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

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

@@ -1,132 +0,0 @@
-import { Action } from '@ngrx/store';
-import { BulkRedaction, Redaction } from '../../redaction/services/redaction.model';
-import { Annotation } from '../../annotations/annotation-set/annotation-view/annotation.model';
-
-export const LOAD_REDACTIONS = '[Redaction] Load Redaction';
-export const LOAD_REDACTION_SUCCESS = '[Redaction] Load Redaction Success';
-export const LOAD_REDACTION_FAIL = '[Redaction] Load Redaction Fail';
-
-export const SAVE_REDACTION = '[Redaction] Save Redaction';
-export const SAVE_REDACTION_SUCCESS = '[Redaction] Save Redaction Success';
-export const SAVE_REDACTION_FAIL = '[Redaction] Save Redaction Fail';
-
-export const SAVE_BULK_REDACTION = '[Redaction] Save bulk Redaction';
-export const SAVE_BULK_REDACTION_SUCCESS = '[Redaction] Save bulk Redaction Success';
-export const SAVE_BULK_REDACTION_FAIL = '[Redaction] Save bulk Redaction Fail';
-
-export const DELETE_REDACTION = '[Redaction] Delete Redaction';
-export const DELETE_REDACTION_SUCCESS = '[Redaction] Delete Redaction Success';
-export const DELETE_REDACTION_FAIL = '[Redaction] Delete Redaction Fail';
-
-export const SELECT_REDACTION = '[Redaction] Select Redaction';
-
-export const REDACT = '[Redaction] Redact';
-export const REDACT_SUCCESS = '[Redaction] Redact Success';
-export const REDACT_FAIL = '[Redaction] Redact Fail';
-export const RESET_REDACTED_DOCUMENT = '[Redaction] Reset Redacted Document';
-
-export const UNMARK_ALL = '[Redaction] Unmark All';
-export const UNMARK_ALL_SUCCESS = '[Redaction] Unmark All Success';
-
-
-export class LoadRedactions implements Action {
-  readonly type = LOAD_REDACTIONS;
-  constructor(public payload: any) { }
-}
-
-export class LoadRedactionSuccess implements Action {
-  readonly type = LOAD_REDACTION_SUCCESS;
-  constructor(public payload: Redaction[]) { }
-}
-
-export class LoadRedactionFailure implements Action {
-  readonly type = LOAD_REDACTION_FAIL;
-  constructor(public payload: any) { }
-}
-
-export class SaveRedaction implements Action {
-  readonly type = SAVE_REDACTION;
-  constructor(public payload: Redaction) { }
-}
-
-export class SaveRedactionSuccess implements Action {
-  readonly type = SAVE_REDACTION_SUCCESS;
-  constructor(public payload: Redaction) { }
-}
-
-export class SaveRedactionFailure implements Action {
-  readonly type = SAVE_REDACTION_FAIL;
-  constructor(public payload: any) { }
-}
-
-export class SaveBulkRedactionFailure implements Action {
-  readonly type = SAVE_BULK_REDACTION_FAIL;
-  constructor(public payload: any) { }
-}
-
-export class SaveBulkRedaction implements Action {
-  readonly type = SAVE_BULK_REDACTION;
-  constructor(public payload: BulkRedaction) { }
-}
-
-export class SaveBulkRedactionSuccess implements Action {
-  readonly type = SAVE_BULK_REDACTION_SUCCESS;
-  constructor(public payload: BulkRedaction) { }
-}
-
-export class DeleteRedaction implements Action {
-  readonly type = DELETE_REDACTION;
-  constructor(public payload: Annotation) { }
-}
-
-export class DeleteRedactionSuccess implements Action {
-  readonly type = DELETE_REDACTION_SUCCESS;
-  constructor(public payload: any) { }
-}
-
-export class DeleteRedactionFailure implements Action {
-  readonly type = DELETE_REDACTION_FAIL;
-  constructor(public payload: any) { }
-}
-
-export class SelectRedaction implements Action {
-  readonly type = SELECT_REDACTION;
-  constructor(public payload: any) { }
-}
-
-export class Redact implements Action {
-  readonly type = REDACT;
-  constructor(public payload: { redactions: Redaction[], documentId: string }) { }
-}
-
-export class RedactSuccess implements Action {
-  readonly type = REDACT_SUCCESS;
-  constructor(public payload: { blob: Blob, filename: string }) { }
-}
-
-export class RedactFailure implements Action {
-  readonly type = REDACT_FAIL;
-  constructor(public payload: any) { }
-}
-
-export class ResetRedactedDocument implements Action {
-  readonly type = RESET_REDACTED_DOCUMENT;
-}
-
-
-export class UnmarkAll implements Action {
-  readonly type = UNMARK_ALL;
-  constructor(public payload: string) { }
-}
-
-export class UnmarkAllSuccess implements Action {
-  readonly type = UNMARK_ALL_SUCCESS;
-}
-
-export type RedactionActions =
-  | LoadRedactions | LoadRedactionSuccess | LoadRedactionFailure
-  | SaveRedaction | SaveRedactionSuccess | SaveRedactionFailure
-  | DeleteRedaction | DeleteRedactionSuccess | DeleteRedactionFailure
-  | SelectRedaction
-  | Redact | RedactSuccess | RedactFailure | ResetRedactedDocument
-  | UnmarkAll | UnmarkAllSuccess | SaveBulkRedactionSuccess;

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

