@netgrif/components-core 6.0.1

package/esm5/lib/view/case-view/components/case-list/abstract-case-list.component.js

@@ -0,0 +1,92 @@
+import { __extends } from "tslib";
+import { EventEmitter, Inject, Input, Optional, Output, ViewChild } from '@angular/core';
+import { CaseViewService } from '../../service/case-view-service';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { Subject } from 'rxjs';
+import { LoggerService } from '../../../../logger/services/logger.service';
+import { TabbedVirtualScrollComponent } from '../../../../panel/abstract/tabbed-virtual-scroll.component';
+import { NAE_TAB_DATA } from '../../../../tabs/tab-data-injection-token/tab-data-injection-token';
+import { ActivatedRoute } from '@angular/router';
+import { filter, takeUntil } from 'rxjs/operators';
+var AbstractCaseListComponent = /** @class */ (function (_super) {
+    __extends(AbstractCaseListComponent, _super);
+    function AbstractCaseListComponent(_caseViewService, _log, injectedTabData, route) {
+        var _this = _super.call(this, injectedTabData) || this;
+        _this._caseViewService = _caseViewService;
+        _this._log = _log;
+        _this.route = route;
+        _this.responsiveBody = true;
+        _this.showCasePanelIcon = true;
+        _this.showDeleteMenu = false;
+        _this.textEllipsis = false;
+        _this.redirectEnabled = true;
+        _this.cases$ = _this._caseViewService.cases$;
+        _this.unsubscribe$ = new Subject();
+        _this.loading$ = _this._caseViewService.loading$;
+        _this.caseClick = new EventEmitter();
+        _this.onRedirect();
+        return _this;
+    }
+    AbstractCaseListComponent.prototype.ngOnDestroy = function () {
+        _super.prototype.ngOnDestroy.call(this);
+        this.caseClick.complete();
+        this.unsubscribe$.complete();
+    };
+    AbstractCaseListComponent.prototype.trackBy = function (i) {
+        return i;
+    };
+    Object.defineProperty(AbstractCaseListComponent.prototype, "loadedDataSize", {
+        get: function () {
+            return this.viewport && this.viewport.getDataLength() ? this.viewport.getDataLength() : 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AbstractCaseListComponent.prototype.loadNextPage = function () {
+        if (!this.viewport) {
+            return;
+        }
+        this._caseViewService.nextPage(this.viewport.getRenderedRange(), this.viewport.getDataLength());
+    };
+    AbstractCaseListComponent.prototype.onCaseClick = function (case_) {
+        this.caseClick.emit(case_);
+    };
+    AbstractCaseListComponent.prototype.onRedirect = function () {
+        var _this = this;
+        if (!this.redirectEnabled) {
+            return;
+        }
+        this.route.queryParams.pipe(filter(function (pm) { return !!pm['caseId']; })).subscribe(function (paramMap) {
+            _this.redirectCaseId = paramMap['caseId'];
+            _this.cases$.pipe(takeUntil(_this.unsubscribe$)).subscribe(function (cases) {
+                if (cases !== undefined && cases.length > 0) {
+                    var _case = cases.find(function (c) { return c.stringId === _this.redirectCaseId; });
+                    if (_case !== undefined) {
+                        _this.caseClick.emit(_case);
+                        _this.unsubscribe$.next();
+                    }
+                }
+            });
+        });
+    };
+    AbstractCaseListComponent.ctorParameters = function () { return [
+        { type: CaseViewService },
+        { type: LoggerService },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_TAB_DATA,] }] },
+        { type: ActivatedRoute }
+    ]; };
+    AbstractCaseListComponent.propDecorators = {
+        selectedHeaders$: [{ type: Input }],
+        responsiveBody: [{ type: Input }],
+        caseClick: [{ type: Output }],
+        showCasePanelIcon: [{ type: Input }],
+        showDeleteMenu: [{ type: Input }],
+        textEllipsis: [{ type: Input }],
+        width: [{ type: Input }],
+        redirectEnabled: [{ type: Input }],
+        viewport: [{ type: ViewChild, args: [CdkVirtualScrollViewport,] }]
+    };
+    return AbstractCaseListComponent;
+}(TabbedVirtualScrollComponent));
+export { AbstractCaseListComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-case-list.component.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/view/case-view/components/case-list/abstract-case-list.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    EventEmitter,\n    Inject,\n    Input,\n    OnDestroy,\n    Optional,\n    Output,\n    ViewChild\n} from '@angular/core';\nimport {CaseViewService} from '../../service/case-view-service';\nimport {CdkVirtualScrollViewport} from '@angular/cdk/scrolling';\nimport {Observable, Subject} from 'rxjs';\nimport {Case} from '../../../../resources/interface/case';\nimport {HeaderColumn} from '../../../../header/models/header-column';\nimport {LoggerService} from '../../../../logger/services/logger.service';\nimport {TabbedVirtualScrollComponent} from '../../../../panel/abstract/tabbed-virtual-scroll.component';\nimport {NAE_TAB_DATA} from '../../../../tabs/tab-data-injection-token/tab-data-injection-token';\nimport {InjectedTabData} from '../../../../tabs/interfaces';\nimport {ActivatedRoute} from '@angular/router';\nimport {filter, takeUntil} from 'rxjs/operators';\n\nexport abstract class AbstractCaseListComponent extends TabbedVirtualScrollComponent implements OnDestroy {\n\n    @Input() selectedHeaders$: Observable<Array<HeaderColumn>>;\n    @Input() responsiveBody = true;\n    @Output() caseClick: EventEmitter<Case>;\n    @Input() showCasePanelIcon = true;\n    @Input() showDeleteMenu = false;\n    @Input() textEllipsis = false;\n    @Input() width: string;\n    @Input() redirectEnabled = true;\n\n    @ViewChild(CdkVirtualScrollViewport) public viewport: CdkVirtualScrollViewport;\n    public cases$: Observable<Array<Case>>;\n    public loading$: Observable<boolean>;\n    private redirectCaseId: string;\n    private unsubscribe$: Subject<void>;\n\n    protected constructor(protected _caseViewService: CaseViewService,\n                          protected _log: LoggerService,\n                          @Optional() @Inject(NAE_TAB_DATA) injectedTabData: InjectedTabData,\n                          protected route?: ActivatedRoute) {\n        super(injectedTabData);\n        this.cases$ = this._caseViewService.cases$;\n        this.unsubscribe$ = new Subject<void>();\n        this.loading$ = this._caseViewService.loading$;\n        this.caseClick = new EventEmitter<Case>();\n        this.onRedirect();\n    }\n\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this.caseClick.complete();\n        this.unsubscribe$.complete();\n    }\n\n    public trackBy(i): any {\n        return i;\n    }\n\n    public get loadedDataSize(): number {\n        return this.viewport && this.viewport.getDataLength() ? this.viewport.getDataLength() : 0;\n    }\n\n    public loadNextPage(): void {\n        if (!this.viewport) {\n            return;\n        }\n        this._caseViewService.nextPage(this.viewport.getRenderedRange(), this.viewport.getDataLength());\n    }\n\n    public onCaseClick(case_: Case) {\n        this.caseClick.emit(case_);\n    }\n\n    public onRedirect() {\n        if (!this.redirectEnabled) {\n            return;\n        }\n\n        this.route.queryParams.pipe(filter(pm => !!pm['caseId'])).subscribe(paramMap => {\n               this.redirectCaseId = paramMap['caseId'];\n               this.cases$.pipe(takeUntil(this.unsubscribe$)).subscribe(cases => {\n                   if (cases !== undefined && cases.length > 0) {\n                       const _case = cases.find(c => c.stringId === this.redirectCaseId);\n                       if (_case !== undefined) {\n                           this.caseClick.emit(_case);\n                           this.unsubscribe$.next();\n                       }\n                   }\n               });\n        });\n    }\n\n}\n"]}

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

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

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

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

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

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Can be used to provide case views with configuration of the {@link CaseViewService#createNewCase}[createNewCase()] method without
+ * having to extend the service and override the method.
+ */
+export var NAE_NEW_CASE_CONFIGURATION = new InjectionToken('NaeNewCaseConfiguration');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV3LWNhc2UtY29uZmlndXJhdGlvbi1pbmplY3Rpb24tdG9rZW4uanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdmlldy9jYXNlLXZpZXcvbW9kZWxzL25ldy1jYXNlLWNvbmZpZ3VyYXRpb24taW5qZWN0aW9uLXRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxjQUFjLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFHN0M7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLElBQU0sMEJBQTBCLEdBQUcsSUFBSSxjQUFjLENBQXVCLHlCQUF5QixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGlvblRva2VufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7TmV3Q2FzZUNvbmZpZ3VyYXRpb259IGZyb20gJy4vbmV3LWNhc2UtY29uZmlndXJhdGlvbic7XG5cbi8qKlxuICogQ2FuIGJlIHVzZWQgdG8gcHJvdmlkZSBjYXNlIHZpZXdzIHdpdGggY29uZmlndXJhdGlvbiBvZiB0aGUge0BsaW5rIENhc2VWaWV3U2VydmljZSNjcmVhdGVOZXdDYXNlfVtjcmVhdGVOZXdDYXNlKCldIG1ldGhvZCB3aXRob3V0XG4gKiBoYXZpbmcgdG8gZXh0ZW5kIHRoZSBzZXJ2aWNlIGFuZCBvdmVycmlkZSB0aGUgbWV0aG9kLlxuICovXG5leHBvcnQgY29uc3QgTkFFX05FV19DQVNFX0NPTkZJR1VSQVRJT04gPSBuZXcgSW5qZWN0aW9uVG9rZW48TmV3Q2FzZUNvbmZpZ3VyYXRpb24+KCdOYWVOZXdDYXNlQ29uZmlndXJhdGlvbicpO1xuIl19

package/esm5/lib/view/case-view/models/new-case-configuration.js

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

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

@@ -0,0 +1,300 @@
+import { __assign, __extends } from "tslib";
+import { Inject, Injectable, Optional } from '@angular/core';
+import { SideMenuService } from '../../../side-menu/services/side-menu.service';
+import { CaseResourceService } from '../../../resources/engine-endpoint/case-resource.service';
+import { BehaviorSubject, of, Subject } from 'rxjs';
+import { HttpParams } from '@angular/common/http';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { SnackBarService } from '../../../snack-bar/services/snack-bar.service';
+import { SearchService } from '../../../search/search-service/search.service';
+import { SideMenuSize } from '../../../side-menu/models/side-menu-size';
+import { TranslateService } from '@ngx-translate/core';
+import { catchError, concatMap, filter, map, mergeMap, scan, switchMap, tap } from 'rxjs/operators';
+import { CaseMetaField } from '../../../header/case-header/case-menta-enum';
+import { NAE_NEW_CASE_COMPONENT } from '../../../side-menu/content-components/injection-tokens';
+import { PageLoadRequestContext } from '../../abstract/page-load-request-context';
+import { LoadingWithFilterEmitter } from '../../../utility/loading-with-filter-emitter';
+import { UserService } from '../../../user/services/user.service';
+import { arrayToObservable } from '../../../utility/array-to-observable';
+import { PermissionType } from '../../../process/permissions';
+import { NAE_NEW_CASE_CONFIGURATION } from '../models/new-case-configuration-injection-token';
+import { ProcessService } from '../../../process/process.service';
+import { SearchIndexResolverService } from '../../../search/search-keyword-resolver-service/search-index-resolver.service';
+import { AllowedNetsService } from '../../../allowed-nets/services/allowed-nets.service';
+import { SortableView } from '../../abstract/sortable-view';
+import { PermissionService } from '../../../authorization/permission/permission.service';
+var CaseViewService = /** @class */ (function (_super) {
+    __extends(CaseViewService, _super);
+    function CaseViewService(_allowedNetsService, _sideMenuService, _caseResourceService, _log, _snackBarService, _searchService, _translate, _user, _processService, resolver, _newCaseComponent, newCaseConfig, _permissionService) {
+        var _this = _super.call(this, resolver) || this;
+        _this._allowedNetsService = _allowedNetsService;
+        _this._sideMenuService = _sideMenuService;
+        _this._caseResourceService = _caseResourceService;
+        _this._log = _log;
+        _this._snackBarService = _snackBarService;
+        _this._searchService = _searchService;
+        _this._translate = _translate;
+        _this._user = _user;
+        _this._processService = _processService;
+        _this._newCaseComponent = _newCaseComponent;
+        _this._permissionService = _permissionService;
+        _this.DEFAULT_NEW_CASE_CONFIGURATION = {
+            useCachedProcesses: true
+        };
+        _this._newCaseConfiguration = __assign({}, _this.DEFAULT_NEW_CASE_CONFIGURATION);
+        if (newCaseConfig !== null) {
+            Object.assign(_this._newCaseConfiguration, newCaseConfig);
+        }
+        _this._loading$ = new LoadingWithFilterEmitter();
+        _this._searchService.activeFilter$.subscribe(function () {
+            _this.reload();
+        });
+        _this._endOfData = false;
+        _this._pagination = {
+            size: 25,
+            totalElements: undefined,
+            totalPages: undefined,
+            number: -1
+        };
+        _this._nextPage$ = new BehaviorSubject(new PageLoadRequestContext(_this.activeFilter, Object.assign({}, _this._pagination, { number: 0 })));
+        var casesMap = _this._nextPage$.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 = [{ cases: {}, requestContext: null }, pageLoadResult];
+                return arrayToObservable(results);
+            }
+            else {
+                return of(pageLoadResult);
+            }
+        }), concatMap(function (o) { return o; }), scan(function (acc, pageLoadResult) {
+            if (pageLoadResult.requestContext === null) {
+                return pageLoadResult.cases;
+            }
+            else {
+                _this._loading$.off(pageLoadResult.requestContext.filter);
+            }
+            Object.assign(_this._pagination, pageLoadResult.requestContext.pagination);
+            return __assign(__assign({}, acc), pageLoadResult.cases);
+        }, {}));
+        _this._cases$ = casesMap.pipe(map(function (v) { return Object.values(v); }));
+        return _this;
+    }
+    CaseViewService.prototype.ngOnDestroy = function () {
+        _super.prototype.ngOnDestroy.call(this);
+        this._loading$.complete();
+        this._nextPage$.complete();
+    };
+    Object.defineProperty(CaseViewService.prototype, "loading", {
+        get: function () {
+            return this._loading$.isActive;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CaseViewService.prototype, "loading$", {
+        get: function () {
+            return this._loading$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CaseViewService.prototype, "cases$", {
+        get: function () {
+            return this._cases$;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CaseViewService.prototype, "activeFilter", {
+        get: function () {
+            return this._searchService.activeFilter;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CaseViewService.prototype.loadPage = function (requestContext) {
+        var _this = this;
+        if (requestContext === null || requestContext.pageNumber < 0) {
+            return of({ cases: {}, requestContext: requestContext });
+        }
+        var params = new HttpParams();
+        params = this.addSortParams(params);
+        params = this.addPageParams(params, requestContext.pagination);
+        this._loading$.on(requestContext.filter);
+        return this._caseResourceService.searchCases(requestContext.filter, params).pipe(catchError(function (err) {
+            _this._log.error('Loading cases 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 cases page is no longer relevant since the active filter has changed before it could arrive.'
+                    + ' Discarding...');
+            }
+            return r;
+        }), tap(function (c) {
+            Object.assign(requestContext.pagination, c.pagination);
+        }), tap(function (c) {
+            _this._endOfData = !Array.isArray(c.content)
+                || c.content.length === 0
+                || c.pagination.number === c.pagination.totalPages;
+        }), map(function (cases) { return Array.isArray(cases.content) ? cases : __assign(__assign({}, cases), { content: [] }); }), map(function (cases) {
+            return cases.content.reduce(function (acc, cur) {
+                var _a;
+                return __assign(__assign({}, acc), (_a = {}, _a[cur.stringId] = cur, _a));
+            }, {});
+        }), map(function (cases) { return ({ cases: cases, requestContext: requestContext }); }));
+    };
+    CaseViewService.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._nextPage$.next(requestContext);
+        }
+    };
+    CaseViewService.prototype.isLoadingRelevantFilter = function (requestContext) {
+        return requestContext === undefined || this._loading$.isActiveWithFilter(requestContext.filter);
+    };
+    CaseViewService.prototype.createNewCase = function (newCaseCreationConfiguration) {
+        var _this = this;
+        if (newCaseCreationConfiguration === void 0) { newCaseCreationConfiguration = {
+            enableCaseTitle: true,
+            isCaseTitleRequired: true
+        }; }
+        var myCase = new Subject();
+        this._sideMenuService.open(this._newCaseComponent, SideMenuSize.MEDIUM, {
+            allowedNets$: this.getNewCaseAllowedNets(),
+            newCaseCreationConfiguration: newCaseCreationConfiguration
+        }).onClose.subscribe(function ($event) {
+            _this._log.debug($event.message, $event.data);
+            if ($event.data) {
+                _this.reload();
+                myCase.next($event.data);
+            }
+            myCase.complete();
+        });
+        return myCase.asObservable();
+    };
+    CaseViewService.prototype.createDefaultNewCase = function () {
+        var _this = this;
+        var myCase = new Subject();
+        this.getNewCaseAllowedNets().subscribe(function (nets) {
+            _this._caseResourceService.createCase({
+                title: null,
+                color: 'panel-primary-icon',
+                netId: nets[0].stringId
+            }).subscribe(function (response) {
+                _this._snackBarService.openSuccessSnackBar(_this._translate.instant('side-menu.new-case.createCase')
+                    + ' ' + _this._translate.instant('side-menu.new-case.defaultCaseName'));
+                _this.reload();
+                myCase.next(response.outcome.aCase);
+                myCase.complete();
+            }, function (error) { return _this._snackBarService.openErrorSnackBar(error.message ? error.message : error); });
+        });
+        return myCase;
+    };
+    CaseViewService.prototype.getNewCaseAllowedNets = function () {
+        var _this = this;
+        if (this._newCaseConfiguration.useCachedProcesses) {
+            return this._allowedNetsService.allowedNets$.pipe(map(function (net) { return net.filter(function (n) { return _this._permissionService.hasNetPermission(PermissionType.CREATE, n); }); }));
+        }
+        else {
+            return this._allowedNetsService.allowedNets$.pipe(switchMap(function (allowedNets) {
+                return _this._processService.getNetReferences(allowedNets.map(function (net) { return net.identifier; })).pipe(map(function (net) { return net.filter(function (n) { return _this._permissionService.hasNetPermission(PermissionType.CREATE, n); }); }));
+            }));
+        }
+    };
+    /**
+     * Returns number of allowed nets of case view
+     * @returns length of allowedNets array if it is defined, 0 if it is undefined
+     */
+    CaseViewService.prototype.getAllowedNetsCount = function () {
+        return this._allowedNetsService.allowedNets === undefined ? 0 : this._allowedNetsService.allowedNets.length;
+    };
+    CaseViewService.prototype.addPageParams = function (params, pagination) {
+        params = params.set('size', pagination.size + '');
+        params = params.set('page', pagination.number + '');
+        return params;
+    };
+    CaseViewService.prototype.getDefaultSortParam = function () {
+        return 'stringId,desc';
+    };
+    CaseViewService.prototype.getMetaFieldSortId = function () {
+        switch (this._lastHeaderSearchState.fieldIdentifier) {
+            case CaseMetaField.TITLE:
+                return 'title.keyword';
+            case CaseMetaField.VISUAL_ID:
+                return 'visualId.keyword';
+            case CaseMetaField.CREATION_DATE:
+                return 'creationDateSortable';
+            default:
+                return this._lastHeaderSearchState.fieldIdentifier;
+        }
+    };
+    CaseViewService.prototype.reload = function () {
+        if (!this._cases$ || !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);
+    };
+    CaseViewService.prototype.hasAuthority = function (authority) {
+        return this._user.hasAuthority(authority);
+    };
+    /**
+     * Determines whether the current user has the [VIEW]{@link PermissionType#VIEW} permission on the current case
+     * @param aCase the tested case
+     * @returns `true` if the current user has the `VIEW` permission on the tested case, `false` otherwise.
+     */
+    CaseViewService.prototype.viewEnabled = function (aCase) {
+        return this._permissionService.hasCasePermission(aCase, PermissionType.VIEW);
+    };
+    CaseViewService.ctorParameters = function () { return [
+        { type: AllowedNetsService },
+        { type: SideMenuService },
+        { type: CaseResourceService },
+        { type: LoggerService },
+        { type: SnackBarService },
+        { type: SearchService },
+        { type: TranslateService },
+        { type: UserService },
+        { type: ProcessService },
+        { type: SearchIndexResolverService },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_NEW_CASE_COMPONENT,] }] },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_NEW_CASE_CONFIGURATION,] }] },
+        { type: PermissionService }
+    ]; };
+    CaseViewService.decorators = [
+        { type: Injectable }
+    ];
+    CaseViewService.ctorParameters = function () { return [
+        { type: AllowedNetsService },
+        { type: SideMenuService },
+        { type: CaseResourceService },
+        { type: LoggerService },
+        { type: SnackBarService },
+        { type: SearchService },
+        { type: TranslateService },
+        { type: UserService },
+        { type: ProcessService },
+        { type: SearchIndexResolverService },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_NEW_CASE_COMPONENT,] }] },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_NEW_CASE_CONFIGURATION,] }] },
+        { type: PermissionService }
+    ]; };
+    return CaseViewService;
+}(SortableView));
+export { CaseViewService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"case-view-service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/view/case-view/service/case-view-service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, OnDestroy, Optional} from '@angular/core';\nimport {SideMenuService} from '../../../side-menu/services/side-menu.service';\nimport {CaseResourceService} from '../../../resources/engine-endpoint/case-resource.service';\nimport {BehaviorSubject, Observable, of, Subject} from 'rxjs';\nimport {HttpParams} from '@angular/common/http';\nimport {Case} from '../../../resources/interface/case';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {SnackBarService} from '../../../snack-bar/services/snack-bar.service';\nimport {SearchService} from '../../../search/search-service/search.service';\nimport {SideMenuSize} from '../../../side-menu/models/side-menu-size';\nimport {TranslateService} from '@ngx-translate/core';\nimport {catchError, concatMap, filter, map, mergeMap, scan, switchMap, tap} from 'rxjs/operators';\nimport {Pagination} from '../../../resources/interface/pagination';\nimport {CaseMetaField} from '../../../header/case-header/case-menta-enum';\nimport {NAE_NEW_CASE_COMPONENT} from '../../../side-menu/content-components/injection-tokens';\nimport {PageLoadRequestContext} from '../../abstract/page-load-request-context';\nimport {Filter} from '../../../filter/models/filter';\nimport {ListRange} from '@angular/cdk/collections';\nimport {LoadingWithFilterEmitter} from '../../../utility/loading-with-filter-emitter';\nimport {CasePageLoadRequestResult} from '../models/case-page-load-request-result';\nimport {UserService} from '../../../user/services/user.service';\nimport {arrayToObservable} from '../../../utility/array-to-observable';\nimport {PermissionType} from '../../../process/permissions';\nimport {NAE_NEW_CASE_CONFIGURATION} from '../models/new-case-configuration-injection-token';\nimport {NewCaseConfiguration} from '../models/new-case-configuration';\nimport {ProcessService} from '../../../process/process.service';\nimport {PetriNetReferenceWithPermissions} from '../../../process/petri-net-reference-with-permissions';\nimport {SearchIndexResolverService} from '../../../search/search-keyword-resolver-service/search-index-resolver.service';\nimport {AllowedNetsService} from '../../../allowed-nets/services/allowed-nets.service';\nimport {SortableView} from '../../abstract/sortable-view';\nimport {NewCaseCreationConfigurationData} from '../../../side-menu/content-components/new-case/model/new-case-injection-data';\nimport {PermissionService} from '../../../authorization/permission/permission.service';\nimport {EventOutcomeMessageResource} from '../../../resources/interface/message-resource';\nimport {CreateCaseEventOutcome} from '../../../event/model/event-outcomes/case-outcomes/create-case-event-outcome';\n\n@Injectable()\nexport class CaseViewService extends SortableView implements OnDestroy {\n\n    readonly DEFAULT_NEW_CASE_CONFIGURATION: NewCaseConfiguration = {\n        useCachedProcesses: true\n    };\n\n    protected _loading$: LoadingWithFilterEmitter;\n    protected _cases$: Observable<Array<Case>>;\n    protected _nextPage$: BehaviorSubject<PageLoadRequestContext>;\n    protected _endOfData: boolean;\n    protected _pagination: Pagination;\n    protected _newCaseConfiguration: NewCaseConfiguration;\n\n    constructor(protected _allowedNetsService: AllowedNetsService,\n                protected _sideMenuService: SideMenuService,\n                protected _caseResourceService: CaseResourceService,\n                protected _log: LoggerService,\n                protected _snackBarService: SnackBarService,\n                protected _searchService: SearchService,\n                protected _translate: TranslateService,\n                protected _user: UserService,\n                protected _processService: ProcessService,\n                resolver: SearchIndexResolverService,\n                @Optional() @Inject(NAE_NEW_CASE_COMPONENT) protected _newCaseComponent: any,\n                @Optional() @Inject(NAE_NEW_CASE_CONFIGURATION) newCaseConfig: NewCaseConfiguration,\n                protected _permissionService: PermissionService) {\n        super(resolver);\n        this._newCaseConfiguration = {...this.DEFAULT_NEW_CASE_CONFIGURATION};\n        if (newCaseConfig !== null) {\n            Object.assign(this._newCaseConfiguration, newCaseConfig);\n        }\n        this._loading$ = new LoadingWithFilterEmitter();\n        this._searchService.activeFilter$.subscribe(() => {\n            this.reload();\n        });\n        this._endOfData = false;\n        this._pagination = {\n            size: 25,\n            totalElements: undefined,\n            totalPages: undefined,\n            number: -1\n        };\n        this._nextPage$ = new BehaviorSubject<PageLoadRequestContext>(\n            new PageLoadRequestContext(this.activeFilter, Object.assign({}, this._pagination, {number: 0}))\n        );\n\n        const casesMap = this._nextPage$.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 = [{cases: {}, requestContext: null}, pageLoadResult];\n                    return arrayToObservable(results);\n                } else {\n                    return of(pageLoadResult);\n                }\n            }),\n            concatMap(o => o),\n            scan((acc, pageLoadResult) => {\n                if (pageLoadResult.requestContext === null) {\n                    return pageLoadResult.cases;\n                } else {\n                    this._loading$.off(pageLoadResult.requestContext.filter);\n                }\n                Object.assign(this._pagination, pageLoadResult.requestContext.pagination);\n                return {...acc, ...pageLoadResult.cases};\n            }, {})\n        );\n        this._cases$ = casesMap.pipe(\n            map(v => Object.values(v))\n        );\n    }\n\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this._loading$.complete();\n        this._nextPage$.complete();\n    }\n\n    public get loading(): boolean {\n        return this._loading$.isActive;\n    }\n\n    public get loading$(): Observable<boolean> {\n        return this._loading$.asObservable();\n    }\n\n    public get cases$(): Observable<Array<Case>> {\n        return this._cases$;\n    }\n\n    protected get activeFilter(): Filter {\n        return this._searchService.activeFilter;\n    }\n\n    public loadPage(requestContext: PageLoadRequestContext): Observable<CasePageLoadRequestResult> {\n        if (requestContext === null || requestContext.pageNumber < 0) {\n            return of({cases: {}, 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        return this._caseResourceService.searchCases(requestContext.filter, params).pipe(\n            catchError(err => {\n                this._log.error('Loading cases 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 cases page is no longer relevant since the active filter has changed before it could arrive.'\n                        + ' Discarding...');\n                }\n                return r;\n            }),\n            tap(c => {\n                Object.assign(requestContext.pagination, c.pagination);\n            }),\n            tap(c => {\n                this._endOfData = !Array.isArray(c.content)\n                    || c.content.length === 0\n                    || c.pagination.number === c.pagination.totalPages;\n            }),\n            map(cases => Array.isArray(cases.content) ? cases : {...cases, content: []}),\n            map(cases => {\n                return cases.content.reduce((acc, cur) => {\n                    return {...acc, [cur.stringId]: cur};\n                }, {});\n            }),\n            map(cases => ({cases, requestContext}))\n        );\n    }\n\n    public nextPage(renderedRange: ListRange, totalLoaded: number, requestContext?: PageLoadRequestContext) {\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._nextPage$.next(requestContext);\n        }\n    }\n\n    private isLoadingRelevantFilter(requestContext?: PageLoadRequestContext): boolean {\n        return requestContext === undefined || this._loading$.isActiveWithFilter(requestContext.filter);\n    }\n\n    public createNewCase(newCaseCreationConfiguration: NewCaseCreationConfigurationData = {\n        enableCaseTitle: true,\n        isCaseTitleRequired: true\n    }): Observable<Case> {\n        const myCase = new Subject<Case>();\n        this._sideMenuService.open(this._newCaseComponent, SideMenuSize.MEDIUM, {\n            allowedNets$: this.getNewCaseAllowedNets(),\n            newCaseCreationConfiguration\n        }).onClose.subscribe($event => {\n            this._log.debug($event.message, $event.data);\n            if ($event.data) {\n                this.reload();\n                myCase.next($event.data);\n            }\n            myCase.complete();\n        });\n        return myCase.asObservable();\n    }\n\n    public createDefaultNewCase(): Observable<Case> {\n        const myCase = new Subject<Case>();\n        this.getNewCaseAllowedNets().subscribe((nets: Array<PetriNetReferenceWithPermissions>) => {\n            this._caseResourceService.createCase({\n                title: null,\n                color: 'panel-primary-icon',\n                netId: nets[0].stringId\n            }).subscribe((response: EventOutcomeMessageResource) => {\n                this._snackBarService.openSuccessSnackBar(this._translate.instant('side-menu.new-case.createCase')\n                    + ' ' + this._translate.instant('side-menu.new-case.defaultCaseName'));\n                this.reload();\n                myCase.next((response.outcome as CreateCaseEventOutcome).aCase);\n                myCase.complete();\n            }, error => this._snackBarService.openErrorSnackBar(error.message ? error.message : error));\n        });\n        return myCase;\n    }\n\n    protected getNewCaseAllowedNets(): Observable<Array<PetriNetReferenceWithPermissions>> {\n        if (this._newCaseConfiguration.useCachedProcesses) {\n            return this._allowedNetsService.allowedNets$.pipe(\n                map(net => net.filter(n => this._permissionService.hasNetPermission(PermissionType.CREATE, n)))\n            );\n        } else {\n            return this._allowedNetsService.allowedNets$.pipe(\n                switchMap(allowedNets => {\n                    return this._processService.getNetReferences(allowedNets.map(net => net.identifier)).pipe(\n                        map(net => net.filter(n => this._permissionService.hasNetPermission(PermissionType.CREATE, n)))\n                    );\n                })\n            );\n        }\n    }\n\n    /**\n     * Returns number of allowed nets of case view\n     * @returns length of allowedNets array if it is defined, 0 if it is undefined\n     */\n    public getAllowedNetsCount(): number {\n        return this._allowedNetsService.allowedNets === undefined ? 0 : this._allowedNetsService.allowedNets.length;\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    protected getDefaultSortParam(): string {\n        return 'stringId,desc';\n    }\n\n    protected getMetaFieldSortId(): string {\n        switch (this._lastHeaderSearchState.fieldIdentifier) {\n            case CaseMetaField.TITLE:\n                return 'title.keyword';\n            case CaseMetaField.VISUAL_ID:\n                return 'visualId.keyword';\n            case CaseMetaField.CREATION_DATE:\n                return 'creationDateSortable';\n            default:\n                return this._lastHeaderSearchState.fieldIdentifier;\n        }\n    }\n\n    public reload(): void {\n        if (!this._cases$ || !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 hasAuthority(authority: Array<string> | string): boolean {\n        return this._user.hasAuthority(authority);\n    }\n\n    /**\n     * Determines whether the current user has the [VIEW]{@link PermissionType#VIEW} permission on the current case\n     * @param aCase the tested case\n     * @returns `true` if the current user has the `VIEW` permission on the tested case, `false` otherwise.\n     */\n    public viewEnabled(aCase: Case): boolean {\n        return this._permissionService.hasCasePermission(aCase, PermissionType.VIEW);\n    }\n}\n"]}

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

