transmogrifier.ex 28.8 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

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

20
21
  require Logger

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

  def fix_addressing_list(map, field) do
56
57
58
59
60
61
62
63
64
    cond do
      is_binary(map[field]) ->
        Map.put(map, field, [map[field]])

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

      true ->
        map
65
66
67
    end
  end

68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
  def fix_explicit_addressing(%{"to" => to, "cc" => cc} = object, explicit_mentions) do
    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)
      |> Enum.uniq()

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

  def fix_explicit_addressing(object, _explicit_mentions), do: object

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

91
  def fix_explicit_addressing(object) do
92
93
94
95
96
97
98
99
    explicit_mentions =
      object
      |> Utils.determine_explicit_mentions()

    explicit_mentions = explicit_mentions ++ ["https://www.w3.org/ns/activitystreams#Public"]

    object
    |> fix_explicit_addressing(explicit_mentions)
lain's avatar
lain committed
100
101
  end

102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
  # 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
        "https://www.w3.org/ns/activitystreams#Public" in cc ->
          to = to ++ [followers_collection]
          Map.put(object, "to", to)

        "https://www.w3.org/ns/activitystreams#Public" in to ->
          cc = cc ++ [followers_collection]
          Map.put(object, "cc", cc)

        true ->
          object
      end
120
    else
121
      object
122
123
124
    end
  end

125
126
  def fix_implicit_addressing(object, _), do: object

127
  def fix_addressing(object) do
Alexander Strizhakov's avatar
Alexander Strizhakov committed
128
    {:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
129
130
    followers_collection = User.ap_followers(user)

131
    object
132
133
134
135
    |> fix_addressing_list("to")
    |> fix_addressing_list("cc")
    |> fix_addressing_list("bto")
    |> fix_addressing_list("bcc")
136
    |> fix_explicit_addressing
137
    |> fix_implicit_addressing(followers_collection)
lain's avatar
lain committed
138
139
  end

140
141
  def fix_actor(%{"attributedTo" => actor} = object) do
    object
142
    |> Map.put("actor", Containment.get_actor(%{"actor" => actor}))
143
144
  end

145
146
147
148
149
  # Check for standardisation
  # This is what Peertube does
  # curl -H 'Accept: application/activity+json' $likes | jq .totalItems
  # Prismo returns only an integer (count) as "likes"
  def fix_likes(%{"likes" => likes} = object) when not is_map(likes) do
150
151
152
153
154
155
156
157
158
    object
    |> Map.put("likes", [])
    |> Map.put("like_count", 0)
  end

  def fix_likes(object) do
    object
  end

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

172
        # Maybe I should output an error too?
173
174
        true ->
          ""
175
176
      end

177
    case get_obj_helper(in_reply_to_id) do
lain's avatar
lain committed
178
      {:ok, replied_object} ->
rinpatch's avatar
rinpatch committed
179
        with %Activity{} = _activity <-
180
               Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
181
182
183
184
185
186
187
          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 ->
188
            Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
189
190
            object
        end
lain's avatar
lain committed
191

lain's avatar
lain committed
192
      e ->
193
        Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
lain's avatar
lain committed
194
195
196
        object
    end
  end
lain's avatar
lain committed
197

lain's avatar
lain committed
198
199
  def fix_in_reply_to(object), do: object

lain's avatar
lain committed
200
  def fix_context(object) do
Haelwenn's avatar
Haelwenn committed
201
202
    context = object["context"] || object["conversation"] || Utils.generate_context_id()

lain's avatar
lain committed
203
    object
Haelwenn's avatar
Haelwenn committed
204
205
    |> Map.put("context", context)
    |> Map.put("conversation", context)
lain's avatar
lain committed
206
207
  end

208
  def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
lain's avatar
lain committed
209
    attachments =
210
      attachment
lain's avatar
lain committed
211
      |> Enum.map(fn data ->
212
213
214
215
216
217
218
219
        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
220
      end)
lain's avatar
lain committed
221
222
223

    object
    |> Map.put("attachment", attachments)
224
225
  end

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

231
  def fix_attachments(object), do: object
232

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

238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
  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
254
255
256
257
258
259
260
261
262
    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

263
264
    object
    |> Map.put("url", url_string)
265
266
267
268
  end

  def fix_url(object), do: object

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

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

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

    # 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

287
288
289
290
291
292
293
294
  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

295
  def fix_emoji(object), do: object
296

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

303
    combined = tag ++ tags
304
305
306
307
308

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

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

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

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

318
  def fix_tag(object), do: object
319

320
321
322
323
324
325
326
327
328
329
330
  # 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

Maksim's avatar
Maksim committed
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
  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

357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
  # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
  # with nil ID.
  def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data) do
    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

