david
790d6f170a
git-svn-id: https://192.168.0.254/svn/Proyectos.MatritumCantat_Web/trunk@2 8e3496fd-7892-4c45-be36-0ff06e9dacc6
399 lines
12 KiB
PHP
399 lines
12 KiB
PHP
<?php
|
|
/**
|
|
* dom_xmlrpc_builder is a utility for building string representations of XML-RPC documents
|
|
* @package dom-xmlrpc
|
|
* @copyright (C) 2004 John Heinstein. All rights reserved
|
|
* @license http://www.gnu.org/copyleft/lesser.html LGPL License
|
|
* @author John Heinstein <johnkarl@nbnet.nb.ca>
|
|
* @link http://www.engageinteractive.com/dom_xmlrpc/ DOM XML-RPC Home Page
|
|
* DOM XML-RPC is Free Software
|
|
**/
|
|
|
|
if (!defined('DOM_XMLRPC_INCLUDE_PATH')) {
|
|
define('DOM_XMLRPC_INCLUDE_PATH', (dirname(__FILE__) . "/"));
|
|
}
|
|
|
|
require_once(DOM_XMLRPC_INCLUDE_PATH . 'dom_xmlrpc_constants.php');
|
|
|
|
/**
|
|
* A utility for building string representations of XML-RPC documents
|
|
*
|
|
* @package dom-xmlrpc
|
|
* @author John Heinstein <johnkarl@nbnet.nb.ca>
|
|
*/
|
|
class dom_xmlrpc_builder {
|
|
/** @var string The method type of the XML-RPC data, e.g., DOM_XMLRPC_TYPE_METHODRESPONSE */
|
|
var $methodType;
|
|
/** @var string The XML string representing the method params */
|
|
var $params = "";
|
|
/** @var string The type of object marshalling to be used, if this option is enabled */
|
|
var $objectMarshalling = DOM_XMLRPC_OBJECT_MARSHALLING_ANONYMOUS;
|
|
|
|
/**
|
|
* Invokes the ability to pass PHP objects in addition to basic native types such as int and string
|
|
* @param string The type of object marshalling to be invoked: either anonymous, named, or serialized
|
|
*/
|
|
function setObjectMarshalling($type) {
|
|
$type = strtolower($type);
|
|
|
|
switch ($type) {
|
|
case DOM_XMLRPC_OBJECT_MARSHALLING_ANONYMOUS: //default
|
|
case DOM_XMLRPC_OBJECT_MARSHALLING_NAMED:
|
|
case DOM_XMLRPC_OBJECT_MARSHALLING_SERIALIZED:
|
|
$this->objectMarshalling = $type;
|
|
break;
|
|
default:
|
|
XMLRPC_Client_Exception::raiseException(XMLRPC_CLIENT_RESPONSE_TYPE_ERR,
|
|
('Invalid object marshalling type: ' . $type));
|
|
}
|
|
} //setObjectMarshalling
|
|
|
|
/**
|
|
* Creates an XML-RPC representation of a scalar value (e.g. string, double, boolean)
|
|
* @param mixed The value to be converted to XML-RPC notation
|
|
* @param string The type of the value (will be autodetected if omitted)
|
|
* @return string An XML-RPC representation of the value
|
|
*/
|
|
function createScalar($value, $type = '') {
|
|
if ($type == '') {
|
|
$type = dom_xmlrpc_utilities::getScalarTypeFromValue($value);
|
|
}
|
|
|
|
switch ($type) {
|
|
case DOM_XMLRPC_TYPE_STRING:
|
|
if ($this->methodType == DOM_XMLRPC_TYPE_METHODRESPONSE) {
|
|
//htmlencode the string, because
|
|
//DOM XML-RPC server has decoded it
|
|
$value = htmlentities($value, ENT_QUOTES);
|
|
}
|
|
break;
|
|
case DOM_XMLRPC_TYPE_DOUBLE:
|
|
//ensure trailing .0 if it looks like an int
|
|
$value = '' . $value;
|
|
if (strpos($value, '.') === false) {
|
|
$value .= '.0';
|
|
}
|
|
break;
|
|
case DOM_XMLRPC_TYPE_BOOLEAN:
|
|
if (is_bool($value)) {
|
|
$value = ($value ? '1' : '0');
|
|
}
|
|
break;
|
|
case DOM_XMLRPC_TYPE_BASE64:
|
|
if (is_object($value)) {
|
|
$value = $value->getEncoded();
|
|
}
|
|
break;
|
|
case DOM_XMLRPC_TYPE_DATETIME:
|
|
if (is_object($value)) {
|
|
$value = $value->getDateTime_iso();
|
|
}
|
|
break;
|
|
}
|
|
|
|
return ("<value><$type>$value</$type></value>");
|
|
} //createScalar
|
|
|
|
/**
|
|
* Generates an XML-RPC param from the scalar and adds it to the method params
|
|
* @param mixed The value to be converted to XML-RPC notation
|
|
* @param string The type of the value (will be autodetected if omitted)
|
|
*/
|
|
function addScalar($value, $type = '') {
|
|
$this->params .= "\n\t\t<param>" . $this->createScalar($value, $type) . '</param>';
|
|
} //addScalar
|
|
|
|
/**
|
|
* Creates an XML-RPC representation of a PHP array
|
|
* @param array The array to be converted to XML-RPC notation
|
|
* @return string An XML-RPC representation of the array
|
|
*/
|
|
function createArray(&$myArray) {
|
|
$data = '<value><array><data>';
|
|
|
|
foreach ($myArray as $key => $value) {
|
|
$currDataItem =& $myArray[$key];
|
|
$currType = dom_xmlrpc_utilities::getTypeFromValue($currDataItem);
|
|
|
|
$data .= $this->create($currDataItem, $currType);
|
|
}
|
|
|
|
$data .= '</data></array></value>';
|
|
|
|
return $data;
|
|
} //createArray
|
|
|
|
/**
|
|
* Generates an XML-RPC param from the array and adds it to the method params
|
|
* @param array The array to be converted to XML-RPC notation
|
|
*/
|
|
function addArray($myArray) {
|
|
$this->addArrayByRef($myArray);
|
|
} //addArray
|
|
|
|
/**
|
|
* Generates an XML-RPC param from the array reference and adds it to the method params
|
|
* @param array The array reference to be converted to XML-RPC notation
|
|
*/
|
|
function addArrayByRef(&$myArray) { //can call with reference if deep copy is required
|
|
$this->params .= "\n\t\t<param>" . $this->createArray($myArray) . '</param>';
|
|
} //addArrayByRef
|
|
|
|
/**
|
|
* Creates an XML-RPC representation of a PHP object
|
|
* @param object The object to be converted to XML-RPC notation
|
|
* @return string An XML-RPC representation of the object
|
|
*/
|
|
function createObject(&$myObject) {
|
|
require_once('dom_xmlrpc_object.php');
|
|
|
|
if (get_class($myObject) == 'dom_xmlrpc_object') { //wrapper for xmlrpc object
|
|
$myObject =& $myObject->getObject(); //grab embedded object
|
|
}
|
|
|
|
switch($this->objectMarshalling){
|
|
case DOM_XMLRPC_OBJECT_MARSHALLING_ANONYMOUS:
|
|
//generic struct, one member for each
|
|
//object property, object type is discarded
|
|
$data = '<value><struct>';
|
|
|
|
foreach ($myObject as $key => $value) {
|
|
$currValue =& $myObject->$key;
|
|
$currType = dom_xmlrpc_utilities::getTypeFromValue($currValue);
|
|
|
|
$data .= $this->createMember($key, $currValue, $currType);
|
|
}
|
|
|
|
$data .= '</struct></value>';
|
|
break;
|
|
|
|
case DOM_XMLRPC_OBJECT_MARSHALLING_NAMED:
|
|
//struct with one member for each
|
|
//object property, object type is defined
|
|
//by an additional member (first in list) named
|
|
//"__phpobject__" whose value is a string
|
|
//containing the class type of the object
|
|
$data = '<value><struct>';
|
|
$data .= $this->createMember(DOM_XMLRPC_PHPOBJECT, get_class($myObject), DOM_XMLRPC_TYPE_STRING);
|
|
|
|
foreach ($myObject as $key => $value) {
|
|
$currValue =& $myObject->$key;
|
|
$currType = dom_xmlrpc_utilities::getTypeFromValue($currValue);
|
|
|
|
$data .= $this->createMember($key, $currValue, $currType);
|
|
}
|
|
|
|
$data .= '</struct></value>';
|
|
break;
|
|
|
|
case DOM_XMLRPC_OBJECT_MARSHALLING_SERIALIZED:
|
|
//serialized object, one member of type base64
|
|
//which is the serialized object, base64 encoded
|
|
require_once(DOM_XMLRPC_INCLUDE_PATH . 'dom_xmlrpc_base64.php');
|
|
$data = '<value><struct>';
|
|
$data .= $this->createMember(DOM_XMLRPC_PHPOBJECT, get_class($myObject), DOM_XMLRPC_TYPE_STRING);
|
|
|
|
$serialized =& serialize($myObject);
|
|
$currValue =& $this->createBase64($serialized);
|
|
$data .= $this->createMember(DOM_XMLRPC_SERIALIZED, $currValue, DOM_XMLRPC_TYPE_BASE64);
|
|
|
|
$data .= '</struct></value>';
|
|
break;
|
|
} // switch
|
|
|
|
return $data;
|
|
} //createObject
|
|
|
|
/**
|
|
* Generates an XML-RPC param from the object and adds it to the method params
|
|
* @param object The object to be converted to XML-RPC notation
|
|
*/
|
|
function addObject($myObject) {
|
|
$this->addObjectByRef($myObject);
|
|
}//addObject
|
|
|
|
/**
|
|
* Generates an XML-RPC param from the object reference and adds it to the method params
|
|
* @param object The object reference to be converted to XML-RPC notation
|
|
*/
|
|
function addObjectByRef(&$myObject) { //can call with reference if deep copy is required
|
|
$this->params .= "\n\t\t<param>" . $this->createObject($myObject) . '</param>';
|
|
}//addObjectByRef
|
|
|
|
/**
|
|
* Creates an XML-RPC representation of a struct
|
|
* @param mixed The struct to be converted to XML-RPC notation
|
|
* @return string An XML-RPC representation of the struct
|
|
*/
|
|
function createStruct(&$myStruct) {
|
|
require_once('dom_xmlrpc_object.php');
|
|
$className = get_class($myStruct);
|
|
|
|
//if struct is explicitly cast as an xmlrpc object
|
|
if ($className == 'dom_xmlrpc_object') {
|
|
$myObject =& $myStruct->getObject(); //grab embedded object
|
|
return $this->createObject($myObject);
|
|
}
|
|
else {
|
|
//wrapper for numeric indexed structs
|
|
//that are meant to be string indexed
|
|
if ($className == 'dom_xmlrpc_struct') {
|
|
$myStruct =& $myStruct->getStruct(); //grab embedded array
|
|
}
|
|
|
|
$isArrayNotObj = is_array($myStruct);
|
|
|
|
//if struct is an object and isn't anonymous
|
|
if ($isArrayNotObj && ($this->objectMarshalling != DOM_XMLRPC_OBJECT_MARSHALLING_ANONYMOUS)) {
|
|
return $this->createObject($myStruct);
|
|
}
|
|
else {
|
|
$data = '<value><struct>';
|
|
|
|
foreach ($myStruct as $key => $value) {
|
|
$isArrayNotObj ? ($currValue =& $myStruct[$key]) : ($currValue =& $value);
|
|
$currType = dom_xmlrpc_utilities::getTypeFromValue($currValue);
|
|
|
|
$data .= $this->createMember($key, $currValue, $currType);
|
|
}
|
|
|
|
$data .= '</struct></value>';
|
|
return $data;
|
|
}
|
|
}
|
|
} //createStruct
|
|
|
|
/**
|
|
* Generates an XML-RPC param from the struct and adds it to the method params
|
|
* @param mixed The struct to be converted to XML-RPC notation
|
|
*/
|
|
function addStruct($myStruct) {
|
|
$this->addStructByRef($myStruct);
|
|
} //addStruct
|
|
|
|
/**
|
|
* Generates an XML-RPC param from the struct reference and adds it to the method params
|
|
* @param mixed The struct reference to be converted to XML-RPC notation
|
|
*/
|
|
function addStructByRef(&$myStruct) { //can call with reference if deep copy is required
|
|
$this->params .= "\n\t\t<param>" . $this->createStruct($myStruct) . '</param>';
|
|
} //addStructRef
|
|
|
|
/**
|
|
* Creates an XML-RPC representation of a member
|
|
* @param mixed The member to be converted to XML-RPC notation
|
|
* @return string An XML-RPC representation of the member
|
|
*/
|
|
function createMember($name, &$value, $type) {
|
|
$data = '<member><name>' . $name . '</name>';
|
|
|
|
if ($type == '') {
|
|
$type = dom_xmlrpc_utilities::getScalarTypeFromValue($value);
|
|
}
|
|
|
|
$data .= $this->create($value, $type) . '</member>';
|
|
|
|
return $data;
|
|
} //createMember
|
|
|
|
/**
|
|
* Generates an XML-RPC param from the value and adds it to the method params
|
|
* @param mixed The value to be converted to XML-RPC notation
|
|
*/
|
|
function create(&$value, $type = '') {
|
|
$data = '';
|
|
|
|
if ($type == '') {
|
|
require_once(DOM_XMLRPC_INCLUDE_PATH . 'dom_xmlrpc_utilities.php');
|
|
$type = dom_xmlrpc_utilities::getTypeFromValue($value);
|
|
}
|
|
|
|
switch ($type) {
|
|
case DOM_XMLRPC_TYPE_STRING:
|
|
case DOM_XMLRPC_TYPE_INT:
|
|
case DOM_XMLRPC_TYPE_I4:
|
|
case DOM_XMLRPC_TYPE_DOUBLE:
|
|
case DOM_XMLRPC_TYPE_BOOLEAN:
|
|
case DOM_XMLRPC_TYPE_BASE64:
|
|
case DOM_XMLRPC_TYPE_DATETIME:
|
|
$data .= $this->createScalar($value, $type);
|
|
break;
|
|
case DOM_XMLRPC_TYPE_STRUCT:
|
|
$data .= $this->createStruct($value, $type);
|
|
break;
|
|
case DOM_XMLRPC_TYPE_ARRAY:
|
|
$data .= $this->createArray($value, $type);
|
|
break;
|
|
}
|
|
|
|
return $data;
|
|
} //create
|
|
|
|
/**
|
|
* Generates an XML-RPC param from the unspecified value
|
|
* @param mixed The value to be converted to XML-RPC notation
|
|
*/
|
|
function add($value, $type = '') {
|
|
$this->addByRef($value, $type);
|
|
} //add
|
|
|
|
/**
|
|
* Generates an XML-RPC param from the unspecified reference
|
|
* @param mixed The reference to be converted to XML-RPC notation
|
|
*/
|
|
function addByRef(&$value, $type = '') { //can call with reference if deep copy is required
|
|
$this->params .= "\n\t\t<param>" . $this->create($value, $type) . '</param>';
|
|
} //addByRef
|
|
|
|
/**
|
|
* Generates an XML-RPC param from list of values
|
|
*/
|
|
function addList() {
|
|
$total = func_num_args();
|
|
|
|
for ($i = 0; $i < $total; $i++) {
|
|
$this->add(func_get_arg($i));
|
|
}
|
|
} //addList
|
|
|
|
/**
|
|
* Creates a dom_xmlrpc_base64 object from the binary data
|
|
* @param mixed The binary data
|
|
* @return object The base64 encoded data
|
|
*/
|
|
function &createBase64($binaryData) {
|
|
require_once(DOM_XMLRPC_INCLUDE_PATH . 'dom_xmlrpc_base64.php');
|
|
|
|
$base64 = new dom_xmlrpc_base64();
|
|
$base64->fromBinary($binaryData);
|
|
return $base64;
|
|
} //createBase64
|
|
|
|
/**
|
|
* Creates a dom_xmlrpc_base64 object from the file
|
|
* @param string The file path
|
|
* @return object The base64 encoded data
|
|
*/
|
|
function &createBase64FromFile($fileName) {
|
|
require_once(DOM_XMLRPC_INCLUDE_PATH . 'dom_xmlrpc_base64.php');
|
|
|
|
$base64 = new dom_xmlrpc_base64();
|
|
$base64->fromFile($fileName);
|
|
return $base64;
|
|
} //createBase64FromFile
|
|
|
|
/**
|
|
* Creates a dom_xmlrpc_datetime_iso8601 object from the PHP time
|
|
* @param string The time
|
|
* @return object The dom_xmlrpc_datetime_iso8601 object
|
|
*/
|
|
function &createDateTimeISO($time) {
|
|
require_once(DOM_XMLRPC_INCLUDE_PATH . 'dom_xmlrpc_datetime_iso8601.php');
|
|
|
|
$isoDateTime = new dom_xmlrpc_datetime_iso8601($time);
|
|
|
|
return $isoDateTime;
|
|
} //createDateTimeISO
|
|
|
|
} //dom_xmlrpc_builder
|
|
?>
|