@rytass/wms-module-core 0.1.0

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

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

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

@@ -0,0 +1,7 @@
+import { DataSource, Repository } from 'typeorm';
+import { UnitEntityClass } from '../models';
+export declare class UnitService {
+    private readonly dataSource;
+    readonly unitRepository: Repository<UnitEntityClass>;
+    constructor(dataSource: DataSource);
+}

package/lib/services/unit.service.js

@@ -0,0 +1,67 @@
+import { __decorate, __metadata } from 'tslib';
+import { Injectable } 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 '../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 { 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';
+
+let UnitService = class UnitService {
+    dataSource;
+    unitRepository;
+    constructor(dataSource) {
+        this.dataSource = dataSource;
+        this.unitRepository =
+            this.dataSource.getRepository(UnitEntityClass);
+    }
+};
+UnitService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DataSource])
+], UnitService);
+
+export { UnitService };

package/lib/services/warehouse-map.service.d.ts

@@ -0,0 +1,10 @@
+import { OnApplicationBootstrap } from '@nestjs/common';
+import { DataSource, Repository } from 'typeorm';
+import { WarehouseMapEntity } from '@rytass/wms-base-nestjs-module/models/warehouse-map.entity';
+export declare class WarehouseMapDataService implements OnApplicationBootstrap {
+    private readonly dataSource;
+    readonly defaultMapDataKey = "DEFAULT_MAP_DATA_KEY";
+    readonly warehouseMapDataRepository: Repository<WarehouseMapEntity>;
+    constructor(dataSource: DataSource);
+    onApplicationBootstrap(): void;
+}

package/lib/services/warehouse-map.service.js

@@ -0,0 +1,38 @@
+import { __decorate, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import { WarehouseMapEntity } from '@rytass/wms-base-nestjs-module/models/warehouse-map.entity';
+
+let WarehouseMapDataService = class WarehouseMapDataService {
+    dataSource;
+    defaultMapDataKey = 'DEFAULT_MAP_DATA_KEY';
+    warehouseMapDataRepository;
+    constructor(dataSource) {
+        this.dataSource = dataSource;
+        this.warehouseMapDataRepository =
+            this.dataSource.getRepository(WarehouseMapEntity);
+    }
+    onApplicationBootstrap() {
+        this.dataSource.transaction(async (manager) => {
+            const defaultMapData = await manager
+                .getRepository(WarehouseMapEntity)
+                .findOneBy({ id: this.defaultMapDataKey });
+            if (!defaultMapData) {
+                await manager.getRepository(WarehouseMapEntity).save(manager.getRepository(WarehouseMapEntity).create({
+                    id: this.defaultMapDataKey,
+                    mapData: {
+                        id: this.defaultMapDataKey,
+                        backgrounds: [],
+                        ranges: [],
+                    },
+                }));
+            }
+        });
+    }
+};
+WarehouseMapDataService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DataSource])
+], WarehouseMapDataService);
+
+export { WarehouseMapDataService };

package/lib/typings/aggregated-stock.d.ts

@@ -0,0 +1,22 @@
+import { type StockEntityClass } from '../models';
+import { ChangeType } from '../constants/stock-status';
+export type AggregatedStock = Pick<StockEntityClass, 'materialId' | 'batchId' | 'locationId' | 'loaderId' | 'status' | 'quantity'> & {
+    transferId?: string | null;
+    held?: boolean;
+    inShipment?: boolean;
+    saleId?: string | null;
+    saleSerialId?: string | null;
+    customerId?: string | null;
+    vendorId?: string | null;
+    inspectionResult?: boolean;
+};
+export interface ValidateStockDeductionParams {
+    materialId: string;
+    batchId: string;
+    locationId?: string;
+    loaderId: string;
+    quantity: number;
+}
+export type ChangeLog = Pick<StockEntityClass, 'id' | 'materialId' | 'batchId' | 'locationId' | 'loaderId' | 'quantity'> & {
+    changeType: ChangeType;
+};

package/lib/typings/cancel-ship-inventory-order.input.d.ts

@@ -0,0 +1,4 @@
+export type CancelShipInventoryOrderInput = {
+    itemId: string;
+    quantity?: number;
+};

