transmogrifier.ex 28 KB
Newer Older
1
# Pleroma: A lightweight social networking server
Haelwenn's avatar
Haelwenn committed
2
# Copyright © 2017-2021 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.EctoType.ActivityPub.ObjectValidators
11
  alias Pleroma.Maps
Haelwenn's avatar
Haelwenn committed
12
  alias Pleroma.Object
rinpatch's avatar
rinpatch committed
13
  alias Pleroma.Object.Containment
Haelwenn's avatar
Haelwenn committed
14
  alias Pleroma.Repo
15
  alias Pleroma.User
Haelwenn's avatar
Haelwenn committed
16
  alias Pleroma.Web.ActivityPub.ActivityPub
17
  alias Pleroma.Web.ActivityPub.Builder
18
19
  alias Pleroma.Web.ActivityPub.ObjectValidator
  alias Pleroma.Web.ActivityPub.Pipeline
Haelwenn's avatar
Haelwenn committed
20
  alias Pleroma.Web.ActivityPub.Utils
lain's avatar
lain committed
21
  alias Pleroma.Web.ActivityPub.Visibility
22
  alias Pleroma.Web.Federator
23
  alias Pleroma.Workers.TransmogrifierWorker
24

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

27
  require Logger
28
  require Pleroma.Constants
29

30
31
32
  @doc """
  Modifies an incoming AP object (mastodon format) to our internal format.
  """
33
  def fix_object(object, options \\ []) do
34
    object
35
36
37
38
39
    |> strip_internal_fields()
    |> fix_actor()
    |> fix_url()
    |> fix_attachments()
    |> fix_context()
40
    |> fix_in_reply_to(options)
41
42
43
44
45
    |> fix_emoji()
    |> fix_tag()
    |> fix_content_map()
    |> fix_addressing()
    |> fix_summary()
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
    addrs = map[field]

62
    cond do
63
64
      is_list(addrs) ->
        Map.put(map, field, Enum.filter(addrs, &is_binary/1))
65

66
67
      is_binary(addrs) ->
        Map.put(map, field, [addrs])
68
69

      true ->
70
        Map.put(map, field, [])
71
72
73
    end
  end

74
75
76
  # if directMessage flag is set to true, leave the addressing alone
  def fix_explicit_addressing(%{"directMessage" => true} = object, _follower_collection),
    do: object
77

78
79
80
81
82
83
  def fix_explicit_addressing(%{"to" => to, "cc" => cc} = object, follower_collection) do
    explicit_mentions =
      Utils.determine_explicit_mentions(object) ++
        [Pleroma.Constants.as_public(), follower_collection]

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

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

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

97
98
99
100
101
102
103
  # 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
104
        Pleroma.Constants.as_public() in cc ->
105
106
107
          to = to ++ [followers_collection]
          Map.put(object, "to", to)

108
        Pleroma.Constants.as_public() in to ->
109
110
111
112
113
114
          cc = cc ++ [followers_collection]
          Map.put(object, "cc", cc)

        true ->
          object
      end
115
    else
116
      object
117
118
119
    end
  end

120
  def fix_addressing(object) do
121
122
123
124
    {:ok, %User{follower_address: follower_collection}} =
      object
      |> Containment.get_actor()
      |> User.get_or_fetch_by_ap_id()
125

126
    object
127
128
129
130
    |> fix_addressing_list("to")
    |> fix_addressing_list("cc")
    |> fix_addressing_list("bto")
    |> fix_addressing_list("bcc")
131
132
    |> fix_explicit_addressing(follower_collection)
    |> fix_implicit_addressing(follower_collection)
lain's avatar
lain committed
133
134
  end

135
  def fix_actor(%{"attributedTo" => actor} = object) do
136
137
138
139
140
141
    actor = Containment.get_actor(%{"actor" => actor})

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

144
145
146
  def fix_in_reply_to(object, options \\ [])

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

151
    if Federator.allowed_thread_distance?(depth) do
152
      with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
minibikini's avatar
minibikini committed
153
           %Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
154
155
156
        object
        |> Map.put("inReplyTo", replied_object.data["id"])
        |> Map.put("context", replied_object.data["context"] || object["conversation"])
157
        |> Map.drop(["conversation", "inReplyToAtomUri"])
158
      else
159
        e ->
