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

package com.iamberry.rst.service.fm;


import com.auth0.jwt.internal.org.apache.commons.lang3.StringUtils;
import com.github.pagehelper.PageHelper;
import com.iamberry.redis.RedisUtils;
import com.iamberry.rst.core.cm.*;
import com.iamberry.rst.core.fm.*;
import com.iamberry.rst.core.order.Product;
import com.iamberry.rst.core.order.ProductColor;
import com.iamberry.rst.core.page.PageRequest;
import com.iamberry.rst.core.page.PagedResult;
import com.iamberry.rst.faces.cm.InventoryService;
import com.iamberry.rst.faces.fm.ComplaintSignclosedInfoService;
import com.iamberry.rst.faces.sms.SmsService;
import com.iamberry.rst.service.cm.mapper.*;
import com.iamberry.rst.service.fm.mapper.*;
import com.iamberry.rst.service.product.mapper.ProductMapper;
import com.iamberry.rst.util.PageUtil;
import com.iamberry.rst.util.ProduceNoUtil;
import com.iamberry.rst.util.SmsConfig;
import net.sf.json.JSONArray;
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.*;

@Service
public class ComplaintSignclosedInfoServiceImpl implements ComplaintSignclosedInfoService {
    private Logger logger = LoggerFactory.getLogger(ComplaintSignclosedInfoServiceImpl.class);
    @Autowired
    private ComplaintSignclosedInfoMapper complaintSignclosedInfoMapper;
    @Autowired
    private ProductMapper productMapper;
    @Autowired
    private AwaitingSignclosedProductMapper awaitingSignclosedProductMapper;
    @Autowired
    private ComplaintSignclosedProductInfoMapper complaintSignclosedProductInfoMapper;
    @Autowired
    private FittingsInfoMapper fittingsInfoMapper;
    @Autowired
    private ComplaintDetectInfoMapper complaintDetectInfoMapper;
    @Autowired
    private CustomerInfoMapper customerInfoMapper;
    @Autowired
    private InventoryMapper inventoryMapper;
    @Autowired
    private InventoryLogMapper inventoryLogMapper;
    @Autowired
    private SmsService smsService;

    @Autowired
    private InventoryService inventoryService;

