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