iamberry-common-parent/watero-rst-service/src/main/java/com/iamberry/rst/service/approval/ApprovalOrderServiceImpl.java

package com.iamberry.rst.service.approval;

import com.github.pagehelper.PageHelper;
import com.iamberry.rst.core.approval.*;
import com.iamberry.rst.core.cm.CustomerInfo;
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.service.approval.mapper.ApplyPickMapper;
import com.iamberry.rst.service.approval.mapper.ApprovalOrderMapper;
import com.iamberry.rst.service.sys.mapper.SysMapper;
import com.iamberry.rst.util.PageUtil;
import com.iamberry.wechat.core.entity.WechatUtils;
import com.iamberry.wechat.tools.ResponseJson;
import com.iamberry.wechat.tools.ResultInfo;
import com.iamberry.wechat.tools.SendMessageUtil;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.text.SimpleDateFormat;
import java.util.*;

/**
 *  提货项信息接口
 * @author
 * @Date 2018-09-19
 */
@Service
public class ApprovalOrderServiceImpl implements ApprovalOrderService {
    @Autowired
    private ApprovalOrderMapper approvalOrderMapper;
    @Autowired
    private SysMapper sysMapper;
    @Autowired
    private ApprovalTaskService approvalTaskService;
    @Autowired
    private ApplyPickMapper applyPickMapper;



    @Override
    public Integer insertApprovalInfo(ApprovalInfo approvalInfo) {
        return approvalOrderMapper.insertApprovalInfo(approvalInfo);
    }

