@chat21/chat21-ionic 2.0.13 → 3.0.5-9.2

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

@@ -0,0 +1,139 @@
+import { LoggerService } from 'src/chat21-core/providers/abstract/logger.service';
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Subject, Observable } from 'rxjs';
+import { GroupModel } from 'src/chat21-core/models/group';
+import { GroupsHandlerService } from 'src/chat21-core/providers/abstract/groups-handler.service';
+import { CustomLogger } from '../logger/customLogger';
+import { Chat21Service } from './chat-service';
+import { LoggerInstance } from '../logger/loggerInstance';
+import { avatarPlaceholder, getColorBck } from 'src/chat21-core/utils/utils-user';
+
+@Injectable({
+    providedIn: 'root'
+  })
+  export class MQTTGroupsHandler extends GroupsHandlerService {
+    
+    // BehaviorSubject
+    BSgroupDetail: BehaviorSubject<GroupModel>;
+    SgroupDetail: Subject<GroupModel>;
+    groupAdded: BehaviorSubject<GroupModel>;
+    groupChanged: BehaviorSubject<GroupModel>;
+    groupRemoved: BehaviorSubject<GroupModel>;
+
+    // private params
+    private tenant: string;
+    private loggedUserId: string;
+    private logger: LoggerService = LoggerInstance.getInstance()
+    
+    constructor(
+        public chat21Service: Chat21Service
+    ) {
+        super();
+    }
+
+    /**
+     * inizializzo groups handler
+     */
+    initialize(tenant: string, loggedUserId: string): void {
+        this.logger.log('initialize GROUP-HANDLER MQTT');
+        this.tenant = tenant;
+        this.loggedUserId = loggedUserId;
+    }
+
+    /**
+     * mi connetto al nodo groups
+     * creo la reference
+     * mi sottoscrivo a change, removed, added
+     */
+    connect(): void {
+        // TODO deprecated method.
+    }
+
+    /**
+     * mi connetto al nodo groups/GROUPID
+     * creo la reference
+     * mi sottoscrivo a value
+     */
+    getDetail(groupId: string, callback?: (group: GroupModel) => void): Promise<GroupModel> {
+        //throw new Error('Method not implemented.');
+        // Ignorare versione firebase
+          this.logger.log('Method not implemented.');
+          return;
+    }
+// abstract onGroupChange(groupId: string): Observable<GroupModel>;
+    onGroupChange(groupId: string): Observable<GroupModel> {
+        if (this.isGroup(groupId)) {
+            this.chat21Service.chatClient.groupData(groupId, (err, group) => {
+                this.logger.log('got result by REST call:', group);
+                this.logger.log('got group by REST call:', group.result);
+                this.groupValue(group.result);
+                this.logger.log('subscribing to group updates...', groupId);
+                const handler_group_updated = this.chat21Service.chatClient.onGroupUpdated( (group, topic) => {
+                    if (topic.conversWith === groupId) {
+                        this.logger.log('group updated:', group);
+                        this.groupValue(group);
+                    }
+                });
+            });
+        }
+        return this.SgroupDetail
+    }
+
+    isGroup(groupId) {
+        if (groupId.indexOf('group-') >= 0) {
+            return true;
+        }
+        return false;
+    }
+
+    private groupValue(childSnapshot: any){
+        this.logger.log('groupValue > childSnapshot:', childSnapshot)
+        const group: GroupModel = childSnapshot;
+        this.logger.log('groupValue > GroupModel by childSnapshot:', group)
+        if (group) {
+            let groupCompleted = this.completeGroup(group)
+            this.logger.log("group:", group);
+            this.logger.log("groupCompleted:", groupCompleted);
+            this.SgroupDetail.next(groupCompleted)
+        }
+    }
+
+    private completeGroup(group: any): GroupModel {
+        group.avatar = avatarPlaceholder(group.name);
+        group.color = getColorBck(group.name);
+        // group.membersinfo = group.members;
+        return group
+    }
+
+    create(groupName: string, members: [string], callback?: (res: any, error: any) => void): Promise<any> {
+        // throw new Error('Method not implemented.');
+        // Ignorare versione firebase
+        this.logger.log('Method not implemented.');
+        return;
+    }
+
+    // create(groupName: string, members: [string], callback?:(res: any, error: any)=>void): Promise<any> {
+
+    // }
+
+    leave(groupId: string, callback?: (res: any, error: any) => void): Promise<any> {
+        // throw new Error('Method not implemented.');
+        // Ignorare versione firebase
+        this.logger.log('Method not implemented.');
+        return;
+    }
+
+    join(groupId: string, member: string, callback?: (res: any, error: any) => void) {
+        // throw new Error('Method not implemented.');
+        // Ignorare versione firebase
+        this.logger.log('Method not implemented.');
+        return;
+    }
+
+
+    dispose(): void {
+        //throw new Error('Method not implemented.');
+        this.logger.log('Method not implemented.');
+    }
+      
+  }

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

