transmogrifier.ex 28.1 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
209
210
211
212
213
214
215
216
            is_map(url) && MIME.extensions(url["mediaType"]) != [] ->
              url["mediaType"]

            is_bitstring(data["mediaType"]) && MIME.extensions(data["mediaType"]) != [] ->
              data["mediaType"]

            is_bitstring(data["mimeType"]) && MIME.extensions(data["mimeType"]) != [] ->
              data["mimeType"]

            true ->
              nil
217
218
219
220
221
222
223
          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
224
            true -> nil
225
226
          end

Haelwenn's avatar
Haelwenn committed
227
228
        if href do
          attachment_url =
Haelwenn's avatar
Haelwenn committed
229
230
231
232
            %{
              "href" => href,
              "type" => Map.get(url || %{}, "type", "Link")
            }
Haelwenn's avatar
Haelwenn committed
233
            |> Maps.put_if_present("mediaType", media_type)
234
235
            |> Maps.put_if_present("width", (url || %{})["width"] || data["width"])
            |> Maps.put_if_present("height", (url || %{})["height"] || data["height"])
236

Haelwenn's avatar
Haelwenn committed
237
238
239
240
          %{
            "url" => [attachment_url],
            "type" => data["type"] || "Document"
          }
Haelwenn's avatar
Haelwenn committed
241
242
          |> Maps.put_if_present("mediaType", media_type)
          |> Maps.put_if_present("name", data["name"])
243
          |> Maps.put_if_present("blurhash", data["blurhash"])
Haelwenn's avatar
Haelwenn committed
244
245
246
        else
          nil
        end
lain's avatar
lain committed
247
      end)
Haelwenn's avatar
Haelwenn committed
248
      |> Enum.filter(& &1)
lain's avatar
lain committed
249

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

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

259
  def fix_attachments(object), do: object
260

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

Haelwenn's avatar
Haelwenn committed
265
  def fix_url(%{"url" => url} = object) when is_list(url) do
266
267
268
269
270
271
272
273
274
    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

275
    Map.put(object, "url", url_string)
276
277
278
279
  end

  def fix_url(object), do: object

280
  def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
lain's avatar
lain committed
281
    emoji =
282
      tags
283
      |> Enum.filter(fn data -> is_map(data) and data["type"] == "Emoji" and data["icon"] end)
lain's avatar
lain committed
284
      |> Enum.reduce(%{}, fn data, mapping ->
285
        name = String.trim(data["name"], ":")
lain's avatar
lain committed
286

287
        Map.put(mapping, name, data["icon"]["url"])
lain's avatar
lain committed
288
      end)
lain's avatar
lain committed
289

290
    Map.put(object, "emoji", emoji)
lain's avatar
lain committed
291
292
  end

293
294
295
296
  def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
    name = String.trim(tag["name"], ":")
    emoji = %{name => tag["icon"]["url"]}

297
    Map.put(object, "emoji", emoji)
298
299
  end

300
  def fix_emoji(object), do: object
301

302
  def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
303
    tags =
304
      tag
lain's avatar
lain committed
305
      |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
306
307
308
      |> Enum.map(fn
        %{"name" => "#" <> hashtag} -> String.downcase(hashtag)
        %{"name" => hashtag} -> String.downcase(hashtag)
309
      end)
310

311
    Map.put(object, "tag", tag ++ tags)
312
313
  end

314
315
316
317
  def fix_tag(%{"tag" => %{} = tag} = object) do
    object
    |> Map.put("tag", [tag])
    |> fix_tag
318
319
  end

320
  def fix_tag(object), do: object
321

322
323
324
325
326
  # 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)

327
    Map.put(object, "content", content)
328
329
330
331
  end

  def fix_content_map(object), do: object

332
333
334
  defp fix_type(%{"type" => "Note", "inReplyTo" => reply_id, "name" => _} = object, options)
       when is_binary(reply_id) do
    options = Keyword.put(options, :fetch, true)
335

336
    with %Object{data: %{"type" => "Question"}} <- Object.normalize(reply_id, options) do
337
338
      Map.put(object, "type", "Answer")
    else
339
      _ -> object
340
341
342
    end
  end

343
  defp fix_type(object, _options), do: object
