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

reformated some code

Browse Source
This commit is contained in:
Tobias K.
2023-10-24 16:57:28 +02:00
parent e5eb9ceeb6
commit 6936d8d02c
8 changed files with 327 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
backend/models/access_control_model.py
View File

@@ -21,14 +21,13 @@ class AccessControlEntry(db.Model):
name = db.Column(db.Unicode(127), unique=False, nullable=False) name = db.Column(db.Unicode(127), unique=False, nullable=False)
url = db.Column(db.Unicode(2047), unique=False, nullable=True, default="") url = db.Column(db.Unicode(2047), unique=False, nullable=True, default="")
required_permission_id = db.Column(db.Integer, db.ForeignKey('permission.id')) required_permission_id = db.Column(db.Integer, db.ForeignKey("permission.id"))
required_permission = db.relationship('Permission', back_populates='access_control_entry') required_permission = db.relationship(
"Permission", back_populates="access_control_entry"
__table_args__ = (
CheckConstraint('length(name) > 2',
name='name_min_length'),
) )
__table_args__ = (CheckConstraint("length(name) > 2", name="name_min_length"),)
def __init__(self, **kwargs): def __init__(self, **kwargs):
super(AccessControlEntry, self).__init__(**kwargs) super(AccessControlEntry, self).__init__(**kwargs)
@@ -56,15 +55,24 @@ class AccessControlEntry(db.Model):
return dict(id=self.id, name=self.name) return dict(id=self.id, name=self.name)
def toJSON(self): def toJSON(self):
return json.dumps(self.to_dict(), default=lambda o: o.__dict__, return json.dumps(
sort_keys=True, indent=4) self.to_dict(), default=lambda o: o.__dict__, sort_keys=True, indent=4
)
def pre_fill_table(): def pre_fill_table():
a_es = {"url": "", } a_es = {
access_entries = [AccessControlEntry(name=room['name'], number=room['room_number'], "url": "",
building_name=room['building_name'], building_number=room['building_number']) for room in }
a_es] access_entries = [
AccessControlEntry(
name=room["name"],
number=room["room_number"],
building_name=room["building_name"],
building_number=room["building_number"],
)
for room in a_es
]
try: try:
db.session.bulk_save_objects(access_entries) db.session.bulk_save_objects(access_entries)

13
backend/models/example_model.py
View File

@@ -7,9 +7,18 @@ class ExampleDataItem(db.Model):
""" """
just an example class... just an example class...
""" """
id = db.Column(db.Integer, primary_key=True, autoincrement=True) id = db.Column(db.Integer, primary_key=True, autoincrement=True)
mac = db.Column(db.String(32), nullable=False, unique=True, index=True) mac = db.Column(db.String(32), nullable=False, unique=True, index=True)
uuid = db.Column(db.String(36), nullable=False, unique=True, index=True, default=str(uuid.uuid4())) uuid = db.Column(
db.String(36),
nullable=False,
unique=True,
index=True,
default=str(uuid.uuid4()),
)
some_string_value = db.Column(db.String, nullable=True, index=True) some_string_value = db.Column(db.String, nullable=True, index=True)
name = db.Column(db.String(128), default="<not set>", nullable=False, index=True, unique=False) name = db.Column(
db.String(128), default="<not set>", nullable=False, index=True, unique=False
)
description = db.Column(db.String(4096), nullable=True, unique=False) description = db.Column(db.String(4096), nullable=True, unique=False)

5
backend/models/post_model.py
View File

@@ -10,10 +10,11 @@ class Post(db.Model):
""" """
A post example class A post example class
""" """
id = db.Column(db.Integer, primary_key=True) id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140)) body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime) timestamp = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.id')) user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
def __repr__(self): def __repr__(self):
return '<Post %r>' % self.body return "<Post %r>" % self.body

103
backend/models/recorder_model.py
View File

