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

172
  def fix_quote_url(%{"quoteUrl" => quote_url} = object, options)
173
174
175
176
177
178
179
180
181
182
183
      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

184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
  # Fix for Fedibird
  # https://github.com/fedibird/mastodon/issues/9
  def fix_quote_url(%{"quoteURL" => quote_url} = object, options) do
    object
    |> Map.put("quoteUrl", quote_url)
    |> fix_quote_url(options)
  end

  # Misskey fallback
  def fix_quote_url(%{"_misskey_quote" => quote_url} = object, options) do
    object
    |> Map.put("quoteUrl", quote_url)
    |> fix_quote_url(options)
  end

  def fix_quote_url(object, _options), do: object
200

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

lain's avatar
lain committed
220
    object
Haelwenn's avatar
Haelwenn committed
221
    |> Map.put("context", context)
222
    |> Map.drop(["conversation"])
lain's avatar
lain committed
223
224
  end

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

        media_type =
          cond do
237
238
239
240
241
242
243
244
245
246
247
            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
248
249
250
251
252
253
254
          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
255
            true -> nil
256
257
          end

Haelwenn's avatar
Haelwenn committed
258
259
        if href do
          attachment_url =
Haelwenn's avatar
Haelwenn committed
260
261
262
263
            %{
              "href" => href,
              "type" => Map.get(url || %{}, "type", "Link")
            }
Haelwenn's avatar
Haelwenn committed
264
            |> Maps.put_if_present("mediaType", media_type)
265
266
            |> Maps.put_if_present("width", (url || %{})["width"] || data["width"])
            |> Maps.put_if_present("height", (url || %{})["height"] || data["height"])
267

Haelwenn's avatar
Haelwenn committed
268
269
270
271
          %{
            "url" => [attachment_url],
            "type" => data["type"] || "Document"
          }
Haelwenn's avatar
Haelwenn committed
272
273
          |> Maps.put_if_present("mediaType", media_type)
          |> Maps.put_if_present("name", data["name"])
274
          |> Maps.put_if_present("blurhash", data["blurhash"])
Haelwenn's avatar
Haelwenn committed
275
276
277
        else
          nil
        end
lain's avatar
lain committed
278
      end)
Haelwenn's avatar
Haelwenn committed
279
      |> Enum.filter(& &1)
lain's avatar
lain committed
280

281
    Map.put(object, "attachment", attachments)
282
283
  end

284
  def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
Maksim's avatar
Maksim committed
285
286
287
    object
    |> Map.put("attachment", [attachment])
    |> fix_attachments()
288
289
  end

290
  def fix_attachments(object), do: object
291

292
  def fix_url(%{"url" => url} = object) when is_map(url) do
293
    Map.put(object, "url", url["href"])
294
295
  end

Haelwenn's avatar
Haelwenn committed
296
  def fix_url(%{"url" => url} = object) when is_list(url) do
297
298
299
300
301
302
303
304
305
    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

306
    Map.put(object, "url", url_string)
307
308
309
310
  end

  def fix_url(object), do: object

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

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

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

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

328
    Map.put(object, "emoji", emoji)
329
330
  end

331
  def fix_emoji(object), do: object
332

333
  def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
334
    tags =
335
      tag
lain's avatar
lain committed
336
      |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
337
338
339
      |> Enum.map(fn
        %{"name" => "#" <> hashtag} -> String.downcase(hashtag)
        %{"name" => hashtag} -> String.downcase(hashtag)
340
      end)
341

342
    Map.put(object, "tag", tag ++ tags)
343
344
  end

345
346
347
348
  def fix_tag(%{"tag" => %{} = tag} = object) do
    object
    |> Map.put("tag", [tag])
    |> fix_tag
349
350
  end

351
  def fix_tag(object), do: object
352

353
354
355
356
357
  # 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)

358
    Map.put(object, "content", content)
359
360
361
362
  end

  def fix_content_map(object), do: object

