代码修改

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;
    }
}