@sedni/cloud_common 1.0.0

package/.eslintrc.js

@@ -0,0 +1,32 @@
+module.exports = {
+    env: {
+        node: true,
+        commonjs: true,
+        es2021: true,
+        mocha: true,
+    },
+    extends: [ "eslint:recommended", "plugin:node/recommended" ],
+    parserOptions: {
+        ecmaVersion: "latest",
+    },
+    rules: {
+        indent: [ "error", 4, { SwitchCase: 1 } ],
+        quotes: [ "error", "double" ],
+        semi: [ "error", "always" ],
+        "no-unused-vars": [
+            "error",
+            {
+                varsIgnorePattern: "should|expect|supertest|assert",
+            },
+        ],
+        curly: [ "error", "all" ],
+        "brace-style": [ "error", "allman" ],
+        "node/no-unpublished-require": [
+            "error",
+            {
+                allowModules: [ "swagger-ui-express" ],
+            },
+        ],
+        "node/no-missing-require": "off",
+    },
+};

package/app/models/Channel.js

@@ -0,0 +1,70 @@
+const mongoose = require("mongoose");
+const mongoosePaginate = require("mongoose-paginate-v2");
+const mongooseAggregatePaginate = require("mongoose-aggregate-paginate-v2");
+
+const channelSchema = new mongoose.Schema({
+    channel_tag: {
+        type: String,
+        required: true,
+        unique: true,
+        index: true,
+    },
+    channel_description: {
+        type: String,
+        required: true,
+        index: true,
+    },
+    channel_unit_id: {
+        type: String,
+        required: true,
+    },
+    channel_parsed : {
+        type: Object,
+        required: true,
+    },
+    channel_last_bucket_sync: {
+        type: Date,
+        required: true,
+    },
+}, {
+    timestamps: {
+        createdAt: true,
+        updatedAt: true
+    },
+    collection: "channels",
+    toJSON: {
+        transform: function (doc, ret) 
+        {
+            ret.id = ret._id;
+            delete ret._id;
+            delete ret.__v;
+        },
+    },
+});
+
+/**
+ * ///////////////////////////////////////////////
+ * /////////////     INDEXES     /////////////////
+ * ///////////////////////////////////////////////
+ */
+
+/**
+ * Index used primarily for filtering by unit_id 
+ */
+channelSchema.index({ "unit_id" : 1 });
+
+/**
+ * Index used primarily for filtering by unit_internal_description 
+ */
+channelSchema.index({ "unit_internal_description" : 1 });
+
+
+/**
+ * ///////////////////////////////////////////////
+ * /////////////     PLUGINS     /////////////////
+ * ///////////////////////////////////////////////
+ */
+channelSchema.plugin(mongoosePaginate);
+channelSchema.plugin(mongooseAggregatePaginate);
+
+module.exports = channelSchema;

package/app/models/ChannelDataBucket.js

