Lines 91.56% 890 / 972
Methods 71.05% 27 / 38
Classes 0.00% 0 / 1
Covered by tests of size
Name Lines Methods CRAP
 __construct 100.00% 1 / 1 100.00% 1 / 1 1
 index 100.00% 36 / 36 100.00% 1 / 1 3
 add 100.00% 14 / 14 100.00% 1 / 1 1
 addChild 100.00% 27 / 27 100.00% 1 / 1 2
 create 75.86% 88 / 116 0.00% 0 / 1 16.76
 edit 100.00% 66 / 66 100.00% 1 / 1 8
 hierarchy 85.00% 34 / 40 0.00% 0 / 1 4.05
 translate 100.00% 36 / 36 100.00% 1 / 1 1
 update 80.55% 145 / 180 0.00% 0 / 1 28.23
 getBaseTemplateVars 100.00% 14 / 14 100.00% 1 / 1 2
 [phpMyFAQ\Controller\Administration\AbstractAdministrationController] initializeFromContainer 80.00% 4 / 5 0.00% 0 / 1 2.03
 [phpMyFAQ\Controller\Administration\AbstractAdministrationController] render 100.00% 4 / 4 100.00% 1 / 1 1
 [phpMyFAQ\Controller\Administration\AbstractAdministrationController] getHeader 97.91% 47 / 48 0.00% 0 / 1 3
 [phpMyFAQ\Controller\Administration\AbstractAdministrationController] getSecondLevelEntries 100.00% 156 / 156 100.00% 1 / 1 6
 [phpMyFAQ\Controller\Administration\AbstractAdministrationController] getPageFlags 100.00% 87 / 87 100.00% 1 / 1 61
 [phpMyFAQ\Controller\Administration\AbstractAdministrationController] getGravatarImage 100.00% 8 / 8 100.00% 1 / 1 4
 [phpMyFAQ\Controller\Administration\AbstractAdministrationController] userHasPermission 100.00% 2 / 2 100.00% 1 / 1 1
 [phpMyFAQ\Controller\Administration\AbstractAdministrationController] getFooter 100.00% 12 / 12 100.00% 1 / 1 1
 [phpMyFAQ\Controller\AbstractController] setContainer 100.00% 2 / 2 100.00% 1 / 1 1
 [phpMyFAQ\Controller\AbstractController] renderView 0.00% 0 / 3 0.00% 0 / 1 2
 [phpMyFAQ\Controller\AbstractController] json 100.00% 1 / 1 100.00% 1 / 1 1
 [phpMyFAQ\Controller\AbstractController] getJsonObject 75.00% 3 / 4 0.00% 0 / 1 2.06
 [phpMyFAQ\Controller\AbstractController] getTwigWrapper 100.00% 10 / 10 100.00% 1 / 1 3
 [phpMyFAQ\Controller\AbstractController] hasValidToken 85.71% 6 / 7 0.00% 0 / 1 5.07
 [phpMyFAQ\Controller\AbstractController] isSecured 100.00% 10 / 10 100.00% 1 / 1 5
 [phpMyFAQ\Controller\AbstractController] isPublicAuthenticationPath 100.00% 23 / 23 100.00% 1 / 1 1
 [phpMyFAQ\Controller\AbstractController] userIsAuthenticated 100.00% 2 / 2 100.00% 1 / 1 2
 [phpMyFAQ\Controller\AbstractController] userIsSuperAdmin 100.00% 2 / 2 100.00% 1 / 1 2
 [phpMyFAQ\Controller\AbstractController] userHasGroupPermission 100.00% 8 / 8 100.00% 1 / 1 6
 [phpMyFAQ\Controller\AbstractController] userHasUserPermission 100.00% 7 / 7 100.00% 1 / 1 5
 [phpMyFAQ\Controller\AbstractController] userHasAnyPermission 100.00% 10 / 10 100.00% 1 / 1 4
 [phpMyFAQ\Controller\AbstractController] verifySessionCsrfToken 70.00% 7 / 10 0.00% 0 / 1 4.43
 [phpMyFAQ\Controller\AbstractController] captchaCodeIsValid 85.71% 6 / 7 0.00% 0 / 1 2.01
 [phpMyFAQ\Controller\AbstractController] isApiEnabled 100.00% 1 / 1 100.00% 1 / 1 1
 [phpMyFAQ\Controller\AbstractController] addExtension 100.00% 1 / 1 100.00% 1 / 1 1
 [phpMyFAQ\Controller\AbstractController] addFilter 100.00% 1 / 1 100.00% 1 / 1 1
 [phpMyFAQ\Controller\AbstractController] getRateLimiter 100.00% 4 / 4 100.00% 1 / 1 3
 [phpMyFAQ\Controller\AbstractController] createFallbackContainer 71.42% 5 / 7 0.00% 0 / 1 2.09
