transmogrifier.ex 30.3 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
Maksim's avatar
Maksim committed
10
  alias Pleroma.EarmarkRenderer
11
  alias Pleroma.EctoType.ActivityPub.ObjectValidators
12
  alias Pleroma.FollowingRelationship
13
  alias Pleroma.Maps
Haelwenn's avatar
Haelwenn committed
14
  alias Pleroma.Object
rinpatch's avatar
rinpatch committed
15
  alias Pleroma.Object.Containment
Haelwenn's avatar
Haelwenn committed
16
  alias Pleroma.Repo
17
  alias Pleroma.User
Haelwenn's avatar
Haelwenn committed
18
  alias Pleroma.Web.ActivityPub.ActivityPub
19
  alias Pleroma.Web.ActivityPub.Builder
20
21
  alias Pleroma.Web.ActivityPub.ObjectValidator
  alias Pleroma.Web.ActivityPub.Pipeline
Haelwenn's avatar
Haelwenn committed
22
  alias Pleroma.Web.ActivityPub.Utils
lain's avatar
lain committed
23
  alias Pleroma.Web.ActivityPub.Visibility
24
  alias Pleroma.Web.Federator
25
  alias Pleroma.Workers.TransmogrifierWorker
26

lain's avatar
lain committed
27
28
  import Ecto.Query

29
  require Logger
30
  require Pleroma.Constants
31

32
33
34
  @doc """
  Modifies an incoming AP object (mastodon format) to our internal format.
  """
35
  def fix_object(object, options \\ []) do
36
    object
37
    |> strip_internal_fields
38
    |> fix_actor
39
    |> fix_url
40
    |> fix_attachments
lain's avatar
lain committed
41
    |> fix_context
42
    |> fix_in_reply_to(options)
lain's avatar
lain committed
43
    |> fix_emoji
44
    |> fix_tag
45
    |> fix_content_map
46
    |> fix_addressing
47
    |> fix_summary
48
    |> fix_type(options)
Maksim's avatar
Maksim committed
49
    |> fix_content
50
51
52
  end

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

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

61
  def fix_summary(object), do: Map.put(object, "summary", "")
62
63

  def fix_addressing_list(map, field) do
64
65
    addrs = map[field]

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

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

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

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

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

    final_cc =
      (cc ++ explicit_cc)
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
  def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object
98

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

102
  def fix_explicit_addressing(object) do
103
    explicit_mentions = Utils.determine_explicit_mentions(object)
104

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

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

117
    fix_explicit_addressing(object, explicit_mentions, follower_collection)
lain's avatar
lain committed
118
119
  end

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

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

        true ->
          object
      end
138
    else
139
      object
140
141
142
    end
  end

143
144
  def fix_implicit_addressing(object, _), do: object

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

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

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

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

167
168
169
  def fix_in_reply_to(object, options \\ [])

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

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

193
  def fix_in_reply_to(object, _options), do: object
lain's avatar
lain committed
194

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

lain's avatar
lain committed
214
    object
Haelwenn's avatar
Haelwenn committed
215
    |> Map.put("context", context)
216
    |> Map.drop(["conversation"])
lain's avatar
lain committed
217
218
  end

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

        media_type =
          cond do
231
232
233
            is_map(url) && MIME.valid?(url["mediaType"]) -> url["mediaType"]
            MIME.valid?(data["mediaType"]) -> data["mediaType"]
            MIME.valid?(data["mimeType"]) -> data["mimeType"]
234
235
236
237
238
239
240
241
            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
242
            true -> nil
243
244
          end

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

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

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

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

274
  def fix_attachments(object), do: object
275

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

280
281
  def fix_url(%{"type" => object_type, "url" => url} = object)
      when object_type in ["Video", "Audio"] and is_list(url) do
Haelwenn's avatar
Haelwenn committed
282
283
284
    attachment =
      Enum.find(url, fn x ->
        media_type = x["mediaType"] || x["mimeType"] || ""
285

Haelwenn's avatar
Haelwenn committed
286
287
288
289
290
        is_map(x) and String.starts_with?(media_type, ["audio/", "video/"])
      end)

    link_element =
      Enum.find(url, fn x -> is_map(x) and (x["mediaType"] || x["mimeType"]) == "text/html" end)
