refactor

lib/mv/membership/member_export/build.ex

@@ -194,13 +194,7 @@ defmodule Mv.Membership.MemberExport.Build do
     field_atom = String.to_existing_atom(field)
 
     if field_atom in Mv.Constants.member_fields() do
-      Enum.sort_by(members, fn member -> Map.get(member, field_atom) end, fn a, b ->
-        case order do
-          "asc" -> a <= b
-          "desc" -> b <= a
-          _ -> true
-        end
-      end)
+      sort_by_field(members, field_atom, order)
     else
       members
     end
@@ -210,6 +204,17 @@ defmodule Mv.Membership.MemberExport.Build do
 
   defp sort_members_in_memory(members, _field, _order), do: members
 
+  defp sort_by_field(members, field_atom, order) do
+    key_fn = fn member -> Map.get(member, field_atom) end
+    compare_fn = build_compare_fn(order)
+
+    Enum.sort_by(members, key_fn, compare_fn)
+  end
+
+  defp build_compare_fn("asc"), do: fn a, b -> a <= b end
+  defp build_compare_fn("desc"), do: fn a, b -> b <= a end
+  defp build_compare_fn(_), do: fn _a, _b -> true end
+
   defp load_custom_field_values_query(query, []), do: query
 
   defp load_custom_field_values_query(query, custom_field_ids) do
@@ -251,11 +256,6 @@ defmodule Mv.Membership.MemberExport.Build do
     ArgumentError -> {query, false}
   end
 
-  defp sort_after_load?(field) when is_binary(field),
-    do: String.starts_with?(field, @custom_field_prefix)
-
-  defp sort_after_load?(_), do: false
-
   defp sort_members_by_custom_field(members, _field, _order, _custom_fields) when members == [],
     do: []
 

lib/mv/membership/members_pdf.ex

@@ -3,8 +3,8 @@ defmodule Mv.Membership.MembersPDF do
   Exports members to PDF using Typst templates and Imprintor.
 
   Uses the same data structure as `MemberExport.Build` and converts it
-  to the format expected by the Typst template. No translations/Gettext
-  in this module - labels come from the web layer.
+  to the format expected by the Typst template. Handles internationalization
+  for PDF-specific labels (title, metadata) and membership fee status.
 
   Ensures deterministic output by maintaining column and row order.
 
@@ -14,15 +14,17 @@ defmodule Mv.Membership.MembersPDF do
 
   require Logger
 
+  use Gettext, backend: MvWeb.Gettext
+
   alias Mv.Config
 
   @template_filename "members_export.typ"
-  @template_path "priv/pdf_templates/members_export.typ"
 
   @doc """
   Renders export data to PDF binary.
 
   - `export_data` - Map from `MemberExport.Build.build/3` with `columns`, `rows`, and `meta`
+  - `opts` - Keyword list with `:locale` (default: "en") and `:club_name` (default: "Club")
 
   Returns `{:ok, binary}` where binary is the PDF content, or `{:error, term}`.
 
@@ -30,48 +32,46 @@ defmodule Mv.Membership.MembersPDF do
 
   Validates row count against configured limit before processing.
   """
-  @spec render(map()) :: {:ok, binary()} | {:error, term()}
-  def render(export_data) do
+  @spec render(map(), keyword()) :: {:ok, binary()} | {:error, term()}
+  def render(export_data, opts \\ []) do
     row_count = length(export_data.rows)
     max_rows = Config.pdf_export_row_limit()
 
     if row_count > max_rows do
