ADD req fields

elastic-publish-service/req/main-controller.http

   "agencyPath": "/1",
   "keyword": "鱼峰区",
   "page": 2,
-  "size": 10
+  "size": 10,
+  "regulatoryLevelId": "27,28",
+  "property": "",
+  "classify": "",
+  "agencyAttributeClassId": ""
 }
 
 ### unitId 信息
   "agencyPath": "/1",
   "keyword": "鱼峰区",
   "page": 2,
-  "size": 10
+  "size": 10,
+  "regulatoryLevelId": "27,28",
+  "property": "",
+  "classify": "",
+  "agencyAttributeClassId": ""
 }
 
 ### 详情信息

elastic-publish-service/src/main/java/com/vcarecity/publish/ElasticPublishApplication.java

 import org.mybatis.spring.annotation.MapperScan;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.scheduling.annotation.EnableScheduling;
 
 /**
  * @author Kerry on 19/12/11
  */
 
 
-@EnableScheduling
 @MapperScan("com.vcarecity.publish.mapper")
 @SpringBootApplication
 public class ElasticPublishApplication {

elastic-publish-service/src/main/java/com/vcarecity/publish/config/MapperConfig.java

 package com.vcarecity.publish.config;
 
-import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.springframework.context.annotation.Bean;
     @Bean
     public ObjectMapper objectMapper() {
         ObjectMapper objectMapper = new ObjectMapper();
-        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+        // objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
         objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
         return objectMapper;
     }

elastic-publish-service/src/main/java/com/vcarecity/publish/config/SchedulingConfiguration.java

+package com.vcarecity.publish.config;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.annotation.EnableScheduling;
+
+@ConditionalOnProperty(value = "app.scheduling.enable", havingValue = "true", matchIfMissing = true)
+@Configuration
+@EnableScheduling
+public class SchedulingConfiguration {
+}

elastic-publish-service/src/main/java/com/vcarecity/publish/controller/MainController.java

 
     @PostMapping("/query-unit-agency")
     public ApiResult queryUnitAgency(@RequestBody @Valid UnitAgencyQuery unitAgencyQuery) throws IOException {
-        final List<UnitAgencyDTO> unitAgencyByQuery = unitService.getUnitAgencyByQuery(unitAgencyQuery.getAgencyPath(), unitAgencyQuery.getKeyword(),
-                unitAgencyQuery.getPage(), unitAgencyQuery.getSize(), ElasticConstant.UNIT_AGENCY_INDEX);
+        final List<UnitAgencyDTO> unitAgencyByQuery = unitService.getUnitAgencyByQuery(unitAgencyQuery, ElasticConstant.UNIT_AGENCY_INDEX);
+
         List<Long> data = unitAgencyByQuery.stream().map(UnitAgencyDTO::getUnitId).collect(Collectors.toList());
         return ApiResult.builder().status(ApiStatus.SUCCESS_CODE).data(data).build();
     }
 
     @PostMapping("/test/query-unit-agency")
     public ApiResult testQueryUnitAgency(@RequestBody @Valid UnitAgencyQuery unitAgencyQuery) throws IOException {
-        List<UnitAgencyDTO> data = unitService.getUnitAgencyByQuery(unitAgencyQuery.getAgencyPath(), unitAgencyQuery.getKeyword(),
-                unitAgencyQuery.getPage(), unitAgencyQuery.getSize(), ElasticConstant.UNIT_AGENCY_INDEX);
+        List<UnitAgencyDTO> data = unitService.getUnitAgencyByQuery(unitAgencyQuery, ElasticConstant.UNIT_AGENCY_INDEX);
         return ApiResult.builder().status(ApiStatus.SUCCESS_CODE).data(data).build();
     }
 

elastic-publish-service/src/main/java/com/vcarecity/publish/elastic/service/ElasticIndexService.java

 package com.vcarecity.publish.elastic.service;
 
+import java.io.IOException;
 import java.util.List;
 
 /**
 
     /**
      * index 是否存在
+     * <a href="https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-indices-exists.html">
+     * API
+     * </a>
      *
      * @param index
      * @return
+     * @throws IOException
      */
-    boolean indexExist(String index);
+    boolean indexExist(String index) throws IOException;
 
     /**
      * create index
     /**
      * delete index
      *
+     * <a href="https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-delete-index.html">
+     * API
+     * </a>
+     *
      * @param indices
+     * @throws IOException
      */
-    void deleteIndex(String... indices);
+    void deleteIndex(String... indices) throws IOException;
 
 
     /**

elastic-publish-service/src/main/java/com/vcarecity/publish/elastic/service/ElasticQueryService.java

 package com.vcarecity.publish.elastic.service;
 
+import java.io.IOException;
+
 /**
  * @author VcKerry on 12/17/19
  */
 
 public interface ElasticQueryService {
 
+    /**
+     * for test
+     *
+     * @throws IOException
+     */
+    void testQuery() throws IOException;
 
 }

elastic-publish-service/src/main/java/com/vcarecity/publish/elastic/service/impl/ElasticIndexServiceImpl.java

 package com.vcarecity.publish.elastic.service.impl;
 
 import com.vcarecity.publish.elastic.service.ElasticIndexService;
+import lombok.extern.slf4j.Slf4j;
+import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
+import org.elasticsearch.client.RequestOptions;
 import org.elasticsearch.client.RestHighLevelClient;
+import org.elasticsearch.client.indices.GetIndexRequest;
 import org.springframework.stereotype.Service;
 
+import java.io.IOException;
 import java.util.List;
 
 /**
  * @author kerryzhang on 2019/12/17
  */
 
+@Slf4j
 @Service
 public class ElasticIndexServiceImpl implements ElasticIndexService {
 
     }
 
     @Override
-    public boolean indexExist(String index) {
-
-        return false;
+    public boolean indexExist(String index) throws IOException {
+        GetIndexRequest request = new GetIndexRequest(index);
+        return restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
     }
 
     @Override
     }
 
     @Override
-    public void deleteIndex(String... indices) {
-
+    public void deleteIndex(String... indices) throws IOException {
+        logger.warn("delete elastic index = {}", indices);
+        DeleteIndexRequest request = new DeleteIndexRequest(indices);
+        restHighLevelClient.indices().delete(request, RequestOptions.DEFAULT);
     }
 
     @Override

elastic-publish-service/src/main/java/com/vcarecity/publish/elastic/service/impl/ElasticLoadDataServiceImpl.java

 package com.vcarecity.publish.elastic.service.impl;
 
 import com.vcarecity.publish.constants.ElasticConstant;
+import com.vcarecity.publish.elastic.service.ElasticIndexService;
 import com.vcarecity.publish.elastic.service.ElasticLoadDataService;
 import com.vcarecity.publish.elastic.service.ElasticUpdateService;
 import com.vcarecity.publish.entity.UnitAgencyMergeEntity;
 
     private final UnitMapper unitMapper;
     private final ElasticUpdateService elasticUpdateService;
+    private final ElasticIndexService elasticIndexService;
     private final int pageCount;
 
     public ElasticLoadDataServiceImpl(UnitMapper unitMapper,
-                                      ElasticUpdateService elasticUpdateService) {
+                                      ElasticUpdateService elasticUpdateService,
+                                      ElasticIndexService elasticIndexService) {
         this.unitMapper = unitMapper;
         this.elasticUpdateService = elasticUpdateService;
+        this.elasticIndexService = elasticIndexService;
         this.pageCount = ElasticConstant.QUERY_PAGE_COUNT;
     }
 
     @Override
     public void loadData() throws IOException {
 
+        boolean exist = elasticIndexService.indexExist(ElasticConstant.UNIT_AGENCY_INDEX);
+        if (exist) {
+            logger.warn("elastic index = [{}] already exits", ElasticConstant.UNIT_AGENCY_INDEX);
+            elasticIndexService.deleteIndex(ElasticConstant.UNIT_AGENCY_INDEX);
+        }
+
         long allTime = System.currentTimeMillis();
 
         // calc handler count

elastic-publish-service/src/main/java/com/vcarecity/publish/elastic/service/impl/ElasticQueryServiceImpl.java

 package com.vcarecity.publish.elastic.service.impl;
 
+import com.vcarecity.publish.constants.ElasticConstant;
 import com.vcarecity.publish.elastic.service.ElasticQueryService;
+import lombok.extern.slf4j.Slf4j;
+import org.elasticsearch.action.search.SearchRequest;
+import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.client.RequestOptions;
+import org.elasticsearch.client.RestHighLevelClient;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.index.query.TermQueryBuilder;
+import org.elasticsearch.search.SearchHit;
+import org.elasticsearch.search.builder.SearchSourceBuilder;
 import org.springframework.stereotype.Service;
 
-import java.util.List;
+import java.io.IOException;
 
 /**
  * @author VcKerry on 12/17/19
  */
 
+@Slf4j
 @Service
 public class ElasticQueryServiceImpl implements ElasticQueryService {
 
+    private final RestHighLevelClient restHighLevelClient;
+
+    public ElasticQueryServiceImpl(RestHighLevelClient restHighLevelClient) {
+        this.restHighLevelClient = restHighLevelClient;
+    }
+
+    @Override
+    public void testQuery() throws IOException {
+
+        TermQueryBuilder unitId = QueryBuilders.termQuery("unitId", 39746);
+
+
+        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
+        searchSourceBuilder.query(unitId);
+
+
+        SearchRequest request = new SearchRequest(ElasticConstant.UNIT_AGENCY_INDEX);
+        request.source(searchSourceBuilder);
+
+        SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
+        for (SearchHit hit : response.getHits()) {
+            logger.debug("{}", hit.getSourceAsString());
+        }
+
+    }
 }

elastic-publish-service/src/main/java/com/vcarecity/publish/elastic/service/impl/ElasticUpdateServiceImpl.java

 package com.vcarecity.publish.elastic.service.impl;
 
+import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.vcarecity.elastic.util.AgencyPathUtil;
 import com.vcarecity.elastic.util.SnowFlake;
     private final AgencyService agencyService;
 
     public ElasticUpdateServiceImpl(RestHighLevelClient restHighLevelClient,
-                                    ObjectMapper objectMapper,
                                     AgencyService agencyService) {
         this.restHighLevelClient = restHighLevelClient;
-        this.objectMapper = objectMapper;
         this.agencyService = agencyService;
 
+        ObjectMapper objectMapper = new ObjectMapper();
+        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+
+        this.objectMapper = objectMapper;
         this.index = ElasticConstant.UNIT_AGENCY_INDEX;
     }
 

elastic-publish-service/src/main/java/com/vcarecity/publish/entity/UnitAgencyMergeEntity.java

     private String unitType;
 
     private Integer isDeleted;
+
+    private Integer property;
+
+    private Integer classify;
+
+    private Integer regulatoryLevelId;
+
+    private Integer agencyAttributeClassId;
 }

elastic-publish-service/src/main/java/com/vcarecity/publish/pojo/dto/UnitAgencyDTO.java

     private String agencyName;
     private String agencyDetail;
     private String nameOfBuilding;
+    private Long classify;
+    private Long property;
+    private Long regulatoryLevelId;
+    private Long agencyAttributeClassId;
 }

elastic-publish-service/src/main/java/com/vcarecity/publish/pojo/query/UnitAgencyQuery.java

     @Min(1)
     private int size = 100;
 
+    private String property;
+    private String classify;
+    private String regulatoryLevelId;
+    private String agencyAttributeClassId;
+
 }

elastic-publish-service/src/main/java/com/vcarecity/publish/sql/service/UnitService.java

 package com.vcarecity.publish.sql.service;
 
 import com.vcarecity.publish.pojo.dto.UnitAgencyDTO;
+import com.vcarecity.publish.pojo.query.UnitAgencyQuery;
 
 import java.io.IOException;
 import java.util.List;
     /**
      * test
      *
-     * @param agencyPath
-     * @param inputKeyword
-     * @param page
-     * @param size
+     * @param queryParam
      * @param indices
      * @return
      * @throws IOException
      */
-    List<UnitAgencyDTO> getUnitAgencyByQuery(String agencyPath, String inputKeyword, int page, int size, String... indices) throws IOException;
+    List<UnitAgencyDTO> getUnitAgencyByQuery(UnitAgencyQuery queryParam, String... indices) throws IOException;
 
 }

elastic-publish-service/src/main/java/com/vcarecity/publish/sql/service/impl/UnitServiceImpl.java

 package com.vcarecity.publish.sql.service.impl;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.vcarecity.elastic.util.AgencyPathUtil;
 import com.vcarecity.publish.pojo.dto.UnitAgencyDTO;
+import com.vcarecity.publish.pojo.query.UnitAgencyQuery;
 import com.vcarecity.publish.sql.service.UnitService;
-import com.vcarecity.elastic.util.AgencyPathUtil;
+import com.vcarecity.publish.util.Utils;
 import lombok.extern.slf4j.Slf4j;
 import org.elasticsearch.action.search.SearchRequest;
 import org.elasticsearch.action.search.SearchResponse;
 import org.elasticsearch.client.RequestOptions;
 import org.elasticsearch.client.RestHighLevelClient;
-import org.elasticsearch.index.query.BoolQueryBuilder;
-import org.elasticsearch.index.query.QueryBuilder;
-import org.elasticsearch.index.query.QueryBuilders;
-import org.elasticsearch.index.query.TermQueryBuilder;
+import org.elasticsearch.index.query.*;
 import org.elasticsearch.search.SearchHit;
 import org.elasticsearch.search.SearchHits;
 import org.elasticsearch.search.builder.SearchSourceBuilder;
 import org.springframework.stereotype.Service;
 
 import java.io.IOException;
+import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
     private final RestHighLevelClient restHighLevelClient;
     private final ObjectMapper objectMapper;
 
-    static final String[] keyNames = new String[]{
+    static final String[] SEARCH_KEY_NAMES = new String[]{
             "agencyName.keyword",
             "agencyDetail.keyword",
             "unitType.keyword",
             "nameOfBuilding.keyword",
     };
 
-    static String[] queryColumns = new String[]{"unitId", "nameOfBuilding", "agencyDetail", "agencyName"};
+    static final String[] MATCH_KEY_NAMES = new String[]{
+            "agencyAttributeClassId",
+            "regulatoryLevelId",
+            "property",
+            "classify"
+    };
+
+    static String[] queryColumns = new String[]{"unitId", "nameOfBuilding", "agencyDetail", "agencyName", "agencyAttributeClassId", "regulatoryLevelId", "property", "classify"};
 
     public UnitServiceImpl(RestHighLevelClient restHighLevelClient,
                            ObjectMapper objectMapper) {
     }
 
     @Override
-    public List<UnitAgencyDTO> getUnitAgencyByQuery(String agencyPath, String inputKeyword, int page, int size, String... indices) throws IOException {
-        List<Integer> agencyIdList = AgencyPathUtil.splitAgencyId(agencyPath);
+    public List<UnitAgencyDTO> getUnitAgencyByQuery(UnitAgencyQuery queryParam, String... indices) throws IOException {
+        List<Integer> agencyIdList = AgencyPathUtil.splitAgencyId(queryParam.getAgencyPath());
         if (agencyIdList.isEmpty()) {
             return Collections.emptyList();
         }
         QueryBuilder agencyIdBoolQuery = agencyIdListCondition(agencyIdList);
-        QueryBuilder keywordBoolQuery = multiInputParamKeywordBool(inputKeyword);
+        QueryBuilder keywordBoolQuery = multiInputParamKeywordBool(queryParam.getKeyword());
 
         BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery().must(agencyIdBoolQuery);
 
             queryBuilder.must(keywordBoolQuery);
         }
 
+        List<QueryBuilder> queryBuilders = arrayParamQuery(queryParam);
+        for (QueryBuilder builder : queryBuilders) {
+            queryBuilder.must(builder);
+        }
+
+        int from = (queryParam.getPage() - 1) * queryParam.getSize();
 
         SearchRequest searchRequest = new SearchRequest();
         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
         searchSourceBuilder.query(queryBuilder);
         searchSourceBuilder.fetchSource(queryColumns, new String[]{});
-        searchSourceBuilder.from((page - 1) * size);
-        searchSourceBuilder.size(size);
+        searchSourceBuilder.from(from);
+        searchSourceBuilder.size(queryParam.getSize());
         searchRequest.source(searchSourceBuilder);
         searchRequest.indices(indices);
 
 
         final BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
 
-        for (String kn : keyNames) {
+        for (String kn : SEARCH_KEY_NAMES) {
             QueryBuilder queryBuilder = QueryBuilders.wildcardQuery(kn, "*" + keyword + "*");
             // QueryBuilder queryBuilder = QueryBuilders.matchQuery(kn, keyword);
             boolQueryBuilder.should(queryBuilder);
         return boolQueryBuilder;
     }
 
+
+    private List<QueryBuilder> arrayParamQuery(UnitAgencyQuery queryParam) {
+        List<QueryBuilder> queryArray = new ArrayList<>(MATCH_KEY_NAMES.length);
+
+        for (String matchKeyName : MATCH_KEY_NAMES) {
+
+            Object value = null;
+            try {
+                Field declaredField = UnitAgencyQuery.class.getDeclaredField(matchKeyName);
+                declaredField.setAccessible(true);
+                value = declaredField.get(queryParam);
+
+            } catch (NoSuchFieldException | IllegalAccessException e) {
+                e.printStackTrace();
+            }
+            if (value == null) {
+                continue;
+            }
+            String listString = value.toString();
+            int[] ints = Utils.paramToArray(listString);
+            if (ints.length == 1) {
+                TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery(matchKeyName, ints[0]);
+                queryArray.add(termQueryBuilder);
+            } else if (ints.length > 1) {
+                TermsQueryBuilder termsQueryBuilder = QueryBuilders.termsQuery(matchKeyName, ints);
+                queryArray.add(termsQueryBuilder);
+            }
+
+        }
+
+        return queryArray;
+    }
+
 }

elastic-publish-service/src/main/java/com/vcarecity/publish/util/Utils.java

+package com.vcarecity.publish.util;
+
+/**
+ * @author VcKerry on 12/19/19
+ */
+
+public class Utils {
+
+    public static final int[] EMPTY_PARAM = new int[0];
+
+    public static int[] paramToArray(String input) {
+        if (input == null) {
+            return EMPTY_PARAM;
+        }
+        input = input.trim();
+        if (input.length() == 0) {
+            return EMPTY_PARAM;
+        }
+
+        String[] split = input.split(",");
+        if (split.length == 0) {
+            return EMPTY_PARAM;
+        }
+        int[] res = new int[split.length];
+        for (int i = 0; i < split.length; i++) {
+            res[i] = Integer.parseInt(split[i]);
+        }
+        return res;
+    }
+
+
+}

elastic-publish-service/src/main/resources/application-dev.yml

     host: 192.168.10.112
     port: 6379
     password: admin~1(^-^)
-logging:
-  level:
-    com:
-      vcarecity: debug
 mybatis:
   type-aliases-package: com.vcarecity.publish.entity
   mapper-locations: classpath:mapper/*.xml
-
+  configuration:
+    map-underscore-to-camel-case: true
 debug: true
+app:
+  scheduling:
+    enable: false

elastic-publish-service/src/main/resources/logback-spring.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<configuration scan="true" scanPeriod="120 seconds">
+
+    <!--spring-boot-2.0.3.RELEASE.jar!/org/springframework/boot/logging/logback/defaults.xml-->
+    <include resource="org/springframework/boot/logging/logback/defaults.xml"/>
+
+
+    <!--默认 Appender-->
+    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>${CONSOLE_LOG_PATTERN}</pattern>
+            <charset>utf8</charset>
+        </encoder>
+    </appender>
+
+
+    <root level="INFO">
+        <appender-ref ref="CONSOLE"/>
+    </root>
+
+
+    <springProfile name="dev">
+
+
+        <logger name="com.vcarecity" level="DEBUG" additivity="false">
+            <appender-ref ref="CONSOLE"/>
+        </logger>
+
+
+        <logger name="com.vcarecity.publish.mapper.AgencyMapper" level="INFO" additivity="false">
+            <appender-ref ref="CONSOLE"/>
+        </logger>
+
+
+    </springProfile>
+
+
+</configuration>

elastic-publish-service/src/main/resources/mapper/AgencyMapper.xml

         <result column="NAME_OF_BUILDING" property="nameOfBuilding"/>
         <result column="UNIT_TYPE_ID" property="unitTypeId"/>
         <result column="UNIT_TYPE" property="unitType"/>
+        <result column="PROPERTY" property="property"/>
+        <result column="CLASSIFY" property="classify"/>
+        <result column="REGULATORY_LEVEL_ID" property="regulatoryLevelId"/>
+        <result column="AGENCY_ATTRIBUTE_CLASS_ID" property="agencyAttributeClassId"/>
     </resultMap>
 
 
                TB.BUILDING_ID,
                TB.NAME_OF_BUILDING,
                TUT.UNIT_TYPE_ID,
-               TUT.UNIT_TYPE
+               TUT.UNIT_TYPE,
+               TUT.PROPERTY,
+               TUT.CLASSIFY,
+               TAE.REGULATORY_LEVEL_ID,
+               TAE.AGENCY_ATTRIBUTE_CLASS_ID
         FROM (select *
               from T_AGENCY I_TAG
               where UPDATESTAMP between '${fromDate}' and '${toDate}'
                  INNER JOIN T_UNIT TU ON TU.AGENCY_ID = TAG.AGENCY_ID
                  INNER JOIN T_BUILDING TB ON TB.BUILDING_ID = TU.BUILDING_ID
                  INNER JOIN T_UNIT_TYPE TUT ON TUT.UNIT_TYPE_ID = TU.UNIT_TYPE_ID
+                 INNER JOIN T_AGENCY_EXTEND TAE ON TAE.AGENCY_ID = TU.AGENCY_ID
     </select>
 
     <select id="findAgencyNameByAgencyIdList" resultType="agencyEntity" parameterType="list">

elastic-publish-service/src/main/resources/mapper/UnitMapper.xml

         <result column="NAME_OF_BUILDING" property="nameOfBuilding"/>
         <result column="UNIT_TYPE_ID" property="unitTypeId"/>
         <result column="UNIT_TYPE" property="unitType"/>
+        <result column="PROPERTY" property="property"/>
+        <result column="CLASSIFY" property="classify"/>
+        <result column="REGULATORY_LEVEL_ID" property="regulatoryLevelId"/>
+        <result column="AGENCY_ATTRIBUTE_CLASS_ID" property="agencyAttributeClassId"/>
     </resultMap>
 
     <select id="findUpdateList" resultType="unitEntity">
                TB.BUILDING_ID,
                TB.NAME_OF_BUILDING,
                TUT.UNIT_TYPE_ID,
-               TUT.UNIT_TYPE
+               TUT.UNIT_TYPE,
+               TUT.PROPERTY,
+               TUT.CLASSIFY,
+               TAE.REGULATORY_LEVEL_ID,
+               TAE.AGENCY_ATTRIBUTE_CLASS_ID
         FROM (select *
               from T_UNIT I_TU
               where UPDATESTAMP between '${fromDate}' and '${toDate}'
                  INNER JOIN T_AGENCY TAG ON TU.AGENCY_ID = TAG.AGENCY_ID
                  INNER JOIN T_BUILDING TB ON TB.BUILDING_ID = TU.BUILDING_ID
                  INNER JOIN T_UNIT_TYPE TUT ON TUT.UNIT_TYPE_ID = TU.UNIT_TYPE_ID
+                 INNER JOIN T_AGENCY_EXTEND TAE ON TAE.AGENCY_ID = TU.AGENCY_ID
     </select>
 
-    <select id="findAllWithPage" resultType="unitAgencyMergeEntity">
+    <select id="findAllWithPage" resultMap="unitAgencyMergeEntityMap">
         SELECT TU.UNIT_ID,
                TU.DTU_NO,
                TU.PUSER_CODE,
                TB.BUILDING_ID,
                TB.NAME_OF_BUILDING,
                TUT.UNIT_TYPE_ID,
-               TUT.UNIT_TYPE
+               TUT.UNIT_TYPE,
+               TUT.PROPERTY,
+               TUT.CLASSIFY,
+               TAE.REGULATORY_LEVEL_ID,
+               TAE.AGENCY_ATTRIBUTE_CLASS_ID
         FROM T_UNIT TU
                  INNER JOIN T_AGENCY TAG ON TU.AGENCY_ID = TAG.AGENCY_ID AND TU.ISDELETED = 0
                  INNER JOIN T_BUILDING TB ON TB.BUILDING_ID = TU.BUILDING_ID
                  INNER JOIN T_UNIT_TYPE TUT ON TUT.UNIT_TYPE_ID = TU.UNIT_TYPE_ID
-        limit ?,?
+                 INNER JOIN T_AGENCY_EXTEND TAE ON TAE.AGENCY_ID = TU.AGENCY_ID
+        limit ${page},${size}
     </select>
 </mapper>

elastic-publish-service/src/test/java/com/vcarecity/publish/config/MapperConfigTest.java

+package com.vcarecity.publish.config;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.vcarecity.publish.entity.AgencyEntity;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Type;
+import java.util.Map;
+
+class MapperConfigTest {
+    @Test
+    public void objectMapper() throws Exception {
+        ObjectMapper objectMapper = new ObjectMapper();
+        // objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+
+
+        AgencyEntity ae = new AgencyEntity();
+        ae.setAgencyId(11L);
+        ae.setIsDeleted(0);
+
+        String s = objectMapper.writeValueAsString(ae);
+        System.out.println(s);
+
+        Map<String, Object> map = objectMapper.convertValue(ae, new TypeReference<Map<String, Object>>() {
+            @Override
+            public Type getType() {
+                return super.getType();
+            }
+        });
+        System.out.println(map);
+
+        String value = "{\"agencyId\":11,\"agencyPath\":null,\"agencyName\":null,\"isDeleted\":0}";
+
+        AgencyEntity agencyEntity = objectMapper.readValue(value, AgencyEntity.class);
+        System.out.println(agencyEntity);
+
+    }
+}

elastic-publish-service/src/test/java/com/vcarecity/publish/elastic/service/impl/ElasticLoadDataServiceImplTest.java

+package com.vcarecity.publish.elastic.service.impl;
+
+import com.vcarecity.publish.elastic.service.ElasticLoadDataService;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.io.IOException;
+
+@SpringBootTest
+class ElasticLoadDataServiceImplTest {
+
+    @Autowired
+    private ElasticLoadDataService elasticLoadDataService;
+
+    @Test
+    void loadData() throws IOException {
+        elasticLoadDataService.loadData();
+    }
+}

elastic-publish-service/src/test/java/com/vcarecity/publish/elastic/service/impl/ElasticQueryServiceImplTest.java

+package com.vcarecity.publish.elastic.service.impl;
+
+import com.vcarecity.publish.elastic.service.ElasticQueryService;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.io.IOException;
+
+
+@SpringBootTest
+class ElasticQueryServiceImplTest {
+
+    @Autowired
+    private ElasticQueryService elasticQueryService;
+
+    @Test
+    void testQuery() throws IOException {
+        elasticQueryService.testQuery();
+    }
+}

elastic-publish-service/src/test/java/com/vcarecity/publish/mapper/AgencyMapperTest.java

 package com.vcarecity.publish.mapper;
 
+import com.vcarecity.publish.entity.AgencyEntity;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.TestPropertySource;
 
+import java.util.ArrayList;
+import java.util.List;
+
+@TestPropertySource(properties = "app.scheduling.enable=false")
 @SpringBootTest
 public class AgencyMapperTest {
 
 
         agencyMapper.findUpdateUaList(from, to);
     }
+
+    @Test
+    public void findAgencyNameByAgencyIdList() {
+        List<Integer> id = new ArrayList<>();
+        id.add(1);
+        id.add(297);
+        id.add(80424);
+        List<AgencyEntity> agencyNameByAgencyIdList = agencyMapper.findAgencyNameByAgencyIdList(id);
+        for (AgencyEntity agencyEntity : agencyNameByAgencyIdList) {
+            System.out.println(agencyEntity);
+        }
+    }
 }

elastic-publish-service/src/test/java/com/vcarecity/publish/service/impl/ElasticUpdateServiceImplTest.java

     @Autowired
     private ElasticUpdateService elasticUpdateService;
 
+
     @Test
     void updateTest() throws Exception {
+
         elasticUpdateService.updateTest();
+
     }