transmogrifier.ex 31.4 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
lain's avatar
lain committed
14
  alias Pleroma.Notification
Haelwenn's avatar
Haelwenn committed
15
  alias Pleroma.Object
rinpatch's avatar
rinpatch committed
16
  alias Pleroma.Object.Containment
Haelwenn's avatar
Haelwenn committed
17
  alias Pleroma.Repo
18
  alias Pleroma.User
Haelwenn's avatar
Haelwenn committed
19
  alias Pleroma.Web.ActivityPub.ActivityPub
20
  alias Pleroma.Web.ActivityPub.Builder
21
22
  alias Pleroma.Web.ActivityPub.ObjectValidator
  alias Pleroma.Web.ActivityPub.Pipeline
Haelwenn's avatar
Haelwenn committed
23
  alias Pleroma.Web.ActivityPub.Utils
lain's avatar
lain committed
24
  alias Pleroma.Web.ActivityPub.Visibility
25
  alias Pleroma.Web.Federator
26
  alias Pleroma.Workers.TransmogrifierWorker
27

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

30
  require Logger
31
  require Pleroma.Constants
32

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

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

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

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

  def fix_addressing_list(map, field) do
65
66
67
68
69
70
71
72
73
    cond do
      is_binary(map[field]) ->
        Map.put(map, field, [map[field]])

      is_nil(map[field]) ->
        Map.put(map, field, [])

      true ->
        map
74
75
76
    end
  end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

157
  def fix_actor(%{"attributedTo" => actor} = object) do
158
    Map.put(object, "actor", Containment.get_actor(%{"actor" => actor}))
159
160
  end

161
162
163
  def fix_in_reply_to(object, options \\ [])

  def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
164
      when not is_nil(in_reply_to) do
165
    in_reply_to_id = prepare_in_reply_to(in_reply_to)
166
    object = Map.put(object, "inReplyToAtomUri", in_reply_to_id)
167
    depth = (options[:depth] || 0) + 1
lain's avatar
lain committed
168

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

187
  def fix_in_reply_to(object, _options), do: object
lain's avatar
lain committed
188

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

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

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

        media_type =
          cond do
225
226
227
            is_map(url) && MIME.valid?(url["mediaType"]) -> url["mediaType"]
            MIME.valid?(data["mediaType"]) -> data["mediaType"]
            MIME.valid?(data["mimeType"]) -> data["mimeType"]
228
229
230
231
232
233
234
235
            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
236
            true -> nil
237
238
          end

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

Haelwenn's avatar
Haelwenn committed
245
246
247
248
249
250
251
          %{"url" => [attachment_url]}
          |> Maps.put_if_present("mediaType", media_type)
          |> Maps.put_if_present("type", data["type"])
          |> Maps.put_if_present("name", data["name"])
        else
          nil
        end
lain's avatar
lain committed
252
      end)
Haelwenn's avatar
Haelwenn committed
253
      |> Enum.filter(& &1)
lain's avatar
lain committed
254

255
    Map.put(object, "attachment", attachments)
256
257
  end

258
  def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
Maksim's avatar
Maksim committed
259
260
261
    object
    |> Map.put("attachment", [attachment])
    |> fix_attachments()
262
263
  end

264
  def fix_attachments(object), do: object
265

266
  def fix_url(%{"url" => url} = object) when is_map(url) do
267
    Map.put(object, "url", url["href"])
268
269
  end

270
271
  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
272
273
274
    attachment =
      Enum.find(url, fn x ->
        media_type = x["mediaType"] || x["mimeType"] || ""
275

Haelwenn's avatar
Haelwenn committed
276
277
278
279
280
        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)
281
282

    object
Haelwenn's avatar
Haelwenn committed
283
    |> Map.put("attachment", [attachment])
284
285
286
287
288
    |> 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
289
290
291
292
293
294
295
296
297
    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

298
    Map.put(object, "url", url_string)
299
300
301
302
  end

  def fix_url(object), do: object

