eservices-core 1.0.601 → 1.0.602

package/dist/classes/Action.d.ts

@@ -0,0 +1,3 @@
+export default class Action {
+    static wrap(): void;
+}

package/dist/classes/ApplicationManager.d.ts

@@ -0,0 +1,85 @@
+import EventEmitter from "jenesius-event-emitter";
+import { IListCell } from "./new/List";
+import { Router } from "vue-router";
+export interface ICustomerContext {
+    id: number;
+    name: string;
+    email?: string;
+    photo?: string;
+}
+interface IUserInformation {
+    id: number;
+}
+export declare type ApplicationType = 'front' | 'back';
+declare class ApplicationManager extends EventEmitter {
+    #private;
+    static EVENT_CONTEXT_UPDATE: string;
+    static EVENT_READY_UPDATE: string;
+    static EVENT_DATA_UPDATE: string;
+    /**
+     * @description Key for localStorage, saving current context ID. using after user login to system
+     * */
+    static CURRENT_CONTEXT_KEY: string;
+    /**
+     * @description Current customer id. If Application state is not ready - undefined.
+     */
+    contextId?: number;
+    get contextType(): 'person' | 'organization' | undefined;
+    set router(v: Router);
+    /**
+     * @description VueRouter of Application
+     * */
+    get router(): Router;
+    set type(type: ApplicationType);
+    get type(): ApplicationType;
+    get isBack(): boolean;
+    get isFront(): boolean;
+    /**
+     * @description User information. Parent Object.
+     */
+    user?: IUserInformation;
+    /**
+     * @description Person information.
+     */
+    person?: ICustomerContext;
+    /**
+     * @description List of organizations
+     */
+    organizations: ICustomerContext[];
+    set ready(v: boolean);
+    get ready(): boolean;
+    onReady(callback: (v: boolean) => any): () => void;
+    onupdateContext(callback: (id: number) => any): () => void;
+    onupdateData(callback: () => any): () => void;
+    /**
+     * @description Method for update current context. After success emit event[EVENT_UPDATE_CONTEXT]
+     */
+    setCurrentContext(id: number): void;
+    /**
+     * @description Initialization of ApplicationManager
+     */
+    init(): Promise<void>;
+    private loadCustomerData;
+    /**
+     * @description The main method of application. Load the main information about user.
+     * @deprecated
+     */
+    updateFullClientData(): Promise<void>;
+    /**
+     * @description Method using for validate provided ID, Checking with existing person ID and each organization ID.
+     * */
+    private validateContextId;
+    private getListKeyById;
+    getListInformationFromLocalStorage(id: string): {
+        config: IListCell[];
+    } | null;
+    setListInformationToLocalStorage(id: string, info: {
+        config: IListCell[];
+    }): void;
+}
+declare const Manager: ApplicationManager;
+export { ApplicationManager, Manager };
+export declare function useManagerState(): {
+    contextType: "person" | "organization";
+    contextId: number;
+};

package/dist/classes/ClassMetadata.d.ts

@@ -0,0 +1,32 @@
+import { DataType, MetadataResponseFieldInterface, ReferencedEntity } from "../types/metadata-types";
+interface MetadataFieldInterface {
+    disabled: boolean;
+    hidden: boolean;
+    type: DataType | ReferencedEntity;
+}
+export default class Metadata {
+    entity: string;
+    rules: () => any;
+    isReady: import("vue").Ref<boolean>;
+    canUpdate: boolean;
+    fields: {
+        [name: string]: MetadataFieldInterface;
+    };
+    constructor(entity: string, rules: () => any);
+    /**
+     * @description Функция для обновления методынных на основе конфиграции
+     * */
+    update(): Promise<void>;
+    static FieldDTO(data: MetadataResponseFieldInterface): MetadataFieldInterface;
+    /**
+     * @description Вернёт массив полей(имена), которые должныбыть задизейблены
+     * @return {Array} disabledFieldsName
+     */
+    getDisabledFields(): string[];
+    /**
+     * @description Возвращает массив name полей, который не доступны для чтения
+     * (Имеют установки hidden(canRead: false))
+     * */
+    getHiddenFields(): string[];
+}
+export {};

package/dist/classes/Communication.d.ts

