class Post(db.Model):
__tablename__ = "posts"
PUBLIC = 100
FRIENDS = 200
PRIVATE = 300
PER_PAGE = 40
query_class = PostQuery
id = db.Column(db.Integer, primary_key=True)
author_id = db.Column(db.Integer,
db.ForeignKey(User.id, ondelete='CASCADE'),
nullable=False)
title = db.Column(db.Unicode(200))
description = db.Column(db.UnicodeText)
link = db.Column(db.String(250))
date_created = db.Column(db.DateTime, default=datetime.utcnow)
score = db.Column(db.Integer, default=1)
num_comments = db.Column(db.Integer, default=0)
votes = db.Column(DenormalizedText)
access = db.Column(db.Integer, default=PUBLIC)
_tags = db.Column("tags", db.UnicodeText)
author = db.relation(User, innerjoin=True, lazy="joined")
__mapper_args__ = {'order_by': id.desc()}
class Permissions(object):
def __init__(self, obj):
self.obj = obj
@cached_property
def default(self):
return Permission(UserNeed(self.obj.author_id)) & moderator
@cached_property
def view(self):
if self.obj.access == Post.PUBLIC:
return Permission()
if self.obj.access == Post.FRIENDS:
needs = [
UserNeed(user_id) for user_id in self.obj.author.friends
]
return self.default & Permission(*needs)
return self.default
@cached_property
def edit(self):
return self.default
@cached_property
def delete(self):
return self.default
@cached_property
def vote(self):
needs = [UserNeed(user_id) for user_id in self.obj.votes]
needs.append(UserNeed(self.obj.author_id))
return auth & Denial(*needs)
@cached_property
def comment(self):
return auth
def __init__(self, *args, **kwargs):
super(Post, self).__init__(*args, **kwargs)
self.votes = self.votes or set()
self.access = self.access or self.PUBLIC
def __str__(self):
return self.title
def __repr__(self):
return "<%s>" % self
@cached_property
def permissions(self):
return self.Permissions(self)
def vote(self, user):
self.votes.add(user.id)
def _get_tags(self):
return self._tags
def _set_tags(self, tags):
self._tags = tags
if self.id:
# ensure existing tag references are removed
d = db.delete(post_tags, post_tags.c.post_id == self.id)
db.engine.execute(d)
for tag in set(self.taglist):
slug = slugify(tag)
tag_obj = Tag.query.filter(Tag.slug == slug).first()
if tag_obj is None:
tag_obj = Tag(name=tag, slug=slug)
db.session.add(tag_obj)
if self not in tag_obj.posts:
tag_obj.posts.append(self)
tags = db.synonym("_tags", descriptor=property(_get_tags, _set_tags))
@property
def taglist(self):
if self.tags is None:
return []
tags = [t.strip() for t in self.tags.split(",")]
return [t for t in tags if t]
@cached_property
def linked_taglist(self):
"""
Returns the tags in the original order and format,
with link to tag page
"""
return [(tag, url_for('frontend.tag', slug=slugify(tag)))
for tag in self.taglist]
@cached_property
def domain(self):
if not self.link:
return ''
return domain(self.link)
@cached_property
def json(self):
"""
Returns dict of safe attributes for passing into
a JSON request.
"""
return dict(post_id=self.id,
score=self.score,
title=self.title,
link=self.link,
description=self.description,
num_comments=self.num_comments,
author=self.author.username)
@cached_property
def access_name(self):
return {
Post.PUBLIC: "public",
Post.FRIENDS: "friends",
Post.PRIVATE: "private"
}.get(self.access, "public")
def can_access(self, user=None):
if self.access == self.PUBLIC:
return True
if user is None:
return False
if user.is_moderator or user.id == self.author_id:
return True
return self.access == self.FRIENDS and self.author_id in user.friends
@cached_property
def comments(self):
"""
Returns comments in tree. Each parent comment has a "comments"
attribute appended and a "depth" attribute.
"""
from newsmeme.models.comments import Comment
comments = Comment.query.filter(Comment.post_id == self.id).all()
def _get_comments(parent, depth):
parent.comments = []
parent.depth = depth
for comment in comments:
if comment.parent_id == parent.id:
parent.comments.append(comment)
_get_comments(comment, depth + 1)
parents = [c for c in comments if c.parent_id is None]
for parent in parents:
_get_comments(parent, 0)
return parents
def _url(self, _external=False):
return url_for('post.view',
post_id=self.id,
slug=self.slug,
_external=_external)
@cached_property
def url(self):
return self._url()
@cached_property
def permalink(self):
return self._url(True)
@cached_property
def markdown(self):
return Markup(markdown(self.description or ''))
@cached_property
def slug(self):
return slugify(self.title or '')[:80]
class Comment(db.Model):
__tablename__ = "comments"
PER_PAGE = 20
query_class = CommentQuery
id = db.Column(db.Integer, primary_key=True)
author_id = db.Column(db.Integer,
db.ForeignKey(User.id, ondelete='CASCADE'),
nullable=False)
post_id = db.Column(db.Integer,
db.ForeignKey(Post.id, ondelete='CASCADE'),
nullable=False)
parent_id = db.Column(db.Integer,
db.ForeignKey("comments.id", ondelete='CASCADE'))
comment = db.Column(db.UnicodeText)
date_created = db.Column(db.DateTime, default=datetime.utcnow)
score = db.Column(db.Integer, default=1)
votes = db.Column(DenormalizedText)
author = db.relation(User, innerjoin=True, lazy="joined")
post = db.relation(Post, innerjoin=True, lazy="joined")
parent = db.relation('Comment', remote_side=[id])
__mapper_args__ = {'order_by': id.asc()}
class Permissions(object):
def __init__(self, obj):
self.obj = obj
@cached_property
def default(self):
return Permission(UserNeed(self.obj.author_id)) & moderator
@cached_property
def edit(self):
return self.default
@cached_property
def delete(self):
return self.default
@cached_property
def vote(self):
needs = [UserNeed(user_id) for user_id in self.obj.votes]
needs.append(UserNeed(self.obj.author_id))
return auth & Denial(*needs)
def __init__(self, *args, **kwargs):
super(Comment, self).__init__(*args, **kwargs)
self.votes = self.votes or set()
@cached_property
def permissions(self):
return self.Permissions(self)
def vote(self, user):
votes_copy = self.votes.copy()
votes_copy.add(user.id)
self.votes = votes_copy.copy()
def _url(self, _external=False):
return '%s#comment-%d' % (self.post._url(_external), self.id)
@cached_property
def url(self):
return self._url()
@cached_property
def permalink(self):
return self._url(True)
@cached_property
def markdown(self):
return Markup(markdown(self.comment or ''))
return self._url(True)
@cached_property
def markdown(self):
return Markup(markdown(self.description or ''))
@cached_property
def slug(self):
return slugify(self.title or '')[:80]
post_tags = db.Table(
"post_tags", db.Model.metadata,
db.Column("post_id",
db.Integer,
db.ForeignKey('posts.id', ondelete='CASCADE'),
primary_key=True),
db.Column("tag_id",
db.Integer,
db.ForeignKey('tags.id', ondelete='CASCADE'),
primary_key=True))
class TagQuery(BaseQuery):
def cloud(self):
tags = self.filter(Tag.num_posts > 0).all()
if not tags:
return []
