feat(mcp): 新增出库单作废写工具 warehouse.out.void(REQ-20261107-0003)

老系统 /myWarehouseOut/remove 的 MCP 化,只作废已完成(order_state=3)单:
主表/明细置作废+库存原子恢复、商城订单回滚待出库、SN 硬库存回库+LifeCycle
撤销推送、关联入库单级联作废+扣库存、金蝶作废推送、无安装单时送货工单级联软删。
m2TransactionManager 包 m2 写,m1 提交后执行,Redis 失败不回滚。
mallOrderNo 多单需 confirmMulti=true 确认(王恒拍板)。无行级权限,只绑研发专用 scope。
This commit is contained in:
my_local_kimi_dev2
2026-11-07 17:10:22 +08:00
parent a5ad575a70
commit dfc18b17aa
13 changed files with 1379 additions and 0 deletions
@@ -10,6 +10,8 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import javax.sql.DataSource;
@@ -38,4 +40,10 @@ public class M2DataSourceConfig {
bean.setPlugins(syncQueryTimeoutInterceptor);
return bean.getObject();
}
/** m2 写工具(出库作废等)专用事务管理器(拍板结论 2,REQ-20261107-0003)。 */
@Bean(name = "m2TransactionManager")
public PlatformTransactionManager m2TransactionManager(@Qualifier("m2DataSource") DataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
}
}
@@ -23,4 +23,8 @@ public class Warehouse implements Serializable {
private Integer softDelete;
private String warehouseNo;
private String warehouseName;
/** 仓库管理公司ID(硬库存恢复需要) */
private Long agentId;
/** 仓库属性(0:库存商品仓;),电池费用化库存规则需要 */
private Integer warehouseAttribute;
}
@@ -0,0 +1,44 @@
package me.iiv.agent.entity.m2;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import java.io.Serializable;
import java.util.Date;
/** 设备日志(m2.warehouse_hard_log),全列拷贝自 b2 参考实体。 */
@Getter
@Setter
@ToString
@TableName("warehouse_hard_log")
public class WarehouseHardLog implements Serializable {
private static final long serialVersionUID = 1L;
@TableId(value = "id", type = IdType.AUTO)
private Long id;
private Long createId;
private Date createTime;
private Long modifyId;
private Date modifyTime;
private Integer softDelete;
private Long agentId;
private String agentName;
private String outInOrderNo;
private Long materielDefinitionId;
private String materialNo;
private String materielFullName;
private String materielSort;
private Long materielIndexId;
private String specifications;
private String snCode;
private Long warehouseId;
private String warehouseName;
/** 操作类型(0:出库;1:入库;2:撤销) */
private Integer opType;
private Date opTime;
}
@@ -0,0 +1,54 @@
package me.iiv.agent.entity.m2;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import java.io.Serializable;
import java.util.Date;
/** 设备库存(m2.warehouse_hard_stock),全列拷贝自 b2 参考实体。 */
@Getter
@Setter
@ToString
@TableName("warehouse_hard_stock")
public class WarehouseHardStock implements Serializable {
private static final long serialVersionUID = 1L;
@TableId(value = "id", type = IdType.AUTO)
private Long id;
private Long createId;
private Date createTime;
private Long modifyId;
private Date modifyTime;
private Integer softDelete;
private Long agentId;
private String agentName;
private Long warehouseId;
private String warehouseName;
private String outInOrderNo;
private Long materielDefinitionId;
private String materialNo;
private String materielFullName;
private String materielSort;
private Long materielIndexId;
private String specifications;
private String snCode;
private Date outInDate;
/** 库存状态(0:在库;1:已出库;) */
private Integer stockState;
private Integer currentInventory;
private Integer useCustomerType;
private Long useCustomerId;
private String useCustomerName;
private Integer assembleState;
private Long warehouseOwnerId;
private String warehouseOwnerName;
private Integer replaceState;
/** 费用化标识(0:费用化;1:非费用化;) */
private Integer chargeFlag;
}
@@ -58,4 +58,6 @@ public class WarehouseOut implements Serializable {
private String deliveryOrderNo;
private String installOrderNo;
private String pickupOrderNo;
/** 金蝶系统内码(作废推送 SyncJinDieData 的前置条件) */
private Long jindieInternalId;
}
@@ -0,0 +1,8 @@
package me.iiv.agent.mapper.m2;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import me.iiv.agent.entity.m2.WarehouseHardLog;
/** 设备日志 Mapper。 */
public interface WarehouseHardLogMapper extends BaseMapper<WarehouseHardLog> {
}
@@ -0,0 +1,8 @@
package me.iiv.agent.mapper.m2;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import me.iiv.agent.entity.m2.WarehouseHardStock;
/** 设备库存 Mapper。 */
public interface WarehouseHardStockMapper extends BaseMapper<WarehouseHardStock> {
}
@@ -2,7 +2,26 @@ package me.iiv.agent.mapper.m2;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import me.iiv.agent.entity.m2.WarehouseStockManage;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;
/** 库存管理 Mapper。 */
public interface WarehouseStockManageMapper extends BaseMapper<WarehouseStockManage> {
/**
* 原子更新 current_inventory(移植自 publicbeanandmap 用户变量方案的语义):
* 故意不带扣负校验,与老系统 setSql 行为一致——作废/撤销路径允许扣成负数。
*
* @return 影响行数;0 表示仓库行不存在
*/
@Update("UPDATE warehouse_stock_manage"
+ " SET current_inventory = current_inventory + #{delta}, modify_time = NOW()"
+ " WHERE materiel_definition_id = #{mdId} AND warehouse_id = #{whId} AND soft_delete = 0")
int updateCurrentInventory(@Param("mdId") Long mdId, @Param("whId") Long whId, @Param("delta") int delta);
/** 电池费用化库存原子更新(库存商品仓 + 电池物料 + 费用化时才调用)。 */
@Update("UPDATE warehouse_stock_manage"
+ " SET battery_inventory = battery_inventory + #{delta}, modify_time = NOW()"
+ " WHERE materiel_definition_id = #{mdId} AND warehouse_id = #{whId} AND soft_delete = 0")
int updateBatteryInventory(@Param("mdId") Long mdId, @Param("whId") Long whId, @Param("delta") int delta);
}
@@ -0,0 +1,679 @@
package me.iiv.agent.mcp.tool;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.fasterxml.jackson.databind.ObjectMapper;
import me.iiv.agent.entity.m0.User;
import me.iiv.agent.entity.m1.MallGoodsOrder;
import me.iiv.agent.entity.m1.MallOrderMaterial;
import me.iiv.agent.entity.m2.DeliveryOrder;
import me.iiv.agent.entity.m2.DeliveryOrderProcess;
import me.iiv.agent.entity.m2.InstallDistributeDetail;
import me.iiv.agent.entity.m2.Warehouse;
import me.iiv.agent.entity.m2.WarehouseHardLog;
import me.iiv.agent.entity.m2.WarehouseHardStock;
import me.iiv.agent.entity.m2.WarehouseIn;
import me.iiv.agent.entity.m2.WarehouseInDetails;
import me.iiv.agent.entity.m2.WarehouseOut;
import me.iiv.agent.entity.m2.WarehouseOutDetails;
import me.iiv.agent.mapper.m1.MallGoodsOrderMapper;
import me.iiv.agent.mapper.m1.MallOrderMaterialMapper;
import me.iiv.agent.mapper.m2.DeliveryOrderMapper;
import me.iiv.agent.mapper.m2.DeliveryOrderProcessMapper;
import me.iiv.agent.mapper.m2.InstallDistributeDetailMapper;
import me.iiv.agent.mapper.m2.WarehouseHardLogMapper;
import me.iiv.agent.mapper.m2.WarehouseHardStockMapper;
import me.iiv.agent.mapper.m2.WarehouseInDetailsMapper;
import me.iiv.agent.mapper.m2.WarehouseInMapper;
import me.iiv.agent.mapper.m2.WarehouseMapper;
import me.iiv.agent.mapper.m2.WarehouseOutDetailsMapper;
import me.iiv.agent.mapper.m2.WarehouseOutMapper;
import me.iiv.agent.mapper.m2.WarehouseStockManageMapper;
import me.iiv.agent.mcp.McpCallContextHolder;
import me.iiv.agent.mcp.McpErrorCode;
import me.iiv.agent.mcp.ToolCallException;
import me.iiv.agent.mcp.ToolObject;
import me.iiv.agent.mcp.XqTool;
import me.iiv.agent.security.AuthContextHolder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.ai.tool.annotation.Tool;
import org.springframework.ai.tool.annotation.ToolParam;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* 出库单作废工具(REQ-20261107-0003,设计文档 doc/warehouse-out-void-mcp-design.md)。
* 老系统 /myWarehouseOut/remove(WarehouseOutController.java:3040-3206)的 MCP 化:
* 只作废"已完成"(order_state=3) 的出库单,全链路 7 步与老系统逐步对齐。
* 零行级权限,门禁靠"研发专用" scope;必须用户身份 Token(作废人落 remove_user_name + 审计)。
*
* 拍板结论:① mallOrderNo 命中多张已完成单时必须 confirmMulti=true 才作废,否则只回候选清单;
* ② m2 写(主表/明细/库存/硬库存/入库单级联/送货工单)包 m2TransactionManager 一个事务,
* m1(商城回写)在 m2 提交后执行,Redis push 最后且失败不回滚主流程;
* ③ 关联入库单未完成则该单整单拒绝;④ 无 dryRun;⑤ 不发消息通知。
*/
@Component
public class WarehouseOutVoidTools implements ToolObject {
private static final Logger log = LoggerFactory.getLogger(WarehouseOutVoidTools.class);
private static final int ORDER_STATE_DONE = 3;
private static final int ORDER_STATE_VOID = 5;
/** 库存商品仓 + 电池物料索引 + 费用化 → 费用化库存联动(老系统 2025-11-18 规则)。 */
private static final int WAREHOUSE_ATTRIBUTE_STOCK = 0;
private static final long MATERIEL_INDEX_BATTERY = 6L;
private static final int CHARGE_FLAG_EXPENSED = 0;
private static final ObjectMapper JSON = new ObjectMapper();
final WarehouseOutMapper outMapper;
final WarehouseOutDetailsMapper outDetailsMapper;
final WarehouseInMapper inMapper;
final WarehouseInDetailsMapper inDetailsMapper;
final WarehouseStockManageMapper stockManageMapper;
final WarehouseHardStockMapper hardStockMapper;
final WarehouseHardLogMapper hardLogMapper;
final WarehouseMapper warehouseMapper;
final DeliveryOrderMapper deliveryOrderMapper;
final DeliveryOrderProcessMapper deliveryOrderProcessMapper;
final InstallDistributeDetailMapper installDistributeDetailMapper;
final MallGoodsOrderMapper mallGoodsOrderMapper;
final MallOrderMaterialMapper mallOrderMaterialMapper;
final StringRedisTemplate redisTemplate;
final TransactionTemplate m2Tx;
public WarehouseOutVoidTools(WarehouseOutMapper outMapper,
WarehouseOutDetailsMapper outDetailsMapper,
WarehouseInMapper inMapper,
WarehouseInDetailsMapper inDetailsMapper,
WarehouseStockManageMapper stockManageMapper,
WarehouseHardStockMapper hardStockMapper,
WarehouseHardLogMapper hardLogMapper,
WarehouseMapper warehouseMapper,
DeliveryOrderMapper deliveryOrderMapper,
DeliveryOrderProcessMapper deliveryOrderProcessMapper,
InstallDistributeDetailMapper installDistributeDetailMapper,
MallGoodsOrderMapper mallGoodsOrderMapper,
MallOrderMaterialMapper mallOrderMaterialMapper,
StringRedisTemplate redisTemplate,
@Qualifier("m2TransactionManager") PlatformTransactionManager m2TransactionManager) {
this.outMapper = outMapper;
this.outDetailsMapper = outDetailsMapper;
this.inMapper = inMapper;
this.inDetailsMapper = inDetailsMapper;
this.stockManageMapper = stockManageMapper;
this.hardStockMapper = hardStockMapper;
this.hardLogMapper = hardLogMapper;
this.warehouseMapper = warehouseMapper;
this.deliveryOrderMapper = deliveryOrderMapper;
this.deliveryOrderProcessMapper = deliveryOrderProcessMapper;
this.installDistributeDetailMapper = installDistributeDetailMapper;
this.mallGoodsOrderMapper = mallGoodsOrderMapper;
this.mallOrderMaterialMapper = mallOrderMaterialMapper;
this.redisTemplate = redisTemplate;
this.m2Tx = new TransactionTemplate(m2TransactionManager);
}
@XqTool(category = "admin", kind = "write")
@Tool(name = "warehouse.out.void", description = "【写操作·研发/运维专用】作废一张或多张『已完成』的出库单,"
+ "按出库单号(outOrderNo)或电商订单号(mallOrderNo)定位(至少给一个)。"
+ "全链路与老系统出库作废一致:主表/明细置作废、恢复库存、商城订单回滚为待出库、"
+ "SN 硬库存回库并推送生命周期撤销、关联入库单级联作废并扣减库存、金蝶作废推送、"
+ "无安装单时送货工单级联软删。只作废 order_state=3(已完成)的单;"
+ "关联入库单未完成时该单整单拒绝。作废不可逆。"
+ "mallOrderNo 命中多张已完成出库单时默认不作废,返回候选清单,"
+ "需 confirmMulti=true 确认后逐张作废,或改用精确 outOrderNo。"
+ "无行级权限校验;必须用户身份 Token(作废人可追溯),每次调用写审计日志。"
+ "返回逐单 stepResults(每步成败透出,Redis 推送失败不回滚主流程)。")
public Map<String, Object> warehouseOutVoid(
@ToolParam(required = false, description = "出库单号(精确匹配)。与 mallOrderNo 至少给一个;都给时以此为准并校验一致性") String outOrderNo,
@ToolParam(required = false, description = "电商订单号(mall_order_no 精确匹配),可能命中多张出库单") String mallOrderNo,
@ToolParam(required = false, description = "作废原因,写入审计日志与返回") String memo,
@ToolParam(required = false, description = "mallOrderNo 命中多张已完成出库单时的确认开关:默认 false 只返回候选清单不作废,true 逐张作废") Boolean confirmMulti) {
String outNo = StringUtils.hasText(outOrderNo) ? outOrderNo.trim() : null;
String mallNo = StringUtils.hasText(mallOrderNo) ? mallOrderNo.trim() : null;
if (outNo == null && mallNo == null) {
throw new ToolCallException(McpErrorCode.INVALID_ARGUMENT,
"outOrderNo 与 mallOrderNo 至少给一个");
}
User caller = AuthContextHolder.get().getUser();
if (caller == null) {
throw new ToolCallException(McpErrorCode.PERMISSION_DENIED,
"该工具要求用户身份 Token 调用(作废人需可追溯),服务身份 Token 不可用");
}
List<WarehouseOut> orders = locateOrders(outNo, mallNo);
List<WarehouseOut> voidable = new ArrayList<>();
List<Map<String, Object>> skippedOrders = new ArrayList<>();
for (WarehouseOut order : orders) {
if (order.getOrderState() != null && order.getOrderState() == ORDER_STATE_DONE) {
voidable.add(order);
} else {
skippedOrders.add(orderBrief(order, "orderState=" + orderStateText(order.getOrderState())
+ ",只作废已完成(order_state=3)的单"));
}
}
if (voidable.isEmpty()) {
throw new ToolCallException(McpErrorCode.NOT_FOUND_OR_FORBIDDEN,
"没有可作废的出库单(只作废已完成 order_state=3 的单)");
}
String requestId = McpCallContextHolder.currentOrCreateRequestId();
Map<String, Object> result = new LinkedHashMap<>();
// 拍板结论 1:多单必须显式确认
if (outNo == null && voidable.size() > 1 && !Boolean.TRUE.equals(confirmMulti)) {
List<Map<String, Object>> candidates = new ArrayList<>();
for (WarehouseOut order : voidable) {
candidates.add(orderBrief(order, null));
}
result.put("confirmMultiRequired", true);
result.put("candidates", candidates);
result.put("skippedOrders", skippedOrders);
result.put("totalCount", 0);
result.put("successCount", 0);
result.put("requestId", requestId);
log.info("warehouse.out.void 多单待确认 requestId={} mallOrderNo={} candidates={} caller={}",
requestId, mallNo, voidable.size(), caller.getId());
return result;
}
List<Map<String, Object>> results = new ArrayList<>();
int successCount = 0;
int skippedCount = 0;
for (WarehouseOut order : voidable) {
Map<String, Object> one = voidOneOrder(order, caller, memo, requestId);
results.add(one);
if (Boolean.TRUE.equals(one.get("success"))) {
successCount++;
}
if (Boolean.TRUE.equals(one.get("skipped"))) {
skippedCount++;
}
}
result.put("results", results);
result.put("skippedOrders", skippedOrders);
result.put("totalCount", results.size());
result.put("successCount", successCount);
result.put("skippedCount", skippedCount);
result.put("memo", memo);
result.put("requestId", requestId);
return result;
}
/** 按单号定位:outOrderNo 精确单张;否则 mallOrderNo 全量(soft_delete=0)。 */
private List<WarehouseOut> locateOrders(String outNo, String mallNo) {
if (outNo != null) {
List<WarehouseOut> rows = outMapper.selectList(new LambdaQueryWrapper<WarehouseOut>()
.eq(WarehouseOut::getSoftDelete, 0)
.eq(WarehouseOut::getOutOrderNo, outNo));
if (rows.isEmpty()) {
throw new ToolCallException(McpErrorCode.NOT_FOUND_OR_FORBIDDEN,
"出库单号 " + outNo + " 不存在");
}
if (rows.size() > 1) {
throw new ToolCallException(McpErrorCode.DATA_INTEGRITY_ERROR,
"出库单号 " + outNo + " 命中多条记录,请携带 request_id 联系运维排查");
}
WarehouseOut order = rows.get(0);
if (mallNo != null && !mallNo.equals(order.getMallOrderNo())) {
throw new ToolCallException(McpErrorCode.INVALID_ARGUMENT,
"出库单 " + outNo + " 的电商订单号是 " + order.getMallOrderNo()
+ ",与入参 mallOrderNo=" + mallNo + " 不一致");
}
return rows;
}
List<WarehouseOut> rows = outMapper.selectList(new LambdaQueryWrapper<WarehouseOut>()
.eq(WarehouseOut::getSoftDelete, 0)
.eq(WarehouseOut::getMallOrderNo, mallNo)
.orderByAsc(WarehouseOut::getId));
if (rows.isEmpty()) {
throw new ToolCallException(McpErrorCode.NOT_FOUND_OR_FORBIDDEN,
"电商订单号 " + mallNo + " 没有对应出库单");
}
return rows;
}
/** 单张出库单全链路作废。m2 写一个事务;m1 商城回写在提交后;Redis push 最后且失败只记 stepResults。 */
private Map<String, Object> voidOneOrder(WarehouseOut order, User caller, String memo, String requestId) {
Map<String, Object> one = new LinkedHashMap<>();
one.put("outOrderNo", order.getOutOrderNo());
one.put("mallOrderNo", order.getMallOrderNo());
one.put("orderId", order.getId());
List<Map<String, Object>> stepResults = new ArrayList<>();
one.put("stepResults", stepResults);
// 前置校验:关联入库单未完成则整单拒绝(拍板结论 3)
WarehouseIn linkedIn = inMapper.selectOne(new LambdaQueryWrapper<WarehouseIn>()
.eq(WarehouseIn::getSoftDelete, 0)
.eq(WarehouseIn::getOutOrderNo, order.getOutOrderNo())
.last("LIMIT 1"));
if (linkedIn != null && (linkedIn.getOrderState() == null || linkedIn.getOrderState() != ORDER_STATE_DONE)) {
one.put("success", false);
one.put("skipped", true);
one.put("skipReason", "关联的入库单 " + linkedIn.getInOrderNo() + " 未完成"
+ "(orderState=" + linkedIn.getOrderState() + "),不能作废");
return one;
}
List<MallMaterialRestore> mallRestores = new ArrayList<>();
List<String> snCodes = new ArrayList<>();
try {
m2Tx.executeWithoutResult(status -> {
stepResults.add(step("outOrderVoid", true, voidOutOrder(order, caller)));
stepResults.add(step("detailsAndStockRestore", true,
voidDetailsAndRestoreStock(order, mallRestores)));
stepResults.add(step("hardStockRestore", true,
restoreHardStock(order, caller, snCodes)));
stepResults.add(step("linkedInOrderVoid", true,
voidLinkedInOrder(linkedIn, caller)));
stepResults.add(step("deliveryOrderCancel", true, cancelDeliveryOrder(order)));
});
} catch (RuntimeException e) {
log.error("warehouse.out.void m2 事务回滚 requestId={} outOrderNo={} error={}",
requestId, order.getOutOrderNo(), e.getMessage(), e);
one.put("success", false);
one.put("skipped", false);
one.put("error", "m2 事务回滚:" + e.getMessage());
return one;
}
// m2 已提交。m1 商城回写失败不回滚主流程(拍板结论 2)
try {
stepResults.add(step("mallOrderRollback", true, rollbackMallOrder(order, mallRestores)));
} catch (RuntimeException e) {
log.error("warehouse.out.void 商城回滚失败 requestId={} outOrderNo={} error={}",
requestId, order.getOutOrderNo(), e.getMessage(), e);
stepResults.add(step("mallOrderRollback", false, "商城回写失败:" + e.getMessage()));
}
// Redis push 最后,失败只记 stepResults(老系统是 @Async 异步,本就不保证)
try {
stepResults.add(step("lifeCyclePush", true, pushLifeCycle(snCodes)));
} catch (RuntimeException e) {
log.error("warehouse.out.void LifeCycle 推送失败 requestId={} outOrderNo={} error={}",
requestId, order.getOutOrderNo(), e.getMessage(), e);
stepResults.add(step("lifeCyclePush", false, "LifeCycle 推送失败:" + e.getMessage()));
}
try {
stepResults.add(step("jindieSyncPush", true, pushJindieSync(order)));
} catch (RuntimeException e) {
log.error("warehouse.out.void 金蝶推送失败 requestId={} outOrderNo={} error={}",
requestId, order.getOutOrderNo(), e.getMessage(), e);
stepResults.add(step("jindieSyncPush", false, "金蝶推送失败:" + e.getMessage()));
}
one.put("success", true);
one.put("skipped", false);
log.info("warehouse.out.void 作废完成 requestId={} outOrderNo={} orderId={} memo={} caller={}",
requestId, order.getOutOrderNo(), order.getId(), memo, caller.getId());
return one;
}
/** 步骤 1:主表置作废。 */
private String voidOutOrder(WarehouseOut order, User caller) {
int updated = outMapper.update(null, new LambdaUpdateWrapper<WarehouseOut>()
.eq(WarehouseOut::getId, order.getId())
.set(WarehouseOut::getOrderState, ORDER_STATE_VOID)
.set(WarehouseOut::getRemoveDate, new Date())
.set(WarehouseOut::getRemoveUserName, caller.getName())
.set(WarehouseOut::getModifyId, caller.getId())
.set(WarehouseOut::getModifyTime, new Date()));
if (updated != 1) {
throw new IllegalStateException("主表置作废影响行数=" + updated + ",预期 1");
}
return "orderState 3→5";
}
/** 步骤 2:明细置作废 + 汇总行(parent_id=0)恢复库存 + 收集商城回写(m1 延迟到提交后)。 */
private String voidDetailsAndRestoreStock(WarehouseOut order, List<MallMaterialRestore> mallRestores) {
List<WarehouseOutDetails> details = outDetailsMapper.selectList(
new LambdaQueryWrapper<WarehouseOutDetails>()
.eq(WarehouseOutDetails::getSoftDelete, 0)
.eq(WarehouseOutDetails::getWarehouseOutId, order.getId()));
int stockRestoreCount = 0;
Date now = new Date();
for (WarehouseOutDetails detail : details) {
outDetailsMapper.update(null, new LambdaUpdateWrapper<WarehouseOutDetails>()
.eq(WarehouseOutDetails::getId, detail.getId())
.set(WarehouseOutDetails::getOrderState, ORDER_STATE_VOID)
.set(WarehouseOutDetails::getModifyTime, now));
long parentId = detail.getParentId() == null ? 0L : detail.getParentId();
if (parentId != 0L) {
continue;
}
// 作废路径不回写明细库存快照(老系统 :3087 决策)
int outCount = detail.getOutCount() == null ? 0 : detail.getOutCount();
if (outCount > 0) {
stockManageMapper.updateCurrentInventory(
detail.getMaterielDefinitionId(), detail.getWarehouseId(), outCount);
stockRestoreCount++;
}
long mallOrderDetailId = detail.getMallOrderDetailId() == null ? 0L : detail.getMallOrderDetailId();
if (mallOrderDetailId != 0L && outCount > 0) {
mallRestores.add(new MallMaterialRestore(mallOrderDetailId, outCount));
}
}
return "明细" + details.size() + "行置作废,恢复库存" + stockRestoreCount + "项";
}
/** 步骤 4:SN 行硬库存回库(upsert + 日志 + 电池费用化规则),LifeCycle 推迟到提交后 push。 */
private String restoreHardStock(WarehouseOut order, User caller, List<String> snCodes) {
List<WarehouseOutDetails> snRows = outDetailsMapper.selectList(
new LambdaQueryWrapper<WarehouseOutDetails>()
.eq(WarehouseOutDetails::getSoftDelete, 0)
.eq(WarehouseOutDetails::getWarehouseOutId, order.getId())
.ne(WarehouseOutDetails::getParentId, 0));
int restored = 0;
Date now = new Date();
for (WarehouseOutDetails detail : snRows) {
if (!StringUtils.hasText(detail.getSnCode())) {
continue;
}
Warehouse warehouse = detail.getWarehouseId() == null ? null
: warehouseMapper.selectById(detail.getWarehouseId());
Long agentId = warehouse == null ? null : warehouse.getAgentId();
String agentName = lookupAgentName(agentId);
WarehouseHardStock stock = hardStockMapper.selectOne(
new LambdaQueryWrapper<WarehouseHardStock>()
.eq(WarehouseHardStock::getSoftDelete, 0)
.eq(WarehouseHardStock::getMaterielDefinitionId, detail.getMaterielDefinitionId())
.eq(WarehouseHardStock::getSnCode, detail.getSnCode())
.last("LIMIT 1"));
boolean isNew = stock == null;
if (isNew) {
stock = new WarehouseHardStock();
stock.setCreateId(caller.getId());
stock.setCreateTime(now);
stock.setChargeFlag(CHARGE_FLAG_EXPENSED);
}
stock.setAgentId(agentId);
stock.setAgentName(agentName);
stock.setWarehouseId(detail.getWarehouseId());
stock.setWarehouseName(detail.getWarehouseName());
stock.setOutInOrderNo(order.getOutOrderNo());
stock.setMaterielDefinitionId(detail.getMaterielDefinitionId());
stock.setMaterialNo(detail.getMaterialNo());
stock.setMaterielFullName(detail.getMaterielFullName());
stock.setMaterielSort(detail.getMaterielSort());
stock.setMaterielIndexId(detail.getMaterielIndexId());
stock.setSpecifications(detail.getSpecifications());
stock.setSnCode(detail.getSnCode());
stock.setModifyId(caller.getId());
stock.setModifyTime(now);
stock.setCurrentInventory(1);
stock.setOutInDate(now);
stock.setStockState(0); // operation=1 → 在库
if (isNew) {
hardStockMapper.insert(stock);
} else {
hardStockMapper.updateById(stock);
}
WarehouseHardLog hardLog = new WarehouseHardLog();
hardLog.setCreateId(stock.getCreateId());
hardLog.setCreateTime(stock.getCreateTime());
hardLog.setModifyId(stock.getModifyId());
hardLog.setModifyTime(stock.getModifyTime());
hardLog.setSoftDelete(stock.getSoftDelete());
hardLog.setAgentId(stock.getAgentId());
hardLog.setAgentName(stock.getAgentName());
hardLog.setOutInOrderNo(stock.getOutInOrderNo());
hardLog.setMaterielDefinitionId(stock.getMaterielDefinitionId());
hardLog.setMaterialNo(stock.getMaterialNo());
hardLog.setMaterielFullName(stock.getMaterielFullName());
hardLog.setMaterielSort(stock.getMaterielSort());
hardLog.setMaterielIndexId(stock.getMaterielIndexId());
hardLog.setSpecifications(stock.getSpecifications());
hardLog.setSnCode(stock.getSnCode());
hardLog.setWarehouseId(stock.getWarehouseId());
hardLog.setWarehouseName(stock.getWarehouseName());
hardLog.setOpType(1); // 入库(回库)
hardLog.setOpTime(now);
hardLogMapper.insert(hardLog);
// 电池费用化库存规则(老系统 2025-11-18)
if (warehouse != null
&& warehouse.getWarehouseAttribute() != null
&& warehouse.getWarehouseAttribute() == WAREHOUSE_ATTRIBUTE_STOCK
&& detail.getMaterielIndexId() != null
&& detail.getMaterielIndexId() == MATERIEL_INDEX_BATTERY
&& stock.getChargeFlag() != null
&& stock.getChargeFlag() == CHARGE_FLAG_EXPENSED) {
stockManageMapper.updateBatteryInventory(
detail.getMaterielDefinitionId(), detail.getWarehouseId(), 1);
}
snCodes.add(detail.getSnCode());
restored++;
}
if (restored == 0) {
return "无 SN 行,跳过";
}
return "SN " + restored + " 个回库,LifeCycle 待推送";
}
/** 步骤 5:关联入库单级联作废 + 扣库存。 */
private String voidLinkedInOrder(WarehouseIn linkedIn, User caller) {
if (linkedIn == null) {
return "无关联入库单,跳过";
}
Date now = new Date();
inMapper.update(null, new LambdaUpdateWrapper<WarehouseIn>()
.eq(WarehouseIn::getId, linkedIn.getId())
.set(WarehouseIn::getOrderState, ORDER_STATE_VOID)
.set(WarehouseIn::getRemoveDate, now)
.set(WarehouseIn::getRemoveUserName, caller.getName())
.set(WarehouseIn::getModifyId, caller.getId())
.set(WarehouseIn::getModifyTime, now));
List<WarehouseInDetails> inDetails = inDetailsMapper.selectList(
new LambdaQueryWrapper<WarehouseInDetails>()
.eq(WarehouseInDetails::getSoftDelete, 0)
.eq(WarehouseInDetails::getWarehouseInId, linkedIn.getId()));
int stockDeductCount = 0;
for (WarehouseInDetails inDetail : inDetails) {
inDetailsMapper.update(null, new LambdaUpdateWrapper<WarehouseInDetails>()
.eq(WarehouseInDetails::getId, inDetail.getId())
.set(WarehouseInDetails::getOrderState, ORDER_STATE_VOID)
.set(WarehouseInDetails::getGoodInState, ORDER_STATE_VOID)
.set(WarehouseInDetails::getModifyTime, now));
int inCount = inDetail.getInCount() == null ? 0 : inDetail.getInCount();
if (inCount > 0) {
stockManageMapper.updateCurrentInventory(
inDetail.getMaterielDefinitionId(), inDetail.getWarehouseId(), -inCount);
stockDeductCount++;
}
}
return "入库单 " + linkedIn.getInOrderNo() + " 级联作废,扣减库存" + stockDeductCount + "项";
}
/** 步骤 7:无安装单时送货工单级联软删(老系统 cancelDeliveryOrder)。 */
private String cancelDeliveryOrder(WarehouseOut order) {
if (StringUtils.hasText(order.getInstallOrderNo())
|| !StringUtils.hasText(order.getDeliveryOrderNo())) {
return "无关联送货工单或有安装单,跳过";
}
String deliveryOrderNo = order.getDeliveryOrderNo();
Date now = new Date();
int orderRows = deliveryOrderMapper.update(null, new LambdaUpdateWrapper<DeliveryOrder>()
.eq(DeliveryOrder::getSoftDelete, 0)
.eq(DeliveryOrder::getDeliveryOrderNo, deliveryOrderNo)
.set(DeliveryOrder::getSoftDelete, 1)
.set(DeliveryOrder::getModifyTime, now));
int detailRows = installDistributeDetailMapper.update(null,
new LambdaUpdateWrapper<InstallDistributeDetail>()
.eq(InstallDistributeDetail::getSoftDelete, 0)
.eq(InstallDistributeDetail::getDeliveryOrderNo, deliveryOrderNo)
.set(InstallDistributeDetail::getSoftDelete, 1));
int processRows = deliveryOrderProcessMapper.update(null,
new LambdaUpdateWrapper<DeliveryOrderProcess>()
.eq(DeliveryOrderProcess::getSoftDelete, 0)
.eq(DeliveryOrderProcess::getDeliveryOrderNo, deliveryOrderNo)
.set(DeliveryOrderProcess::getSoftDelete, 1)
.set(DeliveryOrderProcess::getModifyTime, now));
return "送货工单 " + deliveryOrderNo + " 软删:主表" + orderRows
+ "行/配发明细" + detailRows + "行/流程" + processRows + "行";
}
/** 步骤 2m/3(m1,提交后执行):商城物料回写 + 商城订单回滚为待出库。 */
private String rollbackMallOrder(WarehouseOut order, List<MallMaterialRestore> mallRestores) {
if (!StringUtils.hasText(order.getMallOrderNo())) {
return "非商城订单,跳过";
}
int restoredMaterials = 0;
for (MallMaterialRestore restore : mallRestores) {
MallOrderMaterial material = mallOrderMaterialMapper.selectById(restore.mallOrderDetailId());
if (material == null) {
continue;
}
int notOutCount = (material.getNotOutCount() == null ? 0 : material.getNotOutCount())
+ restore.outCount();
int beenOutCount = (material.getBeenOutCount() == null ? 0 : material.getBeenOutCount())
- restore.outCount();
int warehouseState = beenOutCount == 0 ? 0 : 2;
mallOrderMaterialMapper.update(null, new LambdaUpdateWrapper<MallOrderMaterial>()
.eq(MallOrderMaterial::getId, material.getId())
.set(MallOrderMaterial::getNotOutCount, notOutCount)
.set(MallOrderMaterial::getBeenOutCount, beenOutCount)
.set(MallOrderMaterial::getWarehouseState, warehouseState)
.setSql("modify_time = NOW()"));
restoredMaterials++;
}
// 订单维度 warehouse_state 汇总:有 2→部分出库;无 2 且无 1→未出库;否则→部分出库
String mallOrderNo = order.getMallOrderNo();
Long partialCount = mallOrderMaterialMapper.selectCount(new LambdaQueryWrapper<MallOrderMaterial>()
.eq(MallOrderMaterial::getSoftDelete, 0)
.eq(MallOrderMaterial::getOrderNo, mallOrderNo)
.eq(MallOrderMaterial::getWarehouseState, 2));
int orderWarehouseState;
if (partialCount != null && partialCount > 0) {
orderWarehouseState = 2;
} else {
Long doneCount = mallOrderMaterialMapper.selectCount(new LambdaQueryWrapper<MallOrderMaterial>()
.eq(MallOrderMaterial::getSoftDelete, 0)
.eq(MallOrderMaterial::getOrderNo, mallOrderNo)
.eq(MallOrderMaterial::getWarehouseState, 1));
orderWarehouseState = (doneCount == null || doneCount == 0) ? 0 : 2;
}
MallGoodsOrder goodsOrder = mallGoodsOrderMapper.selectOne(new LambdaQueryWrapper<MallGoodsOrder>()
.eq(MallGoodsOrder::getSoftDelete, 0)
.eq(MallGoodsOrder::getOrderNo, mallOrderNo)
.last("LIMIT 1"));
if (goodsOrder != null) {
mallGoodsOrderMapper.update(null, new LambdaUpdateWrapper<MallGoodsOrder>()
.eq(MallGoodsOrder::getId, goodsOrder.getId())
.set(MallGoodsOrder::getWarehouseState, orderWarehouseState)
.set(MallGoodsOrder::getOrderState, 1) // 待出库
.set(MallGoodsOrder::getJindieInternalId, 0L)
.set(MallGoodsOrder::getModifyTime, new Date()));
}
return "商城订单回滚为待出库(warehouseState=" + orderWarehouseState
+ "),回写物料" + restoredMaterials + "行";
}
/** 步骤 4r:LifeCycle 撤销推送(与老系统 revokeLifeCycle 报文一致)。 */
private String pushLifeCycle(List<String> snCodes) {
if (snCodes.isEmpty()) {
return "无 SN,跳过";
}
for (String snCode : snCodes) {
Map<String, Object> payload = new LinkedHashMap<>();
payload.put("snCode", snCode);
payload.put("memo", "xiaoqu-franchisee->/revokeLifeCycle出库单作废");
payload.put("messageType", 2);
redisTemplate.opsForList().leftPush("LifeCycle", toJson(payload));
}
return "LifeCycle 撤销推送 " + snCodes.size() + " 条";
}
/** 步骤 6:金蝶作废推送(jindie_internal_id != 0 时)。 */
private String pushJindieSync(WarehouseOut order) {
if (order.getJindieInternalId() == null || order.getJindieInternalId() == 0L) {
return "无金蝶内码,跳过";
}
String business = StringUtils.hasText(order.getMallOrderNo())
? "SAL_SaleOrder_Cancel" : "STK_MisDelivery_Cancel";
Map<String, Object> payload = new LinkedHashMap<>();
payload.put("business", business);
payload.put("businessDataId", order.getOutOrderNo());
redisTemplate.opsForList().leftPush("SyncJinDieData", toJson(payload));
return business;
}
private static String toJson(Map<String, Object> payload) {
try {
return JSON.writeValueAsString(payload);
} catch (Exception e) {
throw new IllegalStateException("JSON 序列化失败:" + e.getMessage(), e);
}
}
/** 仓库所属代理名称:与 franchisee 同实例 Redis 字典 name:Agent:{id},读失败不阻断主流程。 */
private String lookupAgentName(Long agentId) {
if (agentId == null) {
return null;
}
try {
return redisTemplate.opsForValue().get("name:Agent:" + agentId);
} catch (RuntimeException e) {
log.warn("warehouse.out.void 读取 name:Agent:{} 失败:{}", agentId, e.getMessage());
return null;
}
}
private static Map<String, Object> orderBrief(WarehouseOut order, String skipReason) {
Map<String, Object> brief = new LinkedHashMap<>();
brief.put("outOrderNo", order.getOutOrderNo());
brief.put("mallOrderNo", order.getMallOrderNo());
brief.put("orderId", order.getId());
brief.put("orderState", order.getOrderState());
brief.put("orderStateText", orderStateText(order.getOrderState()));
brief.put("outDate", order.getOutDate());
if (skipReason != null) {
brief.put("skipReason", skipReason);
}
return brief;
}
private static Map<String, Object> step(String name, boolean success, String detail) {
Map<String, Object> step = new LinkedHashMap<>();
step.put("step", name);
step.put("success", success);
step.put("detail", detail);
return step;
}
private static String orderStateText(Integer code) {
if (code == null) {
return null;
}
return switch (code) {
case 0 -> "待审核";
case 1 -> "被驳回";
case 2 -> "待出库";
case 3 -> "已完成";
case 4 -> "已撤销";
case 5 -> "作废";
default -> "未知";
};
}
/** 商城物料回写指令(m2 事务内收集,提交后落到 m1)。 */
private record MallMaterialRestore(Long mallOrderDetailId, int outCount) {
}
}