SessionService::getSessionCharges() - Code Metrics - Inspection of "Add new views to improve bills queries." - lagdo/tontine - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( ef0742...4e298b )

by Thierry

created 2025-09-23 19:39 UTC

SessionService::getSessionCharges() A

↳ Parent: SessionService

Complexity

Conditions	1
Paths	1

Size

Total Lines	17
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
Bugs	0	Features	0

Metric	Value
cc	1
eloc	12
nc	1
nop	1
dl	0
loc	17
rs	9.8666
c	4
b	0
f	0

<?php

namespace Siak\Tontine\Service\Report;

use Closure;
use Illuminate\Database\Eloquent\Builder as ElBuilder;
use Illuminate\Database\Query\Builder;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\DB;
use Siak\Tontine\Model\Debt;
use Siak\Tontine\Model\Deposit;
use Siak\Tontine\Model\Member;
use Siak\Tontine\Model\Outflow;
use Siak\Tontine\Model\Session;
use Siak\Tontine\Service\Payment\BalanceCalculator;

class SessionService
{
    use Traits\Queries;

    /**
     * @param BalanceCalculator $balanceCalculator
     */
    public function __construct(private BalanceCalculator $balanceCalculator)
    {}

    /**
     * @param Session $session
     *
     * @return Collection
     */
    public function getReceivables(Session $session): Collection
    {
        return $session->pools()
            ->addSelect([
                'paid_amount' => Deposit::select(DB::raw('sum(amount)'))
                    ->whereColumn('pool_id', 'pools.id')
                    ->whereHas('receivable', fn(ElBuilder $qr) =>
                        $qr->whereSession($session)),
            ])
            ->withCount([
                'receivables as total_count' => fn(ElBuilder $query) =>
                    $query->whereSession($session),
                'receivables as paid_count' => fn(ElBuilder $query) =>
                    $query->whereSession($session)->paidHere($session),
                'receivables as late_count' => fn(ElBuilder $query) =>
                    $query->whereSession($session)->paidLater($session),
            ])
            ->get()
            ->each(function($pool) {
                $pool->paid_amount ??= 0;
                $pool->total_amount = $pool->amount * $pool->total_count;
            });
    }

    /**
     * @param Session $session
     *
     * @return Collection
     */
    public function getPayables(Session $session): Collection
    {
        return $session->pools()
            ->withCount([
                'sessions',
                'payables as total_count' => fn(ElBuilder $query) =>
                    $query->whereSession($session),
                'payables as paid_count' => fn(ElBuilder $query) =>
                    $query->whereSession($session)->whereHas('remitment'),
            ])
            ->get()
            ->each(function($pool) use($session) {
                $pool->total_amount = $pool->amount * $pool->total_count * $pool->sessions_count;
                $pool->paid_amount = $this->balanceCalculator->getPoolRemitmentAmount($pool, $session);
            });
    }

    /**
     * @param Session $session
     *
     * @return Collection
     */
    public function getAuctions(Session $session): Collection
    {
        return DB::table('auctions')
            ->select(DB::raw('sum(auctions.amount) as total'), 'subscriptions.pool_id')
            ->join('remitments', 'auctions.remitment_id', '=', 'remitments.id')
            ->join('payables', 'remitments.payable_id', '=', 'payables.id')
            ->join('subscriptions', 'payables.subscription_id', '=', 'subscriptions.id')
            ->where('auctions.session_id', $session->id)
            ->where('paid', true)
            ->groupBy('subscriptions.pool_id')
            ->pluck('total', 'pool_id');
    }

    /**
     * @param Closure $settlementFilter
     * @param Member $member|null
     *
     * @return Collection
     */
    private function getSettlements(Closure $settlementFilter, ?Member $member = null): Collection
    {
        return DB::table('v_settlements')
            ->select(DB::raw('sum(amount) as total_amount'),
                DB::raw('count(*) as total_count'), 'charge_id')
            ->groupBy('charge_id')
            ->where($settlementFilter)
            ->when($member !== null, fn($qm) =>
                $qm->where('member_id', $member->id))
            ->get()
            ->keyBy('charge_id');
    }