363
364
365
  defp fix_type(%{"type" => "Note", "inReplyTo" => reply_id, "name" => _} = object, options)
       when is_binary(reply_id) do
    options = Keyword.put(options, :fetch, true)
366

367
    with %Object{data: %{"type" => "Question"}} <- Object.normalize(reply_id, options) do
368
369
      Map.put(object, "type", "Answer")
    else
370
      _ -> object
371
372
373
    end
  end

374
  defp fix_type(object, _options), do: object
375

376
377
378
379
380
381
382
383
384
385
386
  # 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

387
388
  def handle_incoming(data, options \\ [])

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

411
  # disallow objects with bogus IDs
412
413
  def handle_incoming(%{"id" => nil}, _options), do: :error
  def handle_incoming(%{"id" => ""}, _options), do: :error
414
  # length of https:// = 8, should validate better, but good enough for now.
rinpatch's avatar
rinpatch committed
415
  def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
416
    do: :error
417

418
419
420
421
422
423
424
425
426
427
428
  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
429
430
      reply_depth = (options[:depth] || 0) + 1
      options = Keyword.put(options, :depth, reply_depth)
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
      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

449
450
451
452
453
454
455
456
457
458
  @misskey_reactions %{
    "like" => "👍",
    "love" => "❤️",
    "laugh" => "😆",
    "hmm" => "🤔",
    "surprise" => "😮",
    "congrats" => "🎉",
    "angry" => "💢",
    "confused" => "😥",
    "rip" => "😇",
459
460
    "pudding" => "🍮",
    "star" => "⭐"
461
462
  }

lain's avatar
lain committed
463
  @doc "Rewrite misskey likes into EmojiReacts"
464
465
466
467
468
469
470
471
  def handle_incoming(
        %{
          "type" => "Like",
          "_misskey_reaction" => reaction
        } = data,
        options
      ) do
    data
lain's avatar
lain committed
472
    |> Map.put("type", "EmojiReact")
473
    |> Map.put("content", @misskey_reactions[reaction] || reaction)
474
475
476
    |> handle_incoming(options)
  end

Haelwenn's avatar
Haelwenn committed
477
  def handle_incoming(
478
        %{"type" => "Create", "object" => %{"type" => objtype, "id" => obj_id}} = data,
Haelwenn's avatar
Haelwenn committed
479
        options
Haelwenn's avatar
Haelwenn committed
480
      )
Haelwenn's avatar
Haelwenn committed
481
      when objtype in ~w{Question Answer ChatMessage Audio Video Event Article Note Page} do
482
483
484
485
486
487
488
    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)
489
      |> fix_quote_url(fetch_options)
490
491

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

Haelwenn's avatar
Haelwenn committed
494
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
495
         nil <- Activity.get_create_by_object_ap_id(obj_id),
Haelwenn's avatar
Haelwenn committed
496
         {:ok, activity, _} <- Pipeline.common_pipeline(data, options) do
Haelwenn's avatar
Haelwenn committed
497
      {:ok, activity}
498
499
500
    else
      %Activity{} = activity -> {:ok, activity}
      e -> e
Haelwenn's avatar
Haelwenn committed
501
502
503
    end
  end

504
  def handle_incoming(%{"type" => type} = data, _options)
Alexander Strizhakov's avatar
Alexander Strizhakov committed
505
      when type in ~w{Like EmojiReact Announce Add Remove} do
lain's avatar
lain committed
506
507
508
    with :ok <- ObjectValidator.fetch_actor_and_object(data),
         {:ok, activity, _meta} <-
           Pipeline.common_pipeline(data, local: false) do
lain's avatar
lain committed
509
510
      {:ok, activity}
    else
511
      e -> {:error, e}
lain's avatar
lain committed
512
513
514
    end
  end

lain's avatar
lain committed
515
  def handle_incoming(
516
        %{"type" => type} = data,
517
        _options
518
      )
519
      when type in ~w{Update Block Follow Accept Reject} do
520
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
521
522
         {:ok, activity, _} <-
           Pipeline.common_pipeline(data, local: false) do
