feat(jg):管道导入

amos-boot-system-tzs/amos-boot-module-jg/amos-boot-module-jg-api/src/main/java/com/yeejoin/amos/boot/module/jg/api/converter/DictParamsConverter.java

@@ -34,10 +34,6 @@ public class DictParamsConverter implements Converter<String> {
         dictMap.put("过热器出口集箱", "6006");
         dictMap.put("启动分离器", "6007");
         dictMap.put("长输管道", "5994");
-        dictMap.put("磁粉", "5988");
-        dictMap.put("射线", "5986");
-        dictMap.put("超声", "5987");
-        dictMap.put("渗透", "5989");
         dictMap.put("A1", "6094");
         dictMap.put("A2", "6095");
         dictMap.put("A7", "6100");

amos-boot-system-tzs/amos-boot-module-jg/amos-boot-module-jg-api/src/main/java/com/yeejoin/amos/boot/module/jg/api/dto/InspectConclusionConverter.java

+package com.yeejoin.amos.boot.module.jg.api.dto;
+
+import com.alibaba.excel.converters.Converter;
+import com.alibaba.excel.enums.CellDataTypeEnum;
+import com.alibaba.excel.metadata.CellData;
+import com.alibaba.excel.metadata.GlobalConfiguration;
+import com.alibaba.excel.metadata.property.ExcelContentProperty;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class InspectConclusionConverter implements Converter<String> {
+
+    private static final Map<String, String> dictMap = new HashMap<>();
+
+    static {
+        // 填充映射关系
+        dictMap.put("合格", "6040");
+        dictMap.put("不合格", "6041");
+        dictMap.put("复检合格", "6042");
+        dictMap.put("复检不合格", "6043");
+        dictMap.put("整改后合格", "6045");
+        dictMap.put("符合", "6046");
+        dictMap.put("不符合", "6047");
+        dictMap.put("符合要求", "6048");
+        dictMap.put("基本符合要求", "6049");
+        dictMap.put("不符合要求", "6050");
+        dictMap.put("允许使用", "6051");
+        dictMap.put("降压使用", "6052");
+        dictMap.put("进行合于使用评价", "6053");
+        dictMap.put("其他", "6044");
+    }
+
+    @Override
+    public Class<?> supportJavaTypeKey() {
+        // 实体类中对象属性类型
+        return String.class;
+    }
+
+    @Override
+    public CellDataTypeEnum supportExcelTypeKey() {
+        return CellDataTypeEnum.STRING;
+    }
+
+    @Override
+    public String convertToJavaData(CellData cellData, ExcelContentProperty excelContentProperty,
+                                    GlobalConfiguration globalConfiguration) {
+        // 从Cell中读取数据
+        String cellValue = cellData.getStringValue();
+        // 判断Excel中的值，将其转换为预期的数值
+        return dictMap.getOrDefault(cellValue, null);
+    }
+
+    @Override
+    public CellData convertToExcelData(String o, ExcelContentProperty excelContentProperty, GlobalConfiguration globalConfiguration) throws Exception {
+        return new CellData("");
+    }
+}
\ No newline at end of file

amos-boot-system-tzs/amos-boot-module-jg/amos-boot-module-jg-api/src/main/java/com/yeejoin/amos/boot/module/jg/api/dto/InspectTypeConverter.java

+package com.yeejoin.amos.boot.module.jg.api.dto;
+
+import com.alibaba.excel.converters.Converter;
+import com.alibaba.excel.enums.CellDataTypeEnum;
+import com.alibaba.excel.metadata.CellData;
+import com.alibaba.excel.metadata.GlobalConfiguration;
+import com.alibaba.excel.metadata.property.ExcelContentProperty;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class InspectTypeConverter implements Converter<String> {
+
+    private static final Map<String, String> dictMap = new HashMap<>();
+
+    static {
+        // 填充映射关系
+        dictMap.put("定期检验", "DQJY");
+        dictMap.put("首次检验", "SCJY");
+        dictMap.put("安装监督检验", "AZJDJY");
+        dictMap.put("改造监督检验", "GZJDJY");
+        dictMap.put("维修监督检验", "WXJDJY");
+        dictMap.put("制造监督检验", "ZZJDJY");
+
+    }
+
+    @Override
+    public Class<?> supportJavaTypeKey() {
+        // 实体类中对象属性类型
+        return String.class;
+    }
+
+    @Override
+    public CellDataTypeEnum supportExcelTypeKey() {
+        return CellDataTypeEnum.STRING;
+    }
+
+    @Override
+    public String convertToJavaData(CellData cellData, ExcelContentProperty excelContentProperty,
+                                    GlobalConfiguration globalConfiguration) {
+        // 从Cell中读取数据
+        String cellValue = cellData.getStringValue();
+        // 判断Excel中的值，将其转换为预期的数值
+        return dictMap.getOrDefault(cellValue, null);
+    }
+
+    @Override
+    public CellData convertToExcelData(String o, ExcelContentProperty excelContentProperty, GlobalConfiguration globalConfiguration) throws Exception {
+        return new CellData("");
+    }
+}
\ No newline at end of file

amos-boot-system-tzs/amos-boot-module-jg/amos-boot-module-jg-api/src/main/java/com/yeejoin/amos/boot/module/jg/api/dto/PipingExcelDto.java

+package com.yeejoin.amos.boot.module.jg.api.dto;
+
+import com.alibaba.excel.annotation.ExcelIgnore;
+import com.alibaba.excel.annotation.ExcelProperty;
+import com.yeejoin.amos.boot.biz.common.dto.BaseDto;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+@ApiModel(value = "管道-设备信息", description = "管道-设备信息")
+public class PipingExcelDto extends BaseDto {
+
+    @ExcelIgnore
+    private static final long serialVersionUID = 1L;
+
+
+    //----------------------------------------------------------------------基本信息
+
+    @ApiModelProperty(value = "设备种类")
+    @ExcelIgnore
+    private String equList;
+
+    @ApiModelProperty(value = "设备类别")
+    @ExcelIgnore
+    private String equCategory;
+
+    @ApiModelProperty(value = "设备品种")
+    @ExcelIgnore
+    private String equDefine;
+
+    @ApiModelProperty(value = "单位内编号")
+    @ExcelProperty(value = "单位内编号")
+    private String useInnerCode;
+
+    @ApiModelProperty(value = "产品名称")
+    @ExcelProperty(value = "产品名称")
+    private String productName;
+
+    @ApiModelProperty(value = "管道名称（登记单元）")
+    @ExcelProperty(value = "管道名称（登记单元）")
+    private String pipeName;
+
+    @ApiModelProperty(value = "设备型号")
+    @ExcelProperty(value = "设备型号")
+    private String equType;
+
+    @ApiModelProperty(value = "设备总价值（万元）")
+    @ExcelProperty(value = "设备总价值（万元）")
+    private String equPrice;
+
+
+    @ApiModelProperty(value = "有无设备代码")
+    @ExcelProperty(value = "有无设备代码")
+    private String equCodeType;
+
+    @ApiModelProperty(value = "设备代码")
+    @ExcelProperty(value = "设备代码")
+    private String equCode;
+
+    @ApiModelProperty(value = "工程（装置）名称")
+    @ExcelProperty(value = "工程（装置）名称")
+    private String projectContraption;
+
+
+    @ApiModelProperty(value = "工程（装置）编号")
+    @ExcelProperty(value = "工程（装置）编号")
+    private String projectContraptionNo;
+
+    @ApiModelProperty(value = "使用登记证编号")
+    @ExcelProperty(value = "使用登记证编号")
+    private String useOrgCode;
+
+    //-----------------------------------------------------------------------使用信息
+
+    @ApiModelProperty(value = "使用单位统一社会信用代码")
+    @ExcelProperty(value = "使用单位统一社会信用代码")
+    private String useUnitCode;
+
+    @ApiModelProperty(value = "使用单位名称")
+    @ExcelProperty(value = "使用单位名称")
+    private String useUnit;
+
+    //-----------------------------------------------------------------------安装信息
+
+    @ApiModelProperty(value = "安装单位统一社会信用代码")
+    @ExcelProperty(value = "安装单位统一社会信用代码")
+    private String installUnitCode;
+
+    @ApiModelProperty(value = "安装单位名称")
+    @ExcelProperty(value = "安装单位名称")
+    private String installUnitName;
+
+    //-----------------------------------------------------------------------检验检测信息
+
+    @ApiModelProperty(value = "检验检测机构统一社会信用代码")
+    @ExcelProperty(value = "检验检测机构统一社会信用代码")
+    private String inspectUnitCode;
+
+    @ApiModelProperty(value = "检验检测机构名称")
+    @ExcelProperty(value = "检验检测机构名称")
+    private String inspectUnitName;
+
+    @ApiModelProperty(value = "检验结论")
+    @ExcelProperty(value = "检验结论")
+    private String inspectConclusion;
+
+    @ApiModelProperty(value = "检验类型")
+    @ExcelProperty(value = "检验类型")
+    private String inspectType;
+
+    @ApiModelProperty(value = "检验日期")
+    @ExcelProperty(value = "检验日期")
+    private String inspectDate;
+
+    @ApiModelProperty(value = "检验人员名称")
+    @ExcelProperty(value = "检验人员名称")
+    private String inspectPersonName;
+
+    @ApiModelProperty(value = "下次检验日期")
+    @ExcelProperty(value = "下次检验日期")
+    private String nextInspectDate;
+
+    @ApiModelProperty(value = "检验报告编号")
+    @ExcelProperty(value = "检验报告编号")
+    private String inspectReportCode;
+
+    //-----------------------------------------------------------------------设计信息
+
+    @ApiModelProperty(value = "设计单位统一社会信用代码")
+    @ExcelProperty(value = "设计单位统一社会信用代码")
+    private String designUnitCreditCode;
+
+    @ApiModelProperty(value = "设计单位名称")
+    @ExcelProperty(value = "设计单位名称")
+    private String designUnitName;
+
+
+    //--------------------------------------------------------------------压力管道----技术参数
+
+    @ExcelProperty(value = "管道类别")
+    @ApiModelProperty(value = "管道类别")
+    private String pipelineClass;
+
+    @ExcelProperty(value = "公称壁厚(mm)")
+    @ApiModelProperty(value = "公称壁厚(mm)")
+    private String wallThickness;
+
+    @ExcelProperty(value = "公称直径（mm）")
+    @ApiModelProperty(value = "公称直径（mm）")
+    private String nominalDiameter;
+
+    @ExcelProperty(value = "管道长度（m）")
+    @ApiModelProperty(value = "管道长度（m）")
+    private String pipeLength;
+
+    @ExcelProperty(value = "设计-压力（MPa）")
+    @ApiModelProperty(value = "设计-压力（MPa）")
+    private String pressure;
+
+    @ExcelProperty(value = "设计-介质")
+    @ApiModelProperty(value = "设计-介质")
+    private String medium;
+
+    @ExcelProperty(value = "起/始位置 （经纬度）（格式：经度-纬度）")
+    @ApiModelProperty(value = "起/始位置 （经纬度）（格式：经度-纬度）")
+    private String startePosition;
+
+    @ExcelProperty(value = "设计-温度（℃）")
+    @ApiModelProperty(value = "设计-温度（℃）")
+    private String temperature;
+
+    @ExcelProperty(value = "管道编号")
+    @ApiModelProperty(value = "管道编号")
+    private String pipelineNumber;
+
+    @ExcelProperty(value = "管道级别")
+    @ApiModelProperty(value = "管道级别")
+    private String deviceLevel;
+
+    @ExcelProperty(value = "工作条件-压力(MPa)")
+    @ApiModelProperty(value = "工作条件-压力(MPa)")
+    private String workPressure;
+
+    @ExcelProperty(value = "工作条件-温度(℃)")
+    @ApiModelProperty(value = "工作条件-温度(℃)")
+    private String workTemperature;
+
+    @ExcelProperty(value = "工作条件-介质")
+    @ApiModelProperty(value = "工作条件-介质")
+    private String workMedium;
+
+    @ExcelProperty(value = "备注")
+    @ApiModelProperty(value = "备注")
+    private String remarks;
+
+}
\ No newline at end of file

amos-boot-system-tzs/amos-boot-module-jg/amos-boot-module-jg-biz/src/main/java/com/yeejoin/amos/boot/module/jg/biz/controller/DataDockController.java

@@ -7,6 +7,7 @@ import org.apache.commons.io.FilenameUtils;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
+import org.typroject.tyboot.component.event.RestEventTrigger;
 import org.typroject.tyboot.core.foundation.enumeration.UserType;
 import org.typroject.tyboot.core.restful.doc.TycloudOperation;
 import org.typroject.tyboot.core.restful.utils.ResponseHelper;
@@ -58,32 +59,38 @@ public class DataDockController {
         return ResponseHelper.buildResponse(dataDockService.dataCheckAndImportEquipmentData(remark, file));
     }
 
-    // @TycloudOperation(ApiLevel = UserType.AGENCY)
-    // @PostMapping(value = "/delete")
-    // @ApiOperation(httpMethod = "POST", value = "八大类历史设备导入shanchu", notes = "八大类历史设备导入shachu")
-    // public Object importData() {
-    //     dataDockService.delete();
-    //     return ResponseHelper.buildResponse("ok");
-    // }
+    /**
+     * 工业管道批量检查
+     **/
+    @TycloudOperation(ApiLevel = UserType.AGENCY)
+    @PostMapping(value = "/checkGYGDData")
+    @ApiOperation(httpMethod = "POST", value = "工业管道批量检查", notes = "工业管道批量检查")
+    @RestEventTrigger(value = "operateLogRestEventHandler")
+    public ResponseModel<?> checkGYGDData(@RequestPart("file") MultipartFile multipartFile) throws Exception {
+        return ResponseHelper.buildResponse(dataDockService.checkGDData(multipartFile, true));
+    }
+
+    /**
+     * 工业 、公用、长输管道批量保存
+     **/
+    @TycloudOperation(ApiLevel = UserType.AGENCY)
+    @PostMapping(value = "/savePipingData")
+    @ApiOperation(httpMethod = "POST", value = "工业管道批量保存", notes = "工业管道批量保存")
+    @RestEventTrigger(value = "operateLogRestEventHandler")
+    public ResponseModel<?> savePipingData(@RequestBody Map<String, Object> paramMap) {
+        return ResponseHelper.buildResponse(dataDockService.savePipingData(paramMap));
+    }
+
+    /**
+     * 公用、长输道批量检查
+     **/
+    @TycloudOperation(ApiLevel = UserType.AGENCY)
+    @PostMapping(value = "/checkGYCSGDData")
+    @ApiOperation(httpMethod = "POST", value = "公用、长输管道批量检查", notes = "公用、长输管道批量检查")
+    @RestEventTrigger(value = "operateLogRestEventHandler")
+    public ResponseModel<?> checkGYCSGDData(@RequestPart("file") MultipartFile multipartFile) throws Exception {
+        return ResponseHelper.buildResponse(dataDockService.checkGDData(multipartFile, false));
+    }
 
-    // @TycloudOperation(ApiLevel = UserType.AGENCY)
-    // @GetMapping(value = "/yanChang/ORG_BRANCH_CODE")
-    // @ApiOperation(httpMethod = "get", value = "延炼-延长-刷入属地监管部门", notes = "延炼-延长-刷入属地监管部门")
-    // public Object writeOrgBranchCode2YanChang(@RequestParam String remark) {
-    //     if (ValidationUtil.isEmpty(remark)) {
-    //         throw new BadRequest("remark必填！");
-    //     }
-    //     return ResponseHelper.buildResponse("更新成功，共" + dataDockService.writeOrgBranchCode2YanChang(remark) + "条数据");
-    // }
-    //
-    // @TycloudOperation(ApiLevel = UserType.AGENCY)
-    // @GetMapping(value = "/yanChang/USE_PLACE")
-    // @ApiOperation(httpMethod = "get", value = "延炼-延长-刷入所属区域", notes = "延炼-延长-刷入所属区域")
-    // public Object writeUsePlace2YanChang(@RequestParam String remark) {
-    //     if (ValidationUtil.isEmpty(remark)) {
-    //         throw new BadRequest("remark必填！");
-    //     }
-    //     return ResponseHelper.buildResponse("更新成功，共" + dataDockService.writeUsePlace2YanChang(remark) + "条数据");
-    // }
 }
 

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/DataDockServiceImpl.java

