@doolehealth/service-lib 0.0.1

package/esm2022/lib/services/authentication.service.mjs

@@ -0,0 +1,400 @@
+import { Inject, Injectable, PLATFORM_ID, ViewChild } from '@angular/core';
+import { Preferences } from '@capacitor/preferences';
+import { map, tap } from 'rxjs/operators';
+import { BehaviorSubject } from 'rxjs';
+import { HttpErrorResponse } from '@angular/common/http';
+import { RouterOutlet } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+import { Capacitor } from '@capacitor/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./token.service";
+import * as i3 from "../services/api-endpoints.service";
+import * as i4 from "@ionic/angular";
+import * as i5 from "@angular/fire/compat/auth";
+import * as i6 from "@angular/router";
+import * as i7 from "./change-endpoints.service";
+const TOKEN_KEY = 'token';
+const INTRO_KEY = 'intro';
+const TOKENS = 'tokens';
+const TWO_FACTOR_CENTER = 'two-factor-center';
+export class User {
+    constructor(idUser, secret, name, first_name, image) {
+        this.roles = [];
+        this.listFamilyUnit = [];
+        this.idUser = idUser;
+        this.secret = secret;
+        this.name = name;
+        this.first_name = first_name;
+        this.image = image;
+    }
+    ;
+}
+export class AuthenticationService {
+    constructor(platformId, http, tokenService, api, platform, firebaseAuth, router, alertController, injector, endpoints) {
+        this.platformId = platformId;
+        this.http = http;
+        this.tokenService = tokenService;
+        this.api = api;
+        this.platform = platform;
+        this.firebaseAuth = firebaseAuth;
+        this.router = router;
+        this.alertController = alertController;
+        this.injector = injector;
+        this.endpoints = endpoints;
+        this.isAuthenticated = new BehaviorSubject(false);
+        this.isRecovery = false;
+        this.agendaUser = [];
+        this.tokens = [];
+        this.showingSignInAlert = false;
+        this.setUser();
+    }
+    getIndexEndPoint() {
+        this.indexEndPoint = Number(localStorage.getItem('endpoint'));
+        console.log("[AuthService] indexEndPoint: ", this.indexEndPoint);
+    }
+    getAuthToken() {
+        const token = this.tokenService.getAuthToken();
+        //console.log("[AuthService] getAuthToken: ", token);
+        return token;
+    }
+    setAuthToken(token) {
+        this.tokenService.setAuthToken(token);
+    }
+    // getAuthToken() {
+    //   const token = localStorage.getItem(TOKEN_KEY);
+    //   return token;
+    // }
+    // setAuthToken(token) {
+    //   localStorage.setItem(TOKEN_KEY, token);
+    // }
+    login(credentials) {
+        const endpoint = this.api.getEndpoint('patient/login');
+        console.log('credentials: ', credentials);
+        return this.http.post(endpoint, credentials).pipe(map((res) => {
+            console.log("[AuthService] login() OK ");
+            console.log("[AuthService] endpoint", endpoint);
+            if (!res.success) {
+                return res;
+            }
+            // save user's token
+            if (res.token) {
+                this.tokenService.setAuthToken(res.token);
+                this.setAuthToken(res.token);
+            }
+            // Set indexEndPoint ios_dev if it is QA
+            this.getIndexEndPoint();
+            if (Capacitor.isNativePlatform()) {
+                //console.log(data);
+                let access = true;
+                if (this.deviceToken && this.devicePlatform)
+                    this.registerDevice(this.deviceToken, this.devicePlatform);
+                if (this.platform.is('ios')) {
+                    if (this.voipDeviceToken)
+                        this.registerDevice(this.voipDeviceToken, this.endpoints._ENVIROMENT.device_ios.ios_voip);
+                    //this.registerDevice(this.voipDeviceToken, (this.indexEndPoint!==0)?'iosvoipdev':'iosvoip');
+                }
+            }
+            this.user = new User(res.idUser, credentials.password, res.name, res.first_name, res.temporary_url);
+            this.id_user = res.idUser;
+            this.setUserLocalstorage(this.user);
+            this.setTwoFactor(res.twoFactorCenter);
+            if (res?.familyUnit.length > 0) {
+                this.user.listFamilyUnit = res.familyUnit;
+            }
+            return res;
+        }), tap(_ => {
+            this.isAuthenticated.next(true);
+        }));
+    }
+    setUser() {
+        if (!this.user) {
+            this.getUserLocalstorage().then(user => {
+                console.log("[AuthenticationService] setUser()", user);
+                if (user)
+                    this.user = user;
+            });
+        }
+    }
+    setUserLocalstorage(user) {
+        console.log(`[AuthenticationService] setUserLocalstorage()`, user);
+        Preferences.set({
+            key: 'user',
+            value: JSON.stringify(user)
+        });
+    }
+    setFamilyUnitLocalstorage(familyUnit) {
+        familyUnit.forEach(member => {
+            let s = member['name'];
+            let fullname = s.split(',');
+            let u = new User(member['id'], '', fullname[1], fullname[0], member['thumbnail']);
+            console.log("familyUnit Local:", u);
+            Preferences.set({
+                key: String(u.idUser),
+                value: JSON.stringify(u)
+            });
+        });
+    }
+    getFamilyUnitLocalstorage(id) {
+        return Preferences.get({ key: id }).then((val) => {
+            console.log(`[AuthenticationService] getFamilyUnitLocalstorage(${id})`, val);
+            return JSON.parse(val.value);
+        });
+    }
+    async setFamilyUnit(user) {
+        this.isFamily = true;
+        let s = user['name'];
+        let fullname = s.split(',');
+        this.user = new User(user.id, '', fullname[0].replace(',', ''), fullname[1], user.thumbnail);
+        this.user.familyUnit = user.id;
+        Preferences.set({
+            key: String(user.id),
+            value: JSON.stringify(this.user)
+        });
+    }
+    getUserLocalstorage() {
+        return Preferences.get({ key: 'user' }).then((val) => {
+            return JSON.parse(val.value);
+        });
+    }
+    async setUserFamilyId(id) {
+        await this.getUserLocalstorage().then(user => {
+            console.log(`[AuthenticationService] MEMBER(${id})`, user);
+            let s = user['name'];
+            let fullname = s.split(',');
+            this.user = new User(user['idUser'], '', fullname[0].replace(',', ''), fullname[1], user['image']);
+            this.user.familyUnit = id;
+            this.setUserLocalstorage(this.user);
+        });
+    }
+    getShowIntroLocalstorage() {
+        return Preferences.get({ key: 'showIntro' }).then((val) => {
+            return Boolean(val.value);
+        });
+    }
+    async setShowIntroLocalstorage() {
+        await Preferences.set({
+            key: 'showIntro',
+            value: 'true'
+        });
+    }
+    setTwoFactor(tfCenter) {
+        localStorage.setItem('two-factor-center', tfCenter);
+    }
+    async logout1() {
+        console.log('logout');
+        this.isAuthenticated.next(false);
+        const enviroment = this.endpoints._ENVIROMENT;
+        //localStorage.removeItem(enviroment?.registered_user)
+        await Preferences.remove({ key: 'user' }).then((val) => { });
+        return Preferences.remove({ key: TOKEN_KEY });
+    }
+    logout(allDevices) {
+        this.getAllTokenDevices();
+        let params = {
+            tokens: this.tokens,
+            allDevices: allDevices ? allDevices : false
+        };
+        console.log('logout', params);
+        let path = 'patient/logout';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            console.log(`[AuthenticationService] logout(${path}) res: `, JSON.stringify(res));
+            this.isAuthenticated.next(false);
+            const enviroment = this.endpoints._ENVIROMENT;
+            //localStorage.removeItem(enviroment?.registered_user)
+            Preferences.remove({ key: 'user' }).then((val) => { });
+            Preferences.remove({ key: TOKEN_KEY });
+            return res;
+        }));
+    }
+    getAllTokenDevices() {
+        let list = JSON.parse(localStorage.getItem(TOKENS));
+        this.tokens = list ? list : [];
+    }
+    increaseNumloginFailed() {
+        let numFailLogin = 0;
+        let num = localStorage.getItem('num-fail-login');
+        if (num) {
+            let numFailLogin = Number(JSON.parse(num)) + 1;
+            localStorage.setItem('num-fail-login', '' + numFailLogin);
+            localStorage.setItem('login_request_locked_at', '' + (new Date().getTime()));
+        }
+        else {
+            localStorage.setItem('num-fail-login', '1');
+            localStorage.setItem('login_request_locked_at', '' + (new Date().getTime()));
+            numFailLogin = 1;
+        }
+        console.log('[AuthenticationService] increaseNumloginFailed()', numFailLogin);
+    }
+    increaseNumFPAIOFailed() {
+        let num = localStorage.getItem('num-fail-finger-print');
+        if (num) {
+            localStorage.setItem('num-fail-login', '' + (Number(JSON.parse(num)) + 1));
+            localStorage.setItem('login_request_locked_at', '' + (new Date().getTime()));
+        }
+        else {
+            localStorage.setItem('num-fail-login', '1');
+            localStorage.setItem('login_request_locked_at', '' + (new Date().getTime()));
+        }
+    }
+    getNumloginFailed() {
+        let num = localStorage.getItem('num-fail-login');
+        if (num)
+            return Number(JSON.parse(num));
+        return 0;
+    }
+    getDateloginFailed() {
+        let num = localStorage.getItem('login_request_locked_at');
+        if (num)
+            return Number(JSON.parse(num));
+        return 0;
+    }
+    getNumFingerPrinterFailed() {
+        let num = localStorage.getItem('num-fail-finger-print');
+        if (num)
+            return Number(JSON.parse(num));
+        return 0;
+    }
+    removeNumloginFailed() {
+        localStorage.removeItem('num-fail-login');
+        localStorage.removeItem('login_request_locked_at');
+    }
+    removeNumFirgerPFailed() {
+        localStorage.removeItem('num-fail-finger-print');
+        localStorage.removeItem('login_request_locked_at');
+    }
+    get(endpt) {
+        const endpoint = this.api.getEndpoint(endpt);
+        return this.http.get(endpoint).pipe(map((res) => {
+            return res;
+        }));
+    }
+    post(endpt, items) {
+        const endpoint = this.api.getEndpoint(endpt);
+        return this.http.post(endpoint, items).pipe(map((res) => {
+            return res;
+        }));
+    }
+    throwError(error) {
+        if (error instanceof HttpErrorResponse)
+            throw new HttpErrorResponse(error);
+        else
+            throw new Error(error);
+    }
+    registerDevice(token, platform) {
+        console.log("response IOSDEV", platform);
+        if (platform == 'FCM')
+            platform = 'android';
+        if (platform == 'APNS')
+            platform = this.endpoints._ENVIROMENT.device_ios.ios_push;
+        if (platform == 'ios')
+            platform = this.endpoints._ENVIROMENT.device_ios.ios_push;
+        const postData = {
+            token: token,
+            platform: platform
+        };
+        console.log("postData: ", postData);
+        return this.post('user/device/register', postData).subscribe(async (data) => {
+            let response = data;
+            console.log("response user/device/register");
+            console.log(response);
+            this.saveAllTokenDevices(postData);
+            return response;
+        }, (error) => {
+            // Called when error
+            console.log('error user/device/register: ', error);
+            throw error;
+        });
+    }
+    saveAllTokenDevices(token) {
+        this.tokens.push(token);
+        localStorage.setItem(TOKENS, JSON.stringify(this.tokens));
+    }
+    async showIntro() {
+        return Preferences.get({ key: INTRO_KEY }).then(async (data) => {
+            let showIntro = Boolean(data.value);
+            console.log(`[AuthService] showIntro()`, showIntro);
+            return showIntro;
+        });
+    }
+    postAPIbiometric(params) {
+        let path = `user/biometric`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            console.log(`[DooleService] postAPIbiometric(${path}) res: `, res);
+            return res;
+        }));
+    }
+    putAPIbiometric(id, params) {
+        let path = `user/biometric/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.put(endpoint, params).pipe(map((res) => {
+            console.log(`[DooleService] putAPIbiometric(${path}) res: `, res);
+            return res;
+        }));
+    }
+    deleteAPIbiometric(id) {
+        let path = `user/biometric/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.delete(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] deleteAPIbiometric(${path}) res: ${res}`, JSON.stringify(res));
+            return res;
+        }));
+    }
+    redirectLogin() {
+        this.router.navigateByUrl('/landing');
+    }
+    async redirectUnauthenticated() {
+        const translateService = this.injector.get(TranslateService);
+        const alert = await this.alertController.create({
+            cssClass: "alertClass",
+            header: translateService.instant('info.title'),
+            backdropDismiss: false,
+            // subHeader: 'Subtitle',
+            message: translateService.instant('landing.login_again'),
+            buttons: [
+                { text: translateService.instant('button.accept'),
+                    handler: () => {
+                        this.router.navigateByUrl(`/landing`);
+                    }
+                }
+            ]
+        });
+        await alert.present();
+    }
+    getShowGoogleFitLocalstorage() {
+        return Preferences.get({ key: 'showGoogleFit' }).then((val) => {
+            return Boolean(val.value);
+        });
+    }
+    async setShowGoogleFitLocalstorage() {
+        await Preferences.set({
+            key: 'showGoogleFit',
+            value: 'true'
+        });
+    }
+    setCanceledGoogleFitLocalstorage(mostrar) {
+        localStorage.setItem('cancelGoogleFit', mostrar);
+    }
+    getCanceledGoogleFitLocalstorage() {
+        const value = localStorage.getItem('cancelGoogleFit');
+        console.log("Booelan: ", value);
+        return value !== null ? JSON.parse(value) : false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: AuthenticationService, deps: [{ token: PLATFORM_ID }, { token: i1.HttpClient }, { token: i2.TokenService }, { token: i3.ApiEndpointsService }, { token: i4.Platform }, { token: i5.AngularFireAuth }, { token: i6.Router }, { token: i4.AlertController }, { token: i0.Injector }, { token: i7.ChangeEndpointsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: AuthenticationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: AuthenticationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i1.HttpClient }, { type: i2.TokenService }, { type: i3.ApiEndpointsService }, { type: i4.Platform }, { type: i5.AngularFireAuth }, { type: i6.Router }, { type: i4.AlertController }, { type: i0.Injector }, { type: i7.ChangeEndpointsService }], propDecorators: { outlet: [{
+                type: ViewChild,
+                args: [RouterOutlet]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authentication.service.js","sourceRoot":"","sources":["../../../../../projects/service-lib/src/lib/services/authentication.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Injector, PLATFORM_ID, ViewChild } from '@angular/core';\nimport { Preferences } from '@capacitor/preferences';\nimport { map, tap } from 'rxjs/operators';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { ApiEndpointsService } from '../services/api-endpoints.service';\nimport { HttpClient, HttpErrorResponse } from '@angular/common/http';\nimport { AlertController, Platform } from '@ionic/angular';\nimport { AngularFireAuth } from \"@angular/fire/compat/auth\";\nimport { Router, RouterOutlet } from '@angular/router';\nimport { FamilyUnit } from '../models/user';\nimport { TranslateService } from '@ngx-translate/core';\nimport { TokenService } from './token.service';\nimport { Capacitor } from '@capacitor/core';\nimport { ChangeEndpointsService } from './change-endpoints.service';\n\nconst TOKEN_KEY = 'token';\nconst INTRO_KEY = 'intro';\nconst TOKENS = 'tokens';\nconst TWO_FACTOR_CENTER = 'two-factor-center';\n\nexport class User {\n  condicion_legal?: boolean;\n  image: any;\n  idPatient?: string;\n  idUser: string;\n  first_name: string;\n  secret: string;\n  roles: any = [];\n  familyUnit?: string;\n  name: string;\n  listFamilyUnit: FamilyUnit[] = [];\n  constructor(idUser: string, secret: string, name: string, first_name: string, image: string) {\n    this.idUser = idUser\n    this.secret = secret\n    this.name = name\n    this.first_name = first_name\n    this.image = image\n  };\n\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class AuthenticationService {\n  isAuthenticated: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\n  public user?: User;\n  public isRecovery: boolean = false;\n  public action?: string;\n  public id_user?: string;\n  public data?: Array<any>;\n  public email?: string;\n  public agendaUser = [];\n  public tiene_email?: boolean;\n  public deviceToken?: string;\n  public devicePlatform?: string;\n  public voipDeviceToken?: string;\n  public voipDevicePlatform?: string;\n  public dietsAndAdvices?: [];\n  public isFamily?:boolean;\n  public version_app?:string;\n  private indexEndPoint?: number;\n  private tokens = []\n  showingSignInAlert: boolean = false;\n  @ViewChild(RouterOutlet) outlet?: RouterOutlet;\n  constructor(\n    @Inject(PLATFORM_ID) private platformId: object,\n    private http: HttpClient,\n    private tokenService: TokenService,\n    private api: ApiEndpointsService,\n    public platform: Platform,\n    public firebaseAuth: AngularFireAuth,\n    public router: Router,\n    public alertController: AlertController,\n    private injector: Injector,\n    private endpoints: ChangeEndpointsService,) {\n      this.setUser();\n  }\n\n  getIndexEndPoint(){\n    this.indexEndPoint = Number(localStorage.getItem('endpoint'))\n    console.log(\"[AuthService] indexEndPoint: \", this.indexEndPoint);\n  }\n\n  getAuthToken() {\n    const token =  this.tokenService.getAuthToken()\n    //console.log(\"[AuthService] getAuthToken: \", token);\n    return token;\n  }\n\n  setAuthToken(token : any) {\n    this.tokenService.setAuthToken(token)\n  }\n\n  // getAuthToken() {\n  //   const token = localStorage.getItem(TOKEN_KEY);\n  //   return token;\n  // }\n\n  // setAuthToken(token) {\n  //   localStorage.setItem(TOKEN_KEY, token);\n  // }\n\n  login(credentials: { username, password, hash }): Observable<any> {\n    const endpoint = this.api.getEndpoint('patient/login');\n\n    console.log('credentials: ', credentials);\n    return this.http.post(endpoint, credentials).pipe(\n      map((res: any) => {\n\n        console.log(\"[AuthService] login() OK \");\n        console.log(\"[AuthService] endpoint\", endpoint);\n        if (!res.success) {\n          return res\n        }\n        // save user's token\n        if (res.token){\n          this.tokenService.setAuthToken(res.token);\n          this.setAuthToken(res.token);\n        }\n\n        // Set indexEndPoint ios_dev if it is QA\n          this.getIndexEndPoint()\n            if (Capacitor.isNativePlatform()) {\n              //console.log(data);\n              let access = true;\n              if(this.deviceToken && this.devicePlatform)\n                this.registerDevice(this.deviceToken, this.devicePlatform);\n\n              if (this.platform.is('ios')){\n                if(this.voipDeviceToken)\n                this.registerDevice(this.voipDeviceToken, this.endpoints._ENVIROMENT.device_ios.ios_voip);\n                //this.registerDevice(this.voipDeviceToken, (this.indexEndPoint!==0)?'iosvoipdev':'iosvoip');\n              }\n\n            }\n\n        this.user = new User(res.idUser, credentials.password, res.name, res.first_name, res.temporary_url);\n        \n        this.id_user = res.idUser;\n        this.setUserLocalstorage(this.user)\n        this.setTwoFactor(res.twoFactorCenter)\n        if (res?.familyUnit.length > 0) {\n          this.user.listFamilyUnit = res.familyUnit;\n        }\n\n        return res;\n\n      }),\n      tap(_ => {\n        this.isAuthenticated.next(true);\n      }),\n    );\n  }\n\n  setUser() {\n    if (!this.user) {\n      this.getUserLocalstorage().then(user => {\n        console.log(\"[AuthenticationService] setUser()\", user);\n        if (user)\n          this.user = user\n      })\n    }\n\n  }\n\n  setUserLocalstorage(user: any) {\n    console.log(`[AuthenticationService] setUserLocalstorage()`, user);\n    Preferences.set({\n      key: 'user',\n      value: JSON.stringify(user)\n    });\n\n  }\n\n  setFamilyUnitLocalstorage(familyUnit: []) {\n\n\n    familyUnit.forEach(member => {\n      let s: string = member['name'];\n      let fullname = s.split(',');\n      let u = new User(member['id'], '', fullname[1], fullname[0], member['thumbnail']);\n      console.log(\"familyUnit Local:\", u);\n      Preferences.set({\n        key: String(u.idUser),\n        value: JSON.stringify(u)\n      });\n    })\n  }\n\n  getFamilyUnitLocalstorage(id: any): Promise<User> {\n    return Preferences.get({ key: id }).then((val) => {\n      console.log(`[AuthenticationService] getFamilyUnitLocalstorage(${id})`, val);\n      return JSON.parse(val.value);\n    });\n  }\n\n  public async setFamilyUnit(user: any) {\n    this.isFamily = true;\n    let s: string = user['name'];\n    let fullname = s.split(',');\n    this.user = new User(user.id, '', fullname[0].replace(',',''), fullname[1], user.thumbnail);\n    this.user.familyUnit = user.id;\n    Preferences.set({\n      key: String(user.id),\n      value: JSON.stringify(this.user)\n    });\n\n\n  }\n\n  getUserLocalstorage(): Promise<User> {\n    return Preferences.get({ key: 'user' }).then((val) => {\n      return JSON.parse(val.value);\n    });\n  }\n\n  public async setUserFamilyId(id) {\n\n    await this.getUserLocalstorage().then(user => {\n      console.log(`[AuthenticationService] MEMBER(${id})`, user);\n      let s: string = user['name'];\n      let fullname = s.split(',');\n      this.user = new User(user['idUser'], '', fullname[0].replace(',',''), fullname[1], user['image']);\n      this.user.familyUnit = id;\n      this.setUserLocalstorage(this.user)\n    })\n  }\n\n  getShowIntroLocalstorage(): Promise<any> {\n    return Preferences.get({ key: 'showIntro' }).then((val) => {\n      return Boolean(val.value)\n    });\n  }\n\n  async setShowIntroLocalstorage() {\n    await Preferences.set({\n      key: 'showIntro',\n      value: 'true'\n    });\n  }\n\n  setTwoFactor(tfCenter: any){\n    localStorage.setItem('two-factor-center', tfCenter);\n  }\n\n  async logout1(): Promise<void>{\n    console.log('logout');\n    this.isAuthenticated.next(false);\n    const enviroment = this.endpoints._ENVIROMENT\n    //localStorage.removeItem(enviroment?.registered_user)\n    await Preferences.remove({ key: 'user' }).then((val) => { });\n    return Preferences.remove({ key: TOKEN_KEY });\n  }\n\n  logout(allDevices?): Observable<any>  {\n    this.getAllTokenDevices()\n    let params = {\n      tokens: this.tokens,\n      allDevices: allDevices? allDevices: false\n    }\n    console.log('logout', params );\n    let path = 'patient/logout'\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map( (res: any) => {\n        console.log(`[AuthenticationService] logout(${path}) res: `, JSON.stringify(res) );\n        this.isAuthenticated.next(false);\n        const enviroment = this.endpoints._ENVIROMENT\n        //localStorage.removeItem(enviroment?.registered_user)\n         Preferences.remove({ key: 'user' }).then((val) => { });\n         Preferences.remove({ key: TOKEN_KEY });\n        return res;\n      })\n    );\n}\ngetAllTokenDevices(){\n  let list = JSON.parse(localStorage.getItem(TOKENS))\n  this.tokens = list? list:[]\n}\n\n\n\n  increaseNumloginFailed(){\n    let numFailLogin = 0\n    let num = localStorage.getItem('num-fail-login');\n    if(num){\n      let numFailLogin = Number(JSON.parse(num)) + 1\n      localStorage.setItem('num-fail-login',''+numFailLogin);\n      localStorage.setItem('login_request_locked_at',''+(new Date().getTime()));\n    }else{\n      localStorage.setItem('num-fail-login','1');\n      localStorage.setItem('login_request_locked_at',''+(new Date().getTime()));\n      numFailLogin = 1\n    }\n    console.log('[AuthenticationService] increaseNumloginFailed()', numFailLogin);\n  }\n\n  increaseNumFPAIOFailed(){\n    let num = localStorage.getItem('num-fail-finger-print');\n    if(num){\n      localStorage.setItem('num-fail-login',''+(Number(JSON.parse(num)) + 1));\n      localStorage.setItem('login_request_locked_at',''+(new Date().getTime()));\n    }else{\n      localStorage.setItem('num-fail-login','1');\n      localStorage.setItem('login_request_locked_at',''+(new Date().getTime()));\n    }\n  }\n\n  getNumloginFailed(){\n    let num = localStorage.getItem('num-fail-login');\n    if(num) return Number(JSON.parse(num))\n    return 0\n  }\n\n  getDateloginFailed(){\n    let num = localStorage.getItem('login_request_locked_at');\n    if(num) return Number(JSON.parse(num))\n    return 0\n  }\n\n  getNumFingerPrinterFailed(){\n    let num = localStorage.getItem('num-fail-finger-print');\n    if(num) return Number(JSON.parse(num))\n    return 0\n  }\n\n  removeNumloginFailed(){\n    localStorage.removeItem('num-fail-login');\n    localStorage.removeItem('login_request_locked_at');\n  }\n\n  removeNumFirgerPFailed(){\n    localStorage.removeItem('num-fail-finger-print');\n    localStorage.removeItem('login_request_locked_at');\n  }\n\n  get(endpt): Observable<any> {\n    const endpoint = this.api.getEndpoint(endpt);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        return res;\n      })\n    );\n\n  }\n\n  post(endpt, items): Observable<any> {\n    const endpoint = this.api.getEndpoint(endpt);\n    return this.http.post(endpoint, items).pipe(\n      map((res: any) => {\n        return res;\n      })\n    );\n  }\n\n  throwError(error: any) {\n\n    if (error instanceof HttpErrorResponse)\n      throw new HttpErrorResponse(error);\n    else\n      throw new Error(error);\n  }\n\n\n  public registerDevice(token, platform) {\n\n    console.log(\"response IOSDEV\", platform);\n    if(platform == 'FCM')\n      platform = 'android';\n    if(platform == 'APNS')\n      platform = this.endpoints._ENVIROMENT.device_ios.ios_push;\n    if(platform == 'ios')\n      platform = this.endpoints._ENVIROMENT.device_ios.ios_push;\n\n     const postData = {\n      token: token,\n      platform: platform\n    };\n\n    console.log(\"postData: \",  postData);\n\n    return this.post('user/device/register', postData).subscribe(\n      async (data) => {\n        let response=data;\n        console.log(\"response user/device/register\");\n        console.log(response);\n        this.saveAllTokenDevices(postData)\n        return response;\n      },\n      (error) => {\n        // Called when error\n        console.log('error user/device/register: ', error);\n        throw error;\n      });\n  }\n\n  saveAllTokenDevices(token){\n    this.tokens.push(token)\n    localStorage.setItem(TOKENS,JSON.stringify(this.tokens))\n  }\n\n  async showIntro() {\n    return Preferences.get({ key: INTRO_KEY }).then(async (data) => {\n      let showIntro = Boolean(data.value)\n      console.log(`[AuthService] showIntro()`, showIntro);\n      return showIntro;\n\n    })\n  }\n\n  postAPIbiometric(params: Object): Observable<any> {\n    let path = `user/biometric`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] postAPIbiometric(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  putAPIbiometric(id: any, params: Object): Observable<any> {\n    let path = `user/biometric/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.put(endpoint, params).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] putAPIbiometric(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  deleteAPIbiometric(id: Object): Observable<any> {\n    let path = `user/biometric/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.delete(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] deleteAPIbiometric(${path}) res: ${res}`, JSON.stringify(res));\n        return res;\n      })\n    );\n  }\n\n  redirectLogin(){\n    this.router.navigateByUrl('/landing');\n  }\n\n  async redirectUnauthenticated() {\n      const translateService = this.injector.get(TranslateService)\n      const alert = await this.alertController.create({\n        cssClass: \"alertClass\",\n        header:  translateService.instant('info.title'),\n        backdropDismiss:false,\n        // subHeader: 'Subtitle',\n        message: translateService.instant('landing.login_again'),\n        buttons: [\n          {text: translateService.instant('button.accept'),\n          handler: () => {\n            this.router.navigateByUrl(`/landing`);\n          }\n        }\n        ]\n      });\n\n      await alert.present();\n    }\n\n    getShowGoogleFitLocalstorage(): Promise<any> {\n      return Preferences.get({ key: 'showGoogleFit' }).then((val) => {\n        return Boolean(val.value)\n      });\n    }\n    \n    async setShowGoogleFitLocalstorage() {\n      await Preferences.set({\n        key: 'showGoogleFit',\n        value: 'true'\n      });\n    }\n\n    setCanceledGoogleFitLocalstorage(mostrar: string) {\n      localStorage.setItem('cancelGoogleFit', mostrar);\n    }\n\n    getCanceledGoogleFitLocalstorage():boolean {\n      const value = localStorage.getItem('cancelGoogleFit')\n      console.log(\"Booelan: \", value);\n      return value !== null ? JSON.parse(value) : false;\n    }\n}\n"]}

package/esm2022/lib/services/change-endpoints.service.mjs

@@ -0,0 +1,90 @@
+import { Injectable, Inject } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { CONFIGURACION_TOKEN, PUSHERS_CONFIG_TOKEN } from '../configuration';
+import * as i0 from "@angular/core";
+export var _INDEX_ENPOINT = 0; //Por defecto index 0 
+const ENDPOINT = 'endpoint';
+export class ChangeEndpointsService {
+    constructor(constants, pusher) {
+        this.constants = constants;
+        this.pusher = pusher;
+        this._endpointIndex = new BehaviorSubject(this.getIndexEndPointLocalstorage());
+        this._LIST_ENPOINT = [];
+        this.addEndPoint();
+        this.setDefaultEndPoint();
+    }
+    async addEndPoint() {
+        this._LIST_ENPOINT = [];
+        this._LIST_ENPOINT.push({
+            id: 0,
+            name: 'enviroment.production',
+            api: this.constants.API_DOOLE_ENDPOINT,
+            endpoint: this.constants.DOOLE_ENDPOINT,
+            device_ios: { ios_push: 'ios_dev', ios_voip: 'iosvoipdev' },
+            pusher_key: this.pusher.PUSHER_KEY_PRO,
+            color: 'primary',
+            settings_bio: 'settings-bio0',
+            biometric: 'biometric0',
+            show_bio_dialog: 'show-bio-dialog0',
+            registered_user: 'registered-user0',
+        });
+        this._LIST_ENPOINT.push({
+            id: 1,
+            name: 'enviroment.development',
+            api: this.constants.API_ENDPOINT_DEV,
+            endpoint: this.constants.ENDPOINT_DEV,
+            device_ios: { ios_push: 'ios_dev', ios_voip: 'iosvoipdev' },
+            pusher_key: this.pusher.PUSHER_KEY_DEV,
+            color: 'warning',
+            settings_bio: 'settings-bio1',
+            biometric: 'biometric1',
+            show_bio_dialog: 'show-bio-dialog1',
+            registered_user: 'registered-user1',
+        });
+        //      device_ios: {ios_push: 'ios', ios_voip: 'iosvoip'},
+    }
+    setEndPoint(index) {
+        console.log("DINTRE DEL LIB");
+        this._ENVIROMENT = this._LIST_ENPOINT[index];
+        _INDEX_ENPOINT = index;
+        this.API_ENDPOINT = this._ENVIROMENT.api;
+        this.DOOLE_ENDPOINT = this._ENVIROMENT.endpoint;
+        this.setIndexEndPointLocalstorage(index);
+        this._endpointIndex.next(index);
+    }
+    setIndexEndPointLocalstorage(endpoint) {
+        localStorage.setItem(ENDPOINT, JSON.stringify(endpoint));
+    }
+    getIndexEndPointLocalstorage() {
+        let endpoint = localStorage.getItem(ENDPOINT);
+        //console.log(`[ChangeEndpointsService] setEndPointLocalstorage()`, endpoint);
+        if (endpoint)
+            return Number(JSON.parse(endpoint));
+        return undefined;
+    }
+    getEndpointIndexObservable() {
+        return this._endpointIndex.asObservable();
+    }
+    setDefaultEndPoint() {
+        if (this.API_ENDPOINT == undefined || this.DOOLE_ENDPOINT == undefined) {
+            let index = this.getIndexEndPointLocalstorage();
+            index = (index == undefined) ? _INDEX_ENPOINT : index;
+            this.setEndPoint(index);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ChangeEndpointsService, deps: [{ token: CONFIGURACION_TOKEN }, { token: PUSHERS_CONFIG_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ChangeEndpointsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ChangeEndpointsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CONFIGURACION_TOKEN]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PUSHERS_CONFIG_TOKEN]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"change-endpoints.service.js","sourceRoot":"","sources":["../../../../../projects/service-lib/src/lib/services/change-endpoints.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject } from '@angular/core';\nimport { AngularFireModule } from '@angular/fire/compat';\nimport { BehaviorSubject } from 'rxjs';\nimport { CONFIGURACION_TOKEN, Configuracion, PUSHERS_CONFIG_TOKEN, PusherKey, PushersConfig } from '../configuration';\nexport var _INDEX_ENPOINT: number = 0 //Por defecto index 0 \nconst ENDPOINT = 'endpoint';\n\nexport interface enviroment {\n  id:number,\n  name: string, \n  api: string, \n  endpoint: string,\n  device_ios: {ios_push: string, ios_voip: string},\n  color?: string,\n  pusher_key: PusherKey,\n  settings_bio?: string,\n  biometric?: string,\n  show_bio_dialog?: string,\n  registered_user?: string,\n}\n@Injectable({\n  providedIn: 'root'\n})\nexport class ChangeEndpointsService {\n  private _endpointIndex = new BehaviorSubject<number>(this.getIndexEndPointLocalstorage());\n  public API_ENDPOINT: string;\n  public DOOLE_ENDPOINT: string;\n\n  public _LIST_ENPOINT: Array<enviroment> = [] \n  public _ENVIROMENT: enviroment;\n  public static urlBackEnd: string;\n  constructor(\n    @Inject(CONFIGURACION_TOKEN) private constants: Configuracion,\n    @Inject(PUSHERS_CONFIG_TOKEN) private pusher: PushersConfig,) {\n        this.addEndPoint()\n        this.setDefaultEndPoint()\n     }\n\n  public async addEndPoint(){   \n    this._LIST_ENPOINT = [] \n    this._LIST_ENPOINT.push({ \n      id:0,\n      name: 'enviroment.production', \n      api: this.constants.API_DOOLE_ENDPOINT, \n      endpoint: this.constants.DOOLE_ENDPOINT,\n      device_ios: {ios_push: 'ios_dev', ios_voip: 'iosvoipdev'},\n      pusher_key: this.pusher.PUSHER_KEY_PRO,\n      color: 'primary',\n      settings_bio: 'settings-bio0',\n      biometric: 'biometric0',\n      show_bio_dialog: 'show-bio-dialog0',\n      registered_user: 'registered-user0',\n    }) \n    this._LIST_ENPOINT.push({\n      id:1,\n      name: 'enviroment.development', \n      api: this.constants.API_ENDPOINT_DEV, \n      endpoint: this.constants.ENDPOINT_DEV,\n      device_ios: {ios_push: 'ios_dev', ios_voip: 'iosvoipdev'},\n      pusher_key: this.pusher.PUSHER_KEY_DEV,\n      color: 'warning',\n      settings_bio: 'settings-bio1',\n      biometric: 'biometric1',\n      show_bio_dialog: 'show-bio-dialog1',\n      registered_user: 'registered-user1',\n     \n    })\n  //      device_ios: {ios_push: 'ios', ios_voip: 'iosvoip'},\n  }\n\n  public setEndPoint(index){\n    console.log(\"DINTRE DEL LIB\");\n    this._ENVIROMENT = this._LIST_ENPOINT[index]\n    _INDEX_ENPOINT = index\n\n    this.API_ENDPOINT = this._ENVIROMENT.api\n    this.DOOLE_ENDPOINT = this._ENVIROMENT.endpoint\n    this.setIndexEndPointLocalstorage(index)\n    this._endpointIndex.next(index); \n  }\n\n  setIndexEndPointLocalstorage(endpoint) {\n    localStorage.setItem(ENDPOINT, JSON.stringify(endpoint));\n  }\n\n  getIndexEndPointLocalstorage() {\n    let endpoint = localStorage.getItem(ENDPOINT);\n    //console.log(`[ChangeEndpointsService] setEndPointLocalstorage()`, endpoint);\n    if(endpoint) return Number(JSON.parse(endpoint))\n    return undefined\n  }\n  getEndpointIndexObservable() {\n    return this._endpointIndex.asObservable();\n  }\n  setDefaultEndPoint(){\n    if(this.API_ENDPOINT == undefined || this.DOOLE_ENDPOINT == undefined){\n      let index = this.getIndexEndPointLocalstorage()\n      index = (index == undefined)? _INDEX_ENPOINT: index\n      this.setEndPoint(index)\n    }\n  }\n}\n"]}