git.squeep.com Git - akkoma/blob - lib/pleroma/notification.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Notification do
   6   use Ecto.Schema
   7
   8   alias Pleroma.Activity
   9   alias Pleroma.FollowingRelationship
  10   alias Pleroma.Notification
  11   alias Pleroma.Object
  12   alias Pleroma.Pagination
  13   alias Pleroma.Repo
  14   alias Pleroma.ThreadMute
  15   alias Pleroma.User
  16   alias Pleroma.Web.CommonAPI.Utils
  17   alias Pleroma.Web.Push
  18   alias Pleroma.Web.Streamer
  19
  20   import Ecto.Query
  21   import Ecto.Changeset
  22
  23   require Logger
  24
  25   @type t :: %__MODULE__{}
  26
  27   @include_muted_option :with_muted
  28
  29   schema "notifications" do
  30     field(:seen, :boolean, default: false)
  31     belongs_to(:user, User, type: FlakeId.Ecto.CompatType)
  32     belongs_to(:activity, Activity, type: FlakeId.Ecto.CompatType)
  33
  34     timestamps()
  35   end
  36
  37   def changeset(%Notification{} = notification, attrs) do
  38     notification
  39     |> cast(attrs, [:seen])
  40   end
  41
  42   defp for_user_query_ap_id_opts(user, opts) do
  43     ap_id_relationships =
  44       [:block] ++
  45         if opts[@include_muted_option], do: [], else: [:notification_mute]
  46
  47     preloaded_ap_ids = User.outgoing_relationships_ap_ids(user, ap_id_relationships)
  48
  49     exclude_blocked_opts = Map.merge(%{blocked_users_ap_ids: preloaded_ap_ids[:block]}, opts)
  50
  51     exclude_notification_muted_opts =
  52       Map.merge(%{notification_muted_users_ap_ids: preloaded_ap_ids[:notification_mute]}, opts)
  53
  54     {exclude_blocked_opts, exclude_notification_muted_opts}
  55   end
  56
  57   def for_user_query(user, opts \\ %{}) do
  58     {exclude_blocked_opts, exclude_notification_muted_opts} =
  59       for_user_query_ap_id_opts(user, opts)
  60
  61     Notification
  62     |> where(user_id: ^user.id)
  63     |> where(
  64       [n, a],
  65       fragment(
  66         "? not in (SELECT ap_id FROM users WHERE deactivated = 'true')",
  67         a.actor
  68       )
  69     )
  70     |> join(:inner, [n], activity in assoc(n, :activity))
  71     |> join(:left, [n, a], object in Object,
  72       on:
  73         fragment(
  74           "(?->>'id') = COALESCE((? -> 'object'::text) ->> 'id'::text)",
  75           object.data,
  76           a.data
  77         )
  78     )
  79     |> preload([n, a, o], activity: {a, object: o})
  80     |> exclude_notification_muted(user, exclude_notification_muted_opts)
  81     |> exclude_blocked(user, exclude_blocked_opts)
  82     |> exclude_visibility(opts)
  83   end
  84
  85   # Excludes blocked users and non-followed domain-blocked users
  86   defp exclude_blocked(query, user, opts) do
  87     blocked_ap_ids = opts[:blocked_users_ap_ids] || User.blocked_users_ap_ids(user)
  88
  89     query
  90     |> where([n, a], a.actor not in ^blocked_ap_ids)
  91     |> FollowingRelationship.keep_following_or_not_domain_blocked(user)
  92   end
  93
  94   defp exclude_notification_muted(query, _, %{@include_muted_option => true}) do
  95     query
  96   end
  97
  98   defp exclude_notification_muted(query, user, opts) do
  99     notification_muted_ap_ids =
 100       opts[:notification_muted_users_ap_ids] || User.notification_muted_users_ap_ids(user)
 101
 102     query
 103     |> where([n, a], a.actor not in ^notification_muted_ap_ids)
 104     |> join(:left, [n, a], tm in ThreadMute,
 105       on: tm.user_id == ^user.id and tm.context == fragment("?->>'context'", a.data)
 106     )
 107     |> where([n, a, o, tm], is_nil(tm.user_id))
 108   end
 109
 110   @valid_visibilities ~w[direct unlisted public private]
 111
 112   defp exclude_visibility(query, %{exclude_visibilities: visibility})
 113        when is_list(visibility) do
 114     if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
 115       query
 116       |> join(:left, [n, a], mutated_activity in Pleroma.Activity,
 117         on:
 118           fragment("?->>'context'", a.data) ==
 119             fragment("?->>'context'", mutated_activity.data) and
 120             fragment("(?->>'type' = 'Like' or ?->>'type' = 'Announce')", a.data, a.data) and
 121             fragment("?->>'type'", mutated_activity.data) == "Create",
 122         as: :mutated_activity
 123       )
 124       |> where(
 125         [n, a, mutated_activity: mutated_activity],
 126         not fragment(
 127           """
 128           CASE WHEN (?->>'type') = 'Like' or (?->>'type') = 'Announce'
 129             THEN (activity_visibility(?, ?, ?) = ANY (?))
 130             ELSE (activity_visibility(?, ?, ?) = ANY (?)) END
 131           """,
 132           a.data,
 133           a.data,
 134           mutated_activity.actor,
 135           mutated_activity.recipients,
 136           mutated_activity.data,
 137           ^visibility,
 138           a.actor,
 139           a.recipients,
 140           a.data,
 141           ^visibility
 142         )
 143       )
 144     else
 145       Logger.error("Could not exclude visibility to #{visibility}")
 146       query
 147     end
 148   end
 149
 150   defp exclude_visibility(query, %{exclude_visibilities: visibility})
 151        when visibility in @valid_visibilities do
 152     exclude_visibility(query, [visibility])
 153   end
 154
 155   defp exclude_visibility(query, %{exclude_visibilities: visibility})
 156        when visibility not in @valid_visibilities do
 157     Logger.error("Could not exclude visibility to #{visibility}")
 158     query
 159   end
 160
 161   defp exclude_visibility(query, _visibility), do: query
 162
 163   def for_user(user, opts \\ %{}) do
 164     user
 165     |> for_user_query(opts)
 166     |> Pagination.fetch_paginated(opts)
 167   end
 168
 169   @doc """
 170   Returns notifications for user received since given date.
 171
 172   ## Examples
 173
 174       iex> Pleroma.Notification.for_user_since(%Pleroma.User{}, ~N[2019-04-13 11:22:33])
 175       [%Pleroma.Notification{}, %Pleroma.Notification{}]
 176
 177       iex> Pleroma.Notification.for_user_since(%Pleroma.User{}, ~N[2019-04-15 11:22:33])
 178       []
 179   """
 180   @spec for_user_since(Pleroma.User.t(), NaiveDateTime.t()) :: [t()]
 181   def for_user_since(user, date) do
 182     from(n in for_user_query(user),
 183       where: n.updated_at > ^date
 184     )
 185     |> Repo.all()
 186   end
 187
 188   def set_read_up_to(%{id: user_id} = _user, id) do
 189     query =
 190       from(
 191         n in Notification,
 192         where: n.user_id == ^user_id,
 193         where: n.id <= ^id,
 194         where: n.seen == false,
 195         update: [
 196           set: [
 197             seen: true,
 198             updated_at: ^NaiveDateTime.utc_now()
 199           ]
 200         ],
 201         # Ideally we would preload object and activities here
 202         # but Ecto does not support preloads in update_all
 203         select: n.id
 204       )
 205
 206     {_, notification_ids} = Repo.update_all(query, [])
 207
 208     Notification
 209     |> where([n], n.id in ^notification_ids)
 210     |> join(:inner, [n], activity in assoc(n, :activity))
 211     |> join(:left, [n, a], object in Object,
 212       on:
 213         fragment(
 214           "(?->>'id') = COALESCE((? -> 'object'::text) ->> 'id'::text)",
 215           object.data,
 216           a.data
 217         )
 218     )
 219     |> preload([n, a, o], activity: {a, object: o})
 220     |> Repo.all()
 221   end
 222
 223   def read_one(%User{} = user, notification_id) do
 224     with {:ok, %Notification{} = notification} <- get(user, notification_id) do
 225       notification
 226       |> changeset(%{seen: true})
 227       |> Repo.update()
 228     end
 229   end
 230
 231   def get(%{id: user_id} = _user, id) do
 232     query =
 233       from(
 234         n in Notification,
 235         where: n.id == ^id,
 236         join: activity in assoc(n, :activity),
 237         preload: [activity: activity]
 238       )
 239
 240     notification = Repo.one(query)
 241
 242     case notification do
 243       %{user_id: ^user_id} ->
 244         {:ok, notification}
 245
 246       _ ->
 247         {:error, "Cannot get notification"}
 248     end
 249   end
 250
 251   def clear(user) do
 252     from(n in Notification, where: n.user_id == ^user.id)
 253     |> Repo.delete_all()
 254   end
 255
 256   def destroy_multiple(%{id: user_id} = _user, ids) do
 257     from(n in Notification,
 258       where: n.id in ^ids,
 259       where: n.user_id == ^user_id
 260     )
 261     |> Repo.delete_all()
 262   end
 263
 264   def dismiss(%Pleroma.Activity{} = activity) do
 265     Notification
 266     |> where([n], n.activity_id == ^activity.id)
 267     |> Repo.delete_all()
 268     |> case do
 269       {_, notifications} -> {:ok, notifications}
 270       _ -> {:error, "Cannot dismiss notification"}
 271     end
 272   end
 273
 274   def dismiss(%{id: user_id} = _user, id) do
 275     notification = Repo.get(Notification, id)
 276
 277     case notification do
 278       %{user_id: ^user_id} ->
 279         Repo.delete(notification)
 280
 281       _ ->
 282         {:error, "Cannot dismiss notification"}
 283     end
 284   end
 285
 286   def create_notifications(%Activity{data: %{"to" => _, "type" => "Create"}} = activity) do
 287     object = Object.normalize(activity)
 288
 289     if object && object.data["type"] == "Answer" do
 290       {:ok, []}
 291     else
 292       do_create_notifications(activity)
 293     end
 294   end
 295
 296   def create_notifications(%Activity{data: %{"type" => "Follow"}} = activity) do
 297     if Pleroma.Config.get([:notifications, :enable_follow_request_notifications]) ||
 298          Activity.follow_accepted?(activity) do
 299       do_create_notifications(activity)
 300     else
 301       {:ok, []}
 302     end
 303   end
 304
 305   def create_notifications(%Activity{data: %{"type" => type}} = activity)
 306       when type in ["Like", "Announce", "Move", "EmojiReact"] do
 307     do_create_notifications(activity)
 308   end
 309
 310   def create_notifications(_), do: {:ok, []}
 311
 312   defp do_create_notifications(%Activity{} = activity) do
 313     {enabled_receivers, disabled_receivers} = get_notified_from_activity(activity)
 314     potential_receivers = enabled_receivers ++ disabled_receivers
 315
 316     notifications =
 317       Enum.map(potential_receivers, fn user ->
 318         do_send = user in enabled_receivers
 319         create_notification(activity, user, do_send)
 320       end)
 321
 322     {:ok, notifications}
 323   end
 324
 325   # TODO move to sql, too.
 326   def create_notification(%Activity{} = activity, %User{} = user, do_send \\ true) do
 327     unless skip?(activity, user) do
 328       notification = %Notification{user_id: user.id, activity: activity}
 329       {:ok, notification} = Repo.insert(notification)
 330
 331       if do_send do
 332         Streamer.stream(["user", "user:notification"], notification)
 333         Push.send(notification)
 334       end
 335
 336       notification
 337     end
 338   end
 339
 340   @doc """
 341   Returns a tuple with 2 elements:
 342     {notification-enabled receivers, currently disabled receivers (blocking / [thread] muting)}
 343
 344   NOTE: might be called for FAKE Activities, see ActivityPub.Utils.get_notified_from_object/1
 345   """
 346   @spec get_notified_from_activity(Activity.t(), boolean()) :: {list(User.t()), list(User.t())}
 347   def get_notified_from_activity(activity, local_only \\ true)
 348
 349   def get_notified_from_activity(%Activity{data: %{"type" => type}} = activity, local_only)
 350       when type in ["Create", "Like", "Announce", "Follow", "Move", "EmojiReact"] do
 351     potential_receiver_ap_ids =
 352       []
 353       |> Utils.maybe_notify_to_recipients(activity)
 354       |> Utils.maybe_notify_mentioned_recipients(activity)
 355       |> Utils.maybe_notify_subscribers(activity)
 356       |> Utils.maybe_notify_followers(activity)
 357       |> Enum.uniq()
 358
 359     potential_receivers = User.get_users_from_set(potential_receiver_ap_ids, local_only)
 360
 361     notification_enabled_ap_ids =
 362       potential_receiver_ap_ids
 363       |> exclude_domain_blocker_ap_ids(activity, potential_receivers)
 364       |> exclude_relationship_restricted_ap_ids(activity)
 365       |> exclude_thread_muter_ap_ids(activity)
 366
 367     notification_enabled_users =
 368       Enum.filter(potential_receivers, fn u -> u.ap_id in notification_enabled_ap_ids end)
 369
 370     {notification_enabled_users, potential_receivers -- notification_enabled_users}
 371   end
 372
 373   def get_notified_from_activity(_, _local_only), do: {[], []}
 374
 375   @doc "Filters out AP IDs domain-blocking and not following the activity's actor"
 376   def exclude_domain_blocker_ap_ids(ap_ids, activity, preloaded_users \\ [])
 377
 378   def exclude_domain_blocker_ap_ids([], _activity, _preloaded_users), do: []
 379
 380   def exclude_domain_blocker_ap_ids(ap_ids, %Activity{} = activity, preloaded_users) do
 381     activity_actor_domain = activity.actor && URI.parse(activity.actor).host
 382
 383     users =
 384       ap_ids
 385       |> Enum.map(fn ap_id ->
 386         Enum.find(preloaded_users, &(&1.ap_id == ap_id)) ||
 387           User.get_cached_by_ap_id(ap_id)
 388       end)
 389       |> Enum.filter(& &1)
 390
 391     domain_blocker_ap_ids = for u <- users, activity_actor_domain in u.domain_blocks, do: u.ap_id
 392
 393     domain_blocker_follower_ap_ids =
 394       if Enum.any?(domain_blocker_ap_ids) do
 395         activity
 396         |> Activity.user_actor()
 397         |> FollowingRelationship.followers_ap_ids(domain_blocker_ap_ids)
 398       else
 399         []
 400       end
 401
 402     ap_ids
 403     |> Kernel.--(domain_blocker_ap_ids)
 404     |> Kernel.++(domain_blocker_follower_ap_ids)
 405   end
 406
 407   @doc "Filters out AP IDs of users basing on their relationships with activity actor user"
 408   def exclude_relationship_restricted_ap_ids([], _activity), do: []
 409
 410   def exclude_relationship_restricted_ap_ids(ap_ids, %Activity{} = activity) do
 411     relationship_restricted_ap_ids =
 412       activity
 413       |> Activity.user_actor()
 414       |> User.incoming_relationships_ungrouped_ap_ids([
 415         :block,
 416         :notification_mute
 417       ])
 418
 419     Enum.uniq(ap_ids) -- relationship_restricted_ap_ids
 420   end
 421
 422   @doc "Filters out AP IDs of users who mute activity thread"
 423   def exclude_thread_muter_ap_ids([], _activity), do: []
 424
 425   def exclude_thread_muter_ap_ids(ap_ids, %Activity{} = activity) do
 426     thread_muter_ap_ids = ThreadMute.muter_ap_ids(activity.data["context"])
 427
 428     Enum.uniq(ap_ids) -- thread_muter_ap_ids
 429   end
 430
 431   @spec skip?(Activity.t(), User.t()) :: boolean()
 432   def skip?(%Activity{} = activity, %User{} = user) do
 433     [
 434       :self,
 435       :followers,
 436       :follows,
 437       :non_followers,
 438       :non_follows,
 439       :recently_followed
 440     ]
 441     |> Enum.find(&skip?(&1, activity, user))
 442   end
 443
 444   def skip?(_, _), do: false
 445
 446   @spec skip?(atom(), Activity.t(), User.t()) :: boolean()
 447   def skip?(:self, %Activity{} = activity, %User{} = user) do
 448     activity.data["actor"] == user.ap_id
 449   end
 450
 451   def skip?(
 452         :followers,
 453         %Activity{} = activity,
 454         %User{notification_settings: %{followers: false}} = user
 455       ) do
 456     actor = activity.data["actor"]
 457     follower = User.get_cached_by_ap_id(actor)
 458     User.following?(follower, user)
 459   end
 460
 461   def skip?(
 462         :non_followers,
 463         %Activity{} = activity,
 464         %User{notification_settings: %{non_followers: false}} = user
 465       ) do
 466     actor = activity.data["actor"]
 467     follower = User.get_cached_by_ap_id(actor)
 468     !User.following?(follower, user)
 469   end
 470
 471   def skip?(
 472         :follows,
 473         %Activity{} = activity,
 474         %User{notification_settings: %{follows: false}} = user
 475       ) do
 476     actor = activity.data["actor"]
 477     followed = User.get_cached_by_ap_id(actor)
 478     User.following?(user, followed)
 479   end
 480
 481   def skip?(
 482         :non_follows,
 483         %Activity{} = activity,
 484         %User{notification_settings: %{non_follows: false}} = user
 485       ) do
 486     actor = activity.data["actor"]
 487     followed = User.get_cached_by_ap_id(actor)
 488     !User.following?(user, followed)
 489   end
 490
 491   # To do: consider defining recency in hours and checking FollowingRelationship with a single SQL
 492   def skip?(:recently_followed, %Activity{data: %{"type" => "Follow"}} = activity, %User{} = user) do
 493     actor = activity.data["actor"]
 494
 495     Notification.for_user(user)
 496     |> Enum.any?(fn
 497       %{activity: %{data: %{"type" => "Follow", "actor" => ^actor}}} -> true
 498       _ -> false
 499     end)
 500   end
 501
 502   def skip?(_, _, _), do: false
 503 end