CommonService::enforce() - Code Metrics - Inspection of "3.0-Dev: Architecture correction" - bavix/laravel-wallet - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#40)

by Бабичев
created 2019-05-22 10:06 UTC
CommonService::enforce() A

↳ Parent: CommonService
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes
Metric	Value
cc	1
eloc	2
nc	1
nop	2
dl	0
loc	4
ccs	0
cts	2
cp	0
crap	2
rs	10
c	0
b	0
f	0
<?php

namespace Bavix\Wallet\Services;

use Bavix\Wallet\Exceptions\BalanceIsEmpty;
use Bavix\Wallet\Exceptions\InsufficientFunds;
use Bavix\Wallet\Interfaces\Wallet;
use Bavix\Wallet\Models\Transaction;
use Bavix\Wallet\Models\Transfer;
use Bavix\Wallet\Models\Wallet as WalletModel;
use Bavix\Wallet\Objects\Bring;
use Bavix\Wallet\Objects\Operation;
use Bavix\Wallet\Traits\HasWallet;
use Illuminate\Support\Facades\DB;
use function app;
use function compact;

class CommonService
{

    /**
     * @param Wallet $from
     * @param Wallet $to
     * @param int $amount
     * @param array|null $meta
     * @param string $status
     * @return Transfer
     */
    public function transfer(Wallet $from, Wallet $to, int $amount, ?array $meta = null, string $status = Transfer::STATUS_TRANSFER): Transfer
    {
        $this->verifyWithdraw($from, $amount);
        return $this->forceTransfer($from, $to, $amount, $meta, $status);
        return $this->forceTransfer(/** @scrutinizer ignore-type */ $from, $to, $amount, $meta, $status);
    }

    /**
     * @param Wallet $from
     * @param Wallet $to
     * @param int $amount
     * @param array|null $meta
     * @param string $status
     * @return Transfer
     */
    public function forceTransfer(Wallet $from, Wallet $to, int $amount, ?array $meta = null, string $status = Transfer::STATUS_TRANSFER): Transfer
    {
        $fee = app(WalletService::class)->fee($to, $amount);
        $withdraw = $this->forceWithdraw($from, $amount + $fee, $meta);
        $deposit = $this->deposit($to, $amount, $meta);

        $from = app(WalletService::class)
            ->getWallet($from);

        $transfers = $this->multiBrings([
            (new Bring())
                ->setStatus($status)
                ->setDeposit($deposit)
                ->setWithdraw($withdraw)
                ->setFrom($from)
                ->setTo($to)
        ]);

        return current($transfers);
    }

    /**
     * @param Wallet $wallet
     * @param int $amount
     * @param array|null $meta
     * @param bool|null $confirmed
     * @return Transaction
     */
    public function forceWithdraw(Wallet $wallet, int $amount, ?array $meta, bool $confirmed = true): Transaction
    {
        $walletService = app(WalletService::class);
        $walletService->checkAmount($amount);

        /**
         * @var WalletModel $wallet
         */
        $wallet = $walletService->getWallet($wallet);

        $transactions = $this->multiOperation($wallet, [
            (new Operation())
                ->setType(Transaction::TYPE_WITHDRAW)
                ->setConfirmed($confirmed)
                ->setAmount(-$amount)
                ->setMeta($meta)
        ]);

        return current($transactions);
    }

    /**
     * @param Wallet $wallet
     * @param int $amount
     * @param array|null $meta
     * @param bool $confirmed
     * @return Transaction
     */
    public function deposit(Wallet $wallet, int $amount, ?array $meta, bool $confirmed = true): Transaction
    {
        $walletService = app(WalletService::class);
        $walletService->checkAmount($amount);

        /**
         * @var WalletModel $wallet
         */
        $wallet = $walletService->getWallet($wallet);

        $transactions = $this->multiOperation($wallet, [
            (new Operation())
                ->setType(Transaction::TYPE_DEPOSIT)
                ->setConfirmed($confirmed)
                ->setAmount($amount)
                ->setMeta($meta)
        ]);

        return current($transactions);
    }

    /**
     * @param Wallet $wallet
     * @param int $amount
     * @return void
     * @throws BalanceIsEmpty
     * @throws InsufficientFunds
     */
    public function verifyWithdraw(Wallet $wallet, int $amount): void
    {
        /**
         * @var HasWallet $wallet
         */
        if ($amount && !$wallet->balance) {
            throw new BalanceIsEmpty(trans('wallet::errors.wallet_empty'));
            throw new BalanceIsEmpty(/** @scrutinizer ignore-type */ trans('wallet::errors.wallet_empty'));
        }

        if (!$wallet->canWithdraw($amount)) {
            throw new InsufficientFunds(trans('wallet::errors.insufficient_funds'));
            throw new InsufficientFunds(/** @scrutinizer ignore-type */ trans('wallet::errors.insufficient_funds'));
        }
    }

    /**
     * Create Operation with DB::transaction
     *
     * @param Wallet $self
     * @param Operation[] $transactions
     * @return Transaction[]
     */
    public function enforce(Wallet $self, array $transactions): array
    {
        return DB::transaction(function () use ($self, $transactions) {
            return $this->multiOperation($self, $transactions);
        });
    }

    /**
     * Create Operation without DB::transaction
     *
     * @param Wallet $self
     * @param array $operations
     * @return array
     */
    public function multiOperation(Wallet $self, array $operations): array
    {
        $amount = 0;
        $objects = [];
        foreach ($operations as $operation) {
            if ($operation->isConfirmed()) {
                $amount += $operation->getAmount();
            }

            $objects[] = $operation
                ->setWallet($self)
                ->create();
        }

        $this->addBalance($self, $amount);
        return $objects;
    }

    /**
     * Create Bring with DB::transaction
     *
     * @param Bring[] $brings
     * @return array
     * @throws
     */
    public function assemble(array $brings): array
    {
        return DB::transaction(function () use ($brings) {
            return $this->multiBrings($brings);
        });
    }

    /**
     * Create Bring without DB::transaction
     *
     * @param array $brings
     * @return array
     */
    public function multiBrings(array $brings): array
    {
        $objects = [];
        foreach ($brings as $bring) {
            $objects[] = $bring->create();
        }

        return $objects;
    }

    /**
     * @param Wallet $wallet
     * @param int $amount
     * @return bool
     * @throws
     */
    public function addBalance(Wallet $wallet, int $amount): bool
    {
        /**
         * @var ProxyService $proxy
         * @var WalletModel $wallet
         */
        $proxy = app(ProxyService::class);
        $balance = $wallet->balance + $amount;
        if ($proxy->has($wallet->getKey())) {
        if ($proxy->has(/** @scrutinizer ignore-type */ $wallet->getKey())) {
            $balance = $proxy->get($wallet->getKey()) + $amount;
            $balance = $proxy->get(/** @scrutinizer ignore-type */ $wallet->getKey()) + $amount;
        }

        $result = $wallet->update(compact('balance'));
        $proxy->set($wallet->getKey(), $balance);
        $proxy->set(/** @scrutinizer ignore-type */ $wallet->getKey(), $balance);

        return $result;
    }

}

bavix / laravel-wallet

Pull Request — master (#40)

CommonService::enforce() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
