@netgrif/components-core 6.0.1

package/esm5/lib/user/services/user-list.service.js

@@ -0,0 +1,220 @@
+import { __assign } from "tslib";
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, forkJoin, of, Subject, timer } from 'rxjs';
+import { LoadingEmitter } from '../../utility/loading-emitter';
+import { UserResourceService } from '../../resources/engine-endpoint/user-resource.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { TranslateService } from '@ngx-translate/core';
+import { catchError, map, mergeMap, scan, tap } from 'rxjs/operators';
+import { HttpParams } from '@angular/common/http';
+/**
+ * Performs paged loading users from backend for [UserAssignComponent]{@link AbstractUserAssignComponent}.
+ */
+var UserListService = /** @class */ (function () {
+    /**
+     * Inject services.
+     * Initialize declared attributes.
+     *
+     * Loading and mapped stream of users.
+     * @param _resources Loading users from backend.
+     * @param _log Logging action status.
+     * @param _snackbar Display info about loading from backend for user.
+     * @param _translate Translate messages for user.
+     */
+    function UserListService(_resources, _log, _snackbar, _translate) {
+        var _this = this;
+        this._resources = _resources;
+        this._log = _log;
+        this._snackbar = _snackbar;
+        this._translate = _translate;
+        this._loading$ = new LoadingEmitter();
+        this._updateProgress$ = new LoadingEmitter();
+        this._usersReload$ = new Subject();
+        this._endOfData = false;
+        this._nextPage$ = new BehaviorSubject(null);
+        this._pagination = {
+            size: 20,
+            totalElements: undefined,
+            totalPages: undefined,
+            number: -1
+        };
+        this._clear = false;
+        this._searchQuery = '';
+        this.rolesQuery = new Array();
+        this.negativeRolesQuery = new Array();
+        var usersMap = this._nextPage$.pipe(mergeMap(function (p) { return _this.loadPage(p); }), tap(function () {
+            if (!_this._clear) {
+                _this._usersReload$.next();
+            }
+        }), scan(function (acc, value) {
+            var result = _this._clear ? {} : __assign(__assign({}, acc), value);
+            _this._clear = false;
+            return result;
+        }, {}));
+        this._users$ = usersMap.pipe(map(function (v) { return Object.values(v); }));
+    }
+    UserListService.prototype.ngOnDestroy = function () {
+        this._loading$.complete();
+        this._updateProgress$.complete();
+        this._usersReload$.complete();
+        this._nextPage$.complete();
+    };
+    Object.defineProperty(UserListService.prototype, "loading", {
+        get: function () {
+            return this._loading$.isActive;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(UserListService.prototype, "loading$", {
+        get: function () {
+            return this._loading$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(UserListService.prototype, "usersReload$", {
+        get: function () {
+            return this._usersReload$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(UserListService.prototype, "users$", {
+        get: function () {
+            return this._users$;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(UserListService.prototype, "updating$", {
+        get: function () {
+            return this._updateProgress$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(UserListService.prototype, "totalUsers", {
+        get: function () {
+            return this._pagination.totalElements ? this._pagination.totalElements : 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Get all users from backend and mapped to [UserValue]{@link UserValue} interface with catching errors.
+     * @param page Page number that is requested. / Next page users list.
+     */
+    UserListService.prototype.loadPage = function (page) {
+        var _this = this;
+        if (page === null || page === undefined || this._clear) {
+            return of({});
+        }
+        var params = new HttpParams();
+        params = this.addPageParams(params, page);
+        this._loading$.on();
+        return this._resources.search({ fulltext: this._searchQuery, roles: this.rolesQuery, negativeRoles: this.negativeRolesQuery }, params).pipe(catchError(function (err) {
+            _this._log.error('Loading users has failed on page ' + _this._pagination.number, err);
+            return of({ content: [], pagination: __assign(__assign({}, _this._pagination), { number: _this._pagination.number - 1 }) });
+        }), tap(function (u) { return _this._endOfData = !Array.isArray(u.content) ||
+            (Array.isArray(u.content) && u.content.length === 0) ||
+            u.pagination.number === u.pagination.totalPages; }), map(function (users) { return (Array.isArray(users.content) ? users : __assign(__assign({}, users), { content: [] })); }), map(function (users) {
+            _this._pagination = users.pagination;
+            return users.content.reduce(function (acc, curr) {
+                var _a;
+                var item = curr;
+                item.roles = new Set(curr.processRoles.map(function (pr) { return pr.stringId; }));
+                item.processRoles = undefined;
+                item.selected = false;
+                item.toggle = function () {
+                    this.selected = !this.selected;
+                };
+                return __assign(__assign({}, acc), (_a = {}, _a[curr.id] = item, _a));
+            }, {});
+        }), tap(function (_) { return _this._loading$.off(); }));
+    };
+    /**
+     * Set value to nextPage stream as next page users list.
+     * @param lastRendered Last rendered user index.
+     * @param totalRendered Total loaded size users.
+     */
+    UserListService.prototype.nextPage = function (lastRendered, totalRendered) {
+        if (this.loading || this._endOfData) {
+            return;
+        }
+        if (lastRendered === totalRendered) {
+            this._nextPage$.next(this._pagination.number + 1);
+        }
+    };
+    /**
+     * Reload page with users.
+     */
+    UserListService.prototype.reload = function (newSearchQuery) {
+        var _this = this;
+        if (newSearchQuery === void 0) { newSearchQuery = ''; }
+        if (!this._users$ || !this._pagination) {
+            return;
+        }
+        this._searchQuery = newSearchQuery;
+        this._clear = true;
+        this._pagination.number = -1;
+        this._endOfData = false;
+        this.nextPage(0, 0);
+        timer(100).subscribe(function (_) {
+            _this._pagination.number = -1;
+            _this.nextPage(0, 0);
+        });
+    };
+    UserListService.prototype.updateRoles = function (selectedUsers, selectedRoles) {
+        var _this = this;
+        if (selectedRoles === void 0) { selectedRoles = []; }
+        if (!selectedUsers || selectedUsers.length === 0) {
+            return of([]);
+        }
+        this._updateProgress$.on();
+        return forkJoin(selectedUsers.map(function (user) { return _this._resources.assignRoles(user.id + '', selectedRoles); })).pipe(tap(function (messages) {
+            messages.forEach(function (message, idx) {
+                if (message.error) {
+                    _this._log.error(message.error, message);
+                    _this._snackbar.openErrorSnackBar(message.error);
+                }
+                else {
+                    _this._log.info(message.success);
+                    selectedUsers[idx].roles = new Set(selectedRoles);
+                    _this._snackbar.openSuccessSnackBar(_this._translate.instant('tasks.snackbar.rolesSuccessAssign'));
+                }
+            });
+            _this._updateProgress$.off();
+        }));
+    };
+    /**
+     * Returns HttpParams with page params addition.
+     * @param params Existing HttpParams.
+     * @param page Page number that is requested. / Next page users list.
+     */
+    UserListService.prototype.addPageParams = function (params, page) {
+        params = params.set('size', this._pagination.size + '');
+        page = page !== null ? page : this._pagination.number;
+        params = params.set('page', page + '');
+        return params;
+    };
+    UserListService.ctorParameters = function () { return [
+        { type: UserResourceService },
+        { type: LoggerService },
+        { type: SnackBarService },
+        { type: TranslateService }
+    ]; };
+    UserListService.decorators = [
+        { type: Injectable }
+    ];
+    UserListService.ctorParameters = function () { return [
+        { type: UserResourceService },
+        { type: LoggerService },
+        { type: SnackBarService },
+        { type: TranslateService }
+    ]; };
+    return UserListService;
+}());
+export { UserListService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-list.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/user/services/user-list.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,UAAU,EAAY,MAAM,eAAe,CAAC;AACpD,OAAO,EAAC,eAAe,EAAE,QAAQ,EAAc,EAAE,EAAE,OAAO,EAAE,KAAK,EAAC,MAAM,MAAM,CAAC;AAC/E,OAAO,EAAC,cAAc,EAAC,MAAM,+BAA+B,CAAC;AAE7D,OAAO,EAAC,mBAAmB,EAAC,MAAM,uDAAuD,CAAC;AAC1F,OAAO,EAAC,aAAa,EAAC,MAAM,sCAAsC,CAAC;AACnE,OAAO,EAAC,eAAe,EAAC,MAAM,4CAA4C,CAAC;AAC3E,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAC,UAAU,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAC,MAAM,gBAAgB,CAAC;AACpE,OAAO,EAAC,UAAU,EAAC,MAAM,sBAAsB,CAAC;AAsBhD;;GAEG;AACH;IA0CI;;;;;;;;;OASG;IACH,yBAAoB,UAA+B,EAC/B,IAAmB,EACnB,SAA0B,EAC1B,UAA4B;QAHhD,iBAkCC;QAlCmB,eAAU,GAAV,UAAU,CAAqB;QAC/B,SAAI,GAAJ,IAAI,CAAe;QACnB,cAAS,GAAT,SAAS,CAAiB;QAC1B,eAAU,GAAV,UAAU,CAAkB;QAC5C,IAAI,CAAC,SAAS,GAAG,IAAI,cAAc,EAAE,CAAC;QACtC,IAAI,CAAC,gBAAgB,GAAG,IAAI,cAAc,EAAE,CAAC;QAC7C,IAAI,CAAC,aAAa,GAAG,IAAI,OAAO,EAAQ,CAAC;QACzC,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,IAAI,CAAC,UAAU,GAAG,IAAI,eAAe,CAAS,IAAI,CAAC,CAAC;QACpD,IAAI,CAAC,WAAW,GAAG;YACf,IAAI,EAAE,EAAE;YACR,aAAa,EAAE,SAAS;YACxB,UAAU,EAAE,SAAS;YACrB,MAAM,EAAE,CAAC,CAAC;SACb,CAAC;QACF,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,UAAU,GAAG,IAAI,KAAK,EAAU,CAAC;QACtC,IAAI,CAAC,kBAAkB,GAAG,IAAI,KAAK,EAAU,CAAC;QAE9C,IAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CACjC,QAAQ,CAAC,UAAA,CAAC,IAAI,OAAA,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAhB,CAAgB,CAAC,EAC/B,GAAG,CAAC;YACA,IAAI,CAAC,KAAI,CAAC,MAAM,EAAE;gBAAE,KAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;aAAE;QACpD,CAAC,CAAC,EACF,IAAI,CAAC,UAAC,GAAG,EAAE,KAAK;YACZ,IAAM,MAAM,GAAG,KAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,uBAAK,GAAG,GAAK,KAAK,CAAC,CAAC;YACrD,KAAI,CAAC,MAAM,GAAG,KAAK,CAAC;YACpB,OAAO,MAAM,CAAC;QAClB,CAAC,EAAE,EAAE,CAAC,CACT,CAAC;QACF,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC,IAAI,CACxB,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,MAAM,CAAC,MAAM,CAAC,CAAC,CAAwB,EAAvC,CAAuC,CAAC,CACpD,CAAC;IACN,CAAC;IAED,qCAAW,GAAX;QACI,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;QAC1B,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC;QACjC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;QAC9B,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IAC/B,CAAC;IAED,sBAAW,oCAAO;aAAlB;YACI,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;QACnC,CAAC;;;OAAA;IAED,sBAAW,qCAAQ;aAAnB;YACI,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC;QACzC,CAAC;;;OAAA;IAED,sBAAW,yCAAY;aAAvB;YACI,OAAO,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC;QAC7C,CAAC;;;OAAA;IAED,sBAAW,mCAAM;aAAjB;YACI,OAAO,IAAI,CAAC,OAAO,CAAC;QACxB,CAAC;;;OAAA;IAED,sBAAW,sCAAS;aAApB;YACI,OAAO,IAAI,CAAC,gBAAgB,CAAC,YAAY,EAAE,CAAC;QAChD,CAAC;;;OAAA;IAED,sBAAW,uCAAU;aAArB;YACI,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;QAC/E,CAAC;;;OAAA;IAED;;;OAGG;IACI,kCAAQ,GAAf,UAAgB,IAAY;QAA5B,iBAgCC;QA/BG,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,MAAM,EAAE;YACpD,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;SACjB;QACD,IAAI,MAAM,GAAe,IAAI,UAAU,EAAE,CAAC;QAC1C,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC1C,IAAI,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,CACzB,EAAC,QAAQ,EAAE,IAAI,CAAC,YAAY,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,aAAa,EAAE,IAAI,CAAC,kBAAkB,EAAC,EAAE,MAAM,CAAC,CAAC,IAAI,CAC3G,UAAU,CAAC,UAAA,GAAG;YACV,KAAI,CAAC,IAAI,CAAC,KAAK,CAAC,mCAAmC,GAAG,KAAI,CAAC,WAAW,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;YACpF,OAAO,EAAE,CAAC,EAAC,OAAO,EAAE,EAAE,EAAE,UAAU,wBAAM,KAAI,CAAC,WAAW,KAAE,MAAM,EAAE,KAAI,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,GAAC,EAAC,CAAC,CAAC;QACrG,CAAC,CAAC,EACF,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,KAAI,CAAC,UAAU,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC;YAChD,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC;YACpD,CAAC,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,CAAC,UAAU,CAAC,UAAU,EAF1C,CAE0C,CAAC,EACpD,GAAG,CAAC,UAAA,KAAK,IAAI,OAAA,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,uBAAK,KAAK,KAAE,OAAO,EAAE,EAAE,GAAC,CAAuB,EAAtF,CAAsF,CAAC,EACpG,GAAG,CAAC,UAAA,KAAK;YACL,KAAI,CAAC,WAAW,GAAG,KAAK,CAAC,UAAU,CAAC;YACpC,OAAO,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,UAAC,GAAG,EAAE,IAAI;;gBAClC,IAAM,IAAI,GAAG,IAAoB,CAAC;gBAClC,IAAI,CAAC,KAAK,GAAG,IAAI,GAAG,CAAS,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,UAAA,EAAE,IAAI,OAAA,EAAE,CAAC,QAAQ,EAAX,CAAW,CAAC,CAAC,CAAC;gBACvE,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;gBAC9B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;gBACtB,IAAI,CAAC,MAAM,GAAG;oBACV,IAAI,CAAC,QAAQ,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC;gBACnC,CAAC,CAAC;gBACF,6BAAW,GAAG,gBAAG,IAAI,CAAC,EAAE,IAAG,IAAI,OAAE;YACrC,CAAC,EAAE,EAAE,CAAC,CAAC;QACX,CAAC,CAAC,EACF,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,KAAI,CAAC,SAAS,CAAC,GAAG,EAAE,EAApB,CAAoB,CAAC,CACjC,CAAC;IACN,CAAC;IAED;;;;OAIG;IACI,kCAAQ,GAAf,UAAgB,YAAoB,EAAE,aAAqB;QACvD,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,UAAU,EAAE;YACjC,OAAO;SACV;QAED,IAAI,YAAY,KAAK,aAAa,EAAE;YAChC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;SACrD;IACL,CAAC;IAED;;OAEG;IACI,gCAAM,GAAb,UAAc,cAAmB;QAAjC,iBAaC;QAba,+BAAA,EAAA,mBAAmB;QAC7B,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACpC,OAAO;SACV;QACD,IAAI,CAAC,YAAY,GAAG,cAAc,CAAC;QACnC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC7B,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACpB,KAAK,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,UAAA,CAAC;YAClB,KAAI,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YAC7B,KAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACxB,CAAC,CAAC,CAAC;IACP,CAAC;IAEM,qCAAW,GAAlB,UAAmB,aAAkC,EAAE,aAAiC;QAAxF,iBAmBC;QAnBsD,8BAAA,EAAA,kBAAiC;QACpF,IAAI,CAAC,aAAa,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE;YAC9C,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;SACjB;QACD,IAAI,CAAC,gBAAgB,CAAC,EAAE,EAAE,CAAC;QAC3B,OAAO,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,UAAA,IAAI,IAAI,OAAA,KAAI,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE,aAAa,CAAC,EAAxD,CAAwD,CAAC,CAAC,CAAC,IAAI,CACrG,GAAG,CAAC,UAAA,QAAQ;YACR,QAAQ,CAAC,OAAO,CAAC,UAAC,OAAO,EAAE,GAAG;gBAC1B,IAAI,OAAO,CAAC,KAAK,EAAE;oBACf,KAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;oBACxC,KAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;iBACnD;qBAAM;oBACH,KAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;oBAChC,aAAa,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,IAAI,GAAG,CAAS,aAAa,CAAC,CAAC;oBAC1D,KAAI,CAAC,SAAS,CAAC,mBAAmB,CAAC,KAAI,CAAC,UAAU,CAAC,OAAO,CAAC,mCAAmC,CAAC,CAAC,CAAC;iBACpG;YACL,CAAC,CAAC,CAAC;YACH,KAAI,CAAC,gBAAgB,CAAC,GAAG,EAAE,CAAC;QAChC,CAAC,CAAC,CAAC,CAAC;IACZ,CAAC;IAED;;;;OAIG;IACK,uCAAa,GAArB,UAAsB,MAAkB,EAAE,IAAa;QACnD,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC;QACxD,IAAI,GAAG,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC;QACtD,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;QACvC,OAAO,MAAM,CAAC;IAClB,CAAC;;gBAzK+B,mBAAmB;gBACzB,aAAa;gBACR,eAAe;gBACd,gBAAgB;;;gBAvDnD,UAAU;;;gBA9BH,mBAAmB;gBACnB,aAAa;gBACb,eAAe;gBACf,gBAAgB;;IA0PxB,sBAAC;CAAA,AA/ND,IA+NC;SA9NY,eAAe","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\nimport {BehaviorSubject, forkJoin, Observable, of, Subject, timer} from 'rxjs';\nimport {LoadingEmitter} from '../../utility/loading-emitter';\nimport {Pagination} from '../../resources/interface/pagination';\nimport {UserResourceService} from '../../resources/engine-endpoint/user-resource.service';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {SnackBarService} from '../../snack-bar/services/snack-bar.service';\nimport {TranslateService} from '@ngx-translate/core';\nimport {catchError, map, mergeMap, scan, tap} from 'rxjs/operators';\nimport {HttpParams} from '@angular/common/http';\nimport {MessageResource} from '../../resources/interface/message-resource';\nimport {Page} from '../../resources/interface/page';\nimport {UserResource} from '../../resources/interface/user-resource';\n\nexport interface UserListItem extends UserResource {\n    selected: boolean;\n    roles: Set<string>;\n\n    toggle(): void;\n}\n\nexport interface RolesObject {\n    [k: string]: RoleObject;\n}\n\ninterface RoleObject {\n    perform?: boolean;\n    delegate?: boolean;\n    view?: boolean;\n}\n\n/**\n * Performs paged loading users from backend for [UserAssignComponent]{@link AbstractUserAssignComponent}.\n */\n@Injectable()\nexport class UserListService implements OnDestroy {\n\n    /**\n     * UserValue array stream, that represents users loading from backend.\n     */\n    private readonly _users$: Observable<Array<UserListItem>>;\n    /**\n     * Emit users loading status from backend.\n     */\n    private _loading$: LoadingEmitter;\n    /**\n     * Number stream of next page users list, that to be requested from backend.\n     */\n    private _nextPage$: BehaviorSubject<number>;\n    /**\n     * Signals the end of loaded users.\n     */\n    private _endOfData: boolean;\n    /**\n     * Necessary for pagination parameters in user assign loading from backend.\n     */\n    private _pagination: Pagination;\n    /**\n     * Signals if response is empty or no.\n     */\n    private _clear: boolean;\n    /**\n     * The search content that should be applied to the request\n     */\n    private _searchQuery: string;\n    /**\n     * Roles that should be applied to the request\n     */\n    public rolesQuery: Array<string>;\n    /**\n     * negative Roles that should be applied to the request\n     */\n    public negativeRolesQuery: Array<string>;\n    private _updateProgress$: LoadingEmitter;\n    private _usersReload$: Subject<void>;\n\n    /**\n     * Inject services.\n     * Initialize declared attributes.\n     *\n     * Loading and mapped stream of users.\n     * @param _resources Loading users from backend.\n     * @param _log Logging action status.\n     * @param _snackbar Display info about loading from backend for user.\n     * @param _translate Translate messages for user.\n     */\n    constructor(private _resources: UserResourceService,\n                private _log: LoggerService,\n                private _snackbar: SnackBarService,\n                private _translate: TranslateService) {\n        this._loading$ = new LoadingEmitter();\n        this._updateProgress$ = new LoadingEmitter();\n        this._usersReload$ = new Subject<void>();\n        this._endOfData = false;\n        this._nextPage$ = new BehaviorSubject<number>(null);\n        this._pagination = {\n            size: 20,\n            totalElements: undefined,\n            totalPages: undefined,\n            number: -1\n        };\n        this._clear = false;\n        this._searchQuery = '';\n        this.rolesQuery = new Array<string>();\n        this.negativeRolesQuery = new Array<string>();\n\n        const usersMap = this._nextPage$.pipe(\n            mergeMap(p => this.loadPage(p)),\n            tap(() => {\n                if (!this._clear) { this._usersReload$.next(); }\n            }),\n            scan((acc, value) => {\n                const result = this._clear ? {} : {...acc, ...value};\n                this._clear = false;\n                return result;\n            }, {})\n        );\n        this._users$ = usersMap.pipe(\n            map(v => Object.values(v) as Array<UserListItem>),\n        );\n    }\n\n    ngOnDestroy(): void {\n        this._loading$.complete();\n        this._updateProgress$.complete();\n        this._usersReload$.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 usersReload$(): Observable<void> {\n        return this._usersReload$.asObservable();\n    }\n\n    public get users$(): Observable<Array<UserListItem>> {\n        return this._users$;\n    }\n\n    public get updating$(): Observable<boolean> {\n        return this._updateProgress$.asObservable();\n    }\n\n    public get totalUsers(): number {\n        return this._pagination.totalElements ? this._pagination.totalElements : 0;\n    }\n\n    /**\n     * Get all users from backend and mapped to [UserValue]{@link UserValue} interface with catching errors.\n     * @param page Page number that is requested. / Next page users list.\n     */\n    public loadPage(page: number): Observable<{ [k: string]: UserListItem }> {\n        if (page === null || page === undefined || this._clear) {\n            return of({});\n        }\n        let params: HttpParams = new HttpParams();\n        params = this.addPageParams(params, page);\n        this._loading$.on();\n        return this._resources.search(\n            {fulltext: this._searchQuery, roles: this.rolesQuery, negativeRoles: this.negativeRolesQuery}, params).pipe(\n            catchError(err => {\n                this._log.error('Loading users has failed on page ' + this._pagination.number, err);\n                return of({content: [], pagination: {...this._pagination, number: this._pagination.number - 1}});\n            }),\n            tap(u => this._endOfData = !Array.isArray(u.content) ||\n                (Array.isArray(u.content) && u.content.length === 0) ||\n                u.pagination.number === u.pagination.totalPages),\n            map(users => (Array.isArray(users.content) ? users : {...users, content: []}) as Page<UserResource>),\n            map(users => {\n                this._pagination = users.pagination;\n                return users.content.reduce((acc, curr) => {\n                    const item = curr as UserListItem;\n                    item.roles = new Set<string>(curr.processRoles.map(pr => pr.stringId));\n                    item.processRoles = undefined;\n                    item.selected = false;\n                    item.toggle = function() {\n                        this.selected = !this.selected;\n                    };\n                    return {...acc, [curr.id]: item};\n                }, {});\n            }),\n            tap(_ => this._loading$.off())\n        );\n    }\n\n    /**\n     * Set value to nextPage stream as next page users list.\n     * @param lastRendered Last rendered user index.\n     * @param totalRendered Total loaded size users.\n     */\n    public nextPage(lastRendered: number, totalRendered: number) {\n        if (this.loading || this._endOfData) {\n            return;\n        }\n\n        if (lastRendered === totalRendered) {\n            this._nextPage$.next(this._pagination.number + 1);\n        }\n    }\n\n    /**\n     * Reload page with users.\n     */\n    public reload(newSearchQuery = ''): void {\n        if (!this._users$ || !this._pagination) {\n            return;\n        }\n        this._searchQuery = newSearchQuery;\n        this._clear = true;\n        this._pagination.number = -1;\n        this._endOfData = false;\n        this.nextPage(0, 0);\n        timer(100).subscribe(_ => {\n            this._pagination.number = -1;\n            this.nextPage(0, 0);\n        });\n    }\n\n    public updateRoles(selectedUsers: Array<UserListItem>, selectedRoles: Array<string> = []): Observable<Array<MessageResource>> {\n        if (!selectedUsers || selectedUsers.length === 0) {\n            return of([]);\n        }\n        this._updateProgress$.on();\n        return forkJoin(selectedUsers.map(user => this._resources.assignRoles(user.id + '', selectedRoles))).pipe(\n            tap(messages => {\n                messages.forEach((message, idx) => {\n                    if (message.error) {\n                        this._log.error(message.error, message);\n                        this._snackbar.openErrorSnackBar(message.error);\n                    } else {\n                        this._log.info(message.success);\n                        selectedUsers[idx].roles = new Set<string>(selectedRoles);\n                        this._snackbar.openSuccessSnackBar(this._translate.instant('tasks.snackbar.rolesSuccessAssign'));\n                    }\n                });\n                this._updateProgress$.off();\n            }));\n    }\n\n    /**\n     * Returns HttpParams with page params addition.\n     * @param params Existing HttpParams.\n     * @param page Page number that is requested. / Next page users list.\n     */\n    private addPageParams(params: HttpParams, page?: number): HttpParams {\n        params = params.set('size', this._pagination.size + '');\n        page = page !== null ? page : this._pagination.number;\n        params = params.set('page', page + '');\n        return params;\n    }\n\n}\n"]}

package/esm5/lib/user/services/user-preference.service.js

@@ -0,0 +1,164 @@
+import { Injectable } from '@angular/core';
+import { UserService } from './user.service';
+import { UserResourceService } from '../../resources/engine-endpoint/user-resource.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { Subject } from 'rxjs';
+import { TranslateService } from '@ngx-translate/core';
+import { debounceTime } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./user.service";
+import * as i2 from "../../resources/engine-endpoint/user-resource.service";
+import * as i3 from "../../logger/services/logger.service";
+import * as i4 from "../../snack-bar/services/snack-bar.service";
+import * as i5 from "@ngx-translate/core";
+var DRAWER_DEFAULT_WIDTH = 200;
+var DRAWER_DEBOUNCE = 1000;
+var UserPreferenceService = /** @class */ (function () {
+    function UserPreferenceService(_userService, _userResourceService, _logger, _snackbar, _translate) {
+        var _this = this;
+        this._userService = _userService;
+        this._userResourceService = _userResourceService;
+        this._logger = _logger;
+        this._snackbar = _snackbar;
+        this._translate = _translate;
+        this._preferences = this._emptyPreferences();
+        this._preferencesChanged$ = new Subject();
+        this._drawerWidthChanged$ = new Subject();
+        this._anonym = false;
+        this._sub = this._userService.user$.subscribe(function (loggedUser) {
+            if (loggedUser && loggedUser.id !== '') {
+                _this._userResourceService.getPreferences().subscribe(function (prefs) {
+                    _this._preferences = _this._emptyPreferences();
+                    Object.assign(_this._preferences, prefs);
+                    _this._preferencesChanged$.next();
+                });
+            }
+            else {
+                _this._preferences = _this._emptyPreferences();
+                _this._preferencesChanged$.next();
+            }
+        });
+        this._subAnonym = this._userService.anonymousUser$.subscribe(function (loggedUser) {
+            if (loggedUser && loggedUser.id !== '') {
+                _this._userResourceService.getPublicPreferences().subscribe(function (prefs) {
+                    _this._preferences = _this._emptyPreferences();
+                    Object.assign(_this._preferences, prefs);
+                    _this._preferencesChanged$.next();
+                    _this._anonym = true;
+                });
+            }
+            else {
+                _this._preferences = _this._emptyPreferences();
+                _this._preferencesChanged$.next();
+                _this._anonym = false;
+            }
+        });
+        this._drawerWidthChanged$.asObservable().pipe(debounceTime(DRAWER_DEBOUNCE)).subscribe(function (newWidth) {
+            _this.drawerWidth = newWidth;
+        });
+    }
+    UserPreferenceService.prototype.ngOnDestroy = function () {
+        this._sub.unsubscribe();
+        this._preferencesChanged$.complete();
+    };
+    UserPreferenceService.prototype.setTaskFilters = function (viewId, value) {
+        this._preferences.taskFilters[viewId] = value;
+        this._savePreferences();
+    };
+    UserPreferenceService.prototype.getTaskFilters = function (viewId) {
+        return this._preferences.taskFilters[viewId];
+    };
+    UserPreferenceService.prototype.setCaseFilters = function (viewId, value) {
+        this._preferences.caseFilters[viewId] = value;
+        this._savePreferences();
+    };
+    UserPreferenceService.prototype.getCaseFilters = function (viewId) {
+        return this._preferences.caseFilters[viewId];
+    };
+    UserPreferenceService.prototype.setHeaders = function (viewId, value) {
+        this._preferences.headers[viewId] = value;
+        this._savePreferences();
+    };
+    UserPreferenceService.prototype.getHeaders = function (viewId) {
+        return this._preferences.headers[viewId];
+    };
+    UserPreferenceService.prototype.setLocale = function (locale) {
+        this._preferences.locale = locale;
+        this._savePreferences();
+    };
+    UserPreferenceService.prototype.getLocale = function () {
+        return this._preferences.locale;
+    };
+    Object.defineProperty(UserPreferenceService.prototype, "drawerWidth", {
+        get: function () {
+            return this._preferences.drawerWidth;
+        },
+        set: function (drawerWidth) {
+            this._preferences.drawerWidth = drawerWidth;
+            this._savePreferences();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(UserPreferenceService.prototype, "preferencesChanged$", {
+        get: function () {
+            return this._preferencesChanged$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    UserPreferenceService.prototype._savePreferences = function () {
+        var _this = this;
+        if (!this._anonym) {
+            this._userResourceService.setPreferences(this._preferences).subscribe(function (resultMessage) {
+                _this.resultMessage(resultMessage);
+            });
+        }
+        else {
+            this._userResourceService.setPublicPreferences(this._preferences).subscribe(function (resultMessage) {
+                _this.resultMessage(resultMessage);
+            });
+        }
+    };
+    UserPreferenceService.prototype.resultMessage = function (resultMessage) {
+        if (typeof resultMessage.success === 'string') {
+            this._snackbar.openSuccessSnackBar(this._translate.instant('preferences.snackbar.saveSuccess'));
+        }
+        else {
+            this._snackbar.openErrorSnackBar(this._translate.instant('preferences.snackbar.saveFailure'));
+            this._logger.error('User preferences failed to save', resultMessage);
+        }
+    };
+    UserPreferenceService.prototype._emptyPreferences = function () {
+        return {
+            drawerWidth: DRAWER_DEFAULT_WIDTH,
+            headers: {},
+            caseFilters: {},
+            taskFilters: {}
+        };
+    };
+    UserPreferenceService.ctorParameters = function () { return [
+        { type: UserService },
+        { type: UserResourceService },
+        { type: LoggerService },
+        { type: SnackBarService },
+        { type: TranslateService }
+    ]; };
+    UserPreferenceService.ɵprov = i0.ɵɵdefineInjectable({ factory: function UserPreferenceService_Factory() { return new UserPreferenceService(i0.ɵɵinject(i1.UserService), i0.ɵɵinject(i2.UserResourceService), i0.ɵɵinject(i3.LoggerService), i0.ɵɵinject(i4.SnackBarService), i0.ɵɵinject(i5.TranslateService)); }, token: UserPreferenceService, providedIn: "root" });
+    UserPreferenceService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    UserPreferenceService.ctorParameters = function () { return [
+        { type: UserService },
+        { type: UserResourceService },
+        { type: LoggerService },
+        { type: SnackBarService },
+        { type: TranslateService }
+    ]; };
+    return UserPreferenceService;
+}());
+export { UserPreferenceService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-preference.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/user/services/user-preference.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\nimport {Preferences} from '../../resources/interface/preferences';\nimport {UserService} from './user.service';\nimport {UserResourceService} from '../../resources/engine-endpoint/user-resource.service';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {SnackBarService} from '../../snack-bar/services/snack-bar.service';\nimport {Observable, Subject, Subscription} from 'rxjs';\nimport {TranslateService} from '@ngx-translate/core';\nimport {debounceTime} from 'rxjs/operators';\n\nconst DRAWER_DEFAULT_WIDTH = 200;\nconst DRAWER_DEBOUNCE = 1000;\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class UserPreferenceService implements OnDestroy {\n\n    protected _preferences: Preferences;\n    protected _preferencesChanged$: Subject<void>;\n    protected _sub: Subscription;\n    protected _subAnonym: Subscription;\n    public _drawerWidthChanged$: Subject<number>;\n    protected _anonym: boolean;\n\n    constructor(protected _userService: UserService,\n                protected _userResourceService: UserResourceService,\n                protected _logger: LoggerService,\n                protected _snackbar: SnackBarService,\n                protected _translate: TranslateService) {\n        this._preferences = this._emptyPreferences();\n        this._preferencesChanged$ = new Subject<void>();\n        this._drawerWidthChanged$ = new Subject<number>();\n        this._anonym = false;\n\n        this._sub = this._userService.user$.subscribe(loggedUser => {\n            if (loggedUser && loggedUser.id !== '') {\n                this._userResourceService.getPreferences().subscribe(prefs => {\n                        this._preferences = this._emptyPreferences();\n                        Object.assign(this._preferences, prefs);\n                        this._preferencesChanged$.next();\n                    }\n                );\n            } else {\n                this._preferences = this._emptyPreferences();\n                this._preferencesChanged$.next();\n            }\n        });\n\n        this._subAnonym = this._userService.anonymousUser$.subscribe(loggedUser => {\n            if (loggedUser && loggedUser.id !== '') {\n                this._userResourceService.getPublicPreferences().subscribe(prefs => {\n                        this._preferences = this._emptyPreferences();\n                        Object.assign(this._preferences, prefs);\n                        this._preferencesChanged$.next();\n                        this._anonym = true;\n                    }\n                );\n            } else {\n                this._preferences = this._emptyPreferences();\n                this._preferencesChanged$.next();\n                this._anonym = false;\n            }\n        });\n\n        this._drawerWidthChanged$.asObservable().pipe(\n            debounceTime(DRAWER_DEBOUNCE)\n        ).subscribe(newWidth => {\n            this.drawerWidth = newWidth;\n        });\n    }\n\n    ngOnDestroy(): void {\n        this._sub.unsubscribe();\n        this._preferencesChanged$.complete();\n    }\n\n    public setTaskFilters(viewId: string, value: Array<string>): void {\n        this._preferences.taskFilters[viewId] = value;\n        this._savePreferences();\n    }\n\n    public getTaskFilters(viewId: string): Array<string> | undefined {\n        return this._preferences.taskFilters[viewId];\n    }\n\n    public setCaseFilters(viewId: string, value: Array<string>): void {\n        this._preferences.caseFilters[viewId] = value;\n        this._savePreferences();\n    }\n\n    public getCaseFilters(viewId: string): Array<string> | undefined {\n        return this._preferences.caseFilters[viewId];\n    }\n\n    public setHeaders(viewId: string, value: Array<string>): void {\n        this._preferences.headers[viewId] = value;\n        this._savePreferences();\n    }\n\n    public getHeaders(viewId: string): Array<string> | undefined {\n        return this._preferences.headers[viewId];\n    }\n\n    public setLocale(locale: string): void {\n        this._preferences.locale = locale;\n        this._savePreferences();\n    }\n\n    public getLocale(): string {\n        return this._preferences.locale;\n    }\n\n    set drawerWidth(drawerWidth: number) {\n        this._preferences.drawerWidth = drawerWidth;\n        this._savePreferences();\n    }\n\n    get drawerWidth(): number {\n        return this._preferences.drawerWidth;\n    }\n\n    public get preferencesChanged$(): Observable<void> {\n        return this._preferencesChanged$.asObservable();\n    }\n\n    protected _savePreferences(): void {\n        if (!this._anonym) {\n            this._userResourceService.setPreferences(this._preferences).subscribe(resultMessage => {\n                this.resultMessage(resultMessage);\n            });\n        } else {\n            this._userResourceService.setPublicPreferences(this._preferences).subscribe(resultMessage => {\n                this.resultMessage(resultMessage);\n            });\n        }\n    }\n\n    protected resultMessage(resultMessage): void {\n        if (typeof resultMessage.success === 'string') {\n            this._snackbar.openSuccessSnackBar(this._translate.instant('preferences.snackbar.saveSuccess'));\n        } else {\n            this._snackbar.openErrorSnackBar(this._translate.instant('preferences.snackbar.saveFailure'));\n            this._logger.error('User preferences failed to save', resultMessage);\n        }\n    }\n\n    protected _emptyPreferences(): Preferences {\n        return {\n            drawerWidth: DRAWER_DEFAULT_WIDTH,\n            headers: {},\n            caseFilters: {},\n            taskFilters: {}\n        };\n    }\n}\n"]}