FundService::getFundDefs() - Code Metrics - lagdo/tontine - Measure and Improve Code Quality continuously with Scrutinizer

FundService::getFundDefs() A
last analyzed 2025-09-25 10:51 UTC

↳ Parent: FundService

Complexity

Conditions	1
Paths	1

Size

Total Lines	13
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	9
nc	1
nop	3
dl	0
loc	13
rs	9.9666
c	1
b	0
f	0

<?php

namespace Siak\Tontine\Service\Planning;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Support\Collection;
use Siak\Tontine\Exception\MessageException;
use Siak\Tontine\Model\Fund;
use Siak\Tontine\Model\FundDef;
use Siak\Tontine\Model\Round;
use Siak\Tontine\Service\TenantService;
use Exception;

class FundService
{
    use SessionTrait;


    /**
     * @param TenantService $tenantService
     */
    public function __construct(protected TenantService $tenantService)
    {}

    /**
     * @param Round $round
     * @param bool $filter|null
     *
     * @return Relation
     */
    private function getQuery(Round $round, ?bool $filter): Relation
    {
        $onRoundFilter = fn(Builder|Relation $q) => $q->ofRound($round);
        return $round->guild->funds()
            ->when($filter === true, fn(Builder|Relation $query) => $query
                ->whereHas('funds', $onRoundFilter))
            ->when($filter === false, fn(Builder|Relation $query) => $query
                ->whereDoesntHave('funds', $onRoundFilter));
    }

    /**
     * Get a paginated list of funds.
     *
     * @param Round $round
     * @param bool $filter|null
     * @param int $page
     *
     * @return Collection
     */
    public function getFundDefs(Round $round, ?bool $filter, int $page = 0): Collection
    {
        return $this->getQuery($round, $filter)
            ->with([
                'funds' => fn(Builder|Relation $q) =>
                    $q->where('round_id', $round->id),
            ])
            ->withCount([
                'funds as funds_in_round_count' =>
                    fn(Builder|Relation $q) => $q->ofRound($round),
            ])
            ->page($page, $this->tenantService->getLimit())
            ->get();
    }

    /**
     * Get the number of funds.
     *
     * @param Round $round
     * @param bool $filter|null
     *
     * @return int
     */
    public function getFundDefCount(Round $round, ?bool $filter): int
    {
        return $this->getQuery($round, $filter)->count();
    }

    /**
     * Get a fund.
     *
     * @param Round $round
     * @param int $fundId
     *
     * @return Fund|null
     */
    public function getFund(Round $round, int $fundId): ?Fund
    {
        return Fund::ofRound($round)->with(['sessions'])->find($fundId);
    }

    /**
     * @param Round $round
     * @param int $defId
     *
     * @return FundDef|null
     */
    public function getFundDef(Round $round, int $defId): ?FundDef
    {
        return $round->guild->funds()
            // ->user()
            ->withCount([
                'funds' => fn(Builder|Relation $q) =>
                    $q->where('round_id', $round->id),
            ])
            ->find($defId);
    }

    /**
     * @param Round $round
     * @param int $defId
     *
     * @return void
     */
    public function enableFund(Round $round, int $defId): void
    {
        $def = $this->getFundDef($round, $defId);
        if(!$def || $def->funds_count > 0)

        {
            return; // Todo: throw an exception
        }

        $itemQuery = Fund::withoutGlobalScopes()->where('def_id', $defId);
        $startSession = $this->getStartSession($round, $itemQuery);
        $startSession = $this->getStartSession($round, /** @scrutinizer ignore-type */ $itemQuery);
        $endSession = $this->getEndSession($round, $itemQuery);
        $endSession = $this->getEndSession($round, /** @scrutinizer ignore-type */ $itemQuery);
        if($endSession->day_date <= $startSession->day_date)
        {
            return; // Todo: throw an exception
        }

        // Create the fund
        $def->funds()->create([
            'round_id' => $round->id,
            'start_sid' => $startSession->id,
            'end_sid' => $endSession->id,
            'interest_sid' => $endSession->id,
        ]);
    }

    /**
     * @param Round $round
     * @param int $defId
     *
     * @return void
     */
    public function disableFund(Round $round, int $defId): void
    {
        $def = $this->getFundDef($round, $defId);
        if(!$def || $def->funds_count === 0)

        {
            return;
        }

        try
        {
            // Delete the fund
            $def->funds()->where('round_id', $round->id)->delete();
        }
        catch(Exception $e)
        {
            throw new MessageException(trans('tontine.fund.errors.cannot_remove'));
        }
    }

    /**
     * Save the fund sessions.
     *
     * @param Fund $fund
     * @param array $values
     *
     * @return void
     */
    public function saveSessions(Fund $fund, array $values)
    {
        $fund->update($values);
    }

    /**
     * Get the number of active funds in the round.
     *
     * @param Round $round
     *
     * @return int
     */
    public function getFundCount(Round $round): int
    {
        return $round->funds()->real()/*->user()*/->count();
    }
}


lagdo / tontine

FundService::getFundDefs() A last analyzed 2025-09-25 10:51 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

FundService::getFundDefs() A
last analyzed 2025-09-25 10:51 UTC