PartialRefundService::canPartiallyRefund() - Code Metrics - Inspection of "Merge branch feat/merge-partial-final-refund-pages" - lagdo/tontine - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — main (#62)

by Thierry

created 2025-03-15 03:01 UTC

PartialRefundService::canPartiallyRefund() A

↳ Parent: PartialRefundService

Complexity

Conditions	2
Paths	2

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	1
c	0
b	0
f	0
nc	2
nop	2
dl	0
loc	3
rs	10

<?php

namespace Siak\Tontine\Service\Meeting\Credit;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Log;
use Siak\Tontine\Exception\MessageException;
use Siak\Tontine\Model\Debt;
use Siak\Tontine\Model\Fund;
use Siak\Tontine\Model\PartialRefund;
use Siak\Tontine\Model\Session;
use Siak\Tontine\Service\LocaleService;
use Siak\Tontine\Service\Meeting\PaymentServiceInterface;
use Siak\Tontine\Service\TenantService;
use Siak\Tontine\Service\Tontine\FundService;

use function trans;

class PartialRefundService
{
    use RefundTrait;


    /**
     * @param DebtCalculator $debtCalculator
     * @param TenantService $tenantService
     * @param LocaleService $localeService
     * @param FundService $fundService
     * @param PaymentServiceInterface $paymentService;
     */
    public function __construct(private DebtCalculator $debtCalculator,
        TenantService $tenantService, private LocaleService $localeService,
        FundService $fundService, private PaymentServiceInterface $paymentService)
    {
        $this->tenantService = $tenantService;
        $this->fundService = $fundService;
    }

    /**
     * @param Session $session The session
     * @param Fund $fund
     *
     * @return Builder|Relation
     */
    private function getQuery(Session $session, Fund $fund): Builder|Relation
    {
        return $session->partial_refunds()
            ->whereHas('debt', function(Builder|Relation $query) use($fund) {
                $query->whereHas('loan', function(Builder|Relation $query) use($fund) {
                    $query->where('fund_id', $fund->id);
                });
            });
    }

    /**
     * Get the number of partial refunds.
     *
     * @param Session $session The session
     * @param Fund $fund
     *
     * @return int
     */
    public function getPartialRefundCount(Session $session, Fund $fund): int
    {
        return $this->getQuery($session, $fund)->count();

    }

    /**
     * Get the partial refunds.
     *
     * @param Session $session The session
     * @param Fund $fund
     * @param int $page
     *
     * @return Collection
     */
    public function getPartialRefunds(Session $session, Fund $fund, int $page = 0): Collection
    {
        return $this->getQuery($session, $fund)
            ->page($page, $this->tenantService->getLimit())
            ->with(['debt.refund', 'debt.loan.member', 'debt.loan.session'])
            ->orderBy('id')
            ->get()
            ->each(fn(PartialRefund $refund) => $refund->debtAmount =

                $this->debtCalculator->getDebtDueAmount($refund->debt, $session, false))
            ->sortBy('debt.loan.member.name', SORT_LOCALE_STRING)
            ->values();
    }

    /**
     * @param Session $session The session
     * @param Fund $fund
     * @param bool $with
     *
     * @return Builder|Relation
     */
    private function getUnpaidDebtsQuery(Session $session, Fund $fund, bool $with): Builder|Relation
    {
        return $this->getDebtsQuery($session, $fund, false, false)
            // A debt from a loan created in the current session can be refunded only
            // if it is an interest debt with fixed or unique interest.
            ->where(function(Builder $query) use($session) {
                $query->whereHas('loan', function(Builder $query) use($session) {
                    $query->where('session_id', '!=', $session->id);
                })->orWhere(function(Builder $query) {
                    $query->interest()
                        ->whereHas('loan', fn(Builder $q) => $q->fixedInterest());
                });
            })
            ->when($with, function(Builder $query) use($session) {
                $query->with([
                    'partial_refund' => fn($q) => $q->where('session_id', $session->id),
                ]);
            });
    }

    /**
     * Count the unpaid debts.
     *
     * @param Session $session The session
     * @param Fund $fund
     *
     * @return int
     */
    public function getUnpaidDebtCount(Session $session, Fund $fund): int
    {
        return $this->getUnpaidDebtsQuery($session, $fund, false)->count();

    }

    /**
     * Get the unpaid debts.
     *
     * @param Session $session The session
     * @param Fund $fund
     * @param int $page
     *
     * @return Collection
     */
    public function getUnpaidDebts(Session $session, Fund $fund, int $page = 0): Collection
    {
        return $this->getUnpaidDebtsQuery($session, $fund, true)
            ->page($page, $this->tenantService->getLimit())
            ->get();
    }

    /**
     * Get an unpaid debt.
     *
     * @param Session $session The session
     * @param Fund $fund
     *
     * @return Debt|null
     */
    public function getUnpaidDebt(Session $session, Fund $fund, int $debtId): ?Debt
    {
        return $this->getUnpaidDebtsQuery($session, $fund, true)->find($debtId);
    }

    /**
     * @param Session $session
     * @param Debt $debt
     *
     * @return bool
     */
    private function canPartiallyRefund(Session $session, Debt $debt): bool
    {
        return $session->opened && !$debt->refund;
    }

    /**
     * Create a refund.
     *
     * @param Session $session
     * @param Debt $debt
     * @param int $amount
     *
     * @return void
     */
    public function createPartialRefund(Session $session, Debt $debt, int $amount): void
    {
        if(!$this->canPartiallyRefund($session, $debt))
        {
            throw new MessageException(trans('meeting.refund.errors.cannot_create'));
        }
        // A partial refund must not totally refund a debt
        if($amount >= $this->debtCalculator->getDebtPayableAmount($debt, $session))
        {
            throw new MessageException(trans('meeting.refund.errors.pr_amount'));
        }

        $refund = new PartialRefund();
        $refund->amount = $amount;
        $refund->debt()->associate($debt);
        $refund->session()->associate($session);
        $refund->save();
    }

    /**
     * @param Session $session
     * @param PartialRefund $refund
     *
     * @return bool
     */
    private function canModifyPartialRefund(Session $session, PartialRefund $refund): bool
    {
        // A partial refund cannot be updated or deleted if the debt is already refunded.
        return $session->opened && $refund->debt->refund === null &&
            $this->paymentService->isEditable($refund);
    }

    /**
     * Find a refund.
     *
     * @param Session $session The session
     * @param int $refundId
     *
     * @return PartialRefund
     */
    public function getPartialRefund(Session $session, int $refundId): PartialRefund
    {
        $refund = PartialRefund::where('session_id', $session->id)
            ->with(['debt.refund'])
            ->find($refundId);
        if(!$refund)
        {
            throw new MessageException(trans('meeting.refund.errors.not_found'));
        }

        return $refund;
    }

    /**
     * Update a refund.
     *
     * @param Session $session The session
     * @param PartialRefund $refund
     * @param int $amount
     *
     * @return void
     */
    public function updatePartialRefund(Session $session, PartialRefund $refund, int $amount): void
    {
        if(!$this->canModifyPartialRefund($session, $refund))
        {
            throw new MessageException(trans('meeting.refund.errors.cannot_update'));
        }
        // A partial refund must not totally refund a debt
        $maxAmount = $refund->amount +
            $this->debtCalculator->getDebtPayableAmount($refund->debt, $session);
        if($amount >= $maxAmount)
        {
            throw new MessageException(trans('meeting.refund.errors.pr_amount'));
        }

        $refund->update(['amount' => $amount]);
    }

    /**
     * Delete a refund.
     *
     * @param Session $session The session
     * @param PartialRefund $refund
     *
     * @return void
     */
    public function deletePartialRefund(Session $session, PartialRefund $refund): void
    {
        if(!$this->canModifyPartialRefund($session, $refund))
        {
            throw new MessageException(trans('meeting.refund.errors.cannot_delete'));
        }

        $refund->delete();
    }
}


1			<?php
2
3			namespace Siak\Tontine\Service\Meeting\Credit;
4
5			use Illuminate\Database\Eloquent\Builder;
6			use Illuminate\Database\Eloquent\Relations\Relation;
7			use Illuminate\Support\Collection;
8			use Illuminate\Support\Facades\Log;
9			use Siak\Tontine\Exception\MessageException;
10			use Siak\Tontine\Model\Debt;
11			use Siak\Tontine\Model\Fund;
12			use Siak\Tontine\Model\PartialRefund;
13			use Siak\Tontine\Model\Session;
14			use Siak\Tontine\Service\LocaleService;
15			use Siak\Tontine\Service\Meeting\PaymentServiceInterface;
16			use Siak\Tontine\Service\TenantService;
17			use Siak\Tontine\Service\Tontine\FundService;
18
19			use function trans;
20
21			class PartialRefundService
22			{
23			use RefundTrait;
			0 ignored issues – show introduced 2025-03-15 03:06 UTC by Report Bug Copy Issue Report The trait `Siak\Tontine\Service\Meeting\Credit\RefundTrait` requires some properties which are not provided by `Siak\Tontine\Service\Mee...it\PartialRefundService`: `$principal_debt`, `$is_principal`, `$session_id`, `$refund`, `$opened`, `$loan`, `$interest_debt`, `$id`, `$start_at`, `$partial_refunds`, `$recurrent_interest`, `$session`, `$is_interest` Loading history...
24
25			/**
26			* @param DebtCalculator $debtCalculator
27			* @param TenantService $tenantService
28			* @param LocaleService $localeService
29			* @param FundService $fundService
30			* @param PaymentServiceInterface $paymentService;
31			*/
32			public function __construct(private DebtCalculator $debtCalculator,
33			TenantService $tenantService, private LocaleService $localeService,
34			FundService $fundService, private PaymentServiceInterface $paymentService)
35			{
36			$this->tenantService = $tenantService;
37			$this->fundService = $fundService;
38			}
39
40			/**
41			* @param Session $session The session
42			* @param Fund $fund
43			*
44			* @return Builder\|Relation
45			*/
46			private function getQuery(Session $session, Fund $fund): Builder\|Relation
47			{
48			return $session->partial_refunds()
49			->whereHas('debt', function(Builder\|Relation $query) use($fund) {
50			$query->whereHas('loan', function(Builder\|Relation $query) use($fund) {
51			$query->where('fund_id', $fund->id);
52			});
53			});
54			}
55
56			/**
57			* Get the number of partial refunds.
58			*
59			* @param Session $session The session
60			* @param Fund $fund
61			*
62			* @return int
63			*/
64			public function getPartialRefundCount(Session $session, Fund $fund): int
65			{
66			return $this->getQuery($session, $fund)->count();
			0 ignored issues – show Bug Best Practice introduced 2024-08-21 05:09 UTC by Report Bug Copy Issue Report The expression `return $this->getQuery($session, $fund)->count()` could return the type `Illuminate\Database\Eloq...uent\Relations\Relation` which is incompatible with the type-hinted return `integer`. Consider adding an additional type-check to rule them out. Loading history...
67			}
68
69			/**
70			* Get the partial refunds.
71			*
72			* @param Session $session The session
73			* @param Fund $fund
74			* @param int $page
75			*
76			* @return Collection
77			*/
78			public function getPartialRefunds(Session $session, Fund $fund, int $page = 0): Collection
79			{
80			return $this->getQuery($session, $fund)
81			->page($page, $this->tenantService->getLimit())
82			->with(['debt.refund', 'debt.loan.member', 'debt.loan.session'])
83			->orderBy('id')
84			->get()
85			->each(fn(PartialRefund $refund) => $refund->debtAmount =
			0 ignored issues – show Bug introduced 2024-08-21 05:09 UTC by Report Bug Copy Issue Report The property `debtAmount` does not seem to exist on `Siak\Tontine\Model\PartialRefund`. Are you sure there is no database migration missing? Checks if undeclared accessed properties appear in database migrations and if the creating migration is correct. Loading history...
86			$this->debtCalculator->getDebtDueAmount($refund->debt, $session, false))
87			->sortBy('debt.loan.member.name', SORT_LOCALE_STRING)
88			->values();
89			}
90
91			/**
92			* @param Session $session The session
93			* @param Fund $fund
94			* @param bool $with
95			*
96			* @return Builder\|Relation
97			*/
98			private function getUnpaidDebtsQuery(Session $session, Fund $fund, bool $with): Builder\|Relation
99			{
100			return $this->getDebtsQuery($session, $fund, false, false)
101			// A debt from a loan created in the current session can be refunded only
102			// if it is an interest debt with fixed or unique interest.
103			->where(function(Builder $query) use($session) {
104			$query->whereHas('loan', function(Builder $query) use($session) {
105			$query->where('session_id', '!=', $session->id);
106			})->orWhere(function(Builder $query) {
107			$query->interest()
108			->whereHas('loan', fn(Builder $q) => $q->fixedInterest());
109			});
110			})
111			->when($with, function(Builder $query) use($session) {
112			$query->with([
113			'partial_refund' => fn($q) => $q->where('session_id', $session->id),
114			]);
115			});
116			}
117
118			/**
119			* Count the unpaid debts.
120			*
121			* @param Session $session The session
122			* @param Fund $fund
123			*
124			* @return int
125			*/
126			public function getUnpaidDebtCount(Session $session, Fund $fund): int
127			{
128			return $this->getUnpaidDebtsQuery($session, $fund, false)->count();
			0 ignored issues – show Bug Best Practice introduced 2025-03-15 03:06 UTC by Report Bug Copy Issue Report The expression `return $this->getUnpaidD... $fund, false)->count()` could return the type `Illuminate\Database\Eloq...uent\Relations\Relation` which is incompatible with the type-hinted return `integer`. Consider adding an additional type-check to rule them out. Loading history...
129			}
130
131			/**
132			* Get the unpaid debts.
133			*
134			* @param Session $session The session
135			* @param Fund $fund
136			* @param int $page
137			*
138			* @return Collection
139			*/
140			public function getUnpaidDebts(Session $session, Fund $fund, int $page = 0): Collection
141			{
142			return $this->getUnpaidDebtsQuery($session, $fund, true)
143			->page($page, $this->tenantService->getLimit())
144			->get();
145			}
146
147			/**
148			* Get an unpaid debt.
149			*
150			* @param Session $session The session
151			* @param Fund $fund
152			*
153			* @return Debt\|null
154			*/
155			public function getUnpaidDebt(Session $session, Fund $fund, int $debtId): ?Debt
156			{
157			return $this->getUnpaidDebtsQuery($session, $fund, true)->find($debtId);
158			}
159
160			/**
161			* @param Session $session
162			* @param Debt $debt
163			*
164			* @return bool
165			*/
166			private function canPartiallyRefund(Session $session, Debt $debt): bool
167			{
168			return $session->opened && !$debt->refund;
169			}
170
171			/**
172			* Create a refund.
173			*
174			* @param Session $session
175			* @param Debt $debt
176			* @param int $amount
177			*
178			* @return void
179			*/
180			public function createPartialRefund(Session $session, Debt $debt, int $amount): void
181			{
182			if(!$this->canPartiallyRefund($session, $debt))
183			{
184			throw new MessageException(trans('meeting.refund.errors.cannot_create'));
185			}
186			// A partial refund must not totally refund a debt
187			if($amount >= $this->debtCalculator->getDebtPayableAmount($debt, $session))
188			{
189			throw new MessageException(trans('meeting.refund.errors.pr_amount'));
190			}
191
192			$refund = new PartialRefund();
193			$refund->amount = $amount;
194			$refund->debt()->associate($debt);
195			$refund->session()->associate($session);
196			$refund->save();
197			}
198
199			/**
200			* @param Session $session
201			* @param PartialRefund $refund
202			*
203			* @return bool
204			*/
205			private function canModifyPartialRefund(Session $session, PartialRefund $refund): bool
206			{
207			// A partial refund cannot be updated or deleted if the debt is already refunded.
208			return $session->opened && $refund->debt->refund === null &&
209			$this->paymentService->isEditable($refund);
210			}
211
212			/**
213			* Find a refund.
214			*
215			* @param Session $session The session
216			* @param int $refundId
217			*
218			* @return PartialRefund
219			*/
220			public function getPartialRefund(Session $session, int $refundId): PartialRefund
221			{
222			$refund = PartialRefund::where('session_id', $session->id)
223			->with(['debt.refund'])
224			->find($refundId);
225			if(!$refund)
226			{
227			throw new MessageException(trans('meeting.refund.errors.not_found'));
228			}
229
230			return $refund;
231			}
232
233			/**
234			* Update a refund.
235			*
236			* @param Session $session The session
237			* @param PartialRefund $refund
238			* @param int $amount
239			*
240			* @return void
241			*/
242			public function updatePartialRefund(Session $session, PartialRefund $refund, int $amount): void
243			{
244			if(!$this->canModifyPartialRefund($session, $refund))
245			{
246			throw new MessageException(trans('meeting.refund.errors.cannot_update'));
247			}
248			// A partial refund must not totally refund a debt
249			$maxAmount = $refund->amount +
250			$this->debtCalculator->getDebtPayableAmount($refund->debt, $session);
251			if($amount >= $maxAmount)
252			{
253			throw new MessageException(trans('meeting.refund.errors.pr_amount'));
254			}
255
256			$refund->update(['amount' => $amount]);
257			}
258
259			/**
260			* Delete a refund.
261			*
262			* @param Session $session The session
263			* @param PartialRefund $refund
264			*
265			* @return void
266			*/
267			public function deletePartialRefund(Session $session, PartialRefund $refund): void
268			{
269			if(!$this->canModifyPartialRefund($session, $refund))
270			{
271			throw new MessageException(trans('meeting.refund.errors.cannot_delete'));
272			}
273
274			$refund->delete();
275			}
276			}
277

lagdo / tontine

Pull Request — main (#62)

PartialRefundService::canPartiallyRefund() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like