transmogrifier.ex 30.7 KB
Newer Older
1
# Pleroma: A lightweight social networking server
kaniini's avatar
kaniini committed
2
# Copyright © 2017-2019 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
10
  alias Pleroma.Activity
  alias Pleroma.Object
rinpatch's avatar
rinpatch committed
11
  alias Pleroma.Object.Containment
Haelwenn's avatar
Haelwenn committed
12
  alias Pleroma.Repo
13
  alias Pleroma.User
Haelwenn's avatar
Haelwenn committed
14
15
  alias Pleroma.Web.ActivityPub.ActivityPub
  alias Pleroma.Web.ActivityPub.Utils
lain's avatar
lain committed
16
  alias Pleroma.Web.ActivityPub.Visibility
17
  alias Pleroma.Web.Federator
18

lain's avatar
lain committed
19
20
  import Ecto.Query

21
  require Logger
22
  require Pleroma.Constants
23

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

  def fix_summary(%{"summary" => nil} = object) do
    object
    |> Map.put("summary", "")
  end

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

  def fix_summary(object) do
    object
    |> Map.put("summary", "")
56
57
58
  end

  def fix_addressing_list(map, field) do
59
60
61
62
63
64
65
66
67
    cond do
      is_binary(map[field]) ->
        Map.put(map, field, [map[field]])

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

      true ->
        map
68
69
70
    end
  end

71
72
73
74
75
  def fix_explicit_addressing(
        %{"to" => to, "cc" => cc} = object,
        explicit_mentions,
        follower_collection
      ) do
76
77
78
79
80
81
82
83
84
85
    explicit_to =
      to
      |> Enum.filter(fn x -> x in explicit_mentions end)

    explicit_cc =
      to
      |> Enum.filter(fn x -> x not in explicit_mentions end)

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

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

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

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

99
  def fix_explicit_addressing(object) do
100
101
102
103
    explicit_mentions =
      object
      |> Utils.determine_explicit_mentions()

104
105
    follower_collection = User.get_cached_by_ap_id(Containment.get_actor(object)).follower_address

106
    explicit_mentions = explicit_mentions ++ [Pleroma.Constants.as_public(), follower_collection]
107

108
    fix_explicit_addressing(object, explicit_mentions, follower_collection)
lain's avatar
lain committed
109
110
  end

111
112
113
114
115
116
117
  # 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
118
        Pleroma.Constants.as_public() in cc ->
119
120
121
          to = to ++ [followers_collection]
          Map.put(object, "to", to)

122
        Pleroma.Constants.as_public() in to ->
123
124
125
126
127
128
          cc = cc ++ [followers_collection]
          Map.put(object, "cc", cc)

        true ->
          object
      end
129
    else
130
      object
131
132
133
    end
  end

134
135
  def fix_implicit_addressing(object, _), do: object

136
  def fix_addressing(object) do
Alexander Strizhakov's avatar
Alexander Strizhakov committed
137
    {:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
138
139
    followers_collection = User.ap_followers(user)

140
    object
141
142
143
144
    |> fix_addressing_list("to")
    |> fix_addressing_list("cc")
    |> fix_addressing_list("bto")
    |> fix_addressing_list("bcc")
145
    |> fix_explicit_addressing()
146
    |> fix_implicit_addressing(followers_collection)
lain's avatar
lain committed
147
148
  end

149
150
  def fix_actor(%{"attributedTo" => actor} = object) do
    object
151
    |> Map.put("actor", Containment.get_actor(%{"actor" => actor}))
152
153
  end

154
155
156
  def fix_in_reply_to(object, options \\ [])

  def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
157
158
      when not is_nil(in_reply_to) do
    in_reply_to_id =
159
      cond do
160
161
162
163
164
165
166
167
168
        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)

169
        # Maybe I should output an error too?
170
171
        true ->
          ""
172
173
      end

174
    object = Map.put(object, "inReplyToAtomUri", in_reply_to_id)
