[DURACOM-327] Decoupling state management from data service WIP

Author: atarix83

src/app/access-control/epeople-registry/epeople-registry.component.spec.ts

@@ -57,6 +57,7 @@ import {
 import { NotificationsServiceStub } from '../../shared/testing/notifications-service.stub';
 import { PaginationServiceStub } from '../../shared/testing/pagination-service.stub';
 import { EPeopleRegistryComponent } from './epeople-registry.component';
+import { EpeopleRegistryService } from './epeople-registry.service';
 import { EPersonFormComponent } from './eperson-form/eperson-form.component';
 
 describe('EPeopleRegistryComponent', () => {
@@ -66,13 +67,17 @@ describe('EPeopleRegistryComponent', () => {
 
   let mockEPeople: EPerson[];
   let ePersonDataServiceStub: any;
+  let epeopleRegistryServiceStub: any;
   let authorizationService: AuthorizationDataService;
   let modalService: NgbModal;
   let paginationService: PaginationServiceStub;
 
   beforeEach(waitForAsync(async () => {
     jasmine.getEnv().allowRespy(true);
     mockEPeople = [EPersonMock, EPersonMock2];
+    epeopleRegistryServiceStub = jasmine.createSpyObj('', {
+      getActiveEPerson: of(null),
+    });
     ePersonDataServiceStub = {
       activeEPerson: null,
       allEpeople: mockEPeople,
@@ -84,9 +89,6 @@ describe('EPeopleRegistryComponent', () => {
           currentPage: 1,
         }), this.allEpeople));
       },
-      getActiveEPerson(): Observable<EPerson> {
-        return of(this.activeEPerson);
-      },
       searchByScope(scope: string, query: string, options: FindListOptions = {}): Observable<RemoteData<PaginatedList<EPerson>>> {
         if (scope === 'email') {
           const result = this.allEpeople.find((ePerson: EPerson) => {
@@ -155,6 +157,7 @@ describe('EPeopleRegistryComponent', () => {
         TranslateModule.forRoot(), EPeopleRegistryComponent, BtnDisabledDirective],
       providers: [
         { provide: EPersonDataService, useValue: ePersonDataServiceStub },
+        { provide: EpeopleRegistryService, useValue: epeopleRegistryServiceStub },
         { provide: NotificationsService, useValue: new NotificationsServiceStub() },
         { provide: AuthorizationDataService, useValue: authorizationService },
         { provide: FormBuilderService, useValue: builderService },

src/app/access-control/epeople-registry/epeople-registry.component.ts

@@ -61,14 +61,13 @@ import {
   getEPersonEditRoute,
   getEPersonsRoute,
 } from '../access-control-routing-paths';
-import { EPersonFormComponent } from './eperson-form/eperson-form.component';
+import { EpeopleRegistryService } from './epeople-registry.service';
 
 @Component({
   selector: 'ds-epeople-registry',
   templateUrl: './epeople-registry.component.html',
   imports: [
     AsyncPipe,
-    EPersonFormComponent,
     NgClass,
     PaginationComponent,
     ReactiveFormsModule,
@@ -135,6 +134,7 @@ export class EPeopleRegistryComponent implements OnInit, OnDestroy {
   subs: Subscription[] = [];
 
   constructor(private epersonService: EPersonDataService,
+              private epeopleRegistryService: EpeopleRegistryService,
               private translateService: TranslateService,
               private notificationsService: NotificationsService,
               private authorizationService: AuthorizationDataService,
@@ -163,7 +163,7 @@ export class EPeopleRegistryComponent implements OnInit, OnDestroy {
   initialisePage() {
     this.searching$.next(true);
     this.search({ scope: this.currentSearchScope, query: this.currentSearchQuery });
-    this.activeEPerson$ = this.epersonService.getActiveEPerson();
+    this.activeEPerson$ = this.epeopleRegistryService.getActiveEPerson();
     this.subs.push(this.ePeople$.pipe(
       switchMap((epeople: PaginatedList<EPerson>) => {
         if (epeople.pageInfo.totalElements > 0) {

src/app/access-control/epeople-registry/epeople-registry.service.spec.ts

@@ -0,0 +1,66 @@
+import { TestBed } from '@angular/core/testing';
+import { EPerson } from '@core/eperson/models/eperson.model';
+import {
+  MockStore,
+  provideMockStore,
+} from '@ngrx/store/testing';
+import { cold } from 'jasmine-marbles';
+
+import { AppState } from '../../app.reducer';
+import {
+  EPeopleRegistryCancelEPersonAction,
+  EPeopleRegistryEditEPersonAction,
+} from './epeople-registry.actions';
+import {
+  editEPersonSelector,
+  EpeopleRegistryService,
+} from './epeople-registry.service';
+
+describe('EpeopleRegistryService', () => {
+  let service: EpeopleRegistryService;
+  let store: MockStore<AppState>;
+  const initialState = {};
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        EpeopleRegistryService,
+        provideMockStore({ initialState }),
+      ],
+    });
+
+    service = TestBed.inject(EpeopleRegistryService);
+    store = TestBed.inject(MockStore);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  describe('#getActiveEPerson', () => {
+    it('should select the editEPersonSelector from the store', () => {
+      const mockEPerson: EPerson = { id: '123', name: 'Test User' } as EPerson;
+      store.overrideSelector(editEPersonSelector, mockEPerson);
+
+      const expected = cold('a', { a: mockEPerson });
+      expect(service.getActiveEPerson()).toBeObservable(expected);
+    });
+  });
+
+  describe('#cancelEditEPerson', () => {
+    it('should dispatch EPeopleRegistryCancelEPersonAction', () => {
+      const dispatchSpy = spyOn(store, 'dispatch');
+      service.cancelEditEPerson();
+      expect(dispatchSpy).toHaveBeenCalledWith(new EPeopleRegistryCancelEPersonAction());
+    });
+  });
+
+  describe('#editEPerson', () => {
+    it('should dispatch EPeopleRegistryEditEPersonAction with the given EPerson', () => {
+      const dispatchSpy = spyOn(store, 'dispatch');
+      const mockEPerson: EPerson = { id: '456', name: 'Another User' } as EPerson;
+      service.editEPerson(mockEPerson);
+      expect(dispatchSpy).toHaveBeenCalledWith(new EPeopleRegistryEditEPersonAction(mockEPerson));
+    });
+  });
+});

src/app/access-control/epeople-registry/epeople-registry.service.ts

@@ -0,0 +1,66 @@
+import { Injectable } from '@angular/core';
+import { EPerson } from '@core/eperson/models/eperson.model';
+import {
+  createSelector,
+  select,
+  Store,
+} from '@ngrx/store';
+import { Observable } from 'rxjs';
+import { take } from 'rxjs/operators';
+
+import { AppState } from '../../app.reducer';
+import { getEPersonEditRoute } from '../access-control-routing-paths';
+import {
+  EPeopleRegistryCancelEPersonAction,
+  EPeopleRegistryEditEPersonAction,
+} from './epeople-registry.actions';
+import { EPeopleRegistryState } from './epeople-registry.reducers';
+
+const ePeopleRegistryStateSelector = (state: AppState) => state.epeopleRegistry;
+export const editEPersonSelector = createSelector(ePeopleRegistryStateSelector, (ePeopleRegistryState: EPeopleRegistryState) => ePeopleRegistryState.editEPerson);
+
+@Injectable({
+  providedIn: 'root',
+})
+export class EpeopleRegistryService {
+
+  constructor(protected store: Store<AppState>) {
+  }
+
+  /**
+   * Method to retrieve the eperson that is currently being edited
+   */
+  public getActiveEPerson(): Observable<EPerson> {
+    return this.store.pipe(select(editEPersonSelector));
+  }
+
+  /**
+   * Method to cancel editing an EPerson, dispatches a cancel EPerson action
+   */
+  public cancelEditEPerson() {
+    this.store.dispatch(new EPeopleRegistryCancelEPersonAction());
+  }
+
+  /**
+   * Method to set the EPerson being edited, dispatches an edit EPerson action
+   * @param ePerson The EPerson to edit
+   */
+  public editEPerson(ePerson: EPerson) {
+    this.store.dispatch(new EPeopleRegistryEditEPersonAction(ePerson));
+  }
+
+  /**
+   * Change which ePerson is being edited and return the link for EPeople edit page
+   * @param ePerson New EPerson to edit
+   */
+  public startEditingNewEPerson(ePerson: EPerson): string {
+    this.getActiveEPerson().pipe(take(1)).subscribe((activeEPerson: EPerson) => {
+      if (ePerson === activeEPerson) {
+        this.cancelEditEPerson();
+      } else {
+        this.editEPerson(ePerson);
+      }
+    });
+    return getEPersonEditRoute(ePerson.id);
+  }
+}

src/app/access-control/epeople-registry/eperson-form/eperson-form.component.ts

@@ -72,6 +72,7 @@ import { PaginationComponentOptions } from '../../../shared/pagination/paginatio
 import { followLink } from '../../../shared/utils/follow-link-config.model';
 import { HasNoValuePipe } from '../../../shared/utils/has-no-value.pipe';
 import { getEPersonsRoute } from '../../access-control-routing-paths';
+import { EpeopleRegistryService } from '../epeople-registry.service';
 import { ValidateEmailNotTaken } from './validators/email-taken.validator';
 
 @Component({
@@ -239,6 +240,7 @@ export class EPersonFormComponent implements OnInit, OnDestroy {
   constructor(
     protected changeDetectorRef: ChangeDetectorRef,
     public epersonService: EPersonDataService,
+    public epeopleRegistryService: EpeopleRegistryService,
     public groupsDataService: GroupDataService,
     private formBuilderService: FormBuilderService,
     private translateService: TranslateService,
@@ -256,7 +258,7 @@ export class EPersonFormComponent implements OnInit, OnDestroy {
   }
 
   ngOnInit() {
-    this.activeEPerson$ = this.epersonService.getActiveEPerson();
+    this.activeEPerson$ = this.epeopleRegistryService.getActiveEPerson();
     this.subs.push(this.activeEPerson$.subscribe((eperson: EPerson) => {
       this.epersonInitial = eperson;
       if (hasValue(eperson)) {
@@ -274,7 +276,7 @@ export class EPersonFormComponent implements OnInit, OnDestroy {
   initialisePage() {
     if (this.route.snapshot.params.id) {
       this.subs.push(this.epersonService.findById(this.route.snapshot.params.id).subscribe((ePersonRD: RemoteData<EPerson>) => {
-        this.epersonService.editEPerson(ePersonRD.payload);
+        this.epeopleRegistryService.editEPerson(ePersonRD.payload);
       }));
     }
     this.firstName = new DynamicInputModel({
@@ -393,7 +395,7 @@ export class EPersonFormComponent implements OnInit, OnDestroy {
    * Stop editing the currently selected eperson
    */
   onCancel() {
-    this.epersonService.cancelEditEPerson();
+    this.epeopleRegistryService.cancelEditEPerson();
     this.cancelForm.emit();
     void this.router.navigate([getEPersonsRoute()]);
   }

src/app/admin/admin-registries/bitstream-formats/bitstream-format.service.spec.ts

@@ -0,0 +1,61 @@
+import { waitForAsync } from '@angular/core/testing';
+import { BitstreamFormat } from '@core/shared/bitstream-format.model';
+import { createMockStore } from '@ngrx/store/testing';
+
+import {
+  BitstreamFormatsRegistryDeselectAction,
+  BitstreamFormatsRegistryDeselectAllAction,
+  BitstreamFormatsRegistrySelectAction,
+} from './bitstream-format.actions';
+import { BitstreamFormatService } from './bitstream-format.service';
+
+describe('BitstreamFormatDataService', () => {
+  let service: BitstreamFormatService;
+
+  const store: any = createMockStore({});
+
+  function initTestService() {
+    return new BitstreamFormatService(store);
+  }
+
+  describe('selectBitstreamFormat', () => {
+    beforeEach(waitForAsync(() => {
+      service = initTestService();
+      spyOn(store, 'dispatch');
+    }));
+    it('should add a selected bitstream to the store', () => {
+      const format = new BitstreamFormat();
+      format.uuid = 'uuid';
+
+      service.selectBitstreamFormat(format);
+      expect(store.dispatch).toHaveBeenCalledWith(new BitstreamFormatsRegistrySelectAction(format));
+    });
+  });
+
+  describe('deselectBitstreamFormat', () => {
+    beforeEach(waitForAsync(() => {
+      service = initTestService();
+      spyOn(store, 'dispatch');
+    }));
+    it('should remove a bitstream from the store', () => {
+      const format = new BitstreamFormat();
+      format.uuid = 'uuid';
+
+      service.deselectBitstreamFormat(format);
+      expect(store.dispatch).toHaveBeenCalledWith(new BitstreamFormatsRegistryDeselectAction(format));
+    });
+  });
+
+  describe('deselectAllBitstreamFormats', () => {
+    beforeEach(waitForAsync(() => {
+      service = initTestService();
+      spyOn(store, 'dispatch');
+
+    }));
+    it('should remove all bitstreamFormats from the store', () => {
+      service.deselectAllBitstreamFormats();
+      expect(store.dispatch).toHaveBeenCalledWith(new BitstreamFormatsRegistryDeselectAllAction());
+    });
+  });
+
+});

src/app/admin/admin-registries/bitstream-formats/bitstream-format.service.ts

@@ -0,0 +1,65 @@
+import { Injectable } from '@angular/core';
+import { BitstreamFormat } from '@core/shared/bitstream-format.model';
+import {
+  createSelector,
+  select,
+  Store,
+} from '@ngrx/store';
+import { Observable } from 'rxjs';
+
+import { AppState } from '../../../app.reducer';
+import {
+  BitstreamFormatsRegistryDeselectAction,
+  BitstreamFormatsRegistryDeselectAllAction,
+  BitstreamFormatsRegistrySelectAction,
+} from './bitstream-format.actions';
+import { BitstreamFormatRegistryState } from './bitstream-format.reducers';
+
+
+export const bitstreamFormatsStateSelector = (state: AppState) => state.bitstreamFormats;
+const selectedBitstreamFormatSelector = createSelector(
+  bitstreamFormatsStateSelector,
+  (bitstreamFormatRegistryState: BitstreamFormatRegistryState) => bitstreamFormatRegistryState.selectedBitstreamFormats,
+);
+
+/**
+ * A service responsible for fetching/sending data from/to the REST API on the bitstreamformats endpoint
+ */
+@Injectable({ providedIn: 'root' })
+export class BitstreamFormatService {
+
+  constructor(
+    protected store: Store<AppState>,
+  ) {
+  }
+
+  /**
+   * Gets all the selected BitstreamFormats from the store
+   */
+  public getSelectedBitstreamFormats(): Observable<BitstreamFormat[]> {
+    return this.store.pipe(select(selectedBitstreamFormatSelector));
+  }
+
+  /**
+   * Adds a BistreamFormat to the selected BitstreamFormats in the store
+   * @param bitstreamFormat
+   */
+  public selectBitstreamFormat(bitstreamFormat: BitstreamFormat) {
+    this.store.dispatch(new BitstreamFormatsRegistrySelectAction(bitstreamFormat));
+  }
+
+  /**
+   * Removes a BistreamFormat from the list of selected BitstreamFormats in the store
+   * @param bitstreamFormat
+   */
+  public deselectBitstreamFormat(bitstreamFormat: BitstreamFormat) {
+    this.store.dispatch(new BitstreamFormatsRegistryDeselectAction(bitstreamFormat));
+  }
+
+  /**
+   * Removes all BitstreamFormats from the list of selected BitstreamFormats in the store
+   */
+  public deselectAllBitstreamFormats() {
+    this.store.dispatch(new BitstreamFormatsRegistryDeselectAllAction());
+  }
+}