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