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

Development 3.x

app/Services/ChartOfAccountsService.php

 use App\Models\Accounting\Adjustment;
 use App\Models\Banking\BankAccount;
 use App\Models\Company;
-use App\Utilities\Currency\CurrencyAccessor;
 use Exception;
 
 class ChartOfAccountsService
 {
-    public function createChartOfAccounts(Company $company): void
+    private string $currencyCode;
+
+    public function createChartOfAccounts(Company $company, string $currencyCode = 'USD'): void
     {
+        $this->currencyCode = $currencyCode;
         $chartOfAccounts = config('chart-of-accounts.default');
 
         // Always create a non-recoverable "Purchase Tax" adjustment, even without an account
     {
         if (isset($subtypeConfig['accounts']) && is_array($subtypeConfig['accounts'])) {
             $baseCode = $subtypeConfig['base_code'];
-            $defaultCurrencyCode = CurrencyAccessor::getDefaultCurrency();
+            $defaultCurrencyCode = $this->currencyCode;
 
             if (empty($defaultCurrencyCode)) {
                 throw new Exception('No default currency available for creating accounts.');

app/Services/CompanyDefaultService.php

 
             // Create Chart of Accounts
             $chartOfAccountsService = app(ChartOfAccountsService::class);
-            $chartOfAccountsService->createChartOfAccounts($company);
+            $chartOfAccountsService->createChartOfAccounts($company, $currencyCode);
 
             // Get the default bank account and update the company default record
             $defaultBankAccount = $company->bankAccounts()->where('enabled', true)->firstOrFail();

database/factories/Accounting/BillFactory.php

 use App\Models\Accounting\DocumentLineItem;
 use App\Models\Banking\BankAccount;
 use App\Models\Common\Vendor;
+use App\Models\Company;
 use App\Models\Setting\DocumentDefault;
 use App\Utilities\Currency\CurrencyConverter;
 use Illuminate\Database\Eloquent\Factories\Factory;
 
         return [
             'company_id' => 1,
-            'vendor_id' => Vendor::inRandomOrder()->value('id'),
+            'vendor_id' => fn (array $attributes) => Vendor::where('company_id', $attributes['company_id'])->inRandomOrder()->value('id'),
             'bill_number' => $this->faker->unique()->numerify('BILL-####'),
             'order_number' => $this->faker->unique()->numerify('PO-####'),
             'date' => $billDate,
             'due_date' => Carbon::parse($billDate)->addDays($dueDays),
             'status' => BillStatus::Open,
-            'currency_code' => 'USD',
+            'currency_code' => function (array $attributes) {
+                $vendor = Vendor::find($attributes['vendor_id']);
+
+                return $vendor->currency_code ??
+                    Company::find($attributes['company_id'])->default->currency_code ??
+                    'USD';
+            },
             'notes' => $this->faker->sentence,
             'created_by' => 1,
             'updated_by' => 1,

database/factories/Accounting/DocumentLineItemFactory.php

     {
         return $this
             ->for($invoice, 'documentable')
-            ->state(function (array $attributes) {
-                $offering = Offering::where('sellable', true)
+            ->for($invoice->company, 'company')
+            ->afterCreating(function (DocumentLineItem $lineItem) {
+                $offering = Offering::query()
+                    ->where('company_id', $lineItem->company_id)
+                    ->where('sellable', true)
                     ->inRandomOrder()
-                    ->first();
+                    ->firstOrFail();
 
-                return [
+                $lineItem->updateQuietly([
                     'offering_id' => $offering->id,
                     'unit_price' => $offering->price,
-                ];
-            })
-            ->afterCreating(function (DocumentLineItem $lineItem) {
-                $offering = $lineItem->offering;
+                ]);
 
-                if ($offering) {
-                    $lineItem->salesTaxes()->syncWithoutDetaching($offering->salesTaxes->pluck('id')->toArray());
-                    $lineItem->salesDiscounts()->syncWithoutDetaching($offering->salesDiscounts->pluck('id')->toArray());
-                }
+                $lineItem->salesTaxes()->syncWithoutDetaching($offering->salesTaxes->pluck('id')->toArray());
+                $lineItem->salesDiscounts()->syncWithoutDetaching($offering->salesDiscounts->pluck('id')->toArray());
 
                 $lineItem->refresh();
 
     {
         return $this
             ->for($estimate, 'documentable')
-            ->state(function (array $attributes) {
-                $offering = Offering::where('sellable', true)
+            ->for($estimate->company, 'company')
+            ->afterCreating(function (DocumentLineItem $lineItem) {
+                $offering = Offering::query()
+                    ->where('company_id', $lineItem->company_id)
+                    ->where('sellable', true)
                     ->inRandomOrder()
-                    ->first();
+                    ->firstOrFail();
 
-                return [
+                $lineItem->updateQuietly([
                     'offering_id' => $offering->id,
                     'unit_price' => $offering->price,
-                ];
-            })
-            ->afterCreating(function (DocumentLineItem $lineItem) {
-                $offering = $lineItem->offering;
+                ]);
 
-                if ($offering) {
-                    $lineItem->salesTaxes()->syncWithoutDetaching($offering->salesTaxes->pluck('id')->toArray());
-                    $lineItem->salesDiscounts()->syncWithoutDetaching($offering->salesDiscounts->pluck('id')->toArray());
-                }
+                $lineItem->salesTaxes()->syncWithoutDetaching($offering->salesTaxes->pluck('id')->toArray());
+                $lineItem->salesDiscounts()->syncWithoutDetaching($offering->salesDiscounts->pluck('id')->toArray());
 
                 $lineItem->refresh();
 
     {
         return $this
             ->for($bill, 'documentable')
-            ->state(function (array $attributes) {
-                $offering = Offering::where('purchasable', true)
+            ->for($bill->company, 'company')
+            ->afterCreating(function (DocumentLineItem $lineItem) {
+                $offering = Offering::query()
+                    ->where('company_id', $lineItem->company_id)
+                    ->where('purchasable', true)
                     ->inRandomOrder()
-                    ->first();
+                    ->firstOrFail();
 
-                return [
+                $lineItem->updateQuietly([
                     'offering_id' => $offering->id,
                     'unit_price' => $offering->price,
-                ];
-            })
-            ->afterCreating(function (DocumentLineItem $lineItem) {
-                $offering = $lineItem->offering;
+                ]);
 
-                if ($offering) {
-                    $lineItem->purchaseTaxes()->syncWithoutDetaching($offering->purchaseTaxes->pluck('id')->toArray());
-                    $lineItem->purchaseDiscounts()->syncWithoutDetaching($offering->purchaseDiscounts->pluck('id')->toArray());
-                }
+                $lineItem->purchaseTaxes()->syncWithoutDetaching($offering->purchaseTaxes->pluck('id')->toArray());
+                $lineItem->purchaseDiscounts()->syncWithoutDetaching($offering->purchaseDiscounts->pluck('id')->toArray());
 
                 $lineItem->refresh();
 

database/factories/Accounting/EstimateFactory.php

 use App\Models\Accounting\DocumentLineItem;
 use App\Models\Accounting\Estimate;
 use App\Models\Common\Client;
+use App\Models\Company;
 use App\Models\Setting\DocumentDefault;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Support\Carbon;
 
         return [
             'company_id' => 1,
-            'client_id' => Client::inRandomOrder()->value('id'),
+            'client_id' => fn (array $attributes) => Client::where('company_id', $attributes['company_id'])->inRandomOrder()->value('id'),
             'header' => 'Estimate',
             'subheader' => 'Estimate',
             'estimate_number' => $this->faker->unique()->numerify('EST-####'),
             'date' => $estimateDate,
             'expiration_date' => Carbon::parse($estimateDate)->addDays($this->faker->numberBetween(14, 30)),
             'status' => EstimateStatus::Draft,
-            'currency_code' => 'USD',
+            'currency_code' => function (array $attributes) {
+                $client = Client::find($attributes['client_id']);
+
+                return $client->currency_code ??
+                    Company::find($attributes['company_id'])->default->currency_code ??
+                    'USD';
+            },
             'terms' => $this->faker->sentence,
             'footer' => $this->faker->sentence,
             'created_by' => 1,

database/factories/Accounting/InvoiceFactory.php

 use App\Models\Accounting\Invoice;
 use App\Models\Banking\BankAccount;
 use App\Models\Common\Client;
+use App\Models\Company;
 use App\Models\Setting\DocumentDefault;
 use App\Utilities\Currency\CurrencyConverter;
 use Illuminate\Database\Eloquent\Factories\Factory;
 
         return [
             'company_id' => 1,
-            'client_id' => Client::inRandomOrder()->value('id'),
+            'client_id' => fn (array $attributes) => Client::where('company_id', $attributes['company_id'])->inRandomOrder()->value('id'),
             'header' => 'Invoice',
             'subheader' => 'Invoice',
             'invoice_number' => $this->faker->unique()->numerify('INV-####'),
             'date' => $invoiceDate,
             'due_date' => Carbon::parse($invoiceDate)->addDays($this->faker->numberBetween(14, 60)),
             'status' => InvoiceStatus::Draft,
-            'currency_code' => 'USD',
+            'currency_code' => function (array $attributes) {
+                $client = Client::find($attributes['client_id']);
+
+                return $client->currency_code ??
+                    Company::find($attributes['company_id'])->default->currency_code ??
+                    'USD';
+            },
             'terms' => $this->faker->sentence,
             'footer' => $this->faker->sentence,
             'created_by' => 1,

database/factories/Accounting/RecurringInvoiceFactory.php

 use App\Models\Accounting\DocumentLineItem;
 use App\Models\Accounting\RecurringInvoice;
 use App\Models\Common\Client;
+use App\Models\Company;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Support\Carbon;
 
     {
         return [
             'company_id' => 1,
-            'client_id' => Client::inRandomOrder()->value('id'),
+            'client_id' => fn (array $attributes) => Client::where('company_id', $attributes['company_id'])->inRandomOrder()->value('id'),
             'header' => 'Invoice',
             'subheader' => 'Invoice',
             'order_number' => $this->faker->unique()->numerify('ORD-####'),
             'payment_terms' => PaymentTerms::Net30,
             'status' => RecurringInvoiceStatus::Draft,
-            'currency_code' => 'USD',
+            'currency_code' => function (array $attributes) {
+                $client = Client::find($attributes['client_id']);
+
+                return $client->currency_code ??
+                    Company::find($attributes['company_id'])->default->currency_code ??
+                    'USD';
+            },
             'terms' => $this->faker->sentence,
             'footer' => $this->faker->sentence,
             'created_by' => 1,

database/factories/Common/AddressFactory.php

 
 use App\Enums\Common\AddressType;
 use App\Models\Common\Address;
+use Database\Factories\Concerns\HasParentRelationship;
 use Illuminate\Database\Eloquent\Factories\Factory;
 
 /**
  */
 class AddressFactory extends Factory
 {
+    use HasParentRelationship;
+
     /**
      * The name of the factory's corresponding model.
      */
             'type' => AddressType::General,
         ]);
     }
+
+    public function forCountry(string $countryCode): self
+    {
+        return $this->state([
+            'state_id' => $this->faker->state($countryCode),
+            'country_code' => $countryCode,
+        ]);
+    }
 }

database/factories/Common/ClientFactory.php

 use App\Models\Common\Address;
 use App\Models\Common\Client;
 use App\Models\Common\Contact;
+use App\Models\Company;
 use Illuminate\Database\Eloquent\Factories\Factory;
 
 /**
         return [
             'company_id' => 1,
             'name' => $this->faker->company,
-            'currency_code' => 'USD',
+            'currency_code' => fn (array $attributes) => Company::find($attributes['company_id'])->default->currency_code ?? 'USD',
             'account_number' => $this->faker->unique()->numerify(str_repeat('#', 12)),
             'website' => $this->faker->url,
             'notes' => $this->faker->sentence,
 
     public function withContacts(int $count = 1): self
     {
-        return $this->has(Contact::factory()->count($count));
+        return $this->has(
+            Contact::factory()
+                ->count($count)
+                ->useParentCompany()
+        );
     }
 
     public function withPrimaryContact(): self
     {
-        return $this->has(Contact::factory()->primary());
+        return $this->has(
+            Contact::factory()
+                ->primary()
+                ->useParentCompany()
+        );
     }
 
     public function withAddresses(): self
     {
         return $this
-            ->has(Address::factory()->billing())
-            ->has(Address::factory()->shipping());
+            ->has(Address::factory()->billing()->useParentCompany())
+            ->has(Address::factory()->shipping()->useParentCompany());
     }
 }

database/factories/Common/ContactFactory.php

 namespace Database\Factories\Common;
 
 use App\Models\Common\Contact;
+use Database\Factories\Concerns\HasParentRelationship;
 use Illuminate\Database\Eloquent\Factories\Factory;
 
 /**
  */
 class ContactFactory extends Factory
 {
+    use HasParentRelationship;
+
     /**
      * The name of the factory's corresponding model.
      */

database/factories/Common/OfferingFactory.php

             'description' => $this->faker->sentence,
             'type' => $this->faker->randomElement(OfferingType::cases()),
             'price' => $this->faker->numberBetween(5, 1000),
-            'sellable' => $this->faker->boolean(80),
-            'purchasable' => $this->faker->boolean(80),
-            'income_account_id' => function (array $attributes) {
-                return $attributes['sellable'] ? 10 : null;
-            },
-            'expense_account_id' => function (array $attributes) {
-                return $attributes['purchasable'] ? $this->faker->numberBetween(17, 35) : null;
-            },
+            'sellable' => false,
+            'purchasable' => false,
+            'income_account_id' => null,
+            'expense_account_id' => null,
             'created_by' => 1,
             'updated_by' => 1,
         ];
     }
 
-    public function sellable(): self
+    public function withSalesAdjustments(): self
     {
-        $incomeAccount = Account::query()
-            ->where('category', AccountCategory::Revenue)
-            ->where('type', AccountType::OperatingRevenue)
-            ->inRandomOrder()
-            ->first();
+        return $this->afterCreating(function (Offering $offering) {
+            $incomeAccount = Account::query()
+                ->where('company_id', $offering->company_id)
+                ->where('category', AccountCategory::Revenue)
+                ->where('type', AccountType::OperatingRevenue)
+                ->inRandomOrder()
+                ->firstOrFail();
 
-        return $this->state(function (array $attributes) use ($incomeAccount) {
-            return [
+            $offering->updateQuietly([
                 'sellable' => true,
-                'income_account_id' => $incomeAccount?->id ?? 10,
-            ];
-        });
-    }
-
-    public function purchasable(): self
-    {
-        $expenseAccount = Account::query()
-            ->where('category', AccountCategory::Expense)
-            ->where('type', AccountType::OperatingExpense)
-            ->inRandomOrder()
-            ->first();
-
-        return $this->state(function (array $attributes) use ($expenseAccount) {
-            return [
-                'purchasable' => true,
-                'expense_account_id' => $expenseAccount?->id ?? $this->faker->numberBetween(17, 35),
-            ];
-        });
-    }
+                'income_account_id' => $incomeAccount->id,
+            ]);
 
-    public function withSalesAdjustments(): self
-    {
-        return $this->afterCreating(function (Offering $offering) {
-            if ($offering->sellable) {
-                $adjustments = $offering->company?->adjustments()
-                    ->where('type', AdjustmentType::Sales)
-                    ->pluck('id');
+            $adjustments = $offering->company?->adjustments()
+                ->where('type', AdjustmentType::Sales)
+                ->pluck('id');
 
-                $adjustmentsToAttach = $adjustments->isNotEmpty()
-                    ? $adjustments->random(min(2, $adjustments->count()))
-                    : Adjustment::factory()->salesTax()->count(2)->create()->pluck('id');
+            $adjustmentsToAttach = $adjustments->isNotEmpty()
+                ? $adjustments->random(min(2, $adjustments->count()))
+                : Adjustment::factory()->salesTax()->count(2)->create()->pluck('id');
 
-                $offering->salesAdjustments()->attach($adjustmentsToAttach);
-            }
+            $offering->salesAdjustments()->attach($adjustmentsToAttach);
         });
     }
 
     public function withPurchaseAdjustments(): self
     {
         return $this->afterCreating(function (Offering $offering) {
-            if ($offering->purchasable) {
-                $adjustments = $offering->company?->adjustments()
-                    ->where('type', AdjustmentType::Purchase)
-                    ->pluck('id');
+            $expenseAccount = Account::query()
+                ->where('company_id', $offering->company_id)
+                ->where('category', AccountCategory::Expense)
+                ->where('type', AccountType::OperatingExpense)
+                ->inRandomOrder()
+                ->firstOrFail();
+
+            $offering->updateQuietly([
+                'purchasable' => true,
+                'expense_account_id' => $expenseAccount->id,
+            ]);
+
+            $adjustments = $offering->company?->adjustments()
+                ->where('type', AdjustmentType::Purchase)
+                ->pluck('id');
 
-                $adjustmentsToAttach = $adjustments->isNotEmpty()
-                    ? $adjustments->random(min(2, $adjustments->count()))
-                    : Adjustment::factory()->purchaseTax()->count(2)->create()->pluck('id');
+            $adjustmentsToAttach = $adjustments->isNotEmpty()
+                ? $adjustments->random(min(2, $adjustments->count()))
+                : Adjustment::factory()->purchaseTax()->count(2)->create()->pluck('id');
 
-                $offering->purchaseAdjustments()->attach($adjustmentsToAttach);
-            }
+            $offering->purchaseAdjustments()->attach($adjustmentsToAttach);
         });
     }
 }

database/factories/Common/VendorFactory.php

 use App\Models\Common\Address;
 use App\Models\Common\Contact;
 use App\Models\Common\Vendor;
+use App\Models\Company;
 use Illuminate\Database\Eloquent\Factories\Factory;
 
 /**
             'ein' => function (array $attributes) {
                 return $attributes['contractor_type'] === ContractorType::Business ? $this->faker->numerify(str_repeat('#', 9)) : null;
             },
-            'currency_code' => 'USD',
+            'currency_code' => fn (array $attributes) => Company::find($attributes['company_id'])->default->currency_code ?? 'USD',
             'account_number' => $this->faker->unique()->numerify(str_repeat('#', 12)),
             'website' => $this->faker->url,
             'notes' => $this->faker->sentence,
 
     public function withContact(): self
     {
-        return $this->has(Contact::factory()->primary());
+        return $this->has(Contact::factory()->primary()->useParentCompany());
     }
 
     public function withAddress(): self
     {
-        return $this->has(Address::factory()->general());
+        return $this->has(Address::factory()->general()->useParentCompany());
     }
 }

database/factories/CompanyFactory.php

         ];
     }
 
-    public function withCompanyProfile(): self
+    public function withCompanyProfile(?string $countryCode = null): self
     {
-        return $this->afterCreating(function (Company $company) {
-            CompanyProfile::factory()->forCompany($company)->withAddress()->create();
+        return $this->afterCreating(function (Company $company) use ($countryCode) {
+            CompanyProfile::factory()
+                ->forCompany($company)
+                ->withAddress($countryCode)
+                ->create();
         });
     }
 
     /**
      * Set up default settings for the company after creation.
      */
-    public function withCompanyDefaults(): self
+    public function withCompanyDefaults(string $currencyCode = 'USD', string $locale = 'en'): self
     {
-        return $this->afterCreating(function (Company $company) {
+        return $this->afterCreating(function (Company $company) use ($currencyCode, $locale) {
             $countryCode = $company->profile->address->country_code;
             $companyDefaultService = app(CompanyDefaultService::class);
-            $companyDefaultService->createCompanyDefaults($company, $company->owner, 'USD', $countryCode, 'en');
+            $companyDefaultService->createCompanyDefaults($company, $company->owner, $currencyCode, $countryCode, $locale);
         });
     }
 
 
     public function withClients(int $count = 10): self
     {
-        return $this->has(Client::factory()->count($count)->withPrimaryContact()->withAddresses());
+        return $this->afterCreating(function (Company $company) use ($count) {
+            Client::factory()
+                ->count($count)
+                ->withPrimaryContact()
+                ->withAddresses()
+                ->create([
+                    'company_id' => $company->id,
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+        });
     }
 
     public function withVendors(int $count = 10): self
     {
-        return $this->has(Vendor::factory()->count($count)->withContact()->withAddress());
+        return $this->afterCreating(function (Company $company) use ($count) {
+            Vendor::factory()
+                ->count($count)
+                ->withContact()
+                ->withAddress()
+                ->create([
+                    'company_id' => $company->id,
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+        });
     }
 
     public function withOfferings(int $count = 10): self
         return $this->afterCreating(function (Company $company) use ($count) {
             Offering::factory()
                 ->count($count)
-                ->sellable()
                 ->withSalesAdjustments()
-                ->purchasable()
                 ->withPurchaseAdjustments()
                 ->create([
                     'company_id' => $company->id,

database/factories/Concerns/HasParentRelationship.php

+<?php
+
+namespace Database\Factories\Concerns;
+
+use Illuminate\Database\Eloquent\Model;
+
+trait HasParentRelationship
+{
+    public function useParentCompany(): self
+    {
+        return $this->state(function (array $attributes, Model $parent) {
+            return [
+                'company_id' => $parent->company_id,
+                'created_by' => $parent->created_by ?? 1,
+                'updated_by' => $parent->updated_by ?? 1,
+            ];
+        });
+    }
+}

database/factories/Setting/CompanyProfileFactory.php

         ]);
     }
 
-    public function withAddress(): self
+    public function withAddress(?string $countryCode = null): self
     {
-        return $this->has(Address::factory()->general());
+        return $this->has(
+            Address::factory()
+                ->general()
+                ->when($countryCode, function (Factory $factory) use ($countryCode) {
+                    return $factory->forCountry($countryCode);
+                })
+                ->useParentCompany()
+        );
     }
 }

database/seeders/DatabaseSeeder.php

 
 namespace Database\Seeders;
 
+use App\Models\Company;
 use App\Models\User;
 use Database\Factories\CompanyFactory;
 use Illuminate\Database\Seeder;
     public function run(): void
     {
         // Create a single admin user and their personal company
-        User::factory()
+        $user = User::factory()
             ->withPersonalCompany(function (CompanyFactory $factory) {
                 return $factory
                     ->state([
                 'password' => bcrypt('password'),
                 'current_company_id' => 1,  // Assuming this will be the ID of the created company
             ]);
+
+        $additionalCompanies = [
+            ['name' => 'European Retail GmbH', 'country' => 'DE', 'currency' => 'EUR', 'locale' => 'de'],
+            ['name' => 'UK Services Ltd', 'country' => 'GB', 'currency' => 'GBP', 'locale' => 'en'],
+            ['name' => 'Canadian Manufacturing Inc', 'country' => 'CA', 'currency' => 'CAD', 'locale' => 'en'],
+            ['name' => 'Australian Hospitality Pty', 'country' => 'AU', 'currency' => 'AUD', 'locale' => 'en'],
+        ];
+
+        foreach ($additionalCompanies as $companyData) {
+            Company::factory()
+                ->state([
+                    'name' => $companyData['name'],
+                    'user_id' => $user->id,
+                    'personal_company' => false,
+                ])
+                ->withCompanyProfile($companyData['country'])
+                ->withCompanyDefaults($companyData['currency'], $companyData['locale'])
+                ->withTransactions(100)
+                ->withOfferings()
+                ->withClients()
+                ->withVendors()
+                ->withInvoices(20)
+                ->withRecurringInvoices()
+                ->withEstimates(15)
+                ->withBills(15)
+                ->create();
+        }
     }
 }