Container::getQuestionRepository() - Code Metrics - Inspection of "Course description: update code to use resources." - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 7ade69...469b77 )

by Julito

created 2020-12-10 15:49 UTC

Container::getQuestionRepository() A

↳ Parent: Container

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

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

namespace Chamilo\CoreBundle\Framework;

use Chamilo\CoreBundle\Component\Editor\Editor;
use Chamilo\CoreBundle\Manager\SettingsManager;
use Chamilo\CoreBundle\Repository\AccessUrlRepository;
use Chamilo\CoreBundle\Repository\CourseCategoryRepository;
use Chamilo\CoreBundle\Repository\CourseRepository;
use Chamilo\CoreBundle\Repository\IllustrationRepository;
use Chamilo\CoreBundle\Repository\SequenceRepository;
use Chamilo\CoreBundle\Repository\SequenceResourceRepository;
use Chamilo\CoreBundle\Repository\SessionRepository;
use Chamilo\CoreBundle\Repository\UserRepository;
use Chamilo\CoreBundle\ToolChain;
use Chamilo\CourseBundle\Repository\CAnnouncementAttachmentRepository;
use Chamilo\CourseBundle\Repository\CAnnouncementRepository;
use Chamilo\CourseBundle\Repository\CAttendanceRepository;
use Chamilo\CourseBundle\Repository\CCalendarEventAttachmentRepository;
use Chamilo\CourseBundle\Repository\CCalendarEventRepository;
use Chamilo\CourseBundle\Repository\CCourseDescriptionRepository;
use Chamilo\CourseBundle\Repository\CDocumentRepository;
use Chamilo\CourseBundle\Repository\CExerciseCategoryRepository;
use Chamilo\CourseBundle\Repository\CForumAttachmentRepository;
use Chamilo\CourseBundle\Repository\CForumCategoryRepository;
use Chamilo\CourseBundle\Repository\CForumForumRepository;
use Chamilo\CourseBundle\Repository\CForumPostRepository;
use Chamilo\CourseBundle\Repository\CForumThreadRepository;
use Chamilo\CourseBundle\Repository\CGroupCategoryRepository;
use Chamilo\CourseBundle\Repository\CGroupRepository;
use Chamilo\CourseBundle\Repository\CLinkCategoryRepository;
use Chamilo\CourseBundle\Repository\CLinkRepository;
use Chamilo\CourseBundle\Repository\CLpCategoryRepository;
use Chamilo\CourseBundle\Repository\CLpRepository;
use Chamilo\CourseBundle\Repository\CNotebookRepository;
use Chamilo\CourseBundle\Repository\CQuizQuestionCategoryRepository;
use Chamilo\CourseBundle\Repository\CQuizQuestionRepository;
use Chamilo\CourseBundle\Repository\CQuizRepository;
use Chamilo\CourseBundle\Repository\CShortcutRepository;
use Chamilo\CourseBundle\Repository\CStudentPublicationAssignmentRepository;
use Chamilo\CourseBundle\Repository\CStudentPublicationCommentRepository;
use Chamilo\CourseBundle\Repository\CStudentPublicationRepository;
use Chamilo\CourseBundle\Repository\CThematicAdvanceRepository;
use Chamilo\CourseBundle\Repository\CThematicPlanRepository;
use Chamilo\CourseBundle\Repository\CThematicRepository;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Session\Session;
use Symfony\Component\Routing\Router;
use Symfony\Component\Security\Core\Authorization\AuthorizationChecker;
use Symfony\Component\Security\Core\Role\RoleHierarchy;
use Symfony\Contracts\Translation\TranslatorInterface;
use Twig\Environment;

/**
 * Class Container
 * This class is a way to access Symfony2 services in legacy Chamilo code.
 */
class Container
{
    /**
     * @var ContainerInterface
     */
    public static $container;
    public static $session;
    public static $request;
    public static $configuration;
    public static $environment;
    public static $urlGenerator;
    public static $checker;
    /** @var TranslatorInterface */
    public static $translator;
    public static $mailer;
    public static $template;

    public static $rootDir;
    public static $logDir;
    public static $tempDir;
    public static $dataDir;
    public static $courseDir;
    public static $assets;
    public static $htmlEditor;
    public static $twig;
    public static $roles;
    /** @var string */
    public static $legacyTemplate = '@ChamiloCore/Layout/layout_one_col.html.twig';
    //private static $settingsManager;
    //private static $userManager;
    //private static $siteManager;

