feat: create and generate pending recurrences

Author: danielnottingham

app/models/medical_shift_recurrence.rb

@@ -23,6 +23,11 @@ class MedicalShiftRecurrence < ApplicationRecord
 
   validate :day_of_month_blank_for_weekly
   validate :day_of_week_blank_for_monthly
+  validate :end_date_after_start_date
+  validate :start_date_not_in_past
+
+  scope :active, -> { where(deleted_at: nil) }
+  scope :needs_generation, MedicalShiftRecurrences::NeedsGenerationQuery
 
   private
 
@@ -37,4 +42,16 @@ def day_of_week_blank_for_monthly
 
     errors.add(:day_of_week, "It must be empty for monthly_fixed_day recurrence.")
   end
+
+  def end_date_after_start_date
+    return unless end_date.present? && start_date.present? && end_date < start_date
+
+    errors.add(:end_date, "End date must be after start date.")
+  end
+
+  def start_date_not_in_past
+    return unless start_date.present? && start_date < Time.zone.today
+
+    errors.add(:start_date, "Start date cannot be in the past.")
+  end
 end

app/operations/medical_shift_recurrences/create.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module MedicalShiftRecurrences
+  class Create < Actor
+    input :attributes, type: Hash
+    input :user_id, type: Integer
+
+    output :medical_shift_recurrence, type: MedicalShiftRecurrence
+    output :shifts_created, type: Array, default: -> { [] }
+
+    GENERATION_HORIZON_MONTHS = 2
+
+    def call
+      create_recurrence
+      initialize_shifts_array
+      generate_shifts
+    end
+
+    private
+
+    def create_recurrence
+      self.medical_shift_recurrence = MedicalShiftRecurrence.new(
+        attributes.reverse_merge(user_id: user_id)
+      )
+
+      fail!(error: medical_shift_recurrence.errors.full_messages) unless medical_shift_recurrence.save
+    end
+
+    def initialize_shifts_array
+      self.shifts_created = []
+    end
+
+    def generate_shifts
+      target_date = GENERATION_HORIZON_MONTHS.months.from_now.to_date
+      dates = MedicalShiftRecurrences::RecurrenceDateCalculatorService.new(
+        medical_shift_recurrence
+      ).dates_until(target_date)
+
+      dates.each do |date|
+        result = MedicalShifts::Create.result(
+          attributes: shift_attributes(date),
+          user_id: user_id
+        )
+
+        shifts_created << result.medical_shift if result.success?
+      end
+
+      medical_shift_recurrence.update!(last_generated_until: target_date) if shifts_created.any?
+    end
+
+    def shift_attributes(date)
+      {
+        start_date: date,
+        start_hour: medical_shift_recurrence.start_hour,
+        workload: medical_shift_recurrence.workload,
+        hospital_name: medical_shift_recurrence.hospital_name,
+        amount_cents: medical_shift_recurrence.amount_cents,
+        medical_shift_recurrence_id: medical_shift_recurrence.id,
+        paid: false
+      }
+    end
+  end
+end

app/operations/medical_shift_recurrences/generate_pending.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module MedicalShiftRecurrences
+  class GeneratePending < Actor
+    input :target_date, type: Date, default: -> { 2.months.from_now.to_date }
+
+    output :processed, type: Integer, default: 0
+    output :shifts_created, type: Integer, default: 0
+    output :errors, type: Array, default: -> { [] }
+
+    def call
+      self.processed = 0
+      self.shifts_created = 0
+      self.errors = []
+
+      MedicalShiftRecurrence.needs_generation(target_date:).find_each do |recurrence|
+        process_recurrence(recurrence)
+      end
+    end
+
+    private
+
+    def process_recurrence(recurrence)
+      dates = MedicalShiftRecurrences::RecurrenceDateCalculatorService.new(recurrence).dates_until(target_date)
+
+      created_count = 0
+      dates.each do |date|
+        result = MedicalShifts::Create.call(
+          attributes: shift_attributes(recurrence, date),
+          user_id: recurrence.user_id
+        )
+        created_count += 1 if result.success?
+      end
+
+      recurrence.update!(last_generated_until: target_date) if created_count.positive?
+
+      self.processed += 1
+      self.shifts_created += created_count
+    rescue StandardError => e
+      errors << { recurrence_id: recurrence.id, error: e.message }
+    end
+
+    def shift_attributes(recurrence, date)
+      {
+        start_date: date,
+        start_hour: recurrence.start_hour,
+        workload: recurrence.workload,
+        hospital_name: recurrence.hospital_name,
+        amount_cents: recurrence.amount_cents,
+        medical_shift_recurrence_id: recurrence.id,
+        paid: false
+      }
+    end
+  end
+end

