fix linting

lib/mv/membership/member_export.ex

@@ -55,14 +55,7 @@ defmodule Mv.Membership.MemberExport do
 
     case Ash.read(query, actor: actor) do
       {:ok, custom_fields} ->
-        by_id =
-          Enum.reduce(custom_field_ids, %{}, fn id, acc ->
-            case Enum.find(custom_fields, fn cf -> to_string(cf.id) == to_string(id) end) do
-              nil -> acc
-              cf -> Map.put(acc, id, cf)
-            end
-          end)
-
+        by_id = build_custom_fields_by_id(custom_field_ids, custom_fields)
         {:ok, by_id}
 
       {:error, %Ash.Error.Forbidden{}} ->
@@ -70,33 +63,72 @@ defmodule Mv.Membership.MemberExport do
     end
   end
 
-  defp build_column_specs(parsed, custom_fields_by_id) do
-    member_specs =
-      Enum.map(parsed.member_fields, fn f ->
-        if f in parsed.selectable_member_fields do
-          %{kind: :member_field, key: f}
-        else
-          # only allow known computed export fields to avoid crashing on unknown atoms
-          if f in @computed_export_fields do
-            %{kind: :computed, key: String.to_existing_atom(f)}
-          else
-            # ignore unknown non-selectable fields defensively
-            nil
-          end
-        end
-      end)
-      |> Enum.reject(&is_nil/1)
+  defp build_custom_fields_by_id(custom_field_ids, custom_fields) do
+    Enum.reduce(custom_field_ids, %{}, fn id, acc ->
+      find_and_add_custom_field(acc, id, custom_fields)
+    end)
+  end
 
-    custom_specs =
-      parsed.custom_field_ids
-      |> Enum.map(fn id -> Map.get(custom_fields_by_id, id) end)
-      |> Enum.reject(&is_nil/1)
-      |> Enum.map(fn cf -> %{kind: :custom_field, key: cf.id, custom_field: cf} end)
+  defp find_and_add_custom_field(acc, id, custom_fields) do
+    case Enum.find(custom_fields, fn cf -> to_string(cf.id) == to_string(id) end) do
+      nil -> acc
+      cf -> Map.put(acc, id, cf)
+    end
+  end
+
+  defp build_column_specs(parsed, custom_fields_by_id) do
+    member_specs = build_member_column_specs(parsed)
+    custom_specs = build_custom_column_specs(parsed, custom_fields_by_id)
 
     member_specs ++ custom_specs
   end
 
+  defp build_member_column_specs(parsed) do
+    Enum.map(parsed.member_fields, fn f ->
+      build_single_member_spec(f, parsed.selectable_member_fields)
+    end)
+    |> Enum.reject(&is_nil/1)
+  end
+
+  defp build_single_member_spec(field, selectable_member_fields) do
+    if field in selectable_member_fields do
+      %{kind: :member_field, key: field}
+    else
+      build_computed_spec(field)
+    end
+  end
+
+  defp build_computed_spec(field) do
+    # only allow known computed export fields to avoid crashing on unknown atoms
+    if field in @computed_export_fields do
+      %{kind: :computed, key: String.to_existing_atom(field)}
+    else
+      # ignore unknown non-selectable fields defensively
+      nil
+    end
+  end
+
+  defp build_custom_column_specs(parsed, custom_fields_by_id) do
+    parsed.custom_field_ids
+    |> Enum.map(fn id -> Map.get(custom_fields_by_id, id) end)
+    |> Enum.reject(&is_nil/1)
+    |> Enum.map(fn cf -> %{kind: :custom_field, key: cf.id, custom_field: cf} end)
+  end
+
   defp load_members(actor, parsed, custom_fields_by_id) do
+    query = build_members_query(parsed, custom_fields_by_id)
+
+    case Ash.read(query, actor: actor) do
+      {:ok, members} ->
+        processed_members = process_loaded_members(members, parsed, custom_fields_by_id)
+        {:ok, processed_members}
+
+      {:error, %Ash.Error.Forbidden{}} ->
+        {:error, :forbidden}
+    end
+  end
+
+  defp build_members_query(parsed, _custom_fields_by_id) do
     select_fields =
       [:id] ++ Enum.map(parsed.selectable_member_fields, &String.to_existing_atom/1)
 
