SHIBUI-1521 Fixed issue with entity id validation

ui/src/app/app.component.ts

@@ -51,17 +51,5 @@ export class AppComponent implements OnInit {
         this.store.dispatch(new UserLoadRequestAction());
         this.store.dispatch(new VersionInfoLoadRequestAction());
         this.store.dispatch(new SetLocale(this.i18nService.getCurrentLocale()));
-
-        /*
-        this.router
-            .events
-            .pipe(
-                catchError(err => {
-                    console.error(err);
-                    return err;
-                })
-            )
-            .subscribe((ev) => console.log(ev));
-        */
     }
 }

ui/src/app/metadata/resolver/container/new-resolver.component.spec.ts

@@ -7,7 +7,6 @@ import { APP_BASE_HREF } from '@angular/common';
 import { StoreModule, Store } from '@ngrx/store';
 import { NewResolverComponent } from './new-resolver.component';
 
-import { BlankResolverComponent } from './blank-resolver.component';
 import { UploadResolverComponent } from './upload-resolver.component';
 import { CopyResolverComponent } from './copy-resolver.component';
 import { SharedModule } from '../../../shared/shared.module';
@@ -37,7 +36,6 @@ describe('New Resolver Page', () => {
             ],
             declarations: [
                 NewResolverComponent,
-                BlankResolverComponent,
                 UploadResolverComponent,
                 CopyResolverComponent
             ],

ui/src/app/metadata/resolver/container/resolver-wizard-step.component.ts

@@ -1,5 +1,5 @@
 import { Component, OnDestroy } from '@angular/core';
-import { Observable, Subject } from 'rxjs';
+import { Observable, Subject, combineLatest } from 'rxjs';
 import { withLatestFrom, map, distinctUntilChanged, skipWhile, filter } from 'rxjs/operators';
 import { Store } from '@ngrx/store';
 
@@ -64,14 +64,17 @@ export class ResolverWizardStepComponent implements OnDestroy {
             map(({ model, definition }) => definition.formatter(model))
         );
 
-        this.validators$ = this.definition$.pipe(
-            withLatestFrom(
-                this.store.select(fromResolver.getAllEntityIds),
-                this.model$
-            ),
-            map(([def, ids, resolver]) => def.getValidators(
-                ids.filter(id => id !== resolver.entityId)
-            ))
+        this.validators$ = combineLatest(
+            this.definition$,
+            this.store.select(fromResolver.getValidEntityIds),
+            this.model$
+        ).pipe(
+            map(([def, ids, resolver]) => {
+                console.log(resolver);
+                return def.getValidators(
+                    ids
+                );
+            })
         );
 
         this.valueChangeEmitted$.pipe(

ui/src/app/metadata/resolver/reducer/collection.reducer.spec.ts

@@ -13,14 +13,16 @@ snapshot: fromCollection.CollectionState = {
         [resolvers[0].id]: resolvers[0],
         [resolvers[1].id]: resolvers[1]
     },
-    selectedResolverId: null
+    selectedResolverId: null,
+    loading: false
 };
 
 describe('Resolver Reducer', () => {
     const initialState: fromCollection.CollectionState = {
         ids: [],
         entities: {},
         selectedResolverId: null,
+        loading: false
     };
 
     describe('undefined action', () => {

ui/src/app/metadata/resolver/reducer/collection.reducer.ts

@@ -4,6 +4,7 @@ import { ResolverCollectionActionsUnion, ResolverCollectionActionTypes } from '.
 
 export interface CollectionState extends EntityState<MetadataResolver> {
     selectedResolverId: string | null;
+    loading: boolean;
 }
 
 export function sortByDate(a: MetadataResolver, b: MetadataResolver): number {
@@ -16,14 +17,22 @@ export const adapter: EntityAdapter<MetadataResolver> = createEntityAdapter<Meta
 });
 
 export const initialState: CollectionState = adapter.getInitialState({
-    selectedResolverId: null
+    selectedResolverId: null,
+    loading: false
 });
 
 export function reducer(state = initialState, action: ResolverCollectionActionsUnion): CollectionState {
     switch (action.type) {
+        case ResolverCollectionActionTypes.LOAD_RESOLVER_REQUEST: {
+            return {
+                ...state,
+                loading: true
+            };
+        }
         case ResolverCollectionActionTypes.LOAD_RESOLVER_SUCCESS: {
             return adapter.addAll(action.payload, {
                 ...state,
+                loading: false,
                 selectedResolverId: state.selectedResolverId
             });
         }
@@ -41,7 +50,8 @@ export function reducer(state = initialState, action: ResolverCollectionActionsU
 
         case ResolverCollectionActionTypes.LOAD_RESOLVER_ERROR: {
             return adapter.removeAll({
-                ...state
+                ...state,
+                loading: false
             });
         }
 
@@ -71,3 +81,5 @@ export const {
     selectAll: selectAllResolvers,
     selectTotal: selectResolverTotal
 } = adapter.getSelectors();
+
+export const getResolversLoading = (state: CollectionState) => state.loading;

ui/src/app/metadata/resolver/reducer/index.spec.ts

@@ -0,0 +1,40 @@
+import {
+    getResolverEntityIdCollectionFn,
+    getAllOtherIdsFn,
+    getResolverUniqueValidEntityIdsFn
+} from './index';
+
+describe('Resolver Reducer selectors', () => {
+    describe(`getResolverEntityIdCollectionFn function`, () => {
+        it('should return a list of entity ids', () => {
+
+            const resolvers = [
+                {
+                    entityId: 'foo'
+                },
+                {
+                    entityId: 'bar'
+                },
+                {
+                    entityId: 'baz'
+                }
+            ];
+
+            expect(getResolverEntityIdCollectionFn(resolvers)).toEqual(['foo', 'bar', 'baz']);
+        });
+    });
+
+    describe('getResolverUniqueValidEntityIdsFn function', () => {
+        it('should return a unique and valid list of ids from the provided list', () => {
+            const ids = ['foo', undefined, undefined, 'foo', 'bar'];
+            expect(getResolverUniqueValidEntityIdsFn(ids)).toEqual(['foo', 'bar']);
+        });
+    });
+
+    describe('getAllOtherIdsFn function', () => {
+        it('should return a list of ids without the selected', () => {
+            const ids = ['foo', 'bar', 'baz'];
+            expect(getAllOtherIdsFn(ids, 'foo')).toEqual(['bar', 'baz']);
+        });
+    });
+});

ui/src/app/metadata/resolver/reducer/index.ts

@@ -81,7 +81,10 @@ export const getSelectedResolverId = createSelector(getCollectionState, fromColl
 export const getResolverIds = createSelector(getCollectionState, fromCollection.selectResolverIds);
 
 export const getResolverCollection = createSelector(getCollectionState, getResolverIds, fromCollection.selectAllResolvers);
+export const getResolverEntityIdCollectionFn = (resolvers) => resolvers.map(r => r.entityId);
+export const getResolverEntityIdCollection = createSelector(getResolverCollection, getResolverEntityIdCollectionFn);
 export const getSelectedResolver = createSelector(getResolverEntities, getSelectedResolverId, getInCollectionFn);
+export const getResolversLoading = createSelector(getCollectionState, fromCollection.getResolversLoading);
 
 
 /*
@@ -105,11 +108,15 @@ export const getAllResolvers = createSelector(getDraftCollection, getResolverCol
 export const getAllResolverIds = createSelector(getDraftIds, getResolverIds, combineAllFn);
 
 export const getAllEntityIds = createSelector(getAllResolvers, getEntityIdsFn);
+export const getResolverUniqueValidEntityIdsFn = (ids) => [...new Set(ids.filter(id => !!id))];
+export const getValidEntityIds = createSelector(getResolverEntityIdCollection, getResolverUniqueValidEntityIdsFn);
+
+export const getAllOtherIdsFn = (ids, selected) => ids.filter(id => id !== selected);
 
 export const getAllOtherIds = createSelector(
     getAllResolvers,
     getSelectedResolverId,
-    (ids, selected) => ids.filter(id => id !== selected)
+    getAllOtherIdsFn
 );
 
 export const getDraftModelWithChanges = createSelector(

ui/src/app/metadata/resolver/resolver.component.ts

@@ -1,22 +1,25 @@
 import { Component, ChangeDetectionStrategy } from '@angular/core';
 import { Store } from '@ngrx/store';
-
+import { Observable } from 'rxjs';
 import { LoadResolverRequest } from './action/collection.action';
-import { LoadDraftRequest } from './action/draft.action';
 import * as fromRoot from '../../app.reducer';
+import * as fromResolver from './reducer';
 
 @Component({
     selector: 'metadata-resolver-page',
     changeDetection: ChangeDetectionStrategy.OnPush,
-    template: '<router-outlet></router-outlet>',
+    template: `<ng-container *ngIf="!(loading$ | async)">
+        <router-outlet></router-outlet>
+    <ng-container>`,
     styleUrls: []
 })
 export class MetadataResolverPageComponent {
 
+    loading$: Observable<boolean> = this.store.select(fromResolver.getResolversLoading);
+
     constructor(
         private store: Store<fromRoot.State>
     ) {
-        // this.store.dispatch(new LoadResolverRequest());
-        // this.store.dispatch(new LoadDraftRequest());
+        this.store.dispatch(new LoadResolverRequest());
     }
 }

ui/src/app/metadata/resolver/resolver.module.ts

@@ -9,7 +9,6 @@ import { NgbDropdownModule, NgbPopoverModule, NgbModalModule } from '@ng-bootstr
 
 import { NewResolverComponent } from './container/new-resolver.component';
 import { UploadResolverComponent } from './container/upload-resolver.component';
-import { BlankResolverComponent } from './container/blank-resolver.component';
 import { CopyResolverComponent } from './container/copy-resolver.component';
 import { SharedModule } from '../../shared/shared.module';
 import { SearchIdEffects } from './effect/search.effect';
@@ -42,7 +41,6 @@ import { MetadataConfigurationModule } from '../configuration/configuration.modu
     declarations: [
         NewResolverComponent,
         UploadResolverComponent,
-        BlankResolverComponent,
         CopyResolverComponent,
         ConfirmCopyComponent,
         ResolverEditComponent,