transmogrifier.ex 28.7 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.Maps
Haelwenn's avatar
Haelwenn committed
13
  alias Pleroma.Object
rinpatch's avatar
rinpatch committed
14
  alias Pleroma.Object.Containment
Haelwenn's avatar
Haelwenn committed
15
  alias Pleroma.Repo
16
  alias Pleroma.User
Haelwenn's avatar
Haelwenn committed
17
  alias Pleroma.Web.ActivityPub.ActivityPub
18
  alias Pleroma.Web.ActivityPub.Builder
19
20
  alias Pleroma.Web.ActivityPub.ObjectValidator
  alias Pleroma.Web.ActivityPub.Pipeline
Haelwenn's avatar
Haelwenn committed
21
  alias Pleroma.Web.ActivityPub.Utils
lain's avatar
lain committed
22
  alias Pleroma.Web.ActivityPub.Visibility
23
  alias Pleroma.Web.Federator
24
  alias Pleroma.Workers.TransmogrifierWorker
25

lain's avatar
lain committed
26
27
  import Ecto.Query

28
  require Logger
29
  require Pleroma.Constants
30

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

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

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

60
  def fix_summary(object), do: Map.put(object, "summary", "")
61
62

  def fix_addressing_list(map, field) do
63
64
    addrs = map[field]

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

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

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

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

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

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

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

96
  def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object
97

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

101
  def fix_explicit_addressing(object) do
102
    explicit_mentions = Utils.determine_explicit_mentions(object)
103

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

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

116
    fix_explicit_addressing(object, explicit_mentions, follower_collection)
lain's avatar
lain committed
117
118
  end

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

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

        true ->
          object
      end
137
    else
138
      object
139
140
141
    end
  end

142
143
  def fix_implicit_addressing(object, _), do: object

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

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

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

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

166
167
168
  def fix_in_reply_to(object, options \\ [])

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

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

190
  def fix_in_reply_to(object, _options), do: object
lain's avatar
lain committed
191

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

lain's avatar
lain committed
211
    object
Haelwenn's avatar
Haelwenn committed
212
    |> Map.put("context", context)
213
    |> Map.drop(["conversation"])
lain's avatar
lain committed
214
215
  end

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

        media_type =
          cond do
228
229
230
            is_map(url) && MIME.valid?(url["mediaType"]) -> url["mediaType"]
            MIME.valid?(data["mediaType"]) -> data["mediaType"]
            MIME.valid?(data["mimeType"]) -> data["mimeType"]
231
232
233
234
235
236
237
238
            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
239
            true -> nil
240
241
          end

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

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

262
    Map.put(object, "attachment", attachments)
263
264
  end

265
  def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
Maksim's avatar
Maksim committed
266
267
268
    object
    |> Map.put("attachment", [attachment])
    |> fix_attachments()
269
270
  end

271
  def fix_attachments(object), do: object
272

273
  def fix_url(%{"url" => url} = object) when is_map(url) do
274
    Map.put(object, "url", url["href"])
275
276
  end

Haelwenn's avatar
Haelwenn committed
277
  def fix_url(%{"type" => "Video", "url" => url} = object) when is_list(url) do
Haelwenn's avatar
Haelwenn committed
278
279
280
    attachment =
      Enum.find(url, fn x ->
        media_type = x["mediaType"] || x["mimeType"] || ""
281

Haelwenn's avatar
Haelwenn committed
282
        is_map(x) and String.starts_with?(media_type, "video/")
Haelwenn's avatar
Haelwenn committed
283
284
285
286
      end)

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

    object
Haelwenn's avatar
Haelwenn committed
289
    |> Map.put("attachment", [attachment])
290
291
292
293
294
    |> 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
295
296
297
298
299
300
301
302
303
    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

304
    Map.put(object, "url", url_string)
305
306
307
308
  end

  def fix_url(object), do: object

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

316
        Map.put(mapping, name, data["icon"]["url"])
lain's avatar
lain committed
317
      end)
lain's avatar
lain committed
318

319
    Map.put(object, "emoji", emoji)
lain's avatar
lain committed
320
321
  end

322
323
324
325
  def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
    name = String.trim(tag["name"], ":")
    emoji = %{name => tag["icon"]["url"]}

