Merge branch 'hide-follower-following-count' into 'develop'
[akkoma] / lib / pleroma / web / activity_pub / views / user_view.ex
1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
4
5 defmodule Pleroma.Web.ActivityPub.UserView do
6 use Pleroma.Web, :view
7
8 alias Pleroma.Keys
9 alias Pleroma.Repo
10 alias Pleroma.User
11 alias Pleroma.Web.ActivityPub.ActivityPub
12 alias Pleroma.Web.ActivityPub.Transmogrifier
13 alias Pleroma.Web.ActivityPub.Utils
14 alias Pleroma.Web.Endpoint
15 alias Pleroma.Web.Router.Helpers
16
17 import Ecto.Query
18
19 def render("endpoints.json", %{user: %User{nickname: nil, local: true} = _user}) do
20 %{"sharedInbox" => Helpers.activity_pub_url(Endpoint, :inbox)}
21 end
22
23 def render("endpoints.json", %{user: %User{local: true} = _user}) do
24 %{
25 "oauthAuthorizationEndpoint" => Helpers.o_auth_url(Endpoint, :authorize),
26 "oauthRegistrationEndpoint" => Helpers.mastodon_api_url(Endpoint, :create_app),
27 "oauthTokenEndpoint" => Helpers.o_auth_url(Endpoint, :token_exchange),
28 "sharedInbox" => Helpers.activity_pub_url(Endpoint, :inbox)
29 }
30 end
31
32 def render("endpoints.json", _), do: %{}
33
34 def render("service.json", %{user: user}) do
35 {:ok, user} = User.ensure_keys_present(user)
36 {:ok, _, public_key} = Keys.keys_from_pem(user.info.keys)
37 public_key = :public_key.pem_entry_encode(:SubjectPublicKeyInfo, public_key)
38 public_key = :public_key.pem_encode([public_key])
39
40 endpoints = render("endpoints.json", %{user: user})
41
42 %{
43 "id" => user.ap_id,
44 "type" => "Application",
45 "following" => "#{user.ap_id}/following",
46 "followers" => "#{user.ap_id}/followers",
47 "inbox" => "#{user.ap_id}/inbox",
48 "name" => "Pleroma",
49 "summary" =>
50 "An internal service actor for this Pleroma instance. No user-serviceable parts inside.",
51 "url" => user.ap_id,
52 "manuallyApprovesFollowers" => false,
53 "publicKey" => %{
54 "id" => "#{user.ap_id}#main-key",
55 "owner" => user.ap_id,
56 "publicKeyPem" => public_key
57 },
58 "endpoints" => endpoints
59 }
60 |> Map.merge(Utils.make_json_ld_header())
61 end
62
63 # the instance itself is not a Person, but instead an Application
64 def render("user.json", %{user: %User{nickname: nil} = user}),
65 do: render("service.json", %{user: user})
66
67 def render("user.json", %{user: %User{nickname: "internal." <> _} = user}),
68 do: render("service.json", %{user: user}) |> Map.put("preferredUsername", user.nickname)
69
70 def render("user.json", %{user: user}) do
71 {:ok, user} = User.ensure_keys_present(user)
72 {:ok, _, public_key} = Keys.keys_from_pem(user.info.keys)
73 public_key = :public_key.pem_entry_encode(:SubjectPublicKeyInfo, public_key)
74 public_key = :public_key.pem_encode([public_key])
75
76 endpoints = render("endpoints.json", %{user: user})
77
78 user_tags =
79 user
80 |> Transmogrifier.add_emoji_tags()
81 |> Map.get("tag", [])
82
83 fields =
84 user.info
85 |> User.Info.fields()
86 |> Enum.map(fn %{"name" => name, "value" => value} ->
87 %{
88 "name" => Pleroma.HTML.strip_tags(name),
89 "value" => Pleroma.HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
90 }
91 end)
92 |> Enum.map(&Map.put(&1, "type", "PropertyValue"))
93
94 %{
95 "id" => user.ap_id,
96 "type" => "Person",
97 "following" => "#{user.ap_id}/following",
98 "followers" => "#{user.ap_id}/followers",
99 "inbox" => "#{user.ap_id}/inbox",
100 "outbox" => "#{user.ap_id}/outbox",
101 "preferredUsername" => user.nickname,
102 "name" => user.name,
103 "summary" => user.bio,
104 "url" => user.ap_id,
105 "manuallyApprovesFollowers" => user.info.locked,
106 "publicKey" => %{
107 "id" => "#{user.ap_id}#main-key",
108 "owner" => user.ap_id,
109 "publicKeyPem" => public_key
110 },
111 "endpoints" => endpoints,
112 "attachment" => fields,
113 "tag" => (user.info.source_data["tag"] || []) ++ user_tags
114 }
115 |> Map.merge(maybe_make_image(&User.avatar_url/2, "icon", user))
116 |> Map.merge(maybe_make_image(&User.banner_url/2, "image", user))
117 |> Map.merge(Utils.make_json_ld_header())
118 end
119
120 def render("following.json", %{user: user, page: page} = opts) do
121 showing_items = (opts[:for] && opts[:for] == user) || !user.info.hide_follows
122 showing_count = showing_items || !user.info.hide_follows_count
123
124 query = User.get_friends_query(user)
125 query = from(user in query, select: [:ap_id])
126 following = Repo.all(query)
127
128 total =
129 if showing_count do
130 length(following)
131 else
132 0
133 end
134
135 collection(following, "#{user.ap_id}/following", page, showing_items, total)
136 |> Map.merge(Utils.make_json_ld_header())
137 end
138
139 def render("following.json", %{user: user} = opts) do
140 showing_items = (opts[:for] && opts[:for] == user) || !user.info.hide_follows
141 showing_count = showing_items || !user.info.hide_follows_count
142
143 query = User.get_friends_query(user)
144 query = from(user in query, select: [:ap_id])
145 following = Repo.all(query)
146
147 total =
148 if showing_count do
149 length(following)
150 else
151 0
152 end
153
154 %{
155 "id" => "#{user.ap_id}/following",
156 "type" => "OrderedCollection",
157 "totalItems" => total,
158 "first" =>
159 if showing_items do
160 collection(following, "#{user.ap_id}/following", 1, !user.info.hide_follows)
161 else
162 "#{user.ap_id}/following?page=1"
163 end
164 }
165 |> Map.merge(Utils.make_json_ld_header())
166 end
167
168 def render("followers.json", %{user: user, page: page} = opts) do
169 showing_items = (opts[:for] && opts[:for] == user) || !user.info.hide_followers
170 showing_count = showing_items || !user.info.hide_followers_count
171
172 query = User.get_followers_query(user)
173 query = from(user in query, select: [:ap_id])
174 followers = Repo.all(query)
175
176 total =
177 if showing_count do
178 length(followers)
179 else
180 0
181 end
182
183 collection(followers, "#{user.ap_id}/followers", page, showing_items, total)
184 |> Map.merge(Utils.make_json_ld_header())
185 end
186
187 def render("followers.json", %{user: user} = opts) do
188 showing_items = (opts[:for] && opts[:for] == user) || !user.info.hide_followers
189 showing_count = showing_items || !user.info.hide_followers_count
190
191 query = User.get_followers_query(user)
192 query = from(user in query, select: [:ap_id])
193 followers = Repo.all(query)
194
195 total =
196 if showing_count do
197 length(followers)
198 else
199 0
200 end
201
202 %{
203 "id" => "#{user.ap_id}/followers",
204 "type" => "OrderedCollection",
205 "totalItems" => total,
206 "first" =>
207 if showing_items do
208 collection(followers, "#{user.ap_id}/followers", 1, showing_items, total)
209 else
210 "#{user.ap_id}/followers?page=1"
211 end
212 }
213 |> Map.merge(Utils.make_json_ld_header())
214 end
215
216 def render("outbox.json", %{user: user, max_id: max_qid}) do
217 params = %{
218 "limit" => "10"
219 }
220
221 params =
222 if max_qid != nil do
223 Map.put(params, "max_id", max_qid)
224 else
225 params
226 end
227
228 activities = ActivityPub.fetch_user_activities(user, nil, params)
229
230 {max_id, min_id, collection} =
231 if length(activities) > 0 do
232 {
233 Enum.at(Enum.reverse(activities), 0).id,
234 Enum.at(activities, 0).id,
235 Enum.map(activities, fn act ->
236 {:ok, data} = Transmogrifier.prepare_outgoing(act.data)
237 data
238 end)
239 }
240 else
241 {
242 0,
243 0,
244 []
245 }
246 end
247
248 iri = "#{user.ap_id}/outbox"
249
250 page = %{
251 "id" => "#{iri}?max_id=#{max_id}",
252 "type" => "OrderedCollectionPage",
253 "partOf" => iri,
254 "orderedItems" => collection,
255 "next" => "#{iri}?max_id=#{min_id}"
256 }
257
258 if max_qid == nil do
259 %{
260 "id" => iri,
261 "type" => "OrderedCollection",
262 "first" => page
263 }
264 |> Map.merge(Utils.make_json_ld_header())
265 else
266 page |> Map.merge(Utils.make_json_ld_header())
267 end
268 end
269
270 def render("inbox.json", %{user: user, max_id: max_qid}) do
271 params = %{
272 "limit" => "10"
273 }
274
275 params =
276 if max_qid != nil do
277 Map.put(params, "max_id", max_qid)
278 else
279 params
280 end
281
282 activities = ActivityPub.fetch_activities([user.ap_id | user.following], params)
283
284 min_id = Enum.at(Enum.reverse(activities), 0).id
285 max_id = Enum.at(activities, 0).id
286
287 collection =
288 Enum.map(activities, fn act ->
289 {:ok, data} = Transmogrifier.prepare_outgoing(act.data)
290 data
291 end)
292
293 iri = "#{user.ap_id}/inbox"
294
295 page = %{
296 "id" => "#{iri}?max_id=#{max_id}",
297 "type" => "OrderedCollectionPage",
298 "partOf" => iri,
299 "orderedItems" => collection,
300 "next" => "#{iri}?max_id=#{min_id}"
301 }
302
303 if max_qid == nil do
304 %{
305 "id" => iri,
306 "type" => "OrderedCollection",
307 "first" => page
308 }
309 |> Map.merge(Utils.make_json_ld_header())
310 else
311 page |> Map.merge(Utils.make_json_ld_header())
312 end
313 end
314
315 def collection(collection, iri, page, show_items \\ true, total \\ nil) do
316 offset = (page - 1) * 10
317 items = Enum.slice(collection, offset, 10)
318 items = Enum.map(items, fn user -> user.ap_id end)
319 total = total || length(collection)
320
321 map = %{
322 "id" => "#{iri}?page=#{page}",
323 "type" => "OrderedCollectionPage",
324 "partOf" => iri,
325 "totalItems" => total,
326 "orderedItems" => if(show_items, do: items, else: [])
327 }
328
329 if offset < total do
330 Map.put(map, "next", "#{iri}?page=#{page + 1}")
331 else
332 map
333 end
334 end
335
336 defp maybe_make_image(func, key, user) do
337 if image = func.(user, no_default: true) do
338 %{
339 key => %{
340 "type" => "Image",
341 "url" => image
342 }
343 }
344 else
345 %{}
346 end
347 end
348 end