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_binary(value) or is_map(value) or is_number(value), do: value
  81
  82   defp do_convert(value) when is_atom(value) do
  83     string = to_string(value)
  84
  85     if String.starts_with?(string, "Elixir."),
  86       do: String.trim_leading(string, "Elixir."),
  87       else: value
  88   end
  89
  90   @spec transform(any()) :: binary()
  91   def transform(entity) when is_map(entity) do
  92     tuples =
  93       for {k, v} <- entity,
  94           into: [],
  95           do: {if(is_atom(k), do: k, else: String.to_atom(k)), do_transform(v)}
  96
  97     Enum.reject(tuples, fn {_k, v} -> is_nil(v) end)
  98     |> Enum.sort()
  99     |> :erlang.term_to_binary()
 100   end
 101
 102   def transform(entity) when is_list(entity) do
 103     list = Enum.map(entity, &do_transform(&1))
 104     :erlang.term_to_binary(list)
 105   end
 106
 107   def transform(entity), do: :erlang.term_to_binary(entity)
 108
 109   defp do_transform(%Regex{} = value) when is_map(value), do: value
 110
 111   defp do_transform(value) when is_map(value) do
 112     values =
 113       for {key, val} <- value,
 114           into: [],
 115           do: {String.to_atom(key), do_transform(val)}
 116
 117     Enum.sort(values)
 118   end
 119
 120   defp do_transform(value) when is_list(value) do
 121     Enum.map(value, &do_transform(&1))
 122   end
 123
 124   defp do_transform(entity) when is_list(entity) and length(entity) == 1, do: hd(entity)
 125
 126   defp do_transform(value) when is_binary(value) do
 127     value = String.trim(value)
 128
 129     case String.length(value) do
 130       0 ->
 131         nil
 132
 133       _ ->
 134         cond do
 135           String.starts_with?(value, "Pleroma") ->
 136             String.to_existing_atom("Elixir." <> value)
 137
 138           String.starts_with?(value, ":") ->
 139             String.replace(value, ":", "") |> String.to_existing_atom()
 140
 141           String.starts_with?(value, "i:") ->
 142             String.replace(value, "i:", "") |> String.to_integer()
 143
 144           true ->
 145             value
 146         end
 147     end
 148   end
 149
 150   defp do_transform(value), do: value
 151 end