iamberry-common-parent/watero-rst-web/src/main/java/com/iamberry/rst/controllers/cm/AdminCustomerController.java

package com.iamberry.rst.controllers.cm;

import com.iamberry.rst.core.address.City;
import com.iamberry.rst.core.cm.*;
import com.iamberry.rst.core.order.Product;
import com.iamberry.rst.core.order.ProductColor;
import com.iamberry.rst.core.order.ProductType;
import com.iamberry.rst.core.page.PagedResult;
import com.iamberry.rst.core.sys.Admin;
import com.iamberry.rst.faces.address.AddressService;
import com.iamberry.rst.faces.cm.*;
import com.iamberry.rst.faces.product.ProductService;
import com.iamberry.rst.faces.sms.SmsService;
import com.iamberry.rst.faces.sys.SysService;
import com.iamberry.rst.util.CustomerCommonUtil;
import com.iamberry.rst.util.SmsConfig;
import com.iamberry.rst.utils.AdminUtils;
import com.iamberry.rst.utils.OrderNoUtil;
import com.iamberry.rst.utils.ResultMsg;
import com.iamberry.rst.utils.StitchAttrUtil;
import com.iamberry.wechat.tools.NameUtils;
import com.iamberry.wechat.tools.ResponseJson;
import com.iamberry.wechat.tools.ResultInfo;
import net.sf.json.JSONArray;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import java.text.MessageFormat;
import java.util.*;

/**
 * Created by wxm
 */
@Controller
@RequestMapping("/admin/customer")
public class AdminCustomerController {

    private Logger logger = LoggerFactory.getLogger(AdminCustomerController.class);

    @Autowired
    private CompanyInfoService companyInfoService;
    @Autowired
    private StoreInfoService storeInfoService;
    @Autowired
    private SalesOrderService salesOrderService;
    @Autowired
    private CustomerService customerService;
    @Autowired
    private ProductService productService;
    @Autowired
    private SysService sysService;
    @Autowired
    private ComplaintTypeInfoService complaintTypeInfoService;
    @Autowired
    private VisitService visitService;
    @Autowired
    private QuestionDescribeService questionDescribeService;
    @Autowired
    private RenewedService renewedService;
    @Autowired
    private RepairService repairService;
    @Autowired
    private BackGoodsService backGoodsService;
    @Autowired
    private FittingsInfoService fittingsInfoService;
    @Autowired
    private ReissueService reissueService;
    @Autowired
    private NoreasonBackService noreasonBackService;
    @Autowired
    private ComplaintQuestionInfoService complaintQuestionInfoService;
    @Autowired
    private SmsService smsService;
    @Autowired
    private ComplaintSignclosedInfoService complaintSignclosedInfoService;
    @Autowired
    private ComplaintSmallClassInfoService complaintSmallClassInfoService;
    @Autowired
    private CustomerCommonService customerCommonService;
    @Autowired
    private AddressService addressService;
    @Autowired
    private PostageService postageService;



    /**
     * 获取客诉列表
     *
     * @param request
     * @return
     */
    @RequiresPermissions("customer:list:customer")
    @RequestMapping("/_customer_list")
    public ModelAndView getCustomer(HttpServletRequest request, CustomerInfo customer,
                                    @RequestParam(value = "pageSize", defaultValue = "10", required = false) Integer pageSize,
                                    @RequestParam(value = "pageNO", defaultValue = "1", required = false) Integer pageNO,
                                    @RequestParam(value = "totalNum", defaultValue = "0", required = false) Integer totalNum) {
        ModelAndView mv = new ModelAndView("cm/customer/custome_list");
//        PagedResult<Customer> pagedResult = ptsBomService.listCustomer(pageNO, pageSize, ptsBom, totalNum == 0);
//        if (totalNum != 0) {
//            pagedResult.setTotal(totalNum);
//        }
//        //获取产品集合，用于页面选择产品
//        List<Produce> list = produceService.getProduceList();
//        mv.addObject("produceList", list);
//       StitchAttrUtil.setModelAndView(customer, mv, "/admin/bom/_bom_list", pagedResult);
        return mv;
    }


    /**
     * 跳转到添加客诉页面
     *
     * @return
     */
    @RequiresPermissions("customer:add:customer")
    @RequestMapping(value = "/to_add_customer")
    public ModelAndView toAddCustomer(HttpServletRequest request) {
        ModelAndView mv = new ModelAndView("cm/customer/add_customer");

        //获取产品集合，用于页面选择产品
//        List<Produce> produceList = produceService.getProduceList();

//        mv.addObject("produceList", produceList);
        return mv;
    }

    /**
     * 跳转到修改客诉页面
     *
     * @return
     */
    @RequiresPermissions("customer:update:customer")
    @RequestMapping(value = "/to_update_customer")
    public ModelAndView toUpdateCustomer(HttpServletRequest request,Integer customerId) {
        ModelAndView mv = new ModelAndView("cm/customer/update_customer");

        ProductType productType = new ProductType();
        //查询产品类型集合
        List<ProductType> typeList = productService.listProductType(productType);
        //查询客诉类型集合
        List<ComplaintTypeInfo> complaintTypeList = complaintTypeInfoService.listComplaintTypeInfo(new ComplaintTypeInfo());
        //查询跟进客服集合
        Admin admin = new Admin();
        admin.setAdminDept(3);
        admin.setAdminStatus(1);
        List<Admin> adminList = sysService.listSelectAdmin(admin);
        //获取登录人id
        Integer loginAdminId = AdminUtils.getLoginAdminId();
        //查询客诉基本信息
        CustomerInfo customerInfo = customerService.getCustomerInfo(customerId);
        /*客诉信息处理-stast*/
        //对于区域处理
        if(customerInfo!=null && customerInfo.getCustomerArea() != null){
//            String[] customerAreaAndCity = customerInfo.getCustomerArea().split("-");
//            customerInfo.setProvinceName(customerAreaAndCity[0]);
//            City city
//            addressService.listCity(customerAreaAndCity[0]);
//            customerInfo.setCityName(customerAreaAndCity[0]);
        }
        /*客诉信息处理-end*/
        CustomerCommon customerCommon = new CustomerCommon();
        if(customerInfo.getCustomerIsSolve() != null){
            switch (customerInfo.getCustomerIsSolve()){   //处理结果： 1：已解决  2：未解决 3：换新  4：维修 5：补发 6：退货 7：无理由退货
                case 3://获取换新
                    Renewed renewed = new Renewed();
                    renewed.setCustomerId(customerInfo.getCustomerId());
                    renewed = renewedService.getRenewed(renewed);
                    customerCommon = CustomerCommonUtil.getCustomerCommon(3,renewed);
                    break;
                case 4://维修
                    Repair repair = new Repair();
                    repair.setCustomerId(customerInfo.getCustomerId());
                    repair = repairService.getRepair(repair);
                    customerCommon = CustomerCommonUtil.getCustomerCommon(4,repair);
                    break;
                case 5:
                    Reissue reissue = new  Reissue();
                    reissue.setCustomerId(customerInfo.getCustomerId());
                    reissue = reissueService.getReissue(reissue);
                    customerCommon = CustomerCommonUtil.getCustomerCommon(5,reissue);
                    break;
                case 6:
                    BackGoods backGoods = new  BackGoods();
                    backGoods.setCustomerId(customerInfo.getCustomerId());
                    backGoods = backGoodsService.getBackGoods(backGoods);
                    customerCommon = CustomerCommonUtil.getCustomerCommon(6,backGoods);
                    break;
                case 7:
                    NoreasonBack noreasonBack = new  NoreasonBack();
                    noreasonBack.setCustomerId(customerInfo.getCustomerId());
                    noreasonBack = noreasonBackService.getNoreasonBack(noreasonBack);
                    customerCommon = CustomerCommonUtil.getCustomerCommon(7,noreasonBack);
                    break;
            }

            /*查询所有需要寄入寄出的产品*/
            customerCommon.setCustomerIsSolve(customerInfo.getCustomerIsSolve());
            customerCommon = customerCommonService.getListProduceAndFitting(customerCommon);
            mv.addObject("customerCommon", customerCommon);

            if(customerCommon.getOrderId() == null || "".equals(customerCommon.getOrderId())){
                customerInfo.setIsNeedSelectOrder(2);       //不需要订单
            }else{
                customerInfo.setIsNeedSelectOrder(1);
            }

            /*查询所有的产品，颜色和配件信息*/

            List<Product> productList = productService.listProduce(new Product());
            for(Product product : productList){
                ProductColor productColor = new ProductColor();
                productColor.setColorProductId(product.getProductId());
                List<ProductColor>  productColorList = productService.listProduceColor(productColor);
                product.setColorList(productColorList);

                FittingsInfo fittingsInfo = new FittingsInfo();
                fittingsInfo.setProductId(product.getProductId());
                List<FittingsInfo> fittingsInfoList = fittingsInfoService.listFittings(fittingsInfo);
                product.setFittingsList(fittingsInfoList);
            }
            mv.addObject("productList", productList);
            if(customerCommon.getOrderId() != null){
                /*查询订单信息*/
                SalesOrder salesOrder = salesOrderService.getSalesOrderById(customerCommon.getOrderId());
                SalesOrderItem salesOrderItem = new SalesOrderItem();
                salesOrderItem.setItemOrderId(salesOrder.getSalesId());
                List<SalesOrderItem> salesOrderItemList = salesOrderService.listSalesOrderItem(salesOrderItem);
                salesOrder.setSalesOrderItemList(salesOrderItemList);
                mv.addObject("salesOrder", salesOrder);
            }

        }
        if ("2".equals(customerInfo.getCustomerIsVisit())){ //1:不需要回访  2:需要回访
            Visit visit = new Visit();
            visit.setCustomerId(customerInfo.getCustomerId());
            visit = visitService.getVisit(visit);
            mv.addObject("visit", visit);
        }

        //查询关联问题
        ComplaintQuestionInfo complaintQuestionInfo = complaintQuestionInfoService.getQuestionById(customerInfo.getQuestionId());
        //查询问题小类
        ComplaintSmallClassInfo complaintSmallClassInfo = new ComplaintSmallClassInfo();
        complaintSmallClassInfo.setComplaintId(complaintQuestionInfo.getComplaintId());
        List<ComplaintSmallClassInfo> complaintSmallClassInfoList = complaintSmallClassInfoService.listComplaintSmallClassInfo(complaintSmallClassInfo);
        //查询问题大类
        ComplaintTypeInfo complaintTypeInfo = new ComplaintTypeInfo();
        List<ComplaintTypeInfo> complaintTypeInfoList = complaintTypeInfoService.listComplaintTypeInfo(complaintTypeInfo);


        mv.addObject("customerInfo", customerInfo);
        mv.addObject("typeList", typeList);
        mv.addObject("complaintTypeList", complaintTypeList);
        mv.addObject("complaintTypeList", complaintTypeList);
        mv.addObject("adminList", adminList);
        mv.addObject("loginAdminId", loginAdminId);
        mv.addObject("complaintQuestionInfo", complaintQuestionInfo);
        mv.addObject("complaintSmallClassInfoList", complaintSmallClassInfoList);
        mv.addObject("complaintTypeInfoList", complaintTypeInfoList);
        //mv.addObject("questionDescribe", questionDescribe);
        return mv;
    }

