@chat21/chat21-ionic 3.0.106 → 3.0.107-rc.2

package/src/app/services/global-settings/global-settings.service.ts

@@ -0,0 +1,138 @@
+import { HttpClient } from '@angular/common/http';
+import { ElementRef, Injectable } from '@angular/core';
+import { AppStorageService } from 'src/chat21-core/providers/abstract/app-storage.service';
+import { AppConfigProvider } from '../app-config';
+import { BehaviorSubject } from 'rxjs';
+import { LoggerService } from 'src/chat21-core/providers/abstract/logger.service';
+import { LoggerInstance } from 'src/chat21-core/providers/logger/loggerInstance';
+import { Globals } from 'src/app/utils/globals';
+import { getParameterByName, stringToBoolean } from 'src/chat21-core/utils/utils';
+import { environment } from 'src/environments/environment';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class GlobalSettingsService {
+
+  globals: Globals;
+  el: ElementRef;
+  obsSettingsService: BehaviorSubject<boolean>;
+  private logger: LoggerService = LoggerInstance.getInstance()
+
+  constructor(
+      public http: HttpClient,
+      private appStorageService: AppStorageService,
+      // private settingsService: SettingsService,
+      public appConfigService: AppConfigProvider
+  ) {
+      this.obsSettingsService = new BehaviorSubject<boolean>(null);
+  }
+
+   /**
+     * load paramiters
+     * 0 - imposto globals con i valori di default
+     * 3 - richiamo setParameters per il settaggio dei parametri
+     */
+   initParamiters(globals: Globals, el: ElementRef) {
+    const that = this;
+    this.globals = globals;
+    this.el = el;
+
+    /**
+    * SETTING LOCAL DEFAULT:
+    * set the default globals parameters
+    */
+    this.globals.initDefafultParameters();
+
+    /**SET TENANT parameter */
+    this.globals.tenant = this.appConfigService.getConfig().firebaseConfig.tenant
+    /**SET LOGLEVEL parameter */
+    this.globals.logLevel = this.appConfigService.getConfig().logLevel
+    /**SET PERSISTENCE parameter */
+    this.globals.persistence = this.appConfigService.getConfig().authPersistence
+     /**SET SUPPORTMODE parameter */
+     this.globals.supportMode = this.appConfigService.getConfig().supportMode
+    /** INIT STORAGE SERVICE */
+    this.appStorageService.initialize(environment.storage_prefix, this.globals.persistence, '')
+
+    /** LOAD PARAMETERS 
+     * set parameters in globals
+    */
+   this.setParameters()
+   }
+
+
+   /**
+   * 3: setParameters
+   * imposto i parametri secondo il seguente ordine:
+   * D: imposto i parametri recuperati dallo storage in global
+   * E: imposto i parametri recuperati da url parameters in global
+  */
+  setParameters() {
+    this.logger.debug('[GLOBAL-SET] ***** setParameters ***** ')
+    this.setVariableFromStorage(this.globals);
+    this.setVariablesFromUrlParameters(this.globals);
+    this.logger.debug('[GLOBAL-SET] ***** END SET PARAMETERS *****');
+    this.obsSettingsService.next(true);
+  }
+
+
+  /**
+   * D: setVariableFromStorage
+   * recupero il dictionary global dal local storage
+   * aggiorno tutti i valori di globals
+   * @param globals
+  */
+  setVariableFromStorage(globals: Globals) {
+    this.logger.debug('[GLOBAL-SET] setVariableFromStorage :::::::: SET VARIABLE ---------->', Object.keys(globals));
+    for (const key of Object.keys(globals)) {
+        const val = this.appStorageService.getItem(key);
+        // this.logger.debug('[GLOBAL-SET] setVariableFromStorage SET globals KEY ---------->', key);
+        // this.logger.debug('[GLOBAL-SET] setVariableFromStorage SET globals VAL ---------->', val);
+        if (val && val !== null) {
+            // globals.setParameter(key, val);
+            globals[key] = stringToBoolean(val);
+        }
+        // this.logger.debug('[GLOBAL-SET] setVariableFromStorage SET globals == ---------->', globals);
+    } 
+  }
+
+  /**
+  * E: setVariableFromUrlParameters
+  */
+  setVariablesFromUrlParameters(globals: Globals) {
+    this.logger.debug('[GLOBAL-SET] setVariablesFromUrlParameters: ');
+    const windowContext = globals.windowContext;
+    let TEMP: any;
+    TEMP = getParameterByName(windowContext, 'tiledesk_tenant');
+    if (TEMP) {
+        globals.tenant = stringToBoolean(TEMP);
+    }
+
+    TEMP = getParameterByName(windowContext, 'tiledesk_supportMode');
+    if (TEMP) {
+        globals.supportMode = stringToBoolean(TEMP);
+    }
+
+    TEMP = getParameterByName(windowContext, 'tiledesk_lang');
+    if (TEMP) {
+        globals.lang = stringToBoolean(TEMP);
+    }
+
+    TEMP = getParameterByName(windowContext, 'tiledesk_persistence');
+    if (TEMP) {
+        globals.persistence = TEMP;
+    }
+
+    TEMP = getParameterByName(windowContext, 'jwt');
+    if (TEMP) {
+        globals.jwt = TEMP;
+    }
+
+    TEMP = getParameterByName(windowContext, 'tiledesk_logLevel');
+    if (TEMP) {
+        globals.logLevel = TEMP;
+    }
+
+}
+}

