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

package/projects/media-viewer/src/lib/store/actions/annotation.actions.ts

@@ -0,0 +1,129 @@
+import { Action } from '@ngrx/store';
+import { Annotation } from '../../annotations/annotation-set/annotation-view/annotation.model';
+import { SelectionAnnotation } from '../../annotations/models/event-select.model';
+import { AnnotationSet } from '../../annotations/annotation-set/annotation-set.model';
+import { Filters } from '../models/filters.interface';
+import { Comment } from '../../annotations/comment-set/comment/comment.model';
+
+export const LOAD_ANNOTATION_SET = '[Annotations] Load Annotation Set';
+export const LOAD_ANNOTATION_SET_SUCCESS = '[Annotations] Load Annotation Set Success';
+export const LOAD_ANNOTATION_SET_FAIL = '[Annotations] Load Annotation Set Fail';
+
+export const SAVE_ANNOTATION_SET = '[Annotations] Save Annotation Set';
+export const SAVE_ANNOTATION_SET_SUCCESS = '[Annotations] Save Annotation Set Success';
+export const SAVE_ANNOTATION_SET_FAIL = '[Annotations] Save Annotation Set Fail';
+
+export const SAVE_ANNOTATION = '[Annotations] Save Annotation';
+export const SAVE_ANNOTATION_SUCCESS = '[Annotations] Save Annotation Success';
+export const SAVE_ANNOTATION_FAIL = '[Annotations] Save Annotation Fail';
+export const ADD_OR_EDIT_COMMENT = '[Annotations] Add or Edit Comment';
+
+export const DELETE_ANNOTATION = '[Annotations] Delete Annotation';
+export const DELETE_ANNOTATION_SUCCESS = '[Annotations] Delete Annotation Success';
+export const DELETE_ANNOTATION_FAIL = '[Annotations] Delete Annotation Fail';
+
+export const SELECT_ANNOTATION = '[Annotations] Select Annotation';
+export const SEARCH_COMMENT = '[Comments] Search Comments';
+export const APPLY_COMMENT_SUMMARY_FILTER = '[Comments] Apply Comment Summary Filter';
+export const CLEAR_COMMENT_SUMMARY_FILTER = '[Comments] Clear Comment Summary Filter';
+
+export class LoadAnnotationSet implements Action {
+  readonly type = LOAD_ANNOTATION_SET;
+  constructor(public payload: string) { }
+}
+
+export class SaveAnnotationSet implements Action {
+  readonly type = SAVE_ANNOTATION_SET;
+  constructor(public payload: AnnotationSet) { }
+}
+
+export class LoadAnnotationSetSucess implements Action {
+  readonly type = LOAD_ANNOTATION_SET_SUCCESS;
+  constructor(public payload: { status: number, body: AnnotationSet }) { }
+}
+
+export class SaveAnnotationSetSuccess implements Action {
+  readonly type = SAVE_ANNOTATION_SET_SUCCESS;
+  constructor(public payload: AnnotationSet) { }
+}
+
+export class LoadAnnotationSetFail implements Action {
+  readonly type = LOAD_ANNOTATION_SET_FAIL;
+  constructor(public payload: { status: number, body: any }) { }
+}
+
+export class SaveAnnotationSetFail implements Action {
+  readonly type = SAVE_ANNOTATION_SET_FAIL;
+  constructor(public payload: { status: number, body: any }) { }
+}
+
+export class SaveAnnotation implements Action {
+  readonly type = SAVE_ANNOTATION;
+  constructor(public payload: Annotation) { }
+}
+
+export class SaveAnnotationSuccess implements Action {
+  readonly type = SAVE_ANNOTATION_SUCCESS;
+  constructor(public payload: any) { }
+}
+
+export class SaveAnnotationFail implements Action {
+  readonly type = SAVE_ANNOTATION_FAIL;
+  constructor(public payload: Error) { }
+}
+
+export class AddOrEditComment implements Action {
+  readonly type = ADD_OR_EDIT_COMMENT;
+  constructor(public payload: Comment) { }
+}
+
+export class DeleteAnnotation implements Action {
+  readonly type = DELETE_ANNOTATION;
+  constructor(public payload: string) { }
+}
+
+export class DeleteAnnotationSuccess implements Action {
+  readonly type = DELETE_ANNOTATION_SUCCESS;
+  constructor(public payload: string) { }
+}
+
+export class DeleteAnnotationFail implements Action {
+  readonly type = DELETE_ANNOTATION_FAIL;
+  constructor(public payload: Error) { }
+}
+
+export class SelectedAnnotation implements Action {
+  readonly type = SELECT_ANNOTATION;
+  constructor(public payload: SelectionAnnotation) { }
+}
+
+export class SearchComment implements Action {
+  readonly type = SEARCH_COMMENT;
+  constructor(public payload: string) { }
+}
+
+export class ApplyCommentSymmaryFilter implements Action {
+  readonly type = APPLY_COMMENT_SUMMARY_FILTER;
+  constructor(public payload: Filters) { }
+}
+
+export class ClearCommentSummaryFilters implements Action {
+  readonly type = CLEAR_COMMENT_SUMMARY_FILTER;
+}
+
+export type AnnotationsActions =
+  | LoadAnnotationSet
+  | LoadAnnotationSetSucess
+  | LoadAnnotationSetFail
+  | SaveAnnotation
+  | SaveAnnotationSuccess
+  | SaveAnnotationFail
+  | SaveAnnotationSetSuccess
+  | AddOrEditComment
+  | DeleteAnnotation
+  | DeleteAnnotationSuccess
+  | DeleteAnnotationFail
+  | SelectedAnnotation
+  | SearchComment
+  | ApplyCommentSymmaryFilter
+  | ClearCommentSummaryFilters;

