ReinscriptionCheckCommand::getLatestCertificateDate() - Code Metrics - Inspection of "Internal: Add session replication, reinscription l..." - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#5831)

unknown

created 2025-02-20 15:16 UTC

getLatestCertificateDate() A

↳ Parent: ReinscriptionCheckCommand

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

declare(strict_types=1);

/* For licensing terms, see /license.txt */

namespace Chamilo\CoreBundle\Command;

use Chamilo\CoreBundle\Entity\Session;
use Chamilo\CoreBundle\Entity\SessionRelUser;
use Chamilo\CoreBundle\Entity\SessionRelCourse;
use Chamilo\CoreBundle\Entity\GradebookCertificate;
use Chamilo\CoreBundle\Repository\SessionRepository;
use Chamilo\CoreBundle\Repository\GradebookCertificateRepository;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Input\InputOption;

class ReinscriptionCheckCommand extends Command
{
    protected static $defaultName = 'app:reinscription-check';

    private SessionRepository $sessionRepository;
    private GradebookCertificateRepository $certificateRepository;
    private EntityManagerInterface $entityManager;

    public function __construct(
        SessionRepository $sessionRepository,
        GradebookCertificateRepository $certificateRepository,
        EntityManagerInterface $entityManager
    ) {
        parent::__construct();
        $this->sessionRepository = $sessionRepository;
        $this->certificateRepository = $certificateRepository;
        $this->entityManager = $entityManager;
    }

    protected function configure(): void
    {
        $this
            ->setDescription('Checks for users who have validated all gradebooks and reinscribe them into new sessions if needed.')
            ->addOption(
                'debug',
                null,
                InputOption::VALUE_NONE,
                'If set, debug messages will be shown.'
            );
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $debug = $input->getOption('debug');

        $sessions = $this->sessionRepository->findAll();

        foreach ($sessions as $session) {
            if ($session->getValidityInDays() === null || $session->getValidityInDays() === 0) {
                continue;
            }

            $users = $this->getUsersForSession($session);

            foreach ($users as $user) {
                if ($debug) {
                    $output->writeln(sprintf('Processing user %d in session %d.', $user->getId(), $session->getId()));
                }

                if ($this->isUserReinscribed($user, $session)) {
                    continue;
                }

                if ($this->isUserAlreadyEnrolledInChildSession($user, $session)) {
                    if ($debug) {
                        $output->writeln(sprintf('User %d is already enrolled in a valid child session.', $user->getId()));
                    }
                    continue;
                }

                $certificates = $this->getUserCertificatesForSession($user, $session);

                if ($this->hasUserValidatedAllGradebooks($session, $certificates)) {
                    $latestValidationDate = $this->getLatestCertificateDate($certificates);

                    if ($latestValidationDate !== null) {
                        $reinscriptionDate = (clone $latestValidationDate)->modify("+{$session->getValidityInDays()} days");

                        if ($debug) {
                            $output->writeln(sprintf(
                                'User %d - Latest certificate date: %s, Reinscription date: %s',
                                $user->getId(),
                                $latestValidationDate->format('Y-m-d'),
                                $reinscriptionDate->format('Y-m-d')
                            ));
                        }

                        if (new \DateTime() >= $reinscriptionDate) {
                            $validSession = $this->findValidSessionInHierarchy($session);

                            if ($validSession) {
                                $this->enrollUserInSession($user, $validSession, $session);
                                if ($debug) {
                                    $output->writeln(sprintf(
                                        'User %d re-enrolled into session %d.',
                                        $user->getId(),
                                        $validSession->getId()
                                    ));
                                }
                            }
                        }
                    } else {
                        if ($debug) {
                            $output->writeln(sprintf(
                                'User %d has no valid certificates for session %d.',
                                $user->getId(),
                                $session->getId()
                            ));
                        }
                    }
                }
            }
        }

        return Command::SUCCESS;
    }

    /**
     * Retrieves all users associated with the session.
     */
    private function getUsersForSession(Session $session): array
    {
        $usersToNotify = [];
        $sessionCourses = $this->entityManager->getRepository(SessionRelCourse::class)->findBy(['session' => $session]);

        foreach ($sessionCourses as $courseRel) {
            $course = $courseRel->getCourse();

            $studentSubscriptions = $session->getSessionRelCourseRelUsersByStatus($course, Session::STUDENT);
            foreach ($studentSubscriptions as $studentSubscription) {
                $usersToNotify[$studentSubscription->getUser()->getId()] = $studentSubscription->getUser();
            }

            $coachSubscriptions = $session->getSessionRelCourseRelUsersByStatus($course, Session::COURSE_COACH);
            foreach ($coachSubscriptions as $coachSubscription) {
                $usersToNotify[$coachSubscription->getUser()->getId()] = $coachSubscription->getUser();
            }
        }

        $generalCoaches = $session->getGeneralCoaches();
        foreach ($generalCoaches as $generalCoach) {
            $usersToNotify[$generalCoach->getId()] = $generalCoach;
        }

        return array_values($usersToNotify);
    }

