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

package com.iamberry.rst.controllers.cm;

import com.iamberry.rst.core.cm.*;
import com.iamberry.rst.core.order.Product;
import com.iamberry.rst.core.page.PageRequest;
import com.iamberry.rst.core.page.PagedResult;
import com.iamberry.rst.core.pts.PtsMachine;
import com.iamberry.rst.faces.cm.AwaitingSignclosedProductInfoService;
import com.iamberry.rst.faces.cm.ComplaintDetectInfoService;
import com.iamberry.rst.faces.cm.ComplaintSignclosedInfoService;
import com.iamberry.rst.faces.cm.FittingsInfoService;
import com.iamberry.rst.faces.product.ProductService;
import com.iamberry.rst.faces.pts.MachineService;
import com.iamberry.rst.service.cm.mapper.AwaitingSignclosedProductMapper;
import com.iamberry.rst.service.cm.mapper.ComplaintSignclosedInfoMapper;
import com.iamberry.rst.service.cm.mapper.ComplaintSignclosedProductInfoMapper;
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.text.SimpleDateFormat;
import java.util.*;

/**
 * Created by wxm on 2017/8/29.
 */
@Controller
@RequestMapping("/admin/signclosed")
public class AdminSignclosedController {

   // private
    @Autowired
    private ComplaintDetectInfoService complaintDetectInfoService;
    @Autowired
    private ProductService productService;
    @Autowired
    private FittingsInfoService fittingsInfoService;
    @Autowired
    private ComplaintSignclosedInfoService complaintSignclosedInfoService;
    @Autowired
    private AwaitingSignclosedProductInfoService awaitingSignclosedProductInfoService;
    @Autowired
    private MachineService machineService;
    @Autowired
    private ComplaintSignclosedProductInfoMapper cmplaintSignclosedProductInfoMapper;

    /**
     * 跳转到添加签收记录页面
     *
     * @return
     */
    @RequiresPermissions("signclosed:add:signclosed")
    @RequestMapping(value = "/to_add_signclosed")
    public ModelAndView toAddDetect(HttpServletRequest request) {
        ModelAndView mv = new ModelAndView("cm/signclosed/add_signclosed");
        //获取所有产品及其颜色，配件
        Product product = new Product();
        List<Product> productList = productService.listProductAndColorAndfittings(product);
        mv.addObject("productList",productList);

        return mv;
    }



    /**
     * 客诉 - 查询签收/仓储列表
     * @param request
     * @return
     */
    @RequiresPermissions("signclosed:select:signclosed")
    @RequestMapping("/select_signclosed_list")
    public ModelAndView selectDetectList(HttpServletRequest request,
                                        @RequestParam(value = "pageNO", defaultValue = "1", required = false) int pageNO,
                                        @RequestParam(value = "pageTotal", required = false) Integer pageTotal,
                                        @RequestParam(value = "pageSize", defaultValue = "5", required = false) int pageSize,
                                         ComplaintSignclosedInfo signclosedInfo) {
        ModelAndView mv = new ModelAndView("cm/signclosed/signclosed_list");
        if(signclosedInfo.getIsBinding() != null && signclosedInfo.getIsBinding() == 1){
            mv = new ModelAndView("cm/signclosed/customer_signclosed_list");
        }

        StringBuilder url = new StringBuilder("/admin/signclosed/select_signclosed_list?pageSize=" + pageSize);
        // 封装请求数据
        PageRequest<ComplaintSignclosedInfo> pageRequest = new PageRequest<>(signclosedInfo, pageNO, pageSize, pageTotal == null);
        // 查询订单列表
        PagedResult<ComplaintSignclosedInfo> result = complaintSignclosedInfoService.listSignclosed(pageRequest);
        long total = 0;
        if (pageTotal == null) {
            total = result.getPages();
        } else {
            total = pageTotal;
            result.setPages(total);
        }

       /* url.append("&pageTotal=").append(total).append("&pageNO=");
        mv.addObject("page", result);
        mv.addObject("url", url.toString());*/
         StitchAttrUtil.getSa().setModelAndView(signclosedInfo, mv, "/admin/signclosed/select_signclosed_list", result);
        return mv;
    }


