AlgoliaManager::reindex() - Code Metrics - Inspection of "Simplify class name logic" - lordthorzonus/yii2-algolia - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b8a5e6...49b185 )

by Juuso

created 2016-09-06 12:33 UTC

AlgoliaManager::reindex() B

↳ Parent: AlgoliaManager

Complexity

Conditions	3
Paths	4

Size

Total Lines	37
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	21
CRAP Score	3

Importance

Changes	5
Bugs	1	Features	2

Metric	Value
c	5
b	1
f	2
dl	0
loc	37
ccs	21
cts	21
cp	1
rs	8.8571
cc	3
eloc	19
nc	4
nop	1
crap	3

<?php

namespace leinonen\Yii2Algolia;

use AlgoliaSearch\Client;
use AlgoliaSearch\Index;
use leinonen\Yii2Algolia\ActiveRecord\ActiveRecordFactory;

/**
 * @method setConnectTimeout(int $connectTimeout, int $timeout = 30, int $searchTimeout = 5)
 * @method enableRateLimitForward(string $adminAPIKey, string $endUserIP, string $rateLimitAPIKey)
 * @method setForwarderFor(string $ip)
 * @method setAlgoliaUserToken(string $token)
 * @method disableRateLimitForward()
 * @method isAlive()
 * @method setExtraHeader(string $key, string $value)
 * @method mixed multipleQueries(array $queries, string $indexNameKey = "indexName", string $strategy = "none")
 * @method mixed listIndexes()
 * @method deleteIndex(string $indexName)
 * @method mixed moveIndex(string $srcIndexName, string $dstIndexName)
 * @method mixed copyIndex(string $srcIndexName, string $dstIndexName)
 * @method mixed getLogs(int $offset = 0, int $length = 10, string $type = "all")
 * @method Index initIndex(string $indexName)
 * @method mixed listUserKeys()
 * @method mixed getUserKeyACL(string $key)
 * @method mixed deleteUserKey(string $key)
 * @method mixed addUserKey(array $obj, int $validity = 0, int $maxQueriesPerIPPerHour = 0, int $maxHitsPerQuery = 0, array $indexes = null)
 * @method mixed updateUserKey(string $key, array $obj, int $validity = 0, int $maxQueriesPerIPPerHour = 0, int $maxHitsPerQuery = 0, array $indexes = null)
 * @method mixed batch(array $requests)
 * @method string generateSecuredApiKey(string $privateApiKey, mixed $query, string $userToken = null)
 * @method string buildQuery(array $args)
 * @method mixed request(\AlgoliaSearch\ClientContext $context, string $method, string $path, array $params, array $data, array $hostsArray, int $connectTimeout, int $readTimeout)
 * @method mixed doRequest(\AlgoliaSearch\ClientContext $context, string $method, string $path, array $params, array $data, array $hostsArray, int $connectTimeout, int $readTimeout)
 * @method \AlgoliaSearch\PlacesIndex initPlaces(string $appId, string $appKey, array $hostsArray = null, array $options = [])
 * @see Client
 */
class AlgoliaManager
{
    /**
     * @var AlgoliaFactory
     */
    protected $factory;

    /**
     * @var AlgoliaConfig
     */
    protected $config;

    /**
     * @var Client
     */
    protected $client;

    /**
     * @var ActiveRecordFactory
     */
    protected $activeRecordFactory;

    /**
     * @var null|string
     */
    protected $env;

    /**
     * Initiates a new AlgoliaManager.
     *
     * @param Client $client
     * @param ActiveRecordFactory $activeRecordFactory
     *
     */
    public function __construct(Client $client, ActiveRecordFactory $activeRecordFactory)
    {
        $this->client = $client;
        $this->activeRecordFactory = $activeRecordFactory;
    }

    /**
     * Returns the Algolia Client.
     *
     * @return Client
     */
    public function getClient()
    {
        return $this->client;
    }

    /**
     * Sets the environment for the manager.
     *
     * @param string $env
     */
    public function setEnv($env)
    {
        $this->env = $env;
    }

    /**
     * Returns the environment for the manager.
     *
     * @return null|string
     */
    public function getEnv()
    {
        return $this->env;
    }

    /**
     * Indexes a searchable model to all indices.
     *
     * @param SearchableInterface $searchableModel
     *
     * @return array
     */
    public function pushToIndices(SearchableInterface $searchableModel)
    {
        $indices = $this->initIndices($searchableModel);
        $response = [];

        foreach ($indices as $index) {
            $record = $searchableModel->getAlgoliaRecord();
            $response[$index->indexName] = $index->addObject($record, $searchableModel->getObjectID());
        }

        return $response;
    }

