25180b19-02bd-4eba-8016-492bb4c0996c

Build # 25180b19-02bd-4eba-8016-492bb4c0996c

Build Type

push

circle-ci

Committed by Ryan Barrett

Commit Message

<a href="https://github.com/snarfed/bridgy/commit/3329cd03d">browser endpoints: update tests for </a><a class="double-link" href="https://github.com/snarfed/bridgy/commit/3346c7e6d">3346c7e6d</a>

Run Details

3594 of 3876 relevant lines covered (92.72%)

0.93 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.43

/browser.py

"""Browser extension request handlers.
"""
import copy
from datetime import timedelta
import logging
from operator import itemgetter

from google.cloud import ndb
from granary import instagram as gr_instagram
from granary import microformats2
from granary import source as gr_source
from oauth_dropins import indieauth
from oauth_dropins.webutil.util import json_dumps, json_loads
import webapp2

import models
from models import Activity, Domain, Source, MAX_AUTHOR_URLS
import util

JSON_CONTENT_TYPE = 'application/json'


def merge_by_id(existing, updates):
  """Merges two lists of AS1 objects by id.

  Overwrites the objects in the existing list with objects in the updates list
  with the same id. Requires all objects to have ids.

  Args:
    existing: sequence of AS1 dicts
    updates: sequence of AS1 dicts

  Returns: merged list of AS1 dicts
  """
  objs = {o['id']: o for o in existing}
  objs.update({o['id']: o for o in updates})
  return sorted(objs.values(), key=itemgetter('id'))


class BrowserSource(Source):
  """A source whose data is provided by the browser extension.

  Current subclasses are Instagram and Facebook.
  """
  CAN_LISTEN = True
  CAN_PUBLISH = False
  AUTO_POLL = False
  SLOW_POLL = FAST_POLL = timedelta(0)

  # set by subclasses
  GR_CLASS = None
  OAUTH_START_HANDLER = None
  gr_source = None

  domain_tokens = ndb.StringProperty(repeated=True)

  @classmethod
  def key_id_from_actor(cls, actor):
    """Returns the key id for this entity from a given AS1 actor.

    To be implemented by subclasses.

    Args:
      actor: dict AS1 actor

    Returns: str, key id to use for the corresponding datastore entity
    """
    raise NotImplementedError()

  @classmethod
  def new(cls, handler, auth_entity=None, actor=None, **kwargs):
    """Creates and returns an entity based on an AS1 actor.

    Args:
      handler: the current :class:`webapp2.RequestHandler`
      auth_entity: unused
      actor: dict AS1 actor
    """
    assert not auth_entity
    assert actor

    if not kwargs.get('features'):
      kwargs['features'] = ['listen']

    src = cls(id=cls.key_id_from_actor(actor),
              name=actor.get('displayName'),
              picture=actor.get('image', {}).get('url'),
              **kwargs)
    src.domain_urls, src.domains = src._urls_and_domains(None, None, actor=actor)
    return src

  @classmethod
  def button_html(cls, feature, **kwargs):
    return cls.OAUTH_START_HANDLER.button_html(
      '/about#browser-extension',
      form_method='get',
      image_prefix='/oauth_dropins/static/')

  def get_activities_response(self, *args, **kwargs):
    """Uses Activity entities stored in the datastore."""
    activities = []

    activity_id = kwargs.get('activity_id')
    if activity_id:
      activity = Activity.get_by_id(self.gr_source.tag_uri(activity_id))
      if activity:
        activities = [activity]
    else:
      activities = Activity.query(Activity.source == self.key)\
                           .order(-Activity.updated).fetch(50)

    return self.gr_source.make_activities_base_response(
      [json_loads(a.activity_json) for a in activities])

  def get_comment(self, comment_id,  activity=None, **kwargs):
    """Uses the activity passed in the activity kwarg."""
    if activity:
      for reply in activity.get('object', {}).get('replies', {}).get('items', []):
        parsed = util.parse_tag_uri(reply.get('id', ''))
        if parsed and parsed[1] == comment_id:
          return reply

  def get_like(self, activity_user_id, activity_id, like_user_id, activity=None,
               **kwargs):
    """Uses the activity passed in the activity kwarg."""
    if activity:
      for tag in activity.get('object', {}).get('tags', []):
        if tag.get('verb') == 'like':
          parsed = util.parse_tag_uri(tag.get('author', {}).get('id', ''))
          if parsed and parsed[1] == like_user_id:
            return tag