    @Override
    @Transactional
    public boolean insertApprovalProduction(ApprovalProduction approvalProduction,
                                            List<ApprovalProductionItem> listApprovalProductionItem,
                                            List<ApprovalProductionContract> productionContracts,
                                            Map<String, Object> tasknfo,
                                            String openId) {
        //获取登录人信息
        Admin admin = sysMapper.getByOpenid(openId);
        if(admin == null){
            throw new RuntimeException("未查询到当前登录人信息");
        }
        SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日");
        //添加审批信息
        ApprovalInfo approvalInfo = new ApprovalInfo();
        approvalInfo.setApprovalName(approvalProduction.getApplicantName()+"的审批订单");
        approvalInfo.setApprovalType(1);
        approvalInfo.setApprovalStatus(1);
        approvalInfo.setAdminId(admin.getAdminId());
        approvalInfo.setApprovalApplicant(approvalProduction.getApplicantName());
        approvalInfo.setActivitiId(tasknfo.get("key").toString());
        approvalInfo.setApprovalDetails("html内容");
        approvalInfo.setApprovalRemark(approvalProduction.getProductionRemark());
        int returnValue = approvalOrderMapper.insertApprovalInfo(approvalInfo);
        if(returnValue < 1){
            throw new RuntimeException("添加审批信息失败");
        }
        //添加生产审批信息
        approvalProduction.setApprovalId(approvalInfo.getApprovalId());
        approvalProduction.setApplicantId(admin.getAdminId());
        approvalProduction.setApplicantOrderNo("123456789");//订单编号未定
        approvalProduction.setApplicantName(admin.getAdminName());
        //申请人ID
        approvalProduction.setApplicantId(1);
        approvalProduction.setProductionState(1);
        int returnValue2 = approvalOrderMapper.insertApprovalProduction(approvalProduction);
        if(returnValue2 < 1){
            throw new RuntimeException("添加生产审批信息失败");
        }
        //添加合同信息
        if(productionContracts.size() > 0){
            for(ApprovalProductionContract approvalProductionContract : productionContracts){
                approvalProductionContract.setApprovalId(approvalProduction.getProductionId());
                approvalProductionContract.setContractName(approvalProduction.getApplicantName()+"的审批订单合同");
                approvalOrderMapper.insertProductionContract(approvalProductionContract);
            }
        }
        //封装生产审批产品项
        for(ApprovalProductionItem approvalProductionItem : listApprovalProductionItem){
            approvalProductionItem.setProductionId(approvalProduction.getProductionId());
        }
        int returnValue3 = approvalOrderMapper.insertItem(listApprovalProductionItem);
        if(returnValue3 < 1){
            throw new RuntimeException("添加生产审批产品项信息失败");
        }
        //添加流程信息
        ProcessInfo processInfo = new ProcessInfo();
        processInfo.setAdminId(admin.getAdminId());
        processInfo.setApprovalId(approvalInfo.getApprovalId());
        processInfo.setProcessDesc(approvalInfo.getApprovalDetails());
        processInfo.setProcessState(1);
        int returnValue4 = approvalOrderMapper.insertProcessInfo(processInfo);
        if(returnValue4 < 1){
            throw new RuntimeException("添加生产审批流程信息失败");
        }
        //添加审批历史记录
        ApprovalInfo info = new ApprovalInfo();
        info.setApprovalId(approvalInfo.getApprovalId());
        if(tasknfo.get("users") == null){
            throw new RuntimeException("获取下一个审批人信息失败"+tasknfo);
        }
        String[] split = (String[])tasknfo.get("users");
        for (String name : split){
            //通过name查询管理员id
            Admin approvalAdmin = sysMapper.getByName(name);
            if(approvalAdmin == null){
                throw new RuntimeException("获取下一个审批管理员信息失败"+tasknfo);
            }

            HistoricalRecord recordInfo = new HistoricalRecord();
            recordInfo.setApprovalId(approvalInfo.getApprovalId());
            recordInfo.setAdminId(approvalAdmin.getAdminId());
            recordInfo.setRecordState(1);
            recordInfo.setTaskId(tasknfo.get("taskId").toString());
            recordInfo.setApprovalTime(new Date());
            if(approvalOrderMapper.insertHistoricalRecord(recordInfo) < 1){
                throw new RuntimeException("添加历史审批信息失败"+tasknfo);
            }
            //修改审核信息表
            info.setApprovalStatusDetails("待"+approvalAdmin.getAdminName()+"审批");
            if(approvalOrderMapper.updateApprovalInfo(info) < 1){
                throw new RuntimeException("修改审批信息失败"+tasknfo);
            }
            //推送微信模板消息通知

            SendMessageUtil sendMessageUtil = new SendMessageUtil();
            sendMessageUtil.orderReviewResultsPush("你好，你有个订单需要你的审核",
                    approvalProduction.getApplicantOrderNo(),
                    approvalInfo.getApprovalApplicant(),
                    format.format(new Date()),
                    approvalInfo.getApprovalName(),
                    "点击查看详细信息",
                    approvalAdmin.getAdminOpenId(),
                    ResultInfo.LISTBEREVIEWED);

        }
        return true;
    }

    @Override
    public Integer insertItem(List<ApprovalProductionItem> listApprovalProductionItem) {
        return approvalOrderMapper.insertItem(listApprovalProductionItem);
    }

    @Override
    public Integer insertProductionContract(ApprovalProductionContract approvalProductionContract) {
        return approvalOrderMapper.insertProductionContract(approvalProductionContract);
    }

    @Override
    public Integer insertProcessInfo(ProcessInfo processInfo) {
        return approvalOrderMapper.insertProcessInfo(processInfo);
    }

    @Override
    public Integer insertHistoricalRecord(HistoricalRecord historicalRecord) {
        return approvalOrderMapper.insertHistoricalRecord(historicalRecord);
    }

    @Override
    public PagedResult<ApprovalInfo> listApprovalInfo(int pageNO, int pageSize, ApprovalInfo approvalInfo, boolean isTotalNum) {
        PageHelper.startPage(pageNO, pageSize, isTotalNum);
        //查询客诉列表
        List<ApprovalInfo> approvalList = approvalOrderMapper.listApprovalInfo(approvalInfo);
        return PageUtil.getPage(approvalList);
    }

    @Override
    public Integer updateHistoricalRecord(HistoricalRecord historicalRecord) {
        return approvalOrderMapper.updateHistoricalRecord(historicalRecord);
    }

    @Override
    public HistoricalRecord getHistoricalRecord(HistoricalRecord historicalRecord) {
        return approvalOrderMapper.getHistoricalRecord(historicalRecord);
    }

