@hmcts/media-viewer 4.2.4-exui-3994-f → 4.2.4-exui-3994-g

package/projects/media-viewer/src/lib/icp/icp-update.service.spec.ts

@@ -1,176 +0,0 @@
-import { TestBed, inject } from '@angular/core/testing';
-import { SocketService } from './socket.service';
-import { IcpUpdateService } from './icp-update.service';
-import { IcpParticipant, IcpScreenUpdate, IcpSession } from './icp.interfaces';
-import { of } from 'rxjs';
-
-describe('UpdateService', () => {
-
-  let updateService: IcpUpdateService;
-
-  const username = 'name';
-  const session: IcpSession = {
-    caseId: 'caseId',
-    documentId: 'documentId',
-    sessionId: 'sessionId',
-    dateOfHearing: new Date(),
-    connectionUrl: ''
-  };
-  const participant: IcpParticipant = {
-    id: 'id',
-    username: 'name'
-  };
-  const screen: IcpScreenUpdate = {
-    pdfPosition: {
-      pageNumber: 1,
-      top: 1,
-      left: 1,
-      rotation: 1,
-      scale: 1
-    },
-    document: 'document'
-  };
-
-  const mockSocketService = {
-    connect: () => { },
-    join: () => { },
-    leave: () => { },
-    emit: () => { },
-    listen: () => { },
-    connected: () => { },
-  } as any;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [IcpUpdateService, { provide: SocketService, useValue: mockSocketService }]
-    });
-
-    updateService = TestBed.inject(IcpUpdateService);
-  });
-
-  it('should be created', inject([IcpUpdateService], (service: IcpUpdateService) => {
-    expect(service).toBeTruthy();
-  }));
-
-  it('should join session',
-    inject([SocketService], (socketService) => {
-      spyOn(socketService, 'connect');
-      spyOn(socketService, 'join');
-      spyOn(socketService, 'listen');
-      spyOn(socketService, 'connected').and.returnValue(of(true));
-
-      updateService.joinSession(username, session, "token");
-      expect(updateService.session).toEqual(session);
-      expect(socketService.connect).toHaveBeenCalled();
-      expect(socketService.join).toHaveBeenCalled();
-      expect(socketService.listen).toHaveBeenCalled();
-      expect(socketService.connected).toHaveBeenCalled();
-    }));
-
-  it('should leave session',
-    inject([SocketService], (socketService) => {
-      spyOn(socketService, 'leave');
-
-      updateService.leaveSession();
-      expect(socketService.leave).toHaveBeenCalled();
-    }));
-
-  it('listen for new participant',
-    inject([SocketService], (socketService) => {
-      spyOn(socketService, 'listen');
-
-      updateService.newParticipantJoined();
-      expect(socketService.listen).toHaveBeenCalled();
-    }));
-
-  it('listen for client disconnecting',
-    inject([SocketService], (socketService) => {
-      spyOn(socketService, 'listen');
-
-      updateService.clientDisconnected();
-      expect(socketService.listen).toHaveBeenCalled();
-    }));
-
-  it('emit event when updating presenter',
-    inject([SocketService], (socketService) => {
-      spyOn(socketService, 'emit');
-
-      updateService.updatePresenter(participant);
-      expect(socketService.emit).toHaveBeenCalled();
-    }));
-
-  it('listen for presenter updates',
-    inject([SocketService], (socketService) => {
-      spyOn(socketService, 'listen');
-
-      updateService.presenterUpdated();
-      expect(socketService.listen).toHaveBeenCalled();
-    }));
-
-  it('emit update screen event',
-    inject([SocketService], (socketService) => {
-      spyOn(socketService, 'emit');
-
-      updateService.session = session;
-      updateService.updateScreen(screen);
-      expect(socketService.emit).toHaveBeenCalled();
-    }));
-
-  it('listen for screen updates',
-    inject([SocketService], (socketService) => {
-      spyOn(socketService, 'listen');
-
-      updateService.screenUpdated();
-      expect(socketService.listen).toHaveBeenCalled();
-    }));
-
-  it('emit remove participant event',
-    inject([SocketService], (socketService) => {
-      spyOn(socketService, 'emit');
-
-      updateService.session = session;
-      updateService.removeParticipant('participantId');
-      expect(socketService.emit).toHaveBeenCalled();
-    }));
-
-  it('listen for participant updates',
-    inject([SocketService], (socketService) => {
-      spyOn(socketService, 'listen');
-
-      updateService.participantListUpdated();
-      expect(socketService.listen).toHaveBeenCalled();
-    }));
-
-  it('should unsubscribe from previous joinSessionSubscription when joining session again', inject([SocketService], (socketService) => {
-    const unsubscribeSpy = jasmine.createSpy('unsubscribe');
-    updateService['joinSessionSubscription'] = { unsubscribe: unsubscribeSpy };
-    spyOn(socketService, 'connect');
-    spyOn(socketService, 'join');
-    spyOn(socketService, 'listen');
-    spyOn(socketService, 'connected').and.returnValue(of(true));
-
-    updateService.joinSession(username, session, "token");
-    expect(unsubscribeSpy).toHaveBeenCalled();
-    expect(updateService['joinSessionSubscription']).toBeDefined();
-  }));
-
-  it('should set joinSessionSubscription to null when leaving session', inject([SocketService], (socketService) => {
-    const unsubscribeSpy = jasmine.createSpy('unsubscribe');
-    updateService['joinSessionSubscription'] = { unsubscribe: unsubscribeSpy };
-    spyOn(socketService, 'leave');
-
-    updateService.session = session;
-    updateService.leaveSession();
-    expect(unsubscribeSpy).toHaveBeenCalled();
-    expect(updateService['joinSessionSubscription']).toBeNull();
-    expect(socketService.leave).toHaveBeenCalledWith(session);
-  }));
-
-  it('should not throw if leaveSession called with no joinSessionSubscription', inject([SocketService], (socketService) => {
-    updateService['joinSessionSubscription'] = null;
-    spyOn(socketService, 'leave');
-    updateService.session = session;
-    expect(() => updateService.leaveSession()).not.toThrow();
-    expect(socketService.leave).toHaveBeenCalledWith(session);
-  }));
-});

