iamberry-common-parent/watero-rst-service/src/main/java/com/iamberry/rst/service/cm/CustomerServiceImpl.java

package com.iamberry.rst.service.cm;

import com.github.pagehelper.PageHelper;
import com.iamberry.rst.core.cm.*;
import com.iamberry.rst.core.order.*;
import com.iamberry.rst.core.page.PagedResult;
import com.iamberry.rst.faces.cm.CustomerCommonService;
import com.iamberry.rst.faces.cm.CustomerService;
import com.iamberry.rst.faces.cm.RelationOrderService;
import com.iamberry.rst.faces.order.EfastOrderService;
import com.iamberry.rst.service.address.mapper.AddressMapper;
import com.iamberry.rst.service.cm.mapper.*;
import com.iamberry.rst.service.product.mapper.ProductMapper;
import com.iamberry.rst.util.CustomerCommonUtil;
import com.iamberry.rst.util.PageUtil;
import net.sf.json.JSONObject;
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.util.*;

@Service
public class CustomerServiceImpl implements CustomerService {

    private static Logger logger = LoggerFactory.getLogger(CustomerServiceImpl.class);

    @Autowired
    private CustomerInfoMapper customerInfoMapper;
    @Autowired
    private RepairMapper repairMapper;
    @Autowired
    private BackGoodsMapper backGoodsMapper;
    @Autowired
    private NoreasonBackMapper noreasonBackMapper;
    @Autowired
    private ReissueMapper reissueMapper;
    @Autowired
    private RenewedMapper renewedMapper;
    @Autowired
    private ClosedFittingMapper closedFittingMapper;
    @Autowired
    private ClosedProdcueMapper closedProdcueMapper;
    @Autowired
    private SendProdcueMapper sendProdcueMapper;
    @Autowired
    private SendFittingMapper sendFittingMapper;
    @Autowired
    private SalesOrderMapper salesOrderMapper;
    @Autowired
    private CustomerService customerService;
    @Autowired
    private VisitMapper visitMapper; //回访
    @Autowired
    private ComplaintSignclosedInfoMapper complaintSignclosedInfoMapper;  //仓储
    @Autowired
    private ComplaintDetectInfoMapper complaintDetectInfoMapper;    //品检
    @Autowired
    private QuestionDescribeMapper questionDescribeMapper;   //客诉问题
    @Autowired
    private AddressMapper addressMapper;      //地址
    @Autowired
    private ProductMapper productMapper;  //产品
    @Autowired
    private ComplaintSignclosedProductInfoMapper complaintSignclosedProductInfoMapper;
    @Autowired
    private FittingsInfoMapper fittingsInfoMapper;
    @Autowired
    private EfastOrderService efastOrderService;
    @Autowired
    private StoreInfoMapper storeInfoMapper;
    @Autowired
    private CustomerCommonService customerCommonService;
    @Autowired
    private RelationOrderService relationOrderService;

    @Override
    public CustomerInfo getCustomerInfo(Integer customerId) {
        return customerInfoMapper.getCustomerInfo(customerId);
    }

    @Override
    @Transactional
    public Integer saveCustomerInfo(CustomerInfo customerInfo,SalesOrder salesOrder){
        Integer isNeedSelectOrder = customerInfo.getIsNeedSelectOrder();

        List<SalesOrder> orderList = new ArrayList<>();

        //添加客诉基本信息
        Integer flag = 0;
        flag = customerInfoMapper.insert(customerInfo);
        if(flag < 1){
            throw new RuntimeException("添加客诉失败");
        }
        logger.info("-----------添加客诉-添加客诉基本信息---------------");

        QuestionDescribe questionDescribe = new QuestionDescribe();
        questionDescribe.setCustomerId(customerInfo.getCustomerId());
        questionDescribe.setDescribeTitle(customerInfo.getDescribeTitle());  //客诉问题标题
        questionDescribe.setDescribeContent(customerInfo.getDescribeContent());  //客诉问题描述
        questionDescribe.setDescribeHandleDesc(customerInfo.getDescribeHandleDesc());   //处理描述
        flag = questionDescribeMapper.insert(questionDescribe);
        if(flag < 1){
            throw new RuntimeException("添加客诉问题失败");
        }
        logger.info("-----------添加客诉-添加客诉问题---------------");

        if ("2".equals(customerInfo.getCustomerIsVisit())) {
            Visit visit = new Visit();
            visit.setCustomerId(customerInfo.getCustomerId());
            visit.setAdminId(customerInfo.getAdminId());
            visit.setDesignatedAdminId(customerInfo.getVisitAdminId());
            visit.setVisitName(customerInfo.getVisitName());
            visit.setVisitTel(customerInfo.getVisitTel());
            visit.setVisitDate(customerInfo.getVisitDate());
            visit.setVisitTimeSelect(customerInfo.getVisitTimeSelect());
            visit.setVisitStatus(1);    //回访状态
            flag = visitMapper.addVisitInfo(visit);
            if(flag < 1){
                throw new RuntimeException("添加客诉回访信息失败");
            }
            logger.info("-----------添加客诉-添加客诉回访信息---------------");
        }

        if (2 == customerInfo.getCustomerCounselType() &&
                (customerInfo.getCustomerIsSolve() == 3 || customerInfo.getCustomerIsSolve() == 4 || customerInfo.getCustomerIsSolve() == 5 ||
                customerInfo.getCustomerIsSolve() == 6 || customerInfo.getCustomerIsSolve() == 7)
                ){

            if(isNeedSelectOrder == 1){
                SalesOrder so = new SalesOrder();
                if(salesOrder.getIds()!= null && salesOrder.getIds().indexOf("_") > -1){
                    String[] salesIds = salesOrder.getIds().split("_");
                    so.setSalesIds(salesIds);
                    orderList = salesOrderMapper.listSalesOrder(so);
                    logger.info("-----------添加客诉-查询订单--------------");
                    if(orderList == null || orderList.size() < 1){
                        logger.info("-----------添加客诉-订单为空-请重新添加订单 --------------");
                        throw new RuntimeException("添加客诉-订单为空-请重新添加订单");
                    }
                }
            }

            CustomerCommon customerCommon = customerInfo.getCustomerCommon();
            customerCommon.setCustomerId(customerInfo.getCustomerId()); //设置客诉id
            customerCommon.setRelationBackStatus(1); //寄回状态 1：未寄回
            customerCommon.setRelationSendStatus(1); //寄送状态 1：未寄送
            customerCommon.setRelationState(1); //状态  默认使用中
            customerCommon.setTransactionNumber(customerInfo.getTransactionNumber());   //外部交易号

            // TODO: 2018/3/27 是否转账邮费，默认为不需要转账 ： 0
            customerCommon.setRelationIsTransfer(0);    //是否已转账邮费
            customerCommon.setRelationBackPostage(0);   //邮费默认为0

            customerCommon.setRelationBackName(customerCommon.getRelationSendName()); //姓名
            customerCommon.setRelationBackTel(customerCommon.getRelationSendTel()); //电话号码

            /*  初始化产品类型，名称，配件名称 */
            customerService.setName(customerCommon);
            logger.info("-----------添加客诉-初始化产品，配件信息--------------");

            ComplaintDetectInfo complaintDetectInfo = new ComplaintDetectInfo();  //品质检测
            ComplaintSignclosedInfo complaintSignclosedInfo = new ComplaintSignclosedInfo(); //客诉-签收表
            Map<String,Object> map;
            boolean isReturn = false;
            switch (customerInfo.getCustomerIsSolve()) {  //处理结果： 1：已解决  2：未解决 3：换新  4：维修 5：补发 6：退货 7：无理由退货
                case 3: //换新
//                    customerService.chargebackEfastOrder(customerCommon,salesOrder,2);    //原订单生成退单
//                    map = customerService.sendEfastOrder(customerCommon,salesOrder);  //换新需要向Efast推送一条换新发货的订单
//                    if(map.get("status") == 1){
//                        customerCommon.setRelationBackEfastOrderId(String.valueOf(map.get("EfastOrderId")));  //存放Efast订单编号
//                        complaintSignclosedInfo.setNewEfastId(String.valueOf(map.get("EfastOrderId")));     //仓储签收表添加  发货的Efast订单id
//                    }else{
//                        throw new RuntimeException("换新创建Efast订单失败");
//                    }
                    //complaintSignclosedInfo.setOldEfastId(salesOrder.getSalesOrderId());    //原有订单的Efast的订单编号
                    //customerService.saveComplaintSignclosedInfo(complaintSignclosedInfo,customerCommon);//创建仓储任务
                    //complaintDetectInfo.setSignclosedId(complaintSignclosedInfo.getSignclosedId()); //设置仓储签收id
                    //customerService.saveComplaintDetectInfo(complaintDetectInfo,customerCommon);   //创建品检
                    break;
                case 4: //维修
//                    customerService.chargebackEfastOrder(customerCommon,salesOrder,2);    //原订单生成退单
//                    map = customerService.sendEfastOrder(customerCommon,salesOrder);  //维修需要向Efast推送一条维修发货的订单
//                    if(map.get("status") == 1){
//                        customerCommon.setRelationBackEfastOrderId(String.valueOf(map.get("EfastOrderId")));  //存放Efast订单编号
//                        complaintSignclosedInfo.setNewEfastId(String.valueOf(map.get("EfastOrderId")));     //仓储签收表添加  发货的Efast订单id
//                    }else{
//                        throw new RuntimeException("维修创建Efast订单失败");
//                    }
                    //complaintSignclosedInfo.setOldEfastId(salesOrder.getSalesOrderId());    //原有订单的Efast的订单编号
                    //customerService.saveComplaintSignclosedInfo(complaintSignclosedInfo,customerCommon);//创建仓储任务
                    //complaintDetectInfo.setSignclosedId(complaintSignclosedInfo.getSignclosedId()); //设置仓储签收id
                    //customerService.saveComplaintDetectInfo(complaintDetectInfo,customerCommon);   //创建品检
                    break;
                case 5: //补发  不用创建仓储签收任务
//                    map = customerService.sendEfastOrder(customerCommon,salesOrder);  //补发需要向Efast推送一条发货的订单
//                    if(map.get("status") == 1){
//                        customerCommon.setRelationBackEfastOrderId(String.valueOf(map.get("EfastOrderId")));  //存放Efast订单编号
//                        complaintSignclosedInfo.setNewEfastId(String.valueOf(map.get("EfastOrderId")));     //仓储签收表添加  发货的Efast订单id
//                    }else{
//                        throw new RuntimeException("补发创建Efast订单失败");
//                    }
                    break;
                case 6: //退货

//                   customerService.chargebackEfastOrder(customerCommon,salesOrder,3);    //原订单生成退单

                    //complaintSignclosedInfo.setOldEfastId(salesOrder.getSalesOrderId());    //原有订单的Efast的订单编号
                    //customerService.saveComplaintSignclosedInfo(complaintSignclosedInfo,customerCommon);//创建仓储任务
                    //complaintDetectInfo.setSignclosedId(complaintSignclosedInfo.getSignclosedId()); //设置仓储签收id
                    //customerService.saveComplaintDetectInfo(complaintDetectInfo,customerCommon);   //创建品检
                    break;
                case 7: //无理由退货

//                   customerService.chargebackEfastOrder(customerCommon,salesOrder,3);    //原订单生成退单

                    //complaintSignclosedInfo.setOldEfastId(salesOrder.getSalesOrderId());    //原有订单的Efast的订单编号
                    //customerService.saveComplaintSignclosedInfo(complaintSignclosedInfo,customerCommon);//创建仓储任务
                    //complaintDetectInfo.setSignclosedId(complaintSignclosedInfo.getSignclosedId()); //设置仓储签收id
                    //customerService.saveComplaintDetectInfo(complaintDetectInfo,customerCommon);   //创建品检
                    break;
            }
            logger.info("-----------添加客诉-创建仓储/品检成功--------------");
            customerCommon.setSignclosedId(complaintSignclosedInfo.getSignclosedId()); //设置仓储id


            /*将公共的对象 转换换新/维修/退款等*/
            Object object = CustomerCommonUtil.getRelation(customerInfo.getCustomerIsSolve(), customerCommon);

            Integer relationId = 0;
            Integer orderStatus = 1;
            switch (customerInfo.getCustomerIsSolve()) {  //处理结果： 1：已解决  2：未解决 3：换新  4：维修 5：补发 6：退货 7：无理由退货
                case 3: //换新
                    Renewed renewed = (Renewed) object;
                    flag = renewedMapper.insert(renewed);
                    relationId = renewed.getRenewedId();
                    orderStatus = 2;
                    break;
                case 4: //维修
                    Repair repair = (Repair) object;
                    flag = repairMapper.insert(repair);
                    relationId = repair.getRepairId();
                    orderStatus = 4;
                    break;
                case 5: //补发
                    Reissue reissue = (Reissue) object;
                    flag = reissueMapper.insert(reissue);
                    relationId = reissue.getReissueId();
                    orderStatus = 5;
                    break;
                case 6: //退货
                    BackGoods backGoods = (BackGoods) object;
                    flag = backGoodsMapper.insert(backGoods);
                    relationId = backGoods.getBackGoodsId();
                    orderStatus = 3;
                    break;
                case 7: //无理由退货
                    NoreasonBack noreasonBack = (NoreasonBack) object;
                    flag = noreasonBackMapper.insert(noreasonBack);
                    relationId = noreasonBack.getNoreasonBackId();
                    orderStatus = 3;
                    break;
            }
            if (flag < 1) {
                throw new RuntimeException("添加客诉处理结果失败");
            }
            logger.info("-----------添加客诉-添加换新/维修/补发/退货/无理由退货信息成功--------------");

            /*添加客诉-添加处理与订单关联表*/
            List<RelationOrder> relationOrderList = new ArrayList<>();
            for (SalesOrder sor : orderList) {
                RelationOrder ro = new RelationOrder();
                ro.setRelationType(customerInfo.getCustomerIsSolve());
                ro.setRelationId(relationId);
                ro.setSalesId(sor.getSalesId());
                ro.setRelationCustomerId(customerInfo.getCustomerId());
                relationOrderList.add(ro);
            }
            if(relationOrderList != null && relationOrderList.size() > 0){
                flag = relationOrderService.saveList(relationOrderList);
                if(flag < 1){
                    throw new RuntimeException("添加客诉，关联订单失败");
                }
            }

            for (SalesOrder sor : orderList) {
                SalesOrder newOrder = new SalesOrder(); //salesOrderStatus
                newOrder.setSalesId(sor.getSalesId());
                newOrder.setSalesOrderStatus(orderStatus);
                flag = salesOrderMapper.updateSalesOrder(newOrder);
                if(flag < 1){
                    throw new RuntimeException("添加客诉，修改订单失败");
                }
            }
            logger.info("-----------添加客诉-添加处理与订单关联表--------------");

            customerCommon.setRelationId(relationId);
            CustomerCommonUtil.setProduceOrFitting(customerInfo.getCustomerIsSolve(),customerCommon);

            if(customerCommon.getClosedFittings()!=null && customerCommon.getClosedFittings().size() > 0){
                closedFittingMapper.insert(customerCommon.getClosedFittings());
            }
            if(customerCommon.getClosedProdcues() != null && customerCommon.getClosedProdcues().size()>0){
                closedProdcueMapper.insert(customerCommon.getClosedProdcues());
            }
            if(customerCommon.getSendProdcues() != null && customerCommon.getSendProdcues().size() > 0){
                sendProdcueMapper.insert(customerCommon.getSendProdcues());
            }
            if(customerCommon.getSendFittings() != null && customerCommon.getSendFittings().size() > 0){
                sendFittingMapper.insert(customerCommon.getSendFittings());
            }
            logger.info("-----------添加客诉-寄回寄出产品配件成功--------------");
        }
        return flag;
    }


