feat(projection): add route to get projection from service

documentation/apis/administration/1.0.0/api.yaml

@@ -390,7 +390,55 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/errorResponse"
-
+
+  /services/{service}/projections/{projection}:
+    get:
+      tags:
+      - "Gestion des services"
+      - "Projection"
+      summary: "Récupération d'une projection supportée par un service."
+      description: |
+        Cette requête retourne une projection supportée par un service.
+      operationId: "get-service-projection"
+      parameters:
+      - name: "service"
+        description: "Id du service concerné"
+        in: "path"
+        required: true
+        schema:
+          type: "string"      
+      - name: "projection"
+        description: "Id de la projection concernée"
+        in: "path"
+        required: true
+        schema:
+          type: "string"
+      responses:
+        200:
+          description: "successful operation"
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/projectionConfiguration"
+        400:
+          description: "Invalid parameters"
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/errorResponse"
+        404:
+          description: "Not found"
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/errorResponse"
+        500:
+          description: "Internal server error"
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/errorResponse"
+
   /services/{service}/resources:
     get:
       tags:
@@ -953,6 +1001,14 @@ components:
                   version: 
                     type: "string"
                     example: "1.0.0"
+
+    projectionConfiguration:
+      type: "object"
+      properties:
+        id:
+          type: "string"
+          example: "EPSG:4326"
+          required: true
 
     resourceConfiguration:
       type: "object"

src/js/administrator/administrator.js

@@ -475,6 +475,24 @@ module.exports = class Administrator {
 
     }
 
+    /**
+     *
+     * @function
+     * @name computeRequest
+     * @description Gestion de la requête pour une route d'administration sur un serveur 
+     * @param {string} serviceId - Id du service selon l'administrateur
+     * @param {object} request - Instance fille de la classe Request 
+     *
+     */
+
+    async computeRequest(serviceId, request) {
+
+        LOGGER.info("computeRequest...");
+        LOGGER.debug("Compute request pour le service : " + serviceId);
+        const response = await this._serviceManager.computeRequest(serviceId, request);
+        return response;
+    }
+
     /**
      *
      * @function

src/js/apis/admin/1.0.0/controller/controller.js

@@ -4,6 +4,7 @@ const errorManager = require('../../../../utils/errorManager');
 const log4js = require('log4js');
 const HealthRequest = require('../../../../requests/healthRequest');
 const ServiceRequest = require('../../../../requests/serviceRequest');
+const ProjectionRequest = require('../../../../requests/projectionRequest');
 
 var LOGGER = log4js.getLogger("CONTROLLER");
 
@@ -110,6 +111,69 @@ module.exports = {
 
     return request;
 
+  },
+
+
+  /**
+  *
+  * @function
+  * @name checkProjectionParameters
+  * @description Vérification des paramètres d'une requête sur /services/{service}/projections/{projection}
+  * @param {object} parameters - ensemble des paramètres de la requête ExpressJS
+  * @return {ProjectionRequest} request - Instance de la classe ProjectionRequest
+  *
+  */
+
+  checkProjectionParameters: function(parameters) {
+
+    LOGGER.debug("checkProjectionParameters()");
+
+    // Service
+    if (!parameters.service) {
+      throw errorManager.createError(" Parameter 'service' is invalid: there is no value", 400);
+    } 
+
+    if (parameters.service === "") {
+      throw errorManager.createError(" Parameter 'service' is invalid: value should not be empty", 400);
+    }
+
+    // Projection
+    if (!parameters.projection) {
+      throw errorManager.createError(" Parameter 'projection' is invalid: there is no value", 400);
+    } 
+
+    if (parameters.projection === "") {
+      throw errorManager.createError(" Parameter 'projection' is invalid: value should not be empty", 400);
+    }
+
+    // TODO : vérifier ici que le service existe (appel à une fonction de la classe administrator)
+
+    const request = new ProjectionRequest(parameters.service, parameters.projection);
+
+    return request;
+
+  },
+  /**
+  *
+  * @function
+  * @name writeProjectionResponse
+  * @description Ré-écriture de la réponse pour une requête sur /services/<service>/projections/<projection>
+  * @param {object} projectionResponse - Instance de la classe ProjectionResponse
+  * @return {object} userResponse - Réponse envoyée à l'utilisateur
+  *
+  */
+
+  writeProjectionResponse: function(projectionResponse) {
+
+    let userResponse = {};
+
+    LOGGER.debug("writeProjectionResponse()");
+
+    // On doit utiliser les attributs avec _ car les méthodes ne sont pas disponible dans le cadre d'une communication IPC
+    userResponse.id = projectionResponse._id;
+
+    return userResponse;
+
   }
 
 }

