@idea-ionic/auth 5.29.2 → 6.0.1

package/environment.d.ts

@@ -1,3 +1,6 @@
+/**
+ * The environment variables used by this module.
+ */
 export declare const environment: {
     idea: {
         project: string;

package/esm2020/environment.mjs

@@ -0,0 +1,25 @@
+/**
+ * The environment variables used by this module.
+ */
+export const environment = {
+    idea: {
+        project: '',
+        website: '',
+        ionicExtraModules: ['auth'],
+        app: {
+            title: '',
+            hasIntroPage: false
+        },
+        auth: {
+            registrationIsPossible: false,
+            singleSimultaneousSession: false
+        }
+    },
+    aws: {
+        cognito: {
+            userPoolId: '',
+            userPoolClientId: ''
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52aXJvbm1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9tb2R1bGVzL2F1dGgvZW52aXJvbm1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUc7SUFDekIsSUFBSSxFQUFFO1FBQ0osT0FBTyxFQUFFLEVBQUU7UUFDWCxPQUFPLEVBQUUsRUFBRTtRQUNYLGlCQUFpQixFQUFFLENBQUMsTUFBTSxDQUFDO1FBQzNCLEdBQUcsRUFBRTtZQUNILEtBQUssRUFBRSxFQUFFO1lBQ1QsWUFBWSxFQUFFLEtBQUs7U0FDcEI7UUFDRCxJQUFJLEVBQUU7WUFDSixzQkFBc0IsRUFBRSxLQUFLO1lBQzdCLHlCQUF5QixFQUFFLEtBQUs7U0FDakM7S0FDRjtJQUNELEdBQUcsRUFBRTtRQUNILE9BQU8sRUFBRTtZQUNQLFVBQVUsRUFBRSxFQUFFO1lBQ2QsZ0JBQWdCLEVBQUUsRUFBRTtTQUNyQjtLQUNGO0NBQ0YsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogVGhlIGVudmlyb25tZW50IHZhcmlhYmxlcyB1c2VkIGJ5IHRoaXMgbW9kdWxlLlxuICovXG5leHBvcnQgY29uc3QgZW52aXJvbm1lbnQgPSB7XG4gIGlkZWE6IHtcbiAgICBwcm9qZWN0OiAnJyxcbiAgICB3ZWJzaXRlOiAnJyxcbiAgICBpb25pY0V4dHJhTW9kdWxlczogWydhdXRoJ10sXG4gICAgYXBwOiB7XG4gICAgICB0aXRsZTogJycsXG4gICAgICBoYXNJbnRyb1BhZ2U6IGZhbHNlXG4gICAgfSxcbiAgICBhdXRoOiB7XG4gICAgICByZWdpc3RyYXRpb25Jc1Bvc3NpYmxlOiBmYWxzZSxcbiAgICAgIHNpbmdsZVNpbXVsdGFuZW91c1Nlc3Npb246IGZhbHNlXG4gICAgfVxuICB9LFxuICBhd3M6IHtcbiAgICBjb2duaXRvOiB7XG4gICAgICB1c2VyUG9vbElkOiAnJyxcbiAgICAgIHVzZXJQb29sQ2xpZW50SWQ6ICcnXG4gICAgfVxuICB9XG59O1xuIl19

package/esm2020/idea-ionic-auth.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWRlYS1pb25pYy1hdXRoLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vbW9kdWxlcy9hdXRoL2lkZWEtaW9uaWMtYXV0aC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2020/src/auth.module.mjs

@@ -0,0 +1,70 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { IonicModule } from '@ionic/angular';
+import { RouterModule } from '@angular/router';
+import { IDEATranslationsModule } from '@idea-ionic/common';
+import { IDEASignInPage } from './signIn.page';
+import { IDEASignUpPage } from './signUp.page';
+import { IDEANewPasswordPage } from './newPassword.page';
+import { IDEAResendLinkPage } from './resendLink.page';
+import { IDEAForgotPasswordPage } from './forgotPassword.page';
+import { IDEAConfirmPasswordPage } from './confirmPassword.page';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class IDEAAuthModule {
+}
+IDEAAuthModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: IDEAAuthModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+IDEAAuthModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: IDEAAuthModule, declarations: [IDEASignInPage,
+        IDEASignUpPage,
+        IDEANewPasswordPage,
+        IDEAResendLinkPage,
+        IDEAForgotPasswordPage,
+        IDEAConfirmPasswordPage], imports: [CommonModule,
+        FormsModule,
+        IonicModule,
+        IDEATranslationsModule, i1.RouterModule] });
+IDEAAuthModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: IDEAAuthModule, imports: [[
+            CommonModule,
+            FormsModule,
+            IonicModule,
+            IDEATranslationsModule,
+            RouterModule.forChild([
+                { path: '', redirectTo: 'sign-in', pathMatch: 'full' },
+                { path: 'sign-in', component: IDEASignInPage },
+                { path: 'sign-up', component: IDEASignUpPage },
+                { path: 'new-password', component: IDEANewPasswordPage },
+                { path: 'resend-link', component: IDEAResendLinkPage },
+                { path: 'forgot-password', component: IDEAForgotPasswordPage },
+                { path: 'confirm-password', component: IDEAConfirmPasswordPage }
+            ])
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: IDEAAuthModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        IonicModule,
+                        IDEATranslationsModule,
+                        RouterModule.forChild([
+                            { path: '', redirectTo: 'sign-in', pathMatch: 'full' },
+                            { path: 'sign-in', component: IDEASignInPage },
+                            { path: 'sign-up', component: IDEASignUpPage },
+                            { path: 'new-password', component: IDEANewPasswordPage },
+                            { path: 'resend-link', component: IDEAResendLinkPage },
+                            { path: 'forgot-password', component: IDEAForgotPasswordPage },
+                            { path: 'confirm-password', component: IDEAConfirmPasswordPage }
+                        ])
+                    ],
+                    declarations: [
+                        IDEASignInPage,
+                        IDEASignUpPage,
+                        IDEANewPasswordPage,
+                        IDEAResendLinkPage,
+                        IDEAForgotPasswordPage,
+                        IDEAConfirmPasswordPage
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/auth.service.mjs

@@ -0,0 +1,317 @@
+import { Injectable } from '@angular/core';
+import { AuthenticationDetails, CognitoUser, CognitoUserAttribute, CognitoUserPool, CognitoRefreshToken } from 'amazon-cognito-identity-js';
+import { environment as env } from '@env';
+import * as i0 from "@angular/core";
+import * as i1 from "@idea-ionic/common";
+/**
+ * The name of the Cognito's user attribute which contains the key of the last device to login in this project.
+ */
+const DEVICE_KEY_ATTRIBUTE = 'custom:'.concat(env.idea.project);
+/**
+ * Cognito wrapper to manage the authentication flow.
+ *
+ * Note: in IDEA's Cognito users pools, the email is an alias of the username.
+ */
+export class IDEAAuthService {
+    constructor(storage) {
+        this.storage = storage;
+        this.userPool = new CognitoUserPool({
+            UserPoolId: env.aws.cognito.userPoolId,
+            ClientId: env.aws.cognito.userPoolClientId
+        });
+    }
+    /**
+     * Prepare the necessary structure to get authorized in Cognito.
+     */
+    prepareAuthDetails(username, pwd) {
+        return new AuthenticationDetails({ Username: username, Password: pwd });
+    }
+    /**
+     * Prepare the necessary structure to identify a Cognito user.
+     */
+    prepareCognitoUser(username) {
+        return new CognitoUser({ Username: username, Pool: this.userPool });
+    }
+    /**
+     * Prepare a user attribute (they are all strings) in Cognito's format.
+     */
+    prepareUserAttribute(name, value) {
+        return new CognitoUserAttribute({ Name: name, Value: value });
+    }
+    /**
+     * Perform a login through username and password.
+     */
+    login(username, password) {
+        return new Promise((resolve, reject) => {
+            // get a cognito user and try to authenticate
+            this.prepareCognitoUser(username).authenticateUser(this.prepareAuthDetails(username, password), {
+                onSuccess: () => resolve(false),
+                onFailure: (err) => reject(err),
+                newPasswordRequired: () => resolve(true)
+            });
+        });
+    }
+    /**
+     * Complete a complete new password flow in the authentication.
+     */
+    confirmNewPassword(username, tempPassword, newPassword) {
+        return new Promise((resolve, reject) => {
+            // login with the old password
+            const user = this.prepareCognitoUser(username);
+            user.authenticateUser(this.prepareAuthDetails(username, tempPassword), {
+                onSuccess: () => resolve(),
+                onFailure: (err) => reject(err),
+                newPasswordRequired: () => 
+                // complete the new password challenge
+                user.completeNewPasswordChallenge(newPassword, {}, {
+                    onSuccess: () => resolve(),
+                    onFailure: (err) => reject(err)
+                })
+            });
+        });
+    }
+    /**
+     * Register a new user a set its default attributes.
+     */
+    register(username, password, attributes) {
+        attributes = attributes || {};
+        return new Promise((resolve, reject) => {
+            // add attributes like the email address and the fullname
+            const attrs = [];
+            for (const prop in attributes)
+                if (attributes[prop])
+                    attrs.push(this.prepareUserAttribute(prop, attributes[prop]));
+            // add the email, which is equal to the username for most of our Pools
+            if (!attributes.email)
+                attrs.push(this.prepareUserAttribute('email', username));
+            // register the new user to the pool
+            this.userPool.signUp(username, password, attrs, null, (err, res) => err ? reject(err) : resolve(res.user));
+        });
+    }
+    /**
+     * Confirm a new registration through the confirmation code sent by Cognito.
+     */
+    confirmRegistration(username, code) {
+        return new Promise((resolve, reject) => {
+            this.prepareCognitoUser(username).confirmRegistration(code, true, (err) => err ? reject(err) : resolve());
+        });
+    }
+    /**
+     * Send again a confirmation code for a new registration.
+     */
+    resendConfirmationCode(username) {
+        return new Promise((resolve, reject) => {
+            this.prepareCognitoUser(username).resendConfirmationCode((err) => (err ? reject(err) : resolve()));
+        });
+    }
+    /**
+     * Logout the currently signed-in user.
+     */
+    logout(options) {
+        options = Object.assign({ global: false }, options);
+        return new Promise((resolve, reject) => {
+            // remove the refresh token previosly saved
+            this.storage.remove('AuthRefreshToken').then(() => 
+            // remove the optional auth details
+            this.storage.remove('AuthUserDetails').then(() => {
+                // get the user and the session
+                const user = this.userPool.getCurrentUser();
+                user.getSession(async (err) => {
+                    // if the session is active, run the online sign-out; otherwise, only the local data has been deleted
+                    if (err)
+                        return resolve();
+                    // if a reference to the device was saved, forget it
+                    if (env.idea.auth.singleSimultaneousSession)
+                        await this.setCurrentDeviceForProject(null);
+                    // sign-out from the pool (terminate the current session or all the sessions)
+                    if (options.global)
+                        user.globalSignOut({ onSuccess: () => resolve(), onFailure: err => reject(err) });
+                    else {
+                        user.signOut();
+                        resolve();
+                    }
+                });
+            }));
+        });
+    }
+    /**
+     * Send a password reset request.
+     */
+    forgotPassword(username) {
+        return new Promise((resolve, reject) => {
+            this.prepareCognitoUser(username).forgotPassword({
+                onSuccess: () => resolve(),
+                onFailure: (err) => reject(err)
+            });
+        });
+    }
+    /**
+     * Confirm a new password after a password reset request.
+     */
+    confirmPassword(username, code, newPwd) {
+        return new Promise((resolve, reject) => {
+            // get the user and confirm a new password
+            this.prepareCognitoUser(username).confirmPassword(code, newPwd, {
+                onSuccess: () => resolve(),
+                onFailure: (err) => reject(err)
+            });
+        });
+    }
+    /**
+     * Check if a user is currently authenticated.
+     * @param offlineAllowed if set and if offline, skip authentication and retrieve data locally
+     * @param getFreshIdTokenOnExp cb function to execute when the idToken is refreshed
+     */
+    isAuthenticated(offlineAllowed, getFreshIdTokenOnExp) {
+        return new Promise((resolve, reject) => {
+            if (offlineAllowed && !navigator.onLine) {
+                this.storage.get('AuthUserDetails').then(userDetails => resolve({ idToken: null, userDetails }));
+                // re-execute the method when back online, so that you can retrieve a token to make requests
+                window.addEventListener('online', () => this.isAuthenticated(true, getFreshIdTokenOnExp)
+                    // set the new token as if it was refreshed
+                    .then(result => getFreshIdTokenOnExp(result.idToken)));
+            }
+            else {
+                const user = this.userPool.getCurrentUser();
+                if (!user)
+                    return reject();
+                user.getSession((err, session) => {
+                    if (err)
+                        return reject(err);
+                    // get user attributes
+                    user.getUserAttributes((e, attributes) => {
+                        if (e)
+                            return reject(e);
+                        // remap user attributes
+                        const userDetails = {};
+                        attributes.forEach((a) => (userDetails[a.getName()] = a.getValue()));
+                        // add the user's groups to the attributes
+                        const sessionInfo = session.getAccessToken().decodePayload();
+                        const groups = sessionInfo['cognito:groups'] || [];
+                        userDetails['groups'] = groups;
+                        // run some checks considering the user's groups and devices (based on the project's configuration)
+                        this.runPostAuthChecks(userDetails, err => {
+                            // in case some check failed, reject the authorisation flow
+                            if (err)
+                                return reject(err);
+                            // (async) save the refresh token so it can be accessed by other procedures
+                            this.storage.set('AuthRefreshToken', session.getRefreshToken().getToken());
+                            // set a timer to manage the autorefresh of the idToken (through the refreshToken)
+                            setTimeout(() => this.refreshSession(user, session.getRefreshToken().getToken(), getFreshIdTokenOnExp), 15 * 60 * 1000); // every 15 minutes
+                            // (async) if offlineAllowed, save data locally, to use it next time we'll be offline
+                            if (offlineAllowed)
+                                this.storage.set('AuthUserDetails', userDetails);
+                            // return the idToken (to use with API)
+                            resolve({ idToken: session.getIdToken().getJwtToken(), userDetails });
+                        });
+                    });
+                });
+            }
+        });
+    }
+    /**
+     * Helper to refresh the session every N minutes.
+     */
+    refreshSession(user, refreshToken, callback) {
+        user.refreshSession(new CognitoRefreshToken({ RefreshToken: refreshToken }), (err, session) => {
+            if (err) {
+                // try again in 1 minute
+                setTimeout(() => this.refreshSession(user, refreshToken, callback), 1 * 60 * 1000);
+            }
+            else {
+                // (async) save the refresh token so it can be accessed by other procedures
+                this.storage.set('AuthRefreshToken', session.getRefreshToken().getToken());
+                // repeat every 15 minutes
+                setTimeout(() => this.refreshSession(user, session.getRefreshToken().getToken(), callback), 15 * 60 * 1000);
+                // run the callback action, if set
+                if (callback)
+                    callback(session.getIdToken().getJwtToken());
+            }
+        });
+    }
+    /**
+     * Run some post-auth checks, based on the users groups and on the app's configuration:
+     *  - users in the Cognito's "admins" grup skip all the following rules.
+     *  - users in the Cognito's "robots" group can't sign-into front-ends (they serve only back-end purposes).
+     *  - if `env.idea.auth.singleSimultaneousSession` is on, make sure there is only one active session per user.
+     */
+    runPostAuthChecks(userDetails, callback) {
+        const groups = userDetails['groups'];
+        // skip checks if the user is in the "admins" group
+        const isAdmin = groups.some(x => x === 'admins');
+        if (isAdmin)
+            return callback();
+        // users in the "robots" group can't sign-into front-ends (they serve only back-end purposes)
+        const isRobot = groups.some(x => x === 'robots');
+        if (isRobot)
+            return callback(new Error('ROBOT_USER'));
+        // in case the project limits each account to only one simultaneous session, run a check
+        if (env.idea.auth.singleSimultaneousSession)
+            return this.checkForSimultaneousSessions(userDetails, callback);
+        // otherwise, we're done
+        callback();
+    }
+    /**
+     * Check whether the user signed-into multiple devices.
+     */
+    async checkForSimultaneousSessions(userDetails, callback) {
+        // get or create a key for the current device (~random)
+        let currentDeviceKey = await this.storage.get('AuthDeviceKey');
+        if (!currentDeviceKey) {
+            const randomKey = Math.random().toString(36).substring(10);
+            currentDeviceKey = randomKey.concat(String(Date.now()));
+            await this.storage.set('AuthDeviceKey', currentDeviceKey);
+        }
+        // check whether the last device to sign-into this project (if any) is the current one
+        const lastDeviceToSignIntoThisProject = userDetails[DEVICE_KEY_ATTRIBUTE];
+        // if it's the first user's device to sign-in, save the reference in Cognito and resolve
+        if (!lastDeviceToSignIntoThisProject) {
+            this.setCurrentDeviceForProject(currentDeviceKey)
+                .then(() => callback())
+                .catch(() => callback(new Error('CANT_SET_DEVICE')));
+            // if the device didn't change, resolve
+        }
+        else if (lastDeviceToSignIntoThisProject === currentDeviceKey)
+            callback();
+        // othwerwise, report there is more than one simultaneous session
+        else
+            callback(new Error('SIMULTANEOUS_SESSION'));
+    }
+    /**
+     * Set (or reset) the current user's device (by key) in the current project (stored in Cognito).
+     */
+    setCurrentDeviceForProject(deviceKey) {
+        const attributes = {};
+        // note: an empty string will remove the attribute from Cognito
+        attributes[DEVICE_KEY_ATTRIBUTE] = deviceKey || '';
+        return this.updateUserAttributes(attributes);
+    }
+    /**
+     * Update the currently logged in user's attributes.
+     */
+    updateUserAttributes(attributes) {
+        return new Promise((resolve, reject) => {
+            // prepare the attributes we want to change
+            const attrs = new Array();
+            for (const prop in attributes)
+                if (attributes[prop] !== undefined)
+                    attrs.push(this.prepareUserAttribute(prop, attributes[prop]));
+            const user = this.userPool.getCurrentUser();
+            if (!user)
+                return reject();
+            // we need to get the session before to make changes
+            user.getSession((err) => {
+                if (err)
+                    reject(err);
+                else
+                    user.updateAttributes(attrs, (e) => (e ? reject(e) : resolve()));
+            });
+        });
+    }
+}
+IDEAAuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: IDEAAuthService, deps: [{ token: i1.IDEAStorageService }], target: i0.ɵɵFactoryTarget.Injectable });
+IDEAAuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: IDEAAuthService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: IDEAAuthService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.IDEAStorageService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../modules/auth/src/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  AuthenticationDetails,\n  CognitoUser,\n  CognitoUserAttribute,\n  CognitoUserPool,\n  CognitoRefreshToken,\n  CognitoUserSession,\n  ISignUpResult\n} from 'amazon-cognito-identity-js';\n\nimport { IDEAStorageService } from '@idea-ionic/common';\n\nimport { environment as env } from '@env';\n\n/**\n * The name of the Cognito's user attribute which contains the key of the last device to login in this project.\n */\nconst DEVICE_KEY_ATTRIBUTE = 'custom:'.concat(env.idea.project);\n\n/**\n * Cognito wrapper to manage the authentication flow.\n *\n * Note: in IDEA's Cognito users pools, the email is an alias of the username.\n */\n@Injectable()\nexport class IDEAAuthService {\n  protected userPool: CognitoUserPool;\n\n  constructor(protected storage: IDEAStorageService) {\n    this.userPool = new CognitoUserPool({\n      UserPoolId: env.aws.cognito.userPoolId,\n      ClientId: env.aws.cognito.userPoolClientId\n    });\n  }\n\n  /**\n   * Prepare the necessary structure to get authorized in Cognito.\n   */\n  protected prepareAuthDetails(username: string, pwd: string): AuthenticationDetails {\n    return new AuthenticationDetails({ Username: username, Password: pwd });\n  }\n  /**\n   * Prepare the necessary structure to identify a Cognito user.\n   */\n  protected prepareCognitoUser(username: string): CognitoUser {\n    return new CognitoUser({ Username: username, Pool: this.userPool });\n  }\n  /**\n   * Prepare a user attribute (they are all strings) in Cognito's format.\n   */\n  protected prepareUserAttribute(name: string, value: string): CognitoUserAttribute {\n    return new CognitoUserAttribute({ Name: name, Value: value });\n  }\n\n  /**\n   * Perform a login through username and password.\n   */\n  public login(username: string, password: string): Promise<boolean> {\n    return new Promise((resolve, reject) => {\n      // get a cognito user and try to authenticate\n      this.prepareCognitoUser(username).authenticateUser(this.prepareAuthDetails(username, password), {\n        onSuccess: () => resolve(false),\n        onFailure: (err: Error) => reject(err),\n        newPasswordRequired: () => resolve(true)\n      });\n    });\n  }\n  /**\n   * Complete a complete new password flow in the authentication.\n   */\n  public confirmNewPassword(username: string, tempPassword: string, newPassword: string): Promise<void> {\n    return new Promise((resolve, reject) => {\n      // login with the old password\n      const user = this.prepareCognitoUser(username);\n      user.authenticateUser(this.prepareAuthDetails(username, tempPassword), {\n        onSuccess: () => resolve(),\n        onFailure: (err: Error) => reject(err),\n        newPasswordRequired: () =>\n          // complete the new password challenge\n          user.completeNewPasswordChallenge(\n            newPassword,\n            {},\n            {\n              onSuccess: () => resolve(),\n              onFailure: (err: Error) => reject(err)\n            }\n          )\n      });\n    });\n  }\n  /**\n   * Register a new user a set its default attributes.\n   */\n  public register(username: string, password: string, attributes?: any): Promise<CognitoUser> {\n    attributes = attributes || {};\n    return new Promise((resolve, reject) => {\n      // add attributes like the email address and the fullname\n      const attrs = [];\n      for (const prop in attributes)\n        if (attributes[prop]) attrs.push(this.prepareUserAttribute(prop, attributes[prop]));\n      // add the email, which is equal to the username for most of our Pools\n      if (!attributes.email) attrs.push(this.prepareUserAttribute('email', username));\n      // register the new user to the pool\n      this.userPool.signUp(username, password, attrs, null, (err: Error, res: ISignUpResult) =>\n        err ? reject(err) : resolve(res.user)\n      );\n    });\n  }\n  /**\n   * Confirm a new registration through the confirmation code sent by Cognito.\n   */\n  public confirmRegistration(username: string, code: string): Promise<void> {\n    return new Promise((resolve, reject) => {\n      this.prepareCognitoUser(username).confirmRegistration(code, true, (err: Error) =>\n        err ? reject(err) : resolve()\n      );\n    });\n  }\n  /**\n   * Send again a confirmation code for a new registration.\n   */\n  public resendConfirmationCode(username: string): Promise<void> {\n    return new Promise((resolve, reject) => {\n      this.prepareCognitoUser(username).resendConfirmationCode((err: Error) => (err ? reject(err) : resolve()));\n    });\n  }\n  /**\n   * Logout the currently signed-in user.\n   */\n  public logout(options?: { global: boolean }): Promise<void> {\n    options = Object.assign({ global: false }, options);\n    return new Promise((resolve, reject) => {\n      // remove the refresh token previosly saved\n      this.storage.remove('AuthRefreshToken').then(() =>\n        // remove the optional auth details\n        this.storage.remove('AuthUserDetails').then(() => {\n          // get the user and the session\n          const user = this.userPool.getCurrentUser();\n          user.getSession(async (err: Error) => {\n            // if the session is active, run the online sign-out; otherwise, only the local data has been deleted\n            if (err) return resolve();\n            // if a reference to the device was saved, forget it\n            if (env.idea.auth.singleSimultaneousSession) await this.setCurrentDeviceForProject(null);\n            // sign-out from the pool (terminate the current session or all the sessions)\n            if (options.global) user.globalSignOut({ onSuccess: () => resolve(), onFailure: err => reject(err) });\n            else {\n              user.signOut();\n              resolve();\n            }\n          });\n        })\n      );\n    });\n  }\n  /**\n   * Send a password reset request.\n   */\n  public forgotPassword(username: string): Promise<void> {\n    return new Promise((resolve, reject) => {\n      this.prepareCognitoUser(username).forgotPassword({\n        onSuccess: () => resolve(),\n        onFailure: (err: Error) => reject(err)\n      });\n    });\n  }\n  /**\n   * Confirm a new password after a password reset request.\n   */\n  public confirmPassword(username: string, code: string, newPwd: string): Promise<void> {\n    return new Promise((resolve, reject) => {\n      // get the user and confirm a new password\n      this.prepareCognitoUser(username).confirmPassword(code, newPwd, {\n        onSuccess: () => resolve(),\n        onFailure: (err: Error) => reject(err)\n      });\n    });\n  }\n  /**\n   * Check if a user is currently authenticated.\n   * @param offlineAllowed if set and if offline, skip authentication and retrieve data locally\n   * @param getFreshIdTokenOnExp cb function to execute when the idToken is refreshed\n   */\n  public isAuthenticated(offlineAllowed: boolean, getFreshIdTokenOnExp?: (freshIdToken: string) => void): Promise<any> {\n    return new Promise((resolve, reject) => {\n      if (offlineAllowed && !navigator.onLine) {\n        this.storage.get('AuthUserDetails').then(userDetails => resolve({ idToken: null, userDetails }));\n        // re-execute the method when back online, so that you can retrieve a token to make requests\n        window.addEventListener('online', () =>\n          this.isAuthenticated(true, getFreshIdTokenOnExp)\n            // set the new token as if it was refreshed\n            .then(result => getFreshIdTokenOnExp(result.idToken))\n        );\n      } else {\n        const user = this.userPool.getCurrentUser();\n        if (!user) return reject();\n        user.getSession((err: Error, session: CognitoUserSession) => {\n          if (err) return reject(err);\n          // get user attributes\n          user.getUserAttributes((e: Error, attributes: CognitoUserAttribute[]) => {\n            if (e) return reject(e);\n            // remap user attributes\n            const userDetails: any = {};\n            attributes.forEach((a: CognitoUserAttribute) => (userDetails[a.getName()] = a.getValue()));\n            // add the user's groups to the attributes\n            const sessionInfo = session.getAccessToken().decodePayload();\n            const groups: string[] = sessionInfo['cognito:groups'] || [];\n            userDetails['groups'] = groups;\n            // run some checks considering the user's groups and devices (based on the project's configuration)\n            this.runPostAuthChecks(userDetails, err => {\n              // in case some check failed, reject the authorisation flow\n              if (err) return reject(err);\n              // (async) save the refresh token so it can be accessed by other procedures\n              this.storage.set('AuthRefreshToken', session.getRefreshToken().getToken());\n              // set a timer to manage the autorefresh of the idToken (through the refreshToken)\n              setTimeout(\n                () => this.refreshSession(user, session.getRefreshToken().getToken(), getFreshIdTokenOnExp),\n                15 * 60 * 1000\n              ); // every 15 minutes\n              // (async) if offlineAllowed, save data locally, to use it next time we'll be offline\n              if (offlineAllowed) this.storage.set('AuthUserDetails', userDetails);\n              // return the idToken (to use with API)\n              resolve({ idToken: session.getIdToken().getJwtToken(), userDetails });\n            });\n          });\n        });\n      }\n    });\n  }\n  /**\n   * Helper to refresh the session every N minutes.\n   */\n  protected refreshSession(user: CognitoUser, refreshToken: string, callback: (freshIdToken: string) => void) {\n    user.refreshSession(\n      new CognitoRefreshToken({ RefreshToken: refreshToken }),\n      (err: Error, session: CognitoUserSession) => {\n        if (err) {\n          // try again in 1 minute\n          setTimeout(() => this.refreshSession(user, refreshToken, callback), 1 * 60 * 1000);\n        } else {\n          // (async) save the refresh token so it can be accessed by other procedures\n          this.storage.set('AuthRefreshToken', session.getRefreshToken().getToken());\n          // repeat every 15 minutes\n          setTimeout(() => this.refreshSession(user, session.getRefreshToken().getToken(), callback), 15 * 60 * 1000);\n          // run the callback action, if set\n          if (callback) callback(session.getIdToken().getJwtToken());\n        }\n      }\n    );\n  }\n  /**\n   * Run some post-auth checks, based on the users groups and on the app's configuration:\n   *  - users in the Cognito's \"admins\" grup skip all the following rules.\n   *  - users in the Cognito's \"robots\" group can't sign-into front-ends (they serve only back-end purposes).\n   *  - if `env.idea.auth.singleSimultaneousSession` is on, make sure there is only one active session per user.\n   */\n  protected runPostAuthChecks(userDetails: any, callback: (err?: Error) => void) {\n    const groups: string[] = userDetails['groups'];\n    // skip checks if the user is in the \"admins\" group\n    const isAdmin = groups.some(x => x === 'admins');\n    if (isAdmin) return callback();\n    // users in the \"robots\" group can't sign-into front-ends (they serve only back-end purposes)\n    const isRobot = groups.some(x => x === 'robots');\n    if (isRobot) return callback(new Error('ROBOT_USER'));\n    // in case the project limits each account to only one simultaneous session, run a check\n    if (env.idea.auth.singleSimultaneousSession) return this.checkForSimultaneousSessions(userDetails, callback);\n    // otherwise, we're done\n    callback();\n  }\n  /**\n   * Check whether the user signed-into multiple devices.\n   */\n  protected async checkForSimultaneousSessions(userDetails: any, callback: (err?: Error) => void) {\n    // get or create a key for the current device (~random)\n    let currentDeviceKey = await this.storage.get('AuthDeviceKey');\n    if (!currentDeviceKey) {\n      const randomKey = Math.random().toString(36).substring(10);\n      currentDeviceKey = randomKey.concat(String(Date.now()));\n      await this.storage.set('AuthDeviceKey', currentDeviceKey);\n    }\n    // check whether the last device to sign-into this project (if any) is the current one\n    const lastDeviceToSignIntoThisProject = userDetails[DEVICE_KEY_ATTRIBUTE];\n    // if it's the first user's device to sign-in, save the reference in Cognito and resolve\n    if (!lastDeviceToSignIntoThisProject) {\n      this.setCurrentDeviceForProject(currentDeviceKey)\n        .then(() => callback())\n        .catch(() => callback(new Error('CANT_SET_DEVICE')));\n      // if the device didn't change, resolve\n    } else if (lastDeviceToSignIntoThisProject === currentDeviceKey) callback();\n    // othwerwise, report there is more than one simultaneous session\n    else callback(new Error('SIMULTANEOUS_SESSION'));\n  }\n  /**\n   * Set (or reset) the current user's device (by key) in the current project (stored in Cognito).\n   */\n  protected setCurrentDeviceForProject(deviceKey?: string): Promise<void> {\n    const attributes: any = {};\n    // note: an empty string will remove the attribute from Cognito\n    attributes[DEVICE_KEY_ATTRIBUTE] = deviceKey || '';\n    return this.updateUserAttributes(attributes);\n  }\n  /**\n   * Update the currently logged in user's attributes.\n   */\n  public updateUserAttributes(attributes: any): Promise<void> {\n    return new Promise((resolve, reject) => {\n      // prepare the attributes we want to change\n      const attrs = new Array<any>();\n      for (const prop in attributes)\n        if (attributes[prop] !== undefined) attrs.push(this.prepareUserAttribute(prop, attributes[prop]));\n      const user = this.userPool.getCurrentUser();\n      if (!user) return reject();\n      // we need to get the session before to make changes\n      user.getSession((err: Error) => {\n        if (err) reject(err);\n        else user.updateAttributes(attrs, (e: Error) => (e ? reject(e) : resolve()));\n      });\n    });\n  }\n}\n"]}

package/esm2020/src/confirmPassword.page.mjs

@@ -0,0 +1,59 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+import * as i2 from "@angular/router";
+import * as i3 from "@idea-ionic/common";
+import * as i4 from "./auth.service";
+import * as i5 from "@angular/forms";
+import * as i6 from "@angular/common";
+export class IDEAConfirmPasswordPage {
+    constructor(navCtrl, route, message, loading, auth, t) {
+        this.navCtrl = navCtrl;
+        this.route = route;
+        this.message = message;
+        this.loading = loading;
+        this.auth = auth;
+        this.t = t;
+        this.email = this.route.snapshot.queryParamMap.get('email') || null;
+        if (!this.email && this.route.snapshot.queryParams.user)
+            this.email = decodeURIComponent(this.route.snapshot.queryParams.user);
+        this.code = this.route.snapshot.queryParams.code;
+    }
+    /**
+     * Confirm new password.
+     */
+    async confirmPassword() {
+        this.errorMsg = null;
+        await this.loading.show();
+        this.auth
+            .confirmPassword(this.email, this.code, this.newPassword)
+            .then(() => {
+            this.message.success('IDEA_AUTH.PASSWORD_CHANGED');
+            this.goToAuth();
+        })
+            .catch(() => {
+            this.errorMsg = this.t._('IDEA_AUTH.CONFIRM_PASSWORD_ERROR', { n: 8 });
+            this.message.error(this.errorMsg, true);
+        })
+            .finally(() => this.loading.hide());
+    }
+    /**
+     * Go to forgot password page.
+     */
+    goToForgotPassword() {
+        this.navCtrl.navigateBack(['auth/forgot-password']);
+    }
+    /**
+     * Go to auth page.
+     */
+    goToAuth() {
+        this.navCtrl.navigateBack(['auth']);
+    }
+}
+IDEAConfirmPasswordPage.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: IDEAConfirmPasswordPage, deps: [{ token: i1.NavController }, { token: i2.ActivatedRoute }, { token: i3.IDEAMessageService }, { token: i3.IDEALoadingService }, { token: i4.IDEAAuthService }, { token: i3.IDEATranslationsService }], target: i0.ɵɵFactoryTarget.Component });
+IDEAConfirmPasswordPage.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: IDEAConfirmPasswordPage, selector: "idea-confirm-password", ngImport: i0, template: "<ion-content>\n  <form class=\"flexBox\">\n    <ion-card class=\"authCard\">\n      <ion-card-header>\n        <ion-card-title color=\"primary\">{{ 'IDEA_AUTH.CHANGE_THE_PASSWORD' | translate }}</ion-card-title>\n        <ion-card-subtitle>{{ 'IDEA_AUTH.CHANGE_THE_PASSWORD_HINT' | translate: { n: 8 } }}</ion-card-subtitle>\n      </ion-card-header>\n      <ion-card-content>\n        <p class=\"errorBox\" *ngIf=\"errorMsg\">\n          <b> {{ 'IDEA_AUTH.ERROR' | translate }}. </b>\n          {{ errorMsg }}\n        </p>\n        <ion-item>\n          <ion-label position=\"inline\">\n            <ion-icon name=\"person-circle\" color=\"primary\"> </ion-icon>\n          </ion-label>\n          <ion-input\n            type=\"email\"\n            inputmode=\"email\"\n            pattern=\"[A-Za-z0-9._%+-]{2,}@[a-zA-Z-_.]{2,}[.]{1}[a-zA-Z]{2,}\"\n            spellcheck=\"false\"\n            autocorrect=\"off\"\n            autocapitalize=\"off\"\n            autocomplete=\"email\"\n            [placeholder]=\"t._('IDEA_AUTH.EMAIL')\"\n            [title]=\"t._('IDEA_AUTH.EMAIL_HINT')\"\n            [ngModelOptions]=\"{ standalone: true }\"\n            [(ngModel)]=\"email\"\n            (keyup.enter)=\"confirmPassword()\"\n          ></ion-input>\n        </ion-item>\n        <ion-item>\n          <ion-label position=\"inline\">\n            <ion-icon name=\"disc\" color=\"primary\"></ion-icon>\n          </ion-label>\n          <ion-input\n            type=\"text\"\n            spellcheck=\"false\"\n            autocorrect=\"off\"\n            autocapitalize=\"off\"\n            autocomplete=\"off\"\n            [placeholder]=\"t._('IDEA_AUTH.RESET_CODE')\"\n            [title]=\"t._('IDEA_AUTH.RESET_CODE_HINT')\"\n            [ngModelOptions]=\"{ standalone: true }\"\n            [(ngModel)]=\"code\"\n            (keyup.enter)=\"confirmPassword()\"\n          ></ion-input>\n        </ion-item>\n        <ion-item>\n          <ion-label position=\"inline\">\n            <ion-icon name=\"key\" color=\"primary\"></ion-icon>\n          </ion-label>\n          <ion-input\n            type=\"password\"\n            pattern=\".{8,}\"\n            spellcheck=\"false\"\n            autocorrect=\"off\"\n            autocapitalize=\"off\"\n            autocomplete=\"new-password\"\n            [clearOnEdit]=\"false\"\n            [placeholder]=\"t._('IDEA_AUTH.NEW_PASSWORD')\"\n            [title]=\"t._('IDEA_AUTH.CHOOSE_A_PASSWORD')\"\n            [ngModelOptions]=\"{ standalone: true }\"\n            [(ngModel)]=\"newPassword\"\n            (keyup.enter)=\"confirmPassword()\"\n          ></ion-input>\n        </ion-item>\n        <ion-button expand=\"block\" [title]=\"t._('IDEA_AUTH.CHANGE_MY_PASSWORD_HINT')\" (click)=\"confirmPassword()\">\n          {{ 'IDEA_AUTH.CHANGE_MY_PASSWORD' | translate }}\n        </ion-button>\n        <ion-button\n          fill=\"clear\"\n          expand=\"block\"\n          class=\"smallCaseButton\"\n          [title]=\"t._('IDEA_AUTH.HAVEN_T_RECEIVED_A_RESET_CODE_HINT')\"\n          (click)=\"goToForgotPassword()\"\n        >\n          {{ 'IDEA_AUTH.HAVEN_T_RECEIVED_A_RESET_CODE' | translate }}\n        </ion-button>\n        <ion-button\n          fill=\"clear\"\n          expand=\"block\"\n          class=\"smallCaseButton\"\n          [title]=\"t._('IDEA_AUTH.BACK_TO_SIGN_IN_HINT')\"\n          (click)=\"goToAuth()\"\n        >\n          {{ 'IDEA_AUTH.BACK_TO_SIGN_IN' | translate }}\n        </ion-button>\n      </ion-card-content>\n    </ion-card>\n  </form>\n</ion-content>\n", styles: [".flexBox{background:var(--ion-color-white-shade)}.authCard{min-width:400px;max-width:550px;margin:0 10px;padding:20px;background-color:var(--ion-color-white);border:1px solid var(--ion-color-light);border-radius:10px;box-shadow:none;text-align:center}.authCard ion-img{width:150px;display:block;margin:0 auto}.authCard ion-card-title{font-family:auth-title;font-size:3em}.authCard ion-card-subtitle{font-family:auth-title;font-size:1.2em}.authCard ion-card-content{padding-top:16px}.authCard ion-card-content .errorBox{padding-left:10px;margin-bottom:20px;text-align:left;border-left:2px solid var(--ion-color-danger)}.authCard ion-card-content ion-item{--ion-item-background: var(--ion-color-white);--border-color: var(--ion-color-light)}.authCard ion-card-content ion-icon{padding-top:4px;padding-right:5px;font-size:1.3em}.authCard ion-card-content .agreementsAcceptanceRow{margin-top:15px;font-size:.9em}.authCard ion-card-content .agreementsAcceptanceRow ion-checkbox{vertical-align:bottom;margin-right:3px}.authCard ion-card-content ion-button{margin-top:15px}.authCard ion-card-content .smallCaseButton{text-transform:none;letter-spacing:normal;font-size:1em}@media only screen and (max-width: 500px){.authCard{background-color:transparent;border:none}}.ideaLogo{width:65px;margin:40px auto 0;cursor:pointer}\n"], components: [{ type: i1.IonContent, selector: "ion-content", inputs: ["color", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { type: i1.IonCard, selector: "ion-card", inputs: ["button", "color", "disabled", "download", "href", "mode", "rel", "routerAnimation", "routerDirection", "target", "type"] }, { type: i1.IonCardHeader, selector: "ion-card-header", inputs: ["color", "mode", "translucent"] }, { type: i1.IonCardTitle, selector: "ion-card-title", inputs: ["color", "mode"] }, { type: i1.IonCardSubtitle, selector: "ion-card-subtitle", inputs: ["color", "mode"] }, { type: i1.IonCardContent, selector: "ion-card-content", inputs: ["mode"] }, { type: i1.IonItem, selector: "ion-item", inputs: ["button", "color", "counter", "detail", "detailIcon", "disabled", "download", "fill", "href", "lines", "mode", "rel", "routerAnimation", "routerDirection", "shape", "target", "type"] }, { type: i1.IonLabel, selector: "ion-label", inputs: ["color", "mode", "position"] }, { type: i1.IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { type: i1.IonInput, selector: "ion-input", inputs: ["accept", "autocapitalize", "autocomplete", "autocorrect", "autofocus", "clearInput", "clearOnEdit", "color", "debounce", "disabled", "enterkeyhint", "inputmode", "max", "maxlength", "min", "minlength", "mode", "multiple", "name", "pattern", "placeholder", "readonly", "required", "size", "spellcheck", "step", "type", "value"] }, { type: i1.IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }], directives: [{ type: i5.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { type: i5.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i5.NgForm, selector: "form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]", inputs: ["ngFormOptions"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1.TextValueAccessor, selector: "ion-input:not([type=number]),ion-textarea,ion-searchbar" }, { type: i5.PatternValidator, selector: "[pattern][formControlName],[pattern][formControl],[pattern][ngModel]", inputs: ["pattern"] }, { type: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i5.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }], pipes: { "translate": i3.IDEATranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: IDEAConfirmPasswordPage, decorators: [{
+            type: Component,
+            args: [{ selector: 'idea-confirm-password', template: "<ion-content>\n  <form class=\"flexBox\">\n    <ion-card class=\"authCard\">\n      <ion-card-header>\n        <ion-card-title color=\"primary\">{{ 'IDEA_AUTH.CHANGE_THE_PASSWORD' | translate }}</ion-card-title>\n        <ion-card-subtitle>{{ 'IDEA_AUTH.CHANGE_THE_PASSWORD_HINT' | translate: { n: 8 } }}</ion-card-subtitle>\n      </ion-card-header>\n      <ion-card-content>\n        <p class=\"errorBox\" *ngIf=\"errorMsg\">\n          <b> {{ 'IDEA_AUTH.ERROR' | translate }}. </b>\n          {{ errorMsg }}\n        </p>\n        <ion-item>\n          <ion-label position=\"inline\">\n            <ion-icon name=\"person-circle\" color=\"primary\"> </ion-icon>\n          </ion-label>\n          <ion-input\n            type=\"email\"\n            inputmode=\"email\"\n            pattern=\"[A-Za-z0-9._%+-]{2,}@[a-zA-Z-_.]{2,}[.]{1}[a-zA-Z]{2,}\"\n            spellcheck=\"false\"\n            autocorrect=\"off\"\n            autocapitalize=\"off\"\n            autocomplete=\"email\"\n            [placeholder]=\"t._('IDEA_AUTH.EMAIL')\"\n            [title]=\"t._('IDEA_AUTH.EMAIL_HINT')\"\n            [ngModelOptions]=\"{ standalone: true }\"\n            [(ngModel)]=\"email\"\n            (keyup.enter)=\"confirmPassword()\"\n          ></ion-input>\n        </ion-item>\n        <ion-item>\n          <ion-label position=\"inline\">\n            <ion-icon name=\"disc\" color=\"primary\"></ion-icon>\n          </ion-label>\n          <ion-input\n            type=\"text\"\n            spellcheck=\"false\"\n            autocorrect=\"off\"\n            autocapitalize=\"off\"\n            autocomplete=\"off\"\n            [placeholder]=\"t._('IDEA_AUTH.RESET_CODE')\"\n            [title]=\"t._('IDEA_AUTH.RESET_CODE_HINT')\"\n            [ngModelOptions]=\"{ standalone: true }\"\n            [(ngModel)]=\"code\"\n            (keyup.enter)=\"confirmPassword()\"\n          ></ion-input>\n        </ion-item>\n        <ion-item>\n          <ion-label position=\"inline\">\n            <ion-icon name=\"key\" color=\"primary\"></ion-icon>\n          </ion-label>\n          <ion-input\n            type=\"password\"\n            pattern=\".{8,}\"\n            spellcheck=\"false\"\n            autocorrect=\"off\"\n            autocapitalize=\"off\"\n            autocomplete=\"new-password\"\n            [clearOnEdit]=\"false\"\n            [placeholder]=\"t._('IDEA_AUTH.NEW_PASSWORD')\"\n            [title]=\"t._('IDEA_AUTH.CHOOSE_A_PASSWORD')\"\n            [ngModelOptions]=\"{ standalone: true }\"\n            [(ngModel)]=\"newPassword\"\n            (keyup.enter)=\"confirmPassword()\"\n          ></ion-input>\n        </ion-item>\n        <ion-button expand=\"block\" [title]=\"t._('IDEA_AUTH.CHANGE_MY_PASSWORD_HINT')\" (click)=\"confirmPassword()\">\n          {{ 'IDEA_AUTH.CHANGE_MY_PASSWORD' | translate }}\n        </ion-button>\n        <ion-button\n          fill=\"clear\"\n          expand=\"block\"\n          class=\"smallCaseButton\"\n          [title]=\"t._('IDEA_AUTH.HAVEN_T_RECEIVED_A_RESET_CODE_HINT')\"\n          (click)=\"goToForgotPassword()\"\n        >\n          {{ 'IDEA_AUTH.HAVEN_T_RECEIVED_A_RESET_CODE' | translate }}\n        </ion-button>\n        <ion-button\n          fill=\"clear\"\n          expand=\"block\"\n          class=\"smallCaseButton\"\n          [title]=\"t._('IDEA_AUTH.BACK_TO_SIGN_IN_HINT')\"\n          (click)=\"goToAuth()\"\n        >\n          {{ 'IDEA_AUTH.BACK_TO_SIGN_IN' | translate }}\n        </ion-button>\n      </ion-card-content>\n    </ion-card>\n  </form>\n</ion-content>\n", styles: [".flexBox{background:var(--ion-color-white-shade)}.authCard{min-width:400px;max-width:550px;margin:0 10px;padding:20px;background-color:var(--ion-color-white);border:1px solid var(--ion-color-light);border-radius:10px;box-shadow:none;text-align:center}.authCard ion-img{width:150px;display:block;margin:0 auto}.authCard ion-card-title{font-family:auth-title;font-size:3em}.authCard ion-card-subtitle{font-family:auth-title;font-size:1.2em}.authCard ion-card-content{padding-top:16px}.authCard ion-card-content .errorBox{padding-left:10px;margin-bottom:20px;text-align:left;border-left:2px solid var(--ion-color-danger)}.authCard ion-card-content ion-item{--ion-item-background: var(--ion-color-white);--border-color: var(--ion-color-light)}.authCard ion-card-content ion-icon{padding-top:4px;padding-right:5px;font-size:1.3em}.authCard ion-card-content .agreementsAcceptanceRow{margin-top:15px;font-size:.9em}.authCard ion-card-content .agreementsAcceptanceRow ion-checkbox{vertical-align:bottom;margin-right:3px}.authCard ion-card-content ion-button{margin-top:15px}.authCard ion-card-content .smallCaseButton{text-transform:none;letter-spacing:normal;font-size:1em}@media only screen and (max-width: 500px){.authCard{background-color:transparent;border:none}}.ideaLogo{width:65px;margin:40px auto 0;cursor:pointer}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.NavController }, { type: i2.ActivatedRoute }, { type: i3.IDEAMessageService }, { type: i3.IDEALoadingService }, { type: i4.IDEAAuthService }, { type: i3.IDEATranslationsService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"confirmPassword.page.js","sourceRoot":"","sources":["../../../../modules/auth/src/confirmPassword.page.ts","../../../../modules/auth/src/confirmPassword.page.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;;;;;;;;AAY1C,MAAM,OAAO,uBAAuB;IAkBlC,YACS,OAAsB,EACtB,KAAqB,EACrB,OAA2B,EAC3B,OAA2B,EAC3B,IAAqB,EACrB,CAA0B;QAL1B,YAAO,GAAP,OAAO,CAAe;QACtB,UAAK,GAAL,KAAK,CAAgB;QACrB,YAAO,GAAP,OAAO,CAAoB;QAC3B,YAAO,GAAP,OAAO,CAAoB;QAC3B,SAAI,GAAJ,IAAI,CAAiB;QACrB,MAAC,GAAD,CAAC,CAAyB;QAEjC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;QACpE,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI;YACrD,IAAI,CAAC,KAAK,GAAG,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QACxE,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC;IACnD,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,eAAe;QAC1B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QAC1B,IAAI,CAAC,IAAI;aACN,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC;aACxD,IAAI,CAAC,GAAG,EAAE;YACT,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,4BAA4B,CAAC,CAAC;YACnD,IAAI,CAAC,QAAQ,EAAE,CAAC;QAClB,CAAC,CAAC;aACD,KAAK,CAAC,GAAG,EAAE;YACV,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,kCAAkC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;YACvE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QAC1C,CAAC,CAAC;aACD,OAAO,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IACxC,CAAC;IAED;;OAEG;IACI,kBAAkB;QACvB,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,sBAAsB,CAAC,CAAC,CAAC;IACtD,CAAC;IACD;;OAEG;IACI,QAAQ;QACb,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IACtC,CAAC;;oHA9DU,uBAAuB;wGAAvB,uBAAuB,6DCZpC,i/GA4FA;2FDhFa,uBAAuB;kBALnC,SAAS;+BACE,uBAAuB","sourcesContent":["import { Component } from '@angular/core';\nimport { NavController } from '@ionic/angular';\nimport { ActivatedRoute } from '@angular/router';\n\nimport { IDEAAuthService } from './auth.service';\nimport { IDEAMessageService, IDEALoadingService, IDEATranslationsService } from '@idea-ionic/common';\n\n@Component({\n  selector: 'idea-confirm-password',\n  templateUrl: 'confirmPassword.page.html',\n  styleUrls: ['auth.scss']\n})\nexport class IDEAConfirmPasswordPage {\n  /**\n   * The email address used to identify the account.\n   */\n  public email: string;\n  /**\n   * The code (received via email), to use for confirming the account.\n   */\n  public code: string;\n  /**\n   * The new password for the account.\n   */\n  public newPassword: string;\n  /**\n   * The error message to display in the UI, if any.\n   */\n  public errorMsg: string;\n\n  constructor(\n    public navCtrl: NavController,\n    public route: ActivatedRoute,\n    public message: IDEAMessageService,\n    public loading: IDEALoadingService,\n    public auth: IDEAAuthService,\n    public t: IDEATranslationsService\n  ) {\n    this.email = this.route.snapshot.queryParamMap.get('email') || null;\n    if (!this.email && this.route.snapshot.queryParams.user)\n      this.email = decodeURIComponent(this.route.snapshot.queryParams.user);\n    this.code = this.route.snapshot.queryParams.code;\n  }\n\n  /**\n   * Confirm new password.\n   */\n  public async confirmPassword() {\n    this.errorMsg = null;\n    await this.loading.show();\n    this.auth\n      .confirmPassword(this.email, this.code, this.newPassword)\n      .then(() => {\n        this.message.success('IDEA_AUTH.PASSWORD_CHANGED');\n        this.goToAuth();\n      })\n      .catch(() => {\n        this.errorMsg = this.t._('IDEA_AUTH.CONFIRM_PASSWORD_ERROR', { n: 8 });\n        this.message.error(this.errorMsg, true);\n      })\n      .finally(() => this.loading.hide());\n  }\n\n  /**\n   * Go to forgot password page.\n   */\n  public goToForgotPassword() {\n    this.navCtrl.navigateBack(['auth/forgot-password']);\n  }\n  /**\n   * Go to auth page.\n   */\n  public goToAuth() {\n    this.navCtrl.navigateBack(['auth']);\n  }\n}\n","<ion-content>\n  <form class=\"flexBox\">\n    <ion-card class=\"authCard\">\n      <ion-card-header>\n        <ion-card-title color=\"primary\">{{ 'IDEA_AUTH.CHANGE_THE_PASSWORD' | translate }}</ion-card-title>\n        <ion-card-subtitle>{{ 'IDEA_AUTH.CHANGE_THE_PASSWORD_HINT' | translate: { n: 8 } }}</ion-card-subtitle>\n      </ion-card-header>\n      <ion-card-content>\n        <p class=\"errorBox\" *ngIf=\"errorMsg\">\n          <b> {{ 'IDEA_AUTH.ERROR' | translate }}. </b>\n          {{ errorMsg }}\n        </p>\n        <ion-item>\n          <ion-label position=\"inline\">\n            <ion-icon name=\"person-circle\" color=\"primary\"> </ion-icon>\n          </ion-label>\n          <ion-input\n            type=\"email\"\n            inputmode=\"email\"\n            pattern=\"[A-Za-z0-9._%+-]{2,}@[a-zA-Z-_.]{2,}[.]{1}[a-zA-Z]{2,}\"\n            spellcheck=\"false\"\n            autocorrect=\"off\"\n            autocapitalize=\"off\"\n            autocomplete=\"email\"\n            [placeholder]=\"t._('IDEA_AUTH.EMAIL')\"\n            [title]=\"t._('IDEA_AUTH.EMAIL_HINT')\"\n            [ngModelOptions]=\"{ standalone: true }\"\n            [(ngModel)]=\"email\"\n            (keyup.enter)=\"confirmPassword()\"\n          ></ion-input>\n        </ion-item>\n        <ion-item>\n          <ion-label position=\"inline\">\n            <ion-icon name=\"disc\" color=\"primary\"></ion-icon>\n          </ion-label>\n          <ion-input\n            type=\"text\"\n            spellcheck=\"false\"\n            autocorrect=\"off\"\n            autocapitalize=\"off\"\n            autocomplete=\"off\"\n            [placeholder]=\"t._('IDEA_AUTH.RESET_CODE')\"\n            [title]=\"t._('IDEA_AUTH.RESET_CODE_HINT')\"\n            [ngModelOptions]=\"{ standalone: true }\"\n            [(ngModel)]=\"code\"\n            (keyup.enter)=\"confirmPassword()\"\n          ></ion-input>\n        </ion-item>\n        <ion-item>\n          <ion-label position=\"inline\">\n            <ion-icon name=\"key\" color=\"primary\"></ion-icon>\n          </ion-label>\n          <ion-input\n            type=\"password\"\n            pattern=\".{8,}\"\n            spellcheck=\"false\"\n            autocorrect=\"off\"\n            autocapitalize=\"off\"\n            autocomplete=\"new-password\"\n            [clearOnEdit]=\"false\"\n            [placeholder]=\"t._('IDEA_AUTH.NEW_PASSWORD')\"\n            [title]=\"t._('IDEA_AUTH.CHOOSE_A_PASSWORD')\"\n            [ngModelOptions]=\"{ standalone: true }\"\n            [(ngModel)]=\"newPassword\"\n            (keyup.enter)=\"confirmPassword()\"\n          ></ion-input>\n        </ion-item>\n        <ion-button expand=\"block\" [title]=\"t._('IDEA_AUTH.CHANGE_MY_PASSWORD_HINT')\" (click)=\"confirmPassword()\">\n          {{ 'IDEA_AUTH.CHANGE_MY_PASSWORD' | translate }}\n        </ion-button>\n        <ion-button\n          fill=\"clear\"\n          expand=\"block\"\n          class=\"smallCaseButton\"\n          [title]=\"t._('IDEA_AUTH.HAVEN_T_RECEIVED_A_RESET_CODE_HINT')\"\n          (click)=\"goToForgotPassword()\"\n        >\n          {{ 'IDEA_AUTH.HAVEN_T_RECEIVED_A_RESET_CODE' | translate }}\n        </ion-button>\n        <ion-button\n          fill=\"clear\"\n          expand=\"block\"\n          class=\"smallCaseButton\"\n          [title]=\"t._('IDEA_AUTH.BACK_TO_SIGN_IN_HINT')\"\n          (click)=\"goToAuth()\"\n        >\n          {{ 'IDEA_AUTH.BACK_TO_SIGN_IN' | translate }}\n        </ion-button>\n      </ion-card-content>\n    </ion-card>\n  </form>\n</ion-content>\n"]}