@rytass/wms-module-core 0.1.0

package/lib/services/reclassify-inventory-order.service.js

@@ -0,0 +1,181 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable, Inject } from '@nestjs/common';
+import { BatchEntityClass } from '../models/metadata/batch.entity.js';
+import '../models/metadata/batch-group.entity.js';
+import '../models/metadata/loader.entity.js';
+import '../models/metadata/loader-type.entity.js';
+import '../models/metadata/loader-unit.entity.js';
+import '../models/metadata/location.entity.js';
+import { MaterialEntityClass } from '../models/metadata/material.entity.js';
+import '../models/metadata/material-unit.entity.js';
+import '../models/metadata/sale-order.entity.js';
+import { StockEntityClass } 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 { ReclassifyInventoryOrderEntity } from '../models/extensions/reclassify-inventory-order/reclassify-inventory-order.entity.js';
+import { ReclassifyInventoryOrderItemEntity } from '../models/extensions/reclassify-inventory-order/reclassify-inventory-order-item.entity.js';
+import { ReclassifyInventoryOrderChangeEntityClass } from '../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 '../models/extensions/transfer-customer-order/transfer-customer-order.entity.js';
+import '../models/extensions/transfer-customer-order/transfer-customer-order-item.entity.js';
+import '../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 } from 'typeorm';
+import { OrderEntity } from '@rytass/wms-base-nestjs-module';
+import { MaterialService } from './material.service.js';
+import { BatchService } from './batch.service.js';
+import { HelperService } from './helper.service.js';
+import { StockService } from './stock.service.js';
+
+let ReclassifyInventoryOrderService = class ReclassifyInventoryOrderService {
+    dataSource;
+    materialService;
+    batchService;
+    helperService;
+    stockService;
+    reclassifyInventoryOrderEntity;
+    reclassifyInventoryOrderItemEntity;
+    seqPrefix = 'RCO';
+    constructor(dataSource, materialService, batchService, helperService, stockService, reclassifyInventoryOrderEntity, reclassifyInventoryOrderItemEntity) {
+        this.dataSource = dataSource;
+        this.materialService = materialService;
+        this.batchService = batchService;
+        this.helperService = helperService;
+        this.stockService = stockService;
+        this.reclassifyInventoryOrderEntity = reclassifyInventoryOrderEntity;
+        this.reclassifyInventoryOrderItemEntity = reclassifyInventoryOrderItemEntity;
+    }
+    reclassify(options) {
+        return this.dataSource.transaction(async (manager) => {
+            const reclassifyOrderRepository = manager.getRepository(this.reclassifyInventoryOrderEntity);
+            const reclassifyOrderItemRepository = manager.getRepository(this.reclassifyInventoryOrderItemEntity);
+            const reclassifyOrderChangeRepository = manager.getRepository(ReclassifyInventoryOrderChangeEntityClass);
+            const orderRepository = manager.getRepository(OrderEntity);
+            const stockRepository = manager.getRepository(StockEntityClass);
+            const batchRepository = manager.getRepository(BatchEntityClass);
+            const materialRepository = manager.getRepository(MaterialEntityClass);
+            // Ensure new material exists
+            const material = await materialRepository.findOneOrFail({
+                where: { key: options.materialKey },
+            });
+            const key = await this.helperService.getSeq(this.seqPrefix, manager);
+            const order = await reclassifyOrderRepository.save(reclassifyOrderRepository.create({
+                key,
+            }));
+            // Process each item reclassification
+            await Promise.all(options.items.map(async (item) => {
+                if (item.materialId === material.id) {
+                    throw new Error(`Item with batchId ${item.batchId} is already classified under the target material`);
+                }
+                // Get conversion factor for unit conversion
+                const conversionFactor = await this.materialService.getConversionFactor(material.id, item.unitId || undefined);
+                const { key, ...batch } = await batchRepository.findOneOrFail({
+                    where: { id: item.batchId },
+                });
+                // Get or create a batch for the new material
+                const targetBatch = await this.batchService
+                    .getBatch({
+                    materialId: material.id,
+                    key,
+                    manager,
+                })
+                    .then(({ id }) => this.batchService.splitBatch({
+                    saleId: batch.saleId ?? null,
+                    saleSerialId: batch.saleSerialId ?? null,
+                    customerId: batch.customerId ?? null,
+                    vendorId: batch.vendorId ?? null,
+                    inspectionResult: batch.inspectionResult ?? null,
+                    transferId: batch.transferId ?? null,
+                    held: batch.held ?? false,
+                    inShipment: batch.inShipment ?? false,
+                    manager,
+                    id,
+                }));
+                // Create base order record
+                const baseOrder = await orderRepository.save({});
+                // Create reclassify order item
+                const reclassifyItem = await reclassifyOrderItemRepository.save(reclassifyOrderItemRepository.create({
+                    targetReclassifiedQuantity: item.quantity,
+                    locationId: this.stockService.resolveLocationId(item.locationId),
+                    loaderId: item.loaderId,
+                    orderId: order.id,
+                }));
+                // Record the change
+                await reclassifyOrderChangeRepository.save(reclassifyOrderChangeRepository.create({
+                    itemId: reclassifyItem.id,
+                    id: baseOrder.id,
+                    quantityChanged: item.quantity * conversionFactor,
+                }));
+                // Update stock: deduct from original material and add to new material
+                await this.stockService.validateStockAvailability({
+                    materialId: item.materialId,
+                    batchId: item.batchId,
+                    locationId: this.stockService.resolveLocationId(item.locationId),
+                    loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                    quantity: item.quantity * conversionFactor,
+                }, manager);
+                await stockRepository.save(stockRepository.create([
+                    // Deduct from original material batch
+                    {
+                        orderId: baseOrder.id,
+                        materialId: item.materialId,
+                        batchId: item.batchId,
+                        locationId: this.stockService.resolveLocationId(item.locationId),
+                        loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                        quantity: -1 * item.quantity * conversionFactor,
+                    },
+                    // Add to new material batch
+                    {
+                        orderId: baseOrder.id,
+                        materialId: material.id,
+                        batchId: targetBatch.id,
+                        locationId: this.stockService.resolveLocationId(item.locationId),
+                        loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                        quantity: item.quantity * conversionFactor,
+                    },
+                ]));
+            }));
+            return order;
+        });
+    }
+};
+ReclassifyInventoryOrderService = __decorate([
+    Injectable(),
+    __param(5, Inject(ReclassifyInventoryOrderEntity)),
+    __param(6, Inject(ReclassifyInventoryOrderItemEntity)),
+    __metadata("design:paramtypes", [DataSource,
+        MaterialService,
+        BatchService,
+        HelperService,
+        StockService, Object, Object])
+], ReclassifyInventoryOrderService);
+
+export { ReclassifyInventoryOrderService };

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

