SessionController::about() - Code Metrics - Inspection of "Course home: Fix bug in button Hide all preventing..." - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 9d97a9...43700c )

by Yannick

created 2025-07-13 23:53 UTC

SessionController::about() F

↳ Parent: SessionController

Complexity

Conditions	19
Paths	216

Size

Total Lines	212
Code Lines	130

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	19
eloc	130
nop	5
dl	0
loc	212
rs	2.7866
c	0
b	0
f	0
nc	216

How to fix Long Method Complexity

<?php

declare(strict_types=1);

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

namespace Chamilo\CoreBundle\Controller;

use BuyCoursesPlugin;
use Chamilo\CoreBundle\Entity\ExtraField;
use Chamilo\CoreBundle\Entity\SequenceResource;
use Chamilo\CoreBundle\Entity\Session;
use Chamilo\CoreBundle\Entity\SessionRelCourse;
use Chamilo\CoreBundle\Entity\SessionRelUser;
use Chamilo\CoreBundle\Entity\Tag;
use Chamilo\CoreBundle\Entity\User;
use Chamilo\CoreBundle\Framework\Container;
use Chamilo\CoreBundle\Helpers\MessageHelper;
use Chamilo\CoreBundle\Helpers\UserHelper;
use Chamilo\CoreBundle\Repository\Node\IllustrationRepository;
use Chamilo\CoreBundle\Repository\Node\UserRepository;
use Chamilo\CoreBundle\Repository\SequenceRepository;
use Chamilo\CoreBundle\Repository\SequenceResourceRepository;
use Chamilo\CoreBundle\Repository\TagRepository;
use Chamilo\CourseBundle\Entity\CCourseDescription;
use CourseDescription;
use DateTime;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use Essence\Essence;
use ExtraFieldValue;
use Graphp\GraphViz\GraphViz;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Entity;
use SessionManager;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Bundle\SecurityBundle\Security;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Contracts\Translation\TranslatorInterface;
use UserManager;

#[Route('/sessions')]
class SessionController extends AbstractController
{
    public function __construct(
        private readonly UserHelper $userHelper,
        private readonly TranslatorInterface $translator,
        private readonly RequestStack $requestStack
    ) {}

