@rytass/wms-module-core 0.5.0 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (51) hide show
  1. package/README.md +44 -2
  2. package/docs/api-reference.md +37 -1
  3. package/docs/integration-guide.md +18 -17
  4. package/index.cjs.js +1160 -5
  5. package/index.js +7 -0
  6. package/lib/constants/index.d.ts +2 -0
  7. package/lib/constants/inventory-count-status.d.ts +19 -0
  8. package/lib/constants/inventory-count-status.js +22 -0
  9. package/lib/constants/operations.d.ts +34 -0
  10. package/lib/constants/operations.js +67 -0
  11. package/lib/constants/stock-status.d.ts +2 -0
  12. package/lib/constants/stock-status.js +4 -0
  13. package/lib/core.module.js +9 -1
  14. package/lib/events/index.d.ts +1 -0
  15. package/lib/events/inventory-count-lock.subscriber.d.ts +38 -0
  16. package/lib/events/inventory-count-lock.subscriber.js +98 -0
  17. package/lib/events/stock-change.subscriber.js +6 -0
  18. package/lib/events/wms-event.types.d.ts +2 -2
  19. package/lib/models/extensions/index.d.ts +3 -0
  20. package/lib/models/extensions/inventory-count-order/inventory-count-order-change.entity.d.ts +20 -0
  21. package/lib/models/extensions/inventory-count-order/inventory-count-order-change.entity.js +50 -0
  22. package/lib/models/extensions/inventory-count-order/inventory-count-order-item.entity.d.ts +48 -0
  23. package/lib/models/extensions/inventory-count-order/inventory-count-order-item.entity.js +175 -0
  24. package/lib/models/extensions/inventory-count-order/inventory-count-order.entity.d.ts +50 -0
  25. package/lib/models/extensions/inventory-count-order/inventory-count-order.entity.js +155 -0
  26. package/lib/models/models.module.js +7 -0
  27. package/lib/services/allocate-inventory-order.service.js +3 -0
  28. package/lib/services/batch.service.js +3 -0
  29. package/lib/services/hold-inventory-order.service.js +3 -0
  30. package/lib/services/index.d.ts +1 -0
  31. package/lib/services/inventory-count-order.service.d.ts +174 -0
  32. package/lib/services/inventory-count-order.service.js +641 -0
  33. package/lib/services/loader.service.js +3 -0
  34. package/lib/services/location.service.js +3 -0
  35. package/lib/services/material.service.js +3 -0
  36. package/lib/services/merge-batch-order.service.js +3 -0
  37. package/lib/services/quality-inspection-order.service.js +3 -0
  38. package/lib/services/receive-inventory-order.service.js +3 -0
  39. package/lib/services/reclassify-inventory-order.service.js +3 -0
  40. package/lib/services/scrape.service.js +3 -0
  41. package/lib/services/ship-inventory-order.service.js +3 -0
  42. package/lib/services/split-batch-order.service.js +3 -0
  43. package/lib/services/stock.service.js +27 -0
  44. package/lib/services/transfer-customer-order.service.js +3 -0
  45. package/lib/services/transfer-order.service.js +3 -0
  46. package/lib/services/transfer-vendor-order.service.js +3 -0
  47. package/lib/services/unit.service.js +3 -0
  48. package/lib/services/warehouse-map.service.d.ts +11 -1
  49. package/lib/services/warehouse-map.service.js +13 -4
  50. package/lib/typings/find-stock.input.d.ts +16 -0
  51. package/package.json +5 -5
