@pksep/zod-shared 0.0.490

package/dist/utils/moving.d.ts

@@ -0,0 +1,11 @@
+declare enum PositionToEnum {
+    top = "top",
+    bottom = "bottom"
+}
+export interface IPositionMovingParams {
+    inx: number;
+    positionTo: PositionToEnum;
+    items: any[];
+}
+export declare const movingPositionsInArray: (data: IPositionMovingParams) => any[];
+export {};

package/dist/utils/moving.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.movingPositionsInArray = void 0;
+var PositionToEnum;
+(function (PositionToEnum) {
+    PositionToEnum["top"] = "top";
+    PositionToEnum["bottom"] = "bottom";
+})(PositionToEnum || (PositionToEnum = {}));
+const movingPositionsInArray = (data) => {
+    try {
+        const findItem = data.items[data.inx];
+        if (!findItem)
+            return data.items;
+        if (data.positionTo === PositionToEnum.top && data.items[data.inx - 1]) {
+            data.items[data.inx] = data.items[data.inx - 1];
+            data.items[data.inx - 1] = findItem;
+        }
+        else if (data.positionTo === PositionToEnum.bottom &&
+            data.items[data.inx + 1]) {
+            data.items[data.inx] = data.items[data.inx + 1];
+            data.items[data.inx + 1] = findItem;
+        }
+        return data.items;
+    }
+    catch (err) {
+        console.error(err);
+        return data.items;
+    }
+};
+exports.movingPositionsInArray = movingPositionsInArray;

package/dist/utils/operation.d.ts

@@ -0,0 +1,64 @@
+import { detalParametrsField } from '../detal';
+import { ModelOperation } from '../operations';
+import { StatusWorkingsEnum } from './types';
+export declare const useCalcParametersDetals: (parametrs: any, operations: ModelOperation[]) => detalParametrsField;
+export declare const useCalcParametersCbedProduct: (operations: ModelOperation[]) => number;
+export declare const useCalcParametersCbedProductMinute: (operations: ModelOperation[]) => number;
+/**
+ * Функция проверяет, является ли операция готовой исходя из созданных отметок
+ * @param techProcesses
+ * @param operationId
+ * @param currentId
+ * @param returnIds
+ * @returns
+ */
+export declare function getStatus(techProcesses: any, operationId: number, currentId?: number, returnIds?: string): Promise<number | false | "<p class=\"success_operation\">Готово</p>" | "<p class=\"work_operation\">В процессе</p>" | undefined>;
+/**
+ * Специальный класс для формирования объекта времени выполнения операции
+ */
+export declare class OperationTime {
+    preTime: number;
+    mainTime: number;
+    helperTime: number;
+    count: number;
+    constructor(operation: {
+        preTime: number;
+        mainTime: number;
+        helperTime: number;
+    } | null, count?: number);
+    private timeKolvo;
+}
+export declare function worksHors(operation: any, kolvo_all?: number): number;
+/**
+ * Функция получает время выполнения
+ * @param operation
+ * @param marks
+ * @returns
+ */
+export declare function workingForMarks(operation: any, marks: any[]): number;
+/**
+ *
+ * @param {*} work - metall || ass
+ * @returns
+ */
+export declare function getPrecentNumberOperation(work: any, folder?: string, full_folder?: string): number;
+export declare const statusWorkings: string[];
+export declare function returnStatus(status: StatusWorkingsEnum, precent?: number): string;
+/**
+ * Процент готовности, рассчитывается соотношения заказанного кол-ва
+ * и кол-ва отметок об выполнении во всех операциях
+ * @param {*} work - metall || ass
+ * @returns
+ */
+export declare const precentWorksAsOperation: (work: any, brak?: boolean) => string | number;
+/**
+ * Процент готовности, рассчитывается соотношения заказанного кол-ва
+ * и кол-ва отметок об выполнении во всех операциях
+ * @param {*} work - metall || ass
+ * @returns
+ */
+export declare const calculatePercentWork: (data: {
+    operations: ModelOperation[];
+    quantityOrder: number;
+    brak: boolean;
+}) => number;

package/dist/utils/operation.js

