class Label(db.Model):
__tablename__ = 'labels'
label_id = db.Column(db.String(32), primary_key=True)
user_id = db.Column(db.String(32), db.ForeignKey('users.user_id'))
songs = db.relationship('Song', backref='label')
label_name = db.Column(db.String(50), nullable=False)
class Activity(BaseModel, db.Model):
"""Model for Activity table"""
__tablename__ = "Activities"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), nullable=False)
type_ = db.Column(db.String(128), nullable=False)
start_time = db.Column(db.DateTime, nullable=False)
finished_time = db.Column(db.DateTime, nullable=True)
state = db.Column(db.String, nullable=False)
result = db.Column(db.String, nullable=True)
logs = db.relationship('Log',
back_populates='activity',
lazy=True,
cascade="all, delete",
passive_deletes=False)
def __init__(self, name, type_, start_time, finished_time, state, result):
super().__init__()
self.name = name
self.type_ = type_
self.start_time = start_time
self.finished_time = finished_time
self.state = state
self.result = result
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), unique=True, nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(PasswordType(schemes=[
'sha256_crypt',
]))
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow)
password_changed_at = db.Column(db.DateTime)
identities = db.relationship('Identity', backref='user', lazy='dynamic')
sessions = db.relationship('Session', backref='user', lazy='dynamic')
@classmethod
def find_by_email_or_username(cls, username):
return (User.query.filter((User.email == username)
| (User.username == username)).first())
def change_password(self, password):
self.password = password
self.password_changed_at = datetime.utcnow()
class User(UserMixin, db.Model):
__tablename__ = 'user'
# attributes
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), nullable=False)
phoneNumber = db.Column(db.String(10), nullable=False, unique=True)
# Relationships
tkt = db.relationship('Ticket', backref=db.backref('tickets', lazy=True))
class User(db.Model):
__tablename__ = 'users'
user_id = db.Column(db.String(32), primary_key=True)
email = db.Column(db.String(80), unique=True, nullable=False)
name = db.Column(db.String(50), nullable=False)
password = db.Column(db.String(80), nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
labels = db.relationship('Label', backref='owner')
class Identity(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
provider = db.Column(db.String(255), nullable=False)
provider_user_id = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
last_used_at = db.Column(db.DateTime)
__table_args__ = (db.UniqueConstraint('provider',
'provider_user_id',
name='uniq_provider_user_id'), )
class Session(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
token = db.Column(db.String(255), default=generate_token)
user_agent = db.Column(db.String(255))
ip_address = db.Column(db.String(255))
platform = db.Column(db.String(255))
browser = db.Column(db.String(255))
created_at = db.Column(db.DateTime, default=datetime.utcnow)
last_active_at = db.Column(db.DateTime, default=datetime.utcnow)
class BibboxApp(BaseModel, db.Model):
"""Model for App table"""
__tablename__ = "apps"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
appid = db.Column(db.String(128), nullable=False)
version = db.Column(db.String(128), nullable=False)
appinfo = db.Column(db.UnicodeText(), nullable=False)
environment_parameters = db.Column(db.UnicodeText(), nullable=False)
def __init__(self, appid, version, appinfo, environment_parameters):
super().__init__()
self.appid = appid
self.version = version
self.appinfo = appinfo
self.environment_parameters = environment_parameters
class Song(db.Model):
__tablename__ = 'songs'
song_id = db.Column(db.String(32), primary_key=True)
label_id = db.Column(db.String(32), db.ForeignKey('labels.label_id'))
song_name = db.Column(db.String(80), nullable=True)
song_artist = db.Column(db.String(80), nullable=True)
song_type = db.Column(db.String(80), nullable=True)
rating = db.Column(db.Float, nullable=True)
author = db.Column(db.String(80), nullable=True)
author_id = db.Column(db.Integer, nullable=True)
key = db.Column(db.String(80), nullable=True)
tuning_name = db.Column(db.String(80), nullable=True)
tutning_value = db.Column(db.String(80), nullable=True)
difficulty = db.Column(db.String(80), nullable=True)
content = db.Column(db.Text, nullable=True)
strummings = db.Column(db.Text, nullable=True)
class SqlQuery(db.Model):
id = db.Column(db.Integer, primary_key=True)
label = db.Column(db.String(64), index=True, unique=True)
raw_sql = db.Column(db.Text)
creator_user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
index=True,
nullable=False)
charts = db.relationship('Chart', backref='sql_query', lazy='dynamic')
usergroups = db.relationship("Usergroup",
secondary=query_perms,
backref="queries")
@validates('label')
def validate_label(self, key, label):
if not label:
raise AssertionError('No label provided')
if Usergroup.query.filter(
func.lower(Usergroup.label) == func.lower(label)).first():
raise AssertionError('Provided label is already in use')
return label
@validates('raw_sql')
def validate_raw_sql(self, key, raw_sql):
if not raw_sql:
raise AssertionError('No raw_sql provided')
if not isinstance(raw_sql, str):
raise AssertionError('raw_sql must be a string')
return raw_sql
@validates('usergroups')
def validate_usergroups(self, key, usergroups):
if not isinstance(usergroups, Usergroup):
raise AssertionError('Provided usergroup is not recognized')
return usergroups
def get_dict(self):
dict_format = {
'query_id': self.id,
'label': self.label,
'raw_sql': self.raw_sql,
'creator': self.creator.get_dict(),
}
return dict_format
def get_usergroups(self):
usergroups = helpers.get_dicts_from_usergroups(self.usergroups)
return usergroups
def get_authorized_users(self):
users = dict(users=helpers.get_users_from_usergroups(self.usergroups))
return users
def __repr__(self):
return '<SqlQuery {}:{}'.format(self.id, self.label)
class Catalogue (BaseModel, db.Model):
"""Model for Catalogue table"""
__tablename__ = "catalogue"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), nullable=False)
content = db.Column(db.UnicodeText(), nullable=False)
def __init__(self, name, content):
super().__init__()
self.name = name
self.content = content
class User(BaseModel, db.Model):
"""Model for users table"""
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), nullable=False)
password_hash = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
# using func.now(), so time is calculated by the DB server and not by server backend.
# https://stackoverflow.com/questions/13370317/sqlalchemy-default-datetime?utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa
created_date = db.Column(db.DateTime, nullable=False, default=func.now())
def __init__(self, username, email="", password_hash=""):
super().__init__()
self.username = username
self.email = email
self.password_hash = password_hash
def hash_password(self, password):
self.password_hash = pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password_hash)
def generate_auth_token(self, expiration=600):
s = Serializer(app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id})
@staticmethod
def verify_auth_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
except SignatureExpired:
return None # valid token, but expired
except BadSignature:
return None # invalid token
user = User.query.get(data['id'])
return user
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(50), nullable=False, unique=True)
password_hash = db.Column(db.String(200))
created_on = db.Column(db.DateTime, default=datetime.datetime.utcnow())
updated_on = db.Column(db.DateTime,
default=datetime.datetime.utcnow(),
onupdate=datetime.datetime.utcnow())
def __init__(self, username: str):
self.username = username
def __repr__(self):
return f'<{self.id}:{self.username}>'
def set_password(self, password: str):
self.password_hash = generate_password_hash(password)
def check_password(self, password: str):
return check_password_hash(self.password_hash, password)
class UserTasks(db.Model):
__tablename__ = 'user_tasks'
id = db.Column(db.Integer, primary_key=True)
uuid = db.Column(db.String(200), nullable=False)
user_id = db.Column(db.Integer,
db.ForeignKey(User.id, ondelete='CASCADE'),
nullable=False)
def __init__(self, uuid: str, user_id: int):
self.uuid = uuid
self.user_id = user_id
def __repr__(self):
return f'<id: {self.id}><{self.uuid}><user_id: {self.user_id}>'
class Log(BaseModel, db.Model):
"""Model for Log table"""
__tablename__ = "Logs"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
timestamp = db.Column(db.String, nullable="False")
log_message = db.Column(db.String, nullable="False")
type_ = db.Column(db.String(20), nullable="False")
activity_id = db.Column(db.Integer,
db.ForeignKey('Activities.id', ondelete="CASCADE"),
nullable=False)
activity = db.relationship("Activity", back_populates="logs")
def __init__(self, timestamp, log_message, type_, activity_id):
super().__init__()
self.timestamp = timestamp
self.log_message = log_message
self.type_ = type_
self.activity_id = activity_id
class Connection(db.Model):
id = db.Column(db.Integer, primary_key=True)
label = db.Column(db.String(64), index=True, unique=True, nullable=False)
db_type = db.Column(db.String(64))
host = db.Column(db.String(256))
port = db.Column(db.Integer)
username = db.Column(db.String(128))
password = db.Column(db.String(128))
database_name = db.Column(db.String(256))
charts = db.relationship('Chart',
backref='chart_connection',
lazy='dynamic')
creator_user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
index=True,
nullable=False)
usergroups = db.relationship("Usergroup",
secondary=connection_perms,
backref="connections")
@validates('label')
def validate_label(self, key, label):
if not label:
raise AssertionError('No label provided')
if not isinstance(label, str):
raise AssertionError('Label must be string')
if Usergroup.query.filter(
func.lower(Usergroup.label) == func.lower(label)).first():
raise AssertionError('Provided label is already in use')
return label.lower()
@validates('db_type')
def validate_db_type(self, key, db_type):
if not db_type:
raise AssertionError('No db_type provided')
if not isinstance(db_type, str):
raise AssertionError('Provided db_type not valid')
return db_type
@validates('host')
def validate_host(self, key, host):
if not host:
raise AssertionError('No host provided')
if not isinstance(host, str):
raise AssertionError('Provided host not valid')
return host
@validates('port')
def validate_host(self, key, port):
if not port:
raise AssertionError('No port provided')
if not isinstance(port, (str, int)):
raise AssertionError('Provided port not valid')
return port
@validates('username')
def validate_username(self, key, username):
if not username:
raise AssertionError('No username provided')
if not isinstance(username, str):
raise AssertionError('Provided username not valid')
return username
@validates('password')
def validate_password(self, key, password):
if not password:
raise AssertionError('No password provided')
if not isinstance(password, str):
raise AssertionError('Provided password not valid')
return encrypt_with_aws(password)
@validates('database_name')
def validate_database_name(self, key, database_name):
if not database_name:
raise AssertionError('No database_name provided')
if not isinstance(database_name, str):
raise AssertionError('Provided database name not valid')
return database_name
@validates('creator')
def validate_creator(self, key, creator):
if not isinstance(creator, User):
raise AssertionError('Provided creator is not recognized')
return creator
@validates('usergroups')
def validate_usergroups(self, key, usergroups):
if not isinstance(usergroups, Usergroup):
raise AssertionError('Provided usergroup is not recognized')
return usergroups
def get_dict(self):
dict_format = {
'connection_id':
self.id,
'label':
self.label,
'db_type':
self.db_type,
'host':
self.host,
'port':
self.port,
'username':
self.username,
'password':
decrypt_with_aws(self.password)
if self.password else self.password,
'db_name':
self.database_name,
'creator':
self.creator.get_dict(),
}
return dict_format
def get_usergroups(self):
usergroups = helpers.get_dicts_from_usergroups(self.usergroups)
return usergroups
def get_authorized_users(self):
users = helpers.get_users_from_usergroups(self.usergroups)
return users
def __repr__(self):
return '<Connection label: {}>'.format(self.label)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True, index=True)
def __repr__(self):
return '<User %r>' % self.username
class TokenBlacklist(db.Model):
id = db.Column(db.Integer, primary_key=True)
jti = db.Column(db.String(36), nullable=False)
def __repr__(self):
return '<Blacklist jti: {}'.format(self.jti)
class Contact(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(64))
last_name = db.Column(db.String(64))
email = db.Column(db.String(128))
public = db.Column(db.Boolean)
creator_user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
index=True)
publication_ids = db.relationship("Publication",
secondary=publication_recipients,
backref="recipients")
@validates('first_name')
def validate_first_name(self, key, first_name):
if not first_name:
return None
if not isinstance(first_name, str):
raise AssertionError('First name must be string')
if len(first_name) > 50:
raise AssertionError('First names must be less than 50 characters')
return first_name
@validates('last_name')
def validate_last_name(self, key, last_name):
if not last_name:
return None
if not isinstance(last_name, str):
raise AssertionError('Last name must be string')
if len(last_name) > 50:
raise AssertionError('Last names must be less than 50 characters')
return last_name
@validates('email')
def validate_email(self, key, email):
if not email:
raise AssertionError('No email provided')
if not isinstance(email, str):
raise AssertionError('Email must be string')
if not re.match("[^@]+@[^@]+\.[^@]+", email):
raise AssertionError('Provided email is not an email address')
return email.lower()
@validates('public')
def validates_public(self, key, public):
if not public:
return None
if isinstance(public, bool):
return public
if isinstance(public, str):
if public.lower() == 'true':
return True
if public.lower() == 'false':
return False
else:
raise AssertionError('Public flag must be boolean value')
@validates('publications')
def validate_publications(self, key, publication):
if not publication:
raise AssertionError('No publication provided')
if not isinstance(publication, Publication):
raise AssertionError('Publication not recognized')
return publication
def get_dict(self):
dict_format = {
'contact_id': self.id,
'first_name': self.first_name,
'last_name': self.last_name,
'email': self.email,
'public': self.public,
'creator': self.creator.get_dict(),
}
return dict_format
def __repr__(self):
return '<Recipient {}, {}>'.format(self.last_name, self.first_name)
class Report(db.Model):
id = db.Column(db.Integer, primary_key=True)
label = db.Column(db.String(64), index=True, unique=True)
creator_user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
index=True)
created_on = db.Column(db.DateTime, default=datetime.utcnow)
last_published = db.Column(db.DateTime)
parameters = db.Column(db.Text)
publications = db.relationship('Publication',
backref='publication_report',
lazy='dynamic')
usergroups = db.relationship("Usergroup",
secondary=report_perms,
backref="reports")
@validates('label')
def validate_label(self, key, label):
if not label:
raise AssertionError('No label provided')
if Usergroup.query.filter(
func.lower(Usergroup.label) == func.lower(label)).first():
raise AssertionError('Provided label is already in use')
return label
@validates('parameters')
def validate_parameters(self, key, parameters):
if not parameters:
raise AssertionError('No parameters provided')
if not isinstance(parameters, str):
raise AssertionError('Provided parameters is wrong data type')
return parameters
@validates('usergroups')
def validate_usergroups(self, key, usergroups):
if not isinstance(usergroups, Usergroup):
raise AssertionError('Provided usergroup is not recognized')
return usergroups
def get_dict(self):
dict_format = {
'report_id': self.id,
'label': self.label,
'creator': self.creator.get_dict(),
'created_on': self.created_on,
'last_published': self.last_published,
'parameters': self.parameters,
'publications': self.get_publications(),
}
return dict_format
def get_usergroups(self):
usergroups = helpers.get_dicts_from_usergroups(self.usergroups)
return usergroups
def get_authorized_users(self):
users = dict(users=helpers.get_users_from_usergroups(self.usergroups))
return users
def get_publications(self):
return list(map(lambda obj: obj.get_dict(), self.publications))
def __repr__(self):
return '<Report {}>'.format(self.label)
class Chart(db.Model):
id = db.Column(db.Integer, primary_key=True)
label = db.Column(db.String(64), index=True, unique=True)
type = db.Column(db.String(128))
parameters = db.Column(db.Text)
creator_user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
index=True)
sql_query_id = db.Column(db.Integer, db.ForeignKey('sql_query.id'))
connection_id = db.Column(db.Integer, db.ForeignKey('connection.id'))
usergroups = db.relationship("Usergroup",
secondary=chart_perms,
backref="charts")
@validates('label')
def validate_label(self, key, label):
if not label:
raise AssertionError('No label provided')
if Usergroup.query.filter(
func.lower(Usergroup.label) == func.lower(label)).first():
raise AssertionError('Provided label is already in use')
return label
@validates('type')
def validate_type(self, key, type):
if not type:
raise AssertionError('No chart type provided')
if not isinstance(type, str):
raise AssertionError('chart type must be a string')
return type
@validates('parameters')
def validate_parameters(self, key, parameters):
if not parameters:
raise AssertionError('No parameters provided')
if not isinstance(parameters, str):
raise AssertionError('Provided parameters is wrong data type')
return parameters
@validates('sql_query_id')
def validate_sql_query_id(self, key, sql_query_id):
if not sql_query_id:
raise AssertionError('sql_query_id not provided')
if not helpers.get_record_from_id(SqlQuery, sql_query_id):
raise AssertionError('sql_query_id not recognized')
return sql_query_id
@validates('connection_id')
def validate_connection_id(self, key, connection_id):
if not connection_id:
raise AssertionError('connection_id not provided')
if not helpers.get_record_from_id(Connection, connection_id):
raise AssertionError('connection_id not recognized')
return connection_id
@validates('usergroups')
def validate_usergroups(self, key, usergroups):
if not isinstance(usergroups, Usergroup):
raise AssertionError('Provided usergroup is not recognized')
return usergroups
def get_dict(self):
dict_format = {
'chart_id': self.id,
'label': self.label,
'creator': self.creator.get_dict(),
'type': self.type,
'parameters': self.parameters,
'sql_query': self.sql_query.get_dict(),
'connection': self.chart_connection.get_dict(),
}
return dict_format
def get_usergroups(self):
usergroups = helpers.get_dicts_from_usergroups(self.usergroups)
return usergroups
def get_authorized_users(self):
users = dict(users=helpers.get_users_from_usergroups(self.usergroups))
return users
def __repr__(self):
return '<Chart label: {}>'.format(self.label)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64),
index=True,
unique=True,
nullable=False)
email = db.Column(db.String(120), index=True, nullable=False)
password_hash = db.Column(db.String(128))
role = db.Column(db.Enum('viewer',
'writer',
'admin',
'superuser',
name='user_roles'),
default='viewer')
is_active = db.Column(db.Boolean, default=True, nullable=False)
connections = db.relationship('Connection',
backref='creator',
lazy='dynamic')
queries = db.relationship('SqlQuery', backref='creator', lazy='dynamic')
charts = db.relationship('Chart', backref='creator', lazy='dynamic')
reports = db.relationship('Report', backref='creator', lazy='dynamic')
publications = db.relationship('Publication',
backref='creator',
lazy='dynamic')
contacts = db.relationship('Contact', backref='creator', lazy='dynamic')
usergroups = db.relationship("Usergroup",
secondary=user_perms,
backref="members",
cascade="save-update, merge")
@validates('username')
def validate_username(self, key, username):
if not username:
raise AssertionError('No username provided')
is_string = isinstance(username, str)
is_unique = not User.query.filter(User.username == username).first()
is_only_numbers_and_letters = re.match("^[a-zA-Z0-9_]+$", username)
is_more_than_5_characters = len(username) >= 5
is_less_than_40_characters = len(username) <= 40
if not is_string:
raise AssertionError('Provided username is invalid')
if not is_unique:
raise AssertionError('Provided username is already in use')
if not is_only_numbers_and_letters:
raise AssertionError(
'Usernames may only contain letters, numbers, and underscores')
if not is_more_than_5_characters:
raise AssertionError('Username must be 5 or more characters')
if not is_less_than_40_characters:
raise AssertionError('Usernames may only be 40 characters or less')
return username
@validates('email')
def validate_email(self, key, email):
if not email:
raise AssertionError('No email provided')
if not re.match("[^@]+@[^@]+\.[^@]+", email):
raise AssertionError('Provided email is not an email address')
return email
@validates('role')
def validate_role(self, key, role):
if role not in ('viewer', 'writer', 'admin'):
AssertionError('Provided role is not recognized')
return role
@validates('usergroups')
def validate_usergroups(self, key, usergroups):
if not isinstance(usergroups, Usergroup):
raise AssertionError('Provided usergroup is not recognized')
return usergroups
def get_dict(self):
dict_format = {
"user_id": self.id,
"username": self.username,
"email": self.email,
"role": self.role,
"usergroups": self.get_dicts_from_usergroups()
}
return dict_format
def set_password(self, password):
if not password:
raise AssertionError('Password not provided')
if not re.match('\d.*[A-Z]|[A-Z].*\d', password):
raise AssertionError(
'Password must contain 1 capital letter and 1 number')
if len(password) < 8 or len(password) > 50:
raise AssertionError(
'Password must be between 8 and 50 characters')
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
# returns list of usergroup ids
def get_usergroup_ids(self):
ug_tuple_list = db.session.query(user_perms).filter(
user_perms.c.user_id == self.id).all()
return list(map(lambda tup: tup[1], ug_tuple_list))
# takes table, returns list of ids
def get_authorized_ids(self, table):
usergroup_ids = self.get_usergroup_ids()
conn_tuple_list = db.session.query(table).filter(
table.c.usergroup_id.in_(usergroup_ids)).all()
return list(set(map(lambda tup: tup[1], conn_tuple_list)))
# returns list of usergroup dictionaries
def get_dicts_from_usergroups(self):
usergroup_ids = self.get_usergroup_ids()
usergroup_objects_list = Usergroup.query.filter(
Usergroup.id.in_(usergroup_ids)).all()
return list(
map(lambda obj: {
'id': obj.id,
'label': obj.label,
}, usergroup_objects_list))
# returns list of connection dictionaries
def get_connections(self):
connection_ids = self.get_authorized_ids(connection_perms)
connection_objects_list = Connection.query.filter(
Connection.id.in_(connection_ids)).all()
return list(map(lambda obj: obj.get_dict(), connection_objects_list))
# returns list of query dictionaries
def get_queries(self):
query_ids = self.get_authorized_ids(query_perms)
query_objects_list = SqlQuery.query.filter(
SqlQuery.id.in_(query_ids)).all()
return list(map(lambda obj: obj.get_dict(), query_objects_list))
# returns list of chart dictionaries
def get_charts(self):
chart_ids = self.get_authorized_ids(chart_perms)
chart_objects_list = db.session.query(Chart).filter(
Chart.id.in_(chart_ids)).all()
return list(map(lambda obj: obj.get_dict(), chart_objects_list))
# returns list of report dictionaries
def get_reports(self):
report_ids = self.get_authorized_ids(report_perms)
report_objects_list = Report.query.filter(
Report.id.in_(report_ids)).all()
return list(map(lambda obj: obj.get_dict(), report_objects_list))
# returns list of contact dictionaries
def get_contacts(self):
public_contacts = Contact.query.filter(Contact.public).all()
created_contacts = Contact.query.filter(
Contact.creator_user_id == self.id).all()
return list(
map(lambda obj: obj.get_dict(),
public_contacts + created_contacts))
def __repr__(self):
return '<User {}>'.format(self.username)
# returns personal usergroup
def get_personal_usergroup(self):
usergroup = Usergroup.query.filter(
Usergroup.label == self.username).first()
return usergroup
class Usergroup(db.Model):
id = db.Column(db.Integer, primary_key=True)
label = db.Column(db.String(64), index=True, unique=True)
personal_group = db.Column(db.Boolean, default=False)
@validates('label')
def validate_label(self, key, label):
if not label:
raise AssertionError('No label provided')
if not isinstance(label, str):
raise AssertionError('Label must be string')
if Usergroup.query.filter(
func.lower(Usergroup.label) == func.lower(label)).first():
raise AssertionError('Provided label is already in use')
return label.lower()
@validates('members')
def validate_members(self, key, members):
if not isinstance(members, User):
raise AssertionError('Provided member is not recognized')
return members
@validates('connections')
def validate_connections(self, key, connections):
if not isinstance(connections, Connection):
raise AssertionError('Provided connection is not recognized')
return connections
@validates('queries')
def validate_queries(self, key, queries):
if not isinstance(queries, SqlQuery):
raise AssertionError('Provided SQL query is not recognized')
return queries
@validates('charts')
def validate_charts(self, key, charts):
if not isinstance(charts, Chart):
raise AssertionError('Provided chart is not recognized')
return charts
@validates('reports')
def validate_reports(self, key, reports):
if not isinstance(reports, Report):
raise AssertionError('Provided report is not recognized')
return reports
def get_members(self):
return list(map(lambda obj: obj.get_dict(), self.members))
def get_connections(self):
return list(map(lambda obj: obj.get_dict(), self.connections))
def get_queries(self):
return list(map(lambda obj: obj.get_dict(), self.queries))
def get_charts(self):
return list(map(lambda obj: obj.get_dict(), self.charts))
def get_reports(self):
return list(map(lambda obj: obj.get_dict(), self.reports))
def get_dict(self):
dict_format = {
'usergroup_id': self.id,
'label': self.label,
'members': self.get_members(),
'connections': self.get_connections(),
'queries': self.get_queries(),
'charts': self.get_charts(),
'reports': self.get_reports(),
}
return dict_format
def __repr__(self):
return '<Usergroup id:{} label:{}>'.format(self.id, self.label)
