wip

app/Filament/Company/Clusters/Settings/Resources/AdjustmentResource.php

@@ -14,7 +14,6 @@ use Filament\Forms\Form;
 use Filament\Resources\Resource;
 use Filament\Tables;
 use Filament\Tables\Table;
-use Wallo\FilamentSelectify\Components\ToggleButton;
 
 class AdjustmentResource extends Resource
 {
@@ -33,8 +32,7 @@ class AdjustmentResource extends Resource
                             ->required()
                             ->maxLength(255),
                         Forms\Components\Textarea::make('description')
-                            ->label('Description')
-                            ->autosize(),
+                            ->label('Description'),
                     ]),
                 Forms\Components\Section::make('Configuration')
                     ->schema([
@@ -50,9 +48,10 @@ class AdjustmentResource extends Resource
                             ->default(AdjustmentType::Sales)
                             ->live()
                             ->required(),
-                        ToggleButton::make('recoverable')
+                        Forms\Components\Checkbox::make('recoverable')
                             ->label('Recoverable')
                             ->default(false)
+                            ->helperText('When enabled, tax is tracked separately as claimable from the government. Non-recoverable taxes are treated as part of the expense.')
                             ->visible(fn (Forms\Get $get) => AdjustmentCategory::parse($get('category'))->isTax() && AdjustmentType::parse($get('type'))->isPurchase()),
                     ])
                     ->columns()

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

@@ -114,6 +114,7 @@ class AccountChart extends Page
             ->required()
             ->live()
             ->disabledOn('edit')
+            ->searchable()
             ->options($this->getChartSubtypeOptions($useActiveTab))
             ->afterStateUpdated(static function (?string $state, Set $set): void {
                 if ($state) {
@@ -282,7 +283,7 @@ class AccountChart extends Page
     {
         return Checkbox::make('archived')
             ->label('Archive account')
-            ->helperText('Archived accounts will not be available for selection in transactions.')
+            ->helperText('Archived accounts will not be available for selection in transactions, offerings, or other new records.')
             ->hiddenOn('create');
     }
 

app/Filament/Company/Resources/Common/OfferingResource.php

@@ -4,9 +4,12 @@ namespace App\Filament\Company\Resources\Common;
 
 use App\Enums\Accounting\AccountCategory;
 use App\Enums\Accounting\AccountType;
+use App\Enums\Accounting\AdjustmentCategory;
+use App\Enums\Accounting\AdjustmentType;
 use App\Enums\Common\OfferingType;
 use App\Filament\Company\Resources\Common\OfferingResource\Pages;
-use App\Models\Accounting\Account;
+use App\Filament\Forms\Components\CreateAccountSelect;
+use App\Filament\Forms\Components\CreateAdjustmentSelect;
 use App\Models\Common\Offering;
 use App\Utilities\Currency\CurrencyAccessor;
 use Filament\Forms;
@@ -65,63 +68,52 @@ class OfferingResource extends Resource
                 // Sellable Section
                 Forms\Components\Section::make('Sale Information')
                     ->schema([
-                        Forms\Components\Select::make('income_account_id')
+                        CreateAccountSelect::make('income_account_id')
                             ->label('Income account')
-                            ->options(Account::query()
-                                ->where('category', AccountCategory::Revenue)
-                                ->where('type', AccountType::OperatingRevenue)
-                                ->pluck('name', 'id')
-                                ->toArray())
-                            ->searchable()
-                            ->preload()
+                            ->category(AccountCategory::Revenue)
+                            ->type(AccountType::OperatingRevenue)
                             ->required()
                             ->validationMessages([
                                 'required' => 'The income account is required for sellable offerings.',
                             ]),
-                        Forms\Components\Select::make('salesTaxes')
+                        CreateAdjustmentSelect::make('salesTaxes')
                             ->label('Sales tax')
-                            ->relationship('salesTaxes', 'name')
-                            ->preload()
+                            ->category(AdjustmentCategory::Tax)
+                            ->type(AdjustmentType::Sales)
                             ->multiple(),
-                        Forms\Components\Select::make('salesDiscounts')
+                        CreateAdjustmentSelect::make('salesDiscounts')
                             ->label('Sales discount')
-                            ->relationship('salesDiscounts', 'name')
-                            ->preload()
+                            ->category(AdjustmentCategory::Discount)
+                            ->type(AdjustmentType::Sales)
                             ->multiple(),
                     ])
                     ->columns()
-                    ->visible(fn (Forms\Get $get) => in_array('Sellable', $get('attributes') ?? [])),
+                    ->visible(static fn (Forms\Get $get) => in_array('Sellable', $get('attributes') ?? [])),
 
                 // Purchasable Section
                 Forms\Components\Section::make('Purchase Information')
                     ->schema([
-                        Forms\Components\Select::make('expense_account_id')
+                        CreateAccountSelect::make('expense_account_id')
                             ->label('Expense account')
-                            ->options(Account::query()
-                                ->where('category', AccountCategory::Expense)
-                                ->where('type', AccountType::OperatingExpense)
-                                ->orderBy('name')
-                                ->pluck('name', 'id')
-                                ->toArray())
-                            ->searchable()
-                            ->preload()
+                            ->category(AccountCategory::Expense)
+                            ->type(AccountType::OperatingExpense)
                             ->required()
                             ->validationMessages([
                                 'required' => 'The expense account is required for purchasable offerings.',
                             ]),
-                        Forms\Components\Select::make('purchaseTaxes')
+                        CreateAdjustmentSelect::make('purchaseTaxes')
                             ->label('Purchase tax')
-                            ->relationship('purchaseTaxes', 'name')
-                            ->preload()
+                            ->category(AdjustmentCategory::Tax)
+                            ->type(AdjustmentType::Purchase)
                             ->multiple(),
-                        Forms\Components\Select::make('purchaseDiscounts')
+                        CreateAdjustmentSelect::make('purchaseDiscounts')
                             ->label('Purchase discount')
-                            ->relationship('purchaseDiscounts', 'name')
-                            ->preload()
+                            ->category(AdjustmentCategory::Discount)
+                            ->type(AdjustmentType::Purchase)
                             ->multiple(),
                     ])
                     ->columns()
-                    ->visible(fn (Forms\Get $get) => in_array('Purchasable', $get('attributes') ?? [])),
+                    ->visible(static fn (Forms\Get $get) => in_array('Purchasable', $get('attributes') ?? [])),
             ])->columns();
     }
 

