Просмотр исходного кода

Merge branch 'develop' of http://132.232.206.88:3000/lift-manager/lift-server into huangyuan-user

黄远 5 лет назад
Родитель
Сommit
f0b265dc01

+ 18 - 15
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);

+ 44 - 3
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;

+ 148 - 3
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;
     }
 }

+ 1 - 1
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();

+ 2 - 2
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);

+ 16 - 21
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());

+ 2 - 2
lift-business-service/src/main/java/cn/com/ty/lift/business/maintenance/dao/entity/MaintenancePlan.java

@@ -1,9 +1,9 @@
 package cn.com.ty.lift.business.maintenance.dao.entity;
 
 import java.time.LocalDate;
-import java.util.Date;
 
 import cn.com.ty.lift.business.common.BaseEntity;
+import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableId;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
@@ -20,7 +20,7 @@ public class MaintenancePlan extends BaseEntity {
     /**
      * 维保计划ID
      */
-    @TableId
+    @TableId(value = "id", type = IdType.ID_WORKER)
 	private Long id;
 
     /**

+ 18 - 3
lift-business-service/src/main/java/cn/com/ty/lift/business/maintenance/dao/entity/model/request/MaintenanceModifyRequest.java

@@ -31,20 +31,35 @@ public class MaintenanceModifyRequest {
     private Long projectId;
 
     /**
-     * 间隔 1-15
+     * 项目电梯关联id
+     */
+    @NotNull(message = "notEmpty")
+    private Long relevanceId;
+
+    /**
+     * 维保工ID
      */
     @NotNull(message = "notEmpty")
+    private Long workerId;
+
+    /**
+     * 期数 1-24
+     */
+    @NotNull(message = "notEmpty")
+    private Integer periods;
+
+    /**
+     * 间隔 1-15
+     */
     private Integer interval;
 
     /**
      * 当前时间
      */
-    @NotNull(message = "notEmpty")
     private LocalDate currentTime;
 
     /**
      * 修改时间
      */
-    @NotNull(message = "notEmpty")
     private LocalDate updateTime;
 }

+ 150 - 78
lift-business-service/src/main/java/cn/com/ty/lift/business/maintenance/service/MaintenancePlanService.java

@@ -13,6 +13,7 @@ import cn.com.ty.lift.business.project.dao.entity.Project;
 import cn.com.ty.lift.business.project.service.ProjectService;
 import cn.com.ty.lift.common.base.ExportRequest;
 import cn.com.ty.lift.common.export.ExportUtils;
+import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
@@ -20,11 +21,13 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
 import java.time.LocalDate;
 import java.time.temporal.ChronoUnit;
 import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * @author bieao
@@ -57,6 +60,11 @@ public class MaintenancePlanService extends ServiceImpl<MaintenancePlanMapper, M
         put("planDate", "计划时间");
     }};
 