    /**
     * @param ContainerInterface $container
     */
    public static function setContainer($container)
    {
        self::$container = $container;
    }

    /**
     * @param string $parameter
     */
    public static function getParameter($parameter)
    {
        if (self::$container->hasParameter($parameter)) {
            return self::$container->getParameter($parameter);
        }

        return false;
    }

    /**
     * @return string
     */
    public static function getEnvironment()
    {
        return self::$container->get('kernel')->getEnvironment();
    }

    /**
     * @return RoleHierarchy
     */
    public static function getRoles()
    {
        return self::$container->get('security.role_hierarchy');
    }

    /**
     * @return string
     */
    public static function getLogDir()
    {
        return self::$container->get('kernel')->getLogDir();
    }

    /**
     * @return string
     */
    public static function getCacheDir()
    {
        return self::$container->get('kernel')->getCacheDir().'/';
    }

    /**
     * @return string
     */
    public static function getProjectDir()
    {
        if (isset(self::$container)) {
            return self::$container->get('kernel')->getProjectDir().'/';
        }

        return str_replace('\\', '/', realpath(__DIR__.'/../../../')).'/';
    }

    /**
     * @return string
     */
    public static function isInstalled()
    {
        return self::$container->get('kernel')->isInstalled();
    }

    /**
     * @return Environment
     */
    public static function getTwig()
    {
        return self::$container->get('twig');
    }

    /**
     * @return Environment
     */
    public static function getTemplating()
    {
        return self::$container->get('twig');
    }

    /**
     * @return Editor
     */
    public static function getHtmlEditor()
    {
        return self::$container->get('chamilo_core.html_editor');
    }

    /**
     * @return object|Request
     */
    public static function getRequest()
    {
        if (null === self::$container) {
            return null;
        }

        if (!empty(self::$request)) {
            return self::$request;
        }

        return self::$container->get('request_stack');
    }

    /**
     * @param Request $request
     */
    public static function setRequest($request)
    {
        self::$request = $request;
    }

    /**
     * @return Session|false
     */
    public static function getSession()
    {
        if (self::$container && self::$container->has('session')) {
            return self::$container->get('session');
        }

        return false;
    }

    /**
     * @return AuthorizationChecker
     */
    public static function getAuthorizationChecker()
    {
        return self::$container->get('security.authorization_checker');
    }

    /**
     * @return object|\Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorage
     */
    public static function getTokenStorage()
    {
        return self::$container->get('security.token_storage');
    }

    /**
     * @return TranslatorInterface
     */
    public static function getTranslator()
    {
        if (isset(self::$translator)) {
            return self::$translator;
        }

        if (self::$container) {
            return self::$container->get('translator');
        }

        return false;
    }

    public static function getMailer()
    {
        return self::$container->get('Symfony\Component\Mailer\Mailer');
    }

    public static function getSettingsManager(): SettingsManager
    {
        return self::$container->get('chamilo.settings.manager');
    }

    public static function getCourseSettingsManager(): \Chamilo\CourseBundle\Manager\SettingsManager
    {
        return self::$container->get('Chamilo\CourseBundle\Manager\SettingsManager');
    }

    /**
     * @return \Doctrine\ORM\EntityManager
     */
    public static function getEntityManager()
    {
        return \Database::getManager();
    }

    public static function getUserManager()
    {
        return self::$container->get(UserRepository::class);
    }

    public static function getAttendanceRepository(): CAttendanceRepository
    {
        return self::$container->get(CAttendanceRepository::class);
    }

    public static function getAnnouncementRepository(): CAnnouncementRepository
    {
        return self::$container->get(CAnnouncementRepository::class);
    }

    public static function getAccessUrlRepository(): AccessUrlRepository
    {
        return self::$container->get(AccessUrlRepository::class);
    }

    public static function getAnnouncementAttachmentRepository(): CAnnouncementAttachmentRepository
    {
        return self::$container->get(CAnnouncementAttachmentRepository::class);
    }

    public static function getCourseRepository(): CourseRepository
    {
        return self::$container->get(CourseRepository::class);
    }

    public static function getSessionRepository(): SessionRepository
    {
        return self::$container->get(SessionRepository::class);
    }

    public static function getCourseCategoryRepository(): CourseCategoryRepository
    {
        return self::$container->get(CourseCategoryRepository::class);
    }