app/Filament/Forms/Components/CreateAccountSelect.php

@@ -0,0 +1,152 @@
+<?php
+
+namespace App\Filament\Forms\Components;
+
+use App\Enums\Accounting\AccountCategory;
+use App\Enums\Accounting\AccountType;
+use App\Models\Accounting\Account;
+use App\Models\Accounting\AccountSubtype;
+use App\Utilities\Accounting\AccountCode;
+use Filament\Forms\Components\Actions\Action;
+use Filament\Forms\Components\Select;
+use Filament\Forms\Components\Textarea;
+use Filament\Forms\Components\TextInput;
+use Filament\Forms\Get;
+use Filament\Forms\Set;
+use Filament\Support\Enums\MaxWidth;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\DB;
+
+class CreateAccountSelect extends Select
+{
+    protected ?AccountCategory $category = null;
+
+    protected ?AccountType $type = null;
+
+    protected bool $includeArchived = false;
+
+    public function category(AccountCategory $category): static
+    {
+        $this->category = $category;
+
+        return $this;
+    }
+
+    public function type(AccountType $type): static
+    {
+        $this->type = $type;
+
+        return $this;
+    }
+
+    public function includeArchived(bool $includeArchived = true): static
+    {
+        $this->includeArchived = $includeArchived;
+
+        return $this;
+    }
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this
+            ->searchable()
+            ->live()
+            ->createOptionForm($this->createAccountForm())
+            ->createOptionAction(fn (Action $action) => $this->createAccountAction($action));
+
+        $this->options(function () {
+            $query = Account::query();
+
+            if ($this->category) {
+                $query->where('category', $this->category);
+            }
+
+            if ($this->type) {
+                $query->where('type', $this->type);
+            }
+
+            if (! $this->includeArchived) {
+                $query->where('archived', false);
+            }
+
+            return $query->orderBy('name')
+                ->pluck('name', 'id')
+                ->toArray();
+        });
+
+        $this->createOptionUsing(static function (array $data) {
+            return DB::transaction(static function () use ($data) {
+                $account = Account::create([
+                    'name' => $data['name'],
+                    'code' => $data['code'],
+                    'description' => $data['description'] ?? null,
+                    'subtype_id' => $data['subtype_id'],
+                ]);
+
+                return $account->getKey();
+            });
+        });
+    }
+
+    protected function createAccountForm(): array
+    {
+        return [
+            Select::make('subtype_id')
+                ->label('Type')
+                ->required()
+                ->live()
+                ->searchable()
+                ->options(function () {
+                    $query = AccountSubtype::query()->orderBy('name');
+
+                    if ($this->category) {
+                        $query->where('category', $this->category);
+                    }
+
+                    if ($this->type) {
+                        $query->where('type', $this->type);
+
+                        return $query->pluck('name', 'id')
+                            ->toArray();
+                    } else {
+                        return $query->get()
+                            ->groupBy(fn (AccountSubtype $subtype) => $subtype->type->getLabel())
+                            ->map(fn (Collection $subtypes, string $type) => $subtypes->mapWithKeys(static fn (AccountSubtype $subtype) => [$subtype->id => $subtype->name]))
+                            ->toArray();
+                    }
+                })
+                ->afterStateUpdated(function (string $state, Set $set) {
+                    if ($state) {
+                        $accountSubtype = AccountSubtype::find($state);
+                        $generatedCode = AccountCode::generate($accountSubtype);
+                        $set('code', $generatedCode);
+                    }
+                }),
+
+            TextInput::make('code')
+                ->label('Code')
+                ->required()
+                ->validationAttribute('account code')
+                ->unique(table: Account::class, column: 'code')
+                ->validateAccountCode(static fn (Get $get) => $get('subtype_id')),
+
+            TextInput::make('name')
+                ->label('Name')
+                ->required(),
+
+            Textarea::make('description')
+                ->label('Description'),
+        ];
+    }
+
+    protected function createAccountAction(Action $action): Action
+    {
+        return $action
+            ->label('Create Account')
+            ->slideOver()
+            ->modalWidth(MaxWidth::Large)
+            ->modalHeading('Create a new account');
+    }
+}

