class Task(db.Model, At, By):
__tablename__ = "Task"
PRIORITY_VALUES = [('low', 'low'), ('medium', 'medium'), ('high', 'high')]
STATUS_VALUES = [('TODO', 'TODO'), ('DOING', 'DOING'), ('DONE', 'DONE')]
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
description = db.Column(db.String(1000))
start_date = db.Column(db.Date(), nullable=False)
expected_end_date = db.Column(db.Date(), nullable=True)
actual_end_date = db.Column(db.Date())
task_status = db.Column(ChoiceType(STATUS_VALUES, impl=db.String(5)),
default='TODO',
nullable=True)
priority = db.Column(ChoiceType(PRIORITY_VALUES, impl=db.String(7)),
default='medium')
reporter_id = db.Column(db.Integer, db.ForeignKey('User.id'))
assignee_id = db.Column(db.Integer, db.ForeignKey('User.id'))
team_id = db.Column(db.Integer, db.ForeignKey('Team.id'))
reporter = db.relationship('User',
backref=db.backref('as_reporter'),
primaryjoin="User.id==Task.reporter_id")
assignee = db.relationship('User',
backref=db.backref('as_assignee'),
primaryjoin="User.id==Task.assignee_id")
team = db.relationship('Team', backref=db.backref('tasks', lazy='dynamic'))
class CommitteeContribution(BaseContribution):
donor_committee_id = db.Column(
db.Integer, db.ForeignKey("committee.id"), nullable=False
)
donor_committee = db.relationship(
"Committee",
foreign_keys=[donor_committee_id],
backref=db.backref("contributions_given", lazy=True),
)
recipient_name = db.Column(db.String)
recipient_city = db.Column(db.String(30))
recipient_state = db.Column(db.String(2))
recipient_zip = db.Column(db.String(9))
recipient_occupation = db.Column(db.String(38))
recipient_employer = db.Column(db.String(38))
other_fec_id = db.Column(db.String(9))
candidate_fec_id = db.Column(db.String(9))
recipient_committee_id = db.Column(db.Integer, db.ForeignKey("committee.id"))
recipient_committee = db.relationship(
"Committee",
foreign_keys=[recipient_committee_id],
backref=db.backref("committee_contributions_received", lazy=True),
)
candidate_id = db.Column(db.Integer, db.ForeignKey("candidate.id"))
candidate = db.relationship(
"Candidate", backref=db.backref("committee_contributions", lazy=True)
)
transaction_fec_id = db.Column(db.String(32))
file_num = db.Column(db.Numeric(22))
memo_cd = db.Column(db.String(1))
memo = db.Column(db.String)
fec_unique_id = db.Column(db.Numeric(19), unique=True, nullable=False)
class Note(db.Model):
__tablename__ = 'notes'
STATUS_DRAFT = 'draft'
STATUS_PUBLISHED = 'published'
SALE_TYPE_FREE = "free"
SALE_TYPE_PAY_AS_USE = "pay_as_use"
id = db.Column('id', db.String(64), primary_key=True)
user_id = db.Column('user_id', db.ForeignKey("users.id"), nullable=False)
title = db.Column('title', db.String(255))
description = db.Column('description', db.TEXT)
status = db.Column('status', db.String(32), nullable=False)
created_at = db.Column('created_at',
db.DATETIME,
default=datetime.now,
nullable=False)
updated_at = db.Column('updated_at',
db.DATETIME,
default=datetime.now,
onupdate=datetime.now)
user = db.relationship("User",
backref=db.backref("note_user", uselist=False),
lazy='joined')
tags = db.relationship('Tag',
secondary=NoteTag.__tablename__,
backref=db.backref('note_tags', lazy=True),
lazy='subquery')
def __repr__(self):
return "<Note '{}'>".format(self.id)
class Subject(BaseModel):
__tablename__ = 'subject'
topic = db.Column(db.Text, comment='考题题目')
type = db.Column(db.String(255), comment='考题类型')
answer = db.Column(db.Text, comment='考题答案')
scene_id = db.Column(db.Integer, db.ForeignKey('scene.id'),
comment='场景id')
scene = db.relationship('Scene',
backref=db.backref('subject',
lazy='dynamic'))
labels = db.relationship('Label', secondary=labels_subjects,
backref=db.backref('subjects', lazy='dynamic'))
class GroupHead(BaseModel):
__tablename__ = 'group_head'
total_group_score = db.Column(db.Integer, comment='组总得分', default=0)
group_id = db.Column(db.Integer, db.ForeignKey('group.id'),
comment='用户')
head_id = db.Column(db.Integer, db.ForeignKey('head.id'),
comment='标题')
head = db.relationship('Head',
backref=db.backref('group_head',
lazy='dynamic'))
group = db.relationship('Group',
backref=db.backref('group_head',
lazy='dynamic'))
class Group(SurrogateBaseKey, Model):
"""User Group"""
__tablename__ = 'groups'
name = Column(db.String(20), unique=True, nullable=False)
users = relationship(
'User', secondary=GROUPS_USERS, lazy='subquery',
backref=db.backref('groups', lazy=True))
permissions = relationship(
'Permission', secondary=GROUPS_PERMISSIONS, lazy='subquery',
backref=db.backref('groups', lazy=True))
def __repr__(self):
return '<Group %r>' % self.name
class Question(BaseModel):
__tablename__ = 'question'
number = db.Column(db.Integer, comment='题号')
total_question_score = db.Column(db.Integer, comment='考题总分')
subject_id = db.Column(db.Integer, db.ForeignKey('subject.id'),
comment='题目id')
subject = db.relationship('Subject',
backref=db.backref('question',
lazy='dynamic'))
paper_id = db.Column(db.Integer, db.ForeignKey('paper.id'),
comment='考卷id')
paper = db.relationship('Paper',
backref=db.backref('questions',
lazy='dynamic', order_by=number))
class Paper(BaseModel):
__tablename__ = 'paper'
name = db.Column(db.String(255), comment='考试名称')
total_paper_score = db.Column(db.Integer, comment='考卷总分')
exam_time = db.Column(db.Integer, comment='考试时间（分钟）')
remainder_time = db.Column(db.Integer, comment='剩余时间（分钟）')
head_id = db.Column(db.Integer, db.ForeignKey('head.id'),
comment='标题')
head = db.relationship('Head',
backref=db.backref('papers',
lazy='dynamic'))
status = db.Column(db.String(255), comment='状态', default='new')
users = db.relationship('User', secondary=users_papers,
backref=db.backref('papers', lazy='dynamic'))
class PaperQuestion(BaseModel):
__tablename__ = 'paper_question'
question_score = db.Column(db.Integer, comment='考题得分', default=0)
user_paper_id = db.Column(db.Integer, db.ForeignKey('user_paper.id'),
comment='用户的考卷')
user_answer = db.Column(db.Text, comment='用户答案')
user_paper = db.relationship('UserPaper',
backref=db.backref('paper_questions',
lazy='dynamic'))
question_id = db.Column(db.Integer, db.ForeignKey('question.id'),
comment='关联的考题')
question = db.relationship('Question',
backref=db.backref('paper_questions',
lazy='dynamic'))
status = db.Column(db.String(255), comment='状态', default='uncommitted')
class User(db.Model, UserMixin):
"""
User model
Arguments:
id (int): Primary User Key
username (str): Unique username as chosen by the user
email (str): User's email address
password_hash (str): Users hashed password
"""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), 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 __repr__(self):
return '<User %r>' % self.username
def __str(self):
return self.username
class VSRole(CRUDMixin, db.Model):
"""
角色模型
"""
__tablename__ = 'tbl_vsppm_role'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# 角色名称
name = db.Column(db.String(128), nullable=False, unique=True)
# 角色描述
role = db.Column(db.String(128), nullable=False)
# 创建时间
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 更新时间
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 激活状态
active = db.Column(db.Boolean(), default=True)
# 让VSRole和VSAcl产生关联
# 因为VSAcl和VSRole表中间还有一个vsppm_user_role表,所以添加secondary
# 正向引用是VSRole访问VSAcl,反向引用是从VSAcl访问表VSRole
acls = db.relationship('VSAcl',
secondary=vsppm_role_acl,
backref=db.backref('roles'))
def __init__(self, **kwargs):
super(VSRole, self).__init__(**kwargs)
def __repr__(self):
return '<VSRole #%s:%r>' % (self.id, self.name)
class User(BaseModel, db.Model, UserMixin):
__tablename__ = 'user'
phone = db.Column(db.String(32), unique=True)
password = db.Column(db.String(48))
chinese_name = db.Column(db.String(20))
english_name = db.Column(db.String(20))
photo_path = db.Column(db.String(255))
update_time = db.Column(db.DateTime, default=datetime.now)
create_time = db.Column(db.DateTime, default=datetime.now)
coursetb_update_time = db.Column(db.DateTime, default=datetime.now)
verify_token = db.Column(db.String(32), default='')
status = db.Column(db.String(10))
roles = db.relationship('Role', secondary=role_user_relationship,
backref=db.backref('users', lazy='dynamic'))
teacher = db.relationship('TeacherInfo', backref='user', uselist=False,
cascade="all, delete-orphan")
student = db.relationship('StudentInfo', backref='user', uselist=False,
cascade="all, delete-orphan")
def __init__(self, chinese_name='', englisth_name='', phone='', password=''):
self.chinese_name = chinese_name
self.english_name = englisth_name
self.phone = phone
self.password = password
self.photo_path = ''
self.status = 'enabled'
@property
def is_active(self):
return True
def get_id(self):
return self.id
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(140))
announce = db.Column(db.Text)
description = db.Column(db.Text)
created = db.Column(db.DateTime, default=datetime.now())
pub_date = db.Column(db.DateTime, nullable=True, default=datetime.now())
published = db.Column(db.Boolean, default=False)
is_draft = db.Column(db.Boolean, default=True)
tags = db.relationship('Tag',
secondary=post_tags,
backref=db.backref('posts', lazy='dynamic'))
attachments = db.relationship('Attachment',
cascade='all, delete-orphan',
backref='post')
def get_imgurls(self):
pattern = re.compile(r'src\s*=\s*"(.+?)"')
urls = re.findall(pattern, self.description)
return [op.join(basedir, url[1:]) for url in urls]
def assemble_text(self):
pattern = re.compile(r'<.*?>')
message = re.sub(pattern, '', self.description)
tags = ' '.join(['#' + x.title.replace(' ', '_') for x in self.tags])
return '{}\n{}\n{}'.format(self.title, message, tags)
def __init__(self, *args, **kwargs):
super(Post, self).__init__(*args, **kwargs)
def __repr__(self):
return self.title
class Post(db.Model):
__tablename__ = 'post'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(150))
slug = db.Column(db.String(140), unique=True)
pre_body = db.Column(db.Text)
body = db.Column(db.Text)
created = db.Column(db.DateTime, index=True, default=datetime.utcnow)
updated = db.Column(db.DateTime)
count = db.Column(db.Integer, default=0)
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
tags = db.relationship('Tag',
secondary='tags_posts',
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 + str(datetime.utcnow()))
def __str__(sefl):
return '<{}>-{}'.format(sefl.id, sefl.title)
class Alert(BaseModel):
created_on = db.Column(db.DateTime, default=datetime.utcnow)
from_date = db.Column(db.Date)
to_date = db.Column(db.Date)
flagged_committee_contributions = db.Column(db.Numeric(18, 2))
flagged_individual_contributions = db.Column(db.Numeric(18, 2))
candidate_id = db.Column(db.Integer, db.ForeignKey("candidate.id"), nullable=False)
candidate = db.relationship("Candidate", backref=db.backref("alerts", lazy=True))
class Keyword(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', backref=db.backref('keywords', lazy=True))
def __repr__(self):
return '<Keyword %r>' % self.name
class IndividualContribution(BaseContribution):
committee_id = db.Column(
db.Integer, db.ForeignKey("committee.id"), nullable=False, index=True
)
committee = db.relationship(
"Committee", backref=db.backref("individual_contributions", lazy=True)
)
contributor_id = db.Column(
db.Integer, db.ForeignKey("individual_contributor.id"), nullable=False
)
contributor = db.relationship(
"IndividualContributor",
backref=db.backref("individual_contributions", lazy=True),
)
committee_fec_id = db.Column(db.String(9))
other_fec_id = db.Column(db.String(9))
fec_unique_id = db.Column(db.Numeric(19), unique=True, nullable=False)
class Attachments(db.Model, At, By):
__tablename__ = "Attachments"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
path = db.Column(db.String(100))
task_id = db.Column(db.Integer, db.ForeignKey('Task.id'))
task = db.relationship('Task',
backref=db.backref('attachments', lazy='dynamic'))
class UserHead(BaseModel):
__tablename__ = 'user_head'
total_user_score = db.Column(db.Integer, comment='用户总得分', default=0)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'),
comment='用户')
user = db.relationship('User',
backref=db.backref('user_head',
lazy='dynamic'))
head_id = db.Column(db.Integer, db.ForeignKey('head.id'),
comment='标题')
head = db.relationship('Head',
backref=db.backref('user_head',
lazy='dynamic'))
group_head_id = db.Column(db.Integer, db.ForeignKey('group_head.id'),
comment='组标题id')
group_head = db.relationship('GroupHead',
backref=db.backref('user_heads',
lazy='dynamic'))
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60))
news_api_id = db.Column(db.String(60))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', backref=db.backref('categories', lazy=True))
def __repr__(self):
return '<Category %r>' % self.name
class UserPaper(BaseModel):
__tablename__ = 'user_paper'
user_score = db.Column(db.Integer, comment='考卷得分', default=0)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'),
comment='用户')
user = db.relationship('User',
backref=db.backref('user_paper',
lazy='dynamic'))
paper_id = db.Column(db.Integer, db.ForeignKey('paper.id'),
comment='考卷id')
paper = db.relationship('Paper',
backref=db.backref('user_paper',
lazy='dynamic'))
user_head_id = db.Column(db.Integer, db.ForeignKey('user_head.id'),
comment='用户标题id')
user_head = db.relationship('UserHead',
backref=db.backref('user_papers',
lazy='dynamic'))
class FlaggedEmployerMatchingRule(BaseModel):
employer = db.Column(db.String)
city = db.Column(db.String)
state = db.Column(db.String)
flagged_employer_id = db.Column(
db.Integer, db.ForeignKey("flagged_employer.id"), nullable=False
)
flagged_employer = db.relationship(
"FlaggedEmployer", backref=db.backref("matching_rules")
)
class Words(db.Model):
__tablename__ = 'words'
__table_args__ = (
db.UniqueConstraint("view_id", "word"),
)
id = db.Column(db.Integer, primary_key=True)
word = db.Column(db.String(255), nullable=False)
translation = db.Column(db.String(255), nullable=False)
url = db.Column(db.String(511), nullable=False)
created_on = db.Column(db.DateTime(), default=datetime.utcnow)
category_id = db.Column(db.Integer, db.ForeignKey('category.id', ondelete='CASCADE'), nullable=False)
category = db.relationship('Category', backref=db.backref('words', lazy=True))
view_id = db.Column(db.Integer, db.ForeignKey('view.id', ondelete='CASCADE'), nullable=False)
view = db.relationship('View', backref=db.backref('views', lazy=True))
def __repr__(self):
return '<Words %r>' % self.word
class UserProfile(Model, SurrogatePK):
__tablename__ = 'userprofile'
# id is needed for primary join, it does work with SurrogatePK class
id = db.Column(db.Integer, primary_key=True)
user_id = reference_col('users', nullable=False)
user = relationship('User', backref=db.backref('profile', uselist=False))
follows = relationship('UserProfile',
secondary=followers_assoc,
primaryjoin=id == followers_assoc.c.follower,
secondaryjoin=id == followers_assoc.c.followed_by,
backref='followed_by',
lazy='dynamic')
def __init__(self, user, **kwargs):
db.Model.__init__(self, user=user, **kwargs)
def is_following(self, profile):
return bool(self.follows.filter(followers_assoc.c.followed_by == profile.id).count())
def follow(self, profile):
if self is not profile and not self.is_following(profile):
self.follows.append(profile)
return True
return False
def unfollow(self, profile):
if self is not profile and self.is_following(profile):
self.follows.remove(profile)
return True
return False
@property
def following(self):
if current_user:
return current_user.profile.is_following(self)
return False
@property
def username(self):
return self.user.username
@property
def bio(self):
return self.user.bio
@property
def image(self):
return self.user.image
@property
def email(self):
return self.user.email
class User(BaseModel, UserMixin):
__tablename__ = 'user'
username = db.Column(db.String(255), unique=True, index=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean(), index=True)
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(63))
current_login_ip = db.Column(db.String(63))
login_count = db.Column(db.Integer)
groups = db.relationship('Group',
secondary=groups_users,
backref=db.backref('users', lazy='dynamic'))
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return '<User %r>' % self.username
class Auth(db.Model):
__tablename__ = 'auths'
id = db.Column('id', db.String(64), primary_key=True)
token = db.Column('token', db.String(255), index=True, unique=True)
email = db.Column('email', db.ForeignKey(User.email), index=True, nullable=False)
created_at = db.Column('created_at', db.DATETIME, default=datetime.now, nullable=False)
user = db.relationship("User", backref=db.backref("auth_user", uselist=False), lazy='joined')
def __repr__(self):
return "<Auth '{}'>".format(self.id)
class User(db.Model, UserMixin):
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def get_id(self):
return self.id
def get_urole(self):
return self.role
class Sample(db.Model):
"""
Sample model
Arguments:
id (int): Primary Sample key
sensor_id (int): Foreign ``Sensor``.id key
sensor: ``Sensor`` object related to this sample
datetime (datetime): ``datetime`` object of this sample (should in UTC)
value (float): Value of sample
"""
__tablename__ = 'samples'
id = db.Column(db.Integer, primary_key=True)
sensor_id = db.Column(db.Integer, db.ForeignKey('sensors.id'), index=True)
sensor = db.relationship('Sensor', backref=db.backref('samples'))
datetime = db.Column(db.DateTime, index=True)
value = db.Column(db.Float)
def to_json(self):
"""
Creates a JSON object from Sample. Used where multiple samples will be
displayed at once.
"""
json_sample = {
'id': self.id,
'sensor': self.sensor.to_sample_json(),
'value': self.value,
'datetime': self.datetime,
'url': url_for('api.get_sample', sid=self.id, _external=True)
}
return json_sample
def to_sensor_json(self):
"""
Creates a JSON object from Sample for used with Sensor JSON.
"""
json_sample = {
'id': self.id,
'value': self.value,
'datetime': str(self.datetime),
'url': url_for('api.get_sample', sid=self.id, _external=True)
}
return json_sample
def __repr__(self):
return '<Sample %r>' % self.id
class Product(db.Model):
__tablename__ = 'products'
id = db.Column(db.Integer, primary_key=True)
full_name = db.Column(db.String(255), nullable=False)
short_name = db.Column(db.String(255), nullable=False)
raw_description = db.Column(db.Text, nullable=False)
img = db.Column(db.String(255), nullable=True)
price = db.Column(db.String(25), nullable=False)
color = db.Column(db.String(255), nullable=True)
review_number = db.Column(db.Integer, nullable=True)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'), nullable=False)
category = db.relationship('Category', backref=db.backref('product', lazy=True))
def __str__(self):
return self.short_name
class Comment(Model, SurrogatePK):
__tablename__ = 'comment'
id = db.Column(db.Integer, primary_key=True)
body = Column(db.Text)
createdAt = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
updatedAt = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
author_id = reference_col('userprofile', nullable=False)
author = relationship('UserProfile', backref=db.backref('comments'))
article_id = reference_col('article', nullable=False)
def __init__(self, article, author, body, **kwargs):
db.Model.__init__(self,
author=author,
body=body,
article=article,
**kwargs)
