wip Invoice

app/Collections/Accounting/InvoiceCollection.php

+<?php
+
+namespace App\Collections\Accounting;
+
+use App\Models\Accounting\Invoice;
+use App\Utilities\Currency\CurrencyAccessor;
+use App\Utilities\Currency\CurrencyConverter;
+use Illuminate\Database\Eloquent\Collection;
+
+class InvoiceCollection extends Collection
+{
+    public function sumMoneyInCents(string $column): int
+    {
+        return $this->reduce(static function ($carry, Invoice $invoice) use ($column) {
+            return $carry + $invoice->getRawOriginal($column);
+        }, 0);
+    }
+
+    public function sumMoneyFormattedSimple(string $column, ?string $currency = null): string
+    {
+        $currency ??= CurrencyAccessor::getDefaultCurrency();
+
+        $totalCents = $this->sumMoneyInCents($column);
+
+        return CurrencyConverter::convertCentsToFormatSimple($totalCents, $currency);
+    }
+}

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

 
 namespace App\Filament\Company\Resources\Sales;
 
+use App\Collections\Accounting\InvoiceCollection;
 use App\Enums\Accounting\InvoiceStatus;
-use App\Enums\Accounting\JournalEntryType;
 use App\Enums\Accounting\PaymentMethod;
-use App\Enums\Accounting\TransactionType;
 use App\Filament\Company\Resources\Sales\InvoiceResource\Pages;
 use App\Filament\Company\Resources\Sales\InvoiceResource\RelationManagers;
-use App\Models\Accounting\Account;
+use App\Filament\Tables\Actions\ReplicateBulkAction;
+use App\Filament\Tables\Filters\DateRangeFilter;
 use App\Models\Accounting\Adjustment;
 use App\Models\Accounting\DocumentLineItem;
 use App\Models\Accounting\Invoice;
 use Filament\Forms;
 use Filament\Forms\Components\FileUpload;
 use Filament\Forms\Form;
+use Filament\Notifications\Notification;
 use Filament\Resources\Resource;
 use Filament\Support\Enums\Alignment;
 use Filament\Support\Enums\MaxWidth;
 use Filament\Tables;
 use Filament\Tables\Table;