@@ -1,25 +0,0 @@
-import { Action } from '@ngrx/store';
-import {TagsModel} from '../../annotations/models/tags.model';
-export const UPDATE_TAGS = '[Tags] Update Tags';
-export const ADD_FILTER_TAGS = '[Tags] Add Filter Tags';
-export const CLEAR_FILTER_TAGS = '[Tags] Clear Filter Tags';
-
-export class UpdateTags implements Action {
-  readonly type = UPDATE_TAGS;
-  constructor(public payload: {tags: TagsModel[]; annoId: string}) {}
-}
-
-export class AddFilterTags implements Action {
-  readonly type = ADD_FILTER_TAGS;
-  constructor(public payload: {[id: string]: boolean}) {}
-}
-
-export class ClearFilterTags implements Action {
-  readonly type = CLEAR_FILTER_TAGS;
-}
-
-
-export type TagsActions =
-  | UpdateTags
-  | AddFilterTags
-  | ClearFilterTags;

package/projects/media-viewer/src/lib/store/bookmarks-store-utils.spec.ts

@@ -1,34 +0,0 @@
-import { generateBookmarkEntities, generateBookmarkNodes, getBookmarkChildren } from './bookmarks-store-utils';
-
-describe('bookmarks-store-utils', () => {
-
-  const bookmark1 = {
-    name: 'bookmark 1', xCoordinate: 100, yCoordinate: 50, documentId: 'documentId', id: 'id1'
-  } as any;
-  const bookmark2 = { ...bookmark1, name: 'bookmark 2',  id: 'id2', previous: 'id1' } as any;
-
-  it('should generate bookmark entities', function () {
-    const bookmarkEntities = generateBookmarkEntities([bookmark1, bookmark2]) as any;
-
-    expect(bookmarkEntities).toEqual({ id1: bookmark1, id2: bookmark2 });
-  });
-
-  it('should generate bookmark nodes', function () {
-    const bookmark3 = { ...bookmark1, parent: 'id1', id: 'id3', name: 'bookmark 3' };
-    const parent = { ...bookmark1, children: [ { ...bookmark3, index: 0 } ]};
-    const bookmarkNodes = generateBookmarkNodes({ id1: bookmark1, id2: bookmark2, id3: bookmark3 });
-
-    expect(bookmarkNodes).toEqual([{ ...parent, index: 0 }, { ...bookmark2, index: 1 }]);
-  });
-
-  it('should get bookmark children', function () {
-    const bookmark3 = { ...bookmark1, parent: 'id2', id: 'id3', name: 'bookmark 3' };
-    const parent = { ...bookmark2, previous: undefined, parent: 'id1', children: [bookmark3]};
-    const grandparent = { ...bookmark1, children: [ parent ]};
-
-    const children = getBookmarkChildren(grandparent.children);
-
-    expect(children).toEqual(['id2', 'id3']);
-  });
-
-});

package/projects/media-viewer/src/lib/store/bookmarks-store-utils.ts

