package com.iamberry.rst.service.fm;


import com.github.pagehelper.PageHelper;
import com.iamberry.rst.core.cm.CmRelation;
import com.iamberry.rst.core.cm.CompanyInfo;
import com.iamberry.rst.core.cm.ProcMethod;
import com.iamberry.rst.core.cm.SalesOrderItem;
import com.iamberry.rst.core.fm.*;
import com.iamberry.rst.core.order.OrderWarehouse;
import com.iamberry.rst.core.order.Product;
import com.iamberry.rst.core.page.PageRequest;
import com.iamberry.rst.core.page.PagedResult;
import com.iamberry.rst.core.pts.Produce;
import com.iamberry.rst.core.sys.Admin;
import com.iamberry.rst.faces.cm.InventoryService;
import com.iamberry.rst.faces.cm.SalesOrderService;
import com.iamberry.rst.faces.fm.ComplaintDetectInfoService;
import com.iamberry.rst.faces.sms.SmsService;
import com.iamberry.rst.service.cm.mapper.*;
import com.iamberry.rst.service.fm.mapper.ComplaintDetectInfoMapper;
import com.iamberry.rst.service.fm.mapper.ComplaintMaintenanceInfoMapper;
import com.iamberry.rst.service.fm.mapper.DetectCustmoerPhenomenonMapper;
import com.iamberry.rst.service.fm.mapper.DetectTransportMapper;
import com.iamberry.rst.service.product.mapper.ProductMapper;
import com.iamberry.rst.service.pts.mapper.ProduceMapper;
import com.iamberry.rst.service.sys.mapper.SysConfigMapper;
import com.iamberry.rst.service.sys.mapper.SysMapper;
import com.iamberry.rst.util.PageUtil;
import com.iamberry.rst.util.SmsConfig;
import com.iamberry.wechat.core.entity.AdminUtils;
import com.iamberry.wechat.tools.DateTimeUtil;
import com.iamberry.wechat.tools.ResponseJson;
import com.iamberry.wechat.tools.ResultInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;

import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.*;

@Service
public class ComplaintDetectInfoServiceImpl implements ComplaintDetectInfoService {

    private Logger logger = LoggerFactory.getLogger(ComplaintDetectInfoServiceImpl.class);
    @Autowired
    private ComplaintDetectInfoMapper complaintDetectInfoMapper;
    @Autowired
    private CustomerInfoMapper customerInfoMapper;
    @Autowired
    private ProcMethodMapper procMethodMapper;
    @Autowired
    private SmsService smsService;
    @Autowired
    private SalesOrderService salesOrderService;
    @Autowired
    private InventoryService inventoryService;
    @Autowired
    private SysMapper sysMapper;
    @Autowired
    private MaintainPhenomenonMapper phenomenonMapper;
    @Autowired
    private CompanyInfoMapper companyInfoMapper;
    @Autowired
    private StoreInfoMapper storeInfoMapper;
    @Autowired
    private ProductMapper productMapper;
    @Autowired
    private ProduceMapper produceMapper;
    @Autowired
    private SysConfigMapper sysConfigMapper;
    @Autowired
    private DetectCustmoerPhenomenonMapper detectCustmoerPhenomenonMapper;
    @Autowired
    private DetectTransportMapper detectTransportMapper;

    private static final int MAX_MAINTAIN_PRICE = 500_00;

    @Override
    public ComplaintDetectInfo getDetectByMachine(String machine) {
        return complaintDetectInfoMapper.getDetectByMachine(machine);
    }

    @Override
    public ComplaintDetectInfo getDetectById(Integer detectId) {
        ComplaintDetectInfo res = complaintDetectInfoMapper.getDetectById(detectId);
        if (res == null) {
            return res;
        }
        if (res.getSalesmanAdminId() != null) {
            Admin temp = new Admin();
            temp.setAdminId(res.getSalesmanAdminId());
            res.setSalesmanAdminName(sysMapper.get(temp).getAdminName());
        }
        res.setPhenomena(complaintDetectInfoMapper.listDetectPhenomenon(detectId));
        res.setTransport(detectTransportMapper.get(detectId));
        return res;
    }

