mdt-client 31.3.39 → 31.3.41

package/types/_core/scripts/services/api/ApiAccessor/apiV2Types.d.ts

@@ -0,0 +1,585 @@
+import { BindingExtData, BindingRowTypes } from "./binding/bindingApiTypes";
+import { MessageUiType, UiType } from "mdtScripts/helpers/IUi";
+import { PermissionLevelString } from "mdtScripts/security/PermissionLevel";
+import { HierarchicalRecord, MdtRecord, RecordId } from "../../../../scripts/common/Record";
+import { AnyObject, ColorStyle, FieldPath, LanguageId, Markdown, ModuleId, ObjectCode, ObjectId, ObjectTitle } from "../../../../scripts/helpers/types";
+import { FETCH_COUNT_ALIAS } from "../ApiAccessorRequestAdapter/handlers/fetch/helpers/count/count";
+import { WithExpandedIds } from "../ApiAccessorRequestAdapter/handlers/fetch/helpers/query/exts/hierarchy/hierarchyQueryHelpersTypes";
+import { DataExtraInformation } from "../ApiAccessorRequestAdapter/handlers/messageTypes";
+import { ApiV1 } from "./apiV1Types";
+export declare namespace ApiV2 {
+    namespace Request {
+        type Common = (Save | AnyObject) & WithMessageAction;
+        interface Save {
+            updates: Save.Update[];
+            exts?: Save.Extenders;
+            params?: Save.Params;
+        }
+        interface WithMessageAction {
+            messageAction?: MessageAction | MessageActionForm;
+        }
+        interface MessageActionForm {
+            form: {
+                objectCode: string;
+                record: Record<string, unknown>;
+            };
+        }
+        interface MessageAction {
+            actions?: {
+                code: string;
+                value: string;
+            }[];
+            recordActions?: MessageRecordAction[];
+        }
+        interface MessageRecordAction {
+            recordId: RecordId;
+            code: string;
+            value: string;
+        }
+        namespace Save {
+            type UpdateType = "none" | "createNew" | "delete";
+            interface Params {
+                formId?: RecordId;
+            }
+            interface Update {
+                record: MdtRecord;
+                table: string;
+                updateType: Save.UpdateType;
+                children?: Update[];
+                o2mFkField?: string;
+            }
+            interface Extenders {
+                dataExt?: DataExt;
+                status?: StatusExt;
+            }
+            interface DataExt {
+                exts: {
+                    ID_Language_ext: RecordId;
+                    [key: string]: any;
+                };
+            }
+            interface StatusExt {
+                statusComment: string;
+            }
+        }
+        /** FETCH */
+        interface Fetch {
+            table?: string;
+            select?: Fetch.Select;
+            orderBy?: Fetch.OrderBy;
+            groupBy?: Fetch.GroupBy;
+            filter?: Filter;
+            skip?: number;
+            take?: number;
+            distinct?: boolean;
+            exts?: Fetch.Exts;
+            params?: Fetch.Params & Fetch.SPParams;
+        }
+        namespace Fetch {
+            interface Params {
+                dataext?: "explicit";
+            }
+            /** Параметры для передачи в хранимую процедуру */
+            type SPParams = AnyObject;
+            type Select = SelectItem[];
+            type SelectItem = {
+                path: string;
+                aggregate?: Aggregation;
+                alias?: string;
+                castType?: CastType;
+            };
+            type Aggregation = {
+                function: ApiV2.AggregationType;
+                distinct?: boolean;
+            };
+            type CastType = "date";
+            type OrderByItem = {
+                path: string;
+                orderType: "asc" | "desc";
+                castType?: CastType;
+                aggregate?: Aggregation;
+            };
+            type OrderBy = OrderByItem[];
+            type GroupBy = {
+                path: string;
+            }[];
+            interface Exts {
+                dataExt?: Exts.DataExt;
+                fatLink?: Exts.FatLink;
+                group?: Exts.Group;
+                hierarchy?: Exts.Hierarchy;
+                hierarchyLegacy?: Exts.HierarchyLegacy;
+                dependency?: Exts.Dependency;
+                placeIn?: Exts.PlaceIn;
+                audit?: Exts.Audit;
+                tabular?: Exts.Tabular;
+                tag?: Exts.Tag;
+                workflow?: Exts.Workflow;
+                workflowStage?: Exts.WorkflowStage;
+                mapping?: Exts.Mapping;
+                binding?: Exts.Binding;
+                [k: string]: AnyObject | undefined;
+            }
+            namespace Exts {
+                interface Group {
+                    groups: GroupItem[];
+                    allParents?: boolean;
+                    orphans?: boolean;
+                    toggledValues?: string[][];
+                    skippedRowsCount?: number;
+                }
+                interface GroupItem {
+                    path: FieldPath;
+                    collapsed?: boolean;
+                    select?: FieldPath[];
+                    sorting?: GroupItemSorting[];
+                }
+                interface GroupItemSorting {
+                    path: string;
+                    desc: boolean;
+                }
+                interface DataExt {
+                    explicit?: boolean;
+                    args?: DataExtArgs;
+                }
+                interface DataExtArgs {
+                    ID_Language_ext?: LanguageId;
+                }
+                interface FatLink {
+                    date?: string;
+                    limit?: number;
+                }
+                interface Hierarchy extends WithExpandedIds {
+                    idField?: string;
+                    parentIdField?: string;
+                    parentId?: RecordId;
+                }
+                interface HierarchyLegacy {
+                    idField?: string;
+                    parentIdField?: string;
+                    mode?: Mode;
+                    filter?: Filter;
+                }
+                type Mode = "NA" | "Up" | "Down" | "UpDown";
+                type Dependency = FetchDependencyTypes.Request;
+                type PlaceIn = {
+                    queries: {
+                        query: Fetch;
+                        name: string;
+                        fk: string;
+                    }[];
+                };
+                type Audit = TicketQuery;
+                type Tag = TicketQuery;
+                interface Tabular {
+                    select?: {
+                        path: FieldPath;
+                        table: ObjectCode;
+                    }[];
+                    groupBy?: {
+                        path: FieldPath;
+                        table: ObjectCode;
+                    }[];
+                    orderBy?: {
+                        path: FieldPath;
+                        table: ObjectCode;
+                    }[];
+                }
+                type Workflow = TicketQuery;
+                interface WorkflowStage {
+                    enabled: boolean;
+                }
+                interface TicketQuery {
+                    ticket?: string;
+                    generateTicket?: true;
+                }
+                interface Mapping {
+                    flagGetMappedFKs: boolean;
+                }
+                type Binding = BindingExtData;
+            }
+        }
+    }
+    namespace Response {
+        export type Main = AnyObject | Error | Save | Fetch;
+        type BaseResponse = {
+            exts?: Exts;
+        };
+        interface Exts {
+            objectRule?: {
+                logs: string[];
+            };
+        }
+        export interface Error extends BaseResponse {
+            message: Markdown;
+            code: string;
+            debug?: any;
+            args?: any;
+            error: boolean;
+        }
+        export interface Save extends BaseResponse, WithMessage {
+            stats: Save.SaveStats;
+            details: Save.SaveDetails;
+        }
+        export namespace Save {
+            export interface SaveDetails {
+                inserted?: SaveDetailsItem[];
+                updated?: SaveDetailsItem[];
+                deleted?: SaveDetailsItem[];
+            }
+            interface SaveDetailsItem {
+                table: ObjectCode;
+                ids: RecordId[];
+            }
+            export interface SaveStats {
+                inserted?: number;
+                updated?: number;
+                delete?: number;
+            }
+            export {};
+        }
+        export interface Fetch {
+            message?: DataExtraInformation;
+            exts?: Fetch.Exts;
+            rows?: Fetch.Row[];
+            [k: string]: any;
+        }
+        /** Fetch */
+        export namespace Fetch {
+            type Row = MdtRecord & {
+                [FETCH_COUNT_ALIAS]?: number;
+                $exts?: RecordExt;
+            };
+            interface RecordExt extends RecordExt.WorkflowStageExt {
+                required?: {
+                    fields: {
+                        [k: string]: boolean;
+                    };
+                };
+                placeIn?: {
+                    rows: Record<string, Fetch.Row[]>;
+                };
+                audit?: {
+                    ticket: string;
+                };
+                tag?: {
+                    tags: number[];
+                    ticket: string;
+                };
+                workflow?: {
+                    ticket: string;
+                };
+                dependency?: FetchDependencyTypes.RecordExtResponse;
+                hierarchy?: Exts.Hierarchy;
+                binding?: {
+                    status: BindingRowTypes;
+                };
+                /**
+                 * Ограничения на действия (CRUD) над записью и её полями, накладываемые функцией безопасности.
+                 * [Документация](https://ics-it.gram.ax/mdt/security/objectSecurity/sqlFn?l=ru)
+                 */
+                securityExt?: {
+                    level: PermissionLevelString;
+                    baseLevel: PermissionLevelString;
+                    fields: {
+                        [fieldId: number]: PermissionLevelString;
+                    };
+                };
+            }
+            namespace RecordExt {
+                interface WorkflowStageExt {
+                    workflowStage?: WorkflowStage;
+                }
+                interface WorkflowStage {
+                    title: string;
+                    icon?: string;
+                    labelStyleCode?: ColorStyle;
+                }
+            }
+            interface Exts {
+                hierarchyLegacy?: Exts.HierarchyLegacy;
+                hierarchy?: Exts.Hierarchy;
+                group?: Exts.GroupQuery;
+            }
+            namespace Exts {
+                interface HierarchyLegacy {
+                    rows: HierarchicalRecord[];
+                }
+                interface Hierarchy {
+                    hasChildren: boolean;
+                    children?: Fetch.Row[];
+                }
+                interface GroupQuery {
+                    groups: OutputGroup[];
+                    skippedRowsCount?: number;
+                }
+            }
+            interface OutputGroup {
+                count: number;
+                object?: {
+                    [k: string]: any;
+                };
+                value?: any;
+                subGroups?: OutputGroup[];
+                isEmpty?: boolean;
+            }
+        }
+        export interface WithMessage {
+            message?: Message;
+        }
+        export type Message = MessageWithData | MessageWithForm;
+        export type MessageWithData = MessageBase & MessageData;
+        export type MessageWithForm = MessageBase & MessageForm;
+        interface MessageBase {
+            type: Message.Type;
+            title?: string;
+            icon?: string;
+        }
+        interface MessageData {
+            actions?: Message.Action[];
+            data: Message.ResponseData[];
+        }
+        export interface MessageForm {
+            form?: {
+                layoutCode: string;
+                object: {
+                    Code: string;
+                    Fields: {
+                        Code: string;
+                        Type: string;
+                        Required: string;
+                        RefTableCode: string;
+                    }[];
+                    Title?: string;
+                    Description?: string;
+                };
+            };
+        }
+        export namespace Message {
+            type Type = MessageUiType;
+            type UIType = UiType;
+            interface Action {
+                title: string;
+                icon?: string;
+                type: Type;
+                paramCode: string;
+                paramValue: string;
+            }
+            type ResponseData = ResponseText | ResponseRows | ResponseRef | ResponseRecordAction;
+            interface ResponseText {
+                type: "Text";
+                text: string;
+            }
+            interface ResponseRows<T extends MdtRecord = MdtRecord> {
+                type: "Rows";
+                rows: T[];
+            }
+            interface ResponseRef {
+                type: "Refs";
+                idObject: number;
+                idRecords: RecordId[];
+            }
+            interface ResponseRecordAction<R = any> {
+                type: "RecordAction";
+                columns: ResponseRecordActionColumn[];
+                rows: ResponseRecordActionRow<R>[];
+            }
+            interface ResponseRecordActionColumn {
+                code: string;
+                title: string;
+            }
+            interface ResponseRecordActionRow<R = any> {
+                recordId: RecordId;
+                record: R;
+                recordActions: ResponseRecordActionAction[];
+            }
+            interface ResponseRecordActionAction {
+                code: string;
+                values: {
+                    title: string;
+                    value: string;
+                }[];
+            }
+        }
+        export namespace File {
+            export interface Upload {
+                id: RecordId;
+                name: string;
+                uid: string;
+                shortUid: string;
+                size?: number;
+                storageProvider?: UploadStorageProvider;
+            }
+            type UploadStorageProvider = ApiV1.Response.File.StorageProvider;
+            export {};
+        }
+        export namespace Data {
+            export interface Import {
+                stats: Save.SaveStats;
+                details: {
+                    inserted?: ImportDetail[];
+                    updated?: ImportDetail[];
+                    delete?: ImportDetail[];
+                };
+            }
+            interface ImportDetail {
+                table: string;
+                ids: RecordId[];
+            }
+            export {};
+        }
+        export namespace Template {
+            interface Preview {
+                context: AnyObject;
+                script: string;
+                header: string;
+                text: string;
+            }
+        }
+        export namespace User {
+            interface EntityPermission {
+                level: PermissionLevelString;
+            }
+            interface Permissions {
+                listview: User.EntityPermission;
+                namedfilters: User.EntityPermission;
+                tag: User.EntityPermission;
+                object: ObjectPermissions;
+            }
+            interface ObjectPermissions {
+                objects: ObjectPermissionObjects;
+            }
+            interface ObjectPermissionObjects {
+                [objectCode: string]: {
+                    level: PermissionLevelString;
+                    fields?: Record<string, User.EntityPermission>;
+                };
+            }
+        }
+        export interface User {
+            id: number;
+            isAdmin: boolean;
+            isAnonymous: boolean;
+            isImpersonated: boolean;
+            languageId: number;
+            roles: string[];
+            permissions?: User.Permissions;
+            identityName?: string;
+            languageCode?: string;
+            login?: string;
+            fullName?: string;
+            email?: string;
+        }
+        export type Schema = Schema.Object | Schema.Object[];
+        export namespace Schema {
+            type Object = {
+                $id?: ObjectId;
+                Code?: ObjectCode;
+                DefaultFieldCode?: any;
+                Deleted?: boolean;
+                Fields?: Field[];
+                ID?: ObjectId;
+                ID_ObjectType?: string;
+                ID_ver_Module?: ModuleId;
+                OBJECT_ID?: number;
+                tag_Enabled?: boolean;
+                Title?: ObjectTitle;
+                "Title@"?: ObjectTitle;
+                TitlePlural?: string;
+                "TitlePlural@"?: string;
+                Description?: string;
+                Readonly?: boolean;
+                Icon?: string;
+                audit_Enabled?: boolean;
+                inline_AddInRow?: boolean;
+                inline_Enabled?: boolean;
+                HierarchyParentField?: string;
+                HierarchyIDField?: string;
+                FlagHierarchy?: boolean;
+                FlagConfiguration?: boolean;
+                Settings: string;
+                AccessLevel: string;
+                Parameters?: Parameter[];
+            } & Record<string, any>;
+            type Field = {
+                Code: string;
+                Type: string;
+                DataType: string;
+                $id?: ObjectId;
+                ID?: ObjectId;
+                Title?: string;
+                "Title@"?: string;
+                Identity?: boolean;
+                RefTableCode?: string;
+                SortOreder?: number;
+                FlagScriptDfkInline?: boolean;
+                Primary?: boolean;
+                Readonly?: boolean;
+            };
+            type Parameter = {
+                Code: string;
+                DataType: string;
+            };
+        }
+        export {};
+    }
+    type AggregationType = "sum" | "avg" | "count" | "max" | "min";
+    type Filter = Filter.Simple | Filter.List | Filter.SubQuery | Filter.Multi;
+    namespace Filter {
+        export type MultiOp = "and" | "or";
+        export type BinaryOp = "eq" | "ge" | "le" | "gt" | "lt" | "ne" | "contains" | "startsWith" | "endsWith" | "fullText" | "in";
+        export interface Multi extends WithNot {
+            op: MultiOp;
+            groups: Filter[];
+        }
+        interface WithNot {
+            not?: boolean;
+        }
+        export interface Simple extends WithNot, WithCastType {
+            op: BinaryOp;
+            path: string;
+            value?: any;
+        }
+        export interface List extends WithNot, WithCastType {
+            op: BinaryOp;
+            path: string;
+            list: string[];
+        }
+        export interface SubQuery extends WithNot, WithCastType {
+            op: BinaryOp;
+            path: string;
+            query: SubQueryExpression;
+        }
+        export interface SubQueryExpression {
+            table: string;
+            field: string;
+            filter?: Filter;
+            params?: {
+                [k: string]: any;
+            };
+        }
+        interface WithCastType {
+            castType?: ApiV2.Request.Fetch.CastType;
+        }
+        export {};
+    }
+}
+/**
+ * Расширение позволяет получить информацию о ссылках на текущую запись.
+ */
+declare namespace FetchDependencyTypes {
+    /**
+     * В запросе указывается таблица и поле, которое ссылается на текущую таблицу
+     */
+    type Request = {
+        table: string;
+        field: string;
+    };
+    /**
+     * В ответе вместе с записью приходит информация есть ли ссылки на эту запись по указанным в запросе данным
+     */
+    type RecordExtResponse = {
+        hasDependencies: boolean;
+    };
+}
+export {};