    /**
     * 查询问题描述
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:add:customer")
    @RequestMapping(value = "/select_question_describe")
    public ResponseJson selectQuestionDescribe(HttpServletRequest request, Integer customerId) throws Exception {
        if(customerId == null || customerId == 0){
            return new ResponseJson(500, "未获取到问题描述", 500);
        }
        //查询问题描述表
        QuestionDescribe questionDescribe = new QuestionDescribe();
        questionDescribe.setCustomerId(customerId);
        questionDescribe = questionDescribeService.listQuestionDescribe(questionDescribe).get(0);

        ResponseJson rj = new ResponseJson(200, "查询成功", 200);
        rj.addResponseKeyValue("questionDescribe", questionDescribe);
        return rj;
    }


    /**
     * 查询问题描述
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:add:customer")
    @RequestMapping(value = "/select_company")
    public ResponseJson getCompany(HttpServletRequest request) throws Exception {

        //获取销售公司
        List<CompanyInfo> companyInfoList = companyInfoService.listCompanyInfo(new CompanyInfo());

        ResponseJson rj = new ResponseJson(200, "查询成功", 200);
        rj.addResponseKeyValue("companyInfoList", companyInfoList);
        return rj;
    }

    /**
     * 搜索订单列表弹出框
     *
     * @return
     */
    @RequiresPermissions("customer:add:customer")
    @RequestMapping(value = "/select_order")
    public ModelAndView selectOrder(HttpServletRequest request) {
        ModelAndView mv = new ModelAndView("cm/customer/order_list");

        //获取销售公司
        List<CompanyInfo> companyInfoList = companyInfoService.listCompanyInfo(new CompanyInfo());

        mv.addObject("companyInfoList", companyInfoList);
        return mv;
    }

    /**
     * 添加订单列表弹出框
     *
     * @return
     */
    @RequiresPermissions("customer:add:customer")
    @RequestMapping(value = "/add_order")
    public ModelAndView addOder(HttpServletRequest request) {
        ModelAndView mv = new ModelAndView("cm/customer/order_add");
        return mv;
    }

    /**
     * 添加订单
     *
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:add:customer")
    @RequestMapping(value = "/add_order_info")
    public ResponseJson addOrderInfo(HttpServletRequest request, SalesOrder salesOrder, String itemJson) throws Exception {

        List<SalesOrderItem> list = new ArrayList<>();
        JSONArray jsonArray = JSONArray.fromObject(itemJson);
        list = (List) JSONArray.toCollection(jsonArray, SalesOrderItem.class);

        Integer salesAmount = 0;

        for (int i = 0; i < list.size(); i++) {
            SalesOrderItem salesOrderItem = list.get(i);
            if (salesOrderItem.getItemIsSource() == 1) { //产品来源 1：产品颜色表，2：配件表
                Product product = productService.getProductById(salesOrderItem.getItemColorId());
                ProductColor productColor = productService.getProduceColor(salesOrderItem.getItemColorId());
                salesOrderItem.setItemProductType(product.getProductType());
                salesOrderItem.setItemProductName(product.getProductName());
                salesOrderItem.setItemProductPic(productColor.getColorPicture());
                salesOrderItem.setItemProductColor(productColor.getColorName());
                salesOrderItem.setItemColorBar(productColor.getColorBar());
                salesOrderItem.setItemProductPrice(productColor.getColorPrice());
                salesOrderItem.setItemProductDiscount(productColor.getColorDiscount());
                salesOrderItem.setItemIsSource(1);
                salesAmount += productColor.getColorDiscount();
            } else if (salesOrderItem.getItemIsSource() == 2) {
                Product product = productService.getProductByFittingsId(salesOrderItem.getItemProductId());
                FittingsInfo fittingsInfo = fittingsInfoService.getFittingsById(salesOrderItem.getItemColorId());
                salesOrderItem.setItemProductType(product.getProductType());
                salesOrderItem.setItemProductName(product.getProductName());
                salesOrderItem.setItemProductColor(fittingsInfo.getFittingsName());
                salesOrderItem.setItemColorBar(fittingsInfo.getFittingsBar());
                salesOrderItem.setItemProductPrice(fittingsInfo.getFittingsPrice());
                salesOrderItem.setItemProductDiscount(fittingsInfo.getFittingsDiscount());
                salesOrderItem.setItemIsSource(2);
                salesAmount += fittingsInfo.getFittingsDiscount();
            }
        }

        salesOrder.setSalesOpenId("0");
        salesOrder.setSalesAmount(salesAmount);
        salesOrder.setSalesPayMoney(salesAmount);
        salesOrder.setSalesOrderStatus(1);
        salesOrder.setSalesCreateTime(new Date());
        //salesOrder.setSalesPayTime(new Date());

        salesOrder.setSalesLastMoney(salesAmount);
        salesOrder.setSalesWaitMoney(0);
        salesOrder.setSalesPayMoney(salesAmount);
        salesOrder.setSalesSalesTime(new Date());
        salesOrder.setSalesDiscountMoney(salesAmount);
        salesOrder.setSalesPledgeMoney(0);
        salesOrder.setSalesRemainDeposit(0);
        salesOrder.setSalesType(1);

        salesOrder.setSalesStatus(1);//确认状态:0(未确认)1(确认)2(挂起)3(作废)
        salesOrder.setSalesShippingStatus(1);    //发货状态: 0(未发货)1(已发货,即已扫描出库)3(备货中)*****+++
        salesOrder.setSalesPayStatus(2);   //已付款
        salesOrder.setSalesProcessStatus(0);  //单据状态:0(正常单)1(问题单)
        salesOrder.setSalesIsSend(0);        //0：否 1：是  是否通知配货
        salesOrder.setSalesIsLocked(0); //是否锁定 0：否 1：是
        salesOrder.setSalesIsSeparate(0);   //是否缺货  0：否 1：是
        salesOrder.setSalesShippingFee(0); //邮费

        Integer adminId = AdminUtils.getLoginAdminId();
        String orderCode = OrderNoUtil.createOrderCode(adminId);
        salesOrder.setSalesDealCode(orderCode);
        salesOrder.setSalesOrderId(orderCode);

        //salesOrder = salesOrderService.addOrderAndIteminfo(salesOrder,list);
        salesOrder.setSalesOrderItemList(list);

        try {
            Map<String, Object> map = customerService.sendEfastOrder(salesOrder);
//            if (map.get("status") == 1) {
//                salesOrder.setSalesOrderId((String) map.get("EfastOrderId"));
//            }
        } catch (RuntimeException e) {
            return new ResponseJson(500, "添加订单成功--"+ e.getMessage(), 500);
        }
        Integer orderId = salesOrder.getSalesId();
        ResponseJson rj = new ResponseJson(200, "添加订单成功", 200);
        rj.addResponseKeyValue("orderId", orderId);
        return rj;
    }


    /**
     * 获取店铺集合
     *
     * @param request
     * @param storeInfo
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:add:customer")
    @RequestMapping(value = "/select_storeInfo")
    public ResponseJson listStoreInfo(HttpServletRequest request, StoreInfo storeInfo) {
        storeInfo.setStoreStatus(1);
        List<StoreInfo> storeInfoList = storeInfoService.listStore(storeInfo);

        if (storeInfoList == null || storeInfoList.size() < 1) {
            return new ResponseJson(500, "查询失败", 500);
        } else {
            ResponseJson rj = new ResponseJson(200, "查询成功", 200);
            rj.addResponseKeyValue("storeInfoList", storeInfoList);
            return rj;
        }
    }

    /**
     * 获取订单集合
     *
     * @param request
     * @param salesOrder
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:add:customer")
    @RequestMapping(value = "/select_salesOrder")
    public ResponseJson listOrder(HttpServletRequest request, SalesOrder salesOrder,
                @RequestParam(value = "pageSize", defaultValue = "10", required = false) Integer pageSize,
                @RequestParam(value = "pageNO", defaultValue = "1", required = false) Integer pageNO,
                @RequestParam(value = "totalNum", defaultValue = "0", required = false) Integer totalNum) {

        //分页获取订单信息
        PagedResult<SalesOrder> pagedResult = salesOrderService.listSalesOrderPage(pageNO, pageSize, salesOrder, totalNum == 0);

        List<SalesOrder> salesOrderList = pagedResult.getDataList();

        for (SalesOrder order : salesOrderList) {
            SalesOrderItem salesOrderItem = new SalesOrderItem();
            salesOrderItem.setItemOrderId(order.getSalesId());
            List<SalesOrderItem> salesOrderItemList = salesOrderService.listSalesOrderItem(salesOrderItem);
            order.setSalesOrderItemList(salesOrderItemList);
        }

        if (salesOrderList == null || salesOrderList.size() < 1) {
            return new ResponseJson(500, "查询失败", 500);
        } else {
            ResponseJson rj = new ResponseJson(200, "查询成功", 200);
            rj.addResponseKeyValue("salesOrderList", salesOrderList);
            return rj;
        }
    }

    /**
     * 分页查询客诉列表信息
     *
     * @param request
     * @param customerInfo
     * @param pageSize
     * @param pageNO
     * @param totalNum
     * @return
     * @throws Exception
     */
    @RequiresPermissions("customer:select:customer")
    @RequestMapping("/select_customer_list")
    public ModelAndView selectCustomerList(HttpServletRequest request, CustomerInfo customerInfo,
                                           @RequestParam(value = "isFirst", defaultValue = "2", required = false) Integer isFirst,
                                           @RequestParam(value = "pageSize", defaultValue = "10", required = false) Integer pageSize,
                                           @RequestParam(value = "pageNO", defaultValue = "1", required = false) Integer pageNO,
                                           @RequestParam(value = "totalNum", defaultValue = "0", required = false) Integer totalNum) throws Exception {
        ModelAndView mv = new ModelAndView("cm/customer/custome_list");
        if(customerInfo.getAdminId() == null && isFirst == 1){
            //获取登录员工id
            Integer adminId = AdminUtils.getLoginAdminId();
            customerInfo.setAdminId(adminId);
        }
        PagedResult<CustomerInfo> pagedResult = customerService.listCustomer(pageNO, pageSize, customerInfo, totalNum == 0);
        if (totalNum != 0) {
            pagedResult.setTotal(totalNum);
        }
        ProductType productType = new ProductType();
        //查询产品类型集合
        List<ProductType> typeList = productService.listProductType(productType);

        //查询客诉类型集合
        List<ComplaintTypeInfo> complaintTypeList = complaintTypeInfoService.listComplaintTypeInfo(new ComplaintTypeInfo());
        //查询客诉类型集合
        List<ComplaintSmallClassInfo> complaintSmallClassInfoList = complaintSmallClassInfoService.listComplaintSmallClassInfo(new ComplaintSmallClassInfo());

        //查询问题集合   第 30 条bug
//        List<QuestionDescribe> questionDescribeList = questionDescribeService.listQuestionDescribe(new QuestionDescribe());

        //查询跟进客服集合
        Admin admin = new Admin();
        admin.setAdminDept(3);
        admin.setAdminStatus(1);
        List<Admin> adminList = sysService.listSelectAdmin(admin);

        //获取登录人id
        Integer loginAdminId = AdminUtils.getLoginAdminId();
        mv.addObject("complaintSmallClassInfoList", complaintSmallClassInfoList);
        mv.addObject("loginAdminId", loginAdminId);
        mv.addObject("typeList", typeList);
        mv.addObject("complaintTypeList", complaintTypeList);
        mv.addObject("adminList", adminList);
        customerInfo.setVisit(null);
        customerInfo.setCustomerCommon(null);
        customerInfo.setComplaintDetectList(null);
        StitchAttrUtil.setModelAndView(customerInfo, mv, "/admin/customer/select_customer_list", pagedResult);
        return mv;
    }

