class ShoppingList(DB.Model):
"""Create a shopping list table"""
__tablename__ = "shoppinglists"
list_id = DB.Column(DB.Integer, primary_key=True)
listname = DB.Column(DB.String(50))
shoppingitems = DB.relationship('ShoppingItems',
backref='ShoppingItems.item_id',
cascade="all, delete-orphan")
created_by = DB.Column(DB.Integer, DB.ForeignKey(User.user_id))
def __init__(self, listname, created_by):
""" initilization """
self.listname = listname
self.created_by = created_by
def save(self):
""" stores list to database """
DB.session.add(self)
DB.session.commit()
@staticmethod
def get_all():
""" get all shopping lists """
return ShoppingList.query.all()
def delete(self):
""" deletes shopping list """
DB.session.delete(self)
DB.session.commit()
def __repr__(self):
return "<ShoppingList: {}>".format(self.listname)
class JokeReaction(DB.Model):
"""jokes reactions model"""
__tablename__ = 'joke_reaction'
id = DB.Column(DB.Integer, primary_key=True)
joke_id = DB.Column(DB.Integer, DB.ForeignKey('joke.id'))
reaction_type = DB.Column(Enum(ReactionsType))
created_at = DB.Column(TIMESTAMP, default=datetime.utcnow, nullable=False)
class Joined(DB.Model):
id = DB.Column(DB.Integer, primary_key=True)
username = DB.Column(DB.String(80), unique=True, nullable=False)
score = DB.Column(DB.Integer, unique=False, nullable=True)
def __repr__(self):
return '<Joined %r>' % self.username
class Contact(DB.Model):
id = DB.Column(DB.Integer, primary_key=True)
first_name = DB.Column(DB.String(255), nullable=False)
last_name = DB.Column(DB.String(255))
number = DB.Column(DB.Integer, nullable=False)
__table_args__ = (DB.UniqueConstraint('first_name', 'last_name',
'number'), )
@classmethod
def create(cls, **kwargs):
kwargs['number'] = _clean_phone_number(kwargs['number'])
contact = Contact(**kwargs)
DB.session.add(contact)
DB.session.commit()
return contact
def serialize(self):
return {
'id': self.id,
'first_name': self.first_name,
'last_name': self.last_name,
'number': _format_phone_number(self.number)
}
def delete(self):
DB.session.delete(self)
DB.session.commit()
return {'success': True}
class Notification(db.Model):
'''
This class/table represents a notification to a user
'''
id = db.Column(db.Integer, primary_key=True)
user = db.Column(db.VARCHAR(12))
batchjob_id = db.Column(db.VARCHAR(45))
seen = db.Column(db.Integer, default=0, nullable=False)
occurred_on = db.Column(db.DATETIME(), default=datetime.utcnow)
def to_dict(self):
data = {
'id': self.id,
'user': self.user,
'batchjob_id': self.batchjob_id,
'seen': self.seen,
'occurred_on': self.occurred_on.isoformat() + 'Z'
}
return data
def from_dict(self, data):
for field in ['user', 'batchjob_id', 'seen', 'occurred_on']:
if field in data:
setattr(self, field, data[field])
def __repr__(self):
return '<Notification {}>'.format(self.id)
class Login(DB.Model):
id = DB.Column(DB.Integer, primary_key=True)
name = DB.Column(DB.String(80), unique=True, nullable=False)
email = DB.Column(DB.String(120), unique=True, nullable=False)
def __repr__(self):
return '<Login %r>' % self.name
class LifegroupModel(DB.Model):
__tablename__ = "lifegroups"
name = DB.Column(DB.String(20), primary_key=True)
email = DB.Column(DB.String(120), unique=True, nullable=False)
password_hash = DB.Column(DB.String(100), nullable=False)
notes = DB.relationship('NoteModel', backref='lifegroups', cascade="all, delete-orphan", passive_deletes=True)
members = DB.relationship('MemberModel', backref='lifegroups', cascade="all, delete-orphan", passive_deletes=True)
reset_password_code = DB.Column(DB.String(5), nullable=True)
reset_password_timestamp = DB.Column(DB.DateTime, nullable=True)
@property
def password(self):
raise AttributeError('password is a write only field')
@password.setter
def password(self, password):
self.password_hash = BCRYPT.generate_password_hash(password).decode('utf-8')
def check_password(self, password):
return BCRYPT.check_password_hash(self.password_hash, password)
def __repr__(self):
return '<Lifegroup %r>' % self.name
class RunToSamples(db.Model):
"""
Model for database table that maps SequencingRuns to Sample IDs
and Project IDs. For now, the Project IDs and Sample IDs are stored
as strings (VARCHAR), in case the Project associated with the Run
does not exist in the database yet.
"""
id = db.Column(db.Integer, primary_key=True)
sequencing_run_id = db.Column(db.Integer, db.ForeignKey('sequencing_run.id'))
sample_id = db.Column(db.VARCHAR(512), default=None)
project_id = db.Column(db.VARCHAR(50), default=None)
def to_dict(self):
return {
'id': self.id,
'sequencing_run_id': self.sequencing_run_id,
'sample_id': self.sample_id,
'project_id': self.project_id
}
def from_dict(self, data):
for field in data:
setattr(self, field, data[field])
def __repr__(self):
return ('<RunToSamples mapping with SequencingRun {}, Sample ID {},'
' and Project ID {}>'.format(self.sequencing_run_id, self.sample_id,
self.project_id))
class Bucketlist(DB.Model):
"""This class represents the bucketlist table."""
__tablename__ = 'bucketlists'
id = DB.Column(DB.Integer,
DB.Sequence('bucketlist_id_seq'),
primary_key=True)
name = DB.Column(DB.String(255))
date_created = DB.Column(DB.DateTime, default=DB.func.current_timestamp())
date_modified = DB.Column(DB.DateTime,
default=DB.func.current_timestamp(),
onupdate=DB.func.current_timestamp())
def __init__(self, name):
"""initialize with name."""
self.name = name
def save(self):
DB.session.add(self)
DB.session.commit()
@staticmethod
def get_all():
return Bucketlist.query.all()
def delete(self):
DB.session.delete(self)
DB.session.commit()
def __repr__(self):
return "<Bucketlist: {}>".format(self.name)
class GoogleDate(DB.Model):
"""
ORM Model representing the date for which a complete set of Google terms for a particular model
ID was retrieved. The date here stored assumes the scores for a set of Google terms as a
transaction and should always be added to the session together with the set of GoogleScores.
"""
id = DB.Column(DB.Integer, primary_key=True)
flu_model_id = DB.Column(DB.Integer, DB.ForeignKey('model.id'))
transaction_timestamp = DB.Column(DB.DateTime, default=DB.func.current_timestamp())
score_date = DB.Column(DB.Date)
def __init__(self, model_id: int, score_date: date):
self.flu_model_id = model_id
self.score_date = score_date
def save(self):
""" Convenience method to save current instance """
DB.session.add(self)
DB.session.commit()
def __repr__(self):
return '<GoogleDate model_id=%d %s>' % (
self.flu_model_id, self.score_date.strftime('%Y-%m-%d')
)
class Org(DB.Model):
id = DB.Column(DB.Integer, primary_key=True, autoincrement=True)
name = DB.Column(DB.String(128))
address = DB.Column(DB.String(4096))
def __repr__(self):
return self.name
class Todo(DB.Model):
''' Initialize Todo Table with person_Id/Todo/StartDate/DueDate Columns '''
id = DB.Column(DB.Integer, primary_key=True)
person_id = DB.Column(DB.Integer, DB.ForeignKey('person.id'))
todo = DB.Column(DB.String(255), nullable=False)
start_todo = DB.Column(DB.DateTime, default=start_date_new)
due_date = DB.Column(DB.DateTime, default=end_date_new)
class Tweet(Base):
__tablename__ = 'tweets'
text = db.Column(db.String(120), nullable=False)
user_id = db.Column(db.Integer, nullable=False)
liked = db.Column(db.Integer, nullable=False)
retweet = db.Column(db.Integer, nullable=False)
def __init__(self, text, user=None, username=None):
self.text = text
if username is not None:
user = User.query.filter_by(name=username).first()
self.user_id = user.id
else:
self.user_id = user.id
self.liked = random.randint(0, 10)
self.retweet = random.randint(0, 10)
def __repr__(self):
return '<Tweet %r>' % (self.text)
def get_username(self):
user = User.query.filter_by(id=self.user_id).first()
return user.name
class Project(db.Model):
'''
Represents BMS Genomics Project, where id is BMS ProjectID
'''
id = db.Column(db.VARCHAR(50), primary_key=True)
rnaseq_qc_report = db.Column(db.VARCHAR(255), default=None)
wes_qc_report = db.Column(db.VARCHAR(255), default=None)
xpress_project_id = db.Column(db.INT, default=None)
def to_dict(self):
data = {
'id': self.id,
'rnaseq_qc_report_url': self.rnaseq_qc_report,
'wes_qc_report_url': self.wes_qc_report,
'xpress_project_id': self.xpress_project_id
}
return data
def from_dict(self, data):
for field in ['rnaseq_qc_report', 'wes_qc_report', 'xpress_project_id']:
if field in data:
setattr(self, field, data[field])
def __repr__(self):
return '<Project {}>'.format(self.id)
class Person(DB.Model):
''' Initialize Person Table with ID/Email/Todos/Credentials Columns '''
id = DB.Column(DB.Integer, primary_key=True)
email = DB.Column(DB.String(120), nullable=False)
todos = DB.relationship('Todo', backref='person', lazy=True)
cred = DB.Column(DB.PickleType)
phone = DB.Column(DB.String(20))
class Attendance(DB.Model):
"""Класс для сущности 'Посещаемость'"""
__tablename__ = 'attendance'
__table_args__ = (
DB.ForeignKeyConstraint(['attendance_teaching_lesson_id', 'attendance_curriculum_unit_id'],
['teaching_lesson_and_curriculum_unit.teaching_lesson_id',
'teaching_lesson_and_curriculum_unit.curriculum_unit_id']),
)
attendance_teaching_lesson_id = DB.Column(DB.Integer, primary_key=True, autoincrement=True)
attendance_curriculum_unit_id = DB.Column(DB.Integer, primary_key=True, autoincrement=True)
lesson_attendance = DB.Column(DB.Boolean, nullable=False)
lesson_date = DB.Column(DB.Date, nullable=False)
student_id = DB.Column(DB.BigInteger, DB.ForeignKey('student.student_id'), nullable=False)
def __repr__(self):
return "Attendance(attendance_teaching_lesson_id={attendance_teaching_lesson_id}," \
" attendance_curriculum_unit_id={attendance_curriculum_unit_id}," \
" lesson_attendance={lesson_attendance}," \
" lesson_date={lesson_date}, student_id={student_id})". \
format(attendance_teaching_lesson_id=self.attendance_teaching_lesson_id,
attendance_curriculum_unit_id=self.attendance_curriculum_unit_id,
lesson_attendance=self.lesson_attendance,
lesson_date=self.lesson_date,
student_id=self.student_id)
class Bucketlist(db.Model):
"""This class represents the bucketlist table."""
__tablename__ = 'bucketlists'
id_key = db.Column(db.Integer, primary_key=True)
item = db.Column(db.String(255))
date_created = db.Column(db.DateTime, default=db.func.current_timestamp())
date_modified = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
def __init__(self, name):
"""Initialize tables with name"""
self.name = name
def save(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_all():
return Bucketlist.query.all()
def delete(self):
db.session.delete(self)
db.session.commit()
def __repr__(self):
return "<Bucketlist: {}".format(self.name)
class Active(DB.Model):
'''Active User table.'''
id = DB.Column(DB.Integer, primary_key=True)
name = DB.Column(DB.String(80), unique=True, nullable=False)
def __repr__(self):
return '<Active %r>' % self.name
class TokenModel(DB.Model):
__tablename__ = "tokens"
id = DB.Column(DB.String(), primary_key=True)
jti = DB.Column(DB.String(36), nullable=False)
lifegroup = DB.Column(DB.String(20), nullable=False)
expired_on = DB.Column(DB.DateTime, nullable=False)
created_on = DB.Column(DB.DateTime)
class UserLevel(db.Model):
'''User level class definition'''
id = db.Column(db.Integer, primary_key=True)
levelname = db.Column(db.String(64), index=True, unique=True)
users = db.relationship('User', backref='level', lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.levelname)
class Gamer(DB.Model):
'''class sets table columns'''
id = DB.Column(DB.Integer, primary_key=True)
username = DB.Column(DB.String(80), unique=True, nullable=False)
gameswon = DB.Column(DB.Integer, nullable=False)
def __repr__(self):
return '<Gamer %r>' % self.username
class Account(DB.Model):
id = DB.Column(DB.Integer, primary_key=True, autoincrement=True)
org_id = DB.Column(DB.Integer, DB.ForeignKey("org.id"), nullable=False)
name = DB.Column(DB.String(128))
code = DB.Column(DB.String(128))
def __repr__(self):
return "%s - %s" % (self.code, self.name)
class Leaderboard(DB.Model):
'''Leaderboard table.'''
id = DB.Column(DB.Integer, primary_key=True)
username = DB.Column(DB.String(80), unique=True, nullable=False)
score = DB.Column(DB.Integer, nullable=False)
def __repr__(self):
return '<Leaderboard %r>' % self.username
class User(DB.Model, UserMixin):
id = DB.Column(DB.Integer, primary_key=True)
email = DB.Column(DB.String(255), unique=True)
password = DB.Column(DB.String(255))
active = DB.Column(DB.Boolean())
confirmed_at = DB.Column(DB.DateTime())
roles = DB.relationship('Role', secondary=roles_users,
backref=DB.backref('users', lazy='dynamic'))
class NoteModel(DB.Model):
__tablename__ = "notes"
id = DB.Column(DB.String(), primary_key=True)
lifegroup = DB.Column(DB.String(20), DB.ForeignKey('lifegroups.name', ondelete='CASCADE'), nullable=False)
text = DB.Column(DB.String(), nullable=False)
def __repr__(self):
return '<Note %r>' % self.id
class Person(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
def __repr__(self):
return '<Person %r>' % self.username
def __init__(self, username, email):
self.username = username
self.email = email
class User(DB.Model):
""" User class """
__tablename__ = "users"
id = DB.Column(DB.Integer, primary_key=True)
name = DB.Column(DB.String(64))
def __init__(self, name=None):
self.name = name
class Person(DB.Model):
'''
Schema for database
'''
username = DB.Column(DB.String(80), primary_key=True)
score = DB.Column(DB.Integer, nullable=False)
def __repr__(self):
return '<Person %r>' % self.username
class Subject(DB.Model):
"""Класс для сущности 'Предмет обучения'"""
__tablename__ = 'subject'
id = DB.Column('subject_id', DB.INTEGER, primary_key=True, autoincrement=True)
name = DB.Column('subject_name', DB.String(45), nullable=False, unique=True)
def __repr__(self):
return "Subject(id={id}, name={name})".format(id=self.id, name=self.name)
class Base(DB.Model):
__abstract__ = True
id = DB.Column(DB.Integer, primary_key=True)
date_created = DB.Column(DB.DateTime, default=DB.func.current_timestamp())
date_modified = DB.Column(DB.DateTime,
default=DB.func.current_timestamp(),
onupdate=DB.func.current_timestamp())
