bx-rest 0.0.10 → 0.0.12

package/fesm2020/bx-rest.mjs

@@ -1,37 +1,23 @@
 import * as i0 from '@angular/core';
-import { NgModule, Injectable } from '@angular/core';
-import { MatIconModule } from '@angular/material/icon';
-import { MatButtonModule } from '@angular/material/button';
+import { Injectable, NgModule, inject, Component, ViewEncapsulation, Inject } from '@angular/core';
 import { DateTime } from 'luxon';
-import { take, of } from 'rxjs';
-import { tap, map, mergeMap, first } from 'rxjs/operators';
+import { Subscription, filter, take, of, throwError, forkJoin, mergeMap } from 'rxjs';
+import { map, catchError, tap, mergeMap as mergeMap$1, first } from 'rxjs/operators';
 import clone from 'just-clone';
 import compare from 'just-compare';
+import * as i1$1 from '@angular/material/snack-bar';
+import { MatSnackBarRef, MAT_SNACK_BAR_DATA } from '@angular/material/snack-bar';
+import * as i2 from '@angular/material/icon';
+import { MatIconModule } from '@angular/material/icon';
+import * as i1 from '@angular/material/button';
+import { MatButtonModule } from '@angular/material/button';
+import * as i1$2 from '@ngrx/store';
 import { createAction, props, createReducer, on } from '@ngrx/store';
-
-class BxRestModule {
-}
-BxRestModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BxRestModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-BxRestModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: BxRestModule, imports: [MatIconModule,
-        MatButtonModule], exports: [MatButtonModule,
-        MatIconModule] });
-BxRestModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BxRestModule, imports: [MatIconModule,
-        MatButtonModule, MatButtonModule,
-        MatIconModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BxRestModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [],
-                    imports: [
-                        MatIconModule,
-                        MatButtonModule
-                    ],
-                    exports: [
-                        MatButtonModule,
-                        MatIconModule
-                    ]
-                }]
-        }] });
+import * as i2$1 from '@angular/router';
+import flatten from 'just-flatten-it';
+import * as i1$3 from '@angular/common/http';
+import { HttpParams } from '@angular/common/http';
+import * as i3 from '@angular/common';
 
 const time = {
     oneDayMilliseconds: 1000 * 60 * 60 * 24
@@ -206,6 +192,1007 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                 }]
         }] });
 
