Home

Fix for Fix for jquery xmlrpc plugin - data type can be i4 as well as integer

August 29, 2008 - 9:52am — Anonymous
  1. window.jQuery = window.jQuery || {};
  2. window.jQuery.fn = window.jQuery.fn || {};
  3.  
  4. jQuery.fn.rpc = function(url, dataType, onLoadCallback, version) {
  5.         version = version || "1.0";
  6.         dataType = dataType || "json";
  7.         if(dataType != "json" && dataType != "xml") {
  8.                 new Error("IllegalArgument: Unsupported data type");
  9.         }
  10.         var _self = this;
  11.         var serializeToXml = function(data) {
  12.                 switch (typeof data) {
  13.                 case 'boolean':
  14.                         return '<boolean>'+ ((data) ? '1' : '0') +'</boolean>';
  15.                 case 'number':
  16.                         var parsed = parseInt(data);
  17.                         if(parsed == data) {
  18.                                 return '<int>'+ data +'</int>';
  19.                         }
  20.                         return '<double>'+ data +'</double>';
  21.                 case 'string':
  22.                         return '<string>'+ data +'</string>';
  23.                 case 'object':
  24.                         if(data instanceof Date) {
  25.                                 return '<dateTime.iso8601>'+ data.getFullYear() + data.getMonth() + data.getDate() +'T'+ data.getHours() +':'+ data.getMinutes() +':'+ data.getSeconds() +'</dateTime.iso8601>';
  26.                         } else if(data instanceof Array) {
  27.                                 var ret = '<array><data>'+"\n";
  28.                                 for (var i=0; i < data.length; i++) {
  29.                                         ret += '  <value>'+ serializeToXml(data[i]) +"</value>\n";
  30.                                 }
  31.                                 ret += '</data></array>';
  32.                                 return ret;
  33.                         } else {
  34.                                 var ret = '<struct>'+"\n";
  35.                                 jQuery.each(data, function(key, value) {
  36.                                         ret += "  <member><name>"+ key +"</name><value>";
  37.                                         ret += serializeToXml(value) +"</value></member>\n";
  38.                                 });
  39.                                 ret += '</struct>';
  40.                                 return ret;
  41.                         }
  42.                 }
  43.         }
  44.         var xmlRpc = function(method, params) {
  45.                 var ret = '<?xml version="'+version+'"?><methodCall><methodName>'+method+'</methodName><params>';
  46.                 for(var i=0; i<params.length; i++) {
  47.                         ret += "<param><value>"+serializeToXml(params[i])+"</value></param>";
  48.                 }
  49.                 ret += "</params></methodCall>";
  50.                 return ret;
  51.         }
  52.         var parseXmlValue = function(node) {
  53.                 childs = jQuery(node).children();
  54.                 for(var i=0; i < childs.length; i++) {
  55.                         switch(childs[i].tagName) {
  56.                         case 'boolean':
  57.                                 return (jQuery(childs[i]).text() == 1);
  58.                         case 'int':
  59.                         case 'i4':
  60.                                 return parseInt(jQuery(childs[i]).text());
  61.                         case 'double':
  62.                                 return parseFloat(jQuery(childs[i]).text());
  63.                         case "string":
  64.                                 return jQuery(childs[i]).text();
  65.                         case "array":
  66.                                 var ret = [];
  67.                                 jQuery("> data > value", childs[i]).each(
  68.                                         function() {
  69.                                                 ret.push(parseXmlValue(this));
  70.                                         }
  71.                                 );
  72.                                 return ret;
  73.                         case "struct":
  74.                                 var ret = {};
  75.                                 jQuery("> member", childs[i]).each(
  76.                                         function() {
  77.                                                 ret[jQuery( "> name", this).text()] = parseXmlValue(jQuery("value", this));
  78.                                         }
  79.                                 );
  80.                                 return ret;
  81.                         case "dateTime.iso8601":
  82.                                 /* TODO: fill me :( */
  83.                                 return NULL;
  84.                         }
  85.                 }
  86.         }
  87.         var parseXmlResponse = function(data) {
  88.                 var ret = {};
  89.                 ret.version = version;
  90.                 jQuery("methodResponse params param > value", data).each(
  91.                         function(index) {
  92.                                 ret.result = parseXmlValue(this);
  93.                         }
  94.                 );
  95.                 jQuery("methodResponse fault > value", data).each(
  96.                         function(index) {
  97.                                 ret.error = parseXmlValue(this);
  98.                         }
  99.                 );
  100.                 return ret;
  101.         }
  102.         var rpc_contents = {
  103.                 'xml':'text/xml'
  104.                 ,'json':'application/json'
  105.         };
  106.         var _rpc = function(method, callback) {
  107.                 var params = [];
  108.                 for (var i=2; i<arguments.length; i++) {
  109.                         params.push(arguments[i]);
  110.                 }
  111.                 console.log(params);
  112.                 var data;
  113.                 if(dataType == 'json') {
  114.                         data = {"version":version, "method":method, "params":params};
  115.                 } else {
  116.                         data = xmlRpc(method, params);
  117.                 }
  118.                 console.log(data);
  119.                 jQuery.ajax({
  120.                         "url": url,
  121.                         "dataType": dataType,
  122.                         "type": 'POST',
  123.                         "data": data,
  124.                         "success": function(inp) {
  125.                                 var json = inp;
  126.                                 if(dataType == "xml") {
  127.                                         json = parseXmlResponse(inp);
  128.                                 }
  129.                                 console.log("json response:", json);
  130.                                 callback(json);
  131.                         },
  132.                         "processData": false,
  133.                         "contentType": rpc_contents[dataType]
  134.                 });
  135.         };
  136.         _rpc("system.listMethods",
  137.                 function(json) {
  138.                         console.log(json);
  139.                         /* get the functions */
  140.                         if(!json.result) {
  141.                                 return;
  142.                         }
  143.                         var proc = null;
  144.                         for(var i = 0; i<json.result.length; i++) {
  145.                                 proc = json.result[i];
  146.                                 var obj = _self;
  147.                                 var objStack = proc.split(/\./);
  148.                                 for(var j = 0; j < (objStack.length - 1); j++){
  149.                                         obj[objStack[j]] = obj[objStack[j]] || {};
  150.                                         obj = obj[objStack[j]];
  151.                                 }
  152.                                 /* add the new procedure */
  153.                                 obj[objStack[j]] = (
  154.                                         function(method, obj) {
  155.                                                 var _outer = {"method":method,"rpc":_rpc};
  156.                                                 return function(callback) {
  157.                                                         var params = [];
  158.                                                         params.push(_outer.method);
  159.                                                         params.push(callback);
  160.                                                         for (var i=1; i<arguments.length; i++) {
  161.                                                                 params.push(arguments[i]);
  162.                                                         }
  163.                                                         _rpc.apply(_self, params);
  164.                                                 }
  165.                                         }
  166.                                 )(proc, _rpc);
  167.                         }
  168.                         console.log('Load was performed.');
  169.                         if(onLoadCallback) {
  170.                                 onLoadCallback(_self);
  171.                         }
  172.                 }
  173.         );
  174. };

Submit Fix

Any tags you'd like to associate with your code, delimitered by commas (example: Views, CCK, Module, etc).
Select the syntax highlighting mode to use.