    #[Route(path: '/{sid}/about', name: 'chamilo_core_session_about')]
    public function about(
        Request $request,
        Session $session,
        IllustrationRepository $illustrationRepo,
        UserRepository $userRepo,
        EntityManagerInterface $em
    ): Response {
        $requestSession = $request->getSession();
        $htmlHeadXtra[] = api_get_asset('readmore-js/readmore.js');


        $sessionId = $session->getId();
        $courses = [];
        $sessionCourses = $session->getCourses();

        /** @var EntityRepository $fieldsRepo */
        $fieldsRepo = $em->getRepository(ExtraField::class);

        /** @var TagRepository $tagRepo */
        $tagRepo = $em->getRepository(Tag::class);

        /** @var SequenceRepository $sequenceResourceRepo */
        $sequenceResourceRepo = $em->getRepository(SequenceResource::class);

        /** @var ExtraField $tagField */
        $tagField = $fieldsRepo->findOneBy([
            'itemType' => ExtraField::COURSE_FIELD_TYPE,
            'variable' => 'tags',
        ]);

        $courseValues = new ExtraFieldValue('course');
        $userValues = new ExtraFieldValue('user');
        $sessionValues = new ExtraFieldValue('session');

        /** @var SessionRelCourse $sessionRelCourse */
        foreach ($sessionCourses as $sessionRelCourse) {
            $sessionCourse = $sessionRelCourse->getCourse();
            $courseTags = [];

            if (null !== $tagField) {
                $courseTags = $tagRepo->getTagsByItem($tagField, $sessionCourse->getId());
            }

            $courseCoaches = $userRepo->getCoachesForSessionCourse($session, $sessionCourse);
            $coachesData = [];

            /** @var User $courseCoach */
            foreach ($courseCoaches as $courseCoach) {
                $coachData = [
                    'complete_name' => UserManager::formatUserFullName($courseCoach),
                    'image' => $illustrationRepo->getIllustrationUrl($courseCoach),
                    'diploma' => $courseCoach->getDiplomas(),
                    'openarea' => $courseCoach->getOpenarea(),
                    'extra_fields' => $userValues->getAllValuesForAnItem(
                        $courseCoach->getId(),
                        null,
                        true
                    ),
                ];

                $coachesData[] = $coachData;
            }

            $cd = new CourseDescription();
            $cd->set_course_id($sessionCourse->getId());
            $cd->set_session_id($session->getId());
            $descriptionsData = $cd->get_description_data();

            $courseDescription = [];
            $courseObjectives = [];
            $courseTopics = [];
            $courseMethodology = [];
            $courseMaterial = [];
            $courseResources = [];
            $courseAssessment = [];
            $courseCustom = [];

            if (!empty($descriptionsData)) {
                foreach ($descriptionsData as $descriptionInfo) {
                    $type = $descriptionInfo->getDescriptionType();

                    switch ($type) {
                        case CCourseDescription::TYPE_DESCRIPTION:
                            $courseDescription[] = $descriptionInfo;

                            break;

                        case CCourseDescription::TYPE_OBJECTIVES:
                            $courseObjectives[] = $descriptionInfo;

                            break;

                        case CCourseDescription::TYPE_TOPICS:
                            $courseTopics[] = $descriptionInfo;

                            break;

                        case CCourseDescription::TYPE_METHODOLOGY:
                            $courseMethodology[] = $descriptionInfo;

                            break;

                        case CCourseDescription::TYPE_COURSE_MATERIAL:
                            $courseMaterial[] = $descriptionInfo;

                            break;

                        case CCourseDescription::TYPE_RESOURCES:
                            $courseResources[] = $descriptionInfo;

                            break;

                        case CCourseDescription::TYPE_ASSESSMENT:
                            $courseAssessment[] = $descriptionInfo;

                            break;

                        case CCourseDescription::TYPE_CUSTOM:
                            $courseCustom[] = $descriptionInfo;

                            break;
                    }
                }
            }

            $courses[] = [
                'course' => $sessionCourse,
                'description' => $courseDescription,
                'image' => Container::getIllustrationRepository()->getIllustrationUrl($sessionCourse),
                'tags' => $courseTags,
                'objectives' => $courseObjectives,
                'topics' => $courseTopics,
                'methodology' => $courseMethodology,
                'material' => $courseMaterial,
                'resources' => $courseResources,
                'assessment' => $courseAssessment,
                'custom' => array_reverse($courseCustom),
                'coaches' => $coachesData,
                'extra_fields' => $courseValues->getAllValuesForAnItem(
                    $sessionCourse->getId(),
                    null,
                    true
                ),
            ];
        }

        $sessionDates = SessionManager::parseSessionDates($session, true);

        $hasRequirements = false;

        /*$sessionRequirements = $sequenceResourceRepo->getRequirements(
         * $session->getId(),
         * SequenceResource::SESSION_TYPE
         * );
         * foreach ($sessionRequirements as $sequence) {
         * if (!empty($sequence['requirements'])) {
         * $hasRequirements = true;
         * break;
         * }
         * }*/
        $plugin = BuyCoursesPlugin::create();
        $checker = $plugin->isEnabled();
        $sessionIsPremium = null;
        if ($checker) {
            $sessionIsPremium = $plugin->getItemByProduct(
                $sessionId,
                BuyCoursesPlugin::PRODUCT_TYPE_SESSION
            );
            if ([] !== $sessionIsPremium) {
                $requestSession->set('SessionIsPremium', true);
                $requestSession->set('sessionId', $sessionId);
            }
        }

        $redirectToSession = ('true' === Container::getSettingsManager()->getSetting('session.allow_redirect_to_session_after_inscription_about'));
        $redirectToSession = $redirectToSession ? '?s='.$sessionId : false;

        $coursesInThisSession = SessionManager::get_course_list_by_session_id($sessionId);
        $coursesCount = \count($coursesInThisSession);
        $redirectToSession = 1 === $coursesCount && $redirectToSession
            ? ($redirectToSession.'&cr='.array_values($coursesInThisSession)[0]['directory'])
            : $redirectToSession;

        $essence = new Essence();

        $params = [
            'session' => $session,
            'redirect_to_session' => $redirectToSession,
            'courses' => $courses,
            'essence' => $essence,
            'session_extra_fields' => $sessionValues->getAllValuesForAnItem($session->getId(), null, true),
            'has_requirements' => $hasRequirements,
            // 'sequences' => $sessionRequirements,
            'is_premium' => $sessionIsPremium,
            'show_tutor' => 'true' === api_get_setting('show_session_coach'),
            'page_url' => api_get_path(WEB_PATH).\sprintf('sessions/%s/about/', $session->getId()),
            'session_date' => $sessionDates,
            'is_subscribed' => SessionManager::isUserSubscribedAsStudent(
                $session->getId(),
                api_get_user_id()
            ),
            'user_session_time' => SessionManager::getDayLeftInSession(
                [
                    'id' => $session->getId(),
                    'duration' => $session->getDuration(),
                ],
                api_get_user_id()
            ),
            'base_url' => $request->getSchemeAndHttpHost(),
        ];

        return $this->render('@ChamiloCore/Session/about.html.twig', $params);
    }

