@chat21/chat21-ionic 2.0.13 → 3.0.5-9.2

package/src/app/components/project-item/project-item.component.ts

@@ -0,0 +1,350 @@
+import { Component, EventEmitter, HostListener, OnInit, Output } from '@angular/core';
+import { WebsocketService } from 'src/app/services/websocket/websocket.service';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { AppStorageService } from 'src/chat21-core/providers/abstract/app-storage.service';
+import { LoggerService } from 'src/chat21-core/providers/abstract/logger.service';
+import { LoggerInstance } from 'src/chat21-core/providers/logger/loggerInstance';
+import { CustomTranslateService } from 'src/chat21-core/providers/custom-translate.service';
+import { TiledeskAuthService } from 'src/chat21-core/providers/tiledesk/tiledesk-auth.service';
+import { TiledeskService } from 'src/app/services/tiledesk/tiledesk.service';
+import { WebSocketJs } from 'src/app/services/websocket/websocket-js';
+import { AppConfigProvider } from 'src/app/services/app-config';
+
+@Component({
+  selector: 'app-project-item',
+  templateUrl: './project-item.component.html',
+  styleUrls: ['./project-item.component.scss'],
+})
+export class ProjectItemComponent implements OnInit {
+  @Output() projectIdEvent = new EventEmitter<string>()
+
+  private unsubscribe$: Subject<any> = new Subject<any>();
+  project: any;
+  tiledeskToken: string;
+
+  unservedRequestCount: number = 0;
+  currentUserRequestCount: number;
+  ROLE_IS_AGENT: boolean;
+  currentUserId: string;
+  public translationMap: Map<string, string>;
+  private logger: LoggerService = LoggerInstance.getInstance();
+  window_width_is_60: boolean;
+  newInnerWidth: any;
+
+  constructor(
+    public wsService: WebsocketService,
+    public appStorageService: AppStorageService,
+    private translateService: CustomTranslateService,
+    public tiledeskAuthService: TiledeskAuthService,
+    public tiledeskService: TiledeskService,
+    public webSocketJs: WebSocketJs,
+    private appConfigProvider: AppConfigProvider,
+  ) { }
+
+  ngOnInit() {
+    this.getStoredTokenAndConnectWS();
+    this.getStoredCurrenUser();
+    this.translations();
+    this.listenToPostMsgs();
+    this.onInitWindowWidth();
+    // console.log('[PROJECT-ITEM] - on INIT')
+  }
+
+  getStoredTokenAndConnectWS() {
+    this.tiledeskToken = this.appStorageService.getItem('tiledeskToken');
+    this.logger.log('[PROJECT-ITEM] - STORED TILEDEK TOKEN ', this.tiledeskToken)
+    this.connetWebsocket( this.tiledeskToken) 
+  }
+
+  connetWebsocket(tiledeskToken) {
+   
+    this.logger.log('[WEBSOCKET-JS] connetWebsocket called in [PROJECT-ITEM] tiledeskToken ',tiledeskToken)
+    const appconfig = this.appConfigProvider.getConfig();
+    this.logger.log('[WEBSOCKET-JS] connetWebsocket called in [PROJECT-ITEM] wsUrl ', appconfig.wsUrl)
+    const WS_URL = appconfig.wsUrl + '?token=' + tiledeskToken
+    this.logger.log('[WEBSOCKET-JS] connetWebsocket called in [PROJECT-ITEM] wsUrl ', WS_URL)
+    this.webSocketJs.init(
+      WS_URL,
+      undefined,
+      undefined,
+      undefined
+    );
+
+    this.getLastProjectStoredAndSubscToWSAvailabilityAndConversations();
+  }
+
+  listenToPostMsgs() {
+    window.addEventListener("message", (event) => {
+      // console.log("[PROJECT-ITEM] post message event ", event);
+
+      if (event && event.data && event.data) {
+        // console.log("[PROJECT-ITEM] message event data  ", event.data);
+        if (event.data === 'hasChangedProject') {
+          this.unservedRequestCount = 0;
+          if (this.project) {
+            this.webSocketJs.unsubscribe('/' + this.project.id_project._id + '/requests');  
+          }
+          this.getLastProjectStoredAndSubscToWSAvailabilityAndConversations();
+          
+        }
+      }
+    })
+  }
+
+  public translations() {
+    const keys = [
+      'Available',
+      'Unavailable',
+      'Busy'
+    ];
+    this.translationMap = this.translateService.translateLanguage(keys);
+  }
+
+  @HostListener('window:resize', ['$event'])
+  onResize(event: any) {
+    this.newInnerWidth = event.target.innerWidth;
+    this.logger.log('[PROJECT-ITEM] - INNER WIDTH ', this.newInnerWidth)
+
+    // if (this.newInnerWidth <= 150) {
+    //   this.window_width_is_60 = true;
+    // } else {
+    //   this.window_width_is_60 = false;
+    // }
+  }
+
+  onInitWindowWidth(): any {
+    const actualWidth = window.innerWidth;
+    this.logger.log('[PROJECT-ITEM] - ACTUAL Width ', actualWidth);
+
+
+   
+    // if (actualWidth <= 150) {
+    //   this.window_width_is_60 = true;
+    // } else {
+    //   this.window_width_is_60 = false;
+    // }
+  }
+
+
+
+ 
+
+  getStoredCurrenUser() {
+    const storedCurrentUser = this.appStorageService.getItem('currentUser');
+    this.logger.log('[PROJECT-ITEM] - STORED CURRENT USER ', storedCurrentUser)
+    if (storedCurrentUser) {
+      const currentUser = JSON.parse(storedCurrentUser)
+      this.logger.log('[PROJECT-ITEM] - STORED CURRENT USER OBJCT', currentUser);
+      this.currentUserId = currentUser.uid
+      this.logger.log('[PROJECT-ITEM] - CURRENT USER ID', this.currentUserId);
+    }
+  }
+
+  getLastProjectStoredAndSubscToWSAvailabilityAndConversations() {
+    let stored_project = ''
+    try {
+      stored_project = localStorage.getItem('last_project')
+      this.logger.log('PROJECT-ITEM - THERE IS A STORED PROJECT ', stored_project)
+    } catch (err) {
+      this.logger.error('Get local storage LAST PROJECT ', err)
+    }
+
+
+    if (!stored_project) {
+      this.logger.log('PROJECT-ITEM - THERE IS NOT STORED LAST PROJECT ', stored_project)
+      const tiledeskToken = this.appStorageService.getItem('tiledeskToken');
+      this.logger.log('[PROJECT-ITEM] - GET PROJECTS - tiledeskToken', tiledeskToken);
+      this.tiledeskService.getProjects(tiledeskToken).subscribe(projects => {
+        this.logger.log('[PROJECT-ITEM - GET PROJECTS - RES', projects);
+
+        this.logger.log('[INFO-CONTENT-COMP] - GET PROJECTS - RES this.project', this.project);
+
+        localStorage.setItem('last_project', JSON.stringify(projects[0]))
+        if (projects[0]) {
+          this.project = projects[0];
+          this.doProjectSubscriptions(this.project)
+        }
+
+      }, (error) => {
+        this.logger.error('[PROJECT-ITEM] - GET PROJECTS - ERROR  ', error);
+
+      }, () => {
+        this.logger.log('[INFO-CONTENT-COMP] - GET PROJECTS * COMPLETE *');
+
+      });
+    }
+
+
+    if (stored_project) {
+      this.logger.log('PROJECT-ITEM - THERE IS STORED LAST PROJECT ', stored_project)
+      if (stored_project) {
+        this.project = JSON.parse(stored_project)
+      }
+      this.doProjectSubscriptions(this.project)
+      this.logger.log('[PROJECT-ITEM] - LAST PROJECT PARSED ', this.project)
+    }
+
+
+  }
+
+  doProjectSubscriptions(project) {
+    this.logger.log('[PROJECT-ITEM] doProjectSubscriptions project ', project)
+    if (project) {
+      const user_role = this.project.role
+      this.logger.log('[PROJECT-ITEM] - user_role ', user_role)
+      this.projectIdEvent.emit(project.id_project._id)
+
+
+      if (user_role === 'agent') {
+        this.ROLE_IS_AGENT = true;
+
+      } else {
+        this.ROLE_IS_AGENT = false;
+      }
+
+
+      this.logger.log('[PROJECT-ITEM] - LAST PROJECT PARSED > user_role ', user_role)
+      this.wsService.subscriptionToWsCurrentProjectUserAvailability(project.id_project._id, this.project._id);
+      this.listenTocurrentProjectUserUserAvailability$(project)
+
+      this.wsService.subscriptionToWsConversations(project.id_project._id)
+      // this.updateCurrentUserRequestCount();
+      this.updateUnservedRequestCount();
+
+    }
+  }
+
+  listenTocurrentProjectUserUserAvailability$(project) {
+    this.wsService.currentProjectUserAvailability$
+      .pipe(
+        takeUntil(this.unsubscribe$)
+      )
+      .subscribe((projectUser) => {
+        this.logger.log('[PROJECT-ITEM] - $UBSC TO WS USER AVAILABILITY & BUSY STATUS RES ', projectUser);
+
+        if (project.id_project._id === projectUser['id_project']) {
+          project['ws_projct_user_available'] = projectUser['user_available'];
+          project['ws_projct_user_isBusy'] = projectUser['isBusy']
+        }
+
+      }, (error) => {
+        this.logger.error('[PROJECT-ITEM] - $UBSC TO WS USER AVAILABILITY & BUSY STATUS error ', error);
+      }, () => {
+        this.logger.log('[PROJECT-ITEM] - $UBSC TO WS USER AVAILABILITY & BUSY STATUS * COMPLETE *');
+      })
+  }
+
+  changeAvailabilityState(projectid, available) {
+    this.logger.log('[PROJECT-ITEM] - changeAvailabilityState projectid', projectid, ' available: ', available);
+
+    available = !available
+    this.logger.log('[PROJECT-ITEM] - changeAvailabilityState projectid', projectid, ' available: ', available);
+
+    this.wsService.updateCurrentUserAvailability(this.tiledeskToken, projectid, available)
+      .subscribe((projectUser: any) => {
+
+        this.logger.log('[PROJECT-ITEM] - PROJECT-USER UPDATED ', projectUser)
+
+        // NOTIFY TO THE USER SERVICE WHEN THE AVAILABLE / UNAVAILABLE BUTTON IS CLICKED
+        // this.usersService.availability_btn_clicked(true)
+
+        if (this.project['id_project']._id === projectUser.id_project) {
+          this.project['ws_projct_user_available'] = projectUser.user_available;
+          // this.project['ws_projct_user_isBusy'] = projectUser['isBusy']
+        }
+
+      }, (error) => {
+        this.logger.error('[PROJECT-ITEM] - PROJECT-USER UPDATED - ERROR  ', error);
+
+      }, () => {
+        this.logger.log('[PROJECT-ITEM] - PROJECT-USER UPDATED  * COMPLETE *');
+
+      });
+  }
+
+  updateUnservedRequestCount() {
+    // console.log('[PROJECT-ITEM] updateUnservedRequestCount ')
+    // this.requestsService.requestsList_bs.subscribe((requests) => {
+    this.wsService.wsRequestsList$
+      .subscribe((requests) => {
+        // console.log('[PROJECT-ITEM] requests ', requests)
+        if (requests) {
+          let count = 0;
+          requests.forEach(r => {
+            // this.logger.log('NAVBAR - UPDATE-UNSERVED-REQUEST-COUNT request agents', r.agents)
+            // *bug fix: when the user is an agent also for the unserved we have to consider if he is present in agents
+            // && this.ROLE_IS_AGENT === true
+            if (r['status'] === 100 ) {
+              if (this.hasmeInAgents(r['agents']) === true) {
+                count = count + 1;
+              }
+            }
+            // if (r['status'] === 100 && this.ROLE_IS_AGENT === false) {
+            //   count = count + 1;
+            // }
+          });
+          this.unservedRequestCount = count;
+          // console.log('[PROJECT-ITEM] UNSERVED REQUEST COUNT - RES ', this.unservedRequestCount)
+        }
+      }, error => {
+        this.logger.error('[PROJECT-ITEM] UNSERVED REQUEST COUNT * error * ', error)
+      }, () => {
+        this.logger.log('[PROJECT-ITEM] UNSERVED REQUEST COUNT */* COMPLETE */*')
+      })
+  }
+
+  hasmeInAgents(agents) {
+    if (agents) {
+      for (let j = 0; j < agents.length; j++) {
+        // this.logger.log('[PROJECT-ITEM] hasmeInAgents currentUserId  ', this.currentUserId)
+        // this.logger.log('[PROJECT-ITEM] hasmeInAgents agent  ', agents[j].id_user)
+        if (this.currentUserId === agents[j].id_user) {
+          // this.logger.log('[PROJECT-ITEM] hasmeInAgents ')
+          return true
+        }
+      }
+    } else {
+      this.logger.log('[PROJECT-ITEM] hasmeInAgents OOPS!!! AGENTS THERE ARE NOT ')
+    }
+  }
+
+  updateCurrentUserRequestCount() {
+    // this.requestsService.requestsList_bs.subscribe((requests) => {
+    this.wsService.wsRequestsList$
+      .pipe(
+        takeUntil(this.unsubscribe$)
+      )
+      .subscribe((requests) => {
+        if (requests) {
+          let count = 0;
+          requests.forEach(r => {
+
+            // const membersArray = Object.keys(r.members);
+            const participantsArray = r['participants'] // new used with ws 
+            // this.logger.log('[NAVBAR] »» WIDGET updateCurrentUserRequestCount REQUEST currentUserRequestCount membersArray ', membersArray);
+
+            // const currentUserIsInParticipants = membersArray.includes(this.user._id);
+            const currentUserIsInParticipants = participantsArray.includes(this.currentUserId); // new used with ws 
+
+            // this.logger.log('[NAVBAR] »» WIDGET updateCurrentUserRequestCount REQUEST currentUserRequestCount currentUserIsInParticipants ', currentUserIsInParticipants);
+            if (currentUserIsInParticipants === true) {
+              count = count + 1;
+            }
+          });
+          this.currentUserRequestCount = count;
+          this.logger.log('[PROJECT-ITEM] CURRENT USER REQUEST COUNT - RES', this.currentUserRequestCount);
+        }
+      }, error => {
+        this.logger.error('[PROJECT-ITEM] CURRENT USER REQUEST COUNT * error * ', error)
+      }, () => {
+        this.logger.log('[PROJECT-ITEM] CURRENT USER REQUEST COUNT */* COMPLETE */*')
+      })
+
+  }
+
+
+
+}
+
+

