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.cm.*;
import com.iamberry.rst.core.order.*;
import com.iamberry.rst.core.page.PagedResult;
import com.iamberry.rst.core.pts.ProcessNode;
import com.iamberry.rst.core.pts.ProduceProcess;
import com.iamberry.rst.core.sys.Admin;
import com.iamberry.rst.faces.cm.*;
import com.iamberry.rst.faces.order.EfastOrderService;
import com.iamberry.rst.faces.product.ProductService;
import com.iamberry.rst.faces.sys.SysService;
import com.iamberry.rst.utils.AdminUtils;
import com.iamberry.rst.utils.OrderNoUtil;
import com.iamberry.rst.utils.StitchAttrUtil;
import com.iamberry.wechat.tools.ResponseJson;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.commons.lang.StringUtils;
import org.apache.shiro.authz.annotation.RequiresPermissions;
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.util.*;

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

    @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 EfastOrderService efastOrderService;
    @Autowired
    private NoreasonBackService noreasonBackService;
    @Autowired
    private ComplaintQuestionInfoService complaintQuestionInfoService;

    private Object lock = new Object();


    /**
     * 获取客诉列表
     *
     * @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: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;
    }


    /**
     * 获取店铺集合
     *
     * @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) {
        List<SalesOrder> salesOrderList = salesOrderService.listSalesOrder(salesOrder);

        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 = "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");
        PagedResult<CustomerInfo> pagedResult = customerService.listCustomer(pageNO, pageSize, customerInfo, totalNum == 0);
        if (totalNum != 0) {
            pagedResult.setTotal(totalNum);
        }
        ProductType productType = new ProductType();
        productType.setTypeStatus(1);
        //查询产品类型集合
        List<ProductType> typeList = productService.listProductType(productType);
        //查询客诉类型集合
        List<ComplaintTypeInfo> complaintTypeList = complaintTypeInfoService.listComplaintTypeInfo(new ComplaintTypeInfo());
        //查询跟进客服集合
        Admin admin = new Admin();
        admin.setAdminStatus(1);
        List<Admin> adminList = sysService.listSelectAdmin(admin);

        //获取登录人id
        Integer loginAdminId = AdminUtils.getLoginAdminId();
        mv.addObject("loginAdminId",loginAdminId);
        mv.addObject("typeList", typeList);
        mv.addObject("complaintTypeList", complaintTypeList);
        mv.addObject("adminList", adminList);
        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
     * @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);
        }
        visit.setAdminId(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();
        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();
        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 {
        Integer flag = 0;
        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);
        flag = customerService.saveCustomerInfo(customerInfo, salesOrder);

        if (flag < 1) {
            return new ResponseJson(500, "添加客诉失败!", 500);
        } else {
            return new ResponseJson(200, "添加客诉成功!", 200);
        }



    }

    /**
     * 验证方法
     *
     * @param customerInfo
     * @return
     */
    public boolean isValiData(CustomerInfo customerInfo) {
        boolean flag = true;
//        if (customerInfo.getBomName() == null || "".equals(customerInfo.getBomName())) {
//            return false;
//        }
        return flag;
    }

    /**
     * 添加客诉
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:add:customer")
    @RequestMapping("/send_phone_sms")
    public ResponseJson sendPhoneSms(HttpServletRequest request,String type,String phone,ComplaintQuestionInfo complaintQuestionInfo) throws Exception {
        String url = "https://rst.iamberry.com/QA";
        Integer flag = 1;
        if(type != null && !"".equals(type)){
            if( "p".equals(type)){

                flag =  complaintQuestionInfoService.updateQuestionById(complaintQuestionInfo);

                url += "/problem?questionId="+complaintQuestionInfo.getQuestionId();
            }else if( "m".equals(type)){
                url += "/adress";

            }
        }

        if (flag < 1) {
            return new ResponseJson(500, "发送短信失败!", 500);
        } else {
            return new ResponseJson(200, "发送短信成功!", 200);
        }
    }


    /**
     * 添加回访完成内容
     *
     * @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
     */
    @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
     */
    @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
     */
    @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 {
        if (!StringUtils.isNotEmpty(renewed.getRenewedId().toString())) {
            return new ResponseJson(500, "该换新信息不能修改!", 500);
        }
        if (StringUtils.isNotEmpty(renewed.getRenewedBackPostage().toString())) {
            renewed.setRenewedBackPostage(renewed.getRenewedBackPostage().intValue() * 100);
        }
        //修改换新信息
        int num = renewedService.updateRenewedInfo(renewed);
        if (num > 0) {
            return new ResponseJson(200, "修改成功!", 200);
        } else {
            return new ResponseJson(500, "修改失败!", 500);
        }
    }

    /**
     * 进入修改维修页面
     *
     * @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 {
            ClosedFitting closedFitting = new ClosedFitting();
            closedFitting.setRelationId(repair.getRepairId());
            //获取寄回配件集合
            List<ClosedFitting> fittingList = renewedService.listClosedFitting(closedFitting);
            if (fittingList != null && fittingList.size() > 0) {
                repair.setClosedFittings(fittingList);
            }
            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 provinceNumber = request.getParameter("repairProvinceNumber");
        String cityNumber = request.getParameter("repairCityNumber");
        String areaNumber = request.getParameter("repairAreaNumber");
        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(repair.getRepairBackPostage().toString())) {
            repair.setRepairBackPostage(repair.getRepairBackPostage().intValue() * 100);
        }
        //修改维修信息
        int num = repairService.updateRepairInfo(repair);
        if (num > 0) {
            return new ResponseJson(200, "修改成功!", 200);
        } else {
            return new ResponseJson(500, "修改失败!", 500);
        }
    }

    /**
     * 进入修改售后退货页面
     *
     * @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 {
        if (!StringUtils.isNotEmpty(backGoods.getBackGoodsId().toString())) {
            return new ResponseJson(500, "该售后退货信息不能修改!", 500);
        }
        if (StringUtils.isNotEmpty(backGoods.getBackGoodsBackPostage().toString())) {
            backGoods.setBackGoodsBackPostage(backGoods.getBackGoodsBackPostage().intValue() * 100);
        }
        int num = backGoodsService.updateBackGoods(backGoods);
        if (num > 0) {
            return new ResponseJson(200, "修改成功!", 200);
        } else {
            return new ResponseJson(500, "修改失败!", 500);
        }
    }

    /**
     * 进入修改补寄信息页面
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequiresPermissions("customer:update:reissue")
    @RequestMapping("/_update_reissue")
    public ResponseJson updateReissueUI(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");
        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));
        }
        //修改售后补寄信息
        int num = reissueService.updateReissueInfo(reissue);
        if (num > 0) {
            return new ResponseJson(200, "修改成功!", 200);
        } else {
            return new ResponseJson(500, "修改失败!", 500);
        }
    }

    /**
     * 获取无理由退货信息
     * @param request
     * @return
     * @throws Exception
     */
    @ResponseBody
    @RequiresPermissions("customer:update:noreason")
    @RequestMapping("/_update_noreason")
    public ResponseJson toUpdateNoreason(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 {
        if (!StringUtils.isNotEmpty(noreasonBack.getNoreasonBackId().toString())) {
            return new ResponseJson(500, "该售后无理由退货信息不能修改!", 500);
        }
        if (StringUtils.isNotEmpty(noreasonBack.getNoreasonBackBackPostage().toString())) {
            noreasonBack.setNoreasonBackBackPostage(noreasonBack.getNoreasonBackBackPostage().intValue() * 100);
        }
        int num = noreasonBackService.updateNoreasonBack(noreasonBack);
        if (num > 0) {
            return new ResponseJson(200, "修改成功!", 200);
        } else {
            return new ResponseJson(500, "修改失败!", 500);
        }
    }

    /**
     * 同步百胜订单
     * @return
     * @throws Exception
     */
    @ResponseBody
    @RequiresPermissions("customer:sync:order")
    @RequestMapping("/sync_efast_order")
    public ResponseJson syncEfastOrder() throws Exception {
        int pageNo = 1;
        int pageSize = 20;
        boolean flag = false;	//控制是否还需要获取百胜订单信息
        String date = "";
        synchronized (lock) {
            //根据时间排序查询订单信息
            List<SalesOrder> orderList = salesOrderService.listSalesOrder(new SalesOrder());
            if (orderList != null && orderList.size() > 0) {
                SalesOrder salesOrder = orderList.get(0);
                date = salesOrder.getSalesCreateTime().toString();
            } else {
                date = "2016-04-01";
            }
            do {
                //批量获取百胜订单信息
                JSONObject obj = efastOrderService.listOrderInfoFormEfast(pageNo, pageSize, date);
                if (obj == null) {
                    return new ResponseJson(200, "没有可同步订单!", 200);
                }
                int pageSize1 = obj.getInt("page_size");    //百胜返回数据条目数
                if (pageSize <= pageSize1) {
                    flag = true;
                    pageNo++;
                } else {
                    flag = false;
                }
                salesOrderService.addSalesOrderList(obj);
            } while (flag);    //百胜返回条目数如果等于设置的分页条目数，则继续查询下一页
            return new ResponseJson(200, "同步成功!", 200);
        }
    }
}