MastodonAPI.StatusView: Do not use site_name
[akkoma] / lib / pleroma / web / mastodon_api / views / status_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.MastodonAPI.StatusView do
6 use Pleroma.Web, :view
7
8 require Pleroma.Constants
9
10 alias Pleroma.Activity
11 alias Pleroma.ActivityExpiration
12 alias Pleroma.HTML
13 alias Pleroma.Object
14 alias Pleroma.Repo
15 alias Pleroma.User
16 alias Pleroma.Web.CommonAPI
17 alias Pleroma.Web.CommonAPI.Utils
18 alias Pleroma.Web.MastodonAPI.AccountView
19 alias Pleroma.Web.MastodonAPI.PollView
20 alias Pleroma.Web.MastodonAPI.StatusView
21 alias Pleroma.Web.MediaProxy
22
23 import Pleroma.Web.ActivityPub.Visibility, only: [get_visibility: 1]
24
25 # TODO: Add cached version.
26 defp get_replied_to_activities([]), do: %{}
27
28 defp get_replied_to_activities(activities) do
29 activities
30 |> Enum.map(fn
31 %{data: %{"type" => "Create"}} = activity ->
32 object = Object.normalize(activity)
33 object && object.data["inReplyTo"] != "" && object.data["inReplyTo"]
34
35 _ ->
36 nil
37 end)
38 |> Enum.filter(& &1)
39 |> Activity.create_by_object_ap_id_with_object()
40 |> Repo.all()
41 |> Enum.reduce(%{}, fn activity, acc ->
42 object = Object.normalize(activity)
43 if object, do: Map.put(acc, object.data["id"], activity), else: acc
44 end)
45 end
46
47 defp get_user(ap_id) do
48 cond do
49 user = User.get_cached_by_ap_id(ap_id) ->
50 user
51
52 user = User.get_by_guessed_nickname(ap_id) ->
53 user
54
55 true ->
56 User.error_user(ap_id)
57 end
58 end
59
60 defp get_context_id(%{data: %{"context_id" => context_id}}) when not is_nil(context_id),
61 do: context_id
62
63 defp get_context_id(%{data: %{"context" => context}}) when is_binary(context),
64 do: Utils.context_to_conversation_id(context)
65
66 defp get_context_id(_), do: nil
67
68 defp reblogged?(activity, user) do
69 object = Object.normalize(activity) || %{}
70 present?(user && user.ap_id in (object.data["announcements"] || []))
71 end
72
73 def render("index.json", opts) do
74 replied_to_activities = get_replied_to_activities(opts.activities)
75 opts = Map.put(opts, :replied_to_activities, replied_to_activities)
76
77 safe_render_many(opts.activities, StatusView, "show.json", opts)
78 end
79
80 def render(
81 "show.json",
82 %{activity: %{data: %{"type" => "Announce", "object" => _object}} = activity} = opts
83 ) do
84 user = get_user(activity.data["actor"])
85 created_at = Utils.to_masto_date(activity.data["published"])
86 activity_object = Object.normalize(activity)
87
88 reblogged_activity =
89 Activity.create_by_object_ap_id(activity_object.data["id"])
90 |> Activity.with_preloaded_bookmark(opts[:for])
91 |> Activity.with_set_thread_muted_field(opts[:for])
92 |> Repo.one()
93
94 reblogged = render("show.json", Map.put(opts, :activity, reblogged_activity))
95
96 favorited = opts[:for] && opts[:for].ap_id in (activity_object.data["likes"] || [])
97
98 bookmarked = Activity.get_bookmark(reblogged_activity, opts[:for]) != nil
99
100 mentions =
101 activity.recipients
102 |> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
103 |> Enum.filter(& &1)
104 |> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)
105
106 %{
107 id: to_string(activity.id),
108 uri: activity_object.data["id"],
109 url: activity_object.data["id"],
110 account: AccountView.render("show.json", %{user: user, for: opts[:for]}),
111 in_reply_to_id: nil,
112 in_reply_to_account_id: nil,
113 reblog: reblogged,
114 content: reblogged[:content] || "",
115 created_at: created_at,
116 reblogs_count: 0,
117 replies_count: 0,
118 favourites_count: 0,
119 reblogged: reblogged?(reblogged_activity, opts[:for]),
120 favourited: present?(favorited),
121 bookmarked: present?(bookmarked),
122 muted: false,
123 pinned: pinned?(activity, user),
124 sensitive: false,
125 spoiler_text: "",
126 visibility: get_visibility(activity),
127 media_attachments: reblogged[:media_attachments] || [],
128 mentions: mentions,
129 tags: reblogged[:tags] || [],
130 application: %{
131 name: "Web",
132 website: nil
133 },
134 language: nil,
135 emojis: [],
136 pleroma: %{
137 local: activity.local
138 }
139 }
140 end
141
142 def render("show.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
143 object = Object.normalize(activity)
144
145 user = get_user(activity.data["actor"])
146 user_follower_address = user.follower_address
147
148 like_count = object.data["like_count"] || 0
149 announcement_count = object.data["announcement_count"] || 0
150
151 tags = object.data["tag"] || []
152 sensitive = object.data["sensitive"] || Enum.member?(tags, "nsfw")
153
154 tag_mentions =
155 tags
156 |> Enum.filter(fn tag -> is_map(tag) and tag["type"] == "Mention" end)
157 |> Enum.map(fn tag -> tag["href"] end)
158
159 mentions =
160 (object.data["to"] ++ tag_mentions)
161 |> Enum.uniq()
162 |> Enum.map(fn
163 Pleroma.Constants.as_public() -> nil
164 ^user_follower_address -> nil
165 ap_id -> User.get_cached_by_ap_id(ap_id)
166 end)
167 |> Enum.filter(& &1)
168 |> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)
169
170 favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] || [])
171
172 bookmarked = Activity.get_bookmark(activity, opts[:for]) != nil
173
174 client_posted_this_activity = opts[:for] && user.id == opts[:for].id
175
176 expires_at =
177 with true <- client_posted_this_activity,
178 expiration when not is_nil(expiration) <-
179 ActivityExpiration.get_by_activity_id(activity.id) do
180 expiration.scheduled_at
181 end
182
183 thread_muted? =
184 case activity.thread_muted? do
185 thread_muted? when is_boolean(thread_muted?) -> thread_muted?
186 nil -> (opts[:for] && CommonAPI.thread_muted?(opts[:for], activity)) || false
187 end
188
189 attachment_data = object.data["attachment"] || []
190 attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)
191
192 created_at = Utils.to_masto_date(object.data["published"])
193
194 reply_to = get_reply_to(activity, opts)
195
196 reply_to_user = reply_to && get_user(reply_to.data["actor"])
197
198 content =
199 object
200 |> render_content()
201
202 content_html =
203 content
204 |> HTML.get_cached_scrubbed_html_for_activity(
205 User.html_filter_policy(opts[:for]),
206 activity,
207 "mastoapi:content"
208 )
209
210 content_plaintext =
211 content
212 |> HTML.get_cached_stripped_html_for_activity(
213 activity,
214 "mastoapi:content"
215 )
216
217 summary = object.data["summary"] || ""
218
219 card = render("card.json", Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity))
220
221 url =
222 if user.local do
223 Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
224 else
225 object.data["url"] || object.data["external_url"] || object.data["id"]
226 end
227
228 direct_conversation_id =
229 with {_, nil} <- {:direct_conversation_id, opts[:direct_conversation_id]},
230 {_, true} <- {:include_id, opts[:with_direct_conversation_id]},
231 {_, %User{} = for_user} <- {:for_user, opts[:for]} do
232 Activity.direct_conversation_id(activity, for_user)
233 else
234 {:direct_conversation_id, participation_id} when is_integer(participation_id) ->
235 participation_id
236
237 _e ->
238 nil
239 end
240
241 emoji_reactions =
242 with %{data: %{"reactions" => emoji_reactions}} <- object do
243 Enum.map(emoji_reactions, fn [emoji, users] ->
244 %{
245 name: emoji,
246 count: length(users),
247 me: !!(opts[:for] && opts[:for].ap_id in users)
248 }
249 end)
250 else
251 _ -> []
252 end
253
254 %{
255 id: to_string(activity.id),
256 uri: object.data["id"],
257 url: url,
258 account: AccountView.render("show.json", %{user: user, for: opts[:for]}),
259 in_reply_to_id: reply_to && to_string(reply_to.id),
260 in_reply_to_account_id: reply_to_user && to_string(reply_to_user.id),
261 reblog: nil,
262 card: card,
263 content: content_html,
264 created_at: created_at,
265 reblogs_count: announcement_count,
266 replies_count: object.data["repliesCount"] || 0,
267 favourites_count: like_count,
268 reblogged: reblogged?(activity, opts[:for]),
269 favourited: present?(favorited),
270 bookmarked: present?(bookmarked),
271 muted: thread_muted? || User.mutes?(opts[:for], user),
272 pinned: pinned?(activity, user),
273 sensitive: sensitive,
274 spoiler_text: summary,
275 visibility: get_visibility(object),
276 media_attachments: attachments,
277 poll: render(PollView, "show.json", object: object, for: opts[:for]),
278 mentions: mentions,
279 tags: build_tags(tags),
280 application: %{
281 name: "Web",
282 website: nil
283 },
284 language: nil,
285 emojis: build_emojis(object.data["emoji"]),
286 pleroma: %{
287 local: activity.local,
288 conversation_id: get_context_id(activity),
289 in_reply_to_account_acct: reply_to_user && reply_to_user.nickname,
290 content: %{"text/plain" => content_plaintext},
291 spoiler_text: %{"text/plain" => summary},
292 expires_at: expires_at,
293 direct_conversation_id: direct_conversation_id,
294 thread_muted: thread_muted?,
295 emoji_reactions: emoji_reactions
296 }
297 }
298 end
299
300 def render("show.json", _) do
301 nil
302 end
303
304 def render("card.json", %{rich_media: rich_media, page_url: page_url}) do
305 page_url_data = URI.parse(page_url)
306
307 page_url_data =
308 if rich_media[:url] != nil do
309 URI.merge(page_url_data, URI.parse(rich_media[:url]))
310 else
311 page_url_data
312 end
313
314 page_url = page_url_data |> to_string
315
316 image_url =
317 if rich_media[:image] != nil do
318 URI.merge(page_url_data, URI.parse(rich_media[:image]))
319 |> to_string
320 else
321 nil
322 end
323
324 %{
325 type: "link",
326 provider_name: page_url_data.host,
327 provider_url: page_url_data.scheme <> "://" <> page_url_data.host,
328 url: page_url,
329 image: image_url |> MediaProxy.url(),
330 title: rich_media[:title] || "",
331 description: rich_media[:description] || "",
332 pleroma: %{
333 opengraph: rich_media
334 }
335 }
336 end
337
338 def render("card.json", _), do: nil
339
340 def render("attachment.json", %{attachment: attachment}) do
341 [attachment_url | _] = attachment["url"]
342 media_type = attachment_url["mediaType"] || attachment_url["mimeType"] || "image"
343 href = attachment_url["href"] |> MediaProxy.url()
344
345 type =
346 cond do
347 String.contains?(media_type, "image") -> "image"
348 String.contains?(media_type, "video") -> "video"
349 String.contains?(media_type, "audio") -> "audio"
350 true -> "unknown"
351 end
352
353 <<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)
354
355 %{
356 id: to_string(attachment["id"] || hash_id),
357 url: href,
358 remote_url: href,
359 preview_url: href,
360 text_url: href,
361 type: type,
362 description: attachment["name"],
363 pleroma: %{mime_type: media_type}
364 }
365 end
366
367 def render("listen.json", %{activity: %Activity{data: %{"type" => "Listen"}} = activity} = opts) do
368 object = Object.normalize(activity)
369
370 user = get_user(activity.data["actor"])
371 created_at = Utils.to_masto_date(activity.data["published"])
372
373 %{
374 id: activity.id,
375 account: AccountView.render("show.json", %{user: user, for: opts[:for]}),
376 created_at: created_at,
377 title: object.data["title"] |> HTML.strip_tags(),
378 artist: object.data["artist"] |> HTML.strip_tags(),
379 album: object.data["album"] |> HTML.strip_tags(),
380 length: object.data["length"]
381 }
382 end
383
384 def render("listens.json", opts) do
385 safe_render_many(opts.activities, StatusView, "listen.json", opts)
386 end
387
388 def render("context.json", %{activity: activity, activities: activities, user: user}) do
389 %{ancestors: ancestors, descendants: descendants} =
390 activities
391 |> Enum.reverse()
392 |> Enum.group_by(fn %{id: id} -> if id < activity.id, do: :ancestors, else: :descendants end)
393 |> Map.put_new(:ancestors, [])
394 |> Map.put_new(:descendants, [])
395
396 %{
397 ancestors: render("index.json", for: user, activities: ancestors, as: :activity),
398 descendants: render("index.json", for: user, activities: descendants, as: :activity)
399 }
400 end
401
402 def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
403 object = Object.normalize(activity)
404
405 with nil <- replied_to_activities[object.data["inReplyTo"]] do
406 # If user didn't participate in the thread
407 Activity.get_in_reply_to_activity(activity)
408 end
409 end
410
411 def get_reply_to(%{data: %{"object" => _object}} = activity, _) do
412 object = Object.normalize(activity)
413
414 if object.data["inReplyTo"] && object.data["inReplyTo"] != "" do
415 Activity.get_create_by_object_ap_id(object.data["inReplyTo"])
416 else
417 nil
418 end
419 end
420
421 def render_content(%{data: %{"type" => object_type}} = object)
422 when object_type in ["Video", "Event"] do
423 with name when not is_nil(name) and name != "" <- object.data["name"] do
424 "<p><a href=\"#{object.data["id"]}\">#{name}</a></p>#{object.data["content"]}"
425 else
426 _ -> object.data["content"] || ""
427 end
428 end
429
430 def render_content(%{data: %{"type" => object_type}} = object)
431 when object_type in ["Article", "Page"] do
432 with summary when not is_nil(summary) and summary != "" <- object.data["name"],
433 url when is_bitstring(url) <- object.data["url"] do
434 "<p><a href=\"#{url}\">#{summary}</a></p>#{object.data["content"]}"
435 else
436 _ -> object.data["content"] || ""
437 end
438 end
439
440 def render_content(object), do: object.data["content"] || ""
441
442 @doc """
443 Builds a dictionary tags.
444
445 ## Examples
446
447 iex> Pleroma.Web.MastodonAPI.StatusView.build_tags(["fediverse", "nextcloud"])
448 [{"name": "fediverse", "url": "/tag/fediverse"},
449 {"name": "nextcloud", "url": "/tag/nextcloud"}]
450
451 """
452 @spec build_tags(list(any())) :: list(map())
453 def build_tags(object_tags) when is_list(object_tags) do
454 object_tags = for tag when is_binary(tag) <- object_tags, do: tag
455
456 Enum.reduce(object_tags, [], fn tag, tags ->
457 tags ++ [%{name: tag, url: "/tag/#{URI.encode(tag)}"}]
458 end)
459 end
460
461 def build_tags(_), do: []
462
463 @doc """
464 Builds list emojis.
465
466 Arguments: `nil` or list tuple of name and url.
467
468 Returns list emojis.
469
470 ## Examples
471
472 iex> Pleroma.Web.MastodonAPI.StatusView.build_emojis([{"2hu", "corndog.png"}])
473 [%{shortcode: "2hu", static_url: "corndog.png", url: "corndog.png", visible_in_picker: false}]
474
475 """
476 @spec build_emojis(nil | list(tuple())) :: list(map())
477 def build_emojis(nil), do: []
478
479 def build_emojis(emojis) do
480 emojis
481 |> Enum.map(fn {name, url} ->
482 name = HTML.strip_tags(name)
483
484 url =
485 url
486 |> HTML.strip_tags()
487 |> MediaProxy.url()
488
489 %{shortcode: name, url: url, static_url: url, visible_in_picker: false}
490 end)
491 end
492
493 defp present?(nil), do: false
494 defp present?(false), do: false
495 defp present?(_), do: true
496
497 defp pinned?(%Activity{id: id}, %User{pinned_activities: pinned_activities}),
498 do: id in pinned_activities
499 end