epicyon/webapp_post.py

1837 lines
72 KiB
Python
Raw Normal View History

2020-11-09 19:42:09 +00:00
__filename__ = "webapp_post.py"
__author__ = "Bob Mottram"
__license__ = "AGPL3+"
2021-01-26 10:07:42 +00:00
__version__ = "1.2.0"
2020-11-09 19:42:09 +00:00
__maintainer__ = "Bob Mottram"
__email__ = "bob@freedombone.net"
__status__ = "Production"
2021-06-15 15:08:12 +00:00
__module_group__ = "Web Interface"
2020-11-09 19:42:09 +00:00
import os
import time
from dateutil.parser import parse
from auth import createPassword
from git import isGitPatch
from datetime import datetime
from cache import getPersonFromCache
from bookmarks import bookmarkedByPerson
from like import likedByPerson
from like import noOfLikes
2020-11-09 22:44:03 +00:00
from follow import isFollowingActor
2020-11-09 19:42:09 +00:00
from posts import postIsMuted
from posts import getPersonBox
from posts import downloadAnnounce
2020-11-09 22:44:03 +00:00
from posts import populateRepliesJson
from utils import getActorLanguagesList
2021-07-19 19:40:04 +00:00
from utils import getBaseContentFromPost
from utils import getContentFromPost
2021-07-06 10:00:19 +00:00
from utils import hasObjectDict
from utils import updateAnnounceCollection
from utils import isPGPEncrypted
from utils import isDM
2021-03-05 19:00:37 +00:00
from utils import rejectPostId
from utils import isRecentPost
2021-01-11 19:46:21 +00:00
from utils import getConfigParam
2020-12-16 11:19:16 +00:00
from utils import getFullDomain
2020-12-01 21:44:27 +00:00
from utils import isEditor
2020-11-09 22:44:03 +00:00
from utils import locatePost
from utils import loadJson
2020-11-09 19:42:09 +00:00
from utils import getCachedPostDirectory
from utils import getCachedPostFilename
from utils import getProtocolPrefixes
from utils import isNewsPost
from utils import isBlogPost
from utils import getDisplayName
from utils import isPublicPost
from utils import updateRecentPostsCache
from utils import removeIdEnding
from utils import getNicknameFromActor
from utils import getDomainFromActor
2021-07-13 21:59:53 +00:00
from utils import acctDir
from content import limitRepeatedWords
2020-11-09 19:42:09 +00:00
from content import replaceEmojiFromTags
from content import htmlReplaceQuoteMarks
from content import htmlReplaceEmailQuote
from content import removeTextFormatting
from content import removeLongWords
from content import getMentionsFromHtml
from content import switchWords
from person import isPersonSnoozed
2021-06-25 14:33:16 +00:00
from person import getPersonAvatarUrl
2020-11-09 19:42:09 +00:00
from announce import announcedByPerson
from webapp_utils import getAvatarImageUrl
2020-11-09 19:42:09 +00:00
from webapp_utils import updateAvatarImageCache
from webapp_utils import loadIndividualPostAsHtmlFromCache
from webapp_utils import addEmojiToDisplayName
from webapp_utils import postContainsPublic
from webapp_utils import getContentWarningButton
from webapp_utils import getPostAttachmentsAsHtml
2020-11-12 17:05:38 +00:00
from webapp_utils import htmlHeaderWithExternalStyle
2020-11-09 22:44:03 +00:00
from webapp_utils import htmlFooter
from webapp_utils import getBrokenLinkSubstitute
2020-11-09 19:42:09 +00:00
from webapp_media import addEmbeddedElements
from webapp_question import insertQuestion
from devices import E2EEdecryptMessageFromDevice
2021-01-10 10:34:29 +00:00
from webfinger import webfingerHandle
2021-03-03 19:27:29 +00:00
from speaker import updateSpeaker
2021-07-19 19:40:04 +00:00
from languages import autoTranslatePost
2020-11-09 19:42:09 +00:00
def _logPostTiming(enableTimingLog: bool, postStartTime, debugId: str) -> None:
2020-12-01 17:23:34 +00:00
"""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))
2021-02-02 21:08:33 +00:00
def prepareHtmlPostNickname(nickname: str, postHtml: str) -> str:
2021-02-02 21:54:29 +00:00
"""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.
2021-02-02 21:08:33 +00:00
"""
# 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 preparePostFromHtmlCache(nickname: str, postHtml: str, boxName: str,
pageNumber: int) -> str:
2020-11-09 19:42:09 +00:00
"""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))
2021-02-02 21:08:33 +00:00
return prepareHtmlPostNickname(nickname, withPageNumber)
2020-11-09 19:42:09 +00:00
def _saveIndividualPostAsHtmlToCache(baseDir: str,
nickname: str, domain: str,
postJsonObject: {},
postHtml: str) -> bool:
2020-11-09 19:42:09 +00:00
"""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 = \
getCachedPostDirectory(baseDir, nickname, domain)
cachedPostFilename = \
getCachedPostFilename(baseDir, nickname, domain, postJsonObject)
# 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 e:
2021-06-22 11:25:28 +00:00
print('ERROR: saving post to cache, ' + str(e))
return False
2020-11-09 19:42:09 +00:00
def _getPostFromRecentCache(session,
baseDir: str,
httpPrefix: str,
nickname: str, domain: str,
postJsonObject: {},
postActor: str,
personCache: {},
allowDownloads: bool,
showPublicOnly: bool,
storeToCache: bool,
boxName: str,
avatarUrl: str,
enableTimingLog: bool,
postStartTime,
pageNumber: int,
recentPostsCache: {},
maxRecentPosts: int) -> str:
2020-11-30 12:47:52 +00:00
"""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 = \
getPersonAvatarUrl(baseDir, postActor, personCache,
allowDownloads)
_logPostTiming(enableTimingLog, postStartTime, '2.1')
2020-11-30 12:47:52 +00:00
updateAvatarImageCache(session, baseDir, httpPrefix,
postActor, avatarUrl, personCache,
allowDownloads)
_logPostTiming(enableTimingLog, postStartTime, '2.2')
2020-11-30 12:47:52 +00:00
postHtml = \
loadIndividualPostAsHtmlFromCache(baseDir, nickname, domain,
postJsonObject)
if not postHtml:
return None
2021-02-02 21:08:33 +00:00
postHtml = \
preparePostFromHtmlCache(nickname, postHtml, boxName, pageNumber)
2020-11-30 12:47:52 +00:00
updateRecentPostsCache(recentPostsCache, maxRecentPosts,
postJsonObject, postHtml)
_logPostTiming(enableTimingLog, postStartTime, '3')
2020-11-30 12:47:52 +00:00
return postHtml
def _getAvatarImageHtml(showAvatarOptions: bool,
nickname: str, domainFull: str,
avatarUrl: str, postActor: str,
translate: {}, avatarPosition: str,
pageNumber: int, messageIdStr: str) -> str:
2020-11-30 15:20:10 +00:00
"""Get html for the avatar image
"""
avatarLink = ''
if '/users/news/' not in avatarUrl:
avatarLink = ' <a class="imageAnchor" href="' + postActor + '">'
avatarLink += \
2020-12-12 11:25:50 +00:00
'<img loading="lazy" src="' + avatarUrl + '" title="' + \
2020-11-30 15:20:10 +00:00
translate['Show profile'] + '" alt=" "' + avatarPosition + \
2020-12-09 13:31:54 +00:00
getBrokenLinkSubstitute() + '/></a>\n'
2020-11-30 15:20:10 +00:00
if showAvatarOptions and \
domainFull + '/users/' + nickname not in postActor:
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="' + \
2021-02-07 21:10:21 +00:00
translate['Show options for this person'] + '" ' + \
'alt="👤 ' + \
translate['Show options for this person'] + '" ' + \
'src="' + avatarUrl + '" ' + avatarPosition + \
2020-12-09 13:31:54 +00:00
getBrokenLinkSubstitute() + '/></a>\n'
2020-11-30 15:20:10 +00:00
else:
# don't link to the person options for the news account
avatarLink += \
' <img loading="lazy" title="' + \
2021-02-07 21:10:21 +00:00
translate['Show options for this person'] + '" ' + \
'alt="👤 ' + \
translate['Show options for this person'] + '" ' + \
'src="' + avatarUrl + '" ' + avatarPosition + \
2020-12-09 13:31:54 +00:00
getBrokenLinkSubstitute() + '/>\n'
2020-11-30 15:20:10 +00:00
return avatarLink.strip()
def _getReplyIconHtml(nickname: str, isPublicRepeat: bool,
showIcons: bool, commentsEnabled: bool,
postJsonObject: {}, pageNumberParam: str,
translate: {}, systemLanguage: str) -> str:
2020-11-30 16:00:36 +00:00
"""Returns html for the reply icon/button
"""
replyStr = ''
2020-12-01 09:51:55 +00:00
if not (showIcons and commentsEnabled):
return replyStr
# reply is permitted - create reply icon
replyToLink = postJsonObject['object']['id']
if postJsonObject['object'].get('attributedTo'):
if isinstance(postJsonObject['object']['attributedTo'], str):
replyToLink += \
'?mention=' + postJsonObject['object']['attributedTo']
2021-07-19 19:40:04 +00:00
content = getBaseContentFromPost(postJsonObject, systemLanguage)
if content:
mentionedActors = getMentionsFromHtml(content)
2020-12-01 09:51:55 +00:00
if mentionedActors:
for actorUrl in mentionedActors:
if '?mention=' + actorUrl not in replyToLink:
replyToLink += '?mention=' + actorUrl
if len(replyToLink) > 500:
break
replyToLink += pageNumberParam
replyStr = ''
2020-12-01 10:03:21 +00:00
replyToThisPostStr = translate['Reply to this post']
2020-12-01 09:51:55 +00:00
if isPublicRepeat:
replyStr += \
' <a class="imageAnchor" href="/users/' + \
nickname + '?replyto=' + replyToLink + \
'?actor=' + postJsonObject['actor'] + \
2020-12-01 10:03:21 +00:00
'" title="' + replyToThisPostStr + '">\n'
2020-12-01 09:51:55 +00:00
else:
if isDM(postJsonObject):
2020-11-30 16:00:36 +00:00
replyStr += \
2020-12-01 09:51:55 +00:00
' ' + \
'<a class="imageAnchor" href="/users/' + nickname + \
'?replydm=' + replyToLink + \
2020-11-30 16:00:36 +00:00
'?actor=' + postJsonObject['actor'] + \
2020-12-01 10:03:21 +00:00
'" title="' + replyToThisPostStr + '">\n'
2020-11-30 16:00:36 +00:00
else:
2020-12-01 09:51:55 +00:00
replyStr += \
' ' + \
'<a class="imageAnchor" href="/users/' + nickname + \
'?replyfollowers=' + replyToLink + \
'?actor=' + postJsonObject['actor'] + \
2020-12-01 10:03:21 +00:00
'" title="' + replyToThisPostStr + '">\n'
2020-11-30 16:00:36 +00:00
2020-12-01 09:51:55 +00:00
replyStr += \
' ' + \
'<img loading="lazy" title="' + \
2020-12-01 10:03:21 +00:00
replyToThisPostStr + '" alt="' + replyToThisPostStr + \
2020-12-09 13:08:26 +00:00
' |" src="/icons/reply.png"/></a>\n'
2020-11-30 16:00:36 +00:00
return replyStr
def _getEditIconHtml(baseDir: str, nickname: str, domainFull: str,
postJsonObject: {}, actorNickname: str,
translate: {}, isEvent: bool) -> str:
2020-11-30 16:48:30 +00:00
"""Returns html for the edit icon/button
"""
editStr = ''
2020-12-01 09:58:21 +00:00
actor = postJsonObject['actor']
2021-02-11 12:27:12 +00:00
# This should either be a post which you created,
# or it could be generated from the newswire (see
# _addBlogsToNewswire) in which case anyone with
# editor status should be able to alter it
2021-02-10 15:23:51 +00:00
if (actor.endswith('/' + domainFull + '/users/' + nickname) or
2020-11-30 16:48:30 +00:00
(isEditor(baseDir, nickname) and
2021-02-10 15:23:51 +00:00
actor.endswith('/' + domainFull + '/users/news'))):
2020-12-01 09:58:21 +00:00
postId = postJsonObject['object']['id']
2020-12-01 10:12:25 +00:00
if '/statuses/' not in postId:
return editStr
if isBlogPost(postJsonObject):
editBlogPostStr = translate['Edit blog post']
if not isNewsPost(postJsonObject):
2020-11-30 16:48:30 +00:00
editStr += \
' ' + \
2020-12-01 10:12:25 +00:00
'<a class="imageAnchor" href="/users/' + \
nickname + \
'/tlblogs?editblogpost=' + \
2020-12-01 09:58:21 +00:00
postId.split('/statuses/')[1] + \
2020-11-30 16:48:30 +00:00
'?actor=' + actorNickname + \
2020-12-01 10:12:25 +00:00
'" title="' + editBlogPostStr + '">' + \
2020-11-30 16:48:30 +00:00
'<img loading="lazy" title="' + \
2020-12-01 10:12:25 +00:00
editBlogPostStr + '" alt="' + editBlogPostStr + \
2020-12-09 13:08:26 +00:00
' |" src="/icons/edit.png"/></a>\n'
2020-12-01 10:12:25 +00:00
else:
editStr += \
' ' + \
'<a class="imageAnchor" href="/users/' + \
nickname + '/editnewspost=' + \
postId.split('/statuses/')[1] + \
'?actor=' + actorNickname + \
'" title="' + editBlogPostStr + '">' + \
'<img loading="lazy" title="' + \
editBlogPostStr + '" alt="' + editBlogPostStr + \
2020-12-09 13:08:26 +00:00
' |" src="/icons/edit.png"/></a>\n'
2020-12-01 10:12:25 +00:00
elif isEvent:
editEventStr = translate['Edit event']
editStr += \
' ' + \
'<a class="imageAnchor" href="/users/' + nickname + \
'/tlblogs?editeventpost=' + \
postId.split('/statuses/')[1] + \
'?actor=' + actorNickname + \
'" title="' + editEventStr + '">' + \
'<img loading="lazy" title="' + \
editEventStr + '" alt="' + editEventStr + \
2020-12-09 13:08:26 +00:00
' |" src="/icons/edit.png"/></a>\n'
2020-11-30 16:48:30 +00:00
return editStr
2021-05-07 21:10:55 +00:00
def _getAnnounceIconHtml(isAnnounced: bool,
2021-05-07 22:49:04 +00:00
postActor: str,
2021-05-07 21:10:55 +00:00
nickname: str, domainFull: str,
announceJsonObject: {},
postJsonObject: {},
isPublicRepeat: bool,
isModerationPost: bool,
showRepeatIcon: bool,
translate: {},
pageNumberParam: str,
timelinePostBookmark: str,
boxName: str) -> str:
"""Returns html for announce icon/button
"""
announceStr = ''
2021-05-07 12:42:01 +00:00
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'
announceTitle = translate['Repeat this post']
unannounceLinkStr = ''
2021-05-07 12:42:01 +00:00
2021-05-07 21:10:55 +00:00
if announcedByPerson(isAnnounced,
2021-05-07 22:49:04 +00:00
postActor, nickname, domainFull):
2021-05-07 12:42:01 +00:00
announceIcon = 'repeat.png'
announceEmoji = '🔁 '
announceLink = 'unrepeat'
if not isPublicRepeat:
2021-05-07 12:42:01 +00:00
announceLink = 'unrepeatprivate'
announceTitle = translate['Undo the repeat']
if announceJsonObject:
unannounceLinkStr = '?unannounce=' + \
2021-05-08 13:24:04 +00:00
removeIdEnding(announceJsonObject['id'])
2021-05-07 12:42:01 +00:00
announceLinkStr = '?' + \
announceLink + '=' + postJsonObject['object']['id'] + pageNumberParam
2021-05-07 12:42:01 +00:00
announceStr = \
' <a class="imageAnchor" href="/users/' + \
nickname + announceLinkStr + unannounceLinkStr + \
2021-05-07 12:42:01 +00:00
'?actor=' + postJsonObject['actor'] + \
'?bm=' + timelinePostBookmark + \
'?tl=' + boxName + '" title="' + announceTitle + '">\n'
announceStr += \
' ' + \
2021-05-07 22:07:26 +00:00
'<img loading="lazy" title="' + announceTitle + \
'" alt="' + announceEmoji + announceTitle + \
2021-05-07 12:42:01 +00:00
' |" src="/icons/' + announceIcon + '"/></a>\n'
return announceStr
def _getLikeIconHtml(nickname: str, domainFull: str,
isModerationPost: bool,
showLikeButton: bool,
postJsonObject: {},
enableTimingLog: bool,
postStartTime,
translate: {}, pageNumberParam: str,
timelinePostBookmark: str,
boxName: str,
maxLikeCount: int) -> str:
2020-11-30 17:06:55 +00:00
"""Returns html for like icon/button
"""
likeStr = ''
if not isModerationPost and showLikeButton:
likeIcon = 'like_inactive.png'
likeLink = 'like'
likeTitle = translate['Like this post']
2021-02-07 18:51:49 +00:00
likeEmoji = ''
2020-11-30 17:06:55 +00:00
likeCount = noOfLikes(postJsonObject)
_logPostTiming(enableTimingLog, postStartTime, '12.1')
2020-11-30 17:06:55 +00:00
likeCountStr = ''
if likeCount > 0:
if likeCount <= maxLikeCount:
2020-11-30 17:06:55 +00:00
likeCountStr = ' (' + str(likeCount) + ')'
else:
likeCountStr = ' (' + str(maxLikeCount) + '+)'
2020-11-30 17:06:55 +00:00
if likedByPerson(postJsonObject, nickname, domainFull):
if likeCount == 1:
# liked by the reader only
likeCountStr = ''
likeIcon = 'like.png'
likeLink = 'unlike'
likeTitle = translate['Undo the like']
2021-02-07 19:00:47 +00:00
likeEmoji = '👍 '
2020-11-30 17:06:55 +00:00
_logPostTiming(enableTimingLog, postStartTime, '12.2')
2020-11-30 17:06:55 +00:00
likeStr = ''
if likeCountStr:
# show the number of likes next to icon
likeStr += '<label class="likesCount">'
likeStr += likeCountStr.replace('(', '').replace(')', '').strip()
likeStr += '</label>\n'
likeStr += \
' <a class="imageAnchor" href="/users/' + nickname + '?' + \
likeLink + '=' + postJsonObject['object']['id'] + \
pageNumberParam + \
'?actor=' + postJsonObject['actor'] + \
'?bm=' + timelinePostBookmark + \
'?tl=' + boxName + '" title="' + \
likeTitle + likeCountStr + '">\n'
likeStr += \
' ' + \
'<img loading="lazy" title="' + likeTitle + likeCountStr + \
2021-02-07 18:51:49 +00:00
'" alt="' + likeEmoji + likeTitle + \
2020-12-09 13:08:26 +00:00
' |" src="/icons/' + likeIcon + '"/></a>\n'
2020-11-30 17:06:55 +00:00
return likeStr
def _getBookmarkIconHtml(nickname: str, domainFull: str,
postJsonObject: {},
isModerationPost: bool,
translate: {},
enableTimingLog: bool,
postStartTime, boxName: str,
pageNumberParam: str,
timelinePostBookmark: str) -> str:
"""Returns html for bookmark icon/button
"""
bookmarkStr = ''
2020-12-01 10:15:26 +00:00
if isModerationPost:
return bookmarkStr
bookmarkIcon = 'bookmark_inactive.png'
bookmarkLink = 'bookmark'
2021-02-07 19:11:30 +00:00
bookmarkEmoji = ''
2020-12-01 10:15:26 +00:00
bookmarkTitle = translate['Bookmark this post']
if bookmarkedByPerson(postJsonObject, nickname, domainFull):
bookmarkIcon = 'bookmark.png'
bookmarkLink = 'unbookmark'
2021-02-07 19:11:30 +00:00
bookmarkEmoji = '🔖 '
2020-12-01 10:15:26 +00:00
bookmarkTitle = translate['Undo the bookmark']
_logPostTiming(enableTimingLog, postStartTime, '12.6')
2020-12-01 10:15:26 +00:00
bookmarkStr = \
' <a class="imageAnchor" href="/users/' + nickname + '?' + \
bookmarkLink + '=' + postJsonObject['object']['id'] + \
pageNumberParam + \
'?actor=' + postJsonObject['actor'] + \
'?bm=' + timelinePostBookmark + \
'?tl=' + boxName + '" title="' + bookmarkTitle + '">\n'
bookmarkStr += \
' ' + \
'<img loading="lazy" title="' + bookmarkTitle + '" alt="' + \
2021-02-07 19:11:30 +00:00
bookmarkEmoji + bookmarkTitle + ' |" src="/icons' + \
2020-12-01 10:15:26 +00:00
'/' + bookmarkIcon + '"/></a>\n'
return bookmarkStr
def _getMuteIconHtml(isMuted: bool,
postActor: str,
messageId: str,
nickname: str, domainFull: str,
allowDeletion: bool,
pageNumberParam: str,
boxName: str,
timelinePostBookmark: str,
translate: {}) -> str:
2020-11-30 17:48:35 +00:00
"""Returns html for mute icon/button
"""
muteStr = ''
if (allowDeletion or
('/' + domainFull + '/' in postActor and
messageId.startswith(postActor))):
return muteStr
if not isMuted:
muteStr = \
' <a class="imageAnchor" href="/users/' + nickname + \
'?mute=' + messageId + pageNumberParam + '?tl=' + boxName + \
'?bm=' + timelinePostBookmark + \
'" title="' + translate['Mute this post'] + '">\n'
muteStr += \
' ' + \
'<img loading="lazy" alt="' + \
translate['Mute this post'] + \
' |" title="' + translate['Mute this post'] + \
2020-12-09 13:08:26 +00:00
'" src="/icons/mute.png"/></a>\n'
2020-11-30 17:48:35 +00:00
else:
muteStr = \
' <a class="imageAnchor" href="/users/' + \
nickname + '?unmute=' + messageId + \
pageNumberParam + '?tl=' + boxName + '?bm=' + \
timelinePostBookmark + '" title="' + \
translate['Undo mute'] + '">\n'
muteStr += \
' ' + \
2021-02-07 19:11:30 +00:00
'<img loading="lazy" alt="🔇 ' + translate['Undo mute'] + \
2020-11-30 17:48:35 +00:00
' |" title="' + translate['Undo mute'] + \
2020-12-09 13:08:26 +00:00
'" src="/icons/unmute.png"/></a>\n'
2020-11-30 17:48:35 +00:00
return muteStr
def _getDeleteIconHtml(nickname: str, domainFull: str,
allowDeletion: bool,
postActor: str,
messageId: str,
postJsonObject: {},
pageNumberParam: str,
translate: {}) -> str:
"""Returns html for delete icon/button
"""
deleteStr = ''
if (allowDeletion or
('/' + domainFull + '/' in postActor and
messageId.startswith(postActor))):
if '/users/' + nickname + '/' in messageId:
if not isNewsPost(postJsonObject):
deleteStr = \
' <a class="imageAnchor" href="/users/' + \
nickname + \
'?delete=' + messageId + pageNumberParam + \
'" title="' + translate['Delete this post'] + '">\n'
deleteStr += \
' ' + \
'<img loading="lazy" alt="' + \
translate['Delete this post'] + \
' |" title="' + translate['Delete this post'] + \
2020-12-09 13:08:26 +00:00
'" src="/icons/delete.png"/></a>\n'
return deleteStr
def _getPublishedDateStr(postJsonObject: {},
showPublishedDateOnly: bool) -> str:
"""Return the html for the published date on a post
"""
publishedStr = ''
2020-12-01 10:19:53 +00:00
if not postJsonObject['object'].get('published'):
return publishedStr
publishedStr = postJsonObject['object']['published']
if '.' not in publishedStr:
if '+' not in publishedStr:
datetimeObject = \
datetime.strptime(publishedStr, "%Y-%m-%dT%H:%M:%SZ")
else:
2020-12-01 10:19:53 +00:00
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 showPublishedDateOnly:
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 postJsonObject.get('hasReplies'):
if postJsonObject['hasReplies'] is True:
publishedStr = '[' + publishedStr + ']'
return publishedStr
def _getBlogCitationsHtml(boxName: str,
postJsonObject: {},
translate: {}) -> str:
2020-11-30 20:52:58 +00:00
"""Returns blog citations as html
"""
# show blog citations
citationsStr = ''
2020-12-01 10:19:53 +00:00
if not (boxName == 'tlblogs' or boxName == 'tlfeatures'):
return citationsStr
if not postJsonObject['object'].get('tag'):
return citationsStr
for tagJson in postJsonObject['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:
2020-12-01 10:30:24 +00:00
citationsStr = '<p><b>' + translate['Citations'] + ':</b></p>' + \
2020-12-01 10:19:53 +00:00
'<ul>\n' + citationsStr + '</ul>\n'
2020-11-30 20:52:58 +00:00
return citationsStr
2021-07-21 10:49:54 +00:00
def _boostOwnPostHtml(translate: {}) -> str:
2020-12-01 11:12:38 +00:00
"""The html title for announcing your own post
"""
return ' <img loading="lazy" title="' + \
translate['announces'] + \
'" alt="' + translate['announces'] + \
2020-12-09 13:08:26 +00:00
'" src="/icons' + \
2020-12-01 11:12:38 +00:00
'/repeat_inactive.png" class="announceOrReply"/>\n'
def _announceUnattributedHtml(translate: {},
postJsonObject: {}) -> str:
2020-12-01 11:12:38 +00:00
"""Returns the html for an announce title where there
is no attribution on the announced post
"""
return ' <img loading="lazy" title="' + \
translate['announces'] + '" alt="' + \
2020-12-09 13:08:26 +00:00
translate['announces'] + '" src="/icons' + \
2020-12-01 11:12:38 +00:00
'/repeat_inactive.png" ' + \
'class="announceOrReply"/>\n' + \
' <a href="' + \
postJsonObject['object']['id'] + \
'" class="announceOrReply">@unattributed</a>\n'
def _announceWithDisplayNameHtml(translate: {},
postJsonObject: {},
announceDisplayName: str) -> str:
"""Returns html for an announce having a display name
"""
return ' <img loading="lazy" title="' + \
translate['announces'] + '" alt="' + \
translate['announces'] + '" src="/' + \
2020-12-09 13:08:26 +00:00
'icons/repeat_inactive.png" ' + \
'class="announceOrReply"/>\n' + \
' <a href="' + \
postJsonObject['object']['id'] + '" ' + \
'class="announceOrReply">' + announceDisplayName + '</a>\n'
def _getPostTitleAnnounceHtml(baseDir: str,
httpPrefix: str,
nickname: str, domain: str,
showRepeatIcon: bool,
isAnnounced: bool,
postJsonObject: {},
postActor: str,
translate: {},
enableTimingLog: bool,
postStartTime,
boxName: str,
personCache: {},
allowDownloads: bool,
avatarPosition: str,
pageNumber: int,
messageIdStr: str,
containerClassIcons: str,
containerClass: str) -> (str, str, str, str):
2020-12-01 11:12:38 +00:00
"""Returns the announce title of a post containing names of participants
x announces y
"""
titleStr = ''
replyAvatarImageInPost = ''
2021-07-21 10:48:24 +00:00
objJson = postJsonObject['object']
2020-12-01 11:12:38 +00:00
2021-07-21 10:48:24 +00:00
# has no attribution
if not objJson.get('attributedTo'):
2021-07-21 19:46:31 +00:00
titleStr += _announceUnattributedHtml(translate, postJsonObject)
2021-07-21 10:48:24 +00:00
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
attributedTo = ''
if isinstance(objJson['attributedTo'], str):
attributedTo = objJson['attributedTo']
2021-07-21 10:49:54 +00:00
# boosting your own post
2021-07-21 10:48:24 +00:00
if attributedTo.startswith(postActor):
2021-07-21 10:49:54 +00:00
titleStr += _boostOwnPostHtml(translate)
2021-07-21 10:48:24 +00:00
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
# boosting another person's post
_logPostTiming(enableTimingLog, postStartTime, '13.2')
announceNickname = None
if attributedTo:
announceNickname = getNicknameFromActor(attributedTo)
if not announceNickname:
2021-07-21 19:46:31 +00:00
titleStr += _announceUnattributedHtml(translate, postJsonObject)
2021-07-21 10:48:24 +00:00
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
2021-07-21 19:46:31 +00:00
announceDomain, announcePort = getDomainFromActor(attributedTo)
getPersonFromCache(baseDir, attributedTo, personCache, allowDownloads)
announceDisplayName = getDisplayName(baseDir, attributedTo, personCache)
2021-07-21 10:48:24 +00:00
if not announceDisplayName:
2021-07-21 19:58:34 +00:00
announceDisplayName = announceNickname + '@' + announceDomain
2021-07-21 10:48:24 +00:00
_logPostTiming(enableTimingLog, postStartTime, '13.3')
# add any emoji to the display name
if ':' in announceDisplayName:
announceDisplayName = \
2021-07-21 19:46:31 +00:00
addEmojiToDisplayName(baseDir, httpPrefix, nickname, domain,
announceDisplayName, False)
2021-07-21 10:48:24 +00:00
_logPostTiming(enableTimingLog, postStartTime, '13.3.1')
titleStr += \
2021-07-21 19:46:31 +00:00
_announceWithDisplayNameHtml(translate, postJsonObject,
2021-07-21 10:48:24 +00:00
announceDisplayName)
# show avatar of person replied to
2021-07-21 12:05:30 +00:00
announceActor = attributedTo
2021-07-21 10:48:24 +00:00
announceAvatarUrl = \
getPersonAvatarUrl(baseDir, announceActor,
personCache, allowDownloads)
_logPostTiming(enableTimingLog, postStartTime, '13.4')
if not announceAvatarUrl:
announceAvatarUrl = ''
2021-07-21 20:38:35 +00:00
idx = 'Show options for this person'
if '/users/news/' not in announceAvatarUrl:
replyAvatarImageInPost = \
' <div class="timeline-avatar-reply">\n' \
' <a class="imageAnchor" ' + \
'href="/users/' + nickname + '?options=' + \
announceActor + ';' + str(pageNumber) + \
';' + announceAvatarUrl + messageIdStr + '">' \
2021-07-21 20:38:35 +00:00
'<img loading="lazy" src="' + announceAvatarUrl + '" ' + \
'title="' + translate[idx] + '" alt=" "' + avatarPosition + \
getBrokenLinkSubstitute() + '/></a>\n </div>\n'
2020-12-01 11:12:38 +00:00
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
def _replyToYourselfHtml(translate: {}) -> str:
"""Returns html for a title which is a reply to yourself
"""
return ' <img loading="lazy" title="' + \
translate['replying to themselves'] + \
'" alt="' + translate['replying to themselves'] + \
2020-12-09 13:08:26 +00:00
'" src="/icons' + \
'/reply.png" class="announceOrReply"/>\n'
def _replyToUnknownHtml(translate: {},
postJsonObject: {}) -> str:
2020-12-01 13:17:51 +00:00
"""Returns the html title for a reply to an unknown handle
"""
return ' <img loading="lazy" title="' + \
translate['replying to'] + '" alt="' + \
2020-12-09 13:08:26 +00:00
translate['replying to'] + '" src="/icons' + \
2020-12-01 13:17:51 +00:00
'/reply.png" class="announceOrReply"/>\n' + \
' <a href="' + \
postJsonObject['object']['inReplyTo'] + \
'" class="announceOrReply">@unknown</a>\n'
def _replyWithUnknownPathHtml(translate: {},
postJsonObject: {},
postDomain: str) -> str:
"""Returns html title for a reply with an unknown path
eg. does not contain /statuses/
"""
return ' <img loading="lazy" title="' + \
translate['replying to'] + \
'" alt="' + translate['replying to'] + \
2020-12-09 13:08:26 +00:00
'" src="/icons/reply.png" ' + \
'class="announceOrReply"/>\n' + \
' <a href="' + \
postJsonObject['object']['inReplyTo'] + \
'" class="announceOrReply">' + \
postDomain + '</a>\n'
def _getReplyHtml(translate: {},
inReplyTo: str, replyDisplayName: str) -> str:
2020-12-01 13:32:08 +00:00
"""Returns html title for a reply
"""
return ' ' + \
'<img loading="lazy" title="' + \
translate['replying to'] + '" alt="' + \
translate['replying to'] + '" src="/' + \
2020-12-09 13:08:26 +00:00
'icons/reply.png" ' + \
2020-12-01 13:32:08 +00:00
'class="announceOrReply"/>\n' + \
' <a href="' + inReplyTo + \
'" class="announceOrReply">' + \
replyDisplayName + '</a>\n'
def _getPostTitleReplyHtml(baseDir: str,
httpPrefix: str,
nickname: str, domain: str,
showRepeatIcon: bool,
isAnnounced: bool,
postJsonObject: {},
postActor: str,
translate: {},
enableTimingLog: bool,
postStartTime,
boxName: str,
personCache: {},
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 = ''
2021-07-21 10:02:42 +00:00
objJson = postJsonObject['object']
2021-07-21 10:02:42 +00:00
# not a reply
if not objJson.get('inReplyTo'):
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
containerClassIcons = 'containericons darker'
containerClass = 'container darker'
2021-07-21 10:02:42 +00:00
# reply to self
if objJson['inReplyTo'].startswith(postActor):
titleStr += _replyToYourselfHtml(translate)
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
2021-07-21 10:02:42 +00:00
# has a reply
2021-07-21 12:05:30 +00:00
if '/statuses/' not in objJson['inReplyTo']:
2021-07-21 10:02:42 +00:00
postDomain = objJson['inReplyTo']
prefixes = getProtocolPrefixes()
for prefix in prefixes:
postDomain = postDomain.replace(prefix, '')
if '/' in postDomain:
postDomain = postDomain.split('/', 1)[0]
if postDomain:
titleStr += \
_replyWithUnknownPathHtml(translate,
postJsonObject, postDomain)
2021-07-21 12:05:30 +00:00
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
inReplyTo = objJson['inReplyTo']
replyActor = inReplyTo.split('/statuses/')[0]
replyNickname = getNicknameFromActor(replyActor)
if not replyNickname:
2021-07-21 19:46:31 +00:00
titleStr += _replyToUnknownHtml(translate, postJsonObject)
2021-07-21 12:05:30 +00:00
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
2021-07-21 19:46:31 +00:00
replyDomain, replyPort = getDomainFromActor(replyActor)
2021-07-21 12:05:30 +00:00
if not (replyNickname and replyDomain):
2021-07-21 19:46:31 +00:00
titleStr += _replyToUnknownHtml(translate, postJsonObject)
2021-07-21 12:05:30 +00:00
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
2021-07-21 19:46:31 +00:00
getPersonFromCache(baseDir, replyActor, personCache, allowDownloads)
replyDisplayName = getDisplayName(baseDir, replyActor, personCache)
2021-07-21 12:05:30 +00:00
if not replyDisplayName:
2021-07-21 19:58:34 +00:00
replyDisplayName = replyNickname + '@' + replyDomain
2021-07-21 12:05:30 +00:00
# add emoji to the display name
if ':' in replyDisplayName:
_logPostTiming(enableTimingLog, postStartTime, '13.5')
replyDisplayName = \
2021-07-21 19:46:31 +00:00
addEmojiToDisplayName(baseDir, httpPrefix, nickname, domain,
2021-07-21 12:05:30 +00:00
replyDisplayName, False)
_logPostTiming(enableTimingLog, postStartTime, '13.6')
2021-07-21 19:46:31 +00:00
titleStr += _getReplyHtml(translate, inReplyTo, replyDisplayName)
2021-07-21 12:05:30 +00:00
_logPostTiming(enableTimingLog, postStartTime, '13.7')
# show avatar of person replied to
replyAvatarUrl = \
2021-07-21 19:58:34 +00:00
getPersonAvatarUrl(baseDir, replyActor, personCache, allowDownloads)
2021-07-21 12:05:30 +00:00
_logPostTiming(enableTimingLog, postStartTime, '13.8')
if replyAvatarUrl:
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="' + translate['Show profile'] + \
'" alt=" "' + avatarPosition + getBrokenLinkSubstitute() + \
'/></a>\n </div>\n'
return (titleStr, replyAvatarImageInPost,
containerClassIcons, containerClass)
def _getPostTitleHtml(baseDir: str,
httpPrefix: str,
nickname: str, domain: str,
showRepeatIcon: bool,
isAnnounced: bool,
postJsonObject: {},
postActor: str,
translate: {},
enableTimingLog: bool,
postStartTime,
boxName: str,
personCache: {},
allowDownloads: bool,
avatarPosition: str,
pageNumber: int,
messageIdStr: str,
containerClassIcons: str,
containerClass: str) -> (str, str, str, str):
2020-11-30 23:23:21 +00:00
"""Returns the title of a post containing names of participants
x replies to y, x announces y, etc
2020-11-09 19:42:09 +00:00
"""
2021-07-21 21:23:19 +00:00
if not isAnnounced and boxName == 'search' and \
postJsonObject.get('object'):
if postJsonObject['object'].get('attributedTo'):
if postJsonObject['object']['attributedTo'] != postActor:
isAnnounced = True
2020-12-01 10:30:24 +00:00
if isAnnounced:
return _getPostTitleAnnounceHtml(baseDir,
httpPrefix,
nickname, domain,
showRepeatIcon,
isAnnounced,
postJsonObject,
postActor,
translate,
enableTimingLog,
postStartTime,
boxName,
personCache,
allowDownloads,
avatarPosition,
pageNumber,
messageIdStr,
containerClassIcons,
containerClass)
return _getPostTitleReplyHtml(baseDir,
httpPrefix,
nickname, domain,
showRepeatIcon,
isAnnounced,
postJsonObject,
postActor,
translate,
enableTimingLog,
postStartTime,
boxName,
personCache,
allowDownloads,
avatarPosition,
pageNumber,
messageIdStr,
containerClassIcons,
containerClass)
def _getFooterWithIcons(showIcons: bool,
containerClassIcons: str,
replyStr: str, announceStr: str,
likeStr: str, bookmarkStr: str,
deleteStr: str, muteStr: str, editStr: str,
postJsonObject: {}, publishedLink: str,
timeClass: str, publishedStr: str) -> str:
2020-12-01 14:08:12 +00:00
"""Returns the html for a post footer containing icons
"""
if not showIcons:
return None
2020-12-27 20:33:56 +00:00
footerStr = '\n <nav>\n'
footerStr += ' <div class="' + containerClassIcons + '">\n'
2020-12-01 14:11:50 +00:00
footerStr += replyStr + announceStr + likeStr + bookmarkStr
footerStr += deleteStr + muteStr + editStr
2020-12-01 14:08:12 +00:00
if not isNewsPost(postJsonObject):
footerStr += ' <a href="' + publishedLink + '" class="' + \
timeClass + '">' + publishedStr + '</a>\n'
else:
footerStr += ' <a href="' + \
publishedLink.replace('/news/', '/news/statuses/') + \
2020-12-01 14:11:50 +00:00
'" class="' + timeClass + '">' + publishedStr + '</a>\n'
2020-12-01 14:08:12 +00:00
footerStr += ' </div>\n'
2020-12-27 20:33:56 +00:00
footerStr += ' </nav>\n'
2020-12-01 14:08:12 +00:00
return footerStr
2020-11-30 23:23:21 +00:00
def individualPostAsHtml(allowDownloads: bool,
recentPostsCache: {}, maxRecentPosts: int,
2020-12-09 13:31:54 +00:00
translate: {},
2020-11-30 23:23:21 +00:00
pageNumber: int, baseDir: str,
2020-12-31 12:23:15 +00:00
session, cachedWebfingers: {}, personCache: {},
2020-11-30 23:23:21 +00:00
nickname: str, domain: str, port: int,
postJsonObject: {},
avatarUrl: str, showAvatarOptions: bool,
allowDeletion: bool,
httpPrefix: str, projectVersion: str,
boxName: str, YTReplacementDomain: str,
showPublishedDateOnly: bool,
2020-12-23 23:59:49 +00:00
peertubeInstances: [],
allowLocalNetworkAccess: bool,
themeName: str, systemLanguage: str,
maxLikeCount: int,
2021-06-20 11:28:35 +00:00
showRepeats: bool = True,
showIcons: bool = False,
manuallyApprovesFollowers: bool = False,
showPublicOnly: bool = False,
storeToCache: bool = True) -> str:
2020-11-30 23:23:21 +00:00
""" Shows a single post as html
"""
if not postJsonObject:
return ''
# benchmark
postStartTime = time.time()
postActor = postJsonObject['actor']
# ZZZzzz
if isPersonSnoozed(baseDir, 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
_logPostTiming(enableTimingLog, postStartTime, '1')
2020-11-30 23:23:21 +00:00
avatarPosition = ''
messageId = ''
if postJsonObject.get('id'):
messageId = removeIdEnding(postJsonObject['id'])
_logPostTiming(enableTimingLog, postStartTime, '2')
2020-11-30 23:23:21 +00:00
messageIdStr = ''
if messageId:
messageIdStr = ';' + messageId
2020-11-09 19:42:09 +00:00
2020-12-16 11:19:16 +00:00
domainFull = getFullDomain(domain, port)
2020-11-09 19:42:09 +00:00
pageNumberParam = ''
if pageNumber:
pageNumberParam = '?page=' + str(pageNumber)
2020-11-30 14:45:12 +00:00
# get the html post from the recent posts cache if it exists there
2020-11-30 12:47:52 +00:00
postHtml = \
_getPostFromRecentCache(session, baseDir,
httpPrefix, nickname, domain,
postJsonObject,
postActor,
personCache,
allowDownloads,
showPublicOnly,
storeToCache,
boxName,
avatarUrl,
enableTimingLog,
postStartTime,
pageNumber,
recentPostsCache,
maxRecentPosts)
2020-11-30 12:47:52 +00:00
if postHtml:
return postHtml
2020-11-09 19:42:09 +00:00
_logPostTiming(enableTimingLog, postStartTime, '4')
2020-11-09 19:42:09 +00:00
2020-11-30 14:45:12 +00:00
avatarUrl = \
getAvatarImageUrl(session,
baseDir, httpPrefix,
postActor, personCache,
avatarUrl, allowDownloads)
2020-11-09 19:42:09 +00:00
_logPostTiming(enableTimingLog, postStartTime, '5')
2020-11-09 19:42:09 +00:00
2020-11-30 15:20:10 +00:00
# get the display name
if domainFull not in postActor:
2021-01-09 22:58:34 +00:00
# lookup the correct webfinger for the postActor
postActorNickname = getNicknameFromActor(postActor)
2021-01-09 23:00:36 +00:00
postActorDomain, postActorPort = getDomainFromActor(postActor)
2021-01-09 22:58:34 +00:00
postActorDomainFull = getFullDomain(postActorDomain, postActorPort)
postActorHandle = postActorNickname + '@' + postActorDomainFull
2021-01-10 10:34:29 +00:00
postActorWf = \
webfingerHandle(session, postActorHandle, httpPrefix,
cachedWebfingers,
2021-07-30 13:00:23 +00:00
domain, __version__, False, False)
2021-01-09 22:58:34 +00:00
2021-01-10 10:34:29 +00:00
avatarUrl2 = None
displayName = None
if postActorWf:
(inboxUrl, pubKeyId, pubKey,
fromPersonId, sharedInbox,
avatarUrl2, displayName) = getPersonBox(baseDir, session,
postActorWf,
personCache,
projectVersion,
httpPrefix,
nickname, domain,
'outbox', 72367)
_logPostTiming(enableTimingLog, postStartTime, '6')
2020-11-09 19:42:09 +00:00
if avatarUrl2:
avatarUrl = avatarUrl2
if displayName:
2020-11-30 15:20:10 +00:00
# add any emoji to the display name
2020-11-09 19:42:09 +00:00
if ':' in displayName:
displayName = \
addEmojiToDisplayName(baseDir, httpPrefix,
nickname, domain,
displayName, False)
_logPostTiming(enableTimingLog, postStartTime, '7')
2020-11-09 19:42:09 +00:00
2020-11-30 15:20:10 +00:00
avatarLink = \
_getAvatarImageHtml(showAvatarOptions,
nickname, domainFull,
avatarUrl, postActor,
translate, avatarPosition,
pageNumber, messageIdStr)
2020-11-09 19:42:09 +00:00
avatarImageInPost = \
2020-11-30 15:20:10 +00:00
' <div class="timeline-avatar">' + avatarLink + '</div>\n'
2020-11-09 19:42:09 +00:00
timelinePostBookmark = removeIdEnding(postJsonObject['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
2021-02-24 12:55:34 +00:00
postIsDM = isDM(postJsonObject)
2020-11-09 19:42:09 +00:00
if showRepeats:
2021-02-24 12:55:34 +00:00
if postIsDM:
2020-11-09 19:42:09 +00:00
showRepeatIcon = False
else:
if not isPublicPost(postJsonObject):
isPublicRepeat = True
titleStr = ''
galleryStr = ''
isAnnounced = False
announceJsonObject = None
2020-11-09 19:42:09 +00:00
if postJsonObject['type'] == 'Announce':
announceJsonObject = postJsonObject.copy()
2021-03-03 17:09:31 +00:00
postJsonAnnounce = \
2020-11-09 19:42:09 +00:00
downloadAnnounce(session, baseDir, httpPrefix,
nickname, domain, postJsonObject,
projectVersion, translate,
YTReplacementDomain,
allowLocalNetworkAccess,
recentPostsCache, False,
systemLanguage,
domainFull, personCache)
2020-11-09 19:42:09 +00:00
if not postJsonAnnounce:
# if the announce could not be downloaded then mark it as rejected
rejectPostId(baseDir, nickname, domain, postJsonObject['id'],
recentPostsCache)
2020-11-09 19:42:09 +00:00
return ''
postJsonObject = postJsonAnnounce
2021-03-03 19:27:29 +00:00
announceFilename = \
2021-07-21 19:46:31 +00:00
locatePost(baseDir, nickname, domain, postJsonObject['id'])
if announceFilename:
updateAnnounceCollection(recentPostsCache,
baseDir, announceFilename,
postActor, nickname, domainFull, False)
2021-05-07 21:10:55 +00:00
# create a file for use by text-to-speech
if isRecentPost(postJsonObject):
if postJsonObject.get('actor'):
if not os.path.isfile(announceFilename + '.tts'):
updateSpeaker(baseDir, httpPrefix,
nickname, domain, domainFull,
postJsonObject, personCache,
translate, postJsonObject['actor'],
themeName)
2021-06-22 12:27:10 +00:00
with open(announceFilename + '.tts', 'w+') as ttsFile:
ttsFile.write('\n')
2021-03-03 19:27:29 +00:00
2020-11-09 19:42:09 +00:00
isAnnounced = True
_logPostTiming(enableTimingLog, postStartTime, '8')
2020-11-09 19:42:09 +00:00
2021-07-06 10:00:19 +00:00
if not hasObjectDict(postJsonObject):
2020-11-09 19:42:09 +00:00
return ''
# if this post should be public then check its recipients
if showPublicOnly:
if not postContainsPublic(postJsonObject):
return ''
isModerationPost = False
if postJsonObject['object'].get('moderationStatus'):
isModerationPost = True
containerClass = 'container'
containerClassIcons = 'containericons'
timeClass = 'time-right'
actorNickname = getNicknameFromActor(postActor)
if not actorNickname:
# single user instance
actorNickname = 'dev'
actorDomain, actorPort = getDomainFromActor(postActor)
displayName = getDisplayName(baseDir, postActor, personCache)
if displayName:
if ':' in displayName:
displayName = \
addEmojiToDisplayName(baseDir, httpPrefix,
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(postJsonObject)
print('ERROR: no messageId')
if not actorNickname:
# pprint(postJsonObject)
print('ERROR: no actorNickname')
if not actorDomain:
# pprint(postJsonObject)
print('ERROR: no actorDomain')
titleStr += \
' <a class="imageAnchor" href="/users/' + \
nickname + '?options=' + postActor + \
';' + str(pageNumber) + ';' + avatarUrl + messageIdStr + \
'">@' + actorNickname + '@' + actorDomain + '</a>\n'
# benchmark 9
_logPostTiming(enableTimingLog, postStartTime, '9')
2020-11-09 19:42:09 +00:00
# Show a DM icon for DMs in the inbox timeline
2021-02-24 12:55:34 +00:00
if postIsDM:
2020-11-09 19:42:09 +00:00
titleStr = \
titleStr + ' <img loading="lazy" src="/' + \
2020-12-09 13:08:26 +00:00
'icons/dm.png" class="DMicon"/>\n'
2020-11-09 19:42:09 +00:00
# check if replying is permitted
commentsEnabled = True
if 'commentsEnabled' in postJsonObject['object']:
if postJsonObject['object']['commentsEnabled'] is False:
commentsEnabled = False
elif 'rejectReplies' in postJsonObject['object']:
if postJsonObject['object']['rejectReplies']:
commentsEnabled = False
2020-11-09 19:42:09 +00:00
replyStr = _getReplyIconHtml(nickname, isPublicRepeat,
showIcons, commentsEnabled,
postJsonObject, pageNumberParam,
translate, systemLanguage)
2020-11-09 19:42:09 +00:00
_logPostTiming(enableTimingLog, postStartTime, '10')
2020-11-09 19:42:09 +00:00
editStr = _getEditIconHtml(baseDir, nickname, domainFull,
postJsonObject, actorNickname,
translate, False)
_logPostTiming(enableTimingLog, postStartTime, '11')
2020-11-30 20:52:58 +00:00
announceStr = \
2021-05-07 21:10:55 +00:00
_getAnnounceIconHtml(isAnnounced,
2021-05-07 22:49:04 +00:00
postActor,
2021-05-07 21:10:55 +00:00
nickname, domainFull,
announceJsonObject,
postJsonObject,
isPublicRepeat,
isModerationPost,
showRepeatIcon,
translate,
pageNumberParam,
timelinePostBookmark,
boxName)
_logPostTiming(enableTimingLog, postStartTime, '12')
2020-11-09 19:42:09 +00:00
# whether to show a like button
hideLikeButtonFile = \
2021-07-13 21:59:53 +00:00
acctDir(baseDir, nickname, domain) + '/.hideLikeButton'
2020-11-09 19:42:09 +00:00
showLikeButton = True
if os.path.isfile(hideLikeButtonFile):
showLikeButton = False
likeStr = _getLikeIconHtml(nickname, domainFull,
isModerationPost,
showLikeButton,
postJsonObject,
enableTimingLog,
postStartTime,
translate, pageNumberParam,
timelinePostBookmark,
boxName, maxLikeCount)
2020-11-09 19:42:09 +00:00
_logPostTiming(enableTimingLog, postStartTime, '12.5')
2020-11-09 19:42:09 +00:00
bookmarkStr = \
_getBookmarkIconHtml(nickname, domainFull,
postJsonObject,
isModerationPost,
translate,
enableTimingLog,
postStartTime, boxName,
pageNumberParam,
timelinePostBookmark)
2020-11-09 19:42:09 +00:00
_logPostTiming(enableTimingLog, postStartTime, '12.9')
2020-11-09 19:42:09 +00:00
isMuted = postIsMuted(baseDir, nickname, domain, postJsonObject, messageId)
_logPostTiming(enableTimingLog, postStartTime, '13')
2020-11-09 19:42:09 +00:00
2020-11-30 17:48:35 +00:00
muteStr = \
_getMuteIconHtml(isMuted,
postActor,
messageId,
nickname, domainFull,
allowDeletion,
pageNumberParam,
boxName,
timelinePostBookmark,
translate)
2020-11-30 17:48:35 +00:00
deleteStr = \
_getDeleteIconHtml(nickname, domainFull,
allowDeletion,
postActor,
messageId,
postJsonObject,
pageNumberParam,
translate)
2020-11-09 19:42:09 +00:00
_logPostTiming(enableTimingLog, postStartTime, '13.1')
2020-11-09 19:42:09 +00:00
2020-11-30 23:23:21 +00:00
# get the title: x replies to y, x announces y, etc
(titleStr2,
replyAvatarImageInPost,
containerClassIcons,
containerClass) = _getPostTitleHtml(baseDir,
httpPrefix,
nickname, domain,
showRepeatIcon,
isAnnounced,
postJsonObject,
postActor,
translate,
enableTimingLog,
postStartTime,
boxName,
personCache,
allowDownloads,
avatarPosition,
pageNumber,
messageIdStr,
containerClassIcons,
containerClass)
2020-11-30 23:23:21 +00:00
titleStr += titleStr2
2020-11-09 19:42:09 +00:00
_logPostTiming(enableTimingLog, postStartTime, '14')
2020-11-09 19:42:09 +00:00
attachmentStr, galleryStr = \
getPostAttachmentsAsHtml(postJsonObject, boxName, translate,
2020-11-30 15:20:10 +00:00
isMuted, avatarLink,
2020-11-09 19:42:09 +00:00
replyStr, announceStr, likeStr,
bookmarkStr, deleteStr, muteStr)
publishedStr = \
_getPublishedDateStr(postJsonObject, showPublishedDateOnly)
2020-11-09 19:42:09 +00:00
_logPostTiming(enableTimingLog, postStartTime, '15')
2020-11-09 19:42:09 +00:00
publishedLink = messageId
# blog posts should have no /statuses/ in their link
if isBlogPost(postJsonObject):
# 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 isNewsPost(postJsonObject):
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
2021-02-24 12:55:34 +00:00
if postIsDM:
2020-11-09 19:42:09 +00:00
containerClassIcons = 'containericons dm'
containerClass = 'container dm'
newFooterStr = _getFooterWithIcons(showIcons,
containerClassIcons,
replyStr, announceStr,
likeStr, bookmarkStr,
deleteStr, muteStr, editStr,
postJsonObject, publishedLink,
timeClass, publishedStr)
2020-12-01 14:08:12 +00:00
if newFooterStr:
footerStr = newFooterStr
2020-11-09 19:42:09 +00:00
postIsSensitive = False
if postJsonObject['object'].get('sensitive'):
# sensitive posts should have a summary
if postJsonObject['object'].get('summary'):
postIsSensitive = postJsonObject['object']['sensitive']
else:
# add a generic summary if none is provided
postJsonObject['object']['summary'] = translate['Sensitive']
# add an extra line if there is a content warning,
# for better vertical spacing on mobile
if postIsSensitive:
footerStr = '<br>' + footerStr
if not postJsonObject['object'].get('summary'):
postJsonObject['object']['summary'] = ''
if postJsonObject['object'].get('cipherText'):
postJsonObject['object']['content'] = \
E2EEdecryptMessageFromDevice(postJsonObject['object'])
postJsonObject['object']['contentMap'][systemLanguage] = \
postJsonObject['object']['content']
2020-11-09 19:42:09 +00:00
domainFull = getFullDomain(domain, port)
personUrl = \
httpPrefix + '://' + domainFull + '/users/' + nickname
actorJson = \
getPersonFromCache(baseDir, personUrl, personCache, False)
languagesUnderstood = []
if actorJson:
languagesUnderstood = getActorLanguagesList(actorJson)
contentStr = getContentFromPost(postJsonObject, systemLanguage,
languagesUnderstood)
if not contentStr:
2021-07-20 11:21:15 +00:00
contentStr = \
autoTranslatePost(baseDir, postJsonObject,
systemLanguage, translate)
2021-07-19 19:40:04 +00:00
if not contentStr:
return ''
2020-11-09 19:42:09 +00:00
isPatch = isGitPatch(baseDir, nickname, domain,
postJsonObject['object']['type'],
postJsonObject['object']['summary'],
contentStr)
2020-11-09 19:42:09 +00:00
_logPostTiming(enableTimingLog, postStartTime, '16')
2020-11-09 19:42:09 +00:00
if not isPGPEncrypted(contentStr):
if not isPatch:
objectContent = \
removeLongWords(contentStr, 40, [])
objectContent = removeTextFormatting(objectContent)
objectContent = limitRepeatedWords(objectContent, 6)
objectContent = \
switchWords(baseDir, nickname, domain, objectContent)
objectContent = htmlReplaceEmailQuote(objectContent)
objectContent = htmlReplaceQuoteMarks(objectContent)
else:
objectContent = contentStr
2020-11-09 19:42:09 +00:00
else:
objectContent = '🔒 ' + translate['Encrypted']
2020-11-09 19:42:09 +00:00
2020-12-27 14:04:48 +00:00
objectContent = '<article>' + objectContent + '</article>'
2020-11-09 19:42:09 +00:00
if not postIsSensitive:
contentStr = objectContent + attachmentStr
2020-12-23 23:59:49 +00:00
contentStr = addEmbeddedElements(translate, contentStr,
peertubeInstances)
2020-11-09 19:42:09 +00:00
contentStr = insertQuestion(baseDir, translate,
nickname, domain, port,
contentStr, postJsonObject,
pageNumber)
else:
postID = 'post' + str(createPassword(8))
contentStr = ''
if postJsonObject['object'].get('summary'):
2020-12-29 09:52:52 +00:00
cwStr = str(postJsonObject['object']['summary'])
cwStr = \
addEmojiToDisplayName(baseDir, httpPrefix,
nickname, domain,
cwStr, False)
2021-01-19 19:17:20 +00:00
contentStr += \
2021-01-19 19:24:16 +00:00
'<label class="cw">' + cwStr + '</label>\n '
2020-11-09 19:42:09 +00:00
if isModerationPost:
containerClass = 'container report'
# get the content warning text
cwContentStr = objectContent + attachmentStr
if not isPatch:
2020-12-23 23:59:49 +00:00
cwContentStr = addEmbeddedElements(translate, cwContentStr,
peertubeInstances)
2020-11-09 19:42:09 +00:00
cwContentStr = \
insertQuestion(baseDir, translate, nickname, domain, port,
cwContentStr, postJsonObject, pageNumber)
cwContentStr = \
switchWords(baseDir, nickname, domain, cwContentStr)
2020-11-09 19:42:09 +00:00
if not isBlogPost(postJsonObject):
# get the content warning button
contentStr += \
getContentWarningButton(postID, translate, cwContentStr)
else:
contentStr += cwContentStr
_logPostTiming(enableTimingLog, postStartTime, '17')
2020-11-09 19:42:09 +00:00
if postJsonObject['object'].get('tag') and not isPatch:
contentStr = \
replaceEmojiFromTags(contentStr,
postJsonObject['object']['tag'],
'content')
if isMuted:
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
2020-11-30 20:52:58 +00:00
citationsStr = \
_getBlogCitationsHtml(boxName, postJsonObject, translate)
2020-11-09 19:42:09 +00:00
postHtml = ''
if boxName != 'tlmedia':
postHtml = ' <div id="' + timelinePostBookmark + \
'" class="' + containerClass + '">\n'
2020-11-09 19:42:09 +00:00
postHtml += avatarImageInPost
postHtml += ' <div class="post-title">\n' + \
' ' + titleStr + \
replyAvatarImageInPost + ' </div>\n'
postHtml += contentStr + citationsStr + footerStr + '\n'
postHtml += ' </div>\n'
else:
postHtml = galleryStr
_logPostTiming(enableTimingLog, postStartTime, '18')
2020-11-09 19:42:09 +00:00
2020-11-30 20:52:58 +00:00
# save the created html to the recent posts cache
2020-11-09 19:42:09 +00:00
if not showPublicOnly and storeToCache and \
boxName != 'tlmedia' and boxName != 'tlbookmarks' and \
boxName != 'bookmarks':
_saveIndividualPostAsHtmlToCache(baseDir, nickname, domain,
postJsonObject, postHtml)
2020-11-09 19:42:09 +00:00
updateRecentPostsCache(recentPostsCache, maxRecentPosts,
postJsonObject, postHtml)
_logPostTiming(enableTimingLog, postStartTime, '19')
2020-11-09 19:42:09 +00:00
return postHtml
2020-11-09 22:44:03 +00:00
def htmlIndividualPost(cssCache: {},
recentPostsCache: {}, maxRecentPosts: int,
translate: {},
baseDir: str, session, cachedWebfingers: {},
personCache: {},
2020-11-09 22:44:03 +00:00
nickname: str, domain: str, port: int, authorized: bool,
postJsonObject: {}, httpPrefix: str,
projectVersion: str, likedBy: str,
YTReplacementDomain: str,
2020-12-23 23:59:49 +00:00
showPublishedDateOnly: bool,
peertubeInstances: [],
2021-03-09 19:52:10 +00:00
allowLocalNetworkAccess: bool,
themeName: str, systemLanguage: str,
maxLikeCount: int) -> str:
2020-11-09 22:44:03 +00:00
"""Show an individual post as html
"""
postStr = ''
if likedBy:
likedByNickname = getNicknameFromActor(likedBy)
likedByDomain, likedByPort = getDomainFromActor(likedBy)
2020-12-16 11:19:16 +00:00
likedByDomain = getFullDomain(likedByDomain, likedByPort)
2020-11-09 22:44:03 +00:00
likedByHandle = likedByNickname + '@' + likedByDomain
postStr += \
'<p>' + translate['Liked by'] + \
' <a href="' + likedBy + '">@' + \
likedByHandle + '</a>\n'
2020-12-16 11:19:16 +00:00
domainFull = getFullDomain(domain, port)
2020-11-09 22:44:03 +00:00
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="' + \
likedByHandle + '">\n'
if not isFollowingActor(baseDir, nickname, domainFull, likedBy):
followStr += ' <button type="submit" class="button" ' + \
'name="submitSearch">' + translate['Follow'] + '</button>\n'
followStr += ' <button type="submit" class="button" ' + \
'name="submitBack">' + translate['Go Back'] + '</button>\n'
followStr += ' </form>\n'
postStr += followStr + '</p>\n'
postStr += \
individualPostAsHtml(True, recentPostsCache, maxRecentPosts,
2020-12-09 13:31:54 +00:00
translate, None,
baseDir, session, cachedWebfingers, personCache,
2020-11-09 22:44:03 +00:00
nickname, domain, port, postJsonObject,
None, True, False,
httpPrefix, projectVersion, 'inbox',
YTReplacementDomain,
showPublishedDateOnly,
2020-12-23 23:59:49 +00:00
peertubeInstances,
allowLocalNetworkAccess, themeName,
systemLanguage, maxLikeCount,
2020-11-09 22:44:03 +00:00
False, authorized, False, False, False)
messageId = removeIdEnding(postJsonObject['id'])
# show the previous posts
2021-07-06 10:00:19 +00:00
if hasObjectDict(postJsonObject):
2020-11-09 22:44:03 +00:00
while postJsonObject['object'].get('inReplyTo'):
postFilename = \
locatePost(baseDir, nickname, domain,
postJsonObject['object']['inReplyTo'])
if not postFilename:
break
postJsonObject = loadJson(postFilename)
if postJsonObject:
postStr = \
individualPostAsHtml(True, recentPostsCache,
maxRecentPosts,
2020-12-09 13:31:54 +00:00
translate, None,
baseDir, session, cachedWebfingers,
2020-11-09 22:44:03 +00:00
personCache,
nickname, domain, port,
postJsonObject,
None, True, False,
httpPrefix, projectVersion, 'inbox',
YTReplacementDomain,
showPublishedDateOnly,
2020-12-23 23:59:49 +00:00
peertubeInstances,
allowLocalNetworkAccess,
themeName, systemLanguage,
maxLikeCount,
2020-11-09 22:44:03 +00:00
False, authorized,
False, False, False) + postStr
# show the following posts
postFilename = locatePost(baseDir, nickname, domain, messageId)
if postFilename:
# is there a replies file for this post?
repliesFilename = postFilename.replace('.json', '.replies')
if os.path.isfile(repliesFilename):
# get items from the replies file
repliesJson = {
'orderedItems': []
}
populateRepliesJson(baseDir, nickname, domain,
repliesFilename, authorized, repliesJson)
# add items to the html output
for item in repliesJson['orderedItems']:
postStr += \
individualPostAsHtml(True, recentPostsCache,
maxRecentPosts,
2020-12-09 13:31:54 +00:00
translate, None,
baseDir, session, cachedWebfingers,
2020-11-09 22:44:03 +00:00
personCache,
nickname, domain, port, item,
None, True, False,
httpPrefix, projectVersion, 'inbox',
YTReplacementDomain,
showPublishedDateOnly,
2020-12-23 23:59:49 +00:00
peertubeInstances,
allowLocalNetworkAccess,
themeName, systemLanguage,
maxLikeCount,
2020-11-09 22:44:03 +00:00
False, authorized,
False, False, False)
cssFilename = baseDir + '/epicyon-profile.css'
if os.path.isfile(baseDir + '/epicyon.css'):
cssFilename = baseDir + '/epicyon.css'
2021-01-11 19:46:21 +00:00
instanceTitle = \
getConfigParam(baseDir, 'instanceTitle')
return htmlHeaderWithExternalStyle(cssFilename, instanceTitle) + \
postStr + htmlFooter()
2020-11-09 22:44:03 +00:00
def htmlPostReplies(cssCache: {},
recentPostsCache: {}, maxRecentPosts: int,
translate: {}, baseDir: str,
session, cachedWebfingers: {}, personCache: {},
2020-11-09 22:44:03 +00:00
nickname: str, domain: str, port: int, repliesJson: {},
httpPrefix: str, projectVersion: str,
YTReplacementDomain: str,
2020-12-23 23:59:49 +00:00
showPublishedDateOnly: bool,
peertubeInstances: [],
2021-03-09 19:52:10 +00:00
allowLocalNetworkAccess: bool,
themeName: str, systemLanguage: str,
maxLikeCount: int) -> str:
2020-11-09 22:44:03 +00:00
"""Show the replies to an individual post as html
"""
repliesStr = ''
if repliesJson.get('orderedItems'):
for item in repliesJson['orderedItems']:
repliesStr += \
individualPostAsHtml(True, recentPostsCache,
maxRecentPosts,
2020-12-09 13:31:54 +00:00
translate, None,
baseDir, session, cachedWebfingers,
personCache,
2020-11-09 22:44:03 +00:00
nickname, domain, port, item,
None, True, False,
httpPrefix, projectVersion, 'inbox',
YTReplacementDomain,
showPublishedDateOnly,
2020-12-23 23:59:49 +00:00
peertubeInstances,
allowLocalNetworkAccess,
themeName, systemLanguage,
maxLikeCount,
2020-11-09 22:44:03 +00:00
False, False, False, False, False)
cssFilename = baseDir + '/epicyon-profile.css'
if os.path.isfile(baseDir + '/epicyon.css'):
cssFilename = baseDir + '/epicyon.css'
2021-01-11 19:46:21 +00:00
instanceTitle = \
getConfigParam(baseDir, 'instanceTitle')
return htmlHeaderWithExternalStyle(cssFilename, instanceTitle) + \
repliesStr + htmlFooter()