@chat21/chat21-ionic 2.0.13 → 3.0.5-9.2

package/src/chat21-core/providers/firebase/firebase-groups-handler.ts

@@ -0,0 +1,303 @@
+import { GroupsHandlerService } from '../abstract/groups-handler.service';
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+
+// firebase
+// import * as firebase from 'firebase/app';
+import firebase from "firebase/app";
+import 'firebase/messaging';
+import 'firebase/database';
+import 'firebase/auth';
+import 'firebase/storage';
+
+// models
+import { ConversationModel } from '../../models/conversation';
+
+// services
+//import { DatabaseProvider } from '../database';
+
+// utils
+import { CustomLogger } from '../logger/customLogger';
+import { AppConfigProvider } from '../../../app/services/app-config';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { GroupModel } from 'src/chat21-core/models/group';
+import { avatarPlaceholder, getColorBck } from 'src/chat21-core/utils/utils-user';
+import { LoggerService } from '../abstract/logger.service';
+import { LoggerInstance } from '../logger/loggerInstance';
+
+
+// @Injectable({ providedIn: 'root' })
+@Injectable()
+export class FirebaseGroupsHandler extends GroupsHandlerService {
+
+    // BehaviorSubject
+    BSgroupDetail: BehaviorSubject<GroupModel>;
+    SgroupDetail: Subject<GroupModel>;
+    groupAdded: BehaviorSubject<GroupModel>;
+    groupChanged: BehaviorSubject<GroupModel>;
+    groupRemoved: BehaviorSubject<GroupModel>;
+
+    // public params
+    conversations: Array<ConversationModel> = [];
+    uidConvSelected: string;
+
+    // private params
+    private tenant: string;
+    private loggedUserId: string;
+    private ref: firebase.database.Query;
+    private BASE_URL = this.appConfig.getConfig().firebaseConfig.chat21ApiUrl;
+    private logger:LoggerService = LoggerInstance.getInstance()
+
+    // private audio: any;
+    // private setTimeoutSound: any;
+
+    constructor(
+        public http: HttpClient,
+        public appConfig: AppConfigProvider
+    ) {
+        super();
+    }
+
+    /**
+     * inizializzo groups handler
+     */
+    initialize(tenant: string, loggedUserId: string) {
+        this.tenant = tenant;
+        this.loggedUserId = loggedUserId;
+        this.BASE_URL = this.appConfig.getConfig().firebaseConfig.chat21ApiUrl;
+        this.logger.debug('[FIREBASEGroupHandlerSERVICE] initialize', this.tenant, this.loggedUserId);
+    }
+
+    /**
+     * mi connetto al nodo groups
+     * creo la reference
+     * mi sottoscrivo a change, removed, added
+     */
+    connect() {
+        //********* NOT IN USE ********** */
+        const that = this;
+        const urlNodeGroups = '/apps/' + this.tenant + '/users/' + this.loggedUserId + '/groups';
+        this.logger.debug('[FIREBASEGroupHandlerSERVICE] connect -------> groups::', urlNodeGroups)
+        this.ref = firebase.database().ref(urlNodeGroups)
+        this.ref.on('child_added', (childSnapshot) => {
+            that.logger.debug('[FIREBASEGroupHandlerSERVICE] child_added ------->', childSnapshot.val())
+            // that.added(childSnapshot);
+        });
+        this.ref.on('child_changed', (childSnapshot) => {
+            that.logger.debug('[FIREBASEGroupHandlerSERVICE] child_changed ------->', childSnapshot.val())
+            // that.changed(childSnapshot);
+        });
+        this.ref.on('child_removed', (childSnapshot) => {
+            that.logger.debug('[FIREBASEGroupHandlerSERVICE] child_removed ------->', childSnapshot.val())
+            // that.removed(childSnapshot);
+        });
+    }
+
+    /**
+     * mi connetto al nodo groups/GROUPID
+     * creo la reference
+     * mi sottoscrivo a value
+     */
+    getDetail(groupId: string, callback?: (group: GroupModel)=>void): Promise<GroupModel>{
+        const urlNodeGroupById = '/apps/' + this.tenant + '/users/' + this.loggedUserId + '/groups/' + groupId;
+        this.logger.debug('[FIREBASEGroupHandlerSERVICE] getDetail -------> urlNodeGroupById::', urlNodeGroupById)
+        const ref = firebase.database().ref(urlNodeGroupById)
+        return new Promise((resolve) => {
+            ref.off()
+            ref.on('value', (childSnapshot) => {
+                const group: GroupModel = childSnapshot.val();
+                group.uid = childSnapshot.key
+                // that.BSgroupDetail.next(group)
+                if (callback) {
+                    callback(group)
+                }
+                resolve(group)
+            });
+        });
+
+    }
+
+    onGroupChange(groupId: string): Observable<GroupModel> {
+        const that = this;
+        let SgroupDetail = new Subject<GroupModel>();
+        const urlNodeGroupById = '/apps/' + this.tenant + '/users/' + this.loggedUserId + '/groups/' + groupId;
+        this.logger.log('[FIREBASEGroupHandlerSERVICE] onGroupChange -------> urlNodeGroupById::', urlNodeGroupById)
+        const ref = firebase.database().ref(urlNodeGroupById)
+        ref.off()
+        ref.on('value', (childSnapshot) => {
+            // this.groupValue(childSnapshot)
+            if(childSnapshot.val() ) {
+                const group: GroupModel = childSnapshot.val();
+                if (group) {
+                    group.uid = childSnapshot.key
+                    // that.BSgroupDetail.next(group)
+                    let groupCompleted = this.completeGroup(group)
+                    // this.SgroupDetail.next(groupCompleted) 
+                    SgroupDetail.next(groupCompleted) 
+                } 
+            }
+        });
+        // return this.SgroupDetail
+        return SgroupDetail
+    }
+
+    // private groupValue(childSnapshot: any){
+    //     const that = this;
+    //     let SgroupDetail = new Subject<GroupModel>();
+    //     this.logger.debug('[FIREBASEGroupHandlerSERVICE] group detail::', childSnapshot.val(), childSnapshot)
+    //     const group: GroupModel = childSnapshot.val();
+    //     this.logger.debug('[FIREBASEGroupHandlerSERVICE]  groupValue ', group)
+    //     if (group) {
+    //         group.uid = childSnapshot.key
+    //         // that.BSgroupDetail.next(group)
+    //         let groupCompleted = this.completeGroup(group)
+    //         // this.SgroupDetail.next(groupCompleted) 
+    //         SgroupDetail.next(groupCompleted) 
+    //     } 
+    // }
+
+    create(groupName: string, members: [string], callback?: (res: any, error: any) => void): Promise<any> {
+        var that = this;
+        let listMembers = {};
+        members.forEach(member => {
+            listMembers[member] = 1
+        });
+
+        return new Promise((resolve, reject) =>{
+            this.getFirebaseToken((error, idToken) => {
+                that.logger.debug('[FIREBASEGroupHandlerSERVICE] CREATE GROUP idToken', idToken, error)
+                if (idToken) {
+                    const httpOptions = {
+                        headers: new HttpHeaders({
+                            'Accept': 'application/json',
+                            'Content-Type': 'application/json',
+                            'Authorization': 'Bearer ' + idToken,
+                        })
+                    }
+                    const body = {
+                        "group_name": groupName,
+                        "group_members": listMembers
+                    }
+                    const url = that.BASE_URL + '/api/' + that.tenant + '/groups'
+                    that.http.post(url, body, httpOptions).toPromise().then((res) => {
+                        callback(res, null);
+                        resolve(res)
+                    }).catch(function (error) {
+                        // Handle error
+                        that.logger.error('[FIREBASEGroupHandlerSERVICE] createGROUP error: ', error);
+                        callback(null, error);
+                        reject(error);
+                    });
+                }else{
+                    callback(null, error)
+                    reject(error)
+                }
+            });
+        });
+    }
+
+    join(groupId: string, member: string, callback?: (res: any, error: any) => void) {
+        var that = this;
+        return new Promise((resolve, reject) =>{
+            this.getFirebaseToken((error, idToken) => {
+                that.logger.debug('[FIREBASEGroupHandlerSERVICE] JOIN GROUP idToken', idToken, error)
+                if (idToken) {
+                    const httpOptions = {
+                        headers: new HttpHeaders({
+                            'Accept': 'application/json',
+                            'Content-Type': 'application/json',
+                            'Authorization': 'Bearer ' + idToken,
+                        })
+                    }
+                    const body = {
+                        "member_id": member
+                    }
+                    const url = that.BASE_URL + '/api/' + that.tenant + '/groups/' + groupId + '/members'
+                    that.http.post(url, body, httpOptions).toPromise().then((res) => {
+                        callback(res, null);
+                        resolve(res)
+                    }).catch(function (error) {
+                        // Handle error
+                        that.logger.error('[FIREBASEGroupHandlerSERVICE] createGROUP error: ', error);
+                        callback(null, error);
+                        reject(error);
+                    });
+                }else{
+                    callback(null, error)
+                    reject(error)
+                }
+            });
+        });
+    }
+
+    leave(groupId: string, callback?: (res: any, error: any) => void): Promise<any> {
+        var that = this;
+        return new Promise((resolve, reject) =>{
+            this.getFirebaseToken((error, idToken) => {
+                that.logger.debug('[FIREBASEGroupHandlerSERVICE] LEAVE CONV idToken', idToken, error)
+                if (idToken) {
+                    const httpOptions = {
+                        headers: new HttpHeaders({
+                            'Accept': 'application/json',
+                            'Content-Type': 'application/json',
+                            'Authorization': 'Bearer ' + idToken,
+                        })
+                    }
+                    const url = that.BASE_URL + '/api/' + that.tenant + '/groups/' + groupId + '/members/' + that.loggedUserId
+                    that.http.delete(url, httpOptions).toPromise().then((res) => {
+                        callback(res, null);
+                        resolve(res)
+                    }).catch(function (error) {
+                        // Handle error
+                        that.logger.error('[FIREBASEGroupHandlerSERVICE] LEAVE idToken error: ', error);
+                        callback(null, error);
+                        reject(error);
+                    });
+                }else{
+                    callback(null, error)
+                    reject(error)
+                }
+            });
+        });
+    }
+
+
+    dispose() {
+        this.conversations = [];
+        this.uidConvSelected = '';
+        this.ref.off();
+        // this.ref.off("child_changed");
+        // this.ref.off("child_removed");
+        // this.ref.off("child_added");
+        this.logger.debug('[FIREBASEGroupHandlerSERVICE]  DISPOSE', this.ref)
+    }
+
+    // // -------->>>> PRIVATE METHOD SECTION START <<<<---------------//
+    private getFirebaseToken(callback) {
+        const firebase_currentUser = firebase.auth().currentUser;
+        this.logger.debug('[FIREBASEGroupHandlerSERVICE]  // firebase current user ', firebase_currentUser);
+        if (firebase_currentUser) {
+            const that = this;
+            firebase_currentUser.getIdToken(/* forceRefresh */ true)
+                .then(function (idToken) {
+                    // qui richiama la callback
+                    callback(null, idToken);
+                }).catch(function (error) {
+                    // Handle error
+                    that.logger.error('[FIREBASEGroupHandlerSERVICE] ERROR -> idToken.', error);
+                    callback(error, null);
+                });
+        }
+    }
+
+   
+
+    private completeGroup(group: any): GroupModel{
+        group.avatar = avatarPlaceholder(group.name);
+        group.color = getColorBck(group.name);
+        return group 
+    }
+    // // -------->>>> PRIVATE METHOD SECTION SECTION END <<<<---------------//
+
+
+}

