@pksep/zod-shared 0.0.549 → 0.0.550

package/dist/material/workpiece-mass.js

@@ -0,0 +1,400 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateWorkpieceMassPreview = exports.resolveWorkpieceMassVariables = exports.WORKPIECE_MASS_CALCULATORS = exports.WORKPIECE_MASS_VARIABLE_RESOLVERS = exports.WORKPIECE_MASS_FORMULAS = void 0;
+const enum_1 = require("./enum/enum");
+const utils_1 = require("../utils");
+exports.WORKPIECE_MASS_FORMULAS = [
+    {
+        key: enum_1.WorkpieceMassFormulaKey.boundingBox,
+        name: 'Прямоугольная заготовка',
+        description: 'm = ρ * L * B * H',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'length',
+                name: 'Длина',
+                source: 'workpiece',
+                required: true
+            },
+            {
+                key: 'width',
+                name: 'Ширина',
+                source: 'workpiece',
+                required: true
+            },
+            {
+                key: 'height',
+                name: 'Высота',
+                source: 'workpiece',
+                required: true
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.rectangularSection,
+        name: 'Прямоугольное сечение',
+        description: 'm = ρ * L * B * t',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'length',
+                name: 'Длина',
+                source: 'workpiece',
+                required: true
+            },
+            {
+                key: 'width',
+                name: 'Ширина',
+                source: 'workpiece',
+                required: true
+            },
+            {
+                key: 'thickness',
+                name: 'Толщина',
+                source: 'material',
+                required: true
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.solidRoundSection,
+        name: 'Полнотелое круглое сечение',
+        description: 'm = ρ * π * D² / 4 * L',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'outsideDiameter',
+                name: 'Наружный диаметр',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'length',
+                name: 'Длина',
+                source: 'workpiece',
+                required: true
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.hollowRoundSection,
+        name: 'Полое круглое сечение',
+        description: 'm = ρ * π * t * (D - t) * L',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'outsideDiameter',
+                name: 'Наружный диаметр',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'wallThickness',
+                name: 'Толщина стенки',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'length',
+                name: 'Длина',
+                source: 'workpiece',
+                required: true
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.hollowProfileSection,
+        name: 'Полое профильное сечение',
+        description: 'm = ρ * (B * H - (B - 2t) * (H - 2t)) * L',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'width',
+                name: 'Ширина профиля',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'height',
+                name: 'Высота профиля',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'wallThickness',
+                name: 'Толщина стенки',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'length',
+                name: 'Длина',
+                source: 'workpiece',
+                required: true
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.hexSection,
+        name: 'Шестигранное сечение',
+        description: 'm = ρ * 0.866025 * S² * L',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'acrossFlats',
+                name: 'Размер под ключ',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'length',
+                name: 'Длина',
+                source: 'workpiece',
+                required: true
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.sectionArea,
+        name: 'По площади сечения',
+        description: 'm = ρ * A * L',
+        variables: [
+            {
+                key: 'density',
+                name: 'Плотность',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'areaCrossSectional',
+                name: 'Площадь поперечного сечения',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'length',
+                name: 'Длина',
+                source: 'workpiece',
+                required: true
+            }
+        ]
+    },
+    {
+        key: enum_1.WorkpieceMassFormulaKey.linearMass,
+        name: 'По массе погонного метра',
+        description: 'm = q * L',
+        variables: [
+            {
+                key: 'massPerMeter',
+                name: 'Масса погонного метра',
+                source: 'material',
+                required: true
+            },
+            {
+                key: 'length',
+                name: 'Длина',
+                source: 'workpiece',
+                required: true
+            }
+        ]
+    }
+];
+const getMaterialCharacteristicValue = (context, key) => {
+    var _a, _b;
+    const item = (_b = (_a = context.material) === null || _a === void 0 ? void 0 : _a.characteristics) === null || _b === void 0 ? void 0 : _b[key];
+    return typeof (item === null || item === void 0 ? void 0 : item.znach) === 'number' && !Number.isNaN(item.znach)
+        ? item.znach
+        : null;
+};
+const getWorkpieceCharacteristicValue = (context, key) => {
+    var _a;
+    const value = (_a = context.workpieceCharacterization) === null || _a === void 0 ? void 0 : _a[key];
+    return typeof value === 'number' && !Number.isNaN(value) ? value : null;
+};
+const getPreparedWorkpieceValues = (context) => {
+    var _a, _b, _c, _d;
+    const result = {};
+    const typeMaterialCharacteristics = ((_a = context.typeMaterial) === null || _a === void 0 ? void 0 : _a.characteristics) || {};
+    for (const characteristicKey of Object.keys(typeMaterialCharacteristics)) {
+        const characteristicMode = (_b = typeMaterialCharacteristics[characteristicKey]) === null || _b === void 0 ? void 0 : _b.znach;
+        if (!characteristicMode)
+            continue;
+        result[characteristicKey] =
+            characteristicMode === utils_1.TypeMaterialCharZnachEnum.permanent
+                ? ((_c = getMaterialCharacteristicValue(context, characteristicKey)) !== null && _c !== void 0 ? _c : undefined)
+                : ((_d = getWorkpieceCharacteristicValue(context, characteristicKey)) !== null && _d !== void 0 ? _d : undefined);
+    }
+    const density = getMaterialCharacteristicValue(context, 'density');
+    if (density !== null)
+        result.density = density;
+    const mass = getWorkpieceCharacteristicValue(context, 'mass');
+    if (mass !== null)
+        result.mass = mass;
+    const trash = getWorkpieceCharacteristicValue(context, 'trash');
+    if (trash !== null)
+        result.trash = trash;
+    return result;
+};
+const getPreparedValue = (prepared, key) => {
+    const value = prepared[key];
+    return typeof value === 'number' && !Number.isNaN(value) ? value : null;
+};
+/**
+ * Реестр источников значений переменных.
+ * Здесь описано, откуда брать каждую переменную под расчет массы заготовки.
+ */
+exports.WORKPIECE_MASS_VARIABLE_RESOLVERS = {
+    density: (context, prepared) => {
+        var _a;
+        return (_a = getPreparedValue(prepared, 'density')) !== null && _a !== void 0 ? _a : getMaterialCharacteristicValue(context, 'density');
+    },
+    length: (_context, prepared) => getPreparedValue(prepared, 'length'),
+    width: (_context, prepared) => getPreparedValue(prepared, 'width'),
+    height: (_context, prepared) => getPreparedValue(prepared, 'height'),
+    thickness: (_context, prepared) => getPreparedValue(prepared, 'thickness'),
+    wallThickness: (_context, prepared) => getPreparedValue(prepared, 'wallThickness'),
+    outsideDiameter: (_context, prepared) => getPreparedValue(prepared, 'outsideDiameter'),
+    areaCrossSectional: (_context, prepared) => getPreparedValue(prepared, 'areaCrossSectional'),
+    // TODO: добавить поле в model/type_material/material/workpiece_characterization
+    acrossFlats: (context, prepared) => {
+        var _a;
+        return (_a = getPreparedValue(prepared, 'acrossFlats')) !== null && _a !== void 0 ? _a : getMaterialCharacteristicValue(context, 'acrossFlats');
+    },
+    // TODO: добавить поле в material.characteristics или отдельную модель
+    massPerMeter: (context, prepared) => {
+        var _a;
+        return (_a = getPreparedValue(prepared, 'massPerMeter')) !== null && _a !== void 0 ? _a : getMaterialCharacteristicValue(context, 'massPerMeter');
+    }
+};
+const getRequiredVar = (vars, key) => {
+    const value = vars[key];
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        throw new Error(`Не заполнена переменная "${key}" для расчета массы заготовки`);
+    }
+    return value;
+};
+/**
+ * Реестр математических алгоритмов расчета.
+ * Здесь только математика, без поиска значений по моделям.
+ */
+exports.WORKPIECE_MASS_CALCULATORS = {
+    [enum_1.WorkpieceMassFormulaKey.boundingBox]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const length = getRequiredVar(vars, 'length');
+        const width = getRequiredVar(vars, 'width');
+        const height = getRequiredVar(vars, 'height');
+        return density * length * width * height;
+    },
+    [enum_1.WorkpieceMassFormulaKey.rectangularSection]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const length = getRequiredVar(vars, 'length');
+        const width = getRequiredVar(vars, 'width');
+        const thickness = getRequiredVar(vars, 'thickness');
+        return density * length * width * thickness;
+    },
+    [enum_1.WorkpieceMassFormulaKey.solidRoundSection]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const outsideDiameter = getRequiredVar(vars, 'outsideDiameter');
+        const length = getRequiredVar(vars, 'length');
+        return (density * Math.PI * Math.pow(outsideDiameter, 2) * length) / 4;
+    },
+    [enum_1.WorkpieceMassFormulaKey.hollowRoundSection]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const outsideDiameter = getRequiredVar(vars, 'outsideDiameter');
+        const wallThickness = getRequiredVar(vars, 'wallThickness');
+        const length = getRequiredVar(vars, 'length');
+        return (density *
+            Math.PI *
+            wallThickness *
+            (outsideDiameter - wallThickness) *
+            length);
+    },
+    [enum_1.WorkpieceMassFormulaKey.hollowProfileSection]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const width = getRequiredVar(vars, 'width');
+        const height = getRequiredVar(vars, 'height');
+        const wallThickness = getRequiredVar(vars, 'wallThickness');
+        const length = getRequiredVar(vars, 'length');
+        return (density *
+            (width * height -
+                (width - 2 * wallThickness) * (height - 2 * wallThickness)) *
+            length);
+    },
+    [enum_1.WorkpieceMassFormulaKey.hexSection]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const acrossFlats = getRequiredVar(vars, 'acrossFlats');
+        const length = getRequiredVar(vars, 'length');
+        return density * 0.866025 * Math.pow(acrossFlats, 2) * length;
+    },
+    [enum_1.WorkpieceMassFormulaKey.sectionArea]: vars => {
+        const density = getRequiredVar(vars, 'density');
+        const areaCrossSectional = getRequiredVar(vars, 'areaCrossSectional');
+        const length = getRequiredVar(vars, 'length');
+        return density * areaCrossSectional * length;
+    },
+    [enum_1.WorkpieceMassFormulaKey.linearMass]: vars => {
+        const massPerMeter = getRequiredVar(vars, 'massPerMeter');
+        const length = getRequiredVar(vars, 'length');
+        return massPerMeter * length;
+    }
+};
+const resolveWorkpieceMassVariables = (context, variableKeys) => {
+    var _a;
+    const prepared = getPreparedWorkpieceValues(context);
+    const result = {};
+    for (const key of variableKeys) {
+        result[key] =
+            (_a = exports.WORKPIECE_MASS_VARIABLE_RESOLVERS[key](context, prepared)) !== null && _a !== void 0 ? _a : undefined;
+    }
+    return result;
+};
+exports.resolveWorkpieceMassVariables = resolveWorkpieceMassVariables;
+const calculateWorkpieceMassPreview = (context) => {
+    var _a;
+    const formulaKey = context.workpieceMassFormulaKey ||
+        ((_a = context.typeMaterial) === null || _a === void 0 ? void 0 : _a.workpieceMassFormulaKey) ||
+        null;
+    if (!formulaKey)
+        return null;
+    const formula = exports.WORKPIECE_MASS_FORMULAS.find(currentFormula => currentFormula.key === formulaKey);
+    if (!formula) {
+        throw new Error(`Формула расчета массы заготовки "${formulaKey}" не найдена`);
+    }
+    const variables = (0, exports.resolveWorkpieceMassVariables)(context, formula.variables.map(variable => variable.key));
+    return {
+        formulaKey,
+        mass: exports.WORKPIECE_MASS_CALCULATORS[formulaKey](variables),
+        variables
+    };
+};
+exports.calculateWorkpieceMassPreview = calculateWorkpieceMassPreview;