    /**
     * 获取机器信息
     * @param
     * @return
     * @throws Exception
     */
    @ResponseBody
    @RequiresPermissions("signclosed:add:signclosed")
    @RequestMapping("/get_machine_id")
    public ResponseJson getMachineId(@RequestParam(value = "pageSize", defaultValue = "10", required = false) Integer pageSize,
                                     @RequestParam(value = "pageNO", defaultValue = "1", required = false) Integer pageNO,
                                     @RequestParam(value = "pageTotal", required = false) Integer pageTotal,
                                     PtsMachine ptsMachine) throws Exception {
        ResponseJson rj = new ResponseJson();
        List<PtsMachine> ptsMachineList = machineService.ListPtsMachineToSignclosed(ptsMachine);

        List results = new ArrayList();
        for (PtsMachine machine : ptsMachineList){
            Map<String,Object> m = new HashMap<String,Object>();
            m.put("id",machine.getMachineId());
            m.put("text",machine.getMachineBarcode());
            results.add(m);
        }

//        Map<String,Object> paginationMap = new HashMap<String,Object>();
//        paginationMap.put("more",true);
//
//        Map<String,Object> map = new HashMap<String,Object>();
//        map.put("results",results);
//        map.put("pagination",paginationMap);
//
//        rj.addResponseKeyValue("map",map);
        rj.addResponseKeyValue("results",results);
        return rj;
    }

    /**
     * 添加签收信息
     * @param request
     * @return
     * @throws Exception
     */
    @RequiresPermissions("signclosed:add:signclosed")
    @ResponseBody
    @RequestMapping("/add_signclosed")
    public ResponseJson addSignclosed(HttpServletRequest request,ComplaintSignclosedInfo signclosedInfo,String orderItemString) throws Exception {
        ResponseJson msg = new ResponseJson();
        if(signclosedInfo == null){
            msg.setResultCode(200);
            msg.setReturnCode(500);
            return msg;
        }

        if(orderItemString == null){
            msg.setResultCode(200);
            msg.setReturnCode(502);
            return msg;
        }
        JSONArray jsonArray = JSONArray.fromObject(orderItemString);
        JSONObject jsonArray2  = jsonArray.getJSONObject(0);
        if(jsonArray2.get("itemNum").equals("")){
            msg.setResultCode(200);
             msg.setReturnCode(503);
            return msg;
        }

        String signclosedDate = request.getParameter("signclosed_date");
        if(signclosedDate != null){
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            signclosedInfo.setSignclosedDate(format.parse(signclosedDate));
        }
        signclosedInfo.setSignclosedCreateTime(new Date());
        signclosedInfo.setSignclosedState(1);
        boolean num = complaintSignclosedInfoService.insert(signclosedInfo,orderItemString);


        if (!num) {
            msg.setResultCode(200);
            msg.setReturnCode(500);
        } else {
            msg.setResultCode(200);
            msg.setReturnCode(200);
        }
        return msg;
    }

    /**
     * 跳转到完成签收记录页面
     *
     * @return
     */
    @RequiresPermissions("signclosed:update:signclosed")
    @RequestMapping(value = "/to_complete_signclosed")
    public ModelAndView toCompleteDetect(HttpServletRequest request,Integer signclosedId) {
        ModelAndView mv = new ModelAndView("cm/signclosed/complete_signclosed");
        //获取所有待收产品及其颜色，配件
        if(signclosedId == null){
            return mv;
        }
        ComplaintSignclosedInfo complaintSignclosedInfo = complaintSignclosedInfoService.getSignclosedById(signclosedId);
        List<AwaitingSignclosedProductInfo> signclosedList = awaitingSignclosedProductInfoService.listBySignclosedId(signclosedId);
        mv.addObject("signclosedList",signclosedList);
        mv.addObject("complaintSignclosedInfo",complaintSignclosedInfo);
        return mv;
    }


