transmogrifier.ex 24.3 KB
Newer Older
1
2
3
4
5
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
6
  alias Pleroma.Object
7
  alias Pleroma.Activity
lain's avatar
lain committed
8
  alias Pleroma.Repo
9
  alias Pleroma.Web.ActivityPub.ActivityPub
10
  alias Pleroma.Web.ActivityPub.Utils
11

lain's avatar
lain committed
12
13
  import Ecto.Query

14
15
  require Logger

16
17
18
19
20
  def get_actor(%{"actor" => actor}) when is_binary(actor) do
    actor
  end

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

29
30
  def get_actor(%{"actor" => %{"id" => id}}) when is_bitstring(id) do
    id
31
32
  end

33
34
35
36
  def get_actor(%{"actor" => nil, "attributedTo" => actor}) when not is_nil(actor) do
    get_actor(%{"actor" => actor})
  end

37
38
39
  @doc """
  Checks that an imported AP object's actor matches the domain it came from.
  """
40
41
  def contain_origin(id, %{"actor" => nil}), do: :error

42
  def contain_origin(id, %{"actor" => actor} = params) do
43
    id_uri = URI.parse(id)
44
    actor_uri = URI.parse(get_actor(params))
45
46
47
48
49
50
51
52

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

53
54
55
56
57
58
59
60
61
62
63
64
65
  def contain_origin_from_id(id, %{"id" => nil}), do: :error

  def contain_origin_from_id(id, %{"id" => other_id} = params) do
    id_uri = URI.parse(id)
    other_uri = URI.parse(other_id)

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

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

  def fix_addressing(map) do
    map
    |> fix_addressing_list("to")
    |> fix_addressing_list("cc")
    |> fix_addressing_list("bto")
    |> fix_addressing_list("bcc")
lain's avatar
lain committed
98
99
  end

100
101
  def fix_actor(%{"attributedTo" => actor} = object) do
    object
102
    |> Map.put("actor", get_actor(%{"actor" => actor}))
103
104
  end

105
106
107
108
109
110
111
112
113
114
115
116
117
118
  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

119
120
121
  def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object)
      when not is_nil(in_reply_to) do
    in_reply_to_id =
122
      cond do
123
124
125
126
127
128
129
130
131
        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)

132
        # Maybe I should output an error too?
133
134
        true ->
          ""
135
136
      end

137
    case fetch_obj_helper(in_reply_to_id) do
lain's avatar
lain committed
138
      {:ok, replied_object} ->
139
140
141
142
143
144
145
146
147
148
        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 ->
149
            Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
150
151
            object
        end
lain's avatar
lain committed
152

lain's avatar
lain committed
153
      e ->
154
        Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
lain's avatar
lain committed
155
156
157
        object
    end
  end
lain's avatar
lain committed
158

lain's avatar
lain committed
159
160
  def fix_in_reply_to(object), do: object

lain's avatar
lain committed
161
  def fix_context(object) do
Haelwenn's avatar
Haelwenn committed
162
163
    context = object["context"] || object["conversation"] || Utils.generate_context_id()

lain's avatar
lain committed
164
    object
Haelwenn's avatar
Haelwenn committed
165
166
    |> Map.put("context", context)
    |> Map.put("conversation", context)
lain's avatar
lain committed
167
168
  end

169
  def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
lain's avatar
lain committed
170
    attachments =
171
      attachment
lain's avatar
lain committed
172
173
174
175
      |> Enum.map(fn data ->
        url = [%{"type" => "Link", "mediaType" => data["mediaType"], "href" => data["url"]}]
        Map.put(data, "url", url)
      end)
lain's avatar
lain committed
176
177
178

    object
    |> Map.put("attachment", attachments)
179
180
  end

181
  def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
182
183
    Map.put(object, "attachment", [attachment])
    |> fix_attachments()
184
185
  end

186
  def fix_attachments(object), do: object
187

188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
  def fix_url(%{"url" => url} = object) when is_map(url) do
    object
    |> Map.put("url", url["href"])
  end

  def fix_url(%{"url" => url} = object) when is_list(url) do
    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

    object
    |> Map.put("url", url_string)
  end

  def fix_url(object), do: object

209
  def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
lain's avatar
lain committed
210
211
212
213
214
    emoji = tags |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)

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

