bx-rest 0.0.20 → 0.0.22

package/fesm2015/bx-rest.mjs

@@ -1,9 +1,507 @@
 import * as i0 from '@angular/core';
-import { Injectable } from '@angular/core';
-import { Observable } from 'rxjs';
+import { Injectable, NgModule, inject, Component, ViewEncapsulation, Inject } from '@angular/core';
+import { map, catchError, tap, mergeMap as mergeMap$1, first } from 'rxjs/operators';
+import { Subscription, filter, take, of, throwError, forkJoin, mergeMap } from 'rxjs';
+import clone from 'just-clone';
+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';
 import { __awaiter } from 'tslib';
 import { DateTime } from 'luxon';
-import { map } from 'rxjs/operators';
+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';
+
+const $get = 'get';
+const $add = 'add';
+const $set = 'set';
+const $event = 'event';
+const $update = 'update';
+const $user = 'user';
+const $task = 'task';
+const $calendar = 'calendar';
+const $meeting = 'meeting';
+const $list = 'list';
+const $search = 'search';
+const $accessibility = 'accessibility';
+const $delete = 'delete';
+const $nearest = 'nearest';
+const $params = 'params';
+const $status = 'status';
+const $resource = 'resource';
+const $booking = 'booking';
+const $section = 'section';
+const $settings = 'settings';
+const $tasks = 'tasks';
+const $elapseditem = 'elapseditem';
+const $getlist = 'getlist';
+const $approve = 'approve';
+const $complete = 'complete';
+const $counters = 'counters';
+const $deger = 'deger';
+const $delegate = 'delegate';
+const $disapprove = 'disapprove';
+const $favorite = 'favorite';
+const $files = 'files';
+const $file = 'file';
+const $attach = 'attach';
+const $field = 'field';
+const $getFields = 'get' + $field + 's';
+const $getaccess = 'getaccess';
+const $history = 'history';
+const $pause = 'pause';
+const $renew = 'renew';
+const $start = 'start';
+const $result = 'result';
+const $planner = 'planner';
+const $disk = 'disk';
+const $rename = 'rename';
+const $markdeleted = 'markdeleted';
+const $restore = 'restore';
+const $folder = 'folder';
+const $getchildren = 'getchildren';
+const $copyto = 'copyto';
+const $moveto = 'moveto';
+const $uploadfile = 'uploadfile';
+const $storage = 'storage';
+const $getTypes = 'getTypes';
+const $stages = 'stages';
+const $getmanifest = 'getmanifest';
+const $isactionallowed = 'isactionallowed';
+const $commentitem = 'commentitem';
+const $department = 'department';
+const $sonet_group = 'sonet_group';
+const $create = 'create';
+const $feature = 'feature';
+const $access = 'access';
+const $request = 'request';
+const $socialnetwork = 'socialnetwork';
+const $api = 'api';
+const $workgroup = 'workgroup';
+const $log = 'log';
+const $blogpost = 'blogpost';
+const $lists = 'lists';
+const $iblock = 'iblock';
+const $type = 'type';
+const $id = 'id';
+const $element = 'element';
+const $url = 'url';
+
+class BXRestListsElement {
+    constructor(http, mapResult) {
+        this.http = http;
+        this.mapResult = mapResult;
+        this.url = {
+            add: [$lists, $element, $add],
+            delete: [$lists, $element, $delete],
+            get: [$lists, $element, $get],
+            update: [$lists, $element, $update],
+            getFileUrl: [$lists, $element, $get, $file, $url] // Метод возвращает путь к файлу
+        };
+    }
+    get(pram) {
+        return this.http.post(this.url.get, pram)
+            .pipe(map(v => (v && v.result)
+            ? Object.assign(v, { result: v.result.map(i => this.mapResult.get(i)) })
+            : undefined));
+    }
+}
+
+class BXRestLists {
+    constructor(element) {
+        this.element = element;
+        this.url = {
+            add: [$lists, $add],
+            delete: [$lists, $delete],
+            get: [$lists, $get],
+            update: [$lists, $update],
+            getIblockTypeId: [$lists, $get, $iblock, $type, $id], // Метод возвращает id типа инфоблока
+        };
+    }
+}
+BXRestLists.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestLists, deps: [{ token: BXRestListsElement }], target: i0.ɵɵFactoryTarget.Injectable });
+BXRestLists.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestLists, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestLists, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: BXRestListsElement }]; } });
+
+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);
+}
 
 const time = {
     oneDayMilliseconds: 1000 * 60 * 60 * 24
@@ -180,6 +678,704 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                 }]
         }] });
 
