DateUtils.java 添加获取当月第一天和最后一天的时间 FSExceptionHandler.java 接入处理 ServiceException 修改健康检测

fs-common/src/main/java/com/fs/common/utils/DateUtils.java

@@ -271,4 +271,32 @@ public class DateUtils extends org.apache.commons.lang3.time.DateUtils
         return new SimpleDateFormat("yyyy-MM-dd").format(cal.getTime());
     }
 
+    /**
+     * @Description: yyyy-MM 获取当月的第一天
+     * @Param:
+     * @Return:
+     * @Author xgb
+     * @Date 2025/9/1 14:30
+     */
+    public static Date getStartOfMonth(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        calendar.set(Calendar.DAY_OF_MONTH, 1);
+        return calendar.getTime();
+    }
+
+    /**
+     * @Description: yyyy-MM 获取当月的最后一天
+     * @Param:
+     * @Return:
+     * @Author xgb
+     * @Date 2025/9/1 14:31
+     */
+
+    public static Date getEndOfMonth(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
+        return calendar.getTime();
+    }
 }

fs-company-app/src/main/java/com/fs/app/controller/FsUserHealthDataController.java

@@ -1,18 +1,24 @@
 package com.fs.app.controller;
 
+import cn.hutool.core.text.StrBuilder;
 import com.fs.app.annotation.Login;
 import com.fs.common.core.domain.R;
+import com.fs.common.utils.DateUtils;
 import com.fs.common.utils.StringUtils;
 import com.fs.his.domain.FsUserHealthData;
 import com.fs.his.domain.FsUserInfo;
 import com.fs.his.service.IFsUserHealthDataService;
 import com.fs.his.service.IFsUserInfoService;
+import com.github.pagehelper.PageHelper;
+import com.github.pagehelper.PageInfo;
 import io.swagger.annotations.ApiOperation;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
+
+import java.math.BigDecimal;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 /**
  * 用户身体检测数据Controller
@@ -25,32 +31,86 @@ import org.springframework.web.bind.annotation.RestController;
 public class FsUserHealthDataController extends AppBaseController {
     @Autowired
     private IFsUserHealthDataService fsUserHealthDataService;
-
     @Autowired
     private IFsUserInfoService fsUserInfoService;
 
+
     /**
      * 查询用户身体检测数据列表
      */
-//    @PreAuthorize("@ss.hasPermi('shop:data:list')")
-//    @GetMapping("/list")
-//    public TableDataInfo list(FsUserHealthData fsUserHealthData)
-//    {
-//        startPage();
-//        List<FsUserHealthData> list = fsUserHealthDataService.selectFsUserHealthDataList(fsUserHealthData);
-//        return getDataTable(list);
-//    }
+    @Login
+    @GetMapping("/list")
+    @ApiOperation("获取用户列表信息")
+    public R list(FsUserHealthData fsUserHealthData,
+                  @RequestParam(required = false, defaultValue = "1") Integer pageNum,
+                  @RequestParam(required = false, defaultValue = "1000") Integer pageSize
+                  )
+    {
+        // 时间格式字段处理
+        if(StringUtils.isNotEmpty(fsUserHealthData.getTimeSearch())){
+            Map<String, Object> timeMap = new HashMap<>();
+            // 时间格式处理 2025-01-21 2025-01-01;2025-01-12 2025-01
+            if(fsUserHealthData.getTimeSearch().contains(";")){
+                String[] timeArr = fsUserHealthData.getTimeSearch().split(";");
+                timeMap.put("beginTime", timeArr[0]);
+                timeMap.put("endTime", timeArr[1]);
+            }else if(fsUserHealthData.getTimeSearch().length()==10){
+                fsUserHealthData.setMeasurementDate(DateUtils.parseDate(fsUserHealthData.getTimeSearch()));
+            }else if(fsUserHealthData.getTimeSearch().length()==7){
+                // 按月 取当月第一个和最后一天
+                timeMap.put("beginTime",DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD,DateUtils.getStartOfMonth(DateUtils.parseDate(fsUserHealthData.getTimeSearch()))));
+                timeMap.put("endTime", DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD,DateUtils.getEndOfMonth(DateUtils.parseDate(fsUserHealthData.getTimeSearch()))));
+            }
+            fsUserHealthData.setParams(timeMap);
+        }
+
+
+        List<FsUserHealthData> list = fsUserHealthDataService.selectFsUserHealthDataList(fsUserHealthData);
+
+        Map<String, Object> data=new HashMap<>();
+        data.put("data", new PageInfo<>(list));
+
+
+        // 如果测量类型是空 需要查询各等级（无-0，轻微-1，严重-2） 数量
+        if(fsUserHealthData.getLevel()==null){
+            for(int i=0;i<3;i++){
+                fsUserHealthData.setLevel(i);
+                int num = fsUserHealthDataService.selectFsUserHealthDataListCount(fsUserHealthData);
+                data.put("count"+i, num);
+            }
+        }
+
+
+        return R.ok(data);
+    }
+
 
+    /**
+     * 根据用户ID 查询用户身体检测最新数据
+     */
+    @Login
+    @GetMapping("/latest/info")
+    @ApiOperation("根据用户ID 获取用户身体检测最新数据")
+    public R getInfo(@RequestParam("userId") Long userId,@RequestParam("measurementType") Integer measurementType)
+    {
+        FsUserHealthData fsUserHealthData=new FsUserHealthData();
+        fsUserHealthData.setUserId(userId);
+        fsUserHealthData.setMeasurementType(measurementType);
+        fsUserHealthData = fsUserHealthDataService.selectFsUserHealthDataByUserId(fsUserHealthData);
+        return R.ok().put("data", fsUserHealthData);
+    }
 
     /**
-     * 获取用户身体检测数据详细信息
+     * 根据ID 查询用户身体检测最新数据
      */