    /**
     * 进入客诉基本信息页面
     *
     * @param request
     * @return
     * @throws Exception
     */
    @RequiresPermissions("customer:select:customer")
    @RequestMapping("/_customer_info")
    public ModelAndView toCustomerInfo(HttpServletRequest request) throws Exception {
        ModelAndView mv = new ModelAndView("cm/customer/custome_detail");
        String customerId = request.getParameter("customerId");
        mv.addObject("customerId", customerId);
        return mv;
    }

    /**
     * 查询客诉基本信息
     *
     * @param request
     * @return
     * @throws Exception
     */
    @ResponseBody
    @RequiresPermissions("customer:select:customer")
    @RequestMapping("/get_customer_info")
    public ResponseJson getCustomerInfo(HttpServletRequest request) throws Exception {
        String customerId = request.getParameter("customerId");
        if (!StringUtils.isNotEmpty(customerId)) {
            return new ResponseJson(500, "该客诉信息不存在!", 500);
        }
        CustomerInfo customerInfo = new CustomerInfo();
        customerInfo.setCustomerId(Integer.parseInt(customerId));
        Map<String, Object> map = customerService.getCustomerInfo(customerInfo);
        ResponseJson rj = new ResponseJson(200, "修改成功!", 200);
        rj.addResponseKeyValue("customerCommon", map.get("customerCommon"));
        rj.addResponseKeyValue("customer", map.get("customer"));
        rj.addResponseKeyValue("salesOrder", map.get("salesOrder"));
        return rj;
    }

    /**
     * 进入添加回访页面
     *
     * @param request
     * @return
     * @throws Exception
     */
    @RequiresPermissions("customer:select:customer")
    @RequestMapping("/_add_visit")
    public ModelAndView toAddVisit(HttpServletRequest request) throws Exception {
        ModelAndView mv = new ModelAndView("cm/customer/add_visit");
        String customerId = request.getParameter("customerId");

        //查询跟进客服集合
        Admin admin = new Admin();
        admin.setAdminDept(3);
        admin.setAdminStatus(1);
        List<Admin> adminList = sysService.listSelectAdmin(admin);
        //获取登录人id
        Integer loginAdminId = AdminUtils.getLoginAdminId();
        mv.addObject("loginAdminId", loginAdminId);
        mv.addObject("customerId", customerId);
        mv.addObject("adminList", adminList);
        return mv;
    }