    /**
     * 完成签收信息
     * @param request
     * @return
     * @throws Exception
     */
    @RequiresPermissions("signclosed:update:signclosed")
    @ResponseBody
    @RequestMapping("/complete_signclosed")
    public ResponseJson completeSignclosed(HttpServletRequest request,ComplaintSignclosedInfo signclosedInfo) throws Exception {
        ResponseJson msg = new ResponseJson();
        if(signclosedInfo == null){
            msg.setResultCode(500);
            msg.setReturnCode(500);
            return msg;
        }


        /**签收产品**/
        String[] alreadyColorName = request.getParameterValues("alreadyColorName");
        String[] alreadyFittingsName = request.getParameterValues("alreadyFittingsName");
        if(alreadyColorName == null && alreadyFittingsName == null){
            msg.setResultCode(200);
            msg.setReturnCode(502);
            return msg;
        }
        Map<String,Integer> alreadyColorMap = new HashMap<>();
        Map<String,String[]> machineNumberMap = new HashMap<>();
        if(alreadyColorName != null && alreadyColorName.length> 0){
            for (int i = 0;i<alreadyColorName.length;i++){
                /**获取机器数量**/
                String number = request.getParameter("alreadyColorId"+alreadyColorName[i]);
                alreadyColorMap.put(alreadyColorName[i],Integer.valueOf(number));
            }
        }
        Map<String, Integer> alreadyFittingsMap = new HashMap<>();
        if(alreadyFittingsName != null && alreadyFittingsName.length> 0) {
            for (int i = 0; i < alreadyFittingsName.length; i++) {
                alreadyFittingsMap.put(alreadyFittingsName[i], Integer.valueOf(request.getParameter("alreadyFittingsId" + alreadyFittingsName[i])));
            }
        }
        String signclosedDate = request.getParameter("signclosed_date");
        if(signclosedDate != null){
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            signclosedInfo.setSignclosedDate(format.parse(signclosedDate));
        }
        boolean num = complaintSignclosedInfoService.updateSignclosedById(signclosedInfo,alreadyColorMap,machineNumberMap,alreadyFittingsMap);


        if (!num) {
            msg.setResultCode(500);
            msg.setReturnCode(500);
        } else {
            msg.setResultCode(200);
            msg.setReturnCode(200);
        }
        return msg;
    }

    /**
     * 跳转到修改备注页面
     *
     * @return
     */
    @RequiresPermissions("signclosed:update:signclosed")
    @RequestMapping(value = "/to_update_remark")
    public ModelAndView toUpdateRemark(HttpServletRequest request,Integer signclosedId) {
        ModelAndView mv = new ModelAndView("cm/signclosed/update_remark");
        ComplaintSignclosedInfo complaintSignclosedInfo = complaintSignclosedInfoService.getSignclosedById(signclosedId);
        mv.addObject("signclosedId",signclosedId);
        mv.addObject("complaintSignclosedInfo",complaintSignclosedInfo);
        return mv;
    }
    /**
     * 跳转到客服修改备注页面
     *
     * @return
     */
    @RequiresPermissions("signclosed:update:signclosed")
    @RequestMapping(value = "/to_update_customer_remark")
    public ModelAndView toUpdateCustomerRemark(HttpServletRequest request,Integer signclosedId) {
        ModelAndView mv = new ModelAndView("cm/signclosed/update_customer_remark");
        ComplaintSignclosedInfo complaintSignclosedInfo = complaintSignclosedInfoService.getSignclosedById(signclosedId);
        mv.addObject("signclosedId",signclosedId);
        mv.addObject("complaintSignclosedInfo",complaintSignclosedInfo);
        return mv;
    }
    /**
     * 修改备注
     *
     * @return
     */
    @ResponseBody
    @RequiresPermissions("signclosed:update:signclosed")
    @RequestMapping(value = "/update_remark")
    public ResponseJson updateRemark(HttpServletRequest request,ComplaintSignclosedInfo signclosedInfo){
        ResponseJson msg = new ResponseJson();
        if(signclosedInfo == null){
            msg.setResultCode(500);
            msg.setReturnCode(500);
            return msg;
        }
        Integer num = complaintSignclosedInfoService.updateSignclosedById(signclosedInfo);
        if (num < 1) {
            msg.setResultCode(500);
            msg.setReturnCode(500);
        } else {
            msg.setResultCode(200);
            msg.setReturnCode(200);
        }
        return msg;
    }