@@ -7,8 +7,12 @@ import com.alibaba.excel.event.AnalysisEventListener;
 import com.alibaba.excel.read.metadata.ReadSheet;
 import com.alibaba.excel.read.metadata.holder.ReadRowHolder;
 import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.yeejoin.amos.boot.biz.common.bo.CompanyBo;
+import com.yeejoin.amos.boot.biz.common.bo.ReginParams;
+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;
@@ -16,6 +20,7 @@ import com.yeejoin.amos.boot.module.common.api.dto.ESEquipmentCategoryDto;
 import com.yeejoin.amos.boot.module.jg.api.converter.EquCategoryConverter;
 import com.yeejoin.amos.boot.module.jg.api.converter.EquDefineConverter;
 import com.yeejoin.amos.boot.module.jg.api.dto.EquipInfoExcelDto;
+import com.yeejoin.amos.boot.module.jg.api.dto.PipingExcelDto;
 import com.yeejoin.amos.boot.module.jg.biz.feign.TzsServiceFeignClient;
 import com.yeejoin.amos.boot.module.jg.biz.service.*;
 import com.yeejoin.amos.boot.module.ymt.api.entity.*;
@@ -34,6 +39,7 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.ObjectUtils;
 import org.springframework.web.multipart.MultipartFile;
