1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.MastodonAPI.StatusView do
8 require Pleroma.Constants
10 alias Pleroma.Activity
16 alias Pleroma.UserRelationship
17 alias Pleroma.Web.CommonAPI
18 alias Pleroma.Web.CommonAPI.Utils
19 alias Pleroma.Web.MastodonAPI.AccountView
20 alias Pleroma.Web.MastodonAPI.PollView
21 alias Pleroma.Web.MastodonAPI.StatusView
22 alias Pleroma.Web.MediaProxy
23 alias Pleroma.Web.PleromaAPI.EmojiReactionController
25 import Pleroma.Web.ActivityPub.Visibility, only: [get_visibility: 1, visible_for_user?: 2]
27 # This is a naive way to do this, just spawning a process per activity
28 # to fetch the preview. However it should be fine considering
29 # pagination is restricted to 40 activities at a time
30 defp fetch_rich_media_for_activities(activities) do
31 Enum.each(activities, fn activity ->
33 Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
38 # TODO: Add cached version.
39 defp get_replied_to_activities([]), do: %{}
41 defp get_replied_to_activities(activities) do
44 %{data: %{"type" => "Create"}} = activity ->
45 object = Object.normalize(activity, fetch: false)
46 object && object.data["inReplyTo"] != "" && object.data["inReplyTo"]
52 |> Activity.create_by_object_ap_id_with_object()
54 |> Enum.reduce(%{}, fn activity, acc ->
55 object = Object.normalize(activity, fetch: false)
56 if object, do: Map.put(acc, object.data["id"], activity), else: acc
60 # DEPRECATED This field seems to be a left-over from the StatusNet era.
61 # If your application uses `pleroma.conversation_id`: this field is deprecated.
62 # It is currently stubbed instead by doing a CRC32 of the context, and
63 # clearing the MSB to avoid overflow exceptions with signed integers on the
64 # different clients using this field (Java/Kotlin code, mostly; see Husky.)
65 # This should be removed in a future version of Pleroma. Pleroma-FE currently
66 # depends on this field, as well.
67 defp get_context_id(%{data: %{"context" => context}}) when is_binary(context) do
70 :erlang.crc32(context)
71 |> band(bnot(0x8000_0000))
74 defp get_context_id(_), do: nil
76 # Check if the user reblogged this status
77 defp reblogged?(activity, %User{ap_id: ap_id}) do
78 with %Object{data: %{"announcements" => announcements}} when is_list(announcements) <-
79 Object.normalize(activity, fetch: false) do
80 ap_id in announcements
86 # False if the user is logged out
87 defp reblogged?(_activity, _user), do: false
89 def render("index.json", opts) do
90 reading_user = opts[:for]
91 # To do: check AdminAPIControllerTest on the reasons behind nil activities in the list
92 activities = Enum.filter(opts.activities, & &1)
94 # Start fetching rich media before doing anything else, so that later calls to get the cards
95 # only block for timeout in the worst case, as opposed to
96 # length(activities_with_links) * timeout
97 fetch_rich_media_for_activities(activities)
98 replied_to_activities = get_replied_to_activities(activities)
102 |> Enum.filter(&(&1.data["type"] == "Announce" && &1.data["object"]))
103 |> Enum.map(&Object.normalize(&1, fetch: false).data["id"])
104 |> Activity.create_by_object_ap_id()
105 |> Activity.with_preloaded_object(:left)
106 |> Activity.with_preloaded_bookmark(reading_user)
107 |> Activity.with_set_thread_muted_field(reading_user)
112 Map.has_key?(opts, :relationships) ->
115 is_nil(reading_user) ->
116 UserRelationship.view_relationships_option(nil, [])
119 # Note: unresolved users are filtered out
121 (activities ++ parent_activities)
122 |> Enum.map(&CommonAPI.get_user(&1.data["actor"], false))
125 UserRelationship.view_relationships_option(reading_user, actors, subset: :source_mutes)
130 |> Map.put(:replied_to_activities, replied_to_activities)
131 |> Map.put(:parent_activities, parent_activities)
132 |> Map.put(:relationships, relationships_opt)
134 safe_render_many(activities, StatusView, "show.json", opts)
139 %{activity: %{data: %{"type" => "Announce", "object" => _object}} = activity} = opts
141 user = CommonAPI.get_user(activity.data["actor"])
142 created_at = Utils.to_masto_date(activity.data["published"])
143 object = Object.normalize(activity, fetch: false)
145 reblogged_parent_activity =
146 if opts[:parent_activities] do
147 Activity.Queries.find_by_object_ap_id(
148 opts[:parent_activities],
152 Activity.create_by_object_ap_id(object.data["id"])
153 |> Activity.with_preloaded_bookmark(opts[:for])
154 |> Activity.with_set_thread_muted_field(opts[:for])
158 reblog_rendering_opts = Map.put(opts, :activity, reblogged_parent_activity)
159 reblogged = render("show.json", reblog_rendering_opts)
161 favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] || [])
163 bookmarked = Activity.get_bookmark(reblogged_parent_activity, opts[:for]) != nil
167 |> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
169 |> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)
171 {pinned?, pinned_at} = pin_data(object, user)
174 id: to_string(activity.id),
175 uri: object.data["id"],
176 url: object.data["id"],
178 AccountView.render("show.json", %{
183 in_reply_to_account_id: nil,
185 content: reblogged[:content] || "",
186 created_at: created_at,
190 reblogged: reblogged?(reblogged_parent_activity, opts[:for]),
191 favourited: present?(favorited),
192 bookmarked: present?(bookmarked),
197 visibility: get_visibility(activity),
198 media_attachments: reblogged[:media_attachments] || [],
200 tags: reblogged[:tags] || [],
201 application: build_application(object.data["generator"]),
205 local: activity.local,
211 def render("show.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
212 object = Object.normalize(activity, fetch: false)
214 user = CommonAPI.get_user(activity.data["actor"])
215 user_follower_address = user.follower_address
217 like_count = object.data["like_count"] || 0
218 announcement_count = object.data["announcement_count"] || 0
220 hashtags = Object.hashtags(object)
221 sensitive = object.data["sensitive"] || Enum.member?(hashtags, "nsfw")
223 tags = Object.tags(object)
227 |> Enum.filter(fn tag -> is_map(tag) and tag["type"] == "Mention" end)
228 |> Enum.map(fn tag -> tag["href"] end)
231 (object.data["to"] ++ tag_mentions)
234 Pleroma.Constants.as_public() -> nil
235 ^user_follower_address -> nil
236 ap_id -> User.get_cached_by_ap_id(ap_id)
239 |> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)
241 favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] || [])
243 bookmarked = Activity.get_bookmark(activity, opts[:for]) != nil
245 client_posted_this_activity = opts[:for] && user.id == opts[:for].id
248 with true <- client_posted_this_activity,
249 %Oban.Job{scheduled_at: scheduled_at} <-
250 Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id) do
258 is_nil(opts[:for]) -> false
259 is_boolean(activity.thread_muted?) -> activity.thread_muted?
260 true -> CommonAPI.thread_muted?(opts[:for], activity)
263 attachment_data = object.data["attachment"] || []
264 attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)
266 created_at = Utils.to_masto_date(object.data["published"])
268 reply_to = get_reply_to(activity, opts)
270 reply_to_user = reply_to && CommonAPI.get_user(reply_to.data["actor"])
278 |> Activity.HTML.get_cached_scrubbed_html_for_activity(
279 User.html_filter_policy(opts[:for]),
286 |> Activity.HTML.get_cached_stripped_html_for_activity(
291 summary = object.data["summary"] || ""
293 card = render("card.json", Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity))
297 Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
299 object.data["url"] || object.data["external_url"] || object.data["id"]
302 direct_conversation_id =
303 with {_, nil} <- {:direct_conversation_id, opts[:direct_conversation_id]},
304 {_, true} <- {:include_id, opts[:with_direct_conversation_id]},
305 {_, %User{} = for_user} <- {:for_user, opts[:for]} do
306 Activity.direct_conversation_id(activity, for_user)
308 {:direct_conversation_id, participation_id} when is_integer(participation_id) ->
317 |> Map.get("reactions", [])
318 |> EmojiReactionController.filter_allowed_users(
320 Map.get(opts, :with_muted, false)
322 |> Stream.map(fn {emoji, users, url} ->
323 build_emoji_map(emoji, users, url, opts[:for])
327 # Status muted state (would do 1 request per status unless user mutes are preloaded)
330 UserRelationship.exists?(
331 get_in(opts, [:relationships, :user_relationships]),
335 fn for_user, user -> User.mutes?(for_user, user) end
338 {pinned?, pinned_at} = pin_data(object, user)
340 quote = Activity.get_quoted_activity_from_object(object)
343 id: to_string(activity.id),
344 uri: object.data["id"],
347 AccountView.render("show.json", %{
351 in_reply_to_id: reply_to && to_string(reply_to.id),
352 in_reply_to_account_id: reply_to_user && to_string(reply_to_user.id),
355 content: content_html,
356 text: opts[:with_source] && object.data["source"],
357 created_at: created_at,
358 reblogs_count: announcement_count,
359 replies_count: object.data["repliesCount"] || 0,
360 favourites_count: like_count,
361 reblogged: reblogged?(activity, opts[:for]),
362 favourited: present?(favorited),
363 bookmarked: present?(bookmarked),
366 sensitive: sensitive,
367 spoiler_text: summary,
368 visibility: get_visibility(object),
369 media_attachments: attachments,
370 poll: render(PollView, "show.json", object: object, for: opts[:for]),
372 tags: build_tags(tags),
373 application: build_application(object.data["generator"]),
375 emojis: build_emojis(object.data["emoji"]),
376 quote_id: if(quote, do: quote.id, else: nil),
377 quote: maybe_render_quote(quote, opts),
379 local: activity.local,
380 conversation_id: get_context_id(activity),
381 in_reply_to_account_acct: reply_to_user && reply_to_user.nickname,
382 content: %{"text/plain" => content_plaintext},
383 spoiler_text: %{"text/plain" => summary},
384 expires_at: expires_at,
385 direct_conversation_id: direct_conversation_id,
386 thread_muted: thread_muted?,
387 emoji_reactions: emoji_reactions,
388 parent_visible: visible_for_user?(reply_to, opts[:for]),
392 source: object.data["source"]
397 def render("show.json", _) do
401 def render("card.json", %{rich_media: rich_media, page_url: page_url}) do
402 page_url_data = URI.parse(page_url)
405 if is_binary(rich_media["url"]) do
406 URI.merge(page_url_data, URI.parse(rich_media["url"]))
411 page_url = page_url_data |> to_string
414 if is_binary(rich_media["image"]) do
415 URI.parse(rich_media["image"])
420 image_url = build_image_url(image_url_data, page_url_data)
424 provider_name: page_url_data.host,
425 provider_url: page_url_data.scheme <> "://" <> page_url_data.host,
427 image: image_url |> MediaProxy.url(),
428 title: rich_media["title"] || "",
429 description: rich_media["description"] || "",
431 opengraph: rich_media
436 def render("card.json", _), do: nil
438 def render("attachment.json", %{attachment: attachment}) do
439 [attachment_url | _] = attachment["url"]
440 media_type = attachment_url["mediaType"] || attachment_url["mimeType"] || "image"
441 href = attachment_url["href"] |> MediaProxy.url()
442 href_preview = attachment_url["href"] |> MediaProxy.preview_url()
443 meta = render("attachment_meta.json", %{attachment: attachment})
447 String.contains?(media_type, "image") -> "image"
448 String.contains?(media_type, "video") -> "video"
449 String.contains?(media_type, "audio") -> "audio"
453 <<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)
456 id: to_string(attachment["id"] || hash_id),
459 preview_url: href_preview,
462 description: attachment["name"],
463 pleroma: %{mime_type: media_type},
464 blurhash: attachment["blurhash"]
466 |> Maps.put_if_present(:meta, meta)
469 def render("attachment_meta.json", %{
470 attachment: %{"url" => [%{"width" => width, "height" => height} | _]}
472 when is_integer(width) and is_integer(height) do
477 aspect: width / height
482 def render("attachment_meta.json", _), do: nil
484 def render("context.json", %{activity: activity, activities: activities, user: user}) do
485 %{ancestors: ancestors, descendants: descendants} =
488 |> Enum.group_by(fn %{id: id} -> if id < activity.id, do: :ancestors, else: :descendants end)
489 |> Map.put_new(:ancestors, [])
490 |> Map.put_new(:descendants, [])
493 ancestors: render("index.json", for: user, activities: ancestors, as: :activity),
494 descendants: render("index.json", for: user, activities: descendants, as: :activity)
498 def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
499 object = Object.normalize(activity, fetch: false)
501 with nil <- replied_to_activities[object.data["inReplyTo"]] do
502 # If user didn't participate in the thread
503 Activity.get_in_reply_to_activity(activity)
507 def get_reply_to(%{data: %{"object" => _object}} = activity, _) do
508 object = Object.normalize(activity, fetch: false)
510 if object.data["inReplyTo"] && object.data["inReplyTo"] != "" do
511 Activity.get_create_by_object_ap_id(object.data["inReplyTo"])
517 def render_content(%{data: %{"name" => name}} = object) when not is_nil(name) and name != "" do
518 url = object.data["url"] || object.data["id"]
520 "<p><a href=\"#{url}\">#{name}</a></p>#{object.data["content"]}"
523 def render_content(object), do: object.data["content"] || ""
526 Builds a dictionary tags.
530 iex> Pleroma.Web.MastodonAPI.StatusView.build_tags(["fediverse", "nextcloud"])
531 [{"name": "fediverse", "url": "/tag/fediverse"},
532 {"name": "nextcloud", "url": "/tag/nextcloud"}]
535 @spec build_tags(list(any())) :: list(map())
536 def build_tags(object_tags) when is_list(object_tags) do
538 |> Enum.filter(&is_binary/1)
539 |> Enum.map(&%{name: &1, url: "#{Pleroma.Web.Endpoint.url()}/tag/#{URI.encode(&1)}"})
542 def build_tags(_), do: []
547 Arguments: `nil` or list tuple of name and url.
553 iex> Pleroma.Web.MastodonAPI.StatusView.build_emojis([{"2hu", "corndog.png"}])
554 [%{shortcode: "2hu", static_url: "corndog.png", url: "corndog.png", visible_in_picker: false}]
557 @spec build_emojis(nil | list(tuple())) :: list(map())
558 def build_emojis(nil), do: []
560 def build_emojis(emojis) do
562 |> Enum.map(fn {name, url} ->
563 name = HTML.strip_tags(name)
570 %{shortcode: name, url: url, static_url: url, visible_in_picker: false}
574 defp present?(nil), do: false
575 defp present?(false), do: false
576 defp present?(_), do: true
578 defp pin_data(%Object{data: %{"id" => object_id}}, %User{pinned_objects: pinned_objects}) do
579 if pinned_at = pinned_objects[object_id] do
580 {true, Utils.to_masto_date(pinned_at)}
586 defp build_emoji_map(emoji, users, url, current_user) do
589 count: length(users),
590 url: MediaProxy.url(url),
591 me: !!(current_user && current_user.ap_id in users)
595 @spec build_application(map() | nil) :: map() | nil
596 defp build_application(%{"type" => _type, "name" => name, "url" => url}),
597 do: %{name: name, website: url}
599 defp build_application(_), do: nil
601 # Workaround for Elixir issue #10771
602 # Avoid applying URI.merge unless necessary
603 # TODO: revert to always attempting URI.merge(image_url_data, page_url_data)
604 # when Elixir 1.12 is the minimum supported version
605 @spec build_image_url(struct() | nil, struct()) :: String.t() | nil
606 defp build_image_url(
607 %URI{scheme: image_scheme, host: image_host} = image_url_data,
608 %URI{} = _page_url_data
610 when not is_nil(image_scheme) and not is_nil(image_host) do
611 image_url_data |> to_string
614 defp build_image_url(%URI{} = image_url_data, %URI{} = page_url_data) do
615 URI.merge(page_url_data, image_url_data) |> to_string
618 defp build_image_url(_, _), do: nil
620 defp maybe_render_quote(nil, _), do: nil
622 defp maybe_render_quote(quote, opts) do
623 if opts[:do_not_recurse] || !visible_for_user?(quote, opts[:for]) do
628 |> Map.put(:activity, quote)
629 |> Map.put(:do_not_recurse, true)
631 render("show.json", opts)