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

Documentation generated on Mon, 26 Oct 2015 21:56:56 +0100 by phpDocumentor 1.4.3