mirror of https://gitlab.com/bashrc2/epicyon
684 lines
25 KiB
Python
684 lines
25 KiB
Python
__filename__ = "bookmarks.py"
|
|
__author__ = "Bob Mottram"
|
|
__license__ = "AGPL3+"
|
|
__version__ = "1.5.0"
|
|
__maintainer__ = "Bob Mottram"
|
|
__email__ = "bob@libreserver.org"
|
|
__status__ = "Production"
|
|
__module_group__ = "Timeline"
|
|
|
|
import os
|
|
from pprint import pprint
|
|
from webfinger import webfinger_handle
|
|
from auth import create_basic_auth_header
|
|
from utils import get_url_from_post
|
|
from utils import remove_domain_port
|
|
from utils import has_users_path
|
|
from utils import get_full_domain
|
|
from utils import remove_id_ending
|
|
from utils import remove_post_from_cache
|
|
from utils import url_permitted
|
|
from utils import get_nickname_from_actor
|
|
from utils import get_domain_from_actor
|
|
from utils import locate_post
|
|
from utils import get_cached_post_filename
|
|
from utils import load_json
|
|
from utils import save_json
|
|
from utils import has_object_dict
|
|
from utils import acct_dir
|
|
from utils import local_actor_url
|
|
from utils import has_actor
|
|
from utils import has_object_string_type
|
|
from utils import text_in_file
|
|
from utils import remove_eol
|
|
from utils import remove_html
|
|
from utils import get_actor_from_post
|
|
from posts import get_person_box
|
|
from session import post_json
|
|
|
|
|
|
def undo_bookmarks_collection_entry(recent_posts_cache: {},
|
|
base_dir: str, post_filename: str,
|
|
actor: str, domain: str,
|
|
debug: bool) -> None:
|
|
"""Undoes a bookmark for a particular actor
|
|
"""
|
|
post_json_object = load_json(post_filename)
|
|
if not post_json_object:
|
|
return
|
|
|
|
# remove any cached version of this post so that the
|
|
# bookmark icon is changed
|
|
nickname = get_nickname_from_actor(actor)
|
|
if not nickname:
|
|
return
|
|
cached_post_filename = \
|
|
get_cached_post_filename(base_dir, nickname,
|
|
domain, post_json_object)
|
|
if cached_post_filename:
|
|
if os.path.isfile(cached_post_filename):
|
|
try:
|
|
os.remove(cached_post_filename)
|
|
except OSError:
|
|
if debug:
|
|
print('EX: undo_bookmarks_collection_entry ' +
|
|
'unable to delete cached post file ' +
|
|
str(cached_post_filename))
|
|
remove_post_from_cache(post_json_object, recent_posts_cache)
|
|
|
|
# remove from the index
|
|
bookmarks_index_filename = \
|
|
acct_dir(base_dir, nickname, domain) + '/bookmarks.index'
|
|
if not os.path.isfile(bookmarks_index_filename):
|
|
return
|
|
if '/' in post_filename:
|
|
bookmark_index = post_filename.split('/')[-1].strip()
|
|
else:
|
|
bookmark_index = post_filename.strip()
|
|
bookmark_index = remove_eol(bookmark_index)
|
|
if not text_in_file(bookmark_index, bookmarks_index_filename):
|
|
return
|
|
index_str = ''
|
|
try:
|
|
with open(bookmarks_index_filename, 'r',
|
|
encoding='utf-8') as index_file:
|
|
index_str = index_file.read().replace(bookmark_index + '\n', '')
|
|
except OSError:
|
|
print('EX: unable to read ' + bookmarks_index_filename)
|
|
if index_str:
|
|
try:
|
|
with open(bookmarks_index_filename, 'w+',
|
|
encoding='utf-8') as bmi_file:
|
|
bmi_file.write(index_str)
|
|
except OSError:
|
|
print('EX: unable to write bookmarks index ' +
|
|
bookmarks_index_filename)
|
|
if not post_json_object.get('type'):
|
|
return
|
|
if post_json_object['type'] != 'Create':
|
|
return
|
|
if not has_object_dict(post_json_object):
|
|
if debug:
|
|
print('DEBUG: bookmarked post has no object ' +
|
|
str(post_json_object))
|
|
return
|
|
if not post_json_object['object'].get('bookmarks'):
|
|
return
|
|
if not isinstance(post_json_object['object']['bookmarks'], dict):
|
|
return
|
|
if not post_json_object['object']['bookmarks'].get('items'):
|
|
return
|
|
total_items = 0
|
|
if post_json_object['object']['bookmarks'].get('totalItems'):
|
|
total_items = post_json_object['object']['bookmarks']['totalItems']
|
|
item_found = False
|
|
for bookmark_item in post_json_object['object']['bookmarks']['items']:
|
|
if bookmark_item.get('actor'):
|
|
if bookmark_item['actor'] == actor:
|
|
if debug:
|
|
print('DEBUG: bookmark was removed for ' + actor)
|
|
bm_it = bookmark_item
|
|
post_json_object['object']['bookmarks']['items'].remove(bm_it)
|
|
item_found = True
|
|
break
|
|
|
|
if not item_found:
|
|
return
|
|
|
|
if total_items == 1:
|
|
if debug:
|
|
print('DEBUG: bookmarks was removed from post')
|
|
del post_json_object['object']['bookmarks']
|
|
else:
|
|
bm_it_len = len(post_json_object['object']['bookmarks']['items'])
|
|
post_json_object['object']['bookmarks']['totalItems'] = bm_it_len
|
|
save_json(post_json_object, post_filename)
|
|
|
|
|
|
def bookmarked_by_person(post_json_object: {},
|
|
nickname: str, domain: str) -> bool:
|
|
"""Returns True if the given post is bookmarked by the given person
|
|
"""
|
|
if _no_of_bookmarks(post_json_object) == 0:
|
|
return False
|
|
actor_match = domain + '/users/' + nickname
|
|
for item in post_json_object['object']['bookmarks']['items']:
|
|
if item['actor'].endswith(actor_match):
|
|
return True
|
|
return False
|
|
|
|
|
|
def _no_of_bookmarks(post_json_object: {}) -> int:
|
|
"""Returns the number of bookmarks ona given post
|
|
"""
|
|
if not has_object_dict(post_json_object):
|
|
return 0
|
|
if not post_json_object['object'].get('bookmarks'):
|
|
return 0
|
|
if not isinstance(post_json_object['object']['bookmarks'], dict):
|
|
return 0
|
|
if not post_json_object['object']['bookmarks'].get('items'):
|
|
post_json_object['object']['bookmarks']['items'] = []
|
|
post_json_object['object']['bookmarks']['totalItems'] = 0
|
|
return len(post_json_object['object']['bookmarks']['items'])
|
|
|
|
|
|
def update_bookmarks_collection(recent_posts_cache: {},
|
|
base_dir: str, post_filename: str,
|
|
object_url: str,
|
|
actor: str, domain: str, debug: bool) -> None:
|
|
"""Updates the bookmarks collection within a post
|
|
"""
|
|
post_json_object = load_json(post_filename)
|
|
if not post_json_object:
|
|
return
|
|
|
|
# remove any cached version of this post so that the
|
|
# bookmark icon is changed
|
|
nickname = get_nickname_from_actor(actor)
|
|
if not nickname:
|
|
return
|
|
cached_post_filename = \
|
|
get_cached_post_filename(base_dir, nickname,
|
|
domain, post_json_object)
|
|
if cached_post_filename:
|
|
if os.path.isfile(cached_post_filename):
|
|
try:
|
|
os.remove(cached_post_filename)
|
|
except OSError:
|
|
if debug:
|
|
print('EX: update_bookmarks_collection ' +
|
|
'unable to delete cached post ' +
|
|
str(cached_post_filename))
|
|
remove_post_from_cache(post_json_object, recent_posts_cache)
|
|
|
|
if not post_json_object.get('object'):
|
|
if debug:
|
|
print('DEBUG: no object in bookmarked post ' +
|
|
str(post_json_object))
|
|
return
|
|
if not object_url.endswith('/bookmarks'):
|
|
object_url = object_url + '/bookmarks'
|
|
# does this post have bookmarks on it from differenent actors?
|
|
if not post_json_object['object'].get('bookmarks'):
|
|
if debug:
|
|
print('DEBUG: Adding initial bookmarks to ' + object_url)
|
|
bookmarks_json = {
|
|
"@context": "https://www.w3.org/ns/activitystreams",
|
|
'id': object_url,
|
|
'type': 'Collection',
|
|
"totalItems": 1,
|
|
'items': [{
|
|
'type': 'Bookmark',
|
|
'actor': actor
|
|
}]
|
|
}
|
|
post_json_object['object']['bookmarks'] = bookmarks_json
|
|
else:
|
|
if not post_json_object['object']['bookmarks'].get('items'):
|
|
post_json_object['object']['bookmarks']['items'] = []
|
|
bm_items = post_json_object['object']['bookmarks']['items']
|
|
for bookmark_item in bm_items:
|
|
if bookmark_item.get('actor'):
|
|
if bookmark_item['actor'] == actor:
|
|
return
|
|
new_bookmark = {
|
|
'type': 'Bookmark',
|
|
'actor': actor
|
|
}
|
|
nbook = new_bookmark
|
|
bm_it = len(post_json_object['object']['bookmarks']['items'])
|
|
post_json_object['object']['bookmarks']['items'].append(nbook)
|
|
post_json_object['object']['bookmarks']['totalItems'] = bm_it
|
|
|
|
if debug:
|
|
print('DEBUG: saving post with bookmarks added')
|
|
pprint(post_json_object)
|
|
|
|
save_json(post_json_object, post_filename)
|
|
|
|
# prepend to the index
|
|
bookmarks_index_filename = \
|
|
acct_dir(base_dir, nickname, domain) + '/bookmarks.index'
|
|
bookmark_index = post_filename.split('/')[-1]
|
|
if os.path.isfile(bookmarks_index_filename):
|
|
if not text_in_file(bookmark_index, bookmarks_index_filename):
|
|
try:
|
|
with open(bookmarks_index_filename, 'r+',
|
|
encoding='utf-8') as bmi_file:
|
|
content = bmi_file.read()
|
|
if bookmark_index + '\n' not in content:
|
|
bmi_file.seek(0, 0)
|
|
bmi_file.write(bookmark_index + '\n' + content)
|
|
if debug:
|
|
print('DEBUG: bookmark added to index')
|
|
except OSError as ex:
|
|
print('WARN: Failed to write entry to bookmarks index ' +
|
|
bookmarks_index_filename + ' ' + str(ex))
|
|
else:
|
|
try:
|
|
with open(bookmarks_index_filename, 'w+',
|
|
encoding='utf-8') as bm_file:
|
|
bm_file.write(bookmark_index + '\n')
|
|
except OSError:
|
|
print('EX: unable to write bookmarks index ' +
|
|
bookmarks_index_filename)
|
|
|
|
|
|
def bookmark_post(recent_posts_cache: {},
|
|
base_dir: str, federation_list: [],
|
|
nickname: str, domain: str, port: int,
|
|
cc_list: [], http_prefix: str,
|
|
object_url: str, actor_bookmarked: str,
|
|
debug: bool) -> {}:
|
|
"""Creates a bookmark
|
|
actor is the person doing the bookmarking
|
|
'to' might be a specific person (actor) whose post was bookmarked
|
|
object is typically the url of the message which was bookmarked
|
|
"""
|
|
if not url_permitted(object_url, federation_list):
|
|
return None
|
|
|
|
full_domain = get_full_domain(domain, port)
|
|
|
|
new_bookmark_json = {
|
|
"@context": "https://www.w3.org/ns/activitystreams",
|
|
'type': 'Bookmark',
|
|
'actor': local_actor_url(http_prefix, nickname, full_domain),
|
|
'object': object_url
|
|
}
|
|
if cc_list:
|
|
if len(cc_list) > 0:
|
|
new_bookmark_json['cc'] = cc_list
|
|
|
|
# Extract the domain and nickname from a statuses link
|
|
bookmarked_post_nickname = None
|
|
if actor_bookmarked:
|
|
ac_bm = actor_bookmarked
|
|
bookmarked_post_nickname = get_nickname_from_actor(ac_bm)
|
|
_, _ = get_domain_from_actor(ac_bm)
|
|
else:
|
|
if has_users_path(object_url):
|
|
ourl = object_url
|
|
bookmarked_post_nickname = get_nickname_from_actor(ourl)
|
|
_, _ = get_domain_from_actor(ourl)
|
|
|
|
if bookmarked_post_nickname:
|
|
post_filename = locate_post(base_dir, nickname, domain, object_url)
|
|
if not post_filename:
|
|
print('DEBUG: bookmark base_dir: ' + base_dir)
|
|
print('DEBUG: bookmark nickname: ' + nickname)
|
|
print('DEBUG: bookmark domain: ' + domain)
|
|
print('DEBUG: bookmark object_url: ' + object_url)
|
|
return None
|
|
|
|
update_bookmarks_collection(recent_posts_cache,
|
|
base_dir, post_filename, object_url,
|
|
new_bookmark_json['actor'], domain, debug)
|
|
|
|
return new_bookmark_json
|
|
|
|
|
|
def undo_bookmark_post(recent_posts_cache: {},
|
|
base_dir: str, federation_list: [],
|
|
nickname: str, domain: str, port: int,
|
|
cc_list: [], http_prefix: str,
|
|
object_url: str, actor_bookmarked: str,
|
|
debug: bool) -> {}:
|
|
"""Removes a bookmark
|
|
actor is the person doing the bookmarking
|
|
'to' might be a specific person (actor) whose post was bookmarked
|
|
object is typically the url of the message which was bookmarked
|
|
"""
|
|
if not url_permitted(object_url, federation_list):
|
|
return None
|
|
|
|
full_domain = get_full_domain(domain, port)
|
|
|
|
new_undo_bookmark_json = {
|
|
"@context": "https://www.w3.org/ns/activitystreams",
|
|
'type': 'Undo',
|
|
'actor': local_actor_url(http_prefix, nickname, full_domain),
|
|
'object': {
|
|
'type': 'Bookmark',
|
|
'actor': local_actor_url(http_prefix, nickname, full_domain),
|
|
'object': object_url
|
|
}
|
|
}
|
|
if cc_list:
|
|
if len(cc_list) > 0:
|
|
new_undo_bookmark_json['cc'] = cc_list
|
|
new_undo_bookmark_json['object']['cc'] = cc_list
|
|
|
|
# Extract the domain and nickname from a statuses link
|
|
bookmarked_post_nickname = None
|
|
if actor_bookmarked:
|
|
ac_bm = actor_bookmarked
|
|
bookmarked_post_nickname = get_nickname_from_actor(ac_bm)
|
|
_, _ = get_domain_from_actor(ac_bm)
|
|
else:
|
|
if has_users_path(object_url):
|
|
ourl = object_url
|
|
bookmarked_post_nickname = get_nickname_from_actor(ourl)
|
|
_, _ = get_domain_from_actor(ourl)
|
|
|
|
if bookmarked_post_nickname:
|
|
post_filename = locate_post(base_dir, nickname, domain, object_url)
|
|
if not post_filename:
|
|
return None
|
|
|
|
undo_bookmarks_collection_entry(recent_posts_cache,
|
|
base_dir, post_filename,
|
|
new_undo_bookmark_json['actor'],
|
|
domain, debug)
|
|
else:
|
|
return None
|
|
|
|
return new_undo_bookmark_json
|
|
|
|
|
|
def send_bookmark_via_server(base_dir: str, session,
|
|
nickname: str, password: str,
|
|
domain: str, from_port: int,
|
|
http_prefix: str, bookmark_url: str,
|
|
cached_webfingers: {}, person_cache: {},
|
|
debug: bool, project_version: str,
|
|
signing_priv_key_pem: str,
|
|
system_language: str) -> {}:
|
|
"""Creates a bookmark via c2s
|
|
"""
|
|
if not session:
|
|
print('WARN: No session for send_bookmark_via_server')
|
|
return 6
|
|
|
|
domain_full = get_full_domain(domain, from_port)
|
|
|
|
actor = local_actor_url(http_prefix, nickname, domain_full)
|
|
|
|
new_bookmark_json = {
|
|
"@context": "https://www.w3.org/ns/activitystreams",
|
|
"type": "Add",
|
|
"actor": actor,
|
|
"to": [actor],
|
|
"object": {
|
|
"type": "Document",
|
|
"url": bookmark_url,
|
|
"to": [actor]
|
|
},
|
|
"target": actor + "/tlbookmarks"
|
|
}
|
|
|
|
handle = http_prefix + '://' + domain_full + '/@' + nickname
|
|
|
|
# lookup the inbox for the To handle
|
|
wf_request = \
|
|
webfinger_handle(session, handle, http_prefix,
|
|
cached_webfingers,
|
|
domain, project_version, debug, False,
|
|
signing_priv_key_pem)
|
|
if not wf_request:
|
|
if debug:
|
|
print('DEBUG: bookmark webfinger failed for ' + handle)
|
|
return 1
|
|
if not isinstance(wf_request, dict):
|
|
print('WARN: bookmark webfinger for ' + handle +
|
|
' did not return a dict. ' + str(wf_request))
|
|
return 1
|
|
|
|
post_to_box = 'outbox'
|
|
|
|
# get the actor inbox for the To handle
|
|
origin_domain = domain
|
|
(inbox_url, _, _, from_person_id, _, _,
|
|
_, _) = get_person_box(signing_priv_key_pem,
|
|
origin_domain,
|
|
base_dir, session, wf_request,
|
|
person_cache,
|
|
project_version, http_prefix,
|
|
nickname, domain,
|
|
post_to_box, 58391,
|
|
system_language)
|
|
|
|
if not inbox_url:
|
|
if debug:
|
|
print('DEBUG: bookmark no ' + post_to_box +
|
|
' was found for ' + handle)
|
|
return 3
|
|
if not from_person_id:
|
|
if debug:
|
|
print('DEBUG: bookmark no actor was found for ' + handle)
|
|
return 4
|
|
|
|
auth_header = create_basic_auth_header(nickname, password)
|
|
|
|
headers = {
|
|
'host': domain,
|
|
'Content-type': 'application/json',
|
|
'Authorization': auth_header
|
|
}
|
|
post_result = post_json(http_prefix, domain_full,
|
|
session, new_bookmark_json, [], inbox_url,
|
|
headers, 3, True)
|
|
if not post_result:
|
|
if debug:
|
|
print('WARN: POST bookmark failed for c2s to ' + inbox_url)
|
|
return 5
|
|
|
|
if debug:
|
|
print('DEBUG: c2s POST bookmark success')
|
|
|
|
return new_bookmark_json
|
|
|
|
|
|
def send_undo_bookmark_via_server(base_dir: str, session,
|
|
nickname: str, password: str,
|
|
domain: str, from_port: int,
|
|
http_prefix: str, bookmark_url: str,
|
|
cached_webfingers: {}, person_cache: {},
|
|
debug: bool, project_version: str,
|
|
signing_priv_key_pem: str,
|
|
system_language: str) -> {}:
|
|
"""Removes a bookmark via c2s
|
|
"""
|
|
if not session:
|
|
print('WARN: No session for send_undo_bookmark_via_server')
|
|
return 6
|
|
|
|
domain_full = get_full_domain(domain, from_port)
|
|
|
|
actor = local_actor_url(http_prefix, nickname, domain_full)
|
|
|
|
new_bookmark_json = {
|
|
"@context": "https://www.w3.org/ns/activitystreams",
|
|
"type": "Remove",
|
|
"actor": actor,
|
|
"to": [actor],
|
|
"object": {
|
|
"type": "Document",
|
|
"url": bookmark_url,
|
|
"to": [actor]
|
|
},
|
|
"target": actor + "/tlbookmarks"
|
|
}
|
|
|
|
handle = http_prefix + '://' + domain_full + '/@' + nickname
|
|
|
|
# lookup the inbox for the To handle
|
|
wf_request = \
|
|
webfinger_handle(session, handle, http_prefix,
|
|
cached_webfingers,
|
|
domain, project_version, debug, False,
|
|
signing_priv_key_pem)
|
|
if not wf_request:
|
|
if debug:
|
|
print('DEBUG: unbookmark webfinger failed for ' + handle)
|
|
return 1
|
|
if not isinstance(wf_request, dict):
|
|
print('WARN: unbookmark webfinger for ' + handle +
|
|
' did not return a dict. ' + str(wf_request))
|
|
return 1
|
|
|
|
post_to_box = 'outbox'
|
|
|
|
# get the actor inbox for the To handle
|
|
origin_domain = domain
|
|
(inbox_url, _, _, from_person_id, _, _,
|
|
_, _) = get_person_box(signing_priv_key_pem,
|
|
origin_domain,
|
|
base_dir, session, wf_request,
|
|
person_cache,
|
|
project_version, http_prefix,
|
|
nickname, domain,
|
|
post_to_box, 52594,
|
|
system_language)
|
|
|
|
if not inbox_url:
|
|
if debug:
|
|
print('DEBUG: unbookmark no ' + post_to_box +
|
|
' was found for ' + handle)
|
|
return 3
|
|
if not from_person_id:
|
|
if debug:
|
|
print('DEBUG: unbookmark no actor was found for ' + handle)
|
|
return 4
|
|
|
|
auth_header = create_basic_auth_header(nickname, password)
|
|
|
|
headers = {
|
|
'host': domain,
|
|
'Content-type': 'application/json',
|
|
'Authorization': auth_header
|
|
}
|
|
post_result = post_json(http_prefix, domain_full,
|
|
session, new_bookmark_json, [], inbox_url,
|
|
headers, 3, True)
|
|
if not post_result:
|
|
if debug:
|
|
print('WARN: POST unbookmark failed for c2s to ' + inbox_url)
|
|
return 5
|
|
|
|
if debug:
|
|
print('DEBUG: c2s POST unbookmark success')
|
|
|
|
return new_bookmark_json
|
|
|
|
|
|
def outbox_bookmark(recent_posts_cache: {},
|
|
base_dir: str, http_prefix: str,
|
|
nickname: str, domain: str, port: int,
|
|
message_json: {}, debug: bool) -> None:
|
|
""" When a bookmark request is received by the outbox from c2s
|
|
"""
|
|
if not message_json.get('type'):
|
|
return
|
|
if message_json['type'] != 'Add':
|
|
return
|
|
if not has_actor(message_json, debug):
|
|
return
|
|
if not message_json.get('target'):
|
|
if debug:
|
|
print('DEBUG: no target in bookmark Add')
|
|
return
|
|
if not has_object_string_type(message_json, debug):
|
|
return
|
|
if not isinstance(message_json['target'], str):
|
|
if debug:
|
|
print('DEBUG: bookmark Add target is not string')
|
|
return
|
|
domain_full = get_full_domain(domain, port)
|
|
expected_target = \
|
|
http_prefix + '://' + domain_full + \
|
|
'/users/' + nickname + '/tlbookmarks'
|
|
if message_json['target'] != expected_target:
|
|
if debug:
|
|
print('DEBUG: bookmark Add target invalid ' +
|
|
message_json['target'])
|
|
return
|
|
if message_json['object']['type'] != 'Document':
|
|
if debug:
|
|
print('DEBUG: bookmark Add type is not Document')
|
|
return
|
|
if not message_json['object'].get('url'):
|
|
if debug:
|
|
print('DEBUG: bookmark Add missing url')
|
|
return
|
|
if debug:
|
|
print('DEBUG: c2s bookmark Add request arrived in outbox')
|
|
|
|
url_str = get_url_from_post(message_json['object']['url'])
|
|
message_url = remove_id_ending(url_str)
|
|
message_url = remove_html(message_url)
|
|
domain = remove_domain_port(domain)
|
|
post_filename = locate_post(base_dir, nickname, domain, message_url)
|
|
if not post_filename:
|
|
if debug:
|
|
print('DEBUG: c2s like post not found in inbox or outbox')
|
|
print(message_url)
|
|
return True
|
|
actor_url = get_actor_from_post(message_json)
|
|
update_bookmarks_collection(recent_posts_cache,
|
|
base_dir, post_filename, message_url,
|
|
actor_url, domain, debug)
|
|
if debug:
|
|
print('DEBUG: post bookmarked via c2s - ' + post_filename)
|
|
|
|
|
|
def outbox_undo_bookmark(recent_posts_cache: {},
|
|
base_dir: str, http_prefix: str,
|
|
nickname: str, domain: str, port: int,
|
|
message_json: {}, debug: bool) -> None:
|
|
""" When an undo bookmark request is received by the outbox from c2s
|
|
"""
|
|
if not message_json.get('type'):
|
|
return
|
|
if message_json['type'] != 'Remove':
|
|
return
|
|
if not has_actor(message_json, debug):
|
|
return
|
|
if not message_json.get('target'):
|
|
if debug:
|
|
print('DEBUG: no target in unbookmark Remove')
|
|
return
|
|
if not has_object_string_type(message_json, debug):
|
|
return
|
|
if not isinstance(message_json['target'], str):
|
|
if debug:
|
|
print('DEBUG: unbookmark Remove target is not string')
|
|
return
|
|
domain_full = get_full_domain(domain, port)
|
|
expected_target = \
|
|
http_prefix + '://' + domain_full + \
|
|
'/users/' + nickname + '/tlbookmarks'
|
|
if message_json['target'] != expected_target:
|
|
if debug:
|
|
print('DEBUG: unbookmark Remove target invalid ' +
|
|
message_json['target'])
|
|
return
|
|
if message_json['object']['type'] != 'Document':
|
|
if debug:
|
|
print('DEBUG: unbookmark Remove type is not Document')
|
|
return
|
|
if not message_json['object'].get('url'):
|
|
if debug:
|
|
print('DEBUG: unbookmark Remove missing url')
|
|
return
|
|
if debug:
|
|
print('DEBUG: c2s unbookmark Remove request arrived in outbox')
|
|
|
|
url_str = get_url_from_post(message_json['object']['url'])
|
|
message_url = remove_id_ending(url_str)
|
|
message_url = remove_html(message_url)
|
|
domain = remove_domain_port(domain)
|
|
post_filename = locate_post(base_dir, nickname, domain, message_url)
|
|
if not post_filename:
|
|
if debug:
|
|
print('DEBUG: c2s unbookmark post not found in inbox or outbox')
|
|
print(message_url)
|
|
return True
|
|
actor_url = get_actor_from_post(message_json)
|
|
update_bookmarks_collection(recent_posts_cache,
|
|
base_dir, post_filename, message_url,
|
|
actor_url, domain, debug)
|
|
if debug:
|
|
print('DEBUG: post unbookmarked via c2s - ' + post_filename)
|