IndexService - Code Metrics - Inspection of "up-to-date document in provider" - nextcloud/fulltextsearch - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 93bf15...69947f )

by Maxence

created 2018-01-13 11:09 UTC

IndexService B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	360
Duplicated Lines	2.78 %

Coupling/Cohesion

Components	1
Dependencies	12

Importance

Changes

Metric	Value
wmc	40
c	0
b	0
f	0
lcom	1
cbo	12
dl	10
loc	360
rs	8.2608

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	10	10	1
A	setRunner()	0	3	1
A	updateRunner()	0	7	2
A	indexProviderContentFromUser()	0	11	1
B	updateDocumentsWithCurrIndex()	0	23	4
A	isDocumentUpToDate()	0	13	4
A	getProviderIndexFromProvider()	0	5	1
B	indexChunks()	0	24	5
A	indexChunk()	0	12	2
A	filterDocumentsToIndex()	0	13	3
A	updateDocument()	0	13	2
A	updateIndexes()	0	10	3
A	updateIndex()	0	19	4
A	updateIndexStatus()	0	11	2
A	getIndex()	0	3	1
A	getQueuedIndexes()	0	3	1
A	resetIndex()	0	19	3

How to fix Duplicated Code Complexity

Duplicated Code

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:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like IndexService 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 IndexService, and based on these observations, apply Extract Interface, too.

