@chat21/chat21-ionic 2.0.13 → 3.0.5-9.2

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

@@ -0,0 +1,190 @@
+import { LoggerService } from 'src/chat21-core/providers/abstract/logger.service';
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+
+// firebase
+// import * as firebase from 'firebase/app';
+import firebase from "firebase/app";
+import 'firebase/messaging';
+import 'firebase/database';
+
+// services
+// import { EventsService } from '../events-service';
+import { PresenceService } from '../abstract/presence.service';
+import { CustomLogger } from '../logger/customLogger';
+import { LoggerInstance } from '../logger/loggerInstance';
+
+// utils
+// import { setLastDate } from '../../utils/utils';
+// import { environment } from '../../../environments/environment';
+
+// @Injectable({providedIn: 'root'})
+@Injectable()
+export class FirebasePresenceService extends PresenceService {
+
+  // BehaviorSubject
+  // BSIsOnline: BehaviorSubject<any>;
+  BSIsOnline: BehaviorSubject<any>;
+  BSLastOnline: BehaviorSubject<any>;
+
+  // public tenant: string;
+
+  // -------------------------------
+  // private params
+  // -------------------------------
+  private tenant: string;
+  private urlNodePresence: string;
+  private onlineConnectionsRef: any;
+  private lastOnlineConnectionsRef: any;
+  private keyConnectionRef: any;
+  private logger: LoggerService = LoggerInstance.getInstance();
+  online_member = []
+  constructor() {
+    super();
+  }
+
+  /**
+   *
+   */
+  public initialize(tenant: string) {
+    // this.tenant = this.getTenant();
+    this.tenant = tenant;
+    this.logger.log('[FIREBASEPresenceSERVICE] initialize this.tenant', this.tenant);
+    this.urlNodePresence = '/apps/' + this.tenant + '/presence/';
+  }
+
+  /**
+   * userIsOnline
+   * @param userid
+   */
+  // public userIsOnline(userid: string) {
+  //   this.logger.debug('[FIREBASEPresenceSERVICE] userIsOnline', userid);
+  //   this.logger.debug('CONVERSATION-DETAIL group detail userIsOnline', userid);
+  //   const that = this;
+  //   const urlNodeConnections = this.urlNodePresence + userid + '/connections';
+  //   this.logger.debug('[FIREBASEPresenceSERVICE] userIsOnline: ', urlNodeConnections);
+  //   const connectionsRef = firebase.database().ref().child(urlNodeConnections);
+  //   connectionsRef.on('value', (child) => {
+  //     this.logger.debug('[FIREBASEPresenceSERVICE] is-online-' + userid);
+  //     if (child.val()) {
+  //       this.logger.debug('CONVERSATION-DETAIL group detail userIsOnline id user', userid, '- child.val: ', child.val());
+  //       this.BSIsOnline.next({uid: userid, isOnline: true});
+  //       this.logger.debug('CONVERSATION-DETAIL group detail userIsOnline 1', userid);
+  //     } else {
+  //       this.BSIsOnline.next({uid: userid, isOnline: false});
+  //       this.logger.debug('CONVERSATION-DETAIL group detail userIsOnline 2', userid);
+  //     }
+  //   });
+  // }
+
+  public userIsOnline(userid: string): Observable<any> {
+    const that = this;
+    let local_BSIsOnline = new BehaviorSubject<any>(null);
+    const urlNodeConnections = this.urlNodePresence + userid + '/connections';
+    this.logger.debug('[FIREBASEPresenceSERVICE] userIsOnline: ', urlNodeConnections);
+    const connectionsRef = firebase.database().ref().child(urlNodeConnections);
+    connectionsRef.off()
+    connectionsRef.on('value', (child) => {
+      that.logger.debug('[FIREBASEPresenceSERVICE] CONVERSATION-DETAIL group detail userIsOnline id user', userid, '- child.val: ', child.val());
+      if (child.val()) {
+        that.BSIsOnline.next({ uid: userid, isOnline: true });
+        local_BSIsOnline.next({ uid: userid, isOnline: true });
+      } else {
+        that.BSIsOnline.next({ uid: userid, isOnline: false });
+        local_BSIsOnline.next({ uid: userid, isOnline: false });
+      }
+    });
+    return local_BSIsOnline
+  }
+
+
+  /**
+   * lastOnlineForUser
+   * @param userid
+   */
+  public lastOnlineForUser(userid: string) {
+    this.logger.debug('[FIREBASEPresenceSERVICE] lastOnlineForUser', userid);
+    const that = this;
+    const lastOnlineRef = this.referenceLastOnlineForUser(userid);
+    lastOnlineRef.on('value', (child) => {
+      if (child.val()) {
+        this.BSLastOnline.next({ uid: userid, lastOnline: child.val() });
+      } else {
+        this.BSLastOnline.next({ uid: userid, lastOnline: null });
+      }
+    });
+  }
+
+
+  /**
+   * 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
+   *  https://firebase.google.com/docs/database/web/offline-capabilities?hl=it
+   * @param userid
+   */
+  public setPresence(userid: string): void {
+    this.logger.log('initialize FROM [APP-COMP] - [FIREBASEPresenceSERVICE] - SET PRESENCE userid ', 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) => {
+      this.logger.debug('[FIREBASEPresenceSERVICE] 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 {
+          this.logger.error('[FIREBASEPresenceSERVICE] setPresence --> 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();
+      this.logger.debug('[FIREBASEPresenceSERVICE] goOffline onlineConnectionsRef', this.onlineConnectionsRef);
+    }
+  }
+
+  /**
+   * recupero la reference di lastOnline del currentUser
+   * usata in setupMyPresence
+   * @param userid
+   */
+  private referenceLastOnlineForUser(userid: string): firebase.database.Reference {
+    const urlNodeLastOnLine = this.urlNodePresence + userid + '/lastOnline';
+    const lastOnlineRef = firebase.database().ref().child(urlNodeLastOnLine);
+    return lastOnlineRef;
+  }
+
+  /**
+   * recupero la reference di connections (online/offline) del currentUser
+   * usata in setupMyPresence
+   * @param userid
+   */
+  private referenceOnlineForUser(userid: string): firebase.database.Reference {
+    const urlNodeConnections = this.urlNodePresence + userid + '/connections';
+    const connectionsRef = firebase.database().ref().child(urlNodeConnections);
+    return connectionsRef;
+  }
+
+}

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

@@ -0,0 +1,93 @@
+import { LoggerService } from 'src/chat21-core/providers/abstract/logger.service';
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+
+// firebase
+// import * as firebase from 'firebase/app';
+import firebase from "firebase/app";
+import 'firebase/messaging';
+import 'firebase/database';
+
+// services
+import { TypingService } from '../abstract/typing.service';
+import { CustomLogger } from '../logger/customLogger';
+import { LoggerInstance } from '../logger/loggerInstance';
+
+
+export class TypingModel {
+ 
+
+  constructor(
+      public uid: string,
+      public timestamp: any,
+      public message: string,
+      public name: string
+  ) { }
+}
+
+// @Injectable({
+//   providedIn: 'root'
+// })
+@Injectable()
+export class FirebaseTypingService extends TypingService {
+
+  // BehaviorSubject
+  BSIsTyping: BehaviorSubject<any>;
+  BSSetTyping: BehaviorSubject<any>;
+
+  // public params
+  // public tenant: string;
+  private tenant: string;
+
+  // private params
+  private urlNodeTypings: string;
+  private setTimeoutWritingMessages: any;
+  private logger: LoggerService = LoggerInstance.getInstance();
+
+  constructor() {
+    super();
+  }
+
+  /** */
+  public initialize(tenant: string) {
+    // this.tenant = this.getTenant();
+    this.tenant = tenant;
+    this.logger.log('[FIREBASETypingSERVICE] initialize - tenant ', this.tenant)
+    this.urlNodeTypings = '/apps/' + this.tenant + '/typings/';
+  }
+
+  /** */
+  public isTyping(idConversation: string, idCurrentUser: string, isDirect: boolean ) {
+    const that = this;
+    let urlTyping = this.urlNodeTypings + idConversation;
+    if (isDirect) {
+      urlTyping = this.urlNodeTypings + idCurrentUser + '/' + idConversation;
+    }
+    this.logger.debug('[FIREBASETypingSERVICE] urlTyping: ', urlTyping);
+    const ref = firebase.database().ref(urlTyping);
+    ref.on('child_changed', (childSnapshot) => {
+      const precence: TypingModel = childSnapshot.val();
+      this.BSIsTyping.next({uid: idConversation, uidUserTypingNow: precence.uid, nameUserTypingNow: precence.name});
+    });
+  }
+
+  /** */
+  public setTyping(idConversation: string, message: string, recipientId: string, userFullname: string) {
+    const that = this;
+    clearTimeout(this.setTimeoutWritingMessages);
+    this.setTimeoutWritingMessages = setTimeout(() => {
+      const urlTyping = this.urlNodeTypings + idConversation + '/' + recipientId;// + '/user';
+      this.logger.debug('[FIREBASETypingSERVICE] setWritingMessages:', urlTyping, userFullname);
+      const timestampData =  firebase.database.ServerValue.TIMESTAMP;
+      const precence = new TypingModel(recipientId, timestampData, message, userFullname);
+      firebase.database().ref(urlTyping).set(precence, ( error ) => {
+        if (error) {
+          this.logger.error('[FIREBASETypingSERVICE] setTyping error', error);
+        } else {
+          this.BSSetTyping.next({uid: idConversation, typing: precence});
+        }
+      });
+    }, 500);
+  }
+
+}

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

@@ -0,0 +1,106 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+
+// firebase
+// import * as firebase from 'firebase/app';
+import firebase from "firebase/app";
+import 'firebase/messaging';
+import 'firebase/database';
+import 'firebase/storage';
+import 'firebase/firestore';
+
+// services
+import { UploadService } from '../abstract/upload.service';
+import { LoggerInstance } from '../logger/loggerInstance';
+import { LoggerService } from '../abstract/logger.service';
+
+// models
+import { UploadModel } from '../../models/upload';
+
+// @Injectable({
+//   providedIn: 'root'
+// })
+@Injectable()
+export class FirebaseUploadService extends UploadService {
+
+  // BehaviorSubject
+  BSStateUpload: BehaviorSubject<any>;
+
+  //private
+  private url: string;
+  private logger: LoggerService = LoggerInstance.getInstance()
+
+  constructor() {
+    super();
+  }
+
+  private createGuid() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+      // tslint:disable-next-line:no-bitwise
+      const r = Math.random() * 16 | 0, v = c === 'x' ? r : (r & 0x3 | 0x8);
+      return v.toString(16);
+    });
+  }
+
+  public initialize() {
+    this.logger.log('[FIREBASEUploadSERVICE] initialize');
+  }
+  
+  public upload(userId: string, upload: UploadModel): Promise<any> {
+    const that = this;
+    const uid = this.createGuid();
+    const urlImagesNodeFirebase = '/public/images/' + userId + '/' + uid + '/' + upload.file.name;
+    this.logger.debug('[FIREBASEUploadSERVICE] pushUpload ', urlImagesNodeFirebase, upload.file);
+
+    // Create a root reference
+    const storageRef = firebase.storage().ref();
+    this.logger.debug('[FIREBASEUploadSERVICE] storageRef', storageRef);
+    
+    // Create a reference to 'mountains.jpg'
+    const mountainsRef = storageRef.child(urlImagesNodeFirebase);
+    this.logger.debug('[FIREBASEUploadSERVICE] mountainsRef ', mountainsRef);
+ 
+    // const metadata = {};
+    const metadata = { name: upload.file.name, contentType: upload.file.type, contentDisposition: 'attachment; filename=' + upload.file.name };
+
+    let uploadTask = mountainsRef.put(upload.file, metadata);
+   
+    return new Promise((resolve, reject) => {
+      uploadTask.on('state_changed', function progress(snapshot) {
+        // Observe state change events such as progress, pause, and resume
+        // Get task progress, including the number of bytes uploaded and the total number of bytes to be uploaded
+        var progress = (snapshot.bytesTransferred / snapshot.totalBytes) * 100;
+        that.logger.debug('[FIREBASEUploadSERVICE] Upload is ' + progress + '% done');
+        
+        // ----------------------------------------------------------------------------------------------------------------------------------------------
+        // BehaviorSubject publish the upload progress state - the subscriber is in ion-conversastion-detail.component.ts > listenToUploadFileProgress()
+        // ----------------------------------------------------------------------------------------------------------------------------------------------
+      
+        that.BSStateUpload.next({ upload: progress, type: upload.file.type });
+        
+        switch (snapshot.state) {
+          case firebase.storage.TaskState.PAUSED: // or 'paused'
+            that.logger.debug('[FIREBASEUploadSERVICE] Upload is paused');
+            
+            break;
+          case firebase.storage.TaskState.RUNNING: // or 'running'
+            that.logger.debug('[FIREBASEUploadSERVICE] Upload is running');
+            
+            break;
+        }
+      }, function error(error) {
+        // Handle unsuccessful uploads
+        reject(error)
+      }, function complete() {
+        // Handle successful uploads on complete
+        that.logger.debug('[FIREBASEUploadSERVICE] Upload is complete', upload);
+       
+        resolve(uploadTask.snapshot.ref.getDownloadURL())
+        // that.BSStateUpload.next({upload: upload});
+
+      });
+    })
+
+  }
+
+}