package/projects/media-viewer/src/lib/icp/icp-update.service.ts

@@ -1,81 +0,0 @@
-import { Injectable } from '@angular/core';
-import { SocketService } from './socket.service';
-import { IcpParticipant, IcpScreenUpdate, IcpSession } from './icp.interfaces';
-import { IcpEvents } from './icp.events';
-
-@Injectable({ providedIn: 'root' })
-export class IcpUpdateService {
-
-  session: IcpSession;
-
-  constructor(private socket: SocketService) { }
-
-  private joinSessionSubscription: any;
-
-  joinSession(username: string, session: IcpSession, token: string) {
-    this.session = session;
-    this.socket.connect(`${session.connectionUrl}?access_token=${token}`, session);
-    if (this.joinSessionSubscription) {
-      this.joinSessionSubscription.unsubscribe();
-    }
-    this.joinSessionSubscription = this.socket.connected().subscribe(isConnected => {
-      if (isConnected) {
-        this.socket.join({ ...this.session, username });
-      }
-    });
-    return this.socket.listen(IcpEvents.SESSION_JOINED);
-  }
-
-  leaveSession() {
-    if (this.joinSessionSubscription) {
-      this.joinSessionSubscription.unsubscribe();
-      this.joinSessionSubscription = null;
-    }
-    this.socket.leave(this.session);
-  }
-
-  newParticipantJoined() {
-    return this.socket.listen(IcpEvents.NEW_PARTICIPANT_JOINED);
-  }
-
-  clientDisconnected() {
-    return this.socket.listen(IcpEvents.CLIENT_DISCONNECTED);
-  }
-
-  removeParticipant(participantId) {
-    this.socket.emit(IcpEvents.REMOVE_PARTICIPANT, {
-      participantId: participantId,
-      caseId: this.session.caseId,
-      documentId: this.session.documentId
-    });
-  }
-
-  participantListUpdated() {
-    return this.socket.listen(IcpEvents.PARTICIPANTS_UPDATED);
-  }
-
-  updatePresenter(presenter: IcpParticipant) {
-    this.socket.emit(IcpEvents.UPDATE_PRESENTER, {
-      ...this.session,
-      presenterId: presenter.id,
-      presenterName: presenter.username
-    });
-  }
-
-  presenterUpdated() {
-    return this.socket.listen(IcpEvents.PRESENTER_UPDATED);
-  }
-
-  updateScreen(screen: IcpScreenUpdate) {
-    const update = {
-      body: screen,
-      caseId: this.session.caseId,
-      documentId: this.session.documentId
-    };
-    this.socket.emit(IcpEvents.UPDATE_SCREEN, update);
-  }
-
-  screenUpdated() {
-    return this.socket.listen(IcpEvents.SCREEN_UPDATED);
-  }
-}