50final class CategoryController extends AbstractAdministrationController
51{
52    public function __construct(
53        private readonly AdminCategory $adminCategory,
54        private readonly Order $categoryOrder,
55        private readonly CategoryPermission $categoryPermission,
56        private readonly Image $categoryImage,
57        private readonly Seo $seo,
58        private readonly UserHelper $userHelper,
59    ) {
60        parent::__construct();
61    }
62
63    /**
64     * @throws Exception
65     * @throws LoaderError
66     * @throws \Exception
67     */
68    #[Route(path: '/category', name: 'admin.category', methods: ['GET'])]
69    public function index(Request $request): Response
70    {
71        $this->userHasPermission(PermissionType::CATEGORY_EDIT);
72
73        $currentUserId = $this->currentUser->getUserId();
74
75        $category = new Category($this->configuration, [], withPermission: false);
76        $category->buildCategoryTree();
77
78        $categoryInfo = $category->getAllCategories();
79
80        $orderedCategories = $this->categoryOrder->getAllCategories();
81        $categoryTree = $this->categoryOrder->getCategoryTree($orderedCategories);
82
83        if (in_array($categoryTree, [[], null, false], strict: true)) {
84            // Fallback if no category order is available
85            $categoryTree = $category->buildAdminCategoryTree($categoryInfo);
86        }
87
88        // Per-category translation state for the badge + popover (same source as hierarchy())
89        $categoryLanguageService = new CategoryLanguageService();
90        $allLanguages = $categoryLanguageService->getLanguagesInUse($this->configuration);
91        $allTranslations = $categoryLanguageService->getAllExistingTranslations($this->configuration);
92        $categoryTranslations = [];
93        foreach (array_keys($categoryInfo) as $categoryId) {
94            $categoryTranslations[$categoryId] = $allTranslations[(int) $categoryId] ?? [];
95        }
96
97        return $this->render(file: '@admin/content/category.overview.twig', context: [
98            ...$this->getHeader($request),
99            ...$this->getFooter(),
100            'csrfTokenInput' => Token::getInstance($this->session)->getTokenInput(page: 'category'),
101            'categoryTree' => $categoryTree,
102            'categoryInfo' => $categoryInfo,
103            'categoryTranslations' => $categoryTranslations,
104            'allLanguages' => $allLanguages,
105            'permissionAddCategory' => $this->currentUser->perm->hasPermission(
106                $currentUserId,
107                PermissionType::CATEGORY_ADD->value,
108            ),
109            'permissionDeleteCategory' => $this->currentUser->perm->hasPermission(
110                $currentUserId,
111                PermissionType::CATEGORY_DELETE->value,
112            ),
113            'permissionAddFaq' => $this->currentUser->perm->hasPermission(
114                $currentUserId,
115                PermissionType::FAQ_ADD->value,
116            ),
117        ]);
118    }
119
120    /**
121     * @throws Exception
122     * @throws LoaderError
123     * @throws \Exception
124     */
125    #[Route(path: '/category/add', name: 'admin.category.add', methods: ['GET'])]
126    public function add(Request $request): Response
127    {
128        $this->userHasPermission(PermissionType::CATEGORY_ADD);
129
130        [$currentAdminUser, $currentAdminGroups] = CurrentUser::getCurrentUserGroupId($this->currentUser);
131
132        $this->adminCategory->setUser($currentAdminUser);
133        $this->adminCategory->setGroups($currentAdminGroups);
134        $this->adminCategory->setLanguage($this->configuration->getLanguage()->getLanguage());
135        $this->adminCategory->loadCategories();
136
137        return $this->render(file: '@admin/content/category.add.twig', context: [
138            ...$this->getHeader($request),
139            ...$this->getFooter(),
140            ...$this->getBaseTemplateVars(),
141            'csrfTokenInput' => Token::getInstance($this->session)->getTokenInput(page: 'save-category'),
142            'faqLangCode' => $this->configuration->getLanguage()->getLanguage(),
143            'parentId' => 0,
144        ]);
145    }
146
147    /**
148     * @throws Exception
149     * @throws LoaderError
150     * @throws \Exception
151     */
152    #[Route(path: '/category/add/{parentId}/{language}', name: 'admin.category.add.child', methods: ['GET'])]
153    public function addChild(Request $request): Response
154    {
155        $this->userHasPermission(PermissionType::CATEGORY_ADD);
156
157        [$currentAdminUser, $currentAdminGroups] = CurrentUser::getCurrentUserGroupId($this->currentUser);
158
159        $this->adminCategory->setUser($currentAdminUser);
160        $this->adminCategory->setGroups($currentAdminGroups);
161        $this->adminCategory->setLanguage($this->configuration->getLanguage()->getLanguage());
162        $this->adminCategory->loadCategories();
163
164        $parentId = (int) Filter::filterVar($request->attributes->get(key: 'parentId'), FILTER_VALIDATE_INT);
165
166        $templateVars = [];
167        if ($this->currentUser->perm instanceof MediumPermission) {
168            $templateVars = [
169                'groupsOptions' => $this->currentUser->perm->getAllGroupsOptions([], $this->currentUser),
170            ];
171        }
172
173        return $this->render(file: '@admin/content/category.add.twig', context: [
174            ...$this->getHeader($request),
175            ...$this->getFooter(),
176            ...$this->getBaseTemplateVars(),
177            'faqLangCode' => $this->configuration->getLanguage()->getLanguage(),
178            'parentId' => $parentId,
179            'categoryNameLangCode' => LanguageCodes::get(
180                (string) ($this->adminCategory->categoryName[$parentId]['lang'] ?? 'en'),
181            ),
182            'userAllowed' => $this->categoryPermission->get(CategoryPermission::USER, [$parentId])[0] ?? -1,
183            'groupsAllowed' => $this->categoryPermission->get(CategoryPermission::GROUP, [$parentId]),
184            'categoryName' => $this->adminCategory->categoryName[$parentId]['name'],
185            'msgMainCategory' => Translation::get(key: 'msgMainCategory'),
186            ...$templateVars,
187        ]);
188    }
189
190    /**
191     * @throws Exception
192     * @throws LoaderError
193     * @throws \Exception
194     */
195    #[Route(path: '/category/create', name: 'admin.category.create', methods: ['POST'])]
196    public function create(Request $request): Response
197    {
198        $this->userHasPermission(PermissionType::CATEGORY_ADD);
199
200        $csrfToken = Filter::filterVar($request->request->get(key: 'pmf-csrf-token'), FILTER_SANITIZE_SPECIAL_CHARS);
201        if (!Token::getInstance($this->session)->verifyToken(page: 'save-category', requestToken: $csrfToken)) {
202            throw new Exception('Invalid CSRF token');
203        }
204
205        [$currentAdminUser, $currentAdminGroups] = CurrentUser::getCurrentUserGroupId($this->currentUser);
206
207        $categoryPermission = new CategoryPermission($this->configuration);
208        $seo = $this->seo;
209
210        $category = new Category($this->configuration, [], false);
211        $category->setUser($currentAdminUser);
212        $category->setGroups($currentAdminGroups);
213
214        $parentId = (int) Filter::filterVar($request->request->get(key: 'parent_id'), FILTER_VALIDATE_INT);
215        $categoryId = $this->configuration->getDb()->nextId(Database::getTablePrefix() . 'faqcategories', 'id');
216        $categoryLang = Filter::filterVar($request->request->get(key: 'lang'), FILTER_SANITIZE_SPECIAL_CHARS, '');
217
218        $uploadedFile = $request->files->get('image') ?? [];
219        if ($uploadedFile instanceof UploadedFile) {
220            $this->categoryImage->setUploadedFile($uploadedFile);
221        }
222
223        $hasUploadedImage = $uploadedFile instanceof UploadedFile;
224
225        $categoryEntity = new CategoryEntity();
226        $categoryEntity
227            ->setParentId($parentId)
228            ->setLang($categoryLang)
229            ->setName(Filter::filterVar($request->request->get(key: 'name'), FILTER_SANITIZE_SPECIAL_CHARS, ''))
230            ->setDescription(Filter::filterVar(
231                $request->request->get(key: 'description'),
232                FILTER_SANITIZE_SPECIAL_CHARS,
233            ))
234            ->setUserId(Filter::filterVar($request->request->get(key: 'user_id'), FILTER_VALIDATE_INT) ?? -1)
235            ->setGroupId(Filter::filterVar($request->request->get(key: 'group_id'), FILTER_VALIDATE_INT) ?? -1)
236            ->setActive((bool) Filter::filterVar($request->request->get(key: 'active'), FILTER_VALIDATE_INT))
237            ->setImage($hasUploadedImage ? $this->categoryImage->getFileName($categoryId, $categoryLang) : '')
238            ->setParentId($parentId)
239            ->setShowHome((bool) Filter::filterVar($request->request->get(key: 'show_home'), FILTER_VALIDATE_INT));
240
241        $permissions = [
242            'restricted_user' => [],
243            'restricted_groups' => [],
244        ];
245        $userPermissionMode = Filter::filterVar(
246            $request->request->get(key: 'userpermission'),
247            FILTER_SANITIZE_SPECIAL_CHARS,
248        );
249        if ('all' === $userPermissionMode) {
250            $permissions['restricted_user'] = [-1];
251        }
252
253        if ('all' !== $userPermissionMode) {
254            $restrictedUser = Filter::filterVar($request->request->get(key: 'restricted_users'), FILTER_VALIDATE_INT);
255            $permissions['restricted_user'] = $restrictedUser === null ? [] : [$restrictedUser];
256        }
257
258        $groupPermissionMode = Filter::filterVar(
259            $request->request->get(key: 'grouppermission'),
260            FILTER_SANITIZE_SPECIAL_CHARS,
261        );
262        if ('all' === $groupPermissionMode) {
263            $permissions['restricted_groups'] = [-1];
264        }
265
266        if ('all' !== $groupPermissionMode) {
267            $restrictedGroups = $request->request->all(key: 'restricted_groups');
268            $permissions['restricted_groups'] = array_values(array_filter(
269                array_map(static fn($value): ?int => Filter::filterVar($value, FILTER_VALIDATE_INT), $restrictedGroups),
270                static fn($value): bool => $value !== null,
271            ));
272        }
273
274        $templateVars = [
275            'msgHeaderCategoryMain' => Translation::get(key: 'msgHeaderCategoryOverview'),
276        ];
277
278        if ($category->checkIfCategoryExists($categoryEntity) > 0) {
279            $templateVars = [
280                ...$templateVars,
281                'isError' => true,
282                'errorMessage' => Translation::get(key: 'ad_categ_existing'),
283            ];
284        }
285
286        $categoryId = $category->create($categoryEntity);
287
288        if ($categoryId) {
289            $categoryPermission->add(CategoryPermission::USER, [$categoryId], $permissions['restricted_user']);
290            $categoryPermission->add(CategoryPermission::GROUP, [$categoryId], $permissions['restricted_groups']);
291
292            if ($hasUploadedImage) {
293                try {
294                    $this->categoryImage->upload();
295                } catch (Throwable $exception) {
296                    $templateVars = [
297                        ...$templateVars,
298                        'isWarning' => true,
299                        'warningMessage' => $exception->getMessage(),
300                    ];
301                }
302            }
303
304            // Category Order entry
305            $this->categoryOrder->add($categoryId, $parentId);
306
307            // SEO data
308            $seoEntity = new SeoEntity();
309            $seoEntity
310                ->setSeoType(SeoType::CATEGORY)
311                ->setReferenceId($categoryId)
312                ->setReferenceLanguage($categoryLang)
313                ->setTitle(Filter::filterVar(
314                    $request->request->get(key: 'serpTitle'),
315                    FILTER_SANITIZE_SPECIAL_CHARS,
316                    '',
317                ))
318                ->setDescription(Filter::filterVar(
319                    $request->request->get(key: 'serpDescription'),
320                    FILTER_SANITIZE_SPECIAL_CHARS,
321                    '',
322                ));
323            $seo->create($seoEntity);
324
325            // Admin Log
326            $this->adminLog->log($this->currentUser, AdminLogType::CATEGORY_ADD->value . ':' . $categoryId);
327
328            $templateVars = [
329                ...$templateVars,
330                'isSuccess' => true,
331                'successMessage' => Translation::get(key: 'ad_categ_added'),
332            ];
333        }
334
335        if (!$categoryId) {
336            $this->configuration->getLogger()->error('Failed to add category', [
337                'sqlError' => $this->configuration->getDb()->error(),
338            ]);
339
340            $templateVars = [
341                ...$templateVars,
342                'isError' => true,
343                'errorMessage' => Translation::get(key: 'ad_msg_mysqlerr'),
344            ];
345        }
346
347        return $this->render(file: '@admin/content/category.main.twig', context: [
348            ...$this->getHeader($request),
349            ...$this->getFooter(),
350            ...$this->getBaseTemplateVars(),
351            ...$templateVars,
352        ]);
353    }
354
355    /**
356     * @throws Exception
357     * @throws LoaderError
358     * @throws \Exception
359     */
360    #[Route(path: '/category/edit/{categoryId}', name: 'admin.category.edit', methods: ['GET'])]
361    public function edit(Request $request): Response
362    {
363        $this->userHasPermission(PermissionType::CATEGORY_EDIT);
364
365        [$currentAdminUser, $currentAdminGroups] = CurrentUser::getCurrentUserGroupId($this->currentUser);
366
367        $categoryId = (int) Filter::filterVar(
368            $request->attributes->get(key: 'categoryId'),
369            FILTER_VALIDATE_INT,
370            default: 0,
371        );
372
373        $category = new Category($this->configuration, [], withPermission: false);
374        $category
375            ->setUser($currentAdminUser)
376            ->setGroups($currentAdminGroups)
377            ->setLanguage($this->configuration->getLanguage()->getLanguage());
378
379        $categoryEntity = $category->getCategoryData($categoryId);
380
381        $seoEntity = new SeoEntity();
382        $seoEntity->setSeoType(SeoType::CATEGORY);
383        $seoEntity->setReferenceId($categoryId);
384        $seoEntity->setReferenceLanguage($categoryEntity->getLang());
385
386        $seoData = $this->seo->get($seoEntity);
387
388        $userPermission = $this->categoryPermission->get(CategoryPermission::USER, [$categoryId]);
389        $allUsers = $userPermission[0] === -1;
390        $restrictedUsers = !$allUsers;
391
392        $groupPermission = $this->categoryPermission->get(CategoryPermission::GROUP, [$categoryId]);
393        $allGroups = $groupPermission[0] === -1;
394        $restrictedGroups = !$allGroups;
395
396        $header =
397            Translation::getString(key: 'ad_categ_edit_1')
398            . ' "'
399            . $categoryEntity->getName()
400            . '" '
401            . Translation::getString(key: 'ad_categ_edit_2');
402
403        $allGroupsOptions = '';
404        $restrictedGroupOptions = '';
405        $permission = $this->currentUser->perm;
406        if ($permission instanceof MediumPermission) {
407            $allGroupsOptions = $permission->getAllGroupsOptions([$categoryEntity->getGroupId()], $this->currentUser);
408            $restrictedGroupOptions = $permission->getAllGroupsOptions($groupPermission, $this->currentUser);
409        }
410
411        return $this->render(file: '@admin/content/category.edit.twig', context: [
412            ...$this->getHeader($request),
413            ...$this->getFooter(),
414            'header' => $header,
415            'categoryId' => $categoryId,
416            'categoryLanguage' => $categoryEntity->getLang(),
417            'parentId' => $categoryEntity->getParentId(),
418            'csrfInputToken' => Token::getInstance($this->session)->getTokenInput(page: 'update-category'),
419            'categoryImage' => $categoryEntity->getImage(),
420            'categoryName' => $categoryEntity->getName(),
421            'categoryDescription' => $categoryEntity->getDescription(),
422            'categoryActive' => 1 === (int) $categoryEntity->getActive() ? 'checked' : '',
423            'categoryShowHome' => 1 === (int) $categoryEntity->getShowHome() ? 'checked' : '',
424            'categoryImageReset' => Translation::get(key: 'msgCategoryImageReset'),
425            'userSelection' => $this->userHelper->getAllUsersForTemplate($categoryEntity->getUserId()),
426            'isMediumPermission' => $this->configuration->get(item: 'security.permLevel') !== 'basic',
427            'allGroupsOptions' => $allGroupsOptions,
428            'allGroups' => $allGroups ? 'checked' : '',
429            'restrictedGroups' => $restrictedGroups ? 'checked' : '',
430            'restrictedGroupsLabel' => Translation::get(key: 'ad_entry_restricted_groups'),
431            'restrictedGroupsOptions' => $restrictedGroupOptions,
432            'userPermissionLabel' => Translation::get(key: 'ad_entry_userpermission'),
433            'allUsers' => $allUsers ? 'checked' : '',
434            'restrictedUsers' => $restrictedUsers ? 'checked' : '',
435            'restrictedUsersLabel' => Translation::get(key: 'ad_entry_restricted_users'),
436            'serpTitle' => $seoData->getTitle(),
437            'serpDescription' => $seoData->getDescription(),
438            'buttonCancel' => Translation::get(key: 'ad_gen_cancel'),
439            'buttonUpdate' => Translation::get(key: 'ad_gen_save'),
440        ]);
441    }
442
443    /**
444     * @throws Exception
445     * @throws LoaderError
446     * @throws \Exception
447     */
448    #[Route(path: '/category/hierarchy', name: 'admin.category.hierarchy', methods: ['GET'])]
449    public function hierarchy(Request $request): Response
450    {
451        $this->userHasPermission(PermissionType::CATEGORY_EDIT);
452
453        [$currentAdminUser, $currentAdminGroups] = CurrentUser::getCurrentUserGroupId($this->currentUser);
454
455        $category = new Category($this->configuration, [], withPermission: false);
456        $category->setUser($currentAdminUser);
457        $category->setGroups($currentAdminGroups);
458
459        $category->getMissingCategories();
460        $category->buildCategoryTree();
461
462        $currentLangCode = $this->configuration->getLanguage()->getLanguage();
463        $currentLanguage = LanguageCodes::get($currentLangCode);
464
465        // get languages in use for all categories via service
466        $categoryLanguageService = new CategoryLanguageService();
467        $languages = $categoryLanguageService->getLanguagesInUse($this->configuration); // [code => name]
468
469        $translations = [];
470        foreach ($category->getCategoryTree() as $cat) {
471            $categoryTreeId = (int) ($cat['id'] ?? 0);
472            // [code => name]
473            $existing = $categoryLanguageService->getExistingTranslations($this->configuration, $categoryTreeId);
474            $translations[$categoryTreeId] = array_keys($existing);
475        }
476
477        // Build language codes list: current first
478        $languageCodes = [$currentLangCode];
479        foreach (array_keys($languages) as $code) {
480            if ($code === $currentLangCode) {
481                continue;
482            }
483
484            $languageCodes[] = $code;
485        }
486
487        return $this->render(file: '@admin/content/category.hierarchy.twig', context: [
488            ...$this->getHeader($request),
489            ...$this->getFooter(),
490            'currentLanguage' => $currentLanguage,
491            'allLangs' => $languages,
492            'allLangCodes' => $languageCodes,
493            'categoryTree' => $category->getCategoryTree(),
494            'basePath' => $request->getBasePath(),
495            'faqlangcode' => $currentLangCode,
496            'msgCategoryRemark_overview' => Translation::get(key: 'msgCategoryRemark_overview'),
497            'categoryNameLabel' => Translation::get(key: 'categoryNameLabel'),
498            'ad_categ_translate' => Translation::get(key: 'ad_categ_translate'),
499            'ad_menu_categ_structure' => Translation::get(key: 'ad_menu_categ_structure'),
500            'msgAddCategory' => Translation::get(key: 'msgAddCategory'),
501            'msgHeaderCategoryOverview' => Translation::get(key: 'msgHeaderCategoryOverview'),
502            'msgCategory' => Translation::get(key: 'msgCategory'),
503            'translations' => $translations,
504            'ad_categ_translated' => Translation::get(key: 'ad_categ_translated'),
505        ]);
506    }
507
508    /**
509     * @throws Exception
510     * @throws LoaderError
511     * @throws \Exception
512     */
513    #[Route(path: '/category/translate/{categoryId}', name: 'admin.category.translate', methods: ['GET'])]
514    public function translate(Request $request): Response
515    {
516        $this->userHasPermission(PermissionType::CATEGORY_EDIT);
517
518        [$currentAdminUser, $currentAdminGroups] = CurrentUser::getCurrentUserGroupId($this->currentUser);
519
520        $categoryPermission = new CategoryPermission($this->configuration);
521        $userHelper = new UserHelper($this->currentUser);
522
523        $category = new Category($this->configuration, [], withPermission: false);
524        $category->setUser($currentAdminUser);
525        $category->setGroups($currentAdminGroups);
526
527        $categoryId = (int) Filter::filterVar($request->attributes->get(key: 'categoryId'), FILTER_VALIDATE_INT);
528        $translateTo = Filter::filterVar($request->query->get(key: 'translateTo'), FILTER_SANITIZE_SPECIAL_CHARS);
529
530        // Re-add permission arrays used in the template
531        $userPermission = $this->categoryPermission->get(CategoryPermission::USER, [$categoryId]);
532        $groupPermission = $this->categoryPermission->get(CategoryPermission::GROUP, [$categoryId]);
533
534        // Prepare language selection data via service
535        $categoryLanguageService = new CategoryLanguageService();
536        $toTranslate = $categoryLanguageService->getLanguagesToTranslate($this->configuration, $categoryId);
537
538        return $this->render(file: '@admin/content/category.translate.twig', context: [
539            ...$this->getHeader($request),
540            ...$this->getFooter(),
541            'categoryName' => $category->getCategoryName($categoryId),
542            'ad_categ_trans_1' => Translation::get(key: 'ad_categ_trans_1'),
543            'ad_categ_trans_2' => Translation::get(key: 'ad_categ_trans_2'),
544            'categoryId' => $categoryId,
545            'category' => $category->getCategoryName($categoryId),
546            'permLevel' => $this->configuration->get(item: 'security.permLevel'),
547            'groupPermission' => $groupPermission[0] ?? -1,
548            'userPermission' => $userPermission[0] ?? -1,
549            'csrfInputToken' => Token::getInstance($this->session)->getTokenInput(page: 'update-category'),
550            'categoryNameLabel' => Translation::get(key: 'categoryNameLabel'),
551            'ad_categ_lang' => Translation::get(key: 'ad_categ_lang'),
552            'languagesToTranslate' => $toTranslate,
553            'selectedLanguage' => $translateTo ?? '',
554            'categoryDescriptionLabel' => Translation::get(key: 'categoryDescriptionLabel'),
555            'categoryOwnerLabel' => Translation::get(key: 'categoryOwnerLabel'),
556            'userSelection' => $userHelper->getAllUsersForTemplate($category->getOwner($categoryId)),
557            'ad_categ_transalready' => Translation::get(key: 'ad_categ_transalready'),
558            'langTranslated' => $category->getCategoryLanguagesTranslated($categoryId),
559            'ad_categ_translatecateg' => Translation::get(key: 'ad_categ_translatecateg'),
560        ]);
561    }
562
563    /**
564     * @throws Exception
565     * @throws LoaderError
566     * @throws \Exception
567     */
568    #[Route(path: '/category/update', name: 'admin.category.update', methods: ['POST'])]
569    public function update(Request $request): Response
570    {
571        $this->userHasPermission(PermissionType::CATEGORY_EDIT);
572
573        $csrfToken = Filter::filterVar($request->request->get(key: 'pmf-csrf-token'), FILTER_SANITIZE_SPECIAL_CHARS);
574        if (!Token::getInstance($this->session)->verifyToken(page: 'update-category', requestToken: $csrfToken)) {
575            throw new Exception(message: 'Invalid CSRF token');
576        }
577
578        [$currentAdminUser, $currentAdminGroups] = CurrentUser::getCurrentUserGroupId($this->currentUser);
579
580        $categoryPermission = new CategoryPermission($this->configuration);
581
582        $category = new Category($this->configuration, [], withPermission: false);
583        $category->setUser($currentAdminUser);
584        $category->setGroups($currentAdminGroups);
585
586        $parentId = (int) Filter::filterVar($request->request->get(key: 'parent_id'), FILTER_VALIDATE_INT);
587        $categoryId = (int) Filter::filterVar($request->request->get(key: 'id'), FILTER_VALIDATE_INT);
588        $categoryLang = Filter::filterVar($request->request->get(key: 'catlang'), FILTER_SANITIZE_SPECIAL_CHARS, '');
589        $existingImage = Filter::filterVar(
590            $request->request->get(key: 'existing_image'),
591            FILTER_SANITIZE_SPECIAL_CHARS,
592        );
593
594        $uploadedFile = $request->files->get(key: 'image') ?? [];
595        if ($uploadedFile instanceof UploadedFile) {
596            $this->categoryImage->setUploadedFile($uploadedFile);
597        }
598
599        // Strip any path components: the category image is always a bare file
600        // name inside the upload directory. This prevents traversal sequences
601        // (e.g. "../") from being stored and later passed to Image::delete().
602        $existingImage = is_null($existingImage) ? '' : basename((string) $existingImage);
603        $hasUploadedImage = $uploadedFile instanceof UploadedFile;
604        $image = $hasUploadedImage ? $this->categoryImage->getFileName($categoryId, $categoryLang) : $existingImage;
605
606        $categoryEntity = new CategoryEntity();
607        $categoryEntity
608            ->setId($categoryId)
609            ->setLang($categoryLang)
610            ->setParentId($parentId)
611            ->setName(Filter::filterVar($request->request->get(key: 'name'), FILTER_SANITIZE_SPECIAL_CHARS, ''))
612            ->setDescription(Filter::filterVar(
613                $request->request->get(key: 'description'),
614                FILTER_SANITIZE_SPECIAL_CHARS,
615            ))
616            ->setUserId((int) Filter::filterVar($request->request->get(key: 'user_id'), FILTER_VALIDATE_INT))
617            ->setGroupId((int) Filter::filterVar($request->request->get(key: 'group_id'), FILTER_VALIDATE_INT) ?? -1)
618            ->setActive((bool) Filter::filterVar($request->request->get(key: 'active'), FILTER_VALIDATE_INT))
619            ->setImage($image)
620            ->setShowHome((bool) Filter::filterVar($request->request->get(key: 'show_home'), FILTER_VALIDATE_INT));
621
622        $permissions = [
623            'restricted_user' => [],
624            'restricted_groups' => [],
625        ];
626        $userPermissionMode = Filter::filterVar(
627            $request->request->get(key: 'userpermission'),
628            FILTER_SANITIZE_SPECIAL_CHARS,
629        );
630        if ('all' === $userPermissionMode) {
631            $permissions['restricted_user'] = [-1];
632        }
633
634        if ('all' !== $userPermissionMode) {
635            $restrictedUser = Filter::filterVar($request->request->get(key: 'restricted_users'), FILTER_VALIDATE_INT);
636            $permissions['restricted_user'] = $restrictedUser === null ? [] : [$restrictedUser];
637        }
638
639        $groupPermissionMode = Filter::filterVar(
640            $request->request->get(key: 'grouppermission'),
641            FILTER_SANITIZE_SPECIAL_CHARS,
642        );
643        if ('all' === $groupPermissionMode) {
644            $permissions['restricted_groups'] = [-1];
645        }
646
647        if ('all' !== $groupPermissionMode) {
648            $restrictedGroups = $request->request->all(key: 'restricted_groups');
649            $permissions['restricted_groups'] = array_values(array_filter(
650                array_map(static fn($value): ?int => Filter::filterVar($value, FILTER_VALIDATE_INT), $restrictedGroups),
651                static fn($value): bool => $value !== null,
652            ));
653        }
654
655        $templateVars = [
656            'msgHeaderCategoryMain' => Translation::get(key: 'msgHeaderCategoryOverview'),
657        ];
658
659        $needsTranslation = !$category->hasLanguage($categoryEntity->getId(), $categoryEntity->getLang());
660        if ($needsTranslation) {
661            $translated =
662                $category->create($categoryEntity)
663                && $categoryPermission->add(
664                    CategoryPermission::USER,
665                    [$categoryEntity->getId()],
666                    $permissions['restricted_user'],
667                )
668                && $categoryPermission->add(
669                    CategoryPermission::GROUP,
670                    [$categoryEntity->getId()],
671                    $permissions['restricted_groups'],
672                );
673            if ($translated) {
674                // Add SERP-Title and Description to the translated category
675                $seoEntity = new SeoEntity();
676                $seoEntity
677                    ->setSeoType(SeoType::CATEGORY)
678                    ->setReferenceId($categoryEntity->getId())
679                    ->setReferenceLanguage($categoryEntity->getLang())
680                    ->setTitle(Filter::filterVar(
681                        $request->request->get('serpTitle'),
682                        FILTER_SANITIZE_SPECIAL_CHARS,
683                        '',
684                    ))
685                    ->setDescription(Filter::filterVar(
686                        $request->request->get('serpDescription'),
687                        FILTER_SANITIZE_SPECIAL_CHARS,
688                        '',
689                    ));
690
691                $existingSeoId = $this->seo->get($seoEntity)->getId();
692                if ($existingSeoId === null) {
693                    $this->seo->create($seoEntity);
694                }
695
696                if ($existingSeoId !== null) {
697                    $this->seo->update($seoEntity);
698                }
699
700                $templateVars = [
701                    ...$templateVars,
702                    'isSuccess' => true,
703                    'successMessage' => Translation::get(key: 'ad_categ_translated'),
704                ];
705            }
706
707            if (!$translated) {
708                $templateVars = [
709                    ...$templateVars,
710                    'isError' => true,
711                    'errorMessage' => Translation::get(key: 'ad_msg_mysqlerr'),
712                ];
713
714                $this->configuration->getLogger()->error('Failed to translate category', [
715                    'categoryId' => $categoryId,
716                    'sqlError' => $this->configuration->getDb()->error(),
717                ]);
718            }
719        }
720
721        if (!$needsTranslation) {
722            $updated = $category->update($categoryEntity);
723            if ($updated) {
724                $categoryPermission->delete(CategoryPermission::USER, [$categoryEntity->getId()]);
725                $categoryPermission->delete(CategoryPermission::GROUP, [$categoryEntity->getId()]);
726                $categoryPermission->add(
727                    CategoryPermission::USER,
728                    [$categoryEntity->getId()],
729                    $permissions['restricted_user'],
730                );
731                $categoryPermission->add(
732                    CategoryPermission::GROUP,
733                    [$categoryEntity->getId()],
734                    $permissions['restricted_groups'],
735                );
736
737                if ($hasUploadedImage) {
738                    try {
739                        $this->categoryImage->upload();
740                    } catch (Throwable $exception) {
741                        $templateVars = [
742                            ...$templateVars,
743                            'isWarning' => true,
744                            'warningMessage' => $exception->getMessage(),
745                        ];
746                    }
747                }
748
749                // SEO data
750                $seoEntity = new SeoEntity();
751                $seoEntity
752                    ->setSeoType(SeoType::CATEGORY)
753                    ->setReferenceId($categoryId)
754                    ->setReferenceLanguage($categoryLang)
755                    ->setTitle(Filter::filterVar(
756                        $request->request->get('serpTitle'),
757                        FILTER_SANITIZE_SPECIAL_CHARS,
758                        '',
759                    ))
760                    ->setDescription(Filter::filterVar(
761                        $request->request->get('serpDescription'),
762                        FILTER_SANITIZE_SPECIAL_CHARS,
763                        '',
764                    ));
765
766                $existingSeoId = $this->seo->get($seoEntity)->getId();
767                if ($existingSeoId === null) {
768                    $this->seo->create($seoEntity);
769                }
770
771                if ($existingSeoId !== null) {
772                    $this->seo->update($seoEntity);
773                }
774
775                // Admin Log
776                $this->adminLog->log($this->currentUser, AdminLogType::CATEGORY_EDIT->value . ':' . $categoryId);
777
778                $templateVars = [
779                    ...$templateVars,
780                    'isSuccess' => true,
781                    'successMessage' => Translation::get(key: 'ad_categ_updated'),
782                ];
783            }
784
785            if (!$updated) {
786                $this->configuration->getLogger()->error('Failed to update category', [
787                    'categoryId' => $categoryId,
788                    'sqlError' => $this->configuration->getDb()->error(),
789                ]);
790
791                $templateVars = [
792                    ...$templateVars,
793                    'isError' => true,
794                    'errorMessage' => Translation::get(key: 'ad_msg_mysqlerr'),
795                ];
796            }
797        }
798
799        return $this->render(file: '@admin/content/category.main.twig', context: [
800            ...$this->getHeader($request),
801            ...$this->getFooter(),
802            ...$this->getBaseTemplateVars(),
803            ...$templateVars,
804        ]);
805    }
806
807    /**
808     * @throws \Exception
809     * @return array<string, mixed>
810     */
811    private function getBaseTemplateVars(): array
812    {
813        return [
814            'csrfTokenInput' => Token::getInstance($this->session)->getTokenInput(page: 'save-category'),
815            'userSelection' => $this->userHelper->getAllUsersForTemplate(),
816            'permLevel' => $this->configuration->get(item: 'security.permLevel'),
817            'msgAccessAllUsers' => Translation::get(key: 'msgAccessAllUsers'),
818            'ad_entry_restricted_users' => Translation::get(key: 'ad_entry_restricted_users'),
819            'ad_entry_userpermission' => Translation::get(key: 'ad_entry_userpermission'),
820            'ad_categ_add' => Translation::get(key: 'ad_categ_add'),
821            'ad_entry_restricted_groups' => Translation::get(key: 'ad_entry_restricted_groups'),
822            'restricted_groups' => $this->currentUser->perm instanceof MediumPermission
823                ? $this->currentUser->perm->getAllGroupsOptions([], $this->currentUser)
824                : '',
825            'buttonCancel' => Translation::get(key: 'ad_gen_cancel'),
826        ];
827    }
828}

