体质计算规则

prec-service/src/main/java/com/diagbot/entity/Evaluator.java

@@ -3,6 +3,8 @@ package com.diagbot.entity;
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
 
 import java.io.Serializable;
 import java.math.BigDecimal;
@@ -17,6 +19,7 @@ import java.util.Date;
  * @since 2019-05-30
  */
 @TableName("prec_evaluator")
+@ApiModel
 public class Evaluator implements Serializable {
 
     private static final long serialVersionUID = 1L;
@@ -24,52 +27,63 @@ public class Evaluator implements Serializable {
     /**
      * 主键
      */
+    @ApiModelProperty(hidden = true)
     @TableId(value = "id", type = IdType.AUTO)
     private Long id;
 
+
     /**
      * 是否删除,N:未删除，Y:删除
      */
+    @ApiModelProperty(hidden = true)
     private String isDeleted;
 
     /**
      * 记录创建时间
      */
+    @ApiModelProperty(hidden = true)
     private Date gmtCreate;
 
     /**
      * 记录修改时间,如果时间是1970年则表示纪录未修改
      */
+    @ApiModelProperty(hidden = true)
     private Date gmtModified;
 
     /**
      * 创建人，0表示无创建人值
      */
+    @ApiModelProperty(hidden = true)
     private String creator;
 
     /**
      * 修改人,如果为0则表示纪录未修改
      */
+    @ApiModelProperty(hidden = true)
     private String modifier;
 
     /**
      * 姓名
      */
+    @ApiModelProperty(hidden = true)
     private String name;
 
     /**
      * 手机号
      */
+    @ApiModelProperty(hidden = true)
     private String phone;
 
     /**
      * 性别(1：男 2：女)
      */
+    @ApiModelProperty(hidden = true)
     private Integer sex;
 
     /**
      * 年龄
      */
+    @ApiModelProperty(hidden = true)
     private Integer age;
 
     /**
@@ -105,11 +119,13 @@ public class Evaluator implements Serializable {
     /**
      * 体质结果
      */
+    @ApiModelProperty(hidden = true)
     private String physicalRes;
 
     /**
      * 需要显示的体质逗号隔开
      */
+    @ApiModelProperty(hidden = true)
     private String physicalTypes;
 
     public Long getId() {

prec-service/src/main/java/com/diagbot/enums/PhysicalTypeEnum.java

@@ -0,0 +1,54 @@
+package com.diagbot.enums;
+
+import com.diagbot.core.KeyedNamed;
+import lombok.Setter;
+
+/**
+ * @Description: 体质枚举类型
+ * @author: zhoutg
+ * @Date: 2018/10/26 10:35
+ */
+public enum PhysicalTypeEnum implements KeyedNamed {
+
+    mild(1, "平和体质"),
+    faint(2, "气虚体质"),
+    wet(3, "湿滞体质"),
+    heart(4, "心肝火旺体质"),
+    stagnant(5, "积滞体质"),
+    except(6, "异禀体质");
+
+    @Setter
+    private Integer key;
+
+    @Setter
+    private String name;
+
+    PhysicalTypeEnum(Integer key, String name) {
+        this.key = key;
+        this.name = name;
+    }
+
+    public static PhysicalTypeEnum getEnum(Integer key) {
+        for (PhysicalTypeEnum item : PhysicalTypeEnum.values()) {
+            if (item.key == key) {
+                return item;
+            }
+        }
+        return null;
+    }
+
+    public static String getName(Integer key) {
+        PhysicalTypeEnum item = getEnum(key);
+        return item != null ? item.name : null;
+    }
+
+    @Override
+    public int getKey() {
+        return key;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+}

prec-service/src/main/java/com/diagbot/facade/EvaluatorFacade.java

@@ -6,6 +6,7 @@ import com.diagbot.dto.SearchEvaluatorDTO;
 import com.diagbot.entity.Evaluator;
 import com.diagbot.entity.PhysicalInfo;
 import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.enums.PhysicalTypeEnum;
 import com.diagbot.enums.SexEnum;
 import com.diagbot.exception.CommonErrorCode;
 import com.diagbot.exception.CommonException;
@@ -19,7 +20,9 @@ import com.diagbot.vo.SearchEvaluatorVO;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+import java.math.BigDecimal;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -33,6 +36,330 @@ public class EvaluatorFacade extends EvaluatorServiceImpl {
     @Autowired
     private PhysicalInfoFacade physicalInfoFacade;
 
+
+    public static void main(String[] args) {
+        EvaluatorFacade evaluatorFacade = new EvaluatorFacade();
+        Evaluator evaluator = new Evaluator();
+        evaluator.setMildValue(new BigDecimal(40.0)); // 平和体质
+        evaluator.setFaintValue(new BigDecimal(40.0)); // 气虚体质
+        evaluator.setWetValue(new BigDecimal(40.0)); // 湿滞体质
+        evaluator.setHeartValue(new BigDecimal(41.)); // 心肝火旺体质
+        evaluator.setStagnantValue(new BigDecimal(42.00)); // 积滞同质
+        evaluator.setExceptValue(new BigDecimal(42.01)); // 异禀体质
+        evaluatorFacade.cal(evaluator);
+
+    }
+
+
+    /**
+     * 计算体质
+     *
+     * @param evaluator 参数
+     * @return
+     */
+    public Evaluator cal(Evaluator evaluator) {
+
+        Double max = getMax5(evaluator);
+        Double min = getMin5(evaluator);
+        /**
+         * 判断平和质：
+         * 平和质转化分≥60分，同时其他5种体质转化分均<30分，判断结果：“平和质”。
+         * 平和质转化分≥60分，同时其他5种体质转化分均<50分，判断结果：“基本是平和质”。
+         * 平和质转化分≥60分，同时其他5种体质转化分有30-49分，判断结果：“基本是平和质兼倾向XX体质”。
+         * 不满足上述条件，判断结果：否。
+         */
+        // 平和质转化分≥60分
+         if (evaluator.getMildValue().doubleValue() >= 60.0) {
+             if (max < 30) {
+                 // 同时其他5种体质转化分均<30分, max[2/3/4/5/6] < 30
+                 evaluator.setPhysicalRes("平和体质");
+                 evaluator.setPhysicalTypes(String.valueOf(PhysicalTypeEnum.mild.getKey()));
+             } else if (max < 50 && min >= 30) {
+                 // 同时其他5种体质转化分均<50分,min[2/3/4/5/6] >= 30 and max[2/3/4/5/6] < 50
+                 evaluator.setPhysicalRes("基本是平和体质");
+                 evaluator.setPhysicalTypes(String.valueOf(PhysicalTypeEnum.mild.getKey()) );
+             } else if (max < 50 && max >= 30 && min < 30){
+                 // 同时其他5种体质转化分有30-49分,max[2/3/4/5/6] < 50 and max[2/3/4/5/6] >= 30 and min[2/3/4/5/6] < 30
+                 Map map = getMap(evaluator);
+                 evaluator.setPhysicalRes("基本是平和体质兼倾向" + map.get("msg"));
+                 evaluator.setPhysicalTypes(String.valueOf(PhysicalTypeEnum.mild.getKey()) + "," +  map.get("type"));
+             } else if (max >= 50){
+                 // 同时其他5种体质转化分有>=50分, max[2/3/4/5/6] >= 50
+                 Map map = getMapWithMild(evaluator, max);
+                 // 最大值有多个【是XX体质兼有XX体质】,最大值只有1个【是XX体质】
+                 evaluator.setPhysicalRes(String.valueOf(map.get("msg")));
+                 evaluator.setPhysicalTypes(String.valueOf(map.get("type")));
+             }
+         }
+
+
+        /**
+         * 判断偏颇体质：
+         * 转化分≥50分，判断结果：是XX体质。
+         * 转化分30-49分，判断结果：倾向XX体质。
+         * 转化分<30分，判断结果：否。
+         * 结论：按照偏颇体质得分高低顺序排序，得分最高的为主要偏颇体质，结论按此体质显示，并在结果中按分值顺序提选兼有体质。
+         * 首先判定5种偏颇体质得分是否均大于或等于≧50分。
+         * 有一个或多个大于等于50分的情况，按照偏颇体质选择分值最大的为偏颇体质，排名第二的为兼有体质，其余的不考虑；如果得分排名第一的有两个或以上，则按照自然顺序将第一个列为主要偏颇体质，第二个列为兼有体质，其余的不予考虑。
+         * 如出现得分一样的两种偏颇体质，则按照5种偏颇体质的排列顺序为：气虚质、积滞质、湿滞质、心火偏旺质、异禀质，
+         * 5种全部小于＜30分的情况，按照平和质判定条件执行。
+         * 平和质转化分＜60分，同时其他6种体质转化分30-49分，判断结果：倾向是XX体质。如果有两种或以上的得分一样，则按照6种偏颇体质的排列顺序为：气虚质、积滞质、湿滞质、心肝火旺质、异禀质，判断结果：“倾向是XX体质兼XX体质”，其余不考虑。如果等分倾向是体质有3个或以上，则仅选择分值最高的前两个，判断结果：“倾向是XX体质兼XX体质”，其余不考虑。
+         * 注意：有偏颇体质的不再考虑倾向体质。
+         */
+         else if (evaluator.getMildValue().doubleValue() < 60.0) {
+            if (max < 30) { // max[2/3/4/5/6] < 30
+                evaluator.setPhysicalRes("平和体质");
+                evaluator.setPhysicalTypes(String.valueOf(PhysicalTypeEnum.mild.getKey()));
+            } else if (max < 50 && min >= 30) { // min[2/3/4/5/6] >= 30 and max[2/3/4/5/6] < 50
+                // 最大值有多个【倾向XX体质兼有XX体质】, 最大值只有1个【倾向XX体质】
+                Map map = getMapNoMild(evaluator, "倾向是", max);
+                evaluator.setPhysicalRes(String.valueOf(map.get("msg")));
+                evaluator.setPhysicalTypes(String.valueOf(map.get("type")));
+            } else if (max >= 50) { // max[2/3/4/5/6] >= 50
+                // 最大值有多个【是XX体质兼有XX体质】,最大值只有1个【是XX体质】
+                Map map = getMapNoMild(evaluator, "是", max);
+                evaluator.setPhysicalRes(String.valueOf(map.get("msg")));
+                evaluator.setPhysicalTypes(String.valueOf(map.get("type")));
+            }
+        }
+        return evaluator;
+    }
+
+
+    /**
+     *  获取偏颇体质的最大值
+     *
+     * @param evaluator
+     * @return 最大值
+     */
+    public Double getMax5(Evaluator evaluator) {
+        Double max = evaluator.getFaintValue().doubleValue(); // 气虚质
+        if (max < evaluator.getWetValue().doubleValue()) { // 湿滞质
+            max = evaluator.getWetValue().doubleValue();
+        }
+        if (max < evaluator.getHeartValue().doubleValue()) { // 心肝火旺质
+            max = evaluator.getHeartValue().doubleValue();
+        }
+        if (max < evaluator.getStagnantValue().doubleValue()) { // 积滞质
+            max = evaluator.getStagnantValue().doubleValue();
+        }
+        if (max < evaluator.getExceptValue().doubleValue()) { // 异禀体质
+            max = evaluator.getExceptValue().doubleValue();
+        }
+        return max;
+    }
+
+
+    /**
+     * 获取偏颇体质的最小值
+     *
+     * @param evaluator
+     * @return 最小值
+     */
+    public Double getMin5(Evaluator evaluator) {
+        Double min = evaluator.getFaintValue().doubleValue();// 气虚质
+        if (min > evaluator.getWetValue().doubleValue()) { // 湿滞质
+            min = evaluator.getWetValue().doubleValue();
+        }
+        if (min > evaluator.getHeartValue().doubleValue()) { // 心肝火旺质
+            min = evaluator.getHeartValue().doubleValue();
+        }
+        if (min > evaluator.getStagnantValue().doubleValue()) { // 积滞质
+            min = evaluator.getStagnantValue().doubleValue();
+        }
+        if (min > evaluator.getExceptValue().doubleValue()) { // 异禀体质
+            min = evaluator.getExceptValue().doubleValue();
+        }
+        return min;
+    }
+
+
+    /**
+     * 获取无平和体质下的结果
+     *
+     * @param evaluator 参数
+     * @param prefix 前缀
+     * @param max 最大值
+     * @return
+     */
+    public Map getMapNoMild(Evaluator evaluator, String prefix, Double max) {
+        Map map = new HashMap<>();
+        String msg = "";
+        String type = "";
+        max = getMax5(evaluator);
+        int flag = 0;
+        if (evaluator.getFaintValue().doubleValue() == max) {
+            ++flag; // 最大值加1
+            msg =  prefix + "气虚体质";
+            type = "2";
+        }
+        if (evaluator.getWetValue().doubleValue() == max && flag < 2) {
+            if (flag == 1) {
+                msg += "兼有湿滞体质";
+                type += ",3";
+            } else {
+                msg = prefix + "湿滞体质";
+                type = "3";
+            }
+            ++flag;
+        }
+        if (evaluator.getHeartValue().doubleValue() == max && flag < 2) {
+            if (flag == 1) {
+                msg += "兼有心肝火旺体质";
+                type += ",4";
+            } else {
+                msg = prefix + "心肝火旺体质";
+                type = "4";
+            }
+            ++flag;
+        }
+        if (evaluator.getStagnantValue().doubleValue() == max && flag < 2) {
+            if (flag == 1) {
+                msg += "兼有积滞体质";
+                type += ",5";
+            } else {
+                msg = prefix + "积滞体质";
+                type = "5";
+            }
+            ++flag;
+        }
+        if (evaluator.getExceptValue().doubleValue() == max && flag < 2) {
+            if (flag == 1) {
+                msg += "兼有异禀体质";
+                type += ",6";
+            } else {
+                msg = prefix + "异禀体质";
+                type = "6";
+            }
+        }
+        map.put("msg", msg);
+        map.put("type", type);
+        return map;
+    }
+
+
+    /**
+     * 获取有平和体质下的结果
+     *
+     * @param evaluator 参数
+     * @param max 前缀
+     * @return
+     */
+    public Map getMapWithMild(Evaluator evaluator, Double max) {
+        Map map = new HashMap<>();
+        String msg = "";
+        String type = "";
+        max = getMax5(evaluator);
+        if (evaluator.getMildValue().doubleValue() > max) {
+            msg = "是平和体质";
+            type = String.valueOf(PhysicalTypeEnum.mild.getKey());
+        } else if (evaluator.getMildValue().doubleValue() == max) {
+            if (evaluator.getFaintValue().doubleValue() == max) {
+                msg = "是平和体质兼有气虚体质";
+                type = "1,2";
+            } else if (evaluator.getWetValue().doubleValue() == max) {
+                msg = "是平和体质兼有湿滞体质";
+                type = "1,3";
+            } else if (evaluator.getHeartValue().doubleValue() == max) {
+                msg = "是平和体质兼有心肝火旺体质";
+                type = "1,4";
+            } else if (evaluator.getFaintValue().doubleValue() == max) {
+                msg = "是平和体质兼有积滞同质";
+                type = "1,5";
+            } else if (evaluator.getExceptValue().doubleValue() == max) {
+                msg = "是平和体质兼有异禀体质";
+                type = "1,6";
+            }
+        } else {
+            int flag = 0;
+            if (evaluator.getFaintValue().doubleValue() == max) {
+                ++flag; // 最大值加1
+                msg = "是气虚体质";
+                type = "2";
+            }
+            if (evaluator.getWetValue().doubleValue() == max && flag < 2) {
+                if (flag == 1) {
+                    msg += "兼有湿滞体质";
+                    type += ",3";
+                } else {
+                    msg = "是湿滞体质";
+                    type = "3";
+                }
+                ++flag;
+            }
+            if (evaluator.getHeartValue().doubleValue() == max && flag < 2) {
+                if (flag == 1) {
+                    msg += "兼有心肝火旺体质";
+                    type += ",4";
+                } else {
+                    msg = "是心肝火旺体质";
+                    type = "4";
+                }
+                ++flag;
+            }
+            if (evaluator.getStagnantValue().doubleValue() == max && flag < 2) {
+                if (flag == 1) {
+                    msg += "兼有积滞同质";
+                    type += ",5";
+                } else {
+                    msg = "是积滞同质";
+                    type = "5";
+                }
+                ++flag;
+            }
+            if (evaluator.getExceptValue().doubleValue() == max && flag < 2) {
+                if (flag == 1) {
+                    msg += "兼有异禀体质";
+                    type += ",6";
+                } else {
+                    msg = "是异禀体质";
+                    type = "6";
+                }
+            }
+        }
+        map.put("msg", msg);
+        map.put("type", type);
+        return map;
+    }
+
+
+    /**
+     * 获取平和体质下的结果
+     *
+     * @param evaluator
+     * @return
+     */
+    public Map getMap(Evaluator evaluator) {
+        Map map = new HashMap<>();
+        String msg = "气虚体质";
+        String type = String.valueOf(PhysicalTypeEnum.faint.getKey());
+        Double max = evaluator.getFaintValue().doubleValue(); // 气虚质
+
+        if (max < evaluator.getWetValue().doubleValue()) { // 湿滞质
+            max = evaluator.getWetValue().doubleValue();
+            msg = "湿滞体质";
+            type = String.valueOf(PhysicalTypeEnum.wet.getKey());
+        }
+        if (max < evaluator.getHeartValue().doubleValue()) { // 心肝火旺质
+            max = evaluator.getHeartValue().doubleValue();
+            msg = "心肝火旺体质";
+            type = String.valueOf(PhysicalTypeEnum.heart.getKey());
+        }
+        if (max < evaluator.getStagnantValue().doubleValue()) { // 积滞质
+            max = evaluator.getStagnantValue().doubleValue();
+            msg = "积滞体质";
+            type = String.valueOf(PhysicalTypeEnum.stagnant.getKey());
+        }
+        if (max < evaluator.getExceptValue().doubleValue()) { // 异禀体质
+            max = evaluator.getExceptValue().doubleValue();
+            msg = "异禀体质";
+            type = String.valueOf(PhysicalTypeEnum.except.getKey());
+        }
+        map.put("msg", msg);
+        map.put("type", type);
+        return map;
+    }
+
     public Boolean addEvaluator(AddEvaluatorVO addDeptInfoVO) {
         //参数验证
         if (!RegexValidateUtil.checkMobileNumber(addDeptInfoVO.getPhone())) {
@@ -47,6 +374,8 @@ public class EvaluatorFacade extends EvaluatorServiceImpl {
         Evaluator evaluator = new Evaluator();
         BeanUtil.copyProperties(addDeptInfoVO, evaluator);
         //计算
+        this.cal(evaluator);
+
         //保存结果
         Date now = DateUtil.now();
         evaluator.setIsDeleted(IsDeleteEnum.N.getKey());

prec-service/src/main/java/com/diagbot/web/EvaluatorController.java

@@ -5,6 +5,7 @@ import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.diagbot.annotation.SysLogger;
 import com.diagbot.dto.RespDTO;
 import com.diagbot.dto.SearchEvaluatorDTO;
+import com.diagbot.entity.Evaluator;
 import com.diagbot.facade.EvaluatorFacade;
 import com.diagbot.vo.AddEvaluatorVO;
 import com.diagbot.vo.SearchEvaluatorVO;
@@ -62,4 +63,19 @@ public class EvaluatorController {
     public RespDTO<IPage<SearchEvaluatorDTO>> getEvaluatorPage(@RequestBody SearchEvaluatorVO searchEvaluatorVO){
         return RespDTO.onSuc(evaluatorFacade.getEvaluatorPage(searchEvaluatorVO));
     }
+
+
+    /**
+     * 体质规则计算,测试使用
+     *
+     * @param evaluator 输入参数
+     * @return 返回计算结果值
+     */
+    @ApiOperation(value = "体质规则计算，测试使用", notes = "体质规则计算，测试使用")
+    @PostMapping("/cal2")
+    @SysLogger("cal2")
+    public RespDTO<String> cal2(@RequestBody Evaluator evaluator) {
+        evaluatorFacade.cal(evaluator);
+        return RespDTO.onSuc(evaluator.getPhysicalRes());
+    }
 }