class CMLog(db.Model):
__tablename__ = 'cm_log'
__table_args__ = (db.ForeignKeyConstraint(
('cm_uuid', 'log_type'),
('cm_log_types.cm_uuid', 'cm_log_types.log_type')), )
id = db.Column(db.Integer, primary_key=True)
cm_uuid = db.Column(UUID(as_uuid=True), default=uuid.uuid4())
timestamp = db.Column(TIMESTAMP)
log_type = db.Column(TEXT)
data = db.Column(JSONB)
def __init__(self, cm_uuid: UUID, log_type: str, data: dict):
self.cm_uuid = cm_uuid
self.log_type = log_type
self.timestamp = str(datetime.now(pytz.utc))
self.data = data
@classmethod
def create(cls, cm_uuid: UUID, log_type: str, data: dict) -> dict:
new_log = cls(cm_uuid, log_type, data)
db.session.add(new_log)
db.session.commit()
return new_log.to_dict()
def to_dict(self) -> dict:
return {
"id": self.id,
"cm_uuid": self.cm_uuid,
"timestamp": str(self.timestamp),
"log_type": self.log_type,
"data": self.data
}
class CMLogTypes(db.Model):
__tablename__ = 'cm_log_types'
__table_args__ = (db.UniqueConstraint('cm_uuid',
'log_type',
name='log_type'), )
id = db.Column(db.Integer, primary_key=True)
cm_uuid = db.Column(UUID, ForeignKey("cm_meta.uuid"))
log_type = db.Column(TEXT)
description = db.Column(TEXT)
def __init__(self, cm_uuid: str, log_type: str, description: str):
self.cm_uuid = cm_uuid
self.log_type = log_type
self.description = description
@classmethod
def create(cls,
cm_uuid: str,
log_type: str,
description: str = None) -> dict:
new_cm_log_type = cls(cm_uuid, log_type, description)
db.session.add(new_cm_log_type)
db.session.commit()
return new_cm_log_type.to_dict()
def to_dict(self):
return {
"id": self.id,
"cm_uuid": self.cm_uuid,
"log_type": self.log_type,
"description": self.description
}
class Roles(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(UUID(as_uuid=True),
ForeignKey('users.id'),
default=uuid.uuid4())
role_id = db.Column(db.Integer, ForeignKey('role_descriptions.id'))
def __init__(self, user_id: UUID, role_id: int):
self.user_id = user_id
self.role_id = role_id
@classmethod
def create(cls, user_id: UUID, role_id: int) -> None:
new_role = cls(user_id, role_id)
db.session.add(new_role)
db.session.commit()
def get_name(self) -> str:
return RoleDefinitions.query.filter_by(id=self.role_id).first().name
def has_permission(self, permission: str) -> bool:
"""
Determines if role has the specified permission
"""
definition = RoleDefinitions.query.filter_by(self.role_id).first()
if hasattr(definition, permission):
return getattr(definition, permission)
return False
class RoleDefinitions(db.Model):
__tablename__ = 'role_descriptions'
name = db.Column(TEXT)
id = db.Column(db.Integer, primary_key=True)
create_user = db.Column(BOOLEAN)
get_log = db.Column(BOOLEAN)
post_log = db.Column(BOOLEAN)
def __init__(self, name: str, **kwargs):
self.name = name
self.create_user = kwargs.get("create_user", False)
self.get_log = kwargs.get("get_log", False)
self.post_log = kwargs.get("post_log", False)
@classmethod
def create(cls, name: str, **kwargs):
new_role = cls(name, kwargs=kwargs)
db.session.add(new_role)
db.session.commit()
def to_json(self) -> dict:
return {
"name": self.name,
"is_admin": self.is_admin,
"get_log": self.get_log,
"post_log": self.post_log
}
def has_permission(self, permission: str) -> bool:
"""
Determines if user has permission
"""
if hasattr(self, permission):
return getattr(self, permission)
return False
class CMMeta(db.Model):
__tablename__ = 'cm_meta'
uuid = db.Column(UUID(as_uuid=True),
default=uuid.uuid4(),
primary_key=True)
name = db.Column(TEXT)
def __init__(self, name: str):
self.uuid = uuid.uuid4()
self.name = name
@classmethod
def create(cls, name: str) -> None:
new_meta = cls(name)
db.session.add(new_meta)
db.session.commit()
class Users(db.Model):
__tablename__ = 'users'
username = db.Column(TEXT, unique=True)
password = db.Column(TEXT)
id = db.Column(UUID(as_uuid=True), default=uuid.uuid4(), primary_key=True)
owner = db.Column(BOOLEAN)
active = db.Column(BOOLEAN)
email = db.Column(TEXT, unique=True)
def __init__(self, username: str, password: str, email: str, active: bool):
self.username = username
self.password = password
self.id = uuid.uuid4()
self.owner = False
self.active = active
self.email = email
@classmethod
def create(cls,
username: str,
hashed_password: str,
email: str,
active: bool = False) -> dict:
new_user = cls(username, hashed_password, email, active)
db.session.add(new_user)
db.session.commit()
return new_user.to_dict()
# TODO: differentiate role name vs role id, and change in add role route
def has_role_name(self, search_role: str) -> bool:
"""
Determines if user is member of role, given role name
"""
roles = {role.id: role.name for role in RoleDefinitions.query.all()}
owned_role_ids = [
role.role_id
for role in Roles.query.filter_by(user_id=self.id).all()
]
for owned_role_id in owned_role_ids:
if roles[owned_role_id] == search_role:
return True
return False
def has_role_id(self, role_id: int) -> bool:
"""
Determines if user is member of role, given role id
"""
owned_role_ids = [
role.role_id
for role in Roles.query.filter_by(user_id=self.id).all()
]
print(owned_role_ids)
for owned_role_id in owned_role_ids:
if owned_role_id == role_id:
print("Match!")
return True
return False
def roles(self):
roles_query = Roles.query.filter_by(user_id=self.id).all()
roles = []
for role in roles_query:
role_definition = RoleDefinitions.query.filter_by(
id=role.role_id).first()
role_data = {
"role_id": role_definition.id,
"name": role_definition.name,
}
roles.append(role_data)
return roles
def to_dict(self):
return {
"username": self.username,
"id": self.id,
"owner": self.owner,
"roles": self.roles(),
"active": self.active
}