@rytass/wms-module-graphql 0.1.0

package/lib/inputs/receive-order.args.js

@@ -0,0 +1,40 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, Int, InputType } from '@nestjs/graphql';
+
+let ReceiveOrderArgs = class ReceiveOrderArgs {
+    itemId;
+    batchKey;
+    locationKey;
+    loaderKey;
+    quantity;
+    inspectionResult;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ReceiveOrderArgs.prototype, "itemId", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], ReceiveOrderArgs.prototype, "batchKey", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], ReceiveOrderArgs.prototype, "locationKey", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], ReceiveOrderArgs.prototype, "loaderKey", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], ReceiveOrderArgs.prototype, "quantity", void 0);
+__decorate([
+    Field(() => Boolean, { nullable: true }),
+    __metadata("design:type", Boolean)
+], ReceiveOrderArgs.prototype, "inspectionResult", void 0);
+ReceiveOrderArgs = __decorate([
+    InputType()
+], ReceiveOrderArgs);
+
+export { ReceiveOrderArgs };

package/lib/inputs/reclassify-inventory-order.args.d.ts

@@ -0,0 +1,9 @@
+export declare class ReclassifyInventoryOrderItemInput {
+    quantity: number;
+    unitId?: string;
+    aggregatedKey: string;
+}
+export declare class ReclassifyInventoryOrderArgs {
+    materialKey: string;
+    items: ReclassifyInventoryOrderItemInput[];
+}

package/lib/inputs/reclassify-inventory-order.args.js

@@ -0,0 +1,40 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, InputType, ArgsType } from '@nestjs/graphql';
+
+let ReclassifyInventoryOrderItemInput = class ReclassifyInventoryOrderItemInput {
+    quantity;
+    unitId;
+    aggregatedKey;
+};
+__decorate([
+    Field(() => Number),
+    __metadata("design:type", Number)
+], ReclassifyInventoryOrderItemInput.prototype, "quantity", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], ReclassifyInventoryOrderItemInput.prototype, "unitId", void 0);
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], ReclassifyInventoryOrderItemInput.prototype, "aggregatedKey", void 0);
+ReclassifyInventoryOrderItemInput = __decorate([
+    InputType()
+], ReclassifyInventoryOrderItemInput);
+let ReclassifyInventoryOrderArgs = class ReclassifyInventoryOrderArgs {
+    materialKey;
+    items;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], ReclassifyInventoryOrderArgs.prototype, "materialKey", void 0);
+__decorate([
+    Field(() => [ReclassifyInventoryOrderItemInput]),
+    __metadata("design:type", Array)
+], ReclassifyInventoryOrderArgs.prototype, "items", void 0);
+ReclassifyInventoryOrderArgs = __decorate([
+    ArgsType()
+], ReclassifyInventoryOrderArgs);
+
+export { ReclassifyInventoryOrderArgs, ReclassifyInventoryOrderItemInput };

package/lib/inputs/release-order.args.d.ts

@@ -0,0 +1,5 @@
+export declare class ReleaseOrderArgs {
+    aggregatedKey: string;
+    quantity: number;
+    unitId?: string;
+}

package/lib/inputs/release-order.args.js

@@ -0,0 +1,25 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, Int, InputType } from '@nestjs/graphql';
+
+let ReleaseOrderArgs = class ReleaseOrderArgs {
+    aggregatedKey;
+    quantity;
+    unitId;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], ReleaseOrderArgs.prototype, "aggregatedKey", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], ReleaseOrderArgs.prototype, "quantity", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], ReleaseOrderArgs.prototype, "unitId", void 0);
+ReleaseOrderArgs = __decorate([
+    InputType()
+], ReleaseOrderArgs);
+
+export { ReleaseOrderArgs };

package/lib/inputs/return-transfer-customer-order.args.d.ts

@@ -0,0 +1,7 @@
+export declare class ReturnTransferCustomerOrderArgs {
+    aggregatedKey: string;
+    quantity: number;
+    unitId?: string;
+    locationKey: string;
+    loaderKey?: string;
+}