@@ -0,0 +1,26 @@
+import EventEmitter from "jenesius-event-emitter";
+export default class Communication extends EventEmitter {
+    /**
+     * @description UniqID of Talk
+     */
+    id: number;
+    constructor(talkId: number);
+    read: () => any;
+    sendMessage(text: string): Promise<import("../services/communication-service").IResultCreatingCommunicationMessage>;
+    static checkAndGenerate(data: any): Promise<{
+        id: number;
+    }>;
+}
+export declare function useCommunication(communication: Communication): {
+    array: {
+        appName: "SCP" | "BAP";
+        catalogId: string;
+        content: string;
+        id: number;
+        personId: number;
+        personName: string;
+        userId: number;
+        userName: string;
+        utcCreated: string;
+    }[];
+};

package/dist/classes/CoreError.d.ts

@@ -0,0 +1,42 @@
+import { Form } from "jenesius-vue-form";
+import { ListChunker } from "../types";
+export default class CoreError extends Error {
+    details: any;
+    id: number;
+    static ID: number;
+    constructor(message: string, details?: any);
+    /**
+     * @description Не удалось найти родительскую форму. Обычно ошибка используется при вызове Form.getParentForm();
+     * */
+    static ParentFormNotFound(): CoreError;
+    /**
+     * ОДИН ИЗ ЭЛЕМЕНТОВ, КОТОРЫЙ ПЫТАЕТСЯ ПОДПИСАТЬСЯ НА ФОРМУ
+     * НЕ ИМЕЕТ ПАРАМЕТРА NAME.
+     * */
+    static UndefinedNameOfCompositeFormController(controller: any): CoreError;
+    static EntityWithoutName(entity: any): CoreError;
+    static NotResolvedNameEventEmitter(name: string): CoreError;
+    static FormIsNotValidated(form: Form): CoreError;
+    static ListWorkerIsRunningOrEnd(listChunker: ListChunker): CoreError;
+    static ObjectIdNotNumber(id: any): CoreError;
+    static UndefinedErrorId(id: number, array: any): CoreError;
+    static ApiError(error: any): CoreError;
+    static ApiNotAvailable(): CoreError;
+    static AuthServiceError(message: string | undefined, errors: string[] | null): CoreError;
+    static ApiResponseParseFailed(): CoreError;
+    static MissingIdInValuesEntity(values: any): CoreError;
+    static ObjectWithIdNotFound(id: number, array: any[]): CoreError;
+    /**
+     * ОШИБКА ДЛЯ ТАБЛИЦЫ, В ТОМ СЛУЧАЕ, ЕСЛИ ОБЪЕКТ НА ОБНОВЛЕНИЕ НЕ СВЯЗАН
+     * С СУЩЕСТВУЮЩИМ ОБЪЕКТОМ ПО _tableId
+     * */
+    static ObjectWithoutConnectToPresentArray(object: any, array: any): CoreError;
+    static EntityWithoutId(object: any): CoreError;
+    static NotFoundedTableIndex(tableIndex: number, table: any): CoreError;
+    /**
+     * Использовать в случае, когда тип ошибки не определён или место её
+     * появления не понятно
+     * */
+    static UndefinedError(str: string, details?: any[]): CoreError;
+    static TableArrayAlreadyIncludeProvidedIndexValue(tableIndex: number, array: any, table: any): CoreError;
+}

package/dist/classes/ErrorStorageSystem.d.ts

@@ -0,0 +1,15 @@
+import CoreError from "./CoreError";
+/**
+ * @deprecated
+ * */
+export default class ErrorStorageSystem {
+    static array: {
+        details: any;
+        id: number;
+        name: string;
+        message: string;
+        stack?: string;
+    }[];
+    static add(error: CoreError): void;
+    static remove(id: number): void;
+}

package/dist/classes/InterfaceForm.d.ts

