wip: Accounting Module

app/Actions/OptionAction/CreateCurrency.php

 namespace App\Actions\OptionAction;
 
 use App\Models\Setting\Currency;
-use Illuminate\Support\Facades\Auth;
 
 class CreateCurrency
 {
     public function create(string $code, string $name, string $rate): Currency
     {
-        $companyId = Auth::user()->currentCompany->id;
-
         $defaultCurrency = Currency::getDefaultCurrency();
 
         $hasDefaultCurrency = $defaultCurrency !== null;
             'decimal_mark' => config("money.{$code}.decimal_mark"),
             'thousands_separator' => config("money.{$code}.thousands_separator"),
             'enabled' => !$hasDefaultCurrency,
-            'company_id' => $companyId,
         ]);
     }
 }

app/Filament/Resources/AccountResource/Pages/CreateAccount.php

 use App\Models\Banking\Account;
 use App\Traits\HandlesResourceRecordCreation;
 use Filament\Resources\Pages\CreateRecord;
+use Filament\Support\Exceptions\Halt;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Facades\Auth;
 
 
     protected function mutateFormDataBeforeCreate(array $data): array
     {
-        $data['company_id'] = Auth::user()->currentCompany->id;
         $data['enabled'] = (bool)$data['enabled'];
-        $data['created_by'] = Auth::id();
 
         return $data;
     }
 
+    /**
+     * @throws Halt
+     */
     protected function handleRecordCreation(array $data): Model
     {
-        return $this->handleRecordCreationWithUniqueField($data, new Account());
+        $user = Auth::user();
+
+        if (!$user) {
+            throw new Halt('No authenticated user found.');
+        }
+
+        return $this->handleRecordCreationWithUniqueField($data, new Account(), $user);
     }
 }

app/Filament/Resources/AccountResource/Pages/EditAccount.php

 namespace App\Filament\Resources\AccountResource\Pages;
 
 use App\Filament\Resources\AccountResource;
-use App\Models\Banking\Account;
 use App\Traits\HandlesResourceRecordUpdate;
-use Filament\Notifications\Notification;
 use Filament\Pages\Actions;
 use Filament\Resources\Pages\EditRecord;
+use Filament\Support\Exceptions\Halt;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Facades\Auth;
-use Illuminate\Support\Facades\DB;
 
 class EditAccount extends EditRecord
 {
 
     protected function mutateFormDataBeforeSave(array $data): array
     {
-        $data['company_id'] = Auth::user()->currentCompany->id;
         $data['enabled'] = (bool)$data['enabled'];
-        $data['updated_by'] = Auth::id();
 
         return $data;
     }
 
+    /**
+     * @throws Halt
+     */
     protected function handleRecordUpdate(Model $record, array $data): Model
     {
-        return $this->handleRecordUpdateWithUniqueField($record, $data);
+        $user = Auth::user();
+
+        if (!$user) {
+            throw new Halt('No authenticated user found.');
+        }
+
+        return $this->handleRecordUpdateWithUniqueField($record, $data, $user);
     }
 }

app/Filament/Resources/CategoryResource/Pages/CreateCategory.php

 use App\Models\Setting\Category;
 use App\Traits\HandlesResourceRecordCreation;
 use Filament\Resources\Pages\CreateRecord;
+use Filament\Support\Exceptions\Halt;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Facades\Auth;
 
 
     protected function mutateFormDataBeforeCreate(array $data): array
     {
-        $data['company_id'] = Auth::user()->currentCompany->id;
         $data['enabled'] = (bool)$data['enabled'];
-        $data['created_by'] = Auth::id();
 
         return $data;
     }
 
+    /**
+     * @throws Halt
+     */
     protected function handleRecordCreation(array $data): Model
     {
-        return $this->handleRecordCreationWithUniqueField($data, new Category(), 'type');
+        $user = Auth::user();
+
+        if (!$user) {
+            throw new Halt('No authenticated user found.');
+        }
+
+        return $this->handleRecordCreationWithUniqueField($data, new Category(), $user, 'type');
     }
 }

app/Filament/Resources/CategoryResource/Pages/EditCategory.php

 use App\Traits\HandlesResourceRecordUpdate;
 use Filament\Pages\Actions;
 use Filament\Resources\Pages\EditRecord;
+use Filament\Support\Exceptions\Halt;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Facades\Auth;
 
 
     protected function mutateFormDataBeforeSave(array $data): array
     {
-        $data['company_id'] = Auth::user()->currentCompany->id;
         $data['enabled'] = (bool)$data['enabled'];
-        $data['updated_by'] = Auth::id();
 
         return $data;
     }
 
+    /**
+     * @throws Halt
+     */
     protected function handleRecordUpdate(Model $record, array $data): Model
     {
-        return $this->handleRecordUpdateWithUniqueField($record, $data, 'type');
+        $user = Auth::user();
+
+        if (!$user) {
+            throw new Halt('No authenticated user found.');
+        }
+
+        return $this->handleRecordUpdateWithUniqueField($record, $data, $user, 'type');
     }
 }

app/Filament/Resources/CurrencyResource/Pages/CreateCurrency.php

 use App\Traits\HandlesResourceRecordCreation;
 use Filament\Pages\Actions;
 use Filament\Resources\Pages\CreateRecord;
+use Filament\Support\Exceptions\Halt;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\DB;
 
     protected function mutateFormDataBeforeCreate(array $data): array
     {
-        $data['company_id'] = Auth::user()->currentCompany->id;
         $data['enabled'] = (bool)$data['enabled'];
-        $data['created_by'] = Auth::id();
 
         return $data;
     }
 
+    /**
+     * @throws Halt
+     */
     protected function handleRecordCreation(array $data): Model
     {
-        return $this->handleRecordCreationWithUniqueField($data, new Currency());
+        $user = Auth::user();
+
+        if (!$user) {
+            throw new Halt('No authenticated user found.');
+        }
+
+        return $this->handleRecordCreationWithUniqueField($data, new Currency(), $user);
     }
 }

