wip

app/Enums/Accounting/InvoiceStatus.php

     case Draft = 'draft';
     case Unsent = 'unsent';
     case Sent = 'sent';
+    case Viewed = 'viewed';
 
     case Partial = 'partial';
 
     {
         return match ($this) {
             self::Draft, self::Unsent, self::Void => 'gray',
-            self::Sent => 'primary',
+            self::Sent, self::Viewed => 'primary',
             self::Partial => 'warning',
             self::Paid, self::Overpaid => 'success',
             self::Overdue => 'danger',

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

                         ->successNotificationTitle('Estimates Accepted')
                         ->failureNotificationTitle('Failed to Mark Estimates as Accepted')
                         ->before(function (Collection $records, Tables\Actions\BulkAction $action) {
-                            $doesntContainSent = $records->contains(fn (Estimate $record) => $record->status !== EstimateStatus::Sent || $record->isAccepted());
+                            $doesntContainSent = $records->contains(fn (Estimate $record) => $record->status !== EstimateStatus::Sent || $record->wasAccepted());
 
                             if ($doesntContainSent) {
                                 Notification::make()
                         ->successNotificationTitle('Estimates Declined')
                         ->failureNotificationTitle('Failed to Mark Estimates as Declined')
                         ->before(function (Collection $records, Tables\Actions\BulkAction $action) {
-                            $doesntContainSent = $records->contains(fn (Estimate $record) => $record->status !== EstimateStatus::Sent || $record->isDeclined());
+                            $doesntContainSent = $records->contains(fn (Estimate $record) => $record->status !== EstimateStatus::Sent || $record->wasDeclined());
 
                             if ($doesntContainSent) {
                                 Notification::make()

app/Models/Accounting/Bill.php

 use Illuminate\Database\Eloquent\Relations\MorphOne;
 use Illuminate\Support\Carbon;
 
-#[ObservedBy(BillObserver::class)]
 #[CollectedBy(DocumentCollection::class)]
+#[ObservedBy(BillObserver::class)]
 class Bill extends Model
 {
     use Blamable;
         });
     }
 
+    public function wasInitialized(): bool
+    {
+        return $this->hasInitialTransaction();
+    }
+
+    public function isPaid(): bool
+    {
+        return $this->paid_at !== null;
+    }
+
     public function canBeOverdue(): bool
     {
         return in_array($this->status, BillStatus::canBeOverdue());
         ]) && $this->currency_code === CurrencyAccessor::getDefaultCurrency();
     }
 
+    public function hasLineItems(): bool
+    {
+        return $this->lineItems()->exists();
+    }
+
     public function hasPayments(): bool
     {
         return $this->payments->isNotEmpty();

app/Models/Accounting/Estimate.php

         return $this->status === EstimateStatus::Draft;
     }
 
-    public function isApproved(): bool
+    public function wasApproved(): bool
     {
         return $this->approved_at !== null;
     }
 
-    public function isAccepted(): bool
+    public function wasAccepted(): bool
     {
         return $this->accepted_at !== null;
     }
 
-    public function isDeclined(): bool
+    public function wasDeclined(): bool
     {
         return $this->declined_at !== null;
     }
 
-    public function isSent(): bool
+    public function wasConverted(): bool
+    {
+        return $this->converted_at !== null;
+    }
+
+    public function hasBeenSent(): bool
     {
         return $this->last_sent_at !== null;
     }
 
+    public function hasBeenViewed(): bool
+    {
+        return $this->last_viewed_at !== null;
+    }
+
     public function canBeExpired(): bool
     {
         return ! in_array($this->status, [
         ]);
     }
 
+    public function canBeApproved(): bool
+    {
+        return $this->isDraft() && ! $this->wasApproved();
+    }
+
+    public function canBeConverted(): bool
+    {
+        return $this->wasAccepted() && ! $this->wasConverted();
+    }
+
+    public function canBeMarkedAsDeclined(): bool
+    {
+        return $this->hasBeenSent() && ! $this->wasDeclined();
+    }
+
+    public function canBeMarkedAsSent(): bool
+    {
+        return ! $this->hasBeenSent();
+    }
+
+    public function canBeMarkedAsAccepted(): bool
+    {
+        return $this->hasBeenSent() && ! $this->wasAccepted();
+    }
+
+    public function hasLineItems(): bool
+    {
+        return $this->lineItems()->exists();
+    }
+
     public function scopeActive(Builder $query): Builder
     {
         return $query->whereIn('status', [
             ->label('Approve')
             ->icon('heroicon-o-check-circle')
             ->visible(function (self $record) {
-                return $record->isDraft();
+                return $record->canBeApproved();
             })
             ->databaseTransaction()
             ->successNotificationTitle('Estimate Approved')
             ->label('Mark as Sent')
             ->icon('heroicon-o-paper-airplane')
             ->visible(static function (self $record) {
-                return ! $record->isSent();
+                return $record->canBeMarkedAsSent();
             })
             ->successNotificationTitle('Estimate Sent')
             ->action(function (self $record, MountableAction $action) {
         ]);
     }
 
+    public function markAsViewed(?Carbon $viewedAt = null): void
+    {
+        $viewedAt ??= now();
+
+        $this->update([
+            'status' => EstimateStatus::Viewed,
+            'last_viewed_at' => $viewedAt,
+        ]);
+    }
+
     public static function getReplicateAction(string $action = ReplicateAction::class): MountableAction
     {
         return $action::make()
             ->label('Mark as Accepted')
             ->icon('heroicon-o-check-badge')
             ->visible(static function (self $record) {
-                return $record->isSent() && ! $record->isAccepted();
+                return $record->canBeMarkedAsAccepted();
             })
             ->databaseTransaction()
             ->successNotificationTitle('Estimate Accepted')
             ->label('Mark as Declined')
             ->icon('heroicon-o-x-circle')
             ->visible(static function (self $record) {
-                return $record->isSent() && ! $record->isDeclined();
+                return $record->canBeMarkedAsDeclined();
             })
             ->color('danger')
             ->requiresConfirmation()
             ->label('Convert to Invoice')
             ->icon('heroicon-o-arrow-right-on-rectangle')
             ->visible(static function (self $record) {
-                return $record->status === EstimateStatus::Accepted && ! $record->invoice;
+                return $record->canBeConverted();
             })
             ->databaseTransaction()
             ->successNotificationTitle('Estimate Converted to Invoice')

app/Models/Accounting/Invoice.php

         'approved_at',
         'paid_at',
         'last_sent_at',
+        'last_viewed_at',
         'status',
         'currency_code',
         'discount_method',
         'approved_at' => 'datetime',
         'paid_at' => 'datetime',
         'last_sent_at' => 'datetime',
+        'last_viewed_at' => 'datetime',
         'status' => InvoiceStatus::class,
         'discount_method' => DocumentDiscountMethod::class,
         'discount_computation' => AdjustmentComputation::class,
         return $this->status === InvoiceStatus::Draft;
     }
 
+    public function wasApproved(): bool
+    {
+        return $this->approved_at !== null;
+    }
+
+    public function isPaid(): bool
+    {
+        return $this->paid_at !== null;
+    }
+
+    public function hasBeenSent(): bool
+    {
+        return $this->last_sent_at !== null;
+    }
+
+    public function hasBeenViewed(): bool
+    {
+        return $this->last_viewed_at !== null;
+    }
+
     public function canRecordPayment(): bool
     {
         return ! in_array($this->status, [
         return in_array($this->status, InvoiceStatus::canBeOverdue());
     }
 
+    public function canBeApproved(): bool
+    {
+        return $this->isDraft() && ! $this->wasApproved();
+    }
+
+    public function canBeMarkedAsSent(): bool
+    {
+        return ! $this->hasBeenSent();
+    }
+
+    public function hasLineItems(): bool
+    {
+        return $this->lineItems()->exists();
+    }
+
     public function hasPayments(): bool
     {
-        return $this->payments->isNotEmpty();
+        return $this->payments()->exists();
     }
 
     public static function getNextDocumentNumber(?Company $company = null): string
             ->label('Approve')
             ->icon('heroicon-o-check-circle')
             ->visible(function (self $record) {
-                return $record->isDraft();
+                return $record->canBeApproved();
             })
             ->databaseTransaction()
             ->successNotificationTitle('Invoice Approved')
             ->label('Mark as Sent')
             ->icon('heroicon-o-paper-airplane')
             ->visible(static function (self $record) {
-                return ! $record->last_sent_at;
+                return $record->canBeMarkedAsSent();
             })
             ->successNotificationTitle('Invoice Sent')
             ->action(function (self $record, MountableAction $action) {
         ]);
     }
 
+    public function markAsViewed(?Carbon $viewedAt = null): void
+    {
+        $viewedAt ??= now();
+
+        $this->update([
+            'status' => InvoiceStatus::Viewed,
+            'last_viewed_at' => $viewedAt,
+        ]);
+    }
+
     public static function getReplicateAction(string $action = ReplicateAction::class): MountableAction
     {
         return $action::make()
             })
             ->databaseTransaction()
             ->after(function (self $original, self $replica) {
-                $original->lineItems->each(function (DocumentLineItem $lineItem) use ($replica) {
-                    $replicaLineItem = $lineItem->replicate([
-                        'documentable_id',
-                        'documentable_type',
-                        'subtotal',
-                        'total',
-                        'created_by',
-                        'updated_by',
-                        'created_at',
-                        'updated_at',
-                    ]);
-
-                    $replicaLineItem->documentable_id = $replica->id;
-                    $replicaLineItem->documentable_type = $replica->getMorphClass();
-
-                    $replicaLineItem->save();
-
-                    $replicaLineItem->adjustments()->sync($lineItem->adjustments->pluck('id'));
-                });
+                $original->replicateLineItems($replica);
             })
             ->successRedirectUrl(static function (self $replica) {
                 return InvoiceResource::getUrl('edit', ['record' => $replica]);
             });
     }
+
+    public function replicateLineItems(Model $target): void
+    {
+        $this->lineItems->each(function (DocumentLineItem $lineItem) use ($target) {
+            $replica = $lineItem->replicate([
+                'documentable_id',
+                'documentable_type',
+                'subtotal',
+                'total',
+                'created_by',
+                'updated_by',
+                'created_at',
+                'updated_at',
+            ]);
+
+            $replica->documentable_id = $target->id;
+            $replica->documentable_type = $target->getMorphClass();
+            $replica->save();
+
+            $replica->adjustments()->sync($lineItem->adjustments->pluck('id'));
+        });
+    }
 }

app/Policies/EstimatePolicy.php

 
 namespace App\Policies;
 
-use App\Enums\Accounting\EstimateStatus;
 use App\Models\Accounting\Estimate;
 use App\Models\User;
 
      */
     public function update(User $user, Estimate $estimate): bool
     {
-        if ($estimate->status === EstimateStatus::Converted) {
+        if ($estimate->wasConverted()) {
             return false;
         }
 

composer.lock

         },
         {
             "name": "aws/aws-sdk-php",
-            "version": "3.336.4",
+            "version": "3.336.6",
             "source": {
                 "type": "git",
                 "url": "https://github.com/aws/aws-sdk-php.git",
-                "reference": "5bc056d14a8bad0e9ec5a6ce03e46d8e4329b7fc"
+                "reference": "0a99dab427f0a1c082775301141aeac3558691ad"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/aws/aws-sdk-php/zipball/5bc056d14a8bad0e9ec5a6ce03e46d8e4329b7fc",
-                "reference": "5bc056d14a8bad0e9ec5a6ce03e46d8e4329b7fc",
+                "url": "https://api.github.com/repos/aws/aws-sdk-php/zipball/0a99dab427f0a1c082775301141aeac3558691ad",
+                "reference": "0a99dab427f0a1c082775301141aeac3558691ad",
                 "shasum": ""
             },
             "require": {
             "support": {
                 "forum": "https://forums.aws.amazon.com/forum.jspa?forumID=80",
                 "issues": "https://github.com/aws/aws-sdk-php/issues",
-                "source": "https://github.com/aws/aws-sdk-php/tree/3.336.4"
+                "source": "https://github.com/aws/aws-sdk-php/tree/3.336.6"
             },
-            "time": "2024-12-26T19:13:21+00:00"
+            "time": "2024-12-28T04:16:13+00:00"
         },
         {
             "name": "aws/aws-sdk-php-laravel",

database/factories/Accounting/BillFactory.php

      */
     public function definition(): array
     {
-        // 50% chance of being a future bill
         $isFutureBill = $this->faker->boolean();
 
         if ($isFutureBill) {
-            // For future bills, date is recent and due date is in near future
             $billDate = $this->faker->dateTimeBetween('-10 days', '+10 days');
         } else {
-            // For past bills, both date and due date are in the past
             $billDate = $this->faker->dateTimeBetween('-1 year', '-30 days');
         }
 
         ];
     }
 
-    public function withLineItems(int $count = 3): self
+    public function withLineItems(int $count = 3): static
     {
-        return $this->has(DocumentLineItem::factory()->forBill()->count($count), 'lineItems');
+        return $this->afterCreating(function (Bill $bill) use ($count) {
+            DocumentLineItem::factory()
+                ->count($count)
+                ->forBill($bill)
+                ->create();
+
+            $this->recalculateTotals($bill);
+        });
     }
 
     public function initialized(): static
     {
         return $this->afterCreating(function (Bill $bill) {
-            if ($bill->hasInitialTransaction()) {
+            $this->ensureLineItems($bill);
+
+            if ($bill->wasInitialized()) {
                 return;
             }
 
-            $this->recalculateTotals($bill);
-
-            $postedAt = Carbon::parse($bill->date)->addHours($this->faker->numberBetween(1, 24));
+            $postedAt = Carbon::parse($bill->date)
+                ->addHours($this->faker->numberBetween(1, 24));
 
             $bill->createInitialTransaction($postedAt);
         });
     }
 
-    public function withPayments(?int $min = 1, ?int $max = null, BillStatus $billStatus = BillStatus::Paid): static
+    public function partial(int $maxPayments = 4): static
     {
-        return $this->afterCreating(function (Bill $bill) use ($billStatus, $max, $min) {
-            if (! $bill->hasInitialTransaction()) {
-                $this->recalculateTotals($bill);
+        return $this->afterCreating(function (Bill $bill) use ($maxPayments) {
+            $this->ensureInitialized($bill);
 
-                $postedAt = Carbon::parse($bill->date)->addHours($this->faker->numberBetween(1, 24));
+            $this->withPayments(max: $maxPayments, billStatus: BillStatus::Partial)
+                ->callAfterCreating(collect([$bill]));
+        });
+    }
 
-                $bill->createInitialTransaction($postedAt);
-            }
+    public function paid(int $maxPayments = 4): static
+    {
+        return $this->afterCreating(function (Bill $bill) use ($maxPayments) {
+            $this->ensureInitialized($bill);
+
+            $this->withPayments(max: $maxPayments)
+                ->callAfterCreating(collect([$bill]));
+        });
+    }
+
+    public function overdue(): static
+    {
+        return $this
+            ->state([
+                'due_date' => now()->subDays($this->faker->numberBetween(1, 30)),
+            ])
+            ->afterCreating(function (Bill $bill) {
+                $this->ensureInitialized($bill);
+            });
+    }
+
+    public function withPayments(?int $min = null, ?int $max = null, BillStatus $billStatus = BillStatus::Paid): static
+    {
+        $min ??= 1;
+
+        return $this->afterCreating(function (Bill $bill) use ($billStatus, $max, $min) {
+            $this->ensureInitialized($bill);
 
             $bill->refresh();
 
-            $totalAmountDue = $bill->getRawOriginal('amount_due');
+            $amountDue = $bill->getRawOriginal('amount_due');
 
-            if ($billStatus === BillStatus::Partial) {
-                $totalAmountDue = (int) floor($totalAmountDue * 0.5);
-            }
+            $totalAmountDue = match ($billStatus) {
+                BillStatus::Partial => (int) floor($amountDue * 0.5),
+                default => $amountDue,
+            };
 
             if ($totalAmountDue <= 0 || empty($totalAmountDue)) {
                 return;
                 $remainingAmount -= $amount;
             }
 
-            if ($billStatus === BillStatus::Paid) {
-                $latestPaymentDate = max($paymentDates);
-                $bill->updateQuietly([
-                    'status' => $billStatus,
-                    'paid_at' => $latestPaymentDate,
-                ]);
+            if ($billStatus !== BillStatus::Paid) {
+                return;
             }
+
+            $latestPaymentDate = max($paymentDates);
+            $bill->updateQuietly([
+                'status' => $billStatus,
+                'paid_at' => $latestPaymentDate,
+            ]);
         });
     }
 
     public function configure(): static
     {
         return $this->afterCreating(function (Bill $bill) {
+            $this->ensureInitialized($bill);
+
             $paddedId = str_pad((string) $bill->id, 5, '0', STR_PAD_LEFT);
 
             $bill->updateQuietly([
                 'order_number' => "PO-{$paddedId}",
             ]);
 
-            $this->recalculateTotals($bill);
-
-            // Check for overdue status
-            if ($bill->due_date < today() && $bill->status !== BillStatus::Paid) {
+            if ($bill->wasInitialized() && $bill->is_currently_overdue) {
                 $bill->updateQuietly([
                     'status' => BillStatus::Overdue,
                 ]);
         });
     }
 
+    protected function ensureLineItems(Bill $bill): void
+    {
+        if (! $bill->hasLineItems()) {
+            $this->withLineItems()->callAfterCreating(collect([$bill]));
+        }
+    }
+
+    protected function ensureInitialized(Bill $bill): void
+    {
+        if (! $bill->wasInitialized()) {
+            $this->initialized()->callAfterCreating(collect([$bill]));
+        }
+    }
+
     protected function recalculateTotals(Bill $bill): void
     {
-        if ($bill->lineItems()->exists()) {
-            $bill->refresh();
-            $subtotal = $bill->lineItems()->sum('subtotal') / 100;
-            $taxTotal = $bill->lineItems()->sum('tax_total') / 100;
-            $discountTotal = $bill->lineItems()->sum('discount_total') / 100;
-            $grandTotal = $subtotal + $taxTotal - $discountTotal;
-
-            $bill->update([
-                'subtotal' => $subtotal,
-                'tax_total' => $taxTotal,
-                'discount_total' => $discountTotal,
-                'total' => $grandTotal,
-            ]);
+        $bill->refresh();
+
+        if (! $bill->hasLineItems()) {
+            return;
         }
+
+        $subtotal = $bill->lineItems()->sum('subtotal') / 100;
+        $taxTotal = $bill->lineItems()->sum('tax_total') / 100;
+        $discountTotal = $bill->lineItems()->sum('discount_total') / 100;
+        $grandTotal = $subtotal + $taxTotal - $discountTotal;
+
+        $bill->update([
+            'subtotal' => $subtotal,
+            'tax_total' => $taxTotal,
+            'discount_total' => $discountTotal,
+            'total' => $grandTotal,
+        ]);
     }
 }

database/factories/Accounting/DocumentLineItemFactory.php

 
 namespace Database\Factories\Accounting;
 
+use App\Models\Accounting\Bill;
 use App\Models\Accounting\DocumentLineItem;
+use App\Models\Accounting\Estimate;
+use App\Models\Accounting\Invoice;
 use App\Models\Common\Offering;
 use Illuminate\Database\Eloquent\Factories\Factory;
 
         ];
     }
 
-    public function forInvoice(): static
+    public function forInvoice(Invoice $invoice): static
     {
-        return $this->state(function (array $attributes) {
-            $offering = Offering::where('sellable', true)
-                ->inRandomOrder()
-                ->first();
-
-            return [
-                'offering_id' => $offering->id,
-                'unit_price' => $offering->price,
-            ];
-        })->afterCreating(function (DocumentLineItem $lineItem) {
-            $offering = $lineItem->offering;
-
-            if ($offering) {
-                $lineItem->salesTaxes()->syncWithoutDetaching($offering->salesTaxes->pluck('id')->toArray());
-                $lineItem->salesDiscounts()->syncWithoutDetaching($offering->salesDiscounts->pluck('id')->toArray());
-            }
-
-            $lineItem->refresh();
-
-            $taxTotal = $lineItem->calculateTaxTotal()->getAmount();
-            $discountTotal = $lineItem->calculateDiscountTotal()->getAmount();
-
-            $lineItem->updateQuietly([
-                'tax_total' => $taxTotal,
-                'discount_total' => $discountTotal,
-            ]);
-        });
+        return $this
+            ->for($invoice, 'documentable')
+            ->state(function (array $attributes) {
+                $offering = Offering::where('sellable', true)
+                    ->inRandomOrder()
+                    ->first();
+
+                return [
+                    'offering_id' => $offering->id,
+                    'unit_price' => $offering->price,
+                ];
+            })
+            ->afterCreating(function (DocumentLineItem $lineItem) {
+                $offering = $lineItem->offering;
+
+                if ($offering) {
+                    $lineItem->salesTaxes()->syncWithoutDetaching($offering->salesTaxes->pluck('id')->toArray());
+                    $lineItem->salesDiscounts()->syncWithoutDetaching($offering->salesDiscounts->pluck('id')->toArray());
+                }
+
+                $lineItem->refresh();
+
+                $taxTotal = $lineItem->calculateTaxTotal()->getAmount();
+                $discountTotal = $lineItem->calculateDiscountTotal()->getAmount();
+
+                $lineItem->updateQuietly([
+                    'tax_total' => $taxTotal,
+                    'discount_total' => $discountTotal,
+                ]);
+            });
     }
 
-    public function forEstimate(): static
+    public function forEstimate(Estimate $estimate): static
     {
-        return $this->state(function (array $attributes) {
-            $offering = Offering::where('sellable', true)
-                ->inRandomOrder()
-                ->first();
-
-            return [
-                'offering_id' => $offering->id,
-                'unit_price' => $offering->price,
-            ];
-        })->afterCreating(function (DocumentLineItem $lineItem) {
-            $offering = $lineItem->offering;
-
-            if ($offering) {
-                $lineItem->salesTaxes()->syncWithoutDetaching($offering->salesTaxes->pluck('id')->toArray());
-                $lineItem->salesDiscounts()->syncWithoutDetaching($offering->salesDiscounts->pluck('id')->toArray());
-            }
-
-            $lineItem->refresh();
-
-            $taxTotal = $lineItem->calculateTaxTotal()->getAmount();
-            $discountTotal = $lineItem->calculateDiscountTotal()->getAmount();
-
-            $lineItem->updateQuietly([
-                'tax_total' => $taxTotal,
-                'discount_total' => $discountTotal,
-            ]);
-        });
+        return $this
+            ->for($estimate, 'documentable')
+            ->state(function (array $attributes) {
+                $offering = Offering::where('sellable', true)
+                    ->inRandomOrder()
+                    ->first();
+
+                return [
+                    'offering_id' => $offering->id,
+                    'unit_price' => $offering->price,
+                ];
+            })
+            ->afterCreating(function (DocumentLineItem $lineItem) {
+                $offering = $lineItem->offering;
+
+                if ($offering) {
+                    $lineItem->salesTaxes()->syncWithoutDetaching($offering->salesTaxes->pluck('id')->toArray());
+                    $lineItem->salesDiscounts()->syncWithoutDetaching($offering->salesDiscounts->pluck('id')->toArray());
+                }
+
+                $lineItem->refresh();
+
+                $taxTotal = $lineItem->calculateTaxTotal()->getAmount();
+                $discountTotal = $lineItem->calculateDiscountTotal()->getAmount();
+
+                $lineItem->updateQuietly([
+                    'tax_total' => $taxTotal,
+                    'discount_total' => $discountTotal,
+                ]);
+            });
     }
 
-    public function forBill(): static
+    public function forBill(Bill $bill): static
     {
-        return $this->state(function (array $attributes) {
-            $offering = Offering::where('purchasable', true)
-                ->inRandomOrder()
-                ->first();
-
-            return [
-                'offering_id' => $offering->id,
-                'unit_price' => $offering->price,
-            ];
-        })->afterCreating(function (DocumentLineItem $lineItem) {
-            $offering = $lineItem->offering;
-
-            if ($offering) {
-                $lineItem->purchaseTaxes()->syncWithoutDetaching($offering->purchaseTaxes->pluck('id')->toArray());
-                $lineItem->purchaseDiscounts()->syncWithoutDetaching($offering->purchaseDiscounts->pluck('id')->toArray());
-            }
-
-            $lineItem->refresh();
-
-            $taxTotal = $lineItem->calculateTaxTotal()->getAmount();
-            $discountTotal = $lineItem->calculateDiscountTotal()->getAmount();
-
-            $lineItem->updateQuietly([
-                'tax_total' => $taxTotal,
-                'discount_total' => $discountTotal,
-            ]);
-        });
+        return $this
+            ->for($bill, 'documentable')
+            ->state(function (array $attributes) {
+                $offering = Offering::where('purchasable', true)
+                    ->inRandomOrder()
+                    ->first();
+
+                return [
+                    'offering_id' => $offering->id,
+                    'unit_price' => $offering->price,
+                ];
+            })
+            ->afterCreating(function (DocumentLineItem $lineItem) {
+                $offering = $lineItem->offering;
+
+                if ($offering) {
+                    $lineItem->purchaseTaxes()->syncWithoutDetaching($offering->purchaseTaxes->pluck('id')->toArray());
+                    $lineItem->purchaseDiscounts()->syncWithoutDetaching($offering->purchaseDiscounts->pluck('id')->toArray());
+                }
+
+                $lineItem->refresh();
+
+                $taxTotal = $lineItem->calculateTaxTotal()->getAmount();
+                $discountTotal = $lineItem->calculateDiscountTotal()->getAmount();
+
+                $lineItem->updateQuietly([
+                    'tax_total' => $taxTotal,
+                    'discount_total' => $discountTotal,
+                ]);
+            });
     }
 }

database/factories/Accounting/EstimateFactory.php

         ];
     }
 
-    public function withLineItems(int $count = 3): self
+    public function withLineItems(int $count = 3): static
     {
-        return $this->has(DocumentLineItem::factory()->forEstimate()->count($count), 'lineItems');
+        return $this->afterCreating(function (Estimate $estimate) use ($count) {
+            DocumentLineItem::factory()
+                ->count($count)
+                ->forEstimate($estimate)
+                ->create();
+
+            $this->recalculateTotals($estimate);
+        });
     }
 
     public function approved(): static
     {
         return $this->afterCreating(function (Estimate $estimate) {
-            if (! $estimate->isDraft()) {
+            $this->ensureLineItems($estimate);
+
+            if (! $estimate->canBeApproved()) {
                 return;
             }
 
-            $this->recalculateTotals($estimate);
-
-            $approvedAt = Carbon::parse($estimate->date)->addHours($this->faker->numberBetween(1, 24));
+            $approvedAt = Carbon::parse($estimate->date)
+                ->addHours($this->faker->numberBetween(1, 24));
 
             $estimate->approveDraft($approvedAt);
         });
     public function accepted(): static
     {
         return $this->afterCreating(function (Estimate $estimate) {
-            if (! $estimate->isApproved()) {
-                $this->approved()->create();
-            }
+            $this->ensureSent($estimate);
 
-            $acceptedAt = Carbon::parse($estimate->approved_at)
+            $acceptedAt = Carbon::parse($estimate->last_sent_at)
                 ->addDays($this->faker->numberBetween(1, 7));
 
             $estimate->markAsAccepted($acceptedAt);
     public function converted(): static
     {
         return $this->afterCreating(function (Estimate $estimate) {
-            if (! $estimate->isAccepted()) {
-                $this->accepted()->create();
+            if (! $estimate->wasAccepted()) {
+                $this->accepted()->callAfterCreating(collect([$estimate]));
             }
 
             $convertedAt = Carbon::parse($estimate->accepted_at)
     public function declined(): static
     {
         return $this->afterCreating(function (Estimate $estimate) {
-            if (! $estimate->isApproved()) {
-                $this->approved()->create();
-            }
+            $this->ensureSent($estimate);
 
-            $declinedAt = Carbon::parse($estimate->approved_at)
+            $declinedAt = Carbon::parse($estimate->last_sent_at)
                 ->addDays($this->faker->numberBetween(1, 7));
 
-            $estimate->update([
-                'status' => EstimateStatus::Declined,
-                'declined_at' => $declinedAt,
-            ]);
+            $estimate->markAsDeclined($declinedAt);
         });
     }
 
     public function sent(): static
     {
         return $this->afterCreating(function (Estimate $estimate) {
-            if (! $estimate->isDraft()) {
-                return;
-            }
+            $this->ensureApproved($estimate);
 
-            $this->recalculateTotals($estimate);
-
-            $sentAt = Carbon::parse($estimate->date)->addHours($this->faker->numberBetween(1, 24));
+            $sentAt = Carbon::parse($estimate->approved_at)
+                ->addHours($this->faker->numberBetween(1, 24));
 
             $estimate->markAsSent($sentAt);
         });
     }
 
+    public function viewed(): static
+    {
+        return $this->afterCreating(function (Estimate $estimate) {
+            $this->ensureSent($estimate);
+
+            $viewedAt = Carbon::parse($estimate->last_sent_at)
+                ->addHours($this->faker->numberBetween(1, 24));
+
+            $estimate->markAsViewed($viewedAt);
+        });
+    }
+
+    public function expired(): static
+    {
+        return $this
+            ->state([
+                'expiration_date' => now()->subDays($this->faker->numberBetween(1, 30)),
+            ])
+            ->afterCreating(function (Estimate $estimate) {
+                $this->ensureApproved($estimate);
+            });
+    }
+
     public function configure(): static
     {
         return $this->afterCreating(function (Estimate $estimate) {
+            $this->ensureLineItems($estimate);
+
             $paddedId = str_pad((string) $estimate->id, 5, '0', STR_PAD_LEFT);
 
             $estimate->updateQuietly([
                 'reference_number' => "REF-{$paddedId}",
             ]);
 
-            $this->recalculateTotals($estimate);
-
-            if ($estimate->approved_at && $estimate->is_currently_expired) {
+            if ($estimate->wasApproved() && $estimate->is_currently_expired) {
                 $estimate->updateQuietly([
                     'status' => EstimateStatus::Expired,
                 ]);
         });
     }
 
+    protected function ensureLineItems(Estimate $estimate): void
+    {
+        if (! $estimate->hasLineItems()) {
+            $this->withLineItems()->callAfterCreating(collect([$estimate]));
+        }
+    }
+
+    protected function ensureApproved(Estimate $estimate): void
+    {
+        if (! $estimate->wasApproved()) {
+            $this->approved()->callAfterCreating(collect([$estimate]));
+        }
+    }
+
+    protected function ensureSent(Estimate $estimate): void
+    {
+        if (! $estimate->hasBeenSent()) {
+            $this->sent()->callAfterCreating(collect([$estimate]));
+        }
+    }
+
     protected function recalculateTotals(Estimate $estimate): void
     {
-        if ($estimate->lineItems()->exists()) {
-            $estimate->refresh();
-            $subtotal = $estimate->lineItems()->sum('subtotal') / 100;
-            $taxTotal = $estimate->lineItems()->sum('tax_total') / 100;
-            $discountTotal = $estimate->lineItems()->sum('discount_total') / 100;
-            $grandTotal = $subtotal + $taxTotal - $discountTotal;
-
-            $estimate->update([
-                'subtotal' => $subtotal,
-                'tax_total' => $taxTotal,
-                'discount_total' => $discountTotal,
-                'total' => $grandTotal,
-            ]);
+        $estimate->refresh();
+
+        if (! $estimate->hasLineItems()) {
+            return;
         }
+
+        $subtotal = $estimate->lineItems()->sum('subtotal') / 100;
+        $taxTotal = $estimate->lineItems()->sum('tax_total') / 100;
+        $discountTotal = $estimate->lineItems()->sum('discount_total') / 100;
+        $grandTotal = $subtotal + $taxTotal - $discountTotal;
+
+        $estimate->update([
+            'subtotal' => $subtotal,
+            'tax_total' => $taxTotal,
+            'discount_total' => $discountTotal,
+            'total' => $grandTotal,
+        ]);
     }
 }

database/factories/Accounting/InvoiceFactory.php

         ];
     }
 
-    public function withLineItems(int $count = 3): self
+    public function withLineItems(int $count = 3): static
     {
-        return $this->has(DocumentLineItem::factory()->forInvoice()->count($count), 'lineItems');
+        return $this->afterCreating(function (Invoice $invoice) use ($count) {
+            DocumentLineItem::factory()
+                ->count($count)
+                ->forInvoice($invoice)
+                ->create();
+
+            $this->recalculateTotals($invoice);
+        });
     }
 
     public function approved(): static
     {
         return $this->afterCreating(function (Invoice $invoice) {
-            if (! $invoice->isDraft()) {
+            $this->ensureLineItems($invoice);
+
+            if (! $invoice->canBeApproved()) {
                 return;
             }
 
-            $this->recalculateTotals($invoice);
-
-            $approvedAt = Carbon::parse($invoice->date)->addHours($this->faker->numberBetween(1, 24));
+            $approvedAt = Carbon::parse($invoice->date)
+                ->addHours($this->faker->numberBetween(1, 24));
 
             $invoice->approveDraft($approvedAt);
         });
     }
 
-    public function withPayments(?int $min = 1, ?int $max = null, InvoiceStatus $invoiceStatus = InvoiceStatus::Paid): static
+    public function sent(): static
     {
-        return $this->afterCreating(function (Invoice $invoice) use ($invoiceStatus, $max, $min) {
-            if ($invoice->isDraft()) {
-                $this->recalculateTotals($invoice);
+        return $this->afterCreating(function (Invoice $invoice) {
+            $this->ensureApproved($invoice);
 
-                $approvedAt = Carbon::parse($invoice->date)->addHours($this->faker->numberBetween(1, 24));
-                $invoice->approveDraft($approvedAt);
-            }
+            $sentAt = Carbon::parse($invoice->approved_at)
+                ->addHours($this->faker->numberBetween(1, 24));
+
+            $invoice->markAsSent($sentAt);
+        });
+    }
+
+    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]));
+        });
+    }
+
+    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]));
+        });
+    }
+
+    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]));
+        });
+    }
+
+    public function overdue(): static
+    {
+        return $this
+            ->state([
+                'due_date' => now()->subDays($this->faker->numberBetween(1, 30)),
+            ])
+            ->afterCreating(function (Invoice $invoice) {
+                $this->ensureApproved($invoice);
+            });
+    }
+
+    public function withPayments(?int $min = null, ?int $max = null, InvoiceStatus $invoiceStatus = InvoiceStatus::Paid): static
+    {
+        $min ??= 1;
+
+        return $this->afterCreating(function (Invoice $invoice) use ($invoiceStatus, $max, $min) {
+            $this->ensureSent($invoice);
 
             $invoice->refresh();
 
-            $totalAmountDue = $invoice->getRawOriginal('amount_due');
+            $amountDue = $invoice->getRawOriginal('amount_due');
 
-            if ($invoiceStatus === InvoiceStatus::Overpaid) {
-                $totalAmountDue += random_int(1000, 10000);
-            } elseif ($invoiceStatus === InvoiceStatus::Partial) {
-                $totalAmountDue = (int) floor($totalAmountDue * 0.5);
-            }
+            $totalAmountDue = match ($invoiceStatus) {
+                InvoiceStatus::Overpaid => $amountDue + random_int(1000, 10000),
+                InvoiceStatus::Partial => (int) floor($amountDue * 0.5),
+                default => $amountDue,
+            };
 
             if ($totalAmountDue <= 0 || empty($totalAmountDue)) {
                 return;
                 $remainingAmount -= $amount;
             }
 
-            // If it's a paid invoice, use the latest payment date as paid_at
-            if ($invoiceStatus === InvoiceStatus::Paid) {
-                $latestPaymentDate = max($paymentDates);
-                $invoice->updateQuietly([
-                    'status' => $invoiceStatus,
-                    'paid_at' => $latestPaymentDate,
-                ]);
+            if ($invoiceStatus !== InvoiceStatus::Paid) {
+                return;
             }
+
+            $latestPaymentDate = max($paymentDates);
+            $invoice->updateQuietly([
+                'status' => $invoiceStatus,
+                'paid_at' => $latestPaymentDate,
+            ]);
         });
     }
 
     public function configure(): static
     {
         return $this->afterCreating(function (Invoice $invoice) {
-            // Use the invoice's ID to generate invoice and order numbers
+            $this->ensureLineItems($invoice);
+
             $paddedId = str_pad((string) $invoice->id, 5, '0', STR_PAD_LEFT);
 
             $invoice->updateQuietly([
                 'order_number' => "ORD-{$paddedId}",
             ]);
 
-            $this->recalculateTotals($invoice);
-
-            if ($invoice->approved_at && $invoice->is_currently_overdue) {
+            if ($invoice->wasApproved() && $invoice->is_currently_overdue) {
                 $invoice->updateQuietly([
                     'status' => InvoiceStatus::Overdue,
                 ]);
         });
     }
 
+    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
     {
-        if ($invoice->lineItems()->exists()) {
-            $invoice->refresh();
-            $subtotal = $invoice->lineItems()->sum('subtotal') / 100;
-            $taxTotal = $invoice->lineItems()->sum('tax_total') / 100;
-            $discountTotal = $invoice->lineItems()->sum('discount_total') / 100;
-            $grandTotal = $subtotal + $taxTotal - $discountTotal;
-
-            $invoice->update([
-                'subtotal' => $subtotal,
-                'tax_total' => $taxTotal,
-                'discount_total' => $discountTotal,
-                'total' => $grandTotal,
-            ]);
+        $invoice->refresh();
+
+        if (! $invoice->hasLineItems()) {
+            return;
         }
+
+        $subtotal = $invoice->lineItems()->sum('subtotal') / 100;
+        $taxTotal = $invoice->lineItems()->sum('tax_total') / 100;
+        $discountTotal = $invoice->lineItems()->sum('discount_total') / 100;
+        $grandTotal = $subtotal + $taxTotal - $discountTotal;
+
+        $invoice->update([
+            'subtotal' => $subtotal,
+            'tax_total' => $taxTotal,
+            'discount_total' => $discountTotal,
+            'total' => $grandTotal,
+        ]);
     }
 }

database/factories/CompanyFactory.php

 
 namespace Database\Factories;
 
-use App\Enums\Accounting\BillStatus;
-use App\Enums\Accounting\InvoiceStatus;
 use App\Models\Accounting\Bill;
 use App\Models\Accounting\Estimate;
 use App\Models\Accounting\Invoice;
             $draftCount = (int) floor($count * 0.2);
             $approvedCount = (int) floor($count * 0.2);
             $paidCount = (int) floor($count * 0.3);
-            $partialCount = (int) floor($count * 0.2);
-            $overpaidCount = $count - ($draftCount + $approvedCount + $paidCount + $partialCount);
+            $partialCount = (int) floor($count * 0.1);
+            $overpaidCount = (int) floor($count * 0.1);
+            $overdueCount = $count - ($draftCount + $approvedCount + $paidCount + $partialCount + $overpaidCount);
 
             Invoice::factory()
                 ->count($draftCount)
-                ->withLineItems()
                 ->create([
                     'company_id' => $company->id,
                     'created_by' => $company->user_id,
 
             Invoice::factory()
                 ->count($approvedCount)
-                ->withLineItems()
                 ->approved()
                 ->create([
                     'company_id' => $company->id,
 
             Invoice::factory()
                 ->count($paidCount)
-                ->withLineItems()
-                ->approved()
-                ->withPayments(max: 4)
+                ->paid()
                 ->create([
                     'company_id' => $company->id,
                     'created_by' => $company->user_id,
 
             Invoice::factory()
                 ->count($partialCount)
-                ->withLineItems()
-                ->approved()
-                ->withPayments(max: 4, invoiceStatus: InvoiceStatus::Partial)
+                ->partial()
                 ->create([
                     'company_id' => $company->id,
                     'created_by' => $company->user_id,
 
             Invoice::factory()
                 ->count($overpaidCount)
-                ->withLineItems()
-                ->approved()
-                ->withPayments(max: 4, invoiceStatus: InvoiceStatus::Overpaid)
+                ->overpaid()
+                ->create([
+                    'company_id' => $company->id,
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+
+            Invoice::factory()
+                ->count($overdueCount)
+                ->overdue()
                 ->create([
                     'company_id' => $company->id,
                     'created_by' => $company->user_id,
             $convertedCount = (int) floor($count * 0.1); // 10% converted to invoices
             $expiredCount = $count - ($draftCount + $approvedCount + $acceptedCount + $declinedCount + $convertedCount); // remaining 10%
 
-            // Create draft estimates
             Estimate::factory()
                 ->count($draftCount)
-                ->withLineItems()
                 ->create([
                     'company_id' => $company->id,
                     'created_by' => $company->user_id,
                     'updated_by' => $company->user_id,
                 ]);
 
-            // Create pending (approved) estimates
             Estimate::factory()
                 ->count($approvedCount)
-                ->withLineItems()
                 ->approved()
                 ->create([
                     'company_id' => $company->id,
                     'updated_by' => $company->user_id,
                 ]);
 
-            // Create accepted estimates
             Estimate::factory()
                 ->count($acceptedCount)
-                ->withLineItems()
                 ->accepted()
                 ->create([
                     'company_id' => $company->id,
                     'updated_by' => $company->user_id,
                 ]);
 
-            // Create declined estimates
             Estimate::factory()
                 ->count($declinedCount)
-                ->withLineItems()
                 ->declined()
                 ->create([
                     'company_id' => $company->id,
                     'updated_by' => $company->user_id,
                 ]);
 
-            // Create converted estimates
             Estimate::factory()
                 ->count($convertedCount)
-                ->withLineItems()
-                ->accepted()
                 ->converted()
                 ->create([
                     'company_id' => $company->id,
                     'updated_by' => $company->user_id,
                 ]);
 
-            // Create expired estimates (approved but past expiration date)
             Estimate::factory()
                 ->count($expiredCount)
-                ->withLineItems()
-                ->approved()
-                ->state([
-                    'expiration_date' => now()->subDays(rand(1, 30)),
-                ])
+                ->expired()
                 ->create([
                     'company_id' => $company->id,
                     'created_by' => $company->user_id,
     {
         return $this->afterCreating(function (Company $company) use ($count) {
             $unpaidCount = (int) floor($count * 0.4);
-            $paidCount = (int) floor($count * 0.4);
-            $partialCount = $count - ($unpaidCount + $paidCount);
+            $paidCount = (int) floor($count * 0.3);
+            $partialCount = (int) floor($count * 0.2);
+            $overdueCount = $count - ($unpaidCount + $paidCount + $partialCount);
 
-            // Create unpaid bills
             Bill::factory()
                 ->count($unpaidCount)
-                ->withLineItems()
-                ->initialized()
                 ->create([
                     'company_id' => $company->id,
                     'created_by' => $company->user_id,
                     'updated_by' => $company->user_id,
                 ]);
 
-            // Create paid bills
             Bill::factory()
                 ->count($paidCount)
-                ->withLineItems()
-                ->initialized()
-                ->withPayments(max: 4)
+                ->paid()
                 ->create([
                     'company_id' => $company->id,
                     'created_by' => $company->user_id,
                     'updated_by' => $company->user_id,
                 ]);
 
-            // Create partially paid bills
             Bill::factory()
                 ->count($partialCount)
-                ->withLineItems()
-                ->initialized()
-                ->withPayments(max: 4, billStatus: BillStatus::Partial)
+                ->partial()
+                ->create([
+                    'company_id' => $company->id,
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+
+            Bill::factory()
+                ->count($overdueCount)
+                ->overdue()
                 ->create([
                     'company_id' => $company->id,
                     'created_by' => $company->user_id,

database/migrations/2024_11_27_223015_create_invoices_table.php

             $table->timestamp('approved_at')->nullable();
             $table->timestamp('paid_at')->nullable();
             $table->timestamp('last_sent_at')->nullable();
+            $table->timestamp('last_viewed_at')->nullable();
             $table->string('status')->default('draft');
             $table->string('currency_code')->nullable();
             $table->string('discount_method')->default('per_line_item');