package/src/chat21-core/providers/firebase/firebase-image-repo.ts

@@ -0,0 +1,40 @@
+import { Injectable } from '@angular/core';
+import { environment } from 'src/environments/environment';
+
+// services
+import { ImageRepoService } from '../abstract/image-repo.service';
+
+// firebase
+// import * as firebase from 'firebase/app';
+import firebase from "firebase/app";
+import 'firebase/storage';
+
+@Injectable({ providedIn: 'root' })
+
+export class FirebaseImageRepoService extends ImageRepoService {
+
+    // private params
+    private urlStorageBucket = environment.firebaseConfig.storageBucket + '/o/profiles%2F';
+    private baseImageURL: string;
+    
+    constructor() {
+        super();
+    }
+
+    /**
+     * @param uid
+     */
+    getImagePhotoUrl(uid: string): string {
+        this.baseImageURL = this.getImageBaseUrl()
+        let sender_id = '';
+        if (uid && uid.includes('bot_')) {
+            sender_id = uid.slice(4)
+        } else {
+            sender_id = uid
+        }
+        const firebase_photo = '/o/profiles%2F'+ sender_id + '%2Fphoto.jpg?alt=media'
+        const firebase_thumbnail = '/o/profiles%2F'+ sender_id + '%2Fthumb_photo.jpg?alt=media'
+        const imageurl = this.baseImageURL + firebase.storage().ref().bucket + firebase_thumbnail
+        return imageurl;
+    }
+}