    @Override
    @Transactional
    public Integer updateCustomerInfo(CustomerInfo customerInfo,SalesOrder salesOrder){
        Integer isNeedSelectOrder = customerInfo.getIsNeedSelectOrder();
        //查询旧的客诉类型信息
        CustomerCommon cc = customerInfo.getCustomerCommon();
        cc.setCustomerId(customerInfo.getCustomerId());
        List<CustomerCommon> ccList = customerCommonService.listCustomerCommon(cc);
        /*if(ccList.size() > 0){
            cc = ccList.get(0);
        }*/
        //删除旧的售后数据
        customerService.deleteCustomerAfterSales(customerInfo);

        List<SalesOrder> orderList = new ArrayList<>();

        //修改客诉基本信息
        Integer flag = 0;
        flag = customerInfoMapper.updateCustomerInfo(customerInfo);
        if(flag < 1){
            throw new RuntimeException("修改客诉失败");
        }
        logger.info("-----------修改客诉-修改客诉基本信息---------------");

        QuestionDescribe questionDescribe = new QuestionDescribe();
//        questionDescribe.setCustomerId(customerInfo.getCustomerId());
        questionDescribe.setDescribeId(customerInfo.getDescribeId());//客诉问题主键
        questionDescribe.setDescribeTitle(customerInfo.getDescribeTitle());  //客诉问题标题
        questionDescribe.setDescribeContent(customerInfo.getDescribeContent());  //客诉问题描述
        questionDescribe.setDescribeHandleDesc(customerInfo.getDescribeHandleDesc());   //处理描述
        questionDescribeMapper.updateByPrimaryKeySelective(questionDescribe);
        logger.info("-----------修改客诉-修改客诉问题---------------");
        if ("2".equals(customerInfo.getCustomerIsVisit())) {
            Visit visit = new Visit();
            visit.setCustomerId(customerInfo.getCustomerId());
            visit.setAdminId(customerInfo.getAdminId());
            visit.setDesignatedAdminId(customerInfo.getVisitAdminId());
            visit.setVisitName(customerInfo.getVisitName());
            visit.setVisitTel(customerInfo.getVisitTel());
            visit.setVisitDate(customerInfo.getVisitDate());
            visit.setVisitTimeSelect(customerInfo.getVisitTimeSelect());
            visit.setVisitStatus(1);    //回访状态
            flag = visitMapper.addVisitInfo(visit);
            if(flag < 1){
                throw new RuntimeException("修改客诉回访失败");
            }
            logger.info("-----------修改客诉-修改客诉回访信息---------------");
        }
        if (2 == customerInfo.getCustomerCounselType() &&
                (customerInfo.getCustomerIsSolve() == 3 || customerInfo.getCustomerIsSolve() == 4 || customerInfo.getCustomerIsSolve() == 5 ||
                        customerInfo.getCustomerIsSolve() == 6 || customerInfo.getCustomerIsSolve() == 7)
                ){

            if(isNeedSelectOrder == 1){
                SalesOrder so = new SalesOrder();
                if(salesOrder.getIds()!= null && salesOrder.getIds().indexOf("_") > -1){
                    String[] salesIds = salesOrder.getIds().split("_");
                    so.setSalesIds(salesIds);
                    orderList = salesOrderMapper.listSalesOrder(so);
                    logger.info("-----------修改客诉-查询订单--------------");
                }
            }

            CustomerCommon customerCommon = customerInfo.getCustomerCommon();
            if(ccList.size() > 0){
                cc = ccList.get(0);
                customerCommon.setRelationBackStatus(cc.getRelationBackStatus() == null ? 1:cc.getRelationBackStatus()); //寄回状态 1：未寄回
                customerCommon.setRelationSendStatus(cc.getRelationSendStatus() == null ? 1:cc.getRelationSendStatus()); //寄送状态 1：未寄送
                customerCommon.setRelationIsTransfer(cc.getRelationIsTransfer() == null ? 0:cc.getRelationIsTransfer());    //是否已转账邮费
                customerCommon.setRelationBackPostage(cc.getRelationBackPostage() == null ? 0:cc.getRelationBackPostage());   //邮费
                //旧的物流公司物流单号支付宝信息 邮费状态 efast订单号
                customerCommon.setRelationBackLogisticsCompany(cc.getRelationBackLogisticsCompany());//寄回物流公司
                customerCommon.setRelationBackLogisticsNo(cc.getRelationBackLogisticsNo());//寄回物流单号
                customerCommon.setRelationAlipay(cc.getRelationAlipay());//转账账户
                customerCommon.setRelationAlipayName(cc.getRelationAlipayName());//转账账户 (账户姓名)
                customerCommon.setRelationDesc(cc.getRelationDesc());//备注
                customerCommon.setRelationSendLogisticsCompany(cc.getRelationSendLogisticsCompany());//寄送物流公司
                customerCommon.setRelationSendLogisticsNo(cc.getRelationSendLogisticsNo());//寄送物流单号
                customerCommon.setSalesOrderId(cc.getSalesOrderId());//efast订单号
            }else{
                customerCommon.setRelationBackStatus(1); //寄回状态 1：未寄回
                customerCommon.setRelationSendStatus(1); //寄送状态 1：未寄送
                customerCommon.setRelationIsTransfer(0);    //是否已转账邮费  0:不需要
                customerCommon.setRelationBackPostage(0);   //邮费默认为0
            }
            customerCommon.setCustomerId(customerInfo.getCustomerId()); //设置客诉id
            customerCommon.setRelationState(1); //状态  默认使用中 //新
            if(isNeedSelectOrder == 1){
                customerCommon.setOrderId(salesOrder.getSalesId()); //订单id //新
            }
            customerCommon.setTransactionNumber(customerInfo.getTransactionNumber());   //外部交易号
            customerCommon.setIsNeedSelectOrder(isNeedSelectOrder); //是否需要添加订单
            customerCommon.setRelationBackName(customerCommon.getRelationSendName()); //姓名//新
            customerCommon.setRelationBackTel(customerCommon.getRelationSendTel()); //电话号码//新

            /*  初始化产品类型，名称，配件名称 */
            customerService.setName(customerCommon);
            logger.info("-----------修改客诉-初始化产品，配件信息--------------");

            ComplaintDetectInfo complaintDetectInfo = new ComplaintDetectInfo();  //品质检测
            ComplaintSignclosedInfo complaintSignclosedInfo = new ComplaintSignclosedInfo(); //客诉-签收表
            Map<String,Object> map;
            boolean isReturn = false;
            switch (customerInfo.getCustomerIsSolve()) {  //处理结果： 1：已解决  2：未解决 3：换新  4：维修 5：补发 6：退货 7：无理由退货
                case 3: //换新
//                    customerService.chargebackEfastOrder(customerCommon,salesOrder,2);    //原订单生成退单
//                    map = customerService.sendEfastOrder(customerCommon,salesOrder);  //换新需要向Efast推送一条换新发货的订单
//                    if(map.get("status") == 1){
//                        customerCommon.setRelationBackEfastOrderId(String.valueOf(map.get("EfastOrderId")));  //存放Efast订单编号
//                        complaintSignclosedInfo.setNewEfastId(String.valueOf(map.get("EfastOrderId")));     //仓储签收表添加  发货的Efast订单id
//                    }else{
//                        throw new RuntimeException("换新创建Efast订单失败");
//                    }
//                    complaintSignclosedInfo.setOldEfastId(salesOrder.getSalesOrderId());    //原有订单的Efast的订单编号
//                    customerService.saveComplaintSignclosedInfo(complaintSignclosedInfo,customerCommon);//创建仓储任务
//                    complaintDetectInfo.setSignclosedId(complaintSignclosedInfo.getSignclosedId()); //设置仓储签收id
//                    customerService.saveComplaintDetectInfo(complaintDetectInfo,customerCommon);   //创建品检
                    break;
                case 4: //维修
//                    customerService.chargebackEfastOrder(customerCommon,salesOrder,2);    //原订单生成退单
//                    map = customerService.sendEfastOrder(customerCommon,salesOrder);  //维修需要向Efast推送一条维修发货的订单
//                    if(map.get("status") == 1){
//                        customerCommon.setRelationBackEfastOrderId(String.valueOf(map.get("EfastOrderId")));  //存放Efast订单编号
//                        complaintSignclosedInfo.setNewEfastId(String.valueOf(map.get("EfastOrderId")));     //仓储签收表添加  发货的Efast订单id
//                    }else{
//                        throw new RuntimeException("维修创建Efast订单失败");
//                    }
//                    complaintSignclosedInfo.setOldEfastId(salesOrder.getSalesOrderId());    //原有订单的Efast的订单编号
//                    customerService.saveComplaintSignclosedInfo(complaintSignclosedInfo,customerCommon);//创建仓储任务
//                    complaintDetectInfo.setSignclosedId(complaintSignclosedInfo.getSignclosedId()); //设置仓储签收id
//                    customerService.saveComplaintDetectInfo(complaintDetectInfo,customerCommon);   //创建品检
                    break;
                case 5: //补发  不用创建仓储签收任务
//                    map = customerService.sendEfastOrder(customerCommon,salesOrder);  //补发需要向Efast推送一条发货的订单
//                    if(map.get("status") == 1){
//                        customerCommon.setRelationBackEfastOrderId(String.valueOf(map.get("EfastOrderId")));  //存放Efast订单编号
//                        complaintSignclosedInfo.setNewEfastId(String.valueOf(map.get("EfastOrderId")));     //仓储签收表添加  发货的Efast订单id
//                    }else{
//                        throw new RuntimeException("补发创建Efast订单失败");
//                    }
                    break;
                case 6: //退货
//                    customerService.chargebackEfastOrder(customerCommon,salesOrder,3);    //原订单生成退单

//                    complaintSignclosedInfo.setOldEfastId(salesOrder.getSalesOrderId());    //原有订单的Efast的订单编号
//                    customerService.saveComplaintSignclosedInfo(complaintSignclosedInfo,customerCommon);//创建仓储任务
//                    complaintDetectInfo.setSignclosedId(complaintSignclosedInfo.getSignclosedId()); //设置仓储签收id
//                    customerService.saveComplaintDetectInfo(complaintDetectInfo,customerCommon);   //创建品检
                    break;
                case 7: //无理由退货
//                    customerService.chargebackEfastOrder(customerCommon,salesOrder,3);    //原订单生成退单
//                    complaintSignclosedInfo.setOldEfastId(salesOrder.getSalesOrderId());    //原有订单的Efast的订单编号
//                    customerService.saveComplaintSignclosedInfo(complaintSignclosedInfo,customerCommon);//创建仓储任务
//                    complaintDetectInfo.setSignclosedId(complaintSignclosedInfo.getSignclosedId()); //设置仓储签收id
//                    customerService.saveComplaintDetectInfo(complaintDetectInfo,customerCommon);   //创建品检
                    break;
            }
            logger.info("-----------修改客诉-创建仓储/品检成功--------------");
            customerCommon.setSignclosedId(complaintSignclosedInfo.getSignclosedId()); //设置仓储id

            Object object = CustomerCommonUtil.getRelation(customerInfo.getCustomerIsSolve(), customerCommon);
            Integer relationId = 0;
            Integer orderStatus = 1;
            switch (customerInfo.getCustomerIsSolve()) {  //处理结果： 1：已解决  2：未解决 3：换新  4：维修 5：补发 6：退货 7：无理由退货
                case 3: //换新
                    Renewed renewed = (Renewed) object;
                    flag = renewedMapper.insert(renewed);
                    relationId = renewed.getRenewedId();
                    orderStatus = 2;
                    break;
                case 4: //维修
                    Repair repair = (Repair) object;
                    flag = repairMapper.insert(repair);
                    relationId = repair.getRepairId();
                    orderStatus = 4;
                    break;
                case 5: //补发
                    Reissue reissue = (Reissue) object;
                    flag = reissueMapper.insert(reissue);
                    relationId = reissue.getReissueId();
                    orderStatus = 5;
                    break;
                case 6: //退货
                    BackGoods backGoods = (BackGoods) object;
                    flag = backGoodsMapper.insert(backGoods);
                    relationId = backGoods.getBackGoodsId();
                    orderStatus = 3;
                    break;
                case 7: //无理由退货
                    NoreasonBack noreasonBack = (NoreasonBack) object;
                    flag = noreasonBackMapper.insert(noreasonBack);
                    relationId = noreasonBack.getNoreasonBackId();
                    orderStatus = 3;
                    break;
            }
            if (flag < 1) {
                throw new RuntimeException("添加客诉处理结果失败");
            }
            logger.info("-----------修改客诉-添加换新/维修/补发/退货/无理由退货信息成功--------------");

              /*添加客诉-添加处理与订单关联表*/
            List<RelationOrder> relationOrderList = new ArrayList<>();
            for (SalesOrder sor : orderList) {
                RelationOrder ro = new RelationOrder();
                ro.setRelationType(customerInfo.getCustomerIsSolve());
                ro.setRelationId(relationId);
                ro.setSalesId(sor.getSalesId());
                ro.setRelationCustomerId(customerInfo.getCustomerId());
                relationOrderList.add(ro);
            }
            if(relationOrderList != null && relationOrderList.size() > 0){
                flag = relationOrderService.saveList(relationOrderList);
                if(flag < 1){
                    throw new RuntimeException("添加客诉，关联订单失败");
                }
            }

            for (SalesOrder sor : orderList) {
                SalesOrder newOrder = new SalesOrder(); //salesOrderStatus
                newOrder.setSalesId(sor.getSalesId());
                newOrder.setSalesOrderStatus(orderStatus);
                flag = salesOrderMapper.updateSalesOrder(newOrder);
                if(flag < 1){
                    throw new RuntimeException("添加客诉，修改订单状态失败");
                }
            }
            logger.info("-----------添加客诉-添加处理与订单关联表--------------");

            customerCommon.setRelationId(relationId);
            if(customerCommon.getIsNeedSelectOrder() == 1){
                CustomerCommonUtil.setProduceOrFitting(customerInfo.getCustomerIsSolve(),customerCommon);
                if(customerCommon.getClosedFittings()!=null && customerCommon.getClosedFittings().size() > 0){
                    closedFittingMapper.insert(customerCommon.getClosedFittings());
                }
                if(customerCommon.getClosedProdcues() != null && customerCommon.getClosedProdcues().size() > 0){
                    closedProdcueMapper.insert(customerCommon.getClosedProdcues());
                }
                if(customerCommon.getSendProdcues() != null && customerCommon.getSendProdcues().size() > 0){
                    sendProdcueMapper.insert(customerCommon.getSendProdcues());
                }
                if(customerCommon.getSendFittings() != null && customerCommon.getSendFittings().size() > 0){
                    sendFittingMapper.insert(customerCommon.getSendFittings());
                }
                logger.info("-----------添加客诉-寄回寄出产品配件成功--------------");
            }
        }
        return flag;
    }

