SHIBUI-522 Updated collections to support new structure

ui/src/app/domain/action/filter-collection.action.ts

@@ -4,7 +4,7 @@ import { Update } from '@ngrx/entity';
 
 export enum FilterCollectionActionTypes {
     FIND = '[Metadata Filter] Find',
-    SELECT = '[Metadata Filter] Select',
+    SELECT_FILTER = '[Metadata Filter] Select Request',
     SELECT_FILTER_SUCCESS = '[Metadata Filter] Select Success',
     SELECT_FILTER_FAIL = '[Metadata Filter] Select Fail',
 
@@ -33,7 +33,7 @@ export class FindFilter implements Action {
 }
 
 export class SelectFilter implements Action {
-    readonly type = FilterCollectionActionTypes.SELECT;
+    readonly type = FilterCollectionActionTypes.SELECT_FILTER;
 
     constructor(public payload: string) { }
 }

ui/src/app/domain/domain.type.ts

@@ -4,7 +4,7 @@ import { MetadataProvider } from './model/metadata-provider';
 export * from './model/metadata-provider';
 export * from './model/metadata-filter';
 
-export enum DomainTypes {
+export enum DomainEntityKinds {
     filter = 'filter',
     provider = 'provider'
 }

ui/src/app/domain/effect/entity.effect.spec.ts

@@ -1,16 +1,14 @@
 import { TestBed, tick, fakeAsync } from '@angular/core/testing';
 import { Actions } from '@ngrx/effects';
-import { cold, getTestScheduler, hot } from 'jasmine-marbles';
-import { empty, Observable, of } from 'rxjs';
+import { of } from 'rxjs';
 
 import { TestActions, getActions } from '../../../testing/effect.util';
-import { PreviewEntity } from '../action/entity.action';
 import { EntityEffects } from './entity.effect';
 import { EntityIdService } from '../service/entity-id.service';
 import { EntityDescriptorService } from '../service/entity-descriptor.service';
-import { Filter } from '../entity/filter';
 import { NgbModal } from '@ng-bootstrap/ng-bootstrap';
 import { NgbModalStub } from '../../../testing/modal.stub';
+import { EntityAttributesFilter } from '../entity/entity-attributes.filter';
 
 describe('Entity Effects', () => {
     let effects: EntityEffects;
@@ -50,7 +48,7 @@ describe('Entity Effects', () => {
         it('should open a modal window', fakeAsync(() => {
             spyOn(modal, 'open').and.returnValue({componentInstance: <any>{}});
             spyOn(idService, 'preview').and.returnValue(of('<foo></foo>'));
-            effects.openModal(new Filter());
+            effects.openModal(new EntityAttributesFilter());
             expect(idService.preview).toHaveBeenCalled();
             tick(10);
             expect(modal.open).toHaveBeenCalled();

ui/src/app/domain/effect/entity.effect.ts

@@ -8,7 +8,7 @@ import { map, switchMap, tap } from 'rxjs/operators';
 import { EntityDescriptorService } from '../service/entity-descriptor.service';
 import { MetadataResolverService } from '../service/metadata-resolver.service';
 import { PreviewDialogComponent } from '../../shared/preview/preview-dialog.component';
-import { MetadataEntity, DomainTypes } from '../domain.type';
+import { MetadataEntity, DomainEntityKinds } from '../domain.type';
 import { EntityIdService } from '../service/entity-id.service';
 import * as entityActions from '../action/entity.action';
 
@@ -31,7 +31,7 @@ export class EntityEffects {
     ) { }
 
     openModal(entity: MetadataEntity): void {
-        let request: Observable<string> = entity.type === DomainTypes.filter ?
+        let request: Observable<string> = entity.kind === DomainEntityKinds.filter ?
             this.entityService.preview(entity.entityId) : this.providerService.preview(entity.id);
         request.subscribe(xml => {
             let modal = this.modalService.open(PreviewDialogComponent, {

ui/src/app/domain/effect/filter-collection.effect.ts

@@ -3,16 +3,17 @@ import { Effect, Actions, ofType } from '@ngrx/effects';
 import { Store } from '@ngrx/store';
 import { Router } from '@angular/router';
 
-import { Observable, of } from 'rxjs';
+import { of } from 'rxjs';
 import { switchMap, map, catchError, tap } from 'rxjs/operators';
 
 import * as actions from '../action/filter-collection.action';
-import { FilterCollectionActionTypes, FilterCollectionActionsUnion } from '../action/filter-collection.action';
+import { FilterCollectionActionTypes } from '../action/filter-collection.action';
 import * as fromFilter from '../reducer';
 
 import { MetadataResolverService } from '../service/metadata-resolver.service';
 import { MetadataFilter } from '../../domain/model/metadata-filter';
 import { removeNulls } from '../../shared/util';
+import { EntityAttributesFilter } from '../entity/entity-attributes.filter';
 
 /* istanbul ignore next */
 @Injectable()
@@ -32,15 +33,16 @@ export class FilterCollectionEffects {
     );
     @Effect()
     selectFilterRequest$ = this.actions$.pipe(
-        ofType<actions.SelectFilter>(FilterCollectionActionTypes.SELECT),
+        ofType<actions.SelectFilter>(FilterCollectionActionTypes.SELECT_FILTER),
         map(action => action.payload),
-        switchMap(id =>
-            this.resolverService
+        switchMap(id => {
+            return this.resolverService
                 .find(id)
                 .pipe(
                     map(p => new actions.SelectFilterSuccess(p)),
                     catchError(error => of(new actions.SelectFilterFail(error)))
-                )
+                );
+            }
         )
     );
 
@@ -51,7 +53,7 @@ export class FilterCollectionEffects {
         map(filter => {
             return {
                 ...filter,
-                relyingPartyOverrides: removeNulls(filter.relyingPartyOverrides)
+                relyingPartyOverrides: removeNulls(new EntityAttributesFilter(filter).relyingPartyOverrides)
             };
         }),
         switchMap(unsaved =>

ui/src/app/domain/guard/filter-exists.guard.ts

@@ -38,9 +38,8 @@ export class FilterExistsGuard implements CanActivate {
     }
 
     hasFilterInApi(id: string): Observable<boolean> {
-        return this.mdResolverService.find(id).pipe(
-            map(filterEntity => new FilterActions.LoadFilterSuccess([filterEntity])),
-            tap((action: FilterActions.LoadFilterSuccess) => this.store.dispatch(action)),
+        return this.store.select(fromCollection.getAllFilters).pipe(
+            map(filters => filters.find(f => f.resourceId === id)),
             map(filter => !!filter),
             catchError(() => {
                 this.router.navigate(['/dashboard']);

ui/src/app/domain/reducer/filter-collection.reducer.spec.ts

@@ -1,14 +1,12 @@
 import { reducer } from './filter-collection.reducer';
 import * as fromFilter from './filter-collection.reducer';
-import * as actions from '../action/filter-collection.action';
 import {
-    FilterCollectionActionsUnion,
     FilterCollectionActionTypes,
     LoadFilterSuccess,
     UpdateFilterSuccess,
     SelectFilter
 } from '../action/filter-collection.action';
-import { Filter } from '../entity/filter';
+import { EntityAttributesFilter } from '../entity/entity-attributes.filter';
 
 const snapshot: fromFilter.FilterCollectionState = {
     ids: [],
@@ -39,8 +37,8 @@ describe('Filter Reducer', () => {
         it('should add the loaded filters to the collection', () => {
             spyOn(fromFilter.adapter, 'addAll').and.callThrough();
             const filters = [
-                new Filter({ id: 'foo', createdDate: new Date().toLocaleDateString() }),
-                new Filter({ id: 'bar', createdDate: new Date().toLocaleDateString() })
+                new EntityAttributesFilter({ id: 'foo', createdDate: new Date().toLocaleDateString() }),
+                new EntityAttributesFilter({ id: 'bar', createdDate: new Date().toLocaleDateString() })
             ];
             const action = new LoadFilterSuccess(filters);
             const result = reducer(snapshot, action);
@@ -53,7 +51,7 @@ describe('Filter Reducer', () => {
             spyOn(fromFilter.adapter, 'updateOne').and.callThrough();
             const update = {
                 id: 'foo',
-                changes: new Filter({ id: 'foo', filterName: 'bar', createdDate: new Date().toLocaleDateString() }),
+                changes: new EntityAttributesFilter({ id: 'foo', name: 'bar', createdDate: new Date().toLocaleDateString() }),
             };
             const action = new UpdateFilterSuccess(update);
             const result = reducer(snapshot, action);

ui/src/app/domain/reducer/filter-collection.reducer.ts

@@ -1,8 +1,7 @@
-import { createSelector, createFeatureSelector } from '@ngrx/store';
-import { EntityState, EntityAdapter, createEntityAdapter } from '@ngrx/entity';
-import * as filter from '../action/filter-collection.action';
+import { EntityState, EntityAdapter, createEntityAdapter, Update } from '@ngrx/entity';
 import { FilterCollectionActionTypes, FilterCollectionActionsUnion } from '../action/filter-collection.action';
 import { MetadataFilter } from '../domain.type';
+import { UpdateChanges } from '../../edit-provider/action/editor.action';
 
 export interface FilterCollectionState extends EntityState<MetadataFilter> {
     selectedFilterId: string | null;
@@ -15,7 +14,7 @@ export function sortByDate(a: MetadataFilter, b: MetadataFilter): number {
 
 export const adapter: EntityAdapter<MetadataFilter> = createEntityAdapter<MetadataFilter>({
     sortComparer: sortByDate,
-    selectId: (model: MetadataFilter) => model.id
+    selectId: (model: MetadataFilter) => model.resourceId
 });
 
 export const initialState: FilterCollectionState = adapter.getInitialState({
@@ -26,18 +25,19 @@ export const initialState: FilterCollectionState = adapter.getInitialState({
 export function reducer(state = initialState, action: FilterCollectionActionsUnion): FilterCollectionState {
     switch (action.type) {
         case FilterCollectionActionTypes.LOAD_FILTER_SUCCESS: {
-            return adapter.addAll(action.payload, {
+            let s = adapter.addAll(action.payload, {
                 ...state,
                 selectedFilterId: state.selectedFilterId,
                 loaded: true
             });
+            return s;
         }
 
         case FilterCollectionActionTypes.UPDATE_FILTER_SUCCESS: {
             return adapter.updateOne(action.payload, state);
         }
 
-        case FilterCollectionActionTypes.SELECT: {
+        case FilterCollectionActionTypes.SELECT_FILTER: {
             return {
                 ...state,
                 selectedFilterId: action.payload,

ui/src/app/domain/service/metadata-resolver.service.spec.ts

@@ -1,10 +1,9 @@
 import { TestBed, async, inject } from '@angular/core/testing';
-import { EntityValidators } from './entity-validators.service';
-import { Observable } from 'rxjs';
+import { HttpTestingController, HttpClientTestingModule } from '@angular/common/http/testing';
 import { HttpClientModule, HttpRequest } from '@angular/common/http';
 import { MetadataResolverService } from './metadata-resolver.service';
-import { HttpTestingController, HttpClientTestingModule } from '@angular/common/http/testing';
-import { Filter } from '../entity/filter';
+import { EntityAttributesFilter } from '../entity/entity-attributes.filter';
+
 
 describe(`Metadata Resolver Service`, () => {
 
@@ -49,7 +48,7 @@ describe(`Metadata Resolver Service`, () => {
         it(`should send an expected PUT request`, async(inject([MetadataResolverService, HttpTestingController],
             (service: MetadataResolverService, backend: HttpTestingController) => {
                 const id = 'foo';
-                const filter = new Filter({id});
+                const filter = new EntityAttributesFilter({id});
                 service.update(filter).subscribe();
 
                 backend.expectOne((req: HttpRequest<any>) => {
@@ -63,7 +62,7 @@ describe(`Metadata Resolver Service`, () => {
         it(`should send an expected POST request`, async(inject([MetadataResolverService, HttpTestingController],
             (service: MetadataResolverService, backend: HttpTestingController) => {
                 const id = 'foo';
-                const filter = new Filter({ id });
+                const filter = new EntityAttributesFilter({ id });
                 service.save(filter).subscribe();
 
                 backend.expectOne((req: HttpRequest<any>) => {

ui/src/app/domain/service/metadata-resolver.service.ts

@@ -1,29 +1,25 @@
 
 import { Injectable } from '@angular/core';
-import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
-import { Observable, throwError } from 'rxjs';
-import { catchError } from 'rxjs/operators';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
 
 import { MetadataFilter } from '../../domain/model/metadata-filter';
-import { MOCK_DESCRIPTORS } from '../../../data/descriptors.mock';
-import { Storage } from '../../shared/storage';
-import { environment } from '../../../environments/environment';
-import { Filter } from '../entity/filter';
 
 @Injectable()
 export class MetadataResolverService {
 
-    readonly endpoint = '/MetadataResolver/incommon/Filter';
+    readonly endpoint = '/MetadataResolver/incommon/Filters';
     readonly base = '/api';
 
     constructor(
         private http: HttpClient
     ) {}
     query(): Observable<MetadataFilter[]> {
-        return this.http.get<MetadataFilter[]>(`${this.base}${this.endpoint}s`, {});
+        return this.http.get<MetadataFilter[]>(`${this.base}${this.endpoint}`, {});
     }
 
     find(id: string): Observable<MetadataFilter> {
+        // console.log(id);
         return this.http.get<MetadataFilter>(`${this.base}${this.endpoint}/${id}`);
     }