@floristcloud/api-lib 1.2.6 → 1.2.7

package/build/commands/order-product/group/price-correction-analyze.command.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceCorrectionAnalyzeContractCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../schemas");
+const PriceCorrectionAnalyzeRequestSchema = zod_1.z
+    .object({
+    productUUIDList: zod_1.z.array(zod_1.z.string().uuid()).optional(),
+    consignmentUUID: zod_1.z.string().uuid().optional(),
+})
+    .refine(data => { var _a; return ((_a = data.productUUIDList) === null || _a === void 0 ? void 0 : _a.length) || data.consignmentUUID; }, {
+    message: 'Either productUUIDList or consignmentUUID must be provided',
+});
+const PriceCorrectionAnalyzeResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        items: zod_1.z.array(schemas_1.PriceCorrectionAnalyzeItemSchema),
+    }),
+});
+var PriceCorrectionAnalyzeContractCommand;
+(function (PriceCorrectionAnalyzeContractCommand) {
+    PriceCorrectionAnalyzeContractCommand.RequestSchema = PriceCorrectionAnalyzeRequestSchema;
+    PriceCorrectionAnalyzeContractCommand.ItemSchema = schemas_1.PriceCorrectionAnalyzeItemSchema;
+    PriceCorrectionAnalyzeContractCommand.ResponseSchema = PriceCorrectionAnalyzeResponseSchema;
+})(PriceCorrectionAnalyzeContractCommand || (exports.PriceCorrectionAnalyzeContractCommand = PriceCorrectionAnalyzeContractCommand = {}));

package/build/commands/order-product/group/price-correction-execute.command.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceCorrectionExecuteContractCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../schemas");
+const PRICE_CORRECTION_BATCH_LIMIT = 50;
+const PriceCorrectionExecuteRequestSchema = zod_1.z.object({
+    orderProductUUIDList: zod_1.z.array(zod_1.z.string().uuid()).min(1).max(PRICE_CORRECTION_BATCH_LIMIT),
+    withDiscount: zod_1.z.boolean(),
+});
+const PriceCorrectionExecuteResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        results: zod_1.z.array(schemas_1.PriceCorrectionExecuteResultItemSchema),
+        successCount: zod_1.z.number(),
+        skippedCount: zod_1.z.number(),
+    }),
+});
+var PriceCorrectionExecuteContractCommand;
+(function (PriceCorrectionExecuteContractCommand) {
+    PriceCorrectionExecuteContractCommand.RequestSchema = PriceCorrectionExecuteRequestSchema;
+    PriceCorrectionExecuteContractCommand.BATCH_LIMIT = PRICE_CORRECTION_BATCH_LIMIT;
+    PriceCorrectionExecuteContractCommand.ResponseSchema = PriceCorrectionExecuteResponseSchema;
+})(PriceCorrectionExecuteContractCommand || (exports.PriceCorrectionExecuteContractCommand = PriceCorrectionExecuteContractCommand = {}));

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

@@ -27,6 +27,8 @@ __exportStar(require("./group/update-group-order-product-tag.command"), exports)
 __exportStar(require("./group/delete-group-order-product.command"), exports);
 __exportStar(require("./group/update-group-order-product-order.command"), exports);
 __exportStar(require("./group/zeroing-receipt-order-product.command"), exports);
+__exportStar(require("./group/price-correction-analyze.command"), exports);
+__exportStar(require("./group/price-correction-execute.command"), exports);
 //webshop
 __exportStar(require("./webshop/update-order-product-for-client.command"), exports);
 __exportStar(require("./webshop/create-order-product-for-client.command"), exports);

package/build/constant/error.js

@@ -400,6 +400,21 @@ exports.ERRORS = {
         message: 'The product is not deleted, because it has write-off',
         httpCode: 500,
     },
