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