Item::hasIndexingProperty() - Code Metrics - Inspection of "Use Guzzle API for HTTP Crawling Requests (#1837)" - TYPO3-Solr/ext-solr - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 02f8b8...776b21 )

by Timo

created 2018-02-15 15:13 UTC

Item::hasIndexingProperty() A

↳ Parent: Item

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	5
ccs	0
cts	3
cp	0
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1
crap	2

<?php
namespace ApacheSolrForTypo3\Solr\IndexQueue;

/***************************************************************
 *  Copyright notice
 *
 *  (c) 2009-2015 Ingo Renner <[email protected]>
 *  All rights reserved
 *
 *  This script is part of the TYPO3 project. The TYPO3 project is
 *  free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  The GNU General Public License can be found at
 *  http://www.gnu.org/copyleft/gpl.html.
 *
 *  This script 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 General Public License for more details.
 *
 *  This copyright notice MUST APPEAR in all copies of the script!
 ***************************************************************/

use ApacheSolrForTypo3\Solr\Domain\Index\Queue\IndexQueueIndexingPropertyRepository;
use ApacheSolrForTypo3\Solr\Domain\Index\Queue\QueueItemRepository;
use ApacheSolrForTypo3\Solr\Domain\Site\SiteRepository;
use ApacheSolrForTypo3\Solr\Site;
use TYPO3\CMS\Backend\Utility\BackendUtility;
use TYPO3\CMS\Core\Utility\GeneralUtility;

/**
 * Representation of an index queue item, carrying meta data and the record to be
 * indexed.
 *
 * @todo: Loose coupling from Repos
 *
 * @author Ingo Renner <[email protected]>
 */
class Item
{
    /**
     * The item's uid in the index queue (tx_solr_indexqueue_item.uid)
     *
     * @var int
     */
    protected $indexQueueUid;

    /**
     * The root page uid of the tree the item is located in (tx_solr_indexqueue_item.root)
     *
     * @var int
     */
    protected $rootPageUid;

    /**
     * The record's type, usually a table name, but could also be a file type (tx_solr_indexqueue_item.item_type)
     *
     * @var string
     */
    protected $type;

    /**
     * The name of the indexing configuration that should be used when indexing (tx_solr_indexqueue_item.indexing_configuration)
     * the item.
     *
     * @var string
     */
    protected $indexingConfigurationName;

    /**
     * The unix timestamp when the record was last changed (tx_solr_indexqueue_item.changed)
     *
     * @var int
     */
    protected $changed;

    /**
     * Indexing properties to provide additional information for the item's
     * indexer / how to index the item.
     *
     * @var array
     */
    protected $indexingProperties = [];

    /**
     * Flag for lazy loading indexing properties.
     *
     * @var bool
     */
    protected $indexingPropertiesLoaded = false;

    /**
     * Flag, whether indexing properties exits for this item.
     *
     * @var bool
     */
    protected $hasIndexingProperties = false;

    /**
     * The record's uid.
     *
     * @var int
     */
    protected $recordUid = 0;

    /**
     * The record itself
     *
     * @var array
     */
    protected $record;

    /**
     * Moint point identifier.
     *
     * @var string
     */
    protected $mountPointIdentifier;

    /**
     * @var string
     */
    protected $errors = '';

    /**
     * @var IndexQueueIndexingPropertyRepository
     */
    protected $indexQueueIndexingPropertyRepository;

    /**
     * @var QueueItemRepository
     */
    protected $queueItemRepository;

