X-Git-Url: https://git.squeep.com/?a=blobdiff_plain;f=lib%2Fpleroma%2Fweb%2Fmastodon_api%2Fviews%2Fstatus_view.ex;h=cc58f803e6b2c7773c96f6b1ad21d7ce0f7830ee;hb=0cfd5b4e89b02688342345755577e58eece3db0f;hp=463f3419855f75d0c4960f09b43d9b3900c87abb;hpb=773708cfe82233071ccbce4e3a7c924c8397bcda;p=akkoma

diff --git a/lib/pleroma/web/mastodon_api/views/status_view.ex b/lib/pleroma/web/mastodon_api/views/status_view.ex
index 463f34198..cc58f803e 100644
--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
@@ -57,11 +57,19 @@ defmodule Pleroma.Web.MastodonAPI.StatusView do
     end)
   end
 
-  defp get_context_id(%{data: %{"context_id" => context_id}}) when not is_nil(context_id),
-    do: context_id
-
-  defp get_context_id(%{data: %{"context" => context}}) when is_binary(context),
-    do: Utils.context_to_conversation_id(context)
+  # DEPRECATED This field seems to be a left-over from the StatusNet era.
+  # If your application uses `pleroma.conversation_id`: this field is deprecated.
+  # It is currently stubbed instead by doing a CRC32 of the context, and
+  # clearing the MSB to avoid overflow exceptions with signed integers on the
+  # different clients using this field (Java/Kotlin code, mostly; see Husky.)
+  # This should be removed in a future version of Pleroma. Pleroma-FE currently
+  # depends on this field, as well.
+  defp get_context_id(%{data: %{"context" => context}}) when is_binary(context) do
+    import Bitwise
+
+    :erlang.crc32(context)
+    |> band(bnot(0x8000_0000))
+  end
 
   defp get_context_id(_), do: nil
 
@@ -80,7 +88,6 @@ defmodule Pleroma.Web.MastodonAPI.StatusView do
 
   def render("index.json", opts) do
     reading_user = opts[:for]
-
     # To do: check AdminAPIControllerTest on the reasons behind nil activities in the list
     activities = Enum.filter(opts.activities, & &1)
 
@@ -202,65 +209,272 @@ defmodule Pleroma.Web.MastodonAPI.StatusView do
   end
 
   def render("show.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
-    object = Object.normalize(activity, fetch: false)
+    with %Object{} = object <- Object.normalize(activity, fetch: false) do
+      user = CommonAPI.get_user(activity.data["actor"])
+      user_follower_address = user.follower_address
+
+      like_count = object.data["like_count"] || 0
+      announcement_count = object.data["announcement_count"] || 0
+
+      hashtags = Object.hashtags(object)
+      sensitive = object.data["sensitive"] || Enum.member?(hashtags, "nsfw")
+
+      tags = Object.tags(object)
+
+      tag_mentions =
+        tags
+        |> Enum.filter(fn tag -> is_map(tag) and tag["type"] == "Mention" end)
+        |> Enum.map(fn tag -> tag["href"] end)
+
+      mentions =
+        (object.data["to"] ++ tag_mentions)
+        |> Enum.uniq()
+        |> Enum.map(fn
+          Pleroma.Constants.as_public() -> nil
+          ^user_follower_address -> nil
+          ap_id -> User.get_cached_by_ap_id(ap_id)
+        end)
+        |> Enum.filter(& &1)
+        |> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)
+
+      favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] || [])
+
+      bookmarked = Activity.get_bookmark(activity, opts[:for]) != nil
+
+      client_posted_this_activity = opts[:for] && user.id == opts[:for].id
+
+      expires_at =
+        with true <- client_posted_this_activity,
+             %Oban.Job{scheduled_at: scheduled_at} <-
+               Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id) do
+          scheduled_at
+        else
+          _ -> nil
+        end
+
+      thread_muted? =
+        cond do
+          is_nil(opts[:for]) -> false
+          is_boolean(activity.thread_muted?) -> activity.thread_muted?
+          true -> CommonAPI.thread_muted?(opts[:for], activity)
+        end
+
+      attachment_data = object.data["attachment"] || []
+      attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)
+
+      created_at = Utils.to_masto_date(object.data["published"])
+
+      edited_at =
+        with %{"updated" => updated} <- object.data,
+             date <- Utils.to_masto_date(updated),
+             true <- date != "" do
+          date
+        else
+          _ ->
+            nil
+        end
+
+      reply_to = get_reply_to(activity, opts)
+
+      reply_to_user = reply_to && CommonAPI.get_user(reply_to.data["actor"])
+
+      history_len =
+        1 +
+          (Object.Updater.history_for(object.data)
+           |> Map.get("orderedItems")
+           |> length())
+
+      # See render("history.json", ...) for more details
+      # Here the implicit index of the current content is 0
+      chrono_order = history_len - 1
+
+      content =
+        object
+        |> render_content()
+
+      content_html =
+        content
+        |> Activity.HTML.get_cached_scrubbed_html_for_activity(
+          User.html_filter_policy(opts[:for]),
+          activity,
+          "mastoapi:content:#{chrono_order}"
+        )
 
