transmogrifier.ex 27.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
  def fix_quote(object, options \\ [])

  def fix_quote(%{"quoteUrl" => quote_url} = object, options)
      when not is_nil(quote_url) do
    with {:ok, quoted_object} <- get_obj_helper(quote_url, options),
         %Activity{} <- Activity.get_create_by_object_ap_id(quoted_object.data["id"]) do
      Map.put(object, "quoteUrl", quoted_object.data["id"])
    else
      e ->
        Logger.warn("Couldn't fetch #{inspect(quote_url)}, error: #{inspect(e)}")
        object
    end
  end

  def fix_quote(object, _options), do: object

186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
  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
202
  def fix_context(object) do
Haelwenn's avatar
Haelwenn committed
203
204
    context = object["context"] || object["conversation"] || Utils.generate_context_id()

lain's avatar
lain committed
205
    object
Haelwenn's avatar
Haelwenn committed
206
    |> Map.put("context", context)
207
    |> Map.drop(["conversation"])
lain's avatar
lain committed
208
209
  end

210
  def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
lain's avatar
lain committed
211
    attachments =
212
      Enum.map(attachment, fn data ->
213
214
215
216
217
218
219
220
221
        url =
          cond do
            is_list(data["url"]) -> List.first(data["url"])
            is_map(data["url"]) -> data["url"]
            true -> nil
          end

        media_type =
          cond do
222
223
224
225
226
227
228
229
230
231
232
            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
233
234
235
236
237
238
239
          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
240
            true -> nil
241
242
          end

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

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

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

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

275
  def fix_attachments(object), do: object
276

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

Haelwenn's avatar
Haelwenn committed
281
  def fix_url(%{"url" => url} = object) when is_list(url) do
282
283
284
285
286
287
288
289
290
    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

291
    Map.put(object, "url", url_string)
292
293
294
295
  end

  def fix_url(object), do: object

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

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

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

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

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

316
  def fix_emoji(object), do: object
317

318
  def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
319
    tags =
320
      tag
lain's avatar
lain committed
321
      |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
322
323
324
      |> Enum.map(fn
        %{"name" => "#" <> hashtag} -> String.downcase(hashtag)
        %{"name" => hashtag} -> String.downcase(hashtag)
325
      end)
326

327
    Map.put(object, "tag", tag ++ tags)
328
329
  end

330
331
332
333
  def fix_tag(%{"tag" => %{} = tag} = object) do
    object
    |> Map.put("tag", [tag])
    |> fix_tag
334
335
  end

336
  def fix_tag(object), do: object
337

338
339
340
341
342
  # 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)

343
    Map.put(object, "content", content)
344
345
346
347
  end

  def fix_content_map(object), do: object

348
349
350
  defp fix_type(%{"type" => "Note", "inReplyTo" => reply_id, "name" => _} = object, options)
       when is_binary(reply_id) do
    options = Keyword.put(options, :fetch, true)
351

352
    with %Object{data: %{"type" => "Question"}} <- Object.normalize(reply_id, options) do
353
354
      Map.put(object, "type", "Answer")
    else
355
      _ -> object
356
357
358
    end
  end

359
  defp fix_type(object, _options), do: object
360

361
362
363
364
365
366
367
368
369
370
371
  # 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

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
406
407
408
409
410
411
412
413
  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
414
415
      reply_depth = (options[:depth] || 0) + 1
      options = Keyword.put(options, :depth, reply_depth)
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
      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

434
435
436
437
438
439
440
441
442
443
  @misskey_reactions %{
    "like" => "👍",
    "love" => "❤️",
    "laugh" => "😆",
    "hmm" => "🤔",
    "surprise" => "😮",
    "congrats" => "🎉",
    "angry" => "💢",
    "confused" => "😥",
    "rip" => "😇",
444
445
    "pudding" => "🍮",
    "star" => "⭐"
446
447
  }

lain's avatar
lain committed
448
  @doc "Rewrite misskey likes into EmojiReacts"
449
450
451
452
453
454
455
456
  def handle_incoming(
        %{
          "type" => "Like",
          "_misskey_reaction" => reaction
        } = data,
        options
      ) do
    data
lain's avatar
lain committed
457
    |> Map.put("type", "EmojiReact")
458
    |> Map.put("content", @misskey_reactions[reaction] || reaction)
459
460
461
    |> handle_incoming(options)
  end

Haelwenn's avatar
Haelwenn committed
462
  def handle_incoming(
463
        %{"type" => "Create", "object" => %{"type" => objtype, "id" => obj_id}} = data,
Haelwenn's avatar
Haelwenn committed
464
        options
Haelwenn's avatar
Haelwenn committed
465
      )
Haelwenn's avatar
Haelwenn committed
466
      when objtype in ~w{Question Answer ChatMessage Audio Video Event Article Note Page} do
467
468
469
470
471
472
473
    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)
