@pksep/zod-shared 0.0.490

package/dist/utils/methods/operations.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeComplitedForOperations = exports.findMinKolByMarksOperations = exports.timeComplitedForOperation = void 0;
+exports.countCreateMarks = countCreateMarks;
+const _ = __importStar(require("lodash"));
+const methods_1 = require("../methods");
+/**
+ * Рассчитывает время выполнения операции
+ *
+ * Время выполнении =
+ * Подготовительное + ((главное + вспомогательное) * кол-во операций) / 60
+ **/
+const timeComplitedForOperation = (operation, quantity = 1) => {
+    const preTime = Number(operation.preTime);
+    const mainTime = Number(operation.mainTime);
+    const helperTime = Number(operation.helperTime);
+    const executionTime = _.round(preTime + (mainTime + helperTime) * quantity, 1);
+    return {
+        executionTime,
+        preTime,
+        mainTime,
+        helperTime
+    };
+};
+exports.timeComplitedForOperation = timeComplitedForOperation;
+/**
+ * возвращает максимальное количество возможных к оприходыванию по созданным отметкам
+ */
+const findMinKolByMarksOperations = (operations) => {
+    let min = Infinity;
+    for (const operation of operations) {
+        const operationMarks = (operation === null || operation === void 0 ? void 0 : operation.marks) || [];
+        const create = operationMarks.reduce((prev, current) => {
+            if (!current.brak && !current.ban)
+                prev += (0, methods_1.moreMinusNum)(current.kol - current.quantity_shipped);
+            return prev;
+        }, 0);
+        if (create < min)
+            min = create;
+    }
+    return min;
+};
+exports.findMinKolByMarksOperations = findMinKolByMarksOperations;
+/**
+ * Функция для подсчета времени выполнения операций
+ */
+const timeComplitedForOperations = (operations, quantity = 1) => operations.reduce((prevValue, operation) => prevValue + (0, exports.timeComplitedForOperation)(operation, quantity).executionTime, 0);
+exports.timeComplitedForOperations = timeComplitedForOperations;
+/**
+ * Возвращает актуальное количество сделанных отметок по операции
+ * @param {*} oper
+ * @returns number
+ */
+function countCreateMarks(operation, brakConsider = true) {
+    var _a;
+    if (!((_a = operation === null || operation === void 0 ? void 0 : operation.marks) === null || _a === void 0 ? void 0 : _a.length))
+        return 0;
+    return operation.marks.reduce((kol, mark) => {
+        return (kol +
+            (brakConsider && mark.brak
+                ? 0
+                : (0, methods_1.moreMinusNum)(mark.kol - mark.quantity_shipped)));
+    }, 0);
+}

package/dist/utils/methods/quantity.d.ts

@@ -0,0 +1,6 @@
+import { ModelCbed } from '../../cbed';
+import { ModelDetal } from '../../detal';
+import { ModelProduct } from '../../product';
+type TypeModels = ModelProduct | ModelDetal | ModelCbed;
+export declare const myQuantityForDeficit: (entity: TypeModels) => number;
+export {};

package/dist/utils/methods/quantity.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.myQuantityForDeficit = void 0;
+const methods_1 = require("../methods");
+const isModalProduct = (entity) => {
+    return (entity !== null &&
+        typeof entity === 'object' &&
+        !('deficit_by_sclad' in entity ||
+            'cbed' in entity ||
+            'remainder_after_coming' in entity));
+};
+const myQuantityForDeficit = (entity) => {
+    const shipments_kolvo = isModalProduct(entity)
+        ? Number(entity.shipments_kolvo)
+        : 0;
+    const deficit_by_sclad = !isModalProduct(entity)
+        ? Number(entity.deficit_by_sclad)
+        : 0;
+    return (0, methods_1.moreMinusNum)(entity.min_remaining * 3 +
+        shipments_kolvo +
+        deficit_by_sclad -
+        (entity.quantity + entity.production_ordered));
+};
+exports.myQuantityForDeficit = myQuantityForDeficit;

