DansMaCulotte\PrestashopWebService\PrestashopWebService

Complexity

Total Complexity

28

Size/Duplication

Total Lines	163
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getSchema()	0	4	1
A	fillSchema()	0	17	3
A	getLanguageValue()	0	12	3
A	fillLanguageNode()	0	6	2
A	processNode()	0	17	6
A	checkForUselessNodes()	0	13	4
A	removeSpecificNodes()	0	6	2
A	createNode()	0	15	4
A	emptyNode()	0	11	3

<?php

namespace DansMaCulotte\PrestashopWebService;

use SimpleXMLElement;

class PrestashopWebService extends PrestashopWebServiceLibrary
{

    /**
     * Retrieve the resource schema
     *
     * @param $resource
     * @param string $schema
     * @return SimpleXMLElement
     * @throws Exceptions\PrestashopWebServiceException
     */
    public function getSchema($resource, $schema = 'blank')
    {
        return $this->get(['resource' => $resource . "?schema=$schema"]);
    }

    /**
     * Fill the provided schema with an associative array data, also remove the useless XML nodes if
     * the corresponding flag is true
     *
     * @param SimpleXMLElement $xmlSchema
     * @param array $data
     * @param bool $removeUselessNodes set true if you want to remove nodes that are not present in the data array
     * @param array $removeSpecificNodes If $removeUselessNodes is false you may add here the first level nodes that
     *                                   you want to remove
     * @return SimpleXMLElement
     */
    public function fillSchema(
        SimpleXMLElement $xmlSchema,
        $data,
        $removeUselessNodes = true,
        $removeSpecificNodes = []
    ) {
        $resource = $xmlSchema->children()->children();
        foreach ($data as $key => $value) {
            $this->processNode($resource, $key, $value);
        }
        if ($removeUselessNodes) {
            $this->checkForUselessNodes($resource, $data);
        } else {
            $this->removeSpecificNodes($resource, $removeSpecificNodes);
        }
        return $xmlSchema;
    }

    /**
     * @param string|array $data
     * @param $languageId
     * @return string
     */
    private function getLanguageValue($data, $languageId)
    {
        if (is_string($data)) {
            return $data;
        }

        if (array_key_exists($languageId, $data)) {
            return $data[$languageId];
        } else {
            return $data[1];
        }
    }

    /**
     * @param $node
     * @param $data
     */
    private function fillLanguageNode($node, $data)
    {
        for ($i = 0; $i < count($node->language); $i++) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

            $node->language[$i] = $this->getLanguageValue($data, (int) $node->language[$i]['id']->__toString());
        }
    }

    /**
     * @param SimpleXMLElement $node
     * @param $dataKey
     * @param $dataValue
     */
    private function processNode(SimpleXMLElement $node, $dataKey, $dataValue)
    {
        if (is_int($dataKey)) {
            if ($dataKey === 0) {
                $this->emptyNode($node);
            }
            $this->createNode($node, $dataValue);
        } elseif (property_exists($node->$dataKey, 'language')) {
            $this->fillLanguageNode($node->$dataKey, $dataValue);
        } elseif (is_array($dataValue)) {
            foreach ($dataValue as $key => $value) {
                $this->processNode($node->$dataKey, $key, $value);
            }
        } else {
            $node->$dataKey = $dataValue;
        }
    }

    /**
     * Remove XML first level nodes that are not present int the data array
     * @param SimpleXMLElement $resource
     * @param $data
     */
    private function checkForUselessNodes(SimpleXMLElement $resource, $data)
    {
        $uselessNodes = [];
        foreach ($resource as $key => $value) {
            if (!array_key_exists($key, $data)) {
                $uselessNodes[] = $key;
            }
        }

        foreach ($uselessNodes as $key) {
            unset($resource->$key);
        }
    }

    /**
     * Remove the given nodes from the resource
     * @param $resource
     * @param $removeSpecificNodes
     */
    private function removeSpecificNodes($resource, $removeSpecificNodes)
    {
        foreach ($removeSpecificNodes as $node) {
            unset($resource->$node);
        }
    }

    /**
     * @param SimpleXMLElement $node
     * @param array $dataValue
     */
    private function createNode(SimpleXMLElement $node, $dataValue)
    {
        foreach ($dataValue as $key => $value) {
            if (is_array($value)) {
                if (is_int($key)) {
                    $this->createNode($node, $value);
                } else {
                    $childNode=$node->addChild($key);
                    $this->createNode($childNode, $value);
                }
            } else {
                $node->addChild($key, $value);
            }
        }
    }

    /**
     * @param SimpleXMLElement $node
     */
    private function emptyNode(SimpleXMLElement $node)
    {
        $nodeNames = [];
        foreach ($node->children() as $key => $value) {
            $nodeNames[]=$key;
        }

        foreach ($nodeNames as $nodeName) {
            unset($node->$nodeName);
        }
    }
}