@netgrif/components-core 6.0.1

package/esm5/lib/forms/models/abstract-registration.component.js

@@ -0,0 +1,106 @@
+import { EventEmitter, Input, Output } from '@angular/core';
+import { LoadingEmitter } from '../../utility/loading-emitter';
+import { take } from 'rxjs/operators';
+/**
+ * Holds the logic that is shared between `RegistrationFormComponent` and `ForgottenPasswordFormComponent`.
+ */
+var AbstractRegistrationComponent = /** @class */ (function () {
+    function AbstractRegistrationComponent(_signupService, _log, _translate) {
+        this._signupService = _signupService;
+        this._log = _log;
+        this._translate = _translate;
+        this.MIN_PASSWORD_LENGTH = 8;
+        this.hidePassword = true;
+        this.hideRepeatPassword = true;
+        this.formSubmit = new EventEmitter();
+        this.register = new EventEmitter();
+        this.invalidToken = new EventEmitter();
+        this._tokenVerified = false;
+        this.loadingToken = new LoadingEmitter(true);
+    }
+    AbstractRegistrationComponent.prototype.ngOnDestroy = function () {
+        this.formSubmit.complete();
+        this.register.complete();
+        this.invalidToken.complete();
+        this.loadingToken.complete();
+    };
+    Object.defineProperty(AbstractRegistrationComponent.prototype, "token", {
+        get: function () {
+            return this._token;
+        },
+        set: function (token) {
+            var _this = this;
+            this._token = token;
+            if (!this._token) {
+                this._tokenVerified = false;
+                return;
+            }
+            this.loadingToken.on();
+            this._signupService.verify(this._token).pipe(take(1)).subscribe(function (message) {
+                _this._log.info('Token ' + _this._token + ' has been successfully verified');
+                if (message.success) {
+                    _this.userEmail = message.success;
+                }
+                _this._tokenVerified = true;
+                _this.loadingToken.off();
+            }, function (error) {
+                _this._log.error(error.message);
+                _this._tokenVerified = false;
+                _this.loadingToken.off();
+                _this.invalidToken.emit();
+            });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractRegistrationComponent.prototype, "tokenVerified", {
+        get: function () {
+            return this._tokenVerified;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AbstractRegistrationComponent.prototype.onSubmit = function () {
+        var _this = this;
+        if (!this.rootFormGroup.valid) {
+            return;
+        }
+        var request = this.createRequestBody();
+        this.formSubmit.emit(request);
+        if (!this._tokenVerified) {
+            this.register.emit({ error: 'Provided token ' + this._token + ' is not valid' });
+            return;
+        }
+        request.token = this._token;
+        this.callRegistration(request).pipe(take(1)).subscribe(function (message) {
+            _this.register.emit(message);
+        }, function (error) {
+            _this.register.emit({ error: error });
+        });
+    };
+    AbstractRegistrationComponent.prototype.isFieldValid = function (formControlName) {
+        return this.rootFormGroup.get(formControlName).valid;
+    };
+    AbstractRegistrationComponent.prototype.getErrorMessage = function (formControlName) {
+        var errors = this.rootFormGroup.get(formControlName).errors;
+        if (errors === null)
+            return;
+        switch (Object.keys(errors)[0]) {
+            case 'required':
+                return this._translate.instant('dataField.validations.required');
+            case 'minlength':
+                return this._translate.instant('dataField.validations.minLength', { length: this.MIN_PASSWORD_LENGTH });
+            case 'mismatchedPassword':
+                return this._translate.instant('forms.register.passwordsMustMatch');
+        }
+    };
+    AbstractRegistrationComponent.propDecorators = {
+        formSubmit: [{ type: Output }],
+        register: [{ type: Output }],
+        invalidToken: [{ type: Output }],
+        token: [{ type: Input }]
+    };
+    return AbstractRegistrationComponent;
+}());
+export { AbstractRegistrationComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-registration.component.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/forms/models/abstract-registration.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {EventEmitter, Input, OnDestroy, Output} from '@angular/core';\nimport {FormSubmitEvent, HasForm} from '../has-form';\nimport {FormGroup} from '@angular/forms';\nimport {MessageResource} from '../../resources/interface/message-resource';\nimport {LoadingEmitter} from '../../utility/loading-emitter';\nimport {SignUpService} from '../../authentication/sign-up/services/sign-up.service';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {UserRegistrationRequest} from '../../authentication/sign-up/models/user-registration-request';\nimport {Observable} from 'rxjs';\nimport {TranslateService} from '@ngx-translate/core';\nimport {take} from 'rxjs/operators';\n\n/**\n * Holds the logic that is shared between `RegistrationFormComponent` and `ForgottenPasswordFormComponent`.\n */\nexport abstract class AbstractRegistrationComponent implements HasForm, OnDestroy {\n\n    protected readonly MIN_PASSWORD_LENGTH = 8;\n\n    public rootFormGroup: FormGroup;\n    public hidePassword: boolean;\n    public hideRepeatPassword: boolean;\n\n    @Output() public formSubmit: EventEmitter<FormSubmitEvent>;\n    @Output() public register: EventEmitter<MessageResource>;\n    /**\n     * Emits whenever the provided token gets resolved as invalid\n     */\n    @Output() public invalidToken: EventEmitter<void>;\n\n    private _token: string;\n    private _tokenVerified: boolean;\n    public loadingToken: LoadingEmitter;\n    public userEmail: string;\n\n    protected constructor(protected _signupService: SignUpService,\n                          protected _log: LoggerService,\n                          protected _translate: TranslateService) {\n        this.hidePassword = true;\n        this.hideRepeatPassword = true;\n        this.formSubmit = new EventEmitter<FormSubmitEvent>();\n        this.register = new EventEmitter<MessageResource>();\n        this.invalidToken = new EventEmitter<void>();\n        this._tokenVerified = false;\n        this.loadingToken = new LoadingEmitter(true);\n    }\n\n    ngOnDestroy(): void {\n        this.formSubmit.complete();\n        this.register.complete();\n        this.invalidToken.complete();\n        this.loadingToken.complete();\n    }\n\n    @Input()\n    set token(token: string) {\n        this._token = token;\n        if (!this._token) {\n            this._tokenVerified = false;\n            return;\n        }\n        this.loadingToken.on();\n        this._signupService.verify(this._token).pipe(take(1)).subscribe(message => {\n            this._log.info('Token ' + this._token + ' has been successfully verified');\n            if (message.success) {\n                this.userEmail = message.success;\n            }\n            this._tokenVerified = true;\n            this.loadingToken.off();\n        }, (error: Error) => {\n            this._log.error(error.message);\n            this._tokenVerified = false;\n            this.loadingToken.off();\n            this.invalidToken.emit();\n        });\n    }\n\n    get token(): string {\n        return this._token;\n    }\n\n    get tokenVerified(): boolean {\n        return this._tokenVerified;\n    }\n\n    public onSubmit(): void {\n        if (!this.rootFormGroup.valid) {\n            return;\n        }\n        const request = this.createRequestBody();\n        this.formSubmit.emit(request);\n\n        if (!this._tokenVerified) {\n            this.register.emit({error: 'Provided token ' + this._token + ' is not valid'});\n            return;\n        }\n        request.token = this._token;\n        this.callRegistration(request).pipe(take(1)).subscribe(message => {\n            this.register.emit(message);\n        }, error => {\n            this.register.emit({error});\n        });\n    }\n\n    public isFieldValid(formControlName: string): boolean {\n        return this.rootFormGroup.get(formControlName).valid;\n    }\n\n    public getErrorMessage(formControlName: string): string {\n        const errors = this.rootFormGroup.get(formControlName).errors;\n        if (errors === null)\n            return;\n        switch (Object.keys(errors)[0]) {\n            case 'required':\n                return this._translate.instant('dataField.validations.required');\n            case 'minlength':\n                return this._translate.instant('dataField.validations.minLength', {length: this.MIN_PASSWORD_LENGTH});\n            case 'mismatchedPassword':\n                return this._translate.instant('forms.register.passwordsMustMatch');\n        }\n    }\n\n    protected abstract createRequestBody(): UserRegistrationRequest;\n\n    protected abstract callRegistration(requestBody: UserRegistrationRequest): Observable<MessageResource>;\n}\n"]}

package/esm5/lib/forms/models/password.validator.js

@@ -0,0 +1,21 @@
+/**
+ * Validator to check that passwords are the same
+ */
+export function passwordValidator(control) {
+    var password = control.get('password');
+    var confirmPassword = control.get('confirmPassword');
+    if (!password || !confirmPassword) {
+        return null;
+    }
+    if (password.pristine || confirmPassword.pristine) {
+        return null;
+    }
+    if (password && confirmPassword && password.value !== confirmPassword.value) {
+        confirmPassword.setErrors({ mismatchedPassword: true });
+        return { misMatch: true };
+    }
+    else {
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFzc3dvcmQudmFsaWRhdG9yLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL2Zvcm1zL21vZGVscy9wYXNzd29yZC52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7O0dBRUc7QUFDSCxNQUFNLFVBQVUsaUJBQWlCLENBQUMsT0FBd0I7SUFDdEQsSUFBTSxRQUFRLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUN6QyxJQUFNLGVBQWUsR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDdkQsSUFBSSxDQUFDLFFBQVEsSUFBSSxDQUFDLGVBQWUsRUFBRTtRQUMvQixPQUFPLElBQUksQ0FBQztLQUNmO0lBQ0QsSUFBSSxRQUFRLENBQUMsUUFBUSxJQUFJLGVBQWUsQ0FBQyxRQUFRLEVBQUU7UUFDL0MsT0FBTyxJQUFJLENBQUM7S0FDZjtJQUNELElBQUksUUFBUSxJQUFJLGVBQWUsSUFBSSxRQUFRLENBQUMsS0FBSyxLQUFLLGVBQWUsQ0FBQyxLQUFLLEVBQUU7UUFDekUsZUFBZSxDQUFDLFNBQVMsQ0FBQyxFQUFDLGtCQUFrQixFQUFFLElBQUksRUFBQyxDQUFDLENBQUM7UUFDdEQsT0FBTyxFQUFDLFFBQVEsRUFBRSxJQUFJLEVBQUMsQ0FBQztLQUMzQjtTQUFNO1FBQ0gsT0FBTyxJQUFJLENBQUM7S0FDZjtBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0Fic3RyYWN0Q29udHJvbH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuXG4vKipcbiAqIFZhbGlkYXRvciB0byBjaGVjayB0aGF0IHBhc3N3b3JkcyBhcmUgdGhlIHNhbWVcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHBhc3N3b3JkVmFsaWRhdG9yKGNvbnRyb2w6IEFic3RyYWN0Q29udHJvbCk6IHsgW2tleTogc3RyaW5nXTogYm9vbGVhbiB9IHwgbnVsbCB7XG4gICAgY29uc3QgcGFzc3dvcmQgPSBjb250cm9sLmdldCgncGFzc3dvcmQnKTtcbiAgICBjb25zdCBjb25maXJtUGFzc3dvcmQgPSBjb250cm9sLmdldCgnY29uZmlybVBhc3N3b3JkJyk7XG4gICAgaWYgKCFwYXNzd29yZCB8fCAhY29uZmlybVBhc3N3b3JkKSB7XG4gICAgICAgIHJldHVybiBudWxsO1xuICAgIH1cbiAgICBpZiAocGFzc3dvcmQucHJpc3RpbmUgfHwgY29uZmlybVBhc3N3b3JkLnByaXN0aW5lKSB7XG4gICAgICAgIHJldHVybiBudWxsO1xuICAgIH1cbiAgICBpZiAocGFzc3dvcmQgJiYgY29uZmlybVBhc3N3b3JkICYmIHBhc3N3b3JkLnZhbHVlICE9PSBjb25maXJtUGFzc3dvcmQudmFsdWUpIHtcbiAgICAgICAgY29uZmlybVBhc3N3b3JkLnNldEVycm9ycyh7bWlzbWF0Y2hlZFBhc3N3b3JkOiB0cnVlfSk7XG4gICAgICAgIHJldHVybiB7bWlzTWF0Y2g6IHRydWV9O1xuICAgIH0gZWxzZSB7XG4gICAgICAgIHJldHVybiBudWxsO1xuICAgIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,7 @@
+export * from './email-submission/abstract-email-submission-form.component';
+export * from './login/abstract-login-form.component';
+export * from './registration/abstract-registration-form.component';
+export * from './forgotten-password/abstract-forgotten-password.component';
+export * from './models/abstract-registration.component';
+export * from './has-form';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9mb3Jtcy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNkRBQTZELENBQUM7QUFDNUUsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLHFEQUFxRCxDQUFDO0FBQ3BFLGNBQWMsNERBQTRELENBQUM7QUFDM0UsY0FBYywwQ0FBMEMsQ0FBQztBQUV6RCxjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZW1haWwtc3VibWlzc2lvbi9hYnN0cmFjdC1lbWFpbC1zdWJtaXNzaW9uLWZvcm0uY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbG9naW4vYWJzdHJhY3QtbG9naW4tZm9ybS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9yZWdpc3RyYXRpb24vYWJzdHJhY3QtcmVnaXN0cmF0aW9uLWZvcm0uY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZm9yZ290dGVuLXBhc3N3b3JkL2Fic3RyYWN0LWZvcmdvdHRlbi1wYXNzd29yZC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvYWJzdHJhY3QtcmVnaXN0cmF0aW9uLmNvbXBvbmVudCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vaGFzLWZvcm0nO1xuIl19

package/esm5/lib/forms/registration/abstract-registration-form.component.js

@@ -0,0 +1,42 @@
+import { __extends } from "tslib";
+import { Validators } from '@angular/forms';
+import { passwordValidator } from '../models/password.validator';
+import { AbstractRegistrationComponent } from '../models/abstract-registration.component';
+import { Input } from '@angular/core';
+/**
+ * Holds the logic of the `RegistrationFormComponent`.
+ */
+var AbstractRegistrationFormComponent = /** @class */ (function (_super) {
+    __extends(AbstractRegistrationFormComponent, _super);
+    function AbstractRegistrationFormComponent(formBuilder, signupService, log, translate) {
+        var _this = _super.call(this, signupService, log, translate) || this;
+        _this.displayLegalNotice = true;
+        _this.rootFormGroup = formBuilder.group({
+            name: ['', Validators.required],
+            surname: ['', Validators.required],
+            password: ['', [Validators.required, Validators.minLength(_this.MIN_PASSWORD_LENGTH)]],
+            confirmPassword: ['', [Validators.required, Validators.minLength(_this.MIN_PASSWORD_LENGTH)]]
+        }, { validator: passwordValidator });
+        return _this;
+    }
+    AbstractRegistrationFormComponent.prototype.ngOnDestroy = function () {
+        _super.prototype.ngOnDestroy.call(this);
+    };
+    AbstractRegistrationFormComponent.prototype.createRequestBody = function () {
+        return {
+            token: undefined,
+            name: this.rootFormGroup.controls['name'].value,
+            surname: this.rootFormGroup.controls['surname'].value,
+            password: this.rootFormGroup.controls['password'].value
+        };
+    };
+    AbstractRegistrationFormComponent.prototype.callRegistration = function (requestBody) {
+        return this._signupService.signup(requestBody);
+    };
+    AbstractRegistrationFormComponent.propDecorators = {
+        displayLegalNotice: [{ type: Input }]
+    };
+    return AbstractRegistrationFormComponent;
+}(AbstractRegistrationComponent));
+export { AbstractRegistrationFormComponent };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,3 @@
+export * from './services/next-group.service';
+export * from './services/active-group.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9ncm91cHMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsaUNBQWlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL25leHQtZ3JvdXAuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2FjdGl2ZS1ncm91cC5zZXJ2aWNlJztcbiJdfQ==

package/esm5/lib/groups/services/active-group.service.js

@@ -0,0 +1,107 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { NextGroupService } from './next-group.service';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./next-group.service";
+/**
+ * This service to the groups that are "active" for the logged user.
+ *
+ * The meaning of "active" can wary from application to application. And this service provides the utility to track this state.
+ *
+ * The active groups are assumed to be a subset of the groups the logged user is a member of,
+ * but this assumption is not enforced nor checked.
+ *
+ * If at most one group can be active at a time, this service provides utility methods to access this group directly.
+ *
+ * The groups are assumed to be instances of the engine group process, this is never checked nor enforced.
+ *
+ * In the default implementation the initially active groups are all the groups the logged user is a member of.
+ */
+var ActiveGroupService = /** @class */ (function () {
+    function ActiveGroupService(_groupService) {
+        var _this = this;
+        this._groupService = _groupService;
+        this._activeGroups$ = new BehaviorSubject([]);
+        this._groupSub = this._groupService.memberGroups$.subscribe(function (groups) {
+            _this._activeGroups$.next(groups);
+        });
+    }
+    ActiveGroupService.prototype.ngOnDestroy = function () {
+        this._groupSub.unsubscribe();
+        this._activeGroups$.complete();
+    };
+    Object.defineProperty(ActiveGroupService.prototype, "activeGroups$", {
+        /**
+         * In the default implementation this stream copies the values of the [memberGroups$]{@link NextGroupService#memberGroups$} stream
+         * of the {@link NextGroupService}. Whenever the copies stream emits, the underlying stream in this class emits the same value.
+         *
+         * @returns an Observable of all the groups that are currently active
+         */
+        get: function () {
+            return this._activeGroups$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ActiveGroupService.prototype, "activeGroups", {
+        get: function () {
+            return this._activeGroups$.getValue();
+        },
+        set: function (activeGroups) {
+            this._activeGroups$.next(activeGroups);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ActiveGroupService.prototype, "activeGroup$", {
+        /**
+         * @returns an Observable containing the first element of the [activeGroups$]{@link ActiveGroupService#activeGroups$} observable,
+         * or `undefined` if the contained array is empty
+         */
+        get: function () {
+            return this.activeGroups$.pipe(map(function (array) { return array.length > 0 ? array[0] : undefined; }));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ActiveGroupService.prototype, "activeGroup", {
+        /**
+         * @returns the first element of the [activeGroups]{@link ActiveGroupService#activeGroups} array, or `undefined` if the array is empty
+         */
+        get: function () {
+            var activeGroups = this.activeGroups;
+            return activeGroups.length > 0 ? activeGroups[0] : undefined;
+        },
+        /**
+         * Emits a new array into the [activeGroups$]{@link ActiveGroupService#activeGroups$} observable, that contains only
+         * the provided {@link Case} object. If `undefined` is passed as argument, an empty array will be pushed into the observable.
+         * @param activeGroup the new active group case reference
+         */
+        set: function (activeGroup) {
+            if (activeGroup === undefined) {
+                this._activeGroups$.next([]);
+            }
+            else {
+                this._activeGroups$.next([activeGroup]);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ActiveGroupService.ctorParameters = function () { return [
+        { type: NextGroupService }
+    ]; };
+    ActiveGroupService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ActiveGroupService_Factory() { return new ActiveGroupService(i0.ɵɵinject(i1.NextGroupService)); }, token: ActiveGroupService, providedIn: "root" });
+    ActiveGroupService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    ActiveGroupService.ctorParameters = function () { return [
+        { type: NextGroupService }
+    ]; };
+    return ActiveGroupService;
+}());
+export { ActiveGroupService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/groups/services/next-group.service.js

@@ -0,0 +1,135 @@
+import { Injectable } from '@angular/core';
+import { UserService } from '../../user/services/user.service';
+import { CaseResourceService } from '../../resources/engine-endpoint/case-resource.service';
+import { SimpleFilter } from '../../filter/models/simple-filter';
+import { HttpParams } from '@angular/common/http';
+import { map, switchMap } from 'rxjs/operators';
+import { BehaviorSubject, of } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../user/services/user.service";
+import * as i2 from "../../resources/engine-endpoint/case-resource.service";
+/**
+ * This service allows access to information about the groups of the currently logged user.
+ *
+ * If no user is logged an empty array is provided.
+ *
+ * If a user can be owner of at most one group, this service provides utility methods to access this group directly.
+ *
+ * The groups are assumed to be instances of the engine group process, this is never checked nor enforced.
+ */
+var NextGroupService = /** @class */ (function () {
+    function NextGroupService(_userService, _caseResourceService) {
+        var _this = this;
+        this._userService = _userService;
+        this._caseResourceService = _caseResourceService;
+        this._ownerGroups$ = new BehaviorSubject([]);
+        this._memberGroups$ = new BehaviorSubject([]);
+        this._userSub = this._userService.user$.pipe(switchMap(function (user) {
+            if (user.id === '') {
+                return of([]);
+            }
+            var params = new HttpParams();
+            params.set('size', "" + user.nextGroups.length);
+            return _this._caseResourceService.searchCases(SimpleFilter.fromCaseQuery({ stringId: user.nextGroups }), params)
+                .pipe(map(function (page) { return page.content ? page.content : []; }), map(function (groups) { return groups.filter(function (group) { return group.author.fullName !== 'application engine'; }); }));
+        })).subscribe(function (groups) {
+            var ownerGroups = groups.filter(function (g) { return g.author.email === _this._userService.user.email; });
+            _this._ownerGroups$.next(ownerGroups);
+            _this._memberGroups$.next(groups);
+        });
+    }
+    NextGroupService.prototype.ngOnDestroy = function () {
+        this._userSub.unsubscribe();
+        this._memberGroups$.complete();
+        this._ownerGroups$.complete();
+    };
+    Object.defineProperty(NextGroupService.prototype, "memberGroups$", {
+        /**
+         * @returns an Observable of all the groups the currently logged user is a member of
+         */
+        get: function () {
+            return this._memberGroups$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NextGroupService.prototype, "ownerGroups$", {
+        /**
+         * @returns an Observable of all the groups the currently logged user is an owner of
+         */
+        get: function () {
+            return this._ownerGroups$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NextGroupService.prototype, "memberGroups", {
+        /**
+         * @returns an Array of all the groups the currently logged user is a member of
+         */
+        get: function () {
+            return this._memberGroups$.getValue();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NextGroupService.prototype, "ownerGroups", {
+        /**
+         * @returns an Array of all the groups the currently logged user is an owner of
+         */
+        get: function () {
+            return this._ownerGroups$.getValue();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NextGroupService.prototype, "firstOwnerGroup$", {
+        /**
+         * @returns an Observable containing the first element of the [ownerGroups$]{@link NextGroupService#ownerGroups$} observable,
+         * or `undefined` if the contained array is empty
+         */
+        get: function () {
+            return this._ownerGroups$.pipe(map(function (array) { return array.length > 0 ? array[0] : undefined; }));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NextGroupService.prototype, "firstOwnerGroup", {
+        /**
+         * @returns the first element of the [ownerGroups]{@link NextGroupService#ownerGroups} array, or `undefined` if the array is empty
+         */
+        get: function () {
+            var ownerGroups = this.ownerGroups;
+            return ownerGroups.length > 0 ? ownerGroups[0] : undefined;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NextGroupService.prototype, "groupOfUser", {
+        /**
+         * @deprecated in NAE 5.6.0 - use [ownerGroups]{@link NextGroupService#ownerGroups} instead
+         */
+        get: function () {
+            return this.ownerGroups;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    NextGroupService.ctorParameters = function () { return [
+        { type: UserService },
+        { type: CaseResourceService }
+    ]; };
+    NextGroupService.ɵprov = i0.ɵɵdefineInjectable({ factory: function NextGroupService_Factory() { return new NextGroupService(i0.ɵɵinject(i1.UserService), i0.ɵɵinject(i2.CaseResourceService)); }, token: NextGroupService, providedIn: "root" });
+    NextGroupService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    NextGroupService.ctorParameters = function () { return [
+        { type: UserService },
+        { type: CaseResourceService }
+    ]; };
+    return NextGroupService;
+}());
+export { NextGroupService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"next-group.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/groups/services/next-group.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAY,MAAM,eAAe,CAAC;AACpD,OAAO,EAAC,WAAW,EAAC,MAAM,kCAAkC,CAAC;AAC7D,OAAO,EAAC,mBAAmB,EAAC,MAAM,uDAAuD,CAAC;AAC1F,OAAO,EAAC,YAAY,EAAC,MAAM,mCAAmC,CAAC;AAC/D,OAAO,EAAC,UAAU,EAAC,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAC,GAAG,EAAE,SAAS,EAAC,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EAAC,eAAe,EAAc,EAAE,EAAe,MAAM,MAAM,CAAC;;;;AAEnE;;;;;;;;GAQG;AACH;IAUI,0BAAsB,YAAyB,EAAY,oBAAyC;QAApG,iBAwBC;QAxBqB,iBAAY,GAAZ,YAAY,CAAa;QAAY,yBAAoB,GAApB,oBAAoB,CAAqB;QAChG,IAAI,CAAC,aAAa,GAAG,IAAI,eAAe,CAAc,EAAE,CAAC,CAAC;QAC1D,IAAI,CAAC,cAAc,GAAG,IAAI,eAAe,CAAc,EAAE,CAAC,CAAC;QAE3D,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,CACxC,SAAS,CAAC,UAAA,IAAI;YACV,IAAI,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE;gBAChB,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;aACjB;YAED,IAAM,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;YAChC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,KAAI,IAAY,CAAC,UAAU,CAAC,MAAQ,CAAC,CAAC;YAEzD,OAAO,KAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,YAAY,CAAC,aAAa,CAAC,EAAC,QAAQ,EAAG,IAAY,CAAC,UAAU,EAAC,CAAC,EAAE,MAAM,CAAC;iBACjH,IAAI,CACD,GAAG,CAAC,UAAA,IAAI,IAAI,OAAA,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAhC,CAAgC,CAAC,EAC7C,GAAG,CAAC,UAAA,MAAM,IAAI,OAAA,MAAM,CAAC,MAAM,CAAC,UAAA,KAAK,IAAI,OAAA,KAAK,CAAC,MAAM,CAAC,QAAQ,KAAK,oBAAoB,EAA9C,CAA8C,CAAC,EAAtE,CAAsE,CAAC,CACxF,CAAC;QACV,CAAC,CAAC,CACL,CAAC,SAAS,CAAC,UAAA,MAAM;YACd,IAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,MAAM,CAAC,KAAK,KAAK,KAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,EAA/C,CAA+C,CAAC,CAAC;YACxF,KAAI,CAAC,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YACrC,KAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,sCAAW,GAAX;QACI,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;QAC5B,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,CAAC;QAC/B,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;IAClC,CAAC;IAKD,sBAAW,2CAAa;QAHxB;;WAEG;aACH;YACI,OAAO,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC;QAC9C,CAAC;;;OAAA;IAKD,sBAAW,0CAAY;QAHvB;;WAEG;aACH;YACI,OAAO,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC;QAC7C,CAAC;;;OAAA;IAKD,sBAAW,0CAAY;QAHvB;;WAEG;aACH;YACI,OAAO,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,CAAC;QAC1C,CAAC;;;OAAA;IAKD,sBAAW,yCAAW;QAHtB;;WAEG;aACH;YACI,OAAO,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;QACzC,CAAC;;;OAAA;IAMD,sBAAW,8CAAgB;QAJ3B;;;WAGG;aACH;YACI,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,UAAA,KAAK,IAAI,OAAA,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,EAAvC,CAAuC,CAAC,CAAC,CAAC;QAC1F,CAAC;;;OAAA;IAKD,sBAAW,6CAAe;QAH1B;;WAEG;aACH;YACI,IAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;YACrC,OAAO,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC/D,CAAC;;;OAAA;IAKD,sBAAI,yCAAW;QAHf;;WAEG;aACH;YACI,OAAO,IAAI,CAAC,WAAW,CAAC;QAC5B,CAAC;;;OAAA;;gBAjFmC,WAAW;gBAAkC,mBAAmB;;;;gBAVvG,UAAU,SAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;;gBAnBO,WAAW;gBACX,mBAAmB;;2BAF3B;CA8GC,AA5FD,IA4FC;SAzFY,gBAAgB","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\nimport {UserService} from '../../user/services/user.service';\nimport {CaseResourceService} from '../../resources/engine-endpoint/case-resource.service';\nimport {SimpleFilter} from '../../filter/models/simple-filter';\nimport {HttpParams} from '@angular/common/http';\nimport {map, switchMap} from 'rxjs/operators';\nimport {Case} from '../../resources/interface/case';\nimport {BehaviorSubject, Observable, of, Subscription} from 'rxjs';\n\n/**\n * This service allows access to information about the groups of the currently logged user.\n *\n * If no user is logged an empty array is provided.\n *\n * If a user can be owner of at most one group, this service provides utility methods to access this group directly.\n *\n * The groups are assumed to be instances of the engine group process, this is never checked nor enforced.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class NextGroupService implements OnDestroy {\n\n    protected _memberGroups$: BehaviorSubject<Array<Case>>;\n    protected _ownerGroups$: BehaviorSubject<Array<Case>>;\n\n    private _userSub: Subscription;\n\n    constructor(protected _userService: UserService, protected _caseResourceService: CaseResourceService) {\n        this._ownerGroups$ = new BehaviorSubject<Array<Case>>([]);\n        this._memberGroups$ = new BehaviorSubject<Array<Case>>([]);\n\n        this._userSub = this._userService.user$.pipe(\n            switchMap(user => {\n                if (user.id === '') {\n                    return of([]);\n                }\n\n                const params = new HttpParams();\n                params.set('size', `${(user as any).nextGroups.length}`);\n\n                return this._caseResourceService.searchCases(SimpleFilter.fromCaseQuery({stringId: (user as any).nextGroups}), params)\n                    .pipe(\n                        map(page => page.content ? page.content : []),\n                        map(groups => groups.filter(group => group.author.fullName !== 'application engine'))\n                    );\n            })\n        ).subscribe(groups => {\n            const ownerGroups = groups.filter(g => g.author.email === this._userService.user.email);\n            this._ownerGroups$.next(ownerGroups);\n            this._memberGroups$.next(groups);\n        });\n    }\n\n    ngOnDestroy(): void {\n        this._userSub.unsubscribe();\n        this._memberGroups$.complete();\n        this._ownerGroups$.complete();\n    }\n\n    /**\n     * @returns an Observable of all the groups the currently logged user is a member of\n     */\n    public get memberGroups$(): Observable<Array<Case>> {\n        return this._memberGroups$.asObservable();\n    }\n\n    /**\n     * @returns an Observable of all the groups the currently logged user is an owner of\n     */\n    public get ownerGroups$(): Observable<Array<Case>> {\n        return this._ownerGroups$.asObservable();\n    }\n\n    /**\n     * @returns an Array of all the groups the currently logged user is a member of\n     */\n    public get memberGroups(): Array<Case> {\n        return this._memberGroups$.getValue();\n    }\n\n    /**\n     * @returns an Array of all the groups the currently logged user is an owner of\n     */\n    public get ownerGroups(): Array<Case> {\n        return this._ownerGroups$.getValue();\n    }\n\n    /**\n     * @returns an Observable containing the first element of the [ownerGroups$]{@link NextGroupService#ownerGroups$} observable,\n     * or `undefined` if the contained array is empty\n     */\n    public get firstOwnerGroup$(): Observable<Case | undefined> {\n        return this._ownerGroups$.pipe(map(array => array.length > 0 ? array[0] : undefined));\n    }\n\n    /**\n     * @returns the first element of the [ownerGroups]{@link NextGroupService#ownerGroups} array, or `undefined` if the array is empty\n     */\n    public get firstOwnerGroup(): Case | undefined {\n        const ownerGroups = this.ownerGroups;\n        return ownerGroups.length > 0 ? ownerGroups[0] : undefined;\n    }\n\n    /**\n     * @deprecated in NAE 5.6.0 - use [ownerGroups]{@link NextGroupService#ownerGroups} instead\n     */\n    get groupOfUser(): Array<Case> {\n        return this.ownerGroups;\n    }\n}\n"]}