wip

app/Filament/Company/Resources/Accounting/BudgetResource.php

                                                 // Calculate the total for this budget item across all periods
                                                 foreach ($periods as $period) {
                                                     $allocation = $record->allocations->firstWhere('period', $period);
-                                                    $total += $allocation ? $allocation->amount : 0;
+                                                    $total += $allocation ? $allocation->getRawOriginal('amount') : 0;
                                                 }
-                                                $component->state($total);
+                                                $component->state(CurrencyConverter::convertCentsToFormatSimple($total));
                                             })
                                             ->dehydrated(false),
 

app/Filament/Company/Resources/Accounting/BudgetResource/Pages/ViewBudget.php

 use Filament\Forms\Form;
 use Filament\Infolists\Infolist;
 use Filament\Resources\Pages\ViewRecord;
+use Filament\Support\Enums\MaxWidth;
 
 class ViewBudget extends ViewRecord
 {
     protected static string $resource = BudgetResource::class;
 
+    public function getMaxContentWidth(): MaxWidth | string | null
+    {
+        return '8xl';
+    }
+
     protected function getHeaderActions(): array
     {
         return [

app/Filament/Company/Resources/Accounting/BudgetResource/RelationManagers/BudgetItemsRelationManager.php

 use App\Filament\Tables\Columns\DeferredTextInputColumn;
 use App\Models\Accounting\BudgetAllocation;
 use App\Models\Accounting\BudgetItem;
+use App\Utilities\Currency\CurrencyConverter;
 use Filament\Notifications\Notification;
 use Filament\Resources\RelationManagers\RelationManager;
+use Filament\Support\RawJs;
 use Filament\Tables\Actions\Action;
+use Filament\Tables\Actions\BulkAction;
+use Filament\Tables\Columns\IconColumn;
+use Filament\Tables\Columns\Summarizers\Summarizer;
 use Filament\Tables\Columns\TextColumn;
+use Filament\Tables\Grouping\Group;
 use Filament\Tables\Table;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Collection;
 use Livewire\Attributes\On;
 
 class BudgetItemsRelationManager extends RelationManager
     // Store changes that are pending
     public array $batchChanges = [];
 
-    // Listen for events from the custom column
-
     #[On('batch-column-changed')]
     public function handleBatchColumnChanged($data): void
     {
-        ray($data);
         // Store the changed value
         $key = "{$data['recordKey']}.{$data['name']}";
         $this->batchChanges[$key] = $data['value'];
     #[On('save-batch-changes')]
     public function saveBatchChanges(): void
     {
-        ray('Saving batch changes');
         foreach ($this->batchChanges as $key => $value) {
             // Parse the composite key
             [$recordKey, $column] = explode('.', $key, 2);
             ->send();
     }
 
+    protected function calculateTotalSum(array $budgetItemIds): int
+    {
+        // Get all applicable periods
+        $periods = BudgetAllocation::whereIn('budget_item_id', $budgetItemIds)
+            ->pluck('period')
+            ->unique()
+            ->values()
+            ->toArray();
+
+        $total = 0;
+
+        // Sum up each period
+        foreach ($periods as $period) {
+            $total += $this->calculatePeriodSum($budgetItemIds, $period);
+        }
+
+        return $total;
+    }
+
+    protected function calculatePeriodSum(array $budgetItemIds, string $period): int
+    {
+        // First get database values
+        $dbTotal = BudgetAllocation::whereIn('budget_item_id', $budgetItemIds)
+            ->where('period', $period)
+            ->sum('amount');
+
+        // Now add any batch changes
+        $batchTotal = 0;
+        foreach ($budgetItemIds as $itemId) {
+            $key = "{$itemId}.allocations_by_period.{$period}";
+            if (isset($this->batchChanges[$key])) {
+                // Get the current value from batch changes
+                $batchValue = CurrencyConverter::convertToCents($this->batchChanges[$key]);
+
+                // Find if there's a current allocation in DB
+                $existingAmount = BudgetAllocation::where('budget_item_id', $itemId)
+                    ->where('period', $period)
+                    ->first()
+                    ->getRawOriginal('amount');
+
+                // Add the difference to our running total
+                $batchTotal += ($batchValue - $existingAmount);
+            }
+        }
+
+        return $dbTotal + $batchTotal;
+    }
+
     public function table(Table $table): Table
     {
         $budget = $this->getOwnerRecord();
             ->values()
             ->toArray();
 
-        ray($this->batchChanges);
-
         return $table
             ->recordTitleAttribute('account_id')
             ->paginated(false)
             ->modifyQueryUsing(
-                fn ($query) => $query->with(['account', 'allocations'])
+                fn (Builder $query) => $query->with(['account', 'allocations'])
             )
             ->headerActions([
                 Action::make('saveBatchChanges')
                     ->color('primary')
                     ->icon('heroicon-o-check-circle'),
             ])
+            ->groups([
+                Group::make('account.category')
+                    ->titlePrefixedWithLabel(false)
+                    ->collapsible(),
+            ])
+            ->defaultGroup('account.category')
+            ->bulkActions([
+                BulkAction::make('clearAllocations')
+                    ->label('Clear Allocations')
+                    ->icon('heroicon-o-trash')
+                    ->color('danger')
+                    ->requiresConfirmation()
+                    ->deselectRecordsAfterCompletion()
+                    ->action(function (Collection $records) use ($periods) {
+                        foreach ($records as $record) {
+                            foreach ($periods as $period) {
+                                $periodKey = "{$record->getKey()}.allocations_by_period.{$period}";
+                                $this->batchChanges[$periodKey] = CurrencyConverter::convertCentsToFormatSimple(0);
+                            }
+
+                            $totalKey = "{$record->getKey()}.total";
+                            $this->batchChanges[$totalKey] = CurrencyConverter::convertCentsToFormatSimple(0);
+                        }
+                    }),
+            ])
             ->columns(array_merge([
                 TextColumn::make('account.name')
                     ->label('Accounts')
-                    ->sortable()
+                    ->limit(30)
                     ->searchable(),
+                DeferredTextInputColumn::make('total')
+                    ->label('Total')
+                    ->alignRight()
+                    ->mask(RawJs::make('$money($input)'))
+                    ->getStateUsing(function (BudgetItem $record, DeferredTextInputColumn $column) {
+                        if (isset($this->batchChanges["{$record->getKey()}.{$column->getName()}"])) {
+                            return $this->batchChanges["{$record->getKey()}.{$column->getName()}"];
+                        }
+
+                        $total = $record->allocations->sum(function (BudgetAllocation $budgetAllocation) {
+                            return $budgetAllocation->getRawOriginal('amount');
+                        });
+
+                        return CurrencyConverter::convertCentsToFormatSimple($total);
+                    })
+                    ->batchMode()
+                    ->summarize(
+                        Summarizer::make()
+                            ->using(function (\Illuminate\Database\Query\Builder $query) {
+                                $budgetItemIds = $query->pluck('id')->toArray();
+                                $total = $this->calculateTotalSum($budgetItemIds);
+
+                                return CurrencyConverter::convertCentsToFormatSimple($total);
+                            })
+                    ),
+                IconColumn::make('disperseAction')
+                    ->icon('heroicon-m-chevron-double-right')
+                    ->color('primary')
+                    ->label('')
+                    ->default('')
+                    ->action(
+                        Action::make('disperse')
+                            ->label('Disperse')
+                            ->icon('heroicon-m-chevron-double-right')
+                            ->color('primary')
+                            ->iconButton()
+                            ->action(function (BudgetItem $record) use ($periods) {
+                                if (empty($periods)) {
+                                    return;
+                                }
+
+                                $totalKey = "{$record->getKey()}.total";
+                                $totalAmount = $this->batchChanges[$totalKey] ?? null;
+
+                                if (isset($totalAmount)) {
+                                    $totalCents = CurrencyConverter::convertToCents($totalAmount);
+                                } else {
+                                    $totalCents = $record->allocations->sum(function (BudgetAllocation $budgetAllocation) {
+                                        return $budgetAllocation->getRawOriginal('amount');
+                                    });
+                                }
+
+                                $numPeriods = count($periods);
+
+                                if ($numPeriods === 0) {
+                                    return;
+                                }
+
+                                if ($totalCents <= 0) {
+                                    foreach ($periods as $period) {
+                                        $periodKey = "{$record->getKey()}.allocations_by_period.{$period}";
+                                        $this->batchChanges[$periodKey] = CurrencyConverter::convertCentsToFormatSimple(0);
+                                    }
+
+                                    return;
+                                }
+
+                                $baseAmount = floor($totalCents / $numPeriods);
+                                $remainder = $totalCents - ($baseAmount * $numPeriods);
+
+                                foreach ($periods as $index => $period) {
+                                    $amount = $baseAmount + ($index === 0 ? $remainder : 0);
+                                    $formattedAmount = CurrencyConverter::convertCentsToFormatSimple($amount);
+
+                                    $periodKey = "{$record->getKey()}.allocations_by_period.{$period}";
+                                    $this->batchChanges[$periodKey] = $formattedAmount;
+                                }
+                            }),
+                    ),
             ], collect($periods)->map(
                 fn ($period) => DeferredTextInputColumn::make("allocations_by_period.{$period}")
                     ->label($period)
+                    ->alignRight()
+                    ->mask(RawJs::make('$money($input)'))
+                    ->summarize(
+                        Summarizer::make()
+                            ->label($period)
+                            ->using(function (\Illuminate\Database\Query\Builder $query) use ($period) {
+                                $budgetItemIds = $query->pluck('id')->toArray();
+                                $total = $this->calculatePeriodSum($budgetItemIds, $period);
+
+                                return CurrencyConverter::convertCentsToFormatSimple($total);
+                            })
+                    )
                     ->getStateUsing(function ($record, DeferredTextInputColumn $column) use ($period) {
                         $key = "{$record->getKey()}.{$column->getName()}";
 

app/Models/Accounting/BudgetAllocation.php

 
 namespace App\Models\Accounting;
 
-use App\Casts\DocumentMoneyCast;
+use App\Casts\MoneyCast;
 use App\Concerns\CompanyOwned;
 use App\Enums\Accounting\BudgetIntervalType;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
         'start_date' => 'date',
         'end_date' => 'date',
         'interval_type' => BudgetIntervalType::class,
-        'amount' => DocumentMoneyCast::class,
+        'amount' => MoneyCast::class,
     ];
 
     public function budgetItem(): BelongsTo

composer.lock

         },
         {
             "name": "aws/aws-sdk-php",
-            "version": "3.342.11",
+            "version": "3.342.12",
             "source": {
                 "type": "git",
                 "url": "https://github.com/aws/aws-sdk-php.git",
-                "reference": "e0afed3d0e2c89362f6c9b6bf8f278b04a4858b6"
+                "reference": "29c2c34ddc7ff02ec865355fc235c78acd095fcf"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/aws/aws-sdk-php/zipball/e0afed3d0e2c89362f6c9b6bf8f278b04a4858b6",
-                "reference": "e0afed3d0e2c89362f6c9b6bf8f278b04a4858b6",
+                "url": "https://api.github.com/repos/aws/aws-sdk-php/zipball/29c2c34ddc7ff02ec865355fc235c78acd095fcf",
+                "reference": "29c2c34ddc7ff02ec865355fc235c78acd095fcf",
                 "shasum": ""
             },
             "require": {
             "support": {
                 "forum": "https://github.com/aws/aws-sdk-php/discussions",
                 "issues": "https://github.com/aws/aws-sdk-php/issues",
-                "source": "https://github.com/aws/aws-sdk-php/tree/3.342.11"
+                "source": "https://github.com/aws/aws-sdk-php/tree/3.342.12"
             },
-            "time": "2025-03-21T18:11:10+00:00"
+            "time": "2025-03-24T18:06:44+00:00"
         },
         {
             "name": "aws/aws-sdk-php-laravel",
         },
         {
             "name": "monolog/monolog",
-            "version": "3.8.1",
+            "version": "3.9.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/Seldaek/monolog.git",
-                "reference": "aef6ee73a77a66e404dd6540934a9ef1b3c855b4"
+                "reference": "10d85740180ecba7896c87e06a166e0c95a0e3b6"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/Seldaek/monolog/zipball/aef6ee73a77a66e404dd6540934a9ef1b3c855b4",
-                "reference": "aef6ee73a77a66e404dd6540934a9ef1b3c855b4",
+                "url": "https://api.github.com/repos/Seldaek/monolog/zipball/10d85740180ecba7896c87e06a166e0c95a0e3b6",
+                "reference": "10d85740180ecba7896c87e06a166e0c95a0e3b6",
                 "shasum": ""
             },
             "require": {
             ],
             "support": {
                 "issues": "https://github.com/Seldaek/monolog/issues",
-                "source": "https://github.com/Seldaek/monolog/tree/3.8.1"
+                "source": "https://github.com/Seldaek/monolog/tree/3.9.0"
             },
             "funding": [
                 {
                     "type": "tidelift"
                 }
             ],
-            "time": "2024-12-05T17:15:07+00:00"
+            "time": "2025-03-24T10:02:05+00:00"
         },
         {
             "name": "mtdowling/jmespath.php",

resources/css/filament/company/theme.css

 
 /* End Alignment sortable column enhancement */
 .fi-ta-header-cell:has(button.justify-end > svg.fi-ta-header-cell-sort-icon) {
-    padding-right: 0.25rem;
-}
-
-.fi-ta-cell:has(.fi-ta-col-wrp > .justify-end) {
-    padding-right: 1rem;
+    padding-right: 0;
 }
 
 :not(.dark) .fi-body {

resources/views/filament/tables/columns/deferred-text-input-column.blade.php

         $attributes
             ->merge($getExtraAttributes(), escape: false)
             ->class([
-                'fi-ta-text-input w-full min-w-48',
+                'fi-ta-text-input w-full min-w-36',
                 'px-3 py-4' => ! $isInline(),
             ])
     }}