    /**
     * @param Session $session
     * @param bool $onlyCurrent
     *
     * @return Collection
     */
    private function getDisbursedAmounts(Session $session, bool $onlyCurrent): Collection
    {
        return Outflow::select(DB::raw('sum(amount) as total_amount'),
                DB::raw('count(*) as total_count'), 'charge_id')
            ->groupBy('charge_id')
            ->whereHas('charge', fn($qc) => $qc->where('round_id', $session->round_id))
            ->when($onlyCurrent, fn($qo) => $qo->where('session_id', $session->id))
            ->when(!$onlyCurrent, fn($qo) =>
                $qo->whereHas('session', fn($qs) => $qs->precedes($session)))
            ->get()
            ->keyBy('charge_id');
    }

    /**
     * @param Session $session
     *
     * @return Collection
     */
    public function getSessionCharges(Session $session): Collection
    {
        $settlementFilter = fn(Builder $qs) =>
            $qs->where('session_id', $session->id);
        $settlements = $this->getSettlements($settlementFilter);
        $outflows = $this->getDisbursedAmounts($session, true);

        return $session->round->charges
            ->map(function($charge) use($settlements, $outflows) {
                $settlement = $settlements[$charge->id] ?? null;
                // We need to clone the model, or else the getTotalCharges()
                // method will modify and return the same object and values.
                $charge = $charge->replicate();
                $charge->total_count = $settlement?->total_count ?? 0;
                $charge->total_amount = $settlement?->total_amount ?? 0;
                $charge->outflow = $outflows[$charge->id] ?? null;
                return $charge;
            });
    }

    /**
     * @param Session $session
     * @param Member $member|null
     *
     * @return Collection
     */
    public function getTotalCharges(Session $session, ?Member $member = null): Collection
    {
        $settlementFilter = fn(Builder $qs) =>
            $qs->whereIn('session_id', DB::table('sessions')
                ->select('id')
                ->where('round_id', $session->round_id)
                ->where('day_date', '<=', $session->day_date));
        $settlements = $this->getSettlements($settlementFilter, $member);
        $outflows = $this->getDisbursedAmounts($session, false);
        if($member !== null)
        {
            // The outflow part of each member id calculated by dividing each amount
            // by the number of members.
            $memberCount = $session->round->members->count();
            foreach($outflows as $outflow)
            {
                $outflow->total_amount /= $memberCount;
            }
        }

        return $session->round->charges
            ->map(function($charge) use($settlements, $outflows) {
                $settlement = $settlements[$charge->id] ?? null;
                // We need to clone the model, or else the getSessionCharges()
                // method will modify and return the same object and values.
                $charge = $charge->replicate();
                $charge->total_count = $settlement?->total_count ?? 0;
                $charge->total_amount = $settlement?->total_amount ?? 0;
                $charge->outflow = $outflows[$charge->id] ?? null;
                return $charge;
            });
    }

    /**
     * @param Session $session
     *
     * @return object
     */
    public function getLoan(Session $session): object
    {
        $loan = DB::table('loans')
            ->join('debts', 'loans.id', '=', 'debts.loan_id')
            ->select('debts.type', DB::raw('sum(debts.amount) as total_amount'))
            ->where('loans.session_id', $session->id)
            ->groupBy('debts.type')
            ->pluck('total_amount', 'type');

        return (object)[
            'principal' => $loan[Debt::TYPE_PRINCIPAL] ?? 0,
            'interest' => $loan[Debt::TYPE_INTEREST] ?? 0,
        ];
    }

