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