@@ -0,0 +1,255 @@
+const mongoose = require("mongoose");
+const mongoose_paginate = require("mongoose-paginate-v2");
+const mongoose_aggregate_paginate = require("mongoose-aggregate-paginate-v2");
+
+const channeldataBucketSchema = new mongoose.Schema({
+    start_date: {
+        type: Date,
+        required: true,
+        default: Date.now,
+    },
+    end_date: {
+        type: Date,
+        required: true,
+        default: function() 
+        {
+            return new Date(Date.now() + 1000 * 60 * 60); // 1 hour from now
+        }
+    },
+    data : [{
+        timestamp: {
+            type: Number,
+            required: true,
+        },
+        value: {
+            type: Number,
+            required: true,
+        }
+    }],
+    size : {
+        type: Number,
+        required: true,
+        default: 0,
+    },
+    synced : {
+        type: Number,
+        required: true,
+        default: 0,
+    },
+    sum : {
+        type: Number,
+        required: true,
+        default: 0,
+    },
+}, {
+    toJSON: {
+        transform: function (doc, ret) 
+        {
+            ret.id = ret._id;
+            delete ret._id;
+            delete ret.__v;
+            ret.start_date = ret.start_date.getTime();
+            ret.end_date = ret.end_date.getTime();
+            ret.avg = ret.sum / ret.size;
+        },
+    },
+    versionKey: false,
+});
+
+/**
+ * ///////////////////////////////////////////////
+ * /////////////     INDEXES     /////////////////
+ * ///////////////////////////////////////////////
+ */
+
+/**
+ * Index the start_date and end_date fields for faster queries.
+ * The compound index will be used to query the buckets by date range.
+ */
+channeldataBucketSchema.index({ start_date: 1, end_date: 1 });
+
+/**
+ * ///////////////////////////////////////////////
+ * /////////////     PLUGINS     /////////////////
+ * ///////////////////////////////////////////////
+ */
+channeldataBucketSchema.plugin(mongoose_paginate);
+channeldataBucketSchema.plugin(mongoose_aggregate_paginate);
+
+
+/**
+ * ///////////////////////////////////////////////
+ * ////////////     FUNCTIONS     ////////////////
+ * ///////////////////////////////////////////////
+ */
+/**
+ * Insert a data point into a specific bucket.
+ * 
+ * The data point will be inserted into the bucket and the size and sum will be updated.
+ * @param {Number} timestamp The timestamp of the data point
+ * @param {Number} value The value of the data point
+ */
+channeldataBucketSchema.methods.insertDataPoint = async function(timestamp, value)
+{
+    this.data.push({ timestamp: timestamp, value: value });
+    this.size++;
+    this.sum += value;
+    await this.save();
+};
+
+/**
+ * Check if the bucket is closed, meaning that it is no longer accepting data points.
+ * @param {Number} timestamp The timestamp to check if the bucket is closed
+ * @returns {Boolean} True if the bucket is closed, false otherwise
+ */
+channeldataBucketSchema.methods.isBucketClosed = function(timestamp = Date.now())
+{
+    return timestamp >= this.end_date.getTime();
+};
+
+/**
+ * Insert a data point into the corresponding bucket.
+ * 
+ * If no bucket exists for the timestamp, it will be created.
+ * If a bucket exists for the timestamp, the data point will be inserted into the bucket and the size and sum will be updated.
+ * @param {Number} timestamp The timestamp of the data point 
+ * @param {Number} value The value of the data point
+ * @returns {Object} The bucket that the data point was inserted into
+ */
+channeldataBucketSchema.statics.insertDataPoint = async function(timestamp, value)
+{
+    // Truncate the timestamp to the nearest hour
+    const date = new Date(timestamp);
+    date.setMinutes(0);
+    date.setSeconds(0);
+    date.setMilliseconds(0);
+
+    // Upsert the data point
+    const bucket = await this.updateOne(
+        { 
+            start_date: date 
+        }, 
+        { 
+            $push: 
+            { 
+                data: 
+                { 
+                    timestamp: timestamp, 
+                    value: value 
+                } 
+            }, 
+
+            $inc: 
+            { 
+                size: 1, 
+                sum: value 
+            }, 
+
+            $set: 
+            { 
+                end_date: new Date(date.getTime() + 1000 * 60 * 60),
+            } 
+        }, 
+        { 
+            upsert: true 
+        }
+    );
+
+    return bucket;
+};
+
+/**
+ * Get the last time the data was synced
+ * @param {Object} options The options to get the last time the data was synced
+ * @param {String} options.channel_tag The channel tag to get the data from
+ * @param {Object} options.db The database to get the channel document from 
+ * @returns {Number} The last time the data was synced 
+ */
+channeldataBucketSchema.statics.lastTimeSynced = async function(options)
+{
+    let last_sync = 0;
+    if(options?.channel_tag && options?.db)
+    {
+        // Get the last time the data was synced
+        const channel = await options.db.collection("channels").findOne({ 
+            channel_tag : options.channel_tag
+        });
+
+        last_sync = channel.channel_last_bucket_sync.getTime();
+    }
+    return last_sync;
+};
+
+/**
+ * Get the data that has not been uploaded to the cloud yet
+ * @param {Object} options The options to get the data
+ * @param {Date | Number} options.last_sync The last time the data was synced, if not provided it will be fetched from the channel document 
+ * @param {String} options.channel_tag The channel tag to get the data from, only used if last_sync is not provided
+ * @param {Object} options.db The database to get the channel document from, only used if last_sync is not provided
+ * @returns {Array} The data that has not been uploaded to the cloud yet
+ */
+channeldataBucketSchema.statics.getNotUploadedData = async function(options)
+{
+    // Get the last time the data was synced
+    let last_sync = options?.last_sync ?? await this.lastTimeSynced(options);
+
+    // Get all the buckets that synced is lt size and end_date is gt last_sync
+    const buckets = await this.find({  
+        end_date: { 
+            $gt: new Date(last_sync) 
+        }
+    });
+
+    return buckets;
+};
+
+/**
+ * Get the data in the specified date range
+ * @param {Date | Number} start_date The start date of the date range
+ * @param {Date | Number} end_date The end date of the date range
+ * @param {Boolean} plain If true, the data will be returned as an array of data points, otherwise it will be returned as an array of buckets
+ * @returns {Array} The data in the specified date range. It will be an array of data points if plain is true, otherwise it will be an array of buckets
+ */
+channeldataBucketSchema.statics.getData = async function(start_date, end_date, plain = false)
+{
+    // Get the data in the specified date range
+    const data = await this.find({ 
+        start_date: { 
+            $gte: new Date(start_date), 
+            $lt: new Date(end_date) 
+        }
+    });
+
+    return plain ? data.flatMap(bucket => bucket.data) : data;
+};
+
+
+channeldataBucketSchema.statics.upsertBucket = async function(bucket)
+{
+    const date = new Date(bucket.start_date);
+    date.setMinutes(0);
+    date.setSeconds(0);
+    date.setMilliseconds(0);
+
+    const result = await this.updateOne(
+        { 
+            start_date: date 
+        }, 
+        { 
+            $set: 
+            { 
+                data: bucket.data,
+                size: bucket.size,
+                sum: bucket.sum,
+                end_date: new Date(date.getTime() + 1000 * 60 * 60),
+            } 
+        }, 
+        { 
+            upsert: true 
+        }
+    );
+
+    return result;
+};
+
+module.exports = channeldataBucketSchema;