    @Override
    public List<ProcessInfo> listProcessInfo(ProcessInfo processInfo) {
        return approvalOrderMapper.listProcessInfo(processInfo);
    }

    @Override
    public Integer updateApprovalInfo(ApprovalInfo approvalInfo) {
        return approvalOrderMapper.updateApprovalInfo(approvalInfo);
    }

    @Override
    public Integer deleteHistoricalRecord(Integer approvalId) {
        return approvalOrderMapper.deleteHistoricalRecord(approvalId);
    }

    @Override
    public List<ApprovalInfo> getApprovalInfo(ApprovalInfo approvalInfo) {
        return approvalOrderMapper.listApprovalInfo(approvalInfo);
    }

    @Override
    public ApprovalInfo getApprovalInfoById(Integer approvalId) {
        return approvalOrderMapper.getApprovalInfoById(approvalId);
    }

    @Override
    public Integer updateProductionItem(ApprovalProductionItem approvalProductionItem) {
        return approvalOrderMapper.updateProductionItem(approvalProductionItem);
    }

    @Override
    @Transactional
    public ResponseJson insertInventoryRecords(String inventoryRecordss,Admin admin) {
        ResponseJson rj =new ResponseJson(200, "入库成功", 200);
        Integer appvalId = 0;
        Integer productNum = 0;
        String productName = "";
        Integer isPutStorage = 2; //·1部分入库 2.全部入库
        JSONArray jsonRecordss = JSONArray.fromObject(inventoryRecordss);
        for (int i = 0; i < jsonRecordss.size(); i++) {
            JSONObject jsonRecords = jsonRecordss.getJSONObject(i);
            //封装入库信息
            //根据itemid查询产品项
            ApprovalProductionItem productionItem = approvalOrderMapper.getProductionItem(jsonRecords.getInt("itemId"));
            if((productionItem.getItemLackNumber() > jsonRecords.getInt("actualStorage") ? 1 : 2) == 1){
                isPutStorage = 1;
            }
            ApprovalInventoryRecords records = new ApprovalInventoryRecords();
            if(jsonRecords.get("actualStorage") == null){
                if(productionItem.getItemLackNumber() < jsonRecords.getInt("actualStorage")){
                    return new ResponseJson(200, "实际入库数量不得大于缺少数量", 500);
                }
            }
            records.setStorageState(productionItem.getItemLackNumber() > jsonRecords.getInt("actualStorage") ? 1 : 2);
            records.setApprovalId(jsonRecords.getInt("approvalId"));
            records.setProductName(productionItem.getItemProductName());
            records.setColorName(productionItem.getItemColorName());
            records.setActualStorage(jsonRecords.getInt("actualStorage"));
            records.setShouldStorage(productionItem.getItemLackNumber());
            records.setLackNumber(productionItem.getItemLackNumber() - jsonRecords.getInt("actualStorage"));
            records.setOperatingAdminId(admin.getAdminId());
            records.setItemId(jsonRecords.getInt("itemId"));
            records.setBrandName(productionItem.getItemBrandName());
            records.setProductModel(productionItem.getItemProductModel());
            records.setProductUnit(productionItem.getItemProductUnit());
            records.setProductBoxNumber(productionItem.getItemProductBoxNumber());
            records.setExternalModel(productionItem.getItemExternalModel());
            if(approvalOrderMapper.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.getItemLackNumber() < jsonRecords.getInt("actualStorage")){
                return new ResponseJson(200, "产品入库数量不得大于缺少数量", 500);
            }
            /*productionItem.setItemShouldStorage(productionItem.getItemLackNumber());*/
            productionItem.setItemLackNumber(productionItem.getItemLackNumber() - jsonRecords.getInt("actualStorage"));
            productionItem.setItemActualStorage(productionItem.getItemActualStorage()+jsonRecords.getInt("actualStorage"));
            if(approvalOrderMapper.updateProductionItem(productionItem) < 1){
                return new ResponseJson(200, "修改审批产品项失败", 500);
            }
            appvalId = jsonRecords.getInt("approvalId");
            productNum = productNum + jsonRecords.getInt("actualStorage");
            productName = productName + productionItem.getItemProductName()+",";


        }
        //修改审批订单状态
        ApprovalInfo approvalinfo = new ApprovalInfo();
        approvalinfo.setApprovalId(appvalId);
        if(isPutStorage == 1){
            approvalinfo.setApprovalStatus(6);
            approvalinfo.setApprovalStatusDetails("已完成部分入库");
        }else{
            approvalinfo.setApprovalStatus(7);
            approvalinfo.setApprovalStatusDetails("全部入库，待发货");
        }
        if(approvalOrderMapper.updateApprovalInfo(approvalinfo) < 1){
            return new ResponseJson(200, "修改审批信息状态失败", 500);
        }

        //添加历史入库信息
        HistoricalRecord historicalRecord = new HistoricalRecord();
        historicalRecord.setApprovalTime(new Date());
        historicalRecord.setAdminId(admin.getAdminId());
        historicalRecord.setApprovalId(appvalId);
        if(isPutStorage == 1){
            historicalRecord.setRecordState(4);
        }else{
            historicalRecord.setRecordState(5);
        }
        if(approvalOrderMapper.insertHistoricalRecord(historicalRecord) < 1){
            return new ResponseJson(200, "添加审批历史信息失败", 500);
        }
        //添加审批流程信息
        //流程信息封装
        ProcessInfo processInfo = new ProcessInfo();
        processInfo.setAdminId(admin.getAdminId());
        processInfo.setApprovalId(appvalId);
        if(isPutStorage == 1){
            processInfo.setProcessState(5);
        }else{
            processInfo.setProcessState(6);
        }
        processInfo.setRecordId(historicalRecord.getRecordId() == null ? null : historicalRecord.getRecordId());
        processInfo.setProcessDesc("本次入库："+productNum+"台");
        if(approvalOrderMapper.insertProcessInfo(processInfo) < 1){
            return new ResponseJson(200, "添加审批流程信息失败", 500);
        }
        //推送入库微信模板消息通知
        //查询审批订单信息
        ApprovalInfo approvalInfo = approvalOrderMapper.getApprovalInfoById(appvalId);
        SendMessageUtil sendMessageUtil = new SendMessageUtil();
        productName = productName.substring(0,productName.length() - 1);

        AdminApprovalAuthority authority = new AdminApprovalAuthority();
        authority.setIsWarehouse(1);
        List<AdminApprovalAuthority> listAuthority = approvalOrderMapper.listApprovalAuthority(authority);
        Admin adminTwo = new Admin();
        adminTwo.setAdminId(listAuthority.get(0).getAdminId());
        List<Admin> listAdmin = sysMapper.listAdmin(adminTwo);
        sendMessageUtil.putStoragePush(approvalInfo.getApprovalName()+"已入库，本次入库总数量"+productNum+"台",
                productName,
                ""+productNum,
                admin.getAdminName(),
                "优尼雅仓库",
                "如有疑问请联系上级领导人",
                listAdmin.get(0).getAdminOpenId(),
                ResultInfo.LISTWAREHOUSE);
        return rj;
    }