474
      |> fix_quote(fetch_options)
475
476

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

Haelwenn's avatar
Haelwenn committed
479
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
480
         nil <- Activity.get_create_by_object_ap_id(obj_id),
Haelwenn's avatar
Haelwenn committed
481
         {:ok, activity, _} <- Pipeline.common_pipeline(data, options) do
Haelwenn's avatar
Haelwenn committed
482
      {:ok, activity}
483
484
485
    else
      %Activity{} = activity -> {:ok, activity}
      e -> e
Haelwenn's avatar
Haelwenn committed
486
487
488
    end
  end

489
  def handle_incoming(%{"type" => type} = data, _options)
Alexander Strizhakov's avatar
Alexander Strizhakov committed
490
      when type in ~w{Like EmojiReact Announce Add Remove} do
lain's avatar
lain committed
491
492
493
    with :ok <- ObjectValidator.fetch_actor_and_object(data),
         {:ok, activity, _meta} <-
           Pipeline.common_pipeline(data, local: false) do
lain's avatar
lain committed
494
495
      {:ok, activity}
    else
496
      e -> {:error, e}
lain's avatar
lain committed
497
498
499
    end
  end

lain's avatar
lain committed
500
  def handle_incoming(
501
        %{"type" => type} = data,
502
        _options
503
      )
504
      when type in ~w{Update Block Follow Accept Reject} do
505
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
506
507
         {:ok, activity, _} <-
           Pipeline.common_pipeline(data, local: false) do
508
      {:ok, activity}
lain's avatar
lain committed
509
510
511
    end
  end

lain's avatar
lain committed
512
  def handle_incoming(
513
        %{"type" => "Delete"} = data,
514
        _options
lain's avatar
lain committed
515
      ) do
516
517
    with {:ok, activity, _} <-
           Pipeline.common_pipeline(data, local: false) do
lain's avatar
lain committed
518
      {:ok, activity}
519
    else
Haelwenn's avatar
Haelwenn committed
520
      {:error, {:validate, _}} = e ->
521
        # Check if we have a create activity for this
522
        with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
523
524
525
526
527
528
529
530
531
             %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
532
533
534
    end
  end

normandy's avatar
normandy committed
535
536
537
538
539
540
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Follow", "object" => followed},
          "actor" => follower,
          "id" => id
541
542
        } = _data,
        _options
normandy's avatar
normandy committed
543
      ) do