+use Illuminate\Database\Eloquent\Collection;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Carbon;
 use Illuminate\Support\Facades\Auth;
                                     ->live()
                                     ->afterStateUpdated(function (Forms\Set $set, Forms\Get $get, $state) {
                                         $offeringId = $state;
-                                        $offeringRecord = Offering::with('salesTaxes')->find($offeringId);
+                                        $offeringRecord = Offering::with(['salesTaxes', 'salesDiscounts'])->find($offeringId);
 
                                         if ($offeringRecord) {
                                             $set('description', $offeringRecord->description);
                     ->currency(),
             ])
             ->filters([
-                //
-            ])
+                Tables\Filters\SelectFilter::make('status')
+                    ->options(InvoiceStatus::class)
+                    ->native(false),
+                Tables\Filters\SelectFilter::make('client')
+                    ->relationship('client', 'name')
+                    ->searchable()
+                    ->preload(),
+                DateRangeFilter::make('date')
+                    ->fromLabel('From Date')
+                    ->untilLabel('Until Date')
+                    ->indicatorLabel('Date Range'),
+            ], layout: Tables\Enums\FiltersLayout::Modal)
+            ->filtersFormWidth(MaxWidth::Small)
+            ->filtersTriggerAction(
+                fn (Tables\Actions\Action $action) => $action
+                    ->label('Filter')
+                    ->slideOver(),
+            )
             ->actions([
                 Tables\Actions\ActionGroup::make([
                     Tables\Actions\EditAction::make(),
                         ->databaseTransaction()
                         ->successNotificationTitle('Invoice Approved')
                         ->action(function (Invoice $record, Tables\Actions\Action $action) {
-                            $transaction = $record->transactions()->create([
-                                'type' => TransactionType::Journal,
-                                'posted_at' => now(),
-                                'amount' => $record->total,
-                                'description' => 'Invoice Approval for Invoice #' . $record->invoice_number,
-                            ]);
-
-                            $transaction->journalEntries()->create([
-                                'type' => JournalEntryType::Debit,
-                                'account_id' => Account::getAccountsReceivableAccount()->id,
-                                'amount' => $record->total,
-                                'description' => $transaction->description,
-                            ]);
-
-                            foreach ($record->lineItems as $lineItem) {
-                                $transaction->journalEntries()->create([
-                                    'type' => JournalEntryType::Credit,
-                                    'account_id' => $lineItem->offering->income_account_id,
-                                    'amount' => $lineItem->subtotal,
-                                    'description' => $transaction->description,
-                                ]);
-
-                                foreach ($lineItem->adjustments as $adjustment) {
-                                    $transaction->journalEntries()->create([
-                                        'type' => $adjustment->category->isDiscount() ? JournalEntryType::Debit : JournalEntryType::Credit,
-                                        'account_id' => $adjustment->account_id,
-                                        'amount' => $lineItem->calculateAdjustmentTotal($adjustment)->getAmount(),
-                                        'description' => $transaction->description,
-                                    ]);
-                                }
-                            }
-
-                            $record->updateQuietly([
-                                'status' => InvoiceStatus::Unsent,
-                            ]);
+                            $record->approveDraft();
 
                             $action->success();
                         }),
             ->bulkActions([
                 Tables\Actions\BulkActionGroup::make([
                     Tables\Actions\DeleteBulkAction::make(),
+                    ReplicateBulkAction::make()
+                        ->label('Replicate')
+                        ->modalWidth(MaxWidth::Large)
+                        ->modalDescription('Replicating invoices will also replicate their line items. Are you sure you want to proceed?')
+                        ->successNotificationTitle('Invoices Replicated Successfully')
+                        ->failureNotificationTitle('Failed to Replicate Invoices')
+                        ->databaseTransaction()
+                        ->deselectRecordsAfterCompletion()
+                        ->excludeAttributes([
+                            'status',
+                            'amount_paid',
+                            'amount_due',
+                            'created_by',
+                            'updated_by',
+                            'created_at',
+                            'updated_at',
+                            'invoice_number',
+                            'date',
+                            'due_date',
+                        ])
+                        ->beforeReplicaSaved(function (Invoice $replica) {
+                            $replica->status = InvoiceStatus::Draft;
+                            $replica->invoice_number = Invoice::getNextDocumentNumber();
+                            $replica->date = now();
+                            $replica->due_date = now()->addDays($replica->company->defaultInvoice->payment_terms->getDays());
+                        })
+                        ->withReplicatedRelationships(['lineItems'])
+                        ->withExcludedRelationshipAttributes('lineItems', [
+                            'subtotal',
+                            'total',
+                            'created_by',
+                            'updated_by',
+                            'created_at',
+                            'updated_at',
+                        ]),
+                    Tables\Actions\BulkAction::make('approveDrafts')
+                        ->label('Approve')
+                        ->icon('heroicon-o-check-circle')
+                        ->databaseTransaction()
+                        ->successNotificationTitle('Invoices Approved')
+                        ->failureNotificationTitle('Failed to Approve Invoices')
+                        ->before(function (Collection $records, Tables\Actions\BulkAction $action) {
+                            $containsNonDrafts = $records->contains(fn (Invoice $record) => ! $record->isDraft());
+
+                            if ($containsNonDrafts) {
+                                Notification::make()
+                                    ->title('Approval Failed')
+                                    ->body('Only draft invoices can be approved. Please adjust your selection and try again.')
+                                    ->persistent()
+                                    ->danger()
+                                    ->send();
+
+                                $action->cancel(true);
+                            }
+                        })
+                        ->action(function (Collection $records, Tables\Actions\BulkAction $action) {
+                            $records->each(function (Invoice $record) {
+                                $record->approveDraft();
+                            });
+
+                            $action->success();
+                        }),
+                    Tables\Actions\BulkAction::make('markAsSent')
+                        ->label('Mark as Sent')
+                        ->icon('heroicon-o-paper-airplane')
+                        ->databaseTransaction()
+                        ->successNotificationTitle('Invoices Sent')
+                        ->failureNotificationTitle('Failed to Mark Invoices as Sent')
+                        ->before(function (Collection $records, Tables\Actions\BulkAction $action) {
+                            $doesntContainUnsent = $records->contains(fn (Invoice $record) => $record->status !== InvoiceStatus::Unsent);
+
+                            if ($doesntContainUnsent) {
+                                Notification::make()
+                                    ->title('Sending Failed')
+                                    ->body('Only unsent invoices can be marked as sent. Please adjust your selection and try again.')
+                                    ->persistent()
+                                    ->danger()
+                                    ->send();
+
+                                $action->cancel(true);
+                            }
+                        })
+                        ->action(function (Collection $records, Tables\Actions\BulkAction $action) {
+                            $records->each(function (Invoice $record) {
+                                $record->updateQuietly([
+                                    'status' => InvoiceStatus::Sent,
+                                ]);
+                            });
+
+                            $action->success();
+                        }),
+                    Tables\Actions\BulkAction::make('recordPayments')
+                        ->label('Record Payments')
+                        ->icon('heroicon-o-credit-card')
+                        ->stickyModalHeader()
+                        ->stickyModalFooter()
+                        ->modalFooterActionsAlignment(Alignment::End)
+                        ->modalWidth(MaxWidth::TwoExtraLarge)
+                        ->databaseTransaction()
+                        ->successNotificationTitle('Payments Recorded')
+                        ->failureNotificationTitle('Failed to Record Payments')
+                        ->deselectRecordsAfterCompletion()
+                        ->beforeFormFilled(function (Collection $records, Tables\Actions\BulkAction $action) {
+                            $cantRecordPayments = $records->contains(fn (Invoice $record) => ! $record->canBulkRecordPayment());
+
+                            if ($cantRecordPayments) {
+                                Notification::make()
+                                    ->title('Payment Recording Failed')
+                                    ->body('Invoices that are either draft, paid, overpaid, or voided cannot be processed through bulk payments. Please adjust your selection and try again.')
+                                    ->persistent()
+                                    ->danger()
+                                    ->send();
+
+                                $action->cancel(true);
+                            }
+                        })
+                        ->mountUsing(function (InvoiceCollection $records, Form $form) {
+                            $totalAmountDue = $records->sumMoneyFormattedSimple('amount_due');
+
+                            $form->fill([
+                                'posted_at' => now(),
+                                'amount' => $totalAmountDue,
+                            ]);
+                        })
+                        ->form([
+                            Forms\Components\DatePicker::make('posted_at')
+                                ->label('Date'),
+                            Forms\Components\TextInput::make('amount')
+                                ->label('Amount')
+                                ->required()
+                                ->money()
+                                ->rules([
+                                    static fn (): Closure => static function (string $attribute, $value, Closure $fail) {
+                                        if (! CurrencyConverter::isValidAmount($value)) {
+                                            $fail('Please enter a valid amount');
+                                        }
+                                    },
+                                ]),
+                            Forms\Components\Select::make('payment_method')
+                                ->label('Payment Method')
+                                ->required()
+                                ->options(PaymentMethod::class),
+                            Forms\Components\Select::make('bank_account_id')
+                                ->label('Account')
+                                ->required()
+                                ->options(BankAccount::query()
+                                    ->get()
+                                    ->pluck('account.name', 'id'))
+                                ->searchable(),
+                            Forms\Components\Textarea::make('notes')
+                                ->label('Notes'),
+                        ])
+                        ->before(function (InvoiceCollection $records, Tables\Actions\BulkAction $action, array $data) {
+                            $totalPaymentAmount = CurrencyConverter::convertToCents($data['amount']);
+                            $totalAmountDue = $records->sumMoneyInCents('amount_due');
+
+                            if ($totalPaymentAmount > $totalAmountDue) {
+                                $formattedTotalAmountDue = CurrencyConverter::formatCentsToMoney($totalAmountDue);
+
+                                Notification::make()
+                                    ->title('Excess Payment Amount')
+                                    ->body("The payment amount exceeds the total amount due of {$formattedTotalAmountDue}. Please adjust the payment amount and try again.")
+                                    ->persistent()
+                                    ->warning()
+                                    ->send();
+
+                                $action->halt(true);
+                            }
+                        })
+                        ->action(function (InvoiceCollection $records, Tables\Actions\BulkAction $action, array $data) {
+                            $totalPaymentAmount = CurrencyConverter::convertToCents($data['amount']);
+
+                            $remainingAmount = $totalPaymentAmount;
+
+                            $records->each(function (Invoice $record) use (&$remainingAmount, $data) {
+                                $amountDue = $record->getRawOriginal('amount_due');
+
+                                if ($amountDue <= 0 || $remainingAmount <= 0) {
+                                    return;
+                                }
+
+                                $paymentAmount = min($amountDue, $remainingAmount);
+
+                                $data['amount'] = CurrencyConverter::convertCentsToFormatSimple($paymentAmount);
+
+                                $record->recordPayment($data);
+
+                                $remainingAmount -= $paymentAmount;
+                            });
+
+                            $action->success();
+                        }),
                 ]),
             ]);
     }

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

                             ->color('primary')
                             ->weight(FontWeight::SemiBold)
                             ->url(fn (Invoice $record) => ClientResource::getUrl('edit', ['record' => $record->client_id])),
+                        TextEntry::make('total')
+                            ->label('Total')
+                            ->money(),
                         TextEntry::make('amount_due')
                             ->label('Amount Due')
                             ->money(),

app/Filament/Tables/Actions/ReplicateBulkAction.php

 use Illuminate\Database\Eloquent\Relations\BelongsToMany;
 use Illuminate\Database\Eloquent\Relations\HasMany;
 use Illuminate\Database\Eloquent\Relations\HasOne;
+use Illuminate\Database\Eloquent\Relations\MorphMany;
 
 class ReplicateBulkAction extends BulkAction implements ReplicatesRecords
 {
 
     protected array $relationshipsToReplicate = [];
 
+    protected array | Closure | null $excludedAttributesPerRelationship = null;
+
     public static function getDefaultName(): ?string
     {
         return 'replicate';
                 $records->each(function (Model $record) {
                     $this->replica = $record->replicate($this->getExcludedAttributes());
 
-                    $this->replica->fill($record->attributesToArray());
-
                     $this->callBeforeReplicaSaved();
 
                     $this->replica->save();
         foreach ($this->relationshipsToReplicate as $relationship) {
             $relation = $original->$relationship();
 
+            $excludedAttributes = $this->excludedAttributesPerRelationship[$relationship] ?? [];
+
             if ($relation instanceof BelongsToMany) {
                 $replica->$relationship()->sync($relation->pluck($relation->getRelated()->getKeyName()));
             } elseif ($relation instanceof HasMany) {
-                $relation->each(function (Model $related) use ($replica, $relationship) {
-                    $relatedReplica = $related->replicate($this->getExcludedAttributes());
+                $relation->each(function (Model $related) use ($excludedAttributes, $replica, $relationship) {
+                    $relatedReplica = $related->replicate($excludedAttributes);
                     $relatedReplica->{$replica->$relationship()->getForeignKeyName()} = $replica->getKey();
                     $relatedReplica->save();
                 });
+            } elseif ($relation instanceof MorphMany) {
+                $relation->each(function (Model $related) use ($excludedAttributes, $relation, $replica) {
+                    $relatedReplica = $related->replicate($excludedAttributes);
+                    $relatedReplica->{$relation->getForeignKeyName()} = $replica->getKey();
+                    $relatedReplica->{$relation->getMorphType()} = $replica->getMorphClass();
+                    $relatedReplica->save();
+
+                    if (method_exists($related, 'adjustments')) {
+                        $relatedReplica->adjustments()->sync($related->adjustments->pluck('id'));
+                    }
+                });
             } elseif ($relation instanceof HasOne && $relation->exists()) {
                 $related = $relation->first();
-                $relatedReplica = $related->replicate($this->getExcludedAttributes());
+                $relatedReplica = $related->replicate($excludedAttributes);
                 $relatedReplica->{$replica->$relationship()->getForeignKeyName()} = $replica->getKey();
                 $relatedReplica->save();
             }
         return $this;
     }
 
+    public function withExcludedRelationshipAttributes(string $relationship, array | Closure | null $attributes): static
+    {
+        $this->excludedAttributesPerRelationship[$relationship] = $attributes;
+
+        return $this;
+    }
+
+    public function getExcludedRelationshipAttributes(): ?array
+    {
+        return $this->evaluate($this->excludedAttributesPerRelationship);
+    }
+
     public function afterReplicaSaved(Closure $callback): static
     {
         $this->afterReplicaSaved = $callback;

app/Filament/Tables/Filters/DateRangeFilter.php

+<?php
+
+namespace App\Filament\Tables\Filters;
+
+use Filament\Forms\Components\DatePicker;
+use Filament\Forms\Get;
+use Filament\Forms\Set;
+use Filament\Tables\Filters\Filter;
+use Filament\Tables\Filters\Indicator;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Str;
+
+class DateRangeFilter extends Filter
+{
+    protected string $fromLabel = 'From';
+
+    protected string $untilLabel = 'Until';
+
+    protected ?string $indicatorLabel = null;
+
+    protected ?string $defaultFromDate = null;
+
+    protected ?string $defaultUntilDate = null;
+
+    protected ?string $fromColumn = null;
+
+    protected ?string $untilColumn = null;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->form([
+            DatePicker::make('from')
+                ->label(fn () => $this->fromLabel)
+                ->live()
+                ->default(fn () => $this->defaultFromDate)
+                ->maxDate(function (Get $get) {
+                    return $get('until');
+                })
+                ->afterStateUpdated(function (Set $set, $state) {
+                    if (! $state) {
+                        $set('until', null);
+                    }
+                }),
+            DatePicker::make('until')
+                ->label(fn () => $this->untilLabel)
+                ->live()
+                ->default(fn () => $this->defaultUntilDate)
+                ->minDate(function (Get $get) {
+                    return $get('from');
+                }),
+        ]);
+
+        $this->query(function (Builder $query, array $data): Builder {
+            $fromColumn = $this->fromColumn ?? $this->getName();
+            $untilColumn = $this->untilColumn ?? $this->getName();
+
+            $fromDate = filled($data['from'] ?? null)
+                ? Carbon::parse($data['from'])
+                : null;
+
+            $untilDate = filled($data['until'] ?? null)
+                ? Carbon::parse($data['until'])
+                : null;
+
+            if (! $fromDate && ! $untilDate) {
+                return $query;
+            }
+
+            return $this->applyDateFilter($query, $fromDate, $untilDate, $fromColumn, $untilColumn);
+        });
+
+        $this->indicateUsing(function (array $data): array {
+            $indicators = [];
+
+            $fromDateFormatted = filled($data['from'] ?? null)
+                ? Carbon::parse($data['from'])->toDefaultDateFormat()
+                : null;
+
+            $untilDateFormatted = filled($data['until'] ?? null)
+                ? Carbon::parse($data['until'])->toDefaultDateFormat()
+                : null;
+
+            if ($fromDateFormatted && $untilDateFormatted) {
+                $indicators[] = Indicator::make($this->getIndicatorLabel() . ': ' . $fromDateFormatted . ' - ' . $untilDateFormatted);
+            } else {
+                if ($fromDateFormatted) {
+                    $indicators[] = Indicator::make($this->fromLabel . ': ' . $fromDateFormatted)
+                        ->removeField('from');
+                }
+
+                if ($untilDateFormatted) {
+                    $indicators[] = Indicator::make($this->untilLabel . ': ' . $untilDateFormatted)
+                        ->removeField('until');
+                }
+            }
+
+            return $indicators;
+        });
+    }
+
+    protected function applyDateFilter(Builder $query, ?Carbon $fromDate, ?Carbon $untilDate, string $fromColumn, string $untilColumn): Builder
+    {
+        return $query
+            ->when($fromDate && ! $untilDate, function (Builder $query) use ($fromColumn, $fromDate) {
+                return $query->where($fromColumn, '>=', $fromDate);
+            })
+            ->when($fromDate && $untilDate, function (Builder $query) use ($fromColumn, $fromDate, $untilColumn, $untilDate) {
+                return $query->where($fromColumn, '>=', $fromDate)
+                    ->where($untilColumn, '<=', $untilDate);
+            })
+            ->when(! $fromDate && $untilDate, function (Builder $query) use ($untilColumn, $untilDate) {
+                return $query->where($untilColumn, '<=', $untilDate);
+            });
+    }
+
+    public function fromLabel(string $label): static
+    {
+        $this->fromLabel = $label;
+
+        return $this;
+    }
+
+    public function untilLabel(string $label): static
+    {
+        $this->untilLabel = $label;
+
+        return $this;
+    }
+
+    public function indicatorLabel(string $label): static
+    {
+        $this->indicatorLabel = $label;
+
+        return $this;
+    }
+
+    public function getIndicatorLabel(): string
+    {
+        return $this->indicatorLabel ?? Str::headline($this->getName());
+    }
+
+    public function defaultFromDate(string $date): static
+    {
+        $this->defaultFromDate = $date;
+
+        return $this;
+    }
+
+    public function defaultUntilDate(string $date): static
+    {
+        $this->defaultUntilDate = $date;
+
+        return $this;
+    }
+
+    public function fromColumn(string $column): static
+    {
+        $this->fromColumn = $column;
+
+        return $this;
+    }
+
+    public function untilColumn(string $column): static
+    {
+        $this->untilColumn = $column;
+
+        return $this;
+    }
+}

app/Models/Accounting/Invoice.php

 namespace App\Models\Accounting;
 
 use App\Casts\MoneyCast;
+use App\Collections\Accounting\InvoiceCollection;
 use App\Concerns\Blamable;
 use App\Concerns\CompanyOwned;
 use App\Enums\Accounting\InvoiceStatus;
+use App\Enums\Accounting\JournalEntryType;
 use App\Enums\Accounting\TransactionType;
 use App\Models\Common\Client;
 use App\Observers\InvoiceObserver;
+use Illuminate\Database\Eloquent\Attributes\CollectedBy;
 use Illuminate\Database\Eloquent\Attributes\ObservedBy;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\MorphOne;
 
 #[ObservedBy(InvoiceObserver::class)]
+#[CollectedBy(InvoiceCollection::class)]
 class Invoice extends Model
 {
     use Blamable;
         ]);
     }
 
+    public function canBulkRecordPayment(): bool
+    {
+        return ! in_array($this->status, [
+            InvoiceStatus::Draft,
+            InvoiceStatus::Paid,
+            InvoiceStatus::Void,
+            InvoiceStatus::Overpaid,
+        ]);
+    }
+
     public static function getNextDocumentNumber(): string
     {
         $company = auth()->user()->currentCompany;
 
         // Create transaction
         $this->transactions()->create([
+            'company_id' => $this->company_id,
             'type' => $transactionType,
             'is_payment' => true,
             'posted_at' => $data['posted_at'],
             'notes' => $data['notes'] ?? null,
         ]);
     }
+
+    public function approveDraft(): void
+    {
+        if (! $this->isDraft()) {
+            throw new \RuntimeException('Invoice is not in draft status.');
+        }
+
+        $transaction = $this->transactions()->create([
+            'company_id' => $this->company_id,
+            'type' => TransactionType::Journal,
+            'posted_at' => now(),
+            'amount' => $this->total,
+            'description' => 'Invoice Approval for Invoice #' . $this->invoice_number,
+        ]);
+
+        $transaction->journalEntries()->create([
+            'company_id' => $this->company_id,
+            'type' => JournalEntryType::Debit,
+            'account_id' => Account::getAccountsReceivableAccount()->id,
+            'amount' => $this->total,
+            'description' => $transaction->description,
+        ]);
+
+        foreach ($this->lineItems as $lineItem) {
+            $transaction->journalEntries()->create([
+                'company_id' => $this->company_id,
+                'type' => JournalEntryType::Credit,
+                'account_id' => $lineItem->offering->income_account_id,
+                'amount' => $lineItem->subtotal,
+                'description' => $transaction->description,
+            ]);
+
+            foreach ($lineItem->adjustments as $adjustment) {
+                $transaction->journalEntries()->create([
+                    'company_id' => $this->company_id,
+                    'type' => $adjustment->category->isDiscount() ? JournalEntryType::Debit : JournalEntryType::Credit,
+                    'account_id' => $adjustment->account_id,
+                    'amount' => $lineItem->calculateAdjustmentTotal($adjustment)->getAmount(),
+                    'description' => $transaction->description,
+                ]);
+            }
+        }
+
+        $this->updateQuietly([
+            'status' => InvoiceStatus::Unsent,
+        ]);
+    }
 }

app/Observers/InvoiceObserver.php

     }
 
     public function deleting(Invoice $invoice): void
+    {
+        //
+    }
+
+    /**
+     * Handle the Invoice "deleted" event.
+     */
+    public function deleted(Invoice $invoice): void
     {
         DB::transaction(function () use ($invoice) {
             $invoice->lineItems()->each(function (DocumentLineItem $lineItem) {
         });
     }
 
-    /**
-     * Handle the Invoice "deleted" event.
-     */
-    public function deleted(Invoice $invoice): void
-    {
-        //
-    }
-
     /**
      * Handle the Invoice "restored" event.
      */

app/Observers/TransactionObserver.php

 
             $invoice = $transaction->transactionable;
 
+            if ($invoice instanceof Invoice && ! $invoice->exists) {
+                return;
+            }
+
             if ($invoice instanceof Invoice) {
                 $this->updateInvoiceTotals($invoice, $transaction);
             }

app/Providers/FilamentCompaniesServiceProvider.php

         Tables\Actions\EditAction::configureUsing(static fn (Tables\Actions\EditAction $action) => FilamentComponentConfigurator::configureActionModals($action));
         Tables\Actions\CreateAction::configureUsing(static fn (Tables\Actions\CreateAction $action) => FilamentComponentConfigurator::configureActionModals($action));
         Tables\Actions\DeleteAction::configureUsing(static fn (Tables\Actions\DeleteAction $action) => FilamentComponentConfigurator::configureDeleteAction($action));
+        Tables\Actions\DeleteBulkAction::configureUsing(static fn (Tables\Actions\DeleteBulkAction $action) => FilamentComponentConfigurator::configureDeleteAction($action));
         Forms\Components\DateTimePicker::configureUsing(static function (Forms\Components\DateTimePicker $component) {
             $component->native(false);
         });

app/Utilities/Currency/CurrencyConverter.php

         return money($amount, $currency, true)->getAmount();
     }
 
+    public static function convertCentsToFormatSimple(int $amount, ?string $currency = null): string
+    {
+        $currency ??= CurrencyAccessor::getDefaultCurrency();
+
+        return money($amount, $currency)->formatSimple();
+    }
+
     public static function convertToCents(string | float $amount, ?string $currency = null): int
     {
         $currency ??= CurrencyAccessor::getDefaultCurrency();

composer.lock

         },
         {
             "name": "squirephp/model",
-            "version": "v3.6.0",
+            "version": "v3.7.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/squirephp/model.git",
         },
         {
             "name": "squirephp/repository",
-            "version": "v3.6.0",
+            "version": "v3.7.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/squirephp/repository.git",
             "type": "library",
             "extra": {
                 "laravel": {
-                    "providers": [
-                        "Squire\\RepositoryServiceProvider"
-                    ],
                     "aliases": {
                         "RepositoryManager": "Squire\\Repository\\Facades\\Repository"
-                    }
+                    },
+                    "providers": [
+                        "Squire\\RepositoryServiceProvider"
+                    ]
                 }
             },
             "autoload": {
         },
         {
             "name": "pestphp/pest",
-            "version": "v3.5.1",
+            "version": "v3.5.2",
             "source": {
                 "type": "git",
                 "url": "https://github.com/pestphp/pest.git",
-                "reference": "179d46ce97d52bcb3f791449ae94025c3f32e3e3"
+                "reference": "982353fb38703518c1370d420733a7b61ebc997f"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/pestphp/pest/zipball/179d46ce97d52bcb3f791449ae94025c3f32e3e3",
-                "reference": "179d46ce97d52bcb3f791449ae94025c3f32e3e3",
+                "url": "https://api.github.com/repos/pestphp/pest/zipball/982353fb38703518c1370d420733a7b61ebc997f",
+                "reference": "982353fb38703518c1370d420733a7b61ebc997f",
                 "shasum": ""
             },
             "require": {
                 "brianium/paratest": "^7.6.0",
                 "nunomaduro/collision": "^8.5.0",
-                "nunomaduro/termwind": "^2.2.0",
+                "nunomaduro/termwind": "^2.3.0",
                 "pestphp/pest-plugin": "^3.0.0",
                 "pestphp/pest-plugin-arch": "^3.0.0",
                 "pestphp/pest-plugin-mutate": "^3.0.5",
                 "php": "^8.2.0",
-                "phpunit/phpunit": "^11.4.3"
+                "phpunit/phpunit": "^11.4.4"
             },
             "conflict": {
                 "filp/whoops": "<2.16.0",
-                "phpunit/phpunit": ">11.4.3",
+                "phpunit/phpunit": ">11.4.4",
                 "sebastian/exporter": "<6.0.0",
                 "webmozart/assert": "<1.11.0"
             },
             "require-dev": {
                 "pestphp/pest-dev-tools": "^3.3.0",
-                "pestphp/pest-plugin-type-coverage": "^3.1.0",
-                "symfony/process": "^7.1.6"
+                "pestphp/pest-plugin-type-coverage": "^3.2.0",
+                "symfony/process": "^7.1.8"
             },
             "bin": [
                 "bin/pest"
             ],
             "support": {
                 "issues": "https://github.com/pestphp/pest/issues",
-                "source": "https://github.com/pestphp/pest/tree/v3.5.1"
+                "source": "https://github.com/pestphp/pest/tree/v3.5.2"
             },
             "funding": [
                 {
                     "type": "github"
                 }
             ],
-            "time": "2024-10-31T16:12:45+00:00"
+            "time": "2024-12-01T21:28:14+00:00"
         },
         {
             "name": "pestphp/pest-plugin",
         },
         {
             "name": "phpunit/phpunit",
-            "version": "11.4.3",
+            "version": "11.4.4",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/phpunit.git",
-                "reference": "e8e8ed1854de5d36c088ec1833beae40d2dedd76"
+                "reference": "f9ba7bd3c9f3ff54ec379d7a1c2e3f13fe0bbde4"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/e8e8ed1854de5d36c088ec1833beae40d2dedd76",
-                "reference": "e8e8ed1854de5d36c088ec1833beae40d2dedd76",
+                "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/f9ba7bd3c9f3ff54ec379d7a1c2e3f13fe0bbde4",
+                "reference": "f9ba7bd3c9f3ff54ec379d7a1c2e3f13fe0bbde4",
                 "shasum": ""
             },
             "require": {
                 "ext-mbstring": "*",
                 "ext-xml": "*",
                 "ext-xmlwriter": "*",
-                "myclabs/deep-copy": "^1.12.0",
+                "myclabs/deep-copy": "^1.12.1",
                 "phar-io/manifest": "^2.0.4",
                 "phar-io/version": "^3.2.1",
                 "php": ">=8.2",
                 "phpunit/php-timer": "^7.0.1",
                 "sebastian/cli-parser": "^3.0.2",
                 "sebastian/code-unit": "^3.0.1",
-                "sebastian/comparator": "^6.1.1",
+                "sebastian/comparator": "^6.2.1",
                 "sebastian/diff": "^6.0.2",
                 "sebastian/environment": "^7.2.0",
                 "sebastian/exporter": "^6.1.3",
             "support": {
                 "issues": "https://github.com/sebastianbergmann/phpunit/issues",
                 "security": "https://github.com/sebastianbergmann/phpunit/security/policy",
-                "source": "https://github.com/sebastianbergmann/phpunit/tree/11.4.3"
+                "source": "https://github.com/sebastianbergmann/phpunit/tree/11.4.4"
             },
             "funding": [
                 {
                     "type": "tidelift"
                 }
             ],
-            "time": "2024-10-28T13:07:50+00:00"
+            "time": "2024-11-27T10:44:52+00:00"
         },
         {
             "name": "pimple/pimple",

database/factories/Accounting/DocumentLineItemFactory.php

 
 namespace Database\Factories\Accounting;
 
+use App\Models\Accounting\DocumentLineItem;
+use App\Models\Common\Offering;
 use Illuminate\Database\Eloquent\Factories\Factory;
 
 /**
- * @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\Accounting\DocumentLineItem>
+ * @extends Factory<DocumentLineItem>
  */
 class DocumentLineItemFactory extends Factory
 {
+    /**
+     * The name of the factory's corresponding model.
+     */
+    protected $model = DocumentLineItem::class;
+
     /**
      * Define the model's default state.
      *
      */
     public function definition(): array
     {
+        $offering = Offering::with(['salesTaxes', 'salesDiscounts'])->inRandomOrder()->first();
+
+        $quantity = $this->faker->numberBetween(1, 10);
+        $unitPrice = $offering->price;
+
         return [
-            //
+            'company_id' => 1,
+            'offering_id' => 1,
+            'description' => $this->faker->sentence,
+            'quantity' => $quantity,
+            'unit_price' => $unitPrice,
+            'created_by' => 1,
+            'updated_by' => 1,
         ];
     }
+
+    public function configure(): static
+    {
+        return $this->afterCreating(function (DocumentLineItem $lineItem) {
+            $offering = $lineItem->offering;
+
+            if ($offering) {
+                $lineItem->salesTaxes()->sync($offering->salesTaxes->pluck('id')->toArray());
+                $lineItem->salesDiscounts()->sync($offering->salesDiscounts->pluck('id')->toArray());
+            }
+
+            $taxTotal = $lineItem->calculateTaxTotal()->getAmount();
+            $discountTotal = $lineItem->calculateDiscountTotal()->getAmount();
+
+            $lineItem->updateQuietly([
+                'tax_total' => $taxTotal,
+                'discount_total' => $discountTotal,
+            ]);
+        });
+    }
 }

database/factories/Accounting/InvoiceFactory.php

 
 namespace Database\Factories\Accounting;
 
+use App\Enums\Accounting\InvoiceStatus;
+use App\Enums\Accounting\PaymentMethod;
+use App\Models\Accounting\DocumentLineItem;
+use App\Models\Accounting\Invoice;
+use App\Models\Banking\BankAccount;
+use App\Models\Common\Client;
+use App\Utilities\Currency\CurrencyConverter;
 use Illuminate\Database\Eloquent\Factories\Factory;
 
 /**
- * @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\Accounting\Invoice>
+ * @extends Factory<Invoice>
  */
 class InvoiceFactory extends Factory
 {
+    /**
+     * The name of the factory's corresponding model.
+     */
+    protected $model = Invoice::class;
+
     /**
      * Define the model's default state.
      *
     public function definition(): array
     {
         return [
-            //
+            'company_id' => 1,
+            'client_id' => Client::inRandomOrder()->value('id'),
+            'header' => 'Invoice',
+            'subheader' => 'Invoice',
+            'invoice_number' => $this->faker->unique()->numerify('INV-#####'),
+            'order_number' => $this->faker->unique()->numerify('ORD-#####'),
+            'date' => $this->faker->dateTimeBetween('-1 year'),
+            'due_date' => $this->faker->dateTimeBetween('now', '+2 months'),
+            'status' => InvoiceStatus::Draft,
+            'currency_code' => 'USD',
+            'terms' => $this->faker->sentence,
+            'footer' => $this->faker->sentence,
+            'created_by' => 1,
+            'updated_by' => 1,
         ];
     }
+
+    public function withLineItems(int $count = 3): self
+    {
+        return $this->has(DocumentLineItem::factory()->count($count), 'lineItems');
+    }
+
+    public function approved(): static
+    {
+        return $this->afterCreating(function (Invoice $invoice) {
+            if (! $invoice->isDraft()) {
+                return;
+            }
+
+            $invoice->approveDraft();
+        });
+    }
+
+    public function withPayments(?int $min = 1, ?int $max = null, InvoiceStatus $invoiceStatus = InvoiceStatus::Paid): static
+    {
+        return $this->afterCreating(function (Invoice $invoice) use ($invoiceStatus, $max, $min) {
+            if ($invoice->isDraft()) {
+                $invoice->approveDraft();
+            }
+
+            $this->recalculateTotals($invoice);
+
+            $invoice->refresh();
+
+            $totalAmountDue = $invoice->getRawOriginal('amount_due');
+
+            if ($invoiceStatus === InvoiceStatus::Overpaid) {
+                $totalAmountDue += random_int(1000, 10000);
+            } elseif ($invoiceStatus === InvoiceStatus::Partial) {
+                $totalAmountDue = (int) floor($totalAmountDue * 0.5);
+            }
+
+            if ($totalAmountDue <= 0 || empty($totalAmountDue)) {
+                return;
+            }
+
+            $paymentCount = $max && $min ? $this->faker->numberBetween($min, $max) : $min;
+
+            $paymentAmount = (int) floor($totalAmountDue / $paymentCount);
+            $remainingAmount = $totalAmountDue;
+
+            for ($i = 0; $i < $paymentCount; $i++) {
+                $amount = $i === $paymentCount - 1 ? $remainingAmount : $paymentAmount;
+
+                if ($amount <= 0) {
+                    break;
+                }
+
+                $data = [
+                    'posted_at' => $invoice->date->addDay(),
+                    'amount' => CurrencyConverter::convertCentsToFormatSimple($amount, $invoice->currency_code),
+                    'payment_method' => $this->faker->randomElement(PaymentMethod::class),
+                    'bank_account_id' => BankAccount::inRandomOrder()->value('id'),
+                    'notes' => $this->faker->sentence,
+                ];
+
+                $invoice->recordPayment($data);
+
+                $remainingAmount -= $amount;
+            }
+        });
+    }
+
+    public function configure(): static
+    {
+        return $this->afterCreating(function (Invoice $invoice) {
+            // Use the invoice's ID to generate invoice and order numbers
+            $paddedId = str_pad((string) $invoice->id, 5, '0', STR_PAD_LEFT);
+
+            $invoice->updateQuietly([
+                'invoice_number' => "INV-{$paddedId}",
+                'order_number' => "ORD-{$paddedId}",
+            ]);
+
+            $this->recalculateTotals($invoice);
+
+            if ($invoice->due_date->isPast() && ! in_array($invoice->status, [InvoiceStatus::Draft, InvoiceStatus::Paid, InvoiceStatus::Void, InvoiceStatus::Overpaid])) {
+                $invoice->updateQuietly([
+                    'status' => InvoiceStatus::Overdue,
+                ]);
+            }
+        });
+    }
+
+    protected function recalculateTotals(Invoice $invoice): void
+    {
+        if ($invoice->lineItems()->exists()) {
+            $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->updateQuietly([
+                'subtotal' => $subtotal,
+                'tax_total' => $taxTotal,
+                'discount_total' => $discountTotal,
+                'total' => $grandTotal,
+            ]);
+        }
+    }
 }

database/factories/CompanyFactory.php

 
 namespace Database\Factories;
 
+use App\Enums\Accounting\InvoiceStatus;
+use App\Models\Accounting\Invoice;
 use App\Models\Accounting\Transaction;
 use App\Models\Common\Client;
 use App\Models\Common\Offering;
                 ]);
         });
     }
+
+    public function withInvoices(int $count = 10): self
+    {
+        return $this->afterCreating(function (Company $company) use ($count) {
+            $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);
+
+            Invoice::factory()
+                ->count($draftCount)
+                ->withLineItems()
+                ->create([
+                    'company_id' => $company->id,
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+
+            Invoice::factory()
+                ->count($approvedCount)
+                ->withLineItems()
+                ->approved()
+                ->create([
+                    'company_id' => $company->id,
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+
+            Invoice::factory()
+                ->count($paidCount)
+                ->withLineItems()
+                ->withPayments(max: 4)
+                ->create([
+                    'company_id' => $company->id,
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+
+            Invoice::factory()
+                ->count($partialCount)
+                ->withLineItems()
+                ->withPayments(max: 4, invoiceStatus: InvoiceStatus::Partial)
+                ->create([
+                    'company_id' => $company->id,
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+
+            Invoice::factory()
+                ->count($overpaidCount)
+                ->withLineItems()
+                ->withPayments(max: 4, invoiceStatus: InvoiceStatus::Overpaid)
+                ->create([
+                    'company_id' => $company->id,
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+        });
+    }
 }

database/seeders/DatabaseSeeder.php

                     ->withTransactions()
                     ->withOfferings()
                     ->withClients()
-                    ->withVendors();
+                    ->withVendors()
+                    ->withInvoices(50);
             })
             ->create([
                 'name' => 'Admin',