class CourseReview(BaseModel):
__tablename__ = 'course_reviews'
course_id = db.Column(db.Integer, db.ForeignKey('courses.id'))
body = db.Column(db.TEXT)
course = db.relationship('Course', backref=db.backref('reviews'))
class PollItem(PollItemJsonSerializer, db.Model):
"""PollItem model
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
poll_id = db.Column(db.Integer, db.ForeignKey('poll.id'), nullable=False)
description = db.Column(db.Text)
class CourseRating(BaseModel):
__tablename__ = 'course_ratings'
course_id = db.Column(db.Integer, db.ForeignKey('courses.id'))
reaction = db.Column(db.Boolean)
course = db.relationship('Course', backref=db.backref('ratings'))
class User(UserJsonSerializer, db.Model, UserMixin):
"""User model"""
# __searchable__ = ['email']
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
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(100))
current_login_ip = db.Column(db.String(100))
login_count = db.Column(db.Integer)
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
connections = db.relationship('Connection',
lazy='dynamic',
backref=db.backref('user'),
cascade="all")
following = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.following_id == id),
backref=db.backref('followers',
lazy='dynamic'),
lazy='dynamic')
class CourseContent(BaseModel):
__tablename__ = 'course_contents'
course_id = db.Column(db.Integer, db.ForeignKey('courses.id'))
image = db.Column(db.TEXT)
video = db.Column(db.TEXT)
body = db.Column(db.TEXT)
class Poll(PollJsonSerializer, db.Model):
"""Poll model
"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
status = db.Column(db.SmallInteger, default=0)
created_at = db.Column(db.DateTime, default=datetime.datetime.now)
completed_at = db.Column(db.DateTime)
class JobApplication(BaseModel, HasUID, HasCreator, HasBloc):
__tablename__ = 'job_applications'
cv = db.Column(db.String(1024))
job_id = db.Column(db.Integer, db.ForeignKey('jobs.id'))
job = db.relationship('Job',
backref=db.backref('job_applications', uselist=True),
uselist=False)
class CourseClassAttendance(BaseModel):
__tablename__ = 'course_class_attendance'
course_id = db.Column(db.Integer, db.ForeignKey('courses.id'))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
course = db.relationship('Course',
backref=db.backref('course_class_attendance'))
user = db.relationship('User',
backref=db.backref('course_class_attendance'))
class Conversation(BaseModel):
__tablename__ = 'conversations'
expecting_response_for = db.Column(db.String(128))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User',
backref=db.backref('conversations', uselist=True),
lazy='joined')
class FeedLike(BaseModel, HasUID, HasStatus):
__tablename__ = 'feed_likes'
feed_id = db.Column(db.Integer, db.ForeignKey('feeds.id'))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
feed = db.relationship('Feed',
backref=db.backref('feed_likes', uselist=True))
user = db.relationship('User',
backref=db.backref('feed_likes', uselist=True))
class Job(BaseModel, HasUID, HasCreator, HasBloc):
__tablename__ = 'jobs'
title = db.Column(db.String(128))
location = db.Column(db.String(128))
description = db.Column(db.TEXT)
thumbnail = db.Column(db.TEXT)
min_salary = db.Column(AMOUNT_FIELD)
max_salary = db.Column(AMOUNT_FIELD)
salary_currency = db.Column(db.String(3))
salary_interval = db.Column(db.String(128))
duration = db.Column(
db.Enum('SHORT TERM', 'FULL-TIME', 'PART-TIME', name='job_durations'))
def as_json(self):
return {
'title': self.title,
'location': self.location,
'description': self.description,
'min_salary': self.min_salary,
'max_salary': self.max_salary,
'salary_interval': self.salary_interval,
'duration': self.duration,
'currency': self.currency
}
class Message(BaseModel):
__tablename__ = 'messages'
conversation_id = db.Column(db.Integer, db.ForeignKey('conversations.id'))
origin = db.Column(db.Enum('RECEIVED', 'SENT', name='origin'))
content = db.Column(db.TEXT)
conversation = db.relationship('Conversation',
backref=db.backref('messages',
uselist=True),
lazy='joined')
class BlocFeed(BaseModel):
__tablename__ = 'bloc_feeds'
feed_id = db.Column(db.Integer, db.ForeignKey('feeds.id'))
bloc_id = db.Column(db.Integer, db.ForeignKey('blocs.id'))
feed = db.relationship('Feed',
backref=db.backref('bloc_feeds', uselist=True),
uselist=False)
bloc = db.relationship('Bloc',
backref=db.backref('bloc_feeds', uselist=True),
uselist=False)
class ProjectAuthor(BaseModel, HasUID):
__tablename__ = 'project_authors'
bloc_id = db.Column(db.Integer, db.ForeignKey('blocs.id'))
project_id = db.Column(db.Integer, db.ForeignKey('projects.id'))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
bloc = db.relationship('Bloc',
backref=db.backref('project_authors', uselist=True),
uselist=False)
user = db.relationship('User',
backref=db.backref('project_authors', uselist=True),
uselist=False)
class EventInterest(BaseModel, HasUID, HasStatus):
__tablename__ = 'event_interests'
event_id = db.Column(db.Integer, db.ForeignKey('events.id'))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
event = db.relationship('Event',
backref=db.backref('event_interests_',
uselist=True),
uselist=False)
user = db.relationship('User',
backref=db.backref('event_interests', uselist=True),
uselist=False)
class BlocMembership(BaseModel):
__tablename__ = 'bloc_memberships'
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
bloc_id = db.Column(db.Integer, db.ForeignKey('blocs.id'))
user = db.relationship('User',
backref=db.backref('bloc_memberships',
uselist=True),
uselist=False)
bloc = db.relationship('Bloc',
backref=db.backref('bloc_memberships',
uselist=True),
uselist=False)
class Project(BaseModel, HasUID, HasBloc, HasCreator):
__tablename__ = 'projects'
title = db.Column(db.String(64))
description = db.Column(db.TEXT)
thumbnail = db.Column(db.TEXT)
weblink = db.Column(db.String(256))
@property
def likes_count(self):
return ProjectLike.query.filter_by(project_id=self.id).count()
@property
def views_count(self):
return ProjectView.query.filter_by(project_id=self.id).count()
class Location(BaseModel):
__tablename__ = 'locations'
title = db.Column(db.String(128))
coordinates = db.Column(db.String(50))
address = db.Column(db.String(128))
country = db.Column(db.String(32))
state = db.Column(db.String(32))
town = db.Column(db.String(32))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User',
backref=db.backref('locations', uselist=True),
uselist=False)
def as_json(self):
return {
'title': self.title,
'address': self.address,
'country': self.country,
'state': self.state,
'town': self.town,
'coordinates': self.coordinates
}
class FeedComment(BaseModel, HasUID, HasStatus):
__tablename__ = 'feed_comments'
feed_id = db.Column(db.Integer, db.ForeignKey('feeds.id'))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
message = db.Column(db.TEXT)
feed = db.relationship('Feed',
backref=db.backref('feed_comments', uselist=True))
user = db.relationship('User',
backref=db.backref('feed_comments', uselist=True))
def as_json(self):
return {
'created_at': self.created_at.isoformat(),
'created_by': self.user.as_json(),
'message': self.message
}
class Skill(BaseModel, HasUID, LookUp):
__tablename__ = 'skills'
description = None
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User',
backref=db.backref('users', uselist=True),
uselist=True)
class BlocTag(BaseModel, LookUp):
__tablename__ = 'bloc_tags'
description = None
bloc_id = db.Column(db.Integer, db.ForeignKey('blocs.id'))
bloc = db.relationship('Bloc',
backref=db.backref('bloc_tags', uselist=True),
uselist=False)
class Feed(BaseModel, HasUID):
__tablename__ = 'feeds'
created_by_id = db.Column(db.Integer, db.ForeignKey('users.id'))
external_app_uid = db.Column(db.String(64))
created_at = db.Column(db.DateTime, default=datetime.now)
message = db.Column(db.TEXT)
created_by = db.relationship('User',
backref=db.backref('user_feeds',
uselist=True))
@property
def likes_count(self):
return FeedLike.prep_query_for_active(feed_id=self.id).count()
@property
def comments_count(self):
return FeedComment.prep_query_for_active(feed_id=self.id).count()
class BaseModel(db.Model):
__abstract__ = True
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime, default=datetime.now)
uid = db.Column(db.String(64))
def save(self):
self.uid = shortuuid.uuid()
db.session.add(self)
db.session.commit()
def update(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
db.session.commit()
@classmethod
def get(cls, **kwargs):
return cls.query.filter_by(**kwargs).first()
@classmethod
def query_for_active(cls, _desc=False, **kwargs):
query = cls.query.filter_by(status_id=STATUSES.index('active') + 1,
**kwargs)
if _desc:
query.order_by(cls.id.desc())
return query.all()
@classmethod
def prep_query_for_active(cls, _desc=False, **kwargs):
query = cls.query.filter_by(status_id=STATUSES.index('active') + 1,
**kwargs)
if _desc:
query.order_by(cls.id.desc())
return query
class User(db.Model): __tablename__ = 'users' uid = db.Column(db.Integer, primary_key = True) firstname = db.Column(db.String(100)) lastname = db.Column(db.String(100)) email = db.Column(db.String(120), unique=True) pwdhash = db.Column(db.String(54)) def __init__(self, firstname, lastname, email, password): self.firstname = firstname.title() self.lastname = lastname.title() self.email = email.lower() self.set_password(password) def set_password(self, password): self.pwdhash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.pwdhash, password) def __repr__(self): return '<User %r>' % self.email
class Bloc(BaseModel, HasUID, LookUp, HasStatus):
__tablename__ = 'blocs'
created_by = db.Column(db.Integer, db.ForeignKey('users.id'))
location_id = db.Column(db.Integer, db.ForeignKey('locations.id'))
is_private = db.Column(db.Boolean, default=False)
is_default = db.Column(db.Boolean, default=True)
invite_code = db.Column(db.String(6))
theme_color = db.Column(db.String(8), default=generate_random_bloc_color)
location = db.relationship('Location', backref=db.backref('blocs'))
@property
def latest_feeds(self):
bloc_feeds = BlocFeed.query.filter_by(bloc_id=self.id).order_by(
BlocFeed.id.desc()).limit(PAGINATE_DEFAULT_PER_PAGE).all()
print("latest feeds: %s" % bloc_feeds)
return [bloc_feed.feed for bloc_feed in bloc_feeds]
@property
def events(self):
bloc_events = Event.query.filter_by(bloc_id=self.id).order_by(
Event.id.desc()).limit(PAGINATE_DEFAULT_PER_PAGE).all()
return bloc_events
def generate_invite_code(self):
raise NotImplementedError
def set_invite_code(self, _code=None):
if _code is not None:
_code = self.generate_invite_code()
self.invite_code = _code
def as_json(self):
return {
'name': self.name,
'theme_color': self.theme_color,
'invite_code': self.invite_code,
'is_private': self.is_private,
'is_default': self.is_default,
'creator': self.created_by
}
class Event(BaseModel, HasUID, HasBloc, HasCreator):
__tablename__ = 'events'
bloc_id = db.Column(db.Integer, db.ForeignKey('blocs.id'))
title = db.Column(db.String(128))
description = db.Column(db.TEXT)
thumbnail = db.Column(db.TEXT)
venue = db.Column(db.String(64))
datetime = db.Column(db.DateTime)
bloc = db.relationship('Bloc',
backref=db.backref('events', uselist=True),
uselist=False)
def as_json(self):
return {
'id': self.id,
'title': self.title,
'description': self.description,
'venue': self.venue,
'datetime': self.datetime.isoformat(),
# 'thumbnail': self.thumbnail
}
@property
def interest_count(self):
return EventInterest.query.filter_by(
event_id=self.id,
# status_id=None, STATUSES.index('active'))
).count()
@property
def user_is_interested(self):
return bool(
EventInterest.query.filter_by(event_id=self.id,
user_id=g.user.id).count())
@property
def humane_date(self):
return str(self.created_at.date)
class Comment(CommentJsonSerializer, db.Model):
"""Comment model"""
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id', ondelete='CASCADE'), nullable=False)
main_id = db.Column(db.Integer, db.ForeignKey('comment.id'))
level = db.Column(db.SmallInteger, default=0)
content = db.Column(db.Text)
created_at = db.Column(db.DateTime, default=datetime.datetime.now)
main = db.relationship('Comment', remote_side=[id], uselist=False,
backref=db.backref('subs', lazy='dynamic', cascade="all, delete-orphan", single_parent=True,
order_by='desc(Comment.created_at)'))
@hybrid_property
def date(self):
return naturaltime(self.created_at)
def sub_paginate(self, current_page):
subs = self.subs.paginate(current_page, COMMENT_SUB_PER_PAGE)
return subs.items, subs.has_prev, subs.has_next
@hybrid_property
def sub_list(self):
subs = []
has_next = False
has_prev = False
if self.main_id is None:
subs, has_prev, has_next = self.sub_paginate(1)
return {'replies': subs, 'has_prev': has_prev, 'has_next': has_next, 'current_page': 1}
else:
return {}
@hybrid_property
def is_own(self):
if current_user.is_authenticated():
return self.user == current_user._get_current_object()
return False
#updated_at = db.Column(db.DateTime, onupdate=datetime.datetime.now)
class Tag(TagJsonSerializer, db.Model):
"""Tag model"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), nullable=False)
class AddressBase(object):
recipient_name = db.Column(db.String(90))
phone_number = db.Column(db.String(45))
zip = db.Column(db.String(45))
address_line1 = db.Column(db.String(255))
address_line2 = db.Column(db.String(255))
class LookUp(object):
name = db.Column(db.String(64), unique=True)
description = db.Column(db.String(128))
