home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / pluginy Firefox / 8206 / 8206.xpi / content / rss / xmlrpc.js < prev   
Encoding:
Text File  |  2010-02-02  |  7.2 KB  |  294 lines
  1. function getInnerText (node) {
  2.   if (typeof node.textContent != 'undefined') {
  3.     return node.textContent;
  4.   } else if (typeof node.innerText != 'undefined') {
  5.     return node.innerText;
  6.   } else if (typeof node.text != 'undefined') {
  7.     return node.text;
  8.   } else {
  9.     switch (node.nodeType) {
  10.       case 3:
  11.       case 4:
  12.         return node.nodeValue;
  13.         break;
  14.       case 1:
  15.       case 11:
  16.         var innerText = '';
  17.         for (var i = 0; i < node.childNodes.length; i++) {
  18.           innerText += getInnerText(node.childNodes[i]);
  19.         }
  20.         return innerText;
  21.         break;
  22.       default:
  23.         return '';
  24.     }
  25.   }
  26. }
  27.  
  28. WiseStampXMLRPCResponse.prototype = new Object;
  29. WiseStampXMLRPCResponse.prototype.isError = WiseStampXMLRPCResponse_isError;
  30.  
  31. function WiseStampXMLRPCResponse(param) {
  32.   this.param = param;
  33. }
  34.  
  35. function WiseStampXMLRPCResponse_isError() {
  36.   return false;
  37. }
  38.  
  39. /* ---------- */
  40.  
  41. WiseStampXMLRPCError.prototype = new Object;
  42. WiseStampXMLRPCError.prototype.isError = WiseStampXMLRPCError_isError;
  43. WiseStampXMLRPCError.prototype.getMessage = WiseStampXMLRPCError_getMessage;
  44.  
  45. function WiseStampXMLRPCError(code, message) {
  46.   this._message = message;
  47.   this._code    = code;
  48. }
  49.  
  50. function WiseStampXMLRPCError_getMessage() {
  51.   return this._message;
  52. }
  53.  
  54. function WiseStampXMLRPCError_isError() {
  55.   return true;
  56. }
  57.  
  58. /* ---------- */
  59.  
  60. var WiseStampXMLRPC = new Object;
  61. WiseStampXMLRPC.prepare = function(name, params) {
  62.   var methodName = "<methodName>"+name+"</methodName>\n";
  63.  
  64.   var paramsText = "<params>\n";
  65.  
  66.   for (var i=0; i<params.length; i++) {
  67.     var paramText = "<param><value><string>"+params[i]+"</string></value></param>\n";
  68.     paramsText += this._prepareParam(params[i]);
  69.   };
  70.   paramsText += "</params>\n";
  71.  
  72.   return "<methodCall>\n"+methodName+paramsText+"</methodCall>\n";
  73. };
  74.  
  75. WiseStampXMLRPC._prepareParam = function(value) {
  76.    var paramText;
  77.    paramText  = "<param>";
  78.    paramText += this._prepareValue(value);
  79.    paramText += "</param>\n";
  80.    return paramText;
  81. }
  82.  
  83. WiseStampXMLRPC._prepareValue = function(value) {
  84.   var paramText = "<value>";
  85.   switch (typeof value) {
  86.     case "object":
  87.       paramText += this._prepareObject(value);
  88.       break;
  89.     default:
  90.       paramText += this._prepareString(value);
  91.       break;
  92.   };
  93.   paramText += "</value>";
  94.   return paramText;
  95. }
  96.  
  97. WiseStampXMLRPC._prepareObject = function(value) {
  98.   var valueText = "";
  99.   for (var key in value) {
  100.     valueText += "<member><name>"+key+"</name>"+this._prepareValue(value[key])+"</member>\n"
  101.   };
  102.   return "<struct>"+valueText+"</struct>";
  103. }
  104.  
  105. WiseStampXMLRPC._prepareString = function(value) {
  106.   return "<string>"+value.replace(/&/g, "&").replace(/>/g, ">").replace(/</g, "<")+"</string>";
  107. }
  108.  
  109. WiseStampXMLRPC.parseResponse = function(responseXML) {
  110.   // Check if it is the error response
  111.   var faultElement = responseXML.getElementsByTagName('fault')[0];
  112.  
  113.   // TODO: make more reliable parsing utility
  114.   if (faultElement) {
  115.     var code    = getInnerText(faultElement.getElementsByTagName('int')[0]);
  116.     var message = getInnerText(faultElement.getElementsByTagName('string')[0]);
  117.  
  118.     var response = new WiseStampXMLRPCError(code, message);
  119.     return response;
  120.   };
  121.  
  122.   // Normal response
  123.   //
  124.   // The body of the response is a single XML structure, a <methodResponse>, 
  125.   // which _can_ contain a single <params> which contains a single <param> which contains a single <value>.
  126.   //
  127.   var paramXML = responseXML.getElementsByTagName('param')[0];
  128.   if (paramXML) {
  129.     return new WiseStampXMLRPCResponse(this._parseResponseParam(paramXML));
  130.   } else {
  131.     return new WiseStampXMLRPCResponse(null);
  132.   };
  133. };
  134.  
  135. WiseStampXMLRPC._parseResponseParam = function(element) {
  136.   for (var i=0; i<element.childNodes.length; i++) {
  137.     var node = element.childNodes[i];
  138.     if (node.tagName == "value") {
  139.       return this._parseValue(node);
  140.     };
  141.   };
  142. }
  143.  
  144. WiseStampXMLRPC._parseValue = function(element) {
  145.   for (var i=0; i<element.childNodes.length; i++) {
  146.     var node = element.childNodes[i];
  147.     switch (node.tagName) {
  148.       case "int":
  149.       case "i4":
  150.         return this._parseInt(node);
  151.       case "boolean":
  152.         return this._parseBoolean(node);
  153.       case "string":
  154.         return this._parseString(node);
  155.       case "double":
  156.         return this._parseDouble(node);
  157.       case "dateTime.iso8601":
  158.         return this._parseDateTime(node);
  159.       case "base64":
  160.         return this._parseBase64(node);
  161.       case "struct":
  162.         return this._parseStruct(node);
  163.       case "array":
  164.         return this._parseArray(node);
  165.     };
  166.   };  
  167. }
  168.  
  169. WiseStampXMLRPC._parseInt = function(element) {
  170.   return parseInt(getInnerText(element));
  171. }
  172.  
  173. WiseStampXMLRPC._parseBoolean = function(element) {
  174.   var text = getInnerText(element);
  175.  
  176.   if (!text) { 
  177.     return false;
  178.   };
  179.  
  180.   if (text == 'false') {
  181.     return false;
  182.   };
  183.  
  184.   if (text == 'no') {
  185.     return false;
  186.   };
  187.  
  188.   if (text == '0') {
  189.     return false;
  190.   };
  191.  
  192.   return true;
  193. }
  194.  
  195. WiseStampXMLRPC._parseString = function(element) {
  196.   return getInnerText(element);
  197. }
  198.  
  199. WiseStampXMLRPC._parseDouble = function(element) {
  200.   return parseFloat(getInnerText(element));
  201. }
  202.  
  203. WiseStampXMLRPC._parseDateTime = function(element) {
  204.   // @TODO
  205.   return getInnerText(element);
  206. }
  207.  
  208. WiseStampXMLRPC._parseBase64 = function(element) {
  209.   return getInnerText(element);
  210. }
  211.  
  212. WiseStampXMLRPC._parseStruct = function(element) {
  213.   var struct = new Object;
  214.  
  215.   for (var i=0; i<element.childNodes.length; i++) {
  216.     var node = element.childNodes[i];
  217.     if (node.tagName == "member") {
  218.       var member = this._parseMember(node);
  219.       struct[member.name] = member.value;
  220.     };
  221.   };
  222.  
  223.   return struct;  
  224. }
  225.  
  226. WiseStampXMLRPC._parseMember = function(element) {
  227.   var member = new Array();
  228.  
  229.   for (var i=0; i<element.childNodes.length; i++) {
  230.     var node = element.childNodes[i];
  231.     switch (node.tagName) {
  232.       case "name":
  233.         member.name = this._parseName(node);
  234.         break;
  235.       case "value":
  236.         member.value = this._parseValue(node); 
  237.         break;
  238.     };
  239.   };
  240.  
  241.   return member;
  242. }
  243.  
  244. WiseStampXMLRPC._parseName = function(element) {
  245.   return getInnerText(element);
  246. }
  247.  
  248. WiseStampXMLRPC._parseArray = function(element) {
  249.   for (var i=0; i<element.childNodes.length; i++) {
  250.     var node = element.childNodes[i];
  251.     if (node.tagName == "data") {
  252.       return this._parseData(node);
  253.     };
  254.   };
  255. }
  256.  
  257. WiseStampXMLRPC._parseData = function(element) {
  258.   var data = new Array();
  259.   for (var i=0; i<element.childNodes.length; i++) {
  260.     var node = element.childNodes[i];
  261.     if (node.tagName == "value") {
  262.       data.push(this._parseValue(node));
  263.     };
  264.   };
  265.   return data;
  266. }
  267.  
  268. WiseStampXMLRPC.call = function(url, successCallback, failureCallback, name, params) {
  269.   var request = WiseStampCreateXMLHttpRequest();
  270.   request.error = WiseStampXMLRPC._ajaxErrorHandler;
  271.   request.onsuccess = function() { 
  272.     if (request.handleError()) { 
  273.       if (failureCallback) {
  274.         failureCallback();
  275.       };
  276.       return false; 
  277.     }; 
  278.  
  279.     var response = WiseStampXMLRPC.parseResponse(request.xmlhttp.responseXML);
  280.     successCallback(response); 
  281.   };
  282.  
  283.   request.open('POST',url,1);
  284. //  request.xmlhttp.setRequestHeader("Content-Type", "text/xml");
  285.  
  286.   var query = this.prepare(name, params);
  287.  
  288.   request.send(query);
  289. };
  290.  
  291. WiseStampXMLRPC._ajaxErrorHandler = function(text) {
  292.   alert(text);
  293.   return true;
  294. };