lain's avatar
lain committed
175

176
    if Federator.allowed_incoming_reply_depth?(options[:depth]) do
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
      case get_obj_helper(in_reply_to_id, options) do
        {:ok, replied_object} ->
          with %Activity{} = _activity <-
                 Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
            object
            |> Map.put("inReplyTo", replied_object.data["id"])
            |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
            |> Map.put("conversation", replied_object.data["context"] || object["conversation"])
            |> Map.put("context", replied_object.data["context"] || object["conversation"])
          else
            e ->
              Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
              object
          end

        e ->
          Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
          object
      end
    else
      object
lain's avatar
lain committed
198
199
    end
  end
lain's avatar
lain committed
200

201
  def fix_in_reply_to(object, _options), do: object
lain's avatar
lain committed
202

lain's avatar
lain committed
203
  def fix_context(object) do
Haelwenn's avatar
Haelwenn committed
204
205
    context = object["context"] || object["conversation"] || Utils.generate_context_id()

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

211
  def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
lain's avatar
lain committed
212
    attachments =
213
      attachment
lain's avatar
lain committed
214
      |> Enum.map(fn data ->
215
216
217
218
219
220
221
222
        media_type = data["mediaType"] || data["mimeType"]
        href = data["url"] || data["href"]

        url = [%{"type" => "Link", "mediaType" => media_type, "href" => href}]

        data
        |> Map.put("mediaType", media_type)
        |> Map.put("url", url)
lain's avatar
lain committed
223
      end)
lain's avatar
lain committed
224
225
226

    object
    |> Map.put("attachment", attachments)
227
228
  end

229
  def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
230
231
    Map.put(object, "attachment", [attachment])
    |> fix_attachments()
232
233
  end

234
  def fix_attachments(object), do: object
235

236
237
238
239
240
  def fix_url(%{"url" => url} = object) when is_map(url) do
    object
    |> Map.put("url", url["href"])
  end

241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
  def fix_url(%{"type" => "Video", "url" => url} = object) when is_list(url) do
    first_element = Enum.at(url, 0)

    link_element =
      url
      |> Enum.filter(fn x -> is_map(x) end)
      |> Enum.filter(fn x -> x["mimeType"] == "text/html" end)
      |> Enum.at(0)

    object
    |> Map.put("attachment", [first_element])
    |> 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
257
258
259
260
261
262
263
264
265
    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

266
267
    object
    |> Map.put("url", url_string)
268
269
270
271
  end

  def fix_url(object), do: object

272
  def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
lain's avatar
lain committed
273
274
275
276
277
    emoji = tags |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)

    emoji =
      emoji
      |> Enum.reduce(%{}, fn data, mapping ->
278
        name = String.trim(data["name"], ":")
lain's avatar
lain committed
279

lain's avatar
lain committed
280
281
        mapping |> Map.put(name, data["icon"]["url"])
      end)
lain's avatar
lain committed
282
283
284
285
286
287
288
289

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

    object
    |> Map.put("emoji", emoji)
  end

290
291
292
293
294
295
296
297
  def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
    name = String.trim(tag["name"], ":")
    emoji = %{name => tag["icon"]["url"]}

    object
    |> Map.put("emoji", emoji)
  end

298
  def fix_emoji(object), do: object
299

300
  def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
lain's avatar
lain committed
301
    tags =
302
      tag
lain's avatar
lain committed
303
304
      |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
      |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
305

306
    combined = tag ++ tags
307
308
309
310
311

    object
    |> Map.put("tag", combined)
  end

312
313
  def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
    combined = [tag, String.slice(hashtag, 1..-1)]
314
315
316
317
318

    object
    |> Map.put("tag", combined)
  end

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

321
  def fix_tag(object), do: object
322

323
324
325
326
327
328
329
330
331
332
333
  # 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)

    object
    |> Map.put("content", content)
  end

  def fix_content_map(object), do: object

334
335
  def fix_type(object, options \\ [])

