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 context: object.data["context"],
382 in_reply_to_account_acct: reply_to_user && reply_to_user.nickname,
383 content: %{"text/plain" => content_plaintext},
384 spoiler_text: %{"text/plain" => summary},
385 expires_at: expires_at,
386 direct_conversation_id: direct_conversation_id,
387 thread_muted: thread_muted?,
388 emoji_reactions: emoji_reactions,
389 parent_visible: visible_for_user?(reply_to, opts[:for]),
393 source: object.data["source"]
398 def render("show.json", _) do
402 def render("card.json", %{rich_media: rich_media, page_url: page_url}) do
403 page_url_data = URI.parse(page_url)
406 if is_binary(rich_media["url"]) do
407 URI.merge(page_url_data, URI.parse(rich_media["url"]))
412 page_url = page_url_data |> to_string
415 if is_binary(rich_media["image"]) do
416 URI.parse(rich_media["image"])
421 image_url = build_image_url(image_url_data, page_url_data)
425 provider_name: page_url_data.host,
426 provider_url: page_url_data.scheme <> "://" <> page_url_data.host,
428 image: image_url |> MediaProxy.url(),
429 title: rich_media["title"] || "",
430 description: rich_media["description"] || "",
432 opengraph: rich_media
437 def render("card.json", _), do: nil
439 def render("attachment.json", %{attachment: attachment}) do
440 [attachment_url | _] = attachment["url"]
441 media_type = attachment_url["mediaType"] || attachment_url["mimeType"] || "image"
442 href = attachment_url["href"] |> MediaProxy.url()
443 href_preview = attachment_url["href"] |> MediaProxy.preview_url()
444 meta = render("attachment_meta.json", %{attachment: attachment})
448 String.contains?(media_type, "image") -> "image"
449 String.contains?(media_type, "video") -> "video"
450 String.contains?(media_type, "audio") -> "audio"
454 <<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)
457 id: to_string(attachment["id"] || hash_id),
460 preview_url: href_preview,
463 description: attachment["name"],
464 pleroma: %{mime_type: media_type},
465 blurhash: attachment["blurhash"]
467 |> Maps.put_if_present(:meta, meta)
470 def render("attachment_meta.json", %{
471 attachment: %{"url" => [%{"width" => width, "height" => height} | _]}
473 when is_integer(width) and is_integer(height) do
478 aspect: width / height
483 def render("attachment_meta.json", _), do: nil
485 def render("context.json", %{activity: activity, activities: activities, user: user}) do
486 %{ancestors: ancestors, descendants: descendants} =
489 |> Enum.group_by(fn %{id: id} -> if id < activity.id, do: :ancestors, else: :descendants end)
490 |> Map.put_new(:ancestors, [])
491 |> Map.put_new(:descendants, [])
494 ancestors: render("index.json", for: user, activities: ancestors, as: :activity),
495 descendants: render("index.json", for: user, activities: descendants, as: :activity)
499 def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
500 object = Object.normalize(activity, fetch: false)
502 with nil <- replied_to_activities[object.data["inReplyTo"]] do
503 # If user didn't participate in the thread
504 Activity.get_in_reply_to_activity(activity)
508 def get_reply_to(%{data: %{"object" => _object}} = activity, _) do
509 object = Object.normalize(activity, fetch: false)
511 if object.data["inReplyTo"] && object.data["inReplyTo"] != "" do
512 Activity.get_create_by_object_ap_id(object.data["inReplyTo"])
518 def render_content(%{data: %{"name" => name}} = object) when not is_nil(name) and name != "" do
519 url = object.data["url"] || object.data["id"]
521 "<p><a href=\"#{url}\">#{name}</a></p>#{object.data["content"]}"
524 def render_content(object), do: object.data["content"] || ""
527 Builds a dictionary tags.
531 iex> Pleroma.Web.MastodonAPI.StatusView.build_tags(["fediverse", "nextcloud"])
532 [{"name": "fediverse", "url": "/tag/fediverse"},
533 {"name": "nextcloud", "url": "/tag/nextcloud"}]
536 @spec build_tags(list(any())) :: list(map())
537 def build_tags(object_tags) when is_list(object_tags) do
539 |> Enum.filter(&is_binary/1)
540 |> Enum.map(&%{name: &1, url: "#{Pleroma.Web.Endpoint.url()}/tag/#{URI.encode(&1)}"})
543 def build_tags(_), do: []
548 Arguments: `nil` or list tuple of name and url.
554 iex> Pleroma.Web.MastodonAPI.StatusView.build_emojis([{"2hu", "corndog.png"}])
555 [%{shortcode: "2hu", static_url: "corndog.png", url: "corndog.png", visible_in_picker: false}]
558 @spec build_emojis(nil | list(tuple())) :: list(map())
559 def build_emojis(nil), do: []
561 def build_emojis(emojis) do
563 |> Enum.map(fn {name, url} ->
564 name = HTML.strip_tags(name)
571 %{shortcode: name, url: url, static_url: url, visible_in_picker: false}
575 defp present?(nil), do: false
576 defp present?(false), do: false
577 defp present?(_), do: true
579 defp pin_data(%Object{data: %{"id" => object_id}}, %User{pinned_objects: pinned_objects}) do
580 if pinned_at = pinned_objects[object_id] do
581 {true, Utils.to_masto_date(pinned_at)}
587 defp build_emoji_map(emoji, users, url, current_user) do
590 count: length(users),
591 url: MediaProxy.url(url),
592 me: !!(current_user && current_user.ap_id in users)
596 @spec build_application(map() | nil) :: map() | nil
597 defp build_application(%{"type" => _type, "name" => name, "url" => url}),
598 do: %{name: name, website: url}
600 defp build_application(_), do: nil
602 # Workaround for Elixir issue #10771
603 # Avoid applying URI.merge unless necessary
604 # TODO: revert to always attempting URI.merge(image_url_data, page_url_data)
605 # when Elixir 1.12 is the minimum supported version
606 @spec build_image_url(struct() | nil, struct()) :: String.t() | nil
607 defp build_image_url(
608 %URI{scheme: image_scheme, host: image_host} = image_url_data,
609 %URI{} = _page_url_data
611 when not is_nil(image_scheme) and not is_nil(image_host) do
612 image_url_data |> to_string
615 defp build_image_url(%URI{} = image_url_data, %URI{} = page_url_data) do
616 URI.merge(page_url_data, image_url_data) |> to_string
619 defp build_image_url(_, _), do: nil
621 defp maybe_render_quote(nil, _), do: nil
623 defp maybe_render_quote(quote, opts) do
624 if opts[:do_not_recurse] || !visible_for_user?(quote, opts[:for]) do
629 |> Map.put(:activity, quote)
630 |> Map.put(:do_not_recurse, true)
632 render("show.json", opts)