523
      {:ok, activity}
lain's avatar
lain committed
524
525
526
    end
  end

lain's avatar
lain committed
527
  def handle_incoming(
528
        %{"type" => "Delete"} = data,
529
        _options
lain's avatar
lain committed
530
      ) do
531
532
    with {:ok, activity, _} <-
           Pipeline.common_pipeline(data, local: false) do
lain's avatar
lain committed
533
      {:ok, activity}
534
    else
Haelwenn's avatar
Haelwenn committed
535
      {:error, {:validate, _}} = e ->
536
        # Check if we have a create activity for this
537
        with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
538
539
540
541
542
543
544
545
546
             %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
547
548
549
    end
  end

normandy's avatar
normandy committed
550
551
552
553
554
555
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Follow", "object" => followed},
          "actor" => follower,
          "id" => id
556
557
        } = _data,
        _options
normandy's avatar
normandy committed
558
      ) do
normandy's avatar
normandy committed
559
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
560
         {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
normandy's avatar
normandy committed
561
         {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
normandy's avatar
normandy committed
562
563
564
      User.unfollow(follower, followed)
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
565
      _e -> :error
normandy's avatar
normandy committed
566
567
568
    end
  end

569
570
571
  def handle_incoming(
        %{
          "type" => "Undo",
572
          "object" => %{"type" => type}
573
574
        } = data,
        _options
575
      )
576
      when type in ["Like", "EmojiReact", "Announce", "Block"] do
577
    with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
578
579
580
581
      {:ok, activity}
    end
  end

582
  # For Undos that don't have the complete object attached, try to find it in our database.
normandy's avatar
normandy committed
583
584
585
  def handle_incoming(
        %{
          "type" => "Undo",
586
587
588
589
590
591
592
593
594
          "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
595
    else
Maksim's avatar
Maksim committed
596
      _e -> :error
normandy's avatar
normandy committed
597
598
599
    end
  end

minibikini's avatar
minibikini committed
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
  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

618
  def handle_incoming(_, _), do: :error
619

620
  @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
621
  def get_obj_helper(id, options \\ []) do
622
623
624
    options = Keyword.put(options, :fetch, true)

    case Object.normalize(id, options) do
Maksim's avatar
Maksim committed
625
626
      %Object{} = object -> {:ok, object}
      _ -> nil
627
    end
628
629
  end

630
  @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
Thibaut Girka's avatar
Thibaut Girka committed
631
  def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
632
633
        ap_id: ap_id
      })
Thibaut Girka's avatar
Thibaut Girka committed
634
      when attributed_to == ap_id do
635
636
637
638
639
    with {:ok, activity} <-
           handle_incoming(%{
             "type" => "Create",
             "to" => data["to"],
             "cc" => data["cc"],
Thibaut Girka's avatar
Thibaut Girka committed
640
             "actor" => attributed_to,
641
642
             "object" => data
           }) do
643
      {:ok, Object.normalize(activity, fetch: false)}
644
645
646
647
648
649
650
651
652
    else
      _ -> get_obj_helper(object_id)
    end
  end

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

653
654
655
656
  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)
657
658
659
660
    else
      _e -> object
    end
  end
lain's avatar
lain committed
661

662
663
  def set_reply_to_uri(obj), do: obj

664
665
666
667
668
669
670
671
  # Misskey quotes
  # Despite being underscored, it's potentially more reliable for interop.
  def set_quote_url(%{"quoteUrl" => quote_url} = object) when is_binary(quote_url) do
    Map.put(object, "_misskey_quote", quote_url)
  end

  def set_quote_url(obj), do: obj

672
673
674
675
  @doc """
  Serialized Mastodon-compatible `replies` collection containing _self-replies_.
  Based on Mastodon's ActivityPub::NoteSerializer#replies.
  """
676
  def set_replies(obj_data) do
677
    replies_uris =
Ivan Tashkinov's avatar
Ivan Tashkinov committed
678
679
      with limit when limit > 0 <-
             Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
680
681
682
683
           %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
        object
        |> Object.self_replies()
        |> select([o], fragment("?->>'id'", o.data))
684
685
        |> limit(^limit)
        |> Repo.all()
Ivan Tashkinov's avatar
Ivan Tashkinov committed
686
687
      else
        _ -> []
688
689
      end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
690
    set_replies(obj_data, replies_uris)
691
692
  end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
693
  defp set_replies(obj, []) do
694
695
696
697
698
699
    obj
  end

  defp set_replies(obj, replies_uris) do
    replies_collection = %{
      "type" => "Collection",
700
      "items" => replies_uris
701
702
703
704
705
    }

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

Ivan Tashkinov's avatar
Ivan Tashkinov committed
706
707
708
  def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
    items
  end
709

Ivan Tashkinov's avatar
Ivan Tashkinov committed
710
711
  def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
    items
712
713
714
715
  end

  def replies(_), do: []

716
  # Prepares the object of an outgoing create activity.
lain's avatar
lain committed
717
718
  def prepare_object(object) do
    object
lain's avatar
lain committed
719
    |> add_hashtags
lain's avatar
lain committed
720
    |> add_mention_tags
lain's avatar
lain committed
721
    |> add_emoji_tags
lain's avatar
lain committed
722
    |> add_attributed_to
lain's avatar
lain committed
723
    |> prepare_attachments
lain's avatar
lain committed
724
    |> set_conversation
725
    |> set_reply_to_uri
726
    |> set_quote_url
727
    |> set_replies
728
729
    |> strip_internal_fields
    |> strip_internal_tags
730
    |> set_type
lain's avatar
lain committed
731
732
  end

feld's avatar
feld committed
733
734
735
736
  #  @doc
  #  """
  #  internal -> Mastodon
  #  """
lain's avatar
lain committed
737

738
739
  def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
      when activity_type in ["Create", "Listen"] do
lain's avatar
lain committed
740
    object =
minibikini's avatar
minibikini committed
741
      object_id
742
      |> Object.normalize(fetch: false)
minibikini's avatar
minibikini committed
743
      |> Map.get(:data)
lain's avatar
lain committed
744
745
746
747
748
      |> prepare_object

    data =
      data
      |> Map.put("object", object)
lain's avatar
lain committed
749
      |> Map.merge(Utils.make_json_ld_header())
minibikini's avatar
minibikini committed
750
      |> Map.delete("bcc")
lain's avatar
lain committed
751
752
753
754

    {:ok, data}
  end

755
756
757
  def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
    object =
      object_id
758
      |> Object.normalize(fetch: false)
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775

    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
776
777
778
  # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
  # because of course it does.
  def prepare_outgoing(%{"type" => "Accept"} = data) do
779
    with follow_activity <- Activity.normalize(data["object"]) do
kaniini's avatar
kaniini committed
780
781
782
783
784
785
786
787
788
789
      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
790
        |> Map.merge(Utils.make_json_ld_header())
kaniini's avatar
kaniini committed
791
792
793
794
795

      {:ok, data}
    end
  end

796
  def prepare_outgoing(%{"type" => "Reject"} = data) do
797
    with follow_activity <- Activity.normalize(data["object"]) do
798
799
800
801
802
803
804
805
806
807
      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
808
        |> Map.merge(Utils.make_json_ld_header())
809
810
811
812
813

      {:ok, data}
    end
  end

feld's avatar
feld committed
814
  def prepare_outgoing(%{"type" => _type} = data) do
lain's avatar
lain committed
815
816
    data =
      data
817
      |> strip_internal_fields
lain's avatar
lain committed
818
      |> maybe_fix_object_url
lain's avatar
lain committed
819
      |> Map.merge(Utils.make_json_ld_header())
820
821
822
823

    {:ok, data}
  end

824
825
826
827
828
829
  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)
