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("listen.json", %{activity: %Activity{data: %{"type" => "Listen"}} = activity} = opts) do
 372     object = Object.normalize(activity)
 373
 374     user = get_user(activity.data["actor"])
 375     created_at = Utils.to_masto_date(activity.data["published"])
 376
 377     %{
 378       id: activity.id,
 379       account: AccountView.render("account.json", %{user: user, for: opts[:for]}),
 380       created_at: created_at,
 381       title: object.data["title"] |> HTML.strip_tags(),
 382       artist: object.data["artist"] |> HTML.strip_tags(),
 383       album: object.data["album"] |> HTML.strip_tags(),
 384       length: object.data["length"]
 385     }
 386   end
 387
 388   def render("poll.json", %{object: object} = opts) do
 389     {multiple, options} =
 390       case object.data do
 391         %{"anyOf" => options} when is_list(options) -> {true, options}
 392         %{"oneOf" => options} when is_list(options) -> {false, options}
 393         _ -> {nil, nil}
 394       end
 395
 396     if options do
 397       {end_time, expired} =
 398         case object.data["closed"] || object.data["endTime"] do
 399           end_time when is_binary(end_time) ->
 400             end_time =
 401               (object.data["closed"] || object.data["endTime"])
 402               |> NaiveDateTime.from_iso8601!()
 403
 404             expired =
 405               end_time
 406               |> NaiveDateTime.compare(NaiveDateTime.utc_now())
 407               |> case do
 408                 :lt -> true
 409                 _ -> false
 410               end
 411
 412             end_time = Utils.to_masto_date(end_time)
 413
 414             {end_time, expired}
 415
 416           _ ->
 417             {nil, false}
 418         end
 419
 420       voted =
 421         if opts[:for] do
 422           existing_votes =
 423             Pleroma.Web.ActivityPub.Utils.get_existing_votes(opts[:for].ap_id, object)
 424
 425           existing_votes != [] or opts[:for].ap_id == object.data["actor"]
 426         else
 427           false
 428         end
 429
 430       {options, votes_count} =
 431         Enum.map_reduce(options, 0, fn %{"name" => name} = option, count ->
 432           current_count = option["replies"]["totalItems"] || 0
 433
 434           {%{
 435              title: HTML.strip_tags(name),
 436              votes_count: current_count
 437            }, current_count + count}
 438         end)
 439
 440       %{
 441         # Mastodon uses separate ids for polls, but an object can't have
 442         # more than one poll embedded so object id is fine
 443         id: to_string(object.id),
 444         expires_at: end_time,
 445         expired: expired,
 446         multiple: multiple,
 447         votes_count: votes_count,
 448         options: options,
 449         voted: voted,
 450         emojis: build_emojis(object.data["emoji"])
 451       }
 452     else
 453       nil
 454     end
 455   end
 456
 457   def render("context.json", %{activity: activity, activities: activities, user: user}) do
 458     %{ancestors: ancestors, descendants: descendants} =
 459       activities
 460       |> Enum.reverse()
 461       |> Enum.group_by(fn %{id: id} -> if id < activity.id, do: :ancestors, else: :descendants end)
 462       |> Map.put_new(:ancestors, [])
 463       |> Map.put_new(:descendants, [])
 464
 465     %{
 466       ancestors: render("index.json", for: user, activities: ancestors, as: :activity),
 467       descendants: render("index.json", for: user, activities: descendants, as: :activity)
 468     }
 469   end
 470
 471   def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
 472     object = Object.normalize(activity)
 473
 474     with nil <- replied_to_activities[object.data["inReplyTo"]] do
 475       # If user didn't participate in the thread
 476       Activity.get_in_reply_to_activity(activity)
 477     end
 478   end
 479
 480   def get_reply_to(%{data: %{"object" => _object}} = activity, _) do
 481     object = Object.normalize(activity)
 482
 483     if object.data["inReplyTo"] && object.data["inReplyTo"] != "" do
 484       Activity.get_create_by_object_ap_id(object.data["inReplyTo"])
 485     else
 486       nil
 487     end
 488   end
 489
 490   def render_content(%{data: %{"type" => "Video"}} = object) do
 491     with name when not is_nil(name) and name != "" <- object.data["name"] do
 492       "<p><a href=\"#{object.data["id"]}\">#{name}</a></p>#{object.data["content"]}"
 493     else
 494       _ -> object.data["content"] || ""
 495     end
 496   end
 497
 498   def render_content(%{data: %{"type" => object_type}} = object)
 499       when object_type in ["Article", "Page"] do
 500     with summary when not is_nil(summary) and summary != "" <- object.data["name"],
 501          url when is_bitstring(url) <- object.data["url"] do
 502       "<p><a href=\"#{url}\">#{summary}</a></p>#{object.data["content"]}"
 503     else
 504       _ -> object.data["content"] || ""
 505     end
 506   end
 507
 508   def render_content(object), do: object.data["content"] || ""
 509
 510   @doc """
 511   Builds a dictionary tags.
 512
 513   ## Examples
 514
 515   iex> Pleroma.Web.MastodonAPI.StatusView.build_tags(["fediverse", "nextcloud"])
 516   [{"name": "fediverse", "url": "/tag/fediverse"},
 517    {"name": "nextcloud", "url": "/tag/nextcloud"}]
 518
 519   """
 520   @spec build_tags(list(any())) :: list(map())
 521   def build_tags(object_tags) when is_list(object_tags) do
 522     object_tags = for tag when is_binary(tag) <- object_tags, do: tag
 523
 524     Enum.reduce(object_tags, [], fn tag, tags ->
 525       tags ++ [%{name: tag, url: "/tag/#{URI.encode(tag)}"}]
 526     end)
 527   end
 528
 529   def build_tags(_), do: []
 530
 531   @doc """
 532   Builds list emojis.
 533
 534   Arguments: `nil` or list tuple of name and url.
 535
 536   Returns list emojis.
 537
 538   ## Examples
 539
 540   iex> Pleroma.Web.MastodonAPI.StatusView.build_emojis([{"2hu", "corndog.png"}])
 541   [%{shortcode: "2hu", static_url: "corndog.png", url: "corndog.png", visible_in_picker: false}]
 542
 543   """
 544   @spec build_emojis(nil | list(tuple())) :: list(map())
 545   def build_emojis(nil), do: []
 546
 547   def build_emojis(emojis) do
 548     emojis
 549     |> Enum.map(fn {name, url} ->
 550       name = HTML.strip_tags(name)
 551
 552       url =
 553         url
 554         |> HTML.strip_tags()
 555         |> MediaProxy.url()
 556
 557       %{shortcode: name, url: url, static_url: url, visible_in_picker: false}
 558     end)
 559   end
 560
 561   defp present?(nil), do: false
 562   defp present?(false), do: false
 563   defp present?(_), do: true
 564
 565   defp pinned?(%Activity{id: id}, %User{info: %{pinned_activities: pinned_activities}}),
 566     do: id in pinned_activities
 567 end