    public static function getCourseDescriptionRepository(): CCourseDescriptionRepository
    {
        return self::$container->get(CCourseDescriptionRepository::class);
    }

    public static function getCalendarEventRepository(): CCalendarEventRepository
    {
        return self::$container->get(CCalendarEventRepository::class);
    }

    public static function getCalendarEventAttachmentRepository(): CCalendarEventAttachmentRepository
    {
        return self::$container->get(CCalendarEventAttachmentRepository::class);
    }

    public static function getDocumentRepository(): CDocumentRepository
    {
        return self::$container->get(CDocumentRepository::class);
    }

    public static function getQuizRepository(): CQuizRepository
    {
        return self::$container->get(CQuizRepository::class);
    }

    public static function getExerciseCategoryRepository(): CExerciseCategoryRepository
    {
        return self::$container->get(CExerciseCategoryRepository::class);
    }

    public static function getForumRepository(): CForumForumRepository
    {
        return self::$container->get(CForumForumRepository::class);
    }

    public static function getForumCategoryRepository(): CForumCategoryRepository
    {
        return self::$container->get(CForumCategoryRepository::class);
    }

    public static function getForumPostRepository(): CForumPostRepository
    {
        return self::$container->get(CForumPostRepository::class);
    }

    public static function getForumAttachmentRepository(): CForumAttachmentRepository
    {
        return self::$container->get(CForumAttachmentRepository::class);
    }

    public static function getForumThreadRepository(): CForumThreadRepository
    {
        return self::$container->get(CForumThreadRepository::class);
    }

    public static function getGroupRepository(): CGroupRepository
    {
        return self::$container->get(CGroupRepository::class);
    }

    public static function getGroupCategoryRepository(): CGroupCategoryRepository
    {
        return self::$container->get(CGroupCategoryRepository::class);
    }

    public static function getQuestionRepository(): CQuizQuestionRepository
    {
        return self::$container->get(CQuizQuestionRepository::class);
    }

    public static function getQuestionCategoryRepository(): CQuizQuestionCategoryRepository
    {
        return self::$container->get(CQuizQuestionCategoryRepository::class);
    }

    public static function getLinkRepository(): CLinkRepository
    {
        return self::$container->get(CLinkRepository::class);
    }

    public static function getLinkCategoryRepository(): CLinkCategoryRepository
    {
        return self::$container->get(CLinkCategoryRepository::class);
    }

    public static function getLpRepository(): CLpRepository
    {
        return self::$container->get(CLpRepository::class);
    }

    public static function getLpCategoryRepository(): CLpCategoryRepository
    {
        return self::$container->get(CLpCategoryRepository::class);
    }

    public static function getNotebookRepository(): CNotebookRepository
    {
        return self::$container->get(CNotebookRepository::class);
    }

    public static function getUserRepository(): UserRepository
    {
        return self::$container->get(UserRepository::class);
    }

    public static function getIllustrationRepository(): IllustrationRepository
    {
        return self::$container->get(IllustrationRepository::class);
    }

    public static function getShortcutRepository(): CShortcutRepository
    {
        return self::$container->get(CShortcutRepository::class);
    }

    public static function getStudentPublicationRepository(): CStudentPublicationRepository
    {
        return self::$container->get(CStudentPublicationRepository::class);
    }

    public static function getStudentPublicationAssignmentRepository(): CStudentPublicationAssignmentRepository
    {
        return self::$container->get(CStudentPublicationAssignmentRepository::class);
    }

    public static function getStudentPublicationCommentRepository(): CStudentPublicationCommentRepository
    {
        return self::$container->get(CStudentPublicationCommentRepository::class);
    }

    public static function getSequenceResourceRepository(): SequenceResourceRepository
    {
        return self::$container->get(SequenceResourceRepository::class);
    }

    public static function getSequenceRepository(): SequenceRepository
    {
        return self::$container->get(SequenceRepository::class);
    }

    public static function getThematicRepository(): CThematicRepository
    {
        return self::$container->get(CThematicRepository::class);
    }

    public static function getThematicPlanRepository(): CThematicPlanRepository
    {
        return self::$container->get(CThematicPlanRepository::class);
    }

    public static function getThematicAdvanceRepository(): CThematicAdvanceRepository
    {
        return self::$container->get(CThematicAdvanceRepository::class);
    }