    /**
     * 删除旧的售后数据
     * @param customer
     */
    @Override
    @Transactional
    public void deleteCustomerAfterSales(CustomerInfo customer){
        CustomerInfo customerInfo = customerInfoMapper.getCustomerInfo(customer.getCustomerId());
        //删除回访信息
        if ("2".equals(customerInfo.getCustomerIsVisit())){
            visitMapper.deleteByPrimaryKey(customer.getCustomerId());
        }

        //查询旧客诉类型，判断是否修改了客诉类型
        Integer oldIsSolve = customerInfo.getCustomerIsSolve();// //处理结果： 1：已解决  2：未解决 3：换新  4：维修 5：补发 6：退货 7：无理由退货
        ClosedProdcue closedrecord = new ClosedProdcue();
        ClosedFitting closedRecord = new ClosedFitting();
        SendProdcue sendProdcue = new SendProdcue();
        SendFitting sendFitting = new SendFitting();
        CustomerCommon customerCommon = customerInfo.getCustomerCommon();
        SalesOrder salesOrder = new SalesOrder();
        if(oldIsSolve > 2){
            customerCommon = customerInfo.getCustomerCommon();
            customerCommon.setCustomerId(customerInfo.getCustomerId()); //设置客诉id
            customerCommon.setRelationBackStatus(1); //寄回状态 1：未寄回
            customerCommon.setRelationSendStatus(1); //寄送状态 1：未寄送
            customerCommon.setRelationState(1); //状态  默认使用中
            customerCommon.setTransactionNumber(customerInfo.getTransactionNumber());   //外部交易号
            customerCommon.setRelationIsTransfer(0);    //是否已转账邮费  0:不需要
            customerCommon.setRelationBackPostage(0);   //邮费默认为0
            customerCommon.setRelationBackName(customerCommon.getRelationSendName()); //姓名
            customerCommon.setRelationBackTel(customerCommon.getRelationSendTel()); //电话号码
            /*  初始化产品类型，名称，配件名称 */
            /*customerService.setName(customerCommon);*/
        }
        Integer relationId = 0;
        switch (oldIsSolve){
            case 3:
                //删除换新数据
                Renewed renewed = new Renewed();
                renewed.setCustomerId(customer.getCustomerId());
                //查询换新数据id
                renewed = renewedMapper.getRenewedInfo(renewed);
                relationId = renewed.getRenewedId();
                if(customer.getCustomerIsSolve() < 3){ //从维修换货补发修改为已解决或未解决时，原订单生成退单
                    //salesOrder = salesOrderMapper.getSalesOrderById(renewed.getOrderId());    //salesOrder.getSalesId()  全场最佳，就你戏多
                    //customerCommon.setOrderId(renewed.getOrderId()); //订单id
                    SendProdcue record = new SendProdcue();
                    record.setRelationId(renewed.getRenewedId());
                    customerCommon.setSendProdcues(sendProdcueMapper.listSendProdcue(record));
                    customerService.setName(customerCommon);
                    //customerService.chargebackEfastOrder(customerCommon,salesOrder,8,2);
                }
                //删除寄出寄回产品
                closedRecord.setRelationId(renewed.getRenewedId());
                closedFittingMapper.deleteByPrimaryKey(closedRecord);
                closedrecord.setRelationId(renewed.getRenewedId());
                closedProdcueMapper.deleteByPrimaryKey(closedrecord);
                sendProdcue.setRelationId(renewed.getRenewedId());
                sendProdcueMapper.deleteByPrimaryKey(sendProdcue);
                sendFitting.setRelationId(renewed.getRenewedId());
                sendFittingMapper.deleteByPrimaryKey(sendFitting);
                renewedMapper.deleteByPrimaryKey(renewed);
                break;
            case 4:
                //删除维修数据
                Repair repair = new Repair();
                repair.setCustomerId(customer.getCustomerId());
                //查询维修数据id
                repair = repairMapper.getRepairInfo(repair);
                relationId = repair.getRepairId();
                if(customer.getCustomerIsSolve() < 3) { //从维修换货补发修改为已解决或未解决时，原订单生成退单
                    //salesOrder = salesOrderMapper.getSalesOrderById(repair.getOrderId());
                    //customerCommon.setOrderId(repair.getOrderId()); //订单id
                    SendProdcue record = new SendProdcue();
                    record.setRelationId(repair.getRepairId());
                    customerCommon.setSendProdcues(sendProdcueMapper.listSendProdcue(record));
                    customerService.setName(customerCommon);
                    //customerService.chargebackEfastOrder(customerCommon, salesOrder, 8,2);    //从维修换货补发修改为已解决或未解决时，原订单生成退单
                }
                //删除寄出寄回产品
                closedRecord.setRelationId(repair.getRepairId());
                closedFittingMapper.deleteByPrimaryKey(closedRecord);
                closedrecord.setRelationId(repair.getRepairId());
                closedProdcueMapper.deleteByPrimaryKey(closedrecord);
                sendProdcue.setRelationId(repair.getRepairId());
                sendProdcueMapper.deleteByPrimaryKey(sendProdcue);
                sendFitting.setRelationId(repair.getRepairId());
                sendFittingMapper.deleteByPrimaryKey(sendFitting);
                repairMapper.deleteByPrimaryKey(repair);
                break;
            case 5:
                //删除补发数据
                Reissue reissue = new Reissue();
                reissue.setCustomerId(customer.getCustomerId());
                //查询补发数据id
                reissue = reissueMapper.getReissue(reissue);
                relationId = reissue.getReissueId();
                if(customer.getCustomerIsSolve() < 3) { //从维修换货补发修改为已解决或未解决时，原订单生成退单
                    //salesOrder = salesOrderMapper.getSalesOrderById(reissue.getOrderId());
                    //customerCommon.setOrderId(reissue.getOrderId()); //订单id
                    SendProdcue record = new SendProdcue();
                    record.setRelationId(reissue.getReissueId());
                    customerCommon.setSendProdcues(sendProdcueMapper.listSendProdcue(record));
                    customerService.setName(customerCommon);
                    //customerService.chargebackEfastOrder(customerCommon, salesOrder, 8,2);    //从维修换货补发修改为已解决或未解决时，原订单生成退单
                }
                //删除寄出产品
                sendProdcue.setRelationId(reissue.getReissueId());
                sendProdcueMapper.deleteByPrimaryKey(sendProdcue);
                sendFitting.setRelationId(reissue.getReissueId());
                sendFittingMapper.deleteByPrimaryKey(sendFitting);
                reissueMapper.deleteByPrimaryKey(reissue);
                break;
            case 6:
                //删除退货数据
                BackGoods backGoods = new BackGoods();
                backGoods.setCustomerId(customer.getCustomerId());
                //查询维修数据id
                backGoods = backGoodsMapper.getBackGoods(backGoods);
                relationId = backGoods.getBackGoodsId();
                //删除寄出寄回产品
                closedRecord.setRelationId(backGoods.getBackGoodsId());
                closedFittingMapper.deleteByPrimaryKey(closedRecord);
                closedrecord.setRelationId(backGoods.getBackGoodsId());
                closedProdcueMapper.deleteByPrimaryKey(closedrecord);
                backGoodsMapper.deleteByPrimaryKey(backGoods);
                break;
            case 7:
                //删除无理由退货数据
                NoreasonBack noreasonBack = new NoreasonBack();
                noreasonBack.setCustomerId(customer.getCustomerId());
                //查询维修数据id
                noreasonBack = noreasonBackMapper.getNoreasonBack(noreasonBack);
                relationId = noreasonBack.getNoreasonBackId();
                        //删除寄出寄回产品
                closedRecord.setRelationId(noreasonBack.getNoreasonBackId());
                closedFittingMapper.deleteByPrimaryKey(closedRecord);
                closedrecord.setRelationId(noreasonBack.getNoreasonBackId());
                closedProdcueMapper.deleteByPrimaryKey(closedrecord);
                noreasonBackMapper.deleteByPrimaryKey(noreasonBack);
                break;
        }

        /*恢复订单状态*/
        RelationOrder relationOrder = new RelationOrder();
        relationOrder.setRelationType(oldIsSolve);
        relationOrder.setRelationId(relationId);
        List<RelationOrder> relationOrderList = relationOrderService.getRelationOrderList(relationOrder);
        for (int k=0; k<relationOrderList.size();k++){
            SalesOrder newOrder = new SalesOrder(); //salesOrderStatus
            newOrder.setSalesId(relationOrderList.get(k).getSalesId());
            newOrder.setSalesOrderStatus(1);    //恢复订单到之前的状态
            Integer flag = salesOrderMapper.updateSalesOrder(newOrder);
        }

        /* 删除掉订单与处理的关联表 */
        relationOrderService.deleteByRelationId(relationId);
    }

