tobias/lrc-backend
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

now rooms, recorders and recorder models get initialized in DB

Browse Source
This commit is contained in:
Tobias Kurze
2019-11-20 16:19:59 +01:00
parent 60ff5bdeaf
commit 7700b4381f
6 changed files with 191 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
backend/models/recorder_model.py
View File

@@ -3,30 +3,25 @@
Models for lecture recorder
"""
import importlib
import ipaddress
import json
import pkgutil
import os
import re
from sqlalchemy import MetaData
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.hybrid import hybrid_property
from sqlalchemy.orm import validates
from backend import db, app, login_manager
import re
from backend import db, app, login_manager, LrcException
from sqlalchemy import or_
from datetime import datetime, timedelta
from backend.models.virtual_command_model import virtual_command_recorder_command_table, virtual_command_recorder_table
from backend.recorder_adapters import get_defined_recorder_adapters
from backend.tools.helpers import file_md5
metadata = MetaData()
KNOWN_RECORDERS = {re.compile(r'(SMP)[\s]*([\d]+)[\s]*.?[\s]*([\S]*)'): 'SMP',
re.compile(
r'(LectureRecorder X2|LectureRecorder|VGADVI Recorder|DVI Broadcaster DL|DVIRecorderDL)'): 'Epiphan'}
class RecorderModel(db.Model):
__table_args__ = {'extend_existing': True}
@@ -40,6 +35,7 @@ class RecorderModel(db.Model):
recorders = db.relationship('Recorder', back_populates='recorder_model')
checksum = db.Column(db.String(63), unique=True,
nullable=False) # checksum of the recorder commands! (see: model_updater.py)
last_checksum_change = db.Column(db.DateTime, nullable=True, default=None)
_requires_user = db.Column(db.Integer, default=False, name='requires_user')
_requires_password = db.Column(db.Integer, default=True, name='requires_password')
@@ -55,6 +51,10 @@ class RecorderModel(db.Model):
def get_by_adapter_id(name):
return RecorderModel.query.filter(RecorderModel.record_adapter_id == name).first()
@staticmethod
def get_where_adapter_id_contains(adapter_id):
return RecorderModel.query.filter(RecorderModel.record_adapter_id.contains(adapter_id)).first()
@staticmethod
def get_by_checksum(md5_sum):
return RecorderModel.query.filter(RecorderModel.checksum == md5_sum).first()
@@ -75,6 +75,9 @@ class RecorderModel(db.Model):
def requires_password(self, val: bool):
self._requires_password = 1 if val else 0
def __str__(self):
return self.model_name + " (record adapter: {})".format(self.record_adapter_id)
class Recorder(db.Model):
__table_args__ = {'extend_existing': True}
@@ -82,21 +85,27 @@ class Recorder(db.Model):
created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow())
last_time_modified = db.Column(db.DateTime, nullable=False, default=datetime.utcnow())
name = db.Column(db.Unicode(63), unique=True, nullable=False)
model_name = db.Column(db.Unicode(63), unique=False, nullable=False)
serial_number = db.Column(db.Unicode(63), unique=True, nullable=True)
locked = db.Column(db.Boolean, default=False)
lock_message = db.Column(db.String, nullable=True, default=None)
in_maintenance = db.Column(db.Boolean, default=False)
offline = db.Column(db.Boolean, default=False)
description = db.Column(db.Unicode(255), unique=False, nullable=True, default="")
room_id = db.Column(db.Integer, db.ForeignKey('room.id'))
room = db.relationship('Room', uselist=False, back_populates='recorder') # one-to-one relation (uselist=False)
ip = db.Column(db.String(15), unique=True, nullable=True, default=None)
configured_options_json_string = db.Column(db.UnicodeText, default='')
firmware_version = db.Column(db.String, nullable=True, default=None)
ip6 = db.Column(db.String(46), unique=True, nullable=True, default=None)
_mac = db.Column(db.String(17), unique=True, nullable=True)
_ip = db.Column(db.String(15), unique=True, nullable=True, default=None)
_ip6 = db.Column(db.String(46), unique=True, nullable=True, default=None)
network_name = db.Column(db.String(127), unique=True, nullable=True, default=None)
telnet_port = db.Column(db.Integer, unique=False, nullable=False, default=23)
ssh_port = db.Column(db.Integer, unique=False, nullable=False, default=22)
username = db.Column(db.String, nullable=True, default=None)
password = db.Column(db.String, nullable=True, default=None)
_configured_options_json_string = db.Column(db.UnicodeText, default='')
_additional_notes_json_string = db.Column(db.UnicodeText, default='')
additional_camera_connected = db.Column(db.Boolean, default=False)
firmware_version = db.Column(db.String, nullable=True, default=None)
room_id = db.Column(db.Integer, db.ForeignKey('room.id'))
room = db.relationship('Room', uselist=False, back_populates='recorder') # one-to-one relation (uselist=False)
recorder_model_id = db.Column(db.Integer, db.ForeignKey('recorder_model.id'))
recorder_model = db.relationship('RecorderModel', back_populates='recorders')
virtual_commands = db.relationship('VirtualCommand', secondary=virtual_command_recorder_table,
@@ -124,14 +133,64 @@ class Recorder(db.Model):
@hybrid_property
def configured_options(self) -> list:
return json.loads(self.configured_options_json_string)
return json.loads(self._configured_options_json_string)
@configured_options.setter
def configured_options(self, value: list):
self.configured_options_json_string = json.dumps(value)
self._configured_options_json_string = json.dumps(value)
def add_configured_option(self, value: str):
self.configured_options_json_string = json.dumps(self.configured_options.append(value))
self._configured_options_json_string = json.dumps(self.configured_options.append(value))
@hybrid_property
def additional_notes(self) -> list:
return json.loads(self._additional_notes_json_string)
@additional_notes.setter
def additional_notes(self, value: list):
self._additional_notes_json_string = json.dumps(value)
def add_additional_notes(self, value: str):
self._additional_notes_json_string = json.dumps(self._additional_notes_json_string.append(value))
@hybrid_property
def mac(self) -> str:
return self._mac.upper()
@mac.setter
def mac(self, value: str):
if value is None or value == '':
return
if re.match("[0-9a-f]{2}([-:]?)[0-9a-f]{2}(\\1[0-9a-f]{2}){4}$", value.lower()):
self._mac = value.replace('-', ':').lower()
else:
raise LrcException("'{}' is not a valid MAC Address!".format(value))
@hybrid_property
def ip(self) -> str:
return self._ip
@ip.setter
def ip(self, value: str):
try:
ipaddress.IPv4Interface(value)
self._ip = value
except (ipaddress.AddressValueError, ipaddress.NetmaskValueError):
raise LrcException("'{}' is not a valid IPv4 Address!".format(value))
@hybrid_property
def ip6(self) -> str:
return self._ip6
@ip6.setter
def ip6(self, value: str):
try:
ipaddress.IPv6Interface(value)
self._ip6 = value
except (ipaddress.AddressValueError, ipaddress.NetmaskValueError):
raise LrcException("'{}' is not a valid IPv6 Address!".format(value))
# handle bad ip
def __str__(self):
return self.name
@@ -173,35 +232,3 @@ class RecorderCommand(db.Model):
@parameters.setter
def parameters(self, parameters_dict: dict):
self.parameters_string = json.dumps(parameters_dict)
def pre_create_recorders():
models = set()
f = os.path.abspath(os.path.join(os.path.dirname(__file__), os.path.pardir, 'models', 'initial_recorders.json'))
with open(f, 'r') as json_file:
recorders = json.load(json_file)['recorders']
for r in recorders:
type = r.get('type')
firmware_version = r.get('firmware_version', None)
for k_r in KNOWN_RECORDERS:
if match := k_r.search(type):
print(KNOWN_RECORDERS[k_r])
print(match)
print(match.groups())
models.add(r.get('type', ''))
models.discard('')
print(models)
def pre_fill_table():
try:
pre_create_recorders()
print(db.session.commit())
except IntegrityError as e:
db.session.rollback()
if __name__ == '__main__':
pass
# pre_create_recorder_models()