Merge remote-tracking branch 'origin/dev' into dev

common/common-entity/src/main/java/com/yihu/jw/entity/iot/runcobo/RunCoboUploadData.java

@@ -0,0 +1,1118 @@
package com.yihu.jw.entity.iot.runcobo;
import com.yihu.jw.entity.IdEntityWithCreateTime;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;
/**
 * 云康宝数据上传表-普通测量数据
 * Created by yeshijie on 2025/9/23.
 */
@Entity
@Table(name = "runcobo_upload_data")
public class RunCoboUploadData extends IdEntityWithCreateTime {
    private String sn;//设备序列号
    private Integer createMode;//用于识别该用户是在哪个模式下创建 1默认模式 2局域网模式 3配置服务器 4离线模式 5其他
    private Long timestamp;//测量时间戳(毫秒)
    private String userCode;// 用户标识，具有唯一性
    private Integer gender;//性别：0-⼥，1-男
    private Integer age;//年龄：18 ~ 99
    private Double height;//身高(单位cm)，仅支持1位小数
    private Double weight;//体重(单位kg)，1位小数。该指标有3个等级，分别是 低标准 、 标准 、 超标准
    private Double stdWeightUpper;//标准体重范围值上限(单位kg)，1位小数。大于此值则代表偏高
    private Double stdWeightLower;//标准体重范围值下限(单位kg)，1位小数。小于此值则代表偏低
    private Double bmi;//身体质量指数，1位小数。该指标有4个等级，分别是 偏低 、 标准 、 超标准 、 严重偏高
    private Double stdBMISevere;//超标准bmi范围值下限，1位小数。大于此值则代表严重偏高
    private Double stdBMIUpper;//标准bmi范围值上限，1位小数。大于此值则代表偏高
    private Double stdBMILower;//标准bmi范围值下限，1位小数。小于此值则代表偏低
    private Double sinew;//肌肉量(单位kg)，1位小数。该指标有3个等级，分别是 低标准 、 标准 、 超标准
    private Double stdSinewUpper;//标准肌肉量范围值上限(单位kg)，1位小数。大于此值则代表偏高
    private Double stdSinewLower;//标准肌肉量范围值下限(单位kg)，1位小数。小于此值则代表偏低
    private Double muscle;//骨骼肌(单位kg)，1位小数。该指标有3个等级，分别是 低标准 、 标准 、 超标准
    private Double stdMuscleUpper;//标准骨骼肌范围值上限(单位kg)，1位小数。大于此值则代表偏高
    private Double stdMuscleLower;//标准骨骼肌范围值下限(单位kg)，1位小数。小于此值则代表偏低
    private Double bone;//无机盐(单位kg)，2位小数。该指标有2个等级，分别是 正常 、 缺乏
    private Double stdBoneUpper;//标准无机盐上限(单位kg)，2位小数。大于此值则代表偏高
    private Double stdBoneLower;//标准无机盐下限(单位kg)，2位小数。小于此值则代表缺乏
    private Double water;//水分(单位L)，1位小数。该指标有2个等级，分别是 正常 、 缺乏
    private Double stdWaterUpper;//标准水分上限(单位L)，1位小数。大于此值则代表偏高
    private Double stdWaterLower;//标准水分下限(单位L)，1位小数。小于此值则代表缺乏
    private Double protein;//蛋白质(单位kg)，1位小数。该指标有2个等级，分别是 正常 、 缺乏
    private Double stdProteinUpper;//标准蛋白质上限(单位kg)，1位小数。大于此值则代表偏高
    private Double stdProteinLower;//标准蛋白质下限(单位kg)，1位小数。小于此值则代表缺乏
    private Double bodyfat;//体脂率(单位%)，1位小数。该指标有4个等级，分别是 偏低 、 正常 、 轻度肥胖 、 肥胖
    private Double stdBodyfatSevere;//体脂率肥胖范围值下限(单位%)，1位小数。大于此值则代表肥胖
    private Double stdBodyfatUpper;//标准体脂率范围值上限(单位%)，1位小数。大于此值则代表轻度肥胖
    private Double stdBodyfatLower;//标准体脂率范围值下限(单位%)，1位小数。小于此值则代表偏低
    private Double fat;//脂肪(单位kg)，1位小数。该指标有3个等级，分别是 低标准 、 标准 、 超标准
    private Double stdFatUpper;//标准脂肪范围值上限(单位kg)，1位小数。大于此值则代表偏高
    private Double stdFatLower;//标准脂肪范围值下限(单位kg)，1位小数。小于此值则代表偏低
    private Double lbm;//去脂体重(单位kg)，1位小数。该指标有3个等级，分别是 低标准 、 标准 、 超标准
    private Double stdLbmUpper;//标准去脂体重范围上限(单位kg)，1位小数。大于此值则代表偏高
    private Double stdLbmLower;//标准去脂体重范围值下限(单位kg)，1位小数。小于此值则代表偏低
    private Integer bmr;//基础代谢。该指标有3个等级，分别是低标准 、 标准 、 超标准
    private Integer stdBmrUpper;//标准基础代谢范围值上限。大于此值则代表偏高
    private Integer stdBmrLower;//标准基础代谢范围值下限。小于此值则代表偏低
    private Double subfat;//皮下脂肪率(单位%)，1位小数。该指标有3个等级，分别是 低标准 、 标准 、超标准
    private Double stdSubfatUpper;//标准皮下脂肪率范围值上限(单位%)。大于此值则代表偏高
    private Double stdSubfatLower;//标准皮下脂肪率范围值下限(单位%)。小于此值则代表偏低
    private Integer visfat;//内脏脂肪等级，该指标分为三个级别，分别为 标准 、 超标 、 严重
    private Integer stdVisfatUpper;//标准内脏脂肪范围值上限。大于该值属于超标，小于等于该值处于标准
    private Integer stdVisfatSevere;//内脏脂肪严重超标范围值下限。大于该值属于严重超标，小于等于该值处于超标
    private Integer bodyshape;//体型，1-超体重·虚弱型 2-超体重·肌肉型 3-超体重·肥胖型 4-低体重·虚弱型 5-低体重·肌肉型 6-标准体重·虚弱型 7-标准体重·肥胖型 8-标准体重·肌肉型 9-标准体重·健康型
    private Integer bodyage;//体年龄
    private Double score;//分数，1位小数
    private Double leftArmMuscle;//左上肢肌肉量(单位kg)，1位小数
    private Double leftArmMuscleIdeale;//理想左上肢肌肉量(单位kg)，1位小数
    private Double leftArmMuscleRatio;//左上肢肌肉量与标准值⽐值，1位小数
    private Double stdLeftArmMuscleUpper;// 标准左上肢肌肉量范围值上限(单位kg)，1位小数。大于此值则代表偏高
    private Double stdLeftArmMuscleLower;//标准左上肢肌肉量范围值下限(单位kg)，1位小数。小于此值则代表偏低
    private Double rightArmMuscle;//右上肢肌肉量(单位kg)，1位小数
    private Double rightArmMuscleIdeale;//理想右上肢肌肉量(单位kg)，1位小数
    private Double rightArmMuscleRatio;//右上肢肌肉量与标准值⽐值，1位小数
    private Double stdRightArmMuscleUpper;//标准右上肢肌肉量范围值上限(单位kg)，1位小数。大于此值则代表偏高
    private Double stdRightArmMuscleLower;//标准右上肢肌肉量范围值下限(单位kg)，1位小数。小于此值则代表偏低
    private Double torsoMuscle;//躯干肌肉量(单位kg)，1位小数
    private Double torsoMuscleIdeale;//理想躯干肌肉量(单位kg)，1位小数
    private Double torsoMuscleRatio;//躯干肌肉量与标准值⽐值，1位小数
    private Double stdTorsoMuscleUpper;//标准躯干肌肉量范围值上限(单位kg)，1位小数。大于此值则代表偏高
    private Double stdTorsoMuscleLower;//标准躯干肌肉量范围值下限(单位kg)，1位小数。小于此值则代表偏低
    private Double leftLegMuscle;//左下肢肌肉量(单位kg)，1位小数
    private Double leftLegMuscleIdeale;//理想左下肢肌肉量(单位kg)，1位小数
    private Double leftLegMuscleRatio;//左下肢肌肉量与标准值⽐值，1位小数
    private Double stdLeftLegMuscleUpper;//标准左下肢肌肉量范围值上限(单位kg)，1位小数。大于此值则代表偏高
    private Double stdLeftLegMuscleLower;//标准左下肢肌肉量范围值下限(单位kg)，1位小数。小于此值则代表偏低
    private Double rightLegMuscle;//右下肢肌肉量(单位kg)，1位小数
    private Double rightLegMuscleIdeale;//理想右下肢肌肉量(单位kg)，1位小数
    private Double rightLegMuscleRatio;//右下肢肌肉量与标准值⽐值，1位小数
    private Double stdRightLegMuscleUpper;//标准右下肢肌肉量范围值上限(单位kg)，1位小数。大于此值则代表偏高
    private Double stdRightLegMuscleLower;//标准右下肢肌肉量范围值下限(单位kg)，1位小数。小于此值则代表偏低
    private Double leftArmFat;//左上肢脂肪量(单位kg)，1位小数
    private Double leftArmFatIdeale;//理想左上肢脂肪量(单位kg)，1位小数
    private Double leftArmFatRatio;//左上肢脂肪量与标准值⽐值，1位小数
    private Double stdLeftArmFatUpper;//标准左上肢脂肪量范围值上限(单位kg)，1位小数。大于此值则代表偏高
    private Double stdLeftArmFatLower;//标准左上肢脂肪量范围值下限(单位kg)，1位小数。小于此值则代表偏低
    private Double rightArmFat;//右上肢脂肪量(单位kg)，1位小数
    private Double rightArmFatIdeale;//理想右上肢脂肪量(单位kg)，1位小数
    private Double rightArmFatRatio;//右上肢脂肪量与标准值⽐值，1位小数
    private Double stdRightArmFatUpper;//标准右上肢脂肪量范围值上限(单位kg)，1位小数。大于此值则代表偏高
    private Double stdRightArmFatLower;//标准右上肢脂肪量范围值下限(单位kg)，1位小数。小于此值则代表偏低
    private Double torsoFat;//躯干脂肪量(单位kg)，1位小数
    private Double torsoFatIdeale;//理想躯干脂肪量(单位kg)，1位小数
    private Double torsoFatRatio;//躯干脂肪量与标准值⽐值，1位小数
    private Double stdTorsoFatUpper;//标准躯干脂肪量范围值上限(单位kg)，1位小数。大于此值则代表偏高
    private Double stdTorsoFatLower;//标准躯干脂肪量范围值下限(单位kg)，1位小数。小于此值则代表偏低
    private Double leftLegFat;//左下肢脂肪量(单位kg)，1位小数
    private Double leftLegFatIdeale;//理想左下肢脂肪量(单位kg)，1位小数
    private Double leftLegFatRatio;//左下肢脂肪量与标准值⽐值，1位小数
    private Double stdLeftLegFatUpper;//标准左下肢脂肪量范围值上限(单位kg)，1位小数。大于此值则代表偏高
    private Double stdLeftLegFatLower;//标准左下肢脂肪量范围值下限(单位kg)，1位小数。小于此值则代表偏低
    private Double rightLegFat;//右下肢脂肪量(单位kg)，1位小数
    private Double rightLegFatIdeale;//理想右下肢脂肪量(单位kg)，1位小数
    private Double rightLegFatRatio;//右下肢脂肪量与标准值⽐值，1位小数
    private Double stdRightLegFatUpper;//标准右下肢脂肪量范围值上限(单位kg)，1位小数。大于此值则代表偏高
    private Double stdRightLegFatLower;//标准右下肢脂肪量范围值下限(单位kg)，1位小数。小于此值则代表偏低
    private Double weightControl;//体重控制(单位kg)，1位小数
    private Double fatControl;//体脂控制(单位kg)，1位小数
    private Double sinewControl;//肌肉控制(单位kg)，1位小数
    private Integer armSinewLimbBalance;//上肢肌肉均衡，该指标有三种类型，分别为 1-正常，2-轻度不均，3-重度不均
    private Integer legSinewLimbBalance;//下肢肌肉均衡，该指标有三种类型，分别为 1-正常，2-轻度不均，3-重度不均
    private Integer armLegSinewLimbBalance;//上下肢肌肉均衡，该指标有三种类型，分别为 1-正常，2-轻度不均，3-重度不均
    private Integer armBodyStrength;//上肢身体力量，该指标有三种类型，分别为 1-正常，2-发达，3-不足
    private Integer legBodyStrength;//下肢身体力量，该指标有三种类型，分别为 1-正常，2-发达，3-不足
    private Integer armLegBodyStrength;//上下肢身体力量，该指标有三种类型分别为 1-正常，2-发达，3-不足
    @Column(name = "sn")
    public String getSn() {
        return sn;
    }
    public void setSn(String sn) {
        this.sn = sn;
    }
    @Column(name = "create_mode")
    public Integer getCreateMode() {
        return createMode;
    }
    public void setCreateMode(Integer createMode) {
        this.createMode = createMode;
    }
    @Column(name = "timestamp")
    public Long getTimestamp() {
        return timestamp;
    }
    public void setTimestamp(Long timestamp) {
        this.timestamp = timestamp;
    }
    @Column(name = "user_code")
    public String getUserCode() {
        return userCode;
    }
    public void setUserCode(String userCode) {
        this.userCode = userCode;
    }
    @Column(name = "gender")
    public Integer getGender() {
        return gender;
    }
    public void setGender(Integer gender) {
        this.gender = gender;
    }
    @Column(name = "age")
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Column(name = "height")
    public Double getHeight() {
        return height;
    }
    public void setHeight(Double height) {
        this.height = height;
    }
    @Column(name = "weight")
    public Double getWeight() {
        return weight;
    }
    public void setWeight(Double weight) {
        this.weight = weight;
    }
    @Column(name = "std_weight_upper")
    public Double getStdWeightUpper() {
        return stdWeightUpper;
    }
    public void setStdWeightUpper(Double stdWeightUpper) {
        this.stdWeightUpper = stdWeightUpper;
    }
    @Column(name = "std_weight_lower")
    public Double getStdWeightLower() {
        return stdWeightLower;
    }
    public void setStdWeightLower(Double stdWeightLower) {
        this.stdWeightLower = stdWeightLower;
    }
    @Column(name = "bmi")
    public Double getBmi() {
        return bmi;
    }
    public void setBmi(Double bmi) {
        this.bmi = bmi;
    }
    @Column(name = "std_bmi_severe")
    public Double getStdBMISevere() {
        return stdBMISevere;
    }
    public void setStdBMISevere(Double stdBMISevere) {
        this.stdBMISevere = stdBMISevere;
    }
    @Column(name = "std_bmi_upper")
    public Double getStdBMIUpper() {
        return stdBMIUpper;
    }
    public void setStdBMIUpper(Double stdBMIUpper) {
        this.stdBMIUpper = stdBMIUpper;
    }
    @Column(name = "std_bmi_lower")
    public Double getStdBMILower() {
        return stdBMILower;
    }
    public void setStdBMILower(Double stdBMILower) {
        this.stdBMILower = stdBMILower;
    }
    @Column(name = "sinew")
    public Double getSinew() {
        return sinew;
    }
    public void setSinew(Double sinew) {
        this.sinew = sinew;
    }
    @Column(name = "std_sinew_upper")
    public Double getStdSinewUpper() {
        return stdSinewUpper;
    }
    public void setStdSinewUpper(Double stdSinewUpper) {
        this.stdSinewUpper = stdSinewUpper;
    }
    @Column(name = "std_sinew_lower")
    public Double getStdSinewLower() {
        return stdSinewLower;
    }
    public void setStdSinewLower(Double stdSinewLower) {
        this.stdSinewLower = stdSinewLower;
    }
    @Column(name = "muscle")
    public Double getMuscle() {
        return muscle;
    }
    public void setMuscle(Double muscle) {
        this.muscle = muscle;
    }
    @Column(name = "std_muscle_upper")
    public Double getStdMuscleUpper() {
        return stdMuscleUpper;
    }
    public void setStdMuscleUpper(Double stdMuscleUpper) {
        this.stdMuscleUpper = stdMuscleUpper;
    }
    @Column(name = "std_muscle_lower")
    public Double getStdMuscleLower() {
        return stdMuscleLower;
    }
    public void setStdMuscleLower(Double stdMuscleLower) {
        this.stdMuscleLower = stdMuscleLower;
    }
    @Column(name = "bone")
    public Double getBone() {
        return bone;
    }
    public void setBone(Double bone) {
        this.bone = bone;
    }
    @Column(name = "std_bone_upper")
    public Double getStdBoneUpper() {
        return stdBoneUpper;
    }
    public void setStdBoneUpper(Double stdBoneUpper) {
        this.stdBoneUpper = stdBoneUpper;
    }
    @Column(name = "std_bone_lower")
    public Double getStdBoneLower() {
        return stdBoneLower;
    }
    public void setStdBoneLower(Double stdBoneLower) {
        this.stdBoneLower = stdBoneLower;
    }
    @Column(name = "water")
    public Double getWater() {
        return water;
    }
    public void setWater(Double water) {
        this.water = water;
    }
    @Column(name = "std_water_upper")
    public Double getStdWaterUpper() {
        return stdWaterUpper;
    }
    public void setStdWaterUpper(Double stdWaterUpper) {
        this.stdWaterUpper = stdWaterUpper;
    }
    @Column(name = "std_water_lower")
    public Double getStdWaterLower() {
        return stdWaterLower;
    }
    public void setStdWaterLower(Double stdWaterLower) {
        this.stdWaterLower = stdWaterLower;
    }
    @Column(name = "protein")
    public Double getProtein() {
        return protein;
    }
    public void setProtein(Double protein) {
        this.protein = protein;
    }
    @Column(name = "std_protein_upper")
    public Double getStdProteinUpper() {
        return stdProteinUpper;
    }
    public void setStdProteinUpper(Double stdProteinUpper) {
        this.stdProteinUpper = stdProteinUpper;
    }
    @Column(name = "std_protein_lower")
    public Double getStdProteinLower() {
        return stdProteinLower;
    }
    public void setStdProteinLower(Double stdProteinLower) {
        this.stdProteinLower = stdProteinLower;
    }
    @Column(name = "bodyfat")
    public Double getBodyfat() {
        return bodyfat;
    }
    public void setBodyfat(Double bodyfat) {
        this.bodyfat = bodyfat;
    }
    @Column(name = "std_bodyfat_severe")
    public Double getStdBodyfatSevere() {
        return stdBodyfatSevere;
    }
    public void setStdBodyfatSevere(Double stdBodyfatSevere) {
        this.stdBodyfatSevere = stdBodyfatSevere;
    }
    @Column(name = "std_bodyfat_upper")
    public Double getStdBodyfatUpper() {
        return stdBodyfatUpper;
    }
    public void setStdBodyfatUpper(Double stdBodyfatUpper) {
        this.stdBodyfatUpper = stdBodyfatUpper;
    }
    @Column(name = "std_bodyfat_lower")
    public Double getStdBodyfatLower() {
        return stdBodyfatLower;
    }
    public void setStdBodyfatLower(Double stdBodyfatLower) {
        this.stdBodyfatLower = stdBodyfatLower;
    }
    @Column(name = "fat")
    public Double getFat() {
        return fat;
    }
    public void setFat(Double fat) {
        this.fat = fat;
    }
    @Column(name = "std_fat_upper")
    public Double getStdFatUpper() {
        return stdFatUpper;
    }
    public void setStdFatUpper(Double stdFatUpper) {
        this.stdFatUpper = stdFatUpper;
    }
    @Column(name = "std_fat_lower")
    public Double getStdFatLower() {
        return stdFatLower;
    }
    public void setStdFatLower(Double stdFatLower) {
        this.stdFatLower = stdFatLower;
    }
    @Column(name = "lbm")
    public Double getLbm() {
        return lbm;
    }
    public void setLbm(Double lbm) {
        this.lbm = lbm;
    }
    @Column(name = "std_lbm_upper")
    public Double getStdLbmUpper() {
        return stdLbmUpper;
    }
    public void setStdLbmUpper(Double stdLbmUpper) {
        this.stdLbmUpper = stdLbmUpper;
    }
    @Column(name = "std_lbm_lower")
    public Double getStdLbmLower() {
        return stdLbmLower;
    }
    public void setStdLbmLower(Double stdLbmLower) {
        this.stdLbmLower = stdLbmLower;
    }
    @Column(name = "bmr")
    public Integer getBmr() {
        return bmr;
    }
    public void setBmr(Integer bmr) {
        this.bmr = bmr;
    }
    @Column(name = "std_bmr_upper")
    public Integer getStdBmrUpper() {
        return stdBmrUpper;
    }
    public void setStdBmrUpper(Integer stdBmrUpper) {
        this.stdBmrUpper = stdBmrUpper;
    }
    @Column(name = "std_bmr_lower")
    public Integer getStdBmrLower() {
        return stdBmrLower;
    }
    public void setStdBmrLower(Integer stdBmrLower) {
        this.stdBmrLower = stdBmrLower;
    }
    @Column(name = "subfat")
    public Double getSubfat() {
        return subfat;
    }
    public void setSubfat(Double subfat) {
        this.subfat = subfat;
    }
    @Column(name = "std_subfat_upper")
    public Double getStdSubfatUpper() {
        return stdSubfatUpper;
    }
    public void setStdSubfatUpper(Double stdSubfatUpper) {
        this.stdSubfatUpper = stdSubfatUpper;
    }
    @Column(name = "std_subfat_lower")
    public Double getStdSubfatLower() {
        return stdSubfatLower;
    }
    public void setStdSubfatLower(Double stdSubfatLower) {
        this.stdSubfatLower = stdSubfatLower;
    }
    @Column(name = "visfat")
    public Integer getVisfat() {
        return visfat;
    }
    public void setVisfat(Integer visfat) {
        this.visfat = visfat;
    }
    @Column(name = "std_visfat_upper")
    public Integer getStdVisfatUpper() {
        return stdVisfatUpper;
    }
    public void setStdVisfatUpper(Integer stdVisfatUpper) {
        this.stdVisfatUpper = stdVisfatUpper;
    }
    @Column(name = "std_visfat_severe")
    public Integer getStdVisfatSevere() {
        return stdVisfatSevere;
    }
    public void setStdVisfatSevere(Integer stdVisfatSevere) {
        this.stdVisfatSevere = stdVisfatSevere;
    }
    @Column(name = "bodyshape")
    public Integer getBodyshape() {
        return bodyshape;
    }
    public void setBodyshape(Integer bodyshape) {
        this.bodyshape = bodyshape;
    }
    @Column(name = "bodyage")
    public Integer getBodyage() {
        return bodyage;
    }
    public void setBodyage(Integer bodyage) {
        this.bodyage = bodyage;
    }
    @Column(name = "score")
    public Double getScore() {
        return score;
    }
    public void setScore(Double score) {
        this.score = score;
    }
    @Column(name = "left_arm_muscle")
    public Double getLeftArmMuscle() {
        return leftArmMuscle;
    }
    public void setLeftArmMuscle(Double leftArmMuscle) {
        this.leftArmMuscle = leftArmMuscle;
    }
    @Column(name = "left_arm_muscle_ideale")
    public Double getLeftArmMuscleIdeale() {
        return leftArmMuscleIdeale;
    }
    public void setLeftArmMuscleIdeale(Double leftArmMuscleIdeale) {
        this.leftArmMuscleIdeale = leftArmMuscleIdeale;
    }
    @Column(name = "left_arm_muscle_ratio")
    public Double getLeftArmMuscleRatio() {
        return leftArmMuscleRatio;
    }
    public void setLeftArmMuscleRatio(Double leftArmMuscleRatio) {
        this.leftArmMuscleRatio = leftArmMuscleRatio;
    }
    @Column(name = "std_left_arm_muscle_upper")
    public Double getStdLeftArmMuscleUpper() {
        return stdLeftArmMuscleUpper;
    }
    public void setStdLeftArmMuscleUpper(Double stdLeftArmMuscleUpper) {
        this.stdLeftArmMuscleUpper = stdLeftArmMuscleUpper;
    }
    @Column(name = "std_left_arm_muscle_lower")
    public Double getStdLeftArmMuscleLower() {
        return stdLeftArmMuscleLower;
    }
    public void setStdLeftArmMuscleLower(Double stdLeftArmMuscleLower) {
        this.stdLeftArmMuscleLower = stdLeftArmMuscleLower;
    }
    @Column(name = "right_arm_muscle")
    public Double getRightArmMuscle() {
        return rightArmMuscle;
    }
    public void setRightArmMuscle(Double rightArmMuscle) {
        this.rightArmMuscle = rightArmMuscle;
    }
    @Column(name = "right_arm_muscle_ideale")
    public Double getRightArmMuscleIdeale() {
        return rightArmMuscleIdeale;
    }
    public void setRightArmMuscleIdeale(Double rightArmMuscleIdeale) {
        this.rightArmMuscleIdeale = rightArmMuscleIdeale;
    }
    @Column(name = "right_arm_muscle_ratio")
    public Double getRightArmMuscleRatio() {
        return rightArmMuscleRatio;
    }
    public void setRightArmMuscleRatio(Double rightArmMuscleRatio) {
        this.rightArmMuscleRatio = rightArmMuscleRatio;
    }
    @Column(name = "std_right_arm_muscle_upper")
    public Double getStdRightArmMuscleUpper() {
        return stdRightArmMuscleUpper;
    }
    public void setStdRightArmMuscleUpper(Double stdRightArmMuscleUpper) {
        this.stdRightArmMuscleUpper = stdRightArmMuscleUpper;
    }
    @Column(name = "std_right_arm_muscle_lower")
    public Double getStdRightArmMuscleLower() {
        return stdRightArmMuscleLower;
    }
    public void setStdRightArmMuscleLower(Double stdRightArmMuscleLower) {
        this.stdRightArmMuscleLower = stdRightArmMuscleLower;
    }
    @Column(name = "torso_muscle")
    public Double getTorsoMuscle() {
        return torsoMuscle;
    }
    public void setTorsoMuscle(Double torsoMuscle) {
        this.torsoMuscle = torsoMuscle;
    }
    @Column(name = "torso_muscle_ideale")
    public Double getTorsoMuscleIdeale() {
        return torsoMuscleIdeale;
    }
    public void setTorsoMuscleIdeale(Double torsoMuscleIdeale) {
        this.torsoMuscleIdeale = torsoMuscleIdeale;
    }
    @Column(name = "torso_muscle_ratio")
    public Double getTorsoMuscleRatio() {
        return torsoMuscleRatio;
    }
    public void setTorsoMuscleRatio(Double torsoMuscleRatio) {
        this.torsoMuscleRatio = torsoMuscleRatio;
    }
    @Column(name = "std_torso_muscle_upper")
    public Double getStdTorsoMuscleUpper() {
        return stdTorsoMuscleUpper;
    }
    public void setStdTorsoMuscleUpper(Double stdTorsoMuscleUpper) {
        this.stdTorsoMuscleUpper = stdTorsoMuscleUpper;
    }
    @Column(name = "std_torso_muscle_lower")
    public Double getStdTorsoMuscleLower() {
        return stdTorsoMuscleLower;
    }
    public void setStdTorsoMuscleLower(Double stdTorsoMuscleLower) {
        this.stdTorsoMuscleLower = stdTorsoMuscleLower;
    }
    @Column(name = "left_leg_muscle")
    public Double getLeftLegMuscle() {
        return leftLegMuscle;
    }
    public void setLeftLegMuscle(Double leftLegMuscle) {
        this.leftLegMuscle = leftLegMuscle;
    }
    @Column(name = "left_leg_muscle_ideale")
    public Double getLeftLegMuscleIdeale() {
        return leftLegMuscleIdeale;
    }
    public void setLeftLegMuscleIdeale(Double leftLegMuscleIdeale) {
        this.leftLegMuscleIdeale = leftLegMuscleIdeale;
    }
    @Column(name = "left_leg_muscle_ratio")
    public Double getLeftLegMuscleRatio() {
        return leftLegMuscleRatio;
    }
    public void setLeftLegMuscleRatio(Double leftLegMuscleRatio) {
        this.leftLegMuscleRatio = leftLegMuscleRatio;
    }
    @Column(name = "std_left_leg_muscle_upper")
    public Double getStdLeftLegMuscleUpper() {
        return stdLeftLegMuscleUpper;
    }
    public void setStdLeftLegMuscleUpper(Double stdLeftLegMuscleUpper) {
        this.stdLeftLegMuscleUpper = stdLeftLegMuscleUpper;
    }
    @Column(name = "std_left_leg_muscle_lower")
    public Double getStdLeftLegMuscleLower() {
        return stdLeftLegMuscleLower;
    }
    public void setStdLeftLegMuscleLower(Double stdLeftLegMuscleLower) {
        this.stdLeftLegMuscleLower = stdLeftLegMuscleLower;
    }
    @Column(name = "right_leg_muscle")
    public Double getRightLegMuscle() {
        return rightLegMuscle;
    }
    public void setRightLegMuscle(Double rightLegMuscle) {
        this.rightLegMuscle = rightLegMuscle;
    }
    @Column(name = "right_leg_muscle_ideale")
    public Double getRightLegMuscleIdeale() {
        return rightLegMuscleIdeale;
    }
    public void setRightLegMuscleIdeale(Double rightLegMuscleIdeale) {
        this.rightLegMuscleIdeale = rightLegMuscleIdeale;
    }
    @Column(name = "right_leg_muscle_ratio")
    public Double getRightLegMuscleRatio() {
        return rightLegMuscleRatio;
    }
    public void setRightLegMuscleRatio(Double rightLegMuscleRatio) {
        this.rightLegMuscleRatio = rightLegMuscleRatio;
    }
    @Column(name = "std_right_leg_muscle_upper")
    public Double getStdRightLegMuscleUpper() {
        return stdRightLegMuscleUpper;
    }
    public void setStdRightLegMuscleUpper(Double stdRightLegMuscleUpper) {
        this.stdRightLegMuscleUpper = stdRightLegMuscleUpper;
    }
    @Column(name = "std_right_leg_muscle_lower")
    public Double getStdRightLegMuscleLower() {
        return stdRightLegMuscleLower;
    }
    public void setStdRightLegMuscleLower(Double stdRightLegMuscleLower) {
        this.stdRightLegMuscleLower = stdRightLegMuscleLower;
    }
    @Column(name = "left_arm_fat")
    public Double getLeftArmFat() {
        return leftArmFat;
    }
    public void setLeftArmFat(Double leftArmFat) {
        this.leftArmFat = leftArmFat;
    }
    @Column(name = "left_arm_fat_ideale")
    public Double getLeftArmFatIdeale() {
        return leftArmFatIdeale;
    }
    public void setLeftArmFatIdeale(Double leftArmFatIdeale) {
        this.leftArmFatIdeale = leftArmFatIdeale;
    }
    @Column(name = "left_arm_fat_ratio")
    public Double getLeftArmFatRatio() {
        return leftArmFatRatio;
    }
    public void setLeftArmFatRatio(Double leftArmFatRatio) {
        this.leftArmFatRatio = leftArmFatRatio;
    }
    @Column(name = "std_left_arm_fat_upper")
    public Double getStdLeftArmFatUpper() {
        return stdLeftArmFatUpper;
    }
    public void setStdLeftArmFatUpper(Double stdLeftArmFatUpper) {
        this.stdLeftArmFatUpper = stdLeftArmFatUpper;
    }
    @Column(name = "std_left_arm_fat_lower")
    public Double getStdLeftArmFatLower() {
        return stdLeftArmFatLower;
    }
    public void setStdLeftArmFatLower(Double stdLeftArmFatLower) {
        this.stdLeftArmFatLower = stdLeftArmFatLower;
    }
    @Column(name = "right_arm_fat")
    public Double getRightArmFat() {
        return rightArmFat;
    }
    public void setRightArmFat(Double rightArmFat) {
        this.rightArmFat = rightArmFat;
    }
    @Column(name = "right_arm_fat_ideale")
    public Double getRightArmFatIdeale() {
        return rightArmFatIdeale;
    }
    public void setRightArmFatIdeale(Double rightArmFatIdeale) {
        this.rightArmFatIdeale = rightArmFatIdeale;
    }
    @Column(name = "right_arm_fat_ratio")
    public Double getRightArmFatRatio() {
        return rightArmFatRatio;
    }
    public void setRightArmFatRatio(Double rightArmFatRatio) {
        this.rightArmFatRatio = rightArmFatRatio;
    }
    @Column(name = "std_right_arm_fat_upper")
    public Double getStdRightArmFatUpper() {
        return stdRightArmFatUpper;
    }
    public void setStdRightArmFatUpper(Double stdRightArmFatUpper) {
        this.stdRightArmFatUpper = stdRightArmFatUpper;
    }
    @Column(name = "std_right_arm_fat_lower")
    public Double getStdRightArmFatLower() {
        return stdRightArmFatLower;
    }
    public void setStdRightArmFatLower(Double stdRightArmFatLower) {
        this.stdRightArmFatLower = stdRightArmFatLower;
    }
    @Column(name = "torso_fat")
    public Double getTorsoFat() {
        return torsoFat;
    }
    public void setTorsoFat(Double torsoFat) {
        this.torsoFat = torsoFat;
    }
    @Column(name = "torso_fat_ideale")
    public Double getTorsoFatIdeale() {
        return torsoFatIdeale;
    }
    public void setTorsoFatIdeale(Double torsoFatIdeale) {
        this.torsoFatIdeale = torsoFatIdeale;
    }
    @Column(name = "torso_fat_ratio")
    public Double getTorsoFatRatio() {
        return torsoFatRatio;
    }
    public void setTorsoFatRatio(Double torsoFatRatio) {
        this.torsoFatRatio = torsoFatRatio;
    }
    @Column(name = "std_torso_fat_upper")
    public Double getStdTorsoFatUpper() {
        return stdTorsoFatUpper;
    }
    public void setStdTorsoFatUpper(Double stdTorsoFatUpper) {
        this.stdTorsoFatUpper = stdTorsoFatUpper;
    }
    @Column(name = "std_torso_fat_lower")
    public Double getStdTorsoFatLower() {
        return stdTorsoFatLower;
    }
    public void setStdTorsoFatLower(Double stdTorsoFatLower) {
        this.stdTorsoFatLower = stdTorsoFatLower;
    }
    @Column(name = "left_leg_fat")
    public Double getLeftLegFat() {
        return leftLegFat;
    }
    public void setLeftLegFat(Double leftLegFat) {
        this.leftLegFat = leftLegFat;
    }
    @Column(name = "left_leg_fat_ideale")
    public Double getLeftLegFatIdeale() {
        return leftLegFatIdeale;
    }
    public void setLeftLegFatIdeale(Double leftLegFatIdeale) {
        this.leftLegFatIdeale = leftLegFatIdeale;
    }
    @Column(name = "left_leg_fat_ratio")
    public Double getLeftLegFatRatio() {
        return leftLegFatRatio;
    }
    public void setLeftLegFatRatio(Double leftLegFatRatio) {
        this.leftLegFatRatio = leftLegFatRatio;
    }
    @Column(name = "std_left_leg_fat_upper")
    public Double getStdLeftLegFatUpper() {
        return stdLeftLegFatUpper;
    }
    public void setStdLeftLegFatUpper(Double stdLeftLegFatUpper) {
        this.stdLeftLegFatUpper = stdLeftLegFatUpper;
    }
    @Column(name = "std_left_leg_fat_lower")
    public Double getStdLeftLegFatLower() {
        return stdLeftLegFatLower;
    }
    public void setStdLeftLegFatLower(Double stdLeftLegFatLower) {
        this.stdLeftLegFatLower = stdLeftLegFatLower;
    }
    @Column(name = "right_leg_fat")
    public Double getRightLegFat() {
        return rightLegFat;
    }
    public void setRightLegFat(Double rightLegFat) {
        this.rightLegFat = rightLegFat;
    }
    @Column(name = "right_leg_fat_ideale")
    public Double getRightLegFatIdeale() {
        return rightLegFatIdeale;
    }
    public void setRightLegFatIdeale(Double rightLegFatIdeale) {
        this.rightLegFatIdeale = rightLegFatIdeale;
    }
    @Column(name = "right_leg_fat_ratio")
    public Double getRightLegFatRatio() {
        return rightLegFatRatio;
    }
    public void setRightLegFatRatio(Double rightLegFatRatio) {
        this.rightLegFatRatio = rightLegFatRatio;
    }
    @Column(name = "std_right_leg_fat_upper")
    public Double getStdRightLegFatUpper() {
        return stdRightLegFatUpper;
    }
    public void setStdRightLegFatUpper(Double stdRightLegFatUpper) {
        this.stdRightLegFatUpper = stdRightLegFatUpper;
    }
    @Column(name = "std_right_leg_fat_lower")
    public Double getStdRightLegFatLower() {
        return stdRightLegFatLower;
    }
    public void setStdRightLegFatLower(Double stdRightLegFatLower) {
        this.stdRightLegFatLower = stdRightLegFatLower;
    }
    @Column(name = "weight_control")
    public Double getWeightControl() {
        return weightControl;
    }
    public void setWeightControl(Double weightControl) {
        this.weightControl = weightControl;
    }
    @Column(name = "fat_control")
    public Double getFatControl() {
        return fatControl;
    }
    public void setFatControl(Double fatControl) {
        this.fatControl = fatControl;
    }
    @Column(name = "sinew_control")
    public Double getSinewControl() {
        return sinewControl;
    }
    public void setSinewControl(Double sinewControl) {
        this.sinewControl = sinewControl;
    }
    @Column(name = "arm_sinew_limb_balance")
    public Integer getArmSinewLimbBalance() {
        return armSinewLimbBalance;
    }
    public void setArmSinewLimbBalance(Integer armSinewLimbBalance) {
        this.armSinewLimbBalance = armSinewLimbBalance;
    }
    @Column(name = "leg_sinew_limb_balance")
    public Integer getLegSinewLimbBalance() {
        return legSinewLimbBalance;
    }
    public void setLegSinewLimbBalance(Integer legSinewLimbBalance) {
        this.legSinewLimbBalance = legSinewLimbBalance;
    }
    @Column(name = "arm_leg_sinew_limb_balance")
    public Integer getArmLegSinewLimbBalance() {
        return armLegSinewLimbBalance;
    }
    public void setArmLegSinewLimbBalance(Integer armLegSinewLimbBalance) {
        this.armLegSinewLimbBalance = armLegSinewLimbBalance;
    }
    @Column(name = "arm_body_strength")
    public Integer getArmBodyStrength() {
        return armBodyStrength;
    }
    public void setArmBodyStrength(Integer armBodyStrength) {
        this.armBodyStrength = armBodyStrength;
    }
    @Column(name = "leg_body_strength")
    public Integer getLegBodyStrength() {
        return legBodyStrength;
    }
    public void setLegBodyStrength(Integer legBodyStrength) {
        this.legBodyStrength = legBodyStrength;
    }
    @Column(name = "arm_leg_body_strength")
    public Integer getArmLegBodyStrength() {
        return armLegBodyStrength;
    }
    public void setArmLegBodyStrength(Integer armLegBodyStrength) {
        this.armLegBodyStrength = armLegBodyStrength;
    }
}