-      Logger.warning("PDF export rejected: row count exceeds limit",
-        row_count: row_count,
-        max_rows: max_rows,
+      Logger.warning(
+        "PDF export rejected: row count exceeds limit (rows: #{row_count}, max: #{max_rows})",
         error_type: :row_limit_exceeded
       )
 
       {:error, {:row_limit_exceeded, row_count, max_rows}}
     else
-      Logger.info("Starting PDF export",
-        row_count: row_count,
-        column_count: length(export_data.columns)
+      Logger.info(
+        "Starting PDF export (rows: #{row_count}, columns: #{length(export_data.columns)})"
       )
 
-      create_and_use_temp_directory(export_data)
+      locale = Keyword.get(opts, :locale, "en")
+      club_name = Keyword.get(opts, :club_name, "Club")
+      create_and_use_temp_directory(export_data, locale, club_name)
     end
   end
 
-  defp create_and_use_temp_directory(export_data) do
+  defp create_and_use_temp_directory(export_data, locale, club_name) do
     case create_temp_directory() do
       {:ok, temp_dir} ->
         try do
           with {:ok, template_content} <- load_template(),
                {:ok, _template_path} <- copy_template_to_temp(temp_dir, template_content),
-               {:ok, template_data} <- convert_to_template_format(export_data),
+               {:ok, template_data} <-
+                 convert_to_template_format(export_data, locale, club_name),
                {:ok, config} <-
                  build_imprintor_config(template_content, template_data, temp_dir),
                {:ok, pdf_binary} <- compile_to_pdf(config) do
-            Logger.info("PDF export completed successfully",
-              row_count: length(export_data.rows)
-            )
+            Logger.info("PDF export completed successfully (rows: #{length(export_data.rows)})")
 
             {:ok, pdf_binary}
           else
             {:error, reason} = error ->
-              Logger.error("PDF export failed",
-                error: reason,
+              Logger.error("PDF export failed: #{inspect(reason)}",
                 error_type: :pdf_export_failed
               )
 
@@ -82,8 +82,7 @@ defmodule Mv.Membership.MembersPDF do
         end
 
       {:error, reason} = error ->
-        Logger.error("Failed to create temp directory",
-          error: reason,
+        Logger.error("Failed to create temp directory: #{inspect(reason)}",
           error_type: :temp_dir_creation_failed
         )
 
@@ -138,35 +137,52 @@ defmodule Mv.Membership.MembersPDF do
         :ok
 
       {:error, reason, _} ->
-        Logger.warning("Failed to cleanup temp directory",
-          temp_dir: temp_dir,
-          error: reason
-        )
+        Logger.warning("Failed to cleanup temp directory: #{temp_dir}, error: #{inspect(reason)}")
     end
   end
 
-  defp convert_to_template_format(export_data) do
+  defp convert_to_template_format(export_data, locale, club_name) do
+    # Set locale for translations
+    Gettext.put_locale(MvWeb.Gettext, locale)
+
     headers = Enum.map(export_data.columns, & &1.label)
     column_count = length(export_data.columns)
 
     meta = Map.get(export_data, :meta) || Map.get(export_data, "meta") || %{}
 
-    generated_at =
+    generated_at_raw =
       Map.get(meta, :generated_at) ||
         Map.get(meta, "generated_at") ||
         DateTime.utc_now() |> DateTime.to_iso8601()
 
+    generated_at = format_datetime(generated_at_raw, locale)
+
     member_count =
       Map.get(meta, :member_count) ||
         Map.get(meta, "member_count") ||
         length(export_data.rows)
 
+    # Translate membership fee status and format dates in rows
+    rows =
+      export_data.rows
+      |> translate_membership_fee_status_in_rows(export_data.columns)
+      |> format_dates_in_rows(export_data.columns, locale)
+
+    # Build title based on locale
+    title = build_title(locale, club_name)
+
+    # Build translated labels for metadata
+    created_at_label = gettext("Created at:")
+    member_count_label = gettext("Member count:")
+
     template_data = %{
-      "title" => "Mitglieder-Export",
+      "title" => title,
+      "created_at_label" => created_at_label,
+      "member_count_label" => member_count_label,
       "generated_at" => generated_at,
       "column_count" => column_count,
       "headers" => headers,
-      "rows" => export_data.rows,
+      "rows" => rows,
       "columns" =>
         Enum.map(export_data.columns, fn col ->
           %{
@@ -178,12 +194,178 @@ defmodule Mv.Membership.MembersPDF do
       "meta" => %{
         "generated_at" => generated_at,
         "member_count" => member_count
-      }
+      },
+      "locale" => locale
     }
 
     {:ok, template_data}
   end
 
+  defp build_title(_locale, club_name) do
+    gettext("Member %{club_name}", club_name: club_name)
+  end
+
+  defp format_datetime(iso8601_string, locale) when is_binary(iso8601_string) do
+    # Try to parse as DateTime first
+    case DateTime.from_iso8601(iso8601_string) do
+      {:ok, datetime, _offset} ->
+        format_datetime(datetime, locale)
+
+      {:ok, datetime} ->
+        format_datetime(datetime, locale)
+
+      {:error, _} ->
+        # Try NaiveDateTime if DateTime parsing fails
+        case NaiveDateTime.from_iso8601(iso8601_string) do
+          {:ok, naive_dt} ->
+            # Convert to DateTime in UTC
+            datetime = DateTime.from_naive!(naive_dt, "Etc/UTC")
+            format_datetime(datetime, locale)
+
+          {:error, _} ->
+            # If both fail, return original string
+            iso8601_string
+        end
+    end
+  end
+
+  defp format_datetime(%DateTime{} = datetime, locale) do
+    # Format as readable date and time (locale-specific)
+    case locale do
+      "de" ->
+        # German format: dd.mm.yyyy - HH:MM Uhr
+        Calendar.strftime(datetime, "%d.%m.%Y - %H:%M Uhr")
+
+      _ ->
+        # English format: MM/DD/YYYY HH:MM AM/PM
+        Calendar.strftime(datetime, "%m/%d/%Y %I:%M %p")
+    end
+  end
+
+  defp format_datetime(_, _), do: ""
+
+  defp format_date(%Date{} = date, locale) do
+    # Format as readable date (locale-specific)
+    case locale do
+      "de" ->
+        # German format: dd.mm.yyyy
+        Calendar.strftime(date, "%d.%m.%Y")
+
+      _ ->
+        # English format: MM/DD/YYYY
+        Calendar.strftime(date, "%m/%d/%Y")
+    end
+  end
+
+  defp format_date(_, _), do: ""
+
+  defp format_dates_in_rows(rows, columns, locale) do
+    date_indices = find_date_column_indices(columns)
+
+    if date_indices == [] do
+      rows
+    else
+      format_rows_dates(rows, date_indices, locale)
+    end
+  end
+
+  defp find_date_column_indices(columns) do
+    columns
+    |> Enum.with_index()
+    |> Enum.filter(fn {col, _idx} -> date_column?(col) end)
+    |> Enum.map(fn {_col, idx} -> idx end)
+  end
+
+  defp format_rows_dates(rows, date_indices, locale) do
+    Enum.map(rows, fn row -> format_row_dates(row, date_indices, locale) end)
+  end
+
+  defp format_row_dates(row, date_indices, locale) do
+    Enum.with_index(row)
+    |> Enum.map(fn {cell_value, idx} ->
+      if idx in date_indices do
+        format_cell_date(cell_value, locale)
+      else
+        cell_value
+      end
+    end)
+  end
+
+  defp date_column?(%{kind: :member_field, key: key}) do
+    key_atom = key_to_atom_safe(key)
+    key_atom in [:join_date, :exit_date, :membership_fee_start_date]
+  end
+
+  defp date_column?(_), do: false
+
+  defp key_to_atom_safe(key) when is_binary(key) do
+    try do
+      String.to_existing_atom(key)
+    rescue
+      ArgumentError -> key
+    end
+  end
+
+  defp key_to_atom_safe(key), do: key
+
+  defp format_cell_date(cell_value, locale) when is_binary(cell_value) do
+    format_cell_date_iso8601(cell_value, locale)
+  end
+
+  defp format_cell_date(cell_value, _locale), do: cell_value
+
+  defp format_cell_date_iso8601(cell_value, locale) do
+    case Date.from_iso8601(cell_value) do
+      {:ok, date} -> format_date(date, locale)
+      _ -> format_cell_date_datetime(cell_value, locale)
+    end
+  end
+
+  defp format_cell_date_datetime(cell_value, locale) do
+    case DateTime.from_iso8601(cell_value) do
+      {:ok, datetime} -> format_datetime(datetime, locale)
+      _ -> format_cell_date_naive(cell_value, locale)
+    end
+  end
+
+  defp format_cell_date_naive(cell_value, locale) do
+    case NaiveDateTime.from_iso8601(cell_value) do
+      {:ok, naive_dt} ->
+        datetime = DateTime.from_naive!(naive_dt, "Etc/UTC")
+        format_datetime(datetime, locale)
+
+      _ ->
+        cell_value
+    end
+  end
+
+  defp translate_membership_fee_status_in_rows(rows, columns) do
+    status_col_index = find_membership_fee_status_index(columns)
+
+    if status_col_index do
+      translate_rows_status(rows, status_col_index)
+    else
+      rows
+    end
+  end
+
+  defp find_membership_fee_status_index(columns) do
+    Enum.find_index(columns, fn col ->
+      col.kind == :computed && col.key == :membership_fee_status
+    end)
+  end
+
+  defp translate_rows_status(rows, status_col_index) do
+    Enum.map(rows, fn row ->
+      List.update_at(row, status_col_index, &translate_membership_fee_status/1)
+    end)
+  end
+
+  defp translate_membership_fee_status("paid"), do: gettext("Paid")
+  defp translate_membership_fee_status("unpaid"), do: gettext("Unpaid")
+  defp translate_membership_fee_status("suspended"), do: gettext("Suspended")
+  defp translate_membership_fee_status(value), do: value
+
   defp build_imprintor_config(template_content, template_data, root_directory) do
     # Imprintor.Config.new(source_document, inputs, options)
     # inputs: %{"elixir_data" => template_data} for sys.inputs.elixir_data in template
@@ -197,37 +379,43 @@ defmodule Mv.Membership.MembersPDF do
   end
 
   defp get_extra_fonts do
-    # Try multiple paths: compiled app path and source path (for tests/dev)
-    font_paths = [
+    font_paths = get_font_paths()
+
+    Enum.reduce_while(font_paths, [], &find_fonts_in_path/2)
+    |> normalize_fonts_result()
+  end
+
+  defp get_font_paths do
+    [
       Path.join(Application.app_dir(:mv, "priv"), "fonts"),
       Path.join([File.cwd!(), "priv", "fonts"])
     ]
+  end
 
-    Enum.reduce_while(font_paths, [], fn base_path, _acc ->
-      case File.ls(base_path) do
-        {:ok, files} ->
-          fonts =
-            files
-            |> Enum.filter(&String.ends_with?(&1, ".ttf"))
-            |> Enum.map(&Path.join(base_path, &1))
-            |> Enum.sort()
-
-          if fonts != [] do
-            {:halt, fonts}
-          else
-            {:cont, []}
-          end
-
-        {:error, _reason} ->
-          {:cont, []}
-      end
-    end)
-    |> case do
-      [] -> []
-      fonts -> fonts
+  defp find_fonts_in_path(base_path, _acc) do
+    case File.ls(base_path) do
+      {:ok, files} -> process_font_files(files, base_path)
+      {:error, _reason} -> {:cont, []}
     end
   end
 
+  defp process_font_files(files, base_path) do
+    fonts =
+      files
+      |> Enum.filter(&String.ends_with?(&1, ".ttf"))
+      |> Enum.map(&Path.join(base_path, &1))
+      |> Enum.sort()
+
+    if fonts != [] do
+      {:halt, fonts}
+    else
+      {:cont, []}
+    end
+  end
+
+  defp normalize_fonts_result([]), do: []
+  defp normalize_fonts_result(fonts), do: fonts
+
   defp compile_to_pdf(config) do
     case Imprintor.compile_to_pdf(config) do
       {:ok, pdf_binary} when is_binary(pdf_binary) ->
@@ -235,8 +423,8 @@ defmodule Mv.Membership.MembersPDF do
         if String.starts_with?(pdf_binary, "%PDF") do
           {:ok, pdf_binary}
         else
-          Logger.error("PDF compilation returned invalid format",
-            binary_start: String.slice(pdf_binary, 0, 20)
+          Logger.error(
+            "PDF compilation returned invalid format (start: #{String.slice(pdf_binary, 0, 20)})"
           )
 
           {:error, :invalid_pdf_format}
@@ -251,8 +439,7 @@ defmodule Mv.Membership.MembersPDF do
         {:error, {:compile_error, reason}}
 
       other ->
-        Logger.error("PDF compilation returned unexpected result",
-          result: inspect(other),
+        Logger.error("PDF compilation returned unexpected result: #{inspect(other)}",
           error_type: :unexpected_result
         )
 
@@ -260,8 +447,7 @@ defmodule Mv.Membership.MembersPDF do
     end
   rescue
     e ->
-      Logger.error("PDF compilation raised exception",
-        exception: inspect(e),
+      Logger.error("PDF compilation raised exception: #{inspect(e)}",
         error_type: :compile_exception
       )