normandy's avatar
normandy committed
544
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
545
         {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
normandy's avatar
normandy committed
546
         {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
normandy's avatar
normandy committed
547
548
549
      User.unfollow(follower, followed)
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
550
      _e -> :error
normandy's avatar
normandy committed
551
552
553
    end
  end

554
555
556
  def handle_incoming(
        %{
          "type" => "Undo",
557
          "object" => %{"type" => type}
558
559
        } = data,
        _options
560
      )
561
      when type in ["Like", "EmojiReact", "Announce", "Block"] do
562
    with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
563
564
565
566
      {:ok, activity}
    end
  end

567
  # For Undos that don't have the complete object attached, try to find it in our database.
normandy's avatar
normandy committed
568
569
570
  def handle_incoming(
        %{
          "type" => "Undo",
571
572
573
574
575
576
577
578
579
          "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
580
    else
Maksim's avatar
Maksim committed
581
      _e -> :error
normandy's avatar
normandy committed
582
583
584
    end
  end

minibikini's avatar
minibikini committed
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
  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

603
  def handle_incoming(_, _), do: :error
604

605
  @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
606
  def get_obj_helper(id, options \\ []) do
607
608
609
    options = Keyword.put(options, :fetch, true)

    case Object.normalize(id, options) do
Maksim's avatar
Maksim committed
610
611
      %Object{} = object -> {:ok, object}
      _ -> nil
612
    end
613
614
  end

615
  @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
Thibaut Girka's avatar
Thibaut Girka committed
616
  def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
617
618
        ap_id: ap_id
      })
Thibaut Girka's avatar
Thibaut Girka committed
619
      when attributed_to == ap_id do
620
621
622
623
624
    with {:ok, activity} <-
           handle_incoming(%{
             "type" => "Create",
             "to" => data["to"],
             "cc" => data["cc"],
Thibaut Girka's avatar
Thibaut Girka committed
625
             "actor" => attributed_to,
626
627
             "object" => data
           }) do
628
      {:ok, Object.normalize(activity, fetch: false)}
629
630
631
632
633
634
635
636
637
    else
      _ -> get_obj_helper(object_id)
    end
  end

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

638
639
640
641
  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)
642
643
644
645
    else
      _e -> object
    end
  end
lain's avatar
lain committed
646

647
648
  def set_reply_to_uri(obj), do: obj

649
650
651
652
  @doc """
  Serialized Mastodon-compatible `replies` collection containing _self-replies_.
  Based on Mastodon's ActivityPub::NoteSerializer#replies.
  """
653
  def set_replies(obj_data) do
654
    replies_uris =
Ivan Tashkinov's avatar
Ivan Tashkinov committed
655
656
      with limit when limit > 0 <-
             Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
657
658
659
660
           %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
        object
        |> Object.self_replies()
        |> select([o], fragment("?->>'id'", o.data))
661
662
        |> limit(^limit)
        |> Repo.all()
Ivan Tashkinov's avatar
Ivan Tashkinov committed
663
664
      else
        _ -> []
665
666
      end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
667
    set_replies(obj_data, replies_uris)
668
669
  end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
670
  defp set_replies(obj, []) do
671
672
673
674
675
676
    obj
  end

  defp set_replies(obj, replies_uris) do
    replies_collection = %{
      "type" => "Collection",
677
      "items" => replies_uris
678
679
680
681
682
    }

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

Ivan Tashkinov's avatar
Ivan Tashkinov committed
683
684
685
  def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
    items
  end
686

Ivan Tashkinov's avatar
Ivan Tashkinov committed
687
688
  def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
    items
689
690
691
692
  end

  def replies(_), do: []

693
  # Prepares the object of an outgoing create activity.
lain's avatar
lain committed
694
695
  def prepare_object(object) do
    object
lain's avatar
lain committed
696
    |> add_hashtags
lain's avatar
lain committed
697
    |> add_mention_tags
lain's avatar
lain committed
698
    |> add_emoji_tags
lain's avatar
lain committed
699
    |> add_attributed_to
lain's avatar
lain committed
700
    |> prepare_attachments
lain's avatar
lain committed
701
    |> set_conversation
702
    |> set_reply_to_uri
703
    |> set_replies
704
705
    |> strip_internal_fields
    |> strip_internal_tags
706
    |> set_type
lain's avatar
lain committed
707
708
  end

feld's avatar
feld committed
709
710
711
712
  #  @doc
  #  """
  #  internal -> Mastodon
  #  """
lain's avatar
lain committed
713

714
715
  def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
      when activity_type in ["Create", "Listen"] do
lain's avatar
lain committed
716
    object =
minibikini's avatar
minibikini committed
717
      object_id
718
      |> Object.normalize(fetch: false)
minibikini's avatar
minibikini committed
719
      |> Map.get(:data)
lain's avatar
lain committed
720
721
722
723
724
      |> prepare_object

    data =
      data
      |> Map.put("object", object)
lain's avatar
lain committed
725
      |> Map.merge(Utils.make_json_ld_header())
minibikini's avatar
minibikini committed
726
      |> Map.delete("bcc")
lain's avatar
lain committed
727
728
729
730

    {:ok, data}
  end

731
732
733
  def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
    object =
      object_id
734
      |> Object.normalize(fetch: false)
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751

    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
752
753
754
  # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
  # because of course it does.
  def prepare_outgoing(%{"type" => "Accept"} = data) do
755
    with follow_activity <- Activity.normalize(data["object"]) do
kaniini's avatar
kaniini committed
756
757
758
759
760
761
762
763
764
765
      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
766
        |> Map.merge(Utils.make_json_ld_header())
kaniini's avatar
kaniini committed
767
768
769
770
771

      {:ok, data}
    end
  end

772
  def prepare_outgoing(%{"type" => "Reject"} = data) do
773
    with follow_activity <- Activity.normalize(data["object"]) do
774
775
776
777
778
779
780
781
782
783
      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
784
        |> Map.merge(Utils.make_json_ld_header())
785
786
787
788
789

      {:ok, data}
    end
  end

feld's avatar
feld committed
790
  def prepare_outgoing(%{"type" => _type} = data) do
lain's avatar
lain committed
791
792
    data =
      data
793
      |> strip_internal_fields
lain's avatar
lain committed
794
      |> maybe_fix_object_url
lain's avatar
lain committed
795
      |> Map.merge(Utils.make_json_ld_header())
796
797
798
799

    {:ok, data}
  end

800
801
802
803
804
805
  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)
806
    else
807
808
809
810
811
812
      {:fetch, e} ->
        Logger.error("Couldn't fetch #{object} #{inspect(e)}")
        data

      _ ->
        data
813
814
815
    end
  end

816
817
  def maybe_fix_object_url(data), do: data

lain's avatar
lain committed
818
  def add_hashtags(object) do