@@ -0,0 +1,7 @@
+import { DataSource, Repository } from 'typeorm';
+import { SaleOrderEntityClass } from '../models/metadata/sale-order.entity';
+export declare class SaleOrderService {
+    private readonly dataSource;
+    readonly saleOrderRepository: Repository<SaleOrderEntityClass>;
+    constructor(dataSource: DataSource);
+}

package/lib/services/sale-order.service.js

@@ -0,0 +1,20 @@
+import { __decorate, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import { SaleOrderEntityClass } from '../models/metadata/sale-order.entity.js';
+
+let SaleOrderService = class SaleOrderService {
+    dataSource;
+    saleOrderRepository;
+    constructor(dataSource) {
+        this.dataSource = dataSource;
+        this.saleOrderRepository =
+            this.dataSource.getRepository(SaleOrderEntityClass);
+    }
+};
+SaleOrderService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DataSource])
+], SaleOrderService);
+
+export { SaleOrderService };

package/lib/services/scrape.service.d.ts

@@ -0,0 +1,18 @@
+import { ScrapeOrderEntityClass, StockEntityClass } from '../models';
+import { DataSource, EntityManager, EntityTarget } from 'typeorm';
+import { ScrapeInput } from '../typings/scrape.input';
+import { HelperService } from './helper.service';
+import { MaterialService } from './material.service';
+import { StockService } from './stock.service';
+export declare class ScrapeService<T extends ScrapeOrderEntityClass = ScrapeOrderEntityClass> {
+    private readonly dataSource;
+    private readonly helperService;
+    private readonly materialService;
+    private readonly stockService;
+    readonly scrapeOrderEntity: EntityTarget<T>;
+    readonly stockEntity: EntityTarget<StockEntityClass>;
+    private readonly seqPrefix;
+    constructor(dataSource: DataSource, helperService: HelperService, materialService: MaterialService, stockService: StockService, scrapeOrderEntity: EntityTarget<T>, stockEntity: EntityTarget<StockEntityClass>);
+    private getRepositories;
+    scrape(items: ScrapeInput[], manager?: EntityManager): Promise<T>;
+}