+    ORDER_PRODUCT_PRICE_CORRECTION_BATCH_LIMIT_EXCEEDED: {
+        code: 'OP015',
+        message: 'Price correction batch limit exceeded',
+        httpCode: 400,
+    },
+    ORDER_PRODUCT_PRICE_CORRECTION_FAILED: {
+        code: 'OP016',
+        message: 'Failed to correct price for order product',
+        httpCode: 500,
+    },
+    ORDER_PRODUCT_PRICE_CORRECTION_ORDER_STATUS_NOT_ALLOWED: {
+        code: 'OP017',
+        message: 'Order status does not allow price correction',
+        httpCode: 400,
+    },
     //TRANSACTION
     TRANSACTION_NOT_CREATED: { code: 'TR001', message: 'Failed to transaction product', httpCode: 500 },
     TRANSACTION_FETCH_FAILED: { code: 'TR002', message: 'Error when retrieving a transaction', httpCode: 500 },

package/build/enum/index.js

@@ -43,6 +43,7 @@ __exportStar(require("./discount-rules-type.enum"), exports);
 __exportStar(require("./discount-rules-mode-type.enum"), exports);
 __exportStar(require("./order-distribute-status-list"), exports);
 __exportStar(require("./order-active-status-list"), exports);
+__exportStar(require("./order-price-correction-skipped-status-list"), exports);
 __exportStar(require("./client-status.enum"), exports);
 __exportStar(require("./client-type.enum"), exports);
 __exportStar(require("./consignment-distribution-validation-status.enum"), exports);

package/build/enum/order-price-correction-skipped-status-list.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderPriceCorrectionSkippedStatusList = void 0;
+const order_status_enum_1 = require("./order-status.enum");
+exports.OrderPriceCorrectionSkippedStatusList = [
+    order_status_enum_1.OrderStatusEnum.ASSEMBLED,
+    order_status_enum_1.OrderStatusEnum.VERIFIED,
+    order_status_enum_1.OrderStatusEnum.SHIPPED,
+    order_status_enum_1.OrderStatusEnum.COMPLETED,
+];

package/build/schemas/index.js

@@ -26,6 +26,8 @@ __exportStar(require("./order-delivery/order-delivery.schema"), exports);
 __exportStar(require("./order-product/order-product.schema"), exports);
 __exportStar(require("./order-product/order-product-list.schema"), exports);
 __exportStar(require("./order-product/order-product-multiplicity-optiom.schema"), exports);
+__exportStar(require("./order-product/price-correction-analyze-item.schema"), exports);
+__exportStar(require("./order-product/price-correction-execute-result-item.schema"), exports);
 __exportStar(require("./transaction/transaction.schema"), exports);
 __exportStar(require("./transaction/transaction-list.schema"), exports);
 __exportStar(require("./file"), exports);

package/build/schemas/order-product/price-correction-analyze-item.schema.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceCorrectionAnalyzeItemSchema = void 0;
+const zod_1 = require("zod");
+const enum_1 = require("../../enum");
+const error_message_schema_1 = require("../error-message.schema");
+exports.PriceCorrectionAnalyzeItemSchema = zod_1.z.object({
+    orderProductUUID: zod_1.z.string(),
+    orderUUID: zod_1.z.string(),
+    orderNumber: zod_1.z.number(),
+    orderStatus: zod_1.z.nativeEnum(enum_1.OrderStatusEnum),
+    clientName: zod_1.z.string(),
+    clientUUID: zod_1.z.string(),
+    productUUID: zod_1.z.string(),
+    productName: zod_1.z.string(),
+    categoryName: zod_1.z.string().nullable(),
+    grower: zod_1.z.string().nullable(),
+    size: zod_1.z.string().nullable(),
+    size2: zod_1.z.string().nullable(),
+    size3: zod_1.z.string().nullable(),
+    article: zod_1.z.string().nullable(),
+    color: zod_1.z.string().nullable(),
+    currentPrice: zod_1.z.number(),
+    currentAmount: zod_1.z.number(),
+    quantity: zod_1.z.number(),
+    newPriceWithoutDiscount: zod_1.z.number(),
+    newPriceWithDiscount: zod_1.z.number(),
+    newAmountWithoutDiscount: zod_1.z.number(),
+    newAmountWithDiscount: zod_1.z.number(),
+    priceDifferenceWithoutDiscount: zod_1.z.number(),
+    priceDifferenceWithDiscount: zod_1.z.number(),
+    isSkipped: zod_1.z.boolean(),
+    skipReason: error_message_schema_1.ErrorMessageSchema.optional(),
+});