@@ -0,0 +1,122 @@
+
+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 firebase from "firebase/app";
+import 'firebase/messaging';
+import 'firebase/auth';
+// chat21
+import { Chat21Service } from './chat-service';
+
+@Injectable({
+    providedIn: 'root'
+  })
+  export class MQTTNotifications extends NotificationsService {
+    
+    public BUILD_VERSION: string;
+    private FCMcurrentToken: string;
+    private userId: string;
+    private tenant: string;
+    private vapidkey: string;
+    private logger: LoggerService = LoggerInstance.getInstance();
+
+    constructor(
+      public chat21Service: Chat21Service
+  ) {
+      super();
+  }
+
+    initialize(tenant: string, vapId: string): void {
+      this.tenant = tenant;
+      this.vapidkey = vapId;
+      return;
+    }
+    
+    getNotificationPermissionAndSaveToken(currentUserUid) {
+      console.log("getNotificationPermissionAndSaveToken()",currentUserUid );
+      this.userId = currentUserUid;
+      if (firebase.messaging.isSupported()) {
+        console.log("firebase.messaging.isSupported() YES");
+          const messaging = firebase.messaging();
+          // messaging.requestPermission()
+          Notification.requestPermission().then((permission) => {
+              if (permission === 'granted') {
+                  this.logger.log('[MQTT-FIREBASE-NOTIFICATIONS] >>>> requestPermission Notification permission granted.');
+
+                  return messaging.getToken({ vapidKey: this.vapidkey })
+              }
+          }).then(FCMtoken => {
+              this.logger.log('[MQTT-FIREBASE-NOTIFICATIONS] >>>> requestPermission FCMtoken', FCMtoken)
+              // Save FCM Token in Chat21
+              this.FCMcurrentToken = FCMtoken;
+              this.saveToken(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')
+      }
+    }
+
+
+    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');
+                })
+        }
+    }
+    
+    private saveToken(FCMcurrentToken, currentUserUid) {
+      this.logger.log('[FIREBASE-NOTIFICATIONS] >>>> getPermission > updateToken ', FCMcurrentToken);
+      if (!currentUserUid || !FCMcurrentToken) {
+          return
+      };
+      const device_model = {
+          device_model: navigator.userAgent,
+          language: navigator.language,
+          platform: 'ionic',
+          platform_version: this.BUILD_VERSION
+      }
+      this.chat21Service.chatClient.saveInstance(
+        FCMcurrentToken,
+        device_model,
+        (err, response) => {
+          if (err) {
+            this.logger.error('Error saving FCMcurrentToken on chat21 App Instance', FCMcurrentToken);
+          }
+        }
+      );
+    }
+
+  }

package/src/chat21-core/providers/mqtt/mqtt-presence.service.ts

