@floristcloud/api-lib 1.0.54 → 1.0.55

package/build/commands/pre-order/get-pre-order-list.query.js

@@ -8,6 +8,7 @@ const GetPreOrderListRequestSchema = zod_1.z.object({
     page: zod_1.z.string().transform(val => Number(val) || 1),
     count: zod_1.z.coerce.number().optional().default(10),
     searchQuery: zod_1.z.string().optional(),
+    clientUUID: zod_1.z.string().optional(),
     preOrderCollectionUUID: zod_1.z.string().optional(),
     status: zod_1.z.nativeEnum(enum_1.PreOrderStatusEnum).array().optional(),
     createdAtFrom: zod_1.z.coerce.date().optional(),

package/build/commands/pre-order/group/index.js

@@ -23,3 +23,4 @@ __exportStar(require("./analyze-create-orders-from-pre-orders.command"), exports
 __exportStar(require("./group-create-orders-from-pre-orders.command"), exports);
 __exportStar(require("./analyze-copy-pre-orders.command"), exports);
 __exportStar(require("./group-copy-pre-orders-to-collection.command"), exports);
+__exportStar(require("./merge-pre-orders.command"), exports);

package/build/commands/pre-order/group/merge-pre-orders.command.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergePreOrdersContractCommand = exports.MergePreOrdersGroupAnalysisResponseSchema = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../schemas");
+const MergePreOrdersRequestSchema = zod_1.z.object({
+    preOrderUUIDList: zod_1.z.array(zod_1.z.string().uuid()).min(2),
+});
+exports.MergePreOrdersGroupAnalysisResponseSchema = zod_1.z.object({
+    clientUUID: zod_1.z.string(),
+    branchUUID: zod_1.z.string().nullable(),
+    isPossible: zod_1.z.boolean(),
+    targetPreOrderUUID: zod_1.z.string().nullable(),
+    sourcePreOrdersUUIDs: zod_1.z.array(zod_1.z.string()),
+    errors: zod_1.z.array(schemas_1.ErrorMessageSchema),
+    warnings: zod_1.z.array(schemas_1.ErrorMessageSchema),
+    mergeInfo: zod_1.z
+        .object({
+        willMergeTags: zod_1.z.boolean(),
+        willMergeComments: zod_1.z.boolean(),
+        totalProducts: zod_1.z.number(),
+    })
+        .optional(),
+});
+const MergePreOrdersResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.array(exports.MergePreOrdersGroupAnalysisResponseSchema),
+});
+var MergePreOrdersContractCommand;
+(function (MergePreOrdersContractCommand) {
+    MergePreOrdersContractCommand.RequestSchema = MergePreOrdersRequestSchema;
+    MergePreOrdersContractCommand.ResponseSchema = MergePreOrdersResponseSchema;
+})(MergePreOrdersContractCommand || (exports.MergePreOrdersContractCommand = MergePreOrdersContractCommand = {}));

package/build/commands/pre-order-product/group/move-group-pre-order-product.command.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveGroupPreOrderProductContractCommand = void 0;
+const zod_1 = require("zod");
+const MoveGroupPreOrderProductRequestSchema = zod_1.z.object({
+    preOrderProductUUIDList: zod_1.z.array(zod_1.z.string().uuid()).min(1),
+    newPreOrderUUID: zod_1.z.string().uuid(),
+    isDelete: zod_1.z.coerce.boolean().optional().default(true),
+});
+const MoveGroupPreOrderProductResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        success: zod_1.z.boolean(),
+    }),
+});
+var MoveGroupPreOrderProductContractCommand;
+(function (MoveGroupPreOrderProductContractCommand) {
+    MoveGroupPreOrderProductContractCommand.RequestSchema = MoveGroupPreOrderProductRequestSchema;
+    MoveGroupPreOrderProductContractCommand.ResponseSchema = MoveGroupPreOrderProductResponseSchema;
+})(MoveGroupPreOrderProductContractCommand || (exports.MoveGroupPreOrderProductContractCommand = MoveGroupPreOrderProductContractCommand = {}));

package/build/commands/pre-order-product/index.js

@@ -29,3 +29,4 @@ __exportStar(require("./get-pre-order-product-list.query"), exports);
 __exportStar(require("./get-pre-order-product-extended-list.query"), exports);
 __exportStar(require("./create-manually-pre-order-product-for-standing-order.command"), exports);
 __exportStar(require("./get-pre-order-products-by-pre-order-list.command"), exports);