336
337
  def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
      when is_binary(reply_id) do
338
    reply =
339
340
341
      with true <- Federator.allowed_incoming_reply_depth?(options[:depth]),
           {:ok, object} <- get_obj_helper(reply_id, options) do
        object
342
      end
343

344
    if reply && reply.data["type"] == "Question" do
345
346
347
348
349
350
      Map.put(object, "type", "Answer")
    else
      object
    end
  end

351
  def fix_type(object, _), do: object
352

Maksim's avatar
Maksim committed
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
  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

379
380
  def handle_incoming(data, options \\ [])

381
382
  # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
  # with nil ID.
383
  def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
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
409
410
411
412
413
414
    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.
         %User{} = account <-
           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),

         # Remove the reported user from the object list.
         statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
      params = %{
        actor: actor,
        context: context,
        account: account,
        statuses: statuses,
        content: content,
        additional: %{
          "cc" => [account.ap_id]
        }
      }

      ActivityPub.flag(params)
    end
  end

415
  # disallow objects with bogus IDs
416
417
  def handle_incoming(%{"id" => nil}, _options), do: :error
  def handle_incoming(%{"id" => ""}, _options), do: :error
418
  # length of https:// = 8, should validate better, but good enough for now.
419
420
  def handle_incoming(%{"id" => id}, _options) when not (is_binary(id) and length(id) > 8),
    do: :error
421

422
423
424
  # TODO: validate those with a Ecto scheme
  # - tags
  # - emoji
425
426
427
428
  def handle_incoming(
        %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
        options
      )
429
      when objtype in ["Article", "Note", "Video", "Page", "Question", "Answer"] do
430
    actor = Containment.get_actor(data)
431
432
433
434

    data =
      Map.put(data, "actor", actor)
      |> fix_addressing
435

436
    with nil <- Activity.get_create_by_object_ap_id(object["id"]),
