transmogrifier.ex 26.2 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
9
defmodule Pleroma.Web.ActivityPub.Transmogrifier do
  @moduledoc """
  A module to handle coding from internal to wire ActivityPub and back.
  """
  alias Pleroma.User
lain's avatar
lain committed
10
  alias Pleroma.Object
11
  alias Pleroma.Activity
lain's avatar
lain committed
12
  alias Pleroma.Repo
13
  alias Pleroma.Web.ActivityPub.ActivityPub
14
  alias Pleroma.Web.ActivityPub.Utils
15

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

18
19
  require Logger

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

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

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

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

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

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

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

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

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

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

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

96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
  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

  def fix_addressing(object) do
    object =
      object
      |> fix_addressing_list("to")
      |> fix_addressing_list("cc")
      |> fix_addressing_list("bto")
      |> fix_addressing_list("bcc")

    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
132
133
  end

134
135
  def fix_actor(%{"attributedTo" => actor} = object) do
    object
136
    |> Map.put("actor", get_actor(%{"actor" => actor}))
137
138
  end

139
140
141
142
143
144
145
146
147
148
149
150
151
152
  def fix_likes(%{"likes" => likes} = object)
      when is_bitstring(likes) do
    # Check for standardisation
    # This is what Peertube does
    # curl -H 'Accept: application/activity+json' $likes | jq .totalItems
    object
    |> Map.put("likes", [])
    |> Map.put("like_count", 0)
  end

  def fix_likes(object) do
    object
  end

153
154
155
  def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object)
      when not is_nil(in_reply_to) do
    in_reply_to_id =
156
      cond do
157
158
159
160
161
162
163
164
165
        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)

166
        # Maybe I should output an error too?
167
168
        true ->
          ""
169
170
      end

171
    case fetch_obj_helper(in_reply_to_id) do
lain's avatar
lain committed
172
      {:ok, replied_object} ->
173
174
175
176
177
178
179
180
181
182
        with %Activity{} = activity <-
               Activity.get_create_activity_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("inReplyToStatusId", activity.id)
          |> Map.put("conversation", replied_object.data["context"] || object["conversation"])
          |> Map.put("context", replied_object.data["context"] || object["conversation"])
        else
          e ->
183
            Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
184
185
            object
        end
lain's avatar
lain committed
186

lain's avatar
lain committed
187
      e ->
188
        Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
lain's avatar
lain committed
189
190
191
        object
    end
  end
lain's avatar
lain committed
192

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

lain's avatar
lain committed
195
  def fix_context(object) do
Haelwenn's avatar
Haelwenn committed
196
197
    context = object["context"] || object["conversation"] || Utils.generate_context_id()

lain's avatar
lain committed
198
    object
Haelwenn's avatar
Haelwenn committed
199
200
    |> Map.put("context", context)
    |> Map.put("conversation", context)
lain's avatar
lain committed
201
202
  end

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

    object
    |> Map.put("attachment", attachments)
219
220
  end

221
  def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
222
223
    Map.put(object, "attachment", [attachment])
    |> fix_attachments()
224
225
  end

226
  def fix_attachments(object), do: object
227

228
229
230
231
232
  def fix_url(%{"url" => url} = object) when is_map(url) do
    object
    |> Map.put("url", url["href"])
  end

233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
  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
249
250
251
252
253
254
255
256
257
    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

258
259
    object
    |> Map.put("url", url_string)
260
261
262
263
  end

  def fix_url(object), do: object

264
  def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
lain's avatar
lain committed
265
266
267
268
269
    emoji = tags |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)

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

lain's avatar
lain committed
272
273
        mapping |> Map.put(name, data["icon"]["url"])
      end)
lain's avatar
lain committed
274
275
276
277
278
279
280
281

    # 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

282
283
284
285
286
287
288
289
  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

290
  def fix_emoji(object), do: object
291

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

298
    combined = tag ++ tags
299
300
301
302
303

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

304
305
  def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
    combined = [tag, String.slice(hashtag, 1..-1)]
306
307
308
309
310

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

311
  def fix_tag(object), do: object
312

313
314
315
316
317
318
319
320
321
322
323
  # 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
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
  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

350
351
352
353
354
355
  # 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

356
357
358
  # TODO: validate those with a Ecto scheme
  # - tags
  # - emoji
