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 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 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 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 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 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 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 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 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 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 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 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 Post(BaseModel, HasUID, HasBloc, HasCreator):
__tablename__ = 'posts'
title = db.Column(db.String(64))
body = db.Column(db.TEXT)
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))
def uid(cls):
return db.Column(db.String(64), default=shortuuid.uuid)
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 School(BaseModel, HasUID):
__tablename__ = 'schools'
name = db.Column(db.String(64))
class Tag(TagJsonSerializer, db.Model):
"""Tag model"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), nullable=False)
class Role(RoleJsonSerializer, db.Model, RoleMixin):
"""Role model"""
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255), default='')