Spaces:
Sleeping
Sleeping
| /** | |
| * parses an XML Schema, allows access to it's data, other utility methods | |
| * no validation... yet. | |
| * very experimental and limited. As is discussed on XML-DEV, I'm one of the people | |
| * that just doesn't have time to read the spec(s) thoroughly, and just have a couple of trusty | |
| * tutorials I refer to :) | |
| * | |
| * @author Dietrich Ayala <dietrich@ganx4.com> | |
| * @version $Id: class.xmlschema.php,v 1.39 2005/08/04 01:27:42 snichol Exp $ | |
| * @access public | |
| */ | |
| class XMLSchema extends nusoap_base { | |
| // files | |
| var $schema = ''; | |
| var $xml = ''; | |
| // namespaces | |
| var $enclosingNamespaces; | |
| // schema info | |
| var $schemaInfo = array(); | |
| var $schemaTargetNamespace = ''; | |
| // types, elements, attributes defined by the schema | |
| var $attributes = array(); | |
| var $complexTypes = array(); | |
| var $complexTypeStack = array(); | |
| var $currentComplexType = null; | |
| var $elements = array(); | |
| var $elementStack = array(); | |
| var $currentElement = null; | |
| var $simpleTypes = array(); | |
| var $simpleTypeStack = array(); | |
| var $currentSimpleType = null; | |
| // imports | |
| var $imports = array(); | |
| // parser vars | |
| var $parser; | |
| var $position = 0; | |
| var $depth = 0; | |
| var $depth_array = array(); | |
| var $message = array(); | |
| var $defaultNamespace = array(); | |
| /** | |
| * constructor | |
| * | |
| * @param string $schema schema document URI | |
| * @param string $xml xml document URI | |
| * @param string $namespaces namespaces defined in enclosing XML | |
| * @access public | |
| */ | |
| function XMLSchema($schema='',$xml='',$namespaces=array()){ | |
| parent::nusoap_base(); | |
| $this->debug('xmlschema class instantiated, inside constructor'); | |
| // files | |
| $this->schema = $schema; | |
| $this->xml = $xml; | |
| // namespaces | |
| $this->enclosingNamespaces = $namespaces; | |
| $this->namespaces = array_merge($this->namespaces, $namespaces); | |
| // parse schema file | |
| if($schema != ''){ | |
| $this->debug('initial schema file: '.$schema); | |
| $this->parseFile($schema, 'schema'); | |
| } | |
| // parse xml file | |
| if($xml != ''){ | |
| $this->debug('initial xml file: '.$xml); | |
| $this->parseFile($xml, 'xml'); | |
| } | |
| } | |
| /** | |
| * parse an XML file | |
| * | |
| * @param string $xml, path/URL to XML file | |
| * @param string $type, (schema | xml) | |
| * @return boolean | |
| * @access public | |
| */ | |
| function parseFile($xml,$type){ | |
| // parse xml file | |
| if($xml != ""){ | |
| $xmlStr = @join("",@file($xml)); | |
| if($xmlStr == ""){ | |
| $msg = 'Error reading XML from '.$xml; | |
| $this->setError($msg); | |
| $this->debug($msg); | |
| return false; | |
| } else { | |
| $this->debug("parsing $xml"); | |
| $this->parseString($xmlStr,$type); | |
| $this->debug("done parsing $xml"); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| /** | |
| * parse an XML string | |
| * | |
| * @param string $xml path or URL | |
| * @param string $type, (schema|xml) | |
| * @access private | |
| */ | |
| function parseString($xml,$type){ | |
| // parse xml string | |
| if($xml != ""){ | |
| // Create an XML parser. | |
| $this->parser = xml_parser_create(); | |
| // Set the options for parsing the XML data. | |
| xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, 0); | |
| // Set the object for the parser. | |
| xml_set_object($this->parser, $this); | |
| // Set the element handlers for the parser. | |
| if($type == "schema"){ | |
| xml_set_element_handler($this->parser, 'schemaStartElement','schemaEndElement'); | |
| xml_set_character_data_handler($this->parser,'schemaCharacterData'); | |
| } elseif($type == "xml"){ | |
| xml_set_element_handler($this->parser, 'xmlStartElement','xmlEndElement'); | |
| xml_set_character_data_handler($this->parser,'xmlCharacterData'); | |
| } | |
| // Parse the XML file. | |
| if(!xml_parse($this->parser,$xml,true)){ | |
| // Display an error message. | |
| $errstr = sprintf('XML error parsing XML schema on line %d: %s', | |
| xml_get_current_line_number($this->parser), | |
| xml_error_string(xml_get_error_code($this->parser)) | |
| ); | |
| $this->debug($errstr); | |
| $this->debug("XML payload:\n" . $xml); | |
| $this->setError($errstr); | |
| } | |
| xml_parser_free($this->parser); | |
| } else{ | |
| $this->debug('no xml passed to parseString()!!'); | |
| $this->setError('no xml passed to parseString()!!'); | |
| } | |
| } | |
| /** | |
| * start-element handler | |
| * | |
| * @param string $parser XML parser object | |
| * @param string $name element name | |
| * @param string $attrs associative array of attributes | |
| * @access private | |
| */ | |
| function schemaStartElement($parser, $name, $attrs) { | |
| // position in the total number of elements, starting from 0 | |
| $pos = $this->position++; | |
| $depth = $this->depth++; | |
| // set self as current value for this depth | |
| $this->depth_array[$depth] = $pos; | |
| $this->message[$pos] = array('cdata' => ''); | |
| if ($depth > 0) { | |
| $this->defaultNamespace[$pos] = $this->defaultNamespace[$this->depth_array[$depth - 1]]; | |
| } else { | |
| $this->defaultNamespace[$pos] = false; | |
| } | |
| // get element prefix | |
| if($prefix = $this->getPrefix($name)){ | |
| // get unqualified name | |
| $name = $this->getLocalPart($name); | |
| } else { | |
| $prefix = ''; | |
| } | |
| // loop thru attributes, expanding, and registering namespace declarations | |
| if(count($attrs) > 0){ | |
| foreach($attrs as $k => $v){ | |
| // if ns declarations, add to class level array of valid namespaces | |
| if(ereg("^xmlns",$k)){ | |
| //$this->xdebug("$k: $v"); | |
| //$this->xdebug('ns_prefix: '.$this->getPrefix($k)); | |
| if($ns_prefix = substr(strrchr($k,':'),1)){ | |
| //$this->xdebug("Add namespace[$ns_prefix] = $v"); | |
| $this->namespaces[$ns_prefix] = $v; | |
| } else { | |
| $this->defaultNamespace[$pos] = $v; | |
| if (! $this->getPrefixFromNamespace($v)) { | |
| $this->namespaces['ns'.(count($this->namespaces)+1)] = $v; | |
| } | |
| } | |
| if($v == 'http://www.w3.org/2001/XMLSchema' || $v == 'http://www.w3.org/1999/XMLSchema' || $v == 'http://www.w3.org/2000/10/XMLSchema'){ | |
| $this->XMLSchemaVersion = $v; | |
| $this->namespaces['xsi'] = $v.'-instance'; | |
| } | |
| } | |
| } | |
| foreach($attrs as $k => $v){ | |
| // expand each attribute | |
| $k = strpos($k,':') ? $this->expandQname($k) : $k; | |
| $v = strpos($v,':') ? $this->expandQname($v) : $v; | |
| $eAttrs[$k] = $v; | |
| } | |
| $attrs = $eAttrs; | |
| } else { | |
| $attrs = array(); | |
| } | |
| // find status, register data | |
| switch($name){ | |
| case 'all': // (optional) compositor content for a complexType | |
| case 'choice': | |
| case 'group': | |
| case 'sequence': | |
| //$this->xdebug("compositor $name for currentComplexType: $this->currentComplexType and currentElement: $this->currentElement"); | |
| $this->complexTypes[$this->currentComplexType]['compositor'] = $name; | |
| //if($name == 'all' || $name == 'sequence'){ | |
| // $this->complexTypes[$this->currentComplexType]['phpType'] = 'struct'; | |
| //} | |
| break; | |
| case 'attribute': // complexType attribute | |
| //$this->xdebug("parsing attribute $attrs[name] $attrs[ref] of value: ".$attrs['http://schemas.xmlsoap.org/wsdl/:arrayType']); | |
| $this->xdebug("parsing attribute:"); | |
| $this->appendDebug($this->varDump($attrs)); | |
| if (!isset($attrs['form'])) { | |
| $attrs['form'] = $this->schemaInfo['attributeFormDefault']; | |
| } | |
| if (isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'])) { | |
| $v = $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType']; | |
| if (!strpos($v, ':')) { | |
| // no namespace in arrayType attribute value... | |
| if ($this->defaultNamespace[$pos]) { | |
| // ...so use the default | |
| $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'] = $this->defaultNamespace[$pos] . ':' . $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType']; | |
| } | |
| } | |
| } | |
| if(isset($attrs['name'])){ | |
| $this->attributes[$attrs['name']] = $attrs; | |
| $aname = $attrs['name']; | |
| } elseif(isset($attrs['ref']) && $attrs['ref'] == 'http://schemas.xmlsoap.org/soap/encoding/:arrayType'){ | |
| if (isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'])) { | |
| $aname = $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType']; | |
| } else { | |
| $aname = ''; | |
| } | |
| } elseif(isset($attrs['ref'])){ | |
| $aname = $attrs['ref']; | |
| $this->attributes[$attrs['ref']] = $attrs; | |
| } | |
| if($this->currentComplexType){ // This should *always* be | |
| $this->complexTypes[$this->currentComplexType]['attrs'][$aname] = $attrs; | |
| } | |
| // arrayType attribute | |
| if(isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType']) || $this->getLocalPart($aname) == 'arrayType'){ | |
| $this->complexTypes[$this->currentComplexType]['phpType'] = 'array'; | |
| $prefix = $this->getPrefix($aname); | |
| if(isset($attrs['http://schemas.xmlsoap.org/wsdl/:arrayType'])){ | |
| $v = $attrs['http://schemas.xmlsoap.org/wsdl/:arrayType']; | |
| } else { | |
| $v = ''; | |
| } | |
| if(strpos($v,'[,]')){ | |
| $this->complexTypes[$this->currentComplexType]['multidimensional'] = true; | |
| } | |
| $v = substr($v,0,strpos($v,'[')); // clip the [] | |
| if(!strpos($v,':') && isset($this->typemap[$this->XMLSchemaVersion][$v])){ | |
| $v = $this->XMLSchemaVersion.':'.$v; | |
| } | |
| $this->complexTypes[$this->currentComplexType]['arrayType'] = $v; | |
| } | |
| break; | |
| case 'complexContent': // (optional) content for a complexType | |
| break; | |
| case 'complexType': | |
| array_push($this->complexTypeStack, $this->currentComplexType); | |
| if(isset($attrs['name'])){ | |
| $this->xdebug('processing named complexType '.$attrs['name']); | |
| //$this->currentElement = false; | |
| $this->currentComplexType = $attrs['name']; | |
| $this->complexTypes[$this->currentComplexType] = $attrs; | |
| $this->complexTypes[$this->currentComplexType]['typeClass'] = 'complexType'; | |
| // This is for constructs like | |
| // <complexType name="ListOfString" base="soap:Array"> | |
| // <sequence> | |
| // <element name="string" type="xsd:string" | |
| // minOccurs="0" maxOccurs="unbounded" /> | |
| // </sequence> | |
| // </complexType> | |
| if(isset($attrs['base']) && ereg(':Array$',$attrs['base'])){ | |
| $this->xdebug('complexType is unusual array'); | |
| $this->complexTypes[$this->currentComplexType]['phpType'] = 'array'; | |
| } else { | |
| $this->complexTypes[$this->currentComplexType]['phpType'] = 'struct'; | |
| } | |
| }else{ | |
| $this->xdebug('processing unnamed complexType for element '.$this->currentElement); | |
| $this->currentComplexType = $this->currentElement . '_ContainedType'; | |
| //$this->currentElement = false; | |
| $this->complexTypes[$this->currentComplexType] = $attrs; | |
| $this->complexTypes[$this->currentComplexType]['typeClass'] = 'complexType'; | |
| // This is for constructs like | |
| // <complexType name="ListOfString" base="soap:Array"> | |
| // <sequence> | |
| // <element name="string" type="xsd:string" | |
| // minOccurs="0" maxOccurs="unbounded" /> | |
| // </sequence> | |
| // </complexType> | |
| if(isset($attrs['base']) && ereg(':Array$',$attrs['base'])){ | |
| $this->xdebug('complexType is unusual array'); | |
| $this->complexTypes[$this->currentComplexType]['phpType'] = 'array'; | |
| } else { | |
| $this->complexTypes[$this->currentComplexType]['phpType'] = 'struct'; | |
| } | |
| } | |
| break; | |
| case 'element': | |
| array_push($this->elementStack, $this->currentElement); | |
| // elements defined as part of a complex type should | |
| // not really be added to $this->elements, but for some | |
| // reason, they are | |
| if (!isset($attrs['form'])) { | |
| $attrs['form'] = $this->schemaInfo['elementFormDefault']; | |
| } | |
| if(isset($attrs['type'])){ | |
| $this->xdebug("processing typed element ".$attrs['name']." of type ".$attrs['type']); | |
| if (! $this->getPrefix($attrs['type'])) { | |
| if ($this->defaultNamespace[$pos]) { | |
| $attrs['type'] = $this->defaultNamespace[$pos] . ':' . $attrs['type']; | |
| $this->xdebug('used default namespace to make type ' . $attrs['type']); | |
| } | |
| } | |
| // This is for constructs like | |
| // <complexType name="ListOfString" base="soap:Array"> | |
| // <sequence> | |
| // <element name="string" type="xsd:string" | |
| // minOccurs="0" maxOccurs="unbounded" /> | |
| // </sequence> | |
| // </complexType> | |
| if ($this->currentComplexType && $this->complexTypes[$this->currentComplexType]['phpType'] == 'array') { | |
| $this->xdebug('arrayType for unusual array is ' . $attrs['type']); | |
| $this->complexTypes[$this->currentComplexType]['arrayType'] = $attrs['type']; | |
| } | |
| $this->currentElement = $attrs['name']; | |
| $this->elements[ $attrs['name'] ] = $attrs; | |
| $this->elements[ $attrs['name'] ]['typeClass'] = 'element'; | |
| $ename = $attrs['name']; | |
| } elseif(isset($attrs['ref'])){ | |
| $this->xdebug("processing element as ref to ".$attrs['ref']); | |
| $this->currentElement = "ref to ".$attrs['ref']; | |
| $ename = $this->getLocalPart($attrs['ref']); | |
| } else { | |
| $this->xdebug("processing untyped element ".$attrs['name']); | |
| $this->currentElement = $attrs['name']; | |
| $this->elements[ $attrs['name'] ] = $attrs; | |
| $this->elements[ $attrs['name'] ]['typeClass'] = 'element'; | |
| $attrs['type'] = $this->schemaTargetNamespace . ':' . $attrs['name'] . '_ContainedType'; | |
| $this->elements[ $attrs['name'] ]['type'] = $attrs['type']; | |
| $ename = $attrs['name']; | |
| } | |
| if(isset($ename) && $this->currentComplexType){ | |
| $this->complexTypes[$this->currentComplexType]['elements'][$ename] = $attrs; | |
| } | |
| break; | |
| case 'enumeration': // restriction value list member | |
| $this->xdebug('enumeration ' . $attrs['value']); | |
| if ($this->currentSimpleType) { | |
| $this->simpleTypes[$this->currentSimpleType]['enumeration'][] = $attrs['value']; | |
| } elseif ($this->currentComplexType) { | |
| $this->complexTypes[$this->currentComplexType]['enumeration'][] = $attrs['value']; | |
| } | |
| break; | |
| case 'extension': // simpleContent or complexContent type extension | |
| $this->xdebug('extension ' . $attrs['base']); | |
| if ($this->currentComplexType) { | |
| $this->complexTypes[$this->currentComplexType]['extensionBase'] = $attrs['base']; | |
| } | |
| break; | |
| case 'import': | |
| if (isset($attrs['schemaLocation'])) { | |
| //$this->xdebug('import namespace ' . $attrs['namespace'] . ' from ' . $attrs['schemaLocation']); | |
| $this->imports[$attrs['namespace']][] = array('location' => $attrs['schemaLocation'], 'loaded' => false); | |
| } else { | |
| //$this->xdebug('import namespace ' . $attrs['namespace']); | |
| $this->imports[$attrs['namespace']][] = array('location' => '', 'loaded' => true); | |
| if (! $this->getPrefixFromNamespace($attrs['namespace'])) { | |
| $this->namespaces['ns'.(count($this->namespaces)+1)] = $attrs['namespace']; | |
| } | |
| } | |
| break; | |
| case 'list': // simpleType value list | |
| break; | |
| case 'restriction': // simpleType, simpleContent or complexContent value restriction | |
| $this->xdebug('restriction ' . $attrs['base']); | |
| if($this->currentSimpleType){ | |
| $this->simpleTypes[$this->currentSimpleType]['type'] = $attrs['base']; | |
| } elseif($this->currentComplexType){ | |
| $this->complexTypes[$this->currentComplexType]['restrictionBase'] = $attrs['base']; | |
| if(strstr($attrs['base'],':') == ':Array'){ | |
| $this->complexTypes[$this->currentComplexType]['phpType'] = 'array'; | |
| } | |
| } | |
| break; | |
| case 'schema': | |
| $this->schemaInfo = $attrs; | |
| $this->schemaInfo['schemaVersion'] = $this->getNamespaceFromPrefix($prefix); | |
| if (isset($attrs['targetNamespace'])) { | |
| $this->schemaTargetNamespace = $attrs['targetNamespace']; | |
| } | |
| if (!isset($attrs['elementFormDefault'])) { | |
| $this->schemaInfo['elementFormDefault'] = 'unqualified'; | |
| } | |
| if (!isset($attrs['attributeFormDefault'])) { | |
| $this->schemaInfo['attributeFormDefault'] = 'unqualified'; | |
| } | |
| break; | |
| case 'simpleContent': // (optional) content for a complexType | |
| break; | |
| case 'simpleType': | |
| array_push($this->simpleTypeStack, $this->currentSimpleType); | |
| if(isset($attrs['name'])){ | |
| $this->xdebug("processing simpleType for name " . $attrs['name']); | |
| $this->currentSimpleType = $attrs['name']; | |
| $this->simpleTypes[ $attrs['name'] ] = $attrs; | |
| $this->simpleTypes[ $attrs['name'] ]['typeClass'] = 'simpleType'; | |
| $this->simpleTypes[ $attrs['name'] ]['phpType'] = 'scalar'; | |
| } else { | |
| $this->xdebug('processing unnamed simpleType for element '.$this->currentElement); | |
| $this->currentSimpleType = $this->currentElement . '_ContainedType'; | |
| //$this->currentElement = false; | |
| $this->simpleTypes[$this->currentSimpleType] = $attrs; | |
| $this->simpleTypes[$this->currentSimpleType]['phpType'] = 'scalar'; | |
| } | |
| break; | |
| case 'union': // simpleType type list | |
| break; | |
| default: | |
| //$this->xdebug("do not have anything to do for element $name"); | |
| } | |
| } | |
| /** | |
| * end-element handler | |
| * | |
| * @param string $parser XML parser object | |
| * @param string $name element name | |
| * @access private | |
| */ | |
| function schemaEndElement($parser, $name) { | |
| // bring depth down a notch | |
| $this->depth--; | |
| // position of current element is equal to the last value left in depth_array for my depth | |
| if(isset($this->depth_array[$this->depth])){ | |
| $pos = $this->depth_array[$this->depth]; | |
| } | |
| // get element prefix | |
| if ($prefix = $this->getPrefix($name)){ | |
| // get unqualified name | |
| $name = $this->getLocalPart($name); | |
| } else { | |
| $prefix = ''; | |
| } | |
| // move on... | |
| if($name == 'complexType'){ | |
| $this->xdebug('done processing complexType ' . ($this->currentComplexType ? $this->currentComplexType : '(unknown)')); | |
| $this->currentComplexType = array_pop($this->complexTypeStack); | |
| //$this->currentElement = false; | |
| } | |
| if($name == 'element'){ | |
| $this->xdebug('done processing element ' . ($this->currentElement ? $this->currentElement : '(unknown)')); | |
| $this->currentElement = array_pop($this->elementStack); | |
| } | |
| if($name == 'simpleType'){ | |
| $this->xdebug('done processing simpleType ' . ($this->currentSimpleType ? $this->currentSimpleType : '(unknown)')); | |
| $this->currentSimpleType = array_pop($this->simpleTypeStack); | |
| } | |
| } | |
| /** | |
| * element content handler | |
| * | |
| * @param string $parser XML parser object | |
| * @param string $data element content | |
| * @access private | |
| */ | |
| function schemaCharacterData($parser, $data){ | |
| $pos = $this->depth_array[$this->depth - 1]; | |
| $this->message[$pos]['cdata'] .= $data; | |
| } | |
| /** | |
| * serialize the schema | |
| * | |
| * @access public | |
| */ | |
| function serializeSchema(){ | |
| $schemaPrefix = $this->getPrefixFromNamespace($this->XMLSchemaVersion); | |
| $xml = ''; | |
| // imports | |
| if (sizeof($this->imports) > 0) { | |
| foreach($this->imports as $ns => $list) { | |
| foreach ($list as $ii) { | |
| if ($ii['location'] != '') { | |
| $xml .= " <$schemaPrefix:import location=\"" . $ii['location'] . '" namespace="' . $ns . "\" />\n"; | |
| } else { | |
| $xml .= " <$schemaPrefix:import namespace=\"" . $ns . "\" />\n"; | |
| } | |
| } | |
| } | |
| } | |
| // complex types | |
| foreach($this->complexTypes as $typeName => $attrs){ | |
| $contentStr = ''; | |
| // serialize child elements | |
| if(isset($attrs['elements']) && (count($attrs['elements']) > 0)){ | |
| foreach($attrs['elements'] as $element => $eParts){ | |
| if(isset($eParts['ref'])){ | |
| $contentStr .= " <$schemaPrefix:element ref=\"$element\"/>\n"; | |
| } else { | |
| $contentStr .= " <$schemaPrefix:element name=\"$element\" type=\"" . $this->contractQName($eParts['type']) . "\""; | |
| foreach ($eParts as $aName => $aValue) { | |
| // handle, e.g., abstract, default, form, minOccurs, maxOccurs, nillable | |
| if ($aName != 'name' && $aName != 'type') { | |
| $contentStr .= " $aName=\"$aValue\""; | |
| } | |
| } | |
| $contentStr .= "/>\n"; | |
| } | |
| } | |
| // compositor wraps elements | |
| if (isset($attrs['compositor']) && ($attrs['compositor'] != '')) { | |
| $contentStr = " <$schemaPrefix:$attrs[compositor]>\n".$contentStr." </$schemaPrefix:$attrs[compositor]>\n"; | |
| } | |
| } | |
| // attributes | |
| if(isset($attrs['attrs']) && (count($attrs['attrs']) >= 1)){ | |
| foreach($attrs['attrs'] as $attr => $aParts){ | |
| $contentStr .= " <$schemaPrefix:attribute"; | |
| foreach ($aParts as $a => $v) { | |
| if ($a == 'ref' || $a == 'type') { | |
| $contentStr .= " $a=\"".$this->contractQName($v).'"'; | |
| } elseif ($a == 'http://schemas.xmlsoap.org/wsdl/:arrayType') { | |
| $this->usedNamespaces['wsdl'] = $this->namespaces['wsdl']; | |
| $contentStr .= ' wsdl:arrayType="'.$this->contractQName($v).'"'; | |
| } else { | |
| $contentStr .= " $a=\"$v\""; | |
| } | |
| } | |
| $contentStr .= "/>\n"; | |
| } | |
| } | |
| // if restriction | |
| if (isset($attrs['restrictionBase']) && $attrs['restrictionBase'] != ''){ | |
| $contentStr = " <$schemaPrefix:restriction base=\"".$this->contractQName($attrs['restrictionBase'])."\">\n".$contentStr." </$schemaPrefix:restriction>\n"; | |
| // complex or simple content | |
| if ((isset($attrs['elements']) && count($attrs['elements']) > 0) || (isset($attrs['attrs']) && count($attrs['attrs']) > 0)){ | |
| $contentStr = " <$schemaPrefix:complexContent>\n".$contentStr." </$schemaPrefix:complexContent>\n"; | |
| } | |
| } | |
| // finalize complex type | |
| if($contentStr != ''){ | |
| $contentStr = " <$schemaPrefix:complexType name=\"$typeName\">\n".$contentStr." </$schemaPrefix:complexType>\n"; | |
| } else { | |
| $contentStr = " <$schemaPrefix:complexType name=\"$typeName\"/>\n"; | |
| } | |
| $xml .= $contentStr; | |
| } | |
| // simple types | |
| if(isset($this->simpleTypes) && count($this->simpleTypes) > 0){ | |
| foreach($this->simpleTypes as $typeName => $eParts){ | |
| $xml .= " <$schemaPrefix:simpleType name=\"$typeName\">\n <$schemaPrefix:restriction base=\"".$this->contractQName($eParts['type'])."\"/>\n"; | |
| if (isset($eParts['enumeration'])) { | |
| foreach ($eParts['enumeration'] as $e) { | |
| $xml .= " <$schemaPrefix:enumeration value=\"$e\"/>\n"; | |
| } | |
| } | |
| $xml .= " </$schemaPrefix:simpleType>"; | |
| } | |
| } | |
| // elements | |
| if(isset($this->elements) && count($this->elements) > 0){ | |
| foreach($this->elements as $element => $eParts){ | |
| $xml .= " <$schemaPrefix:element name=\"$element\" type=\"".$this->contractQName($eParts['type'])."\"/>\n"; | |
| } | |
| } | |
| // attributes | |
| if(isset($this->attributes) && count($this->attributes) > 0){ | |
| foreach($this->attributes as $attr => $aParts){ | |
| $xml .= " <$schemaPrefix:attribute name=\"$attr\" type=\"".$this->contractQName($aParts['type'])."\"\n/>"; | |
| } | |
| } | |
| // finish 'er up | |
| $el = "<$schemaPrefix:schema targetNamespace=\"$this->schemaTargetNamespace\"\n"; | |
| foreach (array_diff($this->usedNamespaces, $this->enclosingNamespaces) as $nsp => $ns) { | |
| $el .= " xmlns:$nsp=\"$ns\"\n"; | |
| } | |
| $xml = $el . ">\n".$xml."</$schemaPrefix:schema>\n"; | |
| return $xml; | |
| } | |
| /** | |
| * adds debug data to the clas level debug string | |
| * | |
| * @param string $string debug data | |
| * @access private | |
| */ | |
| function xdebug($string){ | |
| $this->debug('<' . $this->schemaTargetNamespace . '> '.$string); | |
| } | |
| /** | |
| * get the PHP type of a user defined type in the schema | |
| * PHP type is kind of a misnomer since it actually returns 'struct' for assoc. arrays | |
| * returns false if no type exists, or not w/ the given namespace | |
| * else returns a string that is either a native php type, or 'struct' | |
| * | |
| * @param string $type, name of defined type | |
| * @param string $ns, namespace of type | |
| * @return mixed | |
| * @access public | |
| * @deprecated | |
| */ | |
| function getPHPType($type,$ns){ | |
| if(isset($this->typemap[$ns][$type])){ | |
| //print "found type '$type' and ns $ns in typemap<br>"; | |
| return $this->typemap[$ns][$type]; | |
| } elseif(isset($this->complexTypes[$type])){ | |
| //print "getting type '$type' and ns $ns from complexTypes array<br>"; | |
| return $this->complexTypes[$type]['phpType']; | |
| } | |
| return false; | |
| } | |
| /** | |
| * returns an associative array of information about a given type | |
| * returns false if no type exists by the given name | |
| * | |
| * For a complexType typeDef = array( | |
| * 'restrictionBase' => '', | |
| * 'phpType' => '', | |
| * 'compositor' => '(sequence|all)', | |
| * 'elements' => array(), // refs to elements array | |
| * 'attrs' => array() // refs to attributes array | |
| * ... and so on (see addComplexType) | |
| * ) | |
| * | |
| * For simpleType or element, the array has different keys. | |
| * | |
| * @param string | |
| * @return mixed | |
| * @access public | |
| * @see addComplexType | |
| * @see addSimpleType | |
| * @see addElement | |
| */ | |
| function getTypeDef($type){ | |
| //$this->debug("in getTypeDef for type $type"); | |
| if(isset($this->complexTypes[$type])){ | |
| $this->xdebug("in getTypeDef, found complexType $type"); | |
| return $this->complexTypes[$type]; | |
| } elseif(isset($this->simpleTypes[$type])){ | |
| $this->xdebug("in getTypeDef, found simpleType $type"); | |
| if (!isset($this->simpleTypes[$type]['phpType'])) { | |
| // get info for type to tack onto the simple type | |
| // TODO: can this ever really apply (i.e. what is a simpleType really?) | |
| $uqType = substr($this->simpleTypes[$type]['type'], strrpos($this->simpleTypes[$type]['type'], ':') + 1); | |
| $ns = substr($this->simpleTypes[$type]['type'], 0, strrpos($this->simpleTypes[$type]['type'], ':')); | |
| $etype = $this->getTypeDef($uqType); | |
| if ($etype) { | |
| $this->xdebug("in getTypeDef, found type for simpleType $type:"); | |
| $this->xdebug($this->varDump($etype)); | |
| if (isset($etype['phpType'])) { | |
| $this->simpleTypes[$type]['phpType'] = $etype['phpType']; | |
| } | |
| if (isset($etype['elements'])) { | |
| $this->simpleTypes[$type]['elements'] = $etype['elements']; | |
| } | |
| } | |
| } | |
| return $this->simpleTypes[$type]; | |
| } elseif(isset($this->elements[$type])){ | |
| $this->xdebug("in getTypeDef, found element $type"); | |
| if (!isset($this->elements[$type]['phpType'])) { | |
| // get info for type to tack onto the element | |
| $uqType = substr($this->elements[$type]['type'], strrpos($this->elements[$type]['type'], ':') + 1); | |
| $ns = substr($this->elements[$type]['type'], 0, strrpos($this->elements[$type]['type'], ':')); | |
| $etype = $this->getTypeDef($uqType); | |
| if ($etype) { | |
| $this->xdebug("in getTypeDef, found type for element $type:"); | |
| $this->xdebug($this->varDump($etype)); | |
| if (isset($etype['phpType'])) { | |
| $this->elements[$type]['phpType'] = $etype['phpType']; | |
| } | |
| if (isset($etype['elements'])) { | |
| $this->elements[$type]['elements'] = $etype['elements']; | |
| } | |
| } elseif ($ns == 'http://www.w3.org/2001/XMLSchema') { | |
| $this->xdebug("in getTypeDef, element $type is an XSD type"); | |
| $this->elements[$type]['phpType'] = 'scalar'; | |
| } | |
| } | |
| return $this->elements[$type]; | |
| } elseif(isset($this->attributes[$type])){ | |
| $this->xdebug("in getTypeDef, found attribute $type"); | |
| return $this->attributes[$type]; | |
| } elseif (ereg('_ContainedType$', $type)) { | |
| $this->xdebug("in getTypeDef, have an untyped element $type"); | |
| $typeDef['typeClass'] = 'simpleType'; | |
| $typeDef['phpType'] = 'scalar'; | |
| $typeDef['type'] = 'http://www.w3.org/2001/XMLSchema:string'; | |
| return $typeDef; | |
| } | |
| $this->xdebug("in getTypeDef, did not find $type"); | |
| return false; | |
| } | |
| /** | |
| * returns a sample serialization of a given type, or false if no type by the given name | |
| * | |
| * @param string $type, name of type | |
| * @return mixed | |
| * @access public | |
| * @deprecated | |
| */ | |
| function serializeTypeDef($type){ | |
| //print "in sTD() for type $type<br>"; | |
| if($typeDef = $this->getTypeDef($type)){ | |
| $str .= '<'.$type; | |
| if(is_array($typeDef['attrs'])){ | |
| foreach($attrs as $attName => $data){ | |
| $str .= " $attName=\"{type = ".$data['type']."}\""; | |
| } | |
| } | |
| $str .= " xmlns=\"".$this->schema['targetNamespace']."\""; | |
| if(count($typeDef['elements']) > 0){ | |
| $str .= ">"; | |
| foreach($typeDef['elements'] as $element => $eData){ | |
| $str .= $this->serializeTypeDef($element); | |
| } | |
| $str .= "</$type>"; | |
| } elseif($typeDef['typeClass'] == 'element') { | |
| $str .= "></$type>"; | |
| } else { | |
| $str .= "/>"; | |
| } | |
| return $str; | |
| } | |
| return false; | |
| } | |
| /** | |
| * returns HTML form elements that allow a user | |
| * to enter values for creating an instance of the given type. | |
| * | |
| * @param string $name, name for type instance | |
| * @param string $type, name of type | |
| * @return string | |
| * @access public | |
| * @deprecated | |
| */ | |
| function typeToForm($name,$type){ | |
| // get typedef | |
| if($typeDef = $this->getTypeDef($type)){ | |
| // if struct | |
| if($typeDef['phpType'] == 'struct'){ | |
| $buffer .= '<table>'; | |
| foreach($typeDef['elements'] as $child => $childDef){ | |
| $buffer .= " | |
| <tr><td align='right'>$childDef[name] (type: ".$this->getLocalPart($childDef['type'])."):</td> | |
| <td><input type='text' name='parameters[".$name."][$childDef[name]]'></td></tr>"; | |
| } | |
| $buffer .= '</table>'; | |
| // if array | |
| } elseif($typeDef['phpType'] == 'array'){ | |
| $buffer .= '<table>'; | |
| for($i=0;$i < 3; $i++){ | |
| $buffer .= " | |
| <tr><td align='right'>array item (type: $typeDef[arrayType]):</td> | |
| <td><input type='text' name='parameters[".$name."][]'></td></tr>"; | |
| } | |
| $buffer .= '</table>'; | |
| // if scalar | |
| } else { | |
| $buffer .= "<input type='text' name='parameters[$name]'>"; | |
| } | |
| } else { | |
| $buffer .= "<input type='text' name='parameters[$name]'>"; | |
| } | |
| return $buffer; | |
| } | |
| /** | |
| * adds a complex type to the schema | |
| * | |
| * example: array | |
| * | |
| * addType( | |
| * 'ArrayOfstring', | |
| * 'complexType', | |
| * 'array', | |
| * '', | |
| * 'SOAP-ENC:Array', | |
| * array('ref'=>'SOAP-ENC:arrayType','wsdl:arrayType'=>'string[]'), | |
| * 'xsd:string' | |
| * ); | |
| * | |
| * example: PHP associative array ( SOAP Struct ) | |
| * | |
| * addType( | |
| * 'SOAPStruct', | |
| * 'complexType', | |
| * 'struct', | |
| * 'all', | |
| * array('myVar'=> array('name'=>'myVar','type'=>'string') | |
| * ); | |
| * | |
| * @param name | |
| * @param typeClass (complexType|simpleType|attribute) | |
| * @param phpType: currently supported are array and struct (php assoc array) | |
| * @param compositor (all|sequence|choice) | |
| * @param restrictionBase namespace:name (http://schemas.xmlsoap.org/soap/encoding/:Array) | |
| * @param elements = array ( name = array(name=>'',type=>'') ) | |
| * @param attrs = array( | |
| * array( | |
| * 'ref' => "http://schemas.xmlsoap.org/soap/encoding/:arrayType", | |
| * "http://schemas.xmlsoap.org/wsdl/:arrayType" => "string[]" | |
| * ) | |
| * ) | |
| * @param arrayType: namespace:name (http://www.w3.org/2001/XMLSchema:string) | |
| * @access public | |
| * @see getTypeDef | |
| */ | |
| function addComplexType($name,$typeClass='complexType',$phpType='array',$compositor='',$restrictionBase='',$elements=array(),$attrs=array(),$arrayType=''){ | |
| $this->complexTypes[$name] = array( | |
| 'name' => $name, | |
| 'typeClass' => $typeClass, | |
| 'phpType' => $phpType, | |
| 'compositor'=> $compositor, | |
| 'restrictionBase' => $restrictionBase, | |
| 'elements' => $elements, | |
| 'attrs' => $attrs, | |
| 'arrayType' => $arrayType | |
| ); | |
| $this->xdebug("addComplexType $name:"); | |
| $this->appendDebug($this->varDump($this->complexTypes[$name])); | |
| } | |
| /** | |
| * adds a simple type to the schema | |
| * | |
| * @param string $name | |
| * @param string $restrictionBase namespace:name (http://schemas.xmlsoap.org/soap/encoding/:Array) | |
| * @param string $typeClass (should always be simpleType) | |
| * @param string $phpType (should always be scalar) | |
| * @param array $enumeration array of values | |
| * @access public | |
| * @see xmlschema | |
| * @see getTypeDef | |
| */ | |
| function addSimpleType($name, $restrictionBase='', $typeClass='simpleType', $phpType='scalar', $enumeration=array()) { | |
| $this->simpleTypes[$name] = array( | |
| 'name' => $name, | |
| 'typeClass' => $typeClass, | |
| 'phpType' => $phpType, | |
| 'type' => $restrictionBase, | |
| 'enumeration' => $enumeration | |
| ); | |
| $this->xdebug("addSimpleType $name:"); | |
| $this->appendDebug($this->varDump($this->simpleTypes[$name])); | |
| } | |
| /** | |
| * adds an element to the schema | |
| * | |
| * @param array $attrs attributes that must include name and type | |
| * @see xmlschema | |
| * @access public | |
| */ | |
| function addElement($attrs) { | |
| if (! $this->getPrefix($attrs['type'])) { | |
| $attrs['type'] = $this->schemaTargetNamespace . ':' . $attrs['type']; | |
| } | |
| $this->elements[ $attrs['name'] ] = $attrs; | |
| $this->elements[ $attrs['name'] ]['typeClass'] = 'element'; | |
| $this->xdebug("addElement " . $attrs['name']); | |
| $this->appendDebug($this->varDump($this->elements[ $attrs['name'] ])); | |
| } | |
| } | |