    @Override
    @Transactional
    public int updateDetectById(ComplaintDetectInfo record) {
            try {
                //删除旧检测项
                complaintDetectInfoMapper.detectDetectionItem(record.getDetectId());
                //删除旧维修配件项
                complaintDetectInfoMapper.detectMaterialItem(record.getDetectId());
                //封装检测信息
                //检测现象
                if(record.getConfigli1() != null) {
                    if (record.getConfigli1().length > 0) {
                        StringBuffer detectPhenomenon = new StringBuffer("");
                        for (String configid : record.getConfigli1()) {
                            detectPhenomenon.append(adddetectItem(configid, record.getDetectId()) + ";");
                        }
                        record.setDetectPhenomenon(detectPhenomenon.toString());
                    }
                }else{
                    record.setDetectPhenomenon("");
                }
                //故障原因
                if(record.getConfigli2() != null) {
                    if (record.getConfigli2().length > 0) {
                        StringBuffer detectFailureCause = new StringBuffer("");
                        for (String configid : record.getConfigli2()) {
                            detectFailureCause.append(adddetectItem(configid, record.getDetectId()) + ";");
                        }
                        record.setDetectFailureCause(detectFailureCause.toString());
                    }
                }else{
                    record.setDetectFailureCause("");
                }
                //判定结果
                if(record.getConfigli3() != null){
                    if(record.getConfigli3().length > 0){
                        StringBuffer detectResults = new StringBuffer("");
                        for (String configid : record.getConfigli3()){
                            detectResults.append(adddetectItem(configid,record.getDetectId())+";");
                        }
                        record.setDetectResults(detectResults.toString());
                    }
                }else{
                    record.setDetectResults("");
                }
                //故障指向
                if(record.getConfigli4() != null) {
                    if (record.getConfigli4().length > 0) {
                        StringBuffer detectPoint = new StringBuffer("");
                        for (String configid : record.getConfigli4()) {
                            detectPoint.append(adddetectItem(configid, record.getDetectId()) + ";");
                        }
                        record.setDetectPoint(detectPoint.toString());
                    }
                }else{
                    record.setDetectPoint("");
                }
                //原因分析
                if(record.getConfigli5() != null) {
                    if (record.getConfigli5().length > 0) {
                        StringBuffer detectNalysis = new StringBuffer("");
                        for (String configid : record.getConfigli5()) {
                            detectNalysis.append(adddetectItem(configid, record.getDetectId()) + ";");
                        }
                        record.setDetectNalysis(detectNalysis.toString());
                    }
                }else{
                    record.setDetectNalysis("");
                }
                //维修配件
                if(record.getConfigli6() != null) {
                    if (record.getConfigli6().length > 0) {
                        for (String configid : record.getConfigli6()) {
                            MaterialNumberInfo materialNumberInfo = complaintDetectInfoMapper.getMaterialNumber(Integer.valueOf(configid));
                            MaterialItem materialItem = new MaterialItem();
                            materialItem.setDetectId(record.getDetectId());
                            materialItem.setMaterialId(Integer.valueOf(configid));
                            materialItem.setMaterialName(materialNumberInfo.getMaterialName());
                            complaintDetectInfoMapper.addMaterialItem(materialItem);
                        }
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
                throw new RuntimeException("修改检测失败");
            }
        return complaintDetectInfoMapper.updateDetectById(record);
    }
    @Override
    @Transactional
    public int updateDetectContent(ComplaintDetectInfo record) {
        complaintDetectInfoMapper.detectMaterialItem(record.getDetectId());
        try {
            //维修配件
            if(record.getConfigli6() != null) {
                if (record.getConfigli6().length > 0) {
                    for (String configid : record.getConfigli6()) {
                        MaterialNumberInfo materialNumberInfo = complaintDetectInfoMapper.getMaterialNumber(Integer.valueOf(configid));
                        MaterialItem materialItem = new MaterialItem();
                        materialItem.setDetectId(record.getDetectId());
                        materialItem.setMaterialId(Integer.valueOf(configid));
                        materialItem.setMaterialName(materialNumberInfo.getMaterialName());
                        complaintDetectInfoMapper.addMaterialItem(materialItem);
                    }
                }
            }
            //故障原因
            if(record.getConfigli2() != null) {
                if (record.getConfigli2().length > 0) {
                    StringBuffer detectFailureCause = new StringBuffer("");
                    for (String configid : record.getConfigli2()) {
                        detectFailureCause.append(adddetectItem(configid, record.getDetectId()) + ";");
                    }
                    record.setDetectFailureCause(detectFailureCause.toString());
                }
            }
            //判定结果
            if(record.getConfigli3() != null){
                if(record.getConfigli3().length > 0){
                    StringBuffer detectResults = new StringBuffer("");
                    for (String configid : record.getConfigli3()){
                        detectResults.append(adddetectItem(configid,record.getDetectId())+";");
                    }
                    record.setDetectResults(detectResults.toString());
                }
            }
            //故障指向
            if(record.getConfigli4() != null) {
                if (record.getConfigli4().length > 0) {
                    StringBuffer detectPoint = new StringBuffer("");
                    for (String configid : record.getConfigli4()) {
                        detectPoint.append(adddetectItem(configid, record.getDetectId()) + ";");
                    }
                    record.setDetectPoint(detectPoint.toString());
                }
            }
            //原因分析
            if(record.getConfigli5() != null) {
                if (record.getConfigli5().length > 0) {
                    StringBuffer detectNalysis = new StringBuffer("");
                    for (String configid : record.getConfigli5()) {
                        detectNalysis.append(adddetectItem(configid, record.getDetectId()) + ";");
                    }
                    record.setDetectNalysis(detectNalysis.toString());
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            throw new RuntimeException("修改检测维修内容失败");
        }
        return complaintDetectInfoMapper.updateDetectById(record);
    }
    @Override
    @Transactional
    public int updateDetectQc(ComplaintDetectInfo record) {
        ComplaintDetectInfo comdi = complaintDetectInfoMapper.getDetectByIdFast(record.getDetectId());
        record.setDetectNumber(comdi.getDetectNumber());
        if(comdi == null){
            throw new RuntimeException("查询维修记录失败");
        }
        if(comdi.getMaintenanceResults() != null && comdi.getMaintenanceResults() == 1){
            throw new RuntimeException("该机器已通过QC检测");
        }

        Integer flag = 0;
        //添加日志
        QcInfo qcInfo = new  QcInfo();
        qcInfo.setDetectId(record.getDetectId());
        qcInfo.setQcIsThrough(record.getMaintenanceResults());
        qcInfo.setQcInfoDesc(record.getQcDesc());
        flag = complaintDetectInfoMapper.addQcInfo(qcInfo);
        if(flag < 1){
            throw new RuntimeException("添加QC检测记录失败");
        }
        flag = complaintDetectInfoMapper.updateDetectById(record);
        if(flag < 1){
            throw new RuntimeException("修改QC检测状态");
        }

        if(record.getMaintenanceResults() == 1){
            //maintenanceResults
            //判断是否为维修
            ComplaintDetectInfo cdi = complaintDetectInfoMapper.getDetectById(record.getDetectId());
            Integer typeId = cdi.getProcTypeId();
            if(typeId == null){
                typeId = cdi.getTypeId();
            }
            if(typeId != null){
                if(typeId == 3){    //3: 维修
                    //减去售后仓库不良品
                    InventoryInfo inventoryInfo1 = new InventoryInfo();
                    inventoryInfo1.setInventoryDefectiveProductNum(1);
                    inventoryInfo1.setInventoryProductColorId(cdi.getProductColorId());
                    inventoryInfo1.setWarehouseId(2);
                    inventoryInfo1.setInventoryRecentRecord("维修机器完成，从售后不良品仓转入售后良品仓(维修ID:"+record.getDetectNumber()+")");
                    inventoryService.minusInventory(inventoryInfo1);

                    //增加售后仓库的良品
                    InventoryInfo inventoryInfo2 = new InventoryInfo();
                    inventoryInfo2.setInventoryGoodProductNum(1);
                    inventoryInfo2.setInventoryProductColorId(cdi.getProductColorId());
                    inventoryInfo2.setWarehouseId(2);
                    inventoryInfo2.setInventoryRecentRecord("维修机器完成，从售后不良品仓转入售后良品仓(维修ID:"+record.getDetectNumber()+")");
                    inventoryService.addInventory(inventoryInfo2);
                }else{  //退货等
                    //减去售后仓库不良品
                    InventoryInfo inventoryInfo1 = new InventoryInfo();
                    inventoryInfo1.setInventoryDefectiveProductNum(1);
                    inventoryInfo1.setInventoryProductColorId(cdi.getProductColorId());
                    inventoryInfo1.setWarehouseId(2);
                    inventoryInfo1.setInventoryRecentRecord("退货/换货，从售后不良品仓转入正常销售良品仓(维修ID:"+record.getDetectNumber()+")");
                    inventoryService.minusInventory(inventoryInfo1);

                    //增加销售仓库的良品
                    InventoryInfo inventoryInfo2 = new InventoryInfo();
                    inventoryInfo2.setInventoryGoodProductNum(1);
                    inventoryInfo2.setInventoryProductColorId(cdi.getProductColorId());
                    inventoryInfo2.setWarehouseId(2);
                    inventoryInfo2.setInventoryRecentRecord("退货/换货，从售后不良品仓转入正常销售良品仓(维修ID:"+record.getDetectNumber()+")");
                    inventoryService.addInventory(inventoryInfo2);
                }
            }
        }
        return flag;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class}, isolation = Isolation.REPEATABLE_READ)
    public int updateDetectById(ComplaintDetectInfo record,String[] imgs) {
        //判断售后流程
        ProcMethod procMethod;
        Integer procTypeId;
        //判断是签收生成还是手动添加
        ComplaintDetectInfo complaintDetectInfo  = complaintDetectInfoMapper.getDetectById(record.getDetectId());
        if(complaintDetectInfo.getDetectSource() == 2 || complaintDetectInfo.getDetectSource() == 3){
            //手动添加
            procMethod = procMethodMapper.getProcMethodById(complaintDetectInfo.getMethodId());
        }else{
            CmRelation cmRelation = new CmRelation();
            cmRelation.setCustomerId(record.getCustomerId());
            cmRelation = customerInfoMapper.getCmRelationInfo(cmRelation);
            procMethod = procMethodMapper.getProcMethodById(cmRelation.getProcMethodId());
        }
        if (procMethod != null) {
            procTypeId = procMethod.getProcTypeId();
            switch (procTypeId){
                case 3:
                    //维修
                    if(procMethod.getProcMethodIsCharge() == 0){
                        //待定
                        if(record.getIsMaintenance() == 1){
                            //机器故障，待用户确认
                            record.setDetectState(38);
                        }else if(record.getIsMaintenance() == 2){
                            //机器无故障，待用户确认
                            record.setDetectState(37);
                        }
                    }else if(procMethod.getProcMethodIsCharge() == 1){
                        //付费
                        //待用户确认
                        record.setDetectState(30);
                    }else if(procMethod.getProcMethodIsCharge() == 2){
                        //免费
                        //待客服确认维修
                        record.setDetectState(34);
                    }
                    if (complaintDetectInfo.getDetectIsMaintain() == null) {
                        complaintDetectInfo.setDetectIsMaintain(1);
                    }
                    break;
                default:
                    // 退货/换货
                    String processingResults = "";
                    String text = "";
                    if(record.getDetectRenovation() == 1){
                        // 是否可翻新 1可翻新 2不可翻新
                        // 待翻新入库
                        record.setDetectState(20);
                        processingResults = "维修";
                    }else if(record.getDetectRenovation() == 2){
                        // 不能翻新，待报废
                        record.setDetectState(22);
                        processingResults = "报废";
                    }
                    // 查询维修编号
                    ComplaintDetectInfo info = complaintDetectInfoMapper.getDetectById(record.getDetectId());
                    // 客诉状态为换货或退货时完成检测需要短信通知维修人员
                    if(procTypeId == 2){
                        //换货
                        text = MessageFormat.format(SmsConfig.CUSTOMER_EXCHANGE, info.getDetectNumber(),processingResults);
                    }
                    if(procTypeId == 4){
                        //退货
                        text = MessageFormat.format(SmsConfig.CUSTOMER_RETURN, info.getDetectNumber(),processingResults);
                    }
                    if(procTypeId == 2 || procTypeId == 4){
                        String result = smsService.sendOtherCMS(SmsConfig.CUSTOMER_PHONE, text);
                        logger.info("给 " + SmsConfig.CUSTOMER_PHONE + " 手机用户发送短信：" + text+"发送完成检测结果（"+processingResults+"）："+result);
                    }

                    if (complaintDetectInfo.getDetectIsMaintain() == null) {
                        complaintDetectInfo.setDetectIsMaintain(2);
                    }
            }
        }
        Product product = productMapper.getProduce(complaintDetectInfo.getProductId());
        Produce temp = new Produce();
        if (product != null && product.getProduceId() != null && product.getProduceId() != null) {
            temp.setProduceId(product.getProduceId());
            temp = produceMapper.getProduceByPro(temp);
            if (temp == null) {
                throw new RuntimeException("销售产品未获取到对应的绑定生产产品");
            }
        } else {
            throw new RuntimeException("销售产品未获取到对应的绑定生产产品");
        }

        try {
            // 维修报价
            CompanyInfo companyInfo = null;
            if (record.getDetectPhenomenonIds() != null && record.getDetectPhenomenonIds().length >= 1) {

                // 是否维修，1表示判断维修、2表示判断翻新
                if (complaintDetectInfo.getDetectIsMaintain() == 1) {
                    if (complaintDetectInfo.getStoreId() == null) {
                        // 爱贝源客户
                        companyInfo = companyInfoMapper.getCompanyInfoById(1);
                    } else {
                        // 其他客户
                        companyInfo = companyInfoMapper.getCompanyInfoById(storeInfoMapper.getStoreInfoById(complaintDetectInfo.getStoreId()).getCompanyId());
                    }
                    Date createDate = DateTimeUtil.parse(record.getDetectProduction(), "yyyy-MM-dd");
                    createDate = DateTimeUtil.addMonth(createDate, companyInfo.getCompanyMaintainMonth());
                    createDate = DateTimeUtil.addMonth(createDate, companyInfo.getCompaynStorageMonth());
                    if (createDate.getTime() >= complaintDetectInfo.getDetectCreateTime().getTime()
                            && record.getIsMaintenance() == 1
                            && record.getDeleteMaintainType() == 1) {
                        // 质保期内、机器有故障，并且为质量问题导致的（免费维修）
                        record.setDetectState(34);
                        record.setDetectOffer(0);
                    } else if (procMethod != null && procMethod.getProcMethodIsCharge() != null && procMethod.getProcMethodIsCharge() == 0) {
                        // 此处为了兼容爱贝源的检测待定选项
                        if(record.getIsMaintenance() == 1){
                            // 机器故障，待用户确认
                            if (createDate.getTime() >= complaintDetectInfo.getDetectCreateTime().getTime() && record.getDeleteMaintainType() == 1) {
                                // 质保期内、机器有故障，并且为质量问题导致的（免费维修）
                                record.setDetectState(34);
                                record.setDetectOffer(0);
                            } else {
                                // 系统检测，若维修类型为同一个时，再次递增同类型的问题现象，不收取维修费用
                                Map<Integer, Integer> maintainType = new HashMap<>(5);
                                for (Integer id : record.getDetectPhenomenonIds()) {
                                    // 计算维修费用
                                    MaintainPhenomenon phenomenon = null;
                                    if (record.getDetectOffer() == null) {
                                        phenomenon = phenomenonMapper.get(id);
                                        record.setDetectOffer(phenomenon.getPhenomenonMaintainPrice());
                                    } else {
                                        phenomenon = phenomenonMapper.get(id);
                                        record.setDetectOffer(record.getDetectOffer() + phenomenon.getPhenomenonMaintainPrice());
                                    }
                                    // 保存问题类型出现的次数
                                    Integer val = maintainType.get(phenomenon.getTypeId());
                                    if (val == null) {
                                        maintainType.put(phenomenon.getTypeId(), 0);
                                    } else {
                                        maintainType.put(phenomenon.getTypeId(), val++);
                                    }
                                }
                                // 减去同类型问题现象的拆机费用
                                maintainType.forEach((k, v) -> {
                                    record.setDetectOffer(record.getDetectOffer()-v*50_00);
                                });
                                // 系统设置最高的维修价格上限，当超过最高的维修上限时，使用最高的维修价格
                                if (record.getDetectOffer() > MAX_MAINTAIN_PRICE) {
                                    record.setDetectOffer(MAX_MAINTAIN_PRICE);
                                }
                                record.setDetectState(30);
                            }
                        }else if(record.getIsMaintenance() == 2){
                            // 机器无故障，待用户确认
                            record.setDetectOffer(0);
                            record.setDetectState(37);
                        }
                    } else {
                        // 质保期外(付费维修) , 并且机器非检测待定的
                        // 系统检测，若维修类型为同一个时，再次递增同类型的问题现象，不收取维修费用
                        Map<Integer, Integer> maintainType = new HashMap<>(5);
                        for (Integer id : record.getDetectPhenomenonIds()) {
                            // 计算维修费用
                            MaintainPhenomenon phenomenon = null;
                            if (record.getDetectOffer() == null) {
                                phenomenon = phenomenonMapper.get(id);
                                record.setDetectOffer(phenomenon.getPhenomenonMaintainPrice());
                            } else {
                                phenomenon = phenomenonMapper.get(id);
                                record.setDetectOffer(record.getDetectOffer() + phenomenon.getPhenomenonMaintainPrice());
                            }
                            // 保存问题类型出现的次数
                            Integer val = maintainType.get(phenomenon.getTypeId());
                            if (val == null) {
                                maintainType.put(phenomenon.getTypeId(), 0);
                            } else {
                                maintainType.put(phenomenon.getTypeId(), val++);
                            }
                        }
                        // 减去同类型问题现象的拆机费用
                        maintainType.forEach((k, v) -> {
                            record.setDetectOffer(record.getDetectOffer()-v*50_00);
                        });
                        // 系统设置最高的维修价格上限，当超过最高的维修上限时，使用最高的维修价格
                        if (record.getDetectOffer() > MAX_MAINTAIN_PRICE) {
                            record.setDetectOffer(MAX_MAINTAIN_PRICE);
                        }
                        record.setDetectState(30);
                    }
                } else {
                    if (record.getIsMaintenance() == 1) {
                        // 无故障(付费翻新)
                        if (record.getDeleteIsUse() == 1) {
                            // 未过水(翻新)
                            if (temp.getProduceIsW() == 1) {
                                // W系列
                                record.setDetectOffer(Integer.parseInt(sysConfigMapper.getSysConfig(12)));
                            } else if (temp.getProduceIsW() == 2) {
                                // S系列
                                record.setDetectOffer(Integer.parseInt(sysConfigMapper.getSysConfig(14)));
                            }
                        } else {
                            // 已过水(翻新)
                            if (temp.getProduceIsW() == 1) {
                                // W系列
                                record.setDetectOffer(Integer.parseInt(sysConfigMapper.getSysConfig(11)));
                            } else if (temp.getProduceIsW() == 2) {
                                // S系列
                                record.setDetectOffer(Integer.parseInt(sysConfigMapper.getSysConfig(13)));
                            }
                        }
                        record.setDetectState(24);
                    } else {
                        // 有故障
                        if (record.getDeleteMaintainType() == 1) {
                            // 质量问题(获取当前客户录入日期和仓储期+售后期，对比机器生产日期)
                            if (complaintDetectInfo.getStoreId() == null) {
                                // 爱贝源客户
                                companyInfo = companyInfoMapper.getCompanyInfoById(1);
                            } else {
                                // 其他客户
                                companyInfo = companyInfoMapper.getCompanyInfoById(storeInfoMapper.getStoreInfoById(complaintDetectInfo.getStoreId()).getCompanyId());
                            }
                            Date createDate = DateTimeUtil.parse(record.getDetectProduction(), "yyyy-MM-dd");
                            createDate = DateTimeUtil.addMonth(createDate, companyInfo.getCompanyAfterMonth());
                            createDate = DateTimeUtil.addMonth(createDate, companyInfo.getCompaynStorageMonth());
                            if (createDate.getTime() >= complaintDetectInfo.getDetectCreateTime().getTime()) {
                                // 质保期内（免费换新）
                                record.setDetectOffer(0);
                                if (record.getDetectRenovation() == 1) {
                                    // 可以翻新
                                    record.setDetectState(20);
                                } else {
                                    // 不可翻新
                                    record.setDetectState(22);
                                }
                            } else {
                                // 质保期外
                                if (record.getDeleteIsUse() == 1) {
                                    // 未过水(翻新)
                                    if (temp.getProduceIsW() == 1) {
                                        // W系列
                                        record.setDetectOffer(Integer.parseInt(sysConfigMapper.getSysConfig(12)));
                                    } else if (temp.getProduceIsW() == 2) {
                                        // S系列
                                        record.setDetectOffer(Integer.parseInt(sysConfigMapper.getSysConfig(14)));
                                    }
                                } else {
                                    // 已过水(翻新)
                                    if (temp.getProduceIsW() == 1) {
                                        // W系列
                                        record.setDetectOffer(Integer.parseInt(sysConfigMapper.getSysConfig(11)));
                                    } else if (temp.getProduceIsW() == 2) {
                                        // S系列
                                        record.setDetectOffer(Integer.parseInt(sysConfigMapper.getSysConfig(13)));
                                    }
                                }
                                record.setDetectState(24);
                            }
                        } else {
                            // 非质量问题导致
                            if (record.getDeleteIsUse() == 1) {
                                // 未过水(翻新)
                                if (temp.getProduceIsW() == 1) {
                                    // W系列
                                    record.setDetectOffer(Integer.parseInt(sysConfigMapper.getSysConfig(12)));
                                } else if (temp.getProduceIsW() == 2) {
                                    // S系列
                                    record.setDetectOffer(Integer.parseInt(sysConfigMapper.getSysConfig(14)));
                                }
                            } else {
                                // 已过水(翻新)
                                if (temp.getProduceIsW() == 1) {
                                    // W系列
                                    record.setDetectOffer(Integer.parseInt(sysConfigMapper.getSysConfig(11)));
                                } else if (temp.getProduceIsW() == 2) {
                                    // S系列
                                    record.setDetectOffer(Integer.parseInt(sysConfigMapper.getSysConfig(13)));
                                }
                            }
                            record.setDetectState(24);
                        }
                    }
                }

                // 录入检测现象
                StringBuilder detectPhenomenon = new StringBuilder();
                complaintDetectInfoMapper.delPhenomenon(complaintDetectInfo.getDetectId());
                for (Integer id : record.getDetectPhenomenonIds()) {
                    DetectPhenomenon dp = new DetectPhenomenon();
                    dp.setDetectId(record.getDetectId());
                    dp.setPhenomenonId(id);
                    dp.setDpName(phenomenonMapper.get(id).getPhenomenonName());
                    detectPhenomenon.append(dp.getDpName()).append(";");
                    complaintDetectInfoMapper.addPhenomenon(dp);
                }
                // 检测现象描述
                record.setDetectPhenomenon(detectPhenomenon.toString());
            }

            // 修改
            if(complaintDetectInfoMapper.updateDetectById(record) > 0){
                if(imgs != null){
                    if(imgs.length > 0){
                        for(String img : imgs){
                            ComplaintDetectImg detectImg = new ComplaintDetectImg();
                            detectImg.setDetectId(record.getDetectId());
                            detectImg.setDetectImgUrl(img);
                            complaintDetectInfoMapper.addDetectImg(detectImg);
                        }
                    }
                }
            }
            if(complaintDetectInfo.getDetectSource() == 2 || complaintDetectInfo.getDetectSource() == 3){
                // 给客户发送短信
                if (complaintDetectInfo.getAdminId() != null) {
                    Admin admin = new Admin();
                    admin.setAdminId(complaintDetectInfo.getAdminId());
                    admin = sysMapper.get(admin);
                    String result = smsService.sendOtherCMS(admin.getAdminTel(), "【优尼雅电子科技】尊敬的客户您好，您的机器" + complaintDetectInfo.getDetectNumber() + "已经检测完成，请登入我司系统确认处理机器的方案。");
                    logger.info("给 " + admin.getAdminTel() + " 手机用户发送短信：通知客户选择处理方式："+result+"维修id："+record.getDetectId());
                }
                // 给业务员发短信
                if (complaintDetectInfo.getSalesmanAdminId() != null && companyInfo != null && companyInfo.getCompanyName() != null) {
                    Admin admin = new Admin();
                    admin.setAdminId(complaintDetectInfo.getSalesmanAdminId());
                    admin = sysMapper.get(admin);
                    String result = smsService.sendOtherCMS(admin.getAdminTel(), "【优尼雅电子科技】您客户 " + companyInfo.getCompanyName() + " 的机器" + complaintDetectInfo.getDetectNumber() + "已检测完成，请联系客户进入系统确认处理机器的方案。");
                    logger.info("给 " + admin.getAdminTel() + " 手机用户发送短信：通知业务员选择处理方式："+result+"维修id："+record.getDetectId());
                }

                // 手动添加需要给业务员发送短信
                if(complaintDetectInfo.getDetectState() == 30 || complaintDetectInfo.getDetectState() == 34|| complaintDetectInfo.getDetectState() == 38 || complaintDetectInfo.getDetectState() == 37){
                    if(complaintDetectInfo.getDetectTel() != null && !"".equals(complaintDetectInfo.getDetectTel()) && complaintDetectInfo.getSalesmanAdminId() != null){
                        String text = MessageFormat.format(SmsConfig.NOTIFY_SALESMAN, complaintDetectInfo.getDetectName()+complaintDetectInfo.getDetectTel(), ResultInfo.DETECT_MSG+complaintDetectInfo.getDetectId());
                        Admin admin = new Admin();
                        admin.setAdminId(complaintDetectInfo.getSalesmanAdminId());
                        admin = sysMapper.get(admin);
                        String result = smsService.sendOtherCMS(admin.getAdminTel(), text);
                        logger.info("给 " + complaintDetectInfo.getDetectTel() + " 手机用户发送短信：" + text+"发送通知业务员选择处理方式："+result+"维修id："+record.getDetectId());
                    }
                }

            }
        }catch (Exception e){
            e.printStackTrace();
            throw new RuntimeException("完成检测失败");
        }
        return 1;
    }
    //添加检测项
    public String adddetectItem(String configid,Integer detectId){
        DetectionConfig config = complaintDetectInfoMapper.getDetectionConfig(Integer.valueOf(configid));
        DetectionItem item = new DetectionItem();
        item.setDetectId(detectId);
        item.setItemConfigId(config.getConfigId());
        item.setItemDetectContent(config.getConfigDetectContent());
        complaintDetectInfoMapper.insertItem(item);
        return config.getConfigDetectContent();
    }

    @Override
    public PagedResult<ComplaintDetectInfo> listComplaintDetect(PageRequest<ComplaintDetectInfo> pageRequest) {
        PageHelper.startPage(pageRequest.getPageNO(), pageRequest.getPageSize(), pageRequest.isPageTotal());
        List<ComplaintDetectInfo> detectList = complaintDetectInfoMapper.listComplaintDetect(pageRequest.getData());
        PagedResult<ComplaintDetectInfo> result = PageUtil.getPage(detectList);
        if (result.getDataList() != null && !result.getDataList().isEmpty()) {
            for (ComplaintDetectInfo detectInfo : result.getDataList()) {
                detectInfo.setTransport(detectTransportMapper.get(detectInfo.getDetectId()));
            }
        }
        return result;
    }

    @Override
    public PagedResult<ComplaintDetectInfo> listAfterSales(PageRequest<ComplaintDetectInfo> pageRequest) {
        PageHelper.startPage(pageRequest.getPageNO(), pageRequest.getPageSize(), pageRequest.isPageTotal());
        List<ComplaintDetectInfo> detectList = complaintDetectInfoMapper.listAfterSales(pageRequest.getData());
        PagedResult<ComplaintDetectInfo> result = PageUtil.getPage(detectList);
        if (result.getDataList() != null && !result.getDataList().isEmpty()) {
            for (ComplaintDetectInfo detectInfo : result.getDataList()) {
                detectInfo.setTransport(detectTransportMapper.get(detectInfo.getDetectId()));
            }
        }
        return result;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class}, isolation = Isolation.REPEATABLE_READ)
    public int insert(ComplaintDetectInfo record) {
        // 判断是否有多个客户传递的问题现象
        if (record.getCustmoerPhenomena() != null && !record.getCustmoerPhenomena().isEmpty()) {
            record.setDetectCustmoerQuestion(null);
            for (DetectCustmoerPhenomenon custmoerPhenomenon : record.getCustmoerPhenomena()) {
                if (record.getDetectCustmoerQuestion() != null) {
                    record.setDetectCustmoerQuestion(record.getDetectCustmoerQuestion() + custmoerPhenomenon.getDcpName() + ";");
                } else {
                    record.setDetectCustmoerQuestion(custmoerPhenomenon.getDcpName() + ";");
                }
            }
            int res = complaintDetectInfoMapper.insert(record);
            // 添加问题现象
            for (DetectCustmoerPhenomenon custmoerPhenomenon : record.getCustmoerPhenomena()) {
                custmoerPhenomenon.setDetectId(record.getDetectId());
                detectCustmoerPhenomenonMapper.add(custmoerPhenomenon);
            }
            // 添加运输信息
            if (record.getTransport() == null) {
                DetectTransport transport = new DetectTransport();
                transport.setDetectId(record.getDetectId());
                detectTransportMapper.add(transport);
            } else {
                record.getTransport().setDetectId(record.getDetectId());
                detectTransportMapper.add(record.getTransport());
            }
            return res;
        }
        // 单个问题现象
        return complaintDetectInfoMapper.insert(record);
    }

    @Override
    public int deleteDetect(Integer detectId) {
        return complaintDetectInfoMapper.deleteDetect(detectId);
    }

    @Override
    public List<DetectionBasis> listDetectionBasis(DetectionBasis detectionBasis) {
        return complaintDetectInfoMapper.listDetectionBasis(detectionBasis);
    }

    @Override
    public int addDetectImg(ComplaintDetectImg complaintDetectImg) {
        return complaintDetectInfoMapper.addDetectImg(complaintDetectImg);
    }

    @Override
    public List<ComplaintDetectInfo> listComplaintDetect(ComplaintDetectInfo detectInfo) {
        List<ComplaintDetectInfo> res = complaintDetectInfoMapper.listComplaintDetect(detectInfo);
        if (res == null || res.isEmpty()) {
            return null;
        }
        res.forEach((d) -> {
            if (d != null && d.getDetectPhenomenonId() != null) {
                d.setPhenomen(phenomenonMapper.get(d.getDetectPhenomenonId()));
            }
            if (d != null && d.getSalesmanAdminId() != null) {
                Admin temp = new Admin();
                temp.setAdminId(d.getSalesmanAdminId());
                d.setSalesmanAdminName(sysMapper.get(temp).getAdminName());
            }
        });
        return res;
    }
    @Transactional
    @Override
    public boolean customerConfirm(ComplaintDetectInfo detectInfo,Admin admin) {
        ComplaintDetectInfo detect = complaintDetectInfoMapper.getDetectById(detectInfo.getDetectId());
        /*ProcMethod procMethod = procMethodMapper.getProcMethodById(detectInfo.getProcMethodId());*/
        //计算待维修完成时间
        Calendar date = Calendar.getInstance();
        date.setTime(new Date());
        boolean fl = false;
        for (int i = 1 ; i <= 5; i++){
            date.set(Calendar.DATE, date.get(Calendar.DATE) + i);
            int week = date.get(Calendar.DAY_OF_WEEK);//1--7的值,对应：星期日，星期一，星期二，星期三....星期六
            if(week == 1){
                fl = true;
            }
            date.set(Calendar.DATE, date.get(Calendar.DATE) - i);
        }
        if(fl){
            date.set(Calendar.DATE, date.get(Calendar.DATE) + 6);
        }else{
            date.set(Calendar.DATE, date.get(Calendar.DATE) + 5);
        }

        /*switch (detectInfo.getDetectState()){
            case 30:
                if(detectInfo.getDetectProcessingResults() == 1){//付费维修
                    detectInfo.setDetectState(31);//同意付费维修
                    detectInfo.setCompleteCutTime(date.getTime());
                }
                if(detectInfo.getDetectProcessingResults() == 3 || detectInfo.getDetectProcessingResults() == 4){//退货、换货
                    if(detect.getDetectRenovation() == 1){
                        detectInfo.setDetectState(20);//待翻新
                    }else{
                        detectInfo.setDetectState(22);//待报废
                    }
                }
                if(detectInfo.getDetectProcessingResults() == 5){//原机退回
                    detectInfo.setDetectState(33);//
                }
                break;
            case 34:
                if(detectInfo.getDetectProcessingResults() == null || detectInfo.getDetectProcessingResults() == 2 ){//免费维修
                    detectInfo.setDetectState(35);
                    detectInfo.setCompleteCutTime(date.getTime());
                }
                if(detectInfo.getDetectProcessingResults() == 5){//原机退回
                    detectInfo.setDetectState(33);
                }
                break;
            case 37:
                if(detectInfo.getDetectProcessingResults() == 1){//付费维修
                    detectInfo.setDetectState(31);//同意付费维修
                    detectInfo.setCompleteCutTime(date.getTime());
                }
                if(detectInfo.getDetectProcessingResults() == 2){//免费维修
                    detectInfo.setDetectState(35);//同意免费维修
                    detectInfo.setCompleteCutTime(date.getTime());
                }
                if(detectInfo.getDetectProcessingResults() == 3 || detectInfo.getDetectProcessingResults() == 4){//退货、换货
                    if(detect.getDetectRenovation() == 1){
                        detectInfo.setDetectState(20);//待翻新
                    }else{
                        detectInfo.setDetectState(22);//待报废
                    }
                }
                if(detectInfo.getDetectProcessingResults() == 5){//原机退回
                    detectInfo.setDetectState(39);//原机退回
                }
                break;
            case 38:
                if(detectInfo.getDetectProcessingResults() == 1){//付费维修
                    detectInfo.setDetectState(31);//同意付费维修
                    detectInfo.setCompleteCutTime(date.getTime());
                }
                if(detectInfo.getDetectProcessingResults() == 2){//免费维修
                    detectInfo.setDetectState(35);//同意免费维修
                    detectInfo.setCompleteCutTime(date.getTime());
                }
                if(detectInfo.getDetectProcessingResults() == 3 || detectInfo.getDetectProcessingResults() == 4){//退货、换货
                    if(detect.getDetectRenovation() == 1){
                        detectInfo.setDetectState(20);//待翻新
                    }else{
                        detectInfo.setDetectState(22);//待报废
                    }
                }
                if(detectInfo.getDetectProcessingResults() == 5){//原机退回
                    detectInfo.setDetectState(37);//原机退回
                }
                break;
        }*/

        try {
            if(complaintDetectInfoMapper.updateDetectById(detectInfo) > 0){
                if(detectInfo.getProcMethodId() != null && !"".equals(detectInfo.getProcMethodId())){
                    CmRelation cmRelation = new CmRelation();
                    cmRelation.setCustomerId(detectInfo.getCustomerId());
                    cmRelation.setProcMethodId(detectInfo.getProcMethodId());
                    if(customerInfoMapper.updateCmRelationProcMethod(cmRelation) > 0){
                        return true;
                    }
                }
                //添加客服操作记录
                TreatmentRecordLog log = new TreatmentRecordLog();
                log.setDetectId(detectInfo.getDetectId());
                log.setRecordAdminId(admin.getAdminId());
                log.setRecordDesc(detectInfo.getDetectCustomerDesc());
                if (detectInfo.getDetectState() == 25) {
                    log.setRecordProcessingResults(6);
                } else if (detectInfo.getDetectState() == 27) {
                    log.setRecordProcessingResults(5);
                } else if (detectInfo.getDetectState() == 31) {
                    log.setRecordProcessingResults(1);
                } else if (detectInfo.getDetectState() == 33) {
                    log.setRecordProcessingResults(6);
                }

                complaintDetectInfoMapper.addTreatmentRecordLog(log);
                //发送确认短信
                //发送确认短信
                if (detectInfo.getDetectState() != null) {
                    String msg = null;
                    switch (detect.getDetectState()) {
                        case 31: msg="【优尼雅电子科技】客户已确认" + detect.getDetectNumber() + "维修，请立即开始维修处理。";break;
                        case 33: msg="【优尼雅电子科技】客户确认" + detect.getDetectNumber() + "机器不维修(原机退回给客户)，请联系业务员，并请业务员联系客户，将此机器寄回。";break;
                        case 25: msg="【优尼雅电子科技】客户确认" + detect.getDetectNumber() + "机器不翻新(原机退回给客户)，请联系业务员，并请业务员联系客户，将此机器寄回。";break;
                        case 27: msg="【优尼雅电子科技】客户已确认" + detect.getDetectNumber() + "翻新，请立即开始翻新处理。";break;
                        default: break;
                    }
                    if (msg != null) {
                        smsService.sendOtherCMS(SmsConfig.CUSTOMER_PHONE, msg);
                    }
                }
               /* String results = "";
                switch (detectInfo.getDetectProcessingResults()){
                    case 1:
                        results = "付费维修";
                        break;
                    case 2:
                        results = "免费维修";
                        break;
                    case 3:
                        results = "退货";
                        break;
                    case 4:
                        results = "换货";
                        break;
                    case 5:
                        results = "原机退回";
                        break;
                }
                String text = MessageFormat.format(SmsConfig.CUSTOMER_CONFIRM, detect.getDetectNumber(),results);
                String result = smsService.sendOtherCMS(SmsConfig.CUSTOMER_PHONE, text);
                logger.info("给 " + SmsConfig.CUSTOMER_PHONE + " 手机用户发送短信：" + text+"发送结果："+result);*/
             return true;
            }
        }catch (Exception e){
            e.printStackTrace();
            throw new RuntimeException("确认处理失败");
        }
        return false;
    }


    @Transactional(rollbackFor = {RuntimeException.class})
    @Override
    public boolean salesmanConfirm(ComplaintDetectInfo detectInfo) {
        ComplaintDetectInfo detect = complaintDetectInfoMapper.getDetectById(detectInfo.getDetectId());
        if(detect.getDetectState() != 30 && detect.getDetectState() != 24 && detect.getDetectState() != 34 && detect.getDetectState() != 38 && detect.getDetectState() != 37){
            return false;
        }
        //计算待维修完成时间
        Calendar date = Calendar.getInstance();
        date.setTime(new Date());
        boolean fl = false;
        for (int i = 1 ; i <= 5; i++){
            date.set(Calendar.DATE, date.get(Calendar.DATE) + i);
            int week = date.get(Calendar.DAY_OF_WEEK);//1--7的值,对应：星期日，星期一，星期二，星期三....星期六
            if(week == 1){
                fl = true;
            }
            date.set(Calendar.DATE, date.get(Calendar.DATE) - i);
        }
        if(fl){
            date.set(Calendar.DATE, date.get(Calendar.DATE) + 6);
        }else{
            date.set(Calendar.DATE, date.get(Calendar.DATE) + 5);
        }
        if (detectInfo.getDetectProcessingResults() != null) {
            if(detectInfo.getDetectProcessingResults() == 1){
                //付费维修
                detectInfo.setDetectState(31);//同意付费维修
                detectInfo.setCompleteCutTime(date.getTime());
            }else if(detectInfo.getDetectProcessingResults() == 2){
                //免费维修
                detectInfo.setDetectState(35);//同意付费维修
                detectInfo.setCompleteCutTime(date.getTime());
            }
            if(detectInfo.getDetectProcessingResults() == 3 || detectInfo.getDetectProcessingResults() == 4){
                //退货、换货
                if(detect.getDetectRenovation() == 1){
                    //待翻新
                    detectInfo.setDetectState(20);
                }else{
                    //待报废
                    detectInfo.setDetectState(22);
                }
            }
            if(detectInfo.getDetectProcessingResults() == 5){
                //原机退回
                detectInfo.setDetectState(33);
            }
        }
        try {
            if(complaintDetectInfoMapper.updateDetectById(detectInfo) > 0){
                //添加业务员操作记录
                if(detect.getSalesmanAdminId() != null){
                    TreatmentRecordLog log = new TreatmentRecordLog();
                    log.setDetectId(detectInfo.getDetectId());
                    log.setRecordAdminId(detect.getSalesmanAdminId());
                    log.setRecordDesc(detect.getDetectCustomerDesc());
                    log.setRecordProcessingResults(detectInfo.getDetectProcessingResults());
                    complaintDetectInfoMapper.addTreatmentRecordLog(log);
                }
                //发送确认短信
                if (detectInfo.getDetectState() != null) {
                    String msg = null;
                    switch (detect.getDetectState()) {
                        case 31: msg="【优尼雅电子科技】客户已确认" + detect.getDetectNumber() + "维修，请立即开始维修处理。";break;
                        case 33: msg="【优尼雅电子科技】客户确认" + detect.getDetectNumber() + "机器不维修(原机退回给客户)，请联系业务员，并请业务员联系客户，将此机器寄回。";break;
                        case 25: msg="【优尼雅电子科技】客户确认" + detect.getDetectNumber() + "机器不翻新(原机退回给客户)，请联系业务员，并请业务员联系客户，将此机器寄回。";break;
                        case 27: msg="【优尼雅电子科技】客户已确认" + detect.getDetectNumber() + "翻新，请立即开始翻新处理。";break;
                        default: break;
                    }
                    if (msg != null) {
                        smsService.sendOtherCMS(SmsConfig.CUSTOMER_PHONE, msg);
                    }
                }
                return true;
            }
        }catch (Exception e){
            e.printStackTrace();
            throw new RuntimeException("确认处理失败");
        }
        return false;
    }

    @Override
    public List<ComplaintDetectImg> listDetectImg(Integer detectId) {
        return complaintDetectInfoMapper.listDetectImg(detectId);
    }

    @Override
    public Integer getDetectNum() {
        return complaintDetectInfoMapper.getDetectNum();
    }

    @Override
    public List<MaterialNumberInfo> listMaterialNumber() {
        return complaintDetectInfoMapper.listMaterialNumber();
    }

    @Override
    public List<DetectionConfig> listDetectionConfig(Integer configType) {
        return complaintDetectInfoMapper.listDetectionConfig(configType);
    }

    @Override
    public DetectionConfig getDetectionConfig(Integer configId) {
        return complaintDetectInfoMapper.getDetectionConfig(configId);
    }

    @Override
    public Integer insertItem(DetectionItem detectionItem) {
        return complaintDetectInfoMapper.insertItem(detectionItem);
    }

    @Override
    public List<DetectionItem> listDetectionItem(DetectionItem detectionItem) {
        return complaintDetectInfoMapper.listDetectionItem(detectionItem);
    }

    @Override
    public Integer detectDetectionItem(Integer detectId) {
        return complaintDetectInfoMapper.detectDetectionItem(detectId);
    }

    @Override
    public MaterialNumberInfo getMaterialNumber(Integer materialId) {
        return complaintDetectInfoMapper.getMaterialNumber(materialId);
    }

    @Override
    public Integer addMaterialItem(MaterialItem materialItem) {
        return complaintDetectInfoMapper.addMaterialItem(materialItem);
    }

    @Override
    public List<MaterialItem> listMaterialItem(Integer detectId) {
        return complaintDetectInfoMapper.listMaterialItem(detectId);
    }

    @Override
    public Integer detectMaterialItem(Integer detectId) {
        return complaintDetectInfoMapper.detectMaterialItem(detectId);
    }

    @Override
    public Integer addQcInfo(QcInfo qcInfo) {
        return complaintDetectInfoMapper.addQcInfo(qcInfo);
    }

    @Override
    public List<QcInfo> listQcInfo(Integer detectId) {
        return complaintDetectInfoMapper.listQcInfo(detectId);
    }

    @Override
    public Integer addTreatmentRecordLog(TreatmentRecordLog treatmentRecordLog) {
        return complaintDetectInfoMapper.addTreatmentRecordLog(treatmentRecordLog);
    }

    @Override
    public List<TreatmentRecordLog> listTreatmentRecordLog(Integer detectId) {
        return complaintDetectInfoMapper.listTreatmentRecordLog(detectId);
    }

    @Override
    public ComplaintAfterSalesNum getCustomerDetectNum(ComplaintDetectInfo detect) {
        return complaintDetectInfoMapper.getCustomerDetectNum(detect);
    }

    @Override
    @Transactional
    public Integer updatePrint(ComplaintDetectInfo detectInfo) {
        ComplaintDetectInfo cdi = complaintDetectInfoMapper.getDetectByIdFast(detectInfo.getDetectId());
        if(cdi == null){
            return 0;
        }
        detectInfo.setDetectNumber(cdi.getDetectNumber());
        Integer flag = complaintDetectInfoMapper.updateDetectById(detectInfo);
        if(flag < 1){
            return flag;
        }

        if(detectInfo.getDetectState() != null && detectInfo.getDetectState() != 0){
            if(!Objects.equals(cdi.getDetectState(), detectInfo.getDetectState())){ //修改状态时判断状态，来调整库存
                switch (detectInfo.getDetectState()){    //detectState
                    case 23:    //报废完成-减少不良品数量
                        InventoryInfo inventoryInfo2 = new InventoryInfo();
                        inventoryInfo2.setInventoryDefectiveProductNum(1);
                        inventoryInfo2.setInventoryProductColorId(cdi.getProductColorId());
                        inventoryInfo2.setWarehouseId(2);
                        inventoryInfo2.setInventoryRecentRecord("产品报废(维修ID:"+detectInfo.getDetectNumber()+")");
                        flag = inventoryService.minusInventory(inventoryInfo2);
                        if(flag < 1){
                            throw new RuntimeException("签收失败，更新库存失败。");
                        }
                        break;
                    default:
                        break;
                }
            }
        }
        return flag;
    }

    @Override
    public List<ComplaintDetectInfo> listDetectByCustomerId(Integer customerId) {
        return complaintDetectInfoMapper.listDetectByCustomerId(customerId);
    }

    @Override
    public List<ComplaintDetectInfo> listComplaintDetectBySalesId(String detectSalesId) {
        return complaintDetectInfoMapper.listComplaintDetectBySalesId(detectSalesId);
    }

    @Override
    public ComplaintAfterSalesNum getDetectCount() {
        return complaintDetectInfoMapper.getDetectCount();
    }

    @Override
    public List<ComplaintDetectInfo> listMaintenanceCutNotice() {
        return complaintDetectInfoMapper.listMaintenanceCutNotice();
    }

    @Override
    public List<ComplaintDetectInfo> listCompleteCutNotice() {
        return complaintDetectInfoMapper.listCompleteCutNotice();
    }

    @Override
    public Integer perfectDetect(ComplaintDetectInfo detectInfo) {
        return complaintDetectInfoMapper.updateDetectById(detectInfo);
    }

    @Override
    public Integer addConfig(DetectionConfig detectionConfig) {
        return complaintDetectInfoMapper.addConfig(detectionConfig);
    }

    @Override
    public Integer addMaterial(MaterialNumberInfo materialNumberInfo) {
        return complaintDetectInfoMapper.addMaterial(materialNumberInfo);
    }

    @Override
    public List<MaintainPhenomenon> listPhenomenon(Integer typeId) {
        MaintainPhenomenon maintainPhenomenon = new MaintainPhenomenon();
        maintainPhenomenon.setTypeId(typeId);
        return phenomenonMapper.list(maintainPhenomenon);
    }

    @Override
    public int editTransport(DetectTransport detectTransport) {
        return detectTransportMapper.edit(detectTransport);
    }

    @Override
    public MaintainPhenomenon getPhenomenon(Integer id) {
        return phenomenonMapper.get(id);
    }


}