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.address.City;
import com.iamberry.rst.core.address.District;
import com.iamberry.rst.core.address.Province;
import com.iamberry.rst.core.cm.*;
import com.iamberry.rst.core.order.EfastOrder;
import com.iamberry.rst.core.order.OrderItem;
import com.iamberry.rst.core.order.Product;
import com.iamberry.rst.core.order.ProductColor;
import com.iamberry.rst.core.page.PagedResult;
import com.iamberry.rst.faces.cm.CustomerService;
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.order.EfastOrderServiceImpl;
import com.iamberry.rst.service.product.mapper.ProductMapper;
import com.iamberry.rst.util.PageUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class CustomerServiceImpl implements CustomerService {

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


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

    @Override
    @Transactional
    public Integer saveCustomerInfo(CustomerInfo customerInfo,SalesOrder salesOrder) throws Exception{

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

        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 Exception("添加客诉失败");
        }

        if ("2".equals(customerInfo.getCustomerIsVisit())) {
            Visit visit = new Visit();
            visit.setCustomerId(customerInfo.getCustomerId());
            visit.setAdminId(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 Exception("添加客诉失败");
            }
        }

        if (2 == customerInfo.getCustomerCounselType() &&
                (customerInfo.getCustomerIsSolve() == 3 || customerInfo.getCustomerIsSolve() == 4 || customerInfo.getCustomerIsSolve() == 5 ||
                customerInfo.getCustomerIsSolve() == 6 || customerInfo.getCustomerIsSolve() == 7)
                ){
            salesOrder = salesOrderMapper.getSalesOrderById(salesOrder.getSalesId());

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

            /*  初始化产品类型，名称，配件名称 */
            this.setName(customerCommon);

            ComplaintDetectInfo complaintDetectInfo = new ComplaintDetectInfo();  //品质检测
            ComplaintSignclosedInfo complaintSignclosedInfo = new ComplaintSignclosedInfo(); //客诉-签收表
            Map<String,Object> map;
            switch (customerInfo.getCustomerIsSolve()) {  //处理结果： 1：已解决  2：未解决 3：换新  4：维修 5：补发 6：退货 7：无理由退货
                case 3: //换新
                    map = this.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 Exception("换新创建Efast订单失败");
                    }
                    complaintSignclosedInfo.setOldEfastId(salesOrder.getSalesOrderId());    //原有订单的Efast的订单编号
                    this.saveComplaintSignclosedInfo(complaintSignclosedInfo,customerCommon);//创建仓储任务
                    complaintDetectInfo.setSignclosedId(complaintSignclosedInfo.getSignclosedId()); //设置仓储签收id
                    this.saveComplaintDetectInfo(complaintDetectInfo,customerCommon);   //创建品检
                    break;
                case 4: //维修
                    map = this.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 Exception("维修创建Efast订单失败");
                    }
                    complaintSignclosedInfo.setOldEfastId(salesOrder.getSalesOrderId());    //原有订单的Efast的订单编号
                    this.saveComplaintSignclosedInfo(complaintSignclosedInfo,customerCommon);//创建仓储任务
                    complaintDetectInfo.setSignclosedId(complaintSignclosedInfo.getSignclosedId()); //设置仓储签收id
                    this.saveComplaintDetectInfo(complaintDetectInfo,customerCommon);   //创建品检
                    break;
                case 5: //补发  不用创建仓储签收任务
                    map = this.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 Exception("补发创建Efast订单失败");
                    }
                    break;
                case 6: //退货
                    complaintSignclosedInfo.setOldEfastId(salesOrder.getSalesOrderId());    //原有订单的Efast的订单编号
                    this.saveComplaintSignclosedInfo(complaintSignclosedInfo,customerCommon);//创建仓储任务
                    complaintDetectInfo.setSignclosedId(complaintSignclosedInfo.getSignclosedId()); //设置仓储签收id
                    this.saveComplaintDetectInfo(complaintDetectInfo,customerCommon);   //创建品检
                    break;
                case 7: //无理由退货
                    complaintSignclosedInfo.setOldEfastId(salesOrder.getSalesOrderId());    //原有订单的Efast的订单编号
                    this.saveComplaintSignclosedInfo(complaintSignclosedInfo,customerCommon);//创建仓储任务
                    complaintDetectInfo.setSignclosedId(complaintSignclosedInfo.getSignclosedId()); //设置仓储签收id
                    this.saveComplaintDetectInfo(complaintDetectInfo,customerCommon);   //创建品检
                    break;
            }
            customerCommon.setSignclosedId(complaintSignclosedInfo.getSignclosedId()); //设置仓储id

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

            customerCommon.setRelationId(relationId);

            CustomerCommon.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());
            }
        }
        return flag;
    }


    /**
     * 初始化
     * @param cc
     */
    private void setName(CustomerCommon cc){
        for (int i=0;i<cc.getSendProdcues().size();i++) {
            Product product = productMapper.getProduce(cc.getSendProdcues().get(i).getProductId());
            cc.getSendProdcues().get(i).setSendProduceName(product.getProductName());
            cc.getSendProdcues().get(i).setProductType(product.getProductType());
            cc.getSendProdcues().get(i).setProductNumber(product.getProductNumber());

            ProductColor productColor = productMapper.getProduceColor(cc.getSendProdcues().get(i).getColorId());
            cc.getSendProdcues().get(i).setProductColor(productColor);
        }
        for (int i=0;i<cc.getSendFittings().size();i++) {
            FittingsInfo fittingsInfo = fittingsInfoMapper.getFittingsById( cc.getSendFittings().get(i).getFittingsId());
            cc.getSendFittings().get(i).setFittingsId(fittingsInfo.getFittingsId());
        }
        for (int i=0;i<cc.getClosedProdcues().size();i++) {
            Product product = productMapper.getProductById(cc.getSendProdcues().get(i).getProductId());
            cc.getClosedProdcues().get(i).setClosedProductName(product.getProductName());
            cc.getClosedProdcues().get(i).setProductType(product.getProductType());
            cc.getClosedProdcues().get(i).setProductNumber(product.getProductNumber());

            ProductColor productColor = productMapper.getProduceColor(cc.getSendProdcues().get(i).getColorId());
            cc.getSendProdcues().get(i).setProductColor(productColor);
        }
        for (int i=0;i<cc.getClosedFittings().size();i++) {
            FittingsInfo fittingsInfo = fittingsInfoMapper.getFittingsById(cc.getClosedFittings().get(i).getFittingsId());
            cc.getClosedFittings().get(i).setFittingsId(fittingsInfo.getFittingsId());
        }
    }

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

    /**
     * 添加仓储
     * @param customerCommon
     * @return
     */
    @Transactional
    public void saveComplaintSignclosedInfo(ComplaintSignclosedInfo complaintSignclosedInfo,CustomerCommon customerCommon)throws  Exception{
        Integer flag;
        complaintSignclosedInfo.setSignclosedType(1); //客诉寄回
        complaintSignclosedInfo.setSignclosedIsQuality(1); //是否平品检 1：需要品检
        complaintSignclosedInfo.setSignclosedIsInto(2); //是否已转入品检 2：未转入品检
        complaintSignclosedInfo.setSignclosedState(2); //处理状态  2：未签收
        complaintSignclosedInfo.setSignclosedObjectsState(3); //物件状态  3：暂未签收
        complaintSignclosedInfo.setSignclosedCustomerId(customerCommon.getCustomerId()); //客诉id
        flag = complaintSignclosedInfoMapper.insert(complaintSignclosedInfo);
        if(flag < 1){
            throw new Exception("添加签收失败");
        }

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

        awaitingSignclosedProductInfo.setSignclosedProductType(2);  //类型为配件
        for(int i=0 ;i< customerCommon.getClosedFittings().size();i++){
            ClosedFitting closedFitting = customerCommon.getClosedFittings().get(i);
            awaitingSignclosedProductInfo.setProductNum(closedFitting.getClosedFittingNumber());
            awaitingSignclosedProductInfo.setSignclosedProductId(closedFitting.getFittingsId());         //配件id
            awaitingSignclosedProductInfo.setSignclosedProductColor(null);
            awaitingSignclosedProductInfo.setProductName(closedFitting.getFittingName());       //配件名称
            awaitingSignclosedProductInfoArrayList.add(awaitingSignclosedProductInfo);
        }

        flag = complaintSignclosedProductInfoMapper.insertList(awaitingSignclosedProductInfoArrayList);
        if(flag < 1){
            throw new Exception("添加签收产品失败");
        }
    }

    /**
     * 向Efast推送订单  仅换新，维修 ,补发
     * @return
     */
    @Transactional
    public Map<String,Object> sendEfastOrder(CustomerCommon customerCommon,SalesOrder salesOrder) throws Exception{
        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.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;
        }

        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);
        map.put("EfastOrderId",oList.get(0).getEfastOrderId());
        return map;
    }


    @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);
        //查询售后维修集合
        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());
                                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());
                                break;
                            }
                        }
                        break;
                    case 5: //补发
                        for (Reissue reissue : reissueList) {
                            if (reissue.getCustomerId().intValue() == customer.getCustomerId()) {
                                customer.setSendStatus(reissue.getReissueSendStatus());
                                customer.setSalesTime(reissue.getSalesPayTime());
                                break;
                            }
                        }
                        break;
                    case 6: //退货
                        for (BackGoods backGoods : backGoodsList) {
                            if (backGoods.getCustomerId().intValue() == customer.getCustomerId()) {
                                customer.setBackStatus(backGoods.getBackGoodsBackStatus());
                                customer.setSalesTime(backGoods.getSalesPayTime());
                                break;
                            }
                        }
                        break;
                    case 7: //无理由退货
                        for (NoreasonBack noreasonBack : noreasonBackList) {
                            if (noreasonBack.getCustomerId().intValue() == customer.getCustomerId()) {
                                customer.setBackStatus(noreasonBack.getNoreasonBackBackStatus());
                                customer.setSalesTime(noreasonBack.getSalesPayTime());
                                break;
                            }
                        }
                        break;
                }
            }
        }
        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 = CustomerCommon.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);
                orderId = repairInfo.getOrderId();
                customerCommon = CustomerCommon.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 = CustomerCommon.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);
                orderId = backGoodsInfo.getOrderId();
                customerCommon = CustomerCommon.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);
                orderId = noreasonBackInfo.getOrderId();
                customerCommon = CustomerCommon.getCustomerCommon(7,noreasonBackInfo);
                customerCommon = customerService.selectProdcueAndFitting(customerCommon,7);
                break;
        }
        SalesOrder salesOrder = new SalesOrder();
        salesOrder.setSalesId(orderId);
        //查询订单信息
        List<SalesOrder> orderList = salesOrderMapper.listSalesOrder(salesOrder);
        if (orderList != null && orderList.size() > 0) {
            SalesOrder order = orderList.get(0);
            SalesOrderItem salesOrderItem = new SalesOrderItem();
            salesOrderItem.setItemOrderId(order.getSalesId());
            order.setSalesOrderItemList(salesOrderMapper.listSalesOrderItem(salesOrderItem));
            map.put("salesOrder",order);
        } else {
            map.put("salesOrder",null);
        }
        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 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);
        ClosedProdcue closedProdcue = new ClosedProdcue();
        closedProdcue.setRelationId(reissueInfo.getReissueId());
        closedProdcue.setClosedProdcueType(6);
        //查询寄回产品集合
        List<ClosedProdcue> prodcueList = closedProdcueMapper.listclosedProdcue(closedProdcue);
        ClosedFitting fitting = new ClosedFitting();
        fitting.setRelationId(reissueInfo.getReissueId());
        fitting.setClosedFittingType(6);
        //查询寄回配件集合
        List<ClosedFitting> fittingList = closedFittingMapper.listClosedFitting(fitting);
        if (prodcueList != null && prodcueList.size() > 0) {
            reissueInfo.setClosedProdcues(prodcueList);
        }
        if (fittingList != null && fittingList.size() > 0) {
            reissueInfo.setClosedFittings(fittingList);
        }
        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);
        if (prodcueList != null && prodcueList.size() > 0) {
            renewed.setClosedProdcues(prodcueList);
        }
        if (fittingList != null && fittingList.size() > 0) {
            renewed.setClosedFittings(fittingList);
        }
        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);
        if (prodcueList != null && prodcueList.size() > 0) {
            repair.setClosedProdcues(prodcueList);
        }
        if (fittingList != null && fittingList.size() > 0) {
            repair.setClosedFittings(fittingList);
        }
        return repair;
    }
}