common/common-entity/src/main/java/com/yihu/jw/entity/iot/runcobo/RuncoboTeenyUploadData.java

@@ -0,0 +1,1168 @@
package com.yihu.jw.entity.iot.runcobo;
import com.yihu.jw.entity.IdEntityWithCreateTime;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;
/**
 * 云康宝数据上传表-普通测量数据
 * Created by yeshijie on 2025/9/23.
 */
@Entity
@Table(name = "runcobo_teeny_upload_data")
public class RuncoboTeenyUploadData extends IdEntityWithCreateTime{
    private String sn;//设备序列号
    private Integer createMode;//用于识别该用户是在哪个模式下创建 1默认模式 2局域网模式 3配置服务器 4离线模式 5其他
    private Long timestamp;//测量时间戳(毫秒)
    private String userCode;// 用户标识，具有唯一性
    private Integer gender;//性别：0-⼥，1-男
    private Integer age;//年龄：18 ~ 99
    private Double height;//身高(单位cm)，仅支持1位小数
    private Double weight;//体重(单位kg)，1位小数。该指标有3个等级，分别是 低标准 、 标准 、 超标准
    private Double stdWeight;//标准体重(单位kg)，1位小数
    private Double idealWeight;//理想体重(单位kg)，1位小数
    private Double minWeight;//体重等级区间最小极值，1位小数
    private Double maxWeight;//体重等级区间最大极值，1位小数
    private Double stdWeightLower;//标准体重区间范围值下限，1位小数，大于等于该值为标准
    private Double stdWeightUpper;//体重等级区间最大极值，1位小数，小于等于该值为标准
    private Integer weightIndex;//当前体重值处于的等级区间，1--迟缓、2--标准、3--超前
    private Double bmi;//身体质量指数，1位小数，该指标有5个等级，分别是重度消瘦、轻度消瘦、标准、超重、肥胖
    private Double stdBmi;//标准bmi
    private Double moderateBmi;//重度消瘦区间范围上限，小于等于该值为重度消瘦
    private Double mildBmi;//轻度消瘦区间范围上限，小于等于该值为轻度消瘦
    private Double fatBmi;//超重区间范围下限，大于等于该值为超重
    private Double fatnessBmi;//肥胖区间范围下限，小于等于该值为肥胖
    private Integer bmiIndex;//当前bmi值处于的等级区间，1--重度消瘦、2--轻度消瘦、3--标准、4--超重、5--肥胖
    private Double bodyfat;//体脂率(单位%)，1位小数，该指标有5个等级，分别是低标准、标准、轻度肥胖、中度肥胖、中度肥胖
    private Double stdBodyfat;//标准体脂率(单位%)，1位小数
    private Double lowBodyfat;//低标准区间范围上限，1位小数，小于该值为低标准
    private Double mildBodyfat;//标准区间范围上限，1位小数，小于该值为标准
    private Double moderateBodyfat;//轻度肥胖区间范围上限，1位小数，小于该值为轻度肥胖
    private Double servereBodyfat;//中度肥胖区间范围上限，1位小数，小于该值为中度肥胖
    private Integer bodyfatIndex;//当前体脂率值处于的等级区间，1--低标准、2--标准、3--轻度肥胖、4--重度肥胖、5--重度肥胖
    private Double lbm;//去脂体重(单位kg)，2位小数，该指标有3个等级，分别为不足、标准、充足
    private Double stdLbm;//标准去脂体重(单位kg)，1位小数
    private Double minLbm;//去脂体重等级区间最小极值，1位小数
    private Double maxLbm;//去脂体重等级区间最大极值，1位小数
    private Double stdLbmLower;//标准去脂体重区间范围值下限，1位小数，大于等于该值为标准
    private Double stdLbmUpper;//标准去脂体重区间最大极值，1位小数，小于等于该值为标准
    private Double lbmIndex;//当前去脂体重处于的等级区间，1--不足、2--标准、3--充足
    private Double water;//体水分(单位%)，1位小数，该指标有3个等级，分别为不足、标准、充足
    private Double stdWater;//标准体水分(单位%)，1位小数
    private Double minWater;//体水分等级区间最小极值，1位小数
    private Double maxWater;//体水分等级区间最大极值，1位小数
    private Double stdWaterLower;//标准体水分区间范围值下限，1位小数，大于等于该值为标准
    private Double stdWaterUpper;//标准体水分区间最大极值，1位小数，小于等于该值为标准
    private Integer waterIndex;//当前体水分处于的等级区间，1--不足、2--标准、3--充足
    private Integer bmr;//基础代谢，该指标有3个等级，分别为低标准、标准、超标准
    private Integer stdBmrLower;//基础代谢标准区间下限，小于该值为低标准
    private Integer stdBmrUpper;//基础代谢标准区间上限，大于该值为超标准
    private Integer bmrIndex;//当前基础代谢处于的等级区间，1--低标准、2--标准、3--超标准
    private Double muscle;//骨骼肌率(单位%)，1位小数，该指标有3个等级，分别为不足、标准、充足
    private Double stdMuscle;//标准骨骼肌率(单位%)，1位小数
    private Double minMuscle;//骨骼肌率等级区间最小极值，1位小数
    private Double maxMuscle;//骨骼肌率等级区间最大极值，1位小数
    private Double stdMuscleLower;//标准骨骼肌率区间范围值下限，1位小数，大于等于该值为标准
    private Double stdMuscleUpper;//标准骨骼肌率区间最大极值，1位小数，小于等于该值为标准
    private Integer muscleIndex;//当前骨骼肌率处于的等级区间，1--不足、2--标准、3--充足
    private Double sinew;//肌肉量(单位kg)，2位小数，该指标有3个等级，分别为不足、标准、充足
    private Double stdSinew;//标准肌肉量(单位kg)，1位小数
    private Double minSinew;//肌肉量等级区间最小极值，1位小数
    private Double maxSinew;//肌肉量等级区间最大极值，1位小数
    private Double stdSinewLower;//标准肌肉量区间范围值下限，1位小数，大于等于该值为标准
    private Double stdSinewUpper;//标准肌肉量区间最大极值，1位小数，小于等于该值为标准
    private Integer sinewIndex;//当前肌肉量处于的等级区间，1--不足、2--标准、3--充足
    private Double bone;//骨量(单位kg)，2位小数，该指标有3个等级，分别为不足、标准、充足
    private Double stdBone;//标准骨量(单位kg)，1位小数
    private Double minBone;//骨量等级区间最小极值，1位小数
    private Double maxBone;//骨量等级区间最大极值，1位小数
    private Double stdBoneLower;//标准骨量区间范围值下限，1位小数，大于等于该值为标准
    private Double stdBoneUpper;//标准骨量区间最大极值，1位小数，小于等于该值为标准
    private Integer boneIndex;//当前骨量处于的等级区间，1--不足、2--标准、3--充足
    private Double protein;//蛋白质(单位%)，1位小数，该指标有3个等级，分别为不足、标准、充足
    private Double stdProtein;//标准蛋白质(单位%)，1位小数
    private Double minProtein;//蛋白质等级区间最小极值，1位小数
    private Double maxProtein;//蛋白质等级区间最大极值，1位小数
    private Double stdProteinLower;//标准蛋白质区间范围值下限，1位小数，大于等于该值为标准
    private Double stdProteinUpper;//标准蛋白质区间最大极值，1位小数，小于等于该值为标准
    private Integer proteinIndex;//当前蛋白质处于的等级区间，1--不足、2--标准、3--充足
    private Double fat;//脂肪(单位kg)，2位小数，该指标有3个等级，分别为不足、标准、充足
    private Double stdFat;//标准脂肪(单位kg)，1位小数
    private Double minFat;//脂肪等级区间最小极值，1位小数
    private Double maxFat;//脂肪等级区间最大极值，1位小数
    private Double stdFatLower;//标准脂肪区间范围值下限，1位小数，大于等于该值为标准
    private Double stdFatUpper;//标准脂肪区间最大极值，1位小数，小于等于该值为标准
    private Integer fatIndex;//当前脂肪处于的等级区间，1--不足、2--标准、3--充足
    private Integer obesity;//肥胖度(单位%)，整数，该指标有4个定级，分别为偏瘦、标准、偏胖、肥胖
    private Integer minObesity;//肥胖度等级区间最小极值
    private Integer maxObesity;//肥胖度等级区间最大极值
    private Integer thinObesity;//偏瘦区间范围值上限，小于该值为偏瘦
    private Integer fatObesity;//标准区间范围值上限，大于该值为偏胖
    private Integer fatnessObesity;//偏胖区间范围值上限，大于该值为肥胖
    private Integer obesityIndex;//当前肥胖度处于的等级区间，1--偏瘦、2--标准、3--偏胖，4--肥胖
    private Double weightControl;//体重控制(单位kg)，2位小数
    private Double fatControl;//体脂控制(单位kg)，2位小数
    private Double sinewControl;//肌肉控制(单位kg)，2位小数
    private Integer bodyshape;//体型，1-消瘦型 2-偏瘦型 3-苗条型 4-苗条肌肉型 5-健康型 6-隐形肥胖型 7-偏胖型 8-肥胖型 9-强壮型 10-肌肉发达型
    private Integer score;//分数
    private Double waterMass;//水分(单位kg)，2位小数，该指标有3个等级，分别为不足、标准、充足
    private Double stdWaterMass;//标准体水分(单位kg)，1位小数
    private Double minWaterMass;//体水分等级区间最小极值，1位小数
    private Double maxWaterMass;//体水分等级区间最大极值，1位小数
    private Double stdWaterMassLower;//标准体水分区间范围值下限，1位小数，大于等于该值为标准
    private Double stdWaterMassUpper;//标准体水分区间最大极值，1位小数，小于等于该值为标准
    private Integer waterMassIndex;//当前体水分处于的等级区间，1--不足、2--标准、3--充足
    private Double proteinMass;//蛋白质(单位kg)，2位小数，该指标有3个等级，分别为不足、标准、充足
    private Double stdProteinMass;//标准蛋白质(单位kg)，1位小数
    private Double minProteinMass;//蛋白质等级区间最小极值，1位小数
    private Double maxProteinMass;//蛋白质等级区间最大极值，1位小数
    private Double stdProteinMassLower;//标准蛋白质区间范围值下限，1位小数，大于等于该值为标准
    private Double stdProteinMassUpper;//标准蛋白质区间最大极值，1位小数，小于等于该值为标准
    private Integer proteinMassIndex;//当前蛋白质处于的等级区间，1--不足、2--标准、3--充足
    private Double muscleMass;//骨骼肌(单位kg)，2位小数，该指标有3个等级，分别为不足、标准、充足
    private Double stdMuscleMass;//标准骨骼肌(单位kg)，1位小数
    private Double minMuscleMass;//骨骼肌等级区间最小极值，1位小数
    private Double maxMuscleMass;//骨骼肌等级区间最大极值，1位小数
    private Double stdMuscleMassLower;//标准骨骼肌区间范围值下限，1位小数，大于等于该值为标准
    private Double stdMuscleMassUpper;//标准骨骼肌区间最大极值，1位小数，小于等于该值为标准
    private Integer muscleMassIndex;//当前骨骼肌处于的等级区间，1--不足、2--标准、3--充足
    @Column(name = "sn")
    public String getSn() {
        return sn;
    }
    public void setSn(String sn) {
        this.sn = sn;
    }
    @Column(name = "create_mode")
    public Integer getCreateMode() {
        return createMode;
    }
    public void setCreateMode(Integer createMode) {
        this.createMode = createMode;
    }
    @Column(name = "timestamp")
    public Long getTimestamp() {
        return timestamp;
    }
    public void setTimestamp(Long timestamp) {
        this.timestamp = timestamp;
    }
    @Column(name = "user_code")
    public String getUserCode() {
        return userCode;
    }
    public void setUserCode(String userCode) {
        this.userCode = userCode;
    }
    @Column(name = "gender")
    public Integer getGender() {
        return gender;
    }
    public void setGender(Integer gender) {
        this.gender = gender;
    }
    @Column(name = "age")
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Column(name = "height")
    public Double getHeight() {
        return height;
    }
    public void setHeight(Double height) {
        this.height = height;
    }
    @Column(name = "weight")
    public Double getWeight() {
        return weight;
    }
    public void setWeight(Double weight) {
        this.weight = weight;
    }
    @Column(name = "std_weight")
    public Double getStdWeight() {
        return stdWeight;
    }
    public void setStdWeight(Double stdWeight) {
        this.stdWeight = stdWeight;
    }
    @Column(name = "ideal_weight")
    public Double getIdealWeight() {
        return idealWeight;
    }
    public void setIdealWeight(Double idealWeight) {
        this.idealWeight = idealWeight;
    }
    @Column(name = "min_weight")
    public Double getMinWeight() {
        return minWeight;
    }
    public void setMinWeight(Double minWeight) {
        this.minWeight = minWeight;
    }
    @Column(name = "max_weight")
    public Double getMaxWeight() {
        return maxWeight;
    }
    public void setMaxWeight(Double maxWeight) {
        this.maxWeight = maxWeight;
    }
    @Column(name = "std_weight_lower")
    public Double getStdWeightLower() {
        return stdWeightLower;
    }
    public void setStdWeightLower(Double stdWeightLower) {
        this.stdWeightLower = stdWeightLower;
    }
    @Column(name = "std_weight_upper")
    public Double getStdWeightUpper() {
        return stdWeightUpper;
    }
    public void setStdWeightUpper(Double stdWeightUpper) {
        this.stdWeightUpper = stdWeightUpper;
    }
    @Column(name = "weight_index")
    public Integer getWeightIndex() {
        return weightIndex;
    }
    public void setWeightIndex(Integer weightIndex) {
        this.weightIndex = weightIndex;
    }
    @Column(name = "bmi")
    public Double getBmi() {
        return bmi;
    }
    public void setBmi(Double bmi) {
        this.bmi = bmi;
    }
    @Column(name = "std_bmi")
    public Double getStdBmi() {
        return stdBmi;
    }
    public void setStdBmi(Double stdBmi) {
        this.stdBmi = stdBmi;
    }
    @Column(name = "moderate_bmi")
    public Double getModerateBmi() {
        return moderateBmi;
    }
    public void setModerateBmi(Double moderateBmi) {
        this.moderateBmi = moderateBmi;
    }
    @Column(name = "mild_bmi")
    public Double getMildBmi() {
        return mildBmi;
    }
    public void setMildBmi(Double mildBmi) {
        this.mildBmi = mildBmi;
    }
    @Column(name = "fat_bmi")
    public Double getFatBmi() {
        return fatBmi;
    }
    public void setFatBmi(Double fatBmi) {
        this.fatBmi = fatBmi;
    }
    @Column(name = "fatness_bmi")
    public Double getFatnessBmi() {
        return fatnessBmi;
    }
    public void setFatnessBmi(Double fatnessBmi) {
        this.fatnessBmi = fatnessBmi;
    }
    @Column(name = "bmi_index")
    public Integer getBmiIndex() {
        return bmiIndex;
    }
    public void setBmiIndex(Integer bmiIndex) {
        this.bmiIndex = bmiIndex;
    }
    @Column(name = "bodyfat")
    public Double getBodyfat() {
        return bodyfat;
    }
    public void setBodyfat(Double bodyfat) {
        this.bodyfat = bodyfat;
    }
    @Column(name = "std_bodyfat")
    public Double getStdBodyfat() {
        return stdBodyfat;
    }
    public void setStdBodyfat(Double stdBodyfat) {
        this.stdBodyfat = stdBodyfat;
    }
    @Column(name = "low_bodyfat")
    public Double getLowBodyfat() {
        return lowBodyfat;
    }
    public void setLowBodyfat(Double lowBodyfat) {
        this.lowBodyfat = lowBodyfat;
    }
    @Column(name = "mild_bodyfat")
    public Double getMildBodyfat() {
        return mildBodyfat;
    }
    public void setMildBodyfat(Double mildBodyfat) {
        this.mildBodyfat = mildBodyfat;
    }
    @Column(name = "moderate_bodyfat")
    public Double getModerateBodyfat() {
        return moderateBodyfat;
    }
    public void setModerateBodyfat(Double moderateBodyfat) {
        this.moderateBodyfat = moderateBodyfat;
    }
    @Column(name = "servere_bodyfat")
    public Double getServereBodyfat() {
        return servereBodyfat;
    }
    public void setServereBodyfat(Double servereBodyfat) {
        this.servereBodyfat = servereBodyfat;
    }
    @Column(name = "bodyfat_index")
    public Integer getBodyfatIndex() {
        return bodyfatIndex;
    }
    public void setBodyfatIndex(Integer bodyfatIndex) {
        this.bodyfatIndex = bodyfatIndex;
    }
    @Column(name = "lbm")
    public Double getLbm() {
        return lbm;
    }
    public void setLbm(Double lbm) {
        this.lbm = lbm;
    }
    @Column(name = "std_lbm")
    public Double getStdLbm() {
        return stdLbm;
    }
    public void setStdLbm(Double stdLbm) {
        this.stdLbm = stdLbm;
    }
    @Column(name = "min_lbm")
    public Double getMinLbm() {
        return minLbm;
    }
    public void setMinLbm(Double minLbm) {
        this.minLbm = minLbm;
    }
    @Column(name = "max_lbm")
    public Double getMaxLbm() {
        return maxLbm;
    }
    public void setMaxLbm(Double maxLbm) {
        this.maxLbm = maxLbm;
    }
    @Column(name = "std_lbm_lower")
    public Double getStdLbmLower() {
        return stdLbmLower;
    }
    public void setStdLbmLower(Double stdLbmLower) {
        this.stdLbmLower = stdLbmLower;
    }
    @Column(name = "std_lbm_upper")
    public Double getStdLbmUpper() {
        return stdLbmUpper;
    }
    public void setStdLbmUpper(Double stdLbmUpper) {
        this.stdLbmUpper = stdLbmUpper;
    }
    @Column(name = "lbm_index")
    public Double getLbmIndex() {
        return lbmIndex;
    }
    public void setLbmIndex(Double lbmIndex) {
        this.lbmIndex = lbmIndex;
    }
    @Column(name = "water")
    public Double getWater() {
        return water;
    }
    public void setWater(Double water) {
        this.water = water;
    }
    @Column(name = "std_water")
    public Double getStdWater() {
        return stdWater;
    }
    public void setStdWater(Double stdWater) {
        this.stdWater = stdWater;
    }
    @Column(name = "min_water")
    public Double getMinWater() {
        return minWater;
    }
    public void setMinWater(Double minWater) {
        this.minWater = minWater;
    }
    @Column(name = "max_water")
    public Double getMaxWater() {
        return maxWater;
    }
    public void setMaxWater(Double maxWater) {
        this.maxWater = maxWater;
    }
    @Column(name = "std_water_lower")
    public Double getStdWaterLower() {
        return stdWaterLower;
    }
    public void setStdWaterLower(Double stdWaterLower) {
        this.stdWaterLower = stdWaterLower;
    }
    @Column(name = "std_water_upper")
    public Double getStdWaterUpper() {
        return stdWaterUpper;
    }
    public void setStdWaterUpper(Double stdWaterUpper) {
        this.stdWaterUpper = stdWaterUpper;
    }
    @Column(name = "water_index")
    public Integer getWaterIndex() {
        return waterIndex;
    }
    public void setWaterIndex(Integer waterIndex) {
        this.waterIndex = waterIndex;
    }
    @Column(name = "bmr")
    public Integer getBmr() {
        return bmr;
    }
    public void setBmr(Integer bmr) {
        this.bmr = bmr;
    }
    @Column(name = "std_bmr_lower")
    public Integer getStdBmrLower() {
        return stdBmrLower;
    }
    public void setStdBmrLower(Integer stdBmrLower) {
        this.stdBmrLower = stdBmrLower;
    }
    @Column(name = "std_bmr_upper")
    public Integer getStdBmrUpper() {
        return stdBmrUpper;
    }
    public void setStdBmrUpper(Integer stdBmrUpper) {
        this.stdBmrUpper = stdBmrUpper;
    }
    @Column(name = "bmr_index")
    public Integer getBmrIndex() {
        return bmrIndex;
    }
    public void setBmrIndex(Integer bmrIndex) {
        this.bmrIndex = bmrIndex;
    }
    @Column(name = "muscle")
    public Double getMuscle() {
        return muscle;
    }
    public void setMuscle(Double muscle) {
        this.muscle = muscle;
    }
    @Column(name = "std_muscle")
    public Double getStdMuscle() {
        return stdMuscle;
    }
    public void setStdMuscle(Double stdMuscle) {
        this.stdMuscle = stdMuscle;
    }
    @Column(name = "min_muscle")
    public Double getMinMuscle() {
        return minMuscle;
    }
    public void setMinMuscle(Double minMuscle) {
        this.minMuscle = minMuscle;
    }
    @Column(name = "max_muscle")
    public Double getMaxMuscle() {
        return maxMuscle;
    }
    public void setMaxMuscle(Double maxMuscle) {
        this.maxMuscle = maxMuscle;
    }
    @Column(name = "std_muscle_lower")
    public Double getStdMuscleLower() {
        return stdMuscleLower;
    }
    public void setStdMuscleLower(Double stdMuscleLower) {
        this.stdMuscleLower = stdMuscleLower;
    }
    @Column(name = "std_muscle_upper")
    public Double getStdMuscleUpper() {
        return stdMuscleUpper;
    }
    public void setStdMuscleUpper(Double stdMuscleUpper) {
        this.stdMuscleUpper = stdMuscleUpper;
    }
    @Column(name = "muscle_index")
    public Integer getMuscleIndex() {
        return muscleIndex;
    }
    public void setMuscleIndex(Integer muscleIndex) {
        this.muscleIndex = muscleIndex;
    }
    @Column(name = "sinew")
    public Double getSinew() {
        return sinew;
    }
    public void setSinew(Double sinew) {
        this.sinew = sinew;
    }
    @Column(name = "std_sinew")
    public Double getStdSinew() {
        return stdSinew;
    }
    public void setStdSinew(Double stdSinew) {
        this.stdSinew = stdSinew;
    }
    @Column(name = "min_sinew")
    public Double getMinSinew() {
        return minSinew;
    }
    public void setMinSinew(Double minSinew) {
        this.minSinew = minSinew;
    }
    @Column(name = "max_sinew")
    public Double getMaxSinew() {
        return maxSinew;
    }
    public void setMaxSinew(Double maxSinew) {
        this.maxSinew = maxSinew;
    }
    @Column(name = "std_sinew_lower")
    public Double getStdSinewLower() {
        return stdSinewLower;
    }
    public void setStdSinewLower(Double stdSinewLower) {
        this.stdSinewLower = stdSinewLower;
    }
    @Column(name = "std_sinew_upper")
    public Double getStdSinewUpper() {
        return stdSinewUpper;
    }
    public void setStdSinewUpper(Double stdSinewUpper) {
        this.stdSinewUpper = stdSinewUpper;
    }
    @Column(name = "sinew_index")
    public Integer getSinewIndex() {
        return sinewIndex;
    }
    public void setSinewIndex(Integer sinewIndex) {
        this.sinewIndex = sinewIndex;
    }
    @Column(name = "bone")
    public Double getBone() {
        return bone;
    }
    public void setBone(Double bone) {
        this.bone = bone;
    }
    @Column(name = "std_bone")
    public Double getStdBone() {
        return stdBone;
    }
    public void setStdBone(Double stdBone) {
        this.stdBone = stdBone;
    }
    @Column(name = "min_bone")
    public Double getMinBone() {
        return minBone;
    }
    public void setMinBone(Double minBone) {
        this.minBone = minBone;
    }
    @Column(name = "max_bone")
    public Double getMaxBone() {
        return maxBone;
    }
    public void setMaxBone(Double maxBone) {
        this.maxBone = maxBone;
    }
    @Column(name = "std_bone_lower")
    public Double getStdBoneLower() {
        return stdBoneLower;
    }
    public void setStdBoneLower(Double stdBoneLower) {
        this.stdBoneLower = stdBoneLower;
    }
    @Column(name = "std_bone_upper")
    public Double getStdBoneUpper() {
        return stdBoneUpper;
    }
    public void setStdBoneUpper(Double stdBoneUpper) {
        this.stdBoneUpper = stdBoneUpper;
    }
    @Column(name = "bone_index")
    public Integer getBoneIndex() {
        return boneIndex;
    }
    public void setBoneIndex(Integer boneIndex) {
        this.boneIndex = boneIndex;
    }
    @Column(name = "protein")
    public Double getProtein() {
        return protein;
    }
    public void setProtein(Double protein) {
        this.protein = protein;
    }
    @Column(name = "std_protein")
    public Double getStdProtein() {
        return stdProtein;
    }
    public void setStdProtein(Double stdProtein) {
        this.stdProtein = stdProtein;
    }
    @Column(name = "min_protein")
    public Double getMinProtein() {
        return minProtein;
    }
    public void setMinProtein(Double minProtein) {
        this.minProtein = minProtein;
    }
    @Column(name = "max_protein")
    public Double getMaxProtein() {
        return maxProtein;
    }
    public void setMaxProtein(Double maxProtein) {
        this.maxProtein = maxProtein;
    }
    @Column(name = "std_protein_lower")
    public Double getStdProteinLower() {
        return stdProteinLower;
    }
    public void setStdProteinLower(Double stdProteinLower) {
        this.stdProteinLower = stdProteinLower;
    }
    @Column(name = "std_protein_upper")
    public Double getStdProteinUpper() {
        return stdProteinUpper;
    }
    public void setStdProteinUpper(Double stdProteinUpper) {
        this.stdProteinUpper = stdProteinUpper;
    }
    @Column(name = "protein_index")
    public Integer getProteinIndex() {
        return proteinIndex;
    }
    public void setProteinIndex(Integer proteinIndex) {
        this.proteinIndex = proteinIndex;
    }
    @Column(name = "fat")
    public Double getFat() {
        return fat;
    }
    public void setFat(Double fat) {
        this.fat = fat;
    }
    @Column(name = "std_fat")
    public Double getStdFat() {
        return stdFat;
    }
    public void setStdFat(Double stdFat) {
        this.stdFat = stdFat;
    }
    @Column(name = "min_fat")
    public Double getMinFat() {
        return minFat;
    }
    public void setMinFat(Double minFat) {
        this.minFat = minFat;
    }
    @Column(name = "max_fat")
    public Double getMaxFat() {
        return maxFat;
    }
    public void setMaxFat(Double maxFat) {
        this.maxFat = maxFat;
    }
    @Column(name = "std_fat_lower")
    public Double getStdFatLower() {
        return stdFatLower;
    }
    public void setStdFatLower(Double stdFatLower) {
        this.stdFatLower = stdFatLower;
    }
    @Column(name = "std_fat_upper")
    public Double getStdFatUpper() {
        return stdFatUpper;
    }
    public void setStdFatUpper(Double stdFatUpper) {
        this.stdFatUpper = stdFatUpper;
    }
    @Column(name = "fat_index")
    public Integer getFatIndex() {
        return fatIndex;
    }
    public void setFatIndex(Integer fatIndex) {
        this.fatIndex = fatIndex;
    }
    @Column(name = "obesity")
    public Integer getObesity() {
        return obesity;
    }
    public void setObesity(Integer obesity) {
        this.obesity = obesity;
    }
    @Column(name = "min_obesity")
    public Integer getMinObesity() {
        return minObesity;
    }
    public void setMinObesity(Integer minObesity) {
        this.minObesity = minObesity;
    }
    @Column(name = "max_obesity")
    public Integer getMaxObesity() {
        return maxObesity;
    }
    public void setMaxObesity(Integer maxObesity) {
        this.maxObesity = maxObesity;
    }
    @Column(name = "thin_obesity")
    public Integer getThinObesity() {
        return thinObesity;
    }
    public void setThinObesity(Integer thinObesity) {
        this.thinObesity = thinObesity;
    }
    @Column(name = "fat_obesity")
    public Integer getFatObesity() {
        return fatObesity;
    }
    public void setFatObesity(Integer fatObesity) {
        this.fatObesity = fatObesity;
    }
    @Column(name = "fatness_obesity")
    public Integer getFatnessObesity() {
        return fatnessObesity;
    }
    public void setFatnessObesity(Integer fatnessObesity) {
        this.fatnessObesity = fatnessObesity;
    }
    @Column(name = "obesity_index")
    public Integer getObesityIndex() {
        return obesityIndex;
    }
    public void setObesityIndex(Integer obesityIndex) {
        this.obesityIndex = obesityIndex;
    }
    @Column(name = "weight_control")
    public Double getWeightControl() {
        return weightControl;
    }
    public void setWeightControl(Double weightControl) {
        this.weightControl = weightControl;
    }
    @Column(name = "fat_control")
    public Double getFatControl() {
        return fatControl;
    }
    public void setFatControl(Double fatControl) {
        this.fatControl = fatControl;
    }
    @Column(name = "sinew_control")
    public Double getSinewControl() {
        return sinewControl;
    }
    public void setSinewControl(Double sinewControl) {
        this.sinewControl = sinewControl;
    }
    @Column(name = "bodyshape")
    public Integer getBodyshape() {
        return bodyshape;
    }
    public void setBodyshape(Integer bodyshape) {
        this.bodyshape = bodyshape;
    }
    @Column(name = "score")
    public Integer getScore() {
        return score;
    }
    public void setScore(Integer score) {
        this.score = score;
    }
    @Column(name = "water_mass")
    public Double getWaterMass() {
        return waterMass;
    }
    public void setWaterMass(Double waterMass) {
        this.waterMass = waterMass;
    }
    @Column(name = "std_water_mass")
    public Double getStdWaterMass() {
        return stdWaterMass;
    }
    public void setStdWaterMass(Double stdWaterMass) {
        this.stdWaterMass = stdWaterMass;
    }
    @Column(name = "min_water_mass")
    public Double getMinWaterMass() {
        return minWaterMass;
    }
    public void setMinWaterMass(Double minWaterMass) {
        this.minWaterMass = minWaterMass;
    }
    @Column(name = "max_water_mass")
    public Double getMaxWaterMass() {
        return maxWaterMass;
    }
    public void setMaxWaterMass(Double maxWaterMass) {
        this.maxWaterMass = maxWaterMass;
    }
    @Column(name = "std_water_mass_lower")
    public Double getStdWaterMassLower() {
        return stdWaterMassLower;
    }
    public void setStdWaterMassLower(Double stdWaterMassLower) {
        this.stdWaterMassLower = stdWaterMassLower;
    }
    @Column(name = "std_water_mass_upper")
    public Double getStdWaterMassUpper() {
        return stdWaterMassUpper;
    }
    public void setStdWaterMassUpper(Double stdWaterMassUpper) {
        this.stdWaterMassUpper = stdWaterMassUpper;
    }
    @Column(name = "water_mass_index")
    public Integer getWaterMassIndex() {
        return waterMassIndex;
    }
    public void setWaterMassIndex(Integer waterMassIndex) {
        this.waterMassIndex = waterMassIndex;
    }
    @Column(name = "protein_mass")
    public Double getProteinMass() {
        return proteinMass;
    }
    public void setProteinMass(Double proteinMass) {
        this.proteinMass = proteinMass;
    }
    @Column(name = "std_protein_mass")
    public Double getStdProteinMass() {
        return stdProteinMass;
    }
    public void setStdProteinMass(Double stdProteinMass) {
        this.stdProteinMass = stdProteinMass;
    }
    @Column(name = "min_protein_mass")
    public Double getMinProteinMass() {
        return minProteinMass;
    }
    public void setMinProteinMass(Double minProteinMass) {
        this.minProteinMass = minProteinMass;
    }
    @Column(name = "max_protein_mass")
    public Double getMaxProteinMass() {
        return maxProteinMass;
    }
    public void setMaxProteinMass(Double maxProteinMass) {
        this.maxProteinMass = maxProteinMass;
    }
    @Column(name = "std_protein_mass_lower")
    public Double getStdProteinMassLower() {
        return stdProteinMassLower;
    }
    public void setStdProteinMassLower(Double stdProteinMassLower) {
        this.stdProteinMassLower = stdProteinMassLower;
    }
    @Column(name = "std_protein_mass_upper")
    public Double getStdProteinMassUpper() {
        return stdProteinMassUpper;
    }
    public void setStdProteinMassUpper(Double stdProteinMassUpper) {
        this.stdProteinMassUpper = stdProteinMassUpper;
    }
    @Column(name = "protein_mass_index")
    public Integer getProteinMassIndex() {
        return proteinMassIndex;
    }
    public void setProteinMassIndex(Integer proteinMassIndex) {
        this.proteinMassIndex = proteinMassIndex;
    }
    @Column(name = "muscle_mass")
    public Double getMuscleMass() {
        return muscleMass;
    }
    public void setMuscleMass(Double muscleMass) {
        this.muscleMass = muscleMass;
    }
    @Column(name = "std_muscle_mass")
    public Double getStdMuscleMass() {
        return stdMuscleMass;
    }
    public void setStdMuscleMass(Double stdMuscleMass) {
        this.stdMuscleMass = stdMuscleMass;
    }
    @Column(name = "min_muscle_mass")
    public Double getMinMuscleMass() {
        return minMuscleMass;
    }
    public void setMinMuscleMass(Double minMuscleMass) {
        this.minMuscleMass = minMuscleMass;
    }
    @Column(name = "max_muscle_mass")
    public Double getMaxMuscleMass() {
        return maxMuscleMass;
    }
    public void setMaxMuscleMass(Double maxMuscleMass) {
        this.maxMuscleMass = maxMuscleMass;
    }
    @Column(name = "std_muscle_mass_lower")
    public Double getStdMuscleMassLower() {
        return stdMuscleMassLower;
    }
    public void setStdMuscleMassLower(Double stdMuscleMassLower) {
        this.stdMuscleMassLower = stdMuscleMassLower;
    }
    @Column(name = "std_muscle_mass_upper")
    public Double getStdMuscleMassUpper() {
        return stdMuscleMassUpper;
    }
    public void setStdMuscleMassUpper(Double stdMuscleMassUpper) {
        this.stdMuscleMassUpper = stdMuscleMassUpper;
    }
    @Column(name = "muscle_mass_index")
    public Integer getMuscleMassIndex() {
        return muscleMassIndex;
    }
    public void setMuscleMassIndex(Integer muscleMassIndex) {
        this.muscleMassIndex = muscleMassIndex;
    }
}

