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