Merge branch 'chore/remove-reference-to-distsn' into 'develop'
[akkoma] / lib / pleroma / following_relationship.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.FollowingRelationship do
6 use Ecto.Schema
7
8 import Ecto.Changeset
9 import Ecto.Query
10
11 alias Ecto.Changeset
12 alias FlakeId.Ecto.CompatType
13 alias Pleroma.FollowingRelationship.State
14 alias Pleroma.Repo
15 alias Pleroma.User
16
17 schema "following_relationships" do
18 field(:state, State, default: :follow_pending)
19
20 belongs_to(:follower, User, type: CompatType)
21 belongs_to(:following, User, type: CompatType)
22
23 timestamps()
24 end
25
26 @doc "Returns underlying integer code for state atom"
27 def state_int_code(state_atom), do: State.__enum_map__() |> Keyword.fetch!(state_atom)
28
29 def accept_state_code, do: state_int_code(:follow_accept)
30
31 def changeset(%__MODULE__{} = following_relationship, attrs) do
32 following_relationship
33 |> cast(attrs, [:state])
34 |> put_assoc(:follower, attrs.follower)
35 |> put_assoc(:following, attrs.following)
36 |> validate_required([:state, :follower, :following])
37 |> unique_constraint(:follower_id,
38 name: :following_relationships_follower_id_following_id_index
39 )
40 |> validate_not_self_relationship()
41 end
42
43 def state_to_enum(state) when state in ["pending", "accept", "reject"] do
44 String.to_existing_atom("follow_#{state}")
45 end
46
47 def state_to_enum(state) do
48 raise "State is not convertible to Pleroma.FollowingRelationship.State: #{state}"
49 end
50
51 def get(%User{} = follower, %User{} = following) do
52 __MODULE__
53 |> where(follower_id: ^follower.id, following_id: ^following.id)
54 |> Repo.one()
55 end
56
57 def update(follower, following, :follow_reject), do: unfollow(follower, following)
58
59 def update(%User{} = follower, %User{} = following, state) do
60 case get(follower, following) do
61 nil ->
62 follow(follower, following, state)
63
64 following_relationship ->
65 following_relationship
66 |> cast(%{state: state}, [:state])
67 |> validate_required([:state])
68 |> Repo.update()
69 end
70 end
71
72 def follow(%User{} = follower, %User{} = following, state \\ :follow_accept) do
73 %__MODULE__{}
74 |> changeset(%{follower: follower, following: following, state: state})
75 |> Repo.insert(on_conflict: :nothing)
76 end
77
78 def unfollow(%User{} = follower, %User{} = following) do
79 case get(follower, following) do
80 %__MODULE__{} = following_relationship -> Repo.delete(following_relationship)
81 _ -> {:ok, nil}
82 end
83 end
84
85 def follower_count(%User{} = user) do
86 %{followers: user, deactivated: false}
87 |> User.Query.build()
88 |> Repo.aggregate(:count, :id)
89 end
90
91 def followers_query(%User{} = user) do
92 __MODULE__
93 |> join(:inner, [r], u in User, on: r.follower_id == u.id)
94 |> where([r], r.following_id == ^user.id)
95 |> where([r], r.state == ^:follow_accept)
96 end
97
98 def followers_ap_ids(%User{} = user, from_ap_ids \\ nil) do
99 query =
100 user
101 |> followers_query()
102 |> select([r, u], u.ap_id)
103
104 query =
105 if from_ap_ids do
106 where(query, [r, u], u.ap_id in ^from_ap_ids)
107 else
108 query
109 end
110
111 Repo.all(query)
112 end
113
114 def following_count(%User{id: nil}), do: 0
115
116 def following_count(%User{} = user) do
117 %{friends: user, deactivated: false}
118 |> User.Query.build()
119 |> Repo.aggregate(:count, :id)
120 end
121
122 def get_follow_requests(%User{id: id}) do
123 __MODULE__
124 |> join(:inner, [r], f in assoc(r, :follower))
125 |> where([r], r.state == ^:follow_pending)
126 |> where([r], r.following_id == ^id)
127 |> where([r, f], f.deactivated != true)
128 |> select([r, f], f)
129 |> Repo.all()
130 end
131
132 def following?(%User{id: follower_id}, %User{id: followed_id}) do
133 __MODULE__
134 |> where(follower_id: ^follower_id, following_id: ^followed_id, state: ^:follow_accept)
135 |> Repo.exists?()
136 end
137
138 def following_query(%User{} = user) do
139 __MODULE__
140 |> join(:inner, [r], u in User, on: r.following_id == u.id)
141 |> where([r], r.follower_id == ^user.id)
142 |> where([r], r.state == ^:follow_accept)
143 end
144
145 def outgoing_pending_follow_requests_query(%User{} = follower) do
146 __MODULE__
147 |> where([r], r.follower_id == ^follower.id)
148 |> where([r], r.state == ^:follow_pending)
149 end
150
151 def following(%User{} = user) do
152 following =
153 following_query(user)
154 |> select([r, u], u.follower_address)
155 |> Repo.all()
156
157 if not user.local or user.invisible do
158 following
159 else
160 [user.follower_address | following]
161 end
162 end
163
164 def move_following(origin, target) do
165 __MODULE__
166 |> join(:inner, [r], f in assoc(r, :follower))
167 |> where(following_id: ^origin.id)
168 |> where([r, f], f.allow_following_move == true)
169 |> limit(50)
170 |> preload([:follower])
171 |> Repo.all()
172 |> Enum.map(fn following_relationship ->
173 Repo.delete(following_relationship)
174 Pleroma.Web.CommonAPI.follow(following_relationship.follower, target)
175 end)
176 |> case do
177 [] ->
178 User.update_follower_count(origin)
179 :ok
180
181 _ ->
182 move_following(origin, target)
183 end
184 end
185
186 def all_between_user_sets(
187 source_users,
188 target_users
189 )
190 when is_list(source_users) and is_list(target_users) do
191 source_user_ids = User.binary_id(source_users)
192 target_user_ids = User.binary_id(target_users)
193
194 __MODULE__
195 |> where(
196 fragment(
197 "(follower_id = ANY(?) AND following_id = ANY(?)) OR \
198 (follower_id = ANY(?) AND following_id = ANY(?))",
199 ^source_user_ids,
200 ^target_user_ids,
201 ^target_user_ids,
202 ^source_user_ids
203 )
204 )
205 |> Repo.all()
206 end
207
208 def find(following_relationships, follower, following) do
209 Enum.find(following_relationships, fn
210 fr -> fr.follower_id == follower.id and fr.following_id == following.id
211 end)
212 end
213
214 @doc """
215 For a query with joined activity,
216 keeps rows where activity's actor is followed by user -or- is NOT domain-blocked by user.
217 """
218 def keep_following_or_not_domain_blocked(query, user) do
219 where(
220 query,
221 [_, activity],
222 fragment(
223 # "(actor's domain NOT in domain_blocks) OR (actor IS in followed AP IDs)"
224 """
225 NOT (substring(? from '.*://([^/]*)') = ANY(?)) OR
226 ? = ANY(SELECT ap_id FROM users AS u INNER JOIN following_relationships AS fr
227 ON u.id = fr.following_id WHERE fr.follower_id = ? AND fr.state = ?)
228 """,
229 activity.actor,
230 ^user.domain_blocks,
231 activity.actor,
232 ^User.binary_id(user.id),
233 ^accept_state_code()
234 )
235 )
236 end
237
238 defp validate_not_self_relationship(%Changeset{} = changeset) do
239 changeset
240 |> validate_follower_id_following_id_inequality()
241 |> validate_following_id_follower_id_inequality()
242 end
243
244 defp validate_follower_id_following_id_inequality(%Changeset{} = changeset) do
245 validate_change(changeset, :follower_id, fn _, follower_id ->
246 if follower_id == get_field(changeset, :following_id) do
247 [source_id: "can't be equal to following_id"]
248 else
249 []
250 end
251 end)
252 end
253
254 defp validate_following_id_follower_id_inequality(%Changeset{} = changeset) do
255 validate_change(changeset, :following_id, fn _, following_id ->
256 if following_id == get_field(changeset, :follower_id) do
257 [target_id: "can't be equal to follower_id"]
258 else
259 []
260 end
261 end)
262 end
263 end