mqtt-devices-parser 1.0.0

package/models/permissions.models.js

@@ -0,0 +1,26 @@
+
+module.exports = (sequelize,DataTypes)=>{
+	return sequelize.define("permissions", {
+		client_id: {
+			type: DataTypes.INTEGER,
+			references: {
+				model: 'clients',
+				key: 'id'
+			}
+		},
+		device_id: {
+			type: DataTypes.INTEGER,
+			references: {
+				model: 'devices',
+				key: 'id'
+			}
+		},
+		level: {
+			type: DataTypes.INTEGER,
+		}
+	},
+	{
+		tableName: 'permissions',
+		freezeTableName: true
+	})
+}

package/models/projects.models.js

@@ -0,0 +1,24 @@
+
+module.exports = (sequelize,DataTypes)=>{
+	return sequelize.define("projects", {
+		name: {
+			type: DataTypes.STRING,
+			unique: true
+		},
+		description: {
+			type: DataTypes.STRING
+		},
+		project_table: {
+			type: DataTypes.STRING,
+			allowNull: true
+		},
+		logs_table: {
+			type: DataTypes.STRING,
+			allowNull: true
+		},
+	},
+	{
+		tableName: 'projects',
+		freezeTableName: true
+	})
+}

package/models/sensor_logs.models.js

@@ -0,0 +1,41 @@
+module.exports = (sequelize,DataTypes)=>{
+	return sequelize.define("sensor_logs", {
+		device_id: {
+			type: DataTypes.INTEGER,
+			unique: false,
+			allowNull: false,
+			references: {
+				model: 'devices',
+				key: 'id'
+			}
+		},
+		sensor_id: {
+			type: DataTypes.INTEGER,
+			unique: false,
+			allowNull: false,
+			references: {
+				model: 'sensors',
+				key: 'id'
+			}
+		},
+		value: {
+			type: DataTypes.STRING,
+			allowNull: true,
+		},
+		cliend_id: {
+			type: DataTypes.INTEGER,
+			unique: false,
+			allowNull: true,
+			references: {
+				model: 'clients',
+				key: 'id'
+			}
+		},
+
+	},
+	{
+		tableName: 'sensor_logs',
+		freezeTableName: true
+	})
+}
+

package/models/sensors.models.js

@@ -0,0 +1,40 @@
+
+module.exports = (sequelize,DataTypes)=>{
+	return sequelize.define("sensors", {
+		model_id: {
+			type: DataTypes.INTEGER,
+			unique: false,
+			allowNull: false,
+			references: {
+				model: 'models',
+				key: 'id'
+			}
+		},
+		active: {
+			type: DataTypes.BOOLEAN,
+			allowNull: false,
+			defaultValue: true
+		},
+		ref: {
+			type: DataTypes.STRING,
+			allowNull: false,
+		},
+		name: {
+			type: DataTypes.STRING,
+			allowNull: false,
+		},
+		type: {
+			type: DataTypes.STRING,
+			allowNull: false,
+		},
+		graph: {
+			type: DataTypes.JSON,
+			allowNull: true,
+		}
+	},
+	{
+		tableName: 'sensors',
+		freezeTableName: true
+	})
+}
+

package/models/users.models.js

@@ -0,0 +1,19 @@
+
+module.exports = (sequelize,DataTypes)=>{
+	return sequelize.define("users", {
+		type: {
+			type: DataTypes.STRING(32),
+			unique: true
+		},
+		password: {
+			type: DataTypes.STRING
+		},
+		level: {
+			type: DataTypes.INTEGER
+		}
+	},
+	{
+		tableName: 'users',
+		freezeTableName: true
+	})
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "mqtt-devices-parser",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "async": "^3.2.4",
+    "lodash": "^4.17.21",
+    "md5": "^2.3.0",
+    "moment": "^2.29.4",
+    "mqtt": "^5.0.3",
+    "mysql2": "^3.2.0",
+    "net": "^1.0.2",
+    "path": "^0.12.7",
+    "semver": "^7.3.8",
+    "sequelize": "^6.32.1",
+    "websocket-stream": "^5.5.2"
+  }
+}

package/src/aux/parser.js

@@ -0,0 +1,20 @@
+
+module.exports = {
+
+	pathIntoObject : (path,data)=>{
+		const segments = path.split("/").filter(segment => segment !== "");
+
+		let obj = {};
+		let currentObj = obj;
+
+		segments.forEach((segment, index) => {
+			if (index === segments.length - 1) {
+				currentObj[segment] = data;
+			} else {
+				currentObj[segment] = {};
+				currentObj = currentObj[segment];
+			}
+		});
+		return obj;
+	}
+}

package/src/db/data.js

