[chg] 优化年检和急修状态判断,list.stream.findFirst

lift-business-service/src/main/java/cn/com/ty/lift/business/annualinspection/controller/AnnualInspectionController.java

@@ -8,6 +8,7 @@ import cn.com.ty.lift.business.annualinspection.service.AnnualInspectionService;
 import cn.com.ty.lift.business.common.CountPage;
 import cn.com.ty.lift.business.common.Values;
 import cn.com.ty.lift.business.framework.conf.SystemConfiguration;
+import cn.com.ty.lift.business.library.service.PlatformCompanyLiftRelevanceService;
 import cn.com.ty.lift.common.utils.AliyunOSSUtil;
 import cn.com.xwy.boot.web.dto.RestResponse;
 import cn.hutool.core.util.ObjectUtil;
@@ -45,6 +46,8 @@ public class AnnualInspectionController {
 
     private AliyunOSSUtil aliyunOSSUtil;
 
+    private PlatformCompanyLiftRelevanceService platformCompanyLiftRelevanceService;
+
     /**
      * @description 根据id查询
      * @date 2019/12/10 10:19
@@ -149,7 +152,7 @@ public class AnnualInspectionController {
         Integer stepStatus = entity.getStepStatus();
 
         //0 --> 1 维保工确认年检计划
-        if(oldStepStatus == Values.AI_STATUS_NOT_START && stepStatus != Values.AI_STATUS_NOT_START && stepStatus != Values.AI_STATUS_COMFIRM){
+        if(Values.aiStatusNotStart(oldStepStatus) && !Values.aiSameNext(oldStepStatus,stepStatus)){
             return RestResponse.fail("请执行[确认年检计划]操作");
         }
         /**
@@ -157,16 +160,16 @@ public class AnnualInspectionController {
          * 2  维保工上传自检报告,选择自检时间 或者 文员设置 是否检查限速器和荷载年检设置，
          *             文员也可以上传自检报告或者确认自检报告和自检时间，自检时间以最后设置的为准
          */
-        if(oldStepStatus == Values.AI_STATUS_COMFIRM && stepStatus != Values.AI_STATUS_SELFCHECK){
+        if(Values.aiStatusComfirm(oldStepStatus) && !Values.aiNextStatus(oldStepStatus,stepStatus)){
             return RestResponse.fail("请执行[上传自检报告]操作");
         }
         /**
          * 2  维保工上传自检报告,选择自检时间 或者 文员设置 是否检查限速器和荷载年检设置，
          *             文员也可以上传自检报告或者确认自检报告和自检时间，自检时间以最后设置的为准
          */
-        if(oldStepStatus == Values.AI_STATUS_SELFCHECK){
+        if(Values.aiStatusSelfcheck(oldStepStatus)){
             // 修改自检信息
-            if(stepStatus == oldStepStatus){
+            if(Values.aiSameStatus(oldStepStatus,stepStatus)){
                 if(StrUtil.isEmpty(entity.getSelfcheckReportImg())){
                     return RestResponse.fail("请执行[上传自检报告]操作");
                 }
@@ -174,7 +177,7 @@ public class AnnualInspectionController {
                     return RestResponse.fail("请确认自检时间");
                 }
                 //流转到下一个状态 2 --> 3
-            }else if(stepStatus == Values.AI_STATUS_CHECK_COMFIRM){
+            }else if(Values.aiStatusCheckComfirm(stepStatus)){
                 //3  企业文员确认现场检验时间，录入人员信息，政府质检，企业质检，联系电话
                 if(ObjectUtil.isEmpty(entity.getCheckDate())){
                     return RestResponse.fail("请设置现场检验时间");
@@ -193,13 +196,13 @@ public class AnnualInspectionController {
             }
         }
         // 3 --> 4  维保工上传检验结果
-        if(oldStepStatus == Values.AI_STATUS_CHECK_COMFIRM && stepStatus != Values.AI_STATUS_CHECK_UPLOAD){
+        if(Values.aiStatusCheckComfirm(oldStepStatus) && !Values.aiNextStatus(oldStepStatus,stepStatus)){
             return RestResponse.fail("请执行[上传检验结果]操作");
         }
         //4 检查上传检验结果
-        if(oldStepStatus == Values.AI_STATUS_CHECK_UPLOAD){
+        if(Values.aiStatusCheckUpload(oldStepStatus)){
             //修改检验结果
-            if(stepStatus == oldStepStatus){
+            if(Values.aiSameStatus(oldStepStatus,stepStatus)){
                 if(StrUtil.isEmpty(entity.getCheckResultImg())){
                     return RestResponse.fail("请执行[上传检验结果]操作");
                 }
@@ -207,14 +210,14 @@ public class AnnualInspectionController {
                     return RestResponse.fail("请执行[确认检验时间]操作");
                 }
                 //流转到下一个状态
-            }else if((stepStatus < Values.AI_STATUS_CHECK_QUALIFIED || stepStatus > Values.AI_STATUS_CHECK_UNQUALIFIED)){
+            }else if(!Values.aiInStatus(Values.AI_STATUS_CHECK_QUALIFIED,stepStatus,Values.AI_STATUS_CHECK_UNQUALIFIED)){
             /**
              *  5	企业文员确认检验结果-合格
              *  6	企业文员确认检验结果-整改
              *  7	企业文员确认检验结果-不合格
              */
                 return RestResponse.fail("请执行[确认检验结果]操作");
-            } else if(stepStatus == Values.AI_STATUS_CHECK_RECTIFICATION){
+            } else if(Values.aiStatusCheckRectification(stepStatus)){
                 /**
                  * 6 检验结果整改，回到阶段2
                  * (3  企业文员确认现场检验时间 录入人员信息，政府质检，企业质检，联系电话)
@@ -227,8 +230,8 @@ public class AnnualInspectionController {
          * 5	企业文员确认检验结果-合格 --> 8	维保工上传年检报告和合格证
          * 7	企业文员确认检验结果-不合格-->8	维保工上传年检报告和合格证
          */
-        if(oldStepStatus == Values.AI_STATUS_CHECK_QUALIFIED || oldStepStatus == Values.AI_STATUS_CHECK_UNQUALIFIED){
-            if(stepStatus == Values.AI_STATUS_CERTIFICATE_REPORT_UPLOAD){
+        if(Values.aiStatusCheckQualified(oldStepStatus) || Values.aiStatusCheckUnqualified(oldStepStatus)){
+            if(Values.aiStatusCertificateReportUpload(stepStatus)){
                 if(StrUtil.isEmpty(entity.getCertificateImgUrl()) && StrUtil.isEmpty(entity.getAnnualInspectionImg())){
                     return RestResponse.fail("请执行[上传年检报告和合格证]操作");
                 }
@@ -240,13 +243,13 @@ public class AnnualInspectionController {
          * 8	维保工上传年检报告和合格证--> 9  企业文员确认年检报告和合格证 -合格
          * 8	维保工上传年检报告和合格证--> 10  企业文员确认年检报告和合格证 -不合格
          */
-        if(oldStepStatus == Values.AI_STATUS_CERTIFICATE_REPORT_UPLOAD){
+        if(Values.aiStatusCertificateReportUpload(oldStepStatus)){
             //修改年检报告和合格证
             if(stepStatus == oldStepStatus){
                 if(StrUtil.isEmpty(entity.getCertificateImgUrl()) && StrUtil.isEmpty(entity.getAnnualInspectionImg())){
                     return RestResponse.fail("请执行[上传年检报告和合格证]操作");
                 }
-            }else if(stepStatus == Values.AI_STATUS_CERTIFICATE_REPORT_QUALIFIED){
+            }else if(Values.aiStatusCertificateReportQualified(stepStatus)){
                 //合格：文员确认年检报告并设置下次年检时间
                 if(null == entity.getNextInspectionTime()){
                     return RestResponse.fail("请设置下次年检时间");
@@ -254,7 +257,7 @@ public class AnnualInspectionController {
                 // 设置年检完成 status = 1
                 entity.setFinishTime(LocalDateTime.now());
                 entity.setStatus(1);
-            }else if(stepStatus == Values.AI_STATUS_CERTIFICATE_REPORT_UNQUALIFIED){
+            }else if(Values.aiStatusCertificateReportUnqualified(stepStatus)){
                 // 设置年检完成 status = 1
                 entity.setFinishTime(LocalDateTime.now());
                 entity.setStatus(1);

lift-business-service/src/main/java/cn/com/ty/lift/business/annualinspection/service/AnnualInspectionService.java

@@ -7,9 +7,12 @@ import cn.com.ty.lift.business.annualinspection.mapper.AnnualInspectionMapper;
 import cn.com.ty.lift.business.common.Values;
 import cn.com.ty.lift.business.library.dao.entity.Lift;
 import cn.com.ty.lift.business.library.dao.entity.LiftHistory;
+import cn.com.ty.lift.business.library.dao.entity.PlatformCompanyLiftRelevance;
 import cn.com.ty.lift.business.library.service.LiftHistoryService;
 import cn.com.ty.lift.business.library.service.LiftService;
+import cn.com.ty.lift.business.library.service.PlatformCompanyLiftRelevanceService;
 import cn.com.ty.lift.business.maintenance.service.MaintenancePlanService;
+import cn.com.ty.lift.common.constants.CommonEnum;
 import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.core.toolkit.IdWorker;
@@ -43,6 +46,9 @@ public class AnnualInspectionService extends ServiceImpl<AnnualInspectionMapper,
     @Autowired
     private LiftHistoryService liftHistoryService;
 
+    @Autowired
+    private PlatformCompanyLiftRelevanceService platformCompanyLiftRelevanceService;
+
     public IPage<InspectionResponse> pageByCondition(InspectionRequest request) {
         long pageNum = request.getPageNum();
         long pageSize = request.getPageSize();
@@ -66,6 +72,8 @@ public class AnnualInspectionService extends ServiceImpl<AnnualInspectionMapper,
     }
 
     /**
+     * 阶段2 修改电梯的业务状态为年检中
+     * 阶段3 如果合格，修改电梯的业务状态为正常，
      * 完成年检，如果是不合格，清空维保计划，如果是合格，直接更新
      * @param entity
      * @return
@@ -76,8 +84,41 @@ public class AnnualInspectionService extends ServiceImpl<AnnualInspectionMapper,
         if (!up){
             return false;
         }
+        Integer stepStatus = entity.getStepStatus();
+        Integer stepName = entity.getStepName();
+        //阶段2 修改电梯的业务状态为年检中
+        if(Values.aiStepTwo(stepName)){
+            PlatformCompanyLiftRelevance relevance = platformCompanyLiftRelevanceService.findByMtCompanyAndLift(entity.getMtCompanyId(),entity.getLiftId());
+            if(null != relevance){
+                relevance.setLiftCompanyStatus(CommonEnum.LiftStatus.ANNUAL_INSPECTION.getCode());
+                boolean re = platformCompanyLiftRelevanceService.updateById(relevance);
+                if(re){
+                    return true;
+                }else{
+                    //强制手动事务回滚
+                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+                    return false;
+                }
+            }
+        }
+
+        //阶段3 如果合格，修改电梯的业务状态为正常，
+        if(Values.aiStepThree(stepName)){
+            PlatformCompanyLiftRelevance relevance = platformCompanyLiftRelevanceService.findByMtCompanyAndLift(entity.getMtCompanyId(),entity.getLiftId());
+            if(null != relevance){
+                relevance.setLiftCompanyStatus(CommonEnum.LiftStatus.NORMAL.getCode());
+                boolean re = platformCompanyLiftRelevanceService.updateById(relevance);
+                if(re){
+                    return true;
+                }else{
+                    //强制手动事务回滚
+                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+                    return false;
+                }
+            }
+        }
         //todo 不合格：流程结束，电梯扭转到不合格状态列表，电梯停保，清理维保计划记录
-        if(entity.getStepStatus() == Values.AI_STATUS_CERTIFICATE_REPORT_UNQUALIFIED) {
+        if(Values.aiStatusCertificateReportUnqualified(stepStatus)) {
             boolean mp = maintenancePlanService.cleanPlan(entity.getMtCompanyId(), entity.getLiftId());
             if (mp) {
                 return true;
@@ -86,9 +127,9 @@ public class AnnualInspectionService extends ServiceImpl<AnnualInspectionMapper,
                 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                 return false;
             }
-            //todo:合格：修改电梯的年检时间lift-annual_inspection_date，增加lift_history记录
         }
-        if(entity.getStepStatus() == Values.AI_STATUS_CERTIFICATE_REPORT_QUALIFIED){
+        //todo:合格：修改电梯的年检时间lift-annual_inspection_date，增加lift_history记录
+        if(Values.aiStatusCertificateReportQualified(stepStatus)){
             Lift lift = liftService.getById(entity.getLiftId());
             if(null == lift){
                 return false;

lift-business-service/src/main/java/cn/com/ty/lift/business/common/Values.java

@@ -11,90 +11,197 @@ public interface Values {
      * 年检未开始0
      */
     int AI_STEP_NOT_START = 0;
+
+    /**
+     * 判断年检是否开始
+     * @param step
+     * @return
+     */
+    static boolean aiNotStart(int step){
+        return AI_STEP_NOT_START == step;
+    }
     /**
      * 年检 第一阶段
      */
     int AI_STEP_ONE = 1;
+
+    /**
+     * 判断是否为年检阶段一
+     * @param step
+     * @return
+     */
+    static boolean aiStepOne(int step){
+        return AI_STEP_ONE == step;
+    }
     /**
      * 年检 第二阶段
      */
     int AI_STEP_TWO = 2;
+
+    /**
+     * 判断是否为年检阶段二
+     * @param step
+     * @return
+     */
+    static boolean aiStepTwo(int step){
+        return AI_STEP_TWO == step;
+    }
     /**
      * 年检 第三阶段
      */
     int AI_STEP_THREE = 3;
+
+    /**
+     * 判断是否为年检阶段三
+     * @param step
+     * @return
+     */
+    static boolean aiStepThree(int step){
+        return AI_STEP_THREE == step;
+    }
     /**
      * 年检 第四阶段
      */
     int AI_STEP_FOUR = 4;
 
+    /**
+     * 判断是否为年检阶段四
+     * @param step
+     * @return
+     */
+    static boolean aiStepFour(int step){
+        return AI_STEP_FOUR == step;
+    }
+
     /**
      * 0 年检计划初始状态
      */
     int AI_STATUS_NOT_START = 0;
+
+    static boolean aiStatusNotStart(int status){
+        return AI_STEP_NOT_START == status;
+    }
     /**
      * 1  维保工确认年检计划
      */
     int AI_STATUS_COMFIRM = 1;
+
+    static boolean aiStatusComfirm(int status){
+        return AI_STATUS_COMFIRM == status;
+    }
     /**
      * 2  维保工上传自检报告,选择自检时间 或者 文员设置 是否检查限速器和荷载年检设置，
      *             文员也可以上传自检报告或者确认自检报告和自检时间，自检时间以最后设置的为准
      */
     int AI_STATUS_SELFCHECK = 2;
+
+    static boolean aiStatusSelfcheck(int status){
+        return AI_STATUS_SELFCHECK == status;
+    }
     /**
      * 3  企业文员确认现场检验时间
      *             录入人员信息，政府质检，企业质检，联系电话
      */
     int AI_STATUS_CHECK_COMFIRM = 3;
+
+    static boolean aiStatusCheckComfirm(int status){
+        return AI_STATUS_CHECK_COMFIRM == status;
+    }
     /**
      * 4	维保工上传检验结果
      */
     int AI_STATUS_CHECK_UPLOAD = 4;
+
+    static boolean aiStatusCheckUpload(int status){
+        return AI_STATUS_CHECK_UPLOAD == status;
+    }
     /**
      * 5	企业文员确认检验结果-合格 --> 不能算年检超期
      */
     int AI_STATUS_CHECK_QUALIFIED = 5;
+
+    static boolean aiStatusCheckQualified(int status){
+        return AI_STATUS_CHECK_QUALIFIED == status;
+    }
     /**
      * 6	企业文员确认检验结果-整改 --> 回到第二阶段
      */
     int AI_STATUS_CHECK_RECTIFICATION = 6;
+
+    static boolean aiStatusCheckRectification(int status){
+        return AI_STATUS_CHECK_RECTIFICATION == status;
+    }
     /**
      * 7	企业文员确认检验结果-不合格 --> 可以算年检超期
      */
     int AI_STATUS_CHECK_UNQUALIFIED = 7;
+
+    static boolean aiStatusCheckUnqualified(int status){
+        return AI_STATUS_CHECK_UNQUALIFIED == status;
+    }
     /**
      * 8	维保工上传年检报告和合格证
      */
     int AI_STATUS_CERTIFICATE_REPORT_UPLOAD = 8;
+
+    static boolean aiStatusCertificateReportUpload(int status){
+        return AI_STATUS_CERTIFICATE_REPORT_UPLOAD == status;
+    }
     /**
      * 9	企业文员确认年检报告和合格证-合格
      */
     int AI_STATUS_CERTIFICATE_REPORT_QUALIFIED = 9;
+
+    static boolean aiStatusCertificateReportQualified(int status){
+        return AI_STATUS_CERTIFICATE_REPORT_QUALIFIED == status;
+    }
     /**
      * 10	企业文员确认年检报告和合格证-不合格 -->停用电梯
      */
     int AI_STATUS_CERTIFICATE_REPORT_UNQUALIFIED = 10;
+
+    static boolean aiStatusCertificateReportUnqualified(int status){
+        return AI_STATUS_CERTIFICATE_REPORT_UNQUALIFIED == status;
+    }
     /**
      * 急修状态（-1 暂停中）
      */
     int ER_STATUS_STOPING = -1;
+
+    static boolean erStatusStoping(int status){
+        return ER_STATUS_STOPING == status;
+    }
     /**
      * 急修状态（0 待修理）
      */
     int ER_STATUS_TO_REPAIRED = 0;
+
+    static boolean erStatusToRepaired(int status){
+        return ER_STATUS_TO_REPAIRED == status;
+    }
     /**
      * 急修状态（1 修理中）
      */
     int ER_STATUS_REPAIRING = 1;
+
+    static boolean erStatusRepairing(int status){
+        return ER_STATUS_REPAIRING == status;
+    }
     /**
      * 急修状态（2 完成）
      */
     int ER_STATUS_FINISH = 2;
+
+    static boolean erStatusFinish(int status){
+        return ER_STATUS_FINISH == status;
+    }
     /**
      * 急修状态（3 关闭）
      */
     int ER_STATUS_CLOSE = 3;
-
+    static boolean erStatusClose(int status){
+        return ER_STATUS_CLOSE == status;
+    }
     /**
      * 根据年检的状态值返回成年检的状态阶段
      * @param stepStatus
@@ -131,7 +238,45 @@ public interface Values {
         return stepName;
     }
 
-    static boolean isRepairing(int status){
-        return false;
+
+    /**
+     * 判断年检状态是否处于其他阶段之间 min < middle < max
+     * @param middle
+     * @param min
+     * @param max
+     * @return
+     */
+    static boolean aiInStatus(int min, int middle,int max){
+        return min <= middle && middle <= max;
+    }
+
+    /**
+     * 判断两个年检状态是否一样 one == two
+     * @param one
+     * @param two
+     * @return
+     */
+    static boolean aiSameStatus(int one,int two){
+        return one == two;
+    }
+
+    /**
+     * 判断年检中一个状态是否为另一个状态的下一个状态
+     * @param front
+     * @param behind
+     * @return
+     */
+    static boolean aiNextStatus(int front,int behind){
+        return front + 1 == behind;
+    }
+
+    /**
+     * 判断年检中两个状态相同或者为下一个状态
+     * @param front
+     * @param behind
+     * @return
+     */
+    static boolean aiSameNext(int front,int behind){
+        return front == behind || front + 1 == behind;
     }
 }

lift-business-service/src/main/java/cn/com/ty/lift/business/emergency/controller/EmergencyRepairController.java

@@ -213,7 +213,7 @@ public class EmergencyRepairController {
     @PostMapping("close")
     public RestResponse close(@RequestBody RepairRequest request){
         Long id = request.getId();
-        if(null == id){
+        if(null == id || id <= 0){
             return RestResponse.failParam();
         }
         String reason = request.getCloseReason();

lift-business-service/src/main/java/cn/com/ty/lift/business/emergency/service/EmergencyRepairService.java

@@ -136,7 +136,7 @@ public class EmergencyRepairService extends ServiceImpl<EmergencyRepairMapper, E
             return true;
         }
         // 如果存在，并且急修中
-        if(emergencyRepair.getStatus() == Values.ER_STATUS_REPAIRING){
+        if(Values.erStatusRepairing(emergencyRepair.getStatus())){
             //急修改成暂停中
             emergencyRepair.setStatus(Values.ER_STATUS_STOPING);
             boolean er = updateById(emergencyRepair);
@@ -172,7 +172,7 @@ public class EmergencyRepairService extends ServiceImpl<EmergencyRepairMapper, E
         if(null == emergencyRepair){
             return true;
         }
-        if(emergencyRepair.getStatus() == Values.ER_STATUS_STOPING){
+        if(Values.erStatusStoping(emergencyRepair.getStatus())){
             //恢复暂停中的急修为急修中
             emergencyRepair.setStatus(Values.ER_STATUS_REPAIRING);
             boolean er = updateById(emergencyRepair);

lift-business-service/src/main/java/cn/com/ty/lift/business/library/service/LiftService.java

@@ -5,7 +5,10 @@ import cn.com.ty.lift.business.library.dao.entity.Lift;
 import cn.com.ty.lift.business.library.dao.entity.PlatformCompanyLiftRelevance;
 import cn.com.ty.lift.business.library.dao.entity.model.LiftImportModel;
 import cn.com.ty.lift.business.library.dao.entity.model.LiftProjectModel;
-import cn.com.ty.lift.business.library.dao.entity.model.request.*;
+import cn.com.ty.lift.business.library.dao.entity.model.request.LiftChooseRequest;
+import cn.com.ty.lift.business.library.dao.entity.model.request.LiftExtensionRequest;
+import cn.com.ty.lift.business.library.dao.entity.model.request.LiftRequest;
+import cn.com.ty.lift.business.library.dao.entity.model.request.ProjectLiftRequest;
 import cn.com.ty.lift.business.library.dao.entity.model.response.LiftExtendResponse;
 import cn.com.ty.lift.business.library.dao.entity.model.response.LiftResponse;
 import cn.com.ty.lift.business.library.dao.mapper.LiftMapper;
@@ -35,7 +38,6 @@ import org.springframework.transaction.interceptor.TransactionAspectSupport;
 
 import javax.annotation.Resource;
 import java.util.*;
-import java.util.stream.Collectors;
 
 /**
  * @author bieao
@@ -296,24 +298,19 @@ public class LiftService extends ServiceImpl<LiftMapper,Lift> {
 
         for(int i = 0; i< liftImportModels.size();i++){
             LiftImportModel item = liftImportModels.get(i);
-            //0 属性表头，1 文字表头，2 记录行
-            int rowNum = i + 2;
             Lift lift = new Lift();
             //复制解析model中的值到lift中
             BeanUtil.copyProperties(item,lift,true);
             log.info("复制电梯属性后：{}",lift);
-            ProjectLiftRelevance projectLiftRelevance = null;
-            PlatformCompanyLiftRelevance platformCompanyLiftRelevance = null;
 
             String registrationCode = item.getRegistrationCode();
-            List<LiftProjectModel> liftProjectModelTemp = liftProjectModelList.stream().filter(lpm -> (
+            LiftProjectModel liftProjectModel = liftProjectModelList.stream().filter(lpm -> (
                     StrUtil.equals(registrationCode, lpm.getRegistrationCode())
-                    )).distinct().limit(1).collect(Collectors.toList());
+            )).distinct().limit(1).findFirst().get();
 
-            if(null != liftProjectModelTemp && !liftProjectModelTemp.isEmpty()){
+            if(null != liftProjectModel){
                 //如果已经存在lift，取出id赋值
-                LiftProjectModel model = liftProjectModelTemp.get(0);
-                lift.setId(model.getLiftId());
+                lift.setId(liftProjectModel.getLiftId());
             }else{
                 //如果不存在,新建id赋值
                 lift.setId(IdWorker.getId());
@@ -321,10 +318,10 @@ public class LiftService extends ServiceImpl<LiftMapper,Lift> {
                 lifts.add(lift);
             }
 
-            List<PlatformCompanyLiftRelevance> pclrs = platformCompanyLiftRelevanceList.stream().filter(pclr -> (
-                pclr.getLiftId() == lift.getId()
-            )).distinct().limit(1).collect(Collectors.toList());
-            if(ObjectUtil.isEmpty(pclrs)){
+            PlatformCompanyLiftRelevance platformCompanyLiftRelevance = platformCompanyLiftRelevanceList.stream().filter(pclr -> (
+                    pclr.getLiftId() == lift.getId()
+                    )).distinct().limit(1).findFirst().get();
+            if(null == platformCompanyLiftRelevance){
                 //如果不存在就新建
                 platformCompanyLiftRelevance = new PlatformCompanyLiftRelevance();
                 Long relevanceId = IdWorker.getId();
@@ -336,15 +333,13 @@ public class LiftService extends ServiceImpl<LiftMapper,Lift> {
                 log.info("新建PlatformCompanyLiftRelevance:{}",platformCompanyLiftRelevance);
                 //加入到新建list中批量插入
                 platformCompanyLiftRelevances.add(platformCompanyLiftRelevance);
-            }else {
-                platformCompanyLiftRelevance = pclrs.get(0);
             }
 
             //fixme:导入电梯时，是否指定项目导入，添加ProjectLiftRelevance关联信息
-            List<ProjectLiftRelevance> plrs = projectLiftRelevanceList.stream().filter(plr -> (
-                plr.getLiftId() == lift.getId()
-                )).distinct().limit(1).collect(Collectors.toList());
-            if(ObjectUtil.isEmpty(plrs)){
+            ProjectLiftRelevance projectLiftRelevance = projectLiftRelevanceList.stream().filter(plr -> (
+                    plr.getLiftId() == lift.getId()
+            )).distinct().limit(1).findFirst().get();
+            if(null == projectLiftRelevance){
                 projectLiftRelevance = new ProjectLiftRelevance();
                 projectLiftRelevance.setMtCompanyId(mtCompanyId);
                 projectLiftRelevance.setLiftId(lift.getId());

lift-business-service/src/main/java/cn/com/ty/lift/business/project/service/ProjectService.java

@@ -1,14 +1,11 @@
 package cn.com.ty.lift.business.project.service;
 
 import cn.com.ty.lift.business.framework.util.MessageUtils;
-import cn.com.ty.lift.business.project.dao.entity.Project;
-import cn.com.ty.lift.business.project.dao.entity.ProjectHistory;
-import cn.com.ty.lift.business.project.dao.entity.ProjectUser;
+import cn.com.ty.lift.business.project.dao.entity.*;
+import cn.com.ty.lift.business.project.dao.entity.model.ProjectImportModel;
 import cn.com.ty.lift.business.project.dao.entity.model.request.ProjectCompanyRequest;
 import cn.com.ty.lift.business.project.dao.entity.model.request.ProjectExtensionRequest;
-import cn.com.ty.lift.business.project.dao.entity.*;
 import cn.com.ty.lift.business.project.dao.entity.model.request.ProjectRegionRequest;
-import cn.com.ty.lift.business.project.dao.entity.model.ProjectImportModel;
 import cn.com.ty.lift.business.project.dao.entity.model.request.ProjectRequest;
 import cn.com.ty.lift.business.project.dao.entity.model.response.ProjectResponse;
 import cn.com.ty.lift.business.project.dao.mapper.ProjectHistoryMapper;
@@ -36,7 +33,6 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.stream.Collectors;
 
 /**
  * @author bieao
@@ -235,55 +231,46 @@ public class ProjectService extends ServiceImpl<ProjectMapper,Project> {
             BeanUtil.copyProperties(item,project,true);
             log.info("复制属性后的project:{}",project);
             //查找省
-            String provname = item.getProvince();
-            AreaCode province = provinceList.stream().filter(areaCode -> (StrUtil.equals(areaCode.getName(),provname))).distinct().limit(1).collect(Collectors.toList()).get(0);
+            String provName = item.getProvince();
+            AreaCode province = provinceList.stream().filter(areaCode -> (StrUtil.equals(areaCode.getName(), provName))).distinct().limit(1).findFirst().get();
             if(null == province){
-                log.error("表格数据有误，行数：{}, {}没有匹配省",rowNum,provname);
-                return RestResponse.fail(StrUtil.format("表格数据有误，行数：{}, {}没有匹配省",rowNum,provname));
+                log.error("表格数据有误，行数：{}, {}没有匹配省",rowNum,provName);
+                return RestResponse.fail(StrUtil.format("表格数据有误，行数：{}, {}没有匹配省",rowNum,provName));
             }
             //项目中设置省
             project.setProvince(province.getName());
             project.setProvinceCode(province.getCode());
             // 查找市
-            String cityname = item.getCity();
-            AreaCode city = cityList.stream().filter(areaCode -> (
-                    StrUtil.equals(areaCode.getName(), cityname)
-                    )).distinct().limit(1).collect(Collectors.toList()).get(0);
+            String cityName = item.getCity();
+            AreaCode city = cityList.stream().filter(areaCode -> (StrUtil.equals(areaCode.getName(), cityName))).distinct().limit(1).findFirst().get();
             if(null == city){
-                log.error("表格数据有误，行数：{}, {}没有匹配市",rowNum,cityname);
-                return RestResponse.fail(StrUtil.format("表格数据有误，行数：{}, {}没有匹配市",rowNum,cityname));
+                log.error("表格数据有误，行数：{}, {}没有匹配市",rowNum,cityName);
+                return RestResponse.fail(StrUtil.format("表格数据有误，行数：{}, {}没有匹配市",rowNum,cityName));
             }
             //项目中设置市
             project.setCity(city.getName());
             project.setCityCode(city.getCode());
             //查找区
-            String distname = item.getDistrict();
-            AreaCode district = districtList.stream().filter(areaCode -> (
-                            StrUtil.equals(areaCode.getName(),distname)
-                    )).distinct().limit(1).collect(Collectors.toList()).get(0);
+            String distName = item.getDistrict();
+            AreaCode district = districtList.stream().filter(areaCode -> (StrUtil.equals(areaCode.getName(), distName))).distinct().limit(1).findFirst().get();
             if(null == district){
-                log.error("表格数据有误，行数：{}, {}没有匹配区",rowNum,distname);
-                return RestResponse.fail(StrUtil.format("表格数据有误，行数：{}, {}没有匹配区",rowNum,distname));
+                log.error("表格数据有误，行数：{}, {}没有匹配区",rowNum,distName);
+                return RestResponse.fail(StrUtil.format("表格数据有误，行数：{}, {}没有匹配区",rowNum,distName));
             }
             //项目中设置区
             project.setDistrict(district.getName());
             project.setDistrictCode(district.getCode());
 
             //根据省市查找区域
-            Region region = null;
             String areaName = item.getArea();
-            List<Region> regionTemp = regionList.stream().filter(r -> (
-                    StrUtil.equals(r.getProvinceCode(),province.getCode()) &&
-                            StrUtil.equals(r.getCityCode(),city.getCode()) &&
-                            StrUtil.equals(r.getAreaName(),areaName)
-                    )).distinct().limit(1).collect(Collectors.toList());
-            if(null != regionTemp && regionTemp.size() > 0){
-                region = regionTemp.get(0);
-            }
+            Region region = regionList.stream().filter(r -> (
+                    StrUtil.equals(r.getProvinceCode(), province.getCode()) &&
+                            StrUtil.equals(r.getCityCode(), city.getCode()) &&
+                            StrUtil.equals(r.getAreaName(), areaName)
+            )).distinct().limit(1).findFirst().get();
             //根据省市查找区域,如果区域不存在就新增
             if(null == region) {
-
-                log.error("表格数据有误，行数：{}, {}没有匹配区域",rowNum,distname);
+                log.error("表格数据有误，行数：{}, {}没有匹配区域",rowNum,areaName);
                 return RestResponse.fail(StrUtil.format("表格数据有误，行数：{}, {}没有匹配区域",rowNum,areaName));
 
                 //fixme:待确认，如果表格中导入的区域不存在，直接返回还是新增
@@ -305,15 +292,11 @@ public class ProjectService extends ServiceImpl<ProjectMapper,Project> {
             project.setRegionId(region.getId());
 
             //根据名称查询甲方公司
-            PropertyCompany propertyCompany = null;
             Long ppCompanyId;
             String ppCompanyName = item.getPpCompanyName();
-            List<PropertyCompany> propertyCompanyTemp = propertyCompanyList.stream().filter(company -> (
+            PropertyCompany propertyCompany = propertyCompanyList.stream().filter(company -> (
                     StrUtil.equals(company.getName(),ppCompanyName)
-                    )).distinct().limit(1).collect(Collectors.toList());
-            if(null != propertyCompanyTemp && !propertyCompanyTemp.isEmpty()){
-                propertyCompany = propertyCompanyTemp.get(0);
-            }
+                    )).distinct().limit(1).findFirst().get();
             //如果维保公司不存在，新建，生成id
             if(null == propertyCompany){
                 propertyCompany = new PropertyCompany();
@@ -337,17 +320,13 @@ public class ProjectService extends ServiceImpl<ProjectMapper,Project> {
             project.setPpCompanyId(propertyCompany.getId());
 
             //根据名称查询甲方联系人
-            PropertyContact propertyContact = null;
             String ppCompanyContact = item.getPpCompanyContact();
             String ppTelephone = item.getPpCompanyTelephone();
-            List<PropertyContact> propertyContactTemp = propertyContactList.stream().filter(contact -> (
+            PropertyContact propertyContact = propertyContactList.stream().filter(contact -> (
                     StrUtil.equals(contact.getName(),ppCompanyContact) &&
                             StrUtil.equals(contact.getTelephone(),ppTelephone) &&
                             ppCompanyId == contact.getPpCompanyId()
-                    )).distinct().limit(1).collect(Collectors.toList());
-            if(null != propertyContactTemp && propertyContactTemp.size() > 0){
-                propertyContact = propertyContactTemp.get(0);
-            }
+                    )).distinct().limit(1).findFirst().get();
             if(null == propertyContact){
                 propertyContact = new PropertyContact();
                 Long ppContactId = IdWorker.getId();