@doolehealth/service-lib 0.0.4 → 0.0.6

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

@@ -19,10 +19,10 @@ export class EncryptionService {
             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' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EncryptionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EncryptionService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: EncryptionService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EncryptionService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'

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

@@ -37,10 +37,10 @@ export class ErrorService {
         // 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' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ErrorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ErrorService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: ErrorService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ErrorService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'

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

@@ -18,7 +18,7 @@ export class Events {
      * @returns Subscription from which you can unsubscribe to release memory resources and to prevent memory leak.
      */
     subscribe(topic, observer) {
-        console.log("subscribe topic: ", topic);
+        //console.log("subscribe topic: ", topic);
         if (!this.channels[topic]) {
             // You can also use ReplaySubject with one concequence
             this.channels[topic] = new Subject();
@@ -51,13 +51,13 @@ export class Events {
         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' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: Events, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: Events, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: Events, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: Events, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/firebase/auth/firebase-auth.service.mjs

@@ -0,0 +1,154 @@
+import { Inject, Injectable, PLATFORM_ID } from '@angular/core';
+import { Subject, from, of } from 'rxjs';
+import { FirebaseProfileModel } from './firebase-profile.model';
+import { filter, map } from 'rxjs/operators';
+import firebase from "firebase/compat/app";
+//import { cfaSignIn, cfaSignOut } from 'capacitor-firebase-auth';
+import { isPlatformBrowser } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/fire/compat/auth";
+import * as i2 from "@ionic/angular";
+export class FirebaseAuthService {
+    constructor(angularFire, platform, platformId) {
+        this.angularFire = angularFire;
+        this.platform = platform;
+        this.platformId = platformId;
+        this.redirectResult = new Subject();
+        if (isPlatformBrowser(this.platformId)) {
+            this.angularFire.onAuthStateChanged((user) => {
+                if (user) {
+                    // User is signed in.
+                    this.currentUser = user;
+                }
+                else {
+                    // No user is signed in.
+                    this.currentUser = null;
+                }
+            });
+            if (!this.platform.is('capacitor')) {
+                // when using signInWithRedirect, this listens for the redirect results
+                this.angularFire.getRedirectResult()
+                    .then((result) => {
+                    // result.credential.accessToken gives you the Provider Access Token. You can use it to access the Provider API.
+                    if (result.user) {
+                        this.userProviderAdditionalInfo = result.additionalUserInfo.profile;
+                        this.redirectResult.next(result);
+                    }
+                }, (error) => {
+                    this.redirectResult.next({ error: error.code });
+                });
+            }
+        }
+    }
+    getRedirectResult() {
+        return this.redirectResult.asObservable();
+    }
+    getPhotoURL(signInProviderId, photoURL) {
+        // Default imgs are too small and our app needs a bigger image
+        switch (signInProviderId) {
+            case 'facebook.com':
+                return photoURL + '?height=400';
+            case 'password':
+                return 'https://s3-us-west-2.amazonaws.com/ionicthemes/otros/avatar-placeholder.png';
+            case 'twitter.com':
+                return photoURL.replace('_normal', '_400x400');
+            case 'google.com':
+                return photoURL.split('=')[0];
+            default:
+                return photoURL;
+        }
+    }
+    signOut() {
+        if (this.platform.is('capacitor')) {
+            //return cfaSignOut();
+        }
+        else {
+            return from(this.angularFire.signOut());
+        }
+        return null;
+    }
+    signInWithEmail(email, password) {
+        return this.angularFire.signInWithEmailAndPassword(email, password);
+    }
+    signUpWithEmail(email, password) {
+        return this.angularFire.createUserWithEmailAndPassword(email, password);
+    }
+    socialSignIn(providerName, scopes) {
+        if (this.platform.is('capacitor')) {
+            //return cfaSignIn(providerName);
+        }
+        else {
+            const provider = new firebase.auth.OAuthProvider(providerName);
+            ////console.log("provider. ", provider);
+            if (scopes) {
+                scopes.forEach(scope => {
+                    provider.addScope(scope);
+                });
+            }
+            if (this.platform.is('desktop')) {
+                return from(this.angularFire.signInWithPopup(provider));
+            }
+            else {
+                // web but not desktop, for example mobile PWA
+                return from(this.angularFire.signInWithRedirect(provider));
+            }
+        }
+        return null;
+    }
+    signInWithGoogle() {
+        const provider = new firebase.auth.GoogleAuthProvider();
+        ////console.log("provider: ", provider);
+        const scopes = ['profile', 'email'];
+        return this.socialSignIn(provider.providerId, scopes);
+    }
+    signInWithTwitter() {
+        const provider = new firebase.auth.TwitterAuthProvider();
+        return this.socialSignIn(provider.providerId);
+    }
+    getProfileDataSource() {
+        // we need to do this differentiation because there is a bug in
+        // platform capacitor ios when executing this.angularFire.user
+        if (this.platform.is('capacitor')) {
+            return of(this.setUserModelForProfile());
+        }
+        else {
+            return this.angularFire.user
+                .pipe(filter((user) => user != null), map((user) => {
+                return this.setUserModelForProfile();
+            }));
+        }
+    }
+    setUserModelForProfile() {
+        const userModel = new FirebaseProfileModel();
+        const provierData = this.currentUser.providerData[0];
+        const userData = this.userProviderAdditionalInfo ? this.userProviderAdditionalInfo : provierData;
+        userModel.image = this.getPhotoURL(provierData.providerId, provierData.photoURL);
+        userModel.name = userData.name || userData.displayName || 'What\'s your name?';
+        userModel.role = 'How would you describe yourself?';
+        userModel.description = userData.description || 'Anything else you would like to share with the world?';
+        userModel.phoneNumber = userData.phoneNumber || 'Is there a number where I can reach you?';
+        userModel.email = userData.email || 'Where can I send you emails?';
+        userModel.provider = (provierData.providerId !== 'password') ? provierData.providerId : 'Credentials';
+        return userModel;
+    }
+    getProfileStore(dataSource) {
+        // Initialize the model specifying that it is a shell model
+        const shellModel = new FirebaseProfileModel();
+        //this.profileDataStore = new DataStore(shellModel);
+        // Trigger the loading mechanism (with shell) in the dataStore
+        this.profileDataStore.load(dataSource);
+        return this.profileDataStore;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FirebaseAuthService, deps: [{ token: i1.AngularFireAuth }, { token: i2.Platform }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FirebaseAuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FirebaseAuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AngularFireAuth }, { type: i2.Platform }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"firebase-auth.service.js","sourceRoot":"","sources":["../../../../../../../projects/service-lib/src/lib/services/firebase/auth/firebase-auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, PLATFORM_ID } from '@angular/core';\nimport { AngularFireAuth } from '@angular/fire/compat/auth';\nimport { Observable, Subject, from, of } from 'rxjs';\nimport { DataStore } from '../../../utils/data-store';\nimport { FirebaseProfileModel } from './firebase-profile.model';\nimport { Platform } from '@ionic/angular';\nimport { filter, map } from 'rxjs/operators';\n\nimport firebase from \"firebase/compat/app\";\n//import { cfaSignIn, cfaSignOut } from 'capacitor-firebase-auth';\nimport { isPlatformBrowser } from '@angular/common';\nimport { User, Auth } from 'firebase/auth';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class FirebaseAuthService {\n\n  currentUser: User;\n  userProviderAdditionalInfo: any;\n  profileDataStore: DataStore<FirebaseProfileModel>;\n  redirectResult: Subject<any> = new Subject<any>();\n\n\n  constructor(\n    public angularFire: AngularFireAuth,\n    public platform: Platform,\n    @Inject(PLATFORM_ID) private platformId: object\n  ) {\n    if (isPlatformBrowser(this.platformId)) {\n      this.angularFire.onAuthStateChanged((user) => {\n        if (user) {\n          // User is signed in.\n          this.currentUser = user;\n        } else {\n          // No user is signed in.\n          this.currentUser = null;\n        }\n      });\n\n      if (!this.platform.is('capacitor')) {\n        // when using signInWithRedirect, this listens for the redirect results\n        this.angularFire.getRedirectResult()\n        .then((result) => {\n          // result.credential.accessToken gives you the Provider Access Token. You can use it to access the Provider API.\n          if (result.user) {\n            this.userProviderAdditionalInfo = result.additionalUserInfo.profile;\n            this.redirectResult.next(result);\n          }\n        }, (error) => {\n          this.redirectResult.next({error: error.code});\n        });\n      }\n    }\n  }\n\n  getRedirectResult(): Observable<any> {\n    return this.redirectResult.asObservable();\n  }\n\n  getPhotoURL(signInProviderId: string, photoURL: string): string {\n    // Default imgs are too small and our app needs a bigger image\n    switch (signInProviderId) {\n      case 'facebook.com':\n        return photoURL + '?height=400';\n      case 'password':\n        return 'https://s3-us-west-2.amazonaws.com/ionicthemes/otros/avatar-placeholder.png';\n      case 'twitter.com':\n        return photoURL.replace('_normal', '_400x400');\n      case 'google.com':\n        return photoURL.split('=')[0];\n      default:\n        return photoURL;\n    }\n  }\n\n  signOut(): Observable<any> {\n    if (this.platform.is('capacitor')) {\n      //return cfaSignOut();\n    } else {\n      return from(this.angularFire.signOut());\n    }\n    return null\n  }\n\n  signInWithEmail(email: string, password: string): Promise<firebase.auth.UserCredential> {\n    return this.angularFire.signInWithEmailAndPassword(email, password);\n  }\n\n  signUpWithEmail(email: string, password: string): Promise<firebase.auth.UserCredential> {\n    return this.angularFire.createUserWithEmailAndPassword(email, password);\n  }\n\n  socialSignIn(providerName: string, scopes?: Array<string>): Observable<any> {\n    if (this.platform.is('capacitor')) {\n      //return cfaSignIn(providerName);\n    } else {\n\n      const provider = new firebase.auth.OAuthProvider(providerName);\n      ////console.log(\"provider. \", provider);\n      if (scopes) {\n        scopes.forEach(scope => {\n          provider.addScope(scope);\n        });\n      }\n\n\n      if (this.platform.is('desktop')) {\n        return from(this.angularFire.signInWithPopup(provider));\n      } else {\n        // web but not desktop, for example mobile PWA\n        return from(this.angularFire.signInWithRedirect(provider));\n      }\n    }\n    return null\n  }\n\n  signInWithGoogle() {\n    const provider = new firebase.auth.GoogleAuthProvider();\n    ////console.log(\"provider: \", provider);\n    const scopes = ['profile', 'email'];\n    return this.socialSignIn(provider.providerId, scopes);\n  }\n\n  signInWithTwitter() {\n    const provider = new firebase.auth.TwitterAuthProvider();\n    return this.socialSignIn(provider.providerId);\n  }\n\n  public getProfileDataSource(): Observable<FirebaseProfileModel> {\n    // we need to do this differentiation because there is a bug in\n    // platform capacitor ios when executing this.angularFire.user\n    if (this.platform.is('capacitor')) {\n      return of(this.setUserModelForProfile());\n    } else {\n      return this.angularFire.user\n      .pipe(\n        filter((user: User) => user != null),\n        map((user: User) => {\n          return this.setUserModelForProfile();\n        })\n      );\n    }\n  }\n\n  private setUserModelForProfile(): FirebaseProfileModel {\n    const userModel = new FirebaseProfileModel();\n    const provierData = this.currentUser.providerData[0];\n    const userData = this.userProviderAdditionalInfo ? this.userProviderAdditionalInfo : provierData;\n    userModel.image = this.getPhotoURL(provierData.providerId, provierData.photoURL);\n    userModel.name = userData.name || userData.displayName || 'What\\'s your name?';\n    userModel.role = 'How would you describe yourself?';\n    userModel.description = userData.description || 'Anything else you would like to share with the world?';\n    userModel.phoneNumber = userData.phoneNumber || 'Is there a number where I can reach you?';\n    userModel.email = userData.email || 'Where can I send you emails?';\n    userModel.provider = (provierData.providerId !== 'password') ? provierData.providerId : 'Credentials';\n\n    return userModel;\n  }\n\n  public getProfileStore(dataSource: Observable<FirebaseProfileModel>): DataStore<FirebaseProfileModel> {\n    // Initialize the model specifying that it is a shell model\n    const shellModel: FirebaseProfileModel = new FirebaseProfileModel();\n    //this.profileDataStore = new DataStore(shellModel);\n    // Trigger the loading mechanism (with shell) in the dataStore\n    this.profileDataStore.load(dataSource);\n    return this.profileDataStore;\n  }\n}\n"]}

package/esm2022/lib/services/firebase/auth/firebase-profile.model.mjs

@@ -0,0 +1,7 @@
+import { ShellModel } from '../../../utils/data-store';
+export class FirebaseProfileModel extends ShellModel {
+    constructor() {
+        super();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlyZWJhc2UtcHJvZmlsZS5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NlcnZpY2UtbGliL3NyYy9saWIvc2VydmljZXMvZmlyZWJhc2UvYXV0aC9maXJlYmFzZS1wcm9maWxlLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUV2RCxNQUFNLE9BQU8sb0JBQXFCLFNBQVEsVUFBVTtJQVNsRDtRQUNFLEtBQUssRUFBRSxDQUFDO0lBQ1YsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2hlbGxNb2RlbCB9IGZyb20gJy4uLy4uLy4uL3V0aWxzL2RhdGEtc3RvcmUnO1xuXG5leHBvcnQgY2xhc3MgRmlyZWJhc2VQcm9maWxlTW9kZWwgZXh0ZW5kcyBTaGVsbE1vZGVsIHtcbiAgaW1hZ2U6IHN0cmluZztcbiAgbmFtZTogc3RyaW5nO1xuICByb2xlOiBzdHJpbmc7XG4gIGRlc2NyaXB0aW9uOiBzdHJpbmc7XG4gIGVtYWlsOiBzdHJpbmc7XG4gIHByb3ZpZGVyOiBzdHJpbmc7XG4gIHBob25lTnVtYmVyOiBzdHJpbmc7XG5cbiAgY29uc3RydWN0b3IoKSB7XG4gICAgc3VwZXIoKTtcbiAgfVxufVxuIl19

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

@@ -0,0 +1,303 @@
+import { Inject, Injectable } from '@angular/core';
+import { NativeMarket } from "@capacitor-community/native-market";
+import { CONFIGURACION_TOKEN } from '../configuration';
+import * as i0 from "@angular/core";
+import * as i1 from "@awesome-cordova-plugins/device/ngx";
+import * as i2 from "@ionic/angular";
+import * as i3 from "./doole.service";
+import * as i4 from "@angular/router";
+import * as i5 from "@ngx-translate/core";
+import * as i6 from "./language.service";
+import * as i7 from "./authentication.service";
+export class HealthService {
+    constructor(device, platform, dooleService, router, translate, languageService, constants, authService, alertController) {
+        this.device = device;
+        this.platform = platform;
+        this.dooleService = dooleService;
+        this.router = router;
+        this.translate = translate;
+        this.languageService = languageService;
+        this.constants = constants;
+        this.authService = authService;
+        this.alertController = alertController;
+        //private dataTypes = ['distance', 'steps',  'weight', 'blood_glucose', 'heart_rate' ];
+        this.dataTypes = ['distance', 'steps', 'weight', 'heart_rate'];
+        this.enableHealthConnectSettings = false;
+        this.isHealthConnect = true;
+        this.hideButtonHealthConnect = false;
+        if (this.platform.is('android') && !this.platform.is('mobileweb')) {
+            //this.setPrivacyPolicy();
+            this.btnDowloadHealthConnect();
+            // if(this.device.sdkVersion == '34'){
+            //   this.isHealthConnect = false;
+            // }else{
+            //   this.isHealthConnect = true;
+            // }
+        }
+    }
+    btnDowloadHealthConnect() {
+        if (this.platform.is("cordova")) {
+            cordova.plugins.health.isAvailable((available) => {
+                if (available) {
+                    this.hideButtonHealthConnect = true;
+                }
+            }, (e) => {
+                //this.presentAlertConfirm(e);
+                console.error('[HealthService] connect(): error', e);
+            });
+        }
+    }
+    setHealthConnect() {
+    }
+    downloadHealthConnect() {
+        NativeMarket.openStoreListing({
+            appId: /* this.constants.healthconnectPackageID */ 'com.google.android.apps.healthdata'
+        });
+        /* cordova.plugins.health.getHealthConnectFromStore(
+          (success)=>{console.log("All good: ", success)},
+          (error)=>{console.log("Wrong error", error)} ); */
+    }
+    downloadGoogleFit() {
+        NativeMarket.openStoreListing({
+            appId: this.constants.googleFitPackageID
+        });
+    }
+    setPrivacyPolicy() {
+        cordova.plugins.health.setPrivacyPolicyURL(/* this.constants.privacyPolicies */ 'https://doolehealth.com/en/privacy-policy/', () => { }, () => { });
+    }
+    openHealthServices() {
+        cordova.plugins.health.openHealthSettings((success) => { }, (error) => { });
+    }
+    connect(comesFromSettings) {
+        //console.log('HealthService requestAuthorization() connect:', comesFromSettings)
+        if (this.platform.is("cordova")) {
+            cordova.plugins.health.isAvailable((available) => {
+                //console.log('HealthService requestAuthorization() available:', available)
+                if (available) {
+                    cordova.plugins.health.isAuthorized({ read: this.dataTypes }, (authorized) => {
+                        if (!authorized) {
+                            cordova.plugins.health.requestAuthorization({ read: this.dataTypes }, (success) => {
+                                //console.log('HealthService requestAuthorization() success:', success)
+                                this.loadingData = true;
+                                this.authService.setShowHealthConnectLocalstorage();
+                                this.authService.setCanceledHealthConnectLocalstorage("true");
+                                this.readDataFromApp(30);
+                                if (comesFromSettings) {
+                                    this.router.navigate(['settings'], { replaceUrl: true });
+                                }
+                                else {
+                                    this.router.navigate(['home'], { replaceUrl: true });
+                                }
+                                this.enableHealthConnectSettings = true;
+                            }, (error) => {
+                                //console.log('HealthService requestAuthorization() error:', error)
+                                this.enableHealthConnectSettings = false;
+                            });
+                        }
+                        else {
+                            this.loadingData = true;
+                            this.authService.setShowHealthConnectLocalstorage();
+                            this.authService.setCanceledHealthConnectLocalstorage("true");
+                            this.readDataFromApp(30);
+                            this.router.navigate(['home']);
+                            this.enableHealthConnectSettings = true;
+                        }
+                    }, (error) => {
+                        this.presentAlertConfirm();
+                        //console.log(error);
+                    });
+                }
+                else {
+                    this.enableHealthConnectSettings = false;
+                    this.presentAlertConfirm();
+                    //console.log("Health plugin not available");
+                }
+            }, (e) => {
+                //this.presentAlertConfirm(e);
+                console.error('[HealthService] connect(): error', e);
+                this.downloadHealthConnect();
+            });
+        }
+    }
+    retrieveData() {
+        if (this.platform.is("cordova")) {
+            cordova.plugins.health.isAvailable((available) => {
+                if (available) {
+                    cordova.plugins.health.isAuthorized({ read: this.dataTypes }, (authorized) => {
+                        if (authorized) {
+                            this.loadingData = true;
+                            this.authService.setShowHealthConnectLocalstorage();
+                            this.authService.setCanceledHealthConnectLocalstorage("true");
+                            this.readDataFromApp(30);
+                            this.enableHealthConnectSettings = true;
+                        }
+                        else {
+                            this.enableHealthConnectSettings = false;
+                        }
+                    }, (error) => {
+                        this.presentAlertConfirm();
+                        //console.log(error);
+                    });
+                }
+            }, (e) => {
+                //this.presentAlertConfirm(e);
+                console.error('[HealthService] connect(): error', e);
+            });
+        }
+    }
+    readDataFromApp(days) {
+        let startDate = new Date(new Date().getTime() - days * 24 * 60 * 60 * 1000);
+        let endDate = new Date(); // now
+        //console.log("Entering for reading data")
+        this.readData(startDate, endDate);
+        // this.readBloodGlucose(startDate, endDate);
+        //  this.readSteps(startDate, endDate);
+        //  this.readDistance(startDate, endDate);
+        //this.readHeartRate(startDate, endDate);
+        // this.readWeightData(startDate, endDate);
+        // setTimeout(()=> this.readBloodGlucose(startDate, endDate), 500); 
+        // setTimeout(()=> this.readSteps(startDate, endDate), 1500); 
+        // setTimeout(()=> this.readDistance(startDate, endDate), 1500); 
+        // setTimeout(()=> this.readWeightData(startDate, endDate), 1500); 
+        // setTimeout(()=> this.readHeartRate(startDate, endDate), 500); 
+    }
+    async readData(startDate, endDate) {
+        await this.platform.ready();
+        //console.log("[HealthService] Entering for reading health data");
+        for (const element of this.dataTypes) {
+            const config = { startDate: startDate, endDate: endDate, dataType: element };
+            if (element === 'distance' || element === 'steps') {
+                config['bucket'] = 'hour';
+                try {
+                    const data = await this.queryAggregatedHealthData(config);
+                    //console.log(`DATA HEALTH CONNECT (${element}): `, JSON.stringify(data));
+                    await this.postHealth(element, data);
+                }
+                catch (error) {
+                    console.error(`Error for posting ${element} data: `, error);
+                }
+            }
+            else {
+                try {
+                    const data = await this.queryHealthData(config);
+                    //console.log(`DATA HEALTH CONNECT (${element}): `, JSON.stringify(data));
+                    await this.postHealth(element, data);
+                }
+                catch (error) {
+                    console.error(`Error for posting ${element} data: `, error);
+                }
+            }
+        }
+    }
+    queryAggregatedHealthData(config) {
+        return new Promise((resolve, reject) => {
+            cordova.plugins.health.queryAggregated(config, (data) => resolve(data), (error) => reject(error));
+        });
+    }
+    queryHealthData(config) {
+        return new Promise((resolve, reject) => {
+            cordova.plugins.health.query(config, (data) => resolve(data), (error) => reject(error));
+        });
+    }
+    readWeightData(startDate, endDate) {
+        //console.log("[HealthService] Entering for reading weight data")
+        //cordova.plugins.health.query({startDate: startDate,  endDate: endDate ,  dataType: 'weight'}, (data)=> {this.postHealth('weight', data);}, ()=> {console.error()})
+        cordova.plugins.health.query({
+            startDate: startDate, endDate: endDate,
+            dataType: 'weight'
+        }, (data) => { this.postHealth('weight', data); }, (error) => { console.error("Error for posting weight data: ", error); });
+    }
+    readBloodGlucose(startDate, endDate) {
+        //console.log("[HealthService] Entering for reading blood_glucose data")
+        cordova.plugins.health.query({
+            startDate: startDate, endDate: endDate,
+            dataType: 'blood_glucose'
+        }, (data) => { this.postHealth('blood_glucose', data); }, (error) => { console.error("Error for posting blood_glucose data ", error); });
+    }
+    readSteps(startDate, endDate) {
+        //console.log("[HealthService] Entering for reading steps data")
+        cordova.plugins.health.queryAggregated({ startDate: startDate, endDate: endDate, dataType: 'steps', bucket: 'day' }, (data) => { this.postHealth('steps', data); }, (error) => { console.error("Error for posting steps data ", error); });
+    }
+    readDistance(startDate, endDate) {
+        //console.log("[HealthService] Entering for reading distance data")
+        cordova.plugins.health.queryAggregated({ startDate: startDate, endDate: endDate, dataType: 'distance', bucket: 'day' }, (data) => { this.postHealth('distance', data); }, (error) => { console.error("Error for posting distance data ", error); })
+            .then(data => {
+            //console.log("[HealthService] Entering for reading distance data1", data)
+        });
+    }
+    readHeartRate(startDate, endDate) {
+        //console.log("[HealthService] Entering for reading heart_rate data")
+        cordova.plugins.health.query({
+            startDate: startDate, endDate: endDate,
+            dataType: 'heart_rate'
+        }, (data) => { this.postHealth('heart_rate', data); }, () => { console.error(); });
+    }
+    //To send POST with health data to api
+    async postHealth(type, data) {
+        //console.log("[HealthService] postHealth()", type, data);
+        const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        //console.log('[HealthService] syncData', timezone);
+        const postData = {
+            timezone: timezone,
+            type: type,
+            vals: JSON.stringify(data),
+        };
+        //console.log('[HealthService] postObject', postData);
+        if (this.authService?.deviceToken) {
+            postData['device_token'] = this.authService.deviceToken;
+        }
+        try {
+            const response = await this.dooleService.post('user/element/sync', postData).toPromise();
+            //console.log('[HealthService] apiRes', JSON.stringify(response));
+        }
+        catch (error) {
+            //console.log('[HealthService] apiErr', JSON.stringify(error));
+            throw error;
+        }
+    }
+    async presentAlertConfirm(error) {
+        const alert = await this.alertController.create({
+            cssClass: 'my-alert-class',
+            header: this.getErrorMessage(error),
+            buttons: [
+                {
+                    text: this.translate.instant("alert.button_cancel"),
+                    role: 'cancel',
+                    cssClass: 'secondary',
+                    handler: async (blah) => {
+                        //console.log('Confirm Cancel: blah');
+                    }
+                }, {
+                    text: this.translate.instant("health-connect.return_home"),
+                    handler: () => {
+                        this.authService.setShowHealthConnectLocalstorage();
+                        if (this.router.url.includes('landing'))
+                            this.router.navigate(['landing']);
+                        else
+                            this.router.navigate(['home']);
+                    }
+                }
+            ]
+        });
+        await alert.present();
+    }
+    getErrorMessage(e) {
+        if (e && e === 'Health Connect is not installed') {
+            return this.translate.instant("health-connect.error_msg_not_install");
+        }
+        else
+            return this.translate.instant("health-connect.error_msg");
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HealthService, deps: [{ token: i1.Device }, { token: i2.Platform }, { token: i3.DooleService }, { token: i4.Router }, { token: i5.TranslateService }, { token: i6.LanguageService }, { token: CONFIGURACION_TOKEN }, { token: i7.AuthenticationService }, { token: i2.AlertController }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HealthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HealthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Device }, { type: i2.Platform }, { type: i3.DooleService }, { type: i4.Router }, { type: i5.TranslateService }, { type: i6.LanguageService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CONFIGURACION_TOKEN]
+                }] }, { type: i7.AuthenticationService }, { type: i2.AlertController }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"health.service.js","sourceRoot":"","sources":["../../../../../projects/service-lib/src/lib/services/health.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { TranslateService } from '@ngx-translate/core';\nimport { LanguageService } from './language.service';\nimport { Router } from '@angular/router';\nimport { NativeMarket } from \"@capacitor-community/native-market\";\nimport { CONFIGURACION_TOKEN, Configuracion } from '../configuration';\n\nimport { Platform } from '@ionic/angular';\nimport { DooleService } from './doole.service';\nimport { AuthenticationService } from './authentication.service';\nimport { AlertController } from '@ionic/angular';\nimport { Device } from '@awesome-cordova-plugins/device/ngx';\n\n\ndeclare let cordova: any;\n@Injectable({\n  providedIn: 'root'\n})\nexport class HealthService {\n  //private dataTypes = ['distance', 'steps',  'weight', 'blood_glucose', 'heart_rate' ];\n  private dataTypes = ['distance', 'steps',  'weight', 'heart_rate' ];\n  enableHealthConnectSettings: boolean = false;\n  loadingData: boolean;\n  isHealthConnect: boolean = true;\n  hideButtonHealthConnect = false;\n\n  constructor(private device: Device, public platform: Platform, private dooleService: DooleService, public router: Router, private translate: TranslateService, public languageService: LanguageService, @Inject(CONFIGURACION_TOKEN) private constants: Configuracion, public authService: AuthenticationService, private alertController: AlertController) { \n    \n    if(this.platform.is('android') && !this.platform.is('mobileweb')){\n      //this.setPrivacyPolicy();\n      this.btnDowloadHealthConnect();\n      \n\n      // if(this.device.sdkVersion == '34'){\n      //   this.isHealthConnect = false;\n      // }else{\n      //   this.isHealthConnect = true;\n      // }\n      \n    }\n\n  }\n\n  btnDowloadHealthConnect(){\n    if (this.platform.is(\"cordova\")) {\n      cordova.plugins.health.isAvailable((available) => {\n        if (available) {\n          this.hideButtonHealthConnect= true;\n          }\n      }, (e) => {\n        //this.presentAlertConfirm(e);\n        console.error('[HealthService] connect(): error', e)\n      });\n     }\n  }\n  setHealthConnect(){\n    \n  }\n\n  downloadHealthConnect() {\n    NativeMarket.openStoreListing({\n      appId: /* this.constants.healthconnectPackageID */ 'com.google.android.apps.healthdata'\n    });\n    /* cordova.plugins.health.getHealthConnectFromStore(\n      (success)=>{console.log(\"All good: \", success)},\n      (error)=>{console.log(\"Wrong error\", error)} ); */\n  }\n\n  downloadGoogleFit() {\n    NativeMarket.openStoreListing({\n      appId: this.constants.googleFitPackageID\n    });\n  }\n\n  setPrivacyPolicy() {\n    cordova.plugins.health.setPrivacyPolicyURL(/* this.constants.privacyPolicies */ 'https://doolehealth.com/en/privacy-policy/', ()=>{/*console.log(\"succesfuly shown\")*/},  ()=>{/*console.log(\"not displays\")*/})\n  }\n\n  openHealthServices() {\n    cordova.plugins.health.openHealthSettings(\n      (success)=>{/*console.log('[HealthService] openHealthSettings() success: ', success)*/},  \n      (error)=>{/*console.log('[HealthService] openHealthSettings() error: ', error)*/}\n    )\n  }\n\n  public connect(comesFromSettings?: boolean) {\n    //console.log('HealthService requestAuthorization() connect:', comesFromSettings)\n    if (this.platform.is(\"cordova\")) {\n      cordova.plugins.health.isAvailable((available) => {\n        //console.log('HealthService requestAuthorization() available:', available)\n        if (available) {\n\n           cordova.plugins.health.isAuthorized({ read : this.dataTypes }, (authorized) => {\n             if (!authorized) {\n\n\n              cordova.plugins.health.requestAuthorization( { read : this.dataTypes}, \n                                                            (success)=>{\n\n                                                            //console.log('HealthService requestAuthorization() success:', success)\n                                                            this.loadingData = true;\n                                                            this.authService.setShowHealthConnectLocalstorage();\n                                                            this.authService.setCanceledHealthConnectLocalstorage(\"true\");\n                                                            this.readDataFromApp(30);\n                                                            if (comesFromSettings) {\n                                                              this.router.navigate(['settings'], { replaceUrl: true });\n                                                            }\n                                                            else {\n                                                              this.router.navigate(['home'], { replaceUrl: true });\n                                                            }\n                                                            \n                                                            this.enableHealthConnectSettings = true;\n                                    \n                                                          },\n                                                            (error)=>{\n                                                              //console.log('HealthService requestAuthorization() error:', error)\n                                                              this.enableHealthConnectSettings = false;\n                                                            })\n                \n           } else {\n              this.loadingData = true;\n              this.authService.setShowHealthConnectLocalstorage();\n              this.authService.setCanceledHealthConnectLocalstorage(\"true\");\n              this.readDataFromApp(30);\n              this.router.navigate(['home']);\n              this.enableHealthConnectSettings = true\n           }\n          }, (error) => {\n            this.presentAlertConfirm();\n            //console.log(error);\n          });\n        } else {\n          this.enableHealthConnectSettings = false;\n          this.presentAlertConfirm();\n          //console.log(\"Health plugin not available\");\n        }\n      }, (e) => {\n        //this.presentAlertConfirm(e);\n        console.error('[HealthService] connect(): error', e)\n       this.downloadHealthConnect();\n      });\n    }\n  }\n\n  retrieveData() {\n    if (this.platform.is(\"cordova\")) {\n      cordova.plugins.health.isAvailable((available) => {\n        if (available) {\n\n          cordova.plugins.health.isAuthorized({ read : this.dataTypes}, (authorized) => {\n            if (authorized) {                                          \n              this.loadingData = true;\n              this.authService.setShowHealthConnectLocalstorage();\n              this.authService.setCanceledHealthConnectLocalstorage(\"true\");\n              this.readDataFromApp(30);\n              this.enableHealthConnectSettings = true;\n            } \n            else {\n              this.enableHealthConnectSettings = false;\n            }\n          }, (error) => {\n            this.presentAlertConfirm();\n            //console.log(error);\n          });\n        }\n      }, (e) => {\n        //this.presentAlertConfirm(e);\n        console.error('[HealthService] connect(): error', e)\n      });\n    }\n  }\n\n  readDataFromApp(days) {\n    let startDate = new Date(new Date().getTime() - days * 24 * 60 * 60 * 1000);\n    let endDate = new Date(); // now\n\n    //console.log(\"Entering for reading data\")\n     this.readData(startDate, endDate); \n    // this.readBloodGlucose(startDate, endDate);\n    //  this.readSteps(startDate, endDate);\n    //  this.readDistance(startDate, endDate);\n    //this.readHeartRate(startDate, endDate);\n    // this.readWeightData(startDate, endDate);\n\n\n    // setTimeout(()=> this.readBloodGlucose(startDate, endDate), 500); \n    // setTimeout(()=> this.readSteps(startDate, endDate), 1500); \n    // setTimeout(()=> this.readDistance(startDate, endDate), 1500); \n    // setTimeout(()=> this.readWeightData(startDate, endDate), 1500); \n    // setTimeout(()=> this.readHeartRate(startDate, endDate), 500); \n  }\n\n  async readData(startDate: Date, endDate: Date) {\n    await this.platform.ready();\n\n    //console.log(\"[HealthService] Entering for reading health data\");\n\n    for (const element of this.dataTypes) {\n      const config: any = { startDate: startDate, endDate: endDate, dataType: element };\n\n      if (element === 'distance' || element === 'steps') {\n        config['bucket'] = 'hour';\n        try {\n          const data = await this.queryAggregatedHealthData(config);\n          //console.log(`DATA HEALTH CONNECT (${element}): `, JSON.stringify(data));\n          await this.postHealth(element, data);\n        } catch (error) {\n          console.error(`Error for posting ${element} data: `, error);\n        }\n      } else {\n        try {\n          const data = await this.queryHealthData(config);\n          //console.log(`DATA HEALTH CONNECT (${element}): `, JSON.stringify(data));\n          await this.postHealth(element, data);\n        } catch (error) {\n          console.error(`Error for posting ${element} data: `, error);\n        }\n      }\n    }\n  }\n\n  queryAggregatedHealthData(config: any): Promise<any> {\n    return new Promise((resolve, reject) => {\n      cordova.plugins.health.queryAggregated(\n        config,\n        (data: any) => resolve(data),\n        (error: any) => reject(error)\n      );\n    });\n  }\n\n  queryHealthData(config: any): Promise<any> {\n    return new Promise((resolve, reject) => {\n      cordova.plugins.health.query(\n        config,\n        (data: any) => resolve(data),\n        (error: any) => reject(error)\n      );\n    });\n  }\n\n  readWeightData(startDate: Date, endDate: Date) {\n    //console.log(\"[HealthService] Entering for reading weight data\")\n    //cordova.plugins.health.query({startDate: startDate,  endDate: endDate ,  dataType: 'weight'}, (data)=> {this.postHealth('weight', data);}, ()=> {console.error()})\n    cordova.plugins.health.query({\n      startDate: startDate,  endDate: endDate,\n      dataType: 'weight'}, \n      (data: any)=> {this.postHealth('weight', data)}, \n      (error)=> {console.error(\"Error for posting weight data: \", error)}\n    )\n  }\n\n  readBloodGlucose(startDate: Date, endDate: Date) {\n    //console.log(\"[HealthService] Entering for reading blood_glucose data\")\n    cordova.plugins.health.query({\n      startDate: startDate, endDate: endDate, \n      dataType: 'blood_glucose'}, \n      (data)=> {this.postHealth('blood_glucose', data)}, \n      (error)=> {console.error(\"Error for posting blood_glucose data \", error)})\n  }\n\n  readSteps(startDate: Date, endDate: Date) {\n    //console.log(\"[HealthService] Entering for reading steps data\")\n    cordova.plugins.health.queryAggregated(\n      {startDate: startDate, endDate: endDate, dataType: 'steps', bucket: 'day'}, \n      (data)=> {this.postHealth('steps', data)}, \n      (error)=> {console.error(\"Error for posting steps data \", error)})\n  }\n\n  readDistance(startDate: Date, endDate: Date) {\n    //console.log(\"[HealthService] Entering for reading distance data\")\n    cordova.plugins.health.queryAggregated(\n      {startDate: startDate, endDate: endDate, dataType: 'distance', bucket: 'day'}, \n      (data)=> { this.postHealth('distance', data)}, \n      (error)=> {console.error(\"Error for posting distance data \", error)})\n      .then( data => {\n        //console.log(\"[HealthService] Entering for reading distance data1\", data)\n      });\n  }\n\n  readHeartRate(startDate: Date, endDate: Date) {\n    //console.log(\"[HealthService] Entering for reading heart_rate data\")\n    cordova.plugins.health.query({\n      startDate: startDate, endDate: endDate,\n      dataType: 'heart_rate'}, \n      (data)=> {this.postHealth('heart_rate', data)}, ()=> {console.error()})\n  }\n\n  //To send POST with health data to api\n  async postHealth(type: string, data: any) {\n    //console.log(\"[HealthService] postHealth()\", type, data);\n    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;\n    //console.log('[HealthService] syncData', timezone);\n    const postData: any = {\n      timezone: timezone,\n      type: type,\n      vals: JSON.stringify(data),\n    };\n    //console.log('[HealthService] postObject', postData);\n    if (this.authService?.deviceToken) {\n      postData['device_token'] = this.authService.deviceToken;\n    }\n    try {\n      const response = await this.dooleService.post('user/element/sync', postData).toPromise();\n      //console.log('[HealthService] apiRes', JSON.stringify(response));\n    } catch (error) {\n      //console.log('[HealthService] apiErr', JSON.stringify(error));\n      throw error;\n    }\n  }\n\n  async presentAlertConfirm(error?) {\n    const alert = await this.alertController.create({\n      cssClass: 'my-alert-class',\n      header: this.getErrorMessage(error),\n      buttons: [\n        {\n          text: this.translate.instant(\"alert.button_cancel\"),\n          role: 'cancel',\n          cssClass: 'secondary',\n          handler: async (blah) => {\n            //console.log('Confirm Cancel: blah');\n          }\n        }, {\n          text: this.translate.instant(\"health-connect.return_home\"),\n          handler: () => {\n            this.authService.setShowHealthConnectLocalstorage()\n            if (this.router.url.includes('landing')) \n              this.router.navigate(['landing']);\n            else\n              this.router.navigate(['home']);\n          }\n        }\n      ]\n    });\n    await alert.present();\n  }\n\n  getErrorMessage(e?):string{\n    if(e && e === 'Health Connect is not installed'){\n      return this.translate.instant(\"health-connect.error_msg_not_install\")\n    }else\n      return this.translate.instant(\"health-connect.error_msg\")\n  }\n}\n"]}