git.squeep.com Git - akkoma/blob - lib/pleroma/web/activity_pub/transmogrifier.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.ActivityPub.Transmogrifier do
   6   @moduledoc """
   7   A module to handle coding from internal to wire ActivityPub and back.
   8   """
   9   alias Pleroma.Activity
  10   alias Pleroma.Object
  11   alias Pleroma.Object.Containment
  12   alias Pleroma.Repo
  13   alias Pleroma.User
  14   alias Pleroma.Web.ActivityPub.ActivityPub
  15   alias Pleroma.Web.ActivityPub.Utils
  16   alias Pleroma.Web.ActivityPub.Visibility
  17   alias Pleroma.Web.Federator
  18
  19   import Ecto.Query
  20
  21   require Logger
  22
  23   @doc """
  24   Modifies an incoming AP object (mastodon format) to our internal format.
  25   """
  26   def fix_object(object, options \\ []) do
  27     object
  28     |> fix_actor
  29     |> fix_url
  30     |> fix_attachments
  31     |> fix_context
  32     |> fix_in_reply_to(options)
  33     |> fix_emoji
  34     |> fix_tag
  35     |> fix_content_map
  36     |> fix_likes
  37     |> fix_addressing
  38     |> fix_summary
  39     |> fix_type(options)
  40   end
  41
  42   def fix_summary(%{"summary" => nil} = object) do
  43     object
  44     |> Map.put("summary", "")
  45   end
  46
  47   def fix_summary(%{"summary" => _} = object) do
  48     # summary is present, nothing to do
  49     object
  50   end
  51
  52   def fix_summary(object) do
  53     object
  54     |> Map.put("summary", "")
  55   end
  56
  57   def fix_addressing_list(map, field) do
  58     cond do
  59       is_binary(map[field]) ->
  60         Map.put(map, field, [map[field]])
  61
  62       is_nil(map[field]) ->
  63         Map.put(map, field, [])
  64
  65       true ->
  66         map
  67     end
  68   end
  69
  70   def fix_explicit_addressing(
  71         %{"to" => to, "cc" => cc} = object,
  72         explicit_mentions,
  73         follower_collection
  74       ) do
  75     explicit_to =
  76       to
  77       |> Enum.filter(fn x -> x in explicit_mentions end)
  78
  79     explicit_cc =
  80       to
  81       |> Enum.filter(fn x -> x not in explicit_mentions end)
  82
  83     final_cc =
  84       (cc ++ explicit_cc)
  85       |> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
  86       |> Enum.uniq()
  87
  88     object
  89     |> Map.put("to", explicit_to)
  90     |> Map.put("cc", final_cc)
  91   end
  92
  93   def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object
  94
  95   # if directMessage flag is set to true, leave the addressing alone
  96   def fix_explicit_addressing(%{"directMessage" => true} = object), do: object
  97
  98   def fix_explicit_addressing(object) do
  99     explicit_mentions =
 100       object
 101       |> Utils.determine_explicit_mentions()
 102
 103     follower_collection = User.get_cached_by_ap_id(Containment.get_actor(object)).follower_address
 104
 105     explicit_mentions =
 106       explicit_mentions ++ ["https://www.w3.org/ns/activitystreams#Public", follower_collection]
 107
 108     fix_explicit_addressing(object, explicit_mentions, follower_collection)
 109   end
 110
 111   # if as:Public is addressed, then make sure the followers collection is also addressed
 112   # so that the activities will be delivered to local users.
 113   def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
 114     recipients = to ++ cc
 115
 116     if followers_collection not in recipients do
 117       cond do
 118         "https://www.w3.org/ns/activitystreams#Public" in cc ->
 119           to = to ++ [followers_collection]
 120           Map.put(object, "to", to)
 121
 122         "https://www.w3.org/ns/activitystreams#Public" in to ->
 123           cc = cc ++ [followers_collection]
 124           Map.put(object, "cc", cc)
 125
 126         true ->
 127           object
 128       end
 129     else
 130       object
 131     end
 132   end
 133
 134   def fix_implicit_addressing(object, _), do: object
 135
 136   def fix_addressing(object) do
 137     {:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
 138     followers_collection = User.ap_followers(user)
 139
 140     object
 141     |> fix_addressing_list("to")
 142     |> fix_addressing_list("cc")
 143     |> fix_addressing_list("bto")
 144     |> fix_addressing_list("bcc")
 145     |> fix_explicit_addressing()
 146     |> fix_implicit_addressing(followers_collection)
 147   end
 148
 149   def fix_actor(%{"attributedTo" => actor} = object) do
 150     object
 151     |> Map.put("actor", Containment.get_actor(%{"actor" => actor}))
 152   end
 153
 154   # Check for standardisation
 155   # This is what Peertube does
 156   # curl -H 'Accept: application/activity+json' $likes | jq .totalItems
 157   # Prismo returns only an integer (count) as "likes"
 158   def fix_likes(%{"likes" => likes} = object) when not is_map(likes) do
 159     object
 160     |> Map.put("likes", [])
 161     |> Map.put("like_count", 0)
 162   end
 163
 164   def fix_likes(object) do
 165     object
 166   end
 167
 168   def fix_in_reply_to(object, options \\ [])
 169
 170   def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
 171       when not is_nil(in_reply_to) do
 172     in_reply_to_id =
 173       cond do
 174         is_bitstring(in_reply_to) ->
 175           in_reply_to
 176
 177         is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
 178           in_reply_to["id"]
 179
 180         is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
 181           Enum.at(in_reply_to, 0)
 182
 183         # Maybe I should output an error too?
 184         true ->
 185           ""
 186       end
 187
 188     object = Map.put(object, "inReplyToAtomUri", in_reply_to_id)
 189
 190     if Federator.allowed_incoming_reply_depth?(options[:depth]) do
 191       case get_obj_helper(in_reply_to_id, options) do
 192         {:ok, replied_object} ->
 193           with %Activity{} = _activity <-
 194                  Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
 195             object
 196             |> Map.put("inReplyTo", replied_object.data["id"])
 197             |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
 198             |> Map.put("conversation", replied_object.data["context"] || object["conversation"])
 199             |> Map.put("context", replied_object.data["context"] || object["conversation"])
 200           else
 201             e ->
 202               Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
 203               object
 204           end
 205
 206         e ->
 207           Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
 208           object
 209       end
 210     else
 211       object
 212     end
 213   end
 214
 215   def fix_in_reply_to(object, _options), do: object
 216
 217   def fix_context(object) do
 218     context = object["context"] || object["conversation"] || Utils.generate_context_id()
 219
 220     object
 221     |> Map.put("context", context)
 222     |> Map.put("conversation", context)
 223   end
 224
 225   def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
 226     attachments =
 227       attachment
 228       |> Enum.map(fn data ->
 229         media_type = data["mediaType"] || data["mimeType"]
 230         href = data["url"] || data["href"]
 231
 232         url = [%{"type" => "Link", "mediaType" => media_type, "href" => href}]
 233
 234         data
 235         |> Map.put("mediaType", media_type)
 236         |> Map.put("url", url)
 237       end)
 238
 239     object
 240     |> Map.put("attachment", attachments)
 241   end
 242
 243   def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
 244     Map.put(object, "attachment", [attachment])
 245     |> fix_attachments()
 246   end
 247
 248   def fix_attachments(object), do: object
 249
 250   def fix_url(%{"url" => url} = object) when is_map(url) do
 251     object
 252     |> Map.put("url", url["href"])
 253   end
 254
 255   def fix_url(%{"type" => "Video", "url" => url} = object) when is_list(url) do
 256     first_element = Enum.at(url, 0)
 257
 258     link_element =
 259       url
 260       |> Enum.filter(fn x -> is_map(x) end)
 261       |> Enum.filter(fn x -> x["mimeType"] == "text/html" end)
 262       |> Enum.at(0)
 263
 264     object
 265     |> Map.put("attachment", [first_element])
 266     |> Map.put("url", link_element["href"])
 267   end
 268
 269   def fix_url(%{"type" => object_type, "url" => url} = object)
 270       when object_type != "Video" and is_list(url) do
 271     first_element = Enum.at(url, 0)
 272
 273     url_string =
 274       cond do
 275         is_bitstring(first_element) -> first_element
 276         is_map(first_element) -> first_element["href"] || ""
 277         true -> ""
 278       end
 279
 280     object
 281     |> Map.put("url", url_string)
 282   end
 283
 284   def fix_url(object), do: object
 285
 286   def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
 287     emoji = tags |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
 288
 289     emoji =
 290       emoji
 291       |> Enum.reduce(%{}, fn data, mapping ->
 292         name = String.trim(data["name"], ":")
 293
 294         mapping |> Map.put(name, data["icon"]["url"])
 295       end)
 296
 297     # we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
 298     emoji = Map.merge(object["emoji"] || %{}, emoji)
 299
 300     object
 301     |> Map.put("emoji", emoji)
 302   end
 303
 304   def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
 305     name = String.trim(tag["name"], ":")
 306     emoji = %{name => tag["icon"]["url"]}
 307
 308     object
 309     |> Map.put("emoji", emoji)
 310   end
 311
 312   def fix_emoji(object), do: object
 313
 314   def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
 315     tags =
 316       tag
 317       |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
 318       |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
 319
 320     combined = tag ++ tags
 321
 322     object
 323     |> Map.put("tag", combined)
 324   end
 325
 326   def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
 327     combined = [tag, String.slice(hashtag, 1..-1)]
 328
 329     object
 330     |> Map.put("tag", combined)
 331   end
 332
 333   def fix_tag(%{"tag" => %{} = tag} = object), do: Map.put(object, "tag", [tag])
 334
 335   def fix_tag(object), do: object
 336
 337   # content map usually only has one language so this will do for now.
 338   def fix_content_map(%{"contentMap" => content_map} = object) do
 339     content_groups = Map.to_list(content_map)
 340     {_, content} = Enum.at(content_groups, 0)
 341
 342     object
 343     |> Map.put("content", content)
 344   end
 345
 346   def fix_content_map(object), do: object
 347
 348   def fix_type(object, options \\ [])
 349
 350   def fix_type(%{"inReplyTo" => reply_id} = object, options) when is_binary(reply_id) do
 351     reply =
 352       if Federator.allowed_incoming_reply_depth?(options[:depth]) do
 353         Object.normalize(reply_id, true)
 354       end
 355
 356     if reply && (reply.data["type"] == "Question" and object["name"]) do
 357       Map.put(object, "type", "Answer")
 358     else
 359       object
 360     end
 361   end
 362
 363   def fix_type(object, _), do: object
 364
 365   defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
 366     with true <- id =~ "follows",
 367          %User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
 368          %Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
 369       {:ok, activity}
 370     else
 371       _ -> {:error, nil}
 372     end
 373   end
 374
 375   defp mastodon_follow_hack(_, _), do: {:error, nil}
 376
 377   defp get_follow_activity(follow_object, followed) do
 378     with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
 379          {_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
 380       {:ok, activity}
 381     else
 382       # Can't find the activity. This might a Mastodon 2.3 "Accept"
 383       {:activity, nil} ->
 384         mastodon_follow_hack(follow_object, followed)
 385
 386       _ ->
 387         {:error, nil}
 388     end
 389   end
 390
 391   def handle_incoming(data, options \\ [])
 392
 393   # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
 394   # with nil ID.
 395   def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
 396     with context <- data["context"] || Utils.generate_context_id(),
 397          content <- data["content"] || "",
 398          %User{} = actor <- User.get_cached_by_ap_id(actor),
 399
 400          # Reduce the object list to find the reported user.
 401          %User{} = account <-
 402            Enum.reduce_while(objects, nil, fn ap_id, _ ->
 403              with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
 404                {:halt, user}
 405              else
 406                _ -> {:cont, nil}
 407              end
 408            end),
 409
 410          # Remove the reported user from the object list.
 411          statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
 412       params = %{
 413         actor: actor,
 414         context: context,
 415         account: account,
 416         statuses: statuses,
 417         content: content,
 418         additional: %{
 419           "cc" => [account.ap_id]
 420         }
 421       }
 422
 423       ActivityPub.flag(params)
 424     end
 425   end
 426
 427   # disallow objects with bogus IDs
 428   def handle_incoming(%{"id" => nil}, _options), do: :error
 429   def handle_incoming(%{"id" => ""}, _options), do: :error
 430   # length of https:// = 8, should validate better, but good enough for now.
 431   def handle_incoming(%{"id" => id}, _options) when not (is_binary(id) and length(id) > 8),
 432     do: :error
 433
 434   # TODO: validate those with a Ecto scheme
 435   # - tags
 436   # - emoji
 437   def handle_incoming(
 438         %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
 439         options
 440       )
 441       when objtype in ["Article", "Note", "Video", "Page", "Question", "Answer"] do
 442     actor = Containment.get_actor(data)
 443
 444     data =
 445       Map.put(data, "actor", actor)
 446       |> fix_addressing
 447
 448     with nil <- Activity.get_create_by_object_ap_id(object["id"]),
 449          {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
 450       options = Keyword.put(options, :depth, (options[:depth] || 0) + 1)
 451       object = fix_object(data["object"], options)
 452
 453       params = %{
 454         to: data["to"],
 455         object: object,
 456         actor: user,
 457         context: object["conversation"],
 458         local: false,
 459         published: data["published"],
 460         additional:
 461           Map.take(data, [
 462             "cc",
 463             "directMessage",
 464             "id"
 465           ])
 466       }
 467
 468       ActivityPub.create(params)
 469     else
 470       %Activity{} = activity -> {:ok, activity}
 471       _e -> :error
 472     end
 473   end
 474
 475   def handle_incoming(
 476         %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data,
 477         _options
 478       ) do
 479     with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
 480          {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
 481          {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
 482       with deny_follow_blocked <- Pleroma.Config.get([:user, :deny_follow_blocked]),
 483            {_, false} <-
 484              {:user_blocked, User.blocks?(followed, follower) && deny_follow_blocked},
 485            {_, false} <- {:user_locked, User.locked?(followed)},
 486            {_, {:ok, follower}} <- {:follow, User.follow(follower, followed)},
 487            {_, {:ok, _}} <-
 488              {:follow_state_update, Utils.update_follow_state_for_all(activity, "accept")} do
 489         ActivityPub.accept(%{
 490           to: [follower.ap_id],
 491           actor: followed,
 492           object: data,
 493           local: true
 494         })
 495       else
 496         {:user_blocked, true} ->
 497           {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
 498
 499           ActivityPub.reject(%{
 500             to: [follower.ap_id],
 501             actor: followed,
 502             object: data,
 503             local: true
 504           })
 505
 506         {:follow, {:error, _}} ->
 507           {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
 508
 509           ActivityPub.reject(%{
 510             to: [follower.ap_id],
 511             actor: followed,
 512             object: data,
 513             local: true
 514           })
 515
 516         {:user_locked, true} ->
 517           :noop
 518       end
 519
 520       {:ok, activity}
 521     else
 522       _e ->
 523         :error
 524     end
 525   end
 526
 527   def handle_incoming(
 528         %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => _id} = data,
 529         _options
 530       ) do
 531     with actor <- Containment.get_actor(data),
 532          {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
 533          {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
 534          {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
 535          %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
 536          {:ok, _follower} = User.follow(follower, followed) do
 537       ActivityPub.accept(%{
 538         to: follow_activity.data["to"],
 539         type: "Accept",
 540         actor: followed,
 541         object: follow_activity.data["id"],
 542         local: false
 543       })
 544     else
 545       _e -> :error
 546     end
 547   end
 548
 549   def handle_incoming(
 550         %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => _id} = data,
 551         _options
 552       ) do
 553     with actor <- Containment.get_actor(data),
 554          {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
 555          {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
 556          {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
 557          %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
 558          {:ok, activity} <-
 559            ActivityPub.reject(%{
 560              to: follow_activity.data["to"],
 561              type: "Reject",
 562              actor: followed,
 563              object: follow_activity.data["id"],
 564              local: false
 565            }) do
 566       User.unfollow(follower, followed)
 567
 568       {:ok, activity}
 569     else
 570       _e -> :error
 571     end
 572   end
 573
 574   def handle_incoming(
 575         %{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data,
 576         _options
 577       ) do
 578     with actor <- Containment.get_actor(data),
 579          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 580          {:ok, object} <- get_obj_helper(object_id),
 581          {:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
 582       {:ok, activity}
 583     else
 584       _e -> :error
 585     end
 586   end
 587
 588   def handle_incoming(
 589         %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data,
 590         _options
 591       ) do
 592     with actor <- Containment.get_actor(data),
 593          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 594          {:ok, object} <- get_obj_helper(object_id),
 595          public <- Visibility.is_public?(data),
 596          {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
 597       {:ok, activity}
 598     else
 599       _e -> :error
 600     end
 601   end
 602
 603   def handle_incoming(
 604         %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
 605           data,
 606         _options
 607       )
 608       when object_type in ["Person", "Application", "Service", "Organization"] do
 609     with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
 610       {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
 611
 612       banner = new_user_data[:info][:banner]
 613       locked = new_user_data[:info][:locked] || false
 614
 615       update_data =
 616         new_user_data
 617         |> Map.take([:name, :bio, :avatar])
 618         |> Map.put(:info, %{banner: banner, locked: locked})
 619
 620       actor
 621       |> User.upgrade_changeset(update_data)
 622       |> User.update_and_set_cache()
 623
 624       ActivityPub.update(%{
 625         local: false,
 626         to: data["to"] || [],
 627         cc: data["cc"] || [],
 628         object: object,
 629         actor: actor_id
 630       })
 631     else
 632       e ->
 633         Logger.error(e)
 634         :error
 635     end
 636   end
 637
 638   # TODO: We presently assume that any actor on the same origin domain as the object being
 639   # deleted has the rights to delete that object.  A better way to validate whether or not
 640   # the object should be deleted is to refetch the object URI, which should return either
 641   # an error or a tombstone.  This would allow us to verify that a deletion actually took
 642   # place.
 643   def handle_incoming(
 644         %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => _id} = data,
 645         _options
 646       ) do
 647     object_id = Utils.get_ap_id(object_id)
 648
 649     with actor <- Containment.get_actor(data),
 650          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 651          {:ok, object} <- get_obj_helper(object_id),
 652          :ok <- Containment.contain_origin(actor.ap_id, object.data),
 653          {:ok, activity} <- ActivityPub.delete(object, false) do
 654       {:ok, activity}
 655     else
 656       nil ->
 657         case User.get_cached_by_ap_id(object_id) do
 658           %User{ap_id: ^actor} = user ->
 659             {:ok, followers} = User.get_followers(user)
 660
 661             Enum.each(followers, fn follower ->
 662               User.unfollow(follower, user)
 663             end)
 664
 665             {:ok, friends} = User.get_friends(user)
 666
 667             Enum.each(friends, fn followed ->
 668               User.unfollow(user, followed)
 669             end)
 670
 671             User.invalidate_cache(user)
 672             Repo.delete(user)
 673
 674           nil ->
 675             :error
 676         end
 677
 678       _e ->
 679         :error
 680     end
 681   end
 682
 683   def handle_incoming(
 684         %{
 685           "type" => "Undo",
 686           "object" => %{"type" => "Announce", "object" => object_id},
 687           "actor" => _actor,
 688           "id" => id
 689         } = data,
 690         _options
 691       ) do
 692     with actor <- Containment.get_actor(data),
 693          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 694          {:ok, object} <- get_obj_helper(object_id),
 695          {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
 696       {:ok, activity}
 697     else
 698       _e -> :error
 699     end
 700   end
 701
 702   def handle_incoming(
 703         %{
 704           "type" => "Undo",
 705           "object" => %{"type" => "Follow", "object" => followed},
 706           "actor" => follower,
 707           "id" => id
 708         } = _data,
 709         _options
 710       ) do
 711     with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
 712          {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
 713          {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
 714       User.unfollow(follower, followed)
 715       {:ok, activity}
 716     else
 717       _e -> :error
 718     end
 719   end
 720
 721   def handle_incoming(
 722         %{
 723           "type" => "Undo",
 724           "object" => %{"type" => "Block", "object" => blocked},
 725           "actor" => blocker,
 726           "id" => id
 727         } = _data,
 728         _options
 729       ) do
 730     with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
 731          %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
 732          {:ok, %User{} = blocker} <- User.get_or_fetch_by_ap_id(blocker),
 733          {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
 734       User.unblock(blocker, blocked)
 735       {:ok, activity}
 736     else
 737       _e -> :error
 738     end
 739   end
 740
 741   def handle_incoming(
 742         %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
 743         _options
 744       ) do
 745     with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
 746          %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
 747          {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
 748          {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
 749       User.unfollow(blocker, blocked)
 750       User.block(blocker, blocked)
 751       {:ok, activity}
 752     else
 753       _e -> :error
 754     end
 755   end
 756
 757   def handle_incoming(
 758         %{
 759           "type" => "Undo",
 760           "object" => %{"type" => "Like", "object" => object_id},
 761           "actor" => _actor,
 762           "id" => id
 763         } = data,
 764         _options
 765       ) do
 766     with actor <- Containment.get_actor(data),
 767          {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
 768          {:ok, object} <- get_obj_helper(object_id),
 769          {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
 770       {:ok, activity}
 771     else
 772       _e -> :error
 773     end
 774   end
 775
 776   def handle_incoming(_, _), do: :error
 777
 778   def get_obj_helper(id, options \\ []) do
 779     if object = Object.normalize(id, true, options), do: {:ok, object}, else: nil
 780   end
 781
 782   def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
 783     with false <- String.starts_with?(in_reply_to, "http"),
 784          {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
 785       Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
 786     else
 787       _e -> object
 788     end
 789   end
 790
 791   def set_reply_to_uri(obj), do: obj
 792
 793   # Prepares the object of an outgoing create activity.
 794   def prepare_object(object) do
 795     object
 796     |> set_sensitive
 797     |> add_hashtags
 798     |> add_mention_tags
 799     |> add_emoji_tags
 800     |> add_attributed_to
 801     |> add_likes
 802     |> prepare_attachments
 803     |> set_conversation
 804     |> set_reply_to_uri
 805     |> strip_internal_fields
 806     |> strip_internal_tags
 807     |> set_type
 808   end
 809
 810   #  @doc
 811   #  """
 812   #  internal -> Mastodon
 813   #  """
 814
 815   def prepare_outgoing(%{"type" => "Create", "object" => object_id} = data) do
 816     object =
 817       Object.normalize(object_id).data
 818       |> prepare_object
 819
 820     data =
 821       data
 822       |> Map.put("object", object)
 823       |> Map.merge(Utils.make_json_ld_header())
 824
 825     {:ok, data}
 826   end
 827
 828   # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
 829   # because of course it does.
 830   def prepare_outgoing(%{"type" => "Accept"} = data) do
 831     with follow_activity <- Activity.normalize(data["object"]) do
 832       object = %{
 833         "actor" => follow_activity.actor,
 834         "object" => follow_activity.data["object"],
 835         "id" => follow_activity.data["id"],
 836         "type" => "Follow"
 837       }
 838
 839       data =
 840         data
 841         |> Map.put("object", object)
 842         |> Map.merge(Utils.make_json_ld_header())
 843
 844       {:ok, data}
 845     end
 846   end
 847
 848   def prepare_outgoing(%{"type" => "Reject"} = data) do
 849     with follow_activity <- Activity.normalize(data["object"]) do
 850       object = %{
 851         "actor" => follow_activity.actor,
 852         "object" => follow_activity.data["object"],
 853         "id" => follow_activity.data["id"],
 854         "type" => "Follow"
 855       }
 856
 857       data =
 858         data
 859         |> Map.put("object", object)
 860         |> Map.merge(Utils.make_json_ld_header())
 861
 862       {:ok, data}
 863     end
 864   end
 865
 866   def prepare_outgoing(%{"type" => _type} = data) do
 867     data =
 868       data
 869       |> strip_internal_fields
 870       |> maybe_fix_object_url
 871       |> Map.merge(Utils.make_json_ld_header())
 872
 873     {:ok, data}
 874   end
 875
 876   def maybe_fix_object_url(data) do
 877     if is_binary(data["object"]) and not String.starts_with?(data["object"], "http") do
 878       case get_obj_helper(data["object"]) do
 879         {:ok, relative_object} ->
 880           if relative_object.data["external_url"] do
 881             _data =
 882               data
 883               |> Map.put("object", relative_object.data["external_url"])
 884           else
 885             data
 886           end
 887
 888         e ->
 889           Logger.error("Couldn't fetch #{data["object"]} #{inspect(e)}")
 890           data
 891       end
 892     else
 893       data
 894     end
 895   end
 896
 897   def add_hashtags(object) do
 898     tags =
 899       (object["tag"] || [])
 900       |> Enum.map(fn
 901         # Expand internal representation tags into AS2 tags.
 902         tag when is_binary(tag) ->
 903           %{
 904             "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
 905             "name" => "##{tag}",
 906             "type" => "Hashtag"
 907           }
 908
 909         # Do not process tags which are already AS2 tag objects.
 910         tag when is_map(tag) ->
 911           tag
 912       end)
 913
 914     object
 915     |> Map.put("tag", tags)
 916   end
 917
 918   def add_mention_tags(object) do
 919     mentions =
 920       object
 921       |> Utils.get_notified_from_object()
 922       |> Enum.map(fn user ->
 923         %{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"}
 924       end)
 925
 926     tags = object["tag"] || []
 927
 928     object
 929     |> Map.put("tag", tags ++ mentions)
 930   end
 931
 932   def add_emoji_tags(%User{info: %{"emoji" => _emoji} = user_info} = object) do
 933     user_info = add_emoji_tags(user_info)
 934
 935     object
 936     |> Map.put(:info, user_info)
 937   end
 938
 939   # TODO: we should probably send mtime instead of unix epoch time for updated
 940   def add_emoji_tags(%{"emoji" => emoji} = object) do
 941     tags = object["tag"] || []
 942
 943     out =
 944       emoji
 945       |> Enum.map(fn {name, url} ->
 946         %{
 947           "icon" => %{"url" => url, "type" => "Image"},
 948           "name" => ":" <> name <> ":",
 949           "type" => "Emoji",
 950           "updated" => "1970-01-01T00:00:00Z",
 951           "id" => url
 952         }
 953       end)
 954
 955     object
 956     |> Map.put("tag", tags ++ out)
 957   end
 958
 959   def add_emoji_tags(object) do
 960     object
 961   end
 962
 963   def set_conversation(object) do
 964     Map.put(object, "conversation", object["context"])
 965   end
 966
 967   def set_sensitive(object) do
 968     tags = object["tag"] || []
 969     Map.put(object, "sensitive", "nsfw" in tags)
 970   end
 971
 972   def set_type(%{"type" => "Answer"} = object) do
 973     Map.put(object, "type", "Note")
 974   end
 975
 976   def set_type(object), do: object
 977
 978   def add_attributed_to(object) do
 979     attributed_to = object["attributedTo"] || object["actor"]
 980
 981     object
 982     |> Map.put("attributedTo", attributed_to)
 983   end
 984
 985   def add_likes(%{"id" => id, "like_count" => likes} = object) do
 986     likes = %{
 987       "id" => "#{id}/likes",
 988       "first" => "#{id}/likes?page=1",
 989       "type" => "OrderedCollection",
 990       "totalItems" => likes
 991     }
 992
 993     object
 994     |> Map.put("likes", likes)
 995   end
 996
 997   def add_likes(object) do
 998     object
 999   end
1000
1001   def prepare_attachments(object) do
1002     attachments =
1003       (object["attachment"] || [])
1004       |> Enum.map(fn data ->
1005         [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
1006         %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
1007       end)
1008
1009     object
1010     |> Map.put("attachment", attachments)
1011   end
1012
1013   defp strip_internal_fields(object) do
1014     object
1015     |> Map.drop([
1016       "like_count",
1017       "announcements",
1018       "announcement_count",
1019       "emoji",
1020       "context_id",
1021       "deleted_activity_id"
1022     ])
1023   end
1024
1025   defp strip_internal_tags(%{"tag" => tags} = object) do
1026     tags =
1027       tags
1028       |> Enum.filter(fn x -> is_map(x) end)
1029
1030     object
1031     |> Map.put("tag", tags)
1032   end
1033
1034   defp strip_internal_tags(object), do: object
1035
1036   def perform(:user_upgrade, user) do
1037     # we pass a fake user so that the followers collection is stripped away
1038     old_follower_address = User.ap_followers(%User{nickname: user.nickname})
1039
1040     q =
1041       from(
1042         u in User,
1043         where: ^old_follower_address in u.following,
1044         update: [
1045           set: [
1046             following:
1047               fragment(
1048                 "array_replace(?,?,?)",
1049                 u.following,
1050                 ^old_follower_address,
1051                 ^user.follower_address
1052               )
1053           ]
1054         ]
1055       )
1056
1057     Repo.update_all(q, [])
1058
1059     maybe_retire_websub(user.ap_id)
1060
1061     q =
1062       from(
1063         a in Activity,
1064         where: ^old_follower_address in a.recipients,
1065         update: [
1066           set: [
1067             recipients:
1068               fragment(
1069                 "array_replace(?,?,?)",
1070                 a.recipients,
1071                 ^old_follower_address,
1072                 ^user.follower_address
1073               )
1074           ]
1075         ]
1076       )
1077
1078     Repo.update_all(q, [])
1079   end
1080
1081   def upgrade_user_from_ap_id(ap_id) do
1082     with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1083          {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1084          already_ap <- User.ap_enabled?(user),
1085          {:ok, user} <- user |> User.upgrade_changeset(data) |> User.update_and_set_cache() do
1086       unless already_ap do
1087         PleromaJobQueue.enqueue(:transmogrifier, __MODULE__, [:user_upgrade, user])
1088       end
1089
1090       {:ok, user}
1091     else
1092       %User{} = user -> {:ok, user}
1093       e -> e
1094     end
1095   end
1096
1097   def maybe_retire_websub(ap_id) do
1098     # some sanity checks
1099     if is_binary(ap_id) && String.length(ap_id) > 8 do
1100       q =
1101         from(
1102           ws in Pleroma.Web.Websub.WebsubClientSubscription,
1103           where: fragment("? like ?", ws.topic, ^"#{ap_id}%")
1104         )
1105
1106       Repo.delete_all(q)
1107     end
1108   end
1109
1110   def maybe_fix_user_url(data) do
1111     if is_map(data["url"]) do
1112       Map.put(data, "url", data["url"]["href"])
1113     else
1114       data
1115     end
1116   end
1117
1118   def maybe_fix_user_object(data) do
1119     data
1120     |> maybe_fix_user_url
1121   end
1122 end