From c02f2f0d56166fd6135d1374f01867f09ddabf0a Mon Sep 17 00:00:00 2001 From: liufumingren Date: Tue, 27 Oct 2026 03:09:16 +0800 Subject: [PATCH] =?UTF-8?q?feat(stock.check):=20=E7=A7=BB=E9=99=A4=20all?= =?UTF-8?q?=20=E7=9B=98=E7=82=B9=E8=8C=83=E5=9B=B4=E5=B9=B6=E8=BF=81?= =?UTF-8?q?=E7=A7=BB=E4=B8=BA=20location/goods?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 模型 type 默认值 all -> location,注释同步为 location/store/goods - 迁移 20261027010000:有商品明细的 all 任务归 goods(保留原 mode),其余归 location 且 mode=blind;列默认值与注释同步更新 - 补充盘点集成测试与分区编码唯一性集成测试(默认跳过,需 DISPATCH_FACTORY_TEST_MYSQL=1 才连接本地开发库) Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- app/model/stock_check.js | 4 +- ...erge-stock-check-type-all-into-location.js | 53 + .../location_zone.zoneCodeUnique.test.js | 130 + test/app/service/systems/stock_check.test.js | 8315 +++++++++++++++++ 4 files changed, 8500 insertions(+), 2 deletions(-) create mode 100644 database/migrations/20261027010000-merge-stock-check-type-all-into-location.js create mode 100644 test/app/service/systems/location_zone.zoneCodeUnique.test.js create mode 100644 test/app/service/systems/stock_check.test.js diff --git a/app/model/stock_check.js b/app/model/stock_check.js index a98b1a1..b4d8368 100644 --- a/app/model/stock_check.js +++ b/app/model/stock_check.js @@ -33,8 +33,8 @@ module.exports = app => { type: { type: STRING(20), allowNull: false, - defaultValue: 'all', - comment: '盘点范围类型:all=全盘,store=按货主,goods=按商品,location=按库位', + defaultValue: 'location', + comment: '盘点范围类型:location=按库位(未传库位时自动全盘),store=按货主,goods=按商品', }, mode: { type: STRING(20), diff --git a/database/migrations/20261027010000-merge-stock-check-type-all-into-location.js b/database/migrations/20261027010000-merge-stock-check-type-all-into-location.js new file mode 100644 index 0000000..5fb7ab5 --- /dev/null +++ b/database/migrations/20261027010000-merge-stock-check-type-all-into-location.js @@ -0,0 +1,53 @@ +'use strict'; + +/** + * 移除盘点范围类型 all(与 location 语义重复:两者都按库位盘点、都强制盲盘、 + * 明细都是 scope_type='location';all 唯一的额外能力「未传库位时自动拉全仓库启用库位」 + * 已合并进 location): + * + * wms_stock_check: + * 1. 存量数据: + * - 存在商品明细行(scope_type='goods')的 type='all' 任务 = 2026-09-30 改造前的 + * 「全仓按商品」口径,改为 type='goods'(mode 保持原值,改造前商品口径允许明盘); + * - 其余 type='all' 任务统一改为 'location',mode 归一到 'blind'(按库位盘点一律盲盘)。 + * 2. 列定义:默认值 all → location,comment 去掉 all。 + * + * 发布前核查 SQL(确认两类任务各有多少): + * SELECT c.type, d.scope_type, COUNT(DISTINCT c.id) + * FROM wms_stock_check c LEFT JOIN wms_stock_check_detail d ON d.check_id = c.id + * WHERE c.type = 'all' GROUP BY c.type, d.scope_type; + */ + +const TABLE_NAME = 'wms_stock_check'; + +module.exports = { + up: async queryInterface => { + // 改造前的「全仓按商品」任务(明细为商品行)按真实语义归入 goods,保留原 mode + await queryInterface.sequelize.query(` + UPDATE \`${TABLE_NAME}\` c + JOIN ( + SELECT DISTINCT check_id FROM wms_stock_check_detail WHERE scope_type = 'goods' + ) d ON d.check_id = c.id + SET c.\`type\` = 'goods' + WHERE c.\`type\` = 'all' + `); + // 其余(库位口径,含无明细的空任务)统一并入 location,并按库位口径归一为盲盘 + await queryInterface.sequelize.query( + `UPDATE \`${TABLE_NAME}\` SET \`type\` = 'location', \`mode\` = 'blind' WHERE \`type\` = 'all'` + ); + await queryInterface.sequelize.query(` + ALTER TABLE \`${TABLE_NAME}\` + MODIFY COLUMN \`type\` VARCHAR(20) NOT NULL DEFAULT 'location' + COMMENT '盘点范围类型:location=按库位(未传库位时自动全盘),store=按货主,goods=按商品' + `); + }, + + down: async queryInterface => { + // 数据不可回滚(all 已并入 location/goods,无法区分原值),仅恢复列定义 + await queryInterface.sequelize.query(` + ALTER TABLE \`${TABLE_NAME}\` + MODIFY COLUMN \`type\` VARCHAR(20) NOT NULL DEFAULT 'all' + COMMENT '盘点范围类型:all=全盘,store=按货主,goods=按商品,location=按库位' + `); + }, +}; diff --git a/test/app/service/systems/location_zone.zoneCodeUnique.test.js b/test/app/service/systems/location_zone.zoneCodeUnique.test.js new file mode 100644 index 0000000..77097ab --- /dev/null +++ b/test/app/service/systems/location_zone.zoneCodeUnique.test.js @@ -0,0 +1,130 @@ +'use strict'; + +/** + * 分区编码唯一性(真实库集成测试)。 + * + * 覆盖:同仓库同 zone_code 只允许一条未归档分区(归档分区不占用编码)。 + * 背景:uk_warehouse_zone_code 含 deleted_at,未删除行 deleted_at 为 NULL 不参与去重, + * 同 zone_code 并存会导致其下库位 space_code 重复(如 E02-06-01-01 多条), + * 盘点/库存按编码定位会命中历史行。 + * + * 注意:本文件会启动 egg-mock app,需单独运行(与其它同样启动 app 的用例在同一 mocha 进程内 + * 会触发 egg loader "can't overwrite property" 冲突,为仓库既有约束,如 return_received 系列)。 + */ + +const assert = require('node:assert/strict'); +const mm = require('egg-mock'); + +const REAL_DB_ENABLED = process.env.DISPATCH_FACTORY_TEST_MYSQL === '1'; +const runner = REAL_DB_ENABLED ? describe : describe.skip; + +const TEST_WAREHOUSE_ID = 100000; + +runner('test/app/service/systems/location_zone.zoneCodeUnique.test.js(分区编码唯一性)', function() { + this.timeout(120000); + + let app; + let ctx; + const createdZoneIds = []; + + before(async () => { + app = mm.app({ + baseDir: process.cwd(), + env: 'local', + clean: false, + cache: false, + }); + await app.ready(); + ctx = app.createAnonymousContext(); + ctx.user = { id: 4, store_id: TEST_WAREHOUSE_ID, employees_name: '阿猫' }; + }); + + after(async () => { + for (const zoneId of createdZoneIds) { + await ctx.model.LocationZone.destroy({ where: { id: zoneId }, force: true }); + } + await app.close(); + }); + + afterEach(() => { + mm.restore(); + }); + + /** + * 构造创建仓库类型分区的入参(warehouse 类型无需父元素,编码必填)。 + * + * @param {string} zoneCode 分区编码(1-5 位大写字母/数字)。 + * @return {Object} createZone 入参。 + */ + function buildWarehouseZonePayload(zoneCode) { + return { + zone_type: 'warehouse', + zone_name: `测试仓_${zoneCode}`, + zone_code: zoneCode, + parent_id: 0, + x: 0, + y: 0, + z: 0, + length: 100, + width: 100, + height: 100, + }; + } + + /** + * 生成当前仓库未占用的随机编码(1-5 位大写字母/数字)。 + * + * @return {string} 分区编码。 + */ + function uniqueZoneCode() { + const suffix = String(Date.now()).slice(-4); + return `Z${suffix}`.slice(0, 5).toUpperCase(); + } + + it('同仓库同 zone_code 重复创建报错;归档后编码可复用', async () => { + const zoneCode = uniqueZoneCode(); + + const created = await ctx.service.systems.locationZone.createZone(buildWarehouseZonePayload(zoneCode)); + assert.equal(created.success, true); + const firstZoneId = Number(created.data.id); + assert.ok(firstZoneId > 0, '前置:分区应创建成功'); + createdZoneIds.push(firstZoneId); + + // 同编码再次创建 → 拒绝 + await assert.rejects(async () => { + await ctx.service.systems.locationZone.createZone(buildWarehouseZonePayload(zoneCode)); + }, error => /分区编码已存在/.test(error.message)); + + // 编码格式校验(沿用规则:1-5 位大写字母/数字) + await assert.rejects(async () => { + await ctx.service.systems.locationZone.createZone(buildWarehouseZonePayload('bad-code')); + }, error => /编码必须是1-5位大写字母或数字/.test(error.message)); + + // 归档(软删除)后同编码可再次创建:归档行不占用编码 + await ctx.model.LocationZone.destroy({ where: { id: firstZoneId } }); + const recreated = await ctx.service.systems.locationZone.createZone(buildWarehouseZonePayload(zoneCode)); + assert.equal(recreated.success, true); + assert.notEqual(Number(recreated.data.id), firstZoneId, '归档后新建应为新关系'); + createdZoneIds.push(Number(recreated.data.id)); + }); + + it('更新分区编码:改为已占用编码报错,改回自身编码不报错', async () => { + const codeA = uniqueZoneCode(); + const zoneA = await ctx.service.systems.locationZone.createZone(buildWarehouseZonePayload(codeA)); + createdZoneIds.push(Number(zoneA.data.id)); + + // 另建一个分区占位 + const codeB = `Y${String(Date.now()).slice(-4)}`.slice(0, 5).toUpperCase(); + const zoneB = await ctx.service.systems.locationZone.createZone(buildWarehouseZonePayload(codeB)); + createdZoneIds.push(Number(zoneB.data.id)); + + // 把 A 改成 B 的编码 → 报错 + await assert.rejects(async () => { + await ctx.service.systems.locationZone.updateZone(Number(zoneA.data.id), { zone_code: codeB }); + }, error => /分区编码已存在/.test(error.message)); + + // 改回自身编码 → 正常 + const updated = await ctx.service.systems.locationZone.updateZone(Number(zoneA.data.id), { zone_code: codeA }); + assert.ok(updated, '自身编码不应被判为冲突'); + }); +}); diff --git a/test/app/service/systems/stock_check.test.js b/test/app/service/systems/stock_check.test.js new file mode 100644 index 0000000..42d85f3 --- /dev/null +++ b/test/app/service/systems/stock_check.test.js @@ -0,0 +1,8315 @@ +'use strict'; + +/** + * 库存盘点模块(stock.check.*)集成测试。 + * + * 测试层次: + * - systems.stockCheck(业务层):状态机、单号生成、明细快照、作业记录(wms_stock_check_record)、 + * 汇总重算等核心逻辑,直连本地开发库(config.local.js,127.0.0.1:3307)验证真实写入/查询链路; + * - systemMethods.stock.check(方法包装层):仓库上下文注入、统一 success/fail 包装、 + * 业务错误码 400 透传。 + * + * 覆盖范围(本轮适配:detail 精简为只返回任务本身信息({ check })、明细范围行/盘点结果由 + * result 返回、新增 result 返回盘点结果聚合、 + * 主表移除 check_date 字段(start_time=首个明细写入时间、end_time=完成盘点时间)、 + * patternCreate 移除 mode 入参): + * - create 单号全局递增(跨仓库接续)与 uk_check_no 撞号自动重取(并发兜底); + * - create 盘点方式规则:type=location 一律强制盲盘 blind(忽略前端传入的 mode), + * type=store/goods 按传入值(缺省默认明盘 open);type 缺省 location,all 已下线(400); + * - addDetail 类型分派:goods/store 按 stock_ids、location 按 locations, + * 维度互斥报 400;货主一致性校验(invalid_stock_ids); + * type=location 缺省 locations 自动生成全仓库启用库位明细(原全盘语义);库位行幂等跳过; + * - addDetail location_ids 库位ID直查(新增入参):location 类型按 wms_location_space.id + * + warehouse_id 直查校验(与 locations 同传时 location_ids 优先、locations 忽略), + * 无效 ID 计入 invalid_location_ids;幂等按 uk_check_location;商品型任务传 location_ids 报 400; + * addLocationDetail 兼容入口薄封装转调 addDetail(返回结构不变); + * - report 覆盖式上报(mode=created/updated,space_id 必传并按库位ID落库);商品行 stock_id 不一致 400, + * 库位行 stock_id 必填/本仓库校验/库位以明细为准; + * - uk_detail_stock_location(detail_id, stock_id, location_code) 唯一索引并发加固 + * (历史无库位记录库中存空串 ''、recordList 接口返回 null;report 不再产生该分组); + * - recordList/recordDelete 作业记录查询与删除; + * - batchDelete 批量删除:仅作废任务删除(事务级联清空主表/明细/作业记录), + * 非作废与查不到的任务计入 skipped_ids(保持入参顺序);单值 ids 兼容、去重、 + * 200 上限与 400 参数校验;方法层仓库上下文注入与 success/failure 包装; + * - detailDelete 批量删除明细(本轮升级:单值删除 → 批量删除):detailIds 单值自动转数组 + * (单次上限 200)、仅 created/rejected 状态允许(否则 400)、未命中明细计入 skipped_ids + * 不报错(deleted_ids/skipped_ids 保持入参顺序)、删除后防御性清理 wms_stock_check_record + * 并重算 total_items;返回结构 { deleted_count, deleted_ids, skipped_ids, total_items }; + * 400 边界(任务ID为空/任务不存在/状态不允许/请至少选择一个明细/单次最多删除 200 条明细); + * 方法层 detail_ids/detailIds/detail_id 三种入参写法兼容与 success/failure 包装; + * - list 筛选扩展:type/mode 单值或数组 in、store_id、created_at 单值 gte 与 + * [from,to] between(直插 created_at 造数)、start_time/end_time 盘点时间范围 + * (report/finish 后落库)、type+status 组合筛选、非法时间值静默忽略; + * where 标准结构(operator/value)经方法层 prepareWhereContext 提取(eq/in/between); + * - list 货主名称补齐:rows 每条补 store_name(合约表 wms_store_warehouse.store_remask 优先、 + * wms_store.company_name 兜底、store_id 为空或查不到为空串), + * store_id 筛选 + store_name 组合返回口径校验; + * - detail 只返回任务本身信息({ check },_formatCheckRow 口径),不返回明细范围行 + * 与盘点作业聚合(明细范围行/盘点结果由 result 返回、作业记录由 recordList 返回); + * 400 边界(任务ID为空/任务不存在); + * - result 返回盘点结果聚合:商品行 checked_quantity/diff_quantity/is_diff/status/location_codes/ + * checkers/last_checked_at/records/locations,库位行 stocks 按商品聚合(账面来自 wms_storage) + * 与行级 checked_quantity/diff_quantity; + * - 汇总差异口径:商品行用快照、库位行用 wms_storage 实时账面; + * - workData 盘点作业数据(单接口三视图,is_goods 驱动;不返回 check,任务信息由 detail 返回): + * location 视图库位结构(任务库位范围行为列表,行内挂 goods 子列表与 has_unknown/checkers/status)、 + * goods 视图商品结构(明盘返回 system_quantity/checked_quantity/diff_quantity/is_diff 与 + * locations.quantity,盲盘不含任何数量字段)、space 视图聚合库位结构(wms_storage 所在库位 + * 按拣货路径排序,明盘含库位账面/已盘数量,盲盘不含数量);无记录任务子列表为空、 + * 响应为 { view, rows, total, page, pageSize }(view=解析后的视图 location/goods/space;不返回 check,任务信息由 detail 返回)、400 边界(任务ID/任务不存在/跨仓库隔离) + * 与状态限制(created/submitted/rejected/completed/cancelled 均 400,仅 approved/checking 可拉取) + * 及方法层 is_goods 透传/success 包装; + * - finish 允许部分未盘完成(未盘商品行按实盘 0 计盘亏,库位行按商品聚合计盈亏,返回 unchecked_items); + * - exportStockChecks 导出(盘点明细=作业记录口径):Sheet1「盘点单」一行一个任务、 + * Sheet2「盘点明细」一行一条实际盘点记录(不导出未盘范围行),商品快照从 + * wms_stock_warehouse 补齐、空库位编码输出为空、total_count=作业记录总数; + * mock COS 上传后回读 Excel 校验列名/列序/单元格值; + * 未知商品(stock_id 为空)导出商品编码=扫描条码、商品名称=名称快照。 + * - 未知商品记录(stock_id 可空 + barcode/item_name,迁移 20261001100000): + * report 库位行仅传 barcode(未命中系统条码)→ stock_id=NULL + barcode + item_name 落库 + * (item_name 缺省=barcode,显式传名称按快照);barcode 命中 wms_stock_barcodes 系统条码 + * → 回填 stock_id 按已知商品处理(商品行命中其他商品报 400);未知商品覆盖式查重 + * (同 detail+同 barcode+同库位二次上报 → mode=updated 数量更新不新增); + * result 商品行/库位行均输出行级 unknown_items [{ barcode, item_name, checked_quantity }] + * (未知商品无账面:实盘=盘盈计入行级差异,stocks 保持只含已知商品); + * finish 未知商品计入 profit_total/diff_items; + * report 未传 stock_id 且未传 barcode 沿用原报错口径; + * 已知商品原链路回归(stock_id 匹配、库位行必填、barcode/item_name 保持 NULL)。 + * - 图片独立维护:FileReference(business_type=stock_check_record、business_id=记录ID) + * 挂载到 recordList 与 result.records 的 images [{ id: file_id, url }](无图片为空数组); + * recordDelete 删除记录时清理其 FileReference 图片引用; + * recordList 未知商品 item_code=条码、item_name=名称快照(已知商品维持明细快照)。 + * - 操作日志(wms_operation_log,business_type=stock_check):10 个写操作成功路径 + * 写入日志(直查表断言 operation_code/business_id/warehouse_id/message/operator 快照), + * batchDelete 仅 deletedIds 非空写 1 条(business_id=首个删除 id),失败路径不写日志。 + * - patternList/patternCreate 盘点定式快速创建:5 个定式清单(id/name/description/type)、 + * 按定式收集对象(空库位/错发/临期/静态/预警)后任务直接 submitted 落库 + * (明细快照、total_items 重算、STOCK_CHECK_CREATE 日志含 pattern_id、static 定式 + * 写 wms_stock_static_check_task 并排除已盘商品)、盘点方式由定式范围类型固定 + * (库位类盲盘 blind、商品类明盘 open)、主表不含 check_date(start_time/end_time 承载盘点时间语义)、 + * 400 边界(定式不存在/无对象/未开启预警/缺仓库)、方法层 success/failure 包装与仓库注入。 + * + * 运行前提(显式开启真实库,普通测试运行自动跳过,与 interceptRealDb.chain.test.js 口径一致): + * cmd /c "set DISPATCH_FACTORY_TEST_MYSQL=1&& npx egg-bin test test/app/service/systems/stock_check.test.js" + * + * 固定测试参数(与 wms-test-agent 约定一致): + * - 测试仓库 ID:100000 + * - 测试货主 ID:1000000 + * + * 数据策略:按用户偏好,本测试不清理写入数据(保留以供核对写入格式), + * 用例通过唯一标题/关键字与"断言包含关系"的方式保证可重复执行。 + */ + +const assert = require('node:assert/strict'); +const crypto = require('node:crypto'); +const mm = require('egg-mock'); +const ExcelJS = require('exceljs'); + +const REAL_DB_ENABLED = process.env.DISPATCH_FACTORY_TEST_MYSQL === '1'; +const runner = REAL_DB_ENABLED ? describe : describe.skip; + +const TEST_WAREHOUSE_ID = 100000; +// 另一测试仓库(跨仓库隔离/全局递增验证口径,与 detailDelete 仓库隔离用例一致) +const OTHER_TEST_WAREHOUSE_ID = 100001; +const TEST_STORE_ID = 1000000; +// 真实测试账号(开发库 wms_account_store_employee:id=4,account_id=1 liufumingren,store_id=100000,status=1) +const TEST_CREATOR_ID = 4; +const TEST_CREATOR_NAME = '阿猫'; +// 固定测试库位编码与对应 wms_location_space.id(warehouse_id=100000) +const TEST_LOCATION_CODE = 'A1715-01-01-01'; +const TEST_LOCATION_ID = 26885; +// 无库存的启用库位(用于库位行账面 0 口径验证,warehouse_id=100000) +const TEST_EMPTY_LOCATION_CODE = 'E07-01-02-01'; +// 有效库位过滤 SQL(与业务排除无头库位口径一致:库位未删除且所属 zone 存在未删除) +const VALID_SPACE_SQL = '(SELECT ls.id FROM wms_location_space ls ' + + 'JOIN wms_location_zone z ON z.id = ls.zone_id AND z.deleted_at IS NULL ' + + 'WHERE ls.deleted_at IS NULL)'; + +// 第二/第三有效库位(report 已改为 space_id 必传,多库位用例必须用真实库位),在 before 中初始化 +let TEST_LOCATION_CODE_2 = null; +let TEST_LOCATION_ID_2 = 0; +let TEST_LOCATION_CODE_3 = null; + +let titleSeq = 0; + +/** + * 生成唯一标题,避免多次执行测试时互相干扰。 + * + * @param {string} prefix 标题前缀。 + * @return {string} 唯一标题。 + */ +function uniqueTitle(prefix) { + titleSeq += 1; + return `${prefix}_${Date.now()}_${titleSeq}`; +} + +/** + * 获取当前日期片段(YYYYMMDD),用于校验单号前缀。 + * + * @return {string} 日期片段。 + */ +function currentDatePart() { + const now = new Date(); + return `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}${String(now.getDate()).padStart(2, '0')}`; +} + +runner('test/app/service/systems/stock_check.test.js(库存盘点真实库集成测试)', function() { + this.timeout(300000); + + let app; + let ctx; + + before(async () => { + app = mm.app({ + baseDir: process.cwd(), + env: 'local', + clean: false, + cache: false, + }); + await app.ready(); + ctx = app.createAnonymousContext(); + + // 校验固定测试库位编码在当前开发库真实存在,且 location_id 与常量一致(不一致快速失败) + const space = await ctx.model.LocationSpace.findOne({ + where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: TEST_LOCATION_CODE }, + attributes: [ 'id' ], + raw: true, + }); + assert.ok(space, `固定测试库位编码不存在(warehouse_id=${TEST_WAREHOUSE_ID}, code=${TEST_LOCATION_CODE})`); + assert.equal(Number(space.id), TEST_LOCATION_ID, '固定测试库位 ID 与本地库实际值不一致'); + + // 多库位用例所需的有效库位(report 的 space_id 必传,不能再用虚构编码) + const extraLocations = (await fetchValidLocations(3)) + .filter(item => item.space_code !== TEST_LOCATION_CODE && item.space_code !== TEST_EMPTY_LOCATION_CODE); + assert.ok(extraLocations.length >= 2, '测试仓库应至少存在 2 个额外有效库位(多库位用例依赖)'); + TEST_LOCATION_CODE_2 = extraLocations[0].space_code; + TEST_LOCATION_ID_2 = extraLocations[0].id; + TEST_LOCATION_CODE_3 = extraLocations[1].space_code; + }); + + after(async () => { + await app.close(); + }); + + afterEach(() => { + mm.restore(); + }); + + // ------------------- 辅助函数(业务层直调) ------------------- + + /** + * 创建盘点任务(业务层直调,固定测试仓库)。 + * 默认 type=goods(商品维度用例口径);库位维度用例显式传 type=location。 + * + * @param {Object} [options] 创建参数覆盖项。 + * @return {Promise} 格式化后的盘点任务行。 + */ + async function createCheck(options = {}) { + return ctx.service.systems.stockCheck.create({ + warehouseId: options.warehouseId !== undefined ? options.warehouseId : TEST_WAREHOUSE_ID, + title: options.title || uniqueTitle('盘点单元测试'), + type: options.type || 'goods', + mode: options.mode || 'open', + storeId: options.storeId !== undefined ? options.storeId : null, + remark: options.remark, + creatorId: options.creatorId || TEST_CREATOR_ID, + creatorName: options.creatorName || TEST_CREATOR_NAME, + }); + } + + /** + * 拉取固定测试仓库下的真实库存行(用于生成盘点明细快照)。 + * + * @param {number} count 行数。 + * @return {Promise>} 库存行。 + */ + async function fetchStockRows(count = 2) { + // 取「仅在单个启用库位有库存」的商品:商品明细按「商品 + 库位」拆行后每商品 1 行, + // 保证 total_items 与商品数一致(多库位商品拆多行、无库存库位商品不可加入盘点) + const { Op, fn, col, literal } = ctx.app.Sequelize; + const storageRows = await ctx.model.Storage.findAll({ + where: { + warehouse_id: TEST_WAREHOUSE_ID, + is_enabled: 1, + space_id: { [Op.in]: literal(VALID_SPACE_SQL) }, + }, + attributes: [ 'stock_id', [ fn('COUNT', fn('DISTINCT', col('space_id'))), 'spaceCount' ]], + group: [ 'stock_id' ], + raw: true, + }); + const singleSpaceStockIds = storageRows + .filter(row => Number(row.spaceCount) === 1) + .map(row => Number(row.stock_id)); + + return ctx.model.StockWarehouse.findAll({ + where: { + warehouse_id: TEST_WAREHOUSE_ID, + store_id: TEST_STORE_ID, + id: { [Op.in]: singleSpaceStockIds }, + }, + order: [[ 'id', 'ASC' ]], + limit: count, + raw: true, + }); + } + + /** + * 拉取固定测试仓库下其他货主的库存行(货主隔离校验用)。 + * + * @return {Promise} 库存行。 + */ + async function fetchOtherStoreStockRow() { + const { Op } = ctx.app.Sequelize; + return ctx.model.StockWarehouse.findOne({ + where: { + warehouse_id: TEST_WAREHOUSE_ID, + store_id: { [Op.ne]: TEST_STORE_ID }, + }, + order: [[ 'id', 'ASC' ]], + raw: true, + }); + } + + /** + * 拉取其他仓库的库存行(跨仓库隔离校验用)。 + * + * @return {Promise} 库存行。 + */ + async function fetchOtherWarehouseStockRow() { + const { Op } = ctx.app.Sequelize; + return ctx.model.StockWarehouse.findOne({ + where: { warehouse_id: { [Op.ne]: TEST_WAREHOUSE_ID } }, + order: [[ 'id', 'ASC' ]], + raw: true, + }); + } + + /** + * 查询库位商品账面数量(wms_storage 按 stock_id SUM(可用+锁定),与实现口径一致)。 + * + * @param {number} spaceId 库位ID。 + * @param {Array} stockIds 商品库存ID列表。 + * @return {Promise>} stock_id -> 账面数量。 + */ + async function fetchStorageQuantity(spaceId, stockIds) { + const { Op, literal } = ctx.app.Sequelize; + const rows = await ctx.model.Storage.findAll({ + where: { + space_id: Number(spaceId), + stock_id: { [Op.in]: stockIds.map(id => Number(id)) }, + }, + attributes: [ 'stock_id', [ literal('SUM(available_quantity + locked_quantity)'), 'totalQuantity' ]], + group: [ 'stock_id' ], + raw: true, + }); + return new Map(rows.map(row => [ Number(row.stock_id), Number(row.totalQuantity) || 0 ])); + } + + /** + * 查询库位下真实库存商品ID列表(用于库位行多商品上报,按 stock_id 升序)。 + * + * @param {number} spaceId 库位ID。 + * @param {number} [count] 行数。 + * @return {Promise>} 商品库存ID列表。 + */ + async function fetchStorageStockIds(spaceId, count = 2) { + const rows = await ctx.model.Storage.findAll({ + where: { space_id: Number(spaceId) }, + attributes: [ 'stock_id' ], + group: [ 'stock_id' ], + order: [[ 'stock_id', 'ASC' ]], + limit: count, + raw: true, + }); + return rows.map(row => Number(row.stock_id)); + } + + /** + * 取固定测试仓库下「只存放在单一库位」的有效商品与库位对(保证库位-商品一一对应, + * 供 space 视图聚合/排序用例使用),并附库位编码/名称与账面数量(账面口径与实现一致: + * wms_storage 按 warehouse+space+stock+is_enabled=1 SUM(available_quantity+locked_quantity)) + * 及锁定数量(SUM(locked_quantity))。 + * + * @param {number} count 对数。 + * @return {Promise>} [{ spaceId, stockId, spaceCode, customName, book, bookLocked }]。 + */ + async function fetchSpaceStockPairs(count = 3) { + const { Op, fn, col, literal } = ctx.app.Sequelize; + const storageRows = await ctx.model.Storage.findAll({ + where: { + warehouse_id: TEST_WAREHOUSE_ID, + is_enabled: 1, + space_id: { [Op.in]: literal(VALID_SPACE_SQL) }, + }, + attributes: [ 'space_id', 'stock_id' ], + raw: true, + }); + + // 商品 → 库位集合(筛选只存放在单一库位的商品,避免同商品多库位干扰聚合断言) + const spacesByStock = new Map(); + for (const row of storageRows) { + const stockId = Number(row.stock_id); + if (!spacesByStock.has(stockId)) { + spacesByStock.set(stockId, new Set()); + } + spacesByStock.get(stockId).add(Number(row.space_id)); + } + const candidatesBySpace = new Map(); + for (const [ stockId, spaceSet ] of spacesByStock) { + if (spaceSet.size !== 1) { + continue; + } + const spaceId = [ ...spaceSet ][0]; + if (!candidatesBySpace.has(spaceId)) { + candidatesBySpace.set(spaceId, []); + } + candidatesBySpace.get(spaceId).push(stockId); + } + + const pairs = []; + const sortedSpaces = [ ...candidatesBySpace.keys() ].sort((left, right) => left - right); + for (const spaceId of sortedSpaces) { + const stockId = candidatesBySpace.get(spaceId).sort((left, right) => left - right)[0]; + const stock = await ctx.model.StockWarehouse.findOne({ + where: { id: stockId, warehouse_id: TEST_WAREHOUSE_ID, is_valid: 'Y' }, + attributes: [ 'id' ], + raw: true, + }); + if (!stock) { + continue; + } + const space = await ctx.model.LocationSpace.findOne({ + where: { id: spaceId }, + attributes: [ 'id', 'space_code', 'custom_name' ], + raw: true, + }); + if (!space) { + continue; + } + const bookRows = await ctx.model.Storage.findAll({ + where: { + warehouse_id: TEST_WAREHOUSE_ID, + space_id: spaceId, + stock_id: stockId, + is_enabled: 1, + }, + attributes: [ + [ ctx.app.Sequelize.literal('SUM(available_quantity + locked_quantity)'), 'totalQuantity' ], + [ fn('SUM', col('locked_quantity')), 'totalLockedQuantity' ], + ], + raw: true, + }); + pairs.push({ + spaceId, + stockId, + spaceCode: String(space.space_code || '').trim(), + customName: String(space.custom_name || '').trim(), + book: Number(bookRows[0] && bookRows[0].totalQuantity) || 0, + bookLocked: Number(bookRows[0] && bookRows[0].totalLockedQuantity) || 0, + }); + if (pairs.length >= count) { + break; + } + } + assert.ok( + pairs.length >= Math.min(count, 2), + `固定测试仓库应存在至少 ${Math.min(count, 2)} 个单一库位库存商品(space 视图真实数据依赖)` + ); + return pairs; + } + + /** + * 按实现口径解析货主名(合约表 store_remask 优先、公司名兜底、查不到为 null), + * 供 workData 各视图 store_name 字段交叉验证。 + * + * @param {number} storeId 货主ID。 + * @return {Promise} 货主名称。 + */ + async function resolveStoreName(storeId) { + const normalizedId = Number(storeId); + if (!Number.isInteger(normalizedId) || normalizedId <= 0) { + return null; + } + const contract = await ctx.model.StoreWarehouse.findOne({ + where: { store_id: normalizedId, warehouse_id: TEST_WAREHOUSE_ID }, + attributes: [ 'store_remask' ], + raw: true, + }); + if (contract && contract.store_remask) { + return contract.store_remask; + } + const store = await ctx.model.Store.findOne({ + where: { id: normalizedId }, + attributes: [ 'company_name' ], + raw: true, + }); + return (store && store.company_name) || null; + } + + /** + * 创建一条已审核(approved)的库位维度盘点任务(固定测试库位),返回主表与库位明细行。 + * + * @return {Promise} { check, detail }。 + */ + async function createApprovedLocationCheck() { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + const details = await detailCheck(check.id); + return { check, detail: details.rows[0] }; + } + + /** + * 业务层:添加盘点明细(商品维度)。 + * + * @param {number} checkId 盘点任务ID。 + * @param {Array} stockIds 库存ID列表。 + * @return {Promise} 添加结果。 + */ + async function addDetail(checkId, stockIds) { + return ctx.service.systems.stockCheck.addDetail({ + warehouseId: TEST_WAREHOUSE_ID, + id: checkId, + stockIds, + }); + } + + /** + * 业务层:添加盘点明细(库位维度)。 + * + * @param {number} checkId 盘点任务ID。 + * @param {Array} [locations] 库位编码列表(缺省时按任务类型处理)。 + * @return {Promise} 添加结果。 + */ + async function addLocationDetail(checkId, locations) { + return ctx.service.systems.stockCheck.addDetail({ + warehouseId: TEST_WAREHOUSE_ID, + id: checkId, + locations, + }); + } + + /** + * 业务层:添加盘点明细(原始参数透传,用于维度互斥等参数校验场景)。 + * + * @param {Object} params 添加参数(自动注入固定测试仓库)。 + * @return {Promise} 添加结果。 + */ + async function addDetailRaw(params = {}) { + return ctx.service.systems.stockCheck.addDetail({ + warehouseId: TEST_WAREHOUSE_ID, + ...params, + }); + } + + /** + * 业务层:批量添加库位明细(兼容入口,按库位ID直查)。 + * + * @param {number} checkId 盘点任务ID。 + * @param {Array} locationIds 库位ID列表。 + * @return {Promise} 添加结果。 + */ + async function addLocationDetailByIds(checkId, locationIds) { + return ctx.service.systems.stockCheck.addLocationDetail({ + warehouseId: TEST_WAREHOUSE_ID, + id: checkId, + locationIds, + }); + } + + /** + * 取一个本地库中不存在的库位ID(按当前最大 ID 递增,避免与真实数据冲突)。 + * + * @return {Promise} 不存在的库位ID。 + */ + async function fetchMissingLocationId() { + const { fn, col } = ctx.app.Sequelize; + const maxRow = await ctx.model.LocationSpace.findOne({ + attributes: [[ fn('MAX', col('id')), 'maxId' ]], + raw: true, + }); + return Number(maxRow && maxRow.maxId) + 1000; + } + + /** + * 业务层:提交审核。 + * + * @param {number} checkId 盘点任务ID。 + * @return {Promise} 提交结果。 + */ + async function submitCheck(checkId) { + return ctx.service.systems.stockCheck.submit({ + warehouseId: TEST_WAREHOUSE_ID, + id: checkId, + }); + } + + /** + * 业务层:取消任务。 + * + * @param {number} checkId 盘点任务ID。 + * @return {Promise} 取消结果。 + */ + async function cancelCheck(checkId) { + return ctx.service.systems.stockCheck.cancel({ + warehouseId: TEST_WAREHOUSE_ID, + id: checkId, + }); + } + + /** + * 业务层:审核任务。 + * + * @param {number} checkId 盘点任务ID。 + * @param {string} action approve/reject。 + * @param {string} [reason] 驳回原因。 + * @return {Promise} 审核结果。 + */ + async function auditCheck(checkId, action, reason) { + return ctx.service.systems.stockCheck.audit({ + warehouseId: TEST_WAREHOUSE_ID, + id: checkId, + action, + reason, + }); + } + + /** + * 取测试仓库内 N 个分区有效(zone 存在未删除)的库位,供多库位上报用例使用。 + * + * @param {number} count 需要的库位数量。 + * @return {Promise>} [{ id, space_code }](按 id 升序,过滤空编码)。 + */ + async function fetchValidLocations(count = 3) { + const rows = await ctx.model.LocationSpace.findAll({ + where: { warehouse_id: TEST_WAREHOUSE_ID }, + attributes: [ 'id', 'space_code' ], + include: [{ + model: ctx.model.LocationZone, + as: 'zone', + attributes: [], + required: true, + }], + order: [[ 'id', 'ASC' ]], + limit: count + 20, + raw: true, + }); + return rows + .filter(row => String(row.space_code || '').trim()) + .slice(0, count) + .map(row => ({ id: Number(row.id), space_code: String(row.space_code).trim() })); + } + + /** + * 解析上报应携带的 space_id(库位ID):就近取「本仓库 + 分区有效」的库位行。 + * report 已改为 space_id 必传,测试通过本函数模拟调用方从取回数据中拿到的库位ID。 + * + * @param {number} detailId 盘点明细ID。 + * @param {string} [location] 上报库位编码。 + * @return {Promise} 库位ID(解析不到返回 0)。 + */ + async function resolveReportSpaceId(detailId, location) { + const { Op } = ctx.app.Sequelize; + const code = location !== undefined && location !== null ? String(location).trim() : ''; + const validZoneInclude = [{ + model: ctx.model.LocationZone, + as: 'zone', + attributes: [], + required: true, + }]; + if (code) { + const row = await ctx.model.LocationSpace.findOne({ + where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: code }, + attributes: [ 'id' ], + include: validZoneInclude, + order: [[ 'id', 'ASC' ]], + raw: true, + }); + return row ? Number(row.id) : 0; + } + const detail = await ctx.model.StockCheckDetail.findOne({ + where: { id: Number(detailId), warehouse_id: { [Op.or]: [ TEST_WAREHOUSE_ID, OTHER_TEST_WAREHOUSE_ID ] } }, + attributes: [ 'location_id', 'location_code', 'warehouse_id' ], + raw: true, + }); + if (!detail) { + return 0; + } + const candidateIds = []; + if (Number(detail.location_id) > 0) { + candidateIds.push(Number(detail.location_id)); + } + const detailCode = String(detail.location_code || '').trim(); + if (detailCode) { + const rows = await ctx.model.LocationSpace.findAll({ + where: { warehouse_id: Number(detail.warehouse_id), space_code: detailCode }, + attributes: [ 'id' ], + include: validZoneInclude, + order: [[ 'id', 'ASC' ]], + raw: true, + }); + for (const row of rows) { + if (!candidateIds.includes(Number(row.id))) { + candidateIds.push(Number(row.id)); + } + } + } + if (candidateIds.length === 0) { + return 0; + } + const validRow = await ctx.model.LocationSpace.findOne({ + where: { id: { [Op.in]: candidateIds } }, + attributes: [ 'id' ], + include: validZoneInclude, + order: [[ 'id', 'ASC' ]], + raw: true, + }); + return validRow ? Number(validRow.id) : 0; + } + + /** + * 业务层:盘点作业上报。 + * space_id 必传(report 强制要求):未显式传 options.spaceId 时按上报库位编码/明细库位自动解析。 + * + * @param {number} checkId 盘点任务ID。 + * @param {number} detailId 明细ID。 + * @param {number} quantity 实盘数量。 + * @param {string} [location] 库位编码。 + * @param {Object} [options] 覆盖项(spaceId/stockId/barcode/itemName/checkerId/checkerName/is_empty; + * spaceId 显式传 0/null 表示「不携带库位ID」用于 400 用例; + * 库位行必传 stockId 或 barcode(或 is_empty=true 空库位标记),itemName 为未知商品名称快照)。 + * @return {Promise} 上报结果(含新增作业记录 record 与主表汇总)。 + */ + async function reportCheck(checkId, detailId, quantity, location, options = {}) { + const spaceId = options.spaceId !== undefined + ? options.spaceId + : await resolveReportSpaceId(detailId, location); + return ctx.service.systems.stockCheck.report({ + warehouseId: options.warehouseId !== undefined ? options.warehouseId : TEST_WAREHOUSE_ID, + id: checkId, + detailId, + quantity, + location, + spaceId, + stockId: options.stockId, + barcode: options.barcode, + itemName: options.itemName, + is_empty: options.is_empty, + checkerId: options.checkerId !== undefined ? options.checkerId : TEST_CREATOR_ID, + checkerName: options.checkerName !== undefined ? options.checkerName : TEST_CREATOR_NAME, + }); + } + + /** + * 业务层:完成盘点。 + * + * @param {number} checkId 盘点任务ID。 + * @return {Promise} 完成结果。 + */ + async function finishCheck(checkId) { + return ctx.service.systems.stockCheck.finish({ + warehouseId: TEST_WAREHOUSE_ID, + id: checkId, + }); + } + + /** + * 业务层:查询列表。 + * + * @param {Object} [params] 查询参数。 + * @return {Promise} 列表结果。 + */ + async function listChecks(params = {}) { + return ctx.service.systems.stockCheck.list({ + warehouseId: TEST_WAREHOUSE_ID, + ...params, + }); + } + + /** + * 业务层:查询任务详情(主表信息 + 全部明细范围行)。 + * detail 接口只返回任务本身信息({ check });明细范围行改由直查明细表补齐 + * (等价于原 detail.rows 的纯范围行口径),供用例获取明细 ID / 快照字段使用。 + * + * @param {number} checkId 盘点任务ID。 + * @return {Promise} { check, rows, total }。 + */ + async function detailCheck(checkId) { + const { check } = await ctx.service.systems.stockCheck.detail({ + warehouseId: TEST_WAREHOUSE_ID, + id: checkId, + }); + const rows = await ctx.model.StockCheckDetail.findAll({ + where: { check_id: checkId, warehouse_id: TEST_WAREHOUSE_ID }, + order: [[ 'id', 'ASC' ]], + raw: true, + }); + return { check, rows, total: rows.length }; + } + + /** + * 业务层:查询盘点结果聚合(范围行 + 作业记录聚合)。 + * + * @param {number} checkId 盘点任务ID。 + * @return {Promise} { check, rows, total }。 + */ + async function resultCheck(checkId) { + return ctx.service.systems.stockCheck.result({ + warehouseId: TEST_WAREHOUSE_ID, + id: checkId, + }); + } + + /** + * 业务层:拉取盘点作业数据(视图由任务类型与 is_goods 驱动)。 + * + * @param {number} checkId 盘点任务ID。 + * @param {Object} [options] 可选参数 { isGoods, keyword, onlyAbnormal, pagination }。 + * @return {Promise} { view, rows, total, page, pageSize }。 + */ + async function workDataCheck(checkId, options = {}) { + const extraParams = options && typeof options === 'object' ? options : {}; + return ctx.service.systems.stockCheck.workData({ + warehouseId: TEST_WAREHOUSE_ID, + id: checkId, + ...extraParams, + }); + } + + /** + * 业务层:拉取单条盘点明细的作业数据(workData 单行版)。 + * + * @param {number} detailId 盘点明细ID。 + * @return {Promise} 单行作业数据。 + */ + async function workDataDetailCheck(detailId) { + return ctx.service.systems.stockCheck.workDataDetail({ + warehouseId: TEST_WAREHOUSE_ID, + detailId, + }); + } + + /** + * 读取主表最新状态。 + * + * @param {number} checkId 盘点任务ID。 + * @return {Promise} 主表行(plain)。 + */ + async function findCheckRow(checkId) { + const row = await ctx.model.StockCheck.findOne({ + where: { id: Number(checkId) }, + }); + return row ? row.get({ plain: true }) : null; + } + + /** + * 直插主表 created_at(造不同创建时间的历史任务,供 created_at 范围筛选用例使用)。 + * + * @param {number} checkId 盘点任务ID。 + * @param {Date} createdAt 目标创建时间。 + * @return {Promise} 更新后的主表行(plain)。 + */ + async function setCheckCreatedAt(checkId, createdAt) { + await ctx.model.StockCheck.update( + { created_at: createdAt }, + { where: { id: Number(checkId) } } + ); + return findCheckRow(checkId); + } + + /** + * 查询盘点作业记录(wms_stock_check_record)。 + * + * @param {number} checkId 盘点任务ID。 + * @param {number} [detailId] 明细ID(可选,用于限定某条明细)。 + * @return {Promise>} 作业记录行(plain,按 id 升序)。 + */ + async function queryRecords(checkId, detailId) { + const where = { check_id: Number(checkId) }; + if (detailId !== undefined) { + where.detail_id = Number(detailId); + } + return ctx.model.StockCheckRecord.findAll({ + where, + order: [[ 'id', 'ASC' ]], + raw: true, + }); + } + + /** + * 业务层:删除作业记录(批量:单值自动转数组,未命中计入 skipped_ids 不报错)。 + * + * @param {number} checkId 盘点任务ID。 + * @param {Array|number} recordIds 作业记录ID(单值或数组,单次上限 200)。 + * @return {Promise} 删除结果(含重算后的汇总)。 + */ + async function deleteRecord(checkId, recordIds) { + return ctx.service.systems.stockCheck.recordDelete({ + warehouseId: TEST_WAREHOUSE_ID, + id: checkId, + recordIds, + }); + } + + /** + * 业务层:删除盘点明细(批量:单值自动转数组,未命中计入 skipped_ids 不报错)。 + * + * @param {number} checkId 盘点任务ID。 + * @param {Array|number} detailIds 盘点明细ID(单值或数组,单次上限 200)。 + * @return {Promise} { deleted_count, deleted_ids, skipped_ids, total_items }。 + */ + async function deleteDetail(checkId, detailIds) { + return ctx.service.systems.stockCheck.detailDelete({ + warehouseId: TEST_WAREHOUSE_ID, + id: checkId, + detailIds, + }); + } + + /** + * 业务层:删除盘点明细(原始参数透传,用于参数校验场景)。 + * + * @param {Object} params 删除参数(自动注入固定测试仓库)。 + * @return {Promise} { deleted_count, deleted_ids, skipped_ids, total_items }。 + */ + async function deleteDetailRaw(params = {}) { + return ctx.service.systems.stockCheck.detailDelete({ + warehouseId: TEST_WAREHOUSE_ID, + ...params, + }); + } + + /** + * 业务层:查询作业记录列表。 + * + * @param {Object} [params] 查询参数(id/detailId/pagination)。 + * @return {Promise} { rows, total, page, pageSize }。 + */ + async function listRecords(params = {}) { + return ctx.service.systems.stockCheck.recordList({ + warehouseId: TEST_WAREHOUSE_ID, + ...params, + }); + } + + /** + * 业务层:批量删除盘点任务(固定测试仓库)。 + * + * @param {Array|number} ids 盘点任务ID(数组或单值)。 + * @return {Promise} { total, deleted_count, skipped_count, deleted_ids, skipped_ids }。 + */ + async function batchDeleteCheck(ids) { + return ctx.service.systems.stockCheck.batchDelete({ + warehouseId: TEST_WAREHOUSE_ID, + ids, + }); + } + + /** + * 业务层:批量删除盘点任务(原始参数透传,用于参数校验场景)。 + * + * @param {Object} params 批量删除参数。 + * @return {Promise} { total, deleted_count, skipped_count, deleted_ids, skipped_ids }。 + */ + async function batchDeleteRaw(params = {}) { + return ctx.service.systems.stockCheck.batchDelete(params); + } + + /** + * 取一个当前库中不存在的盘点任务 ID(基于主表最大 ID 偏移,避免误删历史数据)。 + * + * @return {Promise} 不存在的主键 ID。 + */ + async function findFreeCheckId() { + const row = await ctx.model.StockCheck.findOne({ + attributes: [ 'id' ], + order: [[ 'id', 'DESC' ]], + raw: true, + }); + return (row ? Number(row.id) : 0) + 1000000; + } + + /** + * 取一个当前库中不存在的盘点明细 ID(基于明细表最大 ID 偏移,避免误删历史数据)。 + * + * @return {Promise} 不存在的主键 ID。 + */ + async function findFreeDetailId() { + const row = await ctx.model.StockCheckDetail.findOne({ + attributes: [ 'id' ], + order: [[ 'id', 'DESC' ]], + raw: true, + }); + return (row ? Number(row.id) : 0) + 1000000; + } + + /** + * 创建一条已作废的盘点任务(含 1 条商品明细,status=cancelled)。 + * + * @return {Promise} { check, stock }。 + */ + async function createCancelledCheck() { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await cancelCheck(check.id); + return { check, stock: stocks[0] }; + } + + /** + * 构造商品条码(wms_stock_barcodes,固定测试仓库,条码值唯一)。 + * + * @param {number} stockId 商品库存ID(wms_stock_warehouse.id,需属于测试仓库)。 + * @param {string} [barcode] 条码值(缺省自动生成唯一条码)。 + * @return {Promise} { barcode, stockBarcode }。 + */ + async function createStockBarcode(stockId, barcode) { + const barcodeValue = barcode || uniqueTitle('TEST-BARCODE'); + const stockBarcode = await ctx.model.StockBarcode.create({ + stock_id: Number(stockId), + warehouse_id: TEST_WAREHOUSE_ID, + barcode: barcodeValue, + description: '盘点未知商品测试条码', + create_time: new Date(), + }); + return { barcode: barcodeValue, stockBarcode }; + } + + /** + * 为作业记录挂载图片(图片独立维护口径:wms_file + wms_file_reference, + * business_type=stock_check_record、business_id=记录ID)。 + * + * @param {number} recordId 作业记录ID。 + * @return {Promise} { file, reference }。 + */ + async function createRecordImage(recordId) { + const token = uniqueTitle('img'); + const file = await ctx.model.File.create({ + warehouse_id: TEST_WAREHOUSE_ID, + file_key: `test/stock_check/${token}.jpg`, + file_url: `https://img.test.local/${token}.jpg`, + file_name: `${token}.jpg`, + file_size: 1024, + file_type: 'stock_check_image', + mime_type: 'image/jpeg', + md5_hash: crypto.createHash('md5').update(token).digest('hex'), + sha1_hash: crypto.createHash('sha1').update(token).digest('hex'), + storage_mode: 'cos', + uploader_id: String(TEST_CREATOR_ID), + uploader_name: TEST_CREATOR_NAME, + created_at: new Date(), + }); + const reference = await ctx.model.FileReference.create({ + file_id: file.id, + warehouse_id: TEST_WAREHOUSE_ID, + business_type: 'stock_check_record', + business_id: String(recordId), + display_order: 0, + created_by: String(TEST_CREATOR_ID), + created_at: new Date(), + }); + return { file, reference }; + } + + // ------------------- create:创建盘点任务 ------------------- + + describe('create 创建盘点任务', () => { + it('生成 PD+YYYYMMDD+6位序号单号,初始状态 created', async () => { + const result = await createCheck(); + + assert.match(result.check_no, /^PD\d{14}$/, `单号格式应为 PD+YYYYMMDD+6位序号: ${result.check_no}`); + assert.ok(result.check_no.startsWith(`PD${currentDatePart()}`), '单号日期部分应为当前日期'); + assert.equal(result.status, 'created'); + assert.equal(result.detail_status, 'none_checked'); + assert.equal(result.total_items, 0); + assert.equal(result.checked_items, 0); + + const row = await findCheckRow(result.id); + assert.equal(row.warehouse_id, TEST_WAREHOUSE_ID, '主表应写入固定测试仓库 ID'); + assert.equal(row.check_no, result.check_no); + }); + + it('同仓库连续创建序号递增', async () => { + const first = await createCheck(); + const second = await createCheck(); + + const firstSeq = Number(first.check_no.slice(-6)); + const secondSeq = Number(second.check_no.slice(-6)); + assert.equal(secondSeq, firstSeq + 1, `序号应连续递增: ${first.check_no} -> ${second.check_no}`); + }); + + it('跨仓库创建序号全局递增:另一仓库单号接续本仓库序号', async () => { + const first = await createCheck(); + const second = await createCheck({ warehouseId: OTHER_TEST_WAREHOUSE_ID }); + + const firstSeq = Number(first.check_no.slice(-6)); + const secondSeq = Number(second.check_no.slice(-6)); + assert.equal( + secondSeq, + firstSeq + 1, + `跨仓库序号应接续递增(不按仓库隔离): ${first.check_no} -> ${second.check_no}` + ); + + const secondRow = await ctx.model.StockCheck.findOne({ + where: { id: second.id }, + raw: true, + }); + assert.equal(Number(secondRow.warehouse_id), OTHER_TEST_WAREHOUSE_ID, '第二个任务应写入另一测试仓库'); + }); + + it('单号撞 uk_check_no 唯一键自动重取:创建成功且取到下一号', async () => { + const service = ctx.service.systems.stockCheck; + const expectedNo = await service.generateCheckNo(); + const expectedSeq = Number(expectedNo.slice(-6)); + + // 预插入同前缀同序号单号,模拟并发创建先占号 + const occupied = await ctx.model.StockCheck.create({ + warehouse_id: OTHER_TEST_WAREHOUSE_ID, + check_no: expectedNo, + title: uniqueTitle('盘点单元测试-撞号占位'), + type: 'location', + mode: 'blind', + status: 'created', + detail_status: 'none_checked', + creator_id: TEST_CREATOR_ID, + creator_name: TEST_CREATOR_NAME, + }); + assert.equal(occupied.check_no, expectedNo, '占位单号应等于预取单号'); + + // 模拟并发撞号:首次取号强制返回已占用单号,随后恢复真实取号逻辑, + // 使 create 的第一次 INSERT 真实触发 uk_check_no 冲突并进入重试。 + const originalGenerate = service.generateCheckNo.bind(service); + let generateCalls = 0; + mm(service, 'generateCheckNo', async () => { + generateCalls += 1; + if (generateCalls === 1) { + return expectedNo; + } + return originalGenerate(); + }); + + const created = await createCheck(); + mm.restore(); + + assert.equal(generateCalls, 2, '撞号后应重新取号一次(第一次撞号、第二次成功)'); + const createdSeq = Number(created.check_no.slice(-6)); + assert.equal( + createdSeq, + expectedSeq + 1, + `撞号后应自动重取下一号: ${expectedNo} -> ${created.check_no}` + ); + const rowCount = await ctx.model.StockCheck.count({ where: { check_no: created.check_no } }); + assert.equal(rowCount, 1, '重取后的单号应正常落库且全局唯一'); + }); + + it('isCheckNoDuplicateError:仅 ER_DUP_ENTRY 且命中 check_no 唯一索引判为撞号', () => { + const service = ctx.service.systems.stockCheck; + + const dupError = new Error('insert duplicate'); + dupError.parent = { + code: 'ER_DUP_ENTRY', + sqlMessage: "Duplicate entry 'PD20260929000001' for key 'wms_stock_check.uk_check_no'", + }; + assert.equal(service.isCheckNoDuplicateError(dupError), true, 'uk_check_no 唯一键冲突应判定为撞号'); + + const primaryError = new Error('insert duplicate'); + primaryError.parent = { code: 'ER_DUP_ENTRY', sqlMessage: "Duplicate entry '1' for key 'PRIMARY'" }; + assert.equal(service.isCheckNoDuplicateError(primaryError), false, '主键冲突不应判定为撞号'); + + const deadlockError = new Error('deadlock'); + deadlockError.parent = { code: 'ER_LOCK_DEADLOCK', sqlMessage: 'Deadlock found' }; + assert.equal(service.isCheckNoDuplicateError(deadlockError), false, '其他错误码不应判定为撞号'); + + const noParentError = new Error("Duplicate entry for key 'uk_check_no'"); + assert.equal(service.isCheckNoDuplicateError(noParentError), false, '缺少 parent 元数据不应判定为撞号'); + }); + + it('非法 type/mode 或按货主缺货主时报 400(check_date 已移除入参)', async () => { + await assert.rejects(async () => { + await createCheck({ type: 'bad_type' }); + }, error => error.code === 400); + + await assert.rejects(async () => { + await createCheck({ mode: 'bad_mode' }); + }, error => error.code === 400); + + await assert.rejects(async () => { + await createCheck({ type: 'store', storeId: null }); + }, error => error.code === 400); + }); + + it('create 不写 check_date:返回与主表均不含该字段,start_time/end_time 初始为空', async () => { + const result = await createCheck(); + + assert.equal(result.status, 'created'); + assert.equal( + Object.prototype.hasOwnProperty.call(result, 'check_date'), + false, + 'create 返回结果不应含 check_date 字段' + ); + const row = await findCheckRow(result.id); + assert.equal( + Object.prototype.hasOwnProperty.call(row, 'check_date'), + false, + '主表行不应含 check_date 字段' + ); + assert.equal(row.start_time, null, '创建时 start_time 应为空(首次上报明细才写入)'); + assert.equal(row.end_time, null, '创建时 end_time 应为空(完成盘点才写入)'); + }); + + it('type=location 传 mode=open:按库位盘点一律盲盘,忽略前端传入', async () => { + const result = await createCheck({ type: 'location', mode: 'open' }); + + assert.equal(result.mode, 'blind', '按库位盘点应强制盲盘,忽略前端传入的 mode=open'); + const row = await findCheckRow(result.id); + assert.equal(row.mode, 'blind', '主表应落库 blind'); + }); + + it('type=all 已下线:创建报 400(全盘语义并入 location)', async () => { + await assert.rejects(async () => { + await createCheck({ type: 'all' }); + }, error => error.code === 400 && /盘点范围类型不合法/.test(error.message)); + }); + + it('type=goods 传 mode=blind:按商品盘点保留传入值', async () => { + const result = await createCheck({ type: 'goods', mode: 'blind' }); + + assert.equal(result.mode, 'blind', '按商品盘点应保留传入的 mode=blind'); + const row = await findCheckRow(result.id); + assert.equal(row.mode, 'blind', '主表应落库 blind'); + }); + + it('type=store 不传 mode:按商品盘点默认明盘 open', async () => { + // 业务层直调且不传 mode,验证默认明盘(绕过 createCheck 辅助函数的 mode 兜底) + const result = await ctx.service.systems.stockCheck.create({ + warehouseId: TEST_WAREHOUSE_ID, + title: uniqueTitle('盘点单元测试-货主默认明盘'), + type: 'store', + storeId: TEST_STORE_ID, + creatorId: TEST_CREATOR_ID, + creatorName: TEST_CREATOR_NAME, + }); + + assert.equal(result.mode, 'open', '按货主盘点不传 mode 应默认明盘 open'); + const row = await findCheckRow(result.id); + assert.equal(row.mode, 'open', '主表应落库 open'); + }); + }); + + // ------------------- addDetail:添加盘点明细 ------------------- + + describe('addDetail 添加盘点明细', () => { + it('按 stock_ids 生成明细快照(item_code/item_name/spec/system_quantity)', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + const stockIds = stocks.map(stock => stock.id); + + const result = await addDetail(check.id, stockIds); + + assert.equal(result.added, 2); + assert.equal(result.skipped, 0); + assert.equal(result.total_items, 2); + + const rows = await ctx.model.StockCheckDetail.findAll({ + where: { check_id: check.id }, + order: [[ 'id', 'ASC' ]], + raw: true, + }); + assert.equal(rows.length, 2); + + for (const row of rows) { + const stock = stocks.find(item => item.id === Number(row.stock_id)); + assert.ok(stock, `明细应命中库存快照 stock_id=${row.stock_id}`); + assert.equal(row.item_code, stock.item_code, 'item_code 快照不一致'); + assert.equal(row.item_name, stock.item_name, 'item_name 快照不一致'); + assert.equal(row.spec, stock.sku_property, 'spec 应快照 sku_property'); + // 拆行口径:system_quantity = 该商品在其库存库位的账面(wms_storage SUM(可用+锁定)) + const storageRows = await ctx.model.Storage.findAll({ + where: { + warehouse_id: TEST_WAREHOUSE_ID, + stock_id: Number(row.stock_id), + space_id: Number(row.location_id), + is_enabled: 1, + }, + raw: true, + }); + const expectedSystemQuantity = storageRows.reduce( + (sum, item) => sum + (Number(item.available_quantity) || 0) + (Number(item.locked_quantity) || 0), + 0 + ); + assert.equal(Number(row.system_quantity), expectedSystemQuantity, 'system_quantity 应为该库位账面'); + assert.equal(row.batch_no, null, '批次快照默认应为空'); + } + + // 明细范围行由直查明细表校验(detail 接口只返回任务本身信息):商品行 scope_type=goods 且绑定库存库位 + const detailResult = await detailCheck(check.id); + assert.equal(detailResult.total, 2); + for (const row of detailResult.rows) { + assert.equal(row.scope_type, 'goods', '商品明细 scope_type 应为 goods'); + assert.ok(row.stock_id, '商品明细应含 stock_id'); + assert.ok(row.location_id, '商品明细应绑定库存库位'); + assert.ok(row.location_code, '商品明细应绑定库位编码'); + } + + // 盘点前(无作业记录):result 直接返回明细范围行(wms_stock_check_detail) + const checkResult = await resultCheck(check.id); + assert.equal(checkResult.total, 2); + for (const row of checkResult.rows) { + assert.equal(row.scope_type, 'goods'); + assert.ok(row.stock_id, '明细行应含 stock_id'); + assert.ok(row.location_code, '明细行应含库位编码'); + assert.ok(Number(row.system_quantity) >= 0, '明细行应含账面快照'); + } + const recordCount = await ctx.model.StockCheckRecord.count({ + where: { check_id: check.id }, + }); + assert.equal(recordCount, 0, '添加明细阶段不应写作业记录'); + }); + + it('重复添加同一 stock_id 幂等跳过,不重复生成明细', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + const stockIds = stocks.map(stock => stock.id); + + const first = await addDetail(check.id, stockIds); + const second = await addDetail(check.id, stockIds); + + assert.equal(first.added, 2); + assert.equal(second.added, 0); + assert.equal(second.skipped, 2); + + const count = await ctx.model.StockCheckDetail.count({ + where: { check_id: check.id }, + }); + assert.equal(count, 2, '重复添加不应生成多余明细'); + }); + + it('多库位商品按「商品 + 库位」拆多行,各行账面为该库位库存', async () => { + const { Op, literal } = ctx.app.Sequelize; + // 找一个在两个启用库位都有库存的商品 + const storageRows = await ctx.model.Storage.findAll({ + where: { + warehouse_id: TEST_WAREHOUSE_ID, + is_enabled: 1, + space_id: { [Op.in]: literal(VALID_SPACE_SQL) }, + }, + attributes: [ 'stock_id', 'space_id', [ literal('SUM(available_quantity + locked_quantity)'), 'totalQuantity' ]], + group: [ 'stock_id', 'space_id' ], + raw: true, + }); + const spacesByStock = new Map(); + for (const row of storageRows) { + const stockId = Number(row.stock_id); + if (!spacesByStock.has(stockId)) { + spacesByStock.set(stockId, []); + } + spacesByStock.get(stockId).push(row); + } + const multiStockEntry = [ ...spacesByStock.entries() ].find(([ , rows ]) => rows.length >= 2); + assert.ok(multiStockEntry, '前置:测试库应存在多库位库存商品'); + const multiStockId = Number(multiStockEntry[0]); + const multiStock = await ctx.model.StockWarehouse.findOne({ + where: { id: multiStockId, warehouse_id: TEST_WAREHOUSE_ID }, + raw: true, + }); + assert.ok(multiStock, '前置:多库位商品应存在于 wms_stock_warehouse'); + + const check = await createCheck({ type: 'goods', storeId: multiStock.store_id || null }); + const result = await addDetail(check.id, [ multiStockId ]); + + assert.equal(result.added, multiStockEntry[1].length, 'added 应为拆分明细行数(商品按库位拆多行)'); + assert.equal(result.total_items, 1, '按商品盘点 total_items 按商品计数(多库位拆多行仍计 1 项)'); + + const rows = await ctx.model.StockCheckDetail.findAll({ + where: { check_id: check.id }, + order: [[ 'id', 'ASC' ]], + raw: true, + }); + assert.equal(rows.length, multiStockEntry[1].length); + const spaceIds = rows.map(row => Number(row.location_id)).sort((a, b) => a - b); + assert.deepEqual( + spaceIds, + multiStockEntry[1].map(row => Number(row.space_id)).sort((a, b) => a - b), + '明细行应覆盖商品全部库存库位' + ); + const quantityBySpace = new Map(multiStockEntry[1].map(row => [ Number(row.space_id), Number(row.totalQuantity) || 0 ])); + for (const row of rows) { + assert.equal(Number(row.system_quantity), quantityBySpace.get(Number(row.location_id)), '各行账面应为该库位库存'); + assert.ok(row.location_code, '各行应绑定库位编码'); + } + + // 拆行任务可正常提交 + const submitResult = await submitCheck(check.id); + assert.equal(submitResult.status, 'submitted'); + }); + + it('商品在仓库中没有启用库存库位 → 计入 invalid_stock_ids 不入明细', async () => { + const check = await createCheck(); + // 构造无库存库位的商品(只写 wms_stock_warehouse,不写 wms_storage) + const [ fabricatedResult ] = await ctx.model.query( + `INSERT INTO wms_stock_warehouse + (item_code, item_name, store_id, stock_unit, item_type, create_at, + warehouse_id, is_valid, quantity, is_shelf_life_mgmt, remaining_threshold_days) + VALUES (:itemCode, '盘点拆行测试商品', :storeId, '个', 'normal', NOW(), + :warehouseId, 'Y', 3, 'N', 0)`, + { + replacements: { + itemCode: `PATT-NOLOC-${Date.now()}`, + storeId: TEST_STORE_ID, + warehouseId: TEST_WAREHOUSE_ID, + }, + type: ctx.model.QueryTypes.INSERT, + } + ); + const fabricatedId = Number(fabricatedResult); + const validStocks = await fetchStockRows(1); + + const result = await addDetail(check.id, [ validStocks[0].id, fabricatedId ]); + + assert.equal(result.added, 1, '仅有效商品入明细'); + assert.deepEqual(result.invalid_stock_ids, [ fabricatedId ], '无库存库位商品应计入 invalid_stock_ids'); + assert.equal(result.total_items, 1); + }); + + it('不存在的 stock_id 计入 invalid_stock_ids,不影响有效明细', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + const result = await addDetail(check.id, [ stocks[0].id, 999999999 ]); + + assert.equal(result.added, 1); + assert.deepEqual(result.invalid_stock_ids, [ 999999999 ]); + assert.equal(result.total_items, 1); + }); + + it('空 stock_ids 报 400', async () => { + const check = await createCheck(); + + await assert.rejects(async () => { + await addDetail(check.id, []); + }, error => error.code === 400); + }); + + it('submitted 状态不允许添加明细,报 400', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + + await assert.rejects(async () => { + await addDetail(check.id, [ stocks[0].id ]); + }, error => error.code === 400); + }); + }); + + // ------------------- addDetail:盘点范围类型分派(商品/库位维度互斥) ------------------- + + describe('addDetail 盘点范围类型分派', () => { + it('goods/store 类型传 locations 报 400(商品与库位维度互斥)', async () => { + const goodsCheck = await createCheck({ type: 'goods' }); + await assert.rejects(async () => { + await addDetailRaw({ id: goodsCheck.id, locations: [ TEST_LOCATION_CODE ] }); + }, error => error.code === 400 && /按商品盘点/.test(error.message)); + + const storeCheck = await createCheck({ type: 'store', storeId: TEST_STORE_ID }); + await assert.rejects(async () => { + await addDetailRaw({ id: storeCheck.id, locations: [ TEST_LOCATION_CODE ] }); + }, error => error.code === 400 && /按商品盘点/.test(error.message)); + }); + + it('location 类型传 stock_ids 报 400(库位与商品维度互斥)', async () => { + const stocks = await fetchStockRows(1); + + const locationCheck = await createCheck({ type: 'location' }); + await assert.rejects(async () => { + await addDetailRaw({ id: locationCheck.id, stockIds: [ stocks[0].id ] }); + }, error => error.code === 400 && /按库位盘点/.test(error.message)); + }); + + it('type=location 缺省 locations 自动生成全仓库启用库位明细(排除无头库位),重复添加全部幂等跳过', async () => { + const check = await createCheck({ type: 'location' }); + // 有效库位口径:启用且所属 zone 存在未删除(与业务排除无头库位口径一致) + const enabledSpaces = await ctx.model.LocationSpace.findAll({ + where: { warehouse_id: TEST_WAREHOUSE_ID, is_enabled: true }, + attributes: [ 'space_code' ], + include: [{ + model: ctx.model.LocationZone, + as: 'zone', + attributes: [], + required: true, + }], + order: [[ 'id', 'ASC' ]], + raw: true, + }); + const enabledCount = new Set(enabledSpaces + .map(row => String(row.space_code || '').trim()) + .filter(Boolean)).size; + assert.ok(enabledCount > 0, '固定测试仓库应存在启用库位'); + + const result = await addLocationDetail(check.id, undefined); + + assert.equal(result.added, enabledCount, '自动生成的明细数应等于全仓库启用库位数'); + assert.equal(result.skipped, 0); + assert.deepEqual(result.invalid_locations, []); + assert.deepEqual(result.invalid_stock_ids, []); + assert.equal(result.total_items, enabledCount); + + const rows = await ctx.model.StockCheckDetail.findAll({ + where: { check_id: check.id }, + order: [[ 'id', 'ASC' ]], + raw: true, + }); + assert.equal(rows.length, enabledCount); + for (const row of rows) { + assert.equal(row.scope_type, 'location', '全盘自动生成的明细应为库位行'); + assert.equal(row.stock_id, null, '库位行不应写商品 ID'); + assert.equal(row.item_code, null, '库位行不应写商品编码快照'); + assert.equal(Number(row.system_quantity), 0, '库位行账面快照固定为 0'); + assert.ok(row.location_code, '库位行应写库位编码'); + assert.ok(row.location_id, '库位行应写库位 ID'); + } + const testLocationRow = rows.find(row => row.location_code === TEST_LOCATION_CODE); + assert.ok(testLocationRow, '固定测试库位应包含在自动生成明细中'); + assert.equal(Number(testLocationRow.location_id), TEST_LOCATION_ID); + + // 幂等:再次缺省添加 → 全部跳过,不重复生成明细 + const again = await addLocationDetail(check.id, undefined); + assert.equal(again.added, 0); + assert.equal(again.skipped, enabledCount); + assert.equal(again.total_items, enabledCount); + }); + + it('历史遗留 type=all 任务拒绝添加明细:报 400(all 已下线,防御脏数据)', async () => { + const legacyCheck = await ctx.model.StockCheck.create({ + warehouse_id: TEST_WAREHOUSE_ID, + check_no: `DIA${Date.now()}`, + title: uniqueTitle('盘点单元测试-历史all任务'), + type: 'all', + mode: 'blind', + status: 'created', + detail_status: 'none_checked', + creator_id: TEST_CREATOR_ID, + creator_name: TEST_CREATOR_NAME, + }); + + await assert.rejects(async () => { + await addLocationDetail(legacyCheck.id, [ TEST_LOCATION_CODE ]); + }, error => error.code === 400 && /盘点范围类型不合法/.test(error.message)); + }); + + it('库位添加:有效编码落库 scope_type/location 字段、无效编码计入 invalid_locations、重复添加幂等跳过', async () => { + const check = await createCheck({ type: 'location' }); + + const first = await addLocationDetail(check.id, [ TEST_LOCATION_CODE, 'NOT_EXIST_SPACE_999' ]); + assert.equal(first.added, 1); + assert.equal(first.skipped, 0); + assert.deepEqual(first.invalid_locations, [ 'NOT_EXIST_SPACE_999' ], '未匹配编码应计入非法库位'); + assert.deepEqual(first.invalid_stock_ids, []); + assert.equal(first.total_items, 1); + + const rows = await ctx.model.StockCheckDetail.findAll({ + where: { check_id: check.id }, + raw: true, + }); + assert.equal(rows.length, 1, '非法库位不应落库'); + assert.equal(rows[0].scope_type, 'location'); + assert.equal(Number(rows[0].location_id), TEST_LOCATION_ID, '库位行应落库 location_id'); + assert.equal(rows[0].location_code, TEST_LOCATION_CODE, '库位行应落库 location_code'); + assert.equal(rows[0].stock_id, null); + assert.equal(rows[0].item_code, null); + assert.equal(Number(rows[0].system_quantity), 0); + + const second = await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); + assert.equal(second.added, 0); + assert.equal(second.skipped, 1, '同库位重复添加应幂等跳过'); + assert.equal(second.total_items, 1); + + const count = await ctx.model.StockCheckDetail.count({ + where: { check_id: check.id }, + }); + assert.equal(count, 1, '重复添加不应生成多余明细'); + }); + + it('无头库位(所属 zone 不存在)计入 invalid_locations 且不入库', async () => { + // fixture:造一个 zone 不存在的库位(zone_id 无外键约束,模拟无头库位) + const headless = await ctx.model.LocationSpace.create({ + warehouse_id: TEST_WAREHOUSE_ID, + zone_id: 999999999, + location_type_id: 1, + space_code: 'HDLS-TEST-001', + }); + try { + const check = await createCheck({ type: 'location' }); + const result = await addLocationDetail(check.id, [ TEST_LOCATION_CODE, 'HDLS-TEST-001' ]); + assert.equal(result.added, 1, '仅有效库位应入库'); + assert.deepEqual(result.invalid_locations, [ 'HDLS-TEST-001' ], '无头库位应计入 invalid_locations'); + assert.equal(result.total_items, 1); + + const rows = await ctx.model.StockCheckDetail.findAll({ where: { check_id: check.id }, raw: true }); + assert.equal(rows.length, 1, '无头库位不应落库'); + assert.equal(rows[0].location_code, TEST_LOCATION_CODE); + } finally { + await ctx.model.LocationSpace.destroy({ where: { id: headless.id }, force: true }); + } + }); + + it('按货主盘点:任务货主与商品货主不一致计入 invalid_stock_ids 且不入库', async () => { + const check = await createCheck({ type: 'store', storeId: TEST_STORE_ID }); + const stocks = await fetchStockRows(1); + const foreignStock = await fetchOtherStoreStockRow(); + assert.ok(foreignStock, '固定测试仓库应存在其他货主的商品(货主隔离校验依赖)'); + + const result = await addDetail(check.id, [ stocks[0].id, foreignStock.id ]); + + assert.equal(result.added, 1, '仅任务货主商品应入库'); + assert.deepEqual(result.invalid_stock_ids, [ Number(foreignStock.id) ], '其他货主商品应计入非法列表'); + assert.equal(result.total_items, 1); + + const rows = await ctx.model.StockCheckDetail.findAll({ + where: { check_id: check.id }, + raw: true, + }); + assert.equal(rows.length, 1, '其他货主商品不应生成明细'); + assert.equal(Number(rows[0].stock_id), stocks[0].id); + }); + }); + + // ------------------- addDetail:location_ids 库位ID直查(新增入参) ------------------- + + describe('addDetail location_ids 库位ID直查', () => { + it('type=location 传 location_ids:按 ID 直查落库 scope_type=location 行,invalid_location_ids=[]', async () => { + const check = await createCheck({ type: 'location' }); + + const result = await addDetailRaw({ id: check.id, locationIds: [ TEST_LOCATION_ID ] }); + + assert.equal(result.added, 1); + assert.equal(result.skipped, 0); + assert.deepEqual(result.invalid_location_ids, [], '有效库位ID不应计入非法列表'); + assert.deepEqual(result.invalid_locations, []); + assert.equal(result.total_items, 1); + + const rows = await ctx.model.StockCheckDetail.findAll({ + where: { check_id: check.id }, + raw: true, + }); + assert.equal(rows.length, 1); + assert.equal(rows[0].scope_type, 'location', '库位ID直查生成的明细应为库位行'); + assert.equal(Number(rows[0].location_id), TEST_LOCATION_ID, '库位行应落库 location_id'); + assert.equal(rows[0].location_code, TEST_LOCATION_CODE, '库位行应落库 location_code'); + assert.equal(rows[0].stock_id, null); + assert.equal(rows[0].item_code, null); + assert.equal(Number(rows[0].system_quantity), 0); + }); + + it('type=location 传 location_ids:只添加指定库位,不触发全盘自动生成', async () => { + const check = await createCheck({ type: 'location' }); + + const result = await addDetailRaw({ id: check.id, locationIds: [ TEST_LOCATION_ID ] }); + + assert.equal(result.added, 1); + assert.equal(result.skipped, 0); + assert.deepEqual(result.invalid_location_ids, []); + assert.equal(result.total_items, 1, '显式传库位ID时不应按全盘自动生成全部启用库位'); + + const rows = await ctx.model.StockCheckDetail.findAll({ + where: { check_id: check.id }, + raw: true, + }); + assert.equal(rows.length, 1); + assert.equal(Number(rows[0].location_id), TEST_LOCATION_ID); + assert.equal(rows[0].location_code, TEST_LOCATION_CODE); + }); + + it('location_ids 与 locations 同传:location_ids 优先,locations 忽略(无效编码不进 invalid_locations)', async () => { + const check = await createCheck({ type: 'location' }); + + const result = await addDetailRaw({ + id: check.id, + locations: [ 'NOT_EXIST_SPACE_999' ], + locationIds: [ TEST_LOCATION_ID ], + }); + + assert.equal(result.added, 1); + assert.equal(result.skipped, 0); + assert.deepEqual(result.invalid_location_ids, []); + assert.deepEqual(result.invalid_locations, [], 'locations 被忽略时不应解析编码,也不应计入非法库位'); + assert.equal(result.total_items, 1); + + const rows = await ctx.model.StockCheckDetail.findAll({ + where: { check_id: check.id }, + raw: true, + }); + assert.equal(rows.length, 1); + assert.equal(Number(rows[0].location_id), TEST_LOCATION_ID, '应按 location_ids 的库位 ID 落库'); + assert.equal(rows[0].location_code, TEST_LOCATION_CODE); + }); + + it('无效 location_id(不存在/其他仓库)计入 invalid_location_ids 且不入库', async () => { + const { Op } = ctx.app.Sequelize; + const check = await createCheck({ type: 'location' }); + + // 其他仓库的真实库位 ID:ID 存在但 warehouse_id 不属于当前仓库,应视为无效 + const foreignSpace = await ctx.model.LocationSpace.findOne({ + where: { warehouse_id: { [Op.ne]: TEST_WAREHOUSE_ID } }, + attributes: [ 'id', 'space_code' ], + order: [[ 'id', 'ASC' ]], + raw: true, + }); + assert.ok(foreignSpace, '本地库应存在其他仓库的库位(跨仓库隔离校验依赖)'); + const missingLocationId = await fetchMissingLocationId(); + + const result = await addDetailRaw({ + id: check.id, + locationIds: [ TEST_LOCATION_ID, missingLocationId, foreignSpace.id ], + }); + + assert.equal(result.added, 1); + assert.equal(result.skipped, 0); + assert.deepEqual( + result.invalid_location_ids, + [ missingLocationId, Number(foreignSpace.id) ], + '不存在与其他仓库的库位ID应按入参顺序计入非法列表' + ); + assert.equal(result.total_items, 1); + + const rows = await ctx.model.StockCheckDetail.findAll({ + where: { check_id: check.id }, + raw: true, + }); + assert.equal(rows.length, 1, '无效库位ID不应落库'); + assert.equal(Number(rows[0].location_id), TEST_LOCATION_ID); + }); + + it('无头库位 ID(zone 不存在)计入 invalid_location_ids 且不入库', async () => { + // fixture:造一个 zone 不存在的库位(zone_id 无外键约束,模拟无头库位) + const headless = await ctx.model.LocationSpace.create({ + warehouse_id: TEST_WAREHOUSE_ID, + zone_id: 999999999, + location_type_id: 1, + space_code: 'HDLS-TEST-002', + }); + try { + const check = await createCheck({ type: 'location' }); + const result = await addDetailRaw({ id: check.id, locationIds: [ TEST_LOCATION_ID, headless.id ] }); + assert.equal(result.added, 1, '仅有效库位应入库'); + assert.deepEqual(result.invalid_location_ids, [ Number(headless.id) ], '无头库位ID应计入非法列表'); + assert.equal(result.total_items, 1); + + const rows = await ctx.model.StockCheckDetail.findAll({ where: { check_id: check.id }, raw: true }); + assert.equal(rows.length, 1, '无头库位不应落库'); + assert.equal(Number(rows[0].location_id), TEST_LOCATION_ID); + } finally { + await ctx.model.LocationSpace.destroy({ where: { id: headless.id }, force: true }); + } + }); + + it('幂等:同次重复 ID 去重、重复传同一 location_id 跳过、编码路径已入库后 ID 路径也跳过', async () => { + const check = await createCheck({ type: 'location' }); + + const first = await addDetailRaw({ + id: check.id, + locationIds: [ TEST_LOCATION_ID, TEST_LOCATION_ID ], + }); + assert.equal(first.added, 1, '同次调用重复 ID 应去重只新增一次'); + assert.equal(first.skipped, 0); + assert.equal(first.total_items, 1); + + const second = await addDetailRaw({ id: check.id, locationIds: [ TEST_LOCATION_ID ] }); + assert.equal(second.added, 0); + assert.equal(second.skipped, 1, '重复传同一 location_id 应幂等跳过'); + assert.equal(second.total_items, 1); + + // 跨路径幂等(uk_check_location 口径):编码路径已入库,再按 ID 添加应跳过 + const anotherCheck = await createCheck({ type: 'location' }); + await addLocationDetail(anotherCheck.id, [ TEST_LOCATION_CODE ]); + const cross = await addDetailRaw({ id: anotherCheck.id, locationIds: [ TEST_LOCATION_ID ] }); + assert.equal(cross.added, 0, '编码路径已入库的库位,ID 路径应跳过'); + assert.equal(cross.skipped, 1); + assert.equal(cross.total_items, 1); + + const count = await ctx.model.StockCheckDetail.count({ where: { check_id: check.id } }); + assert.equal(count, 1, '重复添加不应生成多余明细'); + }); + + it('goods/store 类型传 location_ids 报 400(按商品盘点,不能添加库位明细)', async () => { + const goodsCheck = await createCheck({ type: 'goods' }); + await assert.rejects(async () => { + await addDetailRaw({ id: goodsCheck.id, locationIds: [ TEST_LOCATION_ID ] }); + }, error => error.code === 400 && /按商品盘点,不能添加库位明细/.test(error.message)); + + const storeCheck = await createCheck({ type: 'store', storeId: TEST_STORE_ID }); + await assert.rejects(async () => { + await addDetailRaw({ id: storeCheck.id, locationIds: [ TEST_LOCATION_ID ] }); + }, error => error.code === 400 && /按商品盘点,不能添加库位明细/.test(error.message)); + }); + + it('addLocationDetail 兼容入口:转调 addDetail 落库,返回结构不变(过滤 invalid_locations/invalid_stock_ids)', async () => { + const check = await createCheck({ type: 'location' }); + const missingLocationId = await fetchMissingLocationId(); + + const result = await addLocationDetailByIds(check.id, [ TEST_LOCATION_ID, missingLocationId ]); + + assert.deepEqual( + Object.keys(result).sort(), + [ 'added', 'invalid_location_ids', 'skipped', 'total_items' ].sort(), + '兼容入口返回结构应保持不变' + ); + assert.equal(result.added, 1); + assert.equal(result.skipped, 0); + assert.deepEqual(result.invalid_location_ids, [ missingLocationId ]); + assert.equal(result.total_items, 1); + + const rows = await ctx.model.StockCheckDetail.findAll({ + where: { check_id: check.id }, + raw: true, + }); + assert.equal(rows.length, 1, '无效库位ID不应落库'); + assert.equal(Number(rows[0].location_id), TEST_LOCATION_ID); + assert.equal(rows[0].location_code, TEST_LOCATION_CODE); + }); + + it('addLocationDetail 参数校验保持旧口径:空库位ID与超 200 上限报 400', async () => { + const check = await createCheck({ type: 'location' }); + + await assert.rejects(async () => { + await addLocationDetailByIds(check.id, []); + }, error => error.code === 400 && /至少选择一个库位/.test(error.message)); + + await assert.rejects(async () => { + await addLocationDetailByIds(check.id, undefined); + }, error => error.code === 400 && /至少选择一个库位/.test(error.message)); + + const overLimitIds = Array.from({ length: 201 }, (_, index) => index + 1); + await assert.rejects(async () => { + await addLocationDetailByIds(check.id, overLimitIds); + }, error => error.code === 400 && /200/.test(error.message)); + }); + }); + + // ------------------- detailDelete:删除盘点明细 ------------------- + + describe('detailDelete 删除盘点明细', () => { + it('created 状态删除 1 条明细(detailIds 单值自动转数组):deleted_count=1、total_items 重算、detail 中该 stock_id 消失', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + + const before = await detailCheck(check.id); + assert.equal(before.total, 2); + + const deletedDetail = before.rows[0]; + const keptDetail = before.rows[1]; + const result = await deleteDetail(check.id, deletedDetail.id); + + assert.equal(result.deleted_count, 1); + assert.deepEqual(result.deleted_ids.map(Number), [ Number(deletedDetail.id) ], '返回的明细 ID 应一致'); + assert.deepEqual(result.skipped_ids, [], '全部命中不应有跳过明细'); + assert.equal(result.total_items, 1, '删除后主表明细数应重算为 1'); + + const row = await findCheckRow(check.id); + assert.equal(row.total_items, 1, '主表 total_items 应同步重算'); + + const after = await detailCheck(check.id); + assert.equal(after.total, 1); + assert.ok( + !after.rows.some(item => Number(item.stock_id) === Number(deletedDetail.stock_id)), + '被删除明细的 stock_id 应从 detail 中消失' + ); + assert.ok( + after.rows.some(item => Number(item.stock_id) === Number(keptDetail.stock_id)), + '未删除明细应保留' + ); + }); + + it('批量删除 2 条明细:deleted_count=2、deleted_ids 保持入参顺序、total_items 减 2、DB 明细清空', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(3); + await addDetail(check.id, stocks.map(stock => stock.id)); + const details = await detailCheck(check.id); + assert.equal(details.total, 3, '前置:任务应有 3 条明细'); + + const targetIds = [ details.rows[0].id, details.rows[1].id ]; + const result = await deleteDetail(check.id, targetIds); + + assert.equal(result.deleted_count, 2); + assert.deepEqual(result.deleted_ids.map(Number), targetIds.map(Number), 'deleted_ids 应保持入参顺序'); + assert.deepEqual(result.skipped_ids, [], '全部命中不应有跳过明细'); + assert.equal(result.total_items, 1, '删除 2 条后主表明细数应重算为 1'); + assert.equal((await findCheckRow(check.id)).total_items, 1, '主表 total_items 应同步重算'); + + // DB 明细清空校验:被删 ID 消失、仅剩未删除的 1 条 + const remaining = await ctx.model.StockCheckDetail.findAll({ + where: { check_id: check.id }, + attributes: [ 'id' ], + raw: true, + }); + const remainingIds = remaining.map(row => Number(row.id)); + for (const targetId of targetIds) { + assert.ok(!remainingIds.includes(Number(targetId)), `被删明细 ${targetId} 应从 DB 消失`); + } + assert.deepEqual(remainingIds, [ Number(details.rows[2].id) ], '仅剩未删除的 1 条明细'); + }); + + it('混合删除:存在 + 不存在 ID 分流(deleted_ids/skipped_ids 均保持入参顺序)', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + const details = await detailCheck(check.id); + assert.equal(details.total, 2); + + const missingIdA = await findFreeDetailId(); + const missingIdB = missingIdA + 1; + const mixed = [ missingIdA, details.rows[0].id, missingIdB, details.rows[1].id ]; + const result = await deleteDetail(check.id, mixed); + + assert.equal(result.deleted_count, 2); + assert.deepEqual( + result.deleted_ids.map(Number), + [ Number(details.rows[0].id), Number(details.rows[1].id) ], + 'deleted_ids 应保持命中明细的入参顺序' + ); + assert.deepEqual( + result.skipped_ids.map(Number), + [ missingIdA, missingIdB ], + 'skipped_ids 应保持未命中明细的入参顺序' + ); + assert.equal(result.total_items, 0, '命中明细全部删除后主表明细数重算为 0'); + assert.equal( + await ctx.model.StockCheckDetail.count({ where: { check_id: check.id } }), + 0, + 'DB 明细应清空' + ); + }); + + it('detailIds 超过 200 条报 400(单次最多删除 200 条明细)', async () => { + const check = await createCheck(); + const tooManyIds = Array.from({ length: 201 }, (_, index) => index + 1); + await assert.rejects( + () => deleteDetailRaw({ id: check.id, detailIds: tooManyIds }), + error => error.code === 400 && /单次最多删除 200 条明细/.test(error.message) + ); + }); + + it('重复删除同一明细不报错:未命中计入 skipped_ids(deleted_count=0,不改变剩余明细)', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + + const details = await detailCheck(check.id); + await deleteDetail(check.id, details.rows[0].id); + + const result = await deleteDetail(check.id, details.rows[0].id); + assert.equal(result.deleted_count, 0, '重复删除不应命中'); + assert.deepEqual(result.deleted_ids, [], '重复删除不应有命中明细'); + assert.deepEqual( + result.skipped_ids.map(Number), + [ Number(details.rows[0].id) ], + '未命中明细应计入 skipped_ids' + ); + assert.equal(result.total_items, 1, '未命中删除不应改变剩余明细数'); + assert.equal((await findCheckRow(check.id)).total_items, 1, '主表 total_items 不应变化'); + }); + + it('submitted/approved/checking 状态删除明细报 400', async () => { + // submitted 状态 + const submittedCheck = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(submittedCheck.id, stocks.map(stock => stock.id)); + await submitCheck(submittedCheck.id); + const submittedDetails = await detailCheck(submittedCheck.id); + + await assert.rejects(async () => { + await deleteDetail(submittedCheck.id, submittedDetails.rows[0].id); + }, error => error.code === 400 && /不允许删除明细/.test(error.message)); + + // approved 状态 + const approvedCheck = await createCheck(); + const moreStocks = await fetchStockRows(2); + await addDetail(approvedCheck.id, moreStocks.map(stock => stock.id)); + await submitCheck(approvedCheck.id); + await auditCheck(approvedCheck.id, 'approve'); + const approvedDetails = await detailCheck(approvedCheck.id); + + await assert.rejects(async () => { + await deleteDetail(approvedCheck.id, approvedDetails.rows[0].id); + }, error => error.code === 400 && /不允许删除明细/.test(error.message)); + + // checking 状态(approved → 首次上报 → checking) + await reportCheck(approvedCheck.id, approvedDetails.rows[0].id, 0); + assert.equal((await findCheckRow(approvedCheck.id)).status, 'checking'); + await assert.rejects(async () => { + await deleteDetail(approvedCheck.id, approvedDetails.rows[0].id); + }, error => error.code === 400 && /不允许删除明细/.test(error.message)); + }); + + it('rejected 状态可删除明细(submit→audit reject 后删除成功)', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'reject', '明细商品有误,请重新盘点'); + assert.equal((await findCheckRow(check.id)).status, 'rejected'); + + const details = await detailCheck(check.id); + const result = await deleteDetail(check.id, details.rows[0].id); + + assert.equal(result.deleted_count, 1); + assert.deepEqual(result.deleted_ids.map(Number), [ Number(details.rows[0].id) ]); + assert.deepEqual(result.skipped_ids, []); + assert.equal(result.total_items, 1); + assert.equal((await findCheckRow(check.id)).total_items, 1, '主表 total_items 应同步重算'); + }); + + it('detailIds 缺失/全非法值或任务 id 非法报 400', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + + // detailIds 缺失 + await assert.rejects( + () => deleteDetailRaw({ id: check.id }), + error => error.code === 400 && /请至少选择一个明细/.test(error.message) + ); + + // detailIds 全非法值(归一化后为空):单值与数组形态均报 400 + for (const badDetailIds of [ null, '', 0, -1, 1.5, 'abc', [], [ 0, -1, 1.5, 'abc' ]]) { + await assert.rejects( + () => deleteDetailRaw({ id: check.id, detailIds: badDetailIds }), + error => error.code === 400 && /请至少选择一个明细/.test(error.message) + ); + } + + // 任务 id 非法 + await assert.rejects( + () => deleteDetailRaw({ id: 'abc', detailIds: [ 1 ] }), + error => error.code === 400 && /任务ID/.test(error.message) + ); + }); + + it('仓库隔离:其他仓库任务不可删除;跨仓库明细未命中计入 skipped_ids', async () => { + const otherWarehouseId = OTHER_TEST_WAREHOUSE_ID; + + // 其他仓库任务(直接造数,避免与单号生成器按仓库隔离序号、全局唯一索引的耦合): + // 本仓库视角任务不存在 + const otherCheck = await ctx.model.StockCheck.create({ + warehouse_id: otherWarehouseId, + check_no: `DIA${Date.now()}`, + title: uniqueTitle('盘点单元测试-仓库隔离'), + type: 'location', + mode: 'blind', + status: 'created', + detail_status: 'none_checked', + creator_id: TEST_CREATOR_ID, + creator_name: TEST_CREATOR_NAME, + }); + await assert.rejects(async () => { + await deleteDetail(otherCheck.id, 1); + }, error => error.code === 400 && /任务不存在/.test(error.message)); + + // 同任务下跨仓库明细:仓库隔离查询查不到 → 计入 skipped_ids(不报错) + // (uk_check_stock(check_id, stock_id) 唯一索引下跨仓库明细须使用不同商品,避免直接撞索引) + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, [ stocks[0].id ]); + const foreignDetail = await ctx.model.StockCheckDetail.create({ + check_id: check.id, + warehouse_id: otherWarehouseId, + stock_id: stocks[1].id, + item_code: 'FOREIGN-ISOLATION-ITEM', + item_name: '仓库隔离测试商品', + system_quantity: 1, + }); + const skippedResult = await deleteDetail(check.id, foreignDetail.id); + assert.equal(skippedResult.deleted_count, 0, '跨仓库明细不应命中删除'); + assert.deepEqual(skippedResult.deleted_ids, []); + assert.deepEqual( + skippedResult.skipped_ids.map(Number), + [ Number(foreignDetail.id) ], + '跨仓库明细应计入 skipped_ids' + ); + + // 未命中删除不改变本仓库明细 + const afterSkip = await detailCheck(check.id); + assert.equal(afterSkip.total, 1, '本仓库明细应保持未删除'); + + // 清理跨仓库明细,恢复任务数据形态后本仓库明细删除不受影响 + await ctx.model.StockCheckDetail.destroy({ where: { id: foreignDetail.id } }); + const details = await detailCheck(check.id); + const result = await deleteDetail(check.id, details.rows[0].id); + assert.equal(result.deleted_count, 1); + assert.deepEqual(result.deleted_ids.map(Number), [ Number(details.rows[0].id) ]); + assert.equal(result.total_items, 0, '本仓库明细删除后任务内无剩余明细'); + }); + + it('防御清理:明细存在作业记录时删除明细一并清除记录', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + const details = await detailCheck(check.id); + const targetDetail = details.rows[0]; + + // created 状态正常流程不会有作业记录,直接造数模拟防御清理场景 + await ctx.model.StockCheckRecord.create({ + check_id: check.id, + warehouse_id: TEST_WAREHOUSE_ID, + detail_id: targetDetail.id, + stock_id: targetDetail.stock_id, + location_code: 'DEFENSE-CLEAN-001', + quantity: 5, + checker_id: TEST_CREATOR_ID, + checker_name: TEST_CREATOR_NAME, + checked_at: new Date(), + }); + assert.equal( + (await queryRecords(check.id, targetDetail.id)).length, + 1, + '造数应写入一条作业记录' + ); + + const result = await deleteDetail(check.id, targetDetail.id); + + assert.equal(result.deleted_count, 1); + assert.deepEqual(result.deleted_ids.map(Number), [ Number(targetDetail.id) ]); + assert.deepEqual(result.skipped_ids, []); + assert.equal(result.total_items, 1, '删除明细后主表明细数重算为 1'); + assert.equal( + (await queryRecords(check.id, targetDetail.id)).length, + 0, + '该明细的作业记录应一并清除' + ); + assert.equal( + await ctx.model.StockCheckRecord.count({ where: { check_id: check.id } }), + 0, + '任务内不应残留作业记录' + ); + const after = await detailCheck(check.id); + assert.equal(after.total, 1, '仅剩 1 条未删除明细'); + }); + + it('防御清理(批量):带作业记录的 2 条明细批量删除后作业记录全部清空', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + const details = await detailCheck(check.id); + assert.equal(details.total, 2); + + // created 状态正常流程不会有作业记录,批量造数模拟防御清理场景 + for (const detail of details.rows) { + await ctx.model.StockCheckRecord.create({ + check_id: check.id, + warehouse_id: TEST_WAREHOUSE_ID, + detail_id: detail.id, + stock_id: detail.stock_id, + location_code: `DEFENSE-BATCH-${detail.id}`, + quantity: 5, + checker_id: TEST_CREATOR_ID, + checker_name: TEST_CREATOR_NAME, + checked_at: new Date(), + }); + } + assert.equal( + await ctx.model.StockCheckRecord.count({ where: { check_id: check.id } }), + 2, + '前置:应有 2 条作业记录' + ); + + const targetIds = details.rows.map(detail => detail.id); + const result = await deleteDetail(check.id, targetIds); + + assert.equal(result.deleted_count, 2); + assert.deepEqual(result.deleted_ids.map(Number), targetIds.map(Number)); + assert.deepEqual(result.skipped_ids, []); + assert.equal(result.total_items, 0, '批量删除后主表明细数重算为 0'); + assert.equal( + await ctx.model.StockCheckRecord.count({ where: { check_id: check.id } }), + 0, + '批量删除后任务内不应残留作业记录' + ); + assert.equal( + await ctx.model.StockCheckDetail.count({ where: { check_id: check.id } }), + 0, + '批量删除后 DB 明细应清空' + ); + }); + }); + + // ------------------- submit/cancel/audit:状态流转 ------------------- + + describe('submit/cancel/audit 状态流转', () => { + it('无明细不允许提交(400);有明细提交后置 submitted', async () => { + const check = await createCheck(); + + await assert.rejects(async () => { + await submitCheck(check.id); + }, error => error.code === 400); + + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + const result = await submitCheck(check.id); + + assert.equal(result.status, 'submitted'); + const row = await findCheckRow(check.id); + assert.equal(row.status, 'submitted'); + }); + + it('submitted 状态重复提交报 400', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + + await assert.rejects(async () => { + await submitCheck(check.id); + }, error => error.code === 400); + }); + + it('库位范围明细缺少库位(location_id/location_code 为空)不可提交', async () => { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); + + // 直写一条缺库位的脏数据明细(location_id/location_code 均为空) + await ctx.model.StockCheckDetail.create({ + check_id: check.id, + warehouse_id: TEST_WAREHOUSE_ID, + scope_type: 'location', + stock_id: null, + item_code: null, + item_name: null, + spec: null, + batch_no: null, + system_quantity: 0, + location_id: null, + location_code: '', + }); + + await assert.rejects(async () => { + await submitCheck(check.id); + }, error => error.code === 400 && /缺少库位的盘点明细/.test(error.message)); + + // 清除脏数据后正常提交 + await ctx.model.StockCheckDetail.destroy({ + where: { check_id: check.id, location_code: '' }, + }); + const result = await submitCheck(check.id); + assert.equal(result.status, 'submitted'); + }); + + it('created/submitted 状态可取消 → cancelled;cancelled 终态不可再取消', async () => { + const createdCheck = await createCheck(); + const cancelledFromCreated = await cancelCheck(createdCheck.id); + assert.equal(cancelledFromCreated.status, 'cancelled'); + + const submittedCheck = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(submittedCheck.id, [ stocks[0].id ]); + await submitCheck(submittedCheck.id); + const cancelledFromSubmitted = await cancelCheck(submittedCheck.id); + assert.equal(cancelledFromSubmitted.status, 'cancelled'); + + await assert.rejects(async () => { + await cancelCheck(submittedCheck.id); + }, error => error.code === 400); + }); + + it('audit approve → approved;approved 状态再次审核报 400', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + + const result = await auditCheck(check.id, 'approve'); + assert.equal(result.status, 'approved'); + assert.equal((await findCheckRow(check.id)).status, 'approved'); + + await assert.rejects(async () => { + await auditCheck(check.id, 'approve'); + }, error => error.code === 400); + }); + + it('audit reject → rejected 并写入驳回原因;驳回后可重新提交', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + + const rejected = await auditCheck(check.id, 'reject', '明细商品有误,请重新盘点'); + assert.equal(rejected.status, 'rejected'); + + const row = await findCheckRow(check.id); + assert.equal(row.status, 'rejected'); + assert.equal(row.remark, '明细商品有误,请重新盘点'); + + const resubmitted = await submitCheck(check.id); + assert.equal(resubmitted.status, 'submitted'); + }); + + it('非法审核动作或非 submitted 状态审核报 400', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + + await assert.rejects(async () => { + await auditCheck(check.id, 'bad_action'); + }, error => error.code === 400); + + const createdCheck = await createCheck(); + await assert.rejects(async () => { + await auditCheck(createdCheck.id, 'approve'); + }, error => error.code === 400); + }); + + it('商品任务提交审核刷新明细行账面快照(提交时点账面),主表不写额外快照', async () => { + const { literal } = ctx.app.Sequelize; + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + const details = await detailCheck(check.id); + assert.equal(details.rows.length, 1, '单库位商品应只有一条明细行'); + const detail = details.rows[0]; + const stockId = Number(detail.stock_id); + const spaceId = Number(detail.location_id); + + // 提交前账面(口径与实现一致:SUM 可用+锁定) + const bookRows = await ctx.model.Storage.findAll({ + where: { + warehouse_id: TEST_WAREHOUSE_ID, + stock_id: stockId, + space_id: spaceId, + is_enabled: 1, + }, + attributes: [ + [ literal('SUM(available_quantity + locked_quantity)'), 'totalQuantity' ], + ], + raw: true, + }); + const bookTotal = Number((bookRows[0] || {}).totalQuantity) || 0; + + // 模拟提交前库存变动:一条库存行可用数量 +100(finally 恢复) + const storageRow = await ctx.model.Storage.findOne({ + where: { + warehouse_id: TEST_WAREHOUSE_ID, + stock_id: stockId, + space_id: spaceId, + is_enabled: 1, + }, + raw: true, + }); + assert.ok(storageRow, '前置:应存在库存行'); + await ctx.model.Storage.update( + { available_quantity: Number(storageRow.available_quantity) + 100 }, + { where: { id: storageRow.id } } + ); + try { + await submitCheck(check.id); + + const row = await findCheckRow(check.id); + assert.equal(row.status, 'submitted'); + assert.equal(row.scope_snapshot, null, '主表不写额外快照(明细表已完整记录)'); + + const afterDetails = await detailCheck(check.id); + assert.equal( + Number(afterDetails.rows[0].system_quantity), + bookTotal + 100, + '明细行库位级账面快照应刷新为提交时账面' + ); + } finally { + await ctx.model.Storage.update( + { available_quantity: Number(storageRow.available_quantity) }, + { where: { id: storageRow.id } } + ); + } + }); + + it('库位范围任务提交不刷新商品账面快照(明细行 system_quantity 保持 0、主表 scope_snapshot 保持 null)', async () => { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); + + await submitCheck(check.id); + + const row = await findCheckRow(check.id); + assert.equal(row.status, 'submitted'); + assert.equal(row.scope_snapshot, null, '库位范围任务不写商品账面快照'); + + const details = await detailCheck(check.id); + assert.equal(Number(details.rows[0].system_quantity), 0, '库位明细行账面快照保持 0'); + }); + }); + + // ------------------- report:盘点作业上报 ------------------- + + describe('report 盘点作业上报', () => { + it('实盘数量为负数或非整数报 400', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detailId = details.rows[0].id; + + await assert.rejects(async () => { + await reportCheck(check.id, detailId, -1); + }, error => error.code === 400); + + await assert.rejects(async () => { + await reportCheck(check.id, detailId, 1.5); + }, error => error.code === 400); + }); + + it('report 写记录表:record 字段完整(check_id/warehouse_id/detail_id/stock_id/quantity/checker/checked_at)', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detail = details.rows[0]; + + const result = await reportCheck(check.id, detail.id, 7, TEST_LOCATION_CODE); + + assert.equal(Number(result.detail_id), Number(detail.id), '返回的明细 ID 应一致'); + assert.equal(result.total_items, 1); + assert.equal(result.checked_items, 1, '该明细存在记录应计入已盘'); + assert.equal(result.detail_status, 'all_checked'); + assert.ok(result.record, '应返回新增的作业记录'); + + assert.equal(Number(result.record.check_id), check.id, '记录应关联盘点任务'); + assert.equal(Number(result.record.warehouse_id), TEST_WAREHOUSE_ID, '记录应写入固定测试仓库'); + assert.equal(Number(result.record.detail_id), Number(detail.id), '记录应关联明细'); + assert.equal(Number(result.record.stock_id), Number(detail.stock_id), '记录应冗余商品库存 ID'); + assert.equal(Number(result.record.quantity), 7, '记录应写入实盘数量'); + assert.equal(Number(result.record.checker_id), TEST_CREATOR_ID, '记录应写入盘点人 ID'); + assert.equal(result.record.checker_name, TEST_CREATOR_NAME, '记录应写入盘点人名称'); + assert.ok(result.record.checked_at, '记录应写入上报时间'); + assert.equal(result.mode, 'created', '首次上报 mode 应为 created'); + + const records = await queryRecords(check.id, detail.id); + assert.equal(records.length, 1, '上报一次应写入一条作业记录'); + }); + + it('同一明细多库位多次上报:写入多条记录,明细已盘数量=合计,checked_items 只计一次', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const firstDetail = details.rows[0]; + const secondDetail = details.rows[1]; + + const firstReport = await reportCheck(check.id, firstDetail.id, 10, TEST_LOCATION_CODE); + const secondReport = await reportCheck(check.id, firstDetail.id, 5, TEST_EMPTY_LOCATION_CODE); + await reportCheck(check.id, secondDetail.id, 0); + assert.equal(firstReport.mode, 'created', '首次上报 mode 应为 created'); + assert.equal(secondReport.mode, 'created', '不同库位上报应新增记录'); + + const firstRecords = await queryRecords(check.id, firstDetail.id); + assert.equal(firstRecords.length, 2, '同一明细不同库位两次上报应写入两条作业记录'); + assert.equal(Number(firstRecords[0].quantity), 10); + assert.equal(Number(firstRecords[1].quantity), 5); + + const after = await resultCheck(check.id); + const firstRow = after.rows.find(row => Number(row.id) === Number(firstDetail.id)); + assert.equal(firstRow.checked_quantity, 15, '明细已盘数量应为多条记录合计'); + assert.equal(firstRow.status, 'checked'); + assert.deepEqual( + firstRow.location_codes, + [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ], + '多库位编码应合并' + ); + assert.equal(firstRow.records.length, 2, 'records 应包含该明细全部作业记录'); + + const row = await findCheckRow(check.id); + assert.equal(row.checked_items, 2, 'checked_items 按明细去重计数,不因多记录重复累计'); + assert.equal(row.detail_status, 'all_checked'); + }); + + it('盘盈/无差异场景:按明细聚合校验 diff_quantity/is_diff,汇总 diff_items 正确', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const firstDetail = details.rows[0]; + const secondDetail = details.rows[1]; + + const firstResult = await reportCheck( + check.id, + firstDetail.id, + Number(firstDetail.system_quantity) + 5 + ); + assert.equal(firstResult.checked_items, 1); + assert.equal(firstResult.detail_status, 'partial_checked', '部分已盘'); + + const afterFirst = await resultCheck(check.id); + const firstRow = afterFirst.rows.find(row => Number(row.id) === Number(firstDetail.id)); + assert.equal(firstRow.checked_quantity, Number(firstDetail.system_quantity) + 5); + assert.equal(firstRow.diff_quantity, 5, '盘盈 5'); + assert.equal(firstRow.is_diff, 1, '有差异应标记 is_diff=1'); + assert.equal(firstRow.status, 'checked'); + + const secondResult = await reportCheck( + check.id, + secondDetail.id, + Number(secondDetail.system_quantity) + ); + assert.equal(secondResult.checked_items, 2); + assert.equal(secondResult.diff_items, 1); + assert.equal(secondResult.detail_status, 'all_checked', '全部已盘'); + + const afterSecond = await resultCheck(check.id); + const secondRow = afterSecond.rows.find(row => Number(row.id) === Number(secondDetail.id)); + assert.equal(secondRow.diff_quantity, 0, '数量一致差异为 0'); + assert.equal(secondRow.is_diff, 0, '无差异应标记 is_diff=0'); + }); + + it('明细差异=已盘合计-账面快照(非单次上报数量)', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detail = details.rows[0]; + const snapshot = Number(detail.system_quantity); + + // 第一次上报数量=账面快照 → 单次差异 0 + await reportCheck(check.id, detail.id, snapshot, TEST_LOCATION_CODE); + const afterFirst = await resultCheck(check.id); + assert.equal(afterFirst.rows[0].checked_quantity, snapshot); + assert.equal(afterFirst.rows[0].diff_quantity, 0, '单次上报无差异'); + assert.equal(afterFirst.rows[0].is_diff, 0); + + // 第二次上报 5(另一库位)→ 已盘合计=账面+5,差异应按合计而非单次上报数量计算 + const secondResult = await reportCheck(check.id, detail.id, 5, TEST_EMPTY_LOCATION_CODE); + assert.equal(secondResult.diff_items, 1, '按合计计算应产生 1 条差异明细'); + + const afterSecond = await resultCheck(check.id); + assert.equal(afterSecond.rows[0].checked_quantity, snapshot + 5, '已盘数量应为账面+5'); + assert.equal(afterSecond.rows[0].diff_quantity, 5, '差异=已盘合计-账面快照'); + assert.equal(afterSecond.rows[0].is_diff, 1); + }); + + it('首次上报将主表 approved 自动转 checking 并写 start_time(≈首个明细写入时间)', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const beforeRow = await findCheckRow(check.id); + assert.equal(beforeRow.status, 'approved'); + assert.equal(beforeRow.start_time, null); + + const details = await detailCheck(check.id); + const beforeReport = Date.now(); + await reportCheck(check.id, details.rows[0].id, 0); + const afterReport = Date.now(); + + const afterRow = await findCheckRow(check.id); + assert.equal(afterRow.status, 'checking', '首次上报应自动转盘点作业中'); + assert.ok(afterRow.start_time, '应写入实际开始时间'); + const startTs = new Date(afterRow.start_time).getTime(); + assert.ok( + startTs >= beforeReport - 5000 && startTs <= afterReport + 5000, + 'start_time 应≈第一个盘点明细写入时间' + ); + }); + + it('space_id 必传:库位以 space_id 对应库位为准,编码不一致报 400', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const result = await reportCheck(check.id, details.rows[0].id, 3, TEST_LOCATION_CODE); + + assert.equal(result.record.location_code, TEST_LOCATION_CODE); + assert.equal(Number(result.record.location_id), TEST_LOCATION_ID, '库位编码命中应回填 location_id'); + + const records = await queryRecords(check.id, details.rows[0].id); + assert.equal(records.length, 1); + assert.equal(Number(records[0].location_id), TEST_LOCATION_ID, '记录表应持久化回填的 location_id'); + assert.equal(records[0].location_code, TEST_LOCATION_CODE); + + // 上报编码与 space_id 对应库位编码不一致 → 400(库位以 space_id 为准,不再按编码猜) + await assert.rejects(async () => { + await reportCheck(check.id, details.rows[0].id, 3, 'NOT_EXIST_SPACE_999', { spaceId: TEST_LOCATION_ID }); + }, error => error.code === 400 && error.message.includes('库位ID不一致')); + }); + + it('同仓库同编码存在多条库位时:上报沿用明细固化 location_id,space 视图不产生幽灵行', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detail = details.rows[0]; + const detailLocationId = Number(detail.location_id); + assert.ok(detailLocationId > 0, '前置:商品明细应带库位ID'); + const originSpace = await ctx.model.LocationSpace.findByPk(detailLocationId, { raw: true }); + assert.ok(originSpace, '前置:明细库位应存在'); + + // 构造同仓库同编码的历史重复库位(所属分区不存在,即无头库位) + let duplicateSpace = null; + try { + duplicateSpace = await ctx.model.LocationSpace.create({ + warehouse_id: TEST_WAREHOUSE_ID, + zone_id: 99999999, + location_type_id: Number(originSpace.location_type_id) || 1, + space_code: detail.location_code, + }); + assert.ok(Number(duplicateSpace.id) > 0, '前置:重复库位应创建成功'); + + // 上报库位与明细一致 → 沿用明细固化库位,不被同编码重复库位抢走 + const result = await reportCheck(check.id, detail.id, 5, detail.location_code); + assert.equal( + Number(result.record.location_id), + detailLocationId, + '同编码多条库位时应沿用明细固化 location_id' + ); + + // 模拟历史脏数据(记录被写成重复库位)→ space 视图应归并回有效库位,只出一行且带库位自定义字段 + await ctx.model.StockCheckRecord.update( + { location_id: Number(duplicateSpace.id) }, + { where: { check_id: check.id, detail_id: detail.id } } + ); + const data = await workDataCheck(check.id); + assert.equal(data.view, 'space'); + const rows = data.rows.filter(row => row.space_code === detail.location_code); + assert.equal(rows.length, 1, '同编码重复库位不应产生幽灵行'); + assert.equal(Number(rows[0].id), detailLocationId, '应归并到明细固化库位'); + assert.equal(rows[0].custom_name, originSpace.custom_name || null, '库位自定义名称应取有效库位行'); + const item = rows[0].goods.find(goods => Number(goods.stock_id) === Number(detail.stock_id)); + assert.ok(item, '归并后的库位行应包含该商品'); + assert.equal(Number(item.checked_quantity), 5, '实盘数量应继续落在有效库位行上'); + assert.equal(item.status, 'checked'); + } finally { + if (duplicateSpace) { + await ctx.model.LocationSpace.destroy({ where: { id: duplicateSpace.id }, force: true }); + } + } + }); + + it('space_id 必传且优先:直传库位ID按ID落库;缺失/编码不一致/跨仓库/分区已删除报 400', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detailId = details.rows[0].id; + + // 1) 只传 space_id(不传 location):编码由库位行反推,记录直接用该 ID + const first = await reportCheck(check.id, detailId, 4, undefined, { spaceId: TEST_LOCATION_ID }); + assert.equal(Number(first.record.location_id), TEST_LOCATION_ID, '直传 space_id 应原样落库'); + assert.equal(first.record.location_code, TEST_LOCATION_CODE, '库位编码应由库位行反推'); + + // 2) location 与 space_id 同时传且编码一致:通过 + const second = await reportCheck(check.id, detailId, 6, TEST_LOCATION_CODE, { spaceId: TEST_LOCATION_ID }); + assert.equal(Number(second.record.location_id), TEST_LOCATION_ID); + assert.equal(Number(second.record.quantity), 6); + + // 3) 编码与 ID 不一致:400 + await assert.rejects(async () => { + await reportCheck(check.id, detailId, 6, TEST_EMPTY_LOCATION_CODE, { spaceId: TEST_LOCATION_ID }); + }, error => error.code === 400 && error.message.includes('库位ID不一致')); + + // 4) 其他仓库的库位ID:400 + const otherWarehouseSpace = await ctx.model.LocationSpace.findOne({ + where: { warehouse_id: OTHER_TEST_WAREHOUSE_ID }, + attributes: [ 'id' ], + raw: true, + }); + if (otherWarehouseSpace) { + await assert.rejects(async () => { + await reportCheck(check.id, detailId, 6, undefined, { spaceId: Number(otherWarehouseSpace.id) }); + }, error => error.code === 400 && error.message.includes('上报库位不存在')); + } + + // 5) 无头库位(分区已删除)的ID:400 + let headlessSpace = null; + try { + headlessSpace = await ctx.model.LocationSpace.create({ + warehouse_id: TEST_WAREHOUSE_ID, + zone_id: 99999998, + location_type_id: 1, + space_code: `HD-${Date.now()}`, + }); + await assert.rejects(async () => { + await reportCheck(check.id, detailId, 6, undefined, { spaceId: Number(headlessSpace.id) }); + }, error => error.code === 400 && error.message.includes('上报库位不存在')); + } finally { + if (headlessSpace) { + await ctx.model.LocationSpace.destroy({ where: { id: headlessSpace.id }, force: true }); + } + } + + // 6) 缺失/非法值:400(不允许退回按编码猜库位) + for (const spaceId of [ null, '', 0, -5, 'abc' ]) { + await assert.rejects(async () => { + await reportCheck(check.id, detailId, 6, TEST_LOCATION_CODE, { spaceId }); + }, error => error.code === 400 && error.message.includes('缺少库位ID')); + } + // 完全不传 space_id(直接调业务层,绕过测试辅助的自动解析)同样 400 + await assert.rejects(async () => { + await ctx.service.systems.stockCheck.report({ + warehouseId: TEST_WAREHOUSE_ID, + id: check.id, + detailId, + quantity: 6, + location: TEST_LOCATION_CODE, + checkerId: TEST_CREATOR_ID, + checkerName: TEST_CREATOR_NAME, + }); + }, error => error.code === 400 && error.message.includes('缺少库位ID')); + }); + + it('实盘数量超上限报 400(不落库、不返回 500)', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detailId = details.rows[0].id; + + await assert.rejects(async () => { + await reportCheck(check.id, detailId, 6955416422066, TEST_LOCATION_CODE); + }, error => error.code === 400 && error.message.includes('实盘数量不能超过')); + + const records = await queryRecords(check.id, detailId); + assert.equal(records.length, 0, '超限上报不应落库'); + + // 边界值本身允许 + const boundary = await reportCheck(check.id, detailId, 2147483647, TEST_LOCATION_CODE); + assert.equal(Number(boundary.record.quantity), 2147483647); + }); + + it('上报写入操作日志:message 含库位编码/ID,before_changes 记录库位与明细库位快照', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detailId = details.rows[0].id; + await reportCheck(check.id, detailId, 3, TEST_LOCATION_CODE); + + const log = await ctx.model.OperationLog.findOne({ + where: { + business_type: 'stock_check', + business_id: String(check.id), + operation_code: 'STOCK_CHECK_REPORT', + }, + order: [[ 'id', 'DESC' ]], + raw: true, + }); + assert.ok(log, '应写入 STOCK_CHECK_REPORT 操作日志'); + assert.ok(log.message.includes(TEST_LOCATION_CODE), 'message 应包含库位编码'); + assert.ok(log.message.includes(`#${TEST_LOCATION_ID}`), 'message 应包含库位ID'); + assert.ok(log.before_changes, 'before_changes 应落库'); + const changes = typeof log.before_changes === 'string' + ? JSON.parse(log.before_changes) + : log.before_changes; + assert.equal(changes.detail_id, Number(detailId)); + assert.equal(changes.location_code, TEST_LOCATION_CODE); + assert.equal(changes.location_id, TEST_LOCATION_ID); + assert.equal(changes.quantity, 3); + assert.equal(changes.mode, 'created'); + }); + + it('非 approved/checking 状态上报报 400', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + + const details = await detailCheck(check.id); + await assert.rejects(async () => { + await reportCheck(check.id, details.rows[0].id, 1); + }, error => error.code === 400); + }); + + it('同明细同库位重复上报:记录仍 1 条、数量为最新值、mode=updated', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detailId = details.rows[0].id; + + const first = await reportCheck(check.id, detailId, 7, TEST_LOCATION_CODE); + assert.equal(first.mode, 'created', '首次上报 mode 应为 created'); + + const second = await reportCheck(check.id, detailId, 9, TEST_LOCATION_CODE); + assert.equal(second.mode, 'updated', '同库位重复上报 mode 应为 updated'); + assert.equal(Number(second.record.id), Number(first.record.id), '应更新同一条记录'); + assert.equal(Number(second.record.quantity), 9, '记录数量应为最新值'); + assert.equal(Number(second.record.checker_id), TEST_CREATOR_ID, '盘点人应更新为最新上报人'); + + const records = await queryRecords(check.id, detailId); + assert.equal(records.length, 1, '同明细同库位只保留一条记录'); + assert.equal(Number(records[0].quantity), 9, '库内记录数量应为最新值'); + assert.equal(records[0].location_code, TEST_LOCATION_CODE); + + const after = await resultCheck(check.id); + assert.equal(after.rows[0].checked_quantity, 9, '已盘数量应为最新值而非两次之和'); + assert.equal(after.rows[0].records.length, 1); + }); + + it('同明细跨库位:不同库位新增、同库位覆盖更新,已盘=各库位最新值合计', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detailId = details.rows[0].id; + + const created = await reportCheck(check.id, detailId, 10, TEST_LOCATION_CODE); + assert.equal(created.mode, 'created'); + const updated = await reportCheck(check.id, detailId, 12, TEST_LOCATION_CODE); + assert.equal(updated.mode, 'updated', '同库位重复上报应覆盖更新'); + const otherLocation = await reportCheck(check.id, detailId, 5, TEST_EMPTY_LOCATION_CODE); + assert.equal(otherLocation.mode, 'created', '不同库位应新增记录'); + + const records = await queryRecords(check.id, detailId); + assert.equal(records.length, 2, '两个库位各保留一条记录'); + const quantityByCode = new Map(records.map(record => [ record.location_code, Number(record.quantity) ])); + assert.equal(quantityByCode.get(TEST_LOCATION_CODE), 12, '同库位保留最新值'); + assert.equal(quantityByCode.get(TEST_EMPTY_LOCATION_CODE), 5); + + const after = await resultCheck(check.id); + assert.equal(after.rows[0].checked_quantity, 17, '已盘数量=各库位最新值合计'); + const row = await findCheckRow(check.id); + assert.equal(row.checked_items, 1, 'checked_items 按明细去重不重复累计'); + }); + + it('space_id 必传:未携带库位ID上报报 400;历史无库位记录(location_code=空串)仍可查询归一为 null', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detail = details.rows[0]; + const detailId = detail.id; + + // 1) 不传 space_id → 400(不再有"无库位上报"通道) + await assert.rejects(async () => { + await reportCheck(check.id, detailId, 8, undefined, { spaceId: 0 }); + }, error => error.code === 400 && error.message.includes('缺少库位ID')); + + // 2) 历史脏数据(location_code 空串)仍可查询:recordList 空串归一为 null + const legacy = await ctx.model.StockCheckRecord.create({ + check_id: check.id, + warehouse_id: TEST_WAREHOUSE_ID, + detail_id: detailId, + stock_id: Number(detail.stock_id), + location_id: null, + location_code: '', + quantity: 8, + is_empty: false, + checker_id: TEST_CREATOR_ID, + checker_name: TEST_CREATOR_NAME, + checked_at: new Date(), + }); + assert.ok(Number(legacy.id) > 0, '前置:历史无库位记录应写入成功'); + + const listed = await listRecords({ id: check.id, detailId }); + assert.equal(listed.total, 1); + assert.equal(listed.rows[0].location_code, null, '接口返回无库位记录 location_code 应为 null'); + }); + + it('唯一索引加固:同明细同库位连续上报 DB 记录总数恒为 1', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detailId = details.rows[0].id; + + // 同库位连续三次上报:覆盖式语义下 DB 只保留 1 条记录 + await reportCheck(check.id, detailId, 10, TEST_LOCATION_CODE); + await reportCheck(check.id, detailId, 11, TEST_LOCATION_CODE); + const last = await reportCheck(check.id, detailId, 12, TEST_LOCATION_CODE); + assert.equal(last.mode, 'updated', '第三次同库位上报应为覆盖更新'); + + // 另一库位再报一次:新增 1 条(共 2 条) + await reportCheck(check.id, detailId, 4, TEST_EMPTY_LOCATION_CODE); + + const records = await queryRecords(check.id, detailId); + assert.equal(records.length, 2, '两个库位各 1 条记录'); + + assert.equal( + await ctx.model.StockCheckRecord.count({ + where: { detail_id: detailId, location_code: TEST_LOCATION_CODE }, + }), + 1, + '同库位分组记录数恒为 1(唯一索引生效)' + ); + assert.equal( + await ctx.model.StockCheckRecord.count({ + where: { detail_id: detailId, location_code: null }, + }), + 0, + '库中不应存在 location_code 为 NULL 的记录' + ); + }); + + it('唯一索引 DB 层验证:重复 (detail_id, stock_id, location_code) 直接插入被拒绝', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detail = details.rows[0]; + + // 业务链路先写入一条有库位记录,再直接插入同组记录 → 触发唯一约束错误 + await reportCheck(check.id, detail.id, 7, TEST_LOCATION_CODE); + await assert.rejects(async () => { + await ctx.model.StockCheckRecord.create({ + check_id: check.id, + warehouse_id: TEST_WAREHOUSE_ID, + detail_id: detail.id, + stock_id: detail.stock_id, + location_id: TEST_LOCATION_ID, + location_code: TEST_LOCATION_CODE, + quantity: 99, + checker_id: TEST_CREATOR_ID, + checker_name: TEST_CREATOR_NAME, + checked_at: new Date(), + }); + }, error => error.name === 'SequelizeUniqueConstraintError'); + + // 历史无库位(空串)分组同样受唯一索引约束 + await ctx.model.StockCheckRecord.create({ + check_id: check.id, + warehouse_id: TEST_WAREHOUSE_ID, + detail_id: detail.id, + stock_id: detail.stock_id, + location_id: null, + location_code: '', + quantity: 3, + checker_id: TEST_CREATOR_ID, + checker_name: TEST_CREATOR_NAME, + checked_at: new Date(), + }); + await assert.rejects(async () => { + await ctx.model.StockCheckRecord.create({ + check_id: check.id, + warehouse_id: TEST_WAREHOUSE_ID, + detail_id: detail.id, + stock_id: detail.stock_id, + location_id: null, + location_code: '', + quantity: 88, + checker_id: TEST_CREATOR_ID, + checker_name: TEST_CREATOR_NAME, + checked_at: new Date(), + }); + }, error => error.name === 'SequelizeUniqueConstraintError'); + + const records = await queryRecords(check.id, detail.id); + assert.equal(records.length, 2, '被唯一索引拒绝的插入不应落库'); + }); + }); + + // ------------------- report:库位行与商品行 stock_id 维度校验 ------------------- + + describe('report 库位行与商品行 stock_id 维度校验', () => { + it('库位行缺 stock_id 报 400', async () => { + const { check, detail } = await createApprovedLocationCheck(); + + await assert.rejects(async () => { + await reportCheck(check.id, detail.id, 1); + }, error => error.code === 400 && /必须指定商品/.test(error.message)); + }); + + it('库位行商品非本仓库报 400', async () => { + const { check, detail } = await createApprovedLocationCheck(); + const foreignStock = await fetchOtherWarehouseStockRow(); + assert.ok(foreignStock, '应存在其他仓库商品用于跨仓库隔离校验'); + + await assert.rejects(async () => { + await reportCheck(check.id, detail.id, 1, undefined, { stockId: foreignStock.id }); + }, error => error.code === 400 && /不属于本仓库/.test(error.message)); + }); + + it('库位行上报库位与明细库位不一致报 400', async () => { + const { check, detail } = await createApprovedLocationCheck(); + const stocks = await fetchStockRows(1); + const otherSpace = await ctx.model.LocationSpace.findOne({ + where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: TEST_EMPTY_LOCATION_CODE }, + attributes: [ 'id' ], + raw: true, + }); + assert.ok(otherSpace, '前置:另一有效库位应存在'); + + await assert.rejects(async () => { + await reportCheck(check.id, detail.id, 1, TEST_EMPTY_LOCATION_CODE, { + stockId: stocks[0].id, + spaceId: Number(otherSpace.id), + }); + }, error => error.code === 400 && /库位与盘点明细库位不一致/.test(error.message)); + }); + + it('库位行正常上报:record 含 stock_id、库位以明细为准,覆盖式按 (detail,stock,location) 更新', async () => { + const { check, detail } = await createApprovedLocationCheck(); + const stocks = await fetchStockRows(1); + const stockId = stocks[0].id; + + const first = await reportCheck(check.id, detail.id, 5, TEST_LOCATION_CODE, { stockId }); + assert.equal(first.mode, 'created'); + assert.equal(Number(first.record.stock_id), stockId, '记录应写入上报商品 ID'); + assert.equal(first.record.location_code, TEST_LOCATION_CODE, '库位应以明细库位为准'); + assert.equal(Number(first.record.location_id), TEST_LOCATION_ID, '库位 ID 应取明细库位'); + assert.equal(first.checked_items, 1); + assert.equal(first.detail_status, 'all_checked'); + + // 同明细 + 同商品 + 同库位(未传库位同样以明细库位为准)→ 覆盖更新 + const second = await reportCheck(check.id, detail.id, 9, undefined, { stockId }); + assert.equal(second.mode, 'updated', '同 (detail,stock,location) 应覆盖更新'); + assert.equal(Number(second.record.id), Number(first.record.id), '应更新同一条记录'); + + const records = await queryRecords(check.id, detail.id); + assert.equal(records.length, 1); + assert.equal(Number(records[0].quantity), 9); + assert.equal(Number(records[0].stock_id), stockId); + }); + + it('商品行上报 stock_id 与明细商品不一致报 400', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + await assert.rejects(async () => { + await reportCheck(check.id, details.rows[0].id, 1, undefined, { stockId: stocks[1].id }); + }, error => error.code === 400 && /上报商品与盘点明细商品不一致/.test(error.message)); + }); + + it('同库位行多商品上报:记录按 (detail,stock,location) 各自落库,不撞唯一索引', async () => { + const { check, detail } = await createApprovedLocationCheck(); + const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 2); + assert.ok(stockIds.length >= 2, '固定测试库位应存在至少两个商品库存(真实数据依赖)'); + + const first = await reportCheck(check.id, detail.id, 3, undefined, { stockId: stockIds[0] }); + assert.equal(first.mode, 'created'); + const second = await reportCheck(check.id, detail.id, 4, undefined, { stockId: stockIds[1] }); + assert.equal(second.mode, 'created', '不同商品应新增记录而非覆盖'); + + const records = await queryRecords(check.id, detail.id); + assert.equal(records.length, 2, '同库位行多商品应各保留一条记录(uk_detail_stock_location 生效)'); + for (const record of records) { + assert.equal(record.location_code, TEST_LOCATION_CODE); + } + + // 覆盖式:同商品再报更新原记录,记录数不变 + const updated = await reportCheck(check.id, detail.id, 7, undefined, { stockId: stockIds[0] }); + assert.equal(updated.mode, 'updated'); + const after = await queryRecords(check.id, detail.id); + assert.equal(after.length, 2, '覆盖更新后记录数不变'); + const updatedRecord = after.find(record => Number(record.stock_id) === stockIds[0]); + assert.equal(Number(updatedRecord.quantity), 7); + }); + }); + + // ------------------- recordDelete:删除作业记录 ------------------- + + describe('recordDelete 删除作业记录', () => { + it('删除后汇总回退:明细回到未盘、detail_status=未盘,主表状态不回退', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + await reportCheck(check.id, details.rows[0].id, 5, TEST_LOCATION_CODE); + const beforeRow = await findCheckRow(check.id); + assert.equal(beforeRow.status, 'checking'); + assert.equal(beforeRow.checked_items, 1); + + const records = await queryRecords(check.id, details.rows[0].id); + assert.equal(records.length, 1); + + const result = await deleteRecord(check.id, records[0].id); + + assert.equal(result.deleted_count, 1, '应标记删除 1 条'); + assert.deepEqual(result.deleted_ids.map(Number), [ Number(records[0].id) ]); + assert.deepEqual(result.skipped_ids, []); + assert.equal(result.total_items, 2); + assert.equal(result.checked_items, 0, '删除后已盘明细回退为 0'); + assert.equal(result.diff_items, 0); + assert.equal(result.detail_status, 'none_checked', '明细记录删光回到未盘'); + + const remaining = await queryRecords(check.id, details.rows[0].id); + assert.equal(remaining.length, 0, '记录应被删除'); + + const afterRow = await findCheckRow(check.id); + assert.equal(afterRow.status, 'checking', '主表状态不回退'); + assert.equal(afterRow.checked_items, 0); + assert.equal(afterRow.detail_status, 'none_checked'); + + const after = await resultCheck(check.id); + const targetRow = after.rows.find(row => Number(row.id) === Number(details.rows[0].id)); + assert.ok(targetRow, '记录删光后应返回明细范围行'); + assert.equal(targetRow.scope_type, 'goods'); + assert.ok(Number(targetRow.system_quantity) >= 0, '明细行应含账面快照'); + }); + + it('非 approved/checking 状态删除报 400', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + + await assert.rejects(async () => { + await deleteRecord(check.id, 999999999); + }, error => error.code === 400); + }); + + it('作业记录不属于该盘点任务计入 skipped_ids 不报错(批量口径)', async () => { + const checkA = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(checkA.id, [ stocks[0].id ]); + await submitCheck(checkA.id); + await auditCheck(checkA.id, 'approve'); + const detailsA = await detailCheck(checkA.id); + const reportResult = await reportCheck(checkA.id, detailsA.rows[0].id, 3, TEST_LOCATION_CODE); + + const checkB = await createCheck(); + await addDetail(checkB.id, [ stocks[0].id ]); + await submitCheck(checkB.id); + await auditCheck(checkB.id, 'approve'); + + const result = await ctx.service.systems.stockCheck.recordDelete({ + warehouseId: TEST_WAREHOUSE_ID, + id: checkB.id, + recordIds: [ reportResult.record.id ], + }); + assert.equal(result.deleted_count, 0); + assert.deepEqual(result.deleted_ids, []); + assert.deepEqual(result.skipped_ids.map(Number), [ Number(reportResult.record.id) ], '不属于该任务的记录应计入 skipped_ids'); + }); + }); + + // ------------------- recheckClearLocation:重盘清除库位 ------------------- + + describe('recheckClearLocation 重盘清除库位(按库位清除盘点信息)', () => { + it('清除库位记录:记录清空、汇总回退、库位回到未盘(含空库位标记一并清除)', async () => { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detailId = details.rows[0].id; + const stocks = await fetchStorageStockIds(TEST_LOCATION_ID, 1); + await reportCheck(check.id, detailId, 5, undefined, { stockId: stocks[0] }); + // 覆盖为空标记 + await reportCheck(check.id, detailId, 0, undefined, { is_empty: true }); + assert.equal((await queryRecords(check.id, detailId)).length, 1, '前置:空标记记录存在'); + + const result = await ctx.service.systems.stockCheck.recheckClearLocation({ + warehouseId: TEST_WAREHOUSE_ID, + id: check.id, + locationId: TEST_LOCATION_ID, + }); + + assert.equal(Number(result.detail_id), Number(detailId)); + assert.equal(result.location_id, TEST_LOCATION_ID); + assert.equal(result.deleted_count, 1, '应清除该库位全部记录(含空标记)'); + assert.equal(result.checked_items, 0, '清除后已盘回退为 0'); + assert.equal(result.detail_status, 'none_checked'); + + assert.equal((await queryRecords(check.id, detailId)).length, 0, '记录应被清空'); + const data = await workDataCheck(check.id); + const row = data.rows[0]; + assert.equal(row.status, 'unchecked', '库位回到未盘'); + assert.equal(row.is_empty, false, '空标记一并清除'); + assert.deepEqual(row.goods, []); + }); + + it('非库位任务(商品任务)→ 400 仅库位盘点任务支持重盘清除库位', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + await assert.rejects(async () => { + await ctx.service.systems.stockCheck.recheckClearLocation({ + warehouseId: TEST_WAREHOUSE_ID, + id: check.id, + locationId: TEST_LOCATION_ID, + }); + }, error => error.code === 400 && /仅库位盘点任务支持重盘清除库位/.test(error.message)); + }); + + it('库位不在任务范围 → 400 该库位不在盘点任务范围内', async () => { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_EMPTY_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + await assert.rejects(async () => { + await ctx.service.systems.stockCheck.recheckClearLocation({ + warehouseId: TEST_WAREHOUSE_ID, + id: check.id, + locationId: TEST_LOCATION_ID, + }); + }, error => error.code === 400 && /该库位不在盘点任务范围内/.test(error.message)); + }); + + it('状态不允许(created)→ 400 当前状态不允许清除库位盘点信息', async () => { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); + + await assert.rejects(async () => { + await ctx.service.systems.stockCheck.recheckClearLocation({ + warehouseId: TEST_WAREHOUSE_ID, + id: check.id, + locationId: TEST_LOCATION_ID, + }); + }, error => error.code === 400 && /不允许清除库位盘点信息/.test(error.message)); + }); + + it('方法层:location_id/locationId 兼容 + success 包装 + 非库位任务 failure 400', async () => { + ctx.user = { id: TEST_CREATOR_ID, store_id: TEST_WAREHOUSE_ID, employees_name: TEST_CREATOR_NAME }; + + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_EMPTY_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const emptySpace = await ctx.model.LocationSpace.findOne({ + where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: TEST_EMPTY_LOCATION_CODE }, + attributes: [ 'id' ], + raw: true, + }); + const emptyLocationId = Number(emptySpace.id); + + const result = await ctx.service.systemMethods.stock.check.recheckClearLocation({ + id: check.id, + location_id: emptyLocationId, + }); + assert.equal(result.flag, 'success'); + assert.equal(result.code, 1); + assert.equal(result.data.deleted_count, 0, '未盘库位清除记录数应为 0'); + assert.equal(result.data.location_id, emptyLocationId); + + const goodsCheck = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(goodsCheck.id, [ stocks[0].id ]); + await submitCheck(goodsCheck.id); + await auditCheck(goodsCheck.id, 'approve'); + const failure = await ctx.service.systemMethods.stock.check.recheckClearLocation({ + id: goodsCheck.id, + locationId: TEST_LOCATION_ID, + }); + assert.equal(failure.flag, 'failure'); + assert.equal(failure.code, 400); + assert.match(failure.message, /仅库位盘点任务支持重盘清除库位/); + }); + }); + + // ------------------- recordList:查询作业记录 ------------------- + + describe('recordList 查询作业记录', () => { + it('按任务查询:返回全字段+item_code/item_name,按 id 倒序', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + await reportCheck(check.id, details.rows[0].id, 3, TEST_LOCATION_CODE); + await reportCheck(check.id, details.rows[1].id, 4); + + const result = await listRecords({ id: check.id }); + + assert.equal(result.total, 2); + assert.equal(result.rows.length, 2); + assert.equal(result.page, 1); + assert.equal(result.pageSize, 20); + assert.ok(Number(result.rows[0].id) > Number(result.rows[1].id), '应按记录 id 倒序'); + for (const row of result.rows) { + assert.equal(Number(row.check_id), check.id, '记录应关联盘点任务'); + assert.equal(Number(row.warehouse_id), TEST_WAREHOUSE_ID, '记录应限定固定测试仓库'); + assert.ok(row.detail_id, '记录应含明细 ID'); + assert.ok(row.stock_id, '记录应含库存商品 ID'); + assert.ok(row.checked_at, '记录应含上报时间'); + assert.ok(row.item_code, '记录应回填商品编码'); + assert.ok(row.item_name, '记录应回填商品名称'); + } + }); + + it('按明细查询:仅返回该明细的记录,仅传 detail_id 也可查', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const firstDetail = details.rows[0]; + await reportCheck(check.id, firstDetail.id, 3, TEST_LOCATION_CODE); + await reportCheck(check.id, details.rows[1].id, 4); + + const byTaskAndDetail = await listRecords({ id: check.id, detailId: firstDetail.id }); + assert.equal(byTaskAndDetail.total, 1, '只返回该明细的记录'); + assert.equal(Number(byTaskAndDetail.rows[0].detail_id), Number(firstDetail.id)); + assert.equal(Number(byTaskAndDetail.rows[0].quantity), 3); + assert.equal(byTaskAndDetail.rows[0].item_code, firstDetail.item_code); + + const byDetailOnly = await listRecords({ detailId: firstDetail.id }); + assert.equal(byDetailOnly.total, 1, '仅传 detail_id 应可查询'); + assert.equal(Number(byDetailOnly.rows[0].detail_id), Number(firstDetail.id)); + }); + + it('分页:total 为全量,按页返回且两页无交集', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detailId = details.rows[0].id; + const reportLocations = await fetchValidLocations(3); + assert.equal(reportLocations.length, 3, '前置:测试仓库应有 3 个有效库位'); + await reportCheck(check.id, detailId, 1, reportLocations[0].space_code, { spaceId: reportLocations[0].id }); + await reportCheck(check.id, detailId, 2, reportLocations[1].space_code, { spaceId: reportLocations[1].id }); + await reportCheck(check.id, detailId, 3, reportLocations[2].space_code, { spaceId: reportLocations[2].id }); + + const firstPage = await listRecords({ + id: check.id, + pagination: { page: 1, pageSize: 2 }, + }); + assert.equal(firstPage.total, 3); + assert.equal(firstPage.rows.length, 2); + assert.equal(firstPage.page, 1); + assert.equal(firstPage.pageSize, 2); + + const secondPage = await listRecords({ + id: check.id, + pagination: { page: 2, pageSize: 2 }, + }); + assert.equal(secondPage.total, 3); + assert.equal(secondPage.rows.length, 1); + + const firstPageIds = firstPage.rows.map(row => Number(row.id)); + const secondPageIds = secondPage.rows.map(row => Number(row.id)); + for (const firstId of firstPageIds) { + assert.ok(!secondPageIds.includes(firstId), '两页记录不应重复'); + for (const secondId of secondPageIds) { + assert.ok(firstId > secondId, '倒序分页:第一页记录 id 应大于第二页'); + } + } + }); + + it('id 与 detail_id 均未传报 400', async () => { + await assert.rejects(async () => { + await listRecords({}); + }, error => error.code === 400); + }); + }); + + // ------------------- finish:完成盘点 ------------------- + + describe('finish 完成盘点', () => { + it('存在未盘明细不再拦截:未盘按实盘 0 计盘亏,返回 unchecked_items', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const checkedDetail = details.rows[0]; + const uncheckedDetail = details.rows[1]; + await reportCheck(check.id, checkedDetail.id, Number(checkedDetail.system_quantity) + 2); + + const result = await finishCheck(check.id); + + assert.equal(result.status, 'completed'); + assert.equal(result.total_items, 2); + assert.equal(result.checked_items, 1); + assert.equal(result.unchecked_items, 1, '未盘明细数应为 1'); + assert.equal(result.profit_total, 2, '已盘明细盘盈 2'); + assert.equal( + result.loss_total, + Number(uncheckedDetail.system_quantity), + '未盘明细按实盘 0 处理,盘亏=账面快照' + ); + assert.equal(result.diff_items, 2, '盘盈 1 条 + 未盘盘亏 1 条'); + + const row = await findCheckRow(check.id); + assert.equal(row.status, 'completed'); + assert.equal(row.detail_status, 'all_checked'); + assert.equal(row.checked_items, 1); + assert.equal(row.diff_items, 2); + assert.ok(row.end_time, '完成盘点应写入 end_time'); + }); + + it('全部已盘 → completed + end_time,盘盈盘亏汇总正确', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const firstDetail = details.rows[0]; + const secondDetail = details.rows[1]; + await reportCheck(check.id, firstDetail.id, Number(firstDetail.system_quantity) + 5); + await reportCheck(check.id, secondDetail.id, Number(secondDetail.system_quantity) - 3); + + const beforeFinish = Date.now(); + const result = await finishCheck(check.id); + const afterFinish = Date.now(); + + assert.equal(result.status, 'completed'); + assert.equal(result.total_items, 2); + assert.equal(result.checked_items, 2); + assert.equal(result.diff_items, 2); + assert.equal(result.unchecked_items, 0, '全部已盘时未盘明细数应为 0'); + assert.equal(result.profit_total, 5, '盘盈合计应为 5'); + assert.equal(result.loss_total, 3, '盘亏合计应为 3'); + + const row = await findCheckRow(check.id); + assert.equal(row.status, 'completed'); + assert.equal(row.detail_status, 'all_checked'); + assert.ok(row.end_time, '完成盘点应写入 end_time'); + const endTs = new Date(row.end_time).getTime(); + assert.ok( + endTs >= beforeFinish - 5000 && endTs <= afterFinish + 5000, + 'end_time 应≈完成盘点时间' + ); + }); + }); + + // ------------------- 汇总/差异:库位行口径 ------------------- + + describe('汇总/差异 库位行口径', () => { + it('库位行差异口径:任一商品实盘≠账面即该行有差异,diff_items 按明细去重', async () => { + const { check, detail } = await createApprovedLocationCheck(); + const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 2); + assert.ok(stockIds.length >= 2, '固定测试库位应存在至少两个商品库存(真实数据依赖)'); + const bookMap = await fetchStorageQuantity(TEST_LOCATION_ID, stockIds); + const bookA = Number(bookMap.get(stockIds[0]) || 0); + + // 实盘=账面 → 无差异 + const first = await reportCheck(check.id, detail.id, bookA, undefined, { stockId: stockIds[0] }); + assert.equal(first.diff_items, 0, '实盘=账面应无差异'); + assert.equal(first.detail_status, 'all_checked'); + + // 实盘=账面+3 → 该行有差异(行内任一商品差异即整行差异) + const second = await reportCheck(check.id, detail.id, bookA + 3, undefined, { stockId: stockIds[0] }); + assert.equal(second.diff_items, 1); + assert.equal(second.checked_items, 1, 'checked_items 按明细去重不重复累计'); + + const result = await resultCheck(check.id); + const row = result.rows[0]; + assert.equal(row.is_diff, 1); + assert.equal(row.stocks[0].diff_quantity, 3); + }); + + it('finish 库位行按商品聚合 vs wms_storage 计算盘盈盘亏,未盘库位行不计差异', async () => { + const check = await createCheck({ type: 'location' }); + const emptySpace = await ctx.model.LocationSpace.findOne({ + where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: TEST_EMPTY_LOCATION_CODE }, + raw: true, + }); + assert.ok(emptySpace, `空库位编码不存在(${TEST_EMPTY_LOCATION_CODE})`); + assert.equal( + await ctx.model.Storage.count({ where: { space_id: Number(emptySpace.id) } }), + 0, + '测试用空库位应无库存记录' + ); + + await addLocationDetail(check.id, [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 2); + assert.ok(stockIds.length >= 2, '固定测试库位应存在至少两个商品库存(真实数据依赖)'); + const bookMap = await fetchStorageQuantity(TEST_LOCATION_ID, stockIds); + const bookA = Number(bookMap.get(stockIds[0]) || 0); + const bookB = Number(bookMap.get(stockIds[1]) || 0); + assert.ok(bookB >= 2, '库位行盘亏用例要求第二商品账面≥2(真实数据不满足时需调整固定库位)'); + + const details = await detailCheck(check.id); + const checkedDetail = details.rows.find(row => row.location_code === TEST_LOCATION_CODE); + await reportCheck(check.id, checkedDetail.id, bookA + 5, undefined, { stockId: stockIds[0] }); + await reportCheck(check.id, checkedDetail.id, bookB - 2, undefined, { stockId: stockIds[1] }); + + const result = await finishCheck(check.id); + + assert.equal(result.status, 'completed'); + assert.equal(result.total_items, 2); + assert.equal(result.checked_items, 1, '仅固定测试库位行已盘'); + assert.equal(result.unchecked_items, 1, '未盘空库位行计入未盘'); + assert.equal(result.diff_items, 1, '库位行差异按明细去重计数'); + assert.equal(result.profit_total, 5, '盘盈合计=商品A +5'); + assert.equal(result.loss_total, 2, '盘亏合计=商品B -2'); + + const row = await findCheckRow(check.id); + assert.equal(row.status, 'completed'); + assert.equal(row.diff_items, 1); + assert.ok(row.end_time, '完成盘点应写入 end_time'); + }); + }); + + // ------------------- list:列表查询 ------------------- + + describe('list 列表查询', () => { + it('status 单值筛选:仅返回指定状态的任务', async () => { + const createdCheck = await createCheck(); + const submittedCheck = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(submittedCheck.id, [ stocks[0].id ]); + await submitCheck(submittedCheck.id); + + const result = await listChecks({ status: 'submitted' }); + + assert.ok(Array.isArray(result.rows)); + assert.ok(result.rows.length > 0); + for (const row of result.rows) { + assert.equal(row.status, 'submitted', '筛选结果只能包含 submitted 状态'); + } + const ids = result.rows.map(row => row.id); + assert.ok(ids.includes(submittedCheck.id), '应包含本次提交的任务'); + assert.ok(!ids.includes(createdCheck.id), 'created 任务不应出现在 submitted 筛选结果中'); + }); + + it('status 数组筛选:created/submitted 均可命中', async () => { + const createdCheck = await createCheck(); + const submittedCheck = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(submittedCheck.id, [ stocks[0].id ]); + await submitCheck(submittedCheck.id); + + const result = await listChecks({ status: [ 'created', 'submitted' ] }); + const ids = result.rows.map(row => row.id); + + assert.ok(ids.includes(createdCheck.id), 'created 任务应命中数组筛选'); + assert.ok(ids.includes(submittedCheck.id), 'submitted 任务应命中数组筛选'); + for (const row of result.rows) { + assert.ok([ 'created', 'submitted' ].includes(row.status), `非法状态出现在筛选结果: ${row.status}`); + } + }); + + it('store_id 货主筛选:只返回固定测试货主的任务', async () => { + const storeCheck = await createCheck({ + type: 'store', + storeId: TEST_STORE_ID, + title: uniqueTitle('货主筛选'), + }); + + const result = await listChecks({ storeId: TEST_STORE_ID }); + const ids = result.rows.map(row => row.id); + + assert.ok(ids.includes(storeCheck.id), '固定测试货主的任务应命中筛选'); + for (const row of result.rows) { + assert.equal(Number(row.store_id), TEST_STORE_ID, '筛选结果只能包含固定测试货主'); + } + }); + + it('list 返回 store_name:store 类型任务(store_id=1000000)取合约备注,无合约回退公司全称', async () => { + const storeCheck = await createCheck({ + type: 'store', + storeId: TEST_STORE_ID, + title: uniqueTitle('store_name合约备注'), + }); + + const result = await listChecks({ keyword: storeCheck.title }); + const row = result.rows.find(item => item.id === storeCheck.id); + + assert.ok(row, '本次创建的任务应出现在 keyword 查询结果中'); + assert.ok(Object.prototype.hasOwnProperty.call(row, 'store_name'), 'rows 每条应包含 store_name 字段'); + assert.equal(typeof row.store_name, 'string', 'store_name 应为字符串'); + assert.ok(row.store_name.length > 0, 'store_id=1000000 的任务 store_name 不应为空'); + + // 与实现口径对齐:优先合约表 store_remask,无合约/备注为空时回退公司全称 + const contractRow = await ctx.model.StoreWarehouse.findOne({ + where: { store_id: TEST_STORE_ID, warehouse_id: TEST_WAREHOUSE_ID }, + attributes: [ 'store_remask' ], + raw: true, + }); + if (contractRow && contractRow.store_remask) { + assert.equal(row.store_name, contractRow.store_remask, '有合约备注时应与 wms_store_warehouse.store_remask 一致'); + } else { + const storeRow = await ctx.model.Store.findOne({ + where: { id: TEST_STORE_ID }, + attributes: [ 'company_name' ], + raw: true, + }); + assert.ok(storeRow && storeRow.company_name, '无合约备注时 wms_store.company_name 应存在且非空(否则无法兜底)'); + assert.equal(row.store_name, storeRow.company_name, '无合约备注时应回退 wms_store.company_name'); + } + }); + + it('list 返回 store_name 空串:type=location 任务 store_id 为空', async () => { + const allCheck = await createCheck({ type: 'location', title: uniqueTitle('store_name空串全盘') }); + const mainRow = await findCheckRow(allCheck.id); + assert.ok(mainRow.store_id === null || mainRow.store_id === undefined || mainRow.store_id === 0 || mainRow.store_id === '', + '库位任务 store_id 应为空'); + + const result = await listChecks({ keyword: allCheck.title }); + const row = result.rows.find(item => item.id === allCheck.id); + + assert.ok(row, '本次创建的任务应出现在 keyword 查询结果中'); + assert.ok(Object.prototype.hasOwnProperty.call(row, 'store_name'), 'rows 每条应包含 store_name 字段'); + assert.equal(row.store_name, '', 'store_id 为空的任务 store_name 应为空字符串'); + }); + + it('store_id 筛选 + store_name 组合正确:仅返回该货主任务且名称一致', async () => { + const prefix = uniqueTitle('store_name组合筛选'); + const storeCheck = await createCheck({ type: 'store', storeId: TEST_STORE_ID, title: `${prefix}-store` }); + const goodsCheck = await createCheck({ title: `${prefix}-goods` }); + + const result = await listChecks({ storeId: TEST_STORE_ID, keyword: prefix }); + const ids = result.rows.map(item => item.id); + + assert.ok(ids.includes(storeCheck.id), 'store 类型任务应命中 store_id 筛选'); + assert.ok(!ids.includes(goodsCheck.id), 'store_id 为空的商品任务不应命中 store_id 筛选'); + + const contractRow = await ctx.model.StoreWarehouse.findOne({ + where: { store_id: TEST_STORE_ID, warehouse_id: TEST_WAREHOUSE_ID }, + attributes: [ 'store_remask' ], + raw: true, + }); + const fallbackRow = contractRow && contractRow.store_remask + ? null + : await ctx.model.Store.findOne({ + where: { id: TEST_STORE_ID }, + attributes: [ 'company_name' ], + raw: true, + }); + const expectedName = (contractRow && contractRow.store_remask) || (fallbackRow && fallbackRow.company_name) || ''; + + for (const row of result.rows) { + assert.equal(Number(row.store_id), TEST_STORE_ID, 'store_id 筛选结果只能包含固定测试货主'); + assert.equal(row.store_name, expectedName, '筛选行 store_name 应与合约备注(或公司全称兜底)一致'); + } + const target = result.rows.find(item => item.id === storeCheck.id); + assert.ok(target, '本次创建的任务应出现在 store_id 筛选结果中'); + assert.ok(target.store_name.length > 0, '固定测试货主的 store_name 不应为空'); + }); + + it('分页 total 正确:keyword 限定范围后按页返回', async () => { + const prefix = uniqueTitle('分页测试'); + await createCheck({ title: `${prefix}-1` }); + await createCheck({ title: `${prefix}-2` }); + await createCheck({ title: `${prefix}-3` }); + + const firstPage = await listChecks({ + keyword: prefix, + pagination: { page: 1, pageSize: 2 }, + }); + assert.equal(firstPage.total, 3, 'total 应为关键词命中的全部 3 条'); + assert.equal(firstPage.rows.length, 2, '第一页应返回 2 条'); + + const secondPage = await listChecks({ + keyword: prefix, + pagination: { page: 2, pageSize: 2 }, + }); + assert.equal(secondPage.total, 3); + assert.equal(secondPage.rows.length, 1, '第二页应返回 1 条'); + }); + + it('type 单值筛选:location 与 goods 任务并存时只返回 location', async () => { + const locationCheck = await createCheck({ type: 'location' }); + const goodsCheck = await createCheck(); + + const result = await listChecks({ type: 'location' }); + const ids = result.rows.map(row => row.id); + + assert.ok(ids.includes(locationCheck.id), 'location 任务应命中 type=location'); + assert.ok(!ids.includes(goodsCheck.id), 'goods 任务不应命中 type=location'); + for (const row of result.rows) { + assert.equal(row.type, 'location', '筛选结果只能包含 location 任务'); + } + }); + + it('type 数组筛选 in:命中仅限传入类型(store 不混入 location/goods)', async () => { + const locationCheck = await createCheck({ type: 'location' }); + const goodsCheck = await createCheck(); + const storeCheck = await createCheck({ type: 'store', storeId: TEST_STORE_ID }); + + const result = await listChecks({ type: [ 'location', 'goods' ] }); + const ids = result.rows.map(row => row.id); + + assert.ok(ids.includes(locationCheck.id), 'location 任务应命中数组筛选'); + assert.ok(ids.includes(goodsCheck.id), 'goods 任务应命中数组筛选'); + assert.ok(!ids.includes(storeCheck.id), 'store 任务不应命中 location/goods 数组筛选'); + for (const row of result.rows) { + assert.ok([ 'location', 'goods' ].includes(row.type), `非法类型出现在筛选结果: ${row.type}`); + } + }); + + it('mode 筛选:open/blind 各命中对应任务(location 强制盲盘口径)', async () => { + const openCheck = await createCheck({ type: 'goods', mode: 'open' }); + const blindCheck = await createCheck({ type: 'location' }); + const blindRow = await findCheckRow(blindCheck.id); + assert.equal(blindRow.mode, 'blind', 'location 任务应被强制为盲盘,作为 mode 筛选的盲盘样本'); + + const openResult = await listChecks({ mode: 'open' }); + const openIds = openResult.rows.map(row => row.id); + assert.ok(openIds.includes(openCheck.id), 'open 任务应命中 mode=open'); + assert.ok(!openIds.includes(blindCheck.id), 'blind 任务不应命中 mode=open'); + for (const row of openResult.rows) { + assert.equal(row.mode, 'open', 'mode=open 筛选结果只能包含明盘任务'); + } + + const bothResult = await listChecks({ mode: [ 'open', 'blind' ] }); + const bothIds = bothResult.rows.map(row => row.id); + assert.ok(bothIds.includes(openCheck.id), 'mode 数组筛选应命中 open 任务'); + assert.ok(bothIds.includes(blindCheck.id), 'mode 数组筛选应命中 blind 任务'); + }); + + it('created_at 单值 gte:只返回创建时间不早于阈值的任务(直插 created_at 造数)', async () => { + const oldCheck = await createCheck({ title: uniqueTitle('created_at单值gte') }); + const newCheck = await createCheck({ title: uniqueTitle('created_at单值gte') }); + const oldRow = await setCheckCreatedAt(oldCheck.id, new Date('2019-06-15T00:00:00Z')); + const newRow = await setCheckCreatedAt(newCheck.id, new Date('2021-05-10T00:00:00Z')); + assert.equal(new Date(oldRow.created_at).getFullYear(), 2019, 'created_at 应直插为 2019 年'); + assert.equal(new Date(newRow.created_at).getFullYear(), 2021, 'created_at 应直插为 2021 年'); + + const result = await listChecks({ createdAt: '2021-01-01' }); + const ids = result.rows.map(row => row.id); + + assert.ok(ids.includes(newCheck.id), '2021 年创建的任务应命中 gte=2021-01-01'); + assert.ok(!ids.includes(oldCheck.id), '2019 年创建的任务不应命中 gte=2021-01-01'); + }); + + it('created_at 区间 between:只返回区间内创建的任务(直插 created_at 造数)', async () => { + const inRangeCheck = await createCheck({ title: uniqueTitle('created_at区间between') }); + const outRangeCheck = await createCheck({ title: uniqueTitle('created_at区间between') }); + await setCheckCreatedAt(inRangeCheck.id, new Date('2019-06-15T00:00:00Z')); + await setCheckCreatedAt(outRangeCheck.id, new Date('2021-05-10T00:00:00Z')); + + const result = await listChecks({ createdAt: [ '2019-01-01', '2019-12-31' ] }); + const ids = result.rows.map(row => row.id); + + assert.ok(ids.includes(inRangeCheck.id), '2019-06 创建的任务应命中 2019 年区间'); + assert.ok(!ids.includes(outRangeCheck.id), '2021 年创建的任务不应命中 2019 年区间'); + }); + + it('start_time/end_time 范围:report/finish 后按盘点时间范围筛选', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + const details = await detailCheck(check.id); + await reportCheck(check.id, details.rows[0].id, 3, TEST_LOCATION_CODE); + await finishCheck(check.id); + + const finishedRow = await findCheckRow(check.id); + assert.ok(finishedRow.start_time, 'report 后 start_time 应落库'); + assert.ok(finishedRow.end_time, 'finish 后 end_time 应落库'); + + const wideRange = [ '2000-01-01', '2099-12-31' ]; + const startHit = await listChecks({ startTime: wideRange }); + assert.ok(startHit.rows.map(row => row.id).includes(check.id), 'start_time 应命中宽区间'); + const endHit = await listChecks({ endTime: wideRange }); + assert.ok(endHit.rows.map(row => row.id).includes(check.id), 'end_time 应命中宽区间'); + + const pastRange = [ '1990-01-01', '1999-12-31' ]; + const startMiss = await listChecks({ startTime: pastRange }); + assert.ok(!startMiss.rows.map(row => row.id).includes(check.id), 'start_time 不应命中 1999 年前的区间'); + const endMiss = await listChecks({ endTime: pastRange }); + assert.ok(!endMiss.rows.map(row => row.id).includes(check.id), 'end_time 不应命中 1999 年前的区间'); + }); + + it('组合筛选 type+status:两个条件同时生效', async () => { + const goodsSubmitted = await createCheck({ title: uniqueTitle('组合筛选type-status') }); + const goodsCreated = await createCheck({ title: uniqueTitle('组合筛选type-status') }); + const locationSubmitted = await createCheck({ type: 'location', title: uniqueTitle('组合筛选type-status') }); + const stocks = await fetchStockRows(1); + await addDetail(goodsSubmitted.id, [ stocks[0].id ]); + await submitCheck(goodsSubmitted.id); + await addLocationDetail(locationSubmitted.id, [ TEST_LOCATION_CODE ]); + await submitCheck(locationSubmitted.id); + + const result = await listChecks({ type: 'goods', status: 'submitted' }); + const ids = result.rows.map(row => row.id); + + assert.ok(ids.includes(goodsSubmitted.id), 'goods+submitted 任务应命中组合筛选'); + assert.ok(!ids.includes(goodsCreated.id), 'goods+created 任务不应命中 status=submitted'); + assert.ok(!ids.includes(locationSubmitted.id), 'location+submitted 任务不应命中 type=goods'); + for (const row of result.rows) { + assert.equal(row.type, 'goods', '组合筛选结果只能包含 goods 任务'); + assert.equal(row.status, 'submitted', '组合筛选结果只能包含 submitted 任务'); + } + }); + + it('非法时间值静默忽略:单值/数组/空值均不报错', async () => { + const check = await createCheck({ title: uniqueTitle('非法时间值') }); + + const singleResult = await listChecks({ createdAt: 'not-a-date' }); + assert.ok(Array.isArray(singleResult.rows), '非法单值时间不应报错'); + assert.equal(typeof singleResult.total, 'number', '非法单值时间应返回正常分页结构'); + assert.ok(singleResult.rows.map(row => row.id).includes(check.id), '非法单值时间应按无条件返回全部任务'); + + const rangeResult = await listChecks({ createdAt: [ 'bad-from', 'bad-to' ] }); + assert.ok(Array.isArray(rangeResult.rows), '两端均非法的区间不应报错'); + assert.ok(rangeResult.rows.map(row => row.id).includes(check.id), '两端均非法的区间应按无条件返回全部任务'); + + const partialRangeResult = await listChecks({ startTime: [ 'bad-from', '2099-12-31' ] }); + assert.ok(Array.isArray(partialRangeResult.rows), '一端非法的区间不应报错(降级为 lte)'); + + const emptyResult = await listChecks({ createdAt: '' }); + assert.ok(Array.isArray(emptyResult.rows), '空字符串时间不应报错'); + }); + }); + + // ------------------- detail:查询任务详情(只返回任务本身信息) ------------------- + + describe('detail 查询任务详情(只返回任务本身信息)', () => { + it('只返回任务本身信息({ check }),不返回明细 rows/total', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + + const result = await ctx.service.systems.stockCheck.detail({ + warehouseId: TEST_WAREHOUSE_ID, + id: check.id, + }); + + assert.deepEqual(Object.keys(result).sort(), [ 'check' ], 'detail 只返回 check,不返回 rows/total'); + assert.equal(result.rows, undefined, 'detail 不应返回明细 rows'); + assert.equal(result.total, undefined, 'detail 不应返回明细 total'); + assert.equal(Number(result.check.id), Number(check.id)); + assert.equal(result.check.check_no, check.check_no); + assert.equal(result.check.status, 'created'); + assert.equal(result.check.detail_status, 'none_checked'); + assert.equal(result.check.total_items, 2, 'check.total_items 应为明细行数'); + assert.equal(result.check.checked_items, 0); + assert.equal(result.check.diff_items, 0); + assert.ok(result.check.created_at, 'check 应含创建时间'); + + // 数量差异汇总:未盘商品行按实盘 0 计盘亏(loss_total = 账面快照合计,正数口径) + const snapshotRows = await ctx.model.StockCheckDetail.findAll({ + where: { check_id: Number(check.id) }, + attributes: [ 'system_quantity' ], + raw: true, + }); + const expectedLoss = snapshotRows.reduce((sum, row) => sum + (Number(row.system_quantity) || 0), 0); + assert.equal(result.check.profit_total, 0, '未盘任务盘盈应为 0'); + assert.equal(result.check.loss_total, expectedLoss, '未盘任务盘亏应为账面快照合计(与 finish 未盘口径一致)'); + }); + + it('已盘后数量差异汇总:profit_total/loss_total 与 finish 口径一致', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const firstDetail = details.rows[0]; + const secondDetail = details.rows[1]; + const firstSnapshot = Number(firstDetail.system_quantity); + const secondSnapshot = Number(secondDetail.system_quantity); + + // 第一行盘盈 2、第二行盘亏 1 + await reportCheck(check.id, firstDetail.id, firstSnapshot + 2, TEST_LOCATION_CODE); + await reportCheck(check.id, secondDetail.id, secondSnapshot - 1, TEST_EMPTY_LOCATION_CODE); + + const detailResult = await ctx.service.systems.stockCheck.detail({ + warehouseId: TEST_WAREHOUSE_ID, + id: check.id, + }); + assert.equal(detailResult.check.profit_total, 2, '盘盈合计应为 2'); + assert.equal(detailResult.check.loss_total, 1, '盘亏合计应为 1(正数口径)'); + + // 与 finish 返回口径交叉验证 + const finishResult = await finishCheck(check.id); + assert.equal(detailResult.check.profit_total, finishResult.profit_total, 'detail 盘盈应与 finish 一致'); + assert.equal(detailResult.check.loss_total, finishResult.loss_total, 'detail 盘亏应与 finish 一致'); + assert.equal(detailResult.check.diff_items, finishResult.diff_items, 'detail 差异明细数应与 finish 一致'); + }); + + it('盘点任务ID 非法 / 任务不存在报 400', async () => { + const missingId = await findFreeCheckId(); + await assert.rejects( + () => ctx.service.systems.stockCheck.detail({ warehouseId: TEST_WAREHOUSE_ID, id: 0 }), + error => error.code === 400 && /盘点任务ID不能为空/.test(error.message) + ); + await assert.rejects( + () => ctx.service.systems.stockCheck.detail({ warehouseId: TEST_WAREHOUSE_ID, id: missingId }), + error => error.code === 400 && /盘点任务不存在/.test(error.message) + ); + }); + }); + + // ------------------- result:盘点结果聚合 ------------------- + + describe('result 盘点结果聚合', () => { + it('盘点前(无作业记录):rows 直接返回 wms_stock_check_detail 明细范围行', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + + const result = await resultCheck(check.id); + const details = await detailCheck(check.id); + + assert.equal(result.total, 2); + assert.equal(result.rows.length, details.rows.length); + for (const row of result.rows) { + assert.equal(row.scope_type, 'goods', '明细行应含 scope_type'); + assert.ok(row.stock_id, '明细行应含 stock_id'); + assert.ok(row.location_id, '明细行应含 location_id'); + assert.ok(row.location_code, '明细行应含库位编码'); + assert.ok(row.item_code, '明细行应含商品编码快照'); + assert.ok(Number(row.system_quantity) >= 0, '明细行应含账面快照'); + } + assert.deepEqual( + result.rows.map(row => Number(row.id)), + details.rows.map(row => Number(row.id)), + 'rows 应为明细表原始行' + ); + }); + + it('待提交(submitted)状态:rows 同样返回明细范围行(后台盘点前查看明细)', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + + const result = await resultCheck(check.id); + + assert.equal(result.check.status, 'submitted'); + assert.equal(result.rows.length, 2, '待提交任务应返回明细范围行'); + assert.ok( + result.rows.every(row => row.scope_type === 'goods' && row.stock_id && row.location_code), + '待提交任务 rows 应为明细表原始行(含商品/库位/快照)' + ); + }); + + it('已盘明细:location_codes/checkers 合并去重、records 完整、last_checked_at 取最近', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detailId = details.rows[0].id; + + await reportCheck(check.id, detailId, 3, TEST_LOCATION_CODE, { checkerName: '盘点人A' }); + await reportCheck(check.id, detailId, 4, TEST_LOCATION_CODE_2, { checkerName: '盘点人A' }); + await reportCheck(check.id, detailId, 2, TEST_LOCATION_CODE_3, { checkerName: '盘点人B' }); + + const result = await resultCheck(check.id); + const row = result.rows[0]; + + assert.equal(row.checked_quantity, 9, '已盘数量应为三条记录合计'); + assert.equal(row.status, 'checked'); + assert.deepEqual(row.location_codes, [ TEST_LOCATION_CODE, TEST_LOCATION_CODE_2, TEST_LOCATION_CODE_3 ], '库位编码应合并去重'); + assert.deepEqual(row.checkers, [ '盘点人A', '盘点人B' ], '盘点人应合并去重'); + assert.equal(row.records.length, 3, 'records 应包含全部作业记录'); + for (const record of row.records) { + assert.ok(record.location_code, '记录应含库位编码'); + assert.ok(record.quantity !== undefined, '记录应含实盘数量'); + assert.ok(record.checker_name, '记录应含盘点人'); + assert.ok(record.checked_at, '记录应含上报时间'); + } + assert.ok(row.last_checked_at, '最近盘点时间应非空'); + const lastRecord = row.records[row.records.length - 1]; + assert.equal( + new Date(row.last_checked_at).getTime(), + new Date(lastRecord.checked_at).getTime(), + 'last_checked_at 应为最近一条记录的上报时间' + ); + }); + + it('result 与 detail 行一一对应:范围行数与行 id 完全一致', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + await reportCheck(check.id, details.rows[0].id, 1, TEST_LOCATION_CODE); + + const result = await resultCheck(check.id); + + assert.equal(result.total, details.total, 'result 与 detail 范围行数应一致'); + assert.equal(result.rows.length, details.rows.length); + const detailIds = details.rows.map(row => Number(row.id)); + const resultIds = result.rows.map(row => Number(row.id)); + assert.deepEqual(resultIds, detailIds, 'result 行 id 集合应与 detail 一致'); + for (const row of result.rows) { + assert.ok(row.stock_id, '商品范围行应含 stock_id'); + } + }); + + it('result 商品行聚合与 recordList 交叉验证:checked_quantity/diff/locations 与记录表口径一致', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detailId = details.rows[0].id; + const snapshot = Number(details.rows[0].system_quantity); + await reportCheck(check.id, detailId, snapshot + 2, TEST_LOCATION_CODE, { checkerName: '盘点人A' }); + await reportCheck(check.id, detailId, 4, TEST_LOCATION_CODE_2, { checkerName: '盘点人B' }); + + const result = await resultCheck(check.id); + const row = result.rows[0]; + + const listed = await listRecords({ id: check.id, detailId }); + assert.equal(listed.total, 2, 'recordList 应返回该明细全部作业记录'); + const expectedChecked = listed.rows.reduce((sum, record) => sum + Number(record.quantity), 0); + assert.equal(row.checked_quantity, expectedChecked, 'checked_quantity 应与 recordList 数量合计一致'); + assert.equal(row.diff_quantity, expectedChecked - snapshot, 'diff_quantity=已盘合计-账面快照'); + assert.equal(row.is_diff, 1); + assert.equal(row.status, 'checked'); + assert.equal(row.records.length, listed.total, 'records 条数应与 recordList 一致'); + assert.deepEqual( + row.records.map(record => Number(record.id)).sort((left, right) => left - right), + listed.rows.map(record => Number(record.id)).sort((left, right) => left - right), + 'records 记录 id 应与 recordList 完全一致' + ); + assert.deepEqual( + row.location_codes.sort(), + [ TEST_LOCATION_CODE, TEST_LOCATION_CODE_2 ].sort(), + 'location_codes 应与记录库位编码一致' + ); + const locationQuantityMap = new Map(row.locations.map(item => [ item.location_code, item.quantity ])); + assert.equal(locationQuantityMap.get(TEST_LOCATION_CODE), snapshot + 2, '有库位组数量应为该库位上报值'); + assert.equal(locationQuantityMap.get(TEST_LOCATION_CODE_2), 4, '无库位组数量应为该库位上报值'); + }); + + it('多库位商品合并为一行:locations 输出各库位账面快照与实盘,差异=实盘合计-账面快照合计', async () => { + const { Op, literal } = ctx.app.Sequelize; + // 找一个在两个启用库位都有库存的商品(与 addDetail 拆行用例同口径) + const storageRows = await ctx.model.Storage.findAll({ + where: { + warehouse_id: TEST_WAREHOUSE_ID, + is_enabled: 1, + space_id: { [Op.in]: literal(VALID_SPACE_SQL) }, + }, + attributes: [ 'stock_id', 'space_id', [ literal('SUM(available_quantity + locked_quantity)'), 'totalQuantity' ]], + group: [ 'stock_id', 'space_id' ], + raw: true, + }); + const spacesByStock = new Map(); + for (const row of storageRows) { + const stockId = Number(row.stock_id); + if (!spacesByStock.has(stockId)) { + spacesByStock.set(stockId, []); + } + spacesByStock.get(stockId).push(row); + } + const multiStockEntry = [ ...spacesByStock.entries() ].find(([ , rows ]) => rows.length >= 2); + assert.ok(multiStockEntry, '前置:测试库应存在多库位库存商品'); + const multiStockId = Number(multiStockEntry[0]); + const multiStock = await ctx.model.StockWarehouse.findOne({ + where: { id: multiStockId, warehouse_id: TEST_WAREHOUSE_ID }, + raw: true, + }); + assert.ok(multiStock, '前置:多库位商品应存在于 wms_stock_warehouse'); + + const check = await createCheck({ type: 'goods', storeId: multiStock.store_id || null }); + const addResult = await addDetail(check.id, [ multiStockId ]); + assert.equal(addResult.total_items, 1, '按商品盘点 total_items 按商品计数'); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + assert.ok(details.rows.length >= 2, '前置:商品应按库位拆成多行'); + + // 全部库位上报:第一个库位盘盈 5、第二个库位盘盈 1、其余库位实盘=账面(差异合计恒为 6) + const firstDetail = details.rows[0]; + const secondDetail = details.rows[1]; + for (const detail of details.rows) { + let quantity = Number(detail.system_quantity); + if (Number(detail.id) === Number(firstDetail.id)) { + quantity += 5; + } + if (Number(detail.id) === Number(secondDetail.id)) { + quantity += 1; + } + await reportCheck(check.id, detail.id, quantity, detail.location_code || undefined); + } + + const result = await resultCheck(check.id); + assert.equal(result.total, 1, '多库位商品应合并为一行'); + assert.equal(result.rows.length, 1); + const row = result.rows[0]; + assert.equal(Number(row.stock_id), multiStockId); + assert.equal(row.scope_type, 'goods'); + assert.equal(row.location_id, null, '合并行不绑定单一库位'); + assert.equal(row.location_code, null, '合并行不绑定单一库位编码'); + const totalSnapshot = details.rows.reduce((sum, detail) => sum + Number(detail.system_quantity), 0); + assert.equal(Number(row.system_quantity), totalSnapshot, '行级账面=各库位账面快照合计'); + assert.equal(row.checked_quantity, totalSnapshot + 6, '已盘数量=各库位实盘合计'); + assert.equal(row.diff_quantity, 6, '差异=实盘合计-账面快照合计'); + assert.equal(row.is_diff, 1); + assert.equal(row.status, 'checked'); + assert.equal(row.records.length, details.rows.length, 'records 应包含全部库位作业记录'); + + const firstLocation = row.locations.find(item => item.location_code === firstDetail.location_code); + assert.ok(firstLocation, 'locations 应含第一个库位'); + assert.equal(Number(firstLocation.system_quantity), Number(firstDetail.system_quantity), '库位账面=创建明细时的快照'); + assert.equal(Number(firstLocation.quantity), Number(firstDetail.system_quantity) + 5, '库位实盘=该库位上报值'); + const secondLocation = row.locations.find(item => item.location_code === secondDetail.location_code); + assert.ok(secondLocation, 'locations 应含第二个库位'); + assert.equal(Number(secondLocation.system_quantity), Number(secondDetail.system_quantity), '库位账面=创建明细时的快照'); + assert.equal(Number(secondLocation.quantity), Number(secondDetail.system_quantity) + 1, '库位实盘=该库位上报值'); + }); + }); + + // ------------------- result.locations:库位分组聚合 ------------------- + + describe('result.locations 库位分组聚合', () => { + it('多库位分组:按库位聚合数量、空库位归 null 组、按组内首条记录 id 升序', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detailId = details.rows[0].id; + + await reportCheck(check.id, detailId, 10, TEST_LOCATION_CODE); + await reportCheck(check.id, detailId, 5, TEST_LOCATION_CODE_2); + await reportCheck(check.id, detailId, 7, TEST_LOCATION_CODE); + await reportCheck(check.id, detailId, 3, TEST_LOCATION_CODE_3); + + const result = await resultCheck(check.id); + const row = result.rows[0]; + + // 商品按商品合并后:快照库位(含账面快照)+ 已盘库位(按首条记录 id 升序追加) + const quantityByCode = new Map(row.locations.map(location => [ location.location_code, location.quantity ])); + assert.equal(quantityByCode.get(TEST_LOCATION_CODE), 7, '命中库位数量应为该库位最新值'); + assert.equal(quantityByCode.get(TEST_LOCATION_CODE_2), 5); + assert.equal(quantityByCode.get(TEST_LOCATION_CODE_3), 3); + const snapshotEntry = row.locations.find(location => Number(location.system_quantity) > 0); + assert.ok(snapshotEntry, '应含账面快照库位(system_quantity=创建明细时账面快照)'); + assert.equal( + Number(snapshotEntry.system_quantity), + Number(details.rows[0].system_quantity), + '账面快照应为明细快照值' + ); + const checkedEntry = row.locations.find(location => location.location_code === TEST_LOCATION_CODE); + assert.equal(Number(checkedEntry.location_id), TEST_LOCATION_ID, '命中库位应回填 location_id'); + const otherEntry = row.locations.find(location => location.location_code === TEST_LOCATION_CODE_2); + assert.equal(Number(otherEntry.location_id), TEST_LOCATION_ID_2, '有效库位应回填 location_id'); + assert.equal(row.checked_quantity, 15, '已盘数量=各库位最新值合计'); + assert.equal(row.records.length, 3, 'records 流水保持三条'); + assert.equal(row.location_codes.length, 3, '既有聚合字段 location_codes 不变'); + }); + + it('历史无库位记录(location_code=空串)归入 location_code=null 组(report 不再产生该分组)', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detail = details.rows[0]; + + // report 已强制 space_id,无库位上报直接被拒 + await assert.rejects(async () => { + await reportCheck(check.id, detail.id, 4, undefined, { spaceId: 0 }); + }, error => error.code === 400 && error.message.includes('缺少库位ID')); + + // 历史脏数据(空串库位)仍按既有口径归入 null 组 + await ctx.model.StockCheckRecord.create({ + check_id: check.id, + warehouse_id: TEST_WAREHOUSE_ID, + detail_id: detail.id, + stock_id: Number(detail.stock_id), + location_id: null, + location_code: '', + quantity: 6, + is_empty: false, + checker_id: TEST_CREATOR_ID, + checker_name: TEST_CREATOR_NAME, + checked_at: new Date(), + }); + + const result = await resultCheck(check.id); + const row = result.rows[0]; + + const nullGroup = row.locations.find(location => location.location_code === null); + assert.ok(nullGroup, '空库位归 location_code=null 组'); + assert.equal(nullGroup.location_id, null); + assert.equal(Number(nullGroup.quantity), 6, '无库位组数量为该记录实盘值'); + assert.equal(Number(nullGroup.system_quantity), 0, '无库位组无账面快照'); + assert.equal(Number(row.checked_quantity), 6); + }); + }); + + // ------------------- result:库位行 stocks 聚合(账面来自 wms_storage) ------------------- + + describe('result 库位行 stocks 聚合', () => { + it('库位行 stocks 按商品聚合:多商品账面来自 wms_storage、行级差异为各商品差异代数和', async () => { + const { check, detail } = await createApprovedLocationCheck(); + const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 2); + assert.ok(stockIds.length >= 2, '固定测试库位应存在至少两个商品库存(真实数据依赖)'); + + const bookMap = await fetchStorageQuantity(TEST_LOCATION_ID, stockIds); + const bookA = Number(bookMap.get(stockIds[0]) || 0); + const bookB = Number(bookMap.get(stockIds[1]) || 0); + const qtyA = bookA + 5; + const qtyB = Math.max(0, bookB - 2); + await reportCheck(check.id, detail.id, qtyA, undefined, { stockId: stockIds[0] }); + await reportCheck(check.id, detail.id, qtyB, undefined, { stockId: stockIds[1] }); + + const result = await resultCheck(check.id); + const row = result.rows[0]; + + assert.equal(row.scope_type, 'location', '库位行应输出 scope_type=location'); + assert.equal(row.status, 'checked'); + assert.equal(row.checked_quantity, qtyA + qtyB, '行级已盘数量=行内商品已盘合计'); + const expectedDiff = 5 + (qtyB - bookB); + assert.equal(row.diff_quantity, expectedDiff, '行级差异=各商品差异代数和'); + assert.equal(row.is_diff, expectedDiff !== 0 ? 1 : 0); + + assert.equal(row.stocks.length, 2); + assert.deepEqual( + row.stocks.map(stock => Number(stock.stock_id)), + stockIds, + 'stocks 应按 stock_id 升序' + ); + const stockA = row.stocks[0]; + assert.equal(Number(stockA.system_quantity), bookA, '账面应来自 wms_storage 实时汇总'); + assert.equal(stockA.checked_quantity, qtyA); + assert.equal(stockA.diff_quantity, 5); + assert.ok(stockA.item_code, 'stocks 应回填商品编码'); + const stockB = row.stocks[1]; + assert.equal(Number(stockB.system_quantity), bookB); + assert.equal(stockB.checked_quantity, qtyB); + assert.equal(stockB.diff_quantity, qtyB - bookB); + + // 与作业记录表交叉验证:records 商品 ID 应与上报商品一致 + assert.equal(row.records.length, 2, 'records 应包含行内全部作业记录'); + assert.deepEqual( + row.records.map(record => Number(record.stock_id)).sort((left, right) => left - right), + [ ...stockIds ].sort((left, right) => left - right), + 'records 商品 ID 应与上报商品一致' + ); + }); + + it('库位无库存时账面按 0:diff=已盘-0', async () => { + const check = await createCheck({ type: 'location' }); + const emptySpace = await ctx.model.LocationSpace.findOne({ + where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: TEST_EMPTY_LOCATION_CODE }, + raw: true, + }); + assert.ok(emptySpace, `空库位编码不存在(${TEST_EMPTY_LOCATION_CODE})`); + const storageCount = await ctx.model.Storage.count({ + where: { space_id: Number(emptySpace.id) }, + }); + assert.equal(storageCount, 0, '测试用空库位应无库存记录(账面 0 口径依赖)'); + + await addLocationDetail(check.id, [ TEST_EMPTY_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const stocks = await fetchStockRows(1); + const details = await detailCheck(check.id); + const detail = details.rows.find(row => row.location_code === TEST_EMPTY_LOCATION_CODE); + await reportCheck(check.id, detail.id, 7, undefined, { stockId: stocks[0].id }); + + const result = await resultCheck(check.id); + const row = result.rows.find(item => item.location_code === TEST_EMPTY_LOCATION_CODE); + + assert.equal(row.stocks.length, 1); + assert.equal(Number(row.stocks[0].system_quantity), 0, '无库存库位账面应为 0'); + assert.equal(row.stocks[0].checked_quantity, 7); + assert.equal(row.stocks[0].diff_quantity, 7, 'diff=已盘-0'); + assert.equal(row.diff_quantity, 7); + assert.equal(row.is_diff, 1); + }); + }); + + // ------------------- workData:盘点作业数据(单接口三视图) ------------------- + + describe('workData 盘点作业数据(location/goods/space 单接口三视图)', () => { + it('location 视图:库位范围行与明细一致、未盘行 status=unchecked、子列表为空、不返回 check 且 view=location', async () => { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + assert.equal(details.total, 2, '前置:任务应有两条库位范围行'); + + const data = await workDataCheck(check.id, 'location'); + + assert.deepEqual( + Object.keys(data).sort(), + [ 'page', 'pageSize', 'rows', 'total', 'view' ], + 'workData 只返回作业数据行 + view(不返回 check,任务信息请调 detail)' + ); + assert.equal(data.view, 'location', '库位任务应返回 view=location'); + assert.equal(data.total, 2); + assert.equal(data.rows.length, 2); + assert.equal((await findCheckRow(check.id)).mode, 'blind', '库位维度任务应为盲盘'); + assert.deepEqual( + data.rows.map(row => Number(row.detail_id)), + details.rows.map(row => Number(row.id)), + 'location 行应与任务库位范围行一一对应(按明细 id 升序)' + ); + for (const row of data.rows) { + const detail = details.rows.find(item => Number(item.id) === Number(row.detail_id)); + const space = await ctx.model.LocationSpace.findOne({ + where: { id: Number(detail.location_id) }, + attributes: [ 'space_code', 'custom_name' ], + raw: true, + }); + assert.equal(Number(row.location_id), Number(detail.location_id), 'location_id 应来自明细快照'); + assert.equal(row.location_code, detail.location_code, 'location_code 应来自明细快照'); + assert.equal( + row.location_name, + (space.custom_name || space.space_code) || detail.location_code, + 'location_name 应为 custom_name 兜底 space_code' + ); + assert.equal(row.status, 'unchecked', '无作业记录应输出未盘'); + assert.equal(row.has_unknown, false); + assert.equal(row.checked_at, null); + assert.deepEqual(row.checkers, []); + assert.deepEqual(row.goods, []); + } + }); + + it('keyword 过滤:仅库位任务生效,按 location_code/location_name 模糊匹配(不区分大小写)后再分页', async () => { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const spaceRows = await ctx.model.LocationSpace.findAll({ + where: { space_code: { [ctx.app.Sequelize.Op.in]: [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ] } }, + attributes: [ 'id', 'space_code', 'custom_name' ], + raw: true, + }); + const spaceA = spaceRows.find(row => row.space_code === TEST_LOCATION_CODE); + const spaceE = spaceRows.find(row => row.space_code === TEST_EMPTY_LOCATION_CODE); + + // 1) 按 location_code 前缀匹配(小写验证不区分大小写) + const byCode = await workDataCheck(check.id, { keyword: 'a1715' }); + assert.equal(byCode.total, 1, '按库位编码前缀应命中 1 行'); + assert.equal(byCode.rows.length, 1); + assert.equal(byCode.rows[0].location_code, TEST_LOCATION_CODE); + + // 2) 按 location_name 匹配(取名称中不被另一库位编码/名称包含的唯一字符做关键字) + const nameA = (spaceA && (spaceA.custom_name || spaceA.space_code)) || TEST_LOCATION_CODE; + const otherTexts = [ TEST_EMPTY_LOCATION_CODE, spaceE && spaceE.custom_name ] + .filter(Boolean) + .map(text => String(text).toLowerCase()); + const uniqueChar = Array.from(String(nameA)) + .find(char => !otherTexts.some(text => text.includes(String(char).toLowerCase()))); + if (uniqueChar) { + const byName = await workDataCheck(check.id, { keyword: uniqueChar }); + assert.equal(byName.total, 1, '按库位名称唯一字符应命中 1 行'); + assert.equal(byName.rows[0].location_code, TEST_LOCATION_CODE); + } + + // 3) 无命中关键字 → total=0、rows=[] + const miss = await workDataCheck(check.id, { keyword: 'ZZZ-NO-MATCH-998' }); + assert.equal(miss.total, 0); + assert.deepEqual(miss.rows, []); + + // 4) 空白关键字 → 视为未传,不过滤 + const blank = await workDataCheck(check.id, { keyword: ' ' }); + assert.equal(blank.total, 2, '空白关键字应不过滤'); + + // 5) 非库位任务忽略 keyword(goods 任务 space 视图) + const goodsCheck = await createCheck({ type: 'goods' }); + const stocks = await fetchStockRows(1); + await addDetail(goodsCheck.id, [ stocks[0].id ]); + await submitCheck(goodsCheck.id); + await auditCheck(goodsCheck.id, 'approve'); + const goodsAll = await workDataCheck(goodsCheck.id); + const goodsFiltered = await workDataCheck(goodsCheck.id, { keyword: 'ZZZ-NO-MATCH-998' }); + assert.equal(goodsFiltered.total, goodsAll.total, '商品任务应忽略 keyword'); + }); + + it('space 视图行 location_id 与 id 同义(供调用方直接回传 report 的 location_id)', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const data = await workDataCheck(check.id); + assert.equal(data.view, 'space'); + assert.ok(data.rows.length > 0, '前置:space 视图应有库位行'); + for (const row of data.rows) { + assert.ok(Number(row.id) > 0, 'id 应为库位ID'); + assert.equal(Number(row.location_id), Number(row.id), 'location_id 应与 id 一致'); + } + }); + + it('space 视图:库位仅按拣货顺序排序(pick_sequence 升序,pick_priority 与库位 id 不参与)', async () => { + // 1) 找两个不同库位、各只有一个库存库位的商品(确保 space 视图恰好聚合这两个库位) + const pairs = await fetchSpaceStockPairs(2); + assert.ok(pairs.length >= 2, '测试仓库应至少有 2 个单库位启用库存库位(真实数据依赖)'); + const spaceA = Number(pairs[0].spaceId); + const spaceB = Number(pairs[1].spaceId); + const stockA = Number(pairs[0].stockId); + const stockB = Number(pairs[1].stockId); + const stockRows = await ctx.model.StockWarehouse.findAll({ + where: { + id: { [ctx.app.Sequelize.Op.in]: [ stockA, stockB ] }, + warehouse_id: TEST_WAREHOUSE_ID, + }, + attributes: [ 'id' ], + raw: true, + }); + assert.equal(stockRows.length, 2, '两个商品均应属于测试仓库'); + + const check = await createCheck({ type: 'goods' }); + await addDetail(check.id, [ stockA, stockB ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + // 2) 记录库位原始排序值,验证后恢复(不污染开发库拣货路径数据) + const spaceRows = await ctx.model.LocationSpace.findAll({ + where: { id: { [ctx.app.Sequelize.Op.in]: [ spaceA, spaceB ] } }, + attributes: [ 'id', 'pick_sequence', 'pick_priority' ], + raw: true, + }); + const originalValues = new Map(spaceRows.map(row => [ + Number(row.id), + { pick_sequence: row.pick_sequence, pick_priority: row.pick_priority }, + ])); + const restoreSpaces = async () => { + for (const [ spaceId, values ] of originalValues.entries()) { + await ctx.model.LocationSpace.update( + { pick_sequence: values.pick_sequence, pick_priority: values.pick_priority }, + { where: { id: spaceId } } + ); + } + }; + + try { + // 阶段1:pick_priority 相同(50)时按 pick_sequence 升序 → B(100) 在 A(200) 前 + await ctx.model.LocationSpace.update( + { pick_sequence: 200, pick_priority: 50 }, + { where: { id: spaceA } } + ); + await ctx.model.LocationSpace.update( + { pick_sequence: 100, pick_priority: 50 }, + { where: { id: spaceB } } + ); + let data = await workDataCheck(check.id); + assert.equal(data.view, 'space', '商品任务默认应为 space 视图'); + assert.deepEqual( + data.rows.map(row => Number(row.id)), + [ spaceB, spaceA ], + 'pick_sequence 应升序(小值在前)' + ); + + // 阶段2:pick_sequence 相同(300)时 pick_priority 不参与排序, + // 同值保持库位查询顺序(实际按 id 升序);两方向设置 priority 断言顺序不变, + // 若实现误把 priority 纳入排序键,总有一组断言会失败 + const [ smallerId, largerId ] = [ spaceA, spaceB ].sort((left, right) => left - right); + await ctx.model.LocationSpace.update( + { pick_sequence: 300, pick_priority: 10 }, + { where: { id: smallerId } } + ); + await ctx.model.LocationSpace.update( + { pick_sequence: 300, pick_priority: 90 }, + { where: { id: largerId } } + ); + data = await workDataCheck(check.id); + assert.deepEqual( + data.rows.map(row => Number(row.id)), + [ smallerId, largerId ], + 'pick_priority 不参与排序(同 pick_sequence 保持原顺序,升序误入会交换)' + ); + + await ctx.model.LocationSpace.update( + { pick_sequence: 300, pick_priority: 90 }, + { where: { id: smallerId } } + ); + await ctx.model.LocationSpace.update( + { pick_sequence: 300, pick_priority: 10 }, + { where: { id: largerId } } + ); + data = await workDataCheck(check.id); + assert.deepEqual( + data.rows.map(row => Number(row.id)), + [ smallerId, largerId ], + 'pick_priority 不参与排序(同 pick_sequence 保持原顺序,降序误入会交换)' + ); + } finally { + await restoreSpaces(); + } + }); + + it('only_abnormal 过滤 location 视图:仅保留未盘行与含未知商品行,兼容 onlyAbnormal 驼峰写法', async () => { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const checkedDetail = details.rows.find(row => row.location_code === TEST_LOCATION_CODE); + const uncheckedDetail = details.rows.find(row => row.location_code === TEST_EMPTY_LOCATION_CODE); + assert.ok(checkedDetail && uncheckedDetail, '前置:两条库位范围行均应存在'); + + // 已盘行(无未知商品):上报后应被过滤,仅剩未盘行 + const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 1); + await reportCheck(check.id, checkedDetail.id, 3, undefined, { stockId: stockIds[0] }); + + const abnormal = await workDataCheck(check.id, { onlyAbnormal: true }); + assert.equal(abnormal.total, 1, '已盘无未知商品行应被过滤,仅剩未盘行'); + assert.equal(Number(abnormal.rows[0].detail_id), Number(uncheckedDetail.id)); + assert.equal(abnormal.rows[0].status, 'unchecked'); + + // 未传 only_abnormal → 不过滤;onlyAbnormal 驼峰写法等价 + const all = await workDataCheck(check.id, {}); + assert.equal(all.total, 2, '未传 only_abnormal 应不过滤'); + const camel = await workDataCheck(check.id, { onlyAbnormal: true }); + assert.equal(camel.total, 1, 'onlyAbnormal 驼峰写法应等价生效'); + + // 已盘行补充未知商品记录 → has_unknown=true 视为差异,应保留 + await reportCheck(check.id, checkedDetail.id, 7, undefined, { barcode: uniqueTitle('ONLY-ABN-UNKNOWN') }); + const abnormal2 = await workDataCheck(check.id, { onlyAbnormal: true }); + assert.equal(abnormal2.total, 2, '未知商品行(has_unknown)应视为差异保留'); + const checkedRow = abnormal2.rows.find(row => Number(row.detail_id) === Number(checkedDetail.id)); + assert.equal(checkedRow.has_unknown, true); + }); + + it('only_abnormal 过滤 goods 视图明盘:未盘行与差异行保留、已盘平账行移除、total 为过滤后行数', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const diffDetail = details.rows[0]; + const flatDetail = details.rows[1]; + const diffSnapshot = Number(diffDetail.system_quantity); + const flatSnapshot = Number(flatDetail.system_quantity); + + // 仅第一行盘盈(差异)→ only_abnormal 应保留差异行与未盘行 + await reportCheck(check.id, diffDetail.id, diffSnapshot + 2, TEST_LOCATION_CODE); + + const first = await workDataCheck(check.id, { isGoods: true, onlyAbnormal: true }); + assert.equal(first.view, 'goods'); + assert.equal(first.total, 2, '差异行 + 未盘行应均保留'); + assert.deepEqual( + first.rows.map(row => Number(row.detail_id)).sort((left, right) => left - right), + [ Number(diffDetail.id), Number(flatDetail.id) ].sort((left, right) => left - right), + '保留行应为差异行与未盘行' + ); + const flatRow = first.rows.find(row => Number(row.detail_id) === Number(flatDetail.id)); + assert.ok( + !flatRow.locations.some(location => Array.isArray(location.record_ids) && location.record_ids.length > 0), + '未盘行应无任何作业记录' + ); + + // 第二行平账(已盘无差异)→ 仅剩差异行 + await reportCheck(check.id, flatDetail.id, flatSnapshot, TEST_LOCATION_CODE); + const second = await workDataCheck(check.id, { isGoods: true, onlyAbnormal: true }); + assert.equal(second.total, 1, '已盘平账行应被过滤,仅剩差异行'); + assert.equal(Number(second.rows[0].detail_id), Number(diffDetail.id)); + assert.equal(second.rows[0].is_diff, 1); + + // 过滤在分页切片之前:pageSize=1 时 rows 为当前页、total 仍为过滤后行数 + const paged = await workDataCheck(check.id, { isGoods: true, onlyAbnormal: true, pagination: { page: 1, pageSize: 1 } }); + assert.equal(paged.total, 1); + assert.equal(paged.rows.length, 1); + + // false/0/空串视为未传不过滤 + for (const value of [ false, 0, 'false', '' ]) { + const noFilter = await workDataCheck(check.id, { isGoods: true, onlyAbnormal: value }); + assert.equal(noFilter.total, 2, `only_abnormal=${JSON.stringify(value)} 应不过滤`); + } + }); + + it('only_abnormal 过滤 space 视图明盘:行内 goods 按未盘/数量差异过滤、空行移除', async () => { + const pairs = await fetchSpaceStockPairs(2); + const check = await createCheck(); + await addDetail(check.id, pairs.map(pair => pair.stockId)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const diffPair = pairs[0]; + const flatPair = pairs[1]; + const diffDetail = details.rows.find(row => Number(row.stock_id) === diffPair.stockId); + const flatDetail = details.rows.find(row => Number(row.stock_id) === flatPair.stockId); + + // 库位1盘盈(差异)、库位2未盘 → 两个库位行均应保留(差异子项 + 未盘子项) + await reportCheck(check.id, diffDetail.id, diffPair.book + 2, diffPair.spaceCode); + + const first = await workDataCheck(check.id, { onlyAbnormal: true }); + assert.equal(first.view, 'space'); + assert.equal(first.total, 2, '差异库位与未盘库位均应保留'); + const diffRow = first.rows.find(row => Number(row.id) === diffPair.spaceId); + const uncheckedRow = first.rows.find(row => Number(row.id) === flatPair.spaceId); + assert.ok(diffRow && uncheckedRow, '差异库位与未盘库位行均应存在'); + assert.equal(diffRow.goods.length, 1, '差异库位行应保留差异商品子项'); + assert.equal(Number(diffRow.goods[0].checked_quantity), diffPair.book + 2); + assert.equal(uncheckedRow.goods.length, 1); + assert.equal(uncheckedRow.goods[0].status, 'unchecked'); + + // 库位2平账(已盘无差异)→ 该库位行整体移除,仅剩差异库位行 + await reportCheck(check.id, flatDetail.id, flatPair.book, flatPair.spaceCode); + const second = await workDataCheck(check.id, { onlyAbnormal: true }); + assert.equal(second.total, 1, '已盘平账库位行应被整体移除'); + assert.equal(Number(second.rows[0].id), diffPair.spaceId); + assert.equal(second.rows[0].goods.length, 1, '保留行内 goods 应仅剩差异商品'); + }); + + it('only_abnormal 过滤 space 视图盲盘:无数量字段仅按未盘过滤(已盘行移除)', async () => { + const pairs = await fetchSpaceStockPairs(2); + const check = await createCheck({ mode: 'blind' }); + await addDetail(check.id, pairs.map(pair => pair.stockId)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const reportedDetail = details.rows.find(row => Number(row.stock_id) === pairs[0].stockId); + await reportCheck(check.id, reportedDetail.id, 6, pairs[0].spaceCode); + + const data = await workDataCheck(check.id, { onlyAbnormal: true }); + assert.equal(data.total, 1, '盲盘已盘行无法判断差异应移除,仅剩未盘库位行'); + assert.equal(Number(data.rows[0].id), pairs[1].spaceId, '保留行应为未盘库位'); + assert.equal(data.rows[0].goods[0].status, 'unchecked'); + }); + + it('only_abnormal 与 keyword 叠加:location 视图先 keyword 过滤再按未盘/差异过滤', async () => { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const checkedDetail = details.rows.find(row => row.location_code === TEST_LOCATION_CODE); + const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 1); + await reportCheck(check.id, checkedDetail.id, 3, undefined, { stockId: stockIds[0] }); + + // keyword 命中已盘行 + only_abnormal → 已盘行被过滤 → 0 行 + const hitChecked = await workDataCheck(check.id, { keyword: 'a1715', onlyAbnormal: true }); + assert.equal(hitChecked.total, 0, 'keyword 命中的已盘行被 only_abnormal 过滤后应为空'); + + // keyword 命中未盘行 + only_abnormal → 1 行 + const hitUnchecked = await workDataCheck(check.id, { keyword: TEST_EMPTY_LOCATION_CODE, onlyAbnormal: true }); + assert.equal(hitUnchecked.total, 1, 'keyword 命中的未盘行应保留'); + assert.equal(hitUnchecked.rows[0].status, 'unchecked'); + }); + + it('workDataDetail:按明细ID返回单行(结构同 location 视图行),已盘/未盘口径与列表一致', async () => { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const targetDetail = details.rows.find(row => row.location_code === TEST_LOCATION_CODE); + const emptyDetail = details.rows.find(row => row.location_code === TEST_EMPTY_LOCATION_CODE); + assert.ok(targetDetail && emptyDetail, '前置:两条库位范围行均应存在'); + + const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 1); + const reported = await reportCheck(check.id, targetDetail.id, 6, undefined, { stockId: stockIds[0] }); + + const row = await workDataDetailCheck(targetDetail.id); + assert.deepEqual( + Object.keys(row).sort(), + [ 'checked_at', 'checkers', 'detail_id', 'goods', 'has_unknown', 'is_empty', 'location_code', 'location_id', 'location_name', 'space_id', 'status' ].sort(), + '单行字段应与 location 视图行结构一致' + ); + assert.equal(Number(row.detail_id), Number(targetDetail.id)); + assert.equal(Number(row.location_id), Number(targetDetail.location_id)); + assert.equal(row.location_code, targetDetail.location_code); + assert.ok(row.location_name, '应输出库位名称'); + assert.equal(row.status, 'checked'); + assert.equal(row.has_unknown, false); + assert.equal(row.is_empty, false); + assert.equal(row.goods.length, 1, 'goods 应含已盘商品'); + assert.equal(Number(row.goods[0].record_id), Number(reported.record.id)); + assert.ok(row.checkers.includes(TEST_CREATOR_NAME)); + assert.ok(row.checked_at); + + // 与 workData 列表对应行逐字段一致 + const listData = await workDataCheck(check.id, 'location'); + const listRow = listData.rows.find(item => Number(item.detail_id) === Number(targetDetail.id)); + assert.deepEqual(row, listRow, 'workDataDetail 单行应与 workData 列表对应行一致'); + + // 未盘明细 → unchecked 空行 + const emptyRow = await workDataDetailCheck(emptyDetail.id); + assert.equal(emptyRow.status, 'unchecked'); + assert.deepEqual(emptyRow.goods, []); + assert.deepEqual(emptyRow.checkers, []); + assert.equal(emptyRow.checked_at, null); + assert.equal(emptyRow.is_empty, false); + assert.equal(emptyRow.has_unknown, false); + }); + + it('workDataDetail 校验:明细ID非法/不存在/任务未审核均拒绝', async () => { + await assert.rejects(async () => workDataDetailCheck(null), /盘点明细ID不能为空/); + await assert.rejects(async () => workDataDetailCheck(999999999), /盘点明细不存在/); + + // 任务未审核 → 状态校验拒绝 + const check2 = await createCheck({ type: 'location' }); + const locDetails = await addLocationDetail(check2.id, [ TEST_LOCATION_CODE ]); + assert.ok(locDetails, '前置:应成功添加库位明细'); + const pendingDetails = await detailCheck(check2.id); + await assert.rejects( + async () => workDataDetailCheck(pendingDetails.rows[0].id), + /仅审核完成(approved)或盘点作业中(checking)/ + ); + }); + + it('workDataDetail goods 分支:商品明细返回单行(结构同 goods 视图行),与 location 分支结构对称', async () => { + const check = await createCheck({ type: 'goods' }); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const targetDetail = details.rows[0]; + const snapshot = Number(targetDetail.system_quantity); + + // 上报:盘盈 2 + await reportCheck(check.id, targetDetail.id, snapshot + 2, TEST_LOCATION_CODE); + + const row = await workDataDetailCheck(targetDetail.id); + assert.equal(row.view, undefined, '应直接返回单行对象,不做 view/rows 包装'); + assert.equal(row.rows, undefined, '不应返回 rows 数组'); + assert.equal(Number(row.detail_id), Number(targetDetail.id)); + assert.equal(Number(row.stock_id), Number(targetDetail.stock_id)); + assert.ok(row.item_code !== undefined, '应含商品编码'); + assert.ok(row.item_name !== undefined, '应含商品名称'); + assert.equal(Number(row.system_quantity), snapshot, '账面应为明细快照'); + assert.equal(Number(row.checked_quantity), snapshot + 2, '已盘应为实盘合计'); + assert.equal(Number(row.diff_quantity), 2, '差异应为实盘-账面'); + assert.equal(Number(row.is_diff), 1); + assert.ok(Array.isArray(row.images), '应含商品图片数组'); + assert.ok(Array.isArray(row.locations), '应含商品所在库位列表'); + const checkedLocation = row.locations.find(loc => String(loc.location_code) === TEST_LOCATION_CODE); + assert.ok(checkedLocation, '已盘库位应出现在 locations'); + assert.equal(Number(checkedLocation.quantity), snapshot + 2, '已盘库位实盘应与上报一致'); + assert.equal(typeof checkedLocation.system_quantity, 'number', '明盘已盘库位应含账面数量'); + assert.equal(typeof checkedLocation.locked_quantity, 'number', '明盘已盘库位应含锁定数量'); + assert.ok(checkedLocation.checked_at, '已盘库位应有上报时间'); + assert.ok( + row.locations.some(loc => !loc.checked_at), + '未盘库位 checked_at 应为 null(商品所在库位列表包含未盘库位)' + ); + + // 与 workData goods 视图行交叉验证 + const goodsAll = await workDataCheck(check.id, { isGoods: true }); + const goodsRow = goodsAll.rows.find(item => Number(item.detail_id) === Number(targetDetail.id)); + assert.ok(goodsRow, 'goods 视图应含该明细行'); + assert.equal(Number(row.checked_quantity), Number(goodsRow.checked_quantity), '已盘合计应与 goods 视图一致'); + assert.equal(Number(row.diff_quantity), Number(goodsRow.diff_quantity), '差异应与 goods 视图一致'); + }); + + it('workDataDetail goods 分支盲盘:不返回数量字段,行信息仍输出', async () => { + const check = await createCheck({ type: 'goods', mode: 'blind' }); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const targetDetail = details.rows[0]; + await reportCheck(check.id, targetDetail.id, 6, TEST_LOCATION_CODE); + + const row = await workDataDetailCheck(targetDetail.id); + assert.equal(row.view, undefined, '应直接返回单行对象'); + assert.equal( + Object.prototype.hasOwnProperty.call(row, 'system_quantity'), + false, + '盲盘不应含账面快照' + ); + assert.equal( + Object.prototype.hasOwnProperty.call(row, 'checked_quantity'), + false, + '盲盘不应含已盘数量' + ); + assert.equal( + Object.prototype.hasOwnProperty.call(row, 'diff_quantity'), + false, + '盲盘不应含差异数量' + ); + assert.ok(row.locations.length >= 1, 'locations 应包含商品所在库位'); + for (const location of row.locations) { + assert.equal( + Object.prototype.hasOwnProperty.call(location, 'quantity'), + false, + '盲盘库位不应含数量' + ); + assert.equal( + Object.prototype.hasOwnProperty.call(location, 'system_quantity'), + false, + '盲盘库位不应含账面数量' + ); + assert.equal( + Object.prototype.hasOwnProperty.call(location, 'locked_quantity'), + false, + '盲盘库位不应含锁定数量' + ); + } + }); + + it('location 视图:已盘/未盘 status、checkers 合并去重、checked_at 取最近、goods.quantity 为最新覆盖值', async () => { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_LOCATION_CODE, TEST_EMPTY_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const checkedDetail = details.rows.find(row => row.location_code === TEST_LOCATION_CODE); + const uncheckedDetail = details.rows.find(row => row.location_code === TEST_EMPTY_LOCATION_CODE); + assert.ok(checkedDetail && uncheckedDetail, '前置:两条库位范围行均应存在'); + + const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 2); + assert.ok(stockIds.length >= 2, '固定测试库位应存在至少两个商品库存(真实数据依赖)'); + await reportCheck(check.id, checkedDetail.id, 3, undefined, { stockId: stockIds[0], checkerName: '盘点人A' }); + await reportCheck(check.id, checkedDetail.id, 5, undefined, { stockId: stockIds[1], checkerName: '盘点人B' }); + // 覆盖式上报:同商品再报,goods.quantity 应为最新值 + await reportCheck(check.id, checkedDetail.id, 9, undefined, { stockId: stockIds[0], checkerName: '盘点人A' }); + + const data = await workDataCheck(check.id, 'location'); + + const checkedRow = data.rows.find(row => Number(row.detail_id) === Number(checkedDetail.id)); + const uncheckedRow = data.rows.find(row => Number(row.detail_id) === Number(uncheckedDetail.id)); + assert.equal(checkedRow.status, 'checked', '有作业记录的库位行应输出已盘'); + assert.deepEqual(checkedRow.checkers, [ '盘点人A', '盘点人B' ], '盘点人应按记录顺序合并去重'); + assert.ok(checkedRow.checked_at, '已盘行应输出最近盘点时间'); + assert.equal(checkedRow.has_unknown, false); + + const goodsByStock = new Map(checkedRow.goods.map(item => [ Number(item.stock_id), item ])); + assert.equal(checkedRow.goods.length, 2, 'goods 应含两个已盘商品'); + assert.equal(goodsByStock.get(stockIds[0]).quantity, 9, '覆盖更新后 quantity 应为最新值'); + assert.equal(goodsByStock.get(stockIds[1]).quantity, 5); + assert.equal(goodsByStock.get(stockIds[0]).checker_name, '盘点人A'); + + const records = await queryRecords(check.id, checkedDetail.id); + const latestCheckedAt = records.reduce((latest, record) => { + const timestamp = new Date(record.checked_at).getTime(); + return latest === null || timestamp > latest ? timestamp : latest; + }, null); + assert.equal( + new Date(checkedRow.checked_at).getTime(), + latestCheckedAt, + 'checked_at 应为该库位最近一条记录的上报时间' + ); + + assert.equal(uncheckedRow.status, 'unchecked', '无作业记录的库位行应输出未盘'); + assert.equal(uncheckedRow.checked_at, null); + assert.deepEqual(uncheckedRow.checkers, []); + assert.deepEqual(uncheckedRow.goods, []); + assert.equal(uncheckedRow.has_unknown, false); + }); + + it('location 视图 goods 子项:商品信息/货主名/条码/商品图片与 getStockDetails 交叉验证', async () => { + const { check, detail } = await createApprovedLocationCheck(); + // 取一个有效的库存商品(跳过已从库存表删除的商品) + const storageStockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 5); + let stockId = null; + for (const candidate of storageStockIds) { + const valid = await ctx.model.StockWarehouse.findOne({ + where: { id: candidate, warehouse_id: TEST_WAREHOUSE_ID, is_valid: 'Y' }, + attributes: [ 'id' ], + raw: true, + }); + if (valid) { + stockId = candidate; + break; + } + } + assert.ok(stockId, '前置:固定测试库位应存在有效库存商品'); + + const reported = await reportCheck(check.id, detail.id, 7, undefined, { stockId }); + const stockDetail = (await ctx.service.systems.stockWarehouse.getStockDetails([ stockId ], { + warehouseId: TEST_WAREHOUSE_ID, + }))[0]; + assert.ok(stockDetail, '前置:商品详情应可查询'); + + const data = await workDataCheck(check.id, 'location'); + const goods = data.rows[0].goods; + assert.equal(goods.length, 1, 'goods 应只含已盘商品'); + const item = goods[0]; + assert.equal(Number(item.record_id), Number(reported.record.id), 'goods 子项应关联作业记录'); + assert.equal(Number(item.stock_id), stockId); + assert.equal(item.item_code, stockDetail.item_code || null); + assert.equal(item.item_name, stockDetail.item_name || null); + assert.equal(item.barcode, (stockDetail.barcodes[0] && stockDetail.barcodes[0].barcode) || null); + assert.deepEqual(item.images, stockDetail.image_url || [], 'goods 图片应挂载商品图片列表'); + assert.equal(Number(item.store_id), Number(stockDetail.store_id) || 0); + assert.equal(item.store_name, await resolveStoreName(Number(stockDetail.store_id)), '货主名应为合约备注优先、公司名兜底'); + assert.equal(item.quantity, 7, '实盘数量应与上报一致'); + assert.equal(item.checker_name, TEST_CREATOR_NAME); + assert.ok(item.checked_at, '应输出上报时间'); + }); + + it('location 视图 goods 子项:未知商品也并入 goods(stock_id=null 输出记录快照)+ 记录图片挂载 + has_unknown 标记', async () => { + const { check, detail } = await createApprovedLocationCheck(); + const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 1); + const knownReport = await reportCheck(check.id, detail.id, 4, undefined, { stockId: stockIds[0] }); + const unknownBarcode = uniqueTitle('WORKDATA-UNKNOWN'); + const unknownReport = await reportCheck(check.id, detail.id, 7, undefined, { + barcode: unknownBarcode, + itemName: '未知商品快照名称', + }); + const { file } = await createRecordImage(Number(unknownReport.record.id)); + + const data = await workDataCheck(check.id, 'location'); + const row = data.rows[0]; + + assert.equal(row.has_unknown, true, '存在未知商品记录应标记 has_unknown'); + assert.equal(row.goods.length, 2, '已知商品与未知商品均应进入 goods 子列表'); + const knownGoods = row.goods.find(item => Number(item.record_id) === Number(knownReport.record.id)); + assert.ok(knownGoods, '已知商品应在 goods 子列表'); + assert.ok(Number(knownGoods.stock_id) > 0, '已知商品 stock_id 应为正整数'); + + const unknownGoods = row.goods.find(item => Number(item.record_id) === Number(unknownReport.record.id)); + assert.ok(unknownGoods, '未知商品应在 goods 子列表'); + assert.equal(unknownGoods.stock_id, null, '未知商品 stock_id 应为 null'); + assert.equal(unknownGoods.item_code, unknownBarcode, '未知商品编码列应兑底扫描条码'); + assert.equal(unknownGoods.barcode, unknownBarcode); + assert.equal(unknownGoods.item_name, '未知商品快照名称', '未知商品名称应为上报快照'); + assert.equal(unknownGoods.quantity, 7); + assert.equal(unknownGoods.checker_name, TEST_CREATOR_NAME); + assert.ok(unknownGoods.checked_at, '应输出上报时间'); + assert.deepEqual(unknownGoods.images, [{ id: file.id, url: file.file_url }], '未知商品图片应挂载记录图片'); + }); + + it('库位模式空库位标记:is_empty 上报 → 记录落库 is_empty=1、location 视图行 is_empty=true/goods=[]、计入已盘', async () => { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_EMPTY_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const result = await reportCheck(check.id, details.rows[0].id, 0, undefined, { is_empty: true }); + + assert.equal(result.record.is_empty, true, '空标记记录 is_empty 应为 true'); + assert.equal(result.record.stock_id, null); + assert.equal(result.record.barcode, null); + assert.equal(result.record.quantity, 0); + assert.equal(result.checked_items, 1, '空标记应计入已盘'); + assert.equal(result.diff_items, 0, '账面无库存库位标记空应无差异'); + assert.equal(result.detail_status, 'all_checked'); + + const data = await workDataCheck(check.id); + const row = data.rows[0]; + assert.equal(row.is_empty, true, 'location 行应输出 is_empty 标记'); + assert.equal(row.status, 'checked', '空库位标记后应视为已盘点'); + assert.deepEqual(row.goods, [], '空库位 goods 应为空'); + assert.equal(row.has_unknown, false); + assert.ok(row.checkers.includes(TEST_CREATOR_NAME), '空库位盘点人应计入 checkers'); + }); + + it('空库位标记与商品记录互斥:标记空清商品记录,再上报商品清空标记', async () => { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 1); + await reportCheck(check.id, details.rows[0].id, 3, undefined, { stockId: stockIds[0] }); + + // 标记空 → 商品记录被清除,仅剩空标记记录 + await reportCheck(check.id, details.rows[0].id, 0, undefined, { is_empty: true }); + const afterEmpty = await queryRecords(check.id, details.rows[0].id); + assert.equal(afterEmpty.length, 1, '标记空后应仅剩一条空标记记录'); + assert.equal(Number(afterEmpty[0].is_empty), 1, '空标记记录 is_empty 应为 1'); + + // 再上报商品 → 空标记被清除,仅剩商品记录 + const result = await reportCheck(check.id, details.rows[0].id, 5, undefined, { stockId: stockIds[0] }); + const afterGoods = await queryRecords(check.id, details.rows[0].id); + assert.equal(afterGoods.length, 1, '上报商品后应仅剩一条商品记录'); + assert.equal(Number(afterGoods[0].is_empty), 0); + assert.equal(Number(afterGoods[0].stock_id), stockIds[0]); + const data = await workDataCheck(check.id); + assert.equal(data.rows[0].is_empty, false, '再上报商品后行级 is_empty 应为 false'); + assert.equal(result.detail_status, 'all_checked'); + }); + + it('有账面库存的库位标记空 → 盘亏差异(主表 diff_items=1、result 库位行差异为负)', async () => { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const result = await reportCheck(check.id, details.rows[0].id, 0, undefined, { is_empty: true }); + assert.equal(result.diff_items, 1, '账面有库存的库位标记空应计盘亏差异'); + + const agg = await resultCheck(check.id); + const row = agg.rows[0]; + assert.equal(row.is_empty, true); + assert.equal(row.is_diff, 1); + assert.ok(Number(row.diff_quantity) < 0, '盘亏差异应为负数'); + assert.equal(row.status, 'checked'); + assert.deepEqual(row.stocks, [], '空库位行 stocks 应为空'); + assert.deepEqual(row.unknown_items, [], '空库位行 unknown_items 应为空'); + }); + + it('商品明细行传 is_empty → 400(仅库位盘点明细支持空库位标记)', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + await assert.rejects(async () => { + await reportCheck(check.id, details.rows[0].id, 0, undefined, { is_empty: true }); + }, error => error.code === 400 && /仅库位盘点明细支持空库位标记/.test(error.message)); + }); + + it('markEmpty:库位任务标记空成功(记录/汇总/视图一致)', async () => { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_EMPTY_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const result = await ctx.service.systems.stockCheck.markEmpty({ + warehouseId: TEST_WAREHOUSE_ID, + id: check.id, + detailId: details.rows[0].id, + }); + + assert.equal(result.record.is_empty, true, '应写入空标记记录'); + assert.equal(result.checked_items, 1); + assert.equal(result.detail_status, 'all_checked'); + + const data = await workDataCheck(check.id); + assert.equal(data.rows[0].is_empty, true); + assert.equal(data.rows[0].status, 'checked'); + }); + + it('markEmpty:非库位任务(商品任务)→ 400 仅库位盘点任务支持空库位标记', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + await assert.rejects(async () => { + await ctx.service.systems.stockCheck.markEmpty({ + warehouseId: TEST_WAREHOUSE_ID, + id: check.id, + detailId: details.rows[0].id, + }); + }, error => error.code === 400 && /仅库位盘点任务支持空库位标记/.test(error.message)); + }); + + it('markEmpty:状态不允许(created)→ 400 当前状态不允许盘点作业', async () => { + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); + const details = await detailCheck(check.id); + + await assert.rejects(async () => { + await ctx.service.systems.stockCheck.markEmpty({ + warehouseId: TEST_WAREHOUSE_ID, + id: check.id, + detailId: details.rows[0].id, + }); + }, error => error.code === 400 && /不允许盘点作业/.test(error.message)); + }); + + it('workData 挂载作业照片与 record_ids:location goods 子项 / goods locations 项 / space goods 项', async () => { + // location 视图:已知商品 goods 子项挂记录图片(FileReference) + const { check: locationCheck, detail: locationDetail } = await createApprovedLocationCheck(); + const locationStocks = await fetchStorageStockIds(TEST_LOCATION_ID, 1); + const locationReport = await reportCheck(locationCheck.id, locationDetail.id, 3, undefined, { stockId: locationStocks[0] }); + const { file: locationImage } = await createRecordImage(Number(locationReport.record.id)); + + const locationData = await workDataCheck(locationCheck.id); + const locationGoods = locationData.rows[0].goods[0]; + assert.equal(Number(locationGoods.record_id), Number(locationReport.record.id), 'location goods 子项应含 record_id'); + assert.deepEqual( + locationGoods.images, + [{ id: Number(locationImage.id), url: locationImage.file_url }], + 'location goods 子项应挂作业照片(记录图片)' + ); + + // goods/space 视图:locations/goods 子项输出 record_ids 与作业照片(供编辑移除) + const pairs = await fetchSpaceStockPairs(1); + const goodsCheck = await createCheck(); + await addDetail(goodsCheck.id, [ pairs[0].stockId ]); + await submitCheck(goodsCheck.id); + await auditCheck(goodsCheck.id, 'approve'); + const details = await detailCheck(goodsCheck.id); + const goodsReport = await reportCheck(goodsCheck.id, details.rows[0].id, 5, pairs[0].spaceCode); + const { file: goodsImage } = await createRecordImage(Number(goodsReport.record.id)); + + const goodsData = await workDataCheck(goodsCheck.id, { isGoods: true }); + const locationItem = goodsData.rows[0].locations[0]; + assert.deepEqual(locationItem.record_ids.map(Number), [ Number(goodsReport.record.id) ], 'goods 视图 locations 项应含 record_ids'); + assert.deepEqual(locationItem.images, [{ id: Number(goodsImage.id), url: goodsImage.file_url }], 'goods 视图 locations 项应挂作业照片'); + + const spaceData = await workDataCheck(goodsCheck.id); + const spaceGoods = spaceData.rows[0].goods[0]; + assert.deepEqual(spaceGoods.record_ids.map(Number), [ Number(goodsReport.record.id) ], 'space 视图 goods 子项应含 record_ids'); + assert.deepEqual(spaceGoods.images, [{ id: Number(goodsImage.id), url: goodsImage.file_url }], 'space 视图 goods 子项应挂作业照片'); + }); + + it('goods 视图明盘:system_quantity/checked_quantity/diff_quantity/is_diff/locations.quantity 与 result 交叉验证', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const firstDetail = details.rows[0]; + const secondDetail = details.rows[1]; + const snapshot = Number(firstDetail.system_quantity); + + await reportCheck(check.id, firstDetail.id, snapshot + 2, TEST_LOCATION_CODE, { checkerName: '盘点人A' }); + await reportCheck(check.id, firstDetail.id, 4, TEST_LOCATION_CODE_2, { checkerName: '盘点人B' }); + + const data = await workDataCheck(check.id, { isGoods: true }); + + assert.equal(data.total, 2); + + const firstRow = data.rows.find(row => Number(row.detail_id) === Number(firstDetail.id)); + assert.equal(Number(firstRow.system_quantity), snapshot, '账面应来自明细快照'); + assert.equal(firstRow.checked_quantity, snapshot + 6, '已盘合计应为多库位实盘之和'); + assert.equal(firstRow.diff_quantity, 6, '差异=已盘合计-账面快照'); + assert.equal(firstRow.is_diff, 1); + const quantityByCode = new Map(firstRow.locations.map(item => [ item.location_code, Number(item.quantity) ])); + assert.equal(quantityByCode.get(TEST_LOCATION_CODE), snapshot + 2, '已盘库位实盘应与上报一致'); + assert.equal(quantityByCode.get(TEST_LOCATION_CODE_2), 4, '已盘库位实盘应与上报一致'); + const checkedLocationA = firstRow.locations.find(item => item.location_code === TEST_LOCATION_CODE); + const checkedLocationB = firstRow.locations.find(item => item.location_code === TEST_LOCATION_CODE_2); + assert.equal(checkedLocationA.checker_name, '盘点人A'); + assert.equal(checkedLocationB.checker_name, '盘点人B'); + assert.ok(checkedLocationA.checked_at && checkedLocationB.checked_at); + assert.equal(typeof checkedLocationA.system_quantity, 'number', '明盘已盘库位应含账面数量'); + assert.equal(typeof checkedLocationB.system_quantity, 'number', '明盘已盘库位应含账面数量'); + assert.equal(typeof checkedLocationA.locked_quantity, 'number', '明盘已盘库位应含锁定数量'); + assert.equal(typeof checkedLocationB.locked_quantity, 'number', '明盘已盘库位应含锁定数量'); + + // 与 result 聚合交叉验证:checked_quantity/diff_quantity/is_diff 口径一致 + const result = await resultCheck(check.id); + const resultFirst = result.rows.find(row => Number(row.id) === Number(firstDetail.id)); + assert.equal(firstRow.checked_quantity, resultFirst.checked_quantity); + assert.equal(firstRow.diff_quantity, resultFirst.diff_quantity); + assert.equal(firstRow.is_diff, resultFirst.is_diff); + + // 未盘行:明盘按 0 处理、locations 为商品所在库位列表(无作业信息) + const secondRow = data.rows.find(row => Number(row.detail_id) === Number(secondDetail.id)); + assert.equal(Number(secondRow.system_quantity), Number(secondDetail.system_quantity)); + assert.equal(secondRow.checked_quantity, 0); + assert.equal(secondRow.diff_quantity, 0); + assert.equal(secondRow.is_diff, 0); + assert.ok(Array.isArray(secondRow.locations), '未盘行 locations 应为数组(商品所在库位列表)'); + for (const location of secondRow.locations) { + assert.equal(location.checked_at, null, '未盘库位 checked_at 应为 null'); + assert.equal(Number(location.quantity), 0, '未盘库位实盘应为 0'); + assert.equal(typeof location.system_quantity, 'number', '明盘未盘库位应含账面数量'); + assert.equal(typeof location.locked_quantity, 'number', '明盘未盘库位应含锁定数量'); + } + }); + + it('goods 视图:商品信息/store_name/barcode/images 挂载(未盘行 locations=商品所在库位列表、明盘零差异)', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const stockDetails = await ctx.service.systems.stockWarehouse.getStockDetails( + stocks.map(stock => stock.id), + { warehouseId: TEST_WAREHOUSE_ID } + ); + + const data = await workDataCheck(check.id, { isGoods: true }); + assert.equal(data.total, 2); + + for (const row of data.rows) { + const detail = details.rows.find(item => Number(item.id) === Number(row.detail_id)); + const stockDetail = stockDetails.find(item => Number(item.id) === Number(row.stock_id)); + assert.ok(stockDetail, '前置:商品详情应可查询'); + assert.equal(row.item_code, stockDetail.item_code || detail.item_code || null); + assert.equal(row.item_name, stockDetail.item_name || detail.item_name || null); + assert.equal(row.spec, (stockDetail.sku_property || detail.spec) || null); + assert.equal(Number(row.store_id), Number(stockDetail.store_id) || 0); + assert.equal(row.store_name, await resolveStoreName(Number(row.store_id))); + assert.equal(row.barcode, (stockDetail.barcodes[0] && stockDetail.barcodes[0].barcode) || null); + assert.deepEqual(row.images, stockDetail.image_url || [], 'images 应挂载商品图片列表'); + + // 未盘行 locations = 商品所在全部库位(wms_storage,与业务口径一致排除无头库位),每库位无作业信息、实盘 0 + const storageRows = await ctx.model.Storage.findAll({ + where: { + stock_id: Number(row.stock_id), + warehouse_id: TEST_WAREHOUSE_ID, + is_enabled: 1, + space_id: { [ctx.app.Sequelize.Op.in]: ctx.app.Sequelize.literal(VALID_SPACE_SQL) }, + }, + attributes: [ 'space_id' ], + raw: true, + }); + // 有效库位数:storage 行中能在库位表查到(有 space_code)的库位 + const storageSpaceIds = [ ...new Set(storageRows.map(item => Number(item.space_id)).filter(id => id > 0)) ]; + let validSpaceCount = 0; + if (storageSpaceIds.length > 0) { + const spaceRows = await ctx.model.LocationSpace.findAll({ + where: { id: { [ctx.app.Sequelize.Op.in]: storageSpaceIds } }, + attributes: [ 'id' ], + raw: true, + }); + validSpaceCount = spaceRows.length; + } + assert.ok( + row.locations.length >= validSpaceCount, + '未盘行 locations 应包含商品所在全部库位' + ); + for (const location of row.locations) { + assert.equal(location.checked_at, null, '未盘库位 checked_at 应为 null'); + assert.deepEqual(location.record_ids, [], '未盘库位 record_ids 应为空数组'); + assert.equal(Number(location.quantity), 0, '未盘库位实盘应为 0'); + assert.equal(typeof location.system_quantity, 'number', '明盘未盘库位应含账面数量'); + assert.equal(typeof location.locked_quantity, 'number', '明盘未盘库位应含锁定数量'); + // locations 应回传库位ID(供调用方直接回传 stock.check.report 的 location_id) + assert.ok( + Number(location.location_id) > 0, + 'locations 应含有效库位ID(location_id)' + ); + if (location.location_code) { + const spaceRow = await ctx.model.LocationSpace.findOne({ + where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: location.location_code }, + order: [[ 'id', 'ASC' ]], + attributes: [ 'id' ], + raw: true, + }); + assert.equal(Number(location.location_id), Number(spaceRow.id), 'location_id 应与库位编码对应'); + } + } + assert.equal(Number(row.system_quantity), Number(detail.system_quantity), '账面应为明细快照'); + assert.equal(row.checked_quantity, 0); + assert.equal(row.diff_quantity, 0); + assert.equal(row.is_diff, 0); + } + }); + + it('goods 视图盲盘:不含任何数量字段(system_quantity/checked_quantity/diff_quantity/is_diff 与 locations.quantity)', async () => { + const check = await createCheck({ mode: 'blind' }); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + await reportCheck(check.id, details.rows[0].id, 5, TEST_LOCATION_CODE); + await reportCheck(check.id, details.rows[0].id, 3, TEST_LOCATION_CODE_2); + + const data = await workDataCheck(check.id, { isGoods: true }); + const row = data.rows[0]; + assert.ok(row.locations.length >= 2, 'locations 应包含商品所在库位与已盘库位'); + const checkedCodes = [ TEST_LOCATION_CODE, TEST_LOCATION_CODE_2 ]; + for (const code of checkedCodes) { + const location = row.locations.find(item => String(item.location_code) === code); + assert.ok(location, `已盘库位 ${code} 应出现在 locations`); + assert.ok(location.checked_at, `已盘库位 ${code} 应有上报时间`); + } + assert.ok( + row.locations.some(location => !location.checked_at), + '未盘库位 checked_at 应为 null' + ); + for (const key of [ 'system_quantity', 'checked_quantity', 'diff_quantity', 'is_diff' ]) { + assert.equal( + Object.prototype.hasOwnProperty.call(row, key), + false, + `盲盘行不应包含数量字段 ${key}` + ); + } + for (const location of row.locations) { + assert.equal( + Object.prototype.hasOwnProperty.call(location, 'quantity'), + false, + '盲盘 locations 不应包含 quantity' + ); + assert.equal( + Object.prototype.hasOwnProperty.call(location, 'system_quantity'), + false, + '盲盘 locations 不应包含账面数量' + ); + assert.equal( + Object.prototype.hasOwnProperty.call(location, 'locked_quantity'), + false, + '盲盘 locations 不应包含锁定数量' + ); + assert.ok(location.location_code, '盲盘仍应输出库位编码'); + } + }); + + it('space 视图:库位聚合与 wms_storage 一致、按拣货路径排序(pick_sequence/pick_priority/id 兜底)', async () => { + const pairs = await fetchSpaceStockPairs(3); + const check = await createCheck(); + await addDetail(check.id, pairs.map(pair => pair.stockId)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const data = await workDataCheck(check.id, 'space'); + const returnedIds = data.rows.map(row => Number(row.id)); + + assert.deepEqual( + [ ...returnedIds ].sort((left, right) => left - right), + pairs.map(pair => pair.spaceId).sort((left, right) => left - right), + '聚合库位集合应与任务商品所在库位(wms_storage)一致' + ); + for (const pair of pairs) { + const row = data.rows.find(item => Number(item.id) === pair.spaceId); + assert.ok(row, `任务商品所在库位 ${pair.spaceId} 应出现在聚合列表`); + assert.equal(row.space_code, pair.spaceCode || null, '库位编码应来自库位表'); + assert.equal(row.custom_name, pair.customName || null, '库位名称应为库位表 custom_name 原值'); + assert.equal(row.goods.length, 1, '该库位仅一个任务商品,goods 应恰好一条'); + assert.equal(Number(row.goods[0].stock_id), pair.stockId, '库位行应挂载该库位的任务商品'); + } + + // 排序口径:pick_sequence 升序、pick_priority 降序、同值按库位 id 升序兜底(与实现一致) + const { Op } = ctx.app.Sequelize; + const locationRows = await ctx.model.LocationSpace.findAll({ + where: { id: { [Op.in]: returnedIds } }, + attributes: [ 'id', 'pick_sequence', 'pick_priority' ], + raw: true, + }); + const locationById = new Map(locationRows.map(row => [ Number(row.id), row ])); + const expectedIds = [ ...returnedIds ].sort((left, right) => { + const leftRow = locationById.get(left) || {}; + const rightRow = locationById.get(right) || {}; + const sequenceDiff = Number(leftRow.pick_sequence || 0) - Number(rightRow.pick_sequence || 0); + if (sequenceDiff !== 0) { + return sequenceDiff; + } + const priorityDiff = Number(rightRow.pick_priority || 0) - Number(leftRow.pick_priority || 0); + if (priorityDiff !== 0) { + return priorityDiff; + } + return left - right; + }); + assert.deepEqual(returnedIds, expectedIds, 'space 视图应按拣货路径排序'); + }); + + it('space 视图明盘:库位账面=wms_storage SUM、已盘=该库位实盘合计、status 已盘/未盘', async () => { + const pairs = await fetchSpaceStockPairs(2); + const check = await createCheck(); + await addDetail(check.id, pairs.map(pair => pair.stockId)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const reported = pairs[0]; + const reportedDetail = details.rows.find(row => Number(row.stock_id) === reported.stockId); + const reportedQuantity = reported.book + 2; + await reportCheck(check.id, reportedDetail.id, reportedQuantity, reported.spaceCode); + + const data = await workDataCheck(check.id, 'space'); + + const reportedRow = data.rows.find(row => Number(row.id) === reported.spaceId); + assert.ok(reportedRow, '已盘库位应出现在聚合列表'); + assert.equal(reportedRow.goods.length, 1); + const reportedGoods = reportedRow.goods[0]; + assert.equal(Number(reportedGoods.detail_id), Number(reportedDetail.id)); + assert.equal(Number(reportedGoods.stock_id), reported.stockId); + assert.equal(Number(reportedGoods.system_quantity), reported.book, '库位账面应为 wms_storage SUM(可用+锁定)'); + assert.equal(Number(reportedGoods.locked_quantity), reported.bookLocked, '库位锁定数量应为 wms_storage SUM(locked_quantity)'); + assert.equal(Number(reportedGoods.checked_quantity), reportedQuantity, '已盘应为该库位实盘合计'); + assert.equal(reportedGoods.status, 'checked'); + + const unreported = pairs[1]; + const unreportedRow = data.rows.find(row => Number(row.id) === unreported.spaceId); + assert.ok(unreportedRow, '未盘库位应出现在聚合列表'); + assert.equal(unreportedRow.goods.length, 1); + const unreportedGoods = unreportedRow.goods[0]; + assert.equal(Number(unreportedGoods.system_quantity), unreported.book); + assert.equal(Number(unreportedGoods.locked_quantity), unreported.bookLocked, '未盘库位锁定数量也应输出'); + assert.equal(Number(unreportedGoods.checked_quantity), 0, '未盘库位已盘数量应为 0'); + assert.equal(unreportedGoods.status, 'unchecked'); + }); + + it('space 视图盲盘:不返回数量字段、status 与库位信息仍输出', async () => { + const pairs = await fetchSpaceStockPairs(2); + const check = await createCheck({ mode: 'blind' }); + await addDetail(check.id, pairs.map(pair => pair.stockId)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const reportedDetail = details.rows.find(row => Number(row.stock_id) === pairs[0].stockId); + await reportCheck(check.id, reportedDetail.id, 6, pairs[0].spaceCode); + + const data = await workDataCheck(check.id, 'space'); + + const reportedRow = data.rows.find(row => Number(row.id) === pairs[0].spaceId); + const unreportedRow = data.rows.find(row => Number(row.id) === pairs[1].spaceId); + assert.ok(reportedRow && unreportedRow, '两个库位均应出现在聚合列表'); + for (const [ row, pair ] of [[ reportedRow, pairs[0] ], [ unreportedRow, pairs[1] ]]) { + assert.equal(row.space_code, pair.spaceCode || null); + assert.equal(row.custom_name, pair.customName || null); + assert.equal(row.goods.length, 1); + const goods = row.goods[0]; + assert.equal(Number(goods.stock_id), pair.stockId); + assert.equal( + Object.prototype.hasOwnProperty.call(goods, 'system_quantity'), + false, + '盲盘不应包含库位账面' + ); + assert.equal( + Object.prototype.hasOwnProperty.call(goods, 'locked_quantity'), + false, + '盲盘不应包含库位锁定数量' + ); + assert.equal( + Object.prototype.hasOwnProperty.call(goods, 'checked_quantity'), + false, + '盲盘不应包含已盘数量' + ); + assert.ok(goods.status, '盲盘仍应输出已盘/未盘状态'); + } + assert.equal(reportedRow.goods[0].status, 'checked'); + assert.equal(unreportedRow.goods[0].status, 'unchecked'); + }); + + it('视图驱动规则:库位任务一律 location(无视 is_goods/view)、商品任务默认 space、is_goods=true 才 goods', async () => { + // 库位任务:传 is_goods=true 仍返回 location 视图行(库位范围行) + const { check: locationCheck } = await createApprovedLocationCheck(); + const locRows = await workDataCheck(locationCheck.id, { isGoods: true }); + assert.equal(locRows.view, 'location', '库位任务无视 is_goods,view 应为 location'); + assert.equal(locRows.total, 1, '库位任务应返回库位范围行'); + assert.ok(locRows.rows.every(row => row.location_id !== undefined), 'location 视图行应含 location_id'); + + // 商品任务:默认(不传 is_goods)→ space 聚合库位视图 + const pairs = await fetchSpaceStockPairs(2); + const goodsCheck = await createCheck(); + await addDetail(goodsCheck.id, pairs.map(pair => pair.stockId)); + await submitCheck(goodsCheck.id); + await auditCheck(goodsCheck.id, 'approve'); + + const defaultView = await workDataCheck(goodsCheck.id); + assert.equal(defaultView.view, 'space', '商品任务默认 view 应为 space'); + assert.equal(defaultView.total, 2, '商品任务默认应返回聚合库位视图'); + assert.ok(defaultView.rows.every(row => row.space_code !== undefined), 'space 视图行应含 space_code'); + + // 商品任务:is_goods=true → goods 商品视图(明细行) + const goodsView = await workDataCheck(goodsCheck.id, { isGoods: true }); + assert.equal(goodsView.view, 'goods', 'is_goods=true 时 view 应为 goods'); + assert.equal(goodsView.total, 2); + assert.ok(goodsView.rows.every(row => row.stock_id !== undefined), 'goods 视图行应含 stock_id'); + + // view 入参已废弃:库位任务传 view='space' 仍返回 location 行 + const viewIgnored = await workDataCheck(locationCheck.id, 'space'); + assert.equal(viewIgnored.view, 'location'); + assert.equal(viewIgnored.total, 1); + assert.ok(viewIgnored.rows.every(row => row.location_id !== undefined), 'view 入参被忽略,库位任务仍返回 location 行'); + }); + + it('is_goods 非 true(false/0/字符串/缺省)一律按默认聚合库位视图', async () => { + const pairs = await fetchSpaceStockPairs(1); + const check = await createCheck(); + await addDetail(check.id, [ pairs[0].stockId ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + for (const value of [ undefined, false, 0, 'false', '' ]) { + const data = await workDataCheck(check.id, { isGoods: value }); + assert.equal(data.view, 'space', `is_goods=${JSON.stringify(value)} 应按默认 space 返回`); + assert.equal(data.total, 1, `is_goods=${JSON.stringify(value)} 应按默认 space 返回`); + assert.ok(data.rows[0].space_code !== undefined, '非 true 值应按默认 space 视图返回'); + } + }); + + it('分页:rows 按页切片、total 为全量行数、page/pageSize 归一化(默认 20、上限 200、非法回退)', async () => { + const pairs = await fetchSpaceStockPairs(3); + const check = await createCheck(); + await addDetail(check.id, pairs.map(pair => pair.stockId)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const callWithPagination = pagination => ctx.service.systems.stockCheck.workData({ + warehouseId: TEST_WAREHOUSE_ID, + id: check.id, + view: 'space', + pagination, + }); + + // page=1 pageSize=2 → 2 行,total 仍为全量 3 + const firstPage = await callWithPagination({ page: 1, pageSize: 2 }); + assert.equal(firstPage.total, 3, 'total 应为全量行数(未分页口径)'); + assert.equal(firstPage.rows.length, 2, 'pageSize=2 应只返回 2 行'); + assert.equal(firstPage.page, 1); + assert.equal(firstPage.pageSize, 2); + + // page=2 pageSize=2 → 剩余 1 行,两页并集覆盖全量且不重叠 + const secondPage = await callWithPagination({ page: 2, pageSize: 2 }); + assert.equal(secondPage.rows.length, 1); + const pagedIds = [ + ...firstPage.rows.map(row => Number(row.id)), + ...secondPage.rows.map(row => Number(row.id)), + ].sort((left, right) => left - right); + assert.deepEqual( + pagedIds, + pairs.map(pair => pair.spaceId).sort((left, right) => left - right), + '两页并集应覆盖全量库位且不重叠' + ); + + // 不传分页 → 默认 page=1/pageSize=20,返回全量 + const defaultPage = await workDataCheck(check.id, 'space'); + assert.equal(defaultPage.total, 3); + assert.equal(defaultPage.rows.length, 3, '默认 pageSize=20 应返回全部 3 行'); + assert.equal(defaultPage.page, 1); + assert.equal(defaultPage.pageSize, 20); + + // 非法分页值(page=-1/pageSize=0)→ 回退默认 + const invalidPage = await callWithPagination({ page: -1, pageSize: 0 }); + assert.equal(invalidPage.page, 1); + assert.equal(invalidPage.pageSize, 20); + assert.equal(invalidPage.rows.length, 3); + + // pageSize 超上限 500 → 收敛到 200(本任务全量 3 行全部返回) + const hugePage = await callWithPagination({ page: 1, pageSize: 500 }); + assert.equal(hugePage.pageSize, 200); + assert.equal(hugePage.rows.length, 3); + + // 超出范围页 → rows 空、total 仍为全量 + const beyondPage = await callWithPagination({ page: 3, pageSize: 2 }); + assert.equal(beyondPage.total, 3); + assert.deepEqual(beyondPage.rows, [], '超出范围页应返回空行'); + }); + + it('400 边界:任务 ID 为空/非法(undefined/0/负数/非数字)', async () => { + const assertInvalidId = async badId => { + await assert.rejects(async () => { + await ctx.service.systems.stockCheck.workData({ + warehouseId: TEST_WAREHOUSE_ID, + id: badId, + }); + }, error => error.code === 400 && /任务ID不能为空/.test(error.message)); + }; + for (const badId of [ undefined, 0, -1, 'abc' ]) { + await assertInvalidId(badId); + } + }); + + it('400 边界:任务不存在', async () => { + const missingId = await findFreeCheckId(); + await assert.rejects(async () => { + await workDataCheck(missingId, 'goods'); + }, error => error.code === 400 && /任务不存在/.test(error.message)); + }); + + it('400 边界:其他仓库任务不可见(仓库隔离)', async () => { + const other = await createCheck({ warehouseId: OTHER_TEST_WAREHOUSE_ID }); + await assert.rejects(async () => { + await workDataCheck(other.id, 'goods'); + }, error => error.code === 400 && /任务不存在/.test(error.message)); + }); + + it('400 状态限制:created/submitted/cancelled 状态拉取作业数据均拒绝且 message 含状态说明', async () => { + const assertStatusRejected = async (checkId, label) => { + await assert.rejects(async () => { + await workDataCheck(checkId, 'goods'); + }, error => error.code === 400 + && /不允许拉取盘点作业数据/.test(error.message) + && /仅审核完成(approved)或盘点作业中(checking)的任务可拉取/.test(error.message) + && error.message.includes(`当前状态(${label})`)); + }; + + // created:任务创建(含明细)后未提交审核即拉取 + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await assertStatusRejected(check.id, '已创建'); + + // submitted:提交审核后(未审核)拉取 + await submitCheck(check.id); + await assertStatusRejected(check.id, '待审核'); + + // cancelled:取消任务后拉取 + await cancelCheck(check.id); + await assertStatusRejected(check.id, '已取消'); + }); + + it('400 状态限制:rejected 状态拉取作业数据 → 400 且 message 含状态说明', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'reject', '任务信息有误'); + await assert.rejects(async () => { + await workDataCheck(check.id, 'goods'); + }, error => error.code === 400 + && /不允许拉取盘点作业数据/.test(error.message) + && error.message.includes('当前状态(已驳回)')); + }); + + it('400 状态限制:completed 状态拉取作业数据 → 400 且 message 含状态说明', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + await finishCheck(check.id); + await assert.rejects(async () => { + await workDataCheck(check.id, 'goods'); + }, error => error.code === 400 + && /不允许拉取盘点作业数据/.test(error.message) + && error.message.includes('当前状态(已完成)')); + }); + + it('workDataSpaceDetails:传入 location_id 只返回该库位行(total=1,结构与 space 视图一致)', async () => { + const pairs = await fetchSpaceStockPairs(2); + const check = await createCheck(); + await addDetail(check.id, pairs.map(pair => pair.stockId)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const target = pairs[0]; + const data = await ctx.service.systems.stockCheck.workDataSpaceDetails({ + warehouseId: TEST_WAREHOUSE_ID, + id: check.id, + locationId: target.spaceId, + }); + + assert.equal(data.view, 'space', 'view 应恒为 space'); + assert.equal(data.total, 1, '传入库位ID时应只返回该库位'); + assert.equal(data.rows.length, 1); + const row = data.rows[0]; + assert.equal(Number(row.id), target.spaceId, '行 id 应为库位ID'); + assert.equal(row.space_code, target.spaceCode || null); + assert.equal(row.custom_name, target.customName || null); + assert.equal(row.goods.length, 1, '该库位仅一个任务商品'); + assert.equal(Number(row.goods[0].stock_id), target.stockId, 'goods 应挂载该库位的任务商品'); + assert.equal(Number(row.goods[0].system_quantity), target.book, '明盘库位账面应为 wms_storage SUM(可用+锁定)'); + assert.equal(Number(row.goods[0].locked_quantity), target.bookLocked, '明盘库位锁定数量应为 wms_storage SUM(locked_quantity)'); + assert.equal(Number(row.goods[0].checked_quantity), 0, '未盘库位已盘应为 0'); + assert.equal(row.goods[0].status, 'unchecked'); + }); + + it('workDataSpaceDetails:不传 location_id 按分页返回全部 space 行(total/rows/page/pageSize 口径)', async () => { + const pairs = await fetchSpaceStockPairs(3); + const check = await createCheck(); + await addDetail(check.id, pairs.map(pair => pair.stockId)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const data = await ctx.service.systems.stockCheck.workDataSpaceDetails({ + warehouseId: TEST_WAREHOUSE_ID, + id: check.id, + pagination: { page: 1, pageSize: 2 }, + }); + + assert.equal(data.view, 'space'); + assert.equal(data.total, 3, '应返回全部 3 个库位行数'); + assert.equal(data.rows.length, 2, 'pageSize=2 应只返回 2 行'); + assert.equal(data.page, 1); + assert.equal(data.pageSize, 2); + const page1Ids = data.rows.map(row => Number(row.id)); + assert.ok( + page1Ids.every(id => pairs.some(pair => pair.spaceId === id)), + '第一页返回库位应属于任务商品所在库位集合' + ); + + // 第二页 + const page2 = await ctx.service.systems.stockCheck.workDataSpaceDetails({ + warehouseId: TEST_WAREHOUSE_ID, + id: check.id, + pagination: { page: 2, pageSize: 2 }, + }); + assert.equal(page2.total, 3); + assert.equal(page2.rows.length, 1, '第二页应返回剩余 1 行'); + assert.equal(page2.page, 2); + + // 两页合并应与任务商品所在库位全集一致 + const mergedIds = [ ...page1Ids, ...page2.rows.map(row => Number(row.id)) ].sort((left, right) => left - right); + assert.deepEqual( + mergedIds, + pairs.map(pair => pair.spaceId).sort((left, right) => left - right), + '两页合并的库位集合应与任务商品所在库位一致' + ); + }); + + it('workDataSpaceDetails 方法层:仓库注入 + location_id 驼峰兼容 + success 包装', async () => { + ctx.user = { + id: TEST_CREATOR_ID, + store_id: TEST_WAREHOUSE_ID, + employees_name: TEST_CREATOR_NAME, + }; + const pairs = await fetchSpaceStockPairs(2); + const check = await createCheck(); + await addDetail(check.id, pairs.map(pair => pair.stockId)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const result = await ctx.service.systemMethods.stock.check.workDataSpaceDetails({ + id: check.id, + locationId: pairs[0].spaceId, + }); + assert.equal(result.flag, 'success'); + assert.equal(result.data.view, 'space'); + assert.equal(result.data.total, 1); + assert.equal(Number(result.data.rows[0].id), pairs[0].spaceId, '库位ID驼峰写法应生效'); + + // 库位任务(type=location)不适用 space 视图聚合,但接口仍按任务类型构建(无 goods 明细返回空) + const locationCheck = await createCheck({ type: 'location' }); + await addLocationDetail(locationCheck.id, [ TEST_LOCATION_CODE ]); + await submitCheck(locationCheck.id); + await auditCheck(locationCheck.id, 'approve'); + const locationResult = await ctx.service.systemMethods.stock.check.workDataSpaceDetails({ + id: locationCheck.id, + }); + assert.equal(locationResult.flag, 'success'); + assert.equal(locationResult.data.view, 'space'); + assert.equal(locationResult.data.total, 0, '库位任务无商品范围明细,space 聚合应为空'); + }); + }); + + // ------------------- systemMethods.stock.check.workData:方法包装层 ------------------- + + describe('systemMethods.stock.check.workData 方法包装层', () => { + /** 设置当前上下文的用户信息(模拟登录用户,仓库固定 100000)。 */ + function mockCurrentUser() { + ctx.user = { + id: TEST_CREATOR_ID, + store_id: TEST_WAREHOUSE_ID, + employees_name: TEST_CREATOR_NAME, + }; + } + + it('is_goods 透传 + 仓库上下文注入 + success 包装', async () => { + mockCurrentUser(); + + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const result = await ctx.service.systemMethods.stock.check.workData({ id: check.id, is_goods: true }); + + assert.equal(result.flag, 'success'); + assert.equal(result.code, 1); + assert.equal( + Object.prototype.hasOwnProperty.call(result.data, 'check'), + false, + '方法层 workData 不返回 check(任务信息请调 detail)' + ); + assert.equal(result.data.view, 'goods', '方法层 workData 应返回解析后的 view'); + assert.equal(result.data.total, 1); + assert.equal(result.data.rows.length, 1); + assert.equal(Number(result.data.rows[0].stock_id), Number(stocks[0].id), 'is_goods=true 应返回商品视图行'); + assert.equal( + Object.prototype.hasOwnProperty.call(result.data.rows[0], 'system_quantity'), + true, + '明盘商品视图应含账面快照' + ); + }); + + it('view 入参已废弃:传非法 view 不报错,商品任务默认 space、is_goods=true 时 goods', async () => { + mockCurrentUser(); + + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + // view 传非法值不报错(入参已废弃忽略) + const invalidView = await ctx.service.systemMethods.stock.check.workData({ id: check.id, view: 'invalid' }); + assert.equal(invalidView.flag, 'success'); + assert.equal(invalidView.code, 1); + + // is_goods=true 返回商品视图(商品行含 stock_id 与明盘账面快照) + const goodsResult = await ctx.service.systemMethods.stock.check.workData({ id: check.id, view: 'invalid', is_goods: true }); + assert.equal(goodsResult.flag, 'success'); + assert.equal(goodsResult.data.total, 1); + assert.equal(Number(goodsResult.data.rows[0].stock_id), Number(stocks[0].id), 'is_goods=true 应返回商品视图行'); + assert.equal( + Object.prototype.hasOwnProperty.call(goodsResult.data.rows[0], 'system_quantity'), + true, + '明盘商品视图应含账面快照' + ); + }); + }); + + // ------------------- exportStockChecks:盘点导出(盘点明细=作业记录口径) ------------------- + + describe('exportStockChecks 盘点导出(盘点明细=作业记录口径)', () => { + /** Sheet1「盘点单」表头(列名与列序,与实现完全一致) */ + const SHEET1_HEADERS = [ + '盘点单号', '盘点名称', '盘点范围', '盘点方式', '盘点状态', '盘点进度', + '货主ID', '创建人', '明细行数', '已盘行数', '差异行数', '开始时间', '结束时间', '备注', + ]; + /** Sheet2「盘点明细」表头(作业记录口径:一行一条实际盘点记录) */ + const SHEET2_HEADERS = [ + '盘点单号', '商品编码', '商品名称', '库位编码', '实盘数量', '盘点人', '盘点时间', + ]; + + /** + * mock 上传服务:拦截 uploadFile 收集文件流 Buffer(不发起真实 COS 上传), + * uploadSuccessNotify 返回落库记录。 + * + * @return {Object} captured 捕获的上传调用与文件 Buffer。 + */ + function mockUploadService() { + const captured = { buffers: [], uploadCalls: [], notifyCalls: [] }; + app.mockService('systems.upload', 'uploadFile', async function(fileStream, uploadOptions = {}) { + captured.uploadCalls.push({ + filename: fileStream.filename, + key: uploadOptions.key, + fileSize: fileStream.fileSize, + }); + const chunks = []; + for await (const chunk of fileStream) { + chunks.push(chunk); + } + captured.buffers.push(Buffer.concat(chunks)); + const key = uploadOptions.key; + return { + fileName: key, + url: `https://cdn.test.local/${key}`, + cdnUrl: `https://cdn.test.local/${key}`, + cosUrl: `https://cos.test.local/${key}`, + }; + }); + app.mockService('systems.upload', 'uploadSuccessNotify', async function(data) { + captured.notifyCalls.push(data); + return { + fileId: 90001, + fileUrl: `https://cdn.test.local/${data.fileKey}`, + fileKey: data.fileKey, + fileName: data.fileName, + }; + }); + return captured; + } + + /** + * 将最近一次上传的 Excel Buffer 回读为工作簿。 + * + * @param {Object} captured mockUploadService 返回的捕获对象。 + * @return {Promise} ExcelJS 工作簿。 + */ + async function readBackWorkbook(captured) { + assert.ok(captured.buffers.length > 0, '上传文件流未捕获到内容'); + const workbook = new ExcelJS.Workbook(); + await workbook.xlsx.load(captured.buffers[captured.buffers.length - 1]); + return workbook; + } + + /** + * 读取单元格值(空值统一归一为空字符串)。 + * + * @param {Object} worksheet ExcelJS 工作表。 + * @param {number} rowNo 行号(1 起)。 + * @param {number} colNo 列号(1 起)。 + * @return {*} 单元格值。 + */ + function getCell(worksheet, rowNo, colNo) { + const value = worksheet.getRow(rowNo).getCell(colNo).value; + return value === null || value === undefined ? '' : value; + } + + /** + * 收集工作表表头列名(按列序)。 + * + * @param {Object} worksheet ExcelJS 工作表。 + * @return {Array} 表头列名。 + */ + function collectHeaders(worksheet) { + const headers = []; + for (let col = 1; col <= worksheet.actualColumnCount; col += 1) { + const value = worksheet.getRow(1).getCell(col).value; + headers.push(value === null || value === undefined ? '' : String(value)); + } + return headers; + } + + /** + * 导出指定盘点任务(直调业务层,上传服务已 mock),返回导出结果与回读工作簿。 + * + * @param {Array} ids 盘点任务ID列表。 + * @param {Object} captured mockUploadService 返回的捕获对象。 + * @param {Array} [progressCalls] 进度回调收集数组。 + * @return {Promise} { result, workbook }。 + */ + async function exportChecks(ids, captured, progressCalls = []) { + const result = await ctx.service.systems.stockCheck.exportStockChecks({ + warehouseId: TEST_WAREHOUSE_ID, + ids, + onProgress: async progress => { + progressCalls.push(progress); + }, + }); + const workbook = await readBackWorkbook(captured); + return { result, workbook }; + } + + it('Sheet2 明细行数=作业记录数:未盘范围行不导出,total_count=记录总数', async () => { + const captured = mockUploadService(); + + // 商品维度任务:2 条范围行,仅第一条上报作业记录(第二条保持未盘) + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + const details = await detailCheck(check.id); + assert.equal(details.rows.length, 2, '前置:2 条盘点范围行'); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + await reportCheck(check.id, details.rows[0].id, 5); + + const records = await queryRecords(check.id); + assert.equal(records.length, 1, '前置:仅 1 条作业记录'); + + const progressCalls = []; + const { result, workbook } = await exportChecks([ check.id ], captured, progressCalls); + + // 返回统计:total_count=作业记录总数(而非范围行数) + assert.equal(result.total_count, 1); + assert.equal(result.current_count, 1); + assert.match(result.filename, /^库存盘点导出_\d{14}\.xlsx$/, '文件名格式应为 库存盘点导出_时间戳.xlsx'); + + // 双 Sheet 名称 + 表头列名列序 + assert.equal(workbook.worksheets.length, 2); + assert.equal(workbook.worksheets[0].name, '盘点单'); + assert.equal(workbook.worksheets[1].name, '盘点明细'); + assert.deepEqual(collectHeaders(workbook.worksheets[0]), SHEET1_HEADERS); + assert.deepEqual(collectHeaders(workbook.worksheets[1]), SHEET2_HEADERS); + + // Sheet1 无「盘点日期」列;开始时间=首次上报时间(非空)、结束时间未完成(空) + const sheet1 = workbook.worksheets[0]; + assert.ok( + !collectHeaders(sheet1).includes('盘点日期'), + 'Sheet1 不应含「盘点日期」列' + ); + assert.notEqual(getCell(sheet1, 2, 12), '', 'Sheet1 开始时间应非空(首次上报已写 start_time)'); + assert.equal(getCell(sheet1, 2, 13), '', 'Sheet1 结束时间应为空(未完成盘点)'); + + // Sheet1:表头 + 1 个任务;Sheet2:表头 + 1 条作业记录(未盘的第 2 条范围行不导出) + assert.equal(workbook.worksheets[0].actualRowCount, 2); + assert.equal(workbook.worksheets[1].actualRowCount, 2); + + // Sheet2 数据行:盘点单号/实盘数量正确 + const sheet2 = workbook.worksheets[1]; + assert.equal(getCell(sheet2, 2, 1), check.check_no); + assert.equal(getCell(sheet2, 2, 5), 5); + + // 进度推送 totalCount 为作业记录总数 + const progressWithTotal = progressCalls.find(item => item && item.totalCount !== undefined); + assert.ok(progressWithTotal, '应推送包含 totalCount 的进度'); + assert.equal(progressWithTotal.totalCount, 1); + }); + + it('库位行记录导出含商品快照:item_code/item_name 从 wms_stock_warehouse 补齐', async () => { + const captured = mockUploadService(); + + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + const details = await detailCheck(check.id); + const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 1); + assert.ok(stockIds.length > 0, '前置:固定库位下存在库存商品'); + await reportCheck(check.id, details.rows[0].id, 7, TEST_LOCATION_CODE, { stockId: stockIds[0] }); + + const stockRow = await ctx.model.StockWarehouse.findOne({ + where: { id: stockIds[0] }, + attributes: [ 'id', 'item_code', 'item_name' ], + raw: true, + }); + + const { result, workbook } = await exportChecks([ check.id ], captured); + assert.equal(result.total_count, 1); + + const sheet2 = workbook.worksheets[1]; + assert.equal(sheet2.actualRowCount, 2); + assert.equal(getCell(sheet2, 2, 1), check.check_no); + assert.equal(getCell(sheet2, 2, 2), stockRow.item_code, '商品编码应来自 wms_stock_warehouse'); + assert.equal(getCell(sheet2, 2, 3), stockRow.item_name, '商品名称应来自 wms_stock_warehouse'); + assert.equal(getCell(sheet2, 2, 4), TEST_LOCATION_CODE); + assert.equal(getCell(sheet2, 2, 5), 7); + assert.equal(getCell(sheet2, 2, 6), TEST_CREATOR_NAME); + assert.notEqual(getCell(sheet2, 2, 7), '', '盘点时间应非空'); + }); + + it('历史空库位记录(location_code="")导出库位编码为空', async () => { + const captured = mockUploadService(); + + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + const details = await detailCheck(check.id); + const detail = details.rows[0]; + // report 已强制 space_id,这里直接构造历史脏数据(空串库位)验证导出兼容 + await ctx.model.StockCheckRecord.create({ + check_id: check.id, + warehouse_id: TEST_WAREHOUSE_ID, + detail_id: detail.id, + stock_id: Number(detail.stock_id), + location_id: null, + location_code: '', + quantity: 3, + is_empty: false, + checker_id: TEST_CREATOR_ID, + checker_name: TEST_CREATOR_NAME, + checked_at: new Date(), + }); + + const records = await queryRecords(check.id); + assert.equal(records.length, 1); + assert.equal(records[0].location_code, '', '前置:库中 location_code 应为空串'); + + const { workbook } = await exportChecks([ check.id ], captured); + const sheet2 = workbook.worksheets[1]; + assert.equal(sheet2.actualRowCount, 2); + assert.equal(getCell(sheet2, 2, 1), check.check_no); + assert.equal(getCell(sheet2, 2, 4), '', '空库位记录的库位编码应导出为空'); + assert.equal(getCell(sheet2, 2, 5), 3); + }); + + it('多任务导出:按盘点单号分组正确,Sheet1 一行一个任务', async () => { + const captured = mockUploadService(); + + const checkA = await createCheck(); + const checkB = await createCheck(); + const quantityMap = new Map([ + [ checkA.id, 4 ], + [ checkB.id, 6 ], + ]); + for (const check of [ checkA, checkB ]) { + const stocks = await fetchStockRows(1); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + const details = await detailCheck(check.id); + await reportCheck(check.id, details.rows[0].id, quantityMap.get(check.id)); + } + + const { result, workbook } = await exportChecks([ checkA.id, checkB.id ], captured); + assert.equal(result.total_count, 2); + + // Sheet1:表头 + 2 个任务(按 id 升序) + const sheet1 = workbook.worksheets[0]; + assert.equal(sheet1.actualRowCount, 3); + assert.equal(getCell(sheet1, 2, 1), checkA.check_no); + assert.equal(getCell(sheet1, 3, 1), checkB.check_no); + + // Sheet2:两条作业记录按盘点单号各归各任务 + const sheet2 = workbook.worksheets[1]; + assert.equal(sheet2.actualRowCount, 3); + assert.equal(getCell(sheet2, 2, 1), checkA.check_no, '第一条记录应属于任务A'); + assert.equal(getCell(sheet2, 2, 5), 4); + assert.equal(getCell(sheet2, 3, 1), checkB.check_no, '第二条记录应属于任务B'); + assert.equal(getCell(sheet2, 3, 5), 6); + }); + + it('未知商品导出口径:Sheet2 商品编码=扫描条码、商品名称=名称快照', async () => { + const captured = mockUploadService(); + + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + const details = await detailCheck(check.id); + await reportCheck(check.id, details.rows[0].id, 2, TEST_LOCATION_CODE); + const unknownBarcode = uniqueTitle('UNKNOWN-EXPORT'); + await reportCheck(check.id, details.rows[0].id, 4, TEST_LOCATION_CODE_2, { + barcode: unknownBarcode, + itemName: '导出未知商品快照', + }); + + const { result, workbook } = await exportChecks([ check.id ], captured); + assert.equal(result.total_count, 2); + + const sheet2 = workbook.worksheets[1]; + assert.equal(sheet2.actualRowCount, 3, '表头 + 2 条作业记录'); + assert.equal(getCell(sheet2, 2, 2), details.rows[0].item_code, '已知商品编码来自 wms_stock_warehouse'); + assert.equal(getCell(sheet2, 3, 2), unknownBarcode, '未知商品编码列显示扫描条码'); + assert.equal(getCell(sheet2, 3, 3), '导出未知商品快照', '未知商品名称列显示名称快照'); + assert.equal(getCell(sheet2, 3, 4), TEST_LOCATION_CODE_2); + assert.equal(getCell(sheet2, 3, 5), 4); + }); + }); + + // ------------------- exportCheckDetail:盘点明细导出(按盘点范围分流) ------------------- + + describe('exportCheckDetail 盘点明细导出(商品盘点分库位明细/汇总+差异,库位盘点简化)', () => { + /** 商品盘点 Sheet1「汇总和差异」表头 */ + const SUMMARY_SHEET_HEADERS = [ + '盘点单号', '商品编码', '条码', '商品名称', '规格', '账面数量', '盘点数量', '差异数量', '差异类型', + ]; + /** 商品盘点 Sheet2「库位明细」表头 */ + const LOCATION_SHEET_HEADERS = [ '库位编码', '数量', '条码', '商品名称' ]; + /** 库位盘点 Sheet「盘点明细」表头 */ + const SIMPLE_SHEET_HEADERS = [ '库位编码', '商品编码', '商品名称', '盘点数量' ]; + + function mockUploadService() { + const captured = { buffers: [], uploadCalls: [], notifyCalls: [] }; + app.mockService('systems.upload', 'uploadFile', async function(fileStream, uploadOptions = {}) { + captured.uploadCalls.push({ + filename: fileStream.filename, + key: uploadOptions.key, + fileSize: fileStream.fileSize, + }); + const chunks = []; + for await (const chunk of fileStream) { + chunks.push(chunk); + } + captured.buffers.push(Buffer.concat(chunks)); + const key = uploadOptions.key; + return { + fileName: key, + url: `https://cdn.test.local/${key}`, + cdnUrl: `https://cdn.test.local/${key}`, + cosUrl: `https://cos.test.local/${key}`, + }; + }); + app.mockService('systems.upload', 'uploadSuccessNotify', async function(data) { + captured.notifyCalls.push(data); + return { + fileId: 90002, + fileUrl: `https://cdn.test.local/${data.fileKey}`, + fileKey: data.fileKey, + fileName: data.fileName, + }; + }); + return captured; + } + + async function readBackWorkbook(captured) { + assert.ok(captured.buffers.length > 0, '上传文件流未捕获到内容'); + const workbook = new ExcelJS.Workbook(); + await workbook.xlsx.load(captured.buffers[captured.buffers.length - 1]); + return workbook; + } + + function getCell(worksheet, rowNo, colNo) { + const value = worksheet.getRow(rowNo).getCell(colNo).value; + return value === null || value === undefined ? '' : value; + } + + function collectHeaders(worksheet) { + const headers = []; + for (let col = 1; col <= worksheet.actualColumnCount; col += 1) { + const value = worksheet.getRow(1).getCell(col).value; + headers.push(value === null || value === undefined ? '' : String(value)); + } + return headers; + } + + async function exportDetail(checkId) { + return ctx.service.systems.stockCheck.exportCheckDetail({ + warehouseId: TEST_WAREHOUSE_ID, + id: checkId, + onProgress: () => {}, + }); + } + + /** + * 按实现口径解析库位显示文本:自定义名称 → 自定义编码 → 库位编码。 + * + * @param {string} code 库位编码。 + * @return {Promise} 期望显示的库位文本。 + */ + async function resolveLocationDisplay(code) { + const space = await ctx.model.LocationSpace.findOne({ + where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: String(code || '').trim() }, + attributes: [ 'space_code', 'custom_name', 'custom_barcode' ], + raw: true, + }); + if (!space) { + return String(code || '').trim(); + } + return String(space.custom_name || '').trim() + || String(space.custom_barcode || '').trim() + || String(space.space_code || '').trim(); + } + + it('商品任务:两个 sheet——「汇总和差异」每商品一行 + 「库位明细」库位/数量/条码/商品名称', async () => { + const captured = mockUploadService(); + const { Op } = ctx.app.Sequelize; + + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const firstDetail = details.rows[0]; + const secondDetail = details.rows[1]; + const firstSnapshot = Number(firstDetail.system_quantity); + const secondSnapshot = Number(secondDetail.system_quantity); + // 在商品自身快照库位上报:第一商品盘盈 7、第二商品持平 + await reportCheck(check.id, firstDetail.id, firstSnapshot + 7, firstDetail.location_code); + await reportCheck(check.id, secondDetail.id, secondSnapshot, secondDetail.location_code); + + // 商品条码(wms_stock_barcodes 按 stock_id 取第一条,口径与实现一致) + const barcodeRows = await ctx.model.StockBarcode.findAll({ + where: { + warehouse_id: TEST_WAREHOUSE_ID, + stock_id: { [Op.in]: [ Number(firstDetail.stock_id), Number(secondDetail.stock_id) ] }, + }, + attributes: [ 'stock_id', 'barcode' ], + order: [[ 'id', 'ASC' ]], + raw: true, + }); + const barcodeByStock = new Map(); + for (const row of barcodeRows) { + const rowStockId = Number(row.stock_id); + if (!barcodeByStock.has(rowStockId)) { + barcodeByStock.set(rowStockId, String(row.barcode || '').trim()); + } + } + + const result = await exportDetail(check.id); + assert.equal(result.total_count, 4, '汇总 2 行 + 作业记录 2 行'); + + const workbook = await readBackWorkbook(captured); + assert.equal(workbook.worksheets.length, 2, '商品盘点固定两个 sheet'); + + const summarySheet = workbook.worksheets[0]; + assert.equal(summarySheet.name, '汇总和差异'); + assert.deepEqual(collectHeaders(summarySheet), SUMMARY_SHEET_HEADERS); + assert.equal(summarySheet.actualRowCount, 3, '表头 + 2 商品'); + assert.equal(getCell(summarySheet, 2, 2), firstDetail.item_code); + assert.equal( + getCell(summarySheet, 2, 3), + barcodeByStock.get(Number(firstDetail.stock_id)) || '', + '条码=商品条码' + ); + assert.equal(getCell(summarySheet, 2, 6), firstSnapshot, '账面=快照合计'); + assert.equal(getCell(summarySheet, 2, 7), firstSnapshot + 7); + assert.equal(getCell(summarySheet, 2, 8), 7); + assert.equal(getCell(summarySheet, 2, 9), '盘盈'); + assert.equal(getCell(summarySheet, 3, 8), 0, '持平商品差异 0'); + assert.equal(getCell(summarySheet, 3, 9), '', '持平商品差异类型为空'); + + const locationSheet = workbook.worksheets[1]; + assert.equal(locationSheet.name, '库位明细'); + assert.deepEqual(collectHeaders(locationSheet), LOCATION_SHEET_HEADERS); + assert.equal(locationSheet.actualRowCount, 3, '表头 + 2 条作业记录'); + assert.equal( + getCell(locationSheet, 2, 1), + await resolveLocationDisplay(firstDetail.location_code), + '库位显示=自定义名称→自定义编码→库位编码' + ); + assert.equal(getCell(locationSheet, 2, 2), firstSnapshot + 7, '数量=实盘'); + assert.equal(getCell(locationSheet, 2, 3), barcodeByStock.get(Number(firstDetail.stock_id)) || '', '条码=商品条码'); + assert.equal(getCell(locationSheet, 2, 4), firstDetail.item_name); + assert.equal( + getCell(locationSheet, 3, 1), + await resolveLocationDisplay(secondDetail.location_code), + '库位显示=自定义名称→自定义编码→库位编码' + ); + assert.equal(getCell(locationSheet, 3, 2), secondSnapshot); + assert.equal(getCell(locationSheet, 3, 4), secondDetail.item_name); + }); + + it('库位任务:单 sheet 库位/商品编码/商品名称/盘点数量(未知商品编码=条码)', async () => { + const captured = mockUploadService(); + const { check, detail } = await createApprovedLocationCheck(); + const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 1); + assert.ok(stockIds.length > 0, '前置:固定测试库位应存在库存商品'); + await reportCheck(check.id, detail.id, 3, undefined, { stockId: stockIds[0] }); + const unknownBarcode = uniqueTitle('LOCATION-EXPORT-UNKNOWN'); + await reportCheck(check.id, detail.id, 4, undefined, { barcode: unknownBarcode }); + + const result = await exportDetail(check.id); + assert.equal(result.total_count, 2, '两条作业记录'); + + const workbook = await readBackWorkbook(captured); + assert.equal(workbook.worksheets.length, 1, '库位任务单 sheet'); + const sheet = workbook.worksheets[0]; + assert.equal(sheet.name, '盘点明细'); + assert.deepEqual(collectHeaders(sheet), SIMPLE_SHEET_HEADERS); + assert.equal(sheet.actualRowCount, 3, '表头 + 2 行'); + assert.equal( + getCell(sheet, 2, 1), + await resolveLocationDisplay(TEST_LOCATION_CODE), + '库位列显示=自定义名称→自定义编码→库位编码' + ); + assert.equal(getCell(sheet, 2, 4), 3, '盘点数量'); + assert.equal(getCell(sheet, 3, 2), unknownBarcode, '未知商品编码=扫描条码'); + assert.equal(getCell(sheet, 3, 4), 4); + }); + + it('方法层 exportDetail:返回任务ID并异步完成(进度复用 exportTaskProgress)', async () => { + mockUploadService(); + ctx.user = { + id: TEST_CREATOR_ID, + store_id: TEST_WAREHOUSE_ID, + employees_name: TEST_CREATOR_NAME, + }; + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + + const result = await ctx.service.systemMethods.stock.check.exportDetail({ id: check.id }); + assert.equal(result.flag, 'success'); + assert.equal(result.code, 1); + assert.ok(result.task_id, '应返回导出任务ID'); + assert.equal(result.status, 'submitted'); + + // 轮询导出进度至终态(上传服务已 mock,egg-mock 环境内可正常执行) + const taskId = result.task_id; + let progress = null; + for (let attempt = 0; attempt < 50; attempt++) { + progress = await ctx.service.systemMethods.stock.check.exportTaskProgress({ task_id: taskId }); + if (progress.status === 'success' || progress.status === 'failed') { + break; + } + await new Promise(resolve => setTimeout(resolve, 100)); + } + assert.equal(progress.status, 'success', `导出任务应完成: ${progress.error}`); + assert.ok(progress.download_url, '完成后应返回下载链接'); + + // 未传 id 报 400 + const invalid = await ctx.service.systemMethods.stock.check.exportDetail({}); + assert.equal(invalid.flag, 'failure'); + assert.equal(invalid.code, 400); + }); + }); + + // ------------------- 未知商品记录 + 图片独立维护(迁移 20261001100000) ------------------- + + describe('未知商品记录 + 图片独立维护', () => { + it('未知商品:库位行仅传 barcode(不存在)→ stock_id=NULL、barcode/item_name 落库(item_name 缺省=barcode)', async () => { + const { check, detail } = await createApprovedLocationCheck(); + const unknownBarcode = uniqueTitle('UNKNOWN-BARCODE'); + + // 前置:条码未命中本仓库系统商品 + assert.equal( + await ctx.model.StockBarcode.count({ + where: { warehouse_id: TEST_WAREHOUSE_ID, barcode: unknownBarcode }, + }), + 0, + '前置:测试条码不应命中系统商品' + ); + + const result = await reportCheck(check.id, detail.id, 5, undefined, { barcode: unknownBarcode }); + + assert.equal(result.mode, 'created'); + assert.equal(result.record.stock_id, null, '未知商品 stock_id 应为 NULL'); + assert.equal(result.record.barcode, unknownBarcode, '记录应写入扫描条码'); + assert.equal(result.record.item_name, unknownBarcode, 'item_name 缺省应为条码'); + assert.equal(result.record.location_code, TEST_LOCATION_CODE, '库位以明细库位为准'); + assert.equal(result.checked_items, 1); + assert.equal(result.detail_status, 'all_checked'); + + const record = await ctx.model.StockCheckRecord.findOne({ + where: { id: Number(result.record.id) }, + raw: true, + }); + assert.equal(record.stock_id, null, '库中 stock_id 应为 NULL'); + assert.equal(record.barcode, unknownBarcode); + assert.equal(record.item_name, unknownBarcode); + }); + + it('未知商品:显式传 item_name 按快照落库(非缺省条码)', async () => { + const { check, detail } = await createApprovedLocationCheck(); + const unknownBarcode = uniqueTitle('UNKNOWN-BARCODE-NAME'); + + const result = await reportCheck(check.id, detail.id, 2, undefined, { + barcode: unknownBarcode, + itemName: '未知商品快照名称', + }); + + assert.equal(result.record.stock_id, null); + assert.equal(result.record.barcode, unknownBarcode); + assert.equal(result.record.item_name, '未知商品快照名称', 'item_name 应为显式快照'); + }); + + it('barcode 命中系统条码:库位行回填 stock_id 按已知商品处理,重复上报覆盖更新', async () => { + const { check, detail } = await createApprovedLocationCheck(); + const stocks = await fetchStockRows(1); + const stockId = Number(stocks[0].id); + const knownBarcode = uniqueTitle('KNOWN-BARCODE'); + await createStockBarcode(stockId, knownBarcode); + + const first = await reportCheck(check.id, detail.id, 3, undefined, { barcode: knownBarcode }); + assert.equal(first.mode, 'created'); + assert.equal(Number(first.record.stock_id), stockId, '命中系统条码应回填 stock_id'); + assert.equal(first.record.barcode, knownBarcode, '已知商品记录冗余条码'); + assert.equal(first.record.item_name, null, '已知商品不落 item_name'); + + const second = await reportCheck(check.id, detail.id, 6, undefined, { barcode: knownBarcode }); + assert.equal(second.mode, 'updated', '回填后按 (detail,stock,location) 覆盖更新'); + assert.equal(Number(second.record.id), Number(first.record.id)); + + const records = await queryRecords(check.id, detail.id); + assert.equal(records.length, 1, '同 (detail,stock,location) 只保留一条记录'); + assert.equal(Number(records[0].stock_id), stockId); + assert.equal(Number(records[0].quantity), 6); + }); + + it('商品行 barcode 命中系统条码:与明细商品一致回填 stock_id;命中其他商品报 400', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + const details = await detailCheck(check.id); + const detail = details.rows[0]; + + const barcodeForA = uniqueTitle('GOODS-BARCODE-A'); + const barcodeForB = uniqueTitle('GOODS-BARCODE-B'); + await createStockBarcode(stocks[0].id, barcodeForA); + await createStockBarcode(stocks[1].id, barcodeForB); + + const hit = await reportCheck(check.id, detail.id, 4, undefined, { barcode: barcodeForA }); + assert.equal(hit.mode, 'created'); + assert.equal(Number(hit.record.stock_id), Number(detail.stock_id), '命中且一致应回填明细商品'); + assert.equal(hit.record.barcode, barcodeForA); + + await assert.rejects(async () => { + await reportCheck(check.id, detail.id, 4, undefined, { barcode: barcodeForB }); + }, error => error.code === 400 && /上报商品与盘点明细商品不一致/.test(error.message)); + }); + + it('未知商品覆盖式:同 detail+同 barcode+同库位二次上报 → updated、数量更新、不新增记录', async () => { + const { check, detail } = await createApprovedLocationCheck(); + const unknownBarcode = uniqueTitle('UNKNOWN-UPDATE'); + + const first = await reportCheck(check.id, detail.id, 5, undefined, { barcode: unknownBarcode }); + assert.equal(first.mode, 'created'); + + const second = await reportCheck(check.id, detail.id, 9, undefined, { barcode: unknownBarcode }); + assert.equal(second.mode, 'updated', '同 barcode 同库位应覆盖更新'); + assert.equal(Number(second.record.id), Number(first.record.id), '应更新同一条记录'); + + const records = await queryRecords(check.id, detail.id); + assert.equal(records.length, 1, '未知商品同 barcode 同库位只保留一条记录'); + assert.equal(Number(records[0].quantity), 9); + }); + + it('result 库位行 unknown_items:未知实盘=盘盈差异、stocks 保持只含已知商品', async () => { + const { check, detail } = await createApprovedLocationCheck(); + const stockIds = await fetchStorageStockIds(TEST_LOCATION_ID, 1); + assert.ok(stockIds.length > 0, '前置:固定测试库位应存在库存商品'); + const bookMap = await fetchStorageQuantity(TEST_LOCATION_ID, stockIds); + const bookA = Number(bookMap.get(stockIds[0]) || 0); + + await reportCheck(check.id, detail.id, bookA, undefined, { stockId: stockIds[0] }); + const unknownBarcode = uniqueTitle('UNKNOWN-RESULT'); + await reportCheck(check.id, detail.id, 7, undefined, { barcode: unknownBarcode }); + + const result = await resultCheck(check.id); + const row = result.rows[0]; + assert.equal(row.checked_quantity, bookA + 7, '行级已盘=已知+未知合计'); + assert.equal(row.diff_quantity, 7, '未知商品无账面:差异=实盘=盘盈'); + assert.equal(row.is_diff, 1); + assert.deepEqual(row.unknown_items, [ + { barcode: unknownBarcode, item_name: unknownBarcode, checked_quantity: 7 }, + ], 'unknown_items 应为未知商品聚合'); + assert.equal(row.stocks.length, 1, 'stocks 保持只含已知商品'); + assert.equal(Number(row.stocks[0].stock_id), Number(stockIds[0])); + assert.equal(row.stocks[0].diff_quantity, 0, '已知商品账面持平无差异'); + }); + + it('result 商品行 unknown_items:已知+未知混合,行级差异=已知差异+未知实盘', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + const details = await detailCheck(check.id); + const detail = details.rows[0]; + const snapshot = Number(detail.system_quantity); + + await reportCheck(check.id, detail.id, snapshot, TEST_LOCATION_CODE); + const unknownBarcode = uniqueTitle('GOODS-UNKNOWN'); + await reportCheck(check.id, detail.id, 4, TEST_LOCATION_CODE_2, { barcode: unknownBarcode }); + + const result = await resultCheck(check.id); + const row = result.rows[0]; + assert.equal(row.status, 'checked'); + assert.equal(row.checked_quantity, snapshot + 4); + assert.equal(row.diff_quantity, 4, '未知实盘计入商品行差异'); + assert.equal(row.is_diff, 1); + assert.deepEqual(row.unknown_items, [ + { barcode: unknownBarcode, item_name: unknownBarcode, checked_quantity: 4 }, + ], '商品行同样输出 unknown_items'); + }); + + it('finish 未知商品计入 profit_total/diff_items(无账面=盘盈)', async () => { + const { check, detail } = await createApprovedLocationCheck(); + const unknownBarcode = uniqueTitle('UNKNOWN-FINISH'); + await reportCheck(check.id, detail.id, 11, undefined, { barcode: unknownBarcode }); + + const result = await finishCheck(check.id); + + assert.equal(result.status, 'completed'); + assert.equal(result.total_items, 1); + assert.equal(result.checked_items, 1); + assert.equal(result.unchecked_items, 0); + assert.equal(result.diff_items, 1, '未知商品必然差异计入 diff_items'); + assert.equal(result.profit_total, 11, '未知商品实盘=盘盈'); + assert.equal(result.loss_total, 0); + + const row = await findCheckRow(check.id); + assert.equal(row.status, 'completed'); + assert.equal(row.diff_items, 1); + }); + + it('图片独立维护:FileReference(business_type=stock_check_record) 挂载 recordList 与 result.records', async () => { + const { check, detail } = await createApprovedLocationCheck(); + const stocks = await fetchStockRows(1); + const knownReport = await reportCheck(check.id, detail.id, 3, undefined, { stockId: stocks[0].id }); + const unknownBarcode = uniqueTitle('UNKNOWN-IMAGE-EMPTY'); + const unknownReport = await reportCheck(check.id, detail.id, 2, undefined, { barcode: unknownBarcode }); + const { file } = await createRecordImage(Number(knownReport.record.id)); + + const listed = await listRecords({ id: check.id, detailId: detail.id }); + assert.equal(listed.total, 2); + const listedKnown = listed.rows.find(row => Number(row.id) === Number(knownReport.record.id)); + const listedUnknown = listed.rows.find(row => Number(row.id) === Number(unknownReport.record.id)); + assert.deepEqual( + listedKnown.images, + [{ id: Number(file.id), url: file.file_url }], + 'recordList 应挂载 FileReference 图片' + ); + assert.deepEqual(listedUnknown.images, [], '无图片记录 images 应为空数组'); + + const result = await resultCheck(check.id); + const records = result.rows[0].records; + assert.equal(records.length, 2); + const resultKnown = records.find(record => Number(record.id) === Number(knownReport.record.id)); + const resultUnknown = records.find(record => Number(record.id) === Number(unknownReport.record.id)); + assert.deepEqual( + resultKnown.images, + [{ id: Number(file.id), url: file.file_url }], + 'result.records 应挂载 FileReference 图片' + ); + assert.deepEqual(resultUnknown.images, [], 'result 无图片记录 images 应为空数组'); + }); + + it('recordDelete 删除记录时清理其 FileReference 图片引用', async () => { + const { check, detail } = await createApprovedLocationCheck(); + const stocks = await fetchStockRows(1); + const reportResult = await reportCheck(check.id, detail.id, 3, undefined, { stockId: stocks[0].id }); + const recordId = Number(reportResult.record.id); + await createRecordImage(recordId); + + assert.equal( + await ctx.model.FileReference.count({ + where: { business_type: 'stock_check_record', business_id: String(recordId) }, + }), + 1, + '前置:图片引用已创建' + ); + + await deleteRecord(check.id, recordId); + + assert.equal( + await ctx.model.FileReference.count({ + where: { business_type: 'stock_check_record', business_id: String(recordId) }, + }), + 0, + '删除记录后其图片引用应被清理' + ); + assert.equal((await queryRecords(check.id, detail.id)).length, 0, '作业记录应被删除'); + }); + + it('recordList 未知商品展示口径:item_code=条码、item_name=名称快照;已知商品维持明细快照', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + const details = await detailCheck(check.id); + const detail = details.rows[0]; + + await reportCheck(check.id, detail.id, 2, TEST_LOCATION_CODE); + const unknownBarcode = uniqueTitle('UNKNOWN-LIST'); + await reportCheck(check.id, detail.id, 3, TEST_LOCATION_CODE_2, { + barcode: unknownBarcode, + itemName: '盘点神秘商品', + }); + + const listed = await listRecords({ id: check.id, detailId: detail.id }); + assert.equal(listed.total, 2); + + const unknownRow = listed.rows.find(row => row.stock_id === null); + const knownRow = listed.rows.find(row => row.stock_id !== null); + assert.ok(unknownRow, '应存在未知商品记录'); + assert.ok(knownRow, '应存在已知商品记录'); + assert.equal(unknownRow.item_code, unknownBarcode, '未知商品编码列显示扫描条码'); + assert.equal(unknownRow.item_name, '盘点神秘商品', '未知商品名称列显示名称快照'); + assert.equal(unknownRow.barcode, unknownBarcode, '记录含原始条码字段'); + assert.equal(knownRow.item_code, detail.item_code, '已知商品编码列维持明细快照'); + assert.equal(knownRow.item_name, detail.item_name, '已知商品名称列维持明细快照'); + assert.deepEqual(unknownRow.images, [], '无图片记录 images 应为空数组'); + assert.equal(unknownRow.store_id, null, '未知商品 store_id 应为 null'); + assert.equal(unknownRow.store_name, null, '未知商品 store_name 应为 null'); + assert.equal(unknownRow.spec, null, '未知商品 spec 应为 null'); + }); + + it('recordList 对齐 workData:已知商品挂 store_id/store_name/spec/商品条码,保留记录全字段', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + const details = await detailCheck(check.id); + const reportResult = await reportCheck(check.id, details.rows[0].id, 3, undefined, { stockId: stocks[0].id }); + + const stockDetails = await ctx.service.systems.stockWarehouse.getStockDetails( + [ stocks[0].id ], + { warehouseId: TEST_WAREHOUSE_ID } + ); + const stockDetail = stockDetails.find(item => Number(item.id) === Number(stocks[0].id)) || {}; + + const listed = await listRecords({ id: check.id }); + assert.equal(listed.total, 1); + const row = listed.rows[0]; + assert.equal(Number(row.id), Number(reportResult.record.id)); + // 保留记录全字段 + for (const key of [ 'check_id', 'warehouse_id', 'detail_id', 'stock_id', 'location_id', 'quantity', 'checker_id', 'checker_name', 'checked_at', 'is_empty', 'remark' ]) { + assert.ok(Object.prototype.hasOwnProperty.call(row, key), `应保留全字段 ${key}`); + } + // 对齐 workData 商品口径 + assert.equal(Number(row.store_id), Number(stockDetail.store_id) || 0, '应挂商品货主ID'); + assert.ok(row.store_name, '应解析货主名'); + assert.equal(row.spec, stockDetail.sku_property || null, '应挂商品规格'); + assert.ok(row.item_code); + assert.ok(row.barcode, '应挂商品条码(workData 口径)'); + assert.deepEqual(row.images, [], '保留 images 作业照片字段'); + }); + + it('report 未传 stock_id 且未传 barcode:库位行报 400,barcode 空串同口径', async () => { + const { check, detail } = await createApprovedLocationCheck(); + + await assert.rejects(async () => { + await reportCheck(check.id, detail.id, 1); + }, error => error.code === 400 && /必须指定商品/.test(error.message)); + + await assert.rejects(async () => { + await reportCheck(check.id, detail.id, 1, undefined, { barcode: ' ' }); + }, error => error.code === 400 && /必须指定商品/.test(error.message)); + }); + + it('已知商品原链路回归:库位行传 stock_id 正常上报,barcode/item_name 保持 NULL', async () => { + const { check, detail } = await createApprovedLocationCheck(); + const stocks = await fetchStockRows(1); + const result = await reportCheck(check.id, detail.id, 6, undefined, { stockId: stocks[0].id }); + + assert.equal(result.mode, 'created'); + assert.equal(Number(result.record.stock_id), Number(stocks[0].id)); + assert.equal(result.record.barcode, null, '已知商品未传条码 barcode 应为 NULL'); + assert.equal(result.record.item_name, null, '已知商品 item_name 应为 NULL'); + assert.equal(result.checked_items, 1); + + const row = await findCheckRow(check.id); + assert.equal(row.checked_items, 1); + }); + }); + + // ------------------- 操作日志(wms_operation_log):10 个写操作落库验证 ------------------- + + describe('操作日志落库(wms_operation_log,business_type=stock_check)', () => { + /** + * 查询某个盘点任务的全部操作日志(按 id 升序)。 + * + * @param {number} checkId 盘点任务ID。 + * @return {Promise>} 日志行(plain)。 + */ + async function queryOperationLogs(checkId) { + return ctx.model.OperationLog.findAll({ + where: { business_type: 'stock_check', business_id: String(checkId) }, + order: [[ 'id', 'ASC' ]], + raw: true, + }); + } + + /** + * 查询某个盘点任务指定 operation_code 的日志行。 + * + * @param {number} checkId 盘点任务ID。 + * @param {string} operationCode 操作编码。 + * @return {Promise>} 日志行(plain)。 + */ + async function queryOperationLogsByCode(checkId, operationCode) { + const logs = await queryOperationLogs(checkId); + return logs.filter(item => item.operation_code === operationCode); + } + + it('create 写入 STOCK_CHECK_CREATE:business_id=任务 id、warehouse_id=100000、message 含单号', async () => { + const result = await createCheck(); + + const logs = await queryOperationLogsByCode(result.id, 'STOCK_CHECK_CREATE'); + + assert.equal(logs.length, 1, '创建成功后应写入 1 条 STOCK_CHECK_CREATE 日志'); + const log = logs[0]; + assert.equal(log.business_type, 'stock_check'); + assert.equal(log.business_id, String(result.id), 'business_id 应为任务 id'); + assert.equal(Number(log.warehouse_id), TEST_WAREHOUSE_ID, 'warehouse_id 应为固定测试仓库'); + assert.ok(log.message && log.message.includes(result.check_no), `message 应包含单号: ${log.message}`); + }); + + it('addDetail/detailDelete 分别写入 STOCK_CHECK_ADD_DETAIL 与 STOCK_CHECK_DELETE_DETAIL', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + + await addDetail(check.id, [ stocks[0].id ]); + const details = await detailCheck(check.id); + const detailId = details.rows[0].id; + await deleteDetail(check.id, detailId); + + const addLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_ADD_DETAIL'); + assert.equal(addLogs.length, 1, '添加明细成功后应写入 1 条 STOCK_CHECK_ADD_DETAIL 日志'); + assert.ok(addLogs[0].message && addLogs[0].message.includes('添加盘点明细'), `message 应含操作描述: ${addLogs[0].message}`); + assert.equal(Number(addLogs[0].warehouse_id), TEST_WAREHOUSE_ID); + + const deleteLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_DELETE_DETAIL'); + assert.equal(deleteLogs.length, 1, '删除明细成功后应写入 1 条 STOCK_CHECK_DELETE_DETAIL 日志'); + assert.ok( + deleteLogs[0].message && deleteLogs[0].message.includes('删除盘点明细'), + `message 应含操作描述: ${deleteLogs[0].message}` + ); + assert.ok( + deleteLogs[0].message && deleteLogs[0].message.includes('删除 1 个,跳过 0 个'), + `message 应含批量删除统计: ${deleteLogs[0].message}` + ); + assert.equal(Number(deleteLogs[0].warehouse_id), TEST_WAREHOUSE_ID); + }); + + it('submit/cancel 分别写入 STOCK_CHECK_SUBMIT 与 STOCK_CHECK_CANCEL', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await cancelCheck(check.id); + + const submitLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_SUBMIT'); + assert.equal(submitLogs.length, 1, '提交审核成功后应写入 1 条 STOCK_CHECK_SUBMIT 日志'); + assert.equal(submitLogs[0].business_id, String(check.id)); + assert.ok(submitLogs[0].message && submitLogs[0].message.includes('提交审核'), `message 应含操作描述: ${submitLogs[0].message}`); + + const cancelLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_CANCEL'); + assert.equal(cancelLogs.length, 1, '取消成功后应写入 1 条 STOCK_CHECK_CANCEL 日志'); + assert.equal(cancelLogs[0].business_id, String(check.id)); + assert.ok(cancelLogs[0].message && cancelLogs[0].message.includes('取消盘点任务'), `message 应含操作描述: ${cancelLogs[0].message}`); + }); + + it('report/recordDelete 分别写入 STOCK_CHECK_REPORT 与 STOCK_CHECK_DELETE_RECORD', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + const details = await detailCheck(check.id); + const detailId = details.rows[0].id; + + const reportResult = await reportCheck(check.id, detailId, 7); + assert.equal(reportResult.mode, 'created'); + + const reportLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_REPORT'); + assert.equal(reportLogs.length, 1, '上报成功后应写入 1 条 STOCK_CHECK_REPORT 日志'); + assert.equal(reportLogs[0].business_id, String(check.id)); + assert.equal(Number(reportLogs[0].warehouse_id), TEST_WAREHOUSE_ID); + assert.ok(reportLogs[0].message && reportLogs[0].message.includes(`明细 ${detailId}`), `message 应含 detail_id: ${reportLogs[0].message}`); + assert.ok(reportLogs[0].message && reportLogs[0].message.includes('实盘 7'), `message 应含实盘数量: ${reportLogs[0].message}`); + + const records = await queryRecords(check.id, detailId); + assert.equal(records.length, 1, '前置:应有 1 条作业记录'); + await deleteRecord(check.id, records[0].id); + + const deleteLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_DELETE_RECORD'); + assert.equal(deleteLogs.length, 1, '删除作业记录后应写入 1 条 STOCK_CHECK_DELETE_RECORD 日志'); + assert.ok(deleteLogs[0].message && deleteLogs[0].message.includes('批量删除盘点作业记录 1 条'), `message 应含批量删除描述: ${deleteLogs[0].message}`); + }); + + it('finish 写入 STOCK_CHECK_FINISH:message 含差异汇总(盘盈/盘亏)', async () => { + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + const details = await detailCheck(check.id); + await reportCheck(check.id, details.rows[0].id, 0); + + const finishResult = await finishCheck(check.id); + assert.equal(finishResult.status, 'completed'); + + const logs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_FINISH'); + assert.equal(logs.length, 1, '完成后应写入 1 条 STOCK_CHECK_FINISH 日志'); + assert.equal(logs[0].business_id, String(check.id)); + assert.ok(logs[0].message && logs[0].message.includes('完成盘点'), `message 应含操作描述: ${logs[0].message}`); + assert.ok(logs[0].message && logs[0].message.includes('盘盈'), `message 应含盘盈汇总: ${logs[0].message}`); + assert.ok(logs[0].message && logs[0].message.includes('盘亏'), `message 应含盘亏汇总: ${logs[0].message}`); + }); + + it('audit approve/reject 写入 STOCK_CHECK_AUDIT:reject message 含驳回原因', async () => { + const approveCheck = await createCheck(); + const approveStocks = await fetchStockRows(1); + await addDetail(approveCheck.id, [ approveStocks[0].id ]); + await submitCheck(approveCheck.id); + await auditCheck(approveCheck.id, 'approve'); + + const rejectCheck = await createCheck(); + const rejectStocks = await fetchStockRows(1); + await addDetail(rejectCheck.id, [ rejectStocks[0].id ]); + await submitCheck(rejectCheck.id); + const rejectReason = '实盘与账面差异过大-测试驳回'; + await auditCheck(rejectCheck.id, 'reject', rejectReason); + + const approveLogs = await queryOperationLogsByCode(approveCheck.id, 'STOCK_CHECK_AUDIT'); + assert.equal(approveLogs.length, 1, '审核通过应写入 1 条 STOCK_CHECK_AUDIT 日志'); + assert.ok(approveLogs[0].message && approveLogs[0].message.includes('审核通过'), `approve message 应含动作: ${approveLogs[0].message}`); + + const rejectLogs = await queryOperationLogsByCode(rejectCheck.id, 'STOCK_CHECK_AUDIT'); + assert.equal(rejectLogs.length, 1, '审核驳回应写入 1 条 STOCK_CHECK_AUDIT 日志'); + assert.ok(rejectLogs[0].message && rejectLogs[0].message.includes('审核驳回'), `reject message 应含动作: ${rejectLogs[0].message}`); + assert.ok(rejectLogs[0].message && rejectLogs[0].message.includes(rejectReason), 'reject 日志 message 应包含驳回原因'); + }); + + it('batchDelete 删除 2 个作废任务仅写 1 条日志:business_id=首个删除 id、message 含删除/跳过数量', async () => { + const cancelledA = await createCancelledCheck(); + const cancelledB = await createCancelledCheck(); + + const result = await batchDeleteCheck([ cancelledA.check.id, cancelledB.check.id ]); + assert.equal(result.deleted_count, 2); + assert.equal(result.skipped_count, 0); + + const logsA = await queryOperationLogsByCode(cancelledA.check.id, 'STOCK_CHECK_BATCH_DELETE'); + assert.equal(logsA.length, 1, '删除 2 个任务应只写 1 条日志,business_id 取首个删除 id'); + assert.equal(logsA[0].business_id, String(cancelledA.check.id), 'business_id 应为首个删除任务 id'); + assert.equal(Number(logsA[0].warehouse_id), TEST_WAREHOUSE_ID); + assert.ok(logsA[0].message && logsA[0].message.includes('删除 2 个'), `message 应含删除数量: ${logsA[0].message}`); + assert.ok(logsA[0].message && logsA[0].message.includes('跳过 0 个'), `message 应含跳过数量: ${logsA[0].message}`); + + const logsB = await queryOperationLogsByCode(cancelledB.check.id, 'STOCK_CHECK_BATCH_DELETE'); + assert.equal(logsB.length, 0, '第二个删除 id 不应单独写日志'); + + // deletedIds 为空(全跳过)时不写日志 + const missingId = await findFreeCheckId(); + const skipResult = await batchDeleteCheck([ missingId ]); + assert.equal(skipResult.deleted_count, 0); + assert.equal(skipResult.skipped_count, 1); + const skipLogs = await queryOperationLogsByCode(missingId, 'STOCK_CHECK_BATCH_DELETE'); + assert.equal(skipLogs.length, 0, 'deletedIds 为空时不应写 STOCK_CHECK_BATCH_DELETE 日志'); + }); + + it('失败路径不写日志:submit 空任务/report 非法状态 400 后无新日志', async () => { + const check = await createCheck(); + + await assert.rejects(async () => { + await submitCheck(check.id); + }, error => error.code === 400 && /明细/.test(error.message)); + + const submitLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_SUBMIT'); + assert.equal(submitLogs.length, 0, 'submit 失败后不应写入 STOCK_CHECK_SUBMIT 日志'); + + // created 状态不允许盘点作业:report 状态校验失败后不应写 STOCK_CHECK_REPORT + await assert.rejects(async () => { + await reportCheck(check.id, 1, 1); + }, error => error.code === 400 && /状态/.test(error.message)); + + const reportLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_REPORT'); + assert.equal(reportLogs.length, 0, 'report 失败后不应写入 STOCK_CHECK_REPORT 日志'); + + // 对照:create 成功日志仍在 + const createLogs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_CREATE'); + assert.equal(createLogs.length, 1, '对照:STOCK_CHECK_CREATE 成功日志应存在'); + }); + + it('operator 快照:operator_id/operator_name 与上下文一致', async () => { + // 真实测试工号(开发库 wms_account_store_employee:id=38,account autotest_acc_mgmt_keep,store_id=100000,status=1) + const operatorId = 38; + const operatorName = '测试工号保留'; + ctx.user = { employees_id: operatorId, employees_name: operatorName }; + + const check = await createCheck(); + delete ctx.user; + + const logs = await queryOperationLogsByCode(check.id, 'STOCK_CHECK_CREATE'); + assert.equal(logs.length, 1); + assert.equal(String(logs[0].operator_id), String(operatorId), 'operator_id 应快照 employees_id'); + assert.equal(logs[0].operator_name, operatorName, 'operator_name 应快照 employees_name'); + }); + }); + + // ------------------- patternList/patternCreate:盘点定式快速创建 ------------------- + + describe('盘点定式 patternList/patternCreate(业务层 + 方法层)', () => { + /** 静态定式测试阈值:小时数(300 天,隔离开发库真实商品最后流水集中在 250~300 天的口径) */ + const STATIC_TEST_HOURS = 7200; + /** 构造静态商品的主表创建时间(距今 330 天,超过阈值) */ + const STATIC_STOCK_AGE_DAYS = 330; + /** 构造数据序号(保证 item_code/批次号等唯一) */ + let fabricatedSeq = 0; + /** 上一个 static 用例构造的商品 ID(供再次调用排除断言) */ + let staticStockAId = null; + + /** 生成构造数据唯一后缀。 */ + function nextFabricatedSuffix() { + fabricatedSeq += 1; + return `${Date.now()}-${fabricatedSeq}`; + } + + /** 读取测试仓库 wms_store 实例(subject_config 归一化后返回)。 */ + async function fetchSubjectConfigInstance() { + return ctx.model.Store.findOne({ where: { id: TEST_WAREHOUSE_ID } }); + } + + /** + * 临时修改测试仓库 subject_config,fn 执行后恢复原值。 + * + * @param {Object} patch 待合并的配置覆盖项。 + * @param {Function} fn 配置生效期间执行的异步函数。 + * @return {Promise<*>} fn 的返回值。 + */ + async function withSubjectConfig(patch, fn) { + const store = await fetchSubjectConfigInstance(); + const previous = store.subject_config; + await store.update({ subject_config: { ...previous, ...patch } }); + try { + return await fn(); + } finally { + await ctx.model.Store.update( + { subject_config: previous }, + { where: { id: TEST_WAREHOUSE_ID } } + ); + } + } + + /** + * 业务层:按定式创建盘点任务(自动注入固定测试仓库与创建人)。 + * + * @param {Object} [params={}] 创建参数覆盖项。 + * @return {Promise} patternCreate 返回结果。 + */ + async function patternCreateRaw(params = {}) { + return ctx.service.systems.stockCheck.patternCreate({ + warehouseId: TEST_WAREHOUSE_ID, + creatorId: TEST_CREATOR_ID, + creatorName: TEST_CREATOR_NAME, + ...params, + }); + } + + /** + * 按定式收集盘点对象(业务层直调 stockCheckPatterns.collectById)。 + * + * @param {string} patternId 定式ID。 + * @return {Promise} 收集结果。 + */ + async function collectPattern(patternId) { + return ctx.service.systems.stockCheckPatterns.collectById(patternId, { + warehouseId: TEST_WAREHOUSE_ID, + }); + } + + /** + * 直查任务全部明细行(按 id 升序)。 + * + * @param {number} checkId 盘点任务ID。 + * @return {Promise>} 明细行(plain)。 + */ + async function queryCheckDetails(checkId) { + return ctx.model.StockCheckDetail.findAll({ + where: { check_id: Number(checkId) }, + order: [[ 'id', 'ASC' ]], + raw: true, + }); + } + + /** + * 构造一个全新商品主表行(raw SQL,固定测试仓库/货主)。 + * + * @param {Object} [options={}] 构造参数(itemCode/createAt/quantity/shelfLife/thresholdDays)。 + * @return {Promise} { id, itemCode }。 + */ + async function createFabricatedStock(options = {}) { + const itemCode = options.itemCode || `PATT-STOCK-${nextFabricatedSuffix()}`; + const [ result ] = await ctx.model.query( + `INSERT INTO wms_stock_warehouse + (item_code, item_name, store_id, stock_unit, item_type, create_at, + warehouse_id, is_valid, quantity, is_shelf_life_mgmt, remaining_threshold_days) + VALUES (:itemCode, '盘点定式测试商品', :storeId, '个', 'normal', :createAt, + :warehouseId, 'Y', :quantity, :shelfLife, :thresholdDays)`, + { + replacements: { + itemCode, + storeId: TEST_STORE_ID, + createAt: options.createAt || new Date(), + warehouseId: TEST_WAREHOUSE_ID, + quantity: options.quantity !== undefined ? options.quantity : 0, + shelfLife: options.shelfLife || 'N', + thresholdDays: options.thresholdDays !== undefined ? options.thresholdDays : 0, + }, + type: ctx.model.QueryTypes.INSERT, + } + ); + return { id: Number(result), itemCode }; + } + + /** + * 构造一条库存行(raw SQL,固定测试仓库/货主/库位)。 + * + * @param {Object} [options={}] 构造参数(stockId/spaceId/batchNo/quantity/expiryDate/orderNo)。 + * @return {Promise} 批次号。 + */ + async function createFabricatedStorage(options = {}) { + const batchNo = options.batchNo || `PATT-BATCH-${nextFabricatedSuffix()}`; + await ctx.model.query( + `INSERT INTO wms_storage + (warehouse_id, store_id, space_id, stock_id, batch_no, inventory_type, + quantity, expiry_date, inbound_time, inbound_order_no) + VALUES (:warehouseId, :storeId, :spaceId, :stockId, :batchNo, 'ZP', + :quantity, :expiryDate, NOW(), :orderNo)`, + { + replacements: { + warehouseId: TEST_WAREHOUSE_ID, + storeId: TEST_STORE_ID, + spaceId: options.spaceId, + stockId: options.stockId, + batchNo, + quantity: options.quantity !== undefined ? options.quantity : 5, + expiryDate: options.expiryDate || null, + orderNo: options.orderNo || `PATT-IN-${nextFabricatedSuffix()}`, + }, + type: ctx.model.QueryTypes.INSERT, + } + ); + return batchNo; + } + + /** + * 构造错发售后工单与订单明细分表行(raw SQL,固定测试仓库)。 + * + * @param {number} stockId 关联商品库存ID。 + * @return {Promise} { orderId, afterSaleNo }。 + */ + async function createFabricatedMisShipment(stockId) { + const suffix = nextFabricatedSuffix(); + const [ maxRows ] = await ctx.model.query( + 'SELECT COALESCE(MAX(order_id), 0) AS maxOrderId FROM wms_order_items_100000', + { type: ctx.model.QueryTypes.SELECT } + ); + const orderId = Number(maxRows.maxOrderId) + 1; + await ctx.model.query( + `INSERT INTO wms_order_items_100000 + (order_id, item_code, item_name, stock_id, actual_price, created_at, updated_at) + VALUES (:orderId, 'PATT-ITEM', '错发盘点测试商品', :stockId, 0, NOW(), NOW())`, + { + replacements: { orderId, stockId }, + type: ctx.model.QueryTypes.INSERT, + } + ); + const afterSaleNo = `AS${currentDatePart()}T${suffix}`; + await ctx.model.query( + `INSERT INTO wms_after_sale + (warehouse_id, after_sale_no, type, sub_type, status, title, creator_id, order_id) + VALUES (:warehouseId, :afterSaleNo, 'order', 'mis_shipment', 'pending', + '错发盘点测试工单', :creatorId, :orderId)`, + { + replacements: { + warehouseId: TEST_WAREHOUSE_ID, + afterSaleNo, + creatorId: TEST_CREATOR_ID, + orderId, + }, + type: ctx.model.QueryTypes.INSERT, + } + ); + return { orderId, afterSaleNo }; + } + + it('patternList:返回 5 个定式,id/name/description/type 字段完整且 type 取值合法', async () => { + const result = await ctx.service.systems.stockCheck.patternList(); + + assert.equal(result.total, 5); + assert.equal(result.patterns.length, 5); + assert.deepEqual( + result.patterns.map(item => item.id), + [ 'empty_location', 'mis_shipment', 'expiring', 'static', 'warning' ], + '定式顺序应与注册顺序一致' + ); + for (const pattern of result.patterns) { + assert.deepEqual( + Object.keys(pattern).sort(), + [ 'description', 'id', 'name', 'type' ], + '每条定式应仅包含 id/name/description/type 字段' + ); + assert.ok(pattern.id, 'id 不应为空'); + assert.ok(pattern.name, 'name 不应为空'); + assert.ok(pattern.description, 'description 不应为空'); + assert.ok([ 'location', 'goods' ].includes(pattern.type), `type 取值非法: ${pattern.type}`); + } + const locationPatterns = result.patterns.filter(item => item.type === 'location'); + assert.deepEqual(locationPatterns.map(item => item.id), [ 'empty_location' ]); + for (const goodsPattern of [ 'mis_shipment', 'expiring', 'static', 'warning' ]) { + assert.equal( + result.patterns.find(item => item.id === goodsPattern).type, + 'goods', + `${goodsPattern} 应为 goods 型定式` + ); + } + }); + + it('method 层 patternList:success 包装返回 patterns/total', async () => { + ctx.user = { id: TEST_CREATOR_ID, store_id: TEST_WAREHOUSE_ID, employees_name: TEST_CREATOR_NAME }; + + const result = await ctx.service.systemMethods.stock.check.patternList(); + + assert.equal(result.flag, 'success'); + assert.equal(result.code, 1); + assert.equal(result.data.total, 5); + assert.equal(result.data.patterns.length, 5); + }); + + it('patternCreate(warning):submitted/none_checked、type=goods、mode=open、不含 check_date、明细快照、total_items、check_no 与日志 STOCK_CHECK_CREATE(含 pattern_id)', async () => { + const title = uniqueTitle('预警定式创建'); + const result = await withSubjectConfig( + { stock_warning_enabled: true, stock_warning_quantity: 999999999 }, + async () => { + const collected = await collectPattern('warning'); + assert.ok(collected.stock_ids.length > 0, '前置:开启预警后应存在符合条件的商品'); + return patternCreateRaw({ + patternId: 'warning', + title, + remark: '定式创建测试', + }); + } + ); + + assert.equal(result.pattern_id, 'warning'); + const check = result.check; + assert.match(check.check_no, /^PD\d{14}$/, `应生成盘点单号: ${check.check_no}`); + assert.equal(check.status, 'submitted', '定式创建的任务应直接进入待审核'); + assert.equal(check.detail_status, 'none_checked'); + assert.equal(check.type, 'goods', 'warning 定式应为按商品盘点'); + assert.equal(check.mode, 'open', '商品类定式应固定明盘(open)'); + assert.equal( + Object.prototype.hasOwnProperty.call(check, 'check_date'), + false, + 'patternCreate 返回不应含 check_date 字段' + ); + assert.equal(check.start_time, null, '定式创建任务 start_time 应为空'); + assert.equal(check.end_time, null, '定式创建任务 end_time 应为空'); + assert.equal(check.title, title); + assert.equal(check.creator_id, TEST_CREATOR_ID); + assert.ok(result.total_items > 0, '应有明细行'); + + const row = await findCheckRow(check.id); + assert.equal(Number(row.warehouse_id), TEST_WAREHOUSE_ID); + assert.equal(row.status, 'submitted'); + assert.equal(row.total_items, result.total_items); + assert.equal( + Object.prototype.hasOwnProperty.call(row, 'check_date'), + false, + '主表行不应含 check_date 字段' + ); + + const details = await queryCheckDetails(check.id); + const detailStockIds = new Set(details.map(detail => Number(detail.stock_id))); + assert.equal(detailStockIds.size, result.total_items, 'total_items 应按商品计数(多库位商品拆多行仍计 1 项)'); + assert.ok(details.length >= result.total_items, '明细行数应不少于商品数(按「商品+库位」拆行)'); + for (const detail of details) { + assert.equal(detail.scope_type, 'goods'); + assert.ok(detail.stock_id, '商品明细应含 stock_id'); + assert.ok(detail.item_code, '商品明细应含商品编码快照'); + } + + const logs = await ctx.model.OperationLog.findAll({ + where: { + business_type: 'stock_check', + business_id: String(check.id), + operation_code: 'STOCK_CHECK_CREATE', + }, + raw: true, + }); + assert.equal(logs.length, 1, '应写入 1 条 STOCK_CHECK_CREATE 日志'); + assert.ok(logs[0].message && logs[0].message.includes('warning'), `日志应含 pattern_id: ${logs[0].message}`); + assert.ok(logs[0].message && logs[0].message.includes(check.check_no), '日志应含盘点单号'); + assert.equal(Number(logs[0].warehouse_id), TEST_WAREHOUSE_ID); + }); + + it('patternCreate 参数校验:定式不存在/缺仓库 → 400 且未创建任务(mode/check_date 已移除入参)', async () => { + const beforeRow = await ctx.model.StockCheck.findOne({ + attributes: [ 'id' ], + order: [[ 'id', 'DESC' ]], + raw: true, + }); + const beforeMax = beforeRow ? Number(beforeRow.id) : 0; + + await assert.rejects(async () => { + await patternCreateRaw({ patternId: 'not_exists' }); + }, error => error.code === 400 && /盘点定式不存在/.test(error.message)); + + await assert.rejects(async () => { + await ctx.service.systems.stockCheck.patternCreate({ + warehouseId: 0, + patternId: 'warning', + }); + }, error => error.code === 400 && /仓库/.test(error.message)); + + const afterRow = await ctx.model.StockCheck.findOne({ + attributes: [ 'id' ], + order: [[ 'id', 'DESC' ]], + raw: true, + }); + assert.equal(afterRow ? Number(afterRow.id) : 0, beforeMax, '参数非法时不应创建任务'); + }); + + it('empty_location 收集口径:直查 wms_storage 对比,账面为空库位入库、有库存库位不入', async () => { + const { Op } = ctx.app.Sequelize; + const emptySpace = await ctx.model.LocationSpace.findOne({ + where: { warehouse_id: TEST_WAREHOUSE_ID, space_code: TEST_EMPTY_LOCATION_CODE }, + attributes: [ 'id' ], + raw: true, + }); + const emptyStorageCnt = await ctx.model.Storage.count({ + where: { space_id: Number(emptySpace.id), quantity: { [Op.gt]: 0 } }, + }); + const stockStorageCnt = await ctx.model.Storage.count({ + where: { space_id: TEST_LOCATION_ID, quantity: { [Op.gt]: 0 } }, + }); + assert.equal(emptyStorageCnt, 0, `前置:${TEST_EMPTY_LOCATION_CODE} 应无 quantity>0 库存`); + assert.ok(stockStorageCnt > 0, `前置:${TEST_LOCATION_CODE} 应有 quantity>0 库存`); + + const collected = await collectPattern('empty_location'); + const codes = collected.locations.map(item => item.location_code); + assert.ok(codes.includes(TEST_EMPTY_LOCATION_CODE), '账面为空库位应被收集'); + assert.ok(!codes.includes(TEST_LOCATION_CODE), '有库存库位不应被收集'); + for (const location of collected.locations) { + assert.ok(Number(location.location_id) > 0, 'location_id 应为正整数'); + assert.ok(location.location_code, 'location_code 不应为空'); + } + }); + + it('empty_location patternCreate:明细只含空库位(location 行)、total_items=收集数、mode=blind、不含 check_date', async () => { + const collected = await collectPattern('empty_location'); + assert.ok(collected.locations.length > 0, '前置:应存在账面为空库位'); + + const result = await patternCreateRaw({ + patternId: 'empty_location', + title: uniqueTitle('空库位定式创建'), + }); + + assert.equal(result.pattern_id, 'empty_location'); + assert.equal(result.check.type, 'location'); + assert.equal(result.check.status, 'submitted'); + assert.equal(result.check.mode, 'blind', '库位类定式应固定盲盘(blind)'); + assert.equal( + Object.prototype.hasOwnProperty.call(result.check, 'check_date'), + false, + 'patternCreate 返回不应含 check_date 字段' + ); + assert.equal(result.check.start_time, null, '定式创建任务 start_time 应为空'); + assert.equal(result.check.end_time, null, '定式创建任务 end_time 应为空'); + assert.equal(result.total_items, collected.locations.length); + + const details = await queryCheckDetails(result.check.id); + assert.equal(details.length, result.total_items); + const collectedCodes = new Set(collected.locations.map(item => item.location_code)); + for (const detail of details) { + assert.equal(detail.scope_type, 'location', '库位明细行 scope_type 应为 location'); + assert.equal(detail.stock_id, null, '库位明细行不应含 stock_id'); + assert.ok(Number(detail.location_id) > 0, '库位明细行应含 location_id'); + assert.ok(collectedCodes.has(detail.location_code), `明细库位应属于收集结果: ${detail.location_code}`); + } + assert.ok( + details.some(item => item.location_code === TEST_EMPTY_LOCATION_CODE), + '明细应含账面为空库位' + ); + assert.ok( + !details.some(item => item.location_code === TEST_LOCATION_CODE), + '明细不应含有库存库位' + ); + }); + + it('warning 定式:开启配置后低于阈值商品入明细;关闭配置 → 400 未开启库存预警', async () => { + let lowStockId = 0; + await withSubjectConfig( + { stock_warning_enabled: true, stock_warning_quantity: 2 }, + async () => { + const lowStock = await createFabricatedStock({ quantity: 1 }); + lowStockId = lowStock.id; + // 商品必须有库存库位才能入明细(商品任务按库位盘点拆行) + await createFabricatedStorage({ stockId: lowStock.id, spaceId: TEST_LOCATION_ID, quantity: 1 }); + const collected = await collectPattern('warning'); + assert.ok(collected.stock_ids.includes(lowStock.id), '低于阈值商品应被收集'); + + const result = await patternCreateRaw({ + patternId: 'warning', + title: uniqueTitle('预警阈值创建'), + }); + const details = await queryCheckDetails(result.check.id); + assert.ok( + details.some(item => Number(item.stock_id) === lowStock.id), + '低于阈值商品应写入明细' + ); + } + ); + assert.ok(lowStockId > 0, '前置:应已构造低于阈值商品'); + + await assert.rejects(async () => { + await patternCreateRaw({ patternId: 'warning' }); + }, error => error.code === 400 && /未开启库存预警/.test(error.message)); + }); + + it('static 定式:超时商品入明细,创建后写入 wms_stock_static_check_task', async () => { + const stockA = await createFabricatedStock({ + itemCode: `PATT-STATIC-A-${nextFabricatedSuffix()}`, + createAt: new Date(Date.now() - STATIC_STOCK_AGE_DAYS * 24 * 3600 * 1000), + }); + staticStockAId = stockA.id; + await createFabricatedStorage({ stockId: stockA.id, spaceId: TEST_LOCATION_ID, quantity: 1 }); + + const result = await withSubjectConfig( + { stock_static_hours: STATIC_TEST_HOURS }, + async () => { + const collected = await collectPattern('static'); + assert.ok(collected.stock_ids.includes(stockA.id), '构造的超时商品应被收集'); + return patternCreateRaw({ + patternId: 'static', + title: uniqueTitle('静态定式创建'), + }); + } + ); + + assert.equal(result.pattern_id, 'static'); + assert.equal(result.check.type, 'goods'); + assert.equal(result.check.mode, 'open', '商品类定式应固定明盘(open)'); + const details = await queryCheckDetails(result.check.id); + assert.ok(details.some(item => Number(item.stock_id) === stockA.id), '超时商品应写入明细'); + + const taskRows = await ctx.model.StockStaticCheckTask.findAll({ + where: { stock_id: stockA.id }, + raw: true, + }); + assert.ok(taskRows.length >= 1, '创建成功后应写入静态盘点任务关联记录'); + }); + + it('static 再次调用:已盘商品被排除,明细不再包含', async () => { + assert.ok(staticStockAId > 0, '前置:上一个用例应已构造静态商品 A'); + const stockB = await createFabricatedStock({ + itemCode: `PATT-STATIC-B-${nextFabricatedSuffix()}`, + createAt: new Date(Date.now() - STATIC_STOCK_AGE_DAYS * 24 * 3600 * 1000), + }); + await createFabricatedStorage({ stockId: stockB.id, spaceId: TEST_LOCATION_ID, quantity: 1 }); + + const result = await withSubjectConfig( + { stock_static_hours: STATIC_TEST_HOURS }, + async () => { + const collected = await collectPattern('static'); + assert.ok(collected.stock_ids.includes(stockB.id), '新构造超时商品应被收集'); + assert.ok( + !collected.stock_ids.includes(staticStockAId), + '已写入静态任务记录的商品应被排除' + ); + return patternCreateRaw({ + patternId: 'static', + title: uniqueTitle('静态定式再次创建'), + }); + } + ); + + const details = await queryCheckDetails(result.check.id); + assert.ok(details.some(item => Number(item.stock_id) === stockB.id), '再次调用应只含新超时商品'); + assert.ok( + !details.some(item => Number(item.stock_id) === staticStockAId), + '已盘商品不应再出现在明细中' + ); + }); + + it('expiring 定式:构造保质期管理商品与已过期库存 → 入明细', async () => { + const expiryStock = await createFabricatedStock({ + itemCode: `PATT-EXP-${nextFabricatedSuffix()}`, + shelfLife: 'Y', + thresholdDays: null, + }); + await createFabricatedStorage({ + stockId: expiryStock.id, + spaceId: TEST_LOCATION_ID, + quantity: 3, + expiryDate: new Date(Date.now() - 24 * 3600 * 1000), + }); + + const collected = await collectPattern('expiring'); + assert.ok(collected.stock_ids.includes(expiryStock.id), '临期商品应被收集'); + + const result = await patternCreateRaw({ + patternId: 'expiring', + title: uniqueTitle('临期定式创建'), + }); + assert.equal(result.check.type, 'goods'); + const details = await queryCheckDetails(result.check.id); + assert.ok( + details.some(item => Number(item.stock_id) === expiryStock.id), + '临期商品应写入明细' + ); + }); + + it('mis_shipment 定式:构造错发工单与订单明细商品 → 入明细', async () => { + const stocks = await fetchStockRows(1); + assert.equal(stocks.length, 1); + const stockId = Number(stocks[0].id); + await createFabricatedMisShipment(stockId); + + const collected = await collectPattern('mis_shipment'); + assert.ok(collected.stock_ids.includes(stockId), '错发工单关联商品应被收集'); + + const result = await patternCreateRaw({ + patternId: 'mis_shipment', + title: uniqueTitle('错发定式创建'), + }); + assert.equal(result.check.type, 'goods'); + const details = await queryCheckDetails(result.check.id); + assert.ok( + details.some(item => Number(item.stock_id) === stockId), + '错发商品应写入明细' + ); + }); + + it('无符合条件的商品 → 400「没有符合条件的商品」且未创建任务', async () => { + const beforeRow = await ctx.model.StockCheck.findOne({ + attributes: [ 'id' ], + order: [[ 'id', 'DESC' ]], + raw: true, + }); + const beforeMax = beforeRow ? Number(beforeRow.id) : 0; + + await withSubjectConfig( + { stock_warning_enabled: true, stock_warning_quantity: 0 }, + async () => { + await assert.rejects(async () => { + await patternCreateRaw({ patternId: 'warning' }); + }, error => error.code === 400 && /没有符合条件的商品/.test(error.message)); + } + ); + + const afterRow = await ctx.model.StockCheck.findOne({ + attributes: [ 'id' ], + order: [[ 'id', 'DESC' ]], + raw: true, + }); + assert.equal(afterRow ? Number(afterRow.id) : 0, beforeMax, '无对象时不应创建任务'); + }); + + it('method 层 patternCreate:驼峰 patternId 兼容、仓库注入、定式不存在/缺仓库 400 包装', async () => { + ctx.user = { id: TEST_CREATOR_ID, store_id: TEST_WAREHOUSE_ID, employees_name: TEST_CREATOR_NAME }; + + const result = await ctx.service.systemMethods.stock.check.patternCreate({ + patternId: 'mis_shipment', + title: uniqueTitle('方法层驼峰创建'), + }); + assert.equal(result.flag, 'success'); + assert.equal(result.code, 1); + assert.equal(result.data.pattern_id, 'mis_shipment'); + assert.equal(result.data.check.status, 'submitted'); + assert.ok(result.data.total_items >= 1, '错发定式应收集到商品'); + const row = await findCheckRow(result.data.check.id); + assert.equal(Number(row.warehouse_id), TEST_WAREHOUSE_ID, '仓库应由 ctx.user.store_id 注入'); + + const notFound = await ctx.service.systemMethods.stock.check.patternCreate({ + pattern_id: 'not_exists', + }); + assert.equal(notFound.flag, 'failure'); + assert.equal(notFound.code, 400); + assert.match(notFound.message, /盘点定式不存在/); + + ctx.user = null; + const noWarehouse = await ctx.service.systemMethods.stock.check.patternCreate({ + pattern_id: 'mis_shipment', + }); + assert.equal(noWarehouse.flag, 'failure'); + assert.equal(noWarehouse.code, 400); + assert.match(noWarehouse.message, /仓库/); + }); + }); + + // ------------------- systemMethods.stock.check:方法包装层 ------------------- + + describe('systemMethods.stock.check 方法包装层', () => { + /** + * 设置当前上下文的用户信息(模拟登录用户,仓库固定 100000)。 + */ + function mockCurrentUser() { + ctx.user = { + id: TEST_CREATOR_ID, + store_id: TEST_WAREHOUSE_ID, + employees_name: TEST_CREATOR_NAME, + }; + } + + it('create:注入仓库上下文并统一 success 包装', async () => { + mockCurrentUser(); + + const result = await ctx.service.systemMethods.stock.check.create({ + title: uniqueTitle('方法层创建'), + type: 'location', + mode: 'open', + }); + + assert.equal(result.flag, 'success'); + assert.equal(result.code, 1); + assert.match(result.data.check_no, /^PD\d{14}$/); + assert.equal(result.data.status, 'created'); + assert.equal(result.data.creator_id, TEST_CREATOR_ID, '创建人应由上下文注入'); + assert.equal(result.data.creator_name, TEST_CREATOR_NAME); + + const row = await findCheckRow(result.data.id); + assert.equal(row.warehouse_id, TEST_WAREHOUSE_ID, '仓库 ID 应由 ctx.user.store_id 注入'); + assert.equal( + Object.prototype.hasOwnProperty.call(result.data, 'check_date'), + false, + '方法层 create 返回不应含 check_date 字段' + ); + assert.equal( + Object.prototype.hasOwnProperty.call(row, 'check_date'), + false, + '主表行不应含 check_date 字段' + ); + assert.equal(row.start_time, null, '创建时 start_time 应为空'); + assert.equal(row.end_time, null, '创建时 end_time 应为空'); + }); + + it('list:where.status 数组筛选与统一 success 包装', async () => { + mockCurrentUser(); + + const result = await ctx.service.systemMethods.stock.check.list({ + pagination: { page: 1, pageSize: 10 }, + where: { status: [ 'created', 'submitted' ] }, + }); + + assert.equal(result.flag, 'success'); + assert.equal(result.code, 1); + assert.ok(Array.isArray(result.data.rows)); + assert.ok(Number(result.data.total) >= result.data.rows.length, 'total 应不小于当前页行数'); + for (const row of result.data.rows) { + assert.ok([ 'created', 'submitted' ].includes(row.status)); + } + }); + + it('list:where.type 标准结构(operator/eq/value)只返回 location 任务', async () => { + mockCurrentUser(); + + const locationCheck = await createCheck({ type: 'location', title: uniqueTitle('方法层type标准结构') }); + const goodsCheck = await createCheck({ title: uniqueTitle('方法层type标准结构') }); + + const result = await ctx.service.systemMethods.stock.check.list({ + pagination: { page: 1, pageSize: 200 }, + where: { type: { operator: 'eq', value: 'location' } }, + }); + + assert.equal(result.flag, 'success'); + assert.equal(result.code, 1); + const ids = result.data.rows.map(row => row.id); + assert.ok(ids.includes(locationCheck.id), '标准结构 eq=location 应命中 location 任务'); + assert.ok(!ids.includes(goodsCheck.id), '标准结构 eq=location 不应命中 goods 任务'); + for (const row of result.data.rows) { + assert.equal(row.type, 'location', '标准结构筛选结果只能包含 location 任务'); + } + }); + + it('list:where.type 数组 in 与 where.mode 组合筛选', async () => { + mockCurrentUser(); + + const goodsOpen = await createCheck({ type: 'goods', mode: 'open', title: uniqueTitle('方法层in-mode组合') }); + const locationBlind = await createCheck({ type: 'location', title: uniqueTitle('方法层in-mode组合') }); + + const typeInResult = await ctx.service.systemMethods.stock.check.list({ + pagination: { page: 1, pageSize: 200 }, + where: { type: [ 'location', 'goods' ] }, + }); + assert.equal(typeInResult.flag, 'success'); + const typeInIds = typeInResult.data.rows.map(row => row.id); + assert.ok(typeInIds.includes(goodsOpen.id), 'goods 任务应命中 type in 数组'); + assert.ok(typeInIds.includes(locationBlind.id), 'location 任务应命中 type in 数组'); + for (const row of typeInResult.data.rows) { + assert.ok([ 'location', 'goods' ].includes(row.type), `非法类型出现在 in 筛选结果: ${row.type}`); + } + + const modeResult = await ctx.service.systemMethods.stock.check.list({ + pagination: { page: 1, pageSize: 200 }, + where: { mode: 'blind' }, + }); + assert.equal(modeResult.flag, 'success'); + const modeIds = modeResult.data.rows.map(row => row.id); + assert.ok(modeIds.includes(locationBlind.id), '盲盘任务应命中 mode=blind'); + assert.ok(!modeIds.includes(goodsOpen.id), '明盘任务不应命中 mode=blind'); + }); + + it('list:where.store_id 货主筛选与 where.created_at between(标准结构)', async () => { + mockCurrentUser(); + + const storeCheck = await createCheck({ type: 'store', storeId: TEST_STORE_ID, title: uniqueTitle('方法层store_id') }); + const storeResult = await ctx.service.systemMethods.stock.check.list({ + pagination: { page: 1, pageSize: 200 }, + where: { store_id: TEST_STORE_ID }, + }); + assert.equal(storeResult.flag, 'success'); + const storeIds = storeResult.data.rows.map(row => row.id); + assert.ok(storeIds.includes(storeCheck.id), '固定测试货主的任务应命中 where.store_id'); + for (const row of storeResult.data.rows) { + assert.equal(Number(row.store_id), TEST_STORE_ID, 'where.store_id 筛选结果只能包含固定测试货主'); + } + + const inRangeCheck = await createCheck({ title: uniqueTitle('方法层created_at区间') }); + const outRangeCheck = await createCheck({ title: uniqueTitle('方法层created_at区间') }); + await setCheckCreatedAt(inRangeCheck.id, new Date('2019-06-15T00:00:00Z')); + const betweenResult = await ctx.service.systemMethods.stock.check.list({ + pagination: { page: 1, pageSize: 200 }, + where: { + created_at: { + operator: 'between', + value: { from: '2019-01-01', to: '2019-12-31' }, + }, + }, + }); + assert.equal(betweenResult.flag, 'success'); + const betweenIds = betweenResult.data.rows.map(row => row.id); + assert.ok(betweenIds.includes(inRangeCheck.id), '标准结构 between 应命中 2019 年创建的任务'); + assert.ok(!betweenIds.includes(outRangeCheck.id), '标准结构 between 不应命中 2019 年外创建的任务'); + }); + + it('addDetail:业务错误码 400 经方法层包装为 failure', async () => { + mockCurrentUser(); + + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + + const result = await ctx.service.systemMethods.stock.check.addDetail({ + id: check.id, + stock_ids: [ stocks[0].id ], + }); + + assert.equal(result.flag, 'failure'); + assert.equal(result.code, 400, 'submitted 状态添加明细应包装为 400'); + assert.ok(result.message, '应返回错误文案'); + }); + + it('addDetail:location_ids(snake)与 locationIds(驼峰)均可用并成功包装', async () => { + mockCurrentUser(); + + const snakeCheck = await createCheck({ type: 'location' }); + const snakeResult = await ctx.service.systemMethods.stock.check.addDetail({ + id: snakeCheck.id, + location_ids: [ TEST_LOCATION_ID ], + }); + assert.equal(snakeResult.flag, 'success'); + assert.equal(snakeResult.code, 1); + assert.equal(snakeResult.data.added, 1); + assert.equal(snakeResult.data.skipped, 0); + assert.deepEqual(snakeResult.data.invalid_location_ids, []); + assert.equal(snakeResult.data.total_items, 1); + + const camelCheck = await createCheck({ type: 'location' }); + const camelResult = await ctx.service.systemMethods.stock.check.addDetail({ + id: camelCheck.id, + locationIds: [ TEST_LOCATION_ID ], + }); + assert.equal(camelResult.flag, 'success'); + assert.equal(camelResult.code, 1); + assert.equal(camelResult.data.added, 1); + assert.deepEqual(camelResult.data.invalid_location_ids, []); + + for (const checkId of [ snakeCheck.id, camelCheck.id ]) { + const row = await ctx.model.StockCheckDetail.findOne({ + where: { check_id: checkId }, + raw: true, + }); + assert.equal(Number(row.location_id), TEST_LOCATION_ID, '方法层库位行应落库 location_id'); + assert.equal(row.location_code, TEST_LOCATION_CODE, '方法层库位行应落库 location_code'); + } + }); + + it('addLocationDetail:方法层成功包装(snake/驼峰均可用),商品型任务转调报 400 包装为 failure', async () => { + mockCurrentUser(); + + const snakeCheck = await createCheck({ type: 'location' }); + const snakeResult = await ctx.service.systemMethods.stock.check.addLocationDetail({ + id: snakeCheck.id, + location_ids: [ TEST_LOCATION_ID ], + }); + assert.equal(snakeResult.flag, 'success'); + assert.equal(snakeResult.code, 1); + assert.equal(snakeResult.data.added, 1); + assert.equal(snakeResult.data.skipped, 0); + assert.deepEqual(snakeResult.data.invalid_location_ids, []); + assert.equal(snakeResult.data.total_items, 1); + + const camelCheck = await createCheck({ type: 'location' }); + const camelResult = await ctx.service.systemMethods.stock.check.addLocationDetail({ + id: camelCheck.id, + locationIds: [ TEST_LOCATION_ID ], + }); + assert.equal(camelResult.flag, 'success'); + assert.equal(camelResult.code, 1); + assert.equal(camelResult.data.added, 1); + assert.deepEqual(camelResult.data.invalid_location_ids, []); + + // 商品型任务转调 addDetail 报 400,经方法层包装为 failure + const goodsCheck = await createCheck(); + const failure = await ctx.service.systemMethods.stock.check.addLocationDetail({ + id: goodsCheck.id, + location_ids: [ TEST_LOCATION_ID ], + }); + assert.equal(failure.flag, 'failure'); + assert.equal(failure.code, 400); + assert.match(failure.message, /按商品盘点,不能添加库位明细/); + }); + + it('detail:success 包装只返回任务本身信息({ check }),不含明细 rows/total', async () => { + mockCurrentUser(); + + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + + const result = await ctx.service.systemMethods.stock.check.detail({ + id: check.id, + }); + + assert.equal(result.flag, 'success'); + assert.equal(result.code, 1); + assert.deepEqual(Object.keys(result.data).sort(), [ 'check' ], '方法层 detail 只返回 check'); + assert.equal(result.data.rows, undefined, '方法层 detail 不应返回明细 rows'); + assert.equal(result.data.total, undefined, '方法层 detail 不应返回明细 total'); + assert.equal(Number(result.data.check.id), Number(check.id)); + assert.equal(result.data.check.check_no, check.check_no); + assert.equal(result.data.check.total_items, 1, 'check.total_items 应为明细行数'); + }); + + it('detail:任务ID 非法 / 任务不存在经方法层包装为 failure 400', async () => { + mockCurrentUser(); + + const invalid = await ctx.service.systemMethods.stock.check.detail({ id: 0 }); + assert.equal(invalid.flag, 'failure'); + assert.equal(invalid.code, 400); + assert.match(invalid.message, /盘点任务ID不能为空/); + + const missing = await ctx.service.systemMethods.stock.check.detail({ id: await findFreeCheckId() }); + assert.equal(missing.flag, 'failure'); + assert.equal(missing.code, 400); + assert.match(missing.message, /盘点任务不存在/); + }); + + it('result:仓库上下文注入、success 包装返回盘点结果聚合', async () => { + mockCurrentUser(); + + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detailId = details.rows[0].id; + const snapshot = Number(details.rows[0].system_quantity); + await reportCheck(check.id, detailId, snapshot + 3, TEST_LOCATION_CODE); + + const result = await ctx.service.systemMethods.stock.check.result({ + id: check.id, + }); + + assert.equal(result.flag, 'success'); + assert.equal(result.code, 1); + assert.equal(result.data.total, 1); + assert.equal(result.data.rows.length, 1); + const row = result.data.rows[0]; + assert.equal(Number(row.check_id), check.id, '范围行应关联盘点任务'); + assert.equal(Number(row.warehouse_id), TEST_WAREHOUSE_ID, '仓库应由 ctx.user.store_id 注入'); + assert.equal(row.checked_quantity, snapshot + 3, '已盘数量=各库位记录合计'); + assert.equal(row.diff_quantity, 3); + assert.equal(row.is_diff, 1); + assert.equal(row.status, 'checked'); + assert.equal(row.records.length, 1); + assert.deepEqual(row.location_codes, [ TEST_LOCATION_CODE ]); + const checkedLocation = row.locations.find(item => item.location_code === TEST_LOCATION_CODE); + assert.ok(checkedLocation, '应含已盘库位'); + assert.equal(Number(checkedLocation.location_id), TEST_LOCATION_ID, '命中库位应回填 location_id'); + assert.equal(Number(checkedLocation.quantity), snapshot + 3, '已盘库位实盘应为上报值'); + }); + + it('result:任务不存在包装为 failure 400', async () => { + mockCurrentUser(); + + const result = await ctx.service.systemMethods.stock.check.result({ + id: 999999999, + }); + + assert.equal(result.flag, 'failure'); + assert.equal(result.code, 400); + assert.ok(result.message, '应返回错误文案'); + }); + + it('report:注入仓库/盘点人上下文,success 包装返回作业记录', async () => { + mockCurrentUser(); + + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const result = await ctx.service.systemMethods.stock.check.report({ + id: check.id, + detail_id: details.rows[0].id, + quantity: 6, + location: TEST_LOCATION_CODE, + space_id: TEST_LOCATION_ID, + }); + + assert.equal(result.flag, 'success'); + assert.equal(result.code, 1); + assert.equal(Number(result.data.record.warehouse_id), TEST_WAREHOUSE_ID, '仓库 ID 应由 ctx.user.store_id 注入'); + assert.equal(Number(result.data.record.checker_id), TEST_CREATOR_ID, '盘点人 ID 应由上下文注入'); + assert.equal(result.data.record.checker_name, TEST_CREATOR_NAME); + assert.equal(Number(result.data.record.quantity), 6); + assert.equal(Number(result.data.record.location_id), TEST_LOCATION_ID, '库位以 space_id 为准'); + assert.equal(result.data.detail_status, 'all_checked'); + }); + + it('report:方法层未携带 space_id 包装为 failure 400', async () => { + mockCurrentUser(); + + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const result = await ctx.service.systemMethods.stock.check.report({ + id: check.id, + detail_id: details.rows[0].id, + quantity: 6, + location: TEST_LOCATION_CODE, + }); + assert.equal(result.flag, 'failure'); + assert.equal(result.code, 400); + assert.ok(result.message.includes('缺少库位ID'), '缺少库位ID应返回明确文案'); + }); + + it('report:方法层透传 space_id/locationId 别名,按库位ID落库', async () => { + mockCurrentUser(); + + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const snake = await ctx.service.systemMethods.stock.check.report({ + id: check.id, + detail_id: details.rows[0].id, + quantity: 2, + location: TEST_LOCATION_CODE, + space_id: TEST_LOCATION_ID, + }); + assert.equal(snake.flag, 'success'); + assert.equal(Number(snake.data.record.location_id), TEST_LOCATION_ID, 'space_id 别名应透传为 locationId'); + + const camel = await ctx.service.systemMethods.stock.check.report({ + id: check.id, + detail_id: details.rows[0].id, + quantity: 3, + location: TEST_LOCATION_CODE, + locationId: TEST_LOCATION_ID, + }); + assert.equal(camel.flag, 'success'); + assert.equal(Number(camel.data.record.location_id), TEST_LOCATION_ID, 'locationId 驼峰应透传'); + + const tooLarge = await ctx.service.systemMethods.stock.check.report({ + id: check.id, + detail_id: details.rows[0].id, + quantity: 6955416422066, + location: TEST_LOCATION_CODE, + }); + assert.equal(tooLarge.flag, 'failure'); + assert.equal(tooLarge.code, 400, '超限数量应返回业务 400 而非 500'); + }); + + it('markEmpty:方法层 success 包装(库位任务)+ 非库位任务 failure 400', async () => { + mockCurrentUser(); + + const check = await createCheck({ type: 'location' }); + await addLocationDetail(check.id, [ TEST_EMPTY_LOCATION_CODE ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const result = await ctx.service.systemMethods.stock.check.markEmpty({ + id: check.id, + detail_id: details.rows[0].id, + }); + assert.equal(result.flag, 'success'); + assert.equal(result.code, 1); + assert.equal(result.data.record.is_empty, true); + assert.equal(result.data.detail_status, 'all_checked'); + + const goodsCheck = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(goodsCheck.id, [ stocks[0].id ]); + await submitCheck(goodsCheck.id); + await auditCheck(goodsCheck.id, 'approve'); + const goodsDetails = await detailCheck(goodsCheck.id); + const failure = await ctx.service.systemMethods.stock.check.markEmpty({ + id: goodsCheck.id, + detail_id: goodsDetails.rows[0].id, + }); + assert.equal(failure.flag, 'failure'); + assert.equal(failure.code, 400); + assert.match(failure.message, /仅库位盘点任务支持空库位标记/); + }); + + it('recordList:方法层 success 包装,按任务查询记录并回填商品信息', async () => { + mockCurrentUser(); + + const check = await createCheck(); + const stocks = await fetchStockRows(2); + await addDetail(check.id, stocks.map(stock => stock.id)); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + await reportCheck(check.id, details.rows[0].id, 3, TEST_LOCATION_CODE); + await reportCheck(check.id, details.rows[1].id, 4); + + const result = await ctx.service.systemMethods.stock.check.recordList({ + id: check.id, + pagination: { page: 1, pageSize: 10 }, + }); + + assert.equal(result.flag, 'success'); + assert.equal(result.code, 1); + assert.equal(result.data.total, 2); + assert.equal(result.data.rows.length, 2); + for (const row of result.data.rows) { + assert.equal(Number(row.check_id), check.id, '记录应限定在指定任务'); + assert.equal(Number(row.warehouse_id), TEST_WAREHOUSE_ID, '仓库应由 ctx.user.store_id 注入'); + assert.ok(row.item_code, '记录应回填商品编码'); + } + }); + + it('recordDelete:方法层批量兼容 record_ids/recordIds/record_id 三种写法,未命中计入 skipped、删除后汇总回退', async () => { + mockCurrentUser(); + + const check = await createCheck(); + const stocks = await fetchStockRows(1); + await addDetail(check.id, [ stocks[0].id ]); + await submitCheck(check.id); + await auditCheck(check.id, 'approve'); + + const details = await detailCheck(check.id); + const detailId = details.rows[0].id; + const first = await reportCheck(check.id, detailId, 3, TEST_LOCATION_CODE); + const second = await reportCheck(check.id, detailId, 4, TEST_LOCATION_CODE_2); + + // record_ids 下划线数组写法(批量入口),混入不存在的 ID 计入 skipped + const snakeResult = await ctx.service.systemMethods.stock.check.recordDelete({ + id: check.id, + record_ids: [ first.record.id, 999999999 ], + }); + assert.equal(snakeResult.flag, 'success', `record_ids 批量删除应成功: ${snakeResult.message}`); + assert.equal(snakeResult.code, 1); + assert.equal(snakeResult.data.deleted_count, 1); + assert.deepEqual(snakeResult.data.deleted_ids.map(Number), [ Number(first.record.id) ]); + assert.deepEqual(snakeResult.data.skipped_ids, [ 999999999 ], '未命中记录应计入 skipped_ids'); + assert.equal(snakeResult.data.checked_items, 1, '删除一条后仍有一条记录'); + + // recordId 驼峰单值写法(单值自动转数组) + const camelResult = await ctx.service.systemMethods.stock.check.recordDelete({ + id: check.id, + recordId: second.record.id, + }); + assert.equal(camelResult.flag, 'success', `recordId 单值删除应成功: ${camelResult.message}`); + assert.equal(camelResult.data.deleted_count, 1); + assert.deepEqual(camelResult.data.deleted_ids.map(Number), [ Number(second.record.id) ]); + assert.equal(camelResult.data.checked_items, 0, '全部删除后已盘回退为 0'); + assert.equal(camelResult.data.detail_status, 'none_checked'); + }); + + it('detailDelete:detail_ids/detailIds/detail_id 三种写法兼容、success 包装、未命中计入 skipped、状态限制包装为 failure', async () => { + mockCurrentUser(); + + const check = await createCheck(); + const stocks = await fetchStockRows(3); + await addDetail(check.id, stocks.map(stock => stock.id)); + const details = await detailCheck(check.id); + assert.equal(details.total, 3, '前置:任务应有 3 条明细'); + + // detail_ids 下划线数组写法(批量入口) + const snakeResult = await ctx.service.systemMethods.stock.check.detailDelete({ + id: check.id, + detail_ids: [ details.rows[0].id ], + }); + assert.equal(snakeResult.flag, 'success'); + assert.equal(snakeResult.code, 1); + assert.equal(snakeResult.data.deleted_count, 1); + assert.deepEqual(snakeResult.data.deleted_ids.map(Number), [ Number(details.rows[0].id) ]); + assert.deepEqual(snakeResult.data.skipped_ids, []); + assert.equal(snakeResult.data.total_items, 2); + + // detailIds 驼峰写法(兼容别名,单值自动转数组) + const camelResult = await ctx.service.systemMethods.stock.check.detailDelete({ + id: check.id, + detailIds: details.rows[1].id, + }); + assert.equal(camelResult.flag, 'success'); + assert.equal(camelResult.code, 1); + assert.equal(camelResult.data.deleted_count, 1); + assert.deepEqual(camelResult.data.deleted_ids.map(Number), [ Number(details.rows[1].id) ]); + assert.deepEqual(camelResult.data.skipped_ids, []); + assert.equal(camelResult.data.total_items, 1); + + // detail_id 旧版单值写法(兼容入口,单值自动转数组) + const legacyResult = await ctx.service.systemMethods.stock.check.detailDelete({ + id: check.id, + detail_id: details.rows[2].id, + }); + assert.equal(legacyResult.flag, 'success'); + assert.equal(legacyResult.code, 1); + assert.equal(legacyResult.data.deleted_count, 1); + assert.deepEqual(legacyResult.data.deleted_ids.map(Number), [ Number(details.rows[2].id) ]); + assert.deepEqual(legacyResult.data.skipped_ids, []); + assert.equal(legacyResult.data.total_items, 0); + + // 已删除明细再次删除:未命中 → success + skipped_ids(不再报 400) + const repeatedResult = await ctx.service.systemMethods.stock.check.detailDelete({ + id: check.id, + detail_id: details.rows[0].id, + }); + assert.equal(repeatedResult.flag, 'success'); + assert.equal(repeatedResult.code, 1); + assert.equal(repeatedResult.data.deleted_count, 0); + assert.deepEqual(repeatedResult.data.deleted_ids, []); + assert.deepEqual(repeatedResult.data.skipped_ids.map(Number), [ Number(details.rows[0].id) ]); + + // 状态不允许 → failure 400 包装 + const submittedCheck = await createCheck(); + const submittedStocks = await fetchStockRows(1); + await addDetail(submittedCheck.id, [ submittedStocks[0].id ]); + await submitCheck(submittedCheck.id); + const submittedDetails = await detailCheck(submittedCheck.id); + const statusFailure = await ctx.service.systemMethods.stock.check.detailDelete({ + id: submittedCheck.id, + detail_ids: [ submittedDetails.rows[0].id ], + }); + assert.equal(statusFailure.flag, 'failure'); + assert.equal(statusFailure.code, 400); + assert.match(statusFailure.message, /不允许删除明细/); + }); + }); + + // ------------------- batchDelete:批量删除盘点任务(业务层) ------------------- + + describe('batchDelete 批量删除盘点任务(业务层)', () => { + it('作废任务删除:主表/明细/作业记录全部物理删除(事务级联)', async () => { + const { check, stock } = await createCancelledCheck(); + const details = await detailCheck(check.id); + assert.equal(details.total, 1, '前置:作废任务应有 1 条明细'); + + // report 仅 approved/checking 状态开放,作废任务无法自然产生作业记录; + // 直写两条记录用于验证 batchDelete 级联删除 record 表。 + await ctx.model.StockCheckRecord.bulkCreate([ + { + check_id: check.id, + warehouse_id: TEST_WAREHOUSE_ID, + detail_id: details.rows[0].id, + stock_id: stock.id, + location_code: TEST_LOCATION_CODE, + quantity: 3, + checker_id: TEST_CREATOR_ID, + checker_name: TEST_CREATOR_NAME, + checked_at: new Date(), + }, + { + check_id: check.id, + warehouse_id: TEST_WAREHOUSE_ID, + detail_id: details.rows[0].id, + stock_id: stock.id, + location_code: '', + quantity: 5, + checker_id: TEST_CREATOR_ID, + checker_name: TEST_CREATOR_NAME, + checked_at: new Date(), + }, + ]); + assert.equal( + await ctx.model.StockCheckRecord.count({ where: { check_id: check.id } }), + 2, + '前置:应有 2 条作业记录' + ); + + const result = await batchDeleteCheck([ check.id ]); + + assert.equal(result.total, 1); + assert.equal(result.deleted_count, 1); + assert.equal(result.skipped_count, 0); + assert.deepEqual(result.deleted_ids, [ check.id ]); + assert.deepEqual(result.skipped_ids, []); + + // 级联物理删除:主表 / 明细 / 作业记录全部清空 + assert.equal(await findCheckRow(check.id), null, '主表行应物理删除'); + assert.equal(await ctx.model.StockCheckDetail.count({ where: { check_id: check.id } }), 0, '明细应物理删除'); + assert.equal(await ctx.model.StockCheckRecord.count({ where: { check_id: check.id } }), 0, '作业记录应物理删除'); + }); + + it('非作废状态任务全部跳过:created/submitted/approved/completed 数据保持', async () => { + const created = await createCheck(); + + const submitted = await createCheck(); + const submittedStocks = await fetchStockRows(1); + await addDetail(submitted.id, [ submittedStocks[0].id ]); + await submitCheck(submitted.id); + + const approved = await createCheck(); + const approvedStocks = await fetchStockRows(1); + await addDetail(approved.id, [ approvedStocks[0].id ]); + await submitCheck(approved.id); + await auditCheck(approved.id, 'approve'); + + const completed = await createCheck(); + const completedStocks = await fetchStockRows(1); + await addDetail(completed.id, [ completedStocks[0].id ]); + await submitCheck(completed.id); + await auditCheck(completed.id, 'approve'); + const completedDetails = await detailCheck(completed.id); + await reportCheck(completed.id, completedDetails.rows[0].id, 1); + await finishCheck(completed.id); + + const ids = [ created.id, submitted.id, approved.id, completed.id ]; + const result = await batchDeleteCheck(ids); + + assert.equal(result.total, 4); + assert.equal(result.deleted_count, 0); + assert.equal(result.skipped_count, 4); + assert.deepEqual(result.deleted_ids, []); + assert.deepEqual(result.skipped_ids, ids, 'skipped_ids 应保持入参顺序'); + + // 数据保持:主表仍在且状态不变,明细仍在 + assert.equal((await findCheckRow(created.id)).status, 'created'); + assert.equal((await findCheckRow(submitted.id)).status, 'submitted'); + assert.equal((await findCheckRow(approved.id)).status, 'approved'); + assert.equal((await findCheckRow(completed.id)).status, 'completed'); + for (const checkId of [ submitted.id, approved.id, completed.id ]) { + assert.equal( + await ctx.model.StockCheckDetail.count({ where: { check_id: checkId } }), + 1, + `任务 ${checkId} 明细应保持` + ); + } + }); + + it('混合批量:仅删除作废任务,其余跳过,计数与顺序正确', async () => { + const cancelledA = await createCancelledCheck(); + const kept = await createCheck(); + const cancelledB = await createCancelledCheck(); + const missingId = await findFreeCheckId(); + + const ids = [ cancelledA.check.id, kept.id, missingId, cancelledB.check.id ]; + const result = await batchDeleteCheck(ids); + + assert.equal(result.total, 4); + assert.equal(result.deleted_count, 2); + assert.equal(result.skipped_count, 2); + assert.deepEqual(result.deleted_ids, [ cancelledA.check.id, cancelledB.check.id ], 'deleted_ids 保持入参顺序'); + assert.deepEqual(result.skipped_ids, [ kept.id, missingId ], 'skipped_ids 保持入参顺序'); + + assert.equal(await findCheckRow(cancelledA.check.id), null, '作废任务 A 应删除'); + assert.equal(await findCheckRow(cancelledB.check.id), null, '作废任务 B 应删除'); + assert.equal((await findCheckRow(kept.id)).status, 'created', '非作废任务应保持'); + }); + + it('不存在的 ID 计入 skipped_ids', async () => { + const missingId = await findFreeCheckId(); + + const result = await batchDeleteCheck([ missingId ]); + + assert.equal(result.total, 1); + assert.equal(result.deleted_count, 0); + assert.equal(result.skipped_count, 1); + assert.deepEqual(result.skipped_ids, [ missingId ]); + assert.deepEqual(result.deleted_ids, []); + }); + + it('ids 空/非法 → 400', async () => { + await assert.rejects(async () => { + await batchDeleteCheck([]); + }, error => error.code === 400 && /ids/.test(error.message)); + + await assert.rejects(async () => { + await batchDeleteRaw({ warehouseId: TEST_WAREHOUSE_ID, ids: undefined }); + }, error => error.code === 400 && /ids/.test(error.message)); + + await assert.rejects(async () => { + await batchDeleteCheck([ 0, -1, 'abc' ]); + }, error => error.code === 400 && /ids/.test(error.message)); + + await assert.rejects(async () => { + await batchDeleteRaw({ warehouseId: 0, ids: [ 1 ] }); + }, error => error.code === 400 && /仓库/.test(error.message)); + }); + + it('超过 200 个上限 → 400;200 个边界正常返回', async () => { + const baseId = await findFreeCheckId(); + const overLimitIds = Array.from({ length: 201 }, (_, index) => baseId + index); + + await assert.rejects(async () => { + await batchDeleteCheck(overLimitIds); + }, error => error.code === 400 && /200/.test(error.message)); + + const boundaryIds = Array.from({ length: 200 }, (_, index) => baseId + index + 1000); + const result = await batchDeleteCheck(boundaryIds); + assert.equal(result.total, 200); + assert.equal(result.deleted_count, 0); + assert.equal(result.skipped_count, 200); + }); + + it('单值 ids 兼容(传数字而非数组)', async () => { + const { check } = await createCancelledCheck(); + + const result = await batchDeleteCheck(check.id); + + assert.equal(result.total, 1); + assert.equal(result.deleted_count, 1); + assert.deepEqual(result.deleted_ids, [ check.id ]); + assert.equal(await findCheckRow(check.id), null, '单值 ids 也应正常删除'); + }); + + it('重复 id 去重后只删一次', async () => { + const { check } = await createCancelledCheck(); + + const result = await batchDeleteCheck([ check.id, check.id, check.id ]); + + assert.equal(result.total, 1); + assert.equal(result.deleted_count, 1); + assert.equal(result.skipped_count, 0); + assert.deepEqual(result.deleted_ids, [ check.id ]); + }); + }); + + // ------------------- systemMethods.stock.check.batchDelete:方法包装层 ------------------- + + describe('systemMethods.stock.check.batchDelete 方法包装层', () => { + /** 设置当前上下文的用户信息(模拟登录用户,仓库固定 100000)。 */ + function mockCurrentUser() { + ctx.user = { + id: TEST_CREATOR_ID, + store_id: TEST_WAREHOUSE_ID, + employees_name: TEST_CREATOR_NAME, + }; + } + + it('success 包装:作废任务删除成功,仓库由 ctx.user.store_id 注入', async () => { + mockCurrentUser(); + + const { check } = await createCancelledCheck(); + const result = await ctx.service.systemMethods.stock.check.batchDelete({ ids: [ check.id ] }); + + assert.equal(result.flag, 'success'); + assert.equal(result.code, 1); + assert.equal(result.data.total, 1); + assert.equal(result.data.deleted_count, 1); + assert.equal(result.data.skipped_count, 0); + assert.deepEqual(result.data.deleted_ids, [ check.id ]); + assert.equal(await findCheckRow(check.id), null, '主表行应物理删除(仓库注入正确才可删除)'); + }); + + it('仓库隔离:其他仓库的作废任务计入 skipped_ids 不删除', async () => { + mockCurrentUser(); + + // 其他仓库(100001)作废任务:方法层当前上下文仓库为 100000,应跳过不删 + const other = await createCheck({ warehouseId: OTHER_TEST_WAREHOUSE_ID }); + await ctx.service.systems.stockCheck.cancel({ + warehouseId: OTHER_TEST_WAREHOUSE_ID, + id: other.id, + }); + + const result = await ctx.service.systemMethods.stock.check.batchDelete({ ids: [ other.id ] }); + + assert.equal(result.flag, 'success'); + assert.equal(result.code, 1); + assert.equal(result.data.deleted_count, 0); + assert.equal(result.data.skipped_count, 1); + assert.deepEqual(result.data.skipped_ids, [ other.id ]); + assert.equal((await findCheckRow(other.id)).status, 'cancelled', '其他仓库任务应保持'); + }); + + it('ids 空 → failure 400 包装', async () => { + mockCurrentUser(); + + const result = await ctx.service.systemMethods.stock.check.batchDelete({ ids: [] }); + + assert.equal(result.flag, 'failure'); + assert.equal(result.code, 400); + assert.ok(result.message, '应返回错误文案'); + }); + + it('缺少仓库上下文 → failure 400 包装', async () => { + ctx.user = null; + + const result = await ctx.service.systemMethods.stock.check.batchDelete({ ids: [ 1 ] }); + + assert.equal(result.flag, 'failure'); + assert.equal(result.code, 400); + assert.match(result.message, /仓库/); + }); + + it('单值 ids 兼容(方法层传数字)', async () => { + mockCurrentUser(); + + const { check } = await createCancelledCheck(); + const result = await ctx.service.systemMethods.stock.check.batchDelete({ ids: check.id }); + + assert.equal(result.flag, 'success'); + assert.equal(result.code, 1); + assert.equal(result.data.deleted_count, 1); + assert.deepEqual(result.data.deleted_ids, [ check.id ]); + }); + }); +});