iamberry-common-parent/watero-rst-web/src/main/java/com/iamberry/rst/controllers/approval/ApprovalController.java

package com.iamberry.rst.controllers.approval;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.iamberry.rst.core.approval.*;
import com.iamberry.rst.core.page.PageRequest;
import com.iamberry.rst.core.page.PagedResult;
import com.iamberry.rst.core.sys.Admin;
import com.iamberry.rst.faces.approval.ApprovalOrderService;
import com.iamberry.rst.faces.approval.ApprovalTaskService;
import com.iamberry.rst.faces.sys.SysService;
import com.iamberry.wechat.core.entity.WechatUtils;
import com.iamberry.wechat.tools.ResponseJson;
import com.iamberry.wechat.tools.ResultInfo;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
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.context.ContextLoader;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.multipart.commons.CommonsMultipartFile;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * Created by Administrator on 2018/10/9.
 */

@Controller
@RequestMapping("/approval")
public class ApprovalController {
    @Autowired
    private ApprovalOrderService approvalOrderService;
    @Autowired
    private ApprovalTaskService approvalTaskService;
    @Autowired
    private SysService sysService;
    /**
     * 新增审批信息
     * @param request
     * @param approvalProduction
     * @param productionItems
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/addApproval")
    public ResponseJson addApproval(HttpServletRequest request, ApprovalProduction approvalProduction, String productionItems,String productionContracts) throws ParseException {
        ResponseJson rj =new ResponseJson(200, "添加成功", 200);
        if (approvalProduction == null || productionItems == null) {
            return  ResponseJson.getFAILURE();
        }
        //获取openid,根据openid查询当前登录人信息
        /*String openId = WechatUtils.getUserBySession(request).getUserOpenid();*/
        String openId = "oaH_GwObiozJFBypUg0wKJjQpBiU";

        //获取审批任务id
        Map<String, Object> taskinfo = approvalTaskService.salesmanSubmitApply(1);

        String deliveryDate = request.getParameter("deliveryDate");
        if(deliveryDate == null ){
            return  ResponseJson.getFAILURE();
        }
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        approvalProduction.setProductionDeliveryDate(format.parse(deliveryDate));

