git.squeep.com Git - akkoma/blob - lib/pleroma/web/mastodon_api/views/status_view.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 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.HTML
  12   alias Pleroma.Object
  13   alias Pleroma.Repo
  14   alias Pleroma.User
  15   alias Pleroma.UserRelationship
  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   alias Pleroma.Web.PleromaAPI.EmojiReactionController
  23
  24   import Pleroma.Web.ActivityPub.Visibility, only: [get_visibility: 1, visible_for_user?: 2]
  25
  26   # This is a naive way to do this, just spawning a process per activity
  27   # to fetch the preview. However it should be fine considering
  28   # pagination is restricted to 40 activities at a time
  29   defp fetch_rich_media_for_activities(activities) do
  30     Enum.each(activities, fn activity ->
  31       spawn(fn ->
  32         Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
  33       end)
  34     end)
  35   end
  36
  37   # TODO: Add cached version.
  38   defp get_replied_to_activities([]), do: %{}
  39
  40   defp get_replied_to_activities(activities) do
  41     activities
  42     |> Enum.map(fn
  43       %{data: %{"type" => "Create"}} = activity ->
  44         object = Object.normalize(activity, fetch: false)
  45         object && object.data["inReplyTo"] != "" && object.data["inReplyTo"]
  46
  47       _ ->
  48         nil
  49     end)
  50     |> Enum.filter(& &1)
  51     |> Activity.create_by_object_ap_id_with_object()
  52     |> Repo.all()
  53     |> Enum.reduce(%{}, fn activity, acc ->
  54       object = Object.normalize(activity, fetch: false)
  55       if object, do: Map.put(acc, object.data["id"], activity), else: acc
  56     end)
  57   end
  58
  59   defp get_context_id(%{data: %{"context_id" => context_id}}) when not is_nil(context_id),
  60     do: context_id
  61
  62   defp get_context_id(%{data: %{"context" => context}}) when is_binary(context),
  63     do: Utils.context_to_conversation_id(context)
  64
  65   defp get_context_id(_), do: nil
  66
  67   defp reblogged?(activity, user) do
  68     object = Object.normalize(activity, fetch: false) || %{}
  69     present?(user && user.ap_id in (object.data["announcements"] || []))
  70   end
  71
  72   def render("index.json", opts) do
  73     reading_user = opts[:for]
  74
  75     # To do: check AdminAPIControllerTest on the reasons behind nil activities in the list
  76     activities = Enum.filter(opts.activities, & &1)
  77
  78     # Start fetching rich media before doing anything else, so that later calls to get the cards
  79     # only block for timeout in the worst case, as opposed to
  80     # length(activities_with_links) * timeout
  81     fetch_rich_media_for_activities(activities)
  82     replied_to_activities = get_replied_to_activities(activities)
  83
  84     parent_activities =
  85       activities
  86       |> Enum.filter(&(&1.data["type"] == "Announce" && &1.data["object"]))
  87       |> Enum.map(&Object.normalize(&1, fetch: false).data["id"])
  88       |> Activity.create_by_object_ap_id()
  89       |> Activity.with_preloaded_object(:left)
  90       |> Activity.with_preloaded_bookmark(reading_user)
  91       |> Activity.with_set_thread_muted_field(reading_user)
  92       |> Repo.all()
  93
  94     relationships_opt =
  95       cond do
  96         Map.has_key?(opts, :relationships) ->
  97           opts[:relationships]
  98
  99         is_nil(reading_user) ->
 100           UserRelationship.view_relationships_option(nil, [])
 101
 102         true ->
 103           # Note: unresolved users are filtered out
 104           actors =
 105             (activities ++ parent_activities)
 106             |> Enum.map(&CommonAPI.get_user(&1.data["actor"], false))
 107             |> Enum.filter(& &1)
 108
 109           UserRelationship.view_relationships_option(reading_user, actors, subset: :source_mutes)
 110       end
 111
 112     opts =
 113       opts
 114       |> Map.put(:replied_to_activities, replied_to_activities)
 115       |> Map.put(:parent_activities, parent_activities)
 116       |> Map.put(:relationships, relationships_opt)
 117
 118     safe_render_many(activities, StatusView, "show.json", opts)
 119   end
 120
 121   def render(
 122         "show.json",
 123         %{activity: %{data: %{"type" => "Announce", "object" => _object}} = activity} = opts
 124       ) do
 125     user = CommonAPI.get_user(activity.data["actor"])
 126     created_at = Utils.to_masto_date(activity.data["published"])
 127     object = Object.normalize(activity, fetch: false)
 128
 129     reblogged_parent_activity =
 130       if opts[:parent_activities] do
 131         Activity.Queries.find_by_object_ap_id(
 132           opts[:parent_activities],
 133           object.data["id"]
 134         )
 135       else
 136         Activity.create_by_object_ap_id(object.data["id"])
 137         |> Activity.with_preloaded_bookmark(opts[:for])
 138         |> Activity.with_set_thread_muted_field(opts[:for])
 139         |> Repo.one()
 140       end
 141
 142     reblog_rendering_opts = Map.put(opts, :activity, reblogged_parent_activity)
 143     reblogged = render("show.json", reblog_rendering_opts)
 144
 145     favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] || [])
 146
 147     bookmarked = Activity.get_bookmark(reblogged_parent_activity, opts[:for]) != nil
 148
 149     mentions =
 150       activity.recipients
 151       |> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
 152       |> Enum.filter(& &1)
 153       |> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)
 154
 155     %{
 156       id: to_string(activity.id),
 157       uri: object.data["id"],
 158       url: object.data["id"],
 159       account:
 160         AccountView.render("show.json", %{
 161           user: user,
 162           for: opts[:for]
 163         }),
 164       in_reply_to_id: nil,
 165       in_reply_to_account_id: nil,
 166       reblog: reblogged,
 167       content: reblogged[:content] || "",
 168       created_at: created_at,
 169       reblogs_count: 0,
 170       replies_count: 0,
 171       favourites_count: 0,
 172       reblogged: reblogged?(reblogged_parent_activity, opts[:for]),
 173       favourited: present?(favorited),
 174       bookmarked: present?(bookmarked),
 175       muted: false,
 176       pinned: pinned?(activity, user),
 177       sensitive: false,
 178       spoiler_text: "",
 179       visibility: get_visibility(activity),
 180       media_attachments: reblogged[:media_attachments] || [],
 181       mentions: mentions,
 182       tags: reblogged[:tags] || [],
 183       application: build_application(object.data["generator"]),
 184       language: nil,
 185       emojis: [],
 186       pleroma: %{
 187         local: activity.local
 188       }
 189     }
 190   end
 191
 192   def render("show.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
 193     object = Object.normalize(activity, fetch: false)
 194
 195     user = CommonAPI.get_user(activity.data["actor"])
 196     user_follower_address = user.follower_address
 197
 198     like_count = object.data["like_count"] || 0
 199     announcement_count = object.data["announcement_count"] || 0
 200
 201     hashtags = Object.hashtags(object)
 202     sensitive = object.data["sensitive"] || Enum.member?(hashtags, "nsfw")
 203
 204     tags = Object.tags(object)
 205
 206     tag_mentions =
 207       tags
 208       |> Enum.filter(fn tag -> is_map(tag) and tag["type"] == "Mention" end)
 209       |> Enum.map(fn tag -> tag["href"] end)
 210
 211     mentions =
 212       (object.data["to"] ++ tag_mentions)
 213       |> Enum.uniq()
 214       |> Enum.map(fn
 215         Pleroma.Constants.as_public() -> nil
 216         ^user_follower_address -> nil
 217         ap_id -> User.get_cached_by_ap_id(ap_id)
 218       end)
 219       |> Enum.filter(& &1)
 220       |> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)
 221
 222     favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] || [])
 223
 224     bookmarked = Activity.get_bookmark(activity, opts[:for]) != nil
 225
 226     client_posted_this_activity = opts[:for] && user.id == opts[:for].id
 227
 228     expires_at =
 229       with true <- client_posted_this_activity,
 230            %Oban.Job{scheduled_at: scheduled_at} <-
 231              Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id) do
 232         scheduled_at
 233       else
 234         _ -> nil
 235       end
 236
 237     thread_muted? =
 238       cond do
 239         is_nil(opts[:for]) -> false
 240         is_boolean(activity.thread_muted?) -> activity.thread_muted?
 241         true -> CommonAPI.thread_muted?(opts[:for], activity)
 242       end
 243
 244     attachment_data = object.data["attachment"] || []
 245     attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)
 246
 247     created_at = Utils.to_masto_date(object.data["published"])
 248
 249     reply_to = get_reply_to(activity, opts)
 250
 251     reply_to_user = reply_to && CommonAPI.get_user(reply_to.data["actor"])
 252
 253     content =
 254       object
 255       |> render_content()
 256
 257     content_html =
 258       content
 259       |> HTML.get_cached_scrubbed_html_for_activity(
 260         User.html_filter_policy(opts[:for]),
 261         activity,
 262         "mastoapi:content"
 263       )
 264
 265     content_plaintext =
 266       content
 267       |> HTML.get_cached_stripped_html_for_activity(
 268         activity,
 269         "mastoapi:content"
 270       )
 271
 272     summary = object.data["summary"] || ""
 273
 274     card = render("card.json", Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity))
 275
 276     url =
 277       if user.local do
 278         Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
 279       else
 280         object.data["url"] || object.data["external_url"] || object.data["id"]
 281       end
 282
 283     direct_conversation_id =
 284       with {_, nil} <- {:direct_conversation_id, opts[:direct_conversation_id]},
 285            {_, true} <- {:include_id, opts[:with_direct_conversation_id]},
 286            {_, %User{} = for_user} <- {:for_user, opts[:for]} do
 287         Activity.direct_conversation_id(activity, for_user)
 288       else
 289         {:direct_conversation_id, participation_id} when is_integer(participation_id) ->
 290           participation_id
 291
 292         _e ->
 293           nil
 294       end
 295
 296     emoji_reactions =
 297       object.data
 298       |> Map.get("reactions", [])
 299       |> EmojiReactionController.filter_allowed_users(
 300         opts[:for],
 301         Map.get(opts, :with_muted, false)
 302       )
 303       |> Stream.map(fn {emoji, users} ->
 304         build_emoji_map(emoji, users, opts[:for])
 305       end)
 306       |> Enum.to_list()
 307
 308     # Status muted state (would do 1 request per status unless user mutes are preloaded)
 309     muted =
 310       thread_muted? ||
 311         UserRelationship.exists?(
 312           get_in(opts, [:relationships, :user_relationships]),
 313           :mute,
 314           opts[:for],
 315           user,
 316           fn for_user, user -> User.mutes?(for_user, user) end
 317         )
 318
 319     %{
 320       id: to_string(activity.id),
 321       uri: object.data["id"],
 322       url: url,
 323       account:
 324         AccountView.render("show.json", %{
 325           user: user,
 326           for: opts[:for]
 327         }),
 328       in_reply_to_id: reply_to && to_string(reply_to.id),
 329       in_reply_to_account_id: reply_to_user && to_string(reply_to_user.id),
 330       reblog: nil,
 331       card: card,
 332       content: content_html,
 333       text: opts[:with_source] && object.data["source"],
 334       created_at: created_at,
 335       reblogs_count: announcement_count,
 336       replies_count: object.data["repliesCount"] || 0,
 337       favourites_count: like_count,
 338       reblogged: reblogged?(activity, opts[:for]),
 339       favourited: present?(favorited),
 340       bookmarked: present?(bookmarked),
 341       muted: muted,
 342       pinned: pinned?(activity, user),
 343       sensitive: sensitive,
 344       spoiler_text: summary,
 345       visibility: get_visibility(object),
 346       media_attachments: attachments,
 347       poll: render(PollView, "show.json", object: object, for: opts[:for]),
 348       mentions: mentions,
 349       tags: build_tags(tags),
 350       application: build_application(object.data["generator"]),
 351       language: nil,
 352       emojis: build_emojis(object.data["emoji"]),
 353       pleroma: %{
 354         local: activity.local,
 355         conversation_id: get_context_id(activity),
 356         in_reply_to_account_acct: reply_to_user && reply_to_user.nickname,
 357         content: %{"text/plain" => content_plaintext},
 358         spoiler_text: %{"text/plain" => summary},
 359         expires_at: expires_at,
 360         direct_conversation_id: direct_conversation_id,
 361         thread_muted: thread_muted?,
 362         emoji_reactions: emoji_reactions,
 363         parent_visible: visible_for_user?(reply_to, opts[:for])
 364       }
 365     }
 366   end
 367
 368   def render("show.json", _) do
 369     nil
 370   end
 371
 372   def render("card.json", %{rich_media: rich_media, page_url: page_url}) do
 373     page_url_data = URI.parse(page_url)
 374
 375     page_url_data =
 376       if is_binary(rich_media["url"]) do
 377         URI.merge(page_url_data, URI.parse(rich_media["url"]))
 378       else
 379         page_url_data
 380       end
 381
 382     page_url = page_url_data |> to_string
 383
 384     image_url =
 385       if is_binary(rich_media["image"]) do
 386         URI.merge(page_url_data, URI.parse(rich_media["image"]))
 387         |> to_string
 388       end
 389
 390     %{
 391       type: "link",
 392       provider_name: page_url_data.host,
 393       provider_url: page_url_data.scheme <> "://" <> page_url_data.host,
 394       url: page_url,
 395       image: image_url |> MediaProxy.url(),
 396       title: rich_media["title"] || "",
 397       description: rich_media["description"] || "",
 398       pleroma: %{
 399         opengraph: rich_media
 400       }
 401     }
 402   end
 403
 404   def render("card.json", _), do: nil
 405
 406   def render("attachment.json", %{attachment: attachment}) do
 407     [attachment_url | _] = attachment["url"]
 408     media_type = attachment_url["mediaType"] || attachment_url["mimeType"] || "image"
 409     href = attachment_url["href"] |> MediaProxy.url()
 410     href_preview = attachment_url["href"] |> MediaProxy.preview_url()
 411
 412     type =
 413       cond do
 414         String.contains?(media_type, "image") -> "image"
 415         String.contains?(media_type, "video") -> "video"
 416         String.contains?(media_type, "audio") -> "audio"
 417         true -> "unknown"
 418       end
 419
 420     <<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)
 421
 422     %{
 423       id: to_string(attachment["id"] || hash_id),
 424       url: href,
 425       remote_url: href,
 426       preview_url: href_preview,
 427       text_url: href,
 428       type: type,
 429       description: attachment["name"],
 430       pleroma: %{mime_type: media_type},
 431       blurhash: attachment["blurhash"]
 432     }
 433   end
 434
 435   def render("context.json", %{activity: activity, activities: activities, user: user}) do
 436     %{ancestors: ancestors, descendants: descendants} =
 437       activities
 438       |> Enum.reverse()
 439       |> Enum.group_by(fn %{id: id} -> if id < activity.id, do: :ancestors, else: :descendants end)
 440       |> Map.put_new(:ancestors, [])
 441       |> Map.put_new(:descendants, [])
 442
 443     %{
 444       ancestors: render("index.json", for: user, activities: ancestors, as: :activity),
 445       descendants: render("index.json", for: user, activities: descendants, as: :activity)
 446     }
 447   end
 448
 449   def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
 450     object = Object.normalize(activity, fetch: false)
 451
 452     with nil <- replied_to_activities[object.data["inReplyTo"]] do
 453       # If user didn't participate in the thread
 454       Activity.get_in_reply_to_activity(activity)
 455     end
 456   end
 457
 458   def get_reply_to(%{data: %{"object" => _object}} = activity, _) do
 459     object = Object.normalize(activity, fetch: false)
 460
 461     if object.data["inReplyTo"] && object.data["inReplyTo"] != "" do
 462       Activity.get_create_by_object_ap_id(object.data["inReplyTo"])
 463     else
 464       nil
 465     end
 466   end
 467
 468   def render_content(%{data: %{"name" => name}} = object) when not is_nil(name) and name != "" do
 469     url = object.data["url"] || object.data["id"]
 470
 471     "<p><a href=\"#{url}\">#{name}</a></p>#{object.data["content"]}"
 472   end
 473
 474   def render_content(object), do: object.data["content"] || ""
 475
 476   @doc """
 477   Builds a dictionary tags.
 478
 479   ## Examples
 480
 481   iex> Pleroma.Web.MastodonAPI.StatusView.build_tags(["fediverse", "nextcloud"])
 482   [{"name": "fediverse", "url": "/tag/fediverse"},
 483    {"name": "nextcloud", "url": "/tag/nextcloud"}]
 484
 485   """
 486   @spec build_tags(list(any())) :: list(map())
 487   def build_tags(object_tags) when is_list(object_tags) do
 488     object_tags
 489     |> Enum.filter(&is_binary/1)
 490     |> Enum.map(&%{name: &1, url: "#{Pleroma.Web.base_url()}/tag/#{URI.encode(&1)}"})
 491   end
 492
 493   def build_tags(_), do: []
 494
 495   @doc """
 496   Builds list emojis.
 497
 498   Arguments: `nil` or list tuple of name and url.
 499
 500   Returns list emojis.
 501
 502   ## Examples
 503
 504   iex> Pleroma.Web.MastodonAPI.StatusView.build_emojis([{"2hu", "corndog.png"}])
 505   [%{shortcode: "2hu", static_url: "corndog.png", url: "corndog.png", visible_in_picker: false}]
 506
 507   """
 508   @spec build_emojis(nil | list(tuple())) :: list(map())
 509   def build_emojis(nil), do: []
 510
 511   def build_emojis(emojis) do
 512     emojis
 513     |> Enum.map(fn {name, url} ->
 514       name = HTML.strip_tags(name)
 515
 516       url =
 517         url
 518         |> HTML.strip_tags()
 519         |> MediaProxy.url()
 520
 521       %{shortcode: name, url: url, static_url: url, visible_in_picker: false}
 522     end)
 523   end
 524
 525   defp present?(nil), do: false
 526   defp present?(false), do: false
 527   defp present?(_), do: true
 528
 529   defp pinned?(%Activity{id: id}, %User{pinned_activities: pinned_activities}),
 530     do: id in pinned_activities
 531
 532   defp build_emoji_map(emoji, users, current_user) do
 533     %{
 534       name: emoji,
 535       count: length(users),
 536       me: !!(current_user && current_user.ap_id in users)
 537     }
 538   end
 539
 540   @spec build_application(map() | nil) :: map() | nil
 541   defp build_application(%{"type" => _type, "name" => name, "url" => url}),
 542     do: %{name: name, website: url}
 543
 544   defp build_application(_), do: nil
 545 end