Container::getAnnouncementRepository() - Code Metrics - Inspection of "Update psalm.xml" - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( ab8dec...906584 )

by Julito

created 2021-02-03 10:06 UTC

Container::getAnnouncementRepository() 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
nc	1
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?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\AssetRepository;
use Chamilo\CoreBundle\Repository\CourseCategoryRepository;
use Chamilo\CoreBundle\Repository\Node\AccessUrlRepository;
use Chamilo\CoreBundle\Repository\Node\CourseRepository;
use Chamilo\CoreBundle\Repository\Node\IllustrationRepository;
use Chamilo\CoreBundle\Repository\Node\MessageAttachmentRepository;
use Chamilo\CoreBundle\Repository\Node\UserRepository;
use Chamilo\CoreBundle\Repository\SequenceRepository;
use Chamilo\CoreBundle\Repository\SequenceResourceRepository;
use Chamilo\CoreBundle\Repository\SessionRepository;
use Chamilo\CoreBundle\ToolChain;
use Chamilo\CourseBundle\Repository\CAnnouncementAttachmentRepository;
use Chamilo\CourseBundle\Repository\CAnnouncementRepository;
use Chamilo\CourseBundle\Repository\CAttendanceRepository;
use Chamilo\CourseBundle\Repository\CBlogRepository;
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\CGlossaryRepository;
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\CStudentPublicationCorrectionRepository;
use Chamilo\CourseBundle\Repository\CStudentPublicationRepository;
use Chamilo\CourseBundle\Repository\CSurveyQuestionRepository;
use Chamilo\CourseBundle\Repository\CSurveyRepository;
use Chamilo\CourseBundle\Repository\CThematicAdvanceRepository;
use Chamilo\CourseBundle\Repository\CThematicPlanRepository;
use Chamilo\CourseBundle\Repository\CThematicRepository;
use Chamilo\CourseBundle\Repository\CWikiRepository;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\Form\FormFactory;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Session\Session;
use Symfony\Component\Mailer\Mailer;
use Symfony\Component\Routing\Router;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorage;
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';

    /**
     * @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');
    }

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

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

    /**
     * @return string
     */
    public static function getProjectDir()
    {
        if (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::$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 TokenStorage
     */
    public static function getTokenStorage()
    {
        return self::$container->get('security.token_storage');
    }

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

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

        return false;
    }

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

    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::class);
    }

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

    public static function getUserManager(): UserRepository
    {
        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 getGlossaryRepository(): CGlossaryRepository
    {
        return self::$container->get(CGlossaryRepository::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 getMessageAttachmentRepository(): MessageAttachmentRepository
    {
        return self::$container->get(MessageAttachmentRepository::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 getStudentPublicationCorrectionRepository(): CStudentPublicationCorrectionRepository
    {
        return self::$container->get(CStudentPublicationCorrectionRepository::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 getSurveyRepository(): CSurveyRepository
    {
        return self::$container->get(CSurveyRepository::class);
    }

    public static function getSurveyQuestionRepository(): CSurveyQuestionRepository
    {
        return self::$container->get(CSurveyQuestionRepository::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);
    }

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

    public static function getWikiRepository(): CBlogRepository
    {
        return self::$container->get(CWikiRepository::class);
    }

    public static function getFormFactory(): FormFactory
    {
        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);
    }

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

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

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

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

chamilo / chamilo-lms

Push — master ( ab8dec...906584 )

Container::getAnnouncementRepository() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like