    /**
     * @param Session $session
     *
     * @return object
     */
    public function getRefund(Session $session): object
    {
        $refund = $this->getRefundQuery()
            ->addSelect('debts.type')
            ->where('refunds.session_id', $session->id)
            ->groupBy('debts.type')
            ->pluck('total_amount', 'type');
        $partialRefund = DB::table('partial_refunds')
            ->join('debts', 'partial_refunds.debt_id', '=', 'debts.id')
            ->where('partial_refunds.session_id', $session->id)
            ->select('debts.type', DB::raw('sum(partial_refunds.amount) as total_amount'))
            ->groupBy('debts.type')
            ->pluck('total_amount', 'type');

        return (object)[
            'principal' => ($refund[Debt::TYPE_PRINCIPAL] ?? 0) +
                ($partialRefund[Debt::TYPE_PRINCIPAL] ?? 0),
            'interest' => ($refund[Debt::TYPE_INTEREST] ?? 0) +
                ($partialRefund[Debt::TYPE_INTEREST] ?? 0),
        ];
    }

    /**
     * @param Session $session
     *
     * @return object
     */
    public function getSaving(Session $session): object
    {
        $saving = DB::table('savings')
            ->select(DB::raw('sum(amount) as total_amount'),
                DB::raw('count(id) as total_count'))
            ->where('session_id', $session->id)
            ->first();
        if(!$saving->total_amount)
        {
            $saving->total_amount = 0;
        }
        if(!$saving->total_count)
        {
            $saving->total_count = 0;
        }

        return $saving;
    }

    /**
     * @param Session $session
     *
     * @return object
     */
    public function getOutflow(Session $session): object
    {
        $outflow = DB::table('outflows')
            ->select(DB::raw('sum(amount) as total_amount'),
                DB::raw('count(id) as total_count'))
            ->where('session_id', $session->id)
            ->first();
        if(!$outflow->total_amount)
        {
            $outflow->total_amount = 0;
        }
        if(!$outflow->total_count)
        {
            $outflow->total_count = 0;
        }

        return $outflow;
    }
}


