Bavix\Wallet\Traits\CanBePaid

Complexity

Total Complexity

11

Size/Duplication

Total Lines	96
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	paid()	0	11	1
A	pay()	0	7	2
A	safePay()	0	6	2
A	refund()	0	17	3
A	forceRefund()	0	3	1
A	safeRefund()	0	6	2

<?php

namespace Bavix\Wallet\Traits;

use Bavix\Wallet\Exceptions\ProductEnded;
use Bavix\Wallet\Interfaces\Product;
use Bavix\Wallet\Models\Transfer;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Support\Facades\DB;

trait CanBePaid
{

    use HasWallet;

    /**
     * @param Product $product
     * @return Transfer
     * @throws
     */
    public function pay(Product $product): Transfer
    {
        if (!$product->canBuy($this)) {

$this of type Bavix\Wallet\Traits\CanBePaid is incompatible with the type Bavix\Wallet\Interfaces\Customer expected by parameter $customer of Bavix\Wallet\Interfaces\Product::canBuy().

            throw new ProductEnded('The product is out of stock');
        }

        return $this->transfer($product, $product->getAmountProduct(), $product->getMetaProduct());
    }

    /**
     * @param Product $product
     * @return Transfer|null
     */
    public function safePay(Product $product): ?Transfer
    {
        try {
            return $this->pay($product);
        } catch (\Throwable $throwable) {
            return null;
        }
    }

    /**
     * @param Product $product
     * @return null|Transfer
     */
    public function paid(Product $product): ?Transfer
    {
        /**
         * @var Model $product
         */
        return $this->transfers()
            ->where('to_type', $product->getMorphClass())
            ->where('to_id', $product->getKey())
            ->where('refund', 0)
            ->orderBy('id', 'desc')
            ->first();
    }

    /**
     * @param Product $product
     * @param bool $force
     * @return bool
     * @throws
     */
    public function refund(Product $product, bool $force = false): bool
    {
        $transfer = $this->paid($product);

        if (!$transfer) {
            throw (new ModelNotFoundException())
                ->setModel($this->transfers()->getMorphClass());
        }

        return DB::transaction(function() use ($product, $transfer, $force) {
            if ($force) {
                $product->forceTransfer($this, $product->getAmountProduct(), $product->getMetaProduct());

$this of type Bavix\Wallet\Traits\CanBePaid is incompatible with the type Bavix\Wallet\Interfaces\Wallet expected by parameter $wallet of Bavix\Wallet\Interfaces\Wallet::forceTransfer().

            } else {
                $product->transfer($this, $product->getAmountProduct(), $product->getMetaProduct());

$this of type Bavix\Wallet\Traits\CanBePaid is incompatible with the type Bavix\Wallet\Interfaces\Wallet expected by parameter $wallet of Bavix\Wallet\Interfaces\Wallet::transfer().

            }

            return $transfer->update(['refund' => 1]);
        });
    }

    /**
     * @param Product $product
     * @param bool $force
     * @return bool
     */
    public function safeRefund(Product $product, bool $force = false): bool
    {
        try {
            return $this->refund($product, $force);
        } catch (\Throwable $throwable) {
            return false;
        }
    }

    /**
     * @param Product $product
     * @return bool
     */
    public function forceRefund(Product $product): bool
    {
        return $this->refund($product, true);
    }

}