工具报损-审批提交(扣减库存/更新台账状态/更新单据审批状态)

Houjie

2025-05-26 06ddb489776d6d3859238ae89724efc9db8d7e9d

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/service/impl/ToolsLossBoundServiceImpl.java

@@ -4,27 +4,39 @@
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.shiro.SecurityUtils;
import org.flowable.engine.TaskService;
import org.flowable.task.api.Task;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.modules.flowable.apithird.business.entity.FlowMyBusiness;
import org.jeecg.modules.flowable.apithird.business.service.IFlowMyBusinessService;
import org.jeecg.modules.flowable.apithird.service.FlowCallBackServiceI;
import org.jeecg.modules.flowable.apithird.service.FlowCommonService;
import org.jeecg.modules.flowable.service.IFlowDefinitionService;
import org.jeecg.modules.flowable.service.IFlowTaskService;
import org.jeecg.modules.system.service.ISysBusinessCodeRuleService;
import org.jeecg.modules.tms.entity.ToolLedger;
import org.jeecg.modules.tms.entity.ToolLedgerDetail;
import org.jeecg.modules.tms.entity.ToolsLossBound;
import org.jeecg.modules.tms.entity.ToolsLossBoundDetail;
import org.jeecg.modules.tms.entity.dto.LossBoundFlowDto;
import org.jeecg.modules.tms.enums.OutBillStatus;
import org.jeecg.modules.tms.enums.OutBoundStatusEnum;
import org.jeecg.modules.tms.mapper.ToolsLossBoundDetailMapper;
import org.jeecg.modules.tms.mapper.ToolsLossBoundMapper;
import org.jeecg.modules.tms.service.IToolLedgerDetailService;
import org.jeecg.modules.tms.service.IToolLedgerService;
import org.jeecg.modules.tms.service.IToolsLossBoundDetailService;
import org.jeecg.modules.tms.service.IToolsLossBoundService;
import org.springframework.beans.factory.annotation.Autowired;
@@ -32,6 +44,7 @@

import javax.annotation.Resource;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.*;