package/dist/metaloworking/dto/get-metallworking-pagination.dto.d.ts

@@ -3,6 +3,7 @@ import { IFiltersByByOrder, IFiltersByParents } from '../../production-tasks';
 export declare const GetMetaloworkingPaginationDtoZod: z.ZodObject<{
     page: z.ZodNumber;
     responsibleUserId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    metalloworkingID: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     searchString: z.ZodString;
     isBan: z.ZodBoolean;
     byParents: z.ZodOptional<z.ZodNullable<z.ZodType<IFiltersByParents, z.ZodTypeDef, IFiltersByParents>>>;
@@ -32,6 +33,7 @@ export declare const GetMetaloworkingPaginationDtoZod: z.ZodObject<{
     byParents?: IFiltersByParents | null | undefined;
     byOrder?: IFiltersByByOrder | null | undefined;
     childrenByProductionTaskIds?: number[] | null | undefined;
+    metalloworkingID?: number | null | undefined;
 }, {
     page: number;
     searchString: string;
@@ -45,5 +47,6 @@ export declare const GetMetaloworkingPaginationDtoZod: z.ZodObject<{
     byParents?: IFiltersByParents | null | undefined;
     byOrder?: IFiltersByByOrder | null | undefined;
     childrenByProductionTaskIds?: number[] | null | undefined;
+    metalloworkingID?: number | null | undefined;
 }>;
 export type GetMetaloworkingPaginationDtoZodType = z.infer<typeof GetMetaloworkingPaginationDtoZod>;

package/dist/metaloworking/dto/get-metallworking-pagination.dto.js

@@ -6,6 +6,7 @@ const utils_1 = require("../../utils");
 exports.GetMetaloworkingPaginationDtoZod = zod_1.z.object({
     page: zod_1.z.number(),
     responsibleUserId: zod_1.z.number().nullable().optional(),
+    metalloworkingID: zod_1.z.number().nullable().optional(),
     searchString: zod_1.z.string(),
     isBan: zod_1.z.boolean(),
     byParents: zod_1.z.custom().nullable().optional(),

package/dist/movement-object/schemas/get-one-object-history.schema.d.ts

@@ -1,8 +1,22 @@
 import { z } from 'zod';
-import { IFiltersByParents } from '../../production-tasks';
 export declare const GetOneObjectHistorySchema: z.ZodEffects<z.ZodObject<{
     isCheckChildrens: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>>;
-    byParents: z.ZodOptional<z.ZodNullable<z.ZodType<IFiltersByParents, z.ZodTypeDef, IFiltersByParents>>>;
+    byParents: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        productIds: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>>;
+        cbedIds: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>>;
+        detalIds: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>>;
+        materialIds: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        detalIds: number[];
+        cbedIds: number[];
+        productIds: number[];
+        materialIds: number[];
+    }, {
+        detalIds?: number[] | undefined;
+        cbedIds?: number[] | undefined;
+        productIds?: number[] | undefined;
+        materialIds?: number[] | undefined;
+    }>>>;
     date: z.ZodObject<{
         start: z.ZodDate;
         end: z.ZodDate;
@@ -21,14 +35,24 @@ export declare const GetOneObjectHistorySchema: z.ZodEffects<z.ZodObject<{
     };
     isCheckChildrens: boolean | null;
     page?: number | undefined;
-    byParents?: IFiltersByParents | null | undefined;
+    byParents?: {
+        detalIds: number[];
+        cbedIds: number[];
+        productIds: number[];
+        materialIds: number[];
+    } | null | undefined;
 }, {
     date: {
         start: Date;
         end: Date;
     };
     page?: number | undefined;
-    byParents?: IFiltersByParents | null | undefined;
+    byParents?: {
+        detalIds?: number[] | undefined;
+        cbedIds?: number[] | undefined;
+        productIds?: number[] | undefined;
+        materialIds?: number[] | undefined;
+    } | null | undefined;
     isCheckChildrens?: boolean | null | undefined;
 }>, {
     date: {
@@ -37,14 +61,24 @@ export declare const GetOneObjectHistorySchema: z.ZodEffects<z.ZodObject<{
     };
     isCheckChildrens: boolean | null;
     page?: number | undefined;
-    byParents?: IFiltersByParents | null | undefined;
+    byParents?: {
+        detalIds: number[];
+        cbedIds: number[];
+        productIds: number[];
+        materialIds: number[];
+    } | null | undefined;
 }, {
     date: {
         start: Date;
         end: Date;
     };
     page?: number | undefined;
-    byParents?: IFiltersByParents | null | undefined;
+    byParents?: {
+        detalIds?: number[] | undefined;
+        cbedIds?: number[] | undefined;
+        productIds?: number[] | undefined;
+        materialIds?: number[] | undefined;
+    } | null | undefined;
     isCheckChildrens?: boolean | null | undefined;
 }>;
 export type GetOneObjectHistorySchemaType = z.infer<typeof GetOneObjectHistorySchema>;

package/dist/movement-object/schemas/get-one-object-history.schema.js

@@ -2,10 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetOneObjectHistorySchema = void 0;
 const zod_1 = require("zod");
+const MovementObjectParentsSchema = zod_1.z.object({
+    productIds: zod_1.z.array(zod_1.z.number()).optional().default([]),
+    cbedIds: zod_1.z.array(zod_1.z.number()).optional().default([]),
+    detalIds: zod_1.z.array(zod_1.z.number()).optional().default([]),
+    materialIds: zod_1.z.array(zod_1.z.number()).optional().default([])
+});
 exports.GetOneObjectHistorySchema = zod_1.z
     .object({
     isCheckChildrens: zod_1.z.boolean().nullish().default(false),
-    byParents: zod_1.z.custom().nullable().optional(),
+    byParents: MovementObjectParentsSchema.nullable().optional(),
     date: zod_1.z.object({
         start: zod_1.z.date(),
         end: zod_1.z.date()

package/dist/production-tasks/interfaces/online-board.d.ts

@@ -3,6 +3,7 @@ export interface IFiltersByParents {
     productIds: number[];
     cbedIds: number[];
     detalIds: number[];
+    materialIds?: number[];
 }
 export interface IFiltersByByOrder {
     orderId: number | number[];

package/dist/shipments/dto/format-list-shipment.dto.d.ts

@@ -3,6 +3,7 @@ import { IzdType } from '../../utils';
 export declare const formatinglistShipmentSchema: z.ZodObject<{
     entityId: z.ZodNumber;
     type: z.ZodNativeEnum<typeof IzdType>;
+    productId: z.ZodOptional<z.ZodNumber>;
     shipmentIdToDelete: z.ZodOptional<z.ZodNumber>;
     shipmentToCheckIds: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
     isReturnFirstDeficit: z.ZodOptional<z.ZodBoolean>;
@@ -11,6 +12,7 @@ export declare const formatinglistShipmentSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     type: IzdType;
     entityId: number;
+    productId?: number | undefined;
     recursiveSpecificationObject?: any;
     transaction?: any;
     shipmentIdToDelete?: number | undefined;
@@ -19,6 +21,7 @@ export declare const formatinglistShipmentSchema: z.ZodObject<{
 }, {
     type: IzdType;
     entityId: number;
+    productId?: number | undefined;
     recursiveSpecificationObject?: any;
     transaction?: any;
     shipmentIdToDelete?: number | undefined;

package/dist/shipments/dto/format-list-shipment.dto.js

@@ -6,6 +6,7 @@ const utils_1 = require("../../utils");
 exports.formatinglistShipmentSchema = zod_1.z.object({
     entityId: zod_1.z.number(),
     type: zod_1.z.nativeEnum(utils_1.IzdType),
+    productId: zod_1.z.number().optional(),
     shipmentIdToDelete: zod_1.z.number().optional(),
     shipmentToCheckIds: zod_1.z.array(zod_1.z.number()).optional(),
     isReturnFirstDeficit: zod_1.z.boolean().optional(),

package/dist/shipments/dto/get-shipment-items-by-entity.dto.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { IzdType } from '../../utils';
+export declare const getShipmentItemsByEntitySchema: z.ZodObject<{
+    entityId: z.ZodNumber;
+    entityType: z.ZodNativeEnum<typeof IzdType>;
+    shipmentId: z.ZodOptional<z.ZodNumber>;
+    childId: z.ZodNumber;
+    childType: z.ZodNativeEnum<typeof IzdType>;
+}, "strip", z.ZodTypeAny, {
+    entityId: number;
+    entityType: IzdType;
+    childId: number;
+    childType: IzdType;
+    shipmentId?: number | undefined;
+}, {
+    entityId: number;
+    entityType: IzdType;
+    childId: number;
+    childType: IzdType;
+    shipmentId?: number | undefined;
+}>;
+export type GetShipmentItemsByEntityDto = z.infer<typeof getShipmentItemsByEntitySchema>;

package/dist/shipments/dto/get-shipment-items-by-entity.dto.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getShipmentItemsByEntitySchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../utils");
+exports.getShipmentItemsByEntitySchema = zod_1.z.object({
+    entityId: zod_1.z.number().int().positive(),
+    entityType: zod_1.z.nativeEnum(utils_1.IzdType),
+    shipmentId: zod_1.z.number().int().positive().optional(),
+    childId: zod_1.z.number().int().positive(),
+    childType: zod_1.z.nativeEnum(utils_1.IzdType)
+});