package/types/_core/scripts/services/api/ApiAccessor/binding/bindingApiTypes.d.ts

@@ -0,0 +1,42 @@
+import { MdtRecord, RecordId } from "../../../../common/Record";
+export interface BindingFormData {
+    ID_ObjectTarget: number;
+    ID_ObjectSource: number;
+    ID_TargetRecord: number;
+    ID_SourceRecords: RecordId[];
+    ID_DimensionRecords: MdtRecord[];
+    FlagTotalPeriod: boolean;
+    DateBegin?: Date;
+    DateEndFix?: Date;
+}
+export interface BindingRequestData {
+    TargetObjectId: RecordId;
+    SourceObjectId: RecordId;
+    TargetRecordId: RecordId;
+    SourceRecordIds: RecordId[];
+    FlagTotalPeriod: boolean;
+    DimensionRecordIds?: RecordId[];
+    DateBegin?: Date | unknown;
+    DateEnd?: Date | unknown;
+}
+export interface UnbindingRequestData {
+    ObjectId: RecordId;
+    Items: UnbindingDataItemTypes[];
+}
+export interface UnbindingDataItemTypes {
+    BindingId: RecordId;
+    DateEnd?: Date | unknown;
+}
+export declare type BindingRowTypes = "Bound" | "NotBound" | "BoundOutside";
+export interface BindingFilterParams {
+    targetRecordIds?: RecordId[];
+    dimensionId?: RecordId;
+    customFilterId?: RecordId;
+}
+export interface BindingExtData {
+    bindingObjectId?: RecordId;
+    date?: Date | unknown;
+    filter?: {
+        status?: BindingRowTypes;
+    } & BindingFilterParams;
+}