package/projects/media-viewer/src/lib/icp/icp.events.ts

@@ -1,13 +0,0 @@
-export enum IcpEvents {
-  SESSION_JOINED = 'IcpClientJoinedSession',
-  CLIENT_DISCONNECTED = 'IcpClientDisconnectedFromSession',
-  NEW_PARTICIPANT_JOINED = 'IcpNewParticipantJoinedSession',
-  REMOVE_PARTICIPANT = 'IcpRemoveParticipantFromList',
-  PARTICIPANTS_UPDATED = 'IcpParticipantsListUpdated',
-  UPDATE_PRESENTER = 'IcpNewPresenterStartsPresenting',
-  PRESENTER_UPDATED = 'IcpPresenterUpdated',
-  UPDATE_SCREEN = 'IcpUpdateScreen',
-  SCREEN_UPDATED = 'IcpScreenUpdated',
-  SESSION_JOIN = 'IcpClientJoinSession',
-  SESSION_LEAVE = 'IcpClientLeaveSession',
-}

package/projects/media-viewer/src/lib/icp/icp.interfaces.ts

@@ -1,26 +0,0 @@
-import { PdfPosition } from '../store/reducers/document.reducer';
-
-export interface IcpState {
-  session: IcpSession;
-  presenter: IcpParticipant;
-  client: IcpParticipant;
-  participants: IcpParticipant[];
-}
-
-export interface IcpSession {
-  sessionId: string;
-  documentId: string;
-  caseId: string;
-  dateOfHearing: Date;
-  connectionUrl: string;
-}
-
-export interface IcpParticipant {
-  id: string;
-  username: string;
-}
-
-export interface IcpScreenUpdate {
-  pdfPosition: PdfPosition;
-  document: string;
-}

package/projects/media-viewer/src/lib/icp/icp.service.spec.ts

