@rytass/wms-module-core 0.1.0

package/lib/services/location.service.js

@@ -0,0 +1,130 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable, Inject } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+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 { LocationEntity } 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 '../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 '../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';
+
+let LocationService = class LocationService {
+    dataSource;
+    locationEntity;
+    locationReposistory;
+    constructor(dataSource, locationEntity) {
+        this.dataSource = dataSource;
+        this.locationEntity = locationEntity;
+        this.locationReposistory = this.dataSource.getRepository(this.locationEntity);
+    }
+    async createLocation({ parentId, ...options }) {
+        const parent = parentId
+            ? await this.locationReposistory
+                .createQueryBuilder('l')
+                .where('l.id = :id', { id: parentId })
+                .getOneOrFail()
+            : undefined;
+        return this.locationReposistory.save(this.locationReposistory.create({
+            ...options,
+            ...(parent !== undefined && { parent }),
+        }));
+    }
+    async updateLocation({ id, parentId, ...options }) {
+        const location = await this.locationReposistory
+            .createQueryBuilder('location')
+            .where('location.id = :id', { id })
+            .getOneOrFail();
+        if (parentId) {
+            const parent = await this.locationReposistory
+                .createQueryBuilder('l')
+                .where('l.id = :id', { id: parentId })
+                .getOneOrFail();
+            Object.assign(location, { parent });
+        }
+        else {
+            Object.assign(location, { parent: null });
+        }
+        return this.locationReposistory.save(this.locationReposistory.create({
+            ...location,
+            ...options,
+        }));
+    }
+    async findMany(options) {
+        const queryBuilder = this.locationReposistory
+            .createQueryBuilder('location')
+            .loadRelationIdAndMap('location.parentId', 'location.parent')
+            .leftJoinAndSelect('location.children', 'children');
+        if (options.root !== undefined)
+            queryBuilder.andWhere(options.root
+                ? 'location."parentId" IS NULL'
+                : 'location."parentId" IS NOT NULL');
+        if (options.description)
+            queryBuilder.andWhere('location."description" ILIKE :description', {
+                description: `%${options.description}%`,
+            });
+        if (options.isActive !== undefined)
+            queryBuilder.andWhere('location."isActive" = :isActive', {
+                isActive: options.isActive,
+            });
+        if (options.wildcard) {
+            const { key, value } = options.wildcard;
+            queryBuilder.andWhere(`location."${String(key)}" ILIKE :value`, {
+                value: `%${value}%`,
+            });
+        }
+        if (options.offset !== undefined && options.offset >= 0)
+            queryBuilder.skip(options.offset);
+        if (options.limit !== undefined && options.limit > 0)
+            queryBuilder.take(options.limit);
+        return queryBuilder.getManyAndCount();
+    }
+};
+LocationService = __decorate([
+    Injectable(),
+    __param(1, Inject(LocationEntity)),
+    __metadata("design:paramtypes", [DataSource, Object])
+], LocationService);
+
+export { LocationService };

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

@@ -0,0 +1,27 @@
+import { CreateMaterialInput, UpdateMaterialInput } from '../typings/create-material.input';
+import { MaterialEntityClass } from '../models/metadata/material.entity';
+import { MaterialUnitEntityClass } from '../models/metadata/material-unit.entity';
+import { DataSource, EntityManager, Repository, type EntityTarget } from 'typeorm';
+import { FindMaterialInput } from '../typings/find-material.input';
+/**
+ * Service for managing materials and their units
+ * Supports dynamic entity injection for customization
+ * T - Material entity type
+ * K - Material Unit entity type
+ */
+export declare class MaterialService<T extends MaterialEntityClass = MaterialEntityClass, K extends MaterialUnitEntityClass = MaterialUnitEntityClass> {
+    private readonly dataSource;
+    readonly materialEntity: EntityTarget<T>;
+    readonly materialUnitEntity: EntityTarget<K>;
+    readonly materialRepository: Repository<T>;
+    readonly materialUnitRepository: Repository<K>;
+    constructor(dataSource: DataSource, materialEntity: EntityTarget<T>, materialUnitEntity: EntityTarget<K>);
+    getConversionFactor(materialId: string, unitId?: string): Promise<number>;
+    createMaterial({ manager, ...options }: CreateMaterialInput & {
+        manager?: EntityManager;
+    }): Promise<T>;
+    updateMaterial({ manager, ...options }: UpdateMaterialInput & {
+        manager?: EntityManager;
+    }): Promise<T>;
+    findMany(options: FindMaterialInput<T>): Promise<[T[], number]>;
+}