160
          Logger.warn("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
161
162
163
164
          object
      end
    else
      object
lain's avatar
lain committed
165
166
    end
  end
lain's avatar
lain committed
167

168
  def fix_in_reply_to(object, _options), do: object
lain's avatar
lain committed
169

170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
  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
186
  def fix_context(object) do
Haelwenn's avatar
Haelwenn committed
187
188
    context = object["context"] || object["conversation"] || Utils.generate_context_id()

lain's avatar
lain committed
189
    object
Haelwenn's avatar
Haelwenn committed
190
    |> Map.put("context", context)
191
    |> Map.drop(["conversation"])
lain's avatar
lain committed
192
193
  end

194
  def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
lain's avatar
lain committed
195
    attachments =
196
      Enum.map(attachment, fn data ->
197
198
199
200
201
202
203
204
205
        url =
          cond do
            is_list(data["url"]) -> List.first(data["url"])
            is_map(data["url"]) -> data["url"]
            true -> nil
          end

        media_type =
          cond do
206
207
208
            is_map(url) && MIME.valid?(url["mediaType"]) -> url["mediaType"]
            MIME.valid?(data["mediaType"]) -> data["mediaType"]
            MIME.valid?(data["mimeType"]) -> data["mimeType"]
209
210
211
212
213
214
215
216
            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
217
            true -> nil
218
219
          end

Haelwenn's avatar
Haelwenn committed
220
221
        if href do
          attachment_url =
Haelwenn's avatar
Haelwenn committed
222
223
224
225
            %{
              "href" => href,
              "type" => Map.get(url || %{}, "type", "Link")
            }
Haelwenn's avatar
Haelwenn committed
226
            |> Maps.put_if_present("mediaType", media_type)
227
228
            |> Maps.put_if_present("width", (url || %{})["width"] || data["width"])
            |> Maps.put_if_present("height", (url || %{})["height"] || data["height"])
229

Haelwenn's avatar
Haelwenn committed
230
231
232
233
          %{
            "url" => [attachment_url],
            "type" => data["type"] || "Document"
          }
Haelwenn's avatar
Haelwenn committed
234
235
          |> Maps.put_if_present("mediaType", media_type)
          |> Maps.put_if_present("name", data["name"])
236
          |> Maps.put_if_present("blurhash", data["blurhash"])
Haelwenn's avatar
Haelwenn committed
237
238
239
        else
          nil
        end
lain's avatar
lain committed
240
      end)
Haelwenn's avatar
Haelwenn committed
241
      |> Enum.filter(& &1)
lain's avatar
lain committed
242

243
    Map.put(object, "attachment", attachments)
244
245
  end

246
  def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
Maksim's avatar
Maksim committed
247
248
249
    object
    |> Map.put("attachment", [attachment])
    |> fix_attachments()
250
251
  end

252
  def fix_attachments(object), do: object
253

254
  def fix_url(%{"url" => url} = object) when is_map(url) do
255
    Map.put(object, "url", url["href"])
256
257
  end

Haelwenn's avatar
Haelwenn committed
258
  def fix_url(%{"url" => url} = object) when is_list(url) do
259
260
261
262
263
264
265
266
267
    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

268
    Map.put(object, "url", url_string)
269
270
271
272
  end

  def fix_url(object), do: object

273
  def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
lain's avatar
lain committed
274
    emoji =
275
      tags
276
      |> Enum.filter(fn data -> is_map(data) and data["type"] == "Emoji" and data["icon"] end)
lain's avatar
lain committed
277
      |> Enum.reduce(%{}, fn data, mapping ->
278
        name = String.trim(data["name"], ":")
lain's avatar
lain committed
279

280
        Map.put(mapping, name, data["icon"]["url"])
lain's avatar
lain committed
281
      end)
lain's avatar
lain committed
282

283
    Map.put(object, "emoji", emoji)
lain's avatar
lain committed
284
285
  end

286
287
288
289
  def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
    name = String.trim(tag["name"], ":")
    emoji = %{name => tag["icon"]["url"]}

290
    Map.put(object, "emoji", emoji)
291
292
  end

293
  def fix_emoji(object), do: object
294

295
  def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
296
    tags =
297
      tag
lain's avatar
lain committed
298
      |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
299
300
301
      |> Enum.map(fn
        %{"name" => "#" <> hashtag} -> String.downcase(hashtag)
        %{"name" => hashtag} -> String.downcase(hashtag)
302
      end)
303

304
    Map.put(object, "tag", tag ++ tags)
305
306
  end

307
308
309
310
  def fix_tag(%{"tag" => %{} = tag} = object) do
    object
    |> Map.put("tag", [tag])
    |> fix_tag
311
312
  end

313
  def fix_tag(object), do: object
314

315
316
317
318
319
  # 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)

320
    Map.put(object, "content", content)
321
322
323
324
  end

  def fix_content_map(object), do: object

325
326
327
  defp fix_type(%{"type" => "Note", "inReplyTo" => reply_id, "name" => _} = object, options)
       when is_binary(reply_id) do
    options = Keyword.put(options, :fetch, true)
328

329
    with %Object{data: %{"type" => "Question"}} <- Object.normalize(reply_id, options) do
330
331
      Map.put(object, "type", "Answer")
    else
332
      _ -> object
333
334
335
    end
  end

336
  defp fix_type(object, _options), do: object
337

338
339
340
341
342
343
344
345
346
347
348
  # 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

349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
  # 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

372
373
  def handle_incoming(data, options \\ [])

374
375
  # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
  # with nil ID.
376
  def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
377
378
379
380
    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.
381
         %User{} = account <- get_reported(objects),
382
383
         # Remove the reported user from the object list.
         statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
384
      %{
385
386
387
388
389
        actor: actor,
        context: context,
        account: account,
        statuses: statuses,
        content: content,
390
        additional: %{"cc" => [account.ap_id]}
391
      }
392
      |> ActivityPub.flag()
393
394
395
    end
  end

396
  # disallow objects with bogus IDs
397
398
  def handle_incoming(%{"id" => nil}, _options), do: :error
  def handle_incoming(%{"id" => ""}, _options), do: :error
399
  # length of https:// = 8, should validate better, but good enough for now.
rinpatch's avatar
rinpatch committed
400
  def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
401
    do: :error
402

403
404
405
  # TODO: validate those with a Ecto scheme
  # - tags
  # - emoji
406
  def handle_incoming(
Haelwenn's avatar
Haelwenn committed
407
        %{"type" => "Create", "object" => %{"type" => "Page"} = object} = data,
408
        options
Haelwenn's avatar
Haelwenn committed
409
      ) do
410
    actor = Containment.get_actor(data)
411

412
    with nil <- Activity.get_create_by_object_ap_id(object["id"]),
413
414
415
416
417
418
419
420
         {: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
421
422
423
424
425
426
427
428
429
        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
430
431
432
433
        end

        {:ok, created_activity}
      end
434
    else
lain's avatar
lain committed
435
      %Activity{} = activity -> {:ok, activity}
436
437
438
439
      _e -> :error
    end
  end

440
441
442
443
444
445
446
447
448
449
450
  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
451
452
      reply_depth = (options[:depth] || 0) + 1
      options = Keyword.put(options, :depth, reply_depth)
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
      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

471
472
473
474
475
476
477
478
479
480
  @misskey_reactions %{
    "like" => "👍",
    "love" => "❤️",
    "laugh" => "😆",
    "hmm" => "🤔",
    "surprise" => "😮",
    "congrats" => "🎉",
    "angry" => "💢",
    "confused" => "😥",
    "rip" => "😇",
481
482
    "pudding" => "🍮",
    "star" => "⭐"
483
484
  }

lain's avatar
lain committed
485
  @doc "Rewrite misskey likes into EmojiReacts"
486
487
488
489
490
491
492
493
  def handle_incoming(
        %{
          "type" => "Like",
          "_misskey_reaction" => reaction
        } = data,
        options
      ) do
    data
lain's avatar
lain committed
494
    |> Map.put("type", "EmojiReact")
495
    |> Map.put("content", @misskey_reactions[reaction] || reaction)
496
497
498
    |> handle_incoming(options)
  end

Haelwenn's avatar
Haelwenn committed
499
  def handle_incoming(
500
        %{"type" => "Create", "object" => %{"type" => objtype, "id" => obj_id}} = data,
Haelwenn's avatar
Haelwenn committed
501
        options
Haelwenn's avatar
Haelwenn committed
502
      )
Haelwenn's avatar
Haelwenn committed
503
      when objtype in ~w{Question Answer ChatMessage Audio Video Event Article Note} do
504
505
506
507
508
509
510
511
512
    fetch_options = Keyword.put(options, :depth, (options[:depth] || 0) + 1)

    object =
      data["object"]
      |> strip_internal_fields()
      |> fix_type(fetch_options)
      |> fix_in_reply_to(fetch_options)

    data = Map.put(data, "object", object)
Haelwenn's avatar
Haelwenn committed
513
    options = Keyword.put(options, :local, false)
514

Haelwenn's avatar
Haelwenn committed
515
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
516
         nil <- Activity.get_create_by_object_ap_id(obj_id),
Haelwenn's avatar
Haelwenn committed
517
         {:ok, activity, _} <- Pipeline.common_pipeline(data, options) do
Haelwenn's avatar
Haelwenn committed
518
      {:ok, activity}
519
520
521
    else
      %Activity{} = activity -> {:ok, activity}
      e -> e
Haelwenn's avatar
Haelwenn committed
522
523
524
    end
  end

525
  def handle_incoming(%{"type" => type} = data, _options)
Alexander Strizhakov's avatar
Alexander Strizhakov committed
526
      when type in ~w{Like EmojiReact Announce Add Remove} do
lain's avatar
lain committed
527
528
529
    with :ok <- ObjectValidator.fetch_actor_and_object(data),
         {:ok, activity, _meta} <-
           Pipeline.common_pipeline(data, local: false) do
lain's avatar
lain committed
530
531
      {:ok, activity}
    else
532
      e -> {:error, e}
lain's avatar
lain committed
533
534
535
    end
  end

lain's avatar
lain committed
536
  def handle_incoming(
537
        %{"type" => type} = data,
538
        _options
539
      )
540
      when type in ~w{Update Block Follow Accept Reject} do
541
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
542
543
         {:ok, activity, _} <-
           Pipeline.common_pipeline(data, local: false) do
544
      {:ok, activity}
lain's avatar
lain committed
545
546
547
    end
  end

lain's avatar
lain committed
548
  def handle_incoming(
549
        %{"type" => "Delete"} = data,
550
        _options
lain's avatar
lain committed
551
      ) do
552
553
    with {:ok, activity, _} <-
           Pipeline.common_pipeline(data, local: false) do
lain's avatar
lain committed
554
      {:ok, activity}
555
    else
Haelwenn's avatar
Haelwenn committed
556
      {:error, {:validate, _}} = e ->
557
        # Check if we have a create activity for this
558
        with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
559
560
561
562
563
564
565
566
567
             %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
568
569
570
    end
  end

normandy's avatar
normandy committed
571
572
573
574
575
576
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Follow", "object" => followed},
          "actor" => follower,
          "id" => id
577
578
        } = _data,
        _options
normandy's avatar
normandy committed
579
      ) do
