@chat21/chat21-ionic 2.0.13 → 3.0.5-9.2

package/src/app/pages/unassigned-conversations/unassigned-conversations.page.ts

@@ -0,0 +1,116 @@
+import { Component, Input, OnInit, SecurityContext } from '@angular/core';
+import { ModalController } from '@ionic/angular';
+import { NavProxyService } from 'src/app/services/nav-proxy.service';
+import { LoggerService } from 'src/chat21-core/providers/abstract/logger.service';
+import { LoggerInstance } from 'src/chat21-core/providers/logger/loggerInstance';
+import { DomSanitizer } from '@angular/platform-browser'
+import { CustomTranslateService } from 'src/chat21-core/providers/custom-translate.service';
+
+
+@Component({
+  selector: 'app-unassigned-conversations',
+  templateUrl: './unassigned-conversations.page.html',
+  styleUrls: ['./unassigned-conversations.page.scss'],
+})
+export class UnassignedConversationsPage implements OnInit {
+
+  @Input() unassigned_convs_url: any;
+  unassigned_convs_url_sanitized: any;
+  private logger: LoggerService = LoggerInstance.getInstance();
+  // has_loaded: boolean;
+  ion_content: any;
+  iframe: any;
+
+  isProjectsForPanel: boolean = false
+
+  public translationMap: Map<string, string>;
+  constructor(
+    private modalController: ModalController,
+    private navService: NavProxyService,
+    private sanitizer: DomSanitizer,
+    private translateService: CustomTranslateService,
+  ) { }
+
+  ngOnInit() {
+    const keys = ['UnassignedConversations', 'NewConversations'];
+    this.translationMap = this.translateService.translateLanguage(keys);
+    this.buildIFRAME();
+    this.listenToPostMsg();
+    this.hideHotjarFeedbackBtn();
+  }
+
+  hideHotjarFeedbackBtn() {
+    const hotjarFeedbackBtn = <HTMLElement>document.querySelector("#_hj_feedback_container > div > button")
+    if (hotjarFeedbackBtn) {
+      hotjarFeedbackBtn.style.display = "none";
+    }
+  }
+
+  buildIFRAME() {
+    this.logger.log('[UNASSIGNED-CONVS-PAGE] - UNASSIGNED CONVS URL (ngOnInit)', this.unassigned_convs_url);
+    this.unassigned_convs_url_sanitized = this.sanitizer.sanitize(SecurityContext.URL, this.unassigned_convs_url)
+    this.logger.log('[UNASSIGNED-CONVS-PAGE] - UNASSIGNED CONVS URL SANITIZED (ngOnInit)', this.unassigned_convs_url_sanitized);
+    // this.has_loaded = false
+
+    this.ion_content = document.getElementById("iframe-ion-content");
+    this.iframe = document.createElement("iframe");
+    this.iframe.src = this.unassigned_convs_url_sanitized;
+    this.iframe.width = "100%";
+    this.iframe.height = "99%";
+    this.iframe.id = "unassigned-convs-iframe"
+    this.iframe.frameBorder = "0";
+    this.iframe.style.border = "none";
+    this.iframe.style.background = "white";
+    this.ion_content.appendChild(this.iframe);
+
+    //  this.getIframeHaLoaded()
+  }
+
+  getIframeHaLoaded() {
+    var self = this;
+    var iframe = document.getElementById('unassigned-convs-iframe') as HTMLIFrameElement;;
+    this.logger.log('[APP-STORE-INSTALL] GET iframe ', iframe)
+    if (iframe) {
+      iframe.addEventListener("load", function () {
+        self.logger.log("[APP-STORE-INSTALL] GET - Finish");
+        let spinnerElem = <HTMLElement>document.querySelector('.stretchspinner-unassigned-convs')
+
+        self.logger.log('[APP-STORE-INSTALL] GET iframeDoc readyState spinnerElem', spinnerElem)
+        spinnerElem.classList.add("hide-stretchspinner")
+
+      });
+    }
+  }
+
+  listenToPostMsg() {
+    window.addEventListener("message", (event) => {
+      // console.log("[UNASSIGNED-CONVS-PAGE] message event ", event);
+
+      if (event && event.data) {
+        if (event.data === 'onInitProjectsForPanel') {
+          this.isProjectsForPanel = true;
+        }
+        if (event.data === 'onDestroyProjectsForPanel') {
+          this.isProjectsForPanel = false;
+        }
+      }
+    });
+  }
+
+
+  async onClose() {
+    this.logger.log('[UNASSIGNED-CONVS-PAGE] - onClose MODAL')
+    this.logger.log('[UNASSIGNED-CONVS-PAGE] - onClose MODAL isModalOpened ', await this.modalController.getTop())
+    const isModalOpened = await this.modalController.getTop();
+
+    if (isModalOpened) {
+      this.modalController.dismiss({
+
+        confirmed: true
+      });
+    } else {
+      this.navService.pop();
+    }
+  }
+
+}