    /**
     * Constructor, takes item meta data information and resolves that to the full record.
     *
     * @param array $itemMetaData Metadata describing the item to index using the index queue. Is expected to contain a record from table tx_solr_indexqueue_item
     * @param array $fullRecord Optional full record for the item. If provided, can save some SQL queries.
     * @param IndexQueueIndexingPropertyRepository|null $indexQueueIndexingPropertyRepository
     */
    public function __construct(array $itemMetaData, array $fullRecord = [], IndexQueueIndexingPropertyRepository $indexQueueIndexingPropertyRepository = null, QueueItemRepository $queueItemRepository = null)
    {
        $this->indexQueueUid = $itemMetaData['uid'];
        $this->rootPageUid = $itemMetaData['root'];
        $this->type = $itemMetaData['item_type'];
        $this->recordUid = $itemMetaData['item_uid'];
        $this->mountPointIdentifier = (string) empty($itemMetaData['pages_mountidentifier']) ? '' : $itemMetaData['pages_mountidentifier'];
        $this->changed = $itemMetaData['changed'];
        $this->errors = (string) empty($itemMetaData['errors']) ? '' : $itemMetaData['errors'];

        $this->indexingConfigurationName = $itemMetaData['indexing_configuration'];
        $this->hasIndexingProperties = (boolean)$itemMetaData['has_indexing_properties'];

        if (!empty($fullRecord)) {
            $this->record = $fullRecord;
        }

        $this->indexQueueIndexingPropertyRepository = isset($indexQueueIndexingPropertyRepository) ? $indexQueueIndexingPropertyRepository : GeneralUtility::makeInstance(IndexQueueIndexingPropertyRepository::class);
        $this->queueItemRepository = isset($queueItemRepository) ? $queueItemRepository : GeneralUtility::makeInstance(QueueItemRepository::class);
    }

    /**
     * Getter for Index Queue UID
     *
     * @return integer
     */
    public function getIndexQueueUid()
    {
        return $this->indexQueueUid;
    }

    /**
     * Gets the item's root page ID (uid)
     *
     * @return int root page ID
     */
    public function getRootPageUid()
    {
        return $this->rootPageUid;
    }

    /**
     * Returns mount point identifier
     *
     * @return string
     */
    public function getMountPointIdentifier()
    {
        return $this->mountPointIdentifier;
    }

    /**
     * @param integer $uid
     */
    public function setRootPageUid($uid)
    {
        $this->rootPageUid = intval($uid);
    }

    /**
     * @return string
     */
    public function getErrors()
    {
        return $this->errors;
    }

    /**
     * Gets the site the item belongs to.
     *
     * @return Site Site instance the item belongs to.
     */
    public function getSite()
    {
        $siteRepository = GeneralUtility::makeInstance(SiteRepository::class);
        return $siteRepository->getSiteByRootPageId($this->rootPageUid);
    }

    public function getType()
    {
        return $this->type;
    }

    public function setType($type)
    {
        $this->type = $type;
    }

    public function getIndexingConfigurationName()
    {
        return $this->indexingConfigurationName;
    }

    public function setIndexingConfigurationName($indexingConfigurationName)
    {
        $this->indexingConfigurationName = $indexingConfigurationName;
    }

    public function getChanged()
    {
        return $this->changed;
    }

    public function setChanged($changed)
    {
        $this->changed = intval($changed);
    }

    public function getRecordUid()
    {
        $this->getRecord();

        return $this->record['uid'];
    }

    /**
     * Gets the item's full record.
     *
     * Uses lazy loading.
     *
     * @return array The item's DB record.
     */
    public function getRecord()
    {
        if (empty($this->record)) {
            $this->record = (array)BackendUtility::getRecord(
                $this->type,
                $this->recordUid,
                '*',
                '',
                false
            );
        }

        return $this->record;
    }

    public function setRecord(array $record)
    {
        $this->record = $record;
    }

    /**
     * @return int
     */
    public function getRecordPageId()
    {
        $this->getRecord();

        return $this->record['pid'];
    }

    /**
     * Stores the indexing properties.
     *
     */
    public function storeIndexingProperties()
    {
        $this->indexQueueIndexingPropertyRepository->removeByRootPidAndIndexQueueUid(intval($this->rootPageUid), intval($this->indexQueueUid));

        if ($this->hasIndexingProperties()) {
            $this->writeIndexingProperties();
        }

        $this->queueItemRepository->updateHasIndexingPropertiesFlagByItemUid($this->indexQueueUid, $this->hasIndexingProperties);
    }

    public function hasIndexingProperties()
    {
        return $this->hasIndexingProperties;
    }

