bx-rest 0.26.0 → 1.0.0

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

@@ -0,0 +1,354 @@
+import { Navvy } from '../../services/navvy';
+import { BXRestMapTasksTask } from '../../map/tasks/task';
+import { BXRestNavvyTasksTaskResult } from './task/result';
+import camelCase from 'just-camel-case';
+import { $add, $addFromComment, $approve, $complete, $defer, $delegate, $delete, $deleteFromComment, $disapprove, $get, $getFieldsExact, $getaccess, $list, $mute, $pause, $pin, $renew, $result, $start, $startwatch, $stopwatch, $task, $tasks, $unmute, $unpin, $update } from '../../consts/part-name-methods';
+import { BXRestNavvyTasksTaskAccess } from './task/access';
+import { BXRestNavvyTasksTaskChat } from './task/chat';
+import { BXRestNavvyTasksTaskCounters } from './task/counters';
+import { BXRestNavvyTasksTaskFavorite } from './task/favorite';
+import { BXRestNavvyTasksTaskField } from './task/field';
+import { BXRestNavvyTasksTaskFiles } from './task/files';
+import { BXRestNavvyTasksTaskHistory } from './task/history';
+import { BXRestNavvyTasksTaskFile } from './task/file';
+export class BXRestNavvyTasksTask {
+    constructor() {
+        this.url = {
+            /**
+             * Создает задачу
+             */
+            add: [$tasks, $task, $add],
+            /**
+             * Позволяет принять задачу
+             */
+            approve: [$tasks, $task, $approve],
+            /**
+             * Переводит задачу в статус «завершена»
+             */
+            complete: [$tasks, $task, $complete],
+            // counters: {
+            //   /**
+            //    * Получает счетчики пользователя
+            //    */
+            //   get: [$tasks, $task, $counters, $get],
+            // },
+            /**
+             * Переводит задачу в статус «отложена»
+             */
+            defer: [$tasks, $task, $defer],
+            /**
+             * Метод для делегирования задачи
+             */
+            delegate: [$tasks, $task, $delegate],
+            /**
+             * Возвращает информацию о конкретной задаче
+             */
+            get: [$tasks, $task, $get],
+            // /**
+            //  * Удаляет задачу
+            //  */
+            // 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],
+            // },
+            /**
+             * Возвращает все доступные поля
+             */
+            getFields: [$tasks, $task, $getFieldsExact],
+            /**
+             * Метод для проверки доступа к задаче
+             */
+            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],
+            }
+        };
+        /**
+         * Результаты задачи (`tasks.task.result.*`).
+         */
+        this.result = new BXRestNavvyTasksTaskResult();
+        /**
+         * Права доступа к задаче (`tasks.task.access.*`).
+         */
+        this.access = new BXRestNavvyTasksTaskAccess();
+        /**
+         * Чат задачи (`tasks.task.chat.*`).
+         */
+        this.chat = new BXRestNavvyTasksTaskChat();
+        /**
+         * Счётчики задач (`tasks.task.counters.*`).
+         */
+        this.counters = new BXRestNavvyTasksTaskCounters();
+        /**
+         * Избранные задачи (`tasks.task.favorite.*`).
+         */
+        this.favorite = new BXRestNavvyTasksTaskFavorite();
+        /**
+         * Поля задачи (`tasks.task.field.*`).
+         */
+        this.field = new BXRestNavvyTasksTaskField();
+        /**
+         * Файлы задачи, REST 3.0 (`tasks.task.file.*`).
+         */
+        this.file = new BXRestNavvyTasksTaskFile();
+        /**
+         * Файлы задачи (`tasks.task.files.*`).
+         */
+        this.files = new BXRestNavvyTasksTaskFiles();
+        /**
+         * История задачи (`tasks.task.history.*`).
+         */
+        this.history = new BXRestNavvyTasksTaskHistory();
+        this.Navvy = new Navvy();
+    }
+    add(param) {
+        return this.Navvy.simple(this.url.add, param, BXRestMapTasksTask.add);
+    }
+    // TODO: переписать нормально
+    /**
+     * Принимает задачу.
+     */
+    approve(param) {
+        return this.Navvy.simple(this.url.approve, param);
+    }
+    /**
+     * Переводит задачу в статус «завершена».
+     */
+    complete(param) {
+        return this.Navvy.simple(this.url.complete, param);
+    }
+    /**
+     * Переводит задачу в статус «отложена».
+     */
+    defer(param) {
+        return this.Navvy.simple(this.url.defer, param);
+    }
+    update(task, updateFields) {
+        let sendTask = {};
+        let taskTS = task;
+        if (updateFields.length) {
+            for (let updateField of updateFields) {
+                const key = String(updateField);
+                if (taskTS[camelCase(key)]) {
+                    // @ts-expect-error Custom field keys are selected dynamically.
+                    sendTask[key] = taskTS[camelCase(key)];
+                }
+            }
+            if (Object.values(sendTask).length && task && task.id) {
+                return this.Navvy.simple(this.url.update, { taskId: task.id, fields: sendTask });
+            }
+        }
+        throw new Error('updateFields empty');
+    }
+    get(param) {
+        return this.Navvy.simple(this.url.get, param, (BXRestMapTasksTask.get));
+    }
+    // Возможно можно обойтись без "S extends iBXRestTaskFieldsName[]",
+    // надо что бы понять то как генерировать интейфейс на лету исходя их входящих данных
+    list(param = {}) {
+        return this.Navvy.pagNavTasks(this.url.list, param, (BXRestMapTasksTask.list));
+    }
+    /*
+    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.Navvy.simple(this.url.getFields);
+    }
+    /**
+     * Проверяет доступ к задаче.
+     */
+    getAccess(param) {
+        return this.Navvy.simple(this.url.getAccess, param, BXRestMapTasksTask.getAccess);
+    }
+    /**
+     * Удаляет задачу.
+     */
+    delete(param) {
+        return this.Navvy.simple([$tasks, $task, $delete], param);
+    }
+    /**
+     * Отклоняет задачу.
+     */
+    disapprove(param) {
+        return this.Navvy.simple([$tasks, $task, $disapprove], param);
+    }
+    /**
+     * Включает режим «Без звука» для задачи.
+     */
+    mute(param) {
+        return this.Navvy.simple([$tasks, $task, $mute], param);
+    }
+    /**
+     * Останавливает выполнение задачи и переводит в статус «ждёт».
+     */
+    pause(param) {
+        return this.Navvy.simple([$tasks, $task, $pause], param);
+    }
+    /**
+     * Закрепляет задачу в списке.
+     */
+    pin(param) {
+        return this.Navvy.simple([$tasks, $task, $pin], param);
+    }
+    /**
+     * Возобновляет задачу после завершения.
+     */
+    renew(param) {
+        return this.Navvy.simple([$tasks, $task, $renew], param);
+    }
+    /**
+     * Переводит задачу в статус «выполняется».
+     */
+    start(param) {
+        return this.Navvy.simple([$tasks, $task, $start], param);
+    }
+    /**
+     * Включает наблюдение за задачей.
+     */
+    startWatch(param) {
+        return this.Navvy.simple([$tasks, $task, $startwatch], param);
+    }
+    /**
+     * Отключает наблюдение за задачей.
+     */
+    stopWatch(param) {
+        return this.Navvy.simple([$tasks, $task, $stopwatch], param);
+    }
+    /**
+     * Выключает режим «Без звука» для задачи.
+     */
+    unmute(param) {
+        return this.Navvy.simple([$tasks, $task, $unmute], param);
+    }
+    /**
+     * Открепляет задачу в списке.
+     */
+    unpin(param) {
+        return this.Navvy.simple([$tasks, $task, $unpin], param);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task.js","sourceRoot":"","sources":["../../../../../projects/bx-rest/src/request-navvy/tasks/task.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  iBXRestParamTaskAdd,\r\n  iBXRestParamTasksList,\r\n  iBXRestTaskFieldsName,\r\n  iBXRestTasksTaskBaseAnswer,\r\n  iBXRestTask, iBXRestTasksTaskGetFields, iBXRestTasksTaskDeferHttp,\r\n  iBXRestParamTasksTaskGet, iBXRestTasksTaskGet, iBXRestTasksTaskGetHttp, iBXRestTasksTaskGetHttpDefault,\r\n  iBXRestParamTasksTaskUpdateFields,\r\n  iBXRestTasksTaskFieldsCanUpdate,\r\n  iBXRestParamTasksTaskApprove,\r\n  iBXRestTasksTaskApproveHttp,\r\n  iBXRestParamTasksTaskComplete,\r\n  iBXRestTasksTaskCompleteHttp,\r\n  iBXRestParamTasksTaskDefer,\r\n  iBXRestParamTasksTaskId,\r\n  iBXRestTasksObject\r\n} from '../../typification/rest/tasks'\r\nimport { Navvy } from '../../services/navvy'\r\nimport { BXRestMapTasksTask } from '../../map/tasks/task'\r\nimport { BXRestNavvyTasksTaskResult } from './task/result'\r\nimport camelCase from 'just-camel-case'\r\nimport {\r\n  iBXRestParamTaskGetAccess,\r\n  iBXRestTaskGetAccess,\r\n  iBXRestTaskGetAccessItem\r\n} from '../../typification/rest/task'\r\nimport { ToUpperCaseKeys } from '../../typification/base/upper-case-keys'\r\nimport { ObjectToSnake } from 'ts-case-convert/lib/caseConvert'\r\nimport { AllKeyFree } from '../../typification/base/all-key-free'\r\nimport { $add, $addFromComment, $approve, $complete, $defer, $delegate, $delete, $deleteFromComment, $disapprove, $get, $getFieldsExact, $getaccess, $list, $mute, $pause, $pin, $renew, $result, $start, $startwatch, $stopwatch, $task, $tasks, $unmute, $unpin, $update } from '../../consts/part-name-methods'\r\nimport { BXRestNavvyTasksTaskAccess } from './task/access'\r\nimport { BXRestNavvyTasksTaskChat } from './task/chat'\r\nimport { BXRestNavvyTasksTaskCounters } from './task/counters'\r\nimport { BXRestNavvyTasksTaskFavorite } from './task/favorite'\r\nimport { BXRestNavvyTasksTaskField } from './task/field'\r\nimport { BXRestNavvyTasksTaskFiles } from './task/files'\r\nimport { BXRestNavvyTasksTaskHistory } from './task/history'\r\nimport { BXRestNavvyTasksTaskFile } from './task/file'\r\n\r\nexport class BXRestNavvyTasksTask {\r\n\r\n  url = {\r\n    /**\r\n     * Создает задачу\r\n     */\r\n    add: [$tasks, $task, $add],\r\n    /**\r\n     * Позволяет принять задачу\r\n     */\r\n    approve: [$tasks, $task, $approve],\r\n    /**\r\n     * Переводит задачу в статус «завершена»\r\n     */\r\n    complete: [$tasks, $task, $complete],\r\n    // counters: {\r\n    //   /**\r\n    //    * Получает счетчики пользователя\r\n    //    */\r\n    //   get: [$tasks, $task, $counters, $get],\r\n    // },\r\n    /**\r\n     * Переводит задачу в статус «отложена»\r\n     */\r\n    defer: [$tasks, $task, $defer],\r\n    /**\r\n     * Метод для делегирования задачи\r\n     */\r\n    delegate: [$tasks, $task, $delegate],\r\n    /**\r\n     * Возвращает информацию о конкретной задаче\r\n     */\r\n    get: [$tasks, $task, $get],\r\n    // /**\r\n    //  * Удаляет задачу\r\n    //  */\r\n    // delete: [$tasks, $task, $delete],\r\n    // /**\r\n    //  * Позволяет отклонить задачу\r\n    //  */\r\n    // disapprove: [$tasks, $task, $disapprove],\r\n    // favorite: {\r\n    //   /**\r\n    //    * Добавляет задачи в \"Избранное\"\r\n    //    */\r\n    //   add: [$tasks, $task, $favorite, $add],\r\n    //   /**\r\n    //    * Удаляет задачи из \"Избранного\"\r\n    //    */\r\n    //   delete: [$tasks, $task, $favorite, $delete],\r\n    // },\r\n    // files: {\r\n    //   /**\r\n    //    * Прикрепляет загруженный на диск файл к задаче\r\n    //    */\r\n    //   attach: [$tasks, $task, $files, $attach],\r\n    // },\r\n    /**\r\n     * Возвращает все доступные поля\r\n     */\r\n    getFields: [$tasks, $task, $getFieldsExact],\r\n    /**\r\n     * Метод для проверки доступа к задаче\r\n     */\r\n    getAccess: [$tasks, $task, $getaccess],\r\n    // history: {\r\n    //   /**\r\n    //    * Получает историю задачи\r\n    //    */\r\n    //   list: [$tasks, $task, $history, $list],\r\n    // },\r\n    /**\r\n     * Возвращает массив задач, каждая из которых содержит массив полей\r\n     */\r\n    list: [$tasks, $task, $list],\r\n    // /**\r\n    //  * Останавливает выполнение задачи, переводя ее в статус \"ждет выполнения\"\r\n    //  */\r\n    // pause: [$tasks, $task, $pause],\r\n    // /**\r\n    //  * Возобновляет задачу после ее завершения\r\n    //  */\r\n    // renew: [$tasks, $task, $renew],\r\n    // /**\r\n    //  * Переводит задачу в статус «выполняется»\r\n    //  */\r\n    // start: [$tasks, $task, $start],\r\n    // /**\r\n    //  * Позволяет наблюдать за задачей\r\n    //  */\r\n    // startWatch: [$tasks, $task, 'startwatch'],\r\n    // /**\r\n    //  * Останавливает наблюдение за задачей\r\n    //  */\r\n    // stopwatch: [$tasks, $task, 'stopwatch'],\r\n    /**\r\n     * Обновляет задачу\r\n     */\r\n    update: [$tasks, $task, $update],\r\n    result: {\r\n      /**\r\n       *  Просмотр списка результатов к задаче\r\n       */\r\n      list: [$tasks, $task, $result, $list],\r\n      /**\r\n       * Создание результата задачи из комментария\r\n       */\r\n      addFromComment: [$tasks, $task, $result, $addFromComment],\r\n      /**\r\n       * Удаление результата задачи по комментарию из которого он был создан\r\n       */\r\n      deleteFromComment: [$tasks, $task, $result, $deleteFromComment],\r\n    }\r\n  }\r\n\r\n  /**\n   * Результаты задачи (`tasks.task.result.*`).\n   */\n  public readonly result = new BXRestNavvyTasksTaskResult()\r\n  /**\n   * Права доступа к задаче (`tasks.task.access.*`).\n   */\n  public readonly access = new BXRestNavvyTasksTaskAccess()\r\n  /**\n   * Чат задачи (`tasks.task.chat.*`).\n   */\n  public readonly chat = new BXRestNavvyTasksTaskChat()\r\n  /**\n   * Счётчики задач (`tasks.task.counters.*`).\n   */\n  public readonly counters = new BXRestNavvyTasksTaskCounters()\r\n  /**\n   * Избранные задачи (`tasks.task.favorite.*`).\n   */\n  public readonly favorite = new BXRestNavvyTasksTaskFavorite()\r\n  /**\n   * Поля задачи (`tasks.task.field.*`).\n   */\n  public readonly field = new BXRestNavvyTasksTaskField()\r\n  /**\n   * Файлы задачи, REST 3.0 (`tasks.task.file.*`).\n   */\n  public readonly file = new BXRestNavvyTasksTaskFile()\r\n  /**\n   * Файлы задачи (`tasks.task.files.*`).\n   */\n  public readonly files = new BXRestNavvyTasksTaskFiles()\r\n  /**\n   * История задачи (`tasks.task.history.*`).\n   */\n  public readonly history = new BXRestNavvyTasksTaskHistory()\r\n\r\n  private readonly Navvy = new Navvy()\r\n\r\n  add<CustomFields extends object = object>(param: iBXRestParamTaskAdd<CustomFields>) {\r\n    return this.Navvy.simple<\r\n      iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskGetHttpDefault>,\r\n      iBXRestTask,\r\n      iBXRestParamTaskAdd<CustomFields>\r\n    >(\r\n      this.url.add,\r\n      param,\r\n      BXRestMapTasksTask.add\r\n    )\r\n  }\r\n\r\n  // TODO: переписать нормально\r\n  /**\n   * Принимает задачу.\n   */\n  approve(param: iBXRestParamTasksTaskApprove) {\r\n    return this.Navvy.simple<\r\n      iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskApproveHttp>,\r\n      iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskApproveHttp>,\r\n      iBXRestParamTasksTaskApprove\r\n    >(this.url.approve, param)\r\n  }\r\n\r\n  /**\n   * Переводит задачу в статус «завершена».\n   */\n  complete(param: iBXRestParamTasksTaskComplete) {\r\n    return this.Navvy.simple<\r\n      iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskCompleteHttp>,\r\n      iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskCompleteHttp>,\r\n      iBXRestParamTasksTaskComplete\r\n    >(this.url.complete, param)\r\n  }\r\n\r\n  /**\n   * Переводит задачу в статус «отложена».\n   */\n  defer(param: iBXRestParamTasksTaskDefer) {\r\n    return this.Navvy.simple<\r\n      iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskDeferHttp>,\r\n      iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskDeferHttp>,\r\n      iBXRestParamTasksTaskDefer\r\n    >(this.url.defer, param)\r\n  }\r\n\r\n  update<CustomFields extends object>(\r\n    task: AllKeyFree<iBXRestTasksTaskGet<iBXRestTaskFieldsName[], CustomFields>>,\r\n    updateFields: (iBXRestTasksTaskFieldsCanUpdate | keyof ToUpperCaseKeys<ObjectToSnake<CustomFields>>)[]\r\n  ) {\r\n\r\n    let sendTask: iBXRestParamTasksTaskUpdateFields & AllKeyFree<CustomFields> = {}\r\n    let taskTS: Record<string, any> = task\r\n    if (updateFields.length) {\r\n      for (let updateField of updateFields) {\r\n        const key = String(updateField)\r\n        if (taskTS[camelCase(key)]) {\r\n          // @ts-expect-error Custom field keys are selected dynamically.\r\n          sendTask[key] = taskTS[camelCase(key)]\r\n        }\r\n      }\r\n      if (Object.values(sendTask).length && task && task.id) {\r\n        return this.Navvy.simple<\r\n          iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskDeferHttp>,\r\n          iBXRestTasksTaskBaseAnswer<iBXRestTasksTaskDeferHttp>,\r\n          any\r\n        >(this.url.update, {taskId: task.id, fields: sendTask})\r\n      }\r\n    }\r\n\r\n    throw new Error('updateFields empty')\r\n  }\r\n\r\n  get<S extends iBXRestTaskFieldsName[], CustomFields extends object = object>(param: iBXRestParamTasksTaskGet<CustomFields>) {\r\n    return this.Navvy.simple<\r\n      iBXRestTasksTaskGetHttp<S, CustomFields>,\r\n      iBXRestTasksTaskGet<S, CustomFields>,\r\n      iBXRestParamTasksTaskGet<CustomFields>\r\n    >(\r\n      this.url.get,\r\n      param,\r\n      BXRestMapTasksTask.get<S, CustomFields>\r\n    )\r\n  }\r\n\r\n  // Возможно можно обойтись без \"S extends iBXRestTaskFieldsName[]\",\r\n  // надо что бы понять то как генерировать интейфейс на лету исходя их входящих данных\r\n  list<S extends iBXRestTaskFieldsName[], CustomFields extends object = object>(\r\n    param: iBXRestParamTasksList<CustomFields> = {}\r\n  ) {\r\n    return this.Navvy.pagNavTasks(\r\n      this.url.list,\r\n      param,\r\n      BXRestMapTasksTask.list<S, CustomFields>\r\n    )\r\n  }\r\n\r\n  /*\r\n  listArray(requestArray: RequestApiTaskListBX = {}) {\r\n    return this.list(requestArray).pipe(\r\n      map(v => this.http.mapResult(v)),\r\n      map(v => (v && v.tasks) ? v.tasks : [])\r\n    )\r\n  }\r\n\r\n  listAll(requestArray: RequestApiTaskListBX = {}, cache = false): Observable<TaskBX[]> {\r\n    if (!requestArray.select) {\r\n      requestArray.select = this.def.select\r\n      if (cache) {\r\n        return this.storeTask$.pipe(\r\n          take(1),\r\n          mergeMap(tasks => {\r\n            if (tasks && tasks.data.http.list && requestArray.filter && requestArray.filter.ID) {\r\n              const ids = (typeof requestArray.filter.ID === 'number') ? [requestArray.filter.ID] : requestArray.filter.ID\r\n              let filter = tasks.data.http.list.filter(i => (i.id) ? ids.includes(i.id) : false)\r\n              if (filter.length === ids.length) {\r\n                return of(filter)\r\n              }\r\n            }\r\n            return this.getEndListArray(requestArray)\r\n          })\r\n        )\r\n      }\r\n      return this.getEndListArray(requestArray)\r\n    }\r\n    return this.getEndListArray(requestArray)\r\n  }\r\n\r\n  getEndListArray(requestArray: RequestApiTaskListBX): Observable<TaskBX[]> {\r\n    return this.list(requestArray).pipe(\r\n      mergeMap((items: AnswerApiTaskBX | undefined): ObservableInput<any> | Observable<AnswerApiTaskBX[]> => {\r\n        if (items && items.result && typeof items.result.tasks === 'object') {\r\n          const items$ = of(items.result.tasks)\r\n          if (items.next) {\r\n            this.nowLoad$.next({\r\n              total: (items.total) ? items.total : 0,\r\n              next: items.next\r\n            })\r\n            requestArray.start = items.next\r\n            return this.getEndListArray(requestArray).pipe(\r\n              map(vEnd => {\r\n                if (vEnd && items.result.tasks) {\r\n                  return [...items.result.tasks, ...vEnd]\r\n                }\r\n                return (items.result.tasks) ? items.result.tasks : []\r\n              }))\r\n          }\r\n          this.nowLoad$.next({\r\n            total: 0,\r\n            next: 0\r\n          })\r\n          return items$\r\n        } else {\r\n          return of([])\r\n        }\r\n      })\r\n    )\r\n  }\r\n  */\r\n\r\n  /**\n   * Возвращает список полей задачи.\n   */\n  getFields() {\r\n    return this.Navvy.simple<iBXRestTasksTaskGetFields>(\r\n      this.url.getFields\r\n    )\r\n  }\r\n\r\n  /**\n   * Проверяет доступ к задаче.\n   */\n  getAccess(param: iBXRestParamTaskGetAccess) {\r\n    return this.Navvy.simple<iBXRestTaskGetAccess, Record<number, iBXRestTaskGetAccessItem>, iBXRestParamTaskGetAccess>(\r\n      this.url.getAccess,\r\n      param,\r\n      BXRestMapTasksTask.getAccess\r\n    )\r\n  }\r\n\r\n  /**\n   * Удаляет задачу.\n   */\n  delete(param: iBXRestParamTasksTaskId) {\r\n    return this.Navvy.simple<\r\n      iBXRestTasksObject,\r\n      iBXRestTasksObject,\r\n      iBXRestParamTasksTaskId\r\n    >([$tasks, $task, $delete], param)\r\n  }\r\n\r\n  /**\n   * Отклоняет задачу.\n   */\n  disapprove(param: iBXRestParamTasksTaskId) {\r\n    return this.Navvy.simple<\r\n      iBXRestTasksObject,\r\n      iBXRestTasksObject,\r\n      iBXRestParamTasksTaskId\r\n    >([$tasks, $task, $disapprove], param)\r\n  }\r\n\r\n  /**\n   * Включает режим «Без звука» для задачи.\n   */\n  mute(param: iBXRestParamTasksTaskId) {\r\n    return this.Navvy.simple<\r\n      iBXRestTasksObject,\r\n      iBXRestTasksObject,\r\n      iBXRestParamTasksTaskId\r\n    >([$tasks, $task, $mute], param)\r\n  }\r\n\r\n  /**\n   * Останавливает выполнение задачи и переводит в статус «ждёт».\n   */\n  pause(param: iBXRestParamTasksTaskId) {\r\n    return this.Navvy.simple<\r\n      iBXRestTasksObject,\r\n      iBXRestTasksObject,\r\n      iBXRestParamTasksTaskId\r\n    >([$tasks, $task, $pause], param)\r\n  }\r\n\r\n  /**\n   * Закрепляет задачу в списке.\n   */\n  pin(param: iBXRestParamTasksTaskId) {\r\n    return this.Navvy.simple<\r\n      iBXRestTasksObject,\r\n      iBXRestTasksObject,\r\n      iBXRestParamTasksTaskId\r\n    >([$tasks, $task, $pin], param)\r\n  }\r\n\r\n  /**\n   * Возобновляет задачу после завершения.\n   */\n  renew(param: iBXRestParamTasksTaskId) {\r\n    return this.Navvy.simple<\r\n      iBXRestTasksObject,\r\n      iBXRestTasksObject,\r\n      iBXRestParamTasksTaskId\r\n    >([$tasks, $task, $renew], param)\r\n  }\r\n\r\n  /**\n   * Переводит задачу в статус «выполняется».\n   */\n  start(param: iBXRestParamTasksTaskId) {\r\n    return this.Navvy.simple<\r\n      iBXRestTasksObject,\r\n      iBXRestTasksObject,\r\n      iBXRestParamTasksTaskId\r\n    >([$tasks, $task, $start], param)\r\n  }\r\n\r\n  /**\n   * Включает наблюдение за задачей.\n   */\n  startWatch(param: iBXRestParamTasksTaskId) {\r\n    return this.Navvy.simple<\r\n      iBXRestTasksObject,\r\n      iBXRestTasksObject,\r\n      iBXRestParamTasksTaskId\r\n    >([$tasks, $task, $startwatch], param)\r\n  }\r\n\r\n  /**\n   * Отключает наблюдение за задачей.\n   */\n  stopWatch(param: iBXRestParamTasksTaskId) {\r\n    return this.Navvy.simple<\r\n      iBXRestTasksObject,\r\n      iBXRestTasksObject,\r\n      iBXRestParamTasksTaskId\r\n    >([$tasks, $task, $stopwatch], param)\r\n  }\r\n\r\n  /**\n   * Выключает режим «Без звука» для задачи.\n   */\n  unmute(param: iBXRestParamTasksTaskId) {\r\n    return this.Navvy.simple<\r\n      iBXRestTasksObject,\r\n      iBXRestTasksObject,\r\n      iBXRestParamTasksTaskId\r\n    >([$tasks, $task, $unmute], param)\r\n  }\r\n\r\n  /**\n   * Открепляет задачу в списке.\n   */\n  unpin(param: iBXRestParamTasksTaskId) {\r\n    return this.Navvy.simple<\r\n      iBXRestTasksObject,\r\n      iBXRestTasksObject,\r\n      iBXRestParamTasksTaskId\r\n    >([$tasks, $task, $unpin], param)\r\n  }\r\n\r\n}\r\n"]}

package/esm2022/request-navvy/tasks/template/checklist.mjs

@@ -0,0 +1,80 @@
+import { Navvy } from '../../../services/navvy';
+import { $add, $addAttachmentByContent, $addAttachmentsFromDisk, $checklist, $complete, $delete, $get, $list, $moveAfter, $moveBefore, $removeAttachments, $renew, $tasks, $template, $update } from '../../../consts/part-name-methods';
+export class BXRestNavvyTasksTemplateChecklist {
+    constructor() {
+        this.Navvy = new Navvy();
+    }
+    /**
+     * Добавляет пункт чек-листа шаблона задачи.
+     */
+    add(param) {
+        return this.Navvy.simple([$tasks, $template, $checklist, $add], param);
+    }
+    /**
+     * Добавляет вложение из содержимого к пункту чек-листа.
+     */
+    addAttachmentByContent(param) {
+        return this.Navvy.simple([$tasks, $template, $checklist, $addAttachmentByContent], param);
+    }
+    /**
+     * Добавляет вложения с Диска к пункту чек-листа.
+     */
+    addAttachmentsFromDisk(param) {
+        return this.Navvy.simple([$tasks, $template, $checklist, $addAttachmentsFromDisk], param);
+    }
+    /**
+     * Отмечает пункт чек-листа как выполненный.
+     */
+    complete(param) {
+        return this.Navvy.simple([$tasks, $template, $checklist, $complete], param);
+    }
+    /**
+     * Удаляет пункт чек-листа.
+     */
+    delete(param) {
+        return this.Navvy.simple([$tasks, $template, $checklist, $delete], param);
+    }
+    /**
+     * Возвращает пункт чек-листа по идентификатору.
+     */
+    get(param) {
+        return this.Navvy.simple([$tasks, $template, $checklist, $get], param);
+    }
+    /**
+     * Возвращает список пунктов чек-листа.
+     */
+    list(param) {
+        return this.Navvy.simple([$tasks, $template, $checklist, $list], param);
+    }
+    /**
+     * Перемещает пункт чек-листа после указанного.
+     */
+    moveAfter(param) {
+        return this.Navvy.simple([$tasks, $template, $checklist, $moveAfter], param);
+    }
+    /**
+     * Перемещает пункт чек-листа перед указанным.
+     */
+    moveBefore(param) {
+        return this.Navvy.simple([$tasks, $template, $checklist, $moveBefore], param);
+    }
+    /**
+     * Удаляет вложения пункта чек-листа.
+     */
+    removeAttachments(param) {
+        return this.Navvy.simple([$tasks, $template, $checklist, $removeAttachments], param);
+    }
+    /**
+     * Возвращает пункт чек-листа в невыполненное состояние.
+     */
+    renew(param) {
+        return this.Navvy.simple([$tasks, $template, $checklist, $renew], param);
+    }
+    /**
+     * Обновляет пункт чек-листа.
+     */
+    update(param) {
+        return this.Navvy.simple([$tasks, $template, $checklist, $update], param);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checklist.js","sourceRoot":"","sources":["../../../../../../projects/bx-rest/src/request-navvy/tasks/template/checklist.ts"],"names":[],"mappings":"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","sourcesContent":["import { Navvy } from '../../../services/navvy'\nimport { iBXRestTasksObject, iBXRestTasksParams } from '../../../typification/rest/tasks'\nimport { $add, $addAttachmentByContent, $addAttachmentsFromDisk, $checklist, $complete, $delete, $get, $list, $moveAfter, $moveBefore, $removeAttachments, $renew, $tasks, $template, $update } from '../../../consts/part-name-methods'\n\nexport class BXRestNavvyTasksTemplateChecklist {\n  private readonly Navvy = new Navvy()\n\n  /**\n   * Добавляет пункт чек-листа шаблона задачи.\n   */\n  add(param: iBXRestTasksParams) {\n    return this.Navvy.simple<iBXRestTasksObject, iBXRestTasksObject, iBXRestTasksParams>([$tasks, $template, $checklist, $add], param)\n  }\n\n  /**\n   * Добавляет вложение из содержимого к пункту чек-листа.\n   */\n  addAttachmentByContent(param: iBXRestTasksParams) {\n    return this.Navvy.simple<iBXRestTasksObject, iBXRestTasksObject, iBXRestTasksParams>([$tasks, $template, $checklist, $addAttachmentByContent], param)\n  }\n\n  /**\n   * Добавляет вложения с Диска к пункту чек-листа.\n   */\n  addAttachmentsFromDisk(param: iBXRestTasksParams) {\n    return this.Navvy.simple<iBXRestTasksObject, iBXRestTasksObject, iBXRestTasksParams>([$tasks, $template, $checklist, $addAttachmentsFromDisk], param)\n  }\n\n  /**\n   * Отмечает пункт чек-листа как выполненный.\n   */\n  complete(param: iBXRestTasksParams) {\n    return this.Navvy.simple<iBXRestTasksObject, iBXRestTasksObject, iBXRestTasksParams>([$tasks, $template, $checklist, $complete], param)\n  }\n\n  /**\n   * Удаляет пункт чек-листа.\n   */\n  delete(param: iBXRestTasksParams) {\n    return this.Navvy.simple<iBXRestTasksObject, iBXRestTasksObject, iBXRestTasksParams>([$tasks, $template, $checklist, $delete], param)\n  }\n\n  /**\n   * Возвращает пункт чек-листа по идентификатору.\n   */\n  get(param: iBXRestTasksParams) {\n    return this.Navvy.simple<iBXRestTasksObject, iBXRestTasksObject, iBXRestTasksParams>([$tasks, $template, $checklist, $get], param)\n  }\n\n  /**\n   * Возвращает список пунктов чек-листа.\n   */\n  list(param: iBXRestTasksParams) {\n    return this.Navvy.simple<iBXRestTasksObject, iBXRestTasksObject, iBXRestTasksParams>([$tasks, $template, $checklist, $list], param)\n  }\n\n  /**\n   * Перемещает пункт чек-листа после указанного.\n   */\n  moveAfter(param: iBXRestTasksParams) {\n    return this.Navvy.simple<iBXRestTasksObject, iBXRestTasksObject, iBXRestTasksParams>([$tasks, $template, $checklist, $moveAfter], param)\n  }\n\n  /**\n   * Перемещает пункт чек-листа перед указанным.\n   */\n  moveBefore(param: iBXRestTasksParams) {\n    return this.Navvy.simple<iBXRestTasksObject, iBXRestTasksObject, iBXRestTasksParams>([$tasks, $template, $checklist, $moveBefore], param)\n  }\n\n  /**\n   * Удаляет вложения пункта чек-листа.\n   */\n  removeAttachments(param: iBXRestTasksParams) {\n    return this.Navvy.simple<iBXRestTasksObject, iBXRestTasksObject, iBXRestTasksParams>([$tasks, $template, $checklist, $removeAttachments], param)\n  }\n\n  /**\n   * Возвращает пункт чек-листа в невыполненное состояние.\n   */\n  renew(param: iBXRestTasksParams) {\n    return this.Navvy.simple<iBXRestTasksObject, iBXRestTasksObject, iBXRestTasksParams>([$tasks, $template, $checklist, $renew], param)\n  }\n\n  /**\n   * Обновляет пункт чек-листа.\n   */\n  update(param: iBXRestTasksParams) {\n    return this.Navvy.simple<iBXRestTasksObject, iBXRestTasksObject, iBXRestTasksParams>([$tasks, $template, $checklist, $update], param)\n  }\n}\n\n"]}

package/esm2022/request-navvy/tasks/template.mjs

@@ -0,0 +1,43 @@
+import { Navvy } from '../../services/navvy';
+import { $add, $delete, $fields, $get, $tasks, $template, $update } from '../../consts/part-name-methods';
+import { BXRestNavvyTasksTemplateChecklist } from './template/checklist';
+export class BXRestNavvyTasksTemplate {
+    constructor() {
+        this.Navvy = new Navvy();
+        /**
+         * Чек-листы шаблона задачи (`tasks.template.checklist.*`).
+         */
+        this.checklist = new BXRestNavvyTasksTemplateChecklist();
+    }
+    /**
+     * Добавляет шаблон задачи.
+     */
+    add(param) {
+        return this.Navvy.simple([$tasks, $template, $add], param);
+    }
+    /**
+     * Удаляет шаблон задачи.
+     */
+    delete(param) {
+        return this.Navvy.simple([$tasks, $template, $delete], param);
+    }
+    /**
+     * Возвращает описание полей шаблона задачи.
+     */
+    fields() {
+        return this.Navvy.simple([$tasks, $template, $fields]);
+    }
+    /**
+     * Возвращает шаблон задачи по идентификатору.
+     */
+    get(param) {
+        return this.Navvy.simple([$tasks, $template, $get], param);
+    }
+    /**
+     * Изменяет шаблон задачи.
+     */
+    update(param) {
+        return this.Navvy.simple([$tasks, $template, $update], param);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/request-navvy/tasks.mjs

@@ -0,0 +1,19 @@
+import { BXRestNavvyTasksTask } from './tasks/task';
+import { BXRestNavvyTasksFlow, BXRestNavvyTasksTemplate } from './tasks/extended';
+export class BXRestNavvyTasks {
+    constructor() {
+        /**
+         * Потоки задач (`tasks.flow.*`).
+         */
+        this.flow = new BXRestNavvyTasksFlow();
+        /**
+         * Задачи (`tasks.task.*`).
+         */
+        this.task = new BXRestNavvyTasksTask();
+        /**
+         * Шаблоны задач (`tasks.template.*`).
+         */
+        this.template = new BXRestNavvyTasksTemplate();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFza3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9ieC1yZXN0L3NyYy9yZXF1ZXN0LW5hdnZ5L3Rhc2tzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLGNBQWMsQ0FBQTtBQUNuRCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQTtBQUVqRixNQUFNLE9BQU8sZ0JBQWdCO0lBQTdCO1FBQ0U7O1dBRUc7UUFDYSxTQUFJLEdBQUcsSUFBSSxvQkFBb0IsRUFBRSxDQUFBO1FBQ2pEOztXQUVHO1FBQ2EsU0FBSSxHQUFHLElBQUksb0JBQW9CLEVBQUUsQ0FBQTtRQUNqRDs7V0FFRztRQUNhLGFBQVEsR0FBRyxJQUFJLHdCQUF3QixFQUFFLENBQUE7SUFDM0QsQ0FBQztDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQlhSZXN0TmF2dnlUYXNrc1Rhc2sgfSBmcm9tICcuL3Rhc2tzL3Rhc2snXG5pbXBvcnQgeyBCWFJlc3ROYXZ2eVRhc2tzRmxvdywgQlhSZXN0TmF2dnlUYXNrc1RlbXBsYXRlIH0gZnJvbSAnLi90YXNrcy9leHRlbmRlZCdcblxyXG5leHBvcnQgY2xhc3MgQlhSZXN0TmF2dnlUYXNrcyB7XG4gIC8qKlxuICAgKiDQn9C+0YLQvtC60Lgg0LfQsNC00LDRhyAoYHRhc2tzLmZsb3cuKmApLlxuICAgKi9cbiAgcHVibGljIHJlYWRvbmx5IGZsb3cgPSBuZXcgQlhSZXN0TmF2dnlUYXNrc0Zsb3coKVxuICAvKipcbiAgICog0JfQsNC00LDRh9C4IChgdGFza3MudGFzay4qYCkuXG4gICAqL1xuICBwdWJsaWMgcmVhZG9ubHkgdGFzayA9IG5ldyBCWFJlc3ROYXZ2eVRhc2tzVGFzaygpXG4gIC8qKlxuICAgKiDQqNCw0LHQu9C+0L3RiyDQt9Cw0LTQsNGHIChgdGFza3MudGVtcGxhdGUuKmApLlxuICAgKi9cbiAgcHVibGljIHJlYWRvbmx5IHRlbXBsYXRlID0gbmV3IEJYUmVzdE5hdnZ5VGFza3NUZW1wbGF0ZSgpXG59XG4iXX0=

package/esm2022/request-navvy/telephony/call.mjs

@@ -0,0 +1,14 @@
+import { Navvy } from '../../services/navvy';
+import { $attachTranscription, $call, $telephony } from '../../consts/part-name-methods';
+export class BXRestNavvyTelephonyCall {
+    constructor() {
+        this.Navvy = new Navvy();
+    }
+    /**
+     * Добавляет расшифровку записи к звонку.
+     */
+    attachTranscription(param) {
+        return this.Navvy.simple([$telephony, $call, $attachTranscription], param);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2J4LXJlc3Qvc3JjL3JlcXVlc3QtbmF2dnkvdGVsZXBob255L2NhbGwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLHNCQUFzQixDQUFBO0FBRTVDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sZ0NBQWdDLENBQUE7QUFFeEYsTUFBTSxPQUFPLHdCQUF3QjtJQUFyQztRQUNtQixVQUFLLEdBQUcsSUFBSSxLQUFLLEVBQUUsQ0FBQTtJQVF0QyxDQUFDO0lBTkM7O09BRUc7SUFDSCxtQkFBbUIsQ0FBQyxLQUEyQjtRQUM3QyxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUF5QyxDQUFDLFVBQVUsRUFBRSxLQUFLLEVBQUUsb0JBQW9CLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FBQTtJQUNwSCxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOYXZ2eSB9IGZyb20gJy4uLy4uL3NlcnZpY2VzL25hdnZ5J1xyXG5pbXBvcnQgeyBpQlhSZXN0R2VuZXJpY1BhcmFtcyB9IGZyb20gJy4uLy4uL3R5cGlmaWNhdGlvbi9yZXN0L2NvbW1vbidcclxuaW1wb3J0IHsgJGF0dGFjaFRyYW5zY3JpcHRpb24sICRjYWxsLCAkdGVsZXBob255IH0gZnJvbSAnLi4vLi4vY29uc3RzL3BhcnQtbmFtZS1tZXRob2RzJ1xyXG5cclxuZXhwb3J0IGNsYXNzIEJYUmVzdE5hdnZ5VGVsZXBob255Q2FsbCAge1xyXG4gIHByaXZhdGUgcmVhZG9ubHkgTmF2dnkgPSBuZXcgTmF2dnkoKVxyXG5cclxuICAvKipcbiAgICog0JTQvtCx0LDQstC70Y/QtdGCINGA0LDRgdGI0LjRhNGA0L7QstC60YMg0LfQsNC/0LjRgdC4INC6INC30LLQvtC90LrRgy5cbiAgICovXG4gIGF0dGFjaFRyYW5zY3JpcHRpb24ocGFyYW06IGlCWFJlc3RHZW5lcmljUGFyYW1zKSB7XHJcbiAgICByZXR1cm4gdGhpcy5OYXZ2eS5zaW1wbGU8Ym9vbGVhbiwgYm9vbGVhbiwgaUJYUmVzdEdlbmVyaWNQYXJhbXM+KFskdGVsZXBob255LCAkY2FsbCwgJGF0dGFjaFRyYW5zY3JpcHRpb25dLCBwYXJhbSlcclxuICB9XHJcbn1cclxuXHJcbiJdfQ==