备件折扣价格

README.md

@@ -20,4 +20,10 @@
 3./repairPersonnel/checkRegister  维修登记
     request 添加必填参数
         defineDamage    定损结论 0 非人为损坏，1人为损坏
+4./part/addOrUpdate  添加备件类型
+    request 添加必填参数
+        partPriceDiscount      备件折扣价格
+5./salePersonnel/addOrUpdatePriceList 维修报价
+    request 添加必填参数
+        discount        0没折扣，1有折扣
 ~~~~

src/main/java/com/fdkankan/sale/common/RepairStatusEnum.java

@@ -0,0 +1,36 @@
+package com.fdkankan.sale.common;
+
+public enum  RepairStatusEnum {
+
+    TO_BE_RECEIVED(0, "待接单"),
+    TO_BE_CHECK(10, "待检测"),
+    TO_BE_QUOTED(20, "待报价"),
+    TO_BE_CONFIRMED(30, "待确认"),
+    TO_BE_CANCELED(40, "已取消"),
+    TO_BE_PREPARED(50, "待备料"),
+    TO_BE_REPAIRED(60, "维修中"),
+    TO_BE_TESTED(70, "待测试"),
+    TO_BE_PAID(80, "待支付"),
+    TO_BE_RECOVERED(90, "待回收"),
+    TO_BE_CANCELED_RECOVERED(91, "取消维修待回收"),
+    TO_BE_SHIPPED(100, "待发货"),
+    OVER_SHIPPED(110, "已发货"),
+    ;
+
+    private Integer status;
+    private String message;
+
+    private RepairStatusEnum(Integer status, String message) {
+        this.status = status;
+        this.message = message;
+    }
+
+    public Integer status() {
+        return this.status;
+    }
+
+    public String message() {
+        return this.message;
+    }
+
+}

src/main/java/com/fdkankan/sale/controller/RepairPersonnelController.java