@@ -114,51 +146,48 @@ defmodule Mv.Membership.MemberExport do
       |> load_custom_field_values_query(custom_field_ids_union)
       |> maybe_load_cycles(need_cycles, parsed.show_current_cycle)
 
-    query =
-      if parsed.selected_ids != [] do
-        Ash.Query.filter(query, expr(id in ^parsed.selected_ids))
-      else
-        query
-        |> apply_search(parsed.query)
-        |> then(fn q ->
-          {q, _sort_after_load} = maybe_sort(q, parsed.sort_field, parsed.sort_order)
-          q
-        end)
-      end
+    if parsed.selected_ids != [] do
+      Ash.Query.filter(query, expr(id in ^parsed.selected_ids))
+    else
+      query
+      |> apply_search(parsed.query)
+      |> then(fn q ->
+        {q, _sort_after_load} = maybe_sort(q, parsed.sort_field, parsed.sort_order)
+        q
+      end)
+    end
+  end
 
-    case Ash.read(query, actor: actor) do
-      {:ok, members} ->
-        members =
-          if parsed.selected_ids == [] do
-            members
-            |> apply_cycle_status_filter(parsed.cycle_status_filter, parsed.show_current_cycle)
-            |> MvWeb.MemberLive.Index.apply_boolean_custom_field_filters(
-              parsed.boolean_filters || %{},
-              Map.values(custom_fields_by_id)
-            )
-          else
-            members
-          end
+  defp process_loaded_members(members, parsed, custom_fields_by_id) do
+    members
+    |> apply_post_load_filters(parsed, custom_fields_by_id)
+    |> apply_post_load_sorting(parsed, custom_fields_by_id)
+    |> add_computed_fields(parsed.computed_fields, parsed.show_current_cycle)
+  end
 
-        members =
-          if parsed.selected_ids == [] and sort_after_load?(parsed.sort_field) do
-            sort_members_by_custom_field(
-              members,
-              parsed.sort_field,
-              parsed.sort_order,
-              Map.values(custom_fields_by_id)
-            )
-          else
-            members
-          end
+  defp apply_post_load_filters(members, parsed, custom_fields_by_id) do
+    if parsed.selected_ids == [] do
+      members
+      |> apply_cycle_status_filter(parsed.cycle_status_filter, parsed.show_current_cycle)
+      |> MvWeb.MemberLive.Index.apply_boolean_custom_field_filters(
+        parsed.boolean_filters || %{},
+        Map.values(custom_fields_by_id)
+      )
+    else
+      members
+    end
+  end
 
-        # Calculate membership_fee_status for computed fields
-        members = add_computed_fields(members, parsed.computed_fields, parsed.show_current_cycle)
-
-        {:ok, members}
-
-      {:error, %Ash.Error.Forbidden{}} ->
-        {:error, :forbidden}
+  defp apply_post_load_sorting(members, parsed, custom_fields_by_id) do
+    if parsed.selected_ids == [] and sort_after_load?(parsed.sort_field) do
+      sort_members_by_custom_field(
+        members,
+        parsed.sort_field,
+        parsed.sort_order,
+        Map.values(custom_fields_by_id)
+      )
+    else
+      members
     end
   end
 
@@ -259,7 +288,8 @@ defmodule Mv.Membership.MemberExport do
     if "membership_fee_status" in computed_fields do
       Enum.map(members, fn member ->
         status = MembershipFeeStatus.get_cycle_status_for_member(member, show_current_cycle)
-        Map.put(member, :membership_fee_status, status) # <= Atom rein
+        # <= Atom rein
+        Map.put(member, :membership_fee_status, status)
       end)
     else
       members
@@ -333,8 +363,9 @@ defmodule Mv.Membership.MemberExport do
     case Map.get(params, "boolean_filters") do
       map when is_map(map) ->
         map
-        |> Enum.filter(fn {k, v} -> is_binary(k) and is_boolean(v) end)
-        |> Enum.filter(fn {k, _} -> match?({:ok, _}, Ecto.UUID.cast(k)) end)
+        |> Enum.filter(fn {k, v} ->
+          is_binary(k) and is_boolean(v) and match?({:ok, _}, Ecto.UUID.cast(k))
+        end)
         |> Enum.into(%{})
 
       _ ->