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