    @Override
    @Transactional
    public Integer insert(ComplaintSignclosedInfo record,
                          String orderItemString,String[] componentsImgs) {
        Integer msg = 0;
        int num = 0;
        Integer signclosedId = null;
        Integer flag = 0;
        List<ComplaintSignclosedInfo> sinfoList = new ArrayList<>();
        //查询是否已存在相同单号
        if(record.getSignclosedLogisticsNumber() != null){
            ComplaintSignclosedInfo info = new ComplaintSignclosedInfo();
            //判断是否是京东
            if (record.getSignclosedLogisticsNumber().contains("-")){
                //截取-前的内容搜索一次
                info.setSignclosedLogisticsNumber(StringUtils.substringBefore(record.getSignclosedLogisticsNumber(), "-"));
                sinfoList = complaintSignclosedInfoMapper.listSignclosed(info);
                if(sinfoList.size() <= 0){//如果没有搜索到数据，则用完整单号搜索
                    info.setSignclosedLogisticsNumber(record.getSignclosedLogisticsNumber());
                    sinfoList = complaintSignclosedInfoMapper.listSignclosed(info);
                }
            }else{
                info.setSignclosedLogisticsNumber(record.getSignclosedLogisticsNumber());
                sinfoList = complaintSignclosedInfoMapper.listSignclosed(info);
            }
            if(sinfoList.size() <= 0){
                num = complaintSignclosedInfoMapper.insert(record);
                msg = 1;//添加成功
                signclosedId = record.getSignclosedId();
            }else{
                //将签收记录改为已签收
                ComplaintSignclosedInfo complaintSignclosedInfo = sinfoList.get(0);
                if(complaintSignclosedInfo.getSignclosedIsReceiving() == 1){
                    complaintSignclosedInfo.setSignclosedIsReceiving(2);
                    complaintSignclosedInfo.setSignclosedDate(new Date());
                    complaintSignclosedInfoMapper.updateSignclosedById(complaintSignclosedInfo);
                    msg = 3;//已存在相同单号的签收信息并修改状态为已签收
                    signclosedId = complaintSignclosedInfo.getSignclosedId();
                }else{
                    msg = 4;//已存在相同单号的已签收信息
                }

            }
        }
        if(num > 0){
            if(orderItemString != null){
                JSONArray jsonArray = JSONArray.fromObject(orderItemString);
                List<SalesOrderItem> salesOrderItemList = (List) JSONArray.toCollection(jsonArray, SalesOrderItem.class);
                    for (SalesOrderItem salesOrderItem:salesOrderItemList) {
                        if(salesOrderItem.getItemNum() > 0 && salesOrderItem.getItemColorId() > 0){
                        int i = 0;
                        SignclosedProductInfo signclosedProductInfo = new SignclosedProductInfo();
                        //根据颜色id获取产品信息获取产品信息
                            ProductColor productColor = productMapper.getProduceColor(salesOrderItem.getItemColorId());
//                            Product product = productMapper.getProduce(productColor.getColorProductId());
                            if(productColor == null){
                                msg = 2;
                            }
                            signclosedProductInfo.setSignclosedId(record.getSignclosedId());
                            signclosedProductInfo.setProductName(productColor.getProductName());
                            signclosedProductInfo.setProductNum(salesOrderItem.getItemNum());
                            signclosedProductInfo.setSignclosedProductType(1);
                            signclosedProductInfo.setSignclosedProductId(productColor.getColorProductId());
                            signclosedProductInfo.setSignclosedProductColor(salesOrderItem.getItemColorId());
                            signclosedProductInfo.setSignclosedCreateTime(new Date());
                            signclosedProductInfo.setSignclosedState(2);
                            complaintSignclosedProductInfoMapper.insert(signclosedProductInfo);
                    }
                }
            }

            //添加签收图片
            if(componentsImgs != null) {
                if (componentsImgs.length > 0) {
                    for (String componentsImg : componentsImgs) {
                        ComplaintSignclosedImg complaintSignclosedImg = new ComplaintSignclosedImg();
                        complaintSignclosedImg.setImgUrl(componentsImg);
                        complaintSignclosedImg.setSignclosedId(record.getSignclosedId());
                        complaintSignclosedInfoMapper.insertImg(complaintSignclosedImg);
                    }
                }
            }
            //没有匹配上并且销售公司为‘优尼雅’，‘上朵’时不展示到待联系列表，并且生成维修信息，状态为‘待完善客户信息’
            if(sinfoList.size() <= 0){
                if(record.getSignclosedCompanyId() == 3 || record.getSignclosedCompanyId() == 4){
                    addDet(signclosedId,40);
                }
            }
            //关联客诉/判断是否关联客诉信息
            try {
                addDetect(record,2);
            }catch (Exception e){
                throw new RuntimeException("------------关联客诉出错------------");
            }
        }

        // 代签收 - >  已签收  需要入库到售后仓库
        if(msg==1 || msg == 3){
            List<SignclosedProductInfo> signclosedProductInfoList = complaintSignclosedProductInfoMapper.listSignclosedById(signclosedId);
            for (SignclosedProductInfo spi:signclosedProductInfoList) {
                //增加售后仓库的良品
                InventoryInfo inventoryInfo2 = new InventoryInfo();
                inventoryInfo2.setInventoryDefectiveProductNum(spi.getProductNum());
                inventoryInfo2.setInventoryProductBar(spi.getColorBar());
                inventoryInfo2.setWarehouseId(2);
                inventoryInfo2.setLogType(3);   //售后签收，都是次品
                inventoryInfo2.setInventoryRecentRecord("售后签收产品(签收ID:"+spi.getSignclosedId()+")");
                flag = inventoryService.addInventory(inventoryInfo2);
                if(flag < 1){
                    throw new RuntimeException("签收失败，更新库存失败。");
                }
            }
        }
        return msg;
    }

