758 lines
16 KiB
Python
758 lines
16 KiB
Python
from drama.classes import *
|
|
from flask import g
|
|
from sqlalchemy.orm import joinedload, aliased
|
|
|
|
import re
|
|
|
|
|
|
def get_user(username, v=None, nSession=None, graceful=False):
|
|
|
|
username = username.replace('\\', '')
|
|
username = username.replace('_', '\_')
|
|
username = username.replace('%', '')
|
|
|
|
if not nSession:
|
|
nSession = g.db
|
|
|
|
user = nSession.query(
|
|
User
|
|
).filter(
|
|
or_(
|
|
User.username.ilike(username),
|
|
User.original_username.ilike(username)
|
|
)
|
|
).first()
|
|
|
|
if not user:
|
|
if not graceful:
|
|
abort(404)
|
|
else:
|
|
return None
|
|
|
|
if v:
|
|
block = nSession.query(UserBlock).filter(
|
|
or_(
|
|
and_(
|
|
UserBlock.user_id == v.id,
|
|
UserBlock.target_id == user.id
|
|
),
|
|
and_(UserBlock.user_id == user.id,
|
|
UserBlock.target_id == v.id
|
|
)
|
|
)
|
|
).first()
|
|
|
|
user._is_blocking = block and block.user_id == v.id
|
|
user._is_blocked = block and block.target_id == v.id
|
|
|
|
return user
|
|
|
|
def get_account(base36id, v=None, nSession=None, graceful=False):
|
|
|
|
if not nSession:
|
|
nSession = g.db
|
|
|
|
if isinstance(base36id, str): id = base36decode(base36id)
|
|
else: id = base36id
|
|
|
|
user = nSession.query(User
|
|
).filter(
|
|
User.id == id
|
|
).first()
|
|
|
|
if not user:
|
|
if not graceful:
|
|
abort(404)
|
|
else:
|
|
return None
|
|
|
|
if v:
|
|
block = nSession.query(UserBlock).filter(
|
|
or_(
|
|
and_(
|
|
UserBlock.user_id == v.id,
|
|
UserBlock.target_id == user.id
|
|
),
|
|
and_(UserBlock.user_id == user.id,
|
|
UserBlock.target_id == v.id
|
|
)
|
|
)
|
|
).first()
|
|
|
|
user._is_blocking = block and block.user_id == v.id
|
|
user._is_blocked = block and block.target_id == v.id
|
|
|
|
return user
|
|
|
|
|
|
def get_post(pid, v=None, graceful=False, nSession=None, **kwargs):
|
|
|
|
if isinstance(pid, str):
|
|
i = base36decode(pid)
|
|
else:
|
|
i = pid
|
|
|
|
nSession = nSession or kwargs.get("session")or g.db
|
|
|
|
if v:
|
|
vt = nSession.query(Vote).filter_by(
|
|
user_id=v.id, submission_id=i).subquery()
|
|
mod = nSession.query(ModRelationship).filter_by(
|
|
user_id=v.id, accepted=True, invite_rescinded=False).subquery()
|
|
boardblocks = nSession.query(
|
|
BoardBlock).filter_by(user_id=v.id).subquery()
|
|
blocking = v.blocking.subquery()
|
|
|
|
items = nSession.query(
|
|
Submission,
|
|
vt.c.vote_type,
|
|
aliased(ModRelationship, alias=mod),
|
|
boardblocks.c.id,
|
|
blocking.c.id,
|
|
# aliased(ModAction, alias=exile)
|
|
).options(
|
|
joinedload(Submission.author).joinedload(User.title)
|
|
)
|
|
|
|
if v.admin_level>=4:
|
|
items=items.options(joinedload(Submission.oauth_app))
|
|
|
|
items=items.filter(Submission.id == i
|
|
).join(
|
|
vt,
|
|
vt.c.submission_id == Submission.id,
|
|
isouter=True
|
|
).join(
|
|
mod,
|
|
mod.c.board_id == Submission.board_id,
|
|
isouter=True
|
|
).join(
|
|
boardblocks,
|
|
boardblocks.c.board_id == Submission.board_id,
|
|
isouter=True
|
|
).join(
|
|
blocking,
|
|
blocking.c.target_id == Submission.author_id,
|
|
isouter=True
|
|
# ).join(
|
|
# exile,
|
|
# and_(exile.c.target_submission_id==Submission.id, exile.c.board_id==Submission.original_board_id),
|
|
# isouter=True
|
|
).first()
|
|
|
|
if not items and not graceful:
|
|
abort(404)
|
|
|
|
x = items[0]
|
|
x._voted = items[1] or 0
|
|
x._is_guildmaster = items[2] or 0
|
|
x._is_blocking_guild = items[3] or 0
|
|
x._is_blocking = items[4] or 0
|
|
# x._is_exiled_for=items[5] or 0
|
|
|
|
else:
|
|
items = nSession.query(
|
|
Submission,
|
|
# aliased(ModAction, alias=exile)
|
|
).options(
|
|
joinedload(Submission.author).joinedload(User.title)
|
|
# ).join(
|
|
# exile,
|
|
# and_(exile.c.target_submission_id==Submission.id, exile.c.board_id==Submission.original_board_id),
|
|
# isouter=True
|
|
).filter(Submission.id == i).first()
|
|
|
|
if not items and not graceful:
|
|
abort(404)
|
|
|
|
x=items
|
|
# x._is_exiled_for=items[1] or 0
|
|
|
|
return x
|
|
|
|
|
|
def get_posts(pids, sort="hot", v=None):
|
|
|
|
if not pids:
|
|
return []
|
|
|
|
pids=tuple(pids)
|
|
|
|
# exile=g.db.query(ModAction).options(
|
|
# lazyload('*')
|
|
# ).filter(
|
|
# ModAction.kind=="exile_user",
|
|
# ModAction.target_submission_id.in_(pids)
|
|
# ).subquery()
|
|
|
|
if v:
|
|
vt = g.db.query(Vote).filter(
|
|
Vote.submission_id.in_(pids),
|
|
Vote.user_id==v.id
|
|
).subquery()
|
|
|
|
mod = g.db.query(ModRelationship).filter_by(
|
|
user_id=v.id, accepted=True, invite_rescinded=False).subquery()
|
|
|
|
boardblocks = g.db.query(BoardBlock).filter_by(
|
|
user_id=v.id).subquery()
|
|
blocking = v.blocking.subquery()
|
|
blocked = v.blocked.subquery()
|
|
subs = g.db.query(Subscription).filter_by(user_id=v.id, is_active=True).subquery()
|
|
|
|
query = g.db.query(
|
|
Submission,
|
|
vt.c.vote_type,
|
|
aliased(ModRelationship, alias=mod),
|
|
boardblocks.c.id,
|
|
blocking.c.id,
|
|
blocked.c.id,
|
|
subs.c.id,
|
|
# aliased(ModAction, alias=exile)
|
|
).options(
|
|
joinedload(Submission.author).joinedload(User.title)
|
|
).filter(
|
|
Submission.id.in_(pids)
|
|
).join(
|
|
vt, vt.c.submission_id==Submission.id, isouter=True
|
|
).join(
|
|
mod,
|
|
mod.c.board_id == Submission.board_id,
|
|
isouter=True
|
|
).join(
|
|
boardblocks,
|
|
boardblocks.c.board_id == Submission.board_id,
|
|
isouter=True
|
|
).join(
|
|
blocking,
|
|
blocking.c.target_id == Submission.author_id,
|
|
isouter=True
|
|
).join(
|
|
blocked,
|
|
blocked.c.user_id == Submission.author_id,
|
|
isouter=True
|
|
).join(
|
|
subs,
|
|
subs.c.board_id == Submission.board_id,
|
|
isouter=True
|
|
# ).join(
|
|
# exile,
|
|
# and_(exile.c.target_submission_id==Submission.id, exile.c.board_id==Submission.original_board_id),
|
|
# isouter=True
|
|
).order_by(None).all()
|
|
|
|
posts=[x for x in query]
|
|
|
|
output = [p[0] for p in query]
|
|
for i in range(len(output)):
|
|
output[i]._voted = posts[i][1] or 0
|
|
output[i]._is_guildmaster = posts[i][2] or 0
|
|
output[i]._is_blocking_guild = posts[i][3] or 0
|
|
output[i]._is_blocking = posts[i][4] or 0
|
|
output[i]._is_blocked = posts[i][5] or 0
|
|
output[i]._is_subscribed = posts[i][6] or 0
|
|
# output[i]._is_exiled_for=posts[i][7] or 0
|
|
else:
|
|
query = g.db.query(
|
|
Submission,
|
|
# aliased(ModAction, alias=exile)
|
|
).options(
|
|
joinedload(Submission.author).joinedload(User.title)
|
|
).filter(Submission.id.in_(pids)
|
|
# ).join(
|
|
# exile,
|
|
# and_(exile.c.target_submission_id==Submission.id, exile.c.board_id==Submission.original_board_id),
|
|
# isouter=True
|
|
).order_by(None).all()
|
|
|
|
output=[x for x in query]
|
|
|
|
# output=[]
|
|
# for post in posts:
|
|
# p=post[0]
|
|
# p._is_exiled_for=post[1] or 0
|
|
# output.append(p)
|
|
|
|
return sorted(output, key=lambda x: pids.index(x.id))
|
|
|
|
|
|
def get_post_with_comments(pid, sort="top", v=None):
|
|
|
|
post = get_post(pid, v=v)
|
|
|
|
if v:
|
|
votes = g.db.query(CommentVote).filter_by(user_id=v.id).subquery()
|
|
|
|
blocking = v.blocking.subquery()
|
|
|
|
blocked = v.blocked.subquery()
|
|
|
|
comms = g.db.query(
|
|
Comment,
|
|
votes.c.vote_type,
|
|
blocking.c.id,
|
|
blocked.c.id,
|
|
).options(
|
|
joinedload(Comment.author)
|
|
)
|
|
if v.admin_level >=4:
|
|
comms=comms.options(joinedload(Comment.oauth_app))
|
|
|
|
comms=comms.filter(
|
|
Comment.parent_submission == post.id
|
|
).join(
|
|
votes,
|
|
votes.c.comment_id == Comment.id,
|
|
isouter=True
|
|
).join(
|
|
blocking,
|
|
blocking.c.target_id == Comment.author_id,
|
|
isouter=True
|
|
).join(
|
|
blocked,
|
|
blocked.c.user_id == Comment.author_id,
|
|
isouter=True
|
|
)
|
|
|
|
if sort == "top":
|
|
comments = comms.order_by(Comment.score.desc()).all()
|
|
elif sort == "bottom":
|
|
comments = comms.order_by(Comment.score.asc()).all()
|
|
elif sort == "new":
|
|
comments = comms.order_by(Comment.created_utc.desc()).all()
|
|
elif sort == "old":
|
|
comments = comms.order_by(Comment.created_utc.asc()).all()
|
|
elif sort == "controversial":
|
|
comments = sorted(comms.all(), key=lambda x: x[0].score_disputed, reverse=True)
|
|
elif sort == "random":
|
|
c = comms.all()
|
|
comments = random.sample(c, k=len(c))
|
|
else:
|
|
abort(422)
|
|
|
|
output = []
|
|
for c in comments:
|
|
comment = c[0]
|
|
if comment.author and comment.author.shadowbanned and not (v and v.id == comment.author_id): continue
|
|
comment._voted = c[1] or 0
|
|
comment._is_blocking = c[2] or 0
|
|
comment._is_blocked = c[3] or 0
|
|
output.append(comment)
|
|
|
|
post._preloaded_comments = output
|
|
|
|
else:
|
|
comms = g.db.query(
|
|
Comment
|
|
).options(
|
|
joinedload(Comment.author).joinedload(User.title)
|
|
).filter(
|
|
Comment.parent_submission == post.id
|
|
)
|
|
|
|
if sort == "top":
|
|
comments = comms.order_by(Comment.score.desc()).all()
|
|
elif sort == "bottom":
|
|
comments = comms.order_by(Comment.score.asc()).all()
|
|
elif sort == "new":
|
|
comments = comms.order_by(Comment.created_utc.desc()).all()
|
|
elif sort == "old":
|
|
comments = comms.order_by(Comment.created_utc.asc()).all()
|
|
elif sort == "controversial":
|
|
comments = sorted(comms.all(), key=lambda x: x.score_disputed, reverse=True)
|
|
elif sort == "random":
|
|
c = comms.all()
|
|
comments = random.sample(c, k=len(c))
|
|
else:
|
|
abort(422)
|
|
|
|
if random.random() < 0.1:
|
|
for comment in comments:
|
|
if comment.author and comment.author.shadowbanned:
|
|
rand = random.randint(500,1400)
|
|
vote = CommentVote(user_id=rand,
|
|
vote_type=random.choice([-1, 1]),
|
|
comment_id=comment.id)
|
|
g.db.add(vote)
|
|
try: g.db.flush()
|
|
except: g.db.rollback()
|
|
comment.upvotes = comment.ups
|
|
comment.downvotes = comment.downs
|
|
g.db.add(comment)
|
|
|
|
post._preloaded_comments = [x for x in comments if not (x.author and x.author.shadowbanned) or (v and v.id == x.author_id)]
|
|
|
|
return post
|
|
|
|
|
|
def get_comment(cid, nSession=None, v=None, graceful=False, **kwargs):
|
|
|
|
if isinstance(cid, str):
|
|
i = base36decode(cid)
|
|
else:
|
|
i = cid
|
|
|
|
nSession = nSession or kwargs.get('session') or g.db
|
|
|
|
exile = nSession.query(ModAction
|
|
).options(
|
|
lazyload('*')
|
|
).filter_by(
|
|
kind="exile_user"
|
|
).subquery()
|
|
|
|
if v:
|
|
blocking = v.blocking.subquery()
|
|
blocked = v.blocked.subquery()
|
|
vt = nSession.query(CommentVote).filter(
|
|
CommentVote.user_id == v.id,
|
|
CommentVote.comment_id == i).subquery()
|
|
|
|
mod=nSession.query(ModRelationship
|
|
).filter_by(
|
|
user_id=v.id,
|
|
accepted=True
|
|
).subquery()
|
|
|
|
|
|
items = nSession.query(
|
|
Comment,
|
|
vt.c.vote_type,
|
|
aliased(ModRelationship, alias=mod),
|
|
aliased(ModAction, alias=exile)
|
|
).options(
|
|
joinedload(Comment.author).joinedload(User.title)
|
|
)
|
|
|
|
if v.admin_level >=4:
|
|
items=items.options(joinedload(Comment.oauth_app))
|
|
|
|
items=items.filter(
|
|
Comment.id == i
|
|
).join(
|
|
vt,
|
|
vt.c.comment_id == Comment.id,
|
|
isouter=True
|
|
).join(
|
|
Comment.post,
|
|
isouter=True
|
|
).join(
|
|
mod,
|
|
mod.c.board_id==Submission.board_id,
|
|
isouter=True
|
|
).join(
|
|
exile,
|
|
and_(exile.c.target_comment_id==Comment.id, exile.c.board_id==Comment.original_board_id),
|
|
isouter=True
|
|
).first()
|
|
|
|
if not items and not graceful:
|
|
abort(404)
|
|
|
|
x = items[0]
|
|
x._voted = items[1] or 0
|
|
x._is_guildmaster=items[2] or 0
|
|
x._is_exiled_for=items[3] or 0
|
|
|
|
block = nSession.query(UserBlock).filter(
|
|
or_(
|
|
and_(
|
|
UserBlock.user_id == v.id,
|
|
UserBlock.target_id == x.author_id
|
|
),
|
|
and_(UserBlock.user_id == x.author_id,
|
|
UserBlock.target_id == v.id
|
|
)
|
|
)
|
|
).first()
|
|
|
|
x._is_blocking = block and block.user_id == v.id
|
|
x._is_blocked = block and block.target_id == v.id
|
|
|
|
else:
|
|
q = nSession.query(
|
|
Comment,
|
|
aliased(ModAction, alias=exile)
|
|
).options(
|
|
joinedload(Comment.author).joinedload(User.title)
|
|
).join(
|
|
exile,
|
|
and_(exile.c.target_comment_id==Comment.id, exile.c.board_id==Comment.original_board_id),
|
|
isouter=True
|
|
).filter(Comment.id == i).first()
|
|
|
|
if not q and not graceful:
|
|
abort(404)
|
|
|
|
x=q[0]
|
|
x._is_exiled_for=q[1]
|
|
|
|
|
|
return x
|
|
|
|
|
|
def get_comments(cids, v=None, nSession=None, sort="new",
|
|
load_parent=False, **kwargs):
|
|
|
|
if not cids:
|
|
return []
|
|
|
|
cids=tuple(cids)
|
|
|
|
nSession = nSession or kwargs.get('session') or g.db
|
|
|
|
exile=nSession.query(ModAction
|
|
).options(
|
|
lazyload('*')
|
|
).filter(
|
|
ModAction.kind=="exile_user",
|
|
ModAction.target_comment_id.in_(cids)
|
|
).distinct(ModAction.target_comment_id).subquery()
|
|
|
|
if v:
|
|
vt = nSession.query(CommentVote).filter(
|
|
CommentVote.comment_id.in_(cids),
|
|
CommentVote.user_id==v.id
|
|
).subquery()
|
|
|
|
mod=nSession.query(ModRelationship
|
|
).filter_by(
|
|
user_id=v.id,
|
|
accepted=True
|
|
).subquery()
|
|
|
|
|
|
|
|
query = nSession.query(
|
|
Comment,
|
|
aliased(CommentVote, alias=vt),
|
|
aliased(ModRelationship, alias=mod),
|
|
aliased(ModAction, alias=exile)
|
|
).options(
|
|
joinedload(Comment.author).joinedload(User.title)
|
|
)
|
|
|
|
if v.admin_level >=4:
|
|
query=query.options(joinedload(Comment.oauth_app))
|
|
|
|
if load_parent:
|
|
query = query.options(
|
|
joinedload(
|
|
Comment.parent_comment
|
|
).joinedload(
|
|
Comment.author
|
|
).joinedload(
|
|
User.title
|
|
)
|
|
)
|
|
|
|
query = query.join(
|
|
vt,
|
|
vt.c.comment_id == Comment.id,
|
|
isouter=True
|
|
).join(
|
|
Comment.post,
|
|
isouter=True
|
|
).join(
|
|
mod,
|
|
mod.c.board_id==Submission.board_id,
|
|
isouter=True
|
|
).join(
|
|
exile,
|
|
and_(exile.c.target_comment_id==Comment.id, exile.c.board_id==Comment.original_board_id),
|
|
isouter=True
|
|
).filter(
|
|
Comment.id.in_(cids)
|
|
)
|
|
|
|
|
|
|
|
query=query.options(
|
|
# contains_eager(Comment.post).contains_eager(Submission.board)
|
|
).order_by(None).all()
|
|
|
|
comments=[x for x in query]
|
|
|
|
output = [x[0] for x in comments]
|
|
for i in range(len(output)):
|
|
output[i]._voted = comments[i][1].vote_type if comments[i][1] else 0
|
|
output[i]._is_guildmaster = comments[i][2]
|
|
output[i]._is_exiled_for = comments[i][3]
|
|
|
|
|
|
|
|
else:
|
|
query = nSession.query(
|
|
Comment,
|
|
aliased(ModAction, alias=exile)
|
|
).options(
|
|
joinedload(Comment.author).joinedload(User.title),
|
|
joinedload(Comment.post).joinedload(Submission.board)
|
|
).filter(
|
|
Comment.id.in_(cids)
|
|
).join(
|
|
exile,
|
|
and_(exile.c.target_comment_id==Comment.id, exile.c.board_id==Comment.original_board_id),
|
|
isouter=True
|
|
).order_by(None).all()
|
|
|
|
comments=[x for x in query]
|
|
|
|
output=[x[0] for x in comments]
|
|
for i in range(len(output)):
|
|
output[i]._is_exiled_for=comments[i][1]
|
|
|
|
|
|
output = sorted(output, key=lambda x: cids.index(x.id))
|
|
|
|
return output
|
|
|
|
|
|
def get_board(bid, graceful=False):
|
|
|
|
return g.db.query(Board).first()
|
|
|
|
|
|
def get_guild(name, graceful=False):
|
|
|
|
return g.db.query(Board).first()
|
|
|
|
|
|
def get_domain(s):
|
|
|
|
# parse domain into all possible subdomains
|
|
parts = s.split(".")
|
|
domain_list = set([])
|
|
for i in range(len(parts)):
|
|
new_domain = parts[i]
|
|
for j in range(i + 1, len(parts)):
|
|
new_domain += "." + parts[j]
|
|
|
|
domain_list.add(new_domain)
|
|
|
|
domain_list = tuple(list(domain_list))
|
|
|
|
doms = [x for x in g.db.query(Domain).filter(
|
|
Domain.domain.in_(domain_list)).all()]
|
|
|
|
if not doms:
|
|
return None
|
|
|
|
# return the most specific domain - the one with the longest domain
|
|
# property
|
|
doms = sorted(doms, key=lambda x: len(x.domain), reverse=True)
|
|
|
|
return doms[0]
|
|
|
|
|
|
def get_title(x):
|
|
|
|
title = g.db.query(Title).filter_by(id=x).first()
|
|
|
|
if not title:
|
|
abort(400)
|
|
|
|
else:
|
|
return title
|
|
|
|
|
|
def get_mod(uid, bid):
|
|
|
|
mod = g.db.query(ModRelationship).filter_by(board_id=bid,
|
|
user_id=uid,
|
|
accepted=True,
|
|
invite_rescinded=False).first()
|
|
|
|
return mod
|
|
|
|
|
|
def get_application(client_id, graceful=False):
|
|
|
|
application = g.db.query(OauthApp).filter_by(client_id=client_id).first()
|
|
if not application and not graceful:
|
|
abort(404)
|
|
|
|
return application
|
|
|
|
|
|
def get_from_permalink(link, v=None):
|
|
|
|
if "@" in link:
|
|
|
|
name = re.search("/@(\w+)", link)
|
|
if name:
|
|
name=name.match(1)
|
|
return get_user(name)
|
|
|
|
if "+" in link:
|
|
|
|
x = re.search("/\+(\w+)$", link)
|
|
if x:
|
|
name=x.match(1)
|
|
return get_guild(name)
|
|
|
|
ids = re.search("://[^/]+\w+/post/(\w+)/[^/]+(/(\w+))?", link)
|
|
|
|
try:
|
|
post_id = ids.group(1)
|
|
comment_id = ids.group(3)
|
|
except: abort(400)
|
|
|
|
if comment_id:
|
|
return get_comment(int(comment_id), v=v)
|
|
|
|
else:
|
|
return get_post(int(post_id), v=v)
|
|
|
|
|
|
def get_from_fullname(fullname, v=None, graceful=False):
|
|
|
|
parts = fullname.split('_')
|
|
|
|
if len(parts) != 2:
|
|
if graceful:
|
|
return None
|
|
else:
|
|
abort(400)
|
|
|
|
kind = parts[0]
|
|
b36 = parts[1]
|
|
|
|
if kind == 't1':
|
|
return get_account(b36, v=v, graceful=graceful)
|
|
elif kind == 't2':
|
|
return get_post(b36, v=v, graceful=graceful)
|
|
elif kind == 't3':
|
|
return get_comment(b36, v=v, graceful=graceful)
|
|
elif kind == 't4':
|
|
return get_board(b36, graceful=graceful)
|
|
|
|
def get_txn(paypal_id):
|
|
|
|
txn= g.db.query(PayPalTxn).filter_by(paypal_id=paypal_id).first()
|
|
|
|
if not txn:
|
|
abort(404)
|
|
|
|
return txn
|
|
|
|
def get_txid(txid):
|
|
|
|
txn= g.db.query(PayPalTxn).filter_by(id=base36decode(txid)).first()
|
|
|
|
if not txn:
|
|
abort(404)
|
|
elif txn.status==1:
|
|
abort(404)
|
|
|
|
return txn
|
|
|
|
|
|
def get_promocode(code):
|
|
|
|
code = code.replace('\\', '')
|
|
code = code.replace("_", "\_")
|
|
|
|
code = g.db.query(PromoCode).filter(PromoCode.code.ilike(code)).first()
|
|
|
|
return code |