@floristcloud/api-lib 1.2.180 → 1.2.181

package/commands/integration/one-c/index.ts

@@ -5,3 +5,5 @@ export * from './get-one-c-status.query';
 export * from './get-one-c-stock-conflict-list.query';
 export * from './get-one-c-stock-conflict-preview.query';
 export * from './resolve-one-c-stock-conflict.command';
+
+export * from './update-one-c-settings.command';

package/commands/integration/one-c/update-one-c-settings.command.ts

@@ -0,0 +1,10 @@
+import type { z } from 'zod';
+import { UpdateOneCSettingsRequestSchema } from '../../../schemas/integration/one-c/update-one-c-settings-request.schema';
+import { UpdateOneCSettingsResponseSchema } from '../../../schemas/integration/one-c/update-one-c-settings-response.schema';
+
+export namespace UpdateOneCSettingsContractCommand {
+    export const RequestSchema = UpdateOneCSettingsRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = UpdateOneCSettingsResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/measure-unit/archive-measure-unit.command.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import { MeasureUnitResponseSchema } from '../../schemas/measure-unit/measure-unit-response.schema';
+
+export namespace ArchiveMeasureUnitContractCommand {
+    export const ResponseSchema = MeasureUnitResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/measure-unit/create-measure-unit.command.ts

@@ -0,0 +1,10 @@
+import type { z } from 'zod';
+import { CreateMeasureUnitRequestSchema } from '../../schemas/measure-unit/create-measure-unit-request.schema';
+import { MeasureUnitResponseSchema } from '../../schemas/measure-unit/measure-unit-response.schema';
+
+export namespace CreateMeasureUnitContractCommand {
+    export const RequestSchema = CreateMeasureUnitRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = MeasureUnitResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/measure-unit/get-measure-unit-by-uuid.query.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import { MeasureUnitResponseSchema } from '../../schemas/measure-unit/measure-unit-response.schema';
+
+export namespace GetMeasureUnitByUUIDContractQuery {
+    export const ResponseSchema = MeasureUnitResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/measure-unit/get-measure-unit-list.query.ts

@@ -0,0 +1,10 @@
+import type { z } from 'zod';
+import { GetMeasureUnitListRequestSchema } from '../../schemas/measure-unit/get-measure-unit-list-request.schema';
+import { MeasureUnitListResponseSchema } from '../../schemas/measure-unit/measure-unit-list-response.schema';
+
+export namespace GetMeasureUnitListContractQuery {
+    export const RequestSchema = GetMeasureUnitListRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = MeasureUnitListResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/measure-unit/index.ts

@@ -0,0 +1,8 @@
+export * from './create-measure-unit.command';
+export * from './update-measure-unit.command';
+export * from './set-default-measure-unit.command';
+export * from './reorder-measure-units.command';
+export * from './archive-measure-unit.command';
+export * from './unarchive-measure-unit.command';
+export * from './get-measure-unit-list.query';
+export * from './get-measure-unit-by-uuid.query';

package/commands/measure-unit/reorder-measure-units.command.ts

@@ -0,0 +1,10 @@
+import type { z } from 'zod';
+import { ReorderMeasureUnitsRequestSchema } from '../../schemas/measure-unit/reorder-measure-units-request.schema';
+import { MeasureUnitListResponseSchema } from '../../schemas/measure-unit/measure-unit-list-response.schema';
+
+export namespace ReorderMeasureUnitsContractCommand {
+    export const RequestSchema = ReorderMeasureUnitsRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = MeasureUnitListResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/measure-unit/set-default-measure-unit.command.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import { MeasureUnitResponseSchema } from '../../schemas/measure-unit/measure-unit-response.schema';
+
+export namespace SetDefaultMeasureUnitContractCommand {
+    export const ResponseSchema = MeasureUnitResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/measure-unit/unarchive-measure-unit.command.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import { MeasureUnitResponseSchema } from '../../schemas/measure-unit/measure-unit-response.schema';
+
+export namespace UnarchiveMeasureUnitContractCommand {
+    export const ResponseSchema = MeasureUnitResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/measure-unit/update-measure-unit.command.ts

@@ -0,0 +1,10 @@
+import type { z } from 'zod';
+import { UpdateMeasureUnitRequestSchema } from '../../schemas/measure-unit/update-measure-unit-request.schema';
+import { MeasureUnitResponseSchema } from '../../schemas/measure-unit/measure-unit-response.schema';
+
+export namespace UpdateMeasureUnitContractCommand {
+    export const RequestSchema = UpdateMeasureUnitRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = MeasureUnitResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/pre-order/import-standing-order.command.ts

@@ -1,22 +1,5 @@
-import { z } from 'zod';
-
-const ImportRowErrorSchema = z.object({
-    row: z.number(),
-    column: z.string(),
-    message: z.string(),
-    code: z.string(),
-    i18nKey: z.string().optional(),
-    i18nParams: z.record(z.string(), z.union([z.string(), z.number(), z.null()])).optional(),
-});
-
-const ImportStandingOrderResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        success: z.boolean(),
-        errors: z.array(ImportRowErrorSchema),
-        warnings: z.array(ImportRowErrorSchema),
-    }),
-});
+import type { z } from 'zod';
+import { ImportStandingOrderResponseSchema } from '../../schemas/pre-order/import-standing-order-response.schema';
 
 export namespace ImportStandingOrderContractCommand {
     export const ResponseSchema = ImportStandingOrderResponseSchema;

package/commands/pre-order-collection-item/import-pre-order-collection-item.command.ts

@@ -1,43 +1,6 @@
-import { z } from 'zod';
-import { PreOrderCollectionItemImportEntityPropertyEnum, PreOrderCollectionItemImportErrorsEnum } from '../../enum';
-
-const ImportPreOrderCollectionItemRequestSchema = z.object({});
-
-const PreOrderCollectionItemImportIssueParamsSchema = z.record(
-    z.string(),
-    z.union([z.string(), z.number(), z.null(), z.array(z.string())]),
-);
-
-const PreOrderCollectionItemImportIssueSchema = z.object({
-    path: z.nativeEnum(PreOrderCollectionItemImportEntityPropertyEnum).optional(),
-    type: z.nativeEnum(PreOrderCollectionItemImportErrorsEnum),
-    params: PreOrderCollectionItemImportIssueParamsSchema.optional(),
-});
-
-const PreOrderCollectionItemImportRowErrorSchema = z.object({
-    row: z.number(),
-    errors: z.array(PreOrderCollectionItemImportIssueSchema),
-});
-
-const PreOrderCollectionItemImportGlobalErrorSchema = z.object({
-    errors: z.array(PreOrderCollectionItemImportIssueSchema),
-});
-
-const PreOrderCollectionItemImportCreatedRowSchema = z.object({
-    row: z.number(),
-    uuid: z.string(),
-});
-
-const ImportPreOrderCollectionItemResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        rows: z.number(),
-        created: z.array(PreOrderCollectionItemImportCreatedRowSchema),
-        errors: z.array(PreOrderCollectionItemImportRowErrorSchema),
-        warnings: z.array(PreOrderCollectionItemImportRowErrorSchema),
-        globalErrors: z.array(PreOrderCollectionItemImportGlobalErrorSchema).optional(),
-    }),
-});
+import type { z } from 'zod';
+import { ImportPreOrderCollectionItemRequestSchema } from '../../schemas/pre-order-collection-item/import-pre-order-collection-item-request.schema';
+import { ImportPreOrderCollectionItemResponseSchema } from '../../schemas/pre-order-collection-item/import-pre-order-collection-item-response.schema';
 
 export namespace ImportPreOrderCollectionItemContractCommand {
     export const RequestSchema = ImportPreOrderCollectionItemRequestSchema;

package/commands/pre-order-collection-item/update-group-pre-order-collection-item.command.ts

@@ -1,17 +1,6 @@
-import { z } from 'zod';
-import { UpdatePreOrderCollectionItemSchema } from '../../schemas';
-
-const UpdateGroupPreOrderCollectionItemRequestSchema = z.object({
-    preOrderCollectionItemUUIDs: z.array(z.string()),
-    data: UpdatePreOrderCollectionItemSchema,
-});
-
-const UpdateGroupPreOrderCollectionItemResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        success: z.boolean(),
-    }),
-});
+import type { z } from 'zod';
+import { UpdateGroupPreOrderCollectionItemRequestSchema } from '../../schemas/pre-order-collection-item/update-group-pre-order-collection-item-request.schema';
+import { UpdateGroupPreOrderCollectionItemResponseSchema } from '../../schemas/pre-order-collection-item/update-group-pre-order-collection-item-response.schema';
 
 export namespace UpdateGroupPreOrderCollectionItemContractCommand {
     export const RequestSchema = UpdateGroupPreOrderCollectionItemRequestSchema;

package/commands/product/create-product.command.ts

@@ -1,43 +1,6 @@
-import { z } from 'zod';
-import { ProductMarkEnum, SalesUnitEnum } from '../../enum';
-import { ProductExtendedForAdminSchema } from '../../schemas';
-import { MoneySchema } from '../../schemas/money.schema';
-
-const CreateProductRequestSchema = z.object({
-    name: z.string(),
-    consignmentUUID: z.string(),
-    categoryUUID: z.string(),
-    balance: z.number(),
-    quantity: z.number(),
-    price: MoneySchema,
-    costPrice: MoneySchema,
-    multiplicity: z.number(),
-    isOpen: z.coerce.boolean(),
-
-    article: z.string().nullable(),
-    vbn: z.string().nullable(),
-    barcode: z.string().nullable(),
-    color: z.string().nullable(),
-    size: z.string().nullable(),
-    size2: z.string().nullable(),
-    size3: z.string().nullable(),
-    invoicePrice: MoneySchema.nullable(),
-    invoiceNumber: z.string().nullable(),
-    imageUUID: z.string().nullable(),
-    country: z.string().nullable(),
-    description: z.string().nullable(),
-    quality: z.string().nullable(),
-    grower: z.string().nullable(),
-    vat: z.number().nullable(),
-    multiplicityDescription: z.string().nullable(),
-    salesUnit: z.nativeEnum(SalesUnitEnum).optional().nullable(),
-    marks: z.array(z.nativeEnum(ProductMarkEnum)).optional(),
-});
-
-const CreateProductResponseSchema = z.object({
-    message: z.string().optional(),
-    data: ProductExtendedForAdminSchema,
-});
+import type { z } from 'zod';
+import { CreateProductRequestSchema } from '../../schemas/product/create-product-request.schema';
+import { CreateProductResponseSchema } from '../../schemas/product/create-product-response.schema';
 
 export namespace CreateProductContractCommand {
     export const RequestSchema = CreateProductRequestSchema;

package/commands/product/group/update-group-product-update-batch.command.ts

@@ -1,46 +1,6 @@
-import { z } from 'zod';
-import { SalesUnitEnum } from '../../../enum';
-import { ErrorMessageSchema } from '../../../schemas/error-message.schema';
-import { MoneySchema } from '../../../schemas/money.schema';
-
-const UpdateGroupProductUpdateBatchRequestSchema = z.object({
-    productUUIDList: z.array(z.string()),
-    data: z
-        .object({
-            name: z.string(),
-            categoryUUID: z.string(),
-            price: MoneySchema,
-            costPrice: MoneySchema,
-            color: z.string().nullable(),
-            size: z.string().nullable(),
-            multiplicity: z.coerce.number(),
-            size2: z.string().nullable(),
-            grower: z.string().nullable(),
-            country: z.string().nullable(),
-            invoicePrice: MoneySchema.nullable(),
-            invoiceNumber: z.string().nullable(),
-            imageUUID: z.string().nullable(),
-            multiplicityDescription: z.string().nullable(),
-            salesUnit: z.nativeEnum(SalesUnitEnum).nullable(),
-        })
-        .partial(),
-});
-
-const UpdateGroupProductUpdateBatchResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        success: z.boolean(),
-        successCount: z.number().optional(),
-        failedCount: z.number().optional(),
-        errors: z
-            .array(
-                ErrorMessageSchema.extend({
-                    productUUID: z.uuid(),
-                }),
-            )
-            .optional(),
-    }),
-});
+import type { z } from 'zod';
+import { UpdateGroupProductUpdateBatchRequestSchema } from '../../../schemas/product/group/update-group-product-update-batch-request.schema';
+import { UpdateGroupProductUpdateBatchResponseSchema } from '../../../schemas/product/group/update-group-product-update-batch-response.schema';
 
 export namespace UpdateGroupProductUpdateBatchContractCommand {
     export const RequestSchema = UpdateGroupProductUpdateBatchRequestSchema;

package/commands/product/update-product.command.ts

@@ -1,43 +1,6 @@
-import { z } from 'zod';
-import { ProductMarkEnum, SalesUnitEnum } from '../../enum';
-import { ProductExtendedForAdminSchema } from '../../schemas';
-import { MoneySchema } from '../../schemas/money.schema';
-
-const UpdateProductRequestSchema = z.object({
-    name: z.string(),
-    consignmentUUID: z.string(),
-    categoryUUID: z.string(),
-    balance: z.number(),
-    quantity: z.number(),
-    price: MoneySchema,
-    costPrice: MoneySchema,
-    multiplicity: z.number(),
-    isOpen: z.coerce.boolean(),
-
-    article: z.string().nullable(),
-    vbn: z.string().nullable(),
-    barcode: z.string().nullable(),
-    color: z.string().nullable(),
-    size: z.string().nullable(),
-    size2: z.string().nullable(),
-    size3: z.string().nullable(),
-    invoicePrice: MoneySchema.nullable(),
-    invoiceNumber: z.string().nullable(),
-    imageUUID: z.string().nullable(),
-    country: z.string().nullable(),
-    description: z.string().nullable(),
-    quality: z.string().nullable(),
-    grower: z.string().nullable(),
-    vat: z.number().nullable(),
-    multiplicityDescription: z.string().nullable(),
-    salesUnit: z.nativeEnum(SalesUnitEnum).optional().nullable(),
-    marks: z.array(z.nativeEnum(ProductMarkEnum)).optional(),
-});
-
-const UpdateProductResponseSchema = z.object({
-    message: z.string().optional(),
-    data: ProductExtendedForAdminSchema,
-});
+import type { z } from 'zod';
+import { UpdateProductRequestSchema } from '../../schemas/product/update-product-request.schema';
+import { UpdateProductResponseSchema } from '../../schemas/product/update-product-response.schema';
 
 export namespace UpdateProductContractCommand {
     export const RequestSchema = UpdateProductRequestSchema;

package/commands/report/get-daily-orders-summary.query.ts

@@ -1,77 +1,6 @@
-import { z } from 'zod';
-import { OrderStatusEnum } from '../../enum/order-status.enum';
-import { ReportOrderDateBasisEnum } from '../../enum/report-order-date-basis.enum';
-import { dateRangeCheck, isStatementPeriodWithinLimit } from '../../helpers/date.helper';
-import { MoneySchema } from '../../schemas/money.schema';
-
-const GetDailyOrdersSummaryRequestSchema = z
-    .object({
-        startDate: z.coerce.date(),
-        endDate: z.coerce.date(),
-        // Ось периода — общая с отчётами продаж, чтобы сводка и отчёт за тот же период не разошлись
-        // в семантике. Дизъюнкции «любая из дат» здесь нет намеренно, см. ReportOrderDateBasisEnum.
-        //
-        // COMPLETED_AT сужает сводку до отгруженных заказов: даты отгрузки у остальных статусов
-        // просто нет. Поэтому на этой оси ordersCompleted равен ordersCreated, а фильтр по любому
-        // статусу кроме COMPLETED даёт нули — на фронте эти два фильтра совмещать не нужно.
-        dateBasis: z.nativeEnum(ReportOrderDateBasisEnum).default(ReportOrderDateBasisEnum.CREATED_AT),
-        // Необязательное сужение по статусу. Принимается и CSV (`?status=NEW,ACCEPTED`), и повтор
-        // параметра — как excludeClientUUID в ReportOrderFilterSchema.
-        //
-        // Служебные статусы здесь НЕ отсеиваются, хотя в сводку они и так не попадают: отсев на
-        // этом слое означал бы «фильтр пуст → фильтра нет», и `?status=TEMPLATE` вернул бы весь
-        // отчёт вместо нулей. Отбрасывает их билдер — там пустой результат остаётся пустым.
-        status: z
-            .union([z.string(), z.array(z.string())])
-            .transform(value => (Array.isArray(value) ? value : value.split(',')).map(item => item.trim()).filter(Boolean))
-            .pipe(z.array(z.nativeEnum(OrderStatusEnum)))
-            .optional(),
-    })
-    .refine(value => dateRangeCheck(value.startDate, value.endDate), {
-        message: 'validation.dateRange',
-        path: ['endDate', 'startDate'],
-    })
-    .refine(value => isStatementPeriodWithinLimit(value.startDate, value.endDate), {
-        message: 'validation.reportPeriodMax',
-        path: ['endDate', 'startDate'],
-    });
-
-const UnitsByMeasureSchema = z.object({
-    PIECE: z.number(),
-    PACK: z.number(),
-    BOX: z.number(),
-});
-
-const metricsShape = {
-    ordersCreated: z.number(),
-    ordersCompleted: z.number(),
-    totalSum: MoneySchema,
-    // Часть totalSum по заказам со статусом COMPLETED. На оси COMPLETED_AT равна totalSum:
-    // там весь срез и так отгружен.
-    completedSum: MoneySchema,
-    unitsByMeasure: UnitsByMeasureSchema,
-};
-
-const DailyOrdersSummaryTotalsSchema = z.object({ ...metricsShape });
-
-const DailyOrdersSummaryByDayItemSchema = z.object({
-    date: z.string(),
-    ...metricsShape,
-});
-
-const DailyOrdersSummaryByResponsibleItemSchema = z.object({
-    responsibleUserUUID: z.string().nullable(),
-    responsibleUserName: z.string().nullable(),
-    ...metricsShape,
-});
-
-const GetDailyOrdersSummaryResponseSchema = z.object({
-    data: z.object({
-        totals: DailyOrdersSummaryTotalsSchema,
-        byDay: z.array(DailyOrdersSummaryByDayItemSchema),
-        byResponsible: z.array(DailyOrdersSummaryByResponsibleItemSchema),
-    }),
-});
+import type { z } from 'zod';
+import { GetDailyOrdersSummaryRequestSchema } from '../../schemas/report/get-daily-orders-summary-request.schema';
+import { GetDailyOrdersSummaryResponseSchema } from '../../schemas/report/get-daily-orders-summary-response.schema';
 
 export namespace GetDailyOrdersSummaryContractQuery {
     export const RequestSchema = GetDailyOrdersSummaryRequestSchema;

package/constant/error.ts

@@ -234,6 +234,34 @@ export const ERRORS = {
     BRANCH_NOT_FOUND: { code: 'B004', message: 'Branch not founded', httpCode: 404 },
     BRANCH_NOT_DELETED: { code: 'B005', message: 'Branch not deleted', httpCode: 500 },
     BRANCH_NOT_UPDATED: { code: 'B006', message: 'Branch not updated', httpCode: 500 },
+    // MEASURE_UNIT
+    MEASURE_UNIT_NOT_FOUND: { code: 'MU001', message: 'Measure unit not found', httpCode: 404 },
+    MEASURE_UNIT_NAME_EXISTS: { code: 'MU002', message: 'Measure unit name is already used', httpCode: 409 },
+    MEASURE_UNIT_SHORT_NAME_EXISTS: { code: 'MU003', message: 'Measure unit short name is already used', httpCode: 409 },
+    MEASURE_UNIT_ALIAS_CONFLICT: { code: 'MU004', message: 'Measure unit alias overlaps another unit', httpCode: 409 },
+    MEASURE_UNIT_INVALID_OKEI: { code: 'MU005', message: 'OKEI code must contain three digits', httpCode: 400 },
+    MEASURE_UNIT_DEFAULT_ARCHIVE: { code: 'MU006', message: 'Cannot archive the default measure unit', httpCode: 400 },
+    MEASURE_UNIT_ARCHIVED_DEFAULT: { code: 'MU007', message: 'Cannot make an archived measure unit default', httpCode: 400 },
+    MEASURE_UNIT_ARCHIVED: { code: 'MU008', message: 'Measure unit is archived', httpCode: 400 },
+    MEASURE_UNIT_INVALID_ORDER: {
+        code: 'MU009',
+        message: 'Measure unit order must contain all units or all active units exactly once',
+        httpCode: 400,
+    },
+    MEASURE_UNIT_FAILED: { code: 'MU010', message: 'Failed to process measure units', httpCode: 500 },
+    MEASURE_UNIT_INVALID_NAME: { code: 'MU011', message: 'Measure unit names must not be empty', httpCode: 400 },
+    MEASURE_UNIT_ALREADY_LINKED: { code: 'MU012', message: 'Measure unit is already linked to another external unit', httpCode: 409 },
+    MEASURE_UNIT_INVALID_TEXT: {
+        code: 'MU013',
+        message: 'Measure unit names or aliases exceed limits or contain control characters (name/alias: 100, short name: 32, aliases: 50)',
+        httpCode: 400,
+    },
+    MEASURE_UNIT_LIMIT_EXCEEDED: {
+        code: 'MU014',
+        message: 'Company may have at most 100 measure units, including archived units',
+        httpCode: 400,
+    },
+
     //PRODUCT
     PRODUCT_NOT_CREATED: { code: 'P001', message: 'Failed to create product', httpCode: 500 },
     PRODUCT_FETCH_FAILED: { code: 'P002', message: 'Error when retrieving a product', httpCode: 500 },

package/constant/index.ts

@@ -16,3 +16,4 @@ export * from './client-group-actions.constant';
 export * from './standing-order-positions.constant';
 export * from './order-external-number.constant';
 export * from './discount-rules-pricing-type-list.constant';
+export * from './measure-unit-limits';

package/constant/measure-unit-limits.ts

@@ -0,0 +1 @@
+export const MEASURE_UNIT_LIMITS = { name: 100, shortName: 32, alias: 100, aliases: 50, perCompany: 100 };

package/enum/external-entity-type.enum.ts

@@ -1,4 +1,5 @@
 export enum ExternalEntityTypeEnum {
+    MEASURE_UNIT = 'MEASURE_UNIT',
     PRODUCT = 'PRODUCT',
     CATEGORY = 'CATEGORY',
     CLIENT = 'CLIENT',

package/enum/index.ts

@@ -55,6 +55,7 @@ export * from './language.enum';
 export * from './legal-identifier-field.enum';
 export * from './match-confidence.enum';
 export * from './moysklad-sync-status.enum';
+export * from './moysklad-import-item-status.enum';
 export * from './normalization-decision-action.enum';
 export * from './normalization-target.enum';
 export * from './normalization-value-state.enum';
@@ -162,3 +163,4 @@ export * from './pre-order-fulfillment-status.enum';
 
 export * from './delivery-pricing-rule-scope.enum';
 export * from './delivery-pricing-in-transit-mode.enum';
+export * from './measure-unit-match-source.enum';

package/enum/measure-unit-match-source.enum.ts

@@ -0,0 +1,6 @@
+export enum MeasureUnitMatchSourceEnum {
+    LINK = 'LINK',
+    OKEI = 'OKEI',
+    NAME = 'NAME',
+    DEFAULT = 'DEFAULT',
+}

package/enum/moysklad-import-item-status.enum.ts

@@ -0,0 +1,6 @@
+// Строка предпросмотра импорта из МойСклада: NEW — в FC ещё нет, создастся; KNOWN — уже связана ссылкой.
+// Значения в нижнем регистре — так их уже шлёт и сравнивает fc-app.
+export enum MoyskladImportItemStatusEnum {
+    NEW = 'new',
+    KNOWN = 'known',
+}

package/package.json

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

package/schemas/consignment/consignment-product-multiplicity-option-update.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
+
+export const ConsignmentProductMultiplicityOptionUpdateSchema = z.object({
+    title: z.string().nullable().optional(),
+    optionMultiplicity: z.number().nullable().optional(),
+    optionPrice: MoneySchema.nullable().optional(),
+    // Отсутствие поля — флаг не меняем; у создаваемой кратности берётся умолчание (скидки разрешены).
+    // Пустая ячейка в файле сюда не доезжает: разбор превращает её в отсутствие поля, а не в `false`.
+    isDiscountAllowed: z.boolean().optional(),
+});

package/schemas/consignment/consignment-product-position-update.schema.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { SalesUnitEnum } from '../../enum/sales-unit.enum';
+import { MoneySchema } from '../money.schema';
+import { ConsignmentProductMultiplicityOptionUpdateSchema } from './consignment-product-multiplicity-option-update.schema';
+
+export const ConsignmentProductPositionUpdateSchema = z.object({
+    measureUnitUUID: z.string().uuid().optional(),
+    salesUnit: z.nativeEnum(SalesUnitEnum).nullable().optional(),
+    measureUnitText: z.string().nullable().optional(),
+    name: z.string().nullable().optional(),
+    multiplicity: z.number().nullable().optional(),
+    quantity: z.number().nullable().optional(),
+    balance: z.number().nullable().optional(),
+    price: MoneySchema.nullable().optional(),
+    costPrice: MoneySchema.nullable().optional(),
+    invoicePrice: MoneySchema.nullable().optional(),
+    invoiceNumber: z.string().nullable().optional(),
+    multiplicityDescription: z.string().nullable().optional(),
+    vat: z.number().nullable().optional(),
+    article: z.string().nullable().optional(),
+    color: z.string().nullable().optional(),
+    vbn: z.string().nullable().optional(),
+    barcode: z.string().nullable().optional(),
+    size: z.string().nullable().optional(),
+    size2: z.string().nullable().optional(),
+    size3: z.string().nullable().optional(),
+    country: z.string().nullable().optional(),
+    description: z.string().nullable().optional(),
+    quality: z.string().nullable().optional(),
+    grower: z.string().nullable().optional(),
+    // `null` — слот кратности очищен, кратность надо удалить; отсутствие поля — слотом не управляем.
+    // Различие существенное: обновление по схеме импорта видит только те колонки, что она отображает,
+    // и не должно сносить кратность, которую просто не читает.
+    option1: ConsignmentProductMultiplicityOptionUpdateSchema.nullable().optional(),
+    option2: ConsignmentProductMultiplicityOptionUpdateSchema.nullable().optional(),
+});

package/schemas/consignment/execute-consignment-product-update-request.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { ConsignmentProductPositionUpdateSchema } from './consignment-product-position-update.schema';
+
+export const ExecuteConsignmentProductUpdateRequestSchema = z.object({
+    updates: z.record(z.string(), ConsignmentProductPositionUpdateSchema),
+});

package/schemas/consignment/execute-consignment-product-update-response-data-errors.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { ErrorMessageSchema } from '../error-message.schema';
+
+export const ExecuteConsignmentProductUpdateResponseDataErrorsSchema = ErrorMessageSchema.extend({
+    uuid: z.string(),
+});

package/schemas/consignment/execute-consignment-product-update-response-data.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { ExecuteConsignmentProductUpdateResponseDataErrorsSchema } from './execute-consignment-product-update-response-data-errors.schema';
+
+export const ExecuteConsignmentProductUpdateResponseDataSchema = z.object({
+    unrecognizedMeasureUnitCount: z.number(),
+    unrecognizedMeasureUnitExamples: z.array(z.string()),
+    success: z.boolean(),
+    successCount: z.number(),
+    failedCount: z.number(),
+    errors: z.array(ExecuteConsignmentProductUpdateResponseDataErrorsSchema),
+});

package/schemas/consignment/execute-consignment-product-update-response.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { ExecuteConsignmentProductUpdateResponseDataSchema } from './execute-consignment-product-update-response-data.schema';
+
+export const ExecuteConsignmentProductUpdateResponseSchema = z.object({
+    data: ExecuteConsignmentProductUpdateResponseDataSchema,
+});

package/schemas/consignment/import-consignment-request-constant-data.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { ConsignmentImportSchemaRelationEntityPropertyEnum } from '../../enum';
+
+export const ImportConsignmentRequestConstantDataSchema = z.object({
+    [ConsignmentImportSchemaRelationEntityPropertyEnum.INVOICE_NUMBER]: z.string().nullable().optional(),
+    [ConsignmentImportSchemaRelationEntityPropertyEnum.GROWER]: z.string().nullable().optional(),
+    [ConsignmentImportSchemaRelationEntityPropertyEnum.COUNTRY]: z.string().nullable().optional(),
+});

package/schemas/consignment/import-consignment-request.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { ConsignmentImportNameConventionEnum } from '../../enum';
+import { ImportConsignmentRequestConstantDataSchema } from './import-consignment-request-constant-data.schema';
+
+export const ImportConsignmentRequestSchema = z.object({
+    isAggregate: z.coerce.boolean().optional().default(false),
+    isSeparateByGrower: z.coerce.boolean().optional().default(false),
+    isCutCategoryFromName: z.coerce.boolean().optional().default(false),
+    isFindImage: z.coerce.boolean().optional().default(false),
+    isRemoveSize: z.coerce.boolean().optional().default(false),
+    tradeMargin: z.coerce.number().optional().default(0),
+    coefficient: z.coerce.number().optional().default(0),
+    nameConvention: z.nativeEnum(ConsignmentImportNameConventionEnum).optional(),
+    constantData: ImportConsignmentRequestConstantDataSchema.optional(),
+});