Storage Service

webapp/controllers/administration/Storage.js

@@ -0,0 +1,40 @@
+'use strict';
+
+// dependencies
+const Enums = require('./../../core/Enums');
+const StorageFacade = require('./../../core/facade/storage');
+const makeTokenParameters = require('../../core/Utils').makeTokenParameters;
+
+/**
+ * It exports a object with Storage controllers (get/new/edit)
+ * @return {Object} A object with controllers with http method as key (get/new/edit)
+ */
+module.exports = function(app) {
+  return {
+    get: function(request, response) {
+      const parameters = makeTokenParameters(request.query.token, app);
+      const hasProjectPermission = request.session.activeProject.hasProjectPermission;
+      parameters.hasProjectPermission = hasProjectPermission;
+      response.render('administration/storages', Object.assign({}, parameters, {"Enums": Enums}));
+    },
+
+    new: function(request, response) {
+      response.render('administration/storage');
+    },
+
+    edit: async (request, response) => {
+      const storageId = request.params.id;
+      const hasProjectPermission = request.session.activeProject.hasProjectPermission;
+
+      const facade = new StorageFacade();
+
+      try {
+        await facade.get(storageId);
+
+        response.render('administration/storage', {hasProjectPermission: hasProjectPermission, storage: storageId });
+      } catch (err) {
+        response.render('base/404');
+      }
+    }
+  };
+};

webapp/controllers/api/Service.js