lain's avatar
lain committed
217
218
        mapping |> Map.put(name, data["icon"]["url"])
      end)
lain's avatar
lain committed
219
220
221
222
223
224
225
226

    # 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

227
228
229
230
231
232
233
234
  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

235
  def fix_emoji(object), do: object
236

237
  def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
lain's avatar
lain committed
238
    tags =
239
      tag
lain's avatar
lain committed
240
241
      |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
      |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
242

243
    combined = tag ++ tags
244
245
246
247
248

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

249
250
  def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
    combined = [tag, String.slice(hashtag, 1..-1)]
251
252
253
254
255

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

256
  def fix_tag(object), do: object
257

258
259
260
261
262
263
264
265
266
267
268
  # 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

269
270
271
272
273
274
  # 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

275
276
277
  # TODO: validate those with a Ecto scheme
  # - tags
  # - emoji
kaniini's avatar
kaniini committed
278
  def handle_incoming(%{"type" => "Create", "object" => %{"type" => objtype} = object} = data)
279
      when objtype in ["Article", "Note", "Video", "Page"] do
280
    actor = get_actor(data)
281
282
283
284

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

lain's avatar
lain committed
286
287
    with nil <- Activity.get_create_activity_by_object_ap_id(object["id"]),
         %User{} = user <- User.get_or_fetch_by_ap_id(data["actor"]) do
288
      object = fix_object(data["object"])
289

290
291
292
293
      params = %{
        to: data["to"],
        object: object,
        actor: user,
lain's avatar
lain committed
294
        context: object["conversation"],
295
296
        local: false,
        published: data["published"],
lain's avatar
lain committed
297
298
299
300
301
        additional:
          Map.take(data, [
            "cc",
            "id"
          ])
302
303
304
305
      }

      ActivityPub.create(params)
    else
lain's avatar
lain committed
306
      %Activity{} = activity -> {:ok, activity}
307
308
309
310
      _e -> :error
    end
  end

lain's avatar
lain committed
311
312
313
  def handle_incoming(
        %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data
      ) do
314
    with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
315
316
         %User{} = follower <- User.get_or_fetch_by_ap_id(follower),
         {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
317
      if not User.locked?(followed) do
kaniini's avatar
kaniini committed
318
319
320
321
322
323
324
        ActivityPub.accept(%{
          to: [follower.ap_id],
          actor: followed.ap_id,
          object: data,
          local: true
        })

325
326
        User.follow(follower, followed)
      end
lain's avatar
lain committed
327

328
329
330
331
332
333
      {:ok, activity}
    else
      _e -> :error
    end
  end

334
335
336
337
338
339
340
341
342
  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
kaniini's avatar
kaniini committed
343

344
  defp mastodon_follow_hack(_), do: {:error, nil}
345

346
347
348
349
350
351
352
353
  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)
lain's avatar
lain committed
354

355
      _ ->
356
357
358
359
360
361
362
        {:error, nil}
    end
  end

  def handle_incoming(
        %{"type" => "Accept", "object" => follow_object, "actor" => actor, "id" => id} = data
      ) do
363
364
    with actor <- get_actor(data),
         %User{} = followed <- User.get_or_fetch_by_ap_id(actor),
365
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
366
         {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "accept"),
367
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
lain's avatar
lain committed
368
369
370
371
372
373
374
375
         {:ok, activity} <-
           ActivityPub.accept(%{
             to: follow_activity.data["to"],
             type: "Accept",
             actor: followed.ap_id,
             object: follow_activity.data["id"],
             local: false
           }) do
376
      if not User.following?(follower, followed) do
377
        {:ok, follower} = User.follow(follower, followed)
378
      end
379

380
      {:ok, activity}
381
382
    else
      _e -> :error
383
384
385
386
387
388
    end
  end

  def handle_incoming(
        %{"type" => "Reject", "object" => follow_object, "actor" => actor, "id" => id} = data
      ) do
389
390
    with actor <- get_actor(data),
         %User{} = followed <- User.get_or_fetch_by_ap_id(actor),