-//    @PreAuthorize("@ss.hasPermi('shop:data:query')")
-//    @GetMapping(value = "/{id}")
-//    public AjaxResult getInfo(@PathVariable("id") String id)
-//    {
-//        return AjaxResult.success(fsUserHealthDataService.selectFsUserHealthDataById(id));
-//    }
+    @Login
+    @GetMapping("/info")
+    @ApiOperation("根据ID 获取用户身体检测最新数据")
+    public R getInfoById(@RequestParam("id") Long id)
+    {
+        FsUserHealthData fsUserHealthData = fsUserHealthDataService.selectFsUserHealthDataById(id);
+        return R.ok().put("data", fsUserHealthData);
+    }
 
     /**
      * 新增用户身体检测数据
@@ -59,44 +119,35 @@ public class FsUserHealthDataController extends AppBaseController {
     @PostMapping("/add")
     @ApiOperation("新增用户身体检测数据")
     public R add(@RequestBody FsUserHealthData fsUserHealthData) {
-        // 如果是血酸需要判断是男是女
-        if (fsUserHealthData.getMeasurementType() == 1) {
-            // 根据userId 查询用户信息
-            FsUserInfo user = fsUserInfoService.getById(fsUserHealthData.getUserId());
-            if (StringUtils.isEmpty(user.getSex()) || "2".equals(user.getSex())) {
-                return R.error("请在健康档案中维护性别，以方便判断血酸值是否正常");
-            }
-
-            fsUserHealthData.setSex(user.getSex());
-        }
-        // 计算测量值对应等级
-        int level = fsUserHealthDataService.getHealthIndicatorLevel(fsUserHealthData);
-        fsUserHealthData.setLevel(level);
-        if (fsUserHealthDataService.insertFsUserHealthData(fsUserHealthData) <= 0) {
-            return R.error("新增用户身体检测数据失败");
-        }
+        // 登记检测数据信息
+        fsUserHealthDataService.addHealthData(fsUserHealthData);
         return R.ok();
     }
 
     /**
      * 修改用户身体检测数据
      */
-//    @PreAuthorize("@ss.hasPermi('shop:data:edit')")
-//    @Log(title = "用户身体检测数据", businessType = BusinessType.UPDATE)
-//    @PutMapping
-//    public AjaxResult edit(@RequestBody FsUserHealthData fsUserHealthData)
-//    {
-//        return toAjax(fsUserHealthDataService.updateFsUserHealthData(fsUserHealthData));
-//    }
+    @Login
+    @PostMapping("/update")
+    @ApiOperation("修改用户身体检测数据")
+    public R edit(@RequestBody FsUserHealthData fsUserHealthData)
+    {
+        // 修改检测数据信息
+        fsUserHealthDataService.updateFsUserHealthDataAndLevel(fsUserHealthData);
+        return R.ok();
+    }
 
     /**
      * 删除用户身体检测数据
      */
-//    @PreAuthorize("@ss.hasPermi('shop:data:remove')")
-//    @Log(title = "用户身体检测数据", businessType = BusinessType.DELETE)
-//	@DeleteMapping("/{ids}")
-//    public AjaxResult remove(@PathVariable String[] ids)
-//    {
-//        return toAjax(fsUserHealthDataService.deleteFsUserHealthDataByIds(ids));
-//    }
+    @Login
+	@GetMapping("/delete")
+    @ApiOperation("删除用户身体检测数据")
+    public R remove(@RequestParam Long id)
+    {
+        if(fsUserHealthDataService.deleteFsUserHealthDataById(id)<=0){
+            return R.error("用户身体检测数据删除失败");
+        }
+        return R.ok();
+    }
 }

fs-company-app/src/main/java/com/fs/app/controller/FsUserHealthProfileController.java

@@ -2,14 +2,22 @@ package com.fs.app.controller;
 
 import com.fs.app.annotation.Login;
 import com.fs.common.core.domain.R;
+import com.fs.common.utils.DateUtils;
+import com.fs.his.domain.FsUserHealthData;
 import com.fs.his.domain.FsUserHealthProfile;
+import com.fs.his.domain.FsUserInfo;
+import com.fs.his.dto.FsUserHealthInfoDTO;
 import com.fs.his.service.IFsUserHealthDataService;
 import com.fs.his.service.IFsUserHealthProfileService;
+import com.fs.his.service.IFsUserInfoService;
 import io.swagger.annotations.ApiOperation;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.bind.annotation.*;
 
+import java.util.HashMap;
+import java.util.Map;
+
 /**
  * 用户健康档案Controller
  *
@@ -23,6 +31,8 @@ public class FsUserHealthProfileController extends AppBaseController {
     private IFsUserHealthProfileService fsUserHealthProfileService;
     @Autowired
     private IFsUserHealthDataService fsUserHealthDataService;
+    @Autowired
+    private IFsUserInfoService fsUserInfoService;
 
 
     /**
@@ -36,6 +46,50 @@ public class FsUserHealthProfileController extends AppBaseController {
         return R.ok().put("data", profile);
     }
 
+
+    /**
+     * 获取用户健康档案主页信息
+     */
+    @Login
+    @GetMapping(value = "/home/info")
+    @ApiOperation("获取用户健康档案主页信息")
+    public R getHomeInfo(@RequestParam("userId") Long userId) {
+        FsUserHealthInfoDTO infoDTO = new FsUserHealthInfoDTO();
+        // 查询用户信息
+        FsUserInfo userInfo = fsUserInfoService.selectFsUserInfoById(userId);
+        if (userInfo == null) {
+            return R.error("用户不存在");
+        }
+        infoDTO.setUserId(userId);
+        infoDTO.setUsername(userInfo.getUsername());
+        infoDTO.setAvatar(userInfo.getAvatar());
+        infoDTO.setSex(userInfo.getSex());
+        // 根据生日获取年龄
+        infoDTO.setAge(DateUtils.getAge(userInfo.getBirthdate()));
+
+        // 查询各指标 数据 测量类型（0-腰围，1-臀围，2-血糖，3-血压，4-尿酸 5-BMI）
+        FsUserHealthData query = new FsUserHealthData();
+        query.setUserId(userId);
+        Map<String, Object> dataMap = new HashMap<>();
+        for(int i = 0; i < 6; i++){
+            query.setMeasurementType(i);
+            FsUserHealthData healthData = fsUserHealthDataService.selectFsUserHealthDataByUserId(query);
+            dataMap.put(String.valueOf(i), healthData);
+        }
+        infoDTO.setDataMap(dataMap);
+
+        // 查询健康档案
+        FsUserHealthProfile profile = fsUserHealthProfileService.selectFsUserHealthProfileByUserId(userId);
+        if(profile != null){
+            infoDTO.setSymptomHistory(profile.getSymptomHistory());
+            infoDTO.setOtherMedicalHistory(profile.getOtherMedicalHistory());
+        }
+
+        return R.ok().put("data", infoDTO);
+    }
+
+
+
     /**
      * 新增用户健康档案
      */

