各种工具类和测试代码

biz-base/src/test/java/com/dayou/AddressParser.java

@@ -0,0 +1,59 @@
+package com.dayou;
+
+import com.dayou.dto.Address;
+import com.dayou.utils.AddressUtil;
+import com.dayou.utils.HouseDocumentUtil;
+
+import java.util.*;
+
+public class AddressParser {
+
+    public static void main(String[] args) {
+        String[] addresses = {
+//                "成都市武侯区双凤五路412号1栋2单元3层",
+//                "西安市未央区史蒂五路22号12栋33单元13层",
+//                "成都市青羊区双凤三路412号1栋2单元4层",
+//                "成都市武侯区双凤三路42号1栋2单元4层",
+//                "武侯区双凤五路412号1层",
+//                "武侯区双凤五路450号1层",
+//                "武侯区双凤五路470号1层",
+//                "武侯区金江路216号1层",
+//                "武侯区武兴路989号2层",
+//                "都江堰市玉堂镇青城水街北段255号1栋1单元1层1号",
+//                "都江堰市玉堂镇青城水街北段255号1栋1单元1层2号",
+//                "都江堰市玉堂镇青城水街北段255号1栋1单元1层3号",
+//                "高新区高棚东路18号1幢",
+//                "高新区新乐中街280号1栋-1层局部（共计142套）",
+//                "青羊区草堂路3号6栋1-3楼B1号",
+//                "武侯区晋阳街道晋阳村领秀别墅1栋1-3楼1号",
+//                "武侯区人民南路四段21号3栋3单元5层03号",
+//                "武侯区人民南路四段21号3栋3单元7层03号",
+//                "成都市武侯区双凤五路412号1层",
+//                "成都市武侯区双凤五路450号1层",
+//                "成都市武侯区双凤五路470号1层",
+//                "成都市武侯区金江路216号1层",
+//                "成都市武侯区武兴路989号2层",
+//                "都江堰市玉堂镇青城水街北段255号",
+//                "都江堰市玉堂镇青城水街北段257号",
+//                "都江堰市玉堂镇青城水街北段259号",
+//                "南充市阆中市缓缓路23号"
+                "武侯区晋阳街道晋阳村领秀别墅1栋1-3楼1号"
+
+        };
+        List<String> list = Arrays.asList(addresses);
+        try {
+            List<Address> list1 = new ArrayList<>();
+            list.stream().forEach(x -> {
+                Address parsedAddress = AddressUtil.parseAddress(x);
+                list1.add(parsedAddress);
+            });
+//            String s = HouseDocumentUtil.getProjectName(list1);
+            System.out.println(list1);
+        } catch (Exception e) {
+            System.err.println(e.getMessage());
+        }
+    }
+
+
+
+}

common/src/main/java/com/dayou/constants/TableHTML.java