@@ -9,20 +9,25 @@ module.exports = function(app) {
   return {
     get: function(request, response) {
       var type = request.query.type;
-      var serviceId = request.query.serviceId;
-
+
       if (!serviceId) {
+        var serviceId = request.query.serviceId;
         //todo: improve it
         var restriction = {};
-        switch (type) {
-          case "COLLECT":
-            restriction = {service_type_id: 1};
-            break;
-          case "ANALYSIS":
-            restriction = {service_type_id: 2};
-            break;
-          default:
-            break;
+
+        if (isNaN(type)) {
+          switch (type) {
+            case "COLLECT":
+              restriction = {service_type_id: 1};
+              break;
+              case "ANALYSIS":
+              restriction = {service_type_id: 2};
+              break;
+            default:
+              break;
+          }
+        } else {
+          restriction.service_type_id = type;
         }
 
         return DataManager.listServiceInstances(restriction).then(function(services) {

webapp/controllers/api/storage.js

@@ -0,0 +1,68 @@
+// dependencies
+const storageFacade = require('../../core/facade/storage');
+
+const mergeStorageWithProject = (request, storage) => (
+  { project_id: request.session.activeProject.id, ...storage }
+);
+
+/**
+ * It exports a object with Storage controllers (get/new/edit)
+ * @return {Object} A object with controllers with http method as key (get/new/edit)
+ */
+module.exports = function(app) {
+  return {
+    get: async (request, response) => {
+      try {
+        let output = null;
+
+        const facade = new storageFacade();
+
+        if (request.params.id) {
+          output = await facade.get(request.params.id);
+        } else {
+          output = await facade.list();
+        }
+
+        response.json(output);
+      } catch (err) {
+        response.status(400);
+        response.json({ error: err.message });
+      }
+    },
+    save: async (request, response) => {
+      try {
+        const storage = await new storageFacade().save(mergeStorageWithProject(request, request.body));
+        response.json(storage);
+      } catch (err) {
+        response.status(err.code);
+        response.json(err.getErrors());
+      }
+    },
+    put: async (request, response) => {
+      try {
+        const facade = new storageFacade();
+
+        await facade.update(request.params.id, mergeStorageWithProject(request, request.body));
+
+        response.status(204);
+        response.json({});
+      } catch (err) {
+        response.status(err.code);
+        response.json(err.getErrors());
+      }
+    },
+    delete: async (request, response) => {
+      try {
+        const facade = new storageFacade();
+
+        await facade.delete(request.params.id);
+
+        response.status(204)
+        response.json({});
+      } catch (err) {
+        response.status(err.code);
+        response.json(err.getErrors());
+      }
+    }
+  };
+};

webapp/controllers/configuration/Status.js

@@ -15,10 +15,11 @@ module.exports = function(app) {
         DataManager.listViews(),
         DataManager.listAlerts(),
         DataManager.listInterpolators(),
+        DataManager.listStorages(),
         DataManager.listProjects()
       ])
 
-      .spread(function(collectors, analysisList, views, alerts, interpolators, projects) {
+      .spread(function(collectors, analysisList, views, alerts, interpolators, storages, projects) {
         var outputAnalysis = [];
         analysisList.forEach(function(analysis) {
           outputAnalysis.push(analysis.rawObject());
@@ -41,13 +42,18 @@ module.exports = function(app) {
           return interpolator.rawObject();
         });
 
+        var outputStorages = storages.map(function(storage){
+           return storage;
+        });
+
         var renderParams = {
           "Enums": Enums,
           "analysis": outputAnalysis,
           "collectors": outputCollectors,
           "views": outputViews,
           "alerts": outputAlerts,
           "interpolators": outputInterpolators,
+          "storages": outputStorages,
           "projects": projects,
           "parameters": null
         };

webapp/controllers/configuration/Storages.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var DataManager = require("./../../core/DataManager");
+var ScheduleType = require("./../../core/Enums").ScheduleType;
+var makeTokenParameters = require('../../core/Utils').makeTokenParameters;
+
+module.exports = function(app) {
+	return {
+		get: function(request, response) {
+			var parameters = makeTokenParameters(request.query.token, app);
+			var hasProjectPermission = request.session.activeProject.hasProjectPermission;
+			parameters.hasProjectPermission = hasProjectPermission;
+			response.render("configuration/storages", parameters);
+		},
+		new: function(request, response) {
+			return response.render("configuration/storages", {ScheduleType: ScheduleType});
+		},
+		edit: function(request, response) {
+      var hasProjectPermission = request.session.activeProject.hasProjectPermission;
+      DataManager.getStorage({id: parseInt(request.params.id)})
+      .then(function(storage) {
+          return response.render("configuration/storages", {storage: storage.rawObject(), ScheduleType: ScheduleType, hasProjectPermission: hasProjectPermission});
+      }).catch(function(err) {
+          return response.render("base/404");
+      });
+    }
+  }
+};

webapp/core/Application.js

@@ -1,6 +1,7 @@
 var fs = require("fs");
 var path = require("path");
 var bcrypt = require('bcrypt');
+var util = require('util');
 
 /**
  * It defines a cache object (private) with TerraMA² settings

webapp/core/DataManager.js

@@ -105,6 +105,7 @@ var DataManager = module.exports = {
   init: function(dbConfigPath, callback) {
     var self = this;
     logger.info("Initializing database...");
+    logger.info(dbConfigPath);
 
     return Database.init(dbConfigPath).then(function(dbORM) {
       logger.info("Database loaded.");
@@ -139,6 +140,7 @@ var DataManager = module.exports = {
         inserts.push(models.db.ServiceType.create({id: Enums.ServiceType.VIEW, name: "VIEW"}));
         inserts.push(models.db.ServiceType.create({id: Enums.ServiceType.ALERT, name: "ALERT"}));
         inserts.push(models.db.ServiceType.create({id: Enums.ServiceType.INTERPOLATION, name: "INTERPOLATION"}));
+        inserts.push(models.db.ServiceType.create({id: Enums.ServiceType.STORAGE, name: "STORAGE"}));
 
         // data provider type defaults
         inserts.push(self.addDataProviderType({id: 1, name: "FILE", description: "Desc File"}));
@@ -214,11 +216,19 @@ var DataManager = module.exports = {
             interpolationService.port = 6547;
             interpolationService.service_type_id = Enums.ServiceType.INTERPOLATION;
 
+            var storageService = Object.assign({}, collectorService);
+            storageService.name = "Local Storage";
+            storageService.description = "Local service for Storage";
+            storageService.pathToBinary = "../storage/storage_service.js",
+            storageService.port = 5000;
+            storageService.service_type_id = Enums.ServiceType.STORAGE;
+
             servicesInsert.push(self.addServiceInstance(collectorService));
             servicesInsert.push(self.addServiceInstance(analysisService));
             servicesInsert.push(self.addServiceInstance(viewService));
             servicesInsert.push(self.addServiceInstance(alertService));
             servicesInsert.push(self.addServiceInstance(interpolationService));
+            servicesInsert.push(self.addServiceInstance(storageService));
           }
           return Promise.all(servicesInsert);
         });
@@ -3231,7 +3241,7 @@ var DataManager = module.exports = {
               return reject(new exceptions.CollectorError("Could not find collector. " + err.toString()));
             });
         } else {
-          logger.error("Retrieved null while getting collector", collectorResult);
+          logger.error("Retrieved null while getting collector", restriction, collectorResult);
           return reject(new exceptions.CollectorErrorNotFound("Could not find collector. "));
         }
       }).catch(function(err) {
@@ -6629,5 +6639,66 @@ var DataManager = module.exports = {
         return reject(err);
       });
     });
-  }
+  },
+
+  /**
+   * It retrieves all storages from database
+   *
+   * @param {Object} restriction - A query restriction
+   * @param {Object} options - A query options
+   * @param {Transaction} options.transaction - An ORM transaction
+   * @returns {Promise<Array<Object>>}
+   */
+  listStorages: function(restriction, options) {
+    var self = this;
+    return new Promise(function(resolve, reject) {
+      var _reject = function(err) {
+        logger.error(err);
+        reject(err);
+      };
+
+      return models.db.Storages.findAll({})
+      .then(function(storages){
+        var output = [];
+        storages.forEach(function(storage) {
+          output.push(storage.get());
+        });
+        resolve(output);
+      }).catch(function(err) {
+        reject(new Error("Could not retrieve storage " + err.toString()));
+      });
+
+    });
+  },
+
+  /**
+   * It retrieves a storage of database from given restriction
+   *
+   * @param {Object} restriction - A query restriction
+   * @param {Object} options - A query options
+   * @param {Transaction} options.transaction - An ORM transaction
+   * @returns {Promise<Storage>}
+   */
+  getStorage: function(restriction, options) {
+    var self = this;
+    return new Promise(function(resolve, reject) {
+      self.listStorages(restriction, options)
+        .then(function(storages) {
+          if (storages.length === 0) {
+            return reject(new Error("No storage retrieved"));
+          }
+
+          if (storages.length > 1) {
+            return reject(new Error("Get operation retrieved more than a storage"));
+          }
+
+          return resolve(storages[0]);
+        })
+        .catch(function(err) {
+          return reject(err);
+        });
+    });
+  },
+
 };
+

webapp/core/Enums.js

@@ -134,7 +134,12 @@ module.exports = {
      * Defines Interpolation Service
      * @type {number}
      */
-    INTERPOLATION: 5
+    INTERPOLATION: 5,
+    /**
+     * Defines Storage Service
+     * @type {number}
+     */
+    STORAGE: 6
   },
 
   DataSeriesType: {

webapp/core/Exceptions.js

@@ -406,3 +406,20 @@ errors.InterpolatorError = function(message) {
   this.name = 'InterpolatorError';
 };
 util.inherits(errors.InterpolatorError, errors.BaseError);
+
+class TcpError extends Error {
+  constructor(service, message, process = null) {
+    super(message);
+
+    this.service = service;
+    this.process = process;
+  }
+}
+class NoSuchConnectionError extends TcpError {
+  constructor(service, process = null) {
+    super(service, `There is no active connection to the service ${service.name || service.id || service}`, process);
+  }
+}
+
+errors.TcpError = TcpError;
+errors.NoSuchConnectionError = NoSuchConnectionError;

webapp/core/Logger.js

@@ -59,6 +59,7 @@
    * @returns {string} Formatted string to log
    */
   function loggerFormat(args) {
+    format = new Date().toLocaleTimeString();
     return NodeFormat("[%s] %s %s", format, winston.config.colorize(args.level), args.message);
   }
 

webapp/core/ObjectDependencies.js

@@ -211,6 +211,21 @@ var ObjectDependencies = function(json){
       );
     }
   }
+  else if (json.objectType == "Storage"){
+  for(var i = 0, idsLength = json.ids.length; i < idsLength; i++) {
+    promises.push(
+      DataManager.getStorage({id: json.ids[i]}).then(function(storage){
+        if(output["Storages_" + storage.id] === undefined) output["Storages_" + storage.id] = {};
+
+        if(output["Storages_" + storage.id] === undefined) output["Storages_" + storage.id] = {};
+        var storageDataseriesListPromises = [getDataSeriesDependencies(storage.data_series_input, null, "Storages_" + storage.id)];
+        storageDataseriesListPromises.push(getDataSeriesDependencies(storage.data_series_output, null, "Storages_" + storage.id));
+
+        return Promise.all(storageDataseriesListPromises).catch(_emitError);
+      })
+    );
+  }
+}
 
   return Promise.all(promises).then(function() {
     return Promise.resolve({ status: 200, data: output, projectId: json.projectId });