Merge branch 'dev' of http://192.168.1.220:10080/Amoy2/wlyy2.0 into dev

business/base-service/src/main/java/com/yihu/jw/patient/service/BasePatientService.java

@@ -2,37 +2,28 @@ package com.yihu.jw.patient.service;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.jw.entity.base.doctor.BaseDoctorDO;
import com.yihu.jw.entity.base.patient.BasePatientDO;
import com.yihu.jw.entity.base.patient.PatientMedicareCardDO;
import com.yihu.jw.entity.hospital.consult.WlyyHospitalSysDictDO;
import com.yihu.jw.entity.hospital.prescription.WlyyInspectionDO;
import com.yihu.jw.entity.hospital.prescription.WlyyOutpatientDO;
import com.yihu.jw.entity.hospital.prescription.WlyyPrescriptionInfoDO;
import com.yihu.jw.healthCare.service.HealthCareNewService;
import com.yihu.jw.healthCare.service.HealthCareService;
import com.yihu.jw.hospital.mapping.dao.PatientMappingDao;
import com.yihu.jw.hospital.prescription.dao.OutpatientDao;
import com.yihu.jw.hospital.prescription.dao.PrescriptionDao;
import com.yihu.jw.hospital.prescription.dao.PrescriptionInfoDao;
import com.yihu.jw.hospital.prescription.dao.WlyyInspectionDao;
import com.yihu.jw.hospital.prescription.service.PrescriptionService;
import com.yihu.jw.hospital.ykyy.service.YkyyService;
import com.yihu.jw.patient.dao.BasePatientDao;
import com.yihu.jw.patient.dao.BasePatientGroupDao;
import com.yihu.jw.patient.dao.BasePatientGroupDictDao;
import com.yihu.jw.patient.util.ConstantUtils;
import com.yihu.jw.restmodel.base.patient.BasePatientVO;
import com.yihu.jw.restmodel.hospital.prescription.WlyyInspectionVO;
import com.yihu.jw.restmodel.hospital.prescription.WlyyPrescriptionInfoVO;
import com.yihu.jw.restmodel.hospital.prescription.WlyyPrescriptionVO;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.MixEnvelop;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.rm.base.BaseRequestMapping;
import com.yihu.jw.rm.iot.IotRequestMapping;
import com.yihu.jw.sms.dao.HospitalSysDictDao;
import com.yihu.jw.util.common.IdCardUtil;
@@ -40,10 +31,8 @@ import com.yihu.jw.utils.hibernate.HibenateUtils;
import com.yihu.mysql.query.BaseJpaService;
import com.yihu.utils.security.MD5;
import org.apache.commons.lang3.StringUtils;
import org.checkerframework.checker.units.qual.A;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.repository.CrudRepository;
@@ -166,7 +155,7 @@ public class BasePatientService<T, R extends CrudRepository> extends BaseJpaServ
     * @param sorts
     * @return
     */
    public MixEnvelop queryPatientBaseInfo(String nameOrIdcard, int page, int size, String sorts)throws Exception{
    public MixEnvelop queryPatientBaseInfo(String nameOrIdcard,String mobile, int page, int size, String sorts)throws Exception{
        List<Map<String, Object>> result = new ArrayList<>();
        String sql = "SELECT\n" +
                "\tID AS \"id\",\n" +
@@ -189,11 +178,12 @@ public class BasePatientService<T, R extends CrudRepository> extends BaseJpaServ
                " street_name \"streetName\"," +
                " address AS \"address\"\n" +
                "FROM\n" +
                "\tbase_patient\n";
                "\tbase_patient where 1=1 ";
        if (StringUtils.isNotEmpty(nameOrIdcard)){
            sql+="WHERE\n" +
                    "\tNAME LIKE '%"+nameOrIdcard+"%'\n" +
                    "OR idcard LIKE '%"+nameOrIdcard+"%'\n";
            sql+=" and NAME LIKE '%"+nameOrIdcard+"%' OR idcard LIKE '%"+nameOrIdcard+"%' ";
        }
        if(StringUtils.isNotBlank(mobile)){
            sql  += " and mobile like '%"+mobile+"%' ";
        }
        /*sql+="ORDER BY\n" +
                "\tcreate_time DESC"*/;

business/sms-service/src/main/java/com/yihu/jw/sms/service/TXYSmsService.java

@@ -47,8 +47,9 @@ public class TXYSmsService {
     * 初始化接口参数
     */
    private void init(){
        if(redisTemplate.hasKey(key+ ":SecretId")){
            SecretId = redisTemplate.opsForValue().get(key + ":SecretId");
        String keyS = ":SecretId1";
        if(redisTemplate.hasKey(key+ keyS)){
            SecretId = redisTemplate.opsForValue().get(key + keyS);
            SecretKey = redisTemplate.opsForValue().get(key + ":SecretKey");
            signName = redisTemplate.opsForValue().get(key + ":signName");
            smsSdkAppId = redisTemplate.opsForValue().get(key + ":smsSdkAppId");
@@ -60,7 +61,7 @@ public class TXYSmsService {
        for (WlyyHospitalSysDictDO wlyyHospitalSysDictDO:dictDOList){
            if (wlyyHospitalSysDictDO.getDictCode().equalsIgnoreCase("SecretId")){
                SecretId=wlyyHospitalSysDictDO.getDictValue();
                redisTemplate.opsForValue().set(key + ":SecretId",SecretId);
                redisTemplate.opsForValue().set(key + keyS,SecretId);
            }else if (wlyyHospitalSysDictDO.getDictCode().equalsIgnoreCase("SecretKey")){
                SecretKey=wlyyHospitalSysDictDO.getDictValue();
                redisTemplate.opsForValue().set(key + ":SecretKey",SecretKey);

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-base/src/main/java/com/yihu/jw/base/endpoint/doctor/BaseDoctorEndpoint.java

@@ -1,14 +1,12 @@
package com.yihu.jw.base.endpoint.doctor;
import com.alibaba.fastjson.JSONObject;
import com.yihu.jw.base.endpoint.common.excel.AExcelReader;
import com.yihu.jw.base.endpoint.common.populationBatchImport.PopulationMsg;
import com.yihu.jw.base.service.doctor.BaseDoctorService;
import com.yihu.jw.base.service.doctor.excelImport.BaseDoctorExcelDO;
import com.yihu.jw.base.service.doctor.excelImport.BaseDoctorExcelDOReader;
import com.yihu.jw.base.service.org.OrgTreeService;
import com.yihu.jw.base.util.ConstantUtils;
import com.yihu.jw.base.util.JavaBeanUtils;
import com.yihu.jw.entity.base.doctor.BaseDoctorDO;
import com.yihu.jw.entity.hospital.consult.WlyyHospitalSysDictDO;
import com.yihu.jw.exception.business.ManageException;
import com.yihu.jw.hospital.dict.WlyyHospitalSysDictDao;
@@ -30,10 +28,12 @@ import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
@@ -41,12 +41,6 @@ import java.io.OutputStream;
import java.util.List;
import java.util.Map;
import com.yihu.jw.entity.base.doctor.BaseDoctorDO;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
 * 医生基础信息控制器
 *
@@ -227,6 +221,8 @@ public class BaseDoctorEndpoint extends EnvelopRestEndpoint {
    public PageEnvelop getDoctorFullInfolist(
            @ApiParam(name = "nameOrIdcard", value = "医生姓名或医生身份证号")
            @RequestParam(value = "nameOrIdcard", required = false) String nameOrIdcard,
            @ApiParam(name = "mobile", value = "身份证")
            @RequestParam(value = "mobile", required = false) String mobile,
            @RequestParam(value = "orgCode", required = false) String orgCode,
            @ApiParam(name = "doctorStatus", value = "医生是否生效")
            @RequestParam(value = "doctorStatus", required = false) String doctorStatus,
@@ -234,7 +230,7 @@ public class BaseDoctorEndpoint extends EnvelopRestEndpoint {
            @RequestParam(value = "page") int page,
            @ApiParam(name = "size", value = "页码", required = true, defaultValue = "15")
            @RequestParam(value = "size") int size) throws Exception {
        JSONObject result = baseDoctorService.queryDoctorListFullInfo(nameOrIdcard,orgCode, doctorStatus,page,size,wechatId);
        JSONObject result = baseDoctorService.queryDoctorListFullInfo(nameOrIdcard,mobile,orgCode, doctorStatus,page,size,wechatId);
        return success(result.getJSONArray("msg"),result.getInteger("count"),page,size);
    }

svr/svr-base/src/main/java/com/yihu/jw/base/endpoint/patient/BasePatientEndpoint.java

@@ -16,7 +16,6 @@ import com.yihu.jw.entity.base.servicePackage.ServicePackageRecordDO;
import com.yihu.jw.entity.base.servicePackage.ServicePackageSignRecordDO;
import com.yihu.jw.entity.base.team.BaseTeamDO;
import com.yihu.jw.entity.care.archive.ArchiveDO;
import com.yihu.jw.entity.care.device.DeviceDetail;
import com.yihu.jw.entity.care.label.WlyyPatientLabelDO;
import com.yihu.jw.patient.dao.BasePatientDao;
import com.yihu.jw.patient.service.BasePatientService;
@@ -24,22 +23,15 @@ import com.yihu.jw.restmodel.base.patient.BasePatientVO;
import com.yihu.jw.restmodel.web.*;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import com.yihu.jw.rm.base.BaseRequestMapping;
import com.yihu.utils.date.DateUtil;
import com.yihu.utils.security.MD5;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import jxl.Sheet;
import jxl.Workbook;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.*;
/**
@@ -183,6 +175,8 @@ public class BasePatientEndpoint extends EnvelopRestEndpoint {
    public MixEnvelop queryPatientBaseInfo(
            @ApiParam(name = "nameOrIdcard", value = "居民姓名或身份证")
            @RequestParam(value = "nameOrIdcard", required = false) String nameOrIdcard,
            @ApiParam(name = "mobile", value = "身份证")
            @RequestParam(value = "mobile", required = false) String mobile,
            @ApiParam(name = "page", value = "分页大小", required = true, defaultValue = "1")
            @RequestParam(value = "page") int page,
            @ApiParam(name = "size", value = "页码", required = true, defaultValue = "15")
@@ -190,7 +184,7 @@ public class BasePatientEndpoint extends EnvelopRestEndpoint {
            @ApiParam(name = "sorts", value = "排序，规则参见说明文档")
            @RequestParam(value = "sorts", required = false) String sorts) throws Exception {
        return basePatientService.queryPatientBaseInfo(nameOrIdcard, page,size,sorts);
        return basePatientService.queryPatientBaseInfo(nameOrIdcard,mobile, page,size,sorts);
    }

svr/svr-base/src/main/java/com/yihu/jw/base/endpoint/role/MenuEndpoint.java

@@ -1,6 +1,5 @@
package com.yihu.jw.base.endpoint.role;
import com.alibaba.fastjson.JSON;
import com.yihu.jw.base.contant.CommonContant;
import com.yihu.jw.base.service.role.MenuService;
import com.yihu.jw.base.service.role.RoleMenuService;
@@ -345,7 +344,6 @@ public class MenuEndpoint extends EnvelopRestEndpoint {
            @ApiParam(name = "roleId", value = "角色id")
            @RequestParam(value = "roleId", required = false) String roleId) {
        try {
            System.out.println("获取角色登录菜单==>参数：" + roleId);
            List<MenuVO> menuVOs = roleMenuService.findMenuByRoleId(roleId);
            menuVOs.forEach(menuVO -> {
                if (CommonContant.DEFAULT_PARENTID.equals(menuVO.getParentId())) {
@@ -365,7 +363,6 @@ public class MenuEndpoint extends EnvelopRestEndpoint {
            menuVOs = menuVOs.stream()
                    .filter(menu -> CommonContant.DEFAULT_PARENTID.equals(menu.getParentId()))
                    .collect(Collectors.toList());
            System.out.println("结果==>" + JSON.toJSONString(menuVOs));
            return success(menuVOs);
        } catch (Exception e) {
            e.printStackTrace();

svr/svr-base/src/main/java/com/yihu/jw/base/service/doctor/BaseDoctorService.java

@@ -206,56 +206,13 @@ public class BaseDoctorService extends BaseJpaService<BaseDoctorDO, BaseDoctorDa
     * @param docStatus
     * @return
     */
    public JSONObject queryDoctorListFullInfo(String nameOrIdcard, String orgCode, String docStatus, int page, int size,String wechatId) throws Exception {
    public JSONObject queryDoctorListFullInfo(String nameOrIdcard,String mobile, String orgCode, String docStatus, int page, int size,String wechatId) throws Exception {
        JSONObject result = new JSONObject();
        String orgCodeVale = null == orgCode ? "" : orgCode;
        String del = null == docStatus ? "" : docStatus;
        String nameOrIdcardValue = null == nameOrIdcard ? "" : "%" + nameOrIdcard + "%";
        int start = 0 == page ? page++ : (page - 1) * size;
        int end = 0 == size ? 15 : page * size;
//        String sql = "select" +
//                "  tb.id as id," +
//                "  tb.name as name," +
//                "  tb.idcard as idcard,  " +
//                "  tb.sex as sex,  " +
//                "  tb.mobile as mobile,  " +
//                "  GROUP_CONCAT(tb.org SEPARATOR ',') as orgInfo,  " +
//                "  tb.job_title_name as jobTitleName,  " +
//                "  tb.status as status " +
//                "from  " +
//                "  (  " +
//                "    select  " +
//                "     doc.id,  " +
//                "     doc.name,  " +
//                "     doc.idcard,  " +
//                "     case doc.sex when 1 then '男' when 2 then '女' else '未知' end as sex,  " +
//                "     doc.mobile,  " +
//                "     concat(hos.org_name,'/',dept.name,'/',hos.doctor_duty_name) as org,  " +
//                "     doc.job_title_name,  " +
//                "     case doc.del when 0 then '已失效' when 1 then '生效中' end as status,  " +
//                "      doc.create_time  " +
//                "   from  " +
//                "     base_doctor doc,  " +
//                "     base_doctor_hospital hos,  " +
//                "     dict_hospital_dept dept  " +
//                "  where  " +
//                "    doc.id = hos.doctor_code  " +
//                "    and  " +
//                "    hos.org_code = dept.org_code " +
//                "    and " +
//                "    hos.dept_code = dept.code  " +
//                "    and  " +
//                "    ((doc.idcard like '{idcard}' or ''= '{idcard}' ) or (doc.name like '{name}'  or ''= '{name}' )  and (hos.org_code = '{orgCode}' or ''= '{orgCode}') and (doc.del = '{docStatus}' or ''= '{docStatus}'))  " +
//                "  ) tb  " +
//                "GROUP BY tb.id order by tb.create_time desc limit {start},{end} ";
//        String finalSql = sql
//                .replace("{idcard}",nameOrIdcardValue)
//                .replace("{name}",nameOrIdcardValue)
//                .replace("{orgCode}",orgCodeVale)
//                .replace("{docStatus}",del)
//                .replace("{start}",String.valueOf(start))
//                .replace("{end}",String.valueOf(end));
        String sql="SELECT\n" +
                "\ttb.id AS \"id\",\n" +
                "\ttb.idcard AS \"idcard\",\n" +
@@ -311,16 +268,14 @@ public class BaseDoctorService extends BaseJpaService<BaseDoctorDO, BaseDoctorDa
                " base_doctor doc LEFT join base_doctor_hospital hos on doc.id = hos.doctor_code " +
                " LEFT JOIN dict_hospital_dept dept on hos.org_code = dept.org_code" +
                " AND hos.dept_code = dept.code"+
                /*"\tbase_doctor doc,\n" +
                "\tbase_doctor_hospital hos,\n" +
                "\tdict_hospital_dept dept\n" +*/
                " WHERE 1=1";
                /*"\tdoc.id = hos.doctor_code\n" +
                "AND hos.org_code = dept.org_code\n" +
                "AND hos.dept_code = dept.code\n"*/
        if (!StringUtils.isEmpty(nameOrIdcard)){
            sql += " and (doc.idcard LIKE '%"+nameOrIdcard+"%' or doc.name LIKE '%"+nameOrIdcard+"%')";
        }if (!StringUtils.isEmpty(orgCode)){
        }
        if(org.apache.commons.lang3.StringUtils.isNotBlank(mobile)){
            sql  += " and doc.mobile like '%"+mobile+"%' ";
        }
        if (!StringUtils.isEmpty(orgCode)){
            sql += " and hos.org_code = '"+orgCode+"'";
        }
        if (!StringUtils.isEmpty(del)){
@@ -339,65 +294,8 @@ public class BaseDoctorService extends BaseJpaService<BaseDoctorDO, BaseDoctorDa
                "ORDER BY\n" +
                "\ttb.create_time DESC";
//        if ("xm_ykyy_wx".equalsIgnoreCase(wechatId)){
//            sql+=" GROUP BY\n" +
//                    "\ttb. ID,\n" +
//                    "\ttb.idcard,\n" +
//                    "\ttb. NAME,\n" +
//                    "\ttb.sex,\n" +
//                    "\ttb.mobile,\n" +
//                    "\ttb.job_title_name,\n" +
//                    "\ttb.status,\n" +
//                    "  tb.create_time\n" +
//                    "ORDER BY\n" +
//                    "\ttb.create_time DESC";
//        }else {
//            sql+=" GROUP BY\n" +
//                    "\ttb. ID\n" +
//                    "ORDER BY\n" +
//                    "\ttb.create_time DESC";
//        }
        List<Map<String,Object>> list=null;
        list = hibenateUtils.createSQLQuery(sql,page,size);
       /* if ("xm_ykyy_wx".equalsIgnoreCase(wechatId)){
            if (flag){
                sql+=" LIMIT  " + (page - 1) * size + "," + size + "";
                Logger.getAnonymousLogger().info("finalCountSql="+sql);
                list = jdbcTemplate.queryForList(sql);
            }else {
                String oracleSql="SELECT\n" +
                        "\t*\n" +
                        "FROM\n" +
                        "\t(\n" +
                        "\t\tSELECT\n" +
                        "\t\t\tA .*\n" +
                        "\t\tFROM\n" +
                        "\t\t\t(";
                oracleSql+=sql;
                oracleSql+="\t\t\t) A\n" +
                        "\t\tWHERE\n" +
                        "  ROWNUM <="+page*size +
                        "\t) \n" +
                        "WHERE\n" +
                        "\tROWNUM >= "+(page-1)*size;
                Logger.getAnonymousLogger().info("oracleSql="+oracleSql);
                list = jdbcTemplate.queryForList(oracleSql);
            }
        }else {
            sql+=" LIMIT  " + (page - 1) * size + "," + size + "";
            Logger.getAnonymousLogger().info("finalCountSql="+sql);
            list = jdbcTemplate.queryForList(sql);
        }*/
        String countSql = " select " +
                "     COUNT(DISTINCT (doc.id)) as count " +
                "   from " +
@@ -419,7 +317,6 @@ public class BaseDoctorService extends BaseJpaService<BaseDoctorDO, BaseDoctorDa
            countSql += " and doc.del  = '"+del+"'";
        }
//        List<Map<String,Object>> list = jdbcTemplate.queryForList(finalSql);
        Logger.getAnonymousLogger().info("finalCountSql="+countSql);
        int count = jdbcTemplate.queryForObject(countSql,Integer.class);
        List<WlyyHospitalSysDictDO> listDict = wlyyHospitalSysDictDao.findByDictName("doctor_level");
@@ -428,11 +325,6 @@ public class BaseDoctorService extends BaseJpaService<BaseDoctorDO, BaseDoctorDa
            String deptname = map.get("deptname")==null?"":map.get("deptname").toString();
            String doctorDutyName = map.get("doctorDutyName")==null?"":map.get("doctorDutyName").toString();
            map.put("orgInfo",orgname+"/"+deptname+"/"+doctorDutyName);
            /*for (WlyyHospitalSysDictDO wlyyHospitalSysDictDO:listDict){
                if (map.get("doctorlevel").toString().equals(wlyyHospitalSysDictDO.getDictCode())){
                    map.put("levelName",wlyyHospitalSysDictDO.getDictValue());
                }
            }*/
        }
        result.put("count", count);
        result.put("msg", JavaBeanUtils.getInstance().mapListJson(list));

svr/svr-base/src/main/java/com/yihu/jw/base/service/notice/NoticeService.java

@@ -7,7 +7,6 @@ import com.yihu.jw.base.util.delay.DelayService;
import com.yihu.jw.base.util.delay.Notice;
import com.yihu.jw.base.util.delay.OnDelayedListener;
import com.yihu.jw.base.util.delay.RedisLock;
import com.yihu.jw.base.util.threadPool.ThreadPoolUtil;
import com.yihu.jw.entity.base.notice.NoticeDO;
import com.yihu.jw.entity.base.notice.UserNoticeDO;
import com.yihu.jw.entity.base.user.UserDO;

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/service/assistance/EmergencyAssistanceService.java

@@ -147,17 +147,19 @@ public class EmergencyAssistanceService extends BaseJpaService<EmergencyAssistan
     * 获取百度天气
     */
    public JSONObject getBaiduWeather(){
        try {
            String url = "https://api.map.baidu.com/weather/v1/?district_id=330100&data_type=now&ak=0vjnCSReegE7A47a941ohjv9a07ONiMC";
            String response = httpClientUtil.get(url,"UTF-8");
            JSONObject responseObj = JSONObject.parseObject(response);
            if (responseObj.getInteger("status")==0){
                JSONObject now = responseObj.getJSONObject("result").getJSONObject("now");
                return now;
            }
        }catch (Exception e){
            e.printStackTrace();
        }
//        try {
//            String url = "https://api.map.baidu.com/weather/v1/?district_id=330100&data_type=now&ak=0vjnCSReegE7A47a941ohjv9a07ONiMC";
//            String response = httpClientUtil.get(url,"UTF-8");
//            JSONObject responseObj = JSONObject.parseObject(response);
//            if (responseObj!=null&&responseObj.getInteger("status")!=null&&responseObj.getInteger("status")==0){
//                if(responseObj.getJSONObject("result")!=null){
//                    JSONObject now = responseObj.getJSONObject("result").getJSONObject("now");
//                    return now;
//                }
//            }
//        }catch (Exception e){
//            e.printStackTrace();
//        }
        return new JSONObject();
    }

svr/svr-cloud-care/src/main/java/com/yihu/jw/care/util/HttpClientUtilCare.java

@@ -1,12 +1,6 @@
package com.yihu.jw.care.util;
import com.alibaba.fastjson.JSONObject;
import com.yihu.jw.entity.base.dict.BaseExceptionDictDO;
import com.yihu.jw.entity.base.dict.BaseExceptionLogDO;
import com.yihu.jw.entity.base.dict.BaseExceptionServerDictDO;
import com.yihu.jw.util.dao.BaseExceptionDictUtilDao;
import com.yihu.jw.util.dao.BaseExceptionLogUtilDao;
import com.yihu.jw.util.dao.BaseExceptionServerDictUtilDao;
import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
@@ -20,14 +14,10 @@ import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;
@@ -35,7 +25,10 @@ import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
@Component
public class HttpClientUtilCare {
@@ -566,14 +559,24 @@ public class HttpClientUtilCare {
    }
    public  org.springframework.http.HttpEntity<JSONObject> iotAssesTokenPostHttp(String url, MultiValueMap<String, String> params,HttpMethod method){
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        MediaType type = MediaType.parseMediaType(MediaType.APPLICATION_FORM_URLENCODED_VALUE);
        headers.setContentType(type);
        headers.add("Accept", MediaType.APPLICATION_JSON.toString());
        org.springframework.http.HttpEntity<MultiValueMap<String, String>> request = new org.springframework.http.HttpEntity<>(params, headers);
        org.springframework.http.HttpEntity<JSONObject> response = restTemplate.exchange(url, method, request, JSONObject.class);
        return response;
        try {
            RestTemplate restTemplate = new RestTemplate();
            HttpHeaders headers = new HttpHeaders();
            MediaType type = MediaType.parseMediaType(MediaType.APPLICATION_FORM_URLENCODED_VALUE);
            headers.setContentType(type);
            headers.add("Accept", MediaType.APPLICATION_JSON.toString());
            org.springframework.http.HttpEntity<MultiValueMap<String, String>> request = new org.springframework.http.HttpEntity<>(params, headers);
            org.springframework.http.HttpEntity<JSONObject> response = restTemplate.exchange(url, method, request, JSONObject.class);
            return response;
        }catch (Exception e){
            e.printStackTrace();
            JSONObject responseBody = new JSONObject();
            responseBody.put("code",-1);
            responseBody.put("msg","请求失败");
            org.springframework.http.HttpEntity<JSONObject> response = new org.springframework.http.HttpEntity<JSONObject>(responseBody);
            return response;
        }
    }
    /**

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