291
292

    object
Haelwenn's avatar
Haelwenn committed
293
    |> Map.put("attachment", [attachment])
294
295
296
297
298
    |> Map.put("url", link_element["href"])
  end

  def fix_url(%{"type" => object_type, "url" => url} = object)
      when object_type != "Video" and is_list(url) do
299
300
301
302
303
304
305
306
307
    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

308
    Map.put(object, "url", url_string)
309
310
311
312
  end

  def fix_url(object), do: object

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

320
        Map.put(mapping, name, data["icon"]["url"])
lain's avatar
lain committed
321
      end)
lain's avatar
lain committed
322
323
324
325

    # we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
    emoji = Map.merge(object["emoji"] || %{}, emoji)

326
    Map.put(object, "emoji", emoji)
lain's avatar
lain committed
327
328
  end

329
330
331
332
  def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
    name = String.trim(tag["name"], ":")
    emoji = %{name => tag["icon"]["url"]}

333
    Map.put(object, "emoji", emoji)
334
335
  end

336
  def fix_emoji(object), do: object
337

338
  def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
lain's avatar
lain committed
339
    tags =
340
      tag
lain's avatar
lain committed
341
342
      |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
      |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
343

344
    Map.put(object, "tag", tag ++ tags)
345
346
  end

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

350
    Map.put(object, "tag", combined)
351
352
  end

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

355
  def fix_tag(object), do: object
356

357
358
359
360
361
  # 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)

362
    Map.put(object, "content", content)
363
364
365
366
  end

  def fix_content_map(object), do: object

367
368
  def fix_type(object, options \\ [])

369
370
  def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
      when is_binary(reply_id) do
371
    with true <- Federator.allowed_thread_distance?(options[:depth]),