@@ -0,0 +1,197 @@
+const moment = require('moment');
+var mysql = require('mysql2')
+
+var self = module.exports = {
+
+	checkEntry : async (table,deviceId)=>{
+
+	  return new Promise((resolve,reject) => {
+
+	    let query = "SELECT * FROM ?? where device_id = ?";
+	    let args = [table,deviceId];
+	    query = mysql.format(query,args);
+
+	    $.db.queryRow(query)
+	    .then( rows => {
+	      if(rows.length > 0)
+	        return resolve(rows[0]);
+	      else
+	        return resolve(null);
+	    })
+	    .catch( err => {
+	      console.log(err);
+	      return resolve(null);
+	    });
+	  });
+	},
+
+	update : async (table, deviceId, topic, payload)=>{
+
+		return new Promise( async (resolve,reject) => {
+
+			if(!payload) return resolve();
+
+			let data = null;
+			// check if data is in JSON format
+			try{
+				data = JSON.parse(payload);
+			}catch(e){
+				data = payload;
+			}
+
+			let obj = {
+				updatedAt : moment().utc().format('YYYY-MM-DD HH:mm:ss')
+			}
+
+			let db_columns = $.models.get(table);
+
+			if(db_columns == null) return resolve();
+
+			let index = topic.indexOf("/");
+
+			if(index > -1){ // check if topic has subtopics
+				let key = topic.substring(0,index);
+				topic = topic.substring(index+1);
+
+				if(db_columns.hasOwnProperty(key)){ // check if db has a column for this key
+				  // create JSON struct with the remaining topic
+				  // table is the table
+				  // key is the column
+
+				  // build object with the remaining topic and respective data
+				  if(typeof data === "object")
+				    obj[key] = JSON.stringify(parser.pathIntoObject(topic,JSON.stringify(data)))
+				  else
+				    obj[key] = JSON.stringify(parser.pathIntoObject(topic,data));
+
+				  let exists = await self.checkEntry(table,deviceId);
+				  if(!exists){
+				    obj['device_id'] = deviceId;
+				    obj['createdAt'] = moment().utc().format('YYYY-MM-DD HH:mm:ss');
+				    $.db.insert(table,obj)
+				    .then((rows)=>{
+				    	return resolve(rows);
+				    })
+				    .catch((err)=>{
+				    	console.log(err);
+				    	return resolve();
+				    })
+				  }else{
+				    let filter = {
+				      device_id : deviceId
+				    }
+				    $.db.update(table,obj,filter)
+				    .then((rows)=>{
+				    	return resolve(rows);
+				    })
+				    .catch((err)=>{
+				    	console.log(err);
+				    	return resolve();
+				    })
+				  }
+
+				}else return resolve();
+			}else{
+
+				let key = topic;
+				if(db_columns.hasOwnProperty(key)){ // check if db has a column for this key
+					// build object with respective data
+					if(typeof data === "object")
+						obj[key] = JSON.stringify(data);
+					else
+						obj[key] = data;
+
+					let exists = await self.checkEntry(table,deviceId);
+					if(!exists){
+						obj['device_id'] = deviceId;
+						obj['createdAt'] = moment().utc().format('YYYY-MM-DD HH:mm:ss');
+						$.db.insert(table,obj)
+						.then((rows)=>{
+							return resolve(rows);
+						})
+						.catch((err)=>{
+							console.log(err);
+							return resolve(null);
+						})
+					}else{
+						let filter = {
+						  device_id : deviceId
+						}
+
+						$.db.update(table,obj,filter)
+						.then((rows)=>{
+							return resolve(rows);
+						})
+						.catch((err)=>{
+							console.log(err);
+							return resolve(null);
+						})
+					}
+				}else return resolve();
+			}
+		})
+	},
+
+	addLog : async (table, deviceId, topic, payload)=>{
+
+	  return new Promise((resolve,reject) => {
+
+	    if(!payload) return resolve();
+
+		let data = null;
+		// check if data is in JSON format
+		try{
+			data = JSON.parse(payload);
+		}catch(e){
+			data = payload;
+		}
+
+		let obj = {
+			updatedAt : moment().utc().format('YYYY-MM-DD HH:mm:ss')
+		}
+
+		let db_columns = $.models.get(table);
+		if(db_columns == null)
+			return resolve();
+
+		let index = topic.indexOf("/");
+
+		if(index > -1){ // check if topic has subtopics
+			let key = topic.substring(0,index);
+			topic = topic.substring(index+1);
+
+			if(db_columns.hasOwnProperty(key)){ // check if db has a column for this key
+			  // create JSON struct with the remaining topic
+			  // key is the column
+
+			  // build object with the remaining topic and respective data
+			  if(typeof data === "object")
+			    obj[key] = JSON.stringify(parser.pathIntoObject(topic,JSON.stringify(data)))
+			  else
+			    obj[key] = JSON.stringify(parser.pathIntoObject(topic,data));
+
+			  obj['device_id'] = deviceId;
+			  obj['createdAt'] = moment().utc().format('YYYY-MM-DD HH:mm:ss');
+			  $.db.insert(table,obj)
+
+			}
+		}else{
+
+			let key = topic;
+			if(db_columns.hasOwnProperty(key)){ // check if db has a column for this key
+			  // build object with respective data
+			  if(typeof data === "object")
+			    obj[key] = JSON.stringify(data);
+			  else
+			    obj[key] = data;
+
+			  obj['device_id'] = deviceId;
+			  obj['createdAt'] = moment().utc().format('YYYY-MM-DD HH:mm:ss');
+			  $.db.insert(table,obj);
+			}
+		}
+
+	    return resolve();
+	  });
+	}
+};

