@netgrif/components-core 6.0.1

package/esm5/lib/view/public-api.js

@@ -0,0 +1,42 @@
+/* INTERFACES */
+export * from './case-view/models/case-view-params';
+export * from './case-view/models/case-page-load-request-result';
+export * from './case-view/models/new-case-configuration';
+export * from './task-view/models/task-view-params';
+export * from './task-view/models/injected-tabbed-task-view-data';
+export * from './task-view/models/task-page-load-request-result';
+export * from './task-view/models/task-view-configuration';
+export * from './tree-case-view/tree-component/model/case-tree-node';
+export * from './tree-case-view/tree-component/model/case-tree-path';
+export * from './tree-case-view/tree-component/model/expansion-tree';
+/* ENUMS */
+export * from './tree-case-view/model/tree-petriflow-identifiers';
+export * from './task-view/models/task-endpoint';
+/* CLASSES */
+export * from './case-view/abstract-case-view';
+export * from './case-view/tabbed-case-view';
+export * from './task-view/abstract-task-view';
+export * from './task-view/tabbed-task-view';
+export * from './abstract/view-with-headers';
+export * from './abstract/sortable-view';
+export * from './abstract/page-load-request-context';
+/* INJECTION TOKENS */
+export * from './case-view/models/new-case-configuration-injection-token';
+export * from './task-view/models/injection-token-task-endpoint';
+export * from './task-view/models/task-view-configuration-injection-token';
+export * from './workflow-view/models/injection-token-workflow-service';
+/* SERVICES */
+export * from './case-view/service/case-view-service';
+export * from './task-view/service/task-view.service';
+export * from './workflow-view/workflow-view.service';
+export * from './tree-case-view/tree-case-view.service';
+export * from './tree-case-view/tree-component/case-tree.service';
+export * from './tree-case-view/tree-task-content/tree-task-content.service';
+/* COMPONENTS */
+export * from './workflow-view/abstract-workflow-view.component';
+export * from './case-view/components/case-list/abstract-case-list.component';
+export * from './tree-case-view/tree-component/abstract-tree.component';
+export * from './tree-case-view/tree-component/add-child-node/abstract-add-child-node.component';
+export * from './tree-case-view/tree-component/remove-node/abstract-remove-node.component';
+export * from './tree-case-view/tree-task-content/abstract-tree-task-content.component';
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/view/task-view/abstract-task-view.js

@@ -0,0 +1,18 @@
+import { __extends } from "tslib";
+import { ViewWithHeaders } from '../abstract/view-with-headers';
+var AbstractTaskView = /** @class */ (function (_super) {
+    __extends(AbstractTaskView, _super);
+    function AbstractTaskView(taskViewService) {
+        var _this = _super.call(this, taskViewService) || this;
+        _this.taskViewService = taskViewService;
+        _this.tasks$ = _this.taskViewService.tasks$;
+        _this.loading$ = _this.taskViewService.loading$;
+        return _this;
+    }
+    AbstractTaskView.prototype.ngOnDestroy = function () {
+        _super.prototype.ngOnDestroy.call(this);
+    };
+    return AbstractTaskView;
+}(ViewWithHeaders));
+export { AbstractTaskView };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtdGFzay12aWV3LmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3ZpZXcvdGFzay12aWV3L2Fic3RyYWN0LXRhc2stdmlldy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBSUEsT0FBTyxFQUFDLGVBQWUsRUFBQyxNQUFNLCtCQUErQixDQUFDO0FBRzlEO0lBQStDLG9DQUFlO0lBSzFELDBCQUFnQyxlQUFnQztRQUFoRSxZQUNJLGtCQUFNLGVBQWUsQ0FBQyxTQUd6QjtRQUorQixxQkFBZSxHQUFmLGVBQWUsQ0FBaUI7UUFFNUQsS0FBSSxDQUFDLE1BQU0sR0FBRyxLQUFJLENBQUMsZUFBZSxDQUFDLE1BQU0sQ0FBQztRQUMxQyxLQUFJLENBQUMsUUFBUSxHQUFHLEtBQUksQ0FBQyxlQUFlLENBQUMsUUFBUSxDQUFDOztJQUNsRCxDQUFDO0lBRUQsc0NBQVcsR0FBWDtRQUNJLGlCQUFNLFdBQVcsV0FBRSxDQUFDO0lBQ3hCLENBQUM7SUFDTCx1QkFBQztBQUFELENBQUMsQUFkRCxDQUErQyxlQUFlLEdBYzdEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtPYnNlcnZhYmxlfSBmcm9tICdyeGpzJztcbmltcG9ydCB7T25EZXN0cm95fSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7VGFza1BhbmVsRGF0YX0gZnJvbSAnLi4vLi4vcGFuZWwvdGFzay1wYW5lbC1saXN0L3Rhc2stcGFuZWwtZGF0YS90YXNrLXBhbmVsLWRhdGEnO1xuaW1wb3J0IHtUYXNrVmlld1NlcnZpY2V9IGZyb20gJy4vc2VydmljZS90YXNrLXZpZXcuc2VydmljZSc7XG5pbXBvcnQge1ZpZXdXaXRoSGVhZGVyc30gZnJvbSAnLi4vYWJzdHJhY3Qvdmlldy13aXRoLWhlYWRlcnMnO1xuXG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBBYnN0cmFjdFRhc2tWaWV3IGV4dGVuZHMgVmlld1dpdGhIZWFkZXJzIGltcGxlbWVudHMgT25EZXN0cm95IHtcblxuICAgIHB1YmxpYyB0YXNrcyQ6IE9ic2VydmFibGU8QXJyYXk8VGFza1BhbmVsRGF0YT4+O1xuICAgIHB1YmxpYyBsb2FkaW5nJDogT2JzZXJ2YWJsZTxib29sZWFuPjtcblxuICAgIHByb3RlY3RlZCBjb25zdHJ1Y3Rvcihwcm90ZWN0ZWQgdGFza1ZpZXdTZXJ2aWNlOiBUYXNrVmlld1NlcnZpY2UpIHtcbiAgICAgICAgc3VwZXIodGFza1ZpZXdTZXJ2aWNlKTtcbiAgICAgICAgdGhpcy50YXNrcyQgPSB0aGlzLnRhc2tWaWV3U2VydmljZS50YXNrcyQ7XG4gICAgICAgIHRoaXMubG9hZGluZyQgPSB0aGlzLnRhc2tWaWV3U2VydmljZS5sb2FkaW5nJDtcbiAgICB9XG5cbiAgICBuZ09uRGVzdHJveSgpIHtcbiAgICAgICAgc3VwZXIubmdPbkRlc3Ryb3koKTtcbiAgICB9XG59XG4iXX0=

package/esm5/lib/view/task-view/models/injected-tabbed-task-view-data.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5qZWN0ZWQtdGFiYmVkLXRhc2stdmlldy1kYXRhLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3ZpZXcvdGFzay12aWV3L21vZGVscy9pbmplY3RlZC10YWJiZWQtdGFzay12aWV3LWRhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SW5qZWN0ZWRUYWJEYXRhfSBmcm9tICcuLi8uLi8uLi90YWJzL2ludGVyZmFjZXMnO1xuaW1wb3J0IHtGaWx0ZXJ9IGZyb20gJy4uLy4uLy4uL2ZpbHRlci9tb2RlbHMvZmlsdGVyJztcblxuZXhwb3J0IGludGVyZmFjZSBJbmplY3RlZFRhYmJlZFRhc2tWaWV3RGF0YSBleHRlbmRzIEluamVjdGVkVGFiRGF0YSB7XG4gICAgYmFzZUZpbHRlcjogRmlsdGVyO1xuICAgIC8qKlxuICAgICAqIElkZW50aWZpZXJzIG9mIHRoZSBhbGxvd2VkIG5ldHMuIEFsbG93ZWQgbmV0cyBoYXZlIG5vIGVmZmVjdCBvbiB0aGUgaW5uZXIgd29ya2luZyBvZiB0aGUgdGFzayB2aWV3IGF0IGxhcmdlLlxuICAgICAqIEJ1dCBzZWFyY2ggaW50ZXJmYWNlIHVzZXMgdGhlbSB0byBnZW5lcmF0ZSB0aGUgYXV0b2NvbXBsZXRlIGRhdGEuXG4gICAgICogU28gYnkgbm90IHByb3ZpZGluZyB0aGUgbmV0cywgdGFzayBzZWFyY2ggd2lsbCBiZSBzZXZlcmVseSBsaW1pdGVkLlxuICAgICAqL1xuICAgIGFsbG93ZWROZXRzPzogQXJyYXk8c3RyaW5nPjtcbiAgICBpbml0aWFsbHlPcGVuT25lVGFzaz86IGJvb2xlYW47XG59XG4iXX0=

package/esm5/lib/view/task-view/models/injection-token-task-endpoint.js