package/projects/media-viewer/src/lib/store/actions/bookmark.actions.spec.ts

@@ -0,0 +1,110 @@
+import * as fromBookmarks from './bookmark.actions';
+
+describe('Bookmark actions', () => {
+  describe('Delete Bookmark', () => {
+    describe('Delete Bookmark', () => {
+      it('should create an action', () => {
+        const payload = { deleted: ['1234567'], updated: undefined };
+        const action = new fromBookmarks.DeleteBookmark(payload);
+        expect({ ...action }).toEqual({ type: fromBookmarks.DELETE_BOOKMARK, payload });
+      });
+    });
+    describe('DeleteBookmarkSuccess', () => {
+      it('should create an action', () => {
+        const payload: any = 'some1234id';
+        const action = new fromBookmarks.DeleteBookmarkSuccess(payload);
+        expect({ ...action }).toEqual({
+          type: fromBookmarks.DELETE_BOOKMARK_SUCCESS,
+          payload
+        });
+      });
+    });
+    describe('DeleteBookmarkFail', () => {
+      it('should create an action', () => {
+        const error: any = 'some error';
+        const action = new fromBookmarks.DeleteBookmarkFailure(error);
+        expect({ ...action }).toEqual({
+          type: fromBookmarks.DELETE_BOOKMARK_FAIL,
+          payload: error
+        });
+      });
+    });
+  });
+
+  describe('Update Bookmark', () => {
+    describe('Update Bookmark', () => {
+      it('should create an action', () => {
+        const payload: any = { name: 'bookmark name', id: 'id' };
+        const action = new fromBookmarks.UpdateBookmark(payload);
+        expect({ ...action }).toEqual({
+          type: fromBookmarks.UPDATE_BOOKMARK,
+          payload: payload
+        });
+      });
+    });
+    describe('UpdateBookmarkSuccess', () => {
+      it('should create an action', () => {
+        const payload: any = { name: 'bookmark name', id: 'id' };
+        const action = new fromBookmarks.UpdateBookmarkSuccess(payload);
+        expect({ ...action }).toEqual({
+          type: fromBookmarks.UPDATE_BOOKMARK_SUCCESS,
+          payload: payload
+        });
+      });
+    });
+    describe('UpdateBookmarkFail', () => {
+      it('should create an action', () => {
+        const error: any = 'some error';
+        const action = new fromBookmarks.UpdateBookmarkFailure(error);
+        expect({ ...action }).toEqual({
+          type: fromBookmarks.UPDATE_BOOKMARK_FAIL,
+          payload: error
+        });
+      });
+    });
+  });
+
+  describe('Move Bookmark', () => {
+    describe('Move Bookmark', () => {
+      it('should create an action', () => {
+        const payload: any = [{ name: 'bookmark name', id: 'id' }];
+        const action = new fromBookmarks.MoveBookmark(payload);
+        expect({ ...action }).toEqual({
+          type: fromBookmarks.MOVE_BOOKMARK,
+          payload: payload
+        });
+      });
+    });
+    describe('MoveBookmarkSuccess', () => {
+      it('should create an action', () => {
+        const payload: any = [{ name: 'bookmark name', id: 'id' }];
+        const action = new fromBookmarks.MoveBookmarkSuccess(payload);
+        expect({ ...action }).toEqual({
+          type: fromBookmarks.MOVE_BOOKMARK_SUCCESS,
+          payload: payload
+        });
+      });
+    });
+    describe('UpdateBookmarkScrollTop', () => {
+      it('should create an action', () => {
+        const payload: number = 190;
+        const action = new fromBookmarks.UpdateBookmarkScrollTop(payload);
+        expect({ ...action }).toEqual({
+          type: fromBookmarks.UPDATE_BOOKMARK_SCROLL_TOP,
+          payload: payload
+        });
+      });
+    });
+    describe('MoveBookmarkFail', () => {
+      it('should create an action', () => {
+        const error: any = 'some error';
+        const action = new fromBookmarks.MoveBookmarkFailure(error);
+        expect({ ...action }).toEqual({
+          type: fromBookmarks.MOVE_BOOKMARK_FAIL,
+          payload: error
+        });
+      });
+    });
+  });
+
+});

