1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
package com.ruoyi.quality.utils;
 
import java.math.BigDecimal;
 
/**
 * 质检参数判断工具类
 */
public class QualityJudgeUtil {
 
    public static final String JUDGE_TYPE_GREATER_EQUAL = "大于等于";
    public static final String JUDGE_TYPE_LESS_EQUAL = "小于等于";
    public static final String JUDGE_TYPE_RANGE = "范围";
    public static final String JUDGE_TYPE_TEXT_DESCRIPTION = "文字描述";
 
    /**
     * 判断参数项是否合格
     *
     * @param testValue     检验值
     * @param standardValue 标准值(大于等于、小于等于类型使用)
     * @param minValue      范围下限值(范围类型使用)
     * @param maxValue      范围上限值(范围类型使用)
     * @param judgeType     判断类型
     * @return 判断结果对象
     */
    public static JudgeResult judge(String testValue, String standardValue,
                                    BigDecimal minValue, BigDecimal maxValue, String judgeType) {
        JudgeResult result = new JudgeResult();
 
        // 文字描述类型不自动判断
        if (JUDGE_TYPE_TEXT_DESCRIPTION.equals(judgeType)) {
            result.setQualified(null);
            result.setMessage("文字描述类型需手动判断");
            return result;
        }
 
        // 检验值为空时无法判断
        if (testValue == null || testValue.trim().isEmpty()) {
            result.setQualified(null);
            result.setMessage("检验值为空,无法判断");
            return result;
        }
 
        try {
            BigDecimal testVal = new BigDecimal(testValue.trim());
 
            switch (judgeType) {
                case JUDGE_TYPE_GREATER_EQUAL:
                    return judgeGreaterEqual(testVal, standardValue);
                case JUDGE_TYPE_LESS_EQUAL:
                    return judgeLessEqual(testVal, standardValue);
                case JUDGE_TYPE_RANGE:
                    return judgeRange(testVal, minValue, maxValue);
                default:
                    result.setQualified(null);
                    result.setMessage("未知的判断类型:" + judgeType);
                    return result;
            }
        } catch (NumberFormatException e) {
            result.setQualified(null);
            result.setMessage("检验值格式不正确,无法转换为数值");
            return result;
        }
    }
 
    /**
     * 大于等于判断
     */
    private static JudgeResult judgeGreaterEqual(BigDecimal testValue, String standardValue) {
        JudgeResult result = new JudgeResult();
        try {
            BigDecimal standardVal = new BigDecimal(standardValue.trim());
            boolean qualified = testValue.compareTo(standardVal) >= 0;
            result.setQualified(qualified);
            result.setMessage(String.format("检验值%s >= 标准值%s,%s",
                    testValue, standardVal, qualified ? "合格" : "不合格"));
        } catch (Exception e) {
            result.setQualified(null);
            result.setMessage("标准值格式不正确:" + standardValue);
        }
        return result;
    }
 
    /**
     * 小于等于判断
     */
    private static JudgeResult judgeLessEqual(BigDecimal testValue, String standardValue) {
        JudgeResult result = new JudgeResult();
        try {
            BigDecimal standardVal = new BigDecimal(standardValue.trim());
            boolean qualified = testValue.compareTo(standardVal) <= 0;
            result.setQualified(qualified);
            result.setMessage(String.format("检验值%s <= 标准值%s,%s",
                    testValue, standardVal, qualified ? "合格" : "不合格"));
        } catch (Exception e) {
            result.setQualified(null);
            result.setMessage("标准值格式不正确:" + standardValue);
        }
        return result;
    }
 
    /**
     * 范围判断
     */
    private static JudgeResult judgeRange(BigDecimal testValue, BigDecimal minValue, BigDecimal maxValue) {
        JudgeResult result = new JudgeResult();
        if (minValue == null || maxValue == null) {
            result.setQualified(null);
            result.setMessage("范围类型的上下限值不能为空");
            return result;
        }
        boolean qualified = testValue.compareTo(minValue) >= 0 && testValue.compareTo(maxValue) <= 0;
        result.setQualified(qualified);
        result.setMessage(String.format("检验值%s在范围[%s, %s]%s,%s",
                testValue, minValue, maxValue,
                qualified ? "内" : "外", qualified ? "合格" : "不合格"));
        return result;
    }
 
    /**
     * 判断结果对象
     */
    public static class JudgeResult {
        private Boolean qualified;
        private String message;
 
        public Boolean getQualified() {
            return qualified;
        }
 
        public void setQualified(Boolean qualified) {
            this.qualified = qualified;
        }
 
        public String getMessage() {
            return message;
        }
 
        public void setMessage(String message) {
            this.message = message;
        }
    }
}