class User(db.Model):
__tablename__ = 'user'
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(db.String(255), nullable=False)
admin = db.Column(db.Boolean(), default=False)
registered_on = db.Column(db.DateTime())
def __init__(self, username=None, email=None, password=None, admin=False):
self.username = username
self.email = email
self.admin = admin
self.password = bcrypt.generate_password_hash(
password,
current_app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8')
self.registered_on = datetime.datetime.now()
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.id
def __repr__(self):
return '<User %r>' % self.username
class Organization(BaseModel):
"""
Creates an organization
"""
__tablename__ = "organizations"
# attributes
name = db.Column(db.String(100))
is_master = db.Column(db.Boolean, default=False, index=True)
public_identifier = db.Column(db.String(8),
nullable=False,
index=True,
unique=True)
address = db.Column(db.String, nullable=True)
users = db.relationship("User", backref="organization")
@staticmethod
def master_organisation() -> "Organization":
return Organization.query.filter_by(is_master=True).first()
def __init__(self, public_identifier=None, **kwargs):
super(Organization, self).__init__(**kwargs)
components = string.ascii_letters + string.digits
identifier = "".join(random.choice(components) for i in range(8))
self.public_identifier = public_identifier or identifier
class Urls(db.Model):
__tablename__ = "urls"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
url = db.Column(db.String(255), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
ipv4_origin = db.Column(db.String(255), nullable=True)
ipv6_origin = db.Column(db.String(255), nullable=True)
protocol = db.Column(db.String(255), nullable=True)
searched_on = db.Column(db.DateTime, nullable=True)
# def __init__(self, email, password, admin=False):
# self.email = email
# self.password = bcrypt.generate_password_hash(
# password, app.config.get('BCRYPT_LOG_ROUNDS')
# )
# self.registered_on = datetime.datetime.now()
# self.admin = admin
#
# def is_authenticated(self):
# return True
#
# def is_active(self):
# return True
#
# def is_anonymous(self):
# return False
def get_id(self):
return self.id
def __repr__(self):
return '<Urls {0}>'.format(self.url)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(255), unique=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
registered_on = db.Column(db.DateTime)
admin = db.Column(db.Boolean, default=False)
def __init__(self, username, email, password, admin=False):
self.username = username
self.email = email
self.password = bcrypt.generate_password_hash(
password,
current_app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8')
self.registered_on = datetime.datetime.now()
self.admin = admin
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.id
def __repr__(self):
return '<User {0}>'.format(self.email)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(255), unique=True, index=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
registered_on = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
admin = db.Column(db.Boolean, nullable=False, default=False)
accounts = db.relationship('Account', backref='user', lazy='dynamic')
def __init__(self, email, password, admin=False):
self.email = email
self.password = bcrypt.generate_password_hash(
password, app.config.get('BCRYPT_LOG_ROUNDS')
).decode('utf-8')
self.registered_on = datetime.datetime.now()
self.admin = admin
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.id
def __repr__(self):
return '<User {0}>'.format(self.email)
class PrincipalInvestigatorTbl(Base, db.Model):
id = db.Column(db.Integer, primary_key=True)
last_name = db.Column(db.String(120))
first_initial = db.Column(db.String(120))
@property
def full_name(self):
name = self.last_name
if self.first_initial:
name = '{}, {}'.format(name, self.first_initial)
return name
class search_index(SearchableIndex, db.Model):
__tablename__ = 'search_index'
__searchable__ = ['category', 'sub_category', 'description']
Id = db.Column(db.Integer, index=True, primary_key=True)
category = db.Column(db.String(50), index=True)
sub_category = db.Column(db.String(50), index=True)
description = db.Column(db.String(500), index=True)
def __repr__(self):
return '<search_index {}>'.format(self.category, self.sub_category,
self.description)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), unique=True, nullable=False, info={'validators': Email()})
password = db.Column(db.String(80), nullable=False)
posts = db.relationship('Post', backref='user', lazy='dynamic')
def __init__(self, email, password):
self.email = email
self.password = flask_bcrypt.generate_password_hash(password)
def __repr__(self):
return '<User %r>' % self.email
class User(db.Model):
""" User Model for storing user related details """
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
def __init__(self, name, email, password):
self.name = name
self.email = email
self.password = bcrypt.generate_password_hash(
password, app.config.get('BCRYPT_LOG_ROUNDS')).decode()
self.registered_on = datetime.datetime.now()
def encode_auth_token(self, user_id):
"""
Generates the Auth Token
:return: string
"""
try:
payload = {
'exp':
datetime.datetime.utcnow() +
datetime.timedelta(days=0, seconds=60),
'iat':
datetime.datetime.utcnow(),
'sub':
user_id
}
return jwt.encode(payload,
app.config.get('SECRET_KEY'),
algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
"""
Validates the auth token
:param auth_token:
:return: integer|string
"""
try:
payload = jwt.decode(auth_token, app.config.get('SECRET_KEY'))
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
class Team(Contestant):
id = db.Column(db.Integer, db.ForeignKey('contestant.id'), primary_key=True)
name = db.Column(db.String(128))
city = db.Column(db.String(128))
invite_code = db.Column(db.String(1024))
creator_id = db.Column(db.Integer, db.ForeignKey('user.id'))
creator = db.relationship('User', backref=db.backref('created_teams', lazy='dynamic'), foreign_keys='Team.creator_id')
members = db.relationship('User', secondary=user_to_team, backref=db.backref('teams', lazy='select'))
__mapper_args__ = {
'polymorphic_identity': 'team'
}
def __init__(self, name, city, invite_code, creator):
self.name = name
self.city = city
self.invite_code = invite_code
self.creator_id = creator.id
self.creator = creator
self.members.append(creator)
def save(self):
db.session.add(self)
db.session.commit()
return self.id
def delete(self):
db.session.delete(self)
db.session.commit()
@staticmethod
def get_all():
return Team.query.all()
@staticmethod
def get_by_code(code):
return Team.query.filter(Team.invite_code == code).first()
def add_new_member(self, user):
user.team_id = self.id
self.members.append(user)
db.session.commit()
def remove_member(self, user):
self.members.remove(user)
db.session.commit()
def if_user_in_the_team(self, user):
return user in self.members
@staticmethod
def get_by_id(id):
return db.session.query(Team).filter(Team.id == id).first()
class Currency(db.Model):
__tablename__ = "currencies"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
category = db.Column(db.Enum(CurrencyCategory), nullable=False, index=True)
code = db.Column(db.String(5), nullable=False, index=True)
name = db.Column(db.String(256), nullable=False)
def __init__(self, category, code, name):
self.category = category
self.code = code
self.name = name
class Tag(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
description = db.Column(db.Text, nullable=True)
color = db.Column(db.String(32), nullable=False, default="ffffff")
def __init__(self, name, description, color):
self.name = name
self.description = description
self.color = color
def __repr__(self):
return '<Tag %r>' % self.name
class Milestone(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
description = db.Column(db.Text, nullable=True)
due_date = db.Column(db.DateTime, default=db.func.now())
status = db.Column(db.String(120), nullable=False, default='Active')
def __init__(self, name, description, due_date, status):
self.name = name
self.description = description
self.due_date = due_date
self.stats = status
def __repr__(self):
return '<Milestone %r>' % self.name
class BlacklistedToken(BaseModel):
"""
Create a blacklisted token
"""
__tablename__ = "blacklisted_tokens"
token = db.Column(db.String(500), unique=True, nullable=False)
blacklisted_on = db.Column(db.DateTime, nullable=False)
@staticmethod
def check_if_blacklisted(token):
# check whether token has been blacklisted
result = BlacklistedToken.query.filter_by(token=str(token)).first()
if result:
return True
else:
return False
def __init__(self, token):
self.token = token
self.blacklisted_on = datetime.now()
def __repr__(self):
return f"<id: token: {self.token}"
class Issue(db.Model):
id = db.Column(db.Integer, primary_key=True)
project = db.relationship('Project', backref='issue')
project_id = db.Column(db.Integer, db.ForeignKey('project.id'), nullable=False)
tag = db.relationship('Tag', backref='issue')
tag_id = db.Column(db.Integer, db.ForeignKey('tag.id'), nullable=True)
milestone = db.relationship('Milestone', backref='issue')
milestone_id = db.Column(db.Integer, db.ForeignKey('milestone.id'), nullable=True)
effort = db.relationship('Effort', backref='issue')
effort_id = db.Column(db.Integer, db.ForeignKey('effort.id'), nullable=True)
assigned_to = db.relationship('Contact', backref='issue')
assigned_to_id = db.Column(db.Integer, db.ForeignKey('contact.id'), nullable=True)
column_id = db.Column(db.Integer, db.ForeignKey('column.id'), nullable=False, default=1)
column = db.relationship('Column', backref='tasks')
title = db.Column(db.String(120), nullable=False)
description = db.Column(db.Text, nullable=True)
created_at = db.Column(db.DateTime, default=db.func.now())
def __init__(self, title, description, project_id, column_id, tag_id, milestone_id, effort_id, assigned_to_id):
self.title = title
self.description = description
self.project_id = project_id
self.column_id = column_id
self.tag_id = tag_id
self.milestone_id = milestone_id
self.effort_id = effort_id
self.assigned_to_id = assigned_to_id
def __repr__(self):
return '<Issue %r>' % self.title
class AnalysisTbl(Base, db.Model):
timestamp = db.Column(db.DateTime)
aliquot = db.Column(db.Integer)
increment = db.Column(db.Integer, nullable=True)
analysis_type = db.Column(db.String(80))
irradiation_positionID = db.Column(db.Integer, db.ForeignKey('IrradiationPositionTbl.id'))
irradiation_position = db.relationship('IrradiationPositionTbl')
@property
def step(self):
inc = self.increment
if inc is not None:
s = alphas(inc)
else:
s = ''
return s
@property
def runid(self):
return '{}-{}{}'.format(self.irradiation_position.identifier, self.aliquot, self.step)
@property
def irradiation_info(self):
level = self.irradiation_position.level
irrad = level.irradiation
return '{}{} {}'.format(irrad.name, level.name, self.irradiation_position.position)
class Safe(db.Model):
__tablename__ = 'safe'
pass_id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255))
entered_on = db.Column(db.DateTime())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', backref=db.backref('safe'))
def __init__(self, name=None, password=None):
self.username = username
self.password = password
self.registered_on = datetime.datetime.now()
class Contact(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(120), nullable=False)
last_name = db.Column(db.String(120), nullable=False)
text = db.Column(db.Text, nullable=True)
icon_url = db.Column(db.String(120), nullable=True)
is_selected = db.Column(db.Boolean, nullable=False, default=False)
created_at = db.Column(db.DateTime, default=db.func.now())
def __init__(self, text, first_name, last_name, is_selected):
self.text = text
self.first_name = first_name
self.last_name = last_name
self.is_selected = is_selected
def __repr__(self):
return '<ToDo %r>' % self.text
class Unit(db.Model):
__versioned__ = {}
id = db.Column(db.Integer, primary_key=True)
unit = db.Column(db.String(20), nullable=False, unique=True)
def __repr__(self) -> str:
return '{!s}'.format(self.unit)
class Customer(db.Model):
__versioned__ = {}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), nullable=False, unique=True)
def __repr__(self) -> str:
return '{!s}'.format(self.name)
class IrradiationPositionTbl(Base, db.Model):
identifier = db.Column(db.String(80))
position = db.Column(db.Integer)
levelID = db.Column(db.Integer, db.ForeignKey('LevelTbl.id'))
level = db.relationship('LevelTbl')
sampleID = db.Column(db.Integer, db.ForeignKey('SampleTbl.id'))
sample = db.relationship('SampleTbl')
class UserConfig(db.Model):
__versioned__ = {}
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
name = db.Column(db.String(40), index=True, nullable=False)
value = db.Column(db.String(200), nullable=False)
configs = db.relationship('User')
__table_args__ = (db.Index(
'user_config__can_not_add_one_name_twice_to_a_user',
'user_id',
'name',
unique=True), )
def __repr__(self) -> str:
return '{!s} [{!r}]'.format(self.id, self.name)
class User(db.Model):
__versioned__ = {'exclude': ('password_hash', )}
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30),
nullable=False,
unique=True,
index=True)
password_hash = db.Column(db.String(80), nullable=False)
email = db.Column(db.String(50), nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
disabled = db.Column(db.Boolean, nullable=False, default=False)
configs = db.relationship('UserConfig', lazy='dynamic')
def __repr__(self) -> str:
return '{!s} [admin={!r} disabled={!r}]'.format(
self.username, self.admin, self.disabled)
def set_password(self, password: str):
self.password_hash = bcrypt.generate_password_hash(password)
def check_password(self, password: str) -> bool:
return bcrypt.check_password_hash(self.password_hash, password)
# flask-loginmanager
@property
def is_authenticated(self) -> bool:
return True
# flask-loginmanager
@property
def is_active(self) -> bool:
return not self.disabled
# flask-loginmanager
@property
def is_anonymous(self) -> bool:
return False
# flask-loginmanager
def get_id(self) -> str:
return str(self.id)
class Vendor(db.Model):
__versioned__ = {}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), nullable=False, unique=True)
items = db.relationship('Item', lazy='dynamic')
def __repr__(self) -> str:
return '{!s}'.format(self.name)
class Effort(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
description = db.Column(db.Text, nullable=True)
def __init__(self, name, description):
self.name = name
self.description = description
def __repr__(self):
return '<Effort %r>' % self.name
class Attempt(db.Model):
id = db.Column(db.Integer, primary_key=True)
task_id = db.Column(db.Integer(), db.ForeignKey('task.id'))
try_flag = db.Column(db.String(256))
success = db.Column(db.Boolean())
time = db.Column(db.DateTime())
score = db.Column(db.Integer())
tournament_to_object_id = db.Column(
db.Integer, db.ForeignKey('tournaments_to_object.id'))
tournament_to_object = db.relationship('TournamentsToObject',
backref=db.backref('attempts',
lazy='select'),
lazy='select')
task = db.relationship('Task',
backref=db.backref('task', lazy='select'),
lazy='select')
def __init__(self, flag, success, **kwargs):
self.try_flag = flag
self.success = success
self.score = 0
self.time = dt.now()
if 'tournament_to_object' in kwargs:
self.tournament_to_object_id = kwargs['tournament_to_object']
if 'task' in kwargs:
self.task_id = kwargs['task']
self.score = Task.get_by_id(self.task_id).score
@staticmethod
def get_scoreboard_for_contestant(tournament_to_object):
scorehistory = db.session.query(Attempt). \
filter((Attempt.tournament_to_object_id == tournament_to_object) & Attempt.success).all()
return scorehistory
@staticmethod
def already_solved(tournament_to_object_id, task_id):
return bool(
db.session.query(Attempt).filter(
(Attempt.tournament_to_object_id == tournament_to_object_id)
& (Attempt.task_id == task_id)
& (Attempt.success == True)).first())
def save(self):
db.session.add(self)
db.session.commit()
return self.id
def delete(self):
db.session.delete(self)
db.session.commit()
def get_all(self):
return db.session(Attempt).query.all()
class UsersExt(db.Model):
__tablename__ = "users_ext"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
nicename = db.Column(db.String(255), nullable=True)
url = db.Column(db.String(255), nullable=True)
activation_key = db.Column(db.String(255), nullable=True)
status = db.Column(db.Boolean, nullable=True)
facebook_id = db.Column(db.String(255), nullable=True)
created_at = db.Column(db.DateTime,
default=datetime.datetime.now,
nullable=True)
updated_at = db.Column(db.DateTime,
default=datetime.datetime.now,
onupdate=datetime.datetime.now,
nullable=True)
def __init__(self,
user_id,
nicename,
activation_key,
facebook_id,
status=False,
url=None):
self.user_id = user_id
self.nicename = nicename
self.activation_key = activation_key
self.status = status
self.facebook_id = facebook_id
self.url = url
def has_activated(self):
return self.activation_key is not None
def get_id(self):
return self.id
def __repr__(self):
return '<UsersExt {0}>'.format(self.user_id)
class Column(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
description = db.Column(db.Text, nullable=True)
created_at = db.Column(db.DateTime, default=db.func.now())
def __init__(self, name, description):
self.name = name
self.description = description
def __repr__(self):
return '<Column %r>' % self.name
class Contestant(db.Model):
id = db.Column(db.Integer, primary_key=True)
type = db.Column(db.String(30))
__mapper_args__ = {
'polymorphic_on': type,
'polymorphic_identity': 'contestant'
}
def __str__(self):
return self.__repr__()
def __repr__(self):
return "<Contestant {} {}".format(self.id, self.type)
class Transaction(db.Model):
__tablename__ = "transactions"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False, index=True)
datetime = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
value = db.Column(db.Float, nullable=False)
from_currency = db.Column(db.Integer, db.ForeignKey('currencies.id'), nullable=False, index=True)
from_volume = db.Column(db.Float, nullable=False)
from_wallet = db.Column(db.String(256), nullable=False, default='')
to_currency = db.Column(db.Integer, db.ForeignKey('currencies.id'), nullable=False, index=True)
to_volume = db.Column(db.Float, nullable=False)
to_wallet = db.Column(db.String(256), nullable=False, default='')
stake = db.Column(db.Float, nullable=False)
broker = db.Column(db.String(256), nullable=False, default='')
tx_id = db.Column(db.String(256), nullable=False, default='')
notes = db.Column(db.String(256), nullable=False, default='')
def __init__(self, user_id, value, from_currency, from_volume, to_currency, to_volume,
stake=0, from_wallet='', to_wallet='', broker='', tx_id='', notes='', trans_datetime=None):
self.user_id = user_id
self.datetime = trans_datetime or datetime.datetime.utcnow()
self.value = value
self.from_currency = from_currency
self.from_volume = from_volume
self.to_currency = to_currency
self.to_volume = to_volume
self.stake = stake
self.from_wallet = from_wallet
self.to_wallet = to_wallet
self.broker = broker
self.tx_id = tx_id
self.notes = notes