    #[Route('/{id}/send-course-notification', name: 'chamilo_core_session_send_course_notification', methods: ['POST'])]
    public function sendCourseNotification(
        int $id,
        Request $request,
        UserRepository $userRepo,
        EntityManagerInterface $em,
        MessageHelper $messageHelper
    ): Response {
        $session = $em->getRepository(Session::class)->find($id);
        $currentUser = $this->userHelper->getCurrent();

        if (!$session) {
            return $this->json(['error' => 'Session not found'], Response::HTTP_NOT_FOUND);
        }

        $studentId = $request->request->get('studentId');
        if (!$studentId) {
            return $this->json(['error' => 'Missing studentId'], Response::HTTP_BAD_REQUEST);
        }

        $user = $userRepo->find($studentId);
        if (!$user) {
            return $this->json(['error' => 'User not found'], Response::HTTP_NOT_FOUND);
        }

        $email = $user->getEmail();
        if (empty($email)) {
            return $this->json(['error' => 'User has no email address.'], Response::HTTP_BAD_REQUEST);
        }

        if (!$user->isActive()) {
            $user->setActive(1);
            $em->persist($user);
            $em->flush();
        }

        $now = new DateTime();
        $relSessions = $em->getRepository(SessionRelUser::class)->findBy([
            'user' => $user,
            'relationType' => Session::STUDENT,
        ]);

        $activeSessions = array_filter($relSessions, function (SessionRelUser $rel) use ($now) {
            $s = $rel->getSession();

            return $s->getAccessStartDate() <= $now && $s->getAccessEndDate() >= $now;
        });

        $sessionListHtml = '';
        foreach ($activeSessions as $rel) {
            $session = $rel->getSession();
            $sessionListHtml .= '<li>'.htmlspecialchars($session->getTitle()).'</li>';
        }

        $request = $this->requestStack->getCurrentRequest();
        $baseUrl = $request->getSchemeAndHttpHost().$request->getBasePath();
        $sessionUrl = $baseUrl.'/sessions';

        $subject = $this->translator->trans('You have been enrolled in a new course');

        $body = $this->translator->trans(
            'Hello %s,<br><br>'.
            'You have been enrolled in a new session: <strong>%s</strong>.<br>'.
            'You can access your courses from <a href="%s">here</a>.<br><br>'.
            'Your current active sessions are:<br><ul>%s</ul><br>'.
            'Best regards,<br>'.
            'Chamilo'
        );

        $body = \sprintf(
            $body,
            $user->getFullName(),
            $session->getTitle(),
            $sessionUrl,
            $sessionListHtml
        );

        $messageHelper->sendMessage(
            $user->getId(),
            $subject,
            $body,
            [],
            [],
            0,
            0,
            0,
            $currentUser->getId(),
            0,
            false,
            true
        );

        return $this->json(['success' => true]);
    }