    /**
     * Indexes multiple searchable models in a batch. The given searchable models must be of the same class.
     *
     * @param SearchableInterface[] $searchableModels
     *
     * @return array
     */
    public function pushMultipleToIndices(array $searchableModels)
    {
        list($indices, $algoliaRecords) = $this->getIndicesAndAlgoliaRecordsFromSearchableModelArray($searchableModels);
        $response = [];

        foreach ($indices as $index) {
            /* @var Index $index  */
            $response[$index->indexName] = $index->addObjects($algoliaRecords);
        }

        return $response;
    }

    /**
     * Updates the models data in all indices.
     *
     * @param SearchableInterface $searchableModel
     *
     * @return array
     */
    public function updateInIndices(SearchableInterface $searchableModel)
    {
        $indices = $this->initIndices($searchableModel);
        $response = [];

        foreach ($indices as $index) {
            $record = $searchableModel->getAlgoliaRecord();
            $record['objectID'] = $searchableModel->getObjectID();
            $response[$index->indexName] = $index->saveObject($record);
        }

        return $response;
    }

    /**
     * Updates multiple models data in all indices.  The given searchable models must be of the same class.
     *
     * @param SearchableInterface[] $searchableModels
     *
     * @return array
     */
    public function updateMultipleInIndices(array $searchableModels)
    {
        list($indices, $algoliaRecords) = $this->getIndicesAndAlgoliaRecordsFromSearchableModelArray($searchableModels);
        $response = [];

        foreach ($indices as $index) {
            /* @var Index $index  */
            $response[$index->indexName] = $index->saveObjects($algoliaRecords);
        }

        return $response;
    }

    /**
     * Removes a searchable model from indices.
     *
     * @param SearchableInterface $searchableModel
     *
     * @return array
     * @throws \Exception
     */
    public function removeFromIndices(SearchableInterface $searchableModel)
    {
        $indices = $indices = $this->initIndices($searchableModel);
        $response = [];

        foreach ($indices as $index) {
            $objectID = $searchableModel->getObjectID();
            $response[$index->indexName] = $index->deleteObject($objectID);
        }

        return $response;
    }

    /**
     * Re-indexes the indices safely for the given ActiveRecord Class.
     *
     * @param string $className The name of the ActiveRecord to be indexed.
     *
     * @return array
     */
    public function reindex($className)
    {
        $this->checkImplementsSearchableInterface($className);
        $activeRecord = $this->activeRecordFactory->make($className);
        $response = [];

        /** @var SearchableInterface[] $activeRecordEntities */
        $activeRecordEntities = $activeRecord->find()->all();

        /* @var SearchableInterface $activeRecord */
        $indices = $indices = $this->initIndices($activeRecord);
        $records = [];

        foreach ($activeRecordEntities as $activeRecordEntity) {
            $record = $activeRecordEntity->getAlgoliaRecord();
            $record['objectID'] = $activeRecordEntity->getObjectID();
            $records[] = $record;
        }

        foreach ($indices as $index) {
            $temporaryIndexName = 'tmp_' . $index->indexName;

            /** @var Index $temporaryIndex */
            $temporaryIndex = $this->initIndex($temporaryIndexName);
            $temporaryIndex->addObjects($records);

            $settings = $index->getSettings();

            // Temporary index overrides all the settings on the main one.
            // So let's set the original settings on the temporary one before atomically moving the index.
            $temporaryIndex->setSettings($settings);

            $response[$index->indexName] = $this->moveIndex($temporaryIndexName, $index->indexName);
        }

        return $response;
    }

    /**
     * Clears the indices for the given Class that implements SearchableInterface.
     *
     * @param string $className The name of the Class which indices are to be cleared.
     *
     * @return array
     */
    public function clearIndices($className)
    {
        $this->checkImplementsSearchableInterface($className);
        $activeRecord = $this->activeRecordFactory->make($className);
        $response = [];

        /* @var SearchableInterface $activeRecord */
        $indices = $indices = $this->initIndices($activeRecord);

        foreach ($indices as $index) {
            $response[$index->indexName] = $index->clearIndex();
        }

        return $response;
    }

    /**
     * Dynamically pass methods to the Algolia Client.
     *
     * @param string $method
     * @param array $parameters
     *
     * @return mixed
     */
    public function __call($method, $parameters)
    {
        return call_user_func_array([$this->getClient(), $method], $parameters);
    }

