transmogrifier.ex 28.6 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
11
  alias Pleroma.Activity
  alias Pleroma.Object
  alias Pleroma.Repo
12
  alias Pleroma.User
Haelwenn's avatar
Haelwenn committed
13
14
  alias Pleroma.Web.ActivityPub.ActivityPub
  alias Pleroma.Web.ActivityPub.Utils
lain's avatar
lain committed
15
  alias Pleroma.Web.ActivityPub.Visibility
16

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

19
20
  require Logger

21
22
23
24
25
  def get_actor(%{"actor" => actor}) when is_binary(actor) do
    actor
  end

  def get_actor(%{"actor" => actor}) when is_list(actor) do
26
27
28
    if is_binary(Enum.at(actor, 0)) do
      Enum.at(actor, 0)
    else
29
      Enum.find(actor, fn %{"type" => type} -> type in ["Person", "Service", "Application"] end)
30
31
      |> Map.get("id")
    end
32
33
  end

34
35
  def get_actor(%{"actor" => %{"id" => id}}) when is_bitstring(id) do
    id
36
37
  end

38
39
40
41
  def get_actor(%{"actor" => nil, "attributedTo" => actor}) when not is_nil(actor) do
    get_actor(%{"actor" => actor})
  end

42
43
44
  @doc """
  Checks that an imported AP object's actor matches the domain it came from.
  """
Maksim's avatar
Maksim committed
45
  def contain_origin(_id, %{"actor" => nil}), do: :error
46

Maksim's avatar
Maksim committed
47
  def contain_origin(id, %{"actor" => _actor} = params) do
48
    id_uri = URI.parse(id)
49
    actor_uri = URI.parse(get_actor(params))
50
51
52
53
54
55
56
57

    if id_uri.host == actor_uri.host do
      :ok
    else
      :error
    end
  end

Maksim's avatar
Maksim committed
58
  def contain_origin_from_id(_id, %{"id" => nil}), do: :error
59

Maksim's avatar
Maksim committed
60
  def contain_origin_from_id(id, %{"id" => other_id} = _params) do
61
62
63
64
65
66
67
68
69
70
    id_uri = URI.parse(id)
    other_uri = URI.parse(other_id)

    if id_uri.host == other_uri.host do
      :ok
    else
      :error
    end
  end

71
72
73
74
75
  @doc """
  Modifies an incoming AP object (mastodon format) to our internal format.
  """
  def fix_object(object) do
    object
76
    |> fix_actor
77
    |> fix_url
78
    |> fix_attachments
lain's avatar
lain committed
79
    |> fix_context
lain's avatar
lain committed
80
    |> fix_in_reply_to
lain's avatar
lain committed
81
    |> fix_emoji
82
    |> fix_tag
83
    |> fix_content_map
84
    |> fix_likes
85
86
87
88
89
90
91
92
93
94
95
96
    |> fix_addressing
  end

  def fix_addressing_list(map, field) do
    if is_binary(map[field]) do
      map
      |> Map.put(field, [map[field]])
    else
      map
    end
  end

97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
  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

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

120
  def fix_explicit_addressing(object) do
121
122
123
124
125
126
127
128
    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
129
130
  end

131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
  # 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
    else
      object
    end
  end

  def fix_implicit_addressing(object, _), do: object

156
  def fix_addressing(object) do
157
158
159
    %User{} = user = User.get_cached_by_ap_id(object["actor"])
    followers_collection = User.ap_followers(user)

160
    object
161
162
163
164
    |> fix_addressing_list("to")
    |> fix_addressing_list("cc")
    |> fix_addressing_list("bto")
    |> fix_addressing_list("bcc")
165
    |> fix_explicit_addressing
166
    |> fix_implicit_addressing(followers_collection)
lain's avatar
lain committed
167
168
  end

169
170
  def fix_actor(%{"attributedTo" => actor} = object) do
    object
171
    |> Map.put("actor", get_actor(%{"actor" => actor}))
172
173
  end

