refactor: reduce nesting depth and improve code readability

- Replace Enum.map |> Enum.join with Enum.map_join for efficiency
- Extract helper functions to reduce nesting depth from 4 to 2
- Rename is_current_cycle? to current_cycle? following Elixir conventions

lib/membership/member.ex

@@ -607,7 +607,14 @@ defmodule Mv.Membership.Member do
     cycles = Map.get(member, :membership_fee_cycles)
 
     if is_list(cycles) and cycles != [] do
-      Enum.find(cycles, fn cycle ->
+      Enum.find(cycles, &current_cycle?(&1, today))
+    else
+      nil
+    end
+  end
+
+  # Checks if a cycle is the current cycle (active today)
+  defp current_cycle?(cycle, today) do
     case Map.get(cycle, :membership_fee_type) do
       %{interval: interval} ->
         cycle_end =
@@ -619,10 +626,6 @@ defmodule Mv.Membership.Member do
       _ ->
         false
     end
-      end)
-    else
-      nil
-    end
   end
 
   @doc false
@@ -634,30 +637,40 @@ defmodule Mv.Membership.Member do
 
     if is_list(cycles) and cycles != [] do
       cycles
-      |> Enum.filter(fn cycle ->
+      |> filter_completed_cycles(today)
+      |> sort_cycles_by_end_date()
+      |> List.first()
+    else
+      nil
+    end
+  end
+
+  # Filters cycles that have ended (cycle_end < today)
+  defp filter_completed_cycles(cycles, today) do
+    Enum.filter(cycles, fn cycle ->
       case Map.get(cycle, :membership_fee_type) do
         %{interval: interval} ->
           cycle_end =
             Mv.MembershipFees.CalendarCycles.calculate_cycle_end(cycle.cycle_start, interval)
 
-            # Cycle must have ended (cycle_end < today)
           Date.compare(today, cycle_end) == :gt
 
         _ ->
           false
       end
     end)
-      |> Enum.sort_by(
+  end
+
+  # Sorts cycles by end date in descending order
+  defp sort_cycles_by_end_date(cycles) do
+    Enum.sort_by(
+      cycles,
       fn cycle ->
         interval = Map.get(cycle, :membership_fee_type).interval
         Mv.MembershipFees.CalendarCycles.calculate_cycle_end(cycle.cycle_start, interval)
       end,
       {:desc, Date}
     )
-      |> List.first()
-    else
-      nil
-    end
   end
 
   @doc false
@@ -668,6 +681,14 @@ defmodule Mv.Membership.Member do
     cycles = Map.get(member, :membership_fee_cycles)
 
     if is_list(cycles) and cycles != [] do
+      filter_overdue_cycles(cycles, today)
+    else
+      []
+    end
+  end
+
+  # Filters cycles that are unpaid and have ended (cycle_end < today)
+  defp filter_overdue_cycles(cycles, today) do
     Enum.filter(cycles, fn cycle ->
       case Map.get(cycle, :membership_fee_type) do
         %{interval: interval} ->
@@ -680,18 +701,11 @@ defmodule Mv.Membership.Member do
           false
       end
     end)
-    else
-      []
-    end
   end
 
   # Regenerates cycles when membership fee type changes
   # Deletes future unpaid cycles and regenerates them with the new type/amount
   defp regenerate_cycles_on_type_change(member) do
-    alias Mv.MembershipFees.MembershipFeeCycle
-    alias Mv.MembershipFees.CycleGenerator
-    alias Mv.MembershipFees.CalendarCycles
-
     require Ash.Query
 
     today = Date.utc_today()
@@ -699,58 +713,71 @@ defmodule Mv.Membership.Member do
     # Find all unpaid cycles for this member
     # We need to check cycle_end for each cycle using its own interval
     all_unpaid_cycles_query =
-      MembershipFeeCycle
+      Mv.MembershipFees.MembershipFeeCycle
       |> Ash.Query.filter(member_id == ^member.id)
       |> Ash.Query.filter(status == :unpaid)
       |> Ash.Query.load([:membership_fee_type])
 
     case Ash.read(all_unpaid_cycles_query) do
       {:ok, all_unpaid_cycles} ->
-        # Filter cycles that haven't ended yet (cycle_end >= today)
+        cycles_to_delete = filter_future_cycles(all_unpaid_cycles, today)
+        delete_and_regenerate_cycles(cycles_to_delete, member.id)
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  # Filters cycles that haven't ended yet (cycle_end >= today)
   # These are the "future" cycles that should be regenerated
-        # Use each cycle's own interval to calculate cycle_end
+  defp filter_future_cycles(all_unpaid_cycles, today) do
-        cycles_to_delete =
     Enum.filter(all_unpaid_cycles, fn cycle ->
       case cycle.membership_fee_type do
         %{interval: interval} ->
-                cycle_end = CalendarCycles.calculate_cycle_end(cycle.cycle_start, interval)
+          cycle_end =
+            Mv.MembershipFees.CalendarCycles.calculate_cycle_end(cycle.cycle_start, interval)
+
           Date.compare(today, cycle_end) in [:lt, :eq]
 
         _ ->
           false
       end
     end)
+  end
 
-        # Delete future unpaid cycles
+  # Deletes future cycles and regenerates them with the new type/amount
+  defp delete_and_regenerate_cycles(cycles_to_delete, member_id) do
     if Enum.empty?(cycles_to_delete) do
       # No cycles to delete, just regenerate
-          case CycleGenerator.generate_cycles_for_member(member.id) do
+      regenerate_cycles(member_id)
-            {:ok, _cycles} -> :ok
+    else
+      case delete_cycles(cycles_to_delete) do
+        :ok -> regenerate_cycles(member_id)
         {:error, reason} -> {:error, reason}
       end
-        else
+    end
+  end
+
+  # Deletes cycles and returns :ok if all succeeded, {:error, reason} otherwise
+  defp delete_cycles(cycles_to_delete) do
     delete_results =
       Enum.map(cycles_to_delete, fn cycle ->
         Ash.destroy(cycle)
       end)
 
-          # Check if any deletions failed
     if Enum.any?(delete_results, &match?({:error, _}, &1)) do
       {:error, :deletion_failed}
     else
-            # Regenerate cycles with new type/amount
+      :ok
-            # CycleGenerator uses its own transaction with advisory lock
-            # It will reload the member, so it will see the deleted cycles are gone
-            # and the new membership_fee_type_id
-            case CycleGenerator.generate_cycles_for_member(member.id) do
-              {:ok, _cycles} -> :ok
-              {:error, reason} -> {:error, reason}
-            end
     end
   end
 
-      {:error, reason} ->
+  # Regenerates cycles with new type/amount
-        {:error, reason}
+  # CycleGenerator uses its own transaction with advisory lock
+  defp regenerate_cycles(member_id) do
+    case Mv.MembershipFees.CycleGenerator.generate_cycles_for_member(member_id) do
+      {:ok, _cycles} -> :ok
+      {:error, reason} -> {:error, reason}
     end
   end
 

lib/membership_fees/changes/validate_same_interval.ex

@@ -37,15 +37,23 @@ defmodule Mv.MembershipFees.Changes.ValidateSameInterval do
     current_type_id = get_current_type_id(changeset)
     new_type_id = get_new_type_id(changeset)
 
+    cond do
       # If no current type, allow any change (first assignment)
-    if is_nil(current_type_id) do
+      is_nil(current_type_id) ->
         changeset
-    else
+
       # If new type is nil, that's allowed (removing type)
-      if is_nil(new_type_id) do
+      is_nil(new_type_id) ->
         changeset
-      else
+
       # Both types exist - validate intervals match
+      true ->
+        validate_intervals_match(changeset, current_type_id, new_type_id)
+    end
+  end
+
+  # Validates that intervals match when both types exist
+  defp validate_intervals_match(changeset, current_type_id, new_type_id) do
     case get_intervals(current_type_id, new_type_id) do
       {:ok, current_interval, new_interval} ->
         if current_interval == new_interval do
@@ -60,8 +68,6 @@ defmodule Mv.MembershipFees.Changes.ValidateSameInterval do
         changeset
     end
   end
-    end
-  end
 
   # Get current type ID from changeset data
   defp get_current_type_id(changeset) do

test/membership_fees/changes/validate_same_interval_test.exs

@@ -215,8 +215,7 @@ defmodule Mv.MembershipFees.Changes.ValidateSameIntervalTest do
     defp extract_error_message(%Ash.Error.Invalid{errors: errors}) do
       errors
       |> Enum.filter(&(&1.field == :membership_fee_type_id))
-      |> Enum.map(& &1.message)
+      |> Enum.map_join(" ", & &1.message)
-      |> Enum.join(" ")
     end
   end
 end