@@ -18,26 +18,32 @@ from backend import db, app, login_manager, LrcException
from sqlalchemy import or_ from sqlalchemy import or_
from datetime import datetime, timedelta from datetime import datetime, timedelta
from backend.models.virtual_command_model import virtual_command_recorder_command_table, virtual_command_recorder_table from backend.models.virtual_command_model import (
virtual_command_recorder_command_table,
virtual_command_recorder_table,
)
metadata = MetaData() metadata = MetaData()
class RecorderModel(db.Model): class RecorderModel(db.Model):
__table_args__ = {'extend_existing': True} __table_args__ = {"extend_existing": True}
id = db.Column(db.Integer, autoincrement=True, primary_key=True) id = db.Column(db.Integer, autoincrement=True, primary_key=True)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow()) created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow())
last_time_modified = db.Column(db.DateTime, nullable=True, default=None) last_time_modified = db.Column(db.DateTime, nullable=True, default=None)
record_adapter_id = db.Column(db.Unicode(63), unique=True, nullable=False) record_adapter_id = db.Column(db.Unicode(63), unique=True, nullable=False)
model_name = db.Column(db.Unicode(63), unique=True, nullable=False) model_name = db.Column(db.Unicode(63), unique=True, nullable=False)
notes = db.Column(db.Unicode(255), unique=False, nullable=True, default=None) notes = db.Column(db.Unicode(255), unique=False, nullable=True, default=None)
recorder_commands = db.relationship('RecorderCommand', back_populates='recorder_model') recorder_commands = db.relationship(
recorders = db.relationship('Recorder', back_populates='recorder_model') "RecorderCommand", back_populates="recorder_model"
checksum = db.Column(db.String(63), unique=True, )
nullable=False) # checksum of the recorder commands! (see: model_updater.py) 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) last_checksum_change = db.Column(db.DateTime, nullable=True, default=None)
_requires_user = db.Column(db.Integer, default=False, name='requires_user') _requires_user = db.Column(db.Integer, default=False, name="requires_user")
_requires_password = db.Column(db.Integer, default=True, name='requires_password') _requires_password = db.Column(db.Integer, default=True, name="requires_password")
@staticmethod @staticmethod
def get_all(): def get_all():
@@ -49,11 +55,15 @@ class RecorderModel(db.Model):
@staticmethod @staticmethod
def get_by_adapter_id(name): def get_by_adapter_id(name):
return RecorderModel.query.filter(RecorderModel.record_adapter_id == name).first() return RecorderModel.query.filter(
RecorderModel.record_adapter_id == name
).first()
@staticmethod @staticmethod
def get_where_adapter_id_contains(adapter_id): def get_where_adapter_id_contains(adapter_id):
return RecorderModel.query.filter(RecorderModel.record_adapter_id.contains(adapter_id)).first() return RecorderModel.query.filter(
RecorderModel.record_adapter_id.contains(adapter_id)
).first()
@staticmethod @staticmethod
def get_by_checksum(md5_sum): def get_by_checksum(md5_sum):
@@ -80,10 +90,12 @@ class RecorderModel(db.Model):
class Recorder(db.Model): class Recorder(db.Model):
__table_args__ = {'extend_existing': True} __table_args__ = {"extend_existing": True}
id = db.Column(db.Integer, autoincrement=True, primary_key=True) id = db.Column(db.Integer, autoincrement=True, primary_key=True)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow()) created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow())
last_time_modified = 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) name = db.Column(db.Unicode(63), unique=True, nullable=False)
model_name = db.Column(db.Unicode(63), unique=False, nullable=False) model_name = db.Column(db.Unicode(63), unique=False, nullable=False)
serial_number = db.Column(db.Unicode(63), unique=True, nullable=True) serial_number = db.Column(db.Unicode(63), unique=True, nullable=True)
@@ -99,16 +111,21 @@ class Recorder(db.Model):
ssh_port = db.Column(db.Integer, unique=False, nullable=False, default=22) ssh_port = db.Column(db.Integer, unique=False, nullable=False, default=22)
username = db.Column(db.String, nullable=True, default=None) username = db.Column(db.String, nullable=True, default=None)
password = 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='') _configured_options_json_string = db.Column(db.UnicodeText, default="")
_additional_notes_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) additional_camera_connected = db.Column(db.Boolean, default=False)
firmware_version = db.Column(db.String, nullable=True, default=None) firmware_version = db.Column(db.String, nullable=True, default=None)
room_id = db.Column(db.Integer, db.ForeignKey('room.id')) 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) room = db.relationship(
recorder_model_id = db.Column(db.Integer, db.ForeignKey('recorder_model.id')) "Room", uselist=False, back_populates="recorder"
recorder_model = db.relationship('RecorderModel', back_populates='recorders') ) # one-to-one relation (uselist=False)
virtual_commands = db.relationship('VirtualCommand', secondary=virtual_command_recorder_table, recorder_model_id = db.Column(db.Integer, db.ForeignKey("recorder_model.id"))
back_populates='recorders') recorder_model = db.relationship("RecorderModel", back_populates="recorders")
virtual_commands = db.relationship(
"VirtualCommand",
secondary=virtual_command_recorder_table,
back_populates="recorders",
)
def __init__(self, **kwargs): def __init__(self, **kwargs):
super(Recorder, self).__init__(**kwargs) super(Recorder, self).__init__(**kwargs)
@@ -123,16 +140,16 @@ class Recorder(db.Model):
@staticmethod @staticmethod
def get_by_mac(mac: str): def get_by_mac(mac: str):
if mac is None or mac == '': if mac is None or mac == "":
return None return None
mac = mac.replace('-', ':').lower() mac = mac.replace("-", ":").lower()
return Recorder.query.filter(Recorder._mac == mac).first() return Recorder.query.filter(Recorder._mac == mac).first()
@staticmethod @staticmethod
def get_all(): def get_all():
return Recorder.query.all() return Recorder.query.all()
@validates('name') @validates("name")
def validate_name(self, key, value): def validate_name(self, key, value):
assert len(value) > 2 assert len(value) > 2
return value return value
@@ -146,7 +163,9 @@ class Recorder(db.Model):
self._configured_options_json_string = json.dumps(value) self._configured_options_json_string = json.dumps(value)
def add_configured_option(self, value: str): 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 @hybrid_property
def additional_notes(self) -> list: def additional_notes(self) -> list:
@@ -157,7 +176,9 @@ class Recorder(db.Model):
self._additional_notes_json_string = json.dumps(value) self._additional_notes_json_string = json.dumps(value)
def add_additional_notes(self, value: str): def add_additional_notes(self, value: str):
self._additional_notes_json_string = json.dumps(self._additional_notes_json_string.append(value)) self._additional_notes_json_string = json.dumps(
self._additional_notes_json_string.append(value)
)
@hybrid_property @hybrid_property
def mac(self) -> str: def mac(self) -> str:
@@ -165,10 +186,10 @@ class Recorder(db.Model):
@mac.setter @mac.setter
def mac(self, value: str): def mac(self, value: str):
if value is None or value == '': if value is None or value == "":
return return
if re.match("[0-9a-f]{2}([-:]?)[0-9a-f]{2}(\\1[0-9a-f]{2}){4}$", value.lower()): if re.match("[0-9a-f]{2}([-:]?)[0-9a-f]{2}(\\1[0-9a-f]{2}){4}$", value.lower()):
self._mac = value.replace('-', ':').lower() self._mac = value.replace("-", ":").lower()
else: else:
raise LrcException("'{}' is not a valid MAC Address!".format(value)) raise LrcException("'{}' is not a valid MAC Address!".format(value))
@@ -205,25 +226,35 @@ class Recorder(db.Model):
return dict(id=self.id, name=self.name) return dict(id=self.id, name=self.name)
def toJSON(self): def toJSON(self):
return json.dumps(self.to_dict(), default=lambda o: o.__dict__, return json.dumps(
sort_keys=True, indent=4) self.to_dict(), default=lambda o: o.__dict__, sort_keys=True, indent=4
)
class RecorderCommand(db.Model): class RecorderCommand(db.Model):
__table_args__ = {'extend_existing': True} __table_args__ = {"extend_existing": True}
"""Table containing permissions associated with groups.""" """Table containing permissions associated with groups."""
id = db.Column(db.Integer, autoincrement=True, primary_key=True) id = db.Column(db.Integer, autoincrement=True, primary_key=True)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow()) created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow())
last_time_modified = db.Column(db.DateTime, nullable=True, default=datetime.utcnow()) last_time_modified = db.Column(
db.DateTime, nullable=True, default=datetime.utcnow()
)
name = db.Column(db.Unicode(63), unique=True, nullable=False) name = db.Column(db.Unicode(63), unique=True, nullable=False)
alternative_name = db.Column(db.Unicode(63), unique=True, nullable=True, default=None) alternative_name = db.Column(
db.Unicode(63), unique=True, nullable=True, default=None
)
disabled = db.Column(db.Boolean, default=False) disabled = db.Column(db.Boolean, default=False)
description = db.Column(db.Unicode(511), nullable=True, default=None) description = db.Column(db.Unicode(511), nullable=True, default=None)
parameters_string = db.Column(db.String(2047), nullable=True) parameters_string = db.Column(db.String(2047), nullable=True)
recorder_model = db.relationship('RecorderModel', back_populates='recorder_commands') recorder_model = db.relationship(
recorder_model_id = db.Column(db.Integer, db.ForeignKey('recorder_model.id')) "RecorderModel", back_populates="recorder_commands"
virtual_commands = db.relationship('VirtualCommand', secondary=virtual_command_recorder_command_table, )
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 @staticmethod
def get_all(): def get_all():

32
backend/models/room_model.py
View File

@@ -14,7 +14,7 @@ from backend import db
from backend.models.recorder_model import Recorder from backend.models.recorder_model import Recorder
from backend.tools.scrape_rooms import scrape_rooms from backend.tools.scrape_rooms import scrape_rooms
logger = logging.getLogger("lrc."+__name__) logger = logging.getLogger("lrc." + __name__)
metadata = MetaData() metadata = MetaData()
@@ -23,18 +23,19 @@ class Room(db.Model):
id = db.Column(db.Integer, autoincrement=True, primary_key=True) id = db.Column(db.Integer, autoincrement=True, primary_key=True)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow()) created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow())
name = db.Column(db.Unicode(127), unique=False, nullable=False) name = db.Column(db.Unicode(127), unique=False, nullable=False)
alternate_name = db.Column(db.Unicode(127), unique=False, nullable=True, default=None) alternate_name = db.Column(
db.Unicode(127), unique=False, nullable=True, default=None
)
comment = db.Column(db.Unicode(2047), unique=False, nullable=True, default="") comment = db.Column(db.Unicode(2047), unique=False, nullable=True, default="")
number = db.Column(db.Unicode(63), unique=False, nullable=True) number = db.Column(db.Unicode(63), unique=False, nullable=True)
building_name = db.Column(db.Unicode(63), unique=False, nullable=True) building_name = db.Column(db.Unicode(63), unique=False, nullable=True)
building_number = db.Column(db.Unicode(63), unique=False, nullable=True) building_number = db.Column(db.Unicode(63), unique=False, nullable=True)
recorder = db.relationship(Recorder, uselist=False, back_populates='room') # one-to-one relation (uselist=False) recorder = db.relationship(
Recorder, uselist=False, back_populates="room"
) # one-to-one relation (uselist=False)
__table_args__ = ( __table_args__ = (CheckConstraint("length(name) > 2", name="name_min_length"),)
CheckConstraint('length(name) > 2',
name='name_min_length'),
)
def __init__(self, **kwargs): def __init__(self, **kwargs):
db.Model.__init__(self, **kwargs) db.Model.__init__(self, **kwargs)
@@ -72,17 +73,24 @@ class Room(db.Model):
return dict(id=self.id, name=self.name) return dict(id=self.id, name=self.name)
def toJSON(self): def toJSON(self):
return json.dumps(self.to_dict(), default=lambda o: o.__dict__, return json.dumps(
sort_keys=True, indent=4) self.to_dict(), default=lambda o: o.__dict__, sort_keys=True, indent=4
)
def pre_fill_table(): def pre_fill_table():
rooms = scrape_rooms() rooms = scrape_rooms()
logger.debug("tada") logger.debug("tada")
logger.debug("got {} rooms".format(len(rooms))) logger.debug("got {} rooms".format(len(rooms)))
db_rooms = [Room(name=room['name'], number=room['room_number'], db_rooms = [
building_name=room['building_name'], building_number=room['building_number']) for room in Room(
rooms] name=room["name"],
number=room["room_number"],
building_name=room["building_name"],
building_number=room["building_number"],
)
for room in rooms
]
try: try:
db.session.bulk_save_objects(db_rooms) db.session.bulk_save_objects(db_rooms)