-    user = CommonAPI.get_user(activity.data["actor"])
-    user_follower_address = user.follower_address
+      content_plaintext =
+        content
+        |> Activity.HTML.get_cached_stripped_html_for_activity(
+          activity,
+          "mastoapi:content:#{chrono_order}"
+        )
 
-    like_count = object.data["like_count"] || 0
-    announcement_count = object.data["announcement_count"] || 0
+      summary = object.data["summary"] || ""
 
-    hashtags = Object.hashtags(object)
-    sensitive = object.data["sensitive"] || Enum.member?(hashtags, "nsfw")
+      card = render("card.json", Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity))
 
-    tags = Object.tags(object)
+      url =
+        if user.local do
+          Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
+        else
+          object.data["url"] || object.data["external_url"] || object.data["id"]
+        end
+
+      direct_conversation_id =
+        with {_, nil} <- {:direct_conversation_id, opts[:direct_conversation_id]},
+             {_, true} <- {:include_id, opts[:with_direct_conversation_id]},
+             {_, %User{} = for_user} <- {:for_user, opts[:for]} do
+          Activity.direct_conversation_id(activity, for_user)
+        else
+          {:direct_conversation_id, participation_id} when is_integer(participation_id) ->
+            participation_id
+
+          _e ->
+            nil
+        end
+
+      emoji_reactions =
+        object.data
+        |> Map.get("reactions", [])
+        |> EmojiReactionController.filter_allowed_users(
+          opts[:for],
+          Map.get(opts, :with_muted, false)
+        )
+        |> Stream.map(fn {emoji, users, url} ->
+          build_emoji_map(emoji, users, url, opts[:for])
+        end)
+        |> Enum.to_list()
+
+      # Status muted state (would do 1 request per status unless user mutes are preloaded)
+      muted =
+        thread_muted? ||
+          UserRelationship.exists?(
+            get_in(opts, [:relationships, :user_relationships]),
+            :mute,
+            opts[:for],
+            user,
+            fn for_user, user -> User.mutes?(for_user, user) end
+          )
+
+      {pinned?, pinned_at} = pin_data(object, user)
+
+      quote = Activity.get_quoted_activity_from_object(object)
+
+      %{
+        id: to_string(activity.id),
+        uri: object.data["id"],
+        url: url,
+        account:
+          AccountView.render("show.json", %{
+            user: user,
+            for: opts[:for]
+          }),
+        in_reply_to_id: reply_to && to_string(reply_to.id),
+        in_reply_to_account_id: reply_to_user && to_string(reply_to_user.id),
+        reblog: nil,
+        card: card,
+        content: content_html,
+        text: opts[:with_source] && get_source_text(object.data["source"]),
+        created_at: created_at,
+        edited_at: edited_at,
+        reblogs_count: announcement_count,
+        replies_count: object.data["repliesCount"] || 0,
+        favourites_count: like_count,
+        reblogged: reblogged?(activity, opts[:for]),
+        favourited: present?(favorited),
+        bookmarked: present?(bookmarked),
+        muted: muted,
+        pinned: pinned?,
+        sensitive: sensitive,
+        spoiler_text: summary,
+        visibility: get_visibility(object),
+        media_attachments: attachments,
+        poll: render(PollView, "show.json", object: object, for: opts[:for]),
+        mentions: mentions,
+        tags: build_tags(tags),
+        application: build_application(object.data["generator"]),
+        language: nil,
+        emojis: build_emojis(object.data["emoji"]),
+        quote_id: if(quote, do: quote.id, else: nil),
+        quote: maybe_render_quote(quote, opts),
+        emoji_reactions: emoji_reactions,
+        pleroma: %{
+          local: activity.local,
+          conversation_id: get_context_id(activity),
+          context: object.data["context"],
+          in_reply_to_account_acct: reply_to_user && reply_to_user.nickname,
+          content: %{"text/plain" => content_plaintext},
+          spoiler_text: %{"text/plain" => summary},
+          expires_at: expires_at,
+          direct_conversation_id: direct_conversation_id,
+          thread_muted: thread_muted?,
+          emoji_reactions: emoji_reactions,
+          parent_visible: visible_for_user?(reply_to, opts[:for]),
+          pinned_at: pinned_at
+        },
+        akkoma: %{
+          source: object.data["source"]
+        }
+      }
+    else
+      nil -> nil
+    end
+  end
 