package/src/app/services/app-config.ts

@@ -0,0 +1,107 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { environment } from '../../environments/environment';
+
+// Logger
+// import { LoggerService } from 'src/chat21-core/providers/abstract/logger.service';
+// import { LoggerInstance } from 'src/chat21-core/providers/logger/loggerInstance';
+
+@Injectable({ providedIn: 'root' })
+export class AppConfigProvider {
+  private appConfig: any;
+  // private logger: LoggerService = LoggerInstance.getInstance()
+
+  constructor(public http: HttpClient) {
+    this.appConfig = environment;
+    // console.log('AppConfigProvider constructor environment:: ', environment);
+  }
+
+  /** */
+  loadAppConfig() {
+    // const that = this;
+    // return this.http.get(this.appConfig.remoteConfigUrl).toPromise().then(data => {
+    //     that.appConfig = data;
+    //   }).catch(err => {
+    //     console.log('error loadAppConfig' + err);
+    //   });
+
+    // ---- new
+
+
+    return this.http.get(this.appConfig.remoteConfigUrl)
+      .toPromise().then((data: any ) => {
+        // console.log('AppConfigService loadAppConfig data: ', data);
+ 
+        const allconfig = data
+        // console.log('[APP-CONFIG-SERVICE] - loadAppConfig allconfig: ', allconfig);
+
+        if (allconfig.hasOwnProperty('wsUrlRel')) {
+
+          // console.log('[APP-CONFIG-SERVICE] - loadAppConfig allconfig !!!! exist wsUrlRel ->: ', allconfig.wsUrlRel);
+          var wsUrlRelIsEmpty = this.isEmpty(allconfig.wsUrlRel)
+          // console.log('[APP-CONFIG-SERVICE] - loadAppConfig allconfig !!!! exist wsUrlRel -> wsUrlRelIsEmpty ?', wsUrlRelIsEmpty);
+
+          if (wsUrlRelIsEmpty === false) {
+            // console.log('[APP-CONFIG-SERVICE]- loadAppConfig allconfig !!!! exist - SERVER_BASE_URL', data.apiUrl);
+
+            // if (allconfig.apiUrl.indexOf("http://") !== -1) {
+
+            //   const ws_url = allconfig.apiUrl.replace("http://", "ws://").slice(0, -1) + allconfig.wsUrlRel;
+            //   // console.log('AppConfigService loadAppConfig allconfig !!!! exist - SERVER_BASE_URL protocol is HTTP - wsUrl', ws_url);
+
+            //   allconfig.wsUrl = ws_url
+
+            // } else if (allconfig.apiUrl.indexOf("https://") !== -1) {
+
+            //   const ws_url = allconfig.apiUrl.replace("https://", "wss://").slice(0, -1) + allconfig.wsUrlRel;
+
+            //   allconfig.wsUrl = ws_url
+
+            //   // console.log('AppConfigService loadAppConfig allconfig !!!! exist - SERVER_BASE_URL protocol is HTTPS - wsUrl', ws_url);
+            // } else {
+            
+            
+              // console.log('AppConfigService loadAppConfig allconfig !!!! exist - SERVER_BASE_URL !!! IS RELATIVE - window.location ', window.location);
+
+              // console.log(window.location)
+
+              if (window.location.protocol === 'http:') {
+                allconfig.wsUrl = 'ws://' + window.location.hostname + allconfig.wsUrlRel
+
+              } else if (window.location.protocol === 'https:') {
+
+                allconfig.wsUrl = 'wss://' + window.location.hostname + allconfig.wsUrlRel
+              } else {
+
+                allconfig.wsUrl = 'ws://' + window.location.hostname + allconfig.wsUrlRel
+              }
+            // }
+
+          } else {
+            // console.log('[APP-CONFIG-SERVICE] loadAppConfig allconfig !!!! exist wsUrlRel but IS EMPTY');
+          }
+
+        } else {
+
+          // console.log('[APP-CONFIG-SERVICE] loadAppConfig allconfig !!!! does not exist wsUrlRel');
+        }
+
+        this.appConfig = allconfig;
+      
+
+      }).catch(err => {
+        console.error('error loadAppConfig' + err);
+      });
+  }
+
+  isEmpty(wsUrlRel: string) {
+    return (wsUrlRel === undefined || wsUrlRel == null || wsUrlRel.length <= 0) ? true : false;
+  }
+
+  /** */
+  getConfig() {
+    return this.appConfig;
+  }
+
+
+}