package/lib/inputs/return-transfer-customer-order.args.js

@@ -0,0 +1,35 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, Int, InputType } from '@nestjs/graphql';
+
+let ReturnTransferCustomerOrderArgs = class ReturnTransferCustomerOrderArgs {
+    aggregatedKey;
+    quantity;
+    unitId;
+    locationKey;
+    loaderKey;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], ReturnTransferCustomerOrderArgs.prototype, "aggregatedKey", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], ReturnTransferCustomerOrderArgs.prototype, "quantity", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], ReturnTransferCustomerOrderArgs.prototype, "unitId", void 0);
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], ReturnTransferCustomerOrderArgs.prototype, "locationKey", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], ReturnTransferCustomerOrderArgs.prototype, "loaderKey", void 0);
+ReturnTransferCustomerOrderArgs = __decorate([
+    InputType()
+], ReturnTransferCustomerOrderArgs);
+
+export { ReturnTransferCustomerOrderArgs };

package/lib/inputs/return-transfer-vendor-order.args.d.ts

@@ -0,0 +1,7 @@
+export declare class ReturnTransferVendorOrderArgs {
+    aggregatedKey: string;
+    quantity: number;
+    unitId?: string;
+    locationKey: string;
+    loaderKey?: string;
+}

package/lib/inputs/return-transfer-vendor-order.args.js

@@ -0,0 +1,35 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, Int, InputType } from '@nestjs/graphql';
+
+let ReturnTransferVendorOrderArgs = class ReturnTransferVendorOrderArgs {
+    aggregatedKey;
+    quantity;
+    unitId;
+    locationKey;
+    loaderKey;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], ReturnTransferVendorOrderArgs.prototype, "aggregatedKey", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], ReturnTransferVendorOrderArgs.prototype, "quantity", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], ReturnTransferVendorOrderArgs.prototype, "unitId", void 0);
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], ReturnTransferVendorOrderArgs.prototype, "locationKey", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], ReturnTransferVendorOrderArgs.prototype, "loaderKey", void 0);
+ReturnTransferVendorOrderArgs = __decorate([
+    InputType()
+], ReturnTransferVendorOrderArgs);
+
+export { ReturnTransferVendorOrderArgs };

package/lib/inputs/scrape-order.args.d.ts

@@ -0,0 +1,8 @@
+export declare class ScrapeOrderItemInput {
+    aggregateKey: string;
+    unitId?: string;
+    quantity: number;
+}
+export declare class ScrapeOrderArgs {
+    items: ScrapeOrderItemInput[];
+}

package/lib/inputs/scrape-order.args.js

@@ -0,0 +1,35 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, Int, InputType, ArgsType } from '@nestjs/graphql';
+
+let ScrapeOrderItemInput = class ScrapeOrderItemInput {
+    aggregateKey;
+    unitId;
+    quantity;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ScrapeOrderItemInput.prototype, "aggregateKey", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], ScrapeOrderItemInput.prototype, "unitId", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], ScrapeOrderItemInput.prototype, "quantity", void 0);
+ScrapeOrderItemInput = __decorate([
+    InputType()
+], ScrapeOrderItemInput);
+let ScrapeOrderArgs = class ScrapeOrderArgs {
+    items;
+};
+__decorate([
+    Field(() => [ScrapeOrderItemInput]),
+    __metadata("design:type", Array)
+], ScrapeOrderArgs.prototype, "items", void 0);
+ScrapeOrderArgs = __decorate([
+    ArgsType()
+], ScrapeOrderArgs);
+
+export { ScrapeOrderArgs, ScrapeOrderItemInput };

package/lib/inputs/ship-order.args.d.ts

@@ -0,0 +1,4 @@
+export declare class ShipOrderArgs {
+    itemId: string;
+    quantity: number;
+}

package/lib/inputs/ship-order.args.js

@@ -0,0 +1,20 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, Int, InputType } from '@nestjs/graphql';
+
+let ShipOrderArgs = class ShipOrderArgs {
+    itemId;
+    quantity;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], ShipOrderArgs.prototype, "itemId", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], ShipOrderArgs.prototype, "quantity", void 0);
+ShipOrderArgs = __decorate([
+    InputType()
+], ShipOrderArgs);
+
+export { ShipOrderArgs };