830
    else
831
832
833
834
835
836
      {:fetch, e} ->
        Logger.error("Couldn't fetch #{object} #{inspect(e)}")
        data

      _ ->
        data
837
838
839
    end
  end

840
841
  def maybe_fix_object_url(data), do: data

lain's avatar
lain committed
842
  def add_hashtags(object) do
843
844
845
846
847
848
849
850
851
852
853
854
855
856
    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
857
      end)
lain's avatar
lain committed
858

859
    Map.put(object, "tag", tags)
lain's avatar
lain committed
860
861
  end

862
863
  # 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
864
  def add_mention_tags(object) do
865
866
867
868
869
    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
870

lain's avatar
lain committed
871
    tags = object["tag"] || []
872
    Map.put(object, "tag", tags ++ mentions)
lain's avatar
lain committed
873
874
  end

Maksim's avatar
Maksim committed
875
876
877
  defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
    %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
  end
Haelwenn's avatar
Haelwenn committed
878

879
  def take_emoji_tags(%User{emoji: emoji}) do
Maksim's avatar
Maksim committed
880
    emoji
881
    |> Map.to_list()
Maksim's avatar
Maksim committed
882
    |> Enum.map(&build_emoji_tag/1)
Haelwenn's avatar
Haelwenn committed
883
884
  end

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

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

