bx-rest 0.1.11 → 0.1.15

package/esm2022/request-navvy/lists/element.mjs

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import BXRestListsElementMap from '../../map/lists/element';
+import { Navvy } from '../../services/navvy';
+import * as i0 from "@angular/core";
+import * as i1 from "../../request/lists/element";
+export class BXRestNavvyListsElement {
+    constructor(BXRestListsElement, BXRestMap) {
+        this.BXRestListsElement = BXRestListsElement;
+        this.BXRestMap = BXRestMap;
+        this.Navvy = new Navvy(this.BXRestListsElement, this.BXRestMap);
+    }
+    get(param) {
+        return this.Navvy.PagNav(this.BXRestListsElement.get, param, 'Не удалось получить элемент списка', this.BXRestMap.get);
+    }
+    add(param) {
+        return this.Navvy.simpleWithArg(this.BXRestListsElement.add, param, 'Не удалось добавить элемент списка');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyListsElement, deps: [{ token: i1.BXRestListsElement }, { token: BXRestListsElementMap }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyListsElement, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyListsElement, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BXRestListsElement }, { type: BXRestListsElementMap }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/request-navvy/lists/field.mjs

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import BXRestListsField from '../../request/lists/field';
+import { Navvy } from '../../services/navvy';
+import * as i0 from "@angular/core";
+import * as i1 from "../../map/lists/field";
+export default class BXRestNavvyListsField {
+    constructor(BXRestListsField, BXRestMapListsField) {
+        this.BXRestListsField = BXRestListsField;
+        this.BXRestMapListsField = BXRestMapListsField;
+        this.Navvy = new Navvy(this.BXRestListsField, this.BXRestMapListsField);
+    }
+    get(param) {
+        return this.Navvy.PagNavWithUselessKey(this.BXRestListsField.get, param, 'Не удалось получить поля списка', this.BXRestMapListsField.get);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyListsField, deps: [{ token: BXRestListsField }, { token: i1.BXRestMapListsField }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyListsField, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyListsField, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: BXRestListsField }, { type: i1.BXRestMapListsField }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/request-navvy/lists.mjs

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import { Navvy } from '../services/navvy';
+import BXRestNavvyListsField from './lists/field';
+import * as i0 from "@angular/core";
+import * as i1 from "./lists/element";
+import * as i2 from "../map/lists";
+import * as i3 from "../request/lists";
+export class BXRestNavvyLists {
+    constructor(element, field, mapList, BXRestLists) {
+        this.element = element;
+        this.field = field;
+        this.mapList = mapList;
+        this.BXRestLists = BXRestLists;
+        this.Navvy = new Navvy(this.BXRestLists, this.mapList);
+    }
+    get(param) {
+        return this.Navvy.PagNav(this.BXRestLists.get, param, 'Не удалось получить список', this.mapList.get);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyLists, deps: [{ token: i1.BXRestNavvyListsElement }, { token: BXRestNavvyListsField }, { token: i2.BXRestMapLists }, { token: i3.BXRestLists }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyLists, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyLists, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BXRestNavvyListsElement }, { type: BXRestNavvyListsField }, { type: i2.BXRestMapLists }, { type: i3.BXRestLists }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/request-navvy/log/blogcomment.mjs

@@ -7,13 +7,13 @@ export class BXRestNavvyLogBlogComment {
             add: [$log, $blogcomment, $add], //	Добавляет комментарий к сообщению Живой ленты
         };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyLogBlogComment, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyLogBlogComment, providedIn: 'root' }); }
 }
-BXRestNavvyLogBlogComment.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyLogBlogComment, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-BXRestNavvyLogBlogComment.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyLogBlogComment, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyLogBlogComment, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyLogBlogComment, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvZ2NvbW1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ieC1yZXN0L3NyYy9yZXF1ZXN0LW5hdnZ5L2xvZy9ibG9nY29tbWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFBO0FBQzFDLE9BQU8sRUFBRSxJQUFJLEVBQUUsWUFBWSxFQUFFLElBQUksRUFBRSxNQUFNLCtCQUErQixDQUFBOztBQUt4RSxNQUFNLE9BQU8seUJBQXlCO0lBSHRDO1FBSUUsUUFBRyxHQUFHO1lBQ0osR0FBRyxFQUFFLENBQUMsSUFBSSxFQUFFLFlBQVksRUFBRSxJQUFJLENBQUMsRUFBRSxnREFBZ0Q7U0FDbEYsQ0FBQTtLQUNGOztzSEFKWSx5QkFBeUI7MEhBQXpCLHlCQUF5QixjQUZ4QixNQUFNOzJGQUVQLHlCQUF5QjtrQkFIckMsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSdcclxuaW1wb3J0IHsgJGFkZCwgJGJsb2djb21tZW50LCAkbG9nIH0gZnJvbSAnLi4vLi4vY29uc3RzL3BhcnQtbmFtZS1tZXRvZHMnXHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBCWFJlc3ROYXZ2eUxvZ0Jsb2dDb21tZW50IHtcclxuICB1cmwgPSB7XHJcbiAgICBhZGQ6IFskbG9nLCAkYmxvZ2NvbW1lbnQsICRhZGRdLCAvL1x00JTQvtCx0LDQstC70Y/QtdGCINC60L7QvNC80LXQvdGC0LDRgNC40Lkg0Log0YHQvtC+0LHRidC10L3QuNGOINCW0LjQstC+0Lkg0LvQtdC90YLRi1xyXG4gIH1cclxufVxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvZ2NvbW1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ieC1yZXN0L3NyYy9yZXF1ZXN0LW5hdnZ5L2xvZy9ibG9nY29tbWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFBO0FBQzFDLE9BQU8sRUFBRSxJQUFJLEVBQUUsWUFBWSxFQUFFLElBQUksRUFBRSxNQUFNLCtCQUErQixDQUFBOztBQUt4RSxNQUFNLE9BQU8seUJBQXlCO0lBSHRDO1FBSUUsUUFBRyxHQUFHO1lBQ0osR0FBRyxFQUFFLENBQUMsSUFBSSxFQUFFLFlBQVksRUFBRSxJQUFJLENBQUMsRUFBRSxnREFBZ0Q7U0FDbEYsQ0FBQTtLQUNGOzhHQUpZLHlCQUF5QjtrSEFBekIseUJBQXlCLGNBRnhCLE1BQU07OzJGQUVQLHlCQUF5QjtrQkFIckMsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSdcclxuaW1wb3J0IHsgJGFkZCwgJGJsb2djb21tZW50LCAkbG9nIH0gZnJvbSAnLi4vLi4vY29uc3RzL3BhcnQtbmFtZS1tZXRvZHMnXHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBCWFJlc3ROYXZ2eUxvZ0Jsb2dDb21tZW50IHtcclxuICB1cmwgPSB7XHJcbiAgICBhZGQ6IFskbG9nLCAkYmxvZ2NvbW1lbnQsICRhZGRdLCAvL1x00JTQvtCx0LDQstC70Y/QtdGCINC60L7QvNC80LXQvdGC0LDRgNC40Lkg0Log0YHQvtC+0LHRidC10L3QuNGOINCW0LjQstC+0Lkg0LvQtdC90YLRi1xyXG4gIH1cclxufVxyXG4iXX0=

package/esm2022/request-navvy/log/blogpost.mjs

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import { $add, $blogpost, $delete, $get, $log, $share, $update } from '../../consts/part-name-metods';
+import { Navvy } from '../../services/navvy';
+import * as i0 from "@angular/core";
+import * as i1 from "../../request/log/blogpost";
+export class BXRestNavvyLogBlogPost {
+    constructor(BXRestLogBlogPost) {
+        this.BXRestLogBlogPost = BXRestLogBlogPost;
+        this.url = {
+            add: [$log, $blogpost, $add],
+            // getusers: {
+            //   important: 'log.blogpost.getusers.important' // Отдает массив ID пользователей, прочитавших Важное сообщение
+            // },
+            get: [$log, $blogpost, $get],
+            delete: [$log, $blogpost, $delete],
+            share: [$log, $blogpost, $share],
+            update: [$log, $blogpost, $update], // Изменяет сообщение Живой Ленты
+        };
+        this.Navvy = new Navvy(this.BXRestLogBlogPost, undefined);
+    }
+    add(param) {
+        return this.Navvy.simpleWithArg(this.BXRestLogBlogPost.add, param);
+    }
+    get(param = {}) {
+        return this.Navvy.simpleWithArg(this.BXRestLogBlogPost.get, param);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyLogBlogPost, deps: [{ token: i1.BXRestLogBlogPost }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyLogBlogPost, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyLogBlogPost, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BXRestLogBlogPost }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/request-navvy/log.mjs

@@ -7,13 +7,13 @@ export class BXRestNavvyLog {
         this.blogPost = blogPost;
         this.blogComment = blogComment;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyLog, deps: [{ token: i1.BXRestNavvyLogBlogPost }, { token: i2.BXRestNavvyLogBlogComment }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyLog, providedIn: 'root' }); }
 }
-BXRestNavvyLog.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyLog, deps: [{ token: i1.BXRestNavvyLogBlogPost }, { token: i2.BXRestNavvyLogBlogComment }], target: i0.ɵɵFactoryTarget.Injectable });
-BXRestNavvyLog.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyLog, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyLog, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyLog, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }], ctorParameters: function () { return [{ type: i1.BXRestNavvyLogBlogPost }, { type: i2.BXRestNavvyLogBlogComment }]; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvYngtcmVzdC9zcmMvcmVxdWVzdC1uYXZ2eS9sb2cudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQTs7OztBQU8xQyxNQUFNLE9BQU8sY0FBYztJQUV6QixZQUNTLFFBQWdDLEVBQ2hDLFdBQXNDO1FBRHRDLGFBQVEsR0FBUixRQUFRLENBQXdCO1FBQ2hDLGdCQUFXLEdBQVgsV0FBVyxDQUEyQjtJQUUvQyxDQUFDOzsyR0FOVSxjQUFjOytHQUFkLGNBQWMsY0FGYixNQUFNOzJGQUVQLGNBQWM7a0JBSDFCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXHJcbmltcG9ydCB7IEJYUmVzdE5hdnZ5TG9nQmxvZ1Bvc3QgfSBmcm9tICcuL2xvZy9ibG9ncG9zdCdcclxuaW1wb3J0IHsgQlhSZXN0TmF2dnlMb2dCbG9nQ29tbWVudCB9IGZyb20gJy4vbG9nL2Jsb2djb21tZW50J1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgQlhSZXN0TmF2dnlMb2cge1xyXG5cclxuICBjb25zdHJ1Y3RvcihcclxuICAgIHB1YmxpYyBibG9nUG9zdDogQlhSZXN0TmF2dnlMb2dCbG9nUG9zdCxcclxuICAgIHB1YmxpYyBibG9nQ29tbWVudDogQlhSZXN0TmF2dnlMb2dCbG9nQ29tbWVudFxyXG4gICkge1xyXG4gIH1cclxuXHJcbn1cclxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvYngtcmVzdC9zcmMvcmVxdWVzdC1uYXZ2eS9sb2cudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQTs7OztBQU8xQyxNQUFNLE9BQU8sY0FBYztJQUV6QixZQUNTLFFBQWdDLEVBQ2hDLFdBQXNDO1FBRHRDLGFBQVEsR0FBUixRQUFRLENBQXdCO1FBQ2hDLGdCQUFXLEdBQVgsV0FBVyxDQUEyQjtJQUUvQyxDQUFDOzhHQU5VLGNBQWM7a0hBQWQsY0FBYyxjQUZiLE1BQU07OzJGQUVQLGNBQWM7a0JBSDFCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXHJcbmltcG9ydCB7IEJYUmVzdE5hdnZ5TG9nQmxvZ1Bvc3QgfSBmcm9tICcuL2xvZy9ibG9ncG9zdCdcclxuaW1wb3J0IHsgQlhSZXN0TmF2dnlMb2dCbG9nQ29tbWVudCB9IGZyb20gJy4vbG9nL2Jsb2djb21tZW50J1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgQlhSZXN0TmF2dnlMb2cge1xyXG5cclxuICBjb25zdHJ1Y3RvcihcclxuICAgIHB1YmxpYyBibG9nUG9zdDogQlhSZXN0TmF2dnlMb2dCbG9nUG9zdCxcclxuICAgIHB1YmxpYyBibG9nQ29tbWVudDogQlhSZXN0TmF2dnlMb2dCbG9nQ29tbWVudFxyXG4gICkge1xyXG4gIH1cclxuXHJcbn1cclxuIl19

package/esm2022/request-navvy/sonet_group.mjs

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import { Navvy } from '../services/navvy';
+import * as i0 from "@angular/core";
+import * as i1 from "../request/sonet_group";
+import * as i2 from "../map/sonet_group";
+export class BXRestNavvySonetGroup {
+    constructor(BXRestSonetGroup, mapSonetGroup) {
+        this.BXRestSonetGroup = BXRestSonetGroup;
+        this.mapSonetGroup = mapSonetGroup;
+        this.Navvy = new Navvy(this.BXRestSonetGroup, this.mapSonetGroup);
+    }
+    get(param = {
+        filter: {},
+        order: {}
+    }) {
+        return this.Navvy.simpleWithArg(this.BXRestSonetGroup.get, param, 'Не удалось получить рабочую группу', this.mapSonetGroup.get);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvySonetGroup, deps: [{ token: i1.BXRestSonetGroup }, { token: i2.BXRestMapSonetGroup }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvySonetGroup, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvySonetGroup, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BXRestSonetGroup }, { type: i2.BXRestMapSonetGroup }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29uZXRfZ3JvdXAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9ieC1yZXN0L3NyYy9yZXF1ZXN0LW5hdnZ5L3NvbmV0X2dyb3VwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFHMUMsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLG1CQUFtQixDQUFBOzs7O0FBTXpDLE1BQU0sT0FBTyxxQkFBcUI7SUFJaEMsWUFDVSxnQkFBa0MsRUFDbEMsYUFBa0M7UUFEbEMscUJBQWdCLEdBQWhCLGdCQUFnQixDQUFrQjtRQUNsQyxrQkFBYSxHQUFiLGFBQWEsQ0FBcUI7UUFFMUMsSUFBSSxDQUFDLEtBQUssR0FBRyxJQUFJLEtBQUssQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFBO0lBQ25FLENBQUM7SUFFRCxHQUFHLENBQUMsUUFBbUM7UUFDckMsTUFBTSxFQUFFLEVBQUU7UUFDVixLQUFLLEVBQUUsRUFBRTtLQUNWO1FBQ0MsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLGFBQWEsQ0FDN0IsSUFBSSxDQUFDLGdCQUFnQixDQUFDLEdBQUcsRUFBRSxLQUFLLEVBQ2hDLG9DQUFvQyxFQUNwQyxJQUFJLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FDdkIsQ0FBQTtJQUNILENBQUM7OEdBcEJVLHFCQUFxQjtrSEFBckIscUJBQXFCLGNBRnBCLE1BQU07OzJGQUVQLHFCQUFxQjtrQkFIakMsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSdcclxuaW1wb3J0IHsgaUJYUmVzdFBhcmFtU29uZXRHcm91cEdldCB9IGZyb20gJy4uL3R5cGlmaWNhdGlvbi9yZXN0L3NvbmV0X2dyb3VwL2dldCdcclxuaW1wb3J0IHsgQlhSZXN0TWFwU29uZXRHcm91cCB9IGZyb20gJy4uL21hcC9zb25ldF9ncm91cCdcclxuaW1wb3J0IHsgTmF2dnkgfSBmcm9tICcuLi9zZXJ2aWNlcy9uYXZ2eSdcclxuaW1wb3J0IHsgQlhSZXN0U29uZXRHcm91cCB9IGZyb20gJy4uL3JlcXVlc3Qvc29uZXRfZ3JvdXAnXHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBCWFJlc3ROYXZ2eVNvbmV0R3JvdXAge1xyXG5cclxuICBwcml2YXRlIE5hdnZ5OiBOYXZ2eTxCWFJlc3RTb25ldEdyb3VwLCBCWFJlc3RNYXBTb25ldEdyb3VwPlxyXG5cclxuICBjb25zdHJ1Y3RvcihcclxuICAgIHByaXZhdGUgQlhSZXN0U29uZXRHcm91cDogQlhSZXN0U29uZXRHcm91cCxcclxuICAgIHByaXZhdGUgbWFwU29uZXRHcm91cDogQlhSZXN0TWFwU29uZXRHcm91cCxcclxuICApIHtcclxuICAgIHRoaXMuTmF2dnkgPSBuZXcgTmF2dnkodGhpcy5CWFJlc3RTb25ldEdyb3VwLCB0aGlzLm1hcFNvbmV0R3JvdXApXHJcbiAgfVxyXG5cclxuICBnZXQocGFyYW06IGlCWFJlc3RQYXJhbVNvbmV0R3JvdXBHZXQgPSB7XHJcbiAgICBmaWx0ZXI6IHt9LFxyXG4gICAgb3JkZXI6IHt9XHJcbiAgfSkge1xyXG4gICAgcmV0dXJuIHRoaXMuTmF2dnkuc2ltcGxlV2l0aEFyZyhcclxuICAgICAgdGhpcy5CWFJlc3RTb25ldEdyb3VwLmdldCwgcGFyYW0sXHJcbiAgICAgICfQndC1INGD0LTQsNC70L7RgdGMINC/0L7Qu9GD0YfQuNGC0Ywg0YDQsNCx0L7Rh9GD0Y4g0LPRgNGD0L/Qv9GDJyxcclxuICAgICAgdGhpcy5tYXBTb25ldEdyb3VwLmdldFxyXG4gICAgKVxyXG4gIH1cclxufVxyXG5cclxuXHJcbiJdfQ==

package/esm2022/request-navvy/task/elapseditem.mjs

@@ -0,0 +1,300 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { mergeMap, of, tap, throwError } from 'rxjs';
+import { Permission } from '../../services/permission';
+import { Navvy } from '../../services/navvy';
+import * as i0 from "@angular/core";
+import * as i1 from "../../request/task/elapseditem";
+import * as i2 from "../user";
+import * as i3 from "../tasks";
+import * as i4 from "../../map/task/elapseditem";
+export class BXRestNavvyElapseditem {
+    constructor(BXRestElapseditem, BXRestNavvyUser, BXRestNavvyTasks, BXRestMapElapseditem) {
+        this.BXRestElapseditem = BXRestElapseditem;
+        this.BXRestNavvyUser = BXRestNavvyUser;
+        this.BXRestNavvyTasks = BXRestNavvyTasks;
+        this.BXRestMapElapseditem = BXRestMapElapseditem;
+        this.Navvy = new Navvy(this.BXRestElapseditem, this.BXRestMapElapseditem);
+    }
+    /*
+    call(methodName: string, ...args: any[]){
+      if (typeof this[methodName] === 'function') {
+        return this[methodName](...args);
+      }
+      return this[methodName](...args);
+    }
+     */
+    getList(param = undefined) {
+        if (param) {
+            if (!param.TASKID && !param.SELECT) {
+                param.SELECT = ['*'];
+            }
+            if (!param.TASKID && !param.PARAMS) {
+                param.PARAMS = {
+                    NAV_PARAMS: {
+                        nPageSize: 50,
+                        iNumPage: 1
+                    }
+                };
+            }
+        }
+        return this.Navvy.alterPagNav(this.BXRestElapseditem.getList, param);
+    }
+    add(param) {
+        return this.checkPermissionReadTask(param.TASKID).pipe(mergeMap(allowedReadTask => {
+            if (allowedReadTask) {
+                return this.checkPermissionAddTask(param.TASKID).pipe(mergeMap(allowed => {
+                    if (allowed) {
+                        return this.BXRestElapseditem.add(param);
+                    }
+                    else {
+                        return throwError(() => new Error('Отсутствуют права добавление записи затраченного времени'));
+                    }
+                }));
+            }
+            else {
+                return throwError(() => new Error('Отсутствуют права на чтение задачи'));
+            }
+        }));
+    }
+    update(param) {
+        return this.Navvy.simple(() => this.checkPermissionReadTask(param.TASKID).pipe(mergeMap(allowedReadTask => {
+            if (allowedReadTask) {
+                return this.isAllowedModify(param.TASKID, param.ITEMID).pipe(mergeMap(allowed => {
+                    if (allowed) {
+                        return this.BXRestElapseditem.update(param);
+                    }
+                    else {
+                        return throwError(() => new Error('Отсутствуют права на изменение записи затраченного времени'));
+                    }
+                }));
+            }
+            else {
+                return throwError(() => new Error('Отсутствуют права на чтение задачи'));
+            }
+        })), 'Не удалось обновить элемент списка', this.BXRestMapElapseditem.update);
+    }
+    /*
+    getAll(
+      params: RequestParamsElapsedGetList | undefined = undefined,
+      cache = false
+    ): Observable<iHttpAnswerBX<BXRestElapsed[]> | undefined> {
+      return this.get(params, cache)
+        .pipe(
+          mergeMap(items => {
+            if (items && items.result) {
+              if (items.next) {
+                params = (params) ? params : {}
+                params.PARAMS = {
+                  NAV_PARAMS: {
+                    nPageSize: this.pageSize,
+                    iNumPage: items.next / this.pageSize + 1
+                  }
+                }
+                return this.getAll(params, cache).pipe(
+                  map(vEnd => {
+                    if (vEnd && vEnd.result && items.result) {
+                      return merge(clone(vEnd), {result: [...items.result, ...vEnd.result]})
+                    }
+                    return items
+                  })
+                )
+              }
+              return of(items)
+            } else {
+              return of(undefined)
+            }
+          })
+        )
+    }
+     */
+    /*
+    getByInterval(idsUsers: number[], dateStart: Date, dateEnd: Date) {
+      return new Navvy(
+        this.BXRestElapseditem.getList(
+          {
+            ORDER: {
+              ID: 'DESC'
+            },
+            FILTER: {
+              USER_ID: idsUsers,
+              '>=CREATED_DATE': dateStart.toLocaleString('ru-Ru'),
+              '<=CREATED_DATE': dateEnd.toLocaleString('ru-Ru'),
+            }
+          }
+        ))
+      /*
+      return this.BXRestElapseditem.getList({
+          ORDER: {
+            ID: 'DESC'
+          },
+          FILTER: {
+            USER_ID: idsUsers,
+            '>=CREATED_DATE': dateStart.toLocaleString('ru-Ru'),
+            '<=CREATED_DATE': dateEnd.toLocaleString('ru-Ru'),
+          }
+        }
+      )
+     */
+    /*
+      }
+    
+    
+      /*
+      getCacheOff(params: RequestParamsElapsedGetList | undefined = undefined) {
+        return this.http.post<iHttpAnswerBX<BXRestElapsedHttp[]> | undefined>
+        (this.url.getlist, params, 'не удалось получить время по задачам')
+          .pipe(
+            map(v => {
+              if (v && v.result) {
+                const newResult: BXRestElapsed[] = []
+                for (let task of v.result) {
+                  newResult.push(this.elapsedBXMap.AnswerElapsedGetHttpToAnswerElapsedGet(task))
+                }
+                return extend(v, {result: newResult}) as iHttpAnswerBX<BXRestElapsed[]>
+              }
+              return undefined
+            }),
+            tap(v => {
+              if (v && params) {
+                this.store.dispatch(saveHttpTaskTime({
+                  filter: clone(params),
+                  time: v
+                }))
+              }
+            })
+          )
+      }
+      */
+    isAllowedModify(idTask, idItem) {
+        let permission = Permission.get();
+        if (permission?.tasks?.length) {
+            let findTask = permission.tasks.find(i => i.id === idTask);
+            if (findTask) {
+                let find = findTask.elapsedItem.find(i => i.id === idItem);
+                if (find && find.verified.edit) {
+                    return of(find.edit);
+                }
+            }
+        }
+        return this.isActionAllowed({
+            TASKID: idTask,
+            ITEMID: 2,
+            ACTIONID: idItem
+        }).result().pipe(tap(v => {
+            if (v !== undefined) {
+                Permission.setTaskElapsedItem(idTask, {
+                    id: idItem,
+                    edit: v,
+                    del: false,
+                    verified: {
+                        edit: true,
+                        del: false,
+                    }
+                });
+            }
+        }));
+    }
+    isAllowedRemove(idTask, idItem) {
+        return this.isActionAllowed({
+            TASKID: idTask,
+            ITEMID: 3,
+            ACTIONID: idItem
+        }).result();
+    }
+    /**
+     * idAction:
+     * 1 - ACTION_ELAPSED_TIME_ADD
+     * 2 - ACTION_ELAPSED_TIME_MODIFY
+     * 3 - ACTION_ELAPSED_TIME_REMOVE
+     * @param param
+     */
+    isActionAllowed(param) {
+        return this.Navvy.simple(() => this.checkPermissionReadTask(param.TASKID).pipe(mergeMap(canRead => {
+            if (canRead) {
+                return this.BXRestElapseditem.isActionAllowed(param);
+            }
+            return throwError(() => new Error('Отсутствуют права на чтение задачи'));
+        })));
+    }
+    checkPermissionAddTask(idTask) {
+        let permission = Permission.get();
+        if (permission?.tasks?.length) {
+            let findTask = permission.tasks.find(i => i.id === idTask);
+            if (findTask?.permission) {
+                return of(findTask.permission['ELAPSEDTIME.ADD']);
+            }
+            return this.BXRestNavvyUser.current().result().pipe(mergeMap(self => {
+                if (self) {
+                    return this.BXRestNavvyTasks.task.getaccess({
+                        id: idTask,
+                        users: [self.ID]
+                    }).result().pipe(tap(v => {
+                        if (v && v[self.ID]) {
+                            Permission.set({
+                                tasks: [{ id: idTask, permission: v[self.ID], elapsedItem: [] }]
+                            });
+                        }
+                    }), map(v => {
+                        return (v && v[self.ID]) ? v[self.ID]['ELAPSEDTIME.ADD'] : false;
+                    }));
+                }
+                return of(undefined);
+            }));
+        }
+        return of(undefined);
+    }
+    checkPermissionReadTask(idTask) {
+        let permission = Permission.get();
+        if (permission?.tasks?.length) {
+            let findTask = permission.tasks.find(i => i.id === idTask);
+            if (findTask?.permission) {
+                return of(findTask.permission.ACCEPT);
+            }
+            return this.BXRestNavvyUser.current().result().pipe(mergeMap(self => {
+                if (self) {
+                    return this.BXRestNavvyTasks.task.getaccess({
+                        id: idTask,
+                        users: [self.ID]
+                    }).result().pipe(tap(v => {
+                        if (v && v[self.ID]) {
+                            Permission.set({
+                                tasks: [{ id: idTask, permission: v[self.ID], elapsedItem: [] }]
+                            });
+                        }
+                    }), map(v => {
+                        return (v && v[self.ID]) ? v[self.ID].ACCEPT : false;
+                    }));
+                }
+                return of(undefined);
+            }));
+        }
+        return of(undefined);
+    }
+    del(param) {
+        return this.Navvy.simple(() => this.checkPermissionReadTask(param.TASKID).pipe(mergeMap(allowedReadTask => {
+            if (allowedReadTask) {
+                return this.isAllowedRemove(param.TASKID, param.ITEMID).pipe(mergeMap(allowed => {
+                    if (allowed) {
+                        return this.BXRestElapseditem.del(param);
+                    }
+                    else {
+                        return throwError(() => new Error('Отсутствуют права на удаление записи затраченного времени'));
+                    }
+                }));
+            }
+            else {
+                return throwError(() => new Error('Отсутствуют права на чтение задачи'));
+            }
+        })), 'Не удалось удалить элемент списка', v => (v === null));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyElapseditem, deps: [{ token: i1.BXRestElapseditem }, { token: i2.BXRestNavvyUser }, { token: i3.BXRestNavvyTasks }, { token: i4.BXRestMapTaskElapseditem }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyElapseditem, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyElapseditem, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BXRestElapseditem }, { type: i2.BXRestNavvyUser }, { type: i3.BXRestNavvyTasks }, { type: i4.BXRestMapTaskElapseditem }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"elapseditem.js","sourceRoot":"","sources":["../../../../../projects/bx-rest/src/request-navvy/task/elapseditem.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core'\r\nimport { map } from 'rxjs/operators'\r\nimport { mergeMap, of, tap, throwError } from 'rxjs'\r\nimport { iBXRestParamElapseditemGet } from '../../typification/rest/task/elapseditem/get'\r\nimport { BXRestElapseditem } from '../../request/task/elapseditem'\r\nimport { iBXRestParamAddElapseditem } from '../../typification/rest/task/elapseditem/add'\r\nimport { Permission } from '../../services/permission'\r\nimport { BXRestNavvyUser } from '../user'\r\nimport { BXRestNavvyTasks } from '../tasks'\r\nimport { iBXRestParamUpdateElapseditem } from '../../typification/rest/task/elapseditem/update'\r\nimport { iIsActionAllowedParam } from '../../typification/rest/task/elapseditem/isActionAllowedParam'\r\nimport { iBXRestParamDelElapseditem } from '../../typification/rest/task/elapseditem/del'\r\nimport { Navvy } from '../../services/navvy'\r\nimport { BXRestMapTaskElapseditem } from '../../map/task/elapseditem'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class BXRestNavvyElapseditem {\r\n  private Navvy: Navvy<BXRestElapseditem, BXRestMapTaskElapseditem>\r\n\r\n  constructor(\r\n    private BXRestElapseditem: BXRestElapseditem,\r\n    private BXRestNavvyUser: BXRestNavvyUser,\r\n    private BXRestNavvyTasks: BXRestNavvyTasks,\r\n    private BXRestMapElapseditem: BXRestMapTaskElapseditem,\r\n  ) {\r\n    this.Navvy = new Navvy(this.BXRestElapseditem, this.BXRestMapElapseditem)\r\n  }\r\n\r\n  /*\r\n  call(methodName: string, ...args: any[]){\r\n    if (typeof this[methodName] === 'function') {\r\n      return this[methodName](...args);\r\n    }\r\n    return this[methodName](...args);\r\n  }\r\n   */\r\n\r\n  getList(\r\n    param: iBXRestParamElapseditemGet | undefined = undefined\r\n  ) {\r\n    if (param) {\r\n      if (!param.TASKID && !param.SELECT) {\r\n        param.SELECT = ['*']\r\n      }\r\n      if (!param.TASKID && !param.PARAMS) {\r\n        param.PARAMS = {\r\n          NAV_PARAMS: {\r\n            nPageSize: 50,\r\n            iNumPage: 1\r\n          }\r\n        }\r\n      }\r\n    }\r\n    return this.Navvy.alterPagNav(this.BXRestElapseditem.getList, param)\r\n  }\r\n\r\n  add(param: iBXRestParamAddElapseditem) {\r\n    return this.checkPermissionReadTask(param.TASKID).pipe(\r\n      mergeMap(allowedReadTask => {\r\n        if (allowedReadTask) {\r\n          return this.checkPermissionAddTask(param.TASKID).pipe(\r\n            mergeMap(allowed => {\r\n              if (allowed) {\r\n                return this.BXRestElapseditem.add(param)\r\n              } else {\r\n                return throwError(() => new Error('Отсутствуют права добавление записи затраченного времени'))\r\n              }\r\n            }))\r\n        } else {\r\n          return throwError(() => new Error('Отсутствуют права на чтение задачи'))\r\n        }\r\n      }))\r\n  }\r\n\r\n  update(param: iBXRestParamUpdateElapseditem) {\r\n    return this.Navvy.simple( () => this.checkPermissionReadTask(param.TASKID).pipe(\r\n      mergeMap(allowedReadTask => {\r\n        if (allowedReadTask) {\r\n          return this.isAllowedModify(param.TASKID, param.ITEMID).pipe(\r\n            mergeMap(allowed => {\r\n              if (allowed) {\r\n                return this.BXRestElapseditem.update(param)\r\n              } else {\r\n                return throwError(() => new Error('Отсутствуют права на изменение записи затраченного времени'))\r\n              }\r\n            }))\r\n        } else {\r\n          return throwError(() => new Error('Отсутствуют права на чтение задачи'))\r\n        }\r\n      })), 'Не удалось обновить элемент списка', this.BXRestMapElapseditem.update)\r\n  }\r\n\r\n  /*\r\n  getAll(\r\n    params: RequestParamsElapsedGetList | undefined = undefined,\r\n    cache = false\r\n  ): Observable<iHttpAnswerBX<BXRestElapsed[]> | undefined> {\r\n    return this.get(params, cache)\r\n      .pipe(\r\n        mergeMap(items => {\r\n          if (items && items.result) {\r\n            if (items.next) {\r\n              params = (params) ? params : {}\r\n              params.PARAMS = {\r\n                NAV_PARAMS: {\r\n                  nPageSize: this.pageSize,\r\n                  iNumPage: items.next / this.pageSize + 1\r\n                }\r\n              }\r\n              return this.getAll(params, cache).pipe(\r\n                map(vEnd => {\r\n                  if (vEnd && vEnd.result && items.result) {\r\n                    return merge(clone(vEnd), {result: [...items.result, ...vEnd.result]})\r\n                  }\r\n                  return items\r\n                })\r\n              )\r\n            }\r\n            return of(items)\r\n          } else {\r\n            return of(undefined)\r\n          }\r\n        })\r\n      )\r\n  }\r\n   */\r\n  /*\r\n  getByInterval(idsUsers: number[], dateStart: Date, dateEnd: Date) {\r\n    return new Navvy(\r\n      this.BXRestElapseditem.getList(\r\n        {\r\n          ORDER: {\r\n            ID: 'DESC'\r\n          },\r\n          FILTER: {\r\n            USER_ID: idsUsers,\r\n            '>=CREATED_DATE': dateStart.toLocaleString('ru-Ru'),\r\n            '<=CREATED_DATE': dateEnd.toLocaleString('ru-Ru'),\r\n          }\r\n        }\r\n      ))\r\n    /*\r\n    return this.BXRestElapseditem.getList({\r\n        ORDER: {\r\n          ID: 'DESC'\r\n        },\r\n        FILTER: {\r\n          USER_ID: idsUsers,\r\n          '>=CREATED_DATE': dateStart.toLocaleString('ru-Ru'),\r\n          '<=CREATED_DATE': dateEnd.toLocaleString('ru-Ru'),\r\n        }\r\n      }\r\n    )\r\n   */\r\n/*\r\n  }\r\n\r\n\r\n  /*\r\n  getCacheOff(params: RequestParamsElapsedGetList | undefined = undefined) {\r\n    return this.http.post<iHttpAnswerBX<BXRestElapsedHttp[]> | undefined>\r\n    (this.url.getlist, params, 'не удалось получить время по задачам')\r\n      .pipe(\r\n        map(v => {\r\n          if (v && v.result) {\r\n            const newResult: BXRestElapsed[] = []\r\n            for (let task of v.result) {\r\n              newResult.push(this.elapsedBXMap.AnswerElapsedGetHttpToAnswerElapsedGet(task))\r\n            }\r\n            return extend(v, {result: newResult}) as iHttpAnswerBX<BXRestElapsed[]>\r\n          }\r\n          return undefined\r\n        }),\r\n        tap(v => {\r\n          if (v && params) {\r\n            this.store.dispatch(saveHttpTaskTime({\r\n              filter: clone(params),\r\n              time: v\r\n            }))\r\n          }\r\n        })\r\n      )\r\n  }\r\n  */\r\n\r\n  isAllowedModify(idTask: number, idItem: number) {\r\n    let permission = Permission.get()\r\n    if (permission?.tasks?.length) {\r\n      let findTask = permission.tasks.find(i => i.id === idTask)\r\n      if (findTask) {\r\n        let find = findTask.elapsedItem.find(i => i.id === idItem)\r\n        if (find && find.verified.edit) {\r\n          return of(find.edit)\r\n        }\r\n      }\r\n    }\r\n\r\n    return this.isActionAllowed({\r\n      TASKID: idTask,\r\n      ITEMID: 2,\r\n      ACTIONID: idItem\r\n    }).result().pipe(\r\n      tap(v => {\r\n        if (v !== undefined) {\r\n          Permission.setTaskElapsedItem(idTask,\r\n            {\r\n              id: idItem,\r\n              edit: v,\r\n              del: false,\r\n              verified: {\r\n                edit: true,\r\n                del: false,\r\n              }\r\n            })\r\n        }\r\n      })\r\n    )\r\n  }\r\n\r\n  private isAllowedRemove(idTask: number, idItem: number) {\r\n    return this.isActionAllowed(\r\n      {\r\n        TASKID: idTask,\r\n        ITEMID: 3,\r\n        ACTIONID: idItem\r\n      }).result()\r\n  }\r\n\r\n  /**\r\n   * idAction:\r\n   * 1 - ACTION_ELAPSED_TIME_ADD\r\n   * 2 - ACTION_ELAPSED_TIME_MODIFY\r\n   * 3 - ACTION_ELAPSED_TIME_REMOVE\r\n   * @param param\r\n   */\r\n  isActionAllowed(param: iIsActionAllowedParam) {\r\n    return this.Navvy.simple(() => this.checkPermissionReadTask(param.TASKID).pipe(\r\n      mergeMap(canRead => {\r\n        if (canRead) {\r\n          return this.BXRestElapseditem.isActionAllowed(param)\r\n        }\r\n        return throwError(() => new Error('Отсутствуют права на чтение задачи'))\r\n      })\r\n    ))\r\n  }\r\n\r\n  checkPermissionAddTask(idTask: number) {\r\n    let permission = Permission.get()\r\n    if (permission?.tasks?.length) {\r\n      let findTask = permission.tasks.find(i => i.id === idTask)\r\n      if (findTask?.permission) {\r\n        return of(findTask.permission['ELAPSEDTIME.ADD'])\r\n      }\r\n      return this.BXRestNavvyUser.current().result().pipe(\r\n        mergeMap(self => {\r\n          if (self) {\r\n            return this.BXRestNavvyTasks.task.getaccess(\r\n              {\r\n                id: idTask,\r\n                users: [self.ID]\r\n              }).result().pipe(\r\n              tap(v => {\r\n                if (v && v[self.ID]) {\r\n                  Permission.set({\r\n                    tasks: [{id: idTask, permission: v[self.ID], elapsedItem: []}]\r\n                  })\r\n                }\r\n              }),\r\n              map(v => {\r\n                return (v && v[self.ID]) ? v[self.ID]['ELAPSEDTIME.ADD'] : false\r\n              }),\r\n            )\r\n          }\r\n          return of(undefined)\r\n        })\r\n      )\r\n    }\r\n\r\n    return of(undefined)\r\n  }\r\n\r\n  private checkPermissionReadTask(idTask: number) {\r\n    let permission = Permission.get()\r\n    if (permission?.tasks?.length) {\r\n      let findTask = permission.tasks.find(i => i.id === idTask)\r\n      if (findTask?.permission) {\r\n        return of(findTask.permission.ACCEPT)\r\n      }\r\n      return this.BXRestNavvyUser.current().result().pipe(\r\n        mergeMap(self => {\r\n          if (self) {\r\n            return this.BXRestNavvyTasks.task.getaccess(\r\n              {\r\n                id: idTask,\r\n                users: [self.ID]\r\n              }).result().pipe(\r\n              tap(v => {\r\n                if (v && v[self.ID]) {\r\n                  Permission.set({\r\n                    tasks: [{id: idTask, permission: v[self.ID], elapsedItem: []}]\r\n                  })\r\n                }\r\n              }),\r\n              map(v => {\r\n                return (v && v[self.ID]) ? v[self.ID].ACCEPT : false\r\n              }),\r\n            )\r\n          }\r\n          return of(undefined)\r\n        })\r\n      )\r\n    }\r\n\r\n    return of(undefined)\r\n  }\r\n\r\n  del(param: iBXRestParamDelElapseditem) {\r\n    return this.Navvy.simple( () => this.checkPermissionReadTask(param.TASKID).pipe(\r\n      mergeMap(allowedReadTask => {\r\n        if (allowedReadTask) {\r\n          return this.isAllowedRemove(param.TASKID, param.ITEMID).pipe(\r\n            mergeMap(allowed => {\r\n              if (allowed) {\r\n                return this.BXRestElapseditem.del(param)\r\n              } else {\r\n                return throwError(() => new Error('Отсутствуют права на удаление записи затраченного времени'))\r\n              }\r\n            }))\r\n        } else {\r\n          return throwError(() => new Error('Отсутствуют права на чтение задачи'))\r\n        }\r\n      })\r\n    ), 'Не удалось удалить элемент списка', v => (v === null))\r\n  }\r\n\r\n}\r\n"]}

package/{esm2020 → esm2022}/request-navvy/task.mjs

@@ -5,13 +5,13 @@ export class BXRestNavvyTask {
     constructor(elapseditem) {
         this.elapseditem = elapseditem;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyTask, deps: [{ token: i1.BXRestNavvyElapseditem }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyTask, providedIn: 'root' }); }
 }
-BXRestNavvyTask.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyTask, deps: [{ token: i1.BXRestNavvyElapseditem }], target: i0.ɵɵFactoryTarget.Injectable });
-BXRestNavvyTask.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyTask, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyTask, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyTask, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }], ctorParameters: function () { return [{ type: i1.BXRestNavvyElapseditem }]; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2J4LXJlc3Qvc3JjL3JlcXVlc3QtbmF2dnkvdGFzay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFBOzs7QUFNMUMsTUFBTSxPQUFPLGVBQWU7SUFFMUIsWUFDUyxXQUFtQztRQUFuQyxnQkFBVyxHQUFYLFdBQVcsQ0FBd0I7SUFFNUMsQ0FBQzs7NEdBTFUsZUFBZTtnSEFBZixlQUFlLGNBRmQsTUFBTTsyRkFFUCxlQUFlO2tCQUgzQixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xyXG5pbXBvcnQgeyBCWFJlc3ROYXZ2eUVsYXBzZWRpdGVtIH0gZnJvbSAnLi90YXNrL2VsYXBzZWRpdGVtJ1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgQlhSZXN0TmF2dnlUYXNrIHtcclxuXHJcbiAgY29uc3RydWN0b3IoXHJcbiAgICBwdWJsaWMgZWxhcHNlZGl0ZW06IEJYUmVzdE5hdnZ5RWxhcHNlZGl0ZW0sXHJcbiAgKSB7XHJcbiAgfVxyXG5cclxufVxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2J4LXJlc3Qvc3JjL3JlcXVlc3QtbmF2dnkvdGFzay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFBOzs7QUFNMUMsTUFBTSxPQUFPLGVBQWU7SUFFMUIsWUFDUyxXQUFtQztRQUFuQyxnQkFBVyxHQUFYLFdBQVcsQ0FBd0I7SUFFNUMsQ0FBQzs4R0FMVSxlQUFlO2tIQUFmLGVBQWUsY0FGZCxNQUFNOzsyRkFFUCxlQUFlO2tCQUgzQixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xyXG5pbXBvcnQgeyBCWFJlc3ROYXZ2eUVsYXBzZWRpdGVtIH0gZnJvbSAnLi90YXNrL2VsYXBzZWRpdGVtJ1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgQlhSZXN0TmF2dnlUYXNrIHtcclxuXHJcbiAgY29uc3RydWN0b3IoXHJcbiAgICBwdWJsaWMgZWxhcHNlZGl0ZW06IEJYUmVzdE5hdnZ5RWxhcHNlZGl0ZW0sXHJcbiAgKSB7XHJcbiAgfVxyXG5cclxufVxyXG4iXX0=