@@ -1,226 +0,0 @@
-import { IcpService } from './icp.service';
-import { fakeAsync, inject, TestBed } from '@angular/core/testing';
-import { IcpUpdateService } from './icp-update.service';
-import { SocketService } from './socket.service';
-import { IcpPresenterService } from './icp-presenter.service';
-import { IcpFollowerService } from './icp-follower.service';
-import { Store, StoreModule } from '@ngrx/store';
-import { reducers } from '../store/reducers/reducers';
-import { ToolbarEventService } from '../toolbar/toolbar-event.service';
-import { IcpParticipant, IcpSession } from './icp.interfaces';
-import * as fromIcpActions from '../store/actions/icp.actions';
-import { of, Subscription } from 'rxjs';
-import { IcpEventService } from '../toolbar/icp-event.service';
-
-describe('Icp Service', () => {
-
-  let service: IcpService;
-  let updateService: IcpUpdateService;
-  let presenterService: IcpPresenterService;
-  let followerService: IcpFollowerService;
-  const mockParticipantService = {
-    update: () => {
-    }
-  } as any;
-  const mockUpdateService = {
-    clientDisconnected: () => of('client'),
-    presenterUpdated: () => of(),
-    participantListUpdated: () => of(),
-    leaveSession: () => { },
-    updatePresenter: () => { },
-    screenUpdated: () => { },
-    removeParticipant: () => { },
-  } as any;
-
-  const session: IcpSession = {
-    caseId: 'caseId',
-    documentId: 'documentId',
-    sessionId: 'sessionId',
-    dateOfHearing: new Date(),
-    connectionUrl: ''
-  };
-  const participant: IcpParticipant = {
-    id: 'id',
-    username: 'name'
-  };
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      imports: [
-        StoreModule.forFeature('media-viewer', reducers),
-        StoreModule.forRoot({})
-      ],
-      providers: [IcpService,
-        SocketService,
-        { provide: IcpUpdateService, useValue: mockUpdateService },
-        { provide: IcpPresenterService, useValue: mockParticipantService },
-        { provide: IcpFollowerService, useValue: mockParticipantService },
-      ]
-    });
-    service = TestBed.inject(IcpService);
-    updateService = TestBed.inject(IcpUpdateService);
-    presenterService = TestBed.inject(IcpPresenterService);
-    followerService = TestBed.inject(IcpFollowerService);
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-
-  it('should subscribe to case id in store',
-    inject([Store], fakeAsync((store) => {
-      const action = new fromIcpActions.SetCaseId('caseId');
-      store.dispatch(action);
-
-      expect(service.caseId).toEqual('caseId');
-    }))
-  );
-
-  it('should subscribe to the sessionLaunch event',
-    inject([Store, IcpEventService], fakeAsync((store, icpEventService) => {
-      spyOn(service, 'launchSession');
-      service.caseId = 'caseId';
-      service.documentId = 'documentId';
-      icpEventService.sessionLaunch.next();
-
-      expect(service.launchSession).toHaveBeenCalled();
-    }))
-  );
-
-  it('should load icp session on session launch',
-    inject([Store], fakeAsync((store) => {
-      spyOn(store, 'dispatch');
-
-      service.caseId = 'caseId';
-      service.documentId = 'documentId';
-      service.launchSession();
-
-      expect(store.dispatch).toHaveBeenCalledWith(new fromIcpActions.LoadIcpSession({ caseId: 'caseId', documentId: 'documentId' }));
-    }))
-  );
-
-  it('should subscribe to icp session store when session launched',
-    inject([Store], fakeAsync((store) => {
-      spyOn(service, 'setUpSessionSubscriptions');
-
-      service.caseId = 'caseId';
-      service.launchSession();
-
-      const payload = { session: session, participantInfo: { client: participant, presenter: participant } };
-      const action = new fromIcpActions.IcpSocketSessionJoined(payload);
-      store.dispatch(action);
-
-      expect(service.setUpSessionSubscriptions).toHaveBeenCalled();
-    }))
-  );
-
-  it('should set up session subscriptions when session launched',
-    inject([IcpEventService, Store], fakeAsync((icpEventService, store) => {
-      spyOn(service, 'becomePresenter');
-      spyOn(service, 'stopPresenting');
-      spyOn(service, 'leavePresentation');
-      spyOn(presenterService, 'update');
-      spyOn(service, 'clientDisconnected');
-
-      service.setUpSessionSubscriptions();
-      icpEventService.becomingPresenter.next();
-      icpEventService.stoppingPresenting.next();
-      icpEventService.sessionExitConfirmed.next();
-      const payload = { session: session, participantInfo: { client: participant, presenter: participant } };
-      const action = new fromIcpActions.IcpSocketSessionJoined(payload);
-      store.dispatch(action);
-      mockUpdateService.clientDisconnected();
-
-      expect(service.becomePresenter).toHaveBeenCalled();
-      expect(service.stopPresenting).toHaveBeenCalled();
-      expect(service.leavePresentation).toHaveBeenCalled();
-      expect(service.presenter).toEqual(participant);
-      expect(service.client).toEqual(participant);
-      expect(service.isPresenter).toEqual(true);
-      expect(presenterService.update).toHaveBeenCalled();
-      expect(followerService.update).toHaveBeenCalled();
-      expect(service.clientDisconnected).toHaveBeenCalled();
-    }))
-  );
-
-  it('should unsubscribe from session subscriptions when session destroyed', () => {
-    service.sessionSubscription = new Subscription();
-
-    spyOn(service.sessionSubscription, 'unsubscribe');
-    spyOn(presenterService, 'update');
-
-    service.unsubscribeSession();
-
-    expect(presenterService.update).toHaveBeenCalled();
-    expect(followerService.update).toHaveBeenCalled();
-    expect(service.sessionSubscription.unsubscribe).toHaveBeenCalled();
-  });
-
-  it('should destroy subscriptions', () => {
-    service.subscription = new Subscription();
-    service.sessionSubscription = new Subscription();
-
-    spyOn(service.subscription, 'unsubscribe');
-    spyOn(service, 'unsubscribeSession');
-
-    service.ngOnDestroy();
-
-    expect(service.unsubscribeSession).toHaveBeenCalled();
-    expect(service.subscription.unsubscribe).toHaveBeenCalled();
-  });
-
-  it('should leave presentation',
-    inject([Store], fakeAsync((store) => {
-      spyOn(service, 'stopPresenting');
-      spyOn(service, 'unsubscribeSession');
-      spyOn(service, 'removeParticipant');
-      spyOn(updateService, 'leaveSession');
-      spyOn(store, 'dispatch');
-
-      service.isPresenter = true;
-      service.sessionSubscription = new Subscription();
-      service.client = { id: 'clientId', username: 'name' };
-      service.leavePresentation();
-
-      expect(service.stopPresenting).toHaveBeenCalled();
-      expect(service.unsubscribeSession).toHaveBeenCalled();
-      expect(service.removeParticipant).toHaveBeenCalledWith(service.client.id);
-      expect(updateService.leaveSession).toHaveBeenCalled();
-      expect(store.dispatch).toHaveBeenCalledWith(new fromIcpActions.LeaveIcpSocketSession());
-    }))
-  );
-
-  it('should stop presenting', () => {
-    spyOn(updateService, 'updatePresenter');
-
-    service.stopPresenting();
-
-    expect(updateService.updatePresenter).toHaveBeenCalled();
-  });
-
-  it('should become presenter', () => {
-    spyOn(updateService, 'updatePresenter');
-
-    service.client = participant;
-    service.becomePresenter();
-
-    expect(updateService.updatePresenter).toHaveBeenCalled();
-  });
-
-  it('should call stop presenting if client disconnected is presenter', () => {
-    spyOn(service, 'stopPresenting');
-
-    service.presenter = participant;
-    service.clientDisconnected(participant.id);
-
-    expect(service.stopPresenting).toHaveBeenCalled();
-  });
-
-  it('should remove participant', () => {
-    spyOn(updateService, 'removeParticipant');
-
-    service.removeParticipant(participant.id);
-
-    expect(updateService.removeParticipant).toHaveBeenCalled();
-  });
-});