package/lib/services/scrape.service.js

@@ -0,0 +1,139 @@
+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 '../models/metadata/loader.entity.js';
+import '../models/metadata/loader-type.entity.js';
+import '../models/metadata/loader-unit.entity.js';
+import '../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 '../models/extensions/transfer-customer-order/transfer-customer-order.entity.js';
+import '../models/extensions/transfer-customer-order/transfer-customer-order-item.entity.js';
+import '../models/extensions/transfer-customer-order/transfer-customer-order-change.entity.js';
+import { ScrapeOrderEntity } from '../models/extensions/scrape-order/scrape-order.entity.js';
+import { ScrapeOrderItemEntityClass } from '../models/extensions/scrape-order/scrape-order-item.entity.js';
+import { ScrapeOrderChangeEntityClass } from '../models/extensions/scrape-order/scrape-order-change.entity.js';
+import { DataSource } from 'typeorm';
+import { OrderEntity } from '@rytass/wms-base-nestjs-module';
+import { HelperService } from './helper.service.js';
+import { MaterialService } from './material.service.js';
+import { StockService } from './stock.service.js';
+
+let ScrapeService = class ScrapeService {
+    dataSource;
+    helperService;
+    materialService;
+    stockService;
+    scrapeOrderEntity;
+    stockEntity;
+    seqPrefix = 'SCR';
+    constructor(dataSource, helperService, materialService, stockService, scrapeOrderEntity, stockEntity) {
+        this.dataSource = dataSource;
+        this.helperService = helperService;
+        this.materialService = materialService;
+        this.stockService = stockService;
+        this.scrapeOrderEntity = scrapeOrderEntity;
+        this.stockEntity = stockEntity;
+    }
+    getRepositories(manager) {
+        return {
+            scrapeOrder: manager.getRepository(this.scrapeOrderEntity),
+            scrapeOrderItem: manager.getRepository(ScrapeOrderItemEntityClass),
+            scrapeOrderChange: manager.getRepository(ScrapeOrderChangeEntityClass),
+            order: manager.getRepository(OrderEntity),
+            stock: manager.getRepository(this.stockEntity),
+        };
+    }
+    async scrape(items, manager = this.dataSource.manager) {
+        const repos = this.getRepositories(manager);
+        const key = await this.helperService.getSeq(this.seqPrefix);
+        // Create order
+        const order = await repos.scrapeOrder.save(repos.scrapeOrder.create({
+            key,
+        }));
+        // Process each item
+        await Promise.all(items.map(async (data) => {
+            if (!data.materialId || !data.batchId)
+                return;
+            // Create order item
+            const item = await repos.scrapeOrderItem.save(repos.scrapeOrderItem.create({
+                ...data,
+                orderId: order.id,
+                targetScrapedQuantity: data.quantity,
+            }));
+            // Create base order for the change
+            const baseOrder = await repos.order.save({});
+            // Get conversion factor to convert to base unit
+            const conversionFactor = await this.materialService.getConversionFactor(item.materialId, item.unitId || undefined);
+            // Create change record
+            await repos.scrapeOrderChange.save(repos.scrapeOrderChange.create({
+                item,
+                order: baseOrder,
+                quantityChanged: item.targetScrapedQuantity * conversionFactor,
+            }));
+            // Deduct stock from original batch (only deduction, no transfer)
+            await this.stockService.validateStockAvailability({
+                materialId: item.materialId,
+                batchId: item.batchId,
+                locationId: this.stockService.resolveLocationId(item.locationId),
+                loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                quantity: item.targetScrapedQuantity * conversionFactor,
+            }, manager);
+            await repos.stock.save(repos.stock.create({
+                orderId: baseOrder.id,
+                materialId: item.materialId,
+                batchId: item.batchId,
+                locationId: this.stockService.resolveLocationId(item.locationId),
+                loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                quantity: -1 * item.targetScrapedQuantity * conversionFactor,
+            }));
+        }));
+        return order;
+    }
+};
+ScrapeService = __decorate([
+    Injectable(),
+    __param(4, Inject(ScrapeOrderEntity)),
+    __param(5, Inject(StockEntity)),
+    __metadata("design:paramtypes", [DataSource,
+        HelperService,
+        MaterialService,
+        StockService, Object, Object])
+], ScrapeService);
+
+export { ScrapeService };