app/Filament/Forms/Components/CreateAdjustmentSelect.php

@@ -0,0 +1,180 @@
+<?php
+
+namespace App\Filament\Forms\Components;
+
+use App\Enums\Accounting\AdjustmentCategory;
+use App\Enums\Accounting\AdjustmentComputation;
+use App\Enums\Accounting\AdjustmentScope;
+use App\Enums\Accounting\AdjustmentType;
+use App\Models\Accounting\Adjustment;
+use Filament\Forms\Components\Actions\Action;
+use Filament\Forms\Components\Checkbox;
+use Filament\Forms\Components\DateTimePicker;
+use Filament\Forms\Components\Group;
+use Filament\Forms\Components\Select;
+use Filament\Forms\Components\Textarea;
+use Filament\Forms\Components\TextInput;
+use Filament\Forms\Get;
+use Filament\Support\Enums\MaxWidth;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Support\Facades\DB;
+
+class CreateAdjustmentSelect extends Select
+{
+    protected ?AdjustmentCategory $category = null;
+
+    protected ?AdjustmentType $type = null;
+
+    public function category(AdjustmentCategory $category): static
+    {
+        $this->category = $category;
+
+        return $this;
+    }
+
+    public function type(AdjustmentType $type): static
+    {
+        $this->type = $type;
+
+        return $this;
+    }
+
+    public function getCategory(): ?AdjustmentCategory
+    {
+        return $this->category;
+    }
+
+    public function getType(): ?AdjustmentType
+    {
+        return $this->type;
+    }
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this
+            ->searchable()
+            ->preload()
+            ->createOptionForm($this->createAdjustmentForm())
+            ->createOptionAction(fn (Action $action) => $this->createAdjustmentAction($action));
+
+        $this->relationship(
+            name: 'adjustments',
+            titleAttribute: 'name',
+            modifyQueryUsing: function (Builder $query) {
+                if ($this->category) {
+                    $query->where('category', $this->category);
+                }
+
+                if ($this->type) {
+                    $query->where('type', $this->type);
+                }
+
+                return $query->orderBy('name');
+            },
+        );
+
+        $this->createOptionUsing(static function (array $data, CreateAdjustmentSelect $component) {
+            return DB::transaction(static function () use ($data, $component) {
+                $category = $data['category'] ?? $component->getCategory();
+                $type = $data['type'] ?? $component->getType();
+
+                $adjustment = Adjustment::create([
+                    'name' => $data['name'],
+                    'description' => $data['description'] ?? null,
+                    'category' => $category,
+                    'type' => $type,
+                    'computation' => $data['computation'],
+                    'rate' => $data['rate'],
+                    'scope' => $data['scope'] ?? null,
+                    'recoverable' => $data['recoverable'] ?? false,
+                    'start_date' => $data['start_date'] ?? null,
+                    'end_date' => $data['end_date'] ?? null,
+                ]);
+
+                return $adjustment->getKey();
+            });
+        });
+    }
+
+    protected function createAdjustmentForm(): array
+    {
+        return [
+            TextInput::make('name')
+                ->label('Name')
+                ->required()
+                ->maxLength(255),
+
+            Textarea::make('description')
+                ->label('Description'),
+
+            Select::make('category')
+                ->label('Category')
+                ->options(AdjustmentCategory::class)
+                ->default(AdjustmentCategory::Tax)
+                ->hidden(fn () => (bool) $this->getCategory())
+                ->live()
+                ->required(),
+
+            Select::make('type')
+                ->label('Type')
+                ->options(AdjustmentType::class)
+                ->default(AdjustmentType::Sales)
+                ->hidden(fn () => (bool) $this->getType())
+                ->live()
+                ->required(),
+
+            Select::make('computation')
+                ->label('Computation')
+                ->options(AdjustmentComputation::class)
+                ->default(AdjustmentComputation::Percentage)
+                ->live()
+                ->required(),
+
+            TextInput::make('rate')
+                ->label('Rate')
+                ->rate(static fn (Get $get) => $get('computation'))
+                ->required(),
+
+            Select::make('scope')
+                ->label('Scope')
+                ->options(AdjustmentScope::class),
+
+            Checkbox::make('recoverable')
+                ->label('Recoverable')
+                ->default(false)
+                ->helperText('When enabled, tax is tracked separately as claimable from the government. Non-recoverable taxes are treated as part of the expense.')
+                ->visible(function (Get $get) {
+                    $category = $this->getCategory() ?? AdjustmentCategory::parse($get('category'));
+                    $type = $this->getType() ?? AdjustmentType::parse($get('type'));
+
+                    return $category->isTax() && $type->isPurchase();
+                }),
+
+            Group::make()
+                ->schema([
+                    DateTimePicker::make('start_date'),
+                    DateTimePicker::make('end_date'),
+                ])
+                ->visible(function (Get $get) {
+                    $category = $this->getCategory() ?? AdjustmentCategory::parse($get('category'));
+
+                    return $category->isDiscount();
+                }),
+        ];
+    }
+
+    protected function createAdjustmentAction(Action $action): Action
+    {
+        $categoryLabel = $this->getCategory()?->getLabel() ?? 'Adjustment';
+        $typeLabel = $this->getType()?->getLabel() ?? '';
+        $label = trim($typeLabel . ' ' . $categoryLabel);
+
+        return $action
+            ->label('Create ' . $label)
+            ->slideOver()
+            ->modalWidth(MaxWidth::ExtraLarge)
+            ->modalHeading('Create a new ' . strtolower($label));
+    }
+}

app/Observers/AdjustmentObserver.php

@@ -9,7 +9,7 @@ class AdjustmentObserver
 {
     public function creating(Adjustment $adjustment): void
     {
-        if ($adjustment->account_id === null && ! $adjustment->isNonRecoverablePurchaseTax()) {
+        if (! $adjustment->account_id && ! $adjustment->isNonRecoverablePurchaseTax()) {
             $account = null;
 
             if ($adjustment->isSalesTax()) {

resources/css/filament/company/custom-section.css

@@ -48,10 +48,6 @@
     &.fi-section-not-contained:not(.fi-aside) {
         @apply grid gap-y-4;
 
-        & .fi-section-header {
-            @apply py-2;
-        }
-
         & .fi-section-content-ctn {
             @apply grid gap-y-4;
         }