    /**
     * 添加回访信息
     *
     * @param request
     * @param visit
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:add:visit")
    @RequestMapping("/add_visit_info")
    public ResponseJson addVisitInfo(HttpServletRequest request, Visit visit) throws Exception {
        String visitAdminId = request.getParameter("visitAdminId");
        if (!StringUtils.isNotEmpty(visitAdminId)) {
            return new ResponseJson(500, "请选择回访人!", 500);
        }
        Integer loginAdminId = AdminUtils.getLoginAdminId();
        visit.setAdminId(loginAdminId);
        visit.setDesignatedAdminId(Integer.parseInt(visitAdminId));
        visit.setVisitStatus(1);
        visit.setVisitCreateTime(new Date());
        int num = visitService.addVisitInfo(visit, visit.getCustomerId());
        if (num > 0) {
            return new ResponseJson(200, "修改成功!", 200);
        } else {
            return new ResponseJson(500, "修改失败!", 500);
        }
    }

    /**
     * 修改客诉状态为已解决
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:update:customerIsSolve")
    @RequestMapping("/update_customerIsSolve")
    public ResponseJson updateCustomerIsSolve(HttpServletRequest request) throws Exception {
        String customerId = request.getParameter("customerId");
        if (!StringUtils.isNotEmpty(customerId)) {
            return new ResponseJson(500, "该客诉信息不存在!", 500);
        }

        //根据id获取客诉信息
        CustomerInfo customer = customerService.getCustomerInfo(Integer.parseInt(customerId));
        if (customer == null) {
            return new ResponseJson(500, "该客诉信息不存在!", 500);
        }
        if (customer.getCustomerIsSolve().intValue() != 2) {
            return new ResponseJson(500, "该客诉信息不能修改为已解决状态!", 500);
        }
        CustomerInfo customerInfo = new CustomerInfo();
        customerInfo.setCustomerId(Integer.parseInt(customerId));
        customerInfo.setCustomerIsSolve(1);
        //修改客诉信息
        int num = customerService.updateCustomerInfo(customerInfo);
        if (num > 0) {
            return new ResponseJson(200, "修改成功!", 200);
        } else {
            return new ResponseJson(500, "修改失败!", 500);
        }
    }

    /**
     * 查询客服
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:add:customer")
    @RequestMapping("/select_sys_admin")
    public ResponseJson selectSysAdmin(HttpServletRequest request) throws Exception {
        ResponseJson rj = new ResponseJson(200, "修改成功!", 200);
        Integer adminId = AdminUtils.getLoginAdminId();
        Admin admin = new Admin();
        admin.setAdminDept(3);
        admin.setAdminStatus(1);
        List<Admin> adminList = sysService.listSelectAdmin(admin);
        if (adminList.size() > 0) {
            rj.addResponseKeyValue("adminList", adminList);
            rj.addResponseKeyValue("adminId", adminId);
            return rj;
        } else {
            return new ResponseJson(500, "查询失败!", 500);
        }
    }

    /**
     * 查询产品类型
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:add:customer")
    @RequestMapping("/select_produce_type")
    public ResponseJson selectProduceType(HttpServletRequest request) throws Exception {
        ResponseJson rj = new ResponseJson(200, "修改成功!", 200);

        ProductType productType = new ProductType();
        productType.setTypeStatus(1);
        List<ProductType> productTypeList = productService.listProductType(productType);

        if (productTypeList != null && productTypeList.size() > 0) {
            rj.addResponseKeyValue("productTypeList", productTypeList);
            return rj;
        } else {
            return new ResponseJson(500, "查询失败!", 500);
        }
    }

    /**
     * 查询产品
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:add:customer")
    @RequestMapping("/select_produce")
    public ResponseJson selectProduce(HttpServletRequest request) {
        ResponseJson rj = new ResponseJson(200, "查询成功!", 200);

        Product product = new Product();
        List<Product> productList = productService.listProduce(product);

        for (Product pro : productList) {
            ProductColor productColor = new ProductColor();
            productColor.setColorProductId(pro.getProductId());
            List<ProductColor> productColorList = productService.listProduceColor(productColor);
            pro.setColorList(productColorList);
        }
        if (productList != null && productList.size() > 0) {
            rj.addResponseKeyValue("productList", productList);
            return rj;
        } else {
            return new ResponseJson(500, "查询失败!", 500);
        }
    }

    /**
     * 查询产品
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:add:customer")
    @RequestMapping("/select_produce_fittings")
    public ResponseJson selectProduceFittings(HttpServletRequest request, FittingsInfo fittingsInfo) {
        ResponseJson rj = new ResponseJson(200, "查询成功!", 200);

        List<FittingsInfo> produceFittingsList = fittingsInfoService.listFittings(fittingsInfo);

        if (produceFittingsList != null && produceFittingsList.size() > 0) {
            rj.addResponseKeyValue("produceFittingsList", produceFittingsList);
            return rj;
        } else {
            return new ResponseJson(500, "查询失败!", 500);
        }
    }

    /**
     * 添加客诉
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:add:customer")
    @RequestMapping("/save_customer")
    public ResponseJson addCustomer(HttpServletRequest request, CustomerInfo customerInfo, SalesOrder salesOrder, CustomerCommon customerCommon,
                                    String sendProdcuesJson, String sendFittingsJson, String closedProdcuesJson, String closedFittingsJson) throws Exception {
        ResponseJson rjx = this.isValiData(customerInfo);
        if(rjx.getResultCode() == 500){
            return rjx;
        }

        Integer customerIsSolve = customerInfo.getCustomerIsSolve();    //处理类型
        String phone = customerInfo.getCustomerTel();       //手机号码
        Integer typeCompany = customerInfo.getTypeCompany();    // 所属商城   1:美国watero； 2:上朵电动牙刷  3:优尼雅净水机

        Integer flag = 0;
        if(customerInfo.getIsNeedSelectOrder() == 1){ ////1：需要有订单    2：不需要有订单
            JSONArray jsonArray;
            List<SendProdcue> sendProdcueList;
            List<SendFitting> sendFittingList;
            List<ClosedProdcue> closedProdcueList;
            List<ClosedFitting> closedFittingList;

            jsonArray = JSONArray.fromObject(sendProdcuesJson);
            sendProdcueList = (List) JSONArray.toCollection(jsonArray, SendProdcue.class);

            jsonArray = JSONArray.fromObject(sendFittingsJson);
            sendFittingList = (List) JSONArray.toCollection(jsonArray, SendFitting.class);

            jsonArray = JSONArray.fromObject(closedProdcuesJson);
            closedProdcueList = (List) JSONArray.toCollection(jsonArray, ClosedProdcue.class);

            jsonArray = JSONArray.fromObject(closedFittingsJson);
            closedFittingList = (List) JSONArray.toCollection(jsonArray, ClosedFitting.class);

            customerCommon.setSendProdcues(sendProdcueList);
            customerCommon.setSendFittings(sendFittingList);
            customerCommon.setClosedProdcues(closedProdcueList);
            customerCommon.setClosedFittings(closedFittingList);
        }

        customerInfo.setCustomerCommon(customerCommon);
        String orderId = "";
        if (customerInfo.getCustomerIsSolve() == 3 || customerInfo.getCustomerIsSolve() == 4 || customerInfo.getCustomerIsSolve() == 5) {
            Integer adminId = AdminUtils.getLoginAdminId();
            orderId = OrderNoUtil.createOrderCode(adminId);
        }
        customerInfo.setTransactionNumber(orderId);

        Integer customerId = customerInfo.getCustomerId();
        logger.info("-----------------添加客诉开始----------------------");
        try {
            flag = customerService.saveCustomerInfo(customerInfo, salesOrder);
        } catch (RuntimeException e) {
            return new ResponseJson(500, e.getMessage(), 500);
        }
        customerId = customerInfo.getCustomerId();
        logger.info("-----------------添加客诉结束----------------------");
        if (flag < 1) {
            return new ResponseJson(500, "添加客诉失败!", 500);
        }
        String msg = "";
        //处理结果： 1：已解决  2：未解决 3：换新  4：维修 5：补发 6：退货 7：无理由退货
        if (customerIsSolve == 3 || customerIsSolve == 4 || customerIsSolve == 5 || customerIsSolve == 6 || customerIsSolve == 7) {
            String solveMsg = "";
            switch (customerIsSolve) {
                case 3:
                    solveMsg = "为您更换新机";
                    break;
                case 4:
                    solveMsg = "为您维修机器";
                    break;
                case 5:
                    solveMsg = "为您补发产品";
                    break;
                case 6:
                    solveMsg = "为您办理退货";
                    break;
                case 7:
                    solveMsg = "为您办理退货";
                    break;
            }

            String addCustomerSuccessMsg = "";
            String typeMsg = "";
            switch (typeCompany) {
                case 1:
                    addCustomerSuccessMsg = SmsConfig.ADD_CUSTOMER_SUCCESS_WATERO;
                    typeMsg = "美国WaterO售后";
                    break;
                case 2:
                    addCustomerSuccessMsg = SmsConfig.ADD_CUSTOMER_SUCCESS_SHANGDUO;
                    typeMsg = "上朵售后";
                    break;
                case 3:
                    addCustomerSuccessMsg = SmsConfig.ADD_CUSTOMER_SUCCESS_YULIA;
                    typeMsg = "YULIA售后";
                    break;
                case 4:
                    addCustomerSuccessMsg = SmsConfig.ADD_CUSTOMER_SUCCESS_AIBERLE;
                    typeMsg = "爱贝源售后";
                    break;
            }
//            Object [] msg = new Object[]{solveMsg,typeMsg};
//            String text = MessageFormat.format(addCustomerSuccessMsg, msg);
//            logger.info("添加客诉成功后，给 "+ phone +" 手机用户发送短信：" + text );
//            String result = smsService.sendOtherCMS(phone, text);
//
//            if (!"SUCCESS".equals(result)) {
//                return new ResponseJson(505, "添加客诉发送短信失败，失败原因：" + result + "<br>客诉信息发送失败并不影响客诉添加。客诉编号为："+ customerId, 505);
//            }
            msg = "，请前往Efast进行换货/退货操作。";
        }
        return new ResponseJson(200, "录入客诉成功！客诉编号：" + customerId + msg, 200);
    }

    /**
     * 修改客诉
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:update:customer")
    @RequestMapping("/update_customer")
    public ResponseJson updateCustomer(HttpServletRequest request, CustomerInfo customerInfo, SalesOrder salesOrder, CustomerCommon customerCommon,
                                    String sendProdcuesJson, String sendFittingsJson, String closedProdcuesJson, String closedFittingsJson) throws Exception {
        ResponseJson rjx = this.isValiData(customerInfo);
        if(rjx.getResultCode() == 500){
            return rjx;
        }
        Integer flag = 0;


        Integer customerIsSolve = customerInfo.getCustomerIsSolve();    //处理类型
        String phone = customerInfo.getCustomerTel();       //手机号码
        Integer typeCompany = customerInfo.getTypeCompany();    // 所属商城   1:美国watero； 2:上朵电动牙刷  3:优尼雅净水机

        if(customerInfo.getIsNeedSelectOrder() == 1){
            JSONArray jsonArray;
            List<SendProdcue> sendProdcueList;
            List<SendFitting> sendFittingList;
            List<ClosedProdcue> closedProdcueList;
            List<ClosedFitting> closedFittingList;

            jsonArray = JSONArray.fromObject(sendProdcuesJson);
            sendProdcueList = (List) JSONArray.toCollection(jsonArray, SendProdcue.class);

            jsonArray = JSONArray.fromObject(sendFittingsJson);
            sendFittingList = (List) JSONArray.toCollection(jsonArray, SendFitting.class);

            jsonArray = JSONArray.fromObject(closedProdcuesJson);
            closedProdcueList = (List) JSONArray.toCollection(jsonArray, ClosedProdcue.class);

            jsonArray = JSONArray.fromObject(closedFittingsJson);
            closedFittingList = (List) JSONArray.toCollection(jsonArray, ClosedFitting.class);

            customerCommon.setSendProdcues(sendProdcueList);
            customerCommon.setSendFittings(sendFittingList);
            customerCommon.setClosedProdcues(closedProdcueList);
            customerCommon.setClosedFittings(closedFittingList);
        }
        customerInfo.setCustomerCommon(customerCommon);
        String orderId = "";
        if (customerInfo.getCustomerIsSolve() == 3 || customerInfo.getCustomerIsSolve() == 4 || customerInfo.getCustomerIsSolve() == 5) {
            Integer adminId = AdminUtils.getLoginAdminId();
            orderId = OrderNoUtil.createOrderCode(adminId);
        }
        customerInfo.setTransactionNumber(orderId);

        Integer customerId = customerInfo.getCustomerId();
        logger.info("-----------------修改客诉开始----------------------");
        try {
            flag = customerService.updateCustomerInfo(customerInfo, salesOrder);
        } catch (RuntimeException e) {
            return new ResponseJson(500, e.getMessage(), 500);
        }
        customerId = customerInfo.getCustomerId();
        logger.info("-----------------修改客诉结束----------------------");
        if (flag < 1) {
            return new ResponseJson(500, "修改客诉失败!", 500);
        }

        return new ResponseJson(200, "修改客诉成功!客诉编号为：" + customerId, 200);
    }


    /**
     * 验证方法
     *
     * @param customerInfo
     * @return
     */
    public ResponseJson isValiData(CustomerInfo customerInfo) {
        ResponseJson rj = new ResponseJson();
        if(customerInfo.getAdminId() == null){
            return new ResponseJson(500, "未填写客诉id", 500);
        }
        return rj;
    }