app/Filament/Resources/CurrencyResource/Pages/EditCurrency.php

 namespace App\Filament\Resources\CurrencyResource\Pages;
 
 use App\Filament\Resources\CurrencyResource;
-use App\Models\Banking\Account;
-use App\Models\Setting\Currency;
 use App\Traits\HandlesResourceRecordUpdate;
 use Filament\Pages\Actions;
 use Filament\Resources\Pages\EditRecord;
+use Filament\Support\Exceptions\Halt;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Facades\Auth;
-use Illuminate\Support\Facades\DB;
 
 class EditCurrency extends EditRecord
 {
 
     protected function mutateFormDataBeforeSave(array $data): array
     {
-        $data['company_id'] = Auth::user()->currentCompany->id;
         $data['enabled'] = (bool)$data['enabled'];
-        $data['updated_by'] = Auth::id();
 
         return $data;
     }
 
+    /**
+     * @throws Halt
+     */
     protected function handleRecordUpdate(Model $record, array $data): Model
     {
-        return $this->handleRecordUpdateWithUniqueField($record, $data);
+        $user = Auth::user();
+
+        if (!$user) {
+            throw new Halt('No authenticated user found.');
+        }
+
+        return $this->handleRecordUpdateWithUniqueField($record, $data, $user);
     }
 
 }

app/Filament/Resources/CustomerResource/Pages/CreateCustomer.php

 
     protected function mutateFormDataBeforeCreate(array $data): array
     {
-        $data['company_id'] = Auth::user()->currentCompany->id;
         $data['type'] = 'customer';
-        $data['created_by'] = Auth::id();
 
         return $data;
     }

app/Filament/Resources/CustomerResource/Pages/EditCustomer.php

 use App\Filament\Resources\CustomerResource;
 use Filament\Pages\Actions;
 use Filament\Resources\Pages\EditRecord;
-use Illuminate\Support\Facades\Auth;
 
 class EditCustomer extends EditRecord
 {
 
     protected function getRedirectUrl(): string
     {
-        return $this->getResource()::getUrl('index');
-    }
-
-    protected function mutateFormDataBeforeSave(array $data): array
-    {
-        $data['company_id'] = Auth::user()->currentCompany->id;
-        $data['updated_by'] = Auth::id();
-
-        return $data;
+        return $this->previousUrl;
     }
 }

app/Filament/Resources/DiscountResource.php

                                 return today()->addDay();
                             }
 
-                            return $record?->start_date->isFuture() ? today()->addDay() : $record?->start_date;
+                            return $record?->start_date?->isFuture() ? today()->addDay() : $record?->start_date;
                         })
                         ->maxDate(static function (callable $get, Discount|null $record = null) {
                             $end_date = $get('end_date') ?? $record?->end_date;
                         ->displayFormat('F d, Y H:i')
                         ->withoutSeconds()
                         ->reactive()
-                        ->disabled(static fn ($context, Discount|null $record = null) => $context === 'edit' && $record?->start_date->isPast())
+                        ->disabled(static fn ($context, Discount|null $record = null) => $context === 'edit' && $record?->start_date?->isPast() ?? false)
                         ->helperText(static fn (Forms\Components\DateTimePicker $component) => $component->isDisabled() ? 'Start date cannot be changed after the discount has begun.' : null),
                     Forms\Components\DateTimePicker::make('end_date')
                         ->label('End Date')
                     ->sortable(),
                 Tables\Columns\TextColumn::make('start_date')
                 ->label('Start Date')
-                ->formatStateUsing(static fn (Discount $record) => $record->start_date ? $record->start_date->format('F d, Y H:i') : null)
+                ->formatStateUsing(static fn (Discount $record) => $record->start_date ? $record->start_date->format('F d, Y H:i') : 'N/A')
                 ->searchable()
                 ->sortable(),
                 Tables\Columns\TextColumn::make('end_date')
                 ->label('End Date')
-                ->formatStateUsing(static fn (Discount $record) => $record->end_date ? $record->end_date->format('F d, Y H:i') : null)
+                ->formatStateUsing(static fn (Discount $record) => $record->end_date ? $record->end_date->format('F d, Y H:i') : 'N/A')
                 ->color(static fn(Discount $record) => $record->end_date?->isPast() ? 'danger' : null)
                 ->searchable()
                 ->sortable(),

app/Filament/Resources/DiscountResource/Pages/CreateDiscount.php

 use App\Models\Setting\Discount;
 use App\Traits\HandlesResourceRecordCreation;
 use Filament\Resources\Pages\CreateRecord;
+use Filament\Support\Exceptions\Halt;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Facades\Auth;
 
 
     protected function mutateFormDataBeforeCreate(array $data): array
     {
-        $data['company_id'] = Auth::user()->currentCompany->id;
         $data['enabled'] = (bool)($data['enabled']);
-        $data['created_by'] = Auth::id();
 
         return $data;
     }
 
+    /**
+     * @throws Halt
+     */
     protected function handleRecordCreation(array $data): Model
     {
-        return $this->handleRecordCreationWithUniqueField($data, new Discount(), 'type');
+        $user = Auth::user();
+
+        if (!$user) {
+            throw new Halt('No authenticated user found.');
+        }
+
+        return $this->handleRecordCreationWithUniqueField($data, new Discount(), $user, 'type');
     }
 }

app/Filament/Resources/DiscountResource/Pages/EditDiscount.php

 use App\Traits\HandlesResourceRecordUpdate;
 use Filament\Pages\Actions;
 use Filament\Resources\Pages\EditRecord;
+use Filament\Support\Exceptions\Halt;
 use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Facades\Auth;
 
 class EditDiscount extends EditRecord
 {
         return $this->previousUrl;
     }
 
+    protected function mutateFormDataBeforeSave(array $data): array
+    {
+        $data['enabled'] = (bool)$data['enabled'];
+
+        return $data;
+    }
+
+    /**
+     * @throws Halt
+     */
     protected function handleRecordUpdate(Model $record, array $data): Model
     {
-        return $this->handleRecordUpdateWithUniqueField($record, $data, 'type');
+        $user = Auth::user();
+
+        if (!$user) {
+            throw new Halt('No authenticated user found.');
+        }
+
+        return $this->handleRecordUpdateWithUniqueField($record, $data, $user, 'type');
     }
 }