243
backend/models/user_model.py
View File

@@ -21,61 +21,76 @@ from hashlib import md5
metadata = MetaData() metadata = MetaData()
followers = db.Table('followers', followers = db.Table(
db.Column('follower_id', db.Integer, db.ForeignKey('user.id')), "followers",
db.Column('followed_id', db.Integer, db.ForeignKey('user.id')) db.Column("follower_id", db.Integer, db.ForeignKey("user.id")),
) db.Column("followed_id", db.Integer, db.ForeignKey("user.id")),
)
acquaintances = db.Table('acquaintances', acquaintances = db.Table(
db.Column('me_id', db.Integer, db.ForeignKey('user.id')), "acquaintances",
db.Column('acquaintance_id', db.Integer, db.ForeignKey('user.id')) db.Column("me_id", db.Integer, db.ForeignKey("user.id")),
) db.Column("acquaintance_id", db.Integer, db.ForeignKey("user.id")),
)
user_favorite_recorders_table = db.Table('user_favorite_recorders', user_favorite_recorders_table = db.Table(
db.Column('user_id', db.Integer, "user_favorite_recorders",
db.ForeignKey('user.id', db.Column(
onupdate="CASCADE", "user_id",
ondelete="CASCADE"), db.Integer,
primary_key=True), db.ForeignKey("user.id", onupdate="CASCADE", ondelete="CASCADE"),
db.Column('recorder_id', db.Integer, primary_key=True,
db.ForeignKey('recorder.id', ),
onupdate="CASCADE", db.Column(
ondelete="CASCADE"), "recorder_id",
primary_key=True)) db.Integer,
db.ForeignKey("recorder.id", onupdate="CASCADE", ondelete="CASCADE"),
primary_key=True,
),
)
# This is the association table for the many-to-many relationship between # This is the association table for the many-to-many relationship between
# groups and members - this is, the memberships. # groups and members - this is, the memberships.
user_group_table = db.Table('user_group', user_group_table = db.Table(
db.Column('user_id', db.Integer, "user_group",
db.ForeignKey('user.id', db.Column(
onupdate="CASCADE", "user_id",
ondelete="CASCADE"), db.Integer,
primary_key=True), db.ForeignKey("user.id", onupdate="CASCADE", ondelete="CASCADE"),
db.Column('group_id', db.Integer, primary_key=True,
db.ForeignKey('group.id', ),
onupdate="CASCADE", db.Column(
ondelete="CASCADE"), "group_id",
primary_key=True)) db.Integer,
db.ForeignKey("group.id", onupdate="CASCADE", ondelete="CASCADE"),
primary_key=True,
),
)
# This is the association table for the many-to-many relationship between # This is the association table for the many-to-many relationship between
# groups and permissions. # groups and permissions.
group_permission_table = db.Table('group_permission', group_permission_table = db.Table(
db.Column('group_id', db.Integer, "group_permission",
db.ForeignKey('group.id', db.Column(
onupdate="CASCADE", "group_id",
ondelete="CASCADE"), db.Integer,
primary_key=True), db.ForeignKey("group.id", onupdate="CASCADE", ondelete="CASCADE"),
db.Column('permission_id', db.Integer, primary_key=True,
db.ForeignKey('permission.id', ),
onupdate="CASCADE", db.Column(
ondelete="CASCADE"), "permission_id",
primary_key=True)) db.Integer,
db.ForeignKey("permission.id", onupdate="CASCADE", ondelete="CASCADE"),
primary_key=True,
),
)
class User(UserMixin, db.Model): class User(UserMixin, db.Model):
""" """
Example user model representation. Example user model representation.
""" """
id = db.Column(db.Integer, primary_key=True) id = db.Column(db.Integer, primary_key=True)
social_id = db.Column(db.Unicode(63), nullable=True, unique=True) social_id = db.Column(db.Unicode(63), nullable=True, unique=True)
nickname = db.Column(db.Unicode(63), index=True, unique=True) nickname = db.Column(db.Unicode(63), index=True, unique=True)
@@ -84,32 +99,40 @@ class User(UserMixin, db.Model):
email = db.Column(db.String(120), nullable=False, index=True, unique=True) email = db.Column(db.String(120), nullable=False, index=True, unique=True)
lang = db.Column(db.Unicode(32), index=False, unique=False) lang = db.Column(db.Unicode(32), index=False, unique=False)
timezone = db.Column(db.Unicode(63), index=False, unique=False) timezone = db.Column(db.Unicode(63), index=False, unique=False)
posts = db.relationship(Post, backref='author', lazy='dynamic') posts = db.relationship(Post, backref="author", lazy="dynamic")
example_data_item = db.relationship(ExampleDataItem, backref='owner') example_data_item = db.relationship(ExampleDataItem, backref="owner")
example_data_item_id = db.Column(db.ForeignKey(ExampleDataItem.id)) example_data_item_id = db.Column(db.ForeignKey(ExampleDataItem.id))
about_me = db.Column(db.Unicode(255)) about_me = db.Column(db.Unicode(255))
role = db.Column(db.Unicode(63)) role = db.Column(db.Unicode(63))
groups = db.relationship('Group', secondary=user_group_table, back_populates='users') groups = db.relationship(
"Group", secondary=user_group_table, back_populates="users"
)
password = db.Column(db.String(255), nullable=True) password = db.Column(db.String(255), nullable=True)
registered_on = db.Column(db.DateTime, nullable=False, default=datetime.utcnow()) registered_on = db.Column(db.DateTime, nullable=False, default=datetime.utcnow())
external_user = db.Column(db.Boolean, default=False) external_user = db.Column(db.Boolean, default=False)
last_seen = db.Column(db.DateTime, default=datetime.utcnow()) last_seen = db.Column(db.DateTime, default=datetime.utcnow())
last_time_modified = db.Column(db.DateTime, default=datetime.utcnow()) last_time_modified = db.Column(db.DateTime, default=datetime.utcnow())
jwt_exp_delta_seconds = db.Column(db.Integer, nullable=True) jwt_exp_delta_seconds = db.Column(db.Integer, nullable=True)
acquainted = db.relationship('User', acquainted = db.relationship(
"User",
secondary=acquaintances, secondary=acquaintances,
primaryjoin=(acquaintances.c.me_id == id), primaryjoin=(acquaintances.c.me_id == id),
secondaryjoin=(acquaintances.c.acquaintance_id == id), secondaryjoin=(acquaintances.c.acquaintance_id == id),
backref=db.backref('acquaintances', lazy='dynamic'), backref=db.backref("acquaintances", lazy="dynamic"),
lazy='dynamic') lazy="dynamic",
followed = db.relationship('User', )
followed = db.relationship(
"User",
secondary=followers, secondary=followers,
primaryjoin=(followers.c.follower_id == id), primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id), secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'), backref=db.backref("followers", lazy="dynamic"),
lazy='dynamic') lazy="dynamic",
)
favorite_recorders = db.relationship(Recorder, secondary=user_favorite_recorders_table) favorite_recorders = db.relationship(
Recorder, secondary=user_favorite_recorders_table
)
def __init__(self, **kwargs): def __init__(self, **kwargs):
super(User, self).__init__(**kwargs) super(User, self).__init__(**kwargs)
@@ -128,9 +151,13 @@ class User(UserMixin, db.Model):
:param identifier: :param identifier:
:return: :return:
""" """
return User.query.filter(or_(User.nickname == identifier, return User.query.filter(
or_(
User.nickname == identifier,
User.email == identifier, User.email == identifier,
User.id == identifier)).first() User.id == identifier,
)
).first()
@staticmethod @staticmethod
@login_manager.user_loader @login_manager.user_loader
@@ -174,12 +201,12 @@ class User(UserMixin, db.Model):
:param nickname: :param nickname:
:return: :return:
""" """
return re.sub('[^a-zA-Z0-9_.]', '', nickname) return re.sub("[^a-zA-Z0-9_.]", "", nickname)
@classmethod @classmethod
def authenticate(cls, **kwargs): def authenticate(cls, **kwargs):
email = kwargs.get('email') email = kwargs.get("email")
password = kwargs.get('password') password = kwargs.get("password")
if not email or not password: if not email or not password:
return None return None
@@ -244,16 +271,16 @@ class User(UserMixin, db.Model):
:return: integer|string :return: integer|string
""" """
try: try:
payload = jwt.decode(auth_token, app.config.get('SECRET_KEY')) payload = jwt.decode(auth_token, app.config.get("SECRET_KEY"))
is_blacklisted_token = BlacklistToken.check_blacklist(auth_token) is_blacklisted_token = BlacklistToken.check_blacklist(auth_token)
if is_blacklisted_token: if is_blacklisted_token:
return 'Token blacklisted. Please log in again.' return "Token blacklisted. Please log in again."
else: else:
return payload['sub'] return payload["sub"]
except jwt.ExpiredSignatureError: except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.' return "Signature expired. Please log in again."
except jwt.InvalidTokenError: except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.' return "Invalid token. Please log in again."
def encode_auth_token(self): def encode_auth_token(self):
""" """
@@ -262,15 +289,11 @@ class User(UserMixin, db.Model):
""" """
try: try:
payload = { payload = {
'exp': datetime.utcnow() + timedelta(days=0, hours=3, seconds=5), "exp": datetime.utcnow() + timedelta(days=0, hours=3, seconds=5),
'iat': datetime.utcnow(), "iat": datetime.utcnow(),
'sub': self.id "sub": self.id,
} }
return jwt.encode( return jwt.encode(payload, app.config.get("SECRET_KEY"), algorithm="HS256")
payload,
app.config.get('SECRET_KEY'),
algorithm='HS256'
)
except Exception as e: except Exception as e:
return e return e
@@ -309,7 +332,10 @@ class User(UserMixin, db.Model):
:param size: :param size:
:return: :return:
""" """
return 'https://s.gravatar.com/avatar/%s?d=mm&s=%d' % (md5(self.email.encode('utf-8')).hexdigest(), size) return "https://s.gravatar.com/avatar/%s?d=mm&s=%d" % (
md5(self.email.encode("utf-8")).hexdigest(),
size,
)
def acquaint(self, user): def acquaint(self, user):
""" """
@@ -337,24 +363,35 @@ class User(UserMixin, db.Model):
:param user: :param user:
:return: :return:
""" """
return self.acquainted.filter(acquaintances.c.acquaintance_id == user.id).count() > 0 return (
self.acquainted.filter(acquaintances.c.acquaintance_id == user.id).count()
> 0
)
def get_acquaintances(self): def get_acquaintances(self):
""" """
Returns the list of acquaintances. Returns the list of acquaintances.
:return: :return:
""" """
return User.query.join(acquaintances, (acquaintances.c.acquaintance_id == User.id)).filter( return (
acquaintances.c.me_id == self.id).order_by(User.nickname.desc()) User.query.join(acquaintances, (acquaintances.c.acquaintance_id == User.id))
.filter(acquaintances.c.me_id == self.id)
.order_by(User.nickname.desc())
)
def shared_example_data_items(self): def shared_example_data_items(self):
""" """
Returns a list of the shared data items. Returns a list of the shared data items.
:return: :return:
""" """
return ExampleDataItem.query.join(acquaintances, return (
(acquaintances.c.acquaintance_id == ExampleDataItem.user_id)).filter( ExampleDataItem.query.join(
acquaintances.c.me_id == self.id).order_by(ExampleDataItem.timestamp.desc()) acquaintances,
(acquaintances.c.acquaintance_id == ExampleDataItem.user_id),
)
.filter(acquaintances.c.me_id == self.id)
.order_by(ExampleDataItem.timestamp.desc())
)
def follow(self, user): def follow(self, user):
""" """
@@ -389,26 +426,33 @@ class User(UserMixin, db.Model):
Returns list of followed posts. Returns list of followed posts.
:return: :return:
""" """
return Post.query.join(followers, (followers.c.followed_id == Post.user_id)).filter( return (
followers.c.follower_id == self.id).order_by(Post.timestamp.desc()) Post.query.join(followers, (followers.c.followed_id == Post.user_id))
.filter(followers.c.follower_id == self.id)
.order_by(Post.timestamp.desc())
)
def to_dict(self): def to_dict(self):
# return self.__dict__ # return self.__dict__
return dict(id=self.id, email=self.email, groups=[g.to_dict() for g in self.groups]) return dict(
id=self.id, email=self.email, groups=[g.to_dict() for g in self.groups]
)
def toJSON(self): def toJSON(self):
return json.dumps(self.to_dict(), default=lambda o: o.__dict__, return json.dumps(
sort_keys=True, indent=4) self.to_dict(), default=lambda o: o.__dict__, sort_keys=True, indent=4
)
def __repr__(self): def __repr__(self):
return '<User %r>' % self.email return "<User %r>" % self.email
class BlacklistToken(db.Model): class BlacklistToken(db.Model):
""" """
Token Model for storing JWT tokens Token Model for storing JWT tokens
""" """
__tablename__ = 'blacklist_tokens'
__tablename__ = "blacklist_tokens"
id = db.Column(db.Integer, primary_key=True, autoincrement=True) id = db.Column(db.Integer, primary_key=True, autoincrement=True)
token = db.Column(db.String(500), unique=True, nullable=False) token = db.Column(db.String(500), unique=True, nullable=False)
@@ -419,7 +463,7 @@ class BlacklistToken(db.Model):
self.blacklisted_on = datetime.now() self.blacklisted_on = datetime.now()
def __repr__(self): def __repr__(self):
return '<id: token: {}'.format(self.token) return "<id: token: {}".format(self.token)
@staticmethod @staticmethod
def get_by_token(jwt_id): def get_by_token(jwt_id):
@@ -443,11 +487,13 @@ class Group(db.Model):
id = db.Column(db.Integer, autoincrement=True, primary_key=True) id = db.Column(db.Integer, autoincrement=True, primary_key=True)
name = db.Column(db.Unicode(63), unique=True, nullable=False) name = db.Column(db.Unicode(63), unique=True, nullable=False)
description = db.Column(db.Unicode(255), unique=False, nullable=True, default="") description = db.Column(db.Unicode(255), unique=False, nullable=True, default="")
users = db.relationship('User', secondary=user_group_table, back_populates='groups') users = db.relationship("User", secondary=user_group_table, back_populates="groups")
permissions = db.relationship('Permission', secondary=group_permission_table, back_populates='groups') permissions = db.relationship(
"Permission", secondary=group_permission_table, back_populates="groups"
)
def __init__(self, **kwargs): def __init__(self, **kwargs):
#get permissions from kwargs and make Permission objects out of them # get permissions from kwargs and make Permission objects out of them
permissions = kwargs.pop("permissions", []) permissions = kwargs.pop("permissions", [])
if permissions is not None: if permissions is not None:
for p in permissions: for p in permissions:
@@ -480,37 +526,40 @@ class Group(db.Model):
return dict(id=self.id, name=self.name) return dict(id=self.id, name=self.name)
def toJSON(self): def toJSON(self):
return json.dumps(self.to_dict(), default=lambda o: o.__dict__, return json.dumps(
sort_keys=True, indent=4) self.to_dict(), default=lambda o: o.__dict__, sort_keys=True, indent=4
)
class Permission(db.Model): class Permission(db.Model):
"""Table containing permissions associated with groups.""" """Table containing permissions associated with groups."""
id = db.Column(db.Integer, autoincrement=True, primary_key=True) id = db.Column(db.Integer, autoincrement=True, primary_key=True)
name = db.Column(db.Unicode(63), unique=True, nullable=False) name = db.Column(db.Unicode(63), unique=True, nullable=False)
description = db.Column(db.Unicode(511)) description = db.Column(db.Unicode(511))
groups = db.relationship(Group, secondary=group_permission_table, groups = db.relationship(
back_populates='permissions') Group, secondary=group_permission_table, back_populates="permissions"
access_control_entry = db.relationship('AccessControlEntry', back_populates='required_permission') )
access_control_entry = db.relationship(
"AccessControlEntry", back_populates="required_permission"
)
@event.listens_for(User.__table__, 'after_create') @event.listens_for(User.__table__, "after_create")
def insert_initial_users(*args, **kwargs): def insert_initial_users(*args, **kwargs):
for u in app.config.get("USERS", []): for u in app.config.get("USERS", []):
db.session.add(User(**u)) db.session.add(User(**u))
db.session.commit() db.session.commit()
@event.listens_for(Permission.__table__, "after_create")
@event.listens_for(Permission.__table__, 'after_create')
def insert_initial_permissions(*args, **kwargs): def insert_initial_permissions(*args, **kwargs):
for p in app.config.get("PERMISSIONS", []): for p in app.config.get("PERMISSIONS", []):
db.session.add(Permission(name=p)) db.session.add(Permission(name=p))
db.session.commit() db.session.commit()
@event.listens_for(Group.__table__, 'after_create') @event.listens_for(Group.__table__, "after_create")
def insert_initial_groups(*args, **kwargs): def insert_initial_groups(*args, **kwargs):
for g in app.config.get("GROUPS", []): for g in app.config.get("GROUPS", []):
db.session.add(Group(**g)) db.session.add(Group(**g))
db.session.commit() db.session.commit()