    /**
     * 发送短信
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:add:customer")
    @RequestMapping("/send_phone_sms")
    public ResponseJson sendPhoneSms(HttpServletRequest request, String type, String phone, Integer typeCompany, ComplaintQuestionInfo complaintQuestionInfo) throws Exception {
        String url = NameUtils.getConfig("website");
        Integer flag = 1;

        if (typeCompany == null || typeCompany == 0) {
            return new ResponseJson(500, "未获取到产品类型!", 500);
        }
        String con = "";
        if (type != null && !"".equals(type)) {
            if ("p".equals(type)) { //problem" 问题处理;  mailAddress:邮寄地址;
                if (complaintQuestionInfo.getQuestionId() == null || "".equals(complaintQuestionInfo.getQuestionId())) {
                    complaintQuestionInfo.setQuestionState(1);
                    complaintQuestionInfo.setQuestionIsQcDetect(0);
                    complaintQuestionInfo = complaintQuestionInfoService.insertBackInfo(complaintQuestionInfo);
                } else {
                    complaintQuestionInfo.setSmallClassId(null);    //不能修改小类类型
                    flag = complaintQuestionInfoService.updateQuestionById(complaintQuestionInfo);
                    if (flag < 1) {
                        return new ResponseJson(500, "问题修改失败!", 500);
                    }
                }
                url += "/" + complaintQuestionInfo.getQuestionId()+"/"+typeCompany;
                switch (typeCompany) {
                    case 1:
                        con = SmsConfig.SEND_PRODUCT_SEND_WATERO;
                        break;
                    case 2:
                        con = SmsConfig.SEND_PRODUCT_SEND_SHANGDUO;
                        break;
                    case 3:
                        con = SmsConfig.SEND_PRODUCT_SEND_YULIA;
                        break;
                    case 4:
                        con = SmsConfig.SEND_PRODUCT_SEND_AIBERLE;
                        break;
                }
            } else if ("m".equals(type)) {

                if (complaintQuestionInfo.getQuestionId() == null) {
                    return new ResponseJson(500, "未获取到邮寄信息!", 500);
                }
                complaintQuestionInfo.setQuestionName(null);
                complaintQuestionInfo.setSmallClassId(null);
                url += "/5";
                switch (typeCompany) {
                    case 1:
                        con = SmsConfig.SEND_PRODUCT_SMS_WATERO;
                        break;
                    case 2:
                        con = SmsConfig.SEND_PRODUCT_SMS_SHANGDUO;
                        break;
                    case 3:
                        con = SmsConfig.SEND_PRODUCT_SMS_YULIA;
                        break;
                    case 4:
                        con = SmsConfig.SEND_PRODUCT_SMS_AIBERLE;
                        break;
                }
            }
        }

        String userPhone = encodePhoneNumber(phone);

        String text = MessageFormat.format(con, url);
        logger.info("给 " + phone + " 手机用户发送短信：" + text);
        String result = smsService.sendOtherCMS(phone, text);

        if ("SUCCESS".equals(result)) {
            return new ResponseJson(200, "发送短信成功!", 200);
        } else {
            return new ResponseJson(500, "发送短信失败，失败原因：" + result, 500);
        }
    }

    String encodePhoneNumber(String number)
    {
        int encnum = Integer.parseInt(number.substring(2));

        int prefix = (number.charAt(1) - '2') /2;   // '3'=>0, '5'=>1, '[67]'=>2, '8'=>3

        encnum |= (prefix <<= 30);

        final byte[] raw = new byte[4];

        raw[0] = (byte)(encnum >>> 24);
        raw[1] = (byte)(encnum >>> 16);
        raw[2] = (byte)(encnum >>> 8);
        raw[3] = (byte) encnum;

        return Base64.encodeBase64URLSafeString(raw);
    }


    /**
     * 进入回访完成页面
     *
     * @param request
     * @return
     * @throws Exception
     */
    @RequiresPermissions("customer:update:visit")
    @RequestMapping("/_update_visit_info")
    public ModelAndView toUpdateVisitFinish(HttpServletRequest request) throws Exception {
        ModelAndView mv = new ModelAndView("cm/customer/visit_finish");
        String customerId = request.getParameter("customerId");
        mv.addObject("customerId", customerId);
        return mv;
    }

    /**
     * 添加回访完成内容
     *
     * @param request
     * @param visit
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:update:visit")
    @RequestMapping("/update_visit_finish")
    public ResponseJson updateVisitFinish(HttpServletRequest request, Visit visit) throws Exception {
        String customerId = request.getParameter("finish_customerId");
        if (!StringUtils.isNotEmpty(customerId)) {
            return new ResponseJson(500, "该客诉信息不存在!", 500);
        }
        visit.setCustomerId(Integer.parseInt(customerId));
        visit.setVisitStatus(2);
        //修改回访信息内容
        int num = visitService.updateVisit(visit);
        if (num > 0) {
            return new ResponseJson(200, "添加成功!", 200);
        } else {
            return new ResponseJson(500, "添加失败!", 500);
        }
    }

    /**
     * 进入回访信息详情
     *
     * @param request
     * @return
     * @throws Exception
     */
    @RequiresPermissions("customer:get:visit")
    @RequestMapping("/_visit_info")
    public ModelAndView toVisitInfo(HttpServletRequest request) throws Exception {
        ModelAndView mv = new ModelAndView("cm/customer/visit_detail");
        String customerId = request.getParameter("customerId");
        // 1：未回访，2：已回访
        String num = request.getParameter("num");
        if (!StringUtils.isNotEmpty(num)) {
            num = "2";
        }
        mv.addObject("customerId", customerId);
        mv.addObject("num", num);
        return mv;
    }

    /**
     * 获取回访信息详情
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:get:visit")
    @RequestMapping("/get_visit_info")
    public ResponseJson getVisitInfo(HttpServletRequest request) throws Exception {
        String customerId = request.getParameter("customerId");
        if (!StringUtils.isNotEmpty(customerId)) {
            return new ResponseJson(500, "该客诉信息不存在!", 500);
        }
        Visit visit = new Visit();
        visit.setCustomerId(Integer.parseInt(customerId));
        //查询回访信息集合
        List<Visit> visitList = visitService.listVisit(visit);
        if (visitList == null || visitList.size() == 0) {
            return new ResponseJson(500, "该客诉没有回访信息!", 500);
        }
        visit = visitList.get(0);
        ResponseJson rj = new ResponseJson(200, "查询成功", 200);
        rj.addResponseKeyValue("visit", visit);
        return rj;
    }

    /**
     * 进入问题描述页面
     *
     * @param request
     * @return
     * @throws Exception
     */
    @RequiresPermissions("customer:get:describe")
    @RequestMapping("/_question_describe")
    public ModelAndView toQuestionDescribe(HttpServletRequest request) throws Exception {
        ModelAndView mv = new ModelAndView("cm/customer/describe_detail");
        String customerId = request.getParameter("customerId");
        mv.addObject("customerId", customerId);
        return mv;
    }