package/build/schemas/order-product/price-correction-execute-result-item.schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceCorrectionExecuteResultItemSchema = void 0;
+const zod_1 = require("zod");
+const error_message_schema_1 = require("../error-message.schema");
+exports.PriceCorrectionExecuteResultItemSchema = zod_1.z.object({
+    orderProductUUID: zod_1.z.string(),
+    orderUUID: zod_1.z.string(),
+    isSuccess: zod_1.z.boolean(),
+    error: error_message_schema_1.ErrorMessageSchema.optional(),
+    oldPrice: zod_1.z.number().optional(),
+    newPrice: zod_1.z.number().optional(),
+});

package/commands/order-product/group/price-correction-analyze.command.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { PriceCorrectionAnalyzeItemSchema } from '../../../schemas';
+
+const PriceCorrectionAnalyzeRequestSchema = z
+    .object({
+        productUUIDList: z.array(z.string().uuid()).optional(),
+        consignmentUUID: z.string().uuid().optional(),
+    })
+    .refine(data => data.productUUIDList?.length || data.consignmentUUID, {
+        message: 'Either productUUIDList or consignmentUUID must be provided',
+    });
+
+const PriceCorrectionAnalyzeResponseSchema = z.object({
+    message: z.string().optional(),
+    data: z.object({
+        items: z.array(PriceCorrectionAnalyzeItemSchema),
+    }),
+});
+
+export namespace PriceCorrectionAnalyzeContractCommand {
+    export const RequestSchema = PriceCorrectionAnalyzeRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ItemSchema = PriceCorrectionAnalyzeItemSchema;
+    export type Item = z.infer<typeof ItemSchema>;
+
+    export const ResponseSchema = PriceCorrectionAnalyzeResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/order-product/group/price-correction-execute.command.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { PriceCorrectionExecuteResultItemSchema } from '../../../schemas';
+
+const PRICE_CORRECTION_BATCH_LIMIT = 50;
+
+const PriceCorrectionExecuteRequestSchema = z.object({
+    orderProductUUIDList: z.array(z.string().uuid()).min(1).max(PRICE_CORRECTION_BATCH_LIMIT),
+    withDiscount: z.boolean(),
+});
+
+const PriceCorrectionExecuteResponseSchema = z.object({
+    message: z.string().optional(),
+    data: z.object({
+        results: z.array(PriceCorrectionExecuteResultItemSchema),
+        successCount: z.number(),
+        skippedCount: z.number(),
+    }),
+});
+
+export namespace PriceCorrectionExecuteContractCommand {
+    export const RequestSchema = PriceCorrectionExecuteRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const BATCH_LIMIT = PRICE_CORRECTION_BATCH_LIMIT;
+
+    export const ResponseSchema = PriceCorrectionExecuteResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/order-product/index.ts

@@ -11,6 +11,8 @@ export * from './group/update-group-order-product-tag.command';
 export * from './group/delete-group-order-product.command';
 export * from './group/update-group-order-product-order.command';
 export * from './group/zeroing-receipt-order-product.command';
+export * from './group/price-correction-analyze.command';
+export * from './group/price-correction-execute.command';
 //webshop
 export * from './webshop/update-order-product-for-client.command';
 export * from './webshop/create-order-product-for-client.command';

package/constant/error.ts

@@ -416,6 +416,21 @@ export const ERRORS = {
         message: 'The product is not deleted, because it has write-off',
         httpCode: 500,
     },
+    ORDER_PRODUCT_PRICE_CORRECTION_BATCH_LIMIT_EXCEEDED: {
+        code: 'OP015',
+        message: 'Price correction batch limit exceeded',
+        httpCode: 400,
+    },
+    ORDER_PRODUCT_PRICE_CORRECTION_FAILED: {
+        code: 'OP016',
+        message: 'Failed to correct price for order product',
+        httpCode: 500,
+    },
+    ORDER_PRODUCT_PRICE_CORRECTION_ORDER_STATUS_NOT_ALLOWED: {
+        code: 'OP017',
+        message: 'Order status does not allow price correction',
+        httpCode: 400,
+    },
 
     //TRANSACTION
     TRANSACTION_NOT_CREATED: { code: 'TR001', message: 'Failed to transaction product', httpCode: 500 },

package/enum/index.ts

@@ -27,6 +27,7 @@ export * from './discount-rules-type.enum';
 export * from './discount-rules-mode-type.enum';
 export * from './order-distribute-status-list';
 export * from './order-active-status-list';
+export * from './order-price-correction-skipped-status-list';
 export * from './client-status.enum';
 export * from './client-type.enum';
 export * from './consignment-distribution-validation-status.enum';

package/enum/order-price-correction-skipped-status-list.ts

@@ -0,0 +1,8 @@
+import { OrderStatusEnum } from './order-status.enum';
+
+export const OrderPriceCorrectionSkippedStatusList: OrderStatusEnum[] = [
+    OrderStatusEnum.ASSEMBLED,
+    OrderStatusEnum.VERIFIED,
+    OrderStatusEnum.SHIPPED,
+    OrderStatusEnum.COMPLETED,
+];

package/package.json

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

package/schemas/index.ts

@@ -10,6 +10,8 @@ export * from './order-delivery/order-delivery.schema';
 export * from './order-product/order-product.schema';
 export * from './order-product/order-product-list.schema';
 export * from './order-product/order-product-multiplicity-optiom.schema';
+export * from './order-product/price-correction-analyze-item.schema';
+export * from './order-product/price-correction-execute-result-item.schema';
 export * from './transaction/transaction.schema';
 export * from './transaction/transaction-list.schema';
 export * from './file';

package/schemas/order-product/price-correction-analyze-item.schema.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { OrderStatusEnum } from '../../enum';
+import { ErrorMessageSchema } from '../error-message.schema';
+
+export const PriceCorrectionAnalyzeItemSchema = z.object({
+    orderProductUUID: z.string(),
+    orderUUID: z.string(),
+    orderNumber: z.number(),
+    orderStatus: z.nativeEnum(OrderStatusEnum),
+    clientName: z.string(),
+    clientUUID: z.string(),
+
+    productUUID: z.string(),
+    productName: z.string(),
+    categoryName: z.string().nullable(),
+    grower: z.string().nullable(),
+    size: z.string().nullable(),
+    size2: z.string().nullable(),
+    size3: z.string().nullable(),
+    article: z.string().nullable(),
+    color: z.string().nullable(),
+
+    currentPrice: z.number(),
+    currentAmount: z.number(),
+    quantity: z.number(),
+
+    newPriceWithoutDiscount: z.number(),
+    newPriceWithDiscount: z.number(),
+    newAmountWithoutDiscount: z.number(),
+    newAmountWithDiscount: z.number(),
+
+    priceDifferenceWithoutDiscount: z.number(),
+    priceDifferenceWithDiscount: z.number(),
+
+    isSkipped: z.boolean(),
+    skipReason: ErrorMessageSchema.optional(),
+});

package/schemas/order-product/price-correction-execute-result-item.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { ErrorMessageSchema } from '../error-message.schema';
+
+export const PriceCorrectionExecuteResultItemSchema = z.object({
+    orderProductUUID: z.string(),
+    orderUUID: z.string(),
+    isSuccess: z.boolean(),
+    error: ErrorMessageSchema.optional(),
+    oldPrice: z.number().optional(),
+    newPrice: z.number().optional(),
+});