transmogrifier.ex 31.9 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
Maksim's avatar
Maksim committed
10
  alias Pleroma.EarmarkRenderer
11
  alias Pleroma.EctoType.ActivityPub.ObjectValidators
12
  alias Pleroma.FollowingRelationship
13
  alias Pleroma.Maps
lain's avatar
lain committed
14
  alias Pleroma.Notification
Haelwenn's avatar
Haelwenn committed
15
  alias Pleroma.Object
rinpatch's avatar
rinpatch committed
16
  alias Pleroma.Object.Containment
Haelwenn's avatar
Haelwenn committed
17
  alias Pleroma.Repo
18
  alias Pleroma.User
Haelwenn's avatar
Haelwenn committed
19
  alias Pleroma.Web.ActivityPub.ActivityPub
20
  alias Pleroma.Web.ActivityPub.Builder
21
22
  alias Pleroma.Web.ActivityPub.ObjectValidator
  alias Pleroma.Web.ActivityPub.Pipeline
Haelwenn's avatar
Haelwenn committed
23
  alias Pleroma.Web.ActivityPub.Utils
lain's avatar
lain committed
24
  alias Pleroma.Web.ActivityPub.Visibility
25
  alias Pleroma.Web.Federator
26
  alias Pleroma.Workers.TransmogrifierWorker
27

lain's avatar
lain committed
28
29
  import Ecto.Query

30
  require Logger
31
  require Pleroma.Constants
32

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

  def fix_summary(%{"summary" => nil} = object) do
54
    Map.put(object, "summary", "")
55
56
57
58
59
60
61
  end

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

62
  def fix_summary(object), do: Map.put(object, "summary", "")
63
64

  def fix_addressing_list(map, field) do
65
66
    addrs = map[field]

67
    cond do
68
69
      is_list(addrs) ->
        Map.put(map, field, Enum.filter(addrs, &is_binary/1))
70

71
72
      is_binary(addrs) ->
        Map.put(map, field, [addrs])
73
74

      true ->
75
        Map.put(map, field, [])
76
77
78
    end
  end

79
80
81
82
83
  def fix_explicit_addressing(
        %{"to" => to, "cc" => cc} = object,
        explicit_mentions,
        follower_collection
      ) do
84
    explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)
85

86
    explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)
87
88
89

    final_cc =
      (cc ++ explicit_cc)
90
      |> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
91
92
93
94
95
96
97
      |> Enum.uniq()

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

98
  def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object
99

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

103
  def fix_explicit_addressing(object) do
104
    explicit_mentions = Utils.determine_explicit_mentions(object)
105

106
107
108
109
    %User{follower_address: follower_collection} =
      object
      |> Containment.get_actor()
      |> User.get_cached_by_ap_id()
110

111
112
113
114
115
116
    explicit_mentions =
      explicit_mentions ++
        [
          Pleroma.Constants.as_public(),
          follower_collection
        ]
117

118
    fix_explicit_addressing(object, explicit_mentions, follower_collection)
lain's avatar
lain committed
119
120
  end

121
122
123
124
125
126
127
  # 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
128
        Pleroma.Constants.as_public() in cc ->
129
130
131
          to = to ++ [followers_collection]
          Map.put(object, "to", to)

132
        Pleroma.Constants.as_public() in to ->
133
134
135
136
137
138
          cc = cc ++ [followers_collection]
          Map.put(object, "cc", cc)

        true ->
          object
      end
139
    else
140
      object
141
142
143
    end
  end

144
145
  def fix_implicit_addressing(object, _), do: object

146
  def fix_addressing(object) do