+class BxRestModule {
+}
+BxRestModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BxRestModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+BxRestModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: BxRestModule, imports: [MatIconModule,
+        MatButtonModule], exports: [MatButtonModule,
+        MatIconModule] });
+BxRestModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BxRestModule, imports: [MatIconModule,
+        MatButtonModule, MatButtonModule,
+        MatIconModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BxRestModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [
+                        MatIconModule,
+                        MatButtonModule
+                    ],
+                    exports: [
+                        MatButtonModule,
+                        MatIconModule
+                    ]
+                }]
+        }] });
+
+class ToastMessageComponent {
+    constructor(data) {
+        this.data = data;
+        this.snackBarRef = inject(MatSnackBarRef);
+    }
+    getClass() {
+        switch (this.data.type) {
+            case 'error':
+            case 'warning':
+            case 'success':
+                return this.data.type + '-message';
+        }
+        return '';
+    }
+}
+ToastMessageComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ToastMessageComponent, deps: [{ token: MAT_SNACK_BAR_DATA }], target: i0.ɵɵFactoryTarget.Component });
+ToastMessageComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: ToastMessageComponent, isStandalone: true, selector: "app-view", ngImport: i0, template: "<div class=\"w-100 d-flex\">\n  <span matSnackBarLabel [class]=\"getClass()\">\n  {{ data.message }}\n</span>\n  <span matSnackBarActions [class]=\"getClass()\">\n  <button mat-button matSnackBarAction (click)=\"snackBarRef.dismissWithAction()\">\n    <mat-icon>\n      close\n    </mat-icon>\n  </button>\n</span>\n</div>\n\n", styles: [":host{display:flex;background-color:red}:host .mdc-snackbar__surface{padding:0;margin:0}:host .error-message{color:red}:host.error-box{background-color:#eec1c1}:host.error-box .error-message{color:red}mat-snack-bar-container.mdc-snackbar.error-box .mdc-snackbar__surface{background-color:#eec1c1}mat-snack-bar-container.mdc-snackbar.error-box .error-message{color:red}mat-snack-bar-container.mdc-snackbar.warning-box .mdc-snackbar__surface{background-color:#f0f2b9}mat-snack-bar-container.mdc-snackbar.warning-box .warning-message{color:#15140f}mat-snack-bar-container.mdc-snackbar.success-box .mdc-snackbar__surface{background-color:#daf7d1}mat-snack-bar-container.mdc-snackbar.success-box .success-message{color:#423f31}\n"], dependencies: [{ kind: "ngmodule", type: BxRestModule }, { kind: "component", type: i1.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "component", type: i2.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ToastMessageComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-view', encapsulation: ViewEncapsulation.None, standalone: true, imports: [BxRestModule], template: "<div class=\"w-100 d-flex\">\n  <span matSnackBarLabel [class]=\"getClass()\">\n  {{ data.message }}\n</span>\n  <span matSnackBarActions [class]=\"getClass()\">\n  <button mat-button matSnackBarAction (click)=\"snackBarRef.dismissWithAction()\">\n    <mat-icon>\n      close\n    </mat-icon>\n  </button>\n</span>\n</div>\n\n", styles: [":host{display:flex;background-color:red}:host .mdc-snackbar__surface{padding:0;margin:0}:host .error-message{color:red}:host.error-box{background-color:#eec1c1}:host.error-box .error-message{color:red}mat-snack-bar-container.mdc-snackbar.error-box .mdc-snackbar__surface{background-color:#eec1c1}mat-snack-bar-container.mdc-snackbar.error-box .error-message{color:red}mat-snack-bar-container.mdc-snackbar.warning-box .mdc-snackbar__surface{background-color:#f0f2b9}mat-snack-bar-container.mdc-snackbar.warning-box .warning-message{color:#15140f}mat-snack-bar-container.mdc-snackbar.success-box .mdc-snackbar__surface{background-color:#daf7d1}mat-snack-bar-container.mdc-snackbar.success-box .success-message{color:#423f31}\n"] }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_SNACK_BAR_DATA]
+                }] }]; } });
+
+/**
+ * Сервис для вывода сообщений пользователю
+ * TODO: логирование
+ */
+class SnackBarService {
+    constructor(snackBar) {
+        this.snackBar = snackBar;
+    }
+    error(message, sec = 12) {
+        this.standardMessage(message, sec, 'error');
+    }
+    warning(message, sec = 7) {
+        this.standardMessage(message, sec, 'warning');
+    }
+    success(message, sec = 7) {
+        this.standardMessage(message, sec, 'success');
+    }
+    standardMessage(message, sec = 5, name = 'error') {
+        this.snackBar.open(message);
+        this.snackBar.openFromComponent(ToastMessageComponent, {
+            duration: sec * 1000,
+            data: {
+                message: message,
+                type: name
+            },
+            panelClass: name + '-box'
+        });
+    }
+}
+SnackBarService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SnackBarService, deps: [{ token: i1$1.MatSnackBar }], target: i0.ɵɵFactoryTarget.Injectable });
+SnackBarService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SnackBarService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SnackBarService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1$1.MatSnackBar }]; } });
+
+// Generate an internal UID to make the regexp pattern harder to guess.
+const UID_LENGTH = 16;
+const UID = generateUID();
+const PLACE_HOLDER_REGEXP = new RegExp('(\\\\)?"@__(F|R|D|M|S|A|U|I|B|L)-' + UID + '-(\\d+)__@"', 'g');
+const IS_NATIVE_CODE_REGEXP = /\{\s*\[native code]\s*}/g;
+const IS_PURE_FUNCTION = /function.*?\(/;
+const IS_ARROW_FUNCTION = /.*?=>.*?/;
+const UNSAFE_CHARS_REGEXP = /[<>\/\u2028\u2029]/g;
+const RESERVED_SYMBOLS = ['*', 'async'];
+// Mapping of unsafe HTML and invalid JavaScript line terminator chars to their
+// Unicode char counterparts which are safe to use in JavaScript strings.
+const ESCAPED_CHARS = {
+    '<': '\\u003C',
+    '>': '\\u003E',
+    '/': '\\u002F',
+    '\u2028': '\\u2028',
+    '\u2029': '\\u2029'
+};
+function escapeUnsafeChars(unsafeChar) {
+    return (ESCAPED_CHARS.hasOwnProperty(unsafeChar)) ? ESCAPED_CHARS[unsafeChar] : '';
+}
+function generateUID() {
+    let bytes = window.crypto.getRandomValues(new Uint32Array(UID_LENGTH));
+    let result = '';
+    for (let i = 0; i < UID_LENGTH; ++i) {
+        result += bytes[i].toString(16);
+    }
+    return result;
+}
+function deleteFunctions(obj) {
+    let functionKeys = [];
+    for (let key in obj) {
+        if (typeof obj[key] === "function") {
+            functionKeys.push(key);
+        }
+    }
+    for (let i = 0; i < functionKeys.length; i++) {
+        delete obj[functionKeys[i]];
+    }
+}
+function serialize(obj, options = {}) {
+    // Backwards-compatibility for `space` as the second argument.
+    if (typeof options === 'number' || typeof options === 'string') {
+        options = { space: options };
+    }
+    let functions = [];
+    let regexps = [];
+    let dates = [];
+    let maps = [];
+    let sets = [];
+    let arrays = [];
+    let undefs = [];
+    let infinities = [];
+    let bigInts = [];
+    let urls = [];
+    // Returns placeholders for functions and regexps (identified by index)
+    // which are later replaced by their string representation.
+    function replacer(key, value) {
+        // For nested function
+        if (options.ignoreFunction) {
+            deleteFunctions(value);
+        }
+        if (!value && value !== undefined) {
+            return value;
+        }
+        // let origValue: any = this[key];
+        let origValue = value;
+        let type = typeof origValue;
+        switch (type) {
+            case 'object':
+                if (origValue instanceof RegExp) {
+                    return '@__R-' + UID + '-' + (regexps.push(origValue) - 1) + '__@';
+                }
+                else if (origValue instanceof Date) {
+                    return '@__D-' + UID + '-' + (dates.push(origValue) - 1) + '__@';
+                }
+                else if (origValue instanceof Map) {
+                    return '@__M-' + UID + '-' + (maps.push(origValue) - 1) + '__@';
+                }
+                else if (origValue instanceof Set) {
+                    return '@__S-' + UID + '-' + (sets.push(origValue) - 1) + '__@';
+                }
+                if (origValue instanceof Array) {
+                    let isSparse = origValue.filter(function () {
+                        return true;
+                    }).length !== origValue.length;
+                    if (isSparse) {
+                        return '@__A-' + UID + '-' + (arrays.push(origValue) - 1) + '__@';
+                    }
+                }
+                if (origValue instanceof URL) {
+                    return '@__L-' + UID + '-' + (urls.push(origValue) - 1) + '__@';
+                }
+                break;
+            case 'function':
+                return '@__F-' + UID + '-' + (functions.push(origValue) - 1) + '__@';
+            case 'undefined':
+                return '@__U-' + UID + '-' + (undefs.push(origValue) - 1) + '__@';
+            case 'number':
+                return '@__I-' + UID + '-' + (infinities.push(origValue) - 1) + '__@';
+            case 'bigint':
+                return '@__B-' + UID + '-' + (bigInts.push(origValue) - 1) + '__@';
+        }
+        return value;
+    }
+    function serializeFunc(fn) {
+        let serializedFn = fn.toString();
+        if (IS_NATIVE_CODE_REGEXP.test(serializedFn)) {
+            throw new TypeError('Serializing native function: ' + fn.name);
+        }
+        // pure functions, example: {key: function() {}}
+        if (IS_PURE_FUNCTION.test(serializedFn)) {
+            return serializedFn;
+        }
+        // arrow functions, example: arg1 => arg1+5
+        if (IS_ARROW_FUNCTION.test(serializedFn)) {
+            return serializedFn;
+        }
+        let argsStartsAt = serializedFn.indexOf('(');
+        let def = serializedFn.slice(0, argsStartsAt)
+            .trim()
+            .split(' ')
+            .filter(function (val) {
+            return val.length > 0;
+        });
+        let nonReservedSymbols = def.filter(function (val) {
+            return RESERVED_SYMBOLS.indexOf(val) === -1;
+        });
+        // enhanced literal objects, example: {key() {}}
+        if (nonReservedSymbols.length > 0) {
+            return (def.indexOf('async') > -1 ? 'async ' : '') + 'function'
+                + (def.join('').indexOf('*') > -1 ? '*' : '')
+                + serializedFn.slice(argsStartsAt);
+        }
+        // arrow functions
+        return serializedFn;
+    }
+    // Check if the parameter is function
+    if (options.ignoreFunction && typeof obj === "function") {
+        obj = undefined;
+    }
+    // Protects against `JSON.stringify()` returning `undefined`, by serializing
+    // to the literal string: "undefined".
+    if (obj === undefined) {
+        return String(obj);
+    }
+    let str = '';
+    // Creates a JSON string representation of the value.
+    // NOTE: Node 0.12 goes into slow mode with extra JSON.stringify() args.
+    if (options.isJSON && !options.space) {
+        str = JSON.stringify(obj);
+    }
+    else {
+        str = JSON.stringify(obj, options.isJSON ? undefined : replacer, options.space);
+    }
+    // Replace unsafe HTML and invalid JavaScript line terminator chars with
+    // their safe Unicode char counterpart. This _must_ happen before the
+    // regexps and functions are serialized and added back to the string.
+    if (options.unsafe !== true) {
+        str = str.replace(UNSAFE_CHARS_REGEXP, escapeUnsafeChars);
+    }
+    if (functions.length === 0 && regexps.length === 0 && dates.length === 0 && maps.length === 0 && sets.length === 0 && arrays.length === 0 && undefs.length === 0 && infinities.length === 0 && bigInts.length === 0 && urls.length === 0) {
+        return str;
+    }
+    // Replaces all occurrences of function, regexp, date, map and set placeholders in the
+    // JSON string with their string representations. If the original value can
+    // not be found, then `undefined` is used.
+    return str.replace(PLACE_HOLDER_REGEXP, function (match, backSlash, type, valueIndex) {
+        // The placeholder may not be preceded by a backslash. This is to prevent
+        // replacing things like `"a\"@__R-<UID>-0__@"` and thus outputting
+        // invalid JS.
+        if (backSlash) {
+            return match;
+        }
+        switch (type) {
+            case 'D':
+                return "new Date(\"" + dates[valueIndex].toISOString() + "\")";
+            case 'R':
+                return "new RegExp(" + serialize(regexps[valueIndex].source) + ", \"" + regexps[valueIndex].flags + "\")";
+            case 'M':
+                return "new Map(" + serialize(Array.from(maps[valueIndex].entries()), options) + ")";
+            case 'S':
+                return "new Set(" + serialize(Array.from(sets[valueIndex].values()), options) + ")";
+            case 'A':
+                return "Array.prototype.slice.call(" + serialize(Object.assign({ length: arrays[valueIndex].length }, arrays[valueIndex]), options) + ")";
+            case 'U':
+                return 'undefined';
+            case 'I':
+                return infinities[valueIndex];
+            case 'B':
+                return "BigInt(\"" + bigInts[valueIndex] + "\")";
+            case 'L':
+                return "new URL(\"" + urls[valueIndex].toString() + "\")";
+        }
+        let fn = functions[valueIndex];
+        return serializeFunc(fn);
+    });
+}
+
+class JSONServices {
+    static deserialize(data) {
+        return eval('(' + data + ')');
+    }
+    static serialize(data) {
+        return serialize(data);
+    }
+}
+JSONServices.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: JSONServices, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+JSONServices.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: JSONServices, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: JSONServices, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class CookiesServices {
+    static get(name) {
+        const results = document.cookie.match('(^|;) ?' + name + '=([^;]*)(;|$)');
+        if (results)
+            return results[2];
+        else
+            return '';
+    }
+    static set(name, value, age = 0) {
+        let string = name + '=' + value + ';';
+        if (age) {
+            string += ' max-age=' + age;
+        }
+        string += '; SameSite=None; Secure';
+        document.cookie = string;
+    }
+    static setObj(name, value, age = 0) {
+        let string = name + '=' + JSONServices.serialize(value) + ';';
+        if (age) {
+            string += ' max-age=' + age;
+        }
+        string += '; SameSite=None; Secure';
+        document.cookie = string;
+    }
+    static getObj(name) {
+        const results = document.cookie.match('(^|;) ?' + name + '=([^;]*)(;|$)');
+        if (results) {
+            return JSONServices.deserialize(results[2]);
+        }
+        return false;
+    }
+}
+CookiesServices.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CookiesServices, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CookiesServices.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CookiesServices, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CookiesServices, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+const save$1 = createAction('[Auth Component] Save', props());
+const saveAccessToken = createAction('[Auth Component] SaveAccessToken', props());
+const initialState$1 = {
+    access_token: '',
+    client_endpoint: '',
+    domain: '',
+    expires: 0,
+    expires_in: 0,
+    member_id: '',
+    refresh_token: '',
+    scope: '',
+    server_endpoint: '',
+    status: '',
+    user_id: 0
+};
+const _authReducer = createReducer(initialState$1, on(saveAccessToken, (s, data) => {
+    let copy = clone(s);
+    return Object.assign(copy, data);
+}));
+function authReducer(state = initialState$1, action) {
+    return _authReducer(state, action);
+}
+
+class LocalStorageServices {
+    static get(name) {
+        return localStorage.getItem(name);
+    }
+    static getObj(name) {
+        return JSONServices.deserialize(localStorage.getItem(name));
+    }
+    static set(name, value) {
+        localStorage.setItem(name, value);
+    }
+    static setObj(name, value) {
+        let get = this.get(name);
+        if (get && typeof get === 'object') {
+            localStorage.setItem(name, JSONServices.serialize(Object.assign(get, value)));
+        }
+        else {
+            localStorage.setItem(name, JSONServices.serialize(value));
+        }
+    }
+    static del(name) {
+        localStorage.removeItem(name);
+    }
+}
+LocalStorageServices.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LocalStorageServices, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+LocalStorageServices.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LocalStorageServices, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LocalStorageServices, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class RestServices {
+    constructor() {
+        this.BX24 = false;
+        // @ts-ignore
+        this.BX24 = (window.BX24) ? window.BX24 : false;
+    }
+    init(callBack) {
+        return (this.BX24) ? this.BX24.init(callBack) : false;
+    }
+}
+RestServices.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RestServices, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+RestServices.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RestServices, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RestServices, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class SessionKeyServices extends BaseServices {
+    constructor(store, route, BxApiLib) {
+        super();
+        this.store = store;
+        this.route = route;
+        this.BxApiLib = BxApiLib;
+        this.authHave = false;
+        this.subscribe = {
+            authData: new Subscription()
+        };
+        this.authData$ = this.store.select('auth');
+        this.authData$.subscribe(authData => {
+            if ((authData && !authData.access_token.length) || !authData) {
+                // получаем токен по собственным каналом (в битриксе приложение trace:apps.trace)
+                window.addEventListener('message', (event) => {
+                    if (event.origin !== window.origin) { // проверяем что это не наше сообщение (с текущего приложения)
+                        if (event.data && event.data.param) {
+                            if (typeof event.data.param === 'string') {
+                                event.data.param = JSON.parse(event.data.param);
+                            }
+                            let save = {};
+                            if (event.data.param.access_token) {
+                                let param = event.data.param;
+                                save.access_token = event.data.param.access_token;
+                                save = {
+                                    access_token: (param.access_token) ? param.access_token : undefined,
+                                    client_endpoint: (param.client_endpoint) ? param.client_endpoint : undefined,
+                                    domain: (param.domain) ? param.domain : undefined,
+                                    expires: (param.expires) ? param.expires : undefined,
+                                    expires_in: (param.expires_in) ? param.expires_in : undefined,
+                                    member_id: (param.member_id) ? param.member_id : undefined,
+                                    refresh_token: (param.refresh_token) ? param.refresh_token : undefined,
+                                    scope: (param.scope) ? param.scope : undefined,
+                                    server_endpoint: (param.server_endpoint) ? param.server_endpoint : undefined,
+                                    status: (param.status) ? param.status : undefined,
+                                    user_id: (param.user_id) ? param.user_id : undefined,
+                                    type: (param.type) ? param.type : undefined,
+                                };
+                            }
+                            if (Object.keys(save).length && save.access_token) {
+                                this.store.dispatch(saveAccessToken(save));
+                                this.subscribeAll();
+                            }
+                        }
+                    }
+                });
+                this.subscribe.authData = this.route.queryParamMap
+                    .pipe(filter(param => param.has('AUTH_ID')
+                    || param.has('access_token')
+                    || param.has('REFRESH_ID')
+                    || param.has('DOMAIN')))
+                    .subscribe((param) => {
+                    let save = {};
+                    if (param.has('AUTH_ID') && !authData.access_token.length) {
+                        const get = param.get('AUTH_ID');
+                        if (get) {
+                            CookiesServices.set('auth', get); // потом убрать
+                            save.access_token = get;
+                        }
+                    }
+                    if (param.has('access_token') && !authData.access_token.length) {
+                        const get = param.get('access_token');
+                        if (get) {
+                            CookiesServices.set('auth', get); // потом убрать
+                            save.access_token = get;
+                        }
+                    }
+                    if (param.has('REFRESH_ID') && !authData.refresh_token.length) {
+                        const get = param.get('REFRESH_ID');
+                        if (get) {
+                            save.refresh_token = get;
+                        }
+                    }
+                    if (param.has('DOMAIN') && !authData.domain.length) {
+                        const get = param.get('DOMAIN');
+                        if (get) {
+                            save.domain = get;
+                        }
+                    }
+                    if (Object.keys(save).length && save.access_token) {
+                        this.store.dispatch(saveAccessToken(save));
+                        this.subscribeAll();
+                    }
+                    else {
+                        // если битрикс не шлёт нужные мне параметры на прямую
+                        // просим их мне отдать так как описано это в документации
+                        let f = () => {
+                            if (this.BxApiLib.BX24) {
+                                const initDate = this.BxApiLib.BX24.getAuth();
+                                this.store.dispatch(saveAccessToken(initDate));
+                            }
+                        };
+                        this.BxApiLib.init(f);
+                    }
+                });
+            }
+            else if (this.getAuth().length) {
+                this.authHave = true;
+            }
+            this.authData = authData;
+        });
+    }
+    subscribeAll() {
+        this.subscribe.authData.unsubscribe();
+    }
+    getAuth() {
+        if (window.BX && window.BX.bitrix_sessid()) {
+            return window.BX.bitrix_sessid();
+        }
+        else if (this.getSessid().length) {
+            let str = this.getSessid();
+            return (str) ? str : '';
+        }
+        else {
+            return CookiesServices.get('auth');
+        }
+    }
+    getKeyAuth() {
+        if (window.BX && window.BX.bitrix_sessid()
+            || this.getSessid().length) {
+            return 'sessid';
+        }
+        else {
+            return 'auth';
+        }
+    }
+    getSessid() {
+        const check = new URLSearchParams(document.location.search).get('sessid');
+        if (check) {
+            LocalStorageServices.set('sessid', check);
+            return check;
+        }
+        else if (LocalStorageServices.get('sessid')) {
+            return LocalStorageServices.get('sessid');
+        }
+        return '';
+    }
+    setAuthParams(params) {
+        const keyAuth = this.getKeyAuth();
+        if (params[keyAuth]) {
+            return true;
+        }
+        else if (keyAuth) {
+            params[keyAuth] = this.getAuth();
+            return true;
+        }
+        return false;
+    }
+    getAuthParams() {
+        // if (env.production && !env.component) {
+        return this.authData$.pipe(take(1), map(v => (v) ? v.access_token : undefined));
+        // } else {
+        //     return of(this.getAuth())
+        // }
+    }
+    getBaseUrl() {
+        return this.authData$.pipe(map(v => (v && v.domain) ? this.prepareBaseAddress(v.domain, 'b24.trace-studio.com') : undefined));
+    }
+}
+SessionKeyServices.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SessionKeyServices, deps: [{ token: i1$2.Store }, { token: i2$1.ActivatedRoute }, { token: RestServices }], target: i0.ɵɵFactoryTarget.Injectable });
+SessionKeyServices.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SessionKeyServices, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SessionKeyServices, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1$2.Store }, { type: i2$1.ActivatedRoute }, { type: RestServices }]; } });
+
+class HttpData extends BaseServices {
+    constructor() {
+        super(...arguments);
+        this.defSettings = {
+            timeZone: {
+                calc: true,
+                levelOut: false
+            }
+        };
+    }
+    getHttpParamsGet(// не так уж и сложно сделать сложенный HttpParams, да гугл?
+    obj, sendHttpParams = new HttpParams(), thisArray = false, nesting = [], 
+    // settings = this.defSettings
+    _ = this.defSettings) {
+        for (const key in obj) {
+            let setKey = '';
+            if (nesting.length) {
+                let first = nesting[0];
+                setKey = (nesting.length > 1)
+                    ? first + '[' + nesting.slice(1).join('][') + '][' + key + ']'
+                    : first + '[' + key + ']';
+            }
+            else {
+                setKey = key;
+            }
+            switch (typeof obj[key]) {
+                case 'string':
+                    sendHttpParams = sendHttpParams.set(setKey, obj[key]);
+                    break;
+                case 'symbol':
+                case 'number':
+                case 'bigint':
+                case 'boolean':
+                    sendHttpParams = sendHttpParams.set(setKey, String(obj[key]));
+                    break;
+                case 'object':
+                    nesting.push(key);
+                    sendHttpParams = this.getHttpParamsGet(obj[key], sendHttpParams, false, nesting);
+                    nesting.pop();
+                    break;
+                case 'function':
+                case 'undefined':
+                default:
+                    console.error('Ты отправил что-то не то', obj[key], typeof obj[key], typeof obj);
+            }
+        }
+        return sendHttpParams;
+    }
+    getHttpParamsPost(obj, sendHttpParams = new FormData(), thisArray = false, nesting = [], settings = this.defSettings) {
+        if (obj instanceof Blob) {
+            let first = nesting[0];
+            let setKey = (nesting.length > 1)
+                ? first + '[' + nesting.slice(1).join('][') + ']'
+                : first;
+            sendHttpParams.set(setKey, obj);
+            return sendHttpParams;
+        }
+        else if (obj instanceof Date) {
+            let first = nesting[0];
+            let tzoffset = (settings.timeZone.calc) ? obj.getTimezoneOffset() * 60000 : 0; // вычисляем влияние часового пояса
+            let levelOut = (settings.timeZone.levelOut) ? obj.getTimezoneOffset() * 60000 : 0; // вычисляем влияние часового пояса
+            let setKey = (nesting.length > 1)
+                ? first + '[' + nesting.slice(1).join('][') + ']'
+                : first;
+            sendHttpParams.set(setKey, (new Date(obj.valueOf() + tzoffset - levelOut)).toISOString());
+            return sendHttpParams;
+        }
+        else {
+            for (const key in obj) {
+                let setKey = '';
+                if (nesting.length) {
+                    let first = nesting[0];
+                    setKey = (nesting.length > 1)
+                        ? first + '[' + nesting.slice(1).join('][') + '][' + key + ']'
+                        : first + '[' + key + ']';
+                }
+                else {
+                    setKey = key;
+                }
+                switch (typeof obj[key]) {
+                    case 'string':
+                        sendHttpParams.set(setKey, obj[key]);
+                        break;
+                    case 'symbol':
+                    case 'number':
+                    case 'bigint':
+                    case 'boolean':
+                        sendHttpParams.set(setKey, String(obj[key]));
+                        break;
+                    case 'object':
+                        nesting.push(key);
+                        sendHttpParams = this.getHttpParamsPost(obj[key], sendHttpParams, false, nesting, settings);
+                        nesting.pop();
+                        break;
+                    case 'function':
+                    case 'undefined':
+                    default:
+                        console.error('Ты отправил что-то не то', obj[key], typeof obj[key], typeof obj);
+                }
+            }
+        }
+        return sendHttpParams;
+    }
+    mapResult(v) {
+        if (v && (v.result || typeof v.result === 'boolean')) {
+            return v.result;
+        }
+        return undefined;
+    }
+    sliceArrayIntoChunks(arr, chunkSize) {
+        const res = [];
+        for (let i = 0; i < arr.length; i += chunkSize) {
+            const chunk = arr.slice(i, i + chunkSize);
+            res.push(chunk);
+        }
+        return res;
+    }
+    removingMultipleSlashes(str) {
+        return str.replace(/\/{2,}/g, '/');
+    }
+}
+
+class BaseHttp extends HttpData {
+    constructor(http, snackBar) {
+        super();
+        this.http = http;
+        this.snackBar = snackBar;
+    }
+    handleError(result, textError = 'получения данных') {
+        return (error) => {
+            console.error(`failed: ${error.message}`);
+            this.snackBar.error('Ошибка: ' + textError);
+            return of(result);
+        };
+    }
+}
+BaseHttp.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BaseHttp, deps: [{ token: i1$3.HttpClient }, { token: SnackBarService }], target: i0.ɵɵFactoryTarget.Injectable });
+BaseHttp.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BaseHttp, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BaseHttp, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1$3.HttpClient }, { type: SnackBarService }]; } });
+
+class BaseHttpServices extends BaseHttp {
+    httpGet(url, params = {}, textError = '', settings = this.defSettings) {
+        return this.http.get(url, {
+            params: this.getHttpParamsGet(params, new HttpParams(), false, [], settings)
+        }).pipe(catchError(err => {
+            if (!textError.length && err.error.error_description) {
+                textError = err.error.error_description;
+            }
+            this.snackBar.error('Ошибка: ' + textError);
+            return throwError(() => err);
+        }));
+    }
+    httpPost(url, params = {}, textError = '', settings = this.defSettings) {
+        return this.http.post(url, this.getHttpParamsPost(params, new FormData(), false, [], settings)).pipe(catchError(err => {
+            if (!textError.length && err.error.error_description) {
+                textError = err.error.error_description;
+            }
+            this.snackBar.error('Ошибка: ' + textError);
+            console.error(err);
+            return throwError(() => err);
+        }));
+    }
+}
+
+class HttpServices extends BaseHttpServices {
+    constructor(http, snackBar, session) {
+        super(http, snackBar);
+        this.session = session;
+    }
+    timeNowOnServer() {
+        return this.httpGet('server.time').pipe(map(v => {
+            if (v && v.result) {
+                return new Date(v.result);
+            }
+            return undefined;
+        }));
+    }
+    /**
+     * Это пиздец а не метод
+     * @param param
+     */
+    branch(param) {
+        let prepareParam = Object.entries(this.prepareBatch(param));
+        const size = 50; // больше не отдаст
+        let subarray = []; //массив в который будет выведен результат.
+        for (let i = 0; i < Math.ceil(prepareParam.length / size); i++) {
+            subarray[i] = prepareParam.slice((i * size), (i * size) + size);
+        }
+        return forkJoin(subarray.map(i => {
+            return this.httpPost('batch.json', {
+                halt: 0,
+                cmd: Object.assign({}, ...i.map(x => {
+                    return { [x[0]]: x[1] };
+                }))
+            });
+        }));
+    }
+    prepareBatch(param) {
+        let res = Object.keys(param).reduce((obj, key) => {
+            obj[key] = '';
+            return obj;
+        }, {});
+        for (let key in param) {
+            if (typeof key === 'string' || typeof key === 'number' && param[key].param) {
+                res[key] = param[key].name + '?' + this.getHttpParamsGet(param[key].param).toString();
+            }
+        }
+        return res;
+    }
+    mapBranchResult(res) {
+        return Object.assign([], ...res.map(i => (i.result && i.result.result) ? i.result.result : undefined));
+    }
+    mapBranchResultWithoutKey(res) {
+        return flatten(Object.assign([], ...res.map(i => (i.result && i.result.result) ? i.result.result : undefined)));
+    }
+    post(name, params = {}, textError = '', settings = this.defSettings) {
+        return this.httpPost(this.getNameMethod(name), params, textError, settings);
+    }
+    get(name, params = {}, textError = '', settings = this.defSettings) {
+        return this.httpGet(this.getNameMethod(name), params, textError, settings);
+    }
+    httpPost(url, params = {}, textError = '', settings = this.defSettings) {
+        return this.session.getAuthParams().pipe(mergeMap(auth => {
+            if (auth) {
+                const paramsClone = clone(params);
+                paramsClone[this.session.getKeyAuth()] = auth;
+                return this.session.getBaseUrl().pipe(mergeMap(v => {
+                    if (v) {
+                        return this.http.post(this.prepareBaseAddress(v) + url, this.getHttpParamsPost(paramsClone, new FormData(), false, [], settings))
+                            .pipe(take(1), catchError(err => {
+                            if (!textError.length && err.error.error_description) {
+                                textError = err.error.error_description;
+                            }
+                            this.snackBar.error('Ошибка: ' + textError);
+                            return throwError(() => err);
+                        }));
+                    }
+                    return throwError(() => 'get base url error');
+                }));
+            }
+            else {
+                this.snackBar.error('Error: Auth not get');
+                return throwError(() => 'auth not get');
+            }
+        }));
+    }
+    httpGet(url, params = {}, textError = '', settings = this.defSettings) {
+        return this.session.getAuthParams().pipe(mergeMap(auth => {
+            if (auth) {
+                if (params === null) {
+                    params = {};
+                }
+                const paramsClone = clone(params);
+                paramsClone[this.session.getKeyAuth()] = auth;
+                let options = {
+                    params: this.getHttpParamsGet(paramsClone)
+                };
+                return this.session.getBaseUrl().pipe(mergeMap(v => {
+                    if (v) {
+                        return this.http.get(this.prepareBaseAddress(v) + url, options).pipe(take(1), catchError(err => {
+                            if (!textError.length && err.error.error_description) {
+                                textError = err.error.error_description;
+                            }
+                            this.snackBar.error('Ошибка: ' + textError);
+                            return throwError(() => err);
+                        }));
+                    }
+                    return throwError(() => 'get base url error');
+                }));
+            }
+            else {
+                this.snackBar.error('Error: Auth not get');
+                return throwError(() => 'auth not get');
+            }
+        }));
+    }
+    getNameMethod(arr) {
+        return arr.join('.');
+    }
+}
+HttpServices.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HttpServices, deps: [{ token: i1$3.HttpClient }, { token: SnackBarService }, { token: SessionKeyServices }], target: i0.ɵɵFactoryTarget.Injectable });
+HttpServices.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HttpServices, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HttpServices, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1$3.HttpClient }, { type: SnackBarService }, { type: SessionKeyServices }]; } });
+
+class HttpBXServices extends HttpServices {
+    timeNowOnServer() {
+        return this.httpGet('server.time').pipe(map(v => {
+            if (v && v.result) {
+                return new Date(v.result);
+            }
+            return undefined;
+        }));
+    }
+    /**
+     * Это пиздец а не метод
+     * @param param
+     */
+    branch(param) {
+        let prepareParam = Object.entries(this.prepareBatch(param));
+        const size = 50; // больше не отдаст
+        let subarray = []; //массив в который будет выведен результат.
+        for (let i = 0; i < Math.ceil(prepareParam.length / size); i++) {
+            subarray[i] = prepareParam.slice((i * size), (i * size) + size);
+        }
+        return forkJoin(subarray.map(i => {
+            return this.httpPost('batch.json', {
+                halt: 0,
+                cmd: Object.assign({}, ...i.map(x => {
+                    return { [x[0]]: x[1] };
+                }))
+            });
+        }));
+    }
+    prepareBatch(param) {
+        let res = Object.keys(param).reduce((obj, key) => {
+            obj[key] = '';
+            return obj;
+        }, {});
+        for (let key in param) {
+            if (typeof key === 'string' || typeof key === 'number' && param[key].param) {
+                res[key] = param[key].name + '?' + this.getHttpParamsGet(param[key].param).toString();
+            }
+        }
+        return res;
+    }
+    mapBranchResult(res) {
+        return Object.assign([], ...res.map(i => (i.result && i.result.result) ? i.result.result : undefined));
+    }
+    mapBranchResultWithoutKey(res) {
+        return flatten(Object.assign([], ...res.map(i => (i.result && i.result.result) ? i.result.result : undefined)));
+    }
+    post(name, params = {}, textError = '', settings = this.defSettings) {
+        return this.httpPost(this.getNameMethod(name), params, textError, settings);
+    }
+    get(name, params = {}, textError = '', settings = this.defSettings) {
+        return this.httpGet(this.getNameMethod(name), params, textError, settings);
+    }
+    httpPost(url, params = {}, textError = '', settings = this.defSettings) {
+        return this.session.getAuthParams().pipe(mergeMap(auth => {
+            if (auth) {
+                const paramsClone = clone(params);
+                paramsClone[this.session.getKeyAuth()] = auth;
+                return this.session.getBaseUrl().pipe(mergeMap(v => {
+                    if (v) {
+                        return this.http.post(this.prepareBaseAddress(v) + url, this.getHttpParamsPost(paramsClone, new FormData(), false, [], settings))
+                            .pipe(take(1), catchError(err => {
+                            if (!textError.length && err.error.error_description) {
+                                textError = err.error.error_description;
+                            }
+                            this.snackBar.error('Ошибка: ' + textError);
+                            return throwError(() => err);
+                        }));
+                    }
+                    return throwError(() => 'get base url error');
+                }));
+            }
+            else {
+                this.snackBar.error('Error: Auth not get');
+                return throwError(() => 'auth not get');
+            }
+        }));
+    }
+    httpGet(url, params = {}, textError = '', settings = this.defSettings) {
+        return this.session.getAuthParams().pipe(mergeMap(auth => {
+            if (auth) {
+                if (params === null) {
+                    params = {};
+                }
+                const paramsClone = clone(params);
+                paramsClone[this.session.getKeyAuth()] = auth;
+                let options = {
+                    params: this.getHttpParamsGet(paramsClone)
+                };
+                return this.session.getBaseUrl().pipe(mergeMap(v => {
+                    if (v) {
+                        return this.http.get(this.prepareBaseAddress(v) + url, options).pipe(take(1), catchError(err => {
+                            if (!textError.length && err.error.error_description) {
+                                textError = err.error.error_description;
+                            }
+                            this.snackBar.error('Ошибка: ' + textError);
+                            return throwError(() => err);
+                        }));
+                    }
+                    return throwError(() => 'get base url error');
+                }));
+            }
+            else {
+                this.snackBar.error('Error: Auth not get');
+                return throwError(() => 'auth not get');
+            }
+        }));
+    }
+    getNameMethod(arr) {
+        return arr.join('.');
+    }
+}
+HttpBXServices.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HttpBXServices, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+HttpBXServices.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HttpBXServices, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HttpBXServices, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
 const save = createAction('[Users Component] Save', props());
 const saveArr = createAction('[Users Component] Save Arr', props());
 const update = createAction('[Users Component] Update', props());