package/src/app/services/canned-responses/canned-responses.service.spec.ts

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

package/src/app/services/canned-responses/canned-responses.service.ts

@@ -0,0 +1,49 @@
+import { Injectable } from '@angular/core';
+import { AppConfigProvider } from '../app-config';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+
+// Logger
+import { LoggerService } from 'src/chat21-core/providers/abstract/logger.service';
+import { LoggerInstance } from 'src/chat21-core/providers/logger/loggerInstance';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CannedResponsesService {
+
+  private apiUrl: string;
+  private logger: LoggerService = LoggerInstance.getInstance();
+
+  constructor(
+    public http: HttpClient,
+    public appConfigProvider: AppConfigProvider
+  ) {
+   
+    this.logger.log('[CANNED-RESPONSES-SERVICE] HELLO !');
+    this.apiUrl = appConfigProvider.getConfig().apiUrl;
+    this.logger.log('[CANNED-RESPONSES-SERVICE] apiUrl ', this.apiUrl);
+  }
+
+
+  public getCannedResponses(token: string, projectid: string) {
+
+    const cannedResponsesURL = this.apiUrl + projectid + "/canned/";
+    this.logger.log('[CANNED-RESPONSES-SERVICE] getCannedResponses - URL ', cannedResponsesURL);
+
+    const httpOptions = {
+      headers: new HttpHeaders({
+        'Content-Type': 'application/json',
+        Authorization: token
+      })
+    };
+
+    return this.http
+      .get(cannedResponsesURL, httpOptions)
+      .pipe(map((res: any) => {
+        this.logger.log('[CANNED-RESPONSES-SERVICE] getCannedResponses - RES ', res);
+        return res
+      }))
+  }
+
+}

package/src/app/services/contacts/contacts.service.spec.ts

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

package/src/app/services/contacts/contacts.service.ts