-    tag_mentions =
-      tags
-      |> Enum.filter(fn tag -> is_map(tag) and tag["type"] == "Mention" end)
-      |> Enum.map(fn tag -> tag["href"] end)
+  def render("show.json", _) do
+    nil
+  end
 
-    mentions =
-      (object.data["to"] ++ tag_mentions)
-      |> Enum.uniq()
-      |> Enum.map(fn
-        Pleroma.Constants.as_public() -> nil
-        ^user_follower_address -> nil
-        ap_id -> User.get_cached_by_ap_id(ap_id)
-      end)
-      |> Enum.filter(& &1)
-      |> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)
+  def render("history.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
+    object = Object.normalize(activity, fetch: false)
 
-    favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] || [])
+    hashtags = Object.hashtags(object)
 
-    bookmarked = Activity.get_bookmark(activity, opts[:for]) != nil
+    user = CommonAPI.get_user(activity.data["actor"])
 
-    client_posted_this_activity = opts[:for] && user.id == opts[:for].id
+    past_history =
+      Object.Updater.history_for(object.data)
+      |> Map.get("orderedItems")
+      |> Enum.map(&Map.put(&1, "id", object.data["id"]))
+      |> Enum.map(&%Object{data: &1, id: object.id})
 
-    expires_at =
-      with true <- client_posted_this_activity,
-           %Oban.Job{scheduled_at: scheduled_at} <-
-             Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id) do
-        scheduled_at
-      else
-        _ -> nil
-      end
+    history =
+      [object | past_history]
+      # Mastodon expects the original to be at the first
+      |> Enum.reverse()
+      |> Enum.with_index()
+      |> Enum.map(fn {object, chrono_order} ->
+        %{
+          # The history is prepended every time there is a new edit.
+          # In chrono_order, the oldest item is always at 0, and so on.
+          # The chrono_order is an invariant kept between edits.
+          chrono_order: chrono_order,
+          object: object
+        }
+      end)
 
-    thread_muted? =
-      cond do
-        is_nil(opts[:for]) -> false
-        is_boolean(activity.thread_muted?) -> activity.thread_muted?
-        true -> CommonAPI.thread_muted?(opts[:for], activity)
-      end
+    individual_opts =
+      opts
+      |> Map.put(:as, :item)
+      |> Map.put(:user, user)
+      |> Map.put(:hashtags, hashtags)
 