    @Override
    public Integer selectNotSolvedCustomer(CustomerInfo customerInfo) {
        List<CustomerInfo> listCustomer = customerInfoMapper.listCustomer(customerInfo);
        return listCustomer.size();
    }

    @Override
    public List<CustomerInfo> listOnCustomer(CustomerInfo customerInfo) {
       List<CustomerInfo> customerList = customerInfoMapper.listOnCustomer(customerInfo);
        //查询售后维修集合
        Repair repairInfo = new Repair();
        repairInfo.setRepairState(1);
        List<Repair> repairList = repairMapper.listRepair(repairInfo);
        //查询售后退货集合
        BackGoods backGoodsInfo = new BackGoods();
        backGoodsInfo.setBackGoodsState(1);
        List<BackGoods> backGoodsList = backGoodsMapper.listBackGoods(backGoodsInfo);
        //查询售后无理由退货集合
        NoreasonBack noreasonBackInfo = new NoreasonBack();
        noreasonBackInfo.setNoreasonBackState(1);
        List<NoreasonBack> noreasonBackList = noreasonBackMapper.listNoreasonBack(noreasonBackInfo);
        //查询售后补发集合
        Reissue reissueInfo = new Reissue();
        reissueInfo.setReissueState(1);
        List<Reissue> reissueList = reissueMapper.listReissue(reissueInfo);
        //查询售后换新集合
        Renewed renewedInfo = new Renewed();
        renewedInfo.setRenewedState(1);
        List<Renewed> renewedList = renewedMapper.listRenewed(renewedInfo);

        if (customerList != null && customerList.size() > 0) {
            for (CustomerInfo customer : customerList) {
                switch (customer.getCustomerIsSolve().intValue()) {
                    case 3: //换新
                        for (Renewed renewed : renewedList) {
                            if (renewed.getCustomerId().intValue() == customer.getCustomerId()) {
                                customer.setBackStatus(renewed.getRenewedBackStatus());
                                customer.setSendStatus(renewed.getRenewedSendStatus());
                                customer.setSalesTime(renewed.getSalesPayTime());
                                customer.setSendLogisticsNo(renewed.getRenewedSendLogisticsNo());
                                customer.setSendLogisticsCompany(renewed.getRenewedSendLogisticsCompany());
                                customer.setBackLogisticsNo(renewed.getRenewedBackLogisticsNo());
                                customer.setBackLogisticsCompany(renewed.getRenewedBackLogisticsCompany());
                                break;
                            }
                        }
                        break;
                    case 4: //维修
                        for (Repair repair : repairList) {
                            if (repair.getCustomerId().intValue() == customer.getCustomerId()) {
                                customer.setBackStatus(repair.getRepairBackStatus());
                                customer.setSendStatus(repair.getRepairSendStatus());
                                customer.setSalesTime(repair.getSalesPayTime());
                                customer.setSendLogisticsNo(repair.getRepairSendLogisticsNo());
                                customer.setSendLogisticsCompany(repair.getRepairSendLogisticsCompany());
                                customer.setBackLogisticsNo(repair.getRepairBackLogisticsNo());
                                customer.setBackLogisticsCompany(repair.getRepairBackLogisticsCompany());
                                break;
                            }
                        }
                        break;
                    case 5: //补发
                        for (Reissue reissue : reissueList) {
                            if (reissue.getCustomerId().intValue() == customer.getCustomerId()) {
                                customer.setSendStatus(reissue.getReissueSendStatus());
                                customer.setSalesTime(reissue.getSalesPayTime());
                                customer.setBackLogisticsNo(reissue.getReissueSendLogisticsNo());
                                customer.setBackLogisticsCompany(reissue.getReissueSendLogisticsCompany());
                                break;
                            }
                        }
                        break;
                    case 6: //退货
                        for (BackGoods backGoods : backGoodsList) {
                            if (backGoods.getCustomerId().intValue() == customer.getCustomerId()) {
                                customer.setBackStatus(backGoods.getBackGoodsBackStatus());
                                customer.setSalesTime(backGoods.getSalesPayTime());
                                customer.setSendLogisticsNo(backGoods.getBackGoodsBackLogisticsNo());
                                break;
                            }
                        }
                        break;
                    case 7: //无理由退货
                        for (NoreasonBack noreasonBack : noreasonBackList) {
                            if (noreasonBack.getCustomerId().intValue() == customer.getCustomerId()) {
                                customer.setBackStatus(noreasonBack.getNoreasonBackBackStatus());
                                customer.setSalesTime(noreasonBack.getSalesPayTime());
                                customer.setSendLogisticsNo(noreasonBack.getNoreasonBackBackLogisticsNo());
                                customer.setSendLogisticsCompany(noreasonBack.getNoreasonBackBackLogisticsCompany());
                                break;
                            }
                        }
                        break;
                }
            }
        }
        return customerList;
    }

