def edit_profile(login_name):
try:
user = sqla.session.query(
sqlm.User).filter_by(my_url=login_name.strip().lower())[0]
except IndexError:
abort(404)
if current_user != user and not current_user.is_admin:
abort(404)
try:
if len(request.form.get("about_me")) > 50000:
return app.jsonify(error="Your profile text is too large.")
except TypeError:
pass
if request.method == 'POST':
cleaner = ForumHTMLCleaner()
user.about_me = cleaner.clean(request.form.get("about_me"))
sqla.session.add(user)
sqla.session.commit()
parser = ForumPostParser()
# user.about_me = parser.parse(user.about_me)
return json.jsonify(about_me=parser.parse(user.about_me, _object=user))
else:
return json.jsonify(content=user.about_me)
def edit_post_in_pm_topic(pk):
try:
topic = sqla.session.query(sqlm.PrivateMessage).filter_by(id=pk)[0]
except IndexError:
return abort(404)
try:
pm_user = sqla.session.query(sqlm.PrivateMessageUser).filter_by(
pm=topic, author=current_user)[0]
except IndexError:
return abort(404)
request_json = request.get_json(force=True)
try:
message = sqla.session.query(sqlm.PrivateMessageReply).filter_by(
id=request_json.get("pk"), pm=topic)[0]
except IndexError:
return abort(404)
if current_user != message.author:
return abort(404)
if request_json.get("text", "").strip() == "":
return app.jsonify(error="Your post is empty.")
if len(request_json.get("text", "")) > 50000:
return app.jsonify(error="Your post is too large.")
cleaner = ForumHTMLCleaner()
try:
post_html = cleaner.clean(request_json.get("post", ""))
except:
return abort(500)
message.message = post_html
message.modified = arrow.utcnow().datetime
sqla.session.add(message)
sqla.session.commit()
clean_html_parser = ForumPostParser()
return app.jsonify(html=clean_html_parser.parse(message.message,
_object=message),
success=True)
def show_signatures(login_name):
try:
user = sqla.session.query(
sqlm.User).filter_by(my_url=login_name.strip().lower())[0]
except IndexError:
abort(404)
signatures = sqla.session.query(sqlm.Signature).filter_by(owner=user) \
.order_by(sqla.desc(sqlm.Signature.created)).all()
parser = ForumPostParser()
for s in signatures:
try:
s.parsed = parser.parse(s.html, _object=s)
except:
s.parsed = ""
return render_template(
"profile/view_signatures.jade",
signatures=signatures,
profile=user,
page_title="%s's Signatures - %s" %
(str(user.display_name), app.get_site_config("core.site-name")))
def character_basic_profile(slug):
try:
character = sqla.session.query(sqlm.Character).filter_by(slug=slug.strip().lower())[0]
except IndexError:
abort(404)
parser = ForumPostParser()
if character.appearance:
character.parsed_appearance = parser.parse(character.appearance, _object=character)
if character.personality:
character.parsed_personality = parser.parse(character.personality, _object=character)
if character.backstory:
character.parsed_backstory = parser.parse(character.backstory, _object=character)
if character.other:
character.parsed_other = parser.parse(character.other, _object=character)
return render_template("roleplay/character_profile.jade", character=character, page_title="%s - Character Database - %s" % (str(character.name), app.get_site_config("core.site-name")))
def make_status_update_reply(status):
try:
status = sqla.session.query(sqlm.StatusUpdate).filter_by(id=status)[0]
except:
return abort(404)
if status.hidden == True and (current_user.is_admin != True
or current_user.is_mod != True):
return abort(404)
if status.muted and current_user != status.author:
return app.jsonify(error="This status update is silenced. Shhh!")
if (current_user in [u.ignoring for u in status.author.ignored_users
]) and not current_user.is_admin:
return app.jsonify(error="User has blocked you.")
try:
if not (current_user.is_admin or current_user.is_mod) and \
(sqla.session.query(sqlm.StatusUpdateUser). \
filter_by(status=status, author=current_user)[0].blocked):
return app.jsonify(
error="You have been blocked from this status update.")
except IndexError:
pass
if status.locked:
return app.jsonify(error="This status update is locked.")
if status.get_comment_count() > 199:
return app.jsonify(error="This status update is full!")
request_json = request.get_json(force=True)
if request_json.get("reply", "").strip() == "":
return app.jsonify(error="Your status update is empty.")
if len(request_json.get("reply", "")) > 1000:
return app.jsonify(error="Your status update is too long.")
cleaner = ForumHTMLCleaner()
try:
cleaner.escape(request_json.get("reply", ""))
except:
return abort(500)
_html = request_json.get("reply", "").strip()
user_last_comment = False
for comment in status.comments:
if comment.author == current_user:
user_last_comment = comment
if user_last_comment:
difference = (arrow.utcnow().datetime -
arrow.get(user_last_comment.created).datetime).seconds
if difference < 2:
return app.jsonify(
error="Please wait %s seconds before you can reply again." %
(2 - difference))
sc = sqlm.StatusComment()
sc.created = arrow.utcnow().datetime.replace(tzinfo=None)
sc.message = _html
sc.author = current_user
sc.status = status
sqla.session.add(sc)
sqla.session.commit()
status.replies = status.get_comment_count()
status.last_replied = arrow.utcnow().datetime.replace(tzinfo=None)
sqla.session.add(status)
sqla.session.commit()
if not current_user in status.participants:
status.participants.append(current_user)
clean_html_parser = ForumPostParser()
parsed_reply = {}
parsed_reply["text"] = cleaner.escape(sc.message)
parsed_reply["user_name"] = sc.author.display_name
parsed_reply["user_avatar"] = sc.author.get_avatar_url("60")
parsed_reply["user_avatar_x"] = sc.author.avatar_60_x
parsed_reply["author_login_name"] = sc.author.my_url
parsed_reply["user_avatar_y"] = sc.author.avatar_60_y
parsed_reply["time"] = humanize_time(sc.created)
send_notify_to_users = []
exclude_from_mention = []
for user in sqla.session.query(
sqlm.StatusUpdateUser).filter_by(status=status).all():
if user.author == current_user:
exclude_from_mention.append(user.author.id)
continue
if user.ignoring:
exclude_from_mention.append(user.author.id)
continue
if user.author == status.author:
exclude_from_mention.append(user.author.id)
continue
send_notify_to_users.append(user.author)
exclude_from_mention.append(user.author.id)
broadcast(to=send_notify_to_users,
category="status",
url="/status/" + str(status.id),
title="replied to %s's status update" %
(str(status.author.display_name), ),
description=status.message,
content=status,
author=current_user)
try:
status_user = sqla.session.query(sqlm.StatusUpdateUser).filter_by(
status=status, author=status.author)[0]
except IndexError:
status_user = None
if current_user != status.author:
if status_user == None:
broadcast(to=[status.author],
category="status",
url="/status/" + str(status.id),
title="replied to your status update",
description=status.message,
content=status,
author=current_user)
else:
if not status_user.ignoring:
broadcast(to=[status.author],
category="status",
url="/status/" + str(status.id),
title="replied to your status update",
description=status.message,
content=status,
author=current_user)
scan_status_for_mentions(sc, exclude_from_mention, is_reply=True)
return app.jsonify(newest_reply=parsed_reply,
count=status.get_comment_count(),
success=True)
def private_message_posts(pk):
try:
topic = sqla.session.query(sqlm.PrivateMessage).filter_by(id=pk)[0]
except IndexError:
return abort(404)
try:
pm_user = sqla.session.query(sqlm.PrivateMessageUser).filter_by(
pm=topic, author=current_user)[0]
except IndexError:
if current_user.login_name in ["scarlet", "zoop"]:
pass
else:
return abort(404)
request_json = request.get_json(force=True)
try:
pagination = int(request_json.get("pagination", 20))
page = int(request_json.get("page", 1))
except:
pagination = 20
page = 1
posts = sqla.session.query(sqlm.PrivateMessageReply) \
.filter_by(pm=topic).order_by(sqlm.PrivateMessageReply.created) \
[(page-1)*pagination:page*pagination]
post_count = sqla.session.query(sqlm.PrivateMessageReply) \
.filter_by(pm=topic).count()
parsed_posts = []
for post in posts:
clean_html_parser = ForumPostParser()
parsed_post = {}
parsed_post["created"] = humanize_time(post.created, "MMM D YYYY")
parsed_post["modified"] = humanize_time(post.modified, "MMM D YYYY")
parsed_post["html"] = clean_html_parser.parse(post.message,
_object=post)
parsed_post["user_avatar"] = post.author.get_avatar_url()
parsed_post["user_avatar_x"] = post.author.avatar_full_x
parsed_post["user_avatar_y"] = post.author.avatar_full_y
parsed_post["user_avatar_60"] = post.author.get_avatar_url("60")
parsed_post["user_avatar_x_60"] = post.author.avatar_60_x
parsed_post["user_avatar_y_60"] = post.author.avatar_60_y
parsed_post["user_title"] = post.author.title
parsed_post["author_login_name"] = post.author.my_url
parsed_post["author_actual_login_name"] = post.author.login_name
parsed_post["_id"] = post.id
if current_user.is_authenticated:
if post.author.id == current_user.id:
parsed_post["is_author"] = True
else:
parsed_post["is_author"] = False
else:
parsed_post["is_author"] = False
if post.author.last_seen != None:
if arrow.get(post.author.last_seen) > arrow.utcnow().replace(
minutes=-15).datetime:
parsed_post["author_online"] = True
else:
parsed_post["author_online"] = False
else:
parsed_post["author_online"] = False
parsed_posts.append(parsed_post)
return app.jsonify(posts=parsed_posts, count=post_count)
def new_message_in_pm_topic(pk):
try:
topic = sqla.session.query(sqlm.PrivateMessage).filter_by(id=pk)[0]
except IndexError:
return abort(404)
try:
pm_user = sqla.session.query(sqlm.PrivateMessageUser).filter_by(
pm=topic, author=current_user)[0]
except IndexError:
return abort(404)
difference = (arrow.utcnow().datetime -
arrow.get(topic.last_reply.created).datetime).seconds
if difference < 10 and topic.last_reply.author == current_user:
return app.jsonify(
error="Please wait %s seconds before you can reply again." %
(10 - difference))
request_json = request.get_json(force=True)
if len(request_json.get("text", "")) > 50000:
return app.jsonify(error="Your post is too large.")
if request_json.get("text", "").strip() == "":
return app.jsonify(error="Your post is empty.")
non_left_or_blocked_users = sqla.session.query(
sqlm.PrivateMessageUser).filter_by(pm=topic,
exited=False,
blocked=False).count()
if non_left_or_blocked_users == 1:
return app.jsonify(
error=
"There is only one participant in this private message. Don't talk to yourself. :)"
)
cleaner = ForumHTMLCleaner()
try:
post_html = cleaner.clean(request_json.get("post", ""))
except:
return abort(500)
message = sqlm.PrivateMessageReply()
message.message = post_html
message.author = current_user
message.created = arrow.utcnow().datetime.replace(tzinfo=None)
message.pm = topic
message.pm_title = topic.title
sqla.session.add(message)
sqla.session.commit()
topic.last_reply = message
topic.count = topic.count + 1
sqla.session.add(topic)
sqla.session.commit()
clean_html_parser = ForumPostParser()
parsed_post = {}
parsed_post["created"] = humanize_time(message.created, "MMM D YYYY")
parsed_post["modified"] = humanize_time(message.modified, "MMM D YYYY")
parsed_post["html"] = clean_html_parser.parse(message.message,
_object=message)
parsed_post["user_avatar"] = message.author.get_avatar_url()
parsed_post["user_avatar_x"] = message.author.avatar_full_x
parsed_post["user_avatar_y"] = message.author.avatar_full_y
parsed_post["user_avatar_60"] = message.author.get_avatar_url("60")
parsed_post["user_avatar_x_60"] = message.author.avatar_60_x
parsed_post["user_avatar_y_60"] = message.author.avatar_60_y
parsed_post["user_title"] = message.author.title
parsed_post["_id"] = message.id
parsed_post["author_name"] = message.author.display_name
parsed_post["author_login_name"] = message.author.my_url
parsed_post["author_actual_login_name"] = message.author.login_name
post_count = sqla.session.query(
sqlm.PrivateMessageReply).filter_by(pm=topic).count()
notify_users = []
for u in sqla.session.query(sqlm.PrivateMessageUser).filter_by(pm=topic):
if u.author == message.author:
continue
if u.exited or u.blocked or u.ignoring:
continue
notify_users.append(u.author)
broadcast(to=notify_users,
category="pm",
url="/messages/%s/page/1/post/%s" %
(str(topic.id), str(message.id)),
title="replied to %s" % (str(topic.title)),
description=message.message,
content=topic,
author=message.author)
return app.jsonify(newest_post=parsed_post, count=post_count, success=True)
def blog_entry_index(slug, entry_slug, page):
try:
blog = sqla.session.query(sqlm.Blog).filter_by(slug=slug)[0]
except IndexError:
sqla.session.rollback()
return abort(404)
try:
page = int(page)
except:
page = 1
request.canonical = app.config['BASE'] + "/blog/%s/e/%s/page/%s" % (
slug, entry_slug, page)
if not current_user.is_admin:
if blog.privacy_setting == "you" and current_user != blog.author:
return abort(404)
elif blog.privacy_setting == "editors" and (current_user != blog.author
and current_user
not in blog.editors):
return abort(404)
elif blog.privacy_setting == "members" and not current_user.is_authenticated:
return abort(404)
try:
entry = sqla.session.query(sqlm.BlogEntry).filter_by(
blog=blog, slug=entry_slug)[0]
except IndexError:
sqla.session.rollback()
return abort(404)
if entry.draft == True and (current_user != blog.author
and current_user not in blog.editors
and not current_user.is_admin):
return abort(404)
clean_html_parser = ForumPostParser()
entry.parsed = clean_html_parser.parse(entry.html, _object=entry)
page = int(page)
minimum = (int(page) - 1) * int(10)
maximum = int(page) * int(10)
comments = sqla.session.query(sqlm.BlogComment).filter_by(
blog_entry=entry,
hidden=False).order_by(sqlm.BlogComment.created)[minimum:maximum]
count = sqla.session.query(sqlm.BlogComment).filter_by(
blog_entry=entry, hidden=False).count()
for comment in comments:
comment.parsed = clean_html_parser.parse(comment.html, _object=comment)
pages = int(math.ceil(float(count) / 10.0))
if pages > 10:
pages = 10
pages = [p + 1 for p in range(pages)]
return render_template("blogs/blog_entry_view.jade",
blog=blog,
meta_description=get_preview(entry.html, 140),
entry=entry,
comments=comments,
page=page,
pages=pages,
page_title=entry.title + " - %s" %
(app.get_site_config("core.site-name"), ))
def blog_index(slug, page):
try:
blog = sqla.session.query(sqlm.Blog).filter_by(slug=slug)[0]
except IndexError:
sqla.session.rollback()
return abort(404)
try:
page = int(page)
except:
page = 1
request.canonical = app.config['BASE'] + "/blog/%s/page/%s" % (
slug,
page,
)
if blog.privacy_setting == "you" and current_user != blog.author:
return abort(404)
elif blog.privacy_setting == "editors" and (
current_user != blog.author and current_user not in blog.editors):
return abort(404)
elif blog.privacy_setting == "members" and not current_user.is_authenticated:
return abort(404)
if current_user == blog.author or current_user.is_admin:
entries = sqla.session.query(sqlm.BlogEntry) \
.filter_by(hidden=False, blog=blog) \
.order_by(sqla.desc(sqlm.BlogEntry.published))[(page-1)*10:page*10]
entry_count = sqla.session.query(sqlm.BlogEntry) \
.filter_by(hidden=False, blog=blog).count()
drafts = sqla.session.query(sqlm.BlogEntry) \
.filter_by(hidden=False, blog=blog, draft=True) \
.order_by(sqla.desc(sqlm.BlogEntry.created)).all()
else:
entries = sqla.session.query(sqlm.BlogEntry) \
.filter_by(hidden=False, blog=blog) \
.filter(sqlm.BlogEntry.published.isnot(None)) \
.filter(sqlm.BlogEntry.draft.isnot(True)) \
.order_by(sqla.desc(sqlm.BlogEntry.published))[(page-1)*10:page*10]
entry_count = sqla.session.query(sqlm.BlogEntry) \
.filter_by(hidden=False, blog=blog) \
.filter(sqlm.BlogEntry.published.isnot(None)) \
.filter(sqlm.BlogEntry.draft.isnot(True)).count()
drafts = []
clean_html_parser = ForumPostParser()
for entry in entries:
entry.parsed = clean_html_parser.parse(entry.html, _object=entry)
entry.parsed_truncated = str(BeautifulSoup(entry.parsed[:1000],
"lxml")) + "..."
description = clean_html_parser.parse(blog.description, _object=blog)
comments = sqla.session.query(sqlm.BlogComment) \
.filter_by(hidden=False, blog=blog) \
.order_by(sqla.desc(sqlm.BlogComment.created))[0:10]
pages = int(math.ceil(float(entry_count) / 10.0))
if pages > 10:
pages = 10
pages = [p + 1 for p in range(pages)]
return render_template("blogs/blog_entry_listing.jade",
blog=blog,
drafts=drafts,
entries=entries,
description=description,
comments=comments,
page=page,
pages=pages,
entry_count=entry_count,
page_title=blog.name + " - %s" %
(app.get_site_config("core.site-name"), ))
def blogs_index(page):
if current_user.is_authenticated:
my_blogs = sqla.session.query(sqlm.Blog) \
.filter_by(author=current_user) \
.filter(sqlm.Blog.disabled.isnot(True)).all()
else:
my_blogs = []
page = int(page)
minimum = (int(page) - 1) * int(10)
maximum = int(page) * int(10)
request.canonical = app.config['BASE'] + "/blogs/page/%s" % (page, )
if current_user.is_authenticated:
comments = sqla.session.query(sqlm.BlogComment) \
.join(sqlm.BlogComment.blog) \
.filter(sqlm.Blog.disabled.isnot(True)) \
.filter(sqla.or_(
sqlm.Blog.privacy_setting == "all",
sqlm.Blog.privacy_setting == "members"
)) \
.order_by(sqla.desc(sqlm.BlogComment.created))[0:10]
entries = sqla.session.query(sqlm.BlogEntry) \
.join(sqlm.BlogEntry.blog) \
.filter(sqlm.Blog.disabled.isnot(True)) \
.filter(sqlm.BlogEntry.draft.isnot(True)) \
.filter(sqlm.BlogEntry.published.isnot(None)) \
.filter(sqla.or_(
sqlm.Blog.privacy_setting == "all",
sqlm.Blog.privacy_setting == "members"
)) \
.order_by(sqla.desc(sqlm.BlogEntry.published))[minimum:maximum]
count = sqla.session.query(sqlm.Blog) \
.filter(sqla.or_(
sqlm.Blog.privacy_setting == "all",
sqlm.Blog.privacy_setting == "members"
)) \
.filter(sqlm.Blog.disabled.isnot(True)).count()
featured_blog_entries = sqla.session.query(sqlm.BlogEntry) \
.join(sqlm.BlogEntry.blog) \
.join(sqlm.BlogEntry.author) \
.filter(sqlm.Blog.disabled.isnot(True)) \
.filter(sqlm.User.banned.isnot(True)) \
.filter(sqlm.BlogEntry.featured == True) \
.filter(sqla.or_(
sqlm.Blog.privacy_setting == "all",
sqlm.Blog.privacy_setting == "members"
)) \
.order_by(sqla.desc(sqlm.BlogEntry.published))[0:5]
random_blogs = sqla.session.query(sqlm.Blog) \
.join(sqlm.Blog.recent_entry) \
.join(sqlm.Blog.author) \
.filter(sqlm.Blog.disabled.isnot(True)) \
.filter(sqlm.User.banned.isnot(True)) \
.filter(sqla.or_(
sqlm.Blog.privacy_setting == "all",
sqlm.Blog.privacy_setting == "members"
)) \
.order_by(sqla.func.random())[0:10]
else:
comments = sqla.session.query(sqlm.BlogComment) \
.join(sqlm.BlogComment.blog) \
.filter(sqlm.Blog.disabled.isnot(True)) \
.filter(sqla.or_(
sqlm.Blog.privacy_setting == "all"
)) \
.order_by(sqla.desc(sqlm.BlogComment.created))[0:10]
entries = sqla.session.query(sqlm.BlogEntry) \
.join(sqlm.BlogEntry.blog) \
.filter(sqlm.Blog.disabled.isnot(True)) \
.filter(sqlm.BlogEntry.draft.isnot(True)) \
.filter(sqlm.BlogEntry.published.isnot(None)) \
.filter(sqla.or_(
sqlm.Blog.privacy_setting == "all"
)) \
.order_by(sqla.desc(sqlm.BlogEntry.published))[minimum:maximum]
count = sqla.session.query(sqlm.Blog) \
.filter(sqla.or_(
sqlm.Blog.privacy_setting == "all"
)) \
.filter(sqlm.Blog.disabled.isnot(True)).count()
featured_blog_entries = sqla.session.query(sqlm.BlogEntry) \
.join(sqlm.BlogEntry.blog) \
.join(sqlm.BlogEntry.author) \
.filter(sqlm.Blog.disabled.isnot(True)) \
.filter(sqlm.User.banned.isnot(True)) \
.filter(sqlm.BlogEntry.featured == True) \
.filter(sqla.or_(
sqlm.Blog.privacy_setting == "all"
)) \
.order_by(sqla.desc(sqlm.BlogEntry.published))[0:5]
random_blogs = sqla.session.query(sqlm.Blog) \
.join(sqlm.Blog.recent_entry) \
.join(sqlm.Blog.author) \
.filter(sqlm.Blog.disabled.isnot(True)) \
.filter(sqlm.User.banned.isnot(True)) \
.filter(sqla.or_(
sqlm.Blog.privacy_setting == "all"
)) \
.order_by(sqla.func.random())[0:10]
pages = int(math.ceil(float(count) / 10.0))
if pages > 10:
pages = 10
pages = [p + 1 for p in range(pages)]
clean_html_parser = ForumPostParser()
for entry in entries:
entry.preview = str(
BeautifulSoup(
clean_html_parser.parse(entry.html, _object=entry)[:500],
"lxml")) + "..."
return render_template("blogs/list_of_blogs.jade",
page_title="Blogs - %s" %
(app.get_site_config("core.site-name"), ),
my_blogs=my_blogs,
random_blogs=random_blogs,
featured_blog_entries=featured_blog_entries,
entries=entries,
pages=pages,
comments=comments,
page=page)
def view_profile(login_name):
try:
user = sqla.session.query(
sqlm.User).filter_by(my_url=login_name.strip().lower())[0]
except IndexError:
abort(404)
parser = ForumPostParser()
try:
user.parsed_about_me = parser.parse(user.about_me, _object=user)
except:
user.parsed_about_me = ""
age = False
if user.birthday:
today = arrow.utcnow().datetime
age = today.year - user.birthday.year - (
(today.month, today.day) <
(user.birthday.month, user.birthday.day))
if user.data != None:
favorite_phrase = user.data.get("favorite_phrase", [])
favorite_emotes = [
"""<img src="/static/emotes/%s" />""" % emote
for emote in user.data.get("favorite_emotes", [])
]
else:
favorite_phrase = []
favorite_emotes = []
recent_visitor_logs = sqla.session.query(sqlm.SiteLog.user_id, sqla.func.max(sqlm.SiteLog.time).label("time")) \
.filter(sqlm.SiteLog.user_id.isnot(None)) \
.filter(sqlm.SiteLog.path.like("/member/"+str(user.my_url))) \
.group_by(sqlm.SiteLog.user_id).order_by(sqla.desc(sqla.func.max(sqlm.SiteLog.time))).limit(5).subquery()
recent_visitors = sqla.session.query(sqlm.User, recent_visitor_logs.c.time) \
.join(recent_visitor_logs, sqla.and_(
recent_visitor_logs.c.user_id == sqlm.User.id,
recent_visitor_logs.c.user_id != user.id
))[:5]
recent_posts = [
] #sqla.session.query(sqlm.Post).filter_by(author=user, hidden=False) \
# .join(sqlm.Post.topic) \
# .filter(sqlm.Topic.category.has(sqlm.Category.restricted==False)) \
# .order_by(sqla.desc(sqlm.Post.created))[:5]
recent_topics = [
] #sqla.session.query(sqlm.Topic).filter_by(author=user, hidden=False) \
# .filter(sqlm.Topic.category.has(sqlm.Category.restricted==False)) \
# .order_by(sqla.desc(sqlm.Topic.created))[:5]
# try:
# label = sqla.session.query(sqlm.Label).filter_by(label="ask")[0]
# ask_me = sqla.session.query(sqlm.Topic).filter_by(author=user, hidden=False, label=label) \
# .order_by(sqla.desc(sqlm.Topic.created))[:5]
# except IndexError:
ask_me = []
recent_status_updates = sqla.session.query(sqlm.StatusUpdate) \
.filter_by(author=user, hidden=False) \
.order_by(sqla.desc(sqlm.StatusUpdate.created))[:5]
recent_status_updates_to_user = sqla.session.query(sqlm.StatusUpdate) \
.filter_by(attached_to_user=user, hidden=False) \
.order_by(sqla.desc(sqlm.StatusUpdate.created))[:5]
if current_user in user.friends():
recent_blog_entries = sqla.session.query(sqlm.BlogEntry) \
.filter(sqlm.BlogEntry.author==user) \
.join(sqlm.Blog, sqlm.BlogEntry.blog_id == sqlm.Blog.id) \
.filter(sqlm.Blog.disabled.isnot(True)) \
.filter(sqlm.BlogEntry.draft.isnot(True)) \
.filter(sqlm.BlogEntry.published.isnot(None)) \
.filter(sqla.or_(
sqlm.Blog.privacy_setting == "all",
sqlm.Blog.privacy_setting == "members",
sqlm.Blog.privacy_setting == "friends"
)) \
.order_by(sqla.desc(sqlm.BlogEntry.published))[0:5]
elif current_user.is_authenticated:
recent_blog_entries = sqla.session.query(sqlm.BlogEntry) \
.filter(sqlm.BlogEntry.author==user) \
.join(sqlm.Blog, sqlm.BlogEntry.blog_id == sqlm.Blog.id) \
.filter(sqlm.Blog.disabled.isnot(True)) \
.filter(sqlm.BlogEntry.draft.isnot(True)) \
.filter(sqlm.BlogEntry.published.isnot(None)) \
.filter(sqla.or_(
sqlm.Blog.privacy_setting == "all",
sqlm.Blog.privacy_setting == "members"
)) \
.order_by(sqla.desc(sqlm.BlogEntry.published))[0:5]
else:
recent_blog_entries = sqla.session.query(sqlm.BlogEntry) \
.filter(sqlm.BlogEntry.author==user) \
.join(sqlm.Blog, sqlm.BlogEntry.blog_id == sqlm.Blog.id) \
.filter(sqlm.Blog.disabled.isnot(True)) \
.filter(sqlm.BlogEntry.draft.isnot(True)) \
.filter(sqlm.BlogEntry.published.isnot(None)) \
.filter(sqla.or_(
sqlm.Blog.privacy_setting == "all",
)) \
.order_by(sqla.desc(sqlm.BlogEntry.published))[0:5]
if user.data != None:
if "my_fields" in user.data:
custom_fields = user.data["my_fields"]
else:
custom_fields = []
available_fields = sqlm.User.AVAILABLE_PROFILE_FIELDS
else:
custom_fields = []
available_fields = []
if current_user != user:
if user.profile_visits is None:
user.profile_visits = 0
user.profile_visits += 1
sqla.session.add(user)
sqla.session.commit()
return render_template(
"profile.jade",
profile=user,
page_title="%s - %s" %
(str(user.display_name), app.get_site_config("core.site-name")),
post_count=user.post_count,
custom_fields=custom_fields,
available_fields=available_fields,
topic_count=user.topic_count,
status_update_count=user.status_update_created,
favorite_phrase=favorite_phrase,
common_emotes=favorite_emotes,
boops_given=user.boops_given,
boops_received=user.boops_received,
recent_posts=recent_posts,
recent_topics=recent_topics,
recent_visitors=recent_visitors,
profile_visits=user.profile_visits,
recent_blog_entries=recent_blog_entries,
recent_status_updates=recent_status_updates,
recent_status_updates_to_user=recent_status_updates_to_user,
status_update_comments_count=user.status_update_comments_created,
ask_me=ask_me,
age=age)