Home

Fix for Fix for jquery xmlrpc plugin

October 5, 2009 - 1:13pm — 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.                                 return parseInt(jQuery(childs[i]).text());
  60.                         case 'double':
  61.                                 return parseFloat(jQuery(childs[i]).text());
  62.                         case "string":
  63.                                 return jQuery(childs[i]).text();
  64.                         case "array":
  65.                                 var ret = [];
  66.                                 jQuery("> data > value", childs[i]).each(
  67.                                         function() {
  68.                                                 ret.push(parseXmlValue(this));
  69.                                         }
  70.                                 );
  71.                                 return ret;
  72.                         case "struct":
  73.                                 var ret = {};
  74.                                 jQuery("> member", childs[i]).each(
  75.                                         function() {
  76.                                                 ret[jQuery( "> name", this).text()] = parseXmlValue(jQuery("value", this));
  77.                                         }
  78.                                 );
  79.                                 return ret;
  80.                         case "dateTime.iso8601":
  81.                                 /* TODO: fill me :( */
  82.                                 return NULL;
  83.                         }
  84.                 }
  85.         }
  86.         var parseXmlResponse = function(data) {
  87.                 var ret = {};
  88.                 ret.version = version;
  89.                 jQuery("methodResponse params param > value", data).each(
  90.                         function(index) {
  91.                                 ret.result = parseXmlValue(this);
  92.                         }
  93.                 );
  94.                 jQuery("methodResponse fault > value", data).each(
  95.                         function(index) {
  96.                                 ret.error = parseXmlValue(this);
  97.                         }
  98.                 );
  99.                 return ret;
  100.         }
  101.         var rpc_contents = {
  102.                 'xml':'text/xml'
  103.                 ,'json':'application/json'
  104.         };
  105.         var _rpc = function(method, callback) {
  106.                 var params = [];
  107.                 for (var i=2; i<arguments.length; i++) {
  108.                         params.push(arguments[i]);
  109.                 }
  110.                 console.log(params);
  111.                 var data;
  112.                 if(dataType == 'json') {
  113.                         data = {"version":version, "method":method, "params":params};
  114.                 } else {
  115.                         data = xmlRpc(method, params);
  116.                 }
  117.                 console.log(data);
  118.                 jQuery.ajax({
  119.                         "url": url,
  120.                         "dataType": dataType,
  121.                         "type": 'POST',
  122.                         "data": data,
  123.                         "success": function(inp) {
  124.                                 var json = inp;
  125.                                 if(dataType == "xml") {
  126.                                         json = parseXmlResponse(inp);
  127.                                 }
  128.                                 console.log("json response:", json);
  129.                                 callback(json);
  130.                         },
  131.                         "processData": false,
  132.                         "contentType": rpc_contents[dataType]
  133.                 });
  134.         };
  135.         _rpc("system.listMethods",
  136.                 function(json) {
  137.                         console.log(json);
  138.                         /* get the functions */
  139.                         if(!json.result) {
  140.                                 return;
  141.                         }
  142.                         var proc = null;
  143.                         for(var i = 0; i<json.result.length; i++) {
  144.                                 proc = json.result[i];
  145.                                 var obj = _self;
  146.                                 var objStack = proc.split(/\./);
  147.                                 for(var j = 0; j < (objStack.length - 1); j++){
  148.                                         obj[objStack[j]] = obj[objStack[j]] || {};
  149.                                         obj = obj[objStack[j]];
  150.                                 }
  151.                                 /* add the new procedure */
  152.                                 obj[objStack[j]] = (
  153.                                         function(method, obj) {
  154.                                                 var _outer = {"method":method,"rpc":_rpc};
  155.                                                 return function(callback) {
  156.                                                         var params = [];
  157.                                                         params.push(_outer.method);
  158.                                                         params.push(callback);
  159.                                                         for (var i=1; i<arguments.length; i++) {
  160.                                                                 params.push(arguments[i]);
  161.                                                         }
  162.                                                         _rpc.apply(_self, params);
  163.                                                 }
  164.                                         }
  165.                                 )(proc, _rpc);
  166.                         }
  167.                         console.log('Load was performed.');
  168.                         if(onLoadCallback) {
  169.                                 onLoadCallback(_self);
  170.                         }
  171.                 }
  172.         );
  173. };

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.