@colijnit/sharedcomponents 261.1.0 → 261.1.2

package/projects/sharedcomponents/src/lib/components/login/components/login-change-password.component.ts

@@ -0,0 +1,178 @@
+import {Component, HostBinding, ViewChild, ViewEncapsulation} from '@angular/core';
+import {LoginBaseComponent} from './login-base.component';
+import {equalValidator, FormComponent, InputTextComponent, passwordValidator} from '@colijnit/corecomponents_v12';
+import {LoginStatus} from '@colijnit/ioneconnector/build/enum/login-status.enum';
+import {ValidatorFn} from '@angular/forms';
+import {LoginComponentExtraActionType} from '../../../enum/login-component-extra-action-type.enum';
+import {ActivateUserAccountStatus} from '@colijnit/ioneconnector/build/enum/activate-user-account-status.enum';
+import {HttpErrorResponse} from '@angular/common/http';
+import {LoginResponse} from '@colijnit/ioneconnector/build/model/login-response';
+import {LoginRequest} from '@colijnit/ioneconnector/build/model/login-request';
+
+@Component({
+    selector: 'co-login-change-password',
+    template: `
+        <co-form #formChangePassword (validityChange)="onFormValidityChange($event)">
+            <h2 [textContent]="(loginService.extraAction === extraActions.ChangePasswordAndActivateUser ? 'ACTIVATE_ACCOUNT' : 'CHANGE_PASSWORD') | sharedLocalize"></h2>
+            <p *ngIf="loginService.extraAction === extraActions.ChangePasswordAndActivateUser"
+               [textContent]="'CHANGE_PASSWORD_ACTIVATE_USER_MSG' | sharedLocalize"></p>
+            <div class="field-wrapper">
+                <co-input-text [(model)]="loginService.username" [placeholder]="'EMAIL_OR_USERNAME' | sharedLocalize"
+                               [leftIconData]="iconCacheService.getIcon(icons.Account)"
+                               #userNameInput [disabled]="true"></co-input-text>
+                <div class="input-text-and-button-container">
+                    <co-input-text [(model)]="loginService.password" type="password" class="password" [placeholder]="'NEW_PASSWORD' | sharedLocalize" required
+                                   #passwordInput
+                                   [leftIconData]="iconCacheService.getIcon(icons.Lock)"
+                                   [rightIconData]="iconCacheService.getIcon(icons.EyeRegular)"
+                                   [validators]="[passwordValidatorFn]"
+                                   (rightIconMouseDown)="handlePasswordShow($event)"
+                                   (rightIconMouseUp)="handlePasswordHide($event)"
+                    ></co-input-text>
+                    <!--
+                                        <co-button icon="magic_wand"
+                                                       tabindex="-1"
+                                                       (click)="generateRandomPassword()"
+                                                       (mouseenter)="handleGenerateButtonMouseEnter($event)"
+                                                       (mouseleave)="handleGenerateButtonMouseLeave($event)"></co-button>
+                    -->
+                </div>
+                <co-input-text [(model)]="repeatPassword" type="password" class="repeat-password"
+                               [placeholder]="'PASSWORD_REPEAT' | sharedLocalize" required #passwordRepeatInput
+                               [leftIconData]="iconCacheService.getIcon(icons.Lock)"
+                               [rightIconData]="iconCacheService.getIcon(icons.EyeRegular)"
+                               [validators]="[repeatPasswordValidatorFn]"
+                               (rightIconMouseDown)="handlePasswordRepeatShow($event)"
+                               (rightIconMouseUp)="handlePasswordRepeatHide($event)"
+                ></co-input-text>
+                <div class="login-validation-error-message" [textContent]="validationErrorMessage | sharedLocalize"></div>
+
+                <!--
+                                <co-list-of-values *ngIf="showLanguageSelect" doNotLoadCollection [collection]="languages" icon="dictionary" [(selectedModel)]="language"
+                                                    label="LANGUAGE" descriptionField="description" required></co-list-of-values>
+                -->
+            </div>
+            <div class="login-extended-wrapper">
+                <span class="password-requirement-message" [textContent]="'PASSWORD_MUST_BE_10_CHARACTERS' | sharedLocalize"></span>
+                <span class="password-requirement-message" [textContent]="'PASSWORD_MUST_CONTAIN_LETTER_NUMBER_SPECIAL' | sharedLocalize"></span>
+            </div>
+            <co-button class="login-submit-button" [label]="'COMPLETE' | sharedLocalize" [disabled]="!submitButtonEnabled"
+                       (click)="onChangePasswordButtonClick()"></co-button>
+        </co-form>
+        <re-captcha class="login-recaptcha" [class.hidden]="!showRecaptcha"
+                    [siteKey]="loginService.reCaptchaSiteKey"
+                    (resolved)="onChangePasswordSubmit($event)"
+                    (clickOutside)="hideRecaptcha()"></re-captcha>
+    `,
+    encapsulation: ViewEncapsulation.None
+})
+export class LoginChangePasswordComponent extends LoginBaseComponent {
+    @ViewChild('formChangePassword')
+    public formChangePassword: FormComponent;
+
+    @ViewChild('passwordInput')
+    public inputPassword: InputTextComponent;
+
+    @ViewChild('passwordRepeatInput')
+    public inputPasswordRepeat: InputTextComponent;
+
+    @HostBinding('class.co-login-change-password')
+    public showClass() {
+        return true;
+    }
+
+    public repeatPassword: string;
+
+    public handlePasswordShow(event: MouseEvent): void {
+        if (this.inputPassword) {
+            this.inputPassword.type = undefined;
+        }
+    }
+
+    public handlePasswordHide(event: MouseEvent): void {
+        if (this.inputPassword) {
+            this.inputPassword.type = 'password';
+        }
+    }
+
+    public handlePasswordRepeatShow(event: MouseEvent): void {
+        if (this.inputPasswordRepeat) {
+            this.inputPasswordRepeat.type = undefined;
+        }
+    }
+
+    public handlePasswordRepeatHide(event: MouseEvent): void {
+        if (this.inputPasswordRepeat) {
+            this.inputPasswordRepeat.type = 'password';
+        }
+    }
+
+    public async onChangePasswordButtonClick(): Promise<void> {
+        this.formChangePassword.submit();
+        this.showRecaptcha = true;
+    }
+
+    public async onChangePasswordSubmit(reCaptchaResponse: string): Promise<void> {
+        if (!reCaptchaResponse) {
+            return;
+        }
+        // if (!this.isChangePasswordFormValid()) {
+        //     return;
+        // }
+
+        let isChangePwSuccess: boolean;
+        try {
+            if (this.loginService.extraAction === LoginComponentExtraActionType.ChangePasswordAndActivateUser) {
+                let activateUserAccountStatus: ActivateUserAccountStatus;
+                activateUserAccountStatus = await
+                  this.loginService.changePasswordAndActivateUser(this.repeatPassword, this.loginService.securityCode, this.loginService.upId, reCaptchaResponse);
+                if (activateUserAccountStatus === ActivateUserAccountStatus.SUCCESS) {
+                    isChangePwSuccess = true;
+                } else {
+                    isChangePwSuccess = false;
+                    if (activateUserAccountStatus === ActivateUserAccountStatus.NOT_VALID_SECURITY_CODE) {
+                        this.validationErrorMessage = "SECURITY_CODE_NOT_VALID";
+                    } else if (activateUserAccountStatus === ActivateUserAccountStatus.ACCOUNT_IS_ALREADY_ACTIVE) {
+                        this.validationErrorMessage = "ACCOUNT_IS_ALREADY_ACTIVE";
+                    }
+                }
+            } else {
+                isChangePwSuccess = await this.loginService.changePassword(this.repeatPassword, this.loginService.securityCode, this.loginService.upId);
+            }
+        } catch (error) {
+            if (error instanceof HttpErrorResponse) {
+                this.validationErrorMessage = "CODE_NOT_FOUND_POSSIBLY_EXPIRED";
+            }
+            return;
+        }
+
+        if (isChangePwSuccess) {
+            // this.userService.userName = this._userNameInInitialUrl;
+            // this.userService.password = this.repeatPassword;
+            const loginRequest: LoginRequest = this.loginService.getLoginRequest();
+            let loginResponse: LoginResponse;
+            try {
+                loginResponse = await this.loginService.login(loginRequest);
+                if (loginResponse) {
+                    this.loginService.userPassword = loginResponse.password;
+                }
+            } catch (error) {
+                if (error instanceof HttpErrorResponse) {
+                    this.validationErrorMessage = error.message;
+                }
+                return;
+            }
+            this.handleLoginResponse(loginResponse);
+        }
+        this.recaptchaComponent.reset();
+        this.showRecaptcha = false;
+    }
+
+    public passwordValidatorFn: ValidatorFn = passwordValidator(() => {
+        return this.loginService.username;
+    });
+
+    public repeatPasswordValidatorFn: ValidatorFn = equalValidator(() => {
+        return this.loginService.password;
+    });
+}

