nextcloud /
files_fulltextsearch
Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
Complex classes like FilesService often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use FilesService, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 57 | class FilesService { |
||
| 58 | |||
| 59 | const MIMETYPE_TEXT = 'files_text'; |
||
| 60 | const MIMETYPE_PDF = 'files_pdf'; |
||
| 61 | const MIMETYPE_OFFICE = 'files_office'; |
||
| 62 | const MIMETYPE_IMAGE = 'files_image'; |
||
| 63 | const MIMETYPE_AUDIO = 'files_audio'; |
||
| 64 | |||
| 65 | |||
| 66 | /** @var IAppContainer */ |
||
| 67 | private $container; |
||
| 68 | |||
| 69 | /** @var IRootFolder */ |
||
| 70 | private $rootFolder; |
||
| 71 | |||
| 72 | /** @var IUserManager */ |
||
| 73 | private $userManager; |
||
| 74 | |||
| 75 | /** @var AppManager */ |
||
| 76 | private $appManager; |
||
| 77 | |||
| 78 | /** @var IManager */ |
||
| 79 | private $shareManager; |
||
| 80 | |||
| 81 | /** @var ConfigService */ |
||
| 82 | private $configService; |
||
| 83 | |||
| 84 | /** @var LocalFilesService */ |
||
| 85 | private $localFilesService; |
||
| 86 | |||
| 87 | /** @var ExternalFilesService */ |
||
| 88 | private $externalFilesService; |
||
| 89 | |||
| 90 | /** @var GroupFoldersService */ |
||
| 91 | private $groupFoldersService; |
||
| 92 | |||
| 93 | /** @var ExtensionService */ |
||
| 94 | private $extensionService; |
||
| 95 | |||
| 96 | /** @var MiscService */ |
||
| 97 | private $miscService; |
||
| 98 | |||
| 99 | |||
| 100 | /** @var Runner */ |
||
| 101 | private $runner; |
||
| 102 | |||
| 103 | /** @var int */ |
||
| 104 | private $sumDocuments; |
||
| 105 | |||
| 106 | /** |
||
| 107 | * FilesService constructor. |
||
| 108 | * |
||
| 109 | * @param IAppContainer $container |
||
| 110 | * @param IRootFolder $rootFolder |
||
| 111 | * @param AppManager $appManager |
||
| 112 | * @param IUserManager $userManager |
||
| 113 | * @param IManager $shareManager |
||
| 114 | * @param ConfigService $configService |
||
| 115 | * @param LocalFilesService $localFilesService |
||
| 116 | * @param ExternalFilesService $externalFilesService |
||
| 117 | * @param GroupFoldersService $groupFoldersService |
||
| 118 | * @param ExtensionService $extensionService |
||
| 119 | * @param MiscService $miscService |
||
| 120 | * |
||
| 121 | * @internal param IProviderFactory $factory |
||
| 122 | */ |
||
| 123 | public function __construct( |
||
| 124 | IAppContainer $container, IRootFolder $rootFolder, AppManager $appManager, |
||
| 125 | IUserManager $userManager, IManager $shareManager, |
||
| 126 | ConfigService $configService, LocalFilesService $localFilesService, |
||
| 127 | ExternalFilesService $externalFilesService, GroupFoldersService $groupFoldersService, |
||
| 128 | ExtensionService $extensionService, MiscService $miscService |
||
| 129 | ) { |
||
| 130 | $this->container = $container; |
||
| 131 | $this->rootFolder = $rootFolder; |
||
| 132 | $this->appManager = $appManager; |
||
| 133 | $this->userManager = $userManager; |
||
| 134 | $this->shareManager = $shareManager; |
||
| 135 | |||
| 136 | $this->configService = $configService; |
||
| 137 | $this->localFilesService = $localFilesService; |
||
| 138 | $this->externalFilesService = $externalFilesService; |
||
| 139 | $this->groupFoldersService = $groupFoldersService; |
||
| 140 | $this->extensionService = $extensionService; |
||
| 141 | |||
| 142 | $this->miscService = $miscService; |
||
| 143 | } |
||
| 144 | |||
| 145 | |||
| 146 | public function setRunner(Runner $runner) { |
||
| 147 | $this->runner = $runner; |
||
| 148 | } |
||
| 149 | |||
| 150 | |||
| 151 | /** |
||
| 152 | * @param string $userId |
||
| 153 | * @param IndexOptions $indexOptions |
||
| 154 | * |
||
| 155 | * @return FilesDocument[] |
||
| 156 | * @throws InvalidPathException |
||
| 157 | * @throws NotFoundException |
||
| 158 | */ |
||
| 159 | public function getFilesFromUser($userId, $indexOptions) { |
||
| 160 | |||
| 161 | $this->initFileSystems($userId); |
||
| 162 | $this->sumDocuments = 0; |
||
| 163 | |||
| 164 | /** @var Folder $files */ |
||
| 165 | $files = $this->rootFolder->getUserFolder($userId) |
||
| 166 | ->get($indexOptions->getOption('path', '/')); |
||
| 167 | |||
| 168 | if ($files instanceof Folder) { |
||
|
|
|||
| 169 | $result = $this->getFilesFromDirectory($userId, $files); |
||
| 170 | } else { |
||
| 171 | $result = []; |
||
| 172 | try { |
||
| 173 | $result[] = $this->generateFilesDocumentFromFile($userId, $files); |
||
| 174 | } catch (FileIsNotIndexableException $e) { |
||
| 175 | /** we do nothin' */ |
||
| 176 | } |
||
| 177 | } |
||
| 178 | |||
| 179 | return $result; |
||
| 180 | } |
||
| 181 | |||
| 182 | |||
| 183 | /** |
||
| 184 | * @param string $userId |
||
| 185 | */ |
||
| 186 | private function initFileSystems($userId) { |
||
| 187 | if ($userId === '') { |
||
| 188 | return; |
||
| 189 | } |
||
| 190 | |||
| 191 | $this->externalFilesService->initExternalFilesForUser($userId); |
||
| 192 | $this->groupFoldersService->initGroupSharesForUser($userId); |
||
| 193 | } |
||
| 194 | |||
| 195 | |||
| 196 | /** |
||
| 197 | * @param string $userId |
||
| 198 | * @param Folder $node |
||
| 199 | * |
||
| 200 | * @return FilesDocument[] |
||
| 201 | * @throws InvalidPathException |
||
| 202 | * @throws NotFoundException |
||
| 203 | * @throws Exception |
||
| 204 | */ |
||
| 205 | public function getFilesFromDirectory($userId, Folder $node) { |
||
| 206 | $documents = []; |
||
| 207 | |||
| 208 | $this->updateRunnerAction('generateIndexFiles'); |
||
| 209 | $this->updateRunnerInfo( |
||
| 210 | [ |
||
| 211 | 'info' => $node->getPath(), |
||
| 212 | 'documentTotal' => $this->sumDocuments |
||
| 213 | ] |
||
| 214 | ); |
||
| 215 | |||
| 216 | try { |
||
| 217 | if ($node->nodeExists('.noindex')) { |
||
| 218 | return $documents; |
||
| 219 | } |
||
| 220 | } catch (StorageNotAvailableException $e) { |
||
| 221 | return $documents; |
||
| 222 | } |
||
| 223 | |||
| 224 | $files = $node->getDirectoryListing(); |
||
| 225 | foreach ($files as $file) { |
||
| 226 | |||
| 227 | try { |
||
| 228 | $documents[] = $this->generateFilesDocumentFromFile($userId, $file); |
||
| 229 | $this->sumDocuments++; |
||
| 230 | } catch (FileIsNotIndexableException $e) { |
||
| 231 | continue; |
||
| 232 | } |
||
| 233 | |||
| 234 | if ($file->getType() === FileInfo::TYPE_FOLDER) { |
||
| 235 | /** @var $file Folder */ |
||
| 236 | $documents = |
||
| 237 | array_merge($documents, $this->getFilesFromDirectory($userId, $file)); |
||
| 238 | } |
||
| 239 | } |
||
| 240 | |||
| 241 | return $documents; |
||
| 242 | } |
||
| 243 | |||
| 244 | |||
| 245 | /** |
||
| 246 | * @param Node $file |
||
| 247 | * |
||
| 248 | * @param string $viewerId |
||
| 249 | * |
||
| 250 | * @return FilesDocument |
||
| 251 | * @throws FileIsNotIndexableException |
||
| 252 | * @throws InvalidPathException |
||
| 253 | * @throws NotFoundException |
||
| 254 | * @throws Exception |
||
| 255 | */ |
||
| 256 | private function generateFilesDocumentFromFile($viewerId, Node $file) { |
||
| 257 | |||
| 258 | $source = $this->getFileSource($file); |
||
| 259 | $document = new FilesDocument(FilesProvider::FILES_PROVIDER_ID, $file->getId()); |
||
| 260 | |||
| 261 | if ($file->getId() === -1) { |
||
| 262 | throw new FileIsNotIndexableException(); |
||
| 263 | } |
||
| 264 | |||
| 265 | $ownerId = ''; |
||
| 266 | if ($file->getOwner() !== null) { |
||
| 267 | $ownerId = $file->getOwner() |
||
| 268 | ->getUID(); |
||
| 269 | } |
||
| 270 | $document->setType($file->getType()) |
||
| 271 | ->setSource($source) |
||
| 272 | ->setOwnerId($ownerId) |
||
| 273 | ->setPath($this->getPathFromViewerId($file->getId(), $viewerId)) |
||
| 274 | ->setViewerId($viewerId) |
||
| 275 | ->setModifiedTime($file->getMTime()) |
||
| 276 | ->setMimetype($file->getMimetype()); |
||
| 277 | |||
| 278 | return $document; |
||
| 279 | } |
||
| 280 | |||
| 281 | |||
| 282 | /** |
||
| 283 | * @param Node $file |
||
| 284 | * |
||
| 285 | * @return string |
||
| 286 | * @throws FileIsNotIndexableException |
||
| 287 | * @throws NotFoundException |
||
| 288 | */ |
||
| 289 | private function getFileSource(Node $file) { |
||
| 290 | $source = ''; |
||
| 291 | |||
| 292 | try { |
||
| 293 | $this->localFilesService->getFileSource($file, $source); |
||
| 294 | $this->externalFilesService->getFileSource($file, $source); |
||
| 295 | $this->groupFoldersService->getFileSource($file, $source); |
||
| 296 | } catch (KnownFileSourceException $e) { |
||
| 297 | /** we know the source, just leave. */ |
||
| 298 | } |
||
| 299 | |||
| 300 | return $source; |
||
| 301 | } |
||
| 302 | |||
| 303 | |||
| 304 | /** |
||
| 305 | * @param string $userId |
||
| 306 | * @param string $path |
||
| 307 | * |
||
| 308 | * @return Node |
||
| 309 | * @throws NotFoundException |
||
| 310 | */ |
||
| 311 | public function getFileFromPath($userId, $path) { |
||
| 312 | return $this->rootFolder->getUserFolder($userId) |
||
| 313 | ->get($path); |
||
| 314 | } |
||
| 315 | |||
| 316 | |||
| 317 | /** |
||
| 318 | * @param string $userId |
||
| 319 | * @param int $fileId |
||
| 320 | * |
||
| 321 | * @return Node |
||
| 322 | * @throws FilesNotFoundException |
||
| 323 | * @throws EmptyUserException |
||
| 324 | */ |
||
| 325 | public function getFileFromId($userId, $fileId) { |
||
| 326 | |||
| 327 | if ($userId === '') { |
||
| 328 | throw new EmptyUserException(); |
||
| 329 | } |
||
| 330 | |||
| 331 | $files = $this->rootFolder->getUserFolder($userId) |
||
| 332 | ->getById($fileId); |
||
| 333 | if (sizeof($files) === 0) { |
||
| 334 | throw new FilesNotFoundException(); |
||
| 335 | } |
||
| 336 | |||
| 337 | $file = array_shift($files); |
||
| 338 | |||
| 339 | return $file; |
||
| 340 | } |
||
| 341 | |||
| 342 | |||
| 343 | /** |
||
| 344 | * @param Index $index |
||
| 345 | * |
||
| 346 | * @return Node |
||
| 347 | * @throws EmptyUserException |
||
| 348 | * @throws FilesNotFoundException |
||
| 349 | */ |
||
| 350 | public function getFileFromIndex(Index $index) { |
||
| 351 | $this->impersonateOwner($index); |
||
| 352 | |||
| 353 | return $this->getFileFromId($index->getOwnerId(), $index->getDocumentId()); |
||
| 354 | } |
||
| 355 | |||
| 356 | |||
| 357 | /** |
||
| 358 | * @param int $fileId |
||
| 359 | * @param string $viewerId |
||
| 360 | * |
||
| 361 | * @throws Exception |
||
| 362 | * @return string |
||
| 363 | */ |
||
| 364 | private function getPathFromViewerId($fileId, $viewerId) { |
||
| 365 | |||
| 366 | $viewerFiles = $this->rootFolder->getUserFolder($viewerId) |
||
| 367 | ->getById($fileId); |
||
| 368 | |||
| 369 | if (sizeof($viewerFiles) === 0) { |
||
| 370 | return ''; |
||
| 371 | } |
||
| 372 | |||
| 373 | $file = array_shift($viewerFiles); |
||
| 374 | |||
| 375 | // TODO: better way to do this : we remove the '/userid/files/' |
||
| 376 | $path = MiscService::noEndSlash(substr($file->getPath(), 8 + strlen($viewerId))); |
||
| 377 | |||
| 378 | return $path; |
||
| 379 | } |
||
| 380 | |||
| 381 | |||
| 382 | /** |
||
| 383 | * @param FilesDocument $document |
||
| 384 | */ |
||
| 385 | public function generateDocument(FilesDocument $document) { |
||
| 386 | |||
| 387 | try { |
||
| 388 | $this->updateFilesDocument($document); |
||
| 389 | } catch (Exception $e) { |
||
| 390 | // TODO - update $document with a error status instead of just ignore ! |
||
| 391 | $document->getIndex() |
||
| 392 | ->setStatus(Index::INDEX_IGNORE); |
||
| 393 | echo 'Exception: ' . json_encode($e->getTrace()) . ' - ' . $e->getMessage() |
||
| 394 | . "\n"; |
||
| 395 | } |
||
| 396 | } |
||
| 397 | |||
| 398 | |||
| 399 | /** |
||
| 400 | * @param Index $index |
||
| 401 | * |
||
| 402 | * @return FilesDocument |
||
| 403 | * @throws FileIsNotIndexableException |
||
| 404 | * @throws InvalidPathException |
||
| 405 | * @throws NotFoundException |
||
| 406 | * @throws NotPermittedException |
||
| 407 | */ |
||
| 408 | private function generateDocumentFromIndex(Index $index) { |
||
| 427 | |||
| 428 | |||
| 429 | /** |
||
| 430 | * @param IndexDocument $document |
||
| 431 | * |
||
| 432 | * @return bool |
||
| 433 | */ |
||
| 434 | public function isDocumentUpToDate($document) { |
||
| 454 | |||
| 455 | |||
| 456 | /** |
||
| 457 | * @param Index $index |
||
| 458 | * |
||
| 459 | * @return FilesDocument |
||
| 460 | * @throws InvalidPathException |
||
| 461 | * @throws NotFoundException |
||
| 462 | * @throws NotPermittedException |
||
| 463 | * @throws FileIsNotIndexableException |
||
| 464 | */ |
||
| 465 | public function updateDocument(Index $index) { |
||
| 466 | $this->impersonateOwner($index); |
||
| 471 | |||
| 472 | |||
| 473 | /** |
||
| 474 | * @param FilesDocument $document |
||
| 475 | * |
||
| 476 | * @throws InvalidPathException |
||
| 477 | * @throws NotFoundException |
||
| 478 | * @throws NotPermittedException |
||
| 479 | */ |
||
| 480 | private function updateFilesDocument(FilesDocument $document) { |
||
| 491 | |||
| 492 | |||
| 493 | /** |
||
| 494 | * @param FilesDocument $document |
||
| 495 | * @param Node $file |
||
| 496 | * |
||
| 497 | * @throws InvalidPathException |
||
| 498 | * @throws NotFoundException |
||
| 499 | * @throws NotPermittedException |
||
| 500 | */ |
||
| 501 | private function updateFilesDocumentFromFile(FilesDocument $document, Node $file) { |
||
| 511 | |||
| 512 | |||
| 513 | /** |
||
| 514 | * @param FilesDocument $document |
||
| 515 | * @param Node $file |
||
| 516 | */ |
||
| 517 | private function updateDocumentAccess(FilesDocument $document, Node $file) { |
||
| 532 | |||
| 533 | |||
| 534 | /** |
||
| 535 | * @param FilesDocument $document |
||
| 536 | * @param Node $file |
||
| 537 | * |
||
| 538 | * @throws InvalidPathException |
||
| 539 | * @throws NotFoundException |
||
| 540 | * @throws NotPermittedException |
||
| 541 | */ |
||
| 542 | private function updateContentFromFile(FilesDocument $document, Node $file) { |
||
| 571 | |||
| 572 | |||
| 573 | /** |
||
| 574 | * @param FilesDocument $document |
||
| 575 | * @param Node $file |
||
| 576 | * |
||
| 577 | * @return array |
||
| 578 | */ |
||
| 579 | private function updateShareNames(FilesDocument $document, Node $file) { |
||
| 610 | |||
| 611 | |||
| 612 | /** |
||
| 613 | * @param string $mimeType |
||
| 614 | * |
||
| 615 | * @return string |
||
| 616 | */ |
||
| 617 | private function parseMimeType($mimeType) { |
||
| 629 | |||
| 630 | |||
| 631 | /** |
||
| 632 | * @param string $mimeType |
||
| 633 | * @param string $parsed |
||
| 634 | * |
||
| 635 | * @throws KnownFileMimeTypeException |
||
| 636 | */ |
||
| 637 | private function parseMimeTypeText($mimeType, &$parsed) { |
||
| 655 | |||
| 656 | |||
| 657 | /** |
||
| 658 | * @param string $mimeType |
||
| 659 | * @param string $parsed |
||
| 660 | * |
||
| 661 | * @throws KnownFileMimeTypeException |
||
| 662 | */ |
||
| 663 | private function parseMimeTypePDF($mimeType, &$parsed) { |
||
| 670 | |||
| 671 | |||
| 672 | /** |
||
| 673 | * @param string $mimeType |
||
| 674 | * @param string $parsed |
||
| 675 | * |
||
| 676 | * @throws KnownFileMimeTypeException |
||
| 677 | */ |
||
| 678 | private function parseMimeTypeOffice($mimeType, &$parsed) { |
||
| 697 | |||
| 698 | |||
| 699 | /** |
||
| 700 | * @param FilesDocument $document |
||
| 701 | * @param File $file |
||
| 702 | * |
||
| 703 | * @throws NotPermittedException |
||
| 704 | */ |
||
| 705 | private function extractContentFromFileText(FilesDocument $document, File $file) { |
||
| 719 | |||
| 720 | |||
| 721 | /** |
||
| 722 | * @param FilesDocument $document |
||
| 723 | * @param File $file |
||
| 724 | * |
||
| 725 | * @throws NotPermittedException |
||
| 726 | */ |
||
| 727 | View Code Duplication | private function extractContentFromFilePDF(FilesDocument $document, File $file) { |
|
| 747 | |||
| 748 | |||
| 749 | /** |
||
| 750 | * @param FilesDocument $document |
||
| 751 | * @param File $file |
||
| 752 | * |
||
| 753 | * @throws NotPermittedException |
||
| 754 | */ |
||
| 755 | View Code Duplication | private function extractContentFromFileOffice(FilesDocument $document, File $file) { |
|
| 775 | |||
| 776 | |||
| 777 | /** |
||
| 778 | * @param FilesDocument $document |
||
| 779 | * |
||
| 780 | * @return bool |
||
| 781 | */ |
||
| 782 | private function isSourceIndexable(FilesDocument $document) { |
||
| 792 | |||
| 793 | |||
| 794 | private function impersonateOwner(Index $index) { |
||
| 802 | |||
| 803 | |||
| 804 | /** |
||
| 805 | * @param $action |
||
| 806 | * @param bool $force |
||
| 807 | * |
||
| 808 | * @throws Exception |
||
| 809 | */ |
||
| 810 | private function updateRunnerAction($action, $force = false) { |
||
| 817 | |||
| 818 | |||
| 819 | /** |
||
| 820 | * @param array $data |
||
| 821 | */ |
||
| 822 | private function updateRunnerInfo($data) { |
||
| 829 | |||
| 830 | |||
| 831 | } |
||
| 832 | |||
| 833 |
Loading history...
This error could be the result of:
1. Missing dependencies
PHP Analyzer uses your
composer.jsonfile (if available) to determine the dependencies of your project and to determine all the available classes and functions. It expects thecomposer.jsonto be in the root folder of your repository.Are you sure this class is defined by one of your dependencies, or did you maybe not list a dependency in either the
requireorrequire-devsection?2. Missing use statement
PHP does not complain about undefined classes in
ìnstanceofchecks. For example, the following PHP code will work perfectly fine:If you have not tested against this specific condition, such errors might go unnoticed.