@netgrif/components-core 6.0.1

package/esm2015/lib/tabs/tab-creation-detector/abstract-tab-creation-detector.component.js

@@ -0,0 +1,17 @@
+import { Input } from '@angular/core';
+/**
+ * @ignore
+ * Class that detects tab content creation and then initializes then calls the provided `initializeTab` function.
+ * It is necessary if the tab content is lazy loaded, because the
+ * ComponentPortal's outlet must be initialized before the Portal itself is created.
+ */
+export class AbstractTabCreationDetectorComponent {
+    ngOnInit() {
+        this.initializeTabFunction(this.tabIndex);
+    }
+}
+AbstractTabCreationDetectorComponent.propDecorators = {
+    initializeTabFunction: [{ type: Input }],
+    tabIndex: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtdGFiLWNyZWF0aW9uLWRldGVjdG9yLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi90YWJzL3RhYi1jcmVhdGlvbi1kZXRlY3Rvci9hYnN0cmFjdC10YWItY3JlYXRpb24tZGV0ZWN0b3IuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxLQUFLLEVBQVMsTUFBTSxlQUFlLENBQUM7QUFFNUM7Ozs7O0dBS0c7QUFDSCxNQUFNLE9BQWdCLG9DQUFvQztJQVd0RCxRQUFRO1FBQ0osSUFBSSxDQUFDLHFCQUFxQixDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUM5QyxDQUFDOzs7b0NBUkEsS0FBSzt1QkFJTCxLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbnB1dCwgT25Jbml0fSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLyoqXG4gKiBAaWdub3JlXG4gKiBDbGFzcyB0aGF0IGRldGVjdHMgdGFiIGNvbnRlbnQgY3JlYXRpb24gYW5kIHRoZW4gaW5pdGlhbGl6ZXMgdGhlbiBjYWxscyB0aGUgcHJvdmlkZWQgYGluaXRpYWxpemVUYWJgIGZ1bmN0aW9uLlxuICogSXQgaXMgbmVjZXNzYXJ5IGlmIHRoZSB0YWIgY29udGVudCBpcyBsYXp5IGxvYWRlZCwgYmVjYXVzZSB0aGVcbiAqIENvbXBvbmVudFBvcnRhbCdzIG91dGxldCBtdXN0IGJlIGluaXRpYWxpemVkIGJlZm9yZSB0aGUgUG9ydGFsIGl0c2VsZiBpcyBjcmVhdGVkLlxuICovXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQWJzdHJhY3RUYWJDcmVhdGlvbkRldGVjdG9yQ29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0IHtcblxuICAgIC8qKlxuICAgICAqIGZ1bmN0aW9uIHRoYXQgc2hvdWxkIGJlIGNhbGxlZCB3aGVuIHRoZSB0YWIgY29udGVudCBpcyBjcmVhdGVkXG4gICAgICovXG4gICAgQElucHV0KCkgaW5pdGlhbGl6ZVRhYkZ1bmN0aW9uOiAoaW5kZXg6IG51bWJlcikgPT4gdm9pZDtcbiAgICAvKipcbiAgICAgKiBpbmRleCBvZiB0aGUgdGFiIHRoYXQgdGhlIGBpbml0aWFsaXplVGFiRnVuY3Rpb25gIHNob3VsZCBiZSBjYWxsZWQgZm9yXG4gICAgICovXG4gICAgQElucHV0KCkgdGFiSW5kZXg6IG51bWJlcjtcblxuICAgIG5nT25Jbml0KCkge1xuICAgICAgICB0aGlzLmluaXRpYWxpemVUYWJGdW5jdGlvbih0aGlzLnRhYkluZGV4KTtcbiAgICB9XG5cbn1cbiJdfQ==

package/esm2015/lib/tabs/tab-data-injection-token/tab-data-injection-token.js

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Injection token for injection of {@link InjectedTabData} into tabs in {@link TabView}.
+ *
+ * Also see {@link TabContent} for more information.
+ */
+export const NAE_TAB_DATA = new InjectionToken('NaeTabData');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFiLWRhdGEtaW5qZWN0aW9uLXRva2VuLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3RhYnMvdGFiLWRhdGEtaW5qZWN0aW9uLXRva2VuL3RhYi1kYXRhLWluamVjdGlvbi10b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsY0FBYyxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBRzdDOzs7O0dBSUc7QUFDSCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsSUFBSSxjQUFjLENBQWtCLFlBQVksQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3Rpb25Ub2tlbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0luamVjdGVkVGFiRGF0YX0gZnJvbSAnLi4vaW50ZXJmYWNlcyc7XG5cbi8qKlxuICogSW5qZWN0aW9uIHRva2VuIGZvciBpbmplY3Rpb24gb2Yge0BsaW5rIEluamVjdGVkVGFiRGF0YX0gaW50byB0YWJzIGluIHtAbGluayBUYWJWaWV3fS5cbiAqXG4gKiBBbHNvIHNlZSB7QGxpbmsgVGFiQ29udGVudH0gZm9yIG1vcmUgaW5mb3JtYXRpb24uXG4gKi9cbmV4cG9ydCBjb25zdCBOQUVfVEFCX0RBVEEgPSBuZXcgSW5qZWN0aW9uVG9rZW48SW5qZWN0ZWRUYWJEYXRhPignTmFlVGFiRGF0YScpO1xuIl19

package/esm2015/lib/tabs/tab-view/abstract-tab-view.component.js

@@ -0,0 +1,67 @@
+import { Input } from '@angular/core';
+import { TabView } from '../classes/tab-view';
+import { ReplaySubject } from 'rxjs';
+import { take } from 'rxjs/operators';
+/**
+ * Component that renders a tab view.
+ *
+ * See {@link TabView} for the class that holds the logic for this view.
+ */
+export class AbstractTabViewComponent {
+    constructor(_viewService, _logger, _injector) {
+        this._viewService = _viewService;
+        this._logger = _logger;
+        this._injector = _injector;
+        this.align = 'start';
+        this.offset = '';
+        /**
+         * @ignore
+         * lambda function that is passed to the {@link AbstractTabCreationDetectorComponent}s
+         */
+        this.initializeTabLambda = (index) => { this.tabView.initializeTab(index); };
+    }
+    ngOnInit() {
+        this.tabView = new TabView(this._viewService, this._logger, this.initialTabs, this._injector);
+    }
+    ngOnDestroy() {
+        this.tabView.openedTabs.forEach(tab => tab.destroy());
+    }
+    badgeHidden(tab) {
+        const stream$ = new ReplaySubject(1);
+        if (tab.label && tab.label.count) {
+            tab.label.count.pipe(take(1)).subscribe(() => {
+                stream$.next(false);
+                stream$.complete();
+            });
+        }
+        else {
+            stream$.next(true);
+            stream$.complete();
+        }
+        return stream$;
+    }
+    badgeCount(tab) {
+        const stream$ = new ReplaySubject(1);
+        if (tab.label && tab.label.count) {
+            tab.label.count.pipe(take(1)).subscribe(count => {
+                stream$.next(count + '');
+                this.setOffset((count + '').length);
+                stream$.complete();
+            });
+        }
+        else {
+            stream$.next('0');
+            stream$.complete();
+        }
+        return stream$;
+    }
+    setOffset(count) {
+        this.offset = Array(count * 2).join('\xa0');
+    }
+}
+AbstractTabViewComponent.propDecorators = {
+    initialTabs: [{ type: Input }],
+    stretch: [{ type: Input }],
+    align: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/task/interfaces/task-operations.js

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

package/esm2015/lib/task/models/null-task-operations.js

@@ -0,0 +1,26 @@
+/**
+ * Null implementation of the {@link TaskOperations} interface.
+ */
+export class NullTaskOperations {
+    /**
+     * Calling this function does nothing
+     */
+    close() {
+    }
+    /**
+     * Calling this function does nothing
+     */
+    open() {
+    }
+    /**
+     * Calling this function does nothing
+     */
+    reload() {
+    }
+    /**
+     * Calling this function does nothing
+     */
+    forceReload() {
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVsbC10YXNrLW9wZXJhdGlvbnMuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdGFzay9tb2RlbHMvbnVsbC10YXNrLW9wZXJhdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7O0dBRUc7QUFDSCxNQUFNLE9BQU8sa0JBQWtCO0lBQzNCOztPQUVHO0lBQ0gsS0FBSztJQUNMLENBQUM7SUFFRDs7T0FFRztJQUNILElBQUk7SUFDSixDQUFDO0lBRUQ7O09BRUc7SUFDSCxNQUFNO0lBQ04sQ0FBQztJQUVEOztPQUVHO0lBQ0gsV0FBVztJQUNYLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7VGFza09wZXJhdGlvbnN9IGZyb20gJy4uL2ludGVyZmFjZXMvdGFzay1vcGVyYXRpb25zJztcblxuLyoqXG4gKiBOdWxsIGltcGxlbWVudGF0aW9uIG9mIHRoZSB7QGxpbmsgVGFza09wZXJhdGlvbnN9IGludGVyZmFjZS5cbiAqL1xuZXhwb3J0IGNsYXNzIE51bGxUYXNrT3BlcmF0aW9ucyBpbXBsZW1lbnRzIFRhc2tPcGVyYXRpb25zIHtcbiAgICAvKipcbiAgICAgKiBDYWxsaW5nIHRoaXMgZnVuY3Rpb24gZG9lcyBub3RoaW5nXG4gICAgICovXG4gICAgY2xvc2UoKTogdm9pZCB7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogQ2FsbGluZyB0aGlzIGZ1bmN0aW9uIGRvZXMgbm90aGluZ1xuICAgICAqL1xuICAgIG9wZW4oKTogdm9pZCB7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogQ2FsbGluZyB0aGlzIGZ1bmN0aW9uIGRvZXMgbm90aGluZ1xuICAgICAqL1xuICAgIHJlbG9hZCgpOiB2b2lkIHtcbiAgICB9XG5cbiAgICAvKipcbiAgICAgKiBDYWxsaW5nIHRoaXMgZnVuY3Rpb24gZG9lcyBub3RoaW5nXG4gICAgICovXG4gICAgZm9yY2VSZWxvYWQoKTogdm9pZCB7XG4gICAgfVxufVxuIl19

package/esm2015/lib/task/models/subject-task-operations.js

@@ -0,0 +1,58 @@
+import { Subject } from 'rxjs';
+/**
+ * An implementation of the {@link TaskOperations} interface that provides a Subject for both operations.
+ */
+export class SubjectTaskOperations {
+    constructor() {
+        this._open = new Subject();
+        this._close = new Subject();
+        this._reload = new Subject();
+        this._forceReload = new Subject();
+    }
+    /**
+     * Emits into the [open$]{@link SubjectTaskOperations#open$} stream.
+     */
+    open() {
+        this._open.next();
+    }
+    /**
+     * Emits into the [close$]{@link SubjectTaskOperations#close$} stream.
+     */
+    close() {
+        this._close.next();
+    }
+    /**
+     * Emits into the [reload$]{@link SubjectTaskOperations#reload$} stream.
+     */
+    reload() {
+        this._reload.next();
+    }
+    /**
+     * Emits into the [forceReload$]{@link SubjectTaskOperations#forceReload$} stream.
+     */
+    forceReload() {
+        this._forceReload.next();
+    }
+    get open$() {
+        return this._open.asObservable();
+    }
+    get close$() {
+        return this._close.asObservable();
+    }
+    get reload$() {
+        return this._reload.asObservable();
+    }
+    get forceReload$() {
+        return this._forceReload.asObservable();
+    }
+    /**
+     * Completes the underlying streams
+     */
+    ngOnDestroy() {
+        this._open.complete();
+        this._close.complete();
+        this._reload.complete();
+        this._forceReload.complete();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/task/models/task-operations-injection-token.js

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const NAE_TASK_OPERATIONS = new InjectionToken('NaeTaskOperationsInterface');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1vcGVyYXRpb25zLWluamVjdGlvbi10b2tlbi5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi90YXNrL21vZGVscy90YXNrLW9wZXJhdGlvbnMtaW5qZWN0aW9uLXRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFHN0MsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsSUFBSSxjQUFjLENBQWlCLDRCQUE0QixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGlvblRva2VufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7VGFza09wZXJhdGlvbnN9IGZyb20gJy4uL2ludGVyZmFjZXMvdGFzay1vcGVyYXRpb25zJztcblxuZXhwb3J0IGNvbnN0IE5BRV9UQVNLX09QRVJBVElPTlMgPSBuZXcgSW5qZWN0aW9uVG9rZW48VGFza09wZXJhdGlvbnM+KCdOYWVUYXNrT3BlcmF0aW9uc0ludGVyZmFjZScpO1xuIl19

package/esm2015/lib/task/models/task-set-data-request-context.js

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

package/esm2015/lib/task/public-api.js

@@ -0,0 +1,19 @@
+/* SERVICES */
+export * from './services/assign-task.service';
+export * from './services/cancel-task.service';
+export * from './services/delegate-task.service';
+export * from './services/finish-task.service';
+export * from './services/task-request-state.service';
+export * from './services/task-data.service';
+export * from './services/data-focus-policy.service';
+export * from './services/assign-policy.service';
+export * from './services/finish-policy.service';
+export * from './services/task-handling-service';
+export * from './services/selected-case.service';
+/* MODELS */
+export * from './models/task-operations-injection-token';
+export * from './models/subject-task-operations';
+export * from './models/null-task-operations';
+/* INTERFACES */
+export * from './interfaces/task-operations';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi90YXNrL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxrQ0FBa0MsQ0FBQztBQUVqRCxZQUFZO0FBQ1osY0FBYywwQ0FBMEMsQ0FBQztBQUN6RCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsK0JBQStCLENBQUM7QUFFOUMsZ0JBQWdCO0FBQ2hCLGNBQWMsOEJBQThCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBTRVJWSUNFUyAqL1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcy9hc3NpZ24tdGFzay5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvY2FuY2VsLXRhc2suc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2RlbGVnYXRlLXRhc2suc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2ZpbmlzaC10YXNrLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcy90YXNrLXJlcXVlc3Qtc3RhdGUuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL3Rhc2stZGF0YS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvZGF0YS1mb2N1cy1wb2xpY3kuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2Fzc2lnbi1wb2xpY3kuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2ZpbmlzaC1wb2xpY3kuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL3Rhc2staGFuZGxpbmctc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL3NlbGVjdGVkLWNhc2Uuc2VydmljZSc7XG5cbi8qIE1PREVMUyAqL1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvdGFzay1vcGVyYXRpb25zLWluamVjdGlvbi10b2tlbic7XG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9zdWJqZWN0LXRhc2stb3BlcmF0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9udWxsLXRhc2stb3BlcmF0aW9ucyc7XG5cbi8qIElOVEVSRkFDRVMgKi9cbmV4cG9ydCAqIGZyb20gJy4vaW50ZXJmYWNlcy90YXNrLW9wZXJhdGlvbnMnO1xuIl19

package/esm2015/lib/task/services/assign-policy.service.js

@@ -0,0 +1,175 @@
+import { Inject, Injectable } from '@angular/core';
+import { AssignPolicy } from '../../task-content/model/policy';
+import { TaskHandlingService } from './task-handling-service';
+import { TaskContentService } from '../../task-content/services/task-content.service';
+import { TaskDataService } from './task-data.service';
+import { AssignTaskService } from './assign-task.service';
+import { CancelTaskService } from './cancel-task.service';
+import { FinishPolicyService } from './finish-policy.service';
+import { NAE_TASK_OPERATIONS } from '../models/task-operations-injection-token';
+import { CallChainService } from '../../utility/call-chain/call-chain.service';
+import { UserComparatorService } from '../../user/services/user-comparator.service';
+import { AfterAction } from '../../utility/call-chain/after-action';
+import { PermissionService } from '../../authorization/permission/permission.service';
+import { PermissionType } from '../../process/permissions';
+/**
+ * Handles the sequence of actions that are performed when a task is being assigned, based on the task's configuration.
+ */
+export class AssignPolicyService extends TaskHandlingService {
+    constructor(_taskDataService, _assignTaskService, _cancelTaskService, _finishPolicyService, _callchain, _userComparatorService, _taskOperations, taskContentService, _permissionService) {
+        super(taskContentService);
+        this._taskDataService = _taskDataService;
+        this._assignTaskService = _assignTaskService;
+        this._cancelTaskService = _cancelTaskService;
+        this._finishPolicyService = _finishPolicyService;
+        this._callchain = _callchain;
+        this._userComparatorService = _userComparatorService;
+        this._taskOperations = _taskOperations;
+        this._permissionService = _permissionService;
+        this._isForced = false;
+    }
+    get forced() {
+        return this._isForced;
+    }
+    set forced(bool) {
+        this._isForced = bool;
+    }
+    /**
+     * Performs the actions that correspond to the policy defined by the Task on it's assignment.
+     * @param taskOpened whether the Task was 'opened' (eg. task panel is expanding) or 'closed' (eg. task panel is collapsing)
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    performAssignPolicy(taskOpened, afterAction = new AfterAction()) {
+        if (this._safeTask.assignPolicy === AssignPolicy.auto
+            && this._permissionService.hasTaskPermission(this._safeTask, PermissionType.ASSIGN)) {
+            this.autoAssignPolicy(taskOpened, afterAction);
+        }
+        else {
+            this.manualAssignPolicy(taskOpened, afterAction);
+        }
+    }
+    /**
+     * Performs the actions that correspond to the [Auto Assign Policy]{@link AssignPolicy#auto}.
+     * @param taskOpened whether the Task was 'opened' (eg. task panel is expanding) or 'closed' (eg. task panel is collapsing)
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    autoAssignPolicy(taskOpened, afterAction) {
+        if (taskOpened) {
+            this.autoAssignOpenedPolicy(afterAction);
+        }
+        else {
+            this.autoAssignClosedPolicy(afterAction);
+        }
+    }
+    /**
+     * Performs the actions that correspond to the [Auto Assign Policy]{@link AssignPolicy#auto}
+     * when a task is 'opening' (eg. task panel is expanding).
+     *
+     * Assigns the task, reloads the current task page, loads task data and performs the finish policy.
+     *
+     * See [finish policy]{@link FinishPolicyService#performFinishPolicy} for more information.
+     *
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    autoAssignOpenedPolicy(afterAction) {
+        this._assignTaskService.assign(this._callchain.create((assignSuccess => {
+            this.afterAssignOpenPolicy(assignSuccess, afterAction);
+        })));
+    }
+    /**
+     * Reloads the current page of tasks if the preceding assign operation succeeded. Then initializes the task's data fields.
+     * @param assignSuccess whether the preceding assign succeeded or not
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    afterAssignOpenPolicy(assignSuccess, afterAction) {
+        if (!assignSuccess) {
+            afterAction.resolve(false);
+            return;
+        }
+        this._taskDataService.initializeTaskDataFields(this._callchain.create((requestSuccessful) => {
+            if (requestSuccessful) {
+                this._finishPolicyService.performFinishPolicy(afterAction);
+            }
+            else {
+                afterAction.resolve(false);
+            }
+        }), this._isForced);
+    }
+    /**
+     * Requests a reload of the task and then requests the task to be closed.
+     *
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    autoAssignClosedPolicy(afterAction) {
+        if (!this._userComparatorService.compareUsers(this._task.user)) {
+            this._taskOperations.close();
+            afterAction.next(false);
+            afterAction.complete();
+            return;
+        }
+        this._cancelTaskService.cancel(this._callchain.create((requestSuccess) => {
+            this._taskOperations.close();
+            afterAction.next(requestSuccess);
+            afterAction.complete();
+        }));
+    }
+    /**
+     * Performs the actions that correspond to the [Manual Assign Policy]{@link AssignPolicy#manual}.
+     * @param taskOpened whether the Task was 'opened' (eg. task panel is expanding) or 'closed' (eg. task panel is collapsing)
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    manualAssignPolicy(taskOpened, afterAction) {
+        if (taskOpened) {
+            this.manualAssignOpenedPolicy(afterAction);
+        }
+        else {
+            afterAction.resolve(false);
+        }
+    }
+    /**
+     * Performs the actions that correspond to the [Manual Assign Policy]{@link AssignPolicy#manual}
+     * when a task is 'opening' (eg. task panel is expanding).
+     *
+     * Loads task data and performs the [finish policy]{@link FinishPolicyService#performFinishPolicy}.
+     *
+     * See [finish policy]{@link FinishPolicyService#performFinishPolicy} for more information.
+     *
+     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes
+     */
+    manualAssignOpenedPolicy(afterAction) {
+        this._taskDataService.initializeTaskDataFields(this._callchain.create((requestSuccessful) => {
+            if (requestSuccessful) {
+                this._finishPolicyService.performFinishPolicy(afterAction);
+            }
+            else {
+                afterAction.resolve(false);
+            }
+        }), this._isForced);
+    }
+}
+AssignPolicyService.ctorParameters = () => [
+    { type: TaskDataService },
+    { type: AssignTaskService },
+    { type: CancelTaskService },
+    { type: FinishPolicyService },
+    { type: CallChainService },
+    { type: UserComparatorService },
+    { type: undefined, decorators: [{ type: Inject, args: [NAE_TASK_OPERATIONS,] }] },
+    { type: TaskContentService },
+    { type: PermissionService }
+];
+AssignPolicyService.decorators = [
+    { type: Injectable }
+];
+AssignPolicyService.ctorParameters = () => [
+    { type: TaskDataService },
+    { type: AssignTaskService },
+    { type: CancelTaskService },
+    { type: FinishPolicyService },
+    { type: CallChainService },
+    { type: UserComparatorService },
+    { type: undefined, decorators: [{ type: Inject, args: [NAE_TASK_OPERATIONS,] }] },
+    { type: TaskContentService },
+    { type: PermissionService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assign-policy.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/task/services/assign-policy.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAE,UAAU,EAAC,MAAM,eAAe,CAAC;AACjD,OAAO,EAAC,YAAY,EAAC,MAAM,iCAAiC,CAAC;AAC7D,OAAO,EAAC,mBAAmB,EAAC,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAC,kBAAkB,EAAC,MAAM,kDAAkD,CAAC;AACpF,OAAO,EAAC,eAAe,EAAC,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAC,iBAAiB,EAAC,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAC,iBAAiB,EAAC,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAC,mBAAmB,EAAC,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAC,mBAAmB,EAAC,MAAM,2CAA2C,CAAC;AAE9E,OAAO,EAAC,gBAAgB,EAAC,MAAM,6CAA6C,CAAC;AAE7E,OAAO,EAAC,qBAAqB,EAAC,MAAM,6CAA6C,CAAC;AAClF,OAAO,EAAC,WAAW,EAAC,MAAM,uCAAuC,CAAC;AAClE,OAAO,EAAC,iBAAiB,EAAC,MAAM,mDAAmD,CAAC;AACpF,OAAO,EAAC,cAAc,EAAC,MAAM,2BAA2B,CAAC;AAEzD;;GAEG;AAEH,MAAM,OAAO,mBAAoB,SAAQ,mBAAmB;IAIxD,YAAsB,gBAAiC,EACjC,kBAAqC,EACrC,kBAAqC,EACrC,oBAAyC,EACzC,UAA4B,EAC5B,sBAA6C,EAChB,eAA+B,EACtE,kBAAsC,EAC5B,kBAAqC;QACvD,KAAK,CAAC,kBAAkB,CAAC,CAAC;QATR,qBAAgB,GAAhB,gBAAgB,CAAiB;QACjC,uBAAkB,GAAlB,kBAAkB,CAAmB;QACrC,uBAAkB,GAAlB,kBAAkB,CAAmB;QACrC,yBAAoB,GAApB,oBAAoB,CAAqB;QACzC,eAAU,GAAV,UAAU,CAAkB;QAC5B,2BAAsB,GAAtB,sBAAsB,CAAuB;QAChB,oBAAe,GAAf,eAAe,CAAgB;QAE5D,uBAAkB,GAAlB,kBAAkB,CAAmB;QAVnD,cAAS,GAAG,KAAK,CAAC;IAY1B,CAAC;IAED,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAED,IAAI,MAAM,CAAC,IAAa;QACpB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;IAC1B,CAAC;IAED;;;;OAIG;IACI,mBAAmB,CAAC,UAAmB,EAAE,cAA2B,IAAI,WAAW,EAAE;QACxF,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,KAAK,YAAY,CAAC,IAAI;eAC9C,IAAI,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,IAAI,CAAC,SAAS,EAAE,cAAc,CAAC,MAAM,CAAC,EAAE;YACrF,IAAI,CAAC,gBAAgB,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;SAClD;aAAM;YACH,IAAI,CAAC,kBAAkB,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;SACpD;IACL,CAAC;IAED;;;;OAIG;IACO,gBAAgB,CAAC,UAAmB,EAAE,WAAwB;QACpE,IAAI,UAAU,EAAE;YACZ,IAAI,CAAC,sBAAsB,CAAC,WAAW,CAAC,CAAC;SAC5C;aAAM;YACH,IAAI,CAAC,sBAAsB,CAAC,WAAW,CAAC,CAAC;SAC5C;IACL,CAAC;IAED;;;;;;;;;OASG;IACO,sBAAsB,CAAC,WAAwB;QACrD,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAC1B,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,EAAE;YACpC,IAAI,CAAC,qBAAqB,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;QAC3D,CAAC,CAAC,CAAC,CACN,CAAC;IACN,CAAC;IAED;;;;OAIG;IACO,qBAAqB,CAAC,aAAsB,EAAE,WAAwB;QAC5E,IAAI,CAAC,aAAa,EAAE;YAChB,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC3B,OAAO;SACV;QAED,IAAI,CAAC,gBAAgB,CAAC,wBAAwB,CAC1C,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,iBAAiB,EAAE,EAAE;YACzC,IAAI,iBAAiB,EAAE;gBACnB,IAAI,CAAC,oBAAoB,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;aAC9D;iBAAM;gBACH,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;aAC9B;QACL,CAAC,CAAC,EACF,IAAI,CAAC,SAAS,CACjB,CAAC;IACN,CAAC;IAED;;;;OAIG;IACO,sBAAsB,CAAC,WAA6B;QAC1D,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;YAC5D,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC;YAC7B,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACxB,WAAW,CAAC,QAAQ,EAAE,CAAC;YACvB,OAAO;SACd;QACG,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAC1B,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,cAAc,EAAE,EAAE;YACtC,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC;YAC7B,WAAW,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YACjC,WAAW,CAAC,QAAQ,EAAE,CAAC;QAC3B,CAAC,CAAC,CACL,CAAC;IACN,CAAC;IAED;;;;OAIG;IACO,kBAAkB,CAAC,UAAmB,EAAE,WAAwB;QACtE,IAAI,UAAU,EAAE;YACZ,IAAI,CAAC,wBAAwB,CAAC,WAAW,CAAC,CAAC;SAC9C;aAAM;YACH,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;SAC9B;IACL,CAAC;IAED;;;;;;;;;OASG;IACO,wBAAwB,CAAC,WAAwB;QACvD,IAAI,CAAC,gBAAgB,CAAC,wBAAwB,CAC1C,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,iBAAiB,EAAE,EAAE;YACzC,IAAI,iBAAiB,EAAE;gBACnB,IAAI,CAAC,oBAAoB,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;aAC9D;iBAAM;gBACH,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;aAC9B;QACL,CAAC,CAAC,EACF,IAAI,CAAC,SAAS,CACjB,CAAC;IACN,CAAC;;;YA/IuC,eAAe;YACb,iBAAiB;YACjB,iBAAiB;YACf,mBAAmB;YAC7B,gBAAgB;YACJ,qBAAqB;4CACtD,MAAM,SAAC,mBAAmB;YACP,kBAAkB;YACR,iBAAiB;;;YAb9D,UAAU;;;YAhBH,eAAe;YACf,iBAAiB;YACjB,iBAAiB;YACjB,mBAAmB;YAGnB,gBAAgB;YAEhB,qBAAqB;4CAmBZ,MAAM,SAAC,mBAAmB;YA5BnC,kBAAkB;YAWlB,iBAAiB","sourcesContent":["import {Inject, Injectable} from '@angular/core';\nimport {AssignPolicy} from '../../task-content/model/policy';\nimport {TaskHandlingService} from './task-handling-service';\nimport {TaskContentService} from '../../task-content/services/task-content.service';\nimport {TaskDataService} from './task-data.service';\nimport {AssignTaskService} from './assign-task.service';\nimport {CancelTaskService} from './cancel-task.service';\nimport {FinishPolicyService} from './finish-policy.service';\nimport {NAE_TASK_OPERATIONS} from '../models/task-operations-injection-token';\nimport {TaskOperations} from '../interfaces/task-operations';\nimport {CallChainService} from '../../utility/call-chain/call-chain.service';\nimport {Subject} from 'rxjs';\nimport {UserComparatorService} from '../../user/services/user-comparator.service';\nimport {AfterAction} from '../../utility/call-chain/after-action';\nimport {PermissionService} from '../../authorization/permission/permission.service';\nimport {PermissionType} from '../../process/permissions';\n\n/**\n * Handles the sequence of actions that are performed when a task is being assigned, based on the task's configuration.\n */\n@Injectable()\nexport class AssignPolicyService extends TaskHandlingService {\n\n    private _isForced = false;\n\n    constructor(protected _taskDataService: TaskDataService,\n                protected _assignTaskService: AssignTaskService,\n                protected _cancelTaskService: CancelTaskService,\n                protected _finishPolicyService: FinishPolicyService,\n                protected _callchain: CallChainService,\n                protected _userComparatorService: UserComparatorService,\n                @Inject(NAE_TASK_OPERATIONS) protected _taskOperations: TaskOperations,\n                taskContentService: TaskContentService,\n                protected _permissionService: PermissionService) {\n        super(taskContentService);\n    }\n\n    get forced() {\n        return this._isForced;\n    }\n\n    set forced(bool: boolean) {\n        this._isForced = bool;\n    }\n\n    /**\n     * Performs the actions that correspond to the policy defined by the Task on it's assignment.\n     * @param taskOpened whether the Task was 'opened' (eg. task panel is expanding) or 'closed' (eg. task panel is collapsing)\n     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes\n     */\n    public performAssignPolicy(taskOpened: boolean, afterAction: AfterAction = new AfterAction()): void {\n        if (this._safeTask.assignPolicy === AssignPolicy.auto\n            && this._permissionService.hasTaskPermission(this._safeTask, PermissionType.ASSIGN)) {\n            this.autoAssignPolicy(taskOpened, afterAction);\n        } else {\n            this.manualAssignPolicy(taskOpened, afterAction);\n        }\n    }\n\n    /**\n     * Performs the actions that correspond to the [Auto Assign Policy]{@link AssignPolicy#auto}.\n     * @param taskOpened whether the Task was 'opened' (eg. task panel is expanding) or 'closed' (eg. task panel is collapsing)\n     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes\n     */\n    protected autoAssignPolicy(taskOpened: boolean, afterAction: AfterAction): void {\n        if (taskOpened) {\n            this.autoAssignOpenedPolicy(afterAction);\n        } else {\n            this.autoAssignClosedPolicy(afterAction);\n        }\n    }\n\n    /**\n     * Performs the actions that correspond to the [Auto Assign Policy]{@link AssignPolicy#auto}\n     * when a task is 'opening' (eg. task panel is expanding).\n     *\n     * Assigns the task, reloads the current task page, loads task data and performs the finish policy.\n     *\n     * See [finish policy]{@link FinishPolicyService#performFinishPolicy} for more information.\n     *\n     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes\n     */\n    protected autoAssignOpenedPolicy(afterAction: AfterAction): void {\n        this._assignTaskService.assign(\n            this._callchain.create((assignSuccess => {\n                this.afterAssignOpenPolicy(assignSuccess, afterAction);\n            }))\n        );\n    }\n\n    /**\n     * Reloads the current page of tasks if the preceding assign operation succeeded. Then initializes the task's data fields.\n     * @param assignSuccess whether the preceding assign succeeded or not\n     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes\n     */\n    protected afterAssignOpenPolicy(assignSuccess: boolean, afterAction: AfterAction): void {\n        if (!assignSuccess) {\n            afterAction.resolve(false);\n            return;\n        }\n\n        this._taskDataService.initializeTaskDataFields(\n            this._callchain.create((requestSuccessful) => {\n                if (requestSuccessful) {\n                    this._finishPolicyService.performFinishPolicy(afterAction);\n                } else {\n                    afterAction.resolve(false);\n                }\n            }),\n            this._isForced\n        );\n    }\n\n    /**\n     * Requests a reload of the task and then requests the task to be closed.\n     *\n     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes\n     */\n    protected autoAssignClosedPolicy(afterAction: Subject<boolean>): void {\n        if (!this._userComparatorService.compareUsers(this._task.user)) {\n            this._taskOperations.close();\n            afterAction.next(false);\n            afterAction.complete();\n            return;\n    }\n        this._cancelTaskService.cancel(\n            this._callchain.create((requestSuccess) => {\n                this._taskOperations.close();\n                afterAction.next(requestSuccess);\n                afterAction.complete();\n            })\n        );\n    }\n\n    /**\n     * Performs the actions that correspond to the [Manual Assign Policy]{@link AssignPolicy#manual}.\n     * @param taskOpened whether the Task was 'opened' (eg. task panel is expanding) or 'closed' (eg. task panel is collapsing)\n     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes\n     */\n    protected manualAssignPolicy(taskOpened: boolean, afterAction: AfterAction): void {\n        if (taskOpened) {\n            this.manualAssignOpenedPolicy(afterAction);\n        } else {\n            afterAction.resolve(false);\n        }\n    }\n\n    /**\n     * Performs the actions that correspond to the [Manual Assign Policy]{@link AssignPolicy#manual}\n     * when a task is 'opening' (eg. task panel is expanding).\n     *\n     * Loads task data and performs the [finish policy]{@link FinishPolicyService#performFinishPolicy}.\n     *\n     * See [finish policy]{@link FinishPolicyService#performFinishPolicy} for more information.\n     *\n     * @param afterAction the action that should be performed when the assign policy (and all following policies) finishes\n     */\n    protected manualAssignOpenedPolicy(afterAction: AfterAction): void {\n        this._taskDataService.initializeTaskDataFields(\n            this._callchain.create((requestSuccessful) => {\n                if (requestSuccessful) {\n                    this._finishPolicyService.performFinishPolicy(afterAction);\n                } else {\n                    afterAction.resolve(false);\n                }\n            }),\n            this._isForced\n        );\n    }\n}\n"]}