303
  def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
lain's avatar
lain committed
304
    emoji =
305
306
      tags
      |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
lain's avatar
lain committed
307
      |> Enum.reduce(%{}, fn data, mapping ->
308
        name = String.trim(data["name"], ":")
lain's avatar
lain committed
309

310
        Map.put(mapping, name, data["icon"]["url"])
lain's avatar
lain committed
311
      end)
lain's avatar
lain committed
312
313
314
315

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

316
    Map.put(object, "emoji", emoji)
lain's avatar
lain committed
317
318
  end

319
320
321
322
  def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
    name = String.trim(tag["name"], ":")
    emoji = %{name => tag["icon"]["url"]}

323
    Map.put(object, "emoji", emoji)
324
325
  end

326
  def fix_emoji(object), do: object
327

328
  def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
lain's avatar
lain committed
329
    tags =
330
      tag
lain's avatar
lain committed
331
332
      |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
      |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
333

334
    Map.put(object, "tag", tag ++ tags)
335
336
  end

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

340
    Map.put(object, "tag", combined)
341
342
  end

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

345
  def fix_tag(object), do: object
346

347
348
349
350
351
  # 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)

352
    Map.put(object, "content", content)
353
354
355
356
  end

  def fix_content_map(object), do: object

357
358
  def fix_type(object, options \\ [])

359
360
  def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
      when is_binary(reply_id) do
361
    with true <- Federator.allowed_thread_distance?(options[:depth]),