326
    Map.put(object, "emoji", emoji)
327
328
  end

329
  def fix_emoji(object), do: object
330

331
  def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
lain's avatar
lain committed
332
    tags =
333
      tag
lain's avatar
lain committed
334
335
      |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
      |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
336

337
    Map.put(object, "tag", tag ++ tags)
338
339
  end

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

343
    Map.put(object, "tag", combined)
344
345
  end

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

348
  def fix_tag(object), do: object
349

350
351
352
353
354
  # 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)

355
    Map.put(object, "content", content)
356
357
358
359
  end

  def fix_content_map(object), do: object

360
361
  def fix_type(object, options \\ [])

362
363
  def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
      when is_binary(reply_id) do
364
    with true <- Federator.allowed_thread_distance?(options[:depth]),
365
         {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
366
367
      Map.put(object, "type", "Answer")
    else
368
      _ -> object
369
370
371
    end
  end

372
  def fix_type(object, _), do: object
373

Maksim's avatar
Maksim committed
374
375
376
377
378
379
380
381
  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
382
383
  end

Maksim's avatar
Maksim committed
384
  defp fix_content(object), do: object
Maksim's avatar
Maksim committed
385

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
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
  # 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

420
421
  def handle_incoming(data, options \\ [])

422
423
  # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
  # with nil ID.
424
  def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
425
426
427
428
    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.
429
         %User{} = account <- get_reported(objects),
430
431
         # Remove the reported user from the object list.
         statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
432
      %{
433
434
435
436
437
        actor: actor,
        context: context,
        account: account,
        statuses: statuses,
        content: content,
438
        additional: %{"cc" => [account.ap_id]}
439
      }
440
      |> ActivityPub.flag()
441
442
443
    end
  end

444
  # disallow objects with bogus IDs
445
446
  def handle_incoming(%{"id" => nil}, _options), do: :error
  def handle_incoming(%{"id" => ""}, _options), do: :error
447
  # length of https:// = 8, should validate better, but good enough for now.
rinpatch's avatar
rinpatch committed
448
  def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
449
    do: :error
450

451
452
453
  # TODO: validate those with a Ecto scheme
  # - tags
  # - emoji
454
455
456
457
  def handle_incoming(
        %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
        options
      )
Haelwenn's avatar
Haelwenn committed
458
      when objtype in ~w{Article Note Video Page} do
459
    actor = Containment.get_actor(data)
460

461
    with nil <- Activity.get_create_by_object_ap_id(object["id"]),
462
463
464
465
466
467
468
469
         {: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
470
471
472
473
474
475
476
477
478
        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
479
480
481
482
        end

        {:ok, created_activity}
      end
483
    else
lain's avatar
lain committed
484
      %Activity{} = activity -> {:ok, activity}
485
486
487
488
      _e -> :error
    end
  end

489
490
491
492
493
494
495
496
497
498
499
  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
500
501
      reply_depth = (options[:depth] || 0) + 1
      options = Keyword.put(options, :depth, reply_depth)
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
      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

520
521
522
523
524
525
526
527
528
529
  @misskey_reactions %{
    "like" => "👍",
    "love" => "❤️",
    "laugh" => "😆",
    "hmm" => "🤔",
    "surprise" => "😮",
    "congrats" => "🎉",
    "angry" => "💢",
    "confused" => "😥",
    "rip" => "😇",
530
531
    "pudding" => "🍮",
    "star" => "⭐"
532
533
  }

lain's avatar
lain committed
534
  @doc "Rewrite misskey likes into EmojiReacts"
535
536
537
538
539
540
541
542
  def handle_incoming(
        %{
          "type" => "Like",
          "_misskey_reaction" => reaction
        } = data,
        options
      ) do
    data
lain's avatar
lain committed
543
    |> Map.put("type", "EmojiReact")
544
    |> Map.put("content", @misskey_reactions[reaction] || reaction)
545
546
547
    |> handle_incoming(options)
  end

Haelwenn's avatar
Haelwenn committed
548
  def handle_incoming(
lain's avatar
lain committed
549
        %{"type" => "Create", "object" => %{"type" => objtype}} = data,
Haelwenn's avatar
Haelwenn committed
550
        _options
Haelwenn's avatar
Haelwenn committed
551
      )
Haelwenn's avatar
Haelwenn committed
552
      when objtype in ~w{Question Answer ChatMessage Audio Event} do
Haelwenn's avatar
Haelwenn committed
553
554
555
556
557
558
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
         {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
      {:ok, activity}
    end
  end

559
  def handle_incoming(%{"type" => type} = data, _options)
560
      when type in ~w{Like EmojiReact Announce} do
lain's avatar
lain committed
561
562
563
    with :ok <- ObjectValidator.fetch_actor_and_object(data),
         {:ok, activity, _meta} <-
           Pipeline.common_pipeline(data, local: false) do
lain's avatar
lain committed
564
565
      {:ok, activity}
    else
566
      e -> {:error, e}
lain's avatar
lain committed
567
568
569
    end
  end

lain's avatar
lain committed
570
  def handle_incoming(
571
        %{"type" => type} = data,
572
        _options
573
      )
574
      when type in ~w{Update Block Follow Accept Reject} do
575
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
576
577
         {:ok, activity, _} <-
           Pipeline.common_pipeline(data, local: false) do
578
      {:ok, activity}
lain's avatar
lain committed
579
580
581
    end
  end

lain's avatar
lain committed
582
  def handle_incoming(
583
        %{"type" => "Delete"} = data,
584
        _options
lain's avatar
lain committed
585
      ) do
586
587
    with {:ok, activity, _} <-
           Pipeline.common_pipeline(data, local: false) do
lain's avatar
lain committed
588
      {:ok, activity}
589
590
591
    else
      {:error, {:validate_object, _}} = e ->
        # Check if we have a create activity for this
592
        with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
593
594
595
596
597
598
599
600
601
             %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
602
603
604
    end
  end

normandy's avatar
normandy committed
605
606
607
608
609
610
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Follow", "object" => followed},
          "actor" => follower,
          "id" => id
611
612
        } = _data,
        _options
normandy's avatar
normandy committed
613
      ) do
normandy's avatar
normandy committed
614
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
615
         {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
normandy's avatar
normandy committed
616
         {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
normandy's avatar
normandy committed
617
618
619
      User.unfollow(follower, followed)
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
620
      _e -> :error
normandy's avatar
normandy committed
621
622
623
    end
  end

624
625
626
  def handle_incoming(
        %{
          "type" => "Undo",
627
          "object" => %{"type" => type}
628
629
        } = data,
        _options
630
      )
631
      when type in ["Like", "EmojiReact", "Announce", "Block"] do
632
    with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
633
634
635
636
      {:ok, activity}
    end
  end

637
  # For Undos that don't have the complete object attached, try to find it in our database.
normandy's avatar
normandy committed
638
639
640
  def handle_incoming(
        %{
          "type" => "Undo",
641
642
643
644
645
646
647
648
649
          "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
650
    else
Maksim's avatar
Maksim committed
651
      _e -> :error
normandy's avatar
normandy committed
652
653
654
    end
  end

minibikini's avatar
minibikini committed
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
  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

673
  def handle_incoming(_, _), do: :error
674

675
  @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
676
  def get_obj_helper(id, options \\ []) do
Maksim's avatar
Maksim committed
677
678
679
    case Object.normalize(id, true, options) do
      %Object{} = object -> {:ok, object}
      _ -> nil
680
    end
681
682
  end

683
  @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
Thibaut Girka's avatar
Thibaut Girka committed
684
  def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
685
686
        ap_id: ap_id
      })
Thibaut Girka's avatar
Thibaut Girka committed
687
      when attributed_to == ap_id do
688
689
690
691
692
    with {:ok, activity} <-
           handle_incoming(%{
             "type" => "Create",
             "to" => data["to"],
             "cc" => data["cc"],
Thibaut Girka's avatar
Thibaut Girka committed
693
             "actor" => attributed_to,
694
695
696
697
698
699
700
701
702
703
704
705
             "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

706
707
708
709
  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)
710
711
712
713
    else
      _e -> object
    end
  end
lain's avatar
lain committed
714

715
716
  def set_reply_to_uri(obj), do: obj

717
718
719
720
  @doc """
  Serialized Mastodon-compatible `replies` collection containing _self-replies_.
  Based on Mastodon's ActivityPub::NoteSerializer#replies.
  """
721
  def set_replies(obj_data) do
722
    replies_uris =
Ivan Tashkinov's avatar
Ivan Tashkinov committed
723
724
      with limit when limit > 0 <-
             Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
725
726
727
728
           %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
        object
        |> Object.self_replies()
        |> select([o], fragment("?->>'id'", o.data))
729
730
        |> limit(^limit)
        |> Repo.all()
Ivan Tashkinov's avatar
Ivan Tashkinov committed
731
732
      else
        _ -> []
733
734
      end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
735
    set_replies(obj_data, replies_uris)
736
737
  end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
738
  defp set_replies(obj, []) do
739
740
741
742
743
744
    obj
  end

  defp set_replies(obj, replies_uris) do
    replies_collection = %{
      "type" => "Collection",
745
      "items" => replies_uris
746
747
748
749
750
    }

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

Ivan Tashkinov's avatar
Ivan Tashkinov committed
751
752
753
  def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
    items
  end
754

Ivan Tashkinov's avatar
Ivan Tashkinov committed
755
756
  def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
    items
757
758
759
760
  end

  def replies(_), do: []

761
  # Prepares the object of an outgoing create activity.
lain's avatar
lain committed
762
763
  def prepare_object(object) do
    object
lain's avatar
lain committed
764
    |> set_sensitive
lain's avatar
lain committed
765
    |> add_hashtags
lain's avatar
lain committed
766
    |> add_mention_tags
lain's avatar
lain committed
767
    |> add_emoji_tags
lain's avatar
lain committed
768
    |> add_attributed_to
lain's avatar
lain committed
769
    |> prepare_attachments
lain's avatar
lain committed
770
    |> set_conversation
771
    |> set_reply_to_uri
772
    |> set_replies
773
774
    |> strip_internal_fields
    |> strip_internal_tags
775
    |> set_type
lain's avatar
lain committed
776
777
  end

feld's avatar
feld committed
778
779
780
781
  #  @doc
  #  """
  #  internal -> Mastodon
  #  """
lain's avatar
lain committed
782

783
784
  def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
      when activity_type in ["Create", "Listen"] do
lain's avatar
lain committed
785
    object =
minibikini's avatar
minibikini committed
786
787
788
      object_id
      |> Object.normalize()
      |> Map.get(:data)
lain's avatar
lain committed
789
790
791
792
793
      |> prepare_object

    data =
      data
      |> Map.put("object", object)
lain's avatar
lain committed
794
      |> Map.merge(Utils.make_json_ld_header())
minibikini's avatar
minibikini committed
795
      |> Map.delete("bcc")
lain's avatar
lain committed
796
797
798
799

    {:ok, data}
  end

800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
  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
821
822
823
  # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
  # because of course it does.
  def prepare_outgoing(%{"type" => "Accept"} = data) do
824
    with follow_activity <- Activity.normalize(data["object"]) do
kaniini's avatar
kaniini committed
825
826
827
828
829
830
831
832
833
834
      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
835
        |> Map.merge(Utils.make_json_ld_header())
kaniini's avatar
kaniini committed
836
837
838
839
840

      {:ok, data}
    end
  end

841
  def prepare_outgoing(%{"type" => "Reject"} = data) do
842
    with follow_activity <- Activity.normalize(data["object"]) do
843
844
845
846
847
848
849
850
851
852
      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
853
        |> Map.merge(Utils.make_json_ld_header())
854
855
856
857
858

      {:ok, data}
    end
  end

feld's avatar
feld committed
859
  def prepare_outgoing(%{"type" => _type} = data) do
lain's avatar
lain committed
860
861
    data =
      data
862
      |> strip_internal_fields
lain's avatar
lain committed
863
      |> maybe_fix_object_url
lain's avatar
lain committed
864
      |> Map.merge(Utils.make_json_ld_header())
865
866
867
868

    {:ok, data}
  end

869
870
871
872
873
874
  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)
875
    else
876
877
878
879
880
881
      {:fetch, e} ->
        Logger.error("Couldn't fetch #{object} #{inspect(e)}")
        data

      _ ->
        data
882
883
884
    end
  end

885
886
  def maybe_fix_object_url(data), do: data

lain's avatar
lain committed
887
  def add_hashtags(object) do
lain's avatar
lain committed
888
889
    tags =
      (object["tag"] || [])
890
891
892
893
894
895
896
897
898
899
900
901
      |> Enum.map(fn
        # Expand internal representation tags into AS2 tags.
        tag when is_binary(tag) ->
          %{
            "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
            "name" => "##{tag}",
            "type" => "Hashtag"
          }

        # Do not process tags which are already AS2 tag objects.
        tag when is_map(tag) ->
          tag
lain's avatar
lain committed
902
      end)
lain's avatar
lain committed
903

904
    Map.put(object, "tag", tags)
lain's avatar
lain committed
905
906
  end

907
908
  # TODO These should be added on our side on insertion, it doesn't make much
  # sense to regenerate these all the time
lain's avatar
lain committed
909
  def add_mention_tags(object) do
910
911
912
913
914
    to = object["to"] || []
    cc = object["cc"] || []
    mentioned = User.get_users_from_set(to ++ cc, local_only: false)

    mentions = Enum.map(mentioned, &build_mention_tag/1)
lain's avatar
lain committed
915

lain's avatar
lain committed
916
    tags = object["tag"] || []
917
    Map.put(object, "tag", tags ++ mentions)
lain's avatar
lain committed
918
919
  end

Maksim's avatar
Maksim committed
920
921
922
  defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
    %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
  end
Haelwenn's avatar
Haelwenn committed
923

924
  def take_emoji_tags(%User{emoji: emoji}) do
Maksim's avatar
Maksim committed
925
    emoji
926
    |> Map.to_list()
Maksim's avatar
Maksim committed
927
    |> Enum.map(&build_emoji_tag/1)
Haelwenn's avatar
Haelwenn committed
928
929
  end

lain's avatar
lain committed
930
  # TODO: we should probably send mtime instead of unix epoch time for updated
Haelwenn's avatar
Haelwenn committed
931
  def add_emoji_tags(%{"emoji" => emoji} = object) do
lain's avatar
lain committed
932
    tags = object["tag"] || []
lain's avatar
lain committed
933

Maksim's avatar
Maksim committed
934
    out = Enum.map(emoji, &build_emoji_tag/1)
lain's avatar
lain committed
935

936
    Map.put(object, "tag", tags ++ out)
lain's avatar
lain committed
937
938
  end

939
  def add_emoji_tags(object), do: object
Haelwenn's avatar
Haelwenn committed
940

Maksim's avatar
Maksim committed
941
942
943
944
945
946
947
948
949
950
  defp build_emoji_tag({name, url}) do
    %{
      "icon" => %{"url" => url, "type" => "Image"},
      "name" => ":" <> name <> ":",
      "type" => "Emoji",
      "updated" => "1970-01-01T00:00:00Z",
      "id" => url
    }
  end

lain's avatar
lain committed
951
952
953
954
  def set_conversation(object) do
    Map.put(object, "conversation", object["context"])
  end

955
956
957
958
  def set_sensitive(%{"sensitive" => true} = object) do
    object
  end

lain's avatar
lain committed
959
960
961
962
963
  def set_sensitive(object) do
    tags = object["tag"] || []
    Map.put(object, "sensitive", "nsfw" in tags)
  end

964
965
966
967
968
969
  def set_type(%{"type" => "Answer"} = object) do
    Map.put(object, "type", "Note")
  end

  def set_type(object), do: object

lain's avatar
lain committed
970
  def add_attributed_to(object) do
971
    attributed_to = object["attributedTo"] || object["actor"]
972
    Map.put(object, "attributedTo", attributed_to)
973
  end
lain's avatar
lain committed
974

975
976
977
  # TODO: Revisit this
  def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object

lain's avatar
lain committed
978
  def prepare_attachments(object) do
lain's avatar
lain committed
979
    attachments =
Maksim's avatar
Maksim committed
980
981
      object
      |> Map.get("attachment", [])
lain's avatar
lain committed
982
983
      |> Enum.map(fn data ->
        [%{"mediaType" => media_type, "href" => href} | _] = data["url"]