package/projects/sharedcomponents/src/lib/components/login/components/login-mfa-code-entry.component.ts

@@ -0,0 +1,113 @@
+import {Component, HostBinding, Input, OnInit, ViewEncapsulation} from '@angular/core';
+import {Icon} from '../../../enum/icon.enum';
+import {LoginBaseComponent} from './login-base.component';
+import {LoginResponse} from '@colijnit/ioneconnector/build/model/login-response';
+import {HttpErrorResponse} from '@angular/common/http';
+import {FingerPrintResult} from '../interface/finger-print-result.interface';
+import {IconCacheService} from '../../../service/icon-cache.service';
+import {LoginService} from '../service/login.service';
+import {CoreDialogService, FormMasterService} from '@colijnit/corecomponents_v12';
+import {FingerPrintService} from '../service/finger-print.service';
+import {LoginAdapterService} from '../service/login-adapter.service';
+import {LoginComponentPageType} from '../../../enum/login-component-page.type.enum';
+import {SharedComponentsDictionaryService} from '../../../translation/shared-components-dictionary.service';
+
+@Component({
+    selector: 'co-login-mfa-code-entry',
+    template: `
+        <co-form (validityChange)="onFormValidityChange($event)">
+            <h2 [textContent]="'VERIFICATION_CODE' | sharedLocalize"></h2>
+            <span [textContent]="loginService.verificationCodeLabel | sharedLocalize"></span>
+            <co-input-code [(model)]="confirmationCode" [codePattern]="'3-3'"
+                           (completeChange)="onConfirmationCodeCompleteChange($event)"
+                           (keydown.enter)="onSendVerificationCodeBttnClick()">
+            </co-input-code>
+            <co-button #verificationCodeBttn type="submit" [label]="'SEND' | sharedLocalize" class="login"
+                       (click)="onSendVerificationCodeBttnClick()"
+                       [disabled]="sendConfirmationCodeBttnDisabled"></co-button>
+            <co-button *ngIf="isAvailableToResetGoogleAuth" [label]="'RESET_GOOGLE_AUTHENTICATOR' | sharedLocalize"
+                       (click)="onResetGoogleAuthClick()"></co-button>
+
+        </co-form>
+        <div class="footer">
+            <div (click)="onMfaGoBackClick()" class="back-button">
+                <co-icon [iconData]="iconCacheService.getIcon(icons.ArrowLeftRoundOpen)" class="dark"></co-icon>
+                <span [textContent]="'BACK' | sharedLocalize"></span>
+            </div>
+            <co-input-checkbox [(model)]="rememberDevice" [label]="'REMEMBER_DEVICE' | sharedLocalize"></co-input-checkbox>
+        </div>
+    `,
+    encapsulation: ViewEncapsulation.None
+})
+export class LoginMfaCodeEntryComponent extends LoginBaseComponent implements OnInit {
+    public readonly icons: typeof Icon = Icon;
+
+    @HostBinding('class.login-mfa-code-entry')
+    public showClass() {
+        return true;
+    }
+
+    public barCodeImageSource: string;
+    public confirmationCode: string;
+    public googleConfirmCode: string;
+    public rememberDevice: boolean = false;
+    public sendConfirmationCodeBttnDisabled: boolean = true;
+    public isAvailableToResetGoogleAuth: boolean = false;
+
+    constructor(
+      public iconCacheService: IconCacheService,
+      public loginService: LoginService,
+      protected dictionaryService: SharedComponentsDictionaryService,
+      protected formMasterService: FormMasterService,
+      protected dialogService: CoreDialogService,
+      private _fingerPrintService: FingerPrintService,
+      private _loginAdapter: LoginAdapterService
+    ) {
+        super(iconCacheService, loginService, dictionaryService, formMasterService, dialogService);
+    }
+
+    public async ngOnInit(): Promise<void> {
+        const mfaMethod = await this._loginAdapter.getMfaParameter(this.loginService.upId);
+        // mfaMethod === MfaSendMethodType.GoogleAuthenticator && this.loginStatus === LoginStatus.MFA_GOOGLE_CODE_CONFIRMATION_AWAIT;
+    }
+
+    public onConfirmationCodeCompleteChange(complete: boolean): void {
+        this.sendConfirmationCodeBttnDisabled = !complete;
+    }
+
+    public async onSendVerificationCodeBttnClick(): Promise<void> {
+        let loginResponse: LoginResponse;
+        try {
+            const fingerPrintResult: FingerPrintResult = await this._fingerPrintService.getFingerPrint();
+            loginResponse = await this.loginService.confirmCode(this.loginService.upId, this.loginService.username,
+              this.loginService.userPassword, this.confirmationCode, fingerPrintResult.fingerPrint, fingerPrintResult.deviceLabel, this.rememberDevice);
+        } catch (error) {
+            if (error instanceof HttpErrorResponse) {
+                this.validationErrorMessage = error.message;
+            }
+            return;
+        } finally {
+            this.submitButtonEnabled = true;
+        }
+        this.handleLoginResponse(loginResponse);
+    }
+
+    public onMfaGoBackClick(): void {
+        this.loginService.type = LoginComponentPageType.UserNameAndPasswordEntry;
+    }
+
+    public async onResetGoogleAuthClick(): Promise<void> {
+        await this.loginService.resetGoogleAuth(this.loginService.upId, this.loginService.username);
+        this.loginService.type = LoginComponentPageType.UserNameAndPasswordEntry;
+    }
+
+    protected async defineBarCode(): Promise<void> {
+        const data: string = await this.loginService.getUserGoogleAuthBarcode();
+        this.barCodeImageSource = "data:image/png;base64," + data;
+    }
+
+    protected async clearMFAInput(): Promise<void> {
+        this.confirmationCode = "";
+        this.googleConfirmCode = "";
+    }
+}

