wip

app/Filament/Company/Resources/Sales/InvoiceResource.php

@@ -163,7 +163,7 @@ class InvoiceResource extends Resource
                                         $invoiceDate = $get('date');
                                         $paymentTerms = $get('payment_terms');
 
-                                        if (! $invoiceDate || $paymentTerms === 'custom') {
+                                        if (! $invoiceDate || $paymentTerms === 'custom' || ! $paymentTerms) {
                                             return;
                                         }
 

database/factories/Accounting/InvoiceFactory.php

@@ -15,6 +15,7 @@ use App\Models\Setting\DocumentDefault;
 use App\Utilities\RateCalculator;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Support\Carbon;
+use Random\RandomException;
 
 /**
  * @extends Factory<Invoice>
@@ -33,17 +34,22 @@ class InvoiceFactory extends Factory
      */
     public function definition(): array
     {
-        $invoiceDate = $this->faker->dateTimeBetween('-1 year');
+        $invoiceDate = $this->faker->dateTimeBetween('-2 months');
 
         return [
             'company_id' => 1,
-            'client_id' => fn (array $attributes) => Client::where('company_id', $attributes['company_id'])->inRandomOrder()->value('id'),
+            'client_id' => function (array $attributes) {
+                return Client::where('company_id', $attributes['company_id'])->inRandomOrder()->value('id')
+                    ?? Client::factory()->state([
+                        'company_id' => $attributes['company_id'],
+                    ]);
+            },
             'header' => 'Invoice',
             'subheader' => 'Invoice',
             'invoice_number' => $this->faker->unique()->numerify('INV-####'),
             'order_number' => $this->faker->unique()->numerify('ORD-####'),
             'date' => $invoiceDate,
-            'due_date' => Carbon::parse($invoiceDate)->addDays($this->faker->numberBetween(14, 60)),
+            'due_date' => $this->faker->dateTimeInInterval($invoiceDate, '+3 months'),
             'status' => InvoiceStatus::Draft,
             'discount_method' => $this->faker->randomElement(DocumentDiscountMethod::class),
             'discount_computation' => AdjustmentComputation::Percentage,
@@ -85,58 +91,38 @@ class InvoiceFactory extends Factory
     public function approved(): static
     {
         return $this->afterCreating(function (Invoice $invoice) {
-            $this->ensureLineItems($invoice);
-
-            if (! $invoice->canBeApproved()) {
-                return;
-            }
-
-            $approvedAt = Carbon::parse($invoice->date)
-                ->addHours($this->faker->numberBetween(1, 24));
-
-            $invoice->approveDraft($approvedAt);
+            $this->performApproval($invoice);
         });
     }
 
     public function sent(): static
     {
         return $this->afterCreating(function (Invoice $invoice) {
-            $this->ensureApproved($invoice);
-
-            $sentAt = Carbon::parse($invoice->approved_at)
-                ->addHours($this->faker->numberBetween(1, 24));
-
-            $invoice->markAsSent($sentAt);
+            $this->performSent($invoice);
         });
     }
 
     public function partial(int $maxPayments = 4): static
     {
         return $this->afterCreating(function (Invoice $invoice) use ($maxPayments) {
-            $this->ensureSent($invoice);
-
-            $this->withPayments(max: $maxPayments, invoiceStatus: InvoiceStatus::Partial)
-                ->callAfterCreating(collect([$invoice]));
+            $this->performSent($invoice);
+            $this->performPayments($invoice, $maxPayments, InvoiceStatus::Partial);
         });
     }
 
     public function paid(int $maxPayments = 4): static
     {
         return $this->afterCreating(function (Invoice $invoice) use ($maxPayments) {
-            $this->ensureSent($invoice);
-
-            $this->withPayments(max: $maxPayments)
-                ->callAfterCreating(collect([$invoice]));
+            $this->performSent($invoice);
+            $this->performPayments($invoice, $maxPayments, InvoiceStatus::Paid);
         });
     }
 
     public function overpaid(int $maxPayments = 4): static
     {
         return $this->afterCreating(function (Invoice $invoice) use ($maxPayments) {
-            $this->ensureSent($invoice);
-
-            $this->withPayments(max: $maxPayments, invoiceStatus: InvoiceStatus::Overpaid)
-                ->callAfterCreating(collect([$invoice]));
+            $this->performSent($invoice);
+            $this->performPayments($invoice, $maxPayments, InvoiceStatus::Overpaid);
         });
     }
 
@@ -147,77 +133,98 @@ class InvoiceFactory extends Factory
                 'due_date' => now()->subDays($this->faker->numberBetween(1, 30)),
             ])
             ->afterCreating(function (Invoice $invoice) {
-                $this->ensureApproved($invoice);
+                $this->performApproval($invoice);
             });
     }
 