+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());
+const loadAll = createAction('[Users Component] loadAll', props());
+const saveSelf = createAction('[Users Component] saveSelf', props());
+const saveIDLoadedDepartment = createAction('[Users Component] saveIDLoadedDepartment', props());
+const initialState = {
+    load: {
+        all: false,
+        department: []
+    },
+    self: undefined,
+    data: []
+};
+const _usersReducer = createReducer(initialState, on(saveIDLoadedDepartment, (s, data) => {
+    let copy = clone(s);
+    copy.load.department = [...copy.load.department, ...data.id];
+    return copy;
+}), on(save, (s, data) => {
+    const find = s.data.find(v => v.ID === data.ID);
+    if (!find) {
+        const copy = clone(s);
+        copy.data.push(data);
+        return copy;
+    }
+    return s;
+}), on(saveArr, (s, data) => {
+    const copy = clone(s);
+    if (copy.data && copy.data.length) {
+        for (const user of data.arr) {
+            const find = copy.data.find(v => v.ID === user.ID);
+            if (!find) {
+                copy.data.push(user);
+            }
+        }
+    }
+    else {
+        copy.data = [...data.arr];
+    }
+    return copy;
+}), on(update, (s, data) => {
+    const copy = clone(s);
+    let find = copy.data.findIndex(v => v.ID === data.ID);
+    if (find !== -1) {
+        const copy = clone(s);
+        copy.data.splice(find, 1, data);
+        // copy.data.push(data)
+        return copy;
+    }
+    return s;
+}), on(loadAll, (s, data) => {
+    if (data.load !== s.load.all) {
+        const copy = clone(s);
+        copy.load.all = data.load;
+        return copy;
+    }
+    return s;
+}), on(saveSelf, (s, data) => {
+    return Object.assign(Object.assign({}, s), { self: data.self });
+}));
+function usersReducer(state = initialState, action) {
+    return _usersReducer(state, action);
+}
+
 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 });
@@ -191,66 +1387,301 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                 }]
         }] });
 