package/lib/services/material.service.js

@@ -0,0 +1,172 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable, Inject } from '@nestjs/common';
+import { MaterialEntity } from '../models/metadata/material.entity.js';
+import { MaterialUnitEntity } from '../models/metadata/material-unit.entity.js';
+import { DataSource } from 'typeorm';
+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/sale-order.entity.js';
+import '../models/metadata/stock.entity.js';
+import { UnitEntityClass } from '../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 '../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';
+
+/**
+ * Service for managing materials and their units
+ * Supports dynamic entity injection for customization
+ * T - Material entity type
+ * K - Material Unit entity type
+ */
+let MaterialService = class MaterialService {
+    dataSource;
+    materialEntity;
+    materialUnitEntity;
+    materialRepository;
+    materialUnitRepository;
+    constructor(dataSource, materialEntity, materialUnitEntity) {
+        this.dataSource = dataSource;
+        this.materialEntity = materialEntity;
+        this.materialUnitEntity = materialUnitEntity;
+        this.materialRepository = this.dataSource.getRepository(this.materialEntity);
+        this.materialUnitRepository = this.dataSource.getRepository(this.materialUnitEntity);
+    }
+    async getConversionFactor(materialId, unitId) {
+        const materialUnitRepository = this.dataSource.getRepository(this.materialUnitEntity);
+        if (!unitId)
+            return 1;
+        const materialUnit = await materialUnitRepository.findOneByOrFail({
+            materialId,
+            id: unitId,
+        });
+        return materialUnit.conversionFactor;
+    }
+    async createMaterial({ manager = this.dataSource.manager, ...options }) {
+        const materialRepository = manager.getRepository(this.materialEntity);
+        const materialUnitRepository = manager.getRepository(this.materialUnitEntity);
+        const unitRepository = manager.getRepository(UnitEntityClass);
+        const baseUnit = await unitRepository
+            .findOneBy({ key: options.baseUnit })
+            .then((unit) => {
+            return unit
+                ? unit
+                : unitRepository.save(unitRepository.create({ key: options.baseUnit }));
+        });
+        options.baseUnit = baseUnit.id;
+        const material = materialRepository.create(options);
+        const { id } = await materialRepository.save(material);
+        if (options.units && options.units.length > 0) {
+            const units = materialUnitRepository.create(options.units.map((unit) => ({
+                ...unit,
+                materialId: id,
+            })));
+            await materialUnitRepository.save(units);
+        }
+        return material;
+    }
+    async updateMaterial({ manager = this.dataSource.manager, ...options }) {
+        const materialRepository = manager.getRepository(this.materialEntity);
+        const materialUnitRepository = manager.getRepository(this.materialUnitEntity);
+        const material = await materialRepository.findOneByOrFail({
+            id: options.id,
+        });
+        const updated = await materialRepository.save(materialRepository.create({
+            ...material,
+            ...options,
+        }));
+        if (options.units?.length) {
+            const newUnits = [];
+            const existingUnits = [];
+            await materialUnitRepository
+                .find({ where: { materialId: options.id } })
+                .then((units) => {
+                const unitSet = new Set(units.map((u) => u.unit));
+                options.units?.forEach((unit) => {
+                    if (unitSet.has(unit.unit))
+                        existingUnits.push(unit);
+                    else
+                        newUnits.push(unit);
+                });
+            });
+            if (newUnits.length)
+                await materialUnitRepository.save(materialUnitRepository.create(newUnits.map((unit) => ({ ...unit, materialId: options.id }))));
+            if (existingUnits.length)
+                await Promise.all(existingUnits.map((unit) => materialUnitRepository.update({ materialId: options.id, unit: unit.unit }, unit)));
+        }
+        return updated;
+    }
+    findMany(options) {
+        const queryBuilder = this.dataSource
+            .getRepository(this.materialEntity)
+            .createQueryBuilder('material');
+        if (options.materialId)
+            queryBuilder.andWhere('material.id = :materialId', {
+                materialId: options.materialId,
+            });
+        if (options.materialIds?.length)
+            queryBuilder.andWhere('material.id IN (:...materialIds)', {
+                materialIds: options.materialIds,
+            });
+        if (options.description)
+            queryBuilder.andWhere('material.description ILIKE :description', {
+                description: `%${options.description}%`,
+            });
+        if (options.wildcard) {
+            const { key, value } = options.wildcard;
+            queryBuilder.andWhere(`material."${String(key)}" ILIKE :value`, {
+                value: `%${value}%`,
+            });
+        }
+        if (options.offset !== undefined && options.offset >= 0)
+            queryBuilder.skip(options.offset);
+        if (options.limit !== undefined && options.limit > 0)
+            queryBuilder.take(options.limit);
+        return queryBuilder.getManyAndCount();
+    }
+};
+MaterialService = __decorate([
+    Injectable(),
+    __param(1, Inject(MaterialEntity)),
+    __param(2, Inject(MaterialUnitEntity)),
+    __metadata("design:paramtypes", [DataSource, Object, Object])
+], MaterialService);
+
+export { MaterialService };