    /**
     * Writes all indexing properties.
     */
    protected function writeIndexingProperties()
    {
        $properties = [];
        foreach ($this->indexingProperties as $propertyKey => $propertyValue) {
            $properties[] = [
                'root' => $this->rootPageUid,
                'item_id' => $this->indexQueueUid,
                'property_key' => $propertyKey,
                'property_value' => $propertyValue
            ];
        }
        if (empty($properties)) {
            return;
        }
        $this->indexQueueIndexingPropertyRepository->bulkInsert($properties);
    }

    /**
     * @param string $key
     * @return bool
     */
    public function hasIndexingProperty($key)
    {
        $this->loadIndexingProperties();

        return array_key_exists($key, $this->indexingProperties);
    }

    /**
     * Loads the indexing properties for the item - if not already loaded.
     */
    public function loadIndexingProperties()
    {
        if ($this->indexingPropertiesLoaded) {
            return;
        }

        $indexingProperties = $this->indexQueueIndexingPropertyRepository->findAllByIndexQueueUid(intval($this->indexQueueUid));
        $this->indexingPropertiesLoaded = true;
        if (empty($indexingProperties)) {
            return;
        }

        foreach ($indexingProperties as $indexingProperty) {
            $this->indexingProperties[$indexingProperty['property_key']] = $indexingProperty['property_value'];
        }
    }

    /**
     * Sets an indexing property for the item.
     *
     * @param string $key Indexing property name
     * @param string|int|float $value Indexing property value
     * @throws \InvalidArgumentException when $value is not string, integer or float
     */
    public function setIndexingProperty($key, $value)
    {
        // make sure to not interfere with existing indexing properties
        $this->loadIndexingProperties();

        $key = (string)$key; // Scalar typehints now!

        if (!is_string($value) && !is_int($value) && !is_float($value)) {

            throw new \InvalidArgumentException(
                'Cannot set indexing property "' . $key
                . '", its value must be string, integer or float, '
                . 'type given was "' . gettype($value) . '"',
                1323173209
            );
        }

        $this->indexingProperties[$key] = $value;
        $this->hasIndexingProperties = true;
    }

    /**
     * Gets a specific indexing property by its name/key.
     *
     * @param string $key Indexing property name/key.
     * @throws \InvalidArgumentException when the given $key does not exist.
     * @return string
     */
    public function getIndexingProperty($key)
    {
        $this->loadIndexingProperties();

        if (!array_key_exists($key, $this->indexingProperties)) {
            throw new \InvalidArgumentException(
                'No indexing property "' . $key . '".',
                1323174143
            );
        }

        return $this->indexingProperties[$key];
    }

    /**
     * Gets all indexing properties set for this item.
     *
     * @return array Array of indexing properties.
     */
    public function getIndexingProperties()
    {
        $this->loadIndexingProperties();

        return $this->indexingProperties;
    }

    /**
     * Gets the names/keys of the item's indexing properties.
     *
     * @return array Array of indexing property names/keys
     */
    public function getIndexingPropertyKeys()
    {
        $this->loadIndexingProperties();

        return array_keys($this->indexingProperties);
    }
}


