Taxonomy::vocabulary() - Code Metrics - RocketPropelledTortoise/Core - Measure and Improve Code Quality continuously with Scrutinizer

Taxonomy::vocabulary() A
last analyzed 2020-04-19 15:33 UTC

↳ Parent: Taxonomy

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
nc	2
nop	1
dl	0
loc	8
rs	10
c	0
b	0
f	0
ccs	2
cts	2
cp	1
crap	2

<?php namespace Rocket\Taxonomy;

use Illuminate\Contracts\Cache\Repository as CacheRepository;
use Rocket\Taxonomy\Model\Hierarchy;
use Rocket\Taxonomy\Model\TermContainer;
use Rocket\Taxonomy\Model\TermData;
use Rocket\Taxonomy\Model\Vocabulary;
use Rocket\Taxonomy\Repositories\TermHierarchyRepositoryInterface as TermHieraRep;
use Rocket\Taxonomy\Repositories\TermRepositoryInterface as TermRep;
use Rocket\Translation\Support\Laravel5\Facade as I18N;

/**
 * The Taxonomy base class handles the cache and the creation/modification of terms
 */
class Taxonomy implements TaxonomyInterface
{
    /**
     * @var array Terms internal cache
     */
    public $terms = [];

    /**
     * @var array List of vocabularies by ID
     */
    protected $vocabularyById = [];

    /**
     * @var array List of vocabularies by Name
     */
    protected $vocabularyByName = [];

    /**
     * @var CacheRepository The repository to cache Terms
     */
    protected $cache;

    /**
     * @var TermRep The repository to load Terms
     */
    protected $termRepository;

    /**
     * @var TermHieraRep The repository to handle terms hierarchies
     */
    protected $termHierarchyRepository;

    /**
     * Initialize the Taxonomy system, Loads all existing vocabularies
     *
     * @param CacheRepository $cache The cache repository
     * @param TermRep $termRepository The term retrieval repository
     * @param TermHieraRep $termHierarchyRepository The term hierarchy repository
     */
    public function __construct(CacheRepository $cache, TermRep $termRepository, TermHieraRep $termHierarchyRepository)
    {
        $this->termRepository = $termRepository;
        $this->termHierarchyRepository = $termHierarchyRepository;
        $this->cache = $cache;

        // Get the list of vocabularies
        $vocs = $cache->remember('Rocket::Taxonomy::Vocabularies', 60 * 24 * 7, function () {
            return Vocabulary::all();
        });

        // Initialize the search for terms
        foreach ($vocs as $v) {
            $this->vocabularyByName[$v->machine_name] = $this->vocabularyById[$v->id] = $v;
        }
    }

    /**
     * Is this vocabulary translatable ?
     *
     * @param int|string $vid
     * @return bool
     */
    public function isTranslatable($vid)
    {
        if (!is_numeric($vid)) {
            $vid = $this->vocabulary($vid);
        }

        return $this->vocabularyById[$vid]->isTranslatable();
    }

    /**
     * Get the internal language for the vocabulary
     *
     * This will return the language_id if the vocabulary is translated or 1 if it's not
     *
     * @param int|string $vocabulary_id
     * @param int $language_id
     * @return int|null
     */
    public function getLanguage($vocabulary_id, $language_id = null)
    {
        if (!$this->isTranslatable($vocabulary_id)) {
            return 1;
        }

        if ($language_id === null) {
            return I18N::getCurrentId();
        }

        return $language_id;
    }

    /**
     * Get a vocabulary by name or ID
     *
     *     Taxonomy::vocabulary(1);
     *     returns 'tags'
     *
     *     Taxonomy::vocabulary('tags');
     *     returns 1
     *
     * @param int|string $key
     * @return mixed
     */
    public function vocabulary($key)
    {
        if (is_numeric($key)) {
            return $this->vocabularyById[$key]->machine_name;
        }

        return $this->vocabularyByName[$key]->id;
    }

