Merge branch '39-prepare-sib-dev-environment' into 'develop'

Resolve "Prepare SIB dev environment"

Closes #39

See merge request sibmip/gateway!17

api/src/engine/connectors/datashield/main.connector.ts

@@ -14,37 +14,43 @@ export default class DataShieldService implements IEngineService {
   getAlgorithms(): Algorithm[] | Promise<Algorithm[]> {
     throw new Error('Method not implemented.');
   }
+
   createExperiment(
     data: ExperimentCreateInput,
     isTransient: boolean,
   ): Experiment | Promise<Experiment> {
     throw new Error('Method not implemented.');
   }
+
   listExperiments(
     page: number,
     name: string,
   ): ListExperiments | Promise<ListExperiments> {
     throw new Error('Method not implemented.');
   }
+
   getExperiment(uuid: string): Experiment | Promise<Experiment> {
     throw new Error('Method not implemented.');
   }
+
   removeExperiment(
     uuid: string,
   ): PartialExperiment | Promise<PartialExperiment> {
     throw new Error('Method not implemented.');
   }
+
   editExperient(
     uuid: string,
     expriment: ExperimentEditInput,
   ): Experiment | Promise<Experiment> {
     throw new Error('Method not implemented.');
   }
+
   getDomains(): Domain[] {
     throw new Error('Method not implemented.');
   }
 
-  getActiveUser(): Observable<string> {
+  getActiveUser(): string {
     throw new Error('Method not implemented.');
   }
 
@@ -72,11 +78,11 @@ export default class DataShieldService implements IEngineService {
     throw new Error('Method not implemented.');
   }
 
-  getExperiments(): Observable<string> {
+  getExperiments(): string {
     throw new Error('Method not implemented.');
   }
 
-  getAlgorithmsREST(): Observable<string> {
+  getAlgorithmsREST(): string {
     throw new Error('Method not implemented.');
   }
 }

api/src/engine/connectors/exareme/converters.ts

@@ -28,7 +28,9 @@ export const dataToGroup = (data: Hierarchy): Group => {
     id: data.code,
     label: data.label,
     groups: data.groups ? data.groups.map(dataToGroup) : [],
-    variables: data.variables ? data.variables.map(dataToVariable) : [],
+    variables: data.variables
+      ? data.variables.map((data: VariableEntity) => data.code)
+      : [],
   };
 };
 

api/src/engine/connectors/local/main.connector.ts

+import { Observable } from 'rxjs';
+import { IEngineService } from 'src/engine/engine.interfaces';
+import { Domain } from 'src/engine/models/domain.model';
+import { ExperimentCreateInput } from 'src/engine/models/experiment/input/experiment-create.input';
+import {
+  Experiment,
+  PartialExperiment,
+} from 'src/engine/models/experiment/experiment.model';
+import { ListExperiments } from 'src/engine/models/experiment/list-experiments.model';
+import { ExperimentEditInput } from 'src/engine/models/experiment/input/experiment-edit.input';
+import { Algorithm } from 'src/engine/models/experiment/algorithm.model';
+
+export default class LocalService implements IEngineService {
+  getAlgorithms(): Algorithm[] | Promise<Algorithm[]> {
+    throw new Error('Method not implemented.');
+  }
+
+  createExperiment(
+    data: ExperimentCreateInput,
+    isTransient: boolean,
+  ): Experiment | Promise<Experiment> {
+    throw new Error('Method not implemented.');
+  }
+
+  listExperiments(
+    page: number,
+    name: string,
+  ): ListExperiments | Promise<ListExperiments> {
+    throw new Error('Method not implemented.');
+  }
+
+  getExperiment(uuid: string): Experiment | Promise<Experiment> {
+    throw new Error('Method not implemented.');
+  }
+
+  removeExperiment(
+    uuid: string,
+  ): PartialExperiment | Promise<PartialExperiment> {
+    throw new Error('Method not implemented.');
+  }
+
+  editExperient(
+    uuid: string,
+    expriment: ExperimentEditInput,
+  ): Experiment | Promise<Experiment> {
+    throw new Error('Method not implemented.');
+  }
+
+  getDomains(): Domain[] {
+    return [
+      {
+        id: 'Dummy',
+        label: 'Dummy',
+        datasets: [{ id: 'DummyDataset', label: 'DummyDataset' }],
+        groups: [
+          {
+            id: 'DummyGroup',
+            variables: ['DummyVar'],
+            groups: [],
+          },
+        ],
+        rootGroup: { id: 'DummyGroup' },
+        variables: [{ id: 'DummyVar', type: 'string' }],
+      },
+    ];
+  }
+
+  getActiveUser(): string {
+    const dummyUser = {
+      username: 'anonymous',
+      subjectId: 'anonymousId',
+      fullname: 'anonymous',
+      email: 'anonymous@anonymous.com',
+      agreeNDA: true,
+    };
+    return JSON.stringify(dummyUser);
+  }
+
+  editActiveUser(): Observable<string> {
+    throw new Error('Method not implemented.');
+  }
+
+  getExperimentREST(): Observable<string> {
+    throw new Error('Method not implemented.');
+  }
+
+  deleteExperiment(): Observable<string> {
+    throw new Error('Method not implemented.');
+  }
+
+  editExperimentREST(): Observable<string> {
+    throw new Error('Method not implemented.');
+  }
+
+  startExperimentTransient(): Observable<string> {
+    throw new Error('Method not implemented.');
+  }
+
+  startExperiment(): Observable<string> {
+    throw new Error('Method not implemented.');
+  }
+
+  getExperiments(): string {
+    return '[]';
+  }
+
+  getAlgorithmsREST(): string {
+    return '[]';
+  }
+}

api/src/engine/engine.controller.ts

@@ -20,17 +20,17 @@ export class EngineController {
   ) {}
 
   @Get('/algorithms')
-  getAlgorithms(@Req() request: Request): Observable<string> {
+  getAlgorithms(@Req() request: Request): Observable<string> | string {
     return this.engineService.getAlgorithmsREST(request);
   }
 
   @Get('/experiments')
-  getExperiments(@Req() request: Request): Observable<string> {
+  getExperiments(@Req() request: Request): Observable<string> | string {
     return this.engineService.getExperiments(request);
   }
 
   @Get('/experiments/:uuid')
-  getExperiment(@Param('uuid') uuid: string): Observable<string> {
+  getExperiment(@Param('uuid') uuid: string): Observable<string> | string {
     return this.engineService.getExperimentREST(uuid);
   }
 
@@ -38,7 +38,7 @@ export class EngineController {
   deleteExperiment(
     @Param('uuid') uuid: string,
     @Req() request: Request,
-  ): Observable<string> {
+  ): Observable<string> | string {
     return this.engineService.deleteExperiment(uuid, request);
   }
 
@@ -46,27 +46,29 @@ export class EngineController {
   editExperiment(
     @Param('uuid') uuid: string,
     @Req() request: Request,
-  ): Observable<string> {
+  ): Observable<string> | string {
     return this.engineService.editExperimentREST(uuid, request);
   }
 
   @Post('experiments/transient')
-  startExperimentTransient(@Req() request: Request): Observable<string> {
+  startExperimentTransient(
+    @Req() request: Request,
+  ): Observable<string> | string {
     return this.engineService.startExperimentTransient(request);
   }
 
   @Post('experiments')
-  startExperiment(@Req() request: Request): Observable<string> {
+  startExperiment(@Req() request: Request): Observable<string> | string {
     return this.engineService.startExperiment(request);
   }
 
   @Get('activeUser')
-  getActiveUser(@Req() request: Request): Observable<string> {
+  getActiveUser(@Req() request: Request): Observable<string> | string {
     return this.engineService.getActiveUser(request);
   }
 
   @Post('activeUser/agreeNDA')
-  agreeNDA(@Req() request: Request): Observable<string> {
+  agreeNDA(@Req() request: Request): Observable<string> | string {
     return this.engineService.editActiveUser(request);
   }
 }

api/src/engine/engine.interfaces.ts

@@ -43,21 +43,24 @@ export interface IEngineService {
   getAlgorithms(): Promise<Algorithm[]> | Algorithm[];
 
   // Standard REST API call
-  getAlgorithmsREST(request: Request): Observable<string>;
+  getAlgorithmsREST(request: Request): Observable<string> | string;
 
-  getExperiments(request: Request): Observable<string>;
+  getExperiments(request: Request): Observable<string> | string;
 
-  getExperimentREST(uuid: string): Observable<string>;
+  getExperimentREST(uuid: string): Observable<string> | string;
 
-  deleteExperiment(uuid: string, request: Request): Observable<string>;
+  deleteExperiment(uuid: string, request: Request): Observable<string> | string;
 
-  editExperimentREST(uuid: string, request: Request): Observable<string>;
+  editExperimentREST(
+    uuid: string,
+    request: Request,
+  ): Observable<string> | string;
 
-  startExperimentTransient(request: Request): Observable<string>;
+  startExperimentTransient(request: Request): Observable<string> | string;
 
-  startExperiment(request: Request): Observable<string>;
+  startExperiment(request: Request): Observable<string> | string;
 
-  getActiveUser(request: Request): Observable<string>;
+  getActiveUser(request: Request): Observable<string> | string;
 
-  editActiveUser(request: Request): Observable<string>;
+  editActiveUser(request: Request): Observable<string> | string;
 }

api/src/engine/models/domain.model.ts

 import { Field, ObjectType } from '@nestjs/graphql';
 import { Category } from './category.model';
+import { Entity } from './entity.model';
 import { Group } from './group.model';
+import { Variable } from './variable.model';
 
 @ObjectType()
-export class Domain extends Group {
+export class Domain extends Entity {
+  @Field({ nullable: true })
+  description?: string;
+
+  @Field(() => [Group])
+  groups: Group[];
+
+  @Field(() => [Variable])
+  variables: Variable[];
+
   @Field(() => [Category])
   datasets: Category[];
 

api/src/engine/models/group.model.ts

 import { Field, ObjectType } from '@nestjs/graphql';
 import { Entity } from './entity.model';
-import { Variable } from './variable.model';
 
 @ObjectType()
 export class Group extends Entity {
   @Field({ nullable: true })
   description?: string;
 
-  @Field(() => [Group])
-  groups: Group[];
+  @Field(() => [Group], { defaultValue: [], nullable: true })
+  groups?: Group[];
 
-  @Field(() => [Variable])
-  variables: Variable[];
+  @Field(() => [String], {
+    description: "List of variable's ids",
+    defaultValue: [],
+    nullable: true,
+  })
+  variables?: string[];
 }

api/src/engine/models/variable.model.ts

@@ -11,9 +11,9 @@ export class Variable extends Entity {
   @Field({ nullable: true })
   description?: string;
 
-  @Field(() => [Category])
-  enumerations: Category[];
+  @Field(() => [Category], { nullable: true, defaultValue: [] })
+  enumerations?: Category[];
 
-  @Field(() => [Group])
-  groups: Group[];
+  @Field(() => [Group], { nullable: true, defaultValue: [] })
+  groups?: Group[];
 }

api/src/schema.gql

@@ -7,21 +7,23 @@ type Category {
   label: String
 }
 
-type Variable {
+type Group {
   id: String!
   label: String
-  type: String!
   description: String
-  enumerations: [Category!]!
-  groups: [Group!]!
+  groups: [Group!]
+
+  """List of variable's ids"""
+  variables: [String!]
 }
 
-type Group {
+type Variable {
   id: String!
   label: String
+  type: String!
   description: String
-  groups: [Group!]!
-  variables: [Variable!]!
+  enumerations: [Category!]
+  groups: [Group!]
 }
 
 type Domain {