Merge pull request #88 from andrewdwallo/development-3.x

Development 3.x

app/Casts/RateCast.php

 
 namespace App\Casts;
 
-use App\Enums\Setting\NumberFormat;
-use App\Models\Setting\Localization;
+use App\Enums\Accounting\AdjustmentComputation;
 use App\Utilities\Currency\CurrencyAccessor;
+use App\Utilities\RateCalculator;
 use Illuminate\Contracts\Database\Eloquent\CastsAttributes;
 use Illuminate\Database\Eloquent\Model;
 
 class RateCast implements CastsAttributes
 {
-    private const PRECISION = 4;
-
     public function get($model, string $key, $value, array $attributes): string
     {
+        if (! $value) {
+            return '0';
+        }
+
         $currency_code = $this->getDefaultCurrencyCode();
-        $computation = $attributes['computation'] ?? null;
+        $computation = AdjustmentComputation::parse($attributes['computation'] ?? $attributes['discount_computation'] ?? null);
 
-        if ($computation === 'fixed') {
+        if ($computation?->isFixed()) {
             return money($value, $currency_code)->formatSimple();
         }
 
-        $floatValue = $value / (10 ** self::PRECISION);
-
-        $format = Localization::firstOrFail()->number_format->value;
-        [$decimal_mark, $thousands_separator] = NumberFormat::from($format)->getFormattingParameters();
-
-        return $this->formatWithoutTrailingZeros($floatValue, $decimal_mark, $thousands_separator);
+        return RateCalculator::formatScaledRate($value);
     }
 
     public function set(Model $model, string $key, mixed $value, array $attributes): int
     {
+        if (! $value) {
+            return 0;
+        }
+
         if (is_int($value)) {
             return $value;
         }
 
-        $computation = $attributes['computation'] ?? null;
+        $computation = AdjustmentComputation::parse($attributes['computation'] ?? $attributes['discount_computation'] ?? null);
 
         $currency_code = $this->getDefaultCurrencyCode();
 
-        if ($computation === 'fixed') {
+        if ($computation?->isFixed()) {
             return money($value, $currency_code, true)->getAmount();
         }
 
-        $format = Localization::firstOrFail()->number_format->value;
-        [$decimal_mark, $thousands_separator] = NumberFormat::from($format)->getFormattingParameters();
-
-        $intValue = str_replace([$thousands_separator, $decimal_mark], ['', '.'], $value);
-
-        return (int) round((float) $intValue * (10 ** self::PRECISION));
+        return RateCalculator::parseLocalizedRate($value);
     }
 
     private function getDefaultCurrencyCode(): string
     {
         return CurrencyAccessor::getDefaultCurrency();
     }
-
-    private function formatWithoutTrailingZeros($floatValue, $decimal_mark, $thousands_separator): string
-    {
-        $formatted = number_format($floatValue, self::PRECISION, $decimal_mark, $thousands_separator);
-        $formatted = rtrim($formatted, '0');
-
-        return rtrim($formatted, $decimal_mark);
-    }
 }

app/Collections/Accounting/DocumentCollection.php

+<?php
+
+namespace App\Collections\Accounting;
+
+use App\Utilities\Currency\CurrencyAccessor;
+use App\Utilities\Currency\CurrencyConverter;
+use Illuminate\Database\Eloquent\Collection;
+
+class DocumentCollection extends Collection
+{
+    public function sumMoneyInCents(string $column): int
+    {
+        return $this->reduce(static function ($carry, $document) use ($column) {
+            return $carry + $document->getRawOriginal($column);
+        }, 0);
+    }
+
+    public function sumMoneyFormattedSimple(string $column, ?string $currency = null): string
+    {
+        $currency ??= CurrencyAccessor::getDefaultCurrency();
+
+        $totalCents = $this->sumMoneyInCents($column);
+
+        return CurrencyConverter::convertCentsToFormatSimple($totalCents, $currency);
+    }
+
+    public function sumMoneyFormatted(string $column, ?string $currency = null): string
+    {
+        $currency ??= CurrencyAccessor::getDefaultCurrency();
+
+        $totalCents = $this->sumMoneyInCents($column);
+
+        return CurrencyConverter::formatCentsToMoney($totalCents, $currency);
+    }
+
+    public function sumMoneyInDefaultCurrency(string $column): int
+    {
+        $defaultCurrency = CurrencyAccessor::getDefaultCurrency();
+
+        return $this->reduce(static function ($carry, $document) use ($column, $defaultCurrency) {
+            $amountInCents = $document->getRawOriginal($column);
+            $documentCurrency = $document->currency_code ?? $defaultCurrency;
+
+            if ($documentCurrency !== $defaultCurrency) {
+                $amountInCents = CurrencyConverter::convertBalance(
+                    $amountInCents,
+                    $documentCurrency,
+                    $defaultCurrency
+                );
+            }
+
+            return $carry + $amountInCents;
+        }, 0);
+    }
+}

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);
-    }
-
-    public function sumMoneyFormatted(string $column, ?string $currency = null): string
-    {
-        $currency ??= CurrencyAccessor::getDefaultCurrency();
-
-        $totalCents = $this->sumMoneyInCents($column);
-
-        return CurrencyConverter::formatCentsToMoney($totalCents, $currency);
-    }
-}

app/Concerns/ManagesLineItems.php

 use App\Enums\Accounting\DocumentDiscountMethod;
 use App\Models\Accounting\Bill;
 use App\Models\Accounting\DocumentLineItem;
+use App\Utilities\Currency\CurrencyAccessor;
 use App\Utilities\Currency\CurrencyConverter;
+use App\Utilities\RateCalculator;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Collection;
 
 
     protected function updateDocumentTotals(Model $record, array $data): array
     {
+        $currencyCode = $data['currency_code'] ?? CurrencyAccessor::getDefaultCurrency();
         $subtotalCents = $record->lineItems()->sum('subtotal');
         $taxTotalCents = $record->lineItems()->sum('tax_total');
         $discountTotalCents = $this->calculateDiscountTotal(
             AdjustmentComputation::parse($data['discount_computation']),
             $data['discount_rate'] ?? null,
             $subtotalCents,
-            $record
+            $record,
+            $currencyCode,
         );
 
         $grandTotalCents = $subtotalCents + $taxTotalCents - $discountTotalCents;
 
         return [
-            'subtotal' => CurrencyConverter::convertCentsToFormatSimple($subtotalCents),
-            'tax_total' => CurrencyConverter::convertCentsToFormatSimple($taxTotalCents),
-            'discount_total' => CurrencyConverter::convertCentsToFormatSimple($discountTotalCents),
-            'total' => CurrencyConverter::convertCentsToFormatSimple($grandTotalCents),
+            'subtotal' => CurrencyConverter::convertCentsToFormatSimple($subtotalCents, $currencyCode),
+            'tax_total' => CurrencyConverter::convertCentsToFormatSimple($taxTotalCents, $currencyCode),
+            'discount_total' => CurrencyConverter::convertCentsToFormatSimple($discountTotalCents, $currencyCode),
+            'total' => CurrencyConverter::convertCentsToFormatSimple($grandTotalCents, $currencyCode),
         ];
     }
 
         ?AdjustmentComputation $discountComputation,
         ?string $discountRate,
         int $subtotalCents,
-        Model $record
+        Model $record,
+        string $currencyCode
     ): int {
         if ($discountMethod->isPerLineItem()) {
             return $record->lineItems()->sum('discount_total');
         }
 
         if ($discountComputation?->isPercentage()) {
-            return (int) ($subtotalCents * ((float) $discountRate / 100));
+            $scaledRate = RateCalculator::parseLocalizedRate($discountRate);
+
+            return RateCalculator::calculatePercentage($subtotalCents, $scaledRate);
         }
 
-        return CurrencyConverter::convertToCents($discountRate);
+        return CurrencyConverter::convertToCents($discountRate, $currencyCode);
     }
 }

app/Enums/Accounting/DocumentType.php

+<?php
+
+namespace App\Enums\Accounting;
+
+use Filament\Support\Contracts\HasIcon;
+use Filament\Support\Contracts\HasLabel;
+
+enum DocumentType: string implements HasIcon, HasLabel
+{
+    case Invoice = 'invoice';
+    case Bill = 'bill';
+    // TODO: Add estimate
+    // case Estimate = 'estimate';
+
+    public const DEFAULT = self::Invoice->value;
+
+    public function getLabel(): ?string
+    {
+        return $this->name;
+    }
+
+    public function getIcon(): ?string
+    {
+        return match ($this->value) {
+            self::Invoice->value => 'heroicon-o-document-duplicate',
+            self::Bill->value => 'heroicon-o-clipboard-document-list',
+        };
+    }
+
+    public function getTaxKey(): string
+    {
+        return match ($this) {
+            self::Invoice => 'salesTaxes',
+            self::Bill => 'purchaseTaxes',
+        };
+    }
+
+    public function getDiscountKey(): string
+    {
+        return match ($this) {
+            self::Invoice => 'salesDiscounts',
+            self::Bill => 'purchaseDiscounts',
+        };
+    }
+}

app/Filament/Company/Pages/Accounting/Transactions.php

                         }
                     )
                     ->sortable()
-                    ->currency(static fn (Transaction $transaction) => $transaction->bankAccount?->account->currency_code ?? CurrencyAccessor::getDefaultCurrency(), true),
+                    ->currency(static fn (Transaction $transaction) => $transaction->bankAccount?->account->currency_code),
             ])
             ->recordClasses(static fn (Transaction $transaction) => $transaction->reviewed ? 'bg-primary-300/10' : null)
             ->defaultSort('posted_at', 'desc')

app/Filament/Company/Resources/Banking/AccountResource.php

                                     ->localizeLabel()
                                     ->required(),
                                 CreateCurrencySelect::make('currency_code')
-                                    ->disabledOn('edit')
-                                    ->relationship('currency', 'name'),
+                                    ->disabledOn('edit'),
                             ]),
                         Forms\Components\Group::make()
                             ->columns()

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

 
 use App\Enums\Accounting\BillStatus;
 use App\Enums\Accounting\DocumentDiscountMethod;
+use App\Enums\Accounting\DocumentType;
 use App\Enums\Accounting\PaymentMethod;
 use App\Filament\Company\Resources\Purchases\BillResource\Pages;
-use App\Filament\Forms\Components\BillTotals;
+use App\Filament\Forms\Components\CreateCurrencySelect;
+use App\Filament\Forms\Components\DocumentTotals;
 use App\Filament\Tables\Actions\ReplicateBulkAction;
 use App\Filament\Tables\Filters\DateRangeFilter;
 use App\Models\Accounting\Adjustment;
 use App\Models\Accounting\Bill;
 use App\Models\Banking\BankAccount;
 use App\Models\Common\Offering;
+use App\Models\Common\Vendor;
+use App\Utilities\Currency\CurrencyAccessor;
 use App\Utilities\Currency\CurrencyConverter;
+use App\Utilities\RateCalculator;
 use Awcodes\TableRepeater\Components\TableRepeater;
 use Awcodes\TableRepeater\Header;
 use Closure;
                                     ->relationship('vendor', 'name')
                                     ->preload()
                                     ->searchable()
-                                    ->required(),
+                                    ->required()
+                                    ->live()
+                                    ->afterStateUpdated(function (Forms\Set $set, Forms\Get $get, $state) {
+                                        if (! $state) {
+                                            return;
+                                        }
+
+                                        $currencyCode = Vendor::find($state)?->currency_code;
+
+                                        if ($currencyCode) {
+                                            $set('currency_code', $currencyCode);
+                                        }
+                                    }),
+                                CreateCurrencySelect::make('currency_code'),
                             ]),
                             Forms\Components\Group::make([
                                 Forms\Components\TextInput::make('bill_number')
                             })
                             ->schema([
                                 Forms\Components\Select::make('offering_id')
+                                    ->label('Item')
                                     ->relationship('purchasableOffering', 'name')
                                     ->preload()
                                     ->searchable()
                                     ->live()
                                     ->default(1),
                                 Forms\Components\TextInput::make('unit_price')
+                                    ->label('Price')
                                     ->hiddenLabel()
                                     ->numeric()
                                     ->live()
                                     ->default(0),
                                 Forms\Components\Select::make('purchaseTaxes')
+                                    ->label('Taxes')
                                     ->relationship('purchaseTaxes', 'name')
                                     ->saveRelationshipsUsing(null)
                                     ->dehydrated(true)
                                     ->live()
                                     ->searchable(),
                                 Forms\Components\Select::make('purchaseDiscounts')
+                                    ->label('Discounts')
                                     ->relationship('purchaseDiscounts', 'name')
                                     ->saveRelationshipsUsing(null)
                                     ->dehydrated(true)
                                     ->searchable(),
                                 Forms\Components\Placeholder::make('total')
                                     ->hiddenLabel()
+                                    ->extraAttributes(['class' => 'text-left sm:text-right'])
                                     ->content(function (Forms\Get $get) {
                                         $quantity = max((float) ($get('quantity') ?? 0), 0);
                                         $unitPrice = max((float) ($get('unit_price') ?? 0), 0);
                                         $purchaseTaxes = $get('purchaseTaxes') ?? [];
                                         $purchaseDiscounts = $get('purchaseDiscounts') ?? [];
+                                        $currencyCode = $get('../../currency_code') ?? CurrencyAccessor::getDefaultCurrency();
 
                                         $subtotal = $quantity * $unitPrice;
 
-                                        // Calculate tax amount based on subtotal
-                                        $taxAmount = 0;
-                                        if (! empty($purchaseTaxes)) {
-                                            $taxRates = Adjustment::whereIn('id', $purchaseTaxes)->pluck('rate');
-                                            $taxAmount = collect($taxRates)->sum(fn ($rate) => $subtotal * ($rate / 100));
-                                        }
-
-                                        // Calculate discount amount based on subtotal
-                                        $discountAmount = 0;
-                                        if (! empty($purchaseDiscounts)) {
-                                            $discountRates = Adjustment::whereIn('id', $purchaseDiscounts)->pluck('rate');
-                                            $discountAmount = collect($discountRates)->sum(fn ($rate) => $subtotal * ($rate / 100));
-                                        }
+                                        $subtotalInCents = CurrencyConverter::convertToCents($subtotal, $currencyCode);
+
+                                        $taxAmountInCents = Adjustment::whereIn('id', $purchaseTaxes)
+                                            ->get()
+                                            ->sum(function (Adjustment $adjustment) use ($subtotalInCents) {
+                                                if ($adjustment->computation->isPercentage()) {
+                                                    return RateCalculator::calculatePercentage($subtotalInCents, $adjustment->getRawOriginal('rate'));
+                                                } else {
+                                                    return $adjustment->getRawOriginal('rate');
+                                                }
+                                            });
+
+                                        $discountAmountInCents = Adjustment::whereIn('id', $purchaseDiscounts)
+                                            ->get()
+                                            ->sum(function (Adjustment $adjustment) use ($subtotalInCents) {
+                                                if ($adjustment->computation->isPercentage()) {
+                                                    return RateCalculator::calculatePercentage($subtotalInCents, $adjustment->getRawOriginal('rate'));
+                                                } else {
+                                                    return $adjustment->getRawOriginal('rate');
+                                                }
+                                            });
 
                                         // Final total
-                                        $total = $subtotal + ($taxAmount - $discountAmount);
+                                        $totalInCents = $subtotalInCents + ($taxAmountInCents - $discountAmountInCents);
 
-                                        return CurrencyConverter::formatToMoney($total);
+                                        return CurrencyConverter::formatCentsToMoney($totalInCents, $currencyCode);
                                     }),
                             ]),
