@rytass/wms-module-core 0.1.0

package/lib/services/transfer-customer-order.service.js

@@ -0,0 +1,279 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable, Inject } from '@nestjs/common';
+import '../models/metadata/batch.entity.js';
+import '../models/metadata/batch-group.entity.js';
+import { LoadersEntityClass } from '../models/metadata/loader.entity.js';
+import '../models/metadata/loader-type.entity.js';
+import '../models/metadata/loader-unit.entity.js';
+import { LocationEntityClass } from '../models/metadata/location.entity.js';
+import '../models/metadata/material.entity.js';
+import '../models/metadata/material-unit.entity.js';
+import '../models/metadata/sale-order.entity.js';
+import { StockEntity } from '../models/metadata/stock.entity.js';
+import '../models/metadata/unit.entity.js';
+import '../models/extensions/receive-inventory-order/receive-inventory-order-item.entity.js';
+import '../models/extensions/receive-inventory-order/receive-inventory-order.entity.js';
+import '../models/extensions/receive-inventory-order/receive-inventory-order-change.entity.js';
+import '../models/extensions/ship-inventory-order/ship-inventory-order-item.entity.js';
+import '../models/extensions/ship-inventory-order/ship-inventory-order.entity.js';
+import '../models/extensions/ship-inventory-order/ship-inventory-order-reference.entity.js';
+import '../models/extensions/ship-inventory-order/ship-inventory-order-change.entity.js';
+import '../models/extensions/transfer-order/transfer-order.entity.js';
+import '../models/extensions/transfer-order/transfer-order-item.entity.js';
+import '../models/extensions/transfer-order/transfer-order-change.entity.js';
+import '../models/extensions/hold-inventory-order/hold-inventory-order.entity.js';
+import '../models/extensions/hold-inventory-order/hold-inventory-order-item.entity.js';
+import '../models/extensions/hold-inventory-order/hold-inventory-order-change.entity.js';
+import '../models/extensions/allocate-inventory-order/allocate-inventory-order.entity.js';
+import '../models/extensions/allocate-inventory-order/allocate-inventory-order-item.entity.js';
+import '../models/extensions/allocate-inventory-order/allocate-inventory-order-change.entity.js';
+import '../models/extensions/split-batch-order/split-batch-order.entity.js';
+import '../models/extensions/split-batch-order/split-batch-order-item.entity.js';
+import '../models/extensions/split-batch-order/split-batch-order-change.entity.js';
+import '../models/extensions/merge-batch-order/merge-batch-order.entity.js';
+import '../models/extensions/merge-batch-order/merge-batch-order-item.entity.js';
+import '../models/extensions/merge-batch-order/merge-batch-order-change.entity.js';
+import '../models/extensions/reclassify-inventory-order/reclassify-inventory-order.entity.js';
+import '../models/extensions/reclassify-inventory-order/reclassify-inventory-order-item.entity.js';
+import '../models/extensions/reclassify-inventory-order/reclassify-inventory-order-change.entity.js';
+import '../models/extensions/transfer-vendor-order/transfer-vendor-order.entity.js';
+import '../models/extensions/transfer-vendor-order/transfer-vendor-order-item.entity.js';
+import '../models/extensions/transfer-vendor-order/transfer-vendor-order-change.entity.js';
+import '../models/extensions/quality-inspection-order/quality-inspection-order.entity.js';
+import '../models/extensions/quality-inspection-order/quality-inspection-order-item.entity.js';
+import '../models/extensions/quality-inspection-order/quality-inspection-order-change.entity.js';
+import { TransferCustomerOrderEntity } from '../models/extensions/transfer-customer-order/transfer-customer-order.entity.js';
+import { TransferCustomerOrderItemEntity } from '../models/extensions/transfer-customer-order/transfer-customer-order-item.entity.js';
+import { TransferCustomerOrderChangeEntityClass } from '../models/extensions/transfer-customer-order/transfer-customer-order-change.entity.js';
+import '../models/extensions/scrape-order/scrape-order.entity.js';
+import '../models/extensions/scrape-order/scrape-order-item.entity.js';
+import '../models/extensions/scrape-order/scrape-order-change.entity.js';
+import { DataSource, Not, IsNull } from 'typeorm';
+import { OrderEntity } from '@rytass/wms-base-nestjs-module';
+import { HelperService } from './helper.service.js';
+import { MaterialService } from './material.service.js';
+import { BatchService } from './batch.service.js';
+import { StockService } from './stock.service.js';
+
+let TransferCustomerOrderService = class TransferCustomerOrderService {
+    dataSource;
+    helperService;
+    materialService;
+    batchService;
+    stockService;
+    transferCustomerOrderEntity;
+    transferCustomerOrderItemEntity;
+    stockEntity;
+    seqPrefix = 'TCO';
+    constructor(dataSource, helperService, materialService, batchService, stockService, transferCustomerOrderEntity, transferCustomerOrderItemEntity, stockEntity) {
+        this.dataSource = dataSource;
+        this.helperService = helperService;
+        this.materialService = materialService;
+        this.batchService = batchService;
+        this.stockService = stockService;
+        this.transferCustomerOrderEntity = transferCustomerOrderEntity;
+        this.transferCustomerOrderItemEntity = transferCustomerOrderItemEntity;
+        this.stockEntity = stockEntity;
+    }
+    getRepositories(manager) {
+        return {
+            transferCustomerOrder: manager.getRepository(this.transferCustomerOrderEntity),
+            transferCustomerOrderItem: manager.getRepository(this.transferCustomerOrderItemEntity),
+            transferCustomerOrderChange: manager.getRepository(TransferCustomerOrderChangeEntityClass),
+            order: manager.getRepository(OrderEntity),
+            stock: manager.getRepository(this.stockEntity),
+            location: manager.getRepository(LocationEntityClass),
+            loader: manager.getRepository(LoadersEntityClass),
+        };
+    }
+    async processTransferCustomerOrderItems(items, manager) {
+        const repos = this.getRepositories(manager);
+        await Promise.all(items.map(async (data) => {
+            // Ensure required fields are present
+            if (!data.batchId || !data.materialId)
+                return;
+            // Split batch first with customerId to track customer allocation state
+            const splittedBatch = await this.batchService.splitBatch({
+                id: data.batchId,
+                customerId: data.customerId,
+                manager,
+            });
+            // Save item with ORIGINAL batch id to maintain source state
+            const item = await repos.transferCustomerOrderItem.save(repos.transferCustomerOrderItem.create(data));
+            const base = await repos.order.save({});
+            const conversionFactor = await this.materialService.getConversionFactor(item.materialId, item.unitId || undefined);
+            await repos.transferCustomerOrderChange.save(repos.transferCustomerOrderChange.create({
+                item,
+                order: base,
+                quantityChanged: item.targetTransferredQuantity * conversionFactor,
+            }));
+            // Stock movements track the transfer through splitted batch
+            await this.stockService.validateStockAvailability({
+                materialId: item.materialId,
+                batchId: item.batchId,
+                locationId: this.stockService.resolveLocationId(item.locationId),
+                loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                quantity: item.targetTransferredQuantity * conversionFactor,
+            }, manager);
+            await repos.stock.save(repos.stock.create([
+                // deduct from original batch available stock
+                {
+                    orderId: base.id,
+                    materialId: item.materialId,
+                    batchId: item.batchId, // original batch
+                    locationId: this.stockService.resolveLocationId(item.locationId),
+                    loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                    quantity: -1 * item.targetTransferredQuantity * conversionFactor,
+                },
+                // add to splitted batch in customer transfer state
+                {
+                    orderId: base.id,
+                    materialId: item.materialId,
+                    batchId: splittedBatch.id, // splitted batch marked with customerId
+                    locationId: this.stockService.resolveLocationId(item.locationId),
+                    loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                    quantity: item.targetTransferredQuantity * conversionFactor,
+                },
+            ]));
+        }));
+    }
+    async createTransferCustomerOrder(options, manager = this.dataSource.manager) {
+        const repos = this.getRepositories(manager);
+        const key = await this.helperService.getSeq(this.seqPrefix);
+        const { items, ...orderOptions } = options;
+        const order = await repos.transferCustomerOrder.save(repos.transferCustomerOrder.create({
+            key,
+            ...orderOptions,
+        }));
+        if (items?.length) {
+            const processedItems = items.map((item) => ({
+                ...item,
+                orderId: order.id,
+                customerId: options.customerId,
+            }));
+            await this.processTransferCustomerOrderItems(processedItems, manager);
+        }
+        return order;
+    }
+    async updateTransferCustomerOrder({ id, manager = this.dataSource.manager, ...options }) {
+        const repos = this.getRepositories(manager);
+        const { items, ...orderOptions } = options;
+        const order = await repos.transferCustomerOrder.findOneBy({ id });
+        if (!order)
+            throw new Error(`Order with id ${id} not found`);
+        const updated = await repos.transferCustomerOrder.save({
+            ...order,
+            ...orderOptions,
+        });
+        if (items?.length) {
+            const existingItemIds = new Set((await repos.transferCustomerOrderItem.find({
+                where: { orderId: id },
+                relations: ['changes'],
+            })).map((item) => item.id));
+            const newItems = [];
+            const existingItems = [];
+            items.forEach((item) => {
+                if (item.removedAt)
+                    return;
+                if (!item.id)
+                    newItems.push({ ...item, orderId: id });
+                else if (existingItemIds.has(item.id))
+                    existingItems.push({ ...item, orderId: id });
+            });
+            if (newItems.length)
+                await this.processTransferCustomerOrderItems(newItems, manager);
+            if (existingItems.length)
+                await repos.transferCustomerOrderItem.save(await Promise.all(existingItems.map((item) => repos.transferCustomerOrderItem.create(item))));
+        }
+        return updated;
+    }
+    async returnTransferCustomerOrder(options, manager = this.dataSource.manager) {
+        if (!Array.isArray(options))
+            options = [options];
+        const repos = this.getRepositories(manager);
+        const key = await this.helperService.getSeq(this.seqPrefix, manager);
+        const order = await repos.transferCustomerOrder.save(repos.transferCustomerOrder.create({ key }));
+        if (options.length > 0) {
+            await Promise.all(options.map(async (data) => {
+                // Ensure required fields are present
+                if (!data.batchId || !data.materialId)
+                    return;
+                const originalBatch = await this.batchService.batchRepository.findOneByOrFail({
+                    id: data.batchId,
+                    customerId: Not(IsNull()),
+                });
+                const splittedBatch = await this.batchService.splitBatch({
+                    id: data.batchId,
+                    customerId: null, // split out a batch with null customerId to indicate it's returned and available
+                    manager,
+                });
+                // Save item with ORIGINAL batch id to maintain source state
+                const item = await repos.transferCustomerOrderItem.save(repos.transferCustomerOrderItem.create({
+                    ...data,
+                    customerId: originalBatch.customerId,
+                    targetTransferredQuantity: -1 * data.quantity,
+                    orderId: order.id,
+                }));
+                const base = await repos.order.save({});
+                const conversionFactor = await this.materialService.getConversionFactor(item.materialId, item.unitId || undefined);
+                const change = await repos.transferCustomerOrderChange.save(repos.transferCustomerOrderChange.create({
+                    itemId: item.id,
+                    id: base.id,
+                    quantityChanged: -1 * item.targetTransferredQuantity * conversionFactor,
+                }));
+                let targetLocationId;
+                if (data.locationKey)
+                    targetLocationId = await repos.location
+                        .findOneByOrFail({ key: data.locationKey })
+                        .then(({ id }) => id);
+                let targetLoaderId;
+                if (data.loaderKey)
+                    targetLoaderId = await repos.loader
+                        .findOneByOrFail({ serialId: data.loaderKey })
+                        .then(({ id }) => id);
+                // Stock movements track the hold through splitted batch
+                await this.stockService.validateStockAvailability({
+                    materialId: item.materialId,
+                    batchId: item.batchId,
+                    locationId: this.stockService.resolveLocationId(item.locationId),
+                    loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                    quantity: change.quantityChanged,
+                }, manager);
+                await repos.stock.save(repos.stock.create([
+                    // deduct from original batch available stock
+                    {
+                        orderId: base.id,
+                        materialId: item.materialId,
+                        batchId: item.batchId, // original batch
+                        locationId: this.stockService.resolveLocationId(item.locationId),
+                        loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                        quantity: -1 * change.quantityChanged,
+                    },
+                    // add to splitted batch in released state
+                    {
+                        orderId: base.id,
+                        materialId: item.materialId,
+                        batchId: splittedBatch.id, // splitted batch marked with null customerId
+                        locationId: targetLocationId,
+                        loaderId: this.stockService.resolveLoaderId(targetLoaderId),
+                        quantity: change.quantityChanged,
+                    },
+                ]));
+            }));
+        }
+        return order;
+    }
+};
+TransferCustomerOrderService = __decorate([
+    Injectable(),
+    __param(5, Inject(TransferCustomerOrderEntity)),
+    __param(6, Inject(TransferCustomerOrderItemEntity)),
+    __param(7, Inject(StockEntity)),
+    __metadata("design:paramtypes", [DataSource,
+        HelperService,
+        MaterialService,
+        BatchService,
+        StockService, Object, Object, Object])
+], TransferCustomerOrderService);
+
+export { TransferCustomerOrderService };