normandy's avatar
normandy committed
580
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
581
         {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
normandy's avatar
normandy committed
582
         {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
normandy's avatar
normandy committed
583
584
585
      User.unfollow(follower, followed)
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
586
      _e -> :error
normandy's avatar
normandy committed
587
588
589
    end
  end

590
591
592
  def handle_incoming(
        %{
          "type" => "Undo",
593
          "object" => %{"type" => type}
594
595
        } = data,
        _options
596
      )
597
      when type in ["Like", "EmojiReact", "Announce", "Block"] do
598
    with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
599
600
601
602
      {:ok, activity}
    end
  end

603
  # For Undos that don't have the complete object attached, try to find it in our database.
normandy's avatar
normandy committed
604
605
606
  def handle_incoming(
        %{
          "type" => "Undo",
607
608
609
610
611
612
613
614
615
          "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
616
    else
Maksim's avatar
Maksim committed
617
      _e -> :error
normandy's avatar
normandy committed
618
619
620
    end
  end

minibikini's avatar
minibikini committed
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
  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

639
  def handle_incoming(_, _), do: :error
640

641
  @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
642
  def get_obj_helper(id, options \\ []) do
643
644
645
    options = Keyword.put(options, :fetch, true)

    case Object.normalize(id, options) do
Maksim's avatar
Maksim committed
646
647
      %Object{} = object -> {:ok, object}
      _ -> nil
648
    end
649
650
  end

651
  @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
Thibaut Girka's avatar
Thibaut Girka committed
652
  def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
653
654
        ap_id: ap_id
      })
Thibaut Girka's avatar
Thibaut Girka committed
655
      when attributed_to == ap_id do
656
657
658
659
660
    with {:ok, activity} <-
           handle_incoming(%{
             "type" => "Create",
             "to" => data["to"],
             "cc" => data["cc"],
Thibaut Girka's avatar
Thibaut Girka committed
661
             "actor" => attributed_to,
662
663
             "object" => data
           }) do
664
      {:ok, Object.normalize(activity, fetch: false)}
665
666
667
668
669
670
671
672
673
    else
      _ -> get_obj_helper(object_id)
    end
  end

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

674
675
676
677
  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)
678
679
680
681
    else
      _e -> object
    end
  end
lain's avatar
lain committed
682

683
684
  def set_reply_to_uri(obj), do: obj

685
686
687
688
  @doc """
  Serialized Mastodon-compatible `replies` collection containing _self-replies_.
  Based on Mastodon's ActivityPub::NoteSerializer#replies.
  """
689
  def set_replies(obj_data) do
690
    replies_uris =
Ivan Tashkinov's avatar
Ivan Tashkinov committed
691
692
      with limit when limit > 0 <-
             Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
693
694
695
696
           %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
        object
        |> Object.self_replies()
        |> select([o], fragment("?->>'id'", o.data))
697
698
        |> limit(^limit)
        |> Repo.all()
Ivan Tashkinov's avatar
Ivan Tashkinov committed
699
700
      else
        _ -> []
701
702
      end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
703
    set_replies(obj_data, replies_uris)
704
705
  end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
706
  defp set_replies(obj, []) do
707
708
709
710
711
712
    obj
  end

  defp set_replies(obj, replies_uris) do
    replies_collection = %{
      "type" => "Collection",
713
      "items" => replies_uris
714
715
716
717
718
    }

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

Ivan Tashkinov's avatar
Ivan Tashkinov committed
719
720
721
  def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
    items
  end
722

Ivan Tashkinov's avatar
Ivan Tashkinov committed
723
724
  def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
    items
725
726
727
728
  end

  def replies(_), do: []

729
  # Prepares the object of an outgoing create activity.
lain's avatar
lain committed
730
731
  def prepare_object(object) do
    object
lain's avatar
lain committed
732
    |> add_hashtags
lain's avatar
lain committed
733
    |> add_mention_tags
lain's avatar
lain committed
734
    |> add_emoji_tags
lain's avatar
lain committed
735
    |> add_attributed_to
lain's avatar
lain committed
736
    |> prepare_attachments
lain's avatar
lain committed
737
    |> set_conversation
738
    |> set_reply_to_uri
739
    |> set_replies
740
741
    |> strip_internal_fields
    |> strip_internal_tags
742
    |> set_type
lain's avatar
lain committed
743
744
  end

feld's avatar
feld committed
745
746
747
748
  #  @doc
  #  """
  #  internal -> Mastodon
  #  """
lain's avatar
lain committed
749

750
751
  def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
      when activity_type in ["Create", "Listen"] do
lain's avatar
lain committed
752
    object =
minibikini's avatar
minibikini committed
753
      object_id
754
      |> Object.normalize(fetch: false)
minibikini's avatar
minibikini committed
755
      |> Map.get(:data)
lain's avatar
lain committed
756
757
758
759
760
      |> prepare_object

    data =
      data
      |> Map.put("object", object)
lain's avatar
lain committed
761
      |> Map.merge(Utils.make_json_ld_header())
minibikini's avatar
minibikini committed
762
      |> Map.delete("bcc")
lain's avatar
lain committed
763
764
765
766

    {:ok, data}
  end

767
768
769
  def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
    object =
      object_id
770
      |> Object.normalize(fetch: false)
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787

    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
788
789
790
  # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
  # because of course it does.
  def prepare_outgoing(%{"type" => "Accept"} = data) do
791
    with follow_activity <- Activity.normalize(data["object"]) do
kaniini's avatar
kaniini committed
792
793
794
795
796
797
798
799
800
801
      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
802
        |> Map.merge(Utils.make_json_ld_header())
kaniini's avatar
kaniini committed
803
804
805
806
807

      {:ok, data}
    end
  end

808
  def prepare_outgoing(%{"type" => "Reject"} = data) do
809
    with follow_activity <- Activity.normalize(data["object"]) do
810
811
812
813
814
815
816
817
818
819
      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
820
        |> Map.merge(Utils.make_json_ld_header())
821
822
823
824
825

      {:ok, data}
    end
  end

feld's avatar
feld committed
826
  def prepare_outgoing(%{"type" => _type} = data) do
lain's avatar
lain committed
827
828
    data =
      data
829
      |> strip_internal_fields
lain's avatar
lain committed
830
      |> maybe_fix_object_url
lain's avatar
lain committed
831
      |> Map.merge(Utils.make_json_ld_header())
832
833
834
835

    {:ok, data}
  end

836
837
838
839
840
841
  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)