package/src/app/services/triggerEvents/trigerEvents.spec.ts

@@ -0,0 +1,11 @@
+import { TestBed } from '@angular/core/testing';
+import { TriggerEvents } from './triggerEvents';
+
+describe('TriggerEvents', () => {
+  beforeEach(() => TestBed.configureTestingModule({}));
+
+  it('should be created', () => {
+    const service: TriggerEvents = TestBed.get(TriggerEvents);
+    expect(service).toBeTruthy();
+  });
+});

package/src/app/services/triggerEvents/triggerEvents.ts

@@ -0,0 +1,92 @@
+import { MessageModel } from "src/chat21-core/models/message";
+import { LoggerService } from "src/chat21-core/providers/abstract/logger.service";
+import { LoggerInstance } from "src/chat21-core/providers/logger/loggerInstance";
+import { AppConfigProvider } from "../app-config";
+import { ConversationModel } from "src/chat21-core/models/conversation";
+import { ElementRef, Injectable } from "@angular/core";
+
+@Injectable({
+    providedIn: 'root'
+})
+export class TriggerEvents {
+
+    private el: ElementRef;
+    private windowContext;
+    private logger: LoggerService = LoggerInstance.getInstance()
+    
+    constructor(
+        private appConfig: AppConfigProvider
+    ){}
+
+    public setElement(el: ElementRef){
+        this.el = el
+    }
+
+    public setWindowContext(windowContext){
+        this.windowContext = windowContext
+    }
+
+
+    public triggerOnAuthStateChanged(detailObj: {}) {
+        this.logger.debug(' ---------------- triggerOnAuthStateChanged ---------------- ', detailObj);
+        try {
+            const onAuthStateChanged = new CustomEvent('onAuthStateChanged', { detail: detailObj});
+            const windowContext = this.windowContext;
+            if (windowContext){
+                // window.parent.dispatchEvent(onAuthStateChanged);
+                window.parent.postMessage({type: "onAuthStateChanged", detail: detailObj}, '*')
+                // this.el.nativeElement.dispatchEvent(onAuthStateChanged);
+            }
+        } catch (e) {
+            this.logger.error('[TRIGGER-HANDLER] > Error:' + e);
+        }
+    }
+
+    public triggerAfterSendMessageEvent(messageSent: MessageModel){
+        this.logger.debug(' ---------------- triggerAfterSendMessageEvent ---------------- ', messageSent);
+        try {
+            const onAfterMessageSend = new CustomEvent('onAfterMessageSend', { detail: { message: messageSent } });
+            const windowContext = this.windowContext;
+            if (windowContext){
+                // windowContext.document.dispatchEvent(onAfterMessageSend);
+                window.parent.postMessage({type: "onAfterMessageSend", detail: { message: messageSent }}, '*')
+            }
+        } catch (e) {
+            this.logger.error('[TRIGGER-HANDLER] > Error:' + e);
+        }
+
+    }
+
+    
+    public triggerAfterMessageReceived(message: MessageModel){
+        this.logger.debug(' ---------------- triggerAfterMessageReceived ---------------- ', message);
+        try {
+            const onAfterMessageReceived = new CustomEvent('onAfterMessageReceived', { detail: { message: message } });
+            const windowContext = this.windowContext;
+            if (windowContext){
+                // windowContext.document.dispatchEvent(onAfterMessageReceived);
+                window.parent.postMessage({type: "onAfterMessageReceived", detail: { message: message }}, '*')
+            }
+        } catch (e) {
+            this.logger.error('[TRIGGER-HANDLER] > Error:' + e);
+        }
+
+    }
+
+    public triggerOnNewConversationInit(conversation: ConversationModel){
+        this.logger.debug(' ---------------- triggerOnNewConversation ---------------- ', conversation);
+        try {
+            const onNewConversation = new CustomEvent('onNewConversation', { detail: { conversation: conversation} });
+            const windowContext = this.windowContext;
+            if (windowContext){
+                // windowContext.document.dispatchEvent(onNewConversation);
+                window.parent.postMessage({type: "onNewConversation", detail: { conversation: conversation}}, '*')
+            }
+        } catch (e) {
+            this.logger.error('[TRIGGER-HANDLER] > Error:' + e);
+        }
+
+    }
+
+    
+}