package/lib/services/transfer-order.service.d.ts

@@ -0,0 +1,44 @@
+import { StockEntityClass, TransferOrderEntityClass, TransferOrderItemEntityClass } from '../models';
+import { DataSource, EntityManager, EntityTarget, Repository } from 'typeorm';
+import { HelperService } from './helper.service';
+import { CreateTransferOrderInput, UpdateTransferOrderInput } from '../typings/create-transfer-order.input';
+import { FindTransferOrderInput } from '../typings/find-transfer-order.input';
+import { TransferOrderInput } from '../typings/transfer-order.input';
+import { CancelTransferOrderInput } from '../typings/cancel-transfer-order.input';
+import { MaterialService } from './material.service';
+import { BatchService } from './batch.service';
+import { StockService } from './stock.service';
+export declare class TransferOrderService<T extends TransferOrderEntityClass = TransferOrderEntityClass, K extends TransferOrderItemEntityClass = TransferOrderItemEntityClass> {
+    private readonly dataSource;
+    private readonly helperService;
+    private readonly materialService;
+    private readonly batchService;
+    private readonly stockService;
+    readonly transferOrderEntity: EntityTarget<T>;
+    readonly transferOrderItemEntity: EntityTarget<K>;
+    readonly stockEntity: EntityTarget<StockEntityClass>;
+    private readonly seqPrefix;
+    readonly transferOrderRepository: Repository<T>;
+    constructor(dataSource: DataSource, helperService: HelperService, materialService: MaterialService, batchService: BatchService, stockService: StockService, transferOrderEntity: EntityTarget<T>, transferOrderItemEntity: EntityTarget<K>, stockEntity: EntityTarget<StockEntityClass>);
+    private getRepositories;
+    /**
+     * Process transfer order items (create transfer records and update stock)
+     */
+    private processTransferOrderItems;
+    cancelTransfer(options: CancelTransferOrderInput[] | CancelTransferOrderInput): Promise<boolean>;
+    /**
+     * Internal cancel method that accepts a manager for transaction support
+     */
+    private cancelTransferInternal;
+    /**
+     * Remove a transfer order
+     * Automatically cancels all remaining pending transfers to release stock
+     */
+    removeTransferOrder(id: string): Promise<boolean>;
+    createTransferOrder(options: CreateTransferOrderInput, manager?: EntityManager): Promise<T>;
+    updateTransferOrder({ id, manager, ...options }: UpdateTransferOrderInput & {
+        manager?: EntityManager;
+    }): Promise<T>;
+    findMany(options: FindTransferOrderInput): Promise<[T[], number]>;
+    transfer(options: TransferOrderInput[] | TransferOrderInput): Promise<boolean>;
+}