package/src/chat21-core/providers/firebase/firebase-init-service.ts

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+// firebase
+// import * as firebase from 'firebase/app';
+import firebase from "firebase/app";
+import 'firebase/app';
+/*
+  Generated class for the AuthService provider.
+  See https://angular.io/docs/ts/latest/guide/dependency-injection.html
+  for more info on providers and Angular 2 DI.
+*/
+@Injectable()
+/**
+ * DESC PROVIDER
+ */
+export class FirebaseInitService {
+
+  public static firebaseInit: any;
+  
+  constructor() {
+  }
+
+  public static initFirebase(firebaseConfig: any) {
+    if(!FirebaseInitService.firebaseInit){
+        if (!firebaseConfig || firebaseConfig.apiKey === 'CHANGEIT') {
+            throw new Error('Firebase config is not defined. Please create your chat-config.json. See the chat21-ionic Installation Page');
+          } 
+          FirebaseInitService.firebaseInit = firebase.initializeApp(firebaseConfig); 
+    }
+    return FirebaseInitService.firebaseInit
+  }
+}

package/src/chat21-core/providers/firebase/firebase-notifications.ts

@@ -0,0 +1,246 @@
+import { Injectable } from '@angular/core';
+// services
+import { NotificationsService } from '../abstract/notifications.service';
+import { LoggerInstance } from '../logger/loggerInstance';
+import { LoggerService } from 'src/chat21-core/providers/abstract/logger.service';
+// firebase
+// import * as firebase from 'firebase/app';
+import firebase from "firebase/app";
+import 'firebase/messaging';
+import 'firebase/auth';
+
+@Injectable({ providedIn: 'root' })
+
+export class FirebaseNotifications extends NotificationsService {
+
+    // public BUILD_VERSION: string;
+    private FCMcurrentToken: string;
+    private userId: string;
+    private tenant: string;
+    private vapidkey: string;
+    private logger: LoggerService = LoggerInstance.getInstance();
+    constructor() {
+        super();
+    }
+
+    initialize(tenant: string, vapId: string): void {
+        this.tenant = tenant
+        this.vapidkey = vapId
+        this.logger.log('[FIREBASE-NOTIFICATIONS] initialize - tenant ', this.tenant)
+
+
+        if (!('serviceWorker' in navigator)) {
+            // , disable or hide UI.
+            this.logger.error("[FIREBASE-NOTIFICATIONS] initialize - Service Worker isn't supported on this browser", navigator)
+            return;
+        }
+        // if (('serviceWorker' in navigator)) {
+        //     navigator.serviceWorker.register('firebase-messaging-sw.js')
+        //         .then(function (registration) {
+        //             console.log('[FIREBASE-NOTIFICATIONS] initialize serviceWorker Registration successful, scope is:', registration.scope);
+
+
+        //             // this.logger.log("[FIREBASE-NOTIFICATIONS] initialize - Service Worker is supported on this browser ", navigator)
+        //             // navigator.serviceWorker.getRegistrations().then((serviceWorkerRegistrations) => {
+        //             //     this.logger.log("[FIREBASE-NOTIFICATIONS] initialize - Service Worker is supported on this browser serviceWorkerRegistrations", serviceWorkerRegistrations)
+        //             //     if (serviceWorkerRegistrations.length > 0) {
+        //             //         serviceWorkerRegistrations.forEach(registration => {
+        //             //             this.logger.log("[FIREBASE-NOTIFICATIONS] initialize - Service Worker is supported on this browser registration ", registration)
+        //             //             // this.logger.log("[FIREBASE-NOTIFICATIONS] initialize - Service Worker is supported on this browser registrations scriptURL", registrations.active.scriptURL)
+        //             //             // this.logger.log("[FIREBASE-NOTIFICATIONS] initialize - Service Worker is supported on this browser registrations state", registrations.active.state)
+
+        //             //         });
+        //             //     } else {
+        //             //         this.logger.log("[FIREBASE-NOTIFICATIONS] initialize - Service Worker is supported on this browser - !not registered",)
+        //             //         // navigator.serviceWorker.register('http://localhost:8101/firebase-messaging-sw.js')
+        //             //         //     .then(function (registration) {
+        //             //         //         console.log('Service worker successfully registered.');
+        //             //         //         return registration;
+        //             //         //     }).catch(function (err) {
+        //             //         //         console.error('Unable to register service worker.', err);
+        //             //         //     });
+        //             //     }
+        //             // });
+        //         }).catch(function (err) {
+        //             console.log('Service worker registration failed, error:', err);
+        //         });
+        // }
+    }
+
+
+
+    getNotificationPermissionAndSaveToken(currentUserUid) {
+        // this.tenant = this.getTenant();
+        this.logger.log('initialize FROM [APP-COMP] - [FIREBASE-NOTIFICATIONS] calling requestPermission - tenant ', this.tenant, ' currentUserUid ', currentUserUid)
+        // this.logger.log('[FIREBASE-NOTIFICATIONS] calling requestPermission - currentUserUid ', currentUserUid)
+        this.userId = currentUserUid;
+        // Service Worker explicit registration to explicitly define sw location at a path,
+        // const swRegistration = async () => {
+        //     try {
+        //         await navigator.serviceWorker.register('http://localhost:8101/firebase-messaging-sw.js');
+        //     } catch (error) {
+        //         console.error(error);
+        //     }
+        // }
+
+
+
+        if (firebase.messaging.isSupported()) {
+            const messaging = firebase.messaging();
+            // messaging.requestPermission()
+            Notification.requestPermission().then((permission) => {
+                if (permission === 'granted') {
+                    this.logger.log('[FIREBASE-NOTIFICATIONS] >>>> requestPermission Notification permission granted.');
+
+                    return messaging.getToken({ vapidKey: this.vapidkey })
+                }
+            }).then(FCMtoken => {
+                this.logger.log('[FIREBASE-NOTIFICATIONS] >>>> requestPermission FCMtoken', FCMtoken)
+                // Save FCM Token in Firebase
+                this.FCMcurrentToken = FCMtoken;
+                this.updateToken(FCMtoken, currentUserUid)
+            }).catch((err) => {
+                this.logger.error('[FIREBASE-NOTIFICATIONS] >>>> requestPermission ERR: Unable to get permission to notify.', err);
+            });
+        } else {
+            this.logger.log('[FIREBASE-NOTIFICATIONS] >>>> FIREBASE MESSAGING IS NOT SUPPORTED')
+        }
+    }
+
+
+    // getNotificationPermissionAndSaveToken(currentUserUid) {
+    //     // this.tenant = this.getTenant();
+    //     this.logger.log('[FIREBASE-NOTIFICATIONS] calling requestPermission - tenant ', this.tenant)
+    //     this.logger.log('[FIREBASE-NOTIFICATIONS] calling requestPermission - currentUserUid ', currentUserUid)
+    //     this.userId = currentUserUid;
+    //     const messaging = firebase.messaging();
+    //     if (firebase.messaging.isSupported()) {
+    //         // messaging.requestPermission()
+    //         Notification.requestPermission().then((permission) => {
+    //             if (permission === 'granted') {
+    //                 this.logger.log('[FIREBASE-NOTIFICATIONS] >>>> requestPermission Notification permission granted.');
+    //                 messaging.getToken({ vapidKey: 'BOsgS2ADwspKdWAmiFDZXEYqY1HSYADVfJT3j67wsySh3NxaViJqoabPJH8WM02wb5r8cQIm5TgM0UK047Z1D1c'}).then((currentToken) => {
+    //                     if (currentToken) {
+    //                         this.sendTokenToServer(currentToken);
+    //     // updateUIForPushEnabled(currentToken);
+
+    //                     } else {
+    //                       // Show permission request UI
+    //                       console.log('No registration token available. Request permission to generate one.');
+    //                       // ...
+    //                     }
+    //                   }).catch((err) => {
+    //                     console.log('An error occurred while retrieving token. ', err);
+    //                     // ...
+    //                   });
+
+    //                 resetUI()
+
+    //             } else {
+    //                 this.logger.error('Unable to get permission to notify.');
+    //             }
+    //         })
+
+    //     }
+    // }
+
+    //  sendTokenToServer(currentToken) {
+    //     if (!this.isTokenSentToServer()) {
+    //       console.log('Sending token to server...');
+    //       // TODO(developer): Send the current token to your server.
+    //       this.setTokenSentToServer(true);
+    //     } else {
+    //       console.log('Token already sent to server so won\'t send it again ' +
+    //           'unless it changes');
+    //     }
+    //   }
+
+    //   isTokenSentToServer() {
+    //     return window.localStorage.getItem('sentToServer') === '1';
+    //   }
+
+    //   setTokenSentToServer(sent) {
+    //     window.localStorage.setItem('sentToServer', sent ? '1' : '0');
+    //   }
+
+    removeNotificationsInstance(callback: (string) => void) {
+        var self = this;
+        // firebase.auth().onAuthStateChanged(function (user) {
+        //     if (user) {
+        //         self.logger.debug('[FIREBASE-NOTIFICATIONS] - FB User is signed in. ', user)
+        //         self.logger.log('[FIREBASE-NOTIFICATIONS] >>>> removeNotificationsInstance > this.userId', self.userId);
+        //         self.logger.log('[FIREBASE-NOTIFICATIONS] >>>> removeNotificationsInstance > FCMcurrentToken', self.FCMcurrentToken);
+        //         // this.logger.log('[FIREBASE-NOTIFICATIONS] >>>> removeNotificationsInstance > this.tenant', this.tenant);
+        //     } else {
+        //         self.logger.debug('[FIREBASE-NOTIFICATIONS] - No FB user is signed in. ', user)
+        //     }
+        // });
+        const urlNodeFirebase = '/apps/' + self.tenant
+        const connectionsRefinstancesId = urlNodeFirebase + '/users/' + self.userId + '/instances/'
+        self.logger.log('[FIREBASE-NOTIFICATIONS] >>>> connectionsRefinstancesId ', connectionsRefinstancesId);
+        let connectionsRefURL = '';
+        if (connectionsRefinstancesId) {
+            connectionsRefURL = connectionsRefinstancesId + self.FCMcurrentToken;
+            const connectionsRef = firebase.database().ref().child(connectionsRefURL);
+            self.logger.log('[FIREBASE-NOTIFICATIONS] >>>> connectionsRef ', connectionsRef);
+            self.logger.log('[FIREBASE-NOTIFICATIONS] >>>> connectionsRef url ', connectionsRefURL);
+            connectionsRef.off()
+            connectionsRef.remove()
+                .then(() => {
+                    self.logger.log("[FIREBASE-NOTIFICATIONS] >>>> removeNotificationsInstance > Remove succeeded.")
+                    callback('success')
+                }).catch((error) => {
+                    self.logger.error("[FIREBASE-NOTIFICATIONS] >>>> removeNotificationsInstance Remove failed: " + error.message)
+                    callback('error')
+                }).finally(() => {
+                    self.logger.log('[FIREBASE-NOTIFICATIONS] COMPLETED');
+                })
+        }
+
+    }
+
+    // removeNotificationsInstance() {
+    //     let promise = new Promise((resolve, reject) => {
+    //         this.appStoreService.getInstallation(this.projectId).then((res) => {
+    //             console.log("Get Installation Response: ", res);
+    //             resolve(res);
+    //         }).catch((err) => {
+    //             console.error("Error getting installation: ", err);
+    //             reject(err);
+    //         })
+    //     })
+    //     return promise;
+    // }
+
+
+    // ********** PRIVATE METHOD - START ****************//
+    private updateToken(FCMcurrentToken, currentUserUid) {
+        this.logger.log('[FIREBASE-NOTIFICATIONS] >>>> getPermission > updateToken ', FCMcurrentToken);
+        // this.afAuth.authState.take(1).subscribe(user => {
+        if (!currentUserUid || !FCMcurrentToken) {
+            return
+        };
+
+        const connection = FCMcurrentToken;
+        const updates = {};
+        const urlNodeFirebase = '/apps/' + this.tenant
+        const connectionsRefinstancesId = urlNodeFirebase + '/users/' + currentUserUid + '/instances/';
+
+        // this.connectionsRefinstancesId = this.urlNodeFirebase + "/users/" + userUid + "/instances/";
+        const device_model = {
+            device_model: navigator.userAgent,
+            language: navigator.language,
+            platform: 'ionic',
+            platform_version: this.BUILD_VERSION
+        }
+
+        updates[connectionsRefinstancesId + connection] = device_model;
+
+        this.logger.log('[FIREBASE-NOTIFICATIONS] >>>> getPermission > updateToken in DB', updates);
+        firebase.database().ref().update(updates)
+    }
+    // ********** PRIVATE METHOD - END ****************//
+
+
+
+}