package/dist/utils/methods/sequelize.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Упрощает добавление поля в запрос sequelie
+ * @param conditions
+ * @param query
+ * @returns
+ *
+ * @example
+ * id: {
+      [Op.in]: filterByOnly.cbedIds,
+      ...(filterByOnly.cbedIds.length > 0
+        ? { id: { [Op.in]: filterByOnly.cbedIds } }
+        : {})
+    }
+    TO:
+    ...addFieldByCondition(filterByOnly.cbedIds.length, {
+      id: { [Op.in]: filterByOnly.cbedIds }
+    })
+ */
+export declare const addFieldByCondition: (conditions: any, query: any) => any;

package/dist/utils/methods/sequelize.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addFieldByCondition = void 0;
+/**
+ * Упрощает добавление поля в запрос sequelie
+ * @param conditions
+ * @param query
+ * @returns
+ *
+ * @example
+ * id: {
+      [Op.in]: filterByOnly.cbedIds,
+      ...(filterByOnly.cbedIds.length > 0
+        ? { id: { [Op.in]: filterByOnly.cbedIds } }
+        : {})
+    }
+    TO:
+    ...addFieldByCondition(filterByOnly.cbedIds.length, {
+      id: { [Op.in]: filterByOnly.cbedIds }
+    })
+ */
+const addFieldByCondition = (conditions, query) => conditions ? query : {};
+exports.addFieldByCondition = addFieldByCondition;

package/dist/utils/methods/shipments.d.ts

@@ -0,0 +1,23 @@
+import { ActionEntityTypes } from '../../action';
+import { ModelShipments } from '../../shipments';
+import { EntityCommonSpecification } from '../types/types';
+/**
+ * Функция для соединения списка деталей и сборок в один массив.
+ * Перерасчитывает quantity каждой позиции, умножая его на переданный kol.
+ */
+export declare const organiseListToFormat: (data: {
+    listDetal: EntityCommonSpecification[];
+    listCbed: EntityCommonSpecification[];
+    quantity: number;
+}) => (EntityCommonSpecification & {
+    type: ActionEntityTypes;
+})[];
+/**
+ * Находит объект в Спецификации заказа по типу и id объекта
+ * Возвращает кол-во заказанного объекта для конкретного зкаказа
+ * @param type
+ * @param id
+ * @param shipmnets
+ * @returns
+ */
+export declare const findQuantityInShipmentSpecification: (type: string, id: number, shipmnets: ModelShipments) => number;

package/dist/utils/methods/shipments.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findQuantityInShipmentSpecification = exports.organiseListToFormat = void 0;
+const action_1 = require("../../action");
+const enums_1 = require("../enums");
+/**
+ * Функция для соединения списка деталей и сборок в один массив.
+ * Перерасчитывает quantity каждой позиции, умножая его на переданный kol.
+ */
+const organiseListToFormat = (data) => {
+    var _a, _b;
+    const list1 = ((_a = data.listCbed) === null || _a === void 0 ? void 0 : _a.map(cbed => {
+        return Object.assign(Object.assign({}, cbed), { type: action_1.ActionEntityTypes.cbed, quantity: cbed.quantity * data.quantity });
+    })) || [];
+    const list2 = ((_b = data.listDetal) === null || _b === void 0 ? void 0 : _b.map(detal => {
+        return Object.assign(Object.assign({}, detal), { type: action_1.ActionEntityTypes.detal, quantity: detal.quantity * data.quantity });
+    })) || [];
+    const concatedData = list1.concat(list2);
+    return concatedData;
+};
+exports.organiseListToFormat = organiseListToFormat;
+/**
+ * Находит объект в Спецификации заказа по типу и id объекта
+ * Возвращает кол-во заказанного объекта для конкретного зкаказа
+ * @param type
+ * @param id
+ * @param shipmnets
+ * @returns
+ */
+const findQuantityInShipmentSpecification = (type, id, shipmnets) => {
+    if (type === enums_1.IzdType.product) {
+        if (shipmnets.productId === id) {
+            return Number(shipmnets.kol);
+        }
+        return 0;
+    }
+    const pars_spec = (0, exports.organiseListToFormat)({
+        quantity: shipmnets.kol,
+        listCbed: shipmnets.product.listCbed,
+        listDetal: shipmnets.product.listDetal
+    });
+    let quantity = 0;
+    for (const item of pars_spec) {
+        if (type != item.type)
+            continue;
+        if (id === item.id)
+            quantity += Number(item.quantity);
+    }
+    return quantity;
+};
+exports.findQuantityInShipmentSpecification = findQuantityInShipmentSpecification;