@@ -0,0 +1,223 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculatePercentWork = exports.precentWorksAsOperation = exports.statusWorkings = exports.OperationTime = exports.useCalcParametersCbedProductMinute = exports.useCalcParametersCbedProduct = exports.useCalcParametersDetals = void 0;
+exports.getStatus = getStatus;
+exports.worksHors = worksHors;
+exports.workingForMarks = workingForMarks;
+exports.getPrecentNumberOperation = getPrecentNumberOperation;
+exports.returnStatus = returnStatus;
+const methods_1 = require("./methods");
+const types_1 = require("./types");
+const workings_1 = require("./workings");
+const useCalcParametersDetals = (parametrs, operations) => {
+    let newPreTime = 0;
+    let newHelperTime = 0;
+    let newMainTime = 0;
+    if (operations.length)
+        operations.forEach(op => {
+            newPreTime += Number(op.preTime);
+            newHelperTime += Number(op.helperTime);
+            newMainTime += Number(op.mainTime);
+        });
+    parametrs.preTime.znach = newPreTime;
+    parametrs.helperTime.znach = newHelperTime;
+    parametrs.mainTime.znach = newMainTime;
+    const newParametrs = {};
+    for (const key of Object.keys(parametrs)) {
+        const znach = parametrs[key].znach
+            ? parseFloat((parametrs[key].znach / 60).toFixed(2))
+            : 0;
+        newParametrs[key] = Object.assign(Object.assign({}, parametrs[key]), { znach });
+    }
+    return newParametrs;
+};
+exports.useCalcParametersDetals = useCalcParametersDetals;
+const useCalcParametersCbedProduct = (operations) => {
+    let newPreTime = 0;
+    let newHelperTime = 0;
+    let newMainTime = 0;
+    if (operations.length)
+        operations.forEach(op => {
+            newPreTime += Number(op.preTime);
+            newHelperTime += Number(op.helperTime);
+            newMainTime += Number(op.mainTime);
+        });
+    const znach = parseFloat(((newPreTime + newHelperTime + newMainTime) / 60).toFixed(2));
+    return znach;
+};
+exports.useCalcParametersCbedProduct = useCalcParametersCbedProduct;
+const useCalcParametersCbedProductMinute = (operations) => {
+    let newPreTime = 0;
+    let newHelperTime = 0;
+    let newMainTime = 0;
+    if (operations.length)
+        operations.forEach(op => {
+            newPreTime += Number(op.preTime);
+            newHelperTime += Number(op.helperTime);
+            newMainTime += Number(op.mainTime);
+        });
+    return newPreTime + newHelperTime + newMainTime;
+};
+exports.useCalcParametersCbedProductMinute = useCalcParametersCbedProductMinute;
+/**
+ * Функция проверяет, является ли операция готовой исходя из созданных отметок
+ * @param techProcesses
+ * @param operationId
+ * @param currentId
+ * @param returnIds
+ * @returns
+ */
+function getStatus(techProcesses_1, operationId_1) {
+    return __awaiter(this, arguments, void 0, function* (techProcesses, operationId, currentId = 1, returnIds = 'index') {
+        if (!techProcesses.operations.length)
+            return false;
+        let index = 0;
+        for (const inx in techProcesses.operations) {
+            if (techProcesses.operations[inx].id == operationId)
+                index = Number(inx);
+        }
+        if (returnIds == 'index')
+            return index;
+        if (returnIds == 'pug') {
+            const pug_true = '<p class="success_operation">Готово</p>';
+            const pug_false = '<p class="work_operation">В процессе</p>';
+            for (const inx in techProcesses.operations) {
+                if (techProcesses.operations[inx].id == currentId) {
+                    if (index > Number(inx))
+                        return pug_true;
+                    else
+                        return pug_false;
+                }
+            }
+        }
+    });
+}
+/**
+ * Специальный класс для формирования объекта времени выполнения операции
+ */
+class OperationTime {
+    constructor(operation, count = 1) {
+        if (!operation) {
+            this.preTime = 0;
+            this.mainTime = 0;
+            this.helperTime = 0;
+            this.count = 0;
+        }
+        else {
+            this.preTime = Number(operation.preTime);
+            this.mainTime = Number(operation.mainTime);
+            this.helperTime = Number(operation.helperTime);
+            this.count = this.timeKolvo(this.preTime, this.mainTime, this.helperTime, count);
+        }
+    }
+    timeKolvo(preTime, mainTime, helperTime, count) {
+        return count === 0 ? 0 : preTime + (mainTime + helperTime) * count;
+    }
+}
+exports.OperationTime = OperationTime;
+function worksHors(operation, kolvo_all = 1) {
+    const ot = new OperationTime(operation, kolvo_all);
+    return ot.count;
+}
+/**
+ * Функция получает время выполнения
+ * @param operation
+ * @param marks
+ * @returns
+ */
+function workingForMarks(operation, marks) {
+    if (!marks || marks.length == 0)
+        return 0;
+    let count = 0;
+    for (const mark of marks) {
+        if ((mark === null || mark === void 0 ? void 0 : mark.ban) || (mark === null || mark === void 0 ? void 0 : mark.brak))
+            continue;
+        count = count + worksHors(operation, mark.kol - mark.quantity_shipped);
+    }
+    return count;
+}
+/**
+ *
+ * @param {*} work - metall || ass
+ * @returns
+ */
+function getPrecentNumberOperation(work, folder = 'kolvo_create', full_folder = 'kolvo_shipments') {
+    if (!work[folder] || !work[full_folder])
+        return 0;
+    const precent = (Number(work[folder]) * 100) / work[full_folder];
+    return Number(precent.toFixed(0));
+}
+exports.statusWorkings = [
+    'В процессе',
+    'Готово',
+    'В архиве',
+    'Просрочено',
+    'Проведено'
+];
+function returnStatus(status, precent = 0) {
+    if (!status)
+        return 'work_operation';
+    const successStatus = status == types_1.StatusWorkingsEnum.ready || status == types_1.StatusWorkingsEnum.done;
+    if (successStatus && precent >= 100)
+        return 'success_operation';
+    if (status == types_1.StatusWorkingsEnum.process || precent < 100)
+        return 'work_operation';
+    return 'delete_operation';
+}
+/**
+ * Процент готовности, рассчитывается соотношения заказанного кол-ва
+ * и кол-ва отметок об выполнении во всех операциях
+ * @param {*} work - metall || ass
+ * @returns
+ */
+const precentWorksAsOperation = (work, brak = false) => {
+    var _a, _b, _c, _d, _e, _f;
+    const tp = ((_a = work === null || work === void 0 ? void 0 : work.detal) === null || _a === void 0 ? void 0 : _a.techProcesses) ||
+        ((_b = work === null || work === void 0 ? void 0 : work.cbed) === null || _b === void 0 ? void 0 : _b.techProcesses) ||
+        ((_c = work === null || work === void 0 ? void 0 : work.entity) === null || _c === void 0 ? void 0 : _c.techProcesses) ||
+        ((_d = work === null || work === void 0 ? void 0 : work.product) === null || _d === void 0 ? void 0 : _d.techProcesses);
+    if (!((_e = tp === null || tp === void 0 ? void 0 : tp.operations) === null || _e === void 0 ? void 0 : _e.length))
+        return 0;
+    let kolComplit = 0;
+    for (const item of tp.operations) {
+        if (!((_f = item.marks) === null || _f === void 0 ? void 0 : _f.length))
+            continue;
+        kolComplit += (0, workings_1.returnKolvoCreateWorking)(item.marks, brak);
+    }
+    const quantityNeedByOpetaion = tp.operations.length *
+        (0, methods_1.moreMinusNum)(work.kolvo_shipments - work.kolvo_create);
+    const precent = ((kolComplit * 100) / quantityNeedByOpetaion).toFixed(0);
+    work.kolComplitOperation = kolComplit;
+    return precent;
+};
+exports.precentWorksAsOperation = precentWorksAsOperation;
+/**
+ * Процент готовности, рассчитывается соотношения заказанного кол-ва
+ * и кол-ва отметок об выполнении во всех операциях
+ * @param {*} work - metall || ass
+ * @returns
+ */
+const calculatePercentWork = (data) => {
+    var _a, _b;
+    if (!((_a = data === null || data === void 0 ? void 0 : data.operations) === null || _a === void 0 ? void 0 : _a.length))
+        return 0;
+    let kolComplit = 0;
+    for (const item of data.operations) {
+        if (!((_b = item.marks) === null || _b === void 0 ? void 0 : _b.length))
+            continue;
+        kolComplit += (0, workings_1.returnKolvoCreateWorking)(item.marks, data.brak);
+    }
+    const quantityNeedByOpetaion = data.operations.length * data.quantityOrder;
+    const precent = ((kolComplit * 100) / quantityNeedByOpetaion).toFixed(0);
+    return Number(precent);
+};
+exports.calculatePercentWork = calculatePercentWork;

