bx-rest 0.1.10 → 0.1.15

package/esm2022/request/tasks/task.mjs

@@ -0,0 +1,217 @@
+import { Injectable } from '@angular/core';
+import { $add, $approve, $attach, $complete, $counters, $deger, $delegate, $delete, $disapprove, $favorite, $files, $get, $getaccess, $getFields, $getlist, $history, $list, $pause, $planner, $renew, $result, $start, $task, $tasks, $update } from '../../consts/part-name-metods';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/http/HttpBX";
+// import { AnswerApiTaskBX } from '../../typification/rest/task/answers/task';
+export class BXRestTasksTask {
+    constructor(http) {
+        this.http = http;
+        this.url = {
+            add: [$tasks, $task, $add],
+            approve: [$tasks, $task, $approve],
+            complete: [$tasks, $task, $complete],
+            counters: {
+                get: [$tasks, $task, $counters, $get], //Получает счетчики пользователя
+            },
+            deger: [$tasks, $task, $deger],
+            delegate: [$tasks, $task, $delegate],
+            delete: [$tasks, $task, $delete],
+            disapprove: [$tasks, $task, $disapprove],
+            favorite: {
+                add: [$tasks, $task, $favorite, $add],
+                delete: [$tasks, $task, $favorite, $delete], // Удаляет задачи из "Избранного"
+            },
+            files: {
+                attach: [$tasks, $task, $files, $attach], // Прикрепляет загруженный на диск файл к задаче
+            },
+            get: [$tasks, $task, $get],
+            getFields: [$tasks, $task, $getFields],
+            getaccess: [$tasks, $task, $getaccess],
+            history: {
+                list: [$tasks, $task, $history, $list], // Получает историю задачи
+            },
+            list: [$tasks, $task, $list],
+            pause: [$tasks, $task, $pause],
+            renew: [$tasks, $task, $renew],
+            start: [$tasks, $task, $start],
+            startwatch: [$tasks, $task, 'startwatch'],
+            stopwatch: [$tasks, $task, 'stopwatch'],
+            update: [$tasks, $task, $update],
+            result: {
+                list: [$tasks, $task, $result, $list],
+                addFromComment: [$tasks, $task, $result, 'addFromComment'],
+                deleteFromComment: [$tasks, $task, $result, 'deleteFromComment'], // Удаление результата задачи по комментарию из которого он был создан
+            },
+            planner: {
+                getlist: [$task, $planner, $getlist], // Возвращает массив, содержащий идентификаторы задач в плане на день
+            }
+        };
+    }
+    add(param) {
+        return this.http.post(this.url.add, param);
+    }
+    /*
+    update(taskId: number, updateFields: iBXRestTaskFieldsName[], task: iBXRestTask) {
+      let sendTask: Record<string, any> = {}
+      let taskTS: Record<string, any> = task
+      if (updateFields.length) {
+        for (let updateField of updateFields) {
+          if (taskTS[camelCase(updateField)]) {
+            sendTask[updateField] = taskTS[camelCase(updateField)]
+          }
+        }
+        if (Object.values(sendTask).length) {
+          return this.http.post(
+            this.url.update,
+            {taskId: taskId, fields: sendTask},
+            'error to update task')
+        } else {
+          this.snackBar.error('not valid send data task')
+          console.error('not valid send data task', sendTask, task)
+          return of(undefined)
+        }
+      }
+  
+      this.snackBar.warning('not have field for update')
+      return of(undefined)
+    }
+    */
+    get(requestArray) {
+        return this.http.post(this.url.get, requestArray);
+    }
+    list(param = {}) {
+        return this.http.post(this.url.list, param);
+    }
+    /*
+    listArray(requestArray: RequestApiTaskListBX = {}) {
+      return this.list(requestArray).pipe(
+        map(v => this.http.mapResult(v)),
+        map(v => (v && v.tasks) ? v.tasks : [])
+      )
+    }
+  
+    listAll(requestArray: RequestApiTaskListBX = {}, cache = false): Observable<TaskBX[]> {
+      if (!requestArray.select) {
+        requestArray.select = this.def.select
+        if (cache) {
+          return this.storeTask$.pipe(
+            take(1),
+            mergeMap(tasks => {
+              if (tasks && tasks.data.http.list && requestArray.filter && requestArray.filter.ID) {
+                const ids = (typeof requestArray.filter.ID === 'number') ? [requestArray.filter.ID] : requestArray.filter.ID
+                let filter = tasks.data.http.list.filter(i => (i.id) ? ids.includes(i.id) : false)
+                if (filter.length === ids.length) {
+                  return of(filter)
+                }
+              }
+              return this.getEndListArray(requestArray)
+            })
+          )
+        }
+        return this.getEndListArray(requestArray)
+      }
+      return this.getEndListArray(requestArray)
+    }
+  
+    getEndListArray(requestArray: RequestApiTaskListBX): Observable<TaskBX[]> {
+      return this.list(requestArray).pipe(
+        mergeMap((items: AnswerApiTaskBX | undefined): ObservableInput<any> | Observable<AnswerApiTaskBX[]> => {
+          if (items && items.result && typeof items.result.tasks === 'object') {
+            const items$ = of(items.result.tasks)
+            if (items.next) {
+              this.nowLoad$.next({
+                total: (items.total) ? items.total : 0,
+                next: items.next
+              })
+              requestArray.start = items.next
+              return this.getEndListArray(requestArray).pipe(
+                map(vEnd => {
+                  if (vEnd && items.result.tasks) {
+                    return [...items.result.tasks, ...vEnd]
+                  }
+                  return (items.result.tasks) ? items.result.tasks : []
+                }))
+            }
+            this.nowLoad$.next({
+              total: 0,
+              next: 0
+            })
+            return items$
+          } else {
+            return of([])
+          }
+        })
+      )
+    }
+  
+    getFields() {
+      return this.storeTask$.pipe(
+        mergeMap(v => {
+          if (v && !v.data.fields) {
+            return this.http.post<iHttpAnswerBX<{ fields: iGetFieldsDescription }>>(this.url.getFields).pipe(
+              tap(v => {
+                if (v && v.result) {
+                  this.store.dispatch(saveFields(v.result))
+                }
+              }),
+              map(v => {
+                if (v && v.result && v.result.fields) {
+                  return {result: v.result.fields}
+                }
+  
+                return undefined
+              })
+            )
+          }
+          if (v.data.fields) {
+            return of({result: clone<iGetFieldsDescription>(v.data.fields)})
+          } else {
+            return of(undefined)
+          }
+        })
+      )
+    }
+  
+    deleteResultFromComment(commentID: number) {
+      return this.http.post<iHttpAnswerBX<any>>(this.url.result.deleteFromComment, {commentId: commentID})
+    }
+  
+    addResultFromComment(commentID: number) {
+      return this.http.post<iHttpAnswerBX<iTaskResultHttp>>(this.url.result.addFromComment, {commentId: commentID})
+        .pipe(
+          map(v => {
+            if (v && v.result) {
+              this.taskResultMap.iTaskResultHttpToiTaskResult(v.result)
+            }
+            return undefined
+          }))
+    }
+  
+    getResulList(taskId: number): Observable<iTaskResult[] | undefined> {
+      return this.http.post<iHttpAnswerBX<iTaskResultHttp[]>>(this.url.result.list, {taskId: taskId})
+        .pipe(
+          map(v => {
+            if (v && v.result) {
+              return v.result.map(i => this.taskResultMap.iTaskResultHttpToiTaskResult(i))
+            }
+            return undefined
+          }))
+    }
+  
+    getPlannerList() {s
+      return this.http.post<iHttpAnswerBX<(string | number)[]>>(this.url.planner.getlist)
+    }
+     */
+    getaccess(param) {
+        return this.http.post(this.url.getaccess, param);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestTasksTask, deps: [{ token: i1.HttpBXServices }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestTasksTask, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestTasksTask, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpBXServices }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task.js","sourceRoot":"","sources":["../../../../../projects/bx-rest/src/request/tasks/task.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core'\nimport {\n  $add, $approve, $attach, $complete, $counters, $deger, $delegate, $delete, $disapprove, $favorite, $files,\n  $get, $getaccess, $getFields, $getlist, $history, $list, $pause, $planner, $renew, $result, $start,\n  $task, $tasks, $update\n} from '../../consts/part-name-metods'\nimport { HttpBXServices } from '../../services/http/HttpBX'\nimport { iBXRestHttpTask } from '../../typification/rest/task/task'\nimport { iBXRestParamTaskAdd } from '../../typification/rest/tasks/task/add'\nimport iBXRestParamTaskGet from '../../typification/rest/tasks/task/get'\nimport { iBXRestParamTasksList } from '../../typification/rest/tasks/task/list'\nimport { iBXRestParamTaskGetAccess, iBXRestTaskGetAccess } from '../../typification/rest/task/access/getaccess'\n// import { AnswerApiTaskBX } from '../../typification/rest/task/answers/task';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class BXRestTasksTask {\n\n  url = {\n    add: [$tasks, $task, $add], // Создает задачу\n    approve: [$tasks, $task, $approve], // Позволяет принять задачу\n    complete: [$tasks, $task, $complete], // Переводит задачу в статус «завершена»\n    counters: {\n      get: [$tasks, $task, $counters, $get], //Получает счетчики пользователя\n    },\n    deger: [$tasks, $task, $deger], // Переводит задачу в статус «отложена»\n    delegate: [$tasks, $task, $delegate], // Метод для делегирования задачи\n    delete: [$tasks, $task, $delete], // Удаляет задачу\n    disapprove: [$tasks, $task, $disapprove], // Позволяет отклонить задачу\n    favorite: {\n      add: [$tasks, $task, $favorite, $add], // Добавляет задачи в \"Избранное\"\n      delete: [$tasks, $task, $favorite, $delete], // Удаляет задачи из \"Избранного\"\n    },\n    files: {\n      attach: [$tasks, $task, $files, $attach], // Прикрепляет загруженный на диск файл к задаче\n    },\n    get: [$tasks, $task, $get], // Возвращает информацию о конкретной задаче\n    getFields: [$tasks, $task, $getFields], // Возвращает все доступные поля\n    getaccess: [$tasks, $task, $getaccess], // Метод для проверки доступа к задаче\n    history: {\n      list: [$tasks, $task, $history, $list], // Получает историю задачи\n    },\n    list: [$tasks, $task, $list], // Возвращает массив задач, каждая из которых содержит массив полей\n    pause: [$tasks, $task, $pause], // Останавливает выполнение задачи, переводя ее в статус \"ждет выполнения\"\n    renew: [$tasks, $task, $renew], // Возобновляет задачу после ее завершения\n    start: [$tasks, $task, $start], // Переводит задачу в статус «выполняется»\n    startwatch: [$tasks, $task, 'startwatch'], // Позволяет наблюдать за задачей\n    stopwatch: [$tasks, $task, 'stopwatch'], // Останавливает наблюдение за задачей\n    update: [$tasks, $task, $update], // Обновляет задачу\n    result: {\n      list: [$tasks, $task, $result, $list], // Просмотр списка результатов к задаче\n      addFromComment: [$tasks, $task, $result, 'addFromComment'], // Создание результата задачи из комментария\n      deleteFromComment: [$tasks, $task, $result, 'deleteFromComment'], // Удаление результата задачи по комментарию из которого он был создан\n    },\n    planner: {\n      getlist: [$task, $planner, $getlist], // Возвращает массив, содержащий идентификаторы задач в плане на день\n    }\n  }\n\n  constructor(\n    private http: HttpBXServices,\n  ) {\n  }\n\n  add(param: { fields: iBXRestParamTaskAdd }) {\n    return this.http.post<{ task: iBXRestHttpTask }>(this.url.add, param)\n  }\n\n  /*\n  update(taskId: number, updateFields: iBXRestTaskFieldsName[], task: iBXRestTask) {\n    let sendTask: Record<string, any> = {}\n    let taskTS: Record<string, any> = task\n    if (updateFields.length) {\n      for (let updateField of updateFields) {\n        if (taskTS[camelCase(updateField)]) {\n          sendTask[updateField] = taskTS[camelCase(updateField)]\n        }\n      }\n      if (Object.values(sendTask).length) {\n        return this.http.post(\n          this.url.update,\n          {taskId: taskId, fields: sendTask},\n          'error to update task')\n      } else {\n        this.snackBar.error('not valid send data task')\n        console.error('not valid send data task', sendTask, task)\n        return of(undefined)\n      }\n    }\n\n    this.snackBar.warning('not have field for update')\n    return of(undefined)\n  }\n  */\n\n  get(requestArray: iBXRestParamTaskGet) {\n    return this.http.post<{ task: iBXRestHttpTask | undefined }>(this.url.get, requestArray)\n  }\n\n  list(param: iBXRestParamTasksList = {}) {\n    return this.http.post<{tasks: iBXRestHttpTask[] | undefined}>(this.url.list, param)\n  }\n  /*\n  listArray(requestArray: RequestApiTaskListBX = {}) {\n    return this.list(requestArray).pipe(\n      map(v => this.http.mapResult(v)),\n      map(v => (v && v.tasks) ? v.tasks : [])\n    )\n  }\n\n  listAll(requestArray: RequestApiTaskListBX = {}, cache = false): Observable<TaskBX[]> {\n    if (!requestArray.select) {\n      requestArray.select = this.def.select\n      if (cache) {\n        return this.storeTask$.pipe(\n          take(1),\n          mergeMap(tasks => {\n            if (tasks && tasks.data.http.list && requestArray.filter && requestArray.filter.ID) {\n              const ids = (typeof requestArray.filter.ID === 'number') ? [requestArray.filter.ID] : requestArray.filter.ID\n              let filter = tasks.data.http.list.filter(i => (i.id) ? ids.includes(i.id) : false)\n              if (filter.length === ids.length) {\n                return of(filter)\n              }\n            }\n            return this.getEndListArray(requestArray)\n          })\n        )\n      }\n      return this.getEndListArray(requestArray)\n    }\n    return this.getEndListArray(requestArray)\n  }\n\n  getEndListArray(requestArray: RequestApiTaskListBX): Observable<TaskBX[]> {\n    return this.list(requestArray).pipe(\n      mergeMap((items: AnswerApiTaskBX | undefined): ObservableInput<any> | Observable<AnswerApiTaskBX[]> => {\n        if (items && items.result && typeof items.result.tasks === 'object') {\n          const items$ = of(items.result.tasks)\n          if (items.next) {\n            this.nowLoad$.next({\n              total: (items.total) ? items.total : 0,\n              next: items.next\n            })\n            requestArray.start = items.next\n            return this.getEndListArray(requestArray).pipe(\n              map(vEnd => {\n                if (vEnd && items.result.tasks) {\n                  return [...items.result.tasks, ...vEnd]\n                }\n                return (items.result.tasks) ? items.result.tasks : []\n              }))\n          }\n          this.nowLoad$.next({\n            total: 0,\n            next: 0\n          })\n          return items$\n        } else {\n          return of([])\n        }\n      })\n    )\n  }\n\n  getFields() {\n    return this.storeTask$.pipe(\n      mergeMap(v => {\n        if (v && !v.data.fields) {\n          return this.http.post<iHttpAnswerBX<{ fields: iGetFieldsDescription }>>(this.url.getFields).pipe(\n            tap(v => {\n              if (v && v.result) {\n                this.store.dispatch(saveFields(v.result))\n              }\n            }),\n            map(v => {\n              if (v && v.result && v.result.fields) {\n                return {result: v.result.fields}\n              }\n\n              return undefined\n            })\n          )\n        }\n        if (v.data.fields) {\n          return of({result: clone<iGetFieldsDescription>(v.data.fields)})\n        } else {\n          return of(undefined)\n        }\n      })\n    )\n  }\n\n  deleteResultFromComment(commentID: number) {\n    return this.http.post<iHttpAnswerBX<any>>(this.url.result.deleteFromComment, {commentId: commentID})\n  }\n\n  addResultFromComment(commentID: number) {\n    return this.http.post<iHttpAnswerBX<iTaskResultHttp>>(this.url.result.addFromComment, {commentId: commentID})\n      .pipe(\n        map(v => {\n          if (v && v.result) {\n            this.taskResultMap.iTaskResultHttpToiTaskResult(v.result)\n          }\n          return undefined\n        }))\n  }\n\n  getResulList(taskId: number): Observable<iTaskResult[] | undefined> {\n    return this.http.post<iHttpAnswerBX<iTaskResultHttp[]>>(this.url.result.list, {taskId: taskId})\n      .pipe(\n        map(v => {\n          if (v && v.result) {\n            return v.result.map(i => this.taskResultMap.iTaskResultHttpToiTaskResult(i))\n          }\n          return undefined\n        }))\n  }\n\n  getPlannerList() {s\n    return this.http.post<iHttpAnswerBX<(string | number)[]>>(this.url.planner.getlist)\n  }\n   */\n\n  getaccess(param: iBXRestParamTaskGetAccess) {\n    return this.http.post<iBXRestTaskGetAccess>(this.url.getaccess, param)\n  }\n\n}\n\n"]}

package/{esm2020 → esm2022}/request/tasks.mjs

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

package/esm2022/request/user.mjs

@@ -0,0 +1,109 @@
+import { share, throwError } from 'rxjs';
+import clone from 'just-clone';
+import { $get, $list, $search, $update, $user } from '../consts/part-name-metods';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/http/HttpBX";
+import * as i2 from "../map/user";
+export class BXRestUser {
+    constructor(http, BXRestUserMap) {
+        this.http = http;
+        this.BXRestUserMap = BXRestUserMap;
+        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 }
+        };
+    }
+    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);
+    }
+    current(update = false) {
+        let request = this.http.get(this.url.current, {});
+        if (update) {
+            return request;
+        }
+        else {
+            return request.pipe(share());
+        }
+    }
+    update(user, fieldUpdate) {
+        if (fieldUpdate && fieldUpdate.length) {
+            let sendData = {
+                ID: user.ID,
+            };
+            const userBX = this.BXRestUserMap.BXtoHttp(user);
+            for (const field of fieldUpdate) {
+                if (userBX[field]) {
+                    sendData[field] = userBX[field];
+                }
+                else {
+                    return throwError(() => 'One sent field is empty');
+                }
+            }
+            return this.http.post(this.url.update, sendData);
+        }
+        else {
+            return throwError(() => 'All sent field for edit is empty');
+        }
+    }
+    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);
+    }
+    access(access) {
+        return this.http.get(this.url.access, { ACCESS: access });
+    }
+    fields() {
+        return this.http.get(this.url.fields);
+    }
+    setDefParam(params) {
+        if (!params.FILTER) {
+            params.FILTER = {};
+        }
+        if (!params.hasOwnProperty('ACTIVE')) {
+            params.FILTER.ACTIVE = this.def.params.ACTIVE;
+        }
+        if (params.FILTER.ACTIVE && params.FILTER.ACTIVE === 2) {
+            delete params.FILTER.ACTIVE;
+        }
+        if (!params.hasOwnProperty('start')) {
+            params.start = this.def.params.start;
+        }
+        if (params.FILTER.UF_DEPARTMENT && !params.FILTER.UF_DEPARTMENT.length) {
+            delete params.FILTER.UF_DEPARTMENT;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestUser, deps: [{ token: i1.HttpBXServices }, { token: i2.BXRestUserMap }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestUser, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestUser, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpBXServices }, { type: i2.BXRestUserMap }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user.js","sourceRoot":"","sources":["../../../../projects/bx-rest/src/request/user.ts"],"names":[],"mappings":"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","sourcesContent":["import { share, throwError } from 'rxjs'\nimport clone from 'just-clone'\nimport { iBXRestParamUserGet } from '../typification/rest/user/get'\nimport { HttpBXServices } from '../services/http/HttpBX'\nimport UserFilterSearch from '../typification/rest/user/UserFilterSearch'\nimport { iBXRestUser, iBXRestUserHttp, iBXRestUserHttpField } from '../typification/rest/user/user'\nimport { $get, $list, $search, $update, $user } from '../consts/part-name-metods'\nimport { Injectable } from '@angular/core'\nimport { iBXRestAnswer } from '../typification/rest/base/answer'\nimport { BXRestUserMap } from '../map/user'\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class BXRestUser {\n\n  url = {\n    admin: [$user, 'admin'],\n    get: [$user, $get],\n    current: [$user, 'current'],\n    update: [$user, $update],\n    search: [$user, $search],\n    access: [$user, 'access'], // U1 - пользователь с id =1\n    // AU - все авторизованные пользователи\n    // D1 - подразделение с id=1\n    // G1 - группа с id=1\n    fields: [$user, 'fields'],\n    userfield: {\n      list: [$user, 'userfield', $list]\n    }\n  }\n\n  def: { params: { ACTIVE: 1, start: 0 } } = {\n    params: {ACTIVE: 1, start: 0}\n  }\n\n  constructor(\n    private http: HttpBXServices,\n    private BXRestUserMap: BXRestUserMap\n  ) {\n  }\n\n  admin() {\n    return this.http.get<boolean>(this.url.admin)\n  }\n\n  get(params: iBXRestParamUserGet = {}) {\n    let copyParams = clone(params)\n    this.setDefParam(copyParams)\n    return this.http.post<iBXRestUserHttp[]>\n    (\n      this.url.get,\n      copyParams\n    )\n  }\n\n  current(update = false) {\n    let request = this.http.get<iBXRestUserHttp>(this.url.current, {})\n    if(update) {\n      return request\n    } else {\n      return request.pipe(\n        share()\n      )\n    }\n  }\n\n  update(user: iBXRestUser, fieldUpdate: string[]) {\n    if (fieldUpdate && fieldUpdate.length) {\n      let sendData: any = {\n        ID: user.ID,\n      }\n      const userBX = this.BXRestUserMap.BXtoHttp(user)\n      for (const field of fieldUpdate) {\n        if (userBX[field]) {\n          sendData[field] = userBX[field]\n        } else {\n          return throwError(() => 'One sent field is empty')\n        }\n      }\n      return this.http.post<iBXRestUserHttp[]>(\n        this.url.update,\n        sendData\n      )\n    } else {\n      return throwError(() => 'All sent field for edit is empty')\n    }\n  }\n\n  search(params: string | UserFilterSearch) {\n    if (typeof params === 'string') {\n      params = {FIND: params}\n    }\n    if (typeof params.ACTIVE !== 'boolean') {\n      params.ACTIVE = true\n    }\n    return this.http.get<iBXRestAnswer<iBXRestUserHttp[]>>(\n      this.url.search,\n      params\n    )\n  }\n\n  access(access: string[]) {\n    return this.http.get<iBXRestAnswer<boolean> | undefined>(this.url.access, {ACCESS: access})\n  }\n\n  fields() {\n    return this.http.get<iBXRestAnswer<iBXRestUserHttpField>>(this.url.fields)\n  }\n\n  private setDefParam(params: iBXRestParamUserGet) {\n    if(!params.FILTER) {\n      params.FILTER = {}\n    }\n\n    if (!params.hasOwnProperty('ACTIVE')) {\n      params.FILTER.ACTIVE = this.def.params.ACTIVE\n    }\n    if (params.FILTER.ACTIVE && params.FILTER.ACTIVE === 2) {\n      delete params.FILTER.ACTIVE\n    }\n    if (!params.hasOwnProperty('start')) {\n      params.start = this.def.params.start\n    }\n\n    if (params.FILTER.UF_DEPARTMENT && !params.FILTER.UF_DEPARTMENT.length) {\n      delete params.FILTER.UF_DEPARTMENT\n    }\n  }\n}\n\n"]}

package/esm2022/request-navvy/bizproc/workflow.mjs

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import { Navvy } from '../../services/navvy';
+import * as i0 from "@angular/core";
+import * as i1 from "../../request/bizproc/workflow";
+export class BXRestNavvyBizprocWorkflow {
+    constructor(BXRestBizprocWorkflow) {
+        this.BXRestBizprocWorkflow = BXRestBizprocWorkflow;
+        this.Navvy = new Navvy(this.BXRestBizprocWorkflow, undefined);
+    }
+    start(param) {
+        return this.Navvy.simpleWithArg(this.BXRestBizprocWorkflow.start, param, 'Не удалось запустить бизнес процесс');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyBizprocWorkflow, deps: [{ token: i1.BXRestBizprocWorkflow }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyBizprocWorkflow, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyBizprocWorkflow, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BXRestBizprocWorkflow }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/request-navvy/bizproc.mjs

@@ -0,0 +1,61 @@
+import { Injectable } from '@angular/core';
+import { forkJoin, mergeMap, of, throwError } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./bizproc/workflow";
+import * as i2 from "./lists";
+export class BXRestNavvyBizproc {
+    constructor(workflow, BXRestNavvyLists) {
+        this.workflow = workflow;
+        this.BXRestNavvyLists = BXRestNavvyLists;
+    }
+    /**
+     * Метод по запуску бизнес процессов из ленты
+     * TODO: продумать работу с такими методами-исключениями
+     *
+     * @param id
+     * @param parametersElement
+     * @param parametersBizproc
+     * @param templateIDs
+     */
+    startProcFormNewsFeed(id, parametersElement, parametersBizproc, templateIDs) {
+        return this.BXRestNavvyLists.element.add({
+            IBLOCK_TYPE_ID: 'bitrix_processes',
+            IBLOCK_ID: id,
+            ELEMENT_CODE: 'trace_studio_' + Date.now() + '_' + Math.random(),
+            // тут должно быть уникально значение (генерация уникальных значений на фронте лол),
+            // как ещё уникальнее сделать я просто не знаю
+            // это поле обязательно без него не работает
+            FIELDS: {
+                NAME: parametersElement['NAME'],
+                ...parametersElement
+            }
+        }).result().pipe(mergeMap(v => {
+            if (v) {
+                if (Object.keys(parametersBizproc).length) {
+                    let reques = [];
+                    for (let templateID of templateIDs) {
+                        reques.push(this.workflow.start({
+                            TEMPLATE_ID: templateID,
+                            DOCUMENT_ID: ['lists', 'BizprocDocument', String(v)],
+                            PARAMETERS: parametersBizproc
+                        }).result());
+                    }
+                    return forkJoin(reques);
+                }
+                else {
+                    return of(true);
+                }
+            }
+            return throwError(() => new Error('Не удалось запустить бизнес процесс'));
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyBizproc, deps: [{ token: i1.BXRestNavvyBizprocWorkflow }, { token: i2.BXRestNavvyLists }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyBizproc, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyBizproc, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BXRestNavvyBizprocWorkflow }, { type: i2.BXRestNavvyLists }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/request-navvy/calendar/event.mjs

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

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

@@ -40,13 +40,13 @@ export class BXRestNavvyCalendar {
     constructor(event) {
         this.event = event;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyCalendar, deps: [{ token: i1.BXRestRestCalendarEvent }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyCalendar, providedIn: 'root' }); }
 }
-BXRestNavvyCalendar.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyCalendar, deps: [{ token: i1.BXRestRestCalendarEvent }], target: i0.ɵɵFactoryTarget.Injectable });
-BXRestNavvyCalendar.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyCalendar, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyCalendar, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyCalendar, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }], ctorParameters: function () { return [{ type: i1.BXRestRestCalendarEvent }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/request-navvy/disk/attachedObject.mjs

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

package/esm2022/request-navvy/disk/file.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/disk/file";
+import * as i2 from "../../map/disk/file";
+export class BXRestNavvyDiskFile {
+    constructor(BXRestDiskFile, BXRestMapDiskFile) {
+        this.BXRestDiskFile = BXRestDiskFile;
+        this.BXRestMapDiskFile = BXRestMapDiskFile;
+        this.Navvy = new Navvy(this.BXRestDiskFile, this.BXRestMapDiskFile);
+    }
+    get(id) {
+        return this.Navvy.simpleWithArg(this.BXRestDiskFile.get, id, 'Не удалось получить файл', this.BXRestMapDiskFile.get);
+    }
+    markdeleted(id) {
+        return this.Navvy.simpleWithArg(this.BXRestDiskFile.markdeleted, id, 'Не удалось переместить файл в корзину', this.BXRestMapDiskFile.markdeleted);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyDiskFile, deps: [{ token: i1.BXRestDiskFile }, { token: i2.BXRestMapDiskFile }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyDiskFile, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: BXRestNavvyDiskFile, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BXRestDiskFile }, { type: i2.BXRestMapDiskFile }]; } });
+//# sourceMappingURL=data:application/json;base64,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