bx-rest 0.1.9 → 0.1.11

package/fesm2015/bx-rest.mjs

@@ -1471,6 +1471,78 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                 }]
         }], ctorParameters: function () { return [{ type: BXRestListsElement }, { type: HttpBXServices }]; } });
 
+class BXRestElapseditem {
+    constructor(http) {
+        this.http = http;
+        this.url = {
+            getmanifest: [$task, $elapseditem, $getmanifest],
+            getlist: [$task, $elapseditem, $getlist],
+            get: [$task, $elapseditem, $get],
+            add: [$task, $elapseditem, $add],
+            delete: [$task, $elapseditem, $delete],
+            isactionallowed: [$task, $elapseditem, $isactionallowed],
+            update: [$task, $elapseditem, $update], // Изменяет параметры записи о затраченном времени
+        };
+    }
+    getList(param = undefined) {
+        return this.http.post(this.url.getlist, param);
+    }
+    add(param) {
+        return this.http.post(this.url.add, param, {
+            timeZone: {
+                calc: false,
+                levelOut: false
+            }
+        });
+    }
+    update(param) {
+        return this.http.post(this.url.update, param, {
+            timeZone: {
+                calc: false,
+                levelOut: false
+            }
+        });
+    }
+    del(param) {
+        return this.http.post(this.url.delete, param);
+    }
+    /**
+     * idAction:
+     * 1 - ACTION_ELAPSED_TIME_ADD
+     * 2 - ACTION_ELAPSED_TIME_MODIFY
+     * 3 - ACTION_ELAPSED_TIME_REMOVE
+     * ITEMID - обязателен в конечной отправке но не обязателен для ACTION_ELAPSED_TIME_ADD,
+     * поэтому этом методе можно ставить "1" например, так же метод может выдавать ошибки о не доступности задачи
+     * поэтому рекомендую воспользоваться аналогичным методом в пространстве имен navvy
+     * @param param
+     */
+    isActionAllowed(param) {
+        return this.http.post(this.url.isactionallowed, param);
+    }
+}
+BXRestElapseditem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestElapseditem, deps: [{ token: HttpBXServices }], target: i0.ɵɵFactoryTarget.Injectable });
+BXRestElapseditem.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestElapseditem, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestElapseditem, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: HttpBXServices }]; } });
+
+class BXRestTask {
+    constructor(elapseditem) {
+        this.elapseditem = elapseditem;
+    }
+}
+BXRestTask.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestTask, deps: [{ token: BXRestElapseditem }], target: i0.ɵɵFactoryTarget.Injectable });
+BXRestTask.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestTask, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestTask, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: BXRestElapseditem }]; } });
+
 // import { AnswerApiTaskBX } from '../../typification/rest/task/answers/task';
 class BXRestTasksTask {
     constructor(http) {
@@ -1551,6 +1623,129 @@ class BXRestTasksTask {
     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);
+    }
 }
 BXRestTasksTask.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestTasksTask, deps: [{ token: HttpBXServices }], target: i0.ɵɵFactoryTarget.Injectable });
 BXRestTasksTask.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestTasksTask, providedIn: 'root' });
@@ -2233,6 +2428,46 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                 }]
         }], ctorParameters: function () { return [{ type: BXRestNavvyListsElement }, { type: BXRestLists }, { type: Navvy }, { type: BXRestMapLists }]; } });
 
