transmogrifier.ex 26.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
  def fix_addressing(object) do
    object
133
134
135
136
    |> fix_addressing_list("to")
    |> fix_addressing_list("cc")
    |> fix_addressing_list("bto")
    |> fix_addressing_list("bcc")
137
    |> fix_explicit_addressing
lain's avatar
lain committed
138
139
  end

140
141
  def fix_actor(%{"attributedTo" => actor} = object) do
    object
142
    |> Map.put("actor", 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 fetch_obj_helper(in_reply_to_id) do
lain's avatar
lain committed
178
      {:ok, replied_object} ->
179
        with %Activity{} = activity <-
180
               Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
181
182
183
184
185
186
187
188
          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 ->
189
            Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
190
191
            object
        end
lain's avatar
lain committed
192

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

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

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

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

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

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

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

232
  def fix_attachments(object), do: object
233

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

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

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

  def fix_url(object), do: object

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

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

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

    # 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

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

296
  def fix_emoji(object), do: object
297

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

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

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

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

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

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

319
  def fix_tag(object), do: object
320

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

358
359
360
361
362
363
  # 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

364
365
366
  # TODO: validate those with a Ecto scheme
  # - tags
  # - emoji
kaniini's avatar
kaniini committed
367
  def handle_incoming(%{"type" => "Create", "object" => %{"type" => objtype} = object} = data)
368
      when objtype in ["Article", "Note", "Video", "Page"] do
369
    actor = get_actor(data)
370
371
372
373

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

375
    with nil <- Activity.get_create_by_object_ap_id(object["id"]),
lain's avatar
lain committed
376
         %User{} = user <- User.get_or_fetch_by_ap_id(data["actor"]) do
377
      object = fix_object(data["object"])
378

379
380
381
382
      params = %{
        to: data["to"],
        object: object,
        actor: user,
lain's avatar
lain committed
383
        context: object["conversation"],
384
385
        local: false,
        published: data["published"],
lain's avatar
lain committed
386
387
388
        additional:
          Map.take(data, [
            "cc",
389
            "directMessage",
lain's avatar
lain committed
390
391
            "id"
          ])
392
393
394
395
      }

      ActivityPub.create(params)
    else
lain's avatar
lain committed
396
      %Activity{} = activity -> {:ok, activity}
397
398
399
400
      _e -> :error
    end
  end

lain's avatar
lain committed
401
402
403
  def handle_incoming(
        %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data
      ) do
404
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
405
406
         %User{} = follower <- User.get_or_fetch_by_ap_id(follower),
         {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
407
      if not User.locked?(followed) do
kaniini's avatar
kaniini committed
408
409
        ActivityPub.accept(%{
          to: [follower.ap_id],
410
          actor: followed,
kaniini's avatar
kaniini committed
411
412
413
414
          object: data,
          local: true
        })

415
416
        User.follow(follower, followed)
      end
lain's avatar
lain committed
417

418
419
420
421
422
423
      {:ok, activity}
    else
      _e -> :error
    end
  end

424
  def handle_incoming(
Maksim's avatar
Maksim committed
425
        %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => _id} = data
426
      ) do
427
428
    with actor <- get_actor(data),
         %User{} = followed <- User.get_or_fetch_by_ap_id(actor),
429
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
430
         {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "accept"),
431
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
lain's avatar
lain committed
432
433
434
435
         {:ok, activity} <-
           ActivityPub.accept(%{
             to: follow_activity.data["to"],
             type: "Accept",
436
             actor: followed,
lain's avatar
lain committed
437
438
439
             object: follow_activity.data["id"],
             local: false
           }) do
440
      if not User.following?(follower, followed) do
Maksim's avatar
Maksim committed
441
        {:ok, _follower} = User.follow(follower, followed)
442
      end
443

444
      {:ok, activity}
445
446
    else
      _e -> :error
447
448
449
450
    end
  end

  def handle_incoming(
Maksim's avatar
Maksim committed
451
        %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => _id} = data
452
      ) do
453
454
    with actor <- get_actor(data),
         %User{} = followed <- User.get_or_fetch_by_ap_id(actor),
455
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
456
         {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "reject"),
457
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
lain's avatar
lain committed
458
         {:ok, activity} <-
