@doolehealth/service-lib 0.0.1

package/fesm2022/doolehealth-service-lib.mjs

@@ -0,0 +1,4025 @@
+import * as i0 from '@angular/core';
+import { Component, InjectionToken, NgModule, Injectable, Inject, PLATFORM_ID, ViewChild } from '@angular/core';
+import * as i2$2 from '@angular/common';
+import { CommonModule, DatePipe } from '@angular/common';
+import { BehaviorSubject, Subject, Observable, merge, of, fromEvent } from 'rxjs';
+import { Preferences } from '@capacitor/preferences';
+import { map, tap, catchError, mapTo } from 'rxjs/operators';
+import * as i1 from '@angular/common/http';
+import { HttpErrorResponse, HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';
+import * as i6 from '@angular/router';
+import { RouterOutlet, NavigationEnd } from '@angular/router';
+import * as i1$1 from '@ngx-translate/core';
+import { TranslateService } from '@ngx-translate/core';
+import { Capacitor } from '@capacitor/core';
+import * as CryptoJS from 'crypto-js';
+import * as i2 from '@ionic/angular';
+import * as i5 from '@angular/fire/compat/auth';
+import * as i2$1 from '@awesome-cordova-plugins/file-transfer/ngx';
+import * as i3 from '@awesome-cordova-plugins/file/ngx';
+import moment from 'moment';
+import * as HighCharts from 'highcharts';
+import highchartsMore from 'highcharts/highcharts-more';
+import * as i1$2 from '@angular/material/snack-bar';
+import { MatSnackBarConfig } from '@angular/material/snack-bar';
+import * as i1$3 from '@awesome-cordova-plugins/network/ngx';
+import { CallCapacitor } from '@doole/videocall-notications-plugins';
+import { FirebaseAnalytics } from '@capacitor-community/firebase-analytics';
+
+class ServiceLibComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ServiceLibComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.10", type: ServiceLibComponent, selector: "dev-service-lib", ngImport: i0, template: `
+    <p>
+      service-lib works!
+    </p>
+  `, isInline: true, styles: [""] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ServiceLibComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dev-service-lib', template: `
+    <p>
+      service-lib works!
+    </p>
+  ` }]
+        }] });
+
+const CONFIGURACION_TOKEN = new InjectionToken('configuracion');
+const PUSHERS_CONFIG_TOKEN = new InjectionToken('pushers.config');
+const FIREBASE_CONFIG_TOKEN = new InjectionToken('environment');
+
+class ServiceLibModule {
+    static forRoot(config, configPushers, environment) {
+        return {
+            ngModule: ServiceLibModule,
+            providers: [
+                { provide: CONFIGURACION_TOKEN, useValue: config },
+                { provide: PUSHERS_CONFIG_TOKEN, useValue: configPushers },
+                { provide: FIREBASE_CONFIG_TOKEN, useValue: environment },
+            ]
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ServiceLibModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.10", ngImport: i0, type: ServiceLibModule, declarations: [ServiceLibComponent], imports: [CommonModule], exports: [ServiceLibComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ServiceLibModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ServiceLibModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ServiceLibComponent],
+                    imports: [
+                        CommonModule,
+                    ],
+                    exports: [
+                        ServiceLibComponent
+                    ]
+                }]
+        }] });
+
+class QueryStringParameters {
+    constructor() {
+        this.toString = () => this.paramsAndValues.join('&');
+        this.paramsAndValues = [];
+    }
+    push(key, value) {
+        value = encodeURIComponent(value.toString());
+        this.paramsAndValues.push([key, value].join('='));
+    }
+}
+
+// Application Classes
+class UrlBuilder {
+    constructor(baseUrl, action, queryString) {
+        this.baseUrl = baseUrl;
+        this.action = action;
+        this.url = [baseUrl, action].join('/');
+        this.queryString = queryString || new QueryStringParameters();
+    }
+    toString() {
+        const qs = this.queryString ? this.queryString.toString() : '';
+        return qs ? `${this.url}?${qs}` : this.url;
+    }
+}
+
+var _INDEX_ENPOINT = 0; //Por defecto index 0 
+const ENDPOINT = 'endpoint';
+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]
+                }] }] });
+
+class ApiEndpointsService {
+    constructor(
+    // Application Constants
+    //private constants: Constants,
+    endpoints) {
+        this.endpoints = endpoints;
+        this.getEndpoint = (action) => this.createUrl(action);
+        this.getEndpointWithParameters = (action, parameters) => this.createUrlWithQueryParameters(action, parameters);
+    }
+    /* #region URL CREATOR */
+    // URL
+    createUrl(action, isDooleAPI = false) {
+        const urlBuilder = new UrlBuilder(this.endpoints.API_ENDPOINT, action);
+        return urlBuilder.toString();
+    }
+    // URL WITH QUERY PARAMS
+    createUrlWithQueryParameters(action, queryStringHandler) {
+        const urlBuilder = new UrlBuilder(this.endpoints.API_ENDPOINT, action);
+        // Push extra query string params
+        if (queryStringHandler) {
+            queryStringHandler(urlBuilder.queryString);
+        }
+        return urlBuilder.toString();
+    }
+    // URL WITH PATH VARIABLES
+    createUrlWithPathVariables(action, pathVariables = []) {
+        let encodedPathVariablesUrl = '';
+        // Push extra path variables
+        for (const pathVariable of pathVariables) {
+            if (pathVariable !== null) {
+                encodedPathVariablesUrl +=
+                    `/${encodeURIComponent(pathVariable.toString())}`;
+            }
+        }
+        const urlBuilder = new UrlBuilder(this.endpoints.API_ENDPOINT, `${action}${encodedPathVariablesUrl}`);
+        return urlBuilder.toString();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ApiEndpointsService, deps: [{ token: ChangeEndpointsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ApiEndpointsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ApiEndpointsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: ChangeEndpointsService }] });
+
+class EncryptionService {
+    constructor() {
+        this.secretKey = 'D001E-APP';
+    }
+    encryptData(data) {
+        const encryptedData = CryptoJS.AES.encrypt(JSON.stringify(data), this.secretKey).toString();
+        return encryptedData;
+    }
+    decryptData(encryptedData) {
+        const decryptedData = CryptoJS.AES.decrypt(encryptedData, this.secretKey);
+        try {
+            const data = decryptedData.toString(CryptoJS.enc.Utf8);
+            return JSON.parse(data);
+        }
+        catch (e) {
+            return encryptedData;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: EncryptionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: EncryptionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: EncryptionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+const TOKEN_KEY$1 = 'token';
+const DEVICE_TOKENS = 'tokens';
+class TokenService {
+    constructor(encryptionService) {
+        this.encryptionService = encryptionService;
+        this.deviceTokens = [];
+    }
+    // getToken(){
+    //   return this.token
+    // }
+    // setToken(token){
+    //   this.token = token;
+    // }
+    hasToken() {
+        return this.token != undefined ? true : false;
+    }
+    getAuthToken() {
+        const token = localStorage.getItem(TOKEN_KEY$1);
+        if (!token)
+            return;
+        //console.log("[TokenService] getAuthToken()", token);
+        const encryptedData = this.encryptionService.decryptData(token);
+        return encryptedData;
+    }
+    setAuthToken(token) {
+        const encryptedData = this.encryptionService.encryptData(token);
+        localStorage.setItem(TOKEN_KEY$1, encryptedData);
+    }
+    removeAuthToken() {
+        localStorage.removeItem(TOKEN_KEY$1);
+    }
+    saveAllTokenDevices(token) {
+        this.deviceTokens.push(token);
+        const encryptedData = this.encryptionService.encryptData(this.deviceTokens);
+        console.log("[TokenService] saveAllTokenDevices() ", encryptedData);
+        localStorage.setItem(DEVICE_TOKENS, JSON.stringify(encryptedData));
+    }
+    getAllTokenDevices() {
+        let list = JSON.parse(localStorage.getItem(DEVICE_TOKENS));
+        if (!list)
+            return null;
+        console.log("[TokenService] getAllTokenDevices() ", list);
+        const decryptedData = this.encryptionService.decryptData(list);
+        this.deviceTokens = decryptedData ? decryptedData : [];
+        return this.deviceTokens;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: TokenService, deps: [{ token: EncryptionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: TokenService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: TokenService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: EncryptionService }] });
+
+const TOKEN_KEY = 'token';
+const INTRO_KEY = 'intro';
+const TOKENS = 'tokens';
+const TWO_FACTOR_CENTER = 'two-factor-center';
+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;
+    }
+    ;
+}
+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: TokenService }, { token: ApiEndpointsService }, { token: i2.Platform }, { token: i5.AngularFireAuth }, { token: i6.Router }, { token: i2.AlertController }, { token: i0.Injector }, { token: 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: TokenService }, { type: ApiEndpointsService }, { type: i2.Platform }, { type: i5.AngularFireAuth }, { type: i6.Router }, { type: i2.AlertController }, { type: i0.Injector }, { type: ChangeEndpointsService }], propDecorators: { outlet: [{
+                type: ViewChild,
+                args: [RouterOutlet]
+            }] } });
+
+class HttpService {
+    constructor(http, httpBackend, authService) {
+        this.http = http;
+        this.httpBackend = httpBackend;
+        this.authService = authService;
+        this.httpWithoutInterceptor = new HttpClient(httpBackend);
+    }
+    async formatErrors(error) {
+        return error;
+    }
+    get(path, params = new HttpParams()) {
+        let user = this.authService?.user;
+        params = (user?.familyUnit) ? params.append('user', user?.familyUnit) : params;
+        return this.http.get(`${path}`, { params })
+            .pipe(catchError(this.formatErrors));
+    }
+    put(path, body = {}, options = {}) {
+        let httpOptions = this.setHttpOptions(options);
+        //console.log("url: ", path);
+        //console.log("body: ", body);
+        return this.http.put(`${path}`, JSON.stringify(body), httpOptions).pipe(catchError(this.formatErrors));
+    }
+    postform(path, body = {}, options = {}) {
+        let user = this.authService?.user;
+        if (user?.familyUnit !== null)
+            body['user'] = user?.familyUnit;
+        let httpOptions = this.setHttpOptions(options);
+        //console.log("url: ", path);
+        //console.log("body: ", body);
+        return this.http.post(`${path}`, JSON.stringify(body), httpOptions).pipe(catchError(this.formatErrors));
+    }
+    post(path, body = {}, options = {}, formData) {
+        let user = this.authService?.user;
+        if (user?.familyUnit !== undefined && user?.familyUnit !== null)
+            body['user'] = user?.familyUnit;
+        let httpOptions = this.setHttpOptions(options, formData);
+        //console.log("url: ", path);
+        //console.log("body: ", body);
+        return this.http.post(`${path}`, JSON.stringify(body), httpOptions).pipe(catchError(this.formatErrors));
+    }
+    postForm(path, body = {}, options = {}, formData) {
+        let user = this.authService?.user;
+        if (user?.familyUnit !== null)
+            body['user'] = user?.familyUnit;
+        const httpOptions = {
+            headers: new HttpHeaders({
+                'Accept': 'application/json'
+            })
+        };
+        console.log("url: ", path);
+        console.log("body: ", body);
+        return this.http.post(`${path}`, body, httpOptions).pipe(catchError(this.formatErrors));
+    }
+    delete(path) {
+        return this.http.delete(`${path}`).pipe(catchError(this.formatErrors));
+    }
+    _get(path, params = new HttpParams()) {
+        return this.httpWithoutInterceptor.get(`${path}`, { params })
+            .pipe(catchError(this.formatErrors));
+    }
+    _put(path, body = {}) {
+        return this.httpWithoutInterceptor.put(`${path}`, JSON.stringify(body)).pipe(catchError(this.formatErrors));
+    }
+    _post(path, body = {}, options = {}) {
+        let httpOptions = this.setHttpOptions(options);
+        let params = this.setHttpParams(body);
+        return this.httpWithoutInterceptor.post(`${path}`, JSON.stringify(body), httpOptions).pipe(catchError(error => this.formatErrors(error)));
+    }
+    _delete(path) {
+        return this.httpWithoutInterceptor.delete(`${path}`).pipe(catchError(this.formatErrors));
+    }
+    setHttpParams(body) {
+        let params = new HttpParams();
+        if (body != null)
+            for (let key in body)
+                params = params.append(key, body[key]);
+        return params;
+    }
+    setHttpOptions(options, formData) {
+        console.log('** options', options);
+        if (formData) {
+            const httpOptions = {
+                headers: new HttpHeaders({
+                    'Accept': 'application/json'
+                })
+            };
+            return httpOptions;
+        }
+        else if (Object.keys(options).length > 0) {
+            const httpOptions = {
+                headers: new HttpHeaders({
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                    options
+                })
+            };
+            return httpOptions;
+        }
+        else {
+            const httpOptions = {
+                headers: new HttpHeaders({
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                })
+            };
+            return httpOptions;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: HttpService, deps: [{ token: i1.HttpClient }, { token: i1.HttpBackend }, { token: AuthenticationService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: HttpService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: HttpService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i1.HttpBackend }, { type: AuthenticationService }] });
+
+/**
+ * A custom Events service just like Ionic 3 Events https://ionicframework.com/docs/v3/api/util/Events/ which got removed in Ionic 5.
+ *
+ * @author Shashank Agrawal
+ */
+class Events {
+    constructor() {
+        this.channels = {};
+    }
+    /**
+     * Subscribe to a topic and provide a single handler/observer.
+     * @param topic The name of the topic to subscribe to.
+     * @param observer The observer or callback function to listen when changes are published.
+     *
+     * @returns Subscription from which you can unsubscribe to release memory resources and to prevent memory leak.
+     */
+    subscribe(topic, observer) {
+        console.log("subscribe topic: ", topic);
+        if (!this.channels[topic]) {
+            // You can also use ReplaySubject with one concequence
+            this.channels[topic] = new Subject();
+        }
+        return this.channels[topic].subscribe(observer);
+    }
+    /**
+     * Publish some data to the subscribers of the given topic.
+     * @param topic The name of the topic to emit data to.
+     * @param data data in any format to pass on.
+     */
+    publish(topic, data) {
+        const subject = this.channels[topic];
+        if (!subject) {
+            // Or you can create a new subject for future subscribers
+            return;
+        }
+        subject.next(data);
+    }
+    /**
+     * When you are sure that you are done with the topic and the subscribers no longer needs to listen to a particular topic, you can
+     * destroy the observable of the topic using this method.
+     * @param topic The name of the topic to destroy.
+     */
+    destroy(topic) {
+        const subject = this.channels[topic];
+        if (!subject) {
+            return null;
+        }
+        subject.complete();
+        delete this.channels[topic];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: Events, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: Events, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: Events, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class DooleService {
+    constructor(authService, transfer, file, http, api, events, platform, router, alertController) {
+        this.authService = authService;
+        this.transfer = transfer;
+        this.file = file;
+        this.http = http;
+        this.api = api;
+        this.events = events;
+        this.platform = platform;
+        this.router = router;
+        this.alertController = alertController;
+    }
+    uploadFile(image, id) {
+        console.log("uploading ", image);
+        const token = localStorage.getItem('token');
+        let options = {
+            fileKey: 'file',
+            fileName: 'name.jpg',
+            headers: {
+                'Authorization': 'Bearer ' + token,
+                'Accept': 'application/json',
+            },
+            params: {
+                id: id
+            }
+        };
+        const fileTransfer = this.transfer.create();
+        // Add files for new or saved diagnostics.
+        // uses diagnostic/media when diagnostic is new
+        //const endpoint = id ? this.api.getEndpoint('diagnostic/media'):this.api.getDooleEndpoint('media/upload/temp') ;
+        const endpoint = this.api.getEndpoint('media/upload/temp');
+        //console.log("* uploadFile endpoint", endpoint);
+        return new Promise(function (resolve, reject) {
+            fileTransfer.upload(image, endpoint, options).then(data => {
+                console.log(data);
+                resolve(JSON.parse(data.response));
+            }, (err) => {
+                console.log(err);
+                reject(err);
+            });
+        });
+    }
+    postAPIAddMedia(params) {
+        const endpoint = this.api.getEndpoint('media/add');
+        return this.http.postForm(endpoint, params).pipe(map((res) => {
+            console.log(`[DooleService] postAPIAddMedia(${endpoint}) res: `, res);
+            return res;
+        }));
+    }
+    uploadFileToModel(image, name, params) {
+        //console.log("uploading ", image);
+        const token = localStorage.getItem('token');
+        let options = {
+            fileKey: 'file',
+            fileName: name,
+            headers: {
+                'Authorization': 'Bearer ' + token,
+                'Accept': 'application/json',
+            },
+            params
+        };
+        const fileTransfer = this.transfer.create();
+        const endpoint = this.api.getEndpoint('media/add');
+        return new Promise(function (resolve, reject) {
+            fileTransfer.upload(image, endpoint, options).then(data => {
+                console.log(JSON.parse(data.response));
+                resolve(JSON.parse(data.response));
+            }, (err) => {
+                console.log(err);
+                reject(err);
+            });
+        });
+    }
+    uploadMessageImage(idMessageHeader, idUserTo, message, fileUrl, id_usuari_amiq) {
+        const token = localStorage.getItem('token');
+        let options = {
+            fileKey: 'file',
+            fileName: 'name.pdf', //TODO: 'name.jpg'
+            headers: {
+                'Authorization': 'Bearer ' + token,
+                'Accept': 'application/json',
+            },
+            params: {
+                idUser: id_usuari_amiq,
+                secret: token,
+                value: "",
+                id: idMessageHeader
+            }
+        };
+        //console.log("options: ", options);
+        const fileTransfer = this.transfer.create();
+        fileTransfer.onProgress((progressEvent) => {
+            if (progressEvent.lengthComputable) {
+                var perc = Math.floor(progressEvent.loaded / progressEvent.total * 100);
+                this.events.publish("uploadMessageImage", { fileUrl, perc });
+            }
+            else {
+                //console.log("progressEvent - ", progressEvent);
+            }
+        });
+        const endpoint = this.api.getEndpoint('message');
+        return new Promise(function (resolve, reject) {
+            fileTransfer.upload(fileUrl, endpoint, options)
+                .then(data => {
+                //console.log("success fileTransfer.upload", JSON.parse(data.response));
+                resolve(JSON.parse(data.response));
+            }, (err) => {
+                //console.log("** error ** fileTransfer.upload: ", err);
+                reject(fileTransfer.upload);
+            });
+        });
+    }
+    b64toBlob(b64Data, contentType = '', sliceSize = 512) {
+        const byteCharacters = atob(b64Data);
+        const byteArrays = [];
+        for (let offset = 0; offset < byteCharacters.length; offset += sliceSize) {
+            const slice = byteCharacters.slice(offset, offset + sliceSize);
+            const byteNumbers = new Array(slice.length);
+            for (let i = 0; i < slice.length; i++) {
+                byteNumbers[i] = slice.charCodeAt(i);
+            }
+            const byteArray = new Uint8Array(byteNumbers);
+            byteArrays.push(byteArray);
+        }
+        const blob = new Blob(byteArrays, { type: contentType });
+        return blob;
+    }
+    downloadFile(url, destination) {
+        var result = [];
+        const fileTransfer = this.transfer.create();
+        var path = null;
+        if (this.platform.is('ios')) {
+            path = this.file.documentsDirectory;
+        }
+        else {
+            path = this.file.dataDirectory;
+        }
+        //console.log("downloadFile", url, destination, 'path,destination', path, destination);
+        return new Observable((observer) => {
+            //console.log("before CheckFile", this.file);
+            this.file.checkFile(path, destination).then(res => {
+                //console.log("*res*", res);
+                if (res) {
+                    //console.log("exists", res);
+                    result["success"] = true;
+                    result["downloaded"] = true;
+                    result["file"] = path + destination; //normalizeURL(this.file.cacheDirectory + destination);
+                    result["fileNormalized"] = Capacitor.convertFileSrc(path + destination);
+                    return observer.next(result);
+                }
+            }, error => {
+                //console.log("not exists");
+                fileTransfer.onProgress(event => {
+                    if (event.lengthComputable) {
+                        //console.log(event.loaded / event.total);
+                        result["status"] = "downloading";
+                        result["downloaded"] = false;
+                        result["percent"] = Math.round((event.loaded / event.total) * 100);
+                        return observer.next(result);
+                    }
+                });
+                return fileTransfer.download(url, path + destination).then((entry) => {
+                    //console.log('*download:* ' + url + " " + entry.toURL());
+                    result["success"] = true;
+                    result["downloaded"] = true;
+                    result["file"] = entry.toURL(); //normalizeURL(this.file.cacheDirectory + destination);
+                    result["fileNormalized"] = Capacitor.convertFileSrc(path + destination);
+                    return observer.next(result);
+                }, (error) => {
+                    //console.log(error);
+                    result["success"] = false;
+                    result["downloaded"] = false;
+                    //console.log("error download " + url);
+                    //console.log(result);
+                    return observer.next(result);
+                });
+            });
+        });
+    }
+    deleteFile(id) {
+        let path = `media/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.delete(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] deleteFile(${path}) res: ${res}`, JSON.stringify(res));
+            return res;
+        }));
+    }
+    showAlert(message) {
+        return this.alertController.create({
+            header: 'Info',
+            message: message,
+            backdropDismiss: false,
+            buttons: ['OK']
+        });
+    }
+    async showAlertAndReturn(header, message, isDismiss, route) {
+        //console.log(`[DooleService] showAlertAndReturn()`);
+        let dismiss = (isDismiss !== undefined) ? isDismiss : false;
+        const alert = await this.alertController.create({
+            header: header,
+            message: message,
+            backdropDismiss: dismiss,
+            buttons: [
+                {
+                    text: 'OK',
+                    handler: (blah) => {
+                        // console.log('Confirm OK: blah');
+                        if (route !== undefined && route !== null)
+                            this.router.navigateByUrl(route);
+                    }
+                }
+            ]
+        });
+        await alert.present();
+    }
+    async presentAlert(message, button) {
+        let buttonName = (button !== undefined) ? button : 'Ok';
+        const alert = await this.alertController.create({
+            cssClass: 'my-alert-class',
+            message: message,
+            buttons: [buttonName]
+        });
+        await alert.present();
+    }
+    getFamilyUnitID() {
+        let httpParams = new HttpParams();
+        let user = this.authService?.user;
+        return httpParams = (user.familyUnit) ? httpParams.append('user', user.familyUnit) : httpParams;
+    }
+    getAPILegalInformation() {
+        let path = 'user/legalTerm/lastAccepted';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPILegalInformation(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPILegalConfirmation(params) {
+        let path = 'user/legalTerm/lastAccepted';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] postAPIConfirmationLegal(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIRejectLegalConfirmation(params) {
+        let path = 'user/legalTerm/lastDeclined';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] postAPIConfirmationLegal(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIpasswordRecovery(params) {
+        let path = 'patient/forgot';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] postAPIpasswordRecovery(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIStaffSlots(params) {
+        let path = `staff/${params.id}/availability`;
+        let endpoint;
+        if (params.date !== "") {
+            endpoint = this.api.getEndpointWithParameters(path, (qs) => qs.push('date', params.date));
+        }
+        else {
+            endpoint = this.api.getEndpoint(path);
+        }
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIStaffSlots(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIgoals() {
+        let path = 'user/element/goals';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIhomeInitial(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIvideocall(id) {
+        let path = 'user/agenda/' + id + '/videocallSession';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPIvideocall(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIPendingConnect() {
+        let path = 'user/videocall/pendingConnect';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPIPendingConnect(${path}) res: `, res);
+            return res;
+        }));
+    }
+    /*   getAPIinformationUser(): Observable<any>{
+    
+        let path = 'user/informationUser'
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(
+          map((res: any) => {
+            //console.log(`[DooleService] getAPIhomeInitial(${path}) res: `, res);
+            return res;
+          })
+        )
+      } */
+    getAPIinformationSummary(params) {
+        let path = 'home';
+        const endpoint = this.api.getEndpoint(path);
+        console.log('home params', params);
+        return this.http.post(endpoint, params).pipe(map(res => res));
+    }
+    getAPIinformationSummaryOld(params) {
+        let path = 'home';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map(res => res));
+    }
+    getAPIuserProfile() {
+        let path = 'v2/user/profile';
+        //let httpParams = this.getFamilyUnitID()
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIhomeInitial(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIChangePassword(params) {
+        let path = 'user/changePassword';
+        let httpParams = this.getFamilyUnitID();
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] postAPIChangePassword(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPInotificationConfigurations() {
+        let path = 'user/configuration';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPInotificationConfigurations(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIConfiguration(params) {
+        let path = 'user/configuration';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] postAPIConfiguration(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIlanguagesCenter() {
+        let path = 'center/languages';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIlanguagesCenter(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIFaqs() {
+        let path = 'center/faq';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIhomeInitial(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIFamilyUnit() {
+        let path = 'user/familyUnit';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIFamilyUnit(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIFamilyUnit2() {
+        let path = 'v2/user/familyUnit';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPIFamilyUnit(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIReportProblem(params) {
+        let path = 'user/reportProblem'; // 'media/upload/temp'
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            console.log(`[DooleService] postAPIReportProblem(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIemailVerification(params) {
+        let path = 'user/email_verification';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            console.log(`[DooleService] postAPIemailVerification(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPICodeByEmail() {
+        let path = 'user/resendTwoFactorCode';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPICodeByEmail(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIcodeVerification(params) {
+        let path = 'user/verifyTwoFactor';
+        //let path = 'user/codeVerification';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            console.log(`[DooleService] postAPIcodeVerification(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIhealthCardTypes() {
+        let path = 'center/healthCardTypes';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPIhealthCardTypes(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIhealthCards() {
+        let path = 'user/healthcards';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPhealthCards(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIhealthCardId(id) {
+        let path = `user/healthcard/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPIhealthCard(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIhealthCards(params) {
+        let path = 'user/healthcard';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            console.log(`[DooleService] postAPIReportProblem(${path}) res: `, res);
+            return res;
+        }));
+    }
+    putAPIhealthCard(params) {
+        let path = `user/healthcard/${params.id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.put(endpoint, params).pipe(map((res) => {
+            console.log(`[DooleService] putAPIhealthCard(${path}) res: `, res);
+            return res;
+        }));
+    }
+    deleteAPIhealthCard(params) {
+        let path = `user/healthcard/${params.id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.delete(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] deleteAPIhealthCard(${path}) res: ${res}`, JSON.stringify(res));
+            return res;
+        }));
+    }
+    getAPISocialRelationType() {
+        let path = 'center/socialRelationType';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPISocialRelationType(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIemergencyContact() {
+        let path = 'user/EmergencyContacts';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPIemergencyContact(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIemergencyContactID(id) {
+        let path = `user/EmergencyContact/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPIemergencyContact(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIemergencyContact(params) {
+        let path = 'user/EmergencyContact';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            console.log(`[DooleService] postAPIemergencyContact(${path}) res: `, res);
+            return res;
+        }));
+    }
+    putAPIemergencyContact(id, params) {
+        let path = `user/EmergencyContact/${id}`;
+        console.log('[DooleService] putAPIemergencyContact()', params);
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.put(endpoint, params).pipe(map((res) => {
+            console.log(`[DooleService] putAPIemergencyContact(${path}) res: `, res);
+            return res;
+        }));
+    }
+    deleteAPIemergencyContact(id) {
+        let path = `user/EmergencyContact/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.delete(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] deleteAPIemergencyContact(${path}) res: ${res}`, JSON.stringify(res));
+            return res;
+        }));
+    }
+    getAPIaboutUs() {
+        let path = 'center/about';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPIaboutUs(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIappointmentAgenda() {
+        let path = 'user/agenda';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIappointmentAgenda(${path}) res: `, res);
+            return res;
+        }));
+    }
+    //documents-Tracking
+    getAPIdiagnosticTests() {
+        let path = 'user/diagnosticTests';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIdiagnosticTests(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIdiagnosticTestTypesAvailable() {
+        let path = 'diagnosticTestTypes/available';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPIdiagnosticTestTypesAvailable(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIdiagnosticTestID(id) {
+        let path = 'v2/user/diagnosticTest/' + id;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPIdiagnosticTestID(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIdiagnosticTest(params) {
+        let path = 'v2/user/diagnosticTests/';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            console.log(`[DooleService] postAPIdiagnosticTest(${path}) res: `, res);
+            return res;
+        }));
+    }
+    putAPIdiagnosticTest(id, params) {
+        let path = `user/diagnosticTest/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.put(endpoint, params).pipe(map((res) => {
+            console.log(`[DooleService] putAPIdiagnosticTest(${path}) res: `, res);
+            return res;
+        }));
+    }
+    deleteAPIdiagnosticTest(id) {
+        let path = `user/diagnosticTest/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.delete(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] deleteAPIdiagnosticTest(${path}) res: ${res}`, JSON.stringify(res));
+            return res;
+        }));
+    }
+    getAPIfilteredDiagnosticTest(params) {
+        let path = 'user/diagnosticTests';
+        const endpoint = this.api.getEndpoint(path);
+        let httpParams = new HttpParams();
+        // Begin assigning parameters
+        if (params !== undefined) {
+            httpParams = (params.start_date) ? httpParams.append('from_date', params.start_date) : httpParams;
+            httpParams = (params.end_date) ? httpParams.append('to_date', params.end_date) : httpParams;
+            if (params.diagnosticTestTypes) {
+                params.diagnosticTestTypes.forEach(element => {
+                    httpParams = httpParams.append('diagnostic_test_type_id[]', element);
+                });
+            }
+        }
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            console.log(`[DooleService] getAPIfilteredDiagnosticTest(${path}) res: `, res);
+            return res;
+        }));
+    }
+    //forms-Tracking
+    getAPIformLists() {
+        let path = 'forms/user';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPIformLists(${path}) res: `, res);
+            return res;
+        }));
+    }
+    //graphics-Tracking
+    getAPIelementsList(filter) {
+        let path = 'user/elements'; /* 'user/elementsList/v2'  */
+        let httpParams = new HttpParams();
+        httpParams = (filter?.only_with_values) ? httpParams.append('only_with_values', filter?.only_with_values) : httpParams;
+        httpParams = (filter?.grouped) ? httpParams.append('grouped', filter?.grouped) : httpParams;
+        httpParams = (filter?.filter) ? httpParams.append('filter', filter?.filter) : httpParams;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            console.log(`[DooleService] getAPIelementsList(${path}) res: `, res);
+            return res;
+        }));
+    }
+    /** get elements with query by parameter date  */
+    getAPIelementsListByDate(params) {
+        let path = 'user/elementsList/v2'; /* 'user/elementsList'  */
+        let httpParams = new HttpParams();
+        if (params.filter == '1')
+            httpParams = httpParams.append('filter', '1');
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIelementsListByDate(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIaddElement(id, params) {
+        let path = 'user/element/' + id + '/value/add';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] postAPIaddElement(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIgraphicsElement(id, query) {
+        let path = 'user/element/' + id;
+        let httpParams = new HttpParams();
+        httpParams = (query) ? httpParams.append('interval', query) : httpParams;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIgraphicsElement(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIelementID(id, params) {
+        let path = `v2/user/element/${id}`;
+        let httpParams = new HttpParams();
+        httpParams = (params?.interval) ? httpParams.append('interval', params?.interval) : httpParams;
+        httpParams = (params?.from_date) ? httpParams.append('from_date', params?.from_date) : httpParams;
+        httpParams = (params?.to_date) ? httpParams.append('to_date', params?.to_date) : httpParams;
+        httpParams = (params?.version) ? httpParams.append('version', params?.version) : httpParams;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIgraphicsElement(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIelementAvailableID(id) {
+        let path = `element/available/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIelementAvailableID(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIcategory() {
+        let path = 'user/element_category';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIcategory(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIelementGroupID(id, filter) {
+        let path = `center/elementGroup/${id}/elements`;
+        let httpParams = new HttpParams();
+        httpParams = (filter) ? httpParams.append('filter', filter) : httpParams;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIelementGroupID(${path}) res: `, res);
+            return res;
+        }));
+    }
+    searchAPIelementGroup(params) {
+        let path = 'center/elementGroups';
+        let httpParams = new HttpParams();
+        httpParams = (params?.filter) ? httpParams.append('filter', params?.filter) : httpParams;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIelementGroup(${path}) res: `, res);
+            return res;
+        }));
+    }
+    /** get diets with query by parameter date  */
+    getAPIlistDietsByDate(params) {
+        let path = 'user/diets';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIlistDietsByDate(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIdietsByDate(params) {
+        let path = `user/dietaryIntakes`;
+        let httpParams = new HttpParams();
+        httpParams = (params?.date) ? httpParams.append('date', params.date) : httpParams;
+        httpParams = (params?.grouped_by_times) ? httpParams.append('grouped_by_times', params.grouped_by_times) : httpParams;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIdietsByDate(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIdetailDiets(id) {
+        let path = `diet/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIdetailDiets(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIdetailRecipe(id) {
+        let path = `diet/receipt/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIdetailRecipe(${path}) res: `, res);
+            return res;
+        }));
+    }
+    /** get advices  **/
+    getAPIlistAdvices(params) {
+        let path = 'user/advices';
+        const endpoint = this.api.getEndpoint(path);
+        let httpParams = new HttpParams()
+            .set('tags', params.tags)
+            .set('interactions', params.interactions)
+            .set('readingTime', params.readingTime);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIlistAdvices(${path}) res: `, res);
+            return res;
+        }));
+    }
+    /** get news  **/
+    getAPIlistNews() {
+        let path = 'user/news';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIlistNews(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIdetailNew(id) {
+        let path = `user/new/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIdetailNew(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPISearchNews(query) {
+        let path = 'news';
+        let httpParams = new HttpParams();
+        httpParams = (query) ? httpParams.append('search', query) : httpParams;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            //console.log(`[DooleService] getAPISearchNews(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIAppLatestVersion(version, platform) {
+        let path = 'app/versions/must-update?version=' + version + '&platform=' + platform;
+        console.log(path);
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            return res;
+        }));
+    }
+    getAPISearchAdvices(query) {
+        let path = 'advices';
+        let httpParams = new HttpParams();
+        httpParams = (query) ? httpParams.append('search', query) : httpParams;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            //console.log(`[DooleService] getAPISearchAdvices(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIdetailAdvices(id) {
+        let path = `advice/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIdetailAdvices(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIdrugsList(query) {
+        let path = `drugIntake/list`;
+        let httpParams = new HttpParams();
+        httpParams = (query) ? httpParams.append('search', query) : httpParams;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIdrugsList(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIdrugIntakeByDate(params) {
+        let path = 'user/drugIntake/date';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIdrugIntakeByDate(${path}) res: `, res);
+            return res;
+        }));
+    }
+    // send medication list
+    getAPImedicationList(query) {
+        let path = `sendmedication/list`;
+        let httpParams = new HttpParams();
+        httpParams = (query) ? httpParams.append('search', query) : httpParams;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            console.log(`[DooleService] getAPImedicationList(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIdirectionsList() {
+        let path = `user/addresses`;
+        // let httpParams = new HttpParams();
+        // httpParams = (query) ? httpParams.append('search', query) : httpParams
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPIdirectionList(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPImedicationsList() {
+        let path = `sendmedication/list`;
+        // let httpParams = new HttpParams();
+        // httpParams = (query) ? httpParams.append('search', query) : httpParams
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPIdirectionList(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIsendDirection(params) {
+        let path = 'user/address';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            console.log(`[DooleService] postAPIsendDirection(${path}) res: `, res);
+            return res;
+        }));
+    }
+    putAPIsendDirection(id, params) {
+        let path = `user/address/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.put(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] putAPIdrugIntake(${path}) res: `, res);
+            return res;
+        }));
+    }
+    deleteAPIsendDirection(id) {
+        let path = `user/address/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.delete(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] deleteAPImedicationPlan(${path}) res: ${res}`, JSON.stringify(res));
+            return res;
+        }));
+    }
+    postAPImedicationSendPetition(params) {
+        let path = 'sendmedication';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            console.log(`[DooleService] postAPIsendDirection(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIdrugIntake(params) {
+        let path = 'user/drugIntake';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] postAPIdrugIntake(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIchangeStatedrugIntake(id, state) {
+        let path = `user/drugIntake/${id}/set/${state}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] postAPIdrugIntake(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPImedicationPlan(params) {
+        let path = `user/medicationPlan`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] postAPIdrugIntake(${path}) res: `, res);
+            return res;
+        }));
+    }
+    putAPImedicationPlan(id, params) {
+        let path = `user/medicationPlan/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.put(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] putAPIdrugIntake(${path}) res: `, res);
+            return res;
+        }));
+    }
+    deleteAPImedicationPlan(id) {
+        let path = `user/medicationPlan/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.delete(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] deleteAPImedicationPlan(${path}) res: ${res}`, JSON.stringify(res));
+            return res;
+        }));
+    }
+    getAPImedicationPlan(id) {
+        let path = `user/medicationPlan/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPImedicationPlan(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIgames() {
+        let path = 'user/games';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIgames(${path}) res: `, res);
+            return res;
+        }));
+    }
+    /** get games with query by parameter date  */
+    getAPIgamesByDate(from_date, to_date) {
+        let path = 'user/gamePlays/scheduled';
+        let httpParams = new HttpParams();
+        httpParams = (from_date) ? httpParams.append('from_date', from_date) : httpParams;
+        httpParams = (to_date) ? httpParams.append('to_date', to_date) : httpParams;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIgames(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIgameId(id) {
+        let path = `user/game/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIgameId(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIagenda() {
+        let path = 'user/agenda';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIagenda(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIallAgenda(params) {
+        let path = 'user/agenda/v2';
+        let httpParams = new HttpParams();
+        httpParams = params?.from_date ? httpParams.append('from_date', params?.from_date) : httpParams;
+        httpParams = params?.to_date ? httpParams.append('to_date', params?.to_date) : httpParams;
+        httpParams = params?.filter_by_date ? httpParams.append('filter_by_date', params?.filter_by_date) : httpParams;
+        httpParams = (params?.with_medical_procedures != undefined) ? httpParams.append('with_medical_procedures', params?.with_medical_procedures) : httpParams;
+        httpParams = (params?.order != undefined) ? httpParams.append('order', params?.order) : httpParams;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            console.log(`[DooleService] getAPIappointmentAgendaV2(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIagendaID(id) {
+        let path = `user/agenda/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIagendaID(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIaddAgenda(params) {
+        let path = 'user/agenda/';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] postAPIaddAgenda(${path}) res: `, res);
+            return res;
+        }));
+    }
+    deleteAPIaddAgenda(id) {
+        let params = { agenda: id };
+        let path = 'user/agenda/delete';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] deleteAPIaddAgenda(${path}) res: `, res);
+            return res;
+        }));
+    }
+    putAPIagenda(id, params) {
+        let path = `user/agenda/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.put(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] putAPIagenda(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIallowedContacts() {
+        let path = `user/allowedContacts`;
+        const endpoint = this.api.getEndpoint(path);
+        let httpParams = new HttpParams();
+        httpParams = httpParams.append('withDepartments', '1');
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            console.log(`[DooleService] getAPIallowedContacts(${path}) res: `, res);
+            let allowed = res.allowed;
+            if (res.allowed === undefined)
+                allowed = [];
+            return allowed;
+        }));
+    }
+    getAPIstaffId(id) {
+        let path = `staff/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIstaffId(${path}) res: `, res);
+            return res;
+        }));
+    }
+    /** get games with query by parameter date  */
+    getAPIUserMessages() {
+        let path = 'message/user';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPIUserMessages(${path}) res: `, res);
+            if (res.length == 0)
+                return res;
+            return res.messages;
+        }));
+    }
+    // get the company details, a subset of the user data
+    getUserSubsetData() {
+        let path = 'message/user';
+        const endpoint = this.api.getEndpoint(path);
+        const dataObservable = this.http.get(endpoint);
+        return dataObservable.pipe(map((jsonResponse) => {
+            const filteredData = {
+                ...jsonResponse.messages
+            };
+            return filteredData;
+        }));
+    }
+    /** Reminders */
+    getAPIreminders() {
+        let path = 'user/reminder';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIreminders(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIreminderID(id) {
+        let path = `user/reminder/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIreminderID(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIaddReminder(params) {
+        let path = 'user/reminder/';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] postAPIaddReminder(${path}) res: `, res);
+            return res;
+        }));
+    }
+    deleteAPIReminder(id) {
+        let path = `user/reminder/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.delete(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] deleteAPIReminder(${path}) res: ${res}`, JSON.stringify(res));
+            return res;
+        }));
+    }
+    updateAPIReminder(id, params) {
+        let path = `user/reminder/${id}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.put(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] updateAPIReminder(${path}) res: `, res);
+            return res;
+        }));
+    }
+    updateAPIuser(params) {
+        let path = `user`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.put(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] updateAPIReminder(${path}) res: `, res);
+            return res;
+        }));
+    }
+    updateAPIImageuser(params) {
+        let path = `user/image`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.put(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] updateAPIReminder(${path}) res: `, res);
+            return res;
+        }));
+    }
+    deleteAPIImageuser() {
+        let path = `user/image`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.delete(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] updateAPIReminder(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIContentStatus(params) {
+        let path = 'content/status';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] postAPIContentStatus(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIpatients() {
+        let path = 'user/patients';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIreminders(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPILevelInfo(challengeId, levelId, params) {
+        let path = 'user/challenge/' + challengeId + '/level/' + levelId + '/goals';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPILevelInfo(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIChallenge(challengeId, params) {
+        let path = 'user/challenge/' + challengeId;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPIChallenge(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIChallenges(params) {
+        let path = 'user/challenges';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            console.log(`[DooleService] getAPIChallenges(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPImessage(id, params) {
+        let path = 'user/message/' + id;
+        let httpParams = new HttpParams();
+        httpParams = params?.page ? httpParams.append('page', params?.page) : httpParams;
+        httpParams = params?.user ? httpParams.append('user', params?.user) : httpParams;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIelementsList(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIFormJSON(form, params) {
+        let path = `form/${form}/formFields`;
+        let httpParams = new HttpParams();
+        httpParams = (params?.formAnswer) ? httpParams.append('formAnswer', params?.formAnswer) : httpParams;
+        httpParams = (params?.game_play_id) ? httpParams.append('game_play_id', params?.game_play_id) : httpParams;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIreminders(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIFormJSON(form, params) {
+        let path = `formfield/conditional/${form}/field/${params.formField}`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] postAPIContentStatus(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPIFormFill(params) {
+        let path = `form/fill/`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] postAPIContentStatus(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPINotificationsCount() {
+        let path = 'user/notifications/count';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPINotifications(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPINotifications(params) {
+        let path = 'user/notifications';
+        let httpParams = new HttpParams();
+        httpParams = (params?.read) ? httpParams.append('read', params?.read) : httpParams;
+        httpParams = (params?.withPaginate == 1) ? httpParams.append('withPaginate', params?.withPaginate) : httpParams;
+        httpParams = (params?.page > 0) ? httpParams.append('page', params?.page) : httpParams;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            //console.log(`[DooleService] getAPINotifications(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPINotificationRead(id) {
+        let path = `user/notification/read`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, id).pipe(map((res) => {
+            return res;
+        }));
+    }
+    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;
+        }));
+    }
+    setPushNotification(pushNotification) {
+        this.pushNotification = pushNotification;
+    }
+    getPushNotification() {
+        return this.pushNotification;
+    }
+    getAPIUserImage() {
+        let path = 'user/image';
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIgames(${path}) res: `, res);
+            return res;
+        }));
+    }
+    getAPIFormsByDate(params) {
+        let path = `rehabilify/sharedcareplan/forms`;
+        let httpParams = new HttpParams();
+        httpParams = (params?.date) ? httpParams.append('date', params.date) : httpParams;
+        httpParams = (params?.grouped_by_times) ? httpParams.append('grouped_by_times', params.grouped_by_times) : httpParams;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.get(endpoint, httpParams).pipe(map((res) => {
+            //console.log(`[DooleService] getAPIdietsByDate(${path}) res: `, res);
+            return res;
+        }));
+    }
+    postAPImedicalProcedures(params) {
+        let path = `user/medicalProcedures`;
+        const endpoint = this.api.getEndpoint(path);
+        return this.http.post(endpoint, params).pipe(map((res) => {
+            //console.log(`[DooleService] postAPIdrugIntake(${path}) res: `, res);
+            return res;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: DooleService, deps: [{ token: AuthenticationService }, { token: i2$1.FileTransfer }, { token: i3.File }, { token: HttpService }, { token: ApiEndpointsService }, { token: Events }, { token: i2.Platform }, { token: i6.Router }, { token: i2.AlertController }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: DooleService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: DooleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: AuthenticationService }, { type: i2$1.FileTransfer }, { type: i3.File }, { type: HttpService }, { type: ApiEndpointsService }, { type: Events }, { type: i2.Platform }, { type: i6.Router }, { type: i2.AlertController }] });
+
+class NavigationService {
+    constructor(router, location) {
+        this.router = router;
+        this.location = location;
+        this.history = [];
+        this.router.events.subscribe((event) => {
+            if (event instanceof NavigationEnd) {
+                //console.log("NavigationEnd", event.urlAfterRedirects);
+                this.history.push(event.urlAfterRedirects);
+            }
+        });
+    }
+    back() {
+        this.history.pop();
+        if (this.history?.length > 0)
+            this.location.back();
+        else
+            this.router.navigateByUrl("/home");
+    }
+    async close(modalCtrl) {
+        const modal = await modalCtrl?.getTop();
+        if (modal)
+            await modal.dismiss({ error: null });
+        else
+            this.back();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NavigationService, deps: [{ token: i6.Router }, { token: i2$2.Location }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NavigationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NavigationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i6.Router }, { type: i2$2.Location }] });
+
+class LanguageService {
+    constructor(translate) {
+        this.translate = translate;
+        this.languages = new Array();
+        this.languages.push({ name: 'Català', code: 'ca' }, { name: 'Español', code: 'es' }, { name: 'English', code: 'en' });
+    }
+    getLanguages() {
+        return this.languages;
+    }
+    changeLanguage(langCode) {
+        console.log("langCode", langCode);
+        this.translate.use(langCode);
+    }
+    getCurrent() {
+        let lang = this.translate.currentLang ? this.translate.currentLang : this.translate.getDefaultLang();
+        return lang;
+    }
+    getLanguageAPI() {
+        let lang = this.translate.currentLang ? this.translate.currentLang : this.translate.getDefaultLang();
+        return lang == 'es' ? 'cs' : lang;
+    }
+    setLenguageLocalstorage(language) {
+        this.changeLanguage(language);
+        localStorage.setItem('language', language);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LanguageService, deps: [{ token: i1$1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LanguageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LanguageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1$1.TranslateService }] });
+
+class DateService {
+    constructor(datePipe, translate) {
+        this.datePipe = datePipe;
+        this.translate = translate;
+        this.locale = this.getLocale();
+    }
+    getDateFormat() {
+        let lang = this.translate.currentLang;
+        let format = 'DD/MM/YY ';
+        if (lang === 'en')
+            format = 'MM/DD/YY ';
+        return format;
+    }
+    getDateFormat2() {
+        let lang = this.translate.currentLang;
+        let format = 'dd/MM/YY';
+        if (lang === 'en')
+            format = 'MM/dd/YY';
+        return format;
+    }
+    getDateFormat3() {
+        let lang = this.translate.currentLang;
+        let format = 'DD/MM/YYYY';
+        if (lang === 'en')
+            format = 'MM/DD/YYYY';
+        return format;
+    }
+    getLongFormat() {
+        let lang = this.translate.currentLang;
+        let format = 'dddd, MMM yyyy';
+        if (lang === 'en')
+            format = 'MMM, ddd yyyy';
+        return format;
+    }
+    getMonthViewDayHeader(date) {
+        let lang = this.translate.currentLang;
+        let days = ["D", "L", "M", "X", "J", "V", "S"];
+        if (lang === 'ca') {
+            days = ["DG", "DL", "DT", "DC", "DJ", "DV", "DS"];
+        }
+        else if (lang === 'en')
+            days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+        let num = date.getDay();
+        return days[num];
+    }
+    formatSelectedDate(date) {
+        if (date) {
+            let day = this.transformDate(date, this.getformatSelectedDate());
+            console.log("selected Day", day);
+            return day[0].toUpperCase() + day.slice(1);
+        }
+        return date;
+    }
+    getformatSelectedDate() {
+        let lang = this.translate.currentLang;
+        let format = 'EEEE, d MMMM';
+        if (lang === 'en')
+            format = 'MMMM d, EEEE';
+        return format;
+    }
+    getLocale() {
+        let lang = this.translate.currentLang;
+        let locale = 'es-ES';
+        if (lang === 'ca') {
+            locale = 'ca-ES';
+        }
+        else if (lang === 'en')
+            locale = 'en-US';
+        return locale;
+    }
+    getStartingDayWeek() {
+        let lang = this.translate.currentLang;
+        let day = '1';
+        if (lang == 'en')
+            day = '0';
+        return day;
+    }
+    getStartingDayMonth() {
+        let lang = this.translate.currentLang;
+        let day = 1;
+        if (lang == 'en')
+            day = 0;
+        return day;
+    }
+    ddMMy() {
+        let lang = this.translate.currentLang;
+        let format = 'dd/MM/y';
+        if (lang === 'en')
+            format = 'MM/dd/y';
+        return format;
+    }
+    getShortDateFormat() {
+        let lang = this.translate.currentLang;
+        let format = 'DD/MM/YY';
+        if (lang === 'en')
+            format = 'MM/DD/YY';
+        return format;
+    }
+    ddMMyyyyFormat(date) {
+        let lang = this.translate.currentLang;
+        let format = 'dd/MM/yyyy';
+        if (lang === 'en')
+            format = 'MM/dd/yyyy';
+        let day = this.transformDate(date, format);
+        return day[0].toUpperCase() + day.slice(1);
+    }
+    ddMMyFormat(date) {
+        let lang = this.translate.currentLang;
+        let format = 'dd MMM y';
+        if (lang === 'en')
+            format = 'MMM dd y';
+        let day = this.transformDate(date, format);
+        return day[0].toUpperCase() + day.slice(1);
+    }
+    ddMMMyyyformat(date) {
+        let lang = this.translate.currentLang;
+        let format = 'dd MMM yyy';
+        if (lang === 'en')
+            format = 'MMM dd yyy';
+        let day = this.transformDate(date, format);
+        return day[0].toUpperCase() + day.slice(1);
+    }
+    MMMMyyyyFormat(date) {
+        let format = 'MMMM yyyy';
+        let day = this.transformDate(date, format);
+        return day[0].toUpperCase() + day.slice(1);
+    }
+    getDayMonthYearFormat(date) {
+        let lang = this.translate.currentLang;
+        let format = 'EEEE, d MMMM YYYY';
+        if (lang === 'en')
+            format = 'MMMM, d EEEE YYYY';
+        let day = this.transformDate(date, format);
+        return day[0].toUpperCase() + day.slice(1);
+    }
+    selectedDateFormat(date) {
+        let lang = this.translate.currentLang;
+        let format = 'EEEE, d MMMM';
+        if (lang === 'en')
+            format = 'MMMM d, YYYY';
+        let day = this.transformDate(date, format);
+        return day[0].toUpperCase() + day.slice(1);
+    }
+    ddMMyyyyHHmm(date) {
+        let lang = this.translate.currentLang;
+        let format = 'dd/MM/yyyy HH:mm';
+        if (lang === 'en')
+            format = 'MM/dd/yyyy hh:mm a';
+        let day = this.transformDate(date, format);
+        return day[0].toUpperCase() + day.slice(1);
+    }
+    formatDateLongFormat(date) {
+        if (date) {
+            let day = this.transformDate(date, this.getLongDateFormat());
+            return day[0].toUpperCase() + day.slice(1);
+        }
+        return date;
+    }
+    yyyyMMddHHmm(date) {
+        if (date) {
+            let day = this.transformDate(date, this.yyyyMMddHHmmFormat());
+            console.log("selected Day", day);
+            return day[0].toUpperCase() + day.slice(1);
+        }
+        return date;
+    }
+    yyyyMMddHHmmFormat() {
+        let lang = this.translate.currentLang;
+        let format = 'yyyy-dd-MM HH:mm';
+        if (lang === 'en')
+            format = 'yyyy-MM-dd HH:mm a';
+        return format;
+    }
+    getLongDateFormat() {
+        let lang = this.translate.currentLang;
+        let format = 'EEEE, d MMMM yyyy, HH:mm';
+        if (lang === 'en')
+            format = 'MMMM, d yyyy, hh:mm a';
+        return format;
+    }
+    getDatetimeControlFormat() {
+        let lang = this.translate.currentLang;
+        let format = 'D MMM YYYY HH:mm';
+        if (lang === 'en')
+            format = 'MMM D YY hh:mm a';
+        return format;
+    }
+    getDayMonthFormat() {
+        let lang = this.translate.currentLang;
+        let format = 'd MMM';
+        if (lang === 'en')
+            format = 'MMM d';
+        return format;
+    }
+    getDayDotMonthFormat() {
+        let lang = this.translate.currentLang;
+        let format = 'd. MMM';
+        if (lang === 'en')
+            format = 'MMM. d';
+        return format;
+    }
+    getSelectedWeek(date) {
+        let lang = this.translate.currentLang;
+        let format = 'E d MMM';
+        if (lang === 'en')
+            format = 'MMM d, E';
+        let day = this.transformDate(date, format);
+        return day[0].toUpperCase() + day.slice(1);
+    }
+    getSelectedWeekFullDay(date) {
+        let lang = this.translate.currentLang;
+        let format = 'EEE d MMM';
+        if (lang === 'en')
+            format = 'MMM d, EEE';
+        let day = this.transformDate(date, format);
+        return day[0].toUpperCase() + day.slice(1);
+    }
+    formatDate(date) {
+        if (date) {
+            date = new Date(date);
+            if (this.isToday(date))
+                return this.datePipe.transform(date, this.getTimeFormat());
+            else {
+                let format = this.getDateFormat2();
+                return this.transformDate(date, format);
+            }
+        }
+        return date;
+    }
+    ddMMyyyy(date) {
+        let lang = this.translate.currentLang;
+        let format = 'dd-MM-yyyy';
+        if (lang === 'en')
+            format = 'MM-dd-yyyy';
+        let day = this.transformDate(date, format);
+        return day[0].toUpperCase() + day.slice(1);
+    }
+    highchartsDatesFornmat() {
+        let lang = this.translate.currentLang;
+        let format = {};
+        if (lang == 'en') {
+            // %b: Short month, like 'Jan',%e Day of the month, 1 through 31
+            format = {
+                millisecond: '%H:%M:%S.%L',
+                second: '%l:%M:%S %P',
+                minute: '%l:%M %p',
+                hour: '%l:%M %p',
+                day: '%b. %e',
+                week: '%b. %e',
+                month: '%b \'%y',
+                year: '%Y'
+            };
+        }
+        else {
+            format = {
+                millisecond: '%H:%M:%S.%L',
+                second: '%H:%M:%S',
+                minute: '%H:%M',
+                hour: '%H:%M',
+                day: '%e. %b',
+                week: '%e. %b',
+                month: '%b \'%y',
+                year: '%Y'
+            };
+        }
+        return format;
+    }
+    yyyyMMddFormat(date) {
+        console.log("DATE date: ", date);
+        let lang = this.translate.currentLang;
+        console.log("DATE lang: ", lang);
+        let format = 'yyyy-MM-dd';
+        if (lang == 'en')
+            format = 'yyyy-dd-MM';
+        console.log("DATE format: ", format);
+        let day = this.transformDate(date, format);
+        console.log("DATE day: ", day);
+        return day[0].toUpperCase() + day.slice(1);
+    }
+    yyyyMMddTHHmmssSSSZFormat(date) {
+        const fechaFormateada = this.datePipe.transform(date, 'yyyy-MM-ddTHH:mm:ss.SSS\'Z\'');
+        return fechaFormateada;
+    }
+    convert12to24format(time) {
+        console.log("TIME 12to24: ", time);
+        var hours = Number(time.match(/^(\d+)/)[1]);
+        var minutes = Number(time.match(/:(\d+)/)[1]);
+        var AMPM = time.match(/\s(.*)$/)[1];
+        if (AMPM == "PM" && hours < 12)
+            hours = hours + 12;
+        if (AMPM == "AM" && hours == 12)
+            hours = hours - 12;
+        var sHours = hours.toString();
+        var sMinutes = minutes.toString();
+        if (hours < 10)
+            sHours = "0" + sHours;
+        if (minutes < 10)
+            sMinutes = "0" + sMinutes;
+        let h = sHours + ":" + sMinutes;
+        console.log("HOURS: ", h);
+        return h;
+    }
+    format24h(time) {
+        let lang = this.translate.currentLang;
+        if (lang === 'en') {
+            // Check correct time format and split into components
+            time = time.toString().match(/^([01]\d|2[0-3])(:)([0-5]\d)(:[0-5]\d)?$/) || [time];
+            if (time.length > 1) { // If time format correct
+                time = time.slice(1); // Remove full string match value
+                time[5] = +time[0] < 12 ? ' AM' : ' PM'; // Set AM/PM
+                time[0] = +time[0] % 12 || 12; // Adjust hours
+            }
+            return time.join(''); // return adjusted time or original string
+        }
+        return time;
+    }
+    isAmericanFormat() {
+        return this.translate.currentLang === 'en';
+    }
+    getTimeFormat() {
+        let lang = this.translate.currentLang;
+        let format = 'HH:mm';
+        if (lang === 'en')
+            format = 'hh:mm a';
+        return format;
+    }
+    isToday(mDate) {
+        let date = new Date();
+        if (date.getDate() === mDate.getDate() && date.getMonth() === mDate.getMonth() && date.getFullYear() === mDate.getFullYear())
+            return true;
+        return false;
+    }
+    transformDate(date, format) {
+        const datePipe = new DatePipe(this.getLocale());
+        return datePipe.transform(date, format);
+    }
+    getCalendarDay(epoch) {
+        if (!epoch) {
+            return null;
+        }
+        let timeString = 'h:mm A';
+        const today = this.translate.instant('agenda.today');
+        const yesterday = this.translate.instant('agenda.yesterday');
+        return moment(epoch).calendar(null, {
+            sameDay: `[${today}] ` + timeString,
+            lastDay: `[${yesterday}] ` + timeString,
+            lastWeek: 'DD/MM/YY ' + timeString,
+            sameElse: 'DD/MM/YY ' + timeString,
+            nextDay: 'DD/MM/YY ' + timeString,
+        });
+    }
+    getCalendarDay2(epoch) {
+        if (!epoch) {
+            return null;
+        }
+        let timeString = this.getTimeFormat();
+        let dateString = this.getShortDateFormat();
+        const today = this.translate.instant('agenda.today');
+        const yesterday = this.translate.instant('agenda.yesterday');
+        return moment(epoch).calendar(null, {
+            sameDay: `[${today}]  ` + timeString,
+            lastDay: `[${yesterday}]  ` + timeString,
+            sameElse: dateString + ' ' + timeString,
+            lastWeek: dateString + ' ' + timeString,
+            nextDay: dateString + ' ' + timeString
+        });
+    }
+    getCalendarDayTime(epoch) {
+        if (!epoch) {
+            return null;
+        }
+        let timeString = this.getTimeFormat();
+        let dateString = this.getLongFormat();
+        let lang = this.translate.currentLang;
+        const today = this.translate.instant('agenda.today');
+        const yesterday = this.translate.instant('agenda.yesterday');
+        const to = this.translate.instant('agenda.to');
+        const m = moment;
+        m.locale(lang);
+        return m(epoch).calendar(null, {
+            sameDay: `[${today}]  ` + `[${to}]  ` + timeString,
+            lastDay: `[${yesterday}]  ` + `[${to}]  ` + timeString,
+            sameElse: dateString + ' ' + `[${to}]  ` + timeString,
+            lastWeek: dateString + ' ' + `[${to}]  ` + timeString,
+            nextDay: dateString + ' ' + `[${to}]  ` + timeString
+        });
+    }
+    // return epoch string as specified format
+    formatEpoch(epoch) {
+        return this.getCalendarDay(epoch);
+    }
+    getToday() {
+        const tzoffset = (new Date()).getTimezoneOffset() * 60000; // offset in milliseconds
+        const localISOTime = (new Date(Date.now() - tzoffset)).toISOString().slice(0, -1);
+        let date = localISOTime; // this.dateService.selectedDateFormat(localISOTime);
+        return date;
+    }
+    getCurrentTime() {
+        const tzoffset = (new Date()).getTimezoneOffset() * 60000; // offset in milliseconds
+        const localISOTime = (new Date(Date.now() - tzoffset)).toISOString().slice(0, -1);
+        let date = localISOTime; // this.dateService.selectedDateFormat(localISOTime);
+        return new Date(Date.now() - tzoffset).getTime().toLocaleString();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: DateService, deps: [{ token: i2$2.DatePipe }, { token: i1$1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: DateService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: DateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i2$2.DatePipe }, { type: i1$1.TranslateService }] });
+
+highchartsMore(HighCharts);
+class HighchartsService {
+    constructor(languageService) {
+        this.languageService = languageService;
+        this.weekdaysES = ['Domingo', 'Lunes', 'Martes', 'Miercoles', 'Jueves', 'Viernes', 'Sábado'];
+        this.weekdaysCA = ['Diumenge', 'Dilluns', 'Dimarts', 'Dimecres', 'Dijous', 'Divendres', 'Dissabte'];
+        this.graphData = [];
+        this.series = [];
+        this.withTooltip = false;
+        this.scrollMinWidth = 550;
+    }
+    setTitle(title) {
+        this.title = title;
+    }
+    setUnits(units) {
+        this.units = units;
+    }
+    setLocale() {
+        return this.languageService.getCurrent();
+    }
+    setPointWidth(interval) {
+        switch (interval) {
+            case '1d':
+                return 12;
+            case '1w':
+                return 12;
+            case '1m':
+                return 8;
+            case '1y':
+                return 12;
+            default:
+                return 20;
+        }
+    }
+    setScrollMinWidth(interval) {
+        switch (interval) {
+            case '1d':
+                this.scrollMinWidth = 600;
+                break;
+            case '1w':
+                this.scrollMinWidth = 500;
+                break;
+            case '1m':
+                this.scrollMinWidth = 600;
+                break;
+            case '1y':
+                this.scrollMinWidth = 500;
+                break;
+            default:
+                this.scrollMinWidth = 500;
+                break;
+        }
+    }
+    addTooltip(interval) {
+        switch (interval) {
+            case '1d':
+                this.withTooltip = false;
+                break;
+            case '1w':
+                this.withTooltip = false;
+                break;
+            case '1m':
+                this.withTooltip = true;
+                break;
+            case '1y':
+                this.withTooltip = false;
+                break;
+            default:
+                this.withTooltip = false;
+                break;
+        }
+    }
+    getWeekday() {
+        return (this.setLocale() == 'es') ? this.weekdaysES : this.weekdaysCA;
+    }
+    setSeries(name, data, pointWidth, lineWidth, color, colorKey, colorByPoint) {
+        const serie_name = name ? name : this.units;
+        const serie_data = (data && data.length > 0) ? data : this.graphData;
+        const serie_pointWidth = pointWidth ? pointWidth : this.pointWidth;
+        const serie_colorByPoint = colorByPoint ? true : false;
+        let serie = { name: serie_name, data: serie_data, pointWidth: serie_pointWidth, colorByPoint: serie_colorByPoint };
+        //if (pointWidth != undefined) serie['pointWidth'] = pointWidth
+        if (lineWidth)
+            serie['lineWidth'] = lineWidth;
+        if (color)
+            serie['color'] = color;
+        if (colorKey)
+            serie['colorKey'] = colorKey;
+        this.series = [];
+        this.series.push(serie);
+    }
+    // type: this.typeChart,
+    // maxRange: this.min.getTime(),
+    // categories: this.withTooltip? this.graphDates: null
+    setXAxis(type, categories, maxRange) {
+        this.xAxis = { type: type, maxRange: maxRange, categories: categories, crosshair: true };
+    }
+    setYAxis(minY, maxY, ranges, text) {
+        console.log('[ActivityGoalPage] generateChart() maxY: ', maxY);
+        //Solo para HPC requieren que el valor mínimo de gráfica sea 0, aquí valido que si no hay valores negativos se el minY = 0;
+        const y_min = minY; // (minY > 0) ? 0 : minY;
+        const y_max = (maxY) ? maxY : this.maxY;
+        const y_title = { text: text, align: 'high' };
+        this.yAxis = { min: y_min, max: y_max, alignTicks: false, tickInterval: null, startOnTick: false, title: y_title, opposite: true, plotBands: ranges };
+    }
+    setMinY(valuesA, valuesB) {
+        if (valuesA && valuesB && valuesB.length > 0) {
+            const A = Math.min.apply(null, valuesA);
+            const B = Math.min.apply(null, valuesB);
+            this.minY = A > B ? B : A;
+            return this.minY;
+        }
+        else {
+            this.minY = Math.min.apply(null, valuesA);
+            return this.minY;
+        }
+    }
+    setMaxY(valuesA, valuesB) {
+        if (valuesA && valuesB && valuesB.length > 0) {
+            const A = Math.max.apply(null, valuesA);
+            const B = Math.max.apply(null, valuesB);
+            this.maxY = A > B ? A : B;
+            return this.maxY;
+        }
+        else {
+            this.maxY = Math.max.apply(null, valuesA);
+            return this.maxY;
+        }
+    }
+    getOptionsChart(graphBaseOn) {
+        //console.log('[ActivityGoalPage] generateChart() graphBaseOn: ', graphBaseOn);
+        let charts; //= HighCharts
+        switch (graphBaseOn) {
+            case 'avg':
+                //charts.chart('container', {
+                charts = {
+                    chart: {
+                        renderTo: 'container',
+                        type: 'column',
+                        zoomType: 'x',
+                        scrollablePlotArea: {
+                            minWidth: this.scrollMinWidth,
+                            scrollPositionX: 1
+                        }
+                    },
+                    title: {
+                        text: this.title
+                    },
+                    xAxis: this.xAxis,
+                    yAxis: this.yAxis,
+                    rangeSelector: {
+                        enabled: true
+                    },
+                    plotOptions: {
+                        series: {
+                            allowPointSelect: true,
+                            borderWidth: 1,
+                            dataLabels: {
+                                enabled: true,
+                                format: '{point.y}'
+                            },
+                        }
+                    },
+                    legend: {
+                        enabled: false
+                    },
+                    credits: {
+                        enabled: false
+                    },
+                    series: this.series,
+                    tooltip: {
+                        valueSuffix: ` ${this.units}`
+                    },
+                    lang: {
+                        weekdays: this.getWeekday()
+                    }
+                };
+                //);
+                break;
+            case 'range':
+                //charts.chart('container', {
+                charts = {
+                    chart: {
+                        renderTo: 'container',
+                        type: 'arearange',
+                        zoomType: 'x',
+                        scrollablePlotArea: {
+                            minWidth: this.scrollMinWidth,
+                            scrollPositionX: 1
+                        }
+                    },
+                    title: {
+                        text: this.title
+                    },
+                    xAxis: this.xAxis,
+                    yAxis: this.yAxis,
+                    legend: {
+                        enabled: false
+                    },
+                    credits: {
+                        enabled: false
+                    },
+                    series: this.series,
+                    tooltip: {
+                        valueSuffix: ` ${this.units}`
+                    },
+                    lang: {
+                        weekdays: this.getWeekday()
+                    }
+                };
+                //);
+                break;
+            case 'lasValue': //barra o punto valor de 0 al inicio
+            default:
+                //charts.chart('container', {
+                charts = {
+                    chart: {
+                        renderTo: 'container',
+                        type: 'column',
+                        zoomType: 'x',
+                        scrollablePlotArea: {
+                            minWidth: this.scrollMinWidth,
+                            scrollPositionX: 1
+                        }
+                    },
+                    title: {
+                        text: this.title
+                    },
+                    xAxis: this.xAxis,
+                    yAxis: this.yAxis,
+                    rangeSelector: {
+                        enabled: true
+                    },
+                    plotOptions: {
+                        series: {
+                            allowPointSelect: true,
+                            borderWidth: 1,
+                            dataLabels: {
+                                enabled: true,
+                                format: '{point.y}'
+                            },
+                        }
+                    },
+                    legend: {
+                        enabled: false
+                    },
+                    credits: {
+                        enabled: false
+                    },
+                    series: this.series,
+                    tooltip: {
+                        valueSuffix: ` ${this.units}`
+                    },
+                    lang: {
+                        weekdays: this.getWeekday()
+                    }
+                };
+                //);
+                break;
+        }
+        if (this.withTooltip) {
+            let tool = `<table><tr><th colspan="1">{point.key} ${this.extraTooltip}</th></tr>`; //
+            HighCharts.setOptions({
+                tooltip: {
+                    headerFormat: tool,
+                },
+            });
+        }
+        return charts;
+    }
+    groupByCategory(interval, element) {
+        //console.log('[HighchartsService] groupByCategory ', element.date_value);
+        let elementDate = new Date(element.date_value);
+        let groupByDate = "";
+        let tooltip = "";
+        //console.log('[HighchartsService] groupByCategory ', element.date_value);
+        switch (interval) {
+            case '1d': // group by day
+                let hour = element.date?.split(' ')[1];
+                groupByDate = hour;
+                // let isAllValue = (this.graphBaseOn == 'lasValue' || this.graphBaseOn == 'range')? true:false
+                // groupByDate = isAllValue? hour : hour.split(':')[0] + ':' + hour.split(':')[1];
+                tooltip = moment(elementDate, "YYYY-MM-DD").locale('es').date() + '/' + elementDate.toLocaleString(this.returnShortDate(), { month: 'short' }) + '/' + elementDate.getFullYear() + ' ' + groupByDate;
+                break;
+            case '1w':
+                let date = this.formatSelectedDate(element.date_value);
+                let day = date.toLocaleString(this.returnShortDate(), { weekday: 'short' });
+                groupByDate = this.titleCase(day) + ' ' + this.formatSelectedDate2(element.date_value, 'd');
+                tooltip = moment(elementDate, "YYYY-MM-DD").locale('es').date() + '/' + elementDate.toLocaleString(this.returnShortDate(), { month: 'short' }) + '/' + elementDate.getFullYear();
+                break;
+            case '1m':
+                //let month = elementDate.toLocaleString('es-ES', { month: 'short' });
+                groupByDate = this.formatSelectedDate2(element.date_value, 'd'); //+ ' ' + month
+                tooltip = moment(elementDate, "YYYY-MM-DD").locale('es').date() + '/' + elementDate.toLocaleString(this.returnShortDate(), { month: 'short' }) + '/' + elementDate.getFullYear();
+                break;
+            case '1y':
+                let month = new Date();
+                month.setMonth(Number(element.date_value) - 1);
+                groupByDate = month.toLocaleString(this.returnShortDate(), { month: 'short' });
+                groupByDate = this.titleCase(groupByDate);
+                tooltip = month.toLocaleString(this.returnShortDate(), { month: 'short' }) + '/' + month.getFullYear();
+                break;
+            default:
+                break;
+        }
+        return { groupByDate: groupByDate, tooltip: tooltip };
+    }
+    returnShortDate() {
+        const idioma = this.setLocale();
+        switch (idioma) {
+            case 'es':
+                return 'es-ES';
+            case 'en':
+                return 'en-US';
+            case 'ca':
+                return 'ca-ES';
+            case 'fr':
+                return 'fr-FR';
+            default:
+                return idioma;
+        }
+    }
+    formatSelectedDate2(d, format) {
+        var auxdate = d.split(' ');
+        d = d.replace(' ', 'T');
+        let date0 = new Date(d).toUTCString();
+        let date = new Date(date0);
+        let time = auxdate[1];
+        date.setHours(time.substring(0, 2));
+        date.setMinutes(time.substring(3, 5));
+        let language = this.languageService.getCurrent();
+        const datePipe = new DatePipe('en');
+        return datePipe.transform(date, format);
+    }
+    formatSelectedDate(d) {
+        var auxdate = d.split(' ');
+        d = d.replace(' ', 'T');
+        let date0 = new Date(d).toUTCString();
+        let date = new Date(date0);
+        let time = auxdate[1];
+        date.setHours(time.substring(0, 2));
+        date.setMinutes(time.substring(3, 5));
+        return date;
+    }
+    titleCase(word) {
+        return word.charAt(0).toUpperCase() + word.slice(1);
+    }
+    getGroupedData(json, interval, withoToltip) {
+        let withTooltip = false;
+        let tooltip = [];
+        let groupData;
+        let groups = [];
+        let valuesA = [];
+        let valuesB = [];
+        let datesA = [];
+        let graphData = [];
+        let graphBaseOn = json.graphBaseOn;
+        this.graphBaseOn = json.graphBaseOn;
+        switch (graphBaseOn) {
+            case 'average':
+            case 'avg':
+                groups = json.values.reduce((groups, element) => {
+                    const value = Number(element.avg);
+                    const group = this.groupByCategory(interval, element);
+                    // If date doesn't exist in array, then create it
+                    if (!groups[group.groupByDate]) {
+                        groups[group.groupByDate] = [];
+                        groups[group.groupByDate].value = 0;
+                    }
+                    groups[group.groupByDate].value += value;
+                    groups[group.groupByDate].tooltip = group.tooltip;
+                    return groups;
+                }, {});
+                //console.log('[HighchartsService] rangeGraph', groups); 
+                Object.keys(groups).map((date) => {
+                    datesA.push(date);
+                    valuesA.push(groups[date].value);
+                    // if(withTooltip)
+                    //   graphData.push({y: groups[date].total, tooltip: groups[date].tooltip});
+                    // else
+                    if (withTooltip)
+                        tooltip.push(groups[date].tooltip);
+                    graphData.push([date, groups[date].value]);
+                });
+                //console.log('[HighchartsService] graphData', graphData);
+                groupData = { dates: datesA, valuesA: valuesA, graphData: graphData };
+                break;
+            case 'range':
+                groups = json.values.reduce((groups, element) => {
+                    const valueMax = Number(element.max);
+                    const valueMin = Number(element.min);
+                    const group = this.groupByCategory(interval, element);
+                    // If date doesn't exist in array, then create it
+                    if (!groups[group.groupByDate]) {
+                        groups[group.groupByDate] = [];
+                        groups[group.groupByDate].valueMax = 0;
+                        groups[group.groupByDate].valueMin = 0;
+                    }
+                    groups[group.groupByDate].valueMax += valueMax;
+                    groups[group.groupByDate].valueMin += valueMin;
+                    groups[group.groupByDate].tooltip = group.tooltip;
+                    return groups;
+                }, {});
+                //console.log('[HighchartsService] rangeGraph', groups); 
+                Object.keys(groups).map((date) => {
+                    datesA.push(date);
+                    valuesA.push(groups[date].valueMax);
+                    valuesB.push(groups[date].valueMin);
+                    // if(withTooltip)
+                    //   graphData.push({y: groups[date].total, tooltip: groups[date].tooltip});
+                    // else
+                    if (withTooltip)
+                        tooltip.push(groups[date].tooltip);
+                    graphData.push([date, groups[date].valueMin, groups[date].valueMax]);
+                });
+                //console.log('[HighchartsService] graphData', graphData);
+                groupData = { dates: datesA, valuesA: valuesA, valuesB: valuesB, graphData: graphData };
+                break;
+            case 'sum':
+                groups = json.values.reduce((groups, element) => {
+                    const value = Number(element.value);
+                    const group = this.groupByCategory(interval, element);
+                    // If date doesn't exist in array, then create it
+                    if (!groups[group.groupByDate]) {
+                        groups[group.groupByDate] = [];
+                        groups[group.groupByDate].value = 0;
+                    }
+                    groups[group.groupByDate].value += value;
+                    groups[group.groupByDate].tooltip = group.tooltip;
+                    return groups;
+                }, {});
+                //console.log('[HighchartsService] rangeGraph', groups); 
+                Object.keys(groups).map((date) => {
+                    datesA.push(date);
+                    valuesA.push(groups[date].value);
+                    // if(withTooltip)
+                    //   graphData.push({y: groups[date].total, tooltip: groups[date].tooltip});
+                    // else
+                    if (withTooltip)
+                        tooltip.push(groups[date].tooltip);
+                    graphData.push([date, groups[date].value]);
+                });
+                //console.log('[HighchartsService] graphData', graphData);
+                groupData = { dates: datesA, valuesA: valuesA, graphData: graphData };
+                break;
+            case 'lasValue':
+            default:
+                json.values.forEach(element => {
+                    const value = Number(element.value);
+                    const group = this.groupByCategory(interval, element);
+                    // If date doesn't exist in array, then create it
+                    // Con este codigo solo se hace sumatoria de los pasos en los dias. los demas atributos solo muestra el ultimo valor
+                    if (element.element_id !== 38) { //aca es 38
+                        if (!groups[group.groupByDate]) {
+                            groups[group.groupByDate] = [];
+                            groups[group.groupByDate].value = value;
+                            groups[group.groupByDate].tooltip = group.tooltip;
+                        }
+                        //  }
+                    }
+                    else {
+                        groups[group.groupByDate].value += value;
+                        groups[group.groupByDate].tooltip = group.tooltip;
+                    }
+                });
+                /* if (!groups[group.groupByDate]) {
+                   groups[group.groupByDate] = [];
+                   groups[group.groupByDate].value = 0;
+                 }
+                 groups[group.groupByDate].value += value;
+                 groups[group.groupByDate].tooltip = group.tooltip
+               })*/
+                //console.log('[HighchartsService] rangeGraph', groups); 
+                Object.keys(groups).map((date) => {
+                    datesA.push(date);
+                    valuesA.push(groups[date].value);
+                    // if(withTooltip)
+                    //   graphData.push({y: groups[date].total, tooltip: groups[date].tooltip});
+                    // else
+                    if (withTooltip)
+                        tooltip.push(groups[date].tooltip);
+                    graphData.push([date, groups[date].value]);
+                });
+                //console.log('[HighchartsService] graphData', graphData);
+                groupData = { dates: datesA, valuesA: valuesA, graphData: graphData };
+                break;
+        }
+        return groupData;
+    }
+    getRanges(element, min, max) {
+        let normalValue = [];
+        let outRangeValue = [];
+        let dangerValue = [];
+        let value = [];
+        let ranges = element.ranges;
+        ranges.forEach(range => {
+            var r = [];
+            var color;
+            /*
+            * No toma en cuenta los decimales con coma (,)
+            */
+            range.value1 = parseFloat(range.value1?.replace(",", "."));
+            range.value2 = parseFloat(range.value2?.replace(",", "."));
+            if (range.rangeCondition == '>' || range.rangeCondition == '=>') {
+                r["from"] = range.value1;
+                //const maxValue = this.getMaxRange(range.value1, max) ;
+                //console.log('[ActivityGoalPage] maxValue ', maxValue);
+                r["to"] = this.getMaxRange(range.value1, max);
+            }
+            if (range.rangeCondition == '<' || range.rangeCondition == '<=') {
+                r["from"] = min;
+                r["to"] = range.value1;
+            }
+            if (range.rangeCondition == 'a<x<b') {
+                r["from"] = range.value1;
+                r["to"] = range.value2;
+            }
+            if (range.rangeType == "success")
+                color = 'rgba(96, 173, 121, 0.1)';
+            else if (range.rangeType == "warning")
+                color = 'rgba(245, 157, 24, 0.1)'; //'rgb(243, 156, 18, 0.1)'
+            else if (range.rangeType == "danger")
+                color = 'rgba(245, 46, 24, 0.1)'; //'rgb(231, 76, 60, 0.1)'
+            r["color"] = color;
+            value.push(r);
+            if (range.rangeType === "success") {
+                normalValue.push(range.conditionString);
+            }
+            else if (range.rangeType == "warning") {
+                outRangeValue.push(range.conditionString);
+            }
+            else if (range.rangeType == "danger") {
+                dangerValue.push(range.conditionString);
+            }
+        });
+        if (value?.length > 0) {
+            let rangesElement = {
+                name: element.name,
+                description: element.description,
+                value: value,
+                normalValue: normalValue,
+                outRangeValue: outRangeValue,
+                dangerValue: dangerValue
+            };
+            console.log('[ActivityGoalPage] getRanges() ranges: ', rangesElement);
+            return rangesElement;
+        }
+        else
+            return undefined;
+    }
+    //Aqui se setea el valor max en Y sumando el rango máximo y valor máximo ingresado divdido entre 2
+    getMaxRange(rangeMax, max) {
+        let value1 = Number(rangeMax);
+        let value2 = Number(max);
+        if (value2 <= value1)
+            this.maxY = value1 + value2 / 2;
+        else
+            this.maxY = value2;
+        return this.maxY;
+    }
+    setHighchartsOptions(json, params) {
+        let opt = json?.graphBaseOn;
+        let interval = params.interval;
+        let name = json?.name;
+        let typeChart = '';
+        let valuesA = [];
+        let valuesB = [];
+        let datesA = [];
+        let graphData = [];
+        let ranges;
+        let minY;
+        let maxY;
+        let pointWidth = 20;
+        let units = json?.units;
+        this.units = json.units;
+        const data = this.getGroupedData(json, interval);
+        graphData = data?.graphData;
+        valuesA = data?.valuesA;
+        valuesB = data?.valuesB;
+        datesA = data?.dates;
+        minY = this.setMinY(valuesA, valuesB);
+        maxY = this.setMaxY(valuesA, valuesB);
+        ranges = this.getRanges(json, minY, maxY);
+        this.ranges = ranges;
+        pointWidth = this.setPointWidth(interval);
+        console.log("* valuesA: ", valuesA);
+        console.log("* valuesB: ", valuesB);
+        console.log("* dates: ", datesA);
+        console.log("* graphic: ", graphData);
+        switch (opt) {
+            case 'range':
+                typeChart = 'arearange';
+                break;
+            case 'sum':
+            case 'avg':
+            case 'lasValue':
+            default:
+                typeChart = 'category';
+                break;
+        }
+        this.setXAxis(typeChart, datesA);
+        this.setYAxis(minY, maxY, ranges, units);
+        this.setSeries(name, graphData, pointWidth);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: HighchartsService, deps: [{ token: LanguageService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: HighchartsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: HighchartsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: LanguageService }] });
+
+class ComponentsApp {
+    constructor(goal, advices, news, agenda, reminder, diet, drug, game, element, form, chat, doc_diagnostic, contacta) {
+        this.goal = goal;
+        this.advices = advices;
+        this.news = news;
+        this.agenda = agenda;
+        this.reminder = reminder;
+        this.diet = diet;
+        this.drug = drug;
+        this.game = game;
+        this.element = element;
+        this.form = form;
+        this.chat = chat;
+        this.doc_diagnostic = doc_diagnostic;
+        this.contacta = contacta;
+    }
+}
+class RolesService {
+    constructor() {
+        this.setProfessional(false);
+        this.activatedAllComponents(true);
+        //this.customAllComponents(true,false,true,false,false,false,false,true,true,true,true, false, true)
+    }
+    activatedAllComponents(enable) {
+        this.component = new ComponentsApp(enable, enable, enable, enable, enable, enable, enable, enable, enable, enable, enable, enable, enable);
+    }
+    customAllComponents(goal, advices, news, agenda, reminder, diet, drug, game, element, form, chat, doc_diagnostic, contacta) {
+        this.component = new ComponentsApp(goal, advices, news, agenda, reminder, diet, drug, game, element, form, chat, doc_diagnostic, contacta);
+    }
+    setProfessional(professional) {
+        this.isProfessional = professional ? true : false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: RolesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: RolesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: RolesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+class StorageService {
+    constructor() {
+        Preferences.migrate();
+    }
+    saveFirstTimeLoad(val) {
+        Preferences.set({ key: 'firstTime', value: val });
+    }
+    saveFirstTimeLoad2(val) {
+        Preferences.set({ key: 'firstTime2', value: val });
+    }
+    async isFirstTimeLoad() {
+        const result = await Preferences.get({ key: 'firstTime' });
+        if (result == null) { //si no hay valor previo
+            return true; //retornamos true
+        }
+        return JSON.parse(result.value);
+    }
+    async isFirstTimeLoad2() {
+        const result = await Preferences.get({ key: 'firstTime2' });
+        if (result == null) { //si no hay valor previo
+            return true; //retornamos true
+        }
+        return JSON.parse(result.value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: StorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: StorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: StorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+var NotificationsType;
+(function (NotificationsType) {
+    NotificationsType["ADVICES"] = "advices";
+    NotificationsType["AGENDA"] = "agenda";
+    NotificationsType["COMMUNICATIONS"] = "communications";
+    NotificationsType["DIETS"] = "diets";
+    NotificationsType["EXERCISES"] = "exercises";
+    NotificationsType["FORMS"] = "forms";
+    NotificationsType["GAMES"] = "games";
+    NotificationsType["GOALS"] = "goals";
+    NotificationsType["MEDICATIONS"] = "medication_plans";
+    NotificationsType["MESSAGES"] = "messages";
+    NotificationsType["NEWS"] = "news";
+    NotificationsType["OFFERS"] = "offers";
+    NotificationsType["PROMOTE_CONTENT"] = "promote-content";
+    NotificationsType["PROCEDURES"] = "medical_procedures";
+    NotificationsType["REMINDERS"] = "reminder";
+    //Shared care plan
+    NotificationsType["MONITORING"] = "monitoring";
+    NotificationsType["INFORMED_CONSENT"] = "informed_consent";
+    NotificationsType["LIFE_STILE_HABITS"] = "life_style_habits";
+    NotificationsType["SHARED_CARE_PLAN"] = "shared_care_plan";
+    NotificationsType["AddButtonMedicalTest"] = "add_document";
+    NotificationsType["TESTIMONIALS"] = "testimonials";
+    NotificationsType["AddButtonTodayDrug"] = "drugs-detail";
+    NotificationsType["AddButtonHealthCharts"] = "activity-goal";
+})(NotificationsType || (NotificationsType = {}));
+var NotificationsTypeBO;
+(function (NotificationsTypeBO) {
+    NotificationsTypeBO["ADVICES"] = "App\\Advice";
+    NotificationsTypeBO["AGENDA"] = "App\\Agenda";
+    NotificationsTypeBO["CHALLENGE_LEVEL"] = "App\\LevelAccomplishment";
+    NotificationsTypeBO["DIAGNOSTIC_TEST"] = "App\\DiagnosticTest";
+    NotificationsTypeBO["DIETS"] = "App\\Diet";
+    NotificationsTypeBO["DRUG"] = "App\\DrugIntake";
+    NotificationsTypeBO["EXERCISES"] = "App\\Exercise";
+    NotificationsTypeBO["FORMS"] = "App\\FormAnswer";
+    NotificationsTypeBO["GAMES"] = "App\\Game";
+    NotificationsTypeBO["GAME_PLAY"] = "App\\GamePlay";
+    //GOALS = "App\\Goalable",
+    NotificationsTypeBO["MEDICAL_PROCEDURE"] = "App\\MedicalProcedure";
+    NotificationsTypeBO["MEDICATIONS"] = "App\\MedicationPlan";
+    NotificationsTypeBO["MESSAGES"] = "App\\Message";
+    NotificationsTypeBO["NEWS"] = "App\\News";
+    NotificationsTypeBO["PROGRAMABLE_PLAY"] = "App\\ProgramablePlay";
+    NotificationsTypeBO["REMINDERS"] = "App\\Reminder";
+    NotificationsTypeBO["REMINDERS_EXECUTION"] = "App\\ReminderExecution";
+    NotificationsTypeBO["SHARED_CARE_PLAN"] = "App\\ShareCarePlan";
+})(NotificationsTypeBO || (NotificationsTypeBO = {}));
+var NOTIFICATIONS_TYPE_BO;
+(function (NOTIFICATIONS_TYPE_BO) {
+    NOTIFICATIONS_TYPE_BO["AGENDA"] = "App\\Notifications\\AgendaCreated";
+    NOTIFICATIONS_TYPE_BO["APPOINTMENTS_VISIT"] = "App\\Notifications\\VisitOnlineNotification";
+    NOTIFICATIONS_TYPE_BO["ADVICES"] = "App\\Notifications\\AdviceCreated";
+    NOTIFICATIONS_TYPE_BO["CHALLENGE_LEVEL"] = "App\\Notifications\\LevelAccomplishmentCompletedNotification";
+    NOTIFICATIONS_TYPE_BO["DIETS"] = "App\\Notifications\\DietCreated";
+    NOTIFICATIONS_TYPE_BO["DRUG"] = "App\\Notifications\\DrugIntakeTime";
+    NOTIFICATIONS_TYPE_BO["EXERCISES"] = "App\\Notifications\\ExerciseCreated";
+    NOTIFICATIONS_TYPE_BO["EXERCISES_PLAY"] = "App\\Notifications\\ExercisePlaySchedule";
+    NOTIFICATIONS_TYPE_BO["FORMS"] = "App\\Notifications\\FormAnswerSchedule";
+    NOTIFICATIONS_TYPE_BO["GAMES"] = "App\\Notifications\\GamePlaySchedule";
+    NOTIFICATIONS_TYPE_BO["MESSAGES"] = "App\\Notifications\\MessageNotification";
+    NOTIFICATIONS_TYPE_BO["NEWS"] = "App\\Notifications\\NewsNotification";
+    NOTIFICATIONS_TYPE_BO["REMINDERS"] = "App\\Notifications\\ReminderTime";
+    NOTIFICATIONS_TYPE_BO["SHARED_CARE_PLAN"] = "App\\Notifications\\SharedCarePlanAddContentNotification";
+    // MEDICATIONS = "",
+    // GOALS =  "",
+    // MEDICAL_PROCEDURE = "",
+    // DIAGNOSTIC_TEST = "",
+    // PROGRAMABLE_PLAY = "",
+})(NOTIFICATIONS_TYPE_BO || (NOTIFICATIONS_TYPE_BO = {}));
+var NotificationsTypeColor;
+(function (NotificationsTypeColor) {
+    NotificationsTypeColor["ADVICES"] = "#2356f9";
+    NotificationsTypeColor["AGENDA"] = "#6950ce";
+    NotificationsTypeColor["CHALLENGE_LEVEL"] = "#BDC3C7";
+    NotificationsTypeColor["DIAGNOSTIC_TEST"] = "#1A8E92";
+    NotificationsTypeColor["DIETS"] = "#E67E22";
+    NotificationsTypeColor["DRUG"] = "#5AC445";
+    NotificationsTypeColor["EXERCISES"] = "#f53d3d";
+    NotificationsTypeColor["FORMS"] = "#2356f9";
+    NotificationsTypeColor["GAMES"] = "#9B59B6";
+    NotificationsTypeColor["GAME_PLAY"] = "#9B59B6";
+    //GOALS = '#1A8E92',
+    NotificationsTypeColor["MEDICAL_PROCEDURE"] = "#EC7579";
+    NotificationsTypeColor["MEDICATIONS"] = "#25CAD0";
+    NotificationsTypeColor["MESSAGES"] = "#25CAD0";
+    NotificationsTypeColor["NEWS"] = "#2356f9";
+    NotificationsTypeColor["PROGRAMABLE_PLAY"] = "#7F8C8D";
+    NotificationsTypeColor["REMINDERS"] = "#6950ce";
+    NotificationsTypeColor["REMINDERS_EXECUTION"] = "#6950ce";
+    NotificationsTypeColor["SHARED_CARE_PLAN"] = "#BA0186";
+})(NotificationsTypeColor || (NotificationsTypeColor = {}));
+class NotificationOptions {
+    constructor() {
+        this.agenda = { type: NotificationsType.AGENDA, mail: 'agendaNotificationMail', app: 'agendaNotificationApp', old: null };
+        this.reminder = { type: NotificationsType.REMINDERS, mail: 'reminderNotificationMail', app: 'reminderNotificationApp', old: null };
+        this.diets = { type: NotificationsType.DIETS, mail: 'dietsNotificationMail', app: 'dietsNotificationApp', old: 'dietsNotificaton' };
+        this.medication = { type: NotificationsType.MEDICATIONS, mail: ['drugIntakeNotificationMail', 'medicationPlanExpiredNotificationEmail'], app: ['drugIntakeNotificationApp', 'medicationPlanExpiredNotificationApp'], old: null };
+        this.goals = { type: NotificationsType.GOALS, mail: 'goalsNotificationMail', app: 'goalsNotificationApp', old: 'goalsNotificaton' };
+        this.advices = { type: NotificationsType.ADVICES, mail: 'advicesNotificationMail', app: 'advicesNotificationApp', old: 'advicesNotificaton' };
+        this.forms = { type: NotificationsType.FORMS, mail: 'formNotificationMail', app: 'formNotificationApp', old: 'formNotificaton' };
+        this.messages = { type: NotificationsType.MESSAGES, mail: 'messagesNotificationMail', app: 'messagesNotificationApp', old: 'messagesNotificaton' };
+        this.news = { type: NotificationsType.NEWS, mail: 'newsNotificationMail', app: 'newsNotificationApp', old: null };
+        this.games = { type: NotificationsType.GAMES, mail: 'gamePlayNotificationMail', app: 'gamePlayNotificationApp', old: null };
+        this.exercises = { type: NotificationsType.EXERCISES, mail: 'exercisePlayNotificationMail', app: 'exercisePlayNotificationApp', old: null };
+        this.list_options = [];
+        //Aqui se añaden todas las notificaciones que queremos que aparezca en setting.page
+        this.options = [this.agenda, this.reminder, this.diets, this.medication, this.goals, this.advices, this.forms, this.messages, this.news, this.games, this.exercises];
+        this.setAllNotifications();
+    }
+    setAllNotifications() {
+        const ItembyRole = JSON.parse(localStorage.getItem('showItembyRole'));
+        const showItembyRole = Object.keys(ItembyRole);
+        showItembyRole.forEach(element => {
+            // resultado = this.options.filter(animal => animal != element);
+            for (let index = 0; index < this.options.length; index++) {
+                if (element === this.options[index].type) {
+                    // delete(this.options[index])
+                    this.options.splice(index, 1);
+                    index--;
+                }
+            }
+        });
+        this.options.forEach(opt => {
+            opt['translate'] = this.setTranslate(opt);
+            opt['on_mail'] = false;
+            opt['on_app'] = false;
+            const notification = opt;
+            this.list_options.push(notification);
+        });
+    }
+    getListOptions() {
+        return this.list_options;
+    }
+    setTranslate(opt) {
+        switch (opt?.type) {
+            case NotificationsType.COMMUNICATIONS:
+                return 'setting.subtitle_communications';
+            case NotificationsType.AGENDA:
+                return 'setting.subtitle_appointment';
+            case NotificationsType.REMINDERS:
+                return 'setting.subtitle_reminders';
+            case NotificationsType.DIETS:
+                return 'setting.subtitle_diets';
+            case NotificationsType.MEDICATIONS:
+                return 'setting.subtitle_medication';
+            case NotificationsType.GOALS:
+                return 'setting.subtitle_goals';
+            case NotificationsType.ADVICES:
+                return 'setting.subtitle_advices';
+            case NotificationsType.NEWS:
+                return 'setting.subtitle_release';
+            case NotificationsType.PROCEDURES:
+                return 'setting.subtitle_procedure';
+            case NotificationsType.OFFERS:
+                return 'setting.subtitle_offers';
+            case NotificationsType.FORMS:
+                return 'setting.subtitle_form';
+            case NotificationsType.MESSAGES:
+                return 'setting.subtitle_messages';
+            case NotificationsType.GAMES:
+                return 'setting.subtitle_games';
+            case NotificationsType.PROMOTE_CONTENT:
+                return 'setting.subtitle_release'; //     return 'setting.subtitle_promoteContent';
+            case NotificationsType.EXERCISES:
+                return 'setting.subtitle_exercises';
+            default:
+                return '';
+        }
+    }
+    setAppMailField(list, json) {
+        list.forEach(opt => {
+            opt.on_app = this.isOnApp(opt, json);
+            opt.on_mail = this.isOnMail(opt, json);
+        });
+        return list;
+    }
+    isOnApp(opt, json) {
+        if (typeof opt.app === 'string')
+            return json[opt.app] == '1' ? true : false;
+        else
+            return json[opt.app[0]] == '1' ? true : false;
+    }
+    isOnMail(opt, json) {
+        if (typeof opt.mail === 'string')
+            return json[opt.mail] == '1' ? true : false;
+        else
+            return json[opt.mail[0]] == '1' ? true : false;
+    }
+}
+var ContentTypePath;
+(function (ContentTypePath) {
+    //ADVICES
+    ContentTypePath["Advices"] = "/advices";
+    ContentTypePath["AdvicesDetail"] = "/advices-detail";
+    //AGENDA
+    ContentTypePath["Agenda"] = "/agenda";
+    ContentTypePath["AgendaAppointment"] = "/agenda/list-appointment";
+    ContentTypePath["AgendaDetail"] = "/agenda/detail";
+    //CHALLENGES
+    ContentTypePath["Challenges"] = "/profile/challenges";
+    ContentTypePath["ChallengesDetail"] = "/home/health-path/detail";
+    //DIETS 
+    ContentTypePath["Diets"] = "/journal";
+    ContentTypePath["DietsDetail"] = "/journal/diets-detail";
+    //EXERCISE
+    ContentTypePath["Exercises"] = "/exercices";
+    ContentTypePath["ExercisesDetail"] = "/exercices/exercices-detail";
+    //FORM
+    ContentTypePath["Forms"] = "/tracking";
+    ContentTypePath["FormDetail"] = "/tracking/form";
+    //GAME   
+    ContentTypePath["Games"] = "/journal";
+    ContentTypePath["GamesDetail"] = "/journal/games-detail";
+    //GOALS    
+    ContentTypePath["Goals"] = "/profile/goals";
+    //HOME
+    ContentTypePath["Home"] = "/home";
+    //MEDICAL PROCEDURES
+    ContentTypePath["MedicalProcedure"] = "/procedures";
+    //MEDICAL TEST
+    ContentTypePath["MedicalTest"] = "/document-detail";
+    //MEDICATION
+    ContentTypePath["Medication"] = "/jounal/";
+    ContentTypePath["MedicationDetail"] = "/drugs-detail";
+    //MESSAGE
+    ContentTypePath["Message"] = "/contact/chat/conversation";
+    //GRAPHIS
+    ContentTypePath["Monitoring"] = "/activity-goal";
+    //NEWS
+    ContentTypePath["News"] = "/news";
+    ContentTypePath["NewsDetail"] = "/new-detail";
+    //REMINDERS
+    ContentTypePath["ReminderDetail"] = "/agenda/reminder/";
+    //TRACKING OR FOLLOW UP
+    ContentTypePath["Tracking"] = "/tracking";
+    //INFORMED COSENT
+    ContentTypePath["InformedConsent"] = "/informed-consent";
+    //medical-directory
+    ContentTypePath["MedicalDirectory"] = "/medical-directory";
+    //AgenderCIta
+    ContentTypePath["Bookings"] = "/bookings";
+})(ContentTypePath || (ContentTypePath = {}));
+
+class NotificationService {
+    constructor(snackBar, zone, alertCtrl, translate, toastController, _zone, platform, router) {
+        this.snackBar = snackBar;
+        this.zone = zone;
+        this.alertCtrl = alertCtrl;
+        this.translate = translate;
+        this.toastController = toastController;
+        this._zone = _zone;
+        this.platform = platform;
+        this.router = router;
+    }
+    showSuccess(message) {
+        // Had an issue with the snackbar being ran outside of angular's zone.
+        this.zone.run(() => {
+            // The second parameter is the text in the button. 
+            // In the third, we send in the css class for the snack bar.
+            const config = new MatSnackBarConfig();
+            config.panelClass = ['custom-class'];
+            config.verticalPosition = 'bottom';
+            config.horizontalPosition = 'center';
+            config.duration = 3000;
+            this.snackBar.open(message, '', config);
+        });
+    }
+    showError(error) {
+        let message;
+        if (error.includes('ERR_INTERNET_DISCONNECTED') || error.toLowerCase().includes('network error') || error.toLowerCase().includes('unknown error'))
+            message = this.translate.instant('commons.error-network');
+        else if (error.includes('Timeout has occurred'))
+            message = this.translate.instant('commons.error-timeout');
+        else
+            message = error;
+        this.zone.run(() => {
+            const config = new MatSnackBarConfig();
+            config.panelClass = ['example-pizza-party'];
+            config.verticalPosition = 'bottom';
+            config.horizontalPosition = 'center';
+            config.duration = 3000;
+            this.snackBar.open(message, 'X', config);
+            console.log("NotificationService", message);
+        });
+    }
+    //Toast
+    displayToastSuccessful() {
+        try {
+            this.toastController.dismiss().then(() => {
+            }).catch(() => {
+            }).finally(() => {
+                console.log('Closed');
+            });
+        }
+        catch (e) { }
+        this.toastController.create({
+            position: 'middle', //'middle', 'bottom'
+            cssClass: 'toast-custom-class',
+            animated: true,
+            duration: 2000,
+        }).then((toast) => {
+            toast.present();
+        });
+    }
+    displayToastPusher(message) {
+        try {
+            this.toastController.dismiss().then(() => {
+            }).catch(() => {
+            }).finally(() => {
+                console.log('Closed');
+            });
+        }
+        catch (e) { }
+        this.toastController.create({
+            position: 'middle', //'middle', 'bottom'
+            cssClass: 'toast-pusher-class',
+            message: message,
+            animated: true,
+            duration: 30000,
+            buttons: [{
+                    text: 'Cerrar',
+                    icon: 'close',
+                    role: 'cancel',
+                    handler: () => {
+                        console.log('Cancel clicked');
+                    }
+                }
+            ]
+        }).then((toast) => {
+            toast.present();
+        });
+    }
+    async confirmAllNotification(message) {
+        const alert = await this.alertCtrl.create({
+            cssClass: 'my-alert-class',
+            message: message,
+            buttons: [
+                {
+                    text: this.translate.instant("button.ok"),
+                    handler: (data) => {
+                    }
+                }
+            ]
+        });
+        await alert.present();
+    }
+    redirecPushNotification(data, notification) {
+        switch (data.action) {
+            case "SHARECAREPLAN":
+                this._zone.run(() => {
+                    this.router.navigate([ContentTypePath.Home], { state: { data: data, openNotificationAlertDialog: true } });
+                });
+                break;
+            case "MESSAGE":
+                let staff;
+                // Different payloads for ios and android
+                if (this.platform.is('ios'))
+                    staff = data?.origin;
+                else
+                    staff = data?.origin ? JSON.parse(data?.origin) : null;
+                console.log('staff: ', staff);
+                this._zone.run(() => {
+                    this.router.navigate([ContentTypePath.Message], { state: { data: data, chat: data.id, staff: staff, customData: data?.user_id } });
+                });
+                break;
+            case "FORM":
+                this._zone.run(() => {
+                    this.router.navigate([ContentTypePath.Forms, { id: data.id }], { state: { data: data } });
+                });
+                break;
+            case "DRUGINTAKE":
+                this._zone.run(() => {
+                    this.router.navigate([ContentTypePath.Medication], { state: { data: data, segment: 'medication' } });
+                });
+                break;
+            case "VIDEOCALL":
+                //return "VIDEOCALL";
+                break;
+            case "ADVICE":
+                this._zone.run(() => {
+                    this.router.navigateByUrl('/home').then(() => {
+                        this.router.navigate([ContentTypePath.AdvicesDetail], { state: { data: data, id: data.id } });
+                    });
+                });
+                break;
+            case "NEWS":
+                this._zone.run(() => {
+                    this.router.navigateByUrl('/home').then(() => {
+                        this.router.navigate([ContentTypePath.NewsDetail], { state: { data: data, id: data.id } });
+                    });
+                });
+                break;
+            case "DIET":
+                this._zone.run(() => {
+                    this.router.navigate([ContentTypePath.DietsDetail], { state: { data: data, id: data.id } });
+                });
+                break;
+            case "AGENDA":
+                this._zone.run(() => {
+                    this.router.navigate([ContentTypePath.AgendaDetail], { state: { data: data, id: data.id } });
+                });
+                break;
+            case "REMINDER":
+                this._zone.run(() => {
+                    this.router.navigate([ContentTypePath.ReminderDetail], { state: { data: data, id: data.id } });
+                });
+                break;
+            case "GAME":
+                this._zone.run(() => {
+                    if (data.type == 'form') {
+                        this.router.navigate([ContentTypePath.FormDetail, { id: data.form_id }], { state: { data: data, game_play_id: data?.game_play_id } });
+                    }
+                    else
+                        this.router.navigate([ContentTypePath.GamesDetail], { state: { data: data, id: data.id, server_url: data?.server_url } });
+                });
+                break;
+            case "EXERCISE":
+                this._zone.run(() => {
+                    this.router.navigate([ContentTypePath.Exercises], { state: { data: data, id: data.id, programable_id: data.programable_play_id } });
+                });
+                break;
+            default:
+                console.error('Action on localNotificationActionPerformed not found, redirecting to videocall: ');
+                // this.redirecToVideocall(notification)
+                break;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NotificationService, deps: [{ token: i1$2.MatSnackBar }, { token: i0.NgZone }, { token: i2.AlertController }, { token: i1$1.TranslateService }, { token: i2.ToastController }, { token: i0.NgZone }, { token: i2.Platform }, { token: i6.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NotificationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1$2.MatSnackBar }, { type: i0.NgZone }, { type: i2.AlertController }, { type: i1$1.TranslateService }, { type: i2.ToastController }, { type: i0.NgZone }, { type: i2.Platform }, { type: i6.Router }] });
+
+class NetworkService {
+    constructor(network, platform) {
+        this.network = network;
+        this.platform = platform;
+        this.online$ = undefined;
+        this.online$ = new Observable(observer => {
+            observer.next(true);
+        }).pipe(mapTo(true));
+        if (Capacitor.isNativePlatform()) {
+            // on Device
+            console.log('on Device');
+            this.online$ = merge(this.network.onConnect().pipe(mapTo(true)), this.network.onDisconnect().pipe(mapTo(false)));
+        }
+        else {
+            // on Browser
+            console.log('on Browser');
+            this.online$ = merge(of(navigator.onLine), fromEvent(window, 'online').pipe(mapTo(true)), fromEvent(window, 'offline').pipe(mapTo(false)));
+        }
+    }
+    getNetworkType() {
+        return this.network.type;
+    }
+    getNetworkStatus() {
+        return this.online$;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NetworkService, deps: [{ token: i1$3.Network }, { token: i2.Platform }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NetworkService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NetworkService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1$3.Network }, { type: i2.Platform }] });
+
+class LoadingService {
+    constructor() {
+        this.loadingSub = new BehaviorSubject(false);
+        /**
+         * Contains in-progress loading requests
+         */
+        this.loadingMap = new Map();
+    }
+    /**
+     * Sets the loadingSub property value based on the following:
+     * - If loading is true, add the provided url to the loadingMap with a true value, set loadingSub value to true
+     * - If loading is false, remove the loadingMap entry and only when the map is empty will we set loadingSub to false
+     * This pattern ensures if there are multiple requests awaiting completion, we don't set loading to false before
+     * other requests have completed. At the moment, this function is only called from the @link{HttpRequestInterceptor}
+     * @param loading {boolean}
+     * @param url {string}
+     */
+    setLoading(loading, url) {
+        if (!url) {
+            throw new Error('The request URL must be provided to the LoadingService.setLoading function');
+        }
+        if (loading === true) {
+            this.loadingMap.set(url, loading);
+            this.loadingSub.next(true);
+        }
+        else if (loading === false && this.loadingMap.has(url)) {
+            this.loadingMap.delete(url);
+        }
+        if (this.loadingMap.size === 0) {
+            this.loadingSub.next(false);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LoadingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LoadingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LoadingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+class LoggingService {
+    constructor(platform) {
+        this.platform = platform;
+    }
+    logError(message) {
+        // Send errors to be saved here
+        if (Capacitor.isNativePlatform()) {
+            console.error("Error log: ", message);
+        }
+        else {
+            console.error("Error log: ", message);
+        }
+        return;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LoggingService, deps: [{ token: i2.Platform }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LoggingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LoggingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i2.Platform }] });
+
+class ErrorService {
+    constructor() { }
+    getClientMessage(error) {
+        if (error.constructor == Array) {
+            return error.toString();
+        }
+        else if (error.constructor == Object) {
+            return JSON.stringify(error);
+        }
+        else if (typeof error == 'object') {
+            return error.message ? error.message : 'error';
+        }
+        else {
+            return error;
+        }
+    }
+    getClientStack(error) {
+        return error.stack;
+    }
+    getServerMessage(error) {
+        if (error.constructor == Array) {
+            return error;
+        }
+        else if (error.constructor == Object) {
+            return JSON.stringify(error);
+        }
+        else if (typeof error == 'object') {
+            return error.message;
+        }
+        else {
+            return error;
+        }
+    }
+    getServerStack(error) {
+        // handle stack trace
+        return 'stack';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ErrorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ErrorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ErrorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+class OpentokService {
+    constructor() {
+        this.callEventSubject = new Subject();
+        this.callEvent$ = this.callEventSubject.asObservable();
+        CallCapacitor.addListener('disconnected-call', () => {
+            this.emitCallEvent({ type: "hangup" });
+        });
+    }
+    emitCallEvent(data) {
+        this.callEventSubject.next(data);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: OpentokService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: OpentokService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: OpentokService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+class AnalyticsService {
+    constructor(environment, platform) {
+        this.environment = environment;
+        this.platform = platform;
+        this.analyticsEnabled = true;
+        this.initFb();
+    }
+    async initFb() {
+        if (this.platform.is('mobileweb')) {
+            console.log("initializeFirebase: ", this.environment.firebase);
+            await FirebaseAnalytics.initializeFirebase(this.environment.firebase);
+        }
+        this.toggleAnalytics();
+    }
+    setUserId(userId) {
+        const setUserId = async () => {
+            await FirebaseAnalytics.setUserId({
+                userId: userId,
+            });
+        };
+        return setUserId;
+    }
+    setProperty(property, value) {
+        const setUserProperty = async () => {
+            await FirebaseAnalytics.setUserProperty({
+                name: property,
+                value: value,
+            });
+        };
+        return setUserProperty;
+    }
+    logEvent(name, params) {
+        const logEvent = async () => {
+            await FirebaseAnalytics.logEvent({
+                name: name,
+                params: params
+            });
+        };
+        return logEvent;
+    }
+    async setScreenName(screenName, nameOverride) {
+        await FirebaseAnalytics.setScreenName({
+            screenName: screenName,
+            nameOverride: nameOverride,
+        });
+    }
+    async toggleAnalytics() {
+        const setCollectionEnabled = async () => {
+            await FirebaseAnalytics.setCollectionEnabled({
+                enabled: this.analyticsEnabled,
+            });
+        };
+        return setCollectionEnabled;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: AnalyticsService, deps: [{ token: FIREBASE_CONFIG_TOKEN }, { token: i2.Platform }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: AnalyticsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: AnalyticsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [FIREBASE_CONFIG_TOKEN]
+                }] }, { type: i2.Platform }] });
+
+/*
+ * Public API Surface of service-lib
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AnalyticsService, ApiEndpointsService, AuthenticationService, ChangeEndpointsService, ComponentsApp, DateService, DooleService, EncryptionService, ErrorService, Events, HighchartsService, HttpService, LanguageService, LoadingService, LoggingService, NavigationService, NetworkService, NotificationService, OpentokService, RolesService, ServiceLibComponent, ServiceLibModule, StorageService, TokenService, User, _INDEX_ENPOINT };
+//# sourceMappingURL=doolehealth-service-lib.mjs.map