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

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