now scanning model difinietons and updating db entries

models/recorder_model.py

@@ -5,44 +5,49 @@ Models for lecture recorder
 import json
 
 from sqlalchemy import MetaData
+from sqlalchemy.ext.hybrid import hybrid_property
 
 from backend import db, app, login_manager
 import re
 from sqlalchemy import or_
 from datetime import datetime, timedelta
 
-from backend.models.virtual_command_model import virtual_command_recorder_command_table
+from backend.models.virtual_command_model import virtual_command_recorder_command_table, virtual_command_recorder_table
 
 metadata = MetaData()
 
-# This is the association table for the many-to-many relationship between
-# groups and permissions.
-recorder_model_recorder_command_table = db.Table('recorder_model_recorder_command',
-                           db.Column('recorder_model_id', db.Integer,
-                                  db.ForeignKey('recorder_model.id',
-                                             onupdate="CASCADE",
-                                             ondelete="CASCADE"),
-                                  primary_key=True),
-                           db.Column('recorder_command_id', db.Integer,
-                                  db.ForeignKey('recorder_command.id',
-                                             onupdate="CASCADE",
-                                             ondelete="CASCADE"),
-                                  primary_key=True))
-
 
 class RecorderModel(db.Model):
     id = db.Column(db.Integer, autoincrement=True, primary_key=True)
+    last_time_modified = db.Column(db.DateTime, nullable=True, default=None)
+    record_adapter_id = db.Column(db.Unicode(63), unique=True, nullable=False)
     model_name = db.Column(db.Unicode(63), unique=True, nullable=False)
-    model_checksum = db.Column(db.String(63), unique=True, nullable=True)
     notes = db.Column(db.Unicode(255), unique=False, nullable=True, default=None)
-    recorder_commands = db.relationship('RecorderCommand', secondary=recorder_model_recorder_command_table,
-                                        back_populates='recorder_models')
+    recorder_commands = db.relationship('RecorderCommand', back_populates='recorder_model')
     recorders = db.relationship('Recorder', back_populates='recorder_model')
+    checksum = db.Column(db.String(63), unique=True, nullable=False)
+
+    @staticmethod
+    def get_all():
+        return RecorderModel.query.all()
+
+    @staticmethod
+    def get_by_name(name):
+        return RecorderModel.query.filter(RecorderModel.model_name == name).first()
+
+    @staticmethod
+    def get_by_adapter_id(name):
+        return RecorderModel.query.filter(RecorderModel.record_adapter_id == name).first()
+
+    @staticmethod
+    def get_by_checksum(md5_sum):
+        return RecorderModel.query.filter(RecorderModel.checksum == md5_sum).first()
 
 
 class Recorder(db.Model):
     id = db.Column(db.Integer, autoincrement=True, primary_key=True)
     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)
     description = db.Column(db.Unicode(255), unique=False, nullable=True, default="")
     room_id = db.Column(db.Integer, db.ForeignKey('room.id'))
@@ -53,27 +58,17 @@ class Recorder(db.Model):
     ssh_port = db.Column(db.Integer, unique=False, nullable=False, default=22)
     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', back_populates='recorders')
+    virtual_commands = db.relationship('VirtualCommand', secondary=virtual_command_recorder_table, back_populates='recorders')
 
     def __init__(self, **kwargs):
         super(Recorder, self).__init__(**kwargs)
 
-
     @staticmethod
     def get_by_name(name):
-        """
-        Find group by name
-        :param name:
-        :return:
-        """
         return Recorder.query.filter(Recorder.name == name).first()
 
     @staticmethod
     def get_all():
-        """
-        Return all groups
-        :return:
-        """
         return Recorder.query.all()
 
     def __str__(self):
@@ -90,11 +85,26 @@ class Recorder(db.Model):
 class RecorderCommand(db.Model):
     """Table containing permissions associated with groups."""
     id = db.Column(db.Integer, autoincrement=True, primary_key=True)
+    last_time_modified = db.Column(db.DateTime, nullable=True, default=None)
     name = db.Column(db.Unicode(63), unique=True, nullable=False)
     description = db.Column(db.Unicode(511), nullable=True, default=None)
-    parameters = db.Column(db.String(2047), nullable=True)
-    recorder_models = db.relationship('RecorderModel', secondary=recorder_model_recorder_command_table,
-                  back_populates='recorder_commands')
-
+    parameters_string = db.Column(db.String(2047), nullable=True)
+    recorder_model = db.relationship('RecorderModel', back_populates='recorder_commands')
+    recorder_model_id = db.Column(db.Integer, db.ForeignKey('recorder_model.id'))
     virtual_commands = db.relationship('VirtualCommand', secondary=virtual_command_recorder_command_table,
                   back_populates='recorder_commands')
+
+    @staticmethod
+    def get_all():
+        return RecorderCommand.query.all()
+
+    @hybrid_property
+    def parameters(self):
+        if self.parameters_string is None:
+            return []
+        print(self.parameters_string)
+        return json.loads(self.parameters_string)
+
+    @parameters.setter
+    def parameters(self, parameters_dict: dict):
+        self.parameters_string = json.dumps(parameters_dict)