开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 中间件编程 > 查看源码
ext-base-ajax.js
资源名称：ext-3.0.0.zip　[点击查看]
上传用户：shuoshiled
上传日期：2018-01-28
资源大小：10124k
文件大小：13k
源码类别：

中间件编程

开发平台：

JavaScript

ext-base-ajax.js：源码内容
  1. /*!  * Ext JS Library 3.0.0  * Copyright(c) 2006-2009 Ext JS, LLC  * licensing@extjs.com  * http://www.extjs.com/license  */ /*
  2.  * Portions of this file are based on pieces of Yahoo User Interface Library
  3.  * Copyright (c) 2007, Yahoo! Inc. All rights reserved.
  4.  * YUI licensed under the BSD License:
  5.  * http://developer.yahoo.net/yui/license.txt
  6.  */
  7.     Ext.lib.Ajax = function() {     
  8.     var activeX = ['MSXML2.XMLHTTP.3.0',
  9.            'MSXML2.XMLHTTP',
  10.            'Microsoft.XMLHTTP'],
  11.             CONTENTTYPE = 'Content-Type';
  12.            
  13. // private
  14. function setHeader(o) {
  15.         var conn = o.conn,
  16.          prop;
  17.         
  18.         function setTheHeaders(conn, headers){
  19.       for (prop in headers) {
  20.                     if (headers.hasOwnProperty(prop)) {
  21.                         conn.setRequestHeader(prop, headers[prop]);
  22.                     }
  23.                 }   
  24.         }
  25.         
  26.             if (pub.defaultHeaders) {
  27.             setTheHeaders(conn, pub.defaultHeaders);
  28.             }
  30.             if (pub.headers) {
  31. setTheHeaders(conn, pub.headers);
  32.                 pub.headers = null;                
  33.             }
  34.         }    
  35.         
  36.         // private
  37.         function createExceptionObject(tId, callbackArg, isAbort, isTimeout) {         
  38.             return {
  39.             tId : tId,
  40.             status : isAbort ? -1 : 0,
  41.             statusText : isAbort ? 'transaction aborted' : 'communication failure',
  42.                     isAbort: true,
  43.                     isTimeout: true,
  44.             argument : callbackArg
  45.             };
  46.         }  
  47.         
  48.         // private 
  49.         function initHeader(label, value) {         
  50. (pub.headers = pub.headers || {})[label] = value;             
  51.         }
  52.     
  53.         // private
  54.         function createResponseObject(o, callbackArg) {
  55.             var headerObj = {},
  56.                 headerStr,              
  57.                 conn = o.conn,
  58.                 t,
  59.                 s;
  61.             try {
  62.                 headerStr = o.conn.getAllResponseHeaders();   
  63.                 Ext.each(headerStr.replace(/rn/g, 'n').split('n'), function(v){
  64.                     t = v.indexOf(':');
  65.                     if(t >= 0){
  66.                         s = v.substr(0, t).toLowerCase();
  67.                         if(v.charAt(t + 1) == ' '){
  68.                             ++t;
  69.                         }
  70.                         headerObj[s] = v.substr(t + 1);
  71.                     }
  72.                 });
  73.             } catch(e) {}
  74.                         
  75.             return {
  76.                 tId : o.tId,
  77.                 status : conn.status,
  78.                 statusText : conn.statusText,
  79.                 getResponseHeader : function(header){return headerObj[header.toLowerCase()];},
  80.                 getAllResponseHeaders : function(){return headerStr},
  81.                 responseText : conn.responseText,
  82.                 responseXML : conn.responseXML,
  83.                 argument : callbackArg
  84.             };
  85.         }
  86.         
  87.         // private
  88.         function releaseObject(o) {
  89.             o.conn = null;
  90.             o = null;
  91.         }        
  92.     
  93.         // private
  94.         function handleTransactionResponse(o, callback, isAbort, isTimeout) {
  95.             if (!callback) {
  96.                 releaseObject(o);
  97.                 return;
  98.             }
  100.             var httpStatus, responseObject;
  102.             try {
  103.                 if (o.conn.status !== undefined && o.conn.status != 0) {
  104.                     httpStatus = o.conn.status;
  105.                 }
  106.                 else {
  107.                     httpStatus = 13030;
  108.                 }
  109.             }
  110.             catch(e) {
  111.                 httpStatus = 13030;
  112.             }
  114.             if ((httpStatus >= 200 && httpStatus < 300) || (Ext.isIE && httpStatus == 1223)) {
  115.                 responseObject = createResponseObject(o, callback.argument);
  116.                 if (callback.success) {
  117.                     if (!callback.scope) {
  118.                         callback.success(responseObject);
  119.                     }
  120.                     else {
  121.                         callback.success.apply(callback.scope, [responseObject]);
  122.                     }
  123.                 }
  124.             }
  125.             else {
  126.                 switch (httpStatus) {
  127.                     case 12002:
  128.                     case 12029:
  129.                     case 12030:
  130.                     case 12031:
  131.                     case 12152:
  132.                     case 13030:
  133.                         responseObject = createExceptionObject(o.tId, callback.argument, (isAbort ? isAbort : false), isTimeout);
  134.                         if (callback.failure) {
  135.                             if (!callback.scope) {
  136.                                 callback.failure(responseObject);
  137.                             }
  138.                             else {
  139.                                 callback.failure.apply(callback.scope, [responseObject]);
  140.                             }
  141.                         }
  142.                         break;
  143.                     default:
  144.                         responseObject = createResponseObject(o, callback.argument);
  145.                         if (callback.failure) {
  146.                             if (!callback.scope) {
  147.                                 callback.failure(responseObject);
  148.                             }
  149.                             else {
  150.                                 callback.failure.apply(callback.scope, [responseObject]);
  151.                             }
  152.                         }
  153.                 }
  154.             }
  156.             releaseObject(o);
  157.             responseObject = null;
  158.         }  
  159.         
  160.         // private
  161.         function handleReadyState(o, callback){
  162.     callback = callback || {};
  163.             var conn = o.conn,
  164.              tId = o.tId,
  165.              poll = pub.poll,
  166. cbTimeout = callback.timeout || null;
  168.             if (cbTimeout) {
  169.                 pub.timeout[tId] = setTimeout(function() {
  170.                     pub.abort(o, callback, true);
  171.                 }, cbTimeout);
  172.             }
  174.             poll[tId] = setInterval(
  175.                 function() {
  176.                     if (conn && conn.readyState == 4) {
  177.                         clearInterval(poll[tId]);
  178.                         poll[tId] = null;
  180.                         if (cbTimeout) {
  181.                             clearTimeout(pub.timeout[tId]);
  182.                             pub.timeout[tId] = null;
  183.                         }
  185.                         handleTransactionResponse(o, callback);
  186.                     }
  187.                 },
  188.                 pub.pollInterval);
  189.         }
  190.         
  191.         // private
  192.         function asyncRequest(method, uri, callback, postData) {
  193.             var o = getConnectionObject() || null;
  195.             if (o) {
  196.                 o.conn.open(method, uri, true);
  198.                 if (pub.useDefaultXhrHeader) {                    
  199.                  initHeader('X-Requested-With', pub.defaultXhrHeader);
  200.                 }
  202.                 if(postData && pub.useDefaultHeader && (!pub.headers || !pub.headers[CONTENTTYPE])){
  203.                     initHeader(CONTENTTYPE, pub.defaultPostHeader);
  204.                 }
  206.                 if (pub.defaultHeaders || pub.headers) {
  207.                     setHeader(o);
  208.                 }
  210.                 handleReadyState(o, callback);
  211.                 o.conn.send(postData || null);
  212.             }
  213.             return o;
  214.         }
  215.         
  216.         // private
  217.         function getConnectionObject() {
  218.             var o;      
  220.             try {
  221.                 if (o = createXhrObject(pub.transactionId)) {
  222.                     pub.transactionId++;
  223.                 }
  224.             } catch(e) {
  225.             } finally {
  226.                 return o;
  227.             }
  228.         }
  229.        
  230.         // private
  231.         function createXhrObject(transactionId) {
  232.             var http;
  233.             
  234.             try {
  235.                 http = new XMLHttpRequest();                
  236.             } catch(e) {
  237.                 for (var i = 0; i < activeX.length; ++i) {             
  238.                     try {
  239.                         http = new ActiveXObject(activeX[i]);                        
  240.                         break;
  241.                     } catch(e) {}
  242.                 }
  243.             } finally {
  244.                 return {conn : http, tId : transactionId};
  245.             }
  246.         }
  247.          
  248.     var pub = {
  249.         request : function(method, uri, cb, data, options) {
  250.     if(options){
  251.         var me = this,         
  252.          xmlData = options.xmlData,
  253.          jsonData = options.jsonData,
  254.                         hs;
  255.         
  256.         Ext.applyIf(me, options);         
  257.             
  258.             if(xmlData || jsonData){
  259.                         hs = me.headers;
  260.                         if(!hs || !hs[CONTENTTYPE]){
  261.                 initHeader(CONTENTTYPE, xmlData ? 'text/xml' : 'application/json');
  262.                         }
  263.             data = xmlData || (Ext.isObject(jsonData) ? Ext.encode(jsonData) : jsonData);
  264.         }
  265.     }          
  266.     return asyncRequest(method || options.method || "POST", uri, cb, data);
  267.         },
  269.         serializeForm : function(form) {
  270.         var fElements = form.elements || (document.forms[form] || Ext.getDom(form)).elements,
  271.              hasSubmit = false,
  272.              encoder = encodeURIComponent,
  273.          element,
  274.              options, 
  275.              name, 
  276.              val,             
  277.              data = '',
  278.              type;
  279.             
  280.         Ext.each(fElements, function(element) {             
  281.                 name = element.name;              
  282. type = element.type;
  284.                 if (!element.disabled && name){
  285.                 if(/select-(one|multiple)/i.test(type)){                 
  286.             Ext.each(element.options, function(opt) {
  287.             if (opt.selected) {
  288.             data += String.format("{0}={1}&",                 
  289.               encoder(name),               
  290.                (opt.hasAttribute ? opt.hasAttribute('value') : opt.getAttributeNode('value').specified) ? opt.value : opt.text);
  291.                                 }
  292.                             });
  293.                 } else if(!/file|undefined|reset|button/i.test(type)) {
  294.                 if(!(/radio|checkbox/i.test(type) && !element.checked) && !(type == 'submit' && hasSubmit)){
  295.                                     
  296.                                 data += encoder(name) + '=' + encoder(element.value) + '&';                     
  297.                                 hasSubmit = /submit/i.test(type);    
  298.                             }                  
  299.                 } 
  300.                 }
  301.             });            
  302.             return data.substr(0, data.length - 1);
  303.         },
  304.         
  305.         useDefaultHeader : true,
  306.         defaultPostHeader : 'application/x-www-form-urlencoded; charset=UTF-8',
  307.         useDefaultXhrHeader : true,
  308.         defaultXhrHeader : 'XMLHttpRequest',        
  309.         poll : {},
  310.         timeout : {},
  311.         pollInterval : 50,
  312.         transactionId : 0,
  313.         
  314. // This is never called - Is it worth exposing this?           
  315. //          setProgId : function(id) {
  316. //              activeX.unshift(id);
  317. //          },
  319. // This is never called - Is it worth exposing this?  
  320. //          setDefaultPostHeader : function(b) {
  321. //              this.useDefaultHeader = b;
  322. //          },
  323.         
  324. // This is never called - Is it worth exposing this?  
  325. //          setDefaultXhrHeader : function(b) {
  326. //              this.useDefaultXhrHeader = b;
  327. //          },
  329. // This is never called - Is it worth exposing this?        
  330. //          setPollingInterval : function(i) {
  331. //              if (typeof i == 'number' && isFinite(i)) {
  332. //                  this.pollInterval = i;
  333. //              }
  334. //          },
  335.         
  336. // This is never called - Is it worth exposing this?
  337. //          resetDefaultHeaders : function() {
  338. //              this.defaultHeaders = null;
  339. //          },
  341.         abort : function(o, callback, isTimeout) {
  342.         var me = this,
  343.          tId = o.tId,
  344.          isAbort = false;
  345.         
  346.             if (me.isCallInProgress(o)) {
  347.                 o.conn.abort();
  348.                 clearInterval(me.poll[tId]);
  349.                 me.poll[tId] = null;
  350.                 if (isTimeout) {
  351.                     me.timeout[tId] = null;
  352.                 }
  354.                 handleTransactionResponse(o, callback, (isAbort = true), isTimeout);                
  355.             }
  356.             return isAbort;
  357.         },
  359.         isCallInProgress : function(o) {
  360.             // if there is a connection and readyState is not 0 or 4
  361.             return o.conn && !{0:true,4:true}[o.conn.readyState];         
  362.         }
  363.     };
  364.     return pub;
  365.     }();