-    attachment_data = object.data["attachment"] || []
-    attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)
+    render_many(history, StatusView, "history_item.json", individual_opts)
+  end
 
-    created_at = Utils.to_masto_date(object.data["published"])
+  def render(
+        "history_item.json",
+        %{
+          activity: activity,
+          user: user,
+          item: %{object: object, chrono_order: chrono_order},
+          hashtags: hashtags
+        } = opts
+      ) do
+    sensitive = object.data["sensitive"] || Enum.member?(hashtags, "nsfw")
 
-    reply_to = get_reply_to(activity, opts)
+    attachment_data = object.data["attachment"] || []
+    attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)
 
-    reply_to_user = reply_to && CommonAPI.get_user(reply_to.data["actor"])
+    created_at = Utils.to_masto_date(object.data["updated"] || object.data["published"])
 
     content =
       object
@@ -271,117 +485,36 @@ defmodule Pleroma.Web.MastodonAPI.StatusView do
       |> Activity.HTML.get_cached_scrubbed_html_for_activity(
         User.html_filter_policy(opts[:for]),
         activity,
-        "mastoapi:content"
-      )
-
-    content_plaintext =
-      content
-      |> Activity.HTML.get_cached_stripped_html_for_activity(
-        activity,
-        "mastoapi:content"
+        "mastoapi:content:#{chrono_order}"
       )
 
     summary = object.data["summary"] || ""
 
-    card = render("card.json", Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity))
-
-    url =
-      if user.local do
-        Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
-      else
-        object.data["url"] || object.data["external_url"] || object.data["id"]
-      end
-
-    direct_conversation_id =
-      with {_, nil} <- {:direct_conversation_id, opts[:direct_conversation_id]},
-           {_, true} <- {:include_id, opts[:with_direct_conversation_id]},
-           {_, %User{} = for_user} <- {:for_user, opts[:for]} do
-        Activity.direct_conversation_id(activity, for_user)
-      else
-        {:direct_conversation_id, participation_id} when is_integer(participation_id) ->
-          participation_id
-
-        _e ->
-          nil
-      end
-
-    emoji_reactions =
-      object.data
-      |> Map.get("reactions", [])
-      |> EmojiReactionController.filter_allowed_users(
-        opts[:for],
-        Map.get(opts, :with_muted, false)
-      )
-      |> Stream.map(fn {emoji, users} ->
-        build_emoji_map(emoji, users, opts[:for])
-      end)
-      |> Enum.to_list()
-
-    # Status muted state (would do 1 request per status unless user mutes are preloaded)
-    muted =
-      thread_muted? ||
-        UserRelationship.exists?(
-          get_in(opts, [:relationships, :user_relationships]),
-          :mute,
-          opts[:for],
-          user,
-          fn for_user, user -> User.mutes?(for_user, user) end
-        )
-
-    {pinned?, pinned_at} = pin_data(object, user)
-
     %{
-      id: to_string(activity.id),
-      uri: object.data["id"],
-      url: url,
       account:
         AccountView.render("show.json", %{
           user: user,
           for: opts[:for]
         }),
-      in_reply_to_id: reply_to && to_string(reply_to.id),
-      in_reply_to_account_id: reply_to_user && to_string(reply_to_user.id),
-      reblog: nil,
-      card: card,
       content: content_html,
-      text: opts[:with_source] && object.data["source"],
-      created_at: created_at,
-      reblogs_count: announcement_count,
-      replies_count: object.data["repliesCount"] || 0,
-      favourites_count: like_count,
-      reblogged: reblogged?(activity, opts[:for]),
-      favourited: present?(favorited),
-      bookmarked: present?(bookmarked),
-      muted: muted,
-      pinned: pinned?,
       sensitive: sensitive,
       spoiler_text: summary,
-      visibility: get_visibility(object),
+      created_at: created_at,
       media_attachments: attachments,
-      poll: render(PollView, "show.json", object: object, for: opts[:for]),
-      mentions: mentions,
-      tags: build_tags(tags),
-      application: build_application(object.data["generator"]),
-      language: nil,
       emojis: build_emojis(object.data["emoji"]),
-      pleroma: %{
-        local: activity.local,
-        conversation_id: get_context_id(activity),
-        in_reply_to_account_acct: reply_to_user && reply_to_user.nickname,
-        content: %{"text/plain" => content_plaintext},
-        spoiler_text: %{"text/plain" => summary},
-        expires_at: expires_at,
-        direct_conversation_id: direct_conversation_id,
-        thread_muted: thread_muted?,
-        emoji_reactions: emoji_reactions,
-        parent_visible: visible_for_user?(reply_to, opts[:for]),
-        pinned_at: pinned_at
-      }
+      poll: render(PollView, "show.json", object: object, for: opts[:for])
     }
   end
 
