@pksep/zod-shared 0.0.490

package/dist/user/schemas/user.schema.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSchema = void 0;
+const zod_1 = require("zod");
+const document_1 = require("../../document");
+const cbed_1 = require("../../cbed");
+const product_1 = require("../../product");
+const actions_schema_1 = require("../../action/schemas/actions.schema");
+const operations_1 = require("../../operations");
+const model_1 = require("../default-value/model");
+const enums_1 = require("../enums");
+exports.UserSchema = zod_1.z.object({
+    id: zod_1.z.number().int().positive(),
+    initial: zod_1.z.string().nonempty(),
+    remote_work: zod_1.z.boolean().default(false),
+    tabel: zod_1.z.string().nonempty(),
+    dateWork: zod_1.z.string().nullable(),
+    dateUnWork: zod_1.z.string().nullable(),
+    requisites: zod_1.z
+        .array(zod_1.z.custom())
+        .default(model_1.defaultUserRequisitesUserValue),
+    birthday: zod_1.z.string().nullable(),
+    login: zod_1.z.string().nullable(),
+    haracteristic: zod_1.z.string().nullable(),
+    primetch: zod_1.z.string().nullable(),
+    password: zod_1.z.string().nonempty(),
+    ban: zod_1.z.boolean().default(false),
+    banReason: zod_1.z.string().nullable(),
+    image: zod_1.z.string().nullish(),
+    session_id: zod_1.z.number().int().nullable(),
+    last_online: zod_1.z.number().int().nullable(),
+    rolesId: zod_1.z.number().int(),
+    role: zod_1.z.any(),
+    documents: zod_1.z.array(document_1.DocumentsSchema),
+    cbeds: zod_1.z.array(cbed_1.CbedSchema),
+    products: zod_1.z.array(product_1.ProductSchema),
+    actions: zod_1.z.array(actions_schema_1.ActionsSchema),
+    responsibleForProduct: zod_1.z.array(product_1.ProductSchema),
+    responsibleForDocuments: zod_1.z.array(document_1.DocumentsSchema),
+    typeOperations: zod_1.z.array(operations_1.TypeOperationSchema),
+    subdivision: enums_1.EnumSubdivisionZod.optional()
+});

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

@@ -0,0 +1,68 @@
+/**
+ * @returns date: DD.MM.YYYY
+ * @returns time: H:M.S
+ */
+export declare class DateMethods {
+    constructor();
+    dt: any;
+    year: any;
+    month: any;
+    day: any;
+    hours: any;
+    minute: any;
+    seconds: any;
+    date: () => any;
+    time: () => string;
+    /**
+     * Сравнение дат
+     * @param one_date
+     * @param two_date
+     * @param operation
+     * @returns
+     */
+    comparison: (one_date?: string, two_date?: string, operation?: string) => boolean;
+    /**
+     * Функция возвращает текущее время в UTC формате
+     * @param config
+     * @returns
+     */
+    getUTCDate: (config?: {
+        isNow: boolean;
+    }) => Date;
+    /**
+     * Приводим дату из
+     * Wed Mar 20 2024 12:12:19 GMT+0300 (Moscow Standard Time)
+     * к
+     * 2024-03-20 12:12:19.000+03
+     * @param {*} time
+     * @returns string
+     */
+    formatToPostgresTimeFromat: (time: string | Date) => string;
+    /**
+     * Приводим дату из
+     * DD.MM.YYYY
+     * к
+     * MM.DD.YYYY
+     * @param {*} time
+     * @returns date
+     */
+    toJsDateFormat: (time: string | Date) => Date;
+    /**
+     * '08.08.2000' => new Date()
+     * @param date
+     * @returns
+     */
+    stringToUtf(date: string): string | null;
+    /**
+     * возвращает количество дней между датами
+     * @param startDay = '2021-12-13 00:00:00+03'
+     * @param endDay ='2021-12-13 00:00:00+03'
+     * @returns number
+     */
+    dayFrom: (startDay: (Date | null) | undefined, endDay: Date) => number;
+    /**
+     * Принимает две даты формата DD.MM.YYYY если третий параметр указан по умолчанию,
+     * Сравнивает и возвращает количество прошедщих дней с текущего.
+     */
+    dateDifference: (date_one: string | undefined, date_two: string, prepare?: boolean) => number;
+}

