Moecasts\Laravel\Wallet\Traits\HasWallets

Complexity

Total Complexity

12

Size/Duplication

Total Lines	82
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	transactions()	0	3	1
A	safeRefund()	0	6	2
A	refund()	0	24	3
A	transfers()	0	3	1
A	wallets()	0	3	1
A	paid()	0	13	1
A	getWallet()	0	16	3

<?php

namespace Moecasts\Laravel\Wallet\Traits;

use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Database\Eloquent\Relations\MorphMany;
use Moecasts\Laravel\Wallet\Exceptions\CurrencyInvalid;
use Moecasts\Laravel\Wallet\Interfaces\Product;
use Moecasts\Laravel\Wallet\Interfaces\Refundable;
use Moecasts\Laravel\Wallet\Models\Transaction;
use Moecasts\Laravel\Wallet\Models\Transfer;
use Moecasts\Laravel\Wallet\Models\Wallet;

trait HasWallets {
    public function wallets(): MorphMany
    {
        return $this->morphMany(Wallet::class, 'holder');

It seems like morphMany() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    public function getWallet(string $currency): ?Wallet
    {
        if (! in_array($currency, config('wallet.currencies'))) {
            throw new CurrencyInvalid(trans('wallet::errors.currency_unsupported'));

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

        }

        $wallet = $this->wallets()->where('currency', $currency)->first();

        if (! $wallet) {
            $wallet = $this->wallets()->create([
                'currency' => $currency,
                'balance' => 0
            ]);
        }

        return $wallet;
    }

    public function transactions(): MorphMany
    {
        return $this->morphMany(Transaction::class, 'holder');
    }

    public function transfers(): MorphMany
    {
        return $this->morphMany(Transfer::class, 'from');
    }

    public function paid(Product $product, string $action = Transfer::ACTION_PAID)
    {
        $action = [$action];

        $query = $this->transfers();

        return $query
            ->where('refund', false)
            ->where('to_type', $product->getMorphClass())

The method getMorphClass() does not exist on Moecasts\Laravel\Wallet\Interfaces\Product. Since it exists in all sub-types, consider adding an abstract or default implementation to Moecasts\Laravel\Wallet\Interfaces\Product.

            ->where('to_id', $product->getKey())

The method getKey() does not exist on Moecasts\Laravel\Wallet\Interfaces\Product. Since it exists in all sub-types, consider adding an abstract or default implementation to Moecasts\Laravel\Wallet\Interfaces\Product.

            ->whereIn('action', $action)
            ->orderBy('id', 'desc')
            ->first();
    }

    public function refund(Refundable $product, string $action = Transfer::ACTION_PAID)
    {
        $transfer = $this->paid($product, $action);

        if (! $transfer) {
            throw (new ModelNotFoundException())
                ->setModel(config('wallet.transfer.model'));
        }

        return \DB::transaction(function () use ($transfer) {
            $transfer->withdraw->update([
                'confirmed' => false,
            ]);

            $transfer->deposit->update([
                'confirmed' => false,
            ]);

            $transfer->update([
                'refund' => true,
            ]);

            return $transfer->fromWallet->refreshBalance() &&
                $transfer->toWallet->refreshBalance();
        });
    }

    public function safeRefund(Product $product, string $action = Transfer::ACTION_PAID)
    {
        try {
            return $this->refund($product, $action);
        } catch (\Throwable $throwable) {
            return false;
        }
    }
}