def recommended_users(self):
res = db.fetchall(
"SELECT u.id, u.login FROM posts.recommendations r "
"JOIN users.logins u ON u.id=r.user_id "
"WHERE post_id=%s AND comment_id=0;",
[unb26(self.id)],
)
return [User.from_data(r[0], r[1]) for r in res]
def recipients(self):
res = db.fetchall(
"SELECT u.id, u.login FROM posts.recipients r "
"JOIN users.logins u ON u.id=r.user_id "
"WHERE r.post_id=%s;",
[unb26(self.id)],
)
return [User.from_data(r[0], r[1]) for r in res]
def __init__(self,
post,
id,
to_comment_id=None,
author=None,
created=None,
text=None,
archive=False,
files=None):
if post and id:
if isinstance(post, Post):
self.post = post
elif isinstance(post, (int, long)):
self.post = Post.from_data(b26(post))
else:
self.post = Post.from_data(post)
self.id = int(id)
res = db.fetchone(
"SELECT c.author, u.login, i.name, i.avatar, "
"c.to_comment_id, "
"c.anon_login, "
"c.created at time zone %s AS created, "
"c.text, c.files, c.updated "
"FROM posts.comments c "
"JOIN users.logins u ON u.id=c.author "
"JOIN users.info i ON u.id=i.id "
"WHERE post_id=%s AND comment_id=%s;",
[self.post.tz, unb26(self.post.id), self.id])
if not res:
raise CommentNotFound(self.post.id, id)
if author:
self.author = author
else:
login = res['anon_login'] or res['login']
self.author = User.from_data(res['author'],
login,
info={
'name': res['name'] or login,
'avatar': res['avatar']
})
self.to_comment_id = to_comment_id or res['to_comment_id']
self.created = created or res['created']
self.text = text or res['text']
self.recommendations = 0
self.recommended = False
self.files = res['files']
self.updated = res['updated']
self.comments = []
self.archive = archive
if isinstance(files, (list, tuple)):
self.files = files
def domain_owner(domain):
if domain == settings.domain:
return User.from_data(None, None)
if domain.endswith(settings.domain):
return User("login", domain[0 : domain.find(settings.domain) - 1])
res = db.fetchone("SELECT id FROM users.domains WHERE domain=%s;", [domain]) # , _cache=600)
if res:
return User(res[0])
raise UserNotFound
def domain_owner(domain):
if domain == settings.domain:
return User.from_data(None, None)
if domain.endswith(settings.domain):
return User('login', domain[0:domain.find(settings.domain) - 1])
res = db.fetchone("SELECT id FROM users.domains WHERE domain=%s;",
[domain]) #, _cache=600)
if res:
return User(res[0])
raise UserNotFound
def __init__(self, post, id, to_comment_id=None, author=None,
created=None, text=None, archive=False,
files=None):
if post and id:
if isinstance(post, Post):
self.post = post
elif isinstance(post, (int, long)):
self.post = Post.from_data(b26(post))
else:
self.post = Post.from_data(post)
self.id = int(id)
res = db.fetchone("SELECT c.author, u.login, i.name, i.avatar, "
"c.to_comment_id, "
"c.anon_login, "
"c.created at time zone %s AS created, "
"c.text, c.files, c.updated "
"FROM posts.comments c "
"JOIN users.logins u ON u.id=c.author "
"JOIN users.info i ON u.id=i.id "
"WHERE post_id=%s AND comment_id=%s;",
[self.post.tz, unb26(self.post.id), self.id])
if not res:
raise CommentNotFound(self.post.id, id)
if author:
self.author = author
else:
login = res['anon_login'] or res['login']
self.author = User.from_data(res['author'], login,
info={'name': res['name'] or login,
'avatar': res['avatar']})
self.to_comment_id = to_comment_id or res['to_comment_id']
self.created = created or res['created']
self.text = text or res['text']
self.recommendations = 0
self.recommended = False
self.files = res['files']
self.updated = res['updated']
self.comments = []
self.archive = archive
if isinstance(files, (list, tuple)):
self.files = files
def recommended_users(self):
res = db.fetchall("SELECT u.id, u.login FROM posts.recommendations r "
"JOIN users.logins u ON u.id=r.user_id "
"WHERE post_id=%s AND comment_id=0;",
[unb26(self.id)])
return [ User.from_data(r[0], r[1]) for r in res ]
def recipients(self):
res = db.fetchall("SELECT u.id, u.login FROM posts.recipients r "
"JOIN users.logins u ON u.id=r.user_id "
"WHERE r.post_id=%s;", [unb26(self.id)])
return [ User.from_data(r[0], r[1]) for r in res ]
def __init__(self, post_id, author=None, type=None, tags=None,
private=None, created=None, title=None, link=None, text=None,
edited=None, tz=settings.timezone, archive=None, files=None,
pinned=None, tune=None):
self._comments_count = None
if post_id:
if isinstance(post_id, (int, long)):
if post_id == 0:
raise PostNotFound(post_id)
self.id = b26(post_id)
else:
self.id = post_id.lower()
res = db.fetchone("SELECT p.author, u.login, p.type, p.private, "
"p.created at time zone %s AS created, "
"p.tags, p.title, p.link, p.text, p.files, "
"p.edited, p.archive, p.pinned, p.tune "
"FROM posts.posts p "
"JOIN users.logins u ON p.author=u.id "
"WHERE p.id=%s;",
[tz, unb26(self.id)])
if not res:
raise PostNotFound(post_id)
self.author = User.from_data(res[0], res[1])
self.created = res['created']
if type is not None:
self.type = type
else:
self.type = res['type']
if private is not None:
self.private = private
else:
self.private = res['private']
if tags is not None:
self.tags = [ t.decode('utf8').strip() if isinstance(t, str) else t for t in tags ]
else:
self.tags = res['tags']
if title is not None:
if isinstance(title, str):
self.title = title.decode('utf8').strip()[:128]
elif isinstance(title, unicode):
self.title = title.strip()[:128]
else:
self.title = res['title']
if link is not None:
self.link = link
else:
self.link = res['link']
if text is not None:
if isinstance(text, str):
self.text = text.decode('utf8').strip()[:1048576]
elif isinstance(text, unicode):
self.text = text.strip()[:1048576]
if len(self.text) < 3:
raise PostTextError
else:
self.text = res['text']
if edited is not None:
self.edited = edited
else:
self.edited = res['edited']
self.editable = not self.edited and \
self.created + \
timedelta(seconds=settings.edit_expire) >= \
datetime.now() # and \
#self.comments_count() == 0
if archive is not None:
self.archive = archive
else:
self.archive = res['archive']
if pinned is not None:
self.pinned = pinned
else:
self.pinned = res['pinned']
if tune is not None:
self.tune = tune
else:
self.tune = res['tune']
if isinstance(files, (list, tuple)):
self.files = files
else:
self.files = res['files']
#elif not author:
# raise PostAuthorError
#elif not text:
# raise PostTextError
else:
self.id = None
self.author = author
self.type = type
self.tags = tags
self.private = private
if isinstance(title, str):
self.title = title.decode('utf-8').strip()[:128]
elif isinstance(title, unicode):
self.title = title.strip()[:128]
else:
self.title = title
self.link = link
if isinstance(text, str):
try:
self.text = text.decode('utf-8').strip()[:1048576]
except UnicodeDecodeError:
raise PostTextError
elif isinstance(text, unicode):
self.text = text.strip()[:1048576]
else:
self.text = text
self.created = created
self.edited = False
self.editable = True
self.archive = False if archive is None else archive
self.pinned = False if pinned is None else pinned
self.tune = tune
self.tz = tz
def comments(self, last=False, all=False, offset=None, limit=None,
cuser=None):
if last:
lim = " LIMIT %d" % limit if limit else ''
offset = 0
order = ' DESC'
elif all:
lim = ''
offset = 0
order = ' ASC'
else:
if not offset:
offset = 0
lim = " LIMIT %d" % limit if limit else ''
order = ' ASC'
if isinstance(cuser, User) and cuser.id:
res = db.fetchall("SELECT c.comment_id, c.to_comment_id,"
"c.author AS user_id, "
"CASE WHEN c.anon_login IS NOT NULL "
"THEN c.anon_login ELSE u1.login END AS login,"
"c.created at time zone %%s AS created, "
"c.text, c.files, "
"c.updated at time zone %%s AS updated, "
"CASE WHEN rc.comment_id IS NOT NULL "
"THEN true ELSE false END AS is_rec, "
"ur.user_id AS recommended, "
"ub.user_id AS bookmarked, "
"ui1.name, ui1.avatar "
"FROM posts.comments c "
"JOIN users.logins u1 ON c.author=u1.id "
"LEFT OUTER JOIN users.info ui1 "
"ON ui1.id=c.author "
"LEFT OUTER JOIN posts.recommendations rc "
"ON rc.post_id=c.post_id "
"AND rc.rcid=c.comment_id "
"LEFT OUTER JOIN posts.recommendations ur "
"ON ur.user_id=%%s "
"AND ur.post_id=c.post_id "
"AND ur.comment_id=c.comment_id "
"LEFT OUTER JOIN posts.bookmarks ub "
"ON ub.user_id=%%s "
"AND ub.post_id=c.post_id "
"AND ub.comment_id=c.comment_id "
"WHERE c.post_id=%%s AND c.comment_id>=%%s "
"ORDER BY c.created%s%s;" % (order, lim),
[self.tz, self.tz, cuser.id, cuser.id, unb26(self.id),
offset])
else:
res = db.fetchall("SELECT c.comment_id, c.to_comment_id,"
"c.author AS user_id, ui1.name,"
"CASE WHEN c.anon_login IS NOT NULL "
"THEN c.anon_login ELSE u1.login END AS login,"
"c.created at time zone %%s AS created, "
"c.text, c.files, "
"c.updated at time zone %%s AS updated, "
"CASE WHEN rc.comment_id IS NOT NULL "
"THEN true ELSE false END AS is_rec, "
"false AS recommended, "
"false AS bookmarked, "
"ui1.avatar "
"FROM posts.comments c "
"JOIN users.logins u1 ON c.author=u1.id "
"LEFT OUTER JOIN users.info ui1 "
"ON ui1.id=c.author "
"LEFT OUTER JOIN posts.recommendations rc "
"ON rc.post_id=c.post_id "
"AND rc.rcid=c.comment_id "
"WHERE c.post_id=%%s AND c.comment_id>=%%s "
"ORDER BY c.created%s%s;" % (order, lim),
[self.tz, self.tz, unb26(self.id), offset])
if last:
res.reverse()
if cuser:
unr = db.fetchall("SELECT comment_id FROM posts.unread_comments "
"WHERE user_id=%s AND post_id=%s;",
[cuser.id, unb26(self.id)])
unread = { r['comment_id']: 1 for r in unr }
else:
unread = {}
comments = []
for c in res:
author = User.from_data(c['user_id'], c['login'],
info={'name': c['name'], 'avatar': c['avatar']})
unr = True if c['comment_id'] in unread else False
comment = Comment.from_data(self, id=c['comment_id'],
to_comment_id=c['to_comment_id'],
author=author,
created=c['created'],
text=c['text'],
recommended=c['recommended'],
bookmarked=c['bookmarked'],
is_rec=c['is_rec'],
files=c['files'],
updated=c['updated'],
unread=unr)
comments.append(comment)
if not limit and not offset:
redis = RedisPool(settings.storage_socket)
redis.set('cmnt_cnt.%s' % unb26(self.id), len(comments))
return comments