git.squeep.com Git - akkoma/blob - lib/pleroma/web/activity_pub/activity_pub.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.ActivityPub do
   6   alias Pleroma.Activity
   7   alias Pleroma.Activity.Ir.Topics
   8   alias Pleroma.Config
   9   alias Pleroma.Conversation
  10   alias Pleroma.Notification
  11   alias Pleroma.Object
  12   alias Pleroma.Object.Containment
  13   alias Pleroma.Object.Fetcher
  14   alias Pleroma.Pagination
  15   alias Pleroma.Repo
  16   alias Pleroma.Upload
  17   alias Pleroma.User
  18   alias Pleroma.Web.ActivityPub.MRF
  19   alias Pleroma.Web.ActivityPub.Transmogrifier
  20   alias Pleroma.Web.Streamer
  21   alias Pleroma.Web.WebFinger
  22   alias Pleroma.Workers.BackgroundWorker
  23
  24   import Ecto.Query
  25   import Pleroma.Web.ActivityPub.Utils
  26   import Pleroma.Web.ActivityPub.Visibility
  27
  28   require Logger
  29   require Pleroma.Constants
  30
  31   # For Announce activities, we filter the recipients based on following status for any actors
  32   # that match actual users.  See issue #164 for more information about why this is necessary.
  33   defp get_recipients(%{"type" => "Announce"} = data) do
  34     to = Map.get(data, "to", [])
  35     cc = Map.get(data, "cc", [])
  36     bcc = Map.get(data, "bcc", [])
  37     actor = User.get_cached_by_ap_id(data["actor"])
  38
  39     recipients =
  40       Enum.filter(Enum.concat([to, cc, bcc]), fn recipient ->
  41         case User.get_cached_by_ap_id(recipient) do
  42           nil -> true
  43           user -> User.following?(user, actor)
  44         end
  45       end)
  46
  47     {recipients, to, cc}
  48   end
  49
  50   defp get_recipients(%{"type" => "Create"} = data) do
  51     to = Map.get(data, "to", [])
  52     cc = Map.get(data, "cc", [])
  53     bcc = Map.get(data, "bcc", [])
  54     actor = Map.get(data, "actor", [])
  55     recipients = [to, cc, bcc, [actor]] |> Enum.concat() |> Enum.uniq()
  56     {recipients, to, cc}
  57   end
  58
  59   defp get_recipients(data) do
  60     to = Map.get(data, "to", [])
  61     cc = Map.get(data, "cc", [])
  62     bcc = Map.get(data, "bcc", [])
  63     recipients = Enum.concat([to, cc, bcc])
  64     {recipients, to, cc}
  65   end
  66
  67   defp check_actor_is_active(actor) do
  68     if not is_nil(actor) do
  69       with user <- User.get_cached_by_ap_id(actor),
  70            false <- user.info.deactivated do
  71         true
  72       else
  73         _e -> false
  74       end
  75     else
  76       true
  77     end
  78   end
  79
  80   defp check_remote_limit(%{"object" => %{"content" => content}}) when not is_nil(content) do
  81     limit = Config.get([:instance, :remote_limit])
  82     String.length(content) <= limit
  83   end
  84
  85   defp check_remote_limit(_), do: true
  86
  87   def increase_note_count_if_public(actor, object) do
  88     if is_public?(object), do: User.increase_note_count(actor), else: {:ok, actor}
  89   end
  90
  91   def decrease_note_count_if_public(actor, object) do
  92     if is_public?(object), do: User.decrease_note_count(actor), else: {:ok, actor}
  93   end
  94
  95   def increase_replies_count_if_reply(%{
  96         "object" => %{"inReplyTo" => reply_ap_id} = object,
  97         "type" => "Create"
  98       }) do
  99     if is_public?(object) do
 100       Object.increase_replies_count(reply_ap_id)
 101     end
 102   end
 103
 104   def increase_replies_count_if_reply(_create_data), do: :noop
 105
 106   def decrease_replies_count_if_reply(%Object{
 107         data: %{"inReplyTo" => reply_ap_id} = object
 108       }) do
 109     if is_public?(object) do
 110       Object.decrease_replies_count(reply_ap_id)
 111     end
 112   end
 113
 114   def decrease_replies_count_if_reply(_object), do: :noop
 115
 116   def increase_poll_votes_if_vote(%{
 117         "object" => %{"inReplyTo" => reply_ap_id, "name" => name},
 118         "type" => "Create"
 119       }) do
 120     Object.increase_vote_count(reply_ap_id, name)
 121   end
 122
 123   def increase_poll_votes_if_vote(_create_data), do: :noop
 124
 125   def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
 126     with nil <- Activity.normalize(map),
 127          map <- lazy_put_activity_defaults(map, fake),
 128          true <- bypass_actor_check || check_actor_is_active(map["actor"]),
 129          {_, true} <- {:remote_limit_error, check_remote_limit(map)},
 130          {:ok, map} <- MRF.filter(map),
 131          {recipients, _, _} = get_recipients(map),
 132          {:fake, false, map, recipients} <- {:fake, fake, map, recipients},
 133          :ok <- Containment.contain_child(map),
 134          {:ok, map, object} <- insert_full_object(map) do
 135       {:ok, activity} =
 136         Repo.insert(%Activity{
 137           data: map,
 138           local: local,
 139           actor: map["actor"],
 140           recipients: recipients
 141         })
 142
 143       # Splice in the child object if we have one.
 144       activity =
 145         if not is_nil(object) do
 146           Map.put(activity, :object, object)
 147         else
 148           activity
 149         end
 150
 151       BackgroundWorker.enqueue("fetch_data_for_activity", %{"activity_id" => activity.id})
 152
 153       Notification.create_notifications(activity)
 154
 155       participations =
 156         activity
 157         |> Conversation.create_or_bump_for()
 158         |> get_participations()
 159
 160       stream_out(activity)
 161       stream_out_participations(participations)
 162       {:ok, activity}
 163     else
 164       %Activity{} = activity ->
 165         {:ok, activity}
 166
 167       {:fake, true, map, recipients} ->
 168         activity = %Activity{
 169           data: map,
 170           local: local,
 171           actor: map["actor"],
 172           recipients: recipients,
 173           id: "pleroma:fakeid"
 174         }
 175
 176         Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
 177         {:ok, activity}
 178
 179       error ->
 180         {:error, error}
 181     end
 182   end
 183
 184   defp get_participations({:ok, %{participations: participations}}), do: participations
 185   defp get_participations(_), do: []
 186
 187   def stream_out_participations(participations) do
 188     participations =
 189       participations
 190       |> Repo.preload(:user)
 191
 192     Streamer.stream("participation", participations)
 193   end
 194
 195   def stream_out_participations(%Object{data: %{"context" => context}}, user) do
 196     with %Conversation{} = conversation <- Conversation.get_for_ap_id(context),
 197          conversation = Repo.preload(conversation, :participations),
 198          last_activity_id =
 199            fetch_latest_activity_id_for_context(conversation.ap_id, %{
 200              "user" => user,
 201              "blocking_user" => user
 202            }) do
 203       if last_activity_id do
 204         stream_out_participations(conversation.participations)
 205       end
 206     end
 207   end
 208
 209   def stream_out_participations(_, _), do: :noop
 210
 211   def stream_out(%Activity{data: %{"type" => data_type}} = activity)
 212       when data_type in ["Create", "Announce", "Delete"] do
 213     activity
 214     |> Topics.get_activity_topics()
 215     |> Streamer.stream(activity)
 216   end
 217
 218   def stream_out(_activity) do
 219     :noop
 220   end
 221
 222   def create(%{to: to, actor: actor, context: context, object: object} = params, fake \\ false) do
 223     additional = params[:additional] || %{}
 224     # only accept false as false value
 225     local = !(params[:local] == false)
 226     published = params[:published]
 227
 228     with create_data <-
 229            make_create_data(
 230              %{to: to, actor: actor, published: published, context: context, object: object},
 231              additional
 232            ),
 233          {:ok, activity} <- insert(create_data, local, fake),
 234          {:fake, false, activity} <- {:fake, fake, activity},
 235          _ <- increase_replies_count_if_reply(create_data),
 236          _ <- increase_poll_votes_if_vote(create_data),
 237          # Changing note count prior to enqueuing federation task in order to avoid
 238          # race conditions on updating user.info
 239          {:ok, _actor} <- increase_note_count_if_public(actor, activity),
 240          :ok <- maybe_federate(activity) do
 241       {:ok, activity}
 242     else
 243       {:fake, true, activity} ->
 244         {:ok, activity}
 245
 246       {:error, message} ->
 247         {:error, message}
 248     end
 249   end
 250
 251   def listen(%{to: to, actor: actor, context: context, object: object} = params) do
 252     additional = params[:additional] || %{}
 253     # only accept false as false value
 254     local = !(params[:local] == false)
 255     published = params[:published]
 256
 257     with listen_data <-
 258            make_listen_data(
 259              %{to: to, actor: actor, published: published, context: context, object: object},
 260              additional
 261            ),
 262          {:ok, activity} <- insert(listen_data, local),
 263          :ok <- maybe_federate(activity) do
 264       {:ok, activity}
 265     else
 266       {:error, message} ->
 267         {:error, message}
 268     end
 269   end
 270
 271   def accept(%{to: to, actor: actor, object: object} = params) do
 272     # only accept false as false value
 273     local = !(params[:local] == false)
 274
 275     with data <- %{"to" => to, "type" => "Accept", "actor" => actor.ap_id, "object" => object},
 276          {:ok, activity} <- insert(data, local),
 277          :ok <- maybe_federate(activity) do
 278       {:ok, activity}
 279     end
 280   end
 281
 282   def reject(%{to: to, actor: actor, object: object} = params) do
 283     # only accept false as false value
 284     local = !(params[:local] == false)
 285
 286     with data <- %{"to" => to, "type" => "Reject", "actor" => actor.ap_id, "object" => object},
 287          {:ok, activity} <- insert(data, local),
 288          :ok <- maybe_federate(activity) do
 289       {:ok, activity}
 290     end
 291   end
 292
 293   def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
 294     # only accept false as false value
 295     local = !(params[:local] == false)
 296
 297     with data <- %{
 298            "to" => to,
 299            "cc" => cc,
 300            "type" => "Update",
 301            "actor" => actor,
 302            "object" => object
 303          },
 304          {:ok, activity} <- insert(data, local),
 305          :ok <- maybe_federate(activity) do
 306       {:ok, activity}
 307     end
 308   end
 309
 310   def react_with_emoji(user, object, emoji, options \\ []) do
 311     with local <- Keyword.get(options, :local, true),
 312          activity_id <- Keyword.get(options, :activity_id, nil),
 313          Pleroma.Emoji.is_unicode_emoji?(emoji),
 314          reaction_data <- make_emoji_reaction_data(user, object, emoji, activity_id),
 315          {:ok, activity} <- insert(reaction_data, local),
 316          {:ok, object} <- add_emoji_reaction_to_object(activity, object),
 317          :ok <- maybe_federate(activity) do
 318       {:ok, activity, object}
 319     end
 320   end
 321
 322   def unreact_with_emoji(user, reaction_id, options \\ []) do
 323     with local <- Keyword.get(options, :local, true),
 324          activity_id <- Keyword.get(options, :activity_id, nil),
 325          user_ap_id <- user.ap_id,
 326          %Activity{actor: ^user_ap_id} = reaction_activity <- Activity.get_by_ap_id(reaction_id),
 327          object <- Object.normalize(reaction_activity),
 328          unreact_data <- make_undo_data(user, reaction_activity, activity_id),
 329          {:ok, activity} <- insert(unreact_data, local),
 330          {:ok, object} <- remove_emoji_reaction_from_object(reaction_activity, object),
 331          :ok <- maybe_federate(activity) do
 332       {:ok, activity, object}
 333     end
 334   end
 335
 336   # TODO: This is weird, maybe we shouldn't check here if we can make the activity.
 337   def like(
 338         %User{ap_id: ap_id} = user,
 339         %Object{data: %{"id" => _}} = object,
 340         activity_id \\ nil,
 341         local \\ true
 342       ) do
 343     with nil <- get_existing_like(ap_id, object),
 344          like_data <- make_like_data(user, object, activity_id),
 345          {:ok, activity} <- insert(like_data, local),
 346          {:ok, object} <- add_like_to_object(activity, object),
 347          :ok <- maybe_federate(activity) do
 348       {:ok, activity, object}
 349     else
 350       %Activity{} = activity -> {:ok, activity, object}
 351       error -> {:error, error}
 352     end
 353   end
 354
 355   def unlike(%User{} = actor, %Object{} = object, activity_id \\ nil, local \\ true) do
 356     with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
 357          unlike_data <- make_unlike_data(actor, like_activity, activity_id),
 358          {:ok, unlike_activity} <- insert(unlike_data, local),
 359          {:ok, _activity} <- Repo.delete(like_activity),
 360          {:ok, object} <- remove_like_from_object(like_activity, object),
 361          :ok <- maybe_federate(unlike_activity) do
 362       {:ok, unlike_activity, like_activity, object}
 363     else
 364       _e -> {:ok, object}
 365     end
 366   end
 367
 368   def announce(
 369         %User{ap_id: _} = user,
 370         %Object{data: %{"id" => _}} = object,
 371         activity_id \\ nil,
 372         local \\ true,
 373         public \\ true
 374       ) do
 375     with true <- is_announceable?(object, user, public),
 376          announce_data <- make_announce_data(user, object, activity_id, public),
 377          {:ok, activity} <- insert(announce_data, local),
 378          {:ok, object} <- add_announce_to_object(activity, object),
 379          :ok <- maybe_federate(activity) do
 380       {:ok, activity, object}
 381     else
 382       error -> {:error, error}
 383     end
 384   end
 385
 386   def unannounce(
 387         %User{} = actor,
 388         %Object{} = object,
 389         activity_id \\ nil,
 390         local \\ true
 391       ) do
 392     with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
 393          unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
 394          {:ok, unannounce_activity} <- insert(unannounce_data, local),
 395          :ok <- maybe_federate(unannounce_activity),
 396          {:ok, _activity} <- Repo.delete(announce_activity),
 397          {:ok, object} <- remove_announce_from_object(announce_activity, object) do
 398       {:ok, unannounce_activity, object}
 399     else
 400       _e -> {:ok, object}
 401     end
 402   end
 403
 404   def follow(follower, followed, activity_id \\ nil, local \\ true) do
 405     with data <- make_follow_data(follower, followed, activity_id),
 406          {:ok, activity} <- insert(data, local),
 407          :ok <- maybe_federate(activity),
 408          _ <- User.set_follow_state_cache(follower.ap_id, followed.ap_id, activity.data["state"]) do
 409       {:ok, activity}
 410     end
 411   end
 412
 413   def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
 414     with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
 415          {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
 416          unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
 417          {:ok, activity} <- insert(unfollow_data, local),
 418          :ok <- maybe_federate(activity) do
 419       {:ok, activity}
 420     end
 421   end
 422
 423   def delete(%User{ap_id: ap_id, follower_address: follower_address} = user) do
 424     with data <- %{
 425            "to" => [follower_address],
 426            "type" => "Delete",
 427            "actor" => ap_id,
 428            "object" => %{"type" => "Person", "id" => ap_id}
 429          },
 430          {:ok, activity} <- insert(data, true, true, true),
 431          :ok <- maybe_federate(activity) do
 432       {:ok, user}
 433     end
 434   end
 435
 436   def delete(%Object{data: %{"id" => id, "actor" => actor}} = object, local \\ true) do
 437     user = User.get_cached_by_ap_id(actor)
 438     to = (object.data["to"] || []) ++ (object.data["cc"] || [])
 439
 440     with {:ok, object, activity} <- Object.delete(object),
 441          data <- %{
 442            "type" => "Delete",
 443            "actor" => actor,
 444            "object" => id,
 445            "to" => to,
 446            "deleted_activity_id" => activity && activity.id
 447          },
 448          {:ok, activity} <- insert(data, local, false),
 449          stream_out_participations(object, user),
 450          _ <- decrease_replies_count_if_reply(object),
 451          # Changing note count prior to enqueuing federation task in order to avoid
 452          # race conditions on updating user.info
 453          {:ok, _actor} <- decrease_note_count_if_public(user, object),
 454          :ok <- maybe_federate(activity) do
 455       {:ok, activity}
 456     end
 457   end
 458
 459   @spec block(User.t(), User.t(), String.t() | nil, boolean) :: {:ok, Activity.t() | nil}
 460   def block(blocker, blocked, activity_id \\ nil, local \\ true) do
 461     outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
 462     unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])
 463
 464     if unfollow_blocked do
 465       follow_activity = fetch_latest_follow(blocker, blocked)
 466       if follow_activity, do: unfollow(blocker, blocked, nil, local)
 467     end
 468
 469     with true <- outgoing_blocks,
 470          block_data <- make_block_data(blocker, blocked, activity_id),
 471          {:ok, activity} <- insert(block_data, local),
 472          :ok <- maybe_federate(activity) do
 473       {:ok, activity}
 474     else
 475       _e -> {:ok, nil}
 476     end
 477   end
 478
 479   def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
 480     with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
 481          unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
 482          {:ok, activity} <- insert(unblock_data, local),
 483          :ok <- maybe_federate(activity) do
 484       {:ok, activity}
 485     end
 486   end
 487
 488   @spec flag(map()) :: {:ok, Activity.t()} | any
 489   def flag(
 490         %{
 491           actor: actor,
 492           context: _context,
 493           account: account,
 494           statuses: statuses,
 495           content: content
 496         } = params
 497       ) do
 498     # only accept false as false value
 499     local = !(params[:local] == false)
 500     forward = !(params[:forward] == false)
 501
 502     additional = params[:additional] || %{}
 503
 504     additional =
 505       if forward do
 506         Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
 507       else
 508         Map.merge(additional, %{"to" => [], "cc" => []})
 509       end
 510
 511     with flag_data <- make_flag_data(params, additional),
 512          {:ok, activity} <- insert(flag_data, local),
 513          :ok <- maybe_federate(activity) do
 514       Enum.each(User.all_superusers(), fn superuser ->
 515         superuser
 516         |> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
 517         |> Pleroma.Emails.Mailer.deliver_async()
 518       end)
 519
 520       {:ok, activity}
 521     end
 522   end
 523
 524   defp fetch_activities_for_context_query(context, opts) do
 525     public = [Pleroma.Constants.as_public()]
 526
 527     recipients =
 528       if opts["user"], do: [opts["user"].ap_id | opts["user"].following] ++ public, else: public
 529
 530     from(activity in Activity)
 531     |> maybe_preload_objects(opts)
 532     |> maybe_preload_bookmarks(opts)
 533     |> maybe_set_thread_muted_field(opts)
 534     |> restrict_blocked(opts)
 535     |> restrict_recipients(recipients, opts["user"])
 536     |> where(
 537       [activity],
 538       fragment(
 539         "?->>'type' = ? and ?->>'context' = ?",
 540         activity.data,
 541         "Create",
 542         activity.data,
 543         ^context
 544       )
 545     )
 546     |> exclude_poll_votes(opts)
 547     |> exclude_id(opts)
 548     |> order_by([activity], desc: activity.id)
 549   end
 550
 551   @spec fetch_activities_for_context(String.t(), keyword() | map()) :: [Activity.t()]
 552   def fetch_activities_for_context(context, opts \\ %{}) do
 553     context
 554     |> fetch_activities_for_context_query(opts)
 555     |> Repo.all()
 556   end
 557
 558   @spec fetch_latest_activity_id_for_context(String.t(), keyword() | map()) ::
 559           FlakeId.Ecto.CompatType.t() | nil
 560   def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
 561     context
 562     |> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
 563     |> limit(1)
 564     |> select([a], a.id)
 565     |> Repo.one()
 566   end
 567
 568   def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
 569     opts = Map.drop(opts, ["user"])
 570
 571     [Pleroma.Constants.as_public()]
 572     |> fetch_activities_query(opts)
 573     |> restrict_unlisted()
 574     |> Pagination.fetch_paginated(opts, pagination)
 575     |> Enum.reverse()
 576   end
 577
 578   @valid_visibilities ~w[direct unlisted public private]
 579
 580   defp restrict_visibility(query, %{visibility: visibility})
 581        when is_list(visibility) do
 582     if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
 583       query =
 584         from(
 585           a in query,
 586           where:
 587             fragment(
 588               "activity_visibility(?, ?, ?) = ANY (?)",
 589               a.actor,
 590               a.recipients,
 591               a.data,
 592               ^visibility
 593             )
 594         )
 595
 596       query
 597     else
 598       Logger.error("Could not restrict visibility to #{visibility}")
 599     end
 600   end
 601
 602   defp restrict_visibility(query, %{visibility: visibility})
 603        when visibility in @valid_visibilities do
 604     from(
 605       a in query,
 606       where:
 607         fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
 608     )
 609   end
 610
 611   defp restrict_visibility(_query, %{visibility: visibility})
 612        when visibility not in @valid_visibilities do
 613     Logger.error("Could not restrict visibility to #{visibility}")
 614   end
 615
 616   defp restrict_visibility(query, _visibility), do: query
 617
 618   defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
 619     do: query
 620
 621   defp restrict_thread_visibility(
 622          query,
 623          %{"user" => %User{info: %{skip_thread_containment: true}}},
 624          _
 625        ),
 626        do: query
 627
 628   defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
 629     from(
 630       a in query,
 631       where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
 632     )
 633   end
 634
 635   defp restrict_thread_visibility(query, _, _), do: query
 636
 637   def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
 638     params =
 639       params
 640       |> Map.put("user", reading_user)
 641       |> Map.put("actor_id", user.ap_id)
 642       |> Map.put("whole_db", true)
 643
 644     recipients =
 645       user_activities_recipients(%{
 646         "godmode" => params["godmode"],
 647         "reading_user" => reading_user
 648       })
 649
 650     fetch_activities(recipients, params)
 651     |> Enum.reverse()
 652   end
 653
 654   def fetch_user_activities(user, reading_user, params \\ %{}) do
 655     params =
 656       params
 657       |> Map.put("type", ["Create", "Announce"])
 658       |> Map.put("user", reading_user)
 659       |> Map.put("actor_id", user.ap_id)
 660       |> Map.put("whole_db", true)
 661       |> Map.put("pinned_activity_ids", user.info.pinned_activities)
 662
 663     recipients =
 664       user_activities_recipients(%{
 665         "godmode" => params["godmode"],
 666         "reading_user" => reading_user
 667       })
 668
 669     fetch_activities(recipients, params)
 670     |> Enum.reverse()
 671   end
 672
 673   defp user_activities_recipients(%{"godmode" => true}) do
 674     []
 675   end
 676
 677   defp user_activities_recipients(%{"reading_user" => reading_user}) do
 678     if reading_user do
 679       [Pleroma.Constants.as_public()] ++ [reading_user.ap_id | reading_user.following]
 680     else
 681       [Pleroma.Constants.as_public()]
 682     end
 683   end
 684
 685   defp restrict_since(query, %{"since_id" => ""}), do: query
 686
 687   defp restrict_since(query, %{"since_id" => since_id}) do
 688     from(activity in query, where: activity.id > ^since_id)
 689   end
 690
 691   defp restrict_since(query, _), do: query
 692
 693   defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
 694     raise "Can't use the child object without preloading!"
 695   end
 696
 697   defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
 698        when is_list(tag_reject) and tag_reject != [] do
 699     from(
 700       [_activity, object] in query,
 701       where: fragment("not (?)->'tag' \\?| (?)", object.data, ^tag_reject)
 702     )
 703   end
 704
 705   defp restrict_tag_reject(query, _), do: query
 706
 707   defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
 708     raise "Can't use the child object without preloading!"
 709   end
 710
 711   defp restrict_tag_all(query, %{"tag_all" => tag_all})
 712        when is_list(tag_all) and tag_all != [] do
 713     from(
 714       [_activity, object] in query,
 715       where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
 716     )
 717   end
 718
 719   defp restrict_tag_all(query, _), do: query
 720
 721   defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
 722     raise "Can't use the child object without preloading!"
 723   end
 724
 725   defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
 726     from(
 727       [_activity, object] in query,
 728       where: fragment("(?)->'tag' \\?| (?)", object.data, ^tag)
 729     )
 730   end
 731
 732   defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
 733     from(
 734       [_activity, object] in query,
 735       where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
 736     )
 737   end
 738
 739   defp restrict_tag(query, _), do: query
 740
 741   defp restrict_recipients(query, [], _user), do: query
 742
 743   defp restrict_recipients(query, recipients, nil) do
 744     from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
 745   end
 746
 747   defp restrict_recipients(query, recipients, user) do
 748     from(
 749       activity in query,
 750       where: fragment("? && ?", ^recipients, activity.recipients),
 751       or_where: activity.actor == ^user.ap_id
 752     )
 753   end
 754
 755   defp restrict_local(query, %{"local_only" => true}) do
 756     from(activity in query, where: activity.local == true)
 757   end
 758
 759   defp restrict_local(query, _), do: query
 760
 761   defp restrict_actor(query, %{"actor_id" => actor_id}) do
 762     from(activity in query, where: activity.actor == ^actor_id)
 763   end
 764
 765   defp restrict_actor(query, _), do: query
 766
 767   defp restrict_type(query, %{"type" => type}) when is_binary(type) do
 768     from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
 769   end
 770
 771   defp restrict_type(query, %{"type" => type}) do
 772     from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
 773   end
 774
 775   defp restrict_type(query, _), do: query
 776
 777   defp restrict_state(query, %{"state" => state}) do
 778     from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
 779   end
 780
 781   defp restrict_state(query, _), do: query
 782
 783   defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
 784     from(
 785       [_activity, object] in query,
 786       where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
 787     )
 788   end
 789
 790   defp restrict_favorited_by(query, _), do: query
 791
 792   defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
 793     raise "Can't use the child object without preloading!"
 794   end
 795
 796   defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
 797     from(
 798       [_activity, object] in query,
 799       where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
 800     )
 801   end
 802
 803   defp restrict_media(query, _), do: query
 804
 805   defp restrict_replies(query, %{"exclude_replies" => val}) when val == "true" or val == "1" do
 806     from(
 807       activity in query,
 808       where: fragment("?->'object'->>'inReplyTo' is null", activity.data)
 809     )
 810   end
 811
 812   defp restrict_replies(query, _), do: query
 813
 814   defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val == "true" or val == "1" do
 815     from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
 816   end
 817
 818   defp restrict_reblogs(query, _), do: query
 819
 820   defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query
 821
 822   defp restrict_muted(query, %{"muting_user" => %User{info: info}} = opts) do
 823     mutes = info.mutes
 824
 825     query =
 826       from([activity] in query,
 827         where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
 828         where: fragment("not (?->'to' \\?| ?)", activity.data, ^mutes)
 829       )
 830
 831     unless opts["skip_preload"] do
 832       from([thread_mute: tm] in query, where: is_nil(tm.user_id))
 833     else
 834       query
 835     end
 836   end
 837
 838   defp restrict_muted(query, _), do: query
 839
 840   defp restrict_blocked(query, %{"blocking_user" => %User{info: info}}) do
 841     blocks = info.blocks || []
 842     domain_blocks = info.domain_blocks || []
 843
 844     query =
 845       if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)
 846
 847     from(
 848       [activity, object: o] in query,
 849       where: fragment("not (? = ANY(?))", activity.actor, ^blocks),
 850       where: fragment("not (? && ?)", activity.recipients, ^blocks),
 851       where:
 852         fragment(
 853           "not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
 854           activity.data,
 855           activity.data,
 856           ^blocks
 857         ),
 858       where: fragment("not (split_part(?, '/', 3) = ANY(?))", activity.actor, ^domain_blocks),
 859       where: fragment("not (split_part(?->>'actor', '/', 3) = ANY(?))", o.data, ^domain_blocks)
 860     )
 861   end
 862
 863   defp restrict_blocked(query, _), do: query
 864
 865   defp restrict_unlisted(query) do
 866     from(
 867       activity in query,
 868       where:
 869         fragment(
 870           "not (coalesce(?->'cc', '{}'::jsonb) \\?| ?)",
 871           activity.data,
 872           ^[Pleroma.Constants.as_public()]
 873         )
 874     )
 875   end
 876
 877   defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
 878     from(activity in query, where: activity.id in ^ids)
 879   end
 880
 881   defp restrict_pinned(query, _), do: query
 882
 883   defp restrict_muted_reblogs(query, %{"muting_user" => %User{info: info}}) do
 884     muted_reblogs = info.muted_reblogs || []
 885
 886     from(
 887       activity in query,
 888       where:
 889         fragment(
 890           "not ( ?->>'type' = 'Announce' and ? = ANY(?))",
 891           activity.data,
 892           activity.actor,
 893           ^muted_reblogs
 894         )
 895     )
 896   end
 897
 898   defp restrict_muted_reblogs(query, _), do: query
 899
 900   defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query
 901
 902   defp exclude_poll_votes(query, _) do
 903     if has_named_binding?(query, :object) do
 904       from([activity, object: o] in query,
 905         where: fragment("not(?->>'type' = ?)", o.data, "Answer")
 906       )
 907     else
 908       query
 909     end
 910   end
 911
 912   defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
 913     from(activity in query, where: activity.id != ^id)
 914   end
 915
 916   defp exclude_id(query, _), do: query
 917
 918   defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query
 919
 920   defp maybe_preload_objects(query, _) do
 921     query
 922     |> Activity.with_preloaded_object()
 923   end
 924
 925   defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query
 926
 927   defp maybe_preload_bookmarks(query, opts) do
 928     query
 929     |> Activity.with_preloaded_bookmark(opts["user"])
 930   end
 931
 932   defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query
 933
 934   defp maybe_set_thread_muted_field(query, opts) do
 935     query
 936     |> Activity.with_set_thread_muted_field(opts["muting_user"] || opts["user"])
 937   end
 938
 939   defp maybe_order(query, %{order: :desc}) do
 940     query
 941     |> order_by(desc: :id)
 942   end
 943
 944   defp maybe_order(query, %{order: :asc}) do
 945     query
 946     |> order_by(asc: :id)
 947   end
 948
 949   defp maybe_order(query, _), do: query
 950
 951   def fetch_activities_query(recipients, opts \\ %{}) do
 952     config = %{
 953       skip_thread_containment: Config.get([:instance, :skip_thread_containment])
 954     }
 955
 956     Activity
 957     |> maybe_preload_objects(opts)
 958     |> maybe_preload_bookmarks(opts)
 959     |> maybe_set_thread_muted_field(opts)
 960     |> maybe_order(opts)
 961     |> restrict_recipients(recipients, opts["user"])
 962     |> restrict_tag(opts)
 963     |> restrict_tag_reject(opts)
 964     |> restrict_tag_all(opts)
 965     |> restrict_since(opts)
 966     |> restrict_local(opts)
 967     |> restrict_actor(opts)
 968     |> restrict_type(opts)
 969     |> restrict_state(opts)
 970     |> restrict_favorited_by(opts)
 971     |> restrict_blocked(opts)
 972     |> restrict_muted(opts)
 973     |> restrict_media(opts)
 974     |> restrict_visibility(opts)
 975     |> restrict_thread_visibility(opts, config)
 976     |> restrict_replies(opts)
 977     |> restrict_reblogs(opts)
 978     |> restrict_pinned(opts)
 979     |> restrict_muted_reblogs(opts)
 980     |> Activity.restrict_deactivated_users()
 981     |> exclude_poll_votes(opts)
 982   end
 983
 984   def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
 985     list_memberships = Pleroma.List.memberships(opts["user"])
 986
 987     fetch_activities_query(recipients ++ list_memberships, opts)
 988     |> Pagination.fetch_paginated(opts, pagination)
 989     |> Enum.reverse()
 990     |> maybe_update_cc(list_memberships, opts["user"])
 991   end
 992
 993   defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
 994        when is_list(list_memberships) and length(list_memberships) > 0 do
 995     Enum.map(activities, fn
 996       %{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
 997         if Enum.any?(bcc, &(&1 in list_memberships)) do
 998           update_in(activity.data["cc"], &[user_ap_id | &1])
 999         else
1000           activity
1001         end
1002
1003       activity ->
1004         activity
1005     end)
1006   end
1007
1008   defp maybe_update_cc(activities, _, _), do: activities
1009
1010   def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
1011     from(activity in query,
1012       where:
1013         fragment("? && ?", activity.recipients, ^recipients) or
1014           (fragment("? && ?", activity.recipients, ^recipients_with_public) and
1015              ^Pleroma.Constants.as_public() in activity.recipients)
1016     )
1017   end
1018
1019   def fetch_activities_bounded(
1020         recipients,
1021         recipients_with_public,
1022         opts \\ %{},
1023         pagination \\ :keyset
1024       ) do
1025     fetch_activities_query([], opts)
1026     |> fetch_activities_bounded_query(recipients, recipients_with_public)
1027     |> Pagination.fetch_paginated(opts, pagination)
1028     |> Enum.reverse()
1029   end
1030
1031   def upload(file, opts \\ []) do
1032     with {:ok, data} <- Upload.store(file, opts) do
1033       obj_data =
1034         if opts[:actor] do
1035           Map.put(data, "actor", opts[:actor])
1036         else
1037           data
1038         end
1039
1040       Repo.insert(%Object{data: obj_data})
1041     end
1042   end
1043
1044   defp object_to_user_data(data) do
1045     avatar =
1046       data["icon"]["url"] &&
1047         %{
1048           "type" => "Image",
1049           "url" => [%{"href" => data["icon"]["url"]}]
1050         }
1051
1052     banner =
1053       data["image"]["url"] &&
1054         %{
1055           "type" => "Image",
1056           "url" => [%{"href" => data["image"]["url"]}]
1057         }
1058
1059     fields =
1060       data
1061       |> Map.get("attachment", [])
1062       |> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
1063       |> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
1064
1065     locked = data["manuallyApprovesFollowers"] || false
1066     data = Transmogrifier.maybe_fix_user_object(data)
1067     discoverable = data["discoverable"] || false
1068
1069     user_data = %{
1070       ap_id: data["id"],
1071       info: %{
1072         ap_enabled: true,
1073         source_data: data,
1074         banner: banner,
1075         fields: fields,
1076         locked: locked,
1077         discoverable: discoverable
1078       },
1079       avatar: avatar,
1080       name: data["name"],
1081       follower_address: data["followers"],
1082       following_address: data["following"],
1083       bio: data["summary"]
1084     }
1085
1086     # nickname can be nil because of virtual actors
1087     user_data =
1088       if data["preferredUsername"] do
1089         Map.put(
1090           user_data,
1091           :nickname,
1092           "#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
1093         )
1094       else
1095         Map.put(user_data, :nickname, nil)
1096       end
1097
1098     {:ok, user_data}
1099   end
1100
1101   def fetch_follow_information_for_user(user) do
1102     with {:ok, following_data} <-
1103            Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
1104          following_count when is_integer(following_count) <- following_data["totalItems"],
1105          {:ok, hide_follows} <- collection_private(following_data),
1106          {:ok, followers_data} <-
1107            Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
1108          followers_count when is_integer(followers_count) <- followers_data["totalItems"],
1109          {:ok, hide_followers} <- collection_private(followers_data) do
1110       {:ok,
1111        %{
1112          hide_follows: hide_follows,
1113          follower_count: followers_count,
1114          following_count: following_count,
1115          hide_followers: hide_followers
1116        }}
1117     else
1118       {:error, _} = e ->
1119         e
1120
1121       e ->
1122         {:error, e}
1123     end
1124   end
1125
1126   defp maybe_update_follow_information(data) do
1127     with {:enabled, true} <-
1128            {:enabled, Pleroma.Config.get([:instance, :external_user_synchronization])},
1129          {:ok, info} <- fetch_follow_information_for_user(data) do
1130       info = Map.merge(data.info, info)
1131       Map.put(data, :info, info)
1132     else
1133       {:enabled, false} ->
1134         data
1135
1136       e ->
1137         Logger.error(
1138           "Follower/Following counter update for #{data.ap_id} failed.\n" <> inspect(e)
1139         )
1140
1141         data
1142     end
1143   end
1144
1145   defp collection_private(data) do
1146     if is_map(data["first"]) and
1147          data["first"]["type"] in ["CollectionPage", "OrderedCollectionPage"] do
1148       {:ok, false}
1149     else
1150       with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
1151              Fetcher.fetch_and_contain_remote_object_from_id(data["first"]) do
1152         {:ok, false}
1153       else
1154         {:error, {:ok, %{status: code}}} when code in [401, 403] ->
1155           {:ok, true}
1156
1157         {:error, _} = e ->
1158           e
1159
1160         e ->
1161           {:error, e}
1162       end
1163     end
1164   end
1165
1166   def user_data_from_user_object(data) do
1167     with {:ok, data} <- MRF.filter(data),
1168          {:ok, data} <- object_to_user_data(data) do
1169       {:ok, data}
1170     else
1171       e -> {:error, e}
1172     end
1173   end
1174
1175   def fetch_and_prepare_user_from_ap_id(ap_id) do
1176     with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
1177          {:ok, data} <- user_data_from_user_object(data),
1178          data <- maybe_update_follow_information(data) do
1179       {:ok, data}
1180     else
1181       e -> Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
1182     end
1183   end
1184
1185   def make_user_from_ap_id(ap_id) do
1186     if _user = User.get_cached_by_ap_id(ap_id) do
1187       Transmogrifier.upgrade_user_from_ap_id(ap_id)
1188     else
1189       with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
1190         User.insert_or_update_user(data)
1191       else
1192         e -> {:error, e}
1193       end
1194     end
1195   end
1196
1197   def make_user_from_nickname(nickname) do
1198     with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
1199       make_user_from_ap_id(ap_id)
1200     else
1201       _e -> {:error, "No AP id in WebFinger"}
1202     end
1203   end
1204
1205   # filter out broken threads
1206   def contain_broken_threads(%Activity{} = activity, %User{} = user) do
1207     entire_thread_visible_for_user?(activity, user)
1208   end
1209
1210   # do post-processing on a specific activity
1211   def contain_activity(%Activity{} = activity, %User{} = user) do
1212     contain_broken_threads(activity, user)
1213   end
1214
1215   def fetch_direct_messages_query do
1216     Activity
1217     |> restrict_type(%{"type" => "Create"})
1218     |> restrict_visibility(%{visibility: "direct"})
1219     |> order_by([activity], asc: activity.id)
1220   end
1221 end