package/lib/inputs/split-batch.args.d.ts

@@ -0,0 +1,9 @@
+export declare class SplitBatchItemInput {
+    batchKey: string;
+    quantity: number;
+}
+export declare class SplitBatchArgs {
+    aggregatedKey: string;
+    unitId?: string;
+    items: SplitBatchItemInput[];
+}

package/lib/inputs/split-batch.args.js

@@ -0,0 +1,40 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, InputType, ArgsType } from '@nestjs/graphql';
+
+let SplitBatchItemInput = class SplitBatchItemInput {
+    batchKey;
+    quantity;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], SplitBatchItemInput.prototype, "batchKey", void 0);
+__decorate([
+    Field(() => Number),
+    __metadata("design:type", Number)
+], SplitBatchItemInput.prototype, "quantity", void 0);
+SplitBatchItemInput = __decorate([
+    InputType()
+], SplitBatchItemInput);
+let SplitBatchArgs = class SplitBatchArgs {
+    aggregatedKey;
+    unitId;
+    items;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], SplitBatchArgs.prototype, "aggregatedKey", void 0);
+__decorate([
+    Field(() => ID, { nullable: true }),
+    __metadata("design:type", String)
+], SplitBatchArgs.prototype, "unitId", void 0);
+__decorate([
+    Field(() => [SplitBatchItemInput]),
+    __metadata("design:type", Array)
+], SplitBatchArgs.prototype, "items", void 0);
+SplitBatchArgs = __decorate([
+    ArgsType()
+], SplitBatchArgs);
+
+export { SplitBatchArgs, SplitBatchItemInput };

package/lib/inputs/transfer-order.args.d.ts

@@ -0,0 +1,4 @@
+export declare class TransferOrderArgs {
+    itemId: string;
+    quantity: number;
+}

package/lib/inputs/transfer-order.args.js

@@ -0,0 +1,20 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, Int, InputType } from '@nestjs/graphql';
+
+let TransferOrderArgs = class TransferOrderArgs {
+    itemId;
+    quantity;
+};
+__decorate([
+    Field(() => ID, { description: 'The ID of transfer order item' }),
+    __metadata("design:type", String)
+], TransferOrderArgs.prototype, "itemId", void 0);
+__decorate([
+    Field(() => Int, { description: 'The quantity to transfer' }),
+    __metadata("design:type", Number)
+], TransferOrderArgs.prototype, "quantity", void 0);
+TransferOrderArgs = __decorate([
+    InputType()
+], TransferOrderArgs);
+
+export { TransferOrderArgs };

package/lib/inputs/update-warehouse-map.args.d.ts

@@ -0,0 +1,28 @@
+import { MapRangeType } from '../dto/warehouse-map.dto';
+export declare class MapBackgroundInput {
+    id: string;
+    filename: string;
+    x: number;
+    y: number;
+    height: number;
+    width: number;
+}
+export declare class MapPolygonRangePointInput {
+    x: number;
+    y: number;
+}
+export declare class MapRangeInput {
+    id: string;
+    type: MapRangeType;
+    color: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    points?: MapPolygonRangePointInput[];
+}
+export declare class UpdateWarehouseMapArgs {
+    locationKey: string;
+    backgrounds: MapBackgroundInput[];
+    ranges: MapRangeInput[];
+}

package/lib/inputs/update-warehouse-map.args.js

