mirror of https://gitlab.com/bashrc2/epicyon
2095 lines
91 KiB
Python
2095 lines
91 KiB
Python
__filename__ = "inbox_receive.py"
|
|
__author__ = "Bob Mottram"
|
|
__license__ = "AGPL3+"
|
|
__version__ = "1.6.0"
|
|
__maintainer__ = "Bob Mottram"
|
|
__email__ = "bob@libreserver.org"
|
|
__status__ = "Production"
|
|
__module_group__ = "Timeline"
|
|
|
|
import os
|
|
import time
|
|
from flags import is_recent_post
|
|
from flags import is_quote_toot
|
|
from utils import get_quote_toot_url
|
|
from utils import get_actor_from_post_id
|
|
from utils import contains_invalid_actor_url_chars
|
|
from utils import get_attributed_to
|
|
from utils import remove_eol
|
|
from utils import update_announce_collection
|
|
from utils import get_protocol_prefixes
|
|
from utils import contains_statuses
|
|
from utils import delete_post
|
|
from utils import remove_moderation_post_from_index
|
|
from utils import remove_domain_port
|
|
from utils import get_reply_to
|
|
from utils import acct_handle_dir
|
|
from utils import has_object_string
|
|
from utils import has_users_path
|
|
from utils import has_object_string_type
|
|
from utils import get_config_param
|
|
from utils import acct_dir
|
|
from utils import get_account_timezone
|
|
from utils import is_dm
|
|
from utils import delete_cached_html
|
|
from utils import harmless_markup
|
|
from utils import has_object_dict
|
|
from utils import remove_post_from_cache
|
|
from utils import get_cached_post_filename
|
|
from utils import get_actor_from_post
|
|
from utils import locate_post
|
|
from utils import remove_id_ending
|
|
from utils import has_actor
|
|
from utils import remove_avatar_from_cache
|
|
from utils import text_in_file
|
|
from utils import is_account_dir
|
|
from utils import data_dir
|
|
from utils import get_nickname_from_actor
|
|
from utils import get_domain_from_actor
|
|
from utils import save_json
|
|
from utils import load_json
|
|
from utils import get_url_from_post
|
|
from utils import remove_html
|
|
from utils import get_full_domain
|
|
from utils import get_user_paths
|
|
from cache import get_actor_public_key_from_id
|
|
from cache import store_person_in_cache
|
|
from cache import get_person_pub_key
|
|
from person import get_person_avatar_url
|
|
from filters import is_question_filtered
|
|
from question import dangerous_question
|
|
from question import question_update_votes
|
|
from posts import convert_post_content_to_html
|
|
from posts import download_announce
|
|
from posts import send_to_followers_thread
|
|
from posts import valid_post_content
|
|
from follow import send_follow_request
|
|
from follow import is_following_actor
|
|
from follow import follower_approval_active
|
|
from blocking import is_blocked
|
|
from blocking import is_blocked_domain
|
|
from blocking import is_blocked_nickname
|
|
from blocking import allowed_announce
|
|
from like import update_likes_collection
|
|
from reaction import valid_emoji_content
|
|
from reaction import update_reaction_collection
|
|
from bookmarks import update_bookmarks_collection
|
|
from announce import is_self_announce
|
|
from speaker import update_speaker
|
|
from webapp_post import individual_post_as_html
|
|
from webapp_hashtagswarm import store_hash_tags
|
|
|
|
|
|
def inbox_update_index(boxname: str, base_dir: str, handle: str,
|
|
destination_filename: str, debug: bool) -> bool:
|
|
"""Updates the index of received posts
|
|
The new entry is added to the top of the file
|
|
"""
|
|
index_filename = \
|
|
acct_handle_dir(base_dir, handle) + '/' + boxname + '.index'
|
|
if debug:
|
|
print('DEBUG: Updating index ' + index_filename)
|
|
|
|
if '/' + boxname + '/' in destination_filename:
|
|
destination_filename = \
|
|
destination_filename.split('/' + boxname + '/')[1]
|
|
|
|
# remove the path
|
|
if '/' in destination_filename:
|
|
destination_filename = destination_filename.split('/')[-1]
|
|
|
|
written = False
|
|
if os.path.isfile(index_filename):
|
|
try:
|
|
with open(index_filename, 'r+', encoding='utf-8') as fp_index:
|
|
content = fp_index.read()
|
|
if destination_filename + '\n' not in content:
|
|
fp_index.seek(0, 0)
|
|
fp_index.write(destination_filename + '\n' + content)
|
|
written = True
|
|
return True
|
|
except OSError as ex:
|
|
print('EX: Failed to write entry to index ' + str(ex))
|
|
else:
|
|
try:
|
|
with open(index_filename, 'w+', encoding='utf-8') as fp_index:
|
|
fp_index.write(destination_filename + '\n')
|
|
written = True
|
|
except OSError as ex:
|
|
print('EX: Failed to write initial entry to index ' + str(ex))
|
|
|
|
return written
|
|
|
|
|
|
def _notify_moved(base_dir: str, domain_full: str,
|
|
prev_actor_handle: str, new_actor_handle: str,
|
|
prev_actor: str, prev_avatar_image_url: str,
|
|
http_prefix: str) -> None:
|
|
"""Notify that an actor has moved
|
|
"""
|
|
dir_str = data_dir(base_dir)
|
|
for _, dirs, _ in os.walk(dir_str):
|
|
for account in dirs:
|
|
if not is_account_dir(account):
|
|
continue
|
|
account_dir = dir_str + '/' + account
|
|
following_filename = account_dir + '/following.txt'
|
|
if not os.path.isfile(following_filename):
|
|
continue
|
|
if not text_in_file(prev_actor_handle + '\n', following_filename):
|
|
continue
|
|
if text_in_file(new_actor_handle + '\n', following_filename):
|
|
continue
|
|
# notify
|
|
moved_file = account_dir + '/.newMoved'
|
|
if os.path.isfile(moved_file):
|
|
if not text_in_file('##sent##', moved_file):
|
|
continue
|
|
|
|
nickname = account.split('@')[0]
|
|
url = \
|
|
http_prefix + '://' + domain_full + '/users/' + nickname + \
|
|
'?options=' + prev_actor + ';1;' + prev_avatar_image_url
|
|
moved_str = \
|
|
prev_actor_handle + ' ' + new_actor_handle + ' ' + url
|
|
|
|
if os.path.isfile(moved_file):
|
|
try:
|
|
with open(moved_file, 'r',
|
|
encoding='utf-8') as fp_move:
|
|
prev_moved_str = fp_move.read()
|
|
if prev_moved_str == moved_str:
|
|
continue
|
|
except OSError:
|
|
print('EX: _notify_moved unable to read ' + moved_file)
|
|
try:
|
|
with open(moved_file, 'w+', encoding='utf-8') as fp_move:
|
|
fp_move.write(moved_str)
|
|
except OSError:
|
|
print('EX: ERROR: unable to save moved notification ' +
|
|
moved_file)
|
|
break
|
|
|
|
|
|
def _person_receive_update(base_dir: str,
|
|
domain: str, port: int,
|
|
update_nickname: str, update_domain: str,
|
|
update_port: int,
|
|
person_json: {}, person_cache: {},
|
|
debug: bool, http_prefix: str) -> bool:
|
|
"""Changes an actor. eg: avatar or display name change
|
|
"""
|
|
url_str = get_url_from_post(person_json['url'])
|
|
person_url = remove_html(url_str)
|
|
if debug:
|
|
print('Receiving actor update for ' + person_url +
|
|
' ' + str(person_json))
|
|
domain_full = get_full_domain(domain, port)
|
|
update_domain_full = get_full_domain(update_domain, update_port)
|
|
users_paths = get_user_paths()
|
|
users_str_found = False
|
|
for users_str in users_paths:
|
|
actor = update_domain_full + users_str + update_nickname
|
|
if actor in person_json['id']:
|
|
users_str_found = True
|
|
break
|
|
if not users_str_found:
|
|
actor = update_domain_full + '/' + update_nickname
|
|
if actor in person_json['id']:
|
|
users_str_found = True
|
|
if not users_str_found:
|
|
if debug:
|
|
print('actor: ' + actor)
|
|
print('id: ' + person_json['id'])
|
|
print('DEBUG: Actor does not match id')
|
|
return False
|
|
if update_domain_full == domain_full:
|
|
if debug:
|
|
print('DEBUG: You can only receive actor updates ' +
|
|
'for domains other than your own')
|
|
return False
|
|
person_pub_key, _ = \
|
|
get_actor_public_key_from_id(person_json, None)
|
|
if not person_pub_key:
|
|
if debug:
|
|
print('DEBUG: actor update does not contain a public key')
|
|
return False
|
|
actor_filename = base_dir + '/cache/actors/' + \
|
|
person_json['id'].replace('/', '#') + '.json'
|
|
# check that the public keys match.
|
|
# If they don't then this may be a nefarious attempt to hack an account
|
|
idx = person_json['id']
|
|
if person_cache.get(idx):
|
|
cache_pub_key, _ = \
|
|
get_actor_public_key_from_id(person_cache[idx]['actor'], None)
|
|
if cache_pub_key != person_pub_key:
|
|
if debug:
|
|
print('WARN: Public key does not match when updating actor')
|
|
return False
|
|
else:
|
|
if os.path.isfile(actor_filename):
|
|
existing_person_json = load_json(actor_filename)
|
|
if existing_person_json:
|
|
existing_pub_key, _ = \
|
|
get_actor_public_key_from_id(existing_person_json, None)
|
|
if existing_pub_key != person_pub_key:
|
|
if debug:
|
|
print('WARN: Public key does not match ' +
|
|
'cached actor when updating')
|
|
return False
|
|
# save to cache in memory
|
|
store_person_in_cache(base_dir, idx, person_json,
|
|
person_cache, True)
|
|
# save to cache on file
|
|
if save_json(person_json, actor_filename):
|
|
if debug:
|
|
print('actor updated for ' + idx)
|
|
|
|
if person_json.get('movedTo'):
|
|
prev_domain_full = None
|
|
prev_domain, prev_port = get_domain_from_actor(idx)
|
|
if prev_domain:
|
|
prev_domain_full = get_full_domain(prev_domain, prev_port)
|
|
prev_nickname = get_nickname_from_actor(idx)
|
|
new_domain = None
|
|
new_domain, new_port = get_domain_from_actor(person_json['movedTo'])
|
|
if new_domain:
|
|
new_domain_full = get_full_domain(new_domain, new_port)
|
|
new_nickname = get_nickname_from_actor(person_json['movedTo'])
|
|
|
|
if prev_nickname and prev_domain_full and new_domain and \
|
|
new_nickname and new_domain_full:
|
|
new_actor = prev_nickname + '@' + prev_domain_full + ' ' + \
|
|
new_nickname + '@' + new_domain_full
|
|
refollow_str = ''
|
|
refollow_filename = data_dir(base_dir) + '/actors_moved.txt'
|
|
refollow_file_exists = False
|
|
if os.path.isfile(refollow_filename):
|
|
try:
|
|
with open(refollow_filename, 'r',
|
|
encoding='utf-8') as fp_refollow:
|
|
refollow_str = fp_refollow.read()
|
|
refollow_file_exists = True
|
|
except OSError:
|
|
print('EX: _person_receive_update unable to read ' +
|
|
refollow_filename)
|
|
if new_actor not in refollow_str:
|
|
refollow_type = 'w+'
|
|
if refollow_file_exists:
|
|
refollow_type = 'a+'
|
|
try:
|
|
with open(refollow_filename, refollow_type,
|
|
encoding='utf-8') as fp_refollow:
|
|
fp_refollow.write(new_actor + '\n')
|
|
except OSError:
|
|
print('EX: _person_receive_update unable to write to ' +
|
|
refollow_filename)
|
|
prev_avatar_url = \
|
|
get_person_avatar_url(base_dir, person_json['id'],
|
|
person_cache)
|
|
if prev_avatar_url is None:
|
|
prev_avatar_url = ''
|
|
_notify_moved(base_dir, domain_full,
|
|
prev_nickname + '@' + prev_domain_full,
|
|
new_nickname + '@' + new_domain_full,
|
|
person_json['id'], prev_avatar_url, http_prefix)
|
|
|
|
# remove avatar if it exists so that it will be refreshed later
|
|
# when a timeline is constructed
|
|
actor_str = person_json['id'].replace('/', '-')
|
|
remove_avatar_from_cache(base_dir, actor_str)
|
|
return True
|
|
|
|
|
|
def _receive_update_to_question(recent_posts_cache: {}, message_json: {},
|
|
base_dir: str,
|
|
nickname: str, domain: str,
|
|
system_language: str,
|
|
allow_local_network_access: bool) -> bool:
|
|
"""Updating a question as new votes arrive
|
|
"""
|
|
# message url of the question
|
|
if not message_json.get('id'):
|
|
return False
|
|
if not has_actor(message_json, False):
|
|
return False
|
|
message_id = remove_id_ending(message_json['id'])
|
|
if '#' in message_id:
|
|
message_id = message_id.split('#', 1)[0]
|
|
# find the question post
|
|
post_filename = locate_post(base_dir, nickname, domain, message_id)
|
|
if not post_filename:
|
|
return False
|
|
# load the json for the question
|
|
post_json_object = load_json(post_filename)
|
|
if not post_json_object:
|
|
return False
|
|
if not post_json_object.get('actor'):
|
|
return False
|
|
if is_question_filtered(base_dir, nickname, domain,
|
|
system_language, post_json_object):
|
|
return False
|
|
if dangerous_question(post_json_object, allow_local_network_access):
|
|
return False
|
|
# does the actor match?
|
|
actor_url = get_actor_from_post(post_json_object)
|
|
actor_url2 = get_actor_from_post(message_json)
|
|
if actor_url != actor_url2:
|
|
return False
|
|
save_json(message_json, post_filename)
|
|
# ensure that the cached post is removed if it exists, so
|
|
# that it then will be recreated
|
|
cached_post_filename = \
|
|
get_cached_post_filename(base_dir, nickname, domain, message_json)
|
|
if cached_post_filename:
|
|
if os.path.isfile(cached_post_filename):
|
|
try:
|
|
os.remove(cached_post_filename)
|
|
except OSError:
|
|
print('EX: _receive_update_to_question unable to delete ' +
|
|
cached_post_filename)
|
|
# remove from memory cache
|
|
remove_post_from_cache(message_json, recent_posts_cache)
|
|
return True
|
|
|
|
|
|
def receive_edit_to_post(recent_posts_cache: {}, message_json: {},
|
|
base_dir: str,
|
|
nickname: str, domain: str,
|
|
max_mentions: int, max_emoji: int,
|
|
allow_local_network_access: bool,
|
|
debug: bool,
|
|
system_language: str, http_prefix: str,
|
|
domain_full: str, person_cache: {},
|
|
signing_priv_key_pem: str,
|
|
max_recent_posts: int, translate: {},
|
|
session, cached_webfingers: {}, port: int,
|
|
allow_deletion: bool,
|
|
yt_replace_domain: str,
|
|
twitter_replacement_domain: str,
|
|
show_published_date_only: bool,
|
|
peertube_instances: [],
|
|
theme_name: str, max_like_count: int,
|
|
cw_lists: {}, dogwhistles: {},
|
|
min_images_for_accounts: [],
|
|
max_hashtags: int,
|
|
buy_sites: {},
|
|
auto_cw_cache: {},
|
|
onion_domain: str,
|
|
i2p_domain: str,
|
|
mitm_servers: [],
|
|
instance_software: {}) -> bool:
|
|
"""A post was edited
|
|
"""
|
|
if not has_object_dict(message_json):
|
|
return False
|
|
if not message_json['object'].get('id'):
|
|
return False
|
|
if not message_json.get('actor'):
|
|
return False
|
|
if not has_actor(message_json, False):
|
|
return False
|
|
if not has_actor(message_json['object'], False):
|
|
return False
|
|
message_id = remove_id_ending(message_json['object']['id'])
|
|
if '#' in message_id:
|
|
message_id = message_id.split('#', 1)[0]
|
|
# find the original post which was edited
|
|
post_filename = locate_post(base_dir, nickname, domain, message_id)
|
|
if not post_filename:
|
|
print('EDITPOST: ' + message_id + ' has already expired')
|
|
return False
|
|
convert_post_content_to_html(message_json)
|
|
harmless_markup(message_json)
|
|
if not valid_post_content(base_dir, nickname, domain,
|
|
message_json, max_mentions, max_emoji,
|
|
allow_local_network_access, debug,
|
|
system_language, http_prefix,
|
|
domain_full, person_cache,
|
|
max_hashtags, onion_domain, i2p_domain):
|
|
print('EDITPOST: contains invalid content' + str(message_json))
|
|
return False
|
|
|
|
# load the json for the original post
|
|
post_json_object = load_json(post_filename)
|
|
if not post_json_object:
|
|
return False
|
|
if not post_json_object.get('actor'):
|
|
return False
|
|
if not has_object_dict(post_json_object):
|
|
return False
|
|
if 'content' not in post_json_object['object']:
|
|
return False
|
|
if 'content' not in message_json['object']:
|
|
return False
|
|
# does the actor match?
|
|
actor_url = get_actor_from_post(post_json_object)
|
|
actor_url2 = get_actor_from_post(message_json)
|
|
if actor_url != actor_url2:
|
|
print('EDITPOST: actors do not match ' +
|
|
actor_url + ' != ' + actor_url2)
|
|
return False
|
|
# has the content changed?
|
|
if post_json_object['object']['content'] == \
|
|
message_json['object']['content']:
|
|
# same content. Has the summary changed?
|
|
if 'summary' in post_json_object['object'] and \
|
|
'summary' in message_json['object']:
|
|
if post_json_object['object']['summary'] == \
|
|
message_json['object']['summary']:
|
|
return False
|
|
else:
|
|
return False
|
|
# save the edit history to file
|
|
post_history_filename = post_filename.replace('.json', '') + '.edits'
|
|
post_history_json = {}
|
|
if os.path.isfile(post_history_filename):
|
|
post_history_json = load_json(post_history_filename)
|
|
# get the updated or published date
|
|
if post_json_object['object'].get('updated'):
|
|
published_str = post_json_object['object']['updated']
|
|
else:
|
|
published_str = post_json_object['object']['published']
|
|
# add to the history for this date
|
|
if not post_history_json.get(published_str):
|
|
post_history_json[published_str] = post_json_object
|
|
save_json(post_history_json, post_history_filename)
|
|
# Change Update to Create
|
|
message_json['type'] = 'Create'
|
|
save_json(message_json, post_filename)
|
|
# if the post has been saved both within the outbox and inbox
|
|
# (eg. edited reminder)
|
|
if '/outbox/' in post_filename:
|
|
inbox_post_filename = post_filename.replace('/outbox/', '/inbox/')
|
|
if os.path.isfile(inbox_post_filename):
|
|
save_json(message_json, inbox_post_filename)
|
|
# ensure that the cached post is removed if it exists, so
|
|
# that it then will be recreated
|
|
cached_post_filename = \
|
|
get_cached_post_filename(base_dir, nickname, domain, message_json)
|
|
if cached_post_filename:
|
|
if os.path.isfile(cached_post_filename):
|
|
try:
|
|
os.remove(cached_post_filename)
|
|
except OSError:
|
|
print('EX: _receive_edit_to_post unable to delete ' +
|
|
cached_post_filename)
|
|
# remove any cached html for the post which was edited
|
|
delete_cached_html(base_dir, nickname, domain, post_json_object)
|
|
# remove from memory cache
|
|
remove_post_from_cache(message_json, recent_posts_cache)
|
|
# regenerate html for the post
|
|
page_number = 1
|
|
show_published_date_only = False
|
|
show_individual_post_icons = True
|
|
manually_approve_followers = \
|
|
follower_approval_active(base_dir, nickname, domain)
|
|
not_dm = not is_dm(message_json)
|
|
timezone = get_account_timezone(base_dir, nickname, domain)
|
|
mitm = False
|
|
if os.path.isfile(post_filename.replace('.json', '') + '.mitm'):
|
|
mitm = True
|
|
bold_reading = False
|
|
bold_reading_filename = \
|
|
acct_dir(base_dir, nickname, domain) + '/.boldReading'
|
|
if os.path.isfile(bold_reading_filename):
|
|
bold_reading = True
|
|
timezone = get_account_timezone(base_dir, nickname, domain)
|
|
lists_enabled = get_config_param(base_dir, "listsEnabled")
|
|
minimize_all_images = False
|
|
if nickname in min_images_for_accounts:
|
|
minimize_all_images = True
|
|
individual_post_as_html(signing_priv_key_pem, False,
|
|
recent_posts_cache, max_recent_posts,
|
|
translate, page_number, base_dir,
|
|
session, cached_webfingers, person_cache,
|
|
nickname, domain, port, message_json,
|
|
None, True, allow_deletion,
|
|
http_prefix, __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, not_dm,
|
|
show_individual_post_icons,
|
|
manually_approve_followers,
|
|
False, True, False, cw_lists,
|
|
lists_enabled, timezone, mitm,
|
|
bold_reading, dogwhistles,
|
|
minimize_all_images, None,
|
|
buy_sites, auto_cw_cache,
|
|
mitm_servers, instance_software)
|
|
return True
|
|
|
|
|
|
def receive_move_activity(session, base_dir: str,
|
|
http_prefix: str, domain: str, port: int,
|
|
cached_webfingers: {},
|
|
person_cache: {}, message_json: {},
|
|
nickname: str, debug: bool,
|
|
signing_priv_key_pem: str,
|
|
send_threads: [],
|
|
post_log: [],
|
|
federation_list: [],
|
|
onion_domain: str,
|
|
i2p_domain: str,
|
|
sites_unavailable: [],
|
|
blocked_cache: [],
|
|
block_federated: [],
|
|
system_language: str,
|
|
mitm_servers: []) -> bool:
|
|
"""Receives a move activity within the POST section of HTTPServer
|
|
https://codeberg.org/fediverse/fep/src/branch/main/fep/7628/fep-7628.md
|
|
"""
|
|
if message_json['type'] != 'Move':
|
|
return False
|
|
if not has_actor(message_json, debug):
|
|
if debug:
|
|
print('INBOX: Move activity has no actor: ' + str(message_json))
|
|
return False
|
|
if not message_json.get('object'):
|
|
if debug:
|
|
print('INBOX: Move activity object not found: ' +
|
|
str(message_json))
|
|
return False
|
|
if not isinstance(message_json['object'], str):
|
|
if debug:
|
|
print('INBOX: Move activity object is not a string: ' +
|
|
str(message_json))
|
|
return False
|
|
if not message_json.get('target'):
|
|
if debug:
|
|
print('INBOX: Move activity has no target')
|
|
return False
|
|
if not isinstance(message_json['target'], str):
|
|
if debug:
|
|
print('INBOX: Move activity target is not a string: ' +
|
|
str(message_json['target']))
|
|
return False
|
|
previous_actor = None
|
|
actor_url = get_actor_from_post(message_json)
|
|
if message_json['object'] == actor_url:
|
|
print('INBOX: Move activity sent by old actor ' +
|
|
actor_url + ' moving to ' + message_json['target'])
|
|
previous_actor = actor_url
|
|
elif message_json['target'] == actor_url:
|
|
print('INBOX: Move activity sent by new actor ' +
|
|
actor_url + ' moving from ' +
|
|
message_json['object'])
|
|
previous_actor = message_json['object']
|
|
if not previous_actor:
|
|
print('INBOX: Move activity previous actor not found: ' +
|
|
str(message_json))
|
|
moved_actor = message_json['target']
|
|
# are we following the previous actor?
|
|
if not is_following_actor(base_dir, nickname, domain, previous_actor):
|
|
print('INBOX: Move activity not following previous actor: ' +
|
|
nickname + ' ' + previous_actor)
|
|
return False
|
|
# are we already following the moved actor?
|
|
if is_following_actor(base_dir, nickname, domain, moved_actor):
|
|
print('INBOX: Move activity not following previous actor: ' +
|
|
nickname + ' ' + moved_actor)
|
|
return False
|
|
# follow the moved actor
|
|
moved_nickname = get_nickname_from_actor(moved_actor)
|
|
if not moved_nickname:
|
|
print('INBOX: Move activity invalid actor: ' + moved_actor)
|
|
return False
|
|
moved_domain, moved_port = get_domain_from_actor(moved_actor)
|
|
if not moved_domain:
|
|
print('INBOX: Move activity invalid domain: ' + moved_actor)
|
|
return False
|
|
# is the moved actor blocked?
|
|
if is_blocked(base_dir, nickname, domain,
|
|
moved_nickname, moved_domain,
|
|
blocked_cache, block_federated):
|
|
print('INBOX: Move activity actor is blocked: ' + moved_actor)
|
|
return False
|
|
print('INBOX: Move activity sending follow request: ' +
|
|
nickname + ' ' + moved_actor)
|
|
send_follow_request(session,
|
|
base_dir, nickname,
|
|
domain, domain, port,
|
|
http_prefix,
|
|
moved_nickname,
|
|
moved_domain,
|
|
moved_actor,
|
|
moved_port, http_prefix,
|
|
False, federation_list,
|
|
send_threads,
|
|
post_log,
|
|
cached_webfingers,
|
|
person_cache, debug,
|
|
__version__,
|
|
signing_priv_key_pem,
|
|
domain,
|
|
onion_domain,
|
|
i2p_domain,
|
|
sites_unavailable,
|
|
system_language,
|
|
mitm_servers)
|
|
return True
|
|
|
|
|
|
def receive_update_activity(recent_posts_cache: {}, session, base_dir: str,
|
|
http_prefix: str, domain: str, port: int,
|
|
cached_webfingers: {},
|
|
person_cache: {}, message_json: {},
|
|
nickname: str, debug: bool,
|
|
max_mentions: int, max_emoji: int,
|
|
allow_local_network_access: bool,
|
|
system_language: str,
|
|
signing_priv_key_pem: str,
|
|
max_recent_posts: int, translate: {},
|
|
allow_deletion: bool,
|
|
yt_replace_domain: str,
|
|
twitter_replacement_domain: str,
|
|
show_published_date_only: bool,
|
|
peertube_instances: [],
|
|
theme_name: str, max_like_count: int,
|
|
cw_lists: {}, dogwhistles: {},
|
|
min_images_for_accounts: [],
|
|
max_hashtags: int,
|
|
buy_sites: {},
|
|
auto_cw_cache: {},
|
|
onion_domain: str,
|
|
i2p_domain: str,
|
|
mitm_servers: [],
|
|
instance_software: {}) -> bool:
|
|
"""Receives an Update activity within the POST section of HTTPServer
|
|
"""
|
|
if message_json['type'] != 'Update':
|
|
return False
|
|
if not has_actor(message_json, debug):
|
|
return False
|
|
if not has_object_string_type(message_json, debug):
|
|
return False
|
|
actor_url = get_actor_from_post(message_json)
|
|
if not has_users_path(actor_url):
|
|
if debug:
|
|
print('DEBUG: "users" or "profile" missing from actor in ' +
|
|
message_json['type'])
|
|
return False
|
|
|
|
if message_json['object']['type'] == 'Question':
|
|
if _receive_update_to_question(recent_posts_cache, message_json,
|
|
base_dir, nickname, domain,
|
|
system_language,
|
|
allow_local_network_access):
|
|
if debug:
|
|
print('DEBUG: Question update was received')
|
|
return True
|
|
elif message_json['object']['type'] in ('Note', 'Event'):
|
|
if message_json['object'].get('id'):
|
|
domain_full = get_full_domain(domain, port)
|
|
if receive_edit_to_post(recent_posts_cache, message_json,
|
|
base_dir, nickname, domain,
|
|
max_mentions, max_emoji,
|
|
allow_local_network_access,
|
|
debug, system_language, http_prefix,
|
|
domain_full, person_cache,
|
|
signing_priv_key_pem,
|
|
max_recent_posts, translate,
|
|
session, cached_webfingers, port,
|
|
allow_deletion,
|
|
yt_replace_domain,
|
|
twitter_replacement_domain,
|
|
show_published_date_only,
|
|
peertube_instances,
|
|
theme_name, max_like_count,
|
|
cw_lists, dogwhistles,
|
|
min_images_for_accounts,
|
|
max_hashtags, buy_sites,
|
|
auto_cw_cache,
|
|
onion_domain, i2p_domain,
|
|
mitm_servers,
|
|
instance_software):
|
|
print('EDITPOST: received ' + message_json['object']['id'])
|
|
return True
|
|
else:
|
|
print('EDITPOST: rejected ' + str(message_json))
|
|
return False
|
|
|
|
if message_json['object']['type'] == 'Person' or \
|
|
message_json['object']['type'] == 'Application' or \
|
|
message_json['object']['type'] == 'Group' or \
|
|
message_json['object']['type'] == 'Service':
|
|
if message_json['object'].get('url') and \
|
|
message_json['object'].get('id'):
|
|
if debug:
|
|
print('Request to update actor: ' + str(message_json))
|
|
actor_url = get_actor_from_post(message_json)
|
|
update_nickname = get_nickname_from_actor(actor_url)
|
|
update_domain, update_port = \
|
|
get_domain_from_actor(actor_url)
|
|
if update_nickname and update_domain:
|
|
if _person_receive_update(base_dir,
|
|
domain, port,
|
|
update_nickname, update_domain,
|
|
update_port,
|
|
message_json['object'],
|
|
person_cache, debug, http_prefix):
|
|
print('Person Update: ' + str(message_json))
|
|
if debug:
|
|
print('DEBUG: Profile update was received for ' +
|
|
str(message_json['object']['url']))
|
|
return True
|
|
return False
|
|
|
|
|
|
def _already_liked(base_dir: str, nickname: str, domain: str,
|
|
post_url: str, liker_actor: str) -> bool:
|
|
"""Is the given post already liked by the given handle?
|
|
"""
|
|
post_filename = \
|
|
locate_post(base_dir, nickname, domain, post_url)
|
|
if not post_filename:
|
|
return False
|
|
post_json_object = load_json(post_filename)
|
|
if not post_json_object:
|
|
return False
|
|
if not has_object_dict(post_json_object):
|
|
return False
|
|
if not post_json_object['object'].get('likes'):
|
|
return False
|
|
if not post_json_object['object']['likes'].get('items'):
|
|
return False
|
|
for like in post_json_object['object']['likes']['items']:
|
|
if not like.get('type'):
|
|
continue
|
|
if not like.get('actor'):
|
|
continue
|
|
if like['type'] != 'Like':
|
|
continue
|
|
if like['actor'] == liker_actor:
|
|
return True
|
|
return False
|
|
|
|
|
|
def _already_reacted(base_dir: str, nickname: str, domain: str,
|
|
post_url: str, reaction_actor: str,
|
|
emoji_content: str) -> bool:
|
|
"""Is the given post already emoji reacted by the given handle?
|
|
"""
|
|
post_filename = \
|
|
locate_post(base_dir, nickname, domain, post_url)
|
|
if not post_filename:
|
|
return False
|
|
post_json_object = load_json(post_filename)
|
|
if not post_json_object:
|
|
return False
|
|
if not has_object_dict(post_json_object):
|
|
return False
|
|
if not post_json_object['object'].get('reactions'):
|
|
return False
|
|
if not post_json_object['object']['reactions'].get('items'):
|
|
return False
|
|
for react in post_json_object['object']['reactions']['items']:
|
|
if not react.get('type'):
|
|
continue
|
|
if not react.get('content'):
|
|
continue
|
|
if not react.get('actor'):
|
|
continue
|
|
if react['type'] != 'EmojiReact':
|
|
continue
|
|
if react['content'] != emoji_content:
|
|
continue
|
|
if react['actor'] == reaction_actor:
|
|
return True
|
|
return False
|
|
|
|
|
|
def _like_notify(base_dir: str, domain: str,
|
|
onion_domain: str, i2p_domain: str,
|
|
handle: str, actor: str, url: str) -> None:
|
|
"""Creates a notification that a like has arrived
|
|
"""
|
|
# This is not you liking your own post
|
|
if actor in url:
|
|
return
|
|
|
|
# check that the liked post was by this handle
|
|
nickname = handle.split('@')[0]
|
|
if '/' + domain + '/users/' + nickname not in url:
|
|
if onion_domain:
|
|
if '/' + onion_domain + '/users/' + nickname not in url:
|
|
return
|
|
if i2p_domain:
|
|
if '/' + i2p_domain + '/users/' + nickname not in url:
|
|
return
|
|
if not i2p_domain and not onion_domain:
|
|
return
|
|
|
|
account_dir = acct_handle_dir(base_dir, handle)
|
|
|
|
# are like notifications enabled?
|
|
notify_likes_enabled_filename = account_dir + '/.notifyLikes'
|
|
if not os.path.isfile(notify_likes_enabled_filename):
|
|
return
|
|
|
|
like_file = account_dir + '/.newLike'
|
|
if os.path.isfile(like_file):
|
|
if not text_in_file('##sent##', like_file):
|
|
return
|
|
|
|
liker_nickname = get_nickname_from_actor(actor)
|
|
liker_domain, _ = get_domain_from_actor(actor)
|
|
if liker_nickname and liker_domain:
|
|
liker_handle = liker_nickname + '@' + liker_domain
|
|
else:
|
|
print('_like_notify liker_handle: ' +
|
|
str(liker_nickname) + '@' + str(liker_domain))
|
|
liker_handle = actor
|
|
if liker_handle == handle:
|
|
return
|
|
|
|
like_str = liker_handle + ' ' + url + '?likedBy=' + actor
|
|
prev_like_file = account_dir + '/.prevLike'
|
|
# was there a previous like notification?
|
|
if os.path.isfile(prev_like_file):
|
|
# is it the same as the current notification ?
|
|
try:
|
|
with open(prev_like_file, 'r', encoding='utf-8') as fp_like:
|
|
prev_like_str = fp_like.read()
|
|
if prev_like_str == like_str:
|
|
return
|
|
except OSError:
|
|
print('EX: _like_notify unable to read ' + prev_like_file)
|
|
try:
|
|
with open(prev_like_file, 'w+', encoding='utf-8') as fp_like:
|
|
fp_like.write(like_str)
|
|
except OSError:
|
|
print('EX: ERROR: unable to save previous like notification ' +
|
|
prev_like_file)
|
|
|
|
try:
|
|
with open(like_file, 'w+', encoding='utf-8') as fp_like:
|
|
fp_like.write(like_str)
|
|
except OSError:
|
|
print('EX: ERROR: unable to write like notification file ' +
|
|
like_file)
|
|
|
|
|
|
def _reaction_notify(base_dir: str, domain: str, onion_domain: str,
|
|
handle: str, actor: str,
|
|
url: str, emoji_content: str) -> None:
|
|
"""Creates a notification that an emoji reaction has arrived
|
|
"""
|
|
# This is not you reacting to your own post
|
|
if actor in url:
|
|
return
|
|
|
|
# check that the reaction post was by this handle
|
|
nickname = handle.split('@')[0]
|
|
if '/' + domain + '/users/' + nickname not in url:
|
|
if not onion_domain:
|
|
return
|
|
if '/' + onion_domain + '/users/' + nickname not in url:
|
|
return
|
|
|
|
account_dir = acct_handle_dir(base_dir, handle)
|
|
|
|
# are reaction notifications enabled?
|
|
notify_reaction_enabled_filename = account_dir + '/.notifyReactions'
|
|
if not os.path.isfile(notify_reaction_enabled_filename):
|
|
return
|
|
|
|
reaction_file = account_dir + '/.newReaction'
|
|
if os.path.isfile(reaction_file):
|
|
if not text_in_file('##sent##', reaction_file):
|
|
return
|
|
|
|
reaction_nickname = get_nickname_from_actor(actor)
|
|
reaction_domain, _ = get_domain_from_actor(actor)
|
|
if reaction_nickname and reaction_domain:
|
|
reaction_handle = reaction_nickname + '@' + reaction_domain
|
|
else:
|
|
print('_reaction_notify reaction_handle: ' +
|
|
str(reaction_nickname) + '@' + str(reaction_domain))
|
|
reaction_handle = actor
|
|
if reaction_handle == handle:
|
|
return
|
|
reaction_str = \
|
|
reaction_handle + ' ' + url + '?reactBy=' + actor + \
|
|
';emoj=' + emoji_content
|
|
prev_reaction_file = account_dir + '/.prevReaction'
|
|
# was there a previous reaction notification?
|
|
if os.path.isfile(prev_reaction_file):
|
|
# is it the same as the current notification ?
|
|
try:
|
|
with open(prev_reaction_file, 'r', encoding='utf-8') as fp_react:
|
|
prev_reaction_str = fp_react.read()
|
|
if prev_reaction_str == reaction_str:
|
|
return
|
|
except OSError:
|
|
print('EX: _reaction_notify unable to read ' + prev_reaction_file)
|
|
try:
|
|
with open(prev_reaction_file, 'w+', encoding='utf-8') as fp_react:
|
|
fp_react.write(reaction_str)
|
|
except OSError:
|
|
print('EX: ERROR: unable to save previous reaction notification ' +
|
|
prev_reaction_file)
|
|
|
|
try:
|
|
with open(reaction_file, 'w+', encoding='utf-8') as fp_react:
|
|
fp_react.write(reaction_str)
|
|
except OSError:
|
|
print('EX: ERROR: unable to write reaction notification file ' +
|
|
reaction_file)
|
|
|
|
|
|
def receive_like(recent_posts_cache: {},
|
|
session, handle: str, base_dir: str,
|
|
http_prefix: str, domain: str, port: int,
|
|
onion_domain: str, i2p_domain: str,
|
|
cached_webfingers: {},
|
|
person_cache: {}, message_json: {},
|
|
debug: bool,
|
|
signing_priv_key_pem: str,
|
|
max_recent_posts: int, translate: {},
|
|
allow_deletion: bool,
|
|
yt_replace_domain: str,
|
|
twitter_replacement_domain: str,
|
|
peertube_instances: [],
|
|
allow_local_network_access: bool,
|
|
theme_name: str, system_language: str,
|
|
max_like_count: int, cw_lists: {},
|
|
lists_enabled: str,
|
|
bold_reading: bool, dogwhistles: {},
|
|
min_images_for_accounts: [],
|
|
buy_sites: {},
|
|
auto_cw_cache: {},
|
|
mitm_servers: [],
|
|
instance_software: {}) -> bool:
|
|
"""Receives a Like activity within the POST section of HTTPServer
|
|
"""
|
|
if message_json['type'] != 'Like':
|
|
return False
|
|
if not has_actor(message_json, debug):
|
|
return False
|
|
if not has_object_string(message_json, debug):
|
|
return False
|
|
if not message_json.get('to'):
|
|
if debug:
|
|
print('DEBUG: ' + message_json['type'] + ' has no "to" list')
|
|
return False
|
|
actor_url = get_actor_from_post(message_json)
|
|
if not has_users_path(actor_url):
|
|
if debug:
|
|
print('DEBUG: "users" or "profile" missing from actor in ' +
|
|
message_json['type'])
|
|
return False
|
|
if '/statuses/' not in message_json['object']:
|
|
if debug:
|
|
print('DEBUG: "statuses" missing from object in ' +
|
|
message_json['type'])
|
|
return False
|
|
handle_dir = acct_handle_dir(base_dir, handle)
|
|
if not os.path.isdir(handle_dir):
|
|
print('DEBUG: unknown recipient of like - ' + handle)
|
|
# if this post in the outbox of the person?
|
|
handle_name = handle.split('@')[0]
|
|
handle_dom = handle.split('@')[1]
|
|
post_liked_id = message_json['object']
|
|
post_filename = \
|
|
locate_post(base_dir, handle_name, handle_dom, post_liked_id)
|
|
if not post_filename:
|
|
if debug:
|
|
print('DEBUG: post not found in inbox or outbox')
|
|
print(post_liked_id)
|
|
return True
|
|
if debug:
|
|
print('DEBUG: liked post found in inbox')
|
|
|
|
like_actor = get_actor_from_post(message_json)
|
|
handle_name = handle.split('@')[0]
|
|
handle_dom = handle.split('@')[1]
|
|
if not _already_liked(base_dir,
|
|
handle_name, handle_dom,
|
|
post_liked_id,
|
|
like_actor):
|
|
_like_notify(base_dir, domain, onion_domain, i2p_domain, handle,
|
|
like_actor, post_liked_id)
|
|
update_likes_collection(recent_posts_cache, base_dir, post_filename,
|
|
post_liked_id, like_actor,
|
|
handle_name, domain, debug, None)
|
|
# regenerate the html
|
|
liked_post_json = load_json(post_filename)
|
|
if liked_post_json:
|
|
if liked_post_json.get('type'):
|
|
if liked_post_json['type'] == 'Announce' and \
|
|
liked_post_json.get('object'):
|
|
if isinstance(liked_post_json['object'], str):
|
|
announce_like_url = liked_post_json['object']
|
|
announce_liked_filename = \
|
|
locate_post(base_dir, handle_name,
|
|
domain, announce_like_url)
|
|
if announce_liked_filename:
|
|
post_liked_id = announce_like_url
|
|
post_filename = announce_liked_filename
|
|
update_likes_collection(recent_posts_cache,
|
|
base_dir,
|
|
post_filename,
|
|
post_liked_id,
|
|
like_actor,
|
|
handle_name,
|
|
domain, debug, None)
|
|
if liked_post_json:
|
|
if debug:
|
|
cached_post_filename = \
|
|
get_cached_post_filename(base_dir, handle_name, domain,
|
|
liked_post_json)
|
|
print('Liked post json: ' + str(liked_post_json))
|
|
print('Liked post nickname: ' + handle_name + ' ' + domain)
|
|
print('Liked post cache: ' + str(cached_post_filename))
|
|
page_number = 1
|
|
show_published_date_only = False
|
|
show_individual_post_icons = True
|
|
manually_approve_followers = \
|
|
follower_approval_active(base_dir, handle_name, domain)
|
|
not_dm = not is_dm(liked_post_json)
|
|
timezone = get_account_timezone(base_dir, handle_name, domain)
|
|
mitm = False
|
|
if os.path.isfile(post_filename.replace('.json', '') + '.mitm'):
|
|
mitm = True
|
|
minimize_all_images = False
|
|
if handle_name in min_images_for_accounts:
|
|
minimize_all_images = True
|
|
individual_post_as_html(signing_priv_key_pem, False,
|
|
recent_posts_cache, max_recent_posts,
|
|
translate, page_number, base_dir,
|
|
session, cached_webfingers, person_cache,
|
|
handle_name, domain, port, liked_post_json,
|
|
None, True, allow_deletion,
|
|
http_prefix, __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, not_dm,
|
|
show_individual_post_icons,
|
|
manually_approve_followers,
|
|
False, True, False, cw_lists,
|
|
lists_enabled, timezone, mitm,
|
|
bold_reading, dogwhistles,
|
|
minimize_all_images, None, buy_sites,
|
|
auto_cw_cache, mitm_servers,
|
|
instance_software)
|
|
return True
|
|
|
|
|
|
def receive_reaction(recent_posts_cache: {},
|
|
session, handle: str, base_dir: str,
|
|
http_prefix: str, domain: str, port: int,
|
|
onion_domain: str,
|
|
cached_webfingers: {},
|
|
person_cache: {}, message_json: {},
|
|
debug: bool,
|
|
signing_priv_key_pem: str,
|
|
max_recent_posts: int, translate: {},
|
|
allow_deletion: bool,
|
|
yt_replace_domain: str,
|
|
twitter_replacement_domain: str,
|
|
peertube_instances: [],
|
|
allow_local_network_access: bool,
|
|
theme_name: str, system_language: str,
|
|
max_like_count: int, cw_lists: {},
|
|
lists_enabled: str, bold_reading: bool,
|
|
dogwhistles: {},
|
|
min_images_for_accounts: [],
|
|
buy_sites: {},
|
|
auto_cw_cache: {},
|
|
mitm_servers: [],
|
|
instance_software: {}) -> bool:
|
|
"""Receives an emoji reaction within the POST section of HTTPServer
|
|
"""
|
|
if message_json['type'] != 'EmojiReact':
|
|
return False
|
|
if not has_actor(message_json, debug):
|
|
return False
|
|
if not has_object_string(message_json, debug):
|
|
return False
|
|
if 'content' not in message_json:
|
|
if debug:
|
|
print('DEBUG: ' + message_json['type'] + ' has no "content"')
|
|
return False
|
|
if not isinstance(message_json['content'], str):
|
|
if debug:
|
|
print('DEBUG: ' + message_json['type'] + ' content is not string')
|
|
return False
|
|
actor_url = get_actor_from_post(message_json)
|
|
if not valid_emoji_content(message_json['content']):
|
|
print('_receive_reaction: Invalid emoji reaction: "' +
|
|
message_json['content'] + '" from ' + actor_url)
|
|
return False
|
|
if not has_users_path(actor_url):
|
|
if debug:
|
|
print('DEBUG: "users" or "profile" missing from actor in ' +
|
|
message_json['type'])
|
|
return False
|
|
if '/statuses/' not in message_json['object']:
|
|
if debug:
|
|
print('DEBUG: "statuses" missing from object in ' +
|
|
message_json['type'])
|
|
return False
|
|
handle_dir = acct_handle_dir(base_dir, handle)
|
|
if not os.path.isdir(handle_dir):
|
|
print('DEBUG: unknown recipient of emoji reaction - ' + handle)
|
|
if os.path.isfile(handle_dir + '/.hideReactionButton'):
|
|
print('Emoji reaction rejected by ' + handle +
|
|
' due to their settings')
|
|
return True
|
|
# if this post in the outbox of the person?
|
|
handle_name = handle.split('@')[0]
|
|
handle_dom = handle.split('@')[1]
|
|
|
|
post_reaction_id = message_json['object']
|
|
emoji_content = remove_html(message_json['content'])
|
|
if not emoji_content:
|
|
if debug:
|
|
print('DEBUG: emoji reaction has no content')
|
|
return True
|
|
post_filename = locate_post(base_dir, handle_name, handle_dom,
|
|
post_reaction_id)
|
|
if not post_filename:
|
|
if debug:
|
|
print('DEBUG: emoji reaction post not found in inbox or outbox')
|
|
print(post_reaction_id)
|
|
return True
|
|
if debug:
|
|
print('DEBUG: emoji reaction post found in inbox')
|
|
|
|
reaction_actor = get_actor_from_post(message_json)
|
|
handle_name = handle.split('@')[0]
|
|
handle_dom = handle.split('@')[1]
|
|
if not _already_reacted(base_dir,
|
|
handle_name, handle_dom,
|
|
post_reaction_id,
|
|
reaction_actor,
|
|
emoji_content):
|
|
_reaction_notify(base_dir, domain, onion_domain, handle,
|
|
reaction_actor, post_reaction_id, emoji_content)
|
|
update_reaction_collection(recent_posts_cache, base_dir, post_filename,
|
|
post_reaction_id, reaction_actor,
|
|
handle_name, domain, debug, None, emoji_content)
|
|
# regenerate the html
|
|
reaction_post_json = load_json(post_filename)
|
|
if reaction_post_json:
|
|
if reaction_post_json.get('type'):
|
|
if reaction_post_json['type'] == 'Announce' and \
|
|
reaction_post_json.get('object'):
|
|
if isinstance(reaction_post_json['object'], str):
|
|
announce_reaction_url = reaction_post_json['object']
|
|
announce_reaction_filename = \
|
|
locate_post(base_dir, handle_name,
|
|
domain, announce_reaction_url)
|
|
if announce_reaction_filename:
|
|
post_reaction_id = announce_reaction_url
|
|
post_filename = announce_reaction_filename
|
|
update_reaction_collection(recent_posts_cache,
|
|
base_dir,
|
|
post_filename,
|
|
post_reaction_id,
|
|
reaction_actor,
|
|
handle_name,
|
|
domain, debug, None,
|
|
emoji_content)
|
|
if reaction_post_json:
|
|
if debug:
|
|
cached_post_filename = \
|
|
get_cached_post_filename(base_dir, handle_name, domain,
|
|
reaction_post_json)
|
|
print('Reaction post json: ' + str(reaction_post_json))
|
|
print('Reaction post nickname: ' + handle_name + ' ' + domain)
|
|
print('Reaction post cache: ' + str(cached_post_filename))
|
|
page_number = 1
|
|
show_published_date_only = False
|
|
show_individual_post_icons = True
|
|
manually_approve_followers = \
|
|
follower_approval_active(base_dir, handle_name, domain)
|
|
not_dm = not is_dm(reaction_post_json)
|
|
timezone = get_account_timezone(base_dir, handle_name, domain)
|
|
mitm = False
|
|
if os.path.isfile(post_filename.replace('.json', '') + '.mitm'):
|
|
mitm = True
|
|
minimize_all_images = False
|
|
if handle_name in min_images_for_accounts:
|
|
minimize_all_images = True
|
|
individual_post_as_html(signing_priv_key_pem, False,
|
|
recent_posts_cache, max_recent_posts,
|
|
translate, page_number, base_dir,
|
|
session, cached_webfingers, person_cache,
|
|
handle_name, domain, port,
|
|
reaction_post_json,
|
|
None, True, allow_deletion,
|
|
http_prefix, __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, not_dm,
|
|
show_individual_post_icons,
|
|
manually_approve_followers,
|
|
False, True, False, cw_lists,
|
|
lists_enabled, timezone, mitm,
|
|
bold_reading, dogwhistles,
|
|
minimize_all_images, None, buy_sites,
|
|
auto_cw_cache, mitm_servers,
|
|
instance_software)
|
|
return True
|
|
|
|
|
|
def receive_zot_reaction(recent_posts_cache: {},
|
|
session, handle: str, base_dir: str,
|
|
http_prefix: str, domain: str, port: int,
|
|
onion_domain: str,
|
|
cached_webfingers: {},
|
|
person_cache: {}, message_json: {},
|
|
debug: bool,
|
|
signing_priv_key_pem: str,
|
|
max_recent_posts: int, translate: {},
|
|
allow_deletion: bool,
|
|
yt_replace_domain: str,
|
|
twitter_replacement_domain: str,
|
|
peertube_instances: [],
|
|
allow_local_network_access: bool,
|
|
theme_name: str, system_language: str,
|
|
max_like_count: int, cw_lists: {},
|
|
lists_enabled: str, bold_reading: bool,
|
|
dogwhistles: {},
|
|
min_images_for_accounts: [],
|
|
buy_sites: {},
|
|
auto_cw_cache: {},
|
|
mitm_servers: [],
|
|
instance_software: {}) -> bool:
|
|
"""Receives an zot-style emoji reaction within the POST section of
|
|
HTTPServer A zot style emoji reaction is an ordinary reply Note whose
|
|
content is exactly one emoji
|
|
"""
|
|
if not has_actor(message_json, debug):
|
|
return False
|
|
if not has_object_dict(message_json):
|
|
return False
|
|
if not message_json['object'].get('type'):
|
|
return False
|
|
if not isinstance(message_json['object']['type'], str):
|
|
return False
|
|
if message_json['object']['type'] != 'Note':
|
|
return False
|
|
if 'content' not in message_json['object']:
|
|
if debug:
|
|
print('DEBUG: ' + message_json['object']['type'] +
|
|
' has no "content"')
|
|
return False
|
|
reply_id = get_reply_to(message_json['object'])
|
|
if not reply_id:
|
|
if debug:
|
|
print('DEBUG: ' + message_json['object']['type'] +
|
|
' has no "inReplyTo"')
|
|
return False
|
|
if not isinstance(message_json['object']['content'], str):
|
|
if debug:
|
|
print('DEBUG: ' + message_json['object']['type'] +
|
|
' content is not string')
|
|
return False
|
|
if len(message_json['object']['content']) > 4:
|
|
if debug:
|
|
print('DEBUG: content is too long to be an emoji reaction')
|
|
return False
|
|
if not isinstance(reply_id, str):
|
|
if debug:
|
|
print('DEBUG: ' + message_json['object']['type'] +
|
|
' inReplyTo is not string')
|
|
return False
|
|
actor_url = get_actor_from_post(message_json)
|
|
if not valid_emoji_content(message_json['object']['content']):
|
|
print('_receive_zot_reaction: Invalid emoji reaction: "' +
|
|
message_json['object']['content'] + '" from ' +
|
|
actor_url)
|
|
return False
|
|
if not has_users_path(actor_url):
|
|
if debug:
|
|
print('DEBUG: "users" or "profile" missing from actor in ' +
|
|
message_json['object']['type'])
|
|
return False
|
|
if '/statuses/' not in reply_id:
|
|
if debug:
|
|
print('DEBUG: "statuses" missing from inReplyTo in ' +
|
|
message_json['object']['type'])
|
|
return False
|
|
handle_dir = acct_handle_dir(base_dir, handle)
|
|
if not os.path.isdir(handle_dir):
|
|
print('DEBUG: unknown recipient of zot emoji reaction - ' + handle)
|
|
if os.path.isfile(handle_dir + '/.hideReactionButton'):
|
|
print('Zot emoji reaction rejected by ' + handle +
|
|
' due to their settings')
|
|
return True
|
|
# if this post in the outbox of the person?
|
|
handle_name = handle.split('@')[0]
|
|
handle_dom = handle.split('@')[1]
|
|
|
|
post_reaction_id = get_reply_to(message_json['object'])
|
|
emoji_content = remove_html(message_json['object']['content'])
|
|
if not emoji_content:
|
|
if debug:
|
|
print('DEBUG: zot emoji reaction has no content')
|
|
return True
|
|
post_filename = locate_post(base_dir, handle_name, handle_dom,
|
|
post_reaction_id)
|
|
if not post_filename:
|
|
if debug:
|
|
print('DEBUG: ' +
|
|
'zot emoji reaction post not found in inbox or outbox')
|
|
print(post_reaction_id)
|
|
return True
|
|
if debug:
|
|
print('DEBUG: zot emoji reaction post found in inbox')
|
|
|
|
reaction_actor = get_actor_from_post(message_json)
|
|
handle_name = handle.split('@')[0]
|
|
handle_dom = handle.split('@')[1]
|
|
if not _already_reacted(base_dir,
|
|
handle_name, handle_dom,
|
|
post_reaction_id,
|
|
reaction_actor,
|
|
emoji_content):
|
|
_reaction_notify(base_dir, domain, onion_domain, handle,
|
|
reaction_actor, post_reaction_id, emoji_content)
|
|
update_reaction_collection(recent_posts_cache, base_dir, post_filename,
|
|
post_reaction_id, reaction_actor,
|
|
handle_name, domain, debug, None, emoji_content)
|
|
# regenerate the html
|
|
reaction_post_json = load_json(post_filename)
|
|
if reaction_post_json:
|
|
if reaction_post_json.get('type'):
|
|
if reaction_post_json['type'] == 'Announce' and \
|
|
reaction_post_json.get('object'):
|
|
if isinstance(reaction_post_json['object'], str):
|
|
announce_reaction_url = reaction_post_json['object']
|
|
announce_reaction_filename = \
|
|
locate_post(base_dir, handle_name,
|
|
domain, announce_reaction_url)
|
|
if announce_reaction_filename:
|
|
post_reaction_id = announce_reaction_url
|
|
post_filename = announce_reaction_filename
|
|
update_reaction_collection(recent_posts_cache,
|
|
base_dir,
|
|
post_filename,
|
|
post_reaction_id,
|
|
reaction_actor,
|
|
handle_name,
|
|
domain, debug, None,
|
|
emoji_content)
|
|
if reaction_post_json:
|
|
if debug:
|
|
cached_post_filename = \
|
|
get_cached_post_filename(base_dir, handle_name, domain,
|
|
reaction_post_json)
|
|
print('Reaction post json: ' + str(reaction_post_json))
|
|
print('Reaction post nickname: ' + handle_name + ' ' + domain)
|
|
print('Reaction post cache: ' + str(cached_post_filename))
|
|
page_number = 1
|
|
show_published_date_only = False
|
|
show_individual_post_icons = True
|
|
manually_approve_followers = \
|
|
follower_approval_active(base_dir, handle_name, domain)
|
|
not_dm = not is_dm(reaction_post_json)
|
|
timezone = get_account_timezone(base_dir, handle_name, domain)
|
|
mitm = False
|
|
if os.path.isfile(post_filename.replace('.json', '') + '.mitm'):
|
|
mitm = True
|
|
minimize_all_images = False
|
|
if handle_name in min_images_for_accounts:
|
|
minimize_all_images = True
|
|
individual_post_as_html(signing_priv_key_pem, False,
|
|
recent_posts_cache, max_recent_posts,
|
|
translate, page_number, base_dir,
|
|
session, cached_webfingers, person_cache,
|
|
handle_name, domain, port,
|
|
reaction_post_json,
|
|
None, True, allow_deletion,
|
|
http_prefix, __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, not_dm,
|
|
show_individual_post_icons,
|
|
manually_approve_followers,
|
|
False, True, False, cw_lists,
|
|
lists_enabled, timezone, mitm,
|
|
bold_reading, dogwhistles,
|
|
minimize_all_images, None,
|
|
buy_sites, auto_cw_cache,
|
|
mitm_servers,
|
|
instance_software)
|
|
return True
|
|
|
|
|
|
def receive_bookmark(recent_posts_cache: {},
|
|
session, handle: str, base_dir: str,
|
|
http_prefix: str, domain: str, port: int,
|
|
cached_webfingers: {},
|
|
person_cache: {}, message_json: {},
|
|
debug: bool, signing_priv_key_pem: str,
|
|
max_recent_posts: int, translate: {},
|
|
allow_deletion: bool,
|
|
yt_replace_domain: str,
|
|
twitter_replacement_domain: str,
|
|
peertube_instances: [],
|
|
allow_local_network_access: bool,
|
|
theme_name: str, system_language: str,
|
|
max_like_count: int, cw_lists: {},
|
|
lists_enabled: {}, bold_reading: bool,
|
|
dogwhistles: {},
|
|
min_images_for_accounts: [],
|
|
buy_sites: {},
|
|
auto_cw_cache: {},
|
|
mitm_servers: [],
|
|
instance_software: {}) -> bool:
|
|
"""Receives a bookmark activity within the POST section of HTTPServer
|
|
"""
|
|
if not message_json.get('type'):
|
|
return False
|
|
if message_json['type'] != 'Add':
|
|
return False
|
|
if not has_actor(message_json, debug):
|
|
return False
|
|
if not message_json.get('target'):
|
|
if debug:
|
|
print('DEBUG: no target in inbox bookmark Add')
|
|
return False
|
|
if not has_object_string_type(message_json, debug):
|
|
return False
|
|
if not isinstance(message_json['target'], str):
|
|
if debug:
|
|
print('DEBUG: inbox bookmark Add target is not string')
|
|
return False
|
|
domain_full = get_full_domain(domain, port)
|
|
nickname = handle.split('@')[0]
|
|
actor_url = get_actor_from_post(message_json)
|
|
if not actor_url.endswith(domain_full + '/users/' + nickname):
|
|
if debug:
|
|
print('DEBUG: inbox bookmark Add unexpected actor')
|
|
return False
|
|
if not message_json['target'].endswith(actor_url +
|
|
'/tlbookmarks'):
|
|
if debug:
|
|
print('DEBUG: inbox bookmark Add target invalid ' +
|
|
message_json['target'])
|
|
return False
|
|
if message_json['object']['type'] != 'Document':
|
|
if debug:
|
|
print('DEBUG: inbox bookmark Add type is not Document')
|
|
return False
|
|
if not message_json['object'].get('url'):
|
|
if debug:
|
|
print('DEBUG: inbox bookmark Add missing url')
|
|
return False
|
|
url_str = get_url_from_post(message_json['object']['url'])
|
|
if '/statuses/' not in url_str:
|
|
if debug:
|
|
print('DEBUG: inbox bookmark Add missing statuses un url')
|
|
return False
|
|
if debug:
|
|
print('DEBUG: c2s inbox bookmark Add request arrived in outbox')
|
|
|
|
message_url2 = remove_html(url_str)
|
|
message_url = remove_id_ending(message_url2)
|
|
domain = remove_domain_port(domain)
|
|
post_filename = locate_post(base_dir, nickname, domain, message_url)
|
|
if not post_filename:
|
|
if debug:
|
|
print('DEBUG: c2s inbox like post not found in inbox or outbox')
|
|
print(message_url)
|
|
return True
|
|
|
|
update_bookmarks_collection(recent_posts_cache, base_dir, post_filename,
|
|
message_url2, actor_url, domain, debug)
|
|
# regenerate the html
|
|
bookmarked_post_json = load_json(post_filename)
|
|
if bookmarked_post_json:
|
|
if debug:
|
|
cached_post_filename = \
|
|
get_cached_post_filename(base_dir, nickname, domain,
|
|
bookmarked_post_json)
|
|
print('Bookmarked post json: ' + str(bookmarked_post_json))
|
|
print('Bookmarked post nickname: ' + nickname + ' ' + domain)
|
|
print('Bookmarked post cache: ' + str(cached_post_filename))
|
|
page_number = 1
|
|
show_published_date_only = False
|
|
show_individual_post_icons = True
|
|
manually_approve_followers = \
|
|
follower_approval_active(base_dir, nickname, domain)
|
|
not_dm = not is_dm(bookmarked_post_json)
|
|
timezone = get_account_timezone(base_dir, nickname, domain)
|
|
mitm = False
|
|
if os.path.isfile(post_filename.replace('.json', '') + '.mitm'):
|
|
mitm = True
|
|
minimize_all_images = False
|
|
if nickname in min_images_for_accounts:
|
|
minimize_all_images = True
|
|
individual_post_as_html(signing_priv_key_pem, False,
|
|
recent_posts_cache, max_recent_posts,
|
|
translate, page_number, base_dir,
|
|
session, cached_webfingers, person_cache,
|
|
nickname, domain, port, bookmarked_post_json,
|
|
None, True, allow_deletion,
|
|
http_prefix, __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, not_dm,
|
|
show_individual_post_icons,
|
|
manually_approve_followers,
|
|
False, True, False, cw_lists,
|
|
lists_enabled, timezone, mitm,
|
|
bold_reading, dogwhistles,
|
|
minimize_all_images, None,
|
|
buy_sites, auto_cw_cache,
|
|
mitm_servers,
|
|
instance_software)
|
|
return True
|
|
|
|
|
|
def receive_delete(handle: str, base_dir: str,
|
|
http_prefix: str, domain: str, port: int,
|
|
message_json: {},
|
|
debug: bool, allow_deletion: bool,
|
|
recent_posts_cache: {}) -> bool:
|
|
"""Receives a Delete activity within the POST section of HTTPServer
|
|
"""
|
|
if message_json['type'] != 'Delete':
|
|
return False
|
|
if not has_actor(message_json, debug):
|
|
return False
|
|
if debug:
|
|
print('DEBUG: Delete activity arrived')
|
|
if not has_object_string(message_json, debug):
|
|
return False
|
|
domain_full = get_full_domain(domain, port)
|
|
delete_prefix = http_prefix + '://' + domain_full + '/'
|
|
actor_url = get_actor_from_post(message_json)
|
|
if (not allow_deletion and
|
|
(not message_json['object'].startswith(delete_prefix) or
|
|
not actor_url.startswith(delete_prefix))):
|
|
if debug:
|
|
print('DEBUG: delete not permitted from other instances')
|
|
return False
|
|
if not message_json.get('to'):
|
|
if debug:
|
|
print('DEBUG: ' + message_json['type'] + ' has no "to" list')
|
|
return False
|
|
if not has_users_path(actor_url):
|
|
if debug:
|
|
print('DEBUG: ' +
|
|
'"users" or "profile" missing from actor in ' +
|
|
message_json['type'])
|
|
return False
|
|
if '/statuses/' not in message_json['object']:
|
|
if debug:
|
|
print('DEBUG: "statuses" missing from object in ' +
|
|
message_json['type'])
|
|
return False
|
|
if actor_url not in message_json['object']:
|
|
if debug:
|
|
print('DEBUG: actor is not the owner of the post to be deleted')
|
|
handle_dir = acct_handle_dir(base_dir, handle)
|
|
if not os.path.isdir(handle_dir):
|
|
print('DEBUG: unknown recipient of like - ' + handle)
|
|
# if this post in the outbox of the person?
|
|
message_id = remove_id_ending(message_json['object'])
|
|
remove_moderation_post_from_index(base_dir, message_id, debug)
|
|
handle_nickname = handle.split('@')[0]
|
|
handle_domain = handle.split('@')[1]
|
|
post_filename = locate_post(base_dir, handle_nickname,
|
|
handle_domain, message_id)
|
|
if not post_filename:
|
|
if debug:
|
|
print('DEBUG: delete post not found in inbox or outbox')
|
|
print(message_id)
|
|
return True
|
|
delete_post(base_dir, http_prefix, handle_nickname,
|
|
handle_domain, post_filename, debug,
|
|
recent_posts_cache, True)
|
|
if debug:
|
|
print('DEBUG: post deleted - ' + post_filename)
|
|
|
|
# also delete any local blogs saved to the news actor
|
|
if handle_nickname != 'news' and handle_domain == domain_full:
|
|
post_filename = locate_post(base_dir, 'news',
|
|
handle_domain, message_id)
|
|
if post_filename:
|
|
delete_post(base_dir, http_prefix, 'news',
|
|
handle_domain, post_filename, debug,
|
|
recent_posts_cache, True)
|
|
if debug:
|
|
print('DEBUG: blog post deleted - ' + post_filename)
|
|
return True
|
|
|
|
|
|
def receive_announce(recent_posts_cache: {},
|
|
session, handle: str, base_dir: str,
|
|
http_prefix: str,
|
|
domain: str,
|
|
onion_domain: str, i2p_domain: str, port: int,
|
|
cached_webfingers: {},
|
|
person_cache: {}, message_json: {},
|
|
debug: bool, translate: {},
|
|
yt_replace_domain: str,
|
|
twitter_replacement_domain: str,
|
|
allow_local_network_access: bool,
|
|
theme_name: str, system_language: str,
|
|
signing_priv_key_pem: str,
|
|
max_recent_posts: int,
|
|
allow_deletion: bool,
|
|
peertube_instances: [],
|
|
max_like_count: int, cw_lists: {},
|
|
lists_enabled: str, bold_reading: bool,
|
|
dogwhistles: {}, mitm: bool,
|
|
min_images_for_accounts: [],
|
|
buy_sites: {},
|
|
languages_understood: [],
|
|
auto_cw_cache: {},
|
|
block_federated: [],
|
|
mitm_servers: [],
|
|
instance_software: {}) -> bool:
|
|
"""Receives an announce activity within the POST section of HTTPServer
|
|
"""
|
|
if message_json['type'] != 'Announce':
|
|
return False
|
|
if '@' not in handle:
|
|
if debug:
|
|
print('DEBUG: bad handle ' + handle)
|
|
return False
|
|
if not has_actor(message_json, debug):
|
|
return False
|
|
if debug:
|
|
print('DEBUG: receiving announce on ' + handle)
|
|
is_quote = False
|
|
if not has_object_string(message_json, debug):
|
|
if not is_quote_toot(message_json, ''):
|
|
return False
|
|
else:
|
|
is_quote = True
|
|
if not message_json.get('to'):
|
|
if debug:
|
|
print('DEBUG: ' + message_json['type'] + ' has no "to" list')
|
|
return False
|
|
actor_url = get_actor_from_post(message_json)
|
|
if not has_users_path(actor_url):
|
|
print('WARN: unknown users path ' + actor_url)
|
|
if debug:
|
|
print('DEBUG: ' +
|
|
'"users" or "profile" missing from actor in ' +
|
|
message_json['type'])
|
|
return False
|
|
if is_self_announce(message_json):
|
|
if debug:
|
|
print('DEBUG: self-boost rejected')
|
|
return False
|
|
if not is_quote:
|
|
announce_url = str(message_json['object'])
|
|
else:
|
|
announce_url = get_quote_toot_url(message_json)
|
|
if not has_users_path(announce_url):
|
|
# log any unrecognised statuses
|
|
if not contains_statuses(announce_url):
|
|
print('WARN: unknown statuses path ' + announce_url)
|
|
if debug:
|
|
print('DEBUG: ' +
|
|
'"users", "channel" or "profile" missing in ' +
|
|
message_json['type'])
|
|
return False
|
|
|
|
blocked_cache = {}
|
|
prefixes = get_protocol_prefixes()
|
|
# is the domain of the announce actor blocked?
|
|
object_domain = announce_url
|
|
for prefix in prefixes:
|
|
object_domain = object_domain.replace(prefix, '')
|
|
if '/' in object_domain:
|
|
object_domain = object_domain.split('/')[0]
|
|
if is_blocked_domain(base_dir, object_domain, None, block_federated):
|
|
if debug:
|
|
print('DEBUG: announced domain is blocked')
|
|
return False
|
|
handle_dir = acct_handle_dir(base_dir, handle)
|
|
if not os.path.isdir(handle_dir):
|
|
print('DEBUG: unknown recipient of announce - ' + handle)
|
|
|
|
# is the announce actor blocked?
|
|
nickname = handle.split('@')[0]
|
|
actor_nickname = get_nickname_from_actor(actor_url)
|
|
if not actor_nickname:
|
|
print('WARN: _receive_announce no actor_nickname')
|
|
return False
|
|
actor_domain, _ = get_domain_from_actor(actor_url)
|
|
if not actor_domain:
|
|
print('WARN: _receive_announce no actor_domain')
|
|
return False
|
|
if is_blocked_nickname(base_dir, actor_nickname):
|
|
if debug:
|
|
print('DEBUG: announced nickname is blocked')
|
|
return False
|
|
if is_blocked(base_dir, nickname, domain, actor_nickname, actor_domain,
|
|
None, block_federated):
|
|
print('Receive announce blocked for actor: ' +
|
|
actor_nickname + '@' + actor_domain)
|
|
return False
|
|
|
|
# Are announces permitted from the given actor?
|
|
if not allowed_announce(base_dir, nickname, domain,
|
|
actor_nickname, actor_domain):
|
|
print('Announce not allowed for: ' +
|
|
actor_nickname + '@' + actor_domain)
|
|
return False
|
|
|
|
# also check the actor for the url being announced
|
|
announced_actor_nickname = get_nickname_from_actor(announce_url)
|
|
if not announced_actor_nickname:
|
|
print('WARN: _receive_announce no announced_actor_nickname')
|
|
return False
|
|
announced_actor_domain, _ = get_domain_from_actor(announce_url)
|
|
if not announced_actor_domain:
|
|
print('WARN: _receive_announce no announced_actor_domain')
|
|
return False
|
|
if is_blocked(base_dir, nickname, domain,
|
|
announced_actor_nickname, announced_actor_domain,
|
|
None, block_federated):
|
|
print('Receive announce object blocked for actor: ' +
|
|
announced_actor_nickname + '@' + announced_actor_domain)
|
|
return False
|
|
|
|
# is this post in the inbox or outbox of the account?
|
|
post_filename = locate_post(base_dir, nickname, domain, announce_url)
|
|
if not post_filename:
|
|
if debug:
|
|
print('DEBUG: announce post not found in inbox or outbox')
|
|
print(announce_url)
|
|
return True
|
|
# add actor to the list of announcers for a post
|
|
actor_url = get_actor_from_post(message_json)
|
|
update_announce_collection(recent_posts_cache, base_dir, post_filename,
|
|
actor_url, nickname, domain, debug)
|
|
if debug:
|
|
print('DEBUG: Downloading announce post ' + actor_url +
|
|
' -> ' + announce_url)
|
|
domain_full = get_full_domain(domain, port)
|
|
|
|
# Generate html. This also downloads the announced post.
|
|
page_number = 1
|
|
show_published_date_only = False
|
|
show_individual_post_icons = True
|
|
manually_approve_followers = \
|
|
follower_approval_active(base_dir, nickname, domain)
|
|
not_dm = True
|
|
if debug:
|
|
print('Generating html for announce ' + message_json['id'])
|
|
timezone = get_account_timezone(base_dir, nickname, domain)
|
|
|
|
if mitm:
|
|
post_filename_mitm = \
|
|
post_filename.replace('.json', '') + '.mitm'
|
|
try:
|
|
with open(post_filename_mitm, 'w+',
|
|
encoding='utf-8') as fp_mitm:
|
|
fp_mitm.write('\n')
|
|
except OSError:
|
|
print('EX: unable to write mitm ' + post_filename_mitm)
|
|
minimize_all_images = False
|
|
if nickname in min_images_for_accounts:
|
|
minimize_all_images = True
|
|
|
|
show_vote_posts = True
|
|
show_vote_file = acct_dir(base_dir, nickname, domain) + '/.noVotes'
|
|
if os.path.isfile(show_vote_file):
|
|
show_vote_posts = False
|
|
|
|
announce_html = \
|
|
individual_post_as_html(signing_priv_key_pem, True,
|
|
recent_posts_cache, max_recent_posts,
|
|
translate, page_number, base_dir,
|
|
session, cached_webfingers, person_cache,
|
|
nickname, domain, port, message_json,
|
|
None, True, allow_deletion,
|
|
http_prefix, __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, not_dm,
|
|
show_individual_post_icons,
|
|
manually_approve_followers,
|
|
False, True, False, cw_lists,
|
|
lists_enabled, timezone, mitm,
|
|
bold_reading, dogwhistles,
|
|
minimize_all_images, None,
|
|
buy_sites, auto_cw_cache,
|
|
mitm_servers,
|
|
instance_software)
|
|
if not announce_html:
|
|
print('WARN: Unable to generate html for announce ' +
|
|
str(message_json))
|
|
else:
|
|
if debug:
|
|
announce_html2 = remove_eol(announce_html)
|
|
print('Generated announce html ' + announce_html2)
|
|
|
|
post_json_object = download_announce(session, base_dir,
|
|
http_prefix,
|
|
nickname, domain,
|
|
message_json,
|
|
__version__,
|
|
yt_replace_domain,
|
|
twitter_replacement_domain,
|
|
allow_local_network_access,
|
|
recent_posts_cache, debug,
|
|
system_language,
|
|
domain_full, person_cache,
|
|
signing_priv_key_pem,
|
|
blocked_cache, block_federated,
|
|
bold_reading,
|
|
show_vote_posts,
|
|
languages_understood,
|
|
mitm_servers)
|
|
# are annouced/boosted replies allowed?
|
|
announce_denied = False
|
|
if post_json_object:
|
|
if has_object_dict(post_json_object):
|
|
if post_json_object['object'].get('inReplyTo'):
|
|
account_dir = acct_dir(base_dir, nickname, domain)
|
|
no_reply_boosts_filename = account_dir + '/.noReplyBoosts'
|
|
if os.path.isfile(no_reply_boosts_filename):
|
|
post_json_object = None
|
|
announce_denied = True
|
|
|
|
if not post_json_object:
|
|
if not announce_denied:
|
|
print('WARN: unable to download announce: ' + str(message_json))
|
|
else:
|
|
print('REJECT: Announce/Boost of reply denied ' +
|
|
actor_url + ' 🔁 ' + announce_url)
|
|
not_in_onion = True
|
|
if onion_domain:
|
|
if onion_domain in announce_url:
|
|
not_in_onion = False
|
|
if domain not in announce_url and not_in_onion:
|
|
if os.path.isfile(post_filename):
|
|
# if the announce can't be downloaded then remove it
|
|
try:
|
|
os.remove(post_filename)
|
|
except OSError:
|
|
print('EX: _receive_announce unable to delete ' +
|
|
str(post_filename))
|
|
else:
|
|
if debug:
|
|
actor_url = get_actor_from_post(message_json)
|
|
print('DEBUG: Announce post downloaded for ' +
|
|
actor_url + ' -> ' + announce_url)
|
|
|
|
store_hash_tags(base_dir, nickname, domain,
|
|
http_prefix, domain_full,
|
|
post_json_object, translate, session)
|
|
# Try to obtain the actor for this person
|
|
# so that their avatar can be shown
|
|
lookup_actor = None
|
|
if post_json_object.get('attributedTo'):
|
|
attrib = get_attributed_to(post_json_object['attributedTo'])
|
|
if attrib:
|
|
if not contains_invalid_actor_url_chars(attrib):
|
|
lookup_actor = attrib
|
|
else:
|
|
if has_object_dict(post_json_object):
|
|
if post_json_object['object'].get('attributedTo'):
|
|
attrib_field = post_json_object['object']['attributedTo']
|
|
attrib = get_attributed_to(attrib_field)
|
|
if attrib:
|
|
if not contains_invalid_actor_url_chars(attrib):
|
|
lookup_actor = attrib
|
|
if lookup_actor:
|
|
lookup_actor = get_actor_from_post_id(lookup_actor)
|
|
if lookup_actor:
|
|
if is_recent_post(post_json_object, 3):
|
|
if not os.path.isfile(post_filename + '.tts'):
|
|
domain_full = get_full_domain(domain, port)
|
|
update_speaker(base_dir, http_prefix,
|
|
nickname, domain, domain_full,
|
|
post_json_object, person_cache,
|
|
translate, lookup_actor,
|
|
theme_name, system_language,
|
|
'inbox')
|
|
try:
|
|
with open(post_filename + '.tts', 'w+',
|
|
encoding='utf-8') as fp_tts:
|
|
fp_tts.write('\n')
|
|
except OSError:
|
|
print('EX: unable to write recent post ' +
|
|
post_filename)
|
|
|
|
if debug:
|
|
print('DEBUG: Obtaining actor for announce post ' +
|
|
lookup_actor)
|
|
for tries in range(6):
|
|
pub_key = \
|
|
get_person_pub_key(base_dir, session, lookup_actor,
|
|
person_cache, debug,
|
|
__version__, http_prefix,
|
|
domain, onion_domain,
|
|
i2p_domain,
|
|
signing_priv_key_pem,
|
|
mitm_servers)
|
|
if pub_key:
|
|
if not isinstance(pub_key, dict):
|
|
if debug:
|
|
print('DEBUG: ' +
|
|
'public key obtained for announce: ' +
|
|
lookup_actor)
|
|
else:
|
|
if debug:
|
|
print('DEBUG: http error code returned for ' +
|
|
'public key obtained for announce: ' +
|
|
lookup_actor + ' ' + str(pub_key))
|
|
break
|
|
|
|
if debug:
|
|
print('DEBUG: Retry ' + str(tries + 1) +
|
|
' obtaining actor for ' + lookup_actor)
|
|
time.sleep(5)
|
|
if debug:
|
|
print('DEBUG: announced/repeated post arrived in inbox')
|
|
return True
|
|
|
|
|
|
def receive_question_vote(server, base_dir: str, nickname: str, domain: str,
|
|
http_prefix: str, handle: str, debug: bool,
|
|
post_json_object: {}, recent_posts_cache: {},
|
|
session, session_onion, session_i2p,
|
|
onion_domain: str, i2p_domain: str, port: int,
|
|
federation_list: [], send_threads: [], post_log: [],
|
|
cached_webfingers: {}, person_cache: {},
|
|
signing_priv_key_pem: str,
|
|
max_recent_posts: int, translate: {},
|
|
allow_deletion: bool,
|
|
yt_replace_domain: str,
|
|
twitter_replacement_domain: str,
|
|
peertube_instances: [],
|
|
allow_local_network_access: bool,
|
|
theme_name: str, system_language: str,
|
|
max_like_count: int,
|
|
cw_lists: {}, lists_enabled: bool,
|
|
bold_reading: bool, dogwhistles: {},
|
|
min_images_for_accounts: [],
|
|
buy_sites: {},
|
|
sites_unavailable: [],
|
|
auto_cw_cache: {},
|
|
mitm_servers: [],
|
|
instance_software: {}) -> None:
|
|
"""Updates the votes on a Question/poll
|
|
"""
|
|
# if this is a reply to a question then update the votes
|
|
question_json, question_post_filename = \
|
|
question_update_votes(base_dir, nickname, domain,
|
|
post_json_object, debug)
|
|
if not question_json:
|
|
return
|
|
if not question_post_filename:
|
|
return
|
|
|
|
remove_post_from_cache(question_json, recent_posts_cache)
|
|
# ensure that the cached post is removed if it exists, so
|
|
# that it then will be recreated
|
|
cached_post_filename = \
|
|
get_cached_post_filename(base_dir, nickname, domain, question_json)
|
|
if cached_post_filename:
|
|
if os.path.isfile(cached_post_filename):
|
|
try:
|
|
os.remove(cached_post_filename)
|
|
except OSError:
|
|
print('EX: replytoQuestion unable to delete ' +
|
|
cached_post_filename)
|
|
|
|
page_number = 1
|
|
show_published_date_only = False
|
|
show_individual_post_icons = True
|
|
manually_approve_followers = \
|
|
follower_approval_active(base_dir, nickname, domain)
|
|
not_dm = not is_dm(question_json)
|
|
timezone = get_account_timezone(base_dir, nickname, domain)
|
|
mitm = False
|
|
if os.path.isfile(question_post_filename.replace('.json', '') + '.mitm'):
|
|
mitm = True
|
|
minimize_all_images = False
|
|
if nickname in min_images_for_accounts:
|
|
minimize_all_images = True
|
|
individual_post_as_html(signing_priv_key_pem, False,
|
|
recent_posts_cache, max_recent_posts,
|
|
translate, page_number, base_dir,
|
|
session, cached_webfingers, person_cache,
|
|
nickname, domain, port, question_json,
|
|
None, True, allow_deletion,
|
|
http_prefix, __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, not_dm,
|
|
show_individual_post_icons,
|
|
manually_approve_followers,
|
|
False, True, False, cw_lists,
|
|
lists_enabled, timezone, mitm,
|
|
bold_reading, dogwhistles,
|
|
minimize_all_images, None,
|
|
buy_sites, auto_cw_cache,
|
|
mitm_servers,
|
|
instance_software)
|
|
|
|
# add id to inbox index
|
|
inbox_update_index('inbox', base_dir, handle,
|
|
question_post_filename, debug)
|
|
|
|
# Is this a question created by this instance?
|
|
id_prefix = http_prefix + '://' + domain
|
|
if not question_json['object']['id'].startswith(id_prefix):
|
|
return
|
|
# if the votes on a question have changed then
|
|
# send out an update
|
|
question_json['type'] = 'Update'
|
|
shared_items_federated_domains: list[str] = []
|
|
shared_item_federation_tokens = {}
|
|
send_to_followers_thread(server, session, session_onion, session_i2p,
|
|
base_dir, nickname, domain,
|
|
onion_domain, i2p_domain, port,
|
|
http_prefix, federation_list,
|
|
send_threads, post_log,
|
|
cached_webfingers, person_cache,
|
|
post_json_object, debug, __version__,
|
|
shared_items_federated_domains,
|
|
shared_item_federation_tokens,
|
|
signing_priv_key_pem,
|
|
sites_unavailable, system_language,
|
|
mitm_servers)
|