package/projects/sharedcomponents/src/lib/components/login/components/login-mfa-code-setup.component.ts

@@ -0,0 +1,44 @@
+import {Component, HostBinding, Input, ViewEncapsulation} from '@angular/core';
+
+@Component({
+    selector: 'co-login-mfa-code-setup',
+    template: `
+<!--
+        <div>
+            <ng-container *ngIf="showBarcode">
+                <co-form fxLayout="column" fxLayoutGap="40px" fxLayoutAlign="center center">
+                    <span localize="SCAN_GOOGLE_AUTHENTICATION_BARCODE"></span>
+                    <img class='barcode' [src]="imageSource">
+                    <default-ok-cancel-buttons [okLabel]="'SCANNED'"
+                                               [cancelLabel]="'DO_NOT_ACTIVATE_AUTH_APP'"
+                                               (okClick)="onScanBarcodeButtonClick()"
+                                               (cancelClick)="handlePopupClose()"></default-ok-cancel-buttons>
+                </co-form>
+            </ng-container>
+            <ng-container *ngIf="showCodeConfirmation">
+                <co-form fxLayout="column" fxLayoutGap="40px" fxLayoutAlign="center center">
+                    <span localize="CONFIRM_GOOGLE_AUTHENTICATION"></span>
+                    <input-code [(model)]="googleConfirmCode" [codePattern]="'3-3'"></input-code>
+                    <button-colijn label="CONFIRM" fxFlexAlign="center"
+                                   (click)="onCheckCodeClick()"></button-colijn>
+                </co-form>
+                <div class="back-button-container"
+                     fxLayout fxLayoutGap="5px" (click)="onBackButtonClick()"
+                     fxLayoutAlign="start center">
+                    <co-icon [icon]="Icons.ArrowLeftRoundOpen"></co-icon>
+                    <span localize="BACK"></span>
+                </div>
+            </ng-container>
+        </div>
+-->
+    `,
+    encapsulation: ViewEncapsulation.None
+})
+export class LoginMfaCodeSetupComponent {
+
+    @HostBinding('class.login-mfa-code-setup')
+    public showClass() {
+        return true;
+    }
+
+}

