@floristcloud/api-lib 1.2.160 → 1.2.161

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
+
+export const PreOrderProductForClientSchema = z.object({
+    uuid: z.string(),
+    preOrderCollectionItemUUID: z.string().nullable(),
+    preOrderUUID: z.string(),
+    multiplicityOptionUUID: z.uuid().nullable().optional(),
+    quantity: z.number(),
+    comment: z.string().nullable(),
+    tag: z.string().nullable(),
+    isReplaceable: z.boolean(),
+    stopPrice: MoneySchema.nullable(),
+    highAttention: z.boolean(),
+    categoryUUID: z.string().nullable(),
+    name: z.string().nullable(),
+    grower: z.string().nullable(),
+    size: z.string().nullable(),
+    price: MoneySchema.nullable(),
+    color: z.string().nullable(),
+    parentPreOrderProductUUID: z.string().nullable(),
+});

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

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderProductSchema } from './pre-order-product-base.schema';
+
+export const PreOrderProductListSchema = z.object({
+    list: PreOrderProductSchema.array(),
+    total: z.number(),
+});

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

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+export const PreOrderProductStepperPositionSchema = z.object({
+    uuid: z.string(),
+    preOrderUUID: z.string(),
+    preOrderCollectionUUID: z.string().nullable(),
+    preOrderCollectionItemUUID: z.string().nullable(),
+    multiplicityOptionUUID: z.string().nullable().optional(),
+    multiplicityOptionTitle: z.string().nullable().optional(),
+    quantity: z.number(),
+    balance: z.number().nullable(),
+});

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

@@ -1,138 +1,19 @@
-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';
-import { MoneySchema } from '../money.schema';
-
-export const MatchingConfigSchema = z.object({
-    matchByName: z.coerce.boolean(),
-    matchByCategory: z.coerce.boolean(),
-    matchByColor: z.coerce.boolean(),
-    matchBySize: z.coerce.boolean(),
-    matchByGrower: z.coerce.boolean(),
-    usePreOrderMultiplicity: z.coerce.boolean().optional(),
-});
-
-export const PreOrderProductSchema = z.object({
-    uuid: z.string(),
-    preOrderCollectionItemUUID: z.string().nullable(),
-    preOrderUUID: z.string(),
-    multiplicityOptionUUID: z.uuid().nullable().optional(),
-    quantity: z.number(),
-    comment: z.string().nullable(),
-    tag: z.string().nullable(),
-    isPurchased: z.boolean(),
-    isReplaceable: z.boolean(),
-    stopPrice: MoneySchema.nullable(),
-    highAttention: z.boolean(),
-    categoryUUID: z.string().nullable(),
-    name: z.string().nullable(),
-    grower: z.string().nullable(),
-    size: z.string().nullable(),
-    price: MoneySchema.nullable(),
-    color: z.string().nullable(),
-    parentPreOrderProductUUID: z.string().nullable(),
-    matchingConfig: MatchingConfigSchema.optional().nullable(),
-});
-
-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({
-    multiplicityOptionUUID: z.uuid().nullable().optional(),
-    categoryUUID: z.string().nullable().optional(),
-    name: z.string().nullable().optional(),
-    grower: z.string().nullable().optional(),
-    size: z.string().nullable().optional(),
-    price: MoneySchema.nullable().optional(),
-    color: z.string().nullable().optional(),
-    parentPreOrderProductUUID: z.string().nullable().optional(),
-    matchingConfig: MatchingConfigSchema.optional().nullable(),
-});
-
-export const UpdatePreOrderProductSchema = PreOrderProductSchema.omit({
-    uuid: true,
-    preOrderUUID: true,
-})
-    .extend({
-        multiplicityOptionUUID: z.uuid().nullable().optional(),
-        categoryUUID: z.string().nullable().optional(),
-        name: z.string().nullable().optional(),
-        grower: z.string().nullable().optional(),
-        size: z.string().nullable().optional(),
-        price: MoneySchema.nullable().optional(),
-        color: z.string().nullable().optional(),
-        parentPreOrderProductUUID: z.string().nullable().optional(),
-        matchingConfig: MatchingConfigSchema.optional().nullable(),
-        imageUUID: z.string().uuid().nullable().optional(),
-    })
-    .partial();
-
-export const CreatePreOrderProductWebshopSchema = PreOrderProductSchema.omit({
-    uuid: true,
-    tag: true,
-    isPurchased: true,
-    categoryUUID: true,
-    name: true,
-    grower: true,
-    size: true,
-    price: true,
-    color: true,
-    parentPreOrderProductUUID: true,
-    matchingConfig: true,
-});
-
-export const UpdatePreOrderProductWebshopSchema = PreOrderProductSchema.omit({
-    uuid: true,
-    tag: true,
-    isPurchased: true,
-    preOrderUUID: true,
-    preOrderCollectionItemUUID: true,
-    categoryUUID: true,
-    name: true,
-    grower: true,
-    size: true,
-    price: true,
-    color: true,
-    parentPreOrderProductUUID: true,
-    matchingConfig: true,
-}).partial();
-
-export const PreOrderProductListSchema = z.object({
-    list: PreOrderProductSchema.array(),
-    total: z.number(),
-});
-
-export const preOrderProductExtendedListSchema = z.object({
-    list: PreOrderProductExtendedSchema.array(),
-    total: z.number(),
-});
-
-export const PreOrderProductStepperPositionSchema = z.object({
-    uuid: z.string(),
-    preOrderUUID: z.string(),
-    preOrderCollectionUUID: z.string().nullable(),
-    preOrderCollectionItemUUID: z.string().nullable(),
-    multiplicityOptionUUID: z.string().nullable().optional(),
-    multiplicityOptionTitle: z.string().nullable().optional(),
-    quantity: z.number(),
-    balance: z.number().nullable(),
-});
-
-export const ActiveStepperPositionsResponseSchema = z.object({
-    list: PreOrderProductStepperPositionSchema.array(),
-});
-
-export const SetPreOrderProductQuantityWebshopRequestSchema = z.object({
-    quantity: z.number().int().min(0),
-});
-
-export const SetPreOrderProductQuantityWebshopResponseSchema = z.object({
-    uuid: z.string().optional(),
-    quantity: z.number().optional(),
-    deleted: z.boolean().optional(),
-});
+export { MatchingConfigSchema } from './matching-config.schema';
+export { PreOrderProductSchema } from './pre-order-product-base.schema';
+export { PreOrderProductExtendedSchema } from './pre-order-product-extended.schema';
+export { CreatePreOrderProductSchema } from './create-pre-order-product.schema';
+export { UpdatePreOrderProductSchema } from './update-pre-order-product.schema';
+export { PreOrderProductListSchema } from './pre-order-product-list.schema';
+export { preOrderProductExtendedListSchema } from './pre-order-product-extended-list.schema';
+export { PreOrderProductStepperPositionSchema } from './pre-order-product-stepper-position.schema';
+export { ActiveStepperPositionsResponseSchema } from './active-stepper-positions-response.schema';
+export { SetPreOrderProductQuantityWebshopRequestSchema } from './set-pre-order-product-quantity-webshop-request.schema';
+export { SetPreOrderProductQuantityWebshopResponseSchema } from './set-pre-order-product-quantity-webshop-response.schema';
+export {
+    /** @deprecated Используйте CreatePreOrderProductWebshopRequestSchema. */
+    CreatePreOrderProductWebshopRequestSchema as CreatePreOrderProductWebshopSchema,
+} from './create-pre-order-product-webshop-request.schema';
+export {
+    /** @deprecated Используйте UpdatePreOrderProductWebshopRequestSchema. */
+    UpdatePreOrderProductWebshopRequestSchema as UpdatePreOrderProductWebshopSchema,
+} from './update-pre-order-product-webshop-request.schema';