package/projects/media-viewer/src/lib/store/actions/bookmark.actions.ts

@@ -0,0 +1,107 @@
+import { Action } from '@ngrx/store';
+import { Bookmark } from '../../viewers/pdf-viewer/side-bar/bookmarks/bookmarks.interfaces';
+
+export const LOAD_BOOKMARKS = '[Bookmarks] Load Bookmarks';
+export const LOAD_BOOKMARKS_SUCCESS = '[Bookmarks] Load Bookmarks Success';
+export const LOAD_BOOKMARKS_FAIL = '[Bookmarks] Load Bookmarks Failure';
+export const CREATE_BOOKMARK = '[Bookmarks] Create Bookmark';
+export const CREATE_BOOKMARK_SUCCESS = '[Bookmarks] Create Bookmark Success';
+export const CREATE_BOOKMARK_FAIL = '[Bookmarks] Create Bookmark Failure';
+export const DELETE_BOOKMARK = '[Bookmarks] Delete Bookmark';
+export const DELETE_BOOKMARK_SUCCESS = '[Bookmarks] Delete Bookmark Success';
+export const DELETE_BOOKMARK_FAIL = '[Bookmarks] Delete Bookmark Failure';
+export const MOVE_BOOKMARK = '[Bookmarks] Move Bookmark';
+export const MOVE_BOOKMARK_SUCCESS = '[Bookmarks] Move Bookmark Success';
+export const MOVE_BOOKMARK_FAIL = '[Bookmarks] Move Bookmark Failure';
+export const UPDATE_BOOKMARK = '[Bookmarks] Update Bookmark';
+export const UPDATE_BOOKMARK_SUCCESS = '[Bookmarks] Update Bookmark Success';
+export const UPDATE_BOOKMARK_FAIL = '[Bookmarks] Update Bookmark Failure';
+export const UPDATE_BOOKMARK_SCROLL_TOP = '[Bookmarks] Update Bookmark Scroll Top'
+
+export class LoadBookmarks implements Action {
+  readonly type = LOAD_BOOKMARKS;
+  constructor() { }
+}
+
+export class LoadBookmarksSuccess implements Action {
+  readonly type = LOAD_BOOKMARKS_SUCCESS;
+  constructor(public payload: { body: Bookmark[], status: number }) { }
+}
+
+export class LoadBookmarksFailure implements Action {
+  readonly type = LOAD_BOOKMARKS_FAIL;
+  constructor(public payload: { body: any, status: number }) { }
+}
+
+export class CreateBookmark implements Action {
+  readonly type = CREATE_BOOKMARK;
+  constructor(public payload: Bookmark) { }
+}
+
+export class CreateBookmarkSuccess implements Action {
+  readonly type = CREATE_BOOKMARK_SUCCESS;
+  constructor(public payload: Bookmark) { }
+}
+
+export class CreateBookmarkFailure implements Action {
+  readonly type = CREATE_BOOKMARK_FAIL;
+  constructor(public payload: Bookmark) { }
+}
+
+export class DeleteBookmark implements Action {
+  readonly type = DELETE_BOOKMARK;
+  constructor(public payload: { deleted: string[], updated: Bookmark }) { }
+}
+
+export class DeleteBookmarkSuccess implements Action {
+  readonly type = DELETE_BOOKMARK_SUCCESS;
+  constructor(public payload: string[]) { }
+}
+
+export class DeleteBookmarkFailure implements Action {
+  readonly type = DELETE_BOOKMARK_FAIL;
+  constructor(public payload: string) { }
+}
+
+export class MoveBookmark implements Action {
+  readonly type = MOVE_BOOKMARK;
+  constructor(public payload: Bookmark[]) { }
+}
+
+export class MoveBookmarkSuccess implements Action {
+  readonly type = MOVE_BOOKMARK_SUCCESS;
+  constructor(public payload: Bookmark[]) { }
+}
+
+export class MoveBookmarkFailure implements Action {
+  readonly type = MOVE_BOOKMARK_FAIL;
+  constructor(public payload: string) { }
+}
+
+export class UpdateBookmark implements Action {
+  readonly type = UPDATE_BOOKMARK;
+  constructor(public payload: Bookmark) { }
+}
+
+export class UpdateBookmarkSuccess implements Action {
+  readonly type = UPDATE_BOOKMARK_SUCCESS;
+  constructor(public payload: Bookmark) { }
+}
+
+export class UpdateBookmarkFailure implements Action {
+  readonly type = UPDATE_BOOKMARK_FAIL;
+  constructor(public payload: Bookmark) { }
+}
+
+export class UpdateBookmarkScrollTop implements Action {
+  readonly type = UPDATE_BOOKMARK_SCROLL_TOP;
+  constructor(public payload: number) { }
+}
+
+
+export type BookmarksActions =
+  | LoadBookmarks | LoadBookmarksSuccess | LoadBookmarksFailure
+  | CreateBookmark | CreateBookmarkSuccess | CreateBookmarkFailure
+  | DeleteBookmark | DeleteBookmarkSuccess | DeleteBookmarkFailure
+  | UpdateBookmark | UpdateBookmarkSuccess | UpdateBookmarkFailure
+  | MoveBookmark | MoveBookmarkSuccess | MoveBookmarkFailure | UpdateBookmarkScrollTop;