@@ -0,0 +1,172 @@
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpHeaders, HttpErrorResponse } from '@angular/common/http';
+import { BehaviorSubject } from 'rxjs';
+
+// import {FIREBASESTORAGE_BASE_URL_IMAGE} from 'src/chat21-core/utils/constants'
+// models
+import { UserModel } from 'src/chat21-core/models/user';
+
+// utils
+import { avatarPlaceholder,  getColorBck} from 'src/chat21-core/utils/utils-user';
+import { AppConfigProvider } from '../app-config';
+import { map } from 'rxjs/operators';
+
+// Logger
+import { LoggerService } from 'src/chat21-core/providers/abstract/logger.service';
+import { LoggerInstance } from 'src/chat21-core/providers/logger/loggerInstance';
+
+@Injectable({
+  providedIn: 'root'
+})
+
+export class ContactsService {
+
+  // BehaviorSubjects
+  BScontacts: BehaviorSubject<UserModel[]> = new BehaviorSubject<UserModel[]>(null);
+  BScontactDetail: BehaviorSubject<UserModel> = new BehaviorSubject<UserModel>(null);
+
+  // private
+  private urlRemoteContacts: string;
+  private contacts: UserModel[];
+  private FIREBASESTORAGE_BASE_URL_IMAGE: string;
+  private urlStorageBucket: string;
+  private logger: LoggerService = LoggerInstance.getInstance();
+
+  constructor(
+    public http: HttpClient,
+    public appConfigProvider: AppConfigProvider
+  ) {
+    
+    this.urlRemoteContacts = appConfigProvider.getConfig().apiUrl + 'chat21/contacts';
+    this.FIREBASESTORAGE_BASE_URL_IMAGE = appConfigProvider.getConfig().baseImageUrl;
+    this.urlStorageBucket = appConfigProvider.getConfig().firebaseConfig.storageBucket + '/o/profiles%2F';
+
+  }
+
+
+  // initialize() {}
+
+  /** */
+  public loadContactsFromUrl(token: string) {
+    this.contacts = [];
+    this.logger.log('[CONTACT-SERVICE] loadContactsFromUrl token', token);
+    this.logger.log('[CONTACT-SERVICE] loadContactsFromUrl urlRemoteContacts', this.urlRemoteContacts)
+    // if (this.urlRemoteContacts.startsWith('http') && token) {
+    const that = this;
+    const httpOptions = {
+      headers: new HttpHeaders({
+        'Content-Type': 'application/json',
+        Authorization: token
+      })
+    };
+   
+ 
+    this.http.get<any[]>(this.urlRemoteContacts, httpOptions).subscribe(users => {
+      this.logger.log('[CONTACT-SERVICE] loadContactsFromUrl users ', users);
+      users.forEach(user => {
+        const member = that.createCompleteUser(user);
+        that.contacts.push(member);
+      });
+      localStorage.setItem('contacts', JSON.stringify(this.contacts));
+      this.BScontacts.next(this.contacts);
+    }, error => {
+      this.logger.error('[CONTACT-SERVICE] loadContactsFromUrl ERROR ', error);
+    });
+    // }
+  }
+
+
+
+  // public _loadContactDetail(token: string, uid: string) {
+  //   this.contacts = [];
+  //   console.log('loadContactDetail:: uid ', uid);
+  //   const urlRemoteContactDetail = this.urlRemoteContacts + '/' + uid;
+  //   if (urlRemoteContactDetail.startsWith('http') && token) {
+  //     const that = this;
+  //     const httpOptions = {
+  //       headers: new HttpHeaders({
+  //         'Content-Type': 'application/json',
+  //         Authorization: token
+  //       })
+  //     };
+  //     const postData = {
+  //     };
+  //     console.log('INFO-CONTENT-COMP (contact-service) loadContactDetail:: url ', urlRemoteContactDetail);
+  //     this.http
+  //       .get<any>(urlRemoteContactDetail, httpOptions)
+  //       .subscribe(user => {
+  //         console.log('INFO-CONTENT-COMP (contact-service) loadContactDetail:: data ', user);
+  //         const member = that.createCompleteUser(user);
+  //         this.BScontactDetail.next(member);
+  //       }, error => {
+  //         console.log('urlRemoreContactDetail:: error ', error);
+  //       });
+  //   }
+  // }
+
+  /**
+  * 
+  * @param token
+  * @param uid
+  */
+  public loadContactDetail(token: string, uid: string) {
+    this.contacts = [];
+    this.logger.log('[CONTACT-SERVICE] - loadContactDetail - uid ', uid);
+    this.logger.log('[CONTACT-SERVICE] - loadContactDetail - token ', token);
+    const urlRemoteContactDetail = this.urlRemoteContacts + '/' + uid;
+    // if (urlRemoteContactDetail.startsWith('http') && token) {
+
+      const httpOptions = {
+        headers: new HttpHeaders({
+          'Content-Type': 'application/json',
+          Authorization: token
+        })
+      };
+      // const postData = {};
+      this.logger.log('[CONTACT-SERVICE] - loadContactDetail  url ', urlRemoteContactDetail);
+      return this.http
+        .get(urlRemoteContactDetail, httpOptions)
+        .pipe(map((res: any) => {
+          this.logger.log('[CONTACT-SERVICE] - loadContactDetail - loadContactDetail RES ', res);
+          if (res.uid) {
+            let user = this.createCompleteUser(res)
+            return user
+          }
+        }))
+
+    // }
+  }
+
+
+  /**
+   * createCompleteUser
+   * @param user
+   */
+  private createCompleteUser(user: any): UserModel {
+    this.logger.log('[CONTACT-SERVICE] - createCompleteUser !!!  ');
+    const member = new UserModel(user.uid);
+    try {
+      const uid = user.uid;
+      const firstname = user.firstname ? user.firstname : '';
+      const lastname = user.lastname ? user.lastname : '';
+      const email = user.email ? user.email : '';
+      const fullname = (firstname + ' ' + lastname).trim();
+      const avatar = avatarPlaceholder(fullname);
+      const color = getColorBck(fullname);
+      // const imageurl = getImageUrlThumbFromFirebasestorage(user.uid, this.FIREBASESTORAGE_BASE_URL_IMAGE, this.urlStorageBucket);
+      member.uid = uid;
+      member.email = email;
+      member.firstname = firstname;
+      member.lastname = lastname;
+      member.fullname = fullname;
+      // member.imageurl = imageurl;
+      member.avatar = avatar;
+      member.color = color;
+      this.logger.log('CONTACT-SERVICE] - createCompleteUser member', member);
+    } catch (err) {
+      this.logger.error('CONTACT-SERVICE] - createCompleteUser - ERROR ' , err);
+    }
+    return member;
+  }
+
+}