1		<?php
2		namespace ApacheSolrForTypo3\Solr\IndexQueue;
3
4		/***************************************************************
5		* Copyright notice
6		*
7		* (c) 2009-2015 Ingo Renner <[email protected]>
8		* All rights reserved
9		*
10		* This script is part of the TYPO3 project. The TYPO3 project is
11		* free software; you can redistribute it and/or modify
12		* it under the terms of the GNU General Public License as published by
13		* the Free Software Foundation; either version 3 of the License, or
14		* (at your option) any later version.
15		*
16		* The GNU General Public License can be found at
17		* http://www.gnu.org/copyleft/gpl.html.
18		*
19		* This script is distributed in the hope that it will be useful,
20		* but WITHOUT ANY WARRANTY; without even the implied warranty of
21		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22		* GNU General Public License for more details.
23		*
24		* This copyright notice MUST APPEAR in all copies of the script!
25		***************************************************************/
26
27		use ApacheSolrForTypo3\Solr\Domain\Index\Queue\IndexQueueIndexingPropertyRepository;
28		use ApacheSolrForTypo3\Solr\Domain\Index\Queue\QueueItemRepository;
29		use ApacheSolrForTypo3\Solr\Domain\Site\SiteRepository;
30		use ApacheSolrForTypo3\Solr\Site;
31		use TYPO3\CMS\Backend\Utility\BackendUtility;
32		use TYPO3\CMS\Core\Utility\GeneralUtility;
33
34		/**
35		* Representation of an index queue item, carrying meta data and the record to be
36		* indexed.
37		*
38		* @todo: Loose coupling from Repos
39		*
40		* @author Ingo Renner <[email protected]>
41		*/
42		class Item
43		{
44		/**
45		* The item's uid in the index queue (tx_solr_indexqueue_item.uid)
46		*
47		* @var int
48		*/
49		protected $indexQueueUid;
50
51		/**
52		* The root page uid of the tree the item is located in (tx_solr_indexqueue_item.root)
53		*
54		* @var int
55		*/
56		protected $rootPageUid;
57
58		/**
59		* The record's type, usually a table name, but could also be a file type (tx_solr_indexqueue_item.item_type)
60		*
61		* @var string
62		*/
63		protected $type;
64
65		/**
66		* The name of the indexing configuration that should be used when indexing (tx_solr_indexqueue_item.indexing_configuration)
67		* the item.
68		*
69		* @var string
70		*/
71		protected $indexingConfigurationName;
72
73		/**
74		* The unix timestamp when the record was last changed (tx_solr_indexqueue_item.changed)
75		*
76		* @var int
77		*/
78		protected $changed;
79
80		/**
81		* Indexing properties to provide additional information for the item's
82		* indexer / how to index the item.
83		*
84		* @var array
85		*/
86		protected $indexingProperties = [];
87
88		/**
89		* Flag for lazy loading indexing properties.
90		*
91		* @var bool
92		*/
93		protected $indexingPropertiesLoaded = false;
94
95		/**
96		* Flag, whether indexing properties exits for this item.
97		*
98		* @var bool
99		*/
100		protected $hasIndexingProperties = false;
101
102		/**
103		* The record's uid.
104		*
105		* @var int
106		*/
107		protected $recordUid = 0;
108
109		/**
110		* The record itself
111		*
112		* @var array
113		*/
114		protected $record;
115
116		/**
117		* Moint point identifier.
118		*
119		* @var string
120		*/
121		protected $mountPointIdentifier;
122
123		/**
124		* @var string
125		*/
126		protected $errors = '';
127
128		/**
129		* @var IndexQueueIndexingPropertyRepository
130		*/
131		protected $indexQueueIndexingPropertyRepository;
132
133		/**
134		* @var QueueItemRepository
135		*/
136		protected $queueItemRepository;
137
138		/**
139		* Constructor, takes item meta data information and resolves that to the full record.
140		*
141		* @param array $itemMetaData Metadata describing the item to index using the index queue. Is expected to contain a record from table tx_solr_indexqueue_item
142		* @param array $fullRecord Optional full record for the item. If provided, can save some SQL queries.
143		* @param IndexQueueIndexingPropertyRepository\|null $indexQueueIndexingPropertyRepository
144		*/
145	68	public function __construct(array $itemMetaData, array $fullRecord = [], IndexQueueIndexingPropertyRepository $indexQueueIndexingPropertyRepository = null, QueueItemRepository $queueItemRepository = null)
146		{
147	68	$this->indexQueueUid = $itemMetaData['uid'];
148	68	$this->rootPageUid = $itemMetaData['root'];
149	68	$this->type = $itemMetaData['item_type'];
150	68	$this->recordUid = $itemMetaData['item_uid'];
151	68	$this->mountPointIdentifier = (string) empty($itemMetaData['pages_mountidentifier']) ? '' : $itemMetaData['pages_mountidentifier'];
152	68	$this->changed = $itemMetaData['changed'];
153	68	$this->errors = (string) empty($itemMetaData['errors']) ? '' : $itemMetaData['errors'];
154
155	68	$this->indexingConfigurationName = $itemMetaData['indexing_configuration'];
156	68	$this->hasIndexingProperties = (boolean)$itemMetaData['has_indexing_properties'];
157
158	68	if (!empty($fullRecord)) {
159	36	$this->record = $fullRecord;
160		}
161
162	68	$this->indexQueueIndexingPropertyRepository = isset($indexQueueIndexingPropertyRepository) ? $indexQueueIndexingPropertyRepository : GeneralUtility::makeInstance(IndexQueueIndexingPropertyRepository::class);
163	68	$this->queueItemRepository = isset($queueItemRepository) ? $queueItemRepository : GeneralUtility::makeInstance(QueueItemRepository::class);
164	68	}
165
166		/**
167		* Getter for Index Queue UID
168		*
169		* @return integer
170		*/
171	7	public function getIndexQueueUid()
172		{
173	7	return $this->indexQueueUid;
174		}
175
176		/**
177		* Gets the item's root page ID (uid)
178		*
179		* @return int root page ID
180		*/
181	30	public function getRootPageUid()
182		{
183	30	return $this->rootPageUid;
184		}
185
186		/**
187		* Returns mount point identifier
188		*
189		* @return string
190		*/
191	23	public function getMountPointIdentifier()
192		{
193	23	return $this->mountPointIdentifier;
194		}
195
196		/**
197		* @param integer $uid
198		*/
199		public function setRootPageUid($uid)
200		{
201		$this->rootPageUid = intval($uid);
202		}
203
204		/**
205		* @return string
206		*/
207	5	public function getErrors()
208		{
209	5	return $this->errors;
210		}
211
212		/**
213		* Gets the site the item belongs to.
214		*
215		* @return Site Site instance the item belongs to.
216		*/
217	29	public function getSite()
218		{
219	29	$siteRepository = GeneralUtility::makeInstance(SiteRepository::class);
220	29	return $siteRepository->getSiteByRootPageId($this->rootPageUid);
221		}
222
223	25	public function getType()
224		{
225	25	return $this->type;
226		}
227
228		public function setType($type)
229		{
230		$this->type = $type;
231		}
232
233	35	public function getIndexingConfigurationName()
234		{
235	35	return $this->indexingConfigurationName;
236		}
237
238		public function setIndexingConfigurationName($indexingConfigurationName)
239		{
240		$this->indexingConfigurationName = $indexingConfigurationName;
241		}
242
243		public function getChanged()
244		{
245		return $this->changed;
246		}
247
248		public function setChanged($changed)
249		{
250		$this->changed = intval($changed);
251		}
252
253	4	public function getRecordUid()
254		{
255	4	$this->getRecord();
256
257	4	return $this->record['uid'];
258		}
259
260		/**
261		* Gets the item's full record.
262		*
263		* Uses lazy loading.
264		*
265		* @return array The item's DB record.
266		*/
267	22	public function getRecord()
268		{
269	22	if (empty($this->record)) {
270	1	$this->record = (array)BackendUtility::getRecord(
271	1	$this->type,
272	1	$this->recordUid,
273	1	'*',
274	1	'',
275	1	false
276		);
277		}
278
279	22	return $this->record;
280		}
281
282		public function setRecord(array $record)
283		{
284		$this->record = $record;
285		}
286
287		/**
288		* @return int
289		*/
290	19	public function getRecordPageId()
291		{
292	19	$this->getRecord();
293
294	19	return $this->record['pid'];
295		}
296
297		/**
298		* Stores the indexing properties.
299		*
300		*/
301	7	public function storeIndexingProperties()
302		{
303	7	$this->indexQueueIndexingPropertyRepository->removeByRootPidAndIndexQueueUid(intval($this->rootPageUid), intval($this->indexQueueUid));
304
305	7	if ($this->hasIndexingProperties()) {
306	7	$this->writeIndexingProperties();
307		}
308
309	7	$this->queueItemRepository->updateHasIndexingPropertiesFlagByItemUid($this->indexQueueUid, $this->hasIndexingProperties);
310	7	}
311
312	8	public function hasIndexingProperties()
313		{
314	8	return $this->hasIndexingProperties;
315		}
316
317		/**
318		* Writes all indexing properties.
319		*/
320	7	protected function writeIndexingProperties()
321		{
322	7	$properties = [];
323	7	foreach ($this->indexingProperties as $propertyKey => $propertyValue) {
324	7	$properties[] = [
325	7	'root' => $this->rootPageUid,
326	7	'item_id' => $this->indexQueueUid,
327	7	'property_key' => $propertyKey,
328	7	'property_value' => $propertyValue
329		];
330		}
331	7	if (empty($properties)) {
332		return;
333		}
334	7	$this->indexQueueIndexingPropertyRepository->bulkInsert($properties);
335	7	}
336
337		/**
338		* @param string $key
339		* @return bool
340		*/
341		public function hasIndexingProperty($key)
342		{
343		$this->loadIndexingProperties();
344
345		return array_key_exists($key, $this->indexingProperties);
346		}
347
348		/**
349		* Loads the indexing properties for the item - if not already loaded.
350		*/
351	7	public function loadIndexingProperties()
352		{
353	7	if ($this->indexingPropertiesLoaded) {
354	7	return;
355		}
356
357	7	$indexingProperties = $this->indexQueueIndexingPropertyRepository->findAllByIndexQueueUid(intval($this->indexQueueUid));
358	7	$this->indexingPropertiesLoaded = true;
359	7	if (empty($indexingProperties)) {
360	7	return;
361		}
362
363		foreach ($indexingProperties as $indexingProperty) {
364		$this->indexingProperties[$indexingProperty['property_key']] = $indexingProperty['property_value'];
365		}
366		}
367
368		/**
369		* Sets an indexing property for the item.
370		*
371		* @param string $key Indexing property name
372		* @param string\|int\|float $value Indexing property value
373		* @throws \InvalidArgumentException when $value is not string, integer or float
374		*/
375	7	public function setIndexingProperty($key, $value)
376		{
377		// make sure to not interfere with existing indexing properties
378	7	$this->loadIndexingProperties();
379
380	7	$key = (string)$key; // Scalar typehints now!
381
382	7	if (!is_string($value) && !is_int($value) && !is_float($value)) {
		0 ignored issues – show introduced 2018-02-07 08:29 UTC by Report Bug Copy Issue Report The condition `! is_string($value) && !...) && ! is_float($value)` can never be `true`. Loading history...
383		throw new \InvalidArgumentException(
384		'Cannot set indexing property "' . $key
385		. '", its value must be string, integer or float, '
386		. 'type given was "' . gettype($value) . '"',
387		1323173209
388		);
389		}
390
391	7	$this->indexingProperties[$key] = $value;
392	7	$this->hasIndexingProperties = true;
393	7	}
394
395		/**
396		* Gets a specific indexing property by its name/key.
397		*
398		* @param string $key Indexing property name/key.
399		* @throws \InvalidArgumentException when the given $key does not exist.
400		* @return string
401		*/
402		public function getIndexingProperty($key)
403		{
404		$this->loadIndexingProperties();
405
406		if (!array_key_exists($key, $this->indexingProperties)) {
407		throw new \InvalidArgumentException(
408		'No indexing property "' . $key . '".',
409		1323174143
410		);
411		}
412
413		return $this->indexingProperties[$key];
414		}
415
416		/**
417		* Gets all indexing properties set for this item.
418		*
419		* @return array Array of indexing properties.
420		*/
421		public function getIndexingProperties()
422		{
423		$this->loadIndexingProperties();
424
425		return $this->indexingProperties;
426		}
427
428		/**
429		* Gets the names/keys of the item's indexing properties.
430		*
431		* @return array Array of indexing property names/keys
432		*/
433		public function getIndexingPropertyKeys()
434		{
435		$this->loadIndexingProperties();
436
437		return array_keys($this->indexingProperties);
438		}
439		}
440

TYPO3-Solr / ext-solr

Push — master ( 02f8b8...776b21 )

Item::hasIndexingProperty() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like