@@ -1,54 +0,0 @@
-import { Bookmark } from '../viewers/pdf-viewer/side-bar/bookmarks/bookmarks.interfaces';
-
-export const getBookmarkChildren = (bookmarks: Bookmark[]) => {
-  if (bookmarks) {
-    return bookmarks.reduce((childIds, bookmark) => {
-      if (bookmark.children && bookmark.children.length > 0) {
-        return [...childIds, bookmark.id, ...getBookmarkChildren(bookmark.children)];
-      }
-      return [...childIds, bookmark.id];
-    }, []);
-  } else {
-    return [];
-  }
-};
-
-export const generateBookmarkEntities = (bookmarks: Bookmark[]): {[id: string]: Bookmark} => {
-  return bookmarks.reduce(
-    (bookmarkEntities, bookmark) =>
-      Object.assign(bookmarkEntities, { [bookmark.id]: bookmark }),
-    {});
-};
-
-const indexEntities = (entities: { [id: string]: Bookmark }) => {
-  const entityIds = Object.keys(entities);
-  for (let index = 0; entityIds.length > 0; index++) {
-    let keysToRemove = [];
-    entityIds.forEach(key => {
-      if (!entities[key].previous || !entityIds.includes(entities[key].previous.toString())) {
-        entities[key].index = index;
-        keysToRemove.push(key);
-      }
-    });
-    keysToRemove.forEach(key => entityIds.splice(entityIds.indexOf(key), 1));
-    keysToRemove = [];
-  }
-};
-
-export const generateBookmarkNodes = (entities: { [id: string]: Bookmark }) => {
-  const bookmarkEntities = JSON.parse(JSON.stringify(entities));
-  indexEntities(bookmarkEntities);
-  return Object.keys(bookmarkEntities).reduce((nodes, bookmarkId) => {
-    const bookmarkEntity = bookmarkEntities[bookmarkId];
-    if (bookmarkEntity.parent) {
-      const parentEntity = bookmarkEntities[bookmarkEntity.parent];
-      if (!parentEntity.children) {
-        parentEntity.children = [];
-      }
-      parentEntity.children[bookmarkEntity.index] = bookmarkEntity;
-    } else {
-      nodes[bookmarkEntity.index] = bookmarkEntity;
-    }
-    return nodes;
-  }, []);
-};

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

@@ -1,91 +0,0 @@
-import { HttpClientTestingModule } from '@angular/common/http/testing';
-import { TestBed } from '@angular/core/testing';
-import { hot, cold } from 'jasmine-marbles';
-import { of } from 'rxjs';
-import { provideMockActions } from '@ngrx/effects/testing';
-
-import { mockAnnotations } from 'test/mocks/data/mock-annotations';
-import * as annotationActions from '../actions/annotation.actions';
-import { AnnotationApiService } from '../../annotations/services/annotation-api/annotation-api.service';
-import { AnnotationEffects } from './annotation.effects';
-import { mockAnnotationSet } from 'test/mocks/data/mock-annotation-set';
-
-
-describe('Annotations Effects', () => {
-  let actions$;
-  let effects: AnnotationEffects;
-  const UserServiceMock = jasmine.createSpyObj('AnnotationApiService', [
-    'getAnnotationSet',
-    'postAnnotation',
-    'postAnnotationSet',
-    'deleteAnnotation'
-  ]);
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      imports: [HttpClientTestingModule],
-      providers: [
-        {
-          provide: AnnotationApiService,
-          useValue: UserServiceMock,
-        },
-        AnnotationEffects,
-        provideMockActions(() => actions$)
-      ]
-    });
-
-    effects = TestBed.inject(AnnotationEffects);
-
-  });
-
-  const returnValue: any = {
-      mock1: 'something',
-      mock2: 'something',
-      mock3: 'something',
-      tags: []
-  };
-
-  describe('loadAnnotation$', () => {
-    it('should return a LoadAnnotationSetSuccess', () => {
-      const action = new annotationActions.LoadAnnotationSet('assets/example4.pdf');
-      UserServiceMock.getAnnotationSet.and.returnValue(of({ body: returnValue, status: 200 }));
-      const completion = new annotationActions.LoadAnnotationSetSucess({ body: returnValue, status: 200 });
-      actions$ = hot('-a', { a: action });
-      const expected = cold('-b', { b: completion });
-      expect(effects.loadAnnotation$).toBeObservable(expected);
-    });
-  });
-
-  describe('postAnnotation$', () => {
-    it('should return a SaveAnnotationSuccess', () => {
-      const action = new annotationActions.SaveAnnotation(mockAnnotations[0]);
-      UserServiceMock.postAnnotation.and.returnValue(of(returnValue));
-      const completion = new annotationActions.SaveAnnotationSuccess(returnValue);
-      actions$ = hot('-a', { a: action });
-      const expected = cold('-b', { b: completion });
-      expect(effects.postAnnotation$).toBeObservable(expected);
-    });
-  });
-
-  describe('postAnnotationSet', () => {
-    it('should return a SaveAnnotationSetSuccess', () => {
-      const action = new annotationActions.SaveAnnotationSet(mockAnnotationSet);
-      UserServiceMock.postAnnotationSet.and.returnValue(of(returnValue));
-      const completion = new annotationActions.SaveAnnotationSetSuccess(returnValue);
-      actions$ = hot('-a', { a: action });
-      const expected = cold('-b', { b: completion });
-      expect(effects.saveAnnotationSet$).toBeObservable(expected);
-    });
-  });
-
-  describe('deleteAnnotation$', () => {
-    it('should return a DeleteAnnotationSuccess', () => {
-      const action = new annotationActions.DeleteAnnotation('1bee8923-c936-47f6-9186-52581e4901fd');
-      UserServiceMock.deleteAnnotation.and.returnValue(of('1bee8923-c936-47f6-9186-52581e4901fd'));
-      const completion = new annotationActions.DeleteAnnotationSuccess('1bee8923-c936-47f6-9186-52581e4901fd');
-      actions$ = hot('-a', { a: action });
-      const expected = cold('-b', { b: completion });
-      expect(effects.deleteAnnotation$).toBeObservable(expected);
-    });
-  });
-});

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

