Metamodel module => WIP

client/src/app/admin/admin.module.ts

+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+
+@NgModule({
+    declarations: [],
+    imports: [
+        CommonModule
+    ],
+    providers: []
+})
+export class AdminModule { }
\ No newline at end of file

client/src/app/app.module.ts

@@ -14,6 +14,7 @@ import { environment } from '../environments/environment';
 import { reducers, metaReducers } from './app.reducer';
 import { CustomSerializer } from './custom-route-serializer';
 import { MetamodelModule } from './metamodel/metamodel.module';
+import { AdminModule } from './admin/admin.module';
 
 @NgModule({
     declarations: [
@@ -44,7 +45,8 @@ import { MetamodelModule } from './metamodel/metamodel.module';
             maxAge: 25,
             logOnly: environment.production
         }),
-        MetamodelModule
+        MetamodelModule,
+        AdminModule
     ],
     providers: [],
     bootstrap: [AppComponent]

client/src/app/metamodel/store/effects/database.effects.ts

@@ -9,7 +9,7 @@ import { DatabaseService } from '../services/database.service';
 @Injectable()
 export class DatabaseEffects {
  
-    loadMovies$ = createEffect(() =>
+    loadDatabases$ = createEffect(() =>
         this.actions$.pipe(
             ofType(databaseActions.loadDatabaseList),
             mergeMap(() => this.databaseService.retrieveDatabaseList()

client/src/app/metamodel/store/effects/survey.effects.ts

+import { Injectable } from '@angular/core';
+import { Actions, createEffect, ofType } from '@ngrx/effects';
+import { of } from 'rxjs';
+import { map, mergeMap, catchError } from 'rxjs/operators';
+
+import * as surveyActions from '../actions/survey.actions';
+import { SurveyService } from '../services/survey.service';
+ 
+@Injectable()
+export class SurveyEffects {
+ 
+    loadSurveys$ = createEffect(() =>
+        this.actions$.pipe(
+            ofType(surveyActions.loadSurveyList),
+            mergeMap(() => this.surveyService.retrieveSurveyList()
+                .pipe(
+                    map(surveys => surveyActions.loadSurveyListSuccess({ surveys })),
+                    catchError(() => of(surveyActions.loadSurveyListFail()))
+                )
+            )
+        )
+    );
+ 
+    constructor(
+        private actions$: Actions,
+        private surveyService: SurveyService
+    ) {}
+}
\ No newline at end of file

client/src/app/metamodel/store/selectors/attribute.selector.ts

+import { createSelector } from '@ngrx/store';
+
+import * as reducer from '../reducers';
+import * as fromAttribute from '../reducers/attribute.reducer';
+
+export const selectAttributeState = createSelector(
+    reducer.getMetamodelState,
+    (state: reducer.State) => state.attribute
+);
+
+export const selectAttributeIds = createSelector(
+    selectAttributeState,
+    fromAttribute.selectAttributeIds
+);
+
+export const selectAttributeEntities = createSelector(
+    selectAttributeState,
+    fromAttribute.selectAttributeEntities
+);
+
+export const selectAllAttributes = createSelector(
+    selectAttributeState,
+    fromAttribute.selectAllAttributes
+);
+
+export const selectAttributeTotal = createSelector(
+    selectAttributeState,
+    fromAttribute.selectAttributeTotal
+);

client/src/app/metamodel/store/selectors/criteria-family.selector.ts

+import { createSelector } from '@ngrx/store';
+
+import * as reducer from '../reducers';
+import * as fromCriteriaFamily from '../reducers/criteria-family.reducer';
+
+export const selectCriteriaFamilyState = createSelector(
+    reducer.getMetamodelState,
+    (state: reducer.State) => state.criteriaFamily
+);
+
+export const selectCriteriaFamilyIds = createSelector(
+    selectCriteriaFamilyState,
+    fromCriteriaFamily.selectCriteriaFamilyIds
+);
+
+export const selectCriteriaFamilyEntities = createSelector(
+    selectCriteriaFamilyState,
+    fromCriteriaFamily.selectCriteriaFamilyEntities
+);
+
+export const selectAllCriteriaFamilys = createSelector(
+    selectCriteriaFamilyState,
+    fromCriteriaFamily.selectAllCriteriaFamilies
+);
+
+export const selectCriteriaFamilyTotal = createSelector(
+    selectCriteriaFamilyState,
+    fromCriteriaFamily.selectCriteriaFamilyTotal
+);

client/src/app/metamodel/store/selectors/dataset-family.selector.ts

+import { createSelector } from '@ngrx/store';
+
+import * as reducer from '../reducers';
+import * as fromDatasetFamily from '../reducers/dataset-family.reducer';
+
+export const selectDatasetFamilyState = createSelector(
+    reducer.getMetamodelState,
+    (state: reducer.State) => state.datasetFamily
+);
+
+export const selectDatasetFamilyIds = createSelector(
+    selectDatasetFamilyState,
+    fromDatasetFamily.selectDatasetFamilyIds
+);
+
+export const selectDatasetFamilyEntities = createSelector(
+    selectDatasetFamilyState,
+    fromDatasetFamily.selectDatasetFamilyEntities
+);
+
+export const selectAllDatasetFamilys = createSelector(
+    selectDatasetFamilyState,
+    fromDatasetFamily.selectAllDatasetFamilies
+);
+
+export const selectDatasetFamilyTotal = createSelector(
+    selectDatasetFamilyState,
+    fromDatasetFamily.selectDatasetFamilyTotal
+);

client/src/app/metamodel/store/selectors/dataset.selector.ts

+import { createSelector } from '@ngrx/store';
+
+import * as reducer from '../reducers';
+import * as fromDataset from '../reducers/dataset.reducer';
+
+export const selectDatasetState = createSelector(
+    reducer.getMetamodelState,
+    (state: reducer.State) => state.dataset
+);
+
+export const selectDatasetIds = createSelector(
+    selectDatasetState,
+    fromDataset.selectDatasetIds
+);
+
+export const selectDatasetEntities = createSelector(
+    selectDatasetState,
+    fromDataset.selectDatasetEntities
+);
+
+export const selectAllDatasets = createSelector(
+    selectDatasetState,
+    fromDataset.selectAllDatasets
+);
+
+export const selectDatasetTotal = createSelector(
+    selectDatasetState,
+    fromDataset.selectDatasetTotal
+);

client/src/app/metamodel/store/selectors/group.selector.ts

+import { createSelector } from '@ngrx/store';
+
+import * as reducer from '../reducers';
+import * as fromGroup from '../reducers/group.reducer';
+
+export const selectGroupState = createSelector(
+    reducer.getMetamodelState,
+    (state: reducer.State) => state.group
+);
+
+export const selectGroupIds = createSelector(
+    selectGroupState,
+    fromGroup.selectGroupIds
+);
+
+export const selectGroupEntities = createSelector(
+    selectGroupState,
+    fromGroup.selectGroupEntities
+);
+
+export const selectAllGroups = createSelector(
+    selectGroupState,
+    fromGroup.selectAllGroups
+);
+
+export const selectGroupTotal = createSelector(
+    selectGroupState,
+    fromGroup.selectGroupTotal
+);

client/src/app/metamodel/store/selectors/instance.selector.ts

+import { createSelector } from '@ngrx/store';
+
+import * as reducer from '../reducers';
+import * as fromInstance from '../reducers/instance.reducer';
+
+export const selectInstanceState = createSelector(
+    reducer.getMetamodelState,
+    (state: reducer.State) => state.instance
+);
+
+export const selectInstanceIds = createSelector(
+    selectInstanceState,
+    fromInstance.selectInstanceIds
+);
+
+export const selectInstanceEntities = createSelector(
+    selectInstanceState,
+    fromInstance.selectInstanceEntities
+);
+
+export const selectAllInstances = createSelector(
+    selectInstanceState,
+    fromInstance.selectAllInstances
+);
+
+export const selectInstanceTotal = createSelector(
+    selectInstanceState,
+    fromInstance.selectInstanceTotal
+);

client/src/app/metamodel/store/selectors/output-category.selector.ts

+import { createSelector } from '@ngrx/store';
+
+import * as reducer from '../reducers';
+import * as fromOutputCategory from '../reducers/output-category.reducer';
+
+export const selectOutputCategoryState = createSelector(
+    reducer.getMetamodelState,
+    (state: reducer.State) => state.outputCategory
+);
+
+export const selectOutputCategoryIds = createSelector(
+    selectOutputCategoryState,
+    fromOutputCategory.selectOutputCategoryIds
+);
+
+export const selectOutputCategoryEntities = createSelector(
+    selectOutputCategoryState,
+    fromOutputCategory.selectOutputCategoryEntities
+);
+
+export const selectAllOutputCategorys = createSelector(
+    selectOutputCategoryState,
+    fromOutputCategory.selectAllOutputCategories
+);
+
+export const selectOutputCategoryTotal = createSelector(
+    selectOutputCategoryState,
+    fromOutputCategory.selectOutputCategoryTotal
+);

client/src/app/metamodel/store/selectors/output-family.selector.ts

+import { createSelector } from '@ngrx/store';
+
+import * as reducer from '../reducers';
+import * as fromOutputFamily from '../reducers/output-family.reducer';
+
+export const selectOutputFamilyState = createSelector(
+    reducer.getMetamodelState,
+    (state: reducer.State) => state.outputFamily
+);
+
+export const selectOutputFamilyIds = createSelector(
+    selectOutputFamilyState,
+    fromOutputFamily.selectOutputFamilyIds
+);
+
+export const selectOutputFamilyEntities = createSelector(
+    selectOutputFamilyState,
+    fromOutputFamily.selectOutputFamilyEntities
+);
+
+export const selectAllOutputFamilys = createSelector(
+    selectOutputFamilyState,
+    fromOutputFamily.selectAllOutputFamilies
+);
+
+export const selectOutputFamilyTotal = createSelector(
+    selectOutputFamilyState,
+    fromOutputFamily.selectOutputFamilyTotal
+);

client/src/app/metamodel/store/selectors/survey.selector.ts

+import { createSelector } from '@ngrx/store';
+
+import * as reducer from '../reducers';
+import * as fromSurvey from '../reducers/survey.reducer';
+
+export const selectSurveyState = createSelector(
+    reducer.getMetamodelState,
+    (state: reducer.State) => state.survey
+);
+
+export const selectSurveyIds = createSelector(
+    selectSurveyState,
+    fromSurvey.selectSurveyIds
+);
+
+export const selectSurveyEntities = createSelector(
+    selectSurveyState,
+    fromSurvey.selectSurveyEntities
+);
+
+export const selectAllSurveys = createSelector(
+    selectSurveyState,
+    fromSurvey.selectAllSurveys
+);
+
+export const selectSurveyTotal = createSelector(
+    selectSurveyState,
+    fromSurvey.selectSurveyTotal
+);