app/Filament/Resources/InvoiceResource/Pages/CreateInvoice.php

 
     protected function mutateFormDataBeforeCreate(array $data): array
     {
-        $data['company_id'] = Auth::user()->currentCompany->id;
         $data['type'] = 'invoice';
         $data['status'] = 'draft';
         $data['amount'] = 0;
-        $data['created_by'] = Auth::id();
 
         return $data;
     }

app/Filament/Resources/InvoiceResource/Pages/EditInvoice.php

 use App\Filament\Resources\InvoiceResource;
 use Filament\Pages\Actions;
 use Filament\Resources\Pages\EditRecord;
-use Illuminate\Support\Facades\Auth;
 
 class EditInvoice extends EditRecord
 {
     {
         return $this->previousUrl;
     }
-
-    protected function mutateFormDataBeforeSave(array $data): array
-    {
-        $data['company_id'] = Auth::user()->currentCompany->id;
-        $data['updated_by'] = Auth::id();
-
-        return $data;
-    }
 }

app/Filament/Resources/TaxResource/Pages/CreateTax.php

 use App\Models\Setting\Tax;
 use App\Traits\HandlesResourceRecordCreation;
 use Filament\Resources\Pages\CreateRecord;
+use Filament\Support\Exceptions\Halt;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Facades\Auth;
 
 
     protected function mutateFormDataBeforeCreate(array $data): array
     {
-        $data['company_id'] = Auth::user()->currentCompany->id;
         $data['enabled'] = (bool)$data['enabled'];
-        $data['created_by'] = Auth::id();
 
         return $data;
     }
 
+    /**
+     * @throws Halt
+     */
     protected function handleRecordCreation(array $data): Model
     {
-        return $this->handleRecordCreationWithUniqueField($data, new Tax(), 'type');
+        $user = Auth::user();
+
+        if (!$user) {
+            throw new Halt('No authenticated user found.');
+        }
+
+        return $this->handleRecordCreationWithUniqueField($data, new Tax(), $user, 'type');
     }
 }

app/Filament/Resources/TaxResource/Pages/EditTax.php

 namespace App\Filament\Resources\TaxResource\Pages;
 
 use App\Filament\Resources\TaxResource;
-use App\Models\Setting\Tax;
 use App\Traits\HandlesResourceRecordUpdate;
 use Filament\Pages\Actions;
 use Filament\Resources\Pages\EditRecord;
+use Filament\Support\Exceptions\Halt;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Facades\Auth;
-use Illuminate\Support\Facades\DB;
 
 class EditTax extends EditRecord
 {
 
     protected function mutateFormDataBeforeUpdate(array $data): array
     {
-        $data['company_id'] = Auth::user()->currentCompany->id;
         $data['enabled'] = (bool)$data['enabled'];
-        $data['updated_by'] = Auth::id();
 
         return $data;
     }
 
+    /**
+     * @throws Halt
+     */
     protected function handleRecordUpdate(Model $record, array $data): Model
     {
-        return $this->handleRecordUpdateWithUniqueField($record, $data, 'type');
+        $user = Auth::user();
+
+        if (!$user) {
+            throw new Halt('No authenticated user found.');
+        }
+
+        return $this->handleRecordUpdateWithUniqueField($record, $data, $user, 'type');
     }
 }

app/Http/Livewire/DefaultSetting.php

 use App\Models\Setting\Currency;
 use App\Models\Setting\DefaultSetting as Defaults;
 use App\Models\Setting\Tax;
-use App\Traits\HandlesDefaultSettingRecordCreation;
+use App\Traits\HandlesDefaultSettingRecordUpdate;
 use Filament\Forms\ComponentContainer;
 use Filament\Forms\Components\Section;
 use Filament\Forms\Components\Select;
 use Filament\Forms\Contracts\HasForms;
 use Filament\Notifications\Notification;
 use Illuminate\Contracts\View\View;
