Git of dcc - anni/blob - lib/pleroma/user_relationship.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.UserRelationship do
   6   use Ecto.Schema
   7
   8   import Ecto.Changeset
   9   import Ecto.Query
  10
  11   alias Ecto.Changeset
  12   alias Pleroma.FollowingRelationship
  13   alias Pleroma.Repo
  14   alias Pleroma.User
  15   alias Pleroma.UserRelationship
  16
  17   @type t :: %__MODULE__{}
  18
  19   schema "user_relationships" do
  20     belongs_to(:source, User, type: FlakeId.Ecto.CompatType)
  21     belongs_to(:target, User, type: FlakeId.Ecto.CompatType)
  22     field(:relationship_type, Pleroma.UserRelationship.Type)
  23     field(:expires_at, :utc_datetime)
  24
  25     timestamps(updated_at: false)
  26   end
  27
  28   for relationship_type <- Keyword.keys(Pleroma.UserRelationship.Type.__enum_map__()) do
  29     # `def create_block/3`, `def create_mute/3`, `def create_reblog_mute/3`,
  30     #   `def create_notification_mute/3`, `def create_inverse_subscription/3`,
  31     #   `def endorsement/3`
  32     def unquote(:"create_#{relationship_type}")(source, target, expires_at \\ nil),
  33       do: create(unquote(relationship_type), source, target, expires_at)
  34
  35     # `def delete_block/2`, `def delete_mute/2`, `def delete_reblog_mute/2`,
  36     #   `def delete_notification_mute/2`, `def delete_inverse_subscription/2`,
  37     #   `def delete_endorsement/2`
  38     def unquote(:"delete_#{relationship_type}")(source, target),
  39       do: delete(unquote(relationship_type), source, target)
  40
  41     # `def block_exists?/2`, `def mute_exists?/2`, `def reblog_mute_exists?/2`,
  42     #   `def notification_mute_exists?/2`, `def inverse_subscription_exists?/2`,
  43     #   `def inverse_endorsement_exists?/2`
  44     def unquote(:"#{relationship_type}_exists?")(source, target),
  45       do: exists?(unquote(relationship_type), source, target)
  46
  47     # `def get_block_expire_date/2`, `def get_mute_expire_date/2`,
  48     #   `def get_reblog_mute_expire_date/2`, `def get_notification_mute_exists?/2`,
  49     #   `def get_inverse_subscription_expire_date/2`, `def get_inverse_endorsement_expire_date/2`
  50     def unquote(:"get_#{relationship_type}_expire_date")(source, target),
  51       do: get_expire_date(unquote(relationship_type), source, target)
  52   end
  53
  54   def user_relationship_types, do: Keyword.keys(user_relationship_mappings())
  55
  56   def user_relationship_mappings, do: Pleroma.UserRelationship.Type.__enum_map__()
  57
  58   def changeset(%UserRelationship{} = user_relationship, params \\ %{}) do
  59     user_relationship
  60     |> cast(params, [:relationship_type, :source_id, :target_id, :expires_at])
  61     |> validate_required([:relationship_type, :source_id, :target_id])
  62     |> unique_constraint(:relationship_type,
  63       name: :user_relationships_source_id_relationship_type_target_id_index
  64     )
  65     |> validate_not_self_relationship()
  66   end
  67
  68   def exists?(relationship_type, %User{} = source, %User{} = target) do
  69     UserRelationship
  70     |> where(relationship_type: ^relationship_type, source_id: ^source.id, target_id: ^target.id)
  71     |> Repo.exists?()
  72   end
  73
  74   def get_expire_date(relationship_type, %User{} = source, %User{} = target) do
  75     %UserRelationship{expires_at: expires_at} =
  76       UserRelationship
  77       |> where(
  78         relationship_type: ^relationship_type,
  79         source_id: ^source.id,
  80         target_id: ^target.id
  81       )
  82       |> Repo.one!()
  83
  84     expires_at
  85   end
  86
  87   def create(relationship_type, %User{} = source, %User{} = target, expires_at \\ nil) do
  88     %UserRelationship{}
  89     |> changeset(%{
  90       relationship_type: relationship_type,
  91       source_id: source.id,
  92       target_id: target.id,
  93       expires_at: expires_at
  94     })
  95     |> Repo.insert(
  96       on_conflict: {:replace_all_except, [:id, :inserted_at]},
  97       conflict_target: [:source_id, :relationship_type, :target_id],
  98       returning: true
  99     )
 100   end
 101
 102   def delete(relationship_type, %User{} = source, %User{} = target) do
 103     attrs = %{relationship_type: relationship_type, source_id: source.id, target_id: target.id}
 104
 105     case Repo.get_by(UserRelationship, attrs) do
 106       %UserRelationship{} = existing_record -> Repo.delete(existing_record)
 107       nil -> {:ok, nil}
 108     end
 109   end
 110
 111   def dictionary(
 112         source_users,
 113         target_users,
 114         source_to_target_rel_types \\ nil,
 115         target_to_source_rel_types \\ nil
 116       )
 117
 118   def dictionary(
 119         _source_users,
 120         _target_users,
 121         [] = _source_to_target_rel_types,
 122         [] = _target_to_source_rel_types
 123       ) do
 124     []
 125   end
 126
 127   def dictionary(
 128         source_users,
 129         target_users,
 130         source_to_target_rel_types,
 131         target_to_source_rel_types
 132       )
 133       when is_list(source_users) and is_list(target_users) do
 134     source_user_ids = User.binary_id(source_users)
 135     target_user_ids = User.binary_id(target_users)
 136
 137     get_rel_type_codes = fn rel_type -> user_relationship_mappings()[rel_type] end
 138
 139     source_to_target_rel_types =
 140       Enum.map(source_to_target_rel_types || user_relationship_types(), &get_rel_type_codes.(&1))
 141
 142     target_to_source_rel_types =
 143       Enum.map(target_to_source_rel_types || user_relationship_types(), &get_rel_type_codes.(&1))
 144
 145     __MODULE__
 146     |> where(
 147       fragment(
 148         "(source_id = ANY(?) AND target_id = ANY(?) AND relationship_type = ANY(?)) OR \
 149         (source_id = ANY(?) AND target_id = ANY(?) AND relationship_type = ANY(?))",
 150         ^source_user_ids,
 151         ^target_user_ids,
 152         ^source_to_target_rel_types,
 153         ^target_user_ids,
 154         ^source_user_ids,
 155         ^target_to_source_rel_types
 156       )
 157     )
 158     |> select([ur], [ur.relationship_type, ur.source_id, ur.target_id])
 159     |> Repo.all()
 160   end
 161
 162   def exists?(dictionary, rel_type, source, target, func) do
 163     cond do
 164       is_nil(source) or is_nil(target) ->
 165         false
 166
 167       dictionary ->
 168         [rel_type, source.id, target.id] in dictionary
 169
 170       true ->
 171         func.(source, target)
 172     end
 173   end
 174
 175   @doc ":relationships option for StatusView / AccountView / NotificationView"
 176   def view_relationships_option(reading_user, actors, opts \\ [])
 177
 178   def view_relationships_option(nil = _reading_user, _actors, _opts) do
 179     %{user_relationships: [], following_relationships: []}
 180   end
 181
 182   def view_relationships_option(%User{} = reading_user, actors, opts) do
 183     {source_to_target_rel_types, target_to_source_rel_types} =
 184       case opts[:subset] do
 185         :source_mutes ->
 186           # Used for statuses rendering (FE needs `muted` flag for each status when statuses load)
 187           {[:mute], []}
 188
 189         nil ->
 190           {[:block, :mute, :notification_mute, :reblog_mute], [:block, :inverse_subscription]}
 191
 192         unknown ->
 193           raise "Unsupported :subset option value: #{inspect(unknown)}"
 194       end
 195
 196     user_relationships =
 197       UserRelationship.dictionary(
 198         [reading_user],
 199         actors,
 200         source_to_target_rel_types,
 201         target_to_source_rel_types
 202       )
 203
 204     following_relationships =
 205       case opts[:subset] do
 206         :source_mutes ->
 207           []
 208
 209         nil ->
 210           FollowingRelationship.all_between_user_sets([reading_user], actors)
 211
 212         unknown ->
 213           raise "Unsupported :subset option value: #{inspect(unknown)}"
 214       end
 215
 216     %{user_relationships: user_relationships, following_relationships: following_relationships}
 217   end
 218
 219   defp validate_not_self_relationship(%Changeset{} = changeset) do
 220     changeset
 221     |> validate_source_id_target_id_inequality()
 222     |> validate_target_id_source_id_inequality()
 223   end
 224
 225   defp validate_source_id_target_id_inequality(%Changeset{} = changeset) do
 226     validate_change(changeset, :source_id, fn _, source_id ->
 227       if source_id == get_field(changeset, :target_id) do
 228         [source_id: "can't be equal to target_id"]
 229       else
 230         []
 231       end
 232     end)
 233   end
 234
 235   defp validate_target_id_source_id_inequality(%Changeset{} = changeset) do
 236     validate_change(changeset, :target_id, fn _, target_id ->
 237       if target_id == get_field(changeset, :source_id) do
 238         [target_id: "can't be equal to source_id"]
 239       else
 240         []
 241       end
 242     end)
 243   end
 244 end