package/dist/utils/date.methods.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateMethods = void 0;
+/**
+ * @returns date: DD.MM.YYYY
+ * @returns time: H:M.S
+ */
+class DateMethods {
+    constructor() {
+        this.date = () => this.dt.toISOString().slice(0, 10).split('-').reverse().join('.');
+        this.time = () => `${this.hours}:${this.minute}:${this.seconds}`;
+        /**
+         * Сравнение дат
+         * @param one_date
+         * @param two_date
+         * @param operation
+         * @returns
+         */
+        this.comparison = (one_date = new Date().toLocaleDateString('ru-RU'), two_date = new Date().toLocaleDateString('ru-RU'), operation = '==') => {
+            let result;
+            const d1 = this.stringToUtf(one_date);
+            const d2 = this.stringToUtf(two_date);
+            if (d1 === null || d2 === null) {
+                throw new Error('Invalid date format');
+            }
+            switch (operation) {
+                case '==':
+                    result = Date.parse(d1) === Date.parse(d2);
+                    break;
+                case '<':
+                    result = Date.parse(d1) < Date.parse(d2);
+                    break;
+                case '>':
+                    result = Date.parse(d1) > Date.parse(d2);
+                    break;
+                case '<=':
+                    result = Date.parse(d1) <= Date.parse(d2);
+                    break;
+                case '>=':
+                    result = Date.parse(d1) >= Date.parse(d2);
+                    break;
+                case '!=':
+                    result = Date.parse(d1) !== Date.parse(d2);
+                    break;
+                default:
+                    throw new Error('Invalid operation');
+            }
+            return result;
+        };
+        /**
+         * Функция возвращает текущее время в UTC формате
+         * @param config
+         * @returns
+         */
+        this.getUTCDate = (config = { isNow: false }) => {
+            const nowDate = !config.isNow
+                ? new Date(this.dt.setHours(0, 0, 0, 0))
+                : this.dt;
+            return new Date(Date.UTC(this.year, this.dt.getMonth(), this.day, nowDate.getHours(), nowDate.getMinutes(), nowDate.getSeconds()));
+        };
+        /**
+         * Приводим дату из
+         * Wed Mar 20 2024 12:12:19 GMT+0300 (Moscow Standard Time)
+         * к
+         * 2024-03-20 12:12:19.000+03
+         * @param {*} time
+         * @returns string
+         */
+        this.formatToPostgresTimeFromat = (time) => new Date(time).toLocaleString('sv-SE') + '.000+03';
+        /**
+         * Приводим дату из
+         * DD.MM.YYYY
+         * к
+         * MM.DD.YYYY
+         * @param {*} time
+         * @returns date
+         */
+        this.toJsDateFormat = (time) => {
+            const startDate = `${time}`.split('.');
+            return new Date([startDate[1], startDate[0], startDate[2]].join('.'));
+        };
+        /**
+         * возвращает количество дней между датами
+         * @param startDay = '2021-12-13 00:00:00+03'
+         * @param endDay ='2021-12-13 00:00:00+03'
+         * @returns number
+         */
+        this.dayFrom = (startDay = new Date(), endDay) => {
+            if (!endDay)
+                return 0;
+            const startDayDate = startDay ? startDay : new Date();
+            const diffInMillis = endDay.getTime() - startDayDate.getTime();
+            const diffInDays = diffInMillis / (1000 * 60 * 60 * 24);
+            return Math.ceil(diffInDays);
+        };
+        /**
+         * Принимает две даты формата DD.MM.YYYY если третий параметр указан по умолчанию,
+         * Сравнивает и возвращает количество прошедщих дней с текущего.
+         */
+        this.dateDifference = (date_one = new Date().toLocaleString('ru-RU').split(',')[0], date_two, prepare = true) => {
+            if (!date_two)
+                return 0;
+            const toFormatString = (date) => {
+                const spl = date.split('.');
+                return `${spl[2]}-${spl[1]}-${spl[0]}T10:20:30Z`;
+            };
+            const date1 = new Date(toFormatString(date_one));
+            const date2 = prepare
+                ? new Date(toFormatString(date_two))
+                : new Date(date_two);
+            const mat = Math.ceil(Math.abs(date2.getTime() - date1.getTime()) / (1000 * 3600 * 24));
+            return date2.getTime() < date1.getTime() ? -mat : mat;
+        };
+        this.dt = new Date();
+        this.year = this.dt.getFullYear();
+        this.month = this.dt.getMonth() + 1;
+        this.day = this.dt.getDate();
+        this.hours = this.dt.getUTCHours() + 3;
+        this.minute =
+            this.dt.getMinutes().toString().length === 1
+                ? '0' + this.dt.getMinutes()
+                : this.dt.getMinutes();
+        this.seconds =
+            this.dt.getSeconds().toString().length === 1
+                ? '0' + this.dt.getSeconds()
+                : this.dt.getSeconds();
+    }
+    /**
+     * '08.08.2000' => new Date()
+     * @param date
+     * @returns
+     */
+    stringToUtf(date) {
+        var _a, _b;
+        if (!date)
+            return null;
+        const ds = ((_b = (_a = date === null || date === void 0 ? void 0 : date.split('.')) === null || _a === void 0 ? void 0 : _a.reverse()) === null || _b === void 0 ? void 0 : _b.join('-')) + 'T10:10:10Z';
+        return ds;
+    }
+}
+exports.DateMethods = DateMethods;

