Refactor currency field to use masked input

Author: Flo0807

lib/backpex/fields/currency.ex

@@ -7,6 +7,23 @@ defmodule Backpex.Fields.Currency do
     throttle: [
       doc: "Timeout value (in milliseconds) or function that receives the assigns.",
       type: {:or, [:pos_integer, {:fun, 1}]}
+    ],
+    unit: [
+      doc: "Unit to display with the currency value, e.g. '€'.",
+      type: :string,
+      default: "€"
+    ],
+    radix: [
+      doc:
+        "Character used as the decimal separator, e.g. ',' or '.'. Make sure this value matches the one you've configured in your Money library.",
+      type: :string,
+      default: ","
+    ],
+    thousands_separator: [
+      doc:
+        "Character used as the thousands separator, e.g. '.' or ','. Make sure this value matches the one you've configured in your Money library.",
+      type: :string,
+      default: "."
     ]
   ]
 
@@ -21,16 +38,14 @@ defmodule Backpex.Fields.Currency do
 
   ## Schema
 
-  `Backpex.Ecto.Amount.Type` provides a type for Ecto to store a amount. The underlying data type should be an integer.
-  For a full list of configuration options see: https://hexdocs.pm/money/Money.html#module-configuration
+  Backpex expects you to use a Money library or a similar approach for handling currency values and dumping / casting them correctly in your database schema.
 
-      schema "article" do
-        field :price, Backpex.Ecto.Amount.Type
-        ...
-      end
+  Ensure that your schema field is set up to handle the currency type appropriately.
+
+  For example, if you are using the [Money](https://hex.pm/packages/money) library, your schema might look like this:
 
       schema "article" do
-        field :price, Backpex.Ecto.Amount.Type, currency: :EUR, opts: [separator: ".", delimiter: ","]
+        field :price, Money.Ecto.Amount.Type
         ...
       end
 
@@ -41,46 +56,45 @@ defmodule Backpex.Fields.Currency do
         [
           price: %{
             module: Backpex.Fields.Currency,
-            label: "Price"
+            label: "Price",
+            unit: "€",
+            radix: ",",
+            thousands_separator: "."
           }
         ]
       end
   """
   use Backpex.Field, config_schema: @config_schema
+
   import Ecto.Query
-  alias Backpex.Ecto.Amount.Type
 
   @impl Backpex.Field
   def render_value(assigns) do
-    schema = assigns.live_resource.adapter_config(:schema)
-    assigns = assign(assigns, :casted_value, maybe_cast_value(assigns.name, schema, assigns.value))
-
     ~H"""
     <p class={@live_action in [:index, :resource_action] && "truncate"}>
-      {@casted_value}
+      {@value}
     </p>
     """
   end
 
   @impl Backpex.Field
   def render_form(assigns) do
-    assigns = assign(assigns, :casted_value, maybe_cast_form(PhoenixForm.input_value(assigns.form, assigns.name)))
-
     ~H"""
     <div>
       <Layout.field_container>
         <:label align={Backpex.Field.align_label(@field_options, assigns)}>
           <Layout.input_label text={@field_options[:label]} />
         </:label>
-        <BackpexForm.input
-          type="number"
+        <BackpexForm.masked_input
+          type="text"
           field={@form[@name]}
-          value={@casted_value}
+          translate_error_fun={Backpex.Field.translate_error_fun(@field_options, assigns)}
           help_text={Backpex.Field.help_text(@field_options, assigns)}
           phx-debounce={Backpex.Field.debounce(@field_options, assigns)}
           phx-throttle={Backpex.Field.throttle(@field_options, assigns)}
-          step=".01"
-          min="0"
+          unit={@field_options[:unit]}
+          radix={@field_options[:radix]}
+          thousands_separator={@field_options[:thousands_separator]}
         />
       </Layout.field_container>
     </div>
@@ -91,25 +105,7 @@ defmodule Backpex.Fields.Currency do
   def search_condition(schema_name, field_name, search_string) do
     dynamic(
       [{^schema_name, schema_name}],
-      ilike(fragment("CAST(? AS TEXT)", schema_name |> field(^field_name)), ^search_string)
+      ilike(fragment("CAST(? AS TEXT)", field(schema_name, ^field_name)), ^search_string)
     )
   end
-
-  defp maybe_cast_value(field_name, schema, value) do
-    type = schema.__schema__(:type, field_name) || schema.__schema__(:virtual_type, field_name)
-
-    case type do
-      {:parameterized, Backpex.Ecto.Amount.Type, opts} ->
-        {:ok, money} = Type.cast(value, opts)
-
-        Money.to_string(money, Keyword.get(opts, :opts, []))
-
-      _type ->
-        value
-    end
-  end
-
-  defp maybe_cast_form(val) when is_binary(val), do: val
-  defp maybe_cast_form(nil), do: Decimal.new("0.00")
-  defp maybe_cast_form(%Money{} = value), do: Money.to_decimal(value)
 end