package/src/app/services/events-service.ts

@@ -0,0 +1,79 @@
+import { Injectable } from '@angular/core';
+export type EventHandler = (...args: any[]) => any;
+@Injectable({
+  providedIn: 'root'
+})
+export class EventsService {
+  private c = new Map<string, EventHandler[]>();
+  constructor() {
+  //   console.warn(`[DEPRECATION][Events]: The Events provider is deprecated and it will be removed in the next major release.
+  // - Use "Observables" for a similar pub/sub architecture: https://angular.io/guide/observables
+  // - Use "Redux" for advanced state management: https://ngrx.io`);
+  }
+  /**
+   * Subscribe to an event topic. Events that get posted to that topic will trigger the provided handler.
+   *
+   * @param topic the topic to subscribe to
+   * @param handler the event handler
+   */
+  subscribe(topic: string, ...handlers: EventHandler[]) {
+    let topics = this.c.get(topic);
+    if (!topics) {
+      this.c.set(topic, topics = []);
+    }
+    topics.push(...handlers);
+  }
+
+  /**
+   * Unsubscribe from the given topic. Your handler will no longer receive events published to this topic.
+   *
+   * @param topic the topic to unsubscribe from
+   * @param handler the event handler
+   *
+   * @return true if a handler was removed
+   */
+  unsubscribe(topic: string, handler?: EventHandler): boolean {
+    if (!handler) {
+      return this.c.delete(topic);
+    }
+
+    const topics = this.c.get(topic);
+    if (!topics) {
+      return false;
+    }
+
+    // We need to find and remove a specific handler
+    const index = topics.indexOf(handler);
+
+    if (index < 0) {
+      // Wasn't found, wasn't removed
+      return false;
+    }
+    topics.splice(index, 1);
+    if (topics.length === 0) {
+      this.c.delete(topic);
+    }
+    return true;
+  }
+
+  /**
+   * Publish an event to the given topic.
+   *
+   * @param topic the topic to publish to
+   * @param eventData the data to send as the event
+   */
+  publish(topic: string, ...args: any[]): any[] | null {
+    const topics = this.c.get(topic);
+    if (!topics) {
+      return null;
+    }
+    return topics.map(handler => {
+      try {
+        return handler(...args);
+      } catch (e) {
+        console.error(e);
+        return null;
+      }
+    });
+  }
+}

