Merge pull request #419 from bavix/credit

[7.x] Credit Limits

Author: rez1dent3

src/Models/Wallet.php

@@ -38,6 +38,7 @@
  * @property null|array                      $meta
  * @property int                             $decimal_places
  * @property \Bavix\Wallet\Interfaces\Wallet $holder
+ * @property string                          $credit
  * @property string                          $currency
  */
 class Wallet extends Model implements Customer, WalletFloat, Confirmable, Exchangeable
@@ -109,7 +110,7 @@ public function setNameAttribute(string $name): void
     public function refreshBalance(): bool
     {
         return app(AtomicServiceInterface::class)->block($this, function () {
-            $whatIs = $this->balance;
+            $whatIs = $this->getBalanceAttribute();
             $balance = $this->getAvailableBalanceAttribute();
             if (app(MathServiceInterface::class)->compare($whatIs, $balance) === 0) {
                 return true;
@@ -157,6 +158,11 @@ public function holder(): MorphTo
         return $this->morphTo();
     }
 
+    public function getCreditAttribute(): string
+    {
+        return (string) ($this->meta['credit'] ?? '0');
+    }
+
     public function getCurrencyAttribute(): string
     {
         return $this->meta['currency'] ?? Str::upper($this->slug);

src/Services/ConsistencyService.php

@@ -53,22 +53,41 @@ public function checkPositive($amount): void
     public function checkPotential(Wallet $object, $amount, bool $allowZero = false): void
     {
         $wallet = $this->castService->getWallet($object, false);
+        $balance = $this->mathService->add($wallet->getBalanceAttribute(), $wallet->getCreditAttribute());
 
-        if (($this->mathService->compare($amount, 0) !== 0) && !$wallet->getBalanceAttribute()) {
+        if (($this->mathService->compare($amount, 0) !== 0) && ($this->mathService->compare($balance, 0) === 0)) {
             throw new BalanceIsEmpty(
                 $this->translatorService->get('wallet::errors.wallet_empty'),
                 ExceptionInterface::BALANCE_IS_EMPTY
             );
         }
 
-        if (!$wallet->canWithdraw($amount, $allowZero)) {
+        if (!$this->canWithdraw($balance, $amount, $allowZero)) {
             throw new InsufficientFunds(
                 $this->translatorService->get('wallet::errors.insufficient_funds'),
                 ExceptionInterface::INSUFFICIENT_FUNDS
             );
         }
     }
 
+    /**
+     * @param float|int|string $balance
+     * @param float|int|string $amount
+     */
+    public function canWithdraw($balance, $amount, bool $allowZero = false): bool
+    {
+        $mathService = app(MathServiceInterface::class);
+
+        /**
+         * Allow buying for free with a negative balance.
+         */
+        if ($allowZero && !$mathService->compare($amount, 0)) {
+            return true;
+        }
+
+        return $mathService->compare($balance, $amount) >= 0;
+    }
+
     /**
      * @param TransferLazyDtoInterface[] $objects
      *

src/Services/ConsistencyServiceInterface.php

@@ -27,6 +27,12 @@ public function checkPositive($amount): void;
      */
     public function checkPotential(Wallet $object, $amount, bool $allowZero = false): void;
 
+    /**
+     * @param float|int|string $balance
+     * @param float|int|string $amount
+     */
+    public function canWithdraw($balance, $amount, bool $allowZero = false): bool;
+
     /**
      * @param TransferLazyDtoInterface[] $objects
      *

src/Traits/HasWallet.php

@@ -179,16 +179,11 @@ public function withdraw($amount, ?array $meta = null, bool $confirmed = true):
      */
     public function canWithdraw($amount, bool $allowZero = false): bool
     {
-        $math = app(MathServiceInterface::class);
+        $mathService = app(MathServiceInterface::class);
+        $wallet = app(CastServiceInterface::class)->getWallet($this);
+        $balance = $mathService->add($this->getBalanceAttribute(), $wallet->getCreditAttribute());
 
-        /**
-         * Allow buying for free with a negative balance.
-         */
-        if ($allowZero && !$math->compare($amount, 0)) {
-            return true;
-        }
-
-        return $math->compare($this->balance, $amount) >= 0;
+        return app(ConsistencyServiceInterface::class)->canWithdraw($balance, $amount, $allowZero);
     }
 
     /**

src/Traits/HasWalletFloat.php

@@ -161,6 +161,6 @@ public function getBalanceFloatAttribute()
         $decimalPlacesValue = $wallet->decimal_places;
         $decimalPlaces = $math->powTen($decimalPlacesValue);
 
-        return $math->div($wallet->balance, $decimalPlaces, $decimalPlacesValue);
+        return $math->div($wallet->getBalanceAttribute(), $decimalPlaces, $decimalPlacesValue);
     }
 }

tests/Units/Domain/CreditWalletTest.php

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Bavix\Wallet\Test\Units\Domain;
+
+use Bavix\Wallet\Test\Infra\Factories\UserMultiFactory;
+use Bavix\Wallet\Test\Infra\Models\UserMulti;
+use Bavix\Wallet\Test\Infra\TestCase;
+
+/**
+ * @internal
+ */
+class CreditWalletTest extends TestCase
+{
+    public function testCreditLimit(): void
+    {
+        /** @var UserMulti $user */
+        $user = UserMultiFactory::new()->create();
+        $wallet = $user->createWallet([
+            'name' => 'Credit USD',
+            'slug' => 'credit-usd',
+            'meta' => ['credit' => 10000, 'currency' => 'USD'],
+        ]);
+
+        $transaction = $wallet->deposit(1000);
+        self::assertNotNull($transaction);
+
+        self::assertSame(1000, $wallet->balanceInt);
+        self::assertSame(10., (float) $wallet->balanceFloat);
+
+        $transaction = $wallet->withdraw(10000);
+        self::assertNotNull($transaction);
+        self::assertSame(-9000, $wallet->balanceInt);
+    }
+
+    public function testCreditLimitBalanceZero(): void
+    {
+        /** @var UserMulti $user */
+        $user = UserMultiFactory::new()->create();
+        $wallet = $user->createWallet([
+            'name' => 'Credit USD',
+            'slug' => 'credit-usd',
+            'meta' => ['credit' => 10000, 'currency' => 'USD'],
+        ]);
+
+        self::assertSame(0, $wallet->balanceInt);
+        self::assertSame(0., (float) $wallet->balanceFloat);
+
+        $transaction = $wallet->withdraw(10000);
+        self::assertNotNull($transaction);
+        self::assertSame(-10000, $wallet->balanceInt);
+    }
+}