package/projects/sharedcomponents/src/lib/components/login/components/login-username-password.component.ts

@@ -0,0 +1,160 @@
+import {Component, HostBinding, Input, ViewChild, ViewEncapsulation} from '@angular/core';
+import {LoginBaseComponent} from './login-base.component';
+import {LoginResponse} from '@colijnit/ioneconnector/build/model/login-response';
+import {DialogResponseInterface, FormComponent, InputTextComponent} from '@colijnit/corecomponents_v12';
+import {LoginRequest} from '@colijnit/ioneconnector/build/model/login-request';
+import {HttpErrorResponse} from '@angular/common/http';
+import {ResetPasswordStatus} from '@colijnit/ioneconnector/build/enum/reset-password-status.enum';
+
+@Component({
+    selector: 'co-login-username-password',
+    template: `
+        <co-form #loginForm *ngIf="!showRecaptcha" class="user-and-pass" (validSubmit)="onLoginSubmit()"
+                 (validityChange)="onFormValidityChange($event)">
+            <div class="login-header" *ngIf="title" [textContent]="title"></div>
+            <div class="field-wrapper">
+                <co-input-text #userNameInput required
+                               [(model)]="loginService.username"
+                               [placeholder]="'EMAIL_OR_USERNAME' | sharedLocalize"
+                               [leftIconData]="iconCacheService.getIcon(icons.Account)"
+                               (keyDown)="handleInputKeyDown($event)"
+                ></co-input-text>
+                <co-input-text #passwordInput type="password" class="password" required
+                               [(model)]="loginService.password"
+                               [placeholder]="'PASSWORD' | sharedLocalize"
+                               [leftIconData]="iconCacheService.getIcon(icons.Lock)"
+                               [rightIconData]="iconCacheService.getIcon(icons.EyeRegular)"
+                               (rightIconMouseDown)="handlePasswordShow($event)"
+                               (rightIconMouseUp)="handlePasswordHide($event)"
+                               (keyDown)="handleInputKeyDown($event)"
+                ></co-input-text>
+                <div class="bundle-message" *ngIf="bundleLogin && loginResponse" [textContent]="validationErrorMessage | sharedLocalize"></div>
+                <div *ngIf="validationErrorMessage && !bundleLogin" class="login-validation-error-message" [textContent]="validationErrorMessage | sharedLocalize"></div>
+                <div *ngIf="validationMessage && !bundleLogin" class="login-validation-message" [textContent]="validationMessage | sharedLocalize"></div>
+                <!--
+                                <co-list-of-values *ngIf="showLanguageSelect" doNotLoadCollection [collection]="languages" icon="dictionary" [(selectedModel)]="language"
+                                                    label="LANGUAGE" descriptionField="description" required></co-list-of-values>
+                -->
+            </div>
+            <co-button class="login-submit-button" [label]="'LOGIN' | sharedLocalize" [disabled]="!submitButtonEnabled"
+                       (click)="submitForm()"></co-button>
+            <div class="login-extended-wrapper">
+                <a [class.undefined-username]="!loginService.username" class="login-password-forget-text"
+                   [textContent]="'PASSWORD_FORGOTTEN_TEXT' | sharedLocalize"
+                   (click)="onPasswordForgottenLinkClick()"></a>
+                <span [class.undefined-username]="!loginService.username" class="login-no-username-text"
+                      [textContent]="'PASSWORD_FORGOTTEN_TEXT_EXTRA' | sharedLocalize"></span>
+            </div>
+        </co-form>
+        <re-captcha class="login-recaptcha" [class.hidden]="!showRecaptcha"
+                    [siteKey]="loginService.reCaptchaSiteKey"
+                    (resolved)="onReCaptchaResolved($event)"
+                    (clickOutside)="hideRecaptcha()"></re-captcha>
+    `,
+    encapsulation: ViewEncapsulation.None
+})
+export class LoginUsernamePasswordComponent extends LoginBaseComponent {
+
+    public bundleMessage: string;
+
+    @Input()
+    public bundleLogin: boolean = false;
+
+    @ViewChild('loginForm')
+    public form: FormComponent;
+
+    @ViewChild('passwordInput')
+    public inputPassword: InputTextComponent;
+
+    @HostBinding('class.co-login-username-password')
+    public showClass() {
+        return true;
+    }
+
+    public async onReCaptchaResolved(reCaptchaResponse: string): Promise<void> {
+        if (!reCaptchaResponse) {
+            return;
+        }
+
+        let resetPasswordSuccess: ResetPasswordStatus;
+        try {
+            resetPasswordSuccess = await this.loginService.sendResetPasswordOrInviteMessage(this.loginService.upId, this.loginService.username, reCaptchaResponse);
+        } catch (error) {
+            this.validationErrorMessage = "EMAIL_FORGOT_PW_NOT_SENT";
+        }
+
+        switch (resetPasswordSuccess) {
+            case ResetPasswordStatus.SUCCESS:
+                this.validationMessage = "EMAIL_SENT";
+                break;
+            case ResetPasswordStatus.ACCOUNT_IS_DEACTIVATED:
+                this.validationMessage = "ACCOUNT_INACTIVE_PW_NOT_SENT";
+                break;
+            case ResetPasswordStatus.USER_DOESNT_HAVE_EMAIL:
+                this.validationErrorMessage = "USER_DOESNT_HAVE_EMAIL_PW_NOT_SENT";
+                break;
+        }
+        if (this.recaptchaComponent) {
+            this.recaptchaComponent.reset();
+        }
+        this.showRecaptcha = false;
+    }
+
+    public async onLoginSubmit(): Promise<void> {
+        const loginRequest: LoginRequest = this.loginService.getLoginRequest();
+        // this._toolTip.destroyAllErrorTooltips();
+        // this.passwordInput.forceBlur();
+
+        // this._saveLanguage();
+
+        this.submitButtonEnabled = false;
+        let loginResponse: LoginResponse;
+        try {
+            loginResponse = await this.loginService.login(loginRequest);
+            if (loginResponse) {
+                this.loginService.userPassword = loginResponse.password;
+            }
+        } catch (error) {
+            if (error instanceof HttpErrorResponse) {
+                this.validationErrorMessage = error.message;
+            }
+            return;
+        } finally {
+            this.submitButtonEnabled = true;
+        }
+        this.handleLoginResponse(loginResponse);
+    }
+
+    public async onPasswordForgottenLinkClick(): Promise<void> {
+        if (this.loginService.username) {
+            const response: DialogResponseInterface = await this.dialogService.showYesNo(this.dictionaryService.get("QUESTION"), this.dictionaryService.get("MESSAGE_CONFIRM_CHANGE_FORGOTTEN_PASSWORD"));
+            if (response && response.button === 4) { // todo: export button types in core_components
+                this.showRecaptcha = true;
+            }
+        }
+    }
+
+    public handlePasswordShow(event: MouseEvent): void {
+        if (this.inputPassword) {
+            this.inputPassword.type = undefined;
+        }
+    }
+
+    public handlePasswordHide(event: MouseEvent): void {
+        if (this.inputPassword) {
+            this.inputPassword.type = 'password';
+        }
+    }
+
+    public submitForm(): void {
+        if (this.form) {
+            this.form.submit();
+        }
+    }
+
+    public handleInputKeyDown(event: KeyboardEvent): void {
+        if (event.key === 'Enter' || event.key === 'NumPadEnter') {
+            this.submitForm();
+        }
+    }
+}