    /**
     * 产品配件初始化
     * @param cc
     */
    @Transactional
    public void setName(CustomerCommon cc){
        for (int i=0;i<cc.getSendProdcues().size();i++) {
            ProductColor productColor = productMapper.getProductBySku(cc.getSendProdcues().get(i).getColorBar());
            cc.getSendProdcues().get(i).setProductColor(productColor);
            cc.getSendProdcues().get(i).setColorId(productColor.getColorId());

            Product product = productMapper.getProduce(productColor.getColorProductId());
            cc.getSendProdcues().get(i).setProductId(product.getProductId());
            cc.getSendProdcues().get(i).setSendProduceName(product.getProductName());
            cc.getSendProdcues().get(i).setProductType(product.getProductType());
            cc.getSendProdcues().get(i).setProductNumber(product.getProductNumber());
        }
        for (int i=0;i<cc.getSendFittings().size();i++) {
            FittingsInfo fittingsInfo = productMapper.getFittingsBySku( cc.getSendFittings().get(i).getColorBar());
            cc.getSendFittings().get(i).setFittingsId(fittingsInfo.getFittingsId());
            cc.getSendFittings().get(i).setProductId(fittingsInfo.getFittingsId());
            cc.getSendFittings().get(i).setSendFittingsName(fittingsInfo.getFittingsName());

            Product product = productMapper.getProduce(fittingsInfo.getProductId());
            cc.getSendFittings().get(i).setSendFittingsName(product.getProductName());
        }
        for (int i=0;i<cc.getClosedProdcues().size();i++) {
            ProductColor productColor = productMapper.getProductBySku(cc.getClosedProdcues().get(i).getColorBar());
            cc.getClosedProdcues().get(i).setProductColor(productColor);
            cc.getClosedProdcues().get(i).setColorId(productColor.getColorId());

            Product product = productMapper.getProduce(productColor.getColorProductId());
            cc.getClosedProdcues().get(i).setProductId(product.getProductId());
            cc.getClosedProdcues().get(i).setClosedProductName(product.getProductName());
            cc.getClosedProdcues().get(i).setProductType(product.getProductType());
            cc.getClosedProdcues().get(i).setProductNumber(product.getProductNumber());
        }
        for (int i=0;i<cc.getClosedFittings().size();i++) {
            FittingsInfo fittingsInfo = productMapper.getFittingsBySku(cc.getClosedFittings().get(i).getColorBar());
            cc.getClosedFittings().get(i).setFittingsId(fittingsInfo.getFittingsId());
            cc.getClosedFittings().get(i).setProductId(fittingsInfo.getProductId());
            cc.getClosedFittings().get(i).setClosedFittingsName(fittingsInfo.getFittingsName());

            Product product = productMapper.getProduce(fittingsInfo.getProductId());
            cc.getClosedFittings().get(i).setClosedProductName(product.getProductName());
        }
    }

    /**
     * 添加品检
     * @param complaintDetectInfo
     * @param customerCommon
     * @return
     */
    @Transactional
    public void saveComplaintDetectInfo(ComplaintDetectInfo complaintDetectInfo,CustomerCommon customerCommon){
        if(customerCommon.getIsNeedSelectOrder() == 2){
            return;
        }
        /*Integer flag = 0;
        List<ComplaintDetectInfo> complaintDetectInfoList = new ArrayList<ComplaintDetectInfo>();
        for(int i=0 ;i< customerCommon.getClosedProdcues().size();i++){
            ClosedProdcue closedProdcue = customerCommon.getClosedProdcues().get(i);
            for(int j=0; j<closedProdcue.getClosedProdcueNumber();j++){
                ComplaintDetectInfo cd = new ComplaintDetectInfo();
                cd.setSignclosedId(complaintDetectInfo.getSignclosedId());
                cd.setCustomerId(customerCommon.getCustomerId());    //添加客诉
                cd.setDetectState(1);      //状态  1待仓库转入
                cd.setDetectRevolutionProduced(1);  //是否转入生产部门  1待转入
                cd.setDetectIsMaintenance(1);   //是否需要维修，1 需要 2不需要
                cd.setProductId(closedProdcue.getProductId());
                cd.setDetectProductType(closedProdcue.getProductType());
                if(closedProdcue.getProductNumber() == null || "".equals(closedProdcue.getProductNumber())){
                    cd.setDetectProductNumber("0");
                }else{
                    cd.setDetectProductNumber(closedProdcue.getProductNumber());
                }
                complaintDetectInfoList.add(cd);
            }
        }
        if(complaintDetectInfoList.size() > 0){
            flag = complaintDetectInfoMapper.insertList(complaintDetectInfoList);
        }
        if(flag < 1){
            throw new RuntimeException("添加品检失败");
        }*/
    }

    /**
     * 添加仓储
     * @param customerCommon
     * @return
     */
    @Transactional
    public void saveComplaintSignclosedInfo(ComplaintSignclosedInfo complaintSignclosedInfo,CustomerCommon customerCommon){
        if(customerCommon.getIsNeedSelectOrder() == 2){
            return;
        }
        Integer flag;
        complaintSignclosedInfo.setSignclosedType(1); //客诉寄回
        complaintSignclosedInfo.setSignclosedCustomerId(customerCommon.getCustomerId()); //客诉id
        complaintSignclosedInfo.setSignclosedSendName(customerCommon.getRelationBackName());    //签收姓名
        complaintSignclosedInfo.setSignclosedSendTel(customerCommon.getRelationBackTel());     //签收手机
        flag = complaintSignclosedInfoMapper.insert(complaintSignclosedInfo);
        if(flag < 1){
            throw new RuntimeException("添加签收失败");
        }

        //添加代签收表
        List<AwaitingSignclosedProductInfo> awaitingSignclosedProductInfoArrayList = new ArrayList<>();
        for(int i=0 ;i< customerCommon.getClosedProdcues().size();i++){
            ClosedProdcue closedProdcue = customerCommon.getClosedProdcues().get(i);
            for(int k=0;k<closedProdcue.getClosedProdcueNumber();k++){
                AwaitingSignclosedProductInfo awaitingSignclosedProductInfo = new AwaitingSignclosedProductInfo();
                awaitingSignclosedProductInfo.setSignclosedId(complaintSignclosedInfo.getSignclosedId());   //仓储id
                awaitingSignclosedProductInfo.setSignclosedProductType(1); //类型为产品
                awaitingSignclosedProductInfo.setProductNum(1);
                awaitingSignclosedProductInfo.setSignclosedProductId(closedProdcue.getProductId());         //产品id
                awaitingSignclosedProductInfo.setSignclosedProductColor(closedProdcue.getColorId());        //颜色id
                awaitingSignclosedProductInfo.setProductName(closedProdcue.getClosedProductName());         //产品名称
                awaitingSignclosedProductInfoArrayList.add(awaitingSignclosedProductInfo);
            }
        }

        for(int i=0 ;i< customerCommon.getClosedFittings().size();i++){
            ClosedFitting closedFitting = customerCommon.getClosedFittings().get(i);
            for(int k=0;k<closedFitting.getClosedFittingNumber();k++){
                AwaitingSignclosedProductInfo awaitingSignclosedProductInfo = new AwaitingSignclosedProductInfo();
                awaitingSignclosedProductInfo.setSignclosedId(complaintSignclosedInfo.getSignclosedId());   //仓储id
                awaitingSignclosedProductInfo.setSignclosedProductType(2);  //类型为配件
                awaitingSignclosedProductInfo.setProductNum(1);
                awaitingSignclosedProductInfo.setSignclosedProductId(closedFitting.getFittingsId());         //配件id
                awaitingSignclosedProductInfo.setSignclosedProductColor(null);
                awaitingSignclosedProductInfo.setProductName(closedFitting.getClosedFittingsName());       //配件名称
                awaitingSignclosedProductInfoArrayList.add(awaitingSignclosedProductInfo);
            }
        }
        flag = complaintSignclosedProductInfoMapper.insertList(awaitingSignclosedProductInfoArrayList);
        if(flag < 1){
            throw new RuntimeException("添加签收产品失败");
        }
    }