Inherited from phpMyFAQ\Controller\Administration\AbstractAdministrationController

42    protected function initializeFromContainer(): void
43    {
44        parent::initializeFromContainer();
45
46        $adminLog = $this->container->get(id: 'phpmyfaq.admin.admin-log');
47        if (!$adminLog instanceof AdminLog) {
48            throw new \LogicException('AdminLog service not found in container.');
49        }
50
51        $this->adminLog = $adminLog;
52    }
64    public function render(string $file, array $context = [], ?Response $response = null): Response
65    {
66        $response = parent::render($file, $context, $response);
67        $response->headers->set('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0');
68        $response->headers->set('Pragma', 'no-cache');
69
70        return $response;
71    }
77    protected function getHeader(Request $request): array
78    {
79        $adminHelper = $this->container->get(id: 'phpmyfaq.admin.helper');
80        if (!$adminHelper instanceof AdminMenuBuilder) {
81            throw new \LogicException('AdminMenuBuilder service not found in container.');
82        }
83
84        $adminHelper->setUser($this->currentUser);
85
86        $secLevelEntries = $this->getSecondLevelEntries($adminHelper);
87        $pageFlags = $this->getPageFlags($request);
88        $gravatarImage = $this->getGravatarImage();
89
90        return [
91            'metaLanguage' => Translation::get(key: 'metaLanguage'),
92            'layoutMode' => 'light',
93            'defaultLayoutMode' => (string) ($this->configuration->get('layout.defaultLayoutMode') ?? 'auto'),
94            'allowUserLayoutMode' =>
95                $this->configuration->get('layout.allowUserLayoutMode') === true
96                    || $this->configuration->get('layout.allowUserLayoutMode') === 'true',
97            'pageTitle' => $this->configuration->getTitle() . ' - ' . System::getPoweredByPlainString(),
98            'baseHref' => $this->configuration->getDefaultUrl() . 'admin/',
99            'version' => System::getVersion(),
100            'currentYear' => date(format: 'Y'),
101            'metaRobots' => $this->configuration->get(item: 'seo.metaTagsAdmin'),
102            'templateSetName' => TwigWrapper::getTemplateSetName(),
103            'pageDirection' => Translation::get(key: 'direction'),
104            'userHasAccessPermission' => $adminHelper->canAccessContent($this->currentUser),
105            'msgSessionExpiration' => Translation::get(key: 'ad_session_expiration'),
106            'renderedLanguageSelection' => LanguageHelper::renderSelectLanguage(
107                $this->configuration->getLanguage()->getLanguage(),
108                true,
109                [],
110                'lang',
111            ),
112            'userName' => $this->currentUser->getUserData('display_name'),
113            'hasGravatarSupport' => $this->configuration->get(item: 'main.enableGravatarSupport'),
114            'gravatarImage' => $gravatarImage,
115            'msgChangePassword' => Translation::get(key: 'ad_menu_passwd'),
116            'csrfTokenLogout' => Token::getInstance($this->session)->getTokenString('admin-logout'),
117            'msgLogout' => Translation::get(key: 'admin_mainmenu_logout'),
118            'secondLevelEntries' => $secLevelEntries,
119            'menuUsers' => Translation::get(key: 'admin_mainmenu_users'),
120            'menuContent' => Translation::get(key: 'admin_mainmenu_content'),
121            'menuStatistics' => Translation::get(key: 'admin_mainmenu_statistics'),
122            'menuImportsExports' => Translation::get(key: 'admin_mainmenu_imports_exports'),
123            'menuBackup' => Translation::get(key: 'admin_mainmenu_backup'),
124            'menuConfiguration' => Translation::get(key: 'admin_mainmenu_configuration'),
125            'isSessionTimeoutCounterEnabled' => $this->configuration->get(
126                item: 'security.enableAdminSessionTimeoutCounter',
127            ),
128            'pluginStylesheets' => $this->configuration->getPluginManager()->getAllPluginStylesheets(),
129            'pluginScripts' => $this->configuration->getPluginManager()->getAllPluginScripts(),
130        ] + $pageFlags;
131    }
136    private function getSecondLevelEntries(AdminMenuBuilder $adminHelper): array
137    {
138        $secLevelEntries = [];
139
140        $secLevelEntries['user'] = $adminHelper->addMenuEntry(
141            'add_user+edit_user+delete_user',
142            'ad_menu_user_administration',
143            'user',
144        );
145        if ($this->configuration->get(item: 'security.permLevel') !== 'basic') {
146            $secLevelEntries['user'] .= $adminHelper->addMenuEntry(
147                'addgroup+editgroup+delgroup',
148                'ad_menu_group_administration',
149                'group',
150            );
151        }
152
153        $secLevelEntries['user'] .= $adminHelper->addMenuEntry(
154            PermissionType::PASSWORD_CHANGE->value,
155            'ad_menu_passwd',
156            'password/change',
157        );
158
159        $secLevelEntries['content'] = $adminHelper->addMenuEntry(
160            'addcateg+editcateg+delcateg',
161            'msgHeaderCategoryOverview',
162            'category',
163        );
164        $secLevelEntries['content'] .= $adminHelper->addMenuEntry(
165            PermissionType::FAQ_ADD->value,
166            'msgAddFAQ',
167            'faq/add',
168        );
169        $secLevelEntries['content'] .= $adminHelper->addMenuEntry(
170            'edit_faq+delete_faq',
171            'msgHeaderFAQOverview',
172            'faqs',
173        );
174        $secLevelEntries['content'] .= $adminHelper->addMenuEntry(
175            PermissionType::FAQ_EDIT->value,
176            'stickyRecordsHeader',
177            'sticky-faqs',
178        );
179        $secLevelEntries['content'] .= $adminHelper->addMenuEntry(
180            PermissionType::FAQ_EDIT->value,
181            'msgOrphanedFAQs',
182            'orphaned-faqs',
183        );
184        $secLevelEntries['content'] .= $adminHelper->addMenuEntry(
185            PermissionType::QUESTION_DELETE->value,
186            'ad_menu_open',
187            'questions',
188        );
189        $secLevelEntries['content'] .= $adminHelper->addMenuEntry(
190            PermissionType::COMMENT_DELETE->value,
191            'ad_menu_comments',
192            'comments',
193        );
194        $secLevelEntries['content'] .= $adminHelper->addMenuEntry(
195            'addattachment+editattachment+delattachment',
196            'msgAttachments',
197            'attachments',
198        );
199        $secLevelEntries['content'] .= $adminHelper->addMenuEntry(PermissionType::FAQ_EDIT->value, 'msgTags', 'tags');
200        $secLevelEntries['content'] .= $adminHelper->addMenuEntry(
201            'addglossary+editglossary+delglossary',
202            'ad_menu_glossary',
203            'glossary',
204        );
205        $secLevelEntries['content'] .= $adminHelper->addMenuEntry('addnews+editnews+delnews', 'msgNews', 'news');
206        $secLevelEntries['content'] .= $adminHelper->addMenuEntry('addpage+editpage+delpage', 'ad_menu_pages', 'pages');
207
208        $secLevelEntries['statistics'] = $adminHelper->addMenuEntry(
209            PermissionType::STATISTICS_VIEWLOGS->value,
210            'ad_menu_stat',
211            'statistics/ratings',
212        );
213        $secLevelEntries['statistics'] .= $adminHelper->addMenuEntry(
214            PermissionType::STATISTICS_VIEWLOGS->value,
215            'ad_menu_session',
216            'statistics/sessions',
217        );
218        $secLevelEntries['statistics'] .= $adminHelper->addMenuEntry(
219            PermissionType::STATISTICS_ADMINLOG->value,
220            'ad_menu_adminlog',
221            'statistics/admin-log',
222        );
223        $secLevelEntries['statistics'] .= $adminHelper->addMenuEntry(
224            PermissionType::STATISTICS_VIEWLOGS->value,
225            'msgAdminElasticsearchStats',
226            'statistics/search',
227        );
228        $secLevelEntries['statistics'] .= $adminHelper->addMenuEntry(
229            PermissionType::REPORTS->value,
230            'ad_menu_reports',
231            'statistics/report',
232        );
233
234        $secLevelEntries['imports_exports'] = $adminHelper->addMenuEntry(
235            PermissionType::FAQ_ADD->value,
236            'msgImportRecords',
237            'import',
238        );
239        $secLevelEntries['imports_exports'] .= $adminHelper->addMenuEntry(
240            PermissionType::EXPORT->value,
241            'ad_menu_export',
242            'export',
243        );
244
245        $secLevelEntries['backup'] = $adminHelper->addMenuEntry(
246            PermissionType::CONFIGURATION_EDIT->value,
247            'ad_menu_backup',
248            'backup',
249        );
250
251        $secLevelEntries['config'] = $adminHelper->addMenuEntry(
252            PermissionType::CONFIGURATION_EDIT->value,
253            'ad_menu_editconfig',
254            'configuration',
255        );
256        $secLevelEntries['config'] .= $adminHelper->addMenuEntry('forms_edit', 'msgEditForms', 'forms');
257        $secLevelEntries['config'] .= $adminHelper->addMenuEntry(
258            'editinstances+addinstances+delinstances',
259            'ad_menu_instances',
260            'instances',
261        );
262        $secLevelEntries['config'] .= $adminHelper->addMenuEntry(
263            PermissionType::CONFIGURATION_EDIT->value,
264            'ad_menu_stopwordsconfig',
265            'stopwords',
266        );
267        if ($this->configuration->get(item: 'upgrade.onlineUpdateEnabled')) {
268            $secLevelEntries['config'] .= $adminHelper->addMenuEntry(
269                PermissionType::CONFIGURATION_EDIT->value,
270                'msgAdminHeaderUpdate',
271                'update',
272            );
273        }
274
275        $secLevelEntries['config'] .= $adminHelper->addMenuEntry(
276            PermissionType::CONFIGURATION_EDIT->value,
277            'msgPlugins',
278            'plugins',
279        );
280        if ($this->configuration->get(item: 'search.enableElasticsearch')) {
281            $secLevelEntries['config'] .= $adminHelper->addMenuEntry(
282                PermissionType::CONFIGURATION_EDIT->value,
283                'msgAdminHeaderElasticsearch',
284                'elasticsearch',
285            );
286        }
287
288        if ($this->configuration->isLdapActive()) {
289            $secLevelEntries['config'] .= $adminHelper->addMenuEntry(
290                PermissionType::CONFIGURATION_EDIT->value,
291                'msgAdminHeaderLdap',
292                'ldap',
293            );
294        }
295
296        if ($this->configuration->get(item: 'search.enableOpenSearch')) {
297            $secLevelEntries['config'] .= $adminHelper->addMenuEntry(
298                PermissionType::CONFIGURATION_EDIT->value,
299                'msgAdminHeaderOpenSearch',
300                'opensearch',
301            );
302        }
303
304        $secLevelEntries['config'] .= $adminHelper->addMenuEntry(
305            PermissionType::CONFIGURATION_EDIT->value,
306            'ad_system_info',
307            'system',
308        );
309
310        return $secLevelEntries;
311    }
316    private function getPageFlags(Request $request): array
317    {
318        $userPage = false;
319        $contentPage = false;
320        $statisticsPage = false;
321        $exportsPage = false;
322        $backupPage = false;
323        $configurationPage = false;
324
325        switch ($request->attributes->get('_route')) {
326            case 'admin.group':
327            case 'admin.group.add':
328            case 'admin.group.create':
329            case 'admin.password.change':
330            case 'admin.password.update':
331            case 'admin.user':
332            case 'admin.user.list':
333            case 'admin.user.edit':
334                $userPage = true;
335                break;
336            case 'admin.attachments':
337            case 'admin.category':
338            case 'admin.category.add':
339            case 'admin.category.add.child':
340            case 'admin.category.create':
341            case 'admin.category.edit':
342            case 'admin.category.hierarchy':
343            case 'admin.category.translate':
344            case 'admin.category.update':
345            case 'admin.content.orphaned-faqs':
346            case 'admin.content.sticky-faqs':
347            case 'admin.comments':
348            case 'admin.faq.add':
349            case 'admin.faq.answer':
350            case 'admin.faq.copy':
351            case 'admin.faq.edit':
352            case 'admin.faq.translate':
353            case 'admin.faqs':
354            case 'admin.glossary':
355            case 'admin.news':
356            case 'admin.news.add':
357            case 'admin.news.edit':
358            case 'admin.pages':
359            case 'admin.page.add':
360            case 'admin.page.edit':
361            case 'admin.page.translate':
362            case 'admin.questions':
363            case 'admin.tags':
364                $contentPage = true;
365                break;
366            case 'admin.statistics.admin-log':
367            case 'admin.statistics.ratings':
368            case 'admin.statistics.report':
369            case 'admin.statistics.sessions':
370            case 'admin.statistics.session.day':
371            case 'admin.statistics.session.id':
372            case 'admin.statistics.search':
373                $statisticsPage = true;
374                break;
375            case 'admin.export':
376            case 'admin.import':
377                $exportsPage = true;
378                break;
379            case 'admin.backup':
380            case 'admin.backup.export':
381            case 'admin.backup.restore':
382                $backupPage = true;
383                break;
384            case 'admin.configuration':
385            case 'admin.elasticsearch':
386            case 'admin.ldap':
387            case 'admin.opensearch':
388            case 'admin.forms':
389            case 'admin.instance.edit':
390            case 'admin.instance.update':
391            case 'admin.instances':
392            case 'admin.stopwords':
393            case 'admin.system':
394            case 'admin.configuration.plugins':
395            case 'admin.update':
396                $configurationPage = true;
397                break;
398        }
399
400        return [
401            'userPage' => $userPage,
402            'contentPage' => $contentPage,
403            'statisticsPage' => $statisticsPage,
404            'exportsPage' => $exportsPage,
405            'backupPage' => $backupPage,
406            'configurationPage' => $configurationPage,
407        ];
408    }
410    private function getGravatarImage(): string
411    {
412        if ($this->currentUser->isLoggedIn() && (bool) $this->configuration->get(item: 'main.enableGravatarSupport')) {
413            $email = $this->currentUser->getUserData('email');
414            $gravatar = new Gravatar();
415            return $gravatar->getImage(is_string($email) ? $email : '', [
416                'size' => '24',
417                'class' => 'img-profile rounded-circle',
418            ]);
419        }
420
421        return '';
422    }
428    protected function userHasPermission(PermissionType $permissionType): void
429    {
430        // Administration pages require authentication first: a logged-out user
431        // must be redirected to the login page (UnauthorizedHttpException),
432        // whereas ForbiddenException (403) is reserved for authenticated users
433        // who lack the required permission.
434        $this->userIsAuthenticated();
435        parent::userHasPermission($permissionType);
436    }
441    protected function getFooter(): array
442    {
443        return [
444            'msgModalSessionWarning' => sprintf(
445                Translation::getString('ad_session_expiring'),
446                PMF_AUTH_TIMEOUT_WARNING,
447            ),
448            'msgPoweredBy' => System::getPoweredByPlainString(),
449            'documentationUrl' => System::getDocumentationUrl(),
450            'phpMyFaqUrl' => System::PHPMYFAQ_URL,
451            'isUserLoggedIn' => $this->currentUser->isLoggedIn(),
452            'currentLanguage' => $this->configuration->getLanguage()->getLanguage(),
453            'currentYear' => date(format: 'Y'),
454        ];
455    }