    /**
     * Checks if the given class implements SearchableInterface.
     *
     * @param string $class Either name or instance of the class to be checked.
     */
    private function checkImplementsSearchableInterface($class)
    {
        $reflectionClass = new \ReflectionClass($class);

        if (! $reflectionClass->implementsInterface(SearchableInterface::class)) {
            throw new \InvalidArgumentException("The class: {$reflectionClass->name} doesn't implement leinonen\\Yii2Algolia\\SearchableInterface");
        }
    }

    /**
     * Initializes indices for the given SearchableModel.
     *
     * @param SearchableInterface $searchableModel
     *
     * @return Index[]
     */
    private function initIndices(SearchableInterface $searchableModel)
    {
        $indexNames = $searchableModel->getIndices();

        $indices = array_map(function ($indexName) {
            if ($this->env !== null) {
                $indexName = $this->env . '_' . $indexName;
            }

            return $this->initIndex($indexName);
        }, $indexNames);

        return $indices;
    }

    /**
     * Maps an array of searchable models into an Algolia friendly array. Returns also indices for the searchable model
     * which the array consists of.
     *
     * @param SearchableInterface[] $searchableModels
     *
     * @return array
     */
    private function getIndicesAndAlgoliaRecordsFromSearchableModelArray(array $searchableModels)
    {
        // Use the first element of the array to define what kind of models we are indexing.
        $arrayType = get_class($searchableModels[0]);
        $indices = $this->initIndices($searchableModels[0]);

        $algoliaRecords = array_map(function (SearchableInterface $searchableModel) use ($arrayType) {
            if (! $searchableModel instanceof $arrayType) {
                throw new \InvalidArgumentException('The given array should not contain multiple different classes');
            }

            $algoliaRecord = $searchableModel->getAlgoliaRecord();
            $algoliaRecord['objectID'] = $searchableModel->getObjectID();

            return $algoliaRecord;
        }, $searchableModels);

        return [$indices, $algoliaRecords];
    }
}