src/js/apis/admin/1.0.0/index.js

@@ -197,6 +197,45 @@ router.route("/services/:service/restart")
 
   });
 
+// Services/{service}/projections/{projection}
+// Récupérer une projection supportée par un service
+router.route("/services/:service/projections/:projection")
+
+  .get(async function(req, res, next) {
+
+    LOGGER.debug("requete GET sur /admin/1.0.0/services/:service/projections/:projection");
+    LOGGER.debug(req.originalUrl);
+
+    // On récupère l'instance d'Administrator pour répondre aux requêtes
+    let administrator = req.app.get("administrator");
+
+    // on récupère l'ensemble des paramètres de la requête
+    const parameters = req.params;
+    LOGGER.debug(parameters);
+
+    try {     
+
+      // Vérification des paramètres de la requête
+      const projectionRequest = controller.checkProjectionParameters(parameters);
+      LOGGER.debug(projectionRequest);
+
+      // Envoie à l'administrateur et récupération de l'objet réponse
+      const projectionResponse = await administrator.computeRequest(projectionRequest.service, projectionRequest);
+      LOGGER.debug(projectionResponse);
+
+      // Formattage de la réponse
+      const userResponse = controller.writeProjectionResponse(projectionResponse);
+      LOGGER.debug(userResponse);
+
+      res.set('content-type', 'application/json');
+      res.status(200).json(userResponse);        
+
+    } catch (error) {
+      return next(error);
+    }
+
+  });
+
 // Gestion des erreurs
 // Cette partie doit être placée après la définition des routes normales
 // ---

src/js/requests/projectionRequest.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const Request = require('./request');
+
+/**
+*
+* @class
+* @name projectionRequest
+* @description Classe modélisant une requête sur une projection d'un service géré par l'administrateur.
+*
+*/
+
+module.exports = class projectionRequest extends Request {
+
+  /**
+  *
+  * @function
+  * @name constructor
+  * @description Constructeur de la classe projectionRequest
+  * @param {string} serviceId - Id du service interrogé
+  * @param {string} projectionId - Id de la projection interrogée
+  *
+  */
+
+  constructor(serviceId, projectionId) {
+
+    super("projection", "projectionRequest");
+
+    // Id du service d'après l'administrateur
+    this._service = serviceId;
+
+    // Id de la projection
+    this._projection = projectionId;
+
+  }
+
+  /**
+  *
+  * @function
+  * @name get service
+  * @description Récupérer service de la requete
+  *
+  */
+  get service() {
+    return this._service;
+  }
+
+  /**
+  *
+  * @function
+  * @name set service
+  * @description Attribuer le service de la requete
+  * @param {string} id - Id du service 
+  *
+  */
+  set service(id) {
+    this._service = id;
+  }
+
+  /**
+  *
+  * @function
+  * @name get projection
+  * @description Récupérer la projection demandée
+  *
+  */
+  get projection() {
+    return this._projection;
+  }
+
+  /**
+  *
+  * @function
+  * @name set projection
+  * @description Attribuer la projection de la requete
+  * @param {string} id - Id de la projection 
+  *
+  */
+  set projection(id) {
+    this._projection = id;
+  }
+
+}

src/js/responses/projectionResponse.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const Response = require('./response');
+
+/**
+*
+* @class
+* @name projectionResponse
+* @description Classe modélisant une réponse de description d'une projection
+*
+*/
+
+module.exports = class projectionResponse extends Response {
+
+
+  /**
+  *
+  * @function
+  * @name constructor
+  * @description Constructeur de la classe projectionResponse
+  *
+  */
+  constructor() {
+
+    // Type de la réponse 
+    super("projectionResponse");
+
+    // Identifiant
+    this._id = "";
+
+  }
+
+  /**
+  *
+  * @function
+  * @name get id
+  * @description Récupérer l'identifiant
+  *
+  */
+   get id () {
+    return this._id;
+  }
+
+  /**
+  *
+  * @function
+  * @name set id
+  * @description Attribuer l'identifiant
+  * @param {string} id - identifiant
+  *
+  */
+  set id (id) {
+    this._id = id;
+  }
+
+}