class Tag(db.Model):
__tablename__ = "tags"
query_class = TagQuery
id = db.Column(db.Integer, primary_key=True)
slug = db.Column(db.Unicode(80), unique=True)
posts = db.dynamic_loader(Post, secondary=post_tags, query_class=PostQuery)
_name = db.Column("name", db.Unicode(80), unique=True)
def __init__(self, *args, **kwargs):
super(Tag, self).__init__(*args, **kwargs)
def __str__(self):
return self.name
def _get_name(self):
return self._name
def _set_name(self, name):
self._name = name.lower().strip()
self.slug = slugify(name)
name = db.synonym("_name", descriptor=property(_get_name, _set_name))
@cached_property
def url(self):
return url_for("frontend.tag", slug=self.slug)
num_posts = db.column_property(
db.select([db.func.count(post_tags.c.post_id)]).\
where(db.and_(post_tags.c.tag_id==id,
Post.id==post_tags.c.post_id)).as_scalar())
class Comment(db.Model):
__tablename__ = "comments"
PER_PAGE = 40
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(50))
nickname = db.Column(db.Unicode(50))
website = db.Column(db.String(100))
class UserCode(db.Model):
__tablename__ = 'usercode'
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.String(20), nullable=False)
role = db.Column(db.Integer, default=User.MEMBER)
def __init__(self, *args, **kwargs):
super(UserCode, self).__init__(*args, **kwargs)
def __str__(self):
return self.code
def __repr__(self):
return "<%s>" % self
class Twitter(db.Model):
__tablename__ = 'twitter'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey(User.id, ondelete='CASCADE'),
nullable=False,
unique=True)
token = db.Column(db.String(50))
token_secret = db.Column(db.String(50))
def __init__(self, *args, **kwargs):
super(Twitter, self).__init__(*args, **kwargs)
def __str__(self):
return self.user_id
def __repr__(self):
return "<%s>" % self
class Link(db.Model):
__tablename__ = 'links'
PER_PAGE = 80
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(50), nullable=False)
link = db.Column(db.String(100), nullable=False)
logo = db.Column(db.String(100))
description = db.Column(db.Unicode(100))
email = db.Column(db.String(50))
passed = db.Column(db.Boolean, default=False)
create_date = db.Column(db.DateTime, default=datetime.utcnow)
def __init__(self, *args, **kwargs):
super(Link, self).__init__(*args, **kwargs)
#TODO A
def __str__(self):
return self.name
class Link(db.Model):
__tablename__ = "links"
PER_PAGE = 80
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(50), nullable=False)
link = db.Column(db.String(100), nullable=False)
logo = db.Column(db.String(100))
description = db.Column(db.Unicode(100))
email = db.Column(db.String(50))
passed = db.Column(db.Boolean, default=False)
created_date = db.Column(db.DateTime, default=datetime.utcnow)
class Permissions(object):
def __init__(self, obj):
self.obj = obj
@cached_property
def edit(self):
return moderator
@cached_property
def delete(self):
return moderator
def __init__(self, *args, **kwargs):
super(Link, self).__init__(*args, **kwargs)
@cached_property
def permissions(self):
return self.Permissions(self)
def __str__(self):
return self.name
class Post(db.Model):
__tablename__ = 'posts'
PER_PAGE = 40
query_class = PostQuery
id = db.Column(db.Integer, primary_key=True)
author_id = db.Column(db.Integer) #TODO A
_title = db.Column("title", db.Unicode(100), index=True)
_slug = db.Column("slug", db.Unicode(50), unique=True, index=True)
content = db.Column(db.UnicodeText)
num_comments = db.Column(db.Integer, default=0)
created_date = db.Column(db.DateTime, default=datetime.utcnow)
update_time = db.Column(db.DateTime,
default=datetime.utcnow,
onupdate=datetime.utcnow)
def __init__(self, *args, **kwargs):
super(Post, self).__init__(*args, **kwargs)
def __str__(self):
return self.title
def __repr__(self):
return "<%s>" % self
class User(db.Model):
__tablename__ = 'users'
query_class = UserQuery
PER_PAGE = 50
TWEET_PER_PAGE = 30
MEMBER = 100
MODERATOR = 200
ADMIN = 300
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True)
nickname = db.Column(db.String(20))
email = db.Column(db.String(100), unique=True, nullable=False)
_password = db.Column("password", db.String(80), nullable=False)
role = db.Column(db.Integer, default=MEMBER)
activation_key = db.Column(db.String(40))
date_joined = db.Column(db.DateTime, default=datetime.utcnow)
last_login = db.Column(db.DateTime, default=datetime.utcnow)
last_request = db.Column(db.DateTime, default=datetime.utcnow)
block = db.Column(db.Boolean, default=False)
class Permissions(object):
def __init__(self, obj):
self.obj = obj
@cached_property
def edit(self):
return Permission(UserNeed(self.obj.id)) & admin
def __init__(self, *args, **kwargs):
super(User, self).__init__(*args, **kwargs)
def __str__(self):
return self.nickname
def __repr__(self):
return "<%s>" % self
@cached_property
def permissions(self):
return self.Permissions(self)
def _get_password(self):
return self._password
def _set_password(self, password):
self._password = hashlib.md5(password).hexdigest()
password = db.synonym("_password",
descriptor=property(_get_password, _set_password))
def check_password(self, password):
if self.password is None:
return False
return self.password == hashlib.md5(password).hexdigest()
@cached_property
def provides(self):
needs = [RoleNeed('authenticated'), UserNeed(self.id)]
if self.is_moderator:
needs.append(RoleNeed('moderator'))
if self.is_admin:
needs.append(RoleNeed('admin'))
return needs
@property
def is_moderator(self):
return self.role >= self.MODERATOR
@property
def is_admin(self):
return self.role >= self.ADMIN
@cached_property
def twitter_api(self):
if self.twitter and self.twitter.token \
and self.twitter.token_secret:
api = twitter.Api(current_app.config['TWITTER_KEY'],
current_app.config['TWITTER_SECRET'],
self.twitter.token, self.twitter.token_secret)
else:
api = None
return api
@cached_property
def tweets(self):
api = self.twitter_api
if api:
info = api.VerifyCredentials()
try:
tweets = api.GetUserTimeline(screen_name=info.screen_name,
count=self.TWEET_PER_PAGE)
except:
return []
else:
return []
return tweets
def post_twitter(self, content):
api = self.twitter_api
if api:
status = api.PostUpdate(content)
else:
return False
return True
class Post(db.Model):
__tablename__ = 'posts'
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("title", db.Unicode(100), index=True)
_slug = db.Column("slug", db.Unicode(50), unique=True, index=True)
content = db.Column(db.UnicodeText)
num_comments = db.Column(db.Integer, default=0)
created_date = db.Column(db.DateTime, default=datetime.utcnow)
update_time = db.Column(db.DateTime,
default=datetime.utcnow,
onupdate=datetime.utcnow)
_tags = db.Column("tags", db.Unicode(100), index=True)
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 edit(self):
return Permission(UserNeed(self.obj.author_id))
@cached_property
def delete(self):
return Permission(UserNeed(self.obj.author_id)) & moderator
def __init__(self, *args, **kwargs):
super(Post, self).__init__(*args, **kwargs)
def __str__(self):
return self.title
def __repr__(self):
return "<%s>" % self
@cached_property
def permissions(self):
return self.Permissions(self)
def _get_title(self):
return self._title
def _set_title(self, title):
self._title = title.lower().strip()
if self.slug is None:
self.slug = slugify(title)[:50]
title = db.synonym("_title", descriptor=property(_get_title, _set_title))
def _get_slug(self):
return self._slug
def _set_slug(self, slug):
if slug:
self._slug = slugify(slug)
slug = db.synonym("_slug", descriptor=property(_get_slug, _set_slug))
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)
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 summary(self):
s = re.findall(r'(<p id="more\-(\d+)">)', self.content)
if not s:
return self.content
p, more_id = s[0]
addlink = '<p><a class="more-link" href="%s#more-%s">%s</a></p>' % (
self.url, more_id, _("Read more..."))
return self.content.split(p)[0] + addlink
@cached_property
def comments(self):
"""
Returns comments in tree. Each parent comment has a "comments"
attribute appended and a "depth" attribute.
"""
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
@cached_property
def json(self):
"""
Returns dict of safe attributes for passing into
a JSON request.
"""
return dict(id=self.id,
title=self.title,
content=self.content,
author=self.author.username)
def _url(self, _external=False):
return url_for('frontend.post',
year=self.created_date.year,
month=self.created_date.month,
day=self.created_date.day,
slug=self.slug,
_external=_external)
@cached_property
def url(self):
return self._url()
@cached_property
def permalink(self):
return self._url(True)
class Comment(db.Model):
__tablename__ = "comments"
PER_PAGE = 40
id = db.Column(db.Integer, primary_key=True)
post_id = db.Column(db.Integer,
db.ForeignKey(Post.id, ondelete='CASCADE'),
nullable=False)
author_id = db.Column(db.Integer, db.ForeignKey(User.id,
ondelete='CASCADE'))
parent_id = db.Column(db.Integer,
db.ForeignKey("comments.id", ondelete='CASCADE'))
email = db.Column(db.String(50))
nickname = db.Column(db.Unicode(50))
website = db.Column(db.String(100))
comment = db.Column(db.UnicodeText)
created_date = db.Column(db.DateTime, default=datetime.utcnow)
ip = db.Column(db.Integer)
_author = db.relation(User, backref="posts", 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 reply(self):
return Permission(UserNeed(self.obj.post.author_id))
@cached_property
def delete(self):
return Permission(UserNeed(self.obj.author_id),
UserNeed(self.obj.post.author_id)) & moderator
def __init__(self, *args, **kwargs):
super(Comment, self).__init__(*args, **kwargs)
@cached_property
def permissions(self):
return self.Permissions(self)
def _get_author(self):
if self._author:
return self._author
return storage(email=self.email,
nickname=self.nickname,
website=self.website)
def _set_author(self, author):
self._author = author
author = db.synonym("_author",
descriptor=property(_get_author, _set_author))
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 ''))
slug=self.slug,
_external=_external)
@cached_property
def url(self):
return self._url()
@cached_property
def permalink(self):
return self._url(True)
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 []
class Tag(db.Model):
__tablename__ = 'tags'
id = db.Column(db.Integer, primary_key=True)
slug = db.Column(db.Unicode(80), unique=True)