package/projects/media-viewer/src/lib/store/actions/document.actions.spec.ts

@@ -0,0 +1,47 @@
+import * as fromDocument from './document.actions';
+
+describe('Document actions', () => {
+
+    it('should create AddPages action', () => {
+      const payload = [{div: {}, scale: 1, rotation: 0, id: '1', viewportScale: 1.333333}];
+      const action = new fromDocument.AddPages(payload);
+      expect({ ...action }).toEqual({
+        type: fromDocument.ADD_PAGES,
+        payload
+      });
+    });
+
+    it('should create Convert action', () => {
+      const payload = 'docId';
+      const action = new fromDocument.Convert(payload);
+      expect({...action}).toEqual({
+        type: fromDocument.CONVERT,
+        payload
+      });
+    });
+
+    it('should create ConvertSuccess', () => {
+      const payload = 'url';
+      const action = new fromDocument.ConvertSuccess(payload);
+      expect({...action}).toEqual({
+        type: fromDocument.CONVERT_SUCCESS,
+        payload
+      });
+    });
+
+    it('should create ConvertFailure', () => {
+      const payload = '';
+      const action = new fromDocument.ConvertFailure(payload);
+      expect({...action}).toEqual({
+        type: fromDocument.CONVERT_FAIL,
+        payload
+      });
+    });
+
+    it('should create ClearConvertDocUrl', () => {
+      const action = new fromDocument.ClearConvertDocUrl();
+      expect({...action}).toEqual({
+        type: fromDocument.CLEAR_CONVERT_DOC_URL
+      });
+    });
+});