-                        BillTotals::make(),
+                        DocumentTotals::make()
+                            ->type(DocumentType::Bill),
                     ]),
             ]);
     }
                 Tables\Columns\TextColumn::make('vendor.name')
                     ->sortable(),
                 Tables\Columns\TextColumn::make('total')
-                    ->currency()
-                    ->sortable(),
+                    ->currencyWithConversion(static fn (Bill $record) => $record->currency_code)
+                    ->sortable()
+                    ->toggleable(),
                 Tables\Columns\TextColumn::make('amount_paid')
                     ->label('Amount Paid')
-                    ->currency()
-                    ->sortable(),
+                    ->currencyWithConversion(static fn (Bill $record) => $record->currency_code)
+                    ->sortable()
+                    ->toggleable(),
                 Tables\Columns\TextColumn::make('amount_due')
                     ->label('Amount Due')
-                    ->currency()
+                    ->currencyWithConversion(static fn (Bill $record) => $record->currency_code)
                     ->sortable(),
             ])
             ->filters([
                             Forms\Components\TextInput::make('amount')
                                 ->label('Amount')
                                 ->required()
-                                ->money()
+                                ->money(fn (Bill $record) => $record->currency_code)
                                 ->live(onBlur: true)
                                 ->helperText(function (Bill $record, $state) {
-                                    if (! CurrencyConverter::isValidAmount($state)) {
+                                    $billCurrency = $record->currency_code;
+                                    if (! CurrencyConverter::isValidAmount($state, $billCurrency)) {
                                         return null;
                                     }
 
                                     $amountDue = $record->getRawOriginal('amount_due');
-                                    $amount = CurrencyConverter::convertToCents($state);
+                                    $amount = CurrencyConverter::convertToCents($state, $billCurrency);
 
                                     if ($amount <= 0) {
                                         return 'Please enter a valid positive amount';
                                     $newAmountDue = $amountDue - $amount;
 
                                     return match (true) {
-                                        $newAmountDue > 0 => 'Amount due after payment will be ' . CurrencyConverter::formatCentsToMoney($newAmountDue),
+                                        $newAmountDue > 0 => 'Amount due after payment will be ' . CurrencyConverter::formatCentsToMoney($newAmountDue, $billCurrency),
                                         $newAmountDue === 0 => 'Bill will be fully paid',
-                                        default => 'Amount exceeds bill total by ' . CurrencyConverter::formatCentsToMoney(abs($newAmountDue)),
+                                        default => 'Amount exceeds bill total by ' . CurrencyConverter::formatCentsToMoney(abs($newAmountDue), $billCurrency),
                                     };
                                 })
                                 ->rules([
-                                    static fn (): Closure => static function (string $attribute, $value, Closure $fail) {
-                                        if (! CurrencyConverter::isValidAmount($value)) {
+                                    static fn (Bill $record): Closure => static function (string $attribute, $value, Closure $fail) use ($record) {
+                                        if (! CurrencyConverter::isValidAmount($value, $record->currency_code)) {
                                             $fail('Please enter a valid amount');
                                         }
                                     },
                             if ($cantRecordPayments) {
                                 Notification::make()
                                     ->title('Payment Recording Failed')
-                                    ->body('Bills that are either paid or voided cannot be processed through bulk payments. Please adjust your selection and try again.')
+                                    ->body('Bills that are either paid, voided, or are in a foreign currency cannot be processed through bulk payments. Please adjust your selection and try again.')
                                     ->persistent()
                                     ->danger()
                                     ->send();

app/Filament/Company/Resources/Purchases/BillResource/Widgets/BillOverview.php

         $unpaidBills = $this->getPageTableQuery()
             ->whereIn('status', [BillStatus::Unpaid, BillStatus::Partial, BillStatus::Overdue]);
 
-        $amountToPay = $unpaidBills->sum('amount_due');
+        $amountToPay = $unpaidBills->get()->sumMoneyInDefaultCurrency('amount_due');
 
         $amountOverdue = $unpaidBills
             ->clone()
             ->where('status', BillStatus::Overdue)
-            ->sum('amount_due');
+            ->get()
+            ->sumMoneyInDefaultCurrency('amount_due');
 
         $amountDueWithin7Days = $unpaidBills
             ->clone()
             ->whereBetween('due_date', [today(), today()->addWeek()])
-            ->sum('amount_due');
+            ->get()
+            ->sumMoneyInDefaultCurrency('amount_due');
 
         $averagePaymentTime = $this->getPageTableQuery()
             ->whereNotNull('paid_at')
                 today()->subMonth()->startOfMonth(),
                 today()->subMonth()->endOfMonth(),
             ])
-            ->sum('amount_paid');
+            ->get()
+            ->sumMoneyInDefaultCurrency('amount_paid');
 
         return [
             EnhancedStatsOverviewWidget\EnhancedStat::make('Total To Pay', CurrencyConverter::formatCentsToMoney($amountToPay))

app/Filament/Company/Resources/Purchases/VendorResource.php

                                     ->default(VendorType::Regular)
                                     ->columnSpanFull(),
                                 CreateCurrencySelect::make('currency_code')
-                                    ->relationship('currency', 'name')
                                     ->nullable()
                                     ->visible(fn (Forms\Get $get) => VendorType::parse($get('type')) === VendorType::Regular),
                                 Forms\Components\Select::make('contractor_type')

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

                     ])->columns(1),
                 Forms\Components\Section::make('Billing')
                     ->schema([
-                        CreateCurrencySelect::make('currency_code')
-                            ->relationship('currency', 'name'),
+                        CreateCurrencySelect::make('currency_code'),
                         CustomSection::make('Billing Address')
                             ->relationship('billingAddress')
                             ->contained(false)

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

 
 namespace App\Filament\Company\Resources\Sales;
 
-use App\Collections\Accounting\InvoiceCollection;
+use App\Collections\Accounting\DocumentCollection;
 use App\Enums\Accounting\DocumentDiscountMethod;
+use App\Enums\Accounting\DocumentType;
 use App\Enums\Accounting\InvoiceStatus;
 use App\Enums\Accounting\PaymentMethod;
 use App\Filament\Company\Resources\Sales\InvoiceResource\Pages;
 use App\Filament\Company\Resources\Sales\InvoiceResource\RelationManagers;
 use App\Filament\Company\Resources\Sales\InvoiceResource\Widgets;
-use App\Filament\Forms\Components\InvoiceTotals;
+use App\Filament\Forms\Components\CreateCurrencySelect;
+use App\Filament\Forms\Components\DocumentTotals;
 use App\Filament\Tables\Actions\ReplicateBulkAction;
 use App\Filament\Tables\Filters\DateRangeFilter;
 use App\Models\Accounting\Adjustment;
 use App\Models\Accounting\Invoice;
 use App\Models\Banking\BankAccount;
+use App\Models\Common\Client;
 use App\Models\Common\Offering;
+use App\Utilities\Currency\CurrencyAccessor;
 use App\Utilities\Currency\CurrencyConverter;
+use App\Utilities\RateCalculator;
 use Awcodes\TableRepeater\Components\TableRepeater;
 use Awcodes\TableRepeater\Header;
 use Closure;
                                     ->relationship('client', 'name')
                                     ->preload()
                                     ->searchable()
-                                    ->required(),
+                                    ->required()
+                                    ->live()
+                                    ->afterStateUpdated(function (Forms\Set $set, Forms\Get $get, $state) {
+                                        if (! $state) {
+                                            return;
+                                        }
+
+                                        $currencyCode = Client::find($state)?->currency_code;
+
+                                        if ($currencyCode) {
+                                            $set('currency_code', $currencyCode);
+                                        }
+                                    }),
+                                CreateCurrencySelect::make('currency_code'),
                             ]),
                             Forms\Components\Group::make([
                                 Forms\Components\TextInput::make('invoice_number')
                                     ->searchable(),
                                 Forms\Components\Placeholder::make('total')
                                     ->hiddenLabel()
+                                    ->extraAttributes(['class' => 'text-left sm:text-right'])
                                     ->content(function (Forms\Get $get) {
                                         $quantity = max((float) ($get('quantity') ?? 0), 0);
                                         $unitPrice = max((float) ($get('unit_price') ?? 0), 0);
                                         $salesTaxes = $get('salesTaxes') ?? [];
                                         $salesDiscounts = $get('salesDiscounts') ?? [];
+                                        $currencyCode = $get('../../currency_code') ?? CurrencyAccessor::getDefaultCurrency();
 
                                         $subtotal = $quantity * $unitPrice;
 
-                                        // Calculate tax amount based on subtotal
-                                        $taxAmount = 0;
-                                        if (! empty($salesTaxes)) {
-                                            $taxRates = Adjustment::whereIn('id', $salesTaxes)->pluck('rate');
-                                            $taxAmount = collect($taxRates)->sum(fn ($rate) => $subtotal * ($rate / 100));
-                                        }
-
-                                        // Calculate discount amount based on subtotal
-                                        $discountAmount = 0;
-                                        if (! empty($salesDiscounts)) {
-                                            $discountRates = Adjustment::whereIn('id', $salesDiscounts)->pluck('rate');
-                                            $discountAmount = collect($discountRates)->sum(fn ($rate) => $subtotal * ($rate / 100));
-                                        }
+                                        $subtotalInCents = CurrencyConverter::convertToCents($subtotal, $currencyCode);
+
+                                        $taxAmountInCents = Adjustment::whereIn('id', $salesTaxes)
+                                            ->get()
+                                            ->sum(function (Adjustment $adjustment) use ($subtotalInCents) {
+                                                if ($adjustment->computation->isPercentage()) {
+                                                    return RateCalculator::calculatePercentage($subtotalInCents, $adjustment->getRawOriginal('rate'));
+                                                } else {
+                                                    return $adjustment->getRawOriginal('rate');
+                                                }
+                                            });
+
+                                        $discountAmountInCents = Adjustment::whereIn('id', $salesDiscounts)
+                                            ->get()
+                                            ->sum(function (Adjustment $adjustment) use ($subtotalInCents) {
+                                                if ($adjustment->computation->isPercentage()) {
+                                                    return RateCalculator::calculatePercentage($subtotalInCents, $adjustment->getRawOriginal('rate'));
+                                                } else {
+                                                    return $adjustment->getRawOriginal('rate');
+                                                }
+                                            });
 
                                         // Final total
-                                        $total = $subtotal + ($taxAmount - $discountAmount);
+                                        $totalInCents = $subtotalInCents + ($taxAmountInCents - $discountAmountInCents);
 
-                                        return CurrencyConverter::formatToMoney($total);
+                                        return CurrencyConverter::formatCentsToMoney($totalInCents, $currencyCode);
                                     }),
                             ]),
-                        InvoiceTotals::make(),
+                        DocumentTotals::make()
+                            ->type(DocumentType::Invoice),
                         Forms\Components\Textarea::make('terms')
                             ->columnSpanFull(),
                     ]),
                     ->sortable()
                     ->searchable(),
                 Tables\Columns\TextColumn::make('total')
-                    ->currency()
-                    ->sortable(),
+                    ->currencyWithConversion(static fn (Invoice $record) => $record->currency_code)
+                    ->sortable()
+                    ->toggleable(),
                 Tables\Columns\TextColumn::make('amount_paid')
                     ->label('Amount Paid')
-                    ->currency()
-                    ->sortable(),
+                    ->currencyWithConversion(static fn (Invoice $record) => $record->currency_code)
+                    ->sortable()
+                    ->toggleable(),
                 Tables\Columns\TextColumn::make('amount_due')
                     ->label('Amount Due')
-                    ->currency()
+                    ->currencyWithConversion(static fn (Invoice $record) => $record->currency_code)
                     ->sortable(),
             ])
             ->filters([
                             Forms\Components\TextInput::make('amount')
                                 ->label('Amount')
                                 ->required()
-                                ->money()
+                                ->money(fn (Invoice $record) => $record->currency_code)
                                 ->live(onBlur: true)
                                 ->helperText(function (Invoice $record, $state) {
-                                    if (! CurrencyConverter::isValidAmount($state)) {
+                                    $invoiceCurrency = $record->currency_code;
+                                    if (! CurrencyConverter::isValidAmount($state, $invoiceCurrency)) {
                                         return null;
                                     }
 
                                     $amountDue = $record->getRawOriginal('amount_due');
 
-                                    $amount = CurrencyConverter::convertToCents($state);
+                                    $amount = CurrencyConverter::convertToCents($state, $invoiceCurrency);
 
                                     if ($amount <= 0) {
                                         return 'Please enter a valid positive amount';
                                     }
 
                                     return match (true) {
-                                        $newAmountDue > 0 => 'Amount due after payment will be ' . CurrencyConverter::formatCentsToMoney($newAmountDue),
+                                        $newAmountDue > 0 => 'Amount due after payment will be ' . CurrencyConverter::formatCentsToMoney($newAmountDue, $invoiceCurrency),
                                         $newAmountDue === 0 => 'Invoice will be fully paid',
-                                        default => 'Invoice will be overpaid by ' . CurrencyConverter::formatCentsToMoney(abs($newAmountDue)),
+                                        default => 'Invoice will be overpaid by ' . CurrencyConverter::formatCentsToMoney(abs($newAmountDue), $invoiceCurrency),
                                     };
                                 })
                                 ->rules([
-                                    static fn (): Closure => static function (string $attribute, $value, Closure $fail) {
-                                        if (! CurrencyConverter::isValidAmount($value)) {
+                                    static fn (Invoice $record): Closure => static function (string $attribute, $value, Closure $fail) use ($record) {
+                                        if (! CurrencyConverter::isValidAmount($value, $record->currency_code)) {
                                             $fail('Please enter a valid amount');
                                         }
                                     },
                             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.')
+                                    ->body('Invoices that are either draft, paid, overpaid, voided, or are in a foreign currency 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) {
+                        ->mountUsing(function (DocumentCollection $records, Form $form) {
                             $totalAmountDue = $records->sumMoneyFormattedSimple('amount_due');
 
                             $form->fill([
                             Forms\Components\Textarea::make('notes')
                                 ->label('Notes'),
                         ])
-                        ->before(function (InvoiceCollection $records, Tables\Actions\BulkAction $action, array $data) {
+                        ->before(function (DocumentCollection $records, Tables\Actions\BulkAction $action, array $data) {
                             $totalPaymentAmount = CurrencyConverter::convertToCents($data['amount']);
                             $totalAmountDue = $records->sumMoneyInCents('amount_due');
 
                                 $action->halt(true);
                             }
                         })
-                        ->action(function (InvoiceCollection $records, Tables\Actions\BulkAction $action, array $data) {
+                        ->action(function (DocumentCollection $records, Tables\Actions\BulkAction $action, array $data) {
                             $totalPaymentAmount = CurrencyConverter::convertToCents($data['amount']);
 
                             $remainingAmount = $totalPaymentAmount;

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

                                     ->url(static fn (Invoice $record) => ClientResource::getUrl('edit', ['record' => $record->client_id])),
                                 TextEntry::make('amount_due')
                                     ->label('Amount Due')
-                                    ->money(),
+                                    ->currency(static fn (Invoice $record) => $record->currency_code),
                                 TextEntry::make('due_date')
                                     ->label('Due')
                                     ->asRelativeDay(),

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

     {
         $unpaidInvoices = $this->getPageTableQuery()->unpaid();
 
-        $amountUnpaid = $unpaidInvoices->sum('amount_due');
+        $amountUnpaid = $unpaidInvoices->get()->sumMoneyInDefaultCurrency('amount_due');
 
         $amountOverdue = $unpaidInvoices
             ->clone()
             ->where('status', InvoiceStatus::Overdue)
-            ->sum('amount_due');
+            ->get()
+            ->sumMoneyInDefaultCurrency('amount_due');
 
         $amountDueWithin30Days = $unpaidInvoices
             ->clone()
             ->whereBetween('due_date', [today(), today()->addMonth()])
-            ->sum('amount_due');
+            ->get()
+            ->sumMoneyInDefaultCurrency('amount_due');
 
         $validInvoices = $this->getPageTableQuery()
             ->whereNotIn('status', [
                 InvoiceStatus::Draft,
             ]);
 
-        $totalValidInvoiceAmount = $validInvoices->sum('total');
+        $totalValidInvoiceAmount = $validInvoices->get()->sumMoneyInDefaultCurrency('total');
 
         $totalValidInvoiceCount = $validInvoices->count();
 

app/Filament/Forms/Components/BillTotals.php

-<?php
-
-namespace App\Filament\Forms\Components;
-
-use App\Enums\Accounting\AdjustmentComputation;
-use Filament\Forms\Components\Grid;
-use Filament\Forms\Components\Select;
-use Filament\Forms\Components\TextInput;
-use Filament\Forms\Get;
-
-class BillTotals extends Grid
-{
-    protected string $view = 'filament.forms.components.bill-totals';
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-
-        $this->schema([
-            TextInput::make('discount_rate')
-                ->label('Discount Rate')
-                ->hiddenLabel()
-                ->live()
-                ->rate(computation: static fn (Get $get) => $get('discount_computation'), showAffix: false),
-            Select::make('discount_computation')
-                ->label('Discount Computation')
-                ->hiddenLabel()
-                ->options([
-                    'percentage' => '%',
-                    'fixed' => '$',
-                ])
-                ->default(AdjustmentComputation::Percentage)
-                ->selectablePlaceholder(false)
-                ->live(),
-        ]);
-    }
-}

app/Filament/Forms/Components/CreateCurrencySelect.php

             ->required()
             ->createOptionForm($this->createCurrencyForm())
             ->createOptionAction(fn (Action $action) => $this->createCurrencyAction($action));
+
+        $this->relationship('currency', 'name');
+
+        $this->createOptionUsing(static function (array $data) {
+            return DB::transaction(static function () use ($data) {
+                $currency = CreateCurrency::create(
+                    $data['code'],
+                    $data['name'],
+                    $data['rate']
+                );
+
+                return $currency->code;
+            });
+        });
     }
 
     protected function createCurrencyForm(): array
         return $action
             ->label('Add Currency')
             ->slideOver()
-            ->modalWidth(MaxWidth::Medium)
-            ->action(static function (array $data) {
-                return DB::transaction(static function () use ($data) {
-                    $code = $data['code'];
-                    $name = $data['name'];
-                    $rate = $data['rate'];
-
-                    return CreateCurrency::create($code, $name, $rate);
-                });
-            });
+            ->modalWidth(MaxWidth::Medium);
     }
 }

app/Filament/Forms/Components/DocumentTotals.php

+<?php
+
+namespace App\Filament\Forms\Components;
+
+use App\Enums\Accounting\AdjustmentComputation;
+use App\Enums\Accounting\DocumentType;
+use Filament\Forms\Components\Grid;
+use Filament\Forms\Components\Select;
+use Filament\Forms\Components\TextInput;
+use Filament\Forms\Get;
+
+class DocumentTotals extends Grid
+{
+    protected string $view = 'filament.forms.components.document-totals';
+
+    protected DocumentType $documentType = DocumentType::Invoice;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->schema([
+            Select::make('discount_computation')
+                ->label('Discount Computation')
+                ->hiddenLabel()
+                ->options(AdjustmentComputation::class)
+                ->default(AdjustmentComputation::Percentage)
+                ->selectablePlaceholder(false)
+                ->live(),
+            TextInput::make('discount_rate')
+                ->label('Discount Rate')
+                ->hiddenLabel()
+                ->live()
+                ->extraInputAttributes(['class' => 'text-right'])
+                ->rate(
+                    computation: static fn (Get $get) => $get('discount_computation'),
+                    currency: static fn (Get $get) => $get('currency_code'),
+                ),
+        ]);
+    }
+
+    public function type(DocumentType | string $type): static
+    {
+        if (is_string($type)) {
+            $type = DocumentType::from($type);
+        }
+
+        $this->documentType = $type;
+
+        return $this;
+    }
+
+    public function getType(): DocumentType
+    {
+        return $this->documentType;
+    }
+}

app/Filament/Forms/Components/InvoiceTotals.php

-<?php
-
-namespace App\Filament\Forms\Components;
-
-use App\Enums\Accounting\AdjustmentComputation;
-use Filament\Forms\Components\Grid;
-use Filament\Forms\Components\Select;
-use Filament\Forms\Components\TextInput;
-use Filament\Forms\Get;
-
-class InvoiceTotals extends Grid
-{
-    protected string $view = 'filament.forms.components.invoice-totals';
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-
-        $this->schema([
-            TextInput::make('discount_rate')
-                ->label('Discount Rate')
-                ->hiddenLabel()
-                ->live()
-                ->rate(computation: static fn (Get $get) => $get('discount_computation'), showAffix: false),
-            Select::make('discount_computation')
-                ->label('Discount Computation')
-                ->hiddenLabel()
-                ->options([
-                    'percentage' => '%',
-                    'fixed' => '$',
-                ])
-                ->default(AdjustmentComputation::Percentage)
-                ->selectablePlaceholder(false)
-                ->live(),
-        ]);
-    }
-}

app/Helpers/format.php

 <?php
 
+use App\Enums\Accounting\AdjustmentComputation;
 use App\Enums\Setting\NumberFormat;
 use App\Models\Setting\Localization;
 use Filament\Support\RawJs;
 if (! function_exists('ratePrefix')) {
     function ratePrefix($computation, ?string $currency = null): ?string
     {
-        if ($computation instanceof BackedEnum) {
-            $computation = $computation->value;
-        }
+        $computationEnum = AdjustmentComputation::parse($computation);
+        $localization = Localization::firstOrFail();
 
-        if ($computation === 'fixed') {
-            return currency($currency)->getCodePrefix();
+        if ($computationEnum->isFixed() && currency($currency)->isSymbolFirst()) {
+            return currency($currency)->getPrefix();
         }
 
-        if ($computation === 'percentage' || $computation === 'compound') {
-            $percent_first = Localization::firstOrFail()->percent_first;
-
-            return $percent_first ? '%' : null;
+        if ($computationEnum->isPercentage() && $localization->percent_first) {
+            return '%';
         }
 
         return null;
 if (! function_exists('rateSuffix')) {
     function rateSuffix($computation, ?string $currency = null): ?string
     {
-        if ($computation instanceof BackedEnum) {
-            $computation = $computation->value;
-        }
-
-        if ($computation === 'percentage' || $computation === 'compound') {
-            $percent_first = Localization::firstOrFail()->percent_first;
+        $computationEnum = AdjustmentComputation::parse($computation);
+        $localization = Localization::firstOrFail();
 
-            return $percent_first ? null : '%';
+        if ($computationEnum->isFixed() && ! currency($currency)->isSymbolFirst()) {
+            return currency($currency)->getSuffix();
         }
 
-        if ($computation === 'fixed') {
-            return currency($currency)->getCodeSuffix();
+        if ($computationEnum->isPercentage() && ! $localization->percent_first) {
+            return '%';
         }
 
         return null;
 }
 
 if (! function_exists('rateMask')) {
-    function rateMask($computation, ?string $currency = null): RawJs
+    function rateMask($computation, ?string $currency = null): ?RawJs
     {
-        if ($computation instanceof BackedEnum) {
-            $computation = $computation->value;
-        }
+        $computationEnum = AdjustmentComputation::parse($computation);
 
-        if ($computation === 'percentage' || $computation === 'compound') {
+        if ($computationEnum->isPercentage()) {
             return percentMask(4);
         }
 
-        $precision = currency($currency)->getPrecision();
+        if ($computationEnum->isFixed()) {
+            $precision = currency($currency)->getPrecision();
 
-        return RawJs::make(generateJsCode($precision, $currency));
+            return RawJs::make(generateJsCode($precision, $currency));
+        }
+
+        return null;
     }
 }
 
             return null;
         }
 
-        if ($computation instanceof BackedEnum) {
-            $computation = $computation->value;
-        }
-
-        if ($computation === 'percentage' || $computation === 'compound') {
-            $percent_first = Localization::firstOrFail()->percent_first;
+        $computationEnum = AdjustmentComputation::parse($computation);
+        $localization = Localization::firstOrFail();
 
-            if ($percent_first) {
-                return '%' . $state;
-            }
+        if ($computationEnum->isPercentage() && $localization->percent_first) {
+            return '%' . $state;
+        }
 
+        if ($computationEnum->isPercentage() && ! $localization->percent_first) {
             return $state . '%';
         }
 
-        if ($computation === 'fixed') {
+        if ($computationEnum->isFixed()) {
             return money($state, $currency, true)->formatWithCode();
         }
 

app/Models/Accounting/Bill.php

 
 use App\Casts\MoneyCast;
 use App\Casts\RateCast;
+use App\Collections\Accounting\DocumentCollection;
 use App\Concerns\Blamable;
 use App\Concerns\CompanyOwned;
 use App\Enums\Accounting\AdjustmentComputation;
 use App\Enums\Accounting\JournalEntryType;
 use App\Enums\Accounting\TransactionType;
 use App\Filament\Company\Resources\Purchases\BillResource;
+use App\Models\Banking\BankAccount;
 use App\Models\Common\Vendor;
+use App\Models\Setting\Currency;
 use App\Observers\BillObserver;
+use App\Utilities\Currency\CurrencyAccessor;
 use App\Utilities\Currency\CurrencyConverter;
 use Filament\Actions\MountableAction;
 use Filament\Actions\ReplicateAction;
+use Illuminate\Database\Eloquent\Attributes\CollectedBy;
 use Illuminate\Database\Eloquent\Attributes\ObservedBy;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Casts\Attribute;
 use Illuminate\Support\Carbon;
 
 #[ObservedBy(BillObserver::class)]
+#[CollectedBy(DocumentCollection::class)]
 class Bill extends Model
 {
     use Blamable;
         'amount_due' => MoneyCast::class,
     ];
 
+    public function currency(): BelongsTo
+    {
+        return $this->belongsTo(Currency::class, 'currency_code', 'code');
+    }
+
     public function vendor(): BelongsTo
     {
         return $this->belongsTo(Vendor::class);
         return ! in_array($this->status, [
             BillStatus::Paid,
             BillStatus::Void,
-        ]);
+        ]) && $this->currency_code === CurrencyAccessor::getDefaultCurrency();
     }
 
     public function hasPayments(): bool
         $transactionType = TransactionType::Withdrawal;
         $transactionDescription = "Bill #{$this->bill_number}: Payment to {$this->vendor->name}";
 
-        // Create transaction
+        // Add multi-currency handling
+        $bankAccount = BankAccount::findOrFail($data['bank_account_id']);
+        $bankAccountCurrency = $bankAccount->account->currency_code ?? CurrencyAccessor::getDefaultCurrency();
+
+        $billCurrency = $this->currency_code;
+        $requiresConversion = $billCurrency !== $bankAccountCurrency;
+
+        if ($requiresConversion) {
+            $amountInBillCurrencyCents = CurrencyConverter::convertToCents($data['amount'], $billCurrency);
+            $amountInBankCurrencyCents = CurrencyConverter::convertBalance(
+                $amountInBillCurrencyCents,
+                $billCurrency,
+                $bankAccountCurrency
+            );
+            $formattedAmountForBankCurrency = CurrencyConverter::convertCentsToFormatSimple(
+                $amountInBankCurrencyCents,
+                $bankAccountCurrency
+            );
+        } else {
+            $formattedAmountForBankCurrency = $data['amount']; // Already in simple format
+        }
+
+        // Create transaction with converted amount
         $this->transactions()->create([
             'company_id' => $this->company_id,
             'type' => $transactionType,
             'is_payment' => true,
             'posted_at' => $data['posted_at'],
-            'amount' => $data['amount'],
+            'amount' => $formattedAmountForBankCurrency,
             'payment_method' => $data['payment_method'],
             'bank_account_id' => $data['bank_account_id'],
             'account_id' => Account::getAccountsPayableAccount()->id,
     {
         $postedAt ??= $this->date;
 
+        $total = $this->formatAmountToDefaultCurrency($this->getRawOriginal('total'));
+
         $transaction = $this->transactions()->create([
             'company_id' => $this->company_id,
             'type' => TransactionType::Journal,
             'posted_at' => $postedAt,
-            'amount' => $this->total,
+            'amount' => $total,
             'description' => 'Bill Creation for Bill #' . $this->bill_number,
         ]);
 
             'company_id' => $this->company_id,
             'type' => JournalEntryType::Credit,
             'account_id' => Account::getAccountsPayableAccount()->id,
-            'amount' => $this->total,
+            'amount' => $total,
             'description' => $baseDescription,
         ]);
 
-        $totalLineItemSubtotal = (int) $this->lineItems()->sum('subtotal');
-        $billDiscountTotalCents = (int) $this->getRawOriginal('discount_total');
+        $totalLineItemSubtotalCents = $this->convertAmountToDefaultCurrency((int) $this->lineItems()->sum('subtotal'));
+        $billDiscountTotalCents = $this->convertAmountToDefaultCurrency((int) $this->getRawOriginal('discount_total'));
         $remainingDiscountCents = $billDiscountTotalCents;
 
         foreach ($this->lineItems as $index => $lineItem) {
             $lineItemDescription = "{$baseDescription} › {$lineItem->offering->name}";
 
+            $lineItemSubtotal = $this->formatAmountToDefaultCurrency($lineItem->getRawOriginal('subtotal'));
+
             $transaction->journalEntries()->create([
                 'company_id' => $this->company_id,
                 'type' => JournalEntryType::Debit,
                 'account_id' => $lineItem->offering->expense_account_id,
-                'amount' => $lineItem->subtotal,
+                'amount' => $lineItemSubtotal,
                 'description' => $lineItemDescription,
             ]);
 
             foreach ($lineItem->adjustments as $adjustment) {
+                $adjustmentAmount = $this->formatAmountToDefaultCurrency($lineItem->calculateAdjustmentTotalAmount($adjustment));
+
                 if ($adjustment->isNonRecoverablePurchaseTax()) {
                     $transaction->journalEntries()->create([
                         'company_id' => $this->company_id,
                         'type' => JournalEntryType::Debit,
                         'account_id' => $lineItem->offering->expense_account_id,
-                        'amount' => $lineItem->calculateAdjustmentTotal($adjustment)->getAmount(),
+                        'amount' => $adjustmentAmount,
                         'description' => "{$lineItemDescription} ({$adjustment->name})",
                     ]);
                 } elseif ($adjustment->account_id) {
                         'company_id' => $this->company_id,
                         'type' => $adjustment->category->isDiscount() ? JournalEntryType::Credit : JournalEntryType::Debit,
                         'account_id' => $adjustment->account_id,
-                        'amount' => $lineItem->calculateAdjustmentTotal($adjustment)->getAmount(),
+                        'amount' => $adjustmentAmount,
                         'description' => $lineItemDescription,
                     ]);
                 }
             }
 
-            if ($this->discount_method->isPerDocument() && $totalLineItemSubtotal > 0) {
-                $lineItemSubtotalCents = (int) $lineItem->getRawOriginal('subtotal');
+            if ($this->discount_method->isPerDocument() && $totalLineItemSubtotalCents > 0) {
+                $lineItemSubtotalCents = $this->convertAmountToDefaultCurrency((int) $lineItem->getRawOriginal('subtotal'));
 
                 if ($index === $this->lineItems->count() - 1) {
                     $lineItemDiscount = $remainingDiscountCents;
                 } else {
                     $lineItemDiscount = (int) round(
-                        ($lineItemSubtotalCents / $totalLineItemSubtotal) * $billDiscountTotalCents
+                        ($lineItemSubtotalCents / $totalLineItemSubtotalCents) * $billDiscountTotalCents
                     );
                     $remainingDiscountCents -= $lineItemDiscount;
                 }
         $this->createInitialTransaction();
     }
 
+    public function convertAmountToDefaultCurrency(int $amountCents): int
+    {
+        $defaultCurrency = CurrencyAccessor::getDefaultCurrency();
+        $needsConversion = $this->currency_code !== $defaultCurrency;
+
+        if ($needsConversion) {
+            return CurrencyConverter::convertBalance($amountCents, $this->currency_code, $defaultCurrency);
+        }
+
+        return $amountCents;
+    }
+
+    public function formatAmountToDefaultCurrency(int $amountCents): string
+    {
+        $convertedCents = $this->convertAmountToDefaultCurrency($amountCents);
+
+        return CurrencyConverter::convertCentsToFormatSimple($convertedCents);
+    }
+
     public static function getReplicateAction(string $action = ReplicateAction::class): MountableAction
     {
         return $action::make()

app/Models/Accounting/DocumentLineItem.php

 use App\Models\Common\Offering;
 use App\Observers\DocumentLineItemObserver;
 use App\Utilities\Currency\CurrencyAccessor;
+use App\Utilities\RateCalculator;
 use Illuminate\Database\Eloquent\Attributes\ObservedBy;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
         );
     }
 
+    public function calculateTaxTotalAmount(): int
+    {
+        $subtotalInCents = $this->getRawOriginal('subtotal');
+
+        return $this->taxes->reduce(function (int $carry, Adjustment $tax) use ($subtotalInCents) {
+            if ($tax->computation->isPercentage()) {
+                $scaledRate = $tax->getRawOriginal('rate');
+
+                return $carry + RateCalculator::calculatePercentage($subtotalInCents, $scaledRate);
+            } else {
+                return $carry + $tax->getRawOriginal('rate');
+            }
+        }, 0);
+    }
+
     public function calculateDiscountTotal(): Money
     {
         $subtotal = money($this->subtotal, CurrencyAccessor::getDefaultCurrency());
         );
     }
 
+    public function calculateDiscountTotalAmount(): int
+    {
+        $subtotalInCents = $this->getRawOriginal('subtotal');
+
+        return $this->discounts->reduce(function (int $carry, Adjustment $discount) use ($subtotalInCents) {
+            if ($discount->computation->isPercentage()) {
+                $scaledRate = $discount->getRawOriginal('rate');
+
+                return $carry + RateCalculator::calculatePercentage($subtotalInCents, $scaledRate);
+            } else {
+                return $carry + $discount->getRawOriginal('rate');
+            }
+        }, 0);
+    }
+
     public function calculateAdjustmentTotal(Adjustment $adjustment): Money
     {
         $subtotal = money($this->subtotal, CurrencyAccessor::getDefaultCurrency());
 
         return $subtotal->multiply($adjustment->rate / 100);
     }
+
+    public function calculateAdjustmentTotalAmount(Adjustment $adjustment): int
+    {
+        $subtotalInCents = $this->getRawOriginal('subtotal');
+
+        if ($adjustment->computation->isPercentage()) {
+            $scaledRate = $adjustment->getRawOriginal('rate');
+
+            return RateCalculator::calculatePercentage($subtotalInCents, $scaledRate);
+        } else {
+            return $adjustment->getRawOriginal('rate');
+        }
+    }
 }

app/Models/Accounting/Invoice.php

 
 use App\Casts\MoneyCast;
 use App\Casts\RateCast;
-use App\Collections\Accounting\InvoiceCollection;
+use App\Collections\Accounting\DocumentCollection;
 use App\Concerns\Blamable;
 use App\Concerns\CompanyOwned;
 use App\Enums\Accounting\AdjustmentComputation;
 use App\Enums\Accounting\JournalEntryType;
 use App\Enums\Accounting\TransactionType;
 use App\Filament\Company\Resources\Sales\InvoiceResource;
+use App\Models\Banking\BankAccount;
 use App\Models\Common\Client;
+use App\Models\Setting\Currency;
 use App\Observers\InvoiceObserver;
+use App\Utilities\Currency\CurrencyAccessor;
 use App\Utilities\Currency\CurrencyConverter;
 use Filament\Actions\Action;
 use Filament\Actions\MountableAction;
 use Illuminate\Support\Carbon;
 
 #[ObservedBy(InvoiceObserver::class)]
-#[CollectedBy(InvoiceCollection::class)]
+#[CollectedBy(DocumentCollection::class)]
 class Invoice extends Model
 {
     use Blamable;
         return $this->belongsTo(Client::class);
     }
 
+    public function currency(): BelongsTo
+    {
+        return $this->belongsTo(Currency::class, 'currency_code', 'code');
+    }
+
     public function lineItems(): MorphMany
     {
         return $this->morphMany(DocumentLineItem::class, 'documentable');
             InvoiceStatus::Paid,
             InvoiceStatus::Void,
             InvoiceStatus::Overpaid,
-        ]);
+        ]) && $this->currency_code === CurrencyAccessor::getDefaultCurrency();
     }
 
     public function canBeOverdue(): bool
             $transactionDescription = "Invoice #{$this->invoice_number}: Payment from {$this->client->name}";
         }
 
+        $bankAccount = BankAccount::findOrFail($data['bank_account_id']);
+        $bankAccountCurrency = $bankAccount->account->currency_code ?? CurrencyAccessor::getDefaultCurrency();
+
+        $invoiceCurrency = $this->currency_code;
+        $requiresConversion = $invoiceCurrency !== $bankAccountCurrency;
+
+        if ($requiresConversion) {
+            $amountInInvoiceCurrencyCents = CurrencyConverter::convertToCents($data['amount'], $invoiceCurrency);
+            $amountInBankCurrencyCents = CurrencyConverter::convertBalance(
+                $amountInInvoiceCurrencyCents,
+                $invoiceCurrency,
+                $bankAccountCurrency
+            );
+            $formattedAmountForBankCurrency = CurrencyConverter::convertCentsToFormatSimple(
+                $amountInBankCurrencyCents,
+                $bankAccountCurrency
+            );
+        } else {
+            $formattedAmountForBankCurrency = $data['amount']; // Already in simple format
+        }
+
         // Create transaction
         $this->transactions()->create([
             'company_id' => $this->company_id,
             'type' => $transactionType,
             'is_payment' => true,
             'posted_at' => $data['posted_at'],
-            'amount' => $data['amount'],
+            'amount' => $formattedAmountForBankCurrency,
             'payment_method' => $data['payment_method'],
             'bank_account_id' => $data['bank_account_id'],
             'account_id' => Account::getAccountsReceivableAccount()->id,
 
     public function createApprovalTransaction(): void
     {
+        $total = $this->formatAmountToDefaultCurrency($this->getRawOriginal('total'));
+
         $transaction = $this->transactions()->create([
             'company_id' => $this->company_id,
             'type' => TransactionType::Journal,
             'posted_at' => $this->date,
-            'amount' => $this->total,
+            'amount' => $total,
             'description' => 'Invoice Approval for Invoice #' . $this->invoice_number,
         ]);
 
             'company_id' => $this->company_id,
             'type' => JournalEntryType::Debit,
             'account_id' => Account::getAccountsReceivableAccount()->id,
-            'amount' => $this->total,
+            'amount' => $total,
             'description' => $baseDescription,
         ]);
 
-        $totalLineItemSubtotal = (int) $this->lineItems()->sum('subtotal');
-        $invoiceDiscountTotalCents = (int) $this->getRawOriginal('discount_total');
+        $totalLineItemSubtotalCents = $this->convertAmountToDefaultCurrency((int) $this->lineItems()->sum('subtotal'));
+        $invoiceDiscountTotalCents = $this->convertAmountToDefaultCurrency((int) $this->getRawOriginal('discount_total'));
         $remainingDiscountCents = $invoiceDiscountTotalCents;
 
         foreach ($this->lineItems as $index => $lineItem) {
             $lineItemDescription = "{$baseDescription} › {$lineItem->offering->name}";
 
+            $lineItemSubtotal = $this->formatAmountToDefaultCurrency($lineItem->getRawOriginal('subtotal'));
+
             $transaction->journalEntries()->create([
                 'company_id' => $this->company_id,
                 'type' => JournalEntryType::Credit,
                 'account_id' => $lineItem->offering->income_account_id,
-                'amount' => $lineItem->subtotal,
+                'amount' => $lineItemSubtotal,
                 'description' => $lineItemDescription,
             ]);
 
             foreach ($lineItem->adjustments as $adjustment) {
+                $adjustmentAmount = $this->formatAmountToDefaultCurrency($lineItem->calculateAdjustmentTotalAmount($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(),
+                    'amount' => $adjustmentAmount,
                     'description' => $lineItemDescription,
                 ]);
             }
 
-            if ($this->discount_method->isPerDocument() && $totalLineItemSubtotal > 0) {
-                $lineItemSubtotalCents = (int) $lineItem->getRawOriginal('subtotal');
+            if ($this->discount_method->isPerDocument() && $totalLineItemSubtotalCents > 0) {
+                $lineItemSubtotalCents = $this->convertAmountToDefaultCurrency((int) $lineItem->getRawOriginal('subtotal'));
 
                 if ($index === $this->lineItems->count() - 1) {
                     $lineItemDiscount = $remainingDiscountCents;
                 } else {
                     $lineItemDiscount = (int) round(
-                        ($lineItemSubtotalCents / $totalLineItemSubtotal) * $invoiceDiscountTotalCents
+                        ($lineItemSubtotalCents / $totalLineItemSubtotalCents) * $invoiceDiscountTotalCents
                     );
                     $remainingDiscountCents -= $lineItemDiscount;
                 }
         $this->createApprovalTransaction();
     }
 
+    public function convertAmountToDefaultCurrency(int $amountCents): int
+    {
+        $defaultCurrency = CurrencyAccessor::getDefaultCurrency();
+        $needsConversion = $this->currency_code !== $defaultCurrency;
+
+        if ($needsConversion) {
+            return CurrencyConverter::convertBalance($amountCents, $this->currency_code, $defaultCurrency);
+        }
+
+        return $amountCents;
+    }
+
+    public function formatAmountToDefaultCurrency(int $amountCents): string
+    {
+        $convertedCents = $this->convertAmountToDefaultCurrency($amountCents);
+
+        return CurrencyConverter::convertCentsToFormatSimple($convertedCents);
+    }
+
     public static function getApproveDraftAction(string $action = Action::class): MountableAction
     {
         return $action::make('approveDraft')

app/Observers/TransactionObserver.php

             return;
         }
 
-        $depositTotal = (int) $invoice->deposits()
+        $invoiceCurrency = $invoice->currency_code;
+
+        $depositTotalInInvoiceCurrencyCents = (int) $invoice->deposits()
             ->when($excludedTransaction, fn (Builder $query) => $query->whereKeyNot($excludedTransaction->getKey()))
-            ->sum('amount');
+            ->get()
+            ->sum(function (Transaction $transaction) use ($invoiceCurrency) {
+                $bankAccountCurrency = $transaction->bankAccount->account->currency_code;
+                $amountCents = (int) $transaction->getRawOriginal('amount');
+
+                return CurrencyConverter::convertBalance($amountCents, $bankAccountCurrency, $invoiceCurrency);
+            });
 
-        $withdrawalTotal = (int) $invoice->withdrawals()
+        $withdrawalTotalInInvoiceCurrencyCents = (int) $invoice->withdrawals()
             ->when($excludedTransaction, fn (Builder $query) => $query->whereKeyNot($excludedTransaction->getKey()))
-            ->sum('amount');
+            ->get()
+            ->sum(function (Transaction $transaction) use ($invoiceCurrency) {
+                $bankAccountCurrency = $transaction->bankAccount->account->currency_code;
+                $amountCents = (int) $transaction->getRawOriginal('amount');
+
+                return CurrencyConverter::convertBalance($amountCents, $bankAccountCurrency, $invoiceCurrency);
+            });
 
-        $totalPaid = $depositTotal - $withdrawalTotal;
+        $totalPaidInInvoiceCurrencyCents = $depositTotalInInvoiceCurrencyCents - $withdrawalTotalInInvoiceCurrencyCents;
 
-        $invoiceTotal = (int) $invoice->getRawOriginal('total');
+        $invoiceTotalInInvoiceCurrencyCents = (int) $invoice->getRawOriginal('total');
 
         $newStatus = match (true) {
-            $totalPaid > $invoiceTotal => InvoiceStatus::Overpaid,
-            $totalPaid === $invoiceTotal => InvoiceStatus::Paid,
+            $totalPaidInInvoiceCurrencyCents > $invoiceTotalInInvoiceCurrencyCents => InvoiceStatus::Overpaid,
+            $totalPaidInInvoiceCurrencyCents === $invoiceTotalInInvoiceCurrencyCents => InvoiceStatus::Paid,
             default => InvoiceStatus::Partial,
         };
 
         }
 
         $invoice->update([
-            'amount_paid' => CurrencyConverter::convertCentsToFloat($totalPaid),
+            'amount_paid' => CurrencyConverter::convertCentsToFormatSimple($totalPaidInInvoiceCurrencyCents, $invoiceCurrency),
             'status' => $newStatus,
             'paid_at' => $paidAt,
         ]);
             return;
         }
 
-        $withdrawalTotal = (int) $bill->withdrawals()
+        $billCurrency = $bill->currency_code;
+
+        $withdrawalTotalInBillCurrencyCents = (int) $bill->withdrawals()
             ->when($excludedTransaction, fn (Builder $query) => $query->whereKeyNot($excludedTransaction->getKey()))
-            ->sum('amount');
+            ->get()
+            ->sum(function (Transaction $transaction) use ($billCurrency) {
+                $bankAccountCurrency = $transaction->bankAccount->account->currency_code;
+                $amountCents = (int) $transaction->getRawOriginal('amount');
+
+                return CurrencyConverter::convertBalance($amountCents, $bankAccountCurrency, $billCurrency);
+            });
+
+        $totalPaidInBillCurrencyCents = $withdrawalTotalInBillCurrencyCents;
 
-        $totalPaid = $withdrawalTotal;
-        $billTotal = (int) $bill->getRawOriginal('total');
+        $billTotalInBillCurrencyCents = (int) $bill->getRawOriginal('total');
 
         $newStatus = match (true) {
-            $totalPaid >= $billTotal => BillStatus::Paid,
+            $totalPaidInBillCurrencyCents >= $billTotalInBillCurrencyCents => BillStatus::Paid,
             default => BillStatus::Partial,
         };
 
         }
 
         $bill->update([
-            'amount_paid' => CurrencyConverter::convertCentsToFloat($totalPaid),
+            'amount_paid' => CurrencyConverter::convertCentsToFormatSimple($totalPaidInBillCurrencyCents, $billCurrency),
             'status' => $newStatus,
             'paid_at' => $paidAt,
         ]);

app/Providers/MacroServiceProvider.php

 
 use Akaunting\Money\Currency;
 use Akaunting\Money\Money;
+use App\Enums\Accounting\AdjustmentComputation;
 use App\Enums\Setting\DateFormat;
 use App\Models\Accounting\AccountSubtype;
 use App\Models\Setting\Localization;
 use App\Utilities\Accounting\AccountCode;
 use App\Utilities\Currency\CurrencyAccessor;
+use App\Utilities\Currency\CurrencyConverter;
 use BackedEnum;
 use Carbon\CarbonInterface;
 use Closure;
             return $this;
         });
 
+        TextInput::macro('rate', function (string | Closure | null $computation = null, string | Closure | null $currency = null, bool $showAffix = true): static {
+            return $this
+                ->when(
+                    $showAffix,
+                    fn (TextInput $component) => $component
+                        ->prefix(function (TextInput $component) use ($computation, $currency) {
+                            $evaluatedComputation = $component->evaluate($computation);
+                            $evaluatedCurrency = $component->evaluate($currency);
+
+                            return ratePrefix($evaluatedComputation, $evaluatedCurrency);
+                        })
+                        ->suffix(function (TextInput $component) use ($computation, $currency) {
+                            $evaluatedComputation = $component->evaluate($computation);
+                            $evaluatedCurrency = $component->evaluate($currency);
+
+                            return rateSuffix($evaluatedComputation, $evaluatedCurrency);
+                        })
+                )
+                ->mask(static function (TextInput $component) use ($computation, $currency) {
+                    $computation = $component->evaluate($computation);
+                    $currency = $component->evaluate($currency);
+
+                    $computationEnum = AdjustmentComputation::parse($computation);
+
+                    if ($computationEnum->isPercentage()) {
+                        return rateMask(computation: $computation);
+                    }
+
+                    return moneyMask($currency);
+                })
+                ->rule(static function (TextInput $component) use ($computation) {
+                    return static function (string $attribute, $value, Closure $fail) use ($computation, $component) {
+                        $computation = $component->evaluate($computation);
+                        $numericValue = (float) $value;
+
+                        if ($computation instanceof BackedEnum) {
+                            $computation = $computation->value;
+                        }
+
+                        if ($computation === 'percentage' || $computation === 'compound') {
+                            if ($numericValue < 0 || $numericValue > 100) {
+                                $fail(translate('The rate must be between 0 and 100.'));
+                            }
+                        } elseif ($computation === 'fixed' && $numericValue < 0) {
+                            $fail(translate('The rate must be greater than 0.'));
+                        }
+                    };
+                });
+        });
+
         TextColumn::macro('defaultDateFormat', function (): static {
             $localization = Localization::firstOrFail();
 
             return $this;
         });
 
-        TextInput::macro('rate', function (string | Closure | null $computation = null, bool $showAffix = true): static {
-            $this
-                ->when(
-                    $showAffix,
-                    fn (TextInput $component) => $component
-                        ->prefix(static function (TextInput $component) use ($computation) {
-                            $computation = $component->evaluate($computation);
+        TextEntry::macro('currency', function (string | Closure | null $currency = null, ?bool $convert = null): static {
+            $currency ??= CurrencyAccessor::getDefaultCurrency();
+            $convert ??= true;
 
-                            return ratePrefix(computation: $computation);
-                        })
-                        ->suffix(static function (TextInput $component) use ($computation) {
-                            $computation = $component->evaluate($computation);
+            $this->formatStateUsing(static function (TextEntry $entry, $state) use ($currency, $convert): ?string {
+                if (blank($state)) {
+                    return null;
+                }
 
-                            return rateSuffix(computation: $computation);
-                        })
-                )
-                ->mask(static function (TextInput $component) use ($computation) {
-                    $computation = $component->evaluate($computation);
+                $currency = $entry->evaluate($currency);
+                $convert = $entry->evaluate($convert);
 
-                    return rateMask(computation: $computation);
-                })
-                ->rule(static function (TextInput $component) use ($computation) {
-                    return static function (string $attribute, $value, Closure $fail) use ($computation, $component) {
-                        $computation = $component->evaluate($computation);
-                        $numericValue = (float) $value;
+                return money($state, $currency, $convert)->format();
+            });
 
-                        if ($computation instanceof BackedEnum) {
-                            $computation = $computation->value;
-                        }
+            return $this;
+        });
 
-                        if ($computation === 'percentage' || $computation === 'compound') {
-                            if ($numericValue < 0 || $numericValue > 100) {
-                                $fail(translate('The rate must be between 0 and 100.'));
-                            }
-                        } elseif ($computation === 'fixed' && $numericValue < 0) {
-                            $fail(translate('The rate must be greater than 0.'));
-                        }
-                    };
-                });
+        TextColumn::macro('currencyWithConversion', function (string | Closure | null $currency = null): static {
+            $currency ??= CurrencyAccessor::getDefaultCurrency();
+
+            $this->formatStateUsing(static function (TextColumn $column, $state) use ($currency): ?string {
+                if (blank($state)) {
+                    return null;
+                }
+
+                $currency = $column->evaluate($currency);
+
+                return CurrencyConverter::formatToMoney($state, $currency);
+            });
+
+            $this->description(static function (TextColumn $column, $state) use ($currency): ?string {
+                if (blank($state)) {
+                    return null;
+                }
+
+                $oldCurrency = $column->evaluate($currency);
+                $newCurrency = CurrencyAccessor::getDefaultCurrency();
+
+                if ($oldCurrency === $newCurrency) {
+                    return null;
+                }
+
+                $balanceInCents = CurrencyConverter::convertToCents($state, $oldCurrency);
+
+                $convertedBalanceInCents = CurrencyConverter::convertBalance($balanceInCents, $oldCurrency, $newCurrency);
+
+                return CurrencyConverter::formatCentsToMoney($convertedBalanceInCents, $newCurrency, true);
+            });
+
+            return $this;
+        });
+
+        TextEntry::macro('currencyWithConversion', function (string | Closure | null $currency = null): static {
+            $currency ??= CurrencyAccessor::getDefaultCurrency();
+
+            $this->formatStateUsing(static function (TextEntry $entry, $state) use ($currency): ?string {
+                if (blank($state)) {
+                    return null;
+                }
+
+                $currency = $entry->evaluate($currency);
+
+                return CurrencyConverter::formatToMoney($state, $currency);
+            });
+
+            $this->helperText(static function (TextEntry $entry, $state) use ($currency): ?string {
+                if (blank($state)) {
+                    return null;
+                }
+
+                $oldCurrency = $entry->evaluate($currency);
+                $newCurrency = CurrencyAccessor::getDefaultCurrency();
+
+                if ($oldCurrency === $newCurrency) {
+                    return null;
+                }
+
+                $balanceInCents = CurrencyConverter::convertToCents($state, $oldCurrency);
+                $convertedBalanceInCents = CurrencyConverter::convertBalance($balanceInCents, $oldCurrency, $newCurrency);
+
+                return CurrencyConverter::formatCentsToMoney($convertedBalanceInCents, $newCurrency, true);
+            });
 
             return $this;
         });

app/Utilities/RateCalculator.php

+<?php
+
+namespace App\Utilities;
+
+use App\Enums\Setting\NumberFormat;
+use App\Models\Setting\Localization;
+
+class RateCalculator
+{
+    public const PRECISION = 4;
+
+    public const SCALING_FACTOR = 10 ** self::PRECISION;
+
+    public const PERCENTAGE_SCALING_FACTOR = self::SCALING_FACTOR * 100;
+
+    public static function calculatePercentage(int $value, int $scaledRate): int
+    {
+        return (int) round(($value * $scaledRate) / self::PERCENTAGE_SCALING_FACTOR);
+    }
+
+    public static function scaledRateToDecimal(int $scaledRate): float
+    {
+        return $scaledRate / self::PERCENTAGE_SCALING_FACTOR;
+    }
+
+    public static function decimalToScaledRate(float $decimalRate): int
+    {
+        return (int) round($decimalRate * self::PERCENTAGE_SCALING_FACTOR);
+    }
+
+    public static function parseLocalizedRate(string $value): int
+    {
+        $format = Localization::firstOrFail()->number_format->value;
+        [$decimalMark, $thousandsSeparator] = NumberFormat::from($format)->getFormattingParameters();
+
+        $floatValue = (float) str_replace([$thousandsSeparator, $decimalMark], ['', '.'], $value);
+
+        return (int) round($floatValue * self::SCALING_FACTOR);
+    }
+
+    public static function formatScaledRate(int $scaledRate): string
+    {
+        $format = Localization::firstOrFail()->number_format->value;
+        [$decimalMark, $thousandsSeparator] = NumberFormat::from($format)->getFormattingParameters();
+
+        $percentageValue = $scaledRate / self::SCALING_FACTOR;
+
+        $formatted = number_format($percentageValue, self::PRECISION, $decimalMark, $thousandsSeparator);
+        $formatted = rtrim($formatted, '0');
+
+        return rtrim($formatted, $decimalMark);
+    }
+}

app/View/Models/BillTotalViewModel.php

-<?php
-
-namespace App\View\Models;
-
-use App\Enums\Accounting\AdjustmentComputation;
-use App\Enums\Accounting\DocumentDiscountMethod;
-use App\Models\Accounting\Adjustment;
-use App\Models\Accounting\Bill;
-use App\Utilities\Currency\CurrencyConverter;
-
-class BillTotalViewModel
-{
-    public function __construct(
-        public ?Bill $bill,
-        public ?array $data = null
-    ) {}
-
-    public function buildViewData(): array
-    {
-        $lineItems = collect($this->data['lineItems'] ?? []);
-
-        $subtotal = $lineItems->sum(static function ($item) {
-            $quantity = max((float) ($item['quantity'] ?? 0), 0);
-            $unitPrice = max((float) ($item['unit_price'] ?? 0), 0);
-
-            return $quantity * $unitPrice;
-        });
-
-        $taxTotal = $lineItems->reduce(function ($carry, $item) {
-            $quantity = max((float) ($item['quantity'] ?? 0), 0);
-            $unitPrice = max((float) ($item['unit_price'] ?? 0), 0);
-            $purchaseTaxes = $item['purchaseTaxes'] ?? [];
-            $lineTotal = $quantity * $unitPrice;
-
-            $taxAmount = Adjustment::whereIn('id', $purchaseTaxes)
-                ->pluck('rate')
-                ->sum(fn ($rate) => $lineTotal * ($rate / 100));
-
-            return $carry + $taxAmount;
-        }, 0);
-
-        // Calculate discount based on method
-        $discountMethod = DocumentDiscountMethod::parse($this->data['discount_method']) ?? DocumentDiscountMethod::PerLineItem;
-
-        if ($discountMethod->isPerLineItem()) {
-            $discountTotal = $lineItems->reduce(function ($carry, $item) {
-                $quantity = max((float) ($item['quantity'] ?? 0), 0);
-                $unitPrice = max((float) ($item['unit_price'] ?? 0), 0);
-                $purchaseDiscounts = $item['purchaseDiscounts'] ?? [];
-                $lineTotal = $quantity * $unitPrice;
-
-                $discountAmount = Adjustment::whereIn('id', $purchaseDiscounts)
-                    ->pluck('rate')
-                    ->sum(fn ($rate) => $lineTotal * ($rate / 100));
-
-                return $carry + $discountAmount;
-            }, 0);
-        } else {
-            $discountComputation = AdjustmentComputation::parse($this->data['discount_computation']) ?? AdjustmentComputation::Percentage;
-            $discountRate = (float) ($this->data['discount_rate'] ?? 0);
-
-            if ($discountComputation->isPercentage()) {
-                $discountTotal = $subtotal * ($discountRate / 100);
-            } else {
-                $discountTotal = $discountRate;
-            }
-        }
-
-        $grandTotal = $subtotal + ($taxTotal - $discountTotal);
-
-        return [
-            'subtotal' => CurrencyConverter::formatToMoney($subtotal),
-            'taxTotal' => CurrencyConverter::formatToMoney($taxTotal),
-            'discountTotal' => CurrencyConverter::formatToMoney($discountTotal),
-            'grandTotal' => CurrencyConverter::formatToMoney($grandTotal),
-        ];
-    }
-}

app/View/Models/DocumentTotalViewModel.php

+<?php
+
+namespace App\View\Models;
+
+use App\Enums\Accounting\AdjustmentComputation;
+use App\Enums\Accounting\DocumentDiscountMethod;
+use App\Enums\Accounting\DocumentType;
+use App\Models\Accounting\Adjustment;
+use App\Utilities\Currency\CurrencyAccessor;
+use App\Utilities\Currency\CurrencyConverter;
+use App\Utilities\RateCalculator;
+use Illuminate\Support\Number;
+
+class DocumentTotalViewModel
+{
+    public function __construct(
+        public ?array $data,
+        public DocumentType $documentType = DocumentType::Invoice,
+    ) {}
+
+    public function buildViewData(): array
+    {
+        $currencyCode = $this->data['currency_code'] ?? CurrencyAccessor::getDefaultCurrency();
+        $defaultCurrencyCode = CurrencyAccessor::getDefaultCurrency();
+
+        $lineItems = collect($this->data['lineItems'] ?? []);
+
+        $subtotalInCents = $lineItems->sum(fn ($item) => $this->calculateLineSubtotalInCents($item, $currencyCode));
+
+        $taxTotalInCents = $this->calculateAdjustmentsTotalInCents($lineItems, $this->documentType->getTaxKey(), $currencyCode);
+        $discountTotalInCents = $this->calculateDiscountTotalInCents($lineItems, $subtotalInCents, $currencyCode);
+
+        $grandTotalInCents = $subtotalInCents + ($taxTotalInCents - $discountTotalInCents);
+
+        $conversionMessage = $this->buildConversionMessage($grandTotalInCents, $currencyCode, $defaultCurrencyCode);
+
+        return [
+            'subtotal' => CurrencyConverter::formatCentsToMoney($subtotalInCents, $currencyCode),
+            'taxTotal' => CurrencyConverter::formatCentsToMoney($taxTotalInCents, $currencyCode),
+            'discountTotal' => CurrencyConverter::formatCentsToMoney($discountTotalInCents, $currencyCode),
+            'grandTotal' => CurrencyConverter::formatCentsToMoney($grandTotalInCents, $currencyCode),
+            'conversionMessage' => $conversionMessage,
+        ];
+    }
+
+    private function calculateLineSubtotalInCents(array $item, string $currencyCode): int
+    {
+        $quantity = max((float) ($item['quantity'] ?? 0), 0);
+        $unitPrice = max((float) ($item['unit_price'] ?? 0), 0);
+
+        $subtotal = $quantity * $unitPrice;
+
+        return CurrencyConverter::convertToCents($subtotal, $currencyCode);
+    }
+
+    private function calculateAdjustmentsTotalInCents($lineItems, string $key, string $currencyCode): int
+    {
+        return $lineItems->reduce(function ($carry, $item) use ($key, $currencyCode) {
+            $quantity = max((float) ($item['quantity'] ?? 0), 0);
+            $unitPrice = max((float) ($item['unit_price'] ?? 0), 0);
+            $adjustmentIds = $item[$key] ?? [];
+            $lineTotal = $quantity * $unitPrice;
+
+            $lineTotalInCents = CurrencyConverter::convertToCents($lineTotal, $currencyCode);
+
+            $adjustmentTotal = Adjustment::whereIn('id', $adjustmentIds)
+                ->get()
+                ->sum(function (Adjustment $adjustment) use ($lineTotalInCents) {
+                    if ($adjustment->computation->isPercentage()) {
+                        return RateCalculator::calculatePercentage($lineTotalInCents, $adjustment->getRawOriginal('rate'));
+                    } else {
+                        return $adjustment->getRawOriginal('rate');
+                    }
+                });
+
+            return $carry + $adjustmentTotal;
+        }, 0);
+    }
+
+    private function calculateDiscountTotalInCents($lineItems, int $subtotalInCents, string $currencyCode): int
+    {
+        $discountMethod = DocumentDiscountMethod::parse($this->data['discount_method']) ?? DocumentDiscountMethod::PerLineItem;
+
+        if ($discountMethod->isPerLineItem()) {
+            return $this->calculateAdjustmentsTotalInCents($lineItems, $this->documentType->getDiscountKey(), $currencyCode);
+        }
+
+        $discountComputation = AdjustmentComputation::parse($this->data['discount_computation']) ?? AdjustmentComputation::Percentage;
+        $discountRate = blank($this->data['discount_rate']) ? '0' : $this->data['discount_rate'];
+
+        if ($discountComputation->isPercentage()) {
+            $scaledDiscountRate = RateCalculator::parseLocalizedRate($discountRate);
+
+            return RateCalculator::calculatePercentage($subtotalInCents, $scaledDiscountRate);
+        }
+
+        if (! CurrencyConverter::isValidAmount($discountRate)) {
+            $discountRate = '0';
+        }
+
+        return CurrencyConverter::convertToCents($discountRate, $currencyCode);
+    }
+
+    private function buildConversionMessage(int $grandTotalInCents, string $currencyCode, string $defaultCurrencyCode): ?string
+    {
+        if ($currencyCode === $defaultCurrencyCode) {
+            return null;
+        }
+
+        $rate = currency($currencyCode)->getRate();
+        $indirectRate = 1 / $rate;
+
+        $convertedTotalInCents = CurrencyConverter::convertBalance($grandTotalInCents, $currencyCode, $defaultCurrencyCode);
+
+        $formattedRate = Number::format($indirectRate, maxPrecision: 10);
+
+        return sprintf(
+            'Currency conversion: %s (%s) at an exchange rate of 1 %s = %s %s',
+            CurrencyConverter::formatCentsToMoney($convertedTotalInCents, $defaultCurrencyCode),
+            $defaultCurrencyCode,
+            $currencyCode,
+            $formattedRate,
+            $defaultCurrencyCode
+        );
+    }
+}

app/View/Models/InvoiceTotalViewModel.php

-<?php
-
-namespace App\View\Models;
-
-use App\Enums\Accounting\AdjustmentComputation;
-use App\Enums\Accounting\DocumentDiscountMethod;
-use App\Models\Accounting\Adjustment;
-use App\Models\Accounting\Invoice;
-use App\Utilities\Currency\CurrencyConverter;
-
-class InvoiceTotalViewModel
-{
-    public function __construct(
-        public ?Invoice $invoice,
-        public ?array $data = null
-    ) {}
-
-    public function buildViewData(): array
-    {
-        $lineItems = collect($this->data['lineItems'] ?? []);
-
-        $subtotal = $lineItems->sum(static function ($item) {
-            $quantity = max((float) ($item['quantity'] ?? 0), 0);
-            $unitPrice = max((float) ($item['unit_price'] ?? 0), 0);
-
-            return $quantity * $unitPrice;
-        });
-
-        $taxTotal = $lineItems->reduce(function ($carry, $item) {
-            $quantity = max((float) ($item['quantity'] ?? 0), 0);
-            $unitPrice = max((float) ($item['unit_price'] ?? 0), 0);
-            $salesTaxes = $item['salesTaxes'] ?? [];
-            $lineTotal = $quantity * $unitPrice;
-
-            $taxAmount = Adjustment::whereIn('id', $salesTaxes)
-                ->pluck('rate')
-                ->sum(fn ($rate) => $lineTotal * ($rate / 100));
-
-            return $carry + $taxAmount;
-        }, 0);
-
-        // Calculate discount based on method
-        $discountMethod = DocumentDiscountMethod::parse($this->data['discount_method']) ?? DocumentDiscountMethod::PerLineItem;
-
-        if ($discountMethod->isPerLineItem()) {
-            $discountTotal = $lineItems->reduce(function ($carry, $item) {
-                $quantity = max((float) ($item['quantity'] ?? 0), 0);
-                $unitPrice = max((float) ($item['unit_price'] ?? 0), 0);
-                $salesDiscounts = $item['salesDiscounts'] ?? [];
-                $lineTotal = $quantity * $unitPrice;
-
-                $discountAmount = Adjustment::whereIn('id', $salesDiscounts)
-                    ->pluck('rate')
-                    ->sum(fn ($rate) => $lineTotal * ($rate / 100));
-
-                return $carry + $discountAmount;
-            }, 0);
-        } else {
-            $discountComputation = AdjustmentComputation::parse($this->data['discount_computation']) ?? AdjustmentComputation::Percentage;
-            $discountRate = (float) ($this->data['discount_rate'] ?? 0);
-
-            if ($discountComputation->isPercentage()) {
-                $discountTotal = $subtotal * ($discountRate / 100);
-            } else {
-                $discountTotal = $discountRate;
-            }
-        }
-
-        $grandTotal = $subtotal + ($taxTotal - $discountTotal);
-
-        return [
-            'subtotal' => CurrencyConverter::formatToMoney($subtotal),
-            'taxTotal' => CurrencyConverter::formatToMoney($taxTotal),
-            'discountTotal' => CurrencyConverter::formatToMoney($discountTotal),
-            'grandTotal' => CurrencyConverter::formatToMoney($grandTotal),
-        ];
-    }
-}

composer.json

         "andrewdwallo/transmatic": "^1.1",
         "awcodes/filament-table-repeater": "^3.0",
         "barryvdh/laravel-snappy": "^1.0",
-        "filament/filament": "v3.2.129",
+        "filament/filament": "^3.2",
         "guava/filament-clusters": "^1.1",
         "guzzlehttp/guzzle": "^7.8",
         "jaocero/radio-deck": "^1.2",

composer.lock

         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "7301f370a98e2573adf4e6b4e7ab4a8e",
+    "content-hash": "a04479d57fe01a2694ad92a8901363ea",
     "packages": [
         {
             "name": "akaunting/laravel-money",
         },
         {
             "name": "aws/aws-sdk-php",
-            "version": "3.334.6",
+            "version": "3.336.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/aws/aws-sdk-php.git",
-                "reference": "2b0be3aded849d3b7bb0b53ea3295c7cecdeeee7"
+                "reference": "5a62003bf183e32da038056a4b9077c27224e034"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/aws/aws-sdk-php/zipball/2b0be3aded849d3b7bb0b53ea3295c7cecdeeee7",
-                "reference": "2b0be3aded849d3b7bb0b53ea3295c7cecdeeee7",
+                "url": "https://api.github.com/repos/aws/aws-sdk-php/zipball/5a62003bf183e32da038056a4b9077c27224e034",
+                "reference": "5a62003bf183e32da038056a4b9077c27224e034",
                 "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.334.6"
+                "source": "https://github.com/aws/aws-sdk-php/tree/3.336.0"
             },
-            "time": "2024-12-13T19:18:29+00:00"
+            "time": "2024-12-18T19:04:32+00:00"
         },
         {
             "name": "aws/aws-sdk-php-laravel",
         },
         {
             "name": "filament/actions",
-            "version": "v3.2.129",
+            "version": "v3.2.131",
             "source": {
                 "type": "git",
                 "url": "https://github.com/filamentphp/actions.git",
-                "reference": "1ee8b0a890b53e8b0b341134d3ba9bdaeee294d3"
+                "reference": "8d9ceaf392eeff55fd335f5169d14f84af8c325e"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/filamentphp/actions/zipball/1ee8b0a890b53e8b0b341134d3ba9bdaeee294d3",
-                "reference": "1ee8b0a890b53e8b0b341134d3ba9bdaeee294d3",
+                "url": "https://api.github.com/repos/filamentphp/actions/zipball/8d9ceaf392eeff55fd335f5169d14f84af8c325e",
+                "reference": "8d9ceaf392eeff55fd335f5169d14f84af8c325e",
                 "shasum": ""
             },
             "require": {
                 "issues": "https://github.com/filamentphp/filament/issues",
                 "source": "https://github.com/filamentphp/filament"
             },
-            "time": "2024-12-05T08:56:37+00:00"
+            "time": "2024-12-17T13:03:16+00:00"
         },
         {
             "name": "filament/filament",
-            "version": "v3.2.129",
+            "version": "v3.2.131",
             "source": {
                 "type": "git",
                 "url": "https://github.com/filamentphp/panels.git",
-                "reference": "9a327a54dec24e0b12c437ef799828f492cb882a"
+                "reference": "21febddcc6720b250b41386805a8dbd1deef2c56"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/filamentphp/panels/zipball/9a327a54dec24e0b12c437ef799828f492cb882a",
-                "reference": "9a327a54dec24e0b12c437ef799828f492cb882a",
+                "url": "https://api.github.com/repos/filamentphp/panels/zipball/21febddcc6720b250b41386805a8dbd1deef2c56",
+                "reference": "21febddcc6720b250b41386805a8dbd1deef2c56",
                 "shasum": ""
             },
             "require": {
                 "issues": "https://github.com/filamentphp/filament/issues",
                 "source": "https://github.com/filamentphp/filament"
             },
-            "time": "2024-12-11T09:05:49+00:00"
+            "time": "2024-12-17T13:03:11+00:00"
         },
         {
             "name": "filament/forms",
-            "version": "v3.2.129",
+            "version": "v3.2.131",
             "source": {
                 "type": "git",
                 "url": "https://github.com/filamentphp/forms.git",
-                "reference": "e6133bdc03de05dfe23eac386b49e51093338883"
+                "reference": "72429b0df9c3d123273dd51ba62b764e2114697c"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/filamentphp/forms/zipball/e6133bdc03de05dfe23eac386b49e51093338883",
-                "reference": "e6133bdc03de05dfe23eac386b49e51093338883",
+                "url": "https://api.github.com/repos/filamentphp/forms/zipball/72429b0df9c3d123273dd51ba62b764e2114697c",
+                "reference": "72429b0df9c3d123273dd51ba62b764e2114697c",
                 "shasum": ""
             },
             "require": {
                 "issues": "https://github.com/filamentphp/filament/issues",
                 "source": "https://github.com/filamentphp/filament"
             },
-            "time": "2024-12-11T09:05:38+00:00"
+            "time": "2024-12-17T13:03:11+00:00"
         },
         {
             "name": "filament/infolists",
-            "version": "v3.2.129",
+            "version": "v3.2.131",
             "source": {
                 "type": "git",
                 "url": "https://github.com/filamentphp/infolists.git",
-                "reference": "0db994330e7fe21a9684256ea1fc34fee916a8d6"
+                "reference": "15c200a3172b88a6247ff4b7230f69982d848194"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/filamentphp/infolists/zipball/0db994330e7fe21a9684256ea1fc34fee916a8d6",
-                "reference": "0db994330e7fe21a9684256ea1fc34fee916a8d6",
+                "url": "https://api.github.com/repos/filamentphp/infolists/zipball/15c200a3172b88a6247ff4b7230f69982d848194",
+                "reference": "15c200a3172b88a6247ff4b7230f69982d848194",
                 "shasum": ""
             },
             "require": {
                 "issues": "https://github.com/filamentphp/filament/issues",
                 "source": "https://github.com/filamentphp/filament"
             },
-            "time": "2024-12-11T09:05:38+00:00"
+            "time": "2024-12-17T13:03:14+00:00"
         },
         {
             "name": "filament/notifications",
-            "version": "v3.2.129",
+            "version": "v3.2.131",
             "source": {
                 "type": "git",
                 "url": "https://github.com/filamentphp/notifications.git",
         },
         {
             "name": "filament/support",
-            "version": "v3.2.129",
+            "version": "v3.2.131",
             "source": {
                 "type": "git",
                 "url": "https://github.com/filamentphp/support.git",
-                "reference": "e8aed9684d5c58ff7dde9517c7f1af44d575d871"
+                "reference": "ddc16d8da50d73f7300671b70c9dcb942d845d9d"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/filamentphp/support/zipball/e8aed9684d5c58ff7dde9517c7f1af44d575d871",
-                "reference": "e8aed9684d5c58ff7dde9517c7f1af44d575d871",
+                "url": "https://api.github.com/repos/filamentphp/support/zipball/ddc16d8da50d73f7300671b70c9dcb942d845d9d",
+                "reference": "ddc16d8da50d73f7300671b70c9dcb942d845d9d",
                 "shasum": ""
             },
             "require": {
                 "issues": "https://github.com/filamentphp/filament/issues",
                 "source": "https://github.com/filamentphp/filament"
             },
-            "time": "2024-12-11T09:05:54+00:00"
+            "time": "2024-12-17T13:03:15+00:00"
         },
         {
             "name": "filament/tables",
-            "version": "v3.2.129",
+            "version": "v3.2.131",
             "source": {
                 "type": "git",
                 "url": "https://github.com/filamentphp/tables.git",
-                "reference": "acdec73ae82961654a52a22ed9f53207cfee2ef8"
+                "reference": "224aea12a4a4cfcd158b53df94cdd190f8226cac"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/filamentphp/tables/zipball/acdec73ae82961654a52a22ed9f53207cfee2ef8",
-                "reference": "acdec73ae82961654a52a22ed9f53207cfee2ef8",
+                "url": "https://api.github.com/repos/filamentphp/tables/zipball/224aea12a4a4cfcd158b53df94cdd190f8226cac",
+                "reference": "224aea12a4a4cfcd158b53df94cdd190f8226cac",
                 "shasum": ""
             },
             "require": {
                 "issues": "https://github.com/filamentphp/filament/issues",
                 "source": "https://github.com/filamentphp/filament"
             },
-            "time": "2024-12-11T09:05:54+00:00"
+            "time": "2024-12-17T13:03:09+00:00"
         },
         {
             "name": "filament/widgets",
-            "version": "v3.2.129",
+            "version": "v3.2.131",
             "source": {
                 "type": "git",
                 "url": "https://github.com/filamentphp/widgets.git",
-                "reference": "6de1c84d71168fd1c6a5b1ae1e1b4ec5ee4b6f55"
+                "reference": "869a419fe42e2cf1b9461f2d1e702e2fcad030ae"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/filamentphp/widgets/zipball/6de1c84d71168fd1c6a5b1ae1e1b4ec5ee4b6f55",
-                "reference": "6de1c84d71168fd1c6a5b1ae1e1b4ec5ee4b6f55",
+                "url": "https://api.github.com/repos/filamentphp/widgets/zipball/869a419fe42e2cf1b9461f2d1e702e2fcad030ae",
+                "reference": "869a419fe42e2cf1b9461f2d1e702e2fcad030ae",
                 "shasum": ""
             },
             "require": {
                 "issues": "https://github.com/filamentphp/filament/issues",
                 "source": "https://github.com/filamentphp/filament"
             },
-            "time": "2024-11-27T16:52:29+00:00"
+            "time": "2024-12-17T13:03:07+00:00"
         },
         {
             "name": "firebase/php-jwt",
         },
         {
             "name": "laravel/framework",
-            "version": "v11.35.1",
+            "version": "v11.36.1",
             "source": {
                 "type": "git",
                 "url": "https://github.com/laravel/framework.git",
-                "reference": "dcfa130ede1a6fa4343dc113410963e791ad34fb"
+                "reference": "df06f5163f4550641fdf349ebc04916a61135a64"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/laravel/framework/zipball/dcfa130ede1a6fa4343dc113410963e791ad34fb",
-                "reference": "dcfa130ede1a6fa4343dc113410963e791ad34fb",
+                "url": "https://api.github.com/repos/laravel/framework/zipball/df06f5163f4550641fdf349ebc04916a61135a64",
+                "reference": "df06f5163f4550641fdf349ebc04916a61135a64",
                 "shasum": ""
             },
             "require": {
                 "guzzlehttp/uri-template": "^1.0",
                 "laravel/prompts": "^0.1.18|^0.2.0|^0.3.0",
                 "laravel/serializable-closure": "^1.3|^2.0",
-                "league/commonmark": "^2.2.1",
+                "league/commonmark": "^2.6",
                 "league/flysystem": "^3.25.1",
                 "league/flysystem-local": "^3.25.1",
                 "league/uri": "^7.5.1",
                 "symfony/console": "^7.0.3",
                 "symfony/error-handler": "^7.0.3",
                 "symfony/finder": "^7.0.3",
-                "symfony/http-foundation": "^7.0.3",
+                "symfony/http-foundation": "^7.2.0",
                 "symfony/http-kernel": "^7.0.3",
                 "symfony/mailer": "^7.0.3",
                 "symfony/mime": "^7.0.3",
                 "issues": "https://github.com/laravel/framework/issues",
                 "source": "https://github.com/laravel/framework"
             },
-            "time": "2024-12-12T18:25:58+00:00"
+            "time": "2024-12-17T22:32:08+00:00"
         },
         {
             "name": "laravel/prompts",
         },
         {
             "name": "laravel/sanctum",
-            "version": "v4.0.6",
+            "version": "v4.0.7",
             "source": {
                 "type": "git",
                 "url": "https://github.com/laravel/sanctum.git",
-                "reference": "9e069e36d90b1e1f41886efa0fe9800a6b354694"
+                "reference": "698064236a46df016e64a7eb059b1414e0b281df"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/laravel/sanctum/zipball/9e069e36d90b1e1f41886efa0fe9800a6b354694",
-                "reference": "9e069e36d90b1e1f41886efa0fe9800a6b354694",
+                "url": "https://api.github.com/repos/laravel/sanctum/zipball/698064236a46df016e64a7eb059b1414e0b281df",
+                "reference": "698064236a46df016e64a7eb059b1414e0b281df",
                 "shasum": ""
             },
             "require": {
                 "issues": "https://github.com/laravel/sanctum/issues",
                 "source": "https://github.com/laravel/sanctum"
             },
-            "time": "2024-11-26T21:18:33+00:00"
+            "time": "2024-12-11T16:40:21+00:00"
         },
         {
             "name": "laravel/serializable-closure",
-            "version": "v2.0.0",
+            "version": "v2.0.1",
             "source": {
                 "type": "git",
                 "url": "https://github.com/laravel/serializable-closure.git",
-                "reference": "0d8d3d8086984996df86596a86dea60398093a81"
+                "reference": "613b2d4998f85564d40497e05e89cb6d9bd1cbe8"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/laravel/serializable-closure/zipball/0d8d3d8086984996df86596a86dea60398093a81",
-                "reference": "0d8d3d8086984996df86596a86dea60398093a81",
+                "url": "https://api.github.com/repos/laravel/serializable-closure/zipball/613b2d4998f85564d40497e05e89cb6d9bd1cbe8",
+                "reference": "613b2d4998f85564d40497e05e89cb6d9bd1cbe8",
                 "shasum": ""
             },
             "require": {
                 "issues": "https://github.com/laravel/serializable-closure/issues",
                 "source": "https://github.com/laravel/serializable-closure"
             },
-            "time": "2024-11-19T01:38:44+00:00"
+            "time": "2024-12-16T15:26:28+00:00"
         },
         {
             "name": "laravel/socialite",
-            "version": "v5.16.0",
+            "version": "v5.16.1",
             "source": {
                 "type": "git",
                 "url": "https://github.com/laravel/socialite.git",
-                "reference": "40a2dc98c53d9dc6d55eadb0d490d3d72b73f1bf"
+                "reference": "4e5be83c0b3ecf81b2ffa47092e917d1f79dce71"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/laravel/socialite/zipball/40a2dc98c53d9dc6d55eadb0d490d3d72b73f1bf",
-                "reference": "40a2dc98c53d9dc6d55eadb0d490d3d72b73f1bf",
+                "url": "https://api.github.com/repos/laravel/socialite/zipball/4e5be83c0b3ecf81b2ffa47092e917d1f79dce71",
+                "reference": "4e5be83c0b3ecf81b2ffa47092e917d1f79dce71",
                 "shasum": ""
             },
             "require": {
                 "illuminate/contracts": "^6.0|^7.0|^8.0|^9.0|^10.0|^11.0",
                 "illuminate/http": "^6.0|^7.0|^8.0|^9.0|^10.0|^11.0",
                 "illuminate/support": "^6.0|^7.0|^8.0|^9.0|^10.0|^11.0",
-                "league/oauth1-client": "^1.10.1",
+                "league/oauth1-client": "^1.11",
                 "php": "^7.2|^8.0",
                 "phpseclib/phpseclib": "^3.0"
             },
                 "issues": "https://github.com/laravel/socialite/issues",
                 "source": "https://github.com/laravel/socialite"
             },
-            "time": "2024-09-03T09:46:57+00:00"
+            "time": "2024-12-11T16:43:51+00:00"
         },
         {
             "name": "laravel/tinker",
         },
         {
             "name": "league/csv",
-            "version": "9.20.0",
+            "version": "9.20.1",
             "source": {
                 "type": "git",
                 "url": "https://github.com/thephpleague/csv.git",
-                "reference": "553579df208641ada6ffb450b3a151e2fcfa4f31"
+                "reference": "491d1e79e973a7370c7571dc0fe4a7241f4936ee"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/thephpleague/csv/zipball/553579df208641ada6ffb450b3a151e2fcfa4f31",
-                "reference": "553579df208641ada6ffb450b3a151e2fcfa4f31",
+                "url": "https://api.github.com/repos/thephpleague/csv/zipball/491d1e79e973a7370c7571dc0fe4a7241f4936ee",
+                "reference": "491d1e79e973a7370c7571dc0fe4a7241f4936ee",
                 "shasum": ""
             },
             "require": {
                     "type": "github"
                 }
             ],
-            "time": "2024-12-13T15:49:27+00:00"
+            "time": "2024-12-18T10:11:15+00:00"
         },
         {
             "name": "league/flysystem",
         },
         {
             "name": "matomo/device-detector",
-            "version": "6.4.1",
+            "version": "6.4.2",
             "source": {
                 "type": "git",
                 "url": "https://github.com/matomo-org/device-detector.git",
-                "reference": "0d364e0dd6c177da3c24cd4049178026324fd7ac"
+                "reference": "806e52d214b05ddead1a1d4304c7592f61f95976"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/matomo-org/device-detector/zipball/0d364e0dd6c177da3c24cd4049178026324fd7ac",
-                "reference": "0d364e0dd6c177da3c24cd4049178026324fd7ac",
+                "url": "https://api.github.com/repos/matomo-org/device-detector/zipball/806e52d214b05ddead1a1d4304c7592f61f95976",
+                "reference": "806e52d214b05ddead1a1d4304c7592f61f95976",
                 "shasum": ""
             },
             "require": {
                 "source": "https://github.com/matomo-org/matomo",
                 "wiki": "https://dev.matomo.org/"
             },
-            "time": "2024-09-24T13:50:04+00:00"
+            "time": "2024-12-16T16:38:01+00:00"
         },
         {
             "name": "monolog/monolog",
         },
         {
             "name": "openspout/openspout",
-            "version": "v4.28.2",
+            "version": "v4.28.3",
             "source": {
                 "type": "git",
                 "url": "https://github.com/openspout/openspout.git",
-                "reference": "d6dd654b5db502f28c5773edfa785b516745a142"
+                "reference": "12b5eddcc230a97a9a67a722ad75c247e1a16750"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/openspout/openspout/zipball/d6dd654b5db502f28c5773edfa785b516745a142",
-                "reference": "d6dd654b5db502f28c5773edfa785b516745a142",
+                "url": "https://api.github.com/repos/openspout/openspout/zipball/12b5eddcc230a97a9a67a722ad75c247e1a16750",
+                "reference": "12b5eddcc230a97a9a67a722ad75c247e1a16750",
                 "shasum": ""
             },
             "require": {
                 "phpstan/phpstan": "^2.0.3",
                 "phpstan/phpstan-phpunit": "^2.0.1",
                 "phpstan/phpstan-strict-rules": "^2",
-                "phpunit/phpunit": "^11.4.4"
+                "phpunit/phpunit": "^11.5.0"
             },
             "suggest": {
                 "ext-iconv": "To handle non UTF-8 CSV files (if \"php-mbstring\" is not already installed or is too limited)",
             ],
             "support": {
                 "issues": "https://github.com/openspout/openspout/issues",
-                "source": "https://github.com/openspout/openspout/tree/v4.28.2"
+                "source": "https://github.com/openspout/openspout/tree/v4.28.3"
             },
             "funding": [
                 {
                     "type": "github"
                 }
             ],
-            "time": "2024-12-06T06:17:37+00:00"
+            "time": "2024-12-17T11:28:11+00:00"
         },
         {
             "name": "paragonie/constant_time_encoding",
             "type": "library",
             "extra": {
                 "thanks": {
-                    "name": "symfony/polyfill",
-                    "url": "https://github.com/symfony/polyfill"
+                    "url": "https://github.com/symfony/polyfill",
+                    "name": "symfony/polyfill"
                 }
             },
             "autoload": {

config/money.php

             'symbol' => 'Fr.',
             'symbol_first' => true,
             'decimal_mark' => '.',
-            'thousands_separator' => ',',
+            'thousands_separator' => "'",
         ],
 
         'MOP' => [

package-lock.json

             }
         },
         "node_modules/caniuse-lite": {
-            "version": "1.0.30001688",
-            "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001688.tgz",
-            "integrity": "sha512-Nmqpru91cuABu/DTCXbM2NSRHzM2uVHfPnhJ/1zEAJx/ILBRVmz3pzH4N7DZqbdG0gWClsCC05Oj0mJ/1AWMbA==",
+            "version": "1.0.30001689",
+            "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001689.tgz",
+            "integrity": "sha512-CmeR2VBycfa+5/jOfnp/NpWPGd06nf1XYiefUvhXFfZE4GkRc9jv+eGPS4nT558WS/8lYCzV8SlANCIPvbWP1g==",
             "dev": true,
             "funding": [
                 {
             "license": "MIT"
         },
         "node_modules/electron-to-chromium": {
-            "version": "1.5.73",
-            "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.73.tgz",
-            "integrity": "sha512-8wGNxG9tAG5KhGd3eeA0o6ixhiNdgr0DcHWm85XPCphwZgD1lIEoi6t3VERayWao7SF7AAZTw6oARGJeVjH8Kg==",
+            "version": "1.5.74",
+            "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.74.tgz",
+            "integrity": "sha512-ck3//9RC+6oss/1Bh9tiAVFy5vfSKbRHAFh7Z3/eTRkEqJeWgymloShB17Vg3Z4nmDNp35vAd1BZ6CMW4Wt6Iw==",
             "dev": true,
             "license": "ISC"
         },
             }
         },
         "node_modules/jiti": {
-            "version": "1.21.6",
-            "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.6.tgz",
-            "integrity": "sha512-2yTgeWTWzMWkHu6Jp9NKgePDaYHbntiwvYuuJLbbN9vl7DC9DvXKOB2BC3ZZ92D3cvV/aflH0osDfwpHepQ53w==",
+            "version": "1.21.7",
+            "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
+            "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==",
             "dev": true,
             "license": "MIT",
             "bin": {
             }
         },
         "node_modules/tailwindcss": {
-            "version": "3.4.16",
-            "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.16.tgz",
-            "integrity": "sha512-TI4Cyx7gDiZ6r44ewaJmt0o6BrMCT5aK5e0rmJ/G9Xq3w7CX/5VXl/zIPEJZFUK5VEqwByyhqNPycPlvcK4ZNw==",
+            "version": "3.4.17",
+            "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.17.tgz",
+            "integrity": "sha512-w33E2aCvSDP0tW9RZuNXadXlkHXqFzSkQew/aIa2i/Sj8fThxwovwlXHSPXTbAHwEIhBFXAedUhP2tueAKP8Og==",
             "dev": true,
             "license": "MIT",
             "dependencies": {

resources/views/filament/company/resources/sales/invoices/components/invoice-view.blade.php

                         @endif
                     </td>
                     <td class="text-center py-3">{{ $item->quantity }}</td>
-                    <td class="text-right py-3">{{ CurrencyConverter::formatToMoney($item->unit_price) }}</td>
-                    <td class="text-right pr-6 py-3">{{ CurrencyConverter::formatToMoney($item->subtotal) }}</td>
+                    <td class="text-right py-3">{{ CurrencyConverter::formatToMoney($item->unit_price, $invoice->currency_code) }}</td>
+                    <td class="text-right pr-6 py-3">{{ CurrencyConverter::formatToMoney($item->subtotal, $invoice->currency_code) }}</td>
                 </tr>
             @endforeach
             </tbody>
             <tr>
                 <td class="pl-6 py-2" colspan="2"></td>
                 <td class="text-right font-semibold py-2">Subtotal:</td>
-                <td class="text-right pr-6 py-2">{{ CurrencyConverter::formatToMoney($invoice->subtotal) }}</td>
+                <td class="text-right pr-6 py-2">{{ CurrencyConverter::formatToMoney($invoice->subtotal, $invoice->currency_code) }}</td>
             </tr>
             @if($invoice->discount_total)
                 <tr class="text-success-800 dark:text-success-600">
                     <td class="pl-6 py-2" colspan="2"></td>
                     <td class="text-right py-2">Discount:</td>
                     <td class="text-right pr-6 py-2">
-                        ({{ CurrencyConverter::formatToMoney($invoice->discount_total) }})
+                        ({{ CurrencyConverter::formatToMoney($invoice->discount_total, $invoice->currency_code) }})
                     </td>
                 </tr>
             @endif
                 <tr>
                     <td class="pl-6 py-2" colspan="2"></td>
                     <td class="text-right py-2">Tax:</td>
-                    <td class="text-right pr-6 py-2">{{ CurrencyConverter::formatToMoney($invoice->tax_total) }}</td>
+                    <td class="text-right pr-6 py-2">{{ CurrencyConverter::formatToMoney($invoice->tax_total, $invoice->currency_code) }}</td>
                 </tr>
             @endif
             <tr>
                 <td class="pl-6 py-2" colspan="2"></td>
                 <td class="text-right font-semibold border-t py-2">Total:</td>
-                <td class="text-right border-t pr-6 py-2">{{ CurrencyConverter::formatToMoney($invoice->total) }}</td>
+                <td class="text-right border-t pr-6 py-2">{{ CurrencyConverter::formatToMoney($invoice->total, $invoice->currency_code) }}</td>
             </tr>
             <tr>
                 <td class="pl-6 py-2" colspan="2"></td>
                 <td class="text-right font-semibold border-t-4 border-double py-2">Amount Due
                     ({{ $invoice->currency_code }}):
                 </td>
-                <td class="text-right border-t-4 border-double pr-6 py-2">{{ CurrencyConverter::formatToMoney($invoice->amount_due) }}</td>
+                <td class="text-right border-t-4 border-double pr-6 py-2">{{ CurrencyConverter::formatToMoney($invoice->amount_due, $invoice->currency_code) }}</td>
             </tr>
             </tfoot>
         </table>

resources/views/filament/forms/components/bill-totals.blade.php

-@php
-    use App\Enums\Accounting\DocumentDiscountMethod;
-    use App\Utilities\Currency\CurrencyAccessor;
-    use App\View\Models\BillTotalViewModel;
-
-    $data = $this->form->getRawState();
-    $viewModel = new BillTotalViewModel($this->record, $data);
-    extract($viewModel->buildViewData(), EXTR_SKIP);
-
-    $discountMethod = DocumentDiscountMethod::parse($data['discount_method']);
-    $isPerDocumentDiscount = $discountMethod->isPerDocument();
-@endphp
-
-<div class="totals-summary w-full pr-14">
-    <table class="w-full text-right table-fixed">
-        <colgroup>
-            <col class="w-[20%]"> {{-- Items --}}
-            <col class="w-[30%]"> {{-- Description --}}
-            <col class="w-[10%]"> {{-- Quantity --}}
-            <col class="w-[10%]"> {{-- Price --}}
-            <col class="w-[20%]"> {{-- Taxes --}}
-            <col class="w-[10%]"> {{-- Amount --}}
-        </colgroup>
-        <tbody>
-            <tr>
-                <td colspan="4"></td>
-                <td class="text-sm px-4 py-2 font-medium leading-6 text-gray-950 dark:text-white">Subtotal:</td>
-                <td class="text-sm pl-4 py-2 leading-6">{{ $subtotal }}</td>
-            </tr>
-            <tr>
-                <td colspan="4"></td>
-                <td class="text-sm px-4 py-2 font-medium leading-6 text-gray-950 dark:text-white">Taxes:</td>
-                <td class="text-sm pl-4 py-2 leading-6">{{ $taxTotal }}</td>
-            </tr>
-            @if($isPerDocumentDiscount)
-                <tr>
-                    <td colspan="4" class="text-sm px-4 py-2 font-medium leading-6 text-gray-950 dark:text-white text-right">Discount:</td>
-                    <td class="text-sm px-4 py-2">
-                        <div class="flex justify-between space-x-2">
-                            @foreach($getChildComponentContainer()->getComponents() as $component)
-                                <div class="flex-1">{{ $component }}</div>
-                            @endforeach
-                        </div>
-                    </td>
-                    <td class="text-sm pl-4 py-2 leading-6">({{ $discountTotal }})</td>
-                </tr>
-            @else
-                <tr>
-                    <td colspan="4"></td>
-                    <td class="text-sm px-4 py-2 font-medium leading-6 text-gray-950 dark:text-white">Discounts:</td>
-                    <td class="text-sm pl-4 py-2 leading-6">({{ $discountTotal }})</td>
-                </tr>
-            @endif
-            <tr class="font-semibold">
-                <td colspan="4"></td>
-                <td class="text-sm px-4 py-2 font-medium leading-6 text-gray-950 dark:text-white">Total:</td>
-                <td class="text-sm pl-4 py-2 leading-6">{{ $grandTotal }}</td>
-            </tr>
-        </tbody>
-    </table>
-</div>

resources/views/filament/forms/components/document-totals.blade.php

+@php
+    use App\Enums\Accounting\DocumentDiscountMethod;
+    use App\Utilities\Currency\CurrencyAccessor;
+    use App\View\Models\DocumentTotalViewModel;
+
+    $data = $this->form->getRawState();
+    $type = $getType();
+    $viewModel = new DocumentTotalViewModel($data, $type);
+    extract($viewModel->buildViewData(), EXTR_SKIP);
+
+    $discountMethod = DocumentDiscountMethod::parse($data['discount_method']);
+    $isPerDocumentDiscount = $discountMethod->isPerDocument();
+@endphp
+
+<div class="totals-summary w-full sm:pr-14">
+    <table class="w-full text-right table-fixed hidden sm:table">
+        <colgroup>
+            <col class="w-[20%]"> {{-- Items --}}
+            <col class="w-[30%]"> {{-- Description --}}
+            <col class="w-[10%]"> {{-- Quantity --}}
+            <col class="w-[10%]"> {{-- Price --}}
+            <col class="w-[20%]"> {{-- Taxes --}}
+            <col class="w-[10%]"> {{-- Amount --}}
+        </colgroup>
+        <tbody>
+            <tr>
+                <td colspan="4"></td>
+                <td class="text-sm px-4 py-2 font-medium leading-6 text-gray-950 dark:text-white">Subtotal:</td>
+                <td class="text-sm pl-4 py-2 leading-6">{{ $subtotal }}</td>
+            </tr>
+            <tr>
+                <td colspan="4"></td>
+                <td class="text-sm px-4 py-2 font-medium leading-6 text-gray-950 dark:text-white">Taxes:</td>
+                <td class="text-sm pl-4 py-2 leading-6">{{ $taxTotal }}</td>
+            </tr>
+            @if($isPerDocumentDiscount)
+                <tr>
+                    <td colspan="3" class="text-sm px-4 py-2 font-medium leading-6 text-gray-950 dark:text-white text-right">Discount:</td>
+                    <td colspan="2" class="text-sm px-4 py-2">
+                        <div class="flex justify-between space-x-2">
+                            @foreach($getChildComponentContainer()->getComponents() as $component)
+                                <div class="flex-1 text-left">{{ $component }}</div>
+                            @endforeach
+                        </div>
+                    </td>
+                    <td class="text-sm pl-4 py-2 leading-6">({{ $discountTotal }})</td>
+                </tr>
+            @else
+                <tr>
+                    <td colspan="4"></td>
+                    <td class="text-sm px-4 py-2 font-medium leading-6 text-gray-950 dark:text-white">Discounts:</td>
+                    <td class="text-sm pl-4 py-2 leading-6">({{ $discountTotal }})</td>
+                </tr>
+            @endif
+            <tr class="font-semibold">
+                <td colspan="4"></td>
+                <td class="text-sm px-4 py-2 font-medium leading-6 text-gray-950 dark:text-white">Total:</td>
+                <td class="text-sm pl-4 py-2 leading-6">{{ $grandTotal }}</td>
+            </tr>
+            @if($conversionMessage)
+                <tr>
+                    <td colspan="6" class="text-sm pl-4 py-2 leading-6 text-gray-600">
+                        {{ $conversionMessage }}
+                    </td>
+                </tr>
+            @endif
+        </tbody>
+    </table>
+
+    <!-- Mobile View -->
+    <div class="block sm:hidden p-5">
+        <div class="flex flex-col space-y-6">
+            <div class="flex justify-between items-center">
+                <span class="text-sm font-medium text-gray-950 dark:text-white">Subtotal:</span>
+                <span class="text-sm text-gray-950 dark:text-white">{{ $subtotal }}</span>
+            </div>
+            <div class="flex justify-between items-center">
+                <span class="text-sm font-medium text-gray-950 dark:text-white">Taxes:</span>
+                <span class="text-sm text-gray-950 dark:text-white">{{ $taxTotal }}</span>
+            </div>
+            @if($isPerDocumentDiscount)
+                <div class="flex flex-col space-y-2">
+                    <span class="text-sm font-medium text-gray-950 dark:text-white">Discount:</span>
+                    <div class="flex justify-between space-x-2">
+                        @foreach($getChildComponentContainer()->getComponents() as $component)
+                            <div class="w-1/2">{{ $component }}</div>
+                        @endforeach
+                    </div>
+                </div>
+            @else
+                <div class="flex justify-between items-center">
+                    <span class="text-sm font-medium text-gray-950 dark:text-white">Discounts:</span>
+                    <span class="text-sm text-gray-950 dark:text-white">({{ $discountTotal }})</span>
+                </div>
+            @endif
+            <div class="flex justify-between items-center font-semibold">
+                <span class="text-sm font-medium text-gray-950 dark:text-white">Total:</span>
+                <span class="text-sm text-gray-950 dark:text-white">{{ $grandTotal }}</span>
+            </div>
+            @if($conversionMessage)
+                <div class="text-sm text-gray-600">
+                    {{ $conversionMessage }}
+                </div>
+            @endif
+        </div>
+    </div>
+</div>

resources/views/filament/forms/components/invoice-totals.blade.php

-@php
-    use App\Enums\Accounting\DocumentDiscountMethod;
-    use App\Utilities\Currency\CurrencyAccessor;
-    use App\View\Models\InvoiceTotalViewModel;
-
-    $data = $this->form->getRawState();
-    $viewModel = new InvoiceTotalViewModel($this->record, $data);
-    extract($viewModel->buildViewData(), EXTR_SKIP);
-
-    $discountMethod = DocumentDiscountMethod::parse($data['discount_method']);
-    $isPerDocumentDiscount = $discountMethod->isPerDocument();
-@endphp
-
-<div class="totals-summary w-full pr-14">
-    <table class="w-full text-right table-fixed">
-        <colgroup>
-            <col class="w-[20%]"> {{-- Items --}}
-            <col class="w-[30%]"> {{-- Description --}}
-            <col class="w-[10%]"> {{-- Quantity --}}
-            <col class="w-[10%]"> {{-- Price --}}
-            <col class="w-[20%]"> {{-- Taxes --}}
-            <col class="w-[10%]"> {{-- Amount --}}
-        </colgroup>
-        <tbody>
-            <tr>
-                <td colspan="4"></td>
-                <td class="text-sm px-4 py-2 font-medium leading-6 text-gray-950 dark:text-white">Subtotal:</td>
-                <td class="text-sm pl-4 py-2 leading-6">{{ $subtotal }}</td>
-            </tr>
-            <tr>
-                <td colspan="4"></td>
-                <td class="text-sm px-4 py-2 font-medium leading-6 text-gray-950 dark:text-white">Taxes:</td>
-                <td class="text-sm pl-4 py-2 leading-6">{{ $taxTotal }}</td>
-            </tr>
-            @if($isPerDocumentDiscount)
-                <tr>
-                    <td colspan="4" class="text-sm px-4 py-2 font-medium leading-6 text-gray-950 dark:text-white text-right">Discount:</td>
-                    <td class="text-sm px-4 py-2">
-                        <div class="flex justify-between space-x-2">
-                            @foreach($getChildComponentContainer()->getComponents() as $component)
-                                <div class="flex-1">{{ $component }}</div>
-                            @endforeach
-                        </div>
-                    </td>
-                    <td class="text-sm pl-4 py-2 leading-6">({{ $discountTotal }})</td>
-                </tr>
-            @else
-                <tr>
-                    <td colspan="4"></td>
-                    <td class="text-sm px-4 py-2 font-medium leading-6 text-gray-950 dark:text-white">Discounts:</td>
-                    <td class="text-sm pl-4 py-2 leading-6">({{ $discountTotal }})</td>
-                </tr>
-            @endif
-            <tr class="font-semibold">
-                <td colspan="4"></td>
-                <td class="text-sm px-4 py-2 font-medium leading-6 text-gray-950 dark:text-white">Total:</td>
-                <td class="text-sm pl-4 py-2 leading-6">{{ $grandTotal }}</td>
-            </tr>
-        </tbody>
-    </table>
-</div>