Alexander Strizhakov's avatar
Alexander Strizhakov committed
147
    {:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
148
149
    followers_collection = User.ap_followers(user)

150
    object
151
152
153
154
    |> fix_addressing_list("to")
    |> fix_addressing_list("cc")
    |> fix_addressing_list("bto")
    |> fix_addressing_list("bcc")
155
    |> fix_explicit_addressing()
156
    |> fix_implicit_addressing(followers_collection)
lain's avatar
lain committed
157
158
  end

159
  def fix_actor(%{"attributedTo" => actor} = object) do
160
161
162
163
164
165
    actor = Containment.get_actor(%{"actor" => actor})

    # TODO: Remove actor field for Objects
    object
    |> Map.put("actor", actor)
    |> Map.put("attributedTo", actor)
166
167
  end

168
169
170
  def fix_in_reply_to(object, options \\ [])

  def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
171
      when not is_nil(in_reply_to) do
172
    in_reply_to_id = prepare_in_reply_to(in_reply_to)
173
    object = Map.put(object, "inReplyToAtomUri", in_reply_to_id)
174
    depth = (options[:depth] || 0) + 1
lain's avatar
lain committed
175

176
    if Federator.allowed_thread_distance?(depth) do
177
      with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
minibikini's avatar
minibikini committed
178
           %Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
179
180
181
182
        object
        |> Map.put("inReplyTo", replied_object.data["id"])
        |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
        |> Map.put("context", replied_object.data["context"] || object["conversation"])
183
        |> Map.drop(["conversation"])
184
      else
185
        e ->
186
          Logger.warn("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
187
188
189
190
          object
      end
    else
      object
lain's avatar
lain committed
191
192
    end
  end
lain's avatar
lain committed
193

194
  def fix_in_reply_to(object, _options), do: object
lain's avatar
lain committed
195

196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
  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
212
  def fix_context(object) do
Haelwenn's avatar
Haelwenn committed
213
214
    context = object["context"] || object["conversation"] || Utils.generate_context_id()

lain's avatar
lain committed
215
    object
Haelwenn's avatar
Haelwenn committed
216
    |> Map.put("context", context)
217
    |> Map.drop(["conversation"])
lain's avatar
lain committed
218
219
  end

220
  def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
lain's avatar
lain committed
221
    attachments =
222
      Enum.map(attachment, fn data ->
223
224
225
226
227
228
229
230
231
        url =
          cond do
            is_list(data["url"]) -> List.first(data["url"])
            is_map(data["url"]) -> data["url"]
            true -> nil
          end

        media_type =
          cond do
232
233
234
            is_map(url) && MIME.valid?(url["mediaType"]) -> url["mediaType"]
            MIME.valid?(data["mediaType"]) -> data["mediaType"]
            MIME.valid?(data["mimeType"]) -> data["mimeType"]
235
236
237
238
239
240
241
242
            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"]
Haelwenn's avatar
Haelwenn committed
243
            true -> nil
244
245
          end

Haelwenn's avatar
Haelwenn committed
246
247
        if href do
          attachment_url =
Haelwenn's avatar
Haelwenn committed
248
249
250
251
            %{
              "href" => href,
              "type" => Map.get(url || %{}, "type", "Link")
            }
Haelwenn's avatar
Haelwenn committed
252
            |> Maps.put_if_present("mediaType", media_type)
253

Haelwenn's avatar
Haelwenn committed
254
255
256
257
          %{
            "url" => [attachment_url],
            "type" => data["type"] || "Document"
          }
Haelwenn's avatar
Haelwenn committed
258
259
260
261
262
          |> Maps.put_if_present("mediaType", media_type)
          |> Maps.put_if_present("name", data["name"])
        else
          nil
        end
lain's avatar
lain committed
263
      end)
Haelwenn's avatar
Haelwenn committed
264
      |> Enum.filter(& &1)
lain's avatar
lain committed
265

266
    Map.put(object, "attachment", attachments)
267
268
  end

269
  def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
Maksim's avatar
Maksim committed
270
271
272
    object
    |> Map.put("attachment", [attachment])
    |> fix_attachments()
273
274
  end

275
  def fix_attachments(object), do: object
276

277
  def fix_url(%{"url" => url} = object) when is_map(url) do
278
    Map.put(object, "url", url["href"])
279
280
  end

281
282
  def fix_url(%{"type" => object_type, "url" => url} = object)
      when object_type in ["Video", "Audio"] and is_list(url) do
Haelwenn's avatar
Haelwenn committed
283
284
285
    attachment =
      Enum.find(url, fn x ->
        media_type = x["mediaType"] || x["mimeType"] || ""
286

Haelwenn's avatar
Haelwenn committed
287
288
289
290
291
        is_map(x) and String.starts_with?(media_type, ["audio/", "video/"])
      end)

    link_element =
      Enum.find(url, fn x -> is_map(x) and (x["mediaType"] || x["mimeType"]) == "text/html" end)
292
293

    object
Haelwenn's avatar
Haelwenn committed
294
    |> Map.put("attachment", [attachment])
295
296
297
298
299
    |> 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
300
301
302
303
304
305
306
307
308
    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

309
    Map.put(object, "url", url_string)
310
311
312
313
  end

  def fix_url(object), do: object

314
  def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
lain's avatar
lain committed
315
    emoji =
316
317
      tags
      |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
lain's avatar
lain committed
318
      |> Enum.reduce(%{}, fn data, mapping ->
319
        name = String.trim(data["name"], ":")
lain's avatar
lain committed
320

321
        Map.put(mapping, name, data["icon"]["url"])
lain's avatar
lain committed
322
      end)
lain's avatar
lain committed
323
324
325
326

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

327
    Map.put(object, "emoji", emoji)
lain's avatar
lain committed
328
329
  end

330
331
332
333
  def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
    name = String.trim(tag["name"], ":")
    emoji = %{name => tag["icon"]["url"]}

334
    Map.put(object, "emoji", emoji)
335
336
  end

337
  def fix_emoji(object), do: object
338

339
  def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
lain's avatar
lain committed
340
    tags =
341
      tag
lain's avatar
lain committed
342
343
      |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
      |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
344

345
    Map.put(object, "tag", tag ++ tags)
346
347
  end

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

351
    Map.put(object, "tag", combined)
352
353
  end

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

356
  def fix_tag(object), do: object
357

358
359
360
361
362
  # 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)

363
    Map.put(object, "content", content)
364
365
366
367
  end

  def fix_content_map(object), do: object

368
369
  def fix_type(object, options \\ [])

370
371
  def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
      when is_binary(reply_id) do
372
    with true <- Federator.allowed_thread_distance?(options[:depth]),
373
         {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
374
375
      Map.put(object, "type", "Answer")
    else
376
      _ -> object
377
378
379
    end
  end

380
  def fix_type(object, _), do: object
381

Maksim's avatar
Maksim committed
382
383
384
385
386
387
388
389
  defp fix_content(%{"mediaType" => "text/markdown", "content" => content} = object)
       when is_binary(content) do
    html_content =
      content
      |> Earmark.as_html!(%Earmark.Options{renderer: EarmarkRenderer})
      |> Pleroma.HTML.filter_tags()

    Map.merge(object, %{"content" => html_content, "mediaType" => "text/html"})
Maksim's avatar
Maksim committed
390
391
  end

Maksim's avatar
Maksim committed
392
  defp fix_content(object), do: object
Maksim's avatar
Maksim committed
393

Maksim's avatar
Maksim committed
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
  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

420
421
422
423
424
425
426
427
428
429
430
  # 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

431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
  # Compatibility wrapper for Mastodon votes
  defp handle_create(%{"object" => %{"type" => "Answer"}} = data, _user) do
    handle_incoming(data)
  end

  defp handle_create(%{"object" => object} = data, user) do
    %{
      to: data["to"],
      object: object,
      actor: user,
      context: object["context"],
      local: false,
      published: data["published"],
      additional:
        Map.take(data, [
          "cc",
          "directMessage",
          "id"
        ])
    }
    |> ActivityPub.create()
  end

454
455
  def handle_incoming(data, options \\ [])

456
457
  # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
  # with nil ID.
458
  def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
459
460
461
462
    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.
463
         %User{} = account <- get_reported(objects),
464
465
         # Remove the reported user from the object list.
         statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
466
      %{
467
468
469
470
471
        actor: actor,
        context: context,
        account: account,
        statuses: statuses,
        content: content,
472
        additional: %{"cc" => [account.ap_id]}
473
      }
474
      |> ActivityPub.flag()
475
476
477
    end
  end

478
  # disallow objects with bogus IDs
479
480
  def handle_incoming(%{"id" => nil}, _options), do: :error
  def handle_incoming(%{"id" => ""}, _options), do: :error
481
  # length of https:// = 8, should validate better, but good enough for now.
rinpatch's avatar
rinpatch committed
482
  def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
483
    do: :error
484

485
486
487
  # TODO: validate those with a Ecto scheme
  # - tags
  # - emoji
488
489
490
491
  def handle_incoming(
        %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
        options
      )
Haelwenn's avatar
Haelwenn committed
492
      when objtype in ["Article", "Event", "Note", "Video", "Page", "Audio"] do
493
    actor = Containment.get_actor(data)
494

495
    with nil <- Activity.get_create_by_object_ap_id(object["id"]),
496
497
498
499
500
501
502
503
         {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(actor) do
      data =
        data
        |> Map.put("object", fix_object(object, options))
        |> Map.put("actor", actor)
        |> fix_addressing()

      with {:ok, created_activity} <- handle_create(data, user) do
504
505
506
507
508
509
510
511
512
        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
513
514
515
516
        end

        {:ok, created_activity}
      end
517
    else
lain's avatar
lain committed
518
      %Activity{} = activity -> {:ok, activity}
519
520
521
522
      _e -> :error
    end
  end

523
524
525
526
527
528
529
530
531
532
533
  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
534
535
      reply_depth = (options[:depth] || 0) + 1
      options = Keyword.put(options, :depth, reply_depth)
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
      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

554
  def handle_incoming(
555
        %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
556
        _options
557
      ) do
558
    with actor <- Containment.get_actor(data),
559
         {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
560
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
561
         {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
562
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
563
         {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept) do
564
565
566
      User.update_follower_count(followed)
      User.update_following_count(follower)

567
568
      Notification.update_notification_type(followed, follow_activity)

569
570
571
572
573
      ActivityPub.accept(%{
        to: follow_activity.data["to"],
        type: "Accept",
        actor: followed,
        object: follow_activity.data["id"],
574
575
        local: false,
        activity_id: id
576
      })
577
    else
578
579
      _e ->
        :error
580
581
582
583
    end
  end

  def handle_incoming(
584
        %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
585
        _options
586
      ) do
587
    with actor <- Containment.get_actor(data),
588
         {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
589
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
590
         {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
591
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
592
         {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_reject),
lain's avatar
lain committed
593
         {:ok, activity} <-
594
           ActivityPub.reject(%{
lain's avatar
lain committed
595
             to: follow_activity.data["to"],
596
             type: "Reject",
597
             actor: followed,
lain's avatar
lain committed
598
             object: follow_activity.data["id"],
599
600
             local: false,
             activity_id: id
lain's avatar
lain committed
601
           }) do
602
      {:ok, activity}
603
604
    else
      _e -> :error
605
606
607
    end
  end

608
609
610
611
612
613
614
615
616
617
  @misskey_reactions %{
    "like" => "👍",
    "love" => "❤️",
    "laugh" => "😆",
    "hmm" => "🤔",
    "surprise" => "😮",
    "congrats" => "🎉",
    "angry" => "💢",
    "confused" => "😥",
    "rip" => "😇",
618
619
    "pudding" => "🍮",
    "star" => "⭐"
620
621
  }

lain's avatar
lain committed
622
  @doc "Rewrite misskey likes into EmojiReacts"
623
624
625
626
627
628
629
630
  def handle_incoming(
        %{
          "type" => "Like",
          "_misskey_reaction" => reaction
        } = data,
        options
      ) do
    data
lain's avatar
lain committed
631
    |> Map.put("type", "EmojiReact")
632
    |> Map.put("content", @misskey_reactions[reaction] || reaction)
633
634
635
    |> handle_incoming(options)
  end

Haelwenn's avatar
Haelwenn committed
636
  def handle_incoming(
lain's avatar
lain committed
637
        %{"type" => "Create", "object" => %{"type" => objtype}} = data,
Haelwenn's avatar
Haelwenn committed
638
        _options
Haelwenn's avatar
Haelwenn committed
639
      )
lain's avatar
lain committed
640
      when objtype in ["Question", "Answer", "ChatMessage"] do
Haelwenn's avatar
Haelwenn committed
641
642
643
644
645
646
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
         {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
      {:ok, activity}
    end
  end

647
  def handle_incoming(%{"type" => type} = data, _options)
648
      when type in ~w{Like EmojiReact Announce} do
lain's avatar
lain committed
649
650
651
    with :ok <- ObjectValidator.fetch_actor_and_object(data),
         {:ok, activity, _meta} <-
           Pipeline.common_pipeline(data, local: false) do
lain's avatar
lain committed
652
653
      {:ok, activity}
    else
654
      e -> {:error, e}
lain's avatar
lain committed
655
656
657
    end
  end

lain's avatar
lain committed
658
  def handle_incoming(
659
        %{"type" => type} = data,
660
        _options
661
      )
662
      when type in ~w{Update Block Follow} do
663
664
665
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
         {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
      {:ok, activity}
lain's avatar
lain committed
666
667
668
    end
  end

lain's avatar
lain committed
669
  def handle_incoming(
670
        %{"type" => "Delete"} = data,
671
        _options
lain's avatar
lain committed
672
      ) do
673
    with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
lain's avatar
lain committed
674
      {:ok, activity}
675
676
677
    else
      {:error, {:validate_object, _}} = e ->
        # Check if we have a create activity for this
678
        with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
679
680
681
682
683
684
685
686
687
             %Activity{data: %{"actor" => actor}} <-
               Activity.create_by_object_ap_id(object_id) |> Repo.one(),
             # We have one, insert a tombstone and retry
             {:ok, tombstone_data, _} <- Builder.tombstone(actor, object_id),
             {:ok, _tombstone} <- Object.create(tombstone_data) do
          handle_incoming(data)
        else
          _ -> e
        end
lain's avatar
lain committed
688
689
690
    end
  end

normandy's avatar
normandy committed
691
692
693
694
695
696
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Follow", "object" => followed},
          "actor" => follower,
          "id" => id
697
698
        } = _data,
        _options
normandy's avatar
normandy committed
699
      ) do
normandy's avatar
normandy committed
700
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
701
         {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
normandy's avatar
normandy committed
702
         {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
normandy's avatar
normandy committed
703
704
705
      User.unfollow(follower, followed)
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
706
      _e -> :error
normandy's avatar
normandy committed
707
708
709
    end
  end

710
711
712
  def handle_incoming(
        %{
          "type" => "Undo",
713
          "object" => %{"type" => type}
714
715
        } = data,
        _options
716
      )
717
      when type in ["Like", "EmojiReact", "Announce", "Block"] do
718
    with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
719
720
721
722
      {:ok, activity}
    end
  end

723
  # For Undos that don't have the complete object attached, try to find it in our database.
normandy's avatar
normandy committed
724
725
726
  def handle_incoming(
        %{
          "type" => "Undo",
727
728
729
730
731
732
733
734
735
          "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)
normandy's avatar
normandy committed
736
    else
Maksim's avatar
Maksim committed
737
      _e -> :error
normandy's avatar
normandy committed
738
739
740
    end
  end

minibikini's avatar
minibikini committed
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
  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

759
  def handle_incoming(_, _), do: :error
760

761
  @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
762
  def get_obj_helper(id, options \\ []) do
Maksim's avatar
Maksim committed
763
764
765
    case Object.normalize(id, true, options) do
      %Object{} = object -> {:ok, object}
      _ -> nil
766
    end
767
768
  end

769
  @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
Thibaut Girka's avatar
Thibaut Girka committed
770
  def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
771
772
        ap_id: ap_id
      })
Thibaut Girka's avatar
Thibaut Girka committed
773
      when attributed_to == ap_id do
774
775
776
777
778
    with {:ok, activity} <-
           handle_incoming(%{
             "type" => "Create",
             "to" => data["to"],
             "cc" => data["cc"],
Thibaut Girka's avatar
Thibaut Girka committed
779
             "actor" => attributed_to,
780
781
782
783
784
785
786
787
788
789
790
791
             "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

792
793
794
795
  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)
796
797
798
799
    else
      _e -> object
    end
  end
lain's avatar
lain committed
800

801
802
  def set_reply_to_uri(obj), do: obj

803
804
805
806
  @doc """
  Serialized Mastodon-compatible `replies` collection containing _self-replies_.
  Based on Mastodon's ActivityPub::NoteSerializer#replies.
  """
807
  def set_replies(obj_data) do
808
    replies_uris =
Ivan Tashkinov's avatar
Ivan Tashkinov committed
809
810
      with limit when limit > 0 <-
             Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
811
812
813
814
           %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
        object
        |> Object.self_replies()
        |> select([o], fragment("?->>'id'", o.data))
815
816
        |> limit(^limit)
        |> Repo.all()
Ivan Tashkinov's avatar
Ivan Tashkinov committed
817
818
      else
        _ -> []
819
820
      end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
821
    set_replies(obj_data, replies_uris)
822
823
  end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
824
  defp set_replies(obj, []) do
825
826
827
828
829
830
    obj
  end

  defp set_replies(obj, replies_uris) do
    replies_collection = %{
      "type" => "Collection",
831
      "items" => replies_uris
832
833
834
835
836
    }

    Map.merge(obj, %{"replies" => replies_collection})
  end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
837
838
839
  def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
    items
  end
840

Ivan Tashkinov's avatar
Ivan Tashkinov committed
841
842
  def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
    items
843
844
845
846
  end

  def replies(_), do: []

847
  # Prepares the object of an outgoing create activity.
lain's avatar
lain committed
848
849
  def prepare_object(object) do
    object
lain's avatar
lain committed
850
    |> set_sensitive
lain's avatar
lain committed
851
    |> add_hashtags
lain's avatar
lain committed
852
    |> add_mention_tags
lain's avatar
lain committed
853
    |> add_emoji_tags
lain's avatar
lain committed
854
    |> add_attributed_to
lain's avatar
lain committed
855
    |> prepare_attachments
lain's avatar
lain committed
856
    |> set_conversation
857
    |> set_reply_to_uri
858
    |> set_replies
859
860
    |> strip_internal_fields
    |> strip_internal_tags
861
    |> set_type
lain's avatar
lain committed
862
863
  end

feld's avatar
feld committed
864
865
866
867
  #  @doc
  #  """
  #  internal -> Mastodon
  #  """
lain's avatar
lain committed
868

869
870
  def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
      when activity_type in ["Create", "Listen"] do
lain's avatar
lain committed
871
    object =
minibikini's avatar
minibikini committed
872
873
874
      object_id
      |> Object.normalize()
      |> Map.get(:data)
lain's avatar
lain committed
875
876
877
878
879
      |> prepare_object

    data =
      data
      |> Map.put("object", object)
lain's avatar
lain committed
880
      |> Map.merge(Utils.make_json_ld_header())
minibikini's avatar
minibikini committed
881
      |> Map.delete("bcc")
lain's avatar
lain committed
882
883
884
885

    {:ok, data}
  end

886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
  def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
    object =
      object_id
      |> Object.normalize()

    data =
      if Visibility.is_private?(object) && object.data["actor"] == ap_id do
        data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
      else
        data |> maybe_fix_object_url
      end

    data =
      data
      |> strip_internal_fields
      |> Map.merge(Utils.make_json_ld_header())
      |> Map.delete("bcc")

    {:ok, data}
  end

kaniini's avatar
kaniini committed
907
908
909
  # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
  # because of course it does.
  def prepare_outgoing(%{"type" => "Accept"} = data) do
910
    with follow_activity <- Activity.normalize(data["object"]) do
kaniini's avatar
kaniini committed
911
912
913
914
915
916
917
918
919
920
      object = %{
        "actor" => follow_activity.actor,
        "object" => follow_activity.data["object"],
        "id" => follow_activity.data["id"],
        "type" => "Follow"
      }

      data =
        data
        |> Map.put("object", object)
lain's avatar
lain committed
921
        |> Map.merge(Utils.make_json_ld_header())
kaniini's avatar
kaniini committed
922
923
924
925
926

      {:ok, data}
    end
  end

927
  def prepare_outgoing(%{"type" => "Reject"} = data) do
928
    with follow_activity <- Activity.normalize(data["object"]) do
929
930
931
932
933
934
935
936
937
938
      object = %{
        "actor" => follow_activity.actor,
        "object" => follow_activity.data["object"],
        "id" => follow_activity.data["id"],
        "type" => "Follow"
      }

      data =
        data
        |> Map.put("object", object)
lain's avatar
lain committed
939
        |> Map.merge(Utils.make_json_ld_header())
940
941
942
943
944

      {:ok, data}
    end
  end

feld's avatar
feld committed
945
  def prepare_outgoing(%{"type" => _type} = data) do
lain's avatar
lain committed
946
947
    data =
      data
948
      |> strip_internal_fields
lain's avatar
lain committed
949
      |> maybe_fix_object_url
lain's avatar
lain committed
950
      |> Map.merge(Utils.make_json_ld_header())
951
952
953
954

    {:ok, data}
  end

955
956
957
958
959
960
  def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
    with false <- String.starts_with?(object, "http"),
         {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
         %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
           relative_object do
      Map.put(data, "object", external_url)
961
    else
962
963
964
965
966
967
      {:fetch, e} ->
        Logger.error("Couldn't fetch #{object} #{inspect(e)}")
        data

      _ ->
        data
968
969
970
    end
  end

971
972
  def maybe_fix_object_url(data), do: data

lain's avatar
lain committed
973
  def add_hashtags(object) do
lain's avatar
lain committed
974
975
    tags =
      (object["tag"] || [])
976
977
978
979
980
981
982
983
984
985
986
987
      |> Enum.map(fn
        # Expand internal representation tags into AS2 tags.
        tag when is_binary(tag) ->