174
175
176
177
178
  # 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
179
180
181
182
183
184
185
186
187
    object
    |> Map.put("likes", [])
    |> Map.put("like_count", 0)
  end

  def fix_likes(object) do
    object
  end

188
189
190
  def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object)
      when not is_nil(in_reply_to) do
    in_reply_to_id =
191
      cond do
192
193
194
195
196
197
198
199
200
        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)

201
        # Maybe I should output an error too?
202
203
        true ->
          ""
204
205
      end

206
    case fetch_obj_helper(in_reply_to_id) do
lain's avatar
lain committed
207
      {:ok, replied_object} ->
208
        with %Activity{} = activity <-
209
               Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
210
211
212
213
214
215
216
217
          object
          |> Map.put("inReplyTo", replied_object.data["id"])
          |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
          |> Map.put("inReplyToStatusId", activity.id)
          |> Map.put("conversation", replied_object.data["context"] || object["conversation"])
          |> Map.put("context", replied_object.data["context"] || object["conversation"])
        else
          e ->
218
            Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
219
220
            object
        end
lain's avatar
lain committed
221

lain's avatar
lain committed
222
      e ->
223
        Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
lain's avatar
lain committed
224
225
226
        object
    end
  end
lain's avatar
lain committed
227

lain's avatar
lain committed
228
229
  def fix_in_reply_to(object), do: object

lain's avatar
lain committed
230
  def fix_context(object) do
Haelwenn's avatar
Haelwenn committed
231
232
    context = object["context"] || object["conversation"] || Utils.generate_context_id()

lain's avatar
lain committed
233
    object
Haelwenn's avatar
Haelwenn committed
234
235
    |> Map.put("context", context)
    |> Map.put("conversation", context)
lain's avatar
lain committed
236
237
  end

238
  def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
lain's avatar
lain committed
239
    attachments =
240
      attachment
lain's avatar
lain committed
241
      |> Enum.map(fn data ->
242
243
244
245
246
247
248
249
        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
250
      end)
lain's avatar
lain committed
251
252
253

    object
    |> Map.put("attachment", attachments)
254
255
  end

256
  def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
257
258
    Map.put(object, "attachment", [attachment])
    |> fix_attachments()
259
260
  end

261
  def fix_attachments(object), do: object
262

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

268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
  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
284
285
286
287
288
289
290
291
292
    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

293
294
    object
    |> Map.put("url", url_string)
295
296
297
298
  end

  def fix_url(object), do: object

299
  def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
lain's avatar
lain committed
300
301
302
303
304
    emoji = tags |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)

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

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

    # 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

317
318
319
320
321
322
323
324
  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

325
  def fix_emoji(object), do: object
326

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

333
    combined = tag ++ tags
334
335
336
337
338

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

339
340
  def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
    combined = [tag, String.slice(hashtag, 1..-1)]
341
342
343
344
345

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

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

348
  def fix_tag(object), do: object
349

350
351
352
353
354
355
356
357
358
359
360
  # 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
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
  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

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
415
416
417
418
419
420
  # 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

421
422
423
424
425
426
  # 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

427
428
429
  # TODO: validate those with a Ecto scheme
  # - tags
  # - emoji
kaniini's avatar
kaniini committed
430
  def handle_incoming(%{"type" => "Create", "object" => %{"type" => objtype} = object} = data)
431
      when objtype in ["Article", "Note", "Video", "Page"] do
432
    actor = get_actor(data)
433
434
435
436

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

438
    with nil <- Activity.get_create_by_object_ap_id(object["id"]),
lain's avatar
lain committed
439
         %User{} = user <- User.get_or_fetch_by_ap_id(data["actor"]) do
440
      object = fix_object(data["object"])
441

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

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

lain's avatar
lain committed
464
465
466
  def handle_incoming(
        %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data
      ) do