package/lib/services/ship-inventory-order.service.d.ts

@@ -0,0 +1,60 @@
+import { ShipInventoryOrderEntityClass } from '../models/extensions/ship-inventory-order/ship-inventory-order.entity';
+import { ShipInventoryOrderItemEntityClass } from '../models/extensions/ship-inventory-order/ship-inventory-order-item.entity';
+import { DataSource, EntityManager, SelectQueryBuilder, type EntityTarget } from 'typeorm';
+import { CreateShipInventoryOrderInput, CreateShipInventoryOrderItemsInput, UpdateShipInventoryOrderInput } from '../typings/create-ship-inventory-order.input';
+import { FindShipInventoryOrderInput } from '../typings/find-ship-inventory-order.input';
+import { ShipInventoryOrderReferenceEntityClass, SaleOrderEntityClass } from '../models';
+import { ShipInventoryOrderInput } from '../typings/ship-inventory-order.input';
+import { CancelShipInventoryOrderInput } from '../typings/cancel-ship-inventory-order.input';
+import { MaterialService } from './material.service';
+import { BatchService } from './batch.service';
+import { StockService } from './stock.service';
+/**
+ * Service for managing ship inventory orders and their items
+ * Supports dynamic entity injection for customization
+ * T - Ship Inventory Order entity type
+ * K - Ship Inventory Order Item entity type
+ */
+export declare class ShipInventoryOrderService<T extends ShipInventoryOrderEntityClass = ShipInventoryOrderEntityClass, K extends ShipInventoryOrderItemEntityClass = ShipInventoryOrderItemEntityClass> {
+    private readonly dataSource;
+    private readonly materialService;
+    private readonly batchService;
+    private readonly stockService;
+    readonly shipInventoryOrderEntity: EntityTarget<T>;
+    readonly shipInventoryOrderItemEntity: EntityTarget<K>;
+    readonly shipInventoryOrderReferenceEntity: EntityTarget<ShipInventoryOrderReferenceEntityClass>;
+    readonly saleOrderEntity: EntityTarget<SaleOrderEntityClass>;
+    readonly selectQueryBuilder: (alias: string) => SelectQueryBuilder<T>;
+    constructor(dataSource: DataSource, materialService: MaterialService, batchService: BatchService, stockService: StockService, shipInventoryOrderEntity: EntityTarget<T>, shipInventoryOrderItemEntity: EntityTarget<K>, shipInventoryOrderReferenceEntity: EntityTarget<ShipInventoryOrderReferenceEntityClass>, saleOrderEntity: EntityTarget<SaleOrderEntityClass>);
+    private processShipInventoryOrderReferences;
+    private processShipInventoryOrderItems;
+    createShipInventoryOrder({ manager, ...options }: CreateShipInventoryOrderInput & {
+        manager?: EntityManager;
+    }): Promise<T>;
+    /**
+     * Update a ship inventory order and its items
+     * update existing item when id is provided, otherwise create new item, remove behaviour controlled by removedAt field
+     */
+    updateShipInventoryOrder({ id, manager, ...options }: UpdateShipInventoryOrderInput & {
+        manager?: EntityManager;
+    }): Promise<T>;
+    /**
+     * Remove a ship inventory order
+     * Automatically cancels all remaining prepared (but not shipped) items to release stock
+     */
+    removeShipInventoryOrder(id: string): Promise<boolean>;
+    /**
+     * Internal cancel method that accepts a manager for transaction support
+     */
+    private cancelShipInternal;
+    findMany(options: FindShipInventoryOrderInput<T>): Promise<[T[], number]>;
+    addShipInventoryOrderItems(options: CreateShipInventoryOrderItemsInput, manager?: EntityManager): Promise<T>;
+    ship(options: ShipInventoryOrderInput[] | ShipInventoryOrderInput): Promise<boolean>;
+    /**
+     * Cancel prepared ship inventory order items
+     * Reverses the prepare step by moving stock from IN_SHIPMENT back to FREE
+     * Can only cancel prepared quantity that hasn't been shipped yet
+     * If quantity is not provided, cancels all remaining cancellable quantity
+     */
+    cancelShip(options: CancelShipInventoryOrderInput[] | CancelShipInventoryOrderInput): Promise<boolean>;
+}