@@ -0,0 +1,229 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+
+// firebase
+import * as firebase from 'firebase/app';
+import 'firebase/messaging';
+import 'firebase/database';
+
+// services
+// import { EventsService } from '../events-service';
+import { PresenceService } from '../abstract/presence.service';
+import { LoggerService } from 'src/chat21-core/providers/abstract/logger.service';
+import { LoggerInstance } from '../logger/loggerInstance';
+
+// utils
+import { setLastDate } from '../../utils/utils';
+import { environment } from '../../../environments/environment';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MQTTPresenceService extends PresenceService {
+
+  BSIsOnline: BehaviorSubject<any>;
+  BSLastOnline: BehaviorSubject<any>;
+
+  // private params
+  private tenant: string;
+  private urlNodePresence: string;
+  private logger: LoggerService = LoggerInstance.getInstance();
+  constructor(
+    // private events: EventsService
+  ) {
+    super();
+  }
+
+  initialize(tenant: string) {
+    // this.tenant = this.getTenant();
+    this.tenant = tenant;
+    this.logger.info('[MQTT-PRESENCE] initialize this.tenant', this.tenant);
+    this.urlNodePresence = '/apps/' + this.tenant + '/presence/';
+  }
+
+  userIsOnline(userid: string): Observable<any> {
+    // console.log('userIsOnline', userid);
+    // const that = this;
+    // const urlNodeConnections = this.urlNodePresence + userid + '/connections';
+    // console.log('userIsOnline: ', urlNodeConnections);
+    // const connectionsRef = firebase.database().ref().child(urlNodeConnections);
+    // connectionsRef.on('value', (child) => {
+    //   console.log('is-online-' + userid);
+    //   if (child.val()) {
+    //     that.events.publish('is-online-' + userid, userid, true);
+    //   } else {
+    //     that.events.publish('is-online-' + userid, userid, false);
+    //   }
+    // });
+    return this.BSIsOnline
+  }
+
+  lastOnlineForUser(userid: string) {
+    // console.log('lastOnlineForUser', userid);
+    // const that = this;
+    // const urlNodeLastOnLine = this.urlNodePresence + userid + '/lastOnline';
+    // console.log('urlNodeLastOnLine: ', urlNodeLastOnLine);
+    // const lastOnlineRef = firebase.database().ref().child(urlNodeLastOnLine);
+    // lastOnlineRef.on('value', (child) => {
+    //   if (child.val()) {
+    //     that.events.publish('last-connection-date-' + userid, userid, child.val());
+    //   } else {
+    //     that.events.publish('last-connection-date-' + userid, userid, '');
+    //   }
+    // });
+  }
+
+  public setPresence(userid: string): void  {
+    // console.log(' setPresence: ', userid);
+    // this.onlineConnectionsRef = this.referenceOnlineForUser(userid);
+    // this.lastOnlineConnectionsRef = this.referenceLastOnlineForUser(userid);
+    // const connectedRefURL = '/.info/connected';
+    // const conn = firebase.database().ref(connectedRefURL);
+    // conn.on('value', (dataSnapshot) => {
+    //   // console.log('self.deviceConnectionRef: ', dataSnapshot.val());
+    //   if (dataSnapshot.val()) {
+    //     if (this.onlineConnectionsRef) {
+    //       this.keyConnectionRef = this.onlineConnectionsRef.push(true);
+    //       this.keyConnectionRef.onDisconnect().remove();
+    //       const now: Date = new Date();
+    //       const timestamp = now.valueOf();
+    //       this.lastOnlineConnectionsRef.onDisconnect().set(timestamp);
+    //     } else {
+    //       console.log('This is an error. self.deviceConnectionRef already set. Cannot be set again.');
+    //     }
+    //   }
+    // });
+  }
+
+  /**
+   * removePresence
+   * richiamato prima del logout
+   */
+  public removePresence(): void {
+    // if (this.onlineConnectionsRef) {
+    //   const now: Date = new Date();
+    //   const timestamp = now.valueOf();
+    //   this.lastOnlineConnectionsRef.set(timestamp);
+    //   this.onlineConnectionsRef.off();
+    //   this.onlineConnectionsRef.remove();
+    //   console.log('goOffline onlineConnectionsRef', this.onlineConnectionsRef);
+    // }
+  }
+
+}
+
+
+  /**
+   * controlla se esiste una connessione per l'utente analizzato,
+   * verificando se esiste un nodo in presence/uid/connections
+   * mi sottosrivo al nodo
+   * se non esiste pubblico utente offline
+   * se esiste pubblico utente online
+   * @param userid
+   */
+
+
+  /**
+   * mi sottoscrivo al nodo presence/uid/lastOnline
+   * e recupero la data dell'ultimo stato online
+   * pubblico lastConnectionDate
+   * @param userid
+   */
+
+
+  /**
+   * calcolo tempo trascorso tra ora e timestamp passato
+   * @param timestamp
+   */
+
+
+  // /**
+  //  * recupero la reference di lastOnline del currentUser
+  //  * usata in setupMyPresence
+  //  * @param userid
+  //  */
+  // lastOnlineRefForUser(userid){
+  //   let lastOnlineRefURL = this.urlNodeFirebase+"/presence/"+userid+"/lastOnline";
+  //   const lastOnlineRef = firebase.database().ref().child(lastOnlineRefURL);
+  //   return lastOnlineRef;
+  // }
+
+  // /**
+  //  * recupero la reference di connections (online/offline) del currentUser
+  //  * usata in setupMyPresence
+  //  * @param userid
+  //  */
+  // onlineRefForUser(userid){
+  //   let myConnectionsRefURL = this.urlNodeFirebase+"/presence/"+userid+"/connections";
+  //   const connectionsRef = firebase.database().ref().child(myConnectionsRefURL);
+  //   return connectionsRef;
+  // }
+
+  // /**
+  //  * 1 - imposto reference online/offline
+  //  * 2 - imposto reference lastConnection
+  //  * 3 - mi sincronizzo con /.info/connected
+  //  * 4 - se il valore esiste l'utente è online
+  //  * 5 - aggiungo nodo a connection (true)
+  //  * 6 - aggiungo job su onDisconnect di deviceConnectionRef che rimuove nodo connection 
+  //  * 7 - aggiungo job su onDisconnect di lastOnlineRef che imposta timestamp
+  //  * 8 - salvo reference connected nel singlelton !!!!! DA FARE
+  //  * @param userid
+  //  */
+  // setupMyPresence(userid){
+  //   let that = this;
+  //   this.myConnectionsRef = this.onlineRefForUser(userid);
+  //   this.lastOnlineRef = this.lastOnlineRefForUser(userid);
+  //   let connectedRefURL = "/.info/connected";
+  //   let conn = firebase.database().ref(connectedRefURL);
+  //   conn.on('value', function(dataSnapshot) {
+  //     //console.log("KEY: ",dataSnapshot,that.deviceConnectionRef);
+  //     if(dataSnapshot.val()){
+  //       console.log("self.deviceConnectionRef: ", that.myConnectionsRef);
+  //       //if (!that.myConnectionsRef || that.myConnectionsRef==='undefined') {
+  //       if (that.myConnectionsRef) {
+  //         //this.deviceConnectionRef = myConnectionsRef.set(true);
+  //         let conection = true;
+  //         //that.deviceConnectionRef = 
+  //         const keyMyConnectionRef = that.myConnectionsRef.push(conection);
+  //         //!!! quando faccio logout devo disconnettermi
+  //         keyMyConnectionRef.onDisconnect().remove();
+  //         // when I disconnect, update the last time I was seen online
+  //         let now: Date = new Date();
+  //         let timestamp = now.valueOf();
+  //         that.lastOnlineRef.onDisconnect().set(timestamp);
+  //       } else {
+  //         console.log("This is an error. self.deviceConnectionRef already set. Cannot be set again.");
+  //       }
+  //     }
+  //   });
+  // }
+
+  /**
+   * rimuovo la references su lastOnline
+   * rimuovo la references su connection
+   */
+  // goOffline() {
+  //   console.log("goOffline.", this.myConnectionsRef)
+  //   // this.removeConnectionReference();
+  //   this.removeLastOnlineReference();
+  // }
+
+  // removeConnectionReference(){
+  //   if(this.myConnectionsRef){
+  //     this.myConnectionsRef.off();
+  //     console.log("goOffline 1", this.myConnectionsRef)
+  //     this.myConnectionsRef.remove();
+  //     console.log("goOffline 2", this.myConnectionsRef)
+  //   }
+  //   this.myConnectionsRef = null;
+  // }
+
+//   removeLastOnlineReference(){
+//     if(this.lastOnlineRef){
+//       this.lastOnlineRef.off();
+//       this.lastOnlineRef.remove();
+//     }
+//     this.lastOnlineRef = null;
+//   }
+// }