@@ -0,0 +1,75 @@
+import { __extends } from "tslib";
+import { AbstractCaseView } from './abstract-case-view';
+import { Inject } from '@angular/core';
+import { NAE_TAB_DATA } from '../../tabs/tab-data-injection-token/tab-data-injection-token';
+import { LoggerService } from '../../logger/services/logger.service';
+import { CaseViewService } from './service/case-view-service';
+import { SimpleFilter } from '../../filter/models/simple-filter';
+import { FilterType } from '../../filter/models/filter-type';
+import { OverflowService } from '../../header/services/overflow.service';
+var TabbedCaseView = /** @class */ (function (_super) {
+    __extends(TabbedCaseView, _super);
+    function TabbedCaseView(caseViewService, _loggerService, _injectedTabData, _overflowService, _autoswitchToTaskTab, _openExistingTab, _newCaseCreationConfig) {
+        if (_autoswitchToTaskTab === void 0) { _autoswitchToTaskTab = true; }
+        if (_openExistingTab === void 0) { _openExistingTab = true; }
+        if (_newCaseCreationConfig === void 0) { _newCaseCreationConfig = {
+            enableCaseTitle: true,
+            isCaseTitleRequired: true
+        }; }
+        var _this = _super.call(this, caseViewService, _overflowService, undefined, _newCaseCreationConfig) || this;
+        _this._loggerService = _loggerService;
+        _this._injectedTabData = _injectedTabData;
+        _this._overflowService = _overflowService;
+        _this._autoswitchToTaskTab = _autoswitchToTaskTab;
+        _this._openExistingTab = _openExistingTab;
+        _this._newCaseCreationConfig = _newCaseCreationConfig;
+        _this._correctlyInjected = !!_this._injectedTabData.tabViewComponent && _this._injectedTabData.tabViewOrder !== undefined;
+        if (!_this._correctlyInjected) {
+            _this._loggerService.warn('TabbedCaseView must inject a filled object of type InjectedTabbedCaseViewData to work properly!');
+        }
+        return _this;
+    }
+    TabbedCaseView.prototype.handleCaseClick = function (clickedCase) {
+        if (this._correctlyInjected) {
+            this.openTab(clickedCase);
+        }
+    };
+    TabbedCaseView.prototype.createNewCase = function () {
+        var _this = this;
+        var myCase = _super.prototype.createNewCase.call(this);
+        myCase.subscribe(function (kaze) {
+            if (_this._caseViewService.viewEnabled(kaze)) {
+                _this.openTab(kaze);
+            }
+        });
+        return myCase;
+    };
+    TabbedCaseView.prototype.openTab = function (openCase) {
+        this._injectedTabData.tabViewRef.openTab({
+            label: {
+                text: openCase.title,
+                icon: openCase.icon ? openCase.icon : 'check_box'
+            },
+            canBeClosed: true,
+            tabContentComponent: this._injectedTabData.tabViewComponent,
+            injectedObject: {
+                baseFilter: new SimpleFilter('', FilterType.TASK, { case: { id: "" + openCase.stringId } }),
+                allowedNets: [openCase.processIdentifier]
+            },
+            order: this._injectedTabData.tabViewOrder,
+            parentUniqueId: this._injectedTabData.tabUniqueId
+        }, this._autoswitchToTaskTab, this._openExistingTab);
+    };
+    TabbedCaseView.ctorParameters = function () { return [
+        { type: CaseViewService },
+        { type: LoggerService },
+        { type: undefined, decorators: [{ type: Inject, args: [NAE_TAB_DATA,] }] },
+        { type: OverflowService },
+        null,
+        null,
+        { type: undefined }
+    ]; };
+    return TabbedCaseView;
+}(AbstractCaseView));
+export { TabbedCaseView };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFiYmVkLWNhc2Utdmlldy5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi92aWV3L2Nhc2Utdmlldy90YWJiZWQtY2FzZS12aWV3LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsZ0JBQWdCLEVBQUMsTUFBTSxzQkFBc0IsQ0FBQztBQUN0RCxPQUFPLEVBQUMsTUFBTSxFQUFPLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSw4REFBOEQsQ0FBQztBQUcxRixPQUFPLEVBQUMsYUFBYSxFQUFDLE1BQU0sc0NBQXNDLENBQUM7QUFDbkUsT0FBTyxFQUFDLGVBQWUsRUFBQyxNQUFNLDZCQUE2QixDQUFDO0FBQzVELE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxtQ0FBbUMsQ0FBQztBQUMvRCxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0saUNBQWlDLENBQUM7QUFDM0QsT0FBTyxFQUFDLGVBQWUsRUFBQyxNQUFNLHdDQUF3QyxDQUFDO0FBU3ZFO0lBQTZDLGtDQUFnQjtJQUl6RCx3QkFBc0IsZUFBZ0MsRUFDdEIsY0FBNkIsRUFDUCxnQkFBNEMsRUFDbEUsZ0JBQWtDLEVBQ2xDLG9CQUEyQixFQUMzQixnQkFBdUIsRUFDdkIsc0JBR1Q7UUFMUyxxQ0FBQSxFQUFBLDJCQUEyQjtRQUMzQixpQ0FBQSxFQUFBLHVCQUF1QjtRQUN2Qix1Q0FBQSxFQUFBO1lBQ04sZUFBZSxFQUFFLElBQUk7WUFDckIsbUJBQW1CLEVBQUUsSUFBSTtTQUM1QjtRQVR2QixZQVdJLGtCQUFNLGVBQWUsRUFBRSxnQkFBZ0IsRUFBRSxTQUFTLEVBQUUsc0JBQXNCLENBQUMsU0FLOUU7UUFmK0Isb0JBQWMsR0FBZCxjQUFjLENBQWU7UUFDUCxzQkFBZ0IsR0FBaEIsZ0JBQWdCLENBQTRCO1FBQ2xFLHNCQUFnQixHQUFoQixnQkFBZ0IsQ0FBa0I7UUFDbEMsMEJBQW9CLEdBQXBCLG9CQUFvQixDQUFPO1FBQzNCLHNCQUFnQixHQUFoQixnQkFBZ0IsQ0FBTztRQUN2Qiw0QkFBc0IsR0FBdEIsc0JBQXNCLENBRy9CO1FBR25CLEtBQUksQ0FBQyxrQkFBa0IsR0FBRyxDQUFDLENBQUMsS0FBSSxDQUFDLGdCQUFnQixDQUFDLGdCQUFnQixJQUFJLEtBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxZQUFZLEtBQUssU0FBUyxDQUFDO1FBQ3ZILElBQUksQ0FBQyxLQUFJLENBQUMsa0JBQWtCLEVBQUU7WUFDMUIsS0FBSSxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsaUdBQWlHLENBQUMsQ0FBQztTQUMvSDs7SUFDTCxDQUFDO0lBRU0sd0NBQWUsR0FBdEIsVUFBdUIsV0FBaUI7UUFDcEMsSUFBSSxJQUFJLENBQUMsa0JBQWtCLEVBQUU7WUFDekIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQztTQUM3QjtJQUNMLENBQUM7SUFFTSxzQ0FBYSxHQUFwQjtRQUFBLGlCQVFDO1FBUEcsSUFBTSxNQUFNLEdBQUcsaUJBQU0sYUFBYSxXQUFFLENBQUM7UUFDckMsTUFBTSxDQUFDLFNBQVMsQ0FBRSxVQUFBLElBQUk7WUFDbEIsSUFBSSxLQUFJLENBQUMsZ0JBQWdCLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxFQUFFO2dCQUN6QyxLQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO2FBQ3RCO1FBQ0wsQ0FBQyxDQUFDLENBQUM7UUFDSCxPQUFPLE1BQU0sQ0FBQztJQUNsQixDQUFDO0lBRVMsZ0NBQU8sR0FBakIsVUFBa0IsUUFBYztRQUM1QixJQUFJLENBQUMsZ0JBQWdCLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQztZQUNyQyxLQUFLLEVBQUU7Z0JBQ0gsSUFBSSxFQUFFLFFBQVEsQ0FBQyxLQUFLO2dCQUNwQixJQUFJLEVBQUUsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsV0FBVzthQUNwRDtZQUNELFdBQVcsRUFBRSxJQUFJO1lBQ2pCLG1CQUFtQixFQUFFLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxnQkFBZ0I7WUFDM0QsY0FBYyxFQUFFO2dCQUNaLFVBQVUsRUFBRSxJQUFJLFlBQVksQ0FBQyxFQUFFLEVBQUUsVUFBVSxDQUFDLElBQUksRUFBRSxFQUFDLElBQUksRUFBRSxFQUFDLEVBQUUsRUFBRSxLQUFHLFFBQVEsQ0FBQyxRQUFVLEVBQUMsRUFBQyxDQUFDO2dCQUN2RixXQUFXLEVBQUUsQ0FBQyxRQUFRLENBQUMsaUJBQWlCLENBQUM7YUFDNUM7WUFDRCxLQUFLLEVBQUUsSUFBSSxDQUFDLGdCQUFnQixDQUFDLFlBQVk7WUFDekMsY0FBYyxFQUFFLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxXQUFXO1NBQ3BELEVBQUUsSUFBSSxDQUFDLG9CQUFvQixFQUFFLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO0lBQ3pELENBQUM7O2dCQWpFRyxlQUFlO2dCQURmLGFBQWE7Z0RBbUJNLE1BQU0sU0FBQyxZQUFZO2dCQWZ0QyxlQUFlOzs7OztJQStEdkIscUJBQUM7Q0FBQSxBQXRERCxDQUE2QyxnQkFBZ0IsR0FzRDVEO1NBdERxQixjQUFjIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtBYnN0cmFjdENhc2VWaWV3fSBmcm9tICcuL2Fic3RyYWN0LWNhc2Utdmlldyc7XG5pbXBvcnQge0luamVjdCwgVHlwZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge05BRV9UQUJfREFUQX0gZnJvbSAnLi4vLi4vdGFicy90YWItZGF0YS1pbmplY3Rpb24tdG9rZW4vdGFiLWRhdGEtaW5qZWN0aW9uLXRva2VuJztcbmltcG9ydCB7SW5qZWN0ZWRUYWJEYXRhfSBmcm9tICcuLi8uLi90YWJzL2ludGVyZmFjZXMnO1xuaW1wb3J0IHtDYXNlfSBmcm9tICcuLi8uLi9yZXNvdXJjZXMvaW50ZXJmYWNlL2Nhc2UnO1xuaW1wb3J0IHtMb2dnZXJTZXJ2aWNlfSBmcm9tICcuLi8uLi9sb2dnZXIvc2VydmljZXMvbG9nZ2VyLnNlcnZpY2UnO1xuaW1wb3J0IHtDYXNlVmlld1NlcnZpY2V9IGZyb20gJy4vc2VydmljZS9jYXNlLXZpZXctc2VydmljZSc7XG5pbXBvcnQge1NpbXBsZUZpbHRlcn0gZnJvbSAnLi4vLi4vZmlsdGVyL21vZGVscy9zaW1wbGUtZmlsdGVyJztcbmltcG9ydCB7RmlsdGVyVHlwZX0gZnJvbSAnLi4vLi4vZmlsdGVyL21vZGVscy9maWx0ZXItdHlwZSc7XG5pbXBvcnQge092ZXJmbG93U2VydmljZX0gZnJvbSAnLi4vLi4vaGVhZGVyL3NlcnZpY2VzL292ZXJmbG93LnNlcnZpY2UnO1xuaW1wb3J0IHtOZXdDYXNlQ3JlYXRpb25Db25maWd1cmF0aW9uRGF0YX0gZnJvbSAnLi4vLi4vc2lkZS1tZW51L2NvbnRlbnQtY29tcG9uZW50cy9uZXctY2FzZS9tb2RlbC9uZXctY2FzZS1pbmplY3Rpb24tZGF0YSc7XG5pbXBvcnQge09ic2VydmFibGV9IGZyb20gJ3J4anMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEluamVjdGVkVGFiYmVkQ2FzZVZpZXdEYXRhIGV4dGVuZHMgSW5qZWN0ZWRUYWJEYXRhIHtcbiAgICB0YWJWaWV3Q29tcG9uZW50OiBUeXBlPGFueT47XG4gICAgdGFiVmlld09yZGVyOiBudW1iZXI7XG59XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBUYWJiZWRDYXNlVmlldyBleHRlbmRzIEFic3RyYWN0Q2FzZVZpZXcge1xuXG4gICAgcHJpdmF0ZSByZWFkb25seSBfY29ycmVjdGx5SW5qZWN0ZWQ7XG5cbiAgICBwcm90ZWN0ZWQgY29uc3RydWN0b3IoY2FzZVZpZXdTZXJ2aWNlOiBDYXNlVmlld1NlcnZpY2UsXG4gICAgICAgICAgICAgICAgICAgICAgICAgIHByb3RlY3RlZCBfbG9nZ2VyU2VydmljZTogTG9nZ2VyU2VydmljZSxcbiAgICAgICAgICAgICAgICAgICAgICAgICAgQEluamVjdChOQUVfVEFCX0RBVEEpIHByb3RlY3RlZCBfaW5qZWN0ZWRUYWJEYXRhOiBJbmplY3RlZFRhYmJlZENhc2VWaWV3RGF0YSxcbiAgICAgICAgICAgICAgICAgICAgICAgICAgcHJvdGVjdGVkIF9vdmVyZmxvd1NlcnZpY2U/OiBPdmVyZmxvd1NlcnZpY2UsXG4gICAgICAgICAgICAgICAgICAgICAgICAgIHByb3RlY3RlZCBfYXV0b3N3aXRjaFRvVGFza1RhYiA9IHRydWUsXG4gICAgICAgICAgICAgICAgICAgICAgICAgIHByb3RlY3RlZCBfb3BlbkV4aXN0aW5nVGFiID0gdHJ1ZSxcbiAgICAgICAgICAgICAgICAgICAgICAgICAgcHJvdGVjdGVkIF9uZXdDYXNlQ3JlYXRpb25Db25maWc6IE5ld0Nhc2VDcmVhdGlvbkNvbmZpZ3VyYXRpb25EYXRhID0ge1xuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZW5hYmxlQ2FzZVRpdGxlOiB0cnVlLFxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaXNDYXNlVGl0bGVSZXF1aXJlZDogdHJ1ZVxuICAgICAgICAgICAgICAgICAgICAgICAgICB9KSB7XG5cbiAgICAgICAgc3VwZXIoY2FzZVZpZXdTZXJ2aWNlLCBfb3ZlcmZsb3dTZXJ2aWNlLCB1bmRlZmluZWQsIF9uZXdDYXNlQ3JlYXRpb25Db25maWcpO1xuICAgICAgICB0aGlzLl9jb3JyZWN0bHlJbmplY3RlZCA9ICEhdGhpcy5faW5qZWN0ZWRUYWJEYXRhLnRhYlZpZXdDb21wb25lbnQgJiYgdGhpcy5faW5qZWN0ZWRUYWJEYXRhLnRhYlZpZXdPcmRlciAhPT0gdW5kZWZpbmVkO1xuICAgICAgICBpZiAoIXRoaXMuX2NvcnJlY3RseUluamVjdGVkKSB7XG4gICAgICAgICAgICB0aGlzLl9sb2dnZXJTZXJ2aWNlLndhcm4oJ1RhYmJlZENhc2VWaWV3IG11c3QgaW5qZWN0IGEgZmlsbGVkIG9iamVjdCBvZiB0eXBlIEluamVjdGVkVGFiYmVkQ2FzZVZpZXdEYXRhIHRvIHdvcmsgcHJvcGVybHkhJyk7XG4gICAgICAgIH1cbiAgICB9XG5cbiAgICBwdWJsaWMgaGFuZGxlQ2FzZUNsaWNrKGNsaWNrZWRDYXNlOiBDYXNlKTogdm9pZCB7XG4gICAgICAgIGlmICh0aGlzLl9jb3JyZWN0bHlJbmplY3RlZCkge1xuICAgICAgICAgICAgdGhpcy5vcGVuVGFiKGNsaWNrZWRDYXNlKTtcbiAgICAgICAgfVxuICAgIH1cblxuICAgIHB1YmxpYyBjcmVhdGVOZXdDYXNlKCk6IE9ic2VydmFibGU8Q2FzZT4ge1xuICAgICAgICBjb25zdCBteUNhc2UgPSBzdXBlci5jcmVhdGVOZXdDYXNlKCk7XG4gICAgICAgIG15Q2FzZS5zdWJzY3JpYmUoIGthemUgPT4ge1xuICAgICAgICAgICAgaWYgKHRoaXMuX2Nhc2VWaWV3U2VydmljZS52aWV3RW5hYmxlZChrYXplKSkge1xuICAgICAgICAgICAgICAgIHRoaXMub3BlblRhYihrYXplKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfSk7XG4gICAgICAgIHJldHVybiBteUNhc2U7XG4gICAgfVxuXG4gICAgcHJvdGVjdGVkIG9wZW5UYWIob3BlbkNhc2U6IENhc2UpIHtcbiAgICAgICAgdGhpcy5faW5qZWN0ZWRUYWJEYXRhLnRhYlZpZXdSZWYub3BlblRhYih7XG4gICAgICAgICAgICBsYWJlbDoge1xuICAgICAgICAgICAgICAgIHRleHQ6IG9wZW5DYXNlLnRpdGxlLFxuICAgICAgICAgICAgICAgIGljb246IG9wZW5DYXNlLmljb24gPyBvcGVuQ2FzZS5pY29uIDogJ2NoZWNrX2JveCdcbiAgICAgICAgICAgIH0sXG4gICAgICAgICAgICBjYW5CZUNsb3NlZDogdHJ1ZSxcbiAgICAgICAgICAgIHRhYkNvbnRlbnRDb21wb25lbnQ6IHRoaXMuX2luamVjdGVkVGFiRGF0YS50YWJWaWV3Q29tcG9uZW50LFxuICAgICAgICAgICAgaW5qZWN0ZWRPYmplY3Q6IHtcbiAgICAgICAgICAgICAgICBiYXNlRmlsdGVyOiBuZXcgU2ltcGxlRmlsdGVyKCcnLCBGaWx0ZXJUeXBlLlRBU0ssIHtjYXNlOiB7aWQ6IGAke29wZW5DYXNlLnN0cmluZ0lkfWB9fSksXG4gICAgICAgICAgICAgICAgYWxsb3dlZE5ldHM6IFtvcGVuQ2FzZS5wcm9jZXNzSWRlbnRpZmllcl1cbiAgICAgICAgICAgIH0sXG4gICAgICAgICAgICBvcmRlcjogdGhpcy5faW5qZWN0ZWRUYWJEYXRhLnRhYlZpZXdPcmRlcixcbiAgICAgICAgICAgIHBhcmVudFVuaXF1ZUlkOiB0aGlzLl9pbmplY3RlZFRhYkRhdGEudGFiVW5pcXVlSWRcbiAgICAgICAgfSwgdGhpcy5fYXV0b3N3aXRjaFRvVGFza1RhYiwgdGhpcy5fb3BlbkV4aXN0aW5nVGFiKTtcbiAgICB9XG59XG4iXX0=