@chat21/chat21-web-widget 5.0.53-rc.4 → 5.0.53

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

@@ -28,7 +28,7 @@ import {
   conversationMessagesRef  
 } from '../../utils/utils';
 import { v4 as uuidv4 } from 'uuid';
-import { messageType, checkIfIsMemberJoinedGroup, hideInfoMessage, isJustRecived, isSender } from '../../utils/utils-message';
+import { messageType, checkIfIsMemberJoinedGroup, hideInfoMessage, isJustRecived } from '../../utils/utils-message';
 
 // @Injectable({ providedIn: 'root' })
 @Injectable()
@@ -187,6 +187,7 @@ export class FirebaseConversationHandler extends ConversationHandlerService {
                 type: typeMsg,
                 attributes: attributes,
                 channel_type: channelType
+                // isSender: true
             });
 
         // const message = new MessageModel(
@@ -309,7 +310,7 @@ export class FirebaseConversationHandler extends ConversationHandlerService {
         // }
         
         // verifico che il sender è il logged user
-        msg.isSender = isSender(msg.sender, this.loggedUser.uid);
+        msg.isSender = this.isSender(msg.sender, this.loggedUser.uid);
         //check if message contains only an emojii
         // msg.emoticon = isEmojii(msg.text)
 
@@ -334,7 +335,7 @@ export class FirebaseConversationHandler extends ConversationHandlerService {
         // }
         
         // verifico che il sender è il logged user
-        msg.isSender = isSender(msg.sender, this.loggedUser.uid);
+        msg.isSender = this.isSender(msg.sender, this.loggedUser.uid);
         //check if message contains only an emojii
         // msg.emoticon = isEmojii(msg.text)
 
@@ -452,91 +453,118 @@ export class FirebaseConversationHandler extends ConversationHandlerService {
         }
     }
 
-
-    unsubscribe(key: string) {
-        this.listSubsriptions.forEach(sub => {
-            this.logger.debug('[FIREBASEConversationHandlerSERVICE] unsubscribe: ', sub.uid, key);
-            if (sub.uid === key) {
-                this.logger.debug('[FIREBASEConversationHandlerSERVICE] unsubscribe: ', sub.uid, key);
-                sub.unsubscribe(key, null);
-                return;
+    /**
+     * controllo se il messaggio è stato inviato da loggerUser
+     * richiamato dalla pagina elenco messaggi della conversazione
+     */
+    private isSender(sender: string, currentUserId: string) {
+        if (currentUserId) {
+            if (sender === currentUserId) {
+                return true;
+            } else {
+                return false;
             }
-        });
+        } else {
+            return false;
+        }
     }
 
 
-    private addCommandMessage(msg: MessageModel){
-        const that = this;
-        const commands = msg.attributes.commands;
-        let i=0;
-        function execute(command){
-            if(command.type === "message"){
-                that.logger.debug('[FIREBASEConversationHandlerSERVICE] addCommandMessage --> type="message"', command, i)
-                if (i >= 2) {
-                    
-                    //check if previus wait message type has time value, otherwize set to 1000ms
-                    !commands[i-1].time? commands[i-1].time= 1000 : commands[i-1].time
-                    command.message.timestamp = commands[i-2].message.timestamp + commands[i-1].time;
-                    
-                    /** CHECK IF MESSAGE IS JUST RECEIVED: IF false, set next message time (if object exist) to 0 -> this allow to show it immediately */
-                    if(!isJustRecived(that.startTime.getTime(), msg.timestamp)){
-                        let previewsTimeMsg = msg.timestamp;
-                        commands[i-2]? previewsTimeMsg = commands[i-2].message.timestamp : null;
-                        command.message.timestamp = previewsTimeMsg + 100
-                        commands[i+1]? commands[i+1].time = 0 : null
-                    }
-                } else { /**MANAGE FIRST MESSAGE */
-                    command.message.timestamp = msg.timestamp;
-                    if(!isJustRecived(that.startTime.getTime(), msg.timestamp)){
-                        commands[i+1]? commands[i+1].time = 0 : null
-                    }
+    /** */
+    // updateMetadataMessage(uid: string, metadata: any) {
+    //     metadata.status = true;
+    //     const message = {
+    //         metadata: metadata
+    //     };
+    //     const firebaseMessages = firebase.database().ref(this.urlNodeFirebase + uid);
+    //     firebaseMessages.set(message);
+    // }
+
+
+  unsubscribe(key: string) {
+    this.listSubsriptions.forEach(sub => {
+        this.logger.debug('[FIREBASEConversationHandlerSERVICE] unsubscribe: ', sub.uid, key);
+        if (sub.uid === key) {
+            this.logger.debug('[FIREBASEConversationHandlerSERVICE] unsubscribe: ', sub.uid, key);
+            sub.unsubscribe(key, null);
+            return;
+        }
+    });
+  }
+
+
+private addCommandMessage(msg: MessageModel){
+    const that = this;
+    const commands = msg.attributes.commands;
+    let i=0;
+    function execute(command){
+        if(command.type === "message"){
+            that.logger.debug('[FIREBASEConversationHandlerSERVICE] addCommandMessage --> type="message"', command, i)
+            if (i >= 2) {
+                
+                //check if previus wait message type has time value, otherwize set to 1000ms
+                !commands[i-1].time? commands[i-1].time= 1000 : commands[i-1].time
+                command.message.timestamp = commands[i-2].message.timestamp + commands[i-1].time;
+                
+                /** CHECK IF MESSAGE IS JUST RECEIVED: IF false, set next message time (if object exist) to 0 -> this allow to show it immediately */
+                if(!isJustRecived(that.startTime.getTime(), msg.timestamp)){
+                    let previewsTimeMsg = msg.timestamp;
+                    commands[i-2]? previewsTimeMsg = commands[i-2].message.timestamp : null;
+                    command.message.timestamp = previewsTimeMsg + 100
+                    commands[i+1]? commands[i+1].time = 0 : null
+                }
+            } else { /**MANAGE FIRST MESSAGE */
+                command.message.timestamp = msg.timestamp;
+                if(!isJustRecived(that.startTime.getTime(), msg.timestamp)){
+                    commands[i+1]? commands[i+1].time = 0 : null
+                }
+            }
+            that.generateMessageObject(msg, command.message, function () {
+                i += 1
+                if (i < commands.length) {
+                    execute(commands[i])
                 }
-                that.generateMessageObject(msg, command.message, function () {
-                    i += 1
-                    if (i < commands.length) {
-                        execute(commands[i])
-                    }
-                    else {
-                        that.logger.debug('[FIREBASEConversationHandlerSERVICE] addCommandMessage --> last command executed (wait), exit') 
-                    }
-                })
-            }else if(command.type === "wait"){
-                that.logger.debug('[FIREBASEConversationHandlerSERVICE] addCommandMessage --> type="wait"', command, i, commands.length)
-                //publish waiting event to simulate user typing
-                if(isJustRecived(that.startTime.getTime(), msg.timestamp)){
-                    that.messageWait.next({uid: that.conversationWith, uidUserTypingNow: msg.sender, nameUserTypingNow: msg.sender_fullname, waitTime: command.time, command: command})
+                else {
+                    that.logger.debug('[FIREBASEConversationHandlerSERVICE] addCommandMessage --> last command executed (wait), exit') 
                 }
-                setTimeout(function() {
-                    i += 1
-                    if (i < commands.length) {
-                        execute(commands[i])
-                    }
-                    else {
-                        that.logger.debug('[FIREBASEConversationHandlerSERVICE] addCommandMessage --> last command executed (send message), exit') 
-                    }
-                },command.time)
+            })
+        }else if(command.type === "wait"){
+            that.logger.debug('[FIREBASEConversationHandlerSERVICE] addCommandMessage --> type="wait"', command, i, commands.length)
+            //publish waiting event to simulate user typing
+            if(isJustRecived(that.startTime.getTime(), msg.timestamp)){
+                that.messageWait.next({uid: that.conversationWith, uidUserTypingNow: msg.sender, nameUserTypingNow: msg.sender_fullname, waitTime: command.time, command: command})
             }
+            setTimeout(function() {
+                i += 1
+                if (i < commands.length) {
+                    execute(commands[i])
+                }
+                else {
+                    that.logger.debug('[FIREBASEConversationHandlerSERVICE] addCommandMessage --> last command executed (send message), exit') 
+                }
+            },command.time)
         }
-        execute(commands[0]) //START render first message
     }
+    execute(commands[0]) //START render first message
+}
 
-    private generateMessageObject(message, command_message, callback) {
-        let parentUid = message.uid
-        command_message.uid = uuidv4();
-        if(command_message.text) command_message.text = command_message.text.trim()//remove black msg with only spaces
-        command_message.language = message.language;
-        command_message.recipient = message.recipient;
-        command_message.recipient_fullname = message.recipient_fullname;
-        command_message.sender = message.sender;
-        command_message.sender_fullname = message.sender_fullname;
-        command_message.channel_type = message.channel_type;
-        command_message.status = message.status;
-        command_message.isSender = message.isSender;
-        command_message.attributes? command_message.attributes.commands = true : command_message.attributes = {commands : true}
-        command_message.attributes.parentUid = parentUid //added to manage message STATUS UPDATES
-        this.addedNew(command_message)
-        callback();
-    }
+private generateMessageObject(message, command_message, callback) {
+    let parentUid = message.uid
+    command_message.uid = uuidv4();
+    if(command_message.text) command_message.text = command_message.text.trim()//remove black msg with only spaces
+    command_message.language = message.language;
+    command_message.recipient = message.recipient;
+    command_message.recipient_fullname = message.recipient_fullname;
+    command_message.sender = message.sender;
+    command_message.sender_fullname = message.sender_fullname;
+    command_message.channel_type = message.channel_type;
+    command_message.status = message.status;
+    command_message.isSender = message.isSender;
+    command_message.attributes? command_message.attributes.commands = true : command_message.attributes = {commands : true}
+    command_message.attributes.parentUid = parentUid //added to manage message STATUS UPDATES
+    this.addedNew(command_message)
+    callback();
+}
 
 
     private isValidMessage(msgToCkeck:MessageModel): boolean{

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

@@ -180,8 +180,4 @@ export class FirebasePresenceService extends PresenceService {
     return connectionsRef;
   }
 
-  public imHere(){
-    //NOT IMPLEMENTED FOR FIREBASE ENGINE
-  }
-
 }

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

@@ -24,7 +24,7 @@ import {
   conversationMessagesRef
 } from '../../utils/utils';
 import { v4 as uuidv4 } from 'uuid';
-import { messageType, checkIfIsMemberJoinedGroup, hideInfoMessage, isJustRecived, isSender } from '../../utils/utils-message';
+import { messageType, checkIfIsMemberJoinedGroup, hideInfoMessage, isJustRecived } from '../../utils/utils-message';
 
 
 // @Injectable({ providedIn: 'root' })
@@ -308,7 +308,7 @@ export class MQTTConversationHandler extends ConversationHandlerService {
         // }
         // verifico che il sender è il logged user
         this.logger.log("[MQTTConversationHandlerSERVICE] ****>msg.sender:" + msg.sender);
-        msg.isSender = isSender(msg.sender, this.loggedUser.uid);
+        msg.isSender = this.isSender(msg.sender, this.loggedUser.uid);
         // traduco messaggi se sono del server
         if (messageType(MESSAGE_TYPE_INFO, msg)) {
             this.translateInfoSupportMessages(msg);
@@ -420,6 +420,33 @@ export class MQTTConversationHandler extends ConversationHandlerService {
         }
     }
 
+    /**
+     * controllo se il messaggio è stato inviato da loggerUser
+     * richiamato dalla pagina elenco messaggi della conversazione
+     */
+    private isSender(sender: string, currentUserId: string) {
+        if (currentUserId) {
+            if (sender === currentUserId) {
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+
+
+    /** */
+    // updateMetadataMessage(uid: string, metadata: any) {
+    //     metadata.status = true;
+    //     const message = {
+    //         metadata: metadata
+    //     };
+    //     const firebaseMessages = firebase.database().ref(this.urlNodeFirebase + uid);
+    //     firebaseMessages.set(message);
+    // }
+
 
     unsubscribe(key: string) {
         this.logger.log('[MQTTConversationHandlerSERVICE] unsubscribe: ', key);

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

@@ -1,4 +1,3 @@
-import { Chat21Service } from 'src/chat21-core/providers/mqtt/chat-service';
 import { Injectable } from '@angular/core';
 import { BehaviorSubject, Observable } from 'rxjs';
 
@@ -20,7 +19,6 @@ import { LoggerInstance } from '../logger/loggerInstance';
 // @Injectable({ providedIn: 'root' })
 @Injectable()
 export class MQTTPresenceService extends PresenceService {
-  
 
   // BehaviorSubject
   BSIsOnline: BehaviorSubject<any> = new BehaviorSubject<any>(null);
@@ -32,7 +30,7 @@ export class MQTTPresenceService extends PresenceService {
   private logger: LoggerService = LoggerInstance.getInstance();
 
   constructor(
-    public chat21Service: Chat21Service
+    // private events: EventsService
   ) {
     super();
   }
@@ -49,11 +47,40 @@ export class MQTTPresenceService extends PresenceService {
   }
 
   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.');
+    //     }
+    //   }
+    // });
   }
 
   /**
@@ -61,14 +88,130 @@ export class MQTTPresenceService extends PresenceService {
    * richiamato prima del logout
    */
   public removePresence(): void {
-
-  }
-
-  public imHere(): void {
-    this.logger.debug('[MQTT-PRESENCE] imHere', this.tenant);
-    setTimeout(() => {
-      this.chat21Service.chatClient.ImHere()
-    }, 2000);
+    // 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/tiledesk/tiledesk-requests.service.ts

@@ -1,6 +1,5 @@
 import { HttpClient, HttpHeaders } from '@angular/common/http';
 import { Injectable } from '@angular/core';
-import { map } from 'rxjs/operators';
 import { AppStorageService } from '../abstract/app-storage.service';
 import { LoggerService } from '../abstract/logger.service';
 import { LoggerInstance } from '../logger/loggerInstance';
@@ -12,7 +11,7 @@ export class TiledeskRequestsService {
   public SERVER_BASE_URL: string;
 
   // private
-  private URL_TILEDESK_REQUEST: string;
+  private URL_TILEDESK_CLOSE_REQUEST: string;
   private tiledeskToken: string;
 
   private logger: LoggerService = LoggerInstance.getInstance()
@@ -25,7 +24,7 @@ export class TiledeskRequestsService {
   initialize(serverBaseUrl: string, projectId: string,) {
     this.logger.debug('[TILEDESK-REQUEST-SERV] - initialize', projectId);
     this.SERVER_BASE_URL = serverBaseUrl;
-    this.URL_TILEDESK_REQUEST = this.SERVER_BASE_URL + projectId +'/requests/';
+    this.URL_TILEDESK_CLOSE_REQUEST = this.SERVER_BASE_URL + projectId +'/requests/';
   }
 
 
@@ -38,8 +37,8 @@ export class TiledeskRequestsService {
       Authorization: this.tiledeskToken,
     });
     const requestOptions = { headers: headers };
-    
-    const url = this.URL_TILEDESK_REQUEST + supportgroupid + '/closeg'
+    const that = this;
+    const url = this.URL_TILEDESK_CLOSE_REQUEST + supportgroupid + '/closeg'
     return new Promise((resolve, reject) => {
       this.logger.debug('[TILEDESK-REQUEST-SERV] - closeSupportGroup URLLLL', url, requestOptions);
       this.http.put(url, null, requestOptions).subscribe((data) => {
@@ -50,20 +49,4 @@ export class TiledeskRequestsService {
       });
     });
   }
-
-  public sendMessageToRequest(request_id: string, token: string, message: any): Promise<any> {
-    const url = this.URL_TILEDESK_REQUEST + request_id + '/messages'
-    this.logger.log('[TILEDESK-SERVICE] - SEND MESSAGE TO A REQUEST url ', url);
-    const httpOptions = {
-      headers: new HttpHeaders({
-        'Content-Type': 'application/json',
-        Authorization: token
-      })
-    };
-    const body = message;
-    return this.http.post(url, body, httpOptions).toPromise().then(res => {
-      this.logger.log('[TILEDESK-SERVICE] - SEND MESSAGE TO A REQUEST res ', res);
-      return res
-    })
-  }
 }

package/src/chat21-core/utils/utils-message.ts

@@ -1,7 +1,3 @@
-import { convertMessage } from 'src/app/utils/utils';
-import { MessageModel } from './../models/message';
-import { ConversationModel } from './../models/conversation';
-import { v4 as uuidv4 } from 'uuid';
 import {
     MESSAGE_TYPE_INFO,
     MESSAGE_TYPE_MINE,
@@ -73,18 +69,6 @@ export function isMine(message: any) {
     return false;
 }
 
-export function isSender(sender: string, currentUserId: string) {
-  if (currentUserId) {
-      if (sender === currentUserId) {
-          return true;
-      } else {
-          return false;
-      }
-  } else {
-      return false;
-  }
-}
-
 /** */
 export function messageType(msgType: string, message: any) {
 
@@ -193,23 +177,3 @@ export function hideInfoMessage(msg, infoMessageKeyEnabled): boolean{
   }
   return true
 }
-
-
-export function conversationToMessage(conversation: ConversationModel, currentUserId: string): MessageModel{
-  let message: any = {}
-  message.uid = conversation['message_id']? conversation['message_id'] : uuidv4()
-  message.text = conversation.text? conversation.text.trim(): conversation.last_message_text.trim()
-  message.sender = conversation.sender
-  message.sender_fullname = conversation.sender_fullname
-  message.recipient = conversation.recipient
-  message.recipient_fullname = conversation.recipient_fullname
-  message.status = +conversation.status
-  message.timestamp = conversation.timestamp
-  message.metadata = conversation['metadata']
-  message.channel_type = conversation.channel_type
-  message.type = conversation.type
-  message.isSender = isSender(message.sender, currentUserId)
-  message.attributes = conversation.attributes
-
-  return message as MessageModel
-}

package/src/iframe-style.css

@@ -69,8 +69,8 @@
     max-width: 400px;
 }
 #tiledesk-container.closed #tiledeskdiv.messagePreview {
-    width: 375px; /*340px*/
-    height: 400px; /*300px*/
+    width: 340px;
+    height: 300px;
     min-width: 340px;
 }
 

package/src/models/project.ts

@@ -1,5 +1,3 @@
-import { IRules } from './rule';
-
 export class ProjectModel {
     constructor(
         public id?: string,
@@ -24,7 +22,6 @@ export class ProjectModel {
         public color?: string,
         public welcomeTitle?: string,
         public welcomeMsg?: string,
-        public attributes?: IRules
     ) { }
 
     initialize (
@@ -43,7 +40,7 @@ export class ProjectModel {
         trialDaysLeft?: number,
         trialExpired?: boolean,
         updatedAt?: string,
-        versions?: string,
+        versions?: string
     ) {
         this.id = id;
         this.activeOperatingHours = activeOperatingHours;

package/src/app/providers/events.service.spec.ts

@@ -1,16 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-
-import { EventsService } from './events.service';
-
-describe('EventsService', () => {
-  let service: EventsService;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({});
-    service = TestBed.inject(EventsService);
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-});