@@ -0,0 +1,6 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * @deprecated in 5.3.0 - Use {@link NAE_TASK_VIEW_CONFIGURATION} instead
+ */
+export var NAE_PREFERRED_TASK_ENDPOINT = new InjectionToken('NaePreferredTaskEndpoint');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5qZWN0aW9uLXRva2VuLXRhc2stZW5kcG9pbnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdmlldy90YXNrLXZpZXcvbW9kZWxzL2luamVjdGlvbi10b2tlbi10YXNrLWVuZHBvaW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFHN0M7O0dBRUc7QUFDSCxNQUFNLENBQUMsSUFBTSwyQkFBMkIsR0FBRyxJQUFJLGNBQWMsQ0FBZSwwQkFBMEIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3Rpb25Ub2tlbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1Rhc2tFbmRwb2ludH0gZnJvbSAnLi90YXNrLWVuZHBvaW50JztcblxuLyoqXG4gKiBAZGVwcmVjYXRlZCBpbiA1LjMuMCAtIFVzZSB7QGxpbmsgTkFFX1RBU0tfVklFV19DT05GSUdVUkFUSU9OfSBpbnN0ZWFkXG4gKi9cbmV4cG9ydCBjb25zdCBOQUVfUFJFRkVSUkVEX1RBU0tfRU5EUE9JTlQgPSBuZXcgSW5qZWN0aW9uVG9rZW48VGFza0VuZHBvaW50PignTmFlUHJlZmVycmVkVGFza0VuZHBvaW50Jyk7XG4iXX0=

package/esm5/lib/view/task-view/models/task-endpoint.js