459
           ActivityPub.reject(%{
lain's avatar
lain committed
460
             to: follow_activity.data["to"],
461
             type: "Reject",
462
             actor: followed,
lain's avatar
lain committed
463
464
465
             object: follow_activity.data["id"],
             local: false
           }) do
466
467
      User.unfollow(follower, followed)

468
      {:ok, activity}
469
470
    else
      _e -> :error
471
472
473
    end
  end

lain's avatar
lain committed
474
  def handle_incoming(
Maksim's avatar
Maksim committed
475
        %{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data
lain's avatar
lain committed
476
      ) do
477
478
479
    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
480
         {:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
lain's avatar
lain committed
481
482
483
484
485
486
      {:ok, activity}
    else
      _e -> :error
    end
  end

lain's avatar
lain committed
487
  def handle_incoming(
Maksim's avatar
Maksim committed
488
        %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data
lain's avatar
lain committed
489
      ) do
490
491
492
    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
493
         public <- Visibility.is_public?(data),
494
         {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
lain's avatar
lain committed
495
496
497
498
499
500
      {:ok, activity}
    else
      _e -> :error
    end
  end

lain's avatar
lain committed
501
  def handle_incoming(
502
        %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
lain's avatar
lain committed
503
          data
504
505
      )
      when object_type in ["Person", "Application", "Service", "Organization"] do
lain's avatar
lain committed
506
507
508
509
    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"]
510
      locked = new_user_data[:info]["locked"] || false
lain's avatar
lain committed
511
512
513
514

      update_data =
        new_user_data
        |> Map.take([:name, :bio, :avatar])
lain's avatar
lain committed
515
        |> Map.put(:info, %{"banner" => banner, "locked" => locked})
lain's avatar
lain committed
516
517
518

      actor
      |> User.upgrade_changeset(update_data)
lain's avatar
lain committed
519
      |> User.update_and_set_cache()
lain's avatar
lain committed
520

lain's avatar
lain committed
521
522
523
524
525
526
527
      ActivityPub.update(%{
        local: false,
        to: data["to"] || [],
        cc: data["cc"] || [],
        object: object,
        actor: actor_id
      })
lain's avatar
lain committed
528
529
530
531
532
533
534
    else
      e ->
        Logger.error(e)
        :error
    end
  end

535
536
537
538
539
  # 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
540
  def handle_incoming(
541
        %{"type" => "Delete", "object" => object_id, "actor" => _actor, "id" => _id} = data
lain's avatar
lain committed
542
      ) do
lain's avatar
lain committed
543
    object_id = Utils.get_ap_id(object_id)
lain's avatar
lain committed
544

545
    with actor <- get_actor(data),
546
         %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
547
         {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
548
         :ok <- contain_origin(actor.ap_id, object.data),
lain's avatar
lain committed
549
550
551
         {:ok, activity} <- ActivityPub.delete(object, false) do
      {:ok, activity}
    else
feld's avatar
feld committed
552
      _e -> :error
lain's avatar
lain committed
553
554
555
    end
  end

556
  def handle_incoming(
557
558
        %{
          "type" => "Undo",
559
          "object" => %{"type" => "Announce", "object" => object_id},
Maksim's avatar
Maksim committed
560
          "actor" => _actor,
561
          "id" => id
562
        } = data
563
      ) do
564
565
566
    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),
567
         {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
568
569
      {:ok, activity}
    else
Thog's avatar
Thog committed
570
      _e -> :error
571
572
573
    end
  end

normandy's avatar
normandy committed
574
575
576
577
578
579
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Follow", "object" => followed},
          "actor" => follower,
          "id" => id
normandy's avatar
normandy committed
580
        } = _data
normandy's avatar
normandy committed
581
      ) do
normandy's avatar
normandy committed
582
583
    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
584
         {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
normandy's avatar
normandy committed
585
586
587
      User.unfollow(follower, followed)
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
588
      _e -> :error
normandy's avatar
normandy committed
589
590
591
    end
  end

normandy's avatar
normandy committed
592
593
594
595
596
597
598
599
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Block", "object" => blocked},
          "actor" => blocker,
          "id" => id
        } = _data
      ) do
href's avatar
href committed
600
    with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
601
         %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
normandy's avatar
normandy committed
602
603
         %User{} = blocker <- User.get_or_fetch_by_ap_id(blocker),
         {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
normandy's avatar
normandy committed
604
      User.unblock(blocker, blocked)
normandy's avatar
normandy committed
605
606
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
607
      _e -> :error
normandy's avatar
normandy committed
608
609
610
    end
  end

611
  def handle_incoming(
Maksim's avatar
Maksim committed
612
        %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data
613
      ) do
href's avatar
href committed
614
    with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
615
         %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
normandy's avatar
normandy committed
616
         %User{} = blocker = User.get_or_fetch_by_ap_id(blocker),
normandy's avatar
normandy committed
617
         {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
618
      User.unfollow(blocker, blocked)
619
      User.block(blocker, blocked)
normandy's avatar
normandy committed
620
621
      {:ok, activity}
    else
Maksim's avatar
Maksim committed
622
      _e -> :error
normandy's avatar
normandy committed
623
624
    end
  end
625

Thog's avatar
Thog committed
626
627
628
629
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Like", "object" => object_id},
Maksim's avatar
Maksim committed
630
          "actor" => _actor,
Thog's avatar
Thog committed
631
          "id" => id
632
        } = data
Thog's avatar
Thog committed
633
      ) do
634
635
636
    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
637
638
639
         {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
      {:ok, activity}
    else
Thog's avatar
Thog committed
640
      _e -> :error
Thog's avatar
Thog committed
641
642
643
    end
  end

644
645
  def handle_incoming(_), do: :error

646
647
648
  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"])

649
  def get_obj_helper(id) do
650
    if object = Object.normalize(id), do: {:ok, object}, else: nil
651
652
  end

653
654
655
656
  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)
657
658
659
660
    else
      _e -> object
    end
  end
lain's avatar
lain committed
661

662
663
664
  def set_reply_to_uri(obj), do: obj

  # Prepares the object of an outgoing create activity.
lain's avatar
lain committed
665
666
  def prepare_object(object) do
    object
lain's avatar
lain committed
667
    |> set_sensitive
lain's avatar
lain committed
668
    |> add_hashtags
lain's avatar
lain committed
669
    |> add_mention_tags
lain's avatar
lain committed
670
    |> add_emoji_tags
lain's avatar
lain committed
671
    |> add_attributed_to
672
    |> add_likes
lain's avatar
lain committed
673
    |> prepare_attachments
lain's avatar
lain committed
674
    |> set_conversation
675
    |> set_reply_to_uri
676
677
    |> strip_internal_fields
    |> strip_internal_tags
lain's avatar
lain committed
678
679
  end

feld's avatar
feld committed
680
681
682
683
  #  @doc
  #  """
  #  internal -> Mastodon
  #  """
lain's avatar
lain committed
684

685
  def prepare_outgoing(%{"type" => "Create", "object" => object} = data) do
lain's avatar
lain committed
686
687
688
689
690
691
692
    object =
      object
      |> prepare_object

    data =
      data
      |> Map.put("object", object)
lain's avatar
lain committed
693
      |> Map.merge(Utils.make_json_ld_header())
lain's avatar
lain committed
694
695
696
697

    {:ok, data}
  end

kaniini's avatar
kaniini committed
698
699
700
  # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
  # because of course it does.
  def prepare_outgoing(%{"type" => "Accept"} = data) do
701
    with follow_activity <- Activity.normalize(data["object"]) do
kaniini's avatar
kaniini committed
702
703
704
705
706
707
708
709
710
711
      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
712
        |> Map.merge(Utils.make_json_ld_header())
kaniini's avatar
kaniini committed
713
714
715
716
717

      {:ok, data}
    end
  end

718
  def prepare_outgoing(%{"type" => "Reject"} = data) do
719
    with follow_activity <- Activity.normalize(data["object"]) do
720
721
722
723
724
725
726
727
728
729
      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
730
        |> Map.merge(Utils.make_json_ld_header())
731
732
733
734
735

      {:ok, data}
    end
  end

feld's avatar
feld committed
736
  def prepare_outgoing(%{"type" => _type} = data) do
lain's avatar
lain committed
737
738
    data =
      data
739
      |> strip_internal_fields
lain's avatar
lain committed
740
      |> maybe_fix_object_url
lain's avatar
lain committed
741
      |> Map.merge(Utils.make_json_ld_header())
742
743
744
745

    {:ok, data}
  end

746
747
  def maybe_fix_object_url(data) do
    if is_binary(data["object"]) and not String.starts_with?(data["object"], "http") do
748
      case fetch_obj_helper(data["object"]) do
749
750
        {:ok, relative_object} ->
          if relative_object.data["external_url"] do
feld's avatar
feld committed
751
            _data =
lain's avatar
lain committed
752
753
              data
              |> Map.put("object", relative_object.data["external_url"])
754
755
756
          else
            data
          end
lain's avatar
lain committed
757

758
759
760
761
762
763
764
765
766
        e ->
          Logger.error("Couldn't fetch #{data["object"]} #{inspect(e)}")
          data
      end
    else
      data
    end
  end

lain's avatar
lain committed
767
  def add_hashtags(object) do
lain's avatar
lain committed
768
769
    tags =
      (object["tag"] || [])
770
771
772
773
774
775
776
777
778
779
780
781
      |> 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
782
      end)