437
         {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
438
439
      options = Keyword.put(options, :depth, (options[:depth] || 0) + 1)
      object = fix_object(data["object"], options)
440

441
442
443
444
      params = %{
        to: data["to"],
        object: object,
        actor: user,
lain's avatar
lain committed
445
        context: object["conversation"],
446
447
        local: false,
        published: data["published"],
lain's avatar
lain committed
448
449
450
        additional:
          Map.take(data, [
            "cc",
451
            "directMessage",
lain's avatar
lain committed
452
453
            "id"
          ])
454
455
456
457
      }

      ActivityPub.create(params)
    else
lain's avatar
lain committed
458
      %Activity{} = activity -> {:ok, activity}
459
460
461
462
      _e -> :error
    end
  end

lain's avatar
lain committed
463
  def handle_incoming(
464
465
        %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data,
        _options
lain's avatar
lain committed
466
      ) do
467
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
468
         {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
469
         {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
470
      with deny_follow_blocked <- Pleroma.Config.get([:user, :deny_follow_blocked]),
471
           {_, false} <- {:user_blocked, User.blocks?(followed, follower) && deny_follow_blocked},
472
473
           {_, false} <- {:user_locked, User.locked?(followed)},
           {_, {:ok, follower}} <- {:follow, User.follow(follower, followed)},
474
475
           {_, {:ok, _}} <-
             {:follow_state_update, Utils.update_follow_state_for_all(activity, "accept")} do
kaniini's avatar
kaniini committed
476
477
        ActivityPub.accept(%{
          to: [follower.ap_id],
478
          actor: followed,
kaniini's avatar
kaniini committed
479
480
481
          object: data,
          local: true
        })
482
483
      else
        {:user_blocked, true} ->
484
          {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
485
486
487
488
489
490
491
492
493

          ActivityPub.reject(%{
            to: [follower.ap_id],
            actor: followed,
            object: data,
            local: true
          })

        {:follow, {:error, _}} ->
494
          {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
495
496
497
498
499
500
501
502
503
504

          ActivityPub.reject(%{
            to: [follower.ap_id],
            actor: followed,
            object: data,
            local: true
          })

        {:user_locked, true} ->
          :noop
505
      end
lain's avatar
lain committed
506

507
508
      {:ok, activity}
    else
509
510
      _e ->
        :error
511
512
513
    end
  end

514
  def handle_incoming(
515
516
        %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => _id} = data,
        _options
517
      ) do
518
    with actor <- Containment.get_actor(data),
519
         {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
520
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
521
         {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
522
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
523
524
525
526
527
528
529
530
         {:ok, _follower} = User.follow(follower, followed) do
      ActivityPub.accept(%{
        to: follow_activity.data["to"],
        type: "Accept",
        actor: followed,
        object: follow_activity.data["id"],
        local: false
      })
531
532
    else
      _e -> :error
533
534
535
536
    end
  end

  def handle_incoming(
537
538
        %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => _id} = data,
        _options
539
      ) do
540
    with actor <- Containment.get_actor(data),
541
         {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
542
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
543
         {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
544
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
lain's avatar
lain committed
545
         {:ok, activity} <-
546
           ActivityPub.reject(%{
lain's avatar
lain committed
547
             to: follow_activity.data["to"],
548
             type: "Reject",
549
             actor: followed,
lain's avatar
lain committed
550
551
552
             object: follow_activity.data["id"],
             local: false
           }) do
553
554
      User.unfollow(follower, followed)

555
      {:ok, activity}
556
557
    else
      _e -> :error
558
559
560
    end
  end

lain's avatar
lain committed
561
  def handle_incoming(
562
563
        %{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data,
        _options
lain's avatar
lain committed
564
      ) do
565
    with actor <- Containment.get_actor(data),
566
         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
567
         {:ok, object} <- get_obj_helper(object_id),
feld's avatar
feld committed
568
         {:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
lain's avatar
lain committed
569
570
571
572
573
574
      {:ok, activity}
    else
      _e -> :error
    end
  end

575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
  def handle_incoming(
        %{
          "type" => "EmojiReaction",
          "object" => object_id,
          "actor" => _actor,
          "id" => id,
          "content" => emoji
        } = data,
        _options
      ) do
    with actor <- Containment.get_actor(data),
         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
         {:ok, object} <- get_obj_helper(object_id),
         {:ok, activity, _object} <-
           ActivityPub.react_with_emoji(actor, object, emoji, activity_id: id, local: false) do
      {:ok, activity}
    else
      _e -> :error
    end
  end

lain's avatar
lain committed
596
  def handle_incoming(
597
598
        %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data,
        _options
lain's avatar
lain committed
599
      ) do
600
    with actor <- Containment.get_actor(data),
601
         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
602
         {:ok, object} <- get_obj_helper(object_id),
lain's avatar
lain committed
603
         public <- Visibility.is_public?(data),
604
         {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
lain's avatar
lain committed
605
606
607
608
609
610
      {:ok, activity}
    else
      _e -> :error
    end
  end

lain's avatar
lain committed
611
  def handle_incoming(
612
        %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
613
614
          data,
        _options
615
616
      )
      when object_type in ["Person", "Application", "Service", "Organization"] do
minibikini's avatar
minibikini committed
617
    with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
lain's avatar
lain committed
618
619
      {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)

rinpatch's avatar
rinpatch committed
620
621
      banner = new_user_data[:info][:banner]
      locked = new_user_data[:info][:locked] || false
622
623
624
625
626
627
      attachment = get_in(new_user_data, [:info, :source_data, "attachment"]) || []

      fields =
        attachment
        |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
        |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
lain's avatar
lain committed
628
629
630
631

      update_data =
        new_user_data
        |> Map.take([:name, :bio, :avatar])
632
        |> Map.put(:info, %{banner: banner, locked: locked, fields: fields})
lain's avatar
lain committed
633
634

      actor
635
      |> User.upgrade_changeset(update_data, true)
lain's avatar
lain committed
636
      |> User.update_and_set_cache()
lain's avatar
lain committed
637

lain's avatar
lain committed
638
639
640
641
642
643
644
      ActivityPub.update(%{
        local: false,
        to: data["to"] || [],
        cc: data["cc"] || [],
        object: object,
        actor: actor_id
      })
lain's avatar
lain committed
645
646
647
648
649
650
651
    else
      e ->
        Logger.error(e)
        :error
    end
  end

652
653
654
655
656
  # TODO: We presently assume that any actor on the same origin domain as the object being
  # deleted has the rights to delete that object.  A better way to validate whether or not
  # the object should be deleted is to refetch the object URI, which should return either
  # an error or a tombstone.  This would allow us to verify that a deletion actually took
  # place.
lain's avatar
lain committed
657
  def handle_incoming(
658
        %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => _id} = data,
659
        _options
lain's avatar
lain committed
660
      ) do
lain's avatar
lain committed
661
    object_id = Utils.get_ap_id(object_id)
lain's avatar
lain committed
662

663
    with actor <- Containment.get_actor(data),
664
         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
665
         {:ok, object} <- get_obj_helper(object_id),
666
         :ok <- Containment.contain_origin(actor.ap_id, object.data),
lain's avatar
lain committed
667
668
669
         {:ok, activity} <- ActivityPub.delete(object, false) do
      {:ok, activity}
    else
670
671
672
      nil ->
        case User.get_cached_by_ap_id(object_id) do
          %User{ap_id: ^actor} = user ->
673
            User.delete(user)
674
675
676
677
678
679
680

          nil ->
            :error
        end

      _e ->
        :error
lain's avatar
lain committed
681
682
683
    end
  end

684
  def handle_incoming(
685
686
        %{
          "type" => "Undo",
687
          "object" => %{"type" => "Announce", "object" => object_id},
Maksim's avatar
Maksim committed
688
          "actor" => _actor,
689
          "id" => id
690
691
        } = data,
        _options
692
      ) do
693
    with actor <- Containment.get_actor(data),
694
         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
695
         {:ok, object} <- get_obj_helper(object_id),
696
         {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
697
698
      {:ok, activity}
    else
Thog's avatar
Thog committed
699
      _e -> :error
700
701
702
    end
  end

normandy's avatar
normandy committed
703
704
705
706
707
708
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Follow", "object" => followed},
          "actor" => follower,
          "id" => id
709
710
        } = _data,
        _options
normandy's avatar
normandy committed
711
      ) do
normandy's avatar
normandy committed
712
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
713
         {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
normandy's avatar
normandy committed
714
         {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
normandy's avatar
normandy committed
715
716
717
      User.unfollow(follower, followed)
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
718
      _e -> :error
normandy's avatar
normandy committed
719
720
721
    end
  end

normandy's avatar
normandy committed
722
723
724
725
726
727
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Block", "object" => blocked},
          "actor" => blocker,
          "id" => id
728
729
        } = _data,
        _options
normandy's avatar
normandy committed
730
      ) do
731
    with %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
732
         {:ok, %User{} = blocker} <- User.get_or_fetch_by_ap_id(blocker),
normandy's avatar
normandy committed
733
         {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
normandy's avatar
normandy committed
734
      User.unblock(blocker, blocked)
normandy's avatar
normandy committed
735
736
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
737
      _e -> :error
normandy's avatar
normandy committed
738
739
740
    end
  end

741
  def handle_incoming(
742
743
        %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
        _options
744
      ) do
745
    with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
0x1C3B00DA's avatar
0x1C3B00DA committed
746
         {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
normandy's avatar
normandy committed
747
         {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
748
      User.unfollow(blocker, blocked)
749
      User.block(blocker, blocked)
normandy's avatar
normandy committed
750
751
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
752
      _e -> :error
normandy's avatar
normandy committed
753
754
    end
  end
755

Thog's avatar
Thog committed
756
757
758
759
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Like", "object" => object_id},
Maksim's avatar
Maksim committed
760
          "actor" => _actor,
Thog's avatar
Thog committed
761
          "id" => id
762
763
        } = data,
        _options
Thog's avatar
Thog committed
764
      ) do
765
    with actor <- Containment.get_actor(data),
766
         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
767
         {:ok, object} <- get_obj_helper(object_id),
Thog's avatar
Thog committed
768
769
770
         {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
      {:ok, activity}
    else
Thog's avatar
Thog committed
771
      _e -> :error
Thog's avatar
Thog committed
772
773
774
    end
  end

775
  def handle_incoming(_, _), do: :error
776

777
778
  def get_obj_helper(id, options \\ []) do
    if object = Object.normalize(id, true, options), do: {:ok, object}, else: nil
779
780
  end

781
782
783
784
  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)
785
786
787
788
    else
      _e -> object
    end
  end
lain's avatar
lain committed
789

790
791
792
  def set_reply_to_uri(obj), do: obj

  # Prepares the object of an outgoing create activity.
lain's avatar
lain committed
793
794
  def prepare_object(object) do
    object
lain's avatar
lain committed
795
    |> set_sensitive
lain's avatar
lain committed
796
    |> add_hashtags
lain's avatar
lain committed
797
    |> add_mention_tags
lain's avatar
lain committed
798
    |> add_emoji_tags
lain's avatar
lain committed
799
    |> add_attributed_to
lain's avatar
lain committed
800
    |> prepare_attachments
lain's avatar
lain committed
801
    |> set_conversation
802
    |> set_reply_to_uri
803
804
    |> strip_internal_fields
    |> strip_internal_tags
805
    |> set_type
lain's avatar
lain committed
806
807
  end

feld's avatar
feld committed
808
809
810
811
  #  @doc
  #  """
  #  internal -> Mastodon
  #  """
lain's avatar
lain committed
812

813
  def prepare_outgoing(%{"type" => "Create", "object" => object_id} = data) do
lain's avatar
lain committed
814
    object =
minibikini's avatar
minibikini committed
815
816
817
      object_id
      |> Object.normalize()
      |> Map.get(:data)
lain's avatar
lain committed
818
819
820
821
822
      |> prepare_object

    data =
      data
      |> Map.put("object", object)
lain's avatar
lain committed
823
      |> Map.merge(Utils.make_json_ld_header())
minibikini's avatar
minibikini committed
824
      |> Map.delete("bcc")
lain's avatar
lain committed
825
826
827
828

    {:ok, data}
  end

kaniini's avatar
kaniini committed
829
830
831
  # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
  # because of course it does.
  def prepare_outgoing(%{"type" => "Accept"} = data) do
832
    with follow_activity <- Activity.normalize(data["object"]) do
kaniini's avatar
kaniini committed
833
834
835
836
837
838
839
840
841
842
      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
843
        |> Map.merge(Utils.make_json_ld_header())
kaniini's avatar
kaniini committed
844
845
846
847
848

      {:ok, data}
    end
  end

849
  def prepare_outgoing(%{"type" => "Reject"} = data) do
850
    with follow_activity <- Activity.normalize(data["object"]) do
851
852
853
854
855
856
857
858
859
860
      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
861
        |> Map.merge(Utils.make_json_ld_header())
862
863
864
865
866

      {:ok, data}
    end
  end

feld's avatar
feld committed
867
  def prepare_outgoing(%{"type" => _type} = data) do
lain's avatar
lain committed
868
869
    data =
      data
870
      |> strip_internal_fields
lain's avatar
lain committed
871
      |> maybe_fix_object_url
lain's avatar
lain committed
872
      |> Map.merge(Utils.make_json_ld_header())
873
874
875
876

    {:ok, data}
  end

877
878
  def maybe_fix_object_url(data) do
    if is_binary(data["object"]) and not String.starts_with?(data["object"], "http") do
879
      case get_obj_helper(data["object"]) do
880
881
        {:ok, relative_object} ->
          if relative_object.data["external_url"] do
feld's avatar
feld committed
882
            _data =
lain's avatar
lain committed
883
884
              data
              |> Map.put("object", relative_object.data["external_url"])
885
886
887
          else
            data
          end
lain's avatar
lain committed
888

889
890
891
892
893
894
895
896
897
        e ->
          Logger.error("Couldn't fetch #{data["object"]} #{inspect(e)}")
          data
      end
    else
      data
    end
  end

lain's avatar
lain committed
898
  def add_hashtags(object) do
lain's avatar
lain committed
899
900
    tags =
      (object["tag"] || [])
901
902
903
904
905
906
907
908
909
910
911
912
      |> 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
913
      end)
lain's avatar
lain committed
914
915
916
917
918

    object
    |> Map.put("tag", tags)
  end

lain's avatar
lain committed
919
  def add_mention_tags(object) do
lain's avatar
lain committed
920
    mentions =
921
922
      object
      |> Utils.get_notified_from_object()
lain's avatar
lain committed
923
924
925
      |> Enum.map(fn user ->
        %{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"}
      end)
lain's avatar
lain committed
926

lain's avatar
lain committed
927
    tags = object["tag"] || []
lain's avatar
lain committed
928
929

    object
lain's avatar
lain committed
930
    |> Map.put("tag", tags ++ mentions)
lain's avatar
lain committed
931
932
  end

Haelwenn's avatar
Haelwenn committed
933
934
935
936
937
938
939
  def add_emoji_tags(%User{info: %{"emoji" => _emoji} = user_info} = object) do
    user_info = add_emoji_tags(user_info)

    object
    |> Map.put(:info, user_info)
  end

lain's avatar
lain committed
940
  # TODO: we should probably send mtime instead of unix epoch time for updated
Haelwenn's avatar
Haelwenn committed
941
  def add_emoji_tags(%{"emoji" => emoji} = object) do
lain's avatar
lain committed
942
    tags = object["tag"] || []
lain's avatar
lain committed
943
944
945
946
947
948
949
950
951
952
953
954

    out =
      emoji
      |> Enum.map(fn {name, url} ->
        %{
          "icon" => %{"url" => url, "type" => "Image"},
          "name" => ":" <> name <> ":",
          "type" => "Emoji",
          "updated" => "1970-01-01T00:00:00Z",
          "id" => url
        }
      end)
lain's avatar
lain committed
955
956
957
958
959

    object
    |> Map.put("tag", tags ++ out)
  end

Haelwenn's avatar
Haelwenn committed
960
961
962
963
  def add_emoji_tags(object) do
    object
  end

lain's avatar
lain committed
964
965
966
967
  def set_conversation(object) do
    Map.put(object, "conversation", object["context"])
  end

lain's avatar
lain committed
968
969
970
971
972
  def set_sensitive(object) do
    tags = object["tag"] || []
    Map.put(object, "sensitive", "nsfw" in tags)
  end

973
974
975
976
977
978
  def set_type(%{"type" => "Answer"} = object) do
    Map.put(object, "type", "Note")
  end

  def set_type(object), do: object

lain's avatar
lain committed
979
  def add_attributed_to(object) do
980
    attributed_to = object["attributedTo"] || object["actor"]
lain's avatar
lain committed
981
982

    object
983
    |> Map.put("attributedTo", attributed_to)
984
  end
lain's avatar
lain committed
985
986

  def prepare_attachments(object) do
lain's avatar
lain committed
987
988
989
990
991
992
    attachments =
      (object["attachment"] || [])
      |> Enum.map(fn data ->
        [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
        %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
      end)
lain's avatar
lain committed
993
994
995
996

    object
    |> Map.put("attachment", attachments)
  end
lain's avatar
lain committed
997

998
999
1000
  defp strip_internal_fields(object) do
    object
    |> Map.drop([
For faster browsing, not all history is shown. View entire blame