颅脑损伤患者昏迷时间未填写、首页入院时间与入院记录时间不一致

kernel/src/main/java/com/lantone/qc/kernel/catalogue/firstpagerecord/FIRP0196.java

@@ -26,7 +26,7 @@ public class FIRP0196 extends QCCatalogue {
         if (inputInfo.getBeHospitalizedDoc() != null && inputInfo.getBeHospitalizedDoc().getStructureMap() != null) {
             Map<String, String> beHospitalizedStructureMap = inputInfo.getBeHospitalizedDoc().getStructureMap();
             String present = beHospitalizedStructureMap.get(Content.present);
-            if (StringUtil.isNotBlank(present) && !present.contains("昏迷")) {
+            if (StringUtil.isNotBlank(present) && (!present.contains("昏迷") || present.contains("无昏迷"))) {
                 return;
             }
         }

public/src/main/java/com/lantone/qc/pub/Content.java

@@ -173,6 +173,10 @@ public class Content {
     public static final String dischargeDiag = "出院诊断";
     public static final String leaveHospitalDoctorAdvice = "出院医嘱";
     public static final String dp_out = "损伤、中毒外部原因";
+    public static final String diagnose_type = "诊断类别";
+    public static final String diagnose_type_short = "诊断判别";
+    public static final String diagnose_name = "诊断名称";
+    public static final String icd_code = "诊断编码";
     public static final String pathologyDiagnose = "病理诊断";
     public static final String pathologyDiagnoseCost = "病理诊断费";
     public static final String admitPath = "入院途径";

public/src/main/java/com/lantone/qc/pub/util/StringUtil.java

@@ -1,304 +1,312 @@
-package com.lantone.qc.pub.util;
-
-import com.lantone.qc.pub.Content;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.time.DateUtils;
-
-import java.text.ParseException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Date;
-import java.util.List;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * @Description: 字符串有关帮助类 封装了第三方帮助类
- * @author: gaodm
- * @time: 2018/8/6 11:15
- */
-public class StringUtil {
-    /**
-     * 判断某字符串是否为空或长度为0或由空白符(whitespace) 构成
-     *
-     * @param str 需要判断的字符串
-     * @return
-     */
-    public static boolean isBlank(String str) {
-        return StringUtils.isBlank(str);
-    }
-
-    /**
-     * 判断某字符串是否不是为空或长度为0或由空白符(whitespace) 构成
-     *
-     * @param str 需要判断的字符串
-     * @return
-     */
-    public static boolean isNotBlank(String str) {
-        return StringUtils.isNotBlank(str);
-    }
-
-    /**
-     * 判断某字符串是否为空，为空的标准是 str==null 或 str.length()==0
-     *
-     * @param str 需要判断的字符串
-     * @return
-     */
-    public static boolean isEmpty(String str) {
-        return StringUtils.isEmpty(str);
-    }
-
-    /**
-     * 判断某字符串是否不为空，为空的标准是 str==null 或 str.length()==0
-     *
-     * @param str 需要判断的字符串
-     * @return
-     */
-    public static boolean isNotEmpty(String str) {
-        return StringUtils.isNotEmpty(str);
-    }
-
-    /**
-     * 删除字符串中的换行和控制字符
-     *
-     * @param str
-     */
-    public static String remove_ctl(String str) {
-        String trim = "";
-        if (StringUtils.isNotEmpty(str)) {
-            trim = str.replaceAll("\r|\n|\r\n|/r/n", "").trim();
-        }
-        return trim;
-    }
-
-    /**
-     * 清除字符串中的空白
-     *
-     * @param str
-     * @return
-     */
-    public static String removeBlank(String str) {
-        if (isBlank(str)) {
-            return str;
-        }
-        return str.replaceAll("[\\s\\p{Zs}]", "").replaceAll("　", "");
-    }
-
-    /**
-     * 比较两个列表的内容
-     */
-    public static List<String> compareList(List<String> A, List<String> B) {
-        List<String> res = new ArrayList<>();
-
-        for (String i : A) {
-            if (!B.contains(i)) {
-                res.add(i);
-            }
-        }
-
-        for (String j : B) {
-            if (!A.contains(j)) {
-                res.add(j);
-            }
-        }
-
-        return res;
-    }
-
-    /**
-     * 列表A是否包含列表B
-     */
-    public static boolean containList(List<String> A, List<String> B) {
-        boolean res = true;
-
-        try {
-            for (String item : B) {
-                if (!A.contains(item)) {
-                    res = false;
-                    break;
-                }
-            }
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        } finally {
-            return res;
-        }
-    }
-
-    /**
-     * 比较两个字符串集合是否一模一样：个数一样、顺序一样
-     *
-     * @param source
-     * @param target
-     * @return
-     */
-    public static boolean isEqually(List<String> source, List<String> target) {
-        boolean ret = false;
-        if (ListUtil.isNotEmpty(source) && ListUtil.isNotEmpty(target)) {
-            String[] sourceArray = source.toArray(new String[] {});
-            String[] targetArray = target.toArray(new String[] {});
-            ret = Arrays.equals(sourceArray, targetArray);
-        }
-        return ret;
-    }
-
-    /**
-     * 判断字符串是否包含数字
-     *
-     * @param company
-     * @return
-     */
-    public static boolean isContainNumber(String company) {
-        Pattern p = Pattern.compile("[0-9]");
-        Matcher m = p.matcher(company);
-        if (m.find()) {
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * 标点符号空格等转逗号分割
-     *
-     * @param content
-     * @return
-     */
-    public static String specialCharComma(String content) {
-        if (StringUtil.isNotBlank(content)) {
-            content = content.replaceAll("(\\d+)|[、，。.；;？?]", " ").replaceAll("(\\s+)", ",");
-            if (content.indexOf(",") == 0) {
-                content = content.substring(1);
-            }
-            if (content.lastIndexOf(",") == content.length() - 1) {
-                content = content.substring(0, content.length() - 1);
-            }
-        }
-        return content;
-    }
-
-    /**
-     * 判断两个字符串是否相同
-     *
-     * @param arg1
-     * @param arg2
-     * @return
-     */
-    public static boolean equals(String arg1, String arg2) {
-        return StringUtils.equals(arg1, arg2);
-    }
-
-    /**
-     * 比较两个字符串集合是否内容一样，即A包含B，B包含A，交集为空
-     * 个数、顺序不考虑
-     *
-     * @param source
-     * @param target
-     * @return
-     */
-    //    public static boolean isSameContent(List<String> source, List<String> target) {
-    //        Set<String> sourceSet = Sets.newHashSet(source);
-    //        Set<String> targetSet = Sets.newHashSet(target);
-    //        return Sets.difference(sourceSet, targetSet).isEmpty() && Sets.difference(targetSet, sourceSet).isEmpty();
-    //    }
-
-    /**
-     * 解析时间
-     *
-     * @param datetime
-     * @return
-     */
-    public static Date parseDateTime(String datetime) {
-        Date date = null;
-        try {
-            datetime = remove_ctl(datetime);
-
-            if (datetime.contains("至")) {
-                datetime = datetime.split("至")[1].replaceAll("[\\u4e00-\\u9fa5]", "");
-            }
-
-            if (datetime.length() > 0) {
-                date = DateUtils.parseDate(datetime, Content.dateFormats);
-            }
-        } catch (Exception e) {
-//            ex.printStackTrace();
-            return null;
-        }
-        return date;
-    }
-
-    /**
-     * 根据给定的时间格式解析时间
-     *
-     * @param datetime
-     * @return
-     */
-    public static Date parseDateTime(String datetime, String[] dateFormats) {
-        Date date = null;
-        try {
-            datetime = remove_ctl(datetime);
-
-            if (datetime.contains("至")) {
-                datetime = datetime.split("至")[1].replaceAll("[\\u4e00-\\u9fa5]", "");
-            }
-            if (datetime.length() > 0) {
-                date = DateUtils.parseDate(datetime, dateFormats);
-            }
-        } catch (ParseException ex) {
-            ex.printStackTrace();
-        } finally {
-            return date;
-        }
-    }
-
-    public static String matRegx(String source, String regex1, String regex2, String val) {
-        if (isNotBlank(source) && isNotBlank(regex1) && isNotBlank(regex2)) {
-            Pattern pattern = Pattern.compile(regex1);
-            Matcher matcher = pattern.matcher(source);
-            if (matcher.find()) {
-                String sce1 = matcher.group();
-                if (isBlank(val) || !sce1.contains(val)) {
-                    String sce2 = sce1.replaceAll(regex2, val);
-                    source = source.replaceAll(sce1, sce2);
-                }
-            }
-        }
-        return source;
-    }
-
-    /**
-     * 去除字符串两边空白 包含一些特殊空格
-     *
-     * @param msg
-     * @return
-     */
-    public static String trim(String msg) {
-        if (isNotBlank(msg)) {
-            return org.springframework.util.StringUtils.trimWhitespace(msg).trim();
-        }
-        return msg;
-    }
-
-    /**
-     * 去掉尾部几位符合字符
-     *
-     * @param value
-     * @param regex
-     * @param len
-     * @return
-     */
-    public static String removeWN(String value, String regex, int len) {
-        String ret = value;
-        if (StringUtil.isNotBlank(value) && value.length() >= len) {
-            String endStr = null;
-            for (int i = len; i > 0; i--) {
-                endStr = value.substring(value.length() - len);
-                if (endStr.replaceAll(regex, "").length() == 0) {
-                    ret = value.substring(0, value.length() - len);
-                    break;
-                }
-            }
-        }
-        return ret;
-    }
-
+package com.lantone.qc.pub.util;
+
+import com.lantone.qc.pub.Content;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.time.DateUtils;
+
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * @Description: 字符串有关帮助类 封装了第三方帮助类
+ * @author: gaodm
+ * @time: 2018/8/6 11:15
+ */
+public class StringUtil {
+    /**
+     * 判断某字符串是否为空或长度为0或由空白符(whitespace) 构成
+     *
+     * @param str 需要判断的字符串
+     * @return
+     */
+    public static boolean isBlank(String str) {
+        return StringUtils.isBlank(str);
+    }
+
+    /**
+     * 判断某字符串是否不是为空或长度为0或由空白符(whitespace) 构成
+     *
+     * @param str 需要判断的字符串
+     * @return
+     */
+    public static boolean isNotBlank(String str) {
+        return StringUtils.isNotBlank(str);
+    }
+
+    /**
+     * 判断某字符串是否为空，为空的标准是 str==null 或 str.length()==0
+     *
+     * @param str 需要判断的字符串
+     * @return
+     */
+    public static boolean isEmpty(String str) {
+        return StringUtils.isEmpty(str);
+    }
+
+    /**
+     * 判断某字符串是否不为空，为空的标准是 str==null 或 str.length()==0
+     *
+     * @param str 需要判断的字符串
+     * @return
+     */
+    public static boolean isNotEmpty(String str) {
+        return StringUtils.isNotEmpty(str);
+    }
+
+    /**
+     * 删除字符串中的换行和控制字符
+     *
+     * @param str
+     */
+    public static String remove_ctl(String str) {
+        String trim = "";
+        if (StringUtils.isNotEmpty(str)) {
+            trim = str.replaceAll("\r|\n|\r\n|/r/n", "").trim();
+        }
+        return trim;
+    }
+
+    /**
+     * 清除字符串中的空白
+     *
+     * @param str
+     * @return
+     */
+    public static String removeBlank(String str) {
+        if (isBlank(str)) {
+            return str;
+        }
+        return str.replaceAll("[\\s\\p{Zs}]", "").replaceAll("　", "");
+    }
+
+    /**
+     * 比较两个列表的内容
+     */
+    public static List<String> compareList(List<String> A, List<String> B) {
+        List<String> res = new ArrayList<>();
+
+        for (String i : A) {
+            if (!B.contains(i)) {
+                res.add(i);
+            }
+        }
+
+        for (String j : B) {
+            if (!A.contains(j)) {
+                res.add(j);
+            }
+        }
+
+        return res;
+    }
+
+    /**
+     * 列表A是否包含列表B
+     */
+    public static boolean containList(List<String> A, List<String> B) {
+        boolean res = true;
+
+        try {
+            for (String item : B) {
+                if (!A.contains(item)) {
+                    res = false;
+                    break;
+                }
+            }
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+            return res;
+        }
+    }
+
+    /**
+     * 比较两个字符串集合是否一模一样：个数一样、顺序一样
+     *
+     * @param source
+     * @param target
+     * @return
+     */
+    public static boolean isEqually(List<String> source, List<String> target) {
+        boolean ret = false;
+        if (ListUtil.isNotEmpty(source) && ListUtil.isNotEmpty(target)) {
+            String[] sourceArray = source.toArray(new String[] {});
+            String[] targetArray = target.toArray(new String[] {});
+            ret = Arrays.equals(sourceArray, targetArray);
+        }
+        return ret;
+    }
+
+    /**
+     * 判断字符串是否包含数字
+     *
+     * @param company
+     * @return
+     */
+    public static boolean isContainNumber(String company) {
+        Pattern p = Pattern.compile("[0-9]");
+        Matcher m = p.matcher(company);
+        if (m.find()) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 标点符号空格等转逗号分割
+     *
+     * @param content
+     * @return
+     */
+    public static String specialCharComma(String content) {
+        if (StringUtil.isNotBlank(content)) {
+            content = content.replaceAll("(\\d+)|[、，。.；;？?]", " ").replaceAll("(\\s+)", ",");
+            if (content.indexOf(",") == 0) {
+                content = content.substring(1);
+            }
+            if (content.lastIndexOf(",") == content.length() - 1) {
+                content = content.substring(0, content.length() - 1);
+            }
+        }
+        return content;
+    }
+
+    /**
+     * 判断两个字符串是否相同
+     *
+     * @param arg1
+     * @param arg2
+     * @return
+     */
+    public static boolean equals(String arg1, String arg2) {
+        return StringUtils.equals(arg1, arg2);
+    }
+
+    /**
+     * 比较两个字符串集合是否内容一样，即A包含B，B包含A，交集为空
+     * 个数、顺序不考虑
+     *
+     * @param source
+     * @param target
+     * @return
+     */
+    //    public static boolean isSameContent(List<String> source, List<String> target) {
+    //        Set<String> sourceSet = Sets.newHashSet(source);
+    //        Set<String> targetSet = Sets.newHashSet(target);
+    //        return Sets.difference(sourceSet, targetSet).isEmpty() && Sets.difference(targetSet, sourceSet).isEmpty();
+    //    }
+
+    /**
+     * 解析时间
+     *
+     * @param datetime
+     * @return
+     */
+    public static Date parseDateTime(String datetime) {
+        Date date = null;
+        try {
+            datetime = remove_ctl(datetime);
+
+            if (datetime.contains("至")) {
+                datetime = datetime.split("至")[1].replaceAll("[\\u4e00-\\u9fa5]", "");
+            }
+
+            if (datetime.length() > 0) {
+                if(datetime.contains(",")){
+                    String pattern = "^\\d{4}-\\d{1,2}-\\d{1,2}\\,\\d{1,2}:\\d{1,2}$";
+                    Pattern r = Pattern.compile(pattern);
+                    Matcher m = r.matcher(datetime);
+                    if(m.find()){
+                        datetime = datetime.replace(",", " ");
+                    }
+                }
+                date = DateUtils.parseDate(datetime, Content.dateFormats);
+            }
+        } catch (Exception e) {
+//            ex.printStackTrace();
+            return null;
+        }
+        return date;
+    }
+
+    /**
+     * 根据给定的时间格式解析时间
+     *
+     * @param datetime
+     * @return
+     */
+    public static Date parseDateTime(String datetime, String[] dateFormats) {
+        Date date = null;
+        try {
+            datetime = remove_ctl(datetime);
+
+            if (datetime.contains("至")) {
+                datetime = datetime.split("至")[1].replaceAll("[\\u4e00-\\u9fa5]", "");
+            }
+            if (datetime.length() > 0) {
+                date = DateUtils.parseDate(datetime, dateFormats);
+            }
+        } catch (ParseException ex) {
+            ex.printStackTrace();
+        } finally {
+            return date;
+        }
+    }
+
+    public static String matRegx(String source, String regex1, String regex2, String val) {
+        if (isNotBlank(source) && isNotBlank(regex1) && isNotBlank(regex2)) {
+            Pattern pattern = Pattern.compile(regex1);
+            Matcher matcher = pattern.matcher(source);
+            if (matcher.find()) {
+                String sce1 = matcher.group();
+                if (isBlank(val) || !sce1.contains(val)) {
+                    String sce2 = sce1.replaceAll(regex2, val);
+                    source = source.replaceAll(sce1, sce2);
+                }
+            }
+        }
+        return source;
+    }
+
+    /**
+     * 去除字符串两边空白 包含一些特殊空格
+     *
+     * @param msg
+     * @return
+     */
+    public static String trim(String msg) {
+        if (isNotBlank(msg)) {
+            return org.springframework.util.StringUtils.trimWhitespace(msg).trim();
+        }
+        return msg;
+    }
+
+    /**
+     * 去掉尾部几位符合字符
+     *
+     * @param value
+     * @param regex
+     * @param len
+     * @return
+     */
+    public static String removeWN(String value, String regex, int len) {
+        String ret = value;
+        if (StringUtil.isNotBlank(value) && value.length() >= len) {
+            String endStr = null;
+            for (int i = len; i > 0; i--) {
+                endStr = value.substring(value.length() - len);
+                if (endStr.replaceAll(regex, "").length() == 0) {
+                    ret = value.substring(0, value.length() - len);
+                    break;
+                }
+            }
+        }
+        return ret;
+    }
+
 }