Siak\Tontine\Service\Planning\PoolSyncService

Complexity

Total Complexity

20

Size/Duplication

Total Lines	218
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	sessionDeleted()	0	35	4
A	subscriptionDeleted()	0	7	1
A	sessionsCreated()	0	30	4
A	sessionDisabled()	0	13	1
A	sessionEnabled()	0	14	3
A	sessionsChanged()	0	43	4
A	subscriptionCreated()	0	17	3

<?php

namespace Siak\Tontine\Service\Planning;

use Illuminate\Support\Facades\DB;
use Illuminate\Support\Collection;
use Siak\Tontine\Model\Pool;
use Siak\Tontine\Model\Receivable;
use Siak\Tontine\Model\Round;
use Siak\Tontine\Model\Session;
use Siak\Tontine\Model\Subscription;

use function count;

class PoolSyncService
{
    use SessionSyncTrait;

The trait Siak\Tontine\Service\Planning\SessionSyncTrait requires the property $day_date which is not provided by Siak\Tontine\Service\Planning\PoolSyncService.

    /**
     * @param Round $round
     * @param Collection|array $sessions
     *
     * @return void
     */
    public function sessionsCreated(Round $round, Collection|array $sessions): void
    {
        // Create the receivables.
        $receivables = [];
        $poolFilter = fn($query, $session) => $query->ofRound($round)
            ->whereHas('start', fn($qs) => $qs->where('day_date', '<', $session->day_date))
            ->whereHas('end', fn($qe) => $qe->where('day_date', '>', $session->day_date));
        foreach($sessions as $session)
        {
            // Take all the subscriptions to a pool this session belongs to.
            $subscriptions = Subscription::whereNotNull('id')
                ->whereHas('pool', fn($query) =>
                    $poolFilter($query, $session));
            foreach($subscriptions->get() as $subscription)
            {
                $receivables[] = [
                    'subscription_id' => $subscription->id,
                    'session_id' => $session->id,
                ];
            }
        }
        if(count($receivables) > 0)
        {
            DB::table('receivables')->insert($receivables);
        }

        // Update the start and end sessions.
        $round->pools()->update([
            'start_sid' => $round->start->id,

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

            'end_sid' => $round->end->id,

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

        ]);
    }

    /**
     * @param Session $session
     *
     * @return void
     */
    public function sessionDeleted(Session $session)
    {
        // Detach the payables and delete the receivables.
        $session->payables()->update(['session_id' => null]);
        $session->receivables()->delete();

        // Delete the disabled sessions rows.
        DB::table('pool_session_disabled as psd')
            ->where('session_id', $session->id)
            ->delete();

        $round = $session->round;
        if($round->sessions()->count() === 1)
        {
            // The last session is being deleted.
            $round->pools()->delete();
            return;
        }

        // Update the start sessions.
        $nextSession = $this->getNextSession($round, $session);
        if($nextSession !== null)
        {
            $round->pools()
                ->where('start_sid', $session->id)
                ->update(['start_sid' => $nextSession->id]);
        }

        // Update the end sessions.
        $prevSession = $this->getPrevSession($round, $session);
        if($prevSession !== null)
        {
            $round->pools()
                ->where('end_sid', $session->id)
                ->update(['end_sid' => $prevSession->id]);
        }
    }

    /**
     * @param Pool $pool
     *
     * @return void
     */
    public function sessionsChanged(Pool $pool): void
    {
        // The relations need to be reloaded.
        $pool->refresh();

        // Delete the disabled sessions removed from the pool.
        DB::table(DB::raw('pool_session_disabled as psd'))
            ->where('pool_id', $pool->id)
            ->whereExists(fn($query) => $query->select(DB::raw(1))
                ->from(DB::raw('sessions s'))
                ->whereColumn('s.id', '=', 'psd.session_id')
                ->where(fn($qw) => $qw->where(fn($qs) => $qs
                    ->orWhere('day_date', '<', $pool->start->day_date)
                    ->orWhere('day_date', '>', $pool->end->day_date))))
            ->delete();

        // Delete the receivables for the sessions removed from the pool.
        Receivable::whereHas('subscription', fn($qs) =>
                $qs->where('pool_id', $pool->id))
            ->whereHas('session', fn($qw) =>
                $qw->where(fn($qs) => $qs
                    ->orWhere('day_date', '<', $pool->start->day_date)
                    ->orWhere('day_date', '>', $pool->end->day_date)))
            ->delete();

        // Create the receivables for the sessions added to the pool.
        $receivables = [];
        foreach($pool->sessions as $session)
        {
            $subscriptions = $pool->subscriptions()
                ->whereDoesntHave('receivables', fn($qr) =>
                    $qr->where('session_id', $session->id));
            foreach($subscriptions->get() as $subscription)
            {
                $receivables[] = [
                    'subscription_id' => $subscription->id,
                    'session_id' => $session->id,
                ];
            }
        }
        if(count($receivables) > 0)
        {
            DB::table('receivables')->insert($receivables);
        }
    }

    /**
     * @param Pool $pool
     * @param Session $session
     *
     * @return void
     */
    public function sessionEnabled(Pool $pool, Session $session): void
    {
        // Create the receivables for the pool subscriptions.
        $receivables = [];
        foreach($pool->subscriptions as $subscription)
        {
            $receivables[] = [
                'subscription_id' => $subscription->id,
                'session_id' => $session->id,
            ];
        }
        if(count($receivables) > 0)
        {
            DB::table('receivables')->insert($receivables);
        }
    }

    /**
     * @param Pool $pool
     * @param Session $session
     *
     * @return void
     */
    public function sessionDisabled(Pool $pool, Session $session): void
    {
        // Detach the payables.
        $session->payables()
            ->whereHas('subscription', fn($qs) =>
                $qs->where('pool_id', $pool->id))
            ->update(['session_id' => null]);

        // Delete the receivables
        $session->receivables()
            ->whereHas('subscription', fn($qs) =>
                $qs->where('pool_id', $pool->id))
            ->delete();
    }

    /**
     * @param Subscription $subscription
     *
     * @return void
     */
    public function subscriptionCreated(Subscription $subscription)
    {
        // Create the payable
        $subscription->payable()->create([]);

        // Create the receivables for the pool sessions.
        $receivables = [];
        foreach($subscription->pool->sessions as $session)
        {
            $receivables[] = [
                'subscription_id' => $subscription->id,
                'session_id' => $session->id,
            ];
        }
        if(count($receivables) > 0)
        {
            DB::table('receivables')->insert($receivables);
        }
    }

    /**
     * @param Subscription $subscription
     *
     * @return void
     */
    public function subscriptionDeleted(Subscription $subscription)
    {
        // Delete the payable
        $subscription->payable()->delete();

        // Delete the receivables
        $subscription->receivables()->delete();
    }
}