package/types/_core/scripts/services/api/ApiAccessor/job/jobApiTypes.d.ts

@@ -0,0 +1,82 @@
+import { RecordId } from "mdtScripts/common/Record";
+import { AnyObject, ObjectId, URLString } from "mdtScripts/helpers/types";
+export declare namespace ApiV1 {
+    namespace Request {
+        interface JobTask {
+            ObjectId?: number;
+            RecordId?: number;
+            RecordIds?: number[];
+            Args?: AnyObject;
+            /**
+             * Тип файла (например, "pdf", "docx", "txt")
+             * */
+            File?: string;
+        }
+        namespace Job {
+            interface ExecProc {
+                process: RecordId;
+            }
+            interface ExecTask {
+                taskCode: string;
+            }
+            interface StopTask {
+                taskCode: string;
+            }
+            interface IsRunning {
+                taskCode: string;
+            }
+        }
+    }
+    namespace Response {
+        namespace Job {
+            export type ExecTask = FileExecutionResult | StoredProcExecutionResult | TextExecutionResult | EmptyExecutionResult;
+            interface FileExecutionResult {
+                Type: "File";
+                Url: URLString;
+            }
+            interface StoredProcExecutionResult {
+                Type: "StoredProc";
+                ID_ProcedureObject: ObjectId;
+            }
+            interface TextExecutionResult {
+                Type: "Text" | "Error";
+                Text: string;
+                Header: string;
+            }
+            interface EmptyExecutionResult {
+                Type: "Empty";
+            }
+            export {};
+        }
+    }
+}
+export declare namespace ApiV2 {
+    namespace Request {
+        type ExecProc = ApiV1.Request.Job.ExecProc;
+        type ExecTask = ApiV1.Request.Job.ExecTask;
+        type StopTask = ApiV1.Request.Job.StopTask;
+        type IsRunning = ApiV1.Request.Job.IsRunning;
+    }
+    namespace Response {
+        namespace Job {
+            export type ExecTask = FileExecutionResult | StoredProcExecutionResult | TextExecutionResult | EmptyExecutionResult;
+            interface FileExecutionResult {
+                type: "File";
+                url: URLString;
+            }
+            interface StoredProcExecutionResult {
+                type: "StoredProc";
+                id_ProcedureObject: ObjectId;
+            }
+            interface TextExecutionResult {
+                type: "Text";
+                text: string;
+                header: string;
+            }
+            interface EmptyExecutionResult {
+                type: "Empty";
+            }
+            export {};
+        }
+    }
+}