package/lib/services/merge-batch-order.service.d.ts

@@ -0,0 +1,19 @@
+import { MergeBatchOrderEntityClass, MergeBatchOrderItemEntityClass } from '../models';
+import { DataSource, EntityTarget } from 'typeorm';
+import { MergeBatchInput } from '../typings/merge-batch.input';
+import { MaterialService } from './material.service';
+import { BatchService } from './batch.service';
+import { HelperService } from './helper.service';
+import { StockService } from './stock.service';
+export declare class MergeBatchOrderService<T extends MergeBatchOrderEntityClass = MergeBatchOrderEntityClass, K extends MergeBatchOrderItemEntityClass = MergeBatchOrderItemEntityClass> {
+    private readonly dataSource;
+    private readonly materialService;
+    private readonly batchService;
+    private readonly helperService;
+    private readonly stockService;
+    readonly mergeBatchOrderEntity: EntityTarget<T>;
+    readonly mergeBatchOrderItemEntity: EntityTarget<K>;
+    private readonly seqPrefix;
+    constructor(dataSource: DataSource, materialService: MaterialService, batchService: BatchService, helperService: HelperService, stockService: StockService, mergeBatchOrderEntity: EntityTarget<T>, mergeBatchOrderItemEntity: EntityTarget<K>);
+    merge(options: MergeBatchInput): Promise<T>;
+}

package/lib/services/merge-batch-order.service.js