kaniini's avatar
kaniini committed
359
  def handle_incoming(%{"type" => "Create", "object" => %{"type" => objtype} = object} = data)
360
      when objtype in ["Article", "Note", "Video", "Page"] do
361
    actor = get_actor(data)
362
363
364
365

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

lain's avatar
lain committed
367
368
    with nil <- Activity.get_create_activity_by_object_ap_id(object["id"]),
         %User{} = user <- User.get_or_fetch_by_ap_id(data["actor"]) do
369
      object = fix_object(data["object"])
370

371
372
373
374
      params = %{
        to: data["to"],
        object: object,
        actor: user,
lain's avatar
lain committed
375
        context: object["conversation"],
376
377
        local: false,
        published: data["published"],
lain's avatar
lain committed
378
379
380
381
382
        additional:
          Map.take(data, [
            "cc",
            "id"
          ])
383
384
385
386
      }

      ActivityPub.create(params)
    else
lain's avatar
lain committed
387
      %Activity{} = activity -> {:ok, activity}
388
389
390
391
      _e -> :error
    end
  end

lain's avatar
lain committed
392
393
394
  def handle_incoming(
        %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data
      ) do
395
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
396
397
         %User{} = follower <- User.get_or_fetch_by_ap_id(follower),
         {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
398
      if not User.locked?(followed) do
kaniini's avatar
kaniini committed
399
400
401
402
403
404
405
        ActivityPub.accept(%{
          to: [follower.ap_id],
          actor: followed.ap_id,
          object: data,
          local: true
        })

406
407
        User.follow(follower, followed)
      end
lain's avatar
lain committed
408

409
410
411
412
413
414
      {:ok, activity}
    else
      _e -> :error
    end
  end

415
  def handle_incoming(
Maksim's avatar
Maksim committed
416
        %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => _id} = data
417
      ) do
418
419
    with actor <- get_actor(data),
         %User{} = followed <- User.get_or_fetch_by_ap_id(actor),
420
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
421
         {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "accept"),
422
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
lain's avatar
lain committed
423
424
425
426
427
428
429
430
         {:ok, activity} <-
           ActivityPub.accept(%{
             to: follow_activity.data["to"],
             type: "Accept",
             actor: followed.ap_id,
             object: follow_activity.data["id"],
             local: false
           }) do
431
      if not User.following?(follower, followed) do
Maksim's avatar
Maksim committed
432
        {:ok, _follower} = User.follow(follower, followed)
433
      end
434

435
      {:ok, activity}
436
437
    else
      _e -> :error
438
439
440
441
    end
  end

  def handle_incoming(
Maksim's avatar
Maksim committed
442
        %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => _id} = data
443
      ) do
444
445
    with actor <- get_actor(data),
         %User{} = followed <- User.get_or_fetch_by_ap_id(actor),
446
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
447
         {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "reject"),
448
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
lain's avatar
lain committed
449
450
451
452
453
454
455
456
         {:ok, activity} <-
           ActivityPub.accept(%{
             to: follow_activity.data["to"],
             type: "Accept",
             actor: followed.ap_id,
             object: follow_activity.data["id"],
             local: false
           }) do
457
458
      User.unfollow(follower, followed)

459
      {:ok, activity}
460
461
    else
      _e -> :error
462
463
464
    end
  end

