git.squeep.com Git - akkoma/blob - lib/pleroma/web/static_fe/static_fe_controller.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.StaticFE.StaticFEController do
   6   use Pleroma.Web, :controller
   7
   8   alias Pleroma.Activity
   9   alias Pleroma.Object
  10   alias Pleroma.User
  11   alias Pleroma.Web.ActivityPub.ActivityPub
  12   alias Pleroma.Web.ActivityPub.Visibility
  13   alias Pleroma.Web.Metadata
  14   alias Pleroma.Web.Router.Helpers
  15
  16   plug(:put_layout, :static_fe)
  17   plug(:assign_id)
  18
  19   @page_keys ["max_id", "min_id", "limit", "since_id", "order"]
  20
  21   @doc "Renders requested local public activity or public activities of requested user"
  22   def show(%{assigns: %{notice_id: notice_id}} = conn, _params) do
  23     with %Activity{local: true} = activity <-
  24            Activity.get_by_id_with_object(notice_id),
  25          true <- Visibility.is_public?(activity.object),
  26          {_, true} <- {:visible?, Visibility.visible_for_user?(activity, _reading_user = nil)},
  27          %User{} = user <- User.get_by_ap_id(activity.object.data["actor"]) do
  28       meta = Metadata.build_tags(%{activity_id: notice_id, object: activity.object, user: user})
  29
  30       timeline =
  31         activity.object.data["context"]
  32         |> ActivityPub.fetch_activities_for_context(%{})
  33         |> Enum.reverse()
  34         |> Enum.map(&represent(&1, &1.object.id == activity.object.id))
  35
  36       render(conn, "conversation.html", %{activities: timeline, meta: meta})
  37     else
  38       %Activity{object: %Object{data: data}} ->
  39         conn
  40         |> put_status(:found)
  41         |> redirect(external: data["url"] || data["external_url"] || data["id"])
  42
  43       _ ->
  44         not_found(conn, "Post not found.")
  45     end
  46   end
  47
  48   def show(%{assigns: %{username_or_id: username_or_id, tab: tab}} = conn, params) do
  49     with {_, %User{local: true} = user} <-
  50            {:fetch_user, User.get_cached_by_nickname_or_id(username_or_id)},
  51          {_, :visible} <- {:visibility, User.visible_for(user, _reading_user = nil)} do
  52       meta = Metadata.build_tags(%{user: user})
  53
  54       params =
  55         params
  56         |> Map.take(@page_keys)
  57         |> Map.new(fn {k, v} -> {String.to_existing_atom(k), v} end)
  58         |> Map.put(:limit, 20)
  59
  60       params =
  61         case tab do
  62           "posts" ->
  63             Map.put(params, :exclude_replies, true)
  64
  65           "media" ->
  66             Map.put(params, :only_media, true)
  67
  68           _ ->
  69             params
  70         end
  71
  72       timeline =
  73         case tab do
  74           tab when tab in ["posts", "with_replies", "media"] ->
  75             user
  76             |> ActivityPub.fetch_user_activities(_reading_user = nil, params)
  77             |> Enum.map(&represent/1)
  78
  79           "following" when not user.hide_follows ->
  80             User.get_friends(user)
  81
  82           "followers" when not user.hide_followers ->
  83             User.get_followers(user)
  84
  85           _ ->
  86             []
  87         end
  88
  89       prev_page_id =
  90         (params["min_id"] || params["max_id"]) &&
  91           List.first(timeline) && List.first(timeline).id
  92
  93       next_page_id = List.last(timeline) && List.last(timeline).id
  94
  95       render(conn, "profile.html", %{
  96         user: User.sanitize_html(user),
  97         timeline: timeline,
  98         prev_page_id: prev_page_id,
  99         next_page_id: next_page_id,
 100         meta: meta
 101       })
 102     else
 103       {_, %User{} = user} ->
 104         conn
 105         |> put_status(:found)
 106         |> redirect(external: user.uri || user.ap_id)
 107
 108       _ ->
 109         not_found(conn, "User not found.")
 110     end
 111   end
 112
 113   def show(%{assigns: %{object_id: _}} = conn, _params) do
 114     url = Helpers.url(conn) <> conn.request_path
 115
 116     case Activity.get_create_by_object_ap_id_with_object(url) do
 117       %Activity{} = activity ->
 118         to = Helpers.o_status_path(Pleroma.Web.Endpoint, :notice, activity)
 119         redirect(conn, to: to)
 120
 121       _ ->
 122         not_found(conn, "Post not found.")
 123     end
 124   end
 125
 126   def show(%{assigns: %{activity_id: _}} = conn, _params) do
 127     url = Helpers.url(conn) <> conn.request_path
 128
 129     case Activity.get_by_ap_id(url) do
 130       %Activity{} = activity ->
 131         to = Helpers.o_status_path(Pleroma.Web.Endpoint, :notice, activity)
 132         redirect(conn, to: to)
 133
 134       _ ->
 135         not_found(conn, "Post not found.")
 136     end
 137   end
 138
 139   defp get_title(%Object{data: %{"name" => name}}) when is_binary(name),
 140     do: name
 141
 142   defp get_title(%Object{data: %{"summary" => summary}}) when is_binary(summary),
 143     do: summary
 144
 145   defp get_title(_), do: nil
 146
 147   defp not_found(conn, message) do
 148     conn
 149     |> put_status(404)
 150     |> render("error.html", %{message: message, meta: ""})
 151   end
 152
 153   defp get_counts(%Activity{} = activity) do
 154     %Object{data: data} = Object.normalize(activity, fetch: false)
 155
 156     %{
 157       likes: data["like_count"] || 0,
 158       replies: data["repliesCount"] || 0,
 159       announces: data["announcement_count"] || 0
 160     }
 161   end
 162
 163   defp represent(%Activity{} = activity), do: represent(activity, false)
 164
 165   defp represent(%Activity{object: %Object{data: data}} = activity, selected) do
 166     {:ok, user} = User.get_or_fetch(activity.object.data["actor"])
 167
 168     link =
 169       case user.local do
 170         true -> Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
 171         _ -> data["url"] || data["external_url"] || data["id"]
 172       end
 173
 174     content =
 175       if data["content"] do
 176         data["content"]
 177         |> Pleroma.HTML.filter_tags()
 178         |> Pleroma.Emoji.Formatter.emojify(Map.get(data, "emoji", %{}))
 179       else
 180         nil
 181       end
 182
 183     reply_to_user =
 184       if data["inReplyTo"] do
 185         activity
 186         |> Activity.get_in_reply_to_activity()
 187         |> Map.get(:actor)
 188         |> User.get_cached_by_ap_id()
 189       else
 190         nil
 191       end
 192
 193     total_votes =
 194       if data["oneOf"] do
 195         Enum.sum(for option <- data["oneOf"], do: option["replies"]["totalItems"])
 196       else
 197         0
 198       end
 199
 200     %{
 201       user: User.sanitize_html(user),
 202       title: get_title(activity.object),
 203       content: content,
 204       attachment: data["attachment"],
 205       link: link,
 206       published: data["published"],
 207       sensitive: data["sensitive"],
 208       selected: selected,
 209       counts: get_counts(activity),
 210       id: activity.id,
 211       visibility: Visibility.get_visibility(activity.object),
 212       reply_to: data["inReplyTo"],
 213       reply_to_user: reply_to_user,
 214       edited_at: data["updated"],
 215       poll: data["oneOf"],
 216       total_votes: total_votes
 217     }
 218   end
 219
 220   defp assign_id(%{path_info: ["notice", notice_id]} = conn, _opts),
 221     do: assign(conn, :notice_id, notice_id)
 222
 223   defp assign_id(%{path_info: ["@" <> _nickname, notice_id]} = conn, _opts),
 224     do: assign(conn, :notice_id, notice_id)
 225
 226   defp assign_id(%{path_info: ["@" <> _nickname, "posts", notice_id]} = conn, _opts),
 227     do: assign(conn, :notice_id, notice_id)
 228
 229   defp assign_id(%{path_info: [_nickname, "status", notice_id]} = conn, _opts),
 230     do: assign(conn, :notice_id, notice_id)
 231
 232   defp assign_id(%{path_info: ["users", user_id]} = conn, _opts),
 233     do:
 234       conn
 235       |> assign(:username_or_id, user_id)
 236       |> assign(:tab, "posts")
 237
 238   defp assign_id(%{path_info: ["users", user_id, tab]} = conn, _opts),
 239     do:
 240       conn
 241       |> assign(:username_or_id, user_id)
 242       |> assign(:tab, tab)
 243
 244   defp assign_id(%{path_info: ["objects", object_id]} = conn, _opts),
 245     do: assign(conn, :object_id, object_id)
 246
 247   defp assign_id(%{path_info: ["activities", activity_id]} = conn, _opts),
 248     do: assign(conn, :activity_id, activity_id)
 249
 250   defp assign_id(conn, _opts), do: conn
 251 end