@@ -0,0 +1,106 @@
+import { FormControllerInterface, Values, ValuesInterface } from "../types";
+import EventEmitter from "jenesius-event-emitter";
+interface DisabledElementsInterface {
+    [name: string]: boolean;
+}
+declare type FunctionHandleData = () => Promise<any> | any | void;
+export interface InterfaceFormParams {
+    name?: string;
+}
+/**
+ * Прафило формы: ИСТИНА находится только форме. Все подконтрольные элементы
+ * должны полагаться(А, если нет), то должны уведомлять форму о изменениях.
+ * Поскольку элемент формы, может быть вариативным и при его изменении и затем
+ * скрытии с формы(по средствам v-if) изменённый элемент пропадёт, а значит и ст
+ * атус формы: changed - тоже пропадёт.
+ * */
+export default class InterfaceForm extends EventEmitter {
+    _isForm: boolean;
+    static FORM_INDICATE_KEY: string;
+    name?: string;
+    /**
+     * values - хранилище данных формы
+     * Хранит внутренне состояния. Нужно для того, чтобы мы пологались не на эле
+     * менты, а только на значение внутри формы. Т.к. элементы могут исчезать с
+     * формы, а вместе с ними, наши значения.
+     * */
+    values: ValuesInterface;
+    dependElements: Array<FormControllerInterface>;
+    /**
+     * @description Реактивный объект
+     * */
+    disabledElements: DisabledElementsInterface;
+    disabled: boolean;
+    /**
+     * Внутреннее состояния объекта, используется для установки внешних значений.
+     * Например, для установки входных параметров в таблицу(идентификатор пользо
+     * ватля, которые потом будет передавать в rowForm)
+     * */
+    state: {
+        [name: string]: any;
+    };
+    /**
+     * Функция для очистки изменений
+     * */
+    cleanChanges: (...[]: Iterable<any>) => any;
+    constructor(props: InterfaceFormParams);
+    setValueItem(elementController: FormControllerInterface, values: Values): void;
+    /**
+     * Возвращает Экземпляр подписанного элемента или undefined
+     * @return {object | undefined} AggregateItem
+     * */
+    findDepend(name: string): FormControllerInterface;
+    /**
+     * @description Метод для подписки на форму
+     * */
+    depend(form: InterfaceForm): void;
+    /**
+     * @description Устанавливает значения в зависимые элементы по name
+     *
+     * @param {Object} values
+     * */
+    setValues(values: ValuesInterface): any;
+    /**
+     * @description Вернёт все значения составляющих компонент формы
+     * @description {name: value...}
+     *
+     * @return {Object} values
+     * */
+    getValues(): ValuesInterface;
+    /**
+     * @description Функция блокирует все элементы: вызывает в связанных элементах функциюю disable. Устанавливает флаг disable = true
+     * @description Если names не установлено - блокирует все поля, иначе, только те, у которых name совпадёт
+     * @param {Array, String, null} names
+     *
+     * */
+    disable(names: Array<string> | void): void;
+    /**
+     * @description Проверяет, является ли элемент по name заблокированным
+     * @param {String} name
+     * @return {Boolean} isDisableElement
+     */
+    checkDisabledElement(name: string): boolean;
+    /**
+     * @description форма либо польность, либо частично разблокирует форму
+     * @param {Array, null} names
+     */
+    enable(names: Array<string> | void): void;
+    /**
+     * @description Проходит по ВСЕМ подписанным на форму объектам, и запускает в них метод validate, если он имеется
+     *
+     * @return {Boolean} isValidate
+     * @description true в случае, если форма полность валидна, false - иначе
+     * */
+    validate(): boolean;
+    /**
+     * Функции, хранящие в себе запросы на получение или обновление данных
+     * А также их getter and setter
+     * */
+    readData: FunctionHandleData;
+    updateData: FunctionHandleData;
+    get update(): () => Promise<any> | any;
+    set update(callback: () => Promise<any> | any);
+    get read(): () => Promise<any> | any;
+    set read(callback: () => Promise<any> | any);
+}
+export {};

package/dist/classes/InterfaceWorker.d.ts

@@ -0,0 +1,15 @@
+/**
+ * InterfaceWorker предназначен для удобного взаимодействия с интерфейсом,исполь
+ * зуется для работы с попапом карточки пользователя, открытия навигационного ме
+ * ню, обработка текущего активного элемента в навигационном меню.
+ *
+ * */
+export default class InterfaceWorker {
+    isNavigation: import("vue").Ref<boolean>;
+    isMobileNavigation: import("vue").Ref<boolean>;
+    isUserCard: import("vue").Ref<boolean>;
+    constructor();
+    toggleNavigation(v?: boolean): void;
+    toggleMobileNavigation(v?: boolean): void;
+    toggleUserCard(v?: boolean): void;
+}

package/dist/classes/List.d.ts

