wip

app/Models/Accounting/RecurringInvoice.php

 
     public function hasSchedule(): bool
     {
-        return $this->start_date !== null;
+        if (! $this->start_date) {
+            return false;
+        }
+
+        if (! $this->wasApproved() && $this->start_date->lt(today())) {
+            return false;
+        }
+
+        return true;
     }
 
     public function getScheduleDescription(): string
     {
         $lastDate ??= $this->last_date;
 
-        if (! $lastDate && $this->start_date) {
+        if (! $lastDate && $this->start_date && $this->wasApproved()) {
             return $this->start_date;
         }
 

app/Observers/RecurringInvoiceObserver.php

 {
     public function saving(RecurringInvoice $recurringInvoice): void
     {
-        if (($recurringInvoice->isDirty('start_date') && ! $recurringInvoice->last_date) || $this->otherScheduleDetailsChanged($recurringInvoice)) {
+        if (
+            $recurringInvoice->wasApproved() &&
+            (($recurringInvoice->isDirty('start_date') && ! $recurringInvoice->last_date) || $this->otherScheduleDetailsChanged($recurringInvoice))
+        ) {
             $recurringInvoice->next_date = $recurringInvoice->calculateNextDate();
         }
 

database/factories/Accounting/DocumentLineItemFactory.php

 use App\Models\Accounting\DocumentLineItem;
 use App\Models\Accounting\Estimate;
 use App\Models\Accounting\Invoice;
+use App\Models\Accounting\RecurringInvoice;
 use App\Models\Common\Offering;
 use Illuminate\Database\Eloquent\Factories\Factory;
 
         ];
     }
 
-    public function forInvoice(Invoice $invoice): static
+    public function forInvoice(Invoice | RecurringInvoice $invoice): static
     {
         return $this
             ->for($invoice, 'documentable')

database/factories/Accounting/RecurringInvoiceFactory.php

 use App\Enums\Accounting\Month;
 use App\Enums\Accounting\RecurringInvoiceStatus;
 use App\Enums\Setting\PaymentTerms;
+use App\Models\Accounting\DocumentLineItem;
 use App\Models\Accounting\RecurringInvoice;
 use App\Models\Common\Client;
 use Illuminate\Database\Eloquent\Factories\Factory;
         return [
             'company_id' => 1,
             'client_id' => Client::inRandomOrder()->value('id'),
+            'header' => 'Invoice',
+            'subheader' => 'Invoice',
+            'order_number' => $this->faker->unique()->numerify('ORD-#####'),
+            'payment_terms' => PaymentTerms::Net30,
             'status' => RecurringInvoiceStatus::Draft,
-
-            // Schedule configuration
-            'frequency' => Frequency::Monthly,
-            'day_of_month' => DayOfMonth::First,
-
-            // Date configuration
-            'start_date' => now()->addMonth()->startOfMonth(),
-            'end_type' => EndType::Never,
-
-            // Invoice configuration
-            'payment_terms' => PaymentTerms::DueUponReceipt,
             'currency_code' => 'USD',
-
-            // Timestamps and user tracking
             'terms' => $this->faker->sentence,
             'footer' => $this->faker->sentence,
             'created_by' => 1,
         ];
     }
 
-    public function weekly(DayOfWeek $dayOfWeek = DayOfWeek::Monday): self
+    public function withLineItems(int $count = 3): static
+    {
+        return $this->afterCreating(function (RecurringInvoice $recurringInvoice) use ($count) {
+            DocumentLineItem::factory()
+                ->count($count)
+                ->forInvoice($recurringInvoice)
+                ->create();
+
+            $this->recalculateTotals($recurringInvoice);
+        });
+    }
+
+    public function withSchedule(
+        ?Frequency $frequency = null,
+        ?Carbon $startDate = null,
+        ?EndType $endType = null
+    ): static {
+        $frequency ??= $this->faker->randomElement(Frequency::class);
+        $endType ??= EndType::Never;
+
+        // Adjust the start date range based on frequency
+        $startDate = match ($frequency) {
+            Frequency::Daily => Carbon::parse($this->faker->dateTimeBetween('-30 days')), // At most 30 days back
+            default => $startDate ?? Carbon::parse($this->faker->dateTimeBetween('-1 year')),
+        };
+
+        return match ($frequency) {
+            Frequency::Daily => $this->withDailySchedule($startDate, $endType),
+            Frequency::Weekly => $this->withWeeklySchedule($startDate, $endType),
+            Frequency::Monthly => $this->withMonthlySchedule($startDate, $endType),
+            Frequency::Yearly => $this->withYearlySchedule($startDate, $endType),
+            Frequency::Custom => $this->withCustomSchedule($startDate, $endType),
+        };
+    }
+
+    protected function withDailySchedule(Carbon $startDate, EndType $endType): static
+    {
+        return $this->state([
+            'frequency' => Frequency::Daily,
+            'start_date' => $startDate,
+            'end_type' => $endType,
+        ]);
+    }
+
+    protected function withWeeklySchedule(Carbon $startDate, EndType $endType): static
     {
         return $this->state([
             'frequency' => Frequency::Weekly,
-            'day_of_week' => $dayOfWeek,
+            'day_of_week' => DayOfWeek::from($startDate->dayOfWeek),
+            'start_date' => $startDate,
+            'end_type' => $endType,
         ]);
     }
 
-    public function monthly(DayOfMonth $dayOfMonth = DayOfMonth::First): self
+    protected function withMonthlySchedule(Carbon $startDate, EndType $endType): static
     {
         return $this->state([
             'frequency' => Frequency::Monthly,
-            'day_of_month' => $dayOfMonth,
+            'day_of_month' => DayOfMonth::from($startDate->day),
+            'start_date' => $startDate,
+            'end_type' => $endType,
         ]);
     }
 
-    public function yearly(Month $month = Month::January, DayOfMonth $dayOfMonth = DayOfMonth::First): self
+    protected function withYearlySchedule(Carbon $startDate, EndType $endType): static
     {
         return $this->state([
             'frequency' => Frequency::Yearly,
-            'month' => $month,
-            'day_of_month' => $dayOfMonth,
+            'month' => Month::from($startDate->month),
+            'day_of_month' => DayOfMonth::from($startDate->day),
+            'start_date' => $startDate,
+            'end_type' => $endType,
         ]);
     }
 
-    public function custom(IntervalType $intervalType, int $intervalValue = 1): self
-    {
-        return $this->state([
+    protected function withCustomSchedule(
+        Carbon $startDate,
+        EndType $endType,
+        ?IntervalType $intervalType = null,
+        ?int $intervalValue = null
+    ): static {
+        $intervalType ??= $this->faker->randomElement(IntervalType::class);
+        $intervalValue ??= match ($intervalType) {
+            IntervalType::Day => $this->faker->numberBetween(1, 7),
+            IntervalType::Week => $this->faker->numberBetween(1, 4),
+            IntervalType::Month => $this->faker->numberBetween(1, 3),
+            IntervalType::Year => 1,
+        };
+
+        $state = [
             'frequency' => Frequency::Custom,
             'interval_type' => $intervalType,
             'interval_value' => $intervalValue,
+            'start_date' => $startDate,
+            'end_type' => $endType,
+        ];
+
+        // Add interval-specific attributes
+        switch ($intervalType) {
+            case IntervalType::Day:
+                // No additional attributes needed
+                break;
+
+            case IntervalType::Week:
+                $state['day_of_week'] = DayOfWeek::from($startDate->dayOfWeek);
+
+                break;
+
+            case IntervalType::Month:
+                $state['day_of_month'] = DayOfMonth::from($startDate->day);
+
+                break;
+
+            case IntervalType::Year:
+                $state['month'] = Month::from($startDate->month);
+                $state['day_of_month'] = DayOfMonth::from($startDate->day);
+
+                break;
+        }
+
+        return $this->state($state);
+    }
+
+    public function endAfter(int $occurrences = 12): static
+    {
+        return $this->state([
+            'end_type' => EndType::After,
+            'max_occurrences' => $occurrences,
         ]);
     }
 
-    public function withEndDate(Carbon $endDate): self
+    public function endOn(?Carbon $endDate = null): static
     {
+        $endDate ??= now()->addMonths($this->faker->numberBetween(1, 12));
+
         return $this->state([
             'end_type' => EndType::On,
             'end_date' => $endDate,
         ]);
     }
 
-    public function withMaxOccurrences(int $maxOccurrences): self
+    public function autoSend(string $sendTime = '09:00'): static
     {
         return $this->state([
-            'end_type' => EndType::After,
-            'max_occurrences' => $maxOccurrences,
+            'auto_send' => true,
+            'send_time' => $sendTime,
         ]);
     }
 
-    public function autoSend(string $time = '09:00'): self
+    public function approved(): static
     {
-        return $this->state([
-            'auto_send' => true,
-            'send_time' => $time,
+        return $this->afterCreating(function (RecurringInvoice $recurringInvoice) {
+            $this->ensureLineItems($recurringInvoice);
+
+            if (! $recurringInvoice->hasSchedule()) {
+                $this->withSchedule()->callAfterCreating(collect([$recurringInvoice]));
+                $recurringInvoice->refresh();
+            }
+
+            if (! $recurringInvoice->canBeApproved()) {
+                return;
+            }
+
+            $approvedAt = $recurringInvoice->start_date
+                ? $recurringInvoice->start_date->copy()->subDays($this->faker->numberBetween(1, 7))
+                : now()->subDays($this->faker->numberBetween(1, 30));
+
+            $recurringInvoice->approveDraft($approvedAt);
+        });
+    }
+
+    public function active(): static
+    {
+        return $this->withLineItems()
+            ->withSchedule()
+            ->approved();
+    }
+
+    public function ended(): static
+    {
+        return $this->afterCreating(function (RecurringInvoice $recurringInvoice) {
+            if (! $recurringInvoice->canBeEnded()) {
+                $this->active()->callAfterCreating(collect([$recurringInvoice]));
+            }
+
+            $endedAt = now()->subDays($this->faker->numberBetween(1, 30));
+
+            $recurringInvoice->update([
+                'ended_at' => $endedAt,
+                'status' => RecurringInvoiceStatus::Ended,
+            ]);
+        });
+    }
+
+    public function configure(): static
+    {
+        return $this->afterCreating(function (RecurringInvoice $recurringInvoice) {
+            $this->ensureLineItems($recurringInvoice);
+
+            $nextDate = $recurringInvoice->calculateNextDate();
+
+            if ($nextDate) {
+                $recurringInvoice->updateQuietly([
+                    'next_date' => $nextDate,
+                ]);
+            }
+        });
+    }
+
+    protected function ensureLineItems(RecurringInvoice $recurringInvoice): void
+    {
+        if (! $recurringInvoice->hasLineItems()) {
+            $this->withLineItems()->callAfterCreating(collect([$recurringInvoice]));
+        }
+    }
+
+    protected function recalculateTotals(RecurringInvoice $recurringInvoice): void
+    {
+        $recurringInvoice->refresh();
+
+        if (! $recurringInvoice->hasLineItems()) {
+            return;
+        }
+
+        $subtotal = $recurringInvoice->lineItems()->sum('subtotal') / 100;
+        $taxTotal = $recurringInvoice->lineItems()->sum('tax_total') / 100;
+        $discountTotal = $recurringInvoice->lineItems()->sum('discount_total') / 100;
+        $grandTotal = $subtotal + $taxTotal - $discountTotal;
+
+        $recurringInvoice->update([
+            'subtotal' => $subtotal,
+            'tax_total' => $taxTotal,
+            'discount_total' => $discountTotal,
+            'total' => $grandTotal,
         ]);
     }
 }

database/factories/CompanyFactory.php

 
 namespace Database\Factories;
 
+use App\Enums\Accounting\Frequency;
 use App\Models\Accounting\Bill;
 use App\Models\Accounting\Estimate;
 use App\Models\Accounting\Invoice;
+use App\Models\Accounting\RecurringInvoice;
 use App\Models\Accounting\Transaction;
 use App\Models\Common\Client;
 use App\Models\Common\Offering;
         });
     }
 
+    public function withRecurringInvoices(int $count = 10): self
+    {
+        return $this->afterCreating(function (Company $company) use ($count) {
+            $draftCount = (int) floor($count * 0.2);     // 20% drafts without schedule
+            $scheduledCount = (int) floor($count * 0.2);  // 20% drafts with schedule
+            $activeCount = (int) floor($count * 0.4);     // 40% active and generating
+            $endedCount = (int) floor($count * 0.1);      // 10% manually ended
+            $completedCount = $count - ($draftCount + $scheduledCount + $activeCount + $endedCount); // 10% completed by end conditions
+
+            // Draft recurring invoices (no schedule)
+            RecurringInvoice::factory()
+                ->count($draftCount)
+                ->withLineItems()
+                ->create([
+                    'company_id' => $company->id,
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+
+            // Draft recurring invoices with schedule
+            RecurringInvoice::factory()
+                ->count($scheduledCount)
+                ->withLineItems()
+                ->withSchedule()
+                ->create([
+                    'company_id' => $company->id,
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+
+            // Active recurring invoices with various schedules and historical invoices
+            $frequencies = [
+                Frequency::Daily,
+                Frequency::Weekly,
+                Frequency::Monthly,
+                Frequency::Yearly,
+                Frequency::Custom,
+            ];
+
+            foreach (array_chunk(range(1, $activeCount), (int) ceil($activeCount / count($frequencies))) as $chunk) {
+                RecurringInvoice::factory()
+                    ->count(count($chunk))
+                    ->withLineItems()
+                    ->withSchedule(fake()->randomElement($frequencies)) // Randomize frequency
+                    ->active()
+                    ->create([
+                        'company_id' => $company->id,
+                        'created_by' => $company->user_id,
+                        'updated_by' => $company->user_id,
+                    ]);
+            }
+
+            // Manually ended recurring invoices
+            RecurringInvoice::factory()
+                ->count($endedCount)
+                ->withLineItems()
+                ->withSchedule()
+                ->ended()
+                ->create([
+                    'company_id' => $company->id,
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+
+            // Completed recurring invoices (reached end conditions)
+            RecurringInvoice::factory()
+                ->count($completedCount)
+                ->withLineItems()
+                ->withSchedule()
+                ->endAfter($this->faker->numberBetween(5, 12))
+                ->active()
+                ->create([
+                    'company_id' => $company->id,
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+        });
+    }
+
     public function withEstimates(int $count = 10): self
     {
         return $this->afterCreating(function (Company $company) use ($count) {

database/seeders/DatabaseSeeder.php

                     ->withClients()
                     ->withVendors()
                     ->withInvoices(50)
+                    ->withRecurringInvoices()
                     ->withEstimates(50)
                     ->withBills(50);
             })