Source for file jXmlRpc.class.php

Documentation is available at jXmlRpc.class.php

  1. <?php
  2. /**
  3. @package     jelix
  4. @subpackage  utils
  5. @author      Laurent Jouanneau
  6. @contributor Laurent Jouanneau for jelix
  7. @contributor Gildas Givaja
  8. @contributor Vincent Bonnard
  9. @copyright   2001-2005 CopixTeam, 2005-2006 Laurent Jouanneau
  10. *
  11. *  This class was get originally from the Copix project (CopixXmlRpc, Copix 2.3dev20050901, http://www.copix.org)
  12. *  Some lines of code are copyrighted 2001-2005 CopixTeam (LGPL licence).
  13. *  Initial author of this Copix class is Laurent Jouanneau,
  14. *  and this class was adapted/improved for Jelix by Laurent Jouanneau
  15. *
  16. @link        http://www.jelix.org
  17. @licence     http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public Licence, see LICENCE file
  18. */
  19.  
  20. /**
  21.  * object to encode decode some XMl-RPC request and XMl-RPC response
  22.  * @package    jelix
  23.  * @subpackage utils
  24.  * @see http://www.xmlrpc.com/spec
  25.  */
  26. class jXmlRpc {
  27.  
  28.      private function __construct(){}
  29.  
  30.     /**
  31.      * decode an xmlrpc request
  32.      * @param string $xmlcontent the content of the request, in xmlrpc format
  33.      * @return array first element content the method name to execute
  34.      *                second element content parameters
  35.      */
  36.     public static function decodeRequest($xmlcontent){
  37.         $xml simplexml_load_string($xmlcontent);
  38.         if($xml == false){
  39.  
  40.         }
  41.         $methodname = (string)$xml->methodName;
  42.         if(isset($xml->params)){
  43.             if(isset($xml->params->param)){
  44.                 $params array();
  45.                 foreach($xml->params->param as $param){
  46.                     if(isset($param->value)){
  47.                         $params[self::_decodeValue($param->value);
  48.                     }
  49.                 }
  50.             }
  51.         }
  52.  
  53.         return array($methodname$params);
  54.     }
  55.  
  56.     /**
  57.      * encode an xmlrpc request
  58.      * @param string $methodname 
  59.      * @param array $params method parameters
  60.      * @param string $charset 
  61.      * @return string xmlrpc request
  62.      */
  63.     public static function encodeRequest($methodname$params$charset=''){
  64.         $request =  '<?xml version="1.0" '.($charset?'encoding="'.$charset.'"':'').'?>
  65. <methodCall><methodName>'.htmlspecialchars($methodname).'</methodName><params>';
  66.         foreach($params as $param){
  67.             $request.= '<param>'.self::_encodeValue($param).'</param>';
  68.         }
  69.         $request.='</params></methodCall>';
  70.         return $request;
  71.     }
  72.  
  73.     /**
  74.      * decode an xmlrpc response
  75.      * @param string $xmlcontent the content of the response, in xmlrpc format
  76.      * @return mixed data stored into the response
  77.      */
  78.     public static function decodeResponse($xmlcontent){
  79.         $xml simplexml_load_string($xmlcontent);
  80.         if($xml == false){
  81.  
  82.         }
  83.         $response=array();
  84.         if(isset($xml->params)){
  85.             if(isset($xml->params->param)){
  86.                 $params array();
  87.                 foreach($xml->params->param as $param){
  88.                     if(isset($param->value)){
  89.                         $params[self::_decodeValue($param->value);
  90.                     }
  91.                 }
  92.                 $response[0true;
  93.                 $response[1]=$params;
  94.             }
  95.         }else if(isset($xml->fault)){
  96.             $response[0false;
  97.             if(isset($xml->fault->value))
  98.                 $response[1self::_decodeValue($xml->fault->value);
  99.             else
  100.                 $response[1null;
  101.         }
  102.  
  103.         return $response;
  104.     }
  105.  
  106.     /**
  107.      * encode an xmlrpc response
  108.      * @param mixed $params the value to stored into the response
  109.      * @param string $charset the charset to use
  110.      * @return string the xmlrpc response
  111.      */
  112.     public static function encodeResponse($params$charset=''){
  113.         return '<?xml version="1.0" '.($charset?'encoding="'.$charset.'"':'').'?>
  114. <methodResponse><params><param>'.self::_encodeValue($params).'</param></params></methodResponse>';
  115.     }
  116.  
  117.     /**
  118.      * encode an xmlrpc error response
  119.      * @param string $code the error code
  120.      * @param string $message 
  121.      * @param string $charset the charset to use
  122.      * @return string the xmlrpc response
  123.      */
  124.     public static function encodeFaultResponse($code$message$charset=''){
  125.         return '<?xml version="1.0" '.($charset?'encoding="'.$charset.'"':'').'?>
  126. <methodResponse><fault><value><struct>
  127. <member><name>faultCode</name><value><int>'.intval($code).'</int></value></member>
  128. <member><name>faultString</name><value><string>'.htmlspecialchars($message).'</string></value></member>
  129. </struct></value></fault></methodResponse>';
  130.     }
  131.  
  132.     /**
  133.      * deserialize a xmlrpc content to a php value
  134.      * @param string $valuetag xmlrpc content
  135.      * @return mixed the php value
  136.      */
  137.     private static function _decodeValue($valuetag){
  138.         $children$valuetag->children();
  139.         $value null;
  140.         if(count($children)){
  141.             if(isset($valuetag->i4)){
  142.                 $valueintval((string) $valuetag->i4);
  143.             }else if(isset($valuetag->int)){
  144.                 $valueintval((string) $valuetag->int);
  145.             }else if(isset($valuetag->double)){
  146.                 $valuedoubleval((string)$valuetag->double);
  147.             }else if(isset($valuetag->string)){
  148.                 $valuehtml_entity_decode((string)$valuetag->string);
  149.             }else if(isset($valuetag->boolean)){
  150.                 $valueintval((string)$valuetag->boolean)?true:false;
  151.             }else if(isset($valuetag->array)){
  152.                 $value=array();
  153.                 if(isset($valuetag->array->data->value)){
  154.                     foreach($valuetag->array->data->value as $val){
  155.                         $value[self::_decodeValue($val);
  156.                     }
  157.                 }
  158.             }else if(isset($valuetag->struct)){
  159.                 $value=array();
  160.                 if(isset($children[0]->member)){
  161.                     foreach($children[0]->member as $val){
  162.                         if(isset($val->name&& isset($val->value)){
  163.                             $value[(string)$val->nameself::_decodeValue($val->value);
  164.                         }
  165.                     }
  166.                 }
  167.             }else if(isset($valuetag->{'dateTime.iso8601'})){
  168.                 $value new jDateTime();
  169.                 $value->setFromString((string)$valuetag->{'dateTime.iso8601'}jDateTime::ISO8601_FORMAT);
  170.             }else if(isset($valuetag->base64)){
  171.                 $value new jBinaryData();
  172.                 $value->setFromBase64String((string)$valuetag->base64);
  173.             }
  174.  
  175.         }else{
  176.             $value = (string) $valuetag;
  177.         }
  178.         return $value;
  179.     }
  180.  
  181.     /**
  182.      * serialize a php value into xmlrpc format
  183.      * @param mixed $value a value
  184.      * @return string xmlrpc content
  185.      */
  186.     private static function _encodeValue($value){
  187.         $response='<value>';
  188.         if(is_array($value)){
  189.  
  190.             $isArray true;
  191.             $data array();
  192.             $structkeys array();
  193.             foreach($value as $key => $val){
  194.                 if(!is_numeric($key))
  195.                     $isArray=false;
  196.  
  197.                 $structkeys[]='<name>'.$key.'</name>';
  198.                 $data[]=self::_encodeValue($val);
  199.             }
  200.  
  201.             if($isArray){
  202.                 $response .= '<array><data>'.implode(' ',$data).'</data></array>';
  203.             }else{
  204.                 $response .= '<struct>';
  205.                 foreach($data as $k=>$v){
  206.                     $response.='<member>'.$structkeys[$k].$v.'</member>';
  207.                 }
  208.                 $response .= '</struct>';
  209.             }
  210.         }else if(is_bool($value)){
  211.             $response .= '<boolean>'.($value?1:0).'</boolean>';
  212.         }else if(is_int($value)){
  213.             $response .= '<int>'.intval($value).'</int>';
  214.         }else if(is_string($value)){
  215.             $response .= '<string>'.htmlspecialchars($value).'</string>';
  216.         }else if(is_float($value) ){
  217.             $response .= '<double>'.doubleval($value).'</double>';
  218.         }else if(is_object($value)){
  219.             switch(get_class($value)){
  220.                 case 'jdatetime':
  221.                     $response .= '<dateTime.iso8601>'.$value->toString(jDateTime::ISO8601_FORMAT).'</dateTime.iso8601>';
  222.                     break;
  223.                 case 'jbinarydata':
  224.                     $response .= '<base64>'.$value->toBase64String().'</base64>';
  225.                     break;
  226.             }
  227.         }
  228.         return $response.'</value>';
  229.     }
  230. }
  231.  
  232. /**
  233.  *
  234.  * @package    jelix
  235.  * @subpackage utils
  236.  */
  237. class jBinaryData  {
  238.     public $data;
  239.  
  240.     public function toBase64String(){
  241.         return base64_encode($this->data);
  242.     }
  243.  
  244.     public function setFromBase64String($string){
  245.         $this->data = base64_decode($string);
  246.     }
  247. }

Documentation generated on Thu, 22 Mar 2012 22:17:38 +0100 by phpDocumentor 1.4.3