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