    /**
     * 跳转到修改寄件人信息页面
     *
     * @return
     */
    @RequiresPermissions("signclosed:update:signclosed")
    @RequestMapping(value = "/to_update_sender")
    public ModelAndView toUpdateSender(HttpServletRequest request,Integer signclosedId) {
        ModelAndView mv = new ModelAndView("cm/signclosed/update_sender");
        ComplaintSignclosedInfo complaintSignclosedInfo = complaintSignclosedInfoService.getSignclosedById(signclosedId);
        mv.addObject("signclosedId",signclosedId);
        mv.addObject("complaintSignclosedInfo",complaintSignclosedInfo);
        return mv;
    }

    /**
     * 跳转到转入品质页面
     *
     * @return
     */
    @RequiresPermissions("signclosed:update:signclosed")
    @RequestMapping(value = "/to_into_complaint")
    public ModelAndView tointoComplaint(HttpServletRequest request,Integer signclosedId) {
        ModelAndView mv = new ModelAndView("cm/signclosed/init_complaint");
        ComplaintSignclosedInfo complaintSignclosedInfo = complaintSignclosedInfoService.getSignclosedById(signclosedId);
        List<SignclosedProductInfo> listProductInfo = complaintSignclosedInfoService.listSignclosedById(signclosedId);
        mv.addObject("signclosedId",signclosedId);
        mv.addObject("customerId",complaintSignclosedInfo.getSignclosedCustomerId());
        mv.addObject("listProductInfo",listProductInfo);
        return mv;
    }

    /**
     * 转入品质(修改状态)
     *
     * @return
     */
    @ResponseBody
    @RequiresPermissions("signclosed:update:signclosed")
    @RequestMapping(value = "/update_states")
    public ResponseJson updateStates(HttpServletRequest request,ComplaintSignclosedInfo complaintSignclosedInfo){
        ResponseJson msg = new ResponseJson();
        if(complaintSignclosedInfo == null){
            msg.setResultCode(500);
            msg.setReturnCode(500);
            return msg;
        }
        complaintSignclosedInfo.setSignclosedState(2);
        complaintSignclosedInfoService.updateSignclosedById(complaintSignclosedInfo);
        msg.setResultCode(200);
        msg.setReturnCode(200);
        return msg;
    }

    /**
     * 转入品质
     *
     * @return
     */
    @ResponseBody
    @RequiresPermissions("signclosed:update:signclosed")
    @RequestMapping(value = "/into_complaint")
    public ResponseJson intoComplaint(HttpServletRequest request,ComplaintSignclosedInfo complaintSignclosedInfo){
        ResponseJson msg = new ResponseJson();
        if(complaintSignclosedInfo == null){
            msg.setResultCode(500);
            msg.setReturnCode(500);
            return msg;
        }
        //根据客诉id查询是否已存在品检信息
        ComplaintDetectInfo complaintDetectInfo = new ComplaintDetectInfo();
        if(complaintDetectInfoService.getDetectByCustomerId(complaintSignclosedInfo.getSignclosedCustomerId()) == null){
            complaintDetectInfo.setCustomerId(complaintSignclosedInfo.getSignclosedCustomerId());
            complaintDetectInfo.setSignclosedId(complaintSignclosedInfo.getSignclosedId());
            complaintDetectInfo.setDetectCreateTime(new Date());
            Integer i = complaintDetectInfoService.insert(complaintDetectInfo);
            if(i != 1){
                msg.setResultCode(500);
                msg.setReturnCode(500);
                return msg;
            }
        }
        //签收产品id集合
        String[] productIdList = request.getParameterValues("products");
        //添加品检项
        List<Integer> itemIdList = new ArrayList<>();
        List<ComplaintDetectItem> listDetectItem = new ArrayList<>();
        for(String productid : productIdList){
            SignclosedProductInfo signclosedProductInfo = cmplaintSignclosedProductInfoMapper.listSignclosedProductInfoById(Integer.valueOf(productid));
            ComplaintDetectItem detectItem = new ComplaintDetectItem();
            detectItem.setDetectId(complaintDetectInfo.getDetectId());
            detectItem.setDetectItemCreateTime(new Date());
            detectItem.setProductId(signclosedProductInfo.getSignclosedProductId());
            detectItem.setDetectProductNumber(signclosedProductInfo.getProductName());
            detectItem.setDetectItemState(1);
            detectItem.setCustomerId(complaintSignclosedInfo.getSignclosedCustomerId());
            Integer msg3 =  complaintDetectInfoService.insertItem(detectItem);
            if(msg3 != 1){
                itemIdList.add(detectItem.getDetectItemId());
            }
        }
        msg.setResultCode(200);
        msg.setReturnCode(200);
        msg.addResponseKeyValue("itemIdList",itemIdList);
        return msg;
    }


