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