package/src/app/utils/globals.ts

@@ -0,0 +1,51 @@
+import { style } from '@angular/animations';
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { environment } from '../../environments/environment';
+
+/** CONSTANTS */
+import { CHANNEL_TYPE_GROUP } from 'src/chat21-core/utils/constants';
+import { getParameterByName } from 'src/chat21-core/utils/utils';
+
+
+@Injectable({
+    providedIn: 'root'
+  })
+export class Globals {
+
+  windowContext;
+  
+  supportMode: boolean;
+  tenant: string;
+  logLevel: string
+  persistence: string;
+  lang: string;
+  jwt: string;
+
+  constructor(
+  ) { }
+
+
+  /**
+   * 1: initParameters
+   */
+  initDefafultParameters() {
+
+    let wContext: any = window;
+    // this.parameters['windowContext'] = windowContext;
+    this.windowContext = wContext;
+
+    this.supportMode = true
+    this.tenant = 'tilechat'
+    this.logLevel = 'ERROR'
+    this.persistence = 'local';
+    this.lang = 'en'
+
+  }
+
+
+
+
+  
+
+}

package/src/app/utils/toast.ts

@@ -4,7 +4,7 @@ export class Toast {
 
   public toastController: ToastController = new ToastController()
 
-    constructor() {}
+  constructor() {}
 
   async presentToast(message: string, color: string, cssClass: string, duration: number = 2000, position: 'top' | 'bottom' | 'middle'= 'bottom') {
     const toast = await this.toastController.create({

package/src/assets/test.html

@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width">
+  <title>replit</title>
+</head>
+
+<body style="height: 100%;">
+  <div id="titolo">CHAT IONIC TEST PAGE</div>
+
+  <script>        
+    window.addEventListener('message', event => {
+        console.log('[CHAT-IONIC] test page event::', event)
+    })
+  </script>
+
+  <iframe id="myIFrame" frameBorder="0" width="100%" style="display: flex; height: 95vh"
+    src="http://localhost:8080/#/conversation-detail?jwt=JWT eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJfaWQiOiI1ZmQzNGU0MjQ5NjEwZTAwMzQ5ODUwNzgiLCJlbWFpbCI6ImdhYnJpZWxlLnBhbmljb0Bmcm9udGllcmUyMS5pdCIsImZpcnN0bmFtZSI6IkdhYnJpZWxlMiIsImxhc3RuYW1lIjoiUGFuaWNvIC1wcmUiLCJlbWFpbHZlcmlmaWVkIjp0cnVlLCJpYXQiOjE2OTgzMzYyMTMsImF1ZCI6Imh0dHBzOi8vdGlsZWRlc2suY29tIiwiaXNzIjoiaHR0cHM6Ly90aWxlZGVzay5jb20iLCJzdWIiOiJ1c2VyIiwianRpIjoiNjAzZGY3NDQtZWY0OS00Mjg2LWJlMWQtYWM5OGYyYTNkMTJiIn0.bof5QPQP262yCQfpeSjqyoYPkSCttg5NQFkcV8d634xzeq7wJBdhtiO7IJY6hS81a1YyXrAsxlK7RiNS-UZdYiTXR81UXurQd1fnE9jtaggB82tyNL8vmiZEOs6xh4TqO3-kkBzRxQIp74bY53fk_mu5RmNbAjIgUWEufaNDiv8"></iframe>
+</body>
+
+</html>

package/src/chat21-core/models/department.ts

@@ -0,0 +1,12 @@
+export class DepartmentModel {
+    constructor(
+        public appId: string,
+        public createdAt: string,
+        public createdBy: string,
+        public name: string,
+        public updatedAt: string,
+        public _id: string,
+        public offline_msg: string,
+        public online_msg: string
+    ) { }
+}

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

@@ -36,5 +36,7 @@ export abstract class UploadService {
   // functions
   abstract initialize(): void;
   abstract upload(userId: string, upload: UploadModel): Promise<any>;
+  abstract uploadProfile(userId: string, upload: UploadModel): Promise<any>;
   abstract delete(userId: string, path: string): Promise<any>;
+  abstract deleteProfile(userId: string, path: string): Promise<any>
 }

package/src/chat21-core/providers/chat-manager.ts

@@ -23,7 +23,6 @@ export class ChatManager {
 
   BSStart: BehaviorSubject<any> = new BehaviorSubject<any>(null);
 
-  // supportMode = environment.supportMode;
   // tenant = environment.tenant;
   tenant: string
  
@@ -113,25 +112,6 @@ export class ChatManager {
     // this.contactsSynchronizer = null;
   }
 
-  /**
-   * invocato da user.ts al LOGIN:
-   * LOGIN:
-   * 1 - imposto lo stato di connessione utente
-   * 2 - aggiungo il token
-   * 3 - pubblico stato loggedUser come login
-   */
-  // goOnLine(user) {
-  //   if (user) {
-  //     const uid = user.uid;
-  //     this.loggedUser = new UserModel(uid);
-  //     this.logger.('[CHAT MANAGER]goOnLine::: ', this.loggedUser);
-  //     this.loadCurrentUserDetail();
-  //     if (this.supportMode === false) {
-  //       //this.initContactsSynchronizer();
-  //     }
-  //   }
-  // }
-
 
   
 

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

@@ -103,6 +103,62 @@ export class FirebaseUploadService extends UploadService {
 
   }
 
+  public uploadProfile(userId: string, upload: UploadModel): Promise<any>  {
+    const that = this;
+    const urlImagesNodeFirebase = '/profiles/' + userId + '/photo.jpg'
+    this.logger.debug('[FIREBASEUploadSERVICE] uploadProfile ', 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});
+
+      });
+    })
+
+  }
+
   public async delete(userId: string, path: string): Promise<any>{
     const that = this;
     const file_name_photo = 'photo.jpg';
@@ -133,6 +189,33 @@ export class FirebaseUploadService extends UploadService {
     })
   }
 
