Siak\Tontine\Service\Meeting\Pool\DepositService::saveDepositAmount()

Complexity

Conditions	5
Paths	4

Size

Total Lines	25
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
A	DepositService::createAllDeposits()	0	15	3

<?php

namespace Siak\Tontine\Service\Meeting\Pool;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Collection;
use Siak\Tontine\Model\Deposit;
use Siak\Tontine\Model\DepositReal;
use Siak\Tontine\Model\Pool;
use Siak\Tontine\Model\Receivable;
use Siak\Tontine\Model\Session;
use Siak\Tontine\Service\Payment\PaymentServiceInterface;
use Siak\Tontine\Service\TenantService;
use Siak\Tontine\Validation\SearchSanitizer;

class DepositService
{
    use DepositServiceTrait;

The trait Siak\Tontine\Service\Meeting\Pool\DepositServiceTrait requires some properties which are not provided by Siak\Tontine\Service\Meeting\Pool\DepositService: $deposit_fixed, $id, $deposit

    /**
     * @param TenantService $tenantService
     * @param PaymentServiceInterface $paymentService
     * @param SearchSanitizer $searchSanitizer
     */
    public function __construct(protected TenantService $tenantService,
        protected PaymentServiceInterface $paymentService,
        protected SearchSanitizer $searchSanitizer)
    {}

    /**
     * @param Pool $pool
     * @param Session $session
     * @param bool|null $filter
     * @param string $search
     *
     * @return Builder|Relation
     */
    private function getQuery(Pool $pool, Session $session,
        ?bool $filter = null, string $search = ''): Builder|Relation
    {
        $filterQuery = match($filter) {
            true => fn(Builder $query) => $query->paid(),
            false => fn(Builder $query) => $query->unpaid(),
            default => null,
        };
        $search = $this->searchSanitizer->sanitize($search);

        return $session->receivables()
            ->select('receivables.*')
            ->join('subscriptions', 'subscriptions.id', '=', 'receivables.subscription_id')
            ->where('subscriptions.pool_id', $pool->id)
            ->when($filterQuery !== null, $filterQuery)
            ->when($search !== '', fn(Builder $query) => $query->search($search));
    }

    /**
     * @param Pool $pool
     * @param Session $session
     * @param bool|null $filter
     * @param string $search
     * @param int $page
     *
     * @return Collection
     */
    public function getReceivables(Pool $pool, Session $session,
        ?bool $filter = null, string $search = '', int $page = 0): Collection
    {
        // The jointure with the subscriptions and members tables is needed,
        // so the final records can be ordered by member name.
        $query = $this->getQuery($pool, $session, $filter, $search);
        return $this->getReceivableDetailsQuery($query, $page)->get();
    }

    /**
     * Get the number of receivables in the selected round.
     *
     * @param Pool $pool
     * @param Session $session
     * @param bool|null $filter
     * @param string $search
     *
     * @return int
     */
    public function getReceivableCount(Pool $pool, Session $session,
        ?bool $filter = null, string $search = ''): int
    {
        return $this->getQuery($pool, $session, $filter, $search)->count();

The expression return $this->getQuery($pool, $session, $filter, $search)->count() could return the type Illuminate\Database\Eloquent\Builder|Illuminate\Database\Eloquent\Relations\Relation which is incompatible with the type-hinted return integer. Consider adding an additional type-check to rule them out.

    }

    /**
     * Find the unique receivable for a pool and a session.
     *
     * @param Pool $pool The pool
     * @param Session $session The session
     * @param int $receivableId
     *
     * @return Receivable|null
     */
    public function getReceivable(Pool $pool, Session $session, int $receivableId): ?Receivable
    {
        return $this->getQuery($pool, $session)
            ->with(['deposit'])
            ->find($receivableId);
    }

    /**
     * Create a deposit.
     *
     * @param Pool $pool The pool
     * @param Session $session The session
     * @param int $receivableId
     * @param int $amount
     *
     * @return void
     */
    public function createDeposit(Pool $pool, Session $session,
        int $receivableId, int $amount = 0): void
    {
        $receivable = $this->getReceivable($pool, $session, $receivableId);
        $this->checkDepositCreation($pool, $receivable, $amount);

        $this->saveDeposit($receivable, $session, $amount);
    }