@@ -282,6 +1269,102 @@ const $meeting = 'meeting';
 const $list = 'list';
 const $search = 'search';
 
+class BaseMapServices extends BaseServices {
+}
+BaseMapServices.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BaseMapServices, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+BaseMapServices.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BaseMapServices, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BaseMapServices, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class BitrixApiUserMapServices extends BaseMapServices {
+    HttpToBX(user) {
+        let res = Object.assign(clone(user), {
+            ID: this.toNumber(user.ID),
+            IS_ONLINE: this.toBool(user.IS_ONLINE),
+            DATE_REGISTER: this.toDate(user.DATE_REGISTER),
+            PERSONAL_BIRTHDAY: this.toDate(user.PERSONAL_BIRTHDAY),
+        });
+        if (user.LAST_LOGIN) {
+            res.LAST_LOGIN = this.toDate(user.LAST_LOGIN);
+        }
+        return res;
+    }
+    BXtoHttp(user) {
+        return Object.assign(clone(user), {
+            ID: this.toStr(user.ID),
+            IS_ONLINE: this.toBXYorN(user.IS_ONLINE),
+            DATE_REGISTER: this.getBXStrTime(user.DATE_REGISTER),
+            PERSONAL_BIRTHDAY: this.toStr(user.PERSONAL_BIRTHDAY),
+            LAST_LOGIN: this.toStr(user.LAST_LOGIN)
+        });
+    }
+    getFIO(user) {
+        let res = '';
+        if (!user.LAST_NAME) {
+            const SECOND_NAME = (user.SECOND_NAME) ? user.SECOND_NAME : '';
+            const NAME = (user.NAME) ? user.NAME : '';
+            res = NAME + ' ' + SECOND_NAME;
+        }
+        else if (!user.NAME) {
+            res = user.LAST_NAME;
+        }
+        else if (!user.SECOND_NAME) {
+            res = user.LAST_NAME + ' ' + user.NAME;
+        }
+        else {
+            res = user.LAST_NAME + ' ' + user.NAME + ' ' + user.SECOND_NAME;
+        }
+        return res.trim();
+    }
+    getFI(user) {
+        let res = '';
+        if (!user.LAST_NAME) {
+            const NAME = (user.NAME) ? user.NAME : '';
+            res = NAME;
+        }
+        else if (!user.NAME) {
+            res = user.LAST_NAME;
+        }
+        else {
+            res = user.LAST_NAME + ' ' + user.NAME;
+        }
+        return res.trim();
+    }
+    getFIOShort(user) {
+        let res = '';
+        if (!user.LAST_NAME) {
+            const SECOND_NAME = (user.SECOND_NAME) ? user.SECOND_NAME : '';
+            const NAME = (user.NAME) ? user.NAME : '';
+            res = NAME + ' ' + SECOND_NAME;
+        }
+        else if (!user.NAME) {
+            res = user.LAST_NAME;
+        }
+        else if (!user.SECOND_NAME) {
+            res = user.LAST_NAME + ' ' + user.NAME.charAt(0).toUpperCase() + '.';
+        }
+        else {
+            res =
+                user.LAST_NAME + ' ' +
+                    user.NAME.charAt(0).toUpperCase() + '.' +
+                    user.SECOND_NAME.charAt(0).toUpperCase() + '.';
+        }
+        return res.trim();
+    }
+}
+BitrixApiUserMapServices.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BitrixApiUserMapServices, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+BitrixApiUserMapServices.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BitrixApiUserMapServices, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BitrixApiUserMapServices, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
 class BXRestUser {
     constructor(http, snackBar, 
     // private img: ImgServices,
@@ -333,7 +1416,7 @@ class BXRestUser {
     }
     getByIDs(ids, reload = true) {
         ids = Array.from(new Set(ids));
-        return this.user$.pipe(take(1), mergeMap(v => {
+        return this.user$.pipe(take(1), mergeMap$1(v => {
             if (!reload) {
                 let find = v.data.filter(i => ids.includes(i.ID));
                 if (find && find.length === ids.length) {
@@ -348,7 +1431,7 @@ class BXRestUser {
             return this.getSelfHttp();
         }
         else {
-            return this.user$.pipe(mergeMap(v => {
+            return this.user$.pipe(mergeMap$1(v => {
                 if (v && v.self) {
                     return of(v.self);
                 }
@@ -376,7 +1459,7 @@ class BXRestUser {
     }
     getByDepartment(id) {
         const ids = (typeof id === 'number') ? [id] : id;
-        return this.user$.pipe(first(), mergeMap(v => {
+        return this.user$.pipe(first(), mergeMap$1(v => {
             if (v.load.all) {
                 return of(clone(v.data.filter(i => ids.find(id => i.UF_DEPARTMENT.includes(id)))));
             }
@@ -393,7 +1476,7 @@ class BXRestUser {
             params = clone(this.def.params);
         }
         const saveAllUser = compare(params, this.def.params);
-        return this.user$.pipe(take(1), mergeMap(v => {
+        return this.user$.pipe(take(1), mergeMap$1(v => {
             if (v.load.all) {
                 if (compare(this.def.params, params)) {
                     return of(clone(v.data));
@@ -414,7 +1497,7 @@ class BXRestUser {
         }));
     }
     getAllByPersonalBirthday(day = undefined, month = undefined, checkWeekend = false) {
-        return this.http.timeNowOnServer().pipe(mergeMap(date => {
+        return this.http.timeNowOnServer().pipe(mergeMap$1(date => {
             if (date) {
                 let daySent = (day) ? day : date.getDate();
                 let start = date.getFullYear() + 1;
@@ -496,7 +1579,7 @@ class BXRestUser {
         }
     }
     getEndArray(params = {}) {
-        return this.get(params).pipe(mergeMap(items => {
+        return this.get(params).pipe(mergeMap$1(items => {
             if (items && items.result && typeof items.result === 'object') {
                 if (items.next) {
                     params.start = items.next;
@@ -537,15 +1620,24 @@ class BXRestUser {
     itIsAdmin() {
         return this.http.get(this.url.admin).pipe(map(v => this.http.mapResult(v)));
     }
-}
+}
+BXRestUser.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestUser, deps: [{ token: HttpBXServices }, { token: SnackBarService }, { token: i1$2.Store }, { token: BitrixApiUserMapServices }, { token: i3.DatePipe }], target: i0.ɵɵFactoryTarget.Injectable });
+BXRestUser.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestUser, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestUser, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: HttpBXServices }, { type: SnackBarService }, { type: i1$2.Store }, { type: BitrixApiUserMapServices }, { type: i3.DatePipe }]; } });
 
 /*
  * Public API Surface of bx-rest
- */
+ */
+// export * from './request/bx-rest.module'
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { BXRestUser, BaseServices, BxRestModule };
+export { BXRestUser, BaseServices };
 //# sourceMappingURL=bx-rest.mjs.map