@sedni/cloud_common 3.0.3 → 3.0.5

package/dist/models/ChannelDataPoint.js

@@ -0,0 +1,75 @@
+import mongoose from "mongoose";
+import mongoosePaginate from "mongoose-paginate-v2";
+import mongooseAggregatePaginate from "mongoose-aggregate-paginate-v2";
+/**
+ * Cambiar por timestamp, value y channel_id.
+ * Luego en los indices, agregar un indice compuesto por channel_id y timestamp.
+ */
+const channelDataPointSchema = new mongoose.Schema({
+    c: {
+        type: String,
+        required: true,
+        index: true,
+        alias: "channel_id"
+    },
+    t: {
+        type: Date,
+        required: true,
+        alias: "timestamp"
+    },
+    v: {
+        type: Number,
+        required: true,
+        alias: "value"
+    }
+}, {
+    collection: "channel_data_points",
+    timestamps: false,
+    timeseries: {
+        timeField: "t",
+        metaField: "c",
+        granularity: "seconds"
+    },
+    toJSON: { getters: true },
+    toObject: { getters: true },
+    versionKey: false
+});
+/**
+ * ///////////////////////////////////////////////
+ * /////////////     INDEXES     /////////////////
+ * ///////////////////////////////////////////////
+ */
+channelDataPointSchema.index({ c: 1, t: 1 });
+/**
+ * Index used to delete old buckets automatically.
+ * This function will need to be called to create the TTL index.
+ * The index will expire documents after the specified time in seconds.
+ * The default is set to one year, but it can be changed by passing the expirationTimeInSeconds parameter.
+ */
+const oneYear = 60 * 60 * 24 * 365; // One year in seconds
+channelDataPointSchema.addTTLIndex = function (expirationTimeInSeconds = oneYear, ttlField = "t", metaField = "c") {
+    this.index({
+        [ttlField]: 1
+    }, {
+        expireAfterSeconds: expirationTimeInSeconds,
+        partialFilterExpression: {
+            [metaField]: {
+                $exists: true
+            }
+        },
+        name: "ttl_index_" + ttlField
+    });
+};
+/**
+ * ///////////////////////////////////////////////
+ * ////////////     FUNCTIONS     ////////////////
+ * ///////////////////////////////////////////////
+ */
+/**
+ * ///////////////////////////////////////////////
+ * /////////////     PLUGINS     /////////////////
+ * ///////////////////////////////////////////////
+ */
+channelDataPointSchema.plugin(mongoosePaginate);
+channelDataPointSchema.plugin(mongooseAggregatePaginate);
+export default channelDataPointSchema;

package/dist/models/Event.d.ts

@@ -0,0 +1,28 @@
+import mongoose from "mongoose";
+import { EventCategories, EventCriticalities } from "../types/event.types.js";
+export type EventDocument = mongoose.Document & {
+    event_message: string;
+    event_source: string;
+    event_user?: string;
+    event_category: typeof EventCategories;
+    event_criticality: typeof EventCriticalities;
+    event_type: string;
+    event_timestamp: Date;
+    event_data?: Object;
+};
+export type EventModel = mongoose.PaginateModel<EventDocument> & mongoose.AggregatePaginateModel<EventDocument>;
+export type EventJSON = {
+    id: string;
+    event_message: string;
+    event_source: string;
+    event_user?: string;
+    event_category: typeof EventCategories;
+    event_criticality: typeof EventCriticalities;
+    event_type: string;
+    event_timestamp: number;
+    event_data?: Object;
+};
+declare const eventSchema: mongoose.Schema<EventDocument> & {
+    addTTLIndex?: (expirationTimeInSeconds?: number, ttlField?: string) => void;
+};
+export default eventSchema;

package/dist/models/Event.js