    /**
     * 获取问题描述信息
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:get:describe")
    @RequestMapping("/get_describe_info")
    public ResponseJson getDescribeInfo(HttpServletRequest request) throws Exception {
        String customerId = request.getParameter("customerId");
        if (!StringUtils.isNotEmpty(customerId)) {
            return new ResponseJson(500, "该客诉信息不存在!", 500);
        }
        QuestionDescribe describe = new QuestionDescribe();
        describe.setCustomerId(Integer.parseInt(customerId));
        //查询问题集合
        List<QuestionDescribe> questionList = questionDescribeService.listQuestionDescribe(describe);
        if (questionList == null || questionList.size() == 0) {
            return new ResponseJson(500, "该客诉信息没有问题描述!", 500);
        }
        describe = questionList.get(0);
        ResponseJson rj = new ResponseJson(200, "查询成功", 200);
        rj.addResponseKeyValue("describe", describe);
        return rj;
    }

    /**
     * 进入修改换新页面
     *
     * @param request
     * @return
     * @throws Exception
     */
    @RequiresPermissions("customer:update:renewed")
    @RequestMapping("/_update_renewed")
    public ModelAndView toUpdateRenewed(HttpServletRequest request) throws Exception {
        ModelAndView mv = new ModelAndView("cm/customer/update_renewed");
        String customerId = request.getParameter("customerId");
        mv.addObject("customerId", customerId);
        return mv;
    }

    /**
     * 获取换新详情
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:get:renewed")
    @RequestMapping("/get_renewed_info")
    public ResponseJson getRenewedInfo(HttpServletRequest request) throws Exception {
        String customerId = request.getParameter("customerId");
        if (!StringUtils.isNotEmpty(customerId)) {
            return new ResponseJson(500, "该客诉信息不存在!", 500);
        }
        Renewed renewed = new Renewed();
        renewed.setCustomerId(Integer.parseInt(customerId));
        renewed.setRenewedState(1);
        //获取换新详情和检测信息
        renewed = customerService.getRenewedInfo(renewed);
        if (renewed == null) {
            return new ResponseJson(500, "该客诉没有换新信息!", 500);
        } else {
            ResponseJson rj = new ResponseJson(200, "查询成功", 200);
            rj.addResponseKeyValue("renewed", renewed);
            return rj;
        }
    }

    /**
     * 修改换新信息
     *
     * @param request
     * @param renewed
     * @return
     * @throws Exception
     */
    @ResponseBody
    @RequiresPermissions("customer:update:renewed")
    @RequestMapping("/update_renewed_info")
    public ResponseJson updateRenewedInfo(HttpServletRequest request, Renewed renewed) throws Exception {
        /*String closedProducts = request.getParameter("closed_products");
        String closedFittings = request.getParameter("closed_fittings");*/
        String mergeAddress = request.getParameter("merge_address");
        if (!StringUtils.isNotEmpty(renewed.getRenewedId().toString())) {
            return new ResponseJson(500, "该换新信息不能修改!", 500);
        }
//        if (StringUtils.isNotEmpty(renewed.getRenewedBackPostage().toString())) {
//            renewed.setRenewedBackPostage(renewed.getRenewedBackPostage().intValue() * 100);
//        }
        /*if (!StringUtils.isNotEmpty(renewed.getRenewedBackEfastOrderId())) {
            return new ResponseJson(500, "请输入efast订单号!", 500);
        }*/
        if (StringUtils.isNotEmpty(mergeAddress)) {
            renewed.setRenewedSendMergeAddress(mergeAddress);
        }
    if(renewed.getRenewedBackStatus() != null){
        if(renewed.getRenewedBackStatus() != 1){
            ComplaintSignclosedInfo cs = new ComplaintSignclosedInfo();
            cs.setSignclosedCustomerId(renewed.getCustomerId());
            cs.setSignclosedLogistics(renewed.getRenewedBackLogisticsCompany());
            cs.setSignclosedLogisticsNumber(renewed.getRenewedBackLogisticsNo());
            complaintSignclosedInfoService.updateSignclosedByCustomerId(cs);
        }
    }

        //修改换新信息
        int num = renewedService.updateRenewedInfo(renewed, null, null);
        if (num > 0) {
            return new ResponseJson(200, "修改成功!", 200);
        } else {
            return new ResponseJson(500, "修改失败!", 500);
        }
    }

    /**
     * 进入修改维修页面
     *
     * @param request
     * @return
     * @throws Exception
     */
    @RequiresPermissions("customer:update:repair")
    @RequestMapping("/_to_update_repair")
    public ModelAndView toUpdateRepair(HttpServletRequest request) throws Exception {
        ModelAndView mv = new ModelAndView("cm/customer/update_repair");
        String customerId = request.getParameter("customerId");
        mv.addObject("customerId", customerId);
        return mv;
    }

    /**
     * 进入修改维修页面
     *
     * @param request
     * @return
     * @throws Exception
     */
    @ResponseBody
    @RequiresPermissions("customer:update:repair")
    @RequestMapping("/_update_repair")
    public ResponseJson updateRepairUI(HttpServletRequest request) throws Exception {
        String customerId = request.getParameter("customerId");
        if (!StringUtils.isNotEmpty(customerId)) {
            return new ResponseJson(500, "该客诉信息不存在!", 500);
        }
        Repair repair = new Repair();
        repair.setCustomerId(Integer.parseInt(customerId));
        repair.setRepairState(1);
        //获取维修详情和品质检测信息
        repair = customerService.getRepairInfo(repair);
        if (repair == null) {
            return new ResponseJson(500, "该客诉没有维修信息!", 500);
        } else {
            ResponseJson rj = new ResponseJson(200, "查询成功", 200);
            rj.addResponseKeyValue("repair", repair);
            return rj;
        }
    }

    /**
     * 修改维修处理信息
     *
     * @param request
     * @param repair
     * @return
     * @throws Exception
     */
    @ResponseBody
    @RequiresPermissions("customer:update:repair")
    @RequestMapping("/update_repair_info")
    public ResponseJson updateRepairInfo(HttpServletRequest request, Repair repair) throws Exception {
        if (!StringUtils.isNotEmpty(repair.getRepairId().toString())) {
            return new ResponseJson(500, "该换新信息不能修改!", 500);
        }
       /* String closedProducts = request.getParameter("closed_products");
        String closedFittings = request.getParameter("closed_fittings");*/
        String provinceNumber = request.getParameter("repairProvinceNumber");
        String cityNumber = request.getParameter("repairCityNumber");
        String areaNumber = request.getParameter("repairAreaNumber");
        String mergeAddress = request.getParameter("merge_address");
        if (StringUtils.isNotEmpty(provinceNumber)) {
            repair.setProvinceNumber(Integer.parseInt(provinceNumber));
        }
        if (StringUtils.isNotEmpty(cityNumber)) {
            repair.setCityNumber(Integer.parseInt(cityNumber));
        }
        if (StringUtils.isNotEmpty(areaNumber)) {
            repair.setAreaNumber(Integer.parseInt(areaNumber));
        }
        if (StringUtils.isNotEmpty(mergeAddress)) {
            repair.setRepairSendMergeAddress(mergeAddress);
        }
//        if (StringUtils.isNotEmpty(repair.getRepairBackPostage().toString())) {
//            repair.setRepairBackPostage(repair.getRepairBackPostage().intValue() * 100);
//        }
        /*if (!StringUtils.isNotEmpty(repair.getRepairBackEfastOrderId())) {
            return new ResponseJson(500, "请输入efast订单号!", 500);
        }*/
        if (StringUtils.isNotEmpty(mergeAddress)) {
            repair.setRepairSendMergeAddress(mergeAddress);
        }

        /*SalesOrder order = new SalesOrder();
        order.setSalesOrderStatus(1);
        order.setSalesOrderId(repair.getRepairBackEfastOrderId());
        int count = salesOrderService.getOrderInfoCount(order);
        //判断efast订单是否可查出有效数据
        if (count == 0) {
            return new ResponseJson(500, "该efast订单号无效，请重新输入!", 500);
        }*/

        if(repair.getRepairBackStatus() != null){
            if(repair.getRepairBackStatus() != 1){
                ComplaintSignclosedInfo cs = new ComplaintSignclosedInfo();
                cs.setSignclosedCustomerId(repair.getCustomerId());
                cs.setSignclosedLogistics(repair.getRepairBackLogisticsCompany());
                cs.setSignclosedLogisticsNumber(repair.getRepairBackLogisticsNo());
                complaintSignclosedInfoService.updateSignclosedByCustomerId(cs);
            }
        }

        //修改维修信息
        int num = repairService.updateRepairInfo(repair, null, null);

        if (num > 0) {
            return new ResponseJson(200, "修改成功!", 200);
        } else {
            return new ResponseJson(500, "修改失败!", 500);
        }
    }

    /**
     * 进入修改退货页面
     *
     * @param request
     * @return
     * @throws Exception
     */
    @RequiresPermissions("customer:update:backGoods")
    @RequestMapping("/_to_update_book_goods")
    public ModelAndView toUpdateBookGoods(HttpServletRequest request) throws Exception {
        ModelAndView mv = new ModelAndView("cm/customer/update_back_goods");
        String customerId = request.getParameter("customerId");
        mv.addObject("customerId", customerId);
        return mv;
    }

