class Device(StandardModel):
__tablename__ = 'devices'
uuid = db.Column(UUID(as_uuid=True), nullable=True)
address = db.Column(db.String(100), nullable=True)
poll_rate = db.Column(db.String(100), nullable=True)
module_id = db.Column(UUID(as_uuid=True), db.ForeignKey('modules.id'))
module = db.relationship("Module", back_populates="devices")
def get_device_datapoints(self) -> typing.List:
return self.module.module_device_type.device_type_datapoints
def summary(self) -> dict:
return dict(id=str(self.id),
module_id=str(self.module_id) if self.module_id else None,
uuid=str(self.uuid),
address=self.address,
poll_rate=self.poll_rate,
datapoints=[
datapoint.summary()
for datapoint in self.get_device_datapoints()
])
def module_summary(self) -> dict:
return dict(
id=str(self.id),
uuid=str(self.uuid),
address=self.address,
poll_rate=self.poll_rate,
)
class StandardModel(BaseModel):
__abstract__ = True
id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid4)
created_at = db.Column(db.DateTime, server_default=db.func.now())
updated_at = db.Column(db.DateTime,
server_default=db.func.now(),
server_onupdate=db.func.now())
deleted_at = db.Column(db.DateTime, nullable=True)
def summary(self) -> dict:
pass
class ModuleNotification(TimeScaleModel):
__tablename__ = 'module_notifications'
__timestamp_field__ = 'time'
time = db.Column(db.DateTime,
nullable=False,
primary_key=True,
default=datetime.datetime.utcnow)
message = db.Column(db.String(250), nullable=False)
module_id = db.Column(UUID(as_uuid=True), db.ForeignKey('modules.id'))
module = db.relationship("Module", back_populates="module_notification")
class Protocol(StandardModel):
__tablename__ = 'protocols'
name = db.Column(db.String(100), nullable=True)
datatype_id = db.Column(UUID(as_uuid=True), db.ForeignKey('data_types.id'))
module_device_types = db.relationship("ModuleDeviceType",
back_populates="protocol")
datatype = db.relationship("DataType", back_populates="protocols")
def summary(self) -> dict:
return dict(
id=str(self.id),
datatype_id=str(self.datatype_id),
name=self.name,
)
class ModuleDeviceType(StandardModel):
__tablename__ = 'module_device_types'
manufacturer = db.Column(db.String(100), nullable=True)
model = db.Column(db.String(100), nullable=True)
code = db.Column(db.String(100), nullable=True)
protocol_id = db.Column(UUID(as_uuid=True), db.ForeignKey('protocols.id'))
device_type_datapoints = db.relationship("DeviceTypeDatapoint", lazy='dynamic', back_populates="module_device_type")
protocol = db.relationship("Protocol", back_populates="module_device_types")
modules = db.relationship("Module", back_populates="module_device_type")
def summary(self) -> dict:
return dict(
id=str(self.id),
protocol_id=str(self.protocol_id),
code=self.code,
model=self.model,
manufacturer=self.manufacturer,
)
class DataType(StandardModel):
__tablename__ = 'data_types'
name = db.Column(db.String(100), nullable=True)
protocols = db.relationship("Protocol", back_populates="datatype")
def summary(self) -> dict:
return dict(
id=str(self.id),
name=self.name,
)
class DeviceTypeDatapoint(StandardModel):
__tablename__ = 'device_type_datapoints'
name = db.Column(db.String(100), nullable=True)
units = db.Column(db.String(100), nullable=True)
code = db.Column(db.String(100), nullable=True)
legend = db.Column(db.String(100), nullable=True)
writable = db.Column(db.Boolean, nullable=True)
module_device_type_id = db.Column(UUID(as_uuid=True),
db.ForeignKey('module_device_types.id'))
module_device_type = db.relationship(
"ModuleDeviceType", back_populates="device_type_datapoints")
def summary(self) -> dict:
return dict(
id=str(self.id),
module_device_type_id=str(self.module_device_type_id)
if self.module_device_type else None,
name=self.name,
units=self.units,
code=self.code,
legend=self.legend,
writable=self.writable,
)
class Module(StandardModel):
__tablename__ = 'modules'
mac = db.Column(db.String(100), nullable=True)
module_device_type_id = db.Column(UUID(as_uuid=True),
db.ForeignKey('module_device_types.id'))
devices = db.relationship("Device",
lazy='dynamic',
back_populates="module")
module_notification = db.relationship("ModuleNotification",
lazy='dynamic',
back_populates="module")
module_device_type = db.relationship("ModuleDeviceType",
back_populates="modules")
def summary(self) -> dict:
return dict(
id=str(self.id),
module_device_type_id=str(self.module_device_type_id)
if self.module_device_type_id else None,
mac=self.mac,
devices=[device.module_summary() for device in self.devices])
class Notification(StandardModel):
__tablename__ = 'notifications'
message = db.Column(db.String(100), nullable=True)
method = db.Column(db.String(10), nullable=False, default='GET')
url = db.Column(db.String(250), nullable=False, default='/')
module = db.Column(db.String(50), nullable=False)
function = db.Column(db.String(50), nullable=False)
level = db.Column(db.String(50), nullable=False, default='')
status_code = db.Column(db.Integer, nullable=True)
request = db.Column(types.JSON(), nullable=True)
additional_data = db.Column(types.JSON(), nullable=True)
def __init__(self, message, method, url, module, function, level,
status_code, request, additional_data):
self.message = message
self.method = method
self.url = url
self.module = module
self.function = function
self.level = level
self.status_code = status_code
self.request = request
self.additional_data = additional_data