class StudentModel(UserModel):
student_courses_table = db.Table('student_courses', db.Model.metadata,
db.Column('student_id', db.Integer,
db.ForeignKey('student.id')),
db.Column('course_id', db.Integer, db.ForeignKey('course.id'))
)
student_majors_table = db.Table('student_majors', db.Model.metadata,
db.Column('student_id', db.Integer,
db.ForeignKey('student.id')),
db.Column('major_id', db.Integer, db.ForeignKey('major.id'))
)
__tablename__ = 'student'
id = db.Column(db.Integer, db.ForeignKey('booklick_user.id'), primary_key=True)
first_name = db.Column(db.String(100))
last_name = db.Column(db.String(100))
description = db.Column(db.String(500))
picture = db.Column(db.String(100))
semester = db.Column(db.Integer)
courses = db.relationship("CourseModel",
secondary=student_courses_table,
backref=db.backref('students', lazy=True))
majors = db.relationship("MajorModel",
secondary=student_majors_table,
backref=db.backref('students', lazy=True))
__mapper_args__ = {
'polymorphic_identity': 'student',
}
def __init__(self, username: str, email: str, code: int, first_name: str, last_name: str,
password: str, description: str, picture: str, semester: int):
class TalentPoolGroup(db.Model):
__tablename__ = 'talent_pool_group'
id = db.Column(db.Integer, primary_key=True)
talent_pool_id = db.Column(db.Integer,
db.ForeignKey('talent_pool.id',
ondelete='CASCADE'),
nullable=False)
user_group_id = db.Column(db.Integer,
db.ForeignKey('user_group.Id',
ondelete='CASCADE'),
nullable=False)
# Relationships
talent_pool = db.relationship('TalentPool',
backref=db.backref(
'talent_pool_group',
cascade="all, delete-orphan"))
user_group = db.relationship('UserGroup',
backref=db.backref(
'talent_pool_group',
cascade="all, delete-orphan"))
def __repr__(self):
return "<TalentPoolGroup: (talent_pool_id = {})>".format(
self.talent_pool_id)
@classmethod
def get(cls, talent_pool_id, user_group_id):
return cls.query.filter_by(talent_pool_id=talent_pool_id,
user_group_id=user_group_id).first()
def delete(self):
db.session.delete(self)
db.session.commit()
class RecipeCourses(db.Model):
"""Relationship class recipe and courses"""
__tablename__ = 'recipes_has_courses'
id = db.Column(
db.Integer,
primary_key=True,
)
recipes_id = db.Column(db.Integer, db.ForeignKey('recipes.id'))
courses_id = db.Column(db.Integer, db.ForeignKey('courses.id'))
recipes = db.relationship("RecipeModel",
backref=db.backref("recipes_has_courses",
passive_deletes=True,
cascade="all, delete-orphan"))
courses = db.relationship("CoursesModel",
backref=db.backref("recipes_has_courses",
passive_deletes=True,
cascade="all, delete-orphan"))
def __init__(self, id, recipes_id, courses_id):
self.id = id
self.recipes_id = recipes_id
self.courses_id = courses_id
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(recipes_id=_id).first()
class MovieModel(db.Model):
__tablename__ = 'movies'
id = db.Column(db.Integer, primary_key=True)
imdbId = db.Column(db.String(100))
title = db.Column(db.String(100))
year = db.Column(db.Integer)
rating = db.Column(db.String(5))
releaseDate = db.Column(db.Date)
genres = db.relationship('GenreModel',
secondary=genres,
lazy='subquery',
backref=db.backref('movies', lazy=True))
director = db.Column(db.String(100))
actors = db.relationship('ActorModel',
secondary=actors,
lazy='subquery',
backref=db.backref('movies', lazy=True))
plot = db.Column(db.Text)
languages = db.relationship('LanguageModel',
secondary=languages,
lazy='subquery',
backref=db.backref('movies', lazy=True))
countries = db.relationship('CountryModel',
secondary=countries,
lazy='subquery',
backref=db.backref('movies', lazy=True))
poster = db.Column(db.String(100))
type = db.Column(db.String(50))
production = db.Column(db.String(100))
ratings = db.relationship('RatingModel',
lazy='subquery',
backref=db.backref('ratings', lazy=True))
class OrderItemModel(db.Model):
__tablename__ = "order_items"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
order_id = db.Column(db.Integer,
db.ForeignKey('orders.id'),
nullable=False)
order = db.relationship('OrderModel',
backref=db.backref('order_items', lazy=True))
product_id = db.Column(db.Integer,
db.ForeignKey('products.id'),
nullable=False)
product = db.relationship('ProductModel',
backref=db.backref('order_items', lazy=True))
price = db.Column(db.Integer)
quantity = db.Column(db.Integer, default=1)
created_at = db.Column(db.DateTime, server_default=func.now())
@classmethod
def find_by_id(cls, _id: int) -> "OrderItemModel":
return cls.query.filter_by(id=_id).first()
def update(self) -> None:
db.session.commit()
def save_to_db(self) -> None:
db.session.add(self)
db.session.commit()
def delete_from_db(self) -> None:
db.session.delete(self)
db.session.commit()
class Alarm_record(db.Model):
__tablename__ = 'alarm_record'
id = db.Column(db.String(30),
primary_key=True,
nullable=False,
default=lambda: 'ar_' + shortuuid.uuid())
equipment_id = db.Column(db.String(30), db.ForeignKey('equipment.id'))
equipment = db.relationship('Equipment',
backref=db.backref('alarm_records',
lazy='dynamic'))
describe = db.Column(db.String(30))
class_ = db.Column(db.String(10), nullable=False)
operator_id = db.Column(db.String(30), db.ForeignKey('user.id'))
operator = db.relationship('User',
backref=db.backref('dealed_alarms',
lazy='dynamic'))
alarm_time = db.Column(db.DateTime, nullable=False)
end_time = db.Column(db.DateTime)
create_time = db.Column(db.DateTime, default=datetime.now)
modify_time = db.Column(db.DateTime,
default=datetime.now,
onupdate=datetime.now)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80),
unique=True,
nullable=False,
doc="user account")
name = db.Column(db.String(80), nullable=False, doc="real username")
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
gender = db.Column(db.Integer, nullable=False, doc="1:male,0:female")
status = db.Column(db.Integer, nullable=False, doc="0:disable,1:enable")
group_id = db.Column(db.Integer, db.ForeignKey('group.id'), nullable=False)
position_id = db.Column(db.Integer,
db.ForeignKey('position.id'),
nullable=False)
created_time = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_time = db.Column(db.DateTime, nullable=False, default=datetime.now)
group = db.relationship('Group', backref=db.backref('users', lazy=True))
position = db.relationship('Position',
backref=db.backref('users', lazy=True))
user_role = db.relationship('Role',
secondary=user_role,
lazy='subquery',
backref=db.backref('users', lazy=True))
def __repr__(self):
return '<User %r>' % self.username
class Farms_Model(db.Model):
__tablename__ = "farms"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
latitude = db.Column(db.String(10))
longitude = db.Column(db.String(10))
creation_date = db.Column(db.DateTime(), default=datetime.now())
users = db.relationship('Users_Farms_Model',
backref=db.backref('farm', lazy=True))
sheeps = db.relationship('Sheep_Model',
backref=db.backref('farm', lazy=True))
def __init__(self, name, latitude, longitude):
self.name = name
self.latitude = latitude
self.longitude = longitude
def save_to_db(self):
db.session.add(self)
db.session.commit()
def json(self):
return {
'id': self.id,
'name': self.name,
'latitude': self.latitude,
'longitude': self.longitude
}
class Plan(SerializableModel, db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), nullable=False)
users = db.relationship('User',
secondary=plans_users,
backref=db.backref('plans', lazy='dynamic'))
meals = db.relationship('Meal', backref=db.backref('plan'))
class Project(db.Model):
"""
A Project represents an opensource project
"""
__tablename__ = 'projects'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
url = db.Column(db.String)
createdDate = db.Column(db.DateTime)
private = db.Column(db.Boolean)
owner_id = db.Column(db.Integer, db.ForeignKey('companies.id'))
description = db.Column(db.String)
languages = db.relationship('Language',
secondary=language_usage,
backref=db.backref('projects', lazy='dynamic'))
contributors = db.relationship('Contributor',
secondary=project_participation,
backref=db.backref('projects',
lazy='dynamic'))
def __init__(self, name, url, createdDate, description, private):
self.name = name
self.url = url
self.createdDate = createdDate
self.description = description
self.private = private
def __repr__(self):
return '<Project %r>' % self.name
@staticmethod
def column_queries(tokens):
column_queries = []
for token in tokens:
column_queries.append(
or_(
func.lower(Project.name).like(token),
func.lower(Project.url).like(token),
func.lower(cast(Project.createdDate, String)).like(token),
func.lower(cast(Project.private, String)).like(token),
func.lower(Project.description).like(token)))
return column_queries
def dictionary(self):
pdict = {}
pdict['id'] = self.id
pdict['name'] = self.name
pdict['url'] = self.url
pdict['description'] = self.description
pdict['createdDate'] = self.createdDate
pdict['private'] = self.private
languages = list(self.languages)
contributors = list(self.contributors)
if languages:
pdict['language_ids'] = [l.id for l in languages]
if contributors:
pdict['contributor_ids'] = [c.id for c in contributors]
pdict['owner_id'] = self.owner_id
return pdict
class Measure(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
quantity = db.Column(db.Integer, nullable=False)
ingredient_id = db.Column(db.Integer, db.ForeignKey('ingredient.id'), nullable=False)
unit_id = db.Column(db.Integer, db.ForeignKey('unit.id'), nullable=False)
recipe = db.relationship('Recipe', secondary=recipe_measure, lazy='joined', backref=db.backref('measures', lazy=True))
ingredient = db.relationship('Ingredient', lazy='joined', backref=db.backref('ingredient', lazy=True))
unit = db.relationship('Unit', backref=db.backref('unit', uselist=False))
class Class(db.Model):
__tablename__ = 'class'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100), nullable=False) # 班级名称 专业-班级
admin_id = db.Column(db.Integer, db.ForeignKey('admin_people.id')) # 辅导员id
college_id = db.Column(db.Integer, db.ForeignKey('college.id'), nullable=False) # 班级对应学院
admin = db.relationship('Admin_people', backref=db.backref('classes1'))
college = db.relationship('College', backref=db.backref('classes2'))
class PostModel(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(Configuration.MAX_POST_TITLE_SIZE))
body = db.Column(db.Text)
user_id = db.Column(db.Integer, nullable=False)
is_published = db.Column(db.Boolean, nullable=False)
tags = db.relationship('TagModel',
secondary=post_tags,
backref=db.backref('posts'),
lazy='dynamic')
category_id = db.Column('category_id', db.Integer,
db.ForeignKey(CategoryModel.id))
comments = db.relationship('models.comment.CommentModel',
backref=db.backref('posts'),
lazy='dynamic')
def __init__(self, *args, **kwargs):
super(PostModel, self).__init__(*args, **kwargs)
def __repr__(self):
return "<Post id: {}, title: {}>".format(self.id, self.title)
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def get_json(self):
return {
'id': self.id,
'title': self.title,
'body': self.body,
'is_published': self.is_published,
'user_id': self.user_id,
'tags': self.get_tags(),
'category_id': self.category_id,
'comments': self.get_comments()
}
def get_tags(self):
return [tag.name for tag in self.tags]
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def get_comments(self):
return [comment.name for comment in self.comments]
class UserPolls(Base):
topic_id = db.Column(db.Integer, db.ForeignKey('topics.id'))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
topics = db.relationship('Topics',
foreign_keys=[topic_id],
backref=db.backref('voted_on_by', lazy='dynamic'))
users = db.relationship('Users',
foreign_keys=[user_id],
backref=db.backref('voted_on', lazy='dynamic'))
class User_log(db.Model):
__tablename__ = 'user_log'
id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 这里的id是每检测一个学生就会有一个id
temperature = db.Column(db.String(100))
create_time = db.Column(db.DateTime, default=datetime.now) # 检测时间
status = db.Column(db.Enum('正常', '异常'), server_default='正常')
if_sure = db.Column(db.BOOLEAN,default=False) # 记录是否经过确认
equipment_id = db.Column(db.Integer, db.ForeignKey('equipment.id'), nullable=False) # 检测的仪器
user_id = db.Column(db.Integer, db.ForeignKey('user.id')) # 后期查找时通过user_id来找到多次检测的信息
user = db.relationship('User', backref=db.backref('user_logs'))
equipment = db.relationship('Equipment', backref=db.backref('user_logs1'))
class GroupModel(db.Model):
__tablename__ = 'groups'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
description = db.Column(db.String(255))
members = db.relationship('UserModel',
secondary=group_user,
backref=db.backref('groups'),
lazy='dynamic')
events = db.relationship('EventModel',
backref=db.backref('groups'),
lazy=True)
def __init__(self, name, description):
self.name = name
self.description = description
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def add_member(self, user):
self.members.append(user)
db.session.commit()
def remove_member(self, user):
self.members.remove(user)
db.session.commit()
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
def json(self):
return {
'id': self.id,
'name': self.name,
'description': self.description,
'members': [user.simple_json() for user in self.members.all()],
'events': [event.json() for event in self.events]
}
def short_json(self):
return {'id': self.id, 'name': self.name}
class Answer(db.Model):
__tablename__ = 'answer'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
content = db.Column(db.Text, nullable=False)
create_time = db.Column(db.DateTime, default=datetime.now)
question_id = db.Column(db.Integer, db.ForeignKey('question.id'))
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
question = db.relationship('Question',
backref=db.backref('answers',
order_by=id.desc()))
author = db.relationship('User', backref=db.backref('answers'))
class Article(db.Model):
__tablename__ = 'article'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(50), nullable=False)
content = db.Column(db.String(50), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
create_time = db.Column(db.DATETIME, default=datetime.now)
author = db.relationship('User',
backref=db.backref('articles', uselist=True),
uselist=False)
tags = db.relationship('Tags',
secondary=ArticleTags,
backref=db.backref('articles', uselist=True),
uselist=True)
class Role(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True, nullable=False)
enname = db.Column(db.String(80), unique=True, nullable=False)
status = db.Column(db.Integer, nullable=False, doc="0:disable,1:enable")
created_time = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_time = db.Column(db.DateTime, nullable=False, default=datetime.now)
role_menu = db.relationship('Menu',
secondary=role_menu,
lazy='subquery',
backref=db.backref('roles', lazy=True))
user_role = db.relationship('User',
secondary=user_role,
lazy='subquery',
backref=db.backref('roles', lazy=True))
class CategoryModel(db.Model):
__tablename__ = 'categories'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(Configuration.MAX_CATEGORY_NAME_SIZE),
unique=True)
posts = db.relationship('models.post.PostModel',
backref=db.backref('categories'),
lazy='dynamic')
def __init__(self, *args, **kwargs):
super(CategoryModel, self).__init__(*args, **kwargs)
def __repr__(self):
return '<Category id: {}, name: {}>'.format(self.id, self.name)
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def get_json(self):
return {'id': self.id, 'name': self.name, 'posts': self.get_posts()}
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def get_posts(self):
return [post.id for post in self.posts]
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(250), nullable=False)
last_name = db.Column(db.String(250), nullable=False)
is_loyal = db.Column(db.Boolean, unique=False, default=False)
creation_date = db.Column(db.TIMESTAMP, server_default=db.func.current_timestamp(), nullable=False)
basket_id = db.Column(db.Integer, db.ForeignKey('baskets.id', ondelete='CASCADE'), nullable=False)
basket = db.relationship('Basket', backref=db.backref('users', lazy='dynamic'))
def __init__(self, first_name, last_name, basket_id):
self.first_name = first_name
self.last_name = last_name
self.basket_id = basket_id
@staticmethod
def create(items, first_name=None, last_name=None):
user = User()
user.first_name = first_name
user.last_name = last_name
db.session.add(user)
try:
for item in items:
user.items.append(item[0])
db.session.commit()
return user
except ():
pass
def __repr__(self):
return '<id {}>'.format(self.id)
class Category(BaseModel):
__tablename__ = 'categories'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), unique=True, nullable=False)
# 1 to N relationship with articles
article = db.relationship('Article',
lazy='subquery',
backref=db.backref('category', lazy='joined'))
def __repr__(self):
return '<Category %r>' % self.name
@classmethod
def find_by_uuid(cls, uuid):
return cls.query.filter_by(uuid=uuid).first()
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
def commit(self):
db.session.add(self)
db.session.commit()
def remove(self):
db.session.delete(self)
db.session.commit()
class ConferenceSpeaker(db.Model):
__tablename__ = "speakers"
id = db.Column(db.Integer, primary_key=True)
firstName = db.Column(db.String(150), nullable=False)
lastName = db.Column(db.String(150), nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
phone = db.Column(db.String(80), unique=True, nullable=True)
description = db.Column(db.String(255), nullable=True)
instituion = db.Column(db.String(140), nullable=True)
title = db.Column(db.String(120), nullable=True)
photo = db.Column(db.String(100), nullable=True, default="default.png")
website = db.Column(db.String(200), nullable=True)
# This should later be moved on its own model for db normalization
topic = db.Column(db.String(140), nullable=True)
authors = db.Column(db.String(140), nullable=True)
summary = db.Column(db.String(140), nullable=True)
submittedDate = db.Column(db.DateTime,
nullable=True,
default=datetime.utcnow())
session = db.relationship('ConferenceSession',
backref=db.backref('Speaker', lazy=True))
def __repr__(self):
return f"ConferenceSession {self.firstName} {self.lastName}"
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def update(self):
db.session.commit()
class Game(db.Model):
id = db.Column(db.Integer, primary_key=True)
secret_number = db.Column(db.Integer, default=random.randint(0, 10))
attempt = db.Column(db.Integer)
status = db.Column(db.String, default='active')
author_id = db.Column(db.Integer, db.ForeignKey('game_user.id'))
players = db.relationship('GameUsers',
secondary=game_players,
backref=db.backref('players'))
range_from = db.Column(db.Integer)
range_to = db.Column(db.Integer)
winner_id = db.Column(db.Integer, db.ForeignKey('game_user.id'))
password = db.Column(db.String)
# def __init__(self, secret_number=None, attempt=None, status=None, author_id=None, range_from=None, range_to=None,
# password=None):
def __init__(self, secret_number, attempt, status, author_id, range_from,
range_to, password):
self.secret_number = secret_number
self.attempt = attempt
self.status = status
self.author_id = author_id
self.range_from = range_from
self.range_to = range_to
self.password = password
class Basket(db.Model):
__tablename__ = 'baskets'
id = db.Column(db.Integer, primary_key=True)
items = db.relationship('Item',
secondary=basket_item,
backref=db.backref('items', lazy='dynamic'))
price = db.Column(db.Integer)
@staticmethod
def create(items, price=None):
basket = Basket()
basket.price = price
db.session.add(basket)
try:
for item in items:
basket.items.append(item[0])
db.session.commit()
return basket
except ():
pass
def __repr__(self):
return '<id {}>'.format(self.id)
class Article(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Text, nullable=False)
body = db.Column(db.Text, nullable=False)
link = db.Column(db.Text, nullable=False)
guid = db.Column(db.String(255), nullable=False)
unread = db.Column(db.Boolean(255), default=True, nullable=False)
source_id = db.Column(db.Integer,
db.ForeignKey('source.id'),
nullable=False)
source = db.relationship('Source',
backref=db.backref('articles', lazy=True))
date_added = db.Column(db.DateTime, default=datetime.datetime.utcnow)
date_published = db.Column(db.DateTime)
__table_args__ = (db.UniqueConstraint('source_id',
'guid',
name='uc_source_guid'), )
@classmethod
def insert_from_feed(cls, source_id, feed_articles):
stmt = Article.__table__.insert().prefix_with('IGNORE')
articles = []
for article in feed_articles:
articles.append({
'title': article['title'],
'body': article['summary'],
'link': article['link'],
'guid': article['id'],
'source_id': source_id,
'date_published': article['published'],
})
db.engine.execute(stmt, articles)
class Article(db.Model):
sid = db.Column(db.Integer, primary_key=True)
source_system_id = db.Column(db.Text, nullable=False)
title = db.Column(db.Text, nullable=False)
body = db.Column(db.Text, nullable=False)
link = db.Column(db.Text, nullable=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
source_updated_at = db.Column(db.DateTime)
unread = db.Column(db.Boolean, default=True, nullable=False)
feed_source_sid = db.Column(db.Integer,
db.ForeignKey('feed_source.sid'),
nullable=False)
feed_source = db.relationship('FeedSource',
backref=db.backref('article', lazy=True))
__table_args__ = (db.UniqueConstraint('feed_source_sid',
'source_system_id',
name='uc_feed_source_id'), )
@classmethod
def insert_from_feed(cls, feed_source_sid, feed_articles):
articles = []
for article in feed_articles:
articles.append({
'title': article['title'],
'body': article['summary'],
'link': article['link'],
'source_system_id': article['id'],
'source_updated_at': article['source_updated_at'],
'feed_source_sid': feed_source_sid
})
insert_stmt = insert(Article).values(articles).on_conflict_do_nothing(
constraint='uc_feed_source_id')
db.engine.execute(insert_stmt)
class WorkshopLecturer(db.Model):
__tablename__ = "lecturers"
id = db.Column(db.Integer, primary_key=True)
firstName = db.Column(db.String(150), nullable=False)
lastName = db.Column(db.String(150), nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
phone = db.Column(db.String(80), unique=True, nullable=True)
description = db.Column(db.String(255), nullable=True)
instituion = db.Column(db.String(140), nullable=True)
title = db.Column(db.String(120), nullable=True)
photo = db.Column(db.String(100), nullable=True,default="default.png")
website = db.Column(db.String(200), nullable=True)
isLead = db.Column(db.Boolean, default=False, nullable=False)
trackName = db.relationship('Workshop',
backref=db.backref('lecturer', lazy=True))
def __repr__(self):
return f"WorkshopLecturer {self.firstName} {self.lastName}"
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def update(self):
db.session.commit()
class Note(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50), unique=True, nullable=False)
description = db.Column(db.String(300), default='')
date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
is_markdown = db.Column(db.Boolean, default=False)
categories = db.relationship('Category',
secondary=notes_categories,
lazy='subquery',
backref=db.backref('notes', lazy=True))
def json(self):
return {
'id': self.id,
'title': self.title,
'description': self.description,
'date': str(self.date),
'isMarkdownFile': self.is_markdown,
'categories': [category.name for category in self.categories]
}
def save(self):
db.session.add(self)
db.session.commit()
def __repr__(self):
return f"{self.id} {self.title} {self.categories}"
class User(db.Model, UserMixin):
"""
User Class
"""
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
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'))
def __init__(self, **kwargs):
self.__dict__.update(kwargs)
self.password = utils.hash_password(self.password)
def edit_update(self, form):
self.first_name = form.first_name.data
self.last_name = form.last_name.data
self.email = form.email.data
self.password = utils.hash_password(form.password.data)
def __str__(self):
return self.email
def is_active(self):
return self.active
def __unicode__(self):
return self.first_name