80
backend/models/virtual_command_model.py
View File

@@ -8,31 +8,39 @@ from backend import db
# This is the association table for the many-to-many relationship between # This is the association table for the many-to-many relationship between
# virtual commands and recorder commands. # virtual commands and recorder commands.
virtual_command_recorder_command_table = db.Table('virtual_command_recorder_command', virtual_command_recorder_command_table = db.Table(
db.Column('virtual_command_id', db.Integer, "virtual_command_recorder_command",
db.ForeignKey('virtual_command.id', db.Column(
onupdate="CASCADE", "virtual_command_id",
ondelete="CASCADE"), db.Integer,
primary_key=True), db.ForeignKey("virtual_command.id", onupdate="CASCADE", ondelete="CASCADE"),
db.Column('recorder_command_id', db.Integer, primary_key=True,
db.ForeignKey('recorder_command.id', ),
onupdate="CASCADE", db.Column(
ondelete="CASCADE"), "recorder_command_id",
primary_key=True)) db.Integer,
db.ForeignKey("recorder_command.id", onupdate="CASCADE", ondelete="CASCADE"),
primary_key=True,
),
)
# This is the association table for the many-to-many relationship between # This is the association table for the many-to-many relationship between
# virtual commands and recorder commands. # virtual commands and recorder commands.
virtual_command_recorder_table = db.Table('virtual_command_recorder', virtual_command_recorder_table = db.Table(
db.Column('virtual_command_id', db.Integer, "virtual_command_recorder",
db.ForeignKey('virtual_command.id', db.Column(
onupdate="CASCADE", "virtual_command_id",
ondelete="CASCADE"), db.Integer,
primary_key=True), db.ForeignKey("virtual_command.id", onupdate="CASCADE", ondelete="CASCADE"),
db.Column('recorder_id', db.Integer, primary_key=True,
db.ForeignKey('recorder.id', ),
onupdate="CASCADE", db.Column(
ondelete="CASCADE"), "recorder_id",
primary_key=True)) db.Integer,
db.ForeignKey("recorder.id", onupdate="CASCADE", ondelete="CASCADE"),
primary_key=True,
),
)
class VirtualCommand(db.Model): class VirtualCommand(db.Model):
@@ -41,16 +49,25 @@ class VirtualCommand(db.Model):
name = db.Column(db.Unicode(63), unique=True, nullable=False) name = db.Column(db.Unicode(63), unique=True, nullable=False)
description = db.Column(db.Unicode(255), unique=False, nullable=True, default="") description = db.Column(db.Unicode(255), unique=False, nullable=True, default="")
recorders = db.relationship('Recorder', secondary=virtual_command_recorder_table, recorders = db.relationship(
back_populates='virtual_commands') "Recorder",
secondary=virtual_command_recorder_table,
back_populates="virtual_commands",
)
recorder_commands = db.relationship('RecorderCommand', secondary=virtual_command_recorder_command_table, recorder_commands = db.relationship(
back_populates='virtual_commands') "RecorderCommand",
secondary=virtual_command_recorder_command_table,
back_populates="virtual_commands",
)
# parent_virtual_command = db.relationship('VirtualCommand', back_populates='child_virtual_commands') # parent_virtual_command = db.relationship('VirtualCommand', back_populates='child_virtual_commands')
parent_virtual_command_id = db.Column(db.Integer, db.ForeignKey('virtual_command.id')) parent_virtual_command_id = db.Column(
child_virtual_commands = db.relationship('VirtualCommand', db.Integer, db.ForeignKey("virtual_command.id")
backref=backref('parent_virtual_command', remote_side=[id])) )
child_virtual_commands = db.relationship(
"VirtualCommand", backref=backref("parent_virtual_command", remote_side=[id])
)
command_order_string = db.Column(db.String) command_order_string = db.Column(db.String)
@@ -91,5 +108,6 @@ class VirtualCommand(db.Model):
return dict(id=self.id, name=self.name, description=self.description) return dict(id=self.id, name=self.name, description=self.description)
def toJSON(self): def toJSON(self):
return json.dumps(self.to_dict(), default=lambda o: o.__dict__, return json.dumps(
sort_keys=True, indent=4) self.to_dict(), default=lambda o: o.__dict__, sort_keys=True, indent=4
)

2
backend/tools/exception_decorator.py
View File

@@ -9,5 +9,7 @@ def exception_decorator(*exceptions):
return ret return ret
except exceptions as e: except exceptions as e:
raise LrcException(e) raise LrcException(e)
return new_func return new_func
return decorator return decorator