package/dist/utils/operations/opeartion.d.ts

@@ -0,0 +1,15 @@
+import { ModelOperation } from '../../operations';
+/**
+ * Функция подсчитывает количество отметок, которые осталось сделать по операции
+ * @param operation
+ * @param productionOperation
+ * @returns
+ */
+export declare const leftToDoByMarks: (operation: ModelOperation, productionOperation: any) => number;
+/**
+ * Функция подсчитывает количество отметок, которые осталось сделать по операции
+ * @param operation
+ * @param productionOperation
+ * @returns
+ */
+export declare const leftToDoByMarksByProductionItem: (operation: ModelOperation, quantityShipment: number) => number;

package/dist/utils/operations/opeartion.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.leftToDoByMarksByProductionItem = exports.leftToDoByMarks = void 0;
+const methods_1 = require("../methods");
+const workings_1 = require("../workings");
+/**
+ * Функция подсчитывает количество отметок, которые осталось сделать по операции
+ * @param operation
+ * @param productionOperation
+ * @returns
+ */
+const leftToDoByMarks = (operation, productionOperation) => {
+    const { kolvo_shipments, kolvo_create } = productionOperation;
+    const marks = (operation === null || operation === void 0 ? void 0 : operation.marks) || [];
+    const create = (0, workings_1.returnKolvoCreateWorking)(marks);
+    const actualShipments = (0, methods_1.moreMinusNum)(kolvo_shipments - kolvo_create);
+    return (0, methods_1.moreMinusNum)(actualShipments - create);
+};
+exports.leftToDoByMarks = leftToDoByMarks;
+/**
+ * Функция подсчитывает количество отметок, которые осталось сделать по операции
+ * @param operation
+ * @param productionOperation
+ * @returns
+ */
+const leftToDoByMarksByProductionItem = (operation, quantityShipment) => {
+    const marks = (operation === null || operation === void 0 ? void 0 : operation.marks) || [];
+    const create = (0, workings_1.returnKolvoCreateWorking)(marks);
+    const actualShipments = quantityShipment;
+    return (0, methods_1.moreMinusNum)(actualShipments - create);
+};
+exports.leftToDoByMarksByProductionItem = leftToDoByMarksByProductionItem;

