AdminController::invalidateCacheAllUsers() - Code Metrics - Inspection of "Internal: Add Query Caching Support and Demo Endpo..." - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 5a655a...f1e8b0 )

by Yannick

created 2025-07-09 17:48 UTC

AdminController::invalidateCacheAllUsers() A

↳ Parent: AdminController

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

declare(strict_types=1);

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

namespace Chamilo\CoreBundle\Controller\Admin;

use Chamilo\CoreBundle\Controller\BaseController;
use Chamilo\CoreBundle\Entity\ResourceLink;
use Chamilo\CoreBundle\Entity\ResourceType;
use Chamilo\CoreBundle\Helpers\AccessUrlHelper;
use Chamilo\CoreBundle\Helpers\QueryCacheHelper;
use Chamilo\CoreBundle\Repository\Node\UserRepository;
use Chamilo\CoreBundle\Repository\ResourceFileRepository;
use Chamilo\CoreBundle\Repository\ResourceNodeRepository;
use Chamilo\CoreBundle\Settings\SettingsManager;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\Security\Http\Attribute\IsGranted;

#[Route('/admin')]
class AdminController extends BaseController
{
    private const ITEMS_PER_PAGE = 50;

    public function __construct(
        private readonly ResourceNodeRepository $resourceNodeRepository,
        private readonly AccessUrlHelper $accessUrlHelper
    ) {}

    #[IsGranted('ROLE_ADMIN')]
    #[Route('/register-campus', name: 'admin_register_campus', methods: ['POST'])]
    public function registerCampus(Request $request, SettingsManager $settingsManager): Response
    {
        $requestData = $request->toArray();
        $doNotListCampus = (bool) $requestData['donotlistcampus'];

        $settingsManager->setUrl($this->accessUrlHelper->getCurrent());
        $settingsManager->updateSetting('platform.registered', 'true');

        $settingsManager->updateSetting(
            'platform.donotlistcampus',
            $doNotListCampus ? 'true' : 'false'
        );

        return new Response('', Response::HTTP_NO_CONTENT);
    }

    #[IsGranted('ROLE_ADMIN')]
    #[Route('/files_info', name: 'admin_files_info', methods: ['GET'])]
    public function listFilesInfo(Request $request, ResourceFileRepository $resourceFileRepository): Response
    {
        $page = $request->query->getInt('page', 1);
        $search = $request->query->get('search', '');
        $offset = ($page - 1) * self::ITEMS_PER_PAGE;

        $files = $resourceFileRepository->searchFiles($search, $offset, self::ITEMS_PER_PAGE);
        $totalItems = $resourceFileRepository->countFiles($search);
        $totalPages = $totalItems > 0 ? ceil($totalItems / self::ITEMS_PER_PAGE) : 1;

        $fileUrls = [];
        $filePaths = [];
        foreach ($files as $file) {
            $resourceNode = $file->getResourceNode();
            if ($resourceNode) {
                $fileUrls[$file->getId()] = $this->resourceNodeRepository->getResourceFileUrl($resourceNode);
                $creator = $resourceNode->getCreator();
            } else {
                $fileUrls[$file->getId()] = null;
                $creator = null;
            }
            $filePaths[$file->getId()] = '/upload/resource'.$this->resourceNodeRepository->getFilename($file);
        }

        return $this->render('@ChamiloCore/Admin/files_info.html.twig', [
            'files' => $files,
            'fileUrls' => $fileUrls,
            'filePaths' => $filePaths,
            'totalPages' => $totalPages,
            'currentPage' => $page,
            'search' => $search,
        ]);
    }

