transmogrifier.ex 38 KB
Newer Older
1
# Pleroma: A lightweight social networking server
2
# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3
4
# SPDX-License-Identifier: AGPL-3.0-only

5
6
7
8
defmodule Pleroma.Web.ActivityPub.Transmogrifier do
  @moduledoc """
  A module to handle coding from internal to wire ActivityPub and back.
  """
Haelwenn's avatar
Haelwenn committed
9
  alias Pleroma.Activity
10
  alias Pleroma.FollowingRelationship
Haelwenn's avatar
Haelwenn committed
11
  alias Pleroma.Object
rinpatch's avatar
rinpatch committed
12
  alias Pleroma.Object.Containment
Haelwenn's avatar
Haelwenn committed
13
  alias Pleroma.Repo
14
  alias Pleroma.User
Haelwenn's avatar
Haelwenn committed
15
  alias Pleroma.Web.ActivityPub.ActivityPub
16
17
18
  alias Pleroma.Web.ActivityPub.ObjectValidator
  alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
  alias Pleroma.Web.ActivityPub.Pipeline
Haelwenn's avatar
Haelwenn committed
19
  alias Pleroma.Web.ActivityPub.Utils
lain's avatar
lain committed
20
  alias Pleroma.Web.ActivityPub.Visibility
21
  alias Pleroma.Web.Federator
22
  alias Pleroma.Workers.TransmogrifierWorker
23

lain's avatar
lain committed
24
25
  import Ecto.Query

26
  require Logger
27
  require Pleroma.Constants
28

29
30
31
  @doc """
  Modifies an incoming AP object (mastodon format) to our internal format.
  """
32
  def fix_object(object, options \\ []) do
33
    object
34
    |> strip_internal_fields
35
    |> fix_actor
36
    |> fix_url
37
    |> fix_attachments
lain's avatar
lain committed
38
    |> fix_context
39
    |> fix_in_reply_to(options)
lain's avatar
lain committed
40
    |> fix_emoji
41
    |> fix_tag
42
    |> fix_content_map
43
    |> fix_addressing
44
    |> fix_summary
45
    |> fix_type(options)
46
47
48
  end

  def fix_summary(%{"summary" => nil} = object) do
49
    Map.put(object, "summary", "")
50
51
52
53
54
55
56
  end

  def fix_summary(%{"summary" => _} = object) do
    # summary is present, nothing to do
    object
  end

57
  def fix_summary(object), do: Map.put(object, "summary", "")
58
59

  def fix_addressing_list(map, field) do
60
61
62
63
64
65
66
67
68
    cond do
      is_binary(map[field]) ->
        Map.put(map, field, [map[field]])

      is_nil(map[field]) ->
        Map.put(map, field, [])

      true ->
        map
69
70
71
    end
  end

72
73
74
75
76
  def fix_explicit_addressing(
        %{"to" => to, "cc" => cc} = object,
        explicit_mentions,
        follower_collection
      ) do
77
    explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)
78

79
    explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)
80
81
82

    final_cc =
      (cc ++ explicit_cc)
83
      |> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
84
85
86
87
88
89
90
      |> Enum.uniq()

    object
    |> Map.put("to", explicit_to)
    |> Map.put("cc", final_cc)
  end

91
  def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object
92

93
94
  # if directMessage flag is set to true, leave the addressing alone
  def fix_explicit_addressing(%{"directMessage" => true} = object), do: object
95

96
  def fix_explicit_addressing(object) do
97
    explicit_mentions = Utils.determine_explicit_mentions(object)
98

99
100
101
102
    %User{follower_address: follower_collection} =
      object
      |> Containment.get_actor()
      |> User.get_cached_by_ap_id()
103

104
105
106
107
108
109
    explicit_mentions =
      explicit_mentions ++
        [
          Pleroma.Constants.as_public(),
          follower_collection
        ]
110

111
    fix_explicit_addressing(object, explicit_mentions, follower_collection)
lain's avatar
lain committed
112
113
  end

114
115
116
117
118
119
120
  # if as:Public is addressed, then make sure the followers collection is also addressed
  # so that the activities will be delivered to local users.
  def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
    recipients = to ++ cc

    if followers_collection not in recipients do
      cond do
121
        Pleroma.Constants.as_public() in cc ->