344

345
346
347
348
349
350
351
352
353
354
355
  # 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

356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
  # 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

379
380
  def handle_incoming(data, options \\ [])

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

403
  # disallow objects with bogus IDs
404
405
  def handle_incoming(%{"id" => nil}, _options), do: :error
  def handle_incoming(%{"id" => ""}, _options), do: :error
406
  # length of https:// = 8, should validate better, but good enough for now.
rinpatch's avatar
rinpatch committed
407
  def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
408
    do: :error
409

410
411
412
  # TODO: validate those with a Ecto scheme
  # - tags
  # - emoji
413
  def handle_incoming(
Haelwenn's avatar
Haelwenn committed
414
        %{"type" => "Create", "object" => %{"type" => "Page"} = object} = data,
415
        options
Haelwenn's avatar
Haelwenn committed
416
      ) do
417
    actor = Containment.get_actor(data)
418

419
    with nil <- Activity.get_create_by_object_ap_id(object["id"]),
420
421
422
423
424
425
426
427
         {: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
428
429
430
431
432
433
434
435
436
        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
437
438
439
440
        end

        {:ok, created_activity}
      end
441
    else
lain's avatar
lain committed
442
      %Activity{} = activity -> {:ok, activity}
443
444
445
446
      _e -> :error
    end
  end

447
448
449
450
451
452
453
454
455
456
457
  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
458
459
      reply_depth = (options[:depth] || 0) + 1
      options = Keyword.put(options, :depth, reply_depth)
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
      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

478
479
480
481
482
483
484
485
486
487
  @misskey_reactions %{
    "like" => "👍",
    "love" => "❤️",
    "laugh" => "😆",
    "hmm" => "🤔",
    "surprise" => "😮",
    "congrats" => "🎉",
    "angry" => "💢",
    "confused" => "😥",
    "rip" => "😇",
488
489
    "pudding" => "🍮",
    "star" => "⭐"
490
491
  }

lain's avatar
lain committed
492
  @doc "Rewrite misskey likes into EmojiReacts"
493
494
495
496
497
498
499
500
  def handle_incoming(
        %{
          "type" => "Like",
          "_misskey_reaction" => reaction
        } = data,
        options
      ) do
    data
lain's avatar
lain committed
501
    |> Map.put("type", "EmojiReact")
502
    |> Map.put("content", @misskey_reactions[reaction] || reaction)
503
504
505
    |> handle_incoming(options)
  end

Haelwenn's avatar
Haelwenn committed
506
  def handle_incoming(
507
        %{"type" => "Create", "object" => %{"type" => objtype, "id" => obj_id}} = data,
Haelwenn's avatar
Haelwenn committed
508
        options
Haelwenn's avatar
Haelwenn committed
509
      )
Haelwenn's avatar
Haelwenn committed
510
      when objtype in ~w{Question Answer ChatMessage Audio Video Event Article Note} do
511
512
513
514
515
516
517
518
519
    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
520
    options = Keyword.put(options, :local, false)
521

Haelwenn's avatar
Haelwenn committed
522
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
523
         nil <- Activity.get_create_by_object_ap_id(obj_id),
Haelwenn's avatar
Haelwenn committed
524
         {:ok, activity, _} <- Pipeline.common_pipeline(data, options) do
Haelwenn's avatar
Haelwenn committed
525
      {:ok, activity}
526
527
528
    else
      %Activity{} = activity -> {:ok, activity}
      e -> e
Haelwenn's avatar
Haelwenn committed
529
530
531
    end
  end

532
  def handle_incoming(%{"type" => type} = data, _options)
Alexander Strizhakov's avatar
Alexander Strizhakov committed
533
      when type in ~w{Like EmojiReact Announce Add Remove} do
lain's avatar
lain committed
534
535
536
    with :ok <- ObjectValidator.fetch_actor_and_object(data),
         {:ok, activity, _meta} <-
           Pipeline.common_pipeline(data, local: false) do
lain's avatar
lain committed
537
538
      {:ok, activity}
    else
539
      e -> {:error, e}
lain's avatar
lain committed
540
541
542
    end
  end

lain's avatar
lain committed
543
  def handle_incoming(
544
        %{"type" => type} = data,
545
        _options
546
      )
547
      when type in ~w{Update Block Follow Accept Reject} do
548
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
549
550
         {:ok, activity, _} <-
           Pipeline.common_pipeline(data, local: false) do
551
      {:ok, activity}
lain's avatar
lain committed
552
553
554
    end
  end

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

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

597
598
599
  def handle_incoming(
        %{
          "type" => "Undo",
600
          "object" => %{"type" => type}
601
602
        } = data,
        _options
603
      )
604
      when type in ["Like", "EmojiReact", "Announce", "Block"] do
605
    with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
606
607
608
609
      {:ok, activity}
    end
  end

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

minibikini's avatar
minibikini committed
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
  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

646
  def handle_incoming(_, _), do: :error
647

648
  @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
649
  def get_obj_helper(id, options \\ []) do
650
651
652
    options = Keyword.put(options, :fetch, true)

    case Object.normalize(id, options) do
Maksim's avatar
Maksim committed
653
654
      %Object{} = object -> {:ok, object}
      _ -> nil
655
    end
656
657
  end

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

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

681
682
683
684
  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)