+    private QueryWrapper<MaintenancePlan> queryWrapper = new QueryWrapper<>();
+
+    //保养类型 1.半月,2.季度,3.半年,4.全年
+    private int[] maintenanceType = {1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 4};
+
     /**
      * @param request 维保计划列表
      * @return 1.成功, 0.失败, 消息描述
@@ -75,7 +83,6 @@ public class MaintenancePlanService extends ServiceImpl<MaintenancePlanMapper, M
      * @date 2020/1/2 9:43 上午
      */
     public List<MaintenancePlan> detailList(MaintenanceDetailRequest request) {
-        QueryWrapper<MaintenancePlan> queryWrapper = new QueryWrapper<>();
         LambdaQueryWrapper<MaintenancePlan> lambdaQueryWrapper = queryWrapper.lambda();
         lambdaQueryWrapper.eq(MaintenancePlan::getMtCompanyId, request.getMtCompanyId());
         lambdaQueryWrapper.eq(MaintenancePlan::getProjectId, request.getProjectId());
@@ -91,78 +98,33 @@ public class MaintenancePlanService extends ServiceImpl<MaintenancePlanMapper, M
      * @date 2019/12/16 2:14 PM
      */
     public boolean insertBatch(MaintenanceGenerateRequest request) {
-        List<MaintenancePlan> resultList = generatePlan(request);
+        List<MaintenancePlan> resultList = addPlan(request);
         return saveBatch(resultList, resultList.size());
     }
 
-    /**
-     * @param beginTime 项目开始时间
-     * @param endTime   项目结束时间
-     * @param interval  保养间隔
-     * @return 实际期数
-     * @description 计算当前电梯所在项目开始时间到结束时间需要保养的期数
-     * @date 2019/12/16 2:11 PM
-     */
-    public int calculatePeriods(LocalDate beginTime, LocalDate endTime, int interval) {
-        long days = beginTime.until(endTime, ChronoUnit.DAYS);
-        double num = Math.floor(Double.parseDouble(String.valueOf((days / interval))));
-        return (int) num;
-    }
-
     /**
      * @param request 需要保养的电梯
      * @return List<MaintenancePlan> 维保计划列表
-     * @description 生成维保计划
+     * @description 新增维保计划
      * @date 2019/12/16 1:21 PM
      */
-    public List<MaintenancePlan> generatePlan(MaintenanceGenerateRequest request) {
+    public List<MaintenancePlan> addPlan(MaintenanceGenerateRequest request) {
         List<MaintenancePlan> plans = request.getPlanList();
-        //返回维保计划列表
-        List<MaintenancePlan> planList = new ArrayList<>();
-        //保养类型 1.半月,2.季度,3.半年,4.全年
-        int[] maintenanceType = {1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 4};
-        int times = 0;
-        //获取从第几期开始
-        int periods = request.getPeriods();
+        Collection<Project> projects = projectService.getProjectList(request);
         //获取保养间隔
         int interval = request.getInterval();
+        //获取从第几期开始
+        int periods = request.getPeriods();
         //获取首保时间
         LocalDate firstTime = request.getFirstTime();
-        for (MaintenancePlan plan : plans) {
-            //获取项目id
-            Long projectId = plan.getProjectId();
-            Project project = projectService.detail(projectId);
-            if (project != null) {
-                LocalDate beginTime = project.getStartDate();
-                LocalDate endTime = project.getEndDate();
-                //计算当前电梯所在项目开始时间到结束时间需要保养的期数
-                times = calculatePeriods(beginTime, endTime, interval);
-            }
-            for (int i = 0; i < times; i++) {
-                MaintenancePlan entry = new MaintenancePlan();
-                //设置维保计划电梯ID,维保公司ID,项目ID,维保工ID,维保类型
-                entry.setLiftId(plan.getLiftId());
-                entry.setMtCompanyId(plan.getMtCompanyId());
-                entry.setProjectId(projectId);
-                entry.setWorkerId(plan.getWorkerId());
-                entry.setType(maintenanceType[periods - 1]);
-                entry.setDemand(request.getDemand());
-                if (i == 0) {
-                    entry.setPlanDate(firstTime);
-                } else {
-                    //设置维护保养时间
-                    MaintenancePlan maintenancePlan = planList.get(i - 1);
-                    LocalDate planDate = maintenancePlan.getPlanDate().plusDays(interval);
-                    entry.setPlanDate(planDate);
-                }
-                System.out.printf("i:%s,期数:%s,类型:%s,计划时间:%s,%s", (i + 1), periods, entry.getType(), entry.getPlanDate(), "\n");
-                periods++;
-                if (periods == 25) {
-                    periods = 1;
-                }
-                planList.add(entry);
+        List<MaintenancePlan> planList = new ArrayList<>();
+        plans.forEach(plan -> {
+            Optional<Project> project = projects.stream().filter(p -> (p.getId().equals(plan.getProjectId()))).findFirst();
+            if (project.isPresent()) {
+                Project entry = project.get();
+                planList.addAll(generatePlan(plan, periods, interval, firstTime, entry.getEndDate()));
             }
-        }
+        });
         //更新项目电梯关联表中电梯的首保时间和保养间隔
         List<ProjectLiftRelevance> entryList = request.getRelevanceList();
         entryList.forEach(entry -> {
@@ -173,6 +135,64 @@ public class MaintenancePlanService extends ServiceImpl<MaintenancePlanMapper, M
         return planList;
     }
 
+    /**
+     * @param interval 保养间隔
+     * @param beginTime 开始时间
+     * @param endTime 结束时间
+     * @return 期数
+     * @description 获取维保计划生成期数
+     * @date 2020/1/8 8:11 下午
+     */
+    public int getTimes(int interval, LocalDate beginTime, LocalDate endTime) {
+        //计算当前电梯所在项目开始时间到结束时间需要保养的期数
+        long days = beginTime.until(endTime, ChronoUnit.DAYS);
+        double num = Math.floor(Double.parseDouble(String.valueOf((days / interval))));
+        return (int) num;
+    }
+
+    /**
+     * @param plan 维保计划
+     * @param periods 期数
+     * @param interval 保养间隔
+     * @param beginTime 开始时间
+     * @param endTime 结束时间
+     * @return 维保计划列表
+     * @description 生成维保计划
+     * @date 2020/1/8 8:20 下午
+     */
+    public List<MaintenancePlan> generatePlan(MaintenancePlan plan, int periods, int interval, LocalDate beginTime, LocalDate endTime) {
+        //返回维保计划列表
+        List<MaintenancePlan> planList = new ArrayList<>();
+        int times = getTimes(interval, beginTime, endTime);
+        int length = maintenanceType.length;
+        for (int i = 0; i <= times; i++) {
+            MaintenancePlan entry = new MaintenancePlan();
+            entry.setWorkerId(plan.getWorkerId());
+            entry.setLiftId(plan.getLiftId());
+            entry.setProjectId(plan.getProjectId());
+            entry.setMtCompanyId(plan.getMtCompanyId());
+            int mod = periods % length;
+            //设置维保类型
+            if (mod == 0) {
+                entry.setType(maintenanceType[length - 1]);
+            } else {
+                entry.setType(maintenanceType[mod - 1]);
+            }
+            if (i == 0) {
+                entry.setPlanDate(beginTime);
+            } else {
+                //设置维护保养时间
+                MaintenancePlan maintenancePlan = planList.get(i - 1);
+                LocalDate planDate = maintenancePlan.getPlanDate().plusDays(interval);
+                entry.setPlanDate(planDate);
+            }
+            System.out.printf("i:%s,期数:%s,类型:%s,计划时间:%s,%s", (i + 1), periods, entry.getType(), entry.getPlanDate(), "\n");
+            periods++;
+            planList.add(entry);
+        }
+        return planList;
+    }
+
     /**
      * @param request 当前时间
      * @return List<MaintenancePlan> 维保计划列表
@@ -180,39 +200,91 @@ public class MaintenancePlanService extends ServiceImpl<MaintenancePlanMapper, M
      * @date 2020/1/7 2:40 下午
      */
     public List<MaintenancePlan> findPlanList(MaintenanceModifyRequest request){
-        QueryWrapper<MaintenancePlan> queryWrapper = new QueryWrapper<>();
         LambdaQueryWrapper<MaintenancePlan> lambdaQueryWrapper = queryWrapper.lambda();
         lambdaQueryWrapper.eq(MaintenancePlan::getLiftId, request.getLiftId());
         lambdaQueryWrapper.eq(MaintenancePlan::getProjectId, request.getProjectId());
         lambdaQueryWrapper.eq(MaintenancePlan::getMtCompanyId, request.getMtCompanyId());
-        lambdaQueryWrapper.gt(MaintenancePlan::getPlanDate, request.getCurrentTime());
+        lambdaQueryWrapper.ge(MaintenancePlan::getPlanDate, request.getCurrentTime());
         return list(lambdaQueryWrapper);
     }
 
+
+    /**
+     * @param mtCompanyId 公司id
+     * @param liftId 电梯id
+     * @return 维保计划列表
+     * @description 获取电梯所有维保计划
+     * @date 2020/1/8 10:33 上午
+     */
+    public List<MaintenancePlan> findAllPlanList(Long mtCompanyId, Long liftId) {
+        LambdaQueryWrapper<MaintenancePlan> lambdaQueryWrapper = queryWrapper.lambda();
+        lambdaQueryWrapper.eq(MaintenancePlan::getMtCompanyId,mtCompanyId);
+        lambdaQueryWrapper.eq(MaintenancePlan::getLiftId,liftId);
+        return list(lambdaQueryWrapper);
+    }
+
+
     /**
      * @param request 修改维保计划请求
      * @return 是否修改成功
      * @description 修改维保计划
      * @date 2019/12/16 5:25 PM
      */
+    @Transactional(rollbackFor = Exception.class)
     public boolean modifyPlan(MaintenanceModifyRequest request) {
-        List<MaintenancePlan> resultList = new ArrayList<>();
+        //获取公司id
+        Long mtCompanyId = request.getMtCompanyId();
+        //获取公司id
+        Long projectId = request.getProjectId();
+        //获取公司id
+        Long liftId = request.getLiftId();
+        MaintenancePlan plan = new MaintenancePlan();
+        plan.setProjectId(projectId);
+        plan.setMtCompanyId(mtCompanyId);
+        plan.setLiftId(liftId);
+        plan.setWorkerId(request.getWorkerId());
+        Project project = projectService.detail(request.getProjectId());
+        if (ObjectUtil.isEmpty(project)) return false;
+        LocalDate endDate = project.getEndDate();
+        //获取当前的保养时间
+        LocalDate currentTime = request.getCurrentTime();
         //获取修改的保养时间
         LocalDate updateTime = request.getUpdateTime();
-        //获取保养间隔
-        Integer interval = request.getInterval();
-        //获取当前时间后的维保计划列表
-        List<MaintenancePlan> planList = findPlanList(request);
-        for (int i = 0, size = planList.size(); i < size; i++) {
-            MaintenancePlan entry = planList.get(i);
-            if (i == 0) {
-                entry.setPlanDate(updateTime);
-            } else {
-                entry.setPlanDate(entry.getPlanDate().plusDays(interval));
-            }
-            resultList.add(entry);
+        //获取修改的保养间隔
+        Integer updateInterval = request.getInterval();
+        //获取当前期数
+        Integer periods = request.getPeriods();
+        //获取当前电梯的保养间隔
+        ProjectLiftRelevance entry = projectLiftRelevanceService.getOne(mtCompanyId, liftId);
+        if (ObjectUtil.isEmpty(entry)) return false;
+        int interval = entry.getPlanInterval();
+        boolean isNotNull = ObjectUtil.isNotEmpty(currentTime) && ObjectUtil.isNotEmpty(updateTime);
+        boolean isNull = ObjectUtil.isEmpty(currentTime) && ObjectUtil.isEmpty(updateTime);
+        List<MaintenancePlan> planList;
+        List<MaintenancePlan> plans = new ArrayList<>();
+        if (isNotNull && ObjectUtil.isEmpty(updateInterval)) {
+            //获取当前时间后的维保计划列表,并清除计划
+            planList = findPlanList(request);
+            removeByIds(planList.stream().map(MaintenancePlan::getId).collect(Collectors.toList()));
+            //按照修改时间重新生成计划
+            plans = generatePlan(plan, periods, interval, updateTime, endDate);
+        } else if (isNull && ObjectUtil.isNotEmpty(updateInterval)) {
+            //获取电梯所有维保计划,并清除计划
+            planList = findAllPlanList(mtCompanyId, liftId);
+            removeByIds(planList.stream().map(MaintenancePlan::getId).collect(Collectors.toList()));
+            //更新项目电梯关联表保养间隔
+            projectLiftRelevanceService.modifyPlanInterval(request.getRelevanceId(), updateInterval);
+            plans = generatePlan(plan, periods, updateInterval, entry.getFirstTime(), endDate);
+        } else if (isNotNull && ObjectUtil.isNotEmpty(updateInterval)) {
+            //获取当前时间后的维保计划列表,并清除计划
+            planList = findPlanList(request);
+            removeByIds(planList.stream().map(MaintenancePlan::getId).collect(Collectors.toList()));
+            //更新项目电梯关联表保养间隔
+            projectLiftRelevanceService.modifyPlanInterval(request.getRelevanceId(), updateInterval);
+            //按照修改时间重新生成计划
+            plans = generatePlan(plan, periods, updateInterval, updateTime, endDate);
         }
-        return updateBatchById(resultList, resultList.size());
+        return saveBatch(plans, plans.size());
     }
 
     /**
@@ -223,9 +295,9 @@ public class MaintenancePlanService extends ServiceImpl<MaintenancePlanMapper, M
      * @date 2019/12/28 2:00 PM
      */
     public boolean removeMaintenancePlan(Long mtCompanyId, List<Long> liftList) {
-        QueryWrapper<MaintenancePlan> queryWrapper = new QueryWrapper<>();
-        queryWrapper.eq("mt_company_id", mtCompanyId);
-        queryWrapper.in("lift_id", liftList);
+        LambdaQueryWrapper<MaintenancePlan> lambdaQueryWrapper = queryWrapper.lambda();
+        lambdaQueryWrapper.eq(MaintenancePlan::getMtCompanyId, mtCompanyId);
+        lambdaQueryWrapper.in(MaintenancePlan::getLiftId, liftList);
         return remove(queryWrapper);
     }
 

+ 30 - 0
lift-business-service/src/main/java/cn/com/ty/lift/business/project/service/ProjectLiftRelevanceService.java

@@ -143,6 +143,36 @@ public class ProjectLiftRelevanceService extends ServiceImpl<ProjectLiftRelevanc
         return list(lambdaQueryWrapper);
     }
 
+    /**
+     * @param mtCompanyId 公司id
+     * @param liftId 电梯id
+     * @return ProjectLiftRelevance 项目电梯记录
+     * @description 根据公司id和电梯id查询项目电梯记录
+     * @date 2020/1/8 9:59 上午
+     */
+    public ProjectLiftRelevance getOne(Long mtCompanyId, Long liftId) {
+        QueryWrapper<ProjectLiftRelevance> queryWrapper = new QueryWrapper<>();
+        LambdaQueryWrapper<ProjectLiftRelevance> lambdaQueryWrapper = queryWrapper.lambda();
+        lambdaQueryWrapper.eq(ProjectLiftRelevance::getMtCompanyId, mtCompanyId);
+        lambdaQueryWrapper.eq(ProjectLiftRelevance::getLiftId, liftId);
+        ProjectLiftRelevance entry=  getOne(lambdaQueryWrapper);
+        return ObjectUtil.isNotEmpty(entry) ? entry : null;
+    }
+
+    /**
+     * @param relevanceId 项目电梯关联id
+     * @param interval 保养间隔
+     * @description 根据项目电梯关联id和保养间隔修改项目电梯关联保养间隔
+     * @date 2020/1/8 9:59 上午
+     */
+    public void modifyPlanInterval(Long relevanceId, int interval) {
+        //更新项目电梯关联表保养间隔
+        ProjectLiftRelevance entry = new ProjectLiftRelevance();
+        entry.setId(relevanceId);
+        entry.setPlanInterval(interval);
+        updateById(entry);
+    }
+
     /**
      * @param request projectId 项目id
      * @return RestResponse 状态码和返回消息

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

@@ -1,14 +1,16 @@
 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.*;
+import cn.com.ty.lift.business.project.dao.entity.model.ProjectImportModel;
+import cn.com.ty.lift.business.maintenance.dao.entity.MaintenancePlan;
+import cn.com.ty.lift.business.maintenance.dao.entity.model.request.MaintenanceGenerateRequest;
 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.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,6 +38,7 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
@@ -132,6 +135,18 @@ public class ProjectService extends ServiceImpl<ProjectMapper,Project> {
         return listMaps(queryWrapper);
     }
 
+    /**
+     * @param request 项目id列表
+     * @return 项目列表
+     * @description 获取项目列表
+     * @date 2020/1/8 9:06 下午
+     */
+    public Collection<Project> getProjectList(MaintenanceGenerateRequest request) {
+        List<MaintenancePlan> plans = request.getPlanList();
+        List<Long> projectIdList = plans.stream().map(MaintenancePlan::getProjectId).collect(Collectors.toList());
+        return listByIds(projectIdList);
+    }
+
     /**
      * @param id 项目id
      * @return Project 项目详情
@@ -235,55 +250,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 +311,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 +339,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();