package/src/chat21-core/providers/mqtt/mqtt-typing.service.ts

@@ -0,0 +1,93 @@
+import { Injectable } from '@angular/core';
+
+// firebase
+import * as firebase from 'firebase/app';
+import 'firebase/messaging';
+import 'firebase/database';
+
+// services
+// import { EventsService } from './abstract/events-service';
+import { PresenceService } from '../abstract/presence.service';
+import { LoggerService } from 'src/chat21-core/providers/abstract/logger.service';
+import { LoggerInstance } from '../logger/loggerInstance';
+// utils
+import { setLastDate } from '../../utils/utils';
+import { environment } from '../../../environments/environment';
+import { TypingService } from '../abstract/typing.service';
+
+export class TypingModel {
+
+
+  constructor(
+      public timestamp: any,
+      public message: string,
+      public name: string
+  ) { }
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+
+export class MQTTTypingService extends TypingService {
+
+  // private params
+  private tenant: string;
+  private urlNodeTypings: string;
+  private setTimeoutWritingMessages: any;
+  private logger: LoggerService = LoggerInstance.getInstance();
+  
+  constructor(
+    // private events: EventsService
+  ) {
+    super();
+  }
+
+  /** */
+  initialize(tenant: string) {
+    // this.tenant = this.getTenant();
+    this.tenant = tenant;
+    this.logger.info('[MQTT-TYPING] initialize this.tenant', this.tenant);
+    this.urlNodeTypings = '/apps/' + this.tenant + '/typings/';
+  }
+
+  /** */
+  isTyping(idConversation: string, idUser: string) {
+    // const that = this;
+    // let urlTyping = this.urlNodeTypings + idConversation;
+    // if (idUser) {
+    //   urlTyping = this.urlNodeTypings + idUser + '/' + idConversation;
+    // }
+    // console.log('urlTyping: ', urlTyping);
+    // const ref = firebase.database().ref(urlTyping).orderByChild('timestamp').limitToLast(1);
+    // ref.on('child_changed', (childSnapshot) => {
+    //   console.log('urlTyping: ', childSnapshot.val());
+    //   that.events.publish('isTypings', childSnapshot);
+    // });
+  }
+
+  /** */
+  setTyping(idConversation: string, message: string, idUser: string, userFullname: string) {
+    // const that = this;
+    // this.setTimeoutWritingMessages = setTimeout(() => {
+
+    //   let urlTyping = this.urlNodeTypings + idConversation;
+    //   if (idUser) {
+    //     urlTyping = this.urlNodeTypings + idUser + '/' + idConversation;
+    //   }
+    //   console.log('setWritingMessages:', urlTyping, userFullname);
+    //   const timestampData =  firebase.database.ServerValue.TIMESTAMP;
+    //   const precence = new TypingModel(timestampData, message, userFullname);
+    //   console.log('precence::::', precence);
+    //   firebase.database().ref(urlTyping).set(precence, ( error ) => {
+    //     if (error) {
+    //       console.log('ERRORE', error);
+    //     } else {
+    //       console.log('OK update typing');
+    //     }
+    //     that.events.publish('setTyping', precence, error);
+    //   });
+    // }, 500);
+  }
+
+}

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

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import { ImageRepoService } from 'src/chat21-core/providers/abstract/image-repo.service';
+
+// @Injectable({ providedIn: 'root' })
+@Injectable()
+export class NativeImageRepoService extends ImageRepoService {
+    
+    private baseImageURL: string;
+    
+    constructor() {
+        super();
+    }
+
+    /**
+     * @param uid
+     */
+    getImagePhotoUrl(uid: string): string {
+        this.baseImageURL = this.getImageBaseUrl() + 'images'
+        let sender_id = '';
+        if (uid.includes('bot_')) {
+            sender_id = uid.slice(4)
+        } else {
+            sender_id = uid
+        }
+        const filename_photo = '?path=uploads/users/'+ sender_id + '/images/photo.jpg'
+        const filename_thumbnail = '?path=uploads/users/'+ sender_id + '/images/thumbnails_200_200-photo.jpg'
+        return this.baseImageURL + filename_photo
+   } 
+
+}