class BrowserHandler(util.Handler):
  """Base class for requests from the browser extension."""
  def output(self, obj):
    self.response.headers['Content-Type'] = JSON_CONTENT_TYPE
    self.response.write(json_dumps(obj, indent=2))

  def source_class(self):
    return models.sources.get(self.request.path.strip('/').split('/')[0])

  def gr_source(self):
    return self.source_class().gr_source

  def check_token_for_actor(self, actor):
    """Checks that the given actor is public and matches the request's token.

    Raises: :class:`HTTPException` with HTTP 400
    """
    if not actor:
      self.abort(400, f'Missing actor!')

    if not gr_source.Source.is_public(actor):
      self.abort(400, f'Your {self.gr_source().NAME} account is private. Bridgy only supports public accounts.')

    token = util.get_required_param(self, 'token')
    src_cls = self.source_class()

    domains = set(util.domain_from_link(u) for u in microformats2.object_urls(actor))

    # TEMPORARY since we've lost the profile's domains in Activity contents for
    # Instagram for some reason. :/
    url = actor.get('url')
    if url:
      logging.info(f'Looking up source by URL {url}')
      source = src_cls.query(src_cls.url == url).get()
      if source:
        domains.update(source.domains)

    domains.discard(src_cls.GR_CLASS.DOMAIN)

    logging.info(f'Checking token against domains {domains}')
    for domain in ndb.get_multi(ndb.Key(Domain, d) for d in domains):
      if domain and token in domain.tokens:
        return

    self.abort(403, f'Token {token} is not authorized for any of: {domains}')

  def auth(self, actor=None, check_token=True):
    """Loads the source and (optionally) token and checks that they're valid.

    Expects token in the `token` query param, source in `key` or `username` with
    fallback to `actor` for older browser extension versions that didn't send
    them.

    Args:
      actor: dict, optional, AS1 actor
      check_token: boolean, optional, whether to load and check the token too

    Raises: :class:`HTTPException` with HTTP 400 if the token or source are
      missing or invalid

    Returns: BrowserSource or None
    """
    # Load source
    key = self.request.get('key')
    username = self.request.get('username')
    if not username and actor:
      username = actor.get('username')

    source = None
    if key:
      source = util.load_source(self, param='key')
    elif username:
      source = self.source_class().get_by_id(username)
    else:
      self.abort(400, 'No key or username query param and no scraped actor found')

    if not source:
      self.abort(404, f'No account found for {self.gr_source().NAME} user {key or username}')

    # Load and check token
    if not check_token:
      return source

    token = util.get_required_param(self, 'token')
    for domain in Domain.query(Domain.tokens == token):
      if domain.key.id() in source.domains:
        return source

    self.abort(403, f'Token {token} is not authorized for any of: {source.domains}')


class HomepageHandler(BrowserHandler):
  """Parses a silo home page and returns the logged in user's username.

  Request body is https://www.instagram.com/ HTML for a logged in user.
  """
  def post(self):
    gr_src = self.gr_source()
    _, actor = gr_src.scraped_to_activities(self.request.text)
    logging.info(f'Got actor: {actor}')

    if actor:
      # TODO?
      username = actor.get('username')
      if username:
        logging.info(f"Returning {username}")
        return self.output(username)

    self.abort(400, f"Couldn't determine logged in {gr_src.NAME} user or username")


class FeedHandler(BrowserHandler):
  """Parses a silo feed page and returns the posts.

  Request body is HTML from a silo profile with posts, eg
  https://www.instagram.com/name/ , for a logged in user.

  Response body is the JSON list of translated ActivityStreams activities.
  """
  def post(self):
    activities, _ = self.scrape()
    self.output(activities)

  def scrape(self):
    activities, actor = self.gr_source().scraped_to_activities(self.request.text)
    ids = ' '.join(a['id'] for a in activities)
    logging.info(f"Returning activities: {ids}")
    return activities, actor


