feat(mcp): 新增设备转固定资产写工具 device.lifecycle.fixed_asset.update(REQ-20261117-0003)

按 SN 精确匹配把 device_life_cycle.asset_state 转为固定资产(1),memo 写来源状态文案;
已是固定资产/已报废守卫拒绝,null 按库存商品处理;只写 asset_state/memo/modify_id/
modify_time 四列,不联动资产卡片/金蝶;零行级权限,prod 只绑研发专用 scope 6。
DeviceLifeCycle 实体补 memo 字段映射(DB 列早已存在,老系统从未映射)。
This commit is contained in:
my_local_kimi_dev2
2026-11-17 09:41:24 +08:00
parent e042f62c34
commit 37ce5a3443
6 changed files with 449 additions and 0 deletions
+1
View File
@@ -106,6 +106,7 @@ xiaoqu-agent-service/
| `warehouse.order.handler.update` | admin | write | 仓库单据当前待办处理人改派(平台首个写工具,研发/运维专用,REQ-20261107-0002)。入参 orderType(out/in/allocation/transfer)/orderNo/newHandlerMobile 或 newHandlerName(二选一,均 m0 user 精确匹配+soft_delete=0,姓名需唯一命中,同传需一致,REQ-20261107-0004)/memo;UPDATE 流程物理表 schedule_state=1 待办行的 user_id/user_name(并行多行全改派),调拨/划转同步改主表 warehouse_allocation.next_user_name 待办人,出库/入库不动主表,不发消息;无行级权限,只绑"研发专用" scope,服务身份 Token 拒绝。详细设计见 doc/warehouse-order-handler-update-mcp-design.md |
| `warehouse.out.void` | admin | write | 出库单作废(研发/运维专用,REQ-20261107-0003,老系统 /myWarehouseOut/remove 的 MCP 化)。入参 outOrderNo/mallOrderNo(至少一个)/memo/confirmMulti;只作废已完成(order_state=3)单,全链路 7 步:主表/明细置作废、库存恢复、商城回滚待出库、SN 硬库存回库+LifeCycle 撤销推送、关联入库单级联作废+扣库存、金蝶作废推送、无安装单时送货工单级联软删;m2 一个事务、m1 提交后执行、Redis 最后且失败不回滚;mallOrderNo 多单需 confirmMulti=true 否则只回候选清单;无行级权限,只绑"研发专用" scope,用户身份 Token 调用。详细设计见 doc/warehouse-out-void-mcp-design.md |
| `sms.vercode.latest.query` | admin | read | 短信验证码提取(研发/测试专用,REQ-20261113-0009)。入参 mobile(11 位手机号精确匹配);查 m0 sms_send_record 中 buss_type=验证码+soft_delete=0 的 id DESC 首条,正则 `验证码\s*[=::]\s*(\d{4,8})` 从 sms_content 提取数字码(不命中 vercode=null+原始内容不报错);send_state 不过滤(失败记录也返回并配文案);返回 vercode/sendState/sendStateText/createTime/ageSeconds(供判断 90 秒 redis 有效期);无记录 record=null+notice。验证码=登录敏感原语,零行级权限,全平台唯一显式排除业务 scope 的工具:prod 只绑研发专用 scope 6、dev 只绑测试专用 scope。详细设计见 doc/sms-vercode-latest-mcp-design.md |
| `device.lifecycle.fixed_asset.update` | admin | write | 设备转固定资产(研发/运维专用,REQ-20261117-0003)。入参 snCode(精确匹配 sn_code,不模糊);UPDATE m0 device_life_cycle 的 asset_state→1(固定资产),memo 自动写「从<原状态>变成固定资产」,补 modify_id/modify_time;允许来源 0库存/2出租/3售出/5费用化/null,已是固定资产(1)与已报废(4)报错拒绝(目标状态固定 1,固定资产永远不会被改成其他状态);重复 SN 取 id 最早一条;只写 asset_state/memo/modify_id/modify_time 四列,不动 last_op_* 流转字段、不生成资产卡片、不触发金蝶同步;无行级权限,只绑"研发专用" scope,服务身份 Token 拒绝。详细设计见 doc/device-lifecycle-fixed-asset-mcp-design.md |
分页统一规范:page 从 1 开始,rows 默认 20、上限 100,超出截断为 100 并在返回 `notice` 字段提示。
@@ -1287,6 +1287,31 @@
---
## 55. device.lifecycle.fixed_asset.update
设备转固定资产(写操作,REQ-20261117-0003),研发/运维专用。
- 分类:admin | 类型:写(readOnlyHint=false)
- 入参:`snCode`(必填,trim 后非空,**精确匹配** `sn_code`,不模糊)。
- 行为:`sn_code=? AND soft_delete=0 ORDER BY id ASC LIMIT 1` 定位记录(重复 SN 取最早一条,与老系统同口径);
UPDATE 该行的 `asset_state=1`(固定资产)、`memo='从<原状态文案>变成固定资产'`、
`modify_id=调用方用户 id`、`modify_time=now()`——只写这四列,
不动 exchange_state/last_op_*/jindie_* 等流转与同步字段。
- 守卫(王恒 2026-11-17 拍板):已是固定资产(1) → INVALID_ARGUMENT「不允许重复转换」
(工具目标状态固定为 1,固定资产永远不会被改成其他状态);已报废(4) → INVALID_ARGUMENT;
asset_state 为 null 的历史行按 0(库存商品)处理。允许来源:0库存商品/2出租/3售出/5费用化/null。
- 返回:`snCode/deviceType/deviceTypeText/oldAssetState/oldAssetStateText/newAssetState/
newAssetStateText/memo/modifyTime/requestId`。
- 权限:零行级权限,访问控制完全靠专用 scope 门禁——prod 只绑研发专用 scope 6(code=code)、
dev 只绑测试专用 scope(code=test,seed-dev.sql kind=write 自动段覆盖);必须用户身份 Token
(操作人落 modify_id + audit_log),服务身份 Token 拒绝。
- 联动边界:只改 device_life_cycle 一表;**不**生成 m2 asset_info 资产卡片
(卡片由设备上线队列任务驱动,另一条链路)、**不**触发金蝶同步。
详细设计见 [device-lifecycle-fixed-asset-mcp-design](device-lifecycle-fixed-asset-mcp-design.md)。
---
## 附录:在线查看工具清单
```bash
@@ -0,0 +1,118 @@
# 设备转固定资产 MCP 工具设计
- 需求:REQ-20261117-0003(id 6618,设计任务 27534)
- 状态:**审批通过**(2026-11-17 王恒拍板,见 §5)
- 作者:王恒分身(Kimi)
- 日期:2026-11-17
## 1. 背景与目标
运维侧需要一个把设备资产生命周期记录「转固定资产」的写工具:按 SN 精确匹配,把 `device_life_cycle.asset_state` 从其他状态改成 **固定资产(1)**,并在 `memo` 写明来源状态。老系统没有独立的「转固定资产」接口(asset_state 都随出入库流程联动变化),目前只能人工改库。
用户拍板口径(2026-11-17 原话):
- 输入就是 SN 号,精确匹配,不模糊
- 可以从其他状态变成固定资产;**不允许从固定资产状态变成其他**
- memo 就写「从什么状态变成固定资产」
## 2. 调研结论(代码依据)
### 2.1 表与字段(m0.device_life_cycle)
- `asset_state` int,枚举:**0:库存商品; 1:固定资产; 2:出租; 3:售出; 4:报废; 5:费用化**
(注释见 `xiaoqu-publicbeanandmap/beans/b0/DeviceLifeCycle.java:126`,本地拷贝 `xiaoqu-agent-service/entity/m0/DeviceLifeCycle.java:54`)
- ⚠️ **`memo` 列在 DB 里真实存在**:dev 库实测 DDL 有 `memo varchar(256) DEFAULT ''`(2026-11-17 查 192.168.1.181 `xiaoqu_comples_d`)。但参考库 bean 和本地实体拷贝都**没有映射该列**——老系统经 Redis MQ 的 `LifeCycleInput.memo` 只用于逻辑分支(`ScheduledTask.java:393` 判断"调拨入库/调拨出库"),`BeanUtils.copyProperties` 不会落 memo 列,所以该列历史基本为空。本工具是首次真正写它。**实现时需给本地实体补 memo 字段。**
- 软删 `soft_delete`(0 正常),sn_code 有索引。
### 2.2 老系统相关行为(不复制,仅对齐语义)
- 资产状态联动全部发生在出入库流程里(`PublicService.java:2381-2461`、`WarehouseAllocationServiceImpl.java:741-820`):出库按下单公司类型给 1(固定资产)/3(售出)/0(库存商品),报废出库给 4,费用化给 5。
- 没有「单独把某台设备转固定资产」的接口。
- 老系统查生命周期记录按 `sn_code` 等值 + `id ASC LIMIT 1`(`AssetDepreciationLogTask.java:68-72`),本工具同口径(防重复 SN 行取最早一条)。
- **联动边界(重要)**:改成固定资产**不会**自动生成 m2 `asset_info` 资产卡片——资产卡片由 Redis 队列 `InsertAssetInfoQueue` 驱动(设备上线时入队,`AssetDepreciationLogTask.java:61-138` 消费,且非出纸机仅 asset_state=0 时才建卡)。金蝶侧「库存转资产」也有自己的校验链路(`WarehouseAllocationController.java:1598-1616`)。本工具只改 `device_life_cycle` 一表,不触碰资产卡片/金蝶(见 §5 拍板点 5)。
### 2.3 平台既有先例
完全对齐首个 kind=write 工具 `warehouse.order.handler.update` 的模式(`doc/warehouse-order-handler-update-mcp-design.md`):零行级权限、门禁全靠 scope、svc `audit_log` 全量落审计、`ToolCallException` 透出报错文案。
## 3. 工具契约
### 3.1 基本信息
| 项 | 值 |
|---|---|
| 工具名 | `device.lifecycle.fixed_asset.update` |
| 标题 | 设备转固定资产 |
| category | admin |
| kind | write |
| 数据源 | 纯 MySQL(m0 device_life_cycle),无 ES |
| 权限 | **零行级权限**;门禁完全靠 scope:prod 只绑研发专用 scope 6(code=code),dev seed 只绑测试专用 scope;不绑业务 scope 1/2/3/5 |
### 3.2 入参
| 参数 | 类型 | 必填 | 说明 |
|---|---|---|---|
| snCode | string | 是 | 设备 SN,trim 后非空,**精确匹配**(`sn_code = ?`),不模糊 |
### 3.3 返回
```json
{
"snCode": "XQ...",
"deviceType": 0,
"deviceTypeText": "出纸机",
"oldAssetState": 0,
"oldAssetStateText": "库存商品",
"newAssetState": 1,
"newAssetStateText": "固定资产",
"memo": "从库存商品变成固定资产",
"modifyTime": "2026-11-17 10:00:00",
"requestId": "..."
}
```
### 3.4 行为与校验(按顺序)
1. snCode 必填、trim 后非空 → 否则 `INVALID_ARGUMENT`
2. 查 `device_life_cycle`:`sn_code = snCode AND soft_delete = 0 ORDER BY id ASC LIMIT 1` → 不存在 `NOT_FOUND_OR_FORBIDDEN`「设备生命周期记录不存在(sn_code=…)」
3. 当前 `asset_state == 1`(固定资产)→ **拒绝**:`INVALID_ARGUMENT`「当前已是固定资产,不允许重复转换」——这也天然满足「不允许从固定资产变成其他」(工具目标状态固定为 1,永不写其他值)
4. 当前 `asset_state == 4`(报废)→ **拒绝**:`INVALID_ARGUMENT`「设备已报废,不允许转固定资产」(拍板点 1:报废不允许转)
5. 当前 `asset_state` 为 null → 按 0(库存商品)处理(拍板点 3)
6. UPDATE 该 id 行:`asset_state=1`、`memo='从<原状态文案>变成固定资产'`、`modify_id=<Token 操作人 userId>`、`modify_time=now()`;**不动** exchange_state / road_state / inventory_state / last_op_user / last_op_date / agent_id / asset_owner_* / jindie_*(这不是流转事件,拍板点 4)
7. 写 svc `audit_log`(操作人、入参、新旧 asset_state、request_id),与既有写工具一致
8. 报错统一 `ToolCallException` 透出明确文案(对齐新工具风格)
### 3.5 memo 文案
固定格式:`从<原状态文案>变成固定资产`,枚举文案映射:0库存商品/1固定资产/2出租/3售出/4报废/5费用化。实际允许的来源状态只有 0/2/3/5/null(1 与 4 被守卫拦截)。示例:`从库存商品变成固定资产`、`从出租变成固定资产`。不加来源前缀(用户明确口径)。
## 4. 测试要点
- 参数校验:snCode 空/null/纯空格 → INVALID_ARGUMENT
- SN 不存在 → NOT_FOUND_OR_FORBIDDEN;soft_delete=1 的记录视为不存在
- 已是固定资产(asset_state=1)→ INVALID_ARGUMENT 且不产生 UPDATE
- 报废(asset_state=4)→ INVALID_ARGUMENT 且不产生 UPDATE
- 允许的来源状态(0/2/3/5/null)→ 均成功转 1,memo 文案正确(含 null→库存商品 的归一)
- UPDATE 只写 asset_state/memo/modify_id/modify_time 四列,其他字段不被触碰(mock 验证 set 列集合)
- audit_log 调用参数正确
## 5. 拍板结论(2026-11-17 王恒)
1. **报废(4)设备允许转固定资产?** —— ❌ **不允许**,加守卫:asset_state=4 直接报错拒绝
2. **已是固定资产时的行为** —— ✅ 报错拒绝(INVALID_ARGUMENT),防止静默 no-op 和 memo 被覆写
3. **asset_state 为 null 的历史行** —— ✅ 按 0(库存商品)处理,memo 写「从库存商品变成固定资产」
4. **是否同步更新 last_op_user / last_op_date** —— ✅ 不动;只写 modify_id/modify_time 留痕
5. **是否联动生成 m2 asset_info 资产卡片 / 触发金蝶同步** —— ✅ 不联动,本工具只改 device_life_cycle
6. **scope** —— ✅ prod 只绑研发专用 scope 6,与 warehouse.order.handler.update 同款隔离
## 6. 改动清单(预估)
- `entity/m0/DeviceLifeCycle.java`:补 `memo` 字段(DB 列已存在,仅补映射)
- 新工具类 `DeviceLifecycleFixedAssetTools`(或并入 `DeviceLifecycleTools`,实现时按类内聚定)
- 单测 `DeviceLifecycleFixedAssetToolsTest`
- seed-dev.sql:测试专用 scope 绑定(kind=write 自动段)
- README 工具表 + `doc/agent-mcp-tools-reference.md` 登记
- prod:ToolSyncService 自动注册后,手工 INSERT IGNORE 绑 scope 6
## 7. 冒烟与上线
按 2026-11-07 强制流程:`./deploy/test-up.sh` 起测试环境 → scopeCode=test 签 Token → 写冒烟全在测试环境跑(真实转固定资产 + 各守卫用例含报废拒绝 + DB 复核后改回原状)→ remote-deploy → 生产只读核验(健康检查 401、tools/list 可见、已固定资产设备调用报明确错误)。
@@ -53,6 +53,8 @@ public class DeviceLifeCycle implements Serializable {
private String lastLatitudeAndLongitude;
/** 资产属性(0:库存商品;1:固定资产;2:出租;3:售出;4:报废;5:费用化) */
private Integer assetState;
/** 备注(DB 列真实存在但老系统 bean 未映射,历史基本为空;设备转固定资产工具首次写入) */
private String memo;
private Long agentId;
private String agentName;
private Long assetOwnerId;
@@ -0,0 +1,126 @@
package me.iiv.agent.mcp.tool;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import me.iiv.agent.entity.m0.DeviceLifeCycle;
import me.iiv.agent.entity.m0.User;
import me.iiv.agent.mapper.m0.DeviceLifeCycleMapper;
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.stereotype.Component;
import org.springframework.util.StringUtils;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* 设备转固定资产工具(REQ-20261117-0003,设计文档 doc/device-lifecycle-fixed-asset-mcp-design.md)。
* 按 SN 精确匹配把 device_life_cycle.asset_state 改为 1(固定资产),memo 写来源状态文案;
* 目标状态固定为 1,天然满足「不允许从固定资产变成其他」;报废(4)按拍板结论守卫拒绝。
* 零行级权限,门禁靠「研发专用」scope;必须用户身份 Token(操作人落 modify_id + 审计)。
* 只改 device_life_cycle 一表,不联动 m2 asset_info 资产卡片/金蝶同步,不动 last_op_* 流转字段。
*/
@Component
public class DeviceLifecycleAdminTools implements ToolObject {
private static final Logger log = LoggerFactory.getLogger(DeviceLifecycleAdminTools.class);
private static final int ASSET_STATE_FIXED = 1;
private static final int ASSET_STATE_DISCARDED = 4;
private static final Map<Integer, String> ASSET_STATE_TEXT = Map.of(
0, "库存商品", 1, "固定资产", 2, "出租", 3, "售出", 4, "报废", 5, "费用化");
private static final Map<Integer, String> DEVICE_TYPE_TEXT = Map.of(
0, "出纸机", 1, "空感", 2, "电池", 3, "充电箱", 4, "泡沫机", 5, "蓝牙网关");
final DeviceLifeCycleMapper deviceLifeCycleMapper;
public DeviceLifecycleAdminTools(DeviceLifeCycleMapper deviceLifeCycleMapper) {
this.deviceLifeCycleMapper = deviceLifeCycleMapper;
}
@XqTool(category = "admin", kind = "write")
@Tool(name = "device.lifecycle.fixed_asset.update", description = "【写操作·研发/运维专用】按 SN 精确匹配(不模糊)"
+ "把设备生命周期记录 device_life_cycle.asset_state 转为固定资产(1),"
+ "memo 自动写「从<原状态>变成固定资产」。允许来源状态:库存商品(0)/出租(2)/售出(3)/费用化(5)/空;"
+ "已是固定资产(1)报错拒绝(本工具目标状态固定为 1,任何情况下都不会把固定资产改成其他状态);"
+ "已报废(4)报错拒绝。只更新 asset_state/memo/modify_id/modify_time 四列,"
+ "不动流转状态、不生成资产卡片、不触发金蝶同步。"
+ "无行级权限校验,访问控制靠 scope 绑定;必须用户身份 Token,每次调用写审计日志。"
+ "重复 SN 取 id 最早一条(与老系统口径一致)。")
public Map<String, Object> fixedAssetUpdate(
@ToolParam(description = "设备 SN,精确匹配 sn_code,不模糊") String snCode) {
if (!StringUtils.hasText(snCode)) {
throw new ToolCallException(McpErrorCode.INVALID_ARGUMENT, "snCode 不能为空");
}
String sn = snCode.trim();
User caller = AuthContextHolder.get().getUser();
if (caller == null) {
throw new ToolCallException(McpErrorCode.PERMISSION_DENIED,
"该工具要求用户身份 Token 调用(操作人需可追溯),服务身份 Token 不可用");
}
List<DeviceLifeCycle> rows = deviceLifeCycleMapper.selectList(
new LambdaQueryWrapper<DeviceLifeCycle>()
.eq(DeviceLifeCycle::getSoftDelete, 0)
.eq(DeviceLifeCycle::getSnCode, sn)
.orderByAsc(DeviceLifeCycle::getId)
.last("LIMIT 1"));
if (rows.isEmpty()) {
throw new ToolCallException(McpErrorCode.NOT_FOUND_OR_FORBIDDEN,
"设备生命周期记录不存在(sn_code=" + sn + ")");
}
DeviceLifeCycle record = rows.get(0);
Integer oldState = record.getAssetState() == null ? 0 : record.getAssetState();
if (oldState == ASSET_STATE_FIXED) {
throw new ToolCallException(McpErrorCode.INVALID_ARGUMENT,
"设备 " + sn + " 当前已是固定资产,不允许重复转换");
}
if (oldState == ASSET_STATE_DISCARDED) {
throw new ToolCallException(McpErrorCode.INVALID_ARGUMENT,
"设备 " + sn + " 已报废,不允许转固定资产");
}
String oldStateText = ASSET_STATE_TEXT.getOrDefault(oldState, "未知");
String memo = "从" + oldStateText + "变成固定资产";
Date now = new Date();
int updated = deviceLifeCycleMapper.update(null, new LambdaUpdateWrapper<DeviceLifeCycle>()
.eq(DeviceLifeCycle::getId, record.getId())
.set(DeviceLifeCycle::getAssetState, ASSET_STATE_FIXED)
.set(DeviceLifeCycle::getMemo, memo)
.set(DeviceLifeCycle::getModifyId, caller.getId())
.set(DeviceLifeCycle::getModifyTime, now));
if (updated != 1) {
throw new ToolCallException(McpErrorCode.DATA_INTEGRITY_ERROR,
"更新影响行数=" + updated + ",预期 1,请携带 request_id 联系运维排查");
}
String requestId = McpCallContextHolder.currentOrCreateRequestId();
log.info("device.lifecycle.fixed_asset.update 完成 requestId={} sn={} id={} {}→1 memo={} caller={}",
requestId, sn, record.getId(), oldState, memo, caller.getId());
Map<String, Object> result = new LinkedHashMap<>();
result.put("snCode", sn);
result.put("deviceType", record.getDeviceType());
result.put("deviceTypeText", DEVICE_TYPE_TEXT.get(record.getDeviceType()));
result.put("oldAssetState", oldState);
result.put("oldAssetStateText", oldStateText);
result.put("newAssetState", ASSET_STATE_FIXED);
result.put("newAssetStateText", ASSET_STATE_TEXT.get(ASSET_STATE_FIXED));
result.put("memo", memo);
result.put("modifyTime", now);
result.put("requestId", requestId);
return result;
}
}
@@ -0,0 +1,177 @@
package me.iiv.agent.mcp.tool;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import me.iiv.agent.entity.m0.DeviceLifeCycle;
import me.iiv.agent.entity.m0.User;
import me.iiv.agent.mapper.m0.DeviceLifeCycleMapper;
import me.iiv.agent.mcp.McpErrorCode;
import me.iiv.agent.mcp.ToolCallException;
import me.iiv.agent.security.AuthContext;
import me.iiv.agent.security.AuthContextHolder;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class DeviceLifecycleAdminToolsTest {
@Mock DeviceLifeCycleMapper deviceLifeCycleMapper;
DeviceLifecycleAdminTools tools;
@BeforeEach
void setUp() {
MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
TableInfoHelper.initTableInfo(assistant, DeviceLifeCycle.class);
tools = new DeviceLifecycleAdminTools(deviceLifeCycleMapper);
User caller = new User();
caller.setId(812L);
AuthContextHolder.set(new AuthContext(null, caller));
}
@AfterEach
void tearDown() {
AuthContextHolder.clear();
}
@Test
void rejectsBlankSnCode() {
ToolCallException e1 = assertThrows(ToolCallException.class,
() -> tools.fixedAssetUpdate(null));
assertEquals(McpErrorCode.INVALID_ARGUMENT, e1.getCode());
ToolCallException e2 = assertThrows(ToolCallException.class,
() -> tools.fixedAssetUpdate(" "));
assertEquals(McpErrorCode.INVALID_ARGUMENT, e2.getCode());
verify(deviceLifeCycleMapper, never()).update(isNull(), any());
}
@Test
void deniesServiceTokenWithoutUser() {
AuthContextHolder.set(new AuthContext(null, null));
ToolCallException e = assertThrows(ToolCallException.class,
() -> tools.fixedAssetUpdate("XQ-1"));
assertEquals(McpErrorCode.PERMISSION_DENIED, e.getCode());
verify(deviceLifeCycleMapper, never()).update(isNull(), any());
}
@Test
void notFoundWhenNoRow() {
when(deviceLifeCycleMapper.selectList(any())).thenReturn(List.of());
ToolCallException e = assertThrows(ToolCallException.class,
() -> tools.fixedAssetUpdate("XQ-NONE"));
assertEquals(McpErrorCode.NOT_FOUND_OR_FORBIDDEN, e.getCode());
verify(deviceLifeCycleMapper, never()).update(isNull(), any());
}
@Test
void alreadyFixedAssetRejected() {
when(deviceLifeCycleMapper.selectList(any())).thenReturn(List.of(record(1L, 1)));
ToolCallException e = assertThrows(ToolCallException.class,
() -> tools.fixedAssetUpdate("XQ-1"));
assertEquals(McpErrorCode.INVALID_ARGUMENT, e.getCode());
assertTrue(e.getRawMessage().contains("已是固定资产"));
verify(deviceLifeCycleMapper, never()).update(isNull(), any());
}
@Test
void discardedRejected() {
when(deviceLifeCycleMapper.selectList(any())).thenReturn(List.of(record(1L, 4)));
ToolCallException e = assertThrows(ToolCallException.class,
() -> tools.fixedAssetUpdate("XQ-1"));
assertEquals(McpErrorCode.INVALID_ARGUMENT, e.getCode());
assertTrue(e.getRawMessage().contains("报废"));
verify(deviceLifeCycleMapper, never()).update(isNull(), any());
}
@Test
void convertsFromStockAndSetsOnlyFourColumns() {
when(deviceLifeCycleMapper.selectList(any())).thenReturn(List.of(record(10L, 0)));
when(deviceLifeCycleMapper.update(isNull(), any())).thenReturn(1);
Map<String, Object> result = tools.fixedAssetUpdate("XQ-1");
assertEquals(0, result.get("oldAssetState"));
assertEquals("库存商品", result.get("oldAssetStateText"));
assertEquals(1, result.get("newAssetState"));
assertEquals("从库存商品变成固定资产", result.get("memo"));
@SuppressWarnings("unchecked")
ArgumentCaptor<LambdaUpdateWrapper<DeviceLifeCycle>> captor =
ArgumentCaptor.forClass(LambdaUpdateWrapper.class);
verify(deviceLifeCycleMapper).update(isNull(), captor.capture());
String sqlSet = captor.getValue().getSqlSet();
assertTrue(sqlSet.contains("asset_state"));
assertTrue(sqlSet.contains("memo"));
assertTrue(sqlSet.contains("modify_id"));
assertTrue(sqlSet.contains("modify_time"));
assertFalse(sqlSet.contains("last_op_user"));
assertFalse(sqlSet.contains("last_op_date"));
assertFalse(sqlSet.contains("exchange_state"));
assertFalse(sqlSet.contains("jindie_sync_state"));
}
@Test
void convertsFromRentSoldAndExpensed() {
assertMemoFor(2, "从出租变成固定资产");
assertMemoFor(3, "从售出变成固定资产");
assertMemoFor(5, "从费用化变成固定资产");
}
@Test
void nullAssetStateTreatedAsStock() {
when(deviceLifeCycleMapper.selectList(any())).thenReturn(List.of(record(11L, null)));
when(deviceLifeCycleMapper.update(isNull(), any())).thenReturn(1);
Map<String, Object> result = tools.fixedAssetUpdate("XQ-NULL");
assertEquals(0, result.get("oldAssetState"));
assertEquals("库存商品", result.get("oldAssetStateText"));
assertEquals("从库存商品变成固定资产", result.get("memo"));
}
@Test
void updateRowCountNotOneIsDataIntegrityError() {
when(deviceLifeCycleMapper.selectList(any())).thenReturn(List.of(record(12L, 0)));
when(deviceLifeCycleMapper.update(isNull(), any())).thenReturn(0);
ToolCallException e = assertThrows(ToolCallException.class,
() -> tools.fixedAssetUpdate("XQ-1"));
assertEquals(McpErrorCode.DATA_INTEGRITY_ERROR, e.getCode());
}
private void assertMemoFor(int oldState, String expectedMemo) {
when(deviceLifeCycleMapper.selectList(any())).thenReturn(List.of(record(99L, oldState)));
when(deviceLifeCycleMapper.update(isNull(), any())).thenReturn(1);
Map<String, Object> result = tools.fixedAssetUpdate("XQ-" + oldState);
assertEquals(expectedMemo, result.get("memo"));
}
private static DeviceLifeCycle record(Long id, Integer assetState) {
DeviceLifeCycle record = new DeviceLifeCycle();
record.setId(id);
record.setSnCode("XQ-1");
record.setDeviceType(0);
record.setAssetState(assetState);
return record;
}
}