refactor(jg): 优化工业管道单位变更业务逻辑

amos-boot-system-tzs/amos-boot-module-jg/amos-boot-module-jg-api/src/main/resources/mapper/JgUseRegistrationManageMapper.xml

@@ -511,8 +511,8 @@
         SELECT distinct
         ibjpc.*,
         (SELECT ei.sequence_nbr from idx_biz_jg_use_info ui
-        LEFT JOIN tz_base_enterprise_info ei ON ei.use_unit_code = ui.ESTATE_UNIT_CREDIT_CODE
-        WHERE ui.PROJECT_CONTRAPTION_ID = ibjpc.sequence_nbr ORDER BY ui.REC_DATE DESC LIMIT 1) AS estateUnitName
+        LEFT JOIN tz_base_enterprise_info ei ON ei.use_unit_code = ui."ESTATE_UNIT_CREDIT_CODE"
+        WHERE ui."PROJECT_CONTRAPTION_ID" = ibjpc.sequence_nbr ORDER BY ui."REC_DATE" DESC LIMIT 1) AS estateUnitName
         FROM
         idx_biz_jg_project_contraption ibjpc
         LEFT JOIN tzs_jg_use_registration_manage tjurm ON ibjpc.use_registration_code = tjurm.use_registration_code
@@ -615,14 +615,22 @@
         a.sequence_nbr = b.equip_transfer_id
         and (a.notice_status <![CDATA[ <> ]]> '6614' and a.notice_status <![CDATA[ <> ]]> '6615' and a.notice_status <![CDATA[ <> ]]> '6610' and a.notice_status <![CDATA[ <> ]]> '6617')
         ) temp
-        ) a ON ibjui.record = a.record
+        ) a ON ibjui."RECORD" = a.record
         WHERE
-        ibjpc.sequence_nbr = ibjui.PROJECT_CONTRAPTION_ID
+        ibjpc.sequence_nbr = ibjui."PROJECT_CONTRAPTION_ID"
         )
         and ibjpc.use_unit_credit_code = #{dto.originalUseUnitCreditCode}
         and ibjpc.is_delete = 0
         and tjurm.is_delete = 0
         and (ibjpc.project_contraption_parent_id is null or ibjpc.project_contraption_parent_id = '')
+        AND NOT EXISTS (
+        SELECT 1
+        FROM idx_biz_jg_use_info ui
+        WHERE ui."PROJECT_CONTRAPTION_ID" = ibjpc.sequence_nbr
+        GROUP BY ui."PROJECT_CONTRAPTION_ID"
+        HAVING COUNT(*) > 0
+        AND COUNT(*) = SUM(CASE WHEN ui."EQU_STATE" = '3' THEN 1 ELSE 0 END)
+        )
         <if test="dto.equList != null and dto.equList != ''">
             and tjurm.equ_list = #{dto.equList}
         </if>

amos-boot-system-tzs/amos-boot-module-jg/amos-boot-module-jg-biz/src/main/java/com/yeejoin/amos/boot/module/jg/biz/service/impl/CommonServiceImpl.java