685
686
687
688
    else
      _e -> object
    end
  end
lain's avatar
lain committed
689

690
691
  def set_reply_to_uri(obj), do: obj

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

Ivan Tashkinov's avatar
Ivan Tashkinov committed
710
    set_replies(obj_data, replies_uris)
711
712
  end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
713
  defp set_replies(obj, []) do
714
715
716
717
718
719
    obj
  end

  defp set_replies(obj, replies_uris) do
    replies_collection = %{
      "type" => "Collection",
720
      "items" => replies_uris
721
722
723
724
725
    }

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

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

Ivan Tashkinov's avatar
Ivan Tashkinov committed
730
731
  def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
    items
732
733
734
735
  end

  def replies(_), do: []

736
  # Prepares the object of an outgoing create activity.
lain's avatar
lain committed
737
738
  def prepare_object(object) do
    object
lain's avatar
lain committed
739
    |> add_hashtags
lain's avatar
lain committed
740
    |> add_mention_tags
lain's avatar
lain committed
741
    |> add_emoji_tags
lain's avatar
lain committed
742
    |> add_attributed_to
lain's avatar
lain committed
743
    |> prepare_attachments
lain's avatar
lain committed
744
    |> set_conversation
745
    |> set_reply_to_uri
746
    |> set_replies
747
748
    |> strip_internal_fields
    |> strip_internal_tags
749
    |> set_type
lain's avatar
lain committed
750
751
  end

feld's avatar
feld committed
752
753
754
755
  #  @doc
  #  """
  #  internal -> Mastodon
  #  """
lain's avatar
lain committed
756

757
758
  def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
      when activity_type in ["Create", "Listen"] do
lain's avatar
lain committed
759
    object =
minibikini's avatar
minibikini committed
760
      object_id
761
      |> Object.normalize(fetch: false)
minibikini's avatar
minibikini committed
762
      |> Map.get(:data)
lain's avatar
lain committed
763
764
765
766
767
      |> prepare_object

    data =
      data
      |> Map.put("object", object)
lain's avatar
lain committed
768
      |> Map.merge(Utils.make_json_ld_header())
minibikini's avatar
minibikini committed
769
      |> Map.delete("bcc")
lain's avatar
lain committed
770
771
772
773

    {:ok, data}
  end

774
775
776
  def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
    object =
      object_id
777
      |> Object.normalize(fetch: false)
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794

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

      {:ok, data}
    end
  end

815
  def prepare_outgoing(%{"type" => "Reject"} = data) do
816
    with follow_activity <- Activity.normalize(data["object"]) do
817
818
819
820
821
822
823
824
825
826
      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
827
        |> Map.merge(Utils.make_json_ld_header())
828
829
830
831
832

      {:ok, data}
    end
  end

feld's avatar
feld committed
833
  def prepare_outgoing(%{"type" => _type} = data) do
lain's avatar
lain committed
834
835
    data =
      data
836
      |> strip_internal_fields
lain's avatar
lain committed
837
      |> maybe_fix_object_url
lain's avatar
lain committed
838
      |> Map.merge(Utils.make_json_ld_header())