package/schemas/pre-order-product/set-pre-order-product-quantity-webshop-request.schema.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const SetPreOrderProductQuantityWebshopRequestSchema = z.object({
+    quantity: z.number().int().min(0),
+});

package/schemas/pre-order-product/set-pre-order-product-quantity-webshop-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export const SetPreOrderProductQuantityWebshopResponseSchema = z.object({
+    uuid: z.string().optional(),
+    quantity: z.number().optional(),
+    deleted: z.boolean().optional(),
+});

package/schemas/pre-order-product/update-pre-order-product-webshop-request.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
+
+// Правка позиции предзаказа с витрины — без привязки к предзаказу и коллекции.
+export const UpdatePreOrderProductWebshopRequestSchema = z
+    .object({
+        multiplicityOptionUUID: z.uuid().nullable().optional(),
+        quantity: z.number().int().positive(),
+        comment: z.string().nullable(),
+        isReplaceable: z.boolean(),
+        stopPrice: MoneySchema.nullable(),
+        highAttention: z.boolean(),
+    })
+    .partial();

package/schemas/pre-order-product/update-pre-order-product-webshop-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderProductForClientSchema } from './pre-order-product-for-client.schema';
+
+export const UpdatePreOrderProductWebshopResponseSchema = z.object({
+    message: z.string().optional(),
+    data: PreOrderProductForClientSchema,
+});

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
+import { MatchingConfigSchema } from './matching-config.schema';
+import { PreOrderProductSchema } from './pre-order-product-base.schema';
+
+export const UpdatePreOrderProductSchema = PreOrderProductSchema.omit({
+    uuid: true,
+    preOrderUUID: true,
+})
+    .extend({
+        multiplicityOptionUUID: z.uuid().nullable().optional(),
+        categoryUUID: z.string().nullable().optional(),
+        name: z.string().nullable().optional(),
+        grower: z.string().nullable().optional(),
+        size: z.string().nullable().optional(),
+        price: MoneySchema.nullable().optional(),
+        color: z.string().nullable().optional(),
+        parentPreOrderProductUUID: z.string().nullable().optional(),
+        matchingConfig: MatchingConfigSchema.optional().nullable(),
+        imageUUID: z.string().uuid().nullable().optional(),
+    })
+    .partial();