package/dist/utils/methods/snake-conversion.d.ts

@@ -0,0 +1,19 @@
+type CamelToSnake<T> = T extends Array<infer U> ? Array<CamelToSnake<U>> : T extends Record<string, any> ? {
+    [K in keyof T as K extends string ? K extends `${infer A}${infer B}` ? `${A extends Uppercase<A> ? A : Lowercase<A>}${B extends Uppercase<B> ? `_${Lowercase<B>}` : B extends string ? B : ''}` : K : never]: CamelToSnake<T[K]>;
+} : T;
+type SnakeToCamel<T> = T extends Array<infer U> ? Array<SnakeToCamel<U>> : T extends Record<string, any> ? {
+    [K in keyof T as K extends string ? K extends `${string}_${string}` ? K extends `${infer A}_${infer B}` ? `${A}${Capitalize<SnakeToCamel<B>>}` : K : K : never]: SnakeToCamel<T[K]>;
+} : T;
+/**
+ * Converts object keys from camelCase to snake_case
+ * @param obj The object to convert
+ * @returns A new object with snake_case keys
+ */
+export declare function camelToSnake<T>(obj: T): CamelToSnake<T>;
+/**
+ * Converts object keys from snake_case to camelCase
+ * @param obj The object to convert
+ * @returns A new object with camelCase keys
+ */
+export declare function snakeToCamel<T>(obj: T): SnakeToCamel<T>;
+export {};

package/dist/utils/methods/snake-conversion.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.camelToSnake = camelToSnake;
+exports.snakeToCamel = snakeToCamel;
+/**
+ * Converts object keys from camelCase to snake_case
+ * @param obj The object to convert
+ * @returns A new object with snake_case keys
+ */
+function camelToSnake(obj) {
+    if (obj === null ||
+        obj === undefined ||
+        typeof obj !== 'object' ||
+        obj instanceof Date ||
+        obj instanceof RegExp) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(item => camelToSnake(item));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        // Convert camelCase key to snake_case
+        const snakeKey = key.replace(/([a-z\d])([A-Z])/g, '$1_$2').toLowerCase();
+        result[snakeKey] = camelToSnake(value);
+    }
+    return result;
+}
+/**
+ * Converts object keys from snake_case to camelCase
+ * @param obj The object to convert
+ * @returns A new object with camelCase keys
+ */
+function snakeToCamel(obj) {
+    if (obj === null ||
+        obj === undefined ||
+        typeof obj !== 'object' ||
+        obj instanceof Date ||
+        obj instanceof RegExp) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(item => snakeToCamel(item));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const camelKey = key.replace(/_([a-z])/g, (match, letter) => letter.toUpperCase());
+        result[camelKey] = snakeToCamel(value);
+    }
+    return result;
+}

package/dist/utils/methods/utils.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+/**
+ * Функция формирует ответ сервера функции пагинации
+ */
+export declare const createPaginatedResponseSchema: <T extends z.ZodTypeAny>(itemSchema: T) => z.ZodObject<{
+    count: z.ZodNumber;
+    rows: z.ZodArray<T, "many">;
+}, "strip", z.ZodTypeAny, {
+    count: number;
+    rows: T["_output"][];
+}, {
+    count: number;
+    rows: T["_input"][];
+}>;
+export declare const generateRandomKeys: (key: string) => string;

package/dist/utils/methods/utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandomKeys = exports.createPaginatedResponseSchema = void 0;
+const crypto_1 = require("crypto");
+const zod_1 = require("zod");
+/**
+ * Функция формирует ответ сервера функции пагинации
+ */
+const createPaginatedResponseSchema = (itemSchema) => zod_1.z.object({
+    count: zod_1.z.number().int(),
+    rows: zod_1.z.array(itemSchema)
+});
+exports.createPaginatedResponseSchema = createPaginatedResponseSchema;
+const generateRandomKeys = (key) => {
+    const hash = (0, crypto_1.randomUUID)();
+    return `:${key}#${hash}`;
+};
+exports.generateRandomKeys = generateRandomKeys;