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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 Connection(db.Model):
"""Connection model"""
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
provider_id = db.Column(db.String(255))
provider_user_id = db.Column(db.String(255))
access_token = db.Column(db.String(255))
secret = db.Column(db.String(255))
full_name = db.Column(db.String(255))
display_name = db.Column(db.String(255))
profile_url = db.Column(db.String(512))
image_url = db.Column(db.String(512))
rank = db.Column(db.Integer)
class Course(BaseModel, HasUID, HasBloc, HasCreator):
__tablename__ = 'courses'
title = db.Column(db.String(128))
description = db.Column(db.TEXT)
bloc_id = db.Column(db.Integer, db.ForeignKey('blocs.id'))
created_by_id = db.Column(db.Integer, db.ForeignKey('users.id'))
start_date = db.Column(db.Date)
end_date = db.Column(db.Date)
time = db.Column(db.String(6))
days_of_week = db.Column(db.TEXT)
timezone = db.String(6)
thumbnail = db.Column(db.TEXT)
source_category = db.Column(
db.Enum('SOCIAL MEDIA',
'ONLINE SCHOOL',
name='course_source_categories'))
source = db.Column(db.Enum('FACEBOOK', 'UDACITY', name='course_sources'))
created_by = db.relationship('User',
backref=db.backref('courses', uselist=True))
bloc = db.relationship('Bloc', backref=db.backref('courses'))
@property
def ratings_(self):
return {
'count': CourseRating.prep_query_for_active().count(),
'average': 4.2
}
def as_json(self):
return {
'title': self.title,
'description': self.description,
'created_by': self.created_by.as_json()
}
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 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 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)
def status_id(cls):
return db.Column(db.Integer,
db.ForeignKey('statuses.id'),
default=STATUSES.index('active') + 1)
class User(BaseModel, HasUID, HasStatus):
__tablename__ = 'users'
username = db.Column(db.String(64))
first_name = db.Column(db.String(64))
last_name = db.Column(db.String(64))
external_app_uid = db.Column(db.String(64))
avatar_url = db.Column(db.TEXT)
bio = db.Column(db.String(128))
access_token = db.Column(db.TEXT)
access_token_secret = db.Column(db.TEXT)
blocs_platform_id = db.Column(db.Integer,
db.ForeignKey('blocs_platforms.id'))
@property
def events_count(self):
return Event.query.filter_by(created_by_id=self.id).count()
@property
def clean_avatar_url(self):
return self.avatar_url.replace('\\', '')
@property
def location(self):
return self.locations[-1]
@property
def blocs(self):
all_users_blocs = []
for membership in self.bloc_memberships:
all_users_blocs.append(membership.bloc)
return all_users_blocs
@property
def has_bloc(self):
return bool(self.bloc_memberships)
@property
def event_interests_count(self):
return EventInterest.query.filter_by(user_id=self.id).count()
def as_json(self):
return {
'first_name':
self.first_name,
'last_name':
self.last_name,
'id':
self.id,
'external_app_uid':
self.external_app_uid,
'access_token':
self.access_token,
'username':
self.username,
'bio':
self.bio,
# 'location': self.location,
'avatar_url':
self.clean_avatar_url,
'profile_link':
'https://web.facebook.com/{}'.format(self.external_app_uid)
}
class UserSoftwareBranch(BaseModel, LookUp):
__tablename__ = 'user_software_branches'
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
software_branch_id = db.Column(db.Integer,
db.ForeignKey('software_branches.id'))
class CourseClass(BaseModel):
__tablename__ = 'course_classes'
course_id = db.Column(db.Integer, db.ForeignKey('courses.id'))
course = db.relationship('Course', backref=db.backref('course_classes'))
def created_by_id(cls):
return db.Column(db.Integer, db.ForeignKey('users.id'))
class ProjectView(BaseModel, HasCreator):
__tablename__ = 'project_views'
project_id = db.Column(db.Integer, db.ForeignKey('projects.id'))
project = db.relationship('Project', backref=db.backref('project_views'))
def bloc_id(cls):
return db.Column(db.Integer, db.ForeignKey('blocs.id'))