package/dist/utils/promise-pool.d.ts

@@ -0,0 +1,5 @@
+export declare class PromisePoolService<R = void> {
+    private readonly concurrency;
+    constructor(concurrency?: number);
+    runTasks(tasks: (() => Promise<R>)[]): Promise<R[]>;
+}

package/dist/utils/promise-pool.js

@@ -0,0 +1,44 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromisePoolService = void 0;
+class PromisePoolService {
+    constructor(concurrency = 10) {
+        this.concurrency = concurrency;
+    }
+    runTasks(tasks) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = [];
+            const workers = [];
+            const taskQueue = [...tasks];
+            const worker = () => __awaiter(this, void 0, void 0, function* () {
+                while (taskQueue.length > 0) {
+                    const task = taskQueue.shift();
+                    if (!task)
+                        break;
+                    try {
+                        const res = yield task();
+                        results.push(res);
+                    }
+                    catch (err) {
+                        console.error(err);
+                    }
+                }
+            });
+            for (let i = 0; i < this.concurrency; i++) {
+                workers.push(worker());
+            }
+            yield Promise.all(workers);
+            return results;
+        });
+    }
+}
+exports.PromisePoolService = PromisePoolService;

package/dist/utils/schemas/schema.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const SpecificationForObjectSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    designation: z.ZodString;
+    quantity: z.ZodNumber;
+    discontinued: z.ZodDefault<z.ZodBoolean>;
+    measureId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    designation: string;
+    id: number;
+    name: string;
+    quantity: number;
+    discontinued: boolean;
+    measureId: number;
+}, {
+    designation: string;
+    id: number;
+    name: string;
+    quantity: number;
+    measureId: number;
+    discontinued?: boolean | undefined;
+}>;
+export declare const DateRangeSchema: z.ZodObject<{
+    start: z.ZodUnion<[z.ZodString, z.ZodDate]>;
+    end: z.ZodUnion<[z.ZodString, z.ZodDate]>;
+}, "strip", z.ZodTypeAny, {
+    start: string | Date;
+    end: string | Date;
+}, {
+    start: string | Date;
+    end: string | Date;
+}>;