@@ -43,11 +43,12 @@ public class TableHTML {
                     "</span></p>" +
                     "</td>";
 
-    public static final String TABLE_STYLE = "width:109.9%;border-collapse:collapse; border-spacing:0; empty-cells:show;";
+    public static final String TABLE_STYLE = "width:100%;border-collapse:collapse; border-spacing:0; empty-cells:show;";
 
-    public static final String TD_STYLE = "font-size:9px;border-top-style:solid; border-top-color:#000000; " +
-            "border-left-style:solid; border-left-color:#000000;border-bottom-style:solid; border-bottom-color:#000000;" +
-            "border-right-style:solid; border-right-color:#000000;background-color:transparent; padding-left:0.0035in; padding-right:0.0035in; padding-top:0in; padding-bottom:0in; " +
+
+    public static final String TD_STYLE = "font-size:12px;font-family:宋体; " +
+            "border:1px solid black; " +
+            "background-color:transparent; padding-left:0.0035in; padding-right:0.0035in; padding-top:0in; padding-bottom:0in; " +
             "vertical-align:middle;";
 
     public static String P_SPAN = "<p style = \"text-align: center; text-indent: 0em; line-height: normal;\" ><span style=\"text-align: -webkit-center; text-wrap: wrap;\">content</span> </p> " ;

common/src/main/java/com/dayou/utils/AddressUtil.java

@@ -0,0 +1,93 @@
+package com.dayou.utils;
+
+import com.dayou.dto.Address;
+
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+/**
+ * 行政地址工具类
+ */
+public class AddressUtil {
+
+    private static final Pattern PROVINCE_PATTERN = Pattern.compile("(?<province>.+省|.+自治区|.+市)");
+    private static final Pattern CITY_PATTERN = Pattern.compile("(?<city>.+市|.+自治州|.+盟)");
+    private static final Pattern DISTRICT_PATTERN = Pattern.compile("(?<district>.+区|.+县|.+旗)");
+    private static final Pattern TOWN_PATTERN = Pattern.compile("(?<town>.+街道|.+镇|.+乡)");
+    private static final Pattern COMMUNITY_PATTERN = Pattern.compile("(?<community>.+社区|.+村)");
+    private static final Pattern ROAD_PATTERN = Pattern.compile("(?<road>.+路.+?段|.+路|.+巷|.+?街.+?段|.+?街)");
+    private static final Pattern ROAD_NUMBER_PATTERN = Pattern.compile("(?<roadNumber>\\d+号)");
+    private static final Pattern BUILDING_PATTERN = Pattern.compile("(?<building>\\d+楼|\\d+栋|\\d+幢)");
+    private static final Pattern UNIT_PATTERN = Pattern.compile("(?<unit>\\d+单元)");
+    private static final Pattern FLOOR_PATTERN = Pattern.compile("(?<floor>-?\\d+层|-?\\d+楼)");
+    private static final Pattern ROOM_PATTERN = Pattern.compile("(?<room>\\d+室\\d+号|\\d+室|\\d+号)");
+
+    /**
+     *
+     * @param address 地址字符串
+     * @return 标准地址对象
+     */
+    public static Address parseAddress(String address) {
+        Address result = new Address();
+
+        // 依次匹配每个级别的地址部分，并从剩余字符串中继续解析
+        String remaining = address;
+        result.setProvince(extractAndRemove(PROVINCE_PATTERN, remaining));
+        remaining = removePrefix(remaining, result.getProvince());
+
+        result.setCity(extractAndRemove(CITY_PATTERN, remaining));
+        remaining = removePrefix(remaining, result.getCity());
+
+        result.setDistrict(extractAndRemove(DISTRICT_PATTERN, remaining));
+        remaining = removePrefix(remaining, result.getDistrict());
+
+        result.setTown(extractAndRemove(TOWN_PATTERN, remaining));
+        remaining = removePrefix(remaining, result.getTown());
+
+        result.setCommunity(extractAndRemove(COMMUNITY_PATTERN, remaining));
+        remaining = removePrefix(remaining, result.getCommunity());
+
+        result.setRoad(extractAndRemove(ROAD_PATTERN, remaining));
+        remaining = removePrefix(remaining, result.getRoad());
+
+        result.setRoadNumber(extractAndRemove(ROAD_NUMBER_PATTERN, remaining));
+        remaining = removePrefix(remaining, result.getRoadNumber());
+
+        result.setBuilding(extractAndRemove(BUILDING_PATTERN, remaining));
+        remaining = removePrefix(remaining, result.getBuilding());
+
+        result.setUnit(extractAndRemove(UNIT_PATTERN, remaining));
+        remaining = removePrefix(remaining, result.getUnit());
+
+        result.setFloor(extractAndRemove(FLOOR_PATTERN, remaining));
+        remaining = removePrefix(remaining, result.getFloor());
+
+        result.setRoom(extractAndRemove(ROOM_PATTERN, remaining));
+        remaining = removePrefix(remaining, result.getRoom());
+
+        return result;
+    }
+
+    public static List<Address> parseAddress(List<Object> addresses) {
+        return addresses.stream().map(addr -> {
+            return parseAddress((String) addr);
+        }).collect(Collectors.toList());
+    }
+
+    private static String extractAndRemove(Pattern pattern, String input) {
+        Matcher matcher = pattern.matcher(input);
+        if (matcher.find()) {
+            return matcher.group().trim();
+        }
+        return "";
+    }
+
+    private static String removePrefix(String input, String prefix) {
+        if (prefix == null || input == null) {
+            return input;
+        }
+        return input.replaceFirst(Pattern.quote(prefix), "").trim();
+    }
+}

common/src/main/java/com/dayou/utils/CollectionUtil.java

@@ -0,0 +1,78 @@
+package com.dayou.utils;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class CollectionUtil {
+
+    private static final String EN_DOT = ",";
+
+    private static final String ZH_DOT = "，";
+
+    private static final String ZH_STOP = "、";
+
+    private static final String ZH_SPLIT = "；";
+
+    /**
+     * 根据Map的value个数升序
+     * @param map
+     * @return
+     */
+    public static LinkedHashMap<String, ? extends List<?>> sortedByCounting(Map<String, ? extends List<?>> map ) {
+        // 使用 Stream API 排序
+        return map.entrySet().stream()
+                .sorted(Map.Entry.comparingByValue(Comparator.comparing(List::size)))
+                .collect(Collectors.toMap(
+                        Map.Entry::getKey,
+                        Map.Entry::getValue,
+                        (oldValue, newValue) -> oldValue, // 解决键冲突，这里不会发生因为键是唯一的
+                        LinkedHashMap::new
+                ));
+
+    }
+
+    /**
+     * 改逗号为分号然后去掉前后中括号
+     * @param collection
+     * @return
+     */
+    public static String formatSplitAndRemoveMiddle(Collection<?> collection){
+        return formatRemoveMiddle(formatZHSplit(collection));
+    }
+
+    /**
+     * 改逗号为顿号然后去掉前后中括号
+     * @param collection
+     * @return
+     */
+    public static String formatDotAndRemoveMiddle(Collection<?> collection){
+        return formatRemoveMiddle(formatZHStop(collection));
+    }
+
+    /**
+     * 格式化集合类型数据的中括号
+     * @param string
+     * @return
+     */
+    public static String formatRemoveMiddle(String string) {
+        return  string.replaceAll("^\\[|\\]$", "");
+    }
+
+    /**
+     * 英文逗号改为中文分号
+     * @param collection
+     * @return
+     */
+    public static String formatZHSplit(Collection<?> collection){
+       return  collection.toString().replaceAll(EN_DOT,ZH_SPLIT);
+    }
+
+    /**
+     * 英文逗号改为中文顿号
+     * @param collection
+     * @return
+     */
+    public static String formatZHStop(Collection<?> collection){
+        return  collection.toString().replaceAll(EN_DOT,ZH_STOP);
+    }
+}

common/src/main/java/com/dayou/utils/HouseDocumentUtil.java

@@ -1,13 +1,18 @@
 package com.dayou.utils;
 
-import cn.hutool.core.util.StrUtil;
 import cn.hutool.json.JSONArray;
 import cn.hutool.json.JSONObject;
+import com.dayou.dto.Address;
 import com.dayou.enums.HouseTargetTableColumn;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
+
+import static com.dayou.enums.HouseTargetTableColumn.*;
+import static com.dayou.utils.CollectionUtil.sortedByCounting;
 
 /**
  * 房地产报告相关工具类
@@ -23,11 +28,10 @@ public class HouseDocumentUtil {
         JSONArray targets = new JSONArray();
         if (jsonArray.size()>1){
             JSONObject jsonObject = (JSONObject) jsonArray.get(0);
-            @SuppressWarnings("unchecked")
             Set<String> columns = jsonObject.keySet();
             for (int i = 0; i < jsonArray.size(); i++){
                 JSONObject item  = (JSONObject) jsonArray.get(i);
-                if (item.get(HouseTargetTableColumn.LOCATION.getZhName())!=null
+                if (item.get(LOCATION.getZhName())!=null
                     && item.get(HouseTargetTableColumn.CERTIFICATE_NO.getZhName())!=null){
                     for (String key : columns){
                         if (item.get(key)==null || item.get(key)==""){
@@ -41,4 +45,168 @@ public class HouseDocumentUtil {
         }
         return targets;
     }
+
+    /**
+     * 格式化项目名称
+     * @param array
+     * @return
+     */
+    public static String getProjectName(JSONArray array){
+        List<Object> addresses = array.stream().map(obj -> ((JSONObject) obj).get(LOCATION.getZhName()))
+                .collect(Collectors.toList());
+        List<Address> addressList = AddressUtil.parseAddress(addresses);
+        return CollectionUtil.formatSplitAndRemoveMiddle(mergeAddress(addressList));
+    }
+
+    /**
+     * 格式化权利人
+     * @param array
+     * @return
+     */
+    public static String getOwnShipUser(JSONArray array){
+        Set<Object> ownShipUsers = array.stream().map(obj -> ((JSONObject) obj).get(OWE_SHIP_USER.getZhName()))
+                .collect(Collectors.toSet());
+        return CollectionUtil.formatDotAndRemoveMiddle(ownShipUsers);
+    }
+
+    /**
+     * 合并地址
+     * @param addressList
+     * @return
+     */
+    @SuppressWarnings("unchecked")
+    public static List<String> mergeAddress(List<Address> addressList){
+        List<String> result = new ArrayList<>();
+        //一级分组
+        Map<String, List<Address>> collect1 = addressList.stream().collect(Collectors.groupingBy(Address::getProvince));
+        collect1 = (Map<String, List<Address>>) sortedByCounting(collect1);
+        for (Map.Entry<String, List<Address>> entry1 : collect1.entrySet()) {
+            String province = entry1.getKey();
+            StringBuilder stringBuilder = new StringBuilder(province);
+            List<Address> addresses1 = entry1.getValue();
+            Map<String, List<Address>> collect2 = addresses1.stream().collect(Collectors.groupingBy(Address::getCity));
+            collect2 = (Map<String, List<Address>>) sortedByCounting(collect2);
+            int index2 = 0;
+            for (Map.Entry<String,List<Address>> entry2 : collect2.entrySet()){
+                if (collect2.size()>1 && index2!=0){
+                    stringBuilder.append("、");
+                }
+                String city = entry2.getKey();
+                stringBuilder.append(city);
+                List<Address> addresses2 = entry2.getValue();
+                Map<String, List<Address>> collect3 = addresses2.stream().collect(Collectors.groupingBy(Address::getDistrict));
+                collect3 = (Map<String, List<Address>>) sortedByCounting(collect3);
+                index2 ++;
+                int index3 = 0;
+                for (Map.Entry<String,List<Address>> entry3 : collect3.entrySet()){
+                    if (collect3.size()>1 && index3!=0){
+                        stringBuilder.append("、");
+                    }
+                    String district = entry3.getKey();
+                    stringBuilder.append(district);
+                    List<Address> addresses3 = entry3.getValue();
+                    Map<String, List<Address>> collect4 = addresses3.stream().collect(Collectors.groupingBy(Address::getTown));
+                    collect4 = (Map<String, List<Address>>) sortedByCounting(collect4);
+                    index3 ++;
+                    int index4 = 0;
+                    for (Map.Entry<String,List<Address>> entry4 : collect4.entrySet()){
+                        if (collect4.size()>1 && index4!=0){
+                            stringBuilder.append("、");
+                        }
+                        String town = entry4.getKey();
+                        stringBuilder.append(town);
+                        List<Address> addresses4 = entry4.getValue();
+                        Map<String, List<Address>> collect5 = addresses4.stream().collect(Collectors.groupingBy(Address::getCommunity));
+                        collect5 = (Map<String, List<Address>>) sortedByCounting(collect5);
+                        index4 ++;
+                        int index5 = 0;
+                        for (Map.Entry<String,List<Address>> entry5 : collect5.entrySet()){
+                            if (collect5.size()>1 && index5!=0){
+                                stringBuilder.append("、");
+                            }
+                            String community = entry5.getKey();
+                            stringBuilder.append(community);
+                            List<Address> addresses5 = entry5.getValue();
+                            Map<String, List<Address>> collect6 = addresses5.stream().collect(Collectors.groupingBy(Address::getRoad));
+                            collect6 = (Map<String, List<Address>>) sortedByCounting(collect6);
+                            index5 ++;
+                            int index6 = 0;
+                            for (Map.Entry<String,List<Address>> entry6 : collect6.entrySet()){
+                                if (collect6.size()>1 && index6!=0){
+                                    stringBuilder.append("、");
+                                }
+                                String road = entry6.getKey();
+                                stringBuilder.append(road);
+                                List<Address> addresses6 = entry6.getValue();
+                                Map<String, List<Address>> collect7 = addresses6.stream().collect(Collectors.groupingBy(Address::getRoadNumber));
+                                collect7 = (Map<String, List<Address>>) sortedByCounting(collect7);
+                                index6 ++;
+                                int index7 = 0;
+                                for (Map.Entry<String,List<Address>> entry7 : collect7.entrySet()){
+                                    if (collect7.size()>1 && index7!=0){
+                                        stringBuilder.append("、");
+                                    }
+                                    String roadNumber = entry7.getKey();
+                                    stringBuilder.append(roadNumber);
+                                    List<Address> addresses7 = entry7.getValue();
+                                    Map<String, List<Address>> collect8 = addresses7.stream().collect(Collectors.groupingBy(Address::getBuilding));
+                                    collect8 = (Map<String, List<Address>>) sortedByCounting(collect8);
+                                    index7 ++;
+                                    int index8 = 0;
+                                    for (Map.Entry<String,List<Address>> entry8 : collect8.entrySet()){
+                                        if (collect8.size()>1 && index8!=0){
+                                            stringBuilder.append("、");
+                                        }
+                                        String building = entry8.getKey();
+                                        stringBuilder.append(building);
+                                        List<Address> addresses8 = entry8.getValue();
+                                        Map<String, List<Address>> collect9 = addresses8.stream().collect(Collectors.groupingBy(Address::getUnit));
+                                        collect9 = (Map<String, List<Address>>) sortedByCounting(collect9);
+                                        index8 ++;
+                                        int index9 = 0;
+                                        for (Map.Entry<String,List<Address>> entry9 : collect9.entrySet()){
+                                            if (collect9.size()>1 && index9!=0){
+                                                stringBuilder.append("、");
+                                            }
+                                            String unit = entry9.getKey();
+                                            stringBuilder.append(unit);
+                                            List<Address> addresses9 = entry9.getValue();
+                                            Map<String, List<Address>> collect10 = addresses9.stream().collect(Collectors.groupingBy(Address::getFloor));
+                                            collect10 = (Map<String, List<Address>>) sortedByCounting(collect10);
+                                            index9 ++;
+                                            int index10 = 0;
+                                            for (Map.Entry<String,List<Address>> entry10 : collect10.entrySet()){
+                                                if (collect10.size()>1 && index10!=0){
+                                                    stringBuilder.append("、");
+                                                }
+                                                String floor = entry10.getKey();
+                                                stringBuilder.append(floor);
+                                                List<Address> addresses10 = entry10.getValue();
+                                                Map<String, List<Address>> collect11 = addresses10.stream().collect(Collectors.groupingBy(Address::getRoom));
+                                                collect11 = (Map<String, List<Address>>) sortedByCounting(collect11);
+                                                index10 ++;
+                                                int index11 = 0;
+                                                for (Map.Entry<String,List<Address>> entry11 : collect11.entrySet()){
+                                                    if (collect11.size()>1 && index11!=0){
+                                                        stringBuilder.append("、");
+                                                    }
+                                                    String room = entry11.getKey();
+                                                    stringBuilder.append(room);
+                                                    index11 ++;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                }
+
+            }
+            result.add(stringBuilder.toString());
+        }
+        return result;
+    }
 }

domain/src/main/java/com/dayou/doc/house/ConsignorLetterDO.java

@@ -0,0 +1,31 @@
+package com.dayou.doc.house;
+
+import lombok.Builder;
+import lombok.Data;
+
+/**
+ * 致委托人函 文档对象
+ */
+@Builder
+@Data
+public class ConsignorLetterDO {
+
+    private String projectName;
+
+    private String consignor;
+
+    private String ownshipUser;
+
+    private String appraiser1;
+
+    private String appraiser2;
+
+    private String appraNo1;
+
+    private String appraNo2;
+
+    private String docDate;
+
+    private String docNo;
+
+}

domain/src/main/java/com/dayou/dto/Address.java

@@ -0,0 +1,56 @@
+package com.dayou.dto;
+
+import lombok.Data;
+
+/**
+ * 标准地址
+ */
+@Data
+public class Address {
+
+    /**
+     * 省、自治区、省级市
+     */
+    private String province;
+    /**
+     * 地级市、自治州
+     */
+    private String city;
+    /**
+     * 区、县、旗
+     */
+    private String district;
+    /**
+     * 街道、乡、镇
+     */
+    private String town;
+    /**
+     * 社区、村
+     */
+    private String community;
+    /**
+     * 路、街、段、巷
+     */
+    private String road;
+    /**
+     * 路号
+     */
+    private String roadNumber;
+    /**
+     * 栋、幢、楼
+     */
+    private String building;
+    /**
+     * 单元
+     */
+    private String unit;
+    /**
+     * 层
+     */
+    private String floor;
+    /**
+     * 室、号
+     */
+    private String room;
+
+}

domain/src/main/java/com/dayou/enums/HouseTargetTableColumn.java

@@ -1,9 +1,12 @@
 package com.dayou.enums;
 
+import lombok.Getter;
+
 /**
  * 房地产报告估价对象一览表
  * 表头字段
  */
+@Getter
 public enum HouseTargetTableColumn {
 
     ID("ID","估价对象"),
@@ -32,11 +35,4 @@ public enum HouseTargetTableColumn {
 
     private String zhName;
 
-    public String getZhName() {
-        return zhName;
-    }
-
-    public String getCode() {
-        return code;
-    }
 }