-use Illuminate\Support\Facades\Auth;
 use Livewire\Component;
 
 /**
  */
 class DefaultSetting extends Component implements HasForms
 {
-    use InteractsWithForms, HandlesDefaultSettingRecordCreation;
+    use InteractsWithForms, HandlesDefaultSettingRecordUpdate;
 
     public Defaults $defaultSetting;
 
                     Select::make('account_id')
                         ->label('Account')
                         ->options(Defaults::getAccounts())
-                        ->default(Defaults::getDefaultAccount())
                         ->searchable()
                         ->validationAttribute('Account')
                         ->nullable(),
                     Select::make('currency_code')
                         ->label('Currency')
                         ->options(Defaults::getCurrencies())
-                        ->default(Defaults::getDefaultCurrency())
                         ->searchable()
                         ->validationAttribute('Currency')
                         ->nullable(),
                     Select::make('sales_tax_id')
                         ->label('Sales Tax')
                         ->options(Defaults::getSalesTaxes())
-                        ->default(Defaults::getDefaultSalesTax())
                         ->searchable()
                         ->validationAttribute('Sales Tax')
                         ->nullable(),
                     Select::make('purchase_tax_id')
                         ->label('Purchase Tax')
                         ->options(Defaults::getPurchaseTaxes())
-                        ->default(Defaults::getDefaultPurchaseTax())
                         ->searchable()
                         ->validationAttribute('Purchase Tax')
                         ->nullable(),
                     Select::make('sales_discount_id')
                         ->label('Sales Discount')
                         ->options(Defaults::getSalesDiscounts())
-                        ->default(Defaults::getDefaultSalesDiscount())
                         ->searchable()
                         ->validationAttribute('Sales Discount')
                         ->nullable(),
                     Select::make('purchase_discount_id')
                         ->label('Purchase Discount')
                         ->options(Defaults::getPurchaseDiscounts())
-                        ->default(Defaults::getDefaultPurchaseDiscount())
                         ->searchable()
                         ->validationAttribute('Purchase Discount')
                         ->nullable(),
                     Select::make('income_category_id')
                         ->label('Income Category')
                         ->options(Defaults::getIncomeCategories())
-                        ->default(Defaults::getDefaultIncomeCategory())
                         ->searchable()
                         ->validationAttribute('Income Category')
                         ->nullable(),
                     Select::make('expense_category_id')
                         ->label('Expense Category')
                         ->options(Defaults::getExpenseCategories())
-                        ->default(Defaults::getDefaultExpenseCategory())
                         ->searchable()
                         ->validationAttribute('Expense Category')
                         ->nullable(),
     {
         $data = $this->form->getState();
 
-        $data = $this->mutateFormDataBeforeCreate($data);
-
-        $this->record = $this->handleRecordCreation($data);
+        $this->record = $this->handleRecordUpdate($data);
 
         $this->form->model($this->record)->saveRelationships();
 
         $this->getSavedNotification()?->send();
     }
 
-    protected function mutateFormDataBeforeCreate(array $data): array
-    {
-        $data['company_id'] = Auth::user()->currentCompany->id;
-        $data['updated_by'] = Auth::id();
-
-        return $data;
-    }
-
     protected function getRelatedEntities(): array
     {
         return [

app/Models/Banking/Account.php

 use App\Scopes\CurrentCompanyScope;
 use App\Models\Setting\Currency;
 use App\Models\Setting\DefaultSetting;
+use App\Traits\Blamable;
+use App\Traits\CompanyOwned;
 use Database\Factories\AccountFactory;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\HasMany;
 use Illuminate\Database\Eloquent\Relations\HasOne;
-use Illuminate\Support\Facades\Auth;
-use Illuminate\Support\Facades\Config;
 use Spatie\Tags\HasTags;
 use Wallo\FilamentCompanies\FilamentCompanies;
 
 class Account extends Model
 {
-    use HasFactory;
-    use HasTags;
+    use Blamable, CompanyOwned, HasFactory, HasTags;
 
     protected $table = 'accounts';
 

app/Models/Contact.php

 use App\Models\Document\Document;
 use App\Models\Setting\Currency;
 use App\Scopes\CurrentCompanyScope;
+use App\Traits\Blamable;
+use App\Traits\CompanyOwned;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 
 class Contact extends Model
 {
-    use HasFactory;
+    use Blamable, CompanyOwned, HasFactory;
 
     protected $table = 'contacts';
 

app/Models/Document/Document.php

 use App\Models\Setting\Discount;
 use App\Models\Setting\DocumentDefault;
 use App\Models\Setting\Tax;
+use App\Traits\Blamable;
+use App\Traits\CompanyOwned;
 use Database\Factories\DocumentFactory;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 
 class Document extends Model
 {
-    use HasFactory;
+    use Blamable, CompanyOwned, HasFactory;
 
     protected $table = 'documents';
 

app/Models/Document/DocumentItem.php

 use App\Models\Item;
 use App\Models\Setting\Discount;
 use App\Models\Setting\Tax;
+use App\Traits\Blamable;
+use App\Traits\CompanyOwned;
 use Database\Factories\DocumentItemFactory;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 
 class DocumentItem extends Model
 {
-    use HasFactory;
+    use Blamable, CompanyOwned, HasFactory;
 
     protected $table = 'document_items';
 

app/Models/Document/DocumentTotal.php

 
 namespace App\Models\Document;
 
+use App\Traits\Blamable;
+use App\Traits\CompanyOwned;
 use Database\Factories\DocumentTotalFactory;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 
 class DocumentTotal extends Model
 {
-    use HasFactory;
+    use Blamable, CompanyOwned, HasFactory;
 
     protected $table = 'document_totals';
 

app/Models/Item.php

 use App\Models\Setting\Category;
 use App\Models\Setting\Discount;
 use App\Models\Setting\Tax;
+use App\Traits\Blamable;
+use App\Traits\CompanyOwned;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 
 class Item extends Model
 {
-    use HasFactory;
+    use Blamable, CompanyOwned, HasFactory;
 
     protected $table = 'items';
 

app/Models/Setting/Category.php

 use App\Models\Document\Document;
 use App\Models\Item;
 use App\Scopes\CurrentCompanyScope;
+use App\Traits\Blamable;
+use App\Traits\CompanyOwned;
 use Database\Factories\CategoryFactory;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 
 class Category extends Model
 {
-    use HasFactory;
+    use Blamable, CompanyOwned, HasFactory;
 
     protected $table = 'categories';
 

app/Models/Setting/Currency.php

 
 use App\Models\Banking\Account;
 use App\Scopes\CurrentCompanyScope;
+use App\Traits\Blamable;
+use App\Traits\CompanyOwned;
 use Database\Factories\CurrencyFactory;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 
 class Currency extends Model
 {
-    use HasFactory;
+    use Blamable, CompanyOwned, HasFactory;
 
     protected $table = 'currencies';
 
         return $this->hasMany(Account::class, 'currency_code', 'code');
     }
 
+    public function createdBy(): BelongsTo
+    {
+        return $this->belongsTo(FilamentCompanies::userModel(), 'created_by');
+    }
+
+    public function updatedBy(): BelongsTo
+    {
+        return $this->belongsTo(FilamentCompanies::userModel(), 'updated_by');
+    }
+
     public static function getCurrencyCodes(): array
     {
         $allCodes = array_keys(Config::get('money'));

app/Models/Setting/DefaultSetting.php

 
 use App\Models\Banking\Account;
 use App\Scopes\CurrentCompanyScope;
+use App\Traits\Blamable;
+use App\Traits\CompanyOwned;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 
 class DefaultSetting extends Model
 {
-    use HasFactory;
+    use Blamable, CompanyOwned, HasFactory;
 
     protected $table = 'default_settings';
 
         'purchase_discount_id',
         'income_category_id',
         'expense_category_id',
+        'created_by',
         'updated_by',
     ];
 
             ->where('type', 'expense');
     }
 
+    public function createdBy(): BelongsTo
+    {
+        return $this->belongsTo(FilamentCompanies::userModel(), 'created_by');
+    }
+
     public function updatedBy(): BelongsTo
     {
         return $this->belongsTo(FilamentCompanies::userModel(), 'updated_by');

app/Models/Setting/Discount.php

 use App\Models\Document\DocumentItem;
 use App\Models\Item;
 use App\Scopes\CurrentCompanyScope;
+use App\Traits\Blamable;
+use App\Traits\CompanyOwned;
 use Database\Factories\DiscountFactory;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 
 class Discount extends Model
 {
-    use HasFactory;
+    use Blamable, CompanyOwned, HasFactory;
 
     protected $table = 'discounts';
 

app/Models/Setting/DocumentDefault.php

 
 use App\Models\Document\Document;
 use App\Scopes\CurrentCompanyScope;
+use App\Traits\Blamable;
+use App\Traits\CompanyOwned;
 use Database\Factories\DocumentDefaultFactory;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 
 class DocumentDefault extends Model
 {
-    use HasFactory;
+    use Blamable, CompanyOwned, HasFactory;
 
     protected $table = 'document_defaults';
 
         'notes',
         'terms',
         'footer',
+        'created_by',
+        'updated_by',
     ];
 
     protected static function booted(): void
         return $this->hasMany(Document::class);
     }
 
+    public function createdBy(): BelongsTo
+    {
+        return $this->belongsTo(FilamentCompanies::userModel(), 'created_by');
+    }
+
+    public function updatedBy(): BelongsTo
+    {
+        return $this->belongsTo(FilamentCompanies::userModel(), 'updated_by');
+    }
+
     public static function getDocumentNumberDigits(): array
     {
         return array_combine(range(1, 20), range(1, 20));

app/Models/Setting/Tax.php

 use App\Models\Document\DocumentItem;
 use App\Models\Item;
 use App\Scopes\CurrentCompanyScope;
+use App\Traits\Blamable;
+use App\Traits\CompanyOwned;
 use Database\Factories\TaxFactory;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 
 class Tax extends Model
 {
-    use HasFactory;
+    use Blamable, CompanyOwned, HasFactory;
 
     protected $table = 'taxes';
 

app/Observers/CompanyObserver.php

 namespace App\Observers;
 
 use App\Models\Company;
-use App\Models\Setting\Category;
-use App\Models\Setting\Currency;
-use App\Models\Setting\Discount;
-use App\Models\Setting\DocumentDefault;
-use App\Models\Setting\Tax;
+use App\Services\DefaultSettingService;
 
 class CompanyObserver
 {
      */
     public function created(Company $company): void
     {
-        $incomeCategories = ['Salary', 'Bonus', 'Interest', 'Dividends', 'Rentals'];
-        $expenseCategories = ['Rent', 'Utilities', 'Food', 'Transportation', 'Entertainment'];
-
-        $shuffledCategories = [
-            ...array_map(static fn ($name) => ['name' => $name, 'type' => 'income'], $incomeCategories),
-            ...array_map(static fn ($name) => ['name' => $name, 'type' => 'expense'], $expenseCategories),
-        ];
-
-        shuffle($shuffledCategories);
-
-        $incomeEnabled = $expenseEnabled = false;
-
-        foreach ($shuffledCategories as $category) {
-            $enabled = false;
-            if (!$incomeEnabled && $category['type'] === 'income') {
-                $enabled = $incomeEnabled = true;
-            } elseif (!$expenseEnabled && $category['type'] === 'expense') {
-                $enabled = $expenseEnabled = true;
-            }
-
-            Category::factory()->create([
-                'company_id' => $company->id,
-                'name' => $category['name'],
-                'type' => $category['type'],
-                'enabled' => $enabled,
-                'created_by' => $company->user_id,
-            ]);
-        }
-
-
-        DocumentDefault::factory()->invoice()->create([
-            'company_id' => $company->id,
-        ]);
-
-        DocumentDefault::factory()->bill()->create([
-            'company_id' => $company->id,
-        ]);
-
-        Currency::factory()->create([
-            'company_id' => $company->id,
-            'created_by' => $company->user_id,
-        ]);
-
-        Tax::factory()->salesTax()->create([
-            'company_id' => $company->id,
-            'created_by' => $company->user_id,
-        ]);
-
-        Tax::factory()->purchaseTax()->create([
-            'company_id' => $company->id,
-            'created_by' => $company->user_id,
-        ]);
-
-        Discount::factory()->salesDiscount()->create([
-            'company_id' => $company->id,
-            'created_by' => $company->user_id,
-        ]);
-
-        Discount::factory()->purchaseDiscount()->create([
-            'company_id' => $company->id,
-            'created_by' => $company->user_id,
-        ]);
+        $defaultSettingService = new DefaultSettingService();
+        $defaultSettingService->createDefaultSettings($company);
     }
 
     /**

app/Services/DefaultSettingService.php

+<?php
+
+namespace App\Services;
+
+use App\Models\Company;
+use App\Models\Setting\Category;
+use App\Models\Setting\Currency;
+use App\Models\Setting\DefaultSetting;
+use App\Models\Setting\Discount;
+use App\Models\Setting\DocumentDefault;
+use App\Models\Setting\Tax;
+use Illuminate\Support\Facades\Auth;
+
+class DefaultSettingService
+{
+    public function createDefaultSettings(Company $company): void
+    {
+        $categories = $this->createDefaultCategories($company);
+        $currency = $this->createDefaultCurrency($company);
+        $salesTax = $this->createDefaultSalesTax($company);
+        $purchaseTax = $this->createDefaultPurchaseTax($company);
+        $salesDiscount = $this->createDefaultSalesDiscount($company);
+        $purchaseDiscount = $this->createDefaultPurchaseDiscount($company);
+
+        $defaultSettings = [
+            'company_id' => $company->id,
+            'income_category_id' => $categories['income_category_id'],
+            'expense_category_id' => $categories['expense_category_id'],
+            'currency_code' => $currency->code,
+            'sales_tax_id' => $salesTax->id,
+            'purchase_tax_id' => $purchaseTax->id,
+            'sales_discount_id' => $salesDiscount->id,
+            'purchase_discount_id' => $purchaseDiscount->id,
+            'created_by' => $company->owner->id,
+            'updated_by' => $company->owner->id,
+        ];
+
+        DefaultSetting::create($defaultSettings);
+
+        $this->createDefaultDocuments($company);
+    }
+
+    private function createDefaultCategories(Company $company): array
+    {
+        $incomeCategories = ['Salary', 'Bonus', 'Interest', 'Dividends', 'Rentals'];
+        $expenseCategories = ['Rent', 'Utilities', 'Food', 'Transportation', 'Entertainment'];
+
+        $shuffledCategories = [
+            ...array_map(static fn ($name) => ['name' => $name, 'type' => 'income'], $incomeCategories),
+            ...array_map(static fn ($name) => ['name' => $name, 'type' => 'expense'], $expenseCategories),
+        ];
+
+        shuffle($shuffledCategories);
+
+        $incomeEnabled = $expenseEnabled = false;
+
+        $defaultSettings = [];
+
+        foreach ($shuffledCategories as $category) {
+            $enabled = false;
+            if (!$incomeEnabled && $category['type'] === 'income') {
+                $enabled = $incomeEnabled = true;
+            } elseif (!$expenseEnabled && $category['type'] === 'expense') {
+                $enabled = $expenseEnabled = true;
+            }
+
+            $categoryModel = Category::factory()->create([
+                'company_id' => $company->id,
+                'name' => $category['name'],
+                'type' => $category['type'],
+                'enabled' => $enabled,
+                'created_by' => Auth::id(),
+                'updated_by' => Auth::id(),
+            ]);
+
+            $defaultSettings[$category['type'] . '_category_id'] = $categoryModel->id;
+        }
+
+        return $defaultSettings;
+    }
+
+    private function createDefaultDocuments(Company $company): void
+    {
+        DocumentDefault::factory()->invoice()->create([
+            'company_id' => $company->id,
+            'created_by' => Auth::id(),
+            'updated_by' => Auth::id(),
+        ]);
+
+        DocumentDefault::factory()->bill()->create([
+            'company_id' => $company->id,
+            'created_by' => Auth::id(),
+            'updated_by' => Auth::id(),
+        ]);
+    }
+
+    private function createDefaultCurrency(Company $company): Currency
+    {
+        return Currency::factory()->create([
+            'company_id' => $company->id,
+            'created_by' => Auth::id(),
+            'updated_by' => Auth::id(),
+        ]);
+    }
+
+    private function createDefaultSalesTax(Company $company): Tax
+    {
+        return Tax::factory()->salesTax()->create([
+            'company_id' => $company->id,
+            'created_by' => Auth::id(),
+            'updated_by' => Auth::id(),
+        ]);
+    }
+
+    private function createDefaultPurchaseTax(Company $company): Tax
+    {
+        return Tax::factory()->purchaseTax()->create([
+            'company_id' => $company->id,
+            'created_by' => Auth::id(),
+            'updated_by' => Auth::id(),
+        ]);
+    }
+
+    private function createDefaultSalesDiscount(Company $company): Discount
+    {
+        return Discount::factory()->salesDiscount()->create([
+            'company_id' => $company->id,
+            'created_by' => Auth::id(),
+            'updated_by' => Auth::id(),
+        ]);
+    }
+
+    private function createDefaultPurchaseDiscount(Company $company): Discount
+    {
+        return Discount::factory()->purchaseDiscount()->create([
+            'company_id' => $company->id,
+            'created_by' => Auth::id(),
+            'updated_by' => Auth::id(),
+        ]);
+    }
+}

app/Traits/Blamable.php

+<?php
+
+namespace App\Traits;
+
+use Illuminate\Support\Facades\Auth;
+
+trait Blamable
+{
+    public static function bootBlamable(): void
+    {
+        static::created(static function ($model) {
+            $model->created_by = Auth::check() ? Auth::id() : null;
+            $model->updated_by = Auth::check() ? Auth::id() : null;
+        });
+
+        static::updated(static function ($model) {
+            $model->updated_by = Auth::check() ? Auth::id() : null;
+        });
+    }
+}

app/Traits/CompanyOwned.php

+<?php
+
+namespace App\Traits;
+
+use Filament\Notifications\Notification;
+use Illuminate\Support\Facades\Auth;
+
+trait CompanyOwned
+{
+    public static function bootCompanyOwned(): void
+    {
+        static::created(static function ($model) {
+            if (Auth::check() && Auth::user()->currentCompany) {
+                $model->company_id = Auth::user()->currentCompany->id;
+            } else {
+                Notification::make()
+                    ->danger()
+                    ->title('Oops! Unable to Assign Company')
+                    ->body('We encountered an issue while creating the record. Please ensure you are logged in and have a valid company associated with your account.')
+                    ->persistent()
+                    ->send();
+            }
+        });
+    }
+}

app/Traits/HandlesDefaultSettingRecordCreation.php → app/Traits/HandlesDefaultSettingRecordUpdate.php

 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Facades\Auth;
 
-trait HandlesDefaultSettingRecordCreation
+trait HandlesDefaultSettingRecordUpdate
 {
     abstract protected function getRelatedEntities(): array;
     abstract protected function getFormModel(): string;
 
-    protected function handleRecordCreation(array $data): Model
+    protected function handleRecordUpdate(array $data): Model
     {
         $relatedEntities = $this->getRelatedEntities();
-
         $model = $this->getFormModel();
 
         $existingRecord = $model::where('company_id', Auth::user()->currentCompany->id)
             ->latest()
             ->first();
 
-        $newData = [
-            'company_id' => Auth::user()->currentCompany->id,
-            'updated_by' => Auth::id(),
-        ];
-
         foreach ($relatedEntities as $field => $params) {
             [$class, $key, $type] = array_pad($params, 3, null);
 
             if ($existingRecord === null || !isset($existingRecord->{$field})) {
-                $newData[$field] = $data[$field];
                 continue;
             }
 
             if (isset($data[$field]) && $data[$field] !== $existingRecord->{$field}) {
                 $this->updateEnabledRecord($class, $key, $existingRecord->{$field}, $type, false);
                 $this->updateEnabledRecord($class, $key, $data[$field], $type, true);
-
-                $newData[$field] = $data[$field];
-            } else {
-                $newData[$field] = $existingRecord->{$field};
             }
         }
 
-        return $model::create($newData);
+        $defaults = $model::where('company_id', Auth::user()->currentCompany->id)->first();
+
+        if ($defaults === null) {
+            $defaults = $model::create($data);
+        } else {
+            $defaults->update($data);
+        }
+
+        return $defaults;
     }
 
     protected function updateEnabledRecord($class, $key, $value, $type = null, $enabled = true): void
         }
 
         $query->where($key, $value)
-            ->update([
-                'enabled' => $enabled,
-                'updated_by' => Auth::id(),
-            ]);
+            ->update(compact('enabled'));
     }
 }
 

app/Traits/HandlesResourceRecordCreation.php

 
 namespace App\Traits;
 
+use App\Models\User;
+use Filament\Support\Exceptions\Halt;
+use Illuminate\Auth\Access\AuthorizationException;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\DB;
+use Illuminate\Validation\ValidationException;
+use Throwable;
 
 trait HandlesResourceRecordCreation
 {
-    protected function handleRecordCreationWithUniqueField(array $data, Model $model, string|null $uniqueField = null): Model
+    /**
+     * @throws Halt
+     */
+    protected function handleRecordCreationWithUniqueField(array $data, Model $model, User $user, string|null $uniqueField = null, ?string $uniqueFieldValue = null): Model
     {
-        return DB::transaction(function () use ($data, $uniqueField, $model) {
-            $currentCompanyId = Auth::user()->currentCompany->id;
-            $uniqueFieldValue = $data[$uniqueField] ?? null;
-            $enabled = (bool)($data['enabled'] ?? false);
+        try {
+            return DB::transaction(function () use ($data, $user, $model, $uniqueField, $uniqueFieldValue) {
+                $enabled = (bool)($data['enabled'] ?? false);
 
-            if ($enabled === true) {
-                $this->disableExistingRecord($currentCompanyId, $model, $uniqueField, $uniqueFieldValue);
-            } else {
-                $this->ensureAtLeastOneEnabled($currentCompanyId, $model, $enabled, $uniqueField, $uniqueFieldValue);
-            }
+                if ($enabled === true) {
+                    $this->disableExistingRecord($user->currentCompany->id, $model, $uniqueField, $uniqueFieldValue);
+                } else {
+                    $this->ensureAtLeastOneEnabled($user->currentCompany->id, $model, $enabled, $uniqueField, $uniqueFieldValue);
+                }
 
-            $data['enabled'] = $enabled;
+                $data['enabled'] = $enabled;
 
-            return $model::create($data);
-        });
+                return tap($model)->create($data);
+            });
+        } catch (ValidationException) {
+            throw new Halt('Invalid data provided. Please check the form and try again.');
+        } catch (AuthorizationException) {
+            throw new Halt('You are not authorized to perform this action.');
+        } catch (Throwable) {
+            throw new Halt('An unexpected error occurred. Please try again.');
+        }
     }
 
     protected function disableExistingRecord(int $companyId, Model $model, string|null $uniqueField = null, string|null $uniqueFieldValue = null): void
     {
-        $query = $model::where('company_id', $companyId)
+        $query = $model::query()->where('company_id', $companyId)
             ->where('enabled', true);
 
         if($uniqueField && $uniqueFieldValue){
 
     protected function ensureAtLeastOneEnabled(int $companyId, Model $model, bool &$enabled, string|null $uniqueField = null, string|null $uniqueFieldValue = null): void
     {
-        $query = $model::where('company_id', $companyId)
+        $query = $model::query()->where('company_id', $companyId)
             ->where('enabled', true);
 
         if($uniqueField && $uniqueFieldValue){
             $query->where($uniqueField, $uniqueFieldValue);
         }
 
-        $otherEnabledRecords = $query->count();
+        $otherEnabledRecord = $query->first();
 
-        if ($otherEnabledRecords === 0) {
+        if ($otherEnabledRecord === null) {
             $enabled = true;
         }
     }

app/Traits/HandlesResourceRecordUpdate.php

 
 namespace App\Traits;
 
+use App\Models\User;
+use Filament\Support\Exceptions\Halt;
+use Illuminate\Auth\Access\AuthorizationException;
+use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\DB;
+use Illuminate\Validation\ValidationException;
+use Throwable;
 
 trait HandlesResourceRecordUpdate
 {
-    protected function handleRecordUpdateWithUniqueField(Model $record, array $data, string|null $uniqueField = null): Model
+    /**
+     * @throws Halt
+     */
+    protected function handleRecordUpdateWithUniqueField(Model $record, array $data, User $user, string|null $uniqueField = null): Model
     {
-        return DB::transaction(function () use ($uniqueField, $record, $data) {
-            $companyId = Auth::user()->currentCompany->id;
-            $oldValue = $uniqueField ? $record->{$uniqueField} : null;
-            $newValue = $uniqueField ? $data[$uniqueField] : null;
-            $enabled = (bool)($data['enabled'] ?? false);
-
-            if ($oldValue !== $newValue && $record->enabled) {
-                $this->enableAnotherOfSameValue($companyId, $record, $uniqueField, $oldValue);
-            }
-
-            if ($enabled === true) {
-                $this->disableOthersOfSameValue($companyId, $record, $uniqueField, $newValue);
-            } elseif ($enabled === false) {
-                $this->ensureAtLeastOneEnabled($companyId, $record, $uniqueField, $newValue, $enabled);
-            }
-
-            $data['enabled'] = $enabled;
-
-            return tap($record)->update($data);
-        });
+        try {
+            return DB::transaction(function () use ($user, $uniqueField, $record, $data) {
+                $companyId = $user->currentCompany->id;
+                $oldValue = $uniqueField ? $record->{$uniqueField} : null;
+                $newValue = $uniqueField ? $data[$uniqueField] : null;
+                $enabled = (bool)($data['enabled'] ?? false);
+
+                if ($oldValue !== $newValue && $record->enabled) {
+                    $this->toggleRecord($companyId, $record, $uniqueField, $oldValue, false, true);
+                }
+
+                if ($enabled === true) {
+                    $this->toggleRecord($companyId, $record, $uniqueField, $newValue, true, false);
+                } elseif ($enabled === false) {
+                    $this->ensureAtLeastOneEnabled($companyId, $record, $uniqueField, $newValue, $enabled);
+                }
+
+                $data['enabled'] = $enabled;
+
+                return tap($record)->update($data);
+            });
+        } catch (ValidationException) {
+            throw new Halt('Invalid data provided. Please check the form and try again.');
+        } catch (AuthorizationException) {
+            throw new Halt('You are not authorized to perform this action.');
+        } catch (Throwable) {
+            throw new Halt('An unexpected error occurred. Please try again.');
+        }
     }
 
-    protected function enableAnotherOfSameValue(int $companyId, Model $record, ?string $uniqueField, $value): void
+    protected function toggleRecord(int $companyId, Model $record, ?string $uniqueField, $value, bool $enabled, bool $newStatus): void
     {
-        $query = $record::where('company_id', $companyId)
-            ->where('id', '!=', $record->id)
-            ->where('enabled', false);
+        $query = $this->buildQuery($companyId, $record, $uniqueField, $value, $enabled);
 
-        if($uniqueField){
-            $query->where($uniqueField, $value);
-        }
-
-        $otherRecord = $query->first();
+        if ($newStatus) {
+            $otherRecord = $query->first();
 
-        if ($otherRecord) {
-            $otherRecord->enabled = true;
-            $otherRecord->save();
+            if ($otherRecord) {
+                $otherRecord->enabled = true;
+                $otherRecord->save();
+            }
+        } else {
+            $query->update(['enabled' => false]);
         }
     }
 
-    protected function disableOthersOfSameValue(int $companyId, Model $record, ?string $uniqueField, $value): void
+    protected function buildQuery(int $companyId, Model $record, ?string $uniqueField, $value, bool $enabled): Builder
     {
-        $query = $record::where('company_id', $companyId)
+        $query = $record::query()->where('company_id', $companyId)
             ->where('id', '!=', $record->id)
-            ->where('enabled', true);
+            ->where('enabled', $enabled);
 
         if($uniqueField){
             $query->where($uniqueField, $value);
         }
 
-        $query->update(['enabled' => false]);
+        return $query;
     }
 
     protected function ensureAtLeastOneEnabled(int $companyId, Model $record, ?string $uniqueField, $value, bool &$enabled): void
     {
-        $query = $record::where('company_id', $companyId)
-            ->where('id', '!=', $record->id)
-            ->where('enabled', true);
-
-        if($uniqueField){
-            $query->where($uniqueField, $value);
-        }
-
+        $query = $this->buildQuery($companyId, $record, $uniqueField, $value, true);
         $enabledCount = $query->count();
 
         if ($enabledCount === 0) {

database/migrations/2023_05_22_000100_create_document_defaults_table.php

             $table->text('notes')->nullable();
             $table->text('terms')->nullable();
             $table->string('footer')->nullable();
+            $table->foreignId('created_by')->nullable()->constrained('users')->nullOnDelete();
+            $table->foreignId('updated_by')->nullable()->constrained('users')->nullOnDelete();
             $table->timestamps();
         });
     }

database/migrations/2023_07_03_054805_create_default_settings_table.php

             $table->foreignId('purchase_discount_id')->nullable()->constrained('discounts')->nullOnDelete();
             $table->foreignId('income_category_id')->nullable()->constrained('categories')->nullOnDelete();
             $table->foreignId('expense_category_id')->nullable()->constrained('categories')->nullOnDelete();
+            $table->foreignId('created_by')->nullable()->constrained('users')->nullOnDelete();
             $table->foreignId('updated_by')->nullable()->constrained('users')->nullOnDelete();
             $table->timestamps();