    #[Route('/{sessionId}/next-session', name: 'chamilo_session_next_session')]
    public function getNextSession(
        int $sessionId,
        Request $request,
        SequenceResourceRepository $repo,
        Security $security
    ): JsonResponse {

        $requirementAndDependencies = $repo->getRequirementAndDependencies(
            $sessionId,
            SequenceResource::SESSION_TYPE
        );

        $requirements = [];
        $dependencies = [];

        if (!empty($requirementAndDependencies['requirements'])) {
            foreach ($requirementAndDependencies['requirements'] as $requirement) {
                $requirements[] = [
                    'id' => $requirement['id'],
                    'name' => $requirement['name'],
                    'admin_link' => $requirement['admin_link'],
                ];
            }
        }

        if (!empty($requirementAndDependencies['dependencies'])) {
            foreach ($requirementAndDependencies['dependencies'] as $dependency) {
                $dependencies[] = [
                    'id' => $dependency['id'],
                    'name' => $dependency['name'],
                    'admin_link' => $dependency['admin_link'],
                ];
            }
        }

        $sequenceResource = $repo->findRequirementForResource(
            $sessionId,
            SequenceResource::SESSION_TYPE
        );

        $graphImage = null;
        if ($sequenceResource && $sequenceResource->hasGraph()) {
            $graph = $sequenceResource->getSequence()->getUnSerializeGraph();
            if ($graph !== null) {
                $graph->setAttribute('graphviz.node.fontname', 'arial');
                $graphviz = new GraphViz();
                $graphImage = $graphviz->createImageSrc($graph);
            }
        }

        return new JsonResponse([
            'requirements' => $requirements,
            'dependencies' => $dependencies,
            'graph' => $graphImage,
        ]);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/* For licensing terms, see /license.txt */
6
7			namespace Chamilo\CoreBundle\Controller;
8
9			use BuyCoursesPlugin;
10			use Chamilo\CoreBundle\Entity\ExtraField;
11			use Chamilo\CoreBundle\Entity\SequenceResource;
12			use Chamilo\CoreBundle\Entity\Session;
13			use Chamilo\CoreBundle\Entity\SessionRelCourse;
14			use Chamilo\CoreBundle\Entity\SessionRelUser;
15			use Chamilo\CoreBundle\Entity\Tag;
16			use Chamilo\CoreBundle\Entity\User;
17			use Chamilo\CoreBundle\Framework\Container;
18			use Chamilo\CoreBundle\Helpers\MessageHelper;
19			use Chamilo\CoreBundle\Helpers\UserHelper;
20			use Chamilo\CoreBundle\Repository\Node\IllustrationRepository;
21			use Chamilo\CoreBundle\Repository\Node\UserRepository;
22			use Chamilo\CoreBundle\Repository\SequenceRepository;
23			use Chamilo\CoreBundle\Repository\SequenceResourceRepository;
24			use Chamilo\CoreBundle\Repository\TagRepository;
25			use Chamilo\CourseBundle\Entity\CCourseDescription;
26			use CourseDescription;
27			use DateTime;
28			use Doctrine\ORM\EntityManagerInterface;
29			use Doctrine\ORM\EntityRepository;
30			use Essence\Essence;
31			use ExtraFieldValue;
32			use Graphp\GraphViz\GraphViz;
33			use Sensio\Bundle\FrameworkExtraBundle\Configuration\Entity;
34			use SessionManager;
35			use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
36			use Symfony\Bundle\SecurityBundle\Security;
37			use Symfony\Component\HttpFoundation\JsonResponse;
38			use Symfony\Component\HttpFoundation\Request;
39			use Symfony\Component\HttpFoundation\RequestStack;
40			use Symfony\Component\HttpFoundation\Response;
41			use Symfony\Component\Routing\Attribute\Route;
42			use Symfony\Contracts\Translation\TranslatorInterface;
43			use UserManager;
44
45			#[Route('/sessions')]
46			class SessionController extends AbstractController
47			{
48			public function __construct(
49			private readonly UserHelper $userHelper,
50			private readonly TranslatorInterface $translator,
51			private readonly RequestStack $requestStack
52			) {}
53
54			#[Route(path: '/{sid}/about', name: 'chamilo_core_session_about')]
55			public function about(
56			Request $request,
57			Session $session,
58			IllustrationRepository $illustrationRepo,
59			UserRepository $userRepo,
60			EntityManagerInterface $em
61			): Response {
62			$requestSession = $request->getSession();
63			$htmlHeadXtra[] = api_get_asset('readmore-js/readmore.js');
			0 ignored issues – show Comprehensibility Best Practice introduced 2019-11-29 12:55 UTC by Report Bug Copy Issue Report `$htmlHeadXtra` was never initialized. Although not strictly required by PHP, it is generally a good practice to add `$htmlHeadXtra = array();` before regardless. Loading history...
64
65			$sessionId = $session->getId();
66			$courses = [];
67			$sessionCourses = $session->getCourses();
68
69			/** @var EntityRepository $fieldsRepo */
70			$fieldsRepo = $em->getRepository(ExtraField::class);
71
72			/** @var TagRepository $tagRepo */
73			$tagRepo = $em->getRepository(Tag::class);
74
75			/** @var SequenceRepository $sequenceResourceRepo */
76			$sequenceResourceRepo = $em->getRepository(SequenceResource::class);
77
78			/** @var ExtraField $tagField */
79			$tagField = $fieldsRepo->findOneBy([
80			'itemType' => ExtraField::COURSE_FIELD_TYPE,
81			'variable' => 'tags',
82			]);
83
84			$courseValues = new ExtraFieldValue('course');
85			$userValues = new ExtraFieldValue('user');
86			$sessionValues = new ExtraFieldValue('session');
87
88			/** @var SessionRelCourse $sessionRelCourse */
89			foreach ($sessionCourses as $sessionRelCourse) {
90			$sessionCourse = $sessionRelCourse->getCourse();
91			$courseTags = [];
92
93			if (null !== $tagField) {
94			$courseTags = $tagRepo->getTagsByItem($tagField, $sessionCourse->getId());
95			}
96
97			$courseCoaches = $userRepo->getCoachesForSessionCourse($session, $sessionCourse);
98			$coachesData = [];
99
100			/** @var User $courseCoach */
101			foreach ($courseCoaches as $courseCoach) {
102			$coachData = [
103			'complete_name' => UserManager::formatUserFullName($courseCoach),
104			'image' => $illustrationRepo->getIllustrationUrl($courseCoach),
105			'diploma' => $courseCoach->getDiplomas(),
106			'openarea' => $courseCoach->getOpenarea(),
107			'extra_fields' => $userValues->getAllValuesForAnItem(
108			$courseCoach->getId(),
109			null,
110			true
111			),
112			];
113
114			$coachesData[] = $coachData;
115			}
116
117			$cd = new CourseDescription();
118			$cd->set_course_id($sessionCourse->getId());
119			$cd->set_session_id($session->getId());
120			$descriptionsData = $cd->get_description_data();
121
122			$courseDescription = [];
123			$courseObjectives = [];
124			$courseTopics = [];
125			$courseMethodology = [];
126			$courseMaterial = [];
127			$courseResources = [];
128			$courseAssessment = [];
129			$courseCustom = [];
130
131			if (!empty($descriptionsData)) {
132			foreach ($descriptionsData as $descriptionInfo) {
133			$type = $descriptionInfo->getDescriptionType();
134
135			switch ($type) {
136			case CCourseDescription::TYPE_DESCRIPTION:
137			$courseDescription[] = $descriptionInfo;
138
139			break;
140
141			case CCourseDescription::TYPE_OBJECTIVES:
142			$courseObjectives[] = $descriptionInfo;
143
144			break;
145
146			case CCourseDescription::TYPE_TOPICS:
147			$courseTopics[] = $descriptionInfo;
148
149			break;
150
151			case CCourseDescription::TYPE_METHODOLOGY:
152			$courseMethodology[] = $descriptionInfo;
153
154			break;
155
156			case CCourseDescription::TYPE_COURSE_MATERIAL:
157			$courseMaterial[] = $descriptionInfo;
158
159			break;
160
161			case CCourseDescription::TYPE_RESOURCES:
162			$courseResources[] = $descriptionInfo;
163
164			break;
165
166			case CCourseDescription::TYPE_ASSESSMENT:
167			$courseAssessment[] = $descriptionInfo;
168
169			break;
170
171			case CCourseDescription::TYPE_CUSTOM:
172			$courseCustom[] = $descriptionInfo;
173
174			break;
175			}
176			}
177			}
178
179			$courses[] = [
180			'course' => $sessionCourse,
181			'description' => $courseDescription,
182			'image' => Container::getIllustrationRepository()->getIllustrationUrl($sessionCourse),
183			'tags' => $courseTags,
184			'objectives' => $courseObjectives,
185			'topics' => $courseTopics,
186			'methodology' => $courseMethodology,
187			'material' => $courseMaterial,
188			'resources' => $courseResources,
189			'assessment' => $courseAssessment,
190			'custom' => array_reverse($courseCustom),
191			'coaches' => $coachesData,
192			'extra_fields' => $courseValues->getAllValuesForAnItem(
193			$sessionCourse->getId(),
194			null,
195			true
196			),
197			];
198			}
199
200			$sessionDates = SessionManager::parseSessionDates($session, true);
201
202			$hasRequirements = false;
203
204			/*$sessionRequirements = $sequenceResourceRepo->getRequirements(
205			* $session->getId(),
206			* SequenceResource::SESSION_TYPE
207			* );
208			* foreach ($sessionRequirements as $sequence) {
209			* if (!empty($sequence['requirements'])) {
210			* $hasRequirements = true;
211			* break;
212			* }
213			* }*/
214			$plugin = BuyCoursesPlugin::create();
215			$checker = $plugin->isEnabled();
216			$sessionIsPremium = null;
217			if ($checker) {
218			$sessionIsPremium = $plugin->getItemByProduct(
219			$sessionId,
220			BuyCoursesPlugin::PRODUCT_TYPE_SESSION
221			);
222			if ([] !== $sessionIsPremium) {
223			$requestSession->set('SessionIsPremium', true);
224			$requestSession->set('sessionId', $sessionId);
225			}
226			}
227
228			$redirectToSession = ('true' === Container::getSettingsManager()->getSetting('session.allow_redirect_to_session_after_inscription_about'));
229			$redirectToSession = $redirectToSession ? '?s='.$sessionId : false;
230
231			$coursesInThisSession = SessionManager::get_course_list_by_session_id($sessionId);
232			$coursesCount = \count($coursesInThisSession);
233			$redirectToSession = 1 === $coursesCount && $redirectToSession
234			? ($redirectToSession.'&cr='.array_values($coursesInThisSession)[0]['directory'])
235			: $redirectToSession;
236
237			$essence = new Essence();
238
239			$params = [
240			'session' => $session,
241			'redirect_to_session' => $redirectToSession,
242			'courses' => $courses,
243			'essence' => $essence,
244			'session_extra_fields' => $sessionValues->getAllValuesForAnItem($session->getId(), null, true),
245			'has_requirements' => $hasRequirements,
246			// 'sequences' => $sessionRequirements,
247			'is_premium' => $sessionIsPremium,
248			'show_tutor' => 'true' === api_get_setting('show_session_coach'),
249			'page_url' => api_get_path(WEB_PATH).\sprintf('sessions/%s/about/', $session->getId()),
250			'session_date' => $sessionDates,
251			'is_subscribed' => SessionManager::isUserSubscribedAsStudent(
252			$session->getId(),
253			api_get_user_id()
254			),
255			'user_session_time' => SessionManager::getDayLeftInSession(
256			[
257			'id' => $session->getId(),
258			'duration' => $session->getDuration(),
259			],
260			api_get_user_id()
261			),
262			'base_url' => $request->getSchemeAndHttpHost(),
263			];
264
265			return $this->render('@ChamiloCore/Session/about.html.twig', $params);
266			}
267
268			#[Route('/{id}/send-course-notification', name: 'chamilo_core_session_send_course_notification', methods: ['POST'])]
269			public function sendCourseNotification(
270			int $id,
271			Request $request,
272			UserRepository $userRepo,
273			EntityManagerInterface $em,
274			MessageHelper $messageHelper
275			): Response {
276			$session = $em->getRepository(Session::class)->find($id);
277			$currentUser = $this->userHelper->getCurrent();
278
279			if (!$session) {
280			return $this->json(['error' => 'Session not found'], Response::HTTP_NOT_FOUND);
281			}
282
283			$studentId = $request->request->get('studentId');
284			if (!$studentId) {
285			return $this->json(['error' => 'Missing studentId'], Response::HTTP_BAD_REQUEST);
286			}
287
288			$user = $userRepo->find($studentId);
289			if (!$user) {
290			return $this->json(['error' => 'User not found'], Response::HTTP_NOT_FOUND);
291			}
292
293			$email = $user->getEmail();
294			if (empty($email)) {
295			return $this->json(['error' => 'User has no email address.'], Response::HTTP_BAD_REQUEST);
296			}
297
298			if (!$user->isActive()) {
299			$user->setActive(1);
300			$em->persist($user);
301			$em->flush();
302			}
303
304			$now = new DateTime();
305			$relSessions = $em->getRepository(SessionRelUser::class)->findBy([
306			'user' => $user,
307			'relationType' => Session::STUDENT,
308			]);
309
310			$activeSessions = array_filter($relSessions, function (SessionRelUser $rel) use ($now) {
311			$s = $rel->getSession();
312
313			return $s->getAccessStartDate() <= $now && $s->getAccessEndDate() >= $now;
314			});
315
316			$sessionListHtml = '';
317			foreach ($activeSessions as $rel) {
318			$session = $rel->getSession();
319			$sessionListHtml .= '<li>'.htmlspecialchars($session->getTitle()).'</li>';
320			}
321
322			$request = $this->requestStack->getCurrentRequest();
323			$baseUrl = $request->getSchemeAndHttpHost().$request->getBasePath();
324			$sessionUrl = $baseUrl.'/sessions';
325
326			$subject = $this->translator->trans('You have been enrolled in a new course');
327
328			$body = $this->translator->trans(
329			'Hello %s,<br><br>'.
330			'You have been enrolled in a new session: <strong>%s</strong>.<br>'.
331			'You can access your courses from <a href="%s">here</a>.<br><br>'.
332			'Your current active sessions are:<br><ul>%s</ul><br>'.
333			'Best regards,<br>'.
334			'Chamilo'
335			);
336
337			$body = \sprintf(
338			$body,
339			$user->getFullName(),
340			$session->getTitle(),
341			$sessionUrl,
342			$sessionListHtml
343			);
344
345			$messageHelper->sendMessage(
346			$user->getId(),
347			$subject,
348			$body,
349			[],
350			[],
351			0,
352			0,
353			0,
354			$currentUser->getId(),
355			0,
356			false,
357			true
358			);
359
360			return $this->json(['success' => true]);
361			}
362
363
364			#[Route('/{sessionId}/next-session', name: 'chamilo_session_next_session')]
365			public function getNextSession(
366			int $sessionId,
367			Request $request,
368			SequenceResourceRepository $repo,
369			Security $security
370			): JsonResponse {
371
372			$requirementAndDependencies = $repo->getRequirementAndDependencies(
373			$sessionId,
374			SequenceResource::SESSION_TYPE
375			);
376
377			$requirements = [];
378			$dependencies = [];
379
380			if (!empty($requirementAndDependencies['requirements'])) {
381			foreach ($requirementAndDependencies['requirements'] as $requirement) {
382			$requirements[] = [
383			'id' => $requirement['id'],
384			'name' => $requirement['name'],
385			'admin_link' => $requirement['admin_link'],
386			];
387			}
388			}
389
390			if (!empty($requirementAndDependencies['dependencies'])) {
391			foreach ($requirementAndDependencies['dependencies'] as $dependency) {
392			$dependencies[] = [
393			'id' => $dependency['id'],
394			'name' => $dependency['name'],
395			'admin_link' => $dependency['admin_link'],
396			];
397			}
398			}
399
400			$sequenceResource = $repo->findRequirementForResource(
401			$sessionId,
402			SequenceResource::SESSION_TYPE
403			);
404
405			$graphImage = null;
406			if ($sequenceResource && $sequenceResource->hasGraph()) {
407			$graph = $sequenceResource->getSequence()->getUnSerializeGraph();
408			if ($graph !== null) {
409			$graph->setAttribute('graphviz.node.fontname', 'arial');
410			$graphviz = new GraphViz();
411			$graphImage = $graphviz->createImageSrc($graph);
412			}
413			}
414
415			return new JsonResponse([
416			'requirements' => $requirements,
417			'dependencies' => $dependencies,
418			'graph' => $graphImage,
419			]);
420			}
421			}
422

chamilo / chamilo-lms

Push — master ( 9d97a9...43700c )

SessionController::about() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like