Moecasts\Laravel\Wallet\Models\Wallet

Complexity

Total Complexity

26

Size/Duplication

Total Lines	188
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	transfer()	0	9	1
A	canWithdraw()	0	3	1
A	getAvailableBalance()	0	6	1
A	deposit()	0	7	1
A	withdraw()	0	7	2
A	refreshBalance()	0	9	1
A	transfers()	0	3	1
A	holderTransfers()	0	3	1
A	getBalanceAttribute()	0	10	3
A	addBalance()	0	12	2
A	assemble()	0	14	1
A	holder()	0	3	1
A	forceTransfer()	0	9	1
A	checkAmount()	0	4	2
A	forceWithdraw()	0	7	1
A	change()	0	16	2
A	coefficient()	0	3	1
A	transactions()	0	3	1
A	safeTransfer()	0	6	2

<?php

namespace Moecasts\Laravel\Wallet\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\MorphMany;
use Illuminate\Database\Eloquent\Relations\MorphTo;
use Illuminate\Support\Facades\DB;
use Moecasts\Laravel\Wallet\Exceptions\AmountInvalid;
use Moecasts\Laravel\Wallet\Exceptions\InsufficientFunds;
use Moecasts\Laravel\Wallet\Interfaces\Transferable;
use Moecasts\Laravel\Wallet\Models\Transaction;
use Moecasts\Laravel\Wallet\Tax;
use Moecasts\Laravel\Wallet\Traits\CanPay;
use Moecasts\Laravel\Wallet\WalletProxy;
use Ramsey\Uuid\Uuid;

class Wallet extends Model
{
    use CanPay;

The trait Moecasts\Laravel\Wallet\Traits\CanPay requires some properties which are not provided by Moecasts\Laravel\Wallet\Models\Wallet: $withdraw, $deposit, $fromWallet, $toWallet

    protected $fillable = [
        'holder_type',
        'holder_id',
        'currency',
        'balance'
    ];

    public function holder(): MorphTo
    {
        return $this->morphTo();
    }

    public function transactions(): HasMany
    {
        return $this->hasMany(Transaction::class);
    }

    public function holderTransfers(): MorphMany
    {
        return $this->holder->transfers();
    }

    public function transfers(): HasMany
    {
        return $this->hasMany(Transfer::class, 'from_wallet_id');
    }

    public function deposit(float $amount, ?array $meta = null, bool $confirmed = true): Transaction
    {
        $this->checkAmount($amount);

$amount of type double is incompatible with the type integer expected by parameter $amount of Moecasts\Laravel\Wallet\Models\Wallet::checkAmount().

        $amount = (int) ($amount * $this->coefficient($this->currency));

        return $this->change(Transaction::TYPE_DEPOSIT, $amount, $meta, $confirmed);
    }

    private function checkAmount(int $amount): void
    {
        if ($amount < 0) {
            throw new AmountInvalid(trans('wallet::errors.price_positive'));

It seems like trans('wallet::errors.price_positive') can also be of type array; however, parameter $message of Moecasts\Laravel\Wallet\Exceptions\AmountInvalid::__construct() does only seem to accept string, maybe add an additional type check?

        }
    }

    protected function change(string $type, int $amount, ?array $meta, bool $confirmed): Transaction
    {
        return DB::transaction(function () use ($type, $amount, $meta, $confirmed) {
            if ($confirmed) {
                $this->addBalance($amount);
            }

            return $this->transactions()->create([
                'type' => $type,
                'holder_type' => $this->holder->getMorphClass(),
                'holder_id' => $this->holder->getKey(),
                'wallet_id' => $this->getKey(),
                'uuid' => Uuid::uuid4()->toString(),
                'confirmed' => $confirmed,
                'amount' => $amount,
                'meta' => $meta,
            ]);
        });
    }

    protected function addBalance(float $amount): bool
    {
        $newBalance = $this->attributes['balance'] + $amount;
        $this->balance = $newBalance;
        $finalBalance = $newBalance / $this->coefficient($this->attributes['currency']);

        return
            // update database wallet
            $this->save() &&

            // update static wallet
            WalletProxy::set($this->getKey(), $finalBalance);
    }

    public function getBalanceAttribute(): float
    {
        $this->exists or $this->save();

        if (! WalletProxy::has($this->getKey())) {
            $balance = $this->attributes['balance'] / $this->coefficient($this->attributes['currency']);
            WalletProxy::set($this->getKey(), (float) ($balance ?? 0));
        }

        return WalletProxy::get($this->getKey());
    }