@@ -0,0 +1,9 @@
+/**
+ * Used to determine which backend endpoint should be used to request tasks from
+ */
+export var TaskEndpoint;
+(function (TaskEndpoint) {
+    TaskEndpoint[TaskEndpoint["MONGO"] = 1] = "MONGO";
+    TaskEndpoint[TaskEndpoint["ELASTIC"] = 2] = "ELASTIC";
+})(TaskEndpoint || (TaskEndpoint = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1lbmRwb2ludC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi92aWV3L3Rhc2stdmlldy9tb2RlbHMvdGFzay1lbmRwb2ludC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBTixJQUFZLFlBR1g7QUFIRCxXQUFZLFlBQVk7SUFDcEIsaURBQVMsQ0FBQTtJQUNULHFEQUFPLENBQUE7QUFDWCxDQUFDLEVBSFcsWUFBWSxLQUFaLFlBQVksUUFHdkIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFVzZWQgdG8gZGV0ZXJtaW5lIHdoaWNoIGJhY2tlbmQgZW5kcG9pbnQgc2hvdWxkIGJlIHVzZWQgdG8gcmVxdWVzdCB0YXNrcyBmcm9tXG4gKi9cbmV4cG9ydCBlbnVtIFRhc2tFbmRwb2ludCB7XG4gICAgTU9OR08gPSAxLFxuICAgIEVMQVNUSUMsXG59XG4iXX0=

package/esm5/lib/view/task-view/models/task-page-load-request-result.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1wYWdlLWxvYWQtcmVxdWVzdC1yZXN1bHQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdmlldy90YXNrLXZpZXcvbW9kZWxzL3Rhc2stcGFnZS1sb2FkLXJlcXVlc3QtcmVzdWx0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1Rhc2tQYW5lbERhdGF9IGZyb20gJy4uLy4uLy4uL3BhbmVsL3Rhc2stcGFuZWwtbGlzdC90YXNrLXBhbmVsLWRhdGEvdGFzay1wYW5lbC1kYXRhJztcbmltcG9ydCB7UGFnZUxvYWRSZXF1ZXN0Q29udGV4dH0gZnJvbSAnLi4vLi4vYWJzdHJhY3QvcGFnZS1sb2FkLXJlcXVlc3QtY29udGV4dCc7XG5cbi8qKlxuICogSG9sZHMgdGhlIGluZm9ybWF0aW9uIHJldHVybmVkIGJ5IGEgdGFzayBwYWdlIGxvYWQgcmVxdWVzdCBhbG9uZ3NpZGUgdGhlIGNvbnRleHQgb2YgdGhlIHJlcXVlc3QuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgVGFza1BhZ2VMb2FkUmVxdWVzdFJlc3VsdCB7XG4gICAgLyoqXG4gICAgICogS2V5cyBhcmUgdGFzayBgc3RyaW5nSWRgc1xuICAgICAqL1xuICAgIHRhc2tzOiB7IFtrOiBzdHJpbmddOiBUYXNrUGFuZWxEYXRhIH07XG4gICAgcmVxdWVzdENvbnRleHQ6IFBhZ2VMb2FkUmVxdWVzdENvbnRleHQ7XG59XG4iXX0=

package/esm5/lib/view/task-view/models/task-view-configuration-injection-token.js

@@ -0,0 +1,20 @@
+import { InjectionToken } from '@angular/core';
+import { of } from 'rxjs';
+export var NAE_TASK_VIEW_CONFIGURATION = new InjectionToken('NaeTaskViewConfiguration');
+/**
+ * Convenience method that can be used as a task view configuration object factory for tabbed task views.
+ *
+ * If the injected tab data contain information that is included in the {@link TaskViewConfiguration} interface,
+ * this factory will forward this information into the provided object.
+ *
+ * @param injectedTabData
+ */
+export function tabbedTaskViewConfigurationFactory(injectedTabData) {
+    if ((injectedTabData === null || injectedTabData === void 0 ? void 0 : injectedTabData.initiallyOpenOneTask) !== undefined) {
+        return { initiallyOpenOneTask: of(injectedTabData.initiallyOpenOneTask) };
+    }
+    else {
+        return {};
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/view/task-view/models/task-view-configuration.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay12aWV3LWNvbmZpZ3VyYXRpb24uanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdmlldy90YXNrLXZpZXcvbW9kZWxzL3Rhc2stdmlldy1jb25maWd1cmF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge09ic2VydmFibGV9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHtUYXNrRW5kcG9pbnR9IGZyb20gJy4vdGFzay1lbmRwb2ludCc7XG5cbi8qKlxuICogQ29uZmlndXJhdGlvbiBvZiBiZWhhdmlvciBvZiB0YXNrIGxpc3QgbWFuYWdlZCBieSB0YXNrIHZpZXdcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBUYXNrVmlld0NvbmZpZ3VyYXRpb24ge1xuICAgIC8qKlxuICAgICAqIElmIGJvdGggdGhpcyBhbmQgdGhlIGRlcHJlY2F0ZWQge0BsaW5rIE5BRV9QUkVGRVJSRURfVEFTS19FTkRQT0lOVH0gaXMgcHJvdmlkZWQsIHRoaXMgb3B0aW9uIHRha2VzIHByZWNlZGVuY2UuXG4gICAgICovXG4gICAgcHJlZmVycmVkRW5kcG9pbnQ/OiBUYXNrRW5kcG9pbnQ7XG4gICAgLyoqXG4gICAgICogSWYgbm90IHByZXNlbnQgZGVmYXVsdHMgdG8gYG9mKHRydWUpYFxuICAgICAqL1xuICAgIGluaXRpYWxseU9wZW5PbmVUYXNrPzogT2JzZXJ2YWJsZTxib29sZWFuPjtcbiAgICAvKipcbiAgICAgKiBJZiBub3QgcHJlc2VudCBkZWZhdWx0cyB0byBgb2YodHJ1ZSlgXG4gICAgICovXG4gICAgY2xvc2VUYXNrVGFiT25Ob1Rhc2tzPzogT2JzZXJ2YWJsZTxib29sZWFuPjtcbn1cbiJdfQ==

package/esm5/lib/view/task-view/models/task-view-params.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay12aWV3LXBhcmFtcy5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi92aWV3L3Rhc2stdmlldy9tb2RlbHMvdGFzay12aWV3LXBhcmFtcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBUYXNrVmlld1BhcmFtcyB7XG4gICAgYWxsb3dlZE5ldHM6IEFycmF5PHN0cmluZz47XG59XG4iXX0=

package/esm5/lib/view/task-view/service/task-view.service.js

@@ -0,0 +1,333 @@
+import { __assign, __extends } from "tslib";
+import { Inject, Injectable, Optional } from '@angular/core';
+import { BehaviorSubject, of, ReplaySubject, Subject, timer } from 'rxjs';
+import { TaskResourceService } from '../../../resources/engine-endpoint/task-resource.service';
+import { UserService } from '../../../user/services/user.service';
+import { SnackBarService } from '../../../snack-bar/services/snack-bar.service';
+import { TranslateService } from '@ngx-translate/core';
+import { catchError, concatMap, filter, map, mergeMap, scan, switchMap, take, tap } from 'rxjs/operators';
+import { HttpParams } from '@angular/common/http';
+import { SearchService } from '../../../search/search-service/search.service';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { UserComparatorService } from '../../../user/services/user-comparator.service';
+import { TaskEndpoint } from '../models/task-endpoint';
+import { NAE_PREFERRED_TASK_ENDPOINT } from '../models/injection-token-task-endpoint';
+import { PageLoadRequestContext } from '../../abstract/page-load-request-context';
+import { LoadingWithFilterEmitter } from '../../../utility/loading-with-filter-emitter';
+import { arrayToObservable } from '../../../utility/array-to-observable';
+import { SearchIndexResolverService } from '../../../search/search-keyword-resolver-service/search-index-resolver.service';
+import { SortableView } from '../../abstract/sortable-view';
+import { NAE_TASK_VIEW_CONFIGURATION } from '../models/task-view-configuration-injection-token';
+var TaskViewService = /** @class */ (function (_super) {
+    __extends(TaskViewService, _super);
+    function TaskViewService(_taskService, _userService, _snackBarService, _translate, _searchService, _log, _userComparator, resolver, _preferredEndpoint, taskViewConfig) {
+        if (_preferredEndpoint === void 0) { _preferredEndpoint = null; }
+        if (taskViewConfig === void 0) { taskViewConfig = null; }
+        var _a, _b, _c, _d;
+        var _this = _super.call(this, resolver) || this;
+        _this._taskService = _taskService;
+        _this._userService = _userService;
+        _this._snackBarService = _snackBarService;
+        _this._translate = _translate;
+        _this._searchService = _searchService;
+        _this._log = _log;
+        _this._userComparator = _userComparator;
+        _this._preferredEndpoint = _preferredEndpoint;
+        _this._initializing = true;
+        _this._tasks$ = new Subject();
+        _this._loading$ = new LoadingWithFilterEmitter();
+        _this._changedFields$ = new Subject();
+        _this._allowMultiOpen = true;
+        _this._endOfData = false;
+        _this._pagination = {
+            size: 50,
+            totalElements: undefined,
+            totalPages: undefined,
+            number: -1
+        };
+        _this._requestedPage$ = new BehaviorSubject(new PageLoadRequestContext(_this.activeFilter, Object.assign({}, _this._pagination, { number: 0 })));
+        _this._panelUpdate$ = new BehaviorSubject([]);
+        _this._closeTab$ = new ReplaySubject(1);
+        _this._preferredEndpoint = (_a = taskViewConfig === null || taskViewConfig === void 0 ? void 0 : taskViewConfig.preferredEndpoint) !== null && _a !== void 0 ? _a : ((_b = _this._preferredEndpoint) !== null && _b !== void 0 ? _b : TaskEndpoint.MONGO);
+        _this._initializing = false;
+        _this._subSearch = _this._searchService.activeFilter$.subscribe(function () {
+            _this.reload();
+        });
+        var tasksMap$ = _this._requestedPage$.pipe(mergeMap(function (p) { return _this.loadPage(p); }), map(function (pageLoadResult) {
+            if (pageLoadResult.requestContext && pageLoadResult.requestContext.clearLoaded) {
+                // we set an empty value to the virtual scroll and then replace it by the real value forcing it to redraw its content
+                var results = [{ tasks: {}, requestContext: null }, pageLoadResult];
+                return arrayToObservable(results);
+            }
+            else {
+                return of(pageLoadResult);
+            }
+        }), concatMap(function (o) { return o; }), scan(function (acc, pageLoadResult) {
+            var result;
+            if (pageLoadResult.requestContext === null) {
+                return pageLoadResult.tasks;
+            }
+            if (pageLoadResult.requestContext.reloadCurrentTaskPage) {
+                Object.keys(acc).forEach(function (taskId) {
+                    if (!pageLoadResult.tasks[taskId]) {
+                        delete acc[taskId];
+                    }
+                    else {
+                        pageLoadResult.tasks[taskId].task.dataGroups = acc[taskId].task.dataGroups;
+                        pageLoadResult.tasks[taskId].initiallyExpanded = acc[taskId].initiallyExpanded;
+                        _this.updateTask(acc[taskId].task, pageLoadResult.tasks[taskId].task);
+                        _this.blockTaskFields(acc[taskId].task, !(acc[taskId].task.user
+                            && _this._userComparator.compareUsers(acc[taskId].task.user)));
+                        delete pageLoadResult.tasks[taskId];
+                    }
+                });
+                result = Object.assign(acc, pageLoadResult.tasks);
+            }
+            else {
+                result = __assign(__assign({}, acc), pageLoadResult.tasks);
+            }
+            Object.assign(_this._pagination, pageLoadResult.requestContext.pagination);
+            if (pageLoadResult.requestContext !== null) {
+                _this._loading$.off(pageLoadResult.requestContext.filter);
+            }
+            return result;
+        }, {}));
+        _this._tasks$ = tasksMap$.pipe(map(function (v) { return Object.values(v); }), map(function (taskArray) {
+            if (taskArray.length === 1 && _this._initiallyOpenOneTask) {
+                taskArray[0].task.finishDate === undefined ?
+                    taskArray[0].initiallyExpanded = true :
+                    taskArray[0].initiallyExpanded = false;
+            }
+            return taskArray;
+        }), tap(function (v) { return _this._panelUpdate$.next(v); }));
+        _this._subInitiallyOpen = ((_c = taskViewConfig === null || taskViewConfig === void 0 ? void 0 : taskViewConfig.initiallyOpenOneTask) !== null && _c !== void 0 ? _c : of(true)).subscribe(function (bool) {
+            _this._initiallyOpenOneTask = bool;
+        });
+        _this._subCloseTask = ((_d = taskViewConfig === null || taskViewConfig === void 0 ? void 0 : taskViewConfig.closeTaskTabOnNoTasks) !== null && _d !== void 0 ? _d : of(true)).subscribe(function (bool) {
+            _this._closeTaskTabOnNoTasks = bool;
+        });
+        return _this;
+    }
+    TaskViewService.prototype.ngOnDestroy = function () {
+        _super.prototype.ngOnDestroy.call(this);
+        this._changedFields$.complete();
+        this._requestedPage$.complete();
+        this._panelUpdate$.complete();
+        this._closeTab$.complete();
+        this._subInitiallyOpen.unsubscribe();
+        this._subCloseTask.unsubscribe();
+        this._subSearch.unsubscribe();
+    };
+    Object.defineProperty(TaskViewService.prototype, "tasks$", {
+        get: function () {
+            return this._tasks$;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TaskViewService.prototype, "changedFields$", {
+        get: function () {
+            return this._changedFields$;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TaskViewService.prototype, "loading$", {
+        get: function () {
+            return this._loading$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TaskViewService.prototype, "loading", {
+        get: function () {
+            return this._loading$.isActive;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TaskViewService.prototype, "panelUpdate", {
+        get: function () {
+            return this._panelUpdate$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TaskViewService.prototype, "closeTab", {
+        get: function () {
+            return this._closeTab$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TaskViewService.prototype, "activeFilter", {
+        get: function () {
+            return this._searchService.activeFilter;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TaskViewService.prototype, "allowMultiOpen", {
+        get: function () {
+            return this._allowMultiOpen;
+        },
+        set: function (bool) {
+            this._allowMultiOpen = bool;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TaskViewService.prototype.loadPage = function (requestContext) {
+        var _this = this;
+        if (requestContext === null || requestContext.pageNumber < 0) {
+            return of({ tasks: {}, requestContext: requestContext });
+        }
+        var params = new HttpParams();
+        params = this.addSortParams(params);
+        params = this.addPageParams(params, requestContext.pagination);
+        this._loading$.on(requestContext.filter);
+        var request;
+        if (requestContext.filter.bodyContainsQuery() || this._preferredEndpoint === TaskEndpoint.ELASTIC) {
+            request = timer(200).pipe(switchMap(function () { return _this._taskService.searchTask(requestContext.filter, params).pipe(take(1)); }));
+        }
+        else {
+            request = this._taskService.getTasks(requestContext.filter, params).pipe(take(1));
+        }
+        return request.pipe(catchError(function (err) {
+            _this._log.error('Loading tasks has failed!', err);
+            _this._loading$.off(requestContext.filter);
+            return of({ content: [], pagination: __assign({}, _this._pagination) });
+        }), filter(function () {
+            var r = requestContext.filter === _this._searchService.activeFilter;
+            if (!r) {
+                _this._loading$.off(requestContext.filter);
+                _this._log.debug('Received tasks page is no longer relevant since the active filter has changed before it could arrive.'
+                    + ' Discarding...');
+            }
+            return r;
+        }), tap(function (t) {
+            Object.assign(requestContext.pagination, t.pagination);
+        }), tap(function (t) {
+            if (_this._pagination.totalElements && _this._pagination.totalElements > 0
+                && t.pagination.totalElements === 0 && !Array.isArray(t.content) && _this._closeTaskTabOnNoTasks) {
+                _this._closeTab$.next();
+            }
+        }), tap(function (t) {
+            _this._endOfData = !Array.isArray(t.content)
+                || t.content.length === 0
+                || t.pagination.number === t.pagination.totalPages;
+        }), map(function (tasks) { return Array.isArray(tasks.content) ? tasks : __assign(__assign({}, tasks), { content: [] }); }), map(function (tasks) {
+            return tasks.content.reduce(function (acc, curr) {
+                var _a;
+                _this.blockTaskFields(curr, !(curr.user && _this._userComparator.compareUsers(curr.user)));
+                return __assign(__assign({}, acc), (_a = {}, _a[curr.stringId] = {
+                    task: curr,
+                    changedFields: _this._changedFields$,
+                    initiallyExpanded: false
+                }, _a));
+            }, {});
+        }), map(function (tasks) { return ({ tasks: tasks, requestContext: requestContext }); }));
+    };
+    TaskViewService.prototype.updateTask = function (old, neww) {
+        Object.keys(old).forEach(function (key) {
+            if (!neww.hasOwnProperty(key)) {
+                delete old[key];
+            }
+        });
+        Object.keys(neww).forEach(function (key) {
+            if (neww[key] !== undefined && neww[key] !== null) {
+                old[key] = neww[key];
+            }
+        });
+        this.blockTaskFields(old, !(old.user && this._userComparator.compareUsers(old.user)));
+    };
+    TaskViewService.prototype.blockTaskFields = function (task, block) {
+        if (!task.dataGroups) {
+            return;
+        }
+        task.dataGroups.forEach(function (g) { return g.fields.forEach(function (f) { return f.block = block; }); });
+    };
+    TaskViewService.prototype.nextPage = function (renderedRange, totalLoaded, requestContext) {
+        if (requestContext === undefined) {
+            requestContext = new PageLoadRequestContext(this.activeFilter, this._pagination);
+            requestContext.pagination.number += 1;
+        }
+        if (this.isLoadingRelevantFilter(requestContext) || this._endOfData) {
+            return;
+        }
+        if (renderedRange.end === totalLoaded) {
+            this._requestedPage$.next(requestContext);
+        }
+    };
+    TaskViewService.prototype.isLoadingRelevantFilter = function (requestContext) {
+        return requestContext === undefined || (this._loading$.isActiveWithFilter(requestContext.filter) && !requestContext.force);
+    };
+    TaskViewService.prototype.reload = function () {
+        if (!this._tasks$ || !this._pagination) {
+            return;
+        }
+        this._endOfData = false;
+        var requestContext = new PageLoadRequestContext(this.activeFilter, this._pagination, true);
+        requestContext.pagination.number = 0;
+        var range = {
+            start: -1,
+            end: 0
+        };
+        this.nextPage(range, 0, requestContext);
+    };
+    TaskViewService.prototype.reloadCurrentPage = function (force) {
+        if (!this._tasks$ || !this._pagination) {
+            return;
+        }
+        this._endOfData = false;
+        var requestContext = new PageLoadRequestContext(this.activeFilter, this._pagination, false, true, force);
+        requestContext.pagination.number = 0; // TODO [BUG] - Reloading only first page
+        var range = {
+            start: -1,
+            end: 0
+        };
+        this.nextPage(range, 0, requestContext);
+    };
+    TaskViewService.prototype.getMetaFieldSortId = function () {
+        // TODO Tasks were not sortable on old frontend sorting might require elastic mapping changes on backend
+        return this._lastHeaderSearchState.fieldIdentifier;
+    };
+    TaskViewService.prototype.getDefaultSortParam = function () {
+        return 'priority,desc';
+    };
+    TaskViewService.prototype.addPageParams = function (params, pagination) {
+        params = params.set('size', pagination.size + '');
+        params = params.set('page', pagination.number + '');
+        return params;
+    };
+    TaskViewService.ctorParameters = function () { return [
+        { type: TaskResourceService },
+        { type: UserService },
+        { type: SnackBarService },
+        { type: TranslateService },
+        { type: SearchService },
+        { type: LoggerService },
+        { type: UserComparatorService },
+        { type: SearchIndexResolverService },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_PREFERRED_TASK_ENDPOINT,] }] },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_TASK_VIEW_CONFIGURATION,] }] }
+    ]; };
+    TaskViewService.decorators = [
+        { type: Injectable }
+    ];
+    TaskViewService.ctorParameters = function () { return [
+        { type: TaskResourceService },
+        { type: UserService },
+        { type: SnackBarService },
+        { type: TranslateService },
+        { type: SearchService },
+        { type: LoggerService },
+        { type: UserComparatorService },
+        { type: SearchIndexResolverService },
+        { type: TaskEndpoint, decorators: [{ type: Optional }, { type: Inject, args: [NAE_PREFERRED_TASK_ENDPOINT,] }] },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_TASK_VIEW_CONFIGURATION,] }] }
+    ]; };
+    return TaskViewService;
+}(SortableView));
+export { TaskViewService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-view.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/view/task-view/service/task-view.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,MAAM,EAAE,UAAU,EAAa,QAAQ,EAAC,MAAM,eAAe,CAAC;AACtE,OAAO,EAAC,eAAe,EAAc,EAAE,EAAE,aAAa,EAAE,OAAO,EAAgB,KAAK,EAAC,MAAM,MAAM,CAAC;AAElG,OAAO,EAAC,mBAAmB,EAAC,MAAM,0DAA0D,CAAC;AAC7F,OAAO,EAAC,WAAW,EAAC,MAAM,qCAAqC,CAAC;AAChE,OAAO,EAAC,eAAe,EAAC,MAAM,+CAA+C,CAAC;AAC9E,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAC,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,EAAC,MAAM,gBAAgB,CAAC;AACxG,OAAO,EAAC,UAAU,EAAC,MAAM,sBAAsB,CAAC;AAGhD,OAAO,EAAC,aAAa,EAAC,MAAM,+CAA+C,CAAC;AAC5E,OAAO,EAAC,aAAa,EAAC,MAAM,yCAAyC,CAAC;AAEtE,OAAO,EAAC,qBAAqB,EAAC,MAAM,gDAAgD,CAAC;AACrF,OAAO,EAAC,YAAY,EAAC,MAAM,yBAAyB,CAAC;AAErD,OAAO,EAAC,2BAA2B,EAAC,MAAM,yCAAyC,CAAC;AACpF,OAAO,EAAC,sBAAsB,EAAC,MAAM,0CAA0C,CAAC;AAGhF,OAAO,EAAC,wBAAwB,EAAC,MAAM,8CAA8C,CAAC;AACtF,OAAO,EAAC,iBAAiB,EAAC,MAAM,sCAAsC,CAAC;AACvE,OAAO,EAAC,0BAA0B,EAAC,MAAM,+EAA+E,CAAC;AACzH,OAAO,EAAC,YAAY,EAAC,MAAM,8BAA8B,CAAC;AAC1D,OAAO,EAAC,2BAA2B,EAAC,MAAM,mDAAmD,CAAC;AAK9F;IACqC,mCAAY;IAqB7C,yBAAsB,YAAiC,EACnC,YAAyB,EACzB,gBAAiC,EACjC,UAA4B,EAC1B,cAA6B,EAC/B,IAAmB,EACnB,eAAsC,EAC9C,QAAoC,EACgC,kBAAuC,EAC1D,cAA4C;QADzB,mCAAA,EAAA,yBAAuC;QAC3G,+BAAA,EAAA,qBAA6F;;QATzG,YAUI,kBAAM,QAAQ,CAAC,SAuFlB;QAjGqB,kBAAY,GAAZ,YAAY,CAAqB;QACnC,kBAAY,GAAZ,YAAY,CAAa;QACzB,sBAAgB,GAAhB,gBAAgB,CAAiB;QACjC,gBAAU,GAAV,UAAU,CAAkB;QAC1B,oBAAc,GAAd,cAAc,CAAe;QAC/B,UAAI,GAAJ,IAAI,CAAe;QACnB,qBAAe,GAAf,eAAe,CAAuB;QAEsB,wBAAkB,GAAlB,kBAAkB,CAAqB;QAVtG,mBAAa,GAAY,IAAI,CAAC;QAa3C,KAAI,CAAC,OAAO,GAAG,IAAI,OAAO,EAAwB,CAAC;QACnD,KAAI,CAAC,SAAS,GAAG,IAAI,wBAAwB,EAAE,CAAC;QAChD,KAAI,CAAC,eAAe,GAAG,IAAI,OAAO,EAAoB,CAAC;QACvD,KAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,KAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,KAAI,CAAC,WAAW,GAAG;YACf,IAAI,EAAE,EAAE;YACR,aAAa,EAAE,SAAS;YACxB,UAAU,EAAE,SAAS;YACrB,MAAM,EAAE,CAAC,CAAC;SACb,CAAC;QACF,KAAI,CAAC,eAAe,GAAG,IAAI,eAAe,CACtC,IAAI,sBAAsB,CAAC,KAAI,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,KAAI,CAAC,WAAW,EAAE,EAAC,MAAM,EAAE,CAAC,EAAC,CAAC,CAAC,CAClG,CAAC;QACF,KAAI,CAAC,aAAa,GAAG,IAAI,eAAe,CAAuB,EAAE,CAAC,CAAC;QACnE,KAAI,CAAC,UAAU,GAAG,IAAI,aAAa,CAAO,CAAC,CAAC,CAAC;QAC7C,KAAI,CAAC,kBAAkB,SAAG,cAAc,aAAd,cAAc,uBAAd,cAAc,CAAE,iBAAiB,mCAAI,OAAC,KAAI,CAAC,kBAAkB,mCAAI,YAAY,CAAC,KAAK,CAAC,CAAC;QAE/G,KAAI,CAAC,aAAa,GAAG,KAAK,CAAC;QAE3B,KAAI,CAAC,UAAU,GAAG,KAAI,CAAC,cAAc,CAAC,aAAa,CAAC,SAAS,CAAC;YAC1D,KAAI,CAAC,MAAM,EAAE,CAAC;QAClB,CAAC,CAAC,CAAC;QAEH,IAAM,SAAS,GAAG,KAAI,CAAC,eAAe,CAAC,IAAI,CACvC,QAAQ,CAAC,UAAA,CAAC,IAAI,OAAA,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAhB,CAAgB,CAAC,EAC/B,GAAG,CAAC,UAAA,cAAc;YACd,IAAI,cAAc,CAAC,cAAc,IAAI,cAAc,CAAC,cAAc,CAAC,WAAW,EAAE;gBAC5E,qHAAqH;gBACrH,IAAM,OAAO,GAAG,CAAC,EAAC,KAAK,EAAE,EAAE,EAAE,cAAc,EAAE,IAAI,EAAC,EAAE,cAAc,CAAC,CAAC;gBACpE,OAAO,iBAAiB,CAAC,OAAO,CAAC,CAAC;aACrC;iBAAM;gBACH,OAAO,EAAE,CAAC,cAAc,CAAC,CAAC;aAC7B;QACL,CAAC,CAAC,EACF,SAAS,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,EAAD,CAAC,CAAC,EACjB,IAAI,CAAC,UAAC,GAAG,EAAE,cAAc;YACrB,IAAI,MAAsC,CAAC;YAC3C,IAAI,cAAc,CAAC,cAAc,KAAK,IAAI,EAAE;gBACxC,OAAO,cAAc,CAAC,KAAK,CAAC;aAC/B;YAED,IAAI,cAAc,CAAC,cAAc,CAAC,qBAAqB,EAAE;gBACrD,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,UAAA,MAAM;oBAC3B,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;wBAC/B,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC;qBACtB;yBAAM;wBACH,cAAc,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC;wBAC3E,cAAc,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,iBAAiB,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,iBAAiB,CAAC;wBAC/E,KAAI,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,cAAc,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC;wBACrE,KAAI,CAAC,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI;+BACvD,KAAI,CAAC,eAAe,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;wBAClE,OAAO,cAAc,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;qBACvC;gBACL,CAAC,CAAC,CAAC;gBACH,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC;aACrD;iBAAM;gBACH,MAAM,yBAAO,GAAG,GAAK,cAAc,CAAC,KAAK,CAAC,CAAC;aAC9C;YAED,MAAM,CAAC,MAAM,CAAC,KAAI,CAAC,WAAW,EAAE,cAAc,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;YAC1E,IAAI,cAAc,CAAC,cAAc,KAAK,IAAI,EAAE;gBACxC,KAAI,CAAC,SAAS,CAAC,GAAG,CAAC,cAAc,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;aAC5D;YACD,OAAO,MAAM,CAAC;QAClB,CAAC,EAAE,EAAE,CAAC,CACT,CAAC;QACF,KAAI,CAAC,OAAO,GAAG,SAAS,CAAC,IAAI,CACzB,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,MAAM,CAAC,MAAM,CAAC,CAAC,CAAyB,EAAxC,CAAwC,CAAC,EAClD,GAAG,CAAC,UAAA,SAAS;YACT,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,KAAI,CAAC,qBAAqB,EAAE;gBACtD,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC;oBACxC,SAAS,CAAC,CAAC,CAAC,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;oBACvC,SAAS,CAAC,CAAC,CAAC,CAAC,iBAAiB,GAAG,KAAK,CAAC;aAC9C;YACD,OAAO,SAAS,CAAC;QACrB,CAAC,CAAC,EACF,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,KAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAA1B,CAA0B,CAAC,CAAC,CAAC;QAE1C,KAAI,CAAC,iBAAiB,GAAG,OAAC,cAAc,aAAd,cAAc,uBAAd,cAAc,CAAE,oBAAoB,mCAAI,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,UAAA,IAAI;YACtF,KAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;QACtC,CAAC,CAAC,CAAC;QAEH,KAAI,CAAC,aAAa,GAAG,OAAC,cAAc,aAAd,cAAc,uBAAd,cAAc,CAAE,qBAAqB,mCAAI,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,UAAA,IAAI;YACnF,KAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;QACvC,CAAC,CAAC,CAAC;;IACP,CAAC;IAED,qCAAW,GAAX;QACI,iBAAM,WAAW,WAAE,CAAC;QACpB,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,CAAC;QAChC,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,CAAC;QAChC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;QAC9B,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;QAC3B,IAAI,CAAC,iBAAiB,CAAC,WAAW,EAAE,CAAC;QACrC,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;QACjC,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;IAClC,CAAC;IAED,sBAAW,mCAAM;aAAjB;YACI,OAAO,IAAI,CAAC,OAAO,CAAC;QACxB,CAAC;;;OAAA;IAED,sBAAW,2CAAc;aAAzB;YACI,OAAO,IAAI,CAAC,eAAe,CAAC;QAChC,CAAC;;;OAAA;IAED,sBAAW,qCAAQ;aAAnB;YACI,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC;QACzC,CAAC;;;OAAA;IAED,sBAAW,oCAAO;aAAlB;YACI,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;QACnC,CAAC;;;OAAA;IAED,sBAAW,wCAAW;aAAtB;YACI,OAAO,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC;QAC7C,CAAC;;;OAAA;IAED,sBAAW,qCAAQ;aAAnB;YACI,OAAO,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,CAAC;QAC1C,CAAC;;;OAAA;IAED,sBAAc,yCAAY;aAA1B;YACI,OAAO,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC;QAC5C,CAAC;;;OAAA;IAED,sBAAW,2CAAc;aAIzB;YACI,OAAO,IAAI,CAAC,eAAe,CAAC;QAChC,CAAC;aAND,UAA0B,IAAa;YACnC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAChC,CAAC;;;OAAA;IAMM,kCAAQ,GAAf,UAAgB,cAAsC;QAAtD,iBA6DC;QA5DG,IAAI,cAAc,KAAK,IAAI,IAAI,cAAc,CAAC,UAAU,GAAG,CAAC,EAAE;YAC1D,OAAO,EAAE,CAAC,EAAC,KAAK,EAAE,EAAE,EAAE,cAAc,gBAAA,EAAC,CAAC,CAAC;SAC1C;QACD,IAAI,MAAM,GAAe,IAAI,UAAU,EAAE,CAAC;QAC1C,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QACpC,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;QAC/D,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QAEzC,IAAI,OAA+B,CAAC;QACpC,IAAI,cAAc,CAAC,MAAM,CAAC,iBAAiB,EAAE,IAAI,IAAI,CAAC,kBAAkB,KAAK,YAAY,CAAC,OAAO,EAAE;YAC/F,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CACrB,SAAS,CAAC,cAAM,OAAA,KAAI,CAAC,YAAY,CAAC,UAAU,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAzE,CAAyE,CAAC,CAC7F,CAAC;SACL;aAAM;YACH,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;SACrF;QACD,OAAO,OAAO,CAAC,IAAI,CACf,UAAU,CAAC,UAAA,GAAG;YACV,KAAI,CAAC,IAAI,CAAC,KAAK,CAAC,2BAA2B,EAAE,GAAG,CAAC,CAAC;YAClD,KAAI,CAAC,SAAS,CAAC,GAAG,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;YAC1C,OAAO,EAAE,CAAC,EAAC,OAAO,EAAE,EAAE,EAAE,UAAU,eAAM,KAAI,CAAC,WAAW,CAAC,EAAC,CAAC,CAAC;QAChE,CAAC,CAAC,EACF,MAAM,CAAC;YACH,IAAM,CAAC,GAAG,cAAc,CAAC,MAAM,KAAK,KAAI,CAAC,cAAc,CAAC,YAAY,CAAC;YACrE,IAAI,CAAC,CAAC,EAAE;gBACJ,KAAI,CAAC,SAAS,CAAC,GAAG,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;gBAC1C,KAAI,CAAC,IAAI,CAAC,KAAK,CAAC,uGAAuG;sBACjH,gBAAgB,CAAC,CAAC;aAC3B;YACD,OAAO,CAAC,CAAC;QACb,CAAC,CAAC,EACF,GAAG,CAAC,UAAA,CAAC;YACD,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC;QAC3D,CAAC,CAAC,EACF,GAAG,CAAC,UAAA,CAAC;YACD,IAAI,KAAI,CAAC,WAAW,CAAC,aAAa,IAAI,KAAI,CAAC,WAAW,CAAC,aAAa,GAAG,CAAC;mBACjE,CAAC,CAAC,UAAU,CAAC,aAAa,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,KAAI,CAAC,sBAAsB,EAAE;gBACjG,KAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;aAC1B;QACL,CAAC,CAAC,EACF,GAAG,CAAC,UAAA,CAAC;YACD,KAAI,CAAC,UAAU,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC;mBACpC,CAAC,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC;mBACtB,CAAC,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC;QAC3D,CAAC,CAAC,EACF,GAAG,CAAC,UAAA,KAAK,IAAI,OAAA,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,uBAAK,KAAK,KAAE,OAAO,EAAE,EAAE,GAAC,EAA9D,CAA8D,CAAC,EAC5E,GAAG,CAAC,UAAA,KAAK;YACL,OAAO,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,UAAC,GAAG,EAAE,IAAI;;gBAClC,KAAI,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,IAAI,KAAI,CAAC,eAAe,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBACzF,6BACO,GAAG,gBAAG,IAAI,CAAC,QAAQ,IAAG;oBACrB,IAAI,EAAE,IAAI;oBACV,aAAa,EAAE,KAAI,CAAC,eAAe;oBACnC,iBAAiB,EAAE,KAAK;iBAC3B,OACH;YACN,CAAC,EAAE,EAAE,CAAC,CAAC;QACX,CAAC,CAAC,EACF,GAAG,CAAC,UAAA,KAAK,IAAI,OAAA,CAAC,EAAC,KAAK,OAAA,EAAE,cAAc,gBAAA,EAAC,CAAC,EAAzB,CAAyB,CAAC,CAC1C,CAAC;IACN,CAAC;IAEO,oCAAU,GAAlB,UAAmB,GAAS,EAAE,IAAU;QACpC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,UAAA,GAAG;YACxB,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;gBAC3B,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC;aACnB;QACL,CAAC,CAAC,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,UAAA,GAAG;YACzB,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,SAAS,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE;gBAC/C,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;aACxB;QACL,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,eAAe,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC1F,CAAC;IAEO,yCAAe,GAAvB,UAAwB,IAAU,EAAE,KAAc;QAC9C,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YAClB,OAAO;SACV;QACD,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,KAAK,GAAG,KAAK,EAAf,CAAe,CAAC,EAAtC,CAAsC,CAAC,CAAC;IACzE,CAAC;IAEM,kCAAQ,GAAf,UAAgB,aAAwB,EAAE,WAAmB,EAAE,cAAuC;QAClG,IAAI,cAAc,KAAK,SAAS,EAAE;YAC9B,cAAc,GAAG,IAAI,sBAAsB,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;YACjF,cAAc,CAAC,UAAU,CAAC,MAAM,IAAI,CAAC,CAAC;SACzC;QAED,IAAI,IAAI,CAAC,uBAAuB,CAAC,cAAc,CAAC,IAAI,IAAI,CAAC,UAAU,EAAE;YACjE,OAAO;SACV;QAED,IAAI,aAAa,CAAC,GAAG,KAAK,WAAW,EAAE;YACnC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;SAC7C;IACL,CAAC;IAEO,iDAAuB,GAA/B,UAAgC,cAAuC;QACnE,OAAO,cAAc,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,kBAAkB,CAAC,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAC/H,CAAC;IAEM,gCAAM,GAAb;QACI,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACpC,OAAO;SACV;QAED,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,IAAM,cAAc,GAAG,IAAI,sBAAsB,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;QAC7F,cAAc,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC;QACrC,IAAM,KAAK,GAAG;YACV,KAAK,EAAE,CAAC,CAAC;YACT,GAAG,EAAE,CAAC;SACT,CAAC;QAEF,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,cAAc,CAAC,CAAC;IAC5C,CAAC;IAEM,2CAAiB,GAAxB,UAAyB,KAAe;QACpC,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACpC,OAAO;SACV;QAED,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,IAAM,cAAc,GAAG,IAAI,sBAAsB,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QAC3G,cAAc,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,yCAAyC;QAC/E,IAAM,KAAK,GAAG;YACV,KAAK,EAAE,CAAC,CAAC;YACT,GAAG,EAAE,CAAC;SACT,CAAC;QACF,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,cAAc,CAAC,CAAC;IAC5C,CAAC;IAES,4CAAkB,GAA5B;QACI,wGAAwG;QACxG,OAAO,IAAI,CAAC,sBAAsB,CAAC,eAAe,CAAC;IACvD,CAAC;IAES,6CAAmB,GAA7B;QACI,OAAO,eAAe,CAAC;IAC3B,CAAC;IAES,uCAAa,GAAvB,UAAwB,MAAkB,EAAE,UAAsB;QAC9D,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC;QAClD,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;QACpD,OAAO,MAAM,CAAC;IAClB,CAAC;;gBArSmC,mBAAmB;gBACrB,WAAW;gBACP,eAAe;gBACrB,gBAAgB;gBACV,aAAa;gBACzB,aAAa;gBACF,qBAAqB;gBACpC,0BAA0B;gDACnC,QAAQ,YAAI,MAAM,SAAC,2BAA2B;gDAC9C,QAAQ,YAAI,MAAM,SAAC,2BAA2B;;;gBA/B9D,UAAU;;;gBA3BH,mBAAmB;gBACnB,WAAW;gBACX,eAAe;gBACf,gBAAgB;gBAKhB,aAAa;gBACb,aAAa;gBAEb,qBAAqB;gBASrB,0BAA0B;gBAR1B,YAAY,uBA6CH,QAAQ,YAAI,MAAM,SAAC,2BAA2B;gDAC9C,QAAQ,YAAI,MAAM,SAAC,2BAA2B;;IA6R/D,sBAAC;CAAA,AA5TD,CACqC,YAAY,GA2ThD;SA3TY,eAAe","sourcesContent":["import {Inject, Injectable, OnDestroy, Optional} from '@angular/core';\nimport {BehaviorSubject, Observable, of, ReplaySubject, Subject, Subscription, timer} from 'rxjs';\nimport {TaskPanelData} from '../../../panel/task-panel-list/task-panel-data/task-panel-data';\nimport {TaskResourceService} from '../../../resources/engine-endpoint/task-resource.service';\nimport {UserService} from '../../../user/services/user.service';\nimport {SnackBarService} from '../../../snack-bar/services/snack-bar.service';\nimport {TranslateService} from '@ngx-translate/core';\nimport {catchError, concatMap, filter, map, mergeMap, scan, switchMap, take, tap} from 'rxjs/operators';\nimport {HttpParams} from '@angular/common/http';\nimport {Pagination} from '../../../resources/interface/pagination';\nimport {Task} from '../../../resources/interface/task';\nimport {SearchService} from '../../../search/search-service/search.service';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {ListRange} from '@angular/cdk/collections';\nimport {UserComparatorService} from '../../../user/services/user-comparator.service';\nimport {TaskEndpoint} from '../models/task-endpoint';\nimport {Page} from '../../../resources/interface/page';\nimport {NAE_PREFERRED_TASK_ENDPOINT} from '../models/injection-token-task-endpoint';\nimport {PageLoadRequestContext} from '../../abstract/page-load-request-context';\nimport {Filter} from '../../../filter/models/filter';\nimport {TaskPageLoadRequestResult} from '../models/task-page-load-request-result';\nimport {LoadingWithFilterEmitter} from '../../../utility/loading-with-filter-emitter';\nimport {arrayToObservable} from '../../../utility/array-to-observable';\nimport {SearchIndexResolverService} from '../../../search/search-keyword-resolver-service/search-index-resolver.service';\nimport {SortableView} from '../../abstract/sortable-view';\nimport {NAE_TASK_VIEW_CONFIGURATION} from '../models/task-view-configuration-injection-token';\nimport {TaskViewConfiguration} from '../models/task-view-configuration';\nimport {ChangedFieldsMap} from '../../../event/services/interfaces/changed-fields-map';\n\n\n@Injectable()\nexport class TaskViewService extends SortableView implements OnDestroy {\n\n    protected _tasks$: Observable<Array<TaskPanelData>>;\n    protected _changedFields$: Subject<ChangedFieldsMap>;\n    protected _requestedPage$: BehaviorSubject<PageLoadRequestContext>;\n    protected _loading$: LoadingWithFilterEmitter;\n    protected _endOfData: boolean;\n    protected _pagination: Pagination;\n    protected _initiallyOpenOneTask: boolean;\n    protected _closeTaskTabOnNoTasks: boolean;\n    protected _panelUpdate$: BehaviorSubject<Array<TaskPanelData>>;\n    protected _closeTab$: ReplaySubject<void>;\n    protected _subInitiallyOpen: Subscription;\n    protected _subCloseTask: Subscription;\n    protected _subSearch: Subscription;\n\n    // Serializing assign after cancel\n    protected _allowMultiOpen: boolean;\n\n    private readonly _initializing: boolean = true;\n\n    constructor(protected _taskService: TaskResourceService,\n                private _userService: UserService,\n                private _snackBarService: SnackBarService,\n                private _translate: TranslateService,\n                protected _searchService: SearchService,\n                private _log: LoggerService,\n                private _userComparator: UserComparatorService,\n                resolver: SearchIndexResolverService,\n                @Optional() @Inject(NAE_PREFERRED_TASK_ENDPOINT) protected readonly _preferredEndpoint: TaskEndpoint = null,\n                @Optional() @Inject(NAE_TASK_VIEW_CONFIGURATION) taskViewConfig: TaskViewConfiguration = null) {\n        super(resolver);\n        this._tasks$ = new Subject<Array<TaskPanelData>>();\n        this._loading$ = new LoadingWithFilterEmitter();\n        this._changedFields$ = new Subject<ChangedFieldsMap>();\n        this._allowMultiOpen = true;\n        this._endOfData = false;\n        this._pagination = {\n            size: 50,\n            totalElements: undefined,\n            totalPages: undefined,\n            number: -1\n        };\n        this._requestedPage$ = new BehaviorSubject<PageLoadRequestContext>(\n            new PageLoadRequestContext(this.activeFilter, Object.assign({}, this._pagination, {number: 0}))\n        );\n        this._panelUpdate$ = new BehaviorSubject<Array<TaskPanelData>>([]);\n        this._closeTab$ = new ReplaySubject<void>(1);\n        this._preferredEndpoint = taskViewConfig?.preferredEndpoint ?? (this._preferredEndpoint ?? TaskEndpoint.MONGO);\n\n        this._initializing = false;\n\n        this._subSearch = this._searchService.activeFilter$.subscribe(() => {\n            this.reload();\n        });\n\n        const tasksMap$ = this._requestedPage$.pipe(\n            mergeMap(p => this.loadPage(p)),\n            map(pageLoadResult => {\n                if (pageLoadResult.requestContext && pageLoadResult.requestContext.clearLoaded) {\n                    // we set an empty value to the virtual scroll and then replace it by the real value forcing it to redraw its content\n                    const results = [{tasks: {}, requestContext: null}, pageLoadResult];\n                    return arrayToObservable(results);\n                } else {\n                    return of(pageLoadResult);\n                }\n            }),\n            concatMap(o => o),\n            scan((acc, pageLoadResult) => {\n                let result: { [k: string]: TaskPanelData };\n                if (pageLoadResult.requestContext === null) {\n                    return pageLoadResult.tasks;\n                }\n\n                if (pageLoadResult.requestContext.reloadCurrentTaskPage) {\n                    Object.keys(acc).forEach(taskId => {\n                        if (!pageLoadResult.tasks[taskId]) {\n                            delete acc[taskId];\n                        } else {\n                            pageLoadResult.tasks[taskId].task.dataGroups = acc[taskId].task.dataGroups;\n                            pageLoadResult.tasks[taskId].initiallyExpanded = acc[taskId].initiallyExpanded;\n                            this.updateTask(acc[taskId].task, pageLoadResult.tasks[taskId].task);\n                            this.blockTaskFields(acc[taskId].task, !(acc[taskId].task.user\n                                && this._userComparator.compareUsers(acc[taskId].task.user)));\n                            delete pageLoadResult.tasks[taskId];\n                        }\n                    });\n                    result = Object.assign(acc, pageLoadResult.tasks);\n                } else {\n                    result = {...acc, ...pageLoadResult.tasks};\n                }\n\n                Object.assign(this._pagination, pageLoadResult.requestContext.pagination);\n                if (pageLoadResult.requestContext !== null) {\n                    this._loading$.off(pageLoadResult.requestContext.filter);\n                }\n                return result;\n            }, {})\n        );\n        this._tasks$ = tasksMap$.pipe(\n            map(v => Object.values(v) as Array<TaskPanelData>),\n            map(taskArray => {\n                if (taskArray.length === 1 && this._initiallyOpenOneTask) {\n                    taskArray[0].task.finishDate === undefined ?\n                        taskArray[0].initiallyExpanded = true :\n                        taskArray[0].initiallyExpanded = false;\n                }\n                return taskArray;\n            }),\n            tap(v => this._panelUpdate$.next(v)));\n\n        this._subInitiallyOpen = (taskViewConfig?.initiallyOpenOneTask ?? of(true)).subscribe(bool => {\n            this._initiallyOpenOneTask = bool;\n        });\n\n        this._subCloseTask = (taskViewConfig?.closeTaskTabOnNoTasks ?? of(true)).subscribe(bool => {\n            this._closeTaskTabOnNoTasks = bool;\n        });\n    }\n\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this._changedFields$.complete();\n        this._requestedPage$.complete();\n        this._panelUpdate$.complete();\n        this._closeTab$.complete();\n        this._subInitiallyOpen.unsubscribe();\n        this._subCloseTask.unsubscribe();\n        this._subSearch.unsubscribe();\n    }\n\n    public get tasks$(): Observable<Array<TaskPanelData>> {\n        return this._tasks$;\n    }\n\n    public get changedFields$(): Subject<ChangedFieldsMap> {\n        return this._changedFields$;\n    }\n\n    public get loading$(): Observable<boolean> {\n        return this._loading$.asObservable();\n    }\n\n    public get loading(): boolean {\n        return this._loading$.isActive;\n    }\n\n    public get panelUpdate(): Observable<Array<TaskPanelData>> {\n        return this._panelUpdate$.asObservable();\n    }\n\n    public get closeTab(): Observable<void> {\n        return this._closeTab$.asObservable();\n    }\n\n    protected get activeFilter(): Filter {\n        return this._searchService.activeFilter;\n    }\n\n    public set allowMultiOpen(bool: boolean) {\n        this._allowMultiOpen = bool;\n    }\n\n    public get allowMultiOpen(): boolean {\n        return this._allowMultiOpen;\n    }\n\n    public loadPage(requestContext: PageLoadRequestContext): Observable<TaskPageLoadRequestResult> {\n        if (requestContext === null || requestContext.pageNumber < 0) {\n            return of({tasks: {}, requestContext});\n        }\n        let params: HttpParams = new HttpParams();\n        params = this.addSortParams(params);\n        params = this.addPageParams(params, requestContext.pagination);\n        this._loading$.on(requestContext.filter);\n\n        let request: Observable<Page<Task>>;\n        if (requestContext.filter.bodyContainsQuery() || this._preferredEndpoint === TaskEndpoint.ELASTIC) {\n            request = timer(200).pipe(\n                switchMap(() => this._taskService.searchTask(requestContext.filter, params).pipe(take(1)))\n            );\n        } else {\n            request = this._taskService.getTasks(requestContext.filter, params).pipe(take(1));\n        }\n        return request.pipe(\n            catchError(err => {\n                this._log.error('Loading tasks has failed!', err);\n                this._loading$.off(requestContext.filter);\n                return of({content: [], pagination: {...this._pagination}});\n            }),\n            filter(() => {\n                const r = requestContext.filter === this._searchService.activeFilter;\n                if (!r) {\n                    this._loading$.off(requestContext.filter);\n                    this._log.debug('Received tasks page is no longer relevant since the active filter has changed before it could arrive.'\n                        + ' Discarding...');\n                }\n                return r;\n            }),\n            tap(t => {\n                Object.assign(requestContext.pagination, t.pagination);\n            }),\n            tap(t => {\n                if (this._pagination.totalElements && this._pagination.totalElements > 0\n                    && t.pagination.totalElements === 0 && !Array.isArray(t.content) && this._closeTaskTabOnNoTasks) {\n                    this._closeTab$.next();\n                }\n            }),\n            tap(t => {\n                this._endOfData = !Array.isArray(t.content)\n                    || t.content.length === 0\n                    || t.pagination.number === t.pagination.totalPages;\n            }),\n            map(tasks => Array.isArray(tasks.content) ? tasks : {...tasks, content: []}),\n            map(tasks => {\n                return tasks.content.reduce((acc, curr) => {\n                    this.blockTaskFields(curr, !(curr.user && this._userComparator.compareUsers(curr.user)));\n                    return {\n                        ...acc, [curr.stringId]: {\n                            task: curr,\n                            changedFields: this._changedFields$,\n                            initiallyExpanded: false\n                        }\n                    };\n                }, {});\n            }),\n            map(tasks => ({tasks, requestContext}))\n        );\n    }\n\n    private updateTask(old: Task, neww: Task) {\n        Object.keys(old).forEach(key => {\n            if (!neww.hasOwnProperty(key)) {\n                delete old[key];\n            }\n        });\n        Object.keys(neww).forEach(key => {\n            if (neww[key] !== undefined && neww[key] !== null) {\n                old[key] = neww[key];\n            }\n        });\n        this.blockTaskFields(old, !(old.user && this._userComparator.compareUsers(old.user)));\n    }\n\n    private blockTaskFields(task: Task, block: boolean): void {\n        if (!task.dataGroups) {\n            return;\n        }\n        task.dataGroups.forEach(g => g.fields.forEach(f => f.block = block));\n    }\n\n    public nextPage(renderedRange: ListRange, totalLoaded: number, requestContext?: PageLoadRequestContext): void {\n        if (requestContext === undefined) {\n            requestContext = new PageLoadRequestContext(this.activeFilter, this._pagination);\n            requestContext.pagination.number += 1;\n        }\n\n        if (this.isLoadingRelevantFilter(requestContext) || this._endOfData) {\n            return;\n        }\n\n        if (renderedRange.end === totalLoaded) {\n            this._requestedPage$.next(requestContext);\n        }\n    }\n\n    private isLoadingRelevantFilter(requestContext?: PageLoadRequestContext): boolean {\n        return requestContext === undefined || (this._loading$.isActiveWithFilter(requestContext.filter) && !requestContext.force);\n    }\n\n    public reload(): void {\n        if (!this._tasks$ || !this._pagination) {\n            return;\n        }\n\n        this._endOfData = false;\n        const requestContext = new PageLoadRequestContext(this.activeFilter, this._pagination, true);\n        requestContext.pagination.number = 0;\n        const range = {\n            start: -1,\n            end: 0\n        };\n\n        this.nextPage(range, 0, requestContext);\n    }\n\n    public reloadCurrentPage(force?: boolean): void {\n        if (!this._tasks$ || !this._pagination) {\n            return;\n        }\n\n        this._endOfData = false;\n        const requestContext = new PageLoadRequestContext(this.activeFilter, this._pagination, false, true, force);\n        requestContext.pagination.number = 0; // TODO [BUG] - Reloading only first page\n        const range = {\n            start: -1,\n            end: 0\n        };\n        this.nextPage(range, 0, requestContext);\n    }\n\n    protected getMetaFieldSortId(): string {\n        // TODO Tasks were not sortable on old frontend sorting might require elastic mapping changes on backend\n        return this._lastHeaderSearchState.fieldIdentifier;\n    }\n\n    protected getDefaultSortParam(): string {\n        return 'priority,desc';\n    }\n\n    protected addPageParams(params: HttpParams, pagination: Pagination): HttpParams {\n        params = params.set('size', pagination.size + '');\n        params = params.set('page', pagination.number + '');\n        return params;\n    }\n}\n"]}

package/esm5/lib/view/task-view/tabbed-task-view.js

@@ -0,0 +1,27 @@
+import { __extends } from "tslib";
+import { AbstractTaskView } from './abstract-task-view';
+import { TaskViewService } from './service/task-view.service';
+import { Inject } from '@angular/core';
+import { NAE_TAB_DATA } from '../../tabs/tab-data-injection-token/tab-data-injection-token';
+var TabbedTaskView = /** @class */ (function (_super) {
+    __extends(TabbedTaskView, _super);
+    function TabbedTaskView(taskViewService, _injectedTabData) {
+        var _this = _super.call(this, taskViewService) || this;
+        _this._injectedTabData = _injectedTabData;
+        _this.subTaskView = taskViewService.closeTab.subscribe(function () {
+            _injectedTabData.tabViewRef.closeTabIndex(_injectedTabData.tabViewRef.currentlySelectedTab());
+        });
+        return _this;
+    }
+    TabbedTaskView.prototype.ngOnDestroy = function () {
+        _super.prototype.ngOnDestroy.call(this);
+        this.subTaskView.unsubscribe();
+    };
+    TabbedTaskView.ctorParameters = function () { return [
+        { type: TaskViewService },
+        { type: undefined, decorators: [{ type: Inject, args: [NAE_TAB_DATA,] }] }
+    ]; };
+    return TabbedTaskView;
+}(AbstractTaskView));
+export { TabbedTaskView };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/view/tree-case-view/model/tree-petriflow-identifiers.js

@@ -0,0 +1,43 @@
+/**
+ * Contains the ids of the elements in Petriflow process that are used to represent the tree structure
+ */
+export var TreePetriflowIdentifiers;
+(function (TreePetriflowIdentifiers) {
+    /**
+     * Immediate case ref data variable that contains the children of this tree node
+     */
+    TreePetriflowIdentifiers["CHILDREN_CASE_REF"] = "treeChildCases";
+    /**
+     * Immediate boolean data variable that determines whether the option to can add new child nodes should be displayed.
+     *
+     * The type of node added is determined by the `allowedNets` property of the case ref field that holds the children
+     */
+    TreePetriflowIdentifiers["CAN_ADD_CHILDREN"] = "canAddTreeChildren";
+    /**
+     * Immediate text data variable that contains the id of the transition who's task should be displayed when the case node is selected.
+     */
+    TreePetriflowIdentifiers["FEATURED_TRANSITION"] = "treeTaskTransitionId";
+    /**
+     * Immediate boolean data variable that determines whether the option to remove this node from the tree should be displayed
+     */
+    TreePetriflowIdentifiers["CAN_REMOVE_NODE"] = "canRemoveTreeNode";
+    /**
+     * Immediate text data variable that contains the default case title for this node's children.
+     *
+     * If no value is provided an appropriate translation of 'New Node' will be used instead.
+     */
+    TreePetriflowIdentifiers["CHILD_NODE_TITLE"] = "childNodeCaseTitle";
+    /**
+     * Id of the transition that is executed to set the new child data
+     */
+    TreePetriflowIdentifiers["CASE_REF_TRANSITION"] = "treeCaseRefAccessor";
+    /**
+     * Before text icon
+     */
+    TreePetriflowIdentifiers["BEFORE_TEXT_ICON"] = "beforeTextIcon";
+    /**
+     * Add icon in tree
+     */
+    TreePetriflowIdentifiers["TREE_ADD_ICON"] = "treeAddIcon";
+})(TreePetriflowIdentifiers || (TreePetriflowIdentifiers = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS1wZXRyaWZsb3ctaWRlbnRpZmllcnMuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdmlldy90cmVlLWNhc2Utdmlldy9tb2RlbC90cmVlLXBldHJpZmxvdy1pZGVudGlmaWVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBTixJQUFZLHdCQXFDWDtBQXJDRCxXQUFZLHdCQUF3QjtJQUNoQzs7T0FFRztJQUNILGdFQUFvQyxDQUFBO0lBQ3BDOzs7O09BSUc7SUFDSCxtRUFBdUMsQ0FBQTtJQUN2Qzs7T0FFRztJQUNILHdFQUE0QyxDQUFBO0lBQzVDOztPQUVHO0lBQ0gsaUVBQXFDLENBQUE7SUFDckM7Ozs7T0FJRztJQUNILG1FQUF1QyxDQUFBO0lBQ3ZDOztPQUVHO0lBQ0gsdUVBQTJDLENBQUE7SUFDM0M7O09BRUc7SUFDSCwrREFBbUMsQ0FBQTtJQUNuQzs7T0FFRztJQUNILHlEQUE2QixDQUFBO0FBQ2pDLENBQUMsRUFyQ1csd0JBQXdCLEtBQXhCLHdCQUF3QixRQXFDbkMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvbnRhaW5zIHRoZSBpZHMgb2YgdGhlIGVsZW1lbnRzIGluIFBldHJpZmxvdyBwcm9jZXNzIHRoYXQgYXJlIHVzZWQgdG8gcmVwcmVzZW50IHRoZSB0cmVlIHN0cnVjdHVyZVxuICovXG5leHBvcnQgZW51bSBUcmVlUGV0cmlmbG93SWRlbnRpZmllcnMge1xuICAgIC8qKlxuICAgICAqIEltbWVkaWF0ZSBjYXNlIHJlZiBkYXRhIHZhcmlhYmxlIHRoYXQgY29udGFpbnMgdGhlIGNoaWxkcmVuIG9mIHRoaXMgdHJlZSBub2RlXG4gICAgICovXG4gICAgQ0hJTERSRU5fQ0FTRV9SRUYgPSAndHJlZUNoaWxkQ2FzZXMnLFxuICAgIC8qKlxuICAgICAqIEltbWVkaWF0ZSBib29sZWFuIGRhdGEgdmFyaWFibGUgdGhhdCBkZXRlcm1pbmVzIHdoZXRoZXIgdGhlIG9wdGlvbiB0byBjYW4gYWRkIG5ldyBjaGlsZCBub2RlcyBzaG91bGQgYmUgZGlzcGxheWVkLlxuICAgICAqXG4gICAgICogVGhlIHR5cGUgb2Ygbm9kZSBhZGRlZCBpcyBkZXRlcm1pbmVkIGJ5IHRoZSBgYWxsb3dlZE5ldHNgIHByb3BlcnR5IG9mIHRoZSBjYXNlIHJlZiBmaWVsZCB0aGF0IGhvbGRzIHRoZSBjaGlsZHJlblxuICAgICAqL1xuICAgIENBTl9BRERfQ0hJTERSRU4gPSAnY2FuQWRkVHJlZUNoaWxkcmVuJyxcbiAgICAvKipcbiAgICAgKiBJbW1lZGlhdGUgdGV4dCBkYXRhIHZhcmlhYmxlIHRoYXQgY29udGFpbnMgdGhlIGlkIG9mIHRoZSB0cmFuc2l0aW9uIHdobydzIHRhc2sgc2hvdWxkIGJlIGRpc3BsYXllZCB3aGVuIHRoZSBjYXNlIG5vZGUgaXMgc2VsZWN0ZWQuXG4gICAgICovXG4gICAgRkVBVFVSRURfVFJBTlNJVElPTiA9ICd0cmVlVGFza1RyYW5zaXRpb25JZCcsXG4gICAgLyoqXG4gICAgICogSW1tZWRpYXRlIGJvb2xlYW4gZGF0YSB2YXJpYWJsZSB0aGF0IGRldGVybWluZXMgd2hldGhlciB0aGUgb3B0aW9uIHRvIHJlbW92ZSB0aGlzIG5vZGUgZnJvbSB0aGUgdHJlZSBzaG91bGQgYmUgZGlzcGxheWVkXG4gICAgICovXG4gICAgQ0FOX1JFTU9WRV9OT0RFID0gJ2NhblJlbW92ZVRyZWVOb2RlJyxcbiAgICAvKipcbiAgICAgKiBJbW1lZGlhdGUgdGV4dCBkYXRhIHZhcmlhYmxlIHRoYXQgY29udGFpbnMgdGhlIGRlZmF1bHQgY2FzZSB0aXRsZSBmb3IgdGhpcyBub2RlJ3MgY2hpbGRyZW4uXG4gICAgICpcbiAgICAgKiBJZiBubyB2YWx1ZSBpcyBwcm92aWRlZCBhbiBhcHByb3ByaWF0ZSB0cmFuc2xhdGlvbiBvZiAnTmV3IE5vZGUnIHdpbGwgYmUgdXNlZCBpbnN0ZWFkLlxuICAgICAqL1xuICAgIENISUxEX05PREVfVElUTEUgPSAnY2hpbGROb2RlQ2FzZVRpdGxlJyxcbiAgICAvKipcbiAgICAgKiBJZCBvZiB0aGUgdHJhbnNpdGlvbiB0aGF0IGlzIGV4ZWN1dGVkIHRvIHNldCB0aGUgbmV3IGNoaWxkIGRhdGFcbiAgICAgKi9cbiAgICBDQVNFX1JFRl9UUkFOU0lUSU9OID0gJ3RyZWVDYXNlUmVmQWNjZXNzb3InLFxuICAgIC8qKlxuICAgICAqIEJlZm9yZSB0ZXh0IGljb25cbiAgICAgKi9cbiAgICBCRUZPUkVfVEVYVF9JQ09OID0gJ2JlZm9yZVRleHRJY29uJyxcbiAgICAvKipcbiAgICAgKiBBZGQgaWNvbiBpbiB0cmVlXG4gICAgICovXG4gICAgVFJFRV9BRERfSUNPTiA9ICd0cmVlQWRkSWNvbicsXG59XG4iXX0=