    #[IsGranted('ROLE_ADMIN')]
    #[Route('/resources_info', name: 'admin_resources_info', methods: ['GET'])]
    public function listResourcesInfo(Request $request, ResourceNodeRepository $resourceNodeRepo, EntityManagerInterface $em): Response
    {
        $resourceTypeId = $request->query->getInt('type');
        $resourceTypes = $em->getRepository(ResourceType::class)->findAll();

        $courses = [];
        if ($resourceTypeId > 0) {
            $resourceLinks = $em->getRepository(ResourceLink::class)->createQueryBuilder('rl')
                ->join('rl.resourceNode', 'rn')
                ->where('rn.resourceType = :type')
                ->setParameter('type', $resourceTypeId)
                ->getQuery()
                ->getResult()
            ;

            $seen = [];
            foreach ($resourceLinks as $link) {
                $course = $link->getCourse();
                $session = $link->getSession();
                $node = $link->getResourceNode();

                if (!$course) {
                    continue;
                }

                $key = $session
                    ? 's'.$session->getId().'-'.$course->getId()
                    : 'c'.$course->getId();

                if (!isset($seen[$key])) {
                    $seen[$key] = [
                        'type' => $session ? 'session' : 'course',
                        'id' => $session ? $session->getId() : $course->getId(),
                        'title' => $session ? $session->getTitle().' - '.$course->getTitle() : $course->getTitle(),
                        'url' => $session
                            ? '/course/'.$course->getId().'/home?sid='.$session->getId()
                            : '/course/'.$course->getId().'/home',
                        'count' => 0,
                        'items' => [],
                        'firstCreatedAt' => $node->getCreatedAt(),
                    ];
                }

                $seen[$key]['count']++;
                $seen[$key]['items'][] = $node->getTitle();

                if ($node->getCreatedAt() < $seen[$key]['firstCreatedAt']) {
                    $seen[$key]['firstCreatedAt'] = $node->getCreatedAt();
                }
            }

            $courses = array_values($seen);
            usort($courses, fn ($a, $b) => strnatcasecmp($a['title'], $b['title']));
        }

        return $this->render('@ChamiloCore/Admin/resources_info.html.twig', [
            'resourceTypes' => $resourceTypes,
            'selectedType' => $resourceTypeId,
            'courses' => $courses,
        ]);
    }

    #[IsGranted('ROLE_ADMIN')]
    #[Route('/test-cache-all-users', name: 'chamilo_core_user_test_cache_all_users')]
    public function testCacheAllUsers(UserRepository $userRepository): JsonResponse
    {
        // Without cache
        $startNoCache = microtime(true);
        $usersNoCache = $userRepository->findAllUsers(false);
        $timeNoCache = microtime(true) - $startNoCache;

        // With cache
        $startCache = microtime(true);
        $resultCached = $userRepository->findAllUsers(true);
        $timeCache = microtime(true) - $startCache;

        // Check if we have a key (we do if cache was used)
        $usersCache = $resultCached['data'] ?? $resultCached;

        $cacheKey = $resultCached['cache_key'] ?? null;

        return $this->json([
            'without_cache' => [
                'count' => count($usersNoCache),
                'execution_time' => $timeNoCache,
            ],
            'with_cache' => [
                'count' => count($usersCache),
                'execution_time' => $timeCache,
                'cache_key' => $cacheKey,
            ],
        ]);
    }