    /**
     * Delete a deposit.
     *
     * @param Pool $pool The pool
     * @param Session $session The session
     * @param int $receivableId
     *
     * @return void
     */
    public function deleteDeposit(Pool $pool, Session $session, int $receivableId): void
    {
        $receivable = $this->getReceivable($pool, $session, $receivableId);
        $this->_deleteDeposit($receivable);
    }

    /**
     * Create all deposits for a pool.
     *
     * @param Pool $pool The pool
     * @param Session $session The session
     * @param string $search
     *
     * @return void
     */
    public function createAllDeposits(Pool $pool, Session $session, string $search): void
    {
        $receivables = $this->getQuery($pool, $session, false, $search)->get();
        if($receivables->count() === 0)
        {
            return;
        }

        DB::transaction(function() use($session, $receivables) {
            foreach($receivables as $receivable)
            {
                $deposit = new DepositReal();
                $deposit->receivable()->associate($receivable);
                $deposit->session()->associate($session);
                $deposit->save();
            }
        });
    }

    /**
     * Delete all deposits for a pool.
     *
     * @param Pool $pool The pool
     * @param Session $session The session
     * @param string $search
     *
     * @return void
     */
    public function deleteAllDeposits(Pool $pool, Session $session, string $search): void
    {
        $receivables = $this->getQuery($pool, $session, true, $search)
            ->with(['deposit'])
            ->get()
            ->filter(fn($receivable) =>
                $this->paymentService->isEditable($receivable->deposit));
        if($receivables->count() === 0)
        {
            return;
        }

        DepositReal::whereIn('receivable_id', $receivables->pluck('id'))
            ->where('session_id', $session->id)
            ->delete();
    }

    /**
     * @param Pool $pool The pool
     * @param Session $session The session
     *
     * @return int
     */
    public function getPoolDepositCount(Pool $pool, Session $session): int
    {
        return $this->getQuery($pool, $session, true)->count();

The expression return $this->getQuery($pool, $session, true)->count() could return the type Illuminate\Database\Eloquent\Builder|Illuminate\Database\Eloquent\Relations\Relation which is incompatible with the type-hinted return integer. Consider adding an additional type-check to rule them out.

    }

    /**
     * @param Pool $pool The pool
     * @param Session $session The session
     *
     * @return array
     */
    public function getPoolDepositNumbers(Pool $pool, Session $session): array
    {
        $pool = Pool::where('id', $pool->id)
            ->select([
                'recv_amount' => Deposit::select(DB::raw('sum(amount)'))
                    ->whereColumn('pool_id', 'pools.id')
                    ->whereHas('receivable', fn(Builder $qr) =>
                        $qr->whereSession($session)->paidHere($session)),
            ])
            ->withCount([
                'receivables as recv_count' => fn(Builder $query) =>
                    $query->whereSession($session),
                'receivables as paid_here' => fn(Builder $query) =>
                    $query->whereSession($session)->paidHere($session),
                'receivables as paid_late' => fn(Builder $query) =>
                    $query->whereSession($session)->paidLater($session),
                'receivables as paid_early' => fn(Builder $query) =>
                    $query->whereSession($session)->paidEarlier($session),
            ])
            ->first();
        return !$pool ? [0, 0, 0] : [
            $pool->recv_amount ??= 0, // The amount paid in the session

The property recv_amount does not exist on Siak\Tontine\Model\Pool. Did you mean amount?

            $pool->paid_here, // The number of recv paid in the session

The property paid_here does not seem to exist on Siak\Tontine\Model\Pool. Are you sure there is no database migration missing?

            $pool->recv_count - $pool->paid_late - $pool->paid_early, // The total expected count

The property paid_early does not seem to exist on Siak\Tontine\Model\Pool. Are you sure there is no database migration missing?

The property recv_count does not seem to exist on Siak\Tontine\Model\Pool. Are you sure there is no database migration missing?

The property paid_late does not seem to exist on Siak\Tontine\Model\Pool. Are you sure there is no database migration missing?

        ];
    }
}