839
840
841
842

    {:ok, data}
  end

843
844
845
846
847
848
  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)
849
    else
850
851
852
853
854
855
      {:fetch, e} ->
        Logger.error("Couldn't fetch #{object} #{inspect(e)}")
        data

      _ ->
        data
856
857
858
    end
  end

859
860
  def maybe_fix_object_url(data), do: data

lain's avatar
lain committed
861
  def add_hashtags(object) do
862
863
864
865
866
867
868
869
870
871
872
873
874
875
    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
876
      end)
lain's avatar
lain committed
877

878
    Map.put(object, "tag", tags)
lain's avatar
lain committed
879
880
  end

881
882
  # 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
883
  def add_mention_tags(object) do
884
885
886
887
888
    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
889

lain's avatar
lain committed
890
    tags = object["tag"] || []
891
    Map.put(object, "tag", tags ++ mentions)
lain's avatar
lain committed
892
893
  end

Maksim's avatar
Maksim committed
894
895
896
  defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
    %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
  end
Haelwenn's avatar
Haelwenn committed
897

898
  def take_emoji_tags(%User{emoji: emoji}) do
Maksim's avatar
Maksim committed
899
    emoji
900
    |> Map.to_list()
Maksim's avatar
Maksim committed
901
    |> Enum.map(&build_emoji_tag/1)
Haelwenn's avatar
Haelwenn committed
902
903
  end

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

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

910
    Map.put(object, "tag", tags ++ out)
lain's avatar
lain committed
911
912
  end

913
  def add_emoji_tags(object), do: object
Haelwenn's avatar
Haelwenn committed
914

Maksim's avatar
Maksim committed
915
916
  defp build_emoji_tag({name, url}) do
    %{
feld's avatar
feld committed
917
      "icon" => %{"url" => "#{URI.encode(url)}", "type" => "Image"},
Maksim's avatar
Maksim committed
918
919
920
921
922
923
924
      "name" => ":" <> name <> ":",
      "type" => "Emoji",
      "updated" => "1970-01-01T00:00:00Z",
      "id" => url
    }
  end

lain's avatar
lain committed
925
926
927
928
  def set_conversation(object) do
    Map.put(object, "conversation", object["context"])
  end

929
930
931
932
933
934
  def set_type(%{"type" => "Answer"} = object) do
    Map.put(object, "type", "Note")
  end

  def set_type(object), do: object

lain's avatar
lain committed
935
  def add_attributed_to(object) do
936
    attributed_to = object["attributedTo"] || object["actor"]
937
    Map.put(object, "attributedTo", attributed_to)
938
  end
lain's avatar
lain committed
939

940
941
942
  # TODO: Revisit this
  def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object

lain's avatar
lain committed
943
  def prepare_attachments(object) do
lain's avatar
lain committed
944
    attachments =
Maksim's avatar
Maksim committed
945
946
      object
      |> Map.get("attachment", [])
lain's avatar
lain committed
947
      |> Enum.map(fn data ->
948
        [%{"mediaType" => media_type, "href" => href} = url | _] = data["url"]
Maksim's avatar
Maksim committed
949
950
951
952
953
954
955

        %{
          "url" => href,
          "mediaType" => media_type,
          "name" => data["name"],
          "type" => "Document"
        }
956
957
        |> Maps.put_if_present("width", url["width"])
        |> Maps.put_if_present("height", url["height"])
Alex Gleason's avatar
Alex Gleason committed
958
        |> Maps.put_if_present("blurhash", data["blurhash"])
lain's avatar
lain committed
959
      end)
lain's avatar
lain committed
960

961
    Map.put(object, "attachment", attachments)
lain's avatar
lain committed
962
  end
lain's avatar
lain committed
963

964
  def strip_internal_fields(object) do
Maksim's avatar
Maksim committed
965
    Map.drop(object, Pleroma.Constants.object_internal_fields())
966
967
968
  end

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

971
    Map.put(object, "tag", tags)
972
973
974
975
  end

  defp strip_internal_tags(object), do: object

976
  def perform(:user_upgrade, user) do
977
978
    # we pass a fake user so that the followers collection is stripped away
    old_follower_address = User.ap_followers(%User{nickname: user.