@rytass/wms-module-core 0.1.0

package/lib/services/quality-inspection-order.service.js

@@ -0,0 +1,135 @@
+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 { 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 '../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 { QualityInspectionOrderEntity } from '../models/extensions/quality-inspection-order/quality-inspection-order.entity.js';
+import { QualityInspectionOrderItemEntity } from '../models/extensions/quality-inspection-order/quality-inspection-order-item.entity.js';
+import { QualityInspectionOrderChangeEntityClass } from '../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 { BatchService } from './batch.service.js';
+import { MaterialService } from './material.service.js';
+import { StockService } from './stock.service.js';
+
+let QualityInspectionOrderService = class QualityInspectionOrderService {
+    dataSource;
+    qualityInspectionOrderEntity;
+    qualityInspectionOrderItemEntity;
+    batchService;
+    materialService;
+    stockService;
+    constructor(dataSource, qualityInspectionOrderEntity, qualityInspectionOrderItemEntity, batchService, materialService, stockService) {
+        this.dataSource = dataSource;
+        this.qualityInspectionOrderEntity = qualityInspectionOrderEntity;
+        this.qualityInspectionOrderItemEntity = qualityInspectionOrderItemEntity;
+        this.batchService = batchService;
+        this.materialService = materialService;
+        this.stockService = stockService;
+    }
+    async inspect({ manager = this.dataSource.manager, options, }) {
+        const orderRepository = manager.getRepository(OrderEntity);
+        const qualityInspectionOrderRepository = manager.getRepository(this.qualityInspectionOrderEntity);
+        const qualityInspectionOrderItemRepository = manager.getRepository(this.qualityInspectionOrderItemEntity);
+        const qualityInspectionOrderChangeRepository = manager.getRepository(QualityInspectionOrderChangeEntityClass);
+        const stockRepository = manager.getRepository(StockEntityClass);
+        const order = await qualityInspectionOrderRepository.save(qualityInspectionOrderRepository.create({
+            key: options.key,
+            note: options.note,
+        }));
+        await Promise.all(options.items.map(async (data) => {
+            if (!data.batchId || !data.materialId)
+                return;
+            const item = await qualityInspectionOrderItemRepository.save(qualityInspectionOrderItemRepository.create({
+                ...data,
+                orderId: order.id,
+                targetInspectedQuantity: data.quantity,
+            }));
+            // Create base order for the change
+            const baseOrder = await orderRepository.save({});
+            // Get conversion factor to convert to base unit
+            const conversionFactor = await this.materialService.getConversionFactor(item.materialId, item.unitId || undefined);
+            await qualityInspectionOrderChangeRepository.save(qualityInspectionOrderChangeRepository.create({
+                itemId: item.id,
+                quantityChanged: item.targetInspectedQuantity * conversionFactor,
+                order: baseOrder,
+            }));
+            const splittedBatch = await this.batchService.splitBatch({
+                manager,
+                id: data.batchId,
+                inspectionResult: data.inspectionResult,
+            });
+            await stockRepository.save([
+                stockRepository.create({
+                    orderId: baseOrder.id,
+                    materialId: data.materialId,
+                    batchId: splittedBatch.id,
+                    locationId: this.stockService.resolveLocationId(data.locationId),
+                    loaderId: this.stockService.resolveLoaderId(data.loaderId),
+                    quantity: data.quantity * conversionFactor,
+                }),
+                stockRepository.create({
+                    orderId: baseOrder.id,
+                    materialId: data.materialId,
+                    batchId: data.batchId,
+                    locationId: this.stockService.resolveLocationId(data.locationId),
+                    loaderId: this.stockService.resolveLoaderId(data.loaderId),
+                    quantity: -1 * data.quantity * conversionFactor,
+                }),
+            ]);
+        }));
+        return order;
+    }
+};
+QualityInspectionOrderService = __decorate([
+    Injectable(),
+    __param(1, Inject(QualityInspectionOrderEntity)),
+    __param(2, Inject(QualityInspectionOrderItemEntity)),
+    __metadata("design:paramtypes", [DataSource, Object, Object, BatchService,
+        MaterialService,
+        StockService])
+], QualityInspectionOrderService);
+
+export { QualityInspectionOrderService };

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

@@ -0,0 +1,41 @@
+import { ReceiveInventoryOrderEntityClass } from '../models/extensions/receive-inventory-order/receive-inventory-order.entity';
+import { ReceiveInventoryOrderItemEntityClass } from '../models/extensions/receive-inventory-order/receive-inventory-order-item.entity';
+import { DataSource, EntityManager, SelectQueryBuilder, type EntityTarget } from 'typeorm';
+import { CreateReceiveInventoryOrderInput, UpdateReceiveInventoryOrderInput } from '../typings/create-receive-inventory-order.input';
+import { FindReceiveInventoryOrderInput } from '../typings/find-receive-inventory-order.input';
+import { ReceiveInventoryOrderInput } from '../typings/receive-inventory-order.input';
+import { MaterialService } from './material.service';
+import { BatchService } from './batch.service';
+import { HelperService } from './helper.service';
+import { StockService } from './stock.service';
+/**
+ * Service for managing receive inventory orders and their items
+ * Supports dynamic entity injection for customization
+ * T - Receive Inventory Order entity type
+ * K - Receive Inventory Order Item entity type
+ */
+export declare class ReceiveInventoryOrderService<T extends ReceiveInventoryOrderEntityClass = ReceiveInventoryOrderEntityClass, K extends ReceiveInventoryOrderItemEntityClass = ReceiveInventoryOrderItemEntityClass> {
+    private readonly dataSource;
+    private readonly materialService;
+    private readonly batchService;
+    private readonly helperService;
+    private readonly stockService;
+    readonly receiveInventoryOrderEntity: EntityTarget<T>;
+    readonly receiveInventoryOrderItemEntity: EntityTarget<K>;
+    readonly selectQueryBuilder: (alias: string) => SelectQueryBuilder<T>;
+    constructor(dataSource: DataSource, materialService: MaterialService, batchService: BatchService, helperService: HelperService, stockService: StockService, receiveInventoryOrderEntity: EntityTarget<T>, receiveInventoryOrderItemEntity: EntityTarget<K>);
+    private processReceiveInventoryOrderItems;
+    createReceiveInventoryOrder({ manager, ...options }: CreateReceiveInventoryOrderInput & {
+        manager?: EntityManager;
+    }): Promise<T>;
+    /**
+     * Update a receive inventory order and its items
+     * update existing item when id is provided, otherwise create new item, remove behaviour controlled by removedAt field
+     */
+    updateReceiveInventoryOrder({ id, manager, ...options }: UpdateReceiveInventoryOrderInput & {
+        manager?: EntityManager;
+    }): Promise<T>;
+    removeReceiveInventoryOrder(id: string): Promise<boolean>;
+    findMany(options: FindReceiveInventoryOrderInput<T>): Promise<[T[], number]>;
+    receive(options: ReceiveInventoryOrderInput[] | ReceiveInventoryOrderInput): Promise<boolean>;
+}

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

@@ -0,0 +1,407 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable, Inject } from '@nestjs/common';
+import { ReceiveInventoryOrderEntity } from '../models/extensions/receive-inventory-order/receive-inventory-order.entity.js';
+import { ReceiveInventoryOrderItemEntity } from '../models/extensions/receive-inventory-order/receive-inventory-order-item.entity.js';
+import { DataSource, IsNull, In } from 'typeorm';
+import { OrderEntity } from '@rytass/wms-base-nestjs-module';
+import { ReceiveInventoryOrderStatus } from '../typings/find-receive-inventory-order.input.js';
+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 { 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 { ReceiveInventoryOrderChangeEntityClass } from '../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 '../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 { MaterialService } from './material.service.js';
+import { BatchService } from './batch.service.js';
+import { HelperService } from './helper.service.js';
+import { StockService } from './stock.service.js';
+
+/**
+ * Service for managing receive inventory orders and their items
+ * Supports dynamic entity injection for customization
+ * T - Receive Inventory Order entity type
+ * K - Receive Inventory Order Item entity type
+ */
+let ReceiveInventoryOrderService = class ReceiveInventoryOrderService {
+    dataSource;
+    materialService;
+    batchService;
+    helperService;
+    stockService;
+    receiveInventoryOrderEntity;
+    receiveInventoryOrderItemEntity;
+    selectQueryBuilder;
+    constructor(dataSource, materialService, batchService, helperService, stockService, receiveInventoryOrderEntity, receiveInventoryOrderItemEntity) {
+        this.dataSource = dataSource;
+        this.materialService = materialService;
+        this.batchService = batchService;
+        this.helperService = helperService;
+        this.stockService = stockService;
+        this.receiveInventoryOrderEntity = receiveInventoryOrderEntity;
+        this.receiveInventoryOrderItemEntity = receiveInventoryOrderItemEntity;
+        this.selectQueryBuilder = (alias) => {
+            return this.dataSource
+                .getRepository(this.receiveInventoryOrderEntity)
+                .createQueryBuilder(alias)
+                .leftJoin((subQuery) => subQuery
+                .select(`CASE
+                  WHEN o."removedAt" IS NOT NULL THEN '${ReceiveInventoryOrderStatus.REMOVED}'
+                  WHEN COALESCE((
+                    SELECT SUM(CAST(c."quantityChanged" AS NUMERIC))
+                    FROM receive_inventory_order_changes c
+                    JOIN receive_inventory_order_items i ON c."itemId" = i.id
+                    WHERE i."orderId" = o.id
+                  ), 0) = COALESCE(target_sum.targetsum, 0) AND COALESCE(target_sum.targetsum, 0) > 0 THEN '${ReceiveInventoryOrderStatus.RECEIVED}'
+                  WHEN COALESCE((
+                    SELECT SUM(CAST(c."quantityChanged" AS NUMERIC))
+                    FROM receive_inventory_order_changes c
+                    JOIN receive_inventory_order_items i ON c."itemId" = i.id
+                    WHERE i."orderId" = o.id
+                  ), 0) > 0 AND COALESCE((
+                    SELECT SUM(CAST(c."quantityChanged" AS NUMERIC))
+                    FROM receive_inventory_order_changes c
+                    JOIN receive_inventory_order_items i ON c."itemId" = i.id
+                    WHERE i."orderId" = o.id
+                  ), 0) < COALESCE(target_sum.targetsum, 0) THEN '${ReceiveInventoryOrderStatus.PARTIAL_RECEIVED}'
+                  ELSE '${ReceiveInventoryOrderStatus.PENDING}'
+                END`, 'status')
+                .addSelect('o.id', 'orderid')
+                .from('receive_inventory_orders', 'o')
+                .leftJoin((sumQuery) => sumQuery
+                .select('i."orderId"', 'orderid')
+                .addSelect('SUM(CAST(i."targetReceivedQuantity" AS NUMERIC))', 'targetsum')
+                .from('receive_inventory_order_items', 'i')
+                .groupBy('i."orderId"'), 'target_sum', 'target_sum.orderid = o.id'), 'order_status', `${alias}.id = order_status.orderid`)
+                .select('orders.id', 'id')
+                .addSelect('orders.key', 'key')
+                .addSelect('orders.description', 'description')
+                .addSelect('orders."createdBy"', 'createdBy')
+                .addSelect('orders."createdAt"', 'createdAt')
+                .addSelect('orders."removedAt"', 'removedAt')
+                .addSelect('order_status.status', `status`);
+        };
+    }
+    processReceiveInventoryOrderItems(items, orderId, manager) {
+        const materialRepository = manager.getRepository(MaterialEntityClass);
+        const locationRepository = manager.getRepository(LocationEntityClass);
+        const loaderRepository = manager.getRepository(LoadersEntityClass);
+        return items.reduce(async (accPromise, item) => {
+            const acc = await accPromise;
+            try {
+                const material = await materialRepository.findOneBy({
+                    key: item.materialKey,
+                });
+                if (!material)
+                    return acc;
+                const batch = item.batchKey
+                    ? await this.batchService.getBatch({
+                        manager,
+                        materialId: material.id,
+                        key: item.batchKey,
+                    })
+                    : null;
+                const location = item.locationKey
+                    ? await locationRepository.findOneBy({
+                        key: item.locationKey,
+                    })
+                    : null;
+                const loader = item.loaderKey
+                    ? await loaderRepository.findOneBy({
+                        serialId: item.loaderKey,
+                    })
+                    : null;
+                return [
+                    ...acc,
+                    {
+                        ...item,
+                        orderId,
+                        materialId: material.id,
+                        batchId: batch?.id || null,
+                        locationId: this.stockService.resolveLocationId(location?.id),
+                        loaderId: loader?.id || null,
+                    },
+                ];
+            }
+            catch {
+                return acc;
+            }
+        }, Promise.resolve([]));
+    }
+    async createReceiveInventoryOrder({ manager = this.dataSource.manager, ...options }) {
+        const orderRepository = manager.getRepository(OrderEntity);
+        const receiveInventoryOrderRepository = manager.getRepository(this.receiveInventoryOrderEntity);
+        const receiveInventoryOrderItemRepository = manager.getRepository(this.receiveInventoryOrderItemEntity);
+        // create base order
+        const { id } = await orderRepository.save(orderRepository.create());
+        // create receive inventory order
+        const { items, ...orderOptions } = options;
+        const order = await receiveInventoryOrderRepository.save(receiveInventoryOrderRepository.create({ id, ...orderOptions }));
+        // create receive inventory order items
+        if (items && items.length > 0) {
+            const processedItems = receiveInventoryOrderItemRepository.create(await this.processReceiveInventoryOrderItems(items, id, manager));
+            await receiveInventoryOrderItemRepository.save(processedItems);
+        }
+        return order;
+    }
+    /**
+     * Update a receive inventory order and its items
+     * update existing item when id is provided, otherwise create new item, remove behaviour controlled by removedAt field
+     */
+    async updateReceiveInventoryOrder({ id, manager = this.dataSource.manager, ...options }) {
+        const receiveInventoryOrderRepository = manager.getRepository(this.receiveInventoryOrderEntity);
+        const receiveInventoryOrderItemRepository = manager.getRepository(this.receiveInventoryOrderItemEntity);
+        const order = await receiveInventoryOrderRepository.findOneByOrFail({
+            id,
+            removedAt: IsNull(),
+        });
+        const { items, ...orderOptions } = options;
+        const updated = await receiveInventoryOrderRepository.save(receiveInventoryOrderRepository.create({
+            ...order,
+            ...orderOptions,
+        }));
+        if (items?.length) {
+            const newItems = [];
+            const existingItems = [];
+            await receiveInventoryOrderItemRepository
+                .find({ where: { orderId: id } })
+                .then((items) => {
+                const itemSet = new Set(items.map((i) => i.id));
+                options.items?.forEach((item) => {
+                    if (!item.id)
+                        newItems.push(item);
+                    else if (itemSet.has(item.id))
+                        existingItems.push(item);
+                });
+            });
+            if (newItems.length)
+                await receiveInventoryOrderItemRepository.save(receiveInventoryOrderItemRepository.create(await this.processReceiveInventoryOrderItems(newItems, id, manager)));
+            if (existingItems.length)
+                await receiveInventoryOrderItemRepository.save(existingItems.map((item) => receiveInventoryOrderItemRepository.create({
+                    ...item,
+                    id: item.id,
+                })));
+        }
+        return updated;
+    }
+    async removeReceiveInventoryOrder(id) {
+        return this.dataSource
+            .getRepository(this.receiveInventoryOrderEntity)
+            .update({ id }, { removedAt: new Date() })
+            .then(({ affected }) => !!affected && affected > 0);
+    }
+    async findMany(options) {
+        const queryBuilder = this.selectQueryBuilder('orders');
+        if (options.id)
+            queryBuilder.andWhere('orders.id = :id', { id: options.id });
+        if (options.createdBy)
+            queryBuilder.andWhere('orders."createdBy" ILIKE :createdBy', {
+                createdBy: `%${options.createdBy}%`,
+            });
+        if (options.description)
+            queryBuilder.andWhere('orders.description ILIKE :description', {
+                description: `%${options.description}%`,
+            });
+        if (options.dateRange)
+            queryBuilder.andWhere('orders."createdAt" BETWEEN :from AND :to', {
+                from: options.dateRange.from,
+                to: options.dateRange.to,
+            });
+        if (options.status)
+            queryBuilder.andWhere(`status = :status`, {
+                status: options.status,
+            });
+        if (options.statuses && options.statuses.length > 0)
+            queryBuilder.andWhere(`status IN (:...statuses)`, {
+                statuses: options.statuses,
+            });
+        if (options.materialKey)
+            queryBuilder.andWhere(`EXISTS (
+          SELECT 1 FROM receive_inventory_order_items ri_items
+          INNER JOIN materials ri_mat ON ri_mat.id = ri_items."materialId"
+          WHERE ri_items."orderId" = orders.id
+          AND ri_mat.key ILIKE :materialKey
+        )`, { materialKey: `%${options.materialKey}%` });
+        if (options.batchKey)
+            queryBuilder.andWhere(`EXISTS (
+          SELECT 1 FROM receive_inventory_order_items ri_items
+          INNER JOIN batches ri_batch ON ri_batch.id = ri_items."batchId"
+          WHERE ri_items."orderId" = orders.id
+          AND ri_batch.key ILIKE :batchKey
+        )`, { batchKey: `%${options.batchKey}%` });
+        if (options.locationKey)
+            queryBuilder.andWhere(`EXISTS (
+          SELECT 1 FROM receive_inventory_order_items ri_items
+          INNER JOIN locations ri_loc ON ri_loc.id = ri_items."locationId"
+          WHERE ri_items."orderId" = orders.id
+          AND ri_loc.key ILIKE :locationKey
+        )`, { locationKey: `%${options.locationKey}%` });
+        if (options.loaderKey)
+            queryBuilder.andWhere(`EXISTS (
+          SELECT 1 FROM receive_inventory_order_items ri_items
+          INNER JOIN loaders ri_ldr ON ri_ldr.id = ri_items."loaderId"
+          WHERE ri_items."orderId" = orders.id
+          AND ri_ldr."serialId" ILIKE :loaderKey
+        )`, { loaderKey: `%${options.loaderKey}%` });
+        if (options.wildcard) {
+            const { key, value } = options.wildcard;
+            queryBuilder.andWhere(`orders."${String(key)}" ILIKE :value`, {
+                value: `%${value}%`,
+            });
+        }
+        const total = await queryBuilder.getCount();
+        if (options.offset !== undefined && options.offset >= 0)
+            queryBuilder.skip(options.offset);
+        if (options.limit !== undefined && options.limit > 0)
+            queryBuilder.take(options.limit);
+        const items = await queryBuilder.getRawMany();
+        return [items, total];
+    }
+    receive(options) {
+        if (!Array.isArray(options))
+            options = [options];
+        return this.dataSource.transaction(async (manager) => {
+            const changeRepository = manager.getRepository(ReceiveInventoryOrderChangeEntityClass);
+            const itemRepository = manager.getRepository(this.receiveInventoryOrderItemEntity);
+            const orderRepository = manager.getRepository(OrderEntity);
+            const locationRepository = manager.getRepository(LocationEntityClass);
+            const loaderRepository = manager.getRepository(LoadersEntityClass);
+            const stockRepository = manager.getRepository(StockEntityClass);
+            const items = await itemRepository.find({
+                where: { id: In(options.map((o) => o.itemId)) },
+                relations: ['changes'],
+            });
+            const itemMap = new Map(items.map((i) => [i.id, i]));
+            await Promise.all(options.map(async (option) => {
+                const item = itemMap.get(option.itemId);
+                if (!item)
+                    return;
+                if (!item.batchId && option.batchKey) {
+                    // if batchKey is provided but item doesn't have batchId, attempt to find or create batch and update item with batchId
+                    item.batchId = await this.batchService
+                        .getBatch({
+                        manager,
+                        key: option.batchKey,
+                        materialId: item.materialId,
+                    })
+                        .then(async (b) => {
+                        await itemRepository.update({ id: item.id }, { batchId: b.id });
+                        return b.id;
+                    });
+                }
+                const conversionFactor = await this.materialService.getConversionFactor(item.materialId, item.unitId || undefined);
+                const totalChanged = item.changes.reduce((sum, change) => sum + Number(change.quantityChanged), 0);
+                const remainingQuantity = conversionFactor * item.targetReceivedQuantity - totalChanged;
+                if (remainingQuantity - option.quantity * conversionFactor < 0) {
+                    throw new Error(`Receiving quantity exceeds target for item ${option.itemId}`);
+                }
+                const newOrder = await orderRepository.save(orderRepository.create());
+                let batchId = item.batchId;
+                if (option.batchKey)
+                    batchId = await this.batchService
+                        .getBatch({
+                        manager,
+                        key: option.batchKey,
+                        materialId: item.materialId,
+                    })
+                        .then(({ id }) => id);
+                if (!batchId)
+                    batchId = await this.batchService
+                        .getBatch({
+                        manager,
+                        key: await this.helperService.getSeq('BATCH'),
+                        materialId: item.materialId,
+                    })
+                        .then(({ id }) => id);
+                const inspectionResult = item.requireInspection === false
+                    ? true
+                    : (option.inspectionResult ?? null);
+                if (inspectionResult != null)
+                    batchId = await this.batchService
+                        .splitBatch({
+                        manager,
+                        id: batchId,
+                        inspectionResult,
+                    })
+                        .then(({ id }) => id);
+                let locationId = item.locationId;
+                if (option.locationKey && !locationId)
+                    locationId = await locationRepository
+                        .findOneByOrFail({ key: option.locationKey })
+                        .then(({ id }) => id);
+                let loaderId = item.loaderId;
+                if (option.loaderKey && !loaderId)
+                    loaderId = await loaderRepository
+                        .findOneByOrFail({ serialId: option.loaderKey })
+                        .then(({ id }) => id);
+                await Promise.all([
+                    changeRepository.save(changeRepository.create({
+                        itemId: option.itemId,
+                        quantityChanged: option.quantity * conversionFactor,
+                        id: newOrder.id,
+                    })),
+                    stockRepository.save(stockRepository.create({
+                        batchId: batchId || undefined,
+                        locationId: this.stockService.resolveLocationId(locationId),
+                        loaderId: this.stockService.resolveLoaderId(loaderId),
+                        materialId: item.materialId,
+                        quantity: option.quantity * conversionFactor,
+                        orderId: newOrder.id,
+                    })),
+                ]);
+            }));
+            return true;
+        });
+    }
+};
+ReceiveInventoryOrderService = __decorate([
+    Injectable(),
+    __param(5, Inject(ReceiveInventoryOrderEntity)),
+    __param(6, Inject(ReceiveInventoryOrderItemEntity)),
+    __metadata("design:paramtypes", [DataSource,
+        MaterialService,
+        BatchService,
+        HelperService,
+        StockService, Object, Object])
+], ReceiveInventoryOrderService);
+
+export { ReceiveInventoryOrderService };

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

@@ -0,0 +1,19 @@
+import { ReclassifyInventoryOrderEntityClass, ReclassifyInventoryOrderItemEntityClass } from '../models';
+import { DataSource, EntityTarget } from 'typeorm';
+import { ReclassifyInventoryOrderInput } from '../typings/reclassify-inventory-order.input';
+import { MaterialService } from './material.service';
+import { BatchService } from './batch.service';
+import { HelperService } from './helper.service';
+import { StockService } from './stock.service';
+export declare class ReclassifyInventoryOrderService<T extends ReclassifyInventoryOrderEntityClass = ReclassifyInventoryOrderEntityClass, K extends ReclassifyInventoryOrderItemEntityClass = ReclassifyInventoryOrderItemEntityClass> {
+    private readonly dataSource;
+    private readonly materialService;
+    private readonly batchService;
+    private readonly helperService;
+    private readonly stockService;
+    readonly reclassifyInventoryOrderEntity: EntityTarget<T>;
+    readonly reclassifyInventoryOrderItemEntity: EntityTarget<K>;
+    private readonly seqPrefix;
+    constructor(dataSource: DataSource, materialService: MaterialService, batchService: BatchService, helperService: HelperService, stockService: StockService, reclassifyInventoryOrderEntity: EntityTarget<T>, reclassifyInventoryOrderItemEntity: EntityTarget<K>);
+    reclassify(options: ReclassifyInventoryOrderInput): Promise<T>;
+}