@@ -0,0 +1,102 @@
+import { TableRowController, Values, ValuesInterface } from "../types";
+import EventEmitter from "jenesius-event-emitter";
+export interface ListCell {
+    title?: string;
+    name?: string | string[];
+    value?: (x: Values, obj: ValuesInterface) => Values;
+    link?: (obj: ValuesInterface) => any;
+    type?: "date" | "dateWithTime" | 'toggle' | 'select' | 'edit' | 'remove';
+    icon?: string;
+    class?: string | string[];
+    onClick?: (x: Values, obj: TableRowController) => void;
+    href?: (x: Values, obj: ValuesInterface) => string;
+}
+export default class List extends EventEmitter {
+    #private;
+    static EVENT_DATA: string;
+    static EVENT_CHANGE_WAIT: string;
+    /**
+     * Entity Name
+     * */
+    name: string;
+    set wait(v: boolean);
+    get wait(): boolean;
+    constructor(config: IListConfig);
+    /**
+     * @description Hash для значений filter, order
+     * */
+    hashParams: string;
+    offset: number;
+    read(ReadParams: IReadParams): Promise<void>;
+    set array(data: any[]);
+    add(array: any[]): void;
+    get array(): any[];
+    /**
+     * @description Function get all names from Config.
+     * */
+    static GetFieldNames<T extends {
+        name?: string | string[];
+    }>(config: T[]): string[];
+    /**
+     * @description Получение стандартной информации из ячейки и значений. {name, value}
+     * @example
+     *   cell: { name: ['title', 'id'], value: (x) => `${x}_${x}` }
+     *   values: {id: 1, title: "GG"}
+     * Output: { name: 'title', value: 'GG_GG'}
+     */
+    static getCellInfo<T extends Pick<ListCell, 'name' | 'value'>>(cell: T, rowValues: any): {
+        name: string;
+        value: Values;
+    };
+    static getCellName<T extends Pick<ListCell, 'name'>>(cell: T): string;
+}
+export declare function useListState(list: List): {
+    array: any[];
+    state: {
+        wait: boolean;
+    };
+};
+export declare function useListOrder(defaultOrder: ISortConfig, onSort: any): {
+    order: import("vue").Ref<{
+        name: string;
+        duration: "desc" | "asc";
+    }>;
+};
+export declare function useListFilter(defaultFilter: {
+    [name: string]: any;
+}, onFilter: any): {
+    filters: import("vue").Ref<{
+        [name: string]: any;
+    }>;
+};
+export interface IListConfig {
+    name: string;
+}
+export declare type ListCellType = "date" | "dateWithTime" | 'toggle' | 'select';
+export interface IListCell {
+    title?: string;
+    name?: string | string[];
+    value?: (x: Values, obj: ValuesInterface) => Values;
+    link?: (x: Values, obj: ValuesInterface) => any;
+    type?: ListCellType;
+    class?: string | string[];
+    onClick?: (x: Values, obj: TableRowController) => void;
+    href?: (x: Values, obj: ValuesInterface) => string;
+}
+export interface IReadParams {
+    fields?: string[];
+    order?: ISortConfig;
+    filter?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface ISortConfig {
+    name: string;
+    duration: 'desc' | 'asc';
+}
+export interface IFilterConfig {
+    title: string;
+    name: string;
+    type: "enum";
+    options: any;
+}

package/dist/classes/ListWorker.d.ts

@@ -0,0 +1,2 @@
+import { ListChunker } from "../types";
+export default function ListWorker(request: (v: any) => any): ListChunker;

package/dist/classes/Metadata.d.ts

@@ -0,0 +1,51 @@
+import EventEmitter from "jenesius-event-emitter";
+export default class Metadata extends EventEmitter {
+    state: MetadataState;
+    constructor();
+    /**
+     * @description Устанавливает значение матаданных
+     * */
+    set(data: MetadataResponse): void;
+    /**
+     * @description Вернёт массив полей(имена), которые должныбыть задизейблены
+     * @return {Array} disabledFieldsName
+     */
+    getDisabledFields(): string[];
+    /**
+     * @description Возвращает массив name полей, который не доступны для чтения
+     * (Имеют установки hidden(canRead: false))
+     * */
+    getHiddenFields(): string[];
+}
+export interface MetadataState {
+    ready: boolean;
+    set?: any;
+    disabled?: boolean;
+    fields: {
+        [name: string]: MetadataField;
+    };
+}
+interface MetadataField {
+    disabled: boolean;
+    hidden: boolean;
+    type: DataType | ReferencedEntity;
+}
+export interface MetadataResponse {
+    canCreate: boolean;
+    canDelete: boolean;
+    canRead: boolean;
+    canUpdate: boolean;
+    canUse: boolean;
+    name: string;
+    fields: MetadataResponseField[];
+}
+declare type DataType = 'Entity' | 'String' | 'Integer' | 'Byte' | 'DateTime';
+declare type ReferencedEntity = 'Customer' | 'ApplicationType' | 'ApplicationStatus';
+interface MetadataResponseField {
+    canGet: boolean;
+    canSet: boolean;
+    name: string;
+    dataType: DataType;
+    referencedEntity: ReferencedEntity | null;
+}
+export {};

package/dist/classes/NotificationSystem.d.ts

@@ -0,0 +1,39 @@
+declare const _default: {
+    /**
+     * @description Array of current cards.
+     */
+    store: {
+        id: number;
+        type: "error" | "warning" | "info";
+        msg: string;
+        children?: {
+            id: number;
+            msg: string;
+        }[];
+    }[];
+    /**
+     * @description Adding new card to store
+     */
+    add(type: INotificationCard["type"], msg: string, { children, timeout }?: {
+        children?: string[];
+        timeout?: number;
+    }): void;
+    /**
+     * @description Function remove item by id. Return true if card was founded, otherwise false.
+     * */
+    remove(id: number): boolean;
+    /**
+     * @description Removing child message, Throwing error if card of children not founded.
+     * */
+    removeChild(cardId: number, childId: number): void;
+};
+export default _default;
+export interface INotificationCard {
+    id: number;
+    type: 'error' | 'warning' | 'info';
+    msg: string;
+    children?: {
+        id: number;
+        msg: string;
+    }[];
+}

package/dist/classes/ProcessWrap.d.ts

@@ -0,0 +1,9 @@
+interface ProcessWrapInterface {
+    wait: boolean;
+    error: boolean;
+    call: (...a: any) => void;
+    setFunction: (newFunc: (...a: any) => any) => void;
+    ready: boolean;
+}
+export default function ProcessWrap(fn?: (...a: any) => any): ProcessWrapInterface;
+export {};

package/dist/classes/StepWorker.d.ts

@@ -0,0 +1,9 @@
+export default class StepWorker {
+    count: number;
+    constructor(count: number);
+    current: import("vue").Ref<number>;
+    last: import("vue").ComputedRef<boolean>;
+    first: import("vue").ComputedRef<boolean>;
+    next(): void;
+    prev(): void;
+}

package/dist/classes/_List.d.ts

@@ -0,0 +1,66 @@
+import { ComputedRef, VNode } from "vue";
+import { ListRowValues, Values } from "../types";
+import EventEmitter from "jenesius-event-emitter";
+import { ListCell } from "./List";
+export interface ListParams {
+    config: ComputedRef<ListCell[]>;
+}
+/**
+ * @deprecated
+ * */
+export default class List extends EventEmitter {
+    static EVENT_ORDER: string;
+    config: ComputedRef<ListCell[]>;
+    array: {
+        [name: string]: any;
+    }[];
+    orderField: string;
+    orderDirection: string;
+    constructor(props: ListParams);
+    cleanArray(): void;
+    setArray(array: List["array"]): void;
+    order(fieldName: string, pos: 'asc' | 'desc'): void;
+    /**
+     * @description Статик метод для получения VNode для Строки
+     *
+     * @param {ListCell[]} config - конфигурация списка
+     * @param {ListRowValues} rowValues - значения для одной строки
+     * */
+    static getRow(config: ListCell[], rowValues: ListRowValues): VNode | VNode[];
+    /**
+     * @return { {name: string, value: any} } CellInfo
+     * */
+    static getCellInfo(cell: ListCell, rowValues: ListRowValues): {
+        name: string;
+        value: Values;
+    };
+    /**
+     * @description Статик метод для получения VNode для Ячейки
+     *
+     * @param {ListCell} cellConfig - конфигурация Ячейки
+     * @param {ListRowValues} rowValues - значения Строки
+     * @param {string} cellName - имя Ячейки
+     * @param {values} cellValue - значение ячейки
+     * */
+    static getCell(cellConfig: ListCell, rowValues: ListRowValues, cellName: string | null, cellValue: Values, list?: List): VNode[];
+    /**
+     * @description Принимает конфигурацию списка
+     * @return <String>Array Возвращает массив, содержащий все имена полей из ко
+     * нфигурации
+     * */
+    static getNamesFromConfig(config: ListCell[]): string[];
+    /**
+     * @description Вернёт название ячеки, учитывая все значения поля name
+     * Если значением поля name выступает массив, то вернёт первый элемент масси
+     * ва
+     * */
+    static getCellName(cell: ListCell): string | null;
+}
+export declare function useListState(list: List): {
+    state: {
+        order: {
+            field: string;
+            direction: string;
+        };
+    };
+};