    public function safeTransfer(Transferable $transferable, float $amount, ?array $meta = null, string $action = Transfer::ACTION_TRANSFER): ?Transfer
    {
        try {
            return $this->transfer($transferable, $amount, $meta, $action);
        } catch (\Throwable $throwable) {
            return null;
        }
    }

    public function transfer(Transferable $transferable, float $amount, ?array $meta = null, string $action = Transfer::ACTION_TRANSFER): Transfer
    {
        $wallet = $transferable->getReceiptWallet($this->currency);

        return DB::transaction(function () use ($transferable, $amount, $wallet, $meta, $action) {
            $fee = Tax::fee($transferable, $wallet, $amount);
            $withdraw = $this->withdraw($amount + $fee, $meta);
            $deposit = $wallet->deposit($amount, $meta);
            return $this->assemble($transferable, $wallet, $withdraw, $deposit, $action);
        });
    }

    public function withdraw(float $amount, ?array $meta = null, bool $confirmed = true): Transaction
    {
        if (! $this->canWithdraw($amount)) {
            throw new InsufficientFunds(trans('wallet::errors.insufficient_funds'));

It seems like trans('wallet::errors.insufficient_funds') can also be of type array; however, parameter $message of Moecasts\Laravel\Wallet\Exceptions\InsufficientFunds::__construct() does only seem to accept string, maybe add an additional type check?

        }

        return $this->forceWithdraw($amount, $meta, $confirmed);
    }

    public function canWithdraw($amount): bool
    {
        return $this->balance >= $amount;
    }

    public function forceWithdraw(float $amount, ?array $meta = null, bool $confirmed = true): Transaction
    {
        $amount = (int) ($amount * $this->coefficient($this->currency));

        $this->checkAmount($amount);

        return $this->change(Transaction::TYPE_WITHDRAW, -$amount, $meta, $confirmed);
    }

    protected function assemble(Transferable $transferable, Wallet $wallet, Transaction $withdraw, Transaction $deposit, string $action = Transfer::ACTION_PAID): Transfer
    {
        return \app('moecasts.wallet::transfer')->create([

The method create() does not exist on Illuminate\Contracts\Foundation\Application.

            'action' => $action,
            'deposit_id' => $deposit->getKey(),
            'withdraw_id' => $withdraw->getKey(),
            'from_type' => $this->holder->getMorphClass(),
            'from_id' => $this->holder->getKey(),
            'from_wallet_id' => $this->getKey(),
            'to_type' => $transferable->getMorphClass(),

The method getMorphClass() does not exist on Moecasts\Laravel\Wallet\Interfaces\Transferable. It seems like you code against a sub-type of said class. However, the method does not exist in Moecasts\Laravel\Wallet\Interfaces\Product. Are you sure you never get one of those?

            'to_id' => $transferable->getKey(),

The method getKey() does not exist on Moecasts\Laravel\Wallet\Interfaces\Transferable. It seems like you code against a sub-type of said class. However, the method does not exist in Moecasts\Laravel\Wallet\Interfaces\Product. Are you sure you never get one of those?

            'to_wallet_id' => $wallet->getKey(),
            'fee' => \abs($withdraw->amount) - \abs($deposit->amount),
            'uuid' => Uuid::uuid4()->toString(),
        ]);
    }

    public function forceTransfer(Transferable $transferable, float $amount, ?array $meta = null, string $action = Transfer::ACTION_TRANSFER): Transfer
    {
        $wallet = $transferable->getReceiptWallet($this->currency);

        return DB::transaction(function () use ($transferable, $amount, $wallet, $meta, $action) {
            $fee = Tax::fee($transferable, $wallet, $amount);
            $withdraw = $this->forceWithdraw($amount + $fee, $meta);
            $deposit = $wallet->deposit($amount, $meta);
            return $this->assemble($transferable, $wallet, $withdraw, $deposit, $action);
        });
    }

    public function refreshBalance(): bool
    {
        $balance = $this->getAvailableBalance();

        $this->attributes['balance'] = $balance;

        WalletProxy::set($this->getKey(), $balance);

        return $this->save();
    }

    public function getAvailableBalance(): int
    {
        return $this->transactions()
            ->where('wallet_id', $this->getKey())
            ->where('confirmed', true)
            ->sum('amount');
    }

    public function coefficient(string $currency = ''): float
    {
        return config('wallet.coefficient.' . $currency , 100.);
    }
}