class Menu(db.Model):
__tablename__ = 'menu'
id = db.Column(Integer, primary_key=True, autoincrement=True)
parent_id = Column(Integer, db.ForeignKey('menu.id'), nullable=True)
name = db.Column(db.String(225))
url = db.Column(db.String(225))
slug = db.Column(db.String(225))
parent = db.relation('Menu', remote_side=[id])
position_id = db.Column(Integer, db.ForeignKey('menu_position.id'))
position = db.relation('MenuPosition', remote_side=[MenuPosition.id])
def __repr__(self):
return '<Menu %r>' % (self.name)
def children(self):
_children = Menu.query.filter(Menu.parent == self)
for child in _children:
child.parent = self # Hack to avoid unnecessary DB queries further down the track.
return _children
def is_parent(self):
if not self.parent_id:
return True
return False
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(40), nullable=False)
password = db.Column(db.String(120), nullable=False)
is_admin = db.Column(db.Integer, nullable=False)
icon = db.Column(db.String(45), nullable=False)
created_at = db.Column(db.DateTime, nullable=False)
updated_at = db.Column(db.DateTime, nullable=False)
is_deleted = db.Column(db.Integer, nullable=False)
edudaily = db.relation("EduDaily", backref="user")
edudailycomment = db.relation("EduDailyComment", backref="user")
def __init__(self,
name=None,
password=None,
is_admin=0,
icon=None,
is_deleted=0):
self.name = name
self.password = password
self.is_admin = is_admin
self.icon = icon
now = datetime.datetime.now()
self.created_at = now
self.updated_at = now
self.is_deleted = is_deleted
def get_id(self):
return self.id
def get_name(self):
return self.name
def get_password(self):
return self.password
def get_admin(self):
return self.is_admin == 1
def get_created_at(self):
return str(self.created_at)
def get_updated_at(self):
return str(self.updated_at)
def get_all_posts(self):
return EduDaily.query.order_by(EduDaily.updated_at.desc())
def get_is_deleted(self):
return self.is_deleted == 1
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
class Permission(db.Model):
__tablename__ = "permission"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), nullable=False) # 权限名称
groups = db.relation("Group", secondary="group_permission_relation")
class Room(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30))
link = db.Column(db.String(32))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
guests = db.Column(db.String(50))
tokens = db.relation('Token', backref='party', lazy=True)
class Categories(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), unique=True)
spending = db.relation("Spending", backref="category", lazy="dynamic")
def __repr__(self):
return f"<Category {self.name}>"
class Task(db.Model):
id = db.Column(db.Integer, primary_key=True)
annotator_id = db.Column(db.Integer, nullable=False)
dataset_id = db.Column(db.Integer, nullable=False)
done = db.Column(db.Boolean, nullable=False, default=False)
annotated_on = db.Column(db.DateTime, nullable=True)
admin_assigned = db.Column(db.Boolean, default=False)
user = db.relation("User")
annotator_id = db.Column(db.Integer, db.ForeignKey("user.id"))
dataset = db.relation("Dataset")
dataset_id = db.Column(db.Integer, db.ForeignKey("dataset.id"))
def __repr__(self):
return "<Task (%r, %r)>" % (self.annotator_id, self.dataset_id)
class Bet(db.Model):
__tablename__ = 'bet'
user_id = db.Column(db.Integer,
db.ForeignKey('user.user_id'),
primary_key=True)
match_id = db.Column(db.Integer,
db.ForeignKey('fixture.match_id'),
primary_key=True)
match = db.relation(Match)
bet_type = db.Column(db.Integer, primary_key=True)
bet_amount = db.Column(db.Integer, nullable=False)
bet_content = db.Column(db.String(10), nullable=False)
bet_time = db.Column(db.DATETIME)
bet_status = db.Column(db.String(12))
bet_gain = db.Column(db.Integer)
def __init__(self, user_id, match_id, bet_type, bet_amount, bet_content,
bet_time):
self.user_id = user_id
self.match_id = match_id
self.bet_type = bet_type
self.bet_amount = bet_amount
self.bet_content = bet_content
self.bet_time = bet_time
self.bet_status = 'PROCESSING'
self.bet_gain = 0
def save(self):
db.session.add(self)
db.session.commit()
def end(self, bet_gain):
if bet_gain == 0:
self.bet_status = 'LOSE'
else:
self.bet_gain = bet_gain
self.bet_status = 'WIN'
db.session.commit()
@classmethod
def find_bet(cls, user_id, match_id, bet_type):
return cls.query.filter_by(user_id=user_id,
match_id=match_id,
bet_type=bet_type).first()
@classmethod
def find_bets_of_user(cls, user_id):
return cls.query.filter_by(user_id=user_id).order_by(
desc('bet_time')).all()
@classmethod
def find_bets_of_match(cls, match_id):
return cls.query.filter_by(match_id=match_id).order_by(
asc('bet_time')).all()
@classmethod
def find_user_bets_for_match(cls, match_id, user_id):
return cls.query.filter_by(match_id=match_id, user_id=user_id).all()
class Favorites(db.Model, dbFunctions):
id = db.Column('id', db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey(User.id, ondelete='CASCADE'),
nullable=False)
#post_id = db.Column(db.Integer, db.ForeignKey(Post.id, ondelete='CASCADE'), nullable=False)
author = db.relation(User, innerjoin=True, lazy="joined")
class Comment(db.Model):
__tablename__ = 'comment'
match_id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.user_id'),
primary_key=True)
user = db.relation(User)
time = db.Column(db.DATETIME, primary_key=True)
comment = db.Column(db.String(300))
def __init__(self, match_id, user_id, comment):
self.match_id = match_id
self.user_id = user_id
self.time = datetime.datetime.now()
self.comment = comment
def save(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_comments_of_match(cls, match_id, number):
return cls.query.filter_by(match_id=match_id).order_by(
desc('time')).limit(number).all()
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, unique=True)
users = db.relation('User', backref='role')
def __repr__(self):
return f'<Role {self.name}>'
class Group(db.Model):
__tablename__ = "group"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), nullable=False) # 组名
parent_id = db.Column(db.Integer, nullable=True) # 父级ID
permissions = db.relation("Permission",
secondary="group_permission_relation")
class Annotation(db.Model):
id = db.Column(db.Integer, primary_key=True)
cp_index = db.Column(db.Integer)
task = db.relation("Task")
task_id = db.Column(db.Integer, db.ForeignKey("task.id"))
def __repr__(self):
return "<Annotation %r>" % self.id
class Order(db.Model):
__tablename__ = 'order'
order_id = db.Column(db.Integer, primary_key=True)
status_id = db.Column(db.Integer, db.ForeignKey('order_status.status_id'))
client_id = db.Column(db.Integer, db.ForeignKey('client.client_id'))
house_id = db.Column(db.Integer, db.ForeignKey('house.house_id'))
house = db.relation('House', backref='orders')
booking_time = db.Column(db.DateTime, index=True, default=datetime.utcnow)
check_in_time = db.Column(db.DateTime, index=True)
check_out_time = db.Column(db.DateTime, index=True)
class Case(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
date_opened = db.Column(db.DateTime)
date_closed = db.Column(db.DateTime)
case_name = db.Column(db.String(255), unique=True)
court_case_number = db.Column(db.String(255))
clients = db.relationship('Person', back_populates='case', lazy='dynamic')
phone_logs = db.relation('PhoneLogEntry',
back_populates='case',
lazy='dynamic')
class Match(db.Model):
__tablename__ = 'fixture'
match_id = db.Column(db.Integer, primary_key=True)
league_id = db.Column(db.Integer, db.ForeignKey('league.league_id'))
league_entity = db.relation(League)
match_date = db.Column(db.String(40), nullable=False)
match_time = db.Column(db.String(40), nullable=False)
match_hometeam_name = db.Column(db.String(60), nullable=False)
match_awayteam_name = db.Column(db.String(60), nullable=False)
match_hometeam_halftime_score = db.Column(db.Integer)
match_awayteam_halftime_score = db.Column(db.Integer)
match_hometeam_score = db.Column(db.Integer)
match_awayteam_score = db.Column(db.Integer)
yellow_card = db.Column(db.Integer)
match_status = db.Column(db.String(6))
def __init__(self, match_id, league_id, match_date, match_time,
match_hometeam_name, match_awayteam_name,
match_hometeam_halftime_score, match_awayteam_halftime_score,
match_hometeam_score, match_awayteam_score, yellow_card,
match_status):
self.match_id = match_id
self.league_id = league_id
self.match_date = match_date
self.match_time = match_time
self.match_hometeam_name = match_hometeam_name
self.match_awayteam_name = match_awayteam_name
self.match_hometeam_halftime_score = match_hometeam_halftime_score
self.match_awayteam_halftime_score = match_awayteam_halftime_score
self.match_hometeam_score = match_hometeam_score
self.match_awayteam_score = match_awayteam_score
self.yellow_card = yellow_card
self.match_status = match_status
def save(self):
db.session.add(self)
db.session.commit()
def update(self, match_hometeam_halftime_score,
match_awayteam_halftime_score, match_hometeam_score,
match_awayteam_score, yellow_card, match_status):
self.match_hometeam_halftime_score = match_hometeam_halftime_score
self.match_awayteam_halftime_score = match_awayteam_halftime_score
self.match_hometeam_score = match_hometeam_score
self.match_awayteam_score = match_awayteam_score
self.yellow_card = yellow_card
self.match_status = match_status
db.session.commit()
@classmethod
def find_match_by_id(cls, match_id):
return cls.query.filter_by(match_id=match_id).first()
class QuestionChoice(db.Model):
__tablename__ = 'questionChoice'
id = db.Column(db.Integer,primary_key=True)
question_id = db.Column(db.Integer, ForeignKey('question.id'))
choice_number = db.Column(db.Integer)
choice_content = db.Column(db.String(80))
choice_correct = db.Column(db.Boolean)
userAnswers = db.relation('UserAnswer', back_populates='questionChoice')
#choice_chosen = db.relationship('UserAnswer', backref='questionChoice', lazy=True)
def __repr__(self):
return str(self.id)
def as_str(self):
return ' id:{}'.format(self.id) +'<question_id:{}'.format(self.question_id) +'<choice num:{}'.format(self.choice_number) + '< correct :{}'.format(self.choice_correct) + '<choice content:{}'.format(self.choice_content)
class Role(db.Model):
"""
Create role table
"""
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), unique=True)
description = db.Column(db.String(200))
employee = db.relation('Employee', backref='role', lazy='dynamic')
def __repr__(self):
return '<Role: {}>'.format(self.name)
class Category(db.Model, dbFunctions):
__tabename__ = "category"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
parent_id = db.Column(db.Integer,
db.ForeignKey("category.id", ondelete='CASCADE'))
parent = db.relation('Category', remote_side=[id])
__mapper_args__ = {'order_by': id.asc()}
def __init__(self, *args, **kwargs):
super(Category, self).__init__(*args, **kwargs)
class Cycle(db.Model, dbFunctions):
__tablename__ = "cycles"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True)
build = db.Column(db.String())
description = db.Column(db.String())
author_id = db.Column(db.Integer,
db.ForeignKey(User.id, ondelete='CASCADE'),
nullable=False)
author = db.relation(User, innerjoin=True, lazy="joined")
date_created = db.Column(db.DateTime, default=datetime.utcnow)
last_updated = db.Column(db.DateTime,
onupdate=datetime.utcnow,
default=datetime.utcnow)
__mapper_args__ = {'order_by': id.desc()}
# FIXME Test step
def __init__(self, *args, **kwargs):
super(Cycle, self).__init__(*args, **kwargs)
def __repr__(self):
return '<User %r>' % self.name
def _url(self, _external=False):
return url_for('cycle.view',
cycle_id=self.id,
slug=self.slug,
_external=_external)
@cached_property
def url(self):
return self._url()
@cached_property
def permalink(self):
return self._url(True)
@cached_property
def markdown(self):
return tomarkdown(self.description or '')
@cached_property
def slug(self):
return slugify(self.name or '')[:80]
class Character(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
name = db.Column(db.String(30))
lvlclass = db.Column(db.String(20))
armor = db.Column(db.Integer)
speed = db.Column(db.Integer)
race = db.Column(db.String(15))
stats = db.Column(db.String(20))
willsave = db.Column(db.String(16))
skills = db.Column(db.String(40))
abilities = db.Column(db.String(512))
inventory = db.Column(db.String(512))
health = db.Column(db.Integer)
tokens = db.relation('Token', backref='char', lazy=True)
class Employee(User):
__tablename__ = 'employee'
employee_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False,
unique=True)
managed_by = db.Column(db.Integer,
db.ForeignKey('employee.employee_id'),
nullable=True)
commission = db.Column(db.Float, nullable=False)
max_discount = db.Column(db.Float, nullable=False)
title = db.Column(db.Enum('Director', 'Manager', 'Salesperson'),
nullable=False)
manager = db.relation('Employee',
foreign_keys=[managed_by],
remote_side=[employee_id],
backref=db.backref('direct_reports'))
clients = db.relation('Client',
foreign_keys=[Client.salesperson_id],
backref=db.backref('salesperson'))
@property
def sales_total(self):
return sum([order.total for order in self.orders])
@property
def all_reports(self):
reports = [r for r in self.direct_reports]
for r in reports:
reports.extend(r.all_reports)
return reports
def __repr__(self):
return '<Employee id: %i, username: %r>' % (self.id, self.username)
class UserAnswer(db.Model):
__tablename__ = 'userAnswer'
id = db.Column(db.Integer, primary_key=True)
attempt_id = db.Column(db.Integer, ForeignKey('userAttempt.id'))
user_id = db.Column(db.Integer, ForeignKey('user.id'))
question_id = db.Column(db.Integer, ForeignKey('question.id'))
choice_id = db.Column(db.Integer, ForeignKey('questionChoice.id'))
timestamp = db.Column(db.DateTime, default = datetime.utcnow)
questionChoice = db.relation('QuestionChoice', back_populates='userAnswers')
question = db.relationship('Question', back_populates='userAnswers')
def __repr__(self):
return str(self.id)
def as_str(self):
return '<Answer id:{}'.format(self.id)+' user_id:{}'.format(self.user_id)+' question_id:{}'.format(self.question_id)+' choice_id_id:{}'.format(self.choice_id)+'>'
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
admin = db.Column(db.Boolean)
recorded_data = db.relation('ProdData')
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def __repr__(self):
return '<User {}>'.format(self.username)
class Todo(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50), nullable=False)
description = db.Column(db.String(140), nullable=False)
created_at = db.Column(db.DateTime, index=True, nullable=False, default=datetime.utcnow)
completed = db.Column(db.Boolean, index=True, default=False)
completed_at = db.Column(db.DateTime, index=True, default=None, nullable=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
reactions = db.relation('TodoReaction', backref='todo', lazy='dynamic')
def get_creator(self):
return User.query.get(self.user_id)
def has_liked(self, user):
return self.reactions.filter_by(user_id=user.id).count() > 0
def __repr__(self):
return '<Todo {}>'.format(self.title)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(140))
slug = db.Column(db.String(140), unique=True)
body = db.Column(db.Text)
created = db.Column(db.DateTime, default=datetime.now())
tags = db.relation('Tag', secondary=post_tags, backref=db.backref('posts', lazy='dynamic'))
def __init__(self, *args, **kwargs):
super(Post, self).__init__(*args, **kwargs)
self.generate_slug()
def generate_slug(self):
if self.title:
self.slug = slugify(self.title)
def __repr__(self):
return '<Post id: {}, title: {}>'.format(self.id, self.title)
class EduDaily(db.Model):
__tablename__ = 'edu_daily'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey(User.id), nullable=False)
title = db.Column(db.String(256), nullable=False)
path = db.Column(db.String(256), nullable=False)
star = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime, nullable=False)
updated_at = db.Column(db.DateTime, nullable=False)
edudailycomment = db.relation("EduDailyComment",
backref="edudaily",
cascade="all, delete-orphan")
def __init__(self, user_id=None, title=None, path=None, star=0):
self.user_id = user_id
self.title = title
self.path = path
self.star = star
now = datetime.datetime.now()
self.created_at = now
self.updated_at = now
class TestSet(db.Model, dbFunctions):
__tablename__ = "testsets"
id = db.Column(db.Integer, primary_key=True)
filename = db.Column(db.String(80), unique=True)
author_id = db.Column(db.Integer,
db.ForeignKey(User.id, ondelete='CASCADE'),
nullable=False)
author = db.relation(User, innerjoin=True, lazy="joined")
date_created = db.Column(db.DateTime, default=datetime.utcnow)
last_updated = db.Column(db.DateTime,
onupdate=datetime.utcnow,
default=datetime.utcnow)
__mapper_args__ = {'order_by': id.desc()}
# FIXME Test step
def __init__(self, filename, author_id):
self.filename = filename
self.author_id = author_id
def __repr__(self):
return '<TestSet %r>' % self.filename
@cached_property
def url(self):
return testset.url(self.filename)
@cached_property
def permalink(self):
return self._url(True)
@cached_property
def slug(self):
return slugify(self.filename or '')[:80]
class UserImage(db.Model, dbFunctions):
__tablename__ = "images"
id = db.Column('id', db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey(User.id, ondelete='CASCADE'),
nullable=False)
filename = db.Column(db.String(60))
user = db.relation(User, innerjoin=True, lazy="joined")
def __init__(self, filename, user):
self.filename = filename
self.user = user
def __repr__(self):
return '<Photo %r>' % self.filename
@property
def url(self):
return (userimage.url(self.filename))
def save(self):
db.session.add(self)
db.session.commit()
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
admin = db.Column(db.Boolean)
bias = db.Column(db.Integer)
runs = db.relation('Order',
backref='courrier',
primaryjoin='Order.courrier_id==User.id',
foreign_keys='Order.courrier_id')
orderItems = db.relationship('OrderItem', backref='user', lazy='dynamic')
def configure(self, username, admin, bias):
self.username = username
self.admin = admin
self.bias = bias
def is_authenticated(self):
return True
def is_active(self):
return True
def is_admin(self):
return self.admin
def is_anonymous(self):
return False
def get_id(self):
try:
return unicode(self.id) # python 2
except NameError:
return str(self.id) # python 3
def __repr__(self):
return '%s' % self.username
class UserAttempt(db.Model):
__tablename__ ='userAttempt'
id = db.Column(db.Integer, primary_key=True)
attempt_number = db.Column(db.Integer)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable = False)
quiz_id = db.Column(db.Integer, db.ForeignKey('quiz.id'))
#totalscore = db.Column(db.Integer)
#attemptnum = db.Column(db.Integer)
#prevattempt = db.Column(db.Integer)
userAnswers = db.relation('UserAnswer', backref='userAttempt', lazy='dynamic')
def __repr__(self):
return str(self.id)
def as_str(self):
return '<id:{}'.format(self.id)+' user_id:{}'.format(self.user_id)+ 'attemptnum:{}'.format(self.attempt_number) +'quiz id:{}'.format(self.quiz_id)
def get_score(self):
score = 0
for answer in self.userAnswers:
print("Answer: "+answer.as_str())
if answer.questionChoice.choice_correct: score = score + 1
return score