    /**
     * 根据产品名称查询产品数据
     *
     * @return
     */
    @ResponseBody
    @RequiresPermissions("signclosed:select:signclosed")
    @RequestMapping(value = "/select_product")
    public ResponseJson selectProduct(HttpServletRequest request,String productName){
        ResponseJson msg = new ResponseJson();
        if(productName == null){
            msg.setResultCode(500);
            msg.setReturnCode(500);
            return msg;
        }
        //获取所有产品及其颜色，配件
        Product product = new Product();
        product.setProductName(productName);
        List<Product> productList = productService.listProductAndColorAndfittings(product);
        if (productList.size() == 0) {
            msg.setResultCode(500);
            msg.setReturnCode(500);
        } else {
            msg.setResultCode(200);
            msg.setReturnCode(200);
            msg.addResponseKeyValue("productList",productList);
        }
        return msg;
    }

    /**
     * 获取仓储信息
     *
     * @return
     */
    @ResponseBody
    @RequiresPermissions("signclosed:select:signclosed")
    @RequestMapping(value = "/select_signclosed_info")
    public ResponseJson selectProduct(HttpServletRequest request,Integer signclosedId){
        if(signclosedId == null){
            return new ResponseJson(500, "未获取到仓储信息!", 500);
        }
        ComplaintSignclosedInfo complaintSignclosedInfo = complaintSignclosedInfoService.getSignclosedById(signclosedId);
        return new ResponseJson(500, "未获取到仓储信息!", 500);
    }

    /**
     * 跳转到关联客诉页面
     *
     * @return
     */
    @RequiresPermissions("signclosed:update:signclosed")
    @RequestMapping(value = "/to_associated_customer")
    public ModelAndView toAssociatedCustomer(HttpServletRequest request,Integer signclosedId) {
        ModelAndView mv = new ModelAndView("cm/signclosed/associated_customer");
        ComplaintSignclosedInfo complaintSignclosedInfo = complaintSignclosedInfoService.getSignclosedById(signclosedId);
        mv.addObject("signclosedId",signclosedId);
        mv.addObject("complaintSignclosedInfo",complaintSignclosedInfo);
        return mv;
    }
    /**
     * 关联客诉
     *
     * @return
     */
    @ResponseBody
    @RequiresPermissions("signclosed:update:signclosed")
    @RequestMapping(value = "/associated_customer")
    public ResponseJson associatedCustomer(HttpServletRequest request,ComplaintSignclosedInfo signclosedInfo){
        ResponseJson msg = new ResponseJson();
        if(signclosedInfo == null){
            msg.setResultCode(500);
            msg.setReturnCode(500);
            return msg;
        }
        if(signclosedInfo.getSignclosedCustomerId() == null){
            msg.setResultCode(500);
            msg.setReturnCode(500);
            return msg;
        }

        int num = complaintSignclosedInfoService.addDetect(signclosedInfo);
        if (num < 1) {
            msg.setResultCode(500);
            msg.setReturnCode(500);
        } else {
            msg.setResultCode(200);
            msg.setReturnCode(200);
        }
        return msg;
    }
}