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.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 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.util.*;

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


    @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("未查询到当前登录人信息");
        }
        //添加审批信息
        ApprovalInfo approvalInfo = new ApprovalInfo();
        approvalInfo.setApprovalName(admin.getAdminName()+"的审批订单");
        approvalInfo.setApprovalType(1);
        approvalInfo.setApprovalStatus(1);
        approvalInfo.setAdminId(admin.getAdminId());
        approvalInfo.setApprovalApplicant(approvalProduction.getApplicantName());
        approvalInfo.setActivitiId(tasknfo.get("pid").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("订单编号");
        approvalProduction.setApplicantName(admin.getAdminName());
        //申请人ID
        approvalProduction.setApplicantId(1);
        approvalProduction.setProductionState(1);
        int returnValue2 = approvalOrderMapper.insertApprovalProduction(approvalProduction);
        if(returnValue2 < 1){
            throw new RuntimeException("添加生产审批信息失败");
        }
        //添加合同信息
        for(ApprovalProductionContract approvalProductionContract : productionContracts){
            approvalProductionContract.setApprovalId(approvalProduction.getProductionId());
            approvalProductionContract.setContractName(admin.getAdminName()+"的审批订单合同");
            approvalOrderMapper.insertProductionContract(approvalProductionContract);
        }
        //封装生产审批产品项
        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 = tasknfo.get("users").toString().split(",");
        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());
            if(approvalOrderMapper.insertHistoricalRecord(recordInfo) < 1){
                throw new RuntimeException("添加历史审批信息失败"+tasknfo);
            }
            //修改审核信息表
            info.setApprovalStatusDetails("待"+name+"审批");
            if(approvalOrderMapper.updateApprovalInfo(info) < 1){
                throw new RuntimeException("修改审批信息失败"+tasknfo);
            }
        }
        HistoricalRecord historicalRecord = new HistoricalRecord();
        historicalRecord.setApprovalId(approvalInfo.getApprovalId());
        historicalRecord.setAdminId(admin.getAdminId());
        historicalRecord.setRecordState(1);
        historicalRecord.setTaskId(tasknfo.get("taskId").toString());
        historicalRecord.setApprovalTime(new Date());
        int returnValue5 = approvalOrderMapper.insertHistoricalRecord(historicalRecord);
        if(returnValue5 < 1){
            throw new RuntimeException("添加生产审批历史记录失败");
        }
        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 Integer updateProductionItem(ApprovalProductionItem approvalProductionItem) {
        return approvalOrderMapper.updateProductionItem(approvalProductionItem);
    }

    @Override
    public Integer insertInventoryRecords(ApprovalInventoryRecords approvalInventoryRecords) {
        return approvalOrderMapper.insertInventoryRecords(approvalInventoryRecords);
    }

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