    /**
     * Checks if the user is already enrolled in a valid child session.
     */
    private function isUserAlreadyEnrolledInChildSession($user, $parentSession): bool
    {
        $childSessions = $this->sessionRepository->findChildSessions($parentSession);

        foreach ($childSessions as $childSession) {
            if ($this->findUserSubscriptionInSession($user, $childSession)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Gets the user's certificates for the courses in the session.
     */
    private function getUserCertificatesForSession($user, Session $session): array
    {
        $courses = $this->entityManager->getRepository(SessionRelCourse::class)
            ->findBy(['session' => $session]);

        $courseIds = array_map(fn($rel) => $rel->getCourse()->getId(), $courses);

        return $this->certificateRepository->createQueryBuilder('gc')
            ->join('gc.category', 'cat')
            ->where('gc.user = :user')
            ->andWhere('cat.course IN (:courses)')
            ->setParameter('user', $user)
            ->setParameter('courses', $courseIds)
            ->getQuery()
            ->getResult();
    }

    /**
     * Checks if the user has validated all gradebooks in the session.
     */
    private function hasUserValidatedAllGradebooks(Session $session, array $certificates): bool
    {
        $courses = $this->entityManager->getRepository(SessionRelCourse::class)
            ->findBy(['session' => $session]);

        return count($certificates) === count($courses);
    }

    /**
     * Returns the latest certificate creation date.
     */
    private function getLatestCertificateDate(array $certificates): ?\DateTime
    {
        $dates = array_map(fn($cert) => $cert->getCreatedAt(), $certificates);

        if (empty($dates)) {
            return null;
        }

        return max($dates);
    }

    /**
     * Enrolls the user in a new session and updates the previous session subscription.
     */
    private function enrollUserInSession($user, $newSession, $oldSession): void
    {
        $existingSubscription = $this->findUserSubscriptionInSession($user, $newSession);

        if (!$existingSubscription) {
            $newSession->addUserInSession(Session::STUDENT, $user);

            foreach ($newSession->getCourses() as $sessionRelCourse) {
                $course = $sessionRelCourse->getCourse();
                if ($course) {
                    $newSession->addUserInCourse(Session::STUDENT, $user, $course);
                }
            }

            $subscription = $this->findUserSubscriptionInSession($user, $oldSession);
            if ($subscription) {
                $subscription->setNewSubscriptionSessionId($newSession->getId());
            }

            $this->entityManager->persist($newSession);
            $this->entityManager->flush();
        }
    }

    /**
     * Determines if the user has already been reinscribed.
     */
    private function isUserReinscribed($user, Session $session): bool
    {
        $subscription = $this->findUserSubscriptionInSession($user, $session);
        return $subscription && $subscription->getNewSubscriptionSessionId() !== null;
    }

    /**
     * Finds the user's subscription in the specified session.
     */
    private function findUserSubscriptionInSession($user, $session)
    {
        return $this->entityManager->getRepository(SessionRelUser::class)
            ->findOneBy([
                'user' => $user,
                'session' => $session,
            ]);
    }

    /**
     * Finds a valid session within the session hierarchy.
     */
    private function findValidSessionInHierarchy(Session $session): ?Session
    {
        $childSessions = $this->sessionRepository->findChildSessions($session);

        /* @var Session $child */
        foreach ($childSessions as $child) {
            $validUntil = (clone $child->getAccessEndDate())->modify("-{$child->getDaysToReinscription()} days");
            if (new \DateTime() <= $validUntil) {
                return $child;
            }
        }

        $parentSession = $this->sessionRepository->findParentSession($session);

        if ($parentSession && new \DateTime() <= $parentSession->getAccessEndDate()) {
            return $parentSession;
        }

        return null;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/* For licensing terms, see /license.txt */
6
7			namespace Chamilo\CoreBundle\Command;
8
9			use Chamilo\CoreBundle\Entity\Session;
10			use Chamilo\CoreBundle\Entity\SessionRelUser;
11			use Chamilo\CoreBundle\Entity\SessionRelCourse;
12			use Chamilo\CoreBundle\Entity\GradebookCertificate;
13			use Chamilo\CoreBundle\Repository\SessionRepository;
14			use Chamilo\CoreBundle\Repository\GradebookCertificateRepository;
15			use Doctrine\ORM\EntityManagerInterface;
16			use Symfony\Component\Console\Command\Command;
17			use Symfony\Component\Console\Input\InputInterface;
18			use Symfony\Component\Console\Output\OutputInterface;
19			use Symfony\Component\Console\Input\InputOption;
20
21			class ReinscriptionCheckCommand extends Command
22			{
23			protected static $defaultName = 'app:reinscription-check';
24
25			private SessionRepository $sessionRepository;
26			private GradebookCertificateRepository $certificateRepository;
27			private EntityManagerInterface $entityManager;
28
29			public function __construct(
30			SessionRepository $sessionRepository,
31			GradebookCertificateRepository $certificateRepository,
32			EntityManagerInterface $entityManager
33			) {
34			parent::__construct();
35			$this->sessionRepository = $sessionRepository;
36			$this->certificateRepository = $certificateRepository;
37			$this->entityManager = $entityManager;
38			}
39
40			protected function configure(): void
41			{
42			$this
43			->setDescription('Checks for users who have validated all gradebooks and reinscribe them into new sessions if needed.')
44			->addOption(
45			'debug',
46			null,
47			InputOption::VALUE_NONE,
48			'If set, debug messages will be shown.'
49			);
50			}
51
52			protected function execute(InputInterface $input, OutputInterface $output): int
53			{
54			$debug = $input->getOption('debug');
55
56			$sessions = $this->sessionRepository->findAll();
57
58			foreach ($sessions as $session) {
59			if ($session->getValidityInDays() === null \|\| $session->getValidityInDays() === 0) {
60			continue;
61			}
62
63			$users = $this->getUsersForSession($session);
64
65			foreach ($users as $user) {
66			if ($debug) {
67			$output->writeln(sprintf('Processing user %d in session %d.', $user->getId(), $session->getId()));
68			}
69
70			if ($this->isUserReinscribed($user, $session)) {
71			continue;
72			}
73
74			if ($this->isUserAlreadyEnrolledInChildSession($user, $session)) {
75			if ($debug) {
76			$output->writeln(sprintf('User %d is already enrolled in a valid child session.', $user->getId()));
77			}
78			continue;
79			}
80
81			$certificates = $this->getUserCertificatesForSession($user, $session);
82
83			if ($this->hasUserValidatedAllGradebooks($session, $certificates)) {
84			$latestValidationDate = $this->getLatestCertificateDate($certificates);
85
86			if ($latestValidationDate !== null) {
87			$reinscriptionDate = (clone $latestValidationDate)->modify("+{$session->getValidityInDays()} days");
88
89			if ($debug) {
90			$output->writeln(sprintf(
91			'User %d - Latest certificate date: %s, Reinscription date: %s',
92			$user->getId(),
93			$latestValidationDate->format('Y-m-d'),
94			$reinscriptionDate->format('Y-m-d')
95			));
96			}
97
98			if (new \DateTime() >= $reinscriptionDate) {
99			$validSession = $this->findValidSessionInHierarchy($session);
100
101			if ($validSession) {
102			$this->enrollUserInSession($user, $validSession, $session);
103			if ($debug) {
104			$output->writeln(sprintf(
105			'User %d re-enrolled into session %d.',
106			$user->getId(),
107			$validSession->getId()
108			));
109			}
110			}
111			}
112			} else {
113			if ($debug) {
114			$output->writeln(sprintf(
115			'User %d has no valid certificates for session %d.',
116			$user->getId(),
117			$session->getId()
118			));
119			}
120			}
121			}
122			}
123			}
124
125			return Command::SUCCESS;
126			}
127
128			/**
129			* Retrieves all users associated with the session.
130			*/
131			private function getUsersForSession(Session $session): array
132			{
133			$usersToNotify = [];
134			$sessionCourses = $this->entityManager->getRepository(SessionRelCourse::class)->findBy(['session' => $session]);
135
136			foreach ($sessionCourses as $courseRel) {
137			$course = $courseRel->getCourse();
138
139			$studentSubscriptions = $session->getSessionRelCourseRelUsersByStatus($course, Session::STUDENT);
140			foreach ($studentSubscriptions as $studentSubscription) {
141			$usersToNotify[$studentSubscription->getUser()->getId()] = $studentSubscription->getUser();
142			}
143
144			$coachSubscriptions = $session->getSessionRelCourseRelUsersByStatus($course, Session::COURSE_COACH);
145			foreach ($coachSubscriptions as $coachSubscription) {
146			$usersToNotify[$coachSubscription->getUser()->getId()] = $coachSubscription->getUser();
147			}
148			}
149
150			$generalCoaches = $session->getGeneralCoaches();
151			foreach ($generalCoaches as $generalCoach) {
152			$usersToNotify[$generalCoach->getId()] = $generalCoach;
153			}
154
155			return array_values($usersToNotify);
156			}
157
158			/**
159			* Checks if the user is already enrolled in a valid child session.
160			*/
161			private function isUserAlreadyEnrolledInChildSession($user, $parentSession): bool
162			{
163			$childSessions = $this->sessionRepository->findChildSessions($parentSession);
164
165			foreach ($childSessions as $childSession) {
166			if ($this->findUserSubscriptionInSession($user, $childSession)) {
167			return true;
168			}
169			}
170
171			return false;
172			}
173
174			/**
175			* Gets the user's certificates for the courses in the session.
176			*/
177			private function getUserCertificatesForSession($user, Session $session): array
178			{
179			$courses = $this->entityManager->getRepository(SessionRelCourse::class)
180			->findBy(['session' => $session]);
181
182			$courseIds = array_map(fn($rel) => $rel->getCourse()->getId(), $courses);
183
184			return $this->certificateRepository->createQueryBuilder('gc')
185			->join('gc.category', 'cat')
186			->where('gc.user = :user')
187			->andWhere('cat.course IN (:courses)')
188			->setParameter('user', $user)
189			->setParameter('courses', $courseIds)
190			->getQuery()
191			->getResult();
192			}
193
194			/**
195			* Checks if the user has validated all gradebooks in the session.
196			*/
197			private function hasUserValidatedAllGradebooks(Session $session, array $certificates): bool
198			{
199			$courses = $this->entityManager->getRepository(SessionRelCourse::class)
200			->findBy(['session' => $session]);
201
202			return count($certificates) === count($courses);
203			}
204
205			/**
206			* Returns the latest certificate creation date.
207			*/
208			private function getLatestCertificateDate(array $certificates): ?\DateTime
209			{
210			$dates = array_map(fn($cert) => $cert->getCreatedAt(), $certificates);
211
212			if (empty($dates)) {
213			return null;
214			}
215
216			return max($dates);
217			}
218
219			/**
220			* Enrolls the user in a new session and updates the previous session subscription.
221			*/
222			private function enrollUserInSession($user, $newSession, $oldSession): void
223			{
224			$existingSubscription = $this->findUserSubscriptionInSession($user, $newSession);
225
226			if (!$existingSubscription) {
227			$newSession->addUserInSession(Session::STUDENT, $user);
228
229			foreach ($newSession->getCourses() as $sessionRelCourse) {
230			$course = $sessionRelCourse->getCourse();
231			if ($course) {
232			$newSession->addUserInCourse(Session::STUDENT, $user, $course);
233			}
234			}
235
236			$subscription = $this->findUserSubscriptionInSession($user, $oldSession);
237			if ($subscription) {
238			$subscription->setNewSubscriptionSessionId($newSession->getId());
239			}
240
241			$this->entityManager->persist($newSession);
242			$this->entityManager->flush();
243			}
244			}
245
246			/**
247			* Determines if the user has already been reinscribed.
248			*/
249			private function isUserReinscribed($user, Session $session): bool
250			{
251			$subscription = $this->findUserSubscriptionInSession($user, $session);
252			return $subscription && $subscription->getNewSubscriptionSessionId() !== null;
253			}
254
255			/**
256			* Finds the user's subscription in the specified session.
257			*/
258			private function findUserSubscriptionInSession($user, $session)
259			{
260			return $this->entityManager->getRepository(SessionRelUser::class)
261			->findOneBy([
262			'user' => $user,
263			'session' => $session,
264			]);
265			}
266
267			/**
268			* Finds a valid session within the session hierarchy.
269			*/
270			private function findValidSessionInHierarchy(Session $session): ?Session
271			{
272			$childSessions = $this->sessionRepository->findChildSessions($session);
273
274			/* @var Session $child */
275			foreach ($childSessions as $child) {
276			$validUntil = (clone $child->getAccessEndDate())->modify("-{$child->getDaysToReinscription()} days");
277			if (new \DateTime() <= $validUntil) {
278			return $child;
279			}
280			}
281
282			$parentSession = $this->sessionRepository->findParentSession($session);
283
284			if ($parentSession && new \DateTime() <= $parentSession->getAccessEndDate()) {
285			return $parentSession;
286			}
287
288			return null;
289			}
290			}
291

chamilo / chamilo-lms

Pull Request — master (#5831)

getLatestCertificateDate() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like