    /**
     * 向Efast推送订单  仅换新，维修 ,补发
     * @return
     */
    @Transactional
    public Map<String,Object> sendEfastOrder(CustomerCommon customerCommon,SalesOrder salesOrder){
        Map<String,Object> map = new HashMap<String,Object>();
        List<EfastOrder> orderList = new ArrayList<EfastOrder>();
        List<OrderItem> itemList = new ArrayList<OrderItem>();

        Integer num = 0;  //产品数量
        Integer amout = 0; //商品总价
        String orderProductBarCode = "";    //产品sku
        String productName = "";    //产品名称
        for(int i=0;i<customerCommon.getSendProdcues().size();i++){
            SendProdcue sendProdcue = customerCommon.getSendProdcues().get(i);
            OrderItem orderItem = new OrderItem();
            orderItem.setItemProductName(sendProdcue.getSendProduceName());
            orderItem.setItemProductNum(sendProdcue.getSendProdcueNumber());
            orderItem.setItemProductPrice(sendProdcue.getProductColor().getColorPrice());
            orderItem.setItemColorBar(sendProdcue.getProductColor().getColorBar());
            itemList.add(orderItem);
            orderProductBarCode = sendProdcue.getProductColor().getColorBar();
            productName = sendProdcue.getSendProduceName();
            num += sendProdcue.getSendProdcueNumber();
            amout += sendProdcue.getProductColor().getColorPrice();
        }

        EfastOrder efastOrder = new EfastOrder();
        efastOrder.setOrderAddressName(customerCommon.getRelationSendName());//收货人姓名
        efastOrder.setOrderAddressTel(customerCommon.getRelationSendTel());//收货人电话
        efastOrder.setOrderOpenId("1");//身份证

        String[] address = customerCommon.getRelationSendMergeAddress().split("-");
        efastOrder.setOrderProvince(address[0]);
        efastOrder.setOrderCity(address[1]);
        efastOrder.setOrderArea(address[2]);
        efastOrder.setOrderAddress(customerCommon.getRelationSendAddress());
        efastOrder.setOrderStatus(2);

        efastOrder.setOrderStoreId(salesOrder.getStoreEfast());   //设置efast店铺id

        efastOrder.setOrderNum(num); //产品数量
        efastOrder.setOrderAmount(amout);   //商品总价
        efastOrder.setOrderPayMoney(amout); //已付款

        //支付方式
        switch (salesOrder.getSalesPayType()){
            case 1: //微信支付
                efastOrder.setOrderPayType(1);
                break;
            case 2: //现金支付
                efastOrder.setOrderPayType(2);
                break;
            case 3:
                break;
            case 4: //刷卡支付
                efastOrder.setOrderPayType(4);
                break;
            case 5: //支付宝支付
                efastOrder.setOrderPayType(5);
                break;
            default:
                efastOrder.setOrderPayType(2);  //默认现金
                break;
        }

        efastOrder.setOrderProductBarCode(orderProductBarCode); //产品sku
        efastOrder.setOrderProductName(productName);    //产品名称

        efastOrder.setOrderId(customerCommon.getTransactionNumber());   //外部交易号
        efastOrder.setOid(1);

        orderList.add(efastOrder);

        Integer status = 1;
        Map<String,Object>  orderMap = new HashMap<String,Object>();
        try {
            orderMap = efastOrderService.sendOrder(orderList,itemList);
        } catch (Exception e) {
            status = 0;
        }
        List<EfastOrder> oList = (List<EfastOrder>) orderMap.get("efastOrderList");
        if(oList == null || oList.size() < 1){
            status = 0;
        }
        map.put("status",status);
        if(oList != null && oList.size() > 0){
            map.put("EfastOrderId",oList.get(0).getOrderId());
            logger.info("换新，维修 ,补发向Efast 推送订单成功，订单号为：" + oList.get(0).getOrderId());
        }else{
            logger.info("换新，维修 ,补发向Efast 推送订单，推送失败,交易号为：" + customerCommon.getTransactionNumber());
        }
        return map;
    }

    @Override
    public Integer getQuestionNumber(CustomerInfo customerInfo) {
        return customerInfoMapper.getQuestionNumber(customerInfo);
    }

    /**
     * 添加订单
     * @return
     */
    @Transactional
    public Integer addOrder(SalesOrder salesOrder) {
        //添加订单数据
        int orderNum = salesOrderMapper.addSalesOrder(salesOrder);
        if (orderNum <= 0) {
            throw new RuntimeException("系统添加订单失败");
        }
        for (SalesOrderItem item : salesOrder.getSalesOrderItemList()) {
            item.setItemOrderId(salesOrder.getSalesId());
        }
        //批量添加订单项数据
        int itemNum = salesOrderMapper.addOrderItemList(salesOrder.getSalesOrderItemList());
        if (itemNum <= 0) {
            throw new RuntimeException("系统添加订单项失败");
        }
        return orderNum;
    }

    @Override
    public List<CustomerStatisticalInfo> listStatisticalCustomer() {
        return customerInfoMapper.listStatisticalCustomer();
    }

    @Override
    public List<ReturnStatisticsInfo> salesTotalSales(SalesOrder salesOrder) {
        return customerInfoMapper.salesTotalSales(salesOrder);
    }

    @Override
    public List<ReturnStatisticsInfo> salesTotalExchange(SalesOrder salesOrder) {
        return customerInfoMapper.salesTotalExchange(salesOrder);
    }

    @Override
    public List<ReturnStatisticsInfo> salesTotalReturn(SalesOrder salesOrder) {
        return customerInfoMapper.salesTotalReturn(salesOrder);
    }

    @Override
    public List<ReturnStatisticsInfo> salesSecondaryChangeNew(SalesOrder salesOrder) {
        return customerInfoMapper.salesSecondaryChangeNew(salesOrder);
    }

    @Override
    public List<ReturnStatisticsInfo> salesReturnForSecond(SalesOrder salesOrder) {
        return customerInfoMapper.salesReturnForSecond(salesOrder);
    }

    /**
         * 向Efast推送订单--添加订单
         * @return
         */
    @Transactional
    public Map<String,Object> sendEfastOrder(SalesOrder salesOrder){

        //添加订单数据
        int orderNum = salesOrderMapper.addSalesOrder(salesOrder);
        if (orderNum <= 0) {
            throw new RuntimeException("系统添加订单失败");
        }
        for (SalesOrderItem item : salesOrder.getSalesOrderItemList()) {
            item.setItemOrderId(salesOrder.getSalesId());
        }
        //批量添加订单项数据
        int itemNum = salesOrderMapper.addOrderItemList(salesOrder.getSalesOrderItemList());
        if (itemNum <= 0) {
            throw new RuntimeException("系统添加订单项失败");
        }

        Map<String,Object> map = new HashMap<String,Object>();
        List<EfastOrder> orderList = new ArrayList<EfastOrder>();
        List<OrderItem> itemList = new ArrayList<OrderItem>();

        Integer num = 0;  //产品数量
        Integer amout = 0; //商品总价
        String orderProductBarCode = "";    //产品sku
        String productName = "";    //产品名称
        for(int i=0;i<salesOrder.getSalesOrderItemList().size();i++){
            SalesOrderItem salesOrderItem = salesOrder.getSalesOrderItemList().get(i);
            OrderItem orderItem = new OrderItem();
            orderItem.setItemProductName(salesOrderItem.getItemProductName());
            orderItem.setItemProductNum(salesOrderItem.getItemNum());
            orderItem.setItemProductPrice(salesOrderItem.getItemProductPrice());
            orderItem.setItemColorBar(salesOrderItem.getItemColorBar());
            itemList.add(orderItem);
            orderProductBarCode = salesOrderItem.getItemColorBar();
            productName = salesOrderItem.getItemProductName();
            num += salesOrderItem.getItemNum();
            amout += salesOrderItem.getItemProductPrice();
        }

        EfastOrder efastOrder = new EfastOrder();
        efastOrder.setOrderAddressName(salesOrder.getSalesAddressName());//收货人姓名
        efastOrder.setOrderAddressTel(salesOrder.getSalesAddressTel());//收货人电话
        efastOrder.setOrderOpenId("1");//身份证

        efastOrder.setOrderRemark(salesOrder.getOrderNoteRemark()); //订单备注
        efastOrder.setOrderBuyerRemark(salesOrder.getSalesUserRemark()); //买家备注
        efastOrder.setOrderSellerRemark(salesOrder.getSalesAdminRemark()); //卖家备注

        String[] address = salesOrder.getSalesAddressInfo().split("-");
        efastOrder.setOrderProvince(address[0]);
        efastOrder.setOrderCity(address[1]);
        efastOrder.setOrderArea(address[2]);
        String myAddress = "";
        if(address.length > 4){
            myAddress = address[3] + address[4];
        }else{
            myAddress =  address[3];
        }
        efastOrder.setOrderAddress(myAddress);
        efastOrder.setOrderStatus(1);

        efastOrder.setOrderNum(num); //产品数量
        efastOrder.setOrderAmount(amout);   //商品总价
        efastOrder.setOrderPayMoney(amout); //已付款

        //支付方式
        switch (salesOrder.getSalesPayType()){
            case 1: //微信支付
                efastOrder.setOrderPayType(1);
                break;
            case 2: //现金支付
                efastOrder.setOrderPayType(2);
                break;
            case 3:
                break;
            case 4: //刷卡支付
                efastOrder.setOrderPayType(4);
                break;
            case 5: //支付宝支付
                efastOrder.setOrderPayType(5);
                break;
            default:
                efastOrder.setOrderPayType(2);  //默认现金
                break;
        }

        efastOrder.setOrderProductBarCode(orderProductBarCode); //产品sku
        efastOrder.setOrderProductName(productName);    //产品名称

        efastOrder.setOrderId(salesOrder.getSalesDealCode());   //外部交易号

        StoreInfo storeInfo = new StoreInfo();
        storeInfo = storeInfoMapper.getStoreInfoById(salesOrder.getSalesStoreId());
        efastOrder.setOrderStoreId(storeInfo.getStoreEfast());

        efastOrder.setOid(1);

        orderList.add(efastOrder);

        Integer status = 1;
        Map<String,Object>  orderMap = new HashMap<String,Object>();
        try {
            orderMap = efastOrderService.sendOrder(orderList,itemList);
        } catch (Exception e) {
            status = 0;
        }
        List<EfastOrder> oList = (List<EfastOrder>) orderMap.get("efastOrderList");
        if(oList == null || oList.size() < 1){
            status = 0;
        }
        if(oList != null && oList.size() > 0){
            map.put("EfastOrderId",oList.get(0).getOrderId());

            SalesOrder sa =  new SalesOrder();
            sa.setSalesId(salesOrder.getSalesId());
            sa.setSalesOrderId(oList.get(0).getOrderId());
            orderNum = salesOrderMapper.updateSalesOrder(sa);
            if (orderNum <= 0) {
                throw new RuntimeException("系统修改订单失败,订单回滚，Efast交易号："+salesOrder.getSalesDealCode());
            }
        }else{
            throw new RuntimeException("添加Efast订单失败");
        }
        map.put("status",status);
        return map;
    }