    /**
     * 进入修改售后退货页面
     *
     * @param request
     * @return
     * @throws Exception
     */
    @ResponseBody
    @RequiresPermissions("customer:update:backGoods")
    @RequestMapping("/_update_back_goods")
    public ResponseJson updateBackGoodsUI(HttpServletRequest request) throws Exception {
        String customerId = request.getParameter("customerId");
        if (!StringUtils.isNotEmpty(customerId)) {
            return new ResponseJson(500, "该客诉信息不存在!", 500);
        }
        BackGoods backGoods = new BackGoods();
        backGoods.setCustomerId(Integer.parseInt(customerId));
        //获取售后退货信息
        backGoods = customerService.getBackGoods(backGoods);
        if (backGoods == null) {
            return new ResponseJson(500, "该客诉没有售后退货信息!", 500);
        } else {
            ResponseJson rj = new ResponseJson(200, "查询成功", 200);
            rj.addResponseKeyValue("backGoods", backGoods);
            return rj;
        }
    }

    /**
     * 修改售后退货信息
     *
     * @param request
     * @param backGoods
     * @return
     * @throws Exception
     */
    @ResponseBody
    @RequiresPermissions("customer:update:backGoods")
    @RequestMapping("/update_back_goods")
    public ResponseJson updateBackGoods(HttpServletRequest request, BackGoods backGoods) throws Exception {
        String closedProducts = request.getParameter("closed_products");
        String closedFittings = request.getParameter("closed_fittings");
        if (!StringUtils.isNotEmpty(backGoods.getBackGoodsId().toString())) {
            return new ResponseJson(500, "该售后退货信息不能修改!", 500);
        }
//        if (StringUtils.isNotEmpty(backGoods.getBackGoodsBackPostage().toString())) {
//            backGoods.setBackGoodsBackPostage(backGoods.getBackGoodsBackPostage().intValue() * 100);
//        }

//        if(backGoods.getBackGoodsBackStatus() != 1){
//            ComplaintSignclosedInfo cs = new ComplaintSignclosedInfo();
//            cs.setSignclosedCustomerId(backGoods.getCustomerId());
//            cs.setSignclosedLogistics(backGoods.getBackGoodsBackLogisticsCompany());
//            cs.setSignclosedLogisticsNumber(backGoods.getBackGoodsBackLogisticsNo());
//            complaintSignclosedInfoService.updateSignclosedByCustomerId(cs);
//        }

        int num = backGoodsService.updateBackGoods(backGoods, closedProducts, closedFittings);
        if (num > 0) {
            return new ResponseJson(200, "修改成功!", 200);
        } else {
            return new ResponseJson(500, "修改失败!", 500);
        }
    }

    /**
     * 进入修改补寄页面
     *
     * @param request
     * @return
     * @throws Exception
     */
    @RequiresPermissions("customer:update:reissue")
    @RequestMapping("/_to_update_reissue")
    public ModelAndView toUpdateReissue(HttpServletRequest request) throws Exception {
        ModelAndView mv = new ModelAndView("cm/customer/update_reissue");
        String customerId = request.getParameter("customerId");
        mv.addObject("customerId", customerId);
        return mv;
    }

    /**
     * 进入修改补寄信息页面
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:update:reissue")
    @RequestMapping("/get_reissue_info")
    public ResponseJson getReissueInfo(HttpServletRequest request) {
        String customerId = request.getParameter("customerId");
        if (!StringUtils.isNotEmpty(customerId)) {
            return new ResponseJson(500, "该客诉信息不存在!", 500);
        }
        Reissue reissue = new Reissue();
        reissue.setCustomerId(Integer.parseInt(customerId));
        //获取售后补寄信息
        reissue = customerService.getReissue(reissue);
        if (reissue == null) {
            return new ResponseJson(500, "该客诉没有售后退货信息!", 500);
        } else {
            ResponseJson rj = new ResponseJson(200, "查询成功", 200);
            rj.addResponseKeyValue("reissue", reissue);
            return rj;
        }
    }

    /**
     * 修改售后补寄信息
     *
     * @param request
     * @param reissue
     * @return
     * @throws Exception
     */
    @ResponseBody
    @RequiresPermissions("customer:update:reissue")
    @RequestMapping("/update_reissue_info")
    public ResponseJson updateReissueInfo(HttpServletRequest request, Reissue reissue) throws Exception {
        String provinceNumber = request.getParameter("reissueProvinceNumber");
        String cityNumber = request.getParameter("reissueCityNumber");
        String areaNumber = request.getParameter("reissueAreaNumber");
        String mergeAddress = request.getParameter("merge_address");
        if (!StringUtils.isNotEmpty(reissue.getReissueId().toString())) {
            return new ResponseJson(500, "该售后补寄信息不能修改!", 500);
        }
        if (StringUtils.isNotEmpty(provinceNumber)) {
            reissue.setProvinceNumber(Integer.parseInt(provinceNumber));
        }
        if (StringUtils.isNotEmpty(cityNumber)) {
            reissue.setCityNumber(Integer.parseInt(cityNumber));
        }
        if (StringUtils.isNotEmpty(areaNumber)) {
            reissue.setAreaNumber(Integer.parseInt(areaNumber));
        }
        if (StringUtils.isNotEmpty(mergeAddress)) {
            reissue.setReissueSendMergeAddress(mergeAddress);
        }
        //修改售后补寄信息
        int num = reissueService.updateReissueInfo(reissue);
        if (num > 0) {
            return new ResponseJson(200, "修改成功!", 200);
        } else {
            return new ResponseJson(500, "修改失败!", 500);
        }
    }

    /**
     * 进入修改退货页面
     *
     * @param request
     * @return
     * @throws Exception
     */
    @RequiresPermissions("customer:update:noreason")
    @RequestMapping("/_update_noreason_back")
    public ModelAndView toUpdateNoreasonBack(HttpServletRequest request) throws Exception {
        ModelAndView mv = new ModelAndView("cm/customer/update_noreason_back");
        String customerId = request.getParameter("customerId");
        mv.addObject("customerId", customerId);
        return mv;
    }

    /**
     * 获取无理由退货信息
     *
     * @param request
     * @return
     * @throws Exception
     */
    @ResponseBody
    @RequiresPermissions("customer:update:noreason")
    @RequestMapping("/get_noreason_back")
    public ResponseJson getNoreasonBack(HttpServletRequest request) throws Exception {
        String customerId = request.getParameter("customerId");
        if (!StringUtils.isNotEmpty(customerId)) {
            return new ResponseJson(500, "该客诉信息不存在!", 500);
        }
        NoreasonBack noreasonBack = new NoreasonBack();
        noreasonBack.setCustomerId(Integer.parseInt(customerId));
        noreasonBack.setNoreasonBackState(1);
        //获取无理由退货信息
        noreasonBack = customerService.getNoreasonBack(noreasonBack);
        if (noreasonBack == null) {
            return new ResponseJson(500, "该客诉没有无理由售后退货信息!", 500);
        } else {
            ResponseJson rj = new ResponseJson(200, "查询成功", 200);
            rj.addResponseKeyValue("noreasonBack", noreasonBack);
            return rj;
        }
    }

    /**
     * 修改售后无理由退货信息
     *
     * @param request
     * @param noreasonBack
     * @return
     * @throws Exception
     */
    @ResponseBody
    @RequiresPermissions("customer:update:noreason")
    @RequestMapping("/update_noreason")
    public ResponseJson updateNoreason(HttpServletRequest request, NoreasonBack noreasonBack) throws Exception {
        String closedProducts = request.getParameter("closed_products");
        String closedFittings = request.getParameter("closed_fittings");
        if (!StringUtils.isNotEmpty(noreasonBack.getNoreasonBackId().toString())) {
            return new ResponseJson(500, "该售后无理由退货信息不能修改!", 500);
        }
//        if (StringUtils.isNotEmpty(noreasonBack.getNoreasonBackBackPostage().toString())) {
//            noreasonBack.setNoreasonBackBackPostage(noreasonBack.getNoreasonBackBackPostage().intValue() * 100);
//        }

//        if(noreasonBack.getNoreasonBackBackStatus() != 1){
//            ComplaintSignclosedInfo cs = new ComplaintSignclosedInfo();
//            cs.setSignclosedCustomerId(noreasonBack.getCustomerId());
//            cs.setSignclosedLogistics(noreasonBack.getNoreasonBackBackLogisticsCompany());
//            cs.setSignclosedLogisticsNumber(noreasonBack.getNoreasonBackBackLogisticsNo());
//            complaintSignclosedInfoService.updateSignclosedByCustomerId(cs);
//        }

        int num = noreasonBackService.updateNoreasonBack(noreasonBack, closedProducts, closedFittings);
        if (num > 0) {
            return new ResponseJson(200, "修改成功!", 200);
        } else {
            return new ResponseJson(500, "修改失败!", 500);
        }
    }

