Subversion-Projekte lars-tiefland.php_share

<?php 
require_once 'GetAttributesCSRequestType.php';
require_once 'GetAttributesCSResponseType.php';

class EbatNs_CharacteristicSetDependencyLinker
{
        private $_CharactericsSet = array();
        private $_AttributeSystemVersion;
        
        private $_proxy;
        
        private $_csIdent;
        private $_attribIdent;
        private $_valueIdent;
        
        public function __construct($proxy)
        {
                $this->_proxy = $proxy;
        }
        
        public function getCharactericsSetArray()
        {
                return $this->_CharactericsSet;
        }
        
        public function getCharactericsSet($index)
        {
                return $this->_CharactericsSet[$index];
        }
        
        public function getAttVersion()
        {
                return $this->_AttributeSystemVersion;
        }

        public function getCharactericsSetCount()
        {
                return count($this->_CharactericsSet);
        }
        
        // $csSetId could be either a single csSet-id or an array of ids
        public function fetchByCsSetId($csSetId, $VersionOnly = false)
        {
                if (is_array($csSetId))
                {
                        foreach($csSetId as $setId)
                                $this->_fetchCsSets($setId, $VersionOnly);                                      
                }
                else
                        $this->_fetchCsSets($csSetId, $VersionOnly);
        }
        
        // use $VersionOnly to populate only the version fields
        public function fetchAll($VersionOnly = false)
        {
                $this->_fetchCsSets(null, $VersionOnly);
        }
        
        // function to link the dependent attributes into their parent attribute values
        private function linkDependencies($attribList, $dependencies)
        {
                // get each parent attributeid and the dependencies for each value
                foreach($dependencies as $parentId => $parentValueArray)
                {
                        // reference to the parent attribute object
                        $parentAttribObj = &$attribList[$parentId];
                        // get each value of the parent attribute and the array of childs
                        foreach($parentValueArray as $parentValue => $childIdArray)
                                // get each attributeid of the childs and their arrays of values
                                foreach($childIdArray as $childId => $childValueArrays)
                                        // sometimes we have multiple arrays of values with the same child attributeid
                                        //   linking to valueid of the parent's attribute
                                        foreach($childValueArrays as $outerKey => $childValueArray)
                                        {
                                                // pick a copy of the attribute for the child attributeid
                                                if (is_object($attribList[$childId]))
                                                        // we have to use the clone keyword with brackets,
                                                        // as PHP4 doesn't know this keyword. a function clone()
                                                        // has to be defined in global scope. PHP5 ignores the
                                                        // brackets and executes the internal "clone"
                                                        $childAttribObj = clone($attribList[$childId]);
                                                else
                                                        $childAttribObj = $attribList[$childId];
                                                // empty the values of the child attribute, since we don't need all
                                                //   valueobjects of in the child attribute for the specific parent attribute
                                                $childAttribObj->getValueList()->setValue(array());
                                                // get the dependency type for a later rendering of the csset
                                                $dependencyType = $childValueArray[0];
                                                // get each valueobject to be linked to the parent attributes value
                                                foreach($childValueArray[1] as $key => $childValueObj)
                                                {
                                                        // get the valueid of the childs valueonject
                                                        $childValue = $childValueObj->getTypeAttribute('id');
                                                        // pick the childs attribute value and reference it to the 
                                                        //   parents value array
                                                        $childAttribObj->getValueList()->setValue($attribList[$childId]->getValueList()->getValue($this->_valueIdent[$childId][$childValue]), $key);
                                                        // unset the dependency object of the child attribute,
                                                        //   as we don't need it anymore
                                                        $childAttribObj->setDependency(null);
                                                }
                                                // update the count value for the inserted child attribute values
                                                $childAttribObj->getValueList()->attributeValues['count'] = count($childAttribObj->getValueList()->getValue());
                                                // insert the dependency type to the child attribute object for a later rendering
                                                $childAttribObj->attributeValues['dependencyType'] = $dependencyType;
                                                // copy the child attribute object to the parent's attribute value object
                                                $parentAttribObj->getValueList()->getValue($this->_valueIdent[$parentId][$parentValue])->setDependencyList($childAttribObj, $outerKey);
                                                // unset the dependency object of the parent attribute,
                                                //   as we don't need it anymore
                                                $parentAttribObj->setDependency(null);
                                        }
                }
                
                return $attribList;
        }
        
        // combine the working array of the linked attribute with the complete attributeData-section
        //   of the GetAttributesCS-call
        private function combineCharacteristics($attributeData, $linkedAttribs)
        {
                // get each linked attribute object and the cssetid it belongs to
                foreach($linkedAttribs as $linkedCharacteristicSetId => $linkedAttributeArray)
                {
                        // reference to the attribute array of the csset in the attributeData-section
                        //   of the GetAttributesCS-call
                        $characteristicsListInitial = &$attributeData->getCharacteristics(0)->getCharacteristicsSet($this->_csIdent[$linkedCharacteristicSetId])->getCharacteristicsList()->getInitial();
                        // empty the attribute array, since we have rebuilt all attributes in the working array
                        $characteristicsListInitial = array();
                        // get each linked attribute to copy it to the reference of the attributeData
                        foreach($linkedAttributeArray as $linkedAttribute)
                                // don't copy attributes which are a child (have a parent attribute id),
                                //   since we have linked/inserted them to the parent attributes
                                if (!isset($linkedAttribute->attributeValues['parentAttrId']))
                                        $characteristicsListInitial[] = $linkedAttribute;
                }

                return $attributeData;
        }
        
