iamberry-common-parent/watero-rst-service/src/main/java/com/iamberry/rst/service/fm/ComplaintDetectInfoServiceImpl.java

package com.iamberry.rst.service.fm;


import com.github.pagehelper.PageHelper;
import com.iamberry.rst.core.cm.CmRelation;
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.page.PageRequest;
import com.iamberry.rst.core.page.PagedResult;
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.CustomerInfoMapper;
import com.iamberry.rst.service.cm.mapper.ProcMethodMapper;
import com.iamberry.rst.service.fm.mapper.ComplaintDetectInfoMapper;
import com.iamberry.rst.service.fm.mapper.ComplaintMaintenanceInfoMapper;
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.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.Transactional;

import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Objects;

@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;

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

    @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){
                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){
            throw new RuntimeException("修改检测维修内容失败");
        }
        return complaintDetectInfoMapper.updateDetectById(record);
    }
    @Override
    @Transactional
    public int updateDetectQc(ComplaintDetectInfo record) {
        ComplaintDetectInfo comdi = complaintDetectInfoMapper.getDetectByIdFast(record.getDetectId());
        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());
            if(cdi.getProcTypeId() == 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(1);
                inventoryInfo2.setInventoryRecentRecord("退货/换货，从售后不良品仓转入正常销售良品仓(维修ID:"+record.getDetectNumber()+")");
                inventoryService.addInventory(inventoryInfo2);
            }
        }
        return flag;
    }
    @Transactional
    @Override
    public int updateDetectById(ComplaintDetectInfo record,String[] imgs) {
        //判断售后流程

        /*if(record.getCustomerId() == null){
            if(record.getDetectRenovation() == 1){
                record.setDetectState(20);//待翻新入库
            }else{
                record.setDetectState(22);//不能翻新，待报废
            }
        }else{*/
            ProcMethod procMethod;
            Integer procTypeId;
            //判断是签收生成还是手动添加
            ComplaintDetectInfo complaintDetectInfo  = complaintDetectInfoMapper.getDetectById(record.getDetectId());
            if(complaintDetectInfo.getDetectSource() == 2){//手动添加
                procMethod = procMethodMapper.getProcMethodById(complaintDetectInfo.getMethodId());
            }else{
                CmRelation cmRelation = new CmRelation();
                cmRelation.setCustomerId(record.getCustomerId());
                cmRelation = customerInfoMapper.getCmRelationInfo(cmRelation);
                procMethod = procMethodMapper.getProcMethodById(cmRelation.getProcMethodId());
            }
            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);//待客服确认维修
                    }
                    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);
                    }
            }
        /*}*/
        try {
        //封装检测信息
        //检测现象
        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());
            }
        }

            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){//手动添加需要给业务员发送短信
                //发送短信通知维修检测人员
                if(record.getDetectState() == 30 || record.getDetectState() == 34|| record.getDetectState() == 38){
                    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){
            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());
        return PageUtil.getPage(detectList);
    }

    @Override
    public int insert(ComplaintDetectInfo record) {
        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) {
        return complaintDetectInfoMapper.listComplaintDetect(detectInfo);
    }
    @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:
                detectInfo.setDetectState(35);
                detectInfo.setCompleteCutTime(date.getTime());
                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());
                log.setRecordProcessingResults(detectInfo.getDetectProcessingResults());
                complaintDetectInfoMapper.addTreatmentRecordLog(log);
                //发送确认短信
                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){
            throw new RuntimeException("确认处理失败");
        }
        return false;
    }


    @Transactional
    @Override
    public boolean salesmanConfirm(ComplaintDetectInfo detectInfo) {
        ComplaintDetectInfo detect = complaintDetectInfoMapper.getDetectById(detectInfo.getDetectId());
        if(detect.getDetectState() != 30 && detect.getDetectState() != 34 && detect.getDetectState() != 38){
            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() == 1){//付费维修
                    detectInfo.setDetectState(31);//同意付费维修
                    detectInfo.setCompleteCutTime(date.getTime());
                }else if(detectInfo.getDetectProcessingResults() == 2){//免费维修
                    detectInfo.setDetectState(35);//同意付费维修
                    detectInfo.setCompleteCutTime(date.getTime());
                }
                if(detectInfo.getDetectProcessingResults() == 3 || detect.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){
                //添加业务员操作记录
                TreatmentRecordLog log = new TreatmentRecordLog();
                log.setDetectId(detectInfo.getDetectId());
                log.setRecordAdminId(detect.getSalesmanAdminId());
                log.setRecordDesc(detect.getDetectCustomerDesc());
                log.setRecordProcessingResults(detect.getDetectProcessingResults());
                complaintDetectInfoMapper.addTreatmentRecordLog(log);
                //发送确认短信
                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){
            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;
        }
        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);
    }


}