122
123
124
          to = to ++ [followers_collection]
          Map.put(object, "to", to)

125
        Pleroma.Constants.as_public() in to ->
126
127
128
129
130
131
          cc = cc ++ [followers_collection]
          Map.put(object, "cc", cc)

        true ->
          object
      end
132
    else
133
      object
134
135
136
    end
  end

137
138
  def fix_implicit_addressing(object, _), do: object

139
  def fix_addressing(object) do
Alexander Strizhakov's avatar
Alexander Strizhakov committed
140
    {:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
141
142
    followers_collection = User.ap_followers(user)

143
    object
144
145
146
147
    |> fix_addressing_list("to")
    |> fix_addressing_list("cc")
    |> fix_addressing_list("bto")
    |> fix_addressing_list("bcc")
148
    |> fix_explicit_addressing()
149
    |> fix_implicit_addressing(followers_collection)
lain's avatar
lain committed
150
151
  end

152
  def fix_actor(%{"attributedTo" => actor} = object) do
153
    Map.put(object, "actor", Containment.get_actor(%{"actor" => actor}))
154
155
  end

156
157
158
  def fix_in_reply_to(object, options \\ [])

  def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
159
      when not is_nil(in_reply_to) do
160
    in_reply_to_id = prepare_in_reply_to(in_reply_to)
161
    object = Map.put(object, "inReplyToAtomUri", in_reply_to_id)
162
    depth = (options[:depth] || 0) + 1
lain's avatar
lain committed
163

164
    if Federator.allowed_thread_distance?(depth) do
165
      with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
minibikini's avatar
minibikini committed
166
           %Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
167
168
169
170
171
172
        object
        |> Map.put("inReplyTo", replied_object.data["id"])
        |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
        |> Map.put("conversation", replied_object.data["context"] || object["conversation"])
        |> Map.put("context", replied_object.data["context"] || object["conversation"])
      else
173
        e ->
feld's avatar
feld committed
174
          Logger.error("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
175
176
177
178
          object
      end
    else
      object
lain's avatar
lain committed
179
180
    end
  end
lain's avatar
lain committed
181

182
  def fix_in_reply_to(object, _options), do: object
lain's avatar
lain committed
183

184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
  defp prepare_in_reply_to(in_reply_to) do
    cond do
      is_bitstring(in_reply_to) ->
        in_reply_to

      is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
        in_reply_to["id"]

      is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
        Enum.at(in_reply_to, 0)

      true ->
        ""
    end
  end

lain's avatar
lain committed
200
  def fix_context(object) do
Haelwenn's avatar
Haelwenn committed
201
202
    context = object["context"] || object["conversation"] || Utils.generate_context_id()

lain's avatar
lain committed
203
    object
Haelwenn's avatar
Haelwenn committed
204
205
    |> Map.put("context", context)
    |> Map.put("conversation", context)
lain's avatar
lain committed
206
207
  end

208
209
210
211
212
213
  defp add_if_present(map, _key, nil), do: map

  defp add_if_present(map, key, value) do
    Map.put(map, key, value)
  end

214
  def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
lain's avatar
lain committed
215
    attachments =
216
      Enum.map(attachment, fn data ->
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
        url =
          cond do
            is_list(data["url"]) -> List.first(data["url"])
            is_map(data["url"]) -> data["url"]
            true -> nil
          end

        media_type =
          cond do
            is_map(url) && is_binary(url["mediaType"]) -> url["mediaType"]
            is_binary(data["mediaType"]) -> data["mediaType"]
            is_binary(data["mimeType"]) -> data["mimeType"]
            true -> nil
          end

        href =
          cond do
            is_map(url) && is_binary(url["href"]) -> url["href"]
            is_binary(data["url"]) -> data["url"]
            is_binary(data["href"]) -> data["href"]
          end

        attachment_url =
          %{"href" => href}
          |> add_if_present("mediaType", media_type)
          |> add_if_present("type", Map.get(url || %{}, "type"))

        %{"url" => [attachment_url]}
        |> add_if_present("mediaType", media_type)
        |> add_if_present("type", data["type"])
        |> add_if_present("name", data["name"])
lain's avatar
lain committed
248
      end)
lain's avatar
lain committed
249

250
    Map.put(object, "attachment", attachments)
251
252
  end

253
  def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
Maksim's avatar
Maksim committed
254
255
256
    object
    |> Map.put("attachment", [attachment])
    |> fix_attachments()
257
258
  end

259
  def fix_attachments(object), do: object
260

261
  def fix_url(%{"url" => url} = object) when is_map(url) do
262
    Map.put(object, "url", url["href"])
263
264
  end

265
266
  def fix_url(%{"type" => object_type, "url" => url} = object)
      when object_type in ["Video", "Audio"] and is_list(url) do
267
268
    first_element = Enum.at(url, 0)

269
    link_element = Enum.find(url, fn x -> is_map(x) and x["mimeType"] == "text/html" end)
270
271
272
273
274
275
276
277

    object
    |> Map.put("attachment", [first_element])
    |> Map.put("url", link_element["href"])
  end

  def fix_url(%{"type" => object_type, "url" => url} = object)
      when object_type != "Video" and is_list(url) do
278
279
280
281
282
283
284
285
286
    first_element = Enum.at(url, 0)

    url_string =
      cond do
        is_bitstring(first_element) -> first_element
        is_map(first_element) -> first_element["href"] || ""
        true -> ""
      end

287
    Map.put(object, "url", url_string)
288
289
290
291
  end

  def fix_url(object), do: object

292
  def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
lain's avatar
lain committed
293
    emoji =
294
295
      tags
      |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
lain's avatar
lain committed
296
      |> Enum.reduce(%{}, fn data, mapping ->
297
        name = String.trim(data["name"], ":")
lain's avatar
lain committed
298

299
        Map.put(mapping, name, data["icon"]["url"])
lain's avatar
lain committed
300
      end)
lain's avatar
lain committed
301
302
303
304

    # we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
    emoji = Map.merge(object["emoji"] || %{}, emoji)

305
    Map.put(object, "emoji", emoji)
lain's avatar
lain committed
306
307
  end

308
309
310
311
  def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
    name = String.trim(tag["name"], ":")
    emoji = %{name => tag["icon"]["url"]}

312
    Map.put(object, "emoji", emoji)
313
314
  end

315
  def fix_emoji(object), do: object
316

317
  def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
lain's avatar
lain committed
318
    tags =
319
      tag
lain's avatar
lain committed
320
321
      |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
      |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
322

323
    Map.put(object, "tag", tag ++ tags)
324
325
  end

326
327
  def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
    combined = [tag, String.slice(hashtag, 1..-1)]
328

329
    Map.put(object, "tag", combined)
330
331
  end

332
333
  def fix_tag(%{"tag" => %{} = tag} = object), do: Map.put(object, "tag", [tag])

334
  def fix_tag(object), do: object
335

336
337
338
339
340
  # content map usually only has one language so this will do for now.
  def fix_content_map(%{"contentMap" => content_map} = object) do
    content_groups = Map.to_list(content_map)
    {_, content} = Enum.at(content_groups, 0)

341
    Map.put(object, "content", content)
342
343
344
345
  end

  def fix_content_map(object), do: object

346
347
  def fix_type(object, options \\ [])

348
349
  def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
      when is_binary(reply_id) do
350
    with true <- Federator.allowed_thread_distance?(options[:depth]),
351
         {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
352
353
      Map.put(object, "type", "Answer")
    else
354
      _ -> object
355
356
357
    end
  end

358
  def fix_type(object, _), do: object
359

Maksim's avatar
Maksim committed
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
  defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
    with true <- id =~ "follows",
         %User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
         %Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
      {:ok, activity}
    else
      _ -> {:error, nil}
    end
  end

  defp mastodon_follow_hack(_, _), do: {:error, nil}

  defp get_follow_activity(follow_object, followed) do
    with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
         {_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
      {:ok, activity}
    else
      # Can't find the activity. This might a Mastodon 2.3 "Accept"
      {:activity, nil} ->
        mastodon_follow_hack(follow_object, followed)

      _ ->
        {:error, nil}
    end
  end

386
387
388
389
390
391
392
393
394
395
396
  # Reduce the object list to find the reported user.
  defp get_reported(objects) do
    Enum.reduce_while(objects, nil, fn ap_id, _ ->
      with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
        {:halt, user}
      else
        _ -> {:cont, nil}
      end
    end)
  end

397
398
  def handle_incoming(data, options \\ [])

399
400
  # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
  # with nil ID.
401
  def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
402
403
404
405
    with context <- data["context"] || Utils.generate_context_id(),
         content <- data["content"] || "",
         %User{} = actor <- User.get_cached_by_ap_id(actor),
         # Reduce the object list to find the reported user.
406
         %User{} = account <- get_reported(objects),
407
408
         # Remove the reported user from the object list.
         statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
409
      %{
410
411
412
413
414
        actor: actor,
        context: context,
        account: account,
        statuses: statuses,
        content: content,
415
        additional: %{"cc" => [account.ap_id]}
416
      }
417
      |> ActivityPub.flag()
418
419
420
    end
  end

421
  # disallow objects with bogus IDs
422
423
  def handle_incoming(%{"id" => nil}, _options), do: :error
  def handle_incoming(%{"id" => ""}, _options), do: :error
424
  # length of https:// = 8, should validate better, but good enough for now.
rinpatch's avatar
rinpatch committed
425
  def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
426
    do: :error
427

428
429
430
  # TODO: validate those with a Ecto scheme
  # - tags
  # - emoji
431
432
433
434
  def handle_incoming(
        %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
        options
      )
435
      when objtype in ["Article", "Event", "Note", "Video", "Page", "Question", "Answer", "Audio"] do
436
    actor = Containment.get_actor(data)
437
438
439
440

    data =
      Map.put(data, "actor", actor)
      |> fix_addressing
441

442
    with nil <- Activity.get_create_by_object_ap_id(object["id"]),
443
         {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
444
      object = fix_object(object, options)
445

446
447
448
449
      params = %{
        to: data["to"],
        object: object,
        actor: user,
lain's avatar
lain committed
450
        context: object["conversation"],
451
452
        local: false,
        published: data["published"],
lain's avatar
lain committed
453
454
455
        additional:
          Map.take(data, [
            "cc",
456
            "directMessage",
lain's avatar
lain committed
457
458
            "id"
          ])
459
460
      }

461
      with {:ok, created_activity} <- ActivityPub.create(params) do
462
463
464
465
466
467
468
469
470
        reply_depth = (options[:depth] || 0) + 1

        if Federator.allowed_thread_distance?(reply_depth) do
          for reply_id <- replies(object) do
            Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
              "id" => reply_id,
              "depth" => reply_depth
            })
          end
471
472
473
474
        end

        {:ok, created_activity}
      end
475
    else
lain's avatar
lain committed
476
      %Activity{} = activity -> {:ok, activity}
477
478
479
480
      _e -> :error
    end
  end

481
482
483
484
485
486
487
488
489
490
491
  def handle_incoming(
        %{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
        options
      ) do
    actor = Containment.get_actor(data)

    data =
      Map.put(data, "actor", actor)
      |> fix_addressing

    with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
492
493
      reply_depth = (options[:depth] || 0) + 1
      options = Keyword.put(options, :depth, reply_depth)
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
      object = fix_object(object, options)

      params = %{
        to: data["to"],
        object: object,
        actor: user,
        context: nil,
        local: false,
        published: data["published"],
        additional: Map.take(data, ["cc", "id"])
      }

      ActivityPub.listen(params)
    else
      _e -> :error
    end
  end

lain's avatar
lain committed
512
  def handle_incoming(
513
514
        %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data,
        _options
lain's avatar
lain committed
515
      ) do
516
517
518
519
    with %User{local: true} = followed <-
           User.get_cached_by_ap_id(Containment.get_actor(%{"actor" => followed})),
         {:ok, %User{} = follower} <-
           User.get_or_fetch_by_ap_id(Containment.get_actor(%{"actor" => follower})),
520
         {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
521
      with deny_follow_blocked <- Pleroma.Config.get([:user, :deny_follow_blocked]),
522
           {_, false} <- {:user_blocked, User.blocks?(followed, follower) && deny_follow_blocked},
523
524
           {_, false} <- {:user_locked, User.locked?(followed)},
           {_, {:ok, follower}} <- {:follow, User.follow(follower, followed)},
525
           {_, {:ok, _}} <-
526
             {:follow_state_update, Utils.update_follow_state_for_all(activity, "accept")},
527
528
           {:ok, _relationship} <-
             FollowingRelationship.update(follower, followed, :follow_accept) do
kaniini's avatar
kaniini committed
529
530
        ActivityPub.accept(%{
          to: [follower.ap_id],
531
          actor: followed,
kaniini's avatar
kaniini committed
532
533
534
          object: data,
          local: true
        })
535
536
      else
        {:user_blocked, true} ->
537
          {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
538
          {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_reject)
539
540
541
542
543
544
545
546
547

          ActivityPub.reject(%{
            to: [follower.ap_id],
            actor: followed,
            object: data,
            local: true
          })

        {:follow, {:error, _}} ->
548
          {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
549
          {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_reject)
550
551
552
553
554
555
556
557
558

          ActivityPub.reject(%{
            to: [follower.ap_id],
            actor: followed,
            object: data,
            local: true
          })

        {:user_locked, true} ->
559
          {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_pending)
560
          :noop
561
      end
lain's avatar
lain committed
562

563
564
      {:ok, activity}
    else
565
566
      _e ->
        :error
567
568
569
    end
  end

570
  def handle_incoming(
571
        %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
572
        _options
573
      ) do
574
    with actor <- Containment.get_actor(data),
575
         {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
576
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
577
         {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
578
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
579
         {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept) do
580
581
582
583
584
      ActivityPub.accept(%{
        to: follow_activity.data["to"],
        type: "Accept",
        actor: followed,
        object: follow_activity.data["id"],
585
586
        local: false,
        activity_id: id
587
      })
588
589
    else
      _e -> :error
590
591
592
593
    end
  end

  def handle_incoming(
594
        %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
595
        _options
596
      ) do
597
    with actor <- Containment.get_actor(data),
598
         {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
599
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
600
         {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
601
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
602
         {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_reject),
lain's avatar
lain committed
603
         {:ok, activity} <-
604
           ActivityPub.reject(%{
lain's avatar
lain committed
605
             to: follow_activity.data["to"],
606
             type: "Reject",
607
             actor: followed,
lain's avatar
lain committed
608
             object: follow_activity.data["id"],
609
610
             local: false,
             activity_id: id
lain's avatar
lain committed
611
           }) do
612
      {:ok, activity}
613
614
    else
      _e -> :error
615
616
617
    end
  end

618
619
620
621
622
623
624
625
626
627
  @misskey_reactions %{
    "like" => "👍",
    "love" => "❤️",
    "laugh" => "😆",
    "hmm" => "🤔",
    "surprise" => "😮",
    "congrats" => "🎉",
    "angry" => "💢",
    "confused" => "😥",
    "rip" => "😇",
628
629
    "pudding" => "🍮",
    "star" => "⭐"
630
631
  }

lain's avatar
lain committed
632
  @doc "Rewrite misskey likes into EmojiReacts"
633
634
635
636
637
638
639
640
  def handle_incoming(
        %{
          "type" => "Like",
          "_misskey_reaction" => reaction
        } = data,
        options
      ) do
    data
lain's avatar
lain committed
641
    |> Map.put("type", "EmojiReact")
642
    |> Map.put("content", @misskey_reactions[reaction] || reaction)
643
644
645
    |> handle_incoming(options)
  end

646
  def handle_incoming(%{"type" => "Like"} = data, _options) do
647
648
649
    with {_, {:ok, cast_data_sym}} <-
           {:casting_data,
            data |> LikeValidator.cast_data() |> Ecto.Changeset.apply_action(:insert)},
650
         cast_data = ObjectValidator.stringify_keys(Map.from_struct(cast_data_sym)),
651
         :ok <- ObjectValidator.fetch_actor_and_object(cast_data),
lain's avatar
lain committed
652
         {_, {:ok, cast_data}} <- {:ensure_context_presence, ensure_context_presence(cast_data)},
653
         {_, {:ok, cast_data}} <-
lain's avatar
lain committed
654
           {:ensure_recipients_presence, ensure_recipients_presence(cast_data)},
655
         {_, {:ok, activity, _meta}} <-
656
           {:common_pipeline, Pipeline.common_pipeline(cast_data, local: false)} do
lain's avatar
lain committed
657
658
      {:ok, activity}
    else
659
      e -> {:error, e}
lain's avatar
lain committed
660
661
662
    end
  end

663
664
  def handle_incoming(
        %{
lain's avatar
lain committed
665
          "type" => "EmojiReact",
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
          "object" => object_id,
          "actor" => _actor,
          "id" => id,
          "content" => emoji
        } = data,
        _options
      ) do
    with actor <- Containment.get_actor(data),
         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
         {:ok, object} <- get_obj_helper(object_id),
         {:ok, activity, _object} <-
           ActivityPub.react_with_emoji(actor, object, emoji, activity_id: id, local: false) do
      {:ok, activity}
    else
      _e -> :error
    end
  end

lain's avatar
lain committed
684
  def handle_incoming(
685
686
        %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data,
        _options
lain's avatar
lain committed
687
      ) do
688
    with actor <- Containment.get_actor(data),
689
         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
690
         {:ok, object} <- get_embedded_obj_helper(object_id, actor),
lain's avatar
lain committed
691
         public <- Visibility.is_public?(data),
692
         {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
lain's avatar
lain committed
693
694
695
696
697
698
      {:ok, activity}
    else
      _e -> :error
    end
  end

lain's avatar
lain committed
699
  def handle_incoming(
700
        %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
701
702
          data,
        _options
703
      )
704
705
706
707
      when object_type in [
             "Person",
             "Application",
             "Service",
708
             "Organization"
709
           ] do
minibikini's avatar
minibikini committed
710
    with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
lain's avatar
lain committed
711
712
713
      {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)

      actor
714
      |> User.upgrade_changeset(new_user_data, true)
lain's avatar
lain committed
715
      |> User.update_and_set_cache()
lain's avatar
lain committed
716

lain's avatar
lain committed
717
718
719
720
721
      ActivityPub.update(%{
        local: false,
        to: data["to"] || [],
        cc: data["cc"] || [],
        object: object,
722
723
        actor: actor_id,
        activity_id: data["id"]
lain's avatar
lain committed
724
      })
lain's avatar
lain committed
725
726
727
728
729
730
731
    else
      e ->
        Logger.error(e)
        :error
    end
  end

732
733
734
735
736
  # TODO: We presently assume that any actor on the same origin domain as the object being
  # deleted has the rights to delete that object.  A better way to validate whether or not
  # the object should be deleted is to refetch the object URI, which should return either
  # an error or a tombstone.  This would allow us to verify that a deletion actually took
  # place.
lain's avatar
lain committed
737
  def handle_incoming(
738
        %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => id} = data,
739
        _options
lain's avatar
lain committed
740
      ) do
lain's avatar
lain committed
741
    object_id = Utils.get_ap_id(object_id)
lain's avatar
lain committed
742

743
    with actor <- Containment.get_actor(data),
744
         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
745
         {:ok, object} <- get_obj_helper(object_id),
746
         :ok <- Containment.contain_origin(actor.ap_id, object.data),
747
748
         {:ok, activity} <-
           ActivityPub.delete(object, local: false, activity_id: id, actor: actor.ap_id) do
lain's avatar
lain committed
749
750
      {:ok, activity}
    else
751
752
753
      nil ->
        case User.get_cached_by_ap_id(object_id) do
          %User{ap_id: ^actor} = user ->
754
            User.delete(user)
755
756
757
758
759
760
761

          nil ->
            :error
        end

      _e ->
        :error
lain's avatar
lain committed
762
763
764
    end
  end

765
  def handle_incoming(
766
767
        %{
          "type" => "Undo",
768
          "object" => %{"type" => "Announce", "object" => object_id},
Maksim's avatar
Maksim committed
769
          "actor" => _actor,
770
          "id" => id
771
772
        } = data,
        _options
773
      ) do
774
    with actor <- Containment.get_actor(data),
775
         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
776
         {:ok, object} <- get_obj_helper(object_id),
777
         {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
778
779
      {:ok, activity}
    else
Thog's avatar
Thog committed
780
      _e -> :error
781
782
783
    end
  end

normandy's avatar
normandy committed
784
785
786
787
788
789
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Follow", "object" => followed},
          "actor" => follower,
          "id" => id
790
791
        } = _data,
        _options
normandy's avatar
normandy committed
792
      ) do
normandy's avatar
normandy committed
793
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
794
         {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
normandy's avatar
normandy committed
795
         {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
normandy's avatar
normandy committed
796
797
798
      User.unfollow(follower, followed)
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
799
      _e -> :error
normandy's avatar
normandy committed
800
801
802
    end
  end

803
804
805
  def handle_incoming(
        %{
          "type" => "Undo",
lain's avatar
lain committed
806
          "object" => %{"type" => "EmojiReact", "id" => reaction_activity_id},
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
          "actor" => _actor,
          "id" => id
        } = data,
        _options
      ) do
    with actor <- Containment.get_actor(data),
         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
         {:ok, activity, _} <-
           ActivityPub.unreact_with_emoji(actor, reaction_activity_id,
             activity_id: id,
             local: false
           ) do
      {:ok, activity}
    else
      _e -> :error
    end
  end

normandy's avatar
normandy committed
825
826
827
828
829
830
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Block", "object" => blocked},
          "actor" => blocker,
          "id" => id
831
832
        } = _data,
        _options
normandy's avatar
normandy committed
833
      ) do
834
    with %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
835
         {:ok, %User{} = blocker} <- User.get_or_fetch_by_ap_id(blocker),
normandy's avatar
normandy committed
836
         {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
normandy's avatar
normandy committed
837
      User.unblock(blocker, blocked)
normandy's avatar
normandy committed
838
839
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
840
      _e -> :error
normandy's avatar
normandy committed
841
842
843
    end
  end

844
  def handle_incoming(
845
846
        %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
        _options
847
      ) do
848
    with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
0x1C3B00DA's avatar
0x1C3B00DA committed
849
         {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
normandy's avatar
normandy committed
850
         {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
851
      User.unfollow(blocker, blocked)
852
      User.block(blocker, blocked)
normandy's avatar
normandy committed
853
854
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
855
      _e -> :error
normandy's avatar
normandy committed
856
857
    end
  end
858

Thog's avatar
Thog committed
859
860
861
862
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Like", "object" => object_id},
Maksim's avatar
Maksim committed
863
          "actor" => _actor,
Thog's avatar
Thog committed
864
          "id" => id
865
866
        } = data,
        _options
Thog's avatar
Thog committed
867
      ) do
868
    with actor <- Containment.get_actor(data),
869
         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
870
         {:ok, object} <- get_obj_helper(object_id),
Thog's avatar
Thog committed
871
872
873
         {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
      {:ok, activity}
    else
Thog's avatar
Thog committed
874
      _e -> :error
Thog's avatar
Thog committed
875
876
877
    end
  end

878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
  # For Undos that don't have the complete object attached, try to find it in our database.
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => object
        } = activity,
        options
      )
      when is_binary(object) do
    with %Activity{data: data} <- Activity.get_by_ap_id(object) do
      activity
      |> Map.put("object", data)
      |> handle_incoming(options)
    else
      _e -> :error
    end
  end

minibikini's avatar
minibikini committed
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
  def handle_incoming(
        %{
          "type" => "Move",
          "actor" => origin_actor,
          "object" => origin_actor,
          "target" => target_actor
        },
        _options
      ) do
    with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
         {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
         true <- origin_actor in target_user.also_known_as do
      ActivityPub.move(origin_user, target_user, false)
    else
      _e -> :error
    end
  end

914
  def handle_incoming(_, _), do: :error
915

916
  @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
917
  def get_obj_helper(id, options \\ []) do
Maksim's avatar
Maksim committed
918
919
920
    case Object.normalize(id, true, options) do
      %Object{} = object -> {:ok, object}
      _ -> nil
921
    end
922
923
  end

924
  @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
Thibaut Girka's avatar
Thibaut Girka committed
925
  def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
926
927
        ap_id: ap_id
      })
Thibaut Girka's avatar
Thibaut Girka committed
928
      when attributed_to == ap_id do
929
930
931
932
933
    with {:ok, activity} <-
           handle_incoming(%{
             "type" => "Create",
             "to" => data["to"],
             "cc" => data["cc"],
Thibaut Girka's avatar
Thibaut Girka committed
934
             "actor" => attributed_to,
935
936
937
938
939
940
941
942
943
944
945
946
             "object" => data
           }) do
      {:ok, Object.normalize(activity)}
    else
      _ -> get_obj_helper(object_id)
    end
  end

  def get_embedded_obj_helper(object_id, _) do
    get_obj_helper(object_id)
  end

947
948
949
950
  def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
    with false <- String.starts_with?(in_reply_to, "http"),
         {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
      Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
951
952
953
954
    else
      _e -> object
    end
  end