package/projects/media-viewer/src/lib/store/actions/document.actions.ts

@@ -0,0 +1,96 @@
+import { Action } from '@ngrx/store';
+import { PageEvent } from '../../viewers/pdf-viewer/pdf-js/pdf-js-wrapper';
+import { Rotation } from '../../viewers/rotation-persist/rotation.model';
+import { PdfPosition } from '../reducers/document.reducer';
+
+export const SET_DOCUMENT_ID = '[Document] Set Document Id';
+export const POSITION_UPDATED = '[Document] Position Updated';
+export const ADD_PAGES = '[Document] Add Pages';
+export const CONVERT = '[Document] Convert';
+export const CONVERT_SUCCESS = '[Document] Convert Success';
+export const CONVERT_FAIL = '[Document] Convert Fail';
+export const CLEAR_CONVERT_DOC_URL = '[Document] Clear Convert Doc Url';
+
+export const LOAD_ROTATION = '[Document] Load Rotation';
+export const LOAD_ROTATION_SUCCESS = '[Document] Load Rotation Success';
+export const LOAD_ROTATION_FAIL = '[Document] Load Rotation Fail';
+export const SAVE_ROTATION = '[Document] Save Rotation';
+export const SAVE_ROTATION_SUCCESS = '[Document] Save Rotation Success';
+export const SAVE_ROTATION_FAIL = '[Document] Save Rotation Fail';
+
+export class SetDocumentId implements Action {
+  readonly type = SET_DOCUMENT_ID;
+  constructor(public payload: string) { }
+}
+
+export class AddPages implements Action {
+  readonly type = ADD_PAGES;
+  constructor(public payload: PageEvent[]) { }
+}
+
+export class PdfPositionUpdate implements Action {
+  readonly type = POSITION_UPDATED;
+  constructor(public payload: PdfPosition) {}
+}
+
+export class Convert implements Action {
+  readonly type = CONVERT;
+  constructor(public payload: string ) {}
+}
+
+export class ConvertSuccess implements Action {
+  readonly type = CONVERT_SUCCESS;
+  constructor(public payload: string ) {}
+}
+
+export class ConvertFailure implements Action {
+  readonly type = CONVERT_FAIL;
+  constructor(public payload: string) {}
+}
+
+export class ClearConvertDocUrl implements Action {
+  readonly type = CLEAR_CONVERT_DOC_URL;
+}
+
+export class LoadRotation implements Action {
+  readonly type = LOAD_ROTATION;
+  constructor(public payload: string) {
+  }
+}
+
+export class LoadRotationSuccess implements Action {
+  readonly type = LOAD_ROTATION_SUCCESS;
+  constructor(public payload: { rotationAngle: number }) {
+  }
+}
+
+export class LoadRotationFailure implements Action {
+  readonly type = LOAD_ROTATION_FAIL;
+  constructor(public payload: Error) {
+  }
+}
+
+export class SaveRotation implements Action {
+  readonly type = SAVE_ROTATION;
+  constructor(public payload: Rotation) {
+  }
+}
+
+export class SaveRotationSuccess implements Action {
+  readonly type = SAVE_ROTATION_SUCCESS;
+  constructor(public payload: { rotationAngle: number }) {
+  }
+}
+
+export class SaveRotationFailure implements Action {
+  readonly type = SAVE_ROTATION_FAIL;
+  constructor(public payload: Error) {
+  }
+}
+
+export type DocumentActions =
+  | AddPages | SetDocumentId | Convert
+  | ConvertSuccess | ConvertFailure | ClearConvertDocUrl
+  | PdfPositionUpdate | LoadRotation | LoadRotationSuccess
+  | LoadRotationFailure | SaveRotation | SaveRotationSuccess
+  | SaveRotationFailure;

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