    /**
     * @return \Symfony\Component\Form\FormFactory
     */
    public static function getFormFactory()
    {
        return self::$container->get('form.factory');
    }

    /**
     * @param string $message
     * @param string $type    error|success|warning|danger
     */
    public static function addFlash($message, $type = 'success')
    {
        $session = self::getSession();
        $session->getFlashBag()->add($type, $message);
    }

    /**
     * @return Router
     */
    public static function getRouter()
    {
        return self::$container->get('router');
    }

    /**
     * @return ToolChain
     */
    public static function getToolChain()
    {
        return self::$container->get(ToolChain::class);
    }

    /**
     * @param ContainerInterface $container
     * @param bool               $setSession
     */
    public static function setLegacyServices($container, $setSession = true)
    {
        \Database::setConnection($container->get('doctrine.dbal.default_connection'));
        $em = $container->get('doctrine.orm.entity_manager');
        \Database::setManager($em);
        \CourseManager::setEntityManager($em);
        \CourseManager::setCourseSettingsManager($container->get('Chamilo\CourseBundle\Manager\SettingsManager'));
        // Setting course tool chain (in order to create tools to a course)
        \CourseManager::setToolList($container->get(ToolChain::class));
        if ($setSession) {
            self::$session = $container->get('session');
        }
    }
}