1			<?php
2
3			namespace Siak\Tontine\Service\Report;
4
5			use Closure;
6			use Illuminate\Database\Eloquent\Builder as ElBuilder;
7			use Illuminate\Database\Query\Builder;
8			use Illuminate\Support\Collection;
9			use Illuminate\Support\Facades\DB;
10			use Siak\Tontine\Model\Debt;
11			use Siak\Tontine\Model\Deposit;
12			use Siak\Tontine\Model\Member;
13			use Siak\Tontine\Model\Outflow;
14			use Siak\Tontine\Model\Session;
15			use Siak\Tontine\Service\Payment\BalanceCalculator;
16
17			class SessionService
18			{
19			use Traits\Queries;
20
21			/**
22			* @param BalanceCalculator $balanceCalculator
23			*/
24			public function __construct(private BalanceCalculator $balanceCalculator)
25			{}
26
27			/**
28			* @param Session $session
29			*
30			* @return Collection
31			*/
32			public function getReceivables(Session $session): Collection
33			{
34			return $session->pools()
35			->addSelect([
36			'paid_amount' => Deposit::select(DB::raw('sum(amount)'))
37			->whereColumn('pool_id', 'pools.id')
38			->whereHas('receivable', fn(ElBuilder $qr) =>
39			$qr->whereSession($session)),
40			])
41			->withCount([
42			'receivables as total_count' => fn(ElBuilder $query) =>
43			$query->whereSession($session),
44			'receivables as paid_count' => fn(ElBuilder $query) =>
45			$query->whereSession($session)->paidHere($session),
46			'receivables as late_count' => fn(ElBuilder $query) =>
47			$query->whereSession($session)->paidLater($session),
48			])
49			->get()
50			->each(function($pool) {
51			$pool->paid_amount ??= 0;
52			$pool->total_amount = $pool->amount * $pool->total_count;
53			});
54			}
55
56			/**
57			* @param Session $session
58			*
59			* @return Collection
60			*/
61			public function getPayables(Session $session): Collection
62			{
63			return $session->pools()
64			->withCount([
65			'sessions',
66			'payables as total_count' => fn(ElBuilder $query) =>
67			$query->whereSession($session),
68			'payables as paid_count' => fn(ElBuilder $query) =>
69			$query->whereSession($session)->whereHas('remitment'),
70			])
71			->get()
72			->each(function($pool) use($session) {
73			$pool->total_amount = $pool->amount * $pool->total_count * $pool->sessions_count;
74			$pool->paid_amount = $this->balanceCalculator->getPoolRemitmentAmount($pool, $session);
75			});
76			}
77
78			/**
79			* @param Session $session
80			*
81			* @return Collection
82			*/
83			public function getAuctions(Session $session): Collection
84			{
85			return DB::table('auctions')
86			->select(DB::raw('sum(auctions.amount) as total'), 'subscriptions.pool_id')
87			->join('remitments', 'auctions.remitment_id', '=', 'remitments.id')
88			->join('payables', 'remitments.payable_id', '=', 'payables.id')
89			->join('subscriptions', 'payables.subscription_id', '=', 'subscriptions.id')
90			->where('auctions.session_id', $session->id)
91			->where('paid', true)
92			->groupBy('subscriptions.pool_id')
93			->pluck('total', 'pool_id');
94			}
95
96			/**
97			* @param Closure $settlementFilter
98			* @param Member $member\|null
99			*
100			* @return Collection
101			*/
102			private function getSettlements(Closure $settlementFilter, ?Member $member = null): Collection
103			{
104			return DB::table('v_settlements')
105			->select(DB::raw('sum(amount) as total_amount'),
106			DB::raw('count(*) as total_count'), 'charge_id')
107			->groupBy('charge_id')
108			->where($settlementFilter)
109			->when($member !== null, fn($qm) =>
110			$qm->where('member_id', $member->id))
111			->get()
112			->keyBy('charge_id');
113			}
114
115			/**
116			* @param Session $session
117			* @param bool $onlyCurrent
118			*
119			* @return Collection
120			*/
121			private function getDisbursedAmounts(Session $session, bool $onlyCurrent): Collection
122			{
123			return Outflow::select(DB::raw('sum(amount) as total_amount'),
124			DB::raw('count(*) as total_count'), 'charge_id')
125			->groupBy('charge_id')
126			->whereHas('charge', fn($qc) => $qc->where('round_id', $session->round_id))
127			->when($onlyCurrent, fn($qo) => $qo->where('session_id', $session->id))
128			->when(!$onlyCurrent, fn($qo) =>
129			$qo->whereHas('session', fn($qs) => $qs->precedes($session)))
130			->get()
131			->keyBy('charge_id');
132			}
133
134			/**
135			* @param Session $session
136			*
137			* @return Collection
138			*/
139			public function getSessionCharges(Session $session): Collection
140			{
141			$settlementFilter = fn(Builder $qs) =>
142			$qs->where('session_id', $session->id);
143			$settlements = $this->getSettlements($settlementFilter);
144			$outflows = $this->getDisbursedAmounts($session, true);
145
146			return $session->round->charges
147			->map(function($charge) use($settlements, $outflows) {
148			$settlement = $settlements[$charge->id] ?? null;
149			// We need to clone the model, or else the getTotalCharges()
150			// method will modify and return the same object and values.
151			$charge = $charge->replicate();
152			$charge->total_count = $settlement?->total_count ?? 0;
153			$charge->total_amount = $settlement?->total_amount ?? 0;
154			$charge->outflow = $outflows[$charge->id] ?? null;
155			return $charge;
156			});
157			}
158
159			/**
160			* @param Session $session
161			* @param Member $member\|null
162			*
163			* @return Collection
164			*/
165			public function getTotalCharges(Session $session, ?Member $member = null): Collection
166			{
167			$settlementFilter = fn(Builder $qs) =>
168			$qs->whereIn('session_id', DB::table('sessions')
169			->select('id')
170			->where('round_id', $session->round_id)
171			->where('day_date', '<=', $session->day_date));
172			$settlements = $this->getSettlements($settlementFilter, $member);
173			$outflows = $this->getDisbursedAmounts($session, false);
174			if($member !== null)
175			{
176			// The outflow part of each member id calculated by dividing each amount
177			// by the number of members.
178			$memberCount = $session->round->members->count();
179			foreach($outflows as $outflow)
180			{
181			$outflow->total_amount /= $memberCount;
182			}
183			}
184
185			return $session->round->charges
186			->map(function($charge) use($settlements, $outflows) {
187			$settlement = $settlements[$charge->id] ?? null;
188			// We need to clone the model, or else the getSessionCharges()
189			// method will modify and return the same object and values.
190			$charge = $charge->replicate();
191			$charge->total_count = $settlement?->total_count ?? 0;
192			$charge->total_amount = $settlement?->total_amount ?? 0;
193			$charge->outflow = $outflows[$charge->id] ?? null;
194			return $charge;
195			});
196			}
197
198			/**
199			* @param Session $session
200			*
201			* @return object
202			*/
203			public function getLoan(Session $session): object
204			{
205			$loan = DB::table('loans')
206			->join('debts', 'loans.id', '=', 'debts.loan_id')
207			->select('debts.type', DB::raw('sum(debts.amount) as total_amount'))
208			->where('loans.session_id', $session->id)
209			->groupBy('debts.type')
210			->pluck('total_amount', 'type');
211
212			return (object)[
213			'principal' => $loan[Debt::TYPE_PRINCIPAL] ?? 0,
214			'interest' => $loan[Debt::TYPE_INTEREST] ?? 0,
215			];
216			}
217
218			/**
219			* @param Session $session
220			*
221			* @return object
222			*/
223			public function getRefund(Session $session): object
224			{
225			$refund = $this->getRefundQuery()
226			->addSelect('debts.type')
227			->where('refunds.session_id', $session->id)
228			->groupBy('debts.type')
229			->pluck('total_amount', 'type');
230			$partialRefund = DB::table('partial_refunds')
231			->join('debts', 'partial_refunds.debt_id', '=', 'debts.id')
232			->where('partial_refunds.session_id', $session->id)
233			->select('debts.type', DB::raw('sum(partial_refunds.amount) as total_amount'))
234			->groupBy('debts.type')
235			->pluck('total_amount', 'type');
236
237			return (object)[
238			'principal' => ($refund[Debt::TYPE_PRINCIPAL] ?? 0) +
239			($partialRefund[Debt::TYPE_PRINCIPAL] ?? 0),
240			'interest' => ($refund[Debt::TYPE_INTEREST] ?? 0) +
241			($partialRefund[Debt::TYPE_INTEREST] ?? 0),
242			];
243			}
244
245			/**
246			* @param Session $session
247			*
248			* @return object
249			*/
250			public function getSaving(Session $session): object
251			{
252			$saving = DB::table('savings')
253			->select(DB::raw('sum(amount) as total_amount'),
254			DB::raw('count(id) as total_count'))
255			->where('session_id', $session->id)
256			->first();
257			if(!$saving->total_amount)
258			{
259			$saving->total_amount = 0;
260			}
261			if(!$saving->total_count)
262			{
263			$saving->total_count = 0;
264			}
265
266			return $saving;
267			}
268
269			/**
270			* @param Session $session
271			*
272			* @return object
273			*/
274			public function getOutflow(Session $session): object
275			{
276			$outflow = DB::table('outflows')
277			->select(DB::raw('sum(amount) as total_amount'),
278			DB::raw('count(id) as total_count'))
279			->where('session_id', $session->id)
280			->first();
281			if(!$outflow->total_amount)
282			{
283			$outflow->total_amount = 0;
284			}
285			if(!$outflow->total_count)
286			{
287			$outflow->total_count = 0;
288			}
289
290			return $outflow;
291			}
292			}
293

lagdo / tontine

Push — main ( ef0742...4e298b )

SessionService::getSessionCharges() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like