@doolehealth/service-lib 0.0.1

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

@@ -0,0 +1,1299 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Capacitor } from '@capacitor/core';
+import { map } from 'rxjs/operators';
+import { HttpParams } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/authentication.service";
+import * as i2 from "@awesome-cordova-plugins/file-transfer/ngx";
+import * as i3 from "@awesome-cordova-plugins/file/ngx";
+import * as i4 from "./http.service";
+import * as i5 from "../services/api-endpoints.service";
+import * as i6 from "./events.service";
+import * as i7 from "@ionic/angular";
+import * as i8 from "@angular/router";
+export 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: i1.AuthenticationService }, { token: i2.FileTransfer }, { token: i3.File }, { token: i4.HttpService }, { token: i5.ApiEndpointsService }, { token: i6.Events }, { token: i7.Platform }, { token: i8.Router }, { token: i7.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: i1.AuthenticationService }, { type: i2.FileTransfer }, { type: i3.File }, { type: i4.HttpService }, { type: i5.ApiEndpointsService }, { type: i6.Events }, { type: i7.Platform }, { type: i8.Router }, { type: i7.AlertController }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"doole.service.js","sourceRoot":"","sources":["../../../../../projects/service-lib/src/lib/services/doole.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { FileTransfer, FileUploadOptions, FileTransferObject } from '@awesome-cordova-plugins/file-transfer/ngx';\nimport { ApiEndpointsService } from '../services/api-endpoints.service'\nimport { Events } from './events.service';\nimport { HttpService } from './http.service';\nimport { Observable, of, throwError, TimeoutError } from 'rxjs';\nimport { AlertController, Platform } from '@ionic/angular';\nimport { File } from '@awesome-cordova-plugins/file/ngx';\nimport { Capacitor } from '@capacitor/core';\nimport { catchError, delay, filter, map, mergeMap } from 'rxjs/operators';\nimport { HealthCard } from '../models/user';\nimport { Router } from '@angular/router';\nimport { HttpHeaders, HttpParams } from '@angular/common/http';\nimport { QueryStringParameters } from '../util/query-string-parameters';\nimport { ShellChatModel, ShellMessageModel, ShellRecipientModel } from '../util/chatParameters';\nimport { AuthenticationService } from '../services/authentication.service'\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DooleService {\n  pushNotification: any;\n  constructor(\n    private authService: AuthenticationService,\n    private transfer: FileTransfer,\n    private file: File,\n    private http: HttpService,\n    private api: ApiEndpointsService,\n    public events: Events,\n    private platform: Platform,\n    public router: Router,\n    public alertController: AlertController) { }\n  public selectedDate: Date;\n\n  uploadFile(image: string, id?: string) {\n\n    console.log(\"uploading \", image);\n    const token = localStorage.getItem('token');\n    let options: FileUploadOptions = {\n      fileKey: 'file',\n      fileName: 'name.jpg',\n\n      headers: {\n        'Authorization': 'Bearer ' + token,\n        'Accept': 'application/json',\n      },\n      params: {\n        id: id\n      }\n    }\n\n    const fileTransfer: FileTransferObject = this.transfer.create();\n    // Add files for new or saved diagnostics.\n    // uses diagnostic/media when diagnostic is new\n    //const endpoint = id ? this.api.getEndpoint('diagnostic/media'):this.api.getDooleEndpoint('media/upload/temp') ;\n    const endpoint = this.api.getEndpoint('media/upload/temp');\n    //console.log(\"* uploadFile endpoint\", endpoint);\n\n    return new Promise(function (resolve, reject) {\n      fileTransfer.upload(image, endpoint, options).then(data => {\n        console.log(data);\n        resolve(JSON.parse(data.response));\n      }, (err) => {\n        console.log(err);\n        reject(err);\n      })\n    })\n\n  }\n\n\n\n  postAPIAddMedia(params: Object){\n    const endpoint = this.api.getEndpoint('media/add');\n\n    return this.http.postForm(endpoint, params).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] postAPIAddMedia(${endpoint}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  uploadFileToModel(image: string, name: string, params: any) {\n    //console.log(\"uploading \", image);\n    const token = localStorage.getItem('token');\n    let options: FileUploadOptions = {\n      fileKey: 'file',\n      fileName: name,\n      headers: {\n        'Authorization': 'Bearer ' + token,\n        'Accept': 'application/json',\n      },\n      params\n    }\n\n    const fileTransfer: FileTransferObject = this.transfer.create();\n    const endpoint = this.api.getEndpoint('media/add');\n    return new Promise(function (resolve, reject) {\n      fileTransfer.upload(image, endpoint, options).then(data => {\n        console.log(JSON.parse(data.response));\n        resolve(JSON.parse(data.response));\n      }, (err) => {\n        console.log(err);\n        reject(err);\n      })\n    })\n\n  }\n\n  uploadMessageImage(idMessageHeader, idUserTo, message, fileUrl, id_usuari_amiq) {\n\n    const token = localStorage.getItem('token');\n\n    let options: FileUploadOptions = {\n      fileKey: 'file',\n      fileName: 'name.pdf', //TODO: 'name.jpg'\n      headers: {\n        'Authorization': 'Bearer ' + token,\n        'Accept': 'application/json',\n      },\n      params: {\n        idUser: id_usuari_amiq,\n        secret: token,\n        value: \"\",\n        id: idMessageHeader\n      }\n    }\n    //console.log(\"options: \", options);\n\n    const fileTransfer: FileTransferObject = this.transfer.create();\n\n    fileTransfer.onProgress((progressEvent) => {\n      if (progressEvent.lengthComputable) {\n        var perc = Math.floor(progressEvent.loaded / progressEvent.total * 100);\n        this.events.publish(\"uploadMessageImage\", { fileUrl, perc });\n      } else {\n        //console.log(\"progressEvent - \", progressEvent);\n      }\n    });\n\n    const endpoint = this.api.getEndpoint('message');\n\n    return new Promise(function (resolve, reject) {\n      fileTransfer.upload(fileUrl, endpoint, options)\n        .then(data => {\n          //console.log(\"success fileTransfer.upload\", JSON.parse(data.response));\n          resolve(JSON.parse(data.response));\n        }, (err) => {\n          //console.log(\"** error ** fileTransfer.upload: \", err);\n          reject(fileTransfer.upload);\n        })\n    })\n\n  }\n\n  b64toBlob(b64Data, contentType = '', sliceSize = 512) {\n    const byteCharacters = atob(b64Data);\n    const byteArrays = [];\n\n    for (let offset = 0; offset < byteCharacters.length; offset += sliceSize) {\n      const slice = byteCharacters.slice(offset, offset + sliceSize);\n\n      const byteNumbers = new Array(slice.length);\n      for (let i = 0; i < slice.length; i++) {\n        byteNumbers[i] = slice.charCodeAt(i);\n      }\n\n      const byteArray = new Uint8Array(byteNumbers);\n      byteArrays.push(byteArray);\n    }\n\n    const blob = new Blob(byteArrays, { type: contentType });\n    return blob;\n  }\n\n  downloadFile(url, destination): Observable<any> {\n    var result: any = [];\n    const fileTransfer: FileTransferObject = this.transfer.create();\n    var path = null;\n\n    if (this.platform.is('ios')) {\n      path = this.file.documentsDirectory;\n    } else {\n      path = this.file.dataDirectory;\n    }\n\n    //console.log(\"downloadFile\", url, destination, 'path,destination', path, destination);\n    return new Observable((observer) => {\n      //console.log(\"before CheckFile\", this.file);\n      this.file.checkFile(path, destination).then(res => {\n        //console.log(\"*res*\", res);\n        if (res) {\n          //console.log(\"exists\", res);\n          result[\"success\"] = true;\n          result[\"downloaded\"] = true;\n          result[\"file\"] = path + destination;//normalizeURL(this.file.cacheDirectory + destination);\n          result[\"fileNormalized\"] = Capacitor.convertFileSrc(path + destination);\n          return observer.next(result);\n        }\n      }, error => {\n        //console.log(\"not exists\");\n        fileTransfer.onProgress(event => {                                //descarreguem\n          if (event.lengthComputable) {\n            //console.log(event.loaded / event.total);\n            result[\"status\"] = \"downloading\";\n            result[\"downloaded\"] = false;\n            result[\"percent\"] = Math.round((event.loaded / event.total) * 100);\n            return observer.next(result);\n          }\n        });\n\n        return fileTransfer.download(url, path + destination).then((entry) => {\n          //console.log('*download:* ' + url + \" \" + entry.toURL());\n          result[\"success\"] = true;\n          result[\"downloaded\"] = true;\n          result[\"file\"] = entry.toURL();//normalizeURL(this.file.cacheDirectory + destination);\n          result[\"fileNormalized\"] = Capacitor.convertFileSrc(path + destination);\n          return observer.next(result);\n        }, (error) => {\n          //console.log(error);\n          result[\"success\"] = false;\n          result[\"downloaded\"] = false;\n          //console.log(\"error download \" + url);\n          //console.log(result);\n          return observer.next(result);\n        })\n      });\n    });\n  }\n\n  deleteFile(id): Observable<any> {\n    let path = `media/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.delete(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] deleteFile(${path}) res: ${res}`, JSON.stringify(res));\n        return res;\n\n      })\n    );\n  }\n\n  showAlert(message: string) {\n\n    return this.alertController.create({\n      header: 'Info',\n      message: message,\n      backdropDismiss: false,\n      buttons: ['OK']\n    });\n\n  }\n\n  async showAlertAndReturn(header: string, message: string, isDismiss?: boolean, route?: string) {\n    //console.log(`[DooleService] showAlertAndReturn()`);\n    let dismiss = (isDismiss !== undefined) ? isDismiss : false\n    const alert = await this.alertController.create({\n      header: header,\n      message: message,\n      backdropDismiss: dismiss,\n      buttons: [\n        {\n          text: 'OK',\n          handler: (blah) => {\n           // console.log('Confirm OK: blah');\n            if (route !== undefined && route !== null)\n              this.router.navigateByUrl(route);\n          }\n        }\n      ]\n    });\n    await alert.present();\n  }\n\n  async presentAlert(message, button?: string) {\n    let buttonName = (button !== undefined) ? button : 'Ok'\n    const alert = await this.alertController.create({\n      cssClass: 'my-alert-class',\n      message: message,\n      buttons: [buttonName]\n    });\n    await alert.present();\n  }\n\n  getFamilyUnitID(): HttpParams {\n    let httpParams = new HttpParams();\n    let user = this.authService?.user\n    return httpParams = (user.familyUnit) ? httpParams.append('user', user.familyUnit) : httpParams\n  }\n\n  getAPILegalInformation(): Observable<any> {\n    let path = 'user/legalTerm/lastAccepted';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPILegalInformation(${path}) res: `, res);\n        return res;\n      })\n    )\n  }\n\n  postAPILegalConfirmation(params: Object): Observable<any> {\n    let path = 'user/legalTerm/lastAccepted';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] postAPIConfirmationLegal(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  postAPIRejectLegalConfirmation(params: Object): Observable<any> {\n    let path = 'user/legalTerm/lastDeclined';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] postAPIConfirmationLegal(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  postAPIpasswordRecovery(params: Object): Observable<any> {\n    let path = 'patient/forgot'\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] postAPIpasswordRecovery(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIStaffSlots(params: { id: number, date: string }): Observable<any> {\n\n    let path = `staff/${params.id}/availability`;\n    let endpoint: string;\n    if (params.date !== \"\") {\n      endpoint = this.api.getEndpointWithParameters(path, (qs: QueryStringParameters) => qs.push('date', params.date));\n    } else {\n      endpoint = this.api.getEndpoint(path);\n    }\n\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIStaffSlots(${path}) res: `, res);\n        return res;\n      })\n    )\n  }\n\n  getAPIgoals(): Observable<any> {\n    let path = 'user/element/goals'\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIhomeInitial(${path}) res: `, res);\n        return res;\n      })\n    )\n  }\n\n  getAPIvideocall(id:string): Observable<any>{\n    let path = 'user/agenda/'+id+'/videocallSession'\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIvideocall(${path}) res: `, res);\n        return res;\n      })\n    )\n  }\n\n\n  postAPIPendingConnect(): Observable<any>{\n    let path = 'user/videocall/pendingConnect'\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIPendingConnect(${path}) res: `, res);\n        return res;\n      })\n    )\n  }\n\n/*   getAPIinformationUser(): Observable<any>{\n\n    let path = 'user/informationUser'\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIhomeInitial(${path}) res: `, res);\n        return res;\n      })\n    )\n  } */\n\n\n  getAPIinformationSummary(params: Object){\n    let path = 'home'\n    const endpoint = this.api.getEndpoint(path);\n    console.log('home params', params)\n    return this.http.post(endpoint, params).pipe(\n      map(res => res)\n    );\n  }\n  getAPIinformationSummaryOld(params: Object){\n    let path = 'home'\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map(res => res)\n    );\n  }\n\n\n  getAPIuserProfile(): Observable<any> {\n    let path = 'v2/user/profile'\n    //let httpParams = this.getFamilyUnitID()\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIhomeInitial(${path}) res: `, res);\n        return res;\n      })\n    )\n  }\n\n  postAPIChangePassword(params: Object): Observable<any> {\n    let path = 'user/changePassword';\n    let httpParams = this.getFamilyUnitID()\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] postAPIChangePassword(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  getAPInotificationConfigurations(): Observable<any> {\n    let path = 'user/configuration'\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPInotificationConfigurations(${path}) res: `, res);\n        return res;\n      })\n    )\n  }\n\n  postAPIConfiguration(params: Object): Observable<any> {\n    let path = 'user/configuration';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] postAPIConfiguration(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  getAPIlanguagesCenter(): Observable<any> {\n    let path = 'center/languages'\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIlanguagesCenter(${path}) res: `, res);\n        return res;\n      })\n    )\n  }\n\n  getAPIFaqs(): Observable<any> {\n    let path = 'center/faq'\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIhomeInitial(${path}) res: `, res);\n        return res;\n      })\n    )\n  }\n\n  getAPIFamilyUnit(): Observable<any> {\n    let path = 'user/familyUnit';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIFamilyUnit(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n  getAPIFamilyUnit2(): Observable<any> {\n    let path = 'v2/user/familyUnit';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIFamilyUnit(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  postAPIReportProblem(params: Object): Observable<any> {\n    let path = 'user/reportProblem'; // 'media/upload/temp'\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] postAPIReportProblem(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  postAPIemailVerification(params: Object): Observable<any> {\n    let path = 'user/email_verification';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] postAPIemailVerification(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  getAPICodeByEmail(): Observable<any> {\n    let path = 'user/resendTwoFactorCode';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPICodeByEmail(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  postAPIcodeVerification(params: Object): Observable<any> {\n    let path = 'user/verifyTwoFactor';\n    //let path = 'user/codeVerification';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] postAPIcodeVerification(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n\n  getAPIhealthCardTypes(): Observable<any> {\n    let path = 'center/healthCardTypes';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIhealthCardTypes(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIhealthCards(): Observable<any> {\n    let path = 'user/healthcards';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPhealthCards(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIhealthCardId(id): Observable<any> {\n    let path = `user/healthcard/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIhealthCard(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  postAPIhealthCards(params: Object): Observable<any> {\n    let path = 'user/healthcard';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] postAPIReportProblem(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  putAPIhealthCard(params: HealthCard): Observable<any> {\n    let path = `user/healthcard/${params.id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.put(endpoint, params).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] putAPIhealthCard(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  deleteAPIhealthCard(params: HealthCard): Observable<any> {\n    let path = `user/healthcard/${params.id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.delete(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] deleteAPIhealthCard(${path}) res: ${res}`, JSON.stringify(res));\n        return res;\n\n      })\n    );\n  }\n\n  getAPISocialRelationType(): Observable<any> {\n    let path = 'center/socialRelationType';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPISocialRelationType(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIemergencyContact(): Observable<any> {\n    let path = 'user/EmergencyContacts';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIemergencyContact(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIemergencyContactID(id: any): Observable<any> {\n    let path = `user/EmergencyContact/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIemergencyContact(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  postAPIemergencyContact(params: Object): Observable<any> {\n    let path = 'user/EmergencyContact';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] postAPIemergencyContact(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  putAPIemergencyContact(id: any, params: Object): Observable<any> {\n    let path = `user/EmergencyContact/${id}`;\n    console.log('[DooleService] putAPIemergencyContact()', params);\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.put(endpoint, params).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] putAPIemergencyContact(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  deleteAPIemergencyContact(id: any): Observable<any> {\n    let path = `user/EmergencyContact/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.delete(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] deleteAPIemergencyContact(${path}) res: ${res}`, JSON.stringify(res));\n        return res;\n\n      })\n    );\n  }\n\n\n  getAPIaboutUs(): Observable<any> {\n    let path = 'center/about';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIaboutUs(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIappointmentAgenda(): Observable<any>{\n    let path = 'user/agenda';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIappointmentAgenda(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  //documents-Tracking\n  getAPIdiagnosticTests(): Observable<any> {\n    let path = 'user/diagnosticTests';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIdiagnosticTests(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIdiagnosticTestTypesAvailable(): Observable<any> {\n    let path = 'diagnosticTestTypes/available';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIdiagnosticTestTypesAvailable(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIdiagnosticTestID(id: Object): Observable<any> {\n    let path = 'v2/user/diagnosticTest/' + id;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIdiagnosticTestID(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  postAPIdiagnosticTest(params: Object): Observable<any> {\n    let path = 'v2/user/diagnosticTests/';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] postAPIdiagnosticTest(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  putAPIdiagnosticTest(id, params: any): Observable<any> {\n    let path = `user/diagnosticTest/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.put(endpoint, params).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] putAPIdiagnosticTest(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  deleteAPIdiagnosticTest(id): Observable<any> {\n    let path = `user/diagnosticTest/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.delete(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] deleteAPIdiagnosticTest(${path}) res: ${res}`, JSON.stringify(res));\n        return res;\n\n      })\n    );\n  }\n\n  getAPIfilteredDiagnosticTest(params: any): Observable<any> {\n    let path = 'user/diagnosticTests';\n    const endpoint = this.api.getEndpoint(path);\n    let httpParams = new HttpParams();\n    // Begin assigning parameters\n    if (params !== undefined) {\n      httpParams = (params.start_date) ? httpParams.append('from_date', params.start_date) : httpParams\n      httpParams = (params.end_date) ? httpParams.append('to_date', params.end_date) : httpParams\n      if (params.diagnosticTestTypes) {\n        params.diagnosticTestTypes.forEach(element => {\n          httpParams = httpParams.append('diagnostic_test_type_id[]', element)\n        });\n      }\n    }\n    return this.http.get(endpoint, httpParams).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIfilteredDiagnosticTest(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n  //forms-Tracking\n  getAPIformLists(): Observable<any> {\n    let path = 'forms/user';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIformLists(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n  //graphics-Tracking\n\n  getAPIelementsList(filter?): Observable<any> {\n    let path = 'user/elements'  /* 'user/elementsList/v2'  */\n    let httpParams = new HttpParams();\n    httpParams = (filter?.only_with_values)? httpParams.append('only_with_values', filter?.only_with_values): httpParams\n    httpParams = (filter?.grouped)? httpParams.append('grouped', filter?.grouped) : httpParams\n    httpParams = (filter?.filter)? httpParams.append('filter', filter?.filter) : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint, httpParams).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIelementsList(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  /** get elements with query by parameter date  */\n  getAPIelementsListByDate(params: any): Observable<any> {\n    let path = 'user/elementsList/v2'  /* 'user/elementsList'  */\n    let httpParams = new HttpParams();\n    if(params.filter == '1') httpParams = httpParams.append('filter', '1')\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint,httpParams).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIelementsListByDate(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  postAPIaddElement(id, params: Object): Observable<any> {\n    let path = 'user/element/' + id + '/value/add'\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] postAPIaddElement(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIgraphicsElement(id: Object, query): Observable<any> {\n    let path = 'user/element/' + id;\n    let httpParams = new HttpParams();\n    httpParams = (query) ? httpParams.append('interval', query) : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint,httpParams).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIgraphicsElement(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIelementID(id: Object, params?): Observable<any> {\n    let path = `v2/user/element/${id}`;\n    let httpParams = new HttpParams();\n    httpParams = (params?.interval) ? httpParams.append('interval', params?.interval) : httpParams\n    httpParams = (params?.from_date) ? httpParams.append('from_date', params?.from_date) : httpParams\n    httpParams = (params?.to_date) ? httpParams.append('to_date', params?.to_date) : httpParams\n    httpParams = (params?.version) ? httpParams.append('version', params?.version) : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint,httpParams).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIgraphicsElement(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIelementAvailableID(id: Object): Observable<any> {\n    let path = `element/available/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIelementAvailableID(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIcategory(): Observable<any> {\n    let path = 'user/element_category';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIcategory(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIelementGroupID(id: Object, filter?): Observable<any> {\n    let path = `center/elementGroup/${id}/elements`;\n    let httpParams = new HttpParams();\n    httpParams = (filter) ? httpParams.append('filter', filter) : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint, httpParams).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIelementGroupID(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  searchAPIelementGroup(params: any): Observable<any> {\n   \n    let path = 'center/elementGroups'\n    let httpParams = new HttpParams();\n    httpParams = (params?.filter) ? httpParams.append('filter', params?.filter) : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint, httpParams).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIelementGroup(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n  /** get diets with query by parameter date  */\n  getAPIlistDietsByDate(params: Object): Observable<any> {\n    let path = 'user/diets';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIlistDietsByDate(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIdietsByDate(params: any): Observable<any> {\n    let path = `user/dietaryIntakes`\n    let httpParams = new HttpParams();\n    httpParams = (params?.date) ? httpParams.append('date', params.date) : httpParams\n    httpParams = (params?.grouped_by_times) ? httpParams.append('grouped_by_times', params.grouped_by_times) : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint, httpParams).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIdietsByDate(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIdetailDiets(id: any): Observable<any> {\n    let path = `diet/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIdetailDiets(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIdetailRecipe(id: any): Observable<any> {\n    let path = `diet/receipt/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIdetailRecipe(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  /** get advices  **/\n  getAPIlistAdvices(params): Observable<any> {\n    let path = 'user/advices';\n    const endpoint = this.api.getEndpoint(path);\n    let httpParams = new HttpParams()\n    .set('tags', params.tags)\n    .set('interactions', params.interactions)\n    .set('readingTime', params.readingTime);\n    return this.http.get(endpoint, httpParams).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIlistAdvices(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n    /** get news  **/\n  getAPIlistNews(): Observable<any> {\n    let path = 'user/news';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIlistNews(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIdetailNew(id: any): Observable<any> {\n    let path = `user/new/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIdetailNew(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPISearchNews(query: any): Observable<any> {\n    let path = 'news';\n    let httpParams = new HttpParams();\n    httpParams = (query) ? httpParams.append('search', query) : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint, httpParams).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPISearchNews(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIAppLatestVersion(version, platform): Observable<any> {\n    let path = 'app/versions/must-update?version='+version+'&platform='+platform;\n    console.log(path);\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n\n        return res;\n      })\n    )\n  }\n\n  getAPISearchAdvices(query: any): Observable<any> {\n    let path = 'advices';\n    let httpParams = new HttpParams();\n    httpParams = (query) ? httpParams.append('search', query) : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint, httpParams).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPISearchAdvices(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIdetailAdvices(id: any): Observable<any> {\n    let path = `advice/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIdetailAdvices(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIdrugsList(query: any): Observable<any> {\n    let path = `drugIntake/list`;\n    let httpParams = new HttpParams();\n    httpParams = (query) ? httpParams.append('search', query) : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint, httpParams).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIdrugsList(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n\n  getAPIdrugIntakeByDate(params: Object): Observable<any> {\n    let path = 'user/drugIntake/date';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIdrugIntakeByDate(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n// send medication list\n  getAPImedicationList(query: any): Observable<any> {\n    let path = `sendmedication/list`;\n    let httpParams = new HttpParams();\n    httpParams = (query) ? httpParams.append('search', query) : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint, httpParams).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPImedicationList(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIdirectionsList(): Observable<any> {\n    let path = `user/addresses`;\n    // let httpParams = new HttpParams();\n    // httpParams = (query) ? httpParams.append('search', query) : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIdirectionList(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n  getAPImedicationsList(): Observable<any> {\n    let path = `sendmedication/list`;\n    // let httpParams = new HttpParams();\n    // httpParams = (query) ? httpParams.append('search', query) : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIdirectionList(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  postAPIsendDirection(params: Object): Observable<any> {\n    let path = 'user/address';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] postAPIsendDirection(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  putAPIsendDirection(id: any, params: Object): Observable<any> {\n    let path = `user/address/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.put(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] putAPIdrugIntake(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  deleteAPIsendDirection(id: Object): Observable<any> {\n    let path = `user/address/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.delete(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] deleteAPImedicationPlan(${path}) res: ${res}`, JSON.stringify(res));\n        return res;\n      })\n    );\n  }\n\n  postAPImedicationSendPetition(params: Object): Observable<any> {\n    let path = 'sendmedication';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] postAPIsendDirection(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  postAPIdrugIntake(params: Object): Observable<any> {\n    let path = 'user/drugIntake';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] postAPIdrugIntake(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  postAPIchangeStatedrugIntake(id: Object, state: Object): Observable<any> {\n    let path = `user/drugIntake/${id}/set/${state}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] postAPIdrugIntake(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  postAPImedicationPlan(params: Object): Observable<any> {\n    let path = `user/medicationPlan`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] postAPIdrugIntake(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  putAPImedicationPlan(id: any, params: Object): Observable<any> {\n    let path = `user/medicationPlan/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.put(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] putAPIdrugIntake(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  deleteAPImedicationPlan(id: Object): Observable<any> {\n    let path = `user/medicationPlan/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.delete(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] deleteAPImedicationPlan(${path}) res: ${res}`, JSON.stringify(res));\n        return res;\n      })\n    );\n  }\n\n  getAPImedicationPlan(id): Observable<any> {\n    let path = `user/medicationPlan/${id}`\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPImedicationPlan(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIgames(): Observable<any> {\n    let path = 'user/games';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIgames(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n  /** get games with query by parameter date  */\n  getAPIgamesByDate(from_date: any, to_date: any): Observable<any> {\n    let path = 'user/gamePlays/scheduled';\n    let httpParams = new HttpParams();\n    httpParams = (from_date) ? httpParams.append('from_date', from_date) : httpParams\n    httpParams = (to_date) ? httpParams.append('to_date', to_date) : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint, httpParams).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIgames(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n  getAPIgameId(id): Observable<any> {\n    let path = `user/game/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIgameId(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIagenda(): Observable<any> {\n    let path = 'user/agenda';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIagenda(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIallAgenda(params?): Observable<any>{\n    let path = 'user/agenda/v2';\n    let httpParams = new HttpParams();\n    httpParams = params?.from_date? httpParams.append('from_date', params?.from_date) : httpParams\n    httpParams = params?.to_date? httpParams.append('to_date', params?.to_date) : httpParams\n    httpParams = params?.filter_by_date? httpParams.append('filter_by_date', params?.filter_by_date) : httpParams\n    httpParams = (params?.with_medical_procedures != undefined)? httpParams.append('with_medical_procedures', params?.with_medical_procedures) : httpParams\n    httpParams = (params?.order != undefined)? httpParams.append('order', params?.order) : httpParams\n\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint, httpParams).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIappointmentAgendaV2(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIagendaID(id): Observable<any> {\n    let path = `user/agenda/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIagendaID(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  postAPIaddAgenda(params: Object): Observable<any> {\n    let path = 'user/agenda/'\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] postAPIaddAgenda(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  deleteAPIaddAgenda(id: Object): Observable<any> {\n    let params = { agenda: id }\n    let path = 'user/agenda/delete'\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] deleteAPIaddAgenda(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  putAPIagenda(id: any, params: Object): Observable<any> {\n    let path = `user/agenda/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.put(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] putAPIagenda(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIallowedContacts(): Observable<any> {\n    let path = `user/allowedContacts`;\n    const endpoint = this.api.getEndpoint(path);\n    let httpParams = new HttpParams();\n    httpParams = httpParams.append('withDepartments', '1')\n    return this.http.get(endpoint,httpParams).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIallowedContacts(${path}) res: `, res);\n        let allowed = res.allowed\n        if(res.allowed === undefined)\n        allowed = []\n        return allowed;\n\n      })\n    );\n  }\n\n  getAPIstaffId(id): Observable<any> {\n    let path = `staff/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIstaffId(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  /** get games with query by parameter date  */\n  getAPIUserMessages(): Observable<ShellChatModel[]> {\n\n    let path = 'message/user';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n\n        console.log(`[DooleService] getAPIUserMessages(${path}) res: `, res);\n        if(res.length == 0)\n        return res\n        return res.messages as ShellChatModel[];\n      })\n    );\n  }\n  // get the company details, a subset of the user data\n  getUserSubsetData(): Observable<ShellChatModel> {\n    let path = 'message/user';\n    const endpoint = this.api.getEndpoint(path);\n\n    const dataObservable = this.http.get(endpoint);\n\n    return dataObservable.pipe(\n      map((jsonResponse) => {\n        const filteredData: ShellChatModel = {\n          ...jsonResponse.messages\n        };\n        return filteredData;\n      })\n    );\n  }\n/** Reminders */\n  getAPIreminders(): Observable<any> {\n    let path = 'user/reminder';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIreminders(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIreminderID(id): Observable<any> {\n    let path = `user/reminder/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIreminderID(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  postAPIaddReminder(params: Object): Observable<any> {\n    let path = 'user/reminder/'\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] postAPIaddReminder(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  deleteAPIReminder(id): Observable<any> {\n    let path = `user/reminder/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.delete(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] deleteAPIReminder(${path}) res: ${res}`, JSON.stringify(res));\n        return res;\n      })\n    );\n  }\n\n  updateAPIReminder(id: any, params: Object): Observable<any> {\n    let path = `user/reminder/${id}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.put(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] updateAPIReminder(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  updateAPIuser(params: Object): Observable<any> {\n    let path = `user`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.put(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] updateAPIReminder(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  updateAPIImageuser(params: Object): Observable<any> {\n    let path = `user/image`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.put(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] updateAPIReminder(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n  deleteAPIImageuser(): Observable<any> {\n    let path = `user/image`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.delete(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] updateAPIReminder(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n  postAPIContentStatus(params: Object): Observable<any> {\n    let path = 'content/status'\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] postAPIContentStatus(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIpatients(): Observable<any> {\n    let path = 'user/patients';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIreminders(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPILevelInfo(challengeId, levelId, params?): Observable<any> {\n    let path = 'user/challenge/'+challengeId+'/level/'+ levelId+'/goals'\n\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPILevelInfo(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIChallenge(challengeId, params?): Observable<any> {\n    let path = 'user/challenge/'+challengeId\n\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIChallenge(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIChallenges( params?): Observable<any> {\n    let path = 'user/challenges'\n\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        console.log(`[DooleService] getAPIChallenges(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n\n\n\n  getAPImessage(id, params): Observable<any> {\n    let path = 'user/message/' + id\n    let httpParams = new HttpParams();\n    httpParams = params?.page? httpParams.append('page', params?.page) : httpParams\n    httpParams = params?.user? httpParams.append('user', params?.user) : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint, httpParams).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIelementsList(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIFormJSON(form, params?): Observable<any> {\n    let path = `form/${form}/formFields`;\n    let httpParams = new HttpParams();\n    httpParams = (params?.formAnswer) ? httpParams.append('formAnswer', params?.formAnswer)  : httpParams\n    httpParams = (params?.game_play_id) ? httpParams.append('game_play_id', params?.game_play_id)  : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint, httpParams).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIreminders(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  postAPIFormJSON(form, params): Observable<any> {\n    let path = `formfield/conditional/${form}/field/${params.formField}`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] postAPIContentStatus(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  postAPIFormFill(params): Observable<any> {\n    let path = `form/fill/`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] postAPIContentStatus(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPINotificationsCount(): Observable<any> {\n    let path = 'user/notifications/count';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPINotifications(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPINotifications(params?): Observable<any> {\n    let path = 'user/notifications';\n    let httpParams = new HttpParams();\n    httpParams = (params?.read) ? httpParams.append('read', params?.read) : httpParams\n    httpParams = (params?.withPaginate == 1) ? httpParams.append('withPaginate', params?.withPaginate) : httpParams\n    httpParams = (params?.page > 0) ? httpParams.append('page', params?.page) : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint, httpParams).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPINotifications(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  postAPINotificationRead(id): Observable<any> {\n    let path = `user/notification/read`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, id).pipe(\n      map((res: any) => {\n        return res;\n      })\n    );\n  }\n\n  get(endpt): Observable<any> {\n    const endpoint = this.api.getEndpoint(endpt);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        return res;\n      })\n    );\n  }\n\n  post(endpt, items): Observable<any> {\n    const endpoint = this.api.getEndpoint(endpt);\n    return this.http.post(endpoint, items).pipe(\n      map((res: any) => {\n        return res;\n      })\n    );\n  }\n\n  setPushNotification(pushNotification: any){\n    this.pushNotification = pushNotification;\n  }\n\n  getPushNotification(){\n   return this.pushNotification;\n  }\n\n  getAPIUserImage(): Observable<any> {\n    let path = 'user/image';\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIgames(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  getAPIFormsByDate(params: any): Observable<any> {\n    let path = `rehabilify/sharedcareplan/forms`;\n    let httpParams = new HttpParams();\n    httpParams = (params?.date) ? httpParams.append('date', params.date) : httpParams\n    httpParams = (params?.grouped_by_times) ? httpParams.append('grouped_by_times', params.grouped_by_times) : httpParams\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.get(endpoint, httpParams).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] getAPIdietsByDate(${path}) res: `, res);\n        return res;\n      })\n    );\n  }\n\n  postAPImedicalProcedures(params?: Object): Observable<any> {\n    let path = `user/medicalProcedures`;\n    const endpoint = this.api.getEndpoint(path);\n    return this.http.post(endpoint, params).pipe(\n      map((res: any) => {\n        //console.log(`[DooleService] postAPIdrugIntake(${path}) res: `, res);\n        return res;\n\n      })\n    );\n  }\n\n\n}\n"]}