package/lib/typings/cancel-transfer-order.input.d.ts

@@ -0,0 +1,4 @@
+export type CancelTransferOrderInput = {
+    itemId: string;
+    quantity?: number;
+};

package/lib/typings/core-module-options.d.ts

@@ -0,0 +1,8 @@
+import type { WMSBaseModuleAsyncOptions } from '@rytass/wms-base-nestjs-module';
+export declare const WMS_CORE_MODULE_OPTIONS: unique symbol;
+export interface WmsModuleCoreModuleOptions {
+    defaultLoaderSerialId: string;
+    defaultLoaderTypeKey: string;
+    defaultLocationKey: string;
+}
+export type WmsModuleCoreModuleAsyncOptions = WMSBaseModuleAsyncOptions & WmsModuleCoreModuleOptions;

package/lib/typings/core-module-options.js

@@ -0,0 +1,3 @@
+const WMS_CORE_MODULE_OPTIONS = Symbol('WMS_CORE_MODULE_OPTIONS');
+
+export { WMS_CORE_MODULE_OPTIONS };

package/lib/typings/create-allocate-inventory-order.input.d.ts

@@ -0,0 +1,25 @@
+import { StockStatus } from '../constants';
+export type CreateAllocateInventoryOrderItemInput = {
+    materialId: string;
+    batchId: string;
+    locationId?: string;
+    loaderId?: string;
+    unitId?: string;
+    status?: StockStatus;
+    targetAllocatedQuantity: number;
+    saleId?: string;
+    saleSerialId?: string;
+};
+export type CreateAllocateInventoryOrderInput = {
+    createdBy?: string;
+    items: CreateAllocateInventoryOrderItemInput[];
+};
+export type UpdateAllocateInventoryOrderItemInput = Partial<CreateAllocateInventoryOrderItemInput> & {
+    id?: string;
+    removedAt?: Date;
+};
+export type UpdateAllocateInventoryOrderInput = Partial<Omit<CreateAllocateInventoryOrderInput, 'items'>> & {
+    id: string;
+    removedAt?: Date;
+    items?: UpdateAllocateInventoryOrderItemInput[];
+};

package/lib/typings/create-hold-inventory-order.input.d.ts

@@ -0,0 +1,21 @@
+export type CreateHoldInventoryOrderItemInput = {
+    materialId: string;
+    batchId: string;
+    locationId?: string;
+    loaderId?: string;
+    unitId?: string;
+    targetHeldQuantity: number;
+};
+export type CreateHoldInventoryOrderInput = {
+    createdBy?: string;
+    items: CreateHoldInventoryOrderItemInput[];
+};
+export type UpdateHoldInventoryOrderItemInput = Partial<CreateHoldInventoryOrderItemInput> & {
+    id?: string;
+    removedAt?: Date;
+};
+export type UpdateHoldInventoryOrderInput = Partial<Omit<CreateHoldInventoryOrderInput, 'items'>> & {
+    id: string;
+    removedAt?: Date;
+    items?: UpdateHoldInventoryOrderItemInput[];
+};

package/lib/typings/create-inspection-order.input.d.ts

@@ -0,0 +1,14 @@
+export type CreateInspectionOrderInput = {
+    key: string;
+    note?: string;
+    items: CreateInspectionOrderItemInput[];
+};
+export type CreateInspectionOrderItemInput = {
+    materialId: string;
+    batchId: string;
+    locationId?: string;
+    loaderId?: string;
+    unitId?: string;
+    quantity: number;
+    inspectionResult: boolean;
+};

package/lib/typings/create-loader-type.input.d.ts

@@ -0,0 +1,9 @@
+import { EntityManager } from 'typeorm';
+export type CreateLoaderTypeInput = {
+    description: string;
+    key: string;
+    manager?: EntityManager;
+};
+export type UpdateLoaderTypeInput = Partial<Omit<CreateLoaderTypeInput, 'key'>> & {
+    id: string;
+};

package/lib/typings/create-loader.input.d.ts