package/src/app/components/utils/avatar-profile/avatar-profile.component.html

@@ -0,0 +1,12 @@
+<!-- <div *ngIf="itemAvatar" class="avatar-circle" [style.width]="itemAvatar.width" [style.height]="itemAvatar.height">
+
+  <div class="avatar avatar-placeholder" [ngStyle]="{'background':  'linear-gradient(rgb(255,255,255) -125%,' + color + ')'}" [innerHTML]="avatar" ></div>
+ 
+  <div *ngIf="avatarUrl" class="avatar avatar-image" [style.background-image]="'url(' + avatarUrl + ')'" ></div>    
+</div> -->
+
+<div *ngIf="itemAvatar" class="avatar-circle" [style.width]="itemAvatar.width" [style.height]="itemAvatar.height">
+  <!-- [style.background-color]="itemAvatar.color" -->
+  <div class="avatar avatar-placeholder" [ngStyle]="{'background':  'linear-gradient(rgb(255,255,255) -125%,' + itemAvatar.color + ')'}" [innerHTML]="itemAvatar.avatar" ></div>
+  <div class="avatar avatar-image" [style.background-image]="'url(' + itemAvatar.imageurl + ')'" ></div>    
+</div>

package/src/app/components/utils/avatar-profile/avatar-profile.component.scss