@@ -0,0 +1,121 @@
+import * as fromIcp from './icp.actions';
+import { IcpParticipant } from '../../icp/icp.interfaces';
+
+describe('Icp actions', () => {
+
+  describe('Set Case Id', () => {
+    it('should create an action', () => {
+      const action = new fromIcp.SetCaseId('caseId');
+      expect({ ...action }).toEqual({
+        type: fromIcp.SET_CASE_ID,
+        payload: 'caseId'
+      });
+    });
+  });
+
+  describe('Load Session', () => {
+    describe('Load Session', () => {
+      it('should create an action', () => {
+        const action = new fromIcp.LoadIcpSession({ caseId: 'caseId', documentId: 'documentId' });
+        expect({ ...action }).toEqual({
+          type: fromIcp.LOAD_ICP_SESSION,
+          payload: { caseId: 'caseId', documentId: 'documentId' }
+        });
+      });
+    });
+
+    describe('Load Session Failure', () => {
+      it('should create an action', () => {
+        const error: any = 'some error';
+        const action = new fromIcp.LoadIcpSessionFailure(error);
+        expect({ ...action }).toEqual({
+          type: fromIcp.LOAD_ICP_SESSION_FAIL,
+          payload: error
+        });
+      });
+    });
+  });
+
+  describe('Join Socket Session ', () => {
+    describe('Join Socket Session', () => {
+      it('should create an action', () => {
+        const payload = {
+          username: 'name',
+          session: {
+            sessionId: 'sessionId',
+            documentId: 'documentId',
+            caseId: 'caseId',
+            dateOfHearing: new Date(),
+            connectionUrl: 'url-connectionstring'
+          }
+        };
+        const action = new fromIcp.JoinIcpSocketSession(payload);
+        expect({ ...action }).toEqual({
+          type: fromIcp.JOIN_ICP_SOCKET_SESSION,
+          payload: payload
+        });
+      });
+
+      describe('Socket Session Joined', () => {
+        it('should create an action', () => {
+          const payload = {
+            participantInfo: {
+              client: {
+                id: 'clientId',
+                username: 'name'
+              },
+              presenter: {
+                id: 'presenterId',
+                username: 'name'
+              },
+            },
+            session: {
+              sessionId: 'sessionId',
+              documentId: 'documentId',
+              caseId: 'caseId',
+              dateOfHearing: new Date(),
+              connectionUrl: 'url-connectionstring'
+            }
+          };
+
+          const action = new fromIcp.IcpSocketSessionJoined(payload);
+          expect({ ...action }).toEqual({
+            type: fromIcp.ICP_SOCKET_SESSION_JOINED,
+            payload: payload
+          });
+        });
+      });
+    });
+  });
+
+  describe('Leave Socket Session', () => {
+    it('should create an action', () => {
+      const action = new fromIcp.LeaveIcpSocketSession();
+      expect({ ...action }).toEqual({
+        type: fromIcp.LEAVE_ICP_SOCKET_SESSION
+      });
+    });
+  });
+
+  describe('Presenter Updated', () => {
+    it('should create an action', () => {
+      const payload: IcpParticipant = { id: 'id', username: 'name' };
+      const action = new fromIcp.IcpPresenterUpdated(payload);
+      expect({ ...action }).toEqual({
+        type: fromIcp.ICP_PRESENTER_UPDATED,
+        payload: payload
+      });
+    });
+  });
+
+  describe('Participant List Updated', () => {
+    it('should create an action', () => {
+      const payload = [{ 'participantId': 'name' }];
+      const action = new fromIcp.IcpParticipantListUpdated(payload);
+      expect({ ...action }).toEqual({
+        type: fromIcp.ICP_PARTICIPANT_LIST_UPDATED,
+        payload: payload
+      });
+    });
+  });
+});

