class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(32), nullable=False)
last_name = db.Column(db.String(32))
password_hash = db.Column(db.String(120))
token = db.Column(db.String(130), nullable=False)
email = db.Column(db.String(130), nullable=False, unique=True)
contact_number = db.Column(db.String(12))
profile_url = db.Column(db.String(130))
about_me = db.Column(db.Text)
city = db.Column(db.String(32))
country = db.Column(db.String(32))
no_goals_added = db.Column(db.Integer)
no_goals_completed = db.Column(db.Integer)
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
user_goals = db.relationship('UserGoal', backref="user", cascade="all, delete-orphan", lazy='dynamic')
goal = db.relationship('Goal', backref="user", cascade="all, delete-orphan", uselist=False)
ug_likes = db.relationship('UserGoalLike', backref=db.backref('user', lazy='joined'), lazy='dynamic',
cascade="all, delete, delete-orphan")
g_likes = db.relationship('GoalLike', backref=db.backref('user', lazy='joined'), lazy='dynamic',
cascade="all, delete, delete-orphan")
def hash_password(self, password):
self.password_hash = pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password_hash)
class User(db.Model):
user_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
first_name = db.Column(db.String(80))
last_name = db.Column(db.String(80))
email = db.Column(db.String(80))
picture = db.Column(db.String(120))
age_range = db.Column(db.String(80))
fb_token = db.Column(db.String(120))
gender = db.Column(db.Integer)
reg_date = db.Column(db.DateTime)
posts = db.relationship('Post', backref='publisher', lazy='dynamic')
subscribed_groups = db.relationship('Group',
secondary=subscribe,
backref=db.backref('subscribers',
lazy='dynamic'))
banned_from = db.relationship('Group',
secondary=ban,
backref=db.backref('banned_users',
lazy='dynamic'))
admin_of = db.relationship('Group')
def __init__(self, first_name, last_name, email, picture, age_range,
fb_token, gender):
self.first_name = first_name
self.last_name = last_name
self.email = email
self.picture = picture
self.age_range = age_range
self.fb_token = fb_token
self.gender = gender
self.reg_date = datetime.now()
def __repr__(self):
return '<User %r>' % self.user_id
def get_subscribed_groups(self, user_id, page=0): # -> group_id []
user = User.query.filter(User.user_id == user_id).first()
return [group.group_id for group in user.subscribed_groups]
def subscribe_to(self, group_id, user_id, is_submitter): # -> bool
subscribe.insert().values(group_id=group_id,
user_id=user_id,
is_submitter=is_submitter,
time=datetime.now())
db.session.commit()
return True
def ban_user(self, group_id, admin_id, banned_by, is_shadow): # -> bool
ban.insert().values(group_id=group_id,
admin_id=admin_id,
banned_by=banned_by,
is_shadow=is_shadow,
time=datetime.now())
db.session.commit()
return True
class Subscription(db.Model):
id = db.Column(INTEGER(unsigned=True), primary_key=True)
device = db.Column(db.VARCHAR(40), nullable=False)
service_id = db.Column(INTEGER(unsigned=True), db.ForeignKey('service.id'), nullable=False)
service = db.relationship('Service', backref=db.backref('subscription', lazy='dynamic'))
last_read = db.Column(INTEGER(unsigned=True), db.ForeignKey('message.id'), default=0)
timestamp_created = db.Column(db.TIMESTAMP, default=datetime.utcnow)
timestamp_checked = db.Column(db.TIMESTAMP)
def __init__(self, device, service):
last_message = Message.query.order_by(Message.id.desc()).first()
self.device = device
self.service = service
self.timestamp_checked = datetime.utcnow()
self.last_read = last_message.id if last_message else 0
def __repr__(self):
return '<Subscription {}>'.format(self.id)
def messages(self):
return Message.query \
.filter_by(service_id=self.service_id) \
.filter(Message.id > self.last_read)
def as_dict(self):
data = {
"uuid": self.device,
"service": self.service.as_dict(),
"timestamp": int((self.timestamp_created - datetime.utcfromtimestamp(0)).total_seconds()),
"timestamp_checked": int((self.timestamp_checked - datetime.utcfromtimestamp(0)).total_seconds())
}
return data
class Message(db.Model):
id = db.Column(INTEGER(unsigned=True), primary_key=True)
service_id = db.Column(INTEGER(unsigned=True),
db.ForeignKey('service.id'),
nullable=False)
service = db.relationship('Service',
backref=db.backref('message', lazy='dynamic'))
text = db.Column(db.TEXT, nullable=False)
title = db.Column(db.VARCHAR)
level = db.Column(TINYINT, nullable=False, default=0)
link = db.Column(db.TEXT, nullable=False, default='')
timestamp_created = db.Column(db.TIMESTAMP, default=datetime.utcnow)
def __init__(self, service, text, title=None, level=0, link=''):
self.service = service
self.text = text
self.title = title
self.level = level
self.link = link
def __repr__(self):
return '<Message %r>' % self.id
def as_dict(self):
return {
"service": self.service.as_dict(),
"message": self.text,
"title": self.title,
"link": self.link,
"level": self.level,
"timestamp": int(self.timestamp_created.strftime('%s'))
}
class Goal(db.Model):
__tablename__ = 'goal'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
name = db.Column(db.String(256), nullable=False)
cat_id = db.Column(db.Integer, default=1)
image_url = db.Column(db.String(130))
no_added = db.Column(db.Integer, default=1)
no_completed = db.Column(db.Integer, default=0)
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
user_goals = db.relationship('UserGoal', backref="goal", cascade="all, delete-orphan", lazy='dynamic')
g_likes = db.relationship('GoalLike', backref=db.backref('goal', lazy='joined'), lazy='dynamic',
cascade="all, delete, delete-orphan")
@property
def serialize(self):
return {
'id': self.id,
'user_id': self.user_id,
'first_name': self.user.first_name,
'last_name': self.user.last_name,
'name': self.name,
'cat_id': self.cat_id,
'image_url': self.image_url,
'no_added': self.no_added,
'no_completed': self.no_completed,
'created_at': self.created_at,
'updated_at': self.updated_at
}
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(150), nullable=False)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
login_count = db.Column(db.Integer)
current_login_ip = db.Column(db.String(255))
current_login_at = db.Column(db.DateTime, default=datetime.utcnow)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow)
posts = db.relationship('Post', backref='author', lazy='dynamic')
comments = db.relationship('Comment', backref='author', lazy='dynamic')
roles = db.relationship('Role', secondary=role_users, backref=db.backref('users', lazy="dynamic"),
cascade="save-update, merge, delete")
def __init__(self, email, password=None, *args, **kwargs):
super(User, self).__init__(email=email, password=password, *args, **kwargs)
if not self.username:
self.username = self.email.split("@")[0]
if not self.roles:
user_role = Role.query.filter(Role.name == 'user').first()
self.roles.append(user_role)
def __repr__(self):
return f'<User #{self.id} {self.email}>'
class Subscription(db.Model):
id = db.Column(INTEGER(unsigned=True), primary_key=True)
device = db.Column(db.VARCHAR(40), nullable=False)
service_id = db.Column(INTEGER(unsigned=True),
db.ForeignKey('service.id'),
nullable=False)
service = db.relationship('Service',
backref=db.backref('subscription',
lazy='dynamic'))
timestamp_created = db.Column(db.TIMESTAMP, default=datetime.utcnow)
timestamp_checked = db.Column(db.TIMESTAMP)
def __init__(self, device, service):
self.device = device
self.service = service
self.timestamp_checked = datetime.utcnow() - timedelta(minutes=30)
def __repr__(self):
return '<Subscription %r>' % self.id
def messages(self):
return Message.query \
.filter_by(service_id=self.service_id) \
.filter(Message.timestamp_created > self.timestamp_checked)
def as_dict(self):
data = {
"uuid": self.device,
"service": self.service.as_dict(),
"timestamp": int(self.timestamp_created.strftime('%s')),
"timestamp_checked": int(self.timestamp_checked.strftime('%s'))
}
return data
class Users(db.Model, UserMixin):
__tablename__ = 'users'
# Primary key
id = db.Column(db.Integer, primary_key=True)
# Columns
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())
roles = db.relationship('Roles', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
# Representation
def __repr__(self):
return '<id %r>' % self.id
# Check if a user email exists
@classmethod
def check_user(class_, email):
Users = class_
# Query for the email
user = Users.query.filter_by(email=email).first()
# Return true if exists
if user:
return user
else:
return False
class Post(db.Model):
from models import User, Category
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(140), nullable=False)
slug = db.Column(db.String(140), nullable=False, unique=True)
text = db.Column(db.Text, nullable=False)
photo = db.Column(db.String(255), unique=True)
is_published = db.Column(db.Boolean,
nullable=False,
default=False,
server_default='0')
user_id = db.Column(db.Integer,
db.ForeignKey(User.id,
onupdate="CASCADE",
ondelete="CASCADE"),
nullable=False)
category_id = db.Column(db.Integer,
db.ForeignKey(Category.id,
onupdate="CASCADE",
ondelete="CASCADE"),
nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now())
published_at = db.Column(db.DateTime, default=datetime.now())
tags = db.relationship('Tag',
secondary=post_tags,
backref=db.backref('posts', lazy="dynamic"))
comments = db.relationship('Comment',
secondary=post_comments,
backref=db.backref('post', lazy="dynamic"))
def __init__(self, *args, **kwargs):
super(Post, self).__init__(*args, **kwargs)
self.generate_slug()
def generate_slug(self):
if self.title:
self.slug = slugify(self.title)
def is_owner(self):
return self.author == current_user
def __repr__(self):
return f'<Post #{self.id} {self.title}>'
class Thread(db.Model):
id = db.Column(db.Integer, primary_key=True)
board = db.Column(db.Integer, db.ForeignKey("board.id"), nullable=False)
views = db.Column(db.Integer, nullable=False)
posts = relationship("Post", order_by=Post.datetime)
last_updated = db.Column(db.DateTime)
tags = relationship("Tag", secondary=tags, lazy='subquery',
backref=db.backref('threads', lazy=True))
def num_media(self):
return db.session.query(Post).filter(and_(Post.thread == self.id, Post.media != None)).count()
class UserGoal(db.Model):
__tablename__ = 'usergoal'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
goal_id = db.Column(db.Integer, db.ForeignKey('goal.id'))
likes = db.Column(db.Integer, default=0)
lat = db.Column(db.Float)
long = db.Column(db.Float)
date_target = db.Column(db.DateTime)
privacy = db.Column(db.SmallInteger)
list_id = db.Column(db.ForeignKey('list.id'))
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
ug_likes = db.relationship('UserGoalLike', backref=db.backref('usergoal', lazy='joined'), lazy='dynamic',
cascade="all, delete, delete-orphan")
class SuccessStory(db.Model):
__tablename__ = "successstory"
id = db.Column(db.Integer, primary_key=True)
user_goal_id = db.Column(db.ForeignKey('usergoal.id'))
story = db.Column(db.Text)
lat = db.Column(db.Float)
long = db.Column(db.Float)
date_completed = db.Column(db.DateTime)
likes = db.Column(db.Integer, default=0)
image_url = db.Column(db.String(130))
video_url = db.Column(db.String(130))
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
ss_likes = db.relationship('SuccessStoryLike', backref=db.backref('successstory', lazy='joined'), lazy='dynamic',
cascade="all, delete, delete-orphan")
class Book(db.Model):
__tablename__ = 'books'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Text())
author_id = db.Column(db.Integer, db.ForeignKey('authors.id'))
tags = db.relationship('Tag', secondary='book_tags', backref=db.backref('books', lazy='dynamic'))
def __init__(self, title,author_id):
self.title = title
self.author_id = author_id
# This is what will be displayed when you examine in the python console
def __repr__(self):
return 'id: {}, title: {}, author_id: {}'.format(self.id, self.title, self.author_id)
class Message(db.Model):
id = db.Column(INTEGER(unsigned=True), primary_key=True)
service_id = db.Column(INTEGER(unsigned=True),
db.ForeignKey('service.id'),
nullable=False)
service = db.relationship('Service',
backref=db.backref('message', lazy='dynamic'))
text = db.Column(db.TEXT, nullable=False)
title = db.Column(db.VARCHAR)
level = db.Column(TINYINT, nullable=False, default=0)
link = db.Column(db.TEXT, nullable=False, default='')
timestamp_created = db.Column(db.TIMESTAMP, default=datetime.utcnow)
def __init__(self, service, text, title=None, level=0, link=''):
self.service = service
self.text = text
self.title = title
self.level = level
self.link = link
def __repr__(self):
return '<Message {}>'.format(self.id)
def as_dict(self):
return {
"service":
self.service.as_dict(),
"message":
self.text,
"title":
self.title,
"link":
self.link,
"level":
self.level,
"timestamp":
int((self.timestamp_created -
datetime.utcfromtimestamp(0)).total_seconds())
}
def as_notification(self):
return {
"title": self.title,
"body": self.text,
"click_action": self.link
}
class Thread(db.Model):
id = db.Column(db.Integer, primary_key=True)
board = db.Column(db.Integer, db.ForeignKey("board.id"), nullable=False)
views = db.Column(db.Integer, nullable=False)
posts = relationship("Post", order_by=Post.datetime)
last_updated = db.Column(db.DateTime)
tags = relationship("Tag", secondary=tags, lazy='subquery',
backref=db.backref('threads', lazy=True))
def num_media(self):
return db.session.query(Post).filter(and_(Post.thread == self.id, Post.media != None)).count()
def admin_is_op(self):
poster_id = self.posts[0].poster
slip_id = db.session.query(Poster).filter(Poster.id == poster_id).one().slip
if slip_id is None:
return False
slip = slip_from_id(slip_id)
return slip.is_admin
class Message(db.Model):
id = db.Column(Integer, primary_key=True)
service_id = db.Column(Integer,
db.ForeignKey('service.id'),
nullable=False)
service = db.relationship('Service',
backref=db.backref('message',
lazy='dynamic',
cascade="delete"))
text = db.Column(db.TEXT, nullable=False)
title = db.Column(Unicode(length=255))
level = db.Column(Integer, nullable=False, default=0)
link = db.Column(db.TEXT, nullable=False, default='')
timestamp_created = db.Column(db.TIMESTAMP, default=datetime.utcnow)
def __init__(self, service, text, title=None, level=0, link=''):
self.service = service
self.text = text
self.title = title
self.level = level
self.link = link
def __repr__(self):
return '<Message {}>'.format(self.id)
def as_dict(self):
return {
"service":
self.service.as_dict(),
"message":
self.text,
"title":
self.title,
"link":
self.link,
"level":
self.level,
"timestamp":
int((self.timestamp_created -
datetime.utcfromtimestamp(0)).total_seconds())
}