From 37ce5a3443c1e4f210e06b571ca92bc7cc017dfb Mon Sep 17 00:00:00 2001 From: my_local_kimi_dev2 Date: Tue, 17 Nov 2026 09:41:24 +0800 Subject: [PATCH] =?UTF-8?q?feat(mcp):=20=E6=96=B0=E5=A2=9E=E8=AE=BE?= =?UTF-8?q?=E5=A4=87=E8=BD=AC=E5=9B=BA=E5=AE=9A=E8=B5=84=E4=BA=A7=E5=86=99?= =?UTF-8?q?=E5=B7=A5=E5=85=B7=20device.lifecycle.fixed=5Fasset.update?= =?UTF-8?q?=EF=BC=88REQ-20261117-0003=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 按 SN 精确匹配把 device_life_cycle.asset_state 转为固定资产(1),memo 写来源状态文案; 已是固定资产/已报废守卫拒绝,null 按库存商品处理;只写 asset_state/memo/modify_id/ modify_time 四列,不联动资产卡片/金蝶;零行级权限,prod 只绑研发专用 scope 6。 DeviceLifeCycle 实体补 memo 字段映射(DB 列早已存在,老系统从未映射)。 --- xiaoqu-agent-service/README.md | 1 + .../doc/agent-mcp-tools-reference.md | 25 +++ ...device-lifecycle-fixed-asset-mcp-design.md | 118 ++++++++++++ .../iiv/agent/entity/m0/DeviceLifeCycle.java | 2 + .../mcp/tool/DeviceLifecycleAdminTools.java | 126 +++++++++++++ .../tool/DeviceLifecycleAdminToolsTest.java | 177 ++++++++++++++++++ 6 files changed, 449 insertions(+) create mode 100644 xiaoqu-agent-service/doc/device-lifecycle-fixed-asset-mcp-design.md create mode 100644 xiaoqu-agent-service/src/main/java/me/iiv/agent/mcp/tool/DeviceLifecycleAdminTools.java create mode 100644 xiaoqu-agent-service/src/test/java/me/iiv/agent/mcp/tool/DeviceLifecycleAdminToolsTest.java diff --git a/xiaoqu-agent-service/README.md b/xiaoqu-agent-service/README.md index 5474d60..115aa29 100644 --- a/xiaoqu-agent-service/README.md +++ b/xiaoqu-agent-service/README.md @@ -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` 字段提示。 diff --git a/xiaoqu-agent-service/doc/agent-mcp-tools-reference.md b/xiaoqu-agent-service/doc/agent-mcp-tools-reference.md index cc39f8d..8c432bb 100644 --- a/xiaoqu-agent-service/doc/agent-mcp-tools-reference.md +++ b/xiaoqu-agent-service/doc/agent-mcp-tools-reference.md @@ -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 diff --git a/xiaoqu-agent-service/doc/device-lifecycle-fixed-asset-mcp-design.md b/xiaoqu-agent-service/doc/device-lifecycle-fixed-asset-mcp-design.md new file mode 100644 index 0000000..75df77e --- /dev/null +++ b/xiaoqu-agent-service/doc/device-lifecycle-fixed-asset-mcp-design.md @@ -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=`、`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 可见、已固定资产设备调用报明确错误)。 diff --git a/xiaoqu-agent-service/src/main/java/me/iiv/agent/entity/m0/DeviceLifeCycle.java b/xiaoqu-agent-service/src/main/java/me/iiv/agent/entity/m0/DeviceLifeCycle.java index 61bc111..4fddbf2 100644 --- a/xiaoqu-agent-service/src/main/java/me/iiv/agent/entity/m0/DeviceLifeCycle.java +++ b/xiaoqu-agent-service/src/main/java/me/iiv/agent/entity/m0/DeviceLifeCycle.java @@ -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; diff --git a/xiaoqu-agent-service/src/main/java/me/iiv/agent/mcp/tool/DeviceLifecycleAdminTools.java b/xiaoqu-agent-service/src/main/java/me/iiv/agent/mcp/tool/DeviceLifecycleAdminTools.java new file mode 100644 index 0000000..abe008c --- /dev/null +++ b/xiaoqu-agent-service/src/main/java/me/iiv/agent/mcp/tool/DeviceLifecycleAdminTools.java @@ -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 ASSET_STATE_TEXT = Map.of( + 0, "库存商品", 1, "固定资产", 2, "出租", 3, "售出", 4, "报废", 5, "费用化"); + private static final Map 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 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 rows = deviceLifeCycleMapper.selectList( + new LambdaQueryWrapper() + .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() + .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 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; + } +} diff --git a/xiaoqu-agent-service/src/test/java/me/iiv/agent/mcp/tool/DeviceLifecycleAdminToolsTest.java b/xiaoqu-agent-service/src/test/java/me/iiv/agent/mcp/tool/DeviceLifecycleAdminToolsTest.java new file mode 100644 index 0000000..dffe603 --- /dev/null +++ b/xiaoqu-agent-service/src/test/java/me/iiv/agent/mcp/tool/DeviceLifecycleAdminToolsTest.java @@ -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 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> 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 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 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; + } +}