@@ -1,76 +0,0 @@
-import { Injectable } from '@angular/core';
-import { Actions, createEffect, ofType } from '@ngrx/effects';
-import { catchError, concatMap, exhaustMap, map, switchMap } from 'rxjs/operators';
-import { of } from 'rxjs';
-import { AnnotationApiService } from '../../annotations/services/annotation-api/annotation-api.service';
-import * as annotationsActions from '../actions/annotation.actions';
-
-@Injectable()
-export class AnnotationEffects {
-  constructor(
-    private actions$: Actions,
-    private annotationApiService: AnnotationApiService,
-  ) { }
-
-  loadAnnotation$ = createEffect(() =>
-    this.actions$.pipe(
-    ofType(annotationsActions.LOAD_ANNOTATION_SET),
-    map((action: annotationsActions.LoadAnnotationSet) => action.payload),
-    switchMap((documentId) => {
-      return this.annotationApiService.getAnnotationSet(documentId).pipe(
-        map(res => {
-          if (res.status === 204) {
-            return new annotationsActions.LoadAnnotationSetFail(res);
-          }
-          return new annotationsActions.LoadAnnotationSetSucess(res);
-        }),
-        catchError(error => {
-          return of(new annotationsActions.LoadAnnotationSetFail(error));
-        }));
-    }))
-  );
-
-  postAnnotation$ = createEffect(() =>
-    this.actions$.pipe(
-    ofType(annotationsActions.SAVE_ANNOTATION),
-    concatMap((action: annotationsActions.SaveAnnotation) => {
-      return this.annotationApiService.postAnnotation(action.payload).pipe(
-        map(annotations => {
-          return new annotationsActions.SaveAnnotationSuccess(annotations);
-        }),
-        catchError(error => {
-          return of(new annotationsActions.LoadAnnotationSetFail(error));
-        }));
-    }))
-  );
-
-  deleteAnnotation$ = createEffect(() =>
-    this.actions$.pipe(
-    ofType(annotationsActions.DELETE_ANNOTATION),
-    map((action: annotationsActions.DeleteAnnotation) => action.payload),
-    exhaustMap((annotation) => {
-      return this.annotationApiService.deleteAnnotation(annotation).pipe(
-        map(result => {
-          return new annotationsActions.DeleteAnnotationSuccess(annotation);
-        }),
-        catchError(error => {
-          return of(new annotationsActions.DeleteAnnotationFail(error));
-        }));
-    }))
-  );
-
-  saveAnnotationSet$ = createEffect(() =>
-    this.actions$.pipe(
-    ofType(annotationsActions.SAVE_ANNOTATION_SET),
-    map((action: annotationsActions.SaveAnnotationSet) => action.payload),
-    switchMap((annotationSet) => {
-      return this.annotationApiService.postAnnotationSet(annotationSet).pipe(
-        map(res => {
-          return new annotationsActions.SaveAnnotationSetSuccess(res);
-        }),
-        catchError(error => {
-          return of(new annotationsActions.SaveAnnotationSetFail(error));
-        }));
-    }))
-  );
-}