    /**
     * 关联客诉
     * @param record
     * type 1新增签收 2客服关联客诉
     * @return
     */
    public int addDetect(ComplaintSignclosedInfo record,Integer type){
            CustomerInfo customerInfo = new CustomerInfo();
            List<CustomerInfo> listCustomer = new ArrayList<>();
            if(record.getSignclosedCustomerId() != null){
                customerInfo.setCustomerId(record.getSignclosedCustomerId());
                listCustomer = customerInfoMapper.listCustomer(customerInfo);
            }else if(record.getSignclosedLogisticsNumber() != null){
                //判断是否是京东
                if (record.getSignclosedLogisticsNumber().contains("-")){
                        //截取-前的内容搜索一次
                    customerInfo.setSendLogisticsNo(StringUtils.substringBefore(record.getSignclosedLogisticsNumber(), "-"));
                    listCustomer = customerInfoMapper.listCustomer(customerInfo);
                    if(listCustomer.size() <= 0){//如果没有搜索到数据，则用完整单号搜索
                        customerInfo.setSendLogisticsNo(record.getSignclosedLogisticsNumber());
                        listCustomer = customerInfoMapper.listCustomer(customerInfo);
                    }
                }else{
                    customerInfo.setSendLogisticsNo(record.getSignclosedLogisticsNumber());
                    listCustomer = customerInfoMapper.listCustomer(customerInfo);
                }
            }
            ComplaintSignclosedInfo sigInfo = complaintSignclosedInfoMapper.getSignclosedById(record.getSignclosedId());
            boolean m = false;
            if(listCustomer.size() > 0){
                customerInfo = listCustomer.get(0);
                ComplaintSignclosedInfo signclosedInfo = new ComplaintSignclosedInfo();
                if(customerInfo.getSendbackInfoList().size()>0){
                    for (SendbackInfo info : customerInfo.getSendbackInfoList()){
                        if(info.getSendbackLogisticsNo() != null){
                            if(info.getSendbackLogisticsNo().equals(sigInfo.getSignclosedLogisticsNumber())){
                                m = true;
                                //修改该寄回信息为已签收
                                info.setSendbackStatus(3);
                                customerInfoMapper.updateSendbackInfo(info);
                                //同步寄回id到签收信息
                                record.setSendbackId(info.getSendbackId());
                                complaintSignclosedInfoMapper.updateSignclosedById(record);
                            }
                        }
                    }
                }
                SendbackInfo info = new SendbackInfo();
                if(!m || customerInfo.getSendbackInfoList().size() == 0){
                    info.setSendbackStatus(3);
                    info.setSendbackLogisticsCompany(sigInfo.getSignclosedLogistics());
                    info.setSendbackLogisticsNo(sigInfo.getSignclosedLogisticsNumber());
                    info.setSendbackName(sigInfo.getSignclosedSendName());
                    info.setSendbackTel(sigInfo.getSignclosedSendTel());
                    info.setRelationId(customerInfo.getRelationId());
                    info.setSendbackSignTime(sigInfo.getSignclosedDate());
                    List<SendbackItem> list = new ArrayList<>();
                    if(customerInfoMapper.addSendbackInfo(info) > 0){
                        //添加寄回产品项
                        for(SignclosedProductInfo productInfo : sigInfo.getSignclosedProductInfoList()){
                            SendbackItem sendbackItem = new SendbackItem();
                            sendbackItem.setSendbackId(info.getSendbackId());
                            sendbackItem.setSendbackColorId(productInfo.getSignclosedProductColor());
                            sendbackItem.setSendbackProductId(productInfo.getSignclosedProductId());
                            sendbackItem.setSendbackProdcueNumber(productInfo.getProductNum());
                            list.add(sendbackItem);
                        }
                        customerInfoMapper.addSendbackItemList(list);
                    }

                }
                //同步寄回id到签收信息
                signclosedInfo.setSendbackId(info.getSendbackId());
                signclosedInfo.setSignclosedCustomerId(customerInfo.getCustomerId());
                signclosedInfo.setSignclosedId(record.getSignclosedId());
                Integer msg = complaintSignclosedInfoMapper.updateSignclosedById(signclosedInfo);

            if(msg == 1){
                ComplaintSignclosedInfo infos = complaintSignclosedInfoMapper.getSignclosedById(record.getSignclosedId());
                //判断是否需要生成维修记录
                if(infos.getSignclosedProductInfoList().size() > 0) {
                    for (SignclosedProductInfo productInfo : infos.getSignclosedProductInfoList()) {
                        ProductColor productColor = productMapper.getProduceColor(productInfo.getSignclosedProductColor());
                        Product product = productMapper.getProduce(productColor.getColorProductId());
                        if(product.getProductIsDetection() != null){
                            if (product.getProductIsDetection() == 1) {
                                for (int j = 0; j < productInfo.getProductNum(); j++) {
                                    //添加待检测信息
                                    //查询签收信息
                                    ComplaintDetectInfo detectInfo = new ComplaintDetectInfo();
                                    //生成维修编号
                                    String number = detectNumber();
                                    detectInfo.setDetectNumber(number);
                                    detectInfo.setProductId(productColor.getColorProductId());
                                    detectInfo.setProductColorId(productInfo.getSignclosedProductColor());
                                    detectInfo.setDetectProductNumber(product.getProductNumber());
                                    detectInfo.setDetectState(1);
                                    detectInfo.setCustomerId(infos.getSignclosedCustomerId());
                                    detectInfo.setIsMaintenance(0);
                                    detectInfo.setDetectRenovation(0);
                                    detectInfo.setDetectProcessingResults(0);
                                    detectInfo.setSignclosedId(infos.getSignclosedId());
                                    detectInfo.setDetectSource(1);
                                    Calendar date = Calendar.getInstance();
                                    date.setTime(new Date());
                                    boolean fl = false;
                                    for (int i = 1 ; i <= 3; 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) + 4);
                                    }else{
                                        date.set(Calendar.DATE, date.get(Calendar.DATE) + 3);
                                    }
                                    detectInfo.setMaintenanceCutTime(date.getTime());
                                    try {
                                        complaintDetectInfoMapper.insert(detectInfo);
                                        if(type == 1){//客服关联客诉才发送通知短信
                                            //发送短信通知维修检测人员
                                            String text = MessageFormat.format(SmsConfig.CUSTOMER_CONTACT, sigInfo.getSignclosedLogisticsNumber(),number);
                                            String result = smsService.sendOtherCMS(SmsConfig.CUSTOMER_PHONE, text);
                                            logger.info("给 " + SmsConfig.CUSTOMER_PHONE + " 手机用户发送短信：" + text+"发送关联客诉通知维修人员："+result);
                                        }

                                    } catch (Exception e) {
                                        throw new RuntimeException("------------生成检测信息出错------------");
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        return 1;
    }
    /**
     * 根据签收id生成维修信息
     * @param signclosedId 签收id detectState 状态
     * @return
     */
    public void addDet(Integer signclosedId,Integer detectState){
        ComplaintSignclosedInfo sigInfo = complaintSignclosedInfoMapper.getSignclosedById(signclosedId);
        //判断是否需要生成维修记录
        if(sigInfo.getSignclosedProductInfoList().size() > 0) {
            for (SignclosedProductInfo productInfo : sigInfo.getSignclosedProductInfoList()) {
                ProductColor productColor = productMapper.getProduceColor(productInfo.getSignclosedProductColor());
                Product product = productMapper.getProduce(productColor.getColorProductId());
                if(product.getProductIsDetection() != null){
                    if (product.getProductIsDetection() == 1) {
                        for (int j = 0; j < productInfo.getProductNum(); j++) {
                            //添加待检测信息
                            //查询签收信息
                            ComplaintDetectInfo detectInfo = new ComplaintDetectInfo();
                            //生成维修编号
                            String number = detectNumber();
                            detectInfo.setDetectNumber(number);
                            detectInfo.setProductId(productColor.getColorProductId());
                            detectInfo.setProductColorId(productInfo.getSignclosedProductColor());
                            detectInfo.setDetectProductNumber(product.getProductNumber());
                            detectInfo.setDetectState(detectState);
                            detectInfo.setCustomerId(sigInfo.getSignclosedCustomerId());
                            detectInfo.setIsMaintenance(0);
                            detectInfo.setDetectRenovation(0);
                            detectInfo.setDetectProcessingResults(0);
                            detectInfo.setSignclosedId(sigInfo.getSignclosedId());
                            if(detectState != 40){
                                detectInfo.setDetectSource(1);
                                Calendar date = Calendar.getInstance();
                                date.setTime(new Date());
                                boolean fl = false;
                                for (int i = 1 ; i <= 3; 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) + 4);
                                }else{
                                    date.set(Calendar.DATE, date.get(Calendar.DATE) + 3);
                                }

                                detectInfo.setMaintenanceCutTime(date.getTime());
                            }else{
                                detectInfo.setDetectSource(2);
                            }
                            try {
                                complaintDetectInfoMapper.insert(detectInfo);
                            } catch (Exception e) {
                                throw new RuntimeException("------------生成检测信息出错------------");
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * 生成维修编号
     * @return
     */
    public String detectNumber(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMM");
        String year = sdf.format(new Date());
        String detectNum = RedisUtils.get("detect_"+year);
        Integer detectNumber;
        if(detectNum == null){
            //查询当前月份所有维修机器
            Integer num = complaintDetectInfoMapper.getDetectNum();
            RedisUtils.put("detect_"+year,num);/*
            RedisUtils.expire(SC_DETECT+year,new Date(System.currentTimeMillis() + 2678400000L));*/
            detectNumber = num;
        }else{
            detectNumber =Integer.parseInt(detectNum)+ 1;
            RedisUtils.put("detect_"+year,detectNumber);
        }
        switch (detectNumber.toString().length()){
            case 1:
                detectNum = "000"+detectNumber;
                break;
            case 2:
                detectNum = "00"+detectNumber;
                break;
            case 3:
                detectNum = "0"+detectNumber;
                break;
            case 4:
                detectNum = detectNumber.toString();
                break;
        }
        return year+detectNum;
    }
    @Override
    public List<SignclosedProductInfo> listSignclosedById(Integer signclosedId) {
        return complaintSignclosedInfoMapper.listSignclosedById(signclosedId);
    }

    @Override
    public Integer insertImg(ComplaintSignclosedImg complaintSignclosedImg) {
        return complaintSignclosedInfoMapper.insertImg(complaintSignclosedImg);
    }

    @Override
    public List<ComplaintSignclosedImg> listSignclosedImgById(Integer signclosedId) {
        return complaintSignclosedInfoMapper.listSignclosedImgById(signclosedId);
    }

    @Override
    public Integer delSignclosedImg(Integer signclosedId) {
        return complaintSignclosedInfoMapper.delSignclosedImg(signclosedId);
    }

    @Override
    public Integer delSignclosedBySendbackId(Integer sendbackId) {
        return complaintSignclosedInfoMapper.delSignclosedBySendbackId(sendbackId);
    }

    @Override
    public Integer getSignclosedDay(ComplaintSignclosedInfo complaintSignclosedInfo) {
        return complaintSignclosedInfoMapper.getSignclosedDay(complaintSignclosedInfo);
    }

    @Override
    @Transactional
    public Integer updateSignclosedByYny(ComplaintSignclosedInfo record) {
        int num = complaintSignclosedInfoMapper.updateSignclosedById(record);
        if(num > 0){
            try {
                ComplaintSignclosedInfo signclosedInfo = complaintSignclosedInfoMapper.getSignclosedById(record.getSignclosedId());
                //新增维修记录
                if(signclosedInfo != null && signclosedInfo.getSignclosedProductInfoList().size() > 0){
                    for (SignclosedProductInfo productInfo : signclosedInfo.getSignclosedProductInfoList()){
                        Product product = productMapper.getProduce(productInfo.getSignclosedProductId());
                        if (product.getProductIsDetection() == 1) {
                            ComplaintDetectInfo  info = new ComplaintDetectInfo();
                            //生成维修编号
                            String number = detectNumber();
                            info.setDetectNumber(number);
                            info.setDetectState(40);
                            info.setDetectSource(2);
                            info.setProductId(productInfo.getSignclosedProductId());
                            info.setProductColorId(productInfo.getSignclosedProductColor());
                            info.setSignclosedId(record.getSignclosedId());
                            complaintDetectInfoMapper.insert(info);
                        }
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
                throw new RuntimeException("------------改为优尼雅客户生成检测信息出错------------");
            }

        }else{
            return num;
        }
        return 1;
    }

    private Integer addSifnclosed(Map<String,Integer> Map,Integer signclosedId) {
        Integer msg = 0;
        for (Map.Entry<String, Integer> entry : Map.entrySet()) {
            AwaitingSignclosedProductInfo awaitingSignclosedInfo = new AwaitingSignclosedProductInfo();
            //根据颜色id获取产品信息获取产品信息
            Product product = productMapper.getProductById(Integer.valueOf(entry.getKey()));
            if (product == null) {
                return 0;
            }
            awaitingSignclosedInfo.setSignclosedId(signclosedId);
            awaitingSignclosedInfo.setProductName(product.getProductName());
            awaitingSignclosedInfo.setProductNum(entry.getValue());
            awaitingSignclosedInfo.setSignclosedProductType(1);
            awaitingSignclosedInfo.setSignclosedProductId(product.getProductId());
            awaitingSignclosedInfo.setSignclosedProductColor(Integer.valueOf(entry.getKey()));
            awaitingSignclosedInfo.setSignclosedCreateTime(new Date());
            msg = awaitingSignclosedProductMapper.insert(awaitingSignclosedInfo);

        }
        return msg;
    }

    @Override
    public ComplaintSignclosedInfo getSignclosedById(Integer signclosedId) {
        return complaintSignclosedInfoMapper.getSignclosedById(signclosedId);
    }
    @Transactional
    @Override
    public boolean updateSignclosedById(ComplaintSignclosedInfo record,
                                    Map<String,Integer> alreadyColorMap,
                                    Map<String,String[]> machineNumberMap,
                                    Map<String,Integer> alreadyFittingsMap) {
        boolean msg = true;
        int num = complaintSignclosedInfoMapper.updateSignclosedById(record);
        if(num < 1){
            msg = false;
        }else{
            if(alreadyColorMap != null || alreadyColorMap.size() != 0){
                for (Map.Entry<String,Integer> entry : alreadyColorMap.entrySet()) {
                    int i = 0;
                    SignclosedProductInfo signclosedProductInfo = new SignclosedProductInfo();
                    //根据颜色id获取产品信息获取产品信息
                    Product product = productMapper.getProductById(Integer.valueOf(entry.getKey()));
                    if(product == null){
                        return false;
                    }
                    for (int j = 0;j<entry.getValue();j++){
                        signclosedProductInfo.setSignclosedId(record.getSignclosedId());
                        signclosedProductInfo.setProductName(product.getProductName());
                        signclosedProductInfo.setProductNum(1);
                        signclosedProductInfo.setSignclosedProductType(1);
                        signclosedProductInfo.setSignclosedProductId(product.getProductId());
                        signclosedProductInfo.setSignclosedProductColor(Integer.valueOf(entry.getKey()));
                        signclosedProductInfo.setSignclosedCreateTime(new Date());
                        complaintSignclosedProductInfoMapper.insert(signclosedProductInfo);
                        i++;
                    }

                }
            }
        }
        return msg;
    }
    @Transactional
    @Override
    public boolean updateSignclosedById(ComplaintSignclosedInfo record, String orderItemString, String[] componentsImgs) {
        boolean msg = true;
        int num = complaintSignclosedInfoMapper.updateSignclosedById(record);
        if(num < 1){
            msg = false;
        }else{
            //删除待收货产品
            complaintSignclosedProductInfoMapper.delSignclosedProduct(record.getSignclosedId());
            //删除签收图片
            complaintSignclosedInfoMapper.delSignclosedImg(record.getSignclosedId());
            if(orderItemString != null){
                JSONArray jsonArray = JSONArray.fromObject(orderItemString);
                List<SalesOrderItem> salesOrderItemList = (List) JSONArray.toCollection(jsonArray, SalesOrderItem.class);
                for (SalesOrderItem salesOrderItem:salesOrderItemList) {
                    if(salesOrderItem.getItemNum() > 0 && salesOrderItem.getItemColorId() > 0){
                        int i = 0;
                        SignclosedProductInfo signclosedProductInfo = new SignclosedProductInfo();
                        //根据颜色id获取产品信息获取产品信息
                        ProductColor productColor = productMapper.getProduceColor(salesOrderItem.getItemColorId());
                        Product product = productMapper.getProduce(productColor.getColorProductId());
                        if(productColor == null){
                            msg = false;
                        }
                        signclosedProductInfo.setSignclosedId(record.getSignclosedId());
                        signclosedProductInfo.setProductName(productColor.getProductName());
                        signclosedProductInfo.setProductNum(1);
                        signclosedProductInfo.setSignclosedProductType(1);
                        signclosedProductInfo.setSignclosedProductId(productColor.getColorProductId());
                        signclosedProductInfo.setSignclosedProductColor(salesOrderItem.getItemColorId());
                        signclosedProductInfo.setSignclosedCreateTime(new Date());
                        signclosedProductInfo.setSignclosedState(2);
                        try {
                            complaintSignclosedProductInfoMapper.insert(signclosedProductInfo);
                        }catch (Exception e){
                            throw new RuntimeException("------------生成签收产品出错------------");
                        }
                        /*for (int j = 0;j<salesOrderItem.getItemNum();j++){

                            //判断是否需要生成维修记录
                            if(product.getProductIsDetection() == 1){
                                //添加待检测信息
                                //查询签收信息

                                ComplaintSignclosedInfo signclosedInfo = complaintSignclosedInfoMapper.getSignclosedById(record.getSignclosedId());
                                ComplaintDetectInfo detectInfo = new ComplaintDetectInfo();
                                detectInfo.setProductId(productColor.getColorProductId());
                                detectInfo.setProductColorId(salesOrderItem.getItemColorId());
                                detectInfo.setDetectProductNumber(product.getProductNumber());
                                detectInfo.setDetectState(1);
                                detectInfo.setCustomerId(signclosedInfo.getSignclosedCustomerId());
                                detectInfo.setIsMaintenance(0);
                                detectInfo.setDetectRenovation(0);
                                detectInfo.setDetectProcessingResults(0);
                                try {
                                    complaintDetectInfoMapper.insert(detectInfo);
                                }catch (Exception e){
                                    throw new RuntimeException("------------生成检测信息出错------------");
                                }
                            }
                            j++;
                        }*/
                    }
                }
            }
            //添加签收图片
            if(componentsImgs != null){
                if(componentsImgs.length > 0){
                    for(String componentsImg : componentsImgs){
                        ComplaintSignclosedImg complaintSignclosedImg = new ComplaintSignclosedImg();
                        complaintSignclosedImg.setImgUrl(componentsImg);
                        complaintSignclosedImg.setSignclosedId(record.getSignclosedId());
                        complaintSignclosedInfoMapper.insertImg(complaintSignclosedImg);
                    }
                }
            }

            //同步客诉寄回状态和物流信息
            ComplaintSignclosedInfo signclosedInfo = complaintSignclosedInfoMapper.getSignclosedById(record.getSignclosedId());
            SendbackInfo sendbackInfo = new SendbackInfo();
            sendbackInfo.setSendbackId(signclosedInfo.getSendbackId());
            sendbackInfo.setSendbackStatus(3);
            sendbackInfo.setSendbackLogisticsCompany(signclosedInfo.getSignclosedLogistics());
            sendbackInfo.setSendbackLogisticsNo(signclosedInfo.getSignclosedLogisticsNumber());
            sendbackInfo.setSendbackSignTime(signclosedInfo.getSignclosedDate());
            customerInfoMapper.updateSendbackInfo(sendbackInfo);

            Integer flag = 0;
            // 代签收 - >  已签收  需要入库到售后仓库
            List<SignclosedProductInfo> signclosedProductInfoList = complaintSignclosedProductInfoMapper.listSignclosedById(record.getSignclosedId());
            for (SignclosedProductInfo spi:signclosedProductInfoList) {
                //增加售后仓库的良品
                InventoryInfo inventoryInfo2 = new InventoryInfo();
                inventoryInfo2.setInventoryDefectiveProductNum(spi.getProductNum());
                inventoryInfo2.setInventoryProductBar(spi.getColorBar());
                inventoryInfo2.setWarehouseId(2);
                inventoryInfo2.setLogType(3);   //售后签收，都是次品
                inventoryInfo2.setInventoryRecentRecord("售后签收产品(签收ID:"+spi.getSignclosedId()+")");
                flag = inventoryService.addInventory(inventoryInfo2);
                if(flag < 1){
                    throw new RuntimeException("签收失败，更新库存失败。");
                }
            }

            // 代签收 - >  已签收  需要入库到售后仓库
//            Integer flag = 0;
//            SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//            List<SignclosedProductInfo> signclosedProductInfoList = complaintSignclosedProductInfoMapper.listSignclosedById(record.getSignclosedId());
//            for (SignclosedProductInfo spi:signclosedProductInfoList) {
//                InventoryInfo info = inventoryMapper.getByInventoryByBar(spi.getColorBar(),2);
//                info.setInventoryDefectiveProductNum(info.getInventoryDefectiveProductNum()+spi.getProductNum());
//                info.setInventoryRecentRecord(sdf.format(new Date())+"不良品入库："+ spi.getProductNum() + "件");
//                flag =  inventoryMapper.updateById(info);
//                if(flag < 1){
//                    throw new RuntimeException("更新库存失败，更新库存失败。");
//                }
//                //添加日志
//                InventoryLog inventoryLog = new InventoryLog();
//                inventoryLog.setLogProductName(info.getInventoryProductName());
//                inventoryLog.setLogProductBar(info.getInventoryProductBar());
//                inventoryLog.setLogRemainingNum(spi.getProductNum());
//                inventoryLog.setLogType(3);
//                inventoryLog.setLogOperationType(1);
//                inventoryLog.setLogDesc(sdf.format(new Date())+"不良品入库："+spi.getProductNum()+"件");
//                inventoryLog.setLogQualityType(2);
//                inventoryLog.setLogWarehouseId(2);    //售后仓库
//                flag = inventoryLogMapper.insert(inventoryLog);
//                if(flag < 1){
//                    throw new RuntimeException("更新库存失败，增加库存记录失败。");
//                }
//            }
        }
        //关联客诉/判断是否生成客诉信息
        try {
            addDet(record.getSignclosedId(),1);
        }catch (Exception e){
            throw new RuntimeException("------------关联客诉出错------------");
        }

        return msg;
    }

    @Override
    public Integer updateSignclosedById(ComplaintSignclosedInfo record) {
        return complaintSignclosedInfoMapper.updateSignclosedById(record);
    }

    @Override
    public Integer updateSignclosedByCustomerId(ComplaintSignclosedInfo record) {
        return complaintSignclosedInfoMapper.updateSignclosedByCustomerId(record);
    }

    @Override
    public PagedResult<ComplaintSignclosedInfo> listSignclosed(PageRequest<ComplaintSignclosedInfo> pageRequest) {
        PageHelper.startPage(pageRequest.getPageNO(), pageRequest.getPageSize(), pageRequest.isPageTotal());
        List<ComplaintSignclosedInfo> signclosedList = complaintSignclosedInfoMapper.listSignclosed(pageRequest.getData());
        return PageUtil.getPage(signclosedList);

    }

    @Override
    public List<ComplaintSignclosedInfo> listSignclosed(ComplaintSignclosedInfo complaintSignclosedInfo) {
        return complaintSignclosedInfoMapper.listSignclosed(complaintSignclosedInfo);
    }

}