1005 lines
27 KiB
Python
1005 lines
27 KiB
Python
from sqlalchemy.orm import deferred, contains_eager, aliased
|
|
from secrets import token_hex
|
|
import pyotp
|
|
|
|
from drama.helpers.discord import delete_role
|
|
from drama.helpers.aws import *
|
|
from .alts import Alt
|
|
from .titles import Title
|
|
from .submission import SaveRelationship
|
|
from .comment import Notification
|
|
from .boards import Board
|
|
from .board_relationships import *
|
|
from .subscriptions import *
|
|
from .userblock import *
|
|
from .badges import *
|
|
from .clients import *
|
|
from .paypal import PayPalTxn
|
|
from drama.__main__ import Base, cache
|
|
from drama.helpers.security import *
|
|
|
|
class User(Base, Stndrd, Age_times):
|
|
__tablename__ = "users"
|
|
id = Column(Integer, primary_key=True)
|
|
username = Column(String, default=None)
|
|
namecolor = Column(String, default='ff66ac')
|
|
customtitle = Column(String, default=None)
|
|
customtitleplain = Column(String, default=None)
|
|
titlecolor = Column(String, default='ff66ac')
|
|
theme = Column(String, default='dark')
|
|
themecolor = Column(String, default='ff66ac')
|
|
song = Column(String, default=None)
|
|
profileurl = Column(String, default=None)
|
|
bannerurl = Column(String, default=None)
|
|
email = Column(String, default=None)
|
|
css = deferred(Column(String, default=None))
|
|
profilecss = deferred(Column(String, default=None))
|
|
passhash = deferred(Column(String, default=None))
|
|
banawards = Column(Integer, default=0)
|
|
created_utc = Column(Integer, default=0)
|
|
admin_level = Column(Integer, default=0)
|
|
resized = Column(Boolean, default=True)
|
|
agendaposter = Column(Boolean, default=False)
|
|
agendaposter_expires_utc = Column(Integer, default=0)
|
|
changelogsub = Column(Boolean, default=False)
|
|
is_activated = Column(Boolean, default=False)
|
|
shadowbanned = Column(Boolean, default=False)
|
|
over_18 = Column(Boolean, default=False)
|
|
hidevotedon = Column(Boolean, default=False)
|
|
slurreplacer = Column(Boolean, default=True)
|
|
flairchanged = Column(Boolean, default=False)
|
|
newtab = Column(Boolean, default=False)
|
|
newtabexternal = Column(Boolean, default=True)
|
|
oldreddit = Column(Boolean, default=False)
|
|
creation_ip = Column(String, default=None)
|
|
submissions = relationship(
|
|
"Submission",
|
|
lazy="dynamic",
|
|
primaryjoin="Submission.author_id==User.id",
|
|
backref="author_rel")
|
|
comments = relationship(
|
|
"Comment",
|
|
lazy="dynamic",
|
|
primaryjoin="Comment.author_id==User.id")
|
|
votes = relationship("Vote", lazy="dynamic", backref="users")
|
|
commentvotes = relationship("CommentVote", lazy="dynamic", backref="users")
|
|
bio = Column(String, default="")
|
|
bio_html = Column(String, default="")
|
|
badges = relationship("Badge", lazy="dynamic", backref="user")
|
|
real_id = Column(String, default=None)
|
|
notifications = relationship(
|
|
"Notification",
|
|
lazy="dynamic")
|
|
|
|
# unread_notifications_relationship=relationship(
|
|
# "Notification",
|
|
# primaryjoin="and_(Notification.user_id==User.id, Notification.read==False)")
|
|
|
|
referred_by = Column(Integer, default=None)
|
|
is_banned = Column(Integer, default=0)
|
|
unban_utc = Column(Integer, default=0)
|
|
ban_reason = Column(String, default="")
|
|
feed_nonce = Column(Integer, default=0)
|
|
login_nonce = Column(Integer, default=0)
|
|
title_id = Column(Integer, ForeignKey("titles.id"), default=None)
|
|
title = relationship("Title", lazy="joined")
|
|
has_profile = Column(Boolean, default=False)
|
|
has_banner = Column(Boolean, default=False)
|
|
reserved = Column(String(256), default=None)
|
|
is_nsfw = Column(Boolean, default=False)
|
|
tos_agreed_utc = Column(Integer, default=0)
|
|
profile_nonce = Column(Integer, default=0)
|
|
banner_nonce = Column(Integer, default=0)
|
|
last_siege_utc = Column(Integer, default=0)
|
|
mfa_secret = deferred(Column(String(16), default=None))
|
|
hide_offensive = Column(Boolean, default=False)
|
|
hide_bot = Column(Boolean, default=False)
|
|
show_nsfl = Column(Boolean, default=False)
|
|
is_private = Column(Boolean, default=False)
|
|
read_announcement_utc = Column(Integer, default=0)
|
|
unban_utc = Column(Integer, default=0)
|
|
|
|
is_deleted = Column(Boolean, default=False)
|
|
delete_reason = Column(String(500), default='')
|
|
filter_nsfw = Column(Boolean, default=False)
|
|
stored_subscriber_count = Column(Integer, default=0)
|
|
defaultsortingcomments = Column(String, default="top")
|
|
defaultsorting = Column(String, default="hot")
|
|
defaulttime = Column(String, default="all")
|
|
coin_balance = Column(Integer, default=0)
|
|
premium_expires_utc = Column(Integer, default=0)
|
|
negative_balance_cents = Column(Integer, default=0)
|
|
|
|
is_nofollow = Column(Boolean, default=False)
|
|
custom_filter_list = Column(String(1000), default="")
|
|
discord_id = Column(String(64), default=None)
|
|
creation_region = Column(String(2), default=None)
|
|
ban_evade = Column(Integer, default=0)
|
|
|
|
profile_upload_ip = deferred(Column(String(255), default=None))
|
|
banner_upload_ip = deferred(Column(String(255), default=None))
|
|
profile_upload_region = deferred(Column(String(2)))
|
|
banner_upload_region = deferred(Column(String(2)))
|
|
|
|
# stuff to support name changes
|
|
profile_set_utc = deferred(Column(Integer, default=0))
|
|
banner_set_utc = deferred(Column(Integer, default=0))
|
|
original_username = deferred(Column(String(255)))
|
|
name_changed_utc = deferred(Column(Integer, default=0))
|
|
|
|
moderates = relationship("ModRelationship")
|
|
banned_from = relationship("BanRelationship", primaryjoin="BanRelationship.user_id==User.id")
|
|
subscriptions = relationship("Subscription")
|
|
boards_created = relationship("Board", lazy="dynamic")
|
|
contributes = relationship(
|
|
"ContributorRelationship",
|
|
lazy="dynamic",
|
|
primaryjoin="ContributorRelationship.user_id==User.id")
|
|
board_blocks = relationship("BoardBlock", lazy="dynamic")
|
|
|
|
following = relationship("Follow", primaryjoin="Follow.user_id==User.id")
|
|
followers = relationship("Follow", primaryjoin="Follow.target_id==User.id")
|
|
|
|
blocking = relationship("UserBlock", lazy="dynamic", primaryjoin="User.id==UserBlock.user_id")
|
|
blocked = relationship("UserBlock", lazy="dynamic", primaryjoin="User.id==UserBlock.target_id")
|
|
|
|
_applications = relationship("OauthApp", lazy="dynamic")
|
|
authorizations = relationship("ClientAuth", lazy="dynamic")
|
|
|
|
saved_posts = relationship(
|
|
"SaveRelationship",
|
|
lazy="dynamic",
|
|
primaryjoin="User.id==SaveRelationship.user_id")
|
|
|
|
_transactions = relationship(
|
|
"PayPalTxn",
|
|
lazy="dynamic",
|
|
primaryjoin="PayPalTxn.user_id==User.id")
|
|
|
|
# properties defined as SQL server-side functions
|
|
referral_count = deferred(Column(Integer, server_default=FetchedValue()))
|
|
follower_count = deferred(Column(Integer, server_default=FetchedValue()))
|
|
|
|
def __init__(self, **kwargs):
|
|
|
|
if "password" in kwargs:
|
|
kwargs["passhash"] = self.hash_password(kwargs["password"])
|
|
kwargs.pop("password")
|
|
|
|
kwargs["created_utc"] = int(time.time())
|
|
|
|
super().__init__(**kwargs)
|
|
|
|
@property
|
|
@lazy
|
|
def dramacoins(self):
|
|
posts = sum([x[0] - 1 for x in
|
|
g.db.query(Submission.score).options(lazyload('*')).filter_by(author_id=self.id, is_banned=False,
|
|
deleted_utc=0).all()])
|
|
comments = sum([x[0] - 1 for x in
|
|
g.db.query(Comment.score).options(lazyload('*')).filter_by(author_id=self.id, is_banned=False,
|
|
deleted_utc=0).all()])
|
|
return int(posts + comments)
|
|
|
|
def has_block(self, target):
|
|
|
|
return g.db.query(UserBlock).filter_by(
|
|
user_id=self.id, target_id=target.id).first()
|
|
|
|
def is_blocked_by(self, user):
|
|
|
|
return g.db.query(UserBlock).filter_by(
|
|
user_id=user.id, target_id=self.id).first()
|
|
|
|
def any_block_exists(self, other):
|
|
|
|
return g.db.query(UserBlock).filter(
|
|
or_(and_(UserBlock.user_id == self.id, UserBlock.target_id == other.id), and_(
|
|
UserBlock.user_id == other.id, UserBlock.target_id == self.id))).first()
|
|
|
|
def has_blocked_guild(self, board):
|
|
|
|
return g.db.query(BoardBlock).filter_by(
|
|
user_id=self.id, board_id=board.id).first()
|
|
|
|
def validate_2fa(self, token):
|
|
|
|
x = pyotp.TOTP(self.mfa_secret)
|
|
return x.verify(token, valid_window=1)
|
|
|
|
@property
|
|
def age(self):
|
|
return int(time.time()) - self.created_utc
|
|
|
|
@property
|
|
def strid(self):
|
|
return str(self.id)
|
|
|
|
@cache.memoize(300)
|
|
def userpagelisting(self, v=None, page=1, sort="new", t="all"):
|
|
|
|
submissions = g.db.query(Submission).options(lazyload('*')).filter_by(author_id=self.id, is_pinned=False)
|
|
|
|
if not (v and (v.admin_level >= 3 or v.id == self.id)):
|
|
submissions = submissions.filter_by(deleted_utc=0)
|
|
submissions = submissions.filter_by(is_banned=False)
|
|
|
|
now = int(time.time())
|
|
if t == 'hour':
|
|
cutoff = now - 3600
|
|
elif t == 'day':
|
|
cutoff = now - 86400
|
|
elif t == 'week':
|
|
cutoff = now - 604800
|
|
elif t == 'month':
|
|
cutoff = now - 2592000
|
|
elif t == 'year':
|
|
cutoff = now - 31536000
|
|
else:
|
|
cutoff = 0
|
|
submissions = submissions.filter(Submission.created_utc >= cutoff)
|
|
|
|
if sort == "new":
|
|
submissions = submissions.order_by(Submission.created_utc.desc()).all()
|
|
elif sort == "old":
|
|
submissions = submissions.order_by(Submission.created_utc.asc()).all()
|
|
elif sort == "controversial":
|
|
submissions = sorted(submissions.all(), key=lambda x: x.score_disputed, reverse=True)
|
|
elif sort == "top":
|
|
submissions = submissions.order_by(Submission.score.desc()).all()
|
|
elif sort == "bottom":
|
|
submissions = submissions.order_by(Submission.score.asc()).all()
|
|
elif sort == "comments":
|
|
submissions = submissions.order_by(Submission.comment_count.desc()).all()
|
|
|
|
firstrange = 25 * (page - 1)
|
|
secondrange = firstrange + 26
|
|
listing = [x.id for x in submissions[firstrange:secondrange]]
|
|
return listing
|
|
|
|
@cache.memoize(300)
|
|
def commentlisting(self, v=None, page=1, sort="new", t="all"):
|
|
comments = self.comments.options(lazyload('*')).filter(Comment.parent_submission is not None).join(Comment.post)
|
|
|
|
if (not v) or (v.id != self.id and v.admin_level == 0):
|
|
comments = comments.filter(Comment.deleted_utc == 0)
|
|
comments = comments.filter(Comment.is_banned == False)
|
|
|
|
if v and v.admin_level >= 4:
|
|
pass
|
|
elif v:
|
|
m = g.db.query(ModRelationship).filter_by(user_id=v.id, invite_rescinded=False).subquery()
|
|
c = v.contributes.subquery()
|
|
|
|
comments = comments.join(m,
|
|
m.c.board_id == Submission.board_id,
|
|
isouter=True
|
|
).join(c,
|
|
c.c.board_id == Submission.board_id,
|
|
isouter=True
|
|
).join(Board, Board.id == Submission.board_id)
|
|
comments = comments.filter(or_(Comment.author_id == v.id,
|
|
Submission.post_public == True,
|
|
Board.is_private == False,
|
|
m.c.board_id != None,
|
|
c.c.board_id != None))
|
|
else:
|
|
comments = comments.join(Board, Board.id == Submission.board_id).filter(
|
|
or_(Submission.post_public == True, Board.is_private == False))
|
|
|
|
comments = comments.options(contains_eager(Comment.post))
|
|
|
|
now = int(time.time())
|
|
if t == 'hour':
|
|
cutoff = now - 3600
|
|
elif t == 'day':
|
|
cutoff = now - 86400
|
|
elif t == 'week':
|
|
cutoff = now - 604800
|
|
elif t == 'month':
|
|
cutoff = now - 2592000
|
|
elif t == 'year':
|
|
cutoff = now - 31536000
|
|
else:
|
|
cutoff = 0
|
|
comments = comments.filter(Comment.created_utc >= cutoff)
|
|
|
|
if sort == "new":
|
|
comments = comments.order_by(Comment.created_utc.desc()).all()
|
|
elif sort == "old":
|
|
comments = comments.order_by(Comment.created_utc.asc()).all()
|
|
elif sort == "controversial":
|
|
comments = sorted(comments.all(), key=lambda x: x.score_disputed, reverse=True)
|
|
elif sort == "top":
|
|
comments = comments.order_by(Comment.score.desc()).all()
|
|
elif sort == "bottom":
|
|
comments = comments.order_by(Comment.score.asc()).all()
|
|
|
|
firstrange = 25 * (page - 1)
|
|
secondrange = firstrange + 26
|
|
return [x.id for x in comments[firstrange:secondrange]]
|
|
|
|
@property
|
|
@lazy
|
|
def mods_anything(self):
|
|
|
|
return bool([i for i in self.moderates if i.accepted])
|
|
|
|
@property
|
|
def boards_modded(self):
|
|
|
|
z = [x.board for x in self.moderates if x and x.board and x.accepted and not x.board.is_banned]
|
|
z = sorted(z, key=lambda x: x.name)
|
|
|
|
return z
|
|
|
|
@property
|
|
def base36id(self):
|
|
return base36encode(self.id)
|
|
|
|
@property
|
|
def fullname(self):
|
|
return f"t1_{self.base36id}"
|
|
|
|
@property
|
|
@cache.memoize(timeout=60)
|
|
def has_report_queue(self):
|
|
board_ids = [
|
|
x.board_id for x in self.moderates.filter_by(
|
|
accepted=True).all()]
|
|
return bool(g.db.query(Submission).filter(Submission.board_id.in_(
|
|
board_ids), Submission.mod_approved == 0, Submission.is_banned == False).join(Submission.reports).first())
|
|
|
|
@property
|
|
def banned_by(self):
|
|
|
|
if not self.is_banned:
|
|
return None
|
|
|
|
return g.db.query(User).filter_by(id=self.is_banned).first()
|
|
|
|
def has_badge(self, badgedef_id):
|
|
return self.badges.filter_by(badge_id=badgedef_id).first()
|
|
|
|
@property
|
|
@lazy
|
|
def patron(self):
|
|
if self.id != 147 and (self.has_badge(21) or self.has_badge(22) or self.has_badge(23) or self.has_badge(24)): return True
|
|
else: return False
|
|
|
|
def vote_status_on_post(self, post):
|
|
|
|
return post.voted
|
|
|
|
def vote_status_on_comment(self, comment):
|
|
|
|
return comment.voted
|
|
|
|
def hash_password(self, password):
|
|
return generate_password_hash(
|
|
password, method='pbkdf2:sha512', salt_length=8)
|
|
|
|
def verifyPass(self, password):
|
|
return check_password_hash(self.passhash, password)
|
|
|
|
@property
|
|
def feedkey(self):
|
|
|
|
return generate_hash(f"{self.username}{self.id}{self.feed_nonce}{self.created_utc}")
|
|
|
|
@property
|
|
def formkey(self):
|
|
|
|
if "session_id" not in session:
|
|
session["session_id"] = token_hex(16)
|
|
|
|
msg = f"{session['session_id']}+{self.id}+{self.login_nonce}"
|
|
|
|
return generate_hash(msg)
|
|
|
|
def validate_formkey(self, formkey):
|
|
|
|
return validate_hash(f"{session['session_id']}+{self.id}+{self.login_nonce}", formkey)
|
|
|
|
@property
|
|
def url(self):
|
|
return f"/@{self.username}"
|
|
|
|
@property
|
|
def permalink(self):
|
|
return self.url
|
|
|
|
@property
|
|
def uid_permalink(self):
|
|
return f"/uid/{self.base36id}"
|
|
|
|
@property
|
|
def original_link(self):
|
|
return f"/@{self.original_username}"
|
|
|
|
def __repr__(self):
|
|
return f"<User(username={self.username})>"
|
|
|
|
@property
|
|
@lazy
|
|
def post_notifications_count(self):
|
|
return self.notifications.filter(Notification.read == False).join(Notification.comment).filter(
|
|
Comment.author_id == 2360).count()
|
|
|
|
def notification_subscriptions(self, page=1, all_=False):
|
|
|
|
notifications = self.notifications.join(Notification.comment).filter(Comment.author_id == 2360)
|
|
|
|
notifications = notifications.options(
|
|
contains_eager(Notification.comment)
|
|
)
|
|
|
|
notifications = notifications.order_by(Notification.id.desc()).offset(25 * (page - 1)).limit(26)
|
|
|
|
output = []
|
|
for x in notifications:
|
|
x.read = True
|
|
g.db.add(x)
|
|
output.append(x.comment_id)
|
|
|
|
g.db.commit()
|
|
return output
|
|
|
|
def notification_commentlisting(self, page=1, all_=False):
|
|
|
|
notifications = self.notifications.join(Notification.comment).filter(
|
|
Comment.is_banned == False,
|
|
Comment.deleted_utc == 0,
|
|
Comment.author_id != 2360,
|
|
)
|
|
|
|
if not all_:
|
|
notifications = notifications.filter(Notification.read == False)
|
|
|
|
notifications = notifications.options(
|
|
contains_eager(Notification.comment)
|
|
)
|
|
|
|
notifications = notifications.order_by(
|
|
Notification.id.desc()).offset(25 * (page - 1)).limit(26)
|
|
|
|
output = []
|
|
for x in notifications:
|
|
x.read = True
|
|
g.db.add(x)
|
|
output.append(x.comment_id)
|
|
return output
|
|
|
|
@property
|
|
@lazy
|
|
def notifications_count(self):
|
|
|
|
return self.notifications.join(Notification.comment).filter(Notification.read == False,
|
|
Comment.is_banned == False,
|
|
Comment.deleted_utc == 0).count()
|
|
|
|
@property
|
|
def post_count(self):
|
|
|
|
return self.submissions.filter_by(is_banned=False, deleted_utc=0).count()
|
|
|
|
@property
|
|
def comment_count(self):
|
|
|
|
return self.comments.filter(Comment.parent_submission != None).filter_by(is_banned=False, deleted_utc=0).count()
|
|
|
|
@property
|
|
@lazy
|
|
def alts(self):
|
|
|
|
subq = g.db.query(Alt).filter(
|
|
or_(
|
|
Alt.user1 == self.id,
|
|
Alt.user2 == self.id
|
|
)
|
|
).subquery()
|
|
|
|
data = g.db.query(
|
|
User,
|
|
aliased(Alt, alias=subq)
|
|
).join(
|
|
subq,
|
|
or_(
|
|
subq.c.user1 == User.id,
|
|
subq.c.user2 == User.id
|
|
)
|
|
).filter(
|
|
User.id != self.id
|
|
).order_by(User.username.asc()).all()
|
|
|
|
data = [x for x in data]
|
|
output = []
|
|
for x in data:
|
|
user = x[0]
|
|
user._is_manual = x[1].is_manual
|
|
output.append(user)
|
|
|
|
return output
|
|
|
|
def alts_subquery(self):
|
|
return g.db.query(User.id).filter(
|
|
or_(
|
|
User.id.in_(
|
|
g.db.query(Alt.user1).filter(
|
|
Alt.user2 == self.id
|
|
).subquery()
|
|
),
|
|
User.id.in_(
|
|
g.db.query(Alt.user2).filter(
|
|
Alt.user1 == self.id
|
|
).subquery()
|
|
).subquery()
|
|
)
|
|
).subquery()
|
|
|
|
def alts_threaded(self, db):
|
|
|
|
subq = db.query(Alt).filter(
|
|
or_(
|
|
Alt.user1 == self.id,
|
|
Alt.user2 == self.id
|
|
)
|
|
).subquery()
|
|
|
|
data = db.query(
|
|
User,
|
|
aliased(Alt, alias=subq)
|
|
).join(
|
|
subq,
|
|
or_(
|
|
subq.c.user1 == User.id,
|
|
subq.c.user2 == User.id
|
|
)
|
|
).filter(
|
|
User.id != self.id
|
|
).order_by(User.username.asc()).all()
|
|
|
|
data = [x for x in data]
|
|
output = []
|
|
for x in data:
|
|
user = x[0]
|
|
user._is_manual = x[1].is_manual
|
|
output.append(user)
|
|
|
|
return output
|
|
|
|
def has_follower(self, user):
|
|
|
|
return g.db.query(Follow).filter_by(
|
|
target_id=self.id, user_id=user.id).first()
|
|
|
|
def set_profile(self, file):
|
|
|
|
self.del_profile()
|
|
self.profile_nonce += 1
|
|
|
|
imageurl = upload_file(name=f"profile.gif", file=file, resize=(100, 100))
|
|
if imageurl:
|
|
self.profileurl = imageurl
|
|
self.has_profile = True
|
|
self.profile_upload_ip = request.remote_addr
|
|
self.profile_set_utc = int(time.time())
|
|
self.profile_upload_region = request.headers.get("cf-ipcountry")
|
|
g.db.add(self)
|
|
|
|
def set_banner(self, file):
|
|
|
|
self.del_banner()
|
|
self.banner_nonce += 1
|
|
|
|
imageurl = upload_file(name=f"banner.gif", file=file)
|
|
if imageurl:
|
|
self.bannerurl = imageurl
|
|
self.has_banner = True
|
|
self.banner_upload_ip = request.remote_addr
|
|
self.banner_set_utc = int(time.time())
|
|
self.banner_upload_region = request.headers.get("cf-ipcountry")
|
|
g.db.add(self)
|
|
|
|
def del_profile(self):
|
|
|
|
self.has_profile = False
|
|
g.db.add(self)
|
|
|
|
def del_banner(self):
|
|
|
|
self.has_banner = False
|
|
g.db.add(self)
|
|
|
|
@property
|
|
def banner_url(self):
|
|
if self.has_banner:
|
|
if self.bannerurl:
|
|
return self.bannerurl
|
|
else:
|
|
return f"https://s3.eu-central-1.amazonaws.com/i.drama.ga/uid/{self.base36id}/banner-{self.banner_nonce}.png"
|
|
else:
|
|
return "/assets/images/default_bg.png"
|
|
|
|
@cache.memoize(0)
|
|
def defaultpicture(self):
|
|
pic = random.randint(1, 50)
|
|
return f"/assets/images/defaultpictures/{pic}.png"
|
|
|
|
@property
|
|
def profile_url(self):
|
|
if self.has_profile and not self.is_deleted:
|
|
if self.profileurl:
|
|
return self.profileurl
|
|
else:
|
|
return f"https://s3.eu-central-1.amazonaws.com/i.drama.ga/uid/{self.base36id}/profile-{self.profile_nonce}.png"
|
|
else:
|
|
return self.defaultpicture()
|
|
|
|
@property
|
|
def available_titles(self):
|
|
|
|
locs = {"v": self,
|
|
"Board": Board,
|
|
"Submission": Submission
|
|
}
|
|
|
|
titles = [
|
|
i for i in g.db.query(Title).order_by(
|
|
text("id asc")).all() if eval(
|
|
i.qualification_expr, {}, locs)]
|
|
return titles
|
|
|
|
@property
|
|
def can_make_guild(self):
|
|
return False
|
|
|
|
# return (self.has_premium or self.dramacoins >= 250 or (self.created_utc <= 1592974538 and self.dramacoins >= 50)) and len([x for x in self.boards_modded if x.is_siegable]) < 10
|
|
|
|
@property
|
|
def can_join_gms(self):
|
|
return len([x for x in self.boards_modded if x.is_siegable]) < 10
|
|
|
|
@property
|
|
def can_siege(self):
|
|
|
|
if self.is_suspended:
|
|
return False
|
|
|
|
now = int(time.time())
|
|
|
|
return now - max(self.last_siege_utc,
|
|
self.created_utc) > 60 * 60 * 24 * 7
|
|
|
|
@property
|
|
def can_submit_image(self):
|
|
# Has premium
|
|
# Has 1000 Rep, or 500 for older accounts
|
|
# if connecting through Tor, must have verified email
|
|
return (self.has_premium or self.dramacoins >= 0 or (
|
|
self.created_utc <= 1592974538 and self.dramacoins >= 500)) and (
|
|
self.is_activated or request.headers.get("cf-ipcountry") != "T1")
|
|
|
|
@property
|
|
def can_upload_avatar(self):
|
|
return (self.has_premium or self.dramacoins >= 0 or self.created_utc <= 1592974538) and (
|
|
self.is_activated or request.headers.get("cf-ipcountry") != "T1")
|
|
|
|
@property
|
|
def can_upload_banner(self):
|
|
return (self.has_premium or self.dramacoins >= 0 or self.created_utc <= 1592974538) and (
|
|
self.is_activated or request.headers.get("cf-ipcountry") != "T1")
|
|
|
|
@property
|
|
def json_raw(self):
|
|
data = {'username': self.username,
|
|
'permalink': self.permalink,
|
|
'is_banned': bool(self.is_banned),
|
|
'is_premium': self.has_premium_no_renew,
|
|
'created_utc': self.created_utc,
|
|
'id': self.base36id,
|
|
'is_private': self.is_private,
|
|
'profile_url': self.profile_url,
|
|
'banner_url': self.banner_url,
|
|
'title': self.title.json if self.title else None,
|
|
'bio': self.bio,
|
|
'bio_html': self.bio_html,
|
|
'flair': self.customtitle
|
|
}
|
|
|
|
if self.real_id:
|
|
data['real_id'] = self.real_id
|
|
|
|
return data
|
|
|
|
@property
|
|
def json_core(self):
|
|
|
|
now = int(time.time())
|
|
if self.is_banned and (self.unban_utc == 0 or now < self.unban_utc):
|
|
return {'username': self.username,
|
|
'permalink': self.permalink,
|
|
'is_banned': True,
|
|
'is_permanent_ban': not bool(self.unban_utc),
|
|
'ban_reason': self.ban_reason,
|
|
'id': self.base36id
|
|
}
|
|
|
|
elif self.is_deleted:
|
|
return {'username': self.username,
|
|
'permalink': self.permalink,
|
|
'is_deleted': True,
|
|
'id': self.base36id
|
|
}
|
|
return self.json_raw
|
|
|
|
@property
|
|
def json(self):
|
|
data = self.json_core
|
|
|
|
if self.is_deleted or self.is_banned:
|
|
return data
|
|
|
|
data["badges"] = [x.json_core for x in self.badges]
|
|
data['dramacoins'] = int(self.dramacoins)
|
|
data['post_count'] = self.post_count
|
|
data['comment_count'] = self.comment_count
|
|
|
|
return data
|
|
|
|
@property
|
|
def can_use_darkmode(self):
|
|
return True
|
|
|
|
# return self.referral_count or self.has_earned_darkmode or
|
|
# self.has_badge(16) or self.has_badge(17)
|
|
|
|
@property
|
|
def is_valid(self):
|
|
if self.is_banned and self.unban_utc == 0:
|
|
return False
|
|
|
|
elif self.is_deleted:
|
|
return False
|
|
|
|
else:
|
|
return True
|
|
|
|
def ban(self, admin=None, reason=None, days=0):
|
|
|
|
if days > 0:
|
|
ban_time = int(time.time()) + (days * 86400)
|
|
self.unban_utc = ban_time
|
|
|
|
else:
|
|
self.unban_utc = 0
|
|
if self.has_banner:
|
|
self.del_banner()
|
|
if self.has_profile:
|
|
self.del_profile()
|
|
|
|
delete_role(self, "linked")
|
|
|
|
self.is_banned = admin.id if admin else 2317
|
|
if reason:
|
|
self.ban_reason = reason
|
|
|
|
try:
|
|
g.db.add(self)
|
|
except:
|
|
pass
|
|
|
|
def unban(self):
|
|
|
|
# Takes care of all functions needed for account reinstatement.
|
|
|
|
self.is_banned = None
|
|
self.unban_utc = None
|
|
|
|
g.db.add(self)
|
|
|
|
@property
|
|
def is_suspended(self):
|
|
return (self.is_banned and (self.unban_utc ==
|
|
0 or self.unban_utc > time.time()))
|
|
|
|
@property
|
|
def is_blocking(self):
|
|
return self.__dict__.get('_is_blocking', 0)
|
|
|
|
@property
|
|
def is_blocked(self):
|
|
return self.__dict__.get('_is_blocked', 0)
|
|
|
|
def refresh_selfset_badges(self):
|
|
|
|
# check self-setting badges
|
|
badge_types = g.db.query(BadgeDef).filter(
|
|
BadgeDef.qualification_expr.isnot(None)).all()
|
|
for badge in badge_types:
|
|
if eval(badge.qualification_expr, {}, {'v': self}):
|
|
if not self.has_badge(badge.id):
|
|
new_badge = Badge(user_id=self.id,
|
|
badge_id=badge.id,
|
|
created_utc=int(time.time())
|
|
)
|
|
g.db.add(new_badge)
|
|
|
|
else:
|
|
bad_badge = self.has_badge(badge.id)
|
|
if bad_badge:
|
|
g.db.delete(bad_badge)
|
|
|
|
try:
|
|
g.db.add(self)
|
|
except:
|
|
pass
|
|
|
|
@property
|
|
def applications(self):
|
|
return [x for x in self._applications.order_by(
|
|
OauthApp.id.asc()).all()]
|
|
|
|
def subscribed_idlist(self, page=1):
|
|
posts = g.db.query(Subscription.submission_id).filter_by(user_id=self.id).all()
|
|
return [x[0] for x in posts]
|
|
|
|
def saved_idlist(self, page=1):
|
|
|
|
posts = g.db.query(Submission.id).options(lazyload('*')).filter_by(is_banned=False,
|
|
deleted_utc=0
|
|
)
|
|
|
|
saved = g.db.query(SaveRelationship.submission_id).filter(SaveRelationship.user_id == self.id).subquery()
|
|
posts = posts.filter(Submission.id.in_(saved))
|
|
|
|
if self.admin_level == 0:
|
|
blocking = g.db.query(
|
|
UserBlock.target_id).filter_by(
|
|
user_id=self.id).subquery()
|
|
blocked = g.db.query(
|
|
UserBlock.user_id).filter_by(
|
|
target_id=self.id).subquery()
|
|
|
|
posts = posts.filter(
|
|
Submission.author_id.notin_(blocking),
|
|
Submission.author_id.notin_(blocked)
|
|
)
|
|
|
|
posts = posts.order_by(Submission.created_utc.desc())
|
|
|
|
return [x[0] for x in posts.offset(25 * (page - 1)).limit(26).all()]
|
|
|
|
def saved_comment_idlist(self, page=1):
|
|
|
|
comments = g.db.query(Comment.id).options(lazyload('*')).filter_by(is_banned=False, deleted_utc=0)
|
|
|
|
saved = g.db.query(SaveRelationship.submission_id).filter(SaveRelationship.user_id == self.id).subquery()
|
|
comments = comments.filter(Comment.id.in_(saved))
|
|
|
|
if self.admin_level == 0:
|
|
blocking = g.db.query(
|
|
UserBlock.target_id).filter_by(
|
|
user_id=self.id).subquery()
|
|
blocked = g.db.query(
|
|
UserBlock.user_id).filter_by(
|
|
target_id=self.id).subquery()
|
|
|
|
comments = comments.filter(
|
|
Comment.author_id.notin_(blocking),
|
|
Comment.author_id.notin_(blocked)
|
|
)
|
|
|
|
comments = comments.order_by(Comment.created_utc.desc())
|
|
|
|
return [x[0] for x in comments.offset(25 * (page - 1)).limit(26).all()]
|
|
|
|
def guild_rep(self, guild, recent=0):
|
|
|
|
posts = g.db.query(Submission.score).filter_by(
|
|
is_banned=False,
|
|
original_board_id=guild.id)
|
|
|
|
if recent:
|
|
cutoff = int(time.time()) - 60 * 60 * 24 * recent
|
|
posts = posts.filter(Submission.created_utc > cutoff)
|
|
|
|
posts = posts.all()
|
|
|
|
post_rep = sum([x[0] for x in posts]) - len(list(sum([x[0] for x in posts])))
|
|
|
|
comments = g.db.query(Comment.score).filter_by(
|
|
is_banned=False,
|
|
original_board_id=guild.id)
|
|
|
|
if recent:
|
|
cutoff = int(time.time()) - 60 * 60 * 24 * recent
|
|
comments = comments.filter(Comment.created_utc > cutoff)
|
|
|
|
comments = comments.all()
|
|
|
|
comment_rep = sum([x[0] for x in comments]) - len(list(sum([x[0] for x in comments])))
|
|
|
|
return int(post_rep + comment_rep)
|
|
|
|
@property
|
|
def has_premium(self):
|
|
|
|
now = int(time.time())
|
|
|
|
if self.negative_balance_cents:
|
|
return False
|
|
|
|
elif self.premium_expires_utc > now:
|
|
return True
|
|
|
|
elif self.coin_balance >= 1:
|
|
self.coin_balance -= 1
|
|
self.premium_expires_utc = now + 60 * 60 * 24 * 7
|
|
|
|
g.db.add(self)
|
|
|
|
return True
|
|
|
|
else:
|
|
|
|
if self.premium_expires_utc:
|
|
self.premium_expires_utc = 0
|
|
g.db.add(self)
|
|
|
|
return False
|
|
|
|
@property
|
|
def has_premium_no_renew(self):
|
|
|
|
now = int(time.time())
|
|
|
|
if self.negative_balance_cents:
|
|
return False
|
|
elif self.premium_expires_utc > now:
|
|
return True
|
|
elif self.coin_balance >= 1:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
@property
|
|
def renew_premium_time(self):
|
|
return time.strftime("%d %b %Y at %H:%M:%S",
|
|
time.gmtime(self.premium_expires_utc))
|
|
|
|
@property
|
|
def filter_words(self):
|
|
l = [i.strip() for i in self.custom_filter_list.split('\n')] if self.custom_filter_list else []
|
|
l = [i for i in l if i]
|
|
return l
|
|
|
|
@property
|
|
def boards_modded_ids(self):
|
|
return [x.id for x in self.boards_modded]
|
|
|
|
@property
|
|
def txn_history(self):
|
|
|
|
return self._transactions.filter(PayPalTxn.status != 1).order_by(PayPalTxn.created_utc.desc()).all()
|
|
|
|
@property
|
|
def json_admin(self):
|
|
data = self.json_raw
|
|
|
|
data['creation_ip'] = self.creation_ip
|
|
data['creation_region'] = self.creation_region
|
|
data['email'] = self.email
|
|
data['email_verified'] = self.is_activated
|
|
|
|
return data
|
|
|
|
@property
|
|
def can_upload_comment_image(self):
|
|
return self.dramacoins >= 0 and (request.headers.get("cf-ipcountry") != "T1" or self.is_activated)
|
|
|
|
@property
|
|
def can_change_name(self):
|
|
return True
|
|
# return self.name_changed_utc < int(time.time())-60*60*24*90
|