package/projects/media-viewer/src/lib/store/effects/bookmarks.effects.spec.ts

@@ -1,145 +0,0 @@
-import { inject, TestBed } from '@angular/core/testing';
-import { cold, hot } from 'jasmine-marbles';
-import { of, throwError } from 'rxjs';
-import { provideMockActions } from '@ngrx/effects/testing';
-import * as bookmarkActions from '../actions/bookmark.actions';
-import { BookmarksEffects } from './bookmarks.effects';
-import { BookmarksApiService } from '../../annotations/services/bookmarks-api/bookmarks-api.service';
-import { Store, StoreModule } from '@ngrx/store';
-import { reducers } from '../reducers/reducers';
-import { PdfPositionUpdate } from '../actions/document.actions';
-
-describe('Bookmark Effects', () => {
-  let actions$;
-  let effects: BookmarksEffects;
-  const bookmarksApi = jasmine.createSpyObj('BookmarksApiService', [
-    'getBookmarks',
-    'createBookmark',
-    'updateBookmark',
-    'updateMultipleBookmarks',
-    'deleteMultipleBookmarks'
-  ]);
-  const bookmark = {
-    name: 'bookmark', xCoordinate: 100, yCoordinate: 50, documentId: 'documentId', id: 'id', pageNumber: 1, zoom: 1
-  } as any;
-  const pdfPosition = { pageNumber: 0, scale: 1, top: 100, left: 100, rotation: 0 };
-  const bookmarkInfo = { xCoordinate: 100, yCoordinate: 50, documentId: 'documentId', pageNumber: 1 };
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      imports: [
-        StoreModule.forFeature('media-viewer', reducers),
-        StoreModule.forRoot({})
-      ],
-      providers: [
-        { provide: BookmarksApiService, useValue: bookmarksApi },
-        BookmarksEffects,
-        provideMockActions(() => actions$)
-      ]
-    });
-    effects = TestBed.inject(BookmarksEffects);
-  });
-
-  describe('getBookmarks$', () => {
-    it('should return a LoadBookmarksSuccess', () => {
-      const bookmarks = [bookmark as any];
-      const payload = { body: bookmarks, status: 200 };
-      const action = new bookmarkActions.LoadBookmarks();
-      bookmarksApi.getBookmarks.and.returnValue(of(payload));
-      const completion = new bookmarkActions.LoadBookmarksSuccess(payload);
-      actions$ = hot('-a', { a: action });
-      const expected = cold('-b', { b: completion });
-      expect(effects.loadBookmarks$).toBeObservable(expected);
-    });
-
-    it('should return a LoadBookmarkFailure', () => {
-      const action = new bookmarkActions.LoadBookmarks();
-      bookmarksApi.getBookmarks.and.returnValue(throwError({body: 'error', status: 400}));
-      const completion = new bookmarkActions.LoadBookmarksFailure({body: 'error', status: 400});
-      actions$ = hot('-a', { a: action });
-      const expected = cold('-b', { b: completion });
-      expect(effects.loadBookmarks$).toBeObservable(expected);
-    });
-  });
-
-  describe('createBookmark$', () => {
-    it('should return a CreateBookmarkSuccess', inject([Store], (store) => {
-      store.dispatch(new PdfPositionUpdate(pdfPosition));
-      const action = new bookmarkActions.CreateBookmark({ ...bookmarkInfo, name: 'new bookmark' } as any);
-      bookmarksApi.createBookmark.and.returnValue(of(bookmark));
-      const completion = new bookmarkActions.CreateBookmarkSuccess(bookmark);
-      actions$ = hot('-a', { a: action });
-      const expected = cold('-b', { b: completion });
-      expect(effects.createBookmark$).toBeObservable(expected);
-    }));
-
-    it('should return a CreateBookmarkFailure', inject([Store], (store) => {
-      const action = new bookmarkActions.CreateBookmark({ ...bookmarkInfo, name: 'new bookmark' } as any);
-      store.dispatch(new PdfPositionUpdate(pdfPosition));
-      bookmarksApi.createBookmark.and.returnValue(throwError(bookmark));
-      const completion = new bookmarkActions.CreateBookmarkFailure(bookmark);
-      actions$ = hot('-a', { a: action });
-      const expected = cold('-b', { b: completion });
-      expect(effects.createBookmark$).toBeObservable(expected);
-    }));
-  });
-
-  describe('moveBookmark$', () => {
-    it('should return MoveBookmarkSuccess', () => {
-      bookmarksApi.updateMultipleBookmarks.and.returnValue(of([{ id: 'bookmarkId'}]));
-      const action = new bookmarkActions.MoveBookmark([{ id: 'bookmarkId'} as any]);
-      const completion = new bookmarkActions.MoveBookmarkSuccess([{ id: 'bookmarkId'} as any]);
-      actions$ = hot('-a', { a: action });
-      const expected = cold('-b', { b: completion });
-      expect(effects.moveBookmark$).toBeObservable(expected);
-    });
-
-    it('should return MoveBookmarkFailure', () => {
-      bookmarksApi.updateMultipleBookmarks.and.returnValue(throwError('failure'));
-      const action = new bookmarkActions.MoveBookmark([{}] as any);
-      const completion = new bookmarkActions.MoveBookmarkFailure('failure');
-      actions$ = hot('-a', { a: action });
-      const expected = cold('-b', { b: completion });
-      expect(effects.moveBookmark$).toBeObservable(expected);
-    });
-  });
-  describe('deleteBookmark$', () => {
-    it('should return a DeleteBookmarkSuccess', () => {
-      bookmarksApi.deleteMultipleBookmarks.and.returnValue(of({}));
-      const action = new bookmarkActions.DeleteBookmark({ deleted: ['bookmarkId'], updated: undefined });
-      const completion = new bookmarkActions.DeleteBookmarkSuccess(['bookmarkId']);
-      actions$ = hot('-a', { a: action });
-      const expected = cold('-b', { b: completion });
-      expect(effects.deleteBookmark$).toBeObservable(expected);
-    });
-
-    it('should return a DeleteBookmarkFailure', () => {
-      bookmarksApi.deleteMultipleBookmarks.and.returnValue(throwError('failure'));
-      const action = new bookmarkActions.DeleteBookmark({ id : 'bookmarkId' } as any);
-      const completion = new bookmarkActions.DeleteBookmarkFailure('failure');
-      actions$ = hot('-a', { a: action });
-      const expected = cold('-b', { b: completion });
-      expect(effects.deleteBookmark$).toBeObservable(expected);
-    });
-  });
-
-  describe('updateBookmark$', () => {
-    it('should return a UpdateBookmarkSuccess', () => {
-      const action = new bookmarkActions.UpdateBookmark(bookmark);
-      bookmarksApi.updateBookmark.and.returnValue(of(bookmark));
-      const completion = new bookmarkActions.UpdateBookmarkSuccess(bookmark);
-      actions$ = hot('-a', { a: action });
-      const expected = cold('-b', { b: completion });
-      expect(effects.updateBookmark$).toBeObservable(expected);
-    });
-
-    it('should return a UpdateBookmarkFailure', () => {
-      const action = new bookmarkActions.UpdateBookmark(bookmark);
-      bookmarksApi.updateBookmark.and.returnValue(throwError(bookmark));
-      const completion = new bookmarkActions.UpdateBookmarkFailure(bookmark);
-      actions$ = hot('-a', { a: action });
-      const expected = cold('-b', { b: completion });
-      expect(effects.updateBookmark$).toBeObservable(expected);
-    });
-  });
-});