fs-company-app/src/main/java/com/fs/app/controller/FsUserInfoController.java

@@ -2,6 +2,7 @@ package com.fs.app.controller;
 
 import com.fs.app.annotation.Login;
 import com.fs.common.core.domain.R;
+import com.fs.common.utils.DateUtils;
 import com.fs.common.utils.StringUtils;
 import com.fs.his.domain.FsUser;
 import com.fs.his.domain.FsUserInfo;
@@ -57,6 +58,11 @@ public class FsUserInfoController extends AppBaseController {
     @ApiOperation("获取用户详情信息")
     public R getInfo(@RequestParam("userId") Long userId) {
         FsUserInfo fsUserInfo = fsUserInfoService.selectFsUserInfoById(userId);
+        if (fsUserInfo == null) {
+            return R.error("用户不存在");
+        }else {
+            fsUserInfo.setAge(DateUtils.getAge(fsUserInfo.getBirthdate()));
+        }
         return R.ok().put("data", fsUserInfo);
     }
 

fs-company-app/src/main/java/com/fs/app/exception/FSExceptionHandler.java

@@ -5,6 +5,7 @@ package com.fs.app.exception;
 
 import com.fs.common.core.domain.R;
 import com.fs.common.exception.CustomException;
+import com.fs.common.exception.ServiceException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.dao.DuplicateKeyException;
@@ -36,6 +37,18 @@ public class FSExceptionHandler {
 		return r;
 	}
 
+	/**
+	 * 处理自定义异常
+	 */
+	@ExceptionHandler(ServiceException.class)
+	public R handleRRException(ServiceException e){
+		R r = new R();
+		r.put("code", e.getCode());
+		r.put("msg", e.getMessage());
+
+		return r;
+	}
+
 	@ExceptionHandler(NoHandlerFoundException.class)
 	public R handlerNoFoundException(Exception e) {
 		logger.error(e.getMessage(), e);

fs-service/src/main/java/com/fs/his/config/HealthIndicatorConfig.java

@@ -42,7 +42,7 @@ public class HealthIndicatorConfig {
     public static final String SYSTOLIC = "systolic";
     public static final String DIASTOLIC = "diastolic";
 
-    // male  男性 female  女性 血酸使用
+    // male  男性 female  女性 尿酸使用
     public static final String MALE = "male";
     public static final String FEMALE = "female";
 

fs-service/src/main/java/com/fs/his/domain/FsUserHealthData.java

@@ -27,7 +27,7 @@ public class FsUserHealthData extends BaseEntity{
     private Long userId;
 
     /** 测量类型（0-腰围，1-臀围，2-血糖，3-血压，4-尿酸 5-BMI） */
-    private int measurementType;
+    private Integer measurementType;
 
     /** 数值1（测量值1 测量值只有一个时默认填写/身高cm/舒张压） */
     private BigDecimal value1;
@@ -44,7 +44,7 @@ public class FsUserHealthData extends BaseEntity{
     private Date measurementTime;
 
     /** 等级（无-0，轻微-1，严重-2） */
-    private int level;
+    private Integer level;
 
     /** 记录创建时间 */
     @JsonFormat(pattern = "yyyy-MM-dd")
@@ -53,5 +53,6 @@ public class FsUserHealthData extends BaseEntity{
     /** 性别（0:男, 1:女, 2:未知） */
     private String sex;
 
+    private String timeSearch;
 
 }

fs-service/src/main/java/com/fs/his/domain/FsUserInfo.java

@@ -52,7 +52,7 @@ public class FsUserInfo extends BaseEntity {
     /**
      * 年龄
      */
-    private int age;
+    private Integer age;
 
     /**
      * 电话

fs-service/src/main/java/com/fs/his/dto/FsUserHealthInfoDTO.java

@@ -0,0 +1,55 @@
+package com.fs.his.dto;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fs.common.core.domain.BaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.math.BigDecimal;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 用户健康档案对象 FsUserHealthInfoDTO
+ *
+ * @author fs
+ * @date 2025-08-27
+ */
+@Data
+public class FsUserHealthInfoDTO extends BaseEntity{
+
+    /** 用户ID（主键） */
+    private Long userId;
+
+    /**
+     * 姓名
+     */
+    private String username;
+
+    /**
+     * 头像
+     */
+    private String avatar;
+
+    /**
+     * 性别（0:男, 1:女, 2:未知）
+     */
+    private String sex;
+
+    /**
+     * 年龄
+     */
+    private Integer age;
+    /**
+     * 各数据信息
+     */
+    private Map<String, Object>  dataMap;
+
+    /** 其他病史 */
+    private String otherMedicalHistory;
+
+    /** 症状史 */
+    private String symptomHistory;
+
+}

fs-service/src/main/java/com/fs/his/mapper/FsUserHealthDataMapper.java

@@ -11,13 +11,6 @@ import com.fs.his.domain.FsUserHealthData;
  * @date 2025-08-27
  */
 public interface FsUserHealthDataMapper extends BaseMapper<FsUserHealthData>{
-    /**
-     * 查询用户身体检测数据
-     * 
-     * @param id 用户身体检测数据主键
-     * @return 用户身体检测数据
-     */
-    FsUserHealthData selectFsUserHealthDataById(String id);
 
     /**
      * 查询用户身体检测数据列表
@@ -49,7 +42,7 @@ public interface FsUserHealthDataMapper extends BaseMapper<FsUserHealthData>{
      * @param id 用户身体检测数据主键
      * @return 结果
      */
-    int deleteFsUserHealthDataById(String id);
+    int deleteFsUserHealthDataById(Long id);
 
     /**
      * 批量删除用户身体检测数据
@@ -58,4 +51,22 @@ public interface FsUserHealthDataMapper extends BaseMapper<FsUserHealthData>{
      * @return 结果
      */
     int deleteFsUserHealthDataByIds(String[] ids);
+
+    /**
+     * 查询用户身体检测最新数据
+     *
+     * @param fsUserHealthData 用户身体检测数据主键
+     * @return 用户身体检测数据
+     */
+    FsUserHealthData selectFsUserHealthDataByUserId(FsUserHealthData fsUserHealthData);
+
+    /**
+     * 查询用户身体数据详情
+     *
+     * @param id 用户身体检测数据主键
+     * @return 用户身体检测数据
+     */
+    FsUserHealthData selectFsUserHealthDataById(Long id);
+
+    int selectFsUserHealthDataListCount(FsUserHealthData fsUserHealthData);
 }

fs-service/src/main/java/com/fs/his/service/IFsUserHealthDataService.java

@@ -2,10 +2,8 @@ package com.fs.his.service;
 
 import java.math.BigDecimal;
 import java.util.List;
-import java.util.Map;
 
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.fs.his.config.HealthIndicatorConfig;
 import com.fs.his.domain.FsUserHealthData;
 import com.fs.his.domain.FsUserHealthProfile;
 
@@ -22,7 +20,7 @@ public interface IFsUserHealthDataService extends IService<FsUserHealthData>{
      * @param id 用户身体检测数据主键
      * @return 用户身体检测数据
      */
-    FsUserHealthData selectFsUserHealthDataById(String id);
+//    FsUserHealthData selectFsUserHealthDataById(String id);
 
     /**
      * 查询用户身体检测数据列表
@@ -48,27 +46,13 @@ public interface IFsUserHealthDataService extends IService<FsUserHealthData>{
      */
     int updateFsUserHealthData(FsUserHealthData fsUserHealthData);
 
-    /**
-     * 批量删除用户身体检测数据
-     * 
-     * @param ids 需要删除的用户身体检测数据主键集合
-     * @return 结果
-     */
-    int deleteFsUserHealthDataByIds(String[] ids);
-
     /**
      * 删除用户身体检测数据信息
      * 
      * @param id 用户身体检测数据主键
      * @return 结果
      */
-    int deleteFsUserHealthDataById(String id);
-
-//    HealthIndicatorConfig parseHealthIndicator();
-//
-//    String getHealthIndicatorValue(HealthIndicatorConfig config, String type, String key, String level, String subType);
-//
-//    String getHealthIndicatorValue(HealthIndicatorConfig config, String type, String key, String level);
+    int deleteFsUserHealthDataById(Long id);
 
     /**
      * @Description: 计算用户健康指标等级
@@ -83,4 +67,14 @@ public interface IFsUserHealthDataService extends IService<FsUserHealthData>{
     BigDecimal calculateBMI(BigDecimal height, BigDecimal weight);
 
     void initHealthData(FsUserHealthProfile fsUserHealthProfile);
+
+    void addHealthData(FsUserHealthData fsUserHealthData);
+
+    FsUserHealthData selectFsUserHealthDataByUserId(FsUserHealthData fsUserHealthData);
+
+    FsUserHealthData selectFsUserHealthDataById(Long id);
+
+    void updateFsUserHealthDataAndLevel(FsUserHealthData fsUserHealthData);
+
+    int selectFsUserHealthDataListCount(FsUserHealthData fsUserHealthData);
 }

fs-service/src/main/java/com/fs/his/service/impl/FsUserHealthDataServiceImpl.java

@@ -2,8 +2,8 @@ package com.fs.his.service.impl;
 
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.fs.common.constant.Constants;
-import com.fs.common.core.domain.R;
 import com.fs.common.core.redis.RedisCache;
+import com.fs.common.exception.ServiceException;
 import com.fs.common.utils.StringUtils;
 import com.fs.his.config.HealthIndicatorConfig;
 import com.fs.his.domain.FsUserHealthData;
@@ -48,16 +48,6 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
 
     private static final String HEALTH_INDICATOR_KEY = "his.healthIndexConfig";
 
-    /**
-     * 查询用户身体检测数据
-     *
-     * @param id 用户身体检测数据主键
-     * @return 用户身体检测数据
-     */
-    @Override
-    public FsUserHealthData selectFsUserHealthDataById(String id) {
-        return baseMapper.selectFsUserHealthDataById(id);
-    }
 
     /**
      * 查询用户身体检测数据列表
@@ -70,6 +60,19 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
         return baseMapper.selectFsUserHealthDataList(fsUserHealthData);
     }
 
+    /**
+     * @Description: 查询用户身体检测数据列表 获取数量
+     * @Param:
+     * @Return:
+     * @Author xgb
+     * @Date 2025/9/1 14:58
+     */
+
+    @Override
+    public int selectFsUserHealthDataListCount(FsUserHealthData fsUserHealthData) {
+        return baseMapper.selectFsUserHealthDataListCount(fsUserHealthData);
+    }
+
     /**
      * 新增用户身体检测数据
      *
@@ -93,27 +96,131 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
     }
 
     /**
-     * 批量删除用户身体检测数据
+     * 删除用户身体检测数据信息
      *
-     * @param ids 需要删除的用户身体检测数据主键
+     * @param id 用户身体检测数据主键
      * @return 结果
      */
     @Override
-    public int deleteFsUserHealthDataByIds(String[] ids) {
-        return baseMapper.deleteFsUserHealthDataByIds(ids);
+    public int deleteFsUserHealthDataById(Long id) {
+        return baseMapper.deleteFsUserHealthDataById(id);
     }
 
+
     /**
-     * 删除用户身体检测数据信息
-     *
-     * @param id 用户身体检测数据主键
-     * @return 结果
+     * @Description: 查询用户身体检测最新数据
+     * @Param:
+     * @Return:
+     * @Author xgb
+     * @Date 2025/8/29 17:48
      */
     @Override
-    public int deleteFsUserHealthDataById(String id) {
-        return baseMapper.deleteFsUserHealthDataById(id);
+    public FsUserHealthData selectFsUserHealthDataByUserId(FsUserHealthData fsUserHealthData) {
+
+        return baseMapper.selectFsUserHealthDataByUserId(fsUserHealthData);
+    }
+
+    /**
+     * @Description: 查询用户身体检测数据详情
+     * @Param:
+     * @Return:
+     * @Author xgb
+     * @Date 2025/8/29 17:48
+     */
+    @Override
+    public FsUserHealthData selectFsUserHealthDataById(Long Id) {
+        return baseMapper.selectFsUserHealthDataById(Id);
+    }
+
+    /**
+     * @Description: 更新用户身体检测数据
+     * @Param:  fsUserHealthData
+     * @Return:
+     * @Author xgb
+     * @Date 2025/9/1 10:50
+     */
+    @Override
+    public void updateFsUserHealthDataAndLevel(FsUserHealthData fsUserHealthData) {
+        // 优化后的代码
+        int type = fsUserHealthData.getMeasurementType();
+        boolean hasValue1 = fsUserHealthData.getValue1() != null;
+        boolean hasValue2 = fsUserHealthData.getValue2() != null;
+
+        switch (type) {
+            case 3: // 血压
+            case 5: // BMI
+                // 参数校验: 血压和BMI的Value1和Value2必须同时有值或同时没值
+                if (hasValue1 != hasValue2) {
+                    throw new ServiceException("血压和BMI必须同时有值或同时没值");
+                }
+
+                if (hasValue1 && hasValue2) {
+                    if (type == 3) { // 血压
+                        // 计算测量值对应等级
+                        int level = getHealthIndicatorLevel(fsUserHealthData);
+                        fsUserHealthData.setLevel(level);
+                    } else { // BMI
+                        // 保存原始value1
+                        BigDecimal originalValue1 = fsUserHealthData.getValue1();
+                        // 计算BMI
+                        BigDecimal bmi = calculateBMI(fsUserHealthData.getValue1(), fsUserHealthData.getValue2());
+                        fsUserHealthData.setValue1(bmi);
+                        // 计算测量值对应等级
+                        int level = getHealthIndicatorLevel(fsUserHealthData);
+                        fsUserHealthData.setLevel(level);
+                        // 恢复原始value1
+                        fsUserHealthData.setValue1(originalValue1);
+                    }
+                }
+                // 更新用户身体检测数据信息
+                if (updateFsUserHealthData(fsUserHealthData) <= 0) {
+                    throw new ServiceException("用户身体检测数据修改失败");
+                }
+                break;
+
+            case 0: // 腰围
+            case 1: // 臀围
+                // 更新用户身体检测数据信息
+                if (updateFsUserHealthData(fsUserHealthData) <= 0) {
+                    throw new ServiceException("用户身体检测数据修改失败");
+                }
+                break;
+
+            case 2: // 血糖
+                // 计算测量值对应等级
+                int level = getHealthIndicatorLevel(fsUserHealthData);
+                fsUserHealthData.setLevel(level);
+                // 更新用户身体检测数据信息
+                if (updateFsUserHealthData(fsUserHealthData) <= 0) {
+                    throw new ServiceException("用户身体检测数据修改失败");
+                }
+                break;
+
+            case 4: // 尿酸
+                // 根据userId查询用户信息
+                FsUserInfo user = fsUserInfoService.selectFsUserInfoById(fsUserHealthData.getUserId());
+                if (StringUtils.isEmpty(user.getSex()) || "2".equals(user.getSex())) {
+                    throw new ServiceException("尿酸判断需要性别信息,请完善用户性别信息");
+                }
+                fsUserHealthData.setSex(user.getSex());
+                // 计算测量值对应等级
+                int uricLevel = getHealthIndicatorLevel(fsUserHealthData);
+                fsUserHealthData.setLevel(uricLevel);
+                // 更新用户身体检测数据信息
+                if (updateFsUserHealthData(fsUserHealthData) <= 0) {
+                    throw new ServiceException("用户身体检测数据修改失败");
+                }
+                break;
+
+            default:
+                throw new ServiceException("不支持的测量类型");
+        }
+
     }
 
+
+
+
     /**
      * @Description: 解析健康指标
      * @Param: []
@@ -127,12 +234,12 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
         // str JSON串转 map
         if (StringUtils.isEmpty(str)) {
             // 查询sys_config表配置
-            SysConfig config=configService.selectConfigByConfigKey(HEALTH_INDICATOR_KEY);
+            SysConfig config = configService.selectConfigByConfigKey(HEALTH_INDICATOR_KEY);
             if (config != null && StringUtils.isNotEmpty(config.getConfigValue())) {
                 redisCache.setCacheObject(configKey, config.getConfigValue());
                 return HealthIndicatorConfig.fromJson(config.getConfigValue());
-            }else {
-                throw new RuntimeException("健康指标配置不存在,请联系管理人员");
+            } else {
+                throw new ServiceException("健康指标配置不存在,请联系管理人员");
             }
         }
 
@@ -144,15 +251,15 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
      * 获取健康指标值
      *
      * @param config  健康指标配置对象
-     * @param type    指标类型 (bloodGlucose 血糖, bloodPressure 血压, uricAcid 血酸（分男女）, bmi 胖瘦)
-     * @param key     指标键值 (bloodGlucose使用（fasting 正常, post1Hour 饭后一小时, post2Hour 饭后两小时 ）血酸（male 男性 female 女性） severity 等)
+     * @param type    指标类型 (bloodGlucose 血糖, bloodPressure 血压, uricAcid 尿酸（分男女）, bmi 胖瘦)
+     * @param key     指标键值 (bloodGlucose使用（fasting 正常, post1Hour 饭后一小时, post2Hour 饭后两小时 ）尿酸（male 男性 female 女性） severity 等)
      * @param level   指标级别 (normal 正常, mild 轻微, severe 严重 等)
      * @param subType 子类型 (bloodPressure时使用，systolic 收缩压, diastolic 舒张压)
      * @return 指标值
      */
     private String getHealthIndicatorValue(HealthIndicatorConfig config, String type, String key, String level, String subType) {
         if (config == null) {
-            throw new RuntimeException("健康指标配置不存在,请联系管理人员");
+            throw new ServiceException("健康指标配置不存在,请联系管理人员");
         }
 
         try {
@@ -198,7 +305,7 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
 
                 case "uricAcid":
                     Map<String, Object> uricAcid = config.getUricAcid();
-                    if("male".equals(key)||"female".equals(key)){
+                    if ("male".equals(key) || "female".equals(key)) {
                         List<Map<String, Object>> genderList = (List<Map<String, Object>>) uricAcid.get(key);
                         if (genderList != null) {
                             for (Map<String, Object> severity : genderList) {
@@ -207,7 +314,7 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
                                 }
                             }
                         }
-                    } else{
+                    } else {
                         Map<String, Object> keyMap = (Map<String, Object>) uricAcid.get(key);
                         if (keyMap != null) {
                             return (String) keyMap.get(level);
@@ -229,10 +336,10 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
                     break;
 
                 default:
-                    throw new RuntimeException("不支持的健康指标类型: " + type);
+                    throw new ServiceException("不支持的健康指标类型: " + type);
             }
         } catch (Exception e) {
-            throw new RuntimeException("获取健康指标值失败: " + e.getMessage());
+            throw new ServiceException("获取健康指标值失败: " + e.getMessage());
         }
 
         return null;
@@ -264,7 +371,7 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
 
         HealthDataTypeEnum dataType = HealthDataTypeEnum.getEnumByKey(fsUserHealthData.getMeasurementType());
         if (dataType == null) {
-            throw new RuntimeException("不支持的健康指标类型: " + fsUserHealthData.getMeasurementType());
+            throw new ServiceException("不支持的健康指标类型: " + fsUserHealthData.getMeasurementType());
         }
 
         // 定义健康级别的优先级顺序和对应常量
@@ -292,11 +399,16 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
                 String[] subTypes = {HealthIndicatorConfig.SYSTOLIC, HealthIndicatorConfig.DIASTOLIC};
                 // 遍历各个健康级别，检查用户数据是否符合该级别范围
                 for (int i = 2; i >= 0; i--) {
-                    for (String subType : subTypes) {
-                        String rule = getHealthIndicatorValue(config, dataType.getType(), HealthIndicatorConfig.SEVERITY, levels[i], subType);
-                        if (isContain(rule, userValue)) {
-                            return levelValues[i];
-                        }
+                    // 判断收缩压
+                    String rule = getHealthIndicatorValue(config, dataType.getType(), HealthIndicatorConfig.SEVERITY, levels[i], subTypes[0]);
+                    if (isContain(rule, userValue)) {
+                        return levelValues[i];
+                    }
+                    // 判断舒张压
+                    BigDecimal userValue2 = fsUserHealthData.getValue2();
+                    rule = getHealthIndicatorValue(config, dataType.getType(), HealthIndicatorConfig.SEVERITY, levels[i], subTypes[1]);
+                    if (isContain(rule, userValue2)) {
+                        return levelValues[i];
                     }
                 }
                 // 如果没有匹配的级别，则返回异常数据
@@ -312,7 +424,7 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
                 } else if ("1".equals(sex)) { // 女
                     key = HealthIndicatorConfig.FEMALE;
                 } else {
-                    throw new RuntimeException("不支持的性别类型: " + sex);
+                    throw new ServiceException("不支持的性别类型: " + sex);
                 }
                 for (int i = 0; i < levels.length; i++) {
                     String rule = getHealthIndicatorValue(config, dataType.getType(), key, levels[i]);
@@ -324,7 +436,7 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
                 // 如果没有匹配的级别，则返回异常数据
                 return HealthDataLevelEnum.EXCEPTION.getValue();
             default:
-                throw new RuntimeException("未实现的健康指标类型处理: " + dataType.getType());
+                throw new ServiceException("未实现的健康指标类型处理: " + dataType.getType());
         }
     }
 
@@ -354,7 +466,7 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
 
     /**
      * @Description: 初始化健康档案时登记初始化用户健康数据
-     * @Param:  fsUserHealthProfile
+     * @Param: fsUserHealthProfile
      * @Return:
      * @Author xgb
      * @Date 2025/8/29 13:37
@@ -363,18 +475,18 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
     public void initHealthData(FsUserHealthProfile fsUserHealthProfile) {
         // 查询档案信息获取登记时间
         fsUserHealthProfile = fsUserHealthProfileService.selectFsUserHealthProfileByUserId(fsUserHealthProfile.getUserId());
-        if(fsUserHealthProfile==null){
-            throw new RuntimeException("用户健康档案不存在");
+        if (fsUserHealthProfile == null) {
+            throw new ServiceException("用户健康档案不存在");
         }
         // 第一次登记档案的时候 若存在身高体重 BMI 则进行BMI等级判断
-        FsUserHealthData fsUserHealthData=new FsUserHealthData();
+        FsUserHealthData fsUserHealthData = new FsUserHealthData();
         fsUserHealthData.setUserId(fsUserHealthProfile.getUserId());
         fsUserHealthData.setMeasurementDate(fsUserHealthProfile.getCreatedTime());
         fsUserHealthData.setMeasurementTime(fsUserHealthProfile.getCreatedTime());
         // 若存在身高体重 则登记BMI测量值
-        if(fsUserHealthProfile.getHeight()!=null && fsUserHealthProfile.getWeight()!=null){
+        if (fsUserHealthProfile.getHeight() != null && fsUserHealthProfile.getWeight() != null) {
             // 计算BMI值
-            BigDecimal bmi=calculateBMI(fsUserHealthProfile.getHeight(),fsUserHealthProfile.getWeight());
+            BigDecimal bmi = calculateBMI(fsUserHealthProfile.getHeight(), fsUserHealthProfile.getWeight());
             // 计算BMI等级
             /** 测量类型（0-腰围，1-臀围，2-血糖，3-血压，4-尿酸 5-BMI） */
             fsUserHealthData.setMeasurementType(HealthDataTypeEnum.BMI.getValue());
@@ -385,33 +497,33 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
             fsUserHealthData.setLevel(healthIndicatorLevel);
 
             if (insertFsUserHealthData(fsUserHealthData) <= 0) {
-                throw new RuntimeException("BMI数据登记失败");
+                throw new ServiceException("BMI数据登记失败");
             }
 
         }
 
         // 若存在腰围
-        if(fsUserHealthProfile.getWaistCircumference()!=null){
+        if (fsUserHealthProfile.getWaistCircumference() != null) {
             /** 测量类型（0-腰围，1-臀围，2-血糖，3-血压，4-尿酸 5-BMI） */
             fsUserHealthData.setMeasurementType(HealthDataTypeEnum.WAIST.getValue());
             fsUserHealthData.setValue1(fsUserHealthProfile.getWaistCircumference());
             if (insertFsUserHealthData(fsUserHealthData) <= 0) {
-                throw new RuntimeException("腰围数据登记失败");
+                throw new ServiceException("腰围数据登记失败");
             }
         }
 
         // 若存在臀围
-        if(fsUserHealthProfile.getHipCircumference()!=null){
+        if (fsUserHealthProfile.getHipCircumference() != null) {
             /** 测量类型（0-腰围，1-臀围，2-血糖，3-血压，4-尿酸 5-BMI） */
             fsUserHealthData.setMeasurementType(HealthDataTypeEnum.HIP.getValue());
             fsUserHealthData.setValue1(fsUserHealthProfile.getHipCircumference());
             if (insertFsUserHealthData(fsUserHealthData) <= 0) {
-                throw new RuntimeException("臀围数据登记失败");
+                throw new ServiceException("臀围数据登记失败");
             }
         }
 
         // 若存在血压
-        if(fsUserHealthProfile.getSystolicPressure()!=null && fsUserHealthProfile.getDiastolicPressure()!=null){
+        if (fsUserHealthProfile.getSystolicPressure() != null && fsUserHealthProfile.getDiastolicPressure() != null) {
 
             /** 测量类型（0-腰围，1-臀围，2-血糖，3-血压，4-尿酸 5-BMI） */
             fsUserHealthData.setMeasurementType(HealthDataTypeEnum.BLOOD_PRESSURE.getValue());
@@ -420,28 +532,28 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
             int healthIndicatorLevel = getHealthIndicatorLevel(fsUserHealthData);
             fsUserHealthData.setLevel(healthIndicatorLevel);
             if (insertFsUserHealthData(fsUserHealthData) <= 0) {
-                throw new RuntimeException("血压数据登记失败");
+                throw new ServiceException("血压数据登记失败");
             }
         }
 
         // 若存在血糖
-        if(fsUserHealthProfile.getHyperglycemiaValue()!=null){
+        if (fsUserHealthProfile.getHyperglycemiaValue() != null) {
             /** 测量类型（0-腰围，1-臀围，2-血糖，3-血压，4-尿酸 5-BMI） */
             fsUserHealthData.setMeasurementType(HealthDataTypeEnum.GLUCOSE.getValue());
             fsUserHealthData.setValue1(fsUserHealthProfile.getHyperglycemiaValue());
             int healthIndicatorLevel = getHealthIndicatorLevel(fsUserHealthData);
             fsUserHealthData.setLevel(healthIndicatorLevel);
             if (insertFsUserHealthData(fsUserHealthData) <= 0) {
-                throw new RuntimeException("血糖数据登记失败");
+                throw new ServiceException("血糖数据登记失败");
             }
         }
 
         // 若存在尿酸
-        if(fsUserHealthProfile.getHyperuricemiaValue()!=null){
+        if (fsUserHealthProfile.getHyperuricemiaValue() != null) {
             // 查询用户信息获取 性别
-            FsUserInfo fsUserInfo=fsUserInfoService.selectFsUserInfoById(fsUserHealthProfile.getUserId());
-            if(fsUserInfo== null|| StringUtils.isEmpty(fsUserInfo.getSex())){
-                throw new RuntimeException("无法获取用户性别,请完善用户信息");
+            FsUserInfo fsUserInfo = fsUserInfoService.selectFsUserInfoById(fsUserHealthProfile.getUserId());
+            if (fsUserInfo == null || StringUtils.isEmpty(fsUserInfo.getSex())) {
+                throw new ServiceException("无法获取用户性别,请完善用户信息");
             }
 
             /** 测量类型（0-腰围，1-臀围，2-血糖，3-血压，4-尿酸 5-BMI） */
@@ -451,11 +563,59 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
             int healthIndicatorLevel = getHealthIndicatorLevel(fsUserHealthData);
             fsUserHealthData.setLevel(healthIndicatorLevel);
             if (insertFsUserHealthData(fsUserHealthData) <= 0) {
-                throw new RuntimeException("尿酸数据登记失败");
+                throw new ServiceException("尿酸数据登记失败");
+            }
+        }
+    }
+
+    /**
+     * @Description: 新增健康各类型数据 0-腰围，1-臀围，2-血糖，3-血压，4-尿酸 5-BMI
+     * @Param: fsUserHealthData
+     * @Return:
+     * @Author xgb
+     * @Date 2025/8/29 16:06
+     */
+
+    @Override
+    public void addHealthData(FsUserHealthData fsUserHealthData) {
+        int type = fsUserHealthData.getMeasurementType();
+        // 0-腰围，1-臀围，2-血糖，3-血压，4-尿酸 5-BMI
+        if (type == 4) { // 尿酸查询等级信息时需要性别信息
+            // 根据userId 查询用户信息
+            FsUserInfo user = fsUserInfoService.selectFsUserInfoById(fsUserHealthData.getUserId());
+            if (StringUtils.isEmpty(user.getSex()) || "2".equals(user.getSex())) {
+                throw new ServiceException("尿酸判断需要性别信息,请完善用户性别信息");
             }
+            fsUserHealthData.setSex(user.getSex());
+        }
+        // 2-血糖，3-血压，4-尿酸 5-BMI 判断等级
+        if (type == 2 || type == 3 || type == 4) {
+            // 计算测量值对应等级
+            int level = getHealthIndicatorLevel(fsUserHealthData);
+            fsUserHealthData.setLevel(level);
+        } else if (type == 5) {// BMI 需要用身高体重先计算出BMI
+            // 计算BMI
+            BigDecimal value1 = fsUserHealthData.getValue1();
+            fsUserHealthData.setValue1(calculateBMI(fsUserHealthData.getValue1(), fsUserHealthData.getValue2()));
+            // 计算测量值对应等级
+            int level = getHealthIndicatorLevel(fsUserHealthData);
+            fsUserHealthData.setLevel(level);
+            fsUserHealthData.setValue1(value1);
+        }else if (type == 0 || type == 1) {
+            // 获取性别信息
+            FsUserInfo user = fsUserInfoService.selectFsUserInfoById(fsUserHealthData.getUserId());
+            if (user == null || StringUtils.isEmpty(user.getSex())) {
+                throw new ServiceException("无法获取用户性别,请完善用户信息");
+            }
+            fsUserHealthData.setSex(user.getSex());
+        }
+        // 登记检测数据信息
+        if (insertFsUserHealthData(fsUserHealthData) <= 0) {
+            throw new ServiceException("新增用户身体检测数据失败");
         }
     }
 
+
     /**
      * 判断value1是否在value规则范围内
      *
@@ -465,14 +625,14 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
      */
     private static Boolean isContain(String value, BigDecimal value1) {
         if (value == null || value1 == null) {
-            throw new RuntimeException("参数不能为空");
+            throw new ServiceException("参数不能为空");
         }
 
         // 处理范围值 "0~100"
         if (value.contains("~")) {
             String[] parts = value.split("~");
             if (parts.length != 2) {
-                throw new RuntimeException("无效的范围值格式: " + value);
+                throw new ServiceException("无效的范围值格式: " + value);
             }
             BigDecimal lower = new BigDecimal(parts[0]);
             BigDecimal upper = new BigDecimal(parts[1]);
@@ -499,7 +659,7 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
 
         // 处理大于等于 "≥100"
         if (value.startsWith("≥")) {
-            BigDecimal threshold = new BigDecimal(value.substring(2));
+            BigDecimal threshold = new BigDecimal(value.substring(1));
             return value1.compareTo(threshold) >= 0;
         }
 
@@ -508,7 +668,7 @@ public class FsUserHealthDataServiceImpl extends ServiceImpl<FsUserHealthDataMap
             BigDecimal threshold = new BigDecimal(value);
             return value1.compareTo(threshold) == 0;
         } catch (NumberFormatException e) {
-            throw new RuntimeException("不支持的指标值规则: " + value + ";请联系管理员处理");
+            throw new ServiceException("不支持的指标值规则: " + value + ";请联系管理员处理");
         }
 
     }

fs-service/src/main/resources/mapper/his/FsUserHealthDataMapper.xml

@@ -12,13 +12,35 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         <result property="value2"    column="value2"    />
         <result property="measurementDate"    column="measurement_date"    />
         <result property="measurementTime"    column="measurement_time"    />
+        <result property="level"    column="level"    />
         <result property="createdAt"    column="created_at"    />
     </resultMap>
 
     <sql id="selectFsUserHealthDataVo">
-        select id, user_id, measurement_type, value1, value2, measurement_date, measurement_time, created_at from fs_user_health_data
+        select id, user_id, measurement_type, value1, value2, measurement_date, measurement_time,level, created_at from fs_user_health_data
     </sql>
 
+    <select id="selectFsUserHealthDataListCount" parameterType="FsUserHealthData" resultType="java.lang.Integer">
+        select count(*) from fs_user_health_data
+        <where>
+            <if test="userId != null  and userId != ''"> and user_id = #{userId}</if>
+            <if test="measurementType != null "> and measurement_type = #{measurementType}</if>
+            <if test="value1 != null "> and value1 = #{value1}</if>
+            <if test="value2 != null "> and value2 = #{value2}</if>
+            <if test="measurementDate != null "> and measurement_date = #{measurementDate}</if>
+            <if test="measurementTime != null "> and measurement_time = #{measurementTime}</if>
+            <if test="level != null "> and level = #{level}</if>
+            <if test="createdAt != null "> and created_at = #{createdAt}</if>
+            <if test="params.beginTime != null and params.beginTime != ''"><!-- 开始时间检索 -->
+                and date_format(measurement_date,'%y-%m-%d') &gt;= date_format(#{params.beginTime},'%y-%m-%d')
+            </if>
+            <if test="params.endTime != null and params.endTime != ''"><!-- 开始时间检索 -->
+                and date_format(measurement_date,'%y-%m-%d') &lt;= date_format(#{params.endTime},'%y-%m-%d')
+            </if>
+
+        </where>
+    </select>
+
     <select id="selectFsUserHealthDataList" parameterType="FsUserHealthData" resultMap="FsUserHealthDataResult">
         <include refid="selectFsUserHealthDataVo"/>
         <where>  
@@ -28,15 +50,29 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
             <if test="value2 != null "> and value2 = #{value2}</if>
             <if test="measurementDate != null "> and measurement_date = #{measurementDate}</if>
             <if test="measurementTime != null "> and measurement_time = #{measurementTime}</if>
+            <if test="level != null "> and level = #{level}</if>
             <if test="createdAt != null "> and created_at = #{createdAt}</if>
+            <if test="params.beginTime != null and params.beginTime != ''"><!-- 开始时间检索 -->
+                and date_format(measurement_date,'%y-%m-%d') &gt;= date_format(#{params.beginTime},'%y-%m-%d')
+            </if>
+            <if test="params.endTime != null and params.endTime != ''"><!-- 开始时间检索 -->
+                and date_format(measurement_date,'%y-%m-%d') &lt;= date_format(#{params.endTime},'%y-%m-%d')
+            </if>
+
         </where>
+        order by measurement_date desc, measurement_time desc
     </select>
     
-    <select id="selectFsUserHealthDataById" parameterType="String" resultMap="FsUserHealthDataResult">
+    <select id="selectFsUserHealthDataById" resultMap="FsUserHealthDataResult">
         <include refid="selectFsUserHealthDataVo"/>
         where id = #{id}
     </select>
-        
+    <!-- 根据用户id 获取最新数据   -->
+    <select id="selectFsUserHealthDataByUserId" parameterType="FsUserHealthData" resultType="com.fs.his.domain.FsUserHealthData">
+        <include refid="selectFsUserHealthDataVo"/> where user_id = #{userId} and measurement_type = #{measurementType} order by measurement_date desc, measurement_time desc limit 1
+    </select>
+
+
     <insert id="insertFsUserHealthData" parameterType="FsUserHealthData" useGeneratedKeys="true" keyProperty="id">
         insert into fs_user_health_data
         <trim prefix="(" suffix=")" suffixOverrides=",">
@@ -46,6 +82,7 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
             <if test="value2 != null">value2,</if>
             <if test="measurementDate != null">measurement_date,</if>
             <if test="measurementTime != null">measurement_time,</if>
+            <if test="level != null">level,</if>
             <if test="createdAt != null">created_at,</if>
          </trim>
         <trim prefix="values (" suffix=")" suffixOverrides=",">
@@ -55,6 +92,7 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
             <if test="value2 != null">#{value2},</if>
             <if test="measurementDate != null">#{measurementDate},</if>
             <if test="measurementTime != null">#{measurementTime},</if>
+            <if test="level != null">#{level},</if>
             <if test="createdAt != null">#{createdAt},</if>
          </trim>
     </insert>
@@ -68,16 +106,17 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
             <if test="value2 != null">value2 = #{value2},</if>
             <if test="measurementDate != null">measurement_date = #{measurementDate},</if>
             <if test="measurementTime != null">measurement_time = #{measurementTime},</if>
+            <if test="level != null">level = #{level},</if>
             <if test="createdAt != null">created_at = #{createdAt},</if>
         </trim>
         where id = #{id}
     </update>
 
-    <delete id="deleteFsUserHealthDataById" parameterType="String">
+    <delete id="deleteFsUserHealthDataById">
         delete from fs_user_health_data where id = #{id}
     </delete>
 
-    <delete id="deleteFsUserHealthDataByIds" parameterType="String">
+    <delete id="deleteFsUserHealthDataByIds">
         delete from fs_user_health_data where id in 
         <foreach item="id" collection="array" open="(" separator="," close=")">
             #{id}