@smarterplan/ngx-smarterplan-core 0.3.11

package/esm2020/lib/services/user.service.mjs

@@ -0,0 +1,444 @@
+import { Injectable } from "@angular/core";
+import { Subject } from "rxjs";
+import { LevelStatus, ProfileEntity, ProfileStatus, PropertyType, RoleStatus } from "../types.service";
+import { enumToArray, filterUniqueArrayByID, getHighestLevelForMissions, getHighestRoleForMissions, getLevelsBelow, getRolesBelowForManager } from "../helpers.service";
+import { DateTime } from "luxon";
+import { Auth } from "aws-amplify";
+import * as i0 from "@angular/core";
+import * as i1 from "./models/profile.service";
+import * as i2 from "./models/mission.service";
+import * as i3 from "./models/property.service";
+import * as i4 from "@angular/router";
+import * as i5 from "@angular/common";
+import * as i6 from "@ngx-translate/core";
+/**
+ * UserService handles user's lifecycle, from creation to deletion
+ */
+export class BaseUserService {
+    constructor(profileService, missionService, propertyService, router, location, ngZone, translate) {
+        this.profileService = profileService;
+        this.missionService = missionService;
+        this.propertyService = propertyService;
+        this.router = router;
+        this.location = location;
+        this.ngZone = ngZone;
+        this.translate = translate;
+        this.isChanged = new Subject();
+        this.updating = false;
+        this.managers = [
+            RoleStatus.ADMIN,
+            RoleStatus.MANAGER,
+            RoleStatus.OWNER,
+            RoleStatus.GUIDE_MUSEUM,
+        ];
+        this.cu = null;
+        // this.checkConnectedAWSUser();
+        this.missionService.currentMissionsUpdated.subscribe(async (data) => {
+            console.log("current missions updated");
+            this.currentMissions =
+                await this.missionService.instantMissionsOfCurrent(this.cu.id);
+            console.log("user is changed emitting");
+            this.isChanged.next(true);
+        });
+    }
+    /**
+     * Checks if AWS user is connected and assigng it to current user (this.cu)
+    **/
+    async checkConnectedAWSUser() {
+        if (!this.cu) {
+            console.log("first connection");
+            let cau = null;
+            let user = null;
+            try {
+                cau = await Auth.currentAuthenticatedUser();
+                user = await this.current(cau);
+                console.log(user);
+            }
+            catch { }
+            if (!user) {
+                console.log("here");
+                this.router.navigate(["auth"]);
+            }
+        }
+    }
+    /**
+     * createUser spawns a new User, along with:
+     * - a proper AWSCognito signup
+     * - a Profile entry holding the AWSCognito ID
+     * - a Mission entry holding the Organisation ID
+     *
+     * @see 174
+     * @see https://docs.amplify.aws/lib/auth/emailpassword/q/platform/js#sign-up
+     * @todo wonder if we can mash together Profile, Mission and User entries
+     * @param u User to be created
+     */
+    async createUserAWSandProfile(u, prevalidated = false) {
+        const attributes = {
+            email: u.email.trim(),
+            given_name: u.firstName,
+            family_name: u.lastName,
+            zoneinfo: "fr",
+            locale: "fr",
+            "custom:prevalidated": "false",
+        };
+        if (prevalidated) {
+            attributes["custom:prevalidated"] = "true";
+        }
+        // AWSCognito
+        const password = u.password ? u.password : "temporaryp";
+        let error;
+        try {
+            const { userSub } = await Auth.signUp({
+                username: u.email,
+                password,
+                attributes,
+                clientMetadata: {
+                    phone: u.phone,
+                },
+            });
+            if (userSub) {
+                return this.createProfile(userSub, u);
+            }
+        }
+        catch (error_) {
+            switch (error_.code) {
+                case "InvalidPasswordException":
+                    error = "auth.error.wrong_password";
+                    break;
+                case "UserNotConfirmedException":
+                    error = "auth.error.user_not_confirmed";
+                    break;
+                case "InvalidParameterException":
+                    error = "auth.error.invalid_parameter";
+                    break;
+                default:
+                    error = error_.message;
+            }
+            console.log(`AWS Sign UP error : ${error}`);
+        }
+        return Promise.reject(error);
+    }
+    async createProfile(awsUserID, u) {
+        const profile = await this.profileService.createProfile({
+            userID: awsUserID,
+            metadata: JSON.stringify({
+                email: u.email,
+                phone: u.phone,
+                lastName: u.lastName,
+                firstName: u.firstName,
+            }),
+            status: ProfileStatus.WAITING_FOR_ACTIVATION,
+        });
+        return profile;
+    }
+    currentOrganisation(spaceID = null) {
+        if (this.cu) {
+            if (!spaceID) {
+                return this.currentMissions[0].organisation;
+            }
+            return this.currentMission(spaceID).organisation;
+        }
+        return null;
+    }
+    async current(user, fastConnect = false) {
+        if (!this.cu && !this.updating) {
+            this.updating = true;
+            this.cu = await this.userFromAWSID(user.username);
+            if (!this.cu && user.attributes.email) {
+                console.log(`No profile for userID 🔪 ${user.attributes.email}`);
+                // There's no profiles, profiles.items.length === 0
+                // It's maybe the 🤮 case where the profile has been saved with an email
+                // instead of an hashed id
+                // If found, we need to replace the id in both the Profile
+                const emailProfile = await this.userFromAWSID(user.attributes.email);
+                if (emailProfile) {
+                    console.log(`👏 doing the spacehip reversal email on ${user.attributes.email}`);
+                    this.cu = await this.userFromAWSID(user.username);
+                }
+            }
+            if (!this.cu) {
+                this.updating = false;
+                await Auth.signOut();
+                return null;
+            }
+            const missions = await this.missionService.instantMissionsOfCurrent(this.cu.id);
+            this.currentMissions = missions;
+            let okToLogin = true;
+            if (!fastConnect && !this.isSPAdmin()) {
+                // check access token if not Fast connect (fast connect is for the guest connection via link(/redirect?user=))
+                // and not SmarterPlan Admin
+                okToLogin = await this.checkAccessToken(user.signInUserSession.accessToken.jwtToken);
+            }
+            if (!okToLogin) {
+                this.cu = null;
+                this.currentMissions = [];
+                this.updating = false;
+                await Auth.signOut();
+                return null;
+            }
+            await this.profileService.updateProfile({
+                id: this.cu.id,
+                lastConnectedAt: Date.now(),
+            });
+            if (!missions && this.location.path() !== "/no-mission") {
+                this.ngZone.run(() => {
+                    this.router.navigate(["/no-mission"]);
+                });
+            }
+            console.log("user is changed emitting");
+            this.isChanged.next(true);
+            this.updating = false;
+        }
+        return this.cu;
+    }
+    async userFromAWSID(userId) {
+        const profile = await this.profileService.getProfileFromAWSID(userId);
+        if (profile) {
+            return new ProfileEntity(profile);
+        }
+        return null;
+    }
+    async userFromUserID(userID) {
+        const profile = await this.profileService.getProfile(userID);
+        return new ProfileEntity(profile);
+    }
+    currentMission(spaceID) {
+        const mission = this.getMissionForSpace(spaceID);
+        return mission;
+    }
+    isManager(spaceID) {
+        const mission = this.getMissionForSpace(spaceID);
+        if (mission) {
+            return this.managers.includes(mission.role);
+        }
+        return false;
+    }
+    isService(spaceID) {
+        const mission = this.getMissionForSpace(spaceID);
+        if (mission) {
+            return mission.role === RoleStatus.SERVICE;
+        }
+        return false;
+    }
+    isAdmin(spaceID) {
+        const mission = this.getMissionForSpace(spaceID);
+        if (mission) {
+            return mission.role === RoleStatus.ADMIN;
+        }
+        return false;
+    }
+    isSmarterPlan() {
+        if (!this.currentMissions) {
+            return false;
+        }
+        const spMissions = this.currentMissions.filter((m) => m.organisationID === "6e28201f-4679-4c29-9d2d-8a325f57cee9" &&
+            this.managers.includes(m.role)); // ID of SmarterPlan
+        return spMissions.length > 0;
+    }
+    isSPAdmin() {
+        if (!this.currentMissions) {
+            return false;
+        }
+        const spMissions = this.currentMissions.filter((m) => m.organisationID === "6e28201f-4679-4c29-9d2d-8a325f57cee9" &&
+            m.role === RoleStatus.ADMIN); // ID of SmarterPlan
+        return spMissions.length > 0;
+    }
+    getMissionForSpace(spaceID) {
+        if (!this.currentMissions) {
+            return null;
+        }
+        return this.currentMissions.find((m) => m.spaceID === spaceID);
+    }
+    hasManagerRoleInAnyMission() {
+        if (!this.currentMissions) {
+            return false;
+        }
+        return this.currentMissions.some((mis) => this.managers.includes(mis.role));
+    }
+    hasServiceRoleInAnyMission() {
+        if (!this.currentMissions) {
+            return false;
+        }
+        return this.currentMissions.some((mis) => mis.role === RoleStatus.SERVICE);
+    }
+    hasAdminRoleInAnyMission() {
+        if (!this.currentMissions) {
+            return false;
+        }
+        return this.currentMissions.some((mis) => mis.role === RoleStatus.ADMIN);
+    }
+    async createOrUpdateMissionForOrgWithProperty(missionInput, orgID, create = true) {
+        const mission = await (create
+            ? this.missionService.create(missionInput)
+            : this.missionService.update(missionInput));
+        if (this.managers.includes(mission.role) && mission.spaceID) {
+            const properties = await this.propertyService.getPropertiesForOrganisation(orgID);
+            const propertySpaceIDs = properties.map((property_) => property_.spaceID);
+            if (propertySpaceIDs.includes(mission.spaceID)) {
+                return mission;
+            }
+            // we delegate the rights of the space
+            await this.propertyService.createProperty({
+                spaceID: mission.spaceID,
+                organisationID: orgID,
+                type: PropertyType.SHARED,
+            });
+        }
+        return mission;
+    }
+    async softDeleteUser(userID) {
+        const missions = await this.missionService.getMissionsFromUserID(userID);
+        if (missions.length === 0) {
+            await this.profileService.updateProfile({ id: userID, deletedAt: Date.now() });
+            console.log("Profile soft deleted");
+        }
+    }
+    /**
+     * Checks if the Profile (by id) can be removed completely from the DB (no missions in the DB)
+     * @param profileID
+     * @returns boolean
+     */
+    async canHardDeleteUser(profileID) {
+        const missions = (await this.missionService.getMissionsFromUserID(profileID));
+        return missions.length === 0;
+    }
+    async hardDeleteUser(userID) {
+        const deleted = await this.profileService.deleteProfile(userID);
+        console.log("Profile hard deleted");
+        return deleted;
+    }
+    getManagerMissions() {
+        if (!this.currentMissions) {
+            return [];
+        }
+        return this.currentMissions.filter((mis) => this.managers.includes(mis.role));
+    }
+    getAvalableLevelsForCurrentUser() {
+        if (!this.currentMissions) {
+            return [LevelStatus.MINIMUM];
+        }
+        const levels = enumToArray(LevelStatus);
+        const highestLevel = getHighestLevelForMissions(this.currentMissions);
+        return levels.filter((level) => getLevelsBelow(highestLevel).includes(level));
+    }
+    getAvailableRolesForCurrentUser() {
+        if (!this.currentMissions) {
+            return [RoleStatus.VISITOR];
+        }
+        const roles = enumToArray(RoleStatus);
+        const highestRole = getHighestRoleForMissions(this.currentMissions);
+        return roles.filter((role) => getRolesBelowForManager(highestRole).includes(role));
+    }
+    /** Test if the user have the role given in parameter : "roleStatus" */
+    isRole(roleStatus) {
+        if (!this.currentMissions) {
+            return false;
+        }
+        return this.currentMissions.some((m) => m.role === roleStatus);
+    }
+    isGuide(spaceID = null) {
+        if (spaceID) {
+            const mission = this.getMissionForSpace(spaceID);
+            if (mission) {
+                return mission.role === RoleStatus.GUIDE_MUSEUM;
+            }
+        }
+        return this.isRole(RoleStatus.GUIDE_MUSEUM);
+    }
+    isMuseumVisitor(spaceID = null) {
+        if (spaceID) {
+            const mission = this.getMissionForSpace(spaceID);
+            if (mission) {
+                return mission.role === RoleStatus.VISITOR_MUSEUM;
+            }
+        }
+        return this.isRole(RoleStatus.VISITOR_MUSEUM);
+    }
+    isOccupant() {
+        return this.isRole(RoleStatus.OCCUPANT);
+    }
+    isVisitor(spaceID = null) {
+        if (spaceID) {
+            const mission = this.getMissionForSpace(spaceID);
+            if (mission) {
+                return mission.role === RoleStatus.VISITOR;
+            }
+        }
+        return this.isRole(RoleStatus.VISITOR);
+    }
+    isMuseumUser(spaceID = null) {
+        return this.isGuide(spaceID) || this.isMuseumVisitor(spaceID);
+    }
+    hasOnlyMuseumRole() {
+        if (this.currentMissions) {
+            return this.currentMissions.every((m) => m.role === RoleStatus.GUIDE_MUSEUM ||
+                m.role === RoleStatus.VISITOR_MUSEUM);
+        }
+        return false;
+    }
+    async profileForMail(mail) {
+        const usersWithMail = await this.profileService.getUsersForMail(mail);
+        return usersWithMail.length > 0 ? usersWithMail[0] : null;
+    }
+    currentOrderedOrgList() {
+        if (!this.currentMissions) {
+            return [];
+        }
+        const orderedOrgList = this.currentMissions.map((mis) => mis.orderedOrganisation);
+        return filterUniqueArrayByID(orderedOrgList);
+    }
+    userHasAccessToAllZonesInSpace(spaceID) {
+        const missionsForSpace = this.currentMissions.filter((mis) => mis.spaceID === spaceID);
+        return missionsForSpace.some((mission) => !mission.zoneID || (mission.zone && !mission.zone.parentID));
+    }
+    async logoutCurrentAndSignOutAuth() {
+        await this.profileService.updateProfile({
+            id: this.cu.id,
+            token: null,
+        });
+        this.cu = null;
+        this.currentMissions = null;
+        this.isChanged.next(false);
+        await Auth.signOut();
+    }
+    async checkAccessToken(jwtToken) {
+        const now = DateTime.local();
+        // console.log("now", now);
+        // console.log("in one hour", now.plus({ hours: 1 }).toMillis());
+        if (this.cu.token && this.cu.tokenExpiredAt > now.toMillis()) {
+            // check token
+            if (this.cu.token === jwtToken) {
+                console.log("same aws token");
+                return true;
+            }
+            alert(this.translate.instant("auth.error.activeToken"));
+            return false;
+        }
+        await this.profileService.updateProfile({
+            id: this.cu.id,
+            tokenExpiredAt: now.plus({ hours: 1 }).toMillis(),
+            token: jwtToken,
+            status: ProfileStatus.ACTIVE,
+        });
+        return true;
+    }
+    async clearUserToken(id) {
+        await this.profileService.updateProfile({
+            id: id,
+            token: null,
+        });
+    }
+    updateCurrentUser(profile) {
+        this.cu = new ProfileEntity(profile);
+        this.isChanged.next(true);
+    }
+}
+BaseUserService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: BaseUserService, deps: [{ token: i1.ProfileService }, { token: i2.MissionService }, { token: i3.PropertyService }, { token: i4.Router }, { token: i5.Location }, { token: i0.NgZone }, { token: i6.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+BaseUserService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: BaseUserService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: BaseUserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ProfileService }, { type: i2.MissionService }, { type: i3.PropertyService }, { type: i4.Router }, { type: i5.Location }, { type: i0.NgZone }, { type: i6.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-smarterplan-core/src/lib/services/user.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from \"@angular/core\";\r\nimport { Subject } from \"rxjs\";\r\nimport { Router } from \"@angular/router\";\r\nimport { Location } from \"@angular/common\";\r\nimport { TranslateService } from \"@ngx-translate/core\";\r\nimport { LevelStatus, Mission, Organisation, Profile, ProfileEntity, ProfileStatus, PropertyType, RoleStatus } from \"../types.service\";\r\nimport { enumToArray, filterUniqueArrayByID, getHighestLevelForMissions, getHighestRoleForMissions, getLevelsBelow, getRolesBelowForManager } from \"../helpers.service\";\r\nimport { ProfileService } from \"./models/profile.service\";\r\nimport { MissionService } from \"./models/mission.service\";\r\nimport { PropertyService } from \"./models/property.service\";\r\nimport { DateTime } from \"luxon\";\r\nimport { Auth } from \"aws-amplify\";\r\n\r\ninterface CreateUser {\r\n    email: string;\r\n    phone: string;\r\n    lastName: string;\r\n    firstName: string;\r\n    password?: string;\r\n}\r\n\r\n/**\r\n * UserService handles user's lifecycle, from creation to deletion\r\n */\r\n@Injectable({\r\n    providedIn: \"root\",\r\n})\r\nexport class BaseUserService {\r\n\r\n    isChanged: Subject<boolean> = new Subject<boolean>();\r\n\r\n    updating = false;\r\n\r\n    managers = [\r\n        RoleStatus.ADMIN,\r\n        RoleStatus.MANAGER,\r\n        RoleStatus.OWNER,\r\n        RoleStatus.GUIDE_MUSEUM,\r\n    ];\r\n\r\n    currentMissions: Mission[];\r\n\r\n    lastExpiredMission: Mission;\r\n\r\n    nextMissionToStart: Mission;\r\n\r\n    cu: ProfileEntity = null;\r\n\r\n    constructor(\r\n        private profileService: ProfileService,\r\n        private missionService: MissionService,\r\n        private propertyService: PropertyService,\r\n        private router: Router,\r\n        private location: Location,\r\n        private ngZone: NgZone,\r\n        private translate: TranslateService,\r\n    ) {\r\n        // this.checkConnectedAWSUser();\r\n        this.missionService.currentMissionsUpdated.subscribe(async (data) => {\r\n            console.log(\"current missions updated\");\r\n            this.currentMissions =\r\n                await this.missionService.instantMissionsOfCurrent(this.cu.id);\r\n            console.log(\"user is changed emitting\");\r\n            this.isChanged.next(true);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Checks if AWS user is connected and assigng it to current user (this.cu)\r\n    **/\r\n    async checkConnectedAWSUser() {\r\n        if (!this.cu) {\r\n            console.log(\"first connection\");\r\n            let cau = null;\r\n            let user = null;\r\n            try {\r\n                cau = await Auth.currentAuthenticatedUser();\r\n                user = await this.current(cau);\r\n                console.log(user)\r\n            } catch {}\r\n            if (!user) {\r\n                console.log(\"here\")\r\n                this.router.navigate([\"auth\"]);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * createUser spawns a new User, along with:\r\n     * - a proper AWSCognito signup\r\n     * - a Profile entry holding the AWSCognito ID\r\n     * - a Mission entry holding the Organisation ID\r\n     *\r\n     * @see 174\r\n     * @see https://docs.amplify.aws/lib/auth/emailpassword/q/platform/js#sign-up\r\n     * @todo wonder if we can mash together Profile, Mission and User entries\r\n     * @param u User to be created\r\n     */\r\n    async createUserAWSandProfile(\r\n        u: {\r\n            email: string;\r\n            phone: string;\r\n            lastName: string;\r\n            firstName: string;\r\n            password?: string;\r\n        },\r\n        prevalidated: boolean = false,\r\n    ): Promise<Profile> {\r\n        const attributes = {\r\n            email: u.email.trim(),\r\n            given_name: u.firstName,\r\n            family_name: u.lastName,\r\n            zoneinfo: \"fr\", // @todo deal with zoneinfo and locale\r\n            locale: \"fr\",\r\n            \"custom:prevalidated\": \"false\",\r\n        };\r\n        if (prevalidated) {\r\n            attributes[\"custom:prevalidated\"] = \"true\";\r\n        }\r\n        // AWSCognito\r\n        const password = u.password ? u.password : \"temporaryp\";\r\n        let error;\r\n        try {\r\n            const { userSub } = await Auth.signUp({\r\n                username: u.email, // username should be an email they say\r\n                password,\r\n                attributes,\r\n                clientMetadata: {\r\n                    phone: u.phone,\r\n                },\r\n            });\r\n            if (userSub) {\r\n                return this.createProfile(userSub, u);\r\n            }\r\n        } catch (error_: any) {\r\n            switch (error_.code) {\r\n                case \"InvalidPasswordException\":\r\n                    error = \"auth.error.wrong_password\";\r\n                    break;\r\n                case \"UserNotConfirmedException\":\r\n                    error = \"auth.error.user_not_confirmed\";\r\n                    break;\r\n                case \"InvalidParameterException\":\r\n                    error = \"auth.error.invalid_parameter\";\r\n                    break;\r\n                default:\r\n                    error = error_.message;\r\n            }\r\n            console.log(`AWS Sign UP error : ${error}`);\r\n        }\r\n        return Promise.reject(error);\r\n    }\r\n    \r\n    async createProfile(\r\n        awsUserID: string,\r\n        u: CreateUser,\r\n    ): Promise<Profile> {\r\n        const profile = await this.profileService.createProfile({\r\n            userID: awsUserID,\r\n            metadata: JSON.stringify({\r\n                email: u.email,\r\n                phone: u.phone,\r\n                lastName: u.lastName,\r\n                firstName: u.firstName,\r\n            }),\r\n            status: ProfileStatus.WAITING_FOR_ACTIVATION,\r\n        });\r\n        return profile;\r\n    }\r\n\r\n    currentOrganisation(spaceID: string = null): Organisation {\r\n        if (this.cu) {\r\n            if (!spaceID) {\r\n                return this.currentMissions[0].organisation;\r\n            }\r\n            return this.currentMission(spaceID).organisation;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    async current(\r\n        user,\r\n        fastConnect: boolean = false,\r\n    ): Promise<ProfileEntity | null> {\r\n        if (!this.cu && !this.updating) {\r\n            this.updating = true;\r\n            this.cu = await this.userFromAWSID(user.username);\r\n            if (!this.cu && user.attributes.email) {\r\n                console.log(\r\n                    `No profile for userID 🔪 ${user.attributes.email}`,\r\n                );\r\n                // There's no profiles, profiles.items.length === 0\r\n                // It's maybe the 🤮 case where the profile has been saved with an email\r\n                // instead of an hashed id\r\n                // If found, we need to replace the id in both the Profile\r\n                const emailProfile = await this.userFromAWSID(\r\n                    user.attributes.email,\r\n                );\r\n                if (emailProfile) {\r\n                    console.log(\r\n                        `👏 doing the spacehip reversal email on ${user.attributes.email}`,\r\n                    );\r\n                    this.cu = await this.userFromAWSID(user.username);\r\n                }\r\n            }\r\n            if (!this.cu) {\r\n                this.updating = false;\r\n                await Auth.signOut();\r\n                return null;\r\n            }\r\n            const missions = await this.missionService.instantMissionsOfCurrent(\r\n                this.cu.id\r\n            );\r\n            this.currentMissions = missions;\r\n            let okToLogin = true;\r\n            if (!fastConnect && !this.isSPAdmin()) {\r\n                // check access token if not Fast connect (fast connect is for the guest connection via link(/redirect?user=))\r\n                // and not SmarterPlan Admin\r\n                okToLogin = await this.checkAccessToken(\r\n                    user.signInUserSession.accessToken.jwtToken,\r\n                );\r\n            }\r\n            if (!okToLogin) {\r\n                this.cu = null;\r\n                this.currentMissions = [];\r\n                this.updating = false;\r\n                await Auth.signOut();\r\n                return null;\r\n            }\r\n            await this.profileService.updateProfile({\r\n                id: this.cu.id,\r\n                lastConnectedAt: Date.now(),\r\n            });\r\n            if (!missions && this.location.path() !== \"/no-mission\") {\r\n                this.ngZone.run(() => {\r\n                    this.router.navigate([\"/no-mission\"]);\r\n                });\r\n            }\r\n            console.log(\"user is changed emitting\");\r\n            this.isChanged.next(true);\r\n            this.updating = false;\r\n        }\r\n        return this.cu;\r\n    }\r\n\r\n    async userFromAWSID(userId: string): Promise<ProfileEntity | null> {\r\n        const profile = await this.profileService.getProfileFromAWSID(userId);\r\n        if (profile) {\r\n            return new ProfileEntity(profile);\r\n        }\r\n        return null;\r\n    }\r\n\r\n    async userFromUserID(userID: string): Promise<ProfileEntity | null> {\r\n        const profile = await this.profileService.getProfile(userID);\r\n        return new ProfileEntity(profile);\r\n    }\r\n\r\n    currentMission(spaceID: string): Mission {\r\n        const mission = this.getMissionForSpace(spaceID);\r\n        return mission;\r\n    }\r\n\r\n    isManager(spaceID: string): boolean {\r\n        const mission = this.getMissionForSpace(spaceID);\r\n        if (mission) {\r\n            return this.managers.includes(mission.role);\r\n        }\r\n        return false;\r\n    }\r\n\r\n    isService(spaceID: string): boolean {\r\n        const mission = this.getMissionForSpace(spaceID);\r\n        if (mission) {\r\n            return mission.role === RoleStatus.SERVICE;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    isAdmin(spaceID: string): boolean {\r\n        const mission = this.getMissionForSpace(spaceID);\r\n        if (mission) {\r\n            return mission.role === RoleStatus.ADMIN;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    isSmarterPlan(): boolean {\r\n        if (!this.currentMissions) {\r\n            return false;\r\n        }\r\n        const spMissions = this.currentMissions.filter(\r\n            (m) =>\r\n                m.organisationID === \"6e28201f-4679-4c29-9d2d-8a325f57cee9\" &&\r\n                this.managers.includes(m.role),\r\n        ); // ID of SmarterPlan\r\n        return spMissions.length > 0;\r\n    }\r\n\r\n    isSPAdmin(): boolean {\r\n        if (!this.currentMissions) {\r\n            return false;\r\n        }\r\n        const spMissions = this.currentMissions.filter(\r\n            (m) =>\r\n                m.organisationID === \"6e28201f-4679-4c29-9d2d-8a325f57cee9\" &&\r\n                m.role === RoleStatus.ADMIN,\r\n        ); // ID of SmarterPlan\r\n        return spMissions.length > 0;\r\n    }\r\n\r\n    getMissionForSpace(spaceID: string): Mission {\r\n        if (!this.currentMissions) {\r\n            return null;\r\n        }\r\n        return this.currentMissions.find((m) => m.spaceID === spaceID);\r\n    }\r\n\r\n    hasManagerRoleInAnyMission(): boolean {\r\n        if (!this.currentMissions) {\r\n            return false;\r\n        }\r\n        return this.currentMissions.some((mis) =>\r\n            this.managers.includes(mis.role),\r\n        );\r\n    }\r\n\r\n    hasServiceRoleInAnyMission(): boolean {\r\n        if (!this.currentMissions) {\r\n            return false;\r\n        }\r\n        return this.currentMissions.some(\r\n            (mis) => mis.role === RoleStatus.SERVICE,\r\n        );\r\n    }\r\n\r\n    hasAdminRoleInAnyMission(): boolean {\r\n        if (!this.currentMissions) {\r\n            return false;\r\n        }\r\n        return this.currentMissions.some(\r\n            (mis) => mis.role === RoleStatus.ADMIN,\r\n        );\r\n    }\r\n\r\n    async createOrUpdateMissionForOrgWithProperty(\r\n        missionInput: Mission,\r\n        orgID: string,\r\n        create: boolean = true,\r\n    ): Promise<Mission> {\r\n        const mission = await (create\r\n            ? this.missionService.create(missionInput)\r\n            : this.missionService.update(missionInput));\r\n\r\n        if (this.managers.includes(mission.role) && mission.spaceID) {\r\n            const properties =\r\n                await this.propertyService.getPropertiesForOrganisation(orgID);\r\n            const propertySpaceIDs = properties.map(\r\n                (property_) => property_.spaceID,\r\n            );\r\n            if (propertySpaceIDs.includes(mission.spaceID)) {\r\n                return mission;\r\n            }\r\n            // we delegate the rights of the space\r\n            await this.propertyService.createProperty({\r\n                spaceID: mission.spaceID,\r\n                organisationID: orgID,\r\n                type: PropertyType.SHARED,\r\n            });\r\n        }\r\n        return mission;\r\n    }\r\n\r\n    async softDeleteUser(userID: string) {\r\n        const missions = await this.missionService.getMissionsFromUserID(userID);\r\n        if (missions.length === 0) {\r\n            await this.profileService.updateProfile({ id: userID, deletedAt: Date.now() });\r\n            console.log(\"Profile soft deleted\");\r\n        }\r\n    }\r\n    /**\r\n     * Checks if the Profile (by id) can be removed completely from the DB (no missions in the DB)\r\n     * @param profileID\r\n     * @returns boolean\r\n     */\r\n    async canHardDeleteUser(profileID: string): Promise<boolean> {\r\n        const missions = (await this.missionService.getMissionsFromUserID(profileID));\r\n        return missions.length === 0;\r\n    }\r\n\r\n    async hardDeleteUser(userID: string) {\r\n        const deleted = await this.profileService.deleteProfile(userID);\r\n        console.log(\"Profile hard deleted\");\r\n        return deleted;\r\n    }\r\n\r\n    getManagerMissions(): Mission[] {\r\n        if (!this.currentMissions) {\r\n            return [];\r\n        }\r\n        return this.currentMissions.filter((mis) =>\r\n            this.managers.includes(mis.role),\r\n        );\r\n    }\r\n\r\n    getAvalableLevelsForCurrentUser(): LevelStatus[] {\r\n        if (!this.currentMissions) {\r\n            return [LevelStatus.MINIMUM];\r\n        }\r\n        const levels = enumToArray(LevelStatus);\r\n        const highestLevel = getHighestLevelForMissions(this.currentMissions);\r\n\r\n        return levels.filter((level) =>\r\n            getLevelsBelow(highestLevel).includes(level),\r\n        );\r\n    }\r\n\r\n    getAvailableRolesForCurrentUser(): RoleStatus[] {\r\n        if (!this.currentMissions) {\r\n            return [RoleStatus.VISITOR];\r\n        }\r\n        const roles = enumToArray(RoleStatus);\r\n        const highestRole = getHighestRoleForMissions(this.currentMissions);\r\n        return roles.filter((role) =>\r\n            getRolesBelowForManager(highestRole).includes(role),\r\n        );\r\n    }\r\n\r\n    /** Test if the user have the role given in parameter : \"roleStatus\" */\r\n    isRole(roleStatus: RoleStatus): boolean {\r\n        if (!this.currentMissions) {\r\n            return false;\r\n        }\r\n        return this.currentMissions.some((m) => m.role === roleStatus);\r\n    }\r\n\r\n    isGuide(spaceID: string = null): boolean {\r\n        if (spaceID) {\r\n            const mission = this.getMissionForSpace(spaceID);\r\n            if (mission) {\r\n                return mission.role === RoleStatus.GUIDE_MUSEUM;\r\n            }\r\n        }\r\n        return this.isRole(RoleStatus.GUIDE_MUSEUM);\r\n    }\r\n\r\n    isMuseumVisitor(spaceID: string = null): boolean {\r\n        if (spaceID) {\r\n            const mission = this.getMissionForSpace(spaceID);\r\n            if (mission) {\r\n                return mission.role === RoleStatus.VISITOR_MUSEUM;\r\n            }\r\n        }\r\n        return this.isRole(RoleStatus.VISITOR_MUSEUM);\r\n    }\r\n\r\n    isOccupant(): boolean {\r\n        return this.isRole(RoleStatus.OCCUPANT);\r\n    }\r\n\r\n    isVisitor(spaceID: string = null): boolean {\r\n        if (spaceID) {\r\n            const mission = this.getMissionForSpace(spaceID);\r\n            if (mission) {\r\n                return mission.role === RoleStatus.VISITOR;\r\n            }\r\n        }\r\n        return this.isRole(RoleStatus.VISITOR);\r\n    }\r\n\r\n    isMuseumUser(spaceID: string = null): boolean {\r\n        return this.isGuide(spaceID) || this.isMuseumVisitor(spaceID);\r\n    }\r\n\r\n    hasOnlyMuseumRole(): boolean {\r\n        if (this.currentMissions) {\r\n            return this.currentMissions.every(\r\n                (m) =>\r\n                    m.role === RoleStatus.GUIDE_MUSEUM ||\r\n                    m.role === RoleStatus.VISITOR_MUSEUM,\r\n            );\r\n        }\r\n        return false;\r\n    }\r\n\r\n    async profileForMail(mail: string): Promise<Profile> {\r\n        const usersWithMail = await this.profileService.getUsersForMail(mail);\r\n        return usersWithMail.length > 0 ? usersWithMail[0] : null;\r\n    }\r\n\r\n    currentOrderedOrgList(): Organisation[] {\r\n        if (!this.currentMissions) {\r\n            return [];\r\n        }\r\n        const orderedOrgList = this.currentMissions.map(\r\n            (mis) => mis.orderedOrganisation,\r\n        );\r\n        return filterUniqueArrayByID(orderedOrgList);\r\n    }\r\n\r\n    userHasAccessToAllZonesInSpace(spaceID: string): boolean {\r\n        const missionsForSpace = this.currentMissions.filter(\r\n            (mis) => mis.spaceID === spaceID,\r\n        );\r\n        return missionsForSpace.some(\r\n            (mission) =>\r\n                !mission.zoneID || (mission.zone && !mission.zone.parentID),\r\n        );\r\n    }\r\n\r\n    async logoutCurrentAndSignOutAuth() {\r\n        await this.profileService.updateProfile({\r\n            id: this.cu.id,\r\n            token: null,\r\n        });\r\n        this.cu = null;\r\n        this.currentMissions = null;\r\n        this.isChanged.next(false)\r\n        await Auth.signOut();\r\n    }\r\n\r\n    async checkAccessToken(jwtToken: string): Promise<boolean> {\r\n        const now = DateTime.local();\r\n        // console.log(\"now\", now);\r\n        // console.log(\"in one hour\", now.plus({ hours: 1 }).toMillis());\r\n        if (this.cu.token && this.cu.tokenExpiredAt > now.toMillis()) {\r\n            // check token\r\n            if (this.cu.token === jwtToken) {\r\n                console.log(\"same aws token\");\r\n                return true;\r\n            }\r\n            alert(this.translate.instant(\"auth.error.activeToken\"));\r\n            return false;\r\n        }\r\n        await this.profileService.updateProfile({\r\n            id: this.cu.id,\r\n            tokenExpiredAt: now.plus({ hours: 1 }).toMillis(),\r\n            token: jwtToken,\r\n            status: ProfileStatus.ACTIVE,\r\n        });\r\n        return true;\r\n    }\r\n\r\n    async clearUserToken(id) {\r\n        await this.profileService.updateProfile({\r\n            id: id,\r\n            token: null,\r\n        });\r\n    }\r\n\r\n    updateCurrentUser(profile: Profile) {\r\n        this.cu = new ProfileEntity(profile);\r\n        this.isChanged.next(true);\r\n    }\r\n}\r\n"]}