    /**
     * 将原订单生成退货单
     * @param customerCommon
     * @param salesOrder
     * @return
     * @throws RuntimeException
     */
    @Transactional
    public void chargebackEfastOrder(CustomerCommon customerCommon, SalesOrder salesOrder,Integer status,Integer returnType){

        SalesOrder order = new SalesOrder();
        order.setSalesId(salesOrder.getSalesId());
        order.setSalesOrderStatus(status); //换货状态
        Integer flag = salesOrderMapper.updateSalesOrder(order);
        if(flag < 0){
            throw new RuntimeException("系统生成退单失败");
        }
        EfastOrder efastOrder = new EfastOrder();
        List<EfastOrderItem> itemList = new ArrayList<>();

        /*for(int i=0;i<customerCommon.getSendProdcues().size();i++){
            SendProdcue sendProdcue = customerCommon.getSendProdcues().get(i);
            EfastOrderItem efastOrderItem = new EfastOrderItem();
            efastOrderItem.setItemColorBar(sendProdcue.getProductColor().getColorBar());
            efastOrderItem.setItemNum(sendProdcue.getSendProdcueNumber());
            efastOrderItem.setItemDiscount(sendProdcue.getProductColor().getColorPrice());
            itemList.add(efastOrderItem);
        }*/
        SalesOrderItem salesOrderItem = new SalesOrderItem();
        salesOrderItem.setItemOrderId(salesOrder.getSalesId());
        List<SalesOrderItem> salesOrderItemList = salesOrderMapper.listSalesOrderItem(salesOrderItem);
        for(SalesOrderItem item : salesOrderItemList){
            EfastOrderItem efastOrderItem = new EfastOrderItem();
            efastOrderItem.setItemColorBar(item.getItemColorBar());
            efastOrderItem.setItemNum(item.getItemNum());
            efastOrderItem.setItemDiscount(item.getItemProductPrice());
            itemList.add(efastOrderItem);
        }
        efastOrder.setOrderDealCode(salesOrder.getSalesDealCode()); //交易号
        efastOrder.setOrderPostFirm(salesOrder.getSalesPostFirm()); //物流代码
        efastOrder.setOrderPostNum(salesOrder.getSalesPostNum()); //物流单号
        efastOrder.setOrderId(salesOrder.getSalesOrderId());        //订单编号
        efastOrder.setItemList(itemList);
        efastOrder.setReturnOrderType(returnType);//退单类型
        JSONObject jsonObject = new JSONObject();
        try{
            jsonObject = efastOrderService.returnOrderFormEfast(efastOrder);
            logger.info("------将原订单生成退货订单返回数据：" + jsonObject + "------");
            /*if(jsonObject != null){
                Object obj;
                obj = jsonObject.get("return_sn");
                if(obj != null && !"".equals(obj)){
                    fg = true;
                }else{
                    obj = jsonObject.get("msg");
                    if("系统订单 已作废".equals(obj)){
                        fg = true;
                    }
                }
            }*/
        }catch (Exception e){
            logger.info("------将原订单生成退货订单报错------");
        }
    }

    @Override
    public Integer updateCustomerInfo(CustomerInfo record) {
        return customerInfoMapper.updateCustomerInfo(record);
    }

    @Override
    public PagedResult<CustomerInfo> listCustomer(int pageNO, int pageSize, CustomerInfo customerInfo, boolean isTotalNum) {
        PageHelper.startPage(pageNO, pageSize, isTotalNum);
        //查询客诉列表
        List<CustomerInfo> customerList = customerInfoMapper.listCustomer(customerInfo);
        return PageUtil.getPage(customerList);
    }

    @Override
    public Map<String,Object> getCustomerInfo(CustomerInfo customerInfo) {
        Map<String,Object> map = new HashMap<String,Object>();
        CustomerCommon customerCommon = new CustomerCommon();
        //查询客诉列表
        List<CustomerInfo> customerList = customerInfoMapper.listCustomer(customerInfo);
        if (customerList == null || customerList.size() == 0) {
            return null;
        }
        CustomerInfo customer = customerList.get(0);
        map.put("customer",customer);
        int orderId = 0;
        switch (customer.getCustomerIsSolve().intValue()) {
            case 3://换新
                Renewed renewedInfo = new Renewed();
                renewedInfo.setRenewedState(1);
                renewedInfo.setCustomerId(customerInfo.getCustomerId());
                //查询售后换新详情
                renewedInfo = renewedMapper.getRenewedInfo(renewedInfo);
                //orderId = renewedInfo.getOrderId();
                customerCommon = CustomerCommonUtil.getCustomerCommon(3,renewedInfo);
                customerCommon = customerService.selectProdcueAndFitting(customerCommon,3);
                break;
            case 4://维修
                Repair repairInfo = new Repair();
                repairInfo.setRepairState(1);
                repairInfo.setCustomerId(customerInfo.getCustomerId());
                //查询售后维修集合
                repairInfo = repairMapper.getRepairInfo(repairInfo);
                /*if (repairInfo.getComplaintDetectList() != null && repairInfo.getComplaintDetectList().size() > 0) {
                    repairInfo.setDetectState(repairInfo.getComplaintDetectList().get(0).getDetectState());
                }*/
                //orderId = repairInfo.getOrderId();
                customerCommon = CustomerCommonUtil.getCustomerCommon(4,repairInfo);
                customerCommon = customerService.selectProdcueAndFitting(customerCommon,4);
                break;
            case 5://补发
                Reissue reissueInfo = new Reissue();
                reissueInfo.setReissueState(1);
                reissueInfo.setCustomerId(customerInfo.getCustomerId());
                //查询售后补发集合
                List<Reissue> reissueList = reissueMapper.listReissue(reissueInfo);
                if (reissueList == null || reissueList.size() == 0) {
                    return null;
                }
                reissueInfo = reissueList.get(0);
                //orderId = reissueInfo.getOrderId();
                customerCommon = CustomerCommonUtil.getCustomerCommon(5,reissueInfo);
                customerCommon = customerService.selectProdcueAndFitting(customerCommon,5);
                break;
            case 6://退货
                //查询售后退货集合
                BackGoods backGoodsInfo = new BackGoods();
                backGoodsInfo.setBackGoodsState(1);
                backGoodsInfo.setCustomerId(customerInfo.getCustomerId());
                List<BackGoods> backGoodsList = backGoodsMapper.listBackGoods(backGoodsInfo);
                if (backGoodsList == null || backGoodsList.size() == 0) {
                    return null;
                }
                backGoodsInfo = backGoodsList.get(0);
                /*if (backGoodsInfo.getComplaintDetectList() != null && backGoodsInfo.getComplaintDetectList().size() > 0) {
                    backGoodsInfo.setDetectState(backGoodsInfo.getComplaintDetectList().get(0).getDetectState());
                }*/
                //orderId = backGoodsInfo.getOrderId();
                customerCommon = CustomerCommonUtil.getCustomerCommon(6,backGoodsInfo);
                customerCommon = customerService.selectProdcueAndFitting(customerCommon,6);
                break;
            case 7://无理由退货
                //查询售后无理由退货集合
                NoreasonBack noreasonBackInfo = new NoreasonBack();
                noreasonBackInfo.setNoreasonBackState(1);
                noreasonBackInfo.setCustomerId(customerInfo.getCustomerId());
                List<NoreasonBack> noreasonBackList = noreasonBackMapper.listNoreasonBack(noreasonBackInfo);
                if (noreasonBackList == null || noreasonBackList.size() == 0) {
                    return null;
                }
                noreasonBackInfo = noreasonBackList.get(0);
                /*if (noreasonBackInfo.getComplaintDetectList() != null && noreasonBackInfo.getComplaintDetectList().size() > 0) {
                    noreasonBackInfo.setDetectState(noreasonBackInfo.getComplaintDetectList().get(0).getDetectState());
                }*/
                //orderId = noreasonBackInfo.getOrderId();
                customerCommon = CustomerCommonUtil.getCustomerCommon(7,noreasonBackInfo);
                customerCommon = customerService.selectProdcueAndFitting(customerCommon,7);
                break;
        }

        RelationOrder relationOrder = new RelationOrder();
        relationOrder.setRelationType(customerCommon.getCustomerIsSolve());
        relationOrder.setRelationId(customerCommon.getRelationId());
        List<RelationOrder> relationOrderList = relationOrderService.getRelationOrderList(relationOrder);
        if(relationOrderList != null && relationOrderList.size() > 0){
            String[] salesIds = new String[relationOrderList.size()];
            for (int k=0; k<relationOrderList.size();k++){
                salesIds[k] = String.valueOf(relationOrderList.get(k).getSalesId());
            }
            SalesOrder so = new SalesOrder();
            so.setSalesIds(salesIds);
            List<SalesOrder> orderList = salesOrderMapper.listSalesOrder(so);
            if (orderList != null && orderList.size() > 0) {
                SalesOrder order = orderList.get(0);
                SalesOrderItem salesOrderItem = new SalesOrderItem();
                salesOrderItem.setItemOrderId(order.getSalesId());
                order.setSalesOrderItemList(salesOrderMapper.listSalesOrderItem(salesOrderItem));
            } else {
                map.put("orderList",null);
            }
            map.put("orderList",orderList);
        }
        map.put("customerCommon",customerCommon);
        return map;
    }

