git.squeep.com Git - akkoma/blob - lib/pleroma/web/admin_api/config.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.AdminAPI.Config do
   6   use Ecto.Schema
   7   import Ecto.Changeset
   8   import Pleroma.Web.Gettext
   9   alias __MODULE__
  10   alias Pleroma.Repo
  11
  12   @type t :: %__MODULE__{}
  13
  14   schema "config" do
  15     field(:key, :string)
  16     field(:group, :string)
  17     field(:value, :binary)
  18
  19     timestamps()
  20   end
  21
  22   @spec get_by_params(map()) :: Config.t() | nil
  23   def get_by_params(params), do: Repo.get_by(Config, params)
  24
  25   @spec changeset(Config.t(), map()) :: Changeset.t()
  26   def changeset(config, params \\ %{}) do
  27     config
  28     |> cast(params, [:key, :group, :value])
  29     |> validate_required([:key, :group, :value])
  30     |> unique_constraint(:key, name: :config_group_key_index)
  31   end
  32
  33   @spec create(map()) :: {:ok, Config.t()} | {:error, Changeset.t()}
  34   def create(params) do
  35     %Config{}
  36     |> changeset(Map.put(params, :value, transform(params[:value])))
  37     |> Repo.insert()
  38   end
  39
  40   @spec update(Config.t(), map()) :: {:ok, Config} | {:error, Changeset.t()}
  41   def update(%Config{} = config, %{value: value}) do
  42     config
  43     |> change(value: transform(value))
  44     |> Repo.update()
  45   end
  46
  47   @spec update_or_create(map()) :: {:ok, Config.t()} | {:error, Changeset.t()}
  48   def update_or_create(params) do
  49     with %Config{} = config <- Config.get_by_params(Map.take(params, [:group, :key])) do
  50       Config.update(config, params)
  51     else
  52       nil -> Config.create(params)
  53     end
  54   end
  55
  56   @spec delete(map()) :: {:ok, Config.t()} | {:error, Changeset.t()}
  57   def delete(params) do
  58     with %Config{} = config <- Config.get_by_params(params) do
  59       Repo.delete(config)
  60     else
  61       nil ->
  62         err =
  63           dgettext("errors", "Config with params %{params} not found", params: inspect(params))
  64
  65         {:error, err}
  66     end
  67   end
  68
  69   @spec from_binary(binary()) :: term()
  70   def from_binary(value), do: :erlang.binary_to_term(value)
  71
  72   @spec from_binary_to_map(binary()) :: any()
  73   def from_binary_to_map(binary) do
  74     from_binary(binary)
  75     |> do_convert()
  76   end
  77
  78   defp do_convert([{k, v}] = value) when is_list(value) and length(value) == 1,
  79     do: %{k => do_convert(v)}
  80
  81   defp do_convert(values) when is_list(values), do: for(val <- values, do: do_convert(val))
  82
  83   defp do_convert({k, v} = value) when is_tuple(value),
  84     do: %{k => do_convert(v)}
  85
  86   defp do_convert(value) when is_tuple(value), do: %{"tuple" => do_convert(Tuple.to_list(value))}
  87
  88   defp do_convert(value) when is_binary(value) or is_map(value) or is_number(value), do: value
  89
  90   defp do_convert(value) when is_atom(value) do
  91     string = to_string(value)
  92
  93     if String.starts_with?(string, "Elixir."),
  94       do: String.trim_leading(string, "Elixir."),
  95       else: value
  96   end
  97
  98   @spec transform(any()) :: binary()
  99   def transform(%{"tuple" => _} = entity), do: :erlang.term_to_binary(do_transform(entity))
 100
 101   def transform(entity) when is_map(entity) do
 102     tuples =
 103       for {k, v} <- entity,
 104           into: [],
 105           do: {if(is_atom(k), do: k, else: String.to_atom(k)), do_transform(v)}
 106
 107     Enum.reject(tuples, fn {_k, v} -> is_nil(v) end)
 108     |> Enum.sort()
 109     |> :erlang.term_to_binary()
 110   end
 111
 112   def transform(entity) when is_list(entity) do
 113     list = Enum.map(entity, &do_transform(&1))
 114     :erlang.term_to_binary(list)
 115   end
 116
 117   def transform(entity), do: :erlang.term_to_binary(entity)
 118
 119   defp do_transform(%Regex{} = value) when is_map(value), do: value
 120
 121   defp do_transform(%{"tuple" => [k, values] = entity}) when length(entity) == 2 do
 122     {do_transform(k), do_transform(values)}
 123   end
 124
 125   defp do_transform(%{"tuple" => values}) do
 126     Enum.reduce(values, {}, fn val, acc -> Tuple.append(acc, do_transform(val)) end)
 127   end
 128
 129   defp do_transform(value) when is_map(value) do
 130     values = for {key, val} <- value, into: [], do: {String.to_atom(key), do_transform(val)}
 131
 132     Enum.sort(values)
 133   end
 134
 135   defp do_transform(value) when is_list(value) do
 136     Enum.map(value, &do_transform(&1))
 137   end
 138
 139   defp do_transform(entity) when is_list(entity) and length(entity) == 1, do: hd(entity)
 140
 141   defp do_transform(value) when is_binary(value) do
 142     String.trim(value)
 143     |> do_transform_string()
 144   end
 145
 146   defp do_transform(value), do: value
 147
 148   defp do_transform_string(value) when byte_size(value) == 0, do: nil
 149
 150   defp do_transform_string(value) do
 151     cond do
 152       String.starts_with?(value, "Pleroma") or String.starts_with?(value, "Phoenix") ->
 153         String.to_existing_atom("Elixir." <> value)
 154
 155       String.starts_with?(value, ":") ->
 156         String.replace(value, ":", "") |> String.to_existing_atom()
 157
 158       String.starts_with?(value, "i:") ->
 159         String.replace(value, "i:", "") |> String.to_integer()
 160
 161       true ->
 162         value
 163     end
 164   end
 165 end