package/dist/utils/schemas/schema.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateRangeSchema = exports.SpecificationForObjectSchema = void 0;
+const zod_1 = require("zod");
+exports.SpecificationForObjectSchema = zod_1.z.object({
+    id: zod_1.z.number().int(),
+    name: zod_1.z.string(),
+    designation: zod_1.z.string(),
+    quantity: zod_1.z.number(),
+    discontinued: zod_1.z.boolean().default(false),
+    measureId: zod_1.z.number()
+});
+exports.DateRangeSchema = zod_1.z.object({
+    start: zod_1.z.union([zod_1.z.string(), zod_1.z.date()]),
+    end: zod_1.z.union([zod_1.z.string(), zod_1.z.date()])
+});

package/dist/utils/templatesD3/block-templates.d.ts

@@ -0,0 +1,32 @@
+declare const blockTemplates: {
+    shapeSize: number;
+    shapePayload: {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+            };
+            name: {
+                type: string;
+            };
+            type_object: {
+                type: string;
+            };
+            designation: {
+                type: string;
+            };
+        };
+    };
+    shapeBuilder: typeof shapeBuilder;
+};
+/**
+ * TextShape
+ * Shape
+ * LODStyle,
+ * ShapeStyle
+ * @param {*} data
+ * @param {*} param1
+ * @returns
+ */
+declare function shapeBuilder(data: any, { Shape, ...Template }: any): any;
+export default blockTemplates;

package/dist/utils/templatesD3/block-templates.js

@@ -0,0 +1,85 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const blockTemplates = {
+    shapeSize: 300,
+    shapePayload: {
+        type: 'object',
+        properties: {
+            id: { type: 'number' },
+            name: { type: 'string' },
+            type_object: { type: 'string' },
+            designation: { type: 'string' }
+        }
+    },
+    shapeBuilder: shapeBuilder
+};
+/**
+ * TextShape
+ * Shape
+ * LODStyle,
+ * ShapeStyle
+ * @param {*} data
+ * @param {*} param1
+ * @returns
+ */
+function shapeBuilder(data, _a) {
+    var { Shape } = _a, Template = __rest(_a, ["Shape"]);
+    const shape = Shape.Rectangle(350, 180, 10);
+    const { payload } = data;
+    // const shape = Shape.PathShape("M 100 0 L 200 100 L 200 200 L 0 200 L 0 100 Z");
+    console.log('shape: ', shape);
+    console.log('data: ', data);
+    console.log('Template: ', Template);
+    shape.classed('gly_purple_fill', true);
+    shape.classed('black', true);
+    shape.attr('align', 'center');
+    shape.classed('gly-selectable', true);
+    // shape.append("rect")
+    // 	.attr("width", "100px")
+    // 	.attr("height", "50px")
+    // 	.attr("rx", "20")
+    // 	.attr("ry", "20")
+    // 	.attr("y", "30px")
+    // 	.style("fill", "rgb(16, 18, 19)")
+    shape
+        .append('text')
+        .classed('gly_text', true)
+        .classed('dark', true)
+        .style('font-size', '16px')
+        .style('font-weight', 'bold')
+        .attr('text-anchor', 'middle')
+        .attr('alignment-baseline', 'middle')
+        .attr('x', '170px')
+        .attr('y', '-10px')
+        .text(`Название: ${payload.name.length > 30 ? payload.name.slice(0, 30) + '...' : payload.name}`);
+    shape
+        .append('text')
+        .classed('gly_text', true)
+        .classed('dark', true)
+        .text('Тип объекта: ' + payload.type_object)
+        .attr('x', '70px')
+        .attr('y', '-50px');
+    shape
+        .append('text')
+        .classed('gly_text', true)
+        .classed('dark', true)
+        .text('id: ' + payload.id)
+        .attr('x', '20px')
+        .attr('y', '-30px');
+    console.log('shape: ', shape);
+    console.log('data: ', data);
+    console.log('Template: ', Template);
+    return shape;
+}
+exports.default = blockTemplates;