git.squeep.com Git - akkoma/blob - lib/pleroma/web/pleroma_api/controllers/emoji_pack_controller.ex

   1 defmodule Pleroma.Web.PleromaAPI.EmojiPackController do
   2   use Pleroma.Web, :controller
   3
   4   alias Pleroma.Emoji.Pack
   5
   6   plug(Pleroma.Web.ApiSpec.CastAndValidate)
   7
   8   plug(
   9     Pleroma.Plugs.OAuthScopesPlug,
  10     %{scopes: ["write"], admin: true}
  11     when action in [
  12            :import_from_filesystem,
  13            :remote,
  14            :download,
  15            :create,
  16            :update,
  17            :delete
  18          ]
  19   )
  20
  21   @skip_plugs [Pleroma.Plugs.OAuthScopesPlug, Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug]
  22   plug(:skip_plug, @skip_plugs when action in [:index, :show, :archive])
  23
  24   defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.PleromaEmojiPackOperation
  25
  26   def remote(conn, %{url: url}) do
  27     with {:ok, packs} <- Pack.list_remote(url) do
  28       json(conn, packs)
  29     else
  30       {:error, :not_shareable} ->
  31         conn
  32         |> put_status(:internal_server_error)
  33         |> json(%{error: "The requested instance does not support sharing emoji packs"})
  34     end
  35   end
  36
  37   def index(conn, params) do
  38     emoji_path =
  39       [:instance, :static_dir]
  40       |> Pleroma.Config.get!()
  41       |> Path.join("emoji")
  42
  43     with {:ok, packs, count} <- Pack.list_local(page: params.page, page_size: params.page_size) do
  44       json(conn, %{packs: packs, count: count})
  45     else
  46       {:error, :create_dir, e} ->
  47         conn
  48         |> put_status(:internal_server_error)
  49         |> json(%{error: "Failed to create the emoji pack directory at #{emoji_path}: #{e}"})
  50
  51       {:error, :ls, e} ->
  52         conn
  53         |> put_status(:internal_server_error)
  54         |> json(%{
  55           error: "Failed to get the contents of the emoji pack directory at #{emoji_path}: #{e}"
  56         })
  57     end
  58   end
  59
  60   def show(conn, %{name: name, page: page, page_size: page_size}) do
  61     name = String.trim(name)
  62
  63     with {:ok, pack} <- Pack.show(name: name, page: page, page_size: page_size) do
  64       json(conn, pack)
  65     else
  66       {:error, :not_found} ->
  67         conn
  68         |> put_status(:not_found)
  69         |> json(%{error: "Pack #{name} does not exist"})
  70
  71       {:error, :empty_values} ->
  72         conn
  73         |> put_status(:bad_request)
  74         |> json(%{error: "pack name cannot be empty"})
  75     end
  76   end
  77
  78   def archive(conn, %{name: name}) do
  79     with {:ok, archive} <- Pack.get_archive(name) do
  80       send_download(conn, {:binary, archive}, filename: "#{name}.zip")
  81     else
  82       {:error, :cant_download} ->
  83         conn
  84         |> put_status(:forbidden)
  85         |> json(%{
  86           error:
  87             "Pack #{name} cannot be downloaded from this instance, either pack sharing was disabled for this pack or some files are missing"
  88         })
  89
  90       {:error, :not_found} ->
  91         conn
  92         |> put_status(:not_found)
  93         |> json(%{error: "Pack #{name} does not exist"})
  94     end
  95   end
  96
  97   def download(%{body_params: %{url: url, name: name} = params} = conn, _) do
  98     with {:ok, _pack} <- Pack.download(name, url, params[:as]) do
  99       json(conn, "ok")
 100     else
 101       {:error, :not_shareable} ->
 102         conn
 103         |> put_status(:internal_server_error)
 104         |> json(%{error: "The requested instance does not support sharing emoji packs"})
 105
 106       {:error, :invalid_checksum} ->
 107         conn
 108         |> put_status(:internal_server_error)
 109         |> json(%{error: "SHA256 for the pack doesn't match the one sent by the server"})
 110
 111       {:error, e} ->
 112         conn
 113         |> put_status(:internal_server_error)
 114         |> json(%{error: e})
 115     end
 116   end
 117
 118   def create(conn, %{name: name}) do
 119     name = String.trim(name)
 120
 121     with {:ok, _pack} <- Pack.create(name) do
 122       json(conn, "ok")
 123     else
 124       {:error, :eexist} ->
 125         conn
 126         |> put_status(:conflict)
 127         |> json(%{error: "A pack named \"#{name}\" already exists"})
 128
 129       {:error, :empty_values} ->
 130         conn
 131         |> put_status(:bad_request)
 132         |> json(%{error: "pack name cannot be empty"})
 133
 134       {:error, _} ->
 135         render_error(
 136           conn,
 137           :internal_server_error,
 138           "Unexpected error occurred while creating pack."
 139         )
 140     end
 141   end
 142
 143   def delete(conn, %{name: name}) do
 144     name = String.trim(name)
 145
 146     with {:ok, deleted} when deleted != [] <- Pack.delete(name) do
 147       json(conn, "ok")
 148     else
 149       {:ok, []} ->
 150         conn
 151         |> put_status(:not_found)
 152         |> json(%{error: "Pack #{name} does not exist"})
 153
 154       {:error, :empty_values} ->
 155         conn
 156         |> put_status(:bad_request)
 157         |> json(%{error: "pack name cannot be empty"})
 158
 159       {:error, _, _} ->
 160         conn
 161         |> put_status(:internal_server_error)
 162         |> json(%{error: "Couldn't delete the pack #{name}"})
 163     end
 164   end
 165
 166   def update(%{body_params: %{metadata: metadata}} = conn, %{name: name}) do
 167     with {:ok, pack} <- Pack.update_metadata(name, metadata) do
 168       json(conn, pack.pack)
 169     else
 170       {:error, :incomplete} ->
 171         conn
 172         |> put_status(:bad_request)
 173         |> json(%{error: "The fallback archive does not have all files specified in pack.json"})
 174
 175       {:error, _} ->
 176         render_error(
 177           conn,
 178           :internal_server_error,
 179           "Unexpected error occurred while updating pack metadata."
 180         )
 181     end
 182   end
 183
 184   def import_from_filesystem(conn, _params) do
 185     with {:ok, names} <- Pack.import_from_filesystem() do
 186       json(conn, names)
 187     else
 188       {:error, :no_read_write} ->
 189         conn
 190         |> put_status(:internal_server_error)
 191         |> json(%{error: "Error: emoji pack directory must be writable"})
 192
 193       {:error, _} ->
 194         conn
 195         |> put_status(:internal_server_error)
 196         |> json(%{error: "Error accessing emoji pack directory"})
 197     end
 198   end
 199 end