| defmodule Plausible.Audit.EncoderError do |
| defexception [:message] |
| end |
|
|
| defprotocol Plausible.Audit.Encoder do |
| def encode(x) |
|
|
| def encode(x, opts) |
| end |
|
|
| defimpl Plausible.Audit.Encoder, for: Ecto.Changeset do |
| def encode(changeset, opts \\ []) do |
| changes = |
| Enum.reduce(changeset.changes, %{}, fn {k, v}, acc -> |
| Map.put(acc, k, Plausible.Audit.Encoder.encode(v, opts)) |
| end) |
|
|
| data = Plausible.Audit.Encoder.encode(changeset.data, opts) |
|
|
| case {map_size(data), map_size(changes)} do |
| {n, 0} when n > 0 -> |
| data |
|
|
| {0, n} when n > 0 -> |
| changes |
|
|
| {0, 0} -> |
| %{} |
|
|
| _ -> |
| %{before: data, after: changes} |
| end |
| end |
| end |
|
|
| defimpl Plausible.Audit.Encoder, for: Map do |
| def encode(x, opts \\ []) do |
| {allow_not_loaded, data} = Map.pop(x, :__allow_not_loaded__) |
| raise_on_not_loaded? = Keyword.get(opts, :raise_on_not_loaded?, true) |
|
|
| Enum.reduce(data, %{}, fn |
| {k, %Ecto.Association.NotLoaded{}}, acc -> |
| if k in allow_not_loaded or not raise_on_not_loaded? do |
| acc |
| else |
| raise Plausible.Audit.EncoderError, |
| message: |
| "#{k} association not loaded. Either preload, exclude or mark it as :allow_not_loaded in #{__MODULE__} options" |
| end |
|
|
| {k, v}, acc -> |
| Map.put(acc, k, Plausible.Audit.Encoder.encode(v, opts)) |
| end) |
| end |
| end |
|
|
| defimpl Plausible.Audit.Encoder, for: [Integer, BitString, Float] do |
| def encode(x, _opts \\ []), do: x |
| end |
|
|
| defimpl Plausible.Audit.Encoder, for: [DateTime, Date, NaiveDateTime, Time] do |
| def encode(x, _opts \\ []), do: to_string(x) |
| end |
|
|
| defimpl Plausible.Audit.Encoder, for: Atom do |
| def encode(x, opts \\ []) |
|
|
| def encode(nil, _opts), do: nil |
| def encode(true, _opts), do: true |
| def encode(false, _opts), do: false |
| def encode(x, _opts), do: Atom.to_string(x) |
| end |
|
|
| defimpl Plausible.Audit.Encoder, for: List do |
| def encode(x, opts \\ []) do |
| Enum.map(x, &Plausible.Audit.Encoder.encode(&1, opts)) |
| end |
| end |
|
|
| defimpl Plausible.Audit.Encoder, for: Any do |
| defmacro __deriving__(module, struct, options) do |
| deriving(module, struct, options) |
| end |
|
|
| def deriving(module, _struct, options) do |
| only = options[:only] |
| except = options[:except] |
| allow_not_loaded = options[:allow_not_loaded] || [] |
|
|
| extractor = |
| cond do |
| only -> |
| quote( |
| do: |
| struct |
| |> Map.take(unquote(only)) |
| |> Map.put(:__allow_not_loaded__, unquote(allow_not_loaded)) |
| ) |
|
|
| except -> |
| except = [:__struct__ | except] |
|
|
| quote( |
| do: |
| struct |
| |> Map.drop( |
| unquote(except) |
| |> Map.put(:__allow_not_loaded__, unquote(allow_not_loaded)) |
| ) |
| ) |
|
|
| true -> |
| quote( |
| do: |
| struct |
| |> Map.delete(:__struct__) |
| |> Map.put(:__allow_not_loaded__, unquote(allow_not_loaded)) |
| ) |
| end |
|
|
| quote do |
| defimpl Plausible.Audit.Encoder, for: unquote(module) do |
| def encode(struct, opts \\ []) do |
| Plausible.Audit.Encoder.encode(unquote(extractor), opts) |
| end |
| end |
| end |
| end |
|
|
| def encode(_), do: raise("Implement me") |
| def encode(_, _), do: raise("Implement me") |
| end |
|
|
