@doolehealth/service-lib 0.0.1

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

@@ -0,0 +1,124 @@
+import { Injectable } from '@angular/core';
+import { HttpHeaders, HttpClient, HttpParams } from '@angular/common/http';
+import { catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/authentication.service";
+export class HttpService {
+    constructor(http, httpBackend, authService) {
+        this.http = http;
+        this.httpBackend = httpBackend;
+        this.authService = authService;
+        this.httpWithoutInterceptor = new HttpClient(httpBackend);
+    }
+    async formatErrors(error) {
+        return error;
+    }
+    get(path, params = new HttpParams()) {
+        let user = this.authService?.user;
+        params = (user?.familyUnit) ? params.append('user', user?.familyUnit) : params;
+        return this.http.get(`${path}`, { params })
+            .pipe(catchError(this.formatErrors));
+    }
+    put(path, body = {}, options = {}) {
+        let httpOptions = this.setHttpOptions(options);
+        //console.log("url: ", path);
+        //console.log("body: ", body);
+        return this.http.put(`${path}`, JSON.stringify(body), httpOptions).pipe(catchError(this.formatErrors));
+    }
+    postform(path, body = {}, options = {}) {
+        let user = this.authService?.user;
+        if (user?.familyUnit !== null)
+            body['user'] = user?.familyUnit;
+        let httpOptions = this.setHttpOptions(options);
+        //console.log("url: ", path);
+        //console.log("body: ", body);
+        return this.http.post(`${path}`, JSON.stringify(body), httpOptions).pipe(catchError(this.formatErrors));
+    }
+    post(path, body = {}, options = {}, formData) {
+        let user = this.authService?.user;
+        if (user?.familyUnit !== undefined && user?.familyUnit !== null)
+            body['user'] = user?.familyUnit;
+        let httpOptions = this.setHttpOptions(options, formData);
+        //console.log("url: ", path);
+        //console.log("body: ", body);
+        return this.http.post(`${path}`, JSON.stringify(body), httpOptions).pipe(catchError(this.formatErrors));
+    }
+    postForm(path, body = {}, options = {}, formData) {
+        let user = this.authService?.user;
+        if (user?.familyUnit !== null)
+            body['user'] = user?.familyUnit;
+        const httpOptions = {
+            headers: new HttpHeaders({
+                'Accept': 'application/json'
+            })
+        };
+        console.log("url: ", path);
+        console.log("body: ", body);
+        return this.http.post(`${path}`, body, httpOptions).pipe(catchError(this.formatErrors));
+    }
+    delete(path) {
+        return this.http.delete(`${path}`).pipe(catchError(this.formatErrors));
+    }
+    _get(path, params = new HttpParams()) {
+        return this.httpWithoutInterceptor.get(`${path}`, { params })
+            .pipe(catchError(this.formatErrors));
+    }
+    _put(path, body = {}) {
+        return this.httpWithoutInterceptor.put(`${path}`, JSON.stringify(body)).pipe(catchError(this.formatErrors));
+    }
+    _post(path, body = {}, options = {}) {
+        let httpOptions = this.setHttpOptions(options);
+        let params = this.setHttpParams(body);
+        return this.httpWithoutInterceptor.post(`${path}`, JSON.stringify(body), httpOptions).pipe(catchError(error => this.formatErrors(error)));
+    }
+    _delete(path) {
+        return this.httpWithoutInterceptor.delete(`${path}`).pipe(catchError(this.formatErrors));
+    }
+    setHttpParams(body) {
+        let params = new HttpParams();
+        if (body != null)
+            for (let key in body)
+                params = params.append(key, body[key]);
+        return params;
+    }
+    setHttpOptions(options, formData) {
+        console.log('** options', options);
+        if (formData) {
+            const httpOptions = {
+                headers: new HttpHeaders({
+                    'Accept': 'application/json'
+                })
+            };
+            return httpOptions;
+        }
+        else if (Object.keys(options).length > 0) {
+            const httpOptions = {
+                headers: new HttpHeaders({
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                    options
+                })
+            };
+            return httpOptions;
+        }
+        else {
+            const httpOptions = {
+                headers: new HttpHeaders({
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                })
+            };
+            return httpOptions;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: HttpService, deps: [{ token: i1.HttpClient }, { token: i1.HttpBackend }, { token: i2.AuthenticationService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: HttpService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: HttpService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i1.HttpBackend }, { type: i2.AuthenticationService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.service.js","sourceRoot":"","sources":["../../../../../projects/service-lib/src/lib/services/http.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpHeaders, HttpClient, HttpParams, HttpBackend } from '@angular/common/http';\nimport { Observable, throwError, of } from 'rxjs';\nimport { catchError } from 'rxjs/operators';\nimport { AuthenticationService } from '../services/authentication.service'\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class HttpService {\n  private httpWithoutInterceptor: HttpClient;\n\n  constructor(\n    private http: HttpClient,\n    private httpBackend: HttpBackend,\n    private authService: AuthenticationService,\n  ) {\n    this.httpWithoutInterceptor = new HttpClient(httpBackend);\n  }\n\n  private async formatErrors(error: any) {\n    return error;\n  }\n\n  get(path: string, params: HttpParams = new HttpParams()): Observable<any> {\n    let user = this.authService?.user\n    params = (user?.familyUnit) ? params.append('user', user?.familyUnit) : params\n    return this.http.get(`${path}`, { params })\n      .pipe(catchError(this.formatErrors));\n  }\n\n  put(path: string, body: Object = {}, options: Object = {}): Observable<any> {\n\n    let httpOptions = this.setHttpOptions(options);\n    //console.log(\"url: \", path);\n    //console.log(\"body: \", body);\n    return this.http.put(\n      `${path}`,\n      JSON.stringify(body),\n      httpOptions\n    ).pipe(catchError(this.formatErrors));\n  }\n\n  postform(path: string, body: Object = {}, options: Object = {}): Observable<any> {\n    let user = this.authService?.user\n    if (user?.familyUnit !== null)\n      body['user'] = user?.familyUnit;\n\n    let httpOptions = this.setHttpOptions(options);\n    //console.log(\"url: \", path);\n    //console.log(\"body: \", body);\n\n    return this.http.post(\n      `${path}`,\n      JSON.stringify(body),\n      httpOptions\n    ).pipe(catchError(this.formatErrors));\n  }\n\n\n  post(path: string, body: Object = {}, options: Object = {}, formData?): Observable<any> {\n    let user = this.authService?.user\n    if (user?.familyUnit !== undefined && user?.familyUnit !== null)\n      body['user'] = user?.familyUnit;\n\n    let httpOptions = this.setHttpOptions(options,formData);\n    //console.log(\"url: \", path);\n    //console.log(\"body: \", body);\n\n    return this.http.post(\n      `${path}`,\n      JSON.stringify(body),\n      httpOptions\n    ).pipe(catchError(this.formatErrors));\n  }\n\n  postForm(path: string, body: Object = {}, options: Object = {}, formData?): Observable<any> {\n\n    let user = this.authService?.user\n    if (user?.familyUnit !== null)\n      body['user'] = user?.familyUnit;\n\n      const httpOptions = {\n        headers: new HttpHeaders({\n          'Accept': 'application/json'\n        })\n      };\n\n    console.log(\"url: \", path);\n    console.log(\"body: \", body);\n\n    return this.http.post(\n      `${path}`,\n      body,\n      httpOptions\n    ).pipe(catchError(this.formatErrors));\n  }\n\n  delete(path): Observable<any> {\n    return this.http.delete(\n      `${path}`\n    ).pipe(catchError(this.formatErrors));\n  }\n\n  _get(path: string, params: HttpParams = new HttpParams()): Observable<any> {\n    return this.httpWithoutInterceptor.get(`${path}`, { params })\n      .pipe(catchError(this.formatErrors));\n  }\n\n  _put(path: string, body: Object = {}): Observable<any> {\n    return this.httpWithoutInterceptor.put(\n      `${path}`,\n      JSON.stringify(body)\n    ).pipe(catchError(this.formatErrors));\n  }\n\n  _post(path: string, body: Object = {}, options: Object = {}): Observable<any> {\n\n    let httpOptions = this.setHttpOptions(options);\n    let params = this.setHttpParams(body);\n\n\n    return this.httpWithoutInterceptor.post(\n      `${path}`,\n      JSON.stringify(body),\n      httpOptions\n    ).pipe(catchError(error => this.formatErrors(error)));\n  }\n\n  _delete(path): Observable<any> {\n    return this.httpWithoutInterceptor.delete(\n      `${path}`\n    ).pipe(catchError(this.formatErrors));\n  }\n\n  setHttpParams(body) {\n    let params = new HttpParams();\n\n    if (body != null)\n      for (let key in body)\n        params = params.append(key, body[key]);\n\n    return params;\n  }\n\n  setHttpOptions(options, formData?) {\n\n    console.log('** options', options);\n\n    if(formData){\n      const httpOptions = {\n        headers: new HttpHeaders({\n          'Accept': 'application/json'\n        })\n      };\n\n    return httpOptions;\n    }else if(Object.keys(options).length > 0){\n      const httpOptions = {\n        headers: new HttpHeaders({\n          'Content-Type':'application/json',\n          'Accept': 'application/json',\n          options\n        })\n      };\n\n      return httpOptions;\n    }else{\n      const httpOptions = {\n        headers: new HttpHeaders({\n          'Content-Type':'application/json',\n          'Accept': 'application/json',\n        })\n      };\n\n      return httpOptions;\n    }\n\n  }\n}"]}

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

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class LanguageService {
+    constructor(translate) {
+        this.translate = translate;
+        this.languages = new Array();
+        this.languages.push({ name: 'Català', code: 'ca' }, { name: 'Español', code: 'es' }, { name: 'English', code: 'en' });
+    }
+    getLanguages() {
+        return this.languages;
+    }
+    changeLanguage(langCode) {
+        console.log("langCode", langCode);
+        this.translate.use(langCode);
+    }
+    getCurrent() {
+        let lang = this.translate.currentLang ? this.translate.currentLang : this.translate.getDefaultLang();
+        return lang;
+    }
+    getLanguageAPI() {
+        let lang = this.translate.currentLang ? this.translate.currentLang : this.translate.getDefaultLang();
+        return lang == 'es' ? 'cs' : lang;
+    }
+    setLenguageLocalstorage(language) {
+        this.changeLanguage(language);
+        localStorage.setItem('language', language);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LanguageService, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LanguageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LanguageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class LoadingService {
+    constructor() {
+        this.loadingSub = new BehaviorSubject(false);
+        /**
+         * Contains in-progress loading requests
+         */
+        this.loadingMap = new Map();
+    }
+    /**
+     * Sets the loadingSub property value based on the following:
+     * - If loading is true, add the provided url to the loadingMap with a true value, set loadingSub value to true
+     * - If loading is false, remove the loadingMap entry and only when the map is empty will we set loadingSub to false
+     * This pattern ensures if there are multiple requests awaiting completion, we don't set loading to false before
+     * other requests have completed. At the moment, this function is only called from the @link{HttpRequestInterceptor}
+     * @param loading {boolean}
+     * @param url {string}
+     */
+    setLoading(loading, url) {
+        if (!url) {
+            throw new Error('The request URL must be provided to the LoadingService.setLoading function');
+        }
+        if (loading === true) {
+            this.loadingMap.set(url, loading);
+            this.loadingSub.next(true);
+        }
+        else if (loading === false && this.loadingMap.has(url)) {
+            this.loadingMap.delete(url);
+        }
+        if (this.loadingMap.size === 0) {
+            this.loadingSub.next(false);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LoadingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LoadingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LoadingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import { Capacitor } from '@capacitor/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+export class LoggingService {
+    constructor(platform) {
+        this.platform = platform;
+    }
+    logError(message) {
+        // Send errors to be saved here
+        if (Capacitor.isNativePlatform()) {
+            console.error("Error log: ", message);
+        }
+        else {
+            console.error("Error log: ", message);
+        }
+        return;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LoggingService, deps: [{ token: i1.Platform }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LoggingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: LoggingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Platform }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2luZy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc2VydmljZS1saWIvc3JjL2xpYi9zZXJ2aWNlcy9sb2dnaW5nLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0saUJBQWlCLENBQUM7OztBQUs1QyxNQUFNLE9BQU8sY0FBYztJQUV6QixZQUFvQixRQUFrQjtRQUFsQixhQUFRLEdBQVIsUUFBUSxDQUFVO0lBQUksQ0FBQztJQUUzQyxRQUFRLENBQUMsT0FBTztRQUVkLCtCQUErQjtRQUMvQixJQUFJLFNBQVMsQ0FBQyxnQkFBZ0IsRUFBRSxFQUFFLENBQUM7WUFDakMsT0FBTyxDQUFDLEtBQUssQ0FBQyxhQUFhLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDeEMsQ0FBQzthQUFJLENBQUM7WUFDSixPQUFPLENBQUMsS0FBSyxDQUFDLGFBQWEsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUN4QyxDQUFDO1FBRUQsT0FBTztJQUNULENBQUM7K0dBZFUsY0FBYzttSEFBZCxjQUFjLGNBRmIsTUFBTTs7NEZBRVAsY0FBYztrQkFIMUIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBQbGF0Zm9ybSB9IGZyb20gJ0Bpb25pYy9hbmd1bGFyJztcbmltcG9ydCB7IENhcGFjaXRvciB9IGZyb20gJ0BjYXBhY2l0b3IvY29yZSc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIExvZ2dpbmdTZXJ2aWNlIHtcbiAgXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgcGxhdGZvcm06IFBsYXRmb3JtKSB7IH1cblxuICBsb2dFcnJvcihtZXNzYWdlKSB7XG5cbiAgICAvLyBTZW5kIGVycm9ycyB0byBiZSBzYXZlZCBoZXJlXG4gICAgaWYgKENhcGFjaXRvci5pc05hdGl2ZVBsYXRmb3JtKCkpIHtcbiAgICAgIGNvbnNvbGUuZXJyb3IoXCJFcnJvciBsb2c6IFwiLCBtZXNzYWdlKTtcbiAgICB9ZWxzZXtcbiAgICAgIGNvbnNvbGUuZXJyb3IoXCJFcnJvciBsb2c6IFwiLCBtZXNzYWdlKTtcbiAgICB9XG4gICAgXG4gICAgcmV0dXJuO1xuICB9XG5cbn1cbiJdfQ==

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

@@ -0,0 +1,41 @@
+import { Injectable } from '@angular/core';
+import { NavigationEnd } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/common";
+export class NavigationService {
+    constructor(router, location) {
+        this.router = router;
+        this.location = location;
+        this.history = [];
+        this.router.events.subscribe((event) => {
+            if (event instanceof NavigationEnd) {
+                //console.log("NavigationEnd", event.urlAfterRedirects);
+                this.history.push(event.urlAfterRedirects);
+            }
+        });
+    }
+    back() {
+        this.history.pop();
+        if (this.history?.length > 0)
+            this.location.back();
+        else
+            this.router.navigateByUrl("/home");
+    }
+    async close(modalCtrl) {
+        const modal = await modalCtrl?.getTop();
+        if (modal)
+            await modal.dismiss({ error: null });
+        else
+            this.back();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NavigationService, deps: [{ token: i1.Router }, { token: i2.Location }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NavigationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NavigationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i2.Location }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import { fromEvent, merge, of, Observable } from 'rxjs';
+import { mapTo } from 'rxjs/operators';
+import { Capacitor } from '@capacitor/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@awesome-cordova-plugins/network/ngx";
+import * as i2 from "@ionic/angular";
+export class NetworkService {
+    constructor(network, platform) {
+        this.network = network;
+        this.platform = platform;
+        this.online$ = undefined;
+        this.online$ = new Observable(observer => {
+            observer.next(true);
+        }).pipe(mapTo(true));
+        if (Capacitor.isNativePlatform()) {
+            // on Device
+            console.log('on Device');
+            this.online$ = merge(this.network.onConnect().pipe(mapTo(true)), this.network.onDisconnect().pipe(mapTo(false)));
+        }
+        else {
+            // on Browser
+            console.log('on Browser');
+            this.online$ = merge(of(navigator.onLine), fromEvent(window, 'online').pipe(mapTo(true)), fromEvent(window, 'offline').pipe(mapTo(false)));
+        }
+    }
+    getNetworkType() {
+        return this.network.type;
+    }
+    getNetworkStatus() {
+        return this.online$;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NetworkService, deps: [{ token: i1.Network }, { token: i2.Platform }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NetworkService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NetworkService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Network }, { type: i2.Platform }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,202 @@
+import { Injectable } from '@angular/core';
+import { MatSnackBarConfig } from '@angular/material/snack-bar';
+import { ContentTypePath } from "../util/notification-options";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/snack-bar";
+import * as i2 from "@ionic/angular";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "@angular/router";
+export class NotificationService {
+    constructor(snackBar, zone, alertCtrl, translate, toastController, _zone, platform, router) {
+        this.snackBar = snackBar;
+        this.zone = zone;
+        this.alertCtrl = alertCtrl;
+        this.translate = translate;
+        this.toastController = toastController;
+        this._zone = _zone;
+        this.platform = platform;
+        this.router = router;
+    }
+    showSuccess(message) {
+        // Had an issue with the snackbar being ran outside of angular's zone.
+        this.zone.run(() => {
+            // The second parameter is the text in the button. 
+            // In the third, we send in the css class for the snack bar.
+            const config = new MatSnackBarConfig();
+            config.panelClass = ['custom-class'];
+            config.verticalPosition = 'bottom';
+            config.horizontalPosition = 'center';
+            config.duration = 3000;
+            this.snackBar.open(message, '', config);
+        });
+    }
+    showError(error) {
+        let message;
+        if (error.includes('ERR_INTERNET_DISCONNECTED') || error.toLowerCase().includes('network error') || error.toLowerCase().includes('unknown error'))
+            message = this.translate.instant('commons.error-network');
+        else if (error.includes('Timeout has occurred'))
+            message = this.translate.instant('commons.error-timeout');
+        else
+            message = error;
+        this.zone.run(() => {
+            const config = new MatSnackBarConfig();
+            config.panelClass = ['example-pizza-party'];
+            config.verticalPosition = 'bottom';
+            config.horizontalPosition = 'center';
+            config.duration = 3000;
+            this.snackBar.open(message, 'X', config);
+            console.log("NotificationService", message);
+        });
+    }
+    //Toast
+    displayToastSuccessful() {
+        try {
+            this.toastController.dismiss().then(() => {
+            }).catch(() => {
+            }).finally(() => {
+                console.log('Closed');
+            });
+        }
+        catch (e) { }
+        this.toastController.create({
+            position: 'middle', //'middle', 'bottom'
+            cssClass: 'toast-custom-class',
+            animated: true,
+            duration: 2000,
+        }).then((toast) => {
+            toast.present();
+        });
+    }
+    displayToastPusher(message) {
+        try {
+            this.toastController.dismiss().then(() => {
+            }).catch(() => {
+            }).finally(() => {
+                console.log('Closed');
+            });
+        }
+        catch (e) { }
+        this.toastController.create({
+            position: 'middle', //'middle', 'bottom'
+            cssClass: 'toast-pusher-class',
+            message: message,
+            animated: true,
+            duration: 30000,
+            buttons: [{
+                    text: 'Cerrar',
+                    icon: 'close',
+                    role: 'cancel',
+                    handler: () => {
+                        console.log('Cancel clicked');
+                    }
+                }
+            ]
+        }).then((toast) => {
+            toast.present();
+        });
+    }
+    async confirmAllNotification(message) {
+        const alert = await this.alertCtrl.create({
+            cssClass: 'my-alert-class',
+            message: message,
+            buttons: [
+                {
+                    text: this.translate.instant("button.ok"),
+                    handler: (data) => {
+                    }
+                }
+            ]
+        });
+        await alert.present();
+    }
+    redirecPushNotification(data, notification) {
+        switch (data.action) {
+            case "SHARECAREPLAN":
+                this._zone.run(() => {
+                    this.router.navigate([ContentTypePath.Home], { state: { data: data, openNotificationAlertDialog: true } });
+                });
+                break;
+            case "MESSAGE":
+                let staff;
+                // Different payloads for ios and android
+                if (this.platform.is('ios'))
+                    staff = data?.origin;
+                else
+                    staff = data?.origin ? JSON.parse(data?.origin) : null;
+                console.log('staff: ', staff);
+                this._zone.run(() => {
+                    this.router.navigate([ContentTypePath.Message], { state: { data: data, chat: data.id, staff: staff, customData: data?.user_id } });
+                });
+                break;
+            case "FORM":
+                this._zone.run(() => {
+                    this.router.navigate([ContentTypePath.Forms, { id: data.id }], { state: { data: data } });
+                });
+                break;
+            case "DRUGINTAKE":
+                this._zone.run(() => {
+                    this.router.navigate([ContentTypePath.Medication], { state: { data: data, segment: 'medication' } });
+                });
+                break;
+            case "VIDEOCALL":
+                //return "VIDEOCALL";
+                break;
+            case "ADVICE":
+                this._zone.run(() => {
+                    this.router.navigateByUrl('/home').then(() => {
+                        this.router.navigate([ContentTypePath.AdvicesDetail], { state: { data: data, id: data.id } });
+                    });
+                });
+                break;
+            case "NEWS":
+                this._zone.run(() => {
+                    this.router.navigateByUrl('/home').then(() => {
+                        this.router.navigate([ContentTypePath.NewsDetail], { state: { data: data, id: data.id } });
+                    });
+                });
+                break;
+            case "DIET":
+                this._zone.run(() => {
+                    this.router.navigate([ContentTypePath.DietsDetail], { state: { data: data, id: data.id } });
+                });
+                break;
+            case "AGENDA":
+                this._zone.run(() => {
+                    this.router.navigate([ContentTypePath.AgendaDetail], { state: { data: data, id: data.id } });
+                });
+                break;
+            case "REMINDER":
+                this._zone.run(() => {
+                    this.router.navigate([ContentTypePath.ReminderDetail], { state: { data: data, id: data.id } });
+                });
+                break;
+            case "GAME":
+                this._zone.run(() => {
+                    if (data.type == 'form') {
+                        this.router.navigate([ContentTypePath.FormDetail, { id: data.form_id }], { state: { data: data, game_play_id: data?.game_play_id } });
+                    }
+                    else
+                        this.router.navigate([ContentTypePath.GamesDetail], { state: { data: data, id: data.id, server_url: data?.server_url } });
+                });
+                break;
+            case "EXERCISE":
+                this._zone.run(() => {
+                    this.router.navigate([ContentTypePath.Exercises], { state: { data: data, id: data.id, programable_id: data.programable_play_id } });
+                });
+                break;
+            default:
+                console.error('Action on localNotificationActionPerformed not found, redirecting to videocall: ');
+                // this.redirecToVideocall(notification)
+                break;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NotificationService, deps: [{ token: i1.MatSnackBar }, { token: i0.NgZone }, { token: i2.AlertController }, { token: i3.TranslateService }, { token: i2.ToastController }, { token: i0.NgZone }, { token: i2.Platform }, { token: i4.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NotificationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.10", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.MatSnackBar }, { type: i0.NgZone }, { type: i2.AlertController }, { type: i3.TranslateService }, { type: i2.ToastController }, { type: i0.NgZone }, { type: i2.Platform }, { type: i4.Router }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification.service.js","sourceRoot":"","sources":["../../../../../projects/service-lib/src/lib/services/notification.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAU,MAAM,eAAe,CAAC;AACnD,OAAO,EAAe,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAG7E,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA;;;;;;AAM9D,MAAM,OAAO,mBAAmB;IAE9B,YACS,QAAqB,EACpB,IAAY,EACb,SAA0B,EACzB,SAA2B,EAC3B,eAAgC,EAChC,KAAa,EAAW,QAAkB,EAAU,MAAc;QALnE,aAAQ,GAAR,QAAQ,CAAa;QACpB,SAAI,GAAJ,IAAI,CAAQ;QACb,cAAS,GAAT,SAAS,CAAiB;QACzB,cAAS,GAAT,SAAS,CAAkB;QAC3B,oBAAe,GAAf,eAAe,CAAiB;QAChC,UAAK,GAAL,KAAK,CAAQ;QAAW,aAAQ,GAAR,QAAQ,CAAU;QAAU,WAAM,GAAN,MAAM,CAAQ;IACxE,CAAC;IAEL,WAAW,CAAC,OAAe;QACzB,sEAAsE;QACtE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE;YACjB,mDAAmD;YACnD,4DAA4D;YAC5D,MAAM,MAAM,GAAG,IAAI,iBAAiB,EAAE,CAAC;YACvC,MAAM,CAAC,UAAU,GAAI,CAAC,cAAc,CAAC,CAAC;YACtC,MAAM,CAAC,gBAAgB,GAAG,QAAQ,CAAC;YACnC,MAAM,CAAC,kBAAkB,GAAG,QAAQ,CAAC;YACrC,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC;YACvB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAC,EAAE,EAAE,MAAM,CAAC,CAAC;QAEzC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,SAAS,CAAC,KAAa;QAErB,IAAI,OAAc,CAAC;QACnB,IAAG,KAAK,CAAC,QAAQ,CAAC,2BAA2B,CAAC,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,eAAe,CAAC,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,eAAe,CAAC;YAC5I,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,uBAAuB,CAAC,CAAC;aACvD,IAAG,KAAK,CAAC,QAAQ,CAAC,sBAAsB,CAAC;YAC5C,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,uBAAuB,CAAC,CAAC;;YAE1D,OAAO,GAAG,KAAK,CAAC;QAGpB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE;YAEjB,MAAM,MAAM,GAAG,IAAI,iBAAiB,EAAE,CAAC;YACvC,MAAM,CAAC,UAAU,GAAG,CAAC,qBAAqB,CAAC,CAAC;YAC5C,MAAM,CAAC,gBAAgB,GAAG,QAAQ,CAAC;YACnC,MAAM,CAAC,kBAAkB,GAAG,QAAQ,CAAC;YACrC,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC;YACvB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAC,GAAG,EAAE,MAAM,CAAC,CAAC;YAExC,OAAO,CAAC,GAAG,CAAC,qBAAqB,EAAE,OAAO,CAAC,CAAC;QAE9C,CAAC,CAAC,CAAC;IACL,CAAC;IAED,OAAO;IACP,sBAAsB;QACpB,IAAI,CAAC;YACH,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;YACzC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE;YACd,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;gBACd,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;YACvB,CAAC,CAAC,CAAC;QACL,CAAC;QAAC,OAAM,CAAC,EAAE,CAAC,CAAA,CAAC;QAEb,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC;YAC1B,QAAQ,EAAE,QAAQ,EAAE,oBAAoB;YACxC,QAAQ,EAAE,oBAAoB;YAC9B,QAAQ,EAAE,IAAI;YACd,QAAQ,EAAE,IAAI;SACf,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;YAChB,KAAK,CAAC,OAAO,EAAE,CAAC;QAClB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,kBAAkB,CAAC,OAAO;QACxB,IAAI,CAAC;YACH,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;YACzC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE;YACd,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;gBACd,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;YACvB,CAAC,CAAC,CAAC;QACL,CAAC;QAAC,OAAM,CAAC,EAAE,CAAC,CAAA,CAAC;QAEb,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC;YAC1B,QAAQ,EAAE,QAAQ,EAAE,oBAAoB;YACxC,QAAQ,EAAE,oBAAoB;YAC9B,OAAO,EAAE,OAAO;YAChB,QAAQ,EAAE,IAAI;YACd,QAAQ,EAAE,KAAK;YACf,OAAO,EAAE,CAAC;oBACN,IAAI,EAAE,QAAQ;oBACd,IAAI,EAAE,OAAO;oBACb,IAAI,EAAE,QAAQ;oBACd,OAAO,EAAE,GAAG,EAAE;wBACZ,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;oBAChC,CAAC;iBACF;aACF;SACF,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;YAChB,KAAK,CAAC,OAAO,EAAE,CAAC;QAClB,CAAC,CAAC,CAAC;IACL,CAAC;IAGD,KAAK,CAAC,sBAAsB,CAAC,OAAO;QAClC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;YACxC,QAAQ,EAAE,gBAAgB;YAC1B,OAAO,EAAE,OAAO;YACd,OAAO,EAAE;gBACR;oBACG,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,WAAW,CAAC;oBACzC,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE;oBAElB,CAAC;iBACF;aACF;SACJ,CAAC,CAAC;QAEH,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC;IACxB,CAAC;IAGD,uBAAuB,CAAC,IAAI,EAAE,YAAa;QAGzC,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;YAEpB,KAAK,eAAe;gBAClB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;oBAClB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAE,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,2BAA2B,EAAE,IAAI,EAAC,EAAE,CAAC,CAAC;gBAC7G,CAAC,CAAC,CAAC;gBAEJ,MAAM;YAEP,KAAK,SAAS;gBACZ,IAAI,KAAK,CAAC;gBACV,yCAAyC;gBACzC,IAAI,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,CAAC;oBACzB,KAAK,GAAG,IAAI,EAAE,MAAM,CAAC;;oBAErB,KAAK,GAAG,IAAI,EAAE,MAAM,CAAA,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;gBACxD,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;gBAE9B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;oBAClB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAE,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC;gBACtI,CAAC,CAAC,CAAC;gBACH,MAAM;YACN,KAAK,MAAM;gBACT,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;oBAClB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAE,CAAC,eAAe,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;gBAC7F,CAAC,CAAC,CAAC;gBACH,MAAM;YACR,KAAK,YAAY;gBACf,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;oBAClB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAE,CAAC,eAAe,CAAC,UAAU,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,CAAC,CAAC;gBACxG,CAAC,CAAC,CAAC;gBACH,MAAM;YACR,KAAK,WAAW;gBACf,qBAAqB;gBACpB,MAAM;YACR,KAAK,QAAQ;gBACX,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;oBAClB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;wBAC3C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAE,CAAC,eAAe,CAAC,aAAa,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAC,CAAC,CAAC;oBAChG,CAAC,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;gBACH,MAAM;YACR,KAAK,MAAM;gBACT,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;oBAClB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;wBAC3C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAE,CAAC,eAAe,CAAC,UAAU,CAAC,EAAC,EAAC,KAAK,EAAC,EAAC,IAAI,EAAC,IAAI,EAAE,EAAE,EAAC,IAAI,CAAC,EAAE,EAAC,EAAC,CAAC,CAAC;oBACtF,CAAC,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;gBACH,MAAM;YACR,KAAK,MAAM;gBACT,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;oBAClB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAE,CAAC,eAAe,CAAC,WAAW,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;gBAC/F,CAAC,CAAC,CAAC;gBACH,MAAM;YACR,KAAK,QAAQ;gBACX,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;oBAClB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAE,CAAC,eAAe,CAAC,YAAY,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;gBAChG,CAAC,CAAC,CAAC;gBACH,MAAM;YACR,KAAK,UAAU;gBACb,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;oBAClB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAE,CAAC,eAAe,CAAC,cAAc,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;gBAClG,CAAC,CAAC,CAAC;gBACH,MAAM;YACR,KAAK,MAAM;gBACT,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;oBAClB,IAAI,IAAI,CAAC,IAAI,IAAI,MAAM,EAAE,CAAC;wBACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAE,CAAC,eAAe,CAAC,UAAU,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,CAAC,CAAC;oBACzI,CAAC;;wBACC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,eAAe,CAAC,WAAW,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,CAAC,CAAC;gBAC9H,CAAC,CAAC,CAAC;gBACH,MAAM;YACR,KAAK,UAAU;gBACb,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;oBAClB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,eAAe,CAAC,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,cAAc,EAAE,IAAI,CAAC,mBAAmB,EAAE,EAAE,CAAC,CAAC;gBACtI,CAAC,CAAC,CAAC;gBACH,MAAM;YACR;gBACE,OAAO,CAAC,KAAK,CAAC,kFAAkF,CAAC,CAAA;gBAClG,wCAAwC;gBACvC,MAAM;QACV,CAAC;IACL,CAAC;+GA5MU,mBAAmB;mHAAnB,mBAAmB,cAFlB,MAAM;;4FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\nimport { MatSnackBar, MatSnackBarConfig } from '@angular/material/snack-bar';\nimport { AlertController, Platform, ToastController } from '@ionic/angular';\nimport { TranslateService } from '@ngx-translate/core';\nimport { ContentTypePath } from \"../util/notification-options\"\nimport { Router } from '@angular/router';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class NotificationService {\n\n  constructor(\n    public snackBar: MatSnackBar,\n    private zone: NgZone,\n    public alertCtrl: AlertController,\n    private translate: TranslateService,\n    private toastController: ToastController,\n    private _zone: NgZone,  private platform: Platform, private router: Router,\n  ) { }\n\n  showSuccess(message: string): void {\n    // Had an issue with the snackbar being ran outside of angular's zone.\n    this.zone.run(() => {\n      // The second parameter is the text in the button. \n      // In the third, we send in the css class for the snack bar.\n      const config = new MatSnackBarConfig();\n      config.panelClass =  ['custom-class'];\n      config.verticalPosition = 'bottom';\n      config.horizontalPosition = 'center';\n      config.duration = 3000;\n      this.snackBar.open(message,'', config);\n      \n    });\n  }\n\n  showError(error: string): void {\n    \n    let message:string;\n    if(error.includes('ERR_INTERNET_DISCONNECTED') || error.toLowerCase().includes('network error') || error.toLowerCase().includes('unknown error'))\n        message = this.translate.instant('commons.error-network');\n      else if(error.includes('Timeout has occurred'))\n        message = this.translate.instant('commons.error-timeout');\n      else\n        message = error;\n      \n\n    this.zone.run(() => {\n\n      const config = new MatSnackBarConfig();\n      config.panelClass = ['example-pizza-party'];\n      config.verticalPosition = 'bottom';\n      config.horizontalPosition = 'center';\n      config.duration = 3000;\n      this.snackBar.open(message,'X', config);\n     \n      console.log(\"NotificationService\", message);\n      \n    });\n  }\n\n  //Toast\n  displayToastSuccessful() { \n    try {\n      this.toastController.dismiss().then(() => {\n      }).catch(() => {\n      }).finally(() => {\n        console.log('Closed')\n      });\n    } catch(e) {}\n    \n    this.toastController.create({\n      position: 'middle', //'middle', 'bottom'\n      cssClass: 'toast-custom-class',\n      animated: true,\n      duration: 2000,\n    }).then((toast) => {\n      toast.present();\n    });\n  }\n\n  displayToastPusher(message) { \n    try {\n      this.toastController.dismiss().then(() => {\n      }).catch(() => {\n      }).finally(() => {\n        console.log('Closed')\n      });\n    } catch(e) {}\n    \n    this.toastController.create({\n      position: 'middle', //'middle', 'bottom'\n      cssClass: 'toast-pusher-class',\n      message: message,\n      animated: true,\n      duration: 30000,\n      buttons: [{\n          text: 'Cerrar',\n          icon: 'close',\n          role: 'cancel',\n          handler: () => {\n            console.log('Cancel clicked');\n          }\n        }\n      ]\n    }).then((toast) => {\n      toast.present();\n    });\n  }\n\n\n  async confirmAllNotification(message) {\n    const alert = await this.alertCtrl.create({\n      cssClass: 'my-alert-class',\n      message: message ,\n        buttons: [\n         {\n            text: this.translate.instant(\"button.ok\"),\n            handler: (data) => {\n    \n            }\n          }\n        ]\n    });\n\n    await alert.present();\n  }\n\n\n  redirecPushNotification(data, notification?) {\n\n\n    switch (data.action) {\n\n      case \"SHARECAREPLAN\":\n        this._zone.run(() => {\n          this.router.navigate( [ContentTypePath.Home], { state: { data: data, openNotificationAlertDialog: true} });\n        });\n\n       break;\n\n      case \"MESSAGE\":\n        let staff;\n        // Different payloads for ios and android\n        if (this.platform.is('ios')) \n          staff = data?.origin;\n        else \n          staff = data?.origin? JSON.parse(data?.origin) : null;\n        console.log('staff: ', staff);\n\n        this._zone.run(() => {\n          this.router.navigate( [ContentTypePath.Message], { state: { data: data, chat: data.id, staff: staff, customData: data?.user_id } });\n        });\n        break;\n        case \"FORM\":\n          this._zone.run(() => {\n            this.router.navigate( [ContentTypePath.Forms, { id: data.id }], { state: { data: data } });\n          });\n          break;\n        case \"DRUGINTAKE\":\n          this._zone.run(() => {\n            this.router.navigate( [ContentTypePath.Medication], { state: { data: data, segment: 'medication' } });\n          });\n          break;\n        case \"VIDEOCALL\":\n         //return \"VIDEOCALL\";\n          break;\n        case \"ADVICE\":\n          this._zone.run(() => {\n            this.router.navigateByUrl('/home').then(() => {\n              this.router.navigate( [ContentTypePath.AdvicesDetail], { state: { data: data, id: data.id }});\n            });\n          });\n          break;\n        case \"NEWS\":\n          this._zone.run(() => {\n            this.router.navigateByUrl('/home').then(() => {\n              this.router.navigate( [ContentTypePath.NewsDetail],{state:{data:data, id:data.id}});\n            });\n          });\n          break;\n        case \"DIET\":\n          this._zone.run(() => {\n            this.router.navigate( [ContentTypePath.DietsDetail], { state: { data: data, id: data.id } });\n          });\n          break;\n        case \"AGENDA\":\n          this._zone.run(() => {\n            this.router.navigate( [ContentTypePath.AgendaDetail], { state: { data: data, id: data.id } });\n          });\n          break;\n        case \"REMINDER\":\n          this._zone.run(() => {\n            this.router.navigate( [ContentTypePath.ReminderDetail], { state: { data: data, id: data.id } });\n          });\n          break;\n        case \"GAME\":\n          this._zone.run(() => {\n            if (data.type == 'form') {\n              this.router.navigate( [ContentTypePath.FormDetail, { id: data.form_id }], { state: { data: data, game_play_id: data?.game_play_id } });\n            } else\n              this.router.navigate([ContentTypePath.GamesDetail], { state: { data: data, id: data.id, server_url: data?.server_url } });\n          });\n          break;\n        case \"EXERCISE\":\n          this._zone.run(() => {\n            this.router.navigate([ContentTypePath.Exercises], { state: { data: data, id: data.id, programable_id: data.programable_play_id } });\n          });\n          break;\n        default:\n          console.error('Action on localNotificationActionPerformed not found, redirecting to videocall: ')\n         // this.redirecToVideocall(notification)\n          break;\n      }\n  }\n}\n\n"]}