842
    else
843
844
845
846
847
848
      {:fetch, e} ->
        Logger.error("Couldn't fetch #{object} #{inspect(e)}")
        data

      _ ->
        data
849
850
851
    end
  end

852
853
  def maybe_fix_object_url(data), do: data

lain's avatar
lain committed
854
  def add_hashtags(object) do
855
856
857
858
859
860
861
862
863
864
865
866
867
868
    tags =
      (object["tag"] || [])
      |> 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
869
      end)
lain's avatar
lain committed
870

871
    Map.put(object, "tag", tags)
lain's avatar
lain committed
872
873
  end

874
875
  # 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
876
  def add_mention_tags(object) do
877
878
879
880
881
    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
882

lain's avatar
lain committed
883
    tags = object["tag"] || []
884
    Map.put(object, "tag", tags ++ mentions)
lain's avatar
lain committed
885
886
  end

Maksim's avatar
Maksim committed
887
888
889
  defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
    %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
  end
Haelwenn's avatar
Haelwenn committed
890

891
  def take_emoji_tags(%User{emoji: emoji}) do
Maksim's avatar
Maksim committed
892
    emoji
893
    |> Map.to_list()
Maksim's avatar
Maksim committed
894
    |> Enum.map(&build_emoji_tag/1)
Haelwenn's avatar
Haelwenn committed
895
896
  end

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

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

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