    #[IsGranted('ROLE_ADMIN')]
    #[Route(path: '/test-cache-all-users/invalidate', name: 'chamilo_core_user_test_cache_all_users_invalidate')]
    public function invalidateCacheAllUsers(QueryCacheHelper $queryCacheHelper): JsonResponse
    {
        $cacheKey = $queryCacheHelper->getCacheKey('findAllUsers', []);
        $queryCacheHelper->invalidate('findAllUsers');

        return $this->json([
            'message' => 'Cache for users invalidated!',
            'invalidated_cache_key' => $cacheKey,
        ]);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/* For licensing terms, see /license.txt */
6
7			namespace Chamilo\CoreBundle\Controller\Admin;
8
9			use Chamilo\CoreBundle\Controller\BaseController;
10			use Chamilo\CoreBundle\Entity\ResourceLink;
11			use Chamilo\CoreBundle\Entity\ResourceType;
12			use Chamilo\CoreBundle\Helpers\AccessUrlHelper;
13			use Chamilo\CoreBundle\Helpers\QueryCacheHelper;
14			use Chamilo\CoreBundle\Repository\Node\UserRepository;
15			use Chamilo\CoreBundle\Repository\ResourceFileRepository;
16			use Chamilo\CoreBundle\Repository\ResourceNodeRepository;
17			use Chamilo\CoreBundle\Settings\SettingsManager;
18			use Doctrine\ORM\EntityManagerInterface;
19			use Symfony\Component\HttpFoundation\JsonResponse;
20			use Symfony\Component\HttpFoundation\Request;
21			use Symfony\Component\HttpFoundation\Response;
22			use Symfony\Component\Routing\Annotation\Route;
23			use Symfony\Component\Security\Http\Attribute\IsGranted;
24
25			#[Route('/admin')]
26			class AdminController extends BaseController
27			{
28			private const ITEMS_PER_PAGE = 50;
29
30			public function __construct(
31			private readonly ResourceNodeRepository $resourceNodeRepository,
32			private readonly AccessUrlHelper $accessUrlHelper
33			) {}
34
35			#[IsGranted('ROLE_ADMIN')]
36			#[Route('/register-campus', name: 'admin_register_campus', methods: ['POST'])]
37			public function registerCampus(Request $request, SettingsManager $settingsManager): Response
38			{
39			$requestData = $request->toArray();
40			$doNotListCampus = (bool) $requestData['donotlistcampus'];
41
42			$settingsManager->setUrl($this->accessUrlHelper->getCurrent());
43			$settingsManager->updateSetting('platform.registered', 'true');
44
45			$settingsManager->updateSetting(
46			'platform.donotlistcampus',
47			$doNotListCampus ? 'true' : 'false'
48			);
49
50			return new Response('', Response::HTTP_NO_CONTENT);
51			}
52
53			#[IsGranted('ROLE_ADMIN')]
54			#[Route('/files_info', name: 'admin_files_info', methods: ['GET'])]
55			public function listFilesInfo(Request $request, ResourceFileRepository $resourceFileRepository): Response
56			{
57			$page = $request->query->getInt('page', 1);
58			$search = $request->query->get('search', '');
59			$offset = ($page - 1) * self::ITEMS_PER_PAGE;
60
61			$files = $resourceFileRepository->searchFiles($search, $offset, self::ITEMS_PER_PAGE);
62			$totalItems = $resourceFileRepository->countFiles($search);
63			$totalPages = $totalItems > 0 ? ceil($totalItems / self::ITEMS_PER_PAGE) : 1;
64
65			$fileUrls = [];
66			$filePaths = [];
67			foreach ($files as $file) {
68			$resourceNode = $file->getResourceNode();
69			if ($resourceNode) {
70			$fileUrls[$file->getId()] = $this->resourceNodeRepository->getResourceFileUrl($resourceNode);
71			$creator = $resourceNode->getCreator();
72			} else {
73			$fileUrls[$file->getId()] = null;
74			$creator = null;
75			}
76			$filePaths[$file->getId()] = '/upload/resource'.$this->resourceNodeRepository->getFilename($file);
77			}
78
79			return $this->render('@ChamiloCore/Admin/files_info.html.twig', [
80			'files' => $files,
81			'fileUrls' => $fileUrls,
82			'filePaths' => $filePaths,
83			'totalPages' => $totalPages,
84			'currentPage' => $page,
85			'search' => $search,
86			]);
87			}
88
89			#[IsGranted('ROLE_ADMIN')]
90			#[Route('/resources_info', name: 'admin_resources_info', methods: ['GET'])]
91			public function listResourcesInfo(Request $request, ResourceNodeRepository $resourceNodeRepo, EntityManagerInterface $em): Response
92			{
93			$resourceTypeId = $request->query->getInt('type');
94			$resourceTypes = $em->getRepository(ResourceType::class)->findAll();
95
96			$courses = [];
97			if ($resourceTypeId > 0) {
98			$resourceLinks = $em->getRepository(ResourceLink::class)->createQueryBuilder('rl')
99			->join('rl.resourceNode', 'rn')
100			->where('rn.resourceType = :type')
101			->setParameter('type', $resourceTypeId)
102			->getQuery()
103			->getResult()
104			;
105
106			$seen = [];
107			foreach ($resourceLinks as $link) {
108			$course = $link->getCourse();
109			$session = $link->getSession();
110			$node = $link->getResourceNode();
111
112			if (!$course) {
113			continue;
114			}
115
116			$key = $session
117			? 's'.$session->getId().'-'.$course->getId()
118			: 'c'.$course->getId();
119
120			if (!isset($seen[$key])) {
121			$seen[$key] = [
122			'type' => $session ? 'session' : 'course',
123			'id' => $session ? $session->getId() : $course->getId(),
124			'title' => $session ? $session->getTitle().' - '.$course->getTitle() : $course->getTitle(),
125			'url' => $session
126			? '/course/'.$course->getId().'/home?sid='.$session->getId()
127			: '/course/'.$course->getId().'/home',
128			'count' => 0,
129			'items' => [],
130			'firstCreatedAt' => $node->getCreatedAt(),
131			];
132			}
133
134			$seen[$key]['count']++;
135			$seen[$key]['items'][] = $node->getTitle();
136
137			if ($node->getCreatedAt() < $seen[$key]['firstCreatedAt']) {
138			$seen[$key]['firstCreatedAt'] = $node->getCreatedAt();
139			}
140			}
141
142			$courses = array_values($seen);
143			usort($courses, fn ($a, $b) => strnatcasecmp($a['title'], $b['title']));
144			}
145
146			return $this->render('@ChamiloCore/Admin/resources_info.html.twig', [
147			'resourceTypes' => $resourceTypes,
148			'selectedType' => $resourceTypeId,
149			'courses' => $courses,
150			]);
151			}
152
153			#[IsGranted('ROLE_ADMIN')]
154			#[Route('/test-cache-all-users', name: 'chamilo_core_user_test_cache_all_users')]
155			public function testCacheAllUsers(UserRepository $userRepository): JsonResponse
156			{
157			// Without cache
158			$startNoCache = microtime(true);
159			$usersNoCache = $userRepository->findAllUsers(false);
160			$timeNoCache = microtime(true) - $startNoCache;
161
162			// With cache
163			$startCache = microtime(true);
164			$resultCached = $userRepository->findAllUsers(true);
165			$timeCache = microtime(true) - $startCache;
166
167			// Check if we have a key (we do if cache was used)
168			$usersCache = $resultCached['data'] ?? $resultCached;
169
170			$cacheKey = $resultCached['cache_key'] ?? null;
171
172			return $this->json([
173			'without_cache' => [
174			'count' => count($usersNoCache),
175			'execution_time' => $timeNoCache,
176			],
177			'with_cache' => [
178			'count' => count($usersCache),
179			'execution_time' => $timeCache,
180			'cache_key' => $cacheKey,
181			],
182			]);
183			}
184
185			#[IsGranted('ROLE_ADMIN')]
186			#[Route(path: '/test-cache-all-users/invalidate', name: 'chamilo_core_user_test_cache_all_users_invalidate')]
187			public function invalidateCacheAllUsers(QueryCacheHelper $queryCacheHelper): JsonResponse
188			{
189			$cacheKey = $queryCacheHelper->getCacheKey('findAllUsers', []);
190			$queryCacheHelper->invalidate('findAllUsers');
191
192			return $this->json([
193			'message' => 'Cache for users invalidated!',
194			'invalidated_cache_key' => $cacheKey,
195			]);
196			}
197			}
198

chamilo / chamilo-lms

Push — master ( 5a655a...f1e8b0 )

AdminController::invalidateCacheAllUsers() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like