891
    Map.put(object, "tag", tags ++ out)
lain's avatar
lain committed
892
893
  end

894
  def add_emoji_tags(object), do: object
Haelwenn's avatar
Haelwenn committed
895

Maksim's avatar
Maksim committed
896
897
  defp build_emoji_tag({name, url}) do
    %{
feld's avatar
feld committed
898
      "icon" => %{"url" => "#{URI.encode(url)}", "type" => "Image"},
Maksim's avatar
Maksim committed
899
900
901
902
903
904
905
      "name" => ":" <> name <> ":",
      "type" => "Emoji",
      "updated" => "1970-01-01T00:00:00Z",
      "id" => url
    }
  end

lain's avatar
lain committed
906
907
908
909
  def set_conversation(object) do
    Map.put(object, "conversation", object["context"])
  end

910
911
912
913
914
915
  def set_type(%{"type" => "Answer"} = object) do
    Map.put(object, "type", "Note")
  end

  def set_type(object), do: object

lain's avatar
lain committed
916
  def add_attributed_to(object) do
917
    attributed_to = object["attributedTo"] || object["actor"]
918
    Map.put(object, "attributedTo", attributed_to)
919
  end
lain's avatar
lain committed
920

921
922
923
  # TODO: Revisit this
  def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object

lain's avatar
lain committed
924
  def prepare_attachments(object) do
lain's avatar
lain committed
925
    attachments =
Maksim's avatar
Maksim committed
926
927
      object
      |> Map.get("attachment", [])
lain's avatar
lain committed
928
      |> Enum.map(fn data ->
929
        [%{"mediaType" => media_type, "href" => href} = url | _] = data["url"]
Maksim's avatar
Maksim committed
930
931
932
933
934
935
936

        %{
          "url" => href,
          "mediaType" => media_type,
          "name" => data["name"],
          "type" => "Document"
        }
937
938
        |> Maps.put_if_present("width", url["width"])
        |> Maps.put_if_present("height", url["height"])
Alex Gleason's avatar
Alex Gleason committed
939
        |> Maps.put_if_present("blurhash", data["blurhash"])
lain's avatar
lain committed
940
      end)
lain's avatar
lain committed
941

942
    Map.put(object, "attachment", attachments)
lain's avatar
lain committed
943
  end
lain's avatar
lain committed
944

945
  def strip_internal_fields(object) do
Maksim's avatar
Maksim committed
946
    Map.drop(object, Pleroma.Constants.object_internal_fields())
947
948
949
  end

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

952
    Map.put(object, "tag", tags)
953
954
955
956
  end

  defp strip_internal_tags(object), do: object

957
  def perform(:user_upgrade, user) do
958
959
    # 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
960

961
962
963
964
965
966
967
968
969
970
971
972
    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
973
        ]
974
975
976
      ]
    )
    |> Repo.update_all([])
lain's avatar
lain committed