906
  def add_emoji_tags(object), do: object
Haelwenn's avatar
Haelwenn committed
907

Maksim's avatar
Maksim committed
908
909
  defp build_emoji_tag({name, url}) do
    %{
feld's avatar
feld committed
910
      "icon" => %{"url" => "#{URI.encode(url)}", "type" => "Image"},
Maksim's avatar
Maksim committed
911
912
913
914
915
916
917
      "name" => ":" <> name <> ":",
      "type" => "Emoji",
      "updated" => "1970-01-01T00:00:00Z",
      "id" => url
    }
  end

lain's avatar
lain committed
918
919
920
921
  def set_conversation(object) do
    Map.put(object, "conversation", object["context"])
  end

922
923
924
925
926
927
  def set_type(%{"type" => "Answer"} = object) do
    Map.put(object, "type", "Note")
  end

  def set_type(object), do: object

lain's avatar
lain committed
928
  def add_attributed_to(object) do
929
    attributed_to = object["attributedTo"] || object["actor"]
930
    Map.put(object, "attributedTo", attributed_to)
931
  end
lain's avatar
lain committed
932

933
934
935
  # TODO: Revisit this
  def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object

lain's avatar
lain committed
936
  def prepare_attachments(object) do
lain's avatar
lain committed
937
    attachments =