@@ -0,0 +1,29 @@
+.avatar {
+    position: relative;
+    border-radius: 50%;
+    height: 100%;
+    width: 100%;
+    padding: 0;
+    -webkit-transform: translateX(-50%);
+    transform: translateX(-50%);
+    left: 50%;
+    display: block;
+    margin: 0px;
+}
+
+.avatar-circle {
+    height: 100%;
+    width: 100%;
+}
+
+.avatar-placeholder {
+    text-align: center;
+    font-size: 80%;
+    font-weight: 500;
+}
+.avatar-image {
+    margin-top: -100%;
+    background-color: transparent;
+    background-size: cover;
+    background-position: top center;
+}

package/src/app/components/utils/avatar-profile/avatar-profile.component.spec.ts

@@ -0,0 +1,24 @@
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { IonicModule } from '@ionic/angular';
+
+import { AvatarProfileComponent } from './avatar-profile.component';
+
+describe('AvatarProfileComponent', () => {
+  let component: AvatarProfileComponent;
+  let fixture: ComponentFixture<AvatarProfileComponent>;
+
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      declarations: [ AvatarProfileComponent ],
+      imports: [IonicModule.forRoot()]
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(AvatarProfileComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  }));
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

package/src/app/components/utils/avatar-profile/avatar-profile.component.ts