package/projects/media-viewer/src/lib/store/effects/bookmarks.effects.ts

@@ -1,93 +0,0 @@
-import { Injectable } from '@angular/core';
-import { Actions, createEffect, ofType } from '@ngrx/effects';
-import { catchError, exhaustMap, map, switchMap, withLatestFrom } from 'rxjs/operators';
-import { of } from 'rxjs';
-import { BookmarksApiService } from '../../annotations/services/bookmarks-api/bookmarks-api.service';
-import * as bookmarksActions from '../actions/bookmark.actions';
-import { select, Store } from '@ngrx/store';
-import * as fromDocument from '../selectors/document.selectors';
-import * as fromBookmarks from '../reducers/bookmarks.reducer';
-import * as fromStore from '../reducers/reducers';
-
-@Injectable()
-export class BookmarksEffects {
-
-  constructor(private actions$: Actions,
-              private store: Store<fromStore.AnnotationSetState|fromBookmarks.BookmarksState>,
-              private bookmarksApiService: BookmarksApiService) {}
-
-  loadBookmarks$ = createEffect(() =>
-    this.actions$.pipe(
-    ofType(bookmarksActions.LOAD_BOOKMARKS),
-    withLatestFrom(this.store.pipe(select(fromDocument.getDocumentId))),
-    map(([, documentId]) => documentId),
-    exhaustMap((documentId) =>
-      this.bookmarksApiService.getBookmarks(documentId)
-        .pipe(
-          map(res => new bookmarksActions.LoadBookmarksSuccess(res)),
-          catchError(err => of(new bookmarksActions.LoadBookmarksFailure(err)))
-        )
-    ))
-  );
-
-  createBookmark$ = createEffect(() =>
-    this.actions$.pipe(
-    ofType(bookmarksActions.CREATE_BOOKMARK),
-    map((action: bookmarksActions.CreateBookmark) => action.payload),
-    exhaustMap((bookmark) =>
-      this.bookmarksApiService.createBookmark(bookmark)
-        .pipe(
-          map(bmrk => new bookmarksActions.CreateBookmarkSuccess(bmrk)),
-          catchError(error => of(new bookmarksActions.CreateBookmarkFailure(error)))
-        )
-    ))
-  );
-
-  moveBookmark$ = createEffect(() =>
-    this.actions$.pipe(
-    ofType(bookmarksActions.MOVE_BOOKMARK),
-    map((action: bookmarksActions.MoveBookmark) => action.payload),
-    exhaustMap((bookmarks) =>
-      this.bookmarksApiService.updateMultipleBookmarks(bookmarks)
-        .pipe(
-          map(bmrks => new bookmarksActions.MoveBookmarkSuccess(bmrks)),
-          catchError(error => of(new bookmarksActions.MoveBookmarkFailure(error)))
-        )
-    ))
-  );
-
-  deleteBookmark$ = createEffect(() =>
-    this.actions$.pipe(
-    ofType(bookmarksActions.DELETE_BOOKMARK),
-    map((action: bookmarksActions.DeleteBookmark) => action.payload),
-    exhaustMap(({ deleted, updated }) =>
-      this.bookmarksApiService.deleteMultipleBookmarks({ deleted, updated })
-        .pipe(
-          switchMap(() => {
-            if (updated) {
-              return [
-                new bookmarksActions.DeleteBookmarkSuccess(deleted),
-                new bookmarksActions.UpdateBookmarkSuccess(updated)
-              ];
-            } else {
-              return [new bookmarksActions.DeleteBookmarkSuccess(deleted)];
-            }
-          }),
-          catchError(error => of(new bookmarksActions.DeleteBookmarkFailure(error)))
-        )
-    ))
-  );
-
-  updateBookmark$ = createEffect(() =>
-    this.actions$.pipe(
-    ofType(bookmarksActions.UPDATE_BOOKMARK),
-    map((action: bookmarksActions.UpdateBookmark) => action.payload),
-    switchMap((bookmark) =>
-      this.bookmarksApiService.updateBookmark(bookmark)
-        .pipe(
-          map(bmrk => new bookmarksActions.UpdateBookmarkSuccess(bmrk)),
-          catchError(error => of(new bookmarksActions.UpdateBookmarkFailure(error)))
-        )
-    ))
-  );
-}