mdt-client 1.0.26 → 1.0.29

package/types/_core/scripts/services/Evaluator.d.ts

@@ -0,0 +1,654 @@
+/// <reference types="mithril" />
+import { SchemaManager } from "./SchemaManager";
+import { ExpressionedFilter } from "_core/scripts/services/Filter";
+import { QuerySorting } from "./api/Query";
+import { IExp } from "./schema/IExp.schema";
+export declare type IExpItem = ILogicalExp | ICompareExp | IMathExp | IInExp | IConcatExp | IIfExp | INotExp | ILiteralExp | IStoredProcExp | ISqlFunctionExp | IPropExp | INowExp | IUserIdExp | IIsInRoleExp | IInGroupsExp | INamedExp | IFilterExp | IQueryExp | IFieldExp | IIsFieldEmptyExp | IContextParamExp;
+export interface ExpBase {
+    /**
+     * Условия выполнения выражений
+     * @default [{ "event": "update", "field": "" }]
+     */
+    dep?: ExpDep | ExpDep[];
+}
+/**
+ * Условие выполнения выражений
+ */
+interface ExpDep {
+    /**
+     * Событие при котором выполняется выражение
+     * - `init` - при открытии формы
+     * - `update` - при обновлении поля `field`
+     * - `save` - перед сохранением записи
+     * - `contextUpdate` - при обновлении контекста
+     */
+    event: "init" | "update" | "save" | "contextUpdate";
+    /**
+     * Поле, при изменении которого выражение будет выполнено, если `event=update`
+     */
+    field: string;
+    /**
+     * Если `true`, то выражение будет выполняться во всех иных случаях, кроме указанного
+     */
+    not?: boolean;
+    /**
+     * Выражение будет выполняться только для новых записей
+     */
+    new?: boolean;
+}
+export declare type Expressioned<T> = {
+    [V in keyof T]: T[V] | IExp;
+};
+export declare abstract class Exp<T = IExp> {
+    exp: T;
+    ctx: any;
+    constructor(exp: T, ctx: any);
+    abstract eval(): any;
+}
+/**
+ * @markdownDescription
+ * Логическое выражение
+ *
+ * Выполняются подвыражения `ops` и соответствующая операция над результатами
+ *
+ * @defaultSnippets [{ "label": "Логическое выражение (and, or)", "body": { "$": "and", "ops": [] }}]
+ */
+interface ILogicalExp {
+    $: "or" | "and";
+    ops: IExp[];
+}
+export declare class LogicalExp extends Exp<ILogicalExp> {
+    eval(): _mithril.MithrilPromise<boolean>;
+}
+/**
+ * @markdownDescription
+ * Выражение сравнения
+ *
+ * Сравниваются результаты выполнения подвыражений \`arg1\` и \`arg2\` по выбранному оператору и возвращается \`true\` / \`false\`
+ * - `eq`, `=` - равенство
+ * - `ne`, `<>` - неравенство
+ * - `lt`, `<` - меньше
+ * - `le`, `<=` - меньше или равно
+ * - `gt`, `>` - больше
+ * - `ge`, `>=` - больше или равно
+ *
+ * @defaultSnippets [{ "label": "Выражение сравнения (=, <>, >, <, ...)", "body": { "$": "eq", "arg1": {}, "arg2": {} }}]
+ */
+interface ICompareExp {
+    $: "eq" | "=" | "ne" | "<>" | "lt" | "<" | "le" | "<=" | "ge" | ">=" | "gt" | ">";
+    arg1: IExp;
+    arg2: IExp;
+}
+export declare class CompareExp extends Exp<ICompareExp> {
+    eval(): _mithril.MithrilPromise<boolean>;
+}
+export declare class EqExp extends Exp<ICompareExp> {
+    eval(): _mithril.MithrilPromise<boolean>;
+}
+export declare class NeqExp extends EqExp {
+    eval(): _mithril.MithrilPromise<boolean>;
+}
+/**
+ * @markdownDescription
+ * Математическое выражение
+ *
+ * Выполняется выбранная операция над результатами выполнения подвыражений `arg1` и `arg2`
+ *
+ * @defaultSnippets
+ * [
+ * 		{
+ * 			"label": "Математическое выражение (+, -, *, /)",
+ * 			"body": { "$": "+", "arg1": {}, "arg2": {} }
+ * 		}
+ * 	]
+ */
+interface IMathExp {
+    $: "*" | "/" | "+" | "-";
+    arg1: IExp;
+    arg2: IExp;
+}
+export declare class MathExp extends Exp<IMathExp> {
+    eval(): _mithril.MithrilPromise<any>;
+}
+/**
+ * @markdownDescription
+ * Проверка на вхождение в список
+ *
+ * Выполняется подвыражение `arg` и проверяется вхождение результата в список `list`.
+ * При вхождение возвращается `false`, иначе `true`
+ *
+ * @defaultSnippets
+ * [
+ * 	{
+ * 		"label": "Проверка на вхождение в список (in)",
+ * 		"body": { "$": "in", "arg": {}, "list": [1, 2, 3] }
+ * 	}
+ * ]
+ */
+interface IInExp {
+    $: "in";
+    arg: IExp;
+    list: (string | number)[];
+}
+export declare class InExp extends Exp<IInExp> {
+    eval(): any;
+}
+/**
+ * @markdownDescription
+ * Конкатенация значений
+ *
+ * Последовательно выполняются подвыражения `list` и результаты объединяются в строку с использованием разделителя `sep`
+ *
+ * @defaultSnippets
+ * [
+ * 	{
+ * 		"label": "Конкатенация значений (concat)",
+ * 		"body": { "$": "concat", "list": [{ "$": "field", "path": "$1" }, { "$": "field", "path": "$2" }], "sep": "-" }
+ * 	}
+ * ]
+ */
+interface IConcatExp {
+    $: "concat";
+    list: IExp[];
+    sep?: string;
+}
+export declare class ConcatExp extends Exp<IConcatExp> {
+    eval(): _mithril.MithrilPromise<string>;
+}
+/**
+ * @markdownDescription
+ * Условное ветвление
+ *
+ * В случае, если подвыражение `expr` возвращает `true`, то выполняется подвыражение `then`, иначе `else`
+ *
+ * @defaultSnippets
+ * [
+ *   {
+ *     "label": "Условное ветвление (if)",
+ *     "body": {
+ *       "$": "if",
+ *       "expr": {},
+ *       "then": {},
+ *       "else": {}
+ *     }
+ *   }
+ * ]
+ */
+interface IIfExp {
+    $: "if";
+    expr: IExp;
+    then: IExp;
+    else?: IExp;
+}
+export declare class IfExp extends Exp<IIfExp> {
+    eval(): any;
+}
+/**
+ * @markdownDescription
+ * Выражение отрицания
+ *
+ * Возвращает результат, противоположный результату подвыражения `op`
+ *
+ * @defaultSnippets
+ * [
+ *   {
+ *     "label": "Выражение отрицания (not)",
+ *     "body": {
+ *       "$": "not",
+ *       "op": "$1"
+ *     }
+ *   }
+ * ]
+ */
+interface INotExp {
+    $: "not";
+    op: IExp;
+}
+export declare class NotExp extends Exp<INotExp> {
+    eval(): any;
+}
+/**
+ * @markdownDescription
+ * Произвольный js код
+ *
+ * Выполняется указанный в `exp` js код и возвращается результат
+ *
+ * @defaultSnippets
+ * [
+ *   {
+ *     "label": "Произвольный js код (literal)",
+ *     "body": {
+ *       "$": "literal",
+ *       "exp": "$1"
+ *     }
+ *   }
+ * ]
+ */
+interface ILiteralExp {
+    $: "literal";
+    exp: string;
+}
+export declare class LiteralExp extends Exp<ILiteralExp> {
+    private getPrimitive;
+    eval(): _mithril.MithrilPromiseProperty<any> & {
+        onchange: (v?: any) => any;
+    };
+}
+/**
+ * @markdownDescription
+ * Выполнение хранимой процедуры
+ *
+ * Выполняется запрос к указанной хранимой процедуре `name`.
+ * Если заданы `params`, то сначала выполняются заданные подвыражения и результаты передаются в хранимую процедуру.
+ *
+ * @defaultSnippets
+ * [
+ *   {
+ *     "label": "Выполнение хранимой процедуры (sp)",
+ *     "body": {
+ *       "$": "sp",
+ *       "name": "$1",
+ *       "params": {
+ *         "paramName": {}
+ *       }
+ *     }
+ *   }
+ * ]
+ */
+interface IStoredProcExp {
+    $: "sp";
+    name: string;
+    params: Record<string, IExp | string | number>;
+}
+export declare class StoredProcExp extends Exp<IStoredProcExp> {
+    private api;
+    eval(): _mithril.MithrilPromise<_mithril.MithrilPromise<any>>;
+}
+/**
+ * @markdownDescription
+ * Вызов SQL-функции
+ *
+ * Выполняется запрос к указанной функции `name`.
+ * Если заданы `params`, то сначала выполняются заданные подвыражения и результаты передаются в качестве параметров функции.
+ *
+ * @defaultSnippets
+ * [
+ *   {
+ *     "label": "Вызов SQL-функции (sqlfn)",
+ *     "body": {
+ *       "$": "sqlfn",
+ *       "name": "$1",
+ *       "params": []
+ *     }
+ *   }
+ * ]
+ */
+interface ISqlFunctionExp {
+    $: "sqlfn";
+    name: string;
+    params?: (IExp | string | number)[];
+}
+export declare class SqlFunctionExp extends Exp<ISqlFunctionExp> {
+    private api;
+    private fetchFunction;
+    eval(): _mithril.MithrilPromise<any>;
+}
+/**
+ * @markdownDescription
+ * Получение значения из объекта
+ *
+ * Выполняется подзапрос `source`, из полученного результата извлекается значение с использованием `prop` (пример - `records[0].ID_Company`)
+ *
+ * @defaultSnippets
+ * [
+ *   {
+ *     "label": "Получение значения из объекта (prop)",
+ *     "body": {
+ *       "$": "prop",
+ *       "prop": "$1",
+ *       "source": {
+ *         "$": "query",
+ *         "table": "",
+ *         "filter": {
+ *           "op": "eq",
+ *           "p1": "",
+ *           "p2": ""
+ *         }
+ *       }
+ *     }
+ *   }
+ * ]
+ */
+interface IPropExp {
+    $: "prop";
+    prop: string;
+    source: IExp;
+    nullIfNotExists: boolean;
+}
+export declare class PropExp extends Exp<IPropExp> {
+    eval(): any;
+}
+/**
+ * @markdownDescription
+ * Текущая дата
+ *
+ * @defaultSnippets
+ * [
+ *   {
+ *     "label": "Текущая дата (now)",
+ *     "body": {
+ *       "$": "now"
+ *     }
+ *   }
+ * ]
+ */
+interface INowExp {
+    $: "now";
+}
+export declare class NowExp extends Exp {
+    eval(): _mithril.MithrilPromiseProperty<number> & {
+        onchange: (v?: number) => any;
+    };
+}
+/**
+ * @markdownDescription
+ * ID текущего пользователя
+ *
+ * @defaultSnippets
+ * [
+ *   {
+ *     "label": "Текущий пользователь (userId)",
+ *     "body": {
+ *       "$": "userId"
+ *     }
+ *   }
+ * ]
+ */
+interface IUserIdExp {
+    $: "userId";
+}
+export declare class UserIdExp extends Exp {
+    eval(): _mithril.MithrilPromiseProperty<any> & {
+        onchange: (v?: any) => any;
+    };
+}
+/**
+ * @markdownDescription
+ * Проверка на принадлежность текущего пользователя к группе, заданной в `code`
+ *
+ * @defaultSnippets
+ * [
+ *   {
+ *     "label": "Принадлежность пользователя к роли (inGroup, inRole)",
+ *     "body": {
+ *       "$": "inGroup",
+ *       "code": ""
+ *     }
+ *   }
+ * ]
+ */
+interface IIsInRoleExp {
+    $: "inGroup" | "inRole";
+    code: string;
+}
+export declare class IsInRoleExp extends Exp<IIsInRoleExp> {
+    eval(): _mithril.MithrilPromiseProperty<boolean> & {
+        onchange: (v?: boolean) => any;
+    };
+}
+/**
+ * @markdownDescription
+ * Проверка на принадлежность текущего пользователя к списку групп, заданному в `list`
+ *
+ * @defaultSnippets
+ * [
+ *   {
+ *     "label": "Принадлежность пользователя к списку групп (inGroups)",
+ *     "body": {
+ *       "$": "inGroups",
+ *       "and": true,
+ *       "not": false,
+ *       "list": ["$1"]
+ *     }
+ *   }
+ * ]
+ */
+interface IInGroupsExp {
+    $: "inGroups";
+    /**
+     * Принадлежность всему списку групп (`true`) или части из него (`false`).
+     * @default true
+     */
+    and?: boolean;
+    /**
+     * Принадлежность списку групп (`false`) или не принадлежность (`true`)
+     * @default false
+     */
+    not?: boolean;
+    /**
+     * Список групп
+     */
+    list: string[];
+}
+export declare class InGroupsExp extends Exp<IInGroupsExp> {
+    eval(): _mithril.MithrilPromiseProperty<boolean> & {
+        onchange: (v?: boolean) => any;
+    };
+}
+/**
+ * @markdownDescription
+ * Именованное выражение
+ *
+ * Выполняется выражение `name`, объявленное на уровне формы (`layout.expressions`)
+ *
+ * @defaultSnippets
+ * [
+ *   {
+ *     "label": "Именованное выражение (exp)",
+ *     "body": {
+ *       "$": "exp",
+ *       "name": "$1"
+ *     }
+ *   }
+ * ]
+ */
+interface INamedExp {
+    $: "exp";
+    name: string;
+}
+export declare class NamedExp extends Exp<INamedExp> {
+    private $exp;
+    private e;
+    constructor(exp: any, ctx: any);
+    eval(): any;
+}
+export declare function evalFilter(filter: any, ctx: any): _mithril.MithrilPromise<any>;
+/**
+ * @markdownDescription
+ * Фильтрация запроса
+ *
+ * Выполняются все подвыражения указанные в свойствах `filter` и возвращается объект фильтра
+ *
+ * @defaultSnippets
+ * [
+ *   {
+ *     "label": "Фильтрация запроса (filter)",
+ *     "body": {
+ *       "$": "filter",
+ *       "filter": {
+ *         "op": "eq",
+ *         "p1": "",
+ *         "p2": ""
+ *       }
+ *     }
+ *   }
+ * ]
+ */
+interface IFilterExp {
+    $: "filter";
+    filter: ExpressionedFilter;
+}
+export declare class FilterExp extends Exp<IFilterExp> {
+    filter: ExpressionedFilter;
+    eval(): _mithril.MithrilPromise<any>;
+}
+/**
+ * @markdownDescription
+ * Запрос
+ *
+ * Выполняется запрос к таблице `table` и возвращается результат
+ *
+ * @defaultSnippets
+ * [
+ *   {
+ *     "label": "Запрос (query)",
+ *     "body": {
+ *       "$": "query",
+ *       "table": "",
+ *       "filter": {
+ *         "op": "eq",
+ *         "p1": "",
+ *         "p2": ""
+ *       }
+ *     }
+ *   }
+ * ]
+ */
+interface IQueryExp {
+    $: "query";
+    table: string;
+    filter?: ExpressionedFilter;
+    select?: string[];
+    sorting?: QuerySorting[];
+    count?: boolean;
+    top?: number;
+    skip?: number;
+}
+export declare class QueryExp extends Exp<IQueryExp> {
+    filter: ExpressionedFilter;
+    eval(): _mithril.MithrilPromise<any>;
+    private fetch;
+}
+/**
+ * @markdownDescription
+ * Значение поля по пути
+ *
+ * Возвращается значение поля по пути `path` относительно текущей записи
+ * Сложные пути разделяются символом `/`, например `ID_User/Name`
+ *
+ * Если значение по пути пустое, возвращается `null`
+ *
+ * @defaultSnippets
+ * [
+ *   {
+ *     "label": "Значение поля по пути (field)",
+ *     "body": {
+ *       "$": "field",
+ *       "path": "$1"
+ *     }
+ *   }
+ * ]
+ */
+interface IFieldExp {
+    $: "field";
+    path: string;
+    /** Явно приводит значение к null, если ничего не вернулось. Значение по-умолчанию: true */
+    nullIfEmpty?: boolean;
+}
+export declare class FieldExp extends Exp<IFieldExp> {
+    schema: SchemaManager;
+    eval(): _mithril.MithrilPromise<any>;
+}
+/**
+ * @markdownDescription
+ * Проверка на пустое значение по пути
+ *
+ * Происходит получение значения поля по пути `path` относительно текущей записи и возвращается `true`, если значение пустое
+ *
+ * @defaultSnippets
+ * [
+ *   {
+ *     "label": "Проверка на пустое значение по пути (isFieldEmpty)",
+ *     "body": {
+ *       "$": "isFieldEmpty",
+ *       "path": "$1"
+ *     }
+ *   }
+ * ]
+ */
+interface IIsFieldEmptyExp {
+    $: "isFieldEmpty";
+    path: string;
+}
+export declare class IsFieldEmptyExp extends FieldExp {
+    eval(): _mithril.MithrilPromise<boolean>;
+}
+/**
+ * @markdownDescription
+ * Выбор поля контекста формы
+ *
+ * @defaultSnippets
+ * [
+ *   {
+ * 		"label": "Выбор названия поля контекста формы",
+ * 		"body": {
+ * 			"$": "contextParam",
+ * 			"code": "$1"
+ * 		}
+ *   }
+ * ]
+ */
+interface IContextParamExp {
+    $: "contextParam";
+    code: string;
+    nullIfEmpty?: boolean;
+}
+export declare class ContextParamExp extends Exp<IContextParamExp> {
+    eval(): _mithril.MithrilPromiseProperty<any> & {
+        onchange: (v?: any) => any;
+    };
+}
+export declare class Evaluator {
+    static map: {
+        and: typeof LogicalExp;
+        or: typeof LogicalExp;
+        lt: typeof CompareExp;
+        "<": typeof CompareExp;
+        le: typeof CompareExp;
+        "<=": typeof CompareExp;
+        ge: typeof CompareExp;
+        ">=": typeof CompareExp;
+        gt: typeof CompareExp;
+        ">": typeof CompareExp;
+        "*": typeof MathExp;
+        "-": typeof MathExp;
+        "+": typeof MathExp;
+        "/": typeof MathExp;
+        eq: typeof EqExp;
+        "=": typeof EqExp;
+        ne: typeof NeqExp;
+        "<>": typeof NeqExp;
+        "!=": typeof NeqExp;
+        not: typeof NotExp;
+        field: typeof FieldExp;
+        in: typeof InExp;
+        if: typeof IfExp;
+        sp: typeof StoredProcExp;
+        sqlfn: typeof SqlFunctionExp;
+        prop: typeof PropExp;
+        inGroup: typeof IsInRoleExp;
+        inRole: typeof IsInRoleExp;
+        inGroups: typeof InGroupsExp;
+        query: typeof QueryExp;
+        filter: typeof FilterExp;
+        exp: typeof NamedExp;
+        concat: typeof ConcatExp;
+        userId: typeof UserIdExp;
+        isFieldEmpty: typeof IsFieldEmptyExp;
+        now: typeof NowExp;
+        contextParam: typeof ContextParamExp;
+    };
+    static create(exp: any, ctx: any): any;
+    static exec(exp: any, ctx: any): any;
+}
+export {};

