Merge branch...

Merge branch '7-as-a-client-i-want-to-be-able-to-query-specific-fields-in-pathologies-api-so-that-i-only-get-what' into 'develop'

Resolve "As a client, I want to be able to query specific fields in pathologies API so that I only get what I need"

Closes #7

See merge request sibmip/gateway!7

api/src/common/interfaces/utilities.interface.ts

+export type Dictionary<T> = { [key: string]: T };

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

 import { Observable } from 'rxjs';
 import { IEngineService } from 'src/engine/engine.interfaces';
+import { Domain } from 'src/engine/models/domain.model';
 
 export default class DataShieldService implements IEngineService {
+  getDomains(): Domain[] {
+    throw new Error('Method not implemented.');
+  }
+
   demo(): string {
     return 'datashield';
   }

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

+import { Category } from 'src/engine/models/category.model';
+import { Group } from 'src/engine/models/group.model';
+import { Variable } from 'src/engine/models/variable.model';
+import { Hierarchy } from './interfaces/hierarchy.interface';
+import { VariableEntity } from './interfaces/variable-entity.interface';
+import { Entity } from './interfaces/entity.interface';
+
+export const dataToGroup = (data: Hierarchy): Group => {
+  return {
+    id: data.code,
+    label: data.label,
+    groups: data.groups ? data.groups.map(dataToGroup) : [],
+    variables: [],
+  };
+};
+
+export const dataToCategory = (data: Entity): Category => {
+  return {
+    id: data.code,
+    label: data.label,
+  };
+};
+
+export const dataToVariable = (data: VariableEntity): Variable => {
+  return {
+    id: data.code,
+    label: data.label,
+    type: data.type,
+    description: data.description,
+    enumerations: data.enumerations
+      ? data.enumerations.map(dataToCategory)
+      : [],
+    groups: [],
+  };
+};

api/src/engine/connectors/exareme/interfaces/entity.interface.ts

+export interface Entity {
+  code: string;
+  label?: string;
+}

api/src/engine/connectors/exareme/interfaces/hierarchy.interface.ts

+import { VariableEntity } from './variable-entity.interface';
+
+export interface Hierarchy {
+  code: string;
+  label: string;
+  groups: Hierarchy[];
+  variables: VariableEntity[];
+}

api/src/engine/connectors/exareme/interfaces/pathology.interface.ts

+import { Hierarchy } from './hierarchy.interface';
+import { VariableEntity } from './variable-entity.interface';
+
+export interface Pathology {
+  code: string;
+  label: string;
+  datasets: VariableEntity[];
+  metadataHierarchy: Hierarchy;
+}

api/src/engine/connectors/exareme/interfaces/variable-entity.interface.ts

+import { Entity } from './entity.interface';
+
+export interface VariableEntity extends Entity {
+  type?: 'nominal' | 'ordinal' | 'real' | 'integer' | 'text' | 'date';
+  description?: string;
+  enumerations?: Entity[];
+  group?: Entity[];
+  info?: string;
+}

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

 import { HttpService } from '@nestjs/axios';
+import { HttpException, HttpStatus } from '@nestjs/common';
 import { Request } from 'express';
-import { map, Observable } from 'rxjs';
+import { firstValueFrom, map, Observable } from 'rxjs';
 import { IEngineOptions, IEngineService } from 'src/engine/engine.interfaces';
+import { Domain } from 'src/engine/models/domain.model';
+import { Group } from 'src/engine/models/group.model';
+import { Variable } from 'src/engine/models/variable.model';
+import { dataToCategory, dataToGroup, dataToVariable } from './converters';
+import { Hierarchy } from './interfaces/hierarchy.interface';
+import { Pathology } from './interfaces/pathology.interface';
 
 export default class ExaremeService implements IEngineService {
   constructor(
@@ -9,6 +16,37 @@ export default class ExaremeService implements IEngineService {
     private readonly httpService: HttpService,
   ) {}
 
+  async getDomains(ids: string[]): Promise<Domain[]> {
+    const path = this.options.baseurl + 'pathologies';
+
+    try {
+      const data = await firstValueFrom(
+        this.httpService.get<Pathology[]>(path),
+      );
+
+      return data.data
+        .filter((data) => !ids || ids.length == 0 || ids.includes(data.code))
+        .map((data): Domain => {
+          const groups = this.flattenGroups(data.metadataHierarchy);
+
+          return {
+            id: data.code,
+            label: data.label,
+            groups: groups,
+            datasets: data.datasets ? data.datasets.map(dataToCategory) : [],
+            variables: data.metadataHierarchy
+              ? this.flattenVariables(data.metadataHierarchy, groups)
+              : [],
+          };
+        });
+    } catch {
+      throw new HttpException(
+        `Connexion to the connector ${this.options.type} failed`,
+        HttpStatus.NOT_FOUND,
+      );
+    }
+  }
+
   demo(): string {
     return 'exareme';
   }
@@ -82,4 +120,31 @@ export default class ExaremeService implements IEngineService {
       .get<string>(path)
       .pipe(map((response) => response.data));
   }
+
+  private flattenGroups = (data: Hierarchy): Group[] => {
+    let groups: Group[] = [dataToGroup(data)];
+
+    if (data.groups) {
+      groups = groups.concat(data.groups.flatMap(this.flattenGroups));
+    }
+
+    return groups;
+  };
+
+  private flattenVariables = (data: Hierarchy, groups: Group[]): Variable[] => {
+    const group = groups.find((group) => group.id == data.code);
+    let variables = data.variables ? data.variables.map(dataToVariable) : [];
+
+    variables.forEach((variable) => (variable.groups = group ? [group] : []));
+
+    if (data.groups) {
+      variables = variables.concat(
+        data.groups.flatMap((hierarchy) =>
+          this.flattenVariables(hierarchy, groups),
+        ),
+      );
+    }
+
+    return variables;
+  };
 }

api/src/engine/engine.interfaces.ts

 import { Request } from 'express';
 import { Observable } from 'rxjs';
+import { Domain } from './models/domain.model';
 
 export interface IEngineOptions {
   type: string;
@@ -9,6 +10,8 @@ export interface IEngineOptions {
 export interface IEngineService {
   demo(): string;
 
+  getDomains(ids: string[]): Domain[] | Promise<Domain[]>;
+
   getAlgorithms(request: Request): Observable<string>;
 
   getExperiments(request: Request): Observable<string>;

api/src/engine/engine.resolver.ts

 import { Inject } from '@nestjs/common';
-import { Query, Resolver } from '@nestjs/graphql';
+import { Args, Query, Resolver } from '@nestjs/graphql';
 import { ENGINE_SERVICE } from './engine.constants';
 import { IEngineService } from './engine.interfaces';
 import { Domain } from './models/domain.model';
@@ -10,17 +10,11 @@ export class EngineResolver {
     @Inject(ENGINE_SERVICE) private readonly engineService: IEngineService,
   ) {}
 
-  @Query(() => Domain)
-  async hello() {
-    const dummy: Domain = {
-      id: 'test',
-      label: 'test',
-      description: 'test',
-      groups: [],
-      variables: [],
-      datasets: [],
-    };
-
-    return dummy;
+  @Query(() => [Domain])
+  async domains(
+    @Args('ids', { nullable: true, type: () => [String], defaultValue: [] })
+    ids: string[],
+  ) {
+    return this.engineService.getDomains(ids);
   }
 }

api/src/schema.gql

@@ -34,5 +34,5 @@ type Domain {
 }
 
 type Query {
-  hello: Domain!
+  domains(ids: [String!] = []): [Domain!]!
 }