@@ -0,0 +1,641 @@
1
+ import { __decorate, __param, __metadata } from 'tslib';
2
+ import { Injectable, Inject, NotFoundException, BadRequestException } from '@nestjs/common';
3
+ import { DataSource, In } from 'typeorm';
4
+ import { InventoryCountStatus } from '../constants/inventory-count-status.js';
5
+ import '../models/metadata/batch.entity.js';
6
+ import '../models/metadata/batch-group.entity.js';
7
+ import { LoadersEntityClass } from '../models/metadata/loader.entity.js';
8
+ import '../models/metadata/loader-type.entity.js';
9
+ import '../models/metadata/loader-unit.entity.js';
10
+ import '../models/metadata/location.entity.js';
11
+ import '../models/metadata/material.entity.js';
12
+ import { MaterialUnitEntityClass } from '../models/metadata/material-unit.entity.js';
13
+ import '@rytass/wms-base-nestjs-module';
14
+ import '../models/metadata/sale-order.entity.js';
15
+ import '../models/metadata/stock.entity.js';
16
+ import '../models/metadata/unit.entity.js';
17
+ import { WmsEntities } from '../models/wms-entities.js';
18
+ import '../models/extensions/receive-inventory-order/receive-inventory-order-item.entity.js';
19
+ import '../models/extensions/receive-inventory-order/receive-inventory-order.entity.js';
20
+ import '../models/extensions/receive-inventory-order/receive-inventory-order-change.entity.js';
21
+ import '../models/extensions/ship-inventory-order/ship-inventory-order-item.entity.js';
22
+ import '../models/extensions/ship-inventory-order/ship-inventory-order.entity.js';
23
+ import '../models/extensions/ship-inventory-order/ship-inventory-order-reference.entity.js';
24
+ import '../models/extensions/ship-inventory-order/ship-inventory-order-change.entity.js';
25
+ import '../models/extensions/transfer-order/transfer-order.entity.js';
26
+ import '../models/extensions/transfer-order/transfer-order-item.entity.js';
27
+ import '../models/extensions/transfer-order/transfer-order-change.entity.js';
28
+ import '../models/extensions/hold-inventory-order/hold-inventory-order.entity.js';
29
+ import '../models/extensions/hold-inventory-order/hold-inventory-order-item.entity.js';
30
+ import '../models/extensions/hold-inventory-order/hold-inventory-order-change.entity.js';
31
+ import '../models/extensions/allocate-inventory-order/allocate-inventory-order.entity.js';
32
+ import '../models/extensions/allocate-inventory-order/allocate-inventory-order-item.entity.js';
33
+ import '../models/extensions/allocate-inventory-order/allocate-inventory-order-change.entity.js';
34
+ import '../models/extensions/split-batch-order/split-batch-order.entity.js';
35
+ import '../models/extensions/split-batch-order/split-batch-order-item.entity.js';
36
+ import '../models/extensions/split-batch-order/split-batch-order-change.entity.js';
37
+ import '../models/extensions/merge-batch-order/merge-batch-order.entity.js';
38
+ import '../models/extensions/merge-batch-order/merge-batch-order-item.entity.js';
39
+ import '../models/extensions/merge-batch-order/merge-batch-order-change.entity.js';
40
+ import '../models/extensions/reclassify-inventory-order/reclassify-inventory-order.entity.js';
41
+ import '../models/extensions/reclassify-inventory-order/reclassify-inventory-order-item.entity.js';
42
+ import '../models/extensions/reclassify-inventory-order/reclassify-inventory-order-change.entity.js';
43
+ import '../models/extensions/transfer-vendor-order/transfer-vendor-order.entity.js';
44
+ import '../models/extensions/transfer-vendor-order/transfer-vendor-order-item.entity.js';
45
+ import '../models/extensions/transfer-vendor-order/transfer-vendor-order-change.entity.js';
46
+ import '../models/extensions/quality-inspection-order/quality-inspection-order.entity.js';
47
+ import '../models/extensions/quality-inspection-order/quality-inspection-order-item.entity.js';
48
+ import '../models/extensions/quality-inspection-order/quality-inspection-order-change.entity.js';
49
+ import '../models/extensions/transfer-customer-order/transfer-customer-order.entity.js';
50
+ import '../models/extensions/transfer-customer-order/transfer-customer-order-item.entity.js';
51
+ import '../models/extensions/transfer-customer-order/transfer-customer-order-change.entity.js';
52
+ import '../models/extensions/scrape-order/scrape-order.entity.js';
53
+ import '../models/extensions/scrape-order/scrape-order-item.entity.js';
54
+ import '../models/extensions/scrape-order/scrape-order-change.entity.js';
55
+ import { InventoryCountOrderEntity, InventoryCountOrderLocationEntityClass } from '../models/extensions/inventory-count-order/inventory-count-order.entity.js';
56
+ import { InventoryCountOrderItemEntityClass } from '../models/extensions/inventory-count-order/inventory-count-order-item.entity.js';
57
+ import { InventoryCountOrderChangeEntityClass } from '../models/extensions/inventory-count-order/inventory-count-order-change.entity.js';
58
+ import { BatchService } from './batch.service.js';
59
+ import { HelperService } from './helper.service.js';
60
+ import { MaterialService } from './material.service.js';
61
+ import { StockService } from './stock.service.js';
62
+
63
+ /**
64
+ * Inventory counting: compare the ledger against what is physically there, then
65
+ * adjust the ledger to match.
66
+ *
67
+ * The shape follows the "D. 盤點" design flow. Three properties are worth
68
+ * stating up front because everything else follows from them:
69
+ *
70
+ * - **Counting never moves stock between locations.** A line that is in the
71
+ * wrong place is a transfer, not a count; `transfer-order:create` already does
72
+ * that. This service only ever adjusts quantity, up or down, in place.
73
+ * - **Nothing touches stock until settlement.** Counted quantities are working
74
+ * notes ("暫存的對帳資料"); only {@link settle} writes changes, and it does so
75
+ * in a single transaction.
76
+ * - **Starting a count locks its locations.** The book snapshot taken at
77
+ * {@link start} would be worthless if stock kept moving underneath it, so
78
+ * `InventoryCountLockSubscriber` refuses every other stock movement in the
79
+ * scope until the order settles or is cancelled.
80
+ */
81
+ let InventoryCountOrderService = class InventoryCountOrderService {
82
+ dataSource;
83
+ entities;
84
+ helperService;
85
+ materialService;
86
+ stockService;
87
+ batchService;
88
+ inventoryCountOrderEntity;
89
+ seqPrefix = 'ICO';
90
+ constructor(dataSource, entities, helperService, materialService, stockService, batchService, inventoryCountOrderEntity) {
91
+ this.dataSource = dataSource;
92
+ this.entities = entities;
93
+ this.helperService = helperService;
94
+ this.materialService = materialService;
95
+ this.stockService = stockService;
96
+ this.batchService = batchService;
97
+ this.inventoryCountOrderEntity = inventoryCountOrderEntity;
98
+ }
99
+ getRepositories(manager) {
100
+ return {
101
+ order: manager.getRepository(this.inventoryCountOrderEntity),
102
+ scope: manager.getRepository(InventoryCountOrderLocationEntityClass),
103
+ item: manager.getRepository(InventoryCountOrderItemEntityClass),
104
+ change: manager.getRepository(InventoryCountOrderChangeEntityClass),
105
+ baseOrder: manager.getRepository(this.entities.order),
106
+ stock: manager.getRepository(this.entities.stock),
107
+ };
108
+ }
109
+ /**
110
+ * Expand chosen locations into themselves plus every descendant.
111
+ *
112
+ * `LocationEntity` is a plain adjacency list (`parent` / `children`) with no
113
+ * materialised path, so the subtree needs a recursive CTE. It runs once per
114
+ * scope change and the result is stored, precisely so the lock check never has
115
+ * to run it.
116
+ */
117
+ async expandLocationScope(rootIds, manager) {
118
+ if (!rootIds.length) {
119
+ return [];
120
+ }
121
+ const table = manager.getRepository(this.entities.location).metadata
122
+ .tableName;
123
+ const rows = await manager.query(`WITH RECURSIVE subtree AS (
124
+ SELECT id FROM "${table}" WHERE id = ANY($1)
125
+ UNION
126
+ SELECT child.id
127
+ FROM "${table}" child
128
+ JOIN subtree parent ON child."parentId" = parent.id
129
+ )
130
+ SELECT id FROM subtree`, [[...rootIds]]);
131
+ const roots = new Set(rootIds);
132
+ return rows.map(({ id }) => ({ id, isRoot: roots.has(id) }));
133
+ }
134
+ /** Current ledger quantity per physical position inside the scope. */
135
+ async readPositions(locationIds, manager) {
136
+ if (!locationIds.length) {
137
+ return [];
138
+ }
139
+ // The batch table is joined by name rather than through its repository
140
+ // because it is only read for its attribute columns — the same thing
141
+ // `StockService.selectQueryBuilder` does. Single-table inheritance means
142
+ // every configured batch entity shares this table, so the join is override
143
+ // safe; the name still comes from the configured entity's metadata rather
144
+ // than being hard-coded.
145
+ const batchTable = manager.getRepository(this.entities.batch).metadata
146
+ .tableName;
147
+ // Through the repository, not raw SQL on the table: the stock entity is
148
+ // overridable, and the repository is what applies the right
149
+ // single-table-inheritance discriminator.
150
+ const rows = await manager
151
+ .getRepository(this.entities.stock)
152
+ .createQueryBuilder('stock')
153
+ .leftJoin(batchTable, 'batch', 'batch.id = stock."batchId"')
154
+ .select('stock.materialId', 'materialId')
155
+ .addSelect('stock.batchId', 'batchId')
156
+ .addSelect('stock.locationId', 'locationId')
157
+ .addSelect('stock.loaderId', 'loaderId')
158
+ .addSelect('SUM(stock.quantity)', 'quantity')
159
+ .addSelect('batch.held', 'held')
160
+ .addSelect('batch."inShipment"', 'inShipment')
161
+ .addSelect('batch."inspectionResult"', 'inspectionResult')
162
+ .addSelect('batch."transferId"', 'transferId')
163
+ .addSelect('batch."vendorId"', 'vendorId')
164
+ .addSelect('batch."customerId"', 'customerId')
165
+ .addSelect('batch."saleId"', 'saleId')
166
+ .addSelect('batch."saleSerialId"', 'saleSerialId')
167
+ .where('stock.locationId IN (:...locationIds)', {
168
+ locationIds: [...locationIds],
169
+ })
170
+ .groupBy('stock.materialId')
171
+ .addGroupBy('stock.batchId')
172
+ .addGroupBy('stock.locationId')
173
+ .addGroupBy('stock.loaderId')
174
+ // Functionally dependent on batchId, but PostgreSQL only infers that from
175
+ // the grouped table's own primary key, so they have to be listed.
176
+ .addGroupBy('batch.held')
177
+ .addGroupBy('batch."inShipment"')
178
+ .addGroupBy('batch."inspectionResult"')
179
+ .addGroupBy('batch."transferId"')
180
+ .addGroupBy('batch."vendorId"')
181
+ .addGroupBy('batch."customerId"')
182
+ .addGroupBy('batch."saleId"')
183
+ .addGroupBy('batch."saleSerialId"')
184
+ .having('SUM(stock.quantity) > 0')
185
+ .getRawMany();
186
+ return rows.map((row) => ({
187
+ materialId: row.materialId,
188
+ batchId: row.batchId,
189
+ locationId: row.locationId,
190
+ loaderId: row.loaderId,
191
+ quantity: Number(row.quantity),
192
+ attributes: {
193
+ held: row.held ?? null,
194
+ inShipment: row.inShipment ?? null,
195
+ inspectionResult: row.inspectionResult ?? null,
196
+ transferId: row.transferId ?? null,
197
+ vendorId: row.vendorId ?? null,
198
+ customerId: row.customerId ?? null,
199
+ saleId: row.saleId ?? null,
200
+ saleSerialId: row.saleSerialId ?? null,
201
+ },
202
+ }));
203
+ }
204
+ positionKey(position) {
205
+ return [
206
+ position.materialId,
207
+ position.batchId,
208
+ position.locationId ?? '',
209
+ position.loaderId ?? '',
210
+ ].join('|');
211
+ }
212
+ async scopedLocationIds(orderId, manager) {
213
+ const rows = await this.getRepositories(manager).scope.find({
214
+ where: { orderId },
215
+ select: { locationId: true },
216
+ });
217
+ return rows.map(({ locationId }) => locationId);
218
+ }
219
+ async loadOrderOrFail(id, manager) {
220
+ const order = await this.getRepositories(manager).order.findOneBy({ id });
221
+ if (!order) {
222
+ throw new NotFoundException(`Inventory count order ${id} not found`);
223
+ }
224
+ return order;
225
+ }
226
+ assertStatus(order, allowed) {
227
+ if (!allowed.includes(order.status)) {
228
+ throw new BadRequestException(`Inventory count order ${order.id} is ${order.status}; this operation requires ${allowed.join(' or ')}`);
229
+ }
230
+ }
231
+ /**
232
+ * Rebuild the sheet from the current ledger.
233
+ *
234
+ * Called when the scope changes and again when counting starts. Additions
235
+ * (盤盈 lines) are never touched — they describe stock the ledger does not know
236
+ * about, so a rebuild has nothing to say about them.
237
+ */
238
+ async rebuildItems(orderId, manager) {
239
+ const repos = this.getRepositories(manager);
240
+ const locationIds = await this.scopedLocationIds(orderId, manager);
241
+ const positions = await this.readPositions(locationIds, manager);
242
+ const existing = await repos.item.find({
243
+ where: { orderId, isAddition: false },
244
+ });
245
+ const byKey = new Map(existing.map((item) => [this.positionKey(item), item]));
246
+ const seen = new Set();
247
+ for (const position of positions) {
248
+ const key = this.positionKey(position);
249
+ seen.add(key);
250
+ const item = byKey.get(key);
251
+ if (item) {
252
+ item.bookQuantity = position.quantity;
253
+ Object.assign(item, position.attributes);
254
+ await repos.item.save(item);
255
+ continue;
256
+ }
257
+ await repos.item.save(repos.item.create({
258
+ orderId,
259
+ materialId: position.materialId,
260
+ batchId: position.batchId,
261
+ locationId: position.locationId,
262
+ loaderId: position.loaderId,
263
+ bookQuantity: position.quantity,
264
+ countedQuantity: null,
265
+ unitId: null,
266
+ isAddition: false,
267
+ ...position.attributes,
268
+ }));
269
+ }
270
+ // A position that emptied out between two rebuilds is no longer on the
271
+ // sheet; it cannot be counted and would settle to a meaningless zero.
272
+ const stale = existing.filter((item) => !seen.has(this.positionKey(item)));
273
+ if (stale.length) {
274
+ await repos.item.delete({ id: In(stale.map(({ id }) => id)) });
275
+ }
276
+ }
277
+ /** Filters for the list page. All optional; combined with AND. */
278
+ async findMany(options, manager = this.dataSource.manager) {
279
+ const query = this.getRepositories(manager)
280
+ // The alias is lowercase and is deliberately not `order`. `order` is a
281
+ // PostgreSQL reserved word, so the raw fragments below would render
282
+ // `order."countDate"` and fail to parse; and a camelCase alias would be
283
+ // emitted quoted by the query builder while the unquoted references here
284
+ // fold to lowercase, so the two would never match.
285
+ .order.createQueryBuilder('count_order')
286
+ .orderBy('count_order."countDate"', 'DESC')
287
+ .addOrderBy('count_order."createdAt"', 'DESC');
288
+ if (options.name) {
289
+ query.andWhere('count_order.name ILIKE :name', {
290
+ name: `%${options.name}%`,
291
+ });
292
+ }
293
+ if (options.statuses?.length) {
294
+ query.andWhere('count_order.status IN (:...statuses)', {
295
+ statuses: options.statuses,
296
+ });
297
+ }
298
+ if (options.createdBy) {
299
+ query.andWhere('count_order."createdBy" = :createdBy', {
300
+ createdBy: options.createdBy,
301
+ });
302
+ }
303
+ if (options.countDateFrom) {
304
+ query.andWhere('count_order."countDate" >= :from', {
305
+ from: options.countDateFrom,
306
+ });
307
+ }
308
+ if (options.countDateTo) {
309
+ query.andWhere('count_order."countDate" <= :to', {
310
+ to: options.countDateTo,
311
+ });
312
+ }
313
+ if (options.locationIds?.length) {
314
+ // Scope membership, not the roots the user picked: a count of a whole
315
+ // aisle should surface when filtering by any shelf inside it.
316
+ query.andWhere(`EXISTS (
317
+ SELECT 1 FROM inventory_count_order_locations scope
318
+ WHERE scope."orderId" = count_order.id
319
+ AND scope."locationId" IN (:...locationIds)
320
+ )`, { locationIds: options.locationIds });
321
+ }
322
+ if (options.offset !== undefined && options.offset >= 0) {
323
+ query.skip(options.offset);
324
+ }
325
+ if (options.limit !== undefined && options.limit > 0) {
326
+ query.take(options.limit);
327
+ }
328
+ return query.getManyAndCount();
329
+ }
330
+ async findOne(id, manager = this.dataSource.manager) {
331
+ return this.loadOrderOrFail(id, manager);
332
+ }
333
+ /**
334
+ * The count sheet, filtered and paginated.
335
+ *
336
+ * Server-side rather than handing the whole sheet to the client: a count over
337
+ * a whole warehouse is thousands of lines, and the operator's job is to narrow
338
+ * to the shelf in front of them.
339
+ */
340
+ async findItems(orderId, options = {}, manager = this.dataSource.manager) {
341
+ const tableOf = (entity) => manager.getRepository(entity).metadata.tableName;
342
+ const query = this.getRepositories(manager)
343
+ .item.createQueryBuilder('item')
344
+ .leftJoin(tableOf(this.entities.material), 'material', 'material.id = item."materialId"')
345
+ .leftJoin(tableOf(this.entities.batch), 'batch', 'batch.id = item."batchId"')
346
+ .leftJoin(tableOf(this.entities.location), 'location', 'location.id = item."locationId"')
347
+ .leftJoin(LoadersEntityClass, 'loader', 'loader.id = item."loaderId"')
348
+ .where('item."orderId" = :orderId', { orderId });
349
+ const like = (column, value, parameter) => {
350
+ if (!value)
351
+ return;
352
+ query.andWhere(`${column} ILIKE :${parameter}`, {
353
+ [parameter]: `%${value}%`,
354
+ });
355
+ };
356
+ like('material.key', options.materialKey, 'materialKey');
357
+ like('material.description', options.materialDescription, 'materialDescription');
358
+ like('batch.key', options.batchKey, 'batchKey');
359
+ like('location.key', options.locationKey, 'locationKey');
360
+ like('loader."serialId"', options.loaderSerialId, 'loaderSerialId');
361
+ const exact = (column, value, parameter) => {
362
+ if (!value)
363
+ return;
364
+ query.andWhere(`${column} = :${parameter}`, { [parameter]: value });
365
+ };
366
+ exact('item."vendorId"', options.vendorId, 'vendorId');
367
+ exact('item."customerId"', options.customerId, 'customerId');
368
+ exact('item."saleId"', options.saleId, 'saleId');
369
+ exact('item."saleSerialId"', options.saleSerialId, 'saleSerialId');
370
+ if (options.onlyVariance) {
371
+ // The counted quantity is expressed in the line's unit, so it has to be
372
+ // converted before it can be compared with the base-unit book quantity —
373
+ // the same conversion settlement applies.
374
+ query
375
+ .leftJoin(MaterialUnitEntityClass, 'unit', 'unit.id = item."unitId"')
376
+ .andWhere('item."countedQuantity" IS NOT NULL')
377
+ .andWhere('item."countedQuantity" * COALESCE(unit."conversionFactor", 1) <> item."bookQuantity"');
378
+ }
379
+ // Counted before ordering and paginating: `getCount()` rewrites the query
380
+ // into a COUNT, and an ORDER BY on a joined column it does not select makes
381
+ // that rewrite fail.
382
+ const total = await query.getCount();
383
+ // Additions first — they are what the operator just typed — then a stable
384
+ // order so paging cannot repeat or skip a line.
385
+ query
386
+ .orderBy('item."isAddition"', 'DESC')
387
+ .addOrderBy('material.key', 'ASC')
388
+ .addOrderBy('batch.key', 'ASC')
389
+ .addOrderBy('item.id', 'ASC');
390
+ // `limit`/`offset` rather than `take`/`skip`: the latter wraps the query in a
391
+ // DISTINCT subquery to survive one-to-many joins, and then cannot map an
392
+ // ORDER BY on a joined column into it. Every join here is many-to-one, so no
393
+ // row multiplication and no need for that machinery.
394
+ if (options.offset !== undefined && options.offset >= 0) {
395
+ query.offset(options.offset);
396
+ }
397
+ if (options.limit !== undefined && options.limit > 0) {
398
+ query.limit(options.limit);
399
+ }
400
+ return [await query.getMany(), total];
401
+ }
402
+ async create(input, manager = this.dataSource.manager) {
403
+ if (!input.locationIds.length) {
404
+ throw new BadRequestException('An inventory count needs at least one location in scope');
405
+ }
406
+ const repos = this.getRepositories(manager);
407
+ const key = await this.helperService.getSeq(this.seqPrefix, manager);
408
+ const order = await repos.order.save(repos.order.create({
409
+ key,
410
+ name: input.name,
411
+ countDate: input.countDate,
412
+ status: InventoryCountStatus.PENDING,
413
+ createdBy: input.createdBy ?? null,
414
+ }));
415
+ const scope = await this.expandLocationScope(input.locationIds, manager);
416
+ await repos.scope.save(scope.map(({ id, isRoot }) => repos.scope.create({ orderId: order.id, locationId: id, isRoot })));
417
+ await this.rebuildItems(order.id, manager);
418
+ return order;
419
+ }
420
+ async update(id, input, manager = this.dataSource.manager) {
421
+ const repos = this.getRepositories(manager);
422
+ const order = await this.loadOrderOrFail(id, manager);
423
+ // The design keeps the info panel editable only while nothing has been
424
+ // counted; afterwards the sheet is already anchored to this scope and date.
425
+ this.assertStatus(order, [InventoryCountStatus.PENDING]);
426
+ if (input.name !== undefined)
427
+ order.name = input.name;
428
+ if (input.countDate !== undefined)
429
+ order.countDate = input.countDate;
430
+ await repos.order.save(order);
431
+ if (input.locationIds) {
432
+ if (!input.locationIds.length) {
433
+ throw new BadRequestException('An inventory count needs at least one location in scope');
434
+ }
435
+ await repos.scope.delete({ orderId: id });
436
+ const scope = await this.expandLocationScope(input.locationIds, manager);
437
+ await repos.scope.save(scope.map(({ id: locationId, isRoot }) => repos.scope.create({ orderId: id, locationId, isRoot })));
438
+ await this.rebuildItems(id, manager);
439
+ }
440
+ return order;
441
+ }
442
+ /**
443
+ * Freeze the ledger and open the sheet for counting.
444
+ *
445
+ * The rebuild here is the snapshot: from this point `bookQuantity` is what the
446
+ * variance is measured against, and the lock keeps it true.
447
+ */
448
+ async start(id, manager = this.dataSource.manager) {
449
+ const repos = this.getRepositories(manager);
450
+ const order = await this.loadOrderOrFail(id, manager);
451
+ this.assertStatus(order, [InventoryCountStatus.PENDING]);
452
+ await this.rebuildItems(id, manager);
453
+ order.status = InventoryCountStatus.COUNTING;
454
+ order.startedAt = new Date();
455
+ await repos.order.save(order);
456
+ return order;
457
+ }
458
+ /** Save counted quantities without touching stock ("暫存結果"). */
459
+ async count(id, entries, manager = this.dataSource.manager) {
460
+ const repos = this.getRepositories(manager);
461
+ const order = await this.loadOrderOrFail(id, manager);
462
+ this.assertStatus(order, [InventoryCountStatus.COUNTING]);
463
+ if (!entries.length) {
464
+ return order;
465
+ }
466
+ const items = await repos.item.find({
467
+ where: { orderId: id, id: In(entries.map(({ itemId }) => itemId)) },
468
+ });
469
+ const byId = new Map(items.map((item) => [item.id, item]));
470
+ for (const entry of entries) {
471
+ const item = byId.get(entry.itemId);
472
+ if (!item) {
473
+ throw new NotFoundException(`Item ${entry.itemId} does not belong to inventory count order ${id}`);
474
+ }
475
+ if (entry.countedQuantity !== null &&
476
+ (!Number.isFinite(entry.countedQuantity) || entry.countedQuantity < 0)) {
477
+ throw new BadRequestException(`Counted quantity for item ${entry.itemId} must be a non-negative number`);
478
+ }
479
+ item.countedQuantity = entry.countedQuantity;
480
+ if (entry.unitId !== undefined) {
481
+ item.unitId = entry.unitId;
482
+ }
483
+ await repos.item.save(item);
484
+ }
485
+ return order;
486
+ }
487
+ /**
488
+ * Add a line for stock the ledger has no record of (盤盈).
489
+ *
490
+ * The batch is resolved by key and created when it does not exist, which is
491
+ * what makes "the batch field's default is editable" in the design work.
492
+ */
493
+ async addItem(id, input, manager = this.dataSource.manager) {
494
+ const repos = this.getRepositories(manager);
495
+ const order = await this.loadOrderOrFail(id, manager);
496
+ this.assertStatus(order, [InventoryCountStatus.COUNTING]);
497
+ if (!Number.isFinite(input.countedQuantity) || input.countedQuantity <= 0) {
498
+ throw new BadRequestException('An added inventory count line needs a positive counted quantity');
499
+ }
500
+ const scoped = await this.scopedLocationIds(id, manager);
501
+ // Settlement writes stock at this location, so it has to be one the order
502
+ // locked — otherwise the count would adjust a position other operations are
503
+ // still free to move.
504
+ if (!scoped.includes(input.locationId)) {
505
+ throw new BadRequestException(`Location ${input.locationId} is outside the scope of inventory count order ${id}`);
506
+ }
507
+ const batch = await this.batchService.getBatch({
508
+ key: input.batchKey,
509
+ materialId: input.materialId,
510
+ manager,
511
+ });
512
+ return repos.item.save(repos.item.create({
513
+ orderId: id,
514
+ materialId: input.materialId,
515
+ batchId: batch.id,
516
+ locationId: input.locationId,
517
+ loaderId: input.loaderId ?? null,
518
+ unitId: input.unitId ?? null,
519
+ bookQuantity: 0,
520
+ countedQuantity: input.countedQuantity,
521
+ isAddition: true,
522
+ // Snapshotted from the batch the same way a scoped line is, so an added
523
+ // line renders through the identical columns. A brand-new batch carries
524
+ // the defaults, which is exactly right: unbooked stock is not held, not
525
+ // in transfer and not inspected.
526
+ held: batch.held ?? null,
527
+ inShipment: batch.inShipment ?? null,
528
+ inspectionResult: batch.inspectionResult ?? null,
529
+ transferId: batch.transferId ?? null,
530
+ vendorId: batch.vendorId ?? null,
531
+ customerId: batch.customerId ?? null,
532
+ saleId: batch.saleId ?? null,
533
+ saleSerialId: batch.saleSerialId ?? null,
534
+ }));
535
+ }
536
+ /** Remove an added line. Scoped lines are part of the sheet and never removed. */
537
+ async removeItem(id, itemId, manager = this.dataSource.manager) {
538
+ const repos = this.getRepositories(manager);
539
+ const order = await this.loadOrderOrFail(id, manager);
540
+ this.assertStatus(order, [InventoryCountStatus.COUNTING]);
541
+ const item = await repos.item.findOneBy({ id: itemId, orderId: id });
542
+ if (!item) {
543
+ throw new NotFoundException(`Item ${itemId} does not belong to inventory count order ${id}`);
544
+ }
545
+ if (!item.isAddition) {
546
+ throw new BadRequestException(`Item ${itemId} came from the counted scope and cannot be removed`);
547
+ }
548
+ await repos.item.delete({ id: itemId });
549
+ return order;
550
+ }
551
+ /**
552
+ * Throw the counting away and start over, without leaving the count.
553
+ *
554
+ * The scope stays locked and the status stays `COUNTING`: the point is a
555
+ * re-measure after something went wrong on the floor, not an abandonment. The
556
+ * book snapshot is deliberately *not* retaken — the lock means it has not
557
+ * moved.
558
+ */
559
+ async reset(id, manager = this.dataSource.manager) {
560
+ const repos = this.getRepositories(manager);
561
+ const order = await this.loadOrderOrFail(id, manager);
562
+ this.assertStatus(order, [InventoryCountStatus.COUNTING]);
563
+ await repos.item.delete({ orderId: id, isAddition: true });
564
+ await repos.item.update({ orderId: id }, { countedQuantity: null, unitId: null });
565
+ return order;
566
+ }
567
+ async cancel(id, manager = this.dataSource.manager) {
568
+ const repos = this.getRepositories(manager);
569
+ const order = await this.loadOrderOrFail(id, manager);
570
+ this.assertStatus(order, [
571
+ InventoryCountStatus.PENDING,
572
+ InventoryCountStatus.COUNTING,
573
+ ]);
574
+ order.status = InventoryCountStatus.CANCELLED;
575
+ order.cancelledAt = new Date();
576
+ await repos.order.save(order);
577
+ return order;
578
+ }
579
+ /**
580
+ * Adjust the ledger to the counted reality ("執行盤差").
581
+ *
582
+ * Runs in one transaction and is awaited end to end, so the mutation
583
+ * interceptor's post-commit guarantee holds: every `stock.count-gained` /
584
+ * `stock.count-lost` event fires only after the adjustments are durable.
585
+ *
586
+ * Uncounted lines are left alone — "not counted" is not "counted as zero", and
587
+ * treating it as zero would wipe out stock nobody looked at.
588
+ */
589
+ async settle(id, outerManager) {
590
+ const run = async (manager) => {
591
+ const repos = this.getRepositories(manager);
592
+ const order = await this.loadOrderOrFail(id, manager);
593
+ this.assertStatus(order, [InventoryCountStatus.COUNTING]);
594
+ const items = await repos.item.find({ where: { orderId: id } });
595
+ for (const item of items) {
596
+ if (item.countedQuantity === null) {
597
+ continue;
598
+ }
599
+ const conversionFactor = await this.materialService.getConversionFactor(item.materialId, item.unitId ?? undefined);
600
+ const counted = Number(item.countedQuantity) * conversionFactor;
601
+ const delta = counted - Number(item.bookQuantity);
602
+ if (delta === 0) {
603
+ continue;
604
+ }
605
+ const baseOrder = await repos.baseOrder.save({});
606
+ await repos.change.save(repos.change.create({
607
+ item,
608
+ order: baseOrder,
609
+ quantityChanged: delta,
610
+ }));
611
+ await repos.stock.save(repos.stock.create({
612
+ orderId: baseOrder.id,
613
+ materialId: item.materialId,
614
+ batchId: item.batchId,
615
+ locationId: this.stockService.resolveLocationId(item.locationId),
616
+ loaderId: this.stockService.resolveLoaderId(item.loaderId),
617
+ quantity: delta,
618
+ }));
619
+ }
620
+ order.status = InventoryCountStatus.COMPLETED;
621
+ order.settledAt = new Date();
622
+ await repos.order.save(order);
623
+ return order;
624
+ };
625
+ return outerManager
626
+ ? run(outerManager)
627
+ : this.dataSource.transaction((manager) => run(manager));
628
+ }
629
+ };
630
+ InventoryCountOrderService = __decorate([
631
+ Injectable(),
632
+ __param(6, Inject(InventoryCountOrderEntity)),
633
+ __metadata("design:paramtypes", [DataSource,
634
+ WmsEntities,
635
+ HelperService,
636
+ MaterialService,
637
+ StockService,
638
+ BatchService, Object])
639
+ ], InventoryCountOrderService);
640
+
641
+ export { InventoryCountOrderService };
@@ -51,6 +51,9 @@ import '../models/extensions/transfer-customer-order/transfer-customer-order-cha
51
51
  import '../models/extensions/scrape-order/scrape-order.entity.js';