    @Override
    public CustomerCommon selectProdcueAndFitting(CustomerCommon customerCommon, int isSolve) {
        if (customerCommon == null || customerCommon.getRelationId() == null) {
            return customerCommon;
        }
        List<SendProdcue> sendProdcues = null;
        List<SendFitting> sendFittings = null;
        List<ClosedFitting> closedfittings = null;
        List<ClosedProdcue> closedProdcues = null;
        SendProdcue sendProdcue = new SendProdcue();
        SendFitting sendFitting = new SendFitting();
        ClosedFitting fitting = new ClosedFitting();
        ClosedProdcue closedProdcue = new ClosedProdcue();
        switch (isSolve) {
            case 3://换新
                sendProdcue.setRelationId(customerCommon.getRelationId());
                sendProdcue.setSendProduceType(3);
                //查询寄出产品集合
                sendProdcues = sendProdcueMapper.listSendProdcue(sendProdcue);
                sendFitting.setRelationId(customerCommon.getRelationId());
                sendFitting.setSendFittingType(3);
                //查询寄出配件集合
                sendFittings = sendFittingMapper.listSendFitting(sendFitting);
                fitting.setRelationId(customerCommon.getRelationId());
                fitting.setClosedFittingType(3);
                //查询寄回配件集合
                closedfittings = closedFittingMapper.listClosedFitting(fitting);
                closedProdcue.setRelationId(customerCommon.getRelationId());
                closedProdcue.setClosedProdcueType(3);
                //查询寄回产品集合
                closedProdcues = closedProdcueMapper.listclosedProdcue(closedProdcue);
                break;
            case 4://维修
                sendProdcue.setRelationId(customerCommon.getRelationId());
                sendProdcue.setSendProduceType(4);
                //查询寄出产品集合
                sendProdcues = sendProdcueMapper.listSendProdcue(sendProdcue);
                sendFitting.setRelationId(customerCommon.getRelationId());
                sendFitting.setSendFittingType(4);
                //查询寄出配件集合
                sendFittings = sendFittingMapper.listSendFitting(sendFitting);
                fitting.setRelationId(customerCommon.getRelationId());
                fitting.setClosedFittingType(4);
                //查询寄回配件集合
                closedfittings = closedFittingMapper.listClosedFitting(fitting);
                closedProdcue.setRelationId(customerCommon.getRelationId());
                closedProdcue.setClosedProdcueType(4);
                //查询寄回产品集合
                closedProdcues = closedProdcueMapper.listclosedProdcue(closedProdcue);
                break;
            case 5://补发
                sendProdcue.setRelationId(customerCommon.getRelationId());
                sendProdcue.setSendProduceType(5);
                //查询寄出产品集合
                sendProdcues = sendProdcueMapper.listSendProdcue(sendProdcue);
                sendFitting.setRelationId(customerCommon.getRelationId());
                sendFitting.setSendFittingType(5);
                //查询寄出配件集合
                sendFittings = sendFittingMapper.listSendFitting(sendFitting);
                break;
            case 6://退货
                fitting.setRelationId(customerCommon.getRelationId());
                fitting.setClosedFittingType(6);
                //查询寄回配件集合
                closedfittings = closedFittingMapper.listClosedFitting(fitting);
                closedProdcue.setRelationId(customerCommon.getRelationId());
                closedProdcue.setClosedProdcueType(6);
                //查询寄回产品集合
                closedProdcues = closedProdcueMapper.listclosedProdcue(closedProdcue);
                break;
            case 7://无理由退货
                fitting.setRelationId(customerCommon.getRelationId());
                fitting.setClosedFittingType(7);
                //查询寄回配件集合
                closedfittings = closedFittingMapper.listClosedFitting(fitting);
                closedProdcue.setRelationId(customerCommon.getRelationId());
                closedProdcue.setClosedProdcueType(7);
                //查询寄回产品集合
                closedProdcues = closedProdcueMapper.listclosedProdcue(closedProdcue);
                break;
        }
        customerCommon.setClosedFittings(closedfittings);
        customerCommon.setClosedProdcues(closedProdcues);
        customerCommon.setSendProdcues(sendProdcues);
        customerCommon.setSendFittings(sendFittings);
        return customerCommon;
    }

    @Override
    public ProductType getcompanyAffiliation(Integer customerId) {
        return customerInfoMapper.getcompanyAffiliation(customerId);
    }

    @Override
    public BackGoods getBackGoods(BackGoods backGoods) {
        //获取退货集合
        List<BackGoods> backList = backGoodsMapper.listBackGoods(backGoods);
        if (backList == null || backList.size() == 0) {
            return null;
        }
        BackGoods goods = backList.get(0);
        ClosedProdcue closedProdcue = new ClosedProdcue();
        closedProdcue.setRelationId(goods.getBackGoodsId());
        closedProdcue.setClosedProdcueType(6);
        //查询寄回产品集合
        List<ClosedProdcue> prodcueList = closedProdcueMapper.listclosedProdcue(closedProdcue);
        ClosedFitting fitting = new ClosedFitting();
        fitting.setRelationId(goods.getBackGoodsId());
        fitting.setClosedFittingType(6);
        //查询寄回配件集合
        List<ClosedFitting> fittingList = closedFittingMapper.listClosedFitting(fitting);
        if (prodcueList != null && prodcueList.size() > 0) {
            goods.setClosedProdcues(prodcueList);
        }
        if (fittingList != null && fittingList.size() > 0) {
            goods.setClosedFittings(fittingList);
        }
        return goods;
    }

    @Override
    public NoreasonBack getNoreasonBack(NoreasonBack noreasonBack) {
        //获取无理由退货
        List<NoreasonBack> backList = noreasonBackMapper.listNoreasonBack(noreasonBack);
        if (backList == null || backList.size() == 0) {
            return null;
        }
        NoreasonBack noreasonBackInfo = backList.get(0);
        ClosedProdcue closedProdcue = new ClosedProdcue();
        closedProdcue.setRelationId(noreasonBackInfo.getNoreasonBackId());
        closedProdcue.setClosedProdcueType(7);
        //查询寄回产品集合
        List<ClosedProdcue> prodcueList = closedProdcueMapper.listclosedProdcue(closedProdcue);
        ClosedFitting fitting = new ClosedFitting();
        fitting.setRelationId(noreasonBackInfo.getNoreasonBackId());
        fitting.setClosedFittingType(7);
        //查询寄回配件集合
        List<ClosedFitting> fittingList = closedFittingMapper.listClosedFitting(fitting);
        if (prodcueList != null && prodcueList.size() > 0) {
            noreasonBackInfo.setClosedProdcues(prodcueList);
        }
        if (fittingList != null && fittingList.size() > 0) {
            noreasonBackInfo.setClosedFittings(fittingList);
        }
        return noreasonBackInfo;
    }

    @Override
    public Reissue getReissue(Reissue reissue) {
        //查询售后补发信息
        List<Reissue> reissueList = reissueMapper.listReissue(reissue);
        if (reissueList == null || reissueList.size() == 0) {
            return null;
        }
        Reissue reissueInfo = reissueList.get(0);
        SendProdcue sendProdcue = new SendProdcue();
        sendProdcue.setRelationId(reissueInfo.getReissueId());
        sendProdcue.setSendProduceType(5);
        //查询寄送产品集合
        List<SendProdcue> sendProdcueList = sendProdcueMapper.listSendProdcue(sendProdcue);
        SendFitting sendFitting = new SendFitting();
        sendFitting.setRelationId(reissueInfo.getReissueId());
        sendFitting.setSendFittingType(5);
        //查询寄送配件集合
        List<SendFitting> sendFittingList = sendFittingMapper.listSendFitting(sendFitting);

        if (sendProdcueList != null && sendProdcueList.size() > 0) {
            reissueInfo.setSendProdcues(sendProdcueList);
        }
        if (sendFittingList != null && sendFittingList.size() > 0) {
            reissueInfo.setSendFittings(sendFittingList);
        }
        return reissueInfo;
    }

    @Override
    public Renewed getRenewedInfo(Renewed renewed) {
        renewed = renewedMapper.getRenewedInfo(renewed);
        if (renewed == null){
            return null;
        }
        ClosedProdcue closedProdcue = new ClosedProdcue();
        closedProdcue.setRelationId(renewed.getRenewedId());
        closedProdcue.setClosedProdcueType(3);
        //查询寄回产品集合
        List<ClosedProdcue> prodcueList = closedProdcueMapper.listclosedProdcue(closedProdcue);
        ClosedFitting fitting = new ClosedFitting();
        fitting.setRelationId(renewed.getRenewedId());
        fitting.setClosedFittingType(3);
        //查询寄回配件集合
        List<ClosedFitting> fittingList = closedFittingMapper.listClosedFitting(fitting);
        SendProdcue sendProdcue = new SendProdcue();
        sendProdcue.setRelationId(renewed.getRenewedId());
        sendProdcue.setSendProduceType(3);
        //查询寄送产品集合
        List<SendProdcue> sendProdcueList = sendProdcueMapper.listSendProdcue(sendProdcue);
        SendFitting sendFitting = new SendFitting();
        sendFitting.setRelationId(renewed.getRenewedId());
        sendFitting.setSendFittingType(3);
        //查询寄送配件集合
        List<SendFitting> sendFittingList = sendFittingMapper.listSendFitting(sendFitting);

        if (prodcueList != null && prodcueList.size() > 0) {
            renewed.setClosedProdcues(prodcueList);
        }
        if (fittingList != null && fittingList.size() > 0) {
            renewed.setClosedFittings(fittingList);
        }
        if (sendProdcueList != null && sendProdcueList.size() > 0) {
            renewed.setSendProdcues(sendProdcueList);
        }
        if (sendFittingList != null && sendFittingList.size() > 0) {
            renewed.setSendFittings(sendFittingList);
        }

        return renewed;
    }

    @Override
    public Repair getRepairInfo(Repair repair) {
        repair = repairMapper.getRepairInfo(repair);
        if (repair == null) {
            return null;
        }
        ClosedProdcue closedProdcue = new ClosedProdcue();
        closedProdcue.setRelationId(repair.getRepairId());
        closedProdcue.setClosedProdcueType(4);
        //查询寄回产品集合
        List<ClosedProdcue> prodcueList = closedProdcueMapper.listclosedProdcue(closedProdcue);
        ClosedFitting fitting = new ClosedFitting();
        fitting.setRelationId(repair.getRepairId());
        fitting.setClosedFittingType(4);
        //查询寄回配件集合
        List<ClosedFitting> fittingList = closedFittingMapper.listClosedFitting(fitting);
        SendProdcue sendProdcue = new SendProdcue();
        sendProdcue.setRelationId(repair.getRepairId());
        sendProdcue.setSendProduceType(4);
        //查询寄送产品集合
        List<SendProdcue> sendProdcueList = sendProdcueMapper.listSendProdcue(sendProdcue);
        SendFitting sendFitting = new SendFitting();
        sendFitting.setRelationId(repair.getRepairId());
        sendFitting.setSendFittingType(4);
        //查询寄送配件集合
        List<SendFitting> sendFittingList = sendFittingMapper.listSendFitting(sendFitting);

        if (prodcueList != null && prodcueList.size() > 0) {
            repair.setClosedProdcues(prodcueList);
        }
        if (fittingList != null && fittingList.size() > 0) {
            repair.setClosedFittings(fittingList);
        }
        if (sendProdcueList != null && sendProdcueList.size() > 0) {
            repair.setSendProdcues(sendProdcueList);
        }
        if (sendFittingList != null && sendFittingList.size() > 0) {
            repair.setSendFittings(sendFittingList);
        }
        return repair;
    }
}