transmogrifier.ex 28 KB
Newer Older
1
# Pleroma: A lightweight social networking server
2
# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3
4
# SPDX-License-Identifier: AGPL-3.0-only

5
6
7
8
defmodule Pleroma.Web.ActivityPub.Transmogrifier do
  @moduledoc """
  A module to handle coding from internal to wire ActivityPub and back.
  """
Haelwenn's avatar
Haelwenn committed
9
  alias Pleroma.Activity
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
    |> strip_internal_fields
36
    |> fix_actor
37
    |> fix_url
38
    |> fix_attachments
lain's avatar
lain committed
39
    |> fix_context
40
    |> fix_in_reply_to(options)
lain's avatar
lain committed
41
    |> fix_emoji
42
    |> fix_tag
43
    |> set_sensitive
44
    |> fix_content_map
45
    |> fix_addressing
46
    |> fix_summary
47
    |> fix_type(options)
48
49
50
  end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        media_type =
          cond do
227
228
229
            is_map(url) && MIME.valid?(url["mediaType"]) -> url["mediaType"]
            MIME.valid?(data["mediaType"]) -> data["mediaType"]
            MIME.valid?(data["mimeType"]) -> data["mimeType"]
230
231
232
233
234
235
236
237
            true -> nil
          end

        href =
          cond do
            is_map(url) && is_binary(url["href"]) -> url["href"]
            is_binary(data["url"]) -> data["url"]
            is_binary(data["href"]) -> data["href"]
Haelwenn's avatar
Haelwenn committed
238
            true -> nil
239
240
          end

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

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

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

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

270
  def fix_attachments(object), do: object
271

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

Haelwenn's avatar
Haelwenn committed
276
  def fix_url(%{"url" => url} = object) when is_list(url) do
277
278
279
280
281
282
283
284
285
    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

286
    Map.put(object, "url", url_string)
287
288
289
290
  end

  def fix_url(object), do: object

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

298
        Map.put(mapping, name, data["icon"]["url"])
lain's avatar
lain committed
299
      end)
lain's avatar
lain committed
300

301
    Map.put(object, "emoji", emoji)
lain's avatar
lain committed
302
303
  end

304
305
306
307
  def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
    name = String.trim(tag["name"], ":")
    emoji = %{name => tag["icon"]["url"]}

308
    Map.put(object, "emoji", emoji)
309
310
  end

311
  def fix_emoji(object), do: object
312

313
  def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
lain's avatar
lain committed
314
    tags =
315
      tag
lain's avatar
lain committed
316
      |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
317
318
319
320
321
      |> Enum.map(fn %{"name" => name} ->
        name
        |> String.slice(1..-1)
        |> String.downcase()
      end)
322

323
    Map.put(object, "tag", tag ++ tags)
324
325
  end

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

329
    Map.put(object, "tag", combined)
330
331
  end

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

334
  def fix_tag(object), do: object
335

336
337
338
339
340
  # 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)

341
    Map.put(object, "content", content)
342
343
344
345
  end

  def fix_content_map(object), do: object

346
347
  def fix_type(object, options \\ [])

348
349
  def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
      when is_binary(reply_id) do
350
    with true <- Federator.allowed_thread_distance?(options[:depth]),
