defmodule Pleroma.ConfigDB do
use Ecto.Schema
import Ecto.Changeset
+ import Ecto.Query
import Pleroma.Web.Gettext
alias __MODULE__
alias Pleroma.Repo
field(:key, :string)
field(:group, :string)
field(:value, :binary)
+ field(:db, {:array, :string}, virtual: true, default: [])
timestamps()
end
+ @spec get_all_as_keyword() :: keyword()
+ def get_all_as_keyword do
+ ConfigDB
+ |> select([c], {c.group, c.key, c.value})
+ |> Repo.all()
+ |> Enum.reduce([], fn {group, key, value}, acc ->
+ group = ConfigDB.from_string(group)
+ key = ConfigDB.from_string(key)
+ value = from_binary(value)
+
+ Keyword.update(acc, group, [{key, value}], &Keyword.merge(&1, [{key, value}]))
+ end)
+ end
+
@spec get_by_params(map()) :: ConfigDB.t() | nil
def get_by_params(params), do: Repo.get_by(ConfigDB, params)
|> Repo.update()
end
+ @spec get_db_keys(ConfigDB.t()) :: [String.t()]
+ def get_db_keys(%ConfigDB{} = config) do
+ config.value
+ |> ConfigDB.from_binary()
+ |> get_db_keys(config.key)
+ end
+
+ @spec get_db_keys(keyword(), any()) :: [String.t()]
+ def get_db_keys(value, key) do
+ if Keyword.keyword?(value) do
+ value |> Keyword.keys() |> Enum.map(&convert(&1))
+ else
+ [convert(key)]
+ end
+ end
+
+ @full_subkey_update [
+ {:pleroma, :assets, :mascots},
+ {:pleroma, :emoji, :groups},
+ {:pleroma, :workers, :retries},
+ {:pleroma, :mrf_subchain, :match_actor},
+ {:pleroma, :mrf_keyword, :replace}
+ ]
+
+ @spec deep_merge(atom(), atom(), keyword(), keyword()) :: keyword()
+ def deep_merge(group, key, old_value, new_value) do
+ old_keys =
+ old_value
+ |> Keyword.keys()
+ |> MapSet.new()
+
+ new_keys =
+ new_value
+ |> Keyword.keys()
+ |> MapSet.new()
+
+ intersect_keys = old_keys |> MapSet.intersection(new_keys) |> MapSet.to_list()
+
+ subkeys = sub_key_full_update(group, key, intersect_keys)
+
+ merged_value = DeepMerge.deep_merge(old_value, new_value)
+
+ Enum.reduce(subkeys, merged_value, fn subkey, acc ->
+ Keyword.put(acc, subkey, new_value[subkey])
+ end)
+ end
+
+ @spec sub_key_full_update?(atom(), atom(), [Keyword.key()]) :: boolean()
+ def sub_key_full_update?(group, key, subkeys) do
+ Enum.any?(@full_subkey_update, fn {g, k, subkey} ->
+ g == group and k == key and subkey in subkeys
+ end)
+ end
+
+ defp sub_key_full_update(group, key, subkeys) do
+ Enum.map(@full_subkey_update, fn
+ {g, k, subkey} when g == group and k == key ->
+ if subkey in subkeys, do: subkey, else: []
+
+ _ ->
+ []
+ end)
+ |> List.flatten()
+ end
+
@full_key_update [
{:pleroma, :ecto_repos},
- {:pleroma, :assets},
{:quack, :meta},
{:mime, :types},
{:cors_plug, [:max_age, :methods, :expose, :headers]},
old_value <- from_binary(config.value),
transformed_value <- do_transform(params[:value]),
{:can_be_merged, true, config} <- {:can_be_merged, is_list(transformed_value), config},
- new_value <- DeepMerge.deep_merge(old_value, transformed_value) do
- ConfigDB.update(config, %{value: new_value, transformed?: true})
+ new_value <-
+ deep_merge(
+ ConfigDB.from_string(config.group),
+ ConfigDB.from_string(config.key),
+ old_value,
+ transformed_value
+ ) do
+ ConfigDB.update(config, %{value: new_value})
else
{reason, false, config} when reason in [:partial_update, :can_be_merged] ->
ConfigDB.update(config, params)
end
end
+ @spec convert(any()) :: any()
+ def convert(entity), do: do_convert(entity)
+
defp do_convert(entity) when is_list(entity) do
for v <- entity, into: [], do: do_convert(v)
end
}
end
- defp do_convert({:dispatch, [entity]}), do: %{"tuple" => [":dispatch", [inspect(entity)]]}
# TODO: will become useless after removing hackney
defp do_convert({:partial_chain, entity}), do: %{"tuple" => [":partial_chain", inspect(entity)]}
def transform(entity), do: to_binary(entity)
+ @spec transform_with_out_binary(any()) :: any()
+ def transform_with_out_binary(entity), do: do_transform(entity)
+
@spec to_binary(any()) :: binary()
def to_binary(entity), do: :erlang.term_to_binary(entity)
{:proxy_url, {do_transform_string(type), parse_host(host), port}}
end
- defp do_transform(%{"tuple" => [":dispatch", [entity]]}) do
- {dispatch_settings, []} = do_eval(entity)
- {:dispatch, [dispatch_settings]}
- end
-
# TODO: will become useless after removing hackney
defp do_transform(%{"tuple" => [":partial_chain", entity]}) do
- {partial_chain, []} = do_eval(entity)
+ {partial_chain, []} =
+ entity
+ |> String.replace(~r/[^\w|^{:,[|^,|^[|^\]^}|^\/|^\.|^"]^\s/, "")
+ |> Code.eval_string()
+
{:partial_chain, partial_chain}
end
@spec is_module_name?(String.t()) :: boolean()
def is_module_name?(string) do
- Regex.match?(~r/^(Pleroma|Phoenix|Tesla|Quack)\./, string) or
+ Regex.match?(~r/^(Pleroma|Phoenix|Tesla|Quack|Ueberauth)\./, string) or
string in ["Oban", "Ueberauth", "ExSyslogger"]
end
-
- defp do_eval(entity) do
- cleaned_string = String.replace(entity, ~r/[^\w|^{:,[|^,|^[|^\]^}|^\/|^\.|^"]^\s/, "")
- Code.eval_string(cleaned_string)
- end
end
projects / akkoma / blobdiff