+import org.typroject.tyboot.core.foundation.context.RequestContext;
 import org.typroject.tyboot.core.foundation.utils.ValidationUtil;
 import org.typroject.tyboot.core.restful.exception.instance.BadRequest;
 
@@ -69,6 +75,7 @@ public class DataDockServiceImpl {
     private final IIdxBizJgTechParamsRopewayService iIdxBizJgTechParamsRopewayService;
     private final IIdxBizJgTechParamsElevatorService iIdxBizJgTechParamsElevatorService;
     private final IdxBizJgProjectContraptionServiceImpl idxBizJgProjectContraptionServiceImpl;
+    private final IdxBizJgConstructionInfoServiceImpl idxBizJgConstructionInfoService;
     private final TzBaseEnterpriseInfoMapper tzBaseEnterpriseInfoMapper;
     private final RedisUtils redisUtils;
     private final TzsServiceFeignClient tzsServiceFeignClient;
@@ -123,28 +130,6 @@ public class DataDockServiceImpl {
         }
     }
 
-    // public void delete() {
-    // List<String> records = idxBizJgUseInfoService.lambdaQuery().select(IdxBizJgUseInfo::getRecord).likeRight(IdxBizJgUseInfo::getRemark, "延炼").list()
-    //         .stream().map(IdxBizJgUseInfo::getRecord).collect(Collectors.toList());
-    //
-    //
-    // // saveProjectContraption(equ, equList);
-    // idxBizJgUseInfoService.getBaseMapper().delete(new LambdaQueryWrapper<IdxBizJgUseInfo>().in(IdxBizJgUseInfo::getRecord, records));
-    // idxBizJgDesignInfoService.getBaseMapper().delete(new LambdaQueryWrapper<IdxBizJgDesignInfo>().in(IdxBizJgDesignInfo::getRecord, records));
-    // idxBizJgFactoryInfoService.getBaseMapper().delete(new LambdaQueryWrapper<IdxBizJgFactoryInfo>().in(IdxBizJgFactoryInfo::getRecord, records));
-    // idxBizJgRegisterInfoServiceImpl.getBaseMapper().delete(new LambdaQueryWrapper<IdxBizJgRegisterInfo>().in(IdxBizJgRegisterInfo::getRecord, records));
-    // idxBizJgSupervisionInfoService.getBaseMapper().delete(new LambdaQueryWrapper<IdxBizJgSupervisionInfo>().in(IdxBizJgSupervisionInfo::getRecord, records));
-    // iIdxBizJgTechParamsLiftingService.getBaseMapper().delete(new LambdaQueryWrapper<IdxBizJgTechParamsLifting>().in(IdxBizJgTechParamsLifting::getRecord, records));
-    // iIdxBizJgTechParamsVehicleService.getBaseMapper().delete(new LambdaQueryWrapper<IdxBizJgTechParamsVehicle>().in(IdxBizJgTechParamsVehicle::getRecord, records));
-    // iIdxBizJgTechParamsBoilerService.getBaseMapper().delete(new LambdaQueryWrapper<IdxBizJgTechParamsBoiler>().in(IdxBizJgTechParamsBoiler::getRecord, records));
-    // iIdxBizJgTechParamsVesselService.getBaseMapper().delete(new LambdaQueryWrapper<IdxBizJgTechParamsVessel>().in(IdxBizJgTechParamsVessel::getRecord, records));
-    // iIdxBizJgTechParamsPipelineService.getBaseMapper().delete(new LambdaQueryWrapper<IdxBizJgTechParamsPipeline>().in(IdxBizJgTechParamsPipeline::getRecord, records));
-    // iIdxBizJgTechParamsRidesService.getBaseMapper().delete(new LambdaQueryWrapper<IdxBizJgTechParamsRides>().in(IdxBizJgTechParamsRides::getRecord, records));
-    // iIdxBizJgTechParamsRopewayService.getBaseMapper().delete(new LambdaQueryWrapper<IdxBizJgTechParamsRopeway>().in(IdxBizJgTechParamsRopeway::getRecord, records));
-    // iIdxBizJgTechParamsElevatorService.getBaseMapper().delete(new LambdaQueryWrapper<IdxBizJgTechParamsElevator>().in(IdxBizJgTechParamsElevator::getRecord, records));
-    // records.forEach(record -> this.saveEquInfoToEs(record));
-    // }
-
     public Integer writeOrgBranchCode2YanChang(String remark) {
         List<String> records = idxBizJgUseInfoService.lambdaQuery().select(IdxBizJgUseInfo::getRecord).eq(IdxBizJgUseInfo::getRemark, remark).list().stream().map(IdxBizJgUseInfo::getRecord).collect(Collectors.toList());
 
@@ -172,72 +157,6 @@ public class DataDockServiceImpl {
                 .orElse("");
     }
 
-    public Integer writeUsePlace2YanChang(String remark) {
-        List<String> records = idxBizJgUseInfoService.lambdaQuery()
-                .select(IdxBizJgUseInfo::getRecord)
-                .eq(IdxBizJgUseInfo::getRemark, remark)
-                .list()
-                .stream()
-                .map(IdxBizJgUseInfo::getRecord)
-                .collect(Collectors.toList());
-        if (records.isEmpty()) {
-            return 0;
-        }
-        Optional<String> useUnitCreditCode = idxBizJgUseInfoService.lambdaQuery()
-                .select(IdxBizJgUseInfo::getUseUnitCreditCode)
-                .eq(IdxBizJgUseInfo::getRecord, records.get(0))
-                .list().stream().findFirst().map(IdxBizJgUseInfo::getUseUnitCreditCode);
-
-        useUnitCreditCode.ifPresent(useCode -> {
-
-            TzBaseEnterpriseInfo enterpriseInfo = tzBaseEnterpriseInfoMapper.selectOne(new LambdaQueryWrapper<TzBaseEnterpriseInfo>()
-                    .eq(TzBaseEnterpriseInfo::getUseUnitCode, useCode));
-            String provinceName = enterpriseInfo.getProvince();
-            String provinceCode = "610000";
-            String cityName = enterpriseInfo.getCity();
-            String cityCode = "";
-            if (!ValidationUtil.isEmpty(cityName)) {
-                cityCode = getRegionCode(cityName, "CITY");
-            }
-
-            String districtName = enterpriseInfo.getDistrict();
-            String districtCode = "";
-            if (!ValidationUtil.isEmpty(districtName)) {
-                districtCode = getRegionCode(districtName, "COUNTY");
-            }
-
-            String usePlace = provinceName + "/" + cityName + "/" + districtName;
-            String usePlaceCode = provinceCode + "#" + cityCode + "#" + districtCode;
-
-            idxBizJgUseInfoService.lambdaUpdate()
-                    .set(IdxBizJgUseInfo::getProvince, provinceCode)
-                    .set(IdxBizJgUseInfo::getProvinceName, provinceName)
-                    .set(IdxBizJgUseInfo::getCity, cityCode)
-                    .set(IdxBizJgUseInfo::getCityName, cityName)
-                    .set(IdxBizJgUseInfo::getCounty, districtCode)
-                    .set(IdxBizJgUseInfo::getCountyName, districtName)
-                    .set(IdxBizJgUseInfo::getStreetName, enterpriseInfo.getStreet())
-                    .set(IdxBizJgUseInfo::getAddress, enterpriseInfo.getAddress())
-                    .set(!ValidationUtil.isEmpty(enterpriseInfo.getLatitude()) && !ValidationUtil.isEmpty(enterpriseInfo.getLongitude()),
-                            IdxBizJgUseInfo::getLongitudeLatitude,
-                            String.format("{\"latitude\":\"%s\",\"longitude\":\"%s\"}", enterpriseInfo.getLatitude(), enterpriseInfo.getLongitude()))
-                    .in(IdxBizJgUseInfo::getRecord, records)
-                    .update();
-            
-            records.forEach(record -> {
-                log.error("向{}刷入使用地点信息", record);
-                HashMap<String, Map<String, Object>> objMap = new HashMap<>();
-                HashMap<String, Object> param = new HashMap<>();
-                param.put("USE_PLACE", usePlace);
-                param.put("USE_PLACE_CODE", usePlaceCode);
-                objMap.put(record, param);
-                tzsServiceFeignClient.commonUpdateEsDataByIds(objMap);
-            });
-        });
-
-        return records.size();
-    }
-
     /**
      * 保存工程装置表信息
      */
@@ -1054,7 +973,7 @@ public class DataDockServiceImpl {
             res = res.substring(0, res.length() - 4) + "0" + res.substring(res.length() - 4);
         }
 
-        if (!res.matches("\\d{4}-\\d{2}-\\d{2}")) {
+        if (!res.matches("\\d{4}-\\d{2}-\\d{2}") && !res.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}")) {
             rowError.append(errorMessage);
             return null;
         }
@@ -1162,9 +1081,9 @@ public class DataDockServiceImpl {
         checkNotBlank(data.getWallThickness_YLGD(), "公称壁厚不能为空；", rowError);
         checkNotBlank(data.getNominalDiameter(), "公称直径不能为空；", rowError);
         checkNotBlank(data.getPipeLength(), "管道长度不能为空；", rowError);
-        checkNotBlank(data.getPressure(), "压力不能为空；", rowError);
-        checkNotBlank(data.getMedium_YLGD(), "介质不能为空；", rowError);
-        checkNotBlank(data.getTemperature_YLGD(), "温度不能为空；", rowError);
+        checkNotBlank(data.getPressure(), "设计-压力不能为空；", rowError);
+        checkNotBlank(data.getMedium_YLGD(), "设计-介质不能为空；", rowError);
+        checkNotBlank(data.getTemperature_YLGD(), "设计-温度不能为空；", rowError);
         checkNotBlank(data.getPipelineNumber(), "管道编号不能为空；", rowError);
         checkNotBlank(data.getDeviceLevel_YLGD(), "管道级别不能为空；", rowError);
         Optional.ofNullable(data.getStartePosition()).ifPresent(v -> {
@@ -1172,7 +1091,7 @@ public class DataDockServiceImpl {
                 rowError.append("起/始位置 （经纬度）格式不正确");
             }
         });
-        if (!org.apache.commons.lang3.ObjectUtils.isEmpty(data.getStartePosition()) && data.getStartePosition().split("-").length == 2) {
+        if (!ObjectUtils.isEmpty(data.getStartePosition()) && data.getStartePosition().split("-").length == 2) {
             String[] split = data.getStartePosition().split("-");
             data.setStartePosition(String.format("{\"latitude\":%s,\"longitude\":%s}", split[0], split[1]));
         }
@@ -1383,4 +1302,409 @@ public class DataDockServiceImpl {
         //     }
         // }
     }
+
+    /**
+     * 检查管道的excel数据格式
+     *
+     * @param multipartFile 文件
+     * @param isGYGD        是否工业管道
+     * @return 结果集合
+     * @throws Exception 检测不通过，异常情况描述
+     */
+    public Object checkGDData(MultipartFile multipartFile, Boolean isGYGD) throws Exception {
+        List<PipingExcelDto> dataList = new ArrayList<>();
+        List<String> resultGDError = new ArrayList<>();
+        try {
+            EasyExcel.read(multipartFile.getInputStream(), PipingExcelDto.class, new AnalysisEventListener<PipingExcelDto>() {
+                @Override
+                public void invoke(PipingExcelDto data, AnalysisContext context) {
+                    resultGDError.add(checkGDExcelData(data, context, isGYGD).toString());
+                    dataList.add(data);
+                }
+
+                @Override
+                public void doAfterAllAnalysed(AnalysisContext context) {
+                    if (CollectionUtils.isEmpty(dataList)) {
+                        log.info("你上传了一个空数据的Excel文档!");
+                        resultGDError.add("你上传了一个空数据的Excel文档!");
+                        throw new BadRequest("你上传了一个空数据的Excel文档!");
+                    }
+                }
+            }).headRowNumber(4).sheet().doRead();
+            if (resultGDError.stream().anyMatch(input -> !input.isEmpty())) {
+                throw new BadRequest("上传失败！");
+            }
+            return dataList;
+        } catch (Exception e) {
+            throw new Exception(resultGDError.stream()
+                    .filter(s -> !s.isEmpty())
+                    .collect(Collectors.joining("<br/>")));
+        }
+    }
+
+    public StringBuffer checkGDExcelData(PipingExcelDto data, AnalysisContext context, Boolean isGYGD) {
+
+        StringBuffer rowError = new StringBuffer();
+        ReadRowHolder readRowHolder = context.readRowHolder();
+        int rowIndex = readRowHolder.getRowIndex() + 1;
+        try {
+            log.info("解析第{}行数据：{}", rowIndex, JSON.toJSONString(data));
+            checkNotBlank(data.getPipeName(), "管道名称不能为空；", rowError);
+            // 同一工程装置下管道编号不能重复
+            if (!ValidationUtil.isEmpty(data.getProjectContraption())) {
+                // 使用单位Code
+                String useUnitCode = String.valueOf(data.getUseUnitCode()).trim();
+                // 使用单位名称
+                String useUnit = String.valueOf(data.getUseUnit()).trim();
+                // 工程装置名称
+                String proConName = data.getProjectContraption().trim();
+
+                // 查询该企业下工程装置名称
+                IdxBizJgProjectContraption oldContraption = idxBizJgProjectContraptionService.lambdaQuery()
+                        .eq(IdxBizJgProjectContraption::getUseUnitCreditCode, useUnitCode)
+                        .eq(IdxBizJgProjectContraption::getUseUnitName, useUnit)
+                        .eq(IdxBizJgProjectContraption::getProjectContraption, proConName)
+                        .list().stream().findFirst().orElse(null);
+                Optional.ofNullable(oldContraption).ifPresent(old -> {
+                    List<String> pipelineNumberList = idxBizJgProjectContraptionServiceImpl.getBaseMapper()
+                            .selectEquipList(String.valueOf(old.getSequenceNbr()))
+                            .stream()
+                            .map(item -> (String) item.get("pipelineNumber"))
+                            .collect(Collectors.toList());
+                    if (pipelineNumberList.contains(data.getPipelineNumber())) {
+                        rowError.append(String.format("系统中工程装置（%s）下已经存在管道编号（%s）；", data.getProjectContraption(), data.getPipelineNumber()));
+                    }
+                });
+
+                List<String> list = projectContraptionMap.get(data.getProjectContraption());
+                if (null != list) {
+                    // 判断该装置下是否已经存在该管道编号
+                    if (list.contains(data.getPipelineNumber())) {
+                        rowError.append(String.format("同一工程装置（%s）下管道编号不能重复；", data.getProjectContraption()));
+                    }
+                    list.add(data.getPipelineNumber());
+                } else {
+                    list = new ArrayList<>();
+                }
+                projectContraptionMap.put(data.getProjectContraption(), list);
+            }
+            checkNotBlank(data.getDesignUnitCreditCode(), "设计单位统一社会信用代码不能为空；", rowError);
+            checkNotBlank(data.getDesignUnitName(), "设计单位名称不能为空；", rowError);
+            checkNotBlank(data.getInspectUnitCode(), "检验检测机构统一社会信用代码不能为空；", rowError);
+            checkNotBlank(data.getInspectUnitName(), "检验检测机构名称不能为空；", rowError);
+            checkNotBlank(data.getInspectConclusion(), "检验结论不能为空；", rowError);
+            checkNotBlank(data.getInspectType(), "检验类型不能为空；", rowError);
+            checkNotBlank(data.getInspectDate(), "检验日期不能为空；", rowError);
+            Optional.ofNullable(data.getInspectDate()).ifPresent(v -> checkDateFormatCorrect(v, "检验日期格式不正确；", rowError));
+            checkNotBlank(data.getInspectPersonName(), "检验人员名称不能为空；", rowError);
+            checkNotBlank(data.getNextInspectDate(), "下次检验日期不能为空；", rowError);
+            Optional.ofNullable(data.getNextInspectDate()).ifPresent(v -> checkDateFormatCorrect(v, "下次检验日期格式不正确；", rowError));
+            checkNotBlank(data.getInspectReportCode(), "检验报告编号不能为空；", rowError);
+            checkNotBlank(data.getInstallUnitCode(), "安装单位统一社会信用代码不能为空；", rowError);
+            checkNotBlank(data.getInstallUnitName(), "安装单位名称不能为空；", rowError);
+            // 技术参数
+            checkNotBlank(data.getWallThickness(), "公称壁厚不能为空；", rowError);
+            Optional.ofNullable(data.getWallThickness()).ifPresent(item -> checkPipeSpecifications(item, "公称壁厚请输入数字或者/分割的范围，如2/6", rowError));
+            checkNotBlank(data.getNominalDiameter(), "公称直径不能为空；", rowError);
+            Optional.ofNullable(data.getNominalDiameter()).ifPresent(item -> checkPipeSpecifications(item, "公称直径请输入数字或者/分割的范围，如2/6", rowError));
+            checkNotBlank(data.getPipeLength(), "管道长度不能为空；", rowError);
+            Optional.ofNullable(data.getPipeLength()).ifPresent(item -> checkDateFormatNumber(item, "管道长度必须为数字", rowError));
+            checkNotBlank(data.getPressure(), "设计-压力不能为空；", rowError);
+            checkNotBlank(data.getMedium(), "设计-介质不能为空；", rowError);
+            checkNotBlank(data.getTemperature(), "设计-温度不能为空；", rowError);
+            checkNotBlank(data.getPipelineNumber(), "管道编号不能为空；", rowError);
+            checkNotBlank(data.getDeviceLevel(), "管道级别不能为空；", rowError);
+
+            // 工业管道校验使用信息
+            if (isGYGD) {
+                // todo
+            }
+
+            // 如果存在错误信息，则抛出 BadRequest 异常
+            if (rowError.length() > 0) {
+                rowError.insert(0, "Excel第[" + rowIndex + "]行 -> ");
+            }
+
+        } catch (Exception e) {
+            log.error("行索引数: [{}] -> 失败的 Excel 数据: [{}]", rowIndex, JSON.toJSONString(data), e);
+            throw e;
+        }
+        return rowError;
+    }
+
+    /**
+     * 管道规格格式校验
+     *
+     * @param item
+     * @param errorMessage
+     * @param rowError
+     */
+    public void checkPipeSpecifications(String item, String errorMessage, StringBuffer rowError) {
+        String regex = "^\\d(\\d*[.]?\\d*)([-/]\\d*[.]?\\d*)?$";
+        if (!item.matches(regex)) {
+            rowError.append(errorMessage);
+        }
+    }
+
+    @GlobalTransactional(rollbackFor = Exception.class)
+    public Object savePipingData(Map<String, Object> paramMap) {
+        JSONObject equipInfo = JSON.parseObject(toJSONString(paramMap.get("equipInfo")), JSONObject.class);
+        JSONObject attachmentUpload = JSON.parseObject(toJSONString(paramMap.get("attachmentUpload")), JSONObject.class);
+        List<PipingExcelDto> equLists = JSONArray.parseArray(toJSONString(attachmentUpload.get("equLists"))).toJavaList(PipingExcelDto.class);
+        ReginParams reginParams = JSONObject.parseObject(redisUtils.get(RedisKey.buildReginKey(RequestContext.getExeUserId(), RequestContext.getToken())).toString(), ReginParams.class);
+        CompanyBo company = reginParams.getCompany();
+
+        // 是否工业管道
+        boolean isYLGD = "8300".equals(String.valueOf(equipInfo.get("EQU_CATEGORY")));
+        if (isYLGD) {
+            this.saveIndustrialPipData(company, equipInfo, equLists);
+        } else {
+            this.savePublicLongDistancePipData(company, equipInfo, equLists);
+        }
+        return Boolean.TRUE;
+    }
+
+    /**
+     * 工业管道保存
+     *
+     * @param equipInfo
+     * @param equLists
+     */
+    public void saveIndustrialPipData(CompanyBo company, JSONObject equipInfo, List<PipingExcelDto> equLists) {
+        String equList = String.valueOf(equipInfo.get("EQU_LIST"));
+        String equCategory = String.valueOf(equipInfo.get("EQU_CATEGORY"));
+        String equDefine = String.valueOf(equipInfo.get("EQU_DEFINE"));
+
+        // 1. 校验是否第一次上传，限制同一个工程装置(同一编号同一名称)只能导一次 todo
+        // 2. 有使用登记证 -
+        // 2.1 匹配本单位使用登记证 匹配成功 系统存在改使用登记证
+        // 2.1.0 匹配本单位下的工程装置名称和工程装置编号不是一一对应的，抛出异常
+        // 2.1.1 匹配本单位下的工程装置(同一编号同一名称) (一一对应) 匹配成功 ===》（将设备挂到改装置下）
+        // 2.1.1 匹配本单位下的工程装置(同一编号同一名称) (一一对应) 匹配失败 ===》 生成新工程装置表数据
+        // 2.2 匹配本单位使用登记证 匹配失败 系统不存在改使用登记证
+        // 2.2.0 匹配本单位下的工程装置(同一编号同一名称) (一一对应) 匹配成功 抛出异常
+        // 2.2.1 生成使用登记证表数据
+        // 2.2.2 生成工程装置表信息
+        // 3. 更新管道对应的idx表数据
+
+    }
+
+    // 通用方法初始化 List
+    private <T> List<T> initializeList() {
+        return new ArrayList<>(15);
+    }
+
+    /**
+     * 公用、长输管道保存
+     *
+     * @param equipInfo
+     * @param equLists
+     */
+    public void savePublicLongDistancePipData(CompanyBo company, JSONObject equipInfo, List<PipingExcelDto> equLists) {
+        String companyCode = company.getCompanyCode().split("_")[0];
+        String companyName = company.getCompanyName();
+        String equList = String.valueOf(equipInfo.get("EQU_LIST"));
+        String equCategory = String.valueOf(equipInfo.get("EQU_CATEGORY"));
+        String equDefine = String.valueOf(equipInfo.get("EQU_DEFINE"));
+        // 设备来源
+        String dataSource = "jg_his";
+        // 属地监管部门
+        String orgBranchCode = String.valueOf(equipInfo.get("orgBranchCode"));
+        // 所属属地
+        String vehicleApanage = String.valueOf(equipInfo.get("VEHICLE_APANAGE"));
+        // 工程装置名称
+        String projectContraption = String.valueOf(equipInfo.get("PROJECT_CONTRAPTION"));
+        // 工程装置编号
+        String projectContraptionNo = String.valueOf(equipInfo.get("PROJECT_CONTRAPTION_NO"));
+        // 产品照片
+        String productPhoto = toJSONString(equipInfo.get("PRODUCT_PHOTO"));
+        // 产品质量合格证明
+        String productQualificationCertificate = toJSONString(equipInfo.get("PRODUCT_QUALIFICATION_CERTIFICATE"));
+        // 其他附件
+        String otherAccessories = toJSONString(equipInfo.get("OTHER_ACCESSORIES"));
+        // 汇总管道长度
+        double pipelineLength = equLists.stream().mapToDouble(item -> Double.parseDouble(item.getPipeLength())).sum();
+
+        // 1. 校验是否第一次上传，限制同一个工程装置(同一编号同一名称)只能导一次 todo
+        // 2. 工程装置名称和工程装置编号不是一一对应的，抛出异常
+        Integer existsConflictNum = idxBizJgProjectContraptionService.lambdaQuery()
+                .eq(IdxBizJgProjectContraption::getUseUnitCreditCode, companyCode)
+                .eq(IdxBizJgProjectContraption::getUseUnitName, companyName)
+                .eq(IdxBizJgProjectContraption::getIsIntoManagement, Boolean.TRUE)
+                .eq(IdxBizJgProjectContraption::getIsDelete, Boolean.FALSE)
+                .and(wrapper -> wrapper
+                        .ne(IdxBizJgProjectContraption::getProjectContraptionNo, projectContraptionNo)
+                        .eq(IdxBizJgProjectContraption::getProjectContraption, projectContraption)
+                        .or()
+                        .eq(IdxBizJgProjectContraption::getProjectContraptionNo, projectContraptionNo)
+                        .ne(IdxBizJgProjectContraption::getProjectContraption, projectContraption)
+                )
+                .count();
+        if (existsConflictNum > 0) {
+            throw new BadRequest("工程装置名称或编号与本单位下的已存在的数据冲突！");
+        }
+
+        // 3. 无证 - 匹配本单位下的工程装置(同一编号同一名称)
+        List<IdxBizJgProjectContraption> projectContraptions = idxBizJgProjectContraptionService.lambdaQuery()
+                .select(IdxBizJgProjectContraption::getPipelineLength)
+                .eq(IdxBizJgProjectContraption::getUseUnitCreditCode, companyCode)
+                .eq(IdxBizJgProjectContraption::getUseUnitName, companyName)
+                .eq(IdxBizJgProjectContraption::getEquCategory, equCategory)// 限制到设备类别
+                .eq(IdxBizJgProjectContraption::getIsIntoManagement, Boolean.TRUE)
+                .eq(IdxBizJgProjectContraption::getIsDelete, Boolean.FALSE)
+                .eq(IdxBizJgProjectContraption::getProjectContraption, projectContraption)
+                .eq(IdxBizJgProjectContraption::getProjectContraptionNo, projectContraptionNo)
+                .list();
+        // 3.1 匹配不到数据 生成一条工程装置表信息
+        if (projectContraptions.isEmpty()) {
+            IdxBizJgProjectContraption contraption = IdxBizJgProjectContraption.builder()
+                    .projectContraption(projectContraption)
+                    .projectContraptionNo(projectContraptionNo)
+                    .useUnitCreditCode(companyCode)
+                    .useUnitName(companyName)
+                    // .uscUnitCreditCode().uscUnitName()
+                    .equList(equList)
+                    .equListName(EquipmentClassifityEnum.getNameByCode(equList))
+                    .equCategory(equCategory)
+                    .equCategoryName(EquCategoryConverter.getKeyByValue(equCategory))
+                    .equDefine(equDefine)
+                    .equDefineName(EquDefineConverter.getKeyByValue(equDefine))
+                    .pipelineLength(pipelineLength)
+                    .productPhoto(productPhoto)
+                    .otherAccessories(otherAccessories)
+                    .orgCode(orgBranchCode.split("_")[0])
+                    .orgName(orgBranchCode.split("_")[1])
+                    .productQualificationCertificate(productQualificationCertificate)
+                    // .province().provinceName().city().cityName().county().countyName().street().streetName().address()
+                    .supervisoryCode(idxBizJgRegisterInfoServiceImpl.getSupervisoryCode(vehicleApanage, equCategory))
+                    .isIntoManagement(Boolean.TRUE)
+                    .dataSource(dataSource)
+                    // .equCode()
+                    .isFirstMerge(Boolean.FALSE)
+                    .build();
+            idxBizJgProjectContraptionService.save(contraption);
+        }
+        // 3.2 匹配到数据 名称和编号能一一对应，增补到改工程装置上
+        double oldPipLength = projectContraptions.stream().mapToDouble(item -> Double.parseDouble(String.valueOf(item.getPipelineLength()))).sum();
+        idxBizJgProjectContraptionService.lambdaUpdate()
+                .set(IdxBizJgProjectContraption::getPipelineLength, Double.sum(oldPipLength, pipelineLength))
+                .update();
+        // 4. 更新管道对应的idx表数据
+        List<IdxBizJgUseInfo> useInfoList = initializeList();
+        List<IdxBizJgDesignInfo> designInfoList = initializeList();
+        List<IdxBizJgFactoryInfo> factoryInfoList = initializeList();
+        List<IdxBizJgConstructionInfo> constructionInfoList = initializeList();
+        List<IdxBizJgRegisterInfo> registerInfoList = initializeList();
+        List<IdxBizJgSupervisionInfo> supervisionInfoList = initializeList();
+        List<IdxBizJgOtherInfo> otherInfoList = initializeList();
+        List<IdxBizJgTechParamsPipeline> paramsPipelineList = initializeList();
+        List<ESEquipmentCategoryDto> esEquipmentCategoryList = initializeList();
+        for (PipingExcelDto pipeline : equLists) {
+            String record = UUID.randomUUID().toString();
+
+            // 使用信息
+            IdxBizJgUseInfo useInfo = JSON.parseObject(toJSONString(pipeline), IdxBizJgUseInfo.class);
+            // 使用信息
+            useInfo.setRecord(record);
+            useInfo.setSequenceNbr(null);
+            useInfo.setRecDate(new Date());
+            useInfo.setDataSource(dataSource);
+            useInfo.setIsIntoManagement(Boolean.FALSE);
+            useInfo.setUseUnitCreditCode(companyCode);
+            useInfo.setUseUnitName(companyName);
+            useInfo.setProjectContraption(projectContraption);
+            useInfo.setProjectContraptionId(projectContraptionNo);
+            useInfoList.add(useInfo);
+
+            // 设计信息
+            IdxBizJgDesignInfo designInfo = JSON.parseObject(toJSONString(pipeline), IdxBizJgDesignInfo.class);
+            designInfo.setRecord(record);
+            designInfo.setRecDate(new Date());
+            designInfo.setSequenceNbr(null);
+            designInfoList.add(designInfo);
+
+            // 制造信息
+            IdxBizJgFactoryInfo factoryInfo = JSON.parseObject(toJSONString(pipeline), IdxBizJgFactoryInfo.class);
+            factoryInfo.setRecord(record);
+            factoryInfo.setRecDate(new Date());
+            factoryInfo.setSequenceNbr(null);
+            factoryInfoList.add(factoryInfo);
+
+            // 施工信息
+            IdxBizJgConstructionInfo constructionInfo = JSON.parseObject(toJSONString(pipeline), IdxBizJgConstructionInfo.class);
+            constructionInfo.setRecord(record);
+            constructionInfo.setRecDate(new Date());
+            constructionInfo.setSequenceNbr(null);
+            constructionInfoList.add(constructionInfo);
+
+            // 注册登记信息
+            IdxBizJgRegisterInfo registerInfo = JSON.parseObject(toJSONString(pipeline), IdxBizJgRegisterInfo.class);
+            registerInfo.setRecord(record);
+            registerInfo.setRecDate(new Date());
+            registerInfo.setSequenceNbr(null);
+            registerInfo.setEquCodeType("2");
+            // registerInfo.setRegisterState(this.getRegCode());
+            // registerInfo.setEquCode();
+
+            // 监督管理
+            IdxBizJgSupervisionInfo supervisionInfo = JSON.parseObject(toJSONString(pipeline), IdxBizJgSupervisionInfo.class);
+            supervisionInfo.setRecord(record);
+            supervisionInfo.setRecDate(new Date());
+            supervisionInfo.setSequenceNbr(null);
+            supervisionInfoList.add(supervisionInfo);
+
+            // 其他信息
+            IdxBizJgOtherInfo otherInfo = JSON.parseObject(toJSONString(pipeline), IdxBizJgOtherInfo.class);
+            otherInfo.setRecord(record);
+            otherInfo.setSequenceNbr(null);
+            otherInfo.setClaimStatus("已认领");
+            otherInfo.setRecDate(new Date());
+            otherInfoList.add(otherInfo);
+
+            // 管道技术参数
+            IdxBizJgTechParamsPipeline pipelineInfo = JSON.parseObject(toJSONString(pipeline), IdxBizJgTechParamsPipeline.class);
+            if (!ValidationUtil.isEmpty(pipelineInfo)) {
+                pipelineInfo.setRecord(record);
+                pipelineInfo.setRecDate(new Date());
+                pipelineInfo.setSequenceNbr(null);
+                paramsPipelineList.add(pipelineInfo);
+            }
+            registerInfo.setProductName(pipelineInfo.getPipeName());
+            registerInfoList.add(registerInfo);
+
+            // ESEquipmentCategoryDto esEquipmentDto = JSON.parseObject(toJSONString(equipmentInfoForm), ESEquipmentCategoryDto.class);
+            // esEquipmentDto.setDATA_SOURCE(useInfo.getDataSource());
+            // if (inspectionDetectionInfo.getNextInspectDate() != null) {
+            //     esEquipmentDto.setNEXT_INSPECT_DATE(inspectionDetectionInfo.getNextInspectDate().getTime());
+            // }
+            // esEquipmentDto.setREC_DATE(System.currentTimeMillis());
+            // esEquipmentDto.setSEQUENCE_NBR(record);
+            // esEquipmentDto.setIS_INTO_MANAGEMENT(false);
+            // esEquipmentDto.setEQU_CATEGORY_CODE(registerInfo.getEquCategory());
+            // esEquipmentDto.setEQU_CATEGORY(equCategoryName);
+            // esEquipmentDto.setEQU_LIST_CODE(registerInfo.getEquList());
+            // esEquipmentDto.setEQU_LIST(equListName);
+            // esEquipmentDto.setEQU_DEFINE_CODE(registerInfo.getEquDefine());
+            // esEquipmentDto.setEQU_DEFINE(equListName);
+            // esEquipmentDto.setSTATUS("已认领");
+            // esEquipmentDto.setUSC_UNIT_CREDIT_CODE(projectContraption.getUscUnitCreditCode());
+            // esEquipmentDto.setUSC_UNIT_NAME(projectContraption.getUscUnitName());
+            // esEquipmentDto.setPROJECT_CONTRAPTION(projectContraption.getProjectContraption());
+            // esEquipmentDto.setPRODUCT_NAME(pipelineInfo.getPipeName());
+            // esEquipmentDto.setProjectContraptionId(String.valueOf(sequenceNbr));
+            // if (inspectionDetectionInfo.getNextInspectDate() != null) {
+            //     esEquipmentDto.setNEXT_INSPECT_DATE(inspectionDetectionInfo.getNextInspectDate().getTime());
+            // }
+            // esEquipmentCategoryList.add(esEquipmentDto);
+        }
+        idxBizJgUseInfoService.saveBatch(useInfoList);
+        idxBizJgDesignInfoService.saveBatch(designInfoList);
+        idxBizJgConstructionInfoService.saveBatch(constructionInfoList);
+        idxBizJgFactoryInfoService.saveBatch(factoryInfoList);
+        idxBizJgRegisterInfoServiceImpl.saveBatch(registerInfoList);
+        idxBizJgOtherInfoService.saveBatch(otherInfoList);
+        idxBizJgSupervisionInfoService.saveBatch(supervisionInfoList);
+        iIdxBizJgTechParamsPipelineService.saveBatch(paramsPipelineList);
+        esEquipmentCategory.saveAll(esEquipmentCategoryList);
+    }
 }

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/IdxBizJgRegisterInfoServiceImpl.java

@@ -138,7 +138,6 @@ public class IdxBizJgRegisterInfoServiceImpl extends BaseService<IdxBizJgRegiste
     public static final String DATA_SOURCE_NAME = "DATA_SOURCE_NAME";
     public static final String USE_PLACE_CODE = "USE_PLACE_CODE";
     public static final String EQU_CATEGORY_CODE = "EQU_CATEGORY_CODE";
-    public static final String EQU_LIST_CODE = "EQU_LIST_CODE";
     public static final String PROJECT_CONTRAPTION = "PROJECT_CONTRAPTION";// 工程装置名称
     /**
      * 业务类型 0：单个新增 1:批量导入
@@ -394,9 +393,9 @@ public class IdxBizJgRegisterInfoServiceImpl extends BaseService<IdxBizJgRegiste
         }
         LinkedHashMap equipmentInfoForm = (LinkedHashMap) checkAndCast(paramMap.get(EQUIP_INFO_FORM_ID));
         String dataSource = (String) equipmentInfoForm.get(DATA_SOURCE);
-        String equListCode = (String) equipmentInfoForm.get(EQU_LIST);
+        String equCategory = (String) equipmentInfoForm.get(EQU_CATEGORY);
         //管道添加设备
-        if (PipelineEnum.PRESSURE_PIPELINE.getCode().equals(equListCode)) {
+        if (PipelineEnum.INDUSTRIAL_PIPELINE.getCode().equals(equCategory)) {
             return this.pipelineEquipCreateOrUpdate(paramMap);
         }
         if(dataSource.contains("black")){
@@ -1143,16 +1142,22 @@ public class IdxBizJgRegisterInfoServiceImpl extends BaseService<IdxBizJgRegiste
         if ("his".equals(dataSource) || "black".equals(dataSource)) {
             // 历史数据导入设备类别限制  bug-21172
             if (!ObjectUtils.isEmpty(type) && "PL_DR".equals(type)) {
+                if (EquipmentClassifityEnum.YLRQ.getCode().equals(equList)) {
                     return this.baseMapper.queryAllEquCategoriesUnderTheEquList(equList).stream()
                             .filter(x -> "2300".equals(x.getDictDataKey()))
                             .collect(Collectors.toList());
                 }
-            // 历史数据新增设备类别限制 bug-21139
-            if (!ObjectUtils.isEmpty(equList) && "8000".equals(equList)) {
+                if (EquipmentClassifityEnum.YLGD.getCode().equals(equList) && "his".equals(dataSource)) {
                     return this.baseMapper.queryAllEquCategoriesUnderTheEquList(equList).stream()
                             .filter(x -> "8300".equals(x.getDictDataKey()))
                             .collect(Collectors.toList());
                 }
+                if (EquipmentClassifityEnum.YLGD.getCode().equals(equList) && "black".equals(dataSource)) {
+                    return this.baseMapper.queryAllEquCategoriesUnderTheEquList(equList).stream()
+                            .filter(x -> !"8300".equals(x.getDictDataKey()))
+                            .collect(Collectors.toList());
+                }
+            }
             return this.baseMapper.queryAllEquCategoriesUnderTheEquList(equList);
         }
 
@@ -2474,19 +2479,13 @@ public class IdxBizJgRegisterInfoServiceImpl extends BaseService<IdxBizJgRegiste
             boolMust.must(scBuilder);
         }
         // 设备种类编码
-        if (!ObjectUtils.isEmpty(map.getString(EQU_LIST_CODE))) {
+        if (!ObjectUtils.isEmpty(map.getString("EQU_LIST_CODE"))) {
             BoolQueryBuilder elcBuilder = QueryBuilders.boolQuery();
-            String test = QueryParser.escape(map.getString(EQU_LIST_CODE));
-            elcBuilder.must(QueryBuilders.matchPhraseQuery(EQU_LIST_CODE, test));
+            String test = QueryParser.escape(map.getString("EQU_LIST_CODE"));
+            elcBuilder.must(QueryBuilders.matchPhraseQuery("EQU_LIST_CODE", test));
             boolMust.must(elcBuilder);
-        } else {
-            BoolQueryBuilder pBuilder = QueryBuilders.boolQuery();
-            String test = QueryParser.escape("8000");//不查管道，管道新菜单查询
-            pBuilder.mustNot(QueryBuilders.termQuery(EQU_LIST_CODE, test));
-            boolMust.must(pBuilder);
         }
-
-        // 设备品种编码
+        // 设备类别编码
         if (!ObjectUtils.isEmpty(map.getString("EQU_DEFINE_CODE"))) {
             BoolQueryBuilder elcBuilder = QueryBuilders.boolQuery();
             String test = QueryParser.escape(map.getString("EQU_DEFINE_CODE"));
@@ -2507,6 +2506,11 @@ public class IdxBizJgRegisterInfoServiceImpl extends BaseService<IdxBizJgRegiste
             String test = QueryParser.escape(map.getString(EQU_CATEGORY_CODE));
             pBuilder.must(QueryBuilders.termQuery(EQU_CATEGORY_CODE, test));
             boolMust.must(pBuilder);
+        } else {
+            BoolQueryBuilder pBuilder = QueryBuilders.boolQuery();
+            String test = QueryParser.escape("8300");// 不查管道，管道新菜单查询
+            pBuilder.mustNot(QueryBuilders.termQuery(EQU_CATEGORY_CODE, test));
+            boolMust.must(pBuilder);
         }
         // 是否车用气瓶
         if (!ObjectUtils.isEmpty(map.getString(WHETHER_VEHICLE_CYLINDER))) {
@@ -3823,7 +3827,7 @@ public class IdxBizJgRegisterInfoServiceImpl extends BaseService<IdxBizJgRegiste
             otherInfo.setRecDate(new Date());
             otherInfo.setCylinderStampAttachment(cylinderStampAttachment);
             if ("his".equals(equipInfoDto.getDataSource())) {
-                otherInfo.setSupervisoryCode(this.getSupervisoryCode(equipInfoDto.getPossession(), registerInfo));
+                otherInfo.setSupervisoryCode(this.getSupervisoryCode(equipInfoDto.getPossession(), registerInfo.getEquCategory()));
             }
             otherInfo.setClaimStatus("已认领");
             otherInfoList.add(otherInfo);
@@ -4337,13 +4341,13 @@ public class IdxBizJgRegisterInfoServiceImpl extends BaseService<IdxBizJgRegiste
     /**
      * 生成监管码
      */
-    private String getSupervisoryCode(String possession, IdxBizJgRegisterInfo registerInfo) {
+    public String getSupervisoryCode(String possession, String equCategory) {
         Map<String, Object> map = new HashMap<>();
         boolean isXiXian = XI_XIAN.getCode().equals(possession);
         String cityOrCountyCode = isXiXian ? XIAN_YANG.getCode() : possession;
         map.put("cityCode", cityOrCountyCode);
         map.put("isXiXian", isXiXian ? 1 : 0);
-        map.put("equCategory", registerInfo.getEquCategory());
+        map.put("equCategory", equCategory);
         map.put("countyCode", cityOrCountyCode);
         return Optional.ofNullable(tzsServiceFeignClient.createCode(map).getResult())
                 .filter(res -> !res.isEmpty())