/**
@@ -58,7 +71,16 @@
    private IFlowTaskService flowTaskService;
    @Autowired
    private ISysBusinessCodeRuleService businessCodeRuleService;
    @Autowired
    private IFlowMyBusinessService flowMyBusinessService;
    @Autowired
    private TaskService taskService;

    @Autowired
    private IToolLedgerService toolLedgerService;

    @Autowired
    private IToolLedgerDetailService toolLedgerDetailService;

    @Override
    public void delMain(String id) {
@@ -77,9 +99,9 @@
    @Override
    public void addTotal(ToolsLossBound toolsLossBound) {
        LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
         if (loginUser != null){
             toolsLossBound.setHandler(loginUser.getId());
         }
        if (loginUser != null) {
            toolsLossBound.setHandler(loginUser.getId());
        }
        toolsLossBound.setOrderCode(businessCodeRuleService.generateBusinessCodeSeq("LossBound"));
        toolsLossBound.setOrderStatus(OutBillStatus.DRAFT.getValue());
        save(toolsLossBound);
@@ -115,8 +137,7 @@
    @Override
    public void editTotal(ToolsLossBound toolsLossBound) {
        //删除所有明细
        toolsLossBoundDetailService.remove(new LambdaQueryWrapper<ToolsLossBoundDetail>()
                .eq(ToolsLossBoundDetail::getLossBoundId, toolsLossBound.getId()));
        toolsLossBoundDetailService.remove(new LambdaQueryWrapper<ToolsLossBoundDetail>().eq(ToolsLossBoundDetail::getLossBoundId, toolsLossBound.getId()));
        ToolsLossBound toolsLossBound1 = BeanUtil.copyProperties(toolsLossBound, ToolsLossBound.class);
        this.baseMapper.updateById(toolsLossBound1);
        List<ToolsLossBoundDetail> detailList = CollectionUtil.newArrayList();
@@ -137,8 +158,7 @@
        } else {
            toolsLossBound.setReviewer(toolsLossBound.getReviewer());

            flowCommonService.initActBusiness("报损单号:" + toolsLossBound.getOrderCode() + ";报损人: " + toolsLossBound.getLosser() + ";进行报损",
                    toolsLossBound.getId(), "IToolsStocktakingBoundService", "tools_Loss_Approval", null);
            flowCommonService.initActBusiness("报损单号:" + toolsLossBound.getOrderCode() + ";报损人: " + toolsLossBound.getLosser() + ";进行报损", toolsLossBound.getId(), "IToolsStocktakingBoundService", "tools_Loss_Approval", null);
            Map<String, Object> variables = new HashMap<>();
            variables.put("dataId", toolsLossBound.getId());
            if (StrUtil.isEmpty(toolsLossBound.getReviewer())) {
@@ -165,6 +185,144 @@
    }

    @Override
    public void approvalProcess(LossBoundFlowDto lossBoundFlowDto) {
        if (StrUtil.isBlank(lossBoundFlowDto.getTaskId()) || StrUtil.isBlank(lossBoundFlowDto.getDataId())) {
            throw new JeecgBootException("非法参数！");
        }

        // 获取当前登录用户
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        if (user == null || StrUtil.isBlank(user.getId())) {
            throw new JeecgBootException("账号不存在");
        }

        //获取报损单信息
        ToolsLossBound toolsLossBound = getById(lossBoundFlowDto.getDataId());
        if (toolsLossBound == null) {
            throw new JeecgBootException("未找到对应的出库申请单！");
        }

        //获取流程业务记录
        FlowMyBusiness flowMyBusiness = getFlowMyBusiness(lossBoundFlowDto.getInstanceId());
        if (flowMyBusiness == null) {
            throw new JeecgBootException("流程记录不存在");
        }

        // 检查用户是否有权限操作任务
        if (!isUserAuthorized(flowMyBusiness, user)) {
            throw new JeecgBootException("用户无权操作此任务");
        }

        // 认领任务
        if (!claimTask(flowMyBusiness.getTaskId(), user)) {
            throw new JeecgBootException("任务不存在、已完成或已被他人认领");
        }

        //设置流程变量
        setupProcessVariables(lossBoundFlowDto, toolsLossBound, user);

        //完成流程任务
        Result result = flowTaskService.complete(lossBoundFlowDto);

        //根据任务完成结果更新申请单状态
        if (result.isSuccess()) {
            toolsLossBound.setOrderStatus(lossBoundFlowDto.getStatus());
            if (OutBillStatus.APPROVED.getValue().equals(lossBoundFlowDto.getStatus())) {
                toolsLossBound.setOrderStatus(OutBoundStatusEnum.NOT_OUTBOUND.getValue());
            }
            /**
             * 更新审批时间、审批意见 更新库存扣减 库存总数
             * 获取工具明细列表，遍历每个工具明细，更新对应的工具库存记录。
             * 对于每个工具，获取对应的工具库存记录（ToolLedger），并更新总库存数量（totalCount）和损失数量（lossCount）。
             * 确保在更新总库存数量之前，检查总库存数量是否大于或等于损失数量。如果不满足条件，抛出异常或进行其他处理。
             * 最后，保存更新后的工具库存记录。
             */

            List<ToolsLossBoundDetail> detailList = toolsLossBound.getToolsLossBoundDetailList();

            if (CollectionUtils.isEmpty(detailList)) {
                throw new JeecgBootException("报损明细为空，无法进行库存扣减");
            }
            Map<String, BigDecimal> toolLossMap = new HashMap<>();
            for (ToolsLossBoundDetail item : detailList) {
                if (item.getToolId() == null || item.getLossNumber() == null) {
                    continue; //
                }
                toolLossMap.put(item.getToolId(), toolLossMap.getOrDefault(item.getToolId(), BigDecimal.ZERO).add(item.getLossNumber()));
            }
            /**
             * 遍历每个 toolId，更新对应的 ToolLedger
             */
            for (Map.Entry<String, BigDecimal> entry : toolLossMap.entrySet()) {
                String toolId = entry.getKey();
                BigDecimal totalLossNumber = entry.getValue();

                ToolLedger toolLedger = toolLedgerService.getOne(new QueryWrapper<ToolLedger>().eq("id", toolId));
                if (toolLedger == null) {
                    throw new JeecgBootException("未找到对应的工具库存记录，toolId：" + toolId);
                }

                // 扣减总库存
                if (toolLedger.getTotalCount() != null && toolLedger.getTotalCount().compareTo(totalLossNumber) >= 0) {
                    toolLedger.setTotalCount(toolLedger.getTotalCount().subtract(totalLossNumber));
                    toolLedger.setLossCount(toolLedger.getLossCount().add(totalLossNumber));
                } else {
                    throw new JeecgBootException("库存不足，无法完成报损操作，toolId：" + toolId);
                }

                // 更新数据库中的 ToolLedger
                toolLedgerService.updateById(toolLedger);
                /**
                 * 新增逻辑：更新台账明细表 ToolLedgerDetail 中的状态字段为 6
                 */
                UpdateWrapper<ToolLedgerDetail> updateWrapper = new UpdateWrapper<>();
                updateWrapper.eq("tool_id", toolId)
                        .set("status", 6);         // 状态设置为 6

                toolLedgerDetailService.update(updateWrapper);
            }

            toolsLossBound.setApprovalDate(new Date());
            toolsLossBound.setApprovalOpinion(lossBoundFlowDto.getApprovalOpinion());
            updateById(toolsLossBound);
        }
    }

    private void setupProcessVariables(LossBoundFlowDto lossBoundFlowDto, ToolsLossBound toolsLossBound, LoginUser user) {
        if (OutBillStatus.SUBMITTED.getValue().equals(toolsLossBound.getOrderStatus()) && user.getUsername().equals(toolsLossBound.getReviewer())) {
            Map<String, Object> values = new HashMap<>();
            values.put("dataId", toolsLossBound.getId());
            values.put("organization", lossBoundFlowDto.getApprovalOpinion());
            values.put("comment", lossBoundFlowDto.getApprovalOpinion());
            values.put("status", lossBoundFlowDto.getStatus());
            values.put("NextAssignee", Collections.singletonList(toolsLossBound.getReviewer()));
            lossBoundFlowDto.setValues(values);
        }
    }

    private FlowMyBusiness getFlowMyBusiness(String instanceId) {
        List<FlowMyBusiness> businessList = flowMyBusinessService.list(new LambdaQueryWrapper<FlowMyBusiness>().eq(FlowMyBusiness::getProcessInstanceId, instanceId));
        return businessList.isEmpty() ? null : businessList.get(0);
    }

    private boolean isUserAuthorized(FlowMyBusiness flowMyBusiness, LoginUser user) {
        List<String> todoUsers = JSON.parseArray(flowMyBusiness.getTodoUsers(), String.class);
        return todoUsers != null && todoUsers.contains(user.getUsername());
    }

    private boolean claimTask(String taskId, LoginUser user) {
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        if (task == null) {
            return false;
        }
        if (task.getAssignee() != null && !task.getAssignee().equals(user.getUsername())) {
            return false;
        }
        taskService.claim(taskId, user.getUsername());
        return true;
    }

    @Override
    public void afterFlowHandle(FlowMyBusiness business) {
        business.getTaskNameId();//接下来审批的节点
        business.getValues();//前端传进来的参数