package/schemas/product/get-product-list-for-client-request.schema.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { OrderByEnum, ProductClientSortByEnum, ProductMarkEnum } from '../../enum';
+
+export const GetProductListForClientRequestSchema = z.object({
+    page: z.string().transform(val => Number(val) || 1),
+    count: z.string().transform(val => Number(val) || 10),
+    stock: z
+        .string()
+        .transform(val => (val === 'true' ? true : val === 'false' ? false : undefined))
+        .optional(),
+    deliveryDates: z.coerce.date().array().optional(),
+    sizes: z.string().array().optional(),
+    colors: z.string().array().optional(),
+    growers: z.string().array().optional(),
+    countries: z.string().array().optional(),
+    categoryUUID: z.string().optional(),
+    typeUUID: z.string().optional(),
+    searchQuery: z.string().optional(),
+    marks: z.nativeEnum(ProductMarkEnum).array().optional(),
+    // Без `sortBy` порядок остаётся прежним — по категории, названию и размеру. Сортировка по цене
+    // идёт по базовому прайсу, скидки клиента её не двигают: см. ProductClientSortByEnum.
+    sortBy: z.nativeEnum(ProductClientSortByEnum).optional(),
+    // Без `.default()`: он уезжает в `_output`, а значит и в опубликованный `Request`, делая поле
+    // обязательным для клиентов. Отсутствующее направление билдер и так читает как ASC.
+    sortOrder: z.nativeEnum(OrderByEnum).optional(),
+});

package/schemas/product/get-product-list-for-client-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { ProductListExtendedForClientSchema } from './product-list-extended-for-client.schema';
+
+export const GetProductListForClientResponseSchema = z.object({
+    message: z.string().optional(),
+    data: ProductListExtendedForClientSchema,
+});

package/schemas/product/index.ts

@@ -0,0 +1,15 @@
+export * from './product-discount-price-for-client.schema';
+export * from './product.schema';
+export * from './product-list.schema';
+export * from './get-product-list-request.schema';
+export * from './get-product-list-response.schema';
+export * from './export-stock-products-request.schema';
+export * from './export-stock-products-response.schema';
+export * from './product-multiplicity-option.schema';
+export * from './product-multiplicity-option-for-client.schema';
+export * from './product-list-extended-for-client.schema';
+export * from './get-product-list-for-client-request.schema';
+export * from './get-product-list-for-client-response.schema';
+export * from './product-catalog-name.schema';
+export * from './product-image-for-client.schema';
+export * from './product-consignment-for-client.schema';