class ProfileHandler(FeedHandler):
  """Parses a silo profile page and creates or updates its Bridgy user.

  Request body is HTML from an IG profile, eg https://www.instagram.com/name/ ,
  for a logged in user.

  Response body is the JSON string URL-safe key of the Bridgy source entity.
  """
  def post(self):
    _, actor = self.scrape()
    if not actor:
      actor = self.gr_source().scraped_to_actor(self.request.text)
    self.check_token_for_actor(actor)

    # create/update the Bridgy account
    source = self.source_class().create_new(self, actor=actor)
    self.output(source.key.urlsafe().decode())


class PostHandler(BrowserHandler):
  """Parses a silo post's HTML and creates or updates an Activity.

  Request body is HTML from a silo post, eg https://www.instagram.com/p/ABC123/

  Response body is the translated ActivityStreams activity JSON.
  """
  def post(self):
    gr_src = self.gr_source()
    new_activity, actor = gr_src.scraped_to_activity(self.request.text)
    if not new_activity:
      self.abort(400, f'No {gr_src.NAME} post found in HTML')

    source = self.auth(actor=actor)

    @ndb.transactional()
    def update_activity():
      id = new_activity.get('id')
      if not id:
        self.abort(400, 'Scraped post missing id')
      activity = Activity.get_by_id(id)

      if activity:
        # we already have this activity! merge in any new comments.
        merged_activity = copy.deepcopy(new_activity)
        existing_activity = json_loads(activity.activity_json)
        # TODO: extract out merging replies
        replies = merged_activity.setdefault('object', {}).setdefault('replies', {})
        gr_source.merge_by_id(replies, 'items',
          existing_activity.get('object', {}).get('replies', {}).get('items', []))
        replies['totalItems'] = len(replies.get('items', []))
        # TODO: merge tags too
        activity.activity_json = json_dumps(merged_activity)
      else:
        activity = Activity(id=id, source=source.key,
                            activity_json=json_dumps(new_activity))

      # store and return the activity
      activity.put()
      logging.info(f"Stored activity {id}")
      self.output(new_activity)

    update_activity()


class ReactionsHandler(BrowserHandler):
  """Parses reactions/likes from silo HTML and adds them to an existing Activity.

  Requires the request parameter `id` with the silo post's id (not shortcode!).

  Response body is the translated ActivityStreams JSON for the reactions.
  """
  def post(self, *args):
    gr_src = self.gr_source()
    id = util.get_required_param(self, 'id')

    # validate request
    parsed_id = util.parse_tag_uri(id)
    if not parsed_id:
      self.abort(400, f'Expected id to be tag URI; got {id}')

    activity = Activity.get_by_id(id)
    if not activity:
      self.abort(404, f'No {gr_src.NAME} post found for id {id}')

    activity_data = json_loads(activity.activity_json)
    actor = activity_data['object'].get('author') or activity_data.get('actor')
    self.check_token_for_actor(actor)

    # convert new reactions to AS, merge into existing activity
    new_reactions = gr_src.merge_scraped_reactions(self.request.text, activity_data)
    activity.activity_json = json_dumps(activity_data)
    activity.put()

    reaction_ids = ' '.join(r['id'] for r in new_reactions)
    logging.info(f"Stored reactions for activity {id}: {reaction_ids}")
    self.output(new_reactions)


class PollHandler(BrowserHandler):
  """Triggers a poll for a browser-based account."""
  def post(self):
    source = self.auth(check_token=False)
    util.add_poll_task(source)
    self.output('OK')


class TokenDomainsHandler(BrowserHandler):
  """Returns the domains that a token is registered for."""
  def post(self):
    token = util.get_required_param(self, 'token')

    domains = [d.key.id() for d in Domain.query(Domain.tokens == token)]
    if not domains:
      self.abort(404, f'No registered domains for token {token}')

    self.output(domains)