app/queries/medical_shift_recurrences/needs_generation_query.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module MedicalShiftRecurrences
+  class NeedsGenerationQuery < ApplicationQuery
+    attr_reader :target_date, :relation
+
+    def initialize(target_date:, relation: MedicalShiftRecurrence)
+      @target_date = target_date
+      @relation = relation
+    end
+
+    def call
+      relation
+        .active
+        .where(
+          "last_generated_until IS NULL OR last_generated_until < ?",
+          target_date
+        )
+    end
+  end
+end

app/services/medical_shift_recurrences/recurrence_date_calculator_service.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module MedicalShiftRecurrences
+  class RecurrenceDateCalculatorService
+    def initialize(recurrence)
+      @recurrence = recurrence
+    end
+
+    def dates_until(target_date)
+      return [] if @recurrence.deleted_at.present?
+
+      dates = []
+      current_date = starting_point
+      end_date = effective_end_date(target_date)
+
+      while current_date && current_date <= end_date
+        dates << current_date
+        current_date = next_occurrence(current_date)
+
+        break if dates.size > 365 # Safety
+      end
+
+      dates
+    end
+
+    private
+
+    def starting_point
+      if @recurrence.last_generated_until.present?
+        next_occurrence(@recurrence.last_generated_until)
+      else
+        first_occurrence_after_start_date
+      end
+    end
+
+    def first_occurrence_after_start_date
+      case @recurrence.frequency
+      when "weekly"
+        find_next_weekly_after(@recurrence.start_date, @recurrence.day_of_week)
+      when "biweekly"
+        find_next_biweekly_after(@recurrence.start_date, @recurrence.day_of_week)
+      when "monthly_fixed_day"
+        find_next_month_day_after(@recurrence.start_date, @recurrence.day_of_month)
+      end
+    end
+
+    def find_next_weekly_after(from_date, target_wday)
+      # Se from_date já é o dia correto, pula 7 dias
+      return from_date + 7.days if from_date.wday == target_wday
+
+      # Caso contrário, encontra o próximo dia da semana
+      days_ahead = target_wday - from_date.wday
+      days_ahead += 7 if days_ahead < 0
+
+      from_date + days_ahead.days
+    end
+
+    def find_next_biweekly_after(from_date, target_wday)
+      # Se from_date já é o dia correto, pula 14 dias (2 semanas)
+      return from_date + 14.days if from_date.wday == target_wday
+
+      # Caso contrário, encontra o próximo dia da semana
+      days_ahead = target_wday - from_date.wday
+      days_ahead += 7 if days_ahead < 0
+
+      from_date + days_ahead.days
+    end
+
+    def find_next_month_day_after(from_date, target_day)
+      # Se é o dia correto no mês atual, pula para o próximo mês
+      if from_date.day == target_day && month_has_day?(from_date, target_day)
+        return next_month_with_day(from_date, target_day)
+      end
+
+      # Tenta no mês atual primeiro
+      return from_date.change(day: target_day) if from_date.day < target_day && month_has_day?(from_date, target_day)
+
+      # Se não, próximo mês
+      next_month_with_day(from_date, target_day)
+    end
+
+    def next_occurrence(from_date)
+      case @recurrence.frequency
+      when "weekly"
+        from_date + 7.days
+      when "biweekly"
+        from_date + 14.days
+      when "monthly_fixed_day"
+        next_month_with_day(from_date, @recurrence.day_of_month)
+      end
+    end
+
+    def next_month_with_day(from_date, target_day)
+      current = from_date.next_month.beginning_of_month
+
+      12.times do
+        return current.change(day: target_day) if month_has_day?(current, target_day)
+
+        current = current.next_month
+      end
+
+      nil
+    end
+
+    def month_has_day?(date, day)
+      day <= date.end_of_month.day
+    end
+
+    def effective_end_date(target_date)
+      dates = [target_date]
+      dates << @recurrence.end_date if @recurrence.end_date.present?
+      dates.min
+    end
+  end
+end

spec/factories/medical_shift_recurrences.rb

@@ -6,10 +6,10 @@
 
     frequency { "weekly" }
     day_of_week { 3 } # quarta-feira
-    start_date { Date.tomorrow }
-    workload { "12h" }
-    start_hour { "19:00" }
-    hospital_name { "Hospital Teste" }
+    start_date { Time.zone.today }
+    workload { MedicalShifts::Workloads::SIX }
+    start_hour { "19:00:00" }
+    hospital_name { create(:hospital).name }
     amount_cents { 120_000 }
 
     trait :weekly do