lain's avatar
lain committed
465
  def handle_incoming(
Maksim's avatar
Maksim committed
466
        %{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data
lain's avatar
lain committed
467
      ) do
468
469
470
    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
471
         {:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
lain's avatar
lain committed
472
473
474
475
476
477
      {:ok, activity}
    else
      _e -> :error
    end
  end

lain's avatar
lain committed
478
  def handle_incoming(
Maksim's avatar
Maksim committed
479
        %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data
lain's avatar
lain committed
480
      ) do
481
482
483
    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),
484
485
         public <- ActivityPub.is_public?(data),
         {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
lain's avatar
lain committed
486
487
488
489
490
491
      {:ok, activity}
    else
      _e -> :error
    end
  end

lain's avatar
lain committed
492
  def handle_incoming(
493
        %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
lain's avatar
lain committed
494
          data
495
496
      )
      when object_type in ["Person", "Application", "Service", "Organization"] do
lain's avatar
lain committed
497
498
499
500
    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"]
501
      locked = new_user_data[:info]["locked"] || false
lain's avatar
lain committed
502
503
504
505

      update_data =
        new_user_data
        |> Map.take([:name, :bio, :avatar])
lain's avatar
lain committed
506
        |> Map.put(:info, %{"banner" => banner, "locked" => locked})
lain's avatar
lain committed
507
508
509

      actor
      |> User.upgrade_changeset(update_data)
lain's avatar
lain committed
510
      |> User.update_and_set_cache()
lain's avatar
lain committed
511

lain's avatar
lain committed
512
513
514
515
516
517
518
      ActivityPub.update(%{
        local: false,
        to: data["to"] || [],
        cc: data["cc"] || [],
        object: object,
        actor: actor_id
      })
lain's avatar
lain committed
519
520
521
522
523
524
525
    else
      e ->
        Logger.error(e)
        :error
    end
  end

526
527
528
529
530
  # 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
531
  def handle_incoming(
532
        %{"type" => "Delete", "object" => object_id, "actor" => _actor, "id" => _id} = data
lain's avatar
lain committed
533
      ) do
lain's avatar
lain committed
534
    object_id = Utils.get_ap_id(object_id)
lain's avatar
lain committed
535

536
    with actor <- get_actor(data),
537
         %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
538
         {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
539
         :ok <- contain_origin(actor.ap_id, object.data),
lain's avatar
lain committed
540
541
542
         {:ok, activity} <- ActivityPub.delete(object, false) do
      {:ok, activity}
    else
feld's avatar
feld committed
543
      _e -> :error
lain's avatar
lain committed
544
545
546
    end
  end

547
  def handle_incoming(
548
549
        %{
          "type" => "Undo",
550
          "object" => %{"type" => "Announce", "object" => object_id},
Maksim's avatar
Maksim committed
551
          "actor" => _actor,
552
          "id" => id
553
        } = data
554
      ) do
555
556
557
    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),
558
         {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
559
560
      {:ok, activity}
    else
Thog's avatar
Thog committed
561
      _e -> :error
562
563
564
    end
  end

normandy's avatar
normandy committed
565
566
567
568
569
570
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Follow", "object" => followed},
          "actor" => follower,
          "id" => id
normandy's avatar
normandy committed
571
        } = _data
normandy's avatar
normandy committed
572
      ) do
normandy's avatar
normandy committed
573
574
    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
575
         {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
normandy's avatar
normandy committed
576
577
578
      User.unfollow(follower, followed)
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
579
      _e -> :error
normandy's avatar
normandy committed
580
581
582
    end
  end

normandy's avatar
normandy committed
583
584
585
586
587
588
589
590
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Block", "object" => blocked},
          "actor" => blocker,
          "id" => id
        } = _data
      ) do
href's avatar
href committed
591
    with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
592
         %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
normandy's avatar
normandy committed
593
594
         %User{} = blocker <- User.get_or_fetch_by_ap_id(blocker),
         {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
normandy's avatar
normandy committed
595
      User.unblock(blocker, blocked)
normandy's avatar
normandy committed
596
597
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
598
      _e -> :error
normandy's avatar
normandy committed
599
600
601
    end
  end

602
  def handle_incoming(
Maksim's avatar
Maksim committed
603
        %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data
604
      ) do
href's avatar
href committed
605
    with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
606
         %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
normandy's avatar
normandy committed
607
         %User{} = blocker = User.get_or_fetch_by_ap_id(blocker),
normandy's avatar
normandy committed
608
         {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
609
      User.unfollow(blocker, blocked)
610
      User.block(blocker, blocked)
normandy's avatar
normandy committed
611
612
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
613
      _e -> :error
normandy's avatar
normandy committed
614
615
    end
  end
616

Thog's avatar
Thog committed
617
618
619
620
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Like", "object" => object_id},
Maksim's avatar
Maksim committed
621
          "actor" => _actor,
Thog's avatar
Thog committed
622
          "id" => id
623
        } = data
Thog's avatar
Thog committed
624
      ) do
625
626
627
    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
