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_id
 818       |> Object.normalize()
 819       |> Map.get(:data)
 820       |> prepare_object
 821
 822     data =
 823       data
 824       |> Map.put("object", object)
 825       |> Map.merge(Utils.make_json_ld_header())
 826       |> Map.delete("bcc")
 827
 828     {:ok, data}
 829   end
 830
 831   # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
 832   # because of course it does.
 833   def prepare_outgoing(%{"type" => "Accept"} = data) do
 834     with follow_activity <- Activity.normalize(data["object"]) do
 835       object = %{
 836         "actor" => follow_activity.actor,
 837         "object" => follow_activity.data["object"],
 838         "id" => follow_activity.data["id"],
 839         "type" => "Follow"
 840       }
 841
 842       data =
 843         data
 844         |> Map.put("object", object)
 845         |> Map.merge(Utils.make_json_ld_header())
 846
 847       {:ok, data}
 848     end
 849   end
 850
 851   def prepare_outgoing(%{"type" => "Reject"} = data) do
 852     with follow_activity <- Activity.normalize(data["object"]) do
 853       object = %{
 854         "actor" => follow_activity.actor,
 855         "object" => follow_activity.data["object"],
 856         "id" => follow_activity.data["id"],
 857         "type" => "Follow"
 858       }
 859
 860       data =
 861         data
 862         |> Map.put("object", object)
 863         |> Map.merge(Utils.make_json_ld_header())
 864
 865       {:ok, data}
 866     end
 867   end
 868
 869   def prepare_outgoing(%{"type" => _type} = data) do
 870     data =
 871       data
 872       |> strip_internal_fields
 873       |> maybe_fix_object_url
 874       |> Map.merge(Utils.make_json_ld_header())
 875
 876     {:ok, data}
 877   end
 878
 879   def maybe_fix_object_url(data) do
 880     if is_binary(data["object"]) and not String.starts_with?(data["object"], "http") do
 881       case get_obj_helper(data["object"]) do
 882         {:ok, relative_object} ->
 883           if relative_object.data["external_url"] do
 884             _data =
 885               data
 886               |> Map.put("object", relative_object.data["external_url"])
 887           else
 888             data
 889           end
 890
 891         e ->
 892           Logger.error("Couldn't fetch #{data["object"]} #{inspect(e)}")
 893           data
 894       end
 895     else
 896       data
 897     end
 898   end
 899
 900   def add_hashtags(object) do
 901     tags =
 902       (object["tag"] || [])
 903       |> Enum.map(fn
 904         # Expand internal representation tags into AS2 tags.
 905         tag when is_binary(tag) ->
 906           %{
 907             "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
 908             "name" => "##{tag}",
 909             "type" => "Hashtag"
 910           }
 911
 912         # Do not process tags which are already AS2 tag objects.
 913         tag when is_map(tag) ->
 914           tag
 915       end)
 916
 917     object
 918     |> Map.put("tag", tags)
 919   end
 920
 921   def add_mention_tags(object) do
 922     mentions =
 923       object
 924       |> Utils.get_notified_from_object()
 925       |> Enum.map(fn user ->
 926         %{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"}
 927       end)
 928
 929     tags = object["tag"] || []
 930
 931     object
 932     |> Map.put("tag", tags ++ mentions)
 933   end
 934
 935   def add_emoji_tags(%User{info: %{"emoji" => _emoji} = user_info} = object) do
 936     user_info = add_emoji_tags(user_info)
 937
 938     object
 939     |> Map.put(:info, user_info)
 940   end
 941
 942   # TODO: we should probably send mtime instead of unix epoch time for updated
 943   def add_emoji_tags(%{"emoji" => emoji} = object) do
 944     tags = object["tag"] || []
 945
 946     out =
 947       emoji
 948       |> Enum.map(fn {name, url} ->
 949         %{
 950           "icon" => %{"url" => url, "type" => "Image"},
 951           "name" => ":" <> name <> ":",
 952           "type" => "Emoji",
 953           "updated" => "1970-01-01T00:00:00Z",
 954           "id" => url
 955         }
 956       end)
 957
 958     object
 959     |> Map.put("tag", tags ++ out)
 960   end
 961
 962   def add_emoji_tags(object) do
 963     object
 964   end
 965
 966   def set_conversation(object) do
 967     Map.put(object, "conversation", object["context"])
 968   end
 969
 970   def set_sensitive(object) do
 971     tags = object["tag"] || []
 972     Map.put(object, "sensitive", "nsfw" in tags)
 973   end
 974
 975   def set_type(%{"type" => "Answer"} = object) do
 976     Map.put(object, "type", "Note")
 977   end
 978
 979   def set_type(object), do: object
 980
 981   def add_attributed_to(object) do
 982     attributed_to = object["attributedTo"] || object["actor"]
 983
 984     object
 985     |> Map.put("attributedTo", attributed_to)
 986   end
 987
 988   def add_likes(%{"id" => id, "like_count" => likes} = object) do
 989     likes = %{
 990       "id" => "#{id}/likes",
 991       "first" => "#{id}/likes?page=1",
 992       "type" => "OrderedCollection",
 993       "totalItems" => likes
 994     }
 995
 996     object
 997     |> Map.put("likes", likes)
 998   end
 999
1000   def add_likes(object) do
1001     object
1002   end
1003
1004   def prepare_attachments(object) do
1005     attachments =
1006       (object["attachment"] || [])
1007       |> Enum.map(fn data ->
1008         [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
1009         %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
1010       end)
1011
1012     object
1013     |> Map.put("attachment", attachments)
1014   end
1015
1016   defp strip_internal_fields(object) do
1017     object
1018     |> Map.drop([
1019       "like_count",
1020       "announcements",
1021       "announcement_count",
1022       "emoji",
1023       "context_id",
1024       "deleted_activity_id"
1025     ])
1026   end
1027
1028   defp strip_internal_tags(%{"tag" => tags} = object) do
1029     tags =
1030       tags
1031       |> Enum.filter(fn x -> is_map(x) end)
1032
1033     object
1034     |> Map.put("tag", tags)
1035   end
1036
1037   defp strip_internal_tags(object), do: object
1038
1039   def perform(:user_upgrade, user) do
1040     # we pass a fake user so that the followers collection is stripped away
1041     old_follower_address = User.ap_followers(%User{nickname: user.nickname})
1042
1043     q =
1044       from(
1045         u in User,
1046         where: ^old_follower_address in u.following,
1047         update: [
1048           set: [
1049             following:
1050               fragment(
1051                 "array_replace(?,?,?)",
1052                 u.following,
1053                 ^old_follower_address,
1054                 ^user.follower_address
1055               )
1056           ]
1057         ]
1058       )
1059
1060     Repo.update_all(q, [])
1061
1062     maybe_retire_websub(user.ap_id)
1063
1064     q =
1065       from(
1066         a in Activity,
1067         where: ^old_follower_address in a.recipients,
1068         update: [
1069           set: [
1070             recipients:
1071               fragment(
1072                 "array_replace(?,?,?)",
1073                 a.recipients,
1074                 ^old_follower_address,
1075                 ^user.follower_address
1076               )
1077           ]
1078         ]
1079       )
1080
1081     Repo.update_all(q, [])
1082   end
1083
1084   def upgrade_user_from_ap_id(ap_id) do
1085     with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1086          {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1087          already_ap <- User.ap_enabled?(user),
1088          {:ok, user} <- user |> User.upgrade_changeset(data) |> User.update_and_set_cache() do
1089       unless already_ap do
1090         PleromaJobQueue.enqueue(:transmogrifier, __MODULE__, [:user_upgrade, user])
1091       end
1092
1093       {:ok, user}
1094     else
1095       %User{} = user -> {:ok, user}
1096       e -> e
1097     end
1098   end
1099
1100   def maybe_retire_websub(ap_id) do
1101     # some sanity checks
1102     if is_binary(ap_id) && String.length(ap_id) > 8 do
1103       q =
1104         from(
1105           ws in Pleroma.Web.Websub.WebsubClientSubscription,
1106           where: fragment("? like ?", ws.topic, ^"#{ap_id}%")
1107         )
1108
1109       Repo.delete_all(q)
1110     end
1111   end
1112
1113   def maybe_fix_user_url(data) do
1114     if is_map(data["url"]) do
1115       Map.put(data, "url", data["url"]["href"])
1116     else
1117       data
1118     end
1119   end
1120
1121   def maybe_fix_user_object(data) do
1122     data
1123     |> maybe_fix_user_url
1124   end
1125 end