common/common-entity/src/main/java/com/yihu/jw/entity/iot/runcobo/RuncoboUser.java

@@ -0,0 +1,128 @@
package com.yihu.jw.entity.iot.runcobo;
import com.yihu.jw.entity.IdEntityWithCreateTime;
import javax.persistence.*;
/**
 * 云康宝用户表
 * Created by yeshijie on 2025/9/23.
 */
@Entity
@Table(name = "runcobo_user")
public class RuncoboUser extends IdEntityWithCreateTime {
    private String sn;//设备序列号
    private String userCode;//用户标识，具有唯⼀性
    private String accountName;//用户列表
    private Integer gender;//性别：0-⼥，1-男
    private Integer age;//年龄：18 ~ 99
    private Integer heightUnit;//⾝⾼单位，1-cm 2-inch
    private Double height;//⾝⾼(单位cm)，仅⽀持1位⼩数，范围140 ~ 220。对应单位的数值
    private Long updateTimestamp;//用户信息最后更新时间戳
    private Long createTimestamp;//创建用户时间戳
    private Integer createMode;//用于识别该用户是在哪个模式下创建 1默认模式 2局域网模式 3配置服务器 4离线模式 5其他
    private Integer del;//1 正常 0删除
    @Column(name = "sn")
    public String getSn() {
        return sn;
    }
    public void setSn(String sn) {
        this.sn = sn;
    }
    @Column(name = "user_code")
    public String getUserCode() {
        return userCode;
    }
    public void setUserCode(String userCode) {
        this.userCode = userCode;
    }
    @Column(name = "account_name")
    public String getAccountName() {
        return accountName;
    }
    public void setAccountName(String accountName) {
        this.accountName = accountName;
    }
    @Column(name = "gender")
    public Integer getGender() {
        return gender;
    }
    public void setGender(Integer gender) {
        this.gender = gender;
    }
    @Column(name = "age")
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Column(name = "height_unit")
    public Integer getHeightUnit() {
        return heightUnit;
    }
    public void setHeightUnit(Integer heightUnit) {
        this.heightUnit = heightUnit;
    }
    @Column(name = "height", precision = 6)
    public Double getHeight() {
        return height;
    }
    public void setHeight(Double height) {
        this.height = height;
    }
    @Column(name = "update_timestamp")
    public Long getUpdateTimestamp() {
        return updateTimestamp;
    }
    public void setUpdateTimestamp(Long updateTimestamp) {
        this.updateTimestamp = updateTimestamp;
    }
    @Column(name = "create_timestamp")
    public Long getCreateTimestamp() {
        return createTimestamp;
    }
    public void setCreateTimestamp(Long createTimestamp) {
        this.createTimestamp = createTimestamp;
    }
    @Column(name = "create_mode")
    public Integer getCreateMode() {
        return createMode;
    }
    public void setCreateMode(Integer createMode) {
        this.createMode = createMode;
    }
    @Column(name = "del")
    public Integer getDel() {
        return del;
    }
    public void setDel(Integer del) {
        this.del = del;
    }
}

