@floristcloud/api-lib 1.0.52 → 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/commands/write-off/create-write-off-from-pending.command.js

@@ -4,10 +4,20 @@ exports.CreateWriteOffFromPendingContractCommand = void 0;
 const zod_1 = require("zod");
 const schemas_1 = require("../../schemas");
 const enum_1 = require("../../enum");
-const CreateWriteOffFromPendingRequestSchema = zod_1.z.object({
+const CreateWriteOffFromPendingRequestSchema = zod_1.z
+    .object({
     quantity: zod_1.z.number().min(1),
-    comment: zod_1.z.string().nullable(),
     status: zod_1.z.union([zod_1.z.literal(enum_1.WriteOffStatusEnum.APPROVED), zod_1.z.literal(enum_1.WriteOffStatusEnum.REJECTED)]),
+    rejectionReason: zod_1.z.string().optional(),
+})
+    .refine(data => {
+    if (data.status === enum_1.WriteOffStatusEnum.REJECTED) {
+        return data.rejectionReason && data.rejectionReason.trim().length > 0;
+    }
+    return true;
+}, {
+    message: 'rejectionReason is required when status is REJECTED',
+    path: ['rejectionReason'],
 });
 const CreateWriteOffFromPendingResponseSchema = zod_1.z.object({
     message: zod_1.z.string().optional(),

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

@@ -4,12 +4,14 @@ exports.preOrderProductExtendedListSchema = exports.PreOrderProductListSchema =
 const zod_1 = require("zod");
 const pre_order_collection_item_schema_1 = require("../pre-order-collection-item/pre-order-collection-item.schema");
 const category_schema_1 = require("../category/category.schema");
+const pre_order_collection_item_multiplicity_option_schema_1 = require("../pre-order-collection-item/pre-order-collection-item-multiplicity-option.schema");
 exports.MatchingConfigSchema = zod_1.z.object({
     matchByName: zod_1.z.coerce.boolean(),
     matchByCategory: zod_1.z.coerce.boolean(),
     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(),
@@ -36,6 +38,7 @@ exports.PreOrderProductExtendedSchema = exports.PreOrderProductSchema.extend({
     preOrderCollectionItem: pre_order_collection_item_schema_1.PreOrderCollectionItemExtendedSchema,
     category: category_schema_1.CategorySchema.nullable(),
     deliveryDate: zod_1.z.coerce.date().nullable(),
+    multiplicityOption: pre_order_collection_item_multiplicity_option_schema_1.PreOrderCollectionItemMultiplicityOptionSchema.nullable().optional(),
 });
 exports.CreatePreOrderProductSchema = exports.PreOrderProductSchema.omit({ uuid: true, preOrderUUID: true }).extend({
     multiplicityOptionUUID: zod_1.z.uuid().nullable().optional(),

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/commands/write-off/create-write-off-from-pending.command.ts

@@ -2,11 +2,24 @@ import { z } from 'zod';
 import { WriteOffSchema } from '../../schemas';
 import { WriteOffStatusEnum } from '../../enum';
 
-const CreateWriteOffFromPendingRequestSchema = z.object({
-    quantity: z.number().min(1),
-    comment: z.string().nullable(),
-    status: z.union([z.literal(WriteOffStatusEnum.APPROVED), z.literal(WriteOffStatusEnum.REJECTED)]),
-});
+const CreateWriteOffFromPendingRequestSchema = z
+    .object({
+        quantity: z.number().min(1),
+        status: z.union([z.literal(WriteOffStatusEnum.APPROVED), z.literal(WriteOffStatusEnum.REJECTED)]),
+        rejectionReason: z.string().optional(),
+    })
+    .refine(
+        data => {
+            if (data.status === WriteOffStatusEnum.REJECTED) {
+                return data.rejectionReason && data.rejectionReason.trim().length > 0;
+            }
+            return true;
+        },
+        {
+            message: 'rejectionReason is required when status is REJECTED',
+            path: ['rejectionReason'],
+        },
+    );
 
 const CreateWriteOffFromPendingResponseSchema = z.object({
     message: z.string().optional(),

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.52",
+    "version": "1.0.55",
     "description": "",
     "main": "./build/index.js",
     "scripts": {

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { PreOrderCollectionItemExtendedSchema } from '../pre-order-collection-item/pre-order-collection-item.schema';
 import { CategorySchema } from '../category/category.schema';
+import { PreOrderCollectionItemMultiplicityOptionSchema } from '../pre-order-collection-item/pre-order-collection-item-multiplicity-option.schema';
 
 export const MatchingConfigSchema = z.object({
     matchByName: z.coerce.boolean(),
@@ -8,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({
@@ -36,6 +38,7 @@ export const PreOrderProductExtendedSchema = PreOrderProductSchema.extend({
     preOrderCollectionItem: PreOrderCollectionItemExtendedSchema,
     category: CategorySchema.nullable(),
     deliveryDate: z.coerce.date().nullable(),
+    multiplicityOption: PreOrderCollectionItemMultiplicityOptionSchema.nullable().optional(),
 });
 
 export const CreatePreOrderProductSchema = PreOrderProductSchema.omit({ uuid: true, preOrderUUID: true }).extend({