From 1ae9b57657199f46affc9083c39681f1ec934e3f Mon Sep 17 00:00:00 2001
From: Houjie <714924425@qq.com>
Date: 星期一, 26 五月 2025 17:35:29 +0800
Subject: [PATCH] Merge remote-tracking branch 'origin/master'
---
lxzn-module-tms/src/main/java/org/jeecg/modules/tms/service/impl/OutboundOrderServiceImpl.java | 360 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 files changed, 350 insertions(+), 10 deletions(-)
diff --git a/lxzn-module-tms/src/main/java/org/jeecg/modules/tms/service/impl/OutboundOrderServiceImpl.java b/lxzn-module-tms/src/main/java/org/jeecg/modules/tms/service/impl/OutboundOrderServiceImpl.java
index 70bb424..f5cdf56 100644
--- a/lxzn-module-tms/src/main/java/org/jeecg/modules/tms/service/impl/OutboundOrderServiceImpl.java
+++ b/lxzn-module-tms/src/main/java/org/jeecg/modules/tms/service/impl/OutboundOrderServiceImpl.java
@@ -2,32 +2,49 @@
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.date.DateUtil;
+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.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
+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.business.service.impl.FlowMyBusinessServiceImpl;
+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.OutboundOrder;
-import org.jeecg.modules.tms.entity.OutboundDetail;
+import org.jeecg.modules.tms.entity.*;
+import org.jeecg.modules.tms.entity.dto.OutBoundOrderFlowDto;
+import org.jeecg.modules.tms.entity.dto.OutBoundRequestDto;
import org.jeecg.modules.tms.entity.dto.OutboundOrderAndDetailDto;
import org.jeecg.modules.tms.enums.OutBillStatus;
+import org.jeecg.modules.tms.enums.OutBoundStatusEnum;
+import org.jeecg.modules.tms.enums.OutStorehouseType;
+import org.jeecg.modules.tms.enums.ToolCirculationStatus;
import org.jeecg.modules.tms.mapper.OutboundDetailMapper;
import org.jeecg.modules.tms.mapper.OutboundOrderMapper;
-import org.jeecg.modules.tms.service.IOutboundDetailService;
-import org.jeecg.modules.tms.service.IOutboundOrderService;
+import org.jeecg.modules.tms.service.*;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import java.io.Serializable;
-import java.util.List;
-import java.util.Collection;
-import java.util.Map;
-import java.util.Objects;
+import java.math.BigDecimal;
+import java.util.*;
+import java.util.stream.Collectors;
/**
* @Description: tms_outbound_order
@@ -35,13 +52,30 @@
* @Date: 2025-05-16
* @Version: V1.0
*/
+@Slf4j
@Service
-public class OutboundOrderServiceImpl extends ServiceImpl<OutboundOrderMapper, OutboundOrder> implements IOutboundOrderService {
+public class OutboundOrderServiceImpl extends ServiceImpl<OutboundOrderMapper, OutboundOrder> implements IOutboundOrderService, FlowCallBackServiceI {
@Autowired
private IOutboundDetailService outboundDetailService;
@Autowired
+ private IToolLedgerService toolLedgerService;
+ @Autowired
+ private IToolLedgerDetailService toolLedgerDetailService;
+ @Autowired
+ private IOutStoreDetailService outStoreDetailService;
+ @Autowired
private ISysBusinessCodeRuleService businessCodeRuleService;
+ @Autowired
+ private IFlowDefinitionService flowDefinitionService;
+ @Autowired
+ private IFlowMyBusinessService flowMyBusinessService;
+ @Autowired
+ private IFlowTaskService flowTaskService;
+ @Autowired
+ private TaskService taskService;
+ @Autowired
+ private FlowCommonService flowCommonService;
@Autowired
private OutboundOrderMapper outboundOrderMapper;
@Autowired
@@ -73,6 +107,7 @@
save(order);
List<OutboundDetail> detailList = CollectionUtil.newArrayList();
outboundOrder.getOutboundDetailList().forEach(item->{
+ item.setId(null);
item.setOutStorehouseId(order.getId());
detailList.add(item);
});
@@ -122,7 +157,252 @@
outboundDetailService.saveBatch(detailList);
}
- private LoginUser getCurrentUser() {
+ @Override
+ public void submit(String id) {
+ OutboundOrder outboundOrder = getById(id);
+ if (outboundOrder == null) {
+ throw new JeecgBootException("鍑哄簱鍗曠敵璇峰崟涓嶅瓨鍦紝鏃犳硶鎻愪氦锛�");
+ }
+ if (!Objects.equals(outboundOrder.getOrderStatus(), OutBillStatus.DRAFT.getValue())) {
+ throw new JeecgBootException("鏃犳硶鎻愪氦闈炶崏绋跨姸鎬佺殑鍑哄簱鐢宠鍗曪紒");
+ }
+ //鍚姩娴佺▼
+ if (triggerProcess(outboundOrder)) {
+ outboundOrder.setOrderStatus(OutBillStatus.SUBMITTED.getValue());
+ }
+ updateById(outboundOrder);
+ }
+
+ @Transactional(rollbackFor = Exception.class)
+ @Override
+ public void approvalProcess(OutBoundOrderFlowDto outBoundOrderFlowDto) {
+ if (StrUtil.isBlank(outBoundOrderFlowDto.getTaskId()) || StrUtil.isBlank(outBoundOrderFlowDto.getDataId())) {
+ throw new JeecgBootException("闈炴硶鍙傛暟锛�");
+ }
+
+ // 鑾峰彇褰撳墠鐧诲綍鐢ㄦ埛
+ LoginUser user = getCurrentUser();
+ if (user == null || StrUtil.isBlank(user.getId())) {
+ throw new JeecgBootException("璐﹀彿涓嶅瓨鍦�");
+ }
+
+ //鑾峰彇鍑哄簱鐢宠鍗曚俊鎭�
+ OutboundOrder outboundOrder = getById(outBoundOrderFlowDto.getDataId());
+ if (outboundOrder == null) {
+ throw new JeecgBootException("鏈壘鍒板搴旂殑鍑哄簱鐢宠鍗曪紒");
+ }
+
+ //鑾峰彇娴佺▼涓氬姟璁板綍
+ FlowMyBusiness flowMyBusiness = getFlowMyBusiness(outBoundOrderFlowDto.getInstanceId());
+ if (flowMyBusiness == null) {
+ throw new JeecgBootException("娴佺▼璁板綍涓嶅瓨鍦�");
+ }
+
+ // 妫�鏌ョ敤鎴锋槸鍚︽湁鏉冮檺鎿嶄綔浠诲姟
+ if (!isUserAuthorized(flowMyBusiness, user)) {
+ throw new JeecgBootException("鐢ㄦ埛鏃犳潈鎿嶄綔姝や换鍔�");
+ }
+
+ // 璁ら浠诲姟
+ if (!claimTask(flowMyBusiness.getTaskId(), user)) {
+ throw new JeecgBootException("浠诲姟涓嶅瓨鍦ㄣ�佸凡瀹屾垚鎴栧凡琚粬浜鸿棰�");
+ }
+
+ //璁剧疆娴佺▼鍙橀噺
+ setupProcessVariables(outBoundOrderFlowDto, outboundOrder, user);
+
+ //瀹屾垚娴佺▼浠诲姟
+ Result result = flowTaskService.complete(outBoundOrderFlowDto);
+
+ //鏍规嵁浠诲姟瀹屾垚缁撴灉鏇存柊鐢宠鍗曠姸鎬�
+ if (result.isSuccess()) {
+ if (OutBillStatus.APPROVED.getValue().equals(outBoundOrderFlowDto.getStatus())) {
+ outboundOrder.setOutStatus(OutBoundStatusEnum.NOT_OUTBOUND.getValue());
+ outboundOrder.setOrderStatus(OutBillStatus.APPROVED.getValue());
+ }
+ if (OutBillStatus.REJECTED.getValue().equals(outBoundOrderFlowDto.getStatus())) {
+ //濡傛灉椹冲洖锛屽鎵瑰崟鐘舵�佸洖鍒拌崏绋�
+ outboundOrder.setOrderStatus(OutBillStatus.DRAFT.getValue());
+ }
+ outboundOrder.setAuditDate(new Date());
+ outboundOrder.setApprovalOpinion(outBoundOrderFlowDto.getApprovalOpinion());
+ updateById(outboundOrder);
+ }
+ }
+
+ @Override
+ @Transactional(rollbackFor = Exception.class)
+ public void outBound(List<OutBoundRequestDto> outBoundRequestList) {
+ //鏍￠獙鏄惁鏉ヨ嚜涓�涓敵璇峰崟
+ if (!fromOneApply(outBoundRequestList)) {
+ throw new JeecgBootException("鍑哄簱鏄庣粏蹇呴』鏉ヨ嚜鍚屼竴鍑哄簱鐢宠鍗曪紒");
+ }
+ //鏄惁鍙嚭搴撴牎楠�
+ if (!readyToOutbound(outBoundRequestList)) {
+ throw new JeecgBootException("鏈粡瀹℃壒閫氳繃鐨勭敵璇峰崟涓嶈兘鍑哄簱锛�");
+ }
+ //寮�濮嬪嚭搴�
+ OutboundOrder outboundOrder = getById(outBoundRequestList.get(0).getOutBoundOrderId());
+ List<String> detailIds = outBoundRequestList.stream().map(OutBoundRequestDto::getOutboundDetailId).collect(Collectors.toList());
+ List<OutboundDetail> outboundDetailList = outboundDetailService.listByIds(detailIds);
+ List<String> toolIdList = outboundDetailList.stream().map(OutboundDetail::getToolCode).collect(Collectors.toList());
+
+ Map<String, BigDecimal> outBoundRequestMap = outBoundRequestList.stream()
+ .collect(Collectors.toMap(OutBoundRequestDto::getOutboundDetailId, OutBoundRequestDto::getOutboundQuantity));
+ //澶勭悊搴撳瓨鍙拌处鍙婂彴璐︽槑缁�
+ Map<String, ToolLedger> toolLedgerMap = toolLedgerService.list(new LambdaQueryWrapper<ToolLedger>().in(ToolLedger::getToolId, toolIdList)).stream()
+ .collect(Collectors.toMap(ToolLedger::getToolId, item -> item, (k1, k2) -> k1));
+
+ LambdaQueryWrapper<ToolLedgerDetail> queryWrapper = new LambdaQueryWrapper<>();
+ for (int i = 0; i < outboundDetailList.size(); i++) {
+ if (i > 0) {
+ queryWrapper.or();
+ }
+ OutboundDetail detail = outboundDetailList.get(i);
+ queryWrapper.and(wrapper ->
+ wrapper.eq(ToolLedgerDetail::getToolCode, detail.getToolCode())
+ .eq(ToolLedgerDetail::getToolId, detail.getToolId()) //濡傛灉涓嶇鍒版妸锛岃瀛楁涓虹┖
+ );
+ }
+ List<ToolLedgerDetail> toolLedgerDetailList = toolLedgerDetailService.list(queryWrapper);
+ List<ToolLedger> toolLedgerUpdateList = CollectionUtil.newArrayList();
+ List<ToolLedgerDetail> toolLedgerDetailUpdateList = CollectionUtil.newArrayList();
+ List<OutStoreDetail> outStoreAddList = CollectionUtil.newArrayList();
+ List<OutboundDetail> outboundDetailUpdateList = CollectionUtil.newArrayList();
+
+ for (OutboundDetail detail : outboundDetailList) {
+ //鏇存柊搴撳瓨鍙拌处
+ ToolLedger toolLedger = toolLedgerMap.get(detail.getToolCode());
+ BigDecimal outboundQuantity = outBoundRequestMap.get(detail.getId());
+ OutStorehouseType outStorehouseType = OutStorehouseType.getByValue(outboundOrder.getOutStorehouseType());
+ switch (outStorehouseType) {
+ case TOOL_BORROW:
+ toolLedger.setLendCount(toolLedger.getLendCount().add(outboundQuantity));
+ break;
+ case MAINTENANCE_OUTBOUND:
+ toolLedger.setRepairCount(toolLedger.getRepairCount().add(outboundQuantity));
+ break;
+ case CALIBRATION_OUTBOUND:
+ toolLedger.setDetectionCount(toolLedger.getDetectionCount().add(outboundQuantity));
+ break;
+ case GRINDING_OUTBOUND:
+ toolLedger.setSharpeningCount(toolLedger.getSharpeningCount().add(outboundQuantity));
+ break;
+ default:
+ throw new JeecgBootException("鏈煡鐨勫嚭搴撶被鍨嬶紒");
+ }
+ toolLedgerUpdateList.add(toolLedger);
+
+ //鏇存柊鍙拌处鏄庣粏
+ toolLedgerDetailList.stream().filter(item -> item.getToolCode().equals(detail.getToolCode()) && item.getToolId().equals(detail.getToolId()))
+ .findFirst().ifPresent(item -> {
+ if (StrUtil.isNotBlank(item.getToolId())) {
+ item.setQuantity(BigDecimal.ZERO);
+ switch (outStorehouseType) {
+ case TOOL_BORROW:
+ item.setStatus(ToolCirculationStatus.BORROWED.getValue());
+ break;
+ case MAINTENANCE_OUTBOUND:
+ item.setStatus(ToolCirculationStatus.REPAIRING.getValue());
+ break;
+ case CALIBRATION_OUTBOUND:
+ item.setStatus(ToolCirculationStatus.INSPECTING.getValue());
+ break;
+ case GRINDING_OUTBOUND:
+ item.setStatus(ToolCirculationStatus.GRINDING.getValue());
+ break;
+ default:
+ throw new JeecgBootException("鏈煡鐨勫嚭搴撶被鍨嬶紒");
+ }
+ } else {
+ item.setQuantity(item.getQuantity().subtract(outboundQuantity));
+ }
+ toolLedgerDetailUpdateList.add(item);
+ });
+
+ //璁板綍鍑哄簱娴佹按
+ OutStoreDetail outStoreDetail = new OutStoreDetail()
+ .setToolCode(detail.getToolCode())
+ .setToolId(detail.getToolId())
+ .setOutStorehouseType(outboundOrder.getOutStorehouseType())
+ .setGoodsShelvesCode(detail.getOutboundLocation())
+ .setOutNumber(outboundQuantity)
+ .setOutStorehouseId(outboundOrder.getId())
+ .setOperateType("1");//1锛氭寜鐢宠鍗�
+ outStoreAddList.add(outStoreDetail);
+
+ //鏇存柊鐢宠鍗曟槑缁�
+ detail.setOutActualCount(detail.getOutActualCount().add(outboundQuantity));
+ detail.setOutboundTime(new Date());
+ if (detail.getOutActualCount().compareTo(detail.getOutboundQuantity()) == 0) {
+ detail.setStatus(OutBoundStatusEnum.COMPLETED.getValue());
+ } else {
+ detail.setStatus(OutBoundStatusEnum.PARTIAL_OUTBOUND.getValue());
+ }
+ outboundDetailUpdateList.add(detail);
+ }
+ toolLedgerService.updateBatchById(toolLedgerUpdateList);
+ toolLedgerDetailService.updateBatchById(toolLedgerDetailUpdateList);
+ outStoreDetailService.saveBatch(outStoreAddList);
+ outboundDetailService.updateBatchById(outboundDetailUpdateList);
+
+ //鏇存柊鐢宠鍗�
+ boolean allMatch = outboundDetailService.list(new LambdaQueryWrapper<OutboundDetail>()
+ .eq(OutboundDetail::getOutStorehouseId, outboundOrder.getId()))
+ .stream().filter(i -> !detailIds.contains(i.getId()))
+ .allMatch(i -> i.getStatus().equals(OutBoundStatusEnum.COMPLETED.getValue()));
+ List<OutboundDetail> partialOutboundList = outboundDetailUpdateList.stream()
+ .filter(i -> !i.getStatus().equals(OutBoundStatusEnum.COMPLETED.getValue())).collect(Collectors.toList());
+ if (allMatch && partialOutboundList.isEmpty()) {
+ outboundOrder.setOutStatus(OutBoundStatusEnum.COMPLETED.getValue());
+ } else {
+ outboundOrder.setOutStatus(OutBoundStatusEnum.PARTIAL_OUTBOUND.getValue());
+ }
+ outboundOrder.setOutboundTime(new Date());
+ updateById(outboundOrder);
+ }
+
+ private boolean fromOneApply(List<OutBoundRequestDto> outBoundRequestList) {
+ long count = outBoundRequestList.stream().map(OutBoundRequestDto::getOutBoundOrderId).distinct().count();
+ if (count > 1) {
+ return false;
+ }
+ List<String> outDetailIds = outBoundRequestList.stream().map(OutBoundRequestDto::getOutboundDetailId).collect(Collectors.toList());
+ String outboundDetailId = outBoundRequestList.get(0).getOutboundDetailId();
+ OutboundDetail outboundDetail = outboundDetailService.getById(outboundDetailId);
+ List<String> detailIds = outboundDetailService.list(new LambdaQueryWrapper<OutboundDetail>()
+ .eq(OutboundDetail::getOutStorehouseId, outboundDetail.getOutStorehouseId())).stream()
+ .map(OutboundDetail::getId).collect(Collectors.toList());
+ return new HashSet<>(detailIds).containsAll(outDetailIds);
+ }
+
+ private boolean readyToOutbound(List<OutBoundRequestDto> outBoundRequestList) {
+ String outBoundOrderId = outBoundRequestList.get(0).getOutBoundOrderId();
+ OutboundOrder outboundOrder = getById(outBoundOrderId);
+ return OutBillStatus.APPROVED.getValue().equals(outboundOrder.getOrderStatus());
+ }
+
+ public boolean triggerProcess(OutboundOrder outboundOrder) {
+ flowCommonService.initActBusiness("鍗曞彿涓猴細" + outboundOrder.getOutNum() + " 鐨勫嚭搴撶敵璇凤紝寮�濮嬭繘琛屽鎵�",
+ outboundOrder.getId(), "outboundOrderServiceImpl", "tool_out_storage", null);
+ Map<String, Object> variables = new HashMap<>();
+ variables.put("dataId", outboundOrder.getId());
+ if (StrUtil.isEmpty(outboundOrder.getRemark())) {
+ variables.put("organization", "鏂板鍑哄簱鐢宠鍗曢粯璁ゅ惎鍔ㄦ祦绋�");
+ variables.put("comment", "鏂板鍑哄簱鐢宠鍗曢粯璁ゅ惎鍔ㄦ祦绋�");
+ } else {
+ variables.put("organization", outboundOrder.getRemark());
+ variables.put("comment", outboundOrder.getRemark());
+ }
+ variables.put("proofreading", true);
+ List<String> usernames = new ArrayList<>();
+ usernames.add(outboundOrder.getReviewer());
+ variables.put("NextAssignee", usernames);
+ Result result = flowDefinitionService.startProcessInstanceByKey("tool_out_storage", variables);
+ return result.isSuccess();
+ }
+
+ private LoginUser getCurrentUser() {
// 鑾峰彇褰撳墠璁よ瘉鐨勭櫥褰曠敤鎴蜂俊鎭�
Subject currentUser = SecurityUtils.getSubject();
if (currentUser != null && currentUser.isAuthenticated()) {
@@ -133,4 +413,64 @@
}
return null;
}
+
+ 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;
+ }
+
+ private void setupProcessVariables(OutBoundOrderFlowDto outBoundOrderFlowDto, OutboundOrder outboundOrder, LoginUser user) {
+ if (OutBillStatus.SUBMITTED.getValue().equals(outboundOrder.getOrderStatus()) && user.getUsername().equals(outboundOrder.getReviewer())) {
+ Map<String, Object> values = new HashMap<>();
+ values.put("dataId", outboundOrder.getId());
+ values.put("organization", outBoundOrderFlowDto.getApprovalOpinion());
+ values.put("comment", outBoundOrderFlowDto.getApprovalOpinion());
+ values.put("status", outBoundOrderFlowDto.getStatus());
+ values.put("NextAssignee", Collections.singletonList(outboundOrder.getReviewer()));
+ outBoundOrderFlowDto.setValues(values);
+ }
+ }
+
+ @Override
+ public void afterFlowHandle(FlowMyBusiness business) {
+ business.getTaskNameId();//鎺ヤ笅鏉ュ鎵圭殑鑺傜偣
+ business.getValues();//鍓嶇浼犺繘鏉ョ殑鍙傛暟
+ business.getActStatus();
+ }
+
+ @Override
+ public Object getBusinessDataById(String dataId) {
+ return this.getById(dataId);
+ }
+
+ @Override
+ public Map<String, Object> flowValuesOfTask(String taskNameId, Map<String, Object> values) {
+ return Collections.emptyMap();
+ }
+
+ @Override
+ public List<String> flowCandidateUsernamesOfTask(String taskNameId, Map<String, Object> values) {
+ //涓氬姟鏄惁骞查娴佺▼锛屼笟鍔″共棰勶紝娴佺▼骞查锛屾寚瀹氫汉鍛樿繘琛屽鐞�
+ //鑾峰彇涓嬩竴姝ュ鐞嗕汉
+ Object object = values.get("NextAssignee");
+ return (List<String>) object;
+ }
}
--
Gitblit v1.9.3