package/dist/utils/default-value/default-value.d.ts

@@ -0,0 +1,12 @@
+import { ProductionTimeType } from '../types/types';
+export declare const defaultProducitonTime: ProductionTimeType;
+export declare const defaultUnitsMeasurement: {
+    unitTypeId: number;
+    convertRate: number;
+    isBase: boolean;
+}[];
+export declare const emptyTimeResponse: {
+    totalTimePerItem: number;
+    totalTime: number;
+    totalRemainingTime: number;
+};

package/dist/utils/default-value/default-value.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyTimeResponse = exports.defaultUnitsMeasurement = exports.defaultProducitonTime = void 0;
+exports.defaultProducitonTime = {
+    mainTime: 0,
+    preTime: 0,
+    helperTime: 0
+};
+exports.defaultUnitsMeasurement = [
+    {
+        unitTypeId: 1,
+        convertRate: 1,
+        isBase: true
+    },
+    {
+        unitTypeId: 3,
+        convertRate: 1,
+        isBase: false
+    }
+];
+exports.emptyTimeResponse = {
+    totalTimePerItem: 0,
+    totalTime: 0,
+    totalRemainingTime: 0
+};

package/dist/utils/edizm.d.ts

@@ -0,0 +1,40 @@
+import { IUnitsMeasurement } from '../material';
+import { UnitsEnum } from './enums';
+import { IgetFirstUnits } from './types';
+/**
+ * Получаем выбраную Единицу измерения из материала
+ * @param {*} mat
+ * @returns
+ */
+declare const getFirstUnits: (mat: IgetFirstUnits) => number;
+/**
+ * Вернуть по id ЕИ название
+ * @param {*} units_type
+ * @returns
+ */
+declare function returnEzName(units_type: number): string;
+declare function getAvailableUnitIdsByName(units: UnitsEnum[]): number[];
+/**
+ * Возвращает массив id единиц измерения, доступных для использования
+ * по массиву структуры единиц измерения из материалов
+ * @param measurenents
+ * @returns
+ */
+declare function getAvailableUnitsIdsByUnitsMeasurementStructure(measurenents: IUnitsMeasurement[]): number[];
+/**
+ * парсит и возвращает массив материалов из детали
+ * @param {*} detals[]
+ * @return [{id: number}]
+ */
+declare function parsMaterialFromDetal(detals: any): {
+    id: number;
+}[] | undefined;
+/**
+ * парсит и возвращает массив материалов из сборок и Изделий
+ * @param {*} cbeds[]products[]
+ * @return [{id: number}]
+ */
+declare function parsMaterialFromCbedAndProduct(objects: any): {
+    id: number;
+}[] | undefined;
+export { returnEzName, parsMaterialFromDetal, parsMaterialFromCbedAndProduct, getFirstUnits, getAvailableUnitIdsByName, getAvailableUnitsIdsByUnitsMeasurementStructure };