391
         {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
392
         {:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "reject"),
393
         %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
lain's avatar
lain committed
394
395
396
397
398
399
400
401
         {:ok, activity} <-
           ActivityPub.accept(%{
             to: follow_activity.data["to"],
             type: "Accept",
             actor: followed.ap_id,
             object: follow_activity.data["id"],
             local: false
           }) do
402
403
      User.unfollow(follower, followed)

404
      {:ok, activity}
405
406
    else
      _e -> :error
407
408
409
    end
  end

lain's avatar
lain committed
410
  def handle_incoming(
411
        %{"type" => "Like", "object" => object_id, "actor" => actor, "id" => id} = data
lain's avatar
lain committed
412
      ) do
413
414
415
    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
416
         {:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
lain's avatar
lain committed
417
418
419
420
421
422
      {:ok, activity}
    else
      _e -> :error
    end
  end

lain's avatar
lain committed
423
  def handle_incoming(
424
        %{"type" => "Announce", "object" => object_id, "actor" => actor, "id" => id} = data
lain's avatar
lain committed
425
      ) do
426
427
428
    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
429
         {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false) do
lain's avatar
lain committed
430
431
432
433
434
435
      {:ok, activity}
    else
      _e -> :error
    end
  end

lain's avatar
lain committed
436
  def handle_incoming(
437
        %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
lain's avatar
lain committed
438
          data
439
440
      )
      when object_type in ["Person", "Application", "Service", "Organization"] do
lain's avatar
lain committed
441
442
443
444
    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"]
445
      locked = new_user_data[:info]["locked"] || false
lain's avatar
lain committed
446
447
448
449

      update_data =
        new_user_data
        |> Map.take([:name, :bio, :avatar])
lain's avatar
lain committed
450
        |> Map.put(:info, %{"banner" => banner, "locked" => locked})
lain's avatar
lain committed
451
452
453

      actor
      |> User.upgrade_changeset(update_data)
lain's avatar
lain committed
454
      |> User.update_and_set_cache()
lain's avatar
lain committed
455

lain's avatar
lain committed
456
457
458
459
460
461
462
      ActivityPub.update(%{
        local: false,
        to: data["to"] || [],
        cc: data["cc"] || [],
        object: object,
        actor: actor_id
      })
lain's avatar
lain committed
463
464
465
466
467
468
469
    else
      e ->
        Logger.error(e)
        :error
    end
  end

470
471
472
473
474
  # 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
475
  def handle_incoming(
476
        %{"type" => "Delete", "object" => object_id, "actor" => _actor, "id" => _id} = data
lain's avatar
lain committed
477
      ) do
lain's avatar
lain committed
478
    object_id = Utils.get_ap_id(object_id)
lain's avatar
lain committed
479

480
    with actor <- get_actor(data),
481
         %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
482
         {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
483
         :ok <- contain_origin(actor.ap_id, object.data),
lain's avatar
lain committed
484
485
486
         {:ok, activity} <- ActivityPub.delete(object, false) do
      {:ok, activity}
    else
feld's avatar
feld committed
487
      _e -> :error
lain's avatar
lain committed
488
489
490
    end
  end

491
  def handle_incoming(
492
493
        %{
          "type" => "Undo",
494
          "object" => %{"type" => "Announce", "object" => object_id},
495
496
          "actor" => actor,
          "id" => id
497
        } = data
498
      ) do
499
500
501
    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),
502
         {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
503
504
      {:ok, activity}
    else
Thog's avatar
Thog committed
505
      _e -> :error
506
507
508
    end
  end

normandy's avatar
normandy committed
509
510
511
512
513
514
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Follow", "object" => followed},
          "actor" => follower,
          "id" => id
normandy's avatar
normandy committed
515
        } = _data
normandy's avatar
normandy committed
516
      ) do
normandy's avatar
normandy committed
517
518
    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
519
         {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
normandy's avatar
normandy committed
520
521
522
523
524
525
526
      User.unfollow(follower, followed)
      {:ok, activity}
    else
      e -> :error
    end
  end

normandy's avatar
normandy committed
527
528
529
530
531
532
533
534
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Block", "object" => blocked},
          "actor" => blocker,
          "id" => id
        } = _data
      ) do
href's avatar
href committed
535
    with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
536
         %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