@@ -36,8 +36,8 @@ public class RepairPersonnelController extends BaseController{
     /**
      * 维修工程师
      * statusParam 0 待接单，1待跟进，2已完结
-     * status 0待接单，1待检测，2待报价，3待确认，4已取消，5待备料，6维修中，7待回收，8待测试，
-     *        9待支付（已完结），10待收货，11已发货，12已评价
+     *      * status 0待接单，10待检测，20待报价，30待确认，40已取消，50待备料，60维修中，70待测试，
+     *      *        80待支付（已完结），90待回收，100待发货，110已发货
      */
     @PostMapping("/repairOrderList")
     public ResultData repairerOrderList(@RequestBody RepairParam param){

src/main/java/com/fdkankan/sale/controller/RepairSaleController.java

@@ -40,8 +40,8 @@ public class RepairSaleController extends BaseController{
     /**
      * 售后工程师
      * statusParam 0 待接单，1待跟进，2已完结
-     * status 0待接单，1待检测，2待报价，3待确认，4已取消，5待备料，6维修中，7待回收，8待测试，
-     *        9待支付（已完结），10待收货，11已发货，12已评价
+     *      * status 0待接单，10待检测，20待报价，30待确认，40已取消，50待备料，60维修中，70待测试，
+     *      *        80待支付（已完结），90待回收，100待发货，110已发货
      */
     @PostMapping("/saleOrderList")
     public ResultData saleOrderList(@RequestBody RepairParam param){

src/main/java/com/fdkankan/sale/controller/RepairSupplyController.java

@@ -31,8 +31,8 @@ public class RepairSupplyController extends BaseController{
     /**
      * 维修备件管理 供应链
      * statusParam 0 待备料，1已备料，2待回收
-     * status 0待接单，1待检测，2待报价，3待确认，4已取消，5待备料，6维修中，7待回收，8待测试，
-     *        9待支付（已完结），10待收货，11已发货，12已评价
+     *      * status 0待接单，10待检测，20待报价，30待确认，40已取消，50待备料，60维修中，70待测试，
+     *      *        80待支付（已完结），90待回收，100待发货，110已发货
      */
     @PostMapping("/supplyOrderList")
     public ResultData supplyOrderList(@RequestBody RepairParam param){

src/main/java/com/fdkankan/sale/entity/Part.java

@@ -57,6 +57,12 @@ public class Part implements Serializable {
     @TableField("part_price")
     @JsonFormat(shape = JsonFormat.Shape.STRING)
     private BigDecimal partPrice;
+    /**
+     * 备件价格 ,折扣
+     */
+    @TableField("part_price_discount")
+    @JsonFormat(shape = JsonFormat.Shape.STRING)
+    private BigDecimal partPriceDiscount;
 
     /**
      * 备件库存

src/main/java/com/fdkankan/sale/entity/PriceList.java

@@ -95,5 +95,9 @@ public class PriceList implements Serializable {
     @TableField("recovery_status")
     private Integer recoveryStatus;
 
-
+    /**
+     * 回收状态，0没折扣，1有折扣
+     */
+    @TableField("discount")
+    private Integer discount;
 }

src/main/java/com/fdkankan/sale/entity/RepairLog.java

@@ -69,6 +69,4 @@ public class RepairLog implements Serializable {
     @TableField("test_id")
     private Integer testId;
 
-    @TableField(exist = false)
-    private Integer haveButton = 0;
 }

src/main/java/com/fdkankan/sale/service/IPartService.java

@@ -28,7 +28,7 @@ public interface IPartService extends IService<Part> {
 
     void outStock(Integer partId,Integer count,Long userId,String repairId);
 
-    void recovery(Integer partId, Integer partCount, Long userId, String repairId);
+    void recovery(Integer partId, Integer partCount, Long userId, String repairId,Integer status);
 
     HashMap<Integer, Part> getHashMap();
 }

src/main/java/com/fdkankan/sale/service/IRepairService.java

@@ -27,8 +27,6 @@ public interface IRepairService extends IService<Repair> {
 
     Page<RepairerVo> repairerOrderList(RepairParam param);
 
-    RepairerVo getByRepairId(String repairId);
-
     Page<RepairerVo> testOrderList(RepairParam param);
 
     Page<RepairerVo> saleOrderList(RepairParam param);

src/main/java/com/fdkankan/sale/service/impl/PartServiceImpl.java

@@ -4,6 +4,7 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.fdkankan.sale.common.PageInfo;
+import com.fdkankan.sale.common.RepairStatusEnum;
 import com.fdkankan.sale.common.ResultCode;
 import com.fdkankan.sale.entity.Part;
 import com.fdkankan.sale.entity.PartLog;
@@ -102,7 +103,13 @@ public class PartServiceImpl extends ServiceImpl<IPartMapper, Part> implements I
     }
 
     @Override
-    public void recovery(Integer partId, Integer partCount, Long userId, String repairId) {
+    public void recovery(Integer partId, Integer partCount, Long userId, String repairId,Integer status) {
+        if(status.equals(RepairStatusEnum.TO_BE_CANCELED_RECOVERED.status())){
+            LambdaUpdateWrapper<Part> wrapper = new LambdaUpdateWrapper<>();
+            wrapper.eq(Part::getPartId,partId);
+            wrapper.setSql("part_stock = part_stock +" +partCount);
+            this.update(wrapper);
+        }
         partLogService.saveLog(partId,partCount,userId,2,repairId);
 
     }

src/main/java/com/fdkankan/sale/service/impl/RepairCustomerService.java

@@ -1,6 +1,7 @@
 package com.fdkankan.sale.service.impl;
 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.fdkankan.sale.common.RepairStatusEnum;
 import com.fdkankan.sale.common.ResultCode;
 import com.fdkankan.sale.entity.*;
 import com.fdkankan.sale.exception.BusinessException;
@@ -11,6 +12,7 @@ import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
+import java.math.BigDecimal;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -49,8 +51,8 @@ public class RepairCustomerService {
     }
 
     /**
-     *      * status 0待接单，1待检测，2待报价，3待确认，4已取消，5待备料，6待回收，7维修中，8待测试，
-     *      *        9待支付（已完结），10待收货，11已发货，12已评价
+     *      * status 0待接单，10待检测，20待报价，30待确认，40已取消，50待备料，60维修中，70待测试，
+     *      *        80待支付（已完结），90待回收，100待发货，110已发货
      */
     public void confirmRepair(RepairParam param) {
         if(StringUtils.isBlank(param.getRepairId()) ){
@@ -60,22 +62,22 @@ public class RepairCustomerService {
         if(repair == null){
             throw new BusinessException(ResultCode.ORDER_PAY_NOT_EXITS);
         }
-        if(repair.getStatus() != 3){
+        if(!repair.getStatus().equals(RepairStatusEnum.TO_BE_CONFIRMED.status())){
             throw new BusinessException(ResultCode.REPAIR_STATUS_NOT_EXITS);
         }
 
         if(param.getConfirm() == 0){
             priceListService.updateStatusByRepairId(repair.getRepairId());
-            repairLogService.saveBySysUser(param.getUserId(),repair.getRepairId(),5,"确认维修");
+            repairLogService.saveBySysUser(param.getUserId(),repair.getRepairId(),RepairStatusEnum.TO_BE_PREPARED.status(),"确认维修");
         }
         if(param.getConfirm() == 1) {
-               repairLogService.saveBySysUser(param.getUserId(),repair.getRepairId(),4,"拒绝报价");
-//            //存在确认过的报价单，返回维修中
-//            List<PriceList> priceLists = priceListService.getByRepairIdAndStatus(repair.getRepairId(),1);
-//            if(priceLists !=null && priceLists.size() >0){
-//                repairService.updateRepairStatus(repair.getRepairId(),6);
-//            }
-
+            //有检测费用，已取消，无检测费用，直接到代发货
+            BigDecimal robAmount = priceListService.getRobAmountByRepairId(repair.getRepairId());
+            if(robAmount !=null && robAmount.compareTo(BigDecimal.ZERO) >0){
+                repairLogService.saveBySysUser(param.getUserId(),repair.getRepairId(),RepairStatusEnum.TO_BE_CANCELED.status(),"拒绝报价");
+            }else {
+                repairLogService.saveBySysUser(param.getUserId(),repair.getRepairId(),RepairStatusEnum.TO_BE_SHIPPED.status(),"拒绝报价");
+            }
         }
     }
 

src/main/java/com/fdkankan/sale/service/impl/RepairInfoService.java

@@ -1,6 +1,7 @@
 package com.fdkankan.sale.service.impl;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.fdkankan.sale.common.PageInfo;
+import com.fdkankan.sale.common.RepairStatusEnum;
 import com.fdkankan.sale.entity.*;
 import com.fdkankan.sale.service.*;
 import com.fdkankan.sale.vo.request.RepairInfoListParam;
@@ -70,10 +71,10 @@ public class RepairInfoService {
         }
 
         BigDecimal payAmount = BigDecimal.ZERO;
-        if(repair.getStatus() == 4){
+        if(repair.getStatus().equals(RepairStatusEnum.TO_BE_CANCELED.status())){
             payAmount = priceListService.getRobAmountByRepairId(repair.getRepairId());
         }
-        if(repair.getStatus() == 9){
+        if(repair.getStatus().equals(RepairStatusEnum.TO_BE_PAID.status())){
             payAmount = priceListService.getAmountByRepairId(repair.getRepairId());
         }
         detailVo.setPayAmount(payAmount);
@@ -93,39 +94,32 @@ public class RepairInfoService {
         return detailVo;
     }
 
-    //工单状态status 0待接单，1待检测，2待报价，3待确认，4已取消，5待备料，6待回收，7维修中，8待测试，9待支付（已完结），10待收货，11已发货，12已评价
+    /**
+     *      *      * status 0待接单，10待检测，20待报价，30待确认，40已取消，50待备料，60维修中，70待测试，
+     *      *      *        80待支付（已完结），90待回收，100待发货，110已发货
+     */
     public Object getProcessByRepairId(String repairId,Long sysUserId) {
         List<RepairLogVo> repairLogList = repairLogService.getVoByRepairId(repairId);
         for (RepairLogVo repairLogVo : repairLogList) {
-            Integer haveButton = 0;
-            if(repairLogVo.getSysUserId()!=null){
-                if(repairLogVo.getSysUserId().equals(sysUserId)){
-                    haveButton = 1;
-                }
-            }
-            if(sysUserId == null){
-                haveButton = 1;
-            }
-            repairLogVo.setHaveButton(haveButton);
             switch (repairLogVo.getRepairStatus()){
                 case 0 : //报修
                     Customer customer = customerService.getByRepairId(repairLogVo.getRepairId());
                     repairLogVo.setCustomer(customer);
                     break;
-                case 1 : //接单
+                case 10 : //接单
                     OrderReceiving orderReceiving = orderReceivingService.getByRepairId(repairId);
                     repairLogVo.setOrderReceiving(orderReceiving);
                     if(orderReceiving != null){
                         repairLogVo.setImagesInfo(orderReceiving.getOrderFaultImg());
                     }
                     break;
-                case 2 : //维修检测
+                case 20 : //维修检测
                     RepairRegisterVo repairRegisterVo = repairRegisterService.getVoByRepairId(repairId);
                     repairLogVo.setRepairRegisterVo(repairRegisterVo);
                     if(repairRegisterVo != null){
                         repairLogVo.setImagesInfo(repairRegisterVo.getCheckImg());
                     }
-                case 6 : case 9:  //测试通过与测试不通过
+                case 60 : case 70: case 80: //测试通过与测试不通过
                     if(repairLogVo.getTestId() != null){
                         RepairTest repairTest = repairTestService.getById(repairLogVo.getTestId());
                         if(repairTest != null){
@@ -135,7 +129,7 @@ public class RepairInfoService {
                     }
 
                     break;
-                case 11 : case 12: case 13: //维修完毕
+                case 110 :  //维修完毕
                     CustomerAddress customerAddress = customerAddressService.getByRepairId(repairId);
                     repairLogVo.setCustomerAddress(customerAddress);
                     break;

src/main/java/com/fdkankan/sale/service/impl/RepairLogServiceImpl.java

@@ -31,8 +31,8 @@ public class RepairLogServiceImpl extends ServiceImpl<IRepairLogMapper, RepairLo
     IRepairService repairService;
 
     /**
-     *      * status 0待接单，1待检测，2待报价，3待确认，4已取消，5待备料，6待回收，7维修中，8待测试，
-     *      *        9待支付（已完结），10待发货，11已发货，12已评价
+     *      * status 0待接单，10待检测，20待报价，30待确认，40已取消，50待备料，60维修中，70待测试，
+     *      *        80待支付（已完结），90待回收，100待发货，110已发货
      */
     @Override
     public RepairLog saveBySysUser(Long sysUserId, String repairId,Integer repairStatus,String remark) {

src/main/java/com/fdkankan/sale/service/impl/RepairPersonnelService.java

@@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.fdkankan.sale.common.PageInfo;
+import com.fdkankan.sale.common.RepairStatusEnum;
 import com.fdkankan.sale.common.ResultCode;
 import com.fdkankan.sale.entity.*;
 import com.fdkankan.sale.exception.BusinessException;
@@ -61,8 +62,8 @@ public class RepairPersonnelService {
     /**
      * 维修工程师
      * statusParam 0 待检测，1待跟进，2维修完成
-     * status 0待接单，1待检测，2待报价，3待确认，4已取消，5待备料，6维修中，7待回收，8待测试，
-     *        9待支付（已完结），10待收货，11已发货，12已评价
+     *      * status 0待接单，10待检测，20待报价，30待确认，40已取消，50待备料，60维修中，70待测试，
+     *      *        80待支付（已完结），90待回收，100待发货，110已发货
      */
     public Object repairerOrderList(RepairParam param) {
         List<Integer> repairStatus = StatusUtil.getRepairerStatus(param.getStatusParam());
@@ -92,7 +93,7 @@ public class RepairPersonnelService {
         if(repair == null){
             throw new BusinessException(ResultCode.REPAIR_NOT_EXITS);
         }
-        if(repair.getStatus() !=1 ){ //待检测
+        if(!repair.getStatus().equals(RepairStatusEnum.TO_BE_CHECK.status())){ //待检测
             throw new BusinessException(ResultCode.REPAIR_STATUS_NOT_EXITS);
         }
         RepairRegister repairRegister  = repairRegisterService.getByRepairId(repair.getRepairId());
@@ -114,7 +115,7 @@ public class RepairPersonnelService {
         HashMap<Integer,Integer> partIdMap = new HashMap<>();
         registerParts.forEach(entity -> partIdMap.putIfAbsent(entity.getPartId(),entity.getId()));
 
-        repairLogService.saveBySysUser(userId,repair.getRepairId(),2,"维修登记");
+        repairLogService.saveBySysUser(userId,repair.getRepairId(),RepairStatusEnum.TO_BE_QUOTED.status(),"维修登记");
 
         this.addRepairPart(param.getPartList(),repair,repairRegister,partIdMap);
 
@@ -163,7 +164,7 @@ public class RepairPersonnelService {
         if(repair == null){
             throw new BusinessException(ResultCode.REPAIR_NOT_EXITS);
         }
-        if(repair.getStatus() !=6 ){ //维修中
+        if(!repair.getStatus().equals(RepairStatusEnum.TO_BE_REPAIRED.status())){ //维修中
             throw new BusinessException(ResultCode.REPAIR_STATUS_NOT_EXITS);
         }
         RepairRegister repairRegister  = repairRegisterService.getByRepairId(repair.getRepairId());
@@ -178,7 +179,7 @@ public class RepairPersonnelService {
 
         this.addRepairPart(param.getPartList(),repair,repairRegister,null);
 
-        repairLogService.saveBySysUser(userId,repair.getRepairId(),2,"维修中添加备件");
+        repairLogService.saveBySysUser(userId,repair.getRepairId(),RepairStatusEnum.TO_BE_QUOTED.status(),"维修中添加备件");
 
     }
 
@@ -190,15 +191,15 @@ public class RepairPersonnelService {
         if(repair == null){
             throw new BusinessException(ResultCode.REPAIR_NOT_EXITS);
         }
-        if(repair.getStatus() !=6){
+        if(!repair.getStatus().equals(RepairStatusEnum.TO_BE_REPAIRED.status())){
             throw new BusinessException(ResultCode.REPAIR_STATUS_NOT_EXITS);
         }
         List<PriceList> priceListList = priceListService.getByRepairId(repair.getRepairId());
         List<PriceList> collect = priceListList.stream().filter(entity ->entity.getType()== 0 && entity.getRecoveryStatus() == 0).collect(Collectors.toList());
         if(collect.size() >0){
-            repairLogService.saveBySysUser(userId,repair.getRepairId(),7,"维修完成");
+            repairLogService.saveBySysUser(userId,repair.getRepairId(),RepairStatusEnum.TO_BE_TESTED.status(),"维修完成");
         }else {
-            repairLogService.saveBySysUser(userId,repair.getRepairId(),8,"维修完成");
+            repairLogService.saveBySysUser(userId,repair.getRepairId(), RepairStatusEnum.TO_BE_PAID.status(), "维修完成");
         }
         repairRegisterService.repairOver(repair.getRepairId(),param.getRemark());
 

src/main/java/com/fdkankan/sale/service/impl/RepairSaleService.java

@@ -7,6 +7,7 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.fdkankan.sale.common.PageInfo;
+import com.fdkankan.sale.common.RepairStatusEnum;
 import com.fdkankan.sale.common.ResultCode;
 import com.fdkankan.sale.common.ResultData;
 import com.fdkankan.sale.entity.*;
@@ -57,8 +58,8 @@ public class RepairSaleService {
     /**
      * 售后工程师
      * statusParam 0 待接单，1待跟进，2已完结
-     * status 0待接单，1待检测，2待报价，3待确认，4已取消，5待备料，6待回收，7维修中，8待测试，
-     *        9待支付（已完结），10待发货，11已发货，12已评价
+     *      * status 0待接单，10待检测，20待报价，30待确认，40已取消，50待备料，60维修中，70待测试，
+     *      *        80待支付（已完结），90待回收，100待发货，110已发货
      */
     public PageInfo saleOrderList(RepairParam param) {
         List<Integer> repairStatus = StatusUtil.getSaleStatus(param.getStatusParam());
@@ -67,7 +68,7 @@ public class RepairSaleService {
         sysUserService.setSaleNameAndRepairManName(voPage.getRecords());
         BigDecimal payAmount;
         for (RepairerVo record : voPage.getRecords()) {
-            if(record.getStatus() == 4){
+            if(record.getStatus().equals(RepairStatusEnum.TO_BE_CANCELED.status())){
                 payAmount = priceListService.getRobAmountByRepairId(param.getRepairId());
             }else {
                 payAmount = priceListService.getAmountByRepairId(record.getRepairId());
@@ -86,7 +87,7 @@ public class RepairSaleService {
         if(repair == null){
             throw new BusinessException(ResultCode.REPAIR_NOT_EXITS);
         }
-        if(repair.getStatus() !=0 ){
+        if(!repair.getStatus().equals(RepairStatusEnum.TO_BE_RECEIVED.status())){
             throw new BusinessException(ResultCode.REPAIR_STATUS_NOT_EXITS);
         }
         param.setSysUserId(sysUserId);
@@ -95,7 +96,7 @@ public class RepairSaleService {
         param.setOrderFaultImg(param.getImageUrl());
         orderReceivingService.save(param);
 
-        repairLogService.saveBySysUser(sysUserId,param.getRepairId(),1,"接单");
+        repairLogService.saveBySysUser(sysUserId,param.getRepairId(), RepairStatusEnum.TO_BE_CHECK.status(),"接单");
 
     }
 
@@ -150,7 +151,7 @@ public class RepairSaleService {
         customerAddressService.save(customerAddress);
 
         repairService.save(repair);
-        repairLogService.saveBySysUser(userId,repair.getRepairId(),0,"录单");
+        repairLogService.saveBySysUser(userId,repair.getRepairId(),RepairStatusEnum.TO_BE_RECEIVED.status(),"录单");
 
 
 
@@ -165,7 +166,8 @@ public class RepairSaleService {
         if(repair == null){
             throw new BusinessException(ResultCode.REPAIR_NOT_EXITS);
         }
-        if(repair.getStatus() !=2 && repair.getStatus() !=3){
+        if(!repair.getStatus().equals(RepairStatusEnum.TO_BE_QUOTED.status())
+                && !repair.getStatus().equals(RepairStatusEnum.TO_BE_CONFIRMED.status())){
             throw new BusinessException(ResultCode.REPAIR_STATUS_NOT_EXITS);
         }
 
@@ -178,11 +180,11 @@ public class RepairSaleService {
             }
             if(priceList.getType() == 0){
                 if(priceList.getPartId() == null ||  partMap.get(priceList.getPartId()) == null
-                        || priceList.getPriceListId() == null){
+                        || priceList.getPriceListId() == null || priceList.getDiscount() == null){
                     throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
                 }
                 Part part = partMap.get(priceList.getPartId());
-                priceList.setPrice(part.getPartPrice());
+                priceList.setPrice(priceList.getDiscount() == 0?part.getPartPrice() : part.getPartPriceDiscount());
                 priceList.setName(part.getPartName());
 
             }
@@ -206,7 +208,7 @@ public class RepairSaleService {
             }
 
         }
-        repairLogService.saveBySysUser(userId,param.getRepairId(),3,"维修报价");
+        repairLogService.saveBySysUser(userId,param.getRepairId(),RepairStatusEnum.TO_BE_CONFIRMED.status(),"维修报价");
     }
 
     public PriceListVo getPriceList(String repairId) {
@@ -214,7 +216,7 @@ public class RepairSaleService {
             throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
         }
         List<PriceList> priceLists = priceListService.getByRepairId(repairId);
-        List<RepairLog> repairLogs = repairLogService.getByRepairIdAndStatus(repairId, 3);
+        List<RepairLog> repairLogs = repairLogService.getByRepairIdAndStatus(repairId, RepairStatusEnum.TO_BE_CONFIRMED.status());
         PriceListVo priceListVo = new PriceListVo();
         priceListVo.setPriceLists(priceLists);
         priceListVo.setCount(repairLogs.size() +1);
@@ -230,11 +232,11 @@ public class RepairSaleService {
         if(repair == null){
             throw new BusinessException(ResultCode.REPAIR_NOT_EXITS);
         }
-        if(repair.getStatus() != 4 && repair.getStatus() !=9){
+        if(!repair.getStatus().equals(RepairStatusEnum.TO_BE_CANCELED.status()) && !repair.getStatus().equals(RepairStatusEnum.TO_BE_PAID.status())){
             throw new BusinessException(ResultCode.REPAIR_STATUS_NOT_EXITS);
         }
         BigDecimal payAmount;
-        if(repair.getStatus() == 4){
+        if(repair.getStatus().equals(RepairStatusEnum.TO_BE_CANCELED.status())){
             payAmount = priceListService.getRobAmountByRepairId(repair.getRepairId());
         }else {
             payAmount = priceListService.getAmountByRepairId(repair.getRepairId());
@@ -250,7 +252,7 @@ public class RepairSaleService {
         repairPay.setOrderType(0);
         repairPay.setOrderSn("se_s"+DateUtil.getDate(DateUtil.repairIdFmt));
         repairPayService.save(repairPay);
-        repairLogService.saveBySysUser(userId,param.getRepairId(),10,"付款登记");
+        repairLogService.saveBySysUser(userId,param.getRepairId(),RepairStatusEnum.TO_BE_RECOVERED.status(), "付款登记");
 
     }
 
@@ -262,11 +264,11 @@ public class RepairSaleService {
         if(repair == null){
             throw new BusinessException(ResultCode.REPAIR_NOT_EXITS);
         }
-        if(repair.getStatus() !=10){
+        if(!repair.getStatus().equals(RepairStatusEnum.TO_BE_SHIPPED.status())){
             throw new BusinessException(ResultCode.REPAIR_STATUS_NOT_EXITS);
         }
         customerAddressService.setTrackingNumByRepairId(repair.getRepairId(),param.getGetType(),param.getTrackingNum());
-        repairLogService.saveBySysUser(userId,param.getRepairId(),11,"发货登记");
+        repairLogService.saveBySysUser(userId,param.getRepairId(),RepairStatusEnum.OVER_SHIPPED.status(),"发货登记");
 
     }
 }

src/main/java/com/fdkankan/sale/service/impl/RepairServiceImpl.java

@@ -5,6 +5,7 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.fdkankan.sale.common.PageInfo;
+import com.fdkankan.sale.common.RepairStatusEnum;
 import com.fdkankan.sale.common.ResultCode;
 import com.fdkankan.sale.entity.*;
 import com.fdkankan.sale.exception.BusinessException;
@@ -70,40 +71,6 @@ public class RepairServiceImpl extends ServiceImpl<IRepairMapper, Repair> implem
         return this.getBaseMapper().testOrderList(new Page<>(param.getPageNum(),param.getPageSize()),param);
     }
 
-    @Override
-    public RepairerVo getByRepairId(String repairId) {
-        Repair repair = this.getById(repairId);
-        if(repair == null){
-            return null;
-        }
-        RepairerVo repairerVo = new RepairerVo();
-        BeanUtils.copyProperties(repair,repairerVo);
-        List<RepairLog> repairLogs = repairLogService.getByRepairId(repair.getRepairId());
-
-        Set<Long> sysUserIds = repairLogs.stream().map(RepairLog::getSysUserId).collect(Collectors.toSet());
-        HashMap<Long,SysUser> userMap = sysUserService.getMapByIds(sysUserIds);
-
-        for (RepairLog repairLog : repairLogs) {
-            SysUser sysUser = userMap.get(repairLog.getSysUserId());
-            if(sysUser == null){
-                continue;
-            }
-            switch (repairLog.getRepairStatus()){
-                case 1 :  //接单
-                    repairerVo.setSaleName(sysUser.getNickName());
-                    repairerVo.setOrderReceivingTime(repairLog.getCreateTime());
-                    break;
-                case 2 :  //维修检测
-                    repairerVo.setRepairManName(sysUser.getNickName());
-                    break;
-                case 8 :  //维修完成
-                    repairerVo.setRepairManName(sysUser.getNickName());
-                    repairerVo.setRepairOverTime(repairLog.getCreateTime());
-                    break;
-            }
-        }
-        return repairerVo;
-    }
 
     @Override
     public void paySuccess(String orderSn, String tradeNo, String openid) {
@@ -112,7 +79,12 @@ public class RepairServiceImpl extends ServiceImpl<IRepairMapper, Repair> implem
             return;
         }
         repairPayService.updatePayStatus(orderSn,tradeNo,openid);
-        repairLogService.saveBySysUser(null,repairPay.getRepairId(),10,"支付成功");
+        if(orderSn.contains("se_s")){
+            repairLogService.saveBySysUser(null,repairPay.getRepairId(), RepairStatusEnum.TO_BE_RECOVERED.status(),"完成维修支付成功");
+        }
+        if(orderSn.contains("se_c")){
+            repairLogService.saveBySysUser(null,repairPay.getRepairId(), RepairStatusEnum.TO_BE_CANCELED_RECOVERED.status(),"取消维修支付成功");
+        }
     }
 
     @Override

src/main/java/com/fdkankan/sale/service/impl/RepairSupplyService.java

@@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.fdkankan.sale.common.PageInfo;
+import com.fdkankan.sale.common.RepairStatusEnum;
 import com.fdkankan.sale.common.ResultCode;
 import com.fdkankan.sale.entity.*;
 import com.fdkankan.sale.exception.BusinessException;
@@ -55,8 +56,8 @@ public class RepairSupplyService {
     /**
      * 维修备件管理 供应链
      * statusParam 0 待备料，1已备料，2待回收
-     * status 0待接单，1待检测，2待报价，3待确认，4已取消，5待备料，6维修中，7待回收，8待测试，
-     *        9待支付（已完结），10待收货，11已发货，12已评价
+     *      * status 0待接单，10待检测，20待报价，30待确认，40已取消，50待备料，60维修中，70待测试，
+     *      *        80待支付（已完结），90待回收，100待发货，110已发货
      */
     public Object supplyOrderList(RepairParam param) {
         List<Integer> repairStatus = StatusUtil.getSupplyStatus(param.getStatusParam());
@@ -108,7 +109,7 @@ public class RepairSupplyService {
         if(repair == null){
             throw new BusinessException(ResultCode.REPAIR_NOT_EXITS);
         }
-        if(repair.getStatus() !=5){
+        if(!repair.getStatus().equals(RepairStatusEnum.TO_BE_PREPARED.status())){
             throw new BusinessException(ResultCode.REPAIR_STATUS_NOT_EXITS);
         }
         List<RepairRegisterPartVo> partVoList = this.partInfo(param.getRepairId(),0);
@@ -120,7 +121,7 @@ public class RepairSupplyService {
         }
         priceListService.outStock(repair.getRepairId());
 
-        repairLogService.saveBySysUser(userId,param.getRepairId(),6,"备件出库");
+        repairLogService.saveBySysUser(userId,param.getRepairId(),RepairStatusEnum.TO_BE_REPAIRED.status(),"备件出库");
     }
 
     public void partRecovery(Repair param, Long userId) {
@@ -132,15 +133,16 @@ public class RepairSupplyService {
         if(repair == null){
             throw new BusinessException(ResultCode.REPAIR_NOT_EXITS);
         }
-        if(repair.getStatus() !=10){
+        if(!repair.getStatus().equals(RepairStatusEnum.TO_BE_RECOVERED.status())
+                && !repair.getStatus().equals(RepairStatusEnum.TO_BE_CANCELED_RECOVERED.status())){
             throw new BusinessException(ResultCode.REPAIR_STATUS_NOT_EXITS);
         }
         List<RepairRegisterPartVo> partVoList = this.partInfo(param.getRepairId(),1);
         for (RepairRegisterPartVo partVo : partVoList) {
-            partService.recovery(partVo.getPartId(),partVo.getPartCount(),userId,repair.getRepairId());
+            partService.recovery(partVo.getPartId(),partVo.getPartCount(),userId,repair.getRepairId(),repair.getStatus());
         }
         priceListService.recoveryPart(repair.getRepairId());
 
-        repairLogService.saveBySysUser(userId,param.getRepairId(),7,"备件回收");
+        repairLogService.saveBySysUser(userId,param.getRepairId(),RepairStatusEnum.TO_BE_SHIPPED.status(),"备件回收");
     }
 }

src/main/java/com/fdkankan/sale/service/impl/RepairTesterService.java

@@ -3,7 +3,9 @@ import java.util.Date;
 
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.fdkankan.sale.common.PageInfo;
+import com.fdkankan.sale.common.RepairStatusEnum;
 import com.fdkankan.sale.common.ResultCode;
+import com.fdkankan.sale.entity.Repair;
 import com.fdkankan.sale.entity.RepairTest;
 import com.fdkankan.sale.entity.SysUser;
 import com.fdkankan.sale.exception.BusinessException;
@@ -38,8 +40,8 @@ public class RepairTesterService {
     /**
      * 测试工程师
      * statusParam 0 待测试，1测试完成
-     * status 0待接单，1待检测，2待报价，3待确认，4已取消，5待备料，6维修中，7待回收，8待测试，
-     *        9待支付（已完结），10待收货，11已发货，12已评价
+     *      * status 0待接单，10待检测，20待报价，30待确认，40已取消，50待备料，60维修中，70待测试，
+     *      *        80待支付（已完结），90待回收，100待发货，110已发货
      */
     public Object repairTesterList(RepairParam param) {
         List<Integer> repairStatus = StatusUtil.getTesterStatus(param.getStatusParam());
@@ -55,6 +57,13 @@ public class RepairTesterService {
         if(StringUtils.isBlank(testParam.getRepairId()) || testParam.getResultStatus() == null){
             throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
         }
+        Repair repair = repairService.getById(testParam.getRepairId());
+        if(repair == null){
+            throw new BusinessException(ResultCode.REPAIR_NOT_EXITS);
+        }
+        if(!repair.getStatus().equals(RepairStatusEnum.TO_BE_REPAIRED.status())){
+            throw new BusinessException(ResultCode.REPAIR_STATUS_NOT_EXITS);
+        }
         RepairTest entity = new RepairTest();
         entity.setRepairId(testParam.getRepairId());
         entity.setSysUserId(userId);
@@ -65,10 +74,10 @@ public class RepairTesterService {
         if(testParam.getResultStatus() == 0){
             entity.setPassTime(DateUtil.getDate());
             repairTestService.save(entity);
-            repairLogService.saveBySysUser(userId,testParam.getRepairId(),9,"测试通过",entity.getTestId());
+            repairLogService.saveBySysUser(userId,testParam.getRepairId(), RepairStatusEnum.TO_BE_PAID.status(),"测试通过",entity.getTestId());
         }else {
             repairTestService.save(entity);
-            repairLogService.saveBySysUser(userId,testParam.getRepairId(),6,"测试不通过",entity.getTestId());
+            repairLogService.saveBySysUser(userId,testParam.getRepairId(),RepairStatusEnum.TO_BE_REPAIRED.status(),"测试不通过",entity.getTestId());
         }
 
     }

src/main/java/com/fdkankan/sale/util/StatusUtil.java

@@ -11,12 +11,13 @@ import java.util.List;
 
 public class StatusUtil {
 
-    public static List<Integer> overStatusList = Arrays.asList(11,12,13);
+    //已完结状态
+    public static List<Integer> overStatusList = Arrays.asList(110);
     /**
      * 售后工程师
      * statusParam 0 待接单，1待跟进，2已完结
-     * status 0待接单，1待检测，2待报价，3待确认，4已取消(待支付)，5待备料，6待回收，7维修中，8待测试，
-     *        9已完成（待支付），10待收货，11已发货，12已评价
+     *      * status 0待接单，10待检测，20待报价，30待确认，40已取消，50待备料，60维修中，70待测试，
+     *      *        80待支付（已完结），90待回收，100待发货，110已发货
      */
     public static List<Integer> getSaleStatus(Integer statusParam){
         if(statusParam == null){
@@ -24,25 +25,25 @@ public class StatusUtil {
         }
         switch (statusParam){
             case 0 : return Collections.singletonList(0);
-            case 1 : return Arrays.asList(1,2,3,4,5,7,8,9,10);
-            case 2 : return Arrays.asList(11,12,13);
+            case 1 : return Arrays.asList(10,20,30,40,50,70,80,90,91,100);
+            case 2 : return Arrays.asList(110);
             default: throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
         }
     }
     /**
      * 维修工程师
      * statusParam 0 待检测，1待跟进，2维修完成
-     * status 0待接单，1待检测，2待报价，3待确认，4已取消，5待备料，6维修中，7待回收，8待测试，
-     *        9待支付（已完结），10待收货，11已发货，12已评价
+     *      * status 0待接单，10待检测，20待报价，30待确认，40已取消，50待备料，60维修中，70待测试，
+     *      *        80待支付（已完结），90待回收，91取消维修备件回收，100待发货，110已发货
      */
     public static List<Integer> getRepairerStatus(Integer statusParam){
         if(statusParam == null){
             throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
         }
         switch (statusParam){
-            case 0 : return Collections.singletonList(1);
-            case 1 : return Arrays.asList(5,6,7);
-            case 2 : return Arrays.asList(8,9,10,11,12,13);
+            case 0 : return Collections.singletonList(10);
+            case 1 : return Arrays.asList(20,50,60);
+            case 2 : return Arrays.asList(80,90,91,100,110);
             default: throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
         }
     }
@@ -50,17 +51,17 @@ public class StatusUtil {
     /**
      * 维修备件管理 供应链
      * statusParam 0 待备料，1已备料，2待回收
-     * status 0待接单，1待检测，2待报价，3待确认，4已取消，5待备料，6维修中，7待回收，8待测试，
-     *        9待支付（已完结），10待收货，11已发货，12已评价
+     *      * status 0待接单，10待检测，20待报价，30待确认，40已取消，50待备料，60维修中，70待测试，
+     *      *        80待支付（已完结），90待回收，100待发货，110已发货
      */
     public static List<Integer> getSupplyStatus(Integer statusParam){
         if(statusParam == null){
             throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
         }
         switch (statusParam){
-            case 0 : return Collections.singletonList(5);
-            case 1 : return Arrays.asList(6,8,9,10,11,12,13);
-            case 2 : return Collections.singletonList(7);
+            case 0 : return Collections.singletonList(50);
+            case 1 : return Arrays.asList(60,70,80,90,91,100,110);
+            case 2 : return Arrays.asList(90,91);
             default: throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
         }
     }
@@ -68,16 +69,16 @@ public class StatusUtil {
     /**
      * 测试工程师
      * statusParam 0 待测试，1测试完成
-     * status 0待接单，1待检测，2待报价，3待确认，4已取消，5待备料，6维修中，7待回收，8待测试，
-     *        9待支付（已完结），10待收货，11已发货，12已评价
+     *      * status 0待接单，10待检测，20待报价，30待确认，40已取消，50待备料，60维修中，70待测试，
+     *      *        80待支付（已完结），90待回收，100待发货，110已发货
      */
     public static List<Integer> getTesterStatus(Integer statusParam) {
         if(statusParam == null){
             throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
         }
         switch (statusParam){
-            case 0 : return Collections.singletonList(8);
-            case 1 : return Arrays.asList(9,10,11,12,13);
+            case 0 : return Collections.singletonList(80);
+            case 1 : return Arrays.asList(90,91,100,110);
             default: throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
         }
     }

src/main/java/com/fdkankan/sale/wx/pay/WechatPayService.java

@@ -3,6 +3,7 @@ package com.fdkankan.sale.wx.pay;
 import com.alibaba.fastjson.JSONObject;
 import com.fdkankan.common.util.MD5;
 import com.fdkankan.sale.common.CacheUtil;
+import com.fdkankan.sale.common.RepairStatusEnum;
 import com.fdkankan.sale.common.ResultCode;
 import com.fdkankan.sale.entity.Repair;
 import com.fdkankan.sale.entity.RepairPay;
@@ -48,7 +49,8 @@ public class WechatPayService {
         if(repair == null){
             throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
         }
-        if(repair.getStatus() != 9 && repair.getStatus() != 4){
+        if(!repair.getStatus().equals(RepairStatusEnum.TO_BE_CANCELED.status())
+                && !repair.getStatus().equals(RepairStatusEnum.TO_BE_PAID.status())){
             throw new BusinessException(ResultCode.REPAIR_STATUS_NOT_EXITS);
         }
         RepairPay repairPay = repairPayService.getByRepairId(param.getRepairId(),1);
@@ -59,13 +61,13 @@ public class WechatPayService {
         BigDecimal amount = BigDecimal.ZERO;
         String subject = null;
         Integer orderType = null;
-        if(repair.getStatus() == 9){
+        if(repair.getStatus().equals(RepairStatusEnum.TO_BE_PAID.status())){
             amount = priceListService.getAmountByRepairId(param.getRepairId());
             orderSn = "se_s"+DateUtil.getDate(DateUtil.repairIdFmt);
             subject = "维修订单";
             orderType = 0;
         }
-        if(repair.getStatus() == 4){
+        if(repair.getStatus().equals(RepairStatusEnum.TO_BE_CANCELED.status())){
             amount = priceListService.getRobAmountByRepairId(param.getRepairId());
             orderSn = "se_c"+DateUtil.getDate(DateUtil.repairIdFmt);
             subject = "取消维修订单";

src/main/resources/mapper/sale/RepairMapper.xml

@@ -153,10 +153,10 @@
             and rr.sys_user_id = #{param.repairManId}
         </if>
         <if test="param.payStatus != null and param.payStatus ==0">
-            and r.status &lt; 9
+            and r.status &lt; 80
         </if>
         <if test="param.payStatus != null and param.payStatus ==1">
-          and r.status &gt;= 9
+          and r.status &gt;= 80
         </if>
         <if test="param.commentStatus != null ">
             and r.comment_status = #{param.commentStatus}