package/dist/utils/edizm.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFirstUnits = void 0;
+exports.returnEzName = returnEzName;
+exports.parsMaterialFromDetal = parsMaterialFromDetal;
+exports.parsMaterialFromCbedAndProduct = parsMaterialFromCbedAndProduct;
+exports.getAvailableUnitIdsByName = getAvailableUnitIdsByName;
+exports.getAvailableUnitsIdsByUnitsMeasurementStructure = getAvailableUnitsIdsByUnitsMeasurementStructure;
+const edizm_1 = require("../edizm");
+/**
+ * Получаем выбраную Единицу измерения из материала
+ * @param {*} mat
+ * @returns
+ */
+const getFirstUnits = (mat) => {
+    if (!(mat === null || mat === void 0 ? void 0 : mat.units_measurement))
+        return 1;
+    let units_type = 1;
+    for (const item of mat.units_measurement) {
+        if (item.used)
+            units_type = item.units_type;
+    }
+    return units_type;
+};
+exports.getFirstUnits = getFirstUnits;
+/**
+ * Вернуть по id ЕИ название
+ * @param {*} units_type
+ * @returns
+ */
+function returnEzName(units_type) {
+    if (!units_type)
+        return '';
+    switch (units_type) {
+        case 1:
+            return 'шт';
+        case 2:
+            return 'л';
+        case 3:
+            return 'кг';
+        case 4:
+            return 'м';
+        case 5:
+            return 'м.куб';
+        default:
+            return 'шт';
+    }
+}
+function getAvailableUnitIdsByName(units) {
+    const unitIds = [];
+    for (const unitType of units) {
+        unitIds.push(edizm_1.EdizmIdByName[unitType]);
+    }
+    return unitIds;
+}
+/**
+ * Возвращает массив id единиц измерения, доступных для использования
+ * по массиву структуры единиц измерения из материалов
+ * @param measurenents
+ * @returns
+ */
+function getAvailableUnitsIdsByUnitsMeasurementStructure(measurenents) {
+    const unitsIds = [];
+    for (const measurenent of measurenents) {
+        if (measurenent.unitTypeId)
+            unitsIds.push(measurenent.unitTypeId);
+    }
+    return unitsIds;
+}
+/**
+ * Функция конкатенирует материалы из спецификации и возвращает их
+ * @param materialList
+ * @param listPokDet
+ * @returns
+ */
+function parsMaterialFromSpetification(materialList, listPokDet = []) {
+    const concats = materialList.concat(listPokDet);
+    return concats;
+}
+/**
+ * парсит и возвращает массив материалов из детали
+ * @param {*} detals[]
+ * @return [{id: number}]
+ */
+function parsMaterialFromDetal(detals) {
+    try {
+        const materials = [];
+        for (const detal of detals) {
+            const { materialList, mat_zag } = detal;
+            const parsMaterials = parsMaterialFromSpetification(materialList);
+            for (const material of parsMaterials || []) {
+                if (material === null || material === void 0 ? void 0 : material.id)
+                    materials.push({ id: material === null || material === void 0 ? void 0 : material.id });
+            }
+            if (mat_zag)
+                materials.push({ id: mat_zag });
+        }
+        return materials;
+    }
+    catch (err) {
+        console.log(err);
+    }
+}
+/**
+ * парсит и возвращает массив материалов из сборок и Изделий
+ * @param {*} cbeds[]products[]
+ * @return [{id: number}]
+ */
+function parsMaterialFromCbedAndProduct(objects) {
+    try {
+        const materials = [];
+        for (const item of objects) {
+            const { materialList, listPokDet } = item;
+            const parsMaterials = parsMaterialFromSpetification(materialList, listPokDet);
+            for (const material of parsMaterials || []) {
+                if (material === null || material === void 0 ? void 0 : material.id)
+                    materials.push({ id: material === null || material === void 0 ? void 0 : material.id });
+            }
+        }
+        return materials;
+    }
+    catch (err) {
+        console.log(err);
+    }
+}