@@ -0,0 +1,84 @@
+import mongoose from "mongoose";
+import mongoosePaginate from "mongoose-paginate-v2";
+import mongooseAggregatePaginate from "mongoose-aggregate-paginate-v2";
+import { EventCategories, EventCriticalities } from "../types/event.types.js";
+const eventSchema = new mongoose.Schema({
+    event_message: {
+        type: String,
+        required: true
+    },
+    event_source: {
+        type: String,
+        required: true
+    },
+    event_user: {
+        type: String,
+        required: false
+    },
+    event_category: {
+        type: String,
+        required: true,
+        enum: Object.values(EventCategories)
+    },
+    event_criticality: {
+        type: String,
+        required: true,
+        enum: Object.values(EventCriticalities)
+    },
+    event_type: {
+        type: String,
+        required: true
+    },
+    event_timestamp: {
+        type: Date,
+        default: Date.now
+    },
+    event_data: {
+        type: Object
+    }
+}, {
+    timestamps: {
+        createdAt: true,
+        updatedAt: false
+    },
+    versionKey: false,
+    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 event_type
+ */
+eventSchema.index({ event_type: 1 });
+/**
+ * Index used primarily for filtering by event_category
+ */
+eventSchema.index({ event_category: 1 });
+/**
+ * Index used to delete old events automatically.
+ * This function will need to be called to create the TTL index.
+ * The index will expire documents after the specified time in seconds.
+ * The default is set to one year, but it can be changed by passing the expirationTimeInSeconds parameter.
+ */
+const oneYear = 60 * 60 * 24 * 365; // One year in seconds
+eventSchema.addTTLIndex = function (expirationTimeInSeconds = oneYear, ttlField = "event_timestamp") {
+    this.index({ [ttlField]: 1 }, { expireAfterSeconds: expirationTimeInSeconds });
+};
+/**
+ * ///////////////////////////////////////////////
+ * /////////////     PLUGINS     /////////////////
+ * ///////////////////////////////////////////////
+ */
+eventSchema.plugin(mongoosePaginate);
+eventSchema.plugin(mongooseAggregatePaginate);
+export default eventSchema;

package/dist/models/History.d.ts

@@ -0,0 +1,30 @@
+import mongoose from "mongoose";
+import { AlarmPriorities, AlarmTypes, CloudAlarmStates, DiamarAlarmStates } from "../types/alarm.types.js";
+export type HistoryDocument = mongoose.Document & {
+    channel_tag: string;
+    alarm_timestamp: Date;
+    alarm_priority: typeof AlarmPriorities;
+    alarm_original_state: typeof DiamarAlarmStates;
+    alarm_state: typeof CloudAlarmStates;
+    alarm_type: typeof AlarmTypes;
+    alarm_value?: number;
+    alarm_message?: string;
+    alarm_data?: Object;
+};
+export type HistoryModel = mongoose.PaginateModel<HistoryDocument> & mongoose.AggregatePaginateModel<HistoryDocument>;
+export type HistoryJSON = {
+    id: string;
+    channel_tag: string;
+    alarm_timestamp: number;
+    alarm_priority: typeof AlarmPriorities;
+    alarm_original_state: typeof DiamarAlarmStates;
+    alarm_state: typeof CloudAlarmStates;
+    alarm_type: typeof AlarmTypes;
+    alarm_value?: number;
+    alarm_message?: string;
+    alarm_data?: Object;
+};
+declare const historySchema: mongoose.Schema<HistoryDocument> & {
+    addTTLIndex?: (expirationTimeInSeconds?: number, ttlField?: string) => void;
+};
+export default historySchema;

package/dist/models/History.js

@@ -0,0 +1,96 @@
+import mongoose from "mongoose";
+import mongoosePaginate from "mongoose-paginate-v2";
+import mongooseAggregatePaginate from "mongoose-aggregate-paginate-v2";
+import { AlarmPriorities, AlarmTypes, CloudAlarmStates, DiamarAlarmStates } from "../types/alarm.types.js";
+const historySchema = new mongoose.Schema({
+    channel_tag: {
+        type: String,
+        required: true
+    },
+    alarm_timestamp: {
+        type: Date,
+        required: true,
+        default: Date.now
+    },
+    alarm_priority: {
+        type: String,
+        required: true,
+        enum: Object.values(AlarmPriorities)
+    },
+    alarm_original_state: {
+        type: String,
+        required: true,
+        enum: Object.values(DiamarAlarmStates)
+    },
+    alarm_state: {
+        type: String,
+        required: true,
+        enum: Object.values(CloudAlarmStates)
+    },
+    alarm_type: {
+        type: String,
+        required: true,
+        enum: Object.values(AlarmTypes)
+    },
+    alarm_value: {
+        type: Number,
+        required: false
+    },
+    alarm_message: {
+        type: String,
+        required: false
+    },
+    alarm_data: {
+        type: Object,
+        required: false
+    }
+}, {
+    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_timestamp = new Date(ret.alarm_timestamp).getTime();
+            ret.alarm = {
+                alarm_priority: ret.alarm_priority,
+                alarm_state: ret.alarm_original_state ?? "Inactive",
+                alarm_type: ret.alarm_type,
+                alarm_value: ret.alarm_value === null ? "inf" : `${ret.alarm_value}`,
+                alarm_timestamp: new Date(ret.alarm_timestamp).getTime()
+            };
+        }
+    }
+});
+/**
+ * ///////////////////////////////////////////////
+ * /////////////     INDEXES     /////////////////
+ * ///////////////////////////////////////////////
+ */
+/**
+ * Index used primarily for filtering by channel_tag
+ */
+historySchema.index({ channel_tag: 1 });
+/**
+ * Index used to delete old alarms automatically.
+ * This function will need to be called to create the TTL index.
+ * The index will expire documents after the specified time in seconds.
+ * The default is set to one year, but it can be changed by passing the expirationTimeInSeconds parameter.
+ */
+const oneYear = 60 * 60 * 24 * 365; // One year in seconds
+historySchema.addTTLIndex = function (expirationTimeInSeconds = oneYear, ttlField = "alarm_timestamp") {
+    this.index({ [ttlField]: 1 }, { expireAfterSeconds: expirationTimeInSeconds });
+};
+/**
+ * ///////////////////////////////////////////////
+ * /////////////     PLUGINS     /////////////////
+ * ///////////////////////////////////////////////
+ */
+historySchema.plugin(mongoosePaginate);
+historySchema.plugin(mongooseAggregatePaginate);
+export default historySchema;

