wip

app/Filament/Company/Resources/Purchases/BillResource/Pages/PayBills.php

         return [
             Actions\Action::make('processPayments')
                 ->color('primary')
+                ->requiresConfirmation()
+                ->modalHeading('Confirm payments')
+                ->modalDescription(function () {
+                    $billCount = collect($this->paymentAmounts)->filter(fn ($amount) => $amount > 0)->count();
+                    $totalAmount = array_sum($this->paymentAmounts);
+                    $currencyCode = $this->getTableFilterState('currency_code')['value'];
+                    $totalFormatted = CurrencyConverter::formatCentsToMoney($totalAmount, $currencyCode, true);
+
+                    return "You are about to pay {$billCount} " . Str::plural('bill', $billCount) . " for a total of {$totalFormatted}. This action cannot be undone.";
+                })
                 ->action(function () {
                     $data = $this->data;
                     $tableRecords = $this->getTableRecords();

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

 use App\Filament\Company\Resources\Sales\InvoiceResource;
 use App\Filament\Company\Resources\Sales\InvoiceResource\Widgets;
 use App\Filament\Company\Resources\Sales\RecurringInvoiceResource\Pages\ViewRecurringInvoice;
+use App\Filament\Infolists\Components\BannerEntry;
 use App\Models\Accounting\RecurringInvoice;
-use CodeWithDennis\SimpleAlert\Components\Infolists\SimpleAlert;
 use Filament\Actions;
 use Filament\Infolists\Components\Actions\Action;
 use Filament\Infolists\Infolist;
     {
         return $infolist
             ->schema([
-                SimpleAlert::make('recurringInvoiceFilter')
+                BannerEntry::make('recurringInvoiceFilter')
                     ->info()
                     ->title(function () {
                         if (empty($this->recurringInvoice)) {

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

 
     public ?array $data = [];
 
-    // New property for allocation amount
     public ?int $allocationAmount = null;
 
     #[Url(as: 'invoice_id')]
         return [
             Actions\Action::make('processPayments')
                 ->color('primary')
+                ->requiresConfirmation()
+                ->modalHeading('Confirm payments')
+                ->modalDescription(function () {
+                    $invoiceCount = collect($this->paymentAmounts)->filter(fn ($amount) => $amount > 0)->count();
+                    $totalAmount = array_sum($this->paymentAmounts);
+                    $currencyCode = $this->getTableFilterState('currency_code')['value'];
+                    $totalFormatted = CurrencyConverter::formatCentsToMoney($totalAmount, $currencyCode, true);
+
+                    return "You are about to pay {$invoiceCount} " . Str::plural('invoice', $invoiceCount) . " for a total of {$totalFormatted}. This action cannot be undone.";
+                })
                 ->action(function () {
                     $data = $this->data;
                     $tableRecords = $this->getTableRecords();
                             ->options(PaymentMethod::class)
                             ->default(PaymentMethod::BankPayment)
                             ->softRequired(),
-                        // Allocation amount field with suffix action
                         Forms\Components\TextInput::make('allocation_amount')
                             ->label('Allocate Payment Amount')
-                            ->live()
                             ->default(array_sum($this->paymentAmounts))
                             ->money($this->getTableFilterState('currency_code')['value'])
+                            ->extraAlpineAttributes([
+                                'x-on:keydown.enter.prevent' => '$refs.allocate.click()',
+                            ])
                             ->suffixAction(
                                 Forms\Components\Actions\Action::make('allocate')
                                     ->icon('heroicon-m-calculator')
+                                    ->extraAttributes([
+                                        'x-ref' => 'allocate',
+                                    ])
                                     ->action(function ($state) {
                                         $this->allocationAmount = CurrencyConverter::convertToCents($state, 'USD');
                                         if ($this->allocationAmount && $this->hasSelectedClient()) {
                                             $this->allocateOldestFirst($this->getTableRecords(), $this->allocationAmount);
-
-                                            $amountFormatted = CurrencyConverter::formatCentsToMoney($this->allocationAmount, 'USD', true);
-
-                                            Notification::make()
-                                                ->title('Payment allocated')
-                                                ->body("Allocated {$amountFormatted} across invoices")
-                                                ->success()
-                                                ->send();
                                         }
-                                    })
+                                    }),
                             ),
                     ]),
             ])->statePath('data');
             ->recordClasses(['is-spreadsheet'])
             ->defaultSort('due_date')
             ->paginated(false)
+            ->emptyStateHeading('No client selected')
+            ->emptyStateDescription('Select a client from the filters above to view and process invoice payments.')
             ->columns([
                 TextColumn::make('client.name')
                     ->label('Client')
                                 return $activeCurrency && $activeCurrency !== $bankAccountCurrency;
                             }),
                     ]),
-                // New allocation status column
-                TextColumn::make('allocation_status')
-                    ->label('Status')
-                    ->getStateUsing(function (Invoice $record) {
-                        $paymentAmount = $this->paymentAmounts[$record->id] ?? 0;
-
-                        if ($paymentAmount <= 0) {
-                            return 'No payment';
-                        }
-
-                        if ($paymentAmount >= $record->amount_due) {
-                            return 'Full payment';
-                        }
-
-                        return 'Partial payment';
-                    })
-                    ->badge()
-                    ->color(fn (string $state): string => match ($state) {
-                        'Full payment' => 'success',
-                        'Partial payment' => 'warning',
-                        default => 'gray',
-                    }),
             ])
             ->bulkActions([
                 Tables\Actions\BulkAction::make('setFullAmounts')
 
                         return $query->where('client_id', $data['value']);
                     }),
+                Tables\Filters\Filter::make('invoice_lookup')
+                    ->label('Find Invoice')
+                    ->form([
+                        Forms\Components\TextInput::make('invoice_number')
+                            ->label('Invoice Number')
+                            ->placeholder('Enter invoice number')
+                            ->suffixAction(
+                                Forms\Components\Actions\Action::make('findInvoice')
+                                    ->icon('heroicon-m-magnifying-glass')
+                                    ->keyBindings(['enter'])
+                                    ->action(function ($state, Forms\Set $set) {
+                                        if (blank($state)) {
+                                            return;
+                                        }
+
+                                        $invoice = Invoice::byNumber($state)
+                                            ->unpaid()
+                                            ->first();
+
+                                        if ($invoice) {
+                                            $set('tableFilters.client_id.value', $invoice->client_id, true);
+                                            $this->paymentAmounts[$invoice->id] = $invoice->amount_due;
+
+                                            Notification::make()
+                                                ->title('Invoice found')
+                                                ->body("Found invoice {$invoice->invoice_number} for {$invoice->client->name}")
+                                                ->success()
+                                                ->send();
+                                        } else {
+                                            Notification::make()
+                                                ->title('Invoice not found')
+                                                ->body("No unpaid invoice found with number: {$state}")
+                                                ->warning()
+                                                ->send();
+                                        }
+                                    })
+                            ),
+                    ])
+                    ->query(null)
+                    ->indicateUsing(null),
                 Tables\Filters\SelectFilter::make('status')
                     ->multiple()
                     ->options(InvoiceStatus::getUnpaidOptions()),
         return CurrencyConverter::formatCentsToMoney($total, $currencyCode, true);
     }
 
-    #[Computed]
-    public function allocationVariance(): string
-    {
-        if (! $this->allocationAmount) {
-            return '$0.00';
-        }
-
-        $totalAllocated = array_sum($this->paymentAmounts);
-        $variance = $this->allocationAmount - $totalAllocated;
-
-        $currencyCode = $this->getTableFilterState('currency_code')['value'];
-
-        return CurrencyConverter::formatCentsToMoney($variance, $currencyCode, true);
-    }
-
     public function getSelectedBankAccount(): BankAccount
     {
         $bankAccountId = $this->data['bank_account_id'];
         $visibleInvoiceKeys = array_flip($visibleInvoiceIds);
 
         $this->paymentAmounts = array_intersect_key($this->paymentAmounts, $visibleInvoiceKeys);
-
-        // Reset allocation when client changes
         $this->allocationAmount = null;
     }
 }