+class Permission {
+    static get() {
+        return SessionStorage.getItem('permission');
+    }
+    static set(param) {
+        SessionStorage.setItem('permission', Object.assign(this.get(), param));
+    }
+    static setTaskElapsedItem(idTask, ElapsedItem) {
+        let permission = Permission.get();
+        if (permission.tasks) {
+            let findTask = permission.tasks.find(i => i.id === idTask);
+            if (findTask) {
+                let findTaskElapsedItem = findTask.elapsedItem.find(i => i.id === ElapsedItem.id);
+                if (findTaskElapsedItem) {
+                    if (ElapsedItem.verified.edit) {
+                        findTaskElapsedItem.verified.edit = ElapsedItem.verified.edit;
+                        findTaskElapsedItem.edit = ElapsedItem.edit;
+                    }
+                    if (ElapsedItem.verified.del) {
+                        findTaskElapsedItem.verified.del = ElapsedItem.verified.del;
+                        findTaskElapsedItem.del = ElapsedItem.del;
+                    }
+                }
+                else {
+                    findTask.elapsedItem.push(ElapsedItem);
+                }
+            }
+            SessionStorage.setItem('permission', permission);
+        }
+    }
+}
+Permission.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: Permission, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+Permission.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: Permission, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: Permission, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
 class BXRestTaskMap extends BaseMapServices {
     add(item) {
         return this.TaskBXHttpToTaskBX(item);
@@ -2447,6 +2682,129 @@ class BXRestNavvyTasksTask {
             }
         }));
     }
+    /*
+    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() {
+      return this.http.post<iHttpAnswerBX<(string | number)[]>>(this.url.planner.getlist)
+    }
+     */
+    getaccess(param) {
+        return this.Navvy.mapAndSnackBarError(this.BXRestTasksTask.getaccess(param), 'Не удалось получить права на указанных пользователей').pipe(map(v => (v && v.allowedActions) ? v.allowedActions : undefined));
+    }
 }
 BXRestNavvyTasksTask.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyTasksTask, deps: [{ token: BXRestTasksTask }, { token: SnackBarService }, { token: BXRestTaskMap }, { token: Navvy }], target: i0.ɵɵFactoryTarget.Injectable });
 BXRestNavvyTasksTask.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyTasksTask, providedIn: 'root' });
@@ -2471,6 +2829,273 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                 }]
         }], ctorParameters: function () { return [{ type: BXRestNavvyTasksTask }]; } });
 