package/projects/sharedcomponents/src/lib/components/login/enum/mfa-send-method-type.enum.ts

@@ -0,0 +1,6 @@
+// see internal param: 'MFA_SEND_METHOD'
+export enum MfaSendMethodType {
+  Email = "email",
+  Sms = "sms",
+  GoogleAuthenticator = "google_auth"
+}

package/projects/sharedcomponents/src/lib/components/login/interface/finger-print-result.interface.ts

@@ -0,0 +1,4 @@
+export interface FingerPrintResult {
+  fingerPrint?: string;
+  deviceLabel?: string;
+}

package/projects/sharedcomponents/src/lib/components/login/localization/login-translation.ts

@@ -0,0 +1,15 @@
+// import {Translation} from '../../../localization/translation';
+
+export class LoginTranslation /*extends Translation */{
+    public ACTIVATE_ACCOUNT?: string = 'ACTIVATE_ACCOUNT';
+    public CHANGE_PASSWORD?: string = 'CHANGE_PASSWORD';
+    public CHANGE_PASSWORD_ACTIVATE_USER_MSG?: string = 'CHANGE_PASSWORD_ACTIVATE_USER_MSG';
+    public EMAIL_OR_USERNAME?: string = 'EMAIL_OR_USERNAME';
+    public NEW_PASSWORD?: string = 'NEW_PASSWORD';
+    public PASSWORD?: string = 'PASSWORD';
+    public PASSWORD_FORGOTTEN_TEXT?: string = 'PASSWORD_FORGOTTEN_TEXT';
+    public PASSWORD_FORGOTTEN_TEXT_EXTRA?: string = 'PASSWORD_FORGOTTEN_TEXT_EXTRA';
+    public PASSWORD_REPEAT?: string = 'PASSWORD_REPEAT';
+    public LOGIN?: string = 'LOGIN';
+    public LOGIN_INCORRECT?: string = 'LOGIN_INCORRECT';
+}