package/projects/media-viewer/src/lib/store/actions/icp.actions.ts

@@ -0,0 +1,61 @@
+import { Action } from '@ngrx/store';
+import { IcpParticipant, IcpSession } from '../../icp/icp.interfaces';
+
+export const SET_CASE_ID = '[Icp] Set Case Id';
+export const LOAD_ICP_SESSION = '[Icp] Load Session';
+export const LOAD_ICP_SESSION_FAIL = '[Icp] Load Session Failure';
+export const JOIN_ICP_SOCKET_SESSION = '[Icp] Join Socket Session';
+export const ICP_SOCKET_SESSION_JOINED = '[Icp] Socket Session Joined';
+export const LEAVE_ICP_SOCKET_SESSION = '[Icp] Leave Socket Session';
+export const ICP_PRESENTER_UPDATED = '[Icp] Presenter Updated';
+export const ICP_PARTICIPANT_LIST_UPDATED = '[Icp] Participant List Updated';
+
+export class SetCaseId implements Action {
+  readonly type = SET_CASE_ID;
+  constructor(public payload: string) { }
+}
+
+export class LoadIcpSession implements Action {
+  readonly type = LOAD_ICP_SESSION;
+  constructor(public payload: { caseId: string, documentId: string }) { }
+}
+
+export class LoadIcpSessionFailure implements Action {
+  readonly type = LOAD_ICP_SESSION_FAIL;
+  constructor(public payload: Error) { }
+}
+
+export class JoinIcpSocketSession implements Action {
+  readonly type = JOIN_ICP_SOCKET_SESSION;
+  constructor(public payload: { username: string, session: IcpSession }) { }
+}
+
+export class IcpSocketSessionJoined implements Action {
+  readonly type = ICP_SOCKET_SESSION_JOINED;
+  constructor(public payload: { session: IcpSession, participantInfo: { client: IcpParticipant, presenter: IcpParticipant } }) { }
+}
+
+export class LeaveIcpSocketSession implements Action {
+  readonly type = LEAVE_ICP_SOCKET_SESSION;
+  constructor() { }
+}
+
+export class IcpPresenterUpdated implements Action {
+  readonly type = ICP_PRESENTER_UPDATED;
+  constructor(public payload: IcpParticipant) { }
+}
+
+export class IcpParticipantListUpdated implements Action {
+  readonly type = ICP_PARTICIPANT_LIST_UPDATED;
+  constructor(public payload: any) { }
+}
+
+export type IcpActions =
+  | SetCaseId
+  | LoadIcpSession
+  | LoadIcpSessionFailure
+  | JoinIcpSocketSession
+  | IcpSocketSessionJoined
+  | LeaveIcpSocketSession
+  | IcpPresenterUpdated
+  | IcpParticipantListUpdated;