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 |
||
| 58 | class FilesService { |
||
| 59 | |||
| 60 | const MIMETYPE_TEXT = 'files_text'; |
||
| 61 | const MIMETYPE_PDF = 'files_pdf'; |
||
| 62 | const MIMETYPE_OFFICE = 'files_office'; |
||
| 63 | const MIMETYPE_OCR = 'files_ocr'; |
||
| 64 | const MIMETYPE_IMAGE = 'files_image'; |
||
| 65 | const MIMETYPE_AUDIO = 'files_audio'; |
||
| 66 | |||
| 67 | |||
| 68 | /** @var IAppContainer */ |
||
| 69 | private $container; |
||
| 70 | |||
| 71 | /** @var IRootFolder */ |
||
| 72 | private $rootFolder; |
||
| 73 | |||
| 74 | /** @var IUserManager */ |
||
| 75 | private $userManager; |
||
| 76 | |||
| 77 | /** @var AppManager */ |
||
| 78 | private $appManager; |
||
| 79 | |||
| 80 | /** @var IManager */ |
||
| 81 | private $shareManager; |
||
| 82 | |||
| 83 | /** @var ConfigService */ |
||
| 84 | private $configService; |
||
| 85 | |||
| 86 | /** @var LocalFilesService */ |
||
| 87 | private $localFilesService; |
||
| 88 | |||
| 89 | /** @var ExternalFilesService */ |
||
| 90 | private $externalFilesService; |
||
| 91 | |||
| 92 | /** @var GroupFoldersService */ |
||
| 93 | private $groupFoldersService; |
||
| 94 | |||
| 95 | /** @var MiscService */ |
||
| 96 | private $miscService; |
||
| 97 | |||
| 98 | |||
| 99 | /** |
||
| 100 | * FilesService constructor. |
||
| 101 | * |
||
| 102 | * @param IAppContainer $container |
||
| 103 | * @param IRootFolder $rootFolder |
||
| 104 | * @param AppManager $appManager |
||
| 105 | * @param IUserManager $userManager |
||
| 106 | * @param IManager $shareManager |
||
| 107 | * @param ConfigService $configService |
||
| 108 | * @param LocalFilesService $localFilesService |
||
| 109 | * @param ExternalFilesService $externalFilesService |
||
| 110 | * @param GroupFoldersService $groupFoldersService |
||
| 111 | * @param MiscService $miscService |
||
| 112 | * |
||
| 113 | * @internal param IProviderFactory $factory |
||
| 114 | */ |
||
| 115 | public function __construct( |
||
| 116 | IAppContainer $container, IRootFolder $rootFolder, AppManager $appManager, |
||
| 117 | IUserManager $userManager, |
||
| 118 | IManager $shareManager, |
||
| 119 | ConfigService $configService, LocalFilesService $localFilesService, |
||
| 120 | ExternalFilesService $externalFilesService, |
||
| 121 | GroupFoldersService $groupFoldersService, |
||
| 122 | MiscService $miscService |
||
| 123 | ) { |
||
| 124 | $this->container = $container; |
||
| 125 | $this->rootFolder = $rootFolder; |
||
| 126 | $this->appManager = $appManager; |
||
| 127 | $this->userManager = $userManager; |
||
| 128 | $this->shareManager = $shareManager; |
||
| 129 | |||
| 130 | $this->configService = $configService; |
||
| 131 | $this->localFilesService = $localFilesService; |
||
| 132 | $this->externalFilesService = $externalFilesService; |
||
| 133 | $this->groupFoldersService = $groupFoldersService; |
||
| 134 | |||
| 135 | $this->miscService = $miscService; |
||
| 136 | } |
||
| 137 | |||
| 138 | |||
| 139 | /** |
||
| 140 | * @param Runner $runner |
||
| 141 | * @param string $userId |
||
| 142 | * |
||
| 143 | * @return FilesDocument[] |
||
| 144 | * @throws InterruptException |
||
| 145 | * @throws InvalidPathException |
||
| 146 | * @throws NotFoundException |
||
| 147 | * @throws TickDoesNotExistException |
||
| 148 | */ |
||
| 149 | public function getFilesFromUser(Runner $runner, $userId) { |
||
| 160 | |||
| 161 | |||
| 162 | /** |
||
| 163 | * @param string $userId |
||
| 164 | */ |
||
| 165 | private function initFileSystems($userId) { |
||
| 166 | if ($userId === '') { |
||
| 167 | return; |
||
| 168 | } |
||
| 169 | |||
| 170 | $this->externalFilesService->initExternalFilesForUser($userId); |
||
| 171 | $this->groupFoldersService->initGroupSharesForUser($userId); |
||
| 172 | } |
||
| 173 | |||
| 174 | |||
| 175 | /** |
||
| 176 | * @param Runner $runner |
||
| 177 | * @param string $userId |
||
| 178 | * @param Folder $node |
||
| 179 | * |
||
| 180 | * @return FilesDocument[] |
||
| 181 | * @throws InterruptException |
||
| 182 | * @throws InvalidPathException |
||
| 183 | * @throws NotFoundException |
||
| 184 | * @throws TickDoesNotExistException |
||
| 185 | */ |
||
| 186 | public function getFilesFromDirectory(Runner $runner, $userId, Folder $node) { |
||
| 187 | $documents = []; |
||
| 188 | |||
| 189 | try { |
||
| 190 | if ($node->nodeExists('.noindex')) { |
||
| 191 | return $documents; |
||
| 192 | } |
||
| 193 | } catch (StorageNotAvailableException $e) { |
||
|
|
|||
| 194 | return $documents; |
||
| 195 | } |
||
| 196 | |||
| 197 | $files = $node->getDirectoryListing(); |
||
| 198 | foreach ($files as $file) { |
||
| 199 | $runner->update('getFilesFromDirectory'); |
||
| 200 | |||
| 201 | try { |
||
| 202 | $documents[] = $this->generateFilesDocumentFromFile($file, $userId); |
||
| 203 | } catch (FileIsNotIndexableException $e) { |
||
| 204 | continue; |
||
| 205 | } |
||
| 206 | |||
| 207 | if ($file->getType() === FileInfo::TYPE_FOLDER) { |
||
| 208 | /** @var $file Folder */ |
||
| 209 | $documents = |
||
| 210 | array_merge($documents, $this->getFilesFromDirectory($runner, $userId, $file)); |
||
| 211 | } |
||
| 212 | } |
||
| 213 | |||
| 214 | return $documents; |
||
| 215 | } |
||
| 216 | |||
| 217 | |||
| 218 | /** |
||
| 219 | * @param Node $file |
||
| 220 | * |
||
| 221 | * @param string $viewerId |
||
| 222 | * |
||
| 223 | * @return FilesDocument |
||
| 224 | * @throws FileIsNotIndexableException |
||
| 225 | * @throws InvalidPathException |
||
| 226 | * @throws NotFoundException |
||
| 227 | * @throws Exception |
||
| 228 | */ |
||
| 229 | private function generateFilesDocumentFromFile(Node $file, $viewerId) { |
||
| 230 | |||
| 231 | $source = $this->getFileSource($file); |
||
| 232 | $document = new FilesDocument(FilesProvider::FILES_PROVIDER_ID, $file->getId()); |
||
| 233 | |||
| 234 | $ownerId = ''; |
||
| 235 | if ($file->getOwner() !== null) { |
||
| 236 | $ownerId = $file->getOwner() |
||
| 237 | ->getUID(); |
||
| 238 | } |
||
| 239 | |||
| 240 | $document->setType($file->getType()) |
||
| 241 | ->setSource($source) |
||
| 242 | ->setOwnerId($ownerId) |
||
| 243 | ->setPath($this->getPathFromViewerId($file->getId(), $viewerId)) |
||
| 244 | ->setViewerId($viewerId) |
||
| 245 | ->setModifiedTime($file->getMTime()) |
||
| 246 | ->setMimetype($file->getMimetype()); |
||
| 247 | |||
| 248 | return $document; |
||
| 249 | } |
||
| 250 | |||
| 251 | |||
| 252 | /** |
||
| 253 | * @param Node $file |
||
| 254 | * |
||
| 255 | * @return string |
||
| 256 | * @throws FileIsNotIndexableException |
||
| 257 | * @throws NotFoundException |
||
| 258 | */ |
||
| 259 | private function getFileSource(Node $file) { |
||
| 272 | |||
| 273 | |||
| 274 | /** |
||
| 275 | * @param string $userId |
||
| 276 | * @param string $path |
||
| 277 | * |
||
| 278 | * @return Node |
||
| 279 | * @throws NotFoundException |
||
| 280 | */ |
||
| 281 | public function getFileFromPath($userId, $path) { |
||
| 285 | |||
| 286 | |||
| 287 | /** |
||
| 288 | * @param string $userId |
||
| 289 | * @param int $fileId |
||
| 290 | * |
||
| 291 | * @return Node |
||
| 292 | * @throws FilesNotFoundException |
||
| 293 | * @throws EmptyUserException |
||
| 294 | */ |
||
| 295 | public function getFileFromId($userId, $fileId) { |
||
| 296 | |||
| 297 | if ($userId === '') { |
||
| 298 | throw new EmptyUserException(); |
||
| 299 | } |
||
| 300 | |||
| 301 | $files = $this->rootFolder->getUserFolder($userId) |
||
| 302 | ->getById($fileId); |
||
| 303 | if (sizeof($files) === 0) { |
||
| 304 | throw new FilesNotFoundException(); |
||
| 305 | } |
||
| 306 | |||
| 307 | $file = array_shift($files); |
||
| 308 | |||
| 309 | return $file; |
||
| 310 | } |
||
| 311 | |||
| 312 | |||
| 313 | /** |
||
| 314 | * @param Index $index |
||
| 315 | * |
||
| 316 | * @return Node |
||
| 317 | * @throws EmptyUserException |
||
| 318 | * @throws FilesNotFoundException |
||
| 319 | */ |
||
| 320 | public function getFileFromIndex(Index $index) { |
||
| 325 | |||
| 326 | |||
| 327 | /** |
||
| 328 | * @param int $fileId |
||
| 329 | * @param string $viewerId |
||
| 330 | * |
||
| 331 | * @throws Exception |
||
| 332 | * @return string |
||
| 333 | */ |
||
| 334 | private function getPathFromViewerId($fileId, $viewerId) { |
||
| 350 | |||
| 351 | |||
| 352 | /** |
||
| 353 | * @param FilesDocument[] $documents |
||
| 354 | * |
||
| 355 | * @return FilesDocument[] |
||
| 356 | */ |
||
| 357 | public function generateDocuments($documents) { |
||
| 358 | |||
| 359 | $index = []; |
||
| 360 | |||
| 361 | foreach ($documents as $document) { |
||
| 362 | if (!($document instanceof FilesDocument)) { |
||
| 363 | continue; |
||
| 364 | } |
||
| 365 | |||
| 366 | try { |
||
| 367 | $this->updateFilesDocument($document); |
||
| 368 | } catch (Exception $e) { |
||
| 369 | // TODO - update $document with a error status instead of just ignore ! |
||
| 370 | $document->getIndex() |
||
| 371 | ->setStatus(Index::INDEX_IGNORE); |
||
| 372 | echo 'Exception: ' . json_encode($e->getTrace()) . ' - ' . $e->getMessage() |
||
| 373 | . "\n"; |
||
| 374 | } |
||
| 375 | |||
| 376 | $index[] = $document; |
||
| 377 | } |
||
| 378 | |||
| 379 | return $index; |
||
| 380 | } |
||
| 381 | |||
| 382 | |||
| 383 | /** |
||
| 384 | * @param Index $index |
||
| 385 | * |
||
| 386 | * @return FilesDocument |
||
| 387 | * @throws FileIsNotIndexableException |
||
| 388 | * @throws InvalidPathException |
||
| 389 | * @throws NotFoundException |
||
| 390 | * @throws NotPermittedException |
||
| 391 | */ |
||
| 392 | private function generateDocumentFromIndex(Index $index) { |
||
| 393 | |||
| 394 | try { |
||
| 395 | $file = $this->getFileFromIndex($index); |
||
| 396 | } catch (Exception $e) { |
||
| 397 | $index->setStatus(Index::INDEX_REMOVE); |
||
| 398 | $document = new FilesDocument($index->getProviderId(), $index->getDocumentId()); |
||
| 399 | $document->setIndex($index); |
||
| 400 | |||
| 401 | return $document; |
||
| 402 | } |
||
| 403 | |||
| 404 | $document = $this->generateFilesDocumentFromFile($file, $index->getOwnerId()); |
||
| 405 | $document->setIndex($index); |
||
| 406 | |||
| 407 | $this->updateFilesDocumentFromFile($document, $file); |
||
| 408 | |||
| 409 | return $document; |
||
| 410 | } |
||
| 411 | |||
| 412 | |||
| 413 | /** |
||
| 414 | * @param IndexDocument $document |
||
| 415 | * |
||
| 416 | * @return bool |
||
| 417 | */ |
||
| 418 | public function isDocumentUpToDate($document) { |
||
| 419 | $index = $document->getIndex(); |
||
| 420 | |||
| 421 | if (!$this->configService->compareIndexOptions($index)) { |
||
| 422 | $index->setStatus(Index::INDEX_CONTENT); |
||
| 423 | $document->setIndex($index); |
||
| 424 | |||
| 425 | return false; |
||
| 426 | } |
||
| 427 | |||
| 428 | if ($index->getStatus() !== Index::INDEX_OK) { |
||
| 429 | return false; |
||
| 430 | } |
||
| 431 | |||
| 432 | if ($index->getLastIndex() >= $document->getModifiedTime()) { |
||
| 433 | return true; |
||
| 434 | } |
||
| 435 | |||
| 436 | return false; |
||
| 437 | } |
||
| 438 | |||
| 439 | |||
| 440 | /** |
||
| 441 | * @param Index $index |
||
| 442 | * |
||
| 443 | * @return FilesDocument |
||
| 444 | * @throws InvalidPathException |
||
| 445 | * @throws NotFoundException |
||
| 446 | * @throws NotPermittedException |
||
| 447 | */ |
||
| 448 | public function updateDocument(Index $index) { |
||
| 449 | $this->impersonateOwner($index); |
||
| 450 | $this->initFileSystems($index->getOwnerId()); |
||
| 451 | |||
| 452 | try { |
||
| 453 | $document = $this->generateDocumentFromIndex($index); |
||
| 454 | |||
| 455 | return $document; |
||
| 456 | } catch (FileIsNotIndexableException $e) { |
||
| 457 | return null; |
||
| 458 | } |
||
| 459 | } |
||
| 460 | |||
| 461 | |||
| 462 | /** |
||
| 463 | * @param FilesDocument $document |
||
| 464 | * |
||
| 465 | * @throws InvalidPathException |
||
| 466 | * @throws NotFoundException |
||
| 467 | * @throws NotPermittedException |
||
| 468 | */ |
||
| 469 | private function updateFilesDocument(FilesDocument $document) { |
||
| 480 | |||
| 481 | |||
| 482 | /** |
||
| 483 | * @param FilesDocument $document |
||
| 484 | * @param Node $file |
||
| 485 | * |
||
| 486 | * @throws InvalidPathException |
||
| 487 | * @throws NotFoundException |
||
| 488 | * @throws NotPermittedException |
||
| 489 | */ |
||
| 490 | private function updateFilesDocumentFromFile(FilesDocument $document, Node $file) { |
||
| 491 | |||
| 492 | $document->getIndex() |
||
| 493 | ->setSource($document->getSource()); |
||
| 494 | |||
| 495 | $this->updateDocumentAccess($document, $file); |
||
| 496 | $this->updateContentFromFile($document, $file); |
||
| 497 | |||
| 498 | $document->addTag($document->getSource()); |
||
| 499 | } |
||
| 500 | |||
| 501 | |||
| 502 | /** |
||
| 503 | * @param FilesDocument $document |
||
| 504 | * @param Node $file |
||
| 505 | */ |
||
| 506 | private function updateDocumentAccess(FilesDocument $document, Node $file) { |
||
| 521 | |||
| 522 | |||
| 523 | /** |
||
| 524 | * @param FilesDocument $document |
||
| 525 | * @param Node $file |
||
| 526 | * |
||
| 527 | * @throws InvalidPathException |
||
| 528 | * @throws NotFoundException |
||
| 529 | * @throws NotPermittedException |
||
| 530 | */ |
||
| 531 | private function updateContentFromFile(FilesDocument $document, Node $file) { |
||
| 555 | |||
| 556 | |||
| 557 | /** |
||
| 558 | * @param FilesDocument $document |
||
| 559 | * @param Node $file |
||
| 560 | * |
||
| 561 | * @return array |
||
| 562 | */ |
||
| 563 | private function updateShareNames(FilesDocument $document, Node $file) { |
||
| 592 | |||
| 593 | |||
| 594 | /** |
||
| 595 | * @param string $mimeType |
||
| 596 | * |
||
| 597 | * @return string |
||
| 598 | */ |
||
| 599 | private function parseMimeType($mimeType) { |
||
| 611 | |||
| 612 | |||
| 613 | /** |
||
| 614 | * @param string $mimeType |
||
| 615 | * @param string $parsed |
||
| 616 | * |
||
| 617 | * @throws KnownFileMimeTypeException |
||
| 618 | */ |
||
| 619 | private function parseMimeTypeText($mimeType, &$parsed) { |
||
| 637 | |||
| 638 | |||
| 639 | /** |
||
| 640 | * @param string $mimeType |
||
| 641 | * @param string $parsed |
||
| 642 | * |
||
| 643 | * @throws KnownFileMimeTypeException |
||
| 644 | */ |
||
| 645 | private function parseMimeTypePDF($mimeType, &$parsed) { |
||
| 652 | |||
| 653 | |||
| 654 | /** |
||
| 655 | * @param string $mimeType |
||
| 656 | * @param string $parsed |
||
| 657 | * |
||
| 658 | * @throws KnownFileMimeTypeException |
||
| 659 | */ |
||
| 660 | private function parseMimeTypeOffice($mimeType, &$parsed) { |
||
| 679 | |||
| 680 | |||
| 681 | /** |
||
| 682 | * @param FilesDocument $document |
||
| 683 | * @param File $file |
||
| 684 | * |
||
| 685 | * @throws NotPermittedException |
||
| 686 | */ |
||
| 687 | private function extractContentFromFileText(FilesDocument $document, File $file) { |
||
| 701 | |||
| 702 | |||
| 703 | /** |
||
| 704 | * @param FilesDocument $document |
||
| 705 | * @param File $file |
||
| 706 | * |
||
| 707 | * @throws NotPermittedException |
||
| 708 | */ |
||
| 709 | View Code Duplication | private function extractContentFromFilePDF(FilesDocument $document, File $file) { |
|
| 729 | |||
| 730 | |||
| 731 | /** |
||
| 732 | * @param FilesDocument $document |
||
| 733 | * @param File $file |
||
| 734 | * |
||
| 735 | * @throws NotPermittedException |
||
| 736 | */ |
||
| 737 | View Code Duplication | private function extractContentFromFileOffice(FilesDocument $document, File $file) { |
|
| 757 | |||
| 758 | |||
| 759 | /** |
||
| 760 | * @param FilesDocument $document |
||
| 761 | * @param File $file |
||
| 762 | */ |
||
| 763 | private function extractContentFromFileOCR(FilesDocument $document, File $file) { |
||
| 775 | |||
| 776 | |||
| 777 | /** |
||
| 778 | * @param FilesDocument $document |
||
| 779 | * @param File $file |
||
| 780 | */ |
||
| 781 | private function extractContentUsingTesseractOCR(FilesDocument $document, File $file) { |
||
| 802 | |||
| 803 | |||
| 804 | /** |
||
| 805 | * @param FilesDocument $document |
||
| 806 | * |
||
| 807 | * @return bool |
||
| 808 | */ |
||
| 809 | private function isSourceIndexable(FilesDocument $document) { |
||
| 819 | |||
| 820 | |||
| 821 | private function impersonateOwner(Index $index) { |
||
| 829 | |||
| 830 | } |
||
| 831 | |||
| 832 |
Loading history...
Scrutinizer analyzes your
composer.json/composer.lockfile if available to determine the classes, and functions that are defined by your dependencies.It seems like the listed class was neither found in your dependencies, nor was it found in the analyzed files in your repository. If you are using some other form of dependency management, you might want to disable this analysis.