    @Override
    public ApprovalProductionItem getProductionItem(Integer itemId) {
        return approvalOrderMapper.getProductionItem(itemId);
    }

    @Override
    public ApprovalProduction getApprovalProductionById(Integer approvalId) {
        return approvalOrderMapper.getApprovalProductionById(approvalId);
    }

    @Override
    public List<ApprovalProductionItem> getIteminfo(Integer approvalId) {
        return approvalOrderMapper.getIteminfo(approvalId);
    }

    @Override
    @Transactional
    public ResponseJson auditApprovalinfo(ApprovalInfo approvalInfo, Admin admin,Integer status) {
        ResponseJson rj =new ResponseJson(200, "操作成功", 200);
        ApprovalInfo ainfo = approvalOrderMapper.getApprovalInfoById(approvalInfo.getApprovalId());
        SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日");
        approvalInfo.setApprovalName(ainfo.getApprovalName());
        approvalInfo.setApprovalType(ainfo.getApprovalType());
        approvalInfo.setActivitiId(ainfo.getActivitiId());
        approvalInfo.setApprovalApplicant(ainfo.getApprovalApplicant());
        //审批历史记录查询和封装
        HistoricalRecord historicalRecord = new HistoricalRecord();
        historicalRecord.setApprovalId(approvalInfo.getApprovalId());
        historicalRecord.setAdminId(admin.getAdminId());
        historicalRecord.setRecordState(1);
        historicalRecord = approvalOrderMapper.getHistoricalRecord(historicalRecord);
        if(status != 3){
            if(historicalRecord == null){
                return new ResponseJson(200, "未查询到审批历史记录信息", 500);
            }else{
                historicalRecord.setApprovalTime(new Date());
            }
        }
        //流程信息封装
        ProcessInfo processInfo = new ProcessInfo();
        processInfo.setAdminId(admin.getAdminId());
        processInfo.setApprovalId(approvalInfo.getApprovalId());
        if(status != 3){
            processInfo.setRecordId(historicalRecord.getRecordId() == null ? null : historicalRecord.getRecordId());
        }
        processInfo.setProcessDesc(approvalInfo.getApprovalDetails());//后期在后台添加
        //审批信息封装
        ApprovalInfo info = new ApprovalInfo();
        info.setApprovalId(ainfo.getApprovalId());
        info.setApprovalType(ainfo.getApprovalType());
        info.setApprovalName(ainfo.getApprovalName());
        switch (status){
            case 1:
                //查询当前审核人当前审核任务信息
                HistoricalRecord record = approvalOrderMapper.getHistoricalRecord(historicalRecord);
                if(record == null){
                    rj = ResponseJson.getFAILURE();
                    rj.setResultMsg("查询当前审核人审核任务信息为空！");
                    return  rj;
                }
                //修改审核历史记录状态为已通过 同级其它审核人任务状态为其他人已审核
                HistoricalRecord recordinfo = new HistoricalRecord();
                recordinfo.setApprovalId(approvalInfo.getApprovalId());
                recordinfo.setRecordState(6);
                recordinfo.setTaskId(record.getTaskId());
                recordinfo.setApprovalTime(new Date());
                if(approvalOrderMapper.updateHistoricalRecord(recordinfo) < 1){
                    rj = ResponseJson.getFAILURE();
                    rj.setResultMsg("修改其它审核人审核历史记录状态失败！");
                    return  rj;
                }
                recordinfo.setTaskId(null);
                recordinfo.setAdminId(admin.getAdminId());
                recordinfo.setRecordState(2);
                if(approvalOrderMapper.updateHistoricalRecord(recordinfo) < 1){
                    rj = ResponseJson.getFAILURE();
                    rj.setResultMsg("修改审核历史记录状态失败！");
                    return  rj;
                }
                //获取下一个审核人，并添加审核历史信息
                Map<String, Object> taskMap = approvalTaskService.completeTask(approvalInfo.getActivitiId(),record.getTaskId());
                if(taskMap == null){
                    rj = ResponseJson.getFAILURE();
                    rj.setResultMsg("获取下一个审核人，并添加审核历史信息失败！");
                    return  rj;
                }
                if((Integer) taskMap.get("status") == 1){//没有下一个审批人，修改审批任务状态为已审批通过
                    info.setApprovalStatus(2);
                    info.setApprovalStatusDetails("已审核，待入库");
                    if(approvalOrderMapper.updateApprovalInfo(info) < 1){
                        rj = ResponseJson.getFAILURE();
                        rj.setResultMsg("修改审批信息失败！");
                        return  rj;
                    }
                    //判断是生产审批或提货审批
                    if(info.getApprovalType() == 1){
                        //推送微信模板消息通知

                        ApprovalProduction production = approvalOrderMapper.getApprovalProductionById(approvalInfo.getApprovalId());
                        Admin admininfo = new Admin();
                        admininfo.setAdminId(production.getApplicantId());
                        admininfo = sysMapper.getAdminInfo(admininfo);
                        if(admininfo.getAdminOpenId() == null ){
                            rj = ResponseJson.getFAILURE();
                            rj.setResultMsg("获取管理信息失败！");
                            return  rj;
                        }
                        //通知申请人该审批已通过
                        SendMessageUtil sendMessageUtil = new SendMessageUtil();
                        sendMessageUtil.reviewResultsPush("亲，您提交的申请 "+admin.getAdminName()+" 已处理。",
                                production.getApplicantName(),
                                "通过",
                                format.format(new Date()),
                                "审核通过后可通过公众号进入系统",
                                admininfo.getAdminOpenId(),
                                ResultInfo.LISTISTARTED);
                        //通知仓库订单已确认
                        //获取仓库人员openid
                        AdminApprovalAuthority authority = new AdminApprovalAuthority();
                        authority.setIsWarehouse(1);
                        List<AdminApprovalAuthority> listAuthority = approvalOrderMapper.listApprovalAuthority(authority);
                        Admin adminTwo = new Admin();
                        adminTwo.setAdminId(listAuthority.get(0).getAdminId());
                        List<Admin> listAdmin = sysMapper.listAdmin(adminTwo);
                        List<ApprovalProductionItem> items = approvalOrderMapper.getIteminfo(approvalInfo.getApprovalId());
                        String products = "";
                        Integer num = 0;
                        for(ApprovalProductionItem item : items){
                            products = products + item.getItemProductName()+",";
                            num = item.getItemProductNum()+num;
                        }
                        products = products.substring(0,products.length() - 1);
                        sendMessageUtil.putStoragePush(admininfo.getAdminName()+"的生产订单已确认，请在生产入库后确认",
                                products,
                                ""+num,
                                admin.getAdminName(),
                                "优尼雅仓库",
                                "如有疑问请联系上级领导人",
                                listAdmin.get(0).getAdminOpenId(),
                                ResultInfo.LISTWAREHOUSE);
                    }else{
                        //通知申请人该提货审批已通过
                        ApprovalApplyPick  approvalApplyPick = new ApprovalApplyPick();
                        approvalApplyPick.setApprovalId(approvalInfo.getApprovalId());
                        List<ApprovalApplyPick> pickList = applyPickMapper.listOrderBatchPage(approvalApplyPick);
                        String products = "";
                        for(ApprovalApplyPickItem PickItem : pickList.get(0).getListApplyPickItem()){
                            products = products+PickItem.getItemProductName()+"，";
                        }
                        products = products.substring(0,products.length()-1);
                        Admin admininfo = new Admin();
                        admininfo.setAdminId(pickList.get(0).getAdminId());
                        admininfo = sysMapper.getAdminInfo(admininfo);
                        SendMessageUtil sendMessageUtil = new SendMessageUtil();
                        sendMessageUtil.applicationFormPush("您的申领单被 "+admin.getAdminName()+" 通过。",
                                format.format(new Date()),
                                "0000000"+approvalInfo.getApprovalId(),
                                products,
                                "点击查看详情",
                                admininfo.getAdminOpenId(),
                                ResultInfo.LISTISTARTED);
                    }
                }else if((Integer) taskMap.get("status") == 0){//还有下一个审批人，需要增加审批历史任务
                    //修改状态为已完成部分审批
                    info.setApprovalStatus(4);
                    if(approvalOrderMapper.updateApprovalInfo(info) < 1){
                        rj = ResponseJson.getFAILURE();
                        rj.setResultMsg("修改审批信息状态失败！");
                        return  rj;
                    }
                    if(taskMap.get("users") == null){
                        rj = ResponseJson.getFAILURE();
                        rj.setResultMsg("获取下一个审批人失败！");
                        return  rj;
                    }
                    String[] split = (String[])taskMap.get("users");
                    for (String name : split){
                        //通过name查询管理员id
                        Admin approvalAdmin = sysMapper.getByName(name);
                        if(approvalAdmin == null){
                            rj = ResponseJson.getFAILURE();
                            rj.setResultMsg("查询管理员失败！");
                            return  rj;
                        }

                        HistoricalRecord recordInfo = new HistoricalRecord();
                        recordInfo.setApprovalId(approvalInfo.getApprovalId());
                        recordInfo.setAdminId(approvalAdmin.getAdminId());
                        recordInfo.setRecordState(1);
                        recordInfo.setTaskId(taskMap.get("taskId").toString());
                        if(approvalOrderMapper.insertHistoricalRecord(recordInfo) < 1){
                            rj = ResponseJson.getFAILURE();
                            rj.setResultMsg("添加历史审批人失败！");
                            return  rj;
                        }
                        //修改审核信息表
                        info.setApprovalStatusDetails("待"+approvalAdmin.getAdminName()+"审批");
                        if(approvalOrderMapper.updateApprovalInfo(info) < 1){
                            rj = ResponseJson.getFAILURE();
                            rj.setResultMsg("修改审核信息失败！");
                            return  rj;
                        }
                        //推送微信模板消息通知
                        //查询审批订单信息
                        ApprovalProduction production = approvalOrderMapper.getApprovalProductionById(approvalInfo.getApprovalId());
                        SendMessageUtil sendMessageUtil = new SendMessageUtil();
                        sendMessageUtil.orderReviewResultsPush("你好，你有个订单需要你的审核",
                                production.getApplicantOrderNo(),
                                approvalInfo.getApprovalApplicant(),
                                format.format(new Date()),
                                approvalInfo.getApprovalName(),
                                "点击查看详细信息",
                                approvalAdmin.getAdminOpenId(),
                                ResultInfo.LISTBEREVIEWED);
                    }
                }
                //添加流程信息记录
                processInfo.setProcessState(2);
                if(approvalOrderMapper.insertProcessInfo(processInfo) < 1){
                    rj = ResponseJson.getFAILURE();
                    rj.setResultMsg("添加流程信息记录失败！");
                    return  rj;
                }
                break;
            case 2:
                //修改历史记录状态为已驳回
                SendMessageUtil sendMessageUtil = new SendMessageUtil();
                HistoricalRecord recordinfo2 = new HistoricalRecord();
                recordinfo2.setApprovalId(approvalInfo.getApprovalId());
                recordinfo2.setRecordState(6);
                recordinfo2.setTaskId(historicalRecord.getTaskId());
                recordinfo2.setApprovalTime(new Date());
                if(approvalOrderMapper.updateHistoricalRecord(recordinfo2) < 1){
                    rj = ResponseJson.getFAILURE();
                    rj.setResultMsg("修改其它审核人历史记录状态为其他人已审核！");
                    return  rj;
                }
                recordinfo2.setTaskId(null);
                recordinfo2.setAdminId(admin.getAdminId());
                recordinfo2.setRecordState(3);
                if(approvalOrderMapper.updateHistoricalRecord(recordinfo2) < 1){
                    rj = ResponseJson.getFAILURE();
                    rj.setResultMsg("修改审核历史记录状态失败！");
                    return  rj;
                }

                info.setApprovalStatus(3);
                if(approvalOrderMapper.updateApprovalInfo(info) < 1){
                    rj = ResponseJson.getFAILURE();
                    rj.setResultMsg("修改审批信息失败！");
                    return  rj;
                }
                //添加流程信息记录
                processInfo.setProcessState(3);
                if(approvalOrderMapper.insertProcessInfo(processInfo) < 1){
                    rj = ResponseJson.getFAILURE();
                    rj.setResultMsg("添加流程信息记录失败！");
                    return  rj;
                }
                //判断是生产审批或提货审批 并向申请发起人和历史审批人发送模板消息
                if(info.getApprovalType() == 1){

                    //查询审批发起人信息并发送模板消息
                    ApprovalProduction production = approvalOrderMapper.getApprovalProductionById(approvalInfo.getApprovalId());
                    Admin admininfo = new Admin();
                    admininfo.setAdminId(production.getApplicantId());
                    admininfo = sysMapper.getAdminInfo(admininfo);
                    if(admininfo.getAdminOpenId() == null ){
                        rj = ResponseJson.getFAILURE();
                        rj.setResultMsg("获取管理信息失败！");
                        return  rj;
                    }
                    //通知申请人该审批已驳回

                    sendMessageUtil.reviewResultsPush("亲，您提交的申请 "+admin.getAdminName()+" 已处理。",
                            production.getApplicantName(),
                            "驳回",
                            format.format(new Date()),
                            "可通过公众号进入系统",
                            admininfo.getAdminOpenId(),
                            ResultInfo.LISTISTARTED);
                    //查询历史审批人信息并发送模板消息
                    List<HistoricalRecord> listHl = approvalOrderMapper.hasHistoricalRecordList(approvalInfo.getApprovalId());
                    if(listHl.size() > 0){
                        for(HistoricalRecord hr : listHl){
                            //通知申请人该审批已驳回
                            sendMessageUtil.reviewResultsPush("亲，您审核过的申请 "+admin.getAdminName()+" 已处理。",
                                    hr.getAdminName(),
                                    "驳回",
                                    format.format(new Date()),
                                    "可通过公众号进入系统",
                                    hr.getAdminOpenId(),
                                    ResultInfo.LISTISTARTED);
                        }
                    }
                }else{
                    //通知申请人该提货审批已驳回
                    ApprovalApplyPick  approvalApplyPick = new ApprovalApplyPick();
                    approvalApplyPick.setApprovalId(approvalInfo.getApprovalId());
                    List<ApprovalApplyPick> pickList = applyPickMapper.listOrderBatchPage(approvalApplyPick);
                    Admin admininfo = new Admin();
                    admininfo.setAdminId(pickList.get(0).getAdminId());
                    admininfo = sysMapper.getAdminInfo(admininfo);
                    //通知申请人该审批已驳回
                    sendMessageUtil.reviewResultsPush("亲，您提交的申请 "+admin.getAdminName()+" 已处理。",
                            pickList.get(0).getApplyPickName(),
                            "驳回",
                            format.format(new Date()),
                            "可通过公众号进入系统",
                            admininfo.getAdminOpenId(),
                            ResultInfo.LISTISTARTED);
                }

                //查询历史审批人信息并发送模板消息
                List<HistoricalRecord> listHl = approvalOrderMapper.hasHistoricalRecordList(approvalInfo.getApprovalId());
                if(listHl.size() > 0){
                    for(HistoricalRecord hr : listHl){
                        //通知申请人该申请已驳回
                        sendMessageUtil.reviewResultsPush("亲，您审核过的申请 "+admin.getAdminName()+" 已处理。",
                                hr.getAdminName(),
                                "驳回",
                                format.format(new Date()),
                                "可通过公众号进入系统",
                                hr.getAdminOpenId(),
                                ResultInfo.LISTISTARTED);
                    }
                }
                //调用第三方revokeTask接口执行撤销
                approvalTaskService.revokeTask(approvalInfo.getActivitiId(),"审批人驳回审核");
                break;
            case 3:
                if(ainfo.getApprovalStatus() > 1){
                    rj = ResponseJson.getFAILURE();
                    rj.setResultMsg("已审批的订单不允许撤销！");
                    return  rj;
                }
                //修改审批信息状态为撤销
                info.setApprovalStatus(9);
                if(approvalOrderMapper.updateApprovalInfo(info) < 1){
                    rj = ResponseJson.getFAILURE();
                    rj.setResultMsg("修改审批信息状态为撤销失败！");
                    return  rj;
                }
                //删除该审批的历史记录
                approvalOrderMapper.deleteHistoricalRecord(approvalInfo.getApprovalId());

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

    @Override
    public List<ApprovalInventoryRecords> listInventoryRecords(Integer approvalId) {
        return approvalOrderMapper.listInventoryRecords(approvalId);
    }

    @Override
    public AdminApprovalAuthority getApprovalAuthority(Integer adminId) {
        return approvalOrderMapper.getApprovalAuthority(adminId);
    }

    @Override
    public List<AdminApprovalAuthority> listApprovalAuthority(AdminApprovalAuthority adminApprovalAuthority) {
        return approvalOrderMapper.listApprovalAuthority(adminApprovalAuthority);
    }
}