        // - build some arrays for an easy location of the sets, attributes and value
        //     deep inside the characteristic sets
        // - copy all attributes and their dependencies to link them together
        private function manageDependencies($attributeData)
        {
                // array to identify and locate the cssets
                $this->_csIdent = array();

                // pick up all cssets to link the dependent attributes of each set                      
                $characteristics = $attributeData->getCharacteristics();
                $CharacteristicsSets = $characteristics[0]->getCharacteristicsSet();
                foreach($CharacteristicsSets as $CharacteristicsSetKey => $CharacteristicsSet)
                {
                        // working array of all attributes in a set
                        $copyAttribs = array();
                        // working array of all dependencies between all attributes in a set
                        $depArray = array();
                        // array to identify and locate the attributes
                        $this->_attribIdent = array();
                        // array to identify and locate the attributevalues
                        $this->_valueIdent = array();
                        
                        // save the array-keyids of each csset for an easy location
                        $this->_csIdent[$CharacteristicsSet->attributeValues['id']] = $CharacteristicsSetKey;
                        
                        // pick up all attributes and dependencies in the set and copy them 
                        //   to the working arrays
                        $csAttribs = $CharacteristicsSet->getCharacteristicsList()->getInitial();
                        foreach($csAttribs as $csAttribKey => $csAttrib)
                        {
                                // save the array-keyids of each attribute for an easy location
                                $this->_attribIdent[$csAttrib->attributeValues['id']] = $csAttribKey;
                                // copy each attribute to the working array
                                $copyAttribs[$csAttrib->attributeValues['id']] = $csAttrib;

                                // pick up all attributevalues and dependencies of the attribute
                                if ($csAttrib->getValueList())
                                {
                                        // save the array-keyids of each value of the attribute
                                        //   for an easy location
                                        foreach($csAttrib->getValueList()->getValue() as $valueKey => $valueList)
                                                $this->_valueIdent[$csAttrib->attributeValues['id']][$valueList->attributeValues['id']] = $valueKey;
                                }
                                
                                if ($csAttrib->getDependency())
                                {
                                        // build the working array of all dependencies of the attribute
                                        foreach($csAttrib->getDependency() as $dependency)
                                                $depArray[$csAttrib->attributeValues['id']][$dependency->attributeValues['parentValueId']][$dependency->attributeValues['childAttrId']][] = array($dependency->attributeValues['type'], $dependency->getValue());
                                }
                        }

                        // link all dependencies of a single csset to the attributes
                        $linkedAttribs[$CharacteristicsSet->attributeValues['id']] = $this->linkDependencies($copyAttribs, $depArray);
                }
        
                // combine the linked working arrays of all cssets with the attributeData-section
                //   of the GetAttributesCS-call
                $combinedCharacteristicSets = $this->combineCharacteristics($attributeData, $linkedAttribs);

                return $combinedCharacteristicSets;
        }

        // $CsIdToGet can be null (and so loading ALL CsSets)
        // use $VersionOnly to populate only the version fields
        private function _fetchCsSets($CsIdToGet, $VersionOnly = false)
        {
                // so query the CharactericsSet ...
                $request = new GetAttributesCSRequestType(); 
                
                if ($CsIdToGet)
                        $request->setAttributeSetID($CsIdToGet);

                if (!$VersionOnly)
                {
                        $request->setDetailLevel('ReturnAll');
                }

                $response = $this->_proxy->GetAttributesCS($request);
                
                $this->_AttributeSystemVersion = $response->getAttributeSystemVersion();
                
                if (!$VersionOnly)
                {
                        $attributeData = $response->getAttributeData();

                        $parser = $this->_proxy->getParser('http://www.intradesys.com/Schemas/ebay/AttributeData_Extension.xsd');
                        $parser->setExtensionPrefix('EbatNsCsSetExt_');
                                                                        
                        $parserResponse = $parser->decode('eBay', '<?xml version="1.0" encoding="utf-8" ?>' . utf8_encode($attributeData), 3, 'EbatNsCsSetExt_AttributeDataType');

                        $attributeDependencyData = $this->manageDependencies($parserResponse);

                        $characteristics = $attributeDependencyData->getCharacteristics();
                        $characteristics = $characteristics[0];

                        $characteristicSets = $characteristics->getCharacteristicsSet();
                        foreach($characteristicSets as $characteristicSet)
                        {
                                $this->_CharactericsSet[$characteristicSet->attributeValues['id']] = $characteristicSet;
                        }
                }
        }
}
?>