lain's avatar
lain committed
783
784
785
786
787

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

lain's avatar
lain committed
788
  def add_mention_tags(object) do
lain's avatar
lain committed
789
    mentions =
790
791
      object
      |> Utils.get_notified_from_object()
lain's avatar
lain committed
792
793
794
      |> Enum.map(fn user ->
        %{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"}
      end)
lain's avatar
lain committed
795

lain's avatar
lain committed
796
    tags = object["tag"] || []
lain's avatar
lain committed
797
798

    object
lain's avatar
lain committed
799
    |> Map.put("tag", tags ++ mentions)
lain's avatar
lain committed
800
801
  end

lain's avatar
lain committed
802
803
804
805
  # 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
806
807
808
809
810
811
812
813
814
815
816
817

    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
818
819
820
821
822

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

lain's avatar
lain committed
823
824
825
826
  def set_conversation(object) do
    Map.put(object, "conversation", object["context"])
  end

lain's avatar
lain committed
827
828
829
830
831
  def set_sensitive(object) do
    tags = object["tag"] || []
    Map.put(object, "sensitive", "nsfw" in tags)
  end

lain's avatar
lain committed
832
  def add_attributed_to(object) do
833
    attributed_to = object["attributedTo"] || object["actor"]
lain's avatar
lain committed
834
835

    object
836
    |> Map.put("attributedTo", attributed_to)
837
  end
lain's avatar
lain committed
838

839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
  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
855
  def prepare_attachments(object) do
lain's avatar
lain committed
856
857
858
859
860
861
    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
862
863
864
865

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

867
868
869
870
871
872
873
  defp strip_internal_fields(object) do
    object
    |> Map.drop([
      "like_count",
      "announcements",
      "announcement_count",
      "emoji",
874
875
      "context_id",
      "deleted_activity_id"
876
877
878
879
880
881
882
883
884
885
886
887
888
889
    ])
  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
890
891
  defp user_upgrade_task(user) do
    old_follower_address = User.ap_followers(user)
lain's avatar
lain committed
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909

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

912
913
    maybe_retire_websub(user.ap_id)

lain's avatar
lain committed
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
    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
931
932
933
934
    Repo.update_all(q, [])
  end

  def upgrade_user_from_ap_id(ap_id, async \\ true) do
935
    with %User{local: false} = user <- User.get_by_ap_id(ap_id),
lain's avatar
lain committed
936
         {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id) do
lain's avatar
lain committed
937
      already_ap = User.ap_enabled?(user)
lain's avatar
lain committed
938
939
940
941

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

lain's avatar
lain committed
943
944
945
946
947
948
949
      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
950
          user_upgrade_task(user)
lain's avatar
lain committed
951
        end
lain's avatar
lain committed
952
      end
lain's avatar
lain committed
953
954
955
956
957
958

      {:ok, user}
    else
      e -> e
    end
  end
959
960
961

  def maybe_retire_websub(ap_id) do
    # some sanity checks
lain's avatar
lain committed
962
963
964
965
966
967
968
    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}%")
        )

969
970
971
      Repo.delete_all(q)
    end
  end
972
973
974

  def maybe_fix_user_url(data) do
    if is_map(data["url"]) do
Thog's avatar
Thog committed
975
976
977
      Map.put(data, "url", data["url"]["href"])
    else
      data
978
979
980
981
982
983
984
    end
  end

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