package/src/db/db.js

@@ -0,0 +1,315 @@
+var config = require('../../config');
+var mysql = require('mysql2');
+
+var pool;
+
+var self = module.exports = {
+  connect : (cb)=>{
+    pool      =    mysql.createPool({
+      connectionLimit : config.mysqldb.conn_limit,
+      host     : config.mysqldb.host,
+      port     : config.mysqldb.port,
+      user     : config.mysqldb.user,
+      password : config.mysqldb.pwd,
+      database : config.mysqldb.name,
+      debug    : false
+    });
+    pool.getConnection(function(err,connection){
+        if(err) {
+          console.log("ISSUE WITH MYSQL \n" + err);
+          process.exit(1);
+        } else {
+          setInterval(function(){self.pingMySQL(connection);}, 3600000); // 1 hour
+          connection.on('error', function(err) {
+            console.log("Mysql error: "+err.code); // 'ER_BAD_DB_ERROR'
+            process.exit(1);
+          });
+          cb();
+        }
+    });
+  },
+
+  getConnection : (cb)=>{
+    pool.getConnection(function(err, connection) {
+      cb(err,connection);
+    });
+  },
+
+  pingMySQL : (connection)=>{
+    connection.ping(function (err) {
+      if (err) throw err;
+      //console.log(String(Date.now())+'Server responded to ping');
+    });
+  },
+
+  get_non_persistent_db_connection : (db_name,cb)=>{
+    let pool2      =    mysql.createPool({
+        connectionLimit : 100,
+        host     : config.mysqldb.host,
+        user     : config.mysqldb.user,
+        password : config.mysqldb.pwd,
+        database : db_name,
+        debug    :  false,
+        multipleStatements: true
+    });
+    pool2.getConnection(function(err,connection){
+      cb(err,connection);
+    });
+  },
+
+  close_db_connection : (connection)=>{
+    if(connection != null){
+      connection.release();
+    }
+  },
+
+  queryRow : async (query)=>{
+    return new Promise((resolve,reject) => {
+
+        self.getConnection((err,conn)=>{
+          if(err) return reject(err);
+
+          conn.query(query,function(err,rows){
+            self.close_db_connection(conn);
+            if(err) return reject(err)
+            else return resolve(rows);
+          });
+        });
+      });
+  },
+
+  insert : async(table,data)=>{
+
+    return new Promise((resolve,reject) => {
+      self.getConnection((err,conn)=>{
+        if(err) return reject(err);
+
+        let query = "";
+        let values = [];
+
+        if(typeof data === "object"){
+          const keys = Object.keys(data);
+          values = Object.values(data);
+          const placeholders = values.map(() => '?').join(', ');
+          query = `INSERT INTO ?? (${keys.join(', ')}) VALUES (${placeholders})`;
+        }else{
+          return reject("data passed is not an object");
+        }
+        values.unshift(table);
+        query = mysql.format(query,values);
+
+        conn.query(query,function(err,rows){
+          self.close_db_connection(conn);
+          if(err) return reject(err)
+          else return resolve(rows);
+        });
+      });
+    });
+  },
+
+  update : async (table, data, filter) => {
+
+    return new Promise((resolve, reject) => {
+      self.getConnection((err, conn) => {
+        if (err) return reject(err);
+
+        let query = "";
+        let values = [];
+
+        if (typeof data === "object") {
+          const keys = Object.keys(data);
+          values = Object.values(data);
+          query = `UPDATE ?? SET ${keys.map(key => `${key} = ?`).join(', ')}`;
+        } else {
+          return reject("data passed is not an object");
+        }
+
+        if (typeof filter === "object") {
+          const filterKeys = Object.keys(filter);
+          const filterValues = Object.values(filter);
+          query += ` WHERE ${filterKeys.map(key => `${key} = ?`).join(' AND ')}`;
+          values.push(...filterValues);
+        } else {
+          return reject("filter passed is not an object");
+        }
+
+        values.unshift(table);
+        query = mysql.format(query, values);
+
+        conn.query(query, function (err, rows) {
+          self.close_db_connection(conn);
+          if (err) return reject(err);
+          else return resolve(rows);
+        });
+      });
+    });
+  },
+
+  updateJSON : async (table, column, data, filter) => {
+
+    return new Promise((resolve, reject) => {
+      self.getConnection((err, conn) => {
+        if (err) return reject(err);
+
+        let query = "";
+        let values = [];
+
+        if (typeof data === "object") {
+          const keys = Object.keys(data);
+          query = `UPDATE ${table} SET ${column} = `;
+          keys.forEach((key, index) => {
+            query += `JSON_SET(${column}, '$.${key}', ?)`;
+            values.push(data[key]);
+            if (index !== keys.length - 1) {
+              query += ', ';
+            }
+          });
+        } else {
+          return reject("data passed is not an object");
+        }
+
+        if (typeof filter === "object") {
+          const filterKeys = Object.keys(filter);
+          const filterValues = Object.values(filter);
+          query += ` WHERE ${filterKeys.map(key => `${key} = ?`).join(' AND ')}`;
+          values.push(...filterValues);
+        } else {
+          return reject("filter passed is not an object");
+        }
+
+        query = mysql.format(query, values);
+        conn.query(query, function (err, rows) {
+          self.close_db_connection(conn);
+          if(rows.affectedRows && !rows.changedRows){
+            self.insertJSON(table,column,data,filter)
+            .then( rows => {
+              return resolve(rows);
+            })
+            .catch( err => {
+              return reject(err);
+            })
+          }else{
+            if (err) return reject(err);
+            else return resolve(rows);
+          }
+        });
+      });
+    });
+  },
+
+  insertJSON : async (table, column, data, filter) => {
+
+    return new Promise((resolve, reject) => {
+      self.getConnection((err, conn) => {
+        if (err) return reject(err);
+
+        let query = "";
+        let values = [];
+
+        if (typeof data === "object") {
+          const jsonString = JSON.stringify(data);
+          query = `UPDATE ?? SET ?? = ?`;
+          const inserts = [table, column, jsonString];
+          query = mysql.format(query, inserts);
+        } else {
+          return reject("data passed is not an object");
+        }
+
+        if (typeof filter === "object") {
+          const filterKeys = Object.keys(filter);
+          const filterValues = Object.values(filter);
+          query += ` WHERE ${filterKeys.map(key => `${key} = ?`).join(' AND ')}`;
+          values.push(...filterValues);
+        } else {
+          return reject("filter passed is not an object");
+        }
+
+        query = mysql.format(query, values);
+        conn.query(query, function (err, rows) {
+          self.close_db_connection(conn);
+          if (err) return reject(err);
+          else return resolve(rows);
+        });
+      });
+    });
+  },
+
+  delete : async(table,filter)=>{
+
+    return new Promise((resolve,reject) => {
+
+      self.getConnection((err,conn)=>{
+        if(err) return reject(err);
+
+        let query = "";
+        if(typeof filter === "object"){
+          let values = [];
+          query = `DELETE FROM ${table} WHERE `;
+          for (let key in filter){
+            if(values.length > 0)
+              query += " AND ";
+            query += key + " = ?"
+            values.push(filter[key]);
+          }
+          query = mysql.format(query,values);
+        }else{
+          return reject("filter passed is not an object");
+        }
+
+        conn.query(query,function(err,rows){
+          self.close_db_connection(conn);
+          if(err) return reject(err)
+          else return resolve(rows);
+        });
+      });
+    });
+  },
+
+  getFieldFromDeviceId : async (table,deviceId,field)=>{
+
+    return new Promise((resolve,reject) => {
+
+      self.getConnection((err,conn)=>{
+        if(err) return reject(err);
+
+        let query = "SELECT ?? FROM ?? where device_id = ?";
+        let args = [field,table,deviceId];
+        query = mysql.format(query,args);
+        conn.query(query,function(err,rows){
+          $.db.close_db_connection(conn);
+          if(err) return reject(err)
+          else{
+            if(rows.length == 1 ){
+              return resolve(rows[0][field]);
+            }else return resolve(null);
+          }
+        });
+      });
+    });
+  },
+
+  getPropertyFromDeviceId : async(table,deviceId,field,key)=>{
+
+    return new Promise((resolve,reject) => {
+
+      self.getConnection((err,conn)=>{
+        if(err) return reject(err);
+
+        let query = "SELECT ?? FROM ?? where device_id = ?";
+        let args = [field,table,deviceId];
+
+        query = mysql.format(query,args);
+        conn.query(query,function(err,rows){
+          $.db.close_db_connection(conn);
+          if(err) return reject(err)
+          else{
+            if(rows.length == 1 && rows[0]?.field && rows[0][field]?.key){
+              return resolve(rows[0][field][key]);
+            }else return resolve(null);
+          }
+        });
+      });
+    });
+  }
+}
+