1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.AdminAPI.Config do
11 @type t :: %__MODULE__{}
15 field(:group, :string)
16 field(:value, :binary)
21 @spec get_by_params(map()) :: Config.t() | nil
22 def get_by_params(params), do: Repo.get_by(Config, params)
24 @spec changeset(Config.t(), map()) :: Changeset.t()
25 def changeset(config, params \\ %{}) do
27 |> cast(params, [:key, :group, :value])
28 |> validate_required([:key, :group, :value])
29 |> unique_constraint(:key, name: :config_group_key_index)
32 @spec create(map()) :: {:ok, Config.t()} | {:error, Changeset.t()}
35 |> changeset(Map.put(params, :value, transform(params[:value])))
39 @spec update(Config.t(), map()) :: {:ok, Config} | {:error, Changeset.t()}
40 def update(%Config{} = config, %{value: value}) do
42 |> change(value: transform(value))
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)
51 nil -> Config.create(params)
55 @spec delete(map()) :: {:ok, Config.t()} | {:error, Changeset.t()}
57 with %Config{} = config <- Config.get_by_params(params) do
60 nil -> {:error, "Config with params #{inspect(params)} not found"}
64 @spec from_binary(binary()) :: term()
65 def from_binary(value), do: :erlang.binary_to_term(value)
67 @spec from_binary_to_map(binary()) :: any()
68 def from_binary_to_map(binary) do
73 defp do_convert([{k, v}] = value) when is_list(value) and length(value) == 1,
74 do: %{k => do_convert(v)}
76 defp do_convert(values) when is_list(values), do: for(val <- values, do: do_convert(val))
78 defp do_convert({k, v} = value) when is_tuple(value),
79 do: %{k => do_convert(v)}
81 defp do_convert(value) when is_tuple(value), do: %{"tuple" => do_convert(Tuple.to_list(value))}
83 defp do_convert(value) when is_binary(value) or is_map(value) or is_number(value), do: value
85 defp do_convert(value) when is_atom(value) do
86 string = to_string(value)
88 if String.starts_with?(string, "Elixir."),
89 do: String.trim_leading(string, "Elixir."),
93 @spec transform(any()) :: binary()
94 def transform(%{"tuple" => _} = entity), do: :erlang.term_to_binary(do_transform(entity))
96 def transform(entity) when is_map(entity) do
100 do: {if(is_atom(k), do: k, else: String.to_atom(k)), do_transform(v)}
102 Enum.reject(tuples, fn {_k, v} -> is_nil(v) end)
104 |> :erlang.term_to_binary()
107 def transform(entity) when is_list(entity) do
108 list = Enum.map(entity, &do_transform(&1))
109 :erlang.term_to_binary(list)
112 def transform(entity), do: :erlang.term_to_binary(entity)
114 defp do_transform(%Regex{} = value) when is_map(value), do: value
116 defp do_transform(%{"tuple" => [k, values] = entity}) when length(entity) == 2 do
117 {do_transform(k), do_transform(values)}
120 defp do_transform(%{"tuple" => values}) do
121 Enum.reduce(values, {}, fn val, acc -> Tuple.append(acc, do_transform(val)) end)
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)}
130 defp do_transform(value) when is_list(value) do
131 Enum.map(value, &do_transform(&1))
134 defp do_transform(entity) when is_list(entity) and length(entity) == 1, do: hd(entity)
136 defp do_transform(value) when is_binary(value) do
138 |> do_transform_string()
141 defp do_transform(value), do: value
143 defp do_transform_string(value) when byte_size(value) == 0, do: nil
145 defp do_transform_string(value) do
147 String.starts_with?(value, "Pleroma") or String.starts_with?(value, "Phoenix") ->
148 String.to_existing_atom("Elixir." <> value)
150 String.starts_with?(value, ":") ->
151 String.replace(value, ":", "") |> String.to_existing_atom()
153 String.starts_with?(value, "i:") ->
154 String.replace(value, "i:", "") |> String.to_integer()