class Topic(db.Model):
__tablename__ = 'topics'
tid = db.Column(db.Integer, primary_key=True)
topic = db.Column(db.String(20))
_description = db.Column(db.String(20))
parent_id = db.Column(db.String(20))
posts = db.relationship("Post", backref="topics")
path = None
def __init__(self, topic, _description, parent_id):
self.topic = topic
self._description = _description
self.parent_id = parent_id
@classmethod
def all_topics(self):
return self.query.all()
@classmethod
def getTopicById(self, tid):
return self.query.get(tid)
@classmethod
def getTopicList(self):
return [{t.topic} for t in Topic.all_topics()]
class User(Base, UserMixin):
__tablename__ = "users"
name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
avatar = db.Column(db.String(150), default="avatar.png")
email_verified_at = db.Column(db.DateTime, nullable=True, default=None)
confirmation_token = db.Column(db.String(200), nullable=True, default=None)
threads = db.relationship("Thread", back_populates="owner")
comments = db.relationship("Comment", back_populates="owner")
@classmethod
def create(cls, **kwargs):
user = cls(**kwargs)
user.save()
return user
def json_attributes(self):
return {
"id": self.id,
"email": self.email,
"name": self.name,
"profilePicture": self.profile_picture,
"email_verified": self.email_verified_at is not None
}
@property
def profile_picture(self):
return url_for("static", filename="images/avatars/" + self.avatar)
class Thread(Base):
json_attributes = ("id", "title", "slug", "content", "user_id",
"category_id", "comments_count")
__tablename__ = "threads"
title = db.Column(db.String(100), nullable=False)
slug = db.Column(db.String(250), nullable=False)
content = db.Column(db.Text)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
category_id = db.Column(db.Integer, db.ForeignKey("categories.id"))
views_count = db.Column(db.Integer, nullable=False, default=0)
comments_count = db.Column(db.Integer, default=0)
best_comment_id = db.Column(db.Integer, nullable=True)
owner = db.relationship("User", back_populates="threads")
category = db.relationship("Category", back_populates="threads")
comments = db.relationship("Comment", back_populates="thread")
@property
def summary(self):
return self.content[0:300] + "..."
def is_owner(self, user):
return user == self.owner
def add_comment(self, content, owner):
comment = Comment(content=content, user_id=owner.id, thread_id=self.id)
comment.save()
return comment
@hybrid_property
def has_comments(self):
return self.comments_count > 0
class User(db.Model, UserMixin):
__tablename__ = 'users'
uid = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20))
_password = db.Column(db.String(20))
_email = db.Column(db.String(20), unique=True)
posts = db.relationship("Post", backref="user")
comments = db.relationship("Comment", backref="user")
likes = db.relationship("Like", backref="user")
def __init__(self, username, _password, _email):
self.username = username
self._password = _password
self._email = _email
@classmethod
def all_users(self):
return self.query.all()
@classmethod
def getUserById(self, uid):
return self.query.get(uid)
@classmethod
def getEmail(self):
return self._email
def get_id(self):
try:
return text_type(self.uid)
except AttributeError:
raise NotImplementedError('No `id` attribute - override `get_id`')
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False, unique=True)
email = db.Column(db.String(255), nullable=False)
password = db.Column(db.String(255), nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
registered_on = db.Column(db.DateTime,
nullable=False,
default=db.func.current_timestamp())
texts = db.relationship('Text', backref='user', lazy='dynamic')
links = db.relationship('Link', backref='user', lazy='dynamic')
comments = db.relationship('Comment', backref='user', lazy='dynamic')
post_karma = db.Column(db.Integer, nullable=False, default=0)
comment_karma = db.Column(db.Integer, nullable=False, default=0)
has_upvoted = db.relationship('ThreadUpvote',
backref='user',
lazy='dynamic')
has_downvoted = db.relationship('ThreadDownvote',
backref='user',
lazy='dynamic')
has_upvoted_comment = db.relationship('CommentUpvote',
backref='user',
lazy='dynamic')
has_downvoted_comment = db.relationship('CommentDownvote',
backref='user',
lazy='dynamic')
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), nullable=False, unique=True)
email = db.Column(db.String(120), nullable=False, unique=True)
password = db.Column(db.String(60), nullable=False)
type = db.Column(db.Integer, nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f"User({self.username}, {self.email})"
class Category(Base):
__tablename__ = "categories"
name = db.Column(db.String(100))
slug = db.Column(db.String(200))
threads = db.relationship("Thread", back_populates="category")
def to_json(self):
return {"id": self.id, "name": self.name, "slug": self.slug}
class Post(db.Model):
post_id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
body = db.Column(db.String(250), nullable=False)
image = db.Column(db.String(100), nullable=True, default='default.jpg')
id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
date_created = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
activities = db.relationship('Activity', backref='post', lazy=True)
def __repr__(self):
return f"Post('{self.post_id}','{self.title}','{self.body}','{self.image}','{self.id}')"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
profile_picture = db.Column(db.String(100),
nullable=True,
default='default.jpg')
date_created = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
posts = db.relationship('Post', backref='author', lazy=True)
activities = db.relationship('Activity', backref='author', lazy=True)
def __repr__(self):
return f"User('{self.id}',{self.email}'.'{self.profile_picture}')"
class Tag(db.Model):
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(32), nullable=False)
message_id = db.Column(db.Integer, db.ForeignKey(
'message.id'), nullable=False)
message = db.relationship('Message', backref=db.backref('tags', lazy=True))
class Thread(db.Model):
__abstract__ = True
__metaclass__ = abc.ABCMeta
@declared_attr
def user_id(cls):
"""Foreign key to User table"""
return db.Column(db.Integer, db.ForeignKey('users.id'))
@declared_attr
def subreddit_id(cls):
"""Foreign key to Subreddit table"""
return db.Column(db.Integer, db.ForeignKey('subreddits.id'))
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255), nullable=False)
upvote = db.Column(db.Integer, nullable=False, default=0)
downvote = db.Column(db.Integer, nullable=False, default=0)
modified_on = db.Column(db.DateTime,
default=datetime.datetime.now(),
onupdate=datetime.datetime.now())
@abc.abstractclassmethod
def is_link(cls):
"""Return 0 for link, 1 for text"""
...
def save(self):
db.session.add(self)
db.session.commit()
class Link(Thread):
__tablename__ = 'links'
link = db.Column(db.String(255), nullable=False)
upvoters = db.relationship('ThreadUpvote', backref='link', lazy='dynamic')
downvoters = db.relationship('ThreadDownvote',
backref='link',
lazy='dynamic')
comments = db.relationship('Comment', backref='link', lazy='dynamic')
def __repr__(self):
return f'<Link: {self.title}>'
def get_score(self):
return self.upvote - self.downvote
def get_time(self):
now = datetime.datetime.now()
return timeago.format(now, self.modified_on)
@classmethod
def is_link(self):
return True
def save(self):
super().save()
ThreadUpvote(user_id=self.user_id, link_id=self.id).save()
class Category(db.Model):
__tablename__ = 'category'
category_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
def __init__(self, category_id, name):
self.category_id = category_id
self.name = name
class Message(db.Model):
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(1024), nullable=False)
def __init__(self, text, tags):
self.text = text
self.tags = [
Tag(text=tag.strip()) for tag in tags.split(',')
]
class User(db.Model):
__tablename__ = 'user'
user_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
email = db.Column(db.String(20))
password_hash = db.Column(db.String(20))
token = db.Column(db.String(20))
is_admin = db.Column(db.Integer)
date_joined = db.Column(db.DateTime, default=datetime.utcnow)
avatar_id = db.Column(db.Integer)
def __init__(self, name, email, password_hash, token, is_admin, avatar_id):
self.name = name
self.email = email
self.password_hash = password_hash
self.token = token
self.is_admin = is_admin
self.avatar_id = avatar_id
@classmethod
def getAll(self):
return self.query.all()
@classmethod
def getUserById(self, user_id):
return self.query.get(user_id)
@classmethod
def getUserByToken(self, token):
return self.query.filter(User.token == token).first()
@classmethod
def getUserByEmail(self, email):
return self.query.filter(User.email == email).first()
@classmethod
def getEmail(self):
return self._email
def get_id(self):
try:
return text_type(self.uid)
except AttributeError:
raise NotImplementedError('No `id` attribute - override `get_id`')
class User(db.Model):
__tablename__ = "users"
id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid4)
name = db.Column(db.String(), nullable=False)
def __repl__(self):
return "<User id='%s' name='%s'>" % (self.id, self.name)
def __str__(self):
return self.__repl__()
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.today)
content = db.Column(db.Text, nullable=False)
userid = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post({self.title}, {self.date_posted})"
class Subreddit(db.Model):
__tablename__ = 'subreddits'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False, unique=True)
subscribers = db.Column(db.Integer, default=0)
description = db.Column(db.String(1000), unique=False)
created_on = db.Column(db.DateTime,
nullable=False,
default=db.func.current_timestamp())
texts = db.relationship('Text', backref='subreddit', lazy='dynamic')
links = db.relationship('Link', backref='subreddit', lazy='dynamic')
def __repr__(self):
return f"<Subreddit: {self.name} | " + \
f"Description: {self.description[:50]}>"
def save(self):
db.session.add(self)
db.session.commit()
class Category(db.Model):
__tablename__ = "categories"
id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid4)
name = db.Column(db.String(), nullable=False)
parent_id = db.Column(UUID(as_uuid=True), db.ForeignKey("categories.id"))
parent = db.relationship("Category", remote_side=[id])
def __repl__(self):
return "<Category id='%s' name='%s'>" % (self.id, self.name)
def __str__(self):
return self.__repl__()
class Activity(db.Model):
activity_id = db.Column(db.Integer, primary_key=True)
comment = db.Column(db.String(250), nullable=True)
upvote = db.Column(db.Boolean, default=False)
downvote = db.Column(db.Boolean, default=False)
id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
post_id = db.Column(db.Integer,
db.ForeignKey('post.post_id'),
nullable=False)
date_created = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
def __repr__(self):
return f"Activity('{self.activity_id}','{self.post_id},'{self.comment}','{self.upvote}','{self.downvote}','{self.date_created}')"
class Post(db.Model):
__tablename__ = 'post'
post_id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
content = db.Column(db.Text, nullable=False)
post_time = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
poster_id = db.Column(db.Integer,
db.ForeignKey('user.user_id'),
nullable=False)
category_id = db.Column(db.Integer,
db.ForeignKey('category.category_id'),
nullable=False)
def __init__(self, title, content, poster_id, category_id):
self.title = title
self.content = content
self.poster_id = poster_id
self.category_id = category_id
@classmethod
def getPostsByUser(self, user_id):
return self.query.filter(Post.poster_id == user_id).all()
@classmethod
def getPostById(self, post_id):
return self.query.filter(Post.post_id == post_id).first()
@classmethod
def getAll(self):
return self.query.all()
@classmethod
def getPostsWithContentContaining(self, keyword):
return self.query.filter(Post.content.like('%' + keyword + '%')).all()
@classmethod
def getPostsContaining(self, keyword):
return self.query.filter(
Post.title.like('%' + keyword + '%')
| Post.content.like('%' + keyword + '%')).all()
@classmethod
def getPostCountByCategoryId(self, category_id):
return self.query.filter(Post.category_id == category_id).count()
class Post(db.Model):
__tablename__ = 'posts'
pid = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
content = db.Column(db.Text, nullable=False)
post_time = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow())
uid = db.Column(db.Integer, db.ForeignKey('users.uid'), nullable=False)
tid = db.Column(db.Integer, db.ForeignKey('topics.tid'), nullable=False)
comments = db.relationship("Comment", backref="posts")
likes = db.relationship("Like", backref="posts")
def __init__(self, title, content, post_time, uid, tid):
self.title = title
self.content = content
self.post_time = post_time
self.uid = uid
self.tid = tid
class Topic(db.Model):
id = db.Column(db.Integer, primary_key = True)
header = db.Column(db.String(100), nullable = False)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable = False)
content = db.Column(db.Text, nullable = False)
date = db.Column(db.DateTime, default = datetime.utcnow, nullable = False)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key = True)
username = db.Column(db.String(20), unique = True, nullable = False)
password = db.Column(db.String(60), nullable = False)
topics = db.relationship("Topic", backref = "author", lazy = True)
