SHIBUI-580 Fixed issues with saving provider

TIER · Jul 5, 2018 · f357ea4 · f357ea4
1 parent 2f1e1d7
commit f357ea4
Show file tree

Hide file tree

Showing 19 changed files with 354 additions and 96 deletions.
diff --git a/ui/src/app/metadata/domain/domain.module.ts b/ui/src/app/metadata/domain/domain.module.ts
@@ -12,6 +12,7 @@ import { EntityDraftService } from './service/draft.service';
 import { MetadataProviderService } from './service/provider.service';
 import { EntityEffects } from './effect/entity.effect';
 import { PreviewDialogComponent } from './component/preview-dialog.component';
+import { MetadataFilterService } from './service/filter.service';
 
 export const COMPONENTS = [
     PreviewDialogComponent
@@ -42,7 +43,8 @@ export class DomainModule {
                 ListValuesService,
                 ProviderStatusEmitter,
                 ProviderValueEmitter,
-                MetadataProviderService
+                MetadataProviderService,
+                MetadataFilterService
             ]
         };
     }

diff --git a/ui/src/app/metadata/domain/model/metadata-provider.ts b/ui/src/app/metadata/domain/model/metadata-provider.ts
@@ -1,16 +1,10 @@
 import {
     MetadataBase,
-    Organization,
-    Contact,
-    MDUI,
-    SecurityInfo,
-    SsoService,
-    IdpSsoDescriptor,
-    LogoutEndpoint,
-    RelyingPartyOverrides
 } from '../model';
 
 export interface MetadataProvider extends MetadataBase {
     name: string;
     '@type': string;
+    enabled: boolean;
+    resourceId: string;
 }
