@netgrif/components-core 6.0.1

package/esm2015/lib/forms/email-submission/abstract-email-submission-form.component.js

@@ -0,0 +1,31 @@
+import { EventEmitter, Input, Output } from '@angular/core';
+import { Validators } from '@angular/forms';
+export class AbstractEmailSubmissionFormComponent {
+    constructor(formBuilder) {
+        this.displayLegalNotice = true;
+        this.rootFormGroup = formBuilder.group({
+            email: ['', Validators.email]
+        });
+        this.formSubmit = new EventEmitter();
+        this.goBackButton = new EventEmitter();
+    }
+    ngOnDestroy() {
+        this.formSubmit.complete();
+        this.goBackButton.complete();
+    }
+    emitGoBack() {
+        this.goBackButton.emit();
+    }
+    onSubmit() {
+        if (!this.rootFormGroup.valid) {
+            return;
+        }
+        this.formSubmit.emit({ email: this.rootFormGroup.controls['email'].value });
+    }
+}
+AbstractEmailSubmissionFormComponent.propDecorators = {
+    displayLegalNotice: [{ type: Input }],
+    formSubmit: [{ type: Output }],
+    goBackButton: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/forms/forgotten-password/abstract-forgotten-password.component.js

@@ -0,0 +1,32 @@
+import { AbstractRegistrationComponent } from '../models/abstract-registration.component';
+import { passwordValidator } from '../models/password.validator';
+import { Validators } from '@angular/forms';
+import { Input } from '@angular/core';
+export class AbstractForgottenPasswordComponent extends AbstractRegistrationComponent {
+    constructor(formBuilder, signupService, log, translate) {
+        super(signupService, log, translate);
+        this.displayLegalNotice = false;
+        this.rootFormGroup = formBuilder.group({
+            password: ['', [Validators.required, Validators.minLength(this.MIN_PASSWORD_LENGTH)]],
+            confirmPassword: ['', [Validators.required, Validators.minLength(this.MIN_PASSWORD_LENGTH)]]
+        }, { validator: passwordValidator });
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+    }
+    createRequestBody() {
+        return {
+            token: undefined,
+            name: undefined,
+            surname: undefined,
+            password: this.rootFormGroup.controls['password'].value
+        };
+    }
+    callRegistration(requestBody) {
+        return this._signupService.recoverPassword(requestBody.token, requestBody.password);
+    }
+}
+AbstractForgottenPasswordComponent.propDecorators = {
+    displayLegalNotice: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtZm9yZ290dGVuLXBhc3N3b3JkLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9mb3Jtcy9mb3Jnb3R0ZW4tcGFzc3dvcmQvYWJzdHJhY3QtZm9yZ290dGVuLXBhc3N3b3JkLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsNkJBQTZCLEVBQUMsTUFBTSwyQ0FBMkMsQ0FBQztBQUN4RixPQUFPLEVBQUMsaUJBQWlCLEVBQUMsTUFBTSw4QkFBOEIsQ0FBQztBQUcvRCxPQUFPLEVBQWMsVUFBVSxFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFLdkQsT0FBTyxFQUFDLEtBQUssRUFBWSxNQUFNLGVBQWUsQ0FBQztBQUUvQyxNQUFNLE9BQWdCLGtDQUFtQyxTQUFRLDZCQUE2QjtJQUkxRixZQUFzQixXQUF3QixFQUN4QixhQUE0QixFQUM1QixHQUFrQixFQUNsQixTQUEyQjtRQUM3QyxLQUFLLENBQUMsYUFBYSxFQUFFLEdBQUcsRUFBRSxTQUFTLENBQUMsQ0FBQztRQU56Qix1QkFBa0IsR0FBRyxLQUFLLENBQUM7UUFPdkMsSUFBSSxDQUFDLGFBQWEsR0FBRyxXQUFXLENBQUMsS0FBSyxDQUFDO1lBQ25DLFFBQVEsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDLFVBQVUsQ0FBQyxRQUFRLEVBQUUsVUFBVSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsbUJBQW1CLENBQUMsQ0FBQyxDQUFDO1lBQ3JGLGVBQWUsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDLFVBQVUsQ0FBQyxRQUFRLEVBQUUsVUFBVSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsbUJBQW1CLENBQUMsQ0FBQyxDQUFDO1NBQy9GLEVBQUUsRUFBQyxTQUFTLEVBQUUsaUJBQWlCLEVBQUMsQ0FBQyxDQUFDO0lBQ3ZDLENBQUM7SUFFRCxXQUFXO1FBQ1AsS0FBSyxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQ3hCLENBQUM7SUFFUyxpQkFBaUI7UUFDdkIsT0FBTztZQUNILEtBQUssRUFBRSxTQUFTO1lBQ2hCLElBQUksRUFBRSxTQUFTO1lBQ2YsT0FBTyxFQUFFLFNBQVM7WUFDbEIsUUFBUSxFQUFFLElBQUksQ0FBQyxhQUFhLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxDQUFDLEtBQUs7U0FDMUQsQ0FBQztJQUNOLENBQUM7SUFFUyxnQkFBZ0IsQ0FBQyxXQUFvQztRQUMzRCxPQUFPLElBQUksQ0FBQyxjQUFjLENBQUMsZUFBZSxDQUFDLFdBQVcsQ0FBQyxLQUFLLEVBQUUsV0FBVyxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ3hGLENBQUM7OztpQ0E1QkEsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7QWJzdHJhY3RSZWdpc3RyYXRpb25Db21wb25lbnR9IGZyb20gJy4uL21vZGVscy9hYnN0cmFjdC1yZWdpc3RyYXRpb24uY29tcG9uZW50JztcbmltcG9ydCB7cGFzc3dvcmRWYWxpZGF0b3J9IGZyb20gJy4uL21vZGVscy9wYXNzd29yZC52YWxpZGF0b3InO1xuaW1wb3J0IHtTaWduVXBTZXJ2aWNlfSBmcm9tICcuLi8uLi9hdXRoZW50aWNhdGlvbi9zaWduLXVwL3NlcnZpY2VzL3NpZ24tdXAuc2VydmljZSc7XG5pbXBvcnQge0xvZ2dlclNlcnZpY2V9IGZyb20gJy4uLy4uL2xvZ2dlci9zZXJ2aWNlcy9sb2dnZXIuc2VydmljZSc7XG5pbXBvcnQge0Zvcm1CdWlsZGVyLCBWYWxpZGF0b3JzfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQge1VzZXJSZWdpc3RyYXRpb25SZXF1ZXN0fSBmcm9tICcuLi8uLi9hdXRoZW50aWNhdGlvbi9zaWduLXVwL21vZGVscy91c2VyLXJlZ2lzdHJhdGlvbi1yZXF1ZXN0JztcbmltcG9ydCB7T2JzZXJ2YWJsZX0gZnJvbSAncnhqcyc7XG5pbXBvcnQge01lc3NhZ2VSZXNvdXJjZX0gZnJvbSAnLi4vLi4vcmVzb3VyY2VzL2ludGVyZmFjZS9tZXNzYWdlLXJlc291cmNlJztcbmltcG9ydCB7VHJhbnNsYXRlU2VydmljZX0gZnJvbSAnQG5neC10cmFuc2xhdGUvY29yZSc7XG5pbXBvcnQge0lucHV0LCBPbkRlc3Ryb3l9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQWJzdHJhY3RGb3Jnb3R0ZW5QYXNzd29yZENvbXBvbmVudCBleHRlbmRzIEFic3RyYWN0UmVnaXN0cmF0aW9uQ29tcG9uZW50IGltcGxlbWVudHMgT25EZXN0cm95IHtcblxuICAgIEBJbnB1dCgpIHB1YmxpYyBkaXNwbGF5TGVnYWxOb3RpY2UgPSBmYWxzZTtcblxuICAgIHByb3RlY3RlZCBjb25zdHJ1Y3Rvcihmb3JtQnVpbGRlcjogRm9ybUJ1aWxkZXIsXG4gICAgICAgICAgICAgICAgICAgICAgICAgIHNpZ251cFNlcnZpY2U6IFNpZ25VcFNlcnZpY2UsXG4gICAgICAgICAgICAgICAgICAgICAgICAgIGxvZzogTG9nZ2VyU2VydmljZSxcbiAgICAgICAgICAgICAgICAgICAgICAgICAgdHJhbnNsYXRlOiBUcmFuc2xhdGVTZXJ2aWNlKSB7XG4gICAgICAgIHN1cGVyKHNpZ251cFNlcnZpY2UsIGxvZywgdHJhbnNsYXRlKTtcbiAgICAgICAgdGhpcy5yb290Rm9ybUdyb3VwID0gZm9ybUJ1aWxkZXIuZ3JvdXAoe1xuICAgICAgICAgICAgcGFzc3dvcmQ6IFsnJywgW1ZhbGlkYXRvcnMucmVxdWlyZWQsIFZhbGlkYXRvcnMubWluTGVuZ3RoKHRoaXMuTUlOX1BBU1NXT1JEX0xFTkdUSCldXSxcbiAgICAgICAgICAgIGNvbmZpcm1QYXNzd29yZDogWycnLCBbVmFsaWRhdG9ycy5yZXF1aXJlZCwgVmFsaWRhdG9ycy5taW5MZW5ndGgodGhpcy5NSU5fUEFTU1dPUkRfTEVOR1RIKV1dXG4gICAgICAgIH0sIHt2YWxpZGF0b3I6IHBhc3N3b3JkVmFsaWRhdG9yfSk7XG4gICAgfVxuXG4gICAgbmdPbkRlc3Ryb3koKTogdm9pZCB7XG4gICAgICAgIHN1cGVyLm5nT25EZXN0cm95KCk7XG4gICAgfVxuXG4gICAgcHJvdGVjdGVkIGNyZWF0ZVJlcXVlc3RCb2R5KCk6IFVzZXJSZWdpc3RyYXRpb25SZXF1ZXN0IHtcbiAgICAgICAgcmV0dXJuIHtcbiAgICAgICAgICAgIHRva2VuOiB1bmRlZmluZWQsXG4gICAgICAgICAgICBuYW1lOiB1bmRlZmluZWQsXG4gICAgICAgICAgICBzdXJuYW1lOiB1bmRlZmluZWQsXG4gICAgICAgICAgICBwYXNzd29yZDogdGhpcy5yb290Rm9ybUdyb3VwLmNvbnRyb2xzWydwYXNzd29yZCddLnZhbHVlXG4gICAgICAgIH07XG4gICAgfVxuXG4gICAgcHJvdGVjdGVkIGNhbGxSZWdpc3RyYXRpb24ocmVxdWVzdEJvZHk6IFVzZXJSZWdpc3RyYXRpb25SZXF1ZXN0KTogT2JzZXJ2YWJsZTxNZXNzYWdlUmVzb3VyY2U+IHtcbiAgICAgICAgcmV0dXJuIHRoaXMuX3NpZ251cFNlcnZpY2UucmVjb3ZlclBhc3N3b3JkKHJlcXVlc3RCb2R5LnRva2VuLCByZXF1ZXN0Qm9keS5wYXNzd29yZCk7XG4gICAgfVxufVxuIl19

package/esm2015/lib/forms/has-form.js

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

package/esm2015/lib/forms/login/abstract-login-form.component.js

@@ -0,0 +1,58 @@
+import { EventEmitter, Input, Output } from '@angular/core';
+import { LoadingEmitter } from '../../utility/loading-emitter';
+import { take } from 'rxjs/operators';
+export class AbstractLoginFormComponent {
+    constructor(formBuilder, _userService) {
+        this._userService = _userService;
+        this.hidePassword = true;
+        this.rootFormGroup = formBuilder.group({
+            login: [''],
+            password: ['']
+        });
+        this.login = new EventEmitter();
+        this.resetPassword = new EventEmitter();
+        this.signUp = new EventEmitter();
+        this.formSubmit = new EventEmitter();
+        this.loading = new LoadingEmitter();
+    }
+    ngOnDestroy() {
+        this.loading.complete();
+        this.login.complete();
+        this.resetPassword.complete();
+        this.signUp.complete();
+        this.formSubmit.complete();
+    }
+    onSubmit() {
+        if (!this.rootFormGroup.valid || this.loading.isActive) {
+            return;
+        }
+        const credential = { username: this.rootFormGroup.controls['login'].value, password: this.rootFormGroup.controls['password'].value };
+        this.loading.on();
+        this.formSubmit.emit(credential);
+        this._userService.login(credential).pipe(take(1)).subscribe((user) => {
+            this.login.emit(user);
+            this.loading.off();
+        });
+    }
+    resetEmit() {
+        this.resetPassword.emit();
+    }
+    signUpEmit() {
+        this.signUp.emit();
+    }
+    getButtonsFxLayoutAlign() {
+        if (this.showSignUpButton || this.showForgottenPasswordButton) {
+            return 'space-between';
+        }
+        return 'end';
+    }
+}
+AbstractLoginFormComponent.propDecorators = {
+    showSignUpButton: [{ type: Input }],
+    showForgottenPasswordButton: [{ type: Input }],
+    login: [{ type: Output }],
+    resetPassword: [{ type: Output }],
+    signUp: [{ type: Output }],
+    formSubmit: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,94 @@
+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`.
+ */
+export class AbstractRegistrationComponent {
+    constructor(_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);
+    }
+    ngOnDestroy() {
+        this.formSubmit.complete();
+        this.register.complete();
+        this.invalidToken.complete();
+        this.loadingToken.complete();
+    }
+    set token(token) {
+        this._token = token;
+        if (!this._token) {
+            this._tokenVerified = false;
+            return;
+        }
+        this.loadingToken.on();
+        this._signupService.verify(this._token).pipe(take(1)).subscribe(message => {
+            this._log.info('Token ' + this._token + ' has been successfully verified');
+            if (message.success) {
+                this.userEmail = message.success;
+            }
+            this._tokenVerified = true;
+            this.loadingToken.off();
+        }, (error) => {
+            this._log.error(error.message);
+            this._tokenVerified = false;
+            this.loadingToken.off();
+            this.invalidToken.emit();
+        });
+    }
+    get token() {
+        return this._token;
+    }
+    get tokenVerified() {
+        return this._tokenVerified;
+    }
+    onSubmit() {
+        if (!this.rootFormGroup.valid) {
+            return;
+        }
+        const 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(message => {
+            this.register.emit(message);
+        }, error => {
+            this.register.emit({ error });
+        });
+    }
+    isFieldValid(formControlName) {
+        return this.rootFormGroup.get(formControlName).valid;
+    }
+    getErrorMessage(formControlName) {
+        const 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 }]
+};
+//# 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/esm2015/lib/forms/models/password.validator.js

@@ -0,0 +1,21 @@
+/**
+ * Validator to check that passwords are the same
+ */
+export function passwordValidator(control) {
+    const password = control.get('password');
+    const 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFzc3dvcmQudmFsaWRhdG9yLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL2Zvcm1zL21vZGVscy9wYXNzd29yZC52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7O0dBRUc7QUFDSCxNQUFNLFVBQVUsaUJBQWlCLENBQUMsT0FBd0I7SUFDdEQsTUFBTSxRQUFRLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUN6QyxNQUFNLGVBQWUsR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDdkQsSUFBSSxDQUFDLFFBQVEsSUFBSSxDQUFDLGVBQWUsRUFBRTtRQUMvQixPQUFPLElBQUksQ0FBQztLQUNmO0lBQ0QsSUFBSSxRQUFRLENBQUMsUUFBUSxJQUFJLGVBQWUsQ0FBQyxRQUFRLEVBQUU7UUFDL0MsT0FBTyxJQUFJLENBQUM7S0FDZjtJQUNELElBQUksUUFBUSxJQUFJLGVBQWUsSUFBSSxRQUFRLENBQUMsS0FBSyxLQUFLLGVBQWUsQ0FBQyxLQUFLLEVBQUU7UUFDekUsZUFBZSxDQUFDLFNBQVMsQ0FBQyxFQUFDLGtCQUFrQixFQUFFLElBQUksRUFBQyxDQUFDLENBQUM7UUFDdEQsT0FBTyxFQUFDLFFBQVEsRUFBRSxJQUFJLEVBQUMsQ0FBQztLQUMzQjtTQUFNO1FBQ0gsT0FBTyxJQUFJLENBQUM7S0FDZjtBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0Fic3RyYWN0Q29udHJvbH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuXG4vKipcbiAqIFZhbGlkYXRvciB0byBjaGVjayB0aGF0IHBhc3N3b3JkcyBhcmUgdGhlIHNhbWVcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHBhc3N3b3JkVmFsaWRhdG9yKGNvbnRyb2w6IEFic3RyYWN0Q29udHJvbCk6IHsgW2tleTogc3RyaW5nXTogYm9vbGVhbiB9IHwgbnVsbCB7XG4gICAgY29uc3QgcGFzc3dvcmQgPSBjb250cm9sLmdldCgncGFzc3dvcmQnKTtcbiAgICBjb25zdCBjb25maXJtUGFzc3dvcmQgPSBjb250cm9sLmdldCgnY29uZmlybVBhc3N3b3JkJyk7XG4gICAgaWYgKCFwYXNzd29yZCB8fCAhY29uZmlybVBhc3N3b3JkKSB7XG4gICAgICAgIHJldHVybiBudWxsO1xuICAgIH1cbiAgICBpZiAocGFzc3dvcmQucHJpc3RpbmUgfHwgY29uZmlybVBhc3N3b3JkLnByaXN0aW5lKSB7XG4gICAgICAgIHJldHVybiBudWxsO1xuICAgIH1cbiAgICBpZiAocGFzc3dvcmQgJiYgY29uZmlybVBhc3N3b3JkICYmIHBhc3N3b3JkLnZhbHVlICE9PSBjb25maXJtUGFzc3dvcmQudmFsdWUpIHtcbiAgICAgICAgY29uZmlybVBhc3N3b3JkLnNldEVycm9ycyh7bWlzbWF0Y2hlZFBhc3N3b3JkOiB0cnVlfSk7XG4gICAgICAgIHJldHVybiB7bWlzTWF0Y2g6IHRydWV9O1xuICAgIH0gZWxzZSB7XG4gICAgICAgIHJldHVybiBudWxsO1xuICAgIH1cbn1cbiJdfQ==

package/esm2015/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/esm2015/lib/forms/registration/abstract-registration-form.component.js

@@ -0,0 +1,37 @@
+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`.
+ */
+export class AbstractRegistrationFormComponent extends AbstractRegistrationComponent {
+    constructor(formBuilder, signupService, log, translate) {
+        super(signupService, log, translate);
+        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 });
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+    }
+    createRequestBody() {
+        return {
+            token: undefined,
+            name: this.rootFormGroup.controls['name'].value,
+            surname: this.rootFormGroup.controls['surname'].value,
+            password: this.rootFormGroup.controls['password'].value
+        };
+    }
+    callRegistration(requestBody) {
+        return this._signupService.signup(requestBody);
+    }
+}
+AbstractRegistrationFormComponent.propDecorators = {
+    displayLegalNotice: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/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/esm2015/lib/groups/services/active-group.service.js

@@ -0,0 +1,88 @@
+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.
+ */
+export class ActiveGroupService {
+    constructor(_groupService) {
+        this._groupService = _groupService;
+        this._activeGroups$ = new BehaviorSubject([]);
+        this._groupSub = this._groupService.memberGroups$.subscribe(groups => {
+            this._activeGroups$.next(groups);
+        });
+    }
+    ngOnDestroy() {
+        this._groupSub.unsubscribe();
+        this._activeGroups$.complete();
+    }
+    /**
+     * 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 activeGroups$() {
+        return this._activeGroups$.asObservable();
+    }
+    get activeGroups() {
+        return this._activeGroups$.getValue();
+    }
+    set activeGroups(activeGroups) {
+        this._activeGroups$.next(activeGroups);
+    }
+    /**
+     * @returns an Observable containing the first element of the [activeGroups$]{@link ActiveGroupService#activeGroups$} observable,
+     * or `undefined` if the contained array is empty
+     */
+    get activeGroup$() {
+        return this.activeGroups$.pipe(map(array => array.length > 0 ? array[0] : undefined));
+    }
+    /**
+     * @returns the first element of the [activeGroups]{@link ActiveGroupService#activeGroups} array, or `undefined` if the array is empty
+     */
+    get activeGroup() {
+        const 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 activeGroup(activeGroup) {
+        if (activeGroup === undefined) {
+            this._activeGroups$.next([]);
+        }
+        else {
+            this._activeGroups$.next([activeGroup]);
+        }
+    }
+}
+ActiveGroupService.ctorParameters = () => [
+    { 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 = () => [
+    { type: NextGroupService }
+];
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,104 @@
+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.
+ */
+export class NextGroupService {
+    constructor(_userService, _caseResourceService) {
+        this._userService = _userService;
+        this._caseResourceService = _caseResourceService;
+        this._ownerGroups$ = new BehaviorSubject([]);
+        this._memberGroups$ = new BehaviorSubject([]);
+        this._userSub = this._userService.user$.pipe(switchMap(user => {
+            if (user.id === '') {
+                return of([]);
+            }
+            const params = new HttpParams();
+            params.set('size', `${user.nextGroups.length}`);
+            return this._caseResourceService.searchCases(SimpleFilter.fromCaseQuery({ stringId: user.nextGroups }), params)
+                .pipe(map(page => page.content ? page.content : []), map(groups => groups.filter(group => group.author.fullName !== 'application engine')));
+        })).subscribe(groups => {
+            const ownerGroups = groups.filter(g => g.author.email === this._userService.user.email);
+            this._ownerGroups$.next(ownerGroups);
+            this._memberGroups$.next(groups);
+        });
+    }
+    ngOnDestroy() {
+        this._userSub.unsubscribe();
+        this._memberGroups$.complete();
+        this._ownerGroups$.complete();
+    }
+    /**
+     * @returns an Observable of all the groups the currently logged user is a member of
+     */
+    get memberGroups$() {
+        return this._memberGroups$.asObservable();
+    }
+    /**
+     * @returns an Observable of all the groups the currently logged user is an owner of
+     */
+    get ownerGroups$() {
+        return this._ownerGroups$.asObservable();
+    }
+    /**
+     * @returns an Array of all the groups the currently logged user is a member of
+     */
+    get memberGroups() {
+        return this._memberGroups$.getValue();
+    }
+    /**
+     * @returns an Array of all the groups the currently logged user is an owner of
+     */
+    get ownerGroups() {
+        return this._ownerGroups$.getValue();
+    }
+    /**
+     * @returns an Observable containing the first element of the [ownerGroups$]{@link NextGroupService#ownerGroups$} observable,
+     * or `undefined` if the contained array is empty
+     */
+    get firstOwnerGroup$() {
+        return this._ownerGroups$.pipe(map(array => array.length > 0 ? array[0] : undefined));
+    }
+    /**
+     * @returns the first element of the [ownerGroups]{@link NextGroupService#ownerGroups} array, or `undefined` if the array is empty
+     */
+    get firstOwnerGroup() {
+        const ownerGroups = this.ownerGroups;
+        return ownerGroups.length > 0 ? ownerGroups[0] : undefined;
+    }
+    /**
+     * @deprecated in NAE 5.6.0 - use [ownerGroups]{@link NextGroupService#ownerGroups} instead
+     */
+    get groupOfUser() {
+        return this.ownerGroups;
+    }
+}
+NextGroupService.ctorParameters = () => [
+    { 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 = () => [
+    { type: UserService },
+    { type: CaseResourceService }
+];
+//# 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":"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","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"]}