class PowerModel(SQL.Model):
__tablename__ = 'power'
id = SQL.Column(SQL.Integer, primary_key=True)
date = SQL.Column(SQL.DateTime)
node_id = SQL.Column(SQL.Integer, SQL.ForeignKey('node.id'))
icpe_id = SQL.Column(SQL.Integer, SQL.ForeignKey('icpe.id'))
sensor_id = SQL.Column(SQL.Integer, SQL.ForeignKey('sensor.id'))
high = SQL.Column(SQL.Float)
low = SQL.Column(SQL.Float)
average = SQL.Column(SQL.Float)
total = SQL.Column(SQL.Float)
def __init__(self, power=0.0, date=datetime.now()):
self.high = power
self.low = power
self.average = power
self.total = power
self.date = date
def to_json(self):
node = self.node.name if self.node else None
icpe = self.icpe.mac_address if self.icpe else None
sensor = self.sensor.sensor_id if self.sensor else None
return {
'high': self.high,
'low': self.low,
'average': self.average,
'node': node,
'icpe': icpe,
'sensor': sensor,
'date': str(self.date)
}
class LocationModel(SQL.Model):
'''
One-to-one Table representing Location for iCPE
'''
__tablename__ = 'location'
id = SQL.Column(SQL.Integer, primary_key=True)
node_id = SQL.Column(SQL.Integer, SQL.ForeignKey('node.id'))
group_id = SQL.Column(SQL.Integer, SQL.ForeignKey('group.id'))
street = SQL.Column(SQL.String(30))
city = SQL.Column(SQL.String(30))
latitude = SQL.Column(SQL.String(10))
longitude = SQL.Column(SQL.String(10))
def __init__(self, street, city, latitude, longitude):
self.street = street
self.city = city
self.latitude = latitude
self.longitude = longitude
def to_json(self):
return {
'street': self.street,
'city': self.city,
'latitude': self.latitude,
'longitude': self.longitude
}
def __repr__(self):
return '<%r, %r>' % (self.street, self.city)
class EventModel(SQL.Model):
__tablename__ = 'event'
id = SQL.Column(SQL.Integer, primary_key=True)
date = SQL.Column(SQL.DateTime)
node_id = SQL.Column(SQL.Integer, SQL.ForeignKey('node.id'))
icpe_id = SQL.Column(SQL.Integer, SQL.ForeignKey('icpe.id'))
sensor_id = SQL.Column(SQL.Integer, SQL.ForeignKey('sensor.id'))
commandclass_id = SQL.Column(SQL.Integer,
SQL.ForeignKey('commandclass.id'))
commandclasstype_id = SQL.Column(SQL.Integer,
SQL.ForeignKey('commandclasstype.id'))
state = SQL.Column(SQL.Boolean)
value = SQL.Column(SQL.String(16))
critical = SQL.Column(SQL.Boolean)
normal = SQL.Column(SQL.Boolean)
def __init__(self, state, value, date=None):
self.state = bool(state)
self.value = value
self.date = date if date else datetime.now()
def to_json(self):
commandclass = self.commandclass.name
if self.sensor.name:
sensor_name = self.sensor.name
else:
sensor_name = self.sensor.sensor_id + ', ' + self.sensor.product_name
if self.commandclasstype:
commandclasstype = self.commandclasstype.name
icon = eval('NodeDefender.icpe.zwave.commandclass.'+commandclass\
+'.'+commandclasstype+'.icon')(self.value)
name = eval('NodeDefender.icpe.zwave.commandclass.'+commandclass\
+'.'+commandclasstype+'.fields')['name']
elif self.commandclass:
icon = eval('NodeDefender.icpe.zwave.commandclass.'+commandclass+\
'.icon')(self.value)
name = eval('NodeDefender.icpe.zwave.commandclass.'+commandclass+\
'.fields')['name']
return {'icpe' : self.icpe.mac_address, 'sensor' : sensor_name, 'node' :
self.icpe.node.name, 'value' : self.value,\
'date' : str(self.date), 'icon' : icon,\
'name' : name}
class CommandClassModel(SQL.Model):
__tablename__ = 'commandclass'
id = SQL.Column(SQL.Integer, primary_key=True)
sensor_id = SQL.Column(SQL.Integer, SQL.ForeignKey('sensor.id'))
number = SQL.Column(SQL.String(2))
name = SQL.Column(SQL.String(20))
types = SQL.relationship('CommandClassTypeModel',
backref="commandclass",
cascade="save-update, merge, delete")
supported = SQL.Column(SQL.Boolean)
web_field = SQL.Column(SQL.Boolean)
events = SQL.relationship('EventModel',
backref="commandclass",
cascade="save-update, merge, delete")
def __init__(self, number, name):
self.number = str(number)[:2]
self.name = name
self.supported = False
def commandclasstypes(self):
return [ctype.number for ctype in self.types]
def to_json(self):
return {
'name': self.name,
'number': self.number,
'webField': self.web_field,
'supported': self.supported,
'sensor': self.sensor.sensor_id,
'icpe': self.sensor.icpe.mac_address
}
def columns(self):
return ['number', 'name']
class HeatModel(SQL.Model):
__tablename__ = 'heat'
id = SQL.Column(SQL.Integer, primary_key=True)
date = SQL.Column(SQL.DateTime)
node_id = SQL.Column(SQL.Integer, SQL.ForeignKey('node.id'))
icpe_id = SQL.Column(SQL.Integer, SQL.ForeignKey('icpe.id'))
sensor_id = SQL.Column(SQL.Integer, SQL.ForeignKey('sensor.id'))
high = SQL.Column(SQL.Float)
low = SQL.Column(SQL.Float)
average = SQL.Column(SQL.Float)
def __init__(self, heat, date=datetime.now()):
self.high = heat
self.low = heat
self.average = heat
self.date = date
class NodeNotesModel(SQL.Model):
__tablename__ = 'nodenotes'
id = SQL.Column(SQL.Integer, primary_key=True)
node_id = SQL.Column(SQL.Integer, SQL.ForeignKey('node.id'))
author = SQL.Column(SQL.String(80))
note = SQL.Column(SQL.String(150))
date_created = SQL.Column(SQL.DateTime)
def __init__(self, author, note):
self.author = author
self.note = note
self.date_created = datetime.now()
class CommandClassTypeModel(SQL.Model):
__tablename__ = 'commandclasstype'
id = SQL.Column(SQL.Integer, primary_key=True)
commandclass_id = SQL.Column(SQL.Integer,
SQL.ForeignKey('commandclass.id'))
number = SQL.Column(SQL.String(2))
name = SQL.Column(SQL.String(40))
supported = SQL.Column(SQL.Boolean)
web_field = SQL.Column(SQL.Boolean)
events = SQL.relationship('EventModel',
backref="commandclasstype",
cascade="save-update, merge, delete")
def __init__(self, number):
self.number = str(number)[:2]
self.supported = False
class SensorModel(SQL.Model):
'''
ZWave Sensor, child of iCPE
'''
__tablename__ = 'sensor'
id = SQL.Column(SQL.Integer, primary_key=True)
icpe_id = SQL.Column(SQL.Integer, SQL.ForeignKey('icpe.id'))
name = SQL.Column(SQL.String(64))
sensor_id = SQL.Column(SQL.String(4))
date_created = SQL.Column(SQL.DateTime)
vendor_id = SQL.Column(SQL.String(16))
product_type = SQL.Column(SQL.String(16))
product_id = SQL.Column(SQL.String(16))
vendor_name = SQL.Column(SQL.String(64))
product_name = SQL.Column(SQL.String(64))
device_type = SQL.Column(SQL.String(48))
library_type = SQL.Column(SQL.String(48))
sleepable = SQL.Column(SQL.Boolean)
wakeup_interval = SQL.Column(SQL.Integer)
commandclasses = SQL.relationship('CommandClassModel',
backref='sensor',
cascade='save-update, merge, delete')
heat = SQL.relationship('HeatModel',
backref="sensor",
cascade="save-update, merge, delete")
power = SQL.relationship('PowerModel',
backref="sensor",
cascade="save-update, merge, delete")
events = SQL.relationship('EventModel',
backref="sensor",
cascade="save-update, merge, delete")
messages = SQL.relationship('MessageModel',
backref='sensor',
cascade='save-update, merge, delete')
def __init__(self, sensor_id, sensorinfo=None):
self.sensor_id = str(sensor_id)
self.date_created = datetime.now()
if sensorinfo:
for key, value in sensorinfo.items():
setattr(self, key.lower(), value)
self.name = self.product_name
def columns(self):
return [
'sensor_id', 'vendor_id', 'product_type', 'product_id',
'generic_class', 'specific_class', 'sleepable', 'wakeup_interval',
'name'
]
def to_json(self):
return {'name' : self.name, 'sensor_id' : self.sensor_id,\
'icpe' : self.icpe.mac_address,\
'vendor_name' : self.vendor_name,
'product_name' : str(self.productname)}
class iCPEModel(SQL.Model):
'''
iCPE attached to a Node
'''
__tablename__ = 'icpe'
id = SQL.Column(SQL.Integer, primary_key=True)
node_id = SQL.Column(SQL.Integer, SQL.ForeignKey('node.id'))
name = SQL.Column(SQL.String(64))
mac_address = SQL.Column(SQL.String(12), unique=True)
serial_number = SQL.Column(SQL.String(32))
ip_dhcp = SQL.Column(SQL.Boolean)
ip_address = SQL.Column(SQL.String(32))
ip_subnet = SQL.Column(SQL.String(32))
ip_gateway = SQL.Column(SQL.String(32))
firmware = SQL.Column(SQL.String(12))
hardware = SQL.Column(SQL.String(8))
telnet = SQL.Column(SQL.Boolean)
ssh = SQL.Column(SQL.Boolean)
http = SQL.Column(SQL.Boolean)
snmp = SQL.Column(SQL.Boolean)
enabled = SQL.Column(SQL.Boolean)
date_created = SQL.Column(SQL.DateTime)
last_online = SQL.Column(SQL.DateTime)
sensors = SQL.relationship('SensorModel',
backref='icpe',
cascade='save-update, merge, delete')
notesticky = SQL.Column(SQL.String(150))
heat = SQL.relationship('HeatModel',
backref="icpe",
cascade="save-update, merge, delete")
power = SQL.relationship('PowerModel',
backref="icpe",
cascade="save-update, merge, delete")
events = SQL.relationship('EventModel',
backref="icpe",
cascade="save-update, merge, delete")
messages = SQL.relationship('MessageModel',
backref='icpe',
cascade='save-update, merge, delete')
def __init__(self, mac_address):
self.mac_address = mac_address.upper()
self.enabled = False
self.date_created = datetime.now()
def __repr__(self):
return '<Name %r, Mac %r>' % (self.name, self.mac_address)
def columns(self):
return [
'name', 'mac_address', 'serial_number', 'ip_dhcp', 'ip_address',
'ip_subnet', 'ip_gateway', 'firmware', 'hardware', 'telnet', 'ssh',
'http', 'snmp', 'enabled', 'last_online'
]
def to_json(self):
if self.node:
node = self.node.name
else:
node = 'Not assigned'
icpe = {
'name':
self.name,
'mac_address':
self.mac_address,
'ip_address':
self.ip_address,
'date_created':
str(self.date_created),
'sensors':
str(len(self.sensors)),
'mqtt': [mqtt.to_json() for mqtt in self.mqtt],
'node':
node,
'url':
url_for('node_view.nodes_node',
name=NodeDefender.serializer.dumps(self.node.name))
}
return icpe
class MessageModel(SQL.Model):
'''
Representing one group containing iCPEs and Users
'''
__tablename__ = 'message'
id = SQL.Column(SQL.Integer, primary_key=True)
date = SQL.Column(SQL.DateTime)
subject = SQL.Column(SQL.String(50))
body = SQL.Column(SQL.String(180))
group_id = SQL.Column(SQL.Integer, SQL.ForeignKey('group.id'))
user_id = SQL.Column(SQL.Integer, SQL.ForeignKey('user.id'))
node_id = SQL.Column(SQL.Integer, SQL.ForeignKey('node.id'))
icpe_id = SQL.Column(SQL.Integer, SQL.ForeignKey('icpe.id'))
sensor_id = SQL.Column(SQL.Integer, SQL.ForeignKey('sensor.id'))
def __init__(self, subject, body):
self.subject = subject
self.body = body
self.date = datetime.now()
def to_json(self):
if self.group:
group = self.group.name
url = url_for('admin_view.admin_group',
name=NodeDefender.serializer.dumps(group))
icon = 'fa fa-users fa-3x'
else:
group = False
if self.user:
user = self.user.email
url = url_for('admin_view.admin_user',
email=NodeDefender.serializer.dumps(user))
icon = 'fa fa-user fa-3x'
else:
user = False
if self.node:
node = self.node.name
url = url_for('node_view.nodes_node',
name=NodeDefender.serializer.dumps(node))
icon = 'fa fa-map-marker fa-3x'
else:
node = False
if self.icpe:
icpe = self.icpe.name
url = "#"
icon = 'fa fa-bug fa-3x'
else:
icpe = False
if self.sensor:
sensor = self.sensor.name
url = "#"
icon = 'fa fa-bug fa-3x'
else:
sensor = False
return {'group' : group, 'user' : user,\
'node' : node, 'icpe' : icpe, 'sensor' : sensor,\
'subject' : self.subject,
'body' : self.body,
'date' : str(self.date),
'icon' : icon, 'url' : url}
from NodeDefender.db.sql import SQL
from datetime import datetime
from NodeDefender.db.sql.node import LocationModel
import NodeDefender
from flask import url_for
user_list = SQL.Table(
'user_list', SQL.Column('group_id', SQL.Integer,
SQL.ForeignKey('group.id')),
SQL.Column('user_id', SQL.Integer, SQL.ForeignKey('user.id')))
node_list = SQL.Table(
'node_list', SQL.Column('group_id', SQL.Integer,
SQL.ForeignKey('group.id')),
SQL.Column('node_id', SQL.Integer, SQL.ForeignKey('node.id')))
mqtt_list = SQL.Table(
'mqtt_list', SQL.Column('group_id', SQL.Integer,
SQL.ForeignKey('group.id')),
SQL.Column('mqtt_id', SQL.Integer, SQL.ForeignKey('mqtt.id')))
class GroupModel(SQL.Model):
'''
Representing one group containing iCPEs and Users
'''
__tablename__ = 'group'
id = SQL.Column(SQL.Integer, primary_key=True)
name = SQL.Column(SQL.String(50))
email = SQL.Column(SQL.String(120))
description = SQL.Column(SQL.String(250))
date_created = SQL.Column(SQL.DateTime)
from NodeDefender.db.sql import SQL
from NodeDefender.db.sql.icpe import iCPEModel
from datetime import datetime
import NodeDefender
mqtt_icpe = SQL.Table(
'mqtt_icpe', SQL.Column('mqtt_id', SQL.Integer, SQL.ForeignKey('mqtt.id')),
SQL.Column('icpe_id', SQL.Integer, SQL.ForeignKey('icpe.id')))
class MQTTModel(SQL.Model):
__tablename__ = 'mqtt'
id = SQL.Column(SQL.Integer, primary_key=True)
host = SQL.Column(SQL.String(128))
port = SQL.Column(SQL.Integer)
username = SQL.Column(SQL.String(64))
password = SQL.Column(SQL.String(64))
icpes = SQL.relationship('iCPEModel',
secondary=mqtt_icpe,
backref=SQL.backref('mqtt', lazy='dynamic'))
date_created = SQL.Column(SQL.DateTime)
def __init__(self, host, port, username=None, password=None):
self.host = host
self.port = int(port)
self.username = username
self.password = password
self.date_created = datetime.now()
def online(self):