@@ -2096,7 +2096,7 @@ public class CommonServiceImpl implements ICommonService {
                 String equCategoryAbbrName = CylinderTypeEnum.CYLINDER.getCode().equals(equCategory) ?
                         CylinderTypeEnum.CYLINDER.getName() :
                         EquipTypeEnum.getMessage(equCategory.substring(0, 1));
-                // 设备代码中间两位
+                // 设备类别中间两位
                 String equipType2MidDigits = equCategory.substring(1, 3);
                 //台套还是取品种的中间两位
                 if (!isUnit) {
@@ -2191,12 +2191,11 @@ public class CommonServiceImpl implements ICommonService {
         do {
             ResponseModel<String> stringResponseModel = tzsServiceFeignClient.useRegistrationCode(equCategoryAbbrName + equipType2MidDigits + "陕" + city);
             useRegistrationCode = stringResponseModel.getResult();
-            // 查询是否已有相同登记证号的记录
+            // 查询是否已有相同登记证号的记录（包括已登记和已注销）
             jgUseRegistrationManage = jgUseRegistrationManageService.getBaseMapper().selectOne(
                     new LambdaQueryWrapper<JgUseRegistrationManage>()
                             .eq(JgUseRegistrationManage::getUseRegistrationCode, useRegistrationCode)
                             .eq(JgUseRegistrationManage::getIsDelete, 0)
-                            .eq(JgUseRegistrationManage::getCertificateStatus, "已登记")
             );
         } while (jgUseRegistrationManage != null);
         return useRegistrationCode;

amos-boot-system-tzs/amos-boot-module-jg/amos-boot-module-jg-biz/src/main/java/com/yeejoin/amos/boot/module/jg/biz/service/impl/JgChangeRegistrationUnitServiceImpl.java

@@ -23,7 +23,12 @@ import com.yeejoin.amos.boot.biz.common.utils.DateUtils;
 import com.yeejoin.amos.boot.biz.common.utils.RedisKey;
 import com.yeejoin.amos.boot.biz.common.utils.RedisUtils;
 import com.yeejoin.amos.boot.biz.common.utils.SnowflakeIdUtil;
+import com.yeejoin.amos.boot.module.common.api.dao.ESEquipmentCategory;
+import com.yeejoin.amos.boot.module.common.api.dao.EsEquipmentDao;
+import com.yeejoin.amos.boot.module.common.api.dto.ESEquipmentCategoryDto;
+import com.yeejoin.amos.boot.module.common.api.entity.ESEquipmentInfo;
 import com.yeejoin.amos.boot.module.common.api.enums.CylinderTypeEnum;
+import com.yeejoin.amos.boot.module.common.api.service.ICompensateFlowDataOfRedis;
 import com.yeejoin.amos.boot.module.common.biz.refresh.DataRefreshEvent;
 import com.yeejoin.amos.boot.module.jg.api.dto.*;
 import com.yeejoin.amos.boot.module.jg.api.entity.*;
@@ -35,10 +40,10 @@ import com.yeejoin.amos.boot.module.jg.biz.config.LocalBadRequest;
 import com.yeejoin.amos.boot.module.jg.biz.context.EquipUsedCheckStrategyContext;
 import com.yeejoin.amos.boot.module.jg.biz.context.FlowingEquipRedisContext;
 import com.yeejoin.amos.boot.module.jg.biz.edit.permission.FillingEditPermForCurrentUser;
+import com.yeejoin.amos.boot.module.jg.biz.edit.process.equip.PieLineDataChangeServiceImpl;
 import com.yeejoin.amos.boot.module.jg.biz.event.publisher.EventPublisher;
 import com.yeejoin.amos.boot.module.jg.biz.feign.TzsServiceFeignClient;
 import com.yeejoin.amos.boot.module.jg.biz.service.ICommonService;
-import com.yeejoin.amos.boot.module.common.api.service.ICompensateFlowDataOfRedis;
 import com.yeejoin.amos.boot.module.ymt.api.entity.*;
 import com.yeejoin.amos.boot.module.ymt.api.enums.ApplicationFormTypeEnum;
 import com.yeejoin.amos.boot.module.ymt.api.enums.EquipmentEnum;
@@ -96,6 +101,8 @@ public class JgChangeRegistrationUnitServiceImpl extends BaseService<JgChangeReg
     private static final String SEQUENCE_NBR = "sequenceNbr";
     private static final String EQU_CODE_CC = "5000";
     private static final int ONCE_MAX_SUBMIT = 2000;
+
+    private static final int ONE_BATCH_SIZE = 1000;
     private final List<String> NOT_FLOWING_STATE = Arrays.asList("使用单位待提交", "一级受理已驳回", "使用单位已撤回", "已作废", "已完成");
 
 
@@ -209,6 +216,14 @@ public class JgChangeRegistrationUnitServiceImpl extends BaseService<JgChangeReg
     private IdxBizJgSupervisionInfoMapper idxBizJgSupervisionInfoMapper;
     @Autowired
     private JgUseRegistrationManageServiceImpl jgUseRegistrationManageService;
+    @Autowired
+    private ESEquipmentCategory esEquipmentCategory;
+    @Autowired
+    private EsEquipmentDao esEquipmentDao;
+    @Autowired
+    private PieLineDataChangeServiceImpl pipelineDataChangeService;
+    @Autowired
+    private JgUseRegistrationServiceImpl jgUseRegistrationService;
 
     /**
      * 根据sequenceNbr查询：1、查询单位变更信息，2、查询使用登记证列表
@@ -1868,9 +1883,8 @@ public class JgChangeRegistrationUnitServiceImpl extends BaseService<JgChangeReg
                     //如果是工业管道 如果工程装置对应一个证就直接变更给新单位；如果工程装置对应证下还有其他装置就变更后直接给新单位再重新生成一个登记证号；如果两个工程装置对应同一个使用登记证变更后生成两个新的登记证
                     if (PipelineEnum.PRESSURE_PIPELINE.getCode().equals(dto.getEquListCode())) {
                         this.dealProjectContraption(dto, nextTaskId, registration, op);
-                    }
+                    } else if(CylinderTypeEnum.CYLINDER.getCode().equals(dto.getEquCategoryCode())) {
                         //气瓶单位变更，如果新单位没有证，则生成新的使用登记证，如果新单位有证且是系统生成的证，则选择增补到已有的证下面同时，更新设备其他信息
-                    else if(CylinderTypeEnum.CYLINDER.getCode().equals(dto.getEquCategoryCode())) {
                         this.dealCylinderAuditPassData(dto, nextTaskId, registration, op);
                     } else {
                         // 生成新的使用登记编号，使用登记证  修改设备的使用登记信息表，使用单位名称，使用单位统一信用代码，使用登记证编号，更新ES
@@ -2392,99 +2406,242 @@ public class JgChangeRegistrationUnitServiceImpl extends BaseService<JgChangeReg
         registration.setNextTaskId(nextTaskId);
         TaskV2Model taskV2Model = updateTaskModel(registration, op);
         List<String> projectContraptionIds = new ArrayList<>();
+        String firstProjectContraptionId = null; // 同一使用登记证下第一个装置id
         for (Map<String, Object> map : projectContraptionList) {
             String useRegistrationCode = (String) map.get("useRegistrationCode");
-            String sequenceNbr = (String) map.get(SEQUENCE_NBR);
-            projectContraptionIds.add(sequenceNbr);
+            String projectSequenceNbr = (String) map.get(SEQUENCE_NBR);
+            projectContraptionIds.add(projectSequenceNbr);
             String estateUnitSeq = String.valueOf(map.get("estateUnitName"));
             Map<String, String> propertyUnitInfo = commonServiceImpl.queryTcmUnitInfoBySeq(estateUnitSeq, TcmUnitTypeEnum.CQ.getCode());
             LambdaQueryWrapper<IdxBizJgProjectContraption> wrapper = new LambdaQueryWrapper<>();
             wrapper.eq(IdxBizJgProjectContraption::getUseRegistrationCode, useRegistrationCode)
                     .isNotNull(IdxBizJgProjectContraption::getUseRegistrationCode)
                     .eq(BaseEntity::getIsDelete, false);
-            List<IdxBizJgProjectContraption> jgProjectContraptions = projectContraptionService.list(wrapper);
-            if (CollectionUtils.isEmpty(jgProjectContraptions)) {
+            List<IdxBizJgProjectContraption> projectsUnderSameUseOrgCode = projectContraptionService.list(wrapper).stream().sorted(Comparator.comparing(IdxBizJgProjectContraption::getSequenceNbr)).collect(Collectors.toList());
+            if (CollectionUtils.isEmpty(projectsUnderSameUseOrgCode)) {
                 throw new BadRequest("使用登记证编号：" + useRegistrationCode + "对应的工程/装置列表不存在");
             }
+            if (ValidationUtil.isEmpty(firstProjectContraptionId)) {
+                firstProjectContraptionId = String.valueOf(projectsUnderSameUseOrgCode.get(0).getSequenceNbr());
+            }
             //更新产权信息
             if (!ValidationUtil.isEmpty(propertyUnitInfo)) {
                 idxBizJgUseInfoService.update(
                         new IdxBizJgUseInfo().setEstateUnitCreditCode(propertyUnitInfo.get("unitCode"))
                                 .setEstateUnitName(propertyUnitInfo.get("unitName")),
-                        new LambdaQueryWrapper<IdxBizJgUseInfo>().eq(IdxBizJgUseInfo::getProjectContraptionId, sequenceNbr)
+                        new LambdaQueryWrapper<IdxBizJgUseInfo>().eq(IdxBizJgUseInfo::getProjectContraptionId, projectSequenceNbr)
                 );
             }
+            // 根据装置id查询装置下所有管道使用信息
+            List<IdxBizJgUseInfo> useInfos = idxBizJgUseInfoService.list(new LambdaQueryWrapper<IdxBizJgUseInfo>()
+                    .eq(IdxBizJgUseInfo::getProjectContraptionId, projectSequenceNbr));
 
             //如果工程装置对应一个证就直接变更给新单位 否则重新生成一个登记证
-            if (jgProjectContraptions.size() == 1) {
-                IdxBizJgProjectContraption idxBizJgProjectContraption = jgProjectContraptions.get(0);
+            if (projectsUnderSameUseOrgCode.size() == 1) {
+                IdxBizJgProjectContraption targetProjectContraption = projectsUnderSameUseOrgCode.get(0);
+                this.processSingleProjectContraption(registration, useInfos, targetProjectContraption, projectContraptionIds, useRegistrationCode, false);
+            } else {
+                // 找到同一使用登记证下所有装置中不在本次变更列表的装置
+                List<IdxBizJgProjectContraption> projectsUnderSameUseOrgCodeNotInThisApply = projectsUnderSameUseOrgCode.stream().filter(projectContraption -> !projectContraptionIds.contains(String.valueOf(projectContraption.getSequenceNbr()))).collect(Collectors.toList());
+                // 如果同一使用登记证下 有 装置不在本次变更列表中，则该装置和原使用登记证留给原单位；每一个变更给新单位的装置都重新生成使用登记证
+                if (!ValidationUtil.isEmpty(projectsUnderSameUseOrgCodeNotInThisApply) || !firstProjectContraptionId.equals(projectSequenceNbr)) {
+                    String newUseOrgCode = commonServiceImpl.generateRegistrationCode(useInfos.get(0).getRecord(), registration.getReceiveCompanyCode(), true);
+                    this.processSingleProjectContraption(registration, useInfos, projectsUnderSameUseOrgCode.get(0), projectContraptionIds, newUseOrgCode, true);
+                } else {
+                    // 如果同一使用登记证下所有装置都在本次变更列表中，则将其中一个装置保留原使用登记证并变更给新单位，其他装置则重新生成使用登记证并变更给新单位
+                    // 第一个装置保留原使用登记证
+                    this.processSingleProjectContraption(registration, useInfos, projectsUnderSameUseOrgCode.get(0), projectContraptionIds, useRegistrationCode, false);
+                }
+
+
+//                IdxBizJgProjectContraption idxBizJgProjectContraption = projectContraptionService.getBaseMapper().selectById(Long.valueOf(projectSequenceNbr));
+//                //查询使用登记表eq 查询和装置关联的管道，取第一个用于生成登记编号
+//                LambdaQueryWrapper<JgChangeRegistrationUnitEq> registrationUnitEqWrapper = new LambdaQueryWrapper<>();
+//                registrationUnitEqWrapper.eq(JgChangeRegistrationUnitEq::getProjectContraptionId, idxBizJgProjectContraption.getSequenceNbr())
+//                        .eq(JgChangeRegistrationUnitEq::getUnitChangeRegistrationId, registration.getSequenceNbr())
+//                        .eq(JgChangeRegistrationUnitEq::getIsDelete, false);
+//                List<JgChangeRegistrationUnitEq> changeRegistrationUnitEqs = registrationUnitEqService.list(registrationUnitEqWrapper);
+//                if (CollUtil.isEmpty(changeRegistrationUnitEqs)) {
+//                    throw new BadRequest("使用登记表没有找到工程/装置对应的信息");
+//                }
+//                //重新生成使用登记证
+//                LambdaQueryWrapper<JgUseRegistrationManage> useRegistrationManageWrapper = new LambdaQueryWrapper<>();
+//                useRegistrationManageWrapper.eq(JgUseRegistrationManage::getUseRegistrationCode, useRegistrationCode)
+//                        .isNotNull(JgUseRegistrationManage::getUseRegistrationCode)
+//                        .eq(JgUseRegistrationManage::getCertificateStatus, "已登记")
+//                        .eq(BaseEntity::getIsDelete, false);
+//                List<JgUseRegistrationManage> registrationManages = useRegistrationManageService.getBaseMapper().selectList(useRegistrationManageWrapper);
+//                if (CollUtil.isEmpty(registrationManages)) {
+//                    throw new BadRequest("使用登记编号为：" + useRegistrationCode + "不存在");
+//                }
+//                if (registrationManages.size() != 1) {
+//                    throw new BadRequest("使用登记编号为：" + useRegistrationCode + "有重复数据,请排查");
+//                }
+//                JgUseRegistrationManage registrationManage = registrationManages.get(0);
+//                registrationManage.setSequenceNbr(sequence.nextId());
+//                String code = commonServiceImpl.generateRegistrationCode(changeRegistrationUnitEqs.get(0).getEquId(), registration.getReceiveCompanyCode(), true);
+//                registrationManage.setUseRegistrationCode(code);
+//                //修改使用登记证管理使用单位地址、使用单位代码、接收机构、接收机构公司代码、办理日期、使用单位地址
+//                registrationManage.setUseUnitName(registration.getNewUseUnitName());
+//                registrationManage.setUseUnitCreditCode(registration.getNewUseUnitCreditCode());
+//                registrationManage.setReceiveOrgName(registration.getReceiveOrgName());
+//                registrationManage.setReceiveCompanyCode(registration.getReceiveOrgCode());
+//                registrationManage.setAuditPassDate(registration.getAuditPassDate());
+//                registrationManage.setVersion(1);
+//                registrationManage.setChangeReason(BusinessTypeEnum.JG_COMPANY_CHANGE_REGISTRATION.getName());
+//                if (!ObjectUtils.isEmpty(registration.getNewUseUnitCreditCode())) {//回填新单位地址
+//                    TzBaseEnterpriseInfo useCodeResult = tzBaseEnterpriseInfoMapper.selectOne(new LambdaQueryWrapper<TzBaseEnterpriseInfo>().eq(TzBaseEnterpriseInfo::getUseUnitCode, registration.getNewUseUnitCreditCode()));
+//                    if (useCodeResult != null) {
+//                        registrationManage.setUseUnitAddress(useCodeResult.getAddress());
+//                    }
+//                }
+//                registrationManage.setRecUserId(registration.getCreateUserId());
+//                registrationManage.setRegistrationType("0");
+//                registrationManage.setRegType(BusinessTypeEnum.JG_USAGE_REGISTRATION.getName());
+//                useRegistrationManageService.save(registrationManage);
+//                //更新装置表
+//                idxBizJgProjectContraption.setUseRegistrationCode(code);
+//                idxBizJgProjectContraption.setUseUnitName(registration.getNewUseUnitName());
+//                idxBizJgProjectContraption.setUseUnitCreditCode(registration.getNewUseUnitCreditCode());
+//                idxBizJgProjectContraption.setRecUserId(registration.getCreateUserId());
+//                projectContraptionService.updateById(idxBizJgProjectContraption);
+                //新增使用登记证和设备变更记录
+//                List<String> eqList =  registrationUnitEqService.lambdaQuery().eq(JgChangeRegistrationUnitEq::getUnitChangeRegistrationId, registration.getSequenceNbr()).list().stream().map(JgChangeRegistrationUnitEq::getEquId).collect(Collectors.toList());
+//                this.saveRecordByProjectContraption(registrationManage, registration, eqList);
+//                this.updateUseInfoAndEs(eqList, registration, Boolean.TRUE, code);
+            }
+        }
+        //  创建设备履历
+        this.createResume(projectContraptionIds, registration, taskV2Model.getRoutePath());
+    }
+
+    /**
+      增加管道报废业务后需求调整：
+      如果装置下有报废的管道，则不变更报废的管道（留在原单位），只变更非报废的管道（给新单位）；
+      原装置的登记证号给新单位，并重新生成工程装置，并把非报废的管道变更到新装置
+      原单位报废的管道和原装置保留，清除掉装置和管道的使用登记证号
+     */
+    private void processSingleProjectContraption(JgChangeRegistrationUnit registrationUnit, List<IdxBizJgUseInfo> useInfosOfOneProject, IdxBizJgProjectContraption targetProjectContraption, List<String> projectContraptionIds, String useRegistrationCode, Boolean isNewCode) {
+        Map<Boolean, List<IdxBizJgUseInfo>> groupedUseInfos = useInfosOfOneProject.stream()
+                .collect(Collectors.partitioningBy(useInfo -> EquipmentEnum.BAOFEI.getCode().toString().equals(useInfo.getEquState())));
+        List<IdxBizJgUseInfo> useInfosForScrap = groupedUseInfos.get(true);  // 报废的管道设备
+        List<IdxBizJgUseInfo> useInfosForNotScrap = groupedUseInfos.get(false);  // 非报废的管道设备
+
+        List<String> targetEqIdList = useInfosForNotScrap.stream().map(IdxBizJgUseInfo::getRecord).collect(Collectors.toList());
+
+        // 对应设备的注册信息
+        List<IdxBizJgRegisterInfo> registerInfos = new ArrayList<>();
+        for (int i = 0; i < targetEqIdList.size(); i += ONE_BATCH_SIZE) {
+            List<String> batch = targetEqIdList.subList(i, Math.min(i + ONE_BATCH_SIZE, targetEqIdList.size()));
+            List<IdxBizJgRegisterInfo> batchResults = idxBizJgRegisterInfoService.list(
+                    new LambdaQueryWrapper<IdxBizJgRegisterInfo>().in(IdxBizJgRegisterInfo::getRecord, batch)
+            );
+            registerInfos.addAll(batchResults);
+        }
+
+        // 没有报废的管道设备，直接将装置和证都变更到新单位;有部分报废的管道需给新单位新建管道
+        if (!ValidationUtil.isEmpty(useInfosForScrap)) { // 有部分报废的管道
+            IdxBizJgProjectContraption newProjectContraption = new IdxBizJgProjectContraption();
+            IdxBizJgProjectContraption oldProjectContraption = targetProjectContraption;
+            BeanUtils.copyProperties(oldProjectContraption, newProjectContraption);
+            // 1、老装置保留报废管道，
+            // 1.1 装置清除使用登记证关联
+            oldProjectContraption.setUseRegistrationCode(null);
+            projectContraptionService.updateById(oldProjectContraption);
+            pipelineDataChangeService.updatePipelineLength(String.valueOf(oldProjectContraption.getSequenceNbr()));
+            // 1.2 设备清除使用登记证关联
+            this.terminateRelationOfUseRegistration(useInfosForScrap);
+            // 2、生成新装置
+            newProjectContraption.setSequenceNbr(sequence.nextId());
+            newProjectContraption.setIsIntoManagement(true);
+            newProjectContraption.setIsFirstMerge(false);
+            newProjectContraption.setProjectContraptionParentId(null);
+
+            // 为新装置生成设备代码
+            String equCode = jgUseRegistrationService.getEquCode(registerInfos.get(0), registrationUnit.getReceiveCompanyCode());
+            newProjectContraption.setEquCode(equCode);
+            projectContraptionService.save(newProjectContraption);
+
+            // 2.1 把非报废管道关联到新装置
+            List<List<IdxBizJgUseInfo>> useInfoBatches = new ArrayList<>();
+            for (int i = 0; i < useInfosForNotScrap.size(); i += ONE_BATCH_SIZE) {
+                useInfoBatches.add(useInfosForNotScrap.subList(i, Math.min(i + ONE_BATCH_SIZE, useInfosForNotScrap.size())));
+            }
+            for (List<IdxBizJgUseInfo> batch : useInfoBatches) {
+                batch.forEach(useInfo -> useInfo.setProjectContraptionId(String.valueOf(newProjectContraption.getSequenceNbr())));
+                idxBizJgUseInfoService.updateBatchById(batch);
+            }
+
+            // 2.2 更新新装置下管道的设备代码
+            List<List<IdxBizJgRegisterInfo>> registerInfoBatches = new ArrayList<>();
+            for (int i = 0; i < registerInfos.size(); i += ONE_BATCH_SIZE) {
+                registerInfoBatches.add(registerInfos.subList(i, Math.min(i + ONE_BATCH_SIZE, registerInfos.size())));
+            }
+            for (List<IdxBizJgRegisterInfo> batch : registerInfoBatches) {
+                batch.forEach(registerInfo -> registerInfo.setEquCode(equCode));
+                idxBizJgRegisterInfoService.updateBatchById(batch);
+            }
+
+            pipelineDataChangeService.updatePipelineLength(String.valueOf(newProjectContraption.getSequenceNbr()));
+            targetProjectContraption = newProjectContraption;
+
+            // 新装置ID加人到待生成履历装置ID
+            projectContraptionIds.add(String.valueOf(newProjectContraption.getSequenceNbr()));
+        }
+        this.updateProjectContraptionAndRegistrationManage(registrationUnit, targetProjectContraption, useRegistrationCode, targetEqIdList, isNewCode);
+        this.updateUseInfoAndEs(targetEqIdList, registrationUnit, isNewCode, isNewCode ? useRegistrationCode : null);
+    }
+
+    private void terminateRelationOfUseRegistration(List<IdxBizJgUseInfo> useInfosForScrap) {
+        if (!ValidationUtil.isEmpty(useInfosForScrap)) {
+            List<String> eqIdList = useInfosForScrap.stream().map(IdxBizJgUseInfo::getRecord).collect(Collectors.toList());
+            for (int i = 0; i < eqIdList.size(); i += ONE_BATCH_SIZE) {
+                List<String> batch = eqIdList.subList(i, Math.min(i + ONE_BATCH_SIZE, eqIdList.size()));
+
+                idxBizJgRegisterInfoService.lambdaUpdate()
+                        .setSql("USE_ORG_CODE = NULL")
+                        .in(IdxBizJgRegisterInfo::getRecord, batch)
+                        .update();
+
+                Iterable<ESEquipmentCategoryDto> jgAllEsDtos = esEquipmentCategory.findAllById(batch);
+                jgAllEsDtos.forEach(dto -> dto.setUSE_ORG_CODE(null));
+                esEquipmentCategory.saveAll(jgAllEsDtos);
+
+                Iterable<ESEquipmentInfo> newEsDtos = esEquipmentDao.findAllById(batch);
+                newEsDtos.forEach(dto -> dto.setUSE_ORG_CODE(null));
+                esEquipmentDao.saveAll(newEsDtos);
+            }
+        }
+    }
+
+    private void updateProjectContraptionAndRegistrationManage(JgChangeRegistrationUnit registration, IdxBizJgProjectContraption idxBizJgProjectContraption, String useRegistrationCode, List<String> eqList, Boolean isNewCode) {
         idxBizJgProjectContraption.setUseUnitName(registration.getNewUseUnitName());
         idxBizJgProjectContraption.setUseUnitCreditCode(registration.getNewUseUnitCreditCode());
         idxBizJgProjectContraption.setRecUserId(registration.getCreateUserId());
         projectContraptionService.updateById(idxBizJgProjectContraption);
+        JgUseRegistrationManage registrationManage;
+        if (isNewCode) {
+            registrationManage = new JgUseRegistrationManage();
+            registrationManage.setSequenceNbr(sequence.nextId());
+            registrationManage.setUseRegistrationCode(useRegistrationCode);
+            registrationManage.setRegistrationType("0");
+            registrationManage.setRegType(BusinessTypeEnum.JG_COMPANY_CHANGE_REGISTRATION.getName());
+        } else {
             //获取使用登记证
             LambdaQueryWrapper<JgUseRegistrationManage> useRegistrationManageWrapper = new LambdaQueryWrapper<>();
             useRegistrationManageWrapper.eq(JgUseRegistrationManage::getUseRegistrationCode, useRegistrationCode)
                     .isNotNull(JgUseRegistrationManage::getUseRegistrationCode)
-                        .eq(JgUseRegistrationManage::getCertificateStatus, "已登记")
+                    .eq(JgUseRegistrationManage::getCertificateStatus, CertificateStatusEnum.YIDENGJI.getName())
                     .eq(BaseEntity::getIsDelete, false);
-                JgUseRegistrationManage registrationManage = useRegistrationManageService.getBaseMapper().selectOne(useRegistrationManageWrapper);
-                //修改使用登记证管理使用单位地址、使用单位代码、接收机构、接收机构公司代码、办理日期、使用单位地址
-                registrationManage.setUseUnitName(registration.getNewUseUnitName());
-                registrationManage.setUseUnitCreditCode(registration.getNewUseUnitCreditCode());
-                registrationManage.setReceiveOrgName(registration.getReceiveOrgName());
-                registrationManage.setReceiveCompanyCode(registration.getReceiveOrgCode());
-                registrationManage.setAuditPassDate(registration.getAuditPassDate());
+            registrationManage = useRegistrationManageService.getBaseMapper().selectOne(useRegistrationManageWrapper);
             registrationManage.setVersion(registrationManage.getVersion() + 1);
-                registrationManage.setChangeReason(BusinessTypeEnum.JG_COMPANY_CHANGE_REGISTRATION.getName());
-                if (!ObjectUtils.isEmpty(registration.getNewUseUnitCreditCode())) {//回填新单位地址
-                    TzBaseEnterpriseInfo useCodeResult = tzBaseEnterpriseInfoMapper.selectOne(new QueryWrapper<TzBaseEnterpriseInfo>().eq("use_unit_code", registration.getNewUseUnitCreditCode()));
-                    if (useCodeResult != null) {
-                        registrationManage.setUseUnitAddress(useCodeResult.getAddress());
-                    }
-                }
-                registrationManage.setRecUserId(registration.getCreateUserId());
-                useRegistrationManageService.updateById(registrationManage);
-                //新增使用登记证和设备变更记录
-                this.saveRecordByProjectContraption(registrationManage, registration);
-
-                //通过装置Id查询出设备进行更新 更新其他关联表
-                this.updateRelationTable(idxBizJgProjectContraption.getSequenceNbr(), registration, Boolean.FALSE, null);
-            } else {
-                IdxBizJgProjectContraption idxBizJgProjectContraption = projectContraptionService.getBaseMapper().selectById(Long.valueOf(sequenceNbr));
-                //查询使用登记表eq 查询和装置关联的管道，取第一个用于生成登记编号
-                LambdaQueryWrapper<JgChangeRegistrationUnitEq> registrationUnitEqWrapper = new LambdaQueryWrapper<>();
-                registrationUnitEqWrapper.eq(JgChangeRegistrationUnitEq::getProjectContraptionId, idxBizJgProjectContraption.getSequenceNbr())
-                        .eq(JgChangeRegistrationUnitEq::getUnitChangeRegistrationId, registration.getSequenceNbr())
-                        .eq(JgChangeRegistrationUnitEq::getIsDelete, false);
-                List<JgChangeRegistrationUnitEq> changeRegistrationUnitEqs = registrationUnitEqService.list(registrationUnitEqWrapper);
-                if (CollUtil.isEmpty(changeRegistrationUnitEqs)) {
-                    throw new BadRequest("使用登记表没有找到工程/装置对应的信息");
-                }
-                //重新生成使用登记证
-                LambdaQueryWrapper<JgUseRegistrationManage> useRegistrationManageWrapper = new LambdaQueryWrapper<>();
-                useRegistrationManageWrapper.eq(JgUseRegistrationManage::getUseRegistrationCode, useRegistrationCode)
-                        .isNotNull(JgUseRegistrationManage::getUseRegistrationCode)
-                        .eq(JgUseRegistrationManage::getCertificateStatus, "已登记")
-                        .eq(BaseEntity::getIsDelete, false);
-                List<JgUseRegistrationManage> registrationManages = useRegistrationManageService.getBaseMapper().selectList(useRegistrationManageWrapper);
-                if (CollUtil.isEmpty(registrationManages)) {
-                    throw new BadRequest("使用登记编号为：" + useRegistrationCode + "不存在");
         }
-                if (registrationManages.size() != 1) {
-                    throw new BadRequest("使用登记编号为：" + useRegistrationCode + "有重复数据,请排查");
-                }
-                JgUseRegistrationManage registrationManage = registrationManages.get(0);
-                registrationManage.setSequenceNbr(sequence.nextId());
-                String code = commonServiceImpl.generateRegistrationCode(changeRegistrationUnitEqs.get(0).getEquId(), registrationManage.getReceiveCompanyCode(), true);
-                registrationManage.setUseRegistrationCode(code);
         //修改使用登记证管理使用单位地址、使用单位代码、接收机构、接收机构公司代码、办理日期、使用单位地址
         registrationManage.setUseUnitName(registration.getNewUseUnitName());
         registrationManage.setUseUnitCreditCode(registration.getNewUseUnitCreditCode());
         registrationManage.setReceiveOrgName(registration.getReceiveOrgName());
         registrationManage.setReceiveCompanyCode(registration.getReceiveOrgCode());
         registrationManage.setAuditPassDate(registration.getAuditPassDate());
-                registrationManage.setVersion(1);
         registrationManage.setChangeReason(BusinessTypeEnum.JG_COMPANY_CHANGE_REGISTRATION.getName());
         if (!ObjectUtils.isEmpty(registration.getNewUseUnitCreditCode())) {//回填新单位地址
             TzBaseEnterpriseInfo useCodeResult = tzBaseEnterpriseInfoMapper.selectOne(new QueryWrapper<TzBaseEnterpriseInfo>().eq("use_unit_code", registration.getNewUseUnitCreditCode()));
@@ -2493,23 +2650,9 @@ public class JgChangeRegistrationUnitServiceImpl extends BaseService<JgChangeReg
             }
         }
         registrationManage.setRecUserId(registration.getCreateUserId());
-                registrationManage.setRegistrationType("0");
-                registrationManage.setRegType(BusinessTypeEnum.JG_USAGE_REGISTRATION.getName());
-                useRegistrationManageService.save(registrationManage);
-                //更新装置表
-                idxBizJgProjectContraption.setUseRegistrationCode(code);
-                idxBizJgProjectContraption.setUseUnitName(registration.getNewUseUnitName());
-                idxBizJgProjectContraption.setUseUnitCreditCode(registration.getNewUseUnitCreditCode());
-                idxBizJgProjectContraption.setRecUserId(registration.getCreateUserId());
-                projectContraptionService.updateById(idxBizJgProjectContraption);
+        useRegistrationManageService.saveOrUpdate(registrationManage);
         //新增使用登记证和设备变更记录
-                this.saveRecordByProjectContraption(registrationManage, registration);
-                //通过装置Id查询出设备进行更新 更新其他关联表
-                this.updateRelationTable(idxBizJgProjectContraption.getSequenceNbr(), registration, Boolean.TRUE, code);
-            }
-        }
-        //  创建设备履历
-        this.createResume(projectContraptionIds, registration, taskV2Model.getRoutePath());
+        this.saveRecordByProjectContraption(registrationManage, registration, eqList);
     }
 
     private void createResume(List<String> projectContraptionIds, JgChangeRegistrationUnit registration, String routePath) {
@@ -2527,6 +2670,51 @@ public class JgChangeRegistrationUnitServiceImpl extends BaseService<JgChangeReg
     }
 
     /**
+     * 更新使用信息表和两个设备es
+     *
+     * @param eqIdList 待更新设备ID集合
+     * @param registration 本次单位变更单据
+     * @param isNewUseOrgCode 是否使用新的使用登记证号
+     * @param useOrgCode 新使用登记证号
+     */
+    private void updateUseInfoAndEs(List<String> eqIdList, JgChangeRegistrationUnit registration, Boolean isNewUseOrgCode, String useOrgCode) {
+        if (!ValidationUtil.isEmpty(eqIdList)) {
+            String[] companyCode = registration.getNewUseUnitCreditCode().split("_");
+            String newCompanyCode = companyCode.length > 1 ? companyCode[1] : registration.getNewUseUnitCreditCode();
+            for (int i = 0; i < eqIdList.size(); i += ONE_BATCH_SIZE) {
+                List<String> batch = eqIdList.subList(i, Math.min(i + ONE_BATCH_SIZE, eqIdList.size()));
+                idxBizJgUseInfoService.lambdaUpdate()
+                        .set(IdxBizJgUseInfo::getUseUnitCreditCode, newCompanyCode)
+                        .set(IdxBizJgUseInfo::getUseUnitName, registration.getNewUseUnitName())
+                        .in(IdxBizJgUseInfo::getRecord, batch)
+                        .update();
+
+                Iterable<ESEquipmentCategoryDto> jgAllEsDtos = esEquipmentCategory.findAllById(batch);
+                jgAllEsDtos.forEach(dto -> {
+                    dto.setUSE_UNIT_CREDIT_CODE(newCompanyCode);
+                    dto.setUSE_UNIT_NAME(registration.getNewUseUnitName());
+                    dto.setREC_DATE(new Date().getTime());
+                    if (Boolean.TRUE.equals(isNewUseOrgCode)) {
+                        dto.setUSE_ORG_CODE(useOrgCode);
+                    }
+                });
+                esEquipmentCategory.saveAll(jgAllEsDtos);
+
+                Iterable<ESEquipmentInfo> newEsDtos = esEquipmentDao.findAllById(batch);
+                newEsDtos.forEach(dto -> {
+                    dto.setUSE_UNIT_CREDIT_CODE(newCompanyCode);
+                    dto.setUSE_UNIT_NAME(registration.getNewUseUnitName());
+                    dto.setREC_DATE(new Date().getTime());
+                    if (Boolean.TRUE.equals(isNewUseOrgCode)) {
+                        dto.setUSE_ORG_CODE(useOrgCode);
+                    }
+                });
+                esEquipmentDao.saveAll(newEsDtos);
+            }
+        }
+    }
+
+    /**
      * 更新关系表
      *
      * @param sequenceNbr
@@ -2574,14 +2762,13 @@ public class JgChangeRegistrationUnitServiceImpl extends BaseService<JgChangeReg
      *
      * @param registrationManage
      */
-    private void saveRecordByProjectContraption(JgUseRegistrationManage registrationManage, JgChangeRegistrationUnit registrationUnit) {
-        List<JgChangeRegistrationUnitEq> eqList = registrationUnitEqService.lambdaQuery().eq(JgChangeRegistrationUnitEq::getUnitChangeRegistrationId, registrationManage.getSequenceNbr()).list();
+    private void saveRecordByProjectContraption(JgUseRegistrationManage registrationManage, JgChangeRegistrationUnit registrationUnit, List<String> eqList) {
         List<JgCertificateChangeRecordEq> changeRecordEqList = new ArrayList<>();
         JgCertificateChangeRecord changeRecord = new JgCertificateChangeRecord();
         long nextId = sequence.nextId();
-        changeRecord.setApplyNo(registrationManage.getApplyNo());//申请编号
-        changeRecord.setReceiveOrgName(registrationManage.getReceiveOrgName());//接收机构/登记机关
-        changeRecord.setAuditPassDate(registrationUnit.getApplyDate());//办理日期
+        changeRecord.setApplyNo(registrationUnit.getApplyNo());//申请编号
+        changeRecord.setReceiveOrgName(registrationUnit.getReceiveOrgName());//接收机构/登记机关
+        changeRecord.setAuditPassDate(registrationUnit.getAuditPassDate());//办理通过日期
         changeRecord.setRegType("单位变更登记");//登记类别
         changeRecord.setRegDate(registrationUnit.getCreateDate());//申请日期
         changeRecord.setChangeContent(this.buildRecordContent(registrationUnit));//变更内容
@@ -2593,10 +2780,10 @@ public class JgChangeRegistrationUnitServiceImpl extends BaseService<JgChangeReg
         changeRecord.setEquCategory(registrationManage.getEquCategory());//设备类别编码
         changeRecord.setCreateDate(new Date());
         changeRecord.setSequenceNbr(nextId);
-        for (JgChangeRegistrationUnitEq unitEq : eqList) {
+        for (String eqId : eqList) {
             JgCertificateChangeRecordEq changeRecordEq = new JgCertificateChangeRecordEq();
             changeRecordEq.setChangeRecordId(String.valueOf(nextId));//登记证记录主键
-            changeRecordEq.setEquId(unitEq.getEquId());//设备主键
+            changeRecordEq.setEquId(eqId);//设备主键
             changeRecordEqList.add(changeRecordEq);
         }
         certificateChangeRecordService.save(changeRecord);

amos-boot-system-tzs/amos-boot-module-jg/amos-boot-module-jg-biz/src/main/java/com/yeejoin/amos/boot/module/jg/biz/service/impl/JgUseRegistrationManageServiceImpl.java

@@ -1063,7 +1063,7 @@ public class JgUseRegistrationManageServiceImpl extends BaseService<JgUseRegistr
                 item.setDataSourceName(EquipSourceEnum.getDataSourceName(item.getDataSource()));
                 item.setFullAddress(
                         Stream.of(item.getProvinceName(), item.getCityName(), item.getCountyName(), item.getStreetName(), item.getAddress())
-                                .map(value -> value == null ? "" : value)
+                                .map(value -> value == null || "null".equals(value) ? "" : value)
                                 .collect(Collectors.joining())
                 );
                 // 兼容历史数据，根据产权单位Seq（item.getEstateUnitName()）从tzs_tcm_unit_info表查询产权单位