        //封装生产审批产品项
        List<ApprovalProductionItem> listApprovalProductionItem = new ArrayList<ApprovalProductionItem>();
        JSONArray jsonProductionItems = JSONArray.fromObject(productionItems);
        for (int i = 0; i < jsonProductionItems.size(); i++) {
            JSONObject orderItem = jsonProductionItems.getJSONObject(i);
            //添加产品项内容
            ApprovalProductionItem approvalProductionItem = new ApprovalProductionItem();
            approvalProductionItem.setItemBrandName(orderItem.getString("itemBrandName"));
            approvalProductionItem.setItemProductName(orderItem.getString("itemProductName"));
            approvalProductionItem.setItemColorName(orderItem.getString("itemColorName"));
            approvalProductionItem.setItemProductNum(orderItem.getInt("itemProductNum"));
            approvalProductionItem.setItemProductModel(orderItem.getString("itemProductModel"));
            approvalProductionItem.setItemProductUnit(orderItem.getString("itemProductUnit"));
            approvalProductionItem.setItemProductBoxNumber(orderItem.getInt("itemProductBoxNumber"));
            listApprovalProductionItem.add(approvalProductionItem);
        }
        //封装生产审批合同
        List<ApprovalProductionContract> listProductionContract = new ArrayList<ApprovalProductionContract>();
        JSONArray jsonproductionContracts = JSONArray.fromObject(productionContracts);
        for (int i = 0; i < jsonProductionItems.size(); i++) {
            JSONObject contract = jsonproductionContracts.getJSONObject(i);
            ApprovalProductionContract contractInfo = new ApprovalProductionContract();
            contractInfo.setContractUrl(contract.getString("contractUrl"));
            contractInfo.setContractName(contract.getString("contractName"));
            listProductionContract.add(contractInfo);
        }
        boolean returnValue = approvalOrderService.insertApprovalProduction(approvalProduction,listApprovalProductionItem,listProductionContract,taskinfo,openId);
        if(!returnValue){
            return  ResponseJson.getFAILURE();
        }
        return rj;
    }


    /**
     * 上传合同图片
     * 通过流的方式上传文件
     * @RequestParam("file") 将name=file控件得到的文件封装成CommonsMultipartFile 对象
     */
    @ResponseBody
    @RequestMapping("/fileUpload")
    public ResponseJson  fileUpload(HttpServletRequest request,@RequestParam("file") CommonsMultipartFile file) throws IOException {
        ResponseJson responseJson = new ResponseJson();
        System.out.println("fileName："+file.getOriginalFilename());
        //获取项目根目录
        WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
        ServletContext servletContext = webApplicationContext.getServletContext();
        String realPath = servletContext.getRealPath(ResultInfo.CONTRACT_IMAGE);
        String imgUrl = new Date().getTime()+file.getOriginalFilename();
        try {
            //获取输出流
            OutputStream os=new FileOutputStream(realPath+imgUrl);

            //获取输入流 CommonsMultipartFile 中可以直接得到文件的流
            InputStream is=file.getInputStream();
            byte[] bts = new byte[1024];
            //一个一个字节的读取并写入
            while(is.read(bts)!=-1)
            {
                os.write(bts);
            }
            os.flush();
            os.close();
            is.close();

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        responseJson.setReturnCode(200);
        responseJson.addResponseKeyValue("imgUrl",ResultInfo.CONTRACT_IMAGE+imgUrl);
        return responseJson;
    }

/**
 *  查询我发起的/我审核的列表
 * @param approvalInfo
 * @param pageSize
 * @param pageNO
 * @param totalNum
 * @param selectType 1.我发起的 2.我审核的 3.仓库确认
 * @return
 * @throws Exception
 */
    @ResponseBody
    @RequestMapping(value = "/approvalInfoList")
    public ResponseJson listApprovalInfo(HttpServletRequest request,
            ApprovalInfo approvalInfo,Integer selectType,
            @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 {
        ResponseJson rj =new ResponseJson(200, "查询成功", 200);
        //获取openid,根据openid查询当前登录人信息
        /*String openId = WechatUtils.getUserBySession(request).getUserOpenid();*/
        String openId = "oaH_GwObiozJFBypUg0wKJjQpBiU";
        Admin admin = sysService.getByOpenid(openId);
        if(admin == null){
            return new ResponseJson(200, "未查询到登录人信息", 500);
        }
        if(selectType == null){
            return new ResponseJson(200, "参数不完整，缺少查询类型字段", 500);
        }
        if(selectType == 1){//我发起的
            approvalInfo.setAdminId(admin.getAdminId());
        }else if(selectType == 2){//我审核的
            approvalInfo.setApprovalAdminId(admin.getAdminId());
        }
        PagedResult<ApprovalInfo> pagedResult = approvalOrderService.listApprovalInfo(pageNO, pageSize,approvalInfo,totalNum == null);

        if (totalNum != 0) {
            pagedResult.setTotal(totalNum);
        }
        List<ApprovalInfo> approvalList = pagedResult.getDataList();
        rj.addResponseKeyValue("approvalList",approvalList);
        return rj;
    }

    /**
     * 修改审批状态 （1 通过 2驳回 3撤销 4评论）
     * @param
     * @return
     * @throws Exception
     */
    @ResponseBody
    @RequestMapping(value = "/updateApprovalInfo")
    public ResponseJson updateApprovalInfo(HttpServletRequest request,
            ApprovalInfo approvalInfo,Integer status) throws Exception {
        ResponseJson rj =new ResponseJson(200, "操作成功", 200);
        if(status == null){
            return  ResponseJson.getFAILURE();
        }
        if(approvalInfo == null){
            return  ResponseJson.getFAILURE();
        }
        //获取openid,根据openid查询当前登录人信息
        String openId = WechatUtils.getUserBySession(request).getUserOpenid();
        Admin admin = sysService.getByOpenid(openId);
        if(admin == null){
            return new ResponseJson(200, "未查询到登录人信息", 500);
        }
        //审批历史记录封装
        HistoricalRecord historicalRecord = new HistoricalRecord();
        historicalRecord.setApprovalId(approvalInfo.getApprovalId());
        historicalRecord.setAdminId(admin.getAdminId());
        historicalRecord.setApprovalTime(new Date());
        //流程信息封装
        ProcessInfo processInfo = new ProcessInfo();
        processInfo.setAdminId(admin.getAdminId());
        processInfo.setApprovalId(approvalInfo.getApprovalId());
        processInfo.setProcessDesc(approvalInfo.getApprovalDetails());
        //审批信息封装
        ApprovalInfo info = new ApprovalInfo();
        info.setApprovalId(approvalInfo.getApprovalId());
        switch (status){
            case 1:
                //修改审核历史记录状态为已通过
                historicalRecord.setRecordState(2);
                if(approvalOrderService.updateHistoricalRecord(historicalRecord) < 1){
                    return  ResponseJson.getFAILURE();
                }
                //查询当前审核人当前审核任务信息
                HistoricalRecord record = approvalOrderService.getHistoricalRecord(historicalRecord);
                if(record == null){
                    return  ResponseJson.getFAILURE();
                }
                //获取下一个审核人，并添加审核历史信息
                Map<String, Object> taskMap = approvalTaskService.completeTask(approvalInfo.getActivitiId(),record.getTaskId());
                if(taskMap == null){
                    return  ResponseJson.getFAILURE();
                }
                if((Integer) taskMap.get("status") == 1){//没有下一个审批人，修改审批任务状态为已审批通过
                    info.setApprovalStatus(2);
                    if(approvalOrderService.updateApprovalInfo(info) < 1){
                        return  ResponseJson.getFAILURE();
                    }
                }else if((Integer) taskMap.get("status") == 0){//还有下一个审批人，需要增加审批历史任务
                    if(taskMap.get("users") == null){
                        return  ResponseJson.getFAILURE();
                    }
                    String[] split = (String[])taskMap.get("users");
                    for (String name : split){
                        //通过name查询管理员id
                       Admin approvalAdmin = sysService.getByName(name);
                       if(approvalAdmin == null){
                           return  ResponseJson.getFAILURE();
                       }

                        HistoricalRecord recordInfo = new HistoricalRecord();
                        recordInfo.setApprovalId(approvalInfo.getApprovalId());
                        recordInfo.setAdminId(approvalAdmin.getAdminId());
                        recordInfo.setRecordState(1);
                        recordInfo.setTaskId(taskMap.get("taskId").toString());
                        if(approvalOrderService.insertHistoricalRecord(recordInfo) < 1){
                            return  ResponseJson.getFAILURE();
                        }
                        //修改审核信息表
                        info.setApprovalStatusDetails("待"+name+"审批");
                        if(approvalOrderService.updateApprovalInfo(info) < 1){
                            return  ResponseJson.getFAILURE();
                        }
                    }
                }
                //添加流程信息记录
                processInfo.setProcessState(2);
                if(approvalOrderService.insertProcessInfo(processInfo) < 1){
                    return  ResponseJson.getFAILURE();
                }
                break;
            case 2:
                //修改历史记录状态为已驳回
                historicalRecord.setRecordState(3);
                if(approvalOrderService.updateHistoricalRecord(historicalRecord) < 1){
                    return  ResponseJson.getFAILURE();
                }
                info.setApprovalStatus(3);
                if(approvalOrderService.updateApprovalInfo(info) < 1){
                    return  ResponseJson.getFAILURE();
                }
                //添加流程信息记录
                processInfo.setProcessState(3);
                if(approvalOrderService.insertProcessInfo(processInfo) < 1){
                    return  ResponseJson.getFAILURE();
                }

                //调用第三方revokeTask接口执行撤销
                approvalTaskService.revokeTask(approvalInfo.getActivitiId(),"审批人驳回审核");
                break;
            case 3:
                //修改审批信息状态为撤销
                info.setApprovalStatus(9);
                if(approvalOrderService.updateApprovalInfo(info) < 1){
                    return  ResponseJson.getFAILURE();
                }
                //删除该审批的历史记录
                approvalOrderService.deleteHistoricalRecord(approvalInfo.getApprovalId());

                //添加流程信息记录
                processInfo.setProcessState(4);
                if(approvalOrderService.insertProcessInfo(processInfo) < 1){
                    return  ResponseJson.getFAILURE();
                }
                //调用第三方revokeTask接口执行撤销
                approvalTaskService.revokeTask(approvalInfo.getActivitiId(),"业务员撤销审核");
                break;
            case 4:
                //添加评论内容到流程信息表，不用修改任何状态
                processInfo.setProcessState(0);
                if(approvalOrderService.insertProcessInfo(processInfo) < 1){
                    return  ResponseJson.getFAILURE();
                }
                break;
        }
        return rj;
    }


    /**
     *  查询审批订单详情
     * @param approvalInfo
     * @return
     * @throws Exception
     */
    @ResponseBody
    @RequestMapping(value = "/getApprovalInfo")
    public ResponseJson getApprovalInfo(HttpServletRequest request,
                                         ApprovalInfo approvalInfo) throws Exception {
        ResponseJson rj =new ResponseJson(200, "查询成功", 200);
        if(approvalInfo == null){
            return  ResponseJson.getFAILURE();
        }
        List<ApprovalInfo> info = approvalOrderService.getApprovalInfo(approvalInfo);
        rj.addResponseKeyValue("approvalInfo",info);
        return rj;
    }

    /**
     * 添加入库信息
     * @param request
     * @param inventoryRecordss
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/addInventoryRecords")
    public ResponseJson addInventoryRecords(HttpServletRequest request, String inventoryRecordss){
        ResponseJson rj =new ResponseJson(200, "添加成功", 200);
        if (inventoryRecordss == null || inventoryRecordss.equals("")) {
            return  ResponseJson.getFAILURE();
        }
        //获取openid,根据openid查询当前登录人信息
        String openId = WechatUtils.getUserBySession(request).getUserOpenid();
        Admin admin = sysService.getByOpenid(openId);
        if(admin == null){
            return new ResponseJson(200, "未查询到登录人信息", 500);
        }
        JSONArray jsonRecordss = JSONArray.fromObject(inventoryRecordss);
        for (int i = 0; i < jsonRecordss.size(); i++) {
            JSONObject jsonRecords = jsonRecordss.getJSONObject(i);
            //封装入库信息
            ApprovalInventoryRecords records = new ApprovalInventoryRecords();
            if(jsonRecords.get("shouldStorage") == null || jsonRecords.get("actualStorage") == null){
                if(jsonRecords.getInt("shouldStorage") < jsonRecords.getInt("actualStorage")){
                    return new ResponseJson(200, "实际入库数量不得大于应入库数量", 500);
                }
            }
            records.setStorageState(jsonRecords.getInt("shouldStorage") > jsonRecords.getInt("actualStorage") ? 1 : 2);
            records.setApprovalId(jsonRecords.getInt("approvalId"));
            records.setProductName(jsonRecords.getString("productName"));
            records.setColorName(jsonRecords.getString("colorName"));
            records.setActualStorage(jsonRecords.getInt("actualStorage"));
            records.setShouldStorage(jsonRecords.getInt("shouldStorage"));
            records.setLackNumber(jsonRecords.getInt("lackNumber"));
            records.setOperatingAdminId(admin.getAdminId());
            if(approvalOrderService.insertInventoryRecords(records) < 1){
                return new ResponseJson(200, "添加入库记录失败", 500);
            }
            //修改订单项信息
            if(jsonRecords.get("itemId") == null || jsonRecords.get("itemId").equals("")){
                return new ResponseJson(200, "产品项id不能为空", 500);
            }

            ApprovalProductionItem productionItem = approvalOrderService.getProductionItem(jsonRecords.getInt("itemId"));
            if(productionItem.getItemActualStorage() < productionItem.getItemShouldStorage() + jsonRecords.getInt("shouldStorage")){
                return new ResponseJson(200, "产品项id不能为空", 500);
            }
            productionItem.setItemShouldStorage(productionItem.getItemShouldStorage() + jsonRecords.getInt("shouldStorage"));
            productionItem.setItemLackNumber(productionItem.getItemActualStorage() - (productionItem.getItemShouldStorage() + jsonRecords.getInt("shouldStorage")));
            if(approvalOrderService.updateProductionItem(productionItem) < 1){
                return new ResponseJson(200, "修改审批产品项失败", 500);
            }
        }
        return rj;
    }
}