    /**
     * Get all vocabularies with keys as id's
     *
     * @return array
     */
    public function vocabularies()
    {
        return $this->vocabularyById;
    }

    /**
     * Get a term with all translations
     *
     * @param int $term_id The term's ID
     * @param bool $from_cache Should we take this term from cache or request a fresh one ?
     * @return Term
     */
    public function getTerm($term_id, $from_cache = true)
    {
        if ($from_cache && array_key_exists($term_id, $this->terms)) {
            return $this->terms[$term_id];
        }

        $data = $this->termRepository->getTerm($term_id);
        $this->terms[$term_id] = $data;

        return $data;
    }

    /**
     * Remove a term from the cache
     *
     * @param int $term_id
     * @return bool
     */
    public function uncacheTerm($term_id)
    {
        if (array_key_exists($term_id, $this->terms)) {
            unset($this->terms[$term_id]);
        }

        return $this->termRepository->uncacheTerm($term_id);
    }

    /**
     * Get all paths for a term
     *
     * @param int $term_id
     * @return array<array<int>>
     */
    public function getAncestryPaths($term_id)
    {
        return $this->termHierarchyRepository->getAncestryPaths($term_id);
    }

    /**
     * Get all paths for a term
     *
     * @param int $term_id
     * @return array<array<int>>
     */
    public function getDescentPaths($term_id)
    {
        return $this->termHierarchyRepository->getDescentPaths($term_id);
    }

    /**
     * Get the complete graph
     * @param int $term_id
     * @return array
     */
    public function getAncestryGraph($term_id)
    {
        return $this->termHierarchyRepository->getAncestryGraph($term_id);
    }

    /**
     * Get the complete graph
     * @param int $term_id
     * @return array
     */
    public function getDescentGraph($term_id)
    {
        return $this->termHierarchyRepository->getDescentGraph($term_id);
    }

    /**
     * Add one parent to a term
     *
     * @param int $term_id
     * @param int $parent_id
     */
    public function addParent($term_id, $parent_id)
    {
        $this->testCanAddParents($term_id, 1);

        $this->termHierarchyRepository->addParent($term_id, $parent_id);
    }

    /**
     * Add a list of parents to a term
     *
     * @param int $term_id
     * @param array<integer> $parent_ids
     */
    public function addParents($term_id, array $parent_ids)
    {
        $this->testCanAddParents($term_id, count($parent_ids));

        foreach ($parent_ids as $id) {
            $this->termHierarchyRepository->addParent($term_id, $id);
        }
    }

    /**
     * Test if the term can have more parents
     *
     * @param int $term_id
     * @param int $count
     * @throws \RuntimeException
     */
    protected function testCanAddParents($term_id, $count)
    {
        $vocabulary = (new Vocabulary())->getTable();
        $term = (new TermContainer())->getTable();
        $v = Vocabulary::select('hierarchy', 'name')
            ->where("$term.id", $term_id)
            ->join($term, 'vocabulary_id', '=', "$vocabulary.id")
            ->first();

        if ($v->hierarchy == 0) {
            throw new \RuntimeException("Cannot add a parent in vocabulary '$v->name'");
        }

        if (($v->hierarchy == 1 && Hierarchy::where('term_id', $term_id)->count() > 0)
            || ($v->hierarchy == 1 && $count > 1)) {
            throw new \RuntimeException("Cannot have more than one parent in vocabulary '$v->name'");
        }
    }

    /**
     * Remove the parents form this term
     *
     * @param int $term_id
     * @return bool
     */
    public function unsetParents($term_id)
    {
        return $this->termHierarchyRepository->unsetParents($term_id);
    }

    /**
     * Get all the terms of a vocabulary
     *
     * @param int $vocabulary_id
     * @return array
     */
    public function getTermsForVocabulary($vocabulary_id)
    {
        return $this->cache->remember(
            'Rocket::Taxonomy::Terms::' . $vocabulary_id,
            60,
            function () use ($vocabulary_id) {
                $terms = TermContainer::where('vocabulary_id', $vocabulary_id)->get(['id']);

                $results = [];
                if (!empty($terms)) {
                    foreach ($terms as $term) {
                        $results[] = $term->id;
                    }
                }

                return $results;
            }
        );
    }