628
629
630
         {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
      {:ok, activity}
    else
Thog's avatar
Thog committed
631
      _e -> :error
Thog's avatar
Thog committed
632
633
634
    end
  end

635
636
  def handle_incoming(_), do: :error

637
638
639
  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"])

640
  def get_obj_helper(id) do
641
    if object = Object.normalize(id), do: {:ok, object}, else: nil
642
643
  end

644
645
646
647
648
649
650
651
  def set_reply_to_uri(%{"inReplyTo" => inReplyTo} = object) do
    with false <- String.starts_with?(inReplyTo, "http"),
         {:ok, %{data: replied_to_object}} <- get_obj_helper(inReplyTo) do
      Map.put(object, "inReplyTo", replied_to_object["external_url"] || inReplyTo)
    else
      _e -> object
    end
  end
lain's avatar
lain committed
652

653
654
655
  def set_reply_to_uri(obj), do: obj

  # Prepares the object of an outgoing create activity.
lain's avatar
lain committed
656
657
  def prepare_object(object) do
    object
lain's avatar
lain committed
658
    |> set_sensitive
lain's avatar
lain committed
659
    |> add_hashtags
lain's avatar
lain committed
660
    |> add_mention_tags
lain's avatar
lain committed
661
    |> add_emoji_tags
lain's avatar
lain committed
662
    |> add_attributed_to
663
    |> add_likes
lain's avatar
lain committed
664
    |> prepare_attachments
lain's avatar
lain committed
665
    |> set_conversation
666
    |> set_reply_to_uri
667
668
    |> strip_internal_fields
    |> strip_internal_tags
lain's avatar
lain committed
669
670
  end

feld's avatar
feld committed
671
672
673
674
  #  @doc
  #  """
  #  internal -> Mastodon
  #  """
lain's avatar
lain committed
675

676
  def prepare_outgoing(%{"type" => "Create", "object" => object} = data) do
lain's avatar
lain committed
677
678
679
680
681
682
683
    object =
      object
      |> prepare_object

    data =
      data
      |> Map.put("object", object)
lain's avatar
lain committed
684
      |> Map.merge(Utils.make_json_ld_header())
lain's avatar
lain committed
685
686
687
688

    {:ok, data}
  end

kaniini's avatar
kaniini committed
689
690
691
  # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
  # because of course it does.
  def prepare_outgoing(%{"type" => "Accept"} = data) do
692
    with follow_activity <- Activity.normalize(data["object"]) do
kaniini's avatar
kaniini committed
693
694
695
696
697
698
699
700
701
702
      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
703
        |> Map.merge(Utils.make_json_ld_header())
kaniini's avatar
kaniini committed
704
705
706
707
708

      {:ok, data}
    end
  end

709
  def prepare_outgoing(%{"type" => "Reject"} = data) do
710
    with follow_activity <- Activity.normalize(data["object"]) do
711
712
713
714
715
716
717
718
719
720
      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
721
        |> Map.merge(Utils.make_json_ld_header())
722
723
724
725
726

      {:ok, data}
    end
  end

feld's avatar
feld committed
727
  def prepare_outgoing(%{"type" => _type} = data) do
lain's avatar
lain committed
728
729
730
    data =
      data
      |> maybe_fix_object_url
lain's avatar
lain committed
731
      |> Map.merge(Utils.make_json_ld_header())
732
733
734
735

    {:ok, data}
  end

736
737
  def maybe_fix_object_url(data) do
    if is_binary(data["object"]) and not String.starts_with?(data["object"], "http") do
738
      case fetch_obj_helper(data["object"]) do
739
740
        {:ok, relative_object} ->
          if relative_object.data["external_url"] do
feld's avatar
feld committed
741
            _data =
lain's avatar
lain committed
742
743
              data
              |> Map.put("object", relative_object.data["external_url"])
744
745
746
          else
            data
          end
lain's avatar
lain committed
747

748
749
750
751
752
753
754
755
756
        e ->
          Logger.error("Couldn't fetch #{data["object"]} #{inspect(e)}")
          data
      end
    else
      data
    end
  end

lain's avatar
lain committed
757
  def add_hashtags(object) do
lain's avatar
lain committed
758
759
760
761
762
763
764
765
766
    tags =
      (object["tag"] || [])
      |> Enum.map(fn tag ->
        %{
          "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
          "name" => "##{tag}",
          "type" => "Hashtag"
        }
      end)
lain's avatar
lain committed
767
768
769
770
771

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

lain's avatar
lain committed
772
  def add_mention_tags(object) do
lain's avatar
lain committed
773
    mentions =
774
775
      object
      |> Utils.get_notified_from_object()
lain's avatar
lain committed
776
777
778
      |> Enum.map(fn user ->
        %{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"}
      end)
lain's avatar
lain committed
779

lain's avatar
lain committed
780
    tags = object["tag"] || []
lain's avatar
lain committed
781
782

    object
lain's avatar
lain committed
783
    |> Map.put("tag", tags ++ mentions)
lain's avatar
lain committed
784
785
  end

lain's avatar
lain committed
786
787
788
789
  # 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
790
791
792
793
794
795
796
797
798
799
800
801

    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
802
803
804
805
806

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

lain's avatar
lain committed
807
808
809
810
  def set_conversation(object) do
    Map.put(object, "conversation", object["context"])
  end

lain's avatar
lain committed
811
812
813
814
815
  def set_sensitive(object) do
    tags = object["tag"] || []
    Map.put(object, "sensitive", "nsfw" in tags)
  end

lain's avatar
lain committed
816
817
818
819
820
  def add_attributed_to(object) do
    attributedTo = object["attributedTo"] || object["actor"]

    object
    |> Map.put("attributedTo", attributedTo)
821
  end
lain's avatar
lain committed
822

823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
  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
839
  def prepare_attachments(object) do
lain's avatar
lain committed
840
841
842
843
844
845
    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
846
847
848
849

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

851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
  defp strip_internal_fields(object) do
    object
    |> Map.drop([
      "like_count",
      "announcements",
      "announcement_count",
      "emoji",
      "context_id"
    ])
  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
873
874
  defp user_upgrade_task(user) do
    old_follower_address = User.ap_followers(user)
lain's avatar
lain committed
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892

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

895
896
    maybe_retire_websub(user.ap_id)

lain's avatar
lain committed
897
    # Only do this for recent activties, don't go through the whole db.
lain's avatar
lain committed
898
899
    # Only look at the last 1000 activities.
    since = (Repo.aggregate(Activity, :max, :id) || 0) - 1_000
lain's avatar
lain committed
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918

    q =
      from(
        a in Activity,
        where: ^old_follower_address in a.recipients,
        where: a.id > ^since,
        update: [
          set: [
            recipients:
              fragment(
                "array_replace(?,?,?)",
                a.recipients,
                ^old_follower_address,
                ^user.follower_address
              )
          ]
        ]
      )

lain's avatar
lain committed
919
920
921
922
    Repo.update_all(q, [])
  end

  def upgrade_user_from_ap_id(ap_id, async \\ true) do
923
    with %User{local: false} = user <- User.get_by_ap_id(ap_id),
lain's avatar
lain committed
924
         {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id) do
lain's avatar
lain committed
925
      already_ap = User.ap_enabled?(user)
lain's avatar
lain committed
926
927
928
929

      {:ok, user} =
        User.upgrade_changeset(user, data)
        |> Repo.update()
lain's avatar
lain committed
930

lain's avatar
lain committed
931
932
933
934
935
936
937
      if !already_ap do
        # This could potentially take a long time, do it in the background
        if async do
          Task.start(fn ->
            user_upgrade_task(user)
          end)
        else
lain's avatar
lain committed
938
          user_upgrade_task(user)
lain's avatar
lain committed
939
        end
lain's avatar
lain committed
940
      end
lain's avatar
lain committed
941
942
943
944
945
946

      {:ok, user}
    else
      e -> e
    end
  end
947
948
949

  def maybe_retire_websub(ap_id) do
    # some sanity checks
lain's avatar
lain committed
950
951
952
953
954
955
956
    if is_binary(ap_id) && String.length(ap_id) > 8 do
      q =
        from(
          ws in Pleroma.Web.Websub.WebsubClientSubscription,
          where: fragment("? like ?", ws.topic, ^"#{ap_id}%")
        )

957
958
959
      Repo.delete_all(q)
    end
  end
960
961
962

  def maybe_fix_user_url(data) do
    if is_map(data["url"]) do
Thog's avatar
Thog committed
963
964
965
      Map.put(data, "url", data["url"]["href"])
    else
      data
966
967
968
969
970
971
972
    end
  end

  def maybe_fix_user_object(data) do
    data
    |> maybe_fix_user_url
  end
973
end