svr/svr-iot/src/main/java/com/yihu/iot/controller/third/DataEnvelop.java

@@ -0,0 +1,82 @@
package com.yihu.iot.controller.third;
import com.fasterxml.jackson.annotation.JsonInclude;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
@JsonInclude(JsonInclude.Include.ALWAYS)
@ApiModel(value = "DataEnvelop", description = "基础实体")
public class DataEnvelop implements Serializable {
    @ApiModelProperty(value = "信息", example = "success")
    protected String msg;
    @ApiModelProperty(value = "API中所描述的 响应参数 组成的JSON字符串经过加密后得到的Base64编码的字符串", example = "data")
    protected String data;
    @ApiModelProperty(value = "状态（200 - 成功)", example = "200")
    protected Integer code = 200;
    public Integer getCode() {
        return code;
    }
    public void setCode(Integer code) {
        this.code = code;
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
    public String getData() {
        return data;
    }
    public void setData(String data) {
        this.data = data;
    }
    public static DataEnvelop getSuccess(String msg) {
        DataEnvelop envelop = new DataEnvelop();
        envelop.setMsg(msg);
        envelop.setCode(200);
        return envelop;
    }
    public static DataEnvelop getSuccess(String msg,String data) {
        DataEnvelop envelop = new DataEnvelop();
        envelop.setMsg(msg);
        envelop.setData(data);
        envelop.setCode(200);
        return envelop;
    }
    public static DataEnvelop getError(String msg, int errorCode) {
        DataEnvelop envelop = new DataEnvelop();
        envelop.setMsg(msg);
        envelop.setCode(errorCode);
        return envelop;
    }
    public static DataEnvelop getError(String msg) {
        DataEnvelop envelop = new DataEnvelop();
        envelop.setMsg(msg);
        envelop.setCode(-1);
        return envelop;
    }
    public static DataEnvelop getError(String msg,String data) {
        DataEnvelop envelop = new DataEnvelop();
        envelop.setMsg(msg);
        envelop.setData(data);
        envelop.setCode(-1);
        return envelop;
    }
}

svr/svr-iot/src/main/java/com/yihu/iot/controller/third/RuncoboController.java

@@ -0,0 +1,151 @@
package com.yihu.iot.controller.third;
import com.alibaba.fastjson.JSONObject;
import com.yihu.iot.datainput.service.RuncoboService;
import com.yihu.jw.util.entity.ServiceException;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
 * 云康宝人体成分分析仪
 * Created by yeshijie on 2025/9/23.
 */
@RestController
@RequestMapping("weixin/runcobo")
@Api(tags = "开放接口-云康宝人体成分分析仪", description = "开放接口-云康宝人体成分分析仪")
public class RuncoboController {
    private static final Logger logger = LoggerFactory.getLogger(RuncoboController.class);
    @Autowired
    private RuncoboService runcoboService;
    @GetMapping(value = "major_scale/v1/test_calibrate")
    @ApiOperation(value = "验证接口", notes = "在设备切换模式⾃定义配置服务器时，发送验证。服务器收到")
    public DataEnvelop test_calibrate(String biz_params){
        try{
            logger.info("test_calibrate:biz_params:"+biz_params);
            String params = runcoboService.decryptStr(biz_params);
            logger.info("test_calibrate:params:"+params);
            return DataEnvelop.getSuccess("验证成功");
        } catch (ServiceException e){
            return DataEnvelop.getError(e.getMessage());
        } catch (Exception e){
            e.printStackTrace();
            return DataEnvelop.getError("验证失败");
        }
    }
    @PostMapping(value = "user/v1/save_user_list")
    @ApiOperation(value = "创建/更新用户信息", notes = "创建/更新用户信息")
    public DataEnvelop save_user_list(String biz_params){
        try{
            logger.info("save_user_list:biz_params:"+biz_params);
            String params = runcoboService.decryptStr(biz_params);
            logger.info("save_user_list:params:"+params);
            JSONObject data = runcoboService.save_user_list(params);
            logger.info("save_user_list:data:"+data.toJSONString());
            return DataEnvelop.getSuccess("成功",runcoboService.encryptStr(data.toJSONString()));
        } catch (ServiceException e){
            return DataEnvelop.getError(e.getMessage());
        } catch (Exception e){
            e.printStackTrace();
            return DataEnvelop.getError("失败");
        }
    }
    @PostMapping(value = "user/v1/delete_user_list")
    @ApiOperation(value = "删除用户", notes = "删除用户")
    public DataEnvelop delete_user_list(String biz_params){
        try{
            logger.info("delete_user_list:biz_params:"+biz_params);
            String params = runcoboService.decryptStr(biz_params);
            logger.info("delete_user_list:params:"+params);
            JSONObject data = runcoboService.delete_user_list(params);
            logger.info("delete_user_list:data:"+data.toJSONString());
            return DataEnvelop.getSuccess("成功",runcoboService.encryptStr(data.toJSONString()));
        } catch (ServiceException e){
            return DataEnvelop.getError(e.getMessage());
        } catch (Exception e){
            e.printStackTrace();
            return DataEnvelop.getError("失败");
        }
    }
    @GetMapping(value = "user/v1/get_from_user_list")
    @ApiOperation(value = "增量获取用户信息列表", notes = "增量获取用户信息列表")
    public DataEnvelop get_from_user_list(String biz_params){
        try{
            logger.info("get_from_user_list:biz_params:"+biz_params);
            String params = runcoboService.decryptStr(biz_params);
            logger.info("get_from_user_list:params:"+params);
            JSONObject data = runcoboService.get_from_user_list(params);
            logger.info("get_from_user_list:data:"+data.toJSONString());
            return DataEnvelop.getSuccess("成功",runcoboService.encryptStr(data.toJSONString()));
        } catch (ServiceException e){
            return DataEnvelop.getError(e.getMessage());
        } catch (Exception e){
            e.printStackTrace();
            return DataEnvelop.getError("验证失败");
        }
    }
    @GetMapping(value = "user/v1/get_from_user_id")
    @ApiOperation(value = "获取单⼀用户信息", notes = "获取单⼀用户信息")
    public DataEnvelop get_from_user_id(String biz_params){
        try{
            logger.info("get_from_user_id:biz_params:"+biz_params);
            String params = runcoboService.decryptStr(biz_params);
            logger.info("get_from_user_id:params:"+params);
            JSONObject data = runcoboService.get_from_user_id(params);
            logger.info("get_from_user_id:data:"+data.toJSONString());
            return DataEnvelop.getSuccess("成功",runcoboService.encryptStr(data.toJSONString()));
        } catch (ServiceException e){
            return DataEnvelop.getError(e.getMessage());
        } catch (Exception e){
            e.printStackTrace();
            return DataEnvelop.getError("验证失败");
        }
    }
    @PostMapping(value = "measurement/v1/upload_data")
    @ApiOperation(value = "批量上传测量数据", notes = "批量上传测量数据")
    public DataEnvelop measurement_upload_data(String biz_params){
        try{
            logger.info("measurement_upload_data:biz_params:"+biz_params);
            String params = runcoboService.decryptStr(biz_params);
            logger.info("measurement_upload_data:params:"+params);
            JSONObject data = runcoboService.measurement_upload_data(params);
            return DataEnvelop.getSuccess("成功",runcoboService.encryptStr(data.toJSONString()));
        } catch (ServiceException e){
            return DataEnvelop.getError(e.getMessage());
        } catch (Exception e){
            e.printStackTrace();
            return DataEnvelop.getError("验证失败");
        }
    }
    @PostMapping(value = "teeny_data/v1/upload_data")
    @ApiOperation(value = "批量上传⻘少年测量数据", notes = "批量上传⻘少年测量数据")
    public DataEnvelop teeny_data_upload_data(String biz_params){
        try{
            logger.info("teeny_data_upload_data:biz_params:"+biz_params);
            String params = runcoboService.decryptStr(biz_params);
            logger.info("teeny_data_upload_data:params:"+params);
            JSONObject data = runcoboService.teeny_data_upload_data(params);
            return DataEnvelop.getSuccess("成功",runcoboService.encryptStr(data.toJSONString()));
        } catch (ServiceException e){
            return DataEnvelop.getError(e.getMessage());
        } catch (Exception e){
            e.printStackTrace();
            return DataEnvelop.getError("验证失败");
        }
    }
}

svr/svr-iot/src/main/java/com/yihu/iot/dao/runcobo/RunCoboUploadDataDao.java

@@ -0,0 +1,12 @@
package com.yihu.iot.dao.runcobo;
import com.yihu.jw.entity.iot.runcobo.RunCoboUploadData;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.PagingAndSortingRepository;
/**
 * Created by yeshijie on 2025/9/23.
 */
public interface RunCoboUploadDataDao extends PagingAndSortingRepository<RunCoboUploadData,Long>,
        JpaSpecificationExecutor<RunCoboUploadData> {
}

svr/svr-iot/src/main/java/com/yihu/iot/dao/runcobo/RuncoboTeenyUploadDataDao.java

@@ -0,0 +1,12 @@
package com.yihu.iot.dao.runcobo;
import com.yihu.jw.entity.iot.runcobo.RuncoboTeenyUploadData;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.PagingAndSortingRepository;
/**
 * Created by yeshijie on 2025/9/24.
 */
public interface RuncoboTeenyUploadDataDao extends PagingAndSortingRepository<RuncoboTeenyUploadData,Long>,
        JpaSpecificationExecutor<RuncoboTeenyUploadData> {
}

svr/svr-iot/src/main/java/com/yihu/iot/dao/runcobo/RuncoboUserDao.java

@@ -0,0 +1,16 @@
package com.yihu.iot.dao.runcobo;
import com.yihu.jw.entity.iot.runcobo.RuncoboUser;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;
/**
 * Created by yeshijie on 2025/9/23.
 */
public interface RuncoboUserDao extends PagingAndSortingRepository<RuncoboUser,Long>,
        JpaSpecificationExecutor<RuncoboUser> {
    @Query("from RuncoboUser w where w.sn=?1 and w.userCode =?2")
    RuncoboUser findByUserCode(String sn,String userCode);
}

svr/svr-iot/src/main/java/com/yihu/iot/datainput/service/RuncoboService.java

@@ -0,0 +1,491 @@
package com.yihu.iot.datainput.service;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.yihu.iot.dao.runcobo.RunCoboUploadDataDao;
import com.yihu.iot.dao.runcobo.RuncoboTeenyUploadDataDao;
import com.yihu.iot.dao.runcobo.RuncoboUserDao;
import com.yihu.iot.datainput.util.AesCbcUtils;
import com.yihu.jw.entity.iot.runcobo.RunCoboUploadData;
import com.yihu.jw.entity.iot.runcobo.RuncoboTeenyUploadData;
import com.yihu.jw.entity.iot.runcobo.RuncoboUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import java.util.*;
/**
 * 云康宝人体成分分析仪(横屏)-API文档_V1.2.1--配置服务器接口
 * Created by yeshijie on 2025/9/23.
 */
@Service
public class RuncoboService {
    public static final String aesKey = "yol202302l6qn133";//我司API对接文档秘钥key
    public static final String aesIv = "yol2023king02160";//偏移量iv
    @Autowired
    private RuncoboTeenyUploadDataDao teenyUploadDataDao;
    @Autowired
    private RuncoboUserDao userDao;
    @Autowired
    private RunCoboUploadDataDao uploadDataDao;
    @Autowired
    private JdbcTemplate jdbcTemplate;
    /**
     * 创建/更新用户信息
     */
    public JSONObject save_user_list(String params){
        JSONObject result = new JSONObject();
        List<String> success_user_code_list = new ArrayList<>();//创建/更新成功的用户标识列表
        List<String> failed_user_code_list = new ArrayList<>();//创建/更新失败的用户标识列表
        try{
            JSONObject jsonObject = JSON.parseObject(params);
            String sn = jsonObject.getString("sn");
            JSONArray user_list = jsonObject.getJSONArray("user_list");
            for (int i=0;i<user_list.size();i++){
                JSONObject user = user_list.getJSONObject(i);
                String user_code = user.getString("user_code");
                try {
                    RuncoboUser u = userDao.findByUserCode(sn,user_code);
                    if(u==null){
                        u = new RuncoboUser();
                        u.setUserCode(user_code);
                        u.setCreateTime(new Date());
                    }
                    u.setDel(1);
                    u.setSn(sn);
                    u.setAccountName(user.getString("account_name"));
                    u.setGender(user.getInteger("gender"));
                    u.setAge(user.getInteger("age"));
                    u.setHeightUnit(user.getInteger("height_unit"));
                    u.setHeight(user.getDouble("height"));
                    u.setUpdateTimestamp(user.getLong("update_timestamp"));
                    u.setCreateTimestamp(user.getLong("create_timestamp"));
                    u.setCreateMode(user.getInteger("create_mode"));
                    userDao.save(u);
                    success_user_code_list.add(user_code);
                }catch (Exception e){
                    e.printStackTrace();
                    failed_user_code_list.add(user_code);
                }
            }
        } catch (Exception e){
            e.printStackTrace();
        }
        result.put("success_user_code_list",success_user_code_list);
        result.put("failed_user_code_list",failed_user_code_list);
        return result;
    }
    /**
     * 删除
     */
    public JSONObject delete_user_list(String params){
        JSONObject result = new JSONObject();
        List<String> success_user_code_list = new ArrayList<>();//创建/更新成功的用户标识列表
        List<String> failed_user_code_list = new ArrayList<>();//创建/更新失败的用户标识列表
        try{
            JSONObject jsonObject = JSON.parseObject(params);
            String sn = jsonObject.getString("sn");
            JSONArray user_code_list = jsonObject.getJSONArray("user_code_list");
            for (int i=0;i<user_code_list.size();i++){
                String user_code = user_code_list.getString(i);
                try {
                    RuncoboUser u = userDao.findByUserCode(sn,user_code);
                    if(u!=null){
                        u.setDel(0);
                        userDao.save(u);
                    }
                    success_user_code_list.add(user_code);
                }catch (Exception e){
                    e.printStackTrace();
                    failed_user_code_list.add(user_code);
                }
            }
        } catch (Exception e){
            e.printStackTrace();
        }
        result.put("success_user_code_list",success_user_code_list);
        result.put("failed_user_code_list",failed_user_code_list);
        return result;
    }
    /**
     * 增量获取用户信息列表
     */
    public JSONObject get_from_user_list(String params){
        JSONObject result = new JSONObject();
        try{
            JSONObject jsonObject = JSON.parseObject(params);
            String sn = jsonObject.getString("sn");
            long last_timestamp = jsonObject.getLong("last_timestamp");//最新时间戳，⾸次获取赋值为0；后续值为服务器下发的
            String sql = "SELECT user_code,account_name,gender,age,height,height_unit,update_timestamp,create_timestamp,create_mode " +
                    " from runcobo_user WHERE sn='"+sn+"' and del=1 ";
            if(last_timestamp>0){
                sql += " and create_timestamp>"+last_timestamp;
            }
            sql += " ORDER BY create_timestamp LIMIT 15 ";
            List<Map<String,Object>> list = jdbcTemplate.queryForList(sql);
            String maxSql = "SELECT ifnull(MAX(create_timestamp),0) from runcobo_user WHERE sn='"+sn+"' and del=1";
            long create_timestamp = jdbcTemplate.queryForObject(maxSql,Long.class);
            int is_complete = 1;//是否下发完成，根据该字段判断是否已下拉完成
            if(list.size()>0){
                long create_timestamp1 = Long.parseLong(list.get(list.size()-1).get("create_timestamp")+"");
                if(create_timestamp1!=create_timestamp){
                    is_complete = 0;
                }
            }
            result.put("last_timestamp",create_timestamp);
            result.put("is_complete",is_complete);
            result.put("user_list",list);
        } catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 获取单一用户信息
     */
    public JSONObject get_from_user_id(String params){
        JSONObject result = new JSONObject();
        try{
            JSONObject jsonObject = JSON.parseObject(params);
            String sn = jsonObject.getString("sn");
            String user_code = jsonObject.getString("user_code");
            String sql = "SELECT user_code,account_name,cast(gender as SIGNED) gender,age,height,height_unit,update_timestamp,create_timestamp,create_mode " +
                    " from runcobo_user WHERE sn='"+sn+"' and user_code='"+user_code+"' ";
            List<Map<String,Object>> list = jdbcTemplate.queryForList(sql);
            if(list.size()>0){
                Map<String,Object> map = list.get(0);
                result.put("user_code",map.get("user_code"));
                result.put("account_name",map.get("account_name"));
                result.put("gender",map.get("gender"));
                result.put("age",map.get("age"));
                result.put("height",map.get("height"));
                result.put("height_unit",map.get("height_unit"));
                result.put("update_timestamp",map.get("update_timestamp"));
                result.put("create_timestamp",map.get("create_timestamp"));
                result.put("create_mode",map.get("create_mode"));
            }
        } catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 批量上传测量数据
     */
    public JSONObject measurement_upload_data(String params){
        JSONObject result = new JSONObject();
        JSONArray success_data_timestamp_list = new JSONArray();//保存成功的数据标识列表
        JSONArray failed_data_timestamp_list = new JSONArray();//保存失败的数据标识列表，需要注意返回失败的数据后续会⼀直重复上传。若需阻抗⽆需保存的数据后续不再重复上传，服务端可在success_data_timestamp_list字段中回复
        try{
            JSONObject jsonObject = JSON.parseObject(params);
            JSONArray measurements = jsonObject.getJSONArray("measurements");
            Date now = new Date();
            for (int i=0;i<measurements.size();i++){
                JSONObject user = measurements.getJSONObject(i);
                String user_code = user.getString("user_code");
                Long timestamp = user.getLong("timestamp");
                JSONObject tmp = new JSONObject();
                tmp.put("user_code",user_code);
                tmp.put("timestamp",timestamp);
                try {
                    RunCoboUploadData uploadData = new RunCoboUploadData();
                    uploadData.setCreateTime(now);
                    uploadData.setSn(user.getString("sn"));// sn Y string 设备序列号
                    uploadData.setCreateMode(user.getInteger("create_mode"));
                    uploadData.setTimestamp(user.getLong("timestamp"));
                    uploadData.setUserCode(user_code);
                    uploadData.setGender(user.getInteger("gender"));
                    uploadData.setAge(user.getInteger("age"));
                    uploadData.setHeight(user.getDouble("height"));
                    uploadData.setWeight(user.getDouble("weight"));
                    uploadData.setStdWeightUpper(user.getDouble("std_weight_upper"));
                    uploadData.setStdWeightLower(user.getDouble("std_weight_lower"));
                    uploadData.setBmi(user.getDouble("bmi"));
                    uploadData.setStdBMISevere(user.getDouble("std_bmi_severe"));
                    uploadData.setStdBMIUpper(user.getDouble("std_bmi_upper"));
                    uploadData.setStdBMILower(user.getDouble("std_bmi_lower"));
                    uploadData.setSinew(user.getDouble("sinew"));
                    uploadData.setStdSinewUpper(user.getDouble("std_sinew_upper"));
                    uploadData.setStdSinewLower(user.getDouble("std_sinew_lower"));
                    uploadData.setMuscle(user.getDouble("muscle"));
                    uploadData.setStdMuscleUpper(user.getDouble("std_muscle_upper"));
                    uploadData.setStdMuscleLower(user.getDouble("std_muscle_lower"));
                    uploadData.setBone(user.getDouble("bone"));
                    uploadData.setStdBoneUpper(user.getDouble("std_bone_upper"));
                    uploadData.setStdBoneLower(user.getDouble("std_bone_lower"));
                    uploadData.setWater(user.getDouble("water"));
                    uploadData.setStdWaterUpper(user.getDouble("std_water_upper"));
                    uploadData.setStdWaterLower(user.getDouble("std_water_lower"));
                    uploadData.setProtein(user.getDouble("protein"));
                    uploadData.setStdProteinUpper(user.getDouble("std_protein_upper"));
                    uploadData.setStdProteinLower(user.getDouble("std_protein_lower"));
                    uploadData.setBodyfat(user.getDouble("bodyfat"));
                    uploadData.setStdBodyfatSevere(user.getDouble("std_bodyfat_severe"));
                    uploadData.setStdBodyfatUpper(user.getDouble("std_bodyfat_upper"));
                    uploadData.setStdBodyfatLower(user.getDouble("std_bodyfat_lower"));
                    uploadData.setFat(user.getDouble("fat"));
                    uploadData.setStdFatUpper(user.getDouble("std_fat_upper"));
                    uploadData.setStdFatLower(user.getDouble("std_fat_lower"));
                    uploadData.setLbm(user.getDouble("lbm"));
                    uploadData.setStdLbmUpper(user.getDouble("std_lbm_upper"));
                    uploadData.setStdLbmLower(user.getDouble("std_lbm_lower"));
                    uploadData.setBmr(user.getInteger("bmr"));
                    uploadData.setStdBmrUpper(user.getInteger("std_bmr_upper"));
                    uploadData.setStdBmrLower(user.getInteger("std_bmr_lower"));
                    uploadData.setSubfat(user.getDouble("subfat"));
                    uploadData.setStdSubfatUpper(user.getDouble("std_subfat_upper"));
                    uploadData.setStdSubfatLower(user.getDouble("std_subfat_lower"));
                    uploadData.setVisfat(user.getInteger("visfat"));
                    uploadData.setStdVisfatUpper(user.getInteger("std_visfat_upper"));
                    uploadData.setStdVisfatSevere(user.getInteger("std_visfat_severe"));
                    uploadData.setBodyshape(user.getInteger("bodyshape"));
                    uploadData.setBodyage(user.getInteger("bodyage"));
                    uploadData.setScore(user.getDouble("score"));
                    uploadData.setLeftArmMuscle(user.getDouble("left_arm_muscle"));
                    uploadData.setLeftArmMuscleIdeale(user.getDouble("left_arm_muscle_ideale"));
                    uploadData.setLeftArmMuscleRatio(user.getDouble("left_arm_muscle_ratio"));
                    uploadData.setStdLeftArmMuscleUpper(user.getDouble("std_left_arm_muscle_upper"));
                    uploadData.setStdLeftArmMuscleLower(user.getDouble("std_left_arm_muscle_lower"));
                    uploadData.setRightArmMuscle(user.getDouble("right_arm_muscle"));
                    uploadData.setRightArmMuscleIdeale(user.getDouble("right_arm_muscle_ideale"));
                    uploadData.setRightArmMuscleRatio(user.getDouble("right_arm_muscle_ratio"));
                    uploadData.setStdRightArmMuscleUpper(user.getDouble("std_right_arm_muscle_upper"));
                    uploadData.setStdRightArmMuscleLower(user.getDouble("std_right_arm_muscle_lower"));
                    uploadData.setTorsoMuscle(user.getDouble("torso_muscle"));
                    uploadData.setTorsoMuscleIdeale(user.getDouble("torso_muscle_ideale"));
                    uploadData.setTorsoMuscleRatio(user.getDouble("torso_muscle_ratio"));
                    uploadData.setStdTorsoMuscleUpper(user.getDouble("std_torso_muscle_upper"));
                    uploadData.setStdTorsoMuscleLower(user.getDouble("std_torso_muscle_lower"));
                    uploadData.setLeftLegMuscle(user.getDouble("left_leg_muscle"));
                    uploadData.setLeftLegMuscleIdeale(user.getDouble("left_leg_muscle_ideale"));
                    uploadData.setLeftLegMuscleRatio(user.getDouble("left_leg_muscle_ratio"));
                    uploadData.setStdLeftLegMuscleUpper(user.getDouble("std_left_leg_muscle_upper"));
                    uploadData.setStdLeftLegMuscleLower(user.getDouble("std_left_leg_muscle_lower"));
                    uploadData.setRightLegMuscle(user.getDouble("right_leg_muscle"));
                    uploadData.setRightLegMuscleIdeale(user.getDouble("right_leg_muscle_ideale"));
                    uploadData.setRightLegMuscleRatio(user.getDouble("right_leg_muscle_ratio"));
                    uploadData.setStdRightLegMuscleUpper(user.getDouble("std_right_leg_muscle_upper"));
                    uploadData.setStdRightLegMuscleLower(user.getDouble("std_right_leg_muscle_lower"));
                    uploadData.setLeftArmFat(user.getDouble("left_arm_fat"));
                    uploadData.setLeftArmFatIdeale(user.getDouble("left_arm_fat_ideale"));
                    uploadData.setLeftArmFatRatio(user.getDouble("left_arm_fat_ratio"));
                    uploadData.setStdLeftArmFatUpper(user.getDouble("std_left_arm_fat_upper"));
                    uploadData.setStdLeftArmFatLower(user.getDouble("std_left_arm_fat_lower"));
                    uploadData.setRightArmFat(user.getDouble("right_arm_fat"));
                    uploadData.setRightArmFatIdeale(user.getDouble("right_arm_fat_ideale"));
                    uploadData.setRightArmFatRatio(user.getDouble("right_arm_fat_ratio"));
                    uploadData.setStdRightArmFatUpper(user.getDouble("std_right_arm_fat_upper"));
                    uploadData.setStdRightArmFatLower(user.getDouble("std_right_arm_fat_lower"));
                    uploadData.setTorsoFat(user.getDouble("torso_fat"));
                    uploadData.setTorsoFatIdeale(user.getDouble("torso_fat_ideale"));
                    uploadData.setTorsoFatRatio(user.getDouble("torso_fat_ratio"));
                    uploadData.setStdTorsoFatUpper(user.getDouble("std_torso_fat_upper"));
                    uploadData.setStdTorsoFatLower(user.getDouble("std_torso_fat_lower"));
                    uploadData.setLeftLegFat(user.getDouble("left_leg_fat"));
                    uploadData.setLeftLegFatIdeale(user.getDouble("left_leg_fat_ideale"));
                    uploadData.setLeftLegFatRatio(user.getDouble("left_leg_fat_ratio"));
                    uploadData.setStdLeftLegFatUpper(user.getDouble("std_left_leg_fat_upper"));
                    uploadData.setStdLeftLegFatLower(user.getDouble("std_left_leg_fat_lower"));
                    uploadData.setRightLegFat(user.getDouble("right_leg_fat"));
                    uploadData.setRightLegFatIdeale(user.getDouble("right_leg_fat_ideale"));
                    uploadData.setRightLegFatRatio(user.getDouble("right_leg_fat_ratio"));
                    uploadData.setStdRightLegFatUpper(user.getDouble("std_right_leg_fat_upper"));
                    uploadData.setStdRightLegFatLower(user.getDouble("std_right_leg_fat_lower"));
                    uploadData.setWeightControl(user.getDouble("weight_control"));
                    uploadData.setFatControl(user.getDouble("fat_control"));
                    uploadData.setSinewControl(user.getDouble("sinew_control"));
                    uploadData.setArmSinewLimbBalance(user.getInteger("arm_sinew_limb_balance"));
                    uploadData.setLegSinewLimbBalance(user.getInteger("leg_sinew_limb_balance"));
                    uploadData.setArmLegSinewLimbBalance(user.getInteger("arm_leg_sinew_limb_balance"));
                    uploadData.setArmBodyStrength(user.getInteger("arm_body_strength"));
                    uploadData.setLegBodyStrength(user.getInteger("leg_body_strength"));
                    uploadData.setArmLegBodyStrength(user.getInteger("arm_leg_body_strength"));
                    uploadDataDao.save(uploadData);
                    success_data_timestamp_list.add(tmp);
                }catch (Exception e){
                    e.printStackTrace();
                    failed_data_timestamp_list.add(tmp);
                }
            }
        } catch (Exception e){
            e.printStackTrace();
        }
        result.put("success_data_timestamp_list",success_data_timestamp_list);
        result.put("failed_data_timestamp_list",failed_data_timestamp_list);
        return result;
    }
    /**
     * 批量上传青少年测量数据
     */
    public JSONObject teeny_data_upload_data(String params){
        JSONObject result = new JSONObject();
        JSONArray success_data_timestamp_list = new JSONArray();//保存成功的数据标识列表
        JSONArray failed_data_timestamp_list = new JSONArray();//保存失败的数据标识列表，需要注意返回失败的数据后续会⼀直重复上传。若需阻抗⽆需保存的数据后续不再重复上传，服务端可在success_data_timestamp_list字段中回复
        try{
            JSONObject jsonObject = JSON.parseObject(params);
            JSONArray measurements = jsonObject.getJSONArray("measurements");
            Date now = new Date();
            for (int i=0;i<measurements.size();i++){
                JSONObject user = measurements.getJSONObject(i);
                String user_code = user.getString("user_code");
                Long timestamp = user.getLong("timestamp");
                JSONObject tmp = new JSONObject();
                tmp.put("user_code",user_code);
                tmp.put("timestamp",timestamp);
                try {
                    RuncoboTeenyUploadData uploadData = new RuncoboTeenyUploadData();
                    uploadData.setCreateTime(now);
                    uploadData.setSn(user.getString("sn"));// sn Y string 设备序列号
                    uploadData.setCreateMode(user.getInteger("create_mode"));
                    uploadData.setTimestamp(user.getLong("timestamp"));
                    uploadData.setUserCode(user_code);
                    uploadData.setGender(user.getInteger("gender"));
                    uploadData.setAge(user.getInteger("age"));
                    uploadData.setHeight(user.getDouble("height"));
                    uploadData.setWeight(user.getDouble("weight"));
                    uploadData.setStdWeight(user.getDouble("std_weight"));
                    uploadData.setIdealWeight(user.getDouble("ideal_weight"));
                    uploadData.setMinWeight(user.getDouble("min_weight"));
                    uploadData.setMaxWeight(user.getDouble("max_weight"));
                    uploadData.setStdWeightLower(user.getDouble("std_weight_lower"));
                    uploadData.setStdWeightUpper(user.getDouble("std_weight_upper"));
                    uploadData.setWaterIndex(user.getInteger("weight_index"));
                    uploadData.setBmi(user.getDouble("bmi"));
                    uploadData.setStdBmi(user.getDouble("std_bmi"));
                    uploadData.setModerateBmi(user.getDouble("moderate_bmi"));
                    uploadData.setMildBmi(user.getDouble("mild_bmi"));
                    uploadData.setFatBmi(user.getDouble("fat_bmi"));
                    uploadData.setFatnessBmi(user.getDouble("fatness_bmi"));
                    uploadData.setBmiIndex(user.getInteger("bmi_index"));
                    uploadData.setBodyfat(user.getDouble("bodyfat"));
                    uploadData.setStdBodyfat(user.getDouble("std_bodyfat"));
                    uploadData.setLowBodyfat(user.getDouble("low_bodyfat"));
                    uploadData.setMildBodyfat(user.getDouble("mild_bodyfat"));
                    uploadData.setModerateBodyfat(user.getDouble("moderate_bodyfat"));
                    uploadData.setServereBodyfat(user.getDouble("servere_bodyfat"));
                    uploadData.setBodyfatIndex(user.getInteger("bodyfat_index"));
                    uploadData.setLbm(user.getDouble("lbm"));
                    uploadData.setStdLbm(user.getDouble("std_lbm"));
                    uploadData.setMinLbm(user.getDouble("min_lbm"));
                    uploadData.setMaxLbm(user.getDouble("max_lbm"));
                    uploadData.setStdLbmLower(user.getDouble("std_lbm_lower"));
                    uploadData.setStdLbmUpper(user.getDouble("std_lbm_upper"));
                    uploadData.setLbmIndex(user.getDouble("lbm_index"));
                    uploadData.setWater(user.getDouble("water"));
                    uploadData.setStdWater(user.getDouble("std_water"));
                    uploadData.setMinWater(user.getDouble("min_water"));
                    uploadData.setMaxWater(user.getDouble("max_water"));
                    uploadData.setStdWaterLower(user.getDouble("std_water_lower"));
                    uploadData.setStdWaterUpper(user.getDouble("std_water_upper"));
                    uploadData.setWaterIndex(user.getInteger("water_index"));
                    uploadData.setBmr(user.getInteger("bmr"));
                    uploadData.setStdBmrLower(user.getInteger("std_bmr_lower"));
                    uploadData.setStdBmrUpper(user.getInteger("std_bmr_upper"));
                    uploadData.setBmrIndex(user.getInteger("bmr_index"));
                    uploadData.setMuscle(user.getDouble("muscle"));
                    uploadData.setStdMuscle(user.getDouble("std_muscle"));
                    uploadData.setMinMuscle(user.getDouble("min_muscle"));
                    uploadData.setMaxMuscle(user.getDouble("max_muscle"));
                    uploadData.setStdMuscleLower(user.getDouble("std_muscle_lower"));
                    uploadData.setStdMuscleUpper(user.getDouble("std_muscle_upper"));
                    uploadData.setMuscleIndex(user.getInteger("muscle_index"));
                    uploadData.setSinew(user.getDouble("sinew"));
                    uploadData.setStdSinew(user.getDouble("std_sinew"));
                    uploadData.setMinSinew(user.getDouble("min_sinew"));
                    uploadData.setMaxSinew(user.getDouble("max_sinew"));
                    uploadData.setStdSinewLower(user.getDouble("std_sinew_lower"));
                    uploadData.setStdSinewUpper(user.getDouble("std_sinew_upper"));
                    uploadData.setSinewIndex(user.getInteger("sinew_index"));
                    uploadData.setBone(user.getDouble("bone"));
                    uploadData.setStdBone(user.getDouble("std_bone"));
                    uploadData.setMinBone(user.getDouble("min_bone"));
                    uploadData.setMaxBone(user.getDouble("max_bone"));
                    uploadData.setStdBoneLower(user.getDouble("std_bone_lower"));
                    uploadData.setStdBoneUpper(user.getDouble("std_bone_upper"));
                    uploadData.setBoneIndex(user.getInteger("bone_index"));
                    uploadData.setProtein(user.getDouble("protein"));
                    uploadData.setStdProtein(user.getDouble("std_protein"));
                    uploadData.setMinProtein(user.getDouble("min_protein"));
                    uploadData.setMaxProtein(user.getDouble("max_protein"));
                    uploadData.setStdProteinLower(user.getDouble("std_protein_lower"));
                    uploadData.setStdProteinUpper(user.getDouble("std_protein_upper"));
                    uploadData.setProteinIndex(user.getInteger("protein_index"));
                    uploadData.setFat(user.getDouble("fat"));
                    uploadData.setStdFat(user.getDouble("std_fat"));
                    uploadData.setMinFat(user.getDouble("min_fat"));
                    uploadData.setMaxFat(user.getDouble("max_fat"));
                    uploadData.setStdFatLower(user.getDouble("std_fat_lower"));
                    uploadData.setStdFatUpper(user.getDouble("std_fat_upper"));
                    uploadData.setFatIndex(user.getInteger("fat_index"));
                    uploadData.setObesity(user.getInteger("obesity"));
                    uploadData.setMinObesity(user.getInteger("min_obesity"));
                    uploadData.setMaxObesity(user.getInteger("max_obesity"));
                    uploadData.setThinObesity(user.getInteger("thin_obesity"));
                    uploadData.setFatObesity(user.getInteger("fat_obesity"));
                    uploadData.setFatnessObesity(user.getInteger("fatness_obesity"));
                    uploadData.setObesityIndex(user.getInteger("obesity_index"));
                    uploadData.setWeightControl(user.getDouble("weight_control"));
                    uploadData.setFatControl(user.getDouble("fat_control"));
                    uploadData.setSinewControl(user.getDouble("sinew_control"));
                    uploadData.setBodyshape(user.getInteger("bodyshape"));
                    uploadData.setScore(user.getInteger("score"));
                    uploadData.setWaterMass(user.getDouble("water_mass"));
                    uploadData.setStdWaterMass(user.getDouble("std_water_mass"));
                    uploadData.setMinWaterMass(user.getDouble("min_water_mass"));
                    uploadData.setMaxWaterMass(user.getDouble("max_water_mass"));
                    uploadData.setStdWaterMassLower(user.getDouble("std_water_mass_lower"));
                    uploadData.setStdWaterMassUpper(user.getDouble("std_water_mass_upper"));
                    uploadData.setWaterIndex(user.getInteger("water_mass_index"));
                    uploadData.setProteinMass(user.getDouble("protein_mass"));
                    uploadData.setStdProteinMass(user.getDouble("std_protein_mass"));
                    uploadData.setMinProteinMass(user.getDouble("min_protein_mass"));
                    uploadData.setMaxProteinMass(user.getDouble("max_protein_mass"));
                    uploadData.setStdProteinMassLower(user.getDouble("std_protein_mass_lower"));
                    uploadData.setStdProteinMassUpper(user.getDouble("std_protein_mass_upper"));
                    uploadData.setProteinMassIndex(user.getInteger("protein_mass_index"));
                    uploadData.setMuscleIndex(user.getInteger("muscle_mass"));
                    uploadData.setStdMuscleMass(user.getDouble("std_muscle_mass"));
                    uploadData.setMinMuscleMass(user.getDouble("min_muscle_mass"));
                    uploadData.setMaxMuscleMass(user.getDouble("max_muscle_mass"));
                    uploadData.setStdMuscleMassLower(user.getDouble("std_muscle_mass_lower"));
                    uploadData.setStdMuscleMassUpper(user.getDouble("std_muscle_mass_upper"));
                    uploadData.setMuscleMassIndex(user.getInteger("muscle_mass_index"));
                    teenyUploadDataDao.save(uploadData);
                    success_data_timestamp_list.add(tmp);
                }catch (Exception e){
                    e.printStackTrace();
                    failed_data_timestamp_list.add(tmp);
                }
            }
        } catch (Exception e){
            e.printStackTrace();
        }
        result.put("success_data_timestamp_list",success_data_timestamp_list);
        result.put("failed_data_timestamp_list",failed_data_timestamp_list);
        return result;
    }
    //加密
    public String encryptStr(String plaintext) throws Exception{
        return AesCbcUtils.encryptStr(plaintext,aesKey,aesIv);
    }
    //解密
    public String decryptStr(String encrypted) throws Exception{
        return AesCbcUtils.decryptStr(encrypted,aesKey,aesIv);
    }
}

svr/svr-iot/src/main/java/com/yihu/iot/datainput/util/AesCbcUtils.java

@@ -0,0 +1,89 @@
package com.yihu.iot.datainput.util;
import com.alibaba.fastjson.JSONObject;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
public class AesCbcUtils {
    private static final String ALGORITHM = "AES";
    private static final String TRANSFORMATION = "AES/CBC/NoPadding";
    private static final int BLOCK_SIZE = 16;
    public static void main(String[] args) throws Exception {
        String key = "yol202302l6qn133";
        String iv = "yol2023king02160";
        JSONObject json = new JSONObject();//get_from_user_id
        json.put("sn","002106");
        json.put("user_code","test");
        String get_from_user_id = "{\"user_code\":\"test\",\"sn\":\"002106\"}";
        String save_user_list = "{\"sn\":\"002106\",\"user_list\":[{\"user_code\":\"test1\",\"gender\":1,\"height_unit\":1,\"update_timestamp\":1,\"create_timestamp\":1,\"account_name\":\"test\",\"create_mode\":1,\"age\":1,\"height\":1.0}]}";
        String delete_user_list = "{\"sn\":\"002106\",\"user_code_list\":[\"test1\"]}";
        String get_from_user_list = "{\"last_timestamp\":0,\"sn\":\"002106\"}";
        String upload_data = "{\"last_timestamp\":0,\"sn\":\"002106\"}";//批量上传
        String teeny_upload_data = "{\"last_timestamp\":0,\"sn\":\"002106\"}";//青少年批量上传
        String plaintext = json.toJSONString();
        // 加密
        byte[] encrypted = encrypt(plaintext, key, iv);
        System.out.println("Encrypted: " + Base64.getEncoder().encodeToString(encrypted));
        System.out.println("Encrypted2: " + encryptStr(get_from_user_list, key, iv));
        // 输出示例: bH0vUu7F6I/zdX2ySgwCiRDw7JbWKjFJDDzLRwIDRH3cr3spwdRnT3dTr8BnrqnL
        // 解密
        String ss = "EnNaR2BBavnCL2ZY1W//lyQJCmniY5c9NiJ31vFt+jz+5HpGLoji3ZD7AUPco+oA";
        String decrypted = decrypt(Base64.getDecoder().decode(ss), key, iv);
        System.out.println("Decrypted: " + decrypted);
        System.out.println("Decrypted2: " + decryptStr(ss,key,iv));
    }
    private static byte[] addZeroPadding(byte[] data) {
        int paddingLength = BLOCK_SIZE - (data.length % BLOCK_SIZE);
        if (paddingLength == BLOCK_SIZE) return data;
        byte[] padded = new byte[data.length + paddingLength];
        System.arraycopy(data, 0, padded, 0, data.length);
        return padded;
    }
    private static byte[] removeZeroPadding(byte[] data) {
        int i = data.length - 1;
        while (i >= 0 && data[i] == 0) i--;
            byte[] unpadded = new byte[i + 1];
            System.arraycopy(data, 0, unpadded, 0, unpadded.length);
            return unpadded;
    }
    public static byte[] encrypt(String plaintext, String key, String ivStr) throws Exception {
        byte[] paddedData = addZeroPadding(plaintext.getBytes());
        SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(), ALGORITHM);
        IvParameterSpec iv = new IvParameterSpec(ivStr.getBytes());
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
        return cipher.doFinal(paddedData);
    }
    public static String decrypt(byte[] encrypted, String key, String ivStr) throws Exception {
        SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(), ALGORITHM);
        IvParameterSpec iv = new IvParameterSpec(ivStr.getBytes());
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
        byte[] decrypted = cipher.doFinal(encrypted);
        byte[] unpadded = removeZeroPadding(decrypted);
        return new String(unpadded, StandardCharsets.UTF_8);
    }
    public static String encryptStr(String plaintext, String key, String ivStr) throws Exception {
        byte[] paddedData = addZeroPadding(plaintext.getBytes());
        SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(), ALGORITHM);
        IvParameterSpec iv = new IvParameterSpec(ivStr.getBytes());
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
        byte[] encrypted = cipher.doFinal(paddedData);
        return Base64.getEncoder().encodeToString(encrypted);
    }
    public static String decryptStr(String encrypted, String key, String ivStr) throws Exception {
        SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(), ALGORITHM);
        IvParameterSpec iv = new IvParameterSpec(ivStr.getBytes());
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
        byte[] decrypted = cipher.doFinal(Base64.getDecoder().decode(encrypted));
        byte[] unpadded = removeZeroPadding(decrypted);
        return new String(unpadded, StandardCharsets.UTF_8);
    }
}