normandy's avatar
normandy committed
537
538
         %User{} = blocker <- User.get_or_fetch_by_ap_id(blocker),
         {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
normandy's avatar
normandy committed
539
      User.unblock(blocker, blocked)
normandy's avatar
normandy committed
540
541
542
543
544
545
      {:ok, activity}
    else
      e -> :error
    end
  end

546
547
548
  def handle_incoming(
        %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = data
      ) do
href's avatar
href committed
549
    with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
550
         %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
normandy's avatar
normandy committed
551
         %User{} = blocker = User.get_or_fetch_by_ap_id(blocker),
normandy's avatar
normandy committed
552
         {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
553
      User.unfollow(blocker, blocked)
554
      User.block(blocker, blocked)
normandy's avatar
normandy committed
555
556
557
558
559
      {:ok, activity}
    else
      e -> :error
    end
  end
560

Thog's avatar
Thog committed
561
562
563
564
565
566
  def handle_incoming(
        %{
          "type" => "Undo",
          "object" => %{"type" => "Like", "object" => object_id},
          "actor" => actor,
          "id" => id
567
        } = data
Thog's avatar
Thog committed
568
      ) do
569
570
571
    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
572
573
574
         {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
      {:ok, activity}
    else
Thog's avatar
Thog committed
575
      _e -> :error
Thog's avatar
Thog committed
576
577
578
    end
  end

579
580
  def handle_incoming(_), do: :error

581
582
583
  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"])

584
  def get_obj_helper(id) do
585
    if object = Object.normalize(id), do: {:ok, object}, else: nil
586
587
  end

588
589
590
591
592
593
594
595
  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
596

597
598
599
  def set_reply_to_uri(obj), do: obj

  # Prepares the object of an outgoing create activity.
lain's avatar
lain committed
600
601
  def prepare_object(object) do
    object
lain's avatar
lain committed
602
    |> set_sensitive
lain's avatar
lain committed
603
    |> add_hashtags
lain's avatar
lain committed
604
    |> add_mention_tags
lain's avatar
lain committed
605
    |> add_emoji_tags
lain's avatar
lain committed
606
    |> add_attributed_to
lain's avatar
lain committed
607
    |> prepare_attachments
lain's avatar
lain committed
608
    |> set_conversation
609
    |> set_reply_to_uri
610
611
    |> strip_internal_fields
    |> strip_internal_tags
lain's avatar
lain committed
612
613
  end

feld's avatar
feld committed
614
615
616
617
  #  @doc
  #  """
  #  internal -> Mastodon
  #  """
lain's avatar
lain committed
618

lain's avatar
lain committed
619
  def prepare_outgoing(%{"type" => "Create", "object" => %{"type" => "Note"} = object} = data) do
lain's avatar
lain committed
620
621
622
623
624
625
626
    object =
      object
      |> prepare_object

    data =
      data
      |> Map.put("object", object)
lain's avatar
lain committed
627
      |> Map.merge(Utils.make_json_ld_header())
lain's avatar
lain committed
628
629
630
631

    {:ok, data}
  end

kaniini's avatar
kaniini committed
632
633
634
  # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
  # because of course it does.
  def prepare_outgoing(%{"type" => "Accept"} = data) do
635
    with follow_activity <- Activity.normalize(data["object"]) do
kaniini's avatar
kaniini committed
636
637
638
639
640
641
642
643
644
645
      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
646
        |> Map.merge(Utils.make_json_ld_header())
kaniini's avatar
kaniini committed
647
648
649
650
651

      {:ok, data}
    end
  end

652
  def prepare_outgoing(%{"type" => "Reject"} = data) do
653
    with follow_activity <- Activity.normalize(data["object"]) do
654
655
656
657
658
659
660
661
662
663
      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
664
        |> Map.merge(Utils.make_json_ld_header())
665
666
667
668
669

      {:ok, data}
    end
  end

feld's avatar
feld committed
670
  def prepare_outgoing(%{"type" => _type} = data) do
lain's avatar
lain committed
671
672
673
    data =
      data
      |> maybe_fix_object_url
lain's avatar
lain committed
674
      |> Map.merge(Utils.make_json_ld_header())
675
676
677
678

    {:ok, data}
  end

679
680
  def maybe_fix_object_url(data) do
    if is_binary(data["object"]) and not String.starts_with?(data["object"], "http") do
681
      case fetch_obj_helper(data["object"]) do
682
683
        {:ok, relative_object} ->
          if relative_object.data["external_url"] do
feld's avatar
feld committed
684
            _data =
lain's avatar
lain committed
685
686
              data
              |> Map.put("object", relative_object.data["external_url"])
687
688
689
          else
            data
          end
lain's avatar
lain committed
690

691
692
693
694
695
696
697
698
699
        e ->
          Logger.error("Couldn't fetch #{data["object"]} #{inspect(e)}")
          data
      end
    else
      data
    end
  end

lain's avatar
lain committed
700
  def add_hashtags(object) do
lain's avatar
lain committed
701
702
703
704
705
706
707
708
709
    tags =
      (object["tag"] || [])
      |> Enum.map(fn tag ->
        %{
          "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
          "name" => "##{tag}",
          "type" => "Hashtag"
        }
      end)
lain's avatar
lain committed
710
711
712
713
714

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

lain's avatar
lain committed
715
  def add_mention_tags(object) do
lain's avatar
lain committed
716
    mentions =
717
718
      object
      |> Utils.get_notified_from_object()
lain's avatar
lain committed
719
720
721
      |> Enum.map(fn user ->
        %{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"}
      end)
lain's avatar
lain committed
722

lain's avatar
lain committed
723
    tags = object["tag"] || []
lain's avatar
lain committed
724
725

    object
lain's avatar
lain committed
726
    |> Map.put("tag", tags ++ mentions)
lain's avatar
lain committed
727
728
  end

lain's avatar
lain committed
729
730
731
732
  # 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
733
734
735
736
737
738
739
740
741
742
743
744

    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
745
746
747
748
749

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

lain's avatar
lain committed
750
751
752
753
  def set_conversation(object) do
    Map.put(object, "conversation", object["context"])
  end

lain's avatar
lain committed
754
755
756
757
758
  def set_sensitive(object) do
    tags = object["tag"] || []
    Map.put(object, "sensitive", "nsfw" in tags)
  end

lain's avatar
lain committed
759
760
761
762
763
  def add_attributed_to(object) do
    attributedTo = object["attributedTo"] || object["actor"]

    object
    |> Map.put("attributedTo", attributedTo)
764
  end
lain's avatar
lain committed
765
766

  def prepare_attachments(object) do
lain's avatar
lain committed
767
768
769
770
771
772
    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
773
774
775
776

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

778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
  defp strip_internal_fields(object) do
    object
    |> Map.drop([
      "likes",
      "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
801
802
  defp user_upgrade_task(user) do
    old_follower_address = User.ap_followers(user)
lain's avatar
lain committed
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820

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

823
824
    maybe_retire_websub(user.ap_id)

lain's avatar
lain committed
825
    # Only do this for recent activties, don't go through the whole db.
lain's avatar
lain committed
826
827
    # Only look at the last 1000 activities.
    since = (Repo.aggregate(Activity, :max, :id) || 0) - 1_000
lain's avatar
lain committed
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846

    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
847
848
849
850
    Repo.update_all(q, [])
  end

  def upgrade_user_from_ap_id(ap_id, async \\ true) do
851
    with %User{local: false} = user <- User.get_by_ap_id(ap_id),
lain's avatar
lain committed
852
         {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id) do
lain's avatar
lain committed
853
      already_ap = User.ap_enabled?(user)
lain's avatar
lain committed
854
855
856
857

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

lain's avatar
lain committed
859
860
861
862
863
864
865
      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
866
          user_upgrade_task(user)
lain's avatar
lain committed
867
        end
lain's avatar
lain committed
868
      end
lain's avatar
lain committed
869
870
871
872
873
874

      {:ok, user}
    else
      e -> e
    end
  end
875
876
877

  def maybe_retire_websub(ap_id) do
    # some sanity checks
lain's avatar
lain committed
878
879
880
881
882
883
884
    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}%")
        )

885
886
887
      Repo.delete_all(q)
    end
  end
888
889
890

  def maybe_fix_user_url(data) do
    if is_map(data["url"]) do
Thog's avatar
Thog committed
891
892
893
      Map.put(data, "url", data["url"]["href"])
    else
      data
894
895
896
897
898
899
900
    end
  end

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