package/dist/models/Unit.d.ts

@@ -0,0 +1,50 @@
+import mongoose from "mongoose";
+import { UnitTypes } from "../types/unit.types.js";
+export type UnitDocument = mongoose.Document & {
+    unit_id: string;
+    unit_enabled: boolean;
+    unit_type: typeof UnitTypes;
+    unit_internal_description: string;
+    unit_cabinet_id?: string;
+};
+export type UnitModel = mongoose.PaginateModel<UnitDocument> & mongoose.AggregatePaginateModel<UnitDocument>;
+export type UnitJSON = {
+    id: string;
+    unit_id: string;
+    unit_enabled: boolean;
+    unit_type: typeof UnitTypes;
+    unit_internal_description: string;
+    unit_cabinet_id?: string;
+    createdAt: Date;
+    updatedAt: Date;
+};
+declare const unitSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+    collection: string;
+    toJSON: {
+        transform: (doc: UnitDocument, ret: any) => void;
+    };
+}, {
+    unit_id: string;
+    unit_enabled: boolean;
+    unit_type: "Aim18" | "Dim36" | "Diom24" | "Klim" | "Lum" | "Pmm" | "Slim" | "Tim28";
+    unit_internal_description: string;
+    unit_cabinet_id?: string | null | undefined;
+} & mongoose.DefaultTimestampProps, UnitDocument, {
+    [path: string]: mongoose.SchemaDefinitionProperty<undefined, any, any>;
+} | {
+    [x: string]: mongoose.SchemaDefinitionProperty<any, any, UnitDocument> | undefined;
+}, {
+    unit_id: string;
+    unit_enabled: boolean;
+    unit_type: "Aim18" | "Dim36" | "Diom24" | "Klim" | "Lum" | "Pmm" | "Slim" | "Tim28";
+    unit_internal_description: string;
+    unit_cabinet_id?: string | null | undefined;
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export default unitSchema;

package/dist/models/Unit.js

@@ -0,0 +1,58 @@
+import mongoose from "mongoose";
+import mongoosePaginate from "mongoose-paginate-v2";
+import mongooseAggregatePaginate from "mongoose-aggregate-paginate-v2";
+import { UnitTypes } from "../types/unit.types.js";
+const unitSchema = new mongoose.Schema({
+    unit_id: {
+        type: String,
+        required: true
+    },
+    unit_enabled: {
+        type: Boolean,
+        required: true
+    },
+    unit_type: {
+        type: String,
+        required: true,
+        enum: Object.values(UnitTypes)
+    },
+    unit_internal_description: {
+        type: String,
+        required: true
+    },
+    unit_cabinet_id: {
+        type: String,
+        required: false
+    }
+}, {
+    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 and ensuring uniqueness
+ */
+unitSchema.index({ unit_id: 1 }, { unique: true });
+/**
+ * Index used primarily for filtering by unit_internal_description
+ */
+unitSchema.index({ unit_internal_description: 1 });
+/**
+ * ///////////////////////////////////////////////
+ * /////////////     PLUGINS     /////////////////
+ * ///////////////////////////////////////////////
+ */
+unitSchema.plugin(mongoosePaginate);
+unitSchema.plugin(mongooseAggregatePaginate);
+export default unitSchema;

package/dist/models/docs/Channel.json

@@ -0,0 +1,58 @@
+{
+    "components": {
+        "schemas": {
+            "Channel": {
+                "type": "object",
+                "properties": {
+                    "id": {
+                        "type": "string",
+                        "format": "ObjectId",
+                        "description": "MongoDB ObjectId",
+                        "example": "507f1f77bcf86cd799439011",
+                        "readOnly": true
+                    },
+                    "channel_tag": {
+                        "type": "string",
+                        "description": "Channel tag",
+                        "example": "MOTOR_PS_TEMP",
+                        "readOnly": true
+                    },
+                    "channel_description": {
+                        "type": "string",
+                        "description": "Channel description",
+                        "example": "Motor Power Supply Temperature",
+                        "readOnly": true
+                    },
+                    "channel_unit_id": {
+                        "type": "string",
+                        "format": "ObjectId",
+                        "description": "Unit of the channel",
+                        "example": "507f1f77bcf86cd799439011",
+                        "readOnly": true
+                    },
+                    "channel_parsed": {
+                        "type": "object",
+                        "description": "Parsed channel data",
+                        "readOnly": true
+                    }
+                },
+                "required": [
+                    "channel_tag",
+                    "channel_description",
+                    "channel_unit_id",
+                    "channel_parsed"
+                ]
+            }
+        },
+        "examples": {
+            "Channel": {
+                "value": {
+                    "id": "507f1f77bcf86cd799439011",
+                    "channel_tag": "MOTOR_PS_TEMP",
+                    "channel_description": "Motor Power Supply Temperature",
+                    "channel_type": "Analogic"
+                }
+            }
+        }
+    }
+}

package/dist/models/docs/ChannelDataBucket.json

@@ -0,0 +1,77 @@
+{
+    "components": {
+        "schemas": {
+            "ChannelData": {
+                "type": "object",
+                "description": "ChannelData object. This is the bucket where the data is stored, in batches of 1 hour.",
+                "properties": {
+                    "id": {
+                        "type": "string",
+                        "format": "ObjectId",
+                        "description": "MongoDB ObjectId",
+                        "example": "507f1f77bcf86cd799439011",
+                        "readOnly": true
+                    },
+                    "start_date": {
+                        "type": "string",
+                        "format": "date-time",
+                        "description": "Start date of the data",
+                        "example": "2024-07-03T10:15:30Z",
+                        "readOnly": true
+                    },
+                    "end_date": {
+                        "type": "string",
+                        "format": "date-time",
+                        "description": "End date of the data",
+                        "example": "2024-07-03T11:15:30Z",
+                        "readOnly": true
+                    },
+                    "data": {
+                        "type": "array",
+                        "description": "Data array of DataPoint objects",
+                        "items": {
+                            "$ref": "#/components/schemas/DataPoint"
+                        },
+                        "readOnly": false
+                    },
+                    "size": {
+                        "type": "integer",
+                        "format": "int64",
+                        "description": "Size of the data array",
+                        "example": 60,
+                        "readOnly": true
+                    },
+                    "synced": {
+                        "type": "TODO",
+                        "description": "TODO",
+                        "example": "TODO",
+                        "readOnly": true
+                    },
+                    "sum": {
+                        "type": "number",
+                        "format": "double",
+                        "description": "Sum of the data",
+                        "example": 69.420,
+                        "readOnly": true
+                    }
+                }
+            }
+        },
+        "examples": {
+            "ChannelData": {
+                "id": "507f1f77bcf86cd799439011",
+                "start_date": "2024-07-03T10:15:30Z",
+                "end_date": "2024-07-03T11:15:30Z",
+                "data": [
+                    {
+                        "t": 1710251647000,
+                        "v": 69.420
+                    }
+                ],
+                "size": 60,
+                "synced": "TODO",
+                "sum": 69.420
+            }
+        }
+    }
+}

package/dist/models/docs/ChannelDataPoint.json

@@ -0,0 +1,39 @@
+{
+    "components": {
+        "schemas": {
+            "ChannelDataPoint": {
+                "type": "object",
+                "description": "ChannelDataPoint object. This is the object that is sent to and from the API. It includes only the timestamp and the value. No id is included because the data is stored inside a larger bucket in the database.",
+                "properties": {
+                    "c": {
+                        "type": "string",
+                        "description": "Channel ID associated with the data point",
+                        "example": "U001_001",
+                        "readOnly": true
+                    },
+                    "t": {
+                        "type": "integer",
+                        "format": "int64",
+                        "description": "Timestamp of the data",
+                        "example": 1710251647000,
+                        "readOnly": true
+                    },
+                    "v": {
+                        "type": "number",
+                        "format": "double",
+                        "description": "Value of the data",
+                        "example": 69.420,
+                        "readOnly": true
+                    }
+                }
+            }
+        },
+        "examples": {
+            "ChannelDataPoint": {
+                "c": "U001_001",
+                "t": 1710251647000,
+                "v": 69.420
+            }
+        }
+    }
+}

package/dist/models/docs/ChannelWithData.json

@@ -0,0 +1,58 @@
+{
+    "components": {
+        "schemas": {
+            "ChannelWithData": {
+                "allOf": [
+                    {
+                        "$ref": "#/components/schemas/Channel"
+                    },
+                    {
+                        "type": "object",
+                        "properties": {
+                            "channel_latest_value": {
+                                "type": "string",
+                                "description": "Latest value of the channel",
+                                "example": "25.0",
+                                "readOnly": true
+                            },
+                            "channel_latest_timestamp": {
+                                "type": "string",
+                                "format": "date-time",
+                                "description": "Timestamp of the latest value",
+                                "example": 1700034034,
+                                "readOnly": true
+                            },
+                            "channel_alarm_state": {
+                                "type": "string",
+                                "description": "Alarm state of the channel",
+                                "example": "NoAlarm",
+                                "readOnly": true
+                            }
+                        }
+                    }
+                ],
+                "required": [
+                    "channel_tag",
+                    "channel_description",
+                    "channel_type",
+                    "channel_latest_value",
+                    "channel_latest_timestamp",
+                    "channel_alarm_state"
+                ]
+            }
+        },
+        "examples": {
+            "ChannelWithData": {
+                "value": {
+                    "id": "507f1f77bcf86cd799439011",
+                    "channel_tag": "MOTOR_PS_TEMP",
+                    "channel_description": "Motor Power Supply Temperature",
+                    "channel_type": "Analogic",
+                    "channel_latest_value": 420.69,
+                    "channel_latest_timestamp": 1700034034,
+                    "channel_alarm_state": "NoAlarm"
+                }
+            }
+        }
+    }
+}