    /**
     * Search a specific term, if it doesn't exist, returns false
     *
     * @param  string $term
     * @param  int $vocabulary_id
     * @param  int $language_id
     * @param  array $exclude
     * @return int|null
     */
    public function searchTerm($term, $vocabulary_id, $language_id = null, $exclude = [])
    {
        $language_id = $this->getLanguage($vocabulary_id, $language_id);

        $term = trim($term);
        if ($term == '') {
            return;
        }

        $query = TermData::select('taxonomy_terms.id')
            ->join('taxonomy_terms', 'taxonomy_terms.id', '=', 'taxonomy_terms_data.term_id')
            ->where('taxonomy_terms.vocabulary_id', $vocabulary_id)
            ->where('taxonomy_terms_data.language_id', $language_id)
            ->where('taxonomy_terms_data.title', $term);

        if (count($exclude)) {
            $query->whereNotIn('taxonomy_terms.id', $exclude);
        }

        return $query->value('id');
    }

    /**
     * Returns the id of a term, if it doesn't exist, creates it.
     *
     * @param  string $title
     * @param  int $vocabulary_id
     * @param  int $language_id
     * @param  int $type
     * @return bool|int
     */
    public function getTermId($title, $vocabulary_id, $language_id = null, $type = 0)
    {
        $title = trim($title);
        if ($title == '') {
            return false;
        }

        if (!is_numeric($vocabulary_id)) {
            $vocabulary_id = $this->vocabulary($vocabulary_id);
        }

        $language_id = $this->getLanguage($vocabulary_id, $language_id);

        $search = $this->searchTerm($title, $vocabulary_id, $language_id);
        if ($search !== null) {
            return $search;
        }

        // Add term
        $term = new TermContainer(['vocabulary_id' => $vocabulary_id]);

        if ($type !== 0) {
            $term->type = $type;
        }
        $term->save();

        // Add translation
        $translation = [
            'language_id' => $language_id,
            'title' => $title,
        ];
        $term->translations()->save(new TermData($translation));

        return $term->id;
    }

    /**
     * Adds one or more tags and returns an array of id's
     *
     * @param array $taxonomies
     * @return array
     */
    public function getTermIds($taxonomies)
    {
        $tags = [];
        foreach ($taxonomies as $voc => $terms) {
            $vocabulary_id = $this->vocabulary($voc);
            $exploded = is_array($terms) ? $terms : explode(',', $terms);

            foreach ($exploded as $term) {
                $result = $this->getTermId($term, $vocabulary_id);
                if ($result) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
                    $tags[] = $result;
                }
            }
        }

        return $tags;
    }
}