351
         {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
352
353
      Map.put(object, "type", "Answer")
    else
354
      _ -> object
355
356
357
    end
  end

358
  def fix_type(object, _), do: object
359

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

371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
  # 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

394
395
  def handle_incoming(data, options \\ [])

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

418
  # disallow objects with bogus IDs
419
420
  def handle_incoming(%{"id" => nil}, _options), do: :error
  def handle_incoming(%{"id" => ""}, _options), do: :error
421
  # length of https:// = 8, should validate better, but good enough for now.
rinpatch's avatar
rinpatch committed
422
  def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
423
    do: :error
424

425
426
427
  # TODO: validate those with a Ecto scheme
  # - tags
  # - emoji
428
429
430
431
  def handle_incoming(
        %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
        options
      )
Haelwenn's avatar
Haelwenn committed
432
      when objtype in ~w{Note Page} do
433
    actor = Containment.get_actor(data)
434

435
    with nil <- Activity.get_create_by_object_ap_id(object["id"]),
436
437
438
439
440
441
442
443
         {: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
444
445
446
447
448
449
450
451
452
        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
453
454
455
456
        end

        {:ok, created_activity}
      end
457
    else
lain's avatar
lain committed
458
      %Activity{} = activity -> {:ok, activity}
459
460
461
462
      _e -> :error
    end
  end

463
464
465
466
467
468
469
470
471
472
473
  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
474
475
      reply_depth = (options[:depth] || 0) + 1
      options = Keyword.put(options, :depth, reply_depth)
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
      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

494
495
496
497
498
499
500
501
502
503
  @misskey_reactions %{
    "like" => "👍",
    "love" => "❤️",
    "laugh" => "😆",
    "hmm" => "🤔",
    "surprise" => "😮",
    "congrats" => "🎉",
    "angry" => "💢",
    "confused" => "😥",
    "rip" => "😇",
504
505
    "pudding" => "🍮",
    "star" => "⭐"
506
507
  }

lain's avatar
lain committed
508
  @doc "Rewrite misskey likes into EmojiReacts"
509
510
511
512
513
514
515
516
  def handle_incoming(
        %{
          "type" => "Like",
          "_misskey_reaction" => reaction
        } = data,
        options
      ) do
    data
lain's avatar
lain committed
517
    |> Map.put("type", "EmojiReact")
518
    |> Map.put("content", @misskey_reactions[reaction] || reaction)
519
520
521
    |> handle_incoming(options)
  end

Haelwenn's avatar
Haelwenn committed
522
  def handle_incoming(
523
        %{"type" => "Create", "object" => %{"type" => objtype, "id" => obj_id}} = data,
Haelwenn's avatar
Haelwenn committed
524
        _options
Haelwenn's avatar
Haelwenn committed
525
      )
Haelwenn's avatar
Haelwenn committed
526
      when objtype in ~w{Question Answer ChatMessage Audio Video Event Article} do
527
528
    data = Map.put(data, "object", strip_internal_fields(data["object"]))

Haelwenn's avatar
Haelwenn committed
529
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
530
         nil <- Activity.get_create_by_object_ap_id(obj_id),
Haelwenn's avatar
Haelwenn committed
531
532
         {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
      {:ok, activity}
533
534
535
    else
      %Activity{} = activity -> {:ok, activity}
      e -> e
Haelwenn's avatar
Haelwenn committed
536
537
538
    end
  end

539
  def handle_incoming(%{"type" => type} = data, _options)
540
      when type in ~w{Like EmojiReact Announce} do
lain's avatar
lain committed
541
542
543
    with :ok <- ObjectValidator.fetch_actor_and_object(data),
         {:ok, activity, _meta} <-
           Pipeline.common_pipeline(data, local: false) do
lain's avatar
lain committed
544
545
      {:ok, activity}
    else
546
      e -> {:error, e}
lain's avatar
lain committed
547
548
549
    end
  end

lain's avatar
lain committed
550
  def handle_incoming(
551
        %{"type" => type} = data,
552
        _options
553
      )
554
      when type in ~w{Update Block Follow Accept Reject} do
555
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
556
557
         {:ok, activity, _} <-
           Pipeline.common_pipeline(data, local: false) do
558
      {:ok, activity}
lain's avatar
lain committed
559
560
561
    end
  end

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

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

604
605
606
  def handle_incoming(
        %{
          "type" => "Undo",
607
          "object" => %{"type" => type}
608
609
        } = data,
        _options
610
      )
611
      when type in ["Like", "EmojiReact", "Announce", "Block"] do
612
    with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
613
614
615
616
      {:ok, activity}
    end
  end

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

minibikini's avatar
minibikini committed
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
  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

653
  def handle_incoming(_, _), do: :error
654

655
  @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
656
  def get_obj_helper(id, options \\ []) do
Maksim's avatar
Maksim committed
657
658
659
    case Object.normalize(id, true, options) do
      %Object{} = object -> {:ok, object}
      _ -> nil
660
    end
661
662
  end

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

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

686
687
688
689
  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)
690
691
692
693
    else
      _e -> object
    end
  end
lain's avatar
lain committed
694

695
696
  def set_reply_to_uri(obj), do: obj

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

Ivan Tashkinov's avatar
Ivan Tashkinov committed
715
    set_replies(obj_data, replies_uris)
716
717
  end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
718
  defp set_replies(obj, []) do
719
720
721
722
723
724
    obj
  end

  defp set_replies(obj, replies_uris) do
    replies_collection = %{
      "type" => "Collection",
725
      "items" => replies_uris
726
727
728
729
730
    }

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

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

Ivan Tashkinov's avatar
Ivan Tashkinov committed
735
736
  def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
    items
737
738
739
740
  end

  def replies(_), do: []

741
  # Prepares the object of an outgoing create activity.
lain's avatar
lain committed
742
743
  def prepare_object(object) do
    object
lain's avatar
lain committed
744
    |> set_sensitive
lain's avatar
lain committed
745
    |> add_hashtags
lain's avatar
lain committed
746
    |> add_mention_tags
lain's avatar
lain committed
747
    |> add_emoji_tags
lain's avatar
lain committed
748
    |> add_attributed_to
lain's avatar
lain committed
749
    |> prepare_attachments
lain's avatar
lain committed
750
    |> set_conversation
751
    |> set_reply_to_uri
752
    |> set_replies
753
754
    |> strip_internal_fields
    |> strip_internal_tags
755
    |> set_type
lain's avatar
lain committed
756
757
  end

feld's avatar
feld committed
758
759
760
761
  #  @doc
  #  """
  #  internal -> Mastodon
  #  """
lain's avatar
lain committed
762

763
764
  def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
      when activity_type in ["Create", "Listen"] do
lain's avatar
lain committed
765
    object =
minibikini's avatar
minibikini committed
766
767
768
      object_id
      |> Object.normalize()
      |> Map.get(:data)
lain's avatar
lain committed
769
770
771
772
773
      |> prepare_object

    data =
      data
      |> Map.put("object", object)
lain's avatar
lain committed
774
      |> Map.merge(Utils.make_json_ld_header())
minibikini's avatar
minibikini committed
775
      |> Map.delete("bcc")
lain's avatar
lain committed
776
777
778
779

    {:ok, data}
  end

780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
  def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
    object =
      object_id
      |> Object.normalize()

    data =
      if Visibility.is_private?(object) && object.data["actor"] == ap_id do
        data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
      else
        data |> maybe_fix_object_url
      end

    data =
      data
      |> strip_internal_fields
      |> Map.merge(Utils.make_json_ld_header())
      |> Map.delete("bcc")

    {:ok, data}
  end

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

      {:ok, data}
    end
  end

821
  def prepare_outgoing(%{"type" => "Reject"} = data) do
822
    with follow_activity <- Activity.normalize(data["object"]) do
823
824
825
826
827
828
829
830
831
832
      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
833
        |> Map.merge(Utils.make_json_ld_header())
834
835
836
837
838

      {:ok, data}
    end
  end

feld's avatar
feld committed
839
  def prepare_outgoing(%{"type" => _type} = data) do
lain's avatar
lain committed
840
841
    data =
      data
842
      |> strip_internal_fields
lain's avatar
lain committed
843
      |> maybe_fix_object_url
lain's avatar
lain committed
844
      |> Map.merge(Utils.make_json_ld_header())
845
846
847
848

    {:ok, data}
  end

849
850
851
852
853
854
  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)
855
    else
856
857
858
859
860
861
      {:fetch, e} ->
        Logger.error("Couldn't fetch #{object} #{inspect(e)}")
        data

      _ ->
        data
862
863
864
    end
  end

865
866
  def maybe_fix_object_url(data), do: data

lain's avatar
lain committed
867
  def add_hashtags(object) do
lain's avatar
lain committed
868
869
    tags =
      (object["tag"] || [])
870
871
872
873
874
875
876
877
878
879
880
881
      |> 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
882
      end)