467
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
468
469
         %User{} = follower <- User.get_or_fetch_by_ap_id(follower),
         {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
470
      if not User.locked?(followed) do
kaniini's avatar
kaniini committed
471
472
        ActivityPub.accept(%{
          to: [follower.ap_id],
473
          actor: followed,
kaniini's avatar
kaniini committed
474
475
476
477
          object: data,
          local: true
        })

478
479
        User.follow(follower, followed)
      end
lain's avatar
lain committed
480

481
482
483
484
485
486
      {:ok, activity}
    else
      _e -> :error
    end
  end

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

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

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

531
      {:ok, activity}
532
533
    else
      _e -> :error
534
535
536
    end
  end

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

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

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

      banner = new_user_data[:info]["banner"]
573
      locked = new_user_data[:info]["locked"] || false
lain's avatar
lain committed
574
575
576
577

      update_data =
        new_user_data
        |> Map.take([:name, :bio, :avatar])
lain's avatar
lain committed
578
        |> Map.put(:info, %{"banner" => banner, "locked" => locked})
lain's avatar
lain committed
579
580
581

      actor
      |> User.upgrade_changeset(update_data)
lain's avatar
lain committed
582
      |> User.update_and_set_cache()
lain's avatar
lain committed
583

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

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

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

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

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

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

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

Thog's avatar
Thog committed
689
690
691
692
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Like", "object" => object_id},
Maksim's avatar
Maksim committed
693
          "actor" => _actor,
Thog's avatar
Thog committed
694
          "id" => id
695
        } = data
Thog's avatar
Thog committed
696
      ) do
697
698
699
    with actor <- get_actor(data),
         %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
         {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
Thog's avatar
Thog committed
700
701
702
         {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
      {:ok, activity}
    else
Thog's avatar
Thog committed
703
      _e -> :error
Thog's avatar
Thog committed
704
705
706
    end
  end

707
708
  def handle_incoming(_), do: :error

709
710
711
  def fetch_obj_helper(id) when is_bitstring(id), do: ActivityPub.fetch_object_from_id(id)
  def fetch_obj_helper(obj) when is_map(obj), do: ActivityPub.fetch_object_from_id(obj["id"])

712
  def get_obj_helper(id) do
713
    if object = Object.normalize(id), do: {:ok, object}, else: nil
714
715
  end

716
717
718
719
  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)
720
721
722
723
    else
      _e -> object
    end
  end
lain's avatar
lain committed
724

725
726
727
  def set_reply_to_uri(obj), do: obj

  # Prepares the object of an outgoing create activity.
lain's avatar
lain committed
728
729
  def prepare_object(object) do
    object
lain's avatar
lain committed
730
    |> set_sensitive
lain's avatar
lain committed
731
    |> add_hashtags
lain's avatar
lain committed
732
    |> add_mention_tags
lain's avatar
lain committed
733
    |> add_emoji_tags
lain's avatar
lain committed
734
    |> add_attributed_to
735
    |> add_likes
lain's avatar
lain committed
736
    |> prepare_attachments
lain's avatar
lain committed
737
    |> set_conversation
738
    |> set_reply_to_uri
739
740
    |> strip_internal_fields
    |> strip_internal_tags
lain's avatar
lain committed
741
742
  end

feld's avatar
feld committed
743
744
745
746
  #  @doc
  #  """
  #  internal -> Mastodon
  #  """
lain's avatar
lain committed
747

748
  def prepare_outgoing(%{"type" => "Create", "object" => object} = data) do
lain's avatar
lain committed
749
750
751
752
753
754
755
    object =
      object
      |> prepare_object

    data =
      data
      |> Map.put("object", object)
lain's avatar
lain committed
756
      |> Map.merge(Utils.make_json_ld_header())
lain's avatar
lain committed
757
758
759
760

    {:ok, data}
  end

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

      {:ok, data}
    end
  end

781
  def prepare_outgoing(%{"type" => "Reject"} = data) do
782
    with follow_activity <- Activity.normalize(data["object"]) do
783
784
785
786
787
788
789
790
791
792
      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
793
        |> Map.merge(Utils.make_json_ld_header())
794
795
796
797
798

      {:ok, data}
    end
  end

feld's avatar
feld committed
799
  def prepare_outgoing(%{"type" => _type} = data) do
lain's avatar
lain committed
800
801
    data =
      data
802
      |> strip_internal_fields
lain's avatar
lain committed
803
      |> maybe_fix_object_url
lain's avatar
lain committed
804
      |> Map.merge(Utils.make_json_ld_header())
805
806
807
808

    {:ok, data}
  end

809
810
  def maybe_fix_object_url(data) do
    if is_binary(data["object"]) and not String.starts_with?(data["object"], "http") do
811
      case fetch_obj_helper(data["object"]) do
812
813
        {:ok, relative_object} ->
          if relative_object.data["external_url"] do
feld's avatar
feld committed
814
            _data =
lain's avatar
lain committed
815
816
              data
              |> Map.put("object", relative_object.data["external_url"])
817
818
819
          else
            data
          end
lain's avatar
lain committed
820

821
822
823
824
825
826
827
828
829
        e ->
          Logger.error("Couldn't fetch #{data["object"]} #{inspect(e)}")
          data
      end
    else
      data
    end
  end

lain's avatar
lain committed
830
  def add_hashtags(object) do
lain's avatar
lain committed
831
832
    tags =
      (object["tag"] || [])
833
834
835
836
837
838
839
840
841
842
843
844
      |> 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
845
      end)