372
         {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
373
374
      Map.put(object, "type", "Answer")
    else
375
      _ -> object
376
377
378
    end
  end

379
  def fix_type(object, _), do: object
380

Maksim's avatar
Maksim committed
381
382
383
384
385
386
387
388
  defp fix_content(%{"mediaType" => "text/markdown", "content" => content} = object)
       when is_binary(content) do
    html_content =
      content
      |> Earmark.as_html!(%Earmark.Options{renderer: EarmarkRenderer})
      |> Pleroma.HTML.filter_tags()

    Map.merge(object, %{"content" => html_content, "mediaType" => "text/html"})
Maksim's avatar
Maksim committed
389
390
  end

Maksim's avatar
Maksim committed
391
  defp fix_content(object), do: object
Maksim's avatar
Maksim committed
392

393
  defp get_follow_activity(follow_object, _followed) do
Maksim's avatar
Maksim committed
394
395
396
397
398
399
400
401
402
    with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
         {_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
      {:ok, activity}
    else
      _ ->
        {:error, nil}
    end
  end

403
404
405
406
407
408
409
410
411
412
413
  # 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

414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
  # 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

437
438
  def handle_incoming(data, options \\ [])

439
440
  # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
  # with nil ID.
441
  def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
442
443
444
445
    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.
446
         %User{} = account <- get_reported(objects),
447
448
         # Remove the reported user from the object list.
         statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
449
      %{
450
451
452
453
454
        actor: actor,
        context: context,
        account: account,
        statuses: statuses,
        content: content,
455
        additional: %{"cc" => [account.ap_id]}
456
      }
457
      |> ActivityPub.flag()
458
459
460
    end
  end

461
  # disallow objects with bogus IDs
462
463
  def handle_incoming(%{"id" => nil}, _options), do: :error
  def handle_incoming(%{"id" => ""}, _options), do: :error
464
  # length of https:// = 8, should validate better, but good enough for now.
rinpatch's avatar
rinpatch committed
465
  def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
466
    do: :error
467

468
469
470
  # TODO: validate those with a Ecto scheme
  # - tags
  # - emoji
471
472
473
474
  def handle_incoming(
        %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
        options
      )
Haelwenn's avatar
Haelwenn committed
475
      when objtype in ["Article", "Event", "Note", "Video", "Page", "Audio"] do
476
    actor = Containment.get_actor(data)
477

478
    with nil <- Activity.get_create_by_object_ap_id(object["id"]),
479
480
481
482
483
484
485
486
         {: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
487
488
489
490
491
492
493
494
495
        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
496
497
498
499
        end

        {:ok, created_activity}
      end
500
    else
lain's avatar
lain committed
501
      %Activity{} = activity -> {:ok, activity}
502
503
504
505
      _e -> :error
    end
  end

506
507
508
509
510
511
512
513
514
515
516
  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
517
518
      reply_depth = (options[:depth] || 0) + 1
      options = Keyword.put(options, :depth, reply_depth)
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
      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

537
  def handle_incoming(
538
        %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
539
        _options
540
      ) do
541
    with actor <- Containment.get_actor(data),
542
         {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
543
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
544
         {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
545
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
546
         {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_reject),
lain's avatar
lain committed
547
         {:ok, activity} <-
548
           ActivityPub.reject(%{
lain's avatar
lain committed
549
             to: follow_activity.data["to"],
550
             type: "Reject",
551
             actor: followed,
lain's avatar
lain committed
552
             object: follow_activity.data["id"],
553
554
             local: false,
             activity_id: id
lain's avatar
lain committed
555
           }) do
556
      {:ok, activity}
557
558
    else
      _e -> :error
559
560
561
    end
  end

562
563
564
565
566
567
568
569
570
571
  @misskey_reactions %{
    "like" => "👍",
    "love" => "❤️",
    "laugh" => "😆",
    "hmm" => "🤔",
    "surprise" => "😮",
    "congrats" => "🎉",
    "angry" => "💢",
    "confused" => "😥",
    "rip" => "😇",
572
573
    "pudding" => "🍮",
    "star" => "⭐"
574
575
  }

lain's avatar
lain committed
576
  @doc "Rewrite misskey likes into EmojiReacts"
577
578
579
580
581
582
583
584
  def handle_incoming(
        %{
          "type" => "Like",
          "_misskey_reaction" => reaction
        } = data,
        options
      ) do
    data
lain's avatar
lain committed
585
    |> Map.put("type", "EmojiReact")
586
    |> Map.put("content", @misskey_reactions[reaction] || reaction)
587
588
589
    |> handle_incoming(options)
  end

Haelwenn's avatar
Haelwenn committed
590
  def handle_incoming(
lain's avatar
lain committed
591
        %{"type" => "Create", "object" => %{"type" => objtype}} = data,
Haelwenn's avatar
Haelwenn committed
592
        _options
Haelwenn's avatar
Haelwenn committed
593
      )
lain's avatar
lain committed
594
      when objtype in ["Question", "Answer", "ChatMessage"] do
Haelwenn's avatar
Haelwenn committed
595
596
597
598
599
600
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
         {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
      {:ok, activity}
    end
  end

601
  def handle_incoming(%{"type" => type} = data, _options)
602
      when type in ~w{Like EmojiReact Announce} do
lain's avatar
lain committed
603
604
605
    with :ok <- ObjectValidator.fetch_actor_and_object(data),
         {:ok, activity, _meta} <-
           Pipeline.common_pipeline(data, local: false) do
lain's avatar
lain committed
606
607
      {:ok, activity}
    else
608
      e -> {:error, e}
lain's avatar
lain committed
609
610
611
    end
  end

lain's avatar
lain committed
612
  def handle_incoming(
613
        %{"type" => type} = data,
614
        _options
615
      )
616
      when type in ~w{Update Block Follow Accept} do
617
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
618
619
         {:ok, activity, _} <-
           Pipeline.common_pipeline(data, local: false) do
620
      {:ok, activity}
lain's avatar
lain committed
621
622
623
    end
  end

lain's avatar
lain committed
624
  def handle_incoming(
625
        %{"type" => "Delete"} = data,
626
        _options
lain's avatar
lain committed
627
      ) do
628
629
    with {:ok, activity, _} <-
           Pipeline.common_pipeline(data, local: false) do
lain's avatar
lain committed
630
      {:ok, activity}
631
632
633
    else
      {:error, {:validate_object, _}} = e ->
        # Check if we have a create activity for this
634
        with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
635
636
637
638
639
640
641
642
643
             %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
644
645
646
    end
  end

normandy's avatar
normandy committed
647
648
649
650
651
652
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Follow", "object" => followed},
          "actor" => follower,
          "id" => id
653
654
        } = _data,
        _options
normandy's avatar
normandy committed
655
      ) do
normandy's avatar
normandy committed
656
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
657
         {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
normandy's avatar
normandy committed
658
         {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
normandy's avatar
normandy committed
659
660
661
      User.unfollow(follower, followed)
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
662
      _e -> :error
normandy's avatar
normandy committed
663
664
665
    end
  end

666
667
668
  def handle_incoming(
        %{
          "type" => "Undo",
669
          "object" => %{"type" => type}
670
671
        } = data,
        _options
672
      )
673
      when type in ["Like", "EmojiReact", "Announce", "Block"] do
674
    with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
675
676
677
678
      {:ok, activity}
    end
  end

679
  # For Undos that don't have the complete object attached, try to find it in our database.
normandy's avatar
normandy committed
680
681
682
  def handle_incoming(
        %{
          "type" => "Undo",
683
684
685
686
687
688
689
690
691
          "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
692
    else
Maksim's avatar
Maksim committed
693
      _e -> :error
normandy's avatar
normandy committed
694
695
696
    end
  end

minibikini's avatar
minibikini committed
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
  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

715
  def handle_incoming(_, _), do: :error
716

717
  @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
718
  def get_obj_helper(id, options \\ []) do
Maksim's avatar
Maksim committed
719
720
721
    case Object.normalize(id, true, options) do
      %Object{} = object -> {:ok, object}
      _ -> nil
722
    end
723
724
  end

725
  @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
Thibaut Girka's avatar
Thibaut Girka committed
726
  def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
727
728
        ap_id: ap_id
      })
Thibaut Girka's avatar
Thibaut Girka committed
729
      when attributed_to == ap_id do
730
731
732
733
734
    with {:ok, activity} <-
           handle_incoming(%{
             "type" => "Create",
             "to" => data["to"],
             "cc" => data["cc"],
Thibaut Girka's avatar
Thibaut Girka committed
735
             "actor" => attributed_to,
736
737
738
739
740
741
742
743
744
745
746
747
             "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

748
749
750
751
  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)
752
753
754
755
    else
      _e -> object
    end
  end
lain's avatar
lain committed
756

757
758
  def set_reply_to_uri(obj), do: obj

759
760
761
762
  @doc """
  Serialized Mastodon-compatible `replies` collection containing _self-replies_.
  Based on Mastodon's ActivityPub::NoteSerializer#replies.
  """
763
  def set_replies(obj_data) do
764
    replies_uris =
Ivan Tashkinov's avatar
Ivan Tashkinov committed
765
766
      with limit when limit > 0 <-
             Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
767
768
769
770
           %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
        object
        |> Object.self_replies()
        |> select([o], fragment("?->>'id'", o.data))
771
772
        |> limit(^limit)
        |> Repo.all()
Ivan Tashkinov's avatar
Ivan Tashkinov committed
773
774
      else
        _ -> []
775
776
      end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
777
    set_replies(obj_data, replies_uris)
778
779
  end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
780
  defp set_replies(obj, []) do
781
782
783
784
785
786
    obj
  end

  defp set_replies(obj, replies_uris) do
    replies_collection = %{
      "type" => "Collection",
787
      "items" => replies_uris
788
789
790
791
792
    }

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

Ivan Tashkinov's avatar
Ivan Tashkinov committed
793
794
795
  def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
    items
  end
796

Ivan Tashkinov's avatar
Ivan Tashkinov committed
797
798
  def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
    items
799
800
801
802
  end

  def replies(_), do: []

803
  # Prepares the object of an outgoing create activity.
lain's avatar
lain committed
804
805
  def prepare_object(object) do
    object
lain's avatar
lain committed
806
    |> set_sensitive
lain's avatar
lain committed
807
    |> add_hashtags
lain's avatar
lain committed
808
    |> add_mention_tags
lain's avatar
lain committed
809
    |> add_emoji_tags
lain's avatar
lain committed
810
    |> add_attributed_to
lain's avatar
lain committed
811
    |> prepare_attachments
lain's avatar
lain committed
812
    |> set_conversation
813
    |> set_reply_to_uri
814
    |> set_replies
815
816
    |> strip_internal_fields
    |> strip_internal_tags
817
    |> set_type
lain's avatar
lain committed
818
819
  end

feld's avatar
feld committed
820
821
822
823
  #  @doc
  #  """
  #  internal -> Mastodon
  #  """
lain's avatar
lain committed
824

825
826
  def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
      when activity_type in ["Create", "Listen"] do
lain's avatar
lain committed
827
    object =
minibikini's avatar
minibikini committed
828
829
830
      object_id
      |> Object.normalize()
      |> Map.get(:data)
lain's avatar
lain committed
831
832
833
834
835
      |> prepare_object

    data =
      data
      |> Map.put("object", object)
lain's avatar
lain committed
836
      |> Map.merge(Utils.make_json_ld_header())
minibikini's avatar
minibikini committed
837
      |> Map.delete("bcc")
lain's avatar
lain committed
838
839
840
841

    {:ok, data}
  end

842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
  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
863
864
865
  # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
  # because of course it does.
  def prepare_outgoing(%{"type" => "Accept"} = data) do
866
    with follow_activity <- Activity.normalize(data["object"]) do
kaniini's avatar
kaniini committed
867
868
869
870
871
872
873
874
875
876
      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
877
        |> Map.merge(Utils.make_json_ld_header())
kaniini's avatar
kaniini committed
878
879
880
881
882

      {:ok, data}
    end
  end

883
  def prepare_outgoing(%{"type" => "Reject"} = data) do
884
    with follow_activity <- Activity.normalize(data["object"]) do
885
886
887
888
889
890
891
892
893
894
      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
895
        |> Map.merge(Utils.make_json_ld_header())
896
897
898
899
900

      {:ok, data}
    end
  end

feld's avatar
feld committed
901
  def prepare_outgoing(%{"type" => _type} = data) do
lain's avatar
lain committed
902
903
    data =
      data
904
      |> strip_internal_fields
lain's avatar
lain committed
905
      |> maybe_fix_object_url
lain's avatar
lain committed
906
      |> Map.merge(Utils.make_json_ld_header())
907
908
909
910

    {:ok, data}
  end

911
912
913
914
915
916
  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)
917
    else
918
919
920
921
922
923
      {:fetch, e} ->
        Logger.error("Couldn't fetch #{object} #{inspect(e)}")
        data

      _ ->
        data
924
925
926
    end
  end

927
928
  def maybe_fix_object_url(data), do: data

lain's avatar
lain committed
929
  def add_hashtags(object) do
lain's avatar
lain committed
930
931
    tags =
      (object["tag"] || [])
932
933
934
935
936
937
938
939
940
941
942
943
      |> 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
944
      end)
lain's avatar
lain committed
945

946
    Map.put(object, "tag", tags)
lain's avatar
lain committed
947
948
  end

949
950
  # 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
951
  def add_mention_tags(object) do
952
953
954
955
956
    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
957

lain's avatar
lain committed
958
    tags = object["tag"] || []
959
    Map.put(object, "tag", tags ++ mentions)
lain's avatar
lain committed
960
961
  end

Maksim's avatar
Maksim committed
962
963
964
  defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
    %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
  end
Haelwenn's avatar
Haelwenn committed
965

966
  def take_emoji_tags(%User{emoji: emoji}) do
Maksim's avatar
Maksim committed
967
    emoji
968
    |> Map.to_list()
Maksim's avatar
Maksim committed
969
    |> Enum.map(&build_emoji_tag/1)
Haelwenn's avatar
Haelwenn committed
970
971
  end

lain's avatar
lain committed
972
  # TODO: we should probably send mtime instead of unix epoch time for updated