1			<?php
2
3			/* For licensing terms, see /license.txt */
4
5			namespace Chamilo\CoreBundle\Framework;
6
7			use Chamilo\CoreBundle\Component\Editor\Editor;
8			use Chamilo\CoreBundle\Manager\SettingsManager;
9			use Chamilo\CoreBundle\Repository\AccessUrlRepository;
10			use Chamilo\CoreBundle\Repository\CourseCategoryRepository;
11			use Chamilo\CoreBundle\Repository\CourseRepository;
12			use Chamilo\CoreBundle\Repository\IllustrationRepository;
13			use Chamilo\CoreBundle\Repository\SequenceRepository;
14			use Chamilo\CoreBundle\Repository\SequenceResourceRepository;
15			use Chamilo\CoreBundle\Repository\SessionRepository;
16			use Chamilo\CoreBundle\Repository\UserRepository;
17			use Chamilo\CoreBundle\ToolChain;
18			use Chamilo\CourseBundle\Repository\CAnnouncementAttachmentRepository;
19			use Chamilo\CourseBundle\Repository\CAnnouncementRepository;
20			use Chamilo\CourseBundle\Repository\CAttendanceRepository;
21			use Chamilo\CourseBundle\Repository\CCalendarEventAttachmentRepository;
22			use Chamilo\CourseBundle\Repository\CCalendarEventRepository;
23			use Chamilo\CourseBundle\Repository\CCourseDescriptionRepository;
24			use Chamilo\CourseBundle\Repository\CDocumentRepository;
25			use Chamilo\CourseBundle\Repository\CExerciseCategoryRepository;
26			use Chamilo\CourseBundle\Repository\CForumAttachmentRepository;
27			use Chamilo\CourseBundle\Repository\CForumCategoryRepository;
28			use Chamilo\CourseBundle\Repository\CForumForumRepository;
29			use Chamilo\CourseBundle\Repository\CForumPostRepository;
30			use Chamilo\CourseBundle\Repository\CForumThreadRepository;
31			use Chamilo\CourseBundle\Repository\CGroupCategoryRepository;
32			use Chamilo\CourseBundle\Repository\CGroupRepository;
33			use Chamilo\CourseBundle\Repository\CLinkCategoryRepository;
34			use Chamilo\CourseBundle\Repository\CLinkRepository;
35			use Chamilo\CourseBundle\Repository\CLpCategoryRepository;
36			use Chamilo\CourseBundle\Repository\CLpRepository;
37			use Chamilo\CourseBundle\Repository\CNotebookRepository;
38			use Chamilo\CourseBundle\Repository\CQuizQuestionCategoryRepository;
39			use Chamilo\CourseBundle\Repository\CQuizQuestionRepository;
40			use Chamilo\CourseBundle\Repository\CQuizRepository;
41			use Chamilo\CourseBundle\Repository\CShortcutRepository;
42			use Chamilo\CourseBundle\Repository\CStudentPublicationAssignmentRepository;
43			use Chamilo\CourseBundle\Repository\CStudentPublicationCommentRepository;
44			use Chamilo\CourseBundle\Repository\CStudentPublicationRepository;
45			use Chamilo\CourseBundle\Repository\CThematicAdvanceRepository;
46			use Chamilo\CourseBundle\Repository\CThematicPlanRepository;
47			use Chamilo\CourseBundle\Repository\CThematicRepository;
48			use Symfony\Component\DependencyInjection\ContainerInterface;
49			use Symfony\Component\HttpFoundation\Request;
50			use Symfony\Component\HttpFoundation\Session\Session;
51			use Symfony\Component\Routing\Router;
52			use Symfony\Component\Security\Core\Authorization\AuthorizationChecker;
53			use Symfony\Component\Security\Core\Role\RoleHierarchy;
54			use Symfony\Contracts\Translation\TranslatorInterface;
55			use Twig\Environment;
56
57			/**
58			* Class Container
59			* This class is a way to access Symfony2 services in legacy Chamilo code.
60			*/
61			class Container
62			{
63			/**
64			* @var ContainerInterface
65			*/
66			public static $container;
67			public static $session;
68			public static $request;
69			public static $configuration;
70			public static $environment;
71			public static $urlGenerator;
72			public static $checker;
73			/** @var TranslatorInterface */
74			public static $translator;
75			public static $mailer;
76			public static $template;
77
78			public static $rootDir;
79			public static $logDir;
80			public static $tempDir;
81			public static $dataDir;
82			public static $courseDir;
83			public static $assets;
84			public static $htmlEditor;
85			public static $twig;
86			public static $roles;
87			/** @var string */
88			public static $legacyTemplate = '@ChamiloCore/Layout/layout_one_col.html.twig';
89			//private static $settingsManager;
90			//private static $userManager;
91			//private static $siteManager;
92
93			/**
94			* @param ContainerInterface $container
95			*/
96			public static function setContainer($container)
97			{
98			self::$container = $container;
99			}
100
101			/**
102			* @param string $parameter
103			*/
104			public static function getParameter($parameter)
105			{
106			if (self::$container->hasParameter($parameter)) {
107			return self::$container->getParameter($parameter);
108			}
109
110			return false;
111			}
112
113			/**
114			* @return string
115			*/
116			public static function getEnvironment()
117			{
118			return self::$container->get('kernel')->getEnvironment();
119			}
120
121			/**
122			* @return RoleHierarchy
123			*/
124			public static function getRoles()
125			{
126			return self::$container->get('security.role_hierarchy');
127			}
128
129			/**
130			* @return string
131			*/
132			public static function getLogDir()
133			{
134			return self::$container->get('kernel')->getLogDir();
135			}
136
137			/**
138			* @return string
139			*/
140			public static function getCacheDir()
141			{
142			return self::$container->get('kernel')->getCacheDir().'/';
143			}
144
145			/**
146			* @return string
147			*/
148			public static function getProjectDir()
149			{
150			if (isset(self::$container)) {
151			return self::$container->get('kernel')->getProjectDir().'/';
152			}
153
154			return str_replace('\\', '/', realpath(__DIR__.'/../../../')).'/';
155			}
156
157			/**
158			* @return string
159			*/
160			public static function isInstalled()
161			{
162			return self::$container->get('kernel')->isInstalled();
163			}
164
165			/**
166			* @return Environment
167			*/
168			public static function getTwig()
169			{
170			return self::$container->get('twig');
171			}
172
173			/**
174			* @return Environment
175			*/
176			public static function getTemplating()
177			{
178			return self::$container->get('twig');
179			}
180
181			/**
182			* @return Editor
183			*/
184			public static function getHtmlEditor()
185			{
186			return self::$container->get('chamilo_core.html_editor');
187			}
188
189			/**
190			* @return object\|Request
191			*/
192			public static function getRequest()
193			{
194			if (null === self::$container) {
195			return null;
196			}
197
198			if (!empty(self::$request)) {
199			return self::$request;
200			}
201
202			return self::$container->get('request_stack');
203			}
204
205			/**
206			* @param Request $request
207			*/
208			public static function setRequest($request)
209			{
210			self::$request = $request;
211			}
212
213			/**
214			* @return Session\|false
215			*/
216			public static function getSession()
217			{
218			if (self::$container && self::$container->has('session')) {
219			return self::$container->get('session');
220			}
221
222			return false;
223			}
224
225			/**
226			* @return AuthorizationChecker
227			*/
228			public static function getAuthorizationChecker()
229			{
230			return self::$container->get('security.authorization_checker');
231			}
232
233			/**
234			* @return object\|\Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorage
235			*/
236			public static function getTokenStorage()
237			{
238			return self::$container->get('security.token_storage');
239			}
240
241			/**
242			* @return TranslatorInterface
243			*/
244			public static function getTranslator()
245			{
246			if (isset(self::$translator)) {
247			return self::$translator;
248			}
249
250			if (self::$container) {
251			return self::$container->get('translator');
252			}
253
254			return false;
255			}
256
257			public static function getMailer()
258			{
259			return self::$container->get('Symfony\Component\Mailer\Mailer');
260			}
261
262			public static function getSettingsManager(): SettingsManager
263			{
264			return self::$container->get('chamilo.settings.manager');
265			}
266
267			public static function getCourseSettingsManager(): \Chamilo\CourseBundle\Manager\SettingsManager
268			{
269			return self::$container->get('Chamilo\CourseBundle\Manager\SettingsManager');
270			}
271
272			/**
273			* @return \Doctrine\ORM\EntityManager
274			*/
275			public static function getEntityManager()
276			{
277			return \Database::getManager();
278			}
279
280			public static function getUserManager()
281			{
282			return self::$container->get(UserRepository::class);
283			}
284
285			public static function getAttendanceRepository(): CAttendanceRepository
286			{
287			return self::$container->get(CAttendanceRepository::class);
288			}
289
290			public static function getAnnouncementRepository(): CAnnouncementRepository
291			{
292			return self::$container->get(CAnnouncementRepository::class);
293			}
294
295			public static function getAccessUrlRepository(): AccessUrlRepository
296			{
297			return self::$container->get(AccessUrlRepository::class);
298			}
299
300			public static function getAnnouncementAttachmentRepository(): CAnnouncementAttachmentRepository
301			{
302			return self::$container->get(CAnnouncementAttachmentRepository::class);
303			}
304
305			public static function getCourseRepository(): CourseRepository
306			{
307			return self::$container->get(CourseRepository::class);
308			}
309
310			public static function getSessionRepository(): SessionRepository
311			{
312			return self::$container->get(SessionRepository::class);
313			}
314
315			public static function getCourseCategoryRepository(): CourseCategoryRepository
316			{
317			return self::$container->get(CourseCategoryRepository::class);
318			}
319
320			public static function getCourseDescriptionRepository(): CCourseDescriptionRepository
321			{
322			return self::$container->get(CCourseDescriptionRepository::class);
323			}
324
325			public static function getCalendarEventRepository(): CCalendarEventRepository
326			{
327			return self::$container->get(CCalendarEventRepository::class);
328			}
329
330			public static function getCalendarEventAttachmentRepository(): CCalendarEventAttachmentRepository
331			{
332			return self::$container->get(CCalendarEventAttachmentRepository::class);
333			}
334
335			public static function getDocumentRepository(): CDocumentRepository
336			{
337			return self::$container->get(CDocumentRepository::class);
338			}
339
340			public static function getQuizRepository(): CQuizRepository
341			{
342			return self::$container->get(CQuizRepository::class);
343			}
344
345			public static function getExerciseCategoryRepository(): CExerciseCategoryRepository
346			{
347			return self::$container->get(CExerciseCategoryRepository::class);
348			}
349
350			public static function getForumRepository(): CForumForumRepository
351			{
352			return self::$container->get(CForumForumRepository::class);
353			}
354
355			public static function getForumCategoryRepository(): CForumCategoryRepository
356			{
357			return self::$container->get(CForumCategoryRepository::class);
358			}
359
360			public static function getForumPostRepository(): CForumPostRepository
361			{
362			return self::$container->get(CForumPostRepository::class);
363			}
364
365			public static function getForumAttachmentRepository(): CForumAttachmentRepository
366			{
367			return self::$container->get(CForumAttachmentRepository::class);
368			}
369
370			public static function getForumThreadRepository(): CForumThreadRepository
371			{
372			return self::$container->get(CForumThreadRepository::class);
373			}
374
375			public static function getGroupRepository(): CGroupRepository
376			{
377			return self::$container->get(CGroupRepository::class);
378			}
379
380			public static function getGroupCategoryRepository(): CGroupCategoryRepository
381			{
382			return self::$container->get(CGroupCategoryRepository::class);
383			}
384
385			public static function getQuestionRepository(): CQuizQuestionRepository
386			{
387			return self::$container->get(CQuizQuestionRepository::class);
388			}
389
390			public static function getQuestionCategoryRepository(): CQuizQuestionCategoryRepository
391			{
392			return self::$container->get(CQuizQuestionCategoryRepository::class);
393			}
394
395			public static function getLinkRepository(): CLinkRepository
396			{
397			return self::$container->get(CLinkRepository::class);
398			}
399
400			public static function getLinkCategoryRepository(): CLinkCategoryRepository
401			{
402			return self::$container->get(CLinkCategoryRepository::class);
403			}
404
405			public static function getLpRepository(): CLpRepository
406			{
407			return self::$container->get(CLpRepository::class);
408			}
409
410			public static function getLpCategoryRepository(): CLpCategoryRepository
411			{
412			return self::$container->get(CLpCategoryRepository::class);
413			}
414
415			public static function getNotebookRepository(): CNotebookRepository
416			{
417			return self::$container->get(CNotebookRepository::class);
418			}
419
420			public static function getUserRepository(): UserRepository
421			{
422			return self::$container->get(UserRepository::class);
423			}
424
425			public static function getIllustrationRepository(): IllustrationRepository
426			{
427			return self::$container->get(IllustrationRepository::class);
428			}
429
430			public static function getShortcutRepository(): CShortcutRepository
431			{
432			return self::$container->get(CShortcutRepository::class);
433			}
434
435			public static function getStudentPublicationRepository(): CStudentPublicationRepository
436			{
437			return self::$container->get(CStudentPublicationRepository::class);
438			}
439
440			public static function getStudentPublicationAssignmentRepository(): CStudentPublicationAssignmentRepository
441			{
442			return self::$container->get(CStudentPublicationAssignmentRepository::class);
443			}
444
445			public static function getStudentPublicationCommentRepository(): CStudentPublicationCommentRepository
446			{
447			return self::$container->get(CStudentPublicationCommentRepository::class);
448			}
449
450			public static function getSequenceResourceRepository(): SequenceResourceRepository
451			{
452			return self::$container->get(SequenceResourceRepository::class);
453			}
454
455			public static function getSequenceRepository(): SequenceRepository
456			{
457			return self::$container->get(SequenceRepository::class);
458			}
459
460			public static function getThematicRepository(): CThematicRepository
461			{
462			return self::$container->get(CThematicRepository::class);
463			}
464
465			public static function getThematicPlanRepository(): CThematicPlanRepository
466			{
467			return self::$container->get(CThematicPlanRepository::class);
468			}
469
470			public static function getThematicAdvanceRepository(): CThematicAdvanceRepository
471			{
472			return self::$container->get(CThematicAdvanceRepository::class);
473			}
474
475			/**
476			* @return \Symfony\Component\Form\FormFactory
477			*/
478			public static function getFormFactory()
479			{
480			return self::$container->get('form.factory');
481			}
482
483			/**
484			* @param string $message
485			* @param string $type error\|success\|warning\|danger
486			*/
487			public static function addFlash($message, $type = 'success')
488			{
489			$session = self::getSession();
490			$session->getFlashBag()->add($type, $message);
491			}
492
493			/**
494			* @return Router
495			*/
496			public static function getRouter()
497			{
498			return self::$container->get('router');
499			}
500
501			/**
502			* @return ToolChain
503			*/
504			public static function getToolChain()
505			{
506			return self::$container->get(ToolChain::class);
507			}
508
509			/**
510			* @param ContainerInterface $container
511			* @param bool $setSession
512			*/
513			public static function setLegacyServices($container, $setSession = true)
514			{
515			\Database::setConnection($container->get('doctrine.dbal.default_connection'));
516			$em = $container->get('doctrine.orm.entity_manager');
517			\Database::setManager($em);
518			\CourseManager::setEntityManager($em);
519			\CourseManager::setCourseSettingsManager($container->get('Chamilo\CourseBundle\Manager\SettingsManager'));
520			// Setting course tool chain (in order to create tools to a course)
521			\CourseManager::setToolList($container->get(ToolChain::class));
522			if ($setSession) {
523			self::$session = $container->get('session');
524			}
525			}
526			}
527

chamilo / chamilo-lms

Push — master ( 7ade69...469b77 )

Container::getQuestionRepository() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like