package/app/models/Event.js

@@ -0,0 +1,78 @@
+const mongoose = require("mongoose");
+const mongoose_paginate = require("mongoose-paginate-v2");
+const mongoose_aggregate_paginate = require("mongoose-aggregate-paginate-v2");
+const { EventCategories } = require("app/types/event.types");
+
+const eventSchema = new mongoose.Schema({
+    event_message: {
+        type: String,
+        required: true
+    },
+    event_source: {
+        type: String,
+        required: true
+    },
+    event_category: {
+        type: String,
+        required: true,
+        enum: Object.values(EventCategories)
+    },
+    event_type: {
+        type: String,
+        required: true
+    },
+    event_timestamp: {
+        type: Date,
+        default: Date.now,
+        expires: 60 * 60 * 24 * 7 * 365 // 1 year
+    },
+    event_data: {
+        type: Object
+    }
+}, {
+    timestamps: {
+        createdAt: true,
+        updatedAt: false
+    },
+    versionKey: false,
+    capped: {
+        size: 1000000,
+        max: 10000
+    },
+    toJSON: {
+        transform: function (doc, ret) 
+        {
+            ret.id = ret._id;
+            delete ret._id;
+            delete ret.createdAt;
+            ret.event_timestamp = ret.event_timestamp.getTime();
+        }
+    }
+});
+
+/**
+ * ///////////////////////////////////////////////
+ * /////////////     INDEXES     /////////////////
+ * ///////////////////////////////////////////////
+ */
+
+/**
+ * Index used primarily for filtering by channel_tag 
+ */
+historySchema.index({ "channel_tag" : 1 });
+
+/**
+ * Index used primarily for filtering by timestamp 
+ */
+historySchema.index({ "timestamp" : 1 });
+
+
+/**
+ * ///////////////////////////////////////////////
+ * /////////////     PLUGINS     /////////////////
+ * ///////////////////////////////////////////////
+ */
+historySchema.plugin(mongoose_paginate);
+historySchema.plugin(mongoose_aggregate_paginate);
+
+module.exports = eventSchema;

package/app/models/History.js