package/types/_core/scripts/services/Extendable.d.ts

@@ -0,0 +1,15 @@
+import { FormCtrl } from "../views/form/form";
+export interface ExtendableMixinEvents {
+    init: ((form: FormCtrl) => void)[];
+    creating?: any[];
+    created?: any[];
+}
+export declare class ExtendableMixin<T, E extends ExtendableMixinEvents> {
+    extPostfix: string;
+    exts: T;
+    events: ExtendableMixinEvents;
+    constructor(extPostfix?: string);
+    ext(fn: any, extName?: any, enabled?: any, defaults?: any): void;
+    getExtName(fn: any): any;
+    register(target: any, code: any, options: any): any;
+}

package/types/_core/scripts/services/Filter.d.ts

@@ -0,0 +1,35 @@
+import { Expressioned } from "./Evaluator";
+import { IFilter as IFilterOrig, IFilterGroup, IFilterIn, IFilterItem, Filter as FilterOrig, FilterSetterOptions } from "./IFilter";
+export declare const FilterUserId = "userId";
+/**
+ * Фильтр
+ *
+ * @default { "op": "eq", "p1": "", "p2": "" }
+ */
+export declare type IFilter = IFilterOrig;
+export declare type ExpressionedFilter = Expressioned<IFilterItem> | Expressioned<IFilterGroup> | Expressioned<IFilterIn>;
+export declare const Filter: typeof FilterOrig;
+export interface IFilterSet {
+    [key: string]: any;
+}
+export declare class FilterSet {
+    all: {};
+    static QUICK: string;
+    static VALUES: string;
+    static EXTENDED: string;
+    static DEFAULT: string;
+    static IN_MEMORY: string;
+    events: {
+        set: any[];
+        clear: any[];
+        update: any[];
+    };
+    constructor(all?: {});
+    clear(keyPart: any): void;
+    get(key?: any): any;
+    set(key: string, filter: IFilter, options?: FilterSetterOptions): void;
+    setQuickFilter(path: string, filter: IFilter, options?: FilterSetterOptions): void;
+    getQuickFilterKey(path: string): string;
+    remove(key: string): void;
+    static is(key: string, keyPart: string): boolean;
+}