@@ -0,0 +1,195 @@
+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 '../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 { MergeBatchOrderEntity } from '../models/extensions/merge-batch-order/merge-batch-order.entity.js';
+import { MergeBatchOrderItemEntity } from '../models/extensions/merge-batch-order/merge-batch-order-item.entity.js';
+import { MergeBatchOrderChangeEntityClass } from '../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 { DataSource, In } 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 MergeBatchOrderService = class MergeBatchOrderService {
+    dataSource;
+    materialService;
+    batchService;
+    helperService;
+    stockService;
+    mergeBatchOrderEntity;
+    mergeBatchOrderItemEntity;
+    seqPrefix = 'MBO';
+    constructor(dataSource, materialService, batchService, helperService, stockService, mergeBatchOrderEntity, mergeBatchOrderItemEntity) {
+        this.dataSource = dataSource;
+        this.materialService = materialService;
+        this.batchService = batchService;
+        this.helperService = helperService;
+        this.stockService = stockService;
+        this.mergeBatchOrderEntity = mergeBatchOrderEntity;
+        this.mergeBatchOrderItemEntity = mergeBatchOrderItemEntity;
+    }
+    merge(options) {
+        return this.dataSource.transaction(async (manager) => {
+            const mergeBatchOrderRepository = manager.getRepository(this.mergeBatchOrderEntity);
+            const mergeBatchOrderItemRepository = manager.getRepository(this.mergeBatchOrderItemEntity);
+            const mergeBatchOrderChangeRepository = manager.getRepository(MergeBatchOrderChangeEntityClass);
+            const orderRepository = manager.getRepository(OrderEntity);
+            const stockRepository = manager.getRepository(StockEntityClass);
+            const batchRepository = manager.getRepository(BatchEntityClass);
+            // Verify all source batches have identical metadata (except key and groupId)
+            const sourceBatches = await batchRepository.find({
+                where: { id: In(options.items.map((item) => item.batchId)) },
+            });
+            if (sourceBatches.length !== options.items.length) {
+                throw new Error('Some source batches were not found');
+            }
+            const metadataKeys = [
+                'saleId',
+                'saleSerialId',
+                'customerId',
+                'vendorId',
+                'inspectionResult',
+                'transferId',
+                'held',
+                'inShipment',
+            ];
+            const referenceBatch = sourceBatches[0];
+            for (const batch of sourceBatches) {
+                for (const field of metadataKeys) {
+                    if (batch[field] !== referenceBatch[field]) {
+                        throw new Error(`Batch metadata mismatch on field "${field}": batch ${batch.id} has ${batch[field]}, expected ${referenceBatch[field]}`);
+                    }
+                }
+            }
+            // Get target batch information (batch to merge into)
+            const targetBatch = await this.batchService.getBatch({
+                manager,
+                materialId: options.materialId,
+                key: options.batchKey,
+            });
+            // Split target batch to inherit the source batches' state
+            const mergedBatch = await this.batchService.splitBatch({
+                id: targetBatch.id,
+                manager,
+                saleId: referenceBatch.saleId,
+                saleSerialId: referenceBatch.saleSerialId,
+                customerId: referenceBatch.customerId,
+                vendorId: referenceBatch.vendorId,
+                inspectionResult: referenceBatch.inspectionResult,
+                transferId: referenceBatch.transferId,
+                held: referenceBatch.held,
+                inShipment: referenceBatch.inShipment,
+            });
+            const key = await this.helperService.getSeq(this.seqPrefix, manager);
+            const order = await mergeBatchOrderRepository.save(mergeBatchOrderRepository.create({
+                key,
+            }));
+            // Process each item to merge
+            await Promise.all(options.items.map(async (item) => {
+                // Get conversion factor for unit conversion
+                const conversionFactor = await this.materialService.getConversionFactor(targetBatch.materialId, item.unitId || undefined);
+                // Create base order record
+                const baseOrder = await orderRepository.save({});
+                // Create merge batch order item
+                const mergeItem = await mergeBatchOrderItemRepository.save(mergeBatchOrderItemRepository.create({
+                    targetMergedQuantity: item.quantity,
+                    orderId: order.id,
+                    locationId: this.stockService.resolveLocationId(item.locationId),
+                    loaderId: item.loaderId || null,
+                }));
+                // Record the change
+                await mergeBatchOrderChangeRepository.save(mergeBatchOrderChangeRepository.create({
+                    itemId: mergeItem.id,
+                    id: baseOrder.id,
+                    quantityChanged: item.quantity * conversionFactor,
+                }));
+                // Update stock: deduct from source batch and add to target batch
+                await this.stockService.validateStockAvailability({
+                    materialId: targetBatch.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 source batch
+                    {
+                        orderId: baseOrder.id,
+                        materialId: targetBatch.materialId,
+                        batchId: item.batchId,
+                        locationId: this.stockService.resolveLocationId(item.locationId),
+                        loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                        quantity: -1 * item.quantity * conversionFactor,
+                    },
+                    // Add to target batch
+                    {
+                        orderId: baseOrder.id,
+                        materialId: targetBatch.materialId,
+                        batchId: mergedBatch.id,
+                        locationId: this.stockService.resolveLocationId(item.locationId),
+                        loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                        quantity: item.quantity * conversionFactor,
+                    },
+                ]));
+            }));
+            return order;
+        });
+    }
+};
+MergeBatchOrderService = __decorate([
+    Injectable(),
+    __param(5, Inject(MergeBatchOrderEntity)),
+    __param(6, Inject(MergeBatchOrderItemEntity)),
+    __metadata("design:paramtypes", [DataSource,
+        MaterialService,
+        BatchService,
+        HelperService,
+        StockService, Object, Object])
+], MergeBatchOrderService);
+
+export { MergeBatchOrderService };

package/lib/services/quality-inspection-order.service.d.ts

@@ -0,0 +1,19 @@
+import { QualityInspectionOrderEntityClass, QualityInspectionOrderItemEntityClass } from '../models';
+import { DataSource, EntityManager, EntityTarget } from 'typeorm';
+import { CreateInspectionOrderInput } from '../typings/create-inspection-order.input';
+import { BatchService } from './batch.service';
+import { MaterialService } from './material.service';
+import { StockService } from './stock.service';
+export declare class QualityInspectionOrderService<T extends QualityInspectionOrderEntityClass = QualityInspectionOrderEntityClass, K extends QualityInspectionOrderItemEntityClass = QualityInspectionOrderItemEntityClass> {
+    private readonly dataSource;
+    readonly qualityInspectionOrderEntity: EntityTarget<T>;
+    readonly qualityInspectionOrderItemEntity: EntityTarget<K>;
+    private readonly batchService;
+    private readonly materialService;
+    private readonly stockService;
+    constructor(dataSource: DataSource, qualityInspectionOrderEntity: EntityTarget<T>, qualityInspectionOrderItemEntity: EntityTarget<K>, batchService: BatchService, materialService: MaterialService, stockService: StockService);
+    inspect({ manager, options, }: {
+        manager?: EntityManager;
+        options: CreateInspectionOrderInput;
+    }): Promise<T>;
+}