@@ -0,0 +1,101 @@
+const mongoose = require("mongoose");
+const mongoose_paginate = require("mongoose-paginate-v2");
+const mongoose_aggregate_paginate = require("mongoose-aggregate-paginate-v2");
+const { AlarmTypes, AlarmPriorities, AlarmStates, DiamarAlarmStates } = require("@types/alarm.types");
+
+const historySchema = new mongoose.Schema({
+    timestamp: {
+        type: Date,
+        required: true,
+        default: Date.now,
+    },
+    channel_tag: {
+        type: String,
+        required: true,
+    },
+    alarm_priority: {
+        type: String,
+        required: true,
+        enum: Object.values(AlarmPriorities),
+    },
+    original_alarm_state: {
+        type: String,
+        required: true,
+        enum: Object.values(DiamarAlarmStates),
+    },
+    alarm_state: {
+        type: String,
+        required: true,
+        enum: Object.values(AlarmStates),
+    },
+    alarm_type: {
+        type: String,
+        required: true,
+        enum: Object.values(AlarmTypes),
+    },
+    alarm_value: {
+        type: Number,
+        required: false,
+    },
+    alarm_message: {
+        type: String,
+        required: false,
+    },
+    metadata: {
+        type: Object,
+    }
+}, {
+    timestamps: {
+        createdAt: false,
+        updatedAt: false
+    },
+    versionKey: false,
+    collection: "history",
+    toJSON: {
+        transform: function (doc, ret) 
+        {
+            ret.id = ret._id;
+            delete ret._id;
+            delete ret.__v;
+            ret.alarm = {
+                priority: ret.alarm_priority,
+                state: ret.original_alarm_state ?? "Inactive",
+                type: ret.alarm_type,
+                value: ret.alarm_value === null ? "inf" : `${ret.alarm_value}`,
+                timestamp: new Date(ret.timestamp).getTime()
+            };
+            delete ret.alarm_priority;
+            delete ret.alarm_state;
+            delete ret.alarm_type;
+            delete ret.alarm_value;
+        },
+    },
+});
+
+/**
+ * ///////////////////////////////////////////////
+ * /////////////     INDEXES     /////////////////
+ * ///////////////////////////////////////////////
+ */
+
+/**
+ * Index used primarily for filtering by channel_tag 
+ */
+historySchema.index({ "channel_tag" : 1 });
+
+/**
+ * Index used primarily for filtering by timestamp 
+ */
+historySchema.index({ "timestamp" : 1 });
+
+
+/**
+ * ///////////////////////////////////////////////
+ * /////////////     PLUGINS     /////////////////
+ * ///////////////////////////////////////////////
+ */
+historySchema.plugin(mongoose_paginate);
+historySchema.plugin(mongoose_aggregate_paginate);
+
+
+module.exports = historySchema;

package/app/models/Unit.js

@@ -0,0 +1,65 @@
+const mongoose = require("mongoose");
+const mongoosePaginate = require("mongoose-paginate-v2");
+const mongooseAggregatePaginate = require("mongoose-aggregate-paginate-v2");
+
+const unitSchema = new mongoose.Schema({
+    unit_id: {
+        type: String,
+        required: true,
+        unique: true,
+    },
+    unit_enabled: {
+        type: Boolean,
+        required: true,
+    },
+    unit_type: {
+        type: String,
+        required: true,
+    },
+    unit_internal_description: {
+        type: String,
+        required: true,
+    },
+    unit_cabinet_id: {
+        type: String,
+        required: true,
+    },
+}, {
+    timestamps: true,
+    collection: "units",
+    toJSON: {
+        transform: function (doc, ret) 
+        {
+            ret.id = ret._id;
+            delete ret._id;
+            delete ret.__v;
+        }
+    }
+});
+
+/**
+ * ///////////////////////////////////////////////
+ * /////////////     INDEXES     /////////////////
+ * ///////////////////////////////////////////////
+ */
+
+/**
+ * Index used primarily for filtering by unit_id 
+ */
+unitSchema.index({ "unit_id" : 1 });
+
+/**
+ * Index used primarily for filtering by unit_internal_description 
+ */
+unitSchema.index({ "unit_internal_description" : 1 });
+
+
+/**
+ * ///////////////////////////////////////////////
+ * /////////////     PLUGINS     /////////////////
+ * ///////////////////////////////////////////////
+ */
+unitSchema.plugin(mongoosePaginate);
+unitSchema.plugin(mongooseAggregatePaginate);
+
+module.exports = unitSchema;

package/app/models/docs/Channel.json

@@ -0,0 +1,3 @@
+{
+    
+}

package/app/models/docs/ChannelDataBucket.json

@@ -0,0 +1,3 @@
+{
+    
+}

package/app/models/docs/Event.json

@@ -0,0 +1,3 @@
+{
+    
+}

package/app/models/docs/History.json

@@ -0,0 +1,3 @@
+{
+    
+}

package/app/models/docs/Unit.json

@@ -0,0 +1,3 @@
+{
+    
+}

package/app/types/alarm.types.js