@@ -0,0 +1,121 @@
+import { __decorate, __metadata } from 'tslib';
+import { Field, ID, Float, InputType, ArgsType } from '@nestjs/graphql';
+import { MapRangeType } from '../dto/warehouse-map.dto.js';
+
+let MapBackgroundInput = class MapBackgroundInput {
+    id;
+    filename;
+    x;
+    y;
+    height;
+    width;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], MapBackgroundInput.prototype, "id", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], MapBackgroundInput.prototype, "filename", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MapBackgroundInput.prototype, "x", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MapBackgroundInput.prototype, "y", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MapBackgroundInput.prototype, "height", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MapBackgroundInput.prototype, "width", void 0);
+MapBackgroundInput = __decorate([
+    InputType()
+], MapBackgroundInput);
+let MapPolygonRangePointInput = class MapPolygonRangePointInput {
+    x;
+    y;
+};
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MapPolygonRangePointInput.prototype, "x", void 0);
+__decorate([
+    Field(() => Float),
+    __metadata("design:type", Number)
+], MapPolygonRangePointInput.prototype, "y", void 0);
+MapPolygonRangePointInput = __decorate([
+    InputType()
+], MapPolygonRangePointInput);
+let MapRangeInput = class MapRangeInput {
+    id;
+    type;
+    color;
+    x;
+    y;
+    width;
+    height;
+    points;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], MapRangeInput.prototype, "id", void 0);
+__decorate([
+    Field(() => MapRangeType),
+    __metadata("design:type", String)
+], MapRangeInput.prototype, "type", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], MapRangeInput.prototype, "color", void 0);
+__decorate([
+    Field(() => Float, { nullable: true }),
+    __metadata("design:type", Number)
+], MapRangeInput.prototype, "x", void 0);
+__decorate([
+    Field(() => Float, { nullable: true }),
+    __metadata("design:type", Number)
+], MapRangeInput.prototype, "y", void 0);
+__decorate([
+    Field(() => Float, { nullable: true }),
+    __metadata("design:type", Number)
+], MapRangeInput.prototype, "width", void 0);
+__decorate([
+    Field(() => Float, { nullable: true }),
+    __metadata("design:type", Number)
+], MapRangeInput.prototype, "height", void 0);
+__decorate([
+    Field(() => [MapPolygonRangePointInput], { nullable: true }),
+    __metadata("design:type", Array)
+], MapRangeInput.prototype, "points", void 0);
+MapRangeInput = __decorate([
+    InputType()
+], MapRangeInput);
+let UpdateWarehouseMapArgs = class UpdateWarehouseMapArgs {
+    locationKey;
+    backgrounds;
+    ranges;
+};
+__decorate([
+    Field(() => ID),
+    __metadata("design:type", String)
+], UpdateWarehouseMapArgs.prototype, "locationKey", void 0);
+__decorate([
+    Field(() => [MapBackgroundInput]),
+    __metadata("design:type", Array)
+], UpdateWarehouseMapArgs.prototype, "backgrounds", void 0);
+__decorate([
+    Field(() => [MapRangeInput]),
+    __metadata("design:type", Array)
+], UpdateWarehouseMapArgs.prototype, "ranges", void 0);
+UpdateWarehouseMapArgs = __decorate([
+    ArgsType()
+], UpdateWarehouseMapArgs);
+
+export { MapBackgroundInput, MapPolygonRangePointInput, MapRangeInput, UpdateWarehouseMapArgs };

package/lib/mutations/allocate-inventory-order.mutation.d.ts

@@ -0,0 +1,12 @@
+import { AllocateInventoryOrderService, StockService } from '@rytass/wms-module-core';
+import { AllocateInventoryOrderDto } from '../dto/allocate-inventory-order.dto';
+import { CreateAllocateInventoryOrderArgs, UpdateAllocateInventoryOrderArgs } from '../inputs/create-allocate-inventory-order.args';
+import { DeallocateOrderArgs } from '../inputs/deallocate-order.args';
+export declare class AllocateInventoryOrderMutation {
+    private readonly allocateInventoryOrderService;
+    private readonly stockService;
+    constructor(allocateInventoryOrderService: AllocateInventoryOrderService, stockService: StockService);
+    createAllocateInventoryOrder(args: CreateAllocateInventoryOrderArgs): Promise<AllocateInventoryOrderDto>;
+    updateAllocateInventoryOrder(args: UpdateAllocateInventoryOrderArgs): Promise<AllocateInventoryOrderDto>;
+    deallocate(args: DeallocateOrderArgs[]): Promise<boolean>;
+}

package/lib/mutations/allocate-inventory-order.mutation.js