Inherited from phpMyFAQ\Controller\AbstractController

93    public function setContainer(ContainerInterface $container): void
94    {
95        $this->container = $container;
96        $this->initializeFromContainer();
97    }
154    public function renderView(string $pathToTwigFile, array $templateVars = []): string
155    {
156        $twigWrapper = $this->getTwigWrapper();
157        $templateWrapper = $twigWrapper->loadTemplate($pathToTwigFile);
158
159        return $templateWrapper->render($templateVars);
160    }
167    public function json(mixed $data, int $status = 200, array $headers = []): JsonResponse
168    {
169        return new JsonResponse($data, $status, $headers);
170    }
182    protected function getJsonObject(Request $request): \stdClass
183    {
184        /* @mago-expect analysis:mixed-assignment - json_decode() is mixed by nature; validated to stdClass below */
185        $data = json_decode($request->getContent(), associative: false, depth: 512, flags: JSON_THROW_ON_ERROR);
186
187        if (!$data instanceof \stdClass) {
188            throw new JsonException('The request body must be a JSON object.');
189        }
190
191        return $data;
192    }
197    public function getTwigWrapper(): TwigWrapper
198    {
199        $twigWrapper = new TwigWrapper(
200            (string) PMF_ROOT_DIR . '/assets/templates',
201            false,
202            $this->configuration->getTemplateSet(),
203        );
204
205        foreach ($this->twigExtensions as $twigExtension) {
206            $twigWrapper->addExtension($twigExtension);
207        }
208
209        foreach ($this->twigFilters as $twigFilter) {
210            $twigWrapper->addFilter($twigFilter);
211        }
212
213        return $twigWrapper;
214    }
219    protected function hasValidToken(): void
220    {
221        $configuredToken = $this->configuration->get(item: 'api.apiClientToken');
222        if (!is_string($configuredToken) || $configuredToken === '') {
223            throw new UnauthorizedHttpException(challenge: '"x-pmf-token" is not valid.');
224        }
225
226        $request = Request::createFromGlobals();
227        $requestToken = $request->headers->get(key: 'x-pmf-token');
228        if (!is_string($requestToken) || !hash_equals($configuredToken, $requestToken)) {
229            throw new UnauthorizedHttpException(challenge: '"x-pmf-token" is not valid.');
230        }
231    }
236    protected function isSecured(): void
237    {
238        if ($this->currentUser->isLoggedIn()) {
239            return;
240        }
241
242        if (!$this->configuration->get(item: 'security.enableLoginOnly')) {
243            return;
244        }
245
246        $request = Request::createFromGlobals();
247        $pathInfo = rtrim($request->getPathInfo(), characters: '/');
248        $pathInfo = $pathInfo === '' ? '/' : $pathInfo;
249
250        if ($this->isPublicAuthenticationPath($pathInfo)) {
251            return;
252        }
253
254        throw new UnauthorizedHttpException(challenge: 'You are not allowed to view this content.');
255    }
257    private function isPublicAuthenticationPath(string $pathInfo): bool
258    {
259        $publicAuthenticationPaths = [
260            '/login',
261            '/authenticate',
262            '/forgot-password',
263            '/token',
264            '/check',
265            '/contact.html',
266            '/imprint.html',
267            '/privacy.html',
268            '/terms.html',
269            '/accessibility.html',
270            '/auth/azure/authorize',
271            '/auth/azure/callback',
272            '/auth/azure/callback.php',
273            '/auth/keycloak/authorize',
274            '/auth/keycloak/callback',
275            '/auth/keycloak/logout',
276            '/services/azure/callback',
277            '/services/azure/callback.php',
278            '/api/webauthn/prepare-login',
279            '/api/webauthn/login',
280        ];
281
282        return in_array($pathInfo, $publicAuthenticationPaths, strict: true);
283    }
288    public function userIsAuthenticated(): void
289    {
290        if (!$this->currentUser->isLoggedIn()) {
291            throw new UnauthorizedHttpException(challenge: 'User is not authenticated.');
292        }
293    }
298    protected function userIsSuperAdmin(): void
299    {
300        if (!$this->currentUser->isSuperAdmin()) {
301            throw new UnauthorizedHttpException(challenge: 'User is not super admin.');
302        }
303    }
308    protected function userHasGroupPermission(): void
309    {
310        if (!$this->currentUser->isLoggedIn()) {
311            throw new UnauthorizedHttpException(challenge: 'User is not authenticated.');
312        }
313
314        $currentUser = $this->currentUser;
315        if (
316            !$currentUser->perm->hasPermission($currentUser->getUserId(), PermissionType::USER_ADD->value)
317            || !$currentUser->perm->hasPermission($currentUser->getUserId(), PermissionType::USER_EDIT->value)
318            || !$currentUser->perm->hasPermission($currentUser->getUserId(), PermissionType::USER_DELETE->value)
319            || !$currentUser->perm->hasPermission($currentUser->getUserId(), PermissionType::GROUP_EDIT->value)
320        ) {
321            throw new ForbiddenException(message: 'User has no group permission.');
322        }
323    }
328    protected function userHasUserPermission(): void
329    {
330        if (!$this->currentUser->isLoggedIn()) {
331            throw new UnauthorizedHttpException(challenge: 'User is not authenticated.');
332        }
333
334        $currentUser = $this->currentUser;
335        if (
336            !$currentUser->perm->hasPermission($currentUser->getUserId(), PermissionType::USER_ADD->value)
337            || !$currentUser->perm->hasPermission($currentUser->getUserId(), PermissionType::USER_EDIT->value)
338            || !$currentUser->perm->hasPermission($currentUser->getUserId(), PermissionType::USER_DELETE->value)
339        ) {
340            throw new ForbiddenException(message: 'User has no user permission.');
341        }
342    }
364    protected function userHasAnyPermission(PermissionType ...$permissionTypes): void
365    {
366        if (!$this->currentUser->isLoggedIn()) {
367            throw new UnauthorizedHttpException(challenge: 'User is not authenticated.');
368        }
369
370        $currentUser = $this->currentUser;
371        foreach ($permissionTypes as $permissionType) {
372            if ($currentUser->perm->hasPermission($currentUser->getUserId(), $permissionType->value)) {
373                return;
374            }
375        }
376
377        throw new ForbiddenException(message: sprintf('User has none of the required permissions: %s.', implode(', ', array_map(
378            static fn(PermissionType $type): string => $type->name,
379            $permissionTypes,
380        ))));
381    }
389    protected function verifySessionCsrfToken(string $page, #[\SensitiveParameter] string $requestToken): bool
390    {
391        if ($requestToken === '') {
392            return false;
393        }
394
395        $sessionKey = sprintf('pmf-csrf-token.%s', $page);
396        $storedToken = $this->session->get($sessionKey);
397
398        if (!$storedToken instanceof Token) {
399            return false;
400        }
401
402        if (time() > $storedToken->getExpiry()) {
403            $this->session->remove($sessionKey);
404            return false;
405        }
406
407        return hash_equals($storedToken->getSessionToken(), $requestToken);
408    }
414    protected function captchaCodeIsValid(Request $request): bool
415    {
416        $captcha = Captcha::getInstance($this->configuration);
417        $captcha->setUserIsLoggedIn($this->currentUser->isLoggedIn());
418
419        $data = json_decode($request->getContent(), associative: false, depth: 512, flags: JSON_THROW_ON_ERROR);
420
421        $code = Filter::filterVar($data->captcha ?? '', FILTER_SANITIZE_SPECIAL_CHARS);
422        if ($this->configuration->get(item: 'security.enableGoogleReCaptchaV2')) {
423            $code = Filter::filterVar($data->{'g-recaptcha-response'} ?? '', FILTER_SANITIZE_SPECIAL_CHARS);
424        }
425
426        return $captcha->checkCaptchaCode((string) $code);
427    }
429    public function isApiEnabled(): bool
430    {
431        return (bool) $this->configuration->get(item: 'api.enableAccess');
432    }
434    public function addExtension(ExtensionInterface $extension): void
435    {
436        $this->twigExtensions[] = $extension;
437    }
439    public function addFilter(TwigFilter $twigFilter): void
440    {
441        $this->twigFilters[] = $twigFilter;
442    }
444    protected function getRateLimiter(): ?RateLimiter
445    {
446        if (!$this->container->has('phpmyfaq.http.rate-limiter')) {
447            return null;
448        }
449
450        $rateLimiter = $this->container->get('phpmyfaq.http.rate-limiter');
451
452        return $rateLimiter instanceof RateLimiter ? $rateLimiter : null;
453    }
455    private function createFallbackContainer(): ContainerBuilder
456    {
457        $containerBuilder = new ContainerBuilder();
458        $phpFileLoader = new PhpFileLoader($containerBuilder, new FileLocator(__DIR__));
459        try {
460            $phpFileLoader->load(resource: '../../services.php');
461        } catch (\Exception $exception) {
462            error_log($exception->getMessage());
463        }
464
465        // Register Forms services
466        FormsServiceProvider::register($containerBuilder);
467
468        return $containerBuilder;
469    }