[CLEANUP] The correct case must be used for standard PHP types in phpdoc
[Packages/TYPO3.CMS.git] / typo3 / sysext / indexed_search / Classes / Domain / Repository / AdministrationRepository.php
1 <?php
2 namespace TYPO3\CMS\IndexedSearch\Domain\Repository;
3
4 /*
5 * This file is part of the TYPO3 CMS project.
6 *
7 * It is free software; you can redistribute it and/or modify it under
8 * the terms of the GNU General Public License, either version 2
9 * of the License, or any later version.
10 *
11 * For the full copyright and license information, please read the
12 * LICENSE.txt file that was distributed with this source code.
13 *
14 * The TYPO3 project - inspiring people to share!
15 */
16 use TYPO3\CMS\Backend\FrontendBackendUserAuthentication;
17 use TYPO3\CMS\Backend\Tree\View\PageTreeView;
18 use TYPO3\CMS\Backend\Utility\BackendUtility;
19 use TYPO3\CMS\Core\Authentication\BackendUserAuthentication;
20 use TYPO3\CMS\Core\Cache\CacheManager;
21 use TYPO3\CMS\Core\Cache\Frontend\FrontendInterface;
22 use TYPO3\CMS\Core\Database\Connection;
23 use TYPO3\CMS\Core\Database\ConnectionPool;
24 use TYPO3\CMS\Core\Database\Query\QueryHelper;
25 use TYPO3\CMS\Core\DataHandling\DataHandler;
26 use TYPO3\CMS\Core\Imaging\Icon;
27 use TYPO3\CMS\Core\Imaging\IconFactory;
28 use TYPO3\CMS\Core\Utility\GeneralUtility;
29 use TYPO3\CMS\IndexedSearch\FileContentParser;
30
31 /**
32 * Administration repository
33 */
34 class AdministrationRepository
35 {
36 /**
37 * List of fileContentParsers
38 *
39 * @var FileContentParser[]
40 */
41 public $external_parsers = [];
42
43 /**
44 * @var array
45 */
46 protected $allPhashListed = [];
47
48 /**
49 * @var array
50 */
51 protected $iconFileNameCache = [];
52
53 /**
54 * Get group list information
55 *
56 * @param int $phash
57 * @return array
58 */
59 public function getGrlistRecord($phash)
60 {
61 $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('index_grlist');
62 $result = $queryBuilder
63 ->select('*')
64 ->from('index_grlist')
65 ->where(
66 $queryBuilder->expr()->eq(
67 'phash',
68 $queryBuilder->createNamedParameter($phash, \PDO::PARAM_INT)
69 )
70 )
71 ->execute();
72 $numberOfRows = $result->rowCount();
73 $allRows = [];
74 while ($row = $result->fetch()) {
75 $row['pcount'] = $numberOfRows;
76 $allRows[] = $row;
77 }
78 return $allRows;
79 }
80
81 /**
82 * Get number of fulltext records
83 *
84 * @param int $phash
85 * @return int|bool
86 */
87 public function getNumberOfFulltextRecords($phash)
88 {
89 $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('index_fulltext');
90 return $queryBuilder
91 ->count('phash')
92 ->from('index_fulltext')
93 ->where(
94 $queryBuilder->expr()->eq(
95 'phash',
96 $queryBuilder->createNamedParameter($phash, \PDO::PARAM_INT)
97 )
98 )
99 ->execute()
100 ->fetchColumn(0);
101 }
102
103 /**
104 * Get number of words
105 *
106 * @param int $phash
107 * @return int|bool
108 */
109 public function getNumberOfWords($phash)
110 {
111 $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('index_rel');
112 return $queryBuilder
113 ->count('*')
114 ->from('index_rel')
115 ->where(
116 $queryBuilder->expr()->eq(
117 'phash',
118 $queryBuilder->createNamedParameter($phash, \PDO::PARAM_INT)
119 )
120 )
121 ->execute()
122 ->fetchColumn(0);
123 }
124
125 /**
126 * Get statistic of external documents
127 *
128 * @return array
129 */
130 public function getExternalDocumentsStatistic()
131 {
132 $result = [];
133
134 $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('index_phash');
135 $res = $queryBuilder
136 ->select('index_phash.*')
137 ->addSelectLiteral($queryBuilder->expr()->count('*', 'pcount'))
138 ->from('index_phash')
139 ->where($queryBuilder->expr()->neq('item_type', $queryBuilder->createNamedParameter(0, \PDO::PARAM_INT)))
140 ->groupBy(
141 'phash_grouping',
142 'phash',
143 'cHashParams',
144 'data_filename',
145 'data_page_id',
146 'data_page_reg1',
147 'data_page_type',
148 'data_page_mp',
149 'gr_list',
150 'item_type',
151 'item_title',
152 'item_description',
153 'item_mtime',
154 'tstamp',
155 'item_size',
156 'contentHash',
157 'crdate',
158 'parsetime',
159 'sys_language_uid',
160 'item_crdate',
161 'externalUrl',
162 'recordUid',
163 'freeIndexUid',
164 'freeIndexSetId'
165 )
166 ->orderBy('item_type')
167 ->execute();
168
169 while ($row = $res->fetch()) {
170 $this->addAdditionalInformation($row);
171
172 $result[] = $row;
173
174 if ($row['pcount'] > 1) {
175 $res2 = $queryBuilder
176 ->select('*')
177 ->from('index_phash')
178 ->where(
179 $queryBuilder->expr()->eq(
180 'phash_grouping',
181 $queryBuilder->createNamedParameter($row['phash_grouping'], \PDO::PARAM_INT)
182 ),
183 $queryBuilder->expr()->neq(
184 'phash',
185 $queryBuilder->createNamedParameter($row['phash'], \PDO::PARAM_INT)
186 )
187 )
188 ->execute();
189 while ($row2 = $res2->fetch()) {
190 $this->addAdditionalInformation($row2);
191 $result[] = $row2;
192 }
193 }
194 }
195 return $result;
196 }
197
198 /**
199 * Get count of the tables used for indexed_search
200 *
201 * @return array
202 */
203 public function getRecordsNumbers()
204 {
205 $tables = [
206 'index_phash',
207 'index_words',
208 'index_rel',
209 'index_grlist',
210 'index_section',
211 'index_fulltext',
212 ];
213 $recordList = [];
214 foreach ($tables as $tableName) {
215 $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($tableName);
216 $recordList[$tableName] = $queryBuilder
217 ->count('*')
218 ->from($tableName)
219 ->execute()
220 ->fetchColumn(0);
221 }
222 return $recordList;
223 }
224
225 /**
226 * Get hash types
227 *
228 * @return array
229 */
230 public function getPageHashTypes()
231 {
232 $counts = [];
233 $types = [
234 'html' => 1,
235 'htm' => 1,
236 'pdf' => 2,
237 'doc' => 3,
238 'txt' => 4
239 ];
240 $revTypes = array_flip($types);
241 $revTypes[0] = 'TYPO3 page';
242
243 $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('index_phash');
244 $res = $queryBuilder
245 ->select('item_type')
246 ->addSelectLiteral($queryBuilder->expr()->count('*', 'count'))
247 ->from('index_phash')
248 ->groupBy('item_type')
249 ->orderBy('item_type')
250 ->execute();
251
252 while ($row = $res->fetch()) {
253 $itemType = $row['item_type'];
254 $counts[] = [
255 'count' => $row['count'],
256 'name' => $revTypes[$itemType],
257 'type' => $itemType,
258 'uniqueCount' => $this->countUniqueTypes($itemType),
259 ];
260 }
261 return $counts;
262 }
263
264 /**
265 * Count unique types
266 *
267 * @param string $itemType
268 * @return int
269 */
270 protected function countUniqueTypes($itemType)
271 {
272 $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('index_phash');
273 $items = $queryBuilder
274 ->count('*')
275 ->from('index_phash')
276 ->where(
277 $queryBuilder->expr()->eq(
278 'item_type',
279 $queryBuilder->createNamedParameter($itemType, \PDO::PARAM_STR)
280 )
281 )
282 ->groupBy('phash_grouping')
283 ->execute()
284 ->fetchAll();
285
286 return count($items);
287 }
288
289 /**
290 * Get number of section records
291 *
292 * @param int $pageHash
293 * @return int
294 */
295 public function getNumberOfSections($pageHash)
296 {
297 $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('index_section');
298 return (int)$queryBuilder
299 ->count('phash')
300 ->from('index_section')
301 ->where(
302 $queryBuilder->expr()->eq(
303 'phash',
304 $queryBuilder->createNamedParameter($pageHash, \PDO::PARAM_INT)
305 )
306 )
307 ->execute()
308 ->fetchColumn(0);
309 }
310
311 /**
312 * Get page statistic
313 *
314 * @return array
315 */
316 public function getPageStatistic()
317 {
318 $result = [];
319 $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('index_phash');
320 $res = $queryBuilder
321 ->select('index_phash.*')
322 ->addSelectLiteral($queryBuilder->expr()->count('*', 'pcount'))
323 ->from('index_phash')
324 ->where($queryBuilder->expr()->neq('data_page_id', $queryBuilder->createNamedParameter(0, \PDO::PARAM_INT)))
325 ->groupBy(
326 'phash_grouping',
327 'phash',
328 'cHashParams',
329 'data_filename',
330 'data_page_id',
331 'data_page_reg1',
332 'data_page_type',
333 'data_page_mp',
334 'gr_list',
335 'item_type',
336 'item_title',
337 'item_description',
338 'item_mtime',
339 'tstamp',
340 'item_size',
341 'contentHash',
342 'crdate',
343 'parsetime',
344 'sys_language_uid',
345 'item_crdate',
346 'externalUrl',
347 'recordUid',
348 'freeIndexUid',
349 'freeIndexSetId'
350 )
351 ->orderBy('data_page_id')
352 ->execute();
353
354 while ($row = $res->fetch()) {
355 $this->addAdditionalInformation($row);
356 $result[] = $row;
357
358 if ($row['pcount'] > 1) {
359 $res2 = $queryBuilder
360 ->select('*')
361 ->from('index_phash')
362 ->where(
363 $queryBuilder->expr()->eq(
364 'phash_grouping',
365 $queryBuilder->createNamedParameter($row['phash_grouping'], \PDO::PARAM_INT)
366 ),
367 $queryBuilder->expr()->neq(
368 'phash',
369 $queryBuilder->createNamedParameter($row['phash'], \PDO::PARAM_INT)
370 )
371 )
372 ->execute();
373 while ($row2 = $res2->fetch()) {
374 $this->addAdditionalInformation($row2);
375 $result[] = $row2;
376 }
377 }
378 }
379 return $result;
380 }
381
382 /**
383 * Get general statistic
384 *
385 * @param string $additionalWhere
386 * @param int $pageUid
387 * @param int $max
388 * @return array|null
389 */
390 public function getGeneralSearchStatistic($additionalWhere, $pageUid, $max = 50)
391 {
392 $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
393 ->getQueryBuilderForTable('index_stat_word');
394 $queryBuilder
395 ->select('word')
396 ->from('index_stat_word')
397 ->addSelectLiteral($queryBuilder->expr()->count('*', 'c'))
398 ->where(
399 $queryBuilder->expr()->eq(
400 'pageid',
401 $queryBuilder->createNamedParameter($pageUid, \PDO::PARAM_INT)
402 )
403 )
404 ->groupBy('word')
405 ->setMaxResults((int)$max);
406
407 if (!empty($additionalWhere)) {
408 $queryBuilder->andWhere(QueryHelper::stripLogicalOperatorPrefix($additionalWhere));
409 }
410
411 $result = $queryBuilder->execute();
412 $count = (int)$result->rowCount();
413 $result->closeCursor();
414
415 // exist several statistics for this page?
416 if ($count === 0) {
417 // Limit access to pages of the current site
418 $queryBuilder->where(
419 $queryBuilder->expr()->in(
420 'pageid',
421 $queryBuilder->createNamedParameter(
422 GeneralUtility::intExplode(',', $this->extGetTreeList((int)$pageUid, 100, 0, '1=1'), true),
423 Connection::PARAM_INT_ARRAY
424 )
425 ),
426 QueryHelper::stripLogicalOperatorPrefix($additionalWhere)
427 );
428 }
429
430 return $queryBuilder->execute()->fetchAll();
431 }
432
433 /**
434 * Add additional information to the result row
435 *
436 * @param array $row
437 */
438 protected function addAdditionalInformation(array &$row)
439 {
440 $grListRec = $this->getGrlistRecord($row['phash']);
441 $unserializedCHashParams = unserialize($row['cHashParams']);
442
443 $row['numberOfWords'] = $this->getNumberOfWords($row['phash']);
444 $row['numberOfSections'] = $this->getNumberOfSections($row['phash']);
445 $row['numberOfFulltext'] = $this->getNumberOfFulltextRecords($row['phash']);
446 $row['cHashParams'] = !empty($unserializedCHashParams) ? $unserializedCHashParams : '';
447 $row['grList'] = $grListRec;
448 }
449
450 /**
451 * Get the page tree by using \TYPO3\CMS\Backend\Tree\View\PageTreeView
452 *
453 * @param int $pageId
454 * @param int $depth
455 * @param string $mode
456 * @return array
457 */
458 public function getTree($pageId, $depth = 4, $mode)
459 {
460 $allLines = [];
461 $pageRecord = BackendUtility::getRecord('pages', (int)$pageId);
462 if (!$pageRecord) {
463 return $allLines;
464 }
465 /** @var PageTreeView $tree */
466 $tree = GeneralUtility::makeInstance(PageTreeView::class);
467 $perms_clause = $this->getBackendUserAuthentication()->getPagePermsClause(1);
468 $tree->init('AND ' . $perms_clause);
469 $iconFactory = GeneralUtility::makeInstance(IconFactory::class);
470 $HTML = '<span title="' . htmlspecialchars($pageRecord['title']) . '">' . $iconFactory->getIconForRecord('pages', $pageRecord, Icon::SIZE_SMALL)->render() . '</span>';
471 $tree->tree[] = [
472 'row' => $pageRecord,
473 'HTML' => $HTML
474 ];
475
476 if ($depth > 0) {
477 $tree->getTree((int)$pageId, $depth, '');
478 }
479
480 foreach ($tree->tree as $singleLine) {
481 $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('index_phash');
482 $result = $queryBuilder->select(
483 'ISEC.phash_t3',
484 'ISEC.rl0',
485 'ISEC.rl1',
486 'ISEC.rl2',
487 'ISEC.page_id',
488 'ISEC.uniqid',
489 'IP.phash',
490 'IP.phash_grouping',
491 'IP.cHashParams',
492 'IP.data_filename',
493 'IP.data_page_id',
494 'IP.data_page_reg1',
495 'IP.data_page_type',
496 'IP.data_page_mp',
497 'IP.gr_list',
498 'IP.item_type',
499 'IP.item_title',
500 'IP.item_description',
501 'IP.item_mtime',
502 'IP.tstamp',
503 'IP.item_size',
504 'IP.contentHash',
505 'IP.crdate',
506 'IP.parsetime',
507 'IP.sys_language_uid',
508 'IP.item_crdate',
509 'IP.externalUrl',
510 'IP.recordUid',
511 'IP.freeIndexUid',
512 'IP.freeIndexSetId'
513 )
514 ->addSelectLiteral($queryBuilder->expr()->count('*', 'count_val'))
515 ->from('index_phash', 'IP')
516 ->from('index_section', 'ISEC')
517 ->where(
518 $queryBuilder->expr()->eq('IP.phash', $queryBuilder->quoteIdentifier('ISEC.phash')),
519 $queryBuilder->expr()->eq(
520 'ISEC.page_id',
521 $queryBuilder->createNamedParameter($singleLine['row']['uid'], \PDO::PARAM_INT)
522 )
523 )
524 ->groupBy(
525 'IP.phash',
526 'IP.phash_grouping',
527 'IP.cHashParams',
528 'IP.data_filename',
529 'IP.data_page_id',
530 'IP.data_page_reg1',
531 'IP.data_page_type',
532 'IP.data_page_mp',
533 'IP.gr_list',
534 'IP.item_type',
535 'IP.item_title',
536 'IP.item_description',
537 'IP.item_mtime',
538 'IP.tstamp',
539 'IP.item_size',
540 'IP.contentHash',
541 'IP.crdate',
542 'IP.parsetime',
543 'IP.sys_language_uid',
544 'IP.item_crdate',
545 'ISEC.phash',
546 'ISEC.phash_t3',
547 'ISEC.rl0',
548 'ISEC.rl1',
549 'ISEC.rl2',
550 'ISEC.page_id',
551 'ISEC.uniqid',
552 'IP.externalUrl',
553 'IP.recordUid',
554 'IP.freeIndexUid',
555 'IP.freeIndexSetId'
556 )
557 ->orderBy('IP.item_type')
558 ->addOrderBy('IP.tstamp')
559 ->setMaxResults(11)
560 ->execute();
561
562 $lines = [];
563 // Collecting phash values (to remove local indexing for)
564 // Traverse the result set of phash rows selected:
565 while ($row = $result->fetch()) {
566 $row['icon'] = $this->makeItemTypeIcon($row['item_type']);
567 $this->allPhashListed[] = $row['phash'];
568
569 // Adds a display row:
570 $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
571 ->getQueryBuilderForTable('index_rel');
572 $wordCountResult = $queryBuilder->count('index_words.baseword')
573 ->from('index_rel')
574 ->from('index_words')
575 ->where(
576 $queryBuilder->expr()->eq(
577 'index_rel.phash',
578 $queryBuilder->createNamedParameter($row['phash'], \PDO::PARAM_INT)
579 ),
580 $queryBuilder->expr()->eq('index_words.wid', $queryBuilder->quoteIdentifier('index_rel.wid'))
581 )
582 ->groupBy('index_words.baseword')
583 ->execute();
584
585 $row['wordCount'] = $wordCountResult->rowCount();
586 $wordCountResult->closeCursor();
587
588 if ($mode === 'content') {
589 $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
590 ->getQueryBuilderForTable('index_fulltext');
591 $row['fulltextData'] = $queryBuilder->select('*')
592 ->from('index_fulltext')
593 ->where(
594 $queryBuilder->expr()->eq(
595 'phash',
596 $queryBuilder->createNamedParameter($row['phash'], \PDO::PARAM_INT)
597 )
598 )
599 ->setMaxResults(1)
600 ->execute()
601 ->fetch();
602
603 $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
604 ->getQueryBuilderForTable('index_rel');
605 $wordRecords = $queryBuilder->select('index_words.baseword')
606 ->from('index_rel')
607 ->from('index_words')
608 ->where(
609 $queryBuilder->expr()->eq(
610 'index_rel.phash',
611 $queryBuilder->createNamedParameter($row['phash'], \PDO::PARAM_INT)
612 ),
613 $queryBuilder->expr()->eq(
614 'index_words.wid',
615 $queryBuilder->quoteIdentifier('index_rel.wid')
616 )
617 )
618 ->groupBy('index_words.baseword')
619 ->orderBy('index_words.baseword')
620 ->execute()
621 ->fetchAll();
622
623 if (is_array($wordRecords)) {
624 $row['allWords'] = array_column($wordRecords, 'baseword');
625 }
626 }
627
628 $lines[] = $row;
629 }
630
631 $singleLine['lines'] = $lines;
632 $allLines[] = $singleLine;
633 }
634
635 return $allLines;
636 }
637
638 /**
639 * Generates a list of Page-uid's from $id.
640 * The only pages excluded from the list are deleted pages.
641 *
642 * @param int $id page id
643 * @param int $depth to traverse down the page tree.
644 * @param int $begin is an optional integer that determines at which level in the tree to start collecting uid's. Zero means 'start right away', 1 = 'next level and out'
645 * @param string $perms_clause
646 * @return string Returns the list with a comma in the end + id itself
647 */
648 protected function extGetTreeList($id, $depth, $begin = 0, $perms_clause)
649 {
650 $list = GeneralUtility::makeInstance(FrontendBackendUserAuthentication::class)
651 ->extGetTreeList($id, $depth, $begin, $perms_clause);
652
653 if (empty($list)) {
654 $list = $id;
655 } else {
656 $list = rtrim($list, ',') . ',' . $id;
657 }
658
659 return $list;
660 }
661
662 /**
663 * Remove indexed phash row
664 *
665 * @param string $phashList
666 * @param int $pageId
667 * @param int $depth
668 */
669 public function removeIndexedPhashRow($phashList, $pageId, $depth = 4)
670 {
671 if ($phashList === 'ALL') {
672 $this->getTree($pageId, $depth, '');
673 $phashRows = $this->allPhashListed;
674 $this->allPhashListed = [];
675 } else {
676 $phashRows = GeneralUtility::trimExplode(',', $phashList, true);
677 }
678
679 foreach ($phashRows as $phash) {
680 $phash = (int)$phash;
681 if ($phash > 0) {
682 $idList = [];
683 $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
684 ->getQueryBuilderForTable('index_section');
685 $res = $queryBuilder
686 ->select('page_id')
687 ->from('index_section')
688 ->where(
689 $queryBuilder->expr()->eq(
690 'phash',
691 $queryBuilder->createNamedParameter($phash, \PDO::PARAM_INT)
692 )
693 )
694 ->execute();
695 while ($row = $res->fetch()) {
696 $idList[] = (int)$row['page_id'];
697 }
698
699 if (!empty($idList)) {
700 /** @var FrontendInterface $pageCache */
701 $pageCache = GeneralUtility::makeInstance(CacheManager::class)->getCache('cache_pages');
702 foreach ($idList as $pageId) {
703 $pageCache->flushByTag('pageId_' . $pageId);
704 }
705 }
706
707 // Removing old registrations for all tables.
708 $tableArr = [
709 'index_phash',
710 'index_rel',
711 'index_section',
712 'index_grlist',
713 'index_fulltext',
714 'index_debug'
715 ];
716 foreach ($tableArr as $table) {
717 GeneralUtility::makeInstance(ConnectionPool::class)
718 ->getConnectionForTable($table)
719 ->delete($table, ['phash' => (int)$phash]);
720 }
721 }
722 }
723 }
724
725 /**
726 * Save stop words
727 *
728 * @param array $words stop words
729 */
730 public function saveStopWords(array $words)
731 {
732 foreach ($words as $wid => $state) {
733 $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('index_words');
734 $queryBuilder
735 ->update('index_words')
736 ->set('is_stopword', (int)$state)
737 ->where(
738 $queryBuilder->expr()->eq(
739 'wid',
740 $queryBuilder->createNamedParameter($wid, \PDO::PARAM_INT)
741 )
742 )
743 ->execute();
744 }
745 }
746
747 /**
748 * Save keywords
749 *
750 * @param array $words keywords
751 * @param int $pageId page id
752 */
753 public function saveKeywords(array $words, $pageId)
754 {
755 // Get pages current keywords
756 $pageRec = BackendUtility::getRecord('pages', $pageId);
757 if (!is_array($pageRec)) {
758 return;
759 }
760 $keywords = array_flip(GeneralUtility::trimExplode(',', $pageRec['keywords'], true));
761 // Merge keywords:
762 foreach ($words as $key => $v) {
763 if ($v) {
764 $keywords[$key] = 1;
765 } else {
766 unset($keywords[$key]);
767 }
768 }
769 // Compile new list:
770 $data = [];
771 $data['pages'][$pageId]['keywords'] = implode(', ', array_keys($keywords));
772 $dataHandler = GeneralUtility::makeInstance(DataHandler::class);
773 $dataHandler->start($data, []);
774 $dataHandler->process_datamap();
775 }
776
777 /**
778 * Collect the type icons
779 *
780 * @param string $itemType
781 * @return string
782 */
783 protected function makeItemTypeIcon($itemType)
784 {
785 if (!isset($this->iconFileNameCache[$itemType])) {
786 $icon = '';
787 if ($itemType === '0') {
788 $icon = 'EXT:indexed_search/Resources/Public/Icons/FileTypes/pages.gif';
789 } elseif ($this->external_parsers[$itemType]) {
790 $icon = $this->external_parsers[$itemType]->getIcon($itemType);
791 }
792 $this->iconFileNameCache[$itemType] = $icon;
793 }
794 return $this->iconFileNameCache[$itemType];
795 }
796
797 /**
798 * @return BackendUserAuthentication
799 */
800 protected function getBackendUserAuthentication()
801 {
802 return $GLOBALS['BE_USER'];
803 }
804 }