@@ -0,0 +1,41 @@
+import { Component, OnInit, Input, OnChanges } from '@angular/core';
+// Logger
+import { LoggerService } from 'src/chat21-core/providers/abstract/logger.service';
+import { LoggerInstance } from 'src/chat21-core/providers/logger/loggerInstance';
+
+@Component({
+  selector: 'app-avatar-profile',
+  templateUrl: './avatar-profile.component.html',
+  styleUrls: ['./avatar-profile.component.scss'],
+})
+export class AvatarProfileComponent implements OnInit, OnChanges {
+  @Input() itemAvatar: any;
+  public avatarUrl: string
+  public avatar: string
+  public color: string
+  private logger: LoggerService = LoggerInstance.getInstance();
+  constructor() {
+    this.logger.log('AvatarProfileComponent:::: constructor');
+  }
+
+  ngOnInit() {
+    this.logger.log('AvatarProfileComponent:::: ngOnInit');
+    // console.log('AvatarProfileComponent itemAvatar ',this.itemAvatar);
+    if (this.itemAvatar) {
+      this.avatarUrl = this.itemAvatar.imageurl
+      this.avatar = this.itemAvatar.avatar
+      this.color = this.itemAvatar.color
+    }
+    // console.log('AvatarProfileComponent avatarUrl ',this.avatarUrl);
+    // console.log('AvatarProfileComponent avatar ',this.avatar);
+    // console.log('AvatarProfileComponent color ',this.color);
+  }
+
+  ngOnChanges() {
+    // console.log('AvatarProfileComponent itemAvatar ',this.itemAvatar);
+    // console.log('AvatarProfileComponent avatarUrl ',this.avatarUrl);
+    // console.log('AvatarProfileComponent avatar ',this.avatar);
+    // console.log('AvatarProfileComponent color ',this.color);
+  }
+
+}

