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