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