def routes(source_cls):
  """Returns browser extension webapp2 routes for a given source class.

  ...specifically, with the source's short name as the routes' URL prefix.
  """
  return [
    (f'/{source_cls.SHORT_NAME}/browser/homepage', HomepageHandler),
    (f'/{source_cls.SHORT_NAME}/browser/profile', ProfileHandler),
    (f'/{source_cls.SHORT_NAME}/browser/feed', FeedHandler),
    (f'/{source_cls.SHORT_NAME}/browser/post', PostHandler),
    (f'/{source_cls.SHORT_NAME}/browser/(likes|reactions)', ReactionsHandler),
    (f'/{source_cls.SHORT_NAME}/browser/poll', PollHandler),
    (f'/{source_cls.SHORT_NAME}/browser/token-domains', TokenDomainsHandler),
  ]

1	"""Browser extension request handlers.
2	"""
3	import copy	1✔
4	from datetime import timedelta	1✔
5	import logging	1✔
6	from operator import itemgetter	1✔
7
8	from google.cloud import ndb	1✔
9	from granary import instagram as gr_instagram	1✔
10	from granary import microformats2	1✔
11	from granary import source as gr_source	1✔
12	from oauth_dropins import indieauth	1✔
13	from oauth_dropins.webutil.util import json_dumps, json_loads	1✔
14	import webapp2	1✔
15
16	import models	1✔
17	from models import Activity, Domain, Source, MAX_AUTHOR_URLS	1✔
18	import util	1✔
19
20	JSON_CONTENT_TYPE = 'application/json'	1✔
21
22
23	def merge_by_id(existing, updates):	1✔
24	"""Merges two lists of AS1 objects by id.
25
26	Overwrites the objects in the existing list with objects in the updates list
27	with the same id. Requires all objects to have ids.
28
29	Args:
30	existing: sequence of AS1 dicts
31	updates: sequence of AS1 dicts
32
33	Returns: merged list of AS1 dicts
34	"""
35	objs = {o['id']: o for o in existing}	×
36	objs.update({o['id']: o for o in updates})	×
37	return sorted(objs.values(), key=itemgetter('id'))	×
38
39
40	class BrowserSource(Source):	1✔
41	"""A source whose data is provided by the browser extension.
42
43	Current subclasses are Instagram and Facebook.
44	"""
45	CAN_LISTEN = True	1✔
46	CAN_PUBLISH = False	1✔
47	AUTO_POLL = False	1✔
48	SLOW_POLL = FAST_POLL = timedelta(0)	1✔
49
50	# set by subclasses
51	GR_CLASS = None	1✔
52	OAUTH_START_HANDLER = None	1✔
53	gr_source = None	1✔
54
55	domain_tokens = ndb.StringProperty(repeated=True)	1✔
56
57	@classmethod	1✔
58	def key_id_from_actor(cls, actor):
59	"""Returns the key id for this entity from a given AS1 actor.
60
61	To be implemented by subclasses.
62
63	Args:
64	actor: dict AS1 actor
65
66	Returns: str, key id to use for the corresponding datastore entity
67	"""
68	raise NotImplementedError()	×
69
70	@classmethod	1✔
71	def new(cls, handler, auth_entity=None, actor=None, **kwargs):	1✔
72	"""Creates and returns an entity based on an AS1 actor.
73
74	Args:
75	handler: the current :class:`webapp2.RequestHandler`
76	auth_entity: unused
77	actor: dict AS1 actor
78	"""
79	assert not auth_entity	1✔
80	assert actor	1✔
81
82	if not kwargs.get('features'):	1✔
83	kwargs['features'] = ['listen']	1✔
84
85	src = cls(id=cls.key_id_from_actor(actor),	1✔
86	name=actor.get('displayName'),
87	picture=actor.get('image', {}).get('url'),
88	**kwargs)
89	src.domain_urls, src.domains = src._urls_and_domains(None, None, actor=actor)	1✔
90	return src	1✔
91
92	@classmethod	1✔
93	def button_html(cls, feature, **kwargs):
94	return cls.OAUTH_START_HANDLER.button_html(	1✔
95	'/about#browser-extension',
96	form_method='get',
97	image_prefix='/oauth_dropins/static/')
98
99	def get_activities_response(self, args, *kwargs):	1✔
100	"""Uses Activity entities stored in the datastore."""
101	activities = []	1✔
102
103	activity_id = kwargs.get('activity_id')	1✔
104	if activity_id:	1✔
105	activity = Activity.get_by_id(self.gr_source.tag_uri(activity_id))	1✔
106	if activity:	1✔
107	activities = [activity]	1✔
108	else:
109	activities = Activity.query(Activity.source == self.key)\	1✔
110	.order(-Activity.updated).fetch(50)
111
112	return self.gr_source.make_activities_base_response(	1✔
113	[json_loads(a.activity_json) for a in activities])
114
115	def get_comment(self, comment_id, activity=None, **kwargs):	1✔
116	"""Uses the activity passed in the activity kwarg."""
117	if activity:	1✔
118	for reply in activity.get('object', {}).get('replies', {}).get('items', []):	1✔
119	parsed = util.parse_tag_uri(reply.get('id', ''))	1✔
120	if parsed and parsed[1] == comment_id:	1✔
121	return reply	1✔
122
123	def get_like(self, activity_user_id, activity_id, like_user_id, activity=None,	1✔
124	**kwargs):
125	"""Uses the activity passed in the activity kwarg."""
126	if activity:	1✔
127	for tag in activity.get('object', {}).get('tags', []):	1✔
128	if tag.get('verb') == 'like':	1✔
129	parsed = util.parse_tag_uri(tag.get('author', {}).get('id', ''))	1✔
130	if parsed and parsed[1] == like_user_id:	1✔
131	return tag	1✔
132
133
134	class BrowserHandler(util.Handler):	1✔
135	"""Base class for requests from the browser extension."""
136	def output(self, obj):	1✔
137	self.response.headers['Content-Type'] = JSON_CONTENT_TYPE	1✔
138	self.response.write(json_dumps(obj, indent=2))	1✔
139
140	def source_class(self):	1✔
141	return models.sources.get(self.request.path.strip('/').split('/')[0])	1✔
142
143	def gr_source(self):	1✔
144	return self.source_class().gr_source	1✔
145
146	def check_token_for_actor(self, actor):	1✔
147	"""Checks that the given actor is public and matches the request's token.
148
149	Raises: :class:`HTTPException` with HTTP 400
150	"""
151	if not actor:	1✔
152	self.abort(400, f'Missing actor!')	1✔
153
154	if not gr_source.Source.is_public(actor):	1✔
155	self.abort(400, f'Your {self.gr_source().NAME} account is private. Bridgy only supports public accounts.')	1✔
156
157	token = util.get_required_param(self, 'token')	1✔
158	src_cls = self.source_class()	1✔
159
160	domains = set(util.domain_from_link(u) for u in microformats2.object_urls(actor))	1✔
161
162	# TEMPORARY since we've lost the profile's domains in Activity contents for
163	# Instagram for some reason. :/
164	url = actor.get('url')	1✔
165	if url:	1✔
166	logging.info(f'Looking up source by URL {url}')	1✔
167	source = src_cls.query(src_cls.url == url).get()	1✔
168	if source:	1✔
169	domains.update(source.domains)	×
170
171	domains.discard(src_cls.GR_CLASS.DOMAIN)	1✔
172
173	logging.info(f'Checking token against domains {domains}')	1✔
174	for domain in ndb.get_multi(ndb.Key(Domain, d) for d in domains):	1✔
175	if domain and token in domain.tokens:	1✔
176	return	1✔
177
178	self.abort(403, f'Token {token} is not authorized for any of: {domains}')	1✔
179
180	def auth(self, actor=None, check_token=True):	1✔
181	"""Loads the source and (optionally) token and checks that they're valid.
182
183	Expects token in the `token` query param, source in `key` or `username` with
184	fallback to `actor` for older browser extension versions that didn't send
185	them.
186
187	Args:
188	actor: dict, optional, AS1 actor
189	check_token: boolean, optional, whether to load and check the token too
190
191	Raises: :class:`HTTPException` with HTTP 400 if the token or source are
192	missing or invalid
193
194	Returns: BrowserSource or None
195	"""
196	# Load source
197	key = self.request.get('key')	1✔
198	username = self.request.get('username')	1✔
199	if not username and actor:	1✔
200	username = actor.get('username')	1✔
201
202	source = None	1✔
203	if key:	1✔
204	source = util.load_source(self, param='key')	1✔
205	elif username:	1✔
206	source = self.source_class().get_by_id(username)	1✔
207	else:
208	self.abort(400, 'No key or username query param and no scraped actor found')	1✔
209
210	if not source:	1✔
211	self.abort(404, f'No account found for {self.gr_source().NAME} user {key or username}')	1✔
212
213	# Load and check token
214	if not check_token:	1✔
215	return source	1✔
216
217	token = util.get_required_param(self, 'token')	1✔
218	for domain in Domain.query(Domain.tokens == token):	1✔
219	if domain.key.id() in source.domains:	1✔
220	return source	1✔
221
222	self.abort(403, f'Token {token} is not authorized for any of: {source.domains}')	×
223
224
225	class HomepageHandler(BrowserHandler):	1✔
226	"""Parses a silo home page and returns the logged in user's username.
227
228	Request body is https://www.instagram.com/ HTML for a logged in user.
229	"""
230	def post(self):	1✔
231	gr_src = self.gr_source()	1✔
232	_, actor = gr_src.scraped_to_activities(self.request.text)	1✔
233	logging.info(f'Got actor: {actor}')	1✔
234
235	if actor:	1✔
236	# TODO?
237	username = actor.get('username')	1✔
238	if username:	1✔
239	logging.info(f"Returning {username}")	1✔
240	return self.output(username)	1✔
241
242	self.abort(400, f"Couldn't determine logged in {gr_src.NAME} user or username")	1✔
243
244
245	class FeedHandler(BrowserHandler):	1✔
246	"""Parses a silo feed page and returns the posts.
247
248	Request body is HTML from a silo profile with posts, eg
249	https://www.instagram.com/name/ , for a logged in user.
250
251	Response body is the JSON list of translated ActivityStreams activities.
252	"""
253	def post(self):	1✔
254	activities, _ = self.scrape()	1✔
255	self.output(activities)	1✔
256
257	def scrape(self):	1✔
258	activities, actor = self.gr_source().scraped_to_activities(self.request.text)	1✔
259	ids = ' '.join(a['id'] for a in activities)	1✔
260	logging.info(f"Returning activities: {ids}")	1✔
261	return activities, actor	1✔
262
263
264	class ProfileHandler(FeedHandler):	1✔
265	"""Parses a silo profile page and creates or updates its Bridgy user.
266
267	Request body is HTML from an IG profile, eg https://www.instagram.com/name/ ,
268	for a logged in user.
269
270	Response body is the JSON string URL-safe key of the Bridgy source entity.
271	"""
272	def post(self):	1✔
273	_, actor = self.scrape()	1✔
274	if not actor:	1✔
275	actor = self.gr_source().scraped_to_actor(self.request.text)	1✔
276	self.check_token_for_actor(actor)	1✔
277
278	# create/update the Bridgy account
279	source = self.source_class().create_new(self, actor=actor)	1✔
280	self.output(source.key.urlsafe().decode())	1✔
281
282
283	class PostHandler(BrowserHandler):	1✔
284	"""Parses a silo post's HTML and creates or updates an Activity.
285
286	Request body is HTML from a silo post, eg https://www.instagram.com/p/ABC123/
287
288	Response body is the translated ActivityStreams activity JSON.
289	"""
290	def post(self):	1✔
291	gr_src = self.gr_source()	1✔
292	new_activity, actor = gr_src.scraped_to_activity(self.request.text)	1✔
293	if not new_activity:	1✔
294	self.abort(400, f'No {gr_src.NAME} post found in HTML')	1✔
295
296	source = self.auth(actor=actor)	1✔
297
298	@ndb.transactional()	1✔
299	def update_activity():
300	id = new_activity.get('id')	1✔
301	if not id:	1✔
302	self.abort(400, 'Scraped post missing id')	×
303	activity = Activity.get_by_id(id)	1✔
304
305	if activity:	1✔
306	# we already have this activity! merge in any new comments.
307	merged_activity = copy.deepcopy(new_activity)	1✔
308	existing_activity = json_loads(activity.activity_json)	1✔
309	# TODO: extract out merging replies
310	replies = merged_activity.setdefault('object', {}).setdefault('replies', {})	1✔
311	gr_source.merge_by_id(replies, 'items',	1✔
312	existing_activity.get('object', {}).get('replies', {}).get('items', []))
313	replies['totalItems'] = len(replies.get('items', []))	1✔
314	# TODO: merge tags too
315	activity.activity_json = json_dumps(merged_activity)	1✔
316	else:
317	activity = Activity(id=id, source=source.key,	1✔
318	activity_json=json_dumps(new_activity))
319
320	# store and return the activity
321	activity.put()	1✔
322	logging.info(f"Stored activity {id}")	1✔
323	self.output(new_activity)	1✔
324
325	update_activity()	1✔
326
327
328	class ReactionsHandler(BrowserHandler):	1✔
329	"""Parses reactions/likes from silo HTML and adds them to an existing Activity.
330
331	Requires the request parameter `id` with the silo post's id (not shortcode!).
332
333	Response body is the translated ActivityStreams JSON for the reactions.
334	"""
335	def post(self, *args):	1✔
336	gr_src = self.gr_source()	1✔
337	id = util.get_required_param(self, 'id')	1✔
338
339	# validate request
340	parsed_id = util.parse_tag_uri(id)	1✔
341	if not parsed_id:	1✔
342	self.abort(400, f'Expected id to be tag URI; got {id}')	1✔
343
344	activity = Activity.get_by_id(id)	1✔
345	if not activity:	1✔
346	self.abort(404, f'No {gr_src.NAME} post found for id {id}')	1✔
347
348	activity_data = json_loads(activity.activity_json)	1✔
349	actor = activity_data['object'].get('author') or activity_data.get('actor')	1✔
350	self.check_token_for_actor(actor)	1✔
351
352	# convert new reactions to AS, merge into existing activity
353	new_reactions = gr_src.merge_scraped_reactions(self.request.text, activity_data)	1✔
354	activity.activity_json = json_dumps(activity_data)	1✔
355	activity.put()	1✔
356
357	reaction_ids = ' '.join(r['id'] for r in new_reactions)	1✔
358	logging.info(f"Stored reactions for activity {id}: {reaction_ids}")	1✔
359	self.output(new_reactions)	1✔
360
361
362	class PollHandler(BrowserHandler):	1✔
363	"""Triggers a poll for a browser-based account."""
364	def post(self):	1✔
365	source = self.auth(check_token=False)	1✔
366	util.add_poll_task(source)	1✔
367	self.output('OK')	1✔
368
369
370	class TokenDomainsHandler(BrowserHandler):	1✔
371	"""Returns the domains that a token is registered for."""
372	def post(self):	1✔
373	token = util.get_required_param(self, 'token')	1✔
374
375	domains = [d.key.id() for d in Domain.query(Domain.tokens == token)]	1✔
376	if not domains:	1✔
377	self.abort(404, f'No registered domains for token {token}')	1✔
378
379	self.output(domains)	1✔
380
381
382	def routes(source_cls):	1✔
383	"""Returns browser extension webapp2 routes for a given source class.
384
385	...specifically, with the source's short name as the routes' URL prefix.
386	"""
387	return [	1✔
388	(f'/{source_cls.SHORT_NAME}/browser/homepage', HomepageHandler),
389	(f'/{source_cls.SHORT_NAME}/browser/profile', ProfileHandler),
390	(f'/{source_cls.SHORT_NAME}/browser/feed', FeedHandler),
391	(f'/{source_cls.SHORT_NAME}/browser/post', PostHandler),
392	(f'/{source_cls.SHORT_NAME}/browser/(likes\|reactions)', ReactionsHandler),
393	(f'/{source_cls.SHORT_NAME}/browser/poll', PollHandler),
394	(f'/{source_cls.SHORT_NAME}/browser/token-domains', TokenDomainsHandler),
395	]

snarfed / bridgy / 25180b19-02bd-4eba-8016-492bb4c0996c

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous