add manual load data

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

 
 GET http://{{host}}/load
 
+### load data
+
+
+
+GET http://{{host}}/loadByAgencyIds?agencyIds=190084,196581
+
 ### load data

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

 import com.vcarecity.publish.api.ApiStatus;
 import com.vcarecity.publish.constants.ElasticConstant;
 import com.vcarecity.publish.elastic.service.ElasticLoadDataService;
+import com.vcarecity.publish.elastic.service.ElasticUpdateService;
+import com.vcarecity.publish.entity.UnitAgencyMergeEntity;
 import com.vcarecity.publish.pojo.dto.TotalResultDTO;
 import com.vcarecity.publish.pojo.dto.UnitAgencyDTO;
 import com.vcarecity.publish.pojo.dto.UnitIdDTO;
 import com.vcarecity.publish.pojo.query.UnitAgencyQuery;
 import com.vcarecity.publish.service.LoadDataStatusService;
+import com.vcarecity.publish.sql.service.AgencyService;
 import com.vcarecity.publish.sql.service.UnitService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
 
 import javax.validation.Valid;
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.List;
 
 /**
 
 
     private final UnitService unitService;
+    private final AgencyService agencyService;
     private final ElasticLoadDataService elasticLoadDataService;
+    private final ElasticUpdateService elasticUpdateService;
     private final LoadDataStatusService loadDataStatusService;
 
     public MainController(UnitService unitService,
                           ElasticLoadDataService elasticLoadDataService,
                           LoadDataStatusService loadDataStatusService,
-                          @Value("${app.index.reload}") Boolean reloadData) {
+                          @Value("${app.index.reload}") Boolean reloadData, AgencyService agencyService, ElasticUpdateService elasticUpdateService) {
         this.unitService = unitService;
         this.elasticLoadDataService = elasticLoadDataService;
         this.loadDataStatusService = loadDataStatusService;
+        this.agencyService = agencyService;
+        this.elasticUpdateService = elasticUpdateService;
 
         if (!reloadData) {
             // 不重新加载
 
     @SkipMethod
     @ResponseBody
-    @RequestMapping(value = "/load", method = {RequestMethod.GET, RequestMethod.POST})
+    @RequestMapping(value = "/set-load", method = {RequestMethod.GET, RequestMethod.POST})
     public ApiResult setLoaded() {
         loadDataStatusService.setStatus(LoadDataStatusService.DATA_STATUS_LOADED);
         return ApiResult.builder().status(20000).message("already load data success!").build();
     }
 
 
+    @ResponseBody
+    @RequestMapping(value = "/loadByAgencyIds", method = {RequestMethod.POST, RequestMethod.GET})
+    public ApiResult loadByAgencyIds(@RequestParam("agencyIds") String agencyIds) {
+        String[] split = agencyIds.split(",");
+        List<Long> ids = new ArrayList<>(split.length);
+        for (String s : split) {
+            try {
+                ids.add(Long.parseLong(s));
+            } catch (RuntimeException e) {
+                e.printStackTrace();
+            }
+        }
+        List<UnitAgencyMergeEntity> result = agencyService.loadByAgencyIds(ids);
+        if (result == null) {
+            return ApiResult.builder().status(ApiStatus.FAILED_CODE).build();
+        }
+        try {
+            elasticUpdateService.handlerDataChange("unitId", result);
+            return ApiResult.builder().status(ApiStatus.SUCCESS_CODE).build();
+        } catch (IOException e) {
+            e.printStackTrace();
+            return ApiResult.builder().status(40000).message(e.getMessage()).build();
+        }
+    }
+
+
     @PostMapping("/query-unit-agency")
     public ApiResult queryUnitAgency(@RequestBody @Valid UnitAgencyQuery unitAgencyQuery) throws IOException {
 

elastic-publish-service/src/main/java/com/vcarecity/publish/mapper/AgencyMapper.java

 
 
     /**
+     * load by ids
+     *
+     * @param ids
+     * @return
+     */
+    List<UnitAgencyMergeEntity> loadByAgencyIds(@Param("ids") List<Long> ids);
+
+
+    /**
      * 获取ID对应的AgencyName
      *
      * @param agencyPathIds
      * @return
      */
     List<AgencyEntity> findAgencyNameByAgencyIdList(@Param("agencyPathIds") List<Integer> agencyPathIds);
+
 }

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

 package com.vcarecity.publish.sql.service;
 
+import com.vcarecity.publish.entity.UnitAgencyMergeEntity;
+
 import java.util.List;
 
 /**
      * @return
      */
     List<String> getAgencyPathDetail(List<Integer> agencyPath);
+
+    /**
+     * load by id
+     *
+     * @param ids
+     * @return
+     */
+    List<UnitAgencyMergeEntity> loadByAgencyIds(List<Long> ids);
 }

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

 package com.vcarecity.publish.sql.service.impl;
 
 import com.vcarecity.publish.entity.AgencyEntity;
+import com.vcarecity.publish.entity.UnitAgencyMergeEntity;
 import com.vcarecity.publish.mapper.AgencyMapper;
 import com.vcarecity.publish.sql.service.AgencyService;
 import org.springframework.stereotype.Service;
         List<AgencyEntity> agencyNameByAgencyIdList = agencyMapper.findAgencyNameByAgencyIdList(agencyPath);
         return agencyNameByAgencyIdList.stream().map(AgencyEntity::getAgencyName).collect(Collectors.toList());
     }
+
+    @Override
+    public List<UnitAgencyMergeEntity> loadByAgencyIds(List<Long> ids) {
+        if (ids == null || ids.isEmpty()) {
+            return null;
+        }
+        return agencyMapper.loadByAgencyIds(ids);
+
+    }
 }

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

   port: 8092
 spring:
   datasource:
-    url: jdbc:mysql:replication://192.168.10.210:6446,192.168.10.210:6447/fmmp?serverTimezone=Asia/Shanghai
+    url: jdbc:mysql:replication://192.168.10.31:6446,192.168.10.31:6447/fmmp?serverTimezone=Asia/Shanghai
     username: root
     password: R00T@mysql
+    hikari:
+      connection-test-query: select 1
   elasticsearch:
     rest:
       uris:
 app:
   index:
     config: index-text
-    reload: true
+    reload: false
   scheduling:
-    enable: false
+    enable: true

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

 spring:
   profiles:
-    active: dev
+    #active: dev
     #active: beta
-    #active: production
+    active: production

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

                  INNER JOIN T_AGENCY_EXTEND TAE ON TAE.AGENCY_ID = TU.AGENCY_ID
     </select>
 
+    <select id="loadByAgencyIds" resultMap="unitAgencyMergeEntityMap">
+        SELECT TU.UNIT_ID,
+        TU.DTU_NO,
+        TU.PUSER_CODE,
+        TU.USER_CODE,
+        TU.POSITIONS,
+        TU.UPDATESTAMP UNIT_UPDATE_STAMP,
+        TAG.AGENCY_ID,
+        TAG.AGENCY_PATH,
+        TAG.AGENCY_NAME,
+        TAG.ISDELETED,
+        TB.BUILDING_ID,
+        TB.NAME_OF_BUILDING,
+        TUT.UNIT_TYPE_ID,
+        TUT.UNIT_TYPE,
+        TUT.PROPERTY,
+        TUT.CLASSIFY,
+        TAE.REGULATORY_LEVEL_ID,
+        TAE.AGENCY_ATTRIBUTE_CLASS_ID
+        FROM (select *
+        from T_AGENCY I_TAG
+        <where>
+            where I_TAG.AGENCY_ID in
+            <foreach item="item" index="index" collection="ids" open="(" separator="," close=")">
+                　　　　${item}
+            </foreach>
+        </where>
+        ) TAG
+        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">
         select AGENCY_NAME,AGENCY_ID from T_AGENCY
         <where>

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

 package com.vcarecity.publish.mapper;
 
 import com.vcarecity.publish.entity.AgencyEntity;
+import com.vcarecity.publish.entity.UnitAgencyMergeEntity;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
             System.out.println(agencyEntity);
         }
     }
+
+    @Test
+    public void loadByAgencyIds() {
+        List<Long> ids = new ArrayList<>();
+        ids.add(80424L);
+
+        List<UnitAgencyMergeEntity> unitAgencyMergeEntities = agencyMapper.loadByAgencyIds(ids);
+        for (UnitAgencyMergeEntity unitAgencyMergeEntity : unitAgencyMergeEntities) {
+            System.out.println(unitAgencyMergeEntity);
+        }
+    }
 }