wip RecordPayments.php

app/Enums/Accounting/InvoiceStatus.php

@@ -46,4 +46,22 @@ enum InvoiceStatus: string implements HasColor, HasLabel
             self::Unsent,
         ];
     }
+
+    public static function unpaidStatuses(): array
+    {
+        return [
+            self::Unsent,
+            self::Sent,
+            self::Viewed,
+            self::Partial,
+            self::Overdue,
+        ];
+    }
+
+    public static function getUnpaidOptions(): array
+    {
+        return collect(self::unpaidStatuses())
+            ->mapWithKeys(fn (self $case) => [$case->value => $case->getLabel()])
+            ->toArray();
+    }
 }

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

@@ -743,6 +743,7 @@ class InvoiceResource extends Resource
     {
         return [
             'index' => Pages\ListInvoices::route('/'),
+            'record-payments' => Pages\RecordPayments::route('/record-payments'),
             'create' => Pages\CreateInvoice::route('/create'),
             'view' => Pages\ViewInvoice::route('/{record}'),
             'edit' => Pages\EditInvoice::route('/{record}/edit'),

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

@@ -0,0 +1,361 @@
+<?php
+
+namespace App\Filament\Company\Resources\Sales\InvoiceResource\Pages;
+
+use App\Enums\Accounting\InvoiceStatus;
+use App\Enums\Accounting\PaymentMethod;
+use App\Filament\Company\Resources\Sales\InvoiceResource;
+use App\Filament\Tables\Columns\CustomTextInputColumn;
+use App\Models\Accounting\Invoice;
+use App\Models\Accounting\Transaction;
+use App\Models\Banking\BankAccount;
+use App\Models\Common\Client;
+use App\Models\Setting\Currency;
+use App\Utilities\Currency\CurrencyAccessor;
+use App\Utilities\Currency\CurrencyConverter;
+use Filament\Actions;
+use Filament\Forms;
+use Filament\Forms\Form;
+use Filament\Notifications\Notification;
+use Filament\Resources\Pages\ListRecords;
+use Filament\Support\RawJs;
+use Filament\Tables;
+use Filament\Tables\Columns\Summarizers\Summarizer;
+use Filament\Tables\Columns\TextColumn;
+use Filament\Tables\Table;
+use Illuminate\Contracts\Support\Htmlable;
+use Illuminate\Database\Eloquent\Collection;
+use Illuminate\Database\Query\Builder;
+use Illuminate\Support\Str;
+use Livewire\Attributes\Computed;
+
+/**
+ * @property Form $form
+ */
+class RecordPayments extends ListRecords
+{
+    protected static string $resource = InvoiceResource::class;
+
+    protected static string $view = 'filament.company.resources.sales.invoice-resource.pages.record-payments';
+
+    public array $paymentAmounts = [];
+
+    public ?array $data = [];
+
+    public function getBreadcrumb(): ?string
+    {
+        return 'Record Payments';
+    }
+
+    public function getTitle(): string | Htmlable
+    {
+        return 'Record Payments';
+    }
+
+    public function mount(): void
+    {
+        parent::mount();
+
+        $this->form->fill();
+
+        $this->reset('tableFilters');
+    }
+
+    protected function getHeaderActions(): array
+    {
+        return [
+            Actions\Action::make('processPayments')
+                ->color('primary')
+                ->action(function () {
+                    $data = $this->data;
+                    $tableRecords = $this->getTableRecords();
+                    $paidCount = 0;
+                    $totalPaid = 0;
+
+                    /** @var Invoice $invoice */
+                    foreach ($tableRecords as $invoice) {
+                        if (! $invoice->canRecordPayment()) {
+                            continue;
+                        }
+
+                        // Get the payment amount from our component state
+                        $paymentAmount = $this->getPaymentAmount($invoice);
+
+                        if ($paymentAmount <= 0) {
+                            continue;
+                        }
+
+                        $paymentData = [
+                            'posted_at' => $data['posted_at'],
+                            'payment_method' => $data['payment_method'],
+                            'bank_account_id' => $data['bank_account_id'],
+                            'amount' => $paymentAmount,
+                        ];
+
+                        $invoice->recordPayment($paymentData);
+                        $paidCount++;
+                        $totalPaid += $paymentAmount;
+                    }
+
+                    $currencyCode = $this->getTableFilterState('currency_code')['value'];
+                    $totalFormatted = CurrencyConverter::formatCentsToMoney($totalPaid, $currencyCode, true);
+
+                    Notification::make()
+                        ->title('Payments recorded successfully')
+                        ->body("Recorded {$paidCount} " . Str::plural('payment', $paidCount) . " for a total of {$totalFormatted}")
+                        ->success()
+                        ->send();
+
+                    $this->reset('paymentAmounts');
+
+                    $this->resetTable();
+                }),
+        ];
+    }
+
+    /**
+     * @return array<int | string, string | Form>
+     */
+    protected function getForms(): array
+    {
+        return [
+            'form',
+        ];
+    }
+
+    public function form(Form $form): Form
+    {
+        return $form
+            ->live()
+            ->schema([
+                Forms\Components\Grid::make(3)
+                    ->schema([
+                        Forms\Components\Select::make('bank_account_id')
+                            ->label('Account')
+                            ->options(static function () {
+                                return Transaction::getBankAccountOptionsFlat();
+                            })
+                            ->default(fn () => BankAccount::where('enabled', true)->first()?->id)
+                            ->selectablePlaceholder(false)
+                            ->searchable()
+                            ->softRequired(),
+                        Forms\Components\DatePicker::make('posted_at')
+                            ->label('Date')
+                            ->default(now())
+                            ->softRequired(),
+                        Forms\Components\Select::make('payment_method')
+                            ->label('Payment method')
+                            ->selectablePlaceholder(false)
+                            ->options(PaymentMethod::class)
+                            ->default(PaymentMethod::BankPayment)
+                            ->softRequired(),
+                    ]),
+            ])->statePath('data');
+    }
+
+    public function table(Table $table): Table
+    {
+        return $table
+            ->query(
+                Invoice::query()
+                    ->with(['client'])
+                    ->unpaid()
+            )
+            ->recordClasses(['is-spreadsheet'])
+            ->defaultSort('due_date')
+            ->paginated(false)
+            ->columns([
+                TextColumn::make('client.name')
+                    ->label('Client')
+                    ->sortable(),
+                TextColumn::make('invoice_number')
+                    ->label('Invoice number')
+                    ->sortable(),
+                TextColumn::make('due_date')
+                    ->label('Due date')
+                    ->defaultDateFormat()
+                    ->sortable(),
+                Tables\Columns\TextColumn::make('status')
+                    ->badge()
+                    ->sortable(),
+                TextColumn::make('amount_due')
+                    ->label('Amount due')
+                    ->currency(static fn (Invoice $record) => $record->currency_code)
+                    ->alignEnd()
+                    ->sortable()
+                    ->summarize([
+                        Summarizer::make()
+                            ->using(function (Builder $query) {
+                                $totalAmountDue = $query->sum('amount_due');
+                                $bankAccountCurrency = $this->getSelectedBankAccount()->account->currency_code;
+                                $activeCurrency = $this->getTableFilterState('currency_code')['value'] ?? $bankAccountCurrency;
+
+                                if ($activeCurrency !== $bankAccountCurrency) {
+                                    $totalAmountDue = CurrencyConverter::convertBalance($totalAmountDue, $activeCurrency, $bankAccountCurrency);
+                                }
+
+                                return CurrencyConverter::formatCentsToMoney($totalAmountDue, $bankAccountCurrency, true);
+                            }),
+                        Summarizer::make()
+                            ->using(function (Builder $query) {
+                                $totalAmountDue = $query->sum('amount_due');
+                                $currencyCode = $this->getTableFilterState('currency_code')['value'];
+
+                                return CurrencyConverter::formatCentsToMoney($totalAmountDue, $currencyCode, true);
+                            })
+                            ->visible(function () {
+                                $activeCurrency = $this->getTableFilterState('currency_code')['value'] ?? null;
+                                $bankAccountCurrency = $this->getSelectedBankAccount()->account->currency_code;
+
+                                return $activeCurrency && $activeCurrency !== $bankAccountCurrency;
+                            }),
+                    ]),
+                CustomTextInputColumn::make('payment_amount')
+                    ->label('Payment amount')
+                    ->alignEnd()
+                    ->navigable()
+                    ->mask(RawJs::make('$money($input)'))
+                    ->updateStateUsing(function (Invoice $record, $state) {
+                        if (! CurrencyConverter::isValidAmount($state, 'USD')) {
+                            $this->paymentAmounts[$record->id] = 0;
+
+                            return '0.00';
+                        }
+
+                        $paymentCents = CurrencyConverter::convertToCents($state, 'USD');
+
+                        if ($paymentCents > $record->amount_due) {
+                            $paymentCents = $record->amount_due;
+                        }
+
+                        $this->paymentAmounts[$record->id] = $paymentCents;
+
+                        return $state;
+                    })
+                    ->getStateUsing(function (Invoice $record) {
+                        $paymentAmount = $this->paymentAmounts[$record->id] ?? 0;
+
+                        return CurrencyConverter::convertCentsToFormatSimple($paymentAmount, 'USD');
+                    })
+                    ->summarize([
+                        Summarizer::make()
+                            ->using(function () {
+                                $total = array_sum($this->paymentAmounts);
+                                $defaultCurrency = CurrencyAccessor::getDefaultCurrency();
+                                $activeCurrency = $this->getTableFilterState('currency_code')['value'] ?? $defaultCurrency;
+
+                                if ($activeCurrency !== $defaultCurrency) {
+                                    $total = CurrencyConverter::convertBalance($total, $activeCurrency, $defaultCurrency);
+                                }
+
+                                return CurrencyConverter::formatCentsToMoney($total, $defaultCurrency, true);
+                            }),
+                        Summarizer::make()
+                            ->using(fn () => $this->totalPaymentAmount)
+                            ->visible(function () {
+                                $activeCurrency = $this->getTableFilterState('currency_code')['value'] ?? null;
+                                $defaultCurrency = CurrencyAccessor::getDefaultCurrency();
+
+                                return $activeCurrency && $activeCurrency !== $defaultCurrency;
+                            }),
+                    ]),
+            ])
+            ->bulkActions([
+                Tables\Actions\BulkAction::make('setFullAmounts')
+                    ->label('Set full amounts')
+                    ->icon('heroicon-o-banknotes')
+                    ->color('primary')
+                    ->deselectRecordsAfterCompletion()
+                    ->action(function (Collection $records) {
+                        $records->each(function (Invoice $invoice) {
+                            $this->paymentAmounts[$invoice->id] = $invoice->amount_due;
+                        });
+                    }),
+                Tables\Actions\BulkAction::make('clearAmounts')
+                    ->label('Clear amounts')
+                    ->icon('heroicon-o-x-mark')
+                    ->color('gray')
+                    ->deselectRecordsAfterCompletion()
+                    ->action(function (Collection $records) {
+                        $records->each(function (Invoice $invoice) {
+                            $this->paymentAmounts[$invoice->id] = 0;
+                        });
+                    }),
+            ])
+            ->filters([
+                Tables\Filters\SelectFilter::make('currency_code')
+                    ->label('Currency')
+                    ->selectablePlaceholder(false)
+                    ->default(CurrencyAccessor::getDefaultCurrency())
+                    ->options(Currency::query()->pluck('name', 'code')->toArray())
+                    ->searchable()
+                    ->resetState([
+                        'value' => CurrencyAccessor::getDefaultCurrency(),
+                    ])
+                    ->indicateUsing(function (Tables\Filters\SelectFilter $filter, array $state) {
+                        if (blank($state['value'] ?? null)) {
+                            return [];
+                        }
+
+                        $label = collect($filter->getOptions())
+                            ->mapWithKeys(fn (string | array $label, string $value): array => is_array($label) ? $label : [$value => $label])
+                            ->get($state['value']);
+
+                        if (blank($label)) {
+                            return [];
+                        }
+
+                        $indicator = $filter->getLabel();
+
+                        return Tables\Filters\Indicator::make("{$indicator}: {$label}")->removable(false);
+                    }),
+                Tables\Filters\SelectFilter::make('client_id')
+                    ->label('Client')
+                    ->options(fn () => Client::query()->pluck('name', 'id')->toArray())
+                    ->searchable()
+                    ->default(function () {
+                        // TODO: This needs to be applied through the url with a query parameter, it shouldn't be able to be removed though
+                        $clientCount = Client::count();
+
+                        return $clientCount === 1 ? Client::first()?->id : null;
+                    }),
+                Tables\Filters\SelectFilter::make('status')
+                    ->multiple()
+                    ->options(InvoiceStatus::getUnpaidOptions()),
+            ]);
+    }
+
+    protected function getPaymentAmount(Invoice $record): int
+    {
+        return $this->paymentAmounts[$record->id] ?? 0;
+    }
+
+    #[Computed]
+    public function totalPaymentAmount(): string
+    {
+        $total = array_sum($this->paymentAmounts);
+
+        $currencyCode = $this->getTableFilterState('currency_code')['value'];
+
+        return CurrencyConverter::formatCentsToMoney($total, $currencyCode, true);
+    }
+
+    public function getSelectedBankAccount(): BankAccount
+    {
+        $bankAccountId = $this->data['bank_account_id'];
+
+        $bankAccount = BankAccount::find($bankAccountId);
+
+        return $bankAccount ?: BankAccount::where('enabled', true)->first();
+    }
+
+    protected function handleTableFilterUpdates(): void
+    {
+        parent::handleTableFilterUpdates();
+
+        $visibleInvoiceIds = $this->getTableRecords()->pluck('id')->toArray();
+        $visibleInvoiceKeys = array_flip($visibleInvoiceIds);
+
+        $this->paymentAmounts = array_intersect_key($this->paymentAmounts, $visibleInvoiceKeys);
+    }
+}

app/Models/Accounting/Invoice.php

@@ -183,12 +183,7 @@ class Invoice extends Document
 
     public function scopeUnpaid(Builder $query): Builder
     {
-        return $query->whereNotIn('status', [
-            InvoiceStatus::Paid,
-            InvoiceStatus::Void,
-            InvoiceStatus::Draft,
-            InvoiceStatus::Overpaid,
-        ]);
+        return $query->whereIn('status', InvoiceStatus::unpaidStatuses());
     }
 
     public function scopeOverdue(Builder $query): Builder

resources/views/filament/company/resources/sales/invoice-resource/pages/record-payments.blade.php

@@ -0,0 +1,30 @@
+<x-filament-panels::page
+    @class([
+        'fi-resource-list-records-page',
+        'fi-resource-' . str_replace('/', '-', $this->getResource()::getSlug()),
+    ])
+>
+    <div class="flex flex-col gap-y-6">
+        <x-filament::section>
+            <div class="flex items-center justify-between">
+                <div>
+                    {{ $this->form }}
+                </div>
+                <div class="text-right">
+                    <div class="text-xs font-medium text-gray-500 dark:text-gray-400">
+                        Total Payment Amount
+                    </div>
+                    <div class="text-3xl font-bold text-gray-900 dark:text-white tabular-nums">{{ $this->totalPaymentAmount }}</div>
+                </div>
+            </div>
+        </x-filament::section>
+
+        <x-filament-panels::resources.tabs />
+
+        {{ \Filament\Support\Facades\FilamentView::renderHook(\Filament\View\PanelsRenderHook::RESOURCE_PAGES_LIST_RECORDS_TABLE_BEFORE, scopes: $this->getRenderHookScopes()) }}
+
+        {{ $this->table }}
+
+        {{ \Filament\Support\Facades\FilamentView::renderHook(\Filament\View\PanelsRenderHook::RESOURCE_PAGES_LIST_RECORDS_TABLE_AFTER, scopes: $this->getRenderHookScopes()) }}
+    </div>
+</x-filament-panels::page>