@@ -0,0 +1,51 @@
+const AlarmPriorities =
+{
+    CRITICAL:   "Critical",
+    ALARM:      "Alarm",
+    WARNING:    "Warning",
+}
+
+const DiamarAlarmStates =
+{
+    INACTIVE:       "Inactive",
+    ACKNOWLEDGED:   "Acknowledged",
+    ACTIVE:         "Active",
+    UNACKNOWLEDGED: "Unacknowledged",
+    UNDEFINED:      "Undefined",
+};
+
+const CloudAlarmStates = 
+{
+    INACTIVE:       "Inactive",
+    ALARM:          "Active",
+    ALARM_ACK:      "Acknowledged",
+    WARNING:        "WarningActive",
+    WARNING_ACK:    "WarningAcknowledged",
+    RETURN_NO_ACK:  "Unacknowledged",
+    INHIBITED:      "Inhibited",
+};
+
+const AlarmTypes =
+{
+    NORMAL:         "Normal",
+    ALARM_OPEN:     "AlarmOpen",
+    ALARM_CLOSE:    "AlarmClose",
+    ALARM_IFH:      "AlarmIfh",
+    ALARM_HH:       "AlarmHh",
+    ALARM_H:        "AlarmH",
+    ALARM_L:        "AlarmL",
+    ALARM_LL:       "AlarmLl",
+    ALARM_IFL:      "AlarmIfl",
+    ALARM_OFFSCAN:  "AlarmOffscan",
+    ALARM_FAIL:     "AlarmFail",
+    ALARM_INH:      "AlarmInh",
+    ALARM_UNK:      "AlarmUnk",
+}
+
+module.exports =
+{
+    AlarmPriorities,
+    DiamarAlarmStates,
+    CloudAlarmStates,
+    AlarmTypes,
+};

package/app/types/event.types.js

@@ -0,0 +1,14 @@
+const EventCategories = 
+{
+    ACCESS_CONTROL:     "ACCESS_CONTROL",
+    REQUEST_FAILURE:    "REQUEST_FAILURE",
+    OS:                 "OS",
+    CONTROL:            "CONTROL",
+    BACKUP:             "BACKUP",
+    CONFIG_CHANGE:      "CONFIG_CHANGE",
+    LOGS:               "LOGS"
+};
+
+module.exports = {
+    EventCategories,
+};

package/index.js

@@ -0,0 +1,53 @@
+/**
+ * SCHEMAS
+ */
+const Channel = require("app/models/channel");
+const ChannelDataBucket = require("app/models/channelDataBucket");
+const Event = require("app/models/event");
+const History = require("app/models/history");
+const Unit = require("app/models/unit");
+
+const Schemas = {
+    Channel,
+    ChannelDataBucket,
+    Event,
+    History,
+    Unit,
+};
+
+/**
+ * DOCS
+ */
+const ChannelDocs = require("app/models/docs/channel.docs");
+const ChannelDataBucketDocs = require("app/models/docs/channelDataBucket.docs");
+const EventDocs = require("app/models/docs/event.docs");
+const HistoryDocs = require("app/models/docs/history.docs");
+const UnitDocs = require("app/models/docs/unit.docs");
+
+const Docs = {
+    ChannelDocs,
+    ChannelDataBucketDocs,
+    EventDocs,
+    HistoryDocs,
+    UnitDocs,
+};
+
+/**
+ * TYPES
+ */
+const { AlarmTypes, AlarmPriorities, AlarmStates, DiamarAlarmStates } = require("app/types/alarm.types");
+const { EventCategories } = require("app/types/event.types");
+
+const Types = {
+    AlarmTypes,
+    AlarmPriorities,
+    AlarmStates,
+    DiamarAlarmStates,
+    EventCategories,
+};
+
+module.exports = {
+    Schemas,
+    Docs,
+    Types,
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+    "name": "@sedni/cloud_common",
+    "version": "1.0.0",
+    "description": "Common package for all types, resources and tools of Diamar Cloud",
+    "main": "index.js",
+    "scripts": {
+        "test": "mocha",
+        "coverage": "nyc --include 'app/**/*controller.js' mocha",
+        "lint": "eslint app/*",
+        "lint:fix": "eslint --fix app/*"
+    },
+    "author": "Jose Luis Silvestre García",
+    "license": "ISC",
+    "dependencies": {
+        "mongoose": "^8.7.1",
+        "mongoose-aggregate-paginate-v2": "^1.1.2",
+        "mongoose-paginate-v2": "^1.8.5"
+    },
+    "devDependencies": {
+        "chai": "^5.1.1",
+        "eslint": "^8.57.0",
+        "eslint-plugin-node": "^11.1.0",
+        "mocha": "^10.7.3",
+        "nyc": "^17.0.0",
+        "supertest": "^7.0.0"
+    }
+}