package/src/app/components/utils/user-presence/user-presence.component.html

@@ -0,0 +1,2 @@
+<div class="status-icon" [class.online]="online" [style.border-color]="borderColor"></div>
+<div class="online-point" [style.color]="fontColor">{{status}}</div>

package/src/app/components/utils/user-presence/user-presence.component.scss

@@ -0,0 +1,24 @@
+.status-icon {
+    position: absolute;
+    width: 14px;
+    height: 14px;
+    top: 0px;
+    left: 0;
+    border: 2px solid #ffffff;
+    border-radius: 50%;
+    background-color: #f44336;
+    &.online {
+        background-color: #4caf50;
+    }
+    
+}
+.online-point {
+    position: absolute;
+    display: inline-block;
+    top: 0;
+    left: 20px;
+    color: rgba(255, 255, 255, 0.5);
+    font-size: 12px;
+    line-height: 14px;
+    text-align: left;
+}

package/src/app/components/utils/user-presence/user-presence.component.spec.ts

@@ -0,0 +1,24 @@
+import { async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { IonicModule } from '@ionic/angular';
+
+import { UserPresenceComponent } from './user-presence.component';
+
+describe('UserPresenceComponent', () => {
+  let component: UserPresenceComponent;
+  let fixture: ComponentFixture<UserPresenceComponent>;
+
+  beforeEach(async(() => {
+    TestBed.configureTestingModule({
+      declarations: [ UserPresenceComponent ],
+      imports: [IonicModule.forRoot()]
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(UserPresenceComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  }));
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

package/src/app/components/utils/user-presence/user-presence.component.ts

@@ -0,0 +1,159 @@
+import { Component, OnInit, OnDestroy, Input } from '@angular/core';
+
+// services
+import { PresenceService } from 'src/chat21-core/providers/abstract/presence.service';
+
+// utils
+import { isInArray, setLastDateWithLabels } from 'src/chat21-core/utils/utils';
+
+// Logger
+import { LoggerService } from 'src/chat21-core/providers/abstract/logger.service';
+import { LoggerInstance } from 'src/chat21-core/providers/logger/loggerInstance';
+
+@Component({
+  selector: 'app-user-presence',
+  templateUrl: './user-presence.component.html',
+  styleUrls: ['./user-presence.component.scss'],
+})
+
+export class UserPresenceComponent implements OnInit, OnDestroy {
+  @Input() idUser: string;
+  @Input() translationMap: Map<string, string>;
+  @Input() fontColor: string;
+  @Input() borderColor: string;
+
+
+  public online = true;
+  public status = '';
+  private lastConnectionDate: string;
+  private subscriptions = [];
+  private logger: LoggerService = LoggerInstance.getInstance();
+
+  constructor(
+    public presenceService: PresenceService
+  ) { }
+
+  ngOnInit() {
+    this.logger.log('[USER-PRESENCE-COMP] - ngOnInit');
+    this.initialize();
+  }
+
+
+  /** */
+  ngOnDestroy() {
+    this.logger.log('[USER-PRESENCE-COMP] - ngOnDestroy');
+    this.unsubescribeAll();
+  }
+
+  /** */
+  initialize() {
+    if (this.translationMap) {
+      this.status = this.translationMap.get('LABEL_ACTIVE_NOW');
+    }
+    this.logger.log('[USER-PRESENCE-COMP] - initialize - this.translationMap', this.translationMap);
+    this.logger.log('[USER-PRESENCE-COMP] - initialize - this.status', this.status);
+    this.logger.log('[USER-PRESENCE-COMP] - initialize - idUser ->', this.idUser);
+    this.setSubscriptions();
+  }
+
+
+
+  /** */
+  private setSubscriptions() {
+    this.presenceService.userIsOnline(this.idUser);
+    this.presenceService.lastOnlineForUser(this.idUser);
+    let subscribtionKey = '';
+    let subscribtion: any;
+
+    const that = this;
+
+    subscribtionKey = 'BSIsOnline';
+    subscribtion = this.subscriptions.find(item => item.key === subscribtionKey);
+    if (!subscribtion) {
+      subscribtion = this.presenceService.BSIsOnline.subscribe((data: any) => {
+        this.logger.log('[USER-PRESENCE-COMP] $subs to BSIsOnline - data ', data);
+        if (data) {
+          const userId = data.uid;
+          const isOnline = data.isOnline;
+          if (this.idUser === userId) {
+            that.userIsOnLine(userId, isOnline);
+          }
+        }
+      });
+      const subscribe = { key: subscribtionKey, value: subscribtion };
+      this.subscriptions.push(subscribe);
+    }
+
+
+    subscribtionKey = 'BSLastOnline';
+    subscribtion = this.subscriptions.find(item => item.key === subscribtionKey);
+    if (!subscribtion) {
+      subscribtion = this.presenceService.BSLastOnline.subscribe((data: any) => {
+        this.logger.log('[USER-PRESENCE-COMP] $subs to BSLastOnline - data ', data);
+        if (data) {
+          const userId = data.uid;
+          const timestamp = data.lastOnline;
+          if (this.idUser === userId) {
+            that.userLastConnection(userId, timestamp);
+          }
+        }
+      });
+      const subscribe = { key: subscribtionKey, value: subscribtion };
+      this.subscriptions.push(subscribe);
+    }
+
+
+    // keySubscription = 'is-online-' + this.idUser;
+    // if (!isInArray(keySubscription, this.subscriptions)) {
+    //   this.subscriptions.push(keySubscription);
+    //   this.events.subscribe(keySubscription, this.userIsOnLine);
+    // }
+    // keySubscription = 'last-connection-date-' + this.idUser;
+    // if (!isInArray(keySubscription, this.subscriptions)) {
+    //   this.subscriptions.push(keySubscription);
+    //   this.events.subscribe(keySubscription, this.userLastConnection);
+    // }
+  }
+
+  /**
+   *
+   */
+  userIsOnLine = (userId: string, isOnline: boolean) => {
+    this.logger.log('[USER-PRESENCE-COMP] userIsOnLine - userId: ', userId, ' - isOnline: ', isOnline);
+    this.online = isOnline;
+    if (isOnline) {
+      this.status = this.translationMap.get('LABEL_ACTIVE_NOW');
+    } else {
+      this.status = this.translationMap.get('LABEL_NOT_AVAILABLE');
+      if (this.lastConnectionDate && this.lastConnectionDate.trim() !== '') {
+        this.status = this.lastConnectionDate;
+      }
+    }
+  }
+
+  /**
+   *
+   */
+  userLastConnection = (userId: string, timestamp: string) => {
+    this.logger.log('[USER-PRESENCE-COMP] userLastConnection - userId: ', userId, ' - timestamp: ', timestamp);
+    if (timestamp && timestamp !== '') {
+      const lastConnectionDate = setLastDateWithLabels(this.translationMap, timestamp);
+      this.logger.log('[USER-PRESENCE-COMP] userLastConnection - lastConnectionDate', lastConnectionDate);
+      this.lastConnectionDate = lastConnectionDate;
+      if (this.online === false) {
+        this.status = this.lastConnectionDate;
+      }
+    }
+  }
+
+
+  /** */
+  private unsubescribeAll() {
+    this.logger.log('[USER-PRESENCE-COMP] - unsubescribeAll: ', this.subscriptions);
+    this.subscriptions.forEach(subscription => {
+      subscription.value.unsubscribe(); // vedere come fare l'unsubscribe!!!!
+    });
+    this.subscriptions = [];
+  }
+
+}