Merge branch 'replies-count' into 'develop'
[akkoma] / 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]},
71 conflict_target: [:source_id, :relationship_type, :target_id]
72 )
73 end
74
75 def delete(relationship_type, %User{} = source, %User{} = target) do
76 attrs = %{relationship_type: relationship_type, source_id: source.id, target_id: target.id}
77
78 case Repo.get_by(UserRelationship, attrs) do
79 %UserRelationship{} = existing_record -> Repo.delete(existing_record)
80 nil -> {:ok, nil}
81 end
82 end
83
84 def dictionary(
85 source_users,
86 target_users,
87 source_to_target_rel_types \\ nil,
88 target_to_source_rel_types \\ nil
89 )
90
91 def dictionary(
92 _source_users,
93 _target_users,
94 [] = _source_to_target_rel_types,
95 [] = _target_to_source_rel_types
96 ) do
97 []
98 end
99
100 def dictionary(
101 source_users,
102 target_users,
103 source_to_target_rel_types,
104 target_to_source_rel_types
105 )
106 when is_list(source_users) and is_list(target_users) do
107 source_user_ids = User.binary_id(source_users)
108 target_user_ids = User.binary_id(target_users)
109
110 get_rel_type_codes = fn rel_type -> user_relationship_mappings()[rel_type] end
111
112 source_to_target_rel_types =
113 Enum.map(source_to_target_rel_types || user_relationship_types(), &get_rel_type_codes.(&1))
114
115 target_to_source_rel_types =
116 Enum.map(target_to_source_rel_types || user_relationship_types(), &get_rel_type_codes.(&1))
117
118 __MODULE__
119 |> where(
120 fragment(
121 "(source_id = ANY(?) AND target_id = ANY(?) AND relationship_type = ANY(?)) OR \
122 (source_id = ANY(?) AND target_id = ANY(?) AND relationship_type = ANY(?))",
123 ^source_user_ids,
124 ^target_user_ids,
125 ^source_to_target_rel_types,
126 ^target_user_ids,
127 ^source_user_ids,
128 ^target_to_source_rel_types
129 )
130 )
131 |> select([ur], [ur.relationship_type, ur.source_id, ur.target_id])
132 |> Repo.all()
133 end
134
135 def exists?(dictionary, rel_type, source, target, func) do
136 cond do
137 is_nil(source) or is_nil(target) ->
138 false
139
140 dictionary ->
141 [rel_type, source.id, target.id] in dictionary
142
143 true ->
144 func.(source, target)
145 end
146 end
147
148 @doc ":relationships option for StatusView / AccountView / NotificationView"
149 def view_relationships_option(reading_user, actors, opts \\ [])
150
151 def view_relationships_option(nil = _reading_user, _actors, _opts) do
152 %{user_relationships: [], following_relationships: []}
153 end
154
155 def view_relationships_option(%User{} = reading_user, actors, opts) do
156 {source_to_target_rel_types, target_to_source_rel_types} =
157 case opts[:subset] do
158 :source_mutes ->
159 # Used for statuses rendering (FE needs `muted` flag for each status when statuses load)
160 {[:mute], []}
161
162 nil ->
163 {[:block, :mute, :notification_mute, :reblog_mute], [:block, :inverse_subscription]}
164
165 unknown ->
166 raise "Unsupported :subset option value: #{inspect(unknown)}"
167 end
168
169 user_relationships =
170 UserRelationship.dictionary(
171 [reading_user],
172 actors,
173 source_to_target_rel_types,
174 target_to_source_rel_types
175 )
176
177 following_relationships =
178 case opts[:subset] do
179 :source_mutes ->
180 []
181
182 nil ->
183 FollowingRelationship.all_between_user_sets([reading_user], actors)
184
185 unknown ->
186 raise "Unsupported :subset option value: #{inspect(unknown)}"
187 end
188
189 %{user_relationships: user_relationships, following_relationships: following_relationships}
190 end
191
192 defp validate_not_self_relationship(%Changeset{} = changeset) do
193 changeset
194 |> validate_source_id_target_id_inequality()
195 |> validate_target_id_source_id_inequality()
196 end
197
198 defp validate_source_id_target_id_inequality(%Changeset{} = changeset) do
199 validate_change(changeset, :source_id, fn _, source_id ->
200 if source_id == get_field(changeset, :target_id) do
201 [source_id: "can't be equal to target_id"]
202 else
203 []
204 end
205 end)
206 end
207
208 defp validate_target_id_source_id_inequality(%Changeset{} = changeset) do
209 validate_change(changeset, :target_id, fn _, target_id ->
210 if target_id == get_field(changeset, :source_id) do
211 [target_id: "can't be equal to source_id"]
212 else
213 []
214 end
215 end)
216 end
217 end