-class BXRestListsElementMap extends BaseMapServices {
-    get(item) {
-        return Object.assign(item, {
-            BP_PUBLISHED: item.BP_PUBLISHED === 'Y',
-            CREATED_BY: this.toNum(item.CREATED_BY),
-            IBLOCK_ID: this.toNum(item.IBLOCK_ID),
-            ID: this.toNum(item.ID)
+class BitrixApiUserMapServices extends BaseMapServices {
+    HttpToBX(user) {
+        let res = Object.assign(clone(user), {
+            ID: this.toNum(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();
+    }
 }
-BXRestListsElementMap.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestListsElementMap, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-BXRestListsElementMap.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestListsElementMap, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestListsElementMap, decorators: [{
+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'
                 }]
         }] });
 
-function mapResult(v) {
-    if (v && (v.result || typeof v.result === 'boolean')) {
-        return v.result;
+class BXRestUser {
+    constructor(http, snackBar, 
+    // private img: ImgServices,
+    //private dateTrace: DateTrace,
+    store, userMap) {
+        this.http = http;
+        this.snackBar = snackBar;
+        this.store = store;
+        this.userMap = userMap;
+        this.url = {
+            admin: [$user, 'admin'],
+            get: [$user, $get],
+            current: [$user, 'current'],
+            update: [$user, $update],
+            search: [$user, $search],
+            access: [$user, 'access'],
+            // AU - все авторизованные пользователи
+            // D1 - подразделение с id=1
+            // G1 - группа с id=1
+            fields: [$user, 'fields'],
+            userfield: {
+                list: [$user, 'userfield', $list]
+            }
+        };
+        this.def = {
+            params: { ACTIVE: 1, start: 0 }
+        };
+        this.user$ = this.store.select('users');
     }
-    return undefined;
-}
+    admin() {
+        return this.http.get(this.url.admin);
+    }
+    get(params = {}) {
+        let copyParams = clone(params);
+        this.setDefParam(copyParams);
+        return this.http.post(this.url.get, copyParams, 'Не удалось получить пользователей')
+            .pipe(tap(v => {
+            if (v && v.result) {
+                this.saveArrUser(v.result);
+            }
+        }));
+    }
+    current(update = false) {
+        if (update) {
+            return this.getSelfHttp();
+        }
+        else {
+            return this.user$.pipe(mergeMap$1(v => {
+                if (v && v.self) {
+                    return of(v.self);
+                }
+                else {
+                    return this.getSelfHttp();
+                }
+            }), first());
+        }
+    }
+    getSelfHttp() {
+        return this.http.get(this.url.current, {}, 'Не удалось получить пользователя')
+            .pipe(map(v => {
+            if (v && v.result) {
+                return this.userMap.HttpToBX(v.result);
+            }
+            return undefined;
+        }), tap(v => {
+            if (v) {
+                this.store.dispatch(saveSelf({ self: v }));
+            }
+        }));
+    }
+    access(access, textError = 'Не удалось получить права') {
+        return this.http.get(this.url.access, { ACCESS: access }, textError);
+    }
+    // getAll(params: iBXGetParam = {}): Observable<iBXRestUser [] | undefined> {
+    //   if (!Object.keys(params).length) {
+    //     params = clone(this.def.params)
+    //   }
+    //
+    //   const saveAllUser = compare(params, this.def.params)
+    //   return this.user$.pipe(
+    //     take(1),
+    //     mergeMap(v => {
+    //       if (v.load.all) {
+    //         if (compare(this.def.params, params)) {
+    //           return of(clone(v.data))
+    //         }
+    //       }
+    //
+    //       return this.getEndArray(params).pipe(
+    //         take(1),
+    //         map(v => {
+    //           if (v && v.result) {
+    //             let cl = clone(v.result)
+    //             return this.saveArrUser(cl)
+    //           }
+    //           return undefined
+    //         }),
+    //       )
+    //     }),
+    //     tap(v => {
+    //       if (v && v.length && saveAllUser) {
+    //         this.store.dispatch(loadAll({load: true}))
+    //       }
+    //       params.start = this.def.params.start
+    //     })
+    //   )
+    // }
+    saveArrUser(users) {
+        let result = [];
+        for (const user of users) {
+            result.push(this.userMap.HttpToBX(user));
+        }
+        this.store.dispatch(saveArr({ arr: result }));
+        return result;
+    }
+    search(params) {
+        if (typeof params === 'string') {
+            params = { FIND: params };
+        }
+        if (typeof params.ACTIVE !== 'boolean') {
+            params.ACTIVE = true;
+        }
+        return this.http.get(this.url.search, params, 'Сервер не отвечает на запрос поиска');
+    }
+    fields() {
+        return this.http.get(this.url.fields);
+    }
+    update(user, fieldUpdate) {
+        if (fieldUpdate && fieldUpdate.length) {
+            let sendData = {
+                ID: user.ID,
+            };
+            const userBX = this.userMap.BXtoHttp(user);
+            for (const field of fieldUpdate) {
+                if (userBX[field]) {
+                    sendData[field] = userBX[field];
+                }
+                else {
+                    this.snackBar.error('Одно из указанных полей отправлено не верно');
+                }
+            }
+            return this.http.post(this.url.update, sendData, 'Не удалось обновить пользователя с ID' + user.ID);
+        }
+        else {
+            this.snackBar.error('Не указано ни одно поле для редактирования пользователя');
+            return of({});
+        }
+    }
+    // getEndArray(params: UserFilter = {}): Observable<iHttpAnswerBX<iBXRestUserHttp[]> | undefined> {
+    //   return this.get(params).pipe(
+    //     mergeMap(items => {
+    //       if (items && items.result && typeof items.result === 'object') {
+    //         if (items.next) {
+    //           params.start = items.next
+    //           return this.getEndArray(params).pipe(map(vEnd => {
+    //             if (vEnd && items.result && vEnd.result) {
+    //               return {result: [...items.result, ...vEnd.result]}
+    //             }
+    //             return (items) ? items : undefined
+    //           }))
+    //         }
+    //         return of(items)
+    //       } else {
+    //         return of(undefined)
+    //       }
+    //     }),
+    //   )
+    // }
+    setDefParam(params) {
+        if (!params.hasOwnProperty('ACTIVE')) {
+            params.ACTIVE = this.def.params.ACTIVE;
+        }
+        if (params.ACTIVE && params.ACTIVE === 2) {
+            delete params.ACTIVE;
+        }
+        if (!params.hasOwnProperty('start')) {
+            params.start = this.def.params.start;
+        }
+        if (params.UF_DEPARTMENT && !params.UF_DEPARTMENT.length) {
+            delete params.UF_DEPARTMENT;
+        }
+    }
+}
+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 }], 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 }]; } });
 
-class BXRestBase {
+// import { Observable } from 'rxjs'
+// import BXRestListsElementMap from './map/lists/element'
+// import { map } from 'rxjs/operators'
+// import { mapResult } from './functions/mapResult'
+class BXRest {
     constructor(user, lists) {
         this.user = user;
         this.lists = lists;
     }
 }
-class BXRest extends new Proxy(BXRestBase, {
-    get(target, prop, receiver) {
-        const res = Reflect.get(target, prop, receiver);
-        console.log('res', res);
-        if (res in Observable) {
-            let mapRes = new BXRestListsElementMap();
-            console.log('res', res);
-            return Reflect.get(target, prop, receiver).pipe(
-            // @ts-ignore
-            map(v => (v && v.result)
-                // @ts-ignore
-                ? Object.assign(v, { result: v.result.map(i => mapRes.get(i)) })
-                : undefined), 
-            // @ts-ignore
-            map(v => mapResult(v)));
-        }
-        return res;
-    }
-}) {
-}
-BXRest.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRest, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+BXRest.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRest, deps: [{ token: BXRestUser }, { token: BXRestLists }], target: i0.ɵɵFactoryTarget.Injectable });
 BXRest.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRest, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRest, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }] });
+        }], ctorParameters: function () { return [{ type: BXRestUser }, { type: BXRestLists }]; } });
 
 /*
  * Public API Surface of bx-rest