lain's avatar
lain committed
883

884
    Map.put(object, "tag", tags)
lain's avatar
lain committed
885
886
  end

887
888
  # 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
889
  def add_mention_tags(object) do
890
891
892
893
894
    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
895

lain's avatar
lain committed
896
    tags = object["tag"] || []
897
    Map.put(object, "tag", tags ++ mentions)
lain's avatar
lain committed
898
899
  end

Maksim's avatar
Maksim committed
900
901
902
  defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
    %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
  end
Haelwenn's avatar
Haelwenn committed
903

904
  def take_emoji_tags(%User{emoji: emoji}) do
Maksim's avatar
Maksim committed
905
    emoji
906
    |> Map.to_list()
Maksim's avatar
Maksim committed
907
    |> Enum.map(&build_emoji_tag/1)
Haelwenn's avatar
Haelwenn committed
908
909
  end

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

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

916
    Map.put(object, "tag", tags ++ out)
lain's avatar
lain committed
917
918
  end

919
  def add_emoji_tags(object), do: object
Haelwenn's avatar
Haelwenn committed
920

Maksim's avatar
Maksim committed
921
922
923
924
925
926
927
928
929
930
  defp build_emoji_tag({name, url}) do
    %{
      "icon" => %{"url" => url, "type" => "Image"},
      "name" => ":" <> name <> ":",
      "type" => "Emoji",
      "updated" => "1970-01-01T00:00:00Z",
      "id" => url
    }
  end

lain's avatar
lain committed
931
932
933
934
  def set_conversation(object) do
    Map.put(object, "conversation", object["context"])
  end

935
  def set_sensitive(%{"sensitive" => _} = object) do
936
937
938
    object
  end

lain's avatar
lain committed
939
940
941
942
943
  def set_sensitive(object) do
    tags = object["tag"] || []
    Map.put(object, "sensitive", "nsfw" in tags)
  end

944
945
946
947
948
949
  def set_type(%{"type" => "Answer"} = object) do
    Map.put(object, "type", "Note")
  end

  def set_type(object), do: object

lain's avatar
lain committed
950
  def add_attributed_to(object) do
951
    attributed_to = object["attributedTo"] || object["actor"]
952
    Map.put(object, "attributedTo", attributed_to)
953
  end
lain's avatar
lain committed
954

955
956
957
  # TODO: Revisit this
  def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object

lain's avatar
lain committed
958
  def prepare_attachments(object) do
lain's avatar
lain committed
959
    attachments =
Maksim's avatar
Maksim committed
960
961
      object
      |> Map.get("attachment", [])
lain's avatar
lain committed
962
963
      |> Enum.map(fn data ->
        [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
Maksim's avatar
Maksim committed
964
965
966
967
968
969
970

        %{
          "url" => href,
          "mediaType" => media_type,
          "name" => data["name"],
          "type" => "Document"
        }
lain's avatar
lain committed
971
      end)
lain's avatar
lain committed
972

973
    Map.put(object, "attachment", attachments)
lain's avatar
lain committed
974
  end
lain's avatar
lain committed
975

976
  def strip_internal_fields(object) do