-    public function withPayments(?int $min = null, ?int $max = null, InvoiceStatus $invoiceStatus = InvoiceStatus::Paid): static
+    protected function performApproval(Invoice $invoice): void
     {
-        $min ??= 1;
+        if (! $invoice->hasLineItems()) {
+            throw new \InvalidArgumentException('Cannot approve invoice without line items. Use withLineItems() first.');
+        }
 
-        return $this->afterCreating(function (Invoice $invoice) use ($invoiceStatus, $max, $min) {
-            $this->ensureSent($invoice);
+        if (! $invoice->canBeApproved()) {
+            throw new \InvalidArgumentException('Invoice cannot be approved. Current status: ' . $invoice->status->value);
+        }
 
-            $invoice->refresh();
+        $approvedAt = Carbon::parse($invoice->date)
+            ->addHours($this->faker->numberBetween(1, 24));
 
-            $amountDue = $invoice->getRawOriginal('amount_due');
+        $invoice->approveDraft($approvedAt);
+    }
 
-            $totalAmountDue = match ($invoiceStatus) {
-                InvoiceStatus::Overpaid => $amountDue + random_int(1000, 10000),
-                InvoiceStatus::Partial => (int) floor($amountDue * 0.5),
-                default => $amountDue,
-            };
+    protected function performSent(Invoice $invoice): void
+    {
+        if (! $invoice->wasApproved()) {
+            $this->performApproval($invoice);
+        }
 
-            if ($totalAmountDue <= 0 || empty($totalAmountDue)) {
-                return;
-            }
+        $sentAt = Carbon::parse($invoice->approved_at)
+            ->addHours($this->faker->numberBetween(1, 24));
 
-            $paymentCount = $max && $min ? $this->faker->numberBetween($min, $max) : $min;
-            $paymentAmount = (int) floor($totalAmountDue / $paymentCount);
-            $remainingAmount = $totalAmountDue;
+        $invoice->markAsSent($sentAt);
+    }
 
-            $paymentDate = Carbon::parse($invoice->approved_at);
-            $paymentDates = [];
+    /**
+     * @throws RandomException
+     */
+    protected function performPayments(Invoice $invoice, int $maxPayments, InvoiceStatus $invoiceStatus): void
+    {
+        $invoice->refresh();
 
-            for ($i = 0; $i < $paymentCount; $i++) {
-                $amount = $i === $paymentCount - 1 ? $remainingAmount : $paymentAmount;
+        $amountDue = $invoice->getRawOriginal('amount_due');
 
-                if ($amount <= 0) {
-                    break;
-                }
+        $totalAmountDue = match ($invoiceStatus) {
+            InvoiceStatus::Overpaid => $amountDue + random_int(1000, 10000),
+            InvoiceStatus::Partial => (int) floor($amountDue * 0.5),
+            default => $amountDue,
+        };
 
-                $postedAt = $paymentDate->copy()->addDays($this->faker->numberBetween(1, 30));
-                $paymentDates[] = $postedAt;
+        if ($totalAmountDue <= 0 || empty($totalAmountDue)) {
+            return;
+        }
 
-                $data = [
-                    'posted_at' => $postedAt,
-                    'amount' => $amount,
-                    'payment_method' => $this->faker->randomElement(PaymentMethod::class),
-                    'bank_account_id' => BankAccount::where('company_id', $invoice->company_id)->inRandomOrder()->value('id'),
-                    'notes' => $this->faker->sentence,
-                ];
+        $paymentCount = $this->faker->numberBetween(1, $maxPayments);
+        $paymentAmount = (int) floor($totalAmountDue / $paymentCount);
+        $remainingAmount = $totalAmountDue;
 
-                $invoice->recordPayment($data);
-                $remainingAmount -= $amount;
-            }
+        $paymentDate = Carbon::parse($invoice->approved_at);
+        $paymentDates = [];
+
+        for ($i = 0; $i < $paymentCount; $i++) {
+            $amount = $i === $paymentCount - 1 ? $remainingAmount : $paymentAmount;
 
-            if ($invoiceStatus !== InvoiceStatus::Paid) {
-                return;
+            if ($amount <= 0) {
+                break;
             }
 
+            $postedAt = $paymentDate->copy()->addDays($this->faker->numberBetween(1, 30));
+            $paymentDates[] = $postedAt;
+
+            $data = [
+                'posted_at' => $postedAt,
+                'amount' => $amount,
+                'payment_method' => $this->faker->randomElement(PaymentMethod::class),
+                'bank_account_id' => BankAccount::where('company_id', $invoice->company_id)->inRandomOrder()->value('id'),
+                'notes' => $this->faker->sentence,
+            ];
+
+            $invoice->recordPayment($data);
+            $remainingAmount -= $amount;
+        }
+
+        if ($invoiceStatus === InvoiceStatus::Paid && ! empty($paymentDates)) {
             $latestPaymentDate = max($paymentDates);
             $invoice->updateQuietly([
                 'status' => $invoiceStatus,
                 'paid_at' => $latestPaymentDate,
             ]);
-        });
+        }
     }
 
     public function configure(): static
     {
         return $this->afterCreating(function (Invoice $invoice) {
-            $this->ensureLineItems($invoice);
-
             $number = DocumentDefault::getBaseNumber() + $invoice->id;
 
             $invoice->updateQuietly([
@@ -233,27 +240,6 @@ class InvoiceFactory extends Factory
         });
     }
 
-    protected function ensureLineItems(Invoice $invoice): void
-    {
-        if (! $invoice->hasLineItems()) {
-            $this->withLineItems()->callAfterCreating(collect([$invoice]));
-        }
-    }
-
-    protected function ensureApproved(Invoice $invoice): void
-    {
-        if (! $invoice->wasApproved()) {
-            $this->approved()->callAfterCreating(collect([$invoice]));
-        }
-    }
-
-    protected function ensureSent(Invoice $invoice): void
-    {
-        if (! $invoice->hasBeenSent()) {
-            $this->sent()->callAfterCreating(collect([$invoice]));
-        }
-    }
-
     protected function recalculateTotals(Invoice $invoice): void
     {
         $invoice->refresh();

database/factories/CompanyFactory.php

@@ -133,6 +133,7 @@ class CompanyFactory extends Factory
 
             Invoice::factory()
                 ->count($draftCount)
+                ->withLineItems()
                 ->create([
                     'company_id' => $company->id,
                     'created_by' => $company->user_id,

tests/Feature/Accounting/InvoiceTest.php

@@ -0,0 +1,147 @@
+<?php
+
+use App\Enums\Accounting\InvoiceStatus;
+use App\Models\Accounting\Invoice;
+use App\Utilities\Currency\CurrencyAccessor;
+
+beforeEach(function () {
+    $this->defaultCurrency = CurrencyAccessor::getDefaultCurrency();
+    $this->withOfferings();
+});
+
+it('creates a basic invoice with line items and calculates totals correctly', function () {
+    $invoice = Invoice::factory()
+        ->withLineItems(2)
+        ->create();
+
+    $invoice->refresh();
+
+    expect($invoice)
+        ->hasLineItems()->toBeTrue()
+        ->lineItems->count()->toBe(2)
+        ->subtotal->toBeGreaterThan(0)
+        ->total->toBeGreaterThan(0)
+        ->amount_due->toBe($invoice->total);
+});
+
+describe('invoice approval', function () {
+    beforeEach(function () {
+        $this->invoice = Invoice::factory()
+            ->withLineItems()
+            ->approved()
+            ->create();
+    });
+
+    test('approved invoices are marked as Unsent when not Overdue', function () {
+        $this->invoice->update(['due_date' => now()->addDays(30)]);
+
+        $this->invoice->refresh();
+
+        expect($this->invoice)
+            ->hasLineItems()->toBeTrue()
+            ->status->toBe(InvoiceStatus::Unsent)
+            ->wasApproved()->toBeTrue()
+            ->approvalTransaction->not->toBeNull();
+    });
+});
+
+it('creates sent invoices with line items and approval automatically', function () {
+    $invoice = Invoice::factory()
+        ->withLineItems()
+        ->sent()
+        ->create();
+
+    $invoice->refresh();
+
+    expect($invoice)
+        ->hasLineItems()->toBeTrue()
+        ->lineItems->count()->toBeGreaterThan(0)
+        ->wasApproved()->toBeTrue()
+        ->hasBeenSent()->toBeTrue()
+        ->status->toBe(InvoiceStatus::Sent);
+});
+
+it('creates paid invoices with line items, approval, and payments automatically', function () {
+    $invoice = Invoice::factory()
+        ->withLineItems()
+        ->paid()
+        ->create();
+
+    $invoice->refresh();
+
+    expect($invoice)
+        ->hasLineItems()->toBeTrue()
+        ->lineItems->count()->toBeGreaterThan(0)
+        ->wasApproved()->toBeTrue()
+        ->hasBeenSent()->toBeTrue()
+        ->hasPayments()->toBeTrue()
+        ->isPaid()->toBeTrue()
+        ->status->toBe(InvoiceStatus::Paid);
+});
+
+it('creates partial invoices with line items and partial payments automatically', function () {
+    $invoice = Invoice::factory()
+        ->withLineItems()
+        ->partial()
+        ->create();
+
+    $invoice->refresh();
+
+    expect($invoice)
+        ->hasLineItems()->toBeTrue()
+        ->lineItems->count()->toBeGreaterThan(0)
+        ->wasApproved()->toBeTrue()
+        ->hasBeenSent()->toBeTrue()
+        ->hasPayments()->toBeTrue()
+        ->status->toBeIn([InvoiceStatus::Partial, InvoiceStatus::Overdue])
+        ->amount_paid->toBeGreaterThan(0)
+        ->amount_paid->toBeLessThan($invoice->total);
+});
+
+it('creates overpaid invoices with line items and overpayments automatically', function () {
+    $invoice = Invoice::factory()
+        ->withLineItems()
+        ->overpaid()
+        ->create();
+
+    $invoice->refresh();
+
+    expect($invoice)
+        ->hasLineItems()->toBeTrue()
+        ->lineItems->count()->toBeGreaterThan(0)
+        ->wasApproved()->toBeTrue()
+        ->hasBeenSent()->toBeTrue()
+        ->hasPayments()->toBeTrue()
+        ->status->toBe(InvoiceStatus::Overpaid)
+        ->amount_paid->toBeGreaterThan($invoice->total);
+});
+
+it('creates overdue invoices with line items and approval automatically', function () {
+    $invoice = Invoice::factory()
+        ->withLineItems()
+        ->overdue()
+        ->create();
+
+    $invoice->refresh();
+
+    expect($invoice)
+        ->hasLineItems()->toBeTrue()
+        ->lineItems->count()->toBeGreaterThan(0)
+        ->wasApproved()->toBeTrue()
+        ->status->toBe(InvoiceStatus::Overdue)
+        ->due_date->toBeLessThan(now());
+});
+
+it('handles factory configure method without duplicate line items', function () {
+    $invoice = Invoice::factory()
+        ->withLineItems(2)
+        ->create();
+
+    $invoice->refresh();
+
+    expect($invoice)
+        ->hasLineItems()->toBeTrue()
+        ->lineItems->count()->toBe(2)
+        ->invoice_number->toStartWith('INV-')
+        ->order_number->toStartWith('ORD-');
+});