package/src/chat21-core/providers/localSessionStorage.ts

@@ -0,0 +1,215 @@
+import { Injectable } from '@angular/core';
+import { AppStorageService } from './abstract/app-storage.service';
+import { STORAGE_PREFIX } from '../utils/constants';
+import { supports_html5_session, supports_html5_storage } from '../utils/utils';
+import { LoggerService } from './abstract/logger.service';
+import { LoggerInstance } from './logger/loggerInstance';
+
+@Injectable()
+export class LocalSessionStorage extends AppStorageService {
+
+  private storagePrefix: string = STORAGE_PREFIX;
+  private projectID: string;
+  private persistence: string;
+  private logger: LoggerService = LoggerInstance.getInstance();
+
+  initialize(storagePrefix: string, persistence: string, projectID: string): void {
+    this.storagePrefix = storagePrefix;
+    this.projectID = projectID;
+    this.persistence = persistence;
+    // this.persistence = 'LOCAL';
+    // this.logger.info('[LocalSessionStorage] - initialize ', this.storagePrefix, this.persistence, this.projectID)
+  }
+
+  /** GET item in local/session storage from key value
+   *  @param key
+   */
+  getItem(key: string) {
+    let prefix;
+    try {
+      // const sv = 'sv' + environment.shemaVersion + '_';
+      // prefix = prefix + sv;
+      prefix = this.storagePrefix + '_';
+    } catch (e) {
+      this.logger.error('[LocalSessionStorage] getItem - Error :' + e);
+    }
+    const newKey = prefix + this.projectID + '_' + key;
+    return this.getValueForKey(newKey);
+  }
+
+  /** SET new item in local/session storage
+   *  @param key
+   *  @param value
+   */
+  setItem(key: string, value: any): void {
+    // this.removeItem(key);
+    let prefix;
+    try {
+      // const sv = 'sv' + environment.shemaVersion + '_';
+      // prefix = prefix + sv;
+      prefix = this.storagePrefix + '_';
+    } catch (e) {
+      this.logger.error('[LocalSessionStorage] setItem > Error :' + e);
+    }
+    const newKey = prefix + this.projectID + '_' + key;
+    this.saveValueForKey(newKey, value);
+  }
+
+  /** GET item in local/session storage from key value without project id SUFFIX
+   * @param key
+   * @deprecated
+   */
+  // getItemWithoutProjectID(key: string) {
+  //     let prefix;
+  //     try {
+  //         // const sv = 'sv' + environment.shemaVersion + '_';
+  //         // prefix = prefix + sv;
+  //         prefix = this.storagePrefix + '_';
+  //     } catch (e) {
+  //         this.logger.error('[LocalSessionStorage] getItemWithoutProjectID > Error :' + e);
+  //     }
+  //     const newKey = prefix + key;
+  //     return this.getValueForKey(newKey);
+  // }
+
+  /** SET new item in local/session storage without project id SUFFIX
+   *  @param key
+   *  @param value
+   */
+  // setItemWithoutProjectID(key: string, value: any): void {
+  //   this.removeItem(key);
+  //   let prefix = STORAGE_PREFIX;
+  //   try {
+  //     // const sv = 'sv' + environment.shemaVersion + '_';
+  //     // prefix = prefix + sv;
+  //     prefix = this.storagePrefix + '_';
+  //   } catch (e) {
+  //     this.logger.error('[LocalSessionStorage] setItemWithoutProjectID > Error :' + e);
+  //   }
+  //   const newKey = prefix + key;
+  //   this.saveValueForKey(newKey, value);
+  // }
+
+  removeItem(key: string): void {
+    let prefix;
+    try {
+      // const sv = 'sv' + environment.shemaVersion + '_';
+      // prefix = prefix + sv;
+      prefix = this.storagePrefix + '_';
+    } catch (e) {
+      this.logger.error('[LocalSessionStorage] removeItem > Error :' + e);
+    }
+    const newKey = prefix + this.projectID + '_' + key;
+    return this.removeItemForKey(newKey);
+  }
+
+  clear(): void {
+    let prefix;
+    try {
+      // const sv = 'sv' + environment.shemaVersion + '_';
+      // prefix = prefix + sv;
+      prefix = this.storagePrefix + '_';
+    } catch (e) {
+      this.logger.error('[LocalSessionStorage] clear > Error :' + e);
+    }
+    const prefixKey = prefix + this.projectID
+    const arrayKey: Array<string> = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key.indexOf(prefixKey) !== -1) {
+        arrayKey.push(key);
+      }
+    }
+
+    for (let i = 0; i < arrayKey.length; i++) {
+      // localStorage.removeItem(arrayKey[i]);
+      this.removeItemForKey(arrayKey[i]);
+    }
+
+  }
+
+
+  // ---------- PRIVATE METHODS start --------------- //
+
+  private getValueForKey(key) {
+    if (this.persistence === 'local' || this.persistence === 'LOCAL') {
+      if (supports_html5_storage()) {
+        return localStorage.getItem(key);
+      } else {
+        this.logger.warn('localStorage is not defind. Storage disabled');
+        return null;
+      }
+    } else if (this.persistence === 'session' || this.persistence === 'SESSION') {
+      if (supports_html5_session()) {
+        return sessionStorage.getItem(key);
+      } else {
+        this.logger.warn('sessionStorage is not defind. Storage disabled');
+        return null;
+      }
+    } else if (this.persistence === 'none' || this.persistence === 'NONE') {
+      return null;
+    } else {
+      if (supports_html5_storage()) {
+        return localStorage.getItem(key);
+      } else {
+        this.logger.warn('localStorage is not defind. Storage disabled');
+        return null;
+      }
+    }
+  }
+
+  private saveValueForKey(key, value) {
+    if (this.persistence === 'local' || this.persistence === 'LOCAL') {
+      if (supports_html5_storage()) {
+        return localStorage.setItem(key, value);
+      } else {
+        this.logger.warn('localStorage is not defined. Storage disabled');
+        return null;
+      }
+    } else if (this.persistence === 'session' || this.persistence === 'SESSION') {
+      if (supports_html5_session()) {
+        return sessionStorage.setItem(key, value);
+      } else {
+        this.logger.warn('sessionStorage is not defined. Storage disabled');
+        return null;
+      }
+    } else if (this.persistence === 'none' || this.persistence === 'NONE') {
+      return null;
+    } else {
+      if (supports_html5_storage()) {
+        return localStorage.setItem(key, value);
+      } else {
+        this.logger.warn('localStorage is not defined. Storage disabled');
+        return null;
+      }
+    }
+  }
+
+  private removeItemForKey(key: string) {
+    if (this.persistence === 'local' || this.persistence === 'LOCAL') {
+      if (supports_html5_storage()) {
+        return localStorage.removeItem(key);
+      } else {
+        this.logger.warn('localStorage is not defind. Storage disabled');
+        return null;
+      }
+    } else if (this.persistence === 'session' || this.persistence === 'SESSION') {
+      if (supports_html5_session()) {
+        return sessionStorage.removeItem(key);
+      } else {
+        this.logger.warn('sessionStorage is not defind. Storage disabled');
+        return null;
+      }
+    } else if (this.persistence === 'none' || this.persistence === 'NONE') {
+      return null;
+    } else {
+      if (supports_html5_storage()) {
+        return localStorage.removeItem(key);
+      } else {
+        this.logger.warn('localStorage is not defind. Storage disabled');
+        return null;
+      }
+    }
+  }
+
+}

