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