package/schemas/product/product-base.schema.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { ProductMarkEnum, SalesUnitEnum } from '../../enum';
+import { MoneySchema } from '../money.schema';
+
+export const ProductSchema = z.object({
+    uuid: z.uuid(),
+    consignmentUUID: z.uuid(),
+    categoryUUID: z.uuid().nullable(),
+    name: z.string(),
+
+    balance: z.number(),
+    quantity: z.number(),
+    price: MoneySchema,
+    costPrice: MoneySchema,
+    multiplicity: z.number(),
+    isOpen: z.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).nullable(),
+    marks: z.array(z.nativeEnum(ProductMarkEnum)),
+
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/schemas/product/product-catalog-name.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { LocalizedNameSchema } from '../i18n/localized-name.schema';
+
+export const ProductCatalogNameSchema = z.object({
+    uuid: z.string(),
+    name: z.string(),
+    nameTranslations: LocalizedNameSchema,
+});

package/schemas/product/product-consignment-for-client.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+
+export const ProductConsignmentForClientSchema = z.object({
+    deliveryDate: z.date(),
+    isInStock: z.boolean(),
+});

package/schemas/product/product-discount-price-for-client.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
+
+export const ProductDiscountPriceForClientSchema = z.object({
+    priceWithDiscount: MoneySchema,
+});

package/schemas/product/product-extended-for-admin-with-statistic.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { ProductExtendedForAdminSchema } from './product-extended-for-admin.schema';
+
+export const ProductExtendedForAdminWithStatistic = ProductExtendedForAdminSchema.merge(
+    z.object({
+        writeOffQuantity: z.number(),
+    }),
+);

package/schemas/product/product-extended-for-admin.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { ConsignmentSchema } from '../consignment/consignment.schema';
+import { ProductExtendedSchema } from './product-extended.schema';
+
+export const ProductExtendedForAdminSchema = ProductExtendedSchema.merge(
+    z.object({
+        consignment: ConsignmentSchema,
+    }),
+);

package/schemas/product/product-extended-for-client.schema.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { ProductCatalogNameSchema } from './product-catalog-name.schema';
+import { ProductImageForClientSchema } from './product-image-for-client.schema';
+import { ProductConsignmentForClientSchema } from './product-consignment-for-client.schema';
+import { ProductMultiplicityOptionForClientSchema } from './product-multiplicity-option-for-client.schema';
+import { ProductDiscountPriceForClientSchema } from './product-discount-price-for-client.schema';
+import { MoneySchema } from '../money.schema';
+import { ProductForClientSchema } from './product-for-client.schema';
+
+export const ProductExtendedForClientSchema = ProductForClientSchema.merge(
+    z.object({
+        category: ProductCatalogNameSchema.nullable(),
+        type: ProductCatalogNameSchema.nullable(),
+        image: ProductImageForClientSchema.nullable(),
+        consignment: ProductConsignmentForClientSchema,
+        multiplicityOptions: z.array(ProductMultiplicityOptionForClientSchema).optional(),
+        /**
+         * Сохранён для совместимости и содержит только цену, без данных правил.
+         * @deprecated Используйте priceWithBestDiscount.
+         */
+        discountDataList: ProductDiscountPriceForClientSchema.array().optional(),
+        /**
+         * Лучшая цена базового тарифа после скидки. `null` — скидка неприменима.
+         *
+         * Отдельное поле, потому что «лучшая» — это выбор, а не порядок: раньше клиент брал
+         * `discountDataList[0]`, полагаясь на сортировку бэка, которая нигде не зафиксирована.
+         * Выбор делает бэк.
+         */
+        priceWithBestDiscount: MoneySchema.nullable().optional(),
+    }),
+);

package/schemas/product/product-extended.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { ProductImageSchema } from '../product-image/product-image.schema';
+import { CategorySchema } from '../category/category.schema';
+import { TypeSchema } from '../type/type.schema';
+import { ProductMultiplicityOptionSchema } from './product-multiplicity-option.schema';
+import { ProductSchema } from './product-base.schema';
+
+export const ProductExtendedSchema = ProductSchema.merge(
+    z.object({
+        category: CategorySchema.nullable(),
+        type: TypeSchema.nullable(),
+        image: ProductImageSchema.nullable(),
+        multiplicityOptions: z.array(ProductMultiplicityOptionSchema).optional(),
+    }),
+);

package/schemas/product/product-for-client.schema.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { ProductMarkEnum, SalesUnitEnum } from '../../enum';
+import { MoneySchema } from '../money.schema';
+
+export const ProductForClientSchema = z.object({
+    uuid: z.uuid(),
+    name: z.string(),
+    balance: z.number(),
+    price: MoneySchema,
+    multiplicity: z.number(),
+    article: z.string().nullable(),
+    barcode: z.string().nullable(),
+    color: z.string().nullable(),
+    size: z.string().nullable(),
+    size2: z.string().nullable(),
+    size3: z.string().nullable(),
+    country: z.string().nullable(),
+    description: z.string().nullable(),
+    grower: z.string().nullable(),
+    multiplicityDescription: z.string().nullable(),
+    salesUnit: z.nativeEnum(SalesUnitEnum).nullable(),
+    marks: z.array(z.nativeEnum(ProductMarkEnum)),
+});

package/schemas/product/product-image-for-client.schema.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const ProductImageForClientSchema = z.object({
+    productImageUrl: z.string(),
+});

package/schemas/product/product-list-extended-for-client.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { ProductExtendedForClientSchema } from './product-extended-for-client.schema';
+
+export const ProductListExtendedForClientSchema = z.object({
+    productList: ProductExtendedForClientSchema.array(),
+    total: z.number(),
+});

package/schemas/product/product-list.schema.ts

@@ -1,12 +1,8 @@
 import { z } from 'zod';
-import { ProductExtendedForClientSchema, ProductExtendedForAdminWithStatistic } from './product.schema';
-
-export const ProductListExtendedForClientSchema = z.object({
-    productList: ProductExtendedForClientSchema.array(),
-    total: z.number(),
-});
+import { ProductExtendedForAdminWithStatistic } from './product-extended-for-admin-with-statistic.schema';
 
 export const ProductListSchema = z.object({
     productList: ProductExtendedForAdminWithStatistic.array(),
     total: z.number(),
 });
+export { ProductListExtendedForClientSchema } from './product-list-extended-for-client.schema';