+class BXRestNavvyElapseditem {
+    constructor(BXRestElapseditem, BXRestNavvyUser, BXRestNavvyTasks, Navvy, snackBar) {
+        this.BXRestElapseditem = BXRestElapseditem;
+        this.BXRestNavvyUser = BXRestNavvyUser;
+        this.BXRestNavvyTasks = BXRestNavvyTasks;
+        this.Navvy = Navvy;
+        this.snackBar = snackBar;
+    }
+    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.mapAndSnackBarError(this.BXRestElapseditem.getList(param), 'не удалось получить время по задачам');
+    }
+    add(param) {
+        return this.checkPermissionReadTask(param.TASKID).pipe(mergeMap(allowedReadTask => {
+            if (allowedReadTask) {
+                return this.checkPermissionReadTask(param.TASKID).pipe(mergeMap(allowed => {
+                    if (allowed) {
+                        return this.Navvy.mapAndSnackBarError(this.BXRestElapseditem.add(param), 'Не удалось добавить запись о времени');
+                    }
+                    else {
+                        this.snackBar.error('Отсутствуют права добавление записи затраченного времени');
+                        return of(false);
+                    }
+                }));
+            }
+            else {
+                this.snackBar.error('Отсутствуют права на чтение задачи');
+                return of(false);
+            }
+        }));
+    }
+    update(param) {
+        return this.checkPermissionReadTask(param.TASKID).pipe(mergeMap(allowedReadTask => {
+            if (allowedReadTask) {
+                return this.isAllowedModify(param.TASKID, param.ITEMID).pipe(mergeMap(allowed => {
+                    if (allowed) {
+                        return this.Navvy.mapAndSnackBarError(this.BXRestElapseditem.update(param), 'Не удалось обновить запись о времени');
+                    }
+                    else {
+                        this.snackBar.error('Отсутствуют права на изменение записи затраченного времени');
+                        return of(false);
+                    }
+                }));
+            }
+            else {
+                this.snackBar.error('Отсутствуют права на чтение задачи');
+                return of(false);
+            }
+        }));
+    }
+    /*
+    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, cache = false) {
+      return this.getAll({
+          ORDER: {
+            ID: 'DESC'
+          },
+          FILTER: {
+            USER_ID: idsUsers,
+            '>=CREATED_DATE': dateStart.toLocaleString('ru-Ru'),
+            '<=CREATED_DATE': dateEnd.toLocaleString('ru-Ru'),
+          }
+        },
+        cache
+      ).pipe(
+        map(v => this.http.mapResult(v))
+      )
+    }
+     */
+    /*
+    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) {
+        var _a;
+        let permission = Permission.get();
+        if ((_a = permission === null || permission === void 0 ? void 0 : permission.tasks) === null || _a === void 0 ? void 0 : _a.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
+        }).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
+        });
+    }
+    /**
+     * idAction:
+     * 1 - ACTION_ELAPSED_TIME_ADD
+     * 2 - ACTION_ELAPSED_TIME_MODIFY
+     * 3 - ACTION_ELAPSED_TIME_REMOVE
+     * @param param
+     */
+    isActionAllowed(param) {
+        return this.checkPermissionReadTask(param.TASKID).pipe(mergeMap(canRead => {
+            if (canRead) {
+                this.Navvy.mapAndSnackBarError(this.BXRestElapseditem.isActionAllowed(param), '').pipe(catchError(v => {
+                    console.error(v);
+                    return of(false);
+                }));
+            }
+            return of(false);
+        }));
+    }
+    checkPermissionReadTask(idTask) {
+        var _a;
+        let permission = Permission.get();
+        if ((_a = permission === null || permission === void 0 ? void 0 : permission.tasks) === null || _a === void 0 ? void 0 : _a.length) {
+            let findTask = permission.tasks.find(i => i.id === idTask);
+            if (findTask === null || findTask === void 0 ? void 0 : findTask.permission) {
+                return of(findTask.permission.ACCEPT);
+            }
+            return this.BXRestNavvyUser.current().pipe(mergeMap(self => {
+                if (self) {
+                    return this.BXRestNavvyTasks.task.getaccess({
+                        id: idTask,
+                        users: [self.ID]
+                    }).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.checkPermissionReadTask(param.TASKID).pipe(mergeMap(allowedReadTask => {
+            if (allowedReadTask) {
+                return this.isAllowedRemove(param.TASKID, param.ITEMID).pipe(mergeMap(allowed => {
+                    if (allowed) {
+                        return this.Navvy.mapAndSnackBarError(this.BXRestElapseditem.del(param), 'Не удалось удалить запись')
+                            .pipe(map(v => (v === null)));
+                    }
+                    else {
+                        this.snackBar.error('Отсутствуют права на удаление записи затраченного времени');
+                        return of(false);
+                    }
+                }));
+            }
+            else {
+                this.snackBar.error('Отсутствуют права на чтение задачи');
+                return of(false);
+            }
+        }));
+    }
+}
+BXRestNavvyElapseditem.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyElapseditem, deps: [{ token: BXRestElapseditem }, { token: BXRestNavvyUser }, { token: BXRestNavvyTasks }, { token: Navvy }, { token: SnackBarService }], target: i0.ɵɵFactoryTarget.Injectable });
+BXRestNavvyElapseditem.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyElapseditem, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyElapseditem, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: BXRestElapseditem }, { type: BXRestNavvyUser }, { type: BXRestNavvyTasks }, { type: Navvy }, { type: SnackBarService }]; } });
+
+class BXRestNavvyTask {
+    constructor(elapseditem) {
+        this.elapseditem = elapseditem;
+    }
+}
+BXRestNavvyTask.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvyTask, deps: [{ token: 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: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: BXRestNavvyElapseditem }]; } });
+
 class BXRestMapDiskBase extends BaseMapServices {
     separationFoldersAndFiles(arr) {
         let result = { file: [], folder: [] };
@@ -3135,9 +3760,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
         }], ctorParameters: function () { return [{ type: BXRestSonetGroup }, { type: BXRestMapSonetGroup }, { type: Navvy }]; } });
 
 class BXRest {
-    constructor(user, lists, tasks, disk, bizproc, log, calendar, sonet_group) {
+    constructor(user, lists, task, tasks, disk, bizproc, log, calendar, sonet_group) {
         this.user = user;
         this.lists = lists;
+        this.task = task;
         this.tasks = tasks;
         this.disk = disk;
         this.bizproc = bizproc;
@@ -3146,18 +3772,19 @@ class BXRest {
         this.sonet_group = sonet_group;
     }
 }
-BXRest.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRest, deps: [{ token: BXRestUser }, { token: BXRestLists }, { token: BXRestTasks }, { token: BXRestDisk }, { token: BXRestBizproc }, { token: BXRestLog }, { token: BXRestCalendar }, { token: BXRestSonetGroup }], target: i0.ɵɵFactoryTarget.Injectable });
+BXRest.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRest, deps: [{ token: BXRestUser }, { token: BXRestLists }, { token: BXRestTask }, { token: BXRestTasks }, { token: BXRestDisk }, { token: BXRestBizproc }, { token: BXRestLog }, { token: BXRestCalendar }, { token: BXRestSonetGroup }], target: i0.ɵɵFactoryTarget.Injectable });
 BXRest.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRest, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRest, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: function () { return [{ type: BXRestUser }, { type: BXRestLists }, { type: BXRestTasks }, { type: BXRestDisk }, { type: BXRestBizproc }, { type: BXRestLog }, { type: BXRestCalendar }, { type: BXRestSonetGroup }]; } });