diff --git a/ui/src/app/metadata/domain/service/filter.service.ts b/ui/src/app/metadata/domain/service/filter.service.ts
@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+import { MetadataFilter } from '../../domain/model';
+
+@Injectable()
+export class MetadataFilterService {
+
+    readonly endpoint = '/MetadataResolvers';
+    readonly base = '/api';
+
+    constructor(
+        private http: HttpClient
+    ) { }
+    query(): Observable<MetadataFilter[]> {
+        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}`);
+    }
+
+    update(filter: MetadataFilter): Observable<MetadataFilter> {
+        return this.http.put<MetadataFilter>(`${this.base}${this.endpoint}/${filter.id}`, filter);
+    }
+
+    save(filter: MetadataFilter): Observable<MetadataFilter> {
+        return this.http.post<MetadataFilter>(`${this.base}${this.endpoint}`, filter);
+    }
+}
diff --git a/ui/src/app/metadata/domain/service/provider.service.ts b/ui/src/app/metadata/domain/service/provider.service.ts
@@ -2,31 +2,33 @@ import { Injectable } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
 
-import { MetadataFilter } from '../../domain/model';
+import { MetadataProvider } from '../../domain/model';
+import { FileBackedHttpMetadataProvider } from '../model/providers';
 
 @Injectable()
 export class MetadataProviderService {
 
-    readonly endpoint = '/MetadataResolver/incommon/Filters';
+    readonly endpoint = '/MetadataResolvers';
     readonly base = '/api';
 
     constructor(
         private http: HttpClient
     ) {}
-    query(): Observable<MetadataFilter[]> {
-        return this.http.get<MetadataFilter[]>(`${this.base}${this.endpoint}`, {});
+    query(): Observable<MetadataProvider[]> {
+        return this.http.get<MetadataProvider[]>(`${this.base}${this.endpoint}`, {});
     }
 
-    find(id: string): Observable<MetadataFilter> {
+    find(id: string): Observable<MetadataProvider> {
         // console.log(id);
-        return this.http.get<MetadataFilter>(`${this.base}${this.endpoint}/${id}`);
+        return this.http.get<MetadataProvider>(`${this.base}${this.endpoint}/${id}`);
     }
 
-    update(filter: MetadataFilter): Observable<MetadataFilter> {
-        return this.http.put<MetadataFilter>(`${this.base}${this.endpoint}/${filter.id}`, filter);
+    update(provider: MetadataProvider): Observable<MetadataProvider> {
+        return this.http.put<MetadataProvider>(`${this.base}${this.endpoint}/${provider.id}`, provider);
     }
 
-    save(filter: MetadataFilter): Observable<MetadataFilter> {
-        return this.http.post<MetadataFilter>(`${this.base}${this.endpoint}`, filter);
+    save(provider: MetadataProvider): Observable<MetadataProvider> {
+        const { metadataFilters, id, ...pruned } = provider as FileBackedHttpMetadataProvider;
+        return this.http.post<MetadataProvider>(`${this.base}${this.endpoint}`, pruned);
     }
 }
diff --git a/ui/src/app/metadata/filter/effect/collection.effect.ts b/ui/src/app/metadata/filter/effect/collection.effect.ts
@@ -9,11 +9,10 @@ import { switchMap, map, catchError, tap } from 'rxjs/operators';
 import * as actions from '../action/collection.action';
 import { FilterCollectionActionTypes } from '../action/collection.action';
 import * as fromFilter from '../reducer';
-
-import { MetadataProviderService } from '../../domain/service/provider.service';
 import { MetadataFilter } from '../../domain/model';
 import { removeNulls } from '../../../shared/util';
 import { EntityAttributesFilter } from '../../domain/entity/filter/entity-attributes-filter';
+import { MetadataFilterService } from '../../domain/service/filter.service';
 
 /* istanbul ignore next */
 @Injectable()
@@ -23,7 +22,7 @@ export class FilterCollectionEffects {
     loadFilters$ = this.actions$.pipe(
         ofType<actions.LoadFilterRequest>(FilterCollectionActionTypes.LOAD_FILTER_REQUEST),
         switchMap(() =>
-            this.resolverService
+            this.filterService
                 .query()
                 .pipe(
                     map(filters => new actions.LoadFilterSuccess(filters)),
@@ -36,7 +35,7 @@ export class FilterCollectionEffects {
         ofType<actions.SelectFilter>(FilterCollectionActionTypes.SELECT_FILTER),
         map(action => action.payload),
         switchMap(id => {
-            return this.resolverService
+            return this.filterService
                 .find(id)
                 .pipe(
                     map(p => new actions.SelectFilterSuccess(p)),
@@ -57,7 +56,7 @@ export class FilterCollectionEffects {
             };
         }),
         switchMap(unsaved =>
-            this.resolverService
+            this.filterService
                 .save(unsaved as MetadataFilter)
                 .pipe(
                     map(saved => new actions.AddFilterSuccess(saved)),
@@ -86,7 +85,7 @@ export class FilterCollectionEffects {
         switchMap(filter => {
             delete filter.modifiedDate;
             delete filter.createdDate;
-            return this.resolverService
+            return this.filterService
                 .update(filter)
                 .pipe(
                     map(p => new actions.UpdateFilterSuccess({
@@ -113,7 +112,7 @@ export class FilterCollectionEffects {
     constructor(
         private actions$: Actions,
         private router: Router,
-        private resolverService: MetadataProviderService,
+        private filterService: MetadataFilterService,
         private store: Store<fromFilter.State>
     ) { }
 }
diff --git a/ui/src/app/metadata/provider/action/collection.action.ts b/ui/src/app/metadata/provider/action/collection.action.ts
@@ -0,0 +1,112 @@
+import { Action } from '@ngrx/store';
+import { MetadataProvider } from '../../domain/model/metadata-provider';
+import { Update } from '@ngrx/entity';
+
+export enum ProviderCollectionActionTypes {
+    FIND = '[Metadata Provider] Find',
+    SELECT_PROVIDER = '[Metadata Provider] Select Request',
+    SELECT_PROVIDER_SUCCESS = '[Metadata Provider] Select Success',
+    SELECT_PROVIDER_FAIL = '[Metadata Provider] Select Fail',
+
+    UPDATE_PROVIDER_REQUEST = '[Metadata Provider] Update Request',
+    UPDATE_PROVIDER_SUCCESS = '[Metadata Provider] Update Success',
+    UPDATE_PROVIDER_FAIL = '[Metadata Provider] Update Fail',
+
+    LOAD_PROVIDER_REQUEST = '[Metadata Provider Collection] Provider REQUEST',
+    LOAD_PROVIDER_SUCCESS = '[Metadata Provider Collection] Provider SUCCESS',
+    LOAD_PROVIDER_ERROR = '[Metadata Provider Collection] Provider ERROR',
+
+    ADD_PROVIDER_REQUEST = '[Metadata Provider Collection] Add Provider',
+    ADD_PROVIDER_SUCCESS = '[Metadata Provider Collection] Add Provider Success',
+    ADD_PROVIDER_FAIL = '[Metadata Provider Collection] Add Provider Fail',
+
+    REMOVE_PROVIDER_REQUEST = '[Metadata Provider Collection] Remove Provider Request',
+    REMOVE_PROVIDER_SUCCESS = '[Metadata Provider Collection] Remove Provider Success',
+    REMOVE_PROVIDER_FAIL = '[Metadata Provider Collection] Remove Provider Fail'
+}
+
+export class LoadProviderRequest implements Action {
+    readonly type = ProviderCollectionActionTypes.LOAD_PROVIDER_REQUEST;
+
+    constructor() { }
+}
+
+export class LoadProviderSuccess implements Action {
+    readonly type = ProviderCollectionActionTypes.LOAD_PROVIDER_SUCCESS;
+
+    constructor(public payload: MetadataProvider[]) { }
+}
+
+export class LoadProviderError implements Action {
+    readonly type = ProviderCollectionActionTypes.LOAD_PROVIDER_ERROR;
+
+    constructor(public payload: any) { }
+}
+
+export class UpdateProviderRequest implements Action {
+    readonly type = ProviderCollectionActionTypes.UPDATE_PROVIDER_REQUEST;
+
+    constructor(public payload: MetadataProvider) { }
+}
+
+export class UpdateProviderSuccess implements Action {
+    readonly type = ProviderCollectionActionTypes.UPDATE_PROVIDER_SUCCESS;
+
+    constructor(public payload: Update<MetadataProvider>) { }
+}
+
+export class UpdateProviderFail implements Action {
+    readonly type = ProviderCollectionActionTypes.UPDATE_PROVIDER_FAIL;
+
+    constructor(public payload: MetadataProvider) { }
+}
+
+export class AddProviderRequest implements Action {
+    readonly type = ProviderCollectionActionTypes.ADD_PROVIDER_REQUEST;
+
+    constructor(public payload: MetadataProvider) { }
+}
+
+export class AddProviderSuccess implements Action {
+    readonly type = ProviderCollectionActionTypes.ADD_PROVIDER_SUCCESS;
+
+    constructor(public payload: MetadataProvider) { }
+}
+
+export class AddProviderFail implements Action {
+    readonly type = ProviderCollectionActionTypes.ADD_PROVIDER_FAIL;
+
+    constructor(public payload: any) { }
+}
+
+export class RemoveProviderRequest implements Action {
+    readonly type = ProviderCollectionActionTypes.REMOVE_PROVIDER_REQUEST;
+
+    constructor(public payload: MetadataProvider) { }
+}
+
+export class RemoveProviderSuccess implements Action {
+    readonly type = ProviderCollectionActionTypes.REMOVE_PROVIDER_SUCCESS;
+
+    constructor(public payload: MetadataProvider) { }
+}
+
+export class RemoveProviderFail implements Action {
+    readonly type = ProviderCollectionActionTypes.REMOVE_PROVIDER_FAIL;
+
+    constructor(public payload: MetadataProvider) { }
+}
+
+export type ProviderCollectionActionsUnion =
+    | LoadProviderRequest
+    | LoadProviderSuccess
+    | LoadProviderError
+    | AddProviderRequest
+    | AddProviderSuccess
+    | AddProviderFail
+    | RemoveProviderRequest
+    | RemoveProviderSuccess
+    | RemoveProviderFail
+    | UpdateProviderRequest
+    | UpdateProviderSuccess
+    | UpdateProviderFail;
diff --git a/ui/src/app/metadata/provider/action/entity.action.ts b/ui/src/app/metadata/provider/action/entity.action.ts
@@ -3,12 +3,7 @@ import { MetadataProvider } from '../../domain/model';
 
 export enum EntityActionTypes {
     SELECT_PROVIDER = '[Provider Entity] Select Provider',
-    CREATE_PROVIDER = '[Provider Entity] Create Provider',
     UPDATE_PROVIDER = '[Provider Entity] Update Provider',
-    SAVE_PROVIDER_REQUEST = '[Provider Entity] Save Provider Request',
-    SAVE_PROVIDER_SUCCESS = '[Provider Entity] Save Provider Success',
-    SAVE_PROVIDER_FAIL = '[Provider Entity] Save Provider Fail',
-
     CLEAR_PROVIDER = '[Provider Entity] Clear',
     RESET_CHANGES = '[Provider Entity] Reset Changes'
 }
@@ -19,36 +14,12 @@ export class SelectProvider implements Action {
     constructor(public payload: MetadataProvider) { }
 }
 
-export class CreateProvider implements Action {
-    readonly type = EntityActionTypes.CREATE_PROVIDER;
-
-    constructor(public payload: MetadataProvider) { }
-}
-
 export class UpdateProvider implements Action {
     readonly type = EntityActionTypes.UPDATE_PROVIDER;
 
     constructor(public payload: Partial<MetadataProvider>) { }
 }
 
-export class SaveProviderRequest implements Action {
-    readonly type = EntityActionTypes.SAVE_PROVIDER_REQUEST;
-
-    constructor(public payload: MetadataProvider) { }
-}
-
-export class SaveProviderSuccess implements Action {
-    readonly type = EntityActionTypes.SAVE_PROVIDER_SUCCESS;
-
-    constructor(public payload: MetadataProvider) { }
-}
-
-export class SaveProviderFail implements Action {
-    readonly type = EntityActionTypes.SAVE_PROVIDER_FAIL;
-
-    constructor(public payload: Error) { }
-}
-
 export class ClearProvider implements Action {
     readonly type = EntityActionTypes.CLEAR_PROVIDER;
 }
@@ -60,9 +31,5 @@ export class ResetChanges implements Action {
 export type EntityActionUnion =
     | SelectProvider
     | UpdateProvider
-    | SaveProviderRequest
-    | SaveProviderSuccess
-    | SaveProviderFail
-    | CreateProvider
     | ClearProvider
     | ResetChanges;
diff --git a/ui/src/app/metadata/provider/container/provider-wizard.component.ts b/ui/src/app/metadata/provider/container/provider-wizard.component.ts
@@ -12,6 +12,7 @@ import { MetadataProvider } from '../../domain/model';
 import { ClearProvider } from '../action/entity.action';
 import { Router, ActivatedRoute } from '@angular/router';
 import { map } from 'rxjs/operators';
+import { AddProviderRequest } from '../action/collection.action';
 
 
 @Component({
@@ -32,6 +33,16 @@ export class ProviderWizardComponent implements OnDestroy {
 
     summary$: Observable<{ definition: Wizard<MetadataProvider>, schema: { [id: string]: any }, model: any }>;
 
+    provider: MetadataProvider;
+
+    namesList: string[] = [];
+
+    validators = {
+        '/name': (value, property, form) => {
+            return this.namesList.indexOf(value) > -1 ? { 'name': { 'expectedValue': 'unique' } } : null;
+        }
+    };
+
     constructor(
         private store: Store<fromProvider.ProviderState>,
         private router: Router,
@@ -62,6 +73,10 @@ export class ProviderWizardComponent implements OnDestroy {
         ).pipe(
             map(([ definition, schema, model ]) => ({ definition, schema, model }))
         );
+
+        this.changes$.subscribe(c => this.provider = c);
+
+        this.store.select(fromProvider.getProviderNames).subscribe(list => this.namesList = list);
     }
 
     ngOnDestroy() {
@@ -81,7 +96,7 @@ export class ProviderWizardComponent implements OnDestroy {
     }
 
     save(): void {
-        console.log('Save!');
+        this.store.dispatch(new AddProviderRequest(this.provider));
     }
 
     gotoPage(page: string): void {