+  public async deleteProfile(userId: string, path: string): Promise<any>{
+    const that = this;
+    const file_name_photo = 'photo.jpg';
+    const file_name_thumb_photo = 'thumb_photo.jpg';
+
+    that.logger.debug('[FIREBASEUploadSERVICE] delete image for USER', userId, path);
+
+    // Create a root reference
+    const storageRef = firebase.storage().ref();
+    const ref = storageRef.child('profiles/' + userId + '/')
+    let arrayPromise = []
+    await ref.listAll().then((dir => {
+      dir.items.forEach(fileRef => arrayPromise.push(this.deleteFile(ref.fullPath, fileRef.name)));
+    })).catch(error => {
+      that.logger.error('[FIREBASEUploadSERVICE] delete: listAll error', error)
+    })
+
+    //AWAIT to return ALL the promise delete()
+    return new Promise((resolve, reject)=> {
+      Promise.all(arrayPromise).then(()=>{
+        resolve(true)
+      }).catch((error)=>{
+        reject(error)
+      })
+    })
+  }
+
   // // ------------------------------------
   // // Delete the file photo
   // // ------------------------------------

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

@@ -78,6 +78,30 @@ export class NativeUploadService extends UploadService {
         
     }
 
+    uploadProfile(userId: string, upload: UploadModel): Promise<any> {
+        this.logger.log('[NATIVE UPLOAD] - upload new photo profile  ... upload', upload)
+        const headers = new HttpHeaders({
+          Authorization: this.tiledeskToken,
+          // 'Content-Type': 'multipart/form-data',
+        });
+        const requestOptions = { headers: headers };
+        const formData = new FormData();
+        formData.append('file', upload.file);
+
+        // USE IMAGE API
+        const that = this;
+        const url = this.URL_TILEDESK_IMAGES + `/users/photo?force=true&user_id=${userId}`
+        return new Promise((resolve, reject) => {
+            that.http.put(url, formData, requestOptions).subscribe(data => {
+                const downloadURL = this.URL_TILEDESK_IMAGES + '?path=' + data['thumbnail'];
+                resolve(downloadURL)
+                // that.BSStateUpload.next({upload: upload});
+            }, (error) => {
+                reject(error)
+            });
+        });
+    }
+
     delete(userId: string, path: string): Promise<any>{
         this.logger.log('[NATIVE UPLOAD] - delete image ... upload', userId)
         const headers = new HttpHeaders({
@@ -99,4 +123,26 @@ export class NativeUploadService extends UploadService {
             });
         });
     }
+
+    deleteProfile(userId: string, path: string): Promise<any>{
+        this.logger.log('[NATIVE UPLOAD] - delete image ... upload', userId)
+        const headers = new HttpHeaders({
+            Authorization: this.tiledeskToken,
+            //'Content-Type': 'multipart/form-data',
+        });
+        const requestOptions = { headers: headers };
+
+        //USE IMAGE API
+        const that = this;
+        const url = this.URL_TILEDESK_IMAGES + '/users' + '?path=' + "uploads/users/"+ userId + "/images/photo.jpg"
+        return new Promise((resolve, reject) => {
+            that.http.delete(url, requestOptions).subscribe(data => {
+                // const downloadURL = this.URL_TILEDESK_IMAGES + '?path=' + data['filename'];
+                resolve(true)
+                // that.BSStateUpload.next({upload: upload});
+            }, (error) => {
+                reject(error)
+            });
+        });
+    }
 }