app/Models/Accounting/Invoice.php

         return $query->whereIn('status', InvoiceStatus::unpaidStatuses());
     }
 
+    // TODO: Consider storing the numeric part of the invoice number separately
+    public function scopeByNumber(Builder $query, string $number): Builder
+    {
+        $invoicePrefix = DocumentDefault::invoice()->first()->number_prefix ?? '';
+
+        return $query->where(function ($q) use ($number, $invoicePrefix) {
+            $q->where('invoice_number', $number)
+                ->orWhere('invoice_number', $invoicePrefix . $number);
+        });
+    }
+
     public function scopeOverdue(Builder $query): Builder
     {
         return $query

app/Models/Setting/DocumentDefault.php

 
     public function scopeType(Builder $query, string | DocumentType $type): Builder
     {
-        return $query->where($this->qualifyColumn('type'), $type);
+        return $query->where('type', $type);
     }
 
     public function scopeInvoice(Builder $query): Builder

app/Providers/Filament/CompanyPanelProvider.php

             $table
                 ->paginationPageOptions([5, 10, 25, 50, 100])
                 ->filtersFormWidth(MaxWidth::Small)
-                ->filtersTriggerAction(fn (Tables\Actions\Action $action) => $action->slideOver());
+                ->filtersTriggerAction(
+                    fn (Tables\Actions\Action $action) => $action
+                        ->button()
+                        ->label('Filters')
+                        ->slideOver()
+                );
         });
 
         Tables\Columns\TextColumn::configureUsing(function (Tables\Columns\TextColumn $column): void {