819
820
821
822
823
824
825
826
827
828
829
830
831
832
    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
833
      end)
lain's avatar
lain committed
834

835
    Map.put(object, "tag", tags)
lain's avatar
lain committed
836
837
  end

838
839
  # 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
840
  def add_mention_tags(object) do
841
842
843
844
845
    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
846

lain's avatar
lain committed
847
    tags = object["tag"] || []
848
    Map.put(object, "tag", tags ++ mentions)
lain's avatar
lain committed
849
850
  end

Maksim's avatar
Maksim committed
851
852
853
  defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
    %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
  end
Haelwenn's avatar
Haelwenn committed
854

855
  def take_emoji_tags(%User{emoji: emoji}) do
Maksim's avatar
Maksim committed
856
    emoji
857
    |> Map.to_list()
Maksim's avatar
Maksim committed
858
    |> Enum.map(&build_emoji_tag/1)
Haelwenn's avatar
Haelwenn committed
859
860
  end

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

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

867
    Map.put(object, "tag", tags ++ out)
lain's avatar
lain committed
868
869
  end

870
  def add_emoji_tags(object), do: object
Haelwenn's avatar
Haelwenn committed
871

Maksim's avatar
Maksim committed
872
873
  defp build_emoji_tag({name, url}) do
    %{
feld's avatar
feld committed
874
      "icon" => %{"url" => "#{URI.encode(url)}", "type" => "Image"},
Maksim's avatar
Maksim committed
875
876
877
878
879
880
881
      "name" => ":" <> name <> ":",
      "type" => "Emoji",
      "updated" => "1970-01-01T00:00:00Z",
      "id" => url
    }
  end

lain's avatar
lain committed
882
883
884
885
  def set_conversation(object) do
    Map.put(object, "conversation", object["context"])
  end

886
887
888
889
890
891
  def set_type(%{"type" => "Answer"} = object) do
    Map.put(object, "type", "Note")
  end

  def set_type(object), do: object

lain's avatar
lain committed
892
  def add_attributed_to(object) do
893
    attributed_to = object["attributedTo"] || object["actor"]
894
    Map.put(object, "attributedTo", attributed_to)
895
  end
lain's avatar
lain committed
896

897
898
899
  # TODO: Revisit this
  def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object

lain's avatar
lain committed
900
  def prepare_attachments(object) do
lain's avatar
lain committed
901
    attachments =
Maksim's avatar
Maksim committed
902
903
      object
      |> Map.get("attachment", [])
lain's avatar
lain committed
904
      |> Enum.map(fn data ->
905
        [%{"mediaType" => media_type, "href" => href} = url | _] = data["url"]
Maksim's avatar
Maksim committed
906
907
908
909
910
911
912

        %{
          "url" => href,
          "mediaType" => media_type,
          "name" => data["name"],
          "type" => "Document"
        }
913
914
        |> Maps.put_if_present("width", url["width"])
        |> Maps.put_if_present("height", url["height"])
Alex Gleason's avatar
Alex Gleason committed
915
        |> Maps.put_if_present("blurhash", data["blurhash"])
lain's avatar
lain committed
916
      end)
lain's avatar
lain committed
917

918
    Map.put(object, "attachment", attachments)
lain's avatar
lain committed
919
  end
lain's avatar
lain committed
920

921
  def strip_internal_fields(object) do
Maksim's avatar
Maksim committed
922
    Map.drop(object, Pleroma.Constants.object_internal_fields())
923
924
925
  end

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

928
    Map.put(object, "tag", tags)
929
930
931
932
  end

  defp strip_internal_tags(object), do: object

933
  def perform(:user_upgrade, user) do
934
935
    # 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
936

937
938
939
940
941
942
943
944
945
946
947
948
    from(
      a in Activity,
      where: ^old_follower_address in a.recipients,
      update: [
        set: [
          recipients:
            fragment(
              "array_replace(?,?,?)",
              a.recipients,
              ^old_follower_address,
              ^user.follower_address
            )
lain's avatar
lain committed
949
        ]
950
951
952
      ]
    )
    |> Repo.update_all([])
lain's avatar
lain committed
953
954
  end

955
  def upgrade_user_from_ap_id(ap_id) do
minibikini's avatar
minibikini committed
956
    with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
rinpatch's avatar
rinpatch committed
957
         {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
958
         {:ok, user} <- update_user(user, data) do
Alexander Strizhakov's avatar
Alexander Strizhakov committed
959
      {:ok, _pid} = Task.start(fn -> ActivityPub.pinned_fetch_task(user) end)
960
      TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
lain's avatar
lain committed
961
962
      {:ok, user}
    else
963
      %User{} = user -> {:ok, user}
lain's avatar
lain committed
964
965