@@ -0,0 +1,81 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { Mutation, Args } from '@nestjs/graphql';
+import { AllocateInventoryOrderService, StockService } from '@rytass/wms-module-core';
+import { AllocateInventoryOrderDto } from '../dto/allocate-inventory-order.dto.js';
+import { CreateAllocateInventoryOrderArgs, UpdateAllocateInventoryOrderArgs } from '../inputs/create-allocate-inventory-order.args.js';
+import { DeallocateOrderArgs } from '../inputs/deallocate-order.args.js';
+
+let AllocateInventoryOrderMutation = class AllocateInventoryOrderMutation {
+    allocateInventoryOrderService;
+    stockService;
+    constructor(allocateInventoryOrderService, stockService) {
+        this.allocateInventoryOrderService = allocateInventoryOrderService;
+        this.stockService = stockService;
+    }
+    async createAllocateInventoryOrder(args) {
+        return this.allocateInventoryOrderService.createAllocateInventoryOrder({
+            ...args,
+            items: args.items.map(({ aggregatedKey, ...item }) => {
+                const keys = this.stockService.destructAggregateKey(aggregatedKey);
+                return {
+                    ...item,
+                    ...keys,
+                };
+            }),
+        });
+    }
+    async updateAllocateInventoryOrder(args) {
+        return this.allocateInventoryOrderService.updateAllocateInventoryOrder({
+            ...args,
+            items: args?.items?.map(({ aggregatedKey, ...item }) => {
+                const keys = aggregatedKey
+                    ? this.stockService.destructAggregateKey(aggregatedKey)
+                    : {};
+                return {
+                    ...item,
+                    ...keys,
+                };
+            }),
+        });
+    }
+    async deallocate(args) {
+        return this.allocateInventoryOrderService
+            .deallocate(args.map(({ aggregatedKey, ...item }) => {
+            const keys = this.stockService.destructAggregateKey(aggregatedKey);
+            return {
+                ...item,
+                ...keys,
+            };
+        }))
+            .then(() => true);
+    }
+};
+__decorate([
+    Mutation(() => AllocateInventoryOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CreateAllocateInventoryOrderArgs]),
+    __metadata("design:returntype", Promise)
+], AllocateInventoryOrderMutation.prototype, "createAllocateInventoryOrder", null);
+__decorate([
+    Mutation(() => AllocateInventoryOrderDto),
+    __param(0, Args()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [UpdateAllocateInventoryOrderArgs]),
+    __metadata("design:returntype", Promise)
+], AllocateInventoryOrderMutation.prototype, "updateAllocateInventoryOrder", null);
+__decorate([
+    Mutation(() => Boolean),
+    __param(0, Args('items', { type: () => [DeallocateOrderArgs] })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], AllocateInventoryOrderMutation.prototype, "deallocate", null);
+AllocateInventoryOrderMutation = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [AllocateInventoryOrderService,
+        StockService])
+], AllocateInventoryOrderMutation);
+
+export { AllocateInventoryOrderMutation };

package/lib/mutations/hold-inventory-order.mutation.d.ts

@@ -0,0 +1,12 @@
+import { HoldInventoryOrderService, StockService } from '@rytass/wms-module-core';
+import { HoldInventoryOrderDto } from '../dto/hold-inventory-order.dto';
+import { CreateHoldInventoryOrderArgs, UpdateHoldInventoryOrderArgs } from '../inputs/create-hold-inventory-order.args';
+import { ReleaseOrderArgs } from '../inputs/release-order.args';
+export declare class HoldInventoryOrderMutation {
+    private readonly holdInventoryOrderService;
+    private readonly stockService;
+    constructor(holdInventoryOrderService: HoldInventoryOrderService, stockService: StockService);
+    createHoldInventoryOrder(args: CreateHoldInventoryOrderArgs): Promise<HoldInventoryOrderDto>;
+    updateHoldInventoryOrder(args: UpdateHoldInventoryOrderArgs): Promise<HoldInventoryOrderDto>;
+    release(args: ReleaseOrderArgs[]): Promise<boolean>;
+}