package/src/chat21-core/providers/logger/customLogger.ts

@@ -0,0 +1,70 @@
+import { LogLevel } from './../../utils/constants';
+import { Inject, Injectable } from '@angular/core';
+import { NGXLogger, NGXLoggerMonitor, NGXLogInterface } from 'ngx-logger';
+import { LoggerService } from './../abstract/logger.service';
+@Injectable()
+export class CustomLogger implements LoggerService {
+    // Error = 0,
+    // Warn = 1,
+    // Info = 2,
+    // Debug = 3
+
+    //private variables
+    // private logger: NGXLogger 
+    private logLevel: number = LogLevel.DEBUG;
+    private isLogEnabled: boolean = true;
+
+    constructor(private logger: NGXLogger) { }
+
+    setLoggerConfig(isLogEnabled: boolean, logLevel: string) {
+
+        this.isLogEnabled = isLogEnabled;
+        // console.log('LoggerService this.logLevel  ', this.logLevel)
+
+        if (logLevel) {
+            // console.log('LoggerService typeof logLevel  ', typeof logLevel)
+            if (typeof logLevel === 'string') {
+                this.logLevel = LogLevel[logLevel.toUpperCase()];
+                // console.log('LoggerService this.logLevel toUpperCase', this.logLevel)
+            } else {
+                console.error('logLevel is not a string. See the chat21-ionic README.md')
+            }
+        }
+    }
+
+    error(...message: any[]) {
+        if (this.isLogEnabled && this.logLevel >= LogLevel.ERROR) {
+            this.logger.error(message)
+            // console.log(message)
+        }
+    }
+
+    warn(...message: any[]) {
+        if (this.isLogEnabled && this.logLevel >= LogLevel.WARN) {
+            this.logger.warn(message)
+            // console.log(message)
+        }
+    }
+
+    info(...message: any[]) {
+        if (this.isLogEnabled && this.logLevel >= LogLevel.INFO) {
+            this.logger.info(message)
+            // console.log(message)
+        }
+    }
+
+    debug(...message: any[]) {
+        if (this.isLogEnabled && this.logLevel >= LogLevel.DEBUG) {
+            this.logger.debug(message)
+            // console.debug(message)
+        }
+    }
+
+    log(...message: any[]) {
+        if (this.isLogEnabled && this.logLevel >= LogLevel.DEBUG) {
+            // console.log(message);
+            this.logger.log(message)
+        }
+    }
+
+}

package/src/chat21-core/providers/logger/loggerInstance.ts

@@ -0,0 +1,20 @@
+import { LoggerService } from 'src/chat21-core/providers/abstract/logger.service';
+import { Injectable } from '@angular/core'
+import { CustomLogger } from './customLogger';
+
+@Injectable()
+export class LoggerInstance  {
+    
+    
+    //private variables
+    private static instance: LoggerService;
+    
+    static getInstance() {
+        return LoggerInstance.instance;
+    }
+
+    static setInstance(loggerService: LoggerService) {
+        LoggerInstance.instance = loggerService
+    }
+
+}