lain's avatar
lain committed
846
847
848
849
850

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

lain's avatar
lain committed
851
  def add_mention_tags(object) do
lain's avatar
lain committed
852
    mentions =
853
854
      object
      |> Utils.get_notified_from_object()
lain's avatar
lain committed
855
856
857
      |> Enum.map(fn user ->
        %{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"}
      end)
lain's avatar
lain committed
858

lain's avatar
lain committed
859
    tags = object["tag"] || []
lain's avatar
lain committed
860
861

    object
lain's avatar
lain committed
862
    |> Map.put("tag", tags ++ mentions)
lain's avatar
lain committed
863
864
  end

lain's avatar
lain committed
865
866
867
868
  # TODO: we should probably send mtime instead of unix epoch time for updated
  def add_emoji_tags(object) do
    tags = object["tag"] || []
    emoji = object["emoji"] || []
lain's avatar
lain committed
869
870
871
872
873
874
875
876
877
878
879
880

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

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

lain's avatar
lain committed
886
887
888
889
  def set_conversation(object) do
    Map.put(object, "conversation", object["context"])
  end

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

lain's avatar
lain committed
895
  def add_attributed_to(object) do
896
    attributed_to = object["attributedTo"] || object["actor"]
lain's avatar
lain committed
897
898

    object
899
    |> Map.put("attributedTo", attributed_to)
900
  end
lain's avatar
lain committed
901

902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
  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
918
  def prepare_attachments(object) do
lain's avatar
lain committed
919
920
921
922
923
924
    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
925
926
927
928

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

930
931
932
933
934
935
936
  defp strip_internal_fields(object) do
    object
    |> Map.drop([
      "like_count",
      "announcements",
      "announcement_count",
      "emoji",
937
938
      "context_id",
      "deleted_activity_id"
939
940
941
942
943
944
945
946
947
948
949
950
951
952
    ])
  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

lain's avatar
lain committed
953
954
  defp user_upgrade_task(user) do
    old_follower_address = User.ap_followers(user)
lain's avatar
lain committed
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972

    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
973
974
    Repo.update_all(q, [])

975
976
    maybe_retire_websub(user.ap_id)

lain's avatar
lain committed
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
    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
994
995
996
997
    Repo.update_all(q, [])
  end

  def upgrade_user_from_ap_id(ap_id, async \\ true) do
998
    with %User{local: false} = user <- User.get_by_ap_id(ap_id),
lain's avatar
lain committed
999
         {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id) do
lain's avatar
lain committed
1000
      already_ap = User.ap_enabled?(user)
For faster browsing, not all history is shown. View entire blame