-  def render("show.json", _) do
-    nil
+  def render("source.json", %{activity: %{data: %{"object" => _object}} = activity} = _opts) do
+    object = Object.normalize(activity, fetch: false)
+
+    %{
+      id: activity.id,
+      text: get_source_text(Map.get(object.data, "source", "")),
+      spoiler_text: Map.get(object.data, "summary", ""),
+      content_type: get_source_content_type(object.data["source"])
+    }
   end
 
   def render("card.json", %{rich_media: rich_media, page_url: page_url}) do
@@ -436,10 +569,19 @@ defmodule Pleroma.Web.MastodonAPI.StatusView do
         true -> "unknown"
       end
 
-    <<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)
+    attachment_id =
+      with {_, ap_id} when is_binary(ap_id) <- {:ap_id, attachment["id"]},
+           {_, %Object{data: _object_data, id: object_id}} <-
+             {:object, Object.get_by_ap_id(ap_id)} do
+        to_string(object_id)
+      else
+        _ ->
+          <<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)
+          to_string(attachment["id"] || hash_id)
+      end
 
     %{
-      id: to_string(attachment["id"] || hash_id),
+      id: attachment_id,
       url: href,
       remote_url: href,
       preview_url: href_preview,
@@ -569,11 +711,13 @@ defmodule Pleroma.Web.MastodonAPI.StatusView do
     end
   end
 
-  defp build_emoji_map(emoji, users, current_user) do
+  defp build_emoji_map(emoji, users, url, current_user) do
     %{
-      name: emoji,
+      name: Pleroma.Web.PleromaAPI.EmojiReactionView.emoji_name(emoji, url),
       count: length(users),
-      me: !!(current_user && current_user.ap_id in users)
+      url: MediaProxy.url(url),
+      me: !!(current_user && current_user.ap_id in users),
+      account_ids: Enum.map(users, fn user -> User.get_cached_by_ap_id(user).id end)
     }
   end
 
@@ -601,4 +745,43 @@ defmodule Pleroma.Web.MastodonAPI.StatusView do
   end
 
   defp build_image_url(_, _), do: nil
+
+  defp maybe_render_quote(nil, _), do: nil
+
+  defp maybe_render_quote(quote, opts) do
+    with %User{} = quoted_user <- User.get_cached_by_ap_id(quote.actor),
+         false <- Map.get(opts, :do_not_recurse, false),
+         true <- visible_for_user?(quote, opts[:for]),
+         false <- User.blocks?(opts[:for], quoted_user),
+         false <- User.mutes?(opts[:for], quoted_user) do
+      opts =
+        opts
+        |> Map.put(:activity, quote)
+        |> Map.put(:do_not_recurse, true)
+
+      render("show.json", opts)
+    else
+      _ -> nil
+    end
+  end
+
+  defp get_source_text(%{"content" => content} = _source) do
+    content
+  end
+
+  defp get_source_text(source) when is_binary(source) do
+    source
+  end
+
+  defp get_source_text(_) do
+    ""
+  end
+
+  defp get_source_content_type(%{"mediaType" => type} = _source) do
+    type
+  end
+
+  defp get_source_content_type(_source) do
+    Utils.get_content_type(nil)
+  end
 end