391
392
393
394
395
396
  # disallow objects with bogus IDs
  def handle_incoming(%{"id" => nil}), do: :error
  def handle_incoming(%{"id" => ""}), do: :error
  # length of https:// = 8, should validate better, but good enough for now.
  def handle_incoming(%{"id" => id}) when not (is_binary(id) and length(id) > 8), do: :error

397
398
399
  # TODO: validate those with a Ecto scheme
  # - tags
  # - emoji
kaniini's avatar
kaniini committed
400
  def handle_incoming(%{"type" => "Create", "object" => %{"type" => objtype} = object} = data)
rinpatch's avatar
rinpatch committed
401
      when objtype in ["Article", "Note", "Video", "Page", "Question"] do
402
    actor = Containment.get_actor(data)
403
404
405
406

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

408
    with nil <- Activity.get_create_by_object_ap_id(object["id"]),
409
         {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
410
      object = fix_object(data["object"])
411

412
413
414
415
      params = %{
        to: data["to"],
        object: object,
        actor: user,
lain's avatar
lain committed
416
        context: object["conversation"],
417
418
        local: false,
        published: data["published"],
lain's avatar
lain committed
419
420
421
        additional:
          Map.take(data, [
            "cc",
422
            "directMessage",
lain's avatar
lain committed
423
424
            "id"
          ])
425
426
427
428
      }

      ActivityPub.create(params)
    else
lain's avatar
lain committed
429
      %Activity{} = activity -> {:ok, activity}
430
431
432
433
      _e -> :error
    end
  end

lain's avatar
lain committed
434
435
436
  def handle_incoming(
        %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data
      ) do
437
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
438
         {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
439
         {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
440
441
442
443
444
      with deny_follow_blocked <- Pleroma.Config.get([:user, :deny_follow_blocked]),
           {:user_blocked, false} <-
             {:user_blocked, User.blocks?(followed, follower) && deny_follow_blocked},
           {:user_locked, false} <- {:user_locked, User.locked?(followed)},
           {:follow, {:ok, follower}} <- {:follow, User.follow(follower, followed)} do
kaniini's avatar
kaniini committed
445
446
        ActivityPub.accept(%{
          to: [follower.ap_id],
447
          actor: followed,
kaniini's avatar
kaniini committed
448
449
450
          object: data,
          local: true
        })
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
      else
        {:user_blocked, true} ->
          {:ok, _} = Utils.update_follow_state(activity, "reject")

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

        {:follow, {:error, _}} ->
          {:ok, _} = Utils.update_follow_state(activity, "reject")

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

        {:user_locked, true} ->
          :noop
474
      end
lain's avatar
lain committed
475

476
477
      {:ok, activity}
    else
478
479
      _e ->
        :error
480
481
482
    end
  end

483
  def handle_incoming(
Maksim's avatar
Maksim committed
484
        %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => _id} = data
485
      ) do
486
    with actor <- Containment.get_actor(data),
487
         {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
488
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
489
         {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "accept"),
490
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
lain's avatar
lain committed
491
492
493
494
         {:ok, activity} <-
           ActivityPub.accept(%{
             to: follow_activity.data["to"],
             type: "Accept",
495
             actor: followed,
lain's avatar
lain committed
496
497
498
             object: follow_activity.data["id"],
             local: false
           }) do
499
      if not User.following?(follower, followed) do
Maksim's avatar
Maksim committed
500
        {:ok, _follower} = User.follow(follower, followed)
501
      end
502

503
      {:ok, activity}
504
505
    else
      _e -> :error
506
507
508
509
    end
  end

  def handle_incoming(
Maksim's avatar
Maksim committed
510
        %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => _id} = data
511
      ) do
512
    with actor <- Containment.get_actor(data),
513
         {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
514
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
515
         {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "reject"),
516
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
lain's avatar
lain committed
517
         {:ok, activity} <-
518
           ActivityPub.reject(%{
lain's avatar
lain committed
519
             to: follow_activity.data["to"],
520
             type: "Reject",
521
             actor: followed,
lain's avatar
lain committed
522
523
524
             object: follow_activity.data["id"],
             local: false
           }) do
525
526
      User.unfollow(follower, followed)

527
      {:ok, activity}
528
529
    else
      _e -> :error
530
531
532
    end
  end

lain's avatar
lain committed
533
  def handle_incoming(
Maksim's avatar
Maksim committed
534
        %{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data
lain's avatar
lain committed
535
      ) do
536
    with actor <- Containment.get_actor(data),
537
         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
538
         {:ok, object} <- get_obj_helper(object_id),
feld's avatar
feld committed
539
         {:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
lain's avatar
lain committed
540
541
542
543
544
545
      {:ok, activity}
    else
      _e -> :error
    end
  end

lain's avatar
lain committed
546
  def handle_incoming(
Maksim's avatar
Maksim committed
547
        %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data
lain's avatar
lain committed
548
      ) do
549
    with actor <- Containment.get_actor(data),
550
         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
551
         {:ok, object} <- get_obj_helper(object_id),
lain's avatar
lain committed
552
         public <- Visibility.is_public?(data),
553
         {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
lain's avatar
lain committed
554
555
556
557
558
559
      {:ok, activity}
    else
      _e -> :error
    end
  end

lain's avatar
lain committed
560
  def handle_incoming(
561
        %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
lain's avatar
lain committed
562
          data
563
564
      )
      when object_type in ["Person", "Application", "Service", "Organization"] do
minibikini's avatar
minibikini committed
565
    with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
lain's avatar
lain committed
566
567
568
      {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)

      banner = new_user_data[:info]["banner"]
569
      locked = new_user_data[:info]["locked"] || false
lain's avatar
lain committed
570
571
572
573

      update_data =
        new_user_data
        |> Map.take([:name, :bio, :avatar])
lain's avatar
lain committed
574
        |> Map.put(:info, %{"banner" => banner, "locked" => locked})
lain's avatar
lain committed
575
576
577

      actor
      |> User.upgrade_changeset(update_data)
lain's avatar
lain committed
578
      |> User.update_and_set_cache()
lain's avatar
lain committed
579

lain's avatar
lain committed
580
581
582
583
584
585
586
      ActivityPub.update(%{
        local: false,
        to: data["to"] || [],
        cc: data["cc"] || [],
        object: object,
        actor: actor_id
      })
lain's avatar
lain committed
587
588
589
590
591
592
593
    else
      e ->
        Logger.error(e)
        :error
    end
  end

594
595
596
597
598
  # 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
599
  def handle_incoming(
600
        %{"type" => "Delete", "object" => object_id, "actor" => _actor, "id" => _id} = data
lain's avatar
lain committed
601
      ) do
lain's avatar
lain committed
602
    object_id = Utils.get_ap_id(object_id)
lain's avatar
lain committed
603

604
    with actor <- Containment.get_actor(data),
605
         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
606
         {:ok, object} <- get_obj_helper(object_id),
607
         :ok <- Containment.contain_origin(actor.ap_id, object.data),
lain's avatar
lain committed
608
609
610
         {:ok, activity} <- ActivityPub.delete(object, false) do
      {:ok, activity}
    else
feld's avatar
feld committed
611
      _e -> :error
lain's avatar
lain committed
612
613
614
    end
  end

615
  def handle_incoming(
616
617
        %{
          "type" => "Undo",
618
          "object" => %{"type" => "Announce", "object" => object_id},
Maksim's avatar
Maksim committed
619
          "actor" => _actor,
620
          "id" => id
621
        } = data
622
      ) do
623
    with actor <- Containment.get_actor(data),
624
         {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
625
         {:ok, object} <- get_obj_helper(object_id),
626
         {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
627
628
      {:ok, activity}
    else
Thog's avatar
Thog committed
629
      _e -> :error
630
631
632
    end
  end

normandy's avatar
normandy committed
633
634
635
636
637
638
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Follow", "object" => followed},
          "actor" => follower,
          "id" => id
normandy's avatar
normandy committed
639
        } = _data
normandy's avatar
normandy committed
640
      ) do
normandy's avatar
normandy committed
641
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
642
         {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
normandy's avatar
normandy committed
643
         {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
normandy's avatar
normandy committed
644
645
646
      User.unfollow(follower, followed)
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
647
      _e -> :error
normandy's avatar
normandy committed
648
649
650
    end
  end

normandy's avatar
normandy committed
651
652
653
654
655
656
657
658
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Block", "object" => blocked},
          "actor" => blocker,
          "id" => id
        } = _data
      ) do
href's avatar
href committed
659
    with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
660
         %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
661
         {:ok, %User{} = blocker} <- User.get_or_fetch_by_ap_id(blocker),
normandy's avatar
normandy committed
662
         {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
normandy's avatar
normandy committed
663
      User.unblock(blocker, blocked)
normandy's avatar
normandy committed
664
665
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
666
      _e -> :error
normandy's avatar
normandy committed
667
668
669
    end
  end

670
  def handle_incoming(
Maksim's avatar
Maksim committed
671
        %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data
672
      ) do
href's avatar
href committed
673
    with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
674
         %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
0x1C3B00DA's avatar
0x1C3B00DA committed
675
         {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
normandy's avatar
normandy committed
676
         {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
677
      User.unfollow(blocker, blocked)
678
      User.block(blocker, blocked)
normandy's avatar
normandy committed
679
680
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
681
      _e -> :error
normandy's avatar
normandy committed
682
683
    end
  end
684

Thog's avatar
Thog committed
685
686
687
688
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Like", "object" => object_id},
Maksim's avatar
Maksim committed
689
          "actor" => _actor,
Thog's avatar
Thog committed
690
          "id" => id
691
        } = data
Thog's avatar
Thog committed
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),
Thog's avatar
Thog committed
696
697
698
         {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
      {:ok, activity}
    else
Thog's avatar
Thog committed
699
      _e -> :error
Thog's avatar
Thog committed
700
701
702
    end
  end

703
704
  def handle_incoming(_), do: :error

705
  def get_obj_helper(id) do
706
    if object = Object.normalize(id), do: {:ok, object}, else: nil
707
708
  end

709
710
711
712
  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)
713
714
715
716
    else
      _e -> object
    end
  end
lain's avatar
lain committed
717

718
719
720
  def set_reply_to_uri(obj), do: obj

  # Prepares the object of an outgoing create activity.
lain's avatar
lain committed
721
722
  def prepare_object(object) do
    object
lain's avatar
lain committed
723
    |> set_sensitive
lain's avatar
lain committed
724
    |> add_hashtags
lain's avatar
lain committed
725
    |> add_mention_tags
lain's avatar
lain committed
726
    |> add_emoji_tags
lain's avatar
lain committed
727
    |> add_attributed_to
728
    |> add_likes
lain's avatar
lain committed
729
    |> prepare_attachments
lain's avatar
lain committed
730
    |> set_conversation
731
    |> set_reply_to_uri
732
733
    |> strip_internal_fields
    |> strip_internal_tags
lain's avatar
lain committed
734
735
  end

feld's avatar
feld committed
736
737
738
739
  #  @doc
  #  """
  #  internal -> Mastodon
  #  """
lain's avatar
lain committed
740

741
  def prepare_outgoing(%{"type" => "Create", "object" => object_id} = data) do
lain's avatar
lain committed
742
    object =
743
      Object.normalize(object_id).data
lain's avatar
lain committed
744
745
746
747
748
      |> prepare_object

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

    {:ok, data}
  end

kaniini's avatar
kaniini committed
754
755
756
  # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
  # because of course it does.
  def prepare_outgoing(%{"type" => "Accept"} = data) do
757
    with follow_activity <- Activity.normalize(data["object"]) do
kaniini's avatar
kaniini committed
758
759
760
761
762
763
764
765
766
767
      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
768
        |> Map.merge(Utils.make_json_ld_header())
kaniini's avatar
kaniini committed
769
770
771
772
773

      {:ok, data}
    end
  end

774
  def prepare_outgoing(%{"type" => "Reject"} = data) do
775
    with follow_activity <- Activity.normalize(data["object"]) do
776
777
778
779
780
781
782
783
784
785
      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
786
        |> Map.merge(Utils.make_json_ld_header())
787
788
789
790
791

      {:ok, data}
    end
  end

feld's avatar
feld committed
792
  def prepare_outgoing(%{"type" => _type} = data) do
lain's avatar
lain committed
793
794
    data =
      data
795
      |> strip_internal_fields
lain's avatar
lain committed
796
      |> maybe_fix_object_url
lain's avatar
lain committed
797
      |> Map.merge(Utils.make_json_ld_header())
798
799
800
801

    {:ok, data}
  end

802
803
  def maybe_fix_object_url(data) do
    if is_binary(data["object"]) and not String.starts_with?(data["object"], "http") do
804
      case get_obj_helper(data["object"]) do
805
806
        {:ok, relative_object} ->
          if relative_object.data["external_url"] do
feld's avatar
feld committed
807
            _data =
lain's avatar
lain committed
808
809
              data
              |> Map.put("object", relative_object.data["external_url"])
810
811
812
          else
            data
          end
lain's avatar
lain committed
813

814
815
816
817
818
819
820
821
822
        e ->
          Logger.error("Couldn't fetch #{data["object"]} #{inspect(e)}")
          data
      end
    else
      data
    end
  end

lain's avatar
lain committed
823
  def add_hashtags(object) do
lain's avatar
lain committed
824
825
    tags =
      (object["tag"] || [])
826
827
828
829
830
831
832
833
834
835
836
837
      |> 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
838
      end)
lain's avatar
lain committed
839
840
841
842
843

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

lain's avatar
lain committed
844
  def add_mention_tags(object) do
lain's avatar
lain committed
845
    mentions =
846
847
      object
      |> Utils.get_notified_from_object()
lain's avatar
lain committed
848
849
850
      |> Enum.map(fn user ->
        %{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"}
      end)
lain's avatar
lain committed
851

lain's avatar
lain committed
852
    tags = object["tag"] || []
lain's avatar
lain committed
853
854

    object
lain's avatar
lain committed
855
    |> Map.put("tag", tags ++ mentions)
lain's avatar
lain committed
856
857
  end

Haelwenn's avatar
Haelwenn committed
858
859
860
861
862
863
864
  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
865
  # TODO: we should probably send mtime instead of unix epoch time for updated
Haelwenn's avatar
Haelwenn committed
866
  def add_emoji_tags(%{"emoji" => emoji} = object) do
lain's avatar
lain committed
867
    tags = object["tag"] || []
lain's avatar
lain committed
868
869
870
871
872
873
874
875
876
877
878
879

    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
880
881
882
883
884

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

Haelwenn's avatar
Haelwenn committed
885
886
887
888
  def add_emoji_tags(object) do
    object
  end

lain's avatar
lain committed
889
890
891
892
  def set_conversation(object) do
    Map.put(object, "conversation", object["context"])
  end

lain's avatar
lain committed
893
894
895
896
897
  def set_sensitive(object) do
    tags = object["tag"] || []
    Map.put(object, "sensitive", "nsfw" in tags)
  end

lain's avatar
lain committed
898
  def add_attributed_to(object) do
899
    attributed_to = object["attributedTo"] || object["actor"]
lain's avatar
lain committed
900
901

    object
902
    |> Map.put("attributedTo", attributed_to)
903
  end
lain's avatar
lain committed
904

905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
  def add_likes(%{"id" => id, "like_count" => likes} = object) do
    likes = %{
      "id" => "#{id}/likes",
      "first" => "#{id}/likes?page=1",
      "type" => "OrderedCollection",
      "totalItems" => likes
    }

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

  def add_likes(object) do
    object
  end

lain's avatar
lain committed
921
  def prepare_attachments(object) do
lain's avatar
lain committed
922
923
924
925
926
927
    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
928
929
930
931

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

933
934
935
936
937
938
939
  defp strip_internal_fields(object) do
    object
    |> Map.drop([
      "like_count",
      "announcements",
      "announcement_count",
      "emoji",
940
941
      "context_id",
      "deleted_activity_id"
942
943
944
945
946
947
948
949
950
951
952
953
954
955
    ])
  end

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

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

  defp strip_internal_tags(object), do: object

956
  def perform(:user_upgrade, user) do
957
958
    # we pass a fake user so that the followers collection is stripped away
    old_follower_address = User.ap_followers(%User{nickname: user.nickname})
lain's avatar
lain committed
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976

    q =
      from(
        u in User,
        where: ^old_follower_address in u.following,
        update: [
          set: [
            following:
              fragment(
                "array_replace(?,?,?)",
                u.following,
                ^old_follower_address,
                ^user.follower_address
              )
          ]
        ]
      )

lain's avatar
lain committed
977
978
    Repo.update_all(q, [])

979
980
    maybe_retire_websub(user.ap_id)

lain's avatar
lain committed
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
    q =
      from(
        a in Activity,
        where: ^old_follower_address in a.recipients,
        update: [
          set: [
            recipients:
              fragment(
                "array_replace(?,?,?)",
                a.recipients,
                ^old_follower_address,
                ^user.follower_address
              )
          ]
        ]
      )

lain's avatar
lain committed
998
999
1000
    Repo.update_all(q, [])
  end

For faster browsing, not all history is shown. View entire blame