indymedia
/
epicyon
mirror of https://gitlab.com/bashrc2/epicyon
7
4
Fork 1
Code Issues 14 Releases Wiki Activity
epicyon/webapp_post.py

2309 lines
95 KiB
Python
Raw Blame History

__filename__ = "webapp_post.py"
__author__ = "Bob Mottram"
__license__ = "AGPL3+"
__version__ = "1.2.0"
__maintainer__ = "Bob Mottram"
__email__ = "bob@libreserver.org"
__status__ = "Production"
__module_group__ = "Web Interface"
import os
import time
import urllib.parse
from dateutil.parser import parse
from auth import create_password
from git import is_git_patch
from datetime import datetime
from cache import get_person_from_cache
from bookmarks import bookmarked_by_person
from like import liked_by_person
from like import no_of_likes
from follow import is_following_actor
from posts import post_is_muted
from posts import get_person_box
from posts import download_announce
from posts import populate_replies_json
from utils import remove_hash_from_post_id
from utils import remove_html
from utils import get_actor_languages_list
from utils import get_base_content_from_post
from utils import get_content_from_post
from utils import has_object_dict
from utils import update_announce_collection
from utils import is_pgp_encrypted
from utils import is_dm
from utils import reject_post_id
from utils import is_recent_post
from utils import get_config_param
from utils import get_full_domain
from utils import is_editor
from utils import locate_post
from utils import load_json
from utils import get_cached_post_directory
from utils import get_cached_post_filename
from utils import get_protocol_prefixes
from utils import is_news_post
from utils import is_blog_post
from utils import get_display_name
from utils import is_public_post
from utils import update_recent_posts_cache
from utils import remove_id_ending
from utils import get_nickname_from_actor
from utils import get_domain_from_actor
from utils import acct_dir
from utils import local_actor_url
from content import limit_repeated_words
from content import replace_emoji_from_tags
from content import html_replace_quote_marks
from content import html_replace_email_quote
from content import remove_text_formatting
from content import remove_long_words
from content import get_mentions_from_html
from content import switch_words
from person import is_person_snoozed
from person import get_person_avatar_url
from announce import announced_by_person
from webapp_utils import get_banner_file
from webapp_utils import get_avatar_image_url
from webapp_utils import update_avatar_image_cache
from webapp_utils import load_individual_post_as_html_from_cache
from webapp_utils import add_emoji_to_display_name
from webapp_utils import post_contains_public
from webapp_utils import get_content_warning_button
from webapp_utils import get_post_attachments_as_html
from webapp_utils import html_header_with_external_style
from webapp_utils import html_footer
from webapp_utils import get_broken_link_substitute
from webapp_media import add_embedded_elements
from webapp_question import insert_question
from devices import e2e_edecrypt_message_from_device
from webfinger import webfinger_handle
from speaker import update_speaker
from languages import auto_translate_post
from blocking import is_blocked
from blocking import add_cw_from_lists
from reaction import html_emoji_reactions
def _html_post_metadata_open_graph(domain: str, post_json_object: {}) -> str:
"""Returns html OpenGraph metadata for a post
"""
metadata = \
" <meta content=\"" + domain + "\" property=\"og:site_name\" />\n"
metadata += \
" <meta content=\"article\" property=\"og:type\" />\n"
objJson = post_json_object
if has_object_dict(post_json_object):
objJson = post_json_object['object']
if objJson.get('attributedTo'):
if isinstance(objJson['attributedTo'], str):
attrib = objJson['attributedTo']
actorNick = get_nickname_from_actor(attrib)
actorDomain, _ = get_domain_from_actor(attrib)
actorHandle = actorNick + '@' + actorDomain
metadata += \
" <meta content=\"@" + actorHandle + \
"\" property=\"og:title\" />\n"
if objJson.get('url'):
metadata += \
" <meta content=\"" + objJson['url'] + \
"\" property=\"og:url\" />\n"
if objJson.get('published'):
metadata += \
" <meta content=\"" + objJson['published'] + \
"\" property=\"og:published_time\" />\n"
if not objJson.get('attachment') or objJson.get('sensitive'):
if objJson.get('content') and not objJson.get('sensitive'):
description = remove_html(objJson['content'])
metadata += \
" <meta content=\"" + description + \
"\" name=\"description\">\n"
metadata += \
" <meta content=\"" + description + \
"\" name=\"og:description\">\n"
return metadata
# metadata for attachment
for attachJson in objJson['attachment']:
if not isinstance(attachJson, dict):
continue
if not attachJson.get('mediaType'):
continue
if not attachJson.get('url'):
continue
if not attachJson.get('name'):
continue
description = None
if attachJson['mediaType'].startswith('image/'):
description = 'Attached: 1 image'
elif attachJson['mediaType'].startswith('video/'):
description = 'Attached: 1 video'
elif attachJson['mediaType'].startswith('audio/'):
description = 'Attached: 1 audio'
if description:
if objJson.get('content') and not objJson.get('sensitive'):
description += '\n\n' + remove_html(objJson['content'])
metadata += \
" <meta content=\"" + description + \
"\" name=\"description\">\n"
metadata += \
" <meta content=\"" + description + \
"\" name=\"og:description\">\n"
metadata += \
" <meta content=\"" + attachJson['url'] + \
"\" property=\"og:image\" />\n"
metadata += \
" <meta content=\"" + attachJson['mediaType'] + \
"\" property=\"og:image:type\" />\n"
if attachJson.get('width'):
metadata += \
" <meta content=\"" + str(attachJson['width']) + \
"\" property=\"og:image:width\" />\n"
if attachJson.get('height'):
metadata += \
" <meta content=\"" + str(attachJson['height']) + \
"\" property=\"og:image:height\" />\n"
metadata += \
" <meta content=\"" + attachJson['name'] + \
"\" property=\"og:image:alt\" />\n"
if attachJson['mediaType'].startswith('image/'):
metadata += \
" <meta content=\"summary_large_image\" " + \
"property=\"twitter:card\" />\n"
return metadata
def _log_post_timing(enableTimingLog: bool, postStartTime,
debugId: str) -> None:
"""Create a log of timings for performance tuning
"""
if not enableTimingLog:
return
timeDiff = int((time.time() - postStartTime) * 1000)
if timeDiff > 100:
print('TIMING INDIV ' + debugId + ' = ' + str(timeDiff))
def prepare_html_post_nickname(nickname: str, postHtml: str) -> str:
"""html posts stored in memory are for all accounts on the instance
and they're indexed by id. However, some incoming posts may be
destined for multiple accounts (followers). This creates a problem
where the icon links whose urls begin with href="/users/nickname?
need to be changed for different nicknames to display correctly
within their timelines.
This function changes the nicknames for the icon links.
"""
# replace the nickname
usersStr = ' href="/users/'
if usersStr not in postHtml:
return postHtml
userFound = True
postStr = postHtml
newPostStr = ''
while userFound:
if usersStr not in postStr:
newPostStr += postStr
break
# the next part, after href="/users/nickname?
nextStr = postStr.split(usersStr, 1)[1]
if '?' in nextStr:
nextStr = nextStr.split('?', 1)[1]
else:
newPostStr += postStr
break
# append the previous text to the result
newPostStr += postStr.split(usersStr)[0]
newPostStr += usersStr + nickname + '?'
# post is now the next part
postStr = nextStr
return newPostStr
def prepare_post_from_html_cache(nickname: str, postHtml: str, boxName: str,
pageNumber: int) -> str:
"""Sets the page number on a cached html post
"""
# if on the bookmarks timeline then remain there
if boxName == 'tlbookmarks' or boxName == 'bookmarks':
postHtml = postHtml.replace('?tl=inbox', '?tl=tlbookmarks')
if '?page=' in postHtml:
pageNumberStr = postHtml.split('?page=')[1]
if '?' in pageNumberStr:
pageNumberStr = pageNumberStr.split('?')[0]
postHtml = postHtml.replace('?page=' + pageNumberStr, '?page=-999')
withPageNumber = postHtml.replace(';-999;', ';' + str(pageNumber) + ';')
withPageNumber = withPageNumber.replace('?page=-999',
'?page=' + str(pageNumber))
return prepare_html_post_nickname(nickname, withPageNumber)
def _save_individual_post_as_html_to_cache(base_dir: str,
nickname: str, domain: str,
post_json_object: {},
postHtml: str) -> bool:
"""Saves the given html for a post to a cache file
This is so that it can be quickly reloaded on subsequent
refresh of the timeline
"""
htmlPostCacheDir = \
get_cached_post_directory(base_dir, nickname, domain)
cachedPostFilename = \
get_cached_post_filename(base_dir, nickname, domain, post_json_object)
# create the cache directory if needed
if not os.path.isdir(htmlPostCacheDir):
os.mkdir(htmlPostCacheDir)
try:
with open(cachedPostFilename, 'w+') as fp:
fp.write(postHtml)
return True
except Exception as ex:
print('ERROR: saving post to cache, ' + str(ex))
return False
def _get_post_from_recent_cache(session,
base_dir: str,
http_prefix: str,
nickname: str, domain: str,
post_json_object: {},
postActor: str,
person_cache: {},
allowDownloads: bool,
showPublicOnly: bool,
storeToCache: bool,
boxName: str,
avatarUrl: str,
enableTimingLog: bool,
postStartTime,
pageNumber: int,
recent_posts_cache: {},
max_recent_posts: int,
signing_priv_key_pem: str) -> str:
"""Attempts to get the html post from the recent posts cache in memory
"""
if boxName == 'tlmedia':
return None
if showPublicOnly:
return None
tryCache = False
bmTimeline = boxName == 'bookmarks' or boxName == 'tlbookmarks'
if storeToCache or bmTimeline:
tryCache = True
if not tryCache:
return None
# update avatar if needed
if not avatarUrl:
avatarUrl = \
get_person_avatar_url(base_dir, postActor, person_cache,
allowDownloads)
_log_post_timing(enableTimingLog, postStartTime, '2.1')
update_avatar_image_cache(signing_priv_key_pem,
session, base_dir, http_prefix,
postActor, avatarUrl, person_cache,
allowDownloads)
_log_post_timing(enableTimingLog, postStartTime, '2.2')
postHtml = \
load_individual_post_as_html_from_cache(base_dir, nickname, domain,
post_json_object)
if not postHtml:
return None
postHtml = \
prepare_post_from_html_cache(nickname, postHtml, boxName, pageNumber)
update_recent_posts_cache(recent_posts_cache, max_recent_posts,
post_json_object, postHtml)
_log_post_timing(enableTimingLog, postStartTime, '3')
return postHtml
def _get_avatar_image_html(showAvatarOptions: bool,
nickname: str, domain_full: str,
avatarUrl: str, postActor: str,
translate: {}, avatarPosition: str,
pageNumber: int, messageIdStr: str) -> str:
"""Get html for the avatar image
"""
avatarLink = ''
if '/users/news/' not in avatarUrl:
avatarLink = ' <a class="imageAnchor" href="' + postActor + '">'
showProfileStr = 'Show profile'
if translate.get(showProfileStr):
showProfileStr = translate[showProfileStr]
avatarLink += \
'<img loading="lazy" src="' + avatarUrl + '" title="' + \
showProfileStr + '" alt=" "' + avatarPosition + \
get_broken_link_substitute() + '/></a>\n'
if showAvatarOptions and \
domain_full + '/users/' + nickname not in postActor:
showOptionsForThisPersonStr = 'Show options for this person'
if translate.get(showOptionsForThisPersonStr):
showOptionsForThisPersonStr = \
translate[showOptionsForThisPersonStr]
if '/users/news/' not in avatarUrl:
avatarLink = \
' <a class="imageAnchor" href="/users/' + \
nickname + '?options=' + postActor + \
';' + str(pageNumber) + ';' + avatarUrl + messageIdStr + '">\n'
avatarLink += \
' <img loading="lazy" title="' + \
showOptionsForThisPersonStr + '" ' + \
'alt="👤 ' + \
showOptionsForThisPersonStr + '" ' + \
'src="' + avatarUrl + '" ' + avatarPosition + \
get_broken_link_substitute() + '/></a>\n'
else:
# don't link to the person options for the news account
avatarLink += \
' <img loading="lazy" title="' + \
showOptionsForThisPersonStr + '" ' + \
'alt="👤 ' + \
showOptionsForThisPersonStr + '" ' + \
'src="' + avatarUrl + '" ' + avatarPosition + \
get_broken_link_substitute() + '/>\n'
return avatarLink.strip()
def _get_reply_icon_html(base_dir: str, nickname: str, domain: str,
isPublicRepeat: bool,
showIcons: bool, commentsEnabled: bool,
post_json_object: {}, pageNumberParam: str,
translate: {}, system_language: str,
conversationId: str) -> str:
"""Returns html for the reply icon/button
"""
replyStr = ''
if not (showIcons and commentsEnabled):
return replyStr
# reply is permitted - create reply icon
replyToLink = remove_hash_from_post_id(post_json_object['object']['id'])
replyToLink = remove_id_ending(replyToLink)
# see Mike MacGirvin's replyTo suggestion
if post_json_object['object'].get('replyTo'):
# check that the alternative replyTo url is not blocked
blockNickname = \
get_nickname_from_actor(post_json_object['object']['replyTo'])
blockDomain, _ = \
get_domain_from_actor(post_json_object['object']['replyTo'])
if not is_blocked(base_dir, nickname, domain,
blockNickname, blockDomain, {}):
replyToLink = post_json_object['object']['replyTo']
if post_json_object['object'].get('attributedTo'):
if isinstance(post_json_object['object']['attributedTo'], str):
replyToLink += \
'?mention=' + post_json_object['object']['attributedTo']
content = get_base_content_from_post(post_json_object, system_language)
if content:
mentionedActors = \
get_mentions_from_html(content,
"<span class=\"h-card\"><a href=\"")
if mentionedActors:
for actorUrl in mentionedActors:
if '?mention=' + actorUrl not in replyToLink:
replyToLink += '?mention=' + actorUrl
if len(replyToLink) > 500:
break
replyToLink += pageNumberParam
replyStr = ''
replyToThisPostStr = 'Reply to this post'
if translate.get(replyToThisPostStr):
replyToThisPostStr = translate[replyToThisPostStr]
conversationStr = ''
if conversationId:
conversationStr = '?conversationId=' + conversationId
if isPublicRepeat:
replyStr += \
' <a class="imageAnchor" href="/users/' + \
nickname + '?replyto=' + replyToLink + \
'?actor=' + post_json_object['actor'] + \
conversationStr + \
'" title="' + replyToThisPostStr + '">\n'
else:
if is_dm(post_json_object):
replyStr += \
' ' + \
'<a class="imageAnchor" href="/users/' + nickname + \
'?replydm=' + replyToLink + \
'?actor=' + post_json_object['actor'] + \
conversationStr + \
'" title="' + replyToThisPostStr + '">\n'
else:
replyStr += \
' ' + \
'<a class="imageAnchor" href="/users/' + nickname + \
'?replyfollowers=' + replyToLink + \
'?actor=' + post_json_object['actor'] + \
conversationStr + \
'" title="' + replyToThisPostStr + '">\n'
replyStr += \
' ' + \
'<img loading="lazy" title="' + \
replyToThisPostStr + '" alt="' + replyToThisPostStr + \
' |" src="/icons/reply.png"/></a>\n'
return replyStr
def _get_edit_icon_html(base_dir: str, nickname: str, domain_full: str,
post_json_object: {}, actorNickname: str,
translate: {}, isEvent: bool) -> str:
"""Returns html for the edit icon/button
"""
editStr = ''
actor = post_json_object['actor']
# This should either be a post which you created,
# or it could be generated from the newswire (see
# _add_blogs_to_newswire) in which case anyone with
# editor status should be able to alter it
if (actor.endswith('/' + domain_full + '/users/' + nickname) or
(is_editor(base_dir, nickname) and
actor.endswith('/' + domain_full + '/users/news'))):
post_id = remove_id_ending(post_json_object['object']['id'])
if '/statuses/' not in post_id:
return editStr
if is_blog_post(post_json_object):
editBlogPostStr = 'Edit blog post'
if translate.get(editBlogPostStr):
editBlogPostStr = translate[editBlogPostStr]
if not is_news_post(post_json_object):
editStr += \
' ' + \
'<a class="imageAnchor" href="/users/' + \
nickname + \
'/tlblogs?editblogpost=' + \
post_id.split('/statuses/')[1] + \
';actor=' + actorNickname + \
'" title="' + editBlogPostStr + '">' + \
'<img loading="lazy" title="' + \
editBlogPostStr + '" alt="' + editBlogPostStr + \
' |" src="/icons/edit.png"/></a>\n'
else:
editStr += \
' ' + \
'<a class="imageAnchor" href="/users/' + \
nickname + '/editnewspost=' + \
post_id.split('/statuses/')[1] + \
'?actor=' + actorNickname + \
'" title="' + editBlogPostStr + '">' + \
'<img loading="lazy" title="' + \
editBlogPostStr + '" alt="' + editBlogPostStr + \
' |" src="/icons/edit.png"/></a>\n'
elif isEvent:
editEventStr = 'Edit event'
if translate.get(editEventStr):
editEventStr = translate[editEventStr]
editStr += \
' ' + \
'<a class="imageAnchor" href="/users/' + nickname + \
'/tlblogs?editeventpost=' + \
post_id.split('/statuses/')[1] + \
'?actor=' + actorNickname + \
'" title="' + editEventStr + '">' + \
'<img loading="lazy" title="' + \
editEventStr + '" alt="' + editEventStr + \
' |" src="/icons/edit.png"/></a>\n'
return editStr
def _get_announce_icon_html(isAnnounced: bool,
postActor: str,
nickname: str, domain_full: str,
announceJsonObject: {},
post_json_object: {},
isPublicRepeat: bool,
isModerationPost: bool,
showRepeatIcon: bool,
translate: {},
pageNumberParam: str,
timelinePostBookmark: str,
boxName: str) -> str:
"""Returns html for announce icon/button
"""
announceStr = ''
if not showRepeatIcon:
return announceStr
if isModerationPost:
return announceStr
# don't allow announce/repeat of your own posts
announceIcon = 'repeat_inactive.png'
announceLink = 'repeat'
announceEmoji = ''
if not isPublicRepeat:
announceLink = 'repeatprivate'
repeatThisPostStr = 'Repeat this post'
if translate.get(repeatThisPostStr):
repeatThisPostStr = translate[repeatThisPostStr]
announceTitle = repeatThisPostStr
unannounceLinkStr = ''
if announced_by_person(isAnnounced,
postActor, nickname, domain_full):
announceIcon = 'repeat.png'
announceEmoji = '🔁 '
announceLink = 'unrepeat'
if not isPublicRepeat:
announceLink = 'unrepeatprivate'
undoTheRepeatStr = 'Undo the repeat'
if translate.get(undoTheRepeatStr):
undoTheRepeatStr = translate[undoTheRepeatStr]
announceTitle = undoTheRepeatStr
if announceJsonObject:
unannounceLinkStr = '?unannounce=' + \
remove_id_ending(announceJsonObject['id'])
announcePostId = remove_hash_from_post_id(post_json_object['object']['id'])
announcePostId = remove_id_ending(announcePostId)
announceLinkStr = '?' + \
announceLink + '=' + announcePostId + pageNumberParam
announceStr = \
' <a class="imageAnchor" href="/users/' + \
nickname + announceLinkStr + unannounceLinkStr + \
'?actor=' + post_json_object['actor'] + \
'?bm=' + timelinePostBookmark + \
'?tl=' + boxName + '" title="' + announceTitle + '">\n'
announceStr += \
' ' + \
'<img loading="lazy" title="' + announceTitle + \
'" alt="' + announceEmoji + announceTitle + \
' |" src="/icons/' + announceIcon + '"/></a>\n'
return announceStr
def _get_like_icon_html(nickname: str, domain_full: str,
isModerationPost: bool,
showLikeButton: bool,
post_json_object: {},
enableTimingLog: bool,
postStartTime,
translate: {}, pageNumberParam: str,
timelinePostBookmark: str,
boxName: str,
max_like_count: int) -> str:
"""Returns html for like icon/button
"""
if not showLikeButton or isModerationPost:
return ''
likeStr = ''
likeIcon = 'like_inactive.png'
likeLink = 'like'
likeTitle = 'Like this post'
if translate.get(likeTitle):
likeTitle = translate[likeTitle]
likeEmoji = ''
likeCount = no_of_likes(post_json_object)
_log_post_timing(enableTimingLog, postStartTime, '12.1')
likeCountStr = ''
if likeCount > 0:
if likeCount <= max_like_count:
likeCountStr = ' (' + str(likeCount) + ')'
else:
likeCountStr = ' (' + str(max_like_count) + '+)'
if liked_by_person(post_json_object, nickname, domain_full):
if likeCount == 1:
# liked by the reader only
likeCountStr = ''
likeIcon = 'like.png'
likeLink = 'unlike'
likeTitle = 'Undo the like'
if translate.get(likeTitle):
likeTitle = translate[likeTitle]
likeEmoji = '👍 '
_log_post_timing(enableTimingLog, postStartTime, '12.2')
likeStr = ''
if likeCountStr:
# show the number of likes next to icon
likeStr += '<label class="likesCount">'
likeStr += likeCountStr.replace('(', '').replace(')', '').strip()
likeStr += '</label>\n'
like_postId = remove_hash_from_post_id(post_json_object['id'])
like_postId = remove_id_ending(like_postId)
likeStr += \
' <a class="imageAnchor" href="/users/' + nickname + '?' + \
likeLink + '=' + like_postId + \
pageNumberParam + \
'?actor=' + post_json_object['actor'] + \
'?bm=' + timelinePostBookmark + \
'?tl=' + boxName + '" title="' + \
likeTitle + likeCountStr + '">\n'
likeStr += \
' ' + \
'<img loading="lazy" title="' + likeTitle + likeCountStr + \
'" alt="' + likeEmoji + likeTitle + \
' |" src="/icons/' + likeIcon + '"/></a>\n'
return likeStr
def _get_bookmark_icon_html(nickname: str, domain_full: str,
post_json_object: {},
isModerationPost: bool,
translate: {},
enableTimingLog: bool,
postStartTime, boxName: str,
pageNumberParam: str,
timelinePostBookmark: str) -> str:
"""Returns html for bookmark icon/button
"""
bookmarkStr = ''
if isModerationPost:
return bookmarkStr
bookmarkIcon = 'bookmark_inactive.png'
bookmarkLink = 'bookmark'
bookmarkEmoji = ''
bookmarkTitle = 'Bookmark this post'
if translate.get(bookmarkTitle):
bookmarkTitle = translate[bookmarkTitle]
if bookmarked_by_person(post_json_object, nickname, domain_full):
bookmarkIcon = 'bookmark.png'
bookmarkLink = 'unbookmark'
bookmarkEmoji = '🔖 '
bookmarkTitle = 'Undo the bookmark'
if translate.get(bookmarkTitle):
bookmarkTitle = translate[bookmarkTitle]
_log_post_timing(enableTimingLog, postStartTime, '12.6')
bookmarkPostId = remove_hash_from_post_id(post_json_object['object']['id'])
bookmarkPostId = remove_id_ending(bookmarkPostId)
bookmarkStr = \
' <a class="imageAnchor" href="/users/' + nickname + '?' + \
bookmarkLink + '=' + bookmarkPostId + \
pageNumberParam + \
'?actor=' + post_json_object['actor'] + \
'?bm=' + timelinePostBookmark + \
'?tl=' + boxName + '" title="' + bookmarkTitle + '">\n'
bookmarkStr += \
' ' + \
'<img loading="lazy" title="' + bookmarkTitle + '" alt="' + \
bookmarkEmoji + bookmarkTitle + ' |" src="/icons' + \
'/' + bookmarkIcon + '"/></a>\n'
return bookmarkStr
def _get_reaction_icon_html(nickname: str, domain_full: str,
post_json_object: {},
isModerationPost: bool,
showReactionButton: bool,
translate: {},
enableTimingLog: bool,
postStartTime, boxName: str,
pageNumberParam: str,
timelinePostReaction: str) -> str:
"""Returns html for reaction icon/button
"""
reactionStr = ''
if not showReactionButton or isModerationPost:
return reactionStr
reactionIcon = 'reaction.png'
reactionTitle = 'Select reaction'
if translate.get(reactionTitle):
reactionTitle = translate[reactionTitle]
_log_post_timing(enableTimingLog, postStartTime, '12.65')
reaction_postId = \
remove_hash_from_post_id(post_json_object['object']['id'])
reaction_postId = remove_id_ending(reaction_postId)
reactionStr = \
' <a class="imageAnchor" href="/users/' + nickname + \
'?selreact=' + reaction_postId + pageNumberParam + \
'?actor=' + post_json_object['actor'] + \
'?bm=' + timelinePostReaction + \
'?tl=' + boxName + '" title="' + reactionTitle + '">\n'
reactionStr += \
' ' + \
'<img loading="lazy" title="' + reactionTitle + '" alt="' + \
reactionTitle + ' |" src="/icons' + \
'/' + reactionIcon + '"/></a>\n'
return reactionStr
def _get_mute_icon_html(is_muted: bool,
postActor: str,
messageId: str,
nickname: str, domain_full: str,
allow_deletion: bool,
pageNumberParam: str,
boxName: str,
timelinePostBookmark: str,
translate: {}) -> str:
"""Returns html for mute icon/button
"""
muteStr = ''
if (allow_deletion or
('/' + domain_full + '/' in postActor and
messageId.startswith(postActor))):
return muteStr
if not is_muted:
muteThisPostStr = 'Mute this post'
if translate.get('Mute this post'):
muteThisPostStr = translate[muteThisPostStr]
muteStr = \
' <a class="imageAnchor" href="/users/' + nickname + \
'?mute=' + messageId + pageNumberParam + '?tl=' + boxName + \
'?bm=' + timelinePostBookmark + \
'" title="' + muteThisPostStr + '">\n'
muteStr += \
' ' + \
'<img loading="lazy" alt="' + \
muteThisPostStr + \
' |" title="' + muteThisPostStr + \
'" src="/icons/mute.png"/></a>\n'
else:
undoMuteStr = 'Undo mute'
if translate.get(undoMuteStr):
undoMuteStr = translate[undoMuteStr]
muteStr = \
' <a class="imageAnchor" href="/users/' + \
nickname + '?unmute=' + messageId + \
pageNumberParam + '?tl=' + boxName + '?bm=' + \
timelinePostBookmark + '" title="' + undoMuteStr + '">\n'
muteStr += \
' ' + \
'<img loading="lazy" alt="🔇 ' + undoMuteStr + \
' |" title="' + undoMuteStr + \
'" src="/icons/unmute.png"/></a>\n'
return muteStr
def _get_delete_icon_html(nickname: str, domain_full: str,
allow_deletion: bool,
postActor: str,
messageId: str,
post_json_object: {},
pageNumberParam: str,
translate: {}) -> str:
"""Returns html for delete icon/button
"""
deleteStr = ''
if (allow_deletion or
('/' + domain_full + '/' in postActor and
messageId.startswith(postActor))):
if '/users/' + nickname + '/' in messageId:
if not is_news_post(post_json_object):
deleteThisPostStr = 'Delete this post'
if translate.get(deleteThisPostStr):
deleteThisPostStr = translate[deleteThisPostStr]
deleteStr = \
' <a class="imageAnchor" href="/users/' + \
nickname + \
'?delete=' + messageId + pageNumberParam + \
'" title="' + deleteThisPostStr + '">\n'
deleteStr += \
' ' + \
'<img loading="lazy" alt="' + \
deleteThisPostStr + \
' |" title="' + deleteThisPostStr + \
'" src="/icons/delete.png"/></a>\n'
return deleteStr
def _get_published_date_str(post_json_object: {},
show_published_date_only: bool) -> str:
"""Return the html for the published date on a post
"""
publishedStr = ''
if not post_json_object['object'].get('published'):
return publishedStr
publishedStr = post_json_object['object']['published']
if '.' not in publishedStr:
if '+' not in publishedStr:
datetimeObject = \
datetime.strptime(publishedStr, "%Y-%m-%dT%H:%M:%SZ")
else:
datetimeObject = \
datetime.strptime(publishedStr.split('+')[0] + 'Z',
"%Y-%m-%dT%H:%M:%SZ")
else:
publishedStr = \
publishedStr.replace('T', ' ').split('.')[0]
datetimeObject = parse(publishedStr)
if not show_published_date_only:
publishedStr = datetimeObject.strftime("%a %b %d, %H:%M")
else:
publishedStr = datetimeObject.strftime("%a %b %d")
# if the post has replies then append a symbol to indicate this
if post_json_object.get('hasReplies'):
if post_json_object['hasReplies'] is True:
publishedStr = '[' + publishedStr + ']'
return publishedStr
def _get_blog_citations_html(boxName: str,
post_json_object: {},
translate: {}) -> str:
"""Returns blog citations as html
"""
# show blog citations
citationsStr = ''
if not (boxName == 'tlblogs' or boxName == 'tlfeatures'):
return citationsStr
if not post_json_object['object'].get('tag'):
return citationsStr
for tagJson in post_json_object['object']['tag']:
if not isinstance(tagJson, dict):
continue
if not tagJson.get('type'):
continue
if tagJson['type'] != 'Article':
continue
if not tagJson.get('name'):
continue
if not tagJson.get('url'):
continue
citationsStr += \
'<li><a href="' + tagJson['url'] + '">' + \
'<cite>' + tagJson['name'] + '</cite></a></li>\n'
if citationsStr:
translatedCitationsStr = 'Citations'
if translate.get(translatedCitationsStr):
translatedCitationsStr = translate[translatedCitationsStr]
citationsStr = '<p><b>' + translatedCitationsStr + ':</b></p>' + \
'<ul>\n' + citationsStr + '</ul>\n'
return citationsStr
def _boost_own_post_html(translate: {}) -> str:
"""The html title for announcing your own post
"""
announcesStr = 'announces'
if translate.get(announcesStr):
announcesStr = translate[announcesStr]
return ' <img loading="lazy" title="' + \
announcesStr + \
'" alt="' + announcesStr + \
'" src="/icons' + \
'/repeat_inactive.png" class="announceOrReply"/>\n'
def _announce_unattributed_html(translate: {},
post_json_object: {}) -> str:
"""Returns the html for an announce title where there
is no attribution on the announced post
"""
announcesStr = 'announces'
if translate.get(announcesStr):
announcesStr = translate[announcesStr]
post_id = remove_id_ending(post_json_object['object']['id'])
return ' <img loading="lazy" title="' + \
announcesStr + '" alt="' + \
announcesStr + '" src="/icons' + \
'/repeat_inactive.png" ' + \
'class="announceOrReply"/>\n' + \
' <a href="' + post_id + \
'" class="announceOrReply">@unattributed</a>\n'
def _announce_with_display_name_html(translate: {},
post_json_object: {},
announceDisplayName: str) -> str:
"""Returns html for an announce having a display name
"""
announcesStr = 'announces'
if translate.get(announcesStr):
announcesStr = translate[announcesStr]
post_id = remove_id_ending(post_json_object['object']['id'])
return ' <img loading="lazy" title="' + \
announcesStr + '" alt="' + \
announcesStr + '" src="/' + \
'icons/repeat_inactive.png" ' + \
'class="announceOrReply"/>\n' + \
' <a href="' + post_id + '" ' + \
'class="announceOrReply">' + announceDisplayName + '</a>\n'
def _get_post_title_announce_html(base_dir: str,
http_prefix: str,
nickname: str, domain: str,
showRepeatIcon: bool,
isAnnounced: bool,
post_json_object: {},
postActor: str,
translate: {},
enableTimingLog: bool,
postStartTime,
boxName: str,
person_cache: {},
allowDownloads: bool,
avatarPosition: str,
pageNumber: int,
messageIdStr: str,
containerClassIcons: str,
containerClass: str) -> (str, str, str, str):
"""Returns the announce title of a post containing names of participants
x announces y
"""
titleStr = ''
replyAvatarImageInPost = ''
objJson = post_json_object['object']
# has no attribution
if not objJson.get('attributedTo'):
titleStr += _announce_unattributed_html(translate, post_json_object)
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
attributedTo = ''
if isinstance(objJson['attributedTo'], str):
attributedTo = objJson['attributedTo']
# boosting your own post
if attributedTo.startswith(postActor):
titleStr += _boost_own_post_html(translate)
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
# boosting another person's post
_log_post_timing(enableTimingLog, postStartTime, '13.2')
announceNickname = None
if attributedTo:
announceNickname = get_nickname_from_actor(attributedTo)
if not announceNickname:
titleStr += _announce_unattributed_html(translate, post_json_object)
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
announceDomain, announcePort = get_domain_from_actor(attributedTo)
get_person_from_cache(base_dir, attributedTo, person_cache, allowDownloads)
announceDisplayName = \
get_display_name(base_dir, attributedTo, person_cache)
if not announceDisplayName:
announceDisplayName = announceNickname + '@' + announceDomain
_log_post_timing(enableTimingLog, postStartTime, '13.3')
# add any emoji to the display name
if ':' in announceDisplayName:
announceDisplayName = \
add_emoji_to_display_name(None, base_dir, http_prefix,
nickname, domain,
announceDisplayName, False)
_log_post_timing(enableTimingLog, postStartTime, '13.3.1')
titleStr += \
_announce_with_display_name_html(translate, post_json_object,
announceDisplayName)
# show avatar of person replied to
announceActor = attributedTo
announceAvatarUrl = \
get_person_avatar_url(base_dir, announceActor,
person_cache, allowDownloads)
_log_post_timing(enableTimingLog, postStartTime, '13.4')
if not announceAvatarUrl:
announceAvatarUrl = ''
idx = 'Show options for this person'
if '/users/news/' not in announceAvatarUrl:
showOptionsForThisPersonStr = idx
if translate.get(idx):
showOptionsForThisPersonStr = translate[idx]
replyAvatarImageInPost = \
' <div class="timeline-avatar-reply">\n' \
' <a class="imageAnchor" ' + \
'href="/users/' + nickname + '?options=' + \
announceActor + ';' + str(pageNumber) + \
';' + announceAvatarUrl + messageIdStr + '">' \
'<img loading="lazy" src="' + announceAvatarUrl + '" ' + \
'title="' + showOptionsForThisPersonStr + \
'" alt=" "' + avatarPosition + \
get_broken_link_substitute() + '/></a>\n </div>\n'
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
def _reply_to_yourself_html(translate: {}) -> str:
"""Returns html for a title which is a reply to yourself
"""
replyingToThemselvesStr = 'replying to themselves'
if translate.get(replyingToThemselvesStr):
replyingToThemselvesStr = translate[replyingToThemselvesStr]
return ' <img loading="lazy" title="' + \
replyingToThemselvesStr + \
'" alt="' + replyingToThemselvesStr + \
'" src="/icons' + \
'/reply.png" class="announceOrReply"/>\n'
def _reply_to_unknown_html(translate: {},
post_json_object: {}) -> str:
"""Returns the html title for a reply to an unknown handle
"""
replyingToStr = 'replying to'
if translate.get(replyingToStr):
replyingToStr = translate[replyingToStr]
return ' <img loading="lazy" title="' + \
replyingToStr + '" alt="' + \
replyingToStr + '" src="/icons' + \
'/reply.png" class="announceOrReply"/>\n' + \
' <a href="' + \
post_json_object['object']['inReplyTo'] + \
'" class="announceOrReply">@unknown</a>\n'
def _reply_with_unknown_path_html(translate: {},
post_json_object: {},
postDomain: str) -> str:
"""Returns html title for a reply with an unknown path
eg. does not contain /statuses/
"""
replyingToStr = 'replying to'
if translate.get(replyingToStr):
replyingToStr = translate[replyingToStr]
return ' <img loading="lazy" title="' + \
replyingToStr + \
'" alt="' + replyingToStr + \
'" src="/icons/reply.png" ' + \
'class="announceOrReply"/>\n' + \
' <a href="' + \
post_json_object['object']['inReplyTo'] + \
'" class="announceOrReply">' + \
postDomain + '</a>\n'
def _get_reply_html(translate: {},
inReplyTo: str, replyDisplayName: str) -> str:
"""Returns html title for a reply
"""
replyingToStr = 'replying to'
if translate.get(replyingToStr):
replyingToStr = translate[replyingToStr]
return ' ' + \
'<img loading="lazy" title="' + \
replyingToStr + '" alt="' + \
replyingToStr + '" src="/' + \
'icons/reply.png" ' + \
'class="announceOrReply"/>\n' + \
' <a href="' + inReplyTo + \
'" class="announceOrReply">' + \
replyDisplayName + '</a>\n'
def _get_post_title_reply_html(base_dir: str,
http_prefix: str,
nickname: str, domain: str,
showRepeatIcon: bool,
isAnnounced: bool,
post_json_object: {},
postActor: str,
translate: {},
enableTimingLog: bool,
postStartTime,
boxName: str,
person_cache: {},
allowDownloads: bool,
avatarPosition: str,
pageNumber: int,
messageIdStr: str,
containerClassIcons: str,
containerClass: str) -> (str, str, str, str):
"""Returns the reply title of a post containing names of participants
x replies to y
"""
titleStr = ''
replyAvatarImageInPost = ''
objJson = post_json_object['object']
# not a reply
if not objJson.get('inReplyTo'):
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
containerClassIcons = 'containericons darker'
containerClass = 'container darker'
# reply to self
if objJson['inReplyTo'].startswith(postActor):
titleStr += _reply_to_yourself_html(translate)
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
# has a reply
if '/statuses/' not in objJson['inReplyTo']:
postDomain = objJson['inReplyTo']
prefixes = get_protocol_prefixes()
for prefix in prefixes:
postDomain = postDomain.replace(prefix, '')
if '/' in postDomain:
postDomain = postDomain.split('/', 1)[0]
if postDomain:
titleStr += \
_reply_with_unknown_path_html(translate,
post_json_object, postDomain)
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
inReplyTo = objJson['inReplyTo']
replyActor = inReplyTo.split('/statuses/')[0]
replyNickname = get_nickname_from_actor(replyActor)
if not replyNickname:
titleStr += _reply_to_unknown_html(translate, post_json_object)
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
replyDomain, replyPort = get_domain_from_actor(replyActor)
if not (replyNickname and replyDomain):
titleStr += _reply_to_unknown_html(translate, post_json_object)
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
get_person_from_cache(base_dir, replyActor, person_cache, allowDownloads)
replyDisplayName = get_display_name(base_dir, replyActor, person_cache)
if not replyDisplayName:
replyDisplayName = replyNickname + '@' + replyDomain
# add emoji to the display name
if ':' in replyDisplayName:
_log_post_timing(enableTimingLog, postStartTime, '13.5')
replyDisplayName = \
add_emoji_to_display_name(None, base_dir, http_prefix,
nickname, domain,
replyDisplayName, False)
_log_post_timing(enableTimingLog, postStartTime, '13.6')
titleStr += _get_reply_html(translate, inReplyTo, replyDisplayName)
_log_post_timing(enableTimingLog, postStartTime, '13.7')
# show avatar of person replied to
replyAvatarUrl = \
get_person_avatar_url(base_dir, replyActor, person_cache,
allowDownloads)
_log_post_timing(enableTimingLog, postStartTime, '13.8')
if replyAvatarUrl:
showProfileStr = 'Show profile'
if translate.get(showProfileStr):
showProfileStr = translate[showProfileStr]
replyAvatarImageInPost = \
' <div class="timeline-avatar-reply">\n' + \
' <a class="imageAnchor" ' + \
'href="/users/' + nickname + '?options=' + replyActor + \
';' + str(pageNumber) + ';' + replyAvatarUrl + \
messageIdStr + '">\n' + \
' <img loading="lazy" src="' + replyAvatarUrl + '" ' + \
'title="' + showProfileStr + \
'" alt=" "' + avatarPosition + get_broken_link_substitute() + \
'/></a>\n </div>\n'
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
def _get_post_title_html(base_dir: str,
http_prefix: str,
nickname: str, domain: str,
showRepeatIcon: bool,
isAnnounced: bool,
post_json_object: {},
postActor: str,
translate: {},
enableTimingLog: bool,
postStartTime,
boxName: str,
person_cache: {},
allowDownloads: bool,
avatarPosition: str,
pageNumber: int,
messageIdStr: str,
containerClassIcons: str,
containerClass: str) -> (str, str, str, str):
"""Returns the title of a post containing names of participants
x replies to y, x announces y, etc
"""
if not isAnnounced and boxName == 'search' and \
post_json_object.get('object'):
if post_json_object['object'].get('attributedTo'):
if post_json_object['object']['attributedTo'] != postActor:
isAnnounced = True
if isAnnounced:
return _get_post_title_announce_html(base_dir,
http_prefix,
nickname, domain,
showRepeatIcon,
isAnnounced,
post_json_object,
postActor,
translate,
enableTimingLog,
postStartTime,
boxName,
person_cache,
allowDownloads,
avatarPosition,
pageNumber,
messageIdStr,
containerClassIcons,
containerClass)
return _get_post_title_reply_html(base_dir,
http_prefix,
nickname, domain,
showRepeatIcon,
isAnnounced,
post_json_object,
postActor,
translate,
enableTimingLog,
postStartTime,
boxName,
person_cache,
allowDownloads,
avatarPosition,
pageNumber,
messageIdStr,
containerClassIcons,
containerClass)
def _get_footer_with_icons(showIcons: bool,
containerClassIcons: str,
replyStr: str, announceStr: str,
likeStr: str, reactionStr: str,
bookmarkStr: str,
deleteStr: str, muteStr: str, editStr: str,
post_json_object: {}, publishedLink: str,
timeClass: str, publishedStr: str) -> str:
"""Returns the html for a post footer containing icons
"""
if not showIcons:
return None
footerStr = '\n <nav>\n'
footerStr += ' <div class="' + containerClassIcons + '">\n'
footerStr += replyStr + announceStr + likeStr + bookmarkStr + reactionStr
footerStr += deleteStr + muteStr + editStr
if not is_news_post(post_json_object):
footerStr += ' <a href="' + publishedLink + '" class="' + \
timeClass + '">' + publishedStr + '</a>\n'
else:
footerStr += ' <a href="' + \
publishedLink.replace('/news/', '/news/statuses/') + \
'" class="' + timeClass + '">' + publishedStr + '</a>\n'
footerStr += ' </div>\n'
footerStr += ' </nav>\n'
return footerStr
def individual_post_as_html(signing_priv_key_pem: str,
allowDownloads: bool,
recent_posts_cache: {}, max_recent_posts: int,
translate: {},
pageNumber: int, base_dir: str,
session, cached_webfingers: {}, person_cache: {},
nickname: str, domain: str, port: int,
post_json_object: {},
avatarUrl: str, showAvatarOptions: bool,
allow_deletion: bool,
http_prefix: str, project_version: str,
boxName: str,
yt_replace_domain: str,
twitter_replacement_domain: str,
show_published_date_only: bool,
peertube_instances: [],
allow_local_network_access: bool,
theme_name: str, system_language: str,
max_like_count: int,
showRepeats: bool,
showIcons: bool,
manuallyApprovesFollowers: bool,
showPublicOnly: bool,
storeToCache: bool,
useCacheOnly: bool,
cw_lists: {},
lists_enabled: str) -> str:
""" Shows a single post as html
"""
if not post_json_object:
return ''
# maximum number of different emoji reactions which can be added to a post
maxReactionTypes = 5
# benchmark
postStartTime = time.time()
postActor = post_json_object['actor']
# ZZZzzz
if is_person_snoozed(base_dir, nickname, domain, postActor):
return ''
# if downloads of avatar images aren't enabled then we can do more
# accurate timing of different parts of the code
enableTimingLog = not allowDownloads
_log_post_timing(enableTimingLog, postStartTime, '1')
avatarPosition = ''
messageId = ''
if post_json_object.get('id'):
messageId = remove_hash_from_post_id(post_json_object['id'])
messageId = remove_id_ending(messageId)
_log_post_timing(enableTimingLog, postStartTime, '2')
messageIdStr = ''
if messageId:
messageIdStr = ';' + messageId
domain_full = get_full_domain(domain, port)
pageNumberParam = ''
if pageNumber:
pageNumberParam = '?page=' + str(pageNumber)
# get the html post from the recent posts cache if it exists there
postHtml = \
_get_post_from_recent_cache(session, base_dir,
http_prefix, nickname, domain,
post_json_object,
postActor,
person_cache,
allowDownloads,
showPublicOnly,
storeToCache,
boxName,
avatarUrl,
enableTimingLog,
postStartTime,
pageNumber,
recent_posts_cache,
max_recent_posts,
signing_priv_key_pem)
if postHtml:
return postHtml
if useCacheOnly and post_json_object['type'] != 'Announce':
return ''
_log_post_timing(enableTimingLog, postStartTime, '4')
avatarUrl = \
get_avatar_image_url(session,
base_dir, http_prefix,
postActor, person_cache,
avatarUrl, allowDownloads,
signing_priv_key_pem)
_log_post_timing(enableTimingLog, postStartTime, '5')
# get the display name
if domain_full not in postActor:
# lookup the correct webfinger for the postActor
postActorNickname = get_nickname_from_actor(postActor)
postActorDomain, postActorPort = get_domain_from_actor(postActor)
postActorDomainFull = get_full_domain(postActorDomain, postActorPort)
postActorHandle = postActorNickname + '@' + postActorDomainFull
postActorWf = \
webfinger_handle(session, postActorHandle, http_prefix,
cached_webfingers,
domain, __version__, False, False,
signing_priv_key_pem)
avatarUrl2 = None
displayName = None
if postActorWf:
originDomain = domain
(inboxUrl, pubKeyId, pubKey, fromPersonId, sharedInbox, avatarUrl2,
displayName, _) = get_person_box(signing_priv_key_pem,
originDomain,
base_dir, session,
postActorWf,
person_cache,
project_version,
http_prefix,
nickname, domain,
'outbox', 72367)
_log_post_timing(enableTimingLog, postStartTime, '6')
if avatarUrl2:
avatarUrl = avatarUrl2
if displayName:
# add any emoji to the display name
if ':' in displayName:
displayName = \
add_emoji_to_display_name(session, base_dir, http_prefix,
nickname, domain,
displayName, False)
_log_post_timing(enableTimingLog, postStartTime, '7')
avatarLink = \
_get_avatar_image_html(showAvatarOptions,
nickname, domain_full,
avatarUrl, postActor,
translate, avatarPosition,
pageNumber, messageIdStr)
avatarImageInPost = \
' <div class="timeline-avatar">' + avatarLink + '</div>\n'
timelinePostBookmark = remove_id_ending(post_json_object['id'])
timelinePostBookmark = timelinePostBookmark.replace('://', '-')
timelinePostBookmark = timelinePostBookmark.replace('/', '-')
# If this is the inbox timeline then don't show the repeat icon on any DMs
showRepeatIcon = showRepeats
isPublicRepeat = False
postIsDM = is_dm(post_json_object)
if showRepeats:
if postIsDM:
showRepeatIcon = False
else:
if not is_public_post(post_json_object):
isPublicRepeat = True
titleStr = ''
galleryStr = ''
isAnnounced = False
announceJsonObject = None
if post_json_object['type'] == 'Announce':
announceJsonObject = post_json_object.copy()
blockedCache = {}
post_jsonAnnounce = \
download_announce(session, base_dir, http_prefix,
nickname, domain, post_json_object,
project_version, translate,
yt_replace_domain,
twitter_replacement_domain,
allow_local_network_access,
recent_posts_cache, False,
system_language,
domain_full, person_cache,
signing_priv_key_pem,
blockedCache)
if not post_jsonAnnounce:
# if the announce could not be downloaded then mark it as rejected
announcedPostId = remove_id_ending(post_json_object['id'])
reject_post_id(base_dir, nickname, domain, announcedPostId,
recent_posts_cache)
return ''
post_json_object = post_jsonAnnounce
# is the announced post in the html cache?
postHtml = \
_get_post_from_recent_cache(session, base_dir,
http_prefix, nickname, domain,
post_json_object,
postActor,
person_cache,
allowDownloads,
showPublicOnly,
storeToCache,
boxName,
avatarUrl,
enableTimingLog,
postStartTime,
pageNumber,
recent_posts_cache,
max_recent_posts,
signing_priv_key_pem)
if postHtml:
return postHtml
announceFilename = \
locate_post(base_dir, nickname, domain, post_json_object['id'])
if announceFilename:
update_announce_collection(recent_posts_cache,
base_dir, announceFilename,
postActor, nickname,
domain_full, False)
# create a file for use by text-to-speech
if is_recent_post(post_json_object, 3):
if post_json_object.get('actor'):
if not os.path.isfile(announceFilename + '.tts'):
update_speaker(base_dir, http_prefix,
nickname, domain, domain_full,
post_json_object, person_cache,
translate, post_json_object['actor'],
theme_name)
with open(announceFilename + '.tts', 'w+') as ttsFile:
ttsFile.write('\n')
isAnnounced = True
_log_post_timing(enableTimingLog, postStartTime, '8')
if not has_object_dict(post_json_object):
return ''
# if this post should be public then check its recipients
if showPublicOnly:
if not post_contains_public(post_json_object):
return ''
isModerationPost = False
if post_json_object['object'].get('moderationStatus'):
isModerationPost = True
containerClass = 'container'
containerClassIcons = 'containericons'
timeClass = 'time-right'
actorNickname = get_nickname_from_actor(postActor)
if not actorNickname:
# single user instance
actorNickname = 'dev'
actorDomain, actorPort = get_domain_from_actor(postActor)
displayName = get_display_name(base_dir, postActor, person_cache)
if displayName:
if ':' in displayName:
displayName = \
add_emoji_to_display_name(session, base_dir, http_prefix,
nickname, domain,
displayName, False)
titleStr += \
' <a class="imageAnchor" href="/users/' + \
nickname + '?options=' + postActor + \
';' + str(pageNumber) + ';' + avatarUrl + messageIdStr + \
'">' + displayName + '</a>\n'
else:
if not messageId:
# pprint(post_json_object)
print('ERROR: no messageId')
if not actorNickname:
# pprint(post_json_object)
print('ERROR: no actorNickname')
if not actorDomain:
# pprint(post_json_object)
print('ERROR: no actorDomain')
titleStr += \
' <a class="imageAnchor" href="/users/' + \
nickname + '?options=' + postActor + \
';' + str(pageNumber) + ';' + avatarUrl + messageIdStr + \
'">@' + actorNickname + '@' + actorDomain + '</a>\n'
# benchmark 9
_log_post_timing(enableTimingLog, postStartTime, '9')
# Show a DM icon for DMs in the inbox timeline
if postIsDM:
titleStr = \
titleStr + ' <img loading="lazy" src="/' + \
'icons/dm.png" class="DMicon"/>\n'
# check if replying is permitted
commentsEnabled = True
if isinstance(post_json_object['object'], dict) and \
'commentsEnabled' in post_json_object['object']:
if post_json_object['object']['commentsEnabled'] is False:
commentsEnabled = False
elif 'rejectReplies' in post_json_object['object']:
if post_json_object['object']['rejectReplies']:
commentsEnabled = False
conversationId = None
if isinstance(post_json_object['object'], dict) and \
'conversation' in post_json_object['object']:
if post_json_object['object']['conversation']:
conversationId = post_json_object['object']['conversation']
publicReply = False
if is_public_post(post_json_object):
publicReply = True
replyStr = _get_reply_icon_html(base_dir, nickname, domain,
publicReply,
showIcons, commentsEnabled,
post_json_object, pageNumberParam,
translate, system_language,
conversationId)
_log_post_timing(enableTimingLog, postStartTime, '10')
editStr = _get_edit_icon_html(base_dir, nickname, domain_full,
post_json_object, actorNickname,
translate, False)
_log_post_timing(enableTimingLog, postStartTime, '11')
announceStr = \
_get_announce_icon_html(isAnnounced,
postActor,
nickname, domain_full,
announceJsonObject,
post_json_object,
isPublicRepeat,
isModerationPost,
showRepeatIcon,
translate,
pageNumberParam,
timelinePostBookmark,
boxName)
_log_post_timing(enableTimingLog, postStartTime, '12')
# whether to show a like button
hideLikeButtonFile = \
acct_dir(base_dir, nickname, domain) + '/.hideLikeButton'
showLikeButton = True
if os.path.isfile(hideLikeButtonFile):
showLikeButton = False
# whether to show a reaction button
hideReactionButtonFile = \
acct_dir(base_dir, nickname, domain) + '/.hideReactionButton'
showReactionButton = True
if os.path.isfile(hideReactionButtonFile):
showReactionButton = False
likeJsonObject = post_json_object
if announceJsonObject:
likeJsonObject = announceJsonObject
likeStr = _get_like_icon_html(nickname, domain_full,
isModerationPost,
showLikeButton,
likeJsonObject,
enableTimingLog,
postStartTime,
translate, pageNumberParam,
timelinePostBookmark,
boxName, max_like_count)
_log_post_timing(enableTimingLog, postStartTime, '12.5')
bookmarkStr = \
_get_bookmark_icon_html(nickname, domain_full,
post_json_object,
isModerationPost,
translate,
enableTimingLog,
postStartTime, boxName,
pageNumberParam,
timelinePostBookmark)
_log_post_timing(enableTimingLog, postStartTime, '12.9')
reactionStr = \
_get_reaction_icon_html(nickname, domain_full,
post_json_object,
isModerationPost,
showReactionButton,
translate,
enableTimingLog,
postStartTime, boxName,
pageNumberParam,
timelinePostBookmark)
_log_post_timing(enableTimingLog, postStartTime, '12.10')
is_muted = post_is_muted(base_dir, nickname, domain,
post_json_object, messageId)
_log_post_timing(enableTimingLog, postStartTime, '13')
muteStr = \
_get_mute_icon_html(is_muted,
postActor,
messageId,
nickname, domain_full,
allow_deletion,
pageNumberParam,
boxName,
timelinePostBookmark,
translate)
deleteStr = \
_get_delete_icon_html(nickname, domain_full,
allow_deletion,
postActor,
messageId,
post_json_object,
pageNumberParam,
translate)
_log_post_timing(enableTimingLog, postStartTime, '13.1')
# get the title: x replies to y, x announces y, etc
(titleStr2,
replyAvatarImageInPost,
containerClassIcons,
containerClass) = _get_post_title_html(base_dir,
http_prefix,
nickname, domain,
showRepeatIcon,
isAnnounced,
post_json_object,
postActor,
translate,
enableTimingLog,
postStartTime,
boxName,
person_cache,
allowDownloads,
avatarPosition,
pageNumber,
messageIdStr,
containerClassIcons,
containerClass)
titleStr += titleStr2
_log_post_timing(enableTimingLog, postStartTime, '14')
attachmentStr, galleryStr = \
get_post_attachments_as_html(post_json_object, boxName, translate,
is_muted, avatarLink,
replyStr, announceStr, likeStr,
bookmarkStr, deleteStr, muteStr)
publishedStr = \
_get_published_date_str(post_json_object, show_published_date_only)
_log_post_timing(enableTimingLog, postStartTime, '15')
publishedLink = messageId
# blog posts should have no /statuses/ in their link
if is_blog_post(post_json_object):
# is this a post to the local domain?
if '://' + domain in messageId:
publishedLink = messageId.replace('/statuses/', '/')
# if this is a local link then make it relative so that it works
# on clearnet or onion address
if domain + '/users/' in publishedLink or \
domain + ':' + str(port) + '/users/' in publishedLink:
publishedLink = '/users/' + publishedLink.split('/users/')[1]
if not is_news_post(post_json_object):
footerStr = '<a href="' + publishedLink + \
'" class="' + timeClass + '">' + publishedStr + '</a>\n'
else:
footerStr = '<a href="' + \
publishedLink.replace('/news/', '/news/statuses/') + \
'" class="' + timeClass + '">' + publishedStr + '</a>\n'
# change the background color for DMs in inbox timeline
if postIsDM:
containerClassIcons = 'containericons dm'
containerClass = 'container dm'
newFooterStr = _get_footer_with_icons(showIcons,
containerClassIcons,
replyStr, announceStr,
likeStr, reactionStr, bookmarkStr,
deleteStr, muteStr, editStr,
post_json_object, publishedLink,
timeClass, publishedStr)
if newFooterStr:
footerStr = newFooterStr
# add any content warning from the cwlists directory
add_cw_from_lists(post_json_object, cw_lists, translate, lists_enabled)
postIsSensitive = False
if post_json_object['object'].get('sensitive'):
# sensitive posts should have a summary
if post_json_object['object'].get('summary'):
postIsSensitive = post_json_object['object']['sensitive']
else:
# add a generic summary if none is provided
sensitiveStr = 'Sensitive'
if translate.get(sensitiveStr):
sensitiveStr = translate[sensitiveStr]
post_json_object['object']['summary'] = sensitiveStr
# add an extra line if there is a content warning,
# for better vertical spacing on mobile
if postIsSensitive:
footerStr = '<br>' + footerStr
if not post_json_object['object'].get('summary'):
post_json_object['object']['summary'] = ''
if post_json_object['object'].get('cipherText'):
post_json_object['object']['content'] = \
e2e_edecrypt_message_from_device(post_json_object['object'])
post_json_object['object']['contentMap'][system_language] = \
post_json_object['object']['content']
domain_full = get_full_domain(domain, port)
personUrl = local_actor_url(http_prefix, nickname, domain_full)
actor_json = \
get_person_from_cache(base_dir, personUrl, person_cache, False)
languages_understood = []
if actor_json:
languages_understood = get_actor_languages_list(actor_json)
contentStr = get_content_from_post(post_json_object, system_language,
languages_understood)
if not contentStr:
contentStr = \
auto_translate_post(base_dir, post_json_object,
system_language, translate)
if not contentStr:
return ''
isPatch = is_git_patch(base_dir, nickname, domain,
post_json_object['object']['type'],
post_json_object['object']['summary'],
contentStr)
_log_post_timing(enableTimingLog, postStartTime, '16')
if not is_pgp_encrypted(contentStr):
if not isPatch:
objectContent = \
remove_long_words(contentStr, 40, [])
objectContent = remove_text_formatting(objectContent)
objectContent = limit_repeated_words(objectContent, 6)
objectContent = \
switch_words(base_dir, nickname, domain, objectContent)
objectContent = html_replace_email_quote(objectContent)
objectContent = html_replace_quote_marks(objectContent)
else:
objectContent = contentStr
else:
encryptedStr = 'Encrypted'
if translate.get(encryptedStr):
encryptedStr = translate[encryptedStr]
objectContent = '🔒 ' + encryptedStr
objectContent = '<article>' + objectContent + '</article>'
if not postIsSensitive:
contentStr = objectContent + attachmentStr
contentStr = add_embedded_elements(translate, contentStr,
peertube_instances)
contentStr = insert_question(base_dir, translate,
nickname, domain, port,
contentStr, post_json_object,
pageNumber)
else:
postID = 'post' + str(create_password(8))
contentStr = ''
if post_json_object['object'].get('summary'):
cwStr = str(post_json_object['object']['summary'])
cwStr = \
add_emoji_to_display_name(session, base_dir, http_prefix,
nickname, domain,
cwStr, False)
contentStr += \
'<label class="cw">' + cwStr + '</label>\n '
if isModerationPost:
containerClass = 'container report'
# get the content warning text
cwContentStr = objectContent + attachmentStr
if not isPatch:
cwContentStr = add_embedded_elements(translate, cwContentStr,
peertube_instances)
cwContentStr = \
insert_question(base_dir, translate, nickname, domain, port,
cwContentStr, post_json_object, pageNumber)
cwContentStr = \
switch_words(base_dir, nickname, domain, cwContentStr)
if not is_blog_post(post_json_object):
# get the content warning button
contentStr += \
get_content_warning_button(postID, translate, cwContentStr)
else:
contentStr += cwContentStr
_log_post_timing(enableTimingLog, postStartTime, '17')
if post_json_object['object'].get('tag') and not isPatch:
contentStr = \
replace_emoji_from_tags(session, base_dir, contentStr,
post_json_object['object']['tag'],
'content', False)
if is_muted:
contentStr = ''
else:
if not isPatch:
contentStr = ' <div class="message">' + \
contentStr + \
' </div>\n'
else:
contentStr = \
'<div class="gitpatch"><pre><code>' + contentStr + \
'</code></pre></div>\n'
# show blog citations
citationsStr = \
_get_blog_citations_html(boxName, post_json_object, translate)
postHtml = ''
if boxName != 'tlmedia':
reactionStr = ''
if showIcons:
reactionStr = \
html_emoji_reactions(post_json_object, True, personUrl,
maxReactionTypes,
boxName, pageNumber)
if postIsSensitive and reactionStr:
reactionStr = '<br>' + reactionStr
postHtml = ' <div id="' + timelinePostBookmark + \
'" class="' + containerClass + '">\n'
postHtml += avatarImageInPost
postHtml += ' <div class="post-title">\n' + \
' ' + titleStr + \
replyAvatarImageInPost + ' </div>\n'
postHtml += contentStr + citationsStr + reactionStr + footerStr + '\n'
postHtml += ' </div>\n'
else:
postHtml = galleryStr
_log_post_timing(enableTimingLog, postStartTime, '18')
# save the created html to the recent posts cache
if not showPublicOnly and storeToCache and \
boxName != 'tlmedia' and boxName != 'tlbookmarks' and \
boxName != 'bookmarks':
_save_individual_post_as_html_to_cache(base_dir, nickname, domain,
post_json_object, postHtml)
update_recent_posts_cache(recent_posts_cache, max_recent_posts,
post_json_object, postHtml)
_log_post_timing(enableTimingLog, postStartTime, '19')
return postHtml
def html_individual_post(css_cache: {},
recent_posts_cache: {}, max_recent_posts: int,
translate: {},
base_dir: str, session, cached_webfingers: {},
person_cache: {},
nickname: str, domain: str, port: int,
authorized: bool,
post_json_object: {}, http_prefix: str,
project_version: str, likedBy: str,
reactBy: str, reactEmoji: str,
yt_replace_domain: str,
twitter_replacement_domain: str,
show_published_date_only: bool,
peertube_instances: [],
allow_local_network_access: bool,
theme_name: str, system_language: str,
max_like_count: int, signing_priv_key_pem: str,
cw_lists: {}, lists_enabled: str) -> str:
"""Show an individual post as html
"""
originalPostJson = post_json_object
postStr = ''
byStr = ''
byText = ''
byTextExtra = ''
if likedBy:
byStr = likedBy
byText = 'Liked by'
elif reactBy and reactEmoji:
byStr = reactBy
byText = 'Reaction by'
byTextExtra = ' ' + reactEmoji
if byStr:
byStrNickname = get_nickname_from_actor(byStr)
byStrDomain, byStrPort = get_domain_from_actor(byStr)
byStrDomain = get_full_domain(byStrDomain, byStrPort)
byStrHandle = byStrNickname + '@' + byStrDomain
if translate.get(byText):
byText = translate[byText]
postStr += \
'<p>' + byText + ' <a href="' + byStr + '">@' + \
byStrHandle + '</a>' + byTextExtra + '\n'
domain_full = get_full_domain(domain, port)
actor = '/users/' + nickname
followStr = ' <form method="POST" ' + \
'accept-charset="UTF-8" action="' + actor + '/searchhandle">\n'
followStr += \
' <input type="hidden" name="actor" value="' + actor + '">\n'
followStr += \
' <input type="hidden" name="searchtext" value="' + \
byStrHandle + '">\n'
if not is_following_actor(base_dir, nickname, domain_full, byStr):
translateFollowStr = 'Follow'
if translate.get(translateFollowStr):
translateFollowStr = translate[translateFollowStr]
followStr += ' <button type="submit" class="button" ' + \
'name="submitSearch">' + translateFollowStr + '</button>\n'
goBackStr = 'Go Back'
if translate.get(goBackStr):
goBackStr = translate[goBackStr]
followStr += ' <button type="submit" class="button" ' + \
'name="submitBack">' + goBackStr + '</button>\n'
followStr += ' </form>\n'
postStr += followStr + '</p>\n'
postStr += \
individual_post_as_html(signing_priv_key_pem,
True, recent_posts_cache, max_recent_posts,
translate, None,
base_dir, session,
cached_webfingers, person_cache,
nickname, domain, port, post_json_object,
None, True, False,
http_prefix, project_version, 'inbox',
yt_replace_domain,
twitter_replacement_domain,
show_published_date_only,
peertube_instances,
allow_local_network_access, theme_name,
system_language, max_like_count,
False, authorized, False, False, False, False,
cw_lists, lists_enabled)
messageId = remove_id_ending(post_json_object['id'])
# show the previous posts
if has_object_dict(post_json_object):
while post_json_object['object'].get('inReplyTo'):
post_filename = \
locate_post(base_dir, nickname, domain,
post_json_object['object']['inReplyTo'])
if not post_filename:
break
post_json_object = load_json(post_filename)
if post_json_object:
postStr = \
individual_post_as_html(signing_priv_key_pem,
True, recent_posts_cache,
max_recent_posts,
translate, None,
base_dir, session,
cached_webfingers,
person_cache,
nickname, domain, port,
post_json_object,
None, True, False,
http_prefix, project_version,
'inbox',
yt_replace_domain,
twitter_replacement_domain,
show_published_date_only,
peertube_instances,
allow_local_network_access,
theme_name, system_language,
max_like_count,
False, authorized,
False, False, False, False,
cw_lists, lists_enabled) + postStr
# show the following posts
post_filename = locate_post(base_dir, nickname, domain, messageId)
if post_filename:
# is there a replies file for this post?
repliesFilename = post_filename.replace('.json', '.replies')
if os.path.isfile(repliesFilename):
# get items from the replies file
repliesJson = {
'orderedItems': []
}
populate_replies_json(base_dir, nickname, domain,
repliesFilename, authorized, repliesJson)
# add items to the html output
for item in repliesJson['orderedItems']:
postStr += \
individual_post_as_html(signing_priv_key_pem,
True, recent_posts_cache,
max_recent_posts,
translate, None,
base_dir, session,
cached_webfingers,
person_cache,
nickname, domain, port, item,
None, True, False,
http_prefix, project_version,
'inbox',
yt_replace_domain,
twitter_replacement_domain,
show_published_date_only,
peertube_instances,
allow_local_network_access,
theme_name, system_language,
max_like_count,
False, authorized,
False, False, False, False,
cw_lists, lists_enabled)
cssFilename = base_dir + '/epicyon-profile.css'
if os.path.isfile(base_dir + '/epicyon.css'):
cssFilename = base_dir + '/epicyon.css'
instanceTitle = \
get_config_param(base_dir, 'instanceTitle')
metadataStr = _html_post_metadata_open_graph(domain, originalPostJson)
headerStr = html_header_with_external_style(cssFilename,
instanceTitle, metadataStr)
return headerStr + postStr + html_footer()
def html_post_replies(css_cache: {},
recent_posts_cache: {}, max_recent_posts: int,
translate: {}, base_dir: str,
session, cached_webfingers: {}, person_cache: {},
nickname: str, domain: str, port: int, repliesJson: {},
http_prefix: str, project_version: str,
yt_replace_domain: str,
twitter_replacement_domain: str,
show_published_date_only: bool,
peertube_instances: [],
allow_local_network_access: bool,
theme_name: str, system_language: str,
max_like_count: int,
signing_priv_key_pem: str, cw_lists: {},
lists_enabled: str) -> str:
"""Show the replies to an individual post as html
"""
repliesStr = ''
if repliesJson.get('orderedItems'):
for item in repliesJson['orderedItems']:
repliesStr += \
individual_post_as_html(signing_priv_key_pem,
True, recent_posts_cache,
max_recent_posts,
translate, None,
base_dir, session, cached_webfingers,
person_cache,
nickname, domain, port, item,
None, True, False,
http_prefix, project_version, 'inbox',
yt_replace_domain,
twitter_replacement_domain,
show_published_date_only,
peertube_instances,
allow_local_network_access,
theme_name, system_language,
max_like_count,
False, False, False, False,
False, False,
cw_lists, lists_enabled)
cssFilename = base_dir + '/epicyon-profile.css'
if os.path.isfile(base_dir + '/epicyon.css'):
cssFilename = base_dir + '/epicyon.css'
instanceTitle = get_config_param(base_dir, 'instanceTitle')
metadata = ''
headerStr = \
html_header_with_external_style(cssFilename, instanceTitle, metadata)
return headerStr + repliesStr + html_footer()
def html_emoji_reaction_picker(css_cache: {},
recent_posts_cache: {}, max_recent_posts: int,
translate: {},
base_dir: str, session, cached_webfingers: {},
person_cache: {},
nickname: str, domain: str, port: int,
post_json_object: {}, http_prefix: str,
project_version: str,
yt_replace_domain: str,
twitter_replacement_domain: str,
show_published_date_only: bool,
peertube_instances: [],
allow_local_network_access: bool,
theme_name: str, system_language: str,
max_like_count: int, signing_priv_key_pem: str,
cw_lists: {}, lists_enabled: str,
boxName: str, pageNumber: int) -> str:
"""Returns the emoji picker screen
"""
reactedToPostStr = \
'<br><center><label class="followText">' + \
translate['Select reaction'].title() + '</label></center>\n' + \
individual_post_as_html(signing_priv_key_pem,
True, recent_posts_cache,
max_recent_posts,
translate, None,
base_dir, session, cached_webfingers,
person_cache,
nickname, domain, port, post_json_object,
None, True, False,
http_prefix, project_version, 'inbox',
yt_replace_domain,
twitter_replacement_domain,
show_published_date_only,
peertube_instances,
allow_local_network_access,
theme_name, system_language,
max_like_count,
False, False, False, False, False, False,
cw_lists, lists_enabled)
reactionsFilename = base_dir + '/emoji/reactions.json'
if not os.path.isfile(reactionsFilename):
reactionsFilename = base_dir + '/emoji/default_reactions.json'
reactionsJson = load_json(reactionsFilename)
emojiPicksStr = ''
baseUrl = '/users/' + nickname
post_id = remove_id_ending(post_json_object['id'])
for category, item in reactionsJson.items():
emojiPicksStr += '<div class="container">\n'
for emojiContent in item:
emojiContentEncoded = urllib.parse.quote_plus(emojiContent)
emojiUrl = \
baseUrl + '?react=' + post_id + \
'?actor=' + post_json_object['actor'] + \
'?tl=' + boxName + \
'?page=' + str(pageNumber) + \
'?emojreact=' + emojiContentEncoded
emojiLabel = '<label class="rlab">' + emojiContent + '</label>'
emojiPicksStr += \
' <a href="' + emojiUrl + '">' + emojiLabel + '</a>\n'
emojiPicksStr += '</div>\n'
cssFilename = base_dir + '/epicyon-profile.css'
if os.path.isfile(base_dir + '/epicyon.css'):
cssFilename = base_dir + '/epicyon.css'
# filename of the banner shown at the top
bannerFile, _ = \
get_banner_file(base_dir, nickname, domain, theme_name)
instanceTitle = get_config_param(base_dir, 'instanceTitle')
metadata = ''
headerStr = \
html_header_with_external_style(cssFilename, instanceTitle, metadata)
# banner
headerStr += \
'<header>\n' + \
'<a href="/users/' + nickname + '/' + boxName + \
'?page=' + str(pageNumber) + '" title="' + \
translate['Switch to timeline view'] + '" alt="' + \
translate['Switch to timeline view'] + '">\n'
headerStr += '<img loading="lazy" class="timeline-banner" ' + \
'alt="" ' + \
'src="/users/' + nickname + '/' + bannerFile + '" /></a>\n' + \
'</header>\n'
return headerStr + reactedToPostStr + emojiPicksStr + html_footer()
Reference in New Issue View Git Blame Copy Permalink