Git of dcc - anni/blob - lib/pleroma/web/static_fe/static_fe_controller.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2022 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}} = 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
  59       timeline =
  60         user
  61         |> ActivityPub.fetch_user_activities(_reading_user = nil, params)
  62         |> Enum.map(&represent/1)
  63
  64       prev_page_id =
  65         (params["min_id"] || params["max_id"]) &&
  66           List.first(timeline) && List.first(timeline).id
  67
  68       next_page_id = List.last(timeline) && List.last(timeline).id
  69
  70       render(conn, "profile.html", %{
  71         user: User.sanitize_html(user),
  72         timeline: timeline,
  73         prev_page_id: prev_page_id,
  74         next_page_id: next_page_id,
  75         meta: meta
  76       })
  77     else
  78       _ ->
  79         not_found(conn, "User not found.")
  80     end
  81   end
  82
  83   def show(%{assigns: %{object_id: _}} = conn, _params) do
  84     url = Helpers.url(conn) <> conn.request_path
  85
  86     case Activity.get_create_by_object_ap_id_with_object(url) do
  87       %Activity{} = activity ->
  88         to = Helpers.o_status_path(Pleroma.Web.Endpoint, :notice, activity)
  89         redirect(conn, to: to)
  90
  91       _ ->
  92         not_found(conn, "Post not found.")
  93     end
  94   end
  95
  96   def show(%{assigns: %{activity_id: _}} = conn, _params) do
  97     url = Helpers.url(conn) <> conn.request_path
  98
  99     case Activity.get_by_ap_id(url) do
 100       %Activity{} = activity ->
 101         to = Helpers.o_status_path(Pleroma.Web.Endpoint, :notice, activity)
 102         redirect(conn, to: to)
 103
 104       _ ->
 105         not_found(conn, "Post not found.")
 106     end
 107   end
 108
 109   defp get_title(%Object{data: %{"name" => name}}) when is_binary(name),
 110     do: name
 111
 112   defp get_title(%Object{data: %{"summary" => summary}}) when is_binary(summary),
 113     do: summary
 114
 115   defp get_title(_), do: nil
 116
 117   defp not_found(conn, message) do
 118     conn
 119     |> put_status(404)
 120     |> render("error.html", %{message: message, meta: ""})
 121   end
 122
 123   defp get_counts(%Activity{} = activity) do
 124     %Object{data: data} = Object.normalize(activity, fetch: false)
 125
 126     %{
 127       likes: data["like_count"] || 0,
 128       replies: data["repliesCount"] || 0,
 129       announces: data["announcement_count"] || 0
 130     }
 131   end
 132
 133   defp represent(%Activity{} = activity), do: represent(activity, false)
 134
 135   defp represent(%Activity{object: %Object{data: data}} = activity, selected) do
 136     {:ok, user} = User.get_or_fetch(activity.object.data["actor"])
 137
 138     link =
 139       case user.local do
 140         true -> Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
 141         _ -> data["url"] || data["external_url"] || data["id"]
 142       end
 143
 144     content =
 145       if data["content"] do
 146         data["content"]
 147         |> Pleroma.HTML.filter_tags()
 148         |> Pleroma.Emoji.Formatter.emojify(Map.get(data, "emoji", %{}))
 149       else
 150         nil
 151       end
 152
 153     %{
 154       user: User.sanitize_html(user),
 155       title: get_title(activity.object),
 156       content: content,
 157       attachment: data["attachment"],
 158       link: link,
 159       published: data["published"],
 160       sensitive: data["sensitive"],
 161       selected: selected,
 162       counts: get_counts(activity),
 163       id: activity.id
 164     }
 165   end
 166
 167   defp assign_id(%{path_info: ["notice", notice_id]} = conn, _opts),
 168     do: assign(conn, :notice_id, notice_id)
 169
 170   defp assign_id(%{path_info: ["users", user_id]} = conn, _opts),
 171     do: assign(conn, :username_or_id, user_id)
 172
 173   defp assign_id(%{path_info: ["objects", object_id]} = conn, _opts),
 174     do: assign(conn, :object_id, object_id)
 175
 176   defp assign_id(%{path_info: ["activities", activity_id]} = conn, _opts),
 177     do: assign(conn, :activity_id, activity_id)
 178
 179   defp assign_id(conn, _opts), do: conn
 180 end