TechDivision\Import\Category\Listeners\SortCategoryListener::categoriesOnSameLevel()

Complexity

Conditions	10
Paths	16

Size

Total Lines

64

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    private function categoriesOnSameLevel(string $path) : array
    {

        // initialize the array for the categories an the same level
        $categoriesOnSameLevel = array();

        // explode the path by the category separator
        $elements = $this->serializer->unserialize($path, '/');

        // iterate over the existing categories to load the one's on the same level
        foreach ($this->existingCategories as $p => $category) {
            // initialize the counter with the size of elements
            $sizeOfElements = sizeof($elements);
            // query whether or not the level (integer) is the same as the number of elements
            // AND the category is NOT a root category. This means we virtually cut off the
            // last element of the passed category. Then we know the category is at least on
            // the same level, but NOT if it has the same parent category!!!!!
            if ((int) $category[MemberNames::LEVEL] == $sizeOfElements && $sizeOfElements > 1) {
                // extract the category's path by the category separator
                $el = $this->serializer->unserialize($p, '/');
                // diff the path of the parent category to make sure they are children of the same parent node
                $diff = array_diff(array_slice($elements, 0, sizeof($elements) - 1), array_slice($el, 0, sizeof($elements)));
                // BINGO: We found a category on the same level that has the same parent
                if (sizeof($diff) === 0) {
                    $categoriesOnSameLevel[$p] = $this->template(
                        array_merge(
                            $category,
                            array(ColumnKeys::ATTRIBUTE_SET_CODE => $this->getAttributeSetNameById($category[MemberNames::ATTRIBUTE_SET_ID]))
                        )
                    );
                }
            }
        }

        // iterate over the already processed categories and try to find the one's on the same level
        // because it's possible we've a NEW category in the CSV file which is NOT in the array with
        // the existing ones.
        foreach ($this->artefacts as $p => $artefact) {
            // extract the category's path by the category separator
            $el = $this->serializer->unserialize($p, '/');
            // query whether or not the categories are at least on the same level
            if (sizeof($el) == sizeof($elements)) {
                // diff the path of the parent category to make sure they are children of the same parent node
                $diff = array_diff(array_slice($elements, 0, sizeof($elements) - 1), array_slice($el, 0, sizeof($elements)));
                // BINGO: We found a category on the same level that has the same parent
                if (sizeof($diff) === 0) {
                    $categoriesOnSameLevel[$p] = $artefact;
                }
            }
        }

        // sor the categories by their position and KEEP the keys
        uasort($categoriesOnSameLevel, function ($a, $b) {
            // return 0 when the position is equal (should never happen)
            if ($a[MemberNames::POSITION] == $b[MemberNames::POSITION]) {
                return 0;
            }
            // return 1 or -1 if the categories position differs
            return $a[MemberNames::POSITION] > $b[MemberNames::POSITION] ? 1 : -1;
        });

        // return the sorted array with categories on the same level and the same parent node
        return $categoriesOnSameLevel;
    }