@smarterplan/ngx-smarterplan-core 0.3.11

package/esm2020/lib/components/support-modal/support-modal.component.mjs

@@ -0,0 +1,59 @@
+import { Component } from '@angular/core';
+import { Validators } from "@angular/forms";
+import { Auth } from "aws-amplify";
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/support.service";
+import * as i2 from "@ng-bootstrap/ng-bootstrap";
+import * as i3 from "@angular/forms";
+import * as i4 from "../../services/user.service";
+import * as i5 from "../loader/loader.component";
+import * as i6 from "@ngx-translate/core";
+import * as i7 from "@angular/common";
+export class SupportModalComponent {
+    constructor(supportService, activeModal, formBuilder, userService) {
+        this.supportService = supportService;
+        this.activeModal = activeModal;
+        this.formBuilder = formBuilder;
+        this.userService = userService;
+        this.status = 'new';
+        this.loading = true;
+    }
+    ngOnInit() {
+        this.iniForm();
+    }
+    onClose() {
+        this.activeModal.close();
+    }
+    async getCurrentUser() {
+        return new Promise(async (resolve) => {
+            try {
+                const cau = await Auth.currentAuthenticatedUser();
+                resolve(await this.userService.current(cau));
+            }
+            catch (error) {
+                resolve(undefined);
+            }
+        });
+    }
+    async iniForm() {
+        this.currentUser = await this.getCurrentUser();
+        this.supportForm = this.formBuilder.group({
+            description: ['', [Validators.required]],
+            title: ['', [Validators.required]],
+            email: [(this.currentUser ? this.currentUser.email : ''), [Validators.required, Validators.email]]
+        });
+        this.loading = false;
+    }
+    async onSubmit() {
+        this.loading = true;
+        this.status = await this.supportService.sendSupport(this.supportForm.value);
+        this.loading = false;
+    }
+}
+SupportModalComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SupportModalComponent, deps: [{ token: i1.SupportService }, { token: i2.NgbActiveModal }, { token: i3.FormBuilder }, { token: i4.BaseUserService }], target: i0.ɵɵFactoryTarget.Component });
+SupportModalComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.7", type: SupportModalComponent, selector: "app-support-modal", ngImport: i0, template: "<div class=\"modal-header\">\r\n    <h5 class=\"modal-title\" translate=\"Help\"></h5>\r\n    <!-- <button (click)=\"onClose()\" type=\"button\" class=\"btn rounded-pill btn-museum\" data-dismiss=\"modal\" aria-label=\"Close\" [title]=\"'Close'|translate\">\r\n        <span aria-hidden=\"true\">&times;</span>\r\n    </button> -->\r\n</div>\r\n<div class=\"modal-body\">\r\n    <div class=\"support-loader-container\">\r\n        <lib-loader *ngIf=\"loading\"></lib-loader>\r\n    </div>\r\n    <form (ngSubmit)=\"onSubmit()\" [formGroup]=\"supportForm\" style=\"margin-top:1rem;\" *ngIf=\"!loading && status==='new'\">\r\n        <div>\r\n            <label>{{'Title' | translate}} *</label>\r\n            <div>\r\n                <input type=\"text\" class=\"form-control\" formControlName=\"title\" data-testid=\"new-support-title\">\r\n            </div>\r\n        </div>\r\n        <div *ngIf=\"!currentUser\">\r\n            <label>{{'Email' | translate}} *</label>\r\n            <div>\r\n                <input type=\"email\" class=\"form-control\" formControlName=\"email\" data-testid=\"new-support-email\">\r\n            </div>\r\n        </div>\r\n        <div>\r\n            <label>{{'Description' | translate}} *</label>\r\n            <div>\r\n                <textarea id=\"comment-text\" name=\"comment\" formControlName=\"description\" class=\"form-control\"\r\n                    data-testid=\"new-support-comment\"></textarea>\r\n            </div>\r\n        </div>\r\n    </form>\r\n\r\n    <div *ngIf=\"status ==='send'\" translate=\"Your request has been registered\" data-testid=\"new-support-send-info\">\r\n    </div>\r\n    <div *ngIf=\"status ==='error'\" translate=\"An error has occurred, please renew your request\" data-testid=\"new-support-error-info\">\r\n\r\n    </div>\r\n</div>\r\n<div class=\"modal-footer\">\r\n    <button type=\"button\" class=\"btn rounded-pill btn-museum\" data-dismiss=\"modal\" translate=\"Close\" (click)=\"onClose()\"\r\n        data-testid=\"new-support-close-btn\"></button>\r\n    <button *ngIf=\"!loading && status==='new'\" type=\"button\" class=\"btn rounded-pill btn-museum\" translate=\"Submit\"\r\n        (click)=\"onSubmit()\" [disabled]=\"!supportForm.valid\" data-testid=\"new-support-submit-btn\"></button>\r\n</div>", styles: [".support-loader-container{width:88px;margin:auto}\n"], components: [{ type: i5.LoaderComponent, selector: "lib-loader" }], directives: [{ type: i6.TranslateDirective, selector: "[translate],[ngx-translate]", inputs: ["translate", "translateParams"] }, { type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }], pipes: { "translate": i6.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SupportModalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-support-modal', template: "<div class=\"modal-header\">\r\n    <h5 class=\"modal-title\" translate=\"Help\"></h5>\r\n    <!-- <button (click)=\"onClose()\" type=\"button\" class=\"btn rounded-pill btn-museum\" data-dismiss=\"modal\" aria-label=\"Close\" [title]=\"'Close'|translate\">\r\n        <span aria-hidden=\"true\">&times;</span>\r\n    </button> -->\r\n</div>\r\n<div class=\"modal-body\">\r\n    <div class=\"support-loader-container\">\r\n        <lib-loader *ngIf=\"loading\"></lib-loader>\r\n    </div>\r\n    <form (ngSubmit)=\"onSubmit()\" [formGroup]=\"supportForm\" style=\"margin-top:1rem;\" *ngIf=\"!loading && status==='new'\">\r\n        <div>\r\n            <label>{{'Title' | translate}} *</label>\r\n            <div>\r\n                <input type=\"text\" class=\"form-control\" formControlName=\"title\" data-testid=\"new-support-title\">\r\n            </div>\r\n        </div>\r\n        <div *ngIf=\"!currentUser\">\r\n            <label>{{'Email' | translate}} *</label>\r\n            <div>\r\n                <input type=\"email\" class=\"form-control\" formControlName=\"email\" data-testid=\"new-support-email\">\r\n            </div>\r\n        </div>\r\n        <div>\r\n            <label>{{'Description' | translate}} *</label>\r\n            <div>\r\n                <textarea id=\"comment-text\" name=\"comment\" formControlName=\"description\" class=\"form-control\"\r\n                    data-testid=\"new-support-comment\"></textarea>\r\n            </div>\r\n        </div>\r\n    </form>\r\n\r\n    <div *ngIf=\"status ==='send'\" translate=\"Your request has been registered\" data-testid=\"new-support-send-info\">\r\n    </div>\r\n    <div *ngIf=\"status ==='error'\" translate=\"An error has occurred, please renew your request\" data-testid=\"new-support-error-info\">\r\n\r\n    </div>\r\n</div>\r\n<div class=\"modal-footer\">\r\n    <button type=\"button\" class=\"btn rounded-pill btn-museum\" data-dismiss=\"modal\" translate=\"Close\" (click)=\"onClose()\"\r\n        data-testid=\"new-support-close-btn\"></button>\r\n    <button *ngIf=\"!loading && status==='new'\" type=\"button\" class=\"btn rounded-pill btn-museum\" translate=\"Submit\"\r\n        (click)=\"onSubmit()\" [disabled]=\"!supportForm.valid\" data-testid=\"new-support-submit-btn\"></button>\r\n</div>", styles: [".support-loader-container{width:88px;margin:auto}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.SupportService }, { type: i2.NgbActiveModal }, { type: i3.FormBuilder }, { type: i4.BaseUserService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"support-modal.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-smarterplan-core/src/lib/components/support-modal/support-modal.component.ts","../../../../../../projects/ngx-smarterplan-core/src/lib/components/support-modal/support-modal.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,MAAM,eAAe,CAAC;AAElD,OAAO,EAA0B,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEpE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;;;;;;;;;AAQnC,MAAM,OAAO,qBAAqB;IAShC,YACU,cAA8B,EAC/B,WAA2B,EAC1B,WAAwB,EACxB,WAA4B;QAH5B,mBAAc,GAAd,cAAc,CAAgB;QAC/B,gBAAW,GAAX,WAAW,CAAgB;QAC1B,gBAAW,GAAX,WAAW,CAAa;QACxB,gBAAW,GAAX,WAAW,CAAiB;QAZtC,WAAM,GAAG,KAAK,CAAC;QAMf,YAAO,GAAY,IAAI,CAAC;IAOpB,CAAC;IAEL,QAAQ;QACN,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;IAED,OAAO;QACL,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;IAC3B,CAAC;IAED,KAAK,CAAC,cAAc;QAClB,OAAO,IAAI,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;YACnC,IAAI;gBACF,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,wBAAwB,EAAE,CAAC;gBAClD,OAAO,CAAC,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;aAC9C;YAAC,OAAO,KAAK,EAAE;gBACd,OAAO,CAAC,SAAS,CAAC,CAAC;aACpB;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,KAAK,CAAC,OAAO;QACX,IAAI,CAAC,WAAW,GAAG,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC;QAC/C,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC;YACxC,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;YACxC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;YAClC,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;SACnG,CAAC,CAAC;QACH,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IAED,KAAK,CAAC,QAAQ;QACZ,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAC5E,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;;kHAjDU,qBAAqB;sGAArB,qBAAqB,yDCZlC,8vEA2CM;2FD/BO,qBAAqB;kBALjC,SAAS;+BACE,mBAAmB","sourcesContent":["import { Component, OnInit } from '@angular/core';\r\nimport { NgbActiveModal } from '@ng-bootstrap/ng-bootstrap';\r\nimport { FormBuilder, FormGroup, Validators } from \"@angular/forms\";\r\nimport { BaseUserService } from '../../services/user.service';\r\nimport { Auth } from \"aws-amplify\";\r\nimport { SupportService } from '../../services/support.service';\r\n\r\n@Component({\r\n  selector: 'app-support-modal',\r\n  templateUrl: './support-modal.component.html',\r\n  styleUrls: ['./support-modal.component.scss']\r\n})\r\nexport class SupportModalComponent implements OnInit {\r\n  status = 'new';\r\n\r\n  supportForm: FormGroup;\r\n\r\n  currentUser: any;\r\n\r\n  loading: boolean = true;\r\n\r\n  constructor(\r\n    private supportService: SupportService,\r\n    public activeModal: NgbActiveModal,\r\n    private formBuilder: FormBuilder,\r\n    private userService: BaseUserService,\r\n  ) { }\r\n\r\n  ngOnInit(): void {\r\n    this.iniForm();\r\n  }\r\n\r\n  onClose() {\r\n    this.activeModal.close();\r\n  }\r\n\r\n  async getCurrentUser(): Promise<any> {\r\n    return new Promise(async (resolve) => {\r\n      try {\r\n        const cau = await Auth.currentAuthenticatedUser();\r\n        resolve(await this.userService.current(cau));\r\n      } catch (error) {\r\n        resolve(undefined);\r\n      }\r\n    })\r\n  }\r\n\r\n  async iniForm() {\r\n    this.currentUser = await this.getCurrentUser();\r\n    this.supportForm = this.formBuilder.group({\r\n      description: ['', [Validators.required]],\r\n      title: ['', [Validators.required]],\r\n      email: [(this.currentUser ? this.currentUser.email : ''), [Validators.required, Validators.email]]\r\n    });\r\n    this.loading = false;\r\n  }\r\n  \r\n  async onSubmit() {\r\n    this.loading = true;\r\n    this.status = await this.supportService.sendSupport(this.supportForm.value);\r\n    this.loading = false;\r\n  }\r\n\r\n}","<div class=\"modal-header\">\r\n    <h5 class=\"modal-title\" translate=\"Help\"></h5>\r\n    <!-- <button (click)=\"onClose()\" type=\"button\" class=\"btn rounded-pill btn-museum\" data-dismiss=\"modal\" aria-label=\"Close\" [title]=\"'Close'|translate\">\r\n        <span aria-hidden=\"true\">&times;</span>\r\n    </button> -->\r\n</div>\r\n<div class=\"modal-body\">\r\n    <div class=\"support-loader-container\">\r\n        <lib-loader *ngIf=\"loading\"></lib-loader>\r\n    </div>\r\n    <form (ngSubmit)=\"onSubmit()\" [formGroup]=\"supportForm\" style=\"margin-top:1rem;\" *ngIf=\"!loading && status==='new'\">\r\n        <div>\r\n            <label>{{'Title' | translate}} *</label>\r\n            <div>\r\n                <input type=\"text\" class=\"form-control\" formControlName=\"title\" data-testid=\"new-support-title\">\r\n            </div>\r\n        </div>\r\n        <div *ngIf=\"!currentUser\">\r\n            <label>{{'Email' | translate}} *</label>\r\n            <div>\r\n                <input type=\"email\" class=\"form-control\" formControlName=\"email\" data-testid=\"new-support-email\">\r\n            </div>\r\n        </div>\r\n        <div>\r\n            <label>{{'Description' | translate}} *</label>\r\n            <div>\r\n                <textarea id=\"comment-text\" name=\"comment\" formControlName=\"description\" class=\"form-control\"\r\n                    data-testid=\"new-support-comment\"></textarea>\r\n            </div>\r\n        </div>\r\n    </form>\r\n\r\n    <div *ngIf=\"status ==='send'\" translate=\"Your request has been registered\" data-testid=\"new-support-send-info\">\r\n    </div>\r\n    <div *ngIf=\"status ==='error'\" translate=\"An error has occurred, please renew your request\" data-testid=\"new-support-error-info\">\r\n\r\n    </div>\r\n</div>\r\n<div class=\"modal-footer\">\r\n    <button type=\"button\" class=\"btn rounded-pill btn-museum\" data-dismiss=\"modal\" translate=\"Close\" (click)=\"onClose()\"\r\n        data-testid=\"new-support-close-btn\"></button>\r\n    <button *ngIf=\"!loading && status==='new'\" type=\"button\" class=\"btn rounded-pill btn-museum\" translate=\"Submit\"\r\n        (click)=\"onSubmit()\" [disabled]=\"!supportForm.valid\" data-testid=\"new-support-submit-btn\"></button>\r\n</div>"]}

package/esm2020/lib/config.mjs

@@ -0,0 +1,4 @@
+export class Config {
+    constructor() { }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXNtYXJ0ZXJwbGFuLWNvcmUvc3JjL2xpYi9jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsTUFBTSxPQUFPLE1BQU07SUFlZixnQkFBZ0IsQ0FBQztDQUNwQiIsInNvdXJjZXNDb250ZW50IjpbIlxyXG5leHBvcnQgY2xhc3MgQ29uZmlnIHtcclxuICAgIG15X2NvbmZpZzogeyBcclxuICAgICAgICBpY29uX3RpY2tldDogc3RyaW5nOyBcclxuICAgICAgICBpY29uX2VxdWlwbWVudDogc3RyaW5nO1xyXG4gICAgICAgIGljb25fbWVhc3VyZTogc3RyaW5nO1xyXG4gICAgICAgIGljb25fZGF0YTogc3RyaW5nO1xyXG4gICAgICAgIGljb25fcG9zaXRpb246IHN0cmluZztcclxuICAgICAgICBNQVhfQ0hBUkFDVEVSX0RFU0NSSVBUSU9OX1RBRzogbnVtYmVyO1xyXG4gICAgICAgIERFRkFVTFRfSEVJR0hUX0hUTUxfVEFHOiBudW1iZXI7XHJcbiAgICAgICAgREVGQVVMVF9PUEFDSVRZX1RBRzogbnVtYmVyO1xyXG4gICAgICAgIENPTERfTElNSVQ6IG51bWJlcjtcclxuICAgICAgICBIT1RfTElNSVQ6IG51bWJlcjtcclxuICAgICAgICBERUZBVUxUX1dJRFRIX0hUTUxfVEFHOiBudW1iZXI7XHJcbiAgICAgICAgTUFYX0lNQUdFX0hFSUdIVF9IVE1MX1RBRzogbnVtYmVyfTtcclxuXHJcbiAgICBjb25zdHJ1Y3RvcigpIHsgfVxyXG59XHJcbiJdfQ==

package/esm2020/lib/helpers.service.mjs

@@ -0,0 +1,468 @@
+import { ModalSwitchVisitComponent } from "./components/modal-switch-visit/modal-switch-visit.component";
+import { downloadFileAsObject } from "./services/s3.service";
+import { LevelStatus, Locale, PoiType, RoleStatus } from "./types.service";
+export function getDistanceBetweenTwoPoints(startPoint, endPoint) {
+    const dx = endPoint.x - startPoint.x;
+    const dy = endPoint.y - startPoint.y;
+    const dz = endPoint.z - startPoint.z;
+    const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    return Math.round(distance * 100) / 100;
+}
+export function poiTypeToString(type) {
+    switch (type) {
+        case PoiType.EQUIPMENT:
+            return "equipment";
+        case PoiType.TICKET:
+            return "ticket";
+        case PoiType.DATA:
+            return "data";
+        case PoiType.DESK:
+            return "data";
+        case PoiType.INFORMATION:
+            return "information";
+        case PoiType.MEASURE:
+            return "measure";
+        case PoiType.PEOPLE:
+            return "people";
+        default:
+            return "ticket";
+    }
+}
+export function wait(timeout) {
+    return new Promise((resolve) => {
+        timeout = timeout || 2000;
+        setTimeout(() => {
+            resolve();
+        }, timeout);
+    });
+}
+export const waitUntil = (condition) => {
+    return new Promise((resolve, reject) => {
+        const intervalId = setInterval(() => {
+            if (condition()) {
+                clearInterval(intervalId);
+                resolve();
+            }
+        }, 30);
+    });
+};
+export function enumToArray(enumerable) {
+    return Object.keys(enumerable)
+        .filter((value) => isNaN(Number(value)) === true)
+        .map((key) => enumerable[key]);
+}
+export function getLevelsBelow(level) {
+    const all = [
+        LevelStatus.MINIMUM,
+        LevelStatus.LOW,
+        LevelStatus.MEDIUM,
+        LevelStatus.HIGH,
+        LevelStatus.MAXIMUM,
+    ];
+    switch (level) {
+        case LevelStatus.MAXIMUM:
+            return all;
+        case LevelStatus.HIGH:
+            all.splice(4, 1);
+            return all;
+        case LevelStatus.MEDIUM:
+            all.splice(3, 2);
+            return all;
+        case LevelStatus.LOW:
+            return [LevelStatus.MINIMUM, LevelStatus.LOW];
+        case LevelStatus.MINIMUM:
+            return [LevelStatus.MINIMUM];
+        default:
+            return [LevelStatus.MINIMUM];
+    }
+}
+export function getHighestLevelForMissions(missions) {
+    let latestVisibleLevels = [LevelStatus.MINIMUM];
+    for (const m of missions) {
+        const visibleLevels = getLevelsBelow(m.level);
+        if (visibleLevels.length > latestVisibleLevels.length) {
+            latestVisibleLevels = visibleLevels;
+        }
+    }
+    switch (latestVisibleLevels.length) {
+        case 1:
+            return LevelStatus.MINIMUM;
+        case 2:
+            return LevelStatus.LOW;
+        case 3:
+            return LevelStatus.MEDIUM;
+        case 4:
+            return LevelStatus.HIGH;
+        case 5:
+            return LevelStatus.MAXIMUM;
+        default:
+            return LevelStatus.MINIMUM;
+    }
+}
+export function getHighestRoleForMissions(missions) {
+    let highestRole = RoleStatus.VISITOR;
+    for (const m of missions) {
+        if (m.role === RoleStatus.ADMIN) {
+            return RoleStatus.ADMIN;
+        }
+        if (highestRole === RoleStatus.OWNER) {
+            continue;
+        }
+        if (m.role === RoleStatus.OWNER) {
+            highestRole = RoleStatus.OWNER;
+        }
+        if (m.role === RoleStatus.MANAGER) {
+            highestRole = RoleStatus.MANAGER;
+        }
+        if (m.role === RoleStatus.SERVICE &&
+            highestRole !== RoleStatus.MANAGER) {
+            highestRole = RoleStatus.SERVICE;
+        }
+        if (m.role === RoleStatus.OCCUPANT &&
+            highestRole === RoleStatus.VISITOR) {
+            highestRole = RoleStatus.OCCUPANT;
+        }
+        if (m.role === RoleStatus.GUIDE_MUSEUM) {
+            highestRole = RoleStatus.GUIDE_MUSEUM;
+        }
+        if (m.role === RoleStatus.VISITOR_MUSEUM) {
+            highestRole = RoleStatus.VISITOR_MUSEUM;
+        }
+    }
+    return highestRole;
+}
+export function getRolesBelowForManager(role) {
+    const all = [
+        RoleStatus.VISITOR,
+        RoleStatus.OCCUPANT,
+        RoleStatus.SERVICE,
+        RoleStatus.MANAGER,
+        RoleStatus.OWNER,
+        RoleStatus.ADMIN,
+    ];
+    const museum = [RoleStatus.VISITOR_MUSEUM, RoleStatus.GUIDE_MUSEUM];
+    switch (role) {
+        case RoleStatus.ADMIN:
+            return [...all, ...museum];
+        case RoleStatus.OWNER:
+            all.splice(5, 1);
+            return all;
+        case RoleStatus.MANAGER:
+            all.splice(4, 2);
+            return all;
+        case RoleStatus.GUIDE_MUSEUM:
+            return museum;
+        default:
+            return all.splice(4, 2);
+    }
+}
+export function filterUniqueArrayByID(arrayOfObjects) {
+    return arrayOfObjects.filter((v, index, a) => a.findIndex((t) => t.id === v.id) === index);
+}
+export function removeNullKeysFromObject(object) {
+    for (const key of Object.keys(object)) {
+        if (object[key] === null) {
+            delete object[key];
+        }
+    }
+}
+/**
+ * Test if a date has expired
+ * @param date
+ * @returns true if the date has expired, false otherwise
+ */
+export function dateHasExpired(date) {
+    if (date) {
+        return new Date(date) <= new Date();
+    }
+    return false;
+}
+export function stringLocaleToEnum(locale) {
+    switch (locale) {
+        case "en":
+            return Locale.EN;
+        case "fr":
+            return Locale.FR;
+        default:
+            return Locale.EN;
+    }
+}
+export function getMetaForImage(url) {
+    return new Promise((resolve, reject) => {
+        const img = new Image();
+        img.addEventListener("load", () => {
+            resolve(img);
+        });
+        img.addEventListener("error", () => reject());
+        img.src = url;
+    });
+}
+export function sortAlphabeticallyOnName(array) {
+    return array.sort((a, b) => a.name.localeCompare(b.name));
+}
+export function validEmail(email) {
+    const re = /^(([^\s"(),.:;<>@[\\\]]+(\.[^\s"(),.:;<>@[\\\]]+)*)|(".+"))@((\[(?:\d{1,3}\.){3}\d{1,3}])|(([\dA-Za-z\-]+\.)+[A-Za-z]{2,}))$/;
+    return re.test(email);
+}
+export function downloadBlob(blob, filename) {
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = filename || "download";
+    const clickHandler = () => {
+        setTimeout(() => {
+            URL.revokeObjectURL(url);
+            a.removeEventListener("click", clickHandler);
+        }, 150);
+    };
+    a.addEventListener("click", clickHandler, false);
+    a.click();
+    return a;
+}
+/*
+    Open modal if one has to switch virtual visit
+*/
+export function openModalForVisitSwitch(modalService, model3D, spaceID, dataToMove = null) {
+    const modalReference = modalService.open(ModalSwitchVisitComponent);
+    modalReference.componentInstance.content =
+        "This object belongs to another 3D visit. Are you sure you want to switch the visit?";
+    modalReference.componentInstance.model3D = model3D;
+    modalReference.componentInstance.spaceID = spaceID;
+    if (dataToMove) {
+        modalReference.componentInstance.dataToMove = dataToMove;
+    }
+}
+/**
+ * Return a string of a given date time in local format.
+ * The format is determined by the current language.
+ */
+export function dateTimeToLocalString(date, translate, mode) {
+    let lang = "en-EN";
+    if (translate) {
+        /** Get current language */
+        lang = translate.currentLang
+            ? translate.currentLang
+            : translate.defaultLang;
+        /** Transforme '_fr' to 'fr' */
+        if (lang) {
+            lang = lang.slice(1);
+        }
+    }
+    let options;
+    switch (mode) {
+        case "day_numeric":
+            options = { day: "numeric" };
+            break;
+        case "day":
+            options = { weekday: "long" };
+            break;
+        case "date":
+            options = { dateStyle: "long" };
+            break;
+        case "short_date_time":
+            options = {
+                year: "2-digit",
+                month: "2-digit",
+                day: "2-digit",
+                hour: "2-digit",
+                minute: "2-digit",
+            };
+            break;
+        case "time":
+            options = { hour: "numeric", minute: "numeric" };
+            break;
+        case "day_time_zone":
+            options = {
+                weekday: "long",
+                year: "numeric",
+                month: "long",
+                day: "numeric",
+                hour: "numeric",
+                minute: "numeric",
+                timeZoneName: "shortOffset",
+            };
+            break;
+        default:
+            options = {
+                dateStyle: "long",
+                timeStyle: "short",
+            };
+    }
+    return new Date(date).toLocaleString(lang, options);
+}
+/**
+ * Compares two string arrays
+ * @param array1
+ * @param array2
+ * @returns
+ */
+export function arraysContainSameElements(array1, array2) {
+    return JSON.stringify(array1) === JSON.stringify(array2);
+}
+export function getVisitUrl(currentUrl) {
+    const path = currentUrl.split("/");
+    path.splice(3, path.length - 2);
+    return path.join("/");
+}
+/**
+ * Extract spaceID from url when in visit 3D
+ */
+export function getSpaceIDFromUrl(url) {
+    const visitUrl = getVisitUrl(url);
+    return visitUrl.split("/")[2];
+}
+/**
+ * Download related
+ */
+import FileSaver from "file-saver";
+export function downloadFile(fileUrl, fileName) {
+    FileSaver.saveAs(fileUrl + fileName, fileName);
+}
+export function openDocument(fileUrl, fileName, id) {
+    window.open(`${fileUrl + fileName}#doc=${id}`, "_blank", "");
+}
+export const downloadEquipmentDocument = async (document_) => {
+    const signedFile = await downloadFileAsObject(document_.url);
+    if (signedFile) {
+        // @ts-ignore
+        downloadBlob(signedFile.Body, document_.filename);
+    }
+};
+export async function checkElementById(selector) {
+    let querySelector = null;
+    while (querySelector === null) {
+        await rafAsync();
+        querySelector = document.getElementById(selector);
+    }
+    return querySelector;
+}
+function rafAsync() {
+    return new Promise((resolve) => {
+        requestAnimationFrame(resolve); // faster than set time out
+    });
+}
+/* @param {Array} numbers An array of numbers.
+ * @return {Number} The calculated average (or mean) value from the specified
+ *     numbers.
+ */
+export function mean(numbers) {
+    let total = 0;
+    for (const number of numbers) {
+        total += number;
+    }
+    return total / numbers.length;
+}
+export function convertTimestampToLocalZone(timestamp) {
+    const selectedDate = new Date(timestamp);
+    const localOffset = -1 * selectedDate.getTimezoneOffset() * 60000;
+    const stamp = timestamp + localOffset;
+    return stamp;
+}
+/**
+ * Return string for period of time. Parameters are DateTime objects of luxon library.
+ */
+export function translateDatePeriod(translateService, dateStartPeriod, dateEndPeriod) {
+    const locale = getLocaleLong(translateService);
+    return `${dateStartPeriod.toLocaleString({
+        locale,
+        month: "long",
+        day: "2-digit",
+    })} - ${dateEndPeriod.toLocaleString({
+        locale,
+        month: "long",
+        day: "2-digit",
+    })} `;
+}
+/**
+* Return local in the canonical form: "en-GB", "fr-FR"
+*/
+export function getLocaleLong(translate) {
+    let lang = translate.currentLang
+        ? translate.currentLang
+        : translate.defaultLang;
+    /** Transform '_fr' to 'fr' */
+    lang = lang.slice(1);
+    if (lang === "en") {
+        return "en-GB";
+    }
+    return `${lang}-${lang.toUpperCase()}`;
+}
+/**
+ * Return local in the short form: "en", "fr"
+ */
+export function getLocaleShort(translate) {
+    let lang = translate.currentLang
+        ? translate.currentLang
+        : translate.defaultLang;
+    /** Transform '_fr' to 'fr' */
+    lang = lang.slice(1);
+    return lang;
+}
+/**
+ * Format string to lowercase, no spaces
+ */
+export function stringToLowercaseNoSpaces(input) {
+    const words = input.toLowerCase().split(/\s+/);
+    return words.join("");
+}
+/**
+ * Test if the object === {}
+ * @param obj object {key:value}
+ * @returns boolean
+ */
+export function isEmptyObject(object) {
+    for (const x in object) {
+        return false;
+    }
+    return true;
+}
+export function shuffleArray(array) {
+    const newArray = [...array];
+    for (let index = array.length - 1; index > 0; index--) {
+        const indexNew = Math.floor(Math.random() * (index + 1));
+        // eslint-disable-next-line no-param-reassign
+        [newArray[index], newArray[indexNew]] = [
+            newArray[indexNew],
+            newArray[index],
+        ];
+    }
+    return newArray;
+}
+export function numberToDateString(timestamp) {
+    const jsDate = new Date(timestamp);
+    return jsDate.toLocaleString("fr-FR");
+}
+export function durationToString(duration, translate) {
+    const days = Math.floor(duration / 3600 / 24);
+    const hours = Math.floor((duration - days * 24 * 3600) / 3600);
+    const minutes = Math.floor((duration % 3600) / 60);
+    const seconds = Math.floor(duration % 60);
+    const daysString = translate.instant("day(s)");
+    const hoursString = translate.instant("hour(s)");
+    const oneHourString = translate.instant("hour");
+    const minutesString = translate.instant("minute(s)");
+    const secondsString = translate.instant("second(s)");
+    if (duration > 3600 * 24 * 7) {
+        return `${days} ${daysString}`;
+    }
+    if (duration > 3600 * 24) {
+        return `${days} ${daysString} ${hours} ${hoursString}`;
+    }
+    if (duration === 3600) {
+        return `${hours} ${oneHourString}`;
+    }
+    if (duration > 3600) {
+        if (minutes === 0) {
+            return `${hours} ${hoursString}`;
+        }
+        return `${hours} ${hoursString} ${minutes} ${minutesString}`;
+    }
+    if (duration >= 60) {
+        if (seconds === 0) {
+            return `${minutes} ${minutesString}`;
+        }
+        return `${minutes} ${minutesString} ${seconds} ${secondsString}`;
+    }
+    return `${seconds} ${secondsString}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.service.js","sourceRoot":"","sources":["../../../../projects/ngx-smarterplan-core/src/lib/helpers.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgbModal } from \"@ng-bootstrap/ng-bootstrap\";\r\nimport { TranslateService } from \"@ngx-translate/core\";\r\nimport { ModalSwitchVisitComponent } from \"./components/modal-switch-visit/modal-switch-visit.component\";\r\nimport { downloadFileAsObject } from \"./services/s3.service\";\r\nimport { EquipmentDocument, LevelStatus, Locale, Mission, PoiType, RoleStatus } from \"./types.service\";\r\n\r\nexport function getDistanceBetweenTwoPoints(startPoint, endPoint) {\r\n    const dx = endPoint.x - startPoint.x;\r\n    const dy = endPoint.y - startPoint.y;\r\n    const dz = endPoint.z - startPoint.z;\r\n    const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);\r\n    return Math.round(distance * 100) / 100;\r\n}\r\n\r\nexport function poiTypeToString(type: PoiType): string {\r\n    switch (type) {\r\n        case PoiType.EQUIPMENT:\r\n            return \"equipment\";\r\n        case PoiType.TICKET:\r\n            return \"ticket\";\r\n        case PoiType.DATA:\r\n            return \"data\";\r\n        case PoiType.DESK:\r\n            return \"data\";\r\n        case PoiType.INFORMATION:\r\n            return \"information\";\r\n        case PoiType.MEASURE:\r\n            return \"measure\";\r\n        case PoiType.PEOPLE:\r\n            return \"people\";\r\n        default:\r\n            return \"ticket\";\r\n    }\r\n}\r\n\r\nexport function wait(timeout: number): Promise<void> {\r\n    return new Promise((resolve) => {\r\n        timeout = timeout || 2000;\r\n        setTimeout(() => {\r\n            resolve();\r\n        }, timeout);\r\n    });\r\n}\r\n\r\nexport const waitUntil = (condition: () => boolean) => {\r\n    return new Promise<void>((resolve, reject) => {\r\n        const intervalId = setInterval(() => {\r\n            if (condition()) {\r\n                clearInterval(intervalId);\r\n                resolve();\r\n            }\r\n        }, 30);\r\n    });\r\n};\r\n\r\nexport function enumToArray(enumerable: any) {\r\n    return Object.keys(enumerable)\r\n        .filter((value) => isNaN(Number(value)) === true)\r\n        .map((key) => enumerable[key]);\r\n}\r\n\r\nexport function getLevelsBelow(level: LevelStatus): LevelStatus[] {\r\n    const all = [\r\n        LevelStatus.MINIMUM,\r\n        LevelStatus.LOW,\r\n        LevelStatus.MEDIUM,\r\n        LevelStatus.HIGH,\r\n        LevelStatus.MAXIMUM,\r\n    ];\r\n    switch (level) {\r\n        case LevelStatus.MAXIMUM:\r\n            return all;\r\n        case LevelStatus.HIGH:\r\n            all.splice(4, 1);\r\n            return all;\r\n        case LevelStatus.MEDIUM:\r\n            all.splice(3, 2);\r\n            return all;\r\n        case LevelStatus.LOW:\r\n            return [LevelStatus.MINIMUM, LevelStatus.LOW];\r\n        case LevelStatus.MINIMUM:\r\n            return [LevelStatus.MINIMUM];\r\n        default:\r\n            return [LevelStatus.MINIMUM];\r\n    }\r\n}\r\n\r\nexport function getHighestLevelForMissions(missions: Mission[]): LevelStatus {\r\n    let latestVisibleLevels = [LevelStatus.MINIMUM];\r\n    for (const m of missions) {\r\n        const visibleLevels = getLevelsBelow(m.level);\r\n        if (visibleLevels.length > latestVisibleLevels.length) {\r\n            latestVisibleLevels = visibleLevels;\r\n        }\r\n    }\r\n    switch (latestVisibleLevels.length) {\r\n        case 1:\r\n            return LevelStatus.MINIMUM;\r\n        case 2:\r\n            return LevelStatus.LOW;\r\n        case 3:\r\n            return LevelStatus.MEDIUM;\r\n        case 4:\r\n            return LevelStatus.HIGH;\r\n        case 5:\r\n            return LevelStatus.MAXIMUM;\r\n        default:\r\n            return LevelStatus.MINIMUM;\r\n    }\r\n}\r\n\r\nexport function getHighestRoleForMissions(missions: Mission[]): RoleStatus {\r\n    let highestRole = RoleStatus.VISITOR;\r\n    for (const m of missions) {\r\n        if (m.role === RoleStatus.ADMIN) {\r\n            return RoleStatus.ADMIN;\r\n        }\r\n        if (highestRole === RoleStatus.OWNER) {\r\n            continue;\r\n        }\r\n        if (m.role === RoleStatus.OWNER) {\r\n            highestRole = RoleStatus.OWNER;\r\n        }\r\n        if (m.role === RoleStatus.MANAGER) {\r\n            highestRole = RoleStatus.MANAGER;\r\n        }\r\n        if (\r\n            m.role === RoleStatus.SERVICE &&\r\n            highestRole !== RoleStatus.MANAGER\r\n        ) {\r\n            highestRole = RoleStatus.SERVICE;\r\n        }\r\n        if (\r\n            m.role === RoleStatus.OCCUPANT &&\r\n            highestRole === RoleStatus.VISITOR\r\n        ) {\r\n            highestRole = RoleStatus.OCCUPANT;\r\n        }\r\n        if (m.role === RoleStatus.GUIDE_MUSEUM) {\r\n            highestRole = RoleStatus.GUIDE_MUSEUM;\r\n        }\r\n        if (m.role === RoleStatus.VISITOR_MUSEUM) {\r\n            highestRole = RoleStatus.VISITOR_MUSEUM;\r\n        }\r\n    }\r\n    return highestRole;\r\n}\r\n\r\nexport function getRolesBelowForManager(role: RoleStatus): RoleStatus[] {\r\n    const all = [\r\n        RoleStatus.VISITOR,\r\n        RoleStatus.OCCUPANT,\r\n        RoleStatus.SERVICE,\r\n        RoleStatus.MANAGER,\r\n        RoleStatus.OWNER,\r\n        RoleStatus.ADMIN,\r\n    ];\r\n    const museum = [RoleStatus.VISITOR_MUSEUM, RoleStatus.GUIDE_MUSEUM];\r\n    switch (role) {\r\n        case RoleStatus.ADMIN:\r\n            return [...all, ...museum];\r\n        case RoleStatus.OWNER:\r\n            all.splice(5, 1);\r\n            return all;\r\n        case RoleStatus.MANAGER:\r\n            all.splice(4, 2);\r\n            return all;\r\n        case RoleStatus.GUIDE_MUSEUM:\r\n            return museum;\r\n        default:\r\n            return all.splice(4, 2);\r\n    }\r\n}\r\n\r\nexport function filterUniqueArrayByID(arrayOfObjects: any[]): any[] {\r\n    return arrayOfObjects.filter(\r\n        (v, index, a) => a.findIndex((t) => t.id === v.id) === index,\r\n    );\r\n}\r\n\r\nexport function removeNullKeysFromObject(object: Object) {\r\n    for (const key of Object.keys(object)) {\r\n        if (object[key] === null) {\r\n            delete object[key];\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Test if a date has expired\r\n * @param date\r\n * @returns true if the date has expired, false otherwise\r\n */\r\n export function dateHasExpired(\r\n    date: string | Date | number | null | undefined,\r\n): boolean {\r\n    if (date) {\r\n        return new Date(date) <= new Date();\r\n    }\r\n    return false;\r\n}\r\n\r\nexport function stringLocaleToEnum(locale: string): Locale {\r\n    switch (locale) {\r\n        case \"en\":\r\n            return Locale.EN;\r\n        case \"fr\":\r\n            return Locale.FR;\r\n        default:\r\n            return Locale.EN;\r\n    }\r\n}\r\n\r\n\r\nexport function getMetaForImage(url): Promise<any> {\r\n    return new Promise((resolve, reject) => {\r\n        const img = new Image();\r\n\r\n        img.addEventListener(\"load\", () => {\r\n            resolve(img);\r\n        });\r\n        img.addEventListener(\"error\", () => reject());\r\n        img.src = url;\r\n    });\r\n}\r\n\r\nexport function sortAlphabeticallyOnName(array: { name: string }[]): any[] {\r\n    return array.sort((a, b) => a.name.localeCompare(b.name));\r\n}\r\n\r\nexport function validEmail(email: string) {\r\n    const re =\r\n        /^(([^\\s\"(),.:;<>@[\\\\\\]]+(\\.[^\\s\"(),.:;<>@[\\\\\\]]+)*)|(\".+\"))@((\\[(?:\\d{1,3}\\.){3}\\d{1,3}])|(([\\dA-Za-z\\-]+\\.)+[A-Za-z]{2,}))$/;\r\n    return re.test(email);\r\n}\r\n\r\nexport function downloadBlob(blob, filename) {\r\n    const url = URL.createObjectURL(blob);\r\n    const a = document.createElement(\"a\");\r\n    a.href = url;\r\n    a.download = filename || \"download\";\r\n    const clickHandler = () => {\r\n        setTimeout(() => {\r\n            URL.revokeObjectURL(url);\r\n            a.removeEventListener(\"click\", clickHandler);\r\n        }, 150);\r\n    };\r\n    a.addEventListener(\"click\", clickHandler, false);\r\n    a.click();\r\n    return a;\r\n}\r\n\r\n/*\r\n    Open modal if one has to switch virtual visit\r\n*/\r\nexport function openModalForVisitSwitch(\r\n    modalService: NgbModal,\r\n    model3D: string,\r\n    spaceID: string,\r\n    dataToMove: {sweepToMove:string, rotation:any} | null = null\r\n) {\r\n    const modalReference = modalService.open(ModalSwitchVisitComponent);\r\n    modalReference.componentInstance.content =\r\n        \"This object belongs to another 3D visit. Are you sure you want to switch the visit?\";\r\n    modalReference.componentInstance.model3D = model3D;\r\n    modalReference.componentInstance.spaceID = spaceID;\r\n    if (dataToMove) {\r\n        modalReference.componentInstance.dataToMove = dataToMove;\r\n    }\r\n    \r\n}\r\n\r\n/**\r\n * Return a string of a given date time in local format.\r\n * The format is determined by the current language.\r\n */\r\n export function dateTimeToLocalString(\r\n    date: number | string | Date,\r\n    translate?: TranslateService,\r\n    mode?,\r\n): string {\r\n    let lang = \"en-EN\";\r\n    if (translate) {\r\n        /** Get current language */\r\n        lang = translate.currentLang\r\n            ? translate.currentLang\r\n            : translate.defaultLang;\r\n        /** Transforme '_fr' to 'fr' */\r\n        if (lang) {\r\n            lang = lang.slice(1);\r\n        }\r\n       \r\n    }\r\n\r\n    let options: {\r\n        month?;\r\n        year?;\r\n        day?;\r\n        hour?;\r\n        minute?;\r\n        second?;\r\n        dateStyle?;\r\n        timeStyle?;\r\n        weekday?;\r\n        timeZone?;\r\n        timeZoneName?;\r\n    };\r\n    switch (mode) {\r\n        case \"day_numeric\":\r\n            options = { day: \"numeric\" };\r\n            break;\r\n        case \"day\":\r\n            options = { weekday: \"long\" };\r\n            break;\r\n        case \"date\":\r\n            options = { dateStyle: \"long\" };\r\n            break;\r\n        case \"short_date_time\":\r\n            options = {\r\n                year: \"2-digit\",\r\n                month: \"2-digit\",\r\n                day: \"2-digit\",\r\n                hour: \"2-digit\",\r\n                minute: \"2-digit\",\r\n            };\r\n            break;\r\n        case \"time\":\r\n            options = { hour: \"numeric\", minute: \"numeric\" };\r\n            break;\r\n        case \"day_time_zone\":\r\n            options = {\r\n                weekday: \"long\",\r\n                year: \"numeric\",\r\n                month: \"long\",\r\n                day: \"numeric\",\r\n                hour: \"numeric\",\r\n                minute: \"numeric\",\r\n                timeZoneName: \"shortOffset\",\r\n            };\r\n            break;\r\n        default:\r\n            options = {\r\n                dateStyle: \"long\",\r\n                timeStyle: \"short\",\r\n            };\r\n    }\r\n    return new Date(date).toLocaleString(lang, options);\r\n}\r\n\r\n/**\r\n * Compares two string arrays\r\n * @param array1\r\n * @param array2\r\n * @returns\r\n */\r\n export function arraysContainSameElements(\r\n    array1: string[],\r\n    array2: string[],\r\n): boolean {\r\n    return JSON.stringify(array1) === JSON.stringify(array2);\r\n}\r\n\r\n\r\nexport function getVisitUrl(currentUrl: string): string {\r\n    const path = currentUrl.split(\"/\");\r\n    path.splice(3, path.length - 2);\r\n    return path.join(\"/\");\r\n}\r\n\r\n/**\r\n * Extract spaceID from url when in visit 3D\r\n */\r\n export function getSpaceIDFromUrl(url: string): string {\r\n    const visitUrl = getVisitUrl(url);\r\n    return visitUrl.split(\"/\")[2];\r\n}\r\n\r\n/**\r\n * Download related\r\n */\r\n import FileSaver from \"file-saver\";\r\n\r\n export function downloadFile(fileUrl: string, fileName: string) {\r\n     FileSaver.saveAs(fileUrl + fileName, fileName);\r\n }\r\n \r\n export function openDocument(fileUrl: string, fileName: string, id: number) {\r\n     window.open(`${fileUrl + fileName}#doc=${id}`, \"_blank\", \"\");\r\n }\r\n \r\n export const downloadEquipmentDocument = async (\r\n     document_: EquipmentDocument,\r\n ): Promise<Object | void> => {\r\n     const signedFile = await downloadFileAsObject(document_.url);\r\n     if (signedFile) {\r\n         // @ts-ignore\r\n         downloadBlob(signedFile.Body, document_.filename);\r\n     }\r\n };\r\n\r\n export async function checkElementById(selector) {\r\n    let querySelector = null;\r\n    while (querySelector === null) {\r\n        await rafAsync();\r\n        querySelector = document.getElementById(selector);\r\n    }\r\n    return querySelector;\r\n}\r\n\r\nfunction rafAsync() {\r\n    return new Promise((resolve) => {\r\n        requestAnimationFrame(resolve); // faster than set time out\r\n    });\r\n}\r\n\r\n/* @param {Array} numbers An array of numbers.\r\n * @return {Number} The calculated average (or mean) value from the specified\r\n *     numbers.\r\n */\r\nexport function mean(numbers: number[]) {\r\n    let total = 0;\r\n    for (const number of numbers) {\r\n        total += number;\r\n    }\r\n    return total / numbers.length;\r\n}\r\n\r\nexport function convertTimestampToLocalZone(timestamp: number): number {\r\n    const selectedDate = new Date(timestamp);\r\n    const localOffset = -1 * selectedDate.getTimezoneOffset() * 60000;\r\n    const stamp = timestamp + localOffset;\r\n    return stamp;\r\n}\r\n\r\n/**\r\n * Return string for period of time. Parameters are DateTime objects of luxon library.\r\n */\r\n export function translateDatePeriod(\r\n    translateService: any,\r\n    dateStartPeriod: any,\r\n    dateEndPeriod: any,\r\n): string {\r\n    const locale = getLocaleLong(translateService);\r\n    return `${dateStartPeriod.toLocaleString({\r\n        locale,\r\n        month: \"long\",\r\n        day: \"2-digit\",\r\n    })} - ${dateEndPeriod.toLocaleString({\r\n        locale,\r\n        month: \"long\",\r\n        day: \"2-digit\",\r\n    })} `;\r\n}\r\n\r\n\r\n/**\r\n* Return local in the canonical form: \"en-GB\", \"fr-FR\"\r\n*/\r\nexport function getLocaleLong(translate: TranslateService): string {\r\n    let lang = translate.currentLang\r\n        ? translate.currentLang\r\n        : translate.defaultLang;\r\n\r\n    /** Transform '_fr' to 'fr' */\r\n    lang = lang.slice(1);\r\n    if (lang === \"en\") {\r\n        return \"en-GB\";\r\n    }\r\n    return `${lang}-${lang.toUpperCase()}`;\r\n}\r\n\r\n/**\r\n * Return local in the short form: \"en\", \"fr\"\r\n */\r\n export function getLocaleShort(translate: TranslateService): string {\r\n    let lang = translate.currentLang\r\n        ? translate.currentLang\r\n        : translate.defaultLang;\r\n\r\n    /** Transform '_fr' to 'fr' */\r\n    lang = lang.slice(1);\r\n    return lang;\r\n}\r\n\r\n/**\r\n * Format string to lowercase, no spaces\r\n */\r\n export function stringToLowercaseNoSpaces(input: string): string {\r\n    const words = input.toLowerCase().split(/\\s+/);\r\n    return words.join(\"\");\r\n}\r\n\r\n/**\r\n * Test if the object === {}\r\n * @param obj object {key:value}\r\n * @returns boolean\r\n */\r\n export function isEmptyObject(object): boolean {\r\n    for (const x in object) {\r\n        return false;\r\n    }\r\n    return true;\r\n}\r\n\r\nexport function shuffleArray(array: any[]) {\r\n    const newArray = [...array];\r\n    for (let index = array.length - 1; index > 0; index--) {\r\n        const indexNew = Math.floor(Math.random() * (index + 1));\r\n        // eslint-disable-next-line no-param-reassign\r\n        [newArray[index], newArray[indexNew]] = [\r\n            newArray[indexNew],\r\n            newArray[index],\r\n        ];\r\n    }\r\n    return newArray;\r\n}\r\n\r\nexport function numberToDateString(timestamp: number): string {\r\n    const jsDate = new Date(timestamp);\r\n    return jsDate.toLocaleString(\"fr-FR\");\r\n}\r\n\r\nexport function durationToString(\r\n    duration: number,\r\n    translate: TranslateService,\r\n): string {\r\n    const days = Math.floor(duration / 3600 / 24);\r\n    const hours = Math.floor((duration - days * 24 * 3600) / 3600);\r\n    const minutes = Math.floor((duration % 3600) / 60);\r\n    const seconds = Math.floor(duration % 60);\r\n\r\n    const daysString = translate.instant(\"day(s)\");\r\n    const hoursString = translate.instant(\"hour(s)\");\r\n    const oneHourString = translate.instant(\"hour\");\r\n    const minutesString = translate.instant(\"minute(s)\");\r\n    const secondsString = translate.instant(\"second(s)\");\r\n\r\n    if (duration > 3600 * 24 * 7) {\r\n        return `${days} ${daysString}`;\r\n    }\r\n    if (duration > 3600 * 24) {\r\n        return `${days} ${daysString} ${hours} ${hoursString}`;\r\n    }\r\n    if (duration === 3600) {\r\n        return `${hours} ${oneHourString}`;\r\n    }\r\n    if (duration > 3600) {\r\n        if (minutes === 0) {\r\n            return `${hours} ${hoursString}`;\r\n        }\r\n        return `${hours} ${hoursString} ${minutes} ${minutesString}`;\r\n    }\r\n    if (duration >= 60) {\r\n        if (seconds === 0) {\r\n            return `${minutes} ${minutesString}`;\r\n        }\r\n        return `${minutes} ${minutesString} ${seconds} ${secondsString}`;\r\n    }\r\n    return `${seconds} ${secondsString}`;\r\n}\r\n"]}