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