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