362
         {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
363
364
      Map.put(object, "type", "Answer")
    else
365
      _ -> object
366
367
368
    end
  end

369
  def fix_type(object, _), do: object
370

Maksim's avatar
Maksim committed
371
372
373
374
375
376
377
378
  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
379
380
  end

Maksim's avatar
Maksim committed
381
  defp fix_content(object), do: object
Maksim's avatar
Maksim committed
382

Maksim's avatar
Maksim committed
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
  defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
    with true <- id =~ "follows",
         %User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
         %Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
      {:ok, activity}
    else
      _ -> {:error, nil}
    end
  end

  defp mastodon_follow_hack(_, _), do: {:error, nil}

  defp get_follow_activity(follow_object, followed) do
    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
      # Can't find the activity. This might a Mastodon 2.3 "Accept"
      {:activity, nil} ->
        mastodon_follow_hack(follow_object, followed)

      _ ->
        {:error, nil}
    end
  end

409
410
411
412
413
414
415
416
417
418
419
  # 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

420
421
  def handle_incoming(data, options \\ [])

422
423
  # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
  # with nil ID.
424
  def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
425
426
427
428
    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.
429
         %User{} = account <- get_reported(objects),
430
431
         # Remove the reported user from the object list.
         statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
432
      %{
433
434
435
436
437
        actor: actor,
        context: context,
        account: account,
        statuses: statuses,
        content: content,
438
        additional: %{"cc" => [account.ap_id]}
439
      }
440
      |> ActivityPub.flag()
441
442
443
    end
  end

444
  # disallow objects with bogus IDs
445
446
  def handle_incoming(%{"id" => nil}, _options), do: :error
  def handle_incoming(%{"id" => ""}, _options), do: :error
447
  # length of https:// = 8, should validate better, but good enough for now.
rinpatch's avatar
rinpatch committed
448
  def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
449
    do: :error
450

451
452
453
  # TODO: validate those with a Ecto scheme
  # - tags
  # - emoji
454
455
456
457
  def handle_incoming(
        %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
        options
      )
458
      when objtype in ["Article", "Event", "Note", "Video", "Page", "Question", "Answer", "Audio"] do
459
    actor = Containment.get_actor(data)
460

461
    with nil <- Activity.get_create_by_object_ap_id(object["id"]),
lain's avatar
lain committed
462
463
         {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(actor),
         data <- Map.put(data, "actor", actor) |> fix_addressing() do
464
      object = fix_object(object, options)
465

466
467
468
469
      params = %{
        to: data["to"],
        object: object,
        actor: user,
470
        context: object["context"],
471
472
        local: false,
        published: data["published"],
lain's avatar
lain committed
473
474
475
        additional:
          Map.take(data, [
            "cc",
476
            "directMessage",
lain's avatar
lain committed
477
478
            "id"
          ])
479
480
      }

481
      with {:ok, created_activity} <- ActivityPub.create(params) do
482
483
484
485
486
487
488
489
490
        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
491
492
493
494
        end

        {:ok, created_activity}
      end
495
    else
lain's avatar
lain committed
496
      %Activity{} = activity -> {:ok, activity}
497
498
499
500
      _e -> :error
    end
  end

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

532
  def handle_incoming(
533
        %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
534
        _options
535
      ) do
536
    with actor <- Containment.get_actor(data),
537
         {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
538
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
539
         {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
540
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
541
         {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept) do
542
543
544
      User.update_follower_count(followed)
      User.update_following_count(follower)

545
546
      Notification.update_notification_type(followed, follow_activity)

547
548
549
550
551
      ActivityPub.accept(%{
        to: follow_activity.data["to"],
        type: "Accept",
        actor: followed,
        object: follow_activity.data["id"],
552
553
        local: false,
        activity_id: id
554
      })
555
    else
556
557
      _e ->
        :error
558
559
560
561
    end
  end

  def handle_incoming(
562
        %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
563
        _options
564
      ) do
565
    with actor <- Containment.get_actor(data),
566
         {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
567
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
568
         {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
569
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
570
         {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_reject),
lain's avatar
lain committed
571
         {:ok, activity} <-
572
           ActivityPub.reject(%{
lain's avatar
lain committed
573
             to: follow_activity.data["to"],
574
             type: "Reject",
575
             actor: followed,
lain's avatar
lain committed
576
             object: follow_activity.data["id"],
577
578
             local: false,
             activity_id: id
lain's avatar
lain committed
579
           }) do
580
      {:ok, activity}
581
582
    else
      _e -> :error
583
584
585
    end
  end

586
587
588
589
590
591
592
593
594
595
  @misskey_reactions %{
    "like" => "👍",
    "love" => "❤️",
    "laugh" => "😆",
    "hmm" => "🤔",
    "surprise" => "😮",
    "congrats" => "🎉",
    "angry" => "💢",
    "confused" => "😥",
    "rip" => "😇",
596
597
    "pudding" => "🍮",
    "star" => "⭐"
598
599
  }

lain's avatar
lain committed
600
  @doc "Rewrite misskey likes into EmojiReacts"
601
602
603
604
605
606
607
608
  def handle_incoming(
        %{
          "type" => "Like",
          "_misskey_reaction" => reaction
        } = data,
        options
      ) do
    data
lain's avatar
lain committed
609
    |> Map.put("type", "EmojiReact")
610
    |> Map.put("content", @misskey_reactions[reaction] || reaction)
611
612
613
    |> handle_incoming(options)
  end

lain's avatar
lain committed
614
615
  def handle_incoming(
        %{"type" => "Create", "object" => %{"type" => "ChatMessage"}} = data,
616
617
        _options
      ) do
618
619
620
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
         {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
      {:ok, activity}
621
622
    end
  end
lain's avatar
lain committed
623

624
  def handle_incoming(%{"type" => type} = data, _options)
625
      when type in ~w{Like EmojiReact Announce} do
lain's avatar
lain committed
626
627
628
    with :ok <- ObjectValidator.fetch_actor_and_object(data),
         {:ok, activity, _meta} <-
           Pipeline.common_pipeline(data, local: false) do
lain's avatar
lain committed
629
630
      {:ok, activity}
    else
631
      e -> {:error, e}
lain's avatar
lain committed
632
633
634
    end
  end

lain's avatar
lain committed
635
  def handle_incoming(
636
        %{"type" => type} = data,
637
        _options
638
      )
639
      when type in ~w{Update Block Follow} do
640
641
642
    with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
         {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
      {:ok, activity}
lain's avatar
lain committed
643
644
645
    end
  end

lain's avatar
lain committed
646
  def handle_incoming(
647
        %{"type" => "Delete"} = data,
648
        _options
lain's avatar
lain committed
649
      ) do
650
    with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
lain's avatar
lain committed
651
      {:ok, activity}
652
653
654
    else
      {:error, {:validate_object, _}} = e ->
        # Check if we have a create activity for this
655
        with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
656
657
658
659
660
661
662
663
664
             %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
665
666
667
    end
  end

normandy's avatar
normandy committed
668
669
670
671
672
673
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Follow", "object" => followed},
          "actor" => follower,
          "id" => id
674
675
        } = _data,
        _options
normandy's avatar
normandy committed
676
      ) do
normandy's avatar
normandy committed
677
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
678
         {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
normandy's avatar
normandy committed
679
         {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
normandy's avatar
normandy committed
680
681
682
      User.unfollow(follower, followed)
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
683
      _e -> :error
normandy's avatar
normandy committed
684
685
686
    end
  end

687
688
689
  def handle_incoming(
        %{
          "type" => "Undo",
690
          "object" => %{"type" => type}
691
692
        } = data,
        _options
693
      )
694
      when type in ["Like", "EmojiReact", "Announce", "Block"] do
695
    with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
696
697
698
699
      {:ok, activity}
    end
  end

700
  # For Undos that don't have the complete object attached, try to find it in our database.
normandy's avatar
normandy committed
701
702
703
  def handle_incoming(
        %{
          "type" => "Undo",
704
705
706
707
708
709
710
711
712
          "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
713
    else
Maksim's avatar
Maksim committed
714
      _e -> :error
normandy's avatar
normandy committed
715
716
717
    end
  end

minibikini's avatar
minibikini committed
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
  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

736
  def handle_incoming(_, _), do: :error
737

738
  @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
739
  def get_obj_helper(id, options \\ []) do
Maksim's avatar
Maksim committed
740
741
742
    case Object.normalize(id, true, options) do
      %Object{} = object -> {:ok, object}
      _ -> nil
743
    end
744
745
  end

746
  @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
Thibaut Girka's avatar
Thibaut Girka committed
747
  def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
748
749
        ap_id: ap_id
      })
Thibaut Girka's avatar
Thibaut Girka committed
750
      when attributed_to == ap_id do
751
752
753
754
755
    with {:ok, activity} <-
           handle_incoming(%{
             "type" => "Create",
             "to" => data["to"],
             "cc" => data["cc"],
Thibaut Girka's avatar
Thibaut Girka committed
756
             "actor" => attributed_to,
757
758
759
760
761
762
763
764
765
766
767
768
             "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

769
770
771
772
  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)
773
774
775
776
    else
      _e -> object
    end
  end
lain's avatar
lain committed
777

778
779
  def set_reply_to_uri(obj), do: obj

780
781
782
783
  @doc """
  Serialized Mastodon-compatible `replies` collection containing _self-replies_.
  Based on Mastodon's ActivityPub::NoteSerializer#replies.
  """
784
  def set_replies(obj_data) do
785
    replies_uris =
Ivan Tashkinov's avatar
Ivan Tashkinov committed
786
787
      with limit when limit > 0 <-
             Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
788
789
790
791
           %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
        object
        |> Object.self_replies()
        |> select([o], fragment("?->>'id'", o.data))
792
793
        |> limit(^limit)
        |> Repo.all()
Ivan Tashkinov's avatar
Ivan Tashkinov committed
794
795
      else
        _ -> []
796
797
      end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
798
    set_replies(obj_data, replies_uris)
799
800
  end

Ivan Tashkinov's avatar
Ivan Tashkinov committed
801
  defp set_replies(obj, []) do
802
803
804
805
806
807
    obj
  end

  defp set_replies(obj, replies_uris) do
    replies_collection = %{
      "type" => "Collection",
808
      "items" => replies_uris
809
810
811
812
813
    }

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

Ivan Tashkinov's avatar
Ivan Tashkinov committed
814
815
816
  def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
    items
  end
817

Ivan Tashkinov's avatar
Ivan Tashkinov committed
818
819
  def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
    items
820
821
822
823
  end

  def replies(_), do: []

824
  # Prepares the object of an outgoing create activity.
lain's avatar
lain committed
825
826
  def prepare_object(object) do
    object
lain's avatar
lain committed
827
    |> set_sensitive
lain's avatar
lain committed
828
    |> add_hashtags
lain's avatar
lain committed
829
    |> add_mention_tags
lain's avatar
lain committed
830
    |> add_emoji_tags
lain's avatar
lain committed
831
    |> add_attributed_to
lain's avatar
lain committed
832
    |> prepare_attachments
lain's avatar
lain committed
833
    |> set_conversation
834
    |> set_reply_to_uri
835
    |> set_replies
836
837
    |> strip_internal_fields
    |> strip_internal_tags
838
    |> set_type
lain's avatar
lain committed
839
840
  end

feld's avatar
feld committed
841
842
843
844
  #  @doc
  #  """
  #  internal -> Mastodon
  #  """
lain's avatar
lain committed
845

846
847
  def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
      when activity_type in ["Create", "Listen"] do
lain's avatar
lain committed
848
    object =
minibikini's avatar
minibikini committed
849
850
851
      object_id
      |> Object.normalize()
      |> Map.get(:data)
lain's avatar
lain committed
852
853
854
855
856
      |> prepare_object

    data =
      data
      |> Map.put("object", object)
lain's avatar
lain committed
857
      |> Map.merge(Utils.make_json_ld_header())
minibikini's avatar
minibikini committed
858
      |> Map.delete("bcc")
lain's avatar
lain committed
859
860
861
862

    {:ok, data}
  end

863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
  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
884
885
886
  # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
  # because of course it does.
  def prepare_outgoing(%{"type" => "Accept"} = data) do
887
    with follow_activity <- Activity.normalize(data["object"]) do
kaniini's avatar
kaniini committed
888
889
890
891
892
893
894
895
896
897
      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
898
        |> Map.merge(Utils.make_json_ld_header())
kaniini's avatar
kaniini committed
899
900
901
902
903

      {:ok, data}
    end
  end

904
  def prepare_outgoing(%{"type" => "Reject"} = data) do
905
    with follow_activity <- Activity.normalize(data["object"]) do
906
907
908
909
910
911
912
913
914
915
      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
916
        |> Map.merge(Utils.make_json_ld_header())
917
918
919
920
921

      {:ok, data}
    end
  end

feld's avatar
feld committed
922
  def prepare_outgoing(%{"type" => _type} = data) do
lain's avatar
lain committed
923
924
    data =
      data
925
      |> strip_internal_fields
lain's avatar
lain committed
926
      |> maybe_fix_object_url
lain's avatar
lain committed
927
      |> Map.merge(Utils.make_json_ld_header())
928
929
930
931

    {:ok, data}
  end

932
933
934
935
936
937
  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)
938
    else
939
940
941
942
943
944
      {:fetch, e} ->
        Logger.error("Couldn't fetch #{object} #{inspect(e)}")
        data

      _ ->
        data
945
946
947
    end
  end

948
949
  def maybe_fix_object_url(data), do: data

lain's avatar
lain committed
950
  def add_hashtags(object) do
lain's avatar
lain committed
951
952
    tags =
      (object["tag"] || [])
953
954
955
956
957
958
959
960
961
962
963
964
      |> 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
965
      end)
lain's avatar
lain committed
966

967
    Map.put(object, "tag", tags)
lain's avatar
lain committed
968
969
  end

lain's avatar