class PanelPermission(db.Model):
"""Super-Admin Panel Permissions
"""
__tablename__ = 'panel_permissions'
id = db.Column(db.Integer, primary_key=True)
# Super Admin panel name
panel_name = db.Column(db.String)
# Custom System Role
custom_system_roles = db.relationship(
'CustomSysRole',
secondary=roles_panels,
backref=db.backref('panel_permissions', lazy='dynamic'),
)
can_access = db.Column(db.Boolean, default=True)
def __repr__(self):
return '<PanelPerm {!r} for {!r}>'.format(self.custom_system_roles,
self.panel_name)
class User(UserMixin, db.Model):
"""Implements the User model."""
username = db.Column(db.String(32), unique=True)
password = db.Column(db.String(128))
chinese_name = db.Column(db.String(32))
email = db.Column(db.String(32))
is_admin = db.Column(db.Boolean, default=False)
active = db.Column(db.Boolean(), default=True)
my_groups = db.relationship('Group', backref='user', lazy='dynamic')
groups = db.relationship('Group',
secondary=user_group,
backref=db.backref('users', lazy='dynamic'))
def __init__(self, username, chinese_name=None):
"""
:param username: Username for the user
:param name: Name of the user
"""
super(User, self).__init__()
self.username = username
self.chinese_name = chinese_name
if not chinese_name:
self.chinese_name = username
def set_password(self, plaintext, rounds=12):
password_hash = generate_password_hash(plaintext, rounds)
self.password = password_hash
def check_password(self, plaintext):
return check_password_hash(self.password, plaintext)
def is_active(self):
return True
def is_authenticated(self):
return True
def is_anonymous(self):
return False
class PostModel(db.Model):
__tablename__ = 'post'
__table_args__ = {'schema': cfg_db_schema}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), nullable=False)
body = db.Column(db.Text, nullable=False)
post_type_id = db.Column(db.Integer,
db.ForeignKey(cfg_db_schema + '.post_type.id'),
nullable=False,
default=1)
user_id = db.Column(db.Integer,
db.ForeignKey(cfg_db_schema + '.users.id'),
nullable=False)
user = db.relationship("UserModel",
backref=db.backref("posts", lazy="dynamic"))
# platforms = db.relationship('PlatformModel', secondary=post_platform, backref='platform_posts')
platform = db.relationship('PostPlatformModel', back_populates='post')
md5 = db.Column(db.Text, nullable=False, index=True, unique=True)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
modified_at = db.Column(db.DateTime, default=datetime.utcnow)
def __repr__(self):
return "<Post %r>" % (self.id)
class Patient(db.Model):
__tablename__ = 'patients'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.Unicode)
last_name = db.Column(db.Unicode)
address = db.Column(db.Unicode)
email = db.Column(db.String)
phone = db.Column(db.String)
job = db.Column(db.String)
social_number = db.Column(db.String, unique=True)
latest_admission = db.Column(db.DateTime)
latest_medical_exam = db.Column(db.DateTime)
diseases = db.relationship('CaughtDisease')
id_assigned_user = db.Column(
db.Integer, db.ForeignKey(User.id, name="fk_assigned_user_id"))
assigned_user = db.relationship('User',
lazy='joined',
backref=db.backref('patients', lazy=True))
@property
def full_name(self):
return '{} {}'.format(self.first_name, self.last_name)
def assign(self, user):
if self.id_assigned_user is None:
self.id_assigned_user = user.id
print("Inform {} he is now taking care of {}".format(
user.full_name, self.full_name))
return True
return False
def unassign(self):
print("Inform {} he is no longer taking care of {}".format(
self.assigned_user.full_name, self.full_name))
self.id_assigned_user = None
class Session(db.Model):
"""Session model class"""
__tablename__ = 'session'
__versioned__ = {
'exclude': []
}
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String, nullable=False)
subtitle = db.Column(db.String)
short_abstract = db.Column(db.Text)
long_abstract = db.Column(db.Text)
comments = db.Column(db.Text)
start_time = db.Column(db.DateTime, nullable=False)
end_time = db.Column(db.DateTime, nullable=False)
track_id = db.Column(db.Integer, db.ForeignKey('tracks.id', ondelete='CASCADE'))
speakers = db.relationship(
'Speaker',
secondary=speakers_sessions,
backref=db.backref('sessions', lazy='dynamic'))
language = db.Column(db.String)
microlocation_id = db.Column(db.Integer, db.ForeignKey('microlocation.id', ondelete='CASCADE'))
session_type_id = db.Column(db.Integer, db.ForeignKey('session_type.id', ondelete='CASCADE'))
level = db.Column(db.String)
slides = db.Column(db.String)
video = db.Column(db.String)
audio = db.Column(db.String)
signup_url = db.Column(db.String)
event_id = db.Column(
db.Integer, db.ForeignKey('events.id', ondelete='CASCADE'))
state = db.Column(db.String, default="pending")
in_trash = db.Column(db.Boolean, default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
trash_date = db.Column(db.DateTime)
submission_date = db.Column(db.DateTime)
submission_modifier = db.Column(db.String)
state_email_sent = db.Column(db.Boolean, default=False)
def __init__(self,
title=None,
subtitle=None,
short_abstract='',
long_abstract='',
comments=None,
start_time=None,
end_time=None,
track=None,
language=None,
microlocation=None,
speakers=None,
event_id=None,
state="pending",
slides=None,
video=None,
audio=None,
signup_url=None,
session_type=None,
level=None,
created_at=None,
state_email_sent=False,
in_trash=False,
trash_date=None):
if speakers is None:
speakers = []
self.title = title
self.subtitle = subtitle
self.short_abstract = short_abstract
self.long_abstract = long_abstract
self.comments = comments
self.start_time = start_time
self.end_time = end_time
self.track = track
self.language = language
self.microlocation = microlocation
self.speakers = speakers
self.event_id = event_id
self.state = state
self.slides = slides
self.video = video
self.audio = audio
self.signup_url = signup_url
self.session_type = session_type
self.level = level
self.created_at = created_at
self.in_trash = in_trash
self.trash_date = trash_date
self.state_email_sent = state_email_sent
@staticmethod
def get_service_name():
return 'session'
@property
def is_accepted(self):
return self.state == "accepted"
@property
def serialize(self):
"""Return object data in easily serializeable format"""
return {
'id': self.id,
'title': self.title,
'subtitle': self.subtitle,
'short_abstract': self.short_abstract,
'long_abstract': self.long_abstract,
'comments': self.comments,
'begin': DateFormatter().format_date(self.start_time),
'end': DateFormatter().format_date(self.end_time),
'track': self.track.id if self.track else None,
'speakers': [
{'id': speaker.id,
'name': speaker.name} for speaker in self.speakers
],
'level': self.level,
'microlocation': self.microlocation.id
if self.microlocation else None
}
def __repr__(self):
return '<Session %r>' % self.title
def __str__(self):
return unicode(self).encode('utf-8')
def __setattr__(self, name, value):
if name == 'short_abstract' or name == 'long_abstract' or name == 'comments':
super(Session, self).__setattr__(name, clean_html(clean_up_string(value)))
else:
super(Session, self).__setattr__(name, value)
def __unicode__(self):
return self.title
class Session(SoftDeletionModel):
"""Session model class"""
class State:
PENDING = 'pending'
ACCEPTED = 'accepted'
CONFIRMED = 'confirmed'
REJECTED = 'rejected'
__tablename__ = 'sessions'
__table_args__ = (
db.Index('session_event_idx', 'event_id'),
db.Index('session_state_idx', 'state'),
)
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String, nullable=False)
subtitle = db.Column(db.String)
website = db.Column(db.String)
twitter = db.Column(db.String)
facebook = db.Column(db.String)
github = db.Column(db.String)
linkedin = db.Column(db.String)
instagram = db.Column(db.String)
gitlab = db.Column(db.String)
mastodon = db.Column(db.String)
short_abstract = db.Column(db.Text, default='')
long_abstract = db.Column(db.Text, default='')
comments = db.Column(db.Text)
language = db.Column(db.String)
level = db.Column(db.String)
starts_at = db.Column(db.DateTime(timezone=True))
ends_at = db.Column(db.DateTime(timezone=True))
track_id = db.Column(db.Integer, db.ForeignKey('tracks.id', ondelete='CASCADE'))
microlocation_id = db.Column(
db.Integer, db.ForeignKey('microlocations.id', ondelete='CASCADE')
)
session_type_id = db.Column(
db.Integer, db.ForeignKey('session_types.id', ondelete='CASCADE')
)
speakers = db.relationship(
'Speaker',
secondary=speakers_sessions,
backref=db.backref('sessions', lazy='dynamic'),
)
feedbacks = db.relationship('Feedback', backref="session")
slides_url = db.Column(db.String)
slides = db.Column(db.JSON)
video_url = db.Column(db.String)
audio_url = db.Column(db.String)
signup_url = db.Column(db.String)
event_id = db.Column(db.Integer, db.ForeignKey('events.id', ondelete='CASCADE'))
creator_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete='CASCADE'))
creator = db.relationship('User')
state = db.Column(db.String, default="pending")
created_at = db.Column(db.DateTime(timezone=True), default=sql_func.now())
submitted_at = db.Column(db.DateTime(timezone=True))
submission_modifier = db.Column(db.String)
is_mail_sent = db.Column(db.Boolean, default=False)
last_modified_at = db.Column(db.DateTime(timezone=True), default=func.now())
send_email = db.Column(db.Boolean, nullable=True)
is_locked = db.Column(db.Boolean, default=False, nullable=False)
complex_field_values = db.Column(db.JSON)
@staticmethod
def get_service_name():
return 'session'
@property
def is_accepted(self):
return self.state == "accepted"
@property
def organizer_site_link(self):
return self.event.organizer_site_link + f"/session/{self.id}"
@aggregated(
'feedbacks', db.Column(db.Float, default=0, server_default='0', nullable=False)
)
def average_rating(self):
return func.coalesce(func.avg(Feedback.rating), 0)
@aggregated(
'feedbacks', db.Column(db.Integer, default=0, server_default='0', nullable=False)
)
def rating_count(self):
return func.count('1')
@aggregated(
'favourites', db.Column(db.Integer, default=0, server_default='0', nullable=False)
)
def favourite_count(self):
return func.count('1')
@property
def favourite(self):
if not current_user:
return None
return UserFavouriteSession.query.filter_by(
user=current_user, session=self
).first()
@property
def site_link(self):
return self.event.site_link + f"/session/{self.id}"
@property
def site_cfs_link(self):
return self.event.site_link + "/cfs"
def __repr__(self):
return '<Session %r>' % self.title
def __setattr__(self, name, value):
if name == 'short_abstract' or name == 'long_abstract' or name == 'comments':
super().__setattr__(name, clean_html(clean_up_string(value), allow_link=True))
else:
super().__setattr__(name, value)
class Session(SoftDeletionModel):
"""Session model class"""
__tablename__ = 'sessions'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String, nullable=False)
subtitle = db.Column(db.String)
short_abstract = db.Column(db.Text, default='')
long_abstract = db.Column(db.Text, default='')
comments = db.Column(db.Text)
language = db.Column(db.String)
level = db.Column(db.String)
starts_at = db.Column(db.DateTime(timezone=True))
ends_at = db.Column(db.DateTime(timezone=True))
track_id = db.Column(db.Integer,
db.ForeignKey('tracks.id', ondelete='CASCADE'))
microlocation_id = db.Column(
db.Integer, db.ForeignKey('microlocations.id', ondelete='CASCADE'))
session_type_id = db.Column(
db.Integer, db.ForeignKey('session_types.id', ondelete='CASCADE'))
speakers = db.relationship(
'Speaker',
secondary=speakers_sessions,
backref=db.backref('sessions', lazy='dynamic'),
)
feedbacks = db.relationship('Feedback', backref="session")
slides_url = db.Column(db.String)
video_url = db.Column(db.String)
audio_url = db.Column(db.String)
signup_url = db.Column(db.String)
event_id = db.Column(db.Integer,
db.ForeignKey('events.id', ondelete='CASCADE'))
creator_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'))
state = db.Column(db.String, default="pending")
created_at = db.Column(db.DateTime(timezone=True), default=sql_func.now())
submitted_at = db.Column(db.DateTime(timezone=True))
submission_modifier = db.Column(db.String)
is_mail_sent = db.Column(db.Boolean, default=False)
last_modified_at = db.Column(db.DateTime(timezone=True),
default=func.now())
send_email = db.Column(db.Boolean, nullable=True)
is_locked = db.Column(db.Boolean, default=False, nullable=False)
complex_field_values = db.Column(db.JSON)
@staticmethod
def get_service_name():
return 'session'
@property
def is_accepted(self):
return self.state == "accepted"
def get_average_rating(self):
avg = (db.session.query(func.avg(
Feedback.rating)).filter_by(session_id=self.id).scalar())
if avg is not None:
avg = round(avg, 2)
return avg
@property
def average_rating(self):
return self.get_average_rating()
@property
def site_link(self):
return self.event.site_link + f"/session/{self.id}"
def __repr__(self):
return '<Session %r>' % self.title
def __setattr__(self, name, value):
if name == 'short_abstract' or name == 'long_abstract' or name == 'comments':
super().__setattr__(name, clean_html(clean_up_string(value)))
else:
super().__setattr__(name, value)
class Session(SoftDeletionModel):
"""Session model class"""
__tablename__ = 'sessions'
__versioned__ = {'exclude': []}
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String, nullable=False)
subtitle = db.Column(db.String)
short_abstract = db.Column(db.Text)
long_abstract = db.Column(db.Text)
comments = db.Column(db.Text)
language = db.Column(db.String)
level = db.Column(db.String)
starts_at = db.Column(db.DateTime(timezone=True))
ends_at = db.Column(db.DateTime(timezone=True))
track_id = db.Column(db.Integer,
db.ForeignKey('tracks.id', ondelete='CASCADE'))
microlocation_id = db.Column(
db.Integer, db.ForeignKey('microlocations.id', ondelete='CASCADE'))
session_type_id = db.Column(
db.Integer, db.ForeignKey('session_types.id', ondelete='CASCADE'))
speakers = db.relationship('Speaker',
secondary=speakers_sessions,
backref=db.backref('sessions', lazy='dynamic'))
feedbacks = db.relationship('Feedback', backref="session")
slides_url = db.Column(db.String)
video_url = db.Column(db.String)
audio_url = db.Column(db.String)
signup_url = db.Column(db.String)
event_id = db.Column(db.Integer,
db.ForeignKey('events.id', ondelete='CASCADE'))
creator_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'))
state = db.Column(db.String, default="pending")
created_at = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
submitted_at = db.Column(db.DateTime(timezone=True))
submission_modifier = db.Column(db.String)
is_mail_sent = db.Column(db.Boolean, default=False)
last_modified_at = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
send_email = db.Column(db.Boolean, nullable=True)
def __init__(self,
title=None,
subtitle=None,
short_abstract='',
long_abstract='',
comments=None,
starts_at=None,
ends_at=None,
track_id=None,
language=None,
microlocation_id=None,
speakers=None,
event_id=None,
creator_id=None,
state="pending",
slides_url=None,
video_url=None,
audio_url=None,
signup_url=None,
session_type_id=None,
level=None,
created_at=None,
submission_modifier=None,
is_mail_sent=False,
deleted_at=None,
submitted_at=None,
last_modified_at=None,
send_email=None):
if speakers is None:
speakers = []
self.title = title
self.subtitle = subtitle
self.short_abstract = short_abstract
self.long_abstract = long_abstract
self.comments = comments
self.starts_at = starts_at
self.ends_at = ends_at
self.track_id = track_id
self.language = language
self.microlocation_id = microlocation_id
self.speakers = speakers
self.event_id = event_id
self.creator_id = creator_id
self.state = state
self.slides_url = slides_url
self.video_url = video_url
self.audio_url = audio_url
self.signup_url = signup_url
self.session_type_id = session_type_id
self.level = level
self.created_at = created_at
self.deleted_at = deleted_at
self.is_mail_sent = is_mail_sent
self.submitted_at = submitted_at
self.submission_modifier = submission_modifier
self.last_modified_at = datetime.datetime.now(pytz.utc)
self.send_email = send_email
@staticmethod
def get_service_name():
return 'session'
@property
def is_accepted(self):
return self.state == "accepted"
def get_average_rating(self):
avg = db.session.query(func.avg(
Feedback.rating)).filter_by(session_id=self.id).scalar()
if avg is not None:
avg = round(avg, 2)
return avg
@property
def average_rating(self):
return self.get_average_rating()
def __repr__(self):
return '<Session %r>' % self.title
def __str__(self):
return self.__repr__()
def __setattr__(self, name, value):
if name == 'short_abstract' or name == 'long_abstract' or name == 'comments':
super(Session,
self).__setattr__(name, clean_html(clean_up_string(value)))
else:
super(Session, self).__setattr__(name, value)
class Student(db.Model):
__tablename__ = "students"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(255))
last_name = db.Column(db.Unicode(255))
age = db.Column(db.Integer)
email = db.Column(db.Unicode(50), unique=True)
skills = db.relationship("Skill",
secondary=student_skills,
backref=db.backref("students", lazy="dynamic"))
def __repr__(self):
return "{}, {}".format(self.name, self.email)
@property
def _student_skills_as_set(self):
"""
returns student skills as set to work with it
"""
return set([skill.id for skill in self.skills])
def matching_companies(self):
"""
Returns a list of matching companiesordered by relevance
"""
student_skills = self._student_skills_as_set
companies = db.session.query(Company).all()
print companies
matching_companies = []
for company in companies:
company_skills = set([skill.id for skill in company.skills])
match_skills = [skill for skill in student_skills & company_skills]
other_skills = [skill for skill in company_skills - student_skills]
if len(match_skills) > 0:
# Model lists
match_skills_obj = [
db.session.query(Skill).get(skill)
for skill in match_skills
]
other_skills_obj = [
db.session.query(Skill).get(skill)
for skill in other_skills
]
match = {
"model": company,
"matches": len(match_skills),
"skills": match_skills_obj,
"other_skills": other_skills_obj
}
matching_companies.append(match)
# sort the list by matches, most matches first
from operator import itemgetter
sorted_matching_companies = sorted(matching_companies,
key=itemgetter('matches'),
reverse=True)
return sorted_matching_companies
class Fragment(db.Model):
'''知识碎片'''
__tablename__ = 'fragment'
__table_args__ = {"mysql_engine": "InnoDB", "mysql_charset": "utf8"}
id = db.Column(db.Integer,
nullable=False,
primary_key=True,
autoincrement=True)
title = db.Column(db.String(255), nullable=False, default="", index=True)
access = db.Column(db.Integer, nullable=False, default=1)
status = db.Column(db.Integer, nullable=False, default=0)
markdown = db.deferred(db.Column(LONGTEXT, default="", nullable=False))
html = db.deferred(db.Column(LONGTEXT, default="", nullable=False))
publish_markdown = db.deferred(
db.Column(LONGTEXT, default="", nullable=False))
publish_html = db.deferred(db.Column(LONGTEXT, default="", nullable=False))
publish_timestamp = db.Column(db.DateTime,
default=datetime.now,
nullable=False)
updatetime = db.Column(db.DateTime, default=datetime.now, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
tags = db.relationship('Tag',
secondary=fragment_tags_table,
backref=db.backref('fragments'))
# branch = db.relationship('Branch',back_populates='fragment',uselist=False)
branch_id = db.Column(db.Integer, db.ForeignKey('branch.id'))
# branch = db.relationship('Branch',foreign_keys=branch_id)
def get(self, id):
return Fragment.query.get(id)
@staticmethod
def get_or_404(id):
fragment = Fragment.query.get(id)
if fragment:
return fragment
abort(404)
def save(self):
self.html = self.markdown2html(self.markdown)
db.session.add(self)
db.session.commit()
search_helper.add_document(self.title, str(self.id), self.markdown)
def markdown2html(self, content):
# md = Markdown(['codehilite', 'fenced_code', 'meta', 'tables'])
# html = md.convert(content)
html = markdown(content,
extensions=[
'markdown.extensions.extra',
'markdown.extensions.codehilite',
'markdown.extensions.toc',
])
return html
@staticmethod
def get_nearest_fragments(num=5):
fragments = Fragment.query.filter().order_by(
Fragment.updatetime.desc()).limit(num)
res = []
from app.models.branch import Branch
for fragment in fragments:
fragment.branch = Branch.get(fragment.branch_id)
res.append(fragment)
return res
class User( DogearMixin,db.Model):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
username = Column(String, unique=True)
password = Column(String)
email = Column(String, unique=True)
about = Column(Text)
geolocation = Column(String)
news = db.relationship('News', backref='user', lazy='dynamic')
groups = db.relationship('Group', backref='user', lazy='dynamic')
followed = db.relationship(
'User', secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'), lazy='dynamic')
@hybrid_property #placeholder
def avatar(self,size=128):
digest = hashlib.md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(digest, size)
def __init__(self, email=email, username="", password=""):
self.uuid = str(uuid.uuid4())
self.email = email
if username=="":
self.username=self.email
else:
self.username = username
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def user_news_feed(self):
followed = News.query.join(
followers, (followers.c.followed_id == News.user_id)).filter(
followers.c.follower_id == self.id)
own = News.query.filter_by(user_id=self.id)
return followed.union(own).order_by(News.created_at.desc())
def encode_auth_token(self):
"""
Generates the Auth Token
:return: string
"""
try:
payload = {
'exp': datetime.datetime.utcnow() + datetime.timedelta(days=5, seconds=5),
'iat': datetime.datetime.utcnow(),
'sub': self.uuid
}
return jwt.encode(
payload,
app.config["SECRET_KEY"],
algorithm='HS256'
)
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
"""
Decodes the auth token
:param auth_token:
:return: integer|string
"""
try:
payload = jwt.decode(auth_token, app.config["SECRET_KEY"],algorithms='HS256')
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
def set_password(self, password):
if not password:
raise AssertionError('Hey hey, you need a password is required to sign up')
# if not re.match('\d.*[A-Z]|[A-Z].*\d', password):
# raise AssertionError('Password must contain 1 capital letter and 1 number')
if len(password) < 6 or len(password) > 50:
raise AssertionError('For super secrecy, your password must be between 6 and 50 characters')
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
@validates("username")
def validate_username(self, key, username):
if len(username) < 4:
raise AssertionError('Your username must be more than 4 characters')
#check for unique please
name_exists = User.query.filter(User.username==username).count()
if name_exists > 0 :
raise AssertionError('Boo...someone already has that username. Try again?')
return username
@validates('email')
def validate_email(self, key, email):
if not email:
raise AssertionError('I think you forgot to enter your email?')
if not re.match("[^@]+@[^@]+\.[^@]+", email):
raise AssertionError('Can you double check your email address? Seems funny.')
return email