@@ -0,0 +1,15 @@
+export type CreateLoaderInput = {
+    typeId: string;
+    locationId: string;
+    quantity: number;
+    length?: number | null;
+    width?: number | null;
+    height?: number | null;
+    sizeUnit?: string | null;
+    volume?: number | null;
+    volumeUnit?: string | null;
+    note?: string | null;
+};
+export type UpdateLoaderInput = Partial<Omit<CreateLoaderInput, 'locationId' | 'typeId'>> & {
+    id: string;
+};

package/lib/typings/create-location.input.d.ts

@@ -0,0 +1,12 @@
+export type CreateLocationInput = {
+    key: string;
+    description: string;
+    parentId?: string;
+    isActive?: boolean;
+};
+export type UpdateLocationInput = {
+    id: string;
+    description?: string | null;
+    isActive?: boolean | null;
+    parentId?: string | null;
+};

package/lib/typings/create-material-unit.input.d.ts

@@ -0,0 +1,5 @@
+export type CreateMaterialUnitInput = {
+    unit: string;
+    conversionFactor: number;
+    isActive?: boolean;
+};

package/lib/typings/create-material.input.d.ts

@@ -0,0 +1,11 @@
+import { CreateMaterialUnitInput } from './create-material-unit.input';
+export type CreateMaterialInput = {
+    key: string;
+    description: string;
+    baseUnit: string;
+    units: Array<CreateMaterialUnitInput>;
+    isActive?: boolean;
+};
+export type UpdateMaterialInput = Partial<Omit<CreateMaterialInput, 'baseUnit'>> & {
+    id: string;
+};

package/lib/typings/create-receive-inventory-order.input.d.ts

@@ -0,0 +1,26 @@
+export type CreateReceiveInventoryOrderItemInput = {
+    description?: string;
+    unitId?: string;
+    serialId: string;
+    loaderKey?: string;
+    locationKey?: string;
+    batchKey: string;
+    materialKey: string;
+    targetReceivedQuantity: number;
+    requireInspection?: boolean;
+};
+export type CreateReceiveInventoryOrderInput = {
+    key: string;
+    description: string;
+    items: CreateReceiveInventoryOrderItemInput[];
+};
+export type UpdateReceiveInventoryOrderItemInput = Partial<CreateReceiveInventoryOrderItemInput> & {
+    id?: string;
+    removedAt?: Date;
+};
+export type UpdateReceiveInventoryOrderInput = Partial<Omit<CreateReceiveInventoryOrderInput, 'items'>> & {
+    id: string;
+    createdBy?: string;
+    items?: UpdateReceiveInventoryOrderItemInput[];
+    removedAt?: Date;
+};

package/lib/typings/create-ship-inventory-order.input.d.ts

@@ -0,0 +1,46 @@
+import { StockStatus } from '../constants';
+export type CreateShipInventoryOrderReferenceInput = {
+    description?: string | null;
+    unitId?: string | null;
+    batchKey?: string | null;
+    materialKey: string;
+    targetShippedQuantity: number;
+    serialId: string;
+    saleId?: string | null;
+    saleSerialId?: string | null;
+};
+export type CreateShipInventoryOrderInput = {
+    key: string;
+    description: string;
+    references: CreateShipInventoryOrderReferenceInput[];
+};
+export type UpdateShipInventoryOrderReferenceInput = Partial<CreateShipInventoryOrderReferenceInput> & {
+    id?: string;
+    removedAt?: Date;
+};
+export type UpdateShipInventoryOrderInput = Partial<Omit<CreateShipInventoryOrderInput, 'references'>> & {
+    id: string;
+    createdBy?: string;
+    references?: UpdateShipInventoryOrderReferenceInput[];
+    items?: UpdateShipInventoryOrderItemInput[];
+    removedAt?: Date;
+};
+export type CreateShipInventoryOrderItemInput = {
+    materialId: string;
+    batchId: string;
+    locationId?: string;
+    loaderId?: string;
+    unitId?: string;
+    targetShippedQuantity: number;
+    status: StockStatus;
+    serialId: string;
+    orderId: string;
+};
+export type UpdateShipInventoryOrderItemInput = Partial<CreateShipInventoryOrderItemInput> & {
+    id?: string;
+    removedAt?: Date;
+};
+export type CreateShipInventoryOrderItemsInput = {
+    orderId: string;
+    items: CreateShipInventoryOrderItemInput[];
+};