package/src/app/services/nav-proxy.service.spec.ts

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

package/src/app/services/nav-proxy.service.ts

@@ -0,0 +1,80 @@
+import { Injectable } from '@angular/core';
+import { IonicModule, IonNav, IonRouterOutlet } from '@ionic/angular';
+import { Router, NavigationExtras } from '@angular/router';
+
+// utils
+import { checkPlatformIsMobile } from '../../chat21-core/utils/utils';
+// import { ConversationDetailPage } from '../pages/conversation-detail/conversation-detail.page';
+
+import { LoggerService } from 'src/chat21-core/providers/abstract/logger.service';
+import { LoggerInstance } from 'src/chat21-core/providers/logger/loggerInstance';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class NavProxyService {
+  public sidebarNav: IonNav = null;
+  public detailNav: IonRouterOutlet = null;
+  private logger: LoggerService = LoggerInstance.getInstance();
+
+  constructor(
+    public router: Router
+  ) { }
+
+  init(sidebarNav: IonNav, detailNav: IonRouterOutlet) {
+  
+    this.sidebarNav = sidebarNav;
+    this.detailNav = detailNav;
+    this.logger.log('[NAV-SERV] initialize sidebarNav', sidebarNav, ' detailNav', detailNav);
+  }
+
+  setRoot(page: any, navExtra: any) {
+    this.logger.log('[NAV-SERV] setRoot page', page, ' navExtra', navExtra);
+    this.sidebarNav.setRoot(page, navExtra);
+  }
+
+  pop() {
+    this.sidebarNav.pop();
+  }
+
+  push(page: any, navExtra: any) {
+    this.sidebarNav.push(page, navExtra);
+  }
+
+
+
+
+  openPage(pageName: string, page: any, navExtra?: NavigationExtras) {
+    this.logger.log('[NAV-SERV] openPage pageName:', pageName, ' page:', page, ' navExtra: ',  navExtra);
+    this.router.navigate([pageName], navExtra);
+  }
+
+
+    // !!!! SEEMS NOT USED
+    pushSidebar(page: any, pageName: string, navExtra?) {
+      this.logger.log('push2:', pageName, 'navExtra():', navExtra, 'this.sidebarNav', this.sidebarNav);
+      if (checkPlatformIsMobile()) {
+        this.router.navigate([pageName], navExtra);
+      } else {
+        this.sidebarNav.push(page, navExtra);
+      }
+    }
+  
+
+
+   // !!!! SEEMS NOT USED
+  closePage(pageName: string) {
+    this.logger.log('closePage:', pageName, 'checkPlatformIsMobile():', checkPlatformIsMobile());
+    if (checkPlatformIsMobile()) {
+      const navigationExtras: NavigationExtras = {
+        state: {
+          eventSelected: ''
+        }
+      };
+      this.router.navigate([pageName], navigationExtras);
+      // this.router.navigateByUrl(pageName);
+    } else {
+      this.pop();
+    }
+  }
+}

package/src/app/services/network-service/network.service.spec.ts

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