package/projects/media-viewer/src/lib/icp/icp.service.ts

@@ -1,114 +0,0 @@
-import { Injectable, OnDestroy } from '@angular/core';
-import { IcpParticipant, IcpState } from './icp.interfaces';
-import { Subscription } from 'rxjs';
-import { ToolbarEventService } from '../toolbar/toolbar-event.service';
-import { ViewerEventService } from '../viewers/viewer-event.service';
-import { IcpUpdateService } from './icp-update.service';
-import { IcpPresenterService } from './icp-presenter.service';
-import { IcpFollowerService } from './icp-follower.service';
-import { select, Store } from '@ngrx/store';
-import * as fromIcpActions from '../store/actions/icp.actions';
-import * as fromIcpSelectors from '../store/selectors/icp.selectors';
-import * as fromDocument from '../store/selectors/document.selectors';
-import { filter, take } from 'rxjs/operators';
-import { IcpEventService } from '../toolbar/icp-event.service';
-
-@Injectable({ providedIn: 'root' })
-export class IcpService implements OnDestroy {
-
-  caseId: string;
-  client: IcpParticipant;
-  presenter: IcpParticipant;
-  isPresenter: boolean;
-  documentId: string;
-
-  subscription: Subscription;
-  sessionSubscription: Subscription;
-
-  constructor(private readonly toolbarEvents: ToolbarEventService,
-    private readonly viewerEvents: ViewerEventService,
-    private readonly socketService: IcpUpdateService,
-    private readonly presenterSubscriptions: IcpPresenterService,
-    private readonly followerSubscriptions: IcpFollowerService,
-    private store: Store<IcpState>,
-    private readonly icpEventService: IcpEventService) {
-    this.subscription = this.store.pipe(select(fromIcpSelectors.getCaseId), filter(value => !!value)).subscribe(caseId => {
-      this.caseId = caseId;
-    });
-    this.subscription.add(this.store.pipe(select(fromDocument.getDocumentId)).subscribe(docId => this.documentId = docId));
-    this.subscription.add(this.icpEventService.sessionLaunch.subscribe(() => {
-
-      if (this.caseId && this.documentId) { this.launchSession(); }
-    }));
-  }
-
-  ngOnDestroy() {
-    this.unsubscribeSession();
-    this.subscription.unsubscribe();
-  }
-
-  launchSession() {
-    this.store.dispatch(new fromIcpActions.LoadIcpSession({ caseId: this.caseId, documentId: this.documentId }));
-    this.subscription.add(this.store.pipe(select(fromIcpSelectors.getIcpSession),
-      filter(value => !!value && Object.keys(value).length > 1),
-      take(1)).subscribe(() => { this.setUpSessionSubscriptions(); }));
-  }
-
-  setUpSessionSubscriptions() {
-    this.sessionSubscription = this.icpEventService.becomingPresenter.subscribe(() => this.becomePresenter());
-    this.sessionSubscription.add(this.icpEventService.stoppingPresenting.subscribe(() => this.stopPresenting()));
-    this.sessionSubscription.add(this.icpEventService.sessionExitConfirmed.subscribe(() => this.leavePresentation()));
-    this.sessionSubscription.add(
-      this.store.pipe(select(fromIcpSelectors.getPresenter)).subscribe(presenter => this.presenter = presenter)
-    );
-    this.sessionSubscription.add(this.store.pipe(select(fromIcpSelectors.getClient)).subscribe(client => this.client = client));
-    this.sessionSubscription.add(this.store.pipe(select(fromIcpSelectors.isPresenter)).subscribe(isPresenter => {
-      this.isPresenter = isPresenter;
-      this.presenterSubscriptions.update(isPresenter);
-      this.followerSubscriptions.update(!isPresenter);
-    }));
-    this.sessionSubscription.add(this.socketService.clientDisconnected().subscribe(cli => this.clientDisconnected(cli)));
-    this.sessionSubscription.add(this.socketService.presenterUpdated().subscribe(pres => {
-      this.store.dispatch(new fromIcpActions.IcpPresenterUpdated(pres));
-    }));
-    this.sessionSubscription.add(this.socketService.participantListUpdated().subscribe(participants => {
-      this.store.dispatch(new fromIcpActions.IcpParticipantListUpdated(participants));
-    }));
-  }
-
-  unsubscribeSession() {
-    this.presenterSubscriptions.update(false);
-    this.followerSubscriptions.update(false);
-    this.sessionSubscription.unsubscribe();
-  }
-
-  leavePresentation() {
-    if (this.isPresenter) {
-      this.stopPresenting();
-    }
-    this.removeParticipant(this.client.id);
-    this.socketService.leaveSession();
-    this.store.dispatch(new fromIcpActions.LeaveIcpSocketSession());
-    this.unsubscribeSession();
-  }
-
-  stopPresenting() {
-    const presenter: IcpParticipant = { username: '', id: '' };
-    this.socketService.updatePresenter(presenter);
-  }
-
-  becomePresenter() {
-    this.socketService.updatePresenter(this.client);
-  }
-
-  clientDisconnected(client) {
-    if (client === this.presenter.id) {
-      this.stopPresenting();
-    }
-    this.removeParticipant(client);
-  }
-
-  removeParticipant(participantId) {
-    this.socketService.removeParticipant(participantId);
-  }
-}

package/projects/media-viewer/src/lib/icp/participants-list/participants-list.component.html

@@ -1,18 +0,0 @@
-<div class="comments-panel comment-container icp-mode" [ngClass]="{'expanded': showParticipantsList }">
-
-  <div class="participant__card no-shadow">
-    <p class="participant__name">All Participants</p>
-  </div>
-
-  <div *ngIf="(presenter$ | async)?.username !== ''" class="participant__card">
-    <div class="participant__header"> Presenting </div>
-    <p class="participant__name">{{(presenter$ | async)?.username}}</p>
-  </div>
-
-  <div *ngIf="(participants$ | async).length > 1" class="participant__card">
-    <div class="participant__header">Following</div>
-    <ng-container *ngFor="let participant of (participants$ | async)">
-        <p *ngIf="participant.id !== (presenter$ | async)?.id" class="participant__name">{{participant.username}}</p>
-    </ng-container>
-  </div>
-</div>