+__exportStar(require("./group/move-group-pre-order-product.command"), exports);

package/build/constant/error.js

@@ -588,6 +588,17 @@ exports.ERRORS = {
         message: 'Failed to copy pre order',
         httpCode: 500,
     },
+    PRE_ORDER_MERGE_FAILED: { code: 'PO013', message: 'Pre-order merge failed', httpCode: 500 },
+    PRE_ORDER_MERGE_ANALYSIS_FAILED: { code: 'PO014', message: 'Pre-order merge analysis failed', httpCode: 500 },
+    PRE_ORDER_MERGE_NO_VALID_GROUPS: { code: 'PO015', message: 'No valid groups found for merge', httpCode: 400 },
+    PRE_ORDER_MERGE_NO_COLLECTION: { code: 'PO016', message: 'All pre-orders must belong to a collection for merge', httpCode: 400 },
+    PRE_ORDER_MERGE_NOT_ENOUGH: { code: 'PO017', message: 'At least 2 pre-orders required for merge', httpCode: 400 },
+    PRE_ORDER_MERGE_STATUS_NOT_ALLOWED: { code: 'PO018', message: 'Pre-order status not allowed for merge', httpCode: 400 },
+    PRE_ORDER_MERGE_DIFFERENT_STATUSES: { code: 'PO019', message: 'Pre-orders have different statuses', httpCode: 400 },
+    PRE_ORDER_MERGE_DIFFERENT_COLLECTIONS: { code: 'PO020', message: 'All pre-orders must belong to the same collection', httpCode: 400 },
+    PRE_ORDER_MERGE_HAS_EMPTY: { code: 'PO021', message: 'Some pre-orders are empty and will be deleted', httpCode: 400 },
+    PRE_ORDER_MERGE_TAGS_CONCATENATE: { code: 'PO022', message: 'Pre-orders have different tags', httpCode: 400 },
+    PRE_ORDER_MERGE_COMMENTS_CONCATENATE: { code: 'PO023', message: 'Pre-orders have different comments', httpCode: 400 },
     STANDING_ORDER_CLIENT_NAME_REQUIRED: {
         code: 'SO001',
         message: 'Standing order client name is required',

package/build/schemas/pre-order-product/pre-order-product.schema.js

@@ -11,6 +11,7 @@ exports.MatchingConfigSchema = zod_1.z.object({
     matchByColor: zod_1.z.coerce.boolean(),
     matchBySize: zod_1.z.coerce.boolean(),
     matchByGrower: zod_1.z.coerce.boolean(),
+    usePreOrderMultiplicity: zod_1.z.coerce.boolean().optional(),
 });
 exports.PreOrderProductSchema = zod_1.z.object({
     uuid: zod_1.z.string(),

package/commands/pre-order/get-pre-order-list.query.ts

@@ -6,6 +6,7 @@ const GetPreOrderListRequestSchema = z.object({
     page: z.string().transform(val => Number(val) || 1),
     count: z.coerce.number().optional().default(10),
     searchQuery: z.string().optional(),
+    clientUUID: z.string().optional(),
     preOrderCollectionUUID: z.string().optional(),
     status: z.nativeEnum(PreOrderStatusEnum).array().optional(),
     createdAtFrom: z.coerce.date().optional(),

package/commands/pre-order/group/index.ts

@@ -7,3 +7,4 @@ export * from './analyze-create-orders-from-pre-orders.command';
 export * from './group-create-orders-from-pre-orders.command';
 export * from './analyze-copy-pre-orders.command';
 export * from './group-copy-pre-orders-to-collection.command';
+export * from './merge-pre-orders.command';

package/commands/pre-order/group/merge-pre-orders.command.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { ErrorMessageSchema } from '../../../schemas';
+
+const MergePreOrdersRequestSchema = z.object({
+    preOrderUUIDList: z.array(z.string().uuid()).min(2),
+});
+
+export const MergePreOrdersGroupAnalysisResponseSchema = z.object({
+    clientUUID: z.string(),
+    branchUUID: z.string().nullable(),
+    isPossible: z.boolean(),
+    targetPreOrderUUID: z.string().nullable(),
+    sourcePreOrdersUUIDs: z.array(z.string()),
+    errors: z.array(ErrorMessageSchema),
+    warnings: z.array(ErrorMessageSchema),
+    mergeInfo: z
+        .object({
+            willMergeTags: z.boolean(),
+            willMergeComments: z.boolean(),
+            totalProducts: z.number(),
+        })
+        .optional(),
+});
+
+const MergePreOrdersResponseSchema = z.object({
+    message: z.string().optional(),
+    data: z.array(MergePreOrdersGroupAnalysisResponseSchema),
+});
+
+export namespace MergePreOrdersContractCommand {
+    export const RequestSchema = MergePreOrdersRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = MergePreOrdersResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/pre-order-product/group/move-group-pre-order-product.command.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+
+const MoveGroupPreOrderProductRequestSchema = z.object({
+    preOrderProductUUIDList: z.array(z.string().uuid()).min(1),
+    newPreOrderUUID: z.string().uuid(),
+    isDelete: z.coerce.boolean().optional().default(true),
+});
+
+const MoveGroupPreOrderProductResponseSchema = z.object({
+    message: z.string().optional(),
+    data: z.object({
+        success: z.boolean(),
+    }),
+});
+
+export namespace MoveGroupPreOrderProductContractCommand {
+    export const RequestSchema = MoveGroupPreOrderProductRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = MoveGroupPreOrderProductResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/pre-order-product/index.ts

@@ -13,3 +13,4 @@ export * from './get-pre-order-product-list.query';
 export * from './get-pre-order-product-extended-list.query';
 export * from './create-manually-pre-order-product-for-standing-order.command';
 export * from './get-pre-order-products-by-pre-order-list.command';
+export * from './group/move-group-pre-order-product.command';

package/constant/error.ts

@@ -620,6 +620,17 @@ export const ERRORS = {
         message: 'Failed to copy pre order',
         httpCode: 500,
     },
+    PRE_ORDER_MERGE_FAILED: { code: 'PO013', message: 'Pre-order merge failed', httpCode: 500 },
+    PRE_ORDER_MERGE_ANALYSIS_FAILED: { code: 'PO014', message: 'Pre-order merge analysis failed', httpCode: 500 },
+    PRE_ORDER_MERGE_NO_VALID_GROUPS: { code: 'PO015', message: 'No valid groups found for merge', httpCode: 400 },
+    PRE_ORDER_MERGE_NO_COLLECTION: { code: 'PO016', message: 'All pre-orders must belong to a collection for merge', httpCode: 400 },
+    PRE_ORDER_MERGE_NOT_ENOUGH: { code: 'PO017', message: 'At least 2 pre-orders required for merge', httpCode: 400 },
+    PRE_ORDER_MERGE_STATUS_NOT_ALLOWED: { code: 'PO018', message: 'Pre-order status not allowed for merge', httpCode: 400 },
+    PRE_ORDER_MERGE_DIFFERENT_STATUSES: { code: 'PO019', message: 'Pre-orders have different statuses', httpCode: 400 },
+    PRE_ORDER_MERGE_DIFFERENT_COLLECTIONS: { code: 'PO020', message: 'All pre-orders must belong to the same collection', httpCode: 400 },
+    PRE_ORDER_MERGE_HAS_EMPTY: { code: 'PO021', message: 'Some pre-orders are empty and will be deleted', httpCode: 400 },
+    PRE_ORDER_MERGE_TAGS_CONCATENATE: { code: 'PO022', message: 'Pre-orders have different tags', httpCode: 400 },
+    PRE_ORDER_MERGE_COMMENTS_CONCATENATE: { code: 'PO023', message: 'Pre-orders have different comments', httpCode: 400 },
     STANDING_ORDER_CLIENT_NAME_REQUIRED: {
         code: 'SO001',
         message: 'Standing order client name is required',

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@floristcloud/api-lib",
-    "version": "1.0.54",
+    "version": "1.0.55",
     "description": "",
     "main": "./build/index.js",
     "scripts": {

package/schemas/pre-order-product/pre-order-product.schema.ts

@@ -9,6 +9,7 @@ export const MatchingConfigSchema = z.object({
     matchByColor: z.coerce.boolean(),
     matchBySize: z.coerce.boolean(),
     matchByGrower: z.coerce.boolean(),
+    usePreOrderMultiplicity: z.coerce.boolean().optional(),
 });
 
 export const PreOrderProductSchema = z.object({