Maksim's avatar
Maksim committed
938
939
      object
      |> Map.get("attachment", [])
lain's avatar
lain committed
940
      |> Enum.map(fn data ->
941
        [%{"mediaType" => media_type, "href" => href} = url | _] = data["url"]
Maksim's avatar
Maksim committed
942
943
944
945
946
947
948

        %{
          "url" => href,
          "mediaType" => media_type,
          "name" => data["name"],
          "type" => "Document"
        }
949
950
        |> Maps.put_if_present("width", url["width"])
        |> Maps.put_if_present("height", url["height"])
Alex Gleason's avatar
Alex Gleason committed
951
        |> Maps.put_if_present("blurhash", data["blurhash"])
lain's avatar
lain committed
952
      end)
lain's avatar
lain committed
953

954
    Map.put(object, "attachment", attachments)
lain's avatar
lain committed
955
  end
lain's avatar
lain committed
956

957
  def strip_internal_fields(object) do
Maksim's avatar
Maksim committed
958
    Map.drop(object, Pleroma.Constants.object_internal_fields())
959
960
961
  end

  defp strip_internal_tags(%{"tag" => tags} = object) do
962
    tags = Enum.filter(tags, fn x -> is_map(x) end)
963

964
    Map.put(object, "tag", tags)
965
966
967
968
  end

  defp strip_internal_tags(object), do: object

969
  def perform(:user_upgrade, user) do
970
971
    # we pass a fake user so that the followers collection is stripped away
    old_follower_address = User.ap_followers(%User{nickname: user.nickname})
lain's avatar
lain committed
972