    /**
     * 查询未解决客诉数量
     */
    @ResponseBody
    @RequestMapping(value = "/selectNumberBacklog")
    public ResultMsg selectTodo(HttpServletRequest request){
        ResultMsg msg = new ResultMsg();
        CustomerInfo customerInfo = new CustomerInfo();
        //获取登录员工id
        Integer adminId = AdminUtils.getLoginAdminId();
        customerInfo.setAdminId(adminId);
        customerInfo.setCustomerIsSolve(2);
        //未解决客诉数量
        Integer notSolvedCustomer = customerService.selectNotSolvedCustomer(customerInfo);
        //需要向工厂确认所有已签收的产品数量
        CustomerCommon customerCommon = new CustomerCommon();
        customerCommon.setAdminId(adminId);
        customerCommon.setRelationBackStatus(4);
        Integer amountReceivedCustomer = customerCommonService.listCustomerCommonByStatus(customerCommon);
        //需要填写Efast订单号的客诉数量
        customerCommon.setRelationBackStatus(3);
        Integer noEntryCustomer = customerCommonService.listCustomerCommonByStatus(customerCommon);
        //客诉录入后，三天后未寄回的客诉数量
        customerCommon.setRelationBackStatus(1);
        customerCommon.setRelationCreateTime(new Date());
        Integer notSendCustomer = customerCommonService.listCustomerCommonByStatus(customerCommon);

        Map<String,Integer> numberMap = new HashMap<>();
        numberMap.put("notSolvedCustomer",notSolvedCustomer);
        numberMap.put("amountReceivedCustomer",amountReceivedCustomer);
        numberMap.put("noEntryCustomer",noEntryCustomer);
        numberMap.put("notSendCustomer",notSendCustomer);
        msg.setResultCode(ResultInfo.SUCCESSCODE);
        msg.setStatus(true);
        msg.setData(numberMap);
        return msg;
    }

    /**
     * 根据微信昵称/姓名/电话查询客诉
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:list:customer")
    @RequestMapping("/get_custoner_info")
    public ResponseJson getCustonerInfo(HttpServletRequest request,CustomerCommon customerCommon) throws Exception {
        if (customerCommon == null) {
            return new ResponseJson(500, "参数错误!", 500);
        }
        List<CustomerCommon> customerCommonList = customerCommonService.listCustomerCommon(customerCommon);
        if(customerCommonList.size() < 1){
            return new ResponseJson(500, "不存在相关客诉信息!", 500);
        } else {
            ResponseJson rj = new ResponseJson(200, "查询成功", 200);
            rj.addResponseKeyValue("customer", customerCommonList.get(0));
            return rj;
        }
    }


    /**
     * 申请邮费
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:applyPostage:customer")
    @RequestMapping(value = "/apply_postage")
    public ResponseJson applyPostage(HttpServletRequest request, Integer customerId) throws Exception {
        CustomerInfo customerInfo = customerService.getCustomerInfo(customerId);
        if(customerInfo == null){
            return new ResponseJson(500, "未获取到客诉", 500);
        }

        CustomerCommon customerCommon = new CustomerCommon();
        customerCommon.setCustomerId(customerId);
        List<CustomerCommon> customerCommonList = customerCommonService.listCustomerCommon(customerCommon);
        customerCommon = customerCommonList.get(0);

        if(customerCommon.getRelationBackStatus() == 1){    //1：未寄回  2：已寄回  3：已收货  4:已签收待确认
            return new ResponseJson(500, "请修改寄回状态，并填写寄回信息", 500);
        }

        if(customerCommon.getRelationBackStatus() == 2){    //1：未寄回  2：已寄回  3：已收货  4:已签收待确认
            return new ResponseJson(500, "产品正在寄回中！", 500);
        }

        if(customerCommon.getRelationIsTransfer() == 0){    //relationIsTransfer 是否需要转账邮费  0:不需要 10:需要转账
            return new ResponseJson(500, "请修改邮费转账状态，并填写邮费信息", 500);
        }

        if(customerCommon.getRelationBackPostage() == null || customerCommon.getRelationBackPostage() == 0  //relationBackPostage
                || customerCommon.getRelationAlipay() == null || customerCommon.getRelationAlipayName() == null ){
            return new ResponseJson(500, "请填写邮费信息", 500);
        }

        if(customerInfo.getCompanyId() == null || customerInfo.getCompanyId() == 0 ){
            return new ResponseJson(500, "未正确选择销售公司", 500);
        }

        Postage age = new Postage();
        age.setCustomerId(customerInfo.getCustomerId());    //客诉id
        List<Postage> postageList = postageService.listPostage(age);
        if(postageList != null && postageList.size() > 0){
            return new ResponseJson(500, "该条客诉已在申请邮费中了", 500);
        }

        ResponseJson rj = new ResponseJson(200, "可以申请邮费", 200);
        rj.addResponseKeyValue("customerCommon",customerCommon);
        rj.addResponseKeyValue("customerInfo",customerInfo);
        return rj;
    }

    /**
     * 申请邮费
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:applyPostage:customer")
    @RequestMapping(value = "/add_postage")
    public ResponseJson addPostage(HttpServletRequest request, Integer customerId,String postageLogisticsImg) throws Exception {
        CustomerInfo customerInfo = customerService.getCustomerInfo(customerId);
        if(customerInfo == null){
            return new ResponseJson(500, "未获取到客诉", 500);
        }

        CustomerCommon customerCommon = new CustomerCommon();
        customerCommon.setCustomerId(customerId);
        List<CustomerCommon> customerCommonList = customerCommonService.listCustomerCommon(customerCommon);
        customerCommon = customerCommonList.get(0);

        if(customerCommon.getRelationBackStatus() == 1){    //1：未寄回  2：已寄回  3：已收货  4:已签收待确认
            return new ResponseJson(500, "请修改寄回状态，并填写寄回信息", 500);
        }

        if(customerCommon.getRelationBackStatus() == 2){    //1：未寄回  2：已寄回  3：已收货  4:已签收待确认
            return new ResponseJson(500, "产品正在寄回中！", 500);
        }

        if(customerCommon.getRelationIsTransfer() == 0){    //relationIsTransfer 是否需要转账邮费  0:不需要 10:需要转账
            return new ResponseJson(500, "请修改邮费转账状态，并填写邮费信息", 500);
        }

        if(customerCommon.getRelationBackPostage() == null || customerCommon.getRelationBackPostage() == 0  //relationBackPostage
                || customerCommon.getRelationAlipay() == null || customerCommon.getRelationAlipayName() == null ){
            return new ResponseJson(500, "请填写邮费信息", 500);
        }

        if(customerInfo.getCompanyId() == null || customerInfo.getCompanyId() == 0 ){
            return new ResponseJson(500, "未正确选择销售公司", 500);
        }

        Postage age = new Postage();
        age.setCustomerId(customerInfo.getCustomerId());    //客诉id
        List<Postage> postageList = postageService.listPostage(age);
        if(postageList != null && postageList.size() > 0){
            return new ResponseJson(500, "该条客诉已在申请邮费中了", 500);
        }

        Integer flag = 0;
        Postage postage = new Postage();
        postage.setCompanyId(customerInfo.getCompanyId());      //销售公司
        postage.setAdminId(customerInfo.getAdminId());      //客服
        postage.setCustomerId(customerInfo.getCustomerId());        //客诉id
        postage.setPostageCustomerStatus(2);            //------考虑手动点, 直接变为申请中
        postage.setPostageManagerStatus(1);     //------考虑手动点, 直接变为申请中
        postage.setPostageOrderSource(customerInfo.getStoreId());   //店铺id
        postage.setPostageTreatmentMethod(customerCommon.getCustomerIsSolve()); //处理方式
        postage.setSalesOrderId(customerCommon.getSalesOrderId());       //efast订单号
        postage.setPostageClientName(customerCommon.getRelationBackName());
        postage.setPostageClientTel(customerCommon.getRelationBackTel());
        postage.setPostageClientAddress(customerCommon.getRelationSendAddress());
        postage.setPostageLogisticsCompany(customerCommon.getRelationBackLogisticsCompany());
        postage.setPostageLogisticsNo(customerCommon.getRelationBackLogisticsNo());
        postage.setPostageAmount(customerCommon.getRelationBackPostage());  //寄回邮费
        postage.setPostageAlipay(customerCommon.getRelationAlipay());   //支付宝账户
        postage.setPostageAlipayName(customerCommon.getRelationAlipayName());   //支付宝账号名称
        postage.setPostageLogisticsImg(postageLogisticsImg);
        flag = postageService.savePostage(postage);

        if(flag < 1){
            return new ResponseJson(500, "申请失败", 500);
        }

        ResponseJson rj = new ResponseJson(200, "申请成功，请前往邮费转账列表查看", 200);
        return rj;
    }


    /**
     * 根据客诉id查询产品类型
     *
     * @param request
     * @return
     * @throws Exception
     */
    @ResponseBody
    @RequestMapping("/getProductType")
    public ResponseJson getProductType(HttpServletRequest request) throws Exception {
        String customerId = request.getParameter("customerId");
        if (!StringUtils.isNotEmpty(customerId)) {
            return new ResponseJson(500, "查询产品类型失败!", 500);
        }
        //查询客诉产品类型
        ProductType productType = productService.getProductType(Integer.valueOf(customerId));
        if (productType == null) {
            return new ResponseJson(500, "未找到产品类型!", 500);
        } else {
            ResponseJson rj = new ResponseJson(200, "查询成功", 200);
            rj.addResponseKeyValue("productType", productType);
            return rj;
        }
    }

}