52
52
  import '../models/extensions/scrape-order/scrape-order-item.entity.js';
53
53
  import '../models/extensions/scrape-order/scrape-order-change.entity.js';
54
+ import '../models/extensions/inventory-count-order/inventory-count-order.entity.js';
55
+ import '../models/extensions/inventory-count-order/inventory-count-order-item.entity.js';
56
+ import '../models/extensions/inventory-count-order/inventory-count-order-change.entity.js';
54
57
 
55
58
  /**
56
59
  * Service for managing loaders and their types
@@ -51,6 +51,9 @@ import '../models/extensions/transfer-customer-order/transfer-customer-order-cha
51
51
  import '../models/extensions/scrape-order/scrape-order.entity.js';
52
52
  import '../models/extensions/scrape-order/scrape-order-item.entity.js';
53
53
  import '../models/extensions/scrape-order/scrape-order-change.entity.js';
54
+ import '../models/extensions/inventory-count-order/inventory-count-order.entity.js';
55
+ import '../models/extensions/inventory-count-order/inventory-count-order-item.entity.js';
56
+ import '../models/extensions/inventory-count-order/inventory-count-order-change.entity.js';
54
57
 
55
58
  let LocationService = class LocationService {
56
59
  dataSource;
@@ -51,6 +51,9 @@ import '../models/extensions/transfer-customer-order/transfer-customer-order-cha
51
51
  import '../models/extensions/scrape-order/scrape-order.entity.js';
52
52
  import '../models/extensions/scrape-order/scrape-order-item.entity.js';
53
53
  import '../models/extensions/scrape-order/scrape-order-change.entity.js';
54
+ import '../models/extensions/inventory-count-order/inventory-count-order.entity.js';
55
+ import '../models/extensions/inventory-count-order/inventory-count-order-item.entity.js';
56
+ import '../models/extensions/inventory-count-order/inventory-count-order-change.entity.js';
54
57
 
55
58
  /**
56
59
  * Service for managing materials and their units