1		<?php
2
3		namespace leinonen\Yii2Algolia;
4
5		use AlgoliaSearch\Client;
6		use AlgoliaSearch\Index;
7		use leinonen\Yii2Algolia\ActiveRecord\ActiveRecordFactory;
8
9		/**
10		* @method setConnectTimeout(int $connectTimeout, int $timeout = 30, int $searchTimeout = 5)
11		* @method enableRateLimitForward(string $adminAPIKey, string $endUserIP, string $rateLimitAPIKey)
12		* @method setForwarderFor(string $ip)
13		* @method setAlgoliaUserToken(string $token)
14		* @method disableRateLimitForward()
15		* @method isAlive()
16		* @method setExtraHeader(string $key, string $value)
17		* @method mixed multipleQueries(array $queries, string $indexNameKey = "indexName", string $strategy = "none")
18		* @method mixed listIndexes()
19		* @method deleteIndex(string $indexName)
20		* @method mixed moveIndex(string $srcIndexName, string $dstIndexName)
21		* @method mixed copyIndex(string $srcIndexName, string $dstIndexName)
22		* @method mixed getLogs(int $offset = 0, int $length = 10, string $type = "all")
23		* @method Index initIndex(string $indexName)
24		* @method mixed listUserKeys()
25		* @method mixed getUserKeyACL(string $key)
26		* @method mixed deleteUserKey(string $key)
27		* @method mixed addUserKey(array $obj, int $validity = 0, int $maxQueriesPerIPPerHour = 0, int $maxHitsPerQuery = 0, array $indexes = null)
28		* @method mixed updateUserKey(string $key, array $obj, int $validity = 0, int $maxQueriesPerIPPerHour = 0, int $maxHitsPerQuery = 0, array $indexes = null)
29		* @method mixed batch(array $requests)
30		* @method string generateSecuredApiKey(string $privateApiKey, mixed $query, string $userToken = null)
31		* @method string buildQuery(array $args)
32		* @method mixed request(\AlgoliaSearch\ClientContext $context, string $method, string $path, array $params, array $data, array $hostsArray, int $connectTimeout, int $readTimeout)
33		* @method mixed doRequest(\AlgoliaSearch\ClientContext $context, string $method, string $path, array $params, array $data, array $hostsArray, int $connectTimeout, int $readTimeout)
34		* @method \AlgoliaSearch\PlacesIndex initPlaces(string $appId, string $appKey, array $hostsArray = null, array $options = [])
35		* @see Client
36		*/
37		class AlgoliaManager
38		{
39		/**
40		* @var AlgoliaFactory
41		*/
42		protected $factory;
43
44		/**
45		* @var AlgoliaConfig
46		*/
47		protected $config;
48
49		/**
50		* @var Client
51		*/
52		protected $client;
53
54		/**
55		* @var ActiveRecordFactory
56		*/
57		protected $activeRecordFactory;
58
59		/**
60		* @var null\|string
61		*/
62		protected $env;
63
64		/**
65		* Initiates a new AlgoliaManager.
66		*
67		* @param Client $client
68		* @param ActiveRecordFactory $activeRecordFactory
69		*
70		*/
71	39	public function __construct(Client $client, ActiveRecordFactory $activeRecordFactory)
72		{
73	39	$this->client = $client;
74	39	$this->activeRecordFactory = $activeRecordFactory;
75	39	}
76
77		/**
78		* Returns the Algolia Client.
79		*
80		* @return Client
81		*/
82	19	public function getClient()
83		{
84	19	return $this->client;
85		}
86
87		/**
88		* Sets the environment for the manager.
89		*
90		* @param string $env
91		*/
92	39	public function setEnv($env)
93		{
94	39	$this->env = $env;
95	39	}
96
97		/**
98		* Returns the environment for the manager.
99		*
100		* @return null\|string
101		*/
102	1	public function getEnv()
103		{
104	1	return $this->env;
105		}
106
107		/**
108		* Indexes a searchable model to all indices.
109		*
110		* @param SearchableInterface $searchableModel
111		*
112		* @return array
113		*/
114	5	public function pushToIndices(SearchableInterface $searchableModel)
115		{
116	5	$indices = $this->initIndices($searchableModel);
117	5	$response = [];
118
119	5	foreach ($indices as $index) {
120	5	$record = $searchableModel->getAlgoliaRecord();
121	5	$response[$index->indexName] = $index->addObject($record, $searchableModel->getObjectID());
122	5	}
123
124	5	return $response;
125		}
126
127		/**
128		* Indexes multiple searchable models in a batch. The given searchable models must be of the same class.
129		*
130		* @param SearchableInterface[] $searchableModels
131		*
132		* @return array
133		*/
134	3	public function pushMultipleToIndices(array $searchableModels)
135		{
136	3	list($indices, $algoliaRecords) = $this->getIndicesAndAlgoliaRecordsFromSearchableModelArray($searchableModels);
137	2	$response = [];
138
139	2	foreach ($indices as $index) {
140		/* @var Index $index */
141	2	$response[$index->indexName] = $index->addObjects($algoliaRecords);
142	2	}
143
144	2	return $response;
145		}
146
147		/**
148		* Updates the models data in all indices.
149		*
150		* @param SearchableInterface $searchableModel
151		*
152		* @return array
153		*/
154	3	public function updateInIndices(SearchableInterface $searchableModel)
155		{
156	3	$indices = $this->initIndices($searchableModel);
157	3	$response = [];
158
159	3	foreach ($indices as $index) {
160	3	$record = $searchableModel->getAlgoliaRecord();
161	3	$record['objectID'] = $searchableModel->getObjectID();
162	3	$response[$index->indexName] = $index->saveObject($record);
163	3	}
164
165	3	return $response;
166		}
167
168		/**
169		* Updates multiple models data in all indices. The given searchable models must be of the same class.
170		*
171		* @param SearchableInterface[] $searchableModels
172		*
173		* @return array
174		*/
175	2	public function updateMultipleInIndices(array $searchableModels)
176		{
177	2	list($indices, $algoliaRecords) = $this->getIndicesAndAlgoliaRecordsFromSearchableModelArray($searchableModels);
178	1	$response = [];
179
180	1	foreach ($indices as $index) {
181		/* @var Index $index */
182	1	$response[$index->indexName] = $index->saveObjects($algoliaRecords);
183	1	}
184
185	1	return $response;
186		}
187
188		/**
189		* Removes a searchable model from indices.
190		*
191		* @param SearchableInterface $searchableModel
192		*
193		* @return array
194		* @throws \Exception
195		*/
196	2	public function removeFromIndices(SearchableInterface $searchableModel)
197		{
198	2	$indices = $indices = $this->initIndices($searchableModel);
199	2	$response = [];
200
201	2	foreach ($indices as $index) {
202	2	$objectID = $searchableModel->getObjectID();
203	2	$response[$index->indexName] = $index->deleteObject($objectID);
204	2	}
205
206	2	return $response;
207		}
208
209		/**
210		* Re-indexes the indices safely for the given ActiveRecord Class.
211		*
212		* @param string $className The name of the ActiveRecord to be indexed.
213		*
214		* @return array
215		*/
216	3	public function reindex($className)
217		{
218	3	$this->checkImplementsSearchableInterface($className);
219	2	$activeRecord = $this->activeRecordFactory->make($className);
220	2	$response = [];
221
222		/** @var SearchableInterface[] $activeRecordEntities */
223	2	$activeRecordEntities = $activeRecord->find()->all();
224
225		/* @var SearchableInterface $activeRecord */
226	2	$indices = $indices = $this->initIndices($activeRecord);
227	2	$records = [];
228
229	2	foreach ($activeRecordEntities as $activeRecordEntity) {
230	2	$record = $activeRecordEntity->getAlgoliaRecord();
231	2	$record['objectID'] = $activeRecordEntity->getObjectID();
232	2	$records[] = $record;
233	2	}
234
235	2	foreach ($indices as $index) {
236	2	$temporaryIndexName = 'tmp_' . $index->indexName;
237
238		/** @var Index $temporaryIndex */
239	2	$temporaryIndex = $this->initIndex($temporaryIndexName);
240	2	$temporaryIndex->addObjects($records);
241
242	2	$settings = $index->getSettings();
243
244		// Temporary index overrides all the settings on the main one.
245		// So let's set the original settings on the temporary one before atomically moving the index.
246	2	$temporaryIndex->setSettings($settings);
247
248	2	$response[$index->indexName] = $this->moveIndex($temporaryIndexName, $index->indexName);
249	2	}
250
251	2	return $response;
252		}
253
254		/**
255		* Clears the indices for the given Class that implements SearchableInterface.
256		*
257		* @param string $className The name of the Class which indices are to be cleared.
258		*
259		* @return array
260		*/
261	2	public function clearIndices($className)
262		{
263	2	$this->checkImplementsSearchableInterface($className);
264	1	$activeRecord = $this->activeRecordFactory->make($className);
265	1	$response = [];
266
267		/* @var SearchableInterface $activeRecord */
268	1	$indices = $indices = $this->initIndices($activeRecord);
269
270	1	foreach ($indices as $index) {
271	1	$response[$index->indexName] = $index->clearIndex();
272	1	}
273
274	1	return $response;
275		}
276
277		/**
278		* Dynamically pass methods to the Algolia Client.
279		*
280		* @param string $method
281		* @param array $parameters
282		*
283		* @return mixed
284		*/
285	16	public function __call($method, $parameters)
286		{
287	16	return call_user_func_array([$this->getClient(), $method], $parameters);
288		}
289
290		/**
291		* Checks if the given class implements SearchableInterface.
292		*
293		* @param string $class Either name or instance of the class to be checked.
294		*/
295	5	private function checkImplementsSearchableInterface($class)
296		{
297	5	$reflectionClass = new \ReflectionClass($class);
298
299	5	if (! $reflectionClass->implementsInterface(SearchableInterface::class)) {
300	2	throw new \InvalidArgumentException("The class: {$reflectionClass->name} doesn't implement leinonen\\Yii2Algolia\\SearchableInterface");
301		}
302	3	}
303
304		/**
305		* Initializes indices for the given SearchableModel.
306		*
307		* @param SearchableInterface $searchableModel
308		*
309		* @return Index[]
310		*/
311	15	private function initIndices(SearchableInterface $searchableModel)
312		{
313	15	$indexNames = $searchableModel->getIndices();
314
315		$indices = array_map(function ($indexName) {
316	15	if ($this->env !== null) {
317	3	$indexName = $this->env . '_' . $indexName;
318	3	}
319
320	15	return $this->initIndex($indexName);
321	15	}, $indexNames);
322
323	15	return $indices;
324		}
325
326		/**
327		* Maps an array of searchable models into an Algolia friendly array. Returns also indices for the searchable model
328		* which the array consists of.
329		*
330		* @param SearchableInterface[] $searchableModels
331		*
332		* @return array
333		*/
334	5	private function getIndicesAndAlgoliaRecordsFromSearchableModelArray(array $searchableModels)
335		{
336		// Use the first element of the array to define what kind of models we are indexing.
337	5	$arrayType = get_class($searchableModels[0]);
338	5	$indices = $this->initIndices($searchableModels[0]);
339
340	5	$algoliaRecords = array_map(function (SearchableInterface $searchableModel) use ($arrayType) {
341	5	if (! $searchableModel instanceof $arrayType) {
342	2	throw new \InvalidArgumentException('The given array should not contain multiple different classes');
343		}
344
345	5	$algoliaRecord = $searchableModel->getAlgoliaRecord();
346	5	$algoliaRecord['objectID'] = $searchableModel->getObjectID();
347
348	5	return $algoliaRecord;
349	5	}, $searchableModels);
350
351	3	return [$indices, $algoliaRecords];
352		}
353		}
354

lordthorzonus / yii2-algolia

Push — master ( b8a5e6...49b185 )

AlgoliaManager::reindex() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like