+        }], ctorParameters: function () { return [{ type: BXRestUser }, { type: BXRestLists }, { type: BXRestTask }, { type: BXRestTasks }, { type: BXRestDisk }, { type: BXRestBizproc }, { type: BXRestLog }, { type: BXRestCalendar }, { type: BXRestSonetGroup }]; } });
 class BXRestNavvy {
-    constructor(user, lists, tasks, disk, bizproc, log, calendar, sonet_group) {
+    constructor(user, lists, task, tasks, disk, bizproc, log, calendar, sonet_group) {
         this.user = user;
         this.lists = lists;
+        this.task = task;
         this.tasks = tasks;
         this.disk = disk;
         this.bizproc = bizproc;
@@ -3166,14 +3793,14 @@ class BXRestNavvy {
         this.sonet_group = sonet_group;
     }
 }
-BXRestNavvy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvy, deps: [{ token: BXRestNavvyUser }, { token: BXRestNavvyLists }, { token: BXRestNavvyTasks }, { token: BXRestNavvyDisk }, { token: BXRestNavvyBizproc }, { token: BXRestNavvyLog }, { token: BXRestNavvyCalendar }, { token: BXRestNavvySonetGroup }], target: i0.ɵɵFactoryTarget.Injectable });
+BXRestNavvy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvy, deps: [{ token: BXRestNavvyUser }, { token: BXRestNavvyLists }, { token: BXRestNavvyTask }, { token: BXRestNavvyTasks }, { token: BXRestNavvyDisk }, { token: BXRestNavvyBizproc }, { token: BXRestNavvyLog }, { token: BXRestNavvyCalendar }, { token: BXRestNavvySonetGroup }], target: i0.ɵɵFactoryTarget.Injectable });
 BXRestNavvy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvy, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BXRestNavvy, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: function () { return [{ type: BXRestNavvyUser }, { type: BXRestNavvyLists }, { type: BXRestNavvyTasks }, { type: BXRestNavvyDisk }, { type: BXRestNavvyBizproc }, { type: BXRestNavvyLog }, { type: BXRestNavvyCalendar }, { type: BXRestNavvySonetGroup }]; } });
+        }], ctorParameters: function () { return [{ type: BXRestNavvyUser }, { type: BXRestNavvyLists }, { type: BXRestNavvyTask }, { type: BXRestNavvyTasks }, { type: BXRestNavvyDisk }, { type: BXRestNavvyBizproc }, { type: BXRestNavvyLog }, { type: BXRestNavvyCalendar }, { type: BXRestNavvySonetGroup }]; } });
 class BXRestMap {
     constructor(lists) {
         this.lists = lists;