1		<?php namespace Rocket\Taxonomy;
2
3		use Illuminate\Contracts\Cache\Repository as CacheRepository;
4		use Rocket\Taxonomy\Model\Hierarchy;
5		use Rocket\Taxonomy\Model\TermContainer;
6		use Rocket\Taxonomy\Model\TermData;
7		use Rocket\Taxonomy\Model\Vocabulary;
8		use Rocket\Taxonomy\Repositories\TermHierarchyRepositoryInterface as TermHieraRep;
9		use Rocket\Taxonomy\Repositories\TermRepositoryInterface as TermRep;
10		use Rocket\Translation\Support\Laravel5\Facade as I18N;
11
12		/**
13		* The Taxonomy base class handles the cache and the creation/modification of terms
14		*/
15		class Taxonomy implements TaxonomyInterface
16		{
17		/**
18		* @var array Terms internal cache
19		*/
20		public $terms = [];
21
22		/**
23		* @var array List of vocabularies by ID
24		*/
25		protected $vocabularyById = [];
26
27		/**
28		* @var array List of vocabularies by Name
29		*/
30		protected $vocabularyByName = [];
31
32		/**
33		* @var CacheRepository The repository to cache Terms
34		*/
35		protected $cache;
36
37		/**
38		* @var TermRep The repository to load Terms
39		*/
40		protected $termRepository;
41
42		/**
43		* @var TermHieraRep The repository to handle terms hierarchies
44		*/
45		protected $termHierarchyRepository;
46
47		/**
48		* Initialize the Taxonomy system, Loads all existing vocabularies
49		*
50		* @param CacheRepository $cache The cache repository
51		* @param TermRep $termRepository The term retrieval repository
52		* @param TermHieraRep $termHierarchyRepository The term hierarchy repository
53		*/
54		public function __construct(CacheRepository $cache, TermRep $termRepository, TermHieraRep $termHierarchyRepository)
55		{
56		$this->termRepository = $termRepository;
57		$this->termHierarchyRepository = $termHierarchyRepository;
58		$this->cache = $cache;
59	192
60		// Get the list of vocabularies
61	192	$vocs = $cache->remember('Rocket::Taxonomy::Vocabularies', 60 * 24 * 7, function () {
62	192	return Vocabulary::all();
63	192	});
64
65		// Initialize the search for terms
66		foreach ($vocs as $v) {
67	192	$this->vocabularyByName[$v->machine_name] = $this->vocabularyById[$v->id] = $v;
68	192	}
69		}
70
71	192	/**
72	186	* Is this vocabulary translatable ?
73	192	*
74	192	* @param int\|string $vid
75		* @return bool
76		*/
77		public function isTranslatable($vid)
78		{
79		if (!is_numeric($vid)) {
80		$vid = $this->vocabulary($vid);
81		}
82	180
83		return $this->vocabularyById[$vid]->isTranslatable();
84	180	}
85	3
86	3	/**
87		* Get the internal language for the vocabulary
88	180	*
89		* This will return the language_id if the vocabulary is translated or 1 if it's not
90		*
91		* @param int\|string $vocabulary_id
92		* @param int $language_id
93		* @return int\|null
94		*/
95		public function getLanguage($vocabulary_id, $language_id = null)
96		{
97		if (!$this->isTranslatable($vocabulary_id)) {
98		return 1;
99		}
100	177
101		if ($language_id === null) {
102	177	return I18N::getCurrentId();
103	33	}
104
105		return $language_id;
106	150	}
107	150
108		/**
109		* Get a vocabulary by name or ID
110	150	*
111		* Taxonomy::vocabulary(1);
112		* returns 'tags'
113		*
114		* Taxonomy::vocabulary('tags');
115		* returns 1
116		*
117		* @param int\|string $key
118		* @return mixed
119		*/
120		public function vocabulary($key)
121		{
122		if (is_numeric($key)) {
123		return $this->vocabularyById[$key]->machine_name;
124		}
125	186
126		return $this->vocabularyByName[$key]->id;
127	186	}
128	3
129		/**
130		* Get all vocabularies with keys as id's
131	186	*
132		* @return array
133		*/
134		public function vocabularies()
135		{
136		return $this->vocabularyById;
137		}
138
139	6	/**
140		* Get a term with all translations
141	6	*
142		* @param int $term_id The term's ID
143		* @param bool $from_cache Should we take this term from cache or request a fresh one ?
144		* @return Term
145		*/
146		public function getTerm($term_id, $from_cache = true)
147		{
148		if ($from_cache && array_key_exists($term_id, $this->terms)) {
149		return $this->terms[$term_id];
150		}
151	39
152		$data = $this->termRepository->getTerm($term_id);
153	39	$this->terms[$term_id] = $data;
154	3
155		return $data;
156		}
157	39
158	39	/**
159		* Remove a term from the cache
160	39	*
161		* @param int $term_id
162		* @return bool
163		*/
164		public function uncacheTerm($term_id)
165		{
166		if (array_key_exists($term_id, $this->terms)) {
167		unset($this->terms[$term_id]);
168		}
169	174
170		return $this->termRepository->uncacheTerm($term_id);
171	174	}
172	3
173	3	/**
174		* Get all paths for a term
175	174	*
176		* @param int $term_id
177		* @return array<array<int>>
178		*/
179		public function getAncestryPaths($term_id)
180		{
181		return $this->termHierarchyRepository->getAncestryPaths($term_id);
182		}
183
184	12	/**
185		* Get all paths for a term
186	12	*
187		* @param int $term_id
188		* @return array<array<int>>
189		*/
190		public function getDescentPaths($term_id)
191		{
192		return $this->termHierarchyRepository->getDescentPaths($term_id);
193		}
194
195	12	/**
196		* Get the complete graph
197	12	* @param int $term_id
198		* @return array
199		*/
200		public function getAncestryGraph($term_id)
201		{
202		return $this->termHierarchyRepository->getAncestryGraph($term_id);
203		}
204
205	3	/**
206		* Get the complete graph
207	3	* @param int $term_id
208		* @return array
209		*/
210		public function getDescentGraph($term_id)
211		{
212		return $this->termHierarchyRepository->getDescentGraph($term_id);
213		}
214
215	3	/**
216		* Add one parent to a term
217	3	*
218		* @param int $term_id
219		* @param int $parent_id
220		*/
221		public function addParent($term_id, $parent_id)
222		{
223		$this->testCanAddParents($term_id, 1);
224
225		$this->termHierarchyRepository->addParent($term_id, $parent_id);
226	111	}
227
228	111	/**
229		* Add a list of parents to a term
230	108	*
231	108	* @param int $term_id
232		* @param array<integer> $parent_ids
233		*/
234		public function addParents($term_id, array $parent_ids)
235		{
236		$this->testCanAddParents($term_id, count($parent_ids));
237
238		foreach ($parent_ids as $id) {
239	6	$this->termHierarchyRepository->addParent($term_id, $id);
240		}
241	6	}
242
243	6	/**
244	6	* Test if the term can have more parents
245	6	*
246	6	* @param int $term_id
247		* @param int $count
248		* @throws \RuntimeException
249		*/
250		protected function testCanAddParents($term_id, $count)
251		{
252		$vocabulary = (new Vocabulary())->getTable();
253		$term = (new TermContainer())->getTable();
254		$v = Vocabulary::select('hierarchy', 'name')
255	114	->where("$term.id", $term_id)
256		->join($term, 'vocabulary_id', '=', "$vocabulary.id")
257	114	->first();
258	114
259	114	if ($v->hierarchy == 0) {
260	114	throw new \RuntimeException("Cannot add a parent in vocabulary '$v->name'");
261	114	}
262	114
263		if (($v->hierarchy == 1 && Hierarchy::where('term_id', $term_id)->count() > 0)
264	114	\|\| ($v->hierarchy == 1 && $count > 1)) {
265	3	throw new \RuntimeException("Cannot have more than one parent in vocabulary '$v->name'");
266		}
267		}
268	111
269	111	/**
270	3	* Remove the parents form this term
271		*
272	111	* @param int $term_id
273		* @return bool
274		*/
275		public function unsetParents($term_id)
276		{
277		return $this->termHierarchyRepository->unsetParents($term_id);
278		}
279
280	6	/**
281		* Get all the terms of a vocabulary
282	6	*
283		* @param int $vocabulary_id
284		* @return array
285		*/
286		public function getTermsForVocabulary($vocabulary_id)
287		{
288		return $this->cache->remember(
289		'Rocket::Taxonomy::Terms::' . $vocabulary_id,
290		60,
291	3	function () use ($vocabulary_id) {
292		$terms = TermContainer::where('vocabulary_id', $vocabulary_id)->get(['id']);
293	3
294	3	$results = [];
295	3	if (!empty($terms)) {
296	3	foreach ($terms as $term) {
297	3	$results[] = $term->id;
298		}
299	3	}
300	3
301	3	return $results;
302	3	}
303	3	);
304	3	}
305
306	3	/**
307		* Search a specific term, if it doesn't exist, returns false
308	3	*
309		* @param string $term
310		* @param int $vocabulary_id
311		* @param int $language_id
312		* @param array $exclude
313		* @return int\|null
314		*/
315		public function searchTerm($term, $vocabulary_id, $language_id = null, $exclude = [])
316		{
317		$language_id = $this->getLanguage($vocabulary_id, $language_id);
318
319		$term = trim($term);
320	174	if ($term == '') {
321		return;
322	174	}
323
324	174	$query = TermData::select('taxonomy_terms.id')
325	174	->join('taxonomy_terms', 'taxonomy_terms.id', '=', 'taxonomy_terms_data.term_id')
326	3	->where('taxonomy_terms.vocabulary_id', $vocabulary_id)
327		->where('taxonomy_terms_data.language_id', $language_id)
328		->where('taxonomy_terms_data.title', $term);
329	174
330	174	if (count($exclude)) {
331	174	$query->whereNotIn('taxonomy_terms.id', $exclude);
332	174	}
333	174
334		return $query->value('id');
335	174	}
336	3
337	3	/**
338		* Returns the id of a term, if it doesn't exist, creates it.
339	174	*
340		* @param string $title
341		* @param int $vocabulary_id
342		* @param int $language_id
343		* @param int $type
344		* @return bool\|int
345		*/
346		public function getTermId($title, $vocabulary_id, $language_id = null, $type = 0)
347		{
348		$title = trim($title);
349		if ($title == '') {
350		return false;
351	177	}
352
353	177	if (!is_numeric($vocabulary_id)) {
354	177	$vocabulary_id = $this->vocabulary($vocabulary_id);
355	3	}
356
357		$language_id = $this->getLanguage($vocabulary_id, $language_id);
358	174
359	15	$search = $this->searchTerm($title, $vocabulary_id, $language_id);
360	15	if ($search !== null) {
361		return $search;
362	174	}
363
364	174	// Add term
365	174	$term = new TermContainer(['vocabulary_id' => $vocabulary_id]);
366	21
367		if ($type !== 0) {
368		$term->type = $type;
369		}
370	174	$term->save();
371
372	174	// Add translation
373	6	$translation = [
374	6	'language_id' => $language_id,
375	174	'title' => $title,
376		];
377		$term->translations()->save(new TermData($translation));
378
379	174	return $term->id;
380	174	}
381	174
382	174	/**
383		* Adds one or more tags and returns an array of id's
384	174	*
385		* @param array $taxonomies
386		* @return array
387		*/
388		public function getTermIds($taxonomies)
389		{
390		$tags = [];
391		foreach ($taxonomies as $voc => $terms) {
392		$vocabulary_id = $this->vocabulary($voc);
393	30	$exploded = is_array($terms) ? $terms : explode(',', $terms);
394
395	30	foreach ($exploded as $term) {
396	30	$result = $this->getTermId($term, $vocabulary_id);
397	30	if ($result) {
		0 ignored issues – show Bug Best Practice introduced 2016-06-01 20:03 UTC by Report Bug Copy Issue Report The expression `$result` of type `false\|integer` is loosely compared to `true`; this is ambiguous if the integer can be zero. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `integer` values, zero is a special case, in particular the following results might be unexpected: 0 == false // true 0 == null // true 123 == false // false 123 == null // false // It is often better to use strict comparison 0 === false // false 0 === null // false Loading history...
398	30	$tags[] = $result;
399		}
400	30	}
401	30	}
402	30
403	30	return $tags;
404	30	}
405		}
406

RocketPropelledTortoise / Core

Taxonomy::vocabulary() A last analyzed 2020-04-19 15:33 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Taxonomy::vocabulary() A
last analyzed 2020-04-19 15:33 UTC