<?php
/**
 * FullTextSearch - Full text search framework for Nextcloud
 *
 * This file is licensed under the Affero General Public License version 3 or
 * later. See the COPYING file.
 *
 * @author Maxence Lange <[email protected]>
 * @copyright 2018
 * @license GNU AGPL version 3 or any later version
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

namespace OCA\FullTextSearch\Service;

use Exception;
use OCA\FullTextSearch\Db\IndexesRequest;
use OCA\FullTextSearch\Exceptions\DatabaseException;
use OCA\FullTextSearch\Exceptions\IndexDoesNotExistException;
use OCA\FullTextSearch\Exceptions\InterruptException;
use OCA\FullTextSearch\Exceptions\NoResultException;
use OCA\FullTextSearch\Exceptions\TickDoesNotExistException;
use OCA\FullTextSearch\IFullTextSearchPlatform;
use OCA\FullTextSearch\IFullTextSearchProvider;
use OCA\FullTextSearch\Model\ExtendedIndex;
use OCA\FullTextSearch\Model\Index;
use OCA\FullTextSearch\Model\IndexDocument;
use OCA\FullTextSearch\Model\ProviderIndexes;
use OCA\FullTextSearch\Model\Runner;

class IndexService {

	/** @var IndexesRequest */
	private $indexesRequest;

	/** @var ConfigService */
	private $configService;

	/** @var ProviderService */
	private $providerService;

	/** @var PlatformService */
	private $platformService;

	/** @var MiscService */
	private $miscService;


	/** @var Runner */
	private $runner = null;

	/**
	 * IndexService constructor.
	 *
	 * @param IndexesRequest $indexesRequest
	 * @param ConfigService $configService
	 * @param ProviderService $providerService
	 * @param PlatformService $platformService
	 * @param MiscService $miscService
	 */
	public function __construct(

		IndexesRequest $indexesRequest, ConfigService $configService, ProviderService $providerService,
		PlatformService $platformService, MiscService $miscService
	) {
		$this->indexesRequest = $indexesRequest;
		$this->configService = $configService;
		$this->providerService = $providerService;
		$this->platformService = $platformService;
		$this->miscService = $miscService;
	}


	/**
	 * @param Runner $runner
	 */
	public function setRunner(Runner $runner) {
		$this->runner = $runner;
	}


	/**
	 * @param $action
	 *
	 * @throws InterruptException
	 * @throws TickDoesNotExistException
	 */
	private function updateRunner($action) {
		if ($this->runner === null) {
			return;
		}

		$this->runner->update($action);
	}


	/**
	 * @param IFullTextSearchPlatform $platform
	 * @param IFullTextSearchProvider $provider
	 * @param string $userId
	 *
	 * @throws Exception
	 */
	public function indexProviderContentFromUser(
		IFullTextSearchPlatform $platform, IFullTextSearchProvider $provider, $userId
	) {
		$this->updateRunner('generateIndex' . $provider->getName());
		$documents = $provider->generateIndexableDocuments($userId);

		//$maxSize = sizeof($documents);


		$toIndex = $this->updateDocumentsWithCurrIndex($provider, $documents);
		$this->indexChunks($platform, $provider, $toIndex);
	}


	/**
	 * @param IFullTextSearchProvider $provider
	 * @param IndexDocument[] $documents
	 *
	 * @return IndexDocument[]
	 * @throws InterruptException
	 * @throws TickDoesNotExistException
	 */
	private function updateDocumentsWithCurrIndex(IFullTextSearchProvider $provider, array $documents) {


		$currIndex = $this->getProviderIndexFromProvider($provider);
		$result = [];
		foreach ($documents as $document) {
			$this->updateRunner('compareWithCurrentIndex');

			$index = $currIndex->getIndex($document->getId());
			if ($index === null) {
				$index = new Index($document->getProviderId(), $document->getId());
				$index->setStatus(Index::INDEX_FULL);
				$index->setLastIndex();
			}

			$document->setIndex($index);
			if (!$this->isDocumentUpToDate($provider, $document)) {
				$result[] = $document;
			}

		}

		return $result;
	}


	/**
	 * @param IFullTextSearchProvider $provider
	 * @param IndexDocument $document
	 *
	 * @return bool
	 */
	private function isDocumentUpToDate(IFullTextSearchProvider $provider, IndexDocument $document) {
		$index = $document->getIndex();

		if (!$index->isStatus(Index::INDEX_OK)) {
			return false;
		}

		if ($index->isStatus(Index::INDEX_META) || $index->isStatus(Index::INDEX_CONTENT)) {
			return false;
		}

		return $provider->isDocumentUpToDate($document);
	}


	/**
	 * @param IFullTextSearchProvider $provider
	 *
	 * @return ProviderIndexes
	 */
	private function getProviderIndexFromProvider(IFullTextSearchProvider $provider) {
		$indexes = $this->indexesRequest->getIndexesFromProvider($provider);

		return new ProviderIndexes($indexes);
	}


	/**
	 * @param IFullTextSearchPlatform $platform
	 * @param IFullTextSearchProvider $provider
	 * @param IndexDocument[] $documents
	 *
	 * @throws Exception
	 */
	private function indexChunks(
		IFullTextSearchPlatform $platform, IFullTextSearchProvider $provider, $documents
	) {
		$chunkSize = $this->configService->getAppValue(ConfigService::CHUNK_INDEX);

		$max = sizeof($documents);
		for ($i = 0; $i < $max; $i++) {

			$this->updateRunner('indexChunk');
			try {
				$chunk = array_splice($documents, 0, $chunkSize);
				$this->indexChunk($platform, $provider, $chunk);

				/** @var IndexDocument $doc */
				foreach ($chunk as $doc) {
					$doc->__destruct(); // because.
				}
			} catch (NoResultException $e) {
				return;
			} catch (Exception $e) {
				throw $e;
			}
		}
	}


	/**
	 * @param IFullTextSearchPlatform $platform
	 * @param IFullTextSearchProvider $provider
	 * @param IndexDocument[] $chunk
	 *
	 * @throws NoResultException
	 * @throws DatabaseException
	 */
	private function indexChunk(
		IFullTextSearchPlatform $platform, IFullTextSearchProvider $provider, $chunk
	) {
		if (sizeof($chunk) === 0) {
			throw new NoResultException();
		}

		$documents = $provider->fillIndexDocuments($chunk);
		$toIndex = $this->filterDocumentsToIndex($documents);
		$indexes = $platform->indexDocuments($provider, $toIndex);
		$this->updateIndexes($indexes);
	}


	/**
	 * @param IndexDocument[] $documents
	 *
	 * @return array
	 */
	private function filterDocumentsToIndex($documents) {
		$toIndex = [];
		foreach ($documents as $document) {
			// TODO - rework the index/not_index
//			echo '==st==' . $document->getIndex()->getStatus() . "\n";
			if (!$document->getIndex()
						  ->isStatus(Index::INDEX_IGNORE)) {
				$toIndex[] = $document;
			}
		}

		return $toIndex;
	}


	/**
	 * @param IFullTextSearchPlatform $platform
	 * @param IFullTextSearchProvider $provider
	 * @param Index $index
	 *
	 * @internal param int|string $documentId
	 * @throws Exception
	 */
	public function updateDocument(
		IFullTextSearchPlatform $platform, IFullTextSearchProvider $provider, Index $index
	) {
		$document = $provider->updateDocument($index);
		if ($document === null) {
			$this->indexesRequest->deleteIndex($index);

			return;
		}

		$index = $platform->indexDocument($provider, $document);
		$this->updateIndex($index);
	}


	/**
	 * @param Index[] $indexes
	 *
	 * @throws DatabaseException
	 */
	public function updateIndexes($indexes) {

		try {
			foreach ($indexes as $index) {
				$this->updateIndex($index);
			}
		} catch (Exception $e) {
			throw new DatabaseException($e->getMessage());
		}
	}


	/**
	 * @param Index $index
	 *
	 * @throws Exception
	 */
	private function updateIndex(Index $index) {

		if ($index->isStatus(Index::INDEX_REMOVE)) {

			if ($index->isStatus(Index::INDEX_OK)) {
				$this->indexesRequest->deleteIndex($index);

				return;
			}
			$index->setStatus(Index::INDEX_FAILED);
			$this->indexesRequest->update($index);

			return;
		}

		if (!$this->indexesRequest->update($index)) {
			$this->indexesRequest->create($index);
		}
	}


	/**
	 * @param string $providerId
	 * @param string|int $documentId
	 * @param int $status
	 * @param bool $reset
	 *
	 * @throws DatabaseException
	 */
	public function updateIndexStatus($providerId, $documentId, $status, $reset = false) {

		try {
			$curr = $this->getIndex($providerId, $documentId);
		} catch (IndexDoesNotExistException $e) {
			$curr = new Index($providerId, $documentId);
			$curr->setStatus(Index::INDEX_FULL);
		}

		$curr->setStatus($status);
		$this->updateIndexes([$curr]);
	}


	/**
	 * @param string $providerId
	 * @param string|int $documentId
	 *
	 * @return ExtendedIndex
	 * @throws IndexDoesNotExistException
	 */
	public function getIndex($providerId, $documentId) {
		return $this->indexesRequest->getIndex($providerId, $documentId);
	}


	/**
	 * @return Index[]
	 */
	public function getQueuedIndexes() {
		return $this->indexesRequest->getQueuedIndexes();
	}


	/**
	 * @param string $providerId
	 *
	 * @throws Exception
	 */
	public function resetIndex($providerId = '') {
		$platform = $this->platformService->getPlatform();

		if ($providerId === '') {
			$platform->removeIndex(null);
			$this->providerService->setProvidersAsNotIndexed();
			$this->indexesRequest->reset();

			return;
		} else {
			$providers = [$this->providerService->getProvider($providerId)];
		}

		foreach ($providers AS $provider) {
			$platform->removeIndex($provider);
			$this->providerService->setProviderAsIndexed($provider, false);
			$this->indexesRequest->deleteFromProviderId($provider->getId());
		}
	}


}

1		<?php
2		/**
3		* FullTextSearch - Full text search framework for Nextcloud
4		*
5		* This file is licensed under the Affero General Public License version 3 or
6		* later. See the COPYING file.
7		*
8		* @author Maxence Lange <[email protected]>
9		* @copyright 2018
10		* @license GNU AGPL version 3 or any later version
11		*
12		* This program is free software: you can redistribute it and/or modify
13		* it under the terms of the GNU Affero General Public License as
14		* published by the Free Software Foundation, either version 3 of the
15		* License, or (at your option) any later version.
16		*
17		* This program is distributed in the hope that it will be useful,
18		* but WITHOUT ANY WARRANTY; without even the implied warranty of
19		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20		* GNU Affero General Public License for more details.
21		*
22		* You should have received a copy of the GNU Affero General Public License
23		* along with this program. If not, see <http://www.gnu.org/licenses/>.
24		*
25		*/
26
27		namespace OCA\FullTextSearch\Service;
28
29		use Exception;
30		use OCA\FullTextSearch\Db\IndexesRequest;
31		use OCA\FullTextSearch\Exceptions\DatabaseException;
32		use OCA\FullTextSearch\Exceptions\IndexDoesNotExistException;
33		use OCA\FullTextSearch\Exceptions\InterruptException;
34		use OCA\FullTextSearch\Exceptions\NoResultException;
35		use OCA\FullTextSearch\Exceptions\TickDoesNotExistException;
36		use OCA\FullTextSearch\IFullTextSearchPlatform;
37		use OCA\FullTextSearch\IFullTextSearchProvider;
38		use OCA\FullTextSearch\Model\ExtendedIndex;
39		use OCA\FullTextSearch\Model\Index;
40		use OCA\FullTextSearch\Model\IndexDocument;
41		use OCA\FullTextSearch\Model\ProviderIndexes;
42		use OCA\FullTextSearch\Model\Runner;
43
44		class IndexService {
45
46		/** @var IndexesRequest */
47		private $indexesRequest;
48
49		/** @var ConfigService */
50		private $configService;
51
52		/** @var ProviderService */
53		private $providerService;
54
55		/** @var PlatformService */
56		private $platformService;
57
58		/** @var MiscService */
59		private $miscService;
60
61
62		/** @var Runner */
63		private $runner = null;
64
65		/**
66		* IndexService constructor.
67		*
68		* @param IndexesRequest $indexesRequest
69		* @param ConfigService $configService
70		* @param ProviderService $providerService
71		* @param PlatformService $platformService
72		* @param MiscService $miscService
73		*/
74	View Code Duplication	public function __construct(
		0 ignored issues – show Duplication introduced 2018-01-10 22:09 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
75		IndexesRequest $indexesRequest, ConfigService $configService, ProviderService $providerService,
76		PlatformService $platformService, MiscService $miscService
77		) {
78		$this->indexesRequest = $indexesRequest;
79		$this->configService = $configService;
80		$this->providerService = $providerService;
81		$this->platformService = $platformService;
82		$this->miscService = $miscService;
83		}
84
85
86		/**
87		* @param Runner $runner
88		*/
89		public function setRunner(Runner $runner) {
90		$this->runner = $runner;
91		}
92
93
94		/**
95		* @param $action
96		*
97		* @throws InterruptException
98		* @throws TickDoesNotExistException
99		*/
100		private function updateRunner($action) {
101		if ($this->runner === null) {
102		return;
103		}
104
105		$this->runner->update($action);
106		}
107
108
109		/**
110		* @param IFullTextSearchPlatform $platform
111		* @param IFullTextSearchProvider $provider
112		* @param string $userId
113		*
114		* @throws Exception
115		*/
116		public function indexProviderContentFromUser(
117		IFullTextSearchPlatform $platform, IFullTextSearchProvider $provider, $userId
118		) {
119		$this->updateRunner('generateIndex' . $provider->getName());
120		$documents = $provider->generateIndexableDocuments($userId);
121
122		//$maxSize = sizeof($documents);
		0 ignored issues – show Unused Code Comprehensibility introduced 2018-01-10 22:09 UTC by Report Bug Copy Issue Report `56%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
123
124		$toIndex = $this->updateDocumentsWithCurrIndex($provider, $documents);
125		$this->indexChunks($platform, $provider, $toIndex);
126		}
127
128
129		/**
130		* @param IFullTextSearchProvider $provider
131		* @param IndexDocument[] $documents
132		*
133		* @return IndexDocument[]
134		* @throws InterruptException
135		* @throws TickDoesNotExistException
136		*/
137		private function updateDocumentsWithCurrIndex(IFullTextSearchProvider $provider, array $documents) {
		0 ignored issues – show Coding Style introduced 2018-01-13 11:11 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 100 characters; contains 101 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
138
139		$currIndex = $this->getProviderIndexFromProvider($provider);
140		$result = [];
141		foreach ($documents as $document) {
142		$this->updateRunner('compareWithCurrentIndex');
143
144		$index = $currIndex->getIndex($document->getId());
145		if ($index === null) {
146		$index = new Index($document->getProviderId(), $document->getId());
147		$index->setStatus(Index::INDEX_FULL);
148		$index->setLastIndex();
149		}
150
151		$document->setIndex($index);
152		if (!$this->isDocumentUpToDate($provider, $document)) {
153		$result[] = $document;
154		}
155
156		}
157
158		return $result;
159		}
160
161
162		/**
163		* @param IFullTextSearchProvider $provider
164		* @param IndexDocument $document
165		*
166		* @return bool
167		*/
168		private function isDocumentUpToDate(IFullTextSearchProvider $provider, IndexDocument $document) {
169		$index = $document->getIndex();
170
171		if (!$index->isStatus(Index::INDEX_OK)) {
172		return false;
173		}
174
175		if ($index->isStatus(Index::INDEX_META) \|\| $index->isStatus(Index::INDEX_CONTENT)) {
176		return false;
177		}
178
179		return $provider->isDocumentUpToDate($document);
180		}
181
182
183		/**
184		* @param IFullTextSearchProvider $provider
185		*
186		* @return ProviderIndexes
187		*/
188		private function getProviderIndexFromProvider(IFullTextSearchProvider $provider) {
189		$indexes = $this->indexesRequest->getIndexesFromProvider($provider);
190
191		return new ProviderIndexes($indexes);
192		}
193
194
195		/**
196		* @param IFullTextSearchPlatform $platform
197		* @param IFullTextSearchProvider $provider
198		* @param IndexDocument[] $documents
199		*
200		* @throws Exception
201		*/
202		private function indexChunks(
203		IFullTextSearchPlatform $platform, IFullTextSearchProvider $provider, $documents
204		) {
205		$chunkSize = $this->configService->getAppValue(ConfigService::CHUNK_INDEX);
206
207		$max = sizeof($documents);
208		for ($i = 0; $i < $max; $i++) {
209
210		$this->updateRunner('indexChunk');
211		try {
212		$chunk = array_splice($documents, 0, $chunkSize);
213		$this->indexChunk($platform, $provider, $chunk);
214
215		/** @var IndexDocument $doc */
216		foreach ($chunk as $doc) {
217		$doc->__destruct(); // because.
218		}
219		} catch (NoResultException $e) {
220		return;
221		} catch (Exception $e) {
222		throw $e;
223		}
224		}
225		}
226
227
228		/**
229		* @param IFullTextSearchPlatform $platform
230		* @param IFullTextSearchProvider $provider
231		* @param IndexDocument[] $chunk
232		*
233		* @throws NoResultException
234		* @throws DatabaseException
235		*/
236		private function indexChunk(
237		IFullTextSearchPlatform $platform, IFullTextSearchProvider $provider, $chunk
238		) {
239		if (sizeof($chunk) === 0) {
240		throw new NoResultException();
241		}
242
243		$documents = $provider->fillIndexDocuments($chunk);
244		$toIndex = $this->filterDocumentsToIndex($documents);
245		$indexes = $platform->indexDocuments($provider, $toIndex);
246		$this->updateIndexes($indexes);
247		}
248
249
250		/**
251		* @param IndexDocument[] $documents
252		*
253		* @return array
254		*/
255		private function filterDocumentsToIndex($documents) {
256		$toIndex = [];
257		foreach ($documents as $document) {
258		// TODO - rework the index/not_index
259		// echo '==st==' . $document->getIndex()->getStatus() . "\n";
260		if (!$document->getIndex()
261		->isStatus(Index::INDEX_IGNORE)) {
262		$toIndex[] = $document;
263		}
264		}
265
266		return $toIndex;
267		}
268
269
270		/**
271		* @param IFullTextSearchPlatform $platform
272		* @param IFullTextSearchProvider $provider
273		* @param Index $index
274		*
275		* @internal param int\|string $documentId
276		* @throws Exception
277		*/
278		public function updateDocument(
279		IFullTextSearchPlatform $platform, IFullTextSearchProvider $provider, Index $index
280		) {
281		$document = $provider->updateDocument($index);
282		if ($document === null) {
283		$this->indexesRequest->deleteIndex($index);
284
285		return;
286		}
287
288		$index = $platform->indexDocument($provider, $document);
289		$this->updateIndex($index);
290		}
291
292
293		/**
294		* @param Index[] $indexes
295		*
296		* @throws DatabaseException
297		*/
298		public function updateIndexes($indexes) {
299
300		try {
301		foreach ($indexes as $index) {
302		$this->updateIndex($index);
303		}
304		} catch (Exception $e) {
305		throw new DatabaseException($e->getMessage());
306		}
307		}
308
309
310		/**
311		* @param Index $index
312		*
313		* @throws Exception
314		*/
315		private function updateIndex(Index $index) {
316
317		if ($index->isStatus(Index::INDEX_REMOVE)) {
318
319		if ($index->isStatus(Index::INDEX_OK)) {
320		$this->indexesRequest->deleteIndex($index);
321
322		return;
323		}
324		$index->setStatus(Index::INDEX_FAILED);
325		$this->indexesRequest->update($index);
326
327		return;
328		}
329
330		if (!$this->indexesRequest->update($index)) {
331		$this->indexesRequest->create($index);
332		}
333		}
334
335
336		/**
337		* @param string $providerId
338		* @param string\|int $documentId
339		* @param int $status
340		* @param bool $reset
341		*
342		* @throws DatabaseException
343		*/
344		public function updateIndexStatus($providerId, $documentId, $status, $reset = false) {
		0 ignored issues – show Unused Code introduced 2018-01-11 00:18 UTC by Report Bug Copy Issue Report The parameter `$reset` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
345		try {
346		$curr = $this->getIndex($providerId, $documentId);
347		} catch (IndexDoesNotExistException $e) {
348		$curr = new Index($providerId, $documentId);
349		$curr->setStatus(Index::INDEX_FULL);
350		}
351
352		$curr->setStatus($status);
353		$this->updateIndexes([$curr]);
354		}
355
356
357		/**
358		* @param string $providerId
359		* @param string\|int $documentId
360		*
361		* @return ExtendedIndex
362		* @throws IndexDoesNotExistException
363		*/
364		public function getIndex($providerId, $documentId) {
365		return $this->indexesRequest->getIndex($providerId, $documentId);
366		}
367
368
369		/**
370		* @return Index[]
371		*/
372		public function getQueuedIndexes() {
373		return $this->indexesRequest->getQueuedIndexes();
374		}
375
376
377		/**
378		* @param string $providerId
379		*
380		* @throws Exception
381		*/
382		public function resetIndex($providerId = '') {
383		$platform = $this->platformService->getPlatform();
384
385		if ($providerId === '') {
386		$platform->removeIndex(null);
387		$this->providerService->setProvidersAsNotIndexed();
388		$this->indexesRequest->reset();
389
390		return;
391		} else {
392		$providers = [$this->providerService->getProvider($providerId)];
393		}
394
395		foreach ($providers AS $provider) {
396		$platform->removeIndex($provider);
397		$this->providerService->setProviderAsIndexed($provider, false);
398		$this->indexesRequest->deleteFromProviderId($provider->getId());
399		}
400		}
401
402
403		}

nextcloud / fulltextsearch