* ASC.namespace("property.package");
* ASC.namespace("ASC.property.package");
*
* ASC.namespace("really.long.nested.namespace");
* Note: ASC.namespace always creates the package with ASC as the root whereas ASC.ns will create
* a new object chain with any object as it's root element
*
* ASC.namespace('MyCompany.MyClass');
*
* ASC.namespace('ASC.MyCompany.MyClass');
*
* ASC.ns('MyCompany.MyClass');
*
* Ext.namespace('Company', 'Company.data');
* Company.Widget = function() { ... }
* Company.data.CustomStore = function(config) { ... }
* Note: ASC.namespace always creates the package with ASC as the root whereas ASC.ns will create
* a new object chain with any object as it's root element
*
* ASC.namespace('MyCompany.MyClass');
*
* ASC.namespace('ASC.MyCompany.MyClass');
*
* ASC.ns('MyCompany.MyClass');
* NOTE: this should be safe to use on self referencing objects
*It should not be used on any of the browsers built-in objects as the results will not be indentical
* @return Object * @method clone * @member ASC */ clone: function (o) { var clone = function (obj) { if (!obj || typeof(obj) !== 'object') { return obj; } if(obj.nodeType && obj.cloneNode){ /* isNode */ return obj.cloneNode(true); /* Node */ } var newObj = obj.constructor(); for (var key in obj) { if (obj !== obj[key]) { newObj[key] = clone(obj[key]); } else { //create the self reference but point the new object to itself newObj[key] = newObj; } } return newObj; }; return clone(o); }, /** * Return the dom node for the passed string (id), dom node, or Ext.Element * @param {Mixed} el * @return HTMLElement * @member ASC */ getDom: function (el) { if(!el || !document){ return null; } return el.dom ? el.dom : (typeof el == 'string' ? document.getElementById(el) : el); }, /** * Copies all the properties of config to obj if they don't already exist. * @param {Object} obj The receiver of the properties * @param {Object} cfg The source of the properties * @return {Object} returns obj * @member ASC */ applyIf: function(obj, cfg) { return Ext.applyIf(obj, cfg); }, /** * Extends one class with another class and optionally overrides members with the passed literal. This class * also adds the function "override()" to the class that can be used to override * members on an instance. ** This function also supports a 2-argument call in which the subclass's constructor is * not passed as an argument. In this form, the parameters are as follows:
*
superclass
* overrides
* * This may contain a special member named constructor. This is used * to define the constructor of the new class, and is returned. If this property is * not specified, a constructor is generated and returned which just calls the * superclass's constructor passing on its parameters.
* For example, to create a subclass of the Ext GridPanel: *
* MyAjaxHandler = ASC.extend(ASC.Ajax.Response, {
* constructor: function(cfg)
* {
* // Your preprocessing here
* MyAjaxHandler.superclass.constructor.apply(this, arguments);
* // Your postprocessing here
* },
*
* yourMethod: function() {
* // etc.
* }
* });
*
*
* ASC.override(MyClass, {
* newMethod1: function(){
* // etc.
* },
* newMethod2: function(foo){
* // etc.
* }
* });If str is not a number the value for nanDefault is returned If nanDefault was not provided NaN is returned* @param {String} str String to be converted to a Float * @param {Object} nanDefault optional value to return if the string cannot be converted into a number * @param {String} locale optional Identify the language of str * @method getFloat * @return Float */ getFloat: function (str, nanDefault, locale) { if (typeof nanDefault === 'undefined') { nanDefault = Number.NaN; } if (str == null || str.length < 1) { return nanDefault; } if (typeof str !== 'string') { str = str.toString(); } var regEx = ASC.getFormatProperty('getNumberRegEx', locale); //Clean up any formatting chars if (regEx) { str = str.replace(regEx, ''); } var decChar = ASC.getFormatProperty('decimalChar', locale); //Javascript deals with EN numbers convert the non-standard //decimal character to a . so parse float will execute properly if (decChar != '.') { str = str.replace(decChar, '.'); } var val = parseFloat(str); if (isNaN(val)) { val = nanDefault; } return val; }, /** * Cast a String to a Interger Number Object
If str is not a number the value for nanDefault is returned If nanDefault was not provided NaN is returned* @param {String} str String to be converted to an Integer * @param {Number/Object} [nanDefault] optional value to return if the string cannot be converted into a number * @param {String} [locale] Optional param to identify the language of str * @return Integer * @method getInt */ getInt: function (str, nanDefault, locale) { var val = ASC.util.getFloat(str, nanDefault, locale); if (!isNaN(val)) { return parseInt(val, 10); } else { return val; //getFloat should equal nanDefault and NaN if nanDefault is undefined } }, /** * Cast a String to a Boolean * @param {String} str String to cast to a Boolean * @return Boolean * @method getBool */ getBool: function (str) { if (typeof(str) === 'string') { return str.toLowerCase() == 'true'; } else { return str.toString().toLowerCase() == 'true'; } }, /** * Retrieved the selected text of a select option * @param {String/HTMLElement/ASC.Element} element Element Id, Element, or ASC.Element reference of the select to retrieve the text of * @param {Object} [defaultValue] Value to be returned should the lookup fail * @method getText * @return String */ getText: function (element, defaultValue) { var el = document.getElement(element); if (!el) { return defaultValue; } return el.selectedIndex !== -1 ? el.options[el.selectedIndex].text : defaultValue; }, /** * Given the name of a set of Radio Buttons return an HTMLElement reference to the * selected input * @param {String} name HTML name attribute for the group of inputs to search * @method getSelectedRadioButton * @return HTMLElement */ getSelectedRadioButton: function (name) { var els = document.getElementsByName(name); var selected = null; for (var i=0; selected === null && i
* ASC.util.addOptionsToSelect('foo', [{text:'Foo', value:'Bar', selected: false}], false);
*
* @param {HTMLElement/ASC.Element} el
* @param {Array} options
* @param {Boolean} append Add the options to the existing values in the select
* @method addOptionsToSelect
*/
addOptionsToSelect: function (el, options, append)
{
var select = null;
if (typeof el === 'string') {
select = document.getElementById(el);
} else if (el && el.dom) {
select = el.dom;
} else if (el) {
select = el;
}
if (!select.nodeName || select.nodeName !== 'SELECT') { return; }
var insertAt = 0;
if (append) {
insertAt = select.options.length;
} else {
select.options.length = 0; /*clear out the list*/
}
ASC.forEach(options, function (item) {
var i = insertAt++;
select.options[i] = new Option(item.text, item.value);
if (item.selected) {
select.selectedIndex = i;
}
});
},
/**
* Verify if a String is a valid email address
* The RFC822 specification is used to validate the string
* @param {String} str String to test as an email address
* @param {Boolean} [allowIntranetAddress] Flag to use strict compliance to the RFC822 specification
* intranet addresses such as me@domain are valid under the specification
* By default this method will require a top level domain as part the email address
* @method isEmailAddress
* @return Boolean
*/
isEmailAddress: function (str, allowIntranetAddress)
{
if (allowIntranetAddress !== true) {
return regexEmail.test(str) && regexHasTLD.test(str);
}
return regexEmail.test(str);
},
/**
* Test to see if we have a valid number before calling getFloat()
* as we do not want to auto convert an invalid value to 0
* @param {String} str String to test as a numeric value
* @param {String/Locale} [locale] Provide the locale that should be used to validate the String against
* Defaults to the current locale
* @return Boolean
* @method isNumeric
*/
isNumeric: function (str, locale)
{
var testRegEx = ASC.getFormatProperty('testNumberRegEx', locale);
if (!testRegEx) {
throw 'ASC.util.isNumeric testNumberReg could not be found.';
}
return !testRegEx.test(str);
},
/**
* Test to see if a string contains a valid zip code
* @param {String} str String to be tested for a valid zip code
* @return Boolean
* @method isZip
*/
isZip: function (str)
{
return /^\d{5}(-\d{4})?$/.test(str);
},
/**
* Convert an Number object to a formatted StringThe presence of whitespace in the DOM can make manipulation of the content * tree difficult in unforeseen ways.
*In Mozilla, all whitespace in the text content of the original document is * represented in the DOM (this does not include whitespace within tags). * This is needed internally so that the editor can preserve formatting of * documents and so that white-space: pre in CSS will work. * This means that: there will be some text nodes that contain only whitespace, and * some text nodes will have whitespace at the beginning or end.
** Whitespace is defined as one of the characters *
* "\t" TAB \u0009 * "\n" LF \u000A * "\r" CR \u000D * " " SPC \u0020 **
This does not use Javascript's "\s" because that includes non-breaking * spaces (and also some other characters).
* @singleton */ ASC.namespace('ASC.xmlUtils'); (function () { /** * @ignore * @private */ var is_all_ws = function (nod) { // Use ECMA-262 Edition 3 String and RegExp features return !(/[^\t\n\r ]/.test(nod.data)); }; /** * @ignore * @private */ var is_ignorable = function (nod) { return ( nod.nodeType == 8) || /*A comment node*/ ( (nod.nodeType == 3) && is_all_ws(nod) ); /* a text node, all ws*/ }; /** * @ignore * @private */ var node_before = function (sib) { while ((sib = sib.previousSibling)) { if (!is_ignorable(sib)) return sib; } return null; }; /** * @ignore * @private */ var node_after = function (sib) { while ((sib = sib.nextSibling)) { if (!is_ignorable(sib)) return sib; } return null; }; /** * @ignore * @private */ var last_child = function (par) { var res=par.lastChild; while (res) { if (!is_ignorable(res)) return res; res = res.previousSibling; } return null; }; /** * @ignore * @private */ var first_child = function (par) { var res=par.firstChild; while (res) { if (!is_ignorable(res)) return res; res = res.nextSibling; } return null; }; /** * @ignore * @private */ var data_of = function (txt) { var data = txt.data; // Use ECMA-262 Edition 3 String and RegExp features data = data.replace(/[\t\n\r ]+/g, " "); if (data.charAt(0) == " ") data = data.substring(1, data.length); if (data.charAt(data.length - 1) == " ") data = data.substring(0, data.length - 1); return data; }; /** * @ignore * @private * @param {Object} doc DomNode to serialize * @param {Object} appendTo Object to append the serialized XML to */ function _nodeToObject(doc, appendTo) { var xu = ASC.xmlUtils; var keyFunc = function (field) { return field.name; }; var ret = { attributes: new Ext.util.MixedCollection(false, keyFunc) }; ASC.forEach(doc.attributes, function (attr) { ret.attributes.add(attr.nodeName, attr.value); }); var node = xu.firstChild(doc); while(node) { var data = null; var firstChild = xu.firstChild(node); if (firstChild) { if (firstChild.nodeType === 3) { //TEXT_NODE data = xu.dataOf(firstChild); } else if (firstChild.nodeType === 4) { //CDATA_SECTION_NODE data = firstChild.nodeValue; } } setValue(ret, node.nodeName, { value: data, attributes: new Ext.util.MixedCollection(false, keyFunc) }); if (node.attributes.length > 0) { ASC.forEach(node.attributes, function (attr) { //ret.attributes.add(attr.nodeName, attr.value); ret[node.nodeName].attributes.add(attr.nodeName, attr.value); }); } if (firstChild && firstChild.nodeType === 1 /*ELEMENT_NODE*/) { _nodeToObject(node, ret); } node = xu.nodeAfter(node); } if (appendTo) { setValue(appendTo, doc.nodeName, ret); return appendTo; } return ret; } /** * @ignore * @private * For the nameed property in object, set the value. If a value * already exists and it is a string, convert the value to be an * array of values * @param {Object} obj * @param {String} name * @param {Object} value */ function setValue(obj, name, value) { var val = obj[name]; if(ASC.isArray(val)) { val.push(value); } else if (val) { obj[name] = [val, value]; } else { obj[name] = value; } } ASC.apply(ASC.xmlUtils, { /** * Determine whether a node's text content is entirely whitespace. * @param {Node} nod A node implementing the |CharacterData| interface (i.e. Text, Comment, or CDATASection node * @return {Boolean} Returns true if all of the text content of |nod| is whitespace, otherwise false. * @member ASC.xmlUtils * @method isAllWhiteSpace */ isAllWhiteSpace: is_all_ws, /** * Determine if a node should be ignored by the iterator functions. * * @param {Node} nod An object implementing the DOM1 Node interface. * @return {Boolean} Returns true if the node is: a Text node that is all whitespace * or a Comment node. * @method isIgnorable * @member ASC.xmlUtils */ isIgnorable: is_ignorable, /** * Version of previousSibling that skips nodes that are entirely * whitespace or comments.See {@link ASC.Element#addListener} for examples of how to use these options.
*/ addListener: function (el, eventName, handler, scope, options) { return EM.addListener(el, eventName, handler, scope, options); }, /** * Fires when the document is ready (before onload and before images are loaded). Can be * accessed shorthanded as ASC.onReady(). * @param {Function} fn The method the event invokes * @param {Object} scope (optional) An object that becomes the scope of the handler * @param {Boolean} options (optional) An object containing standard {@link #addListener} options */ onDocumentReady: function (fn, scope, options) { EM.onDocumentReady(fn, scope, options); }, /** * Fires when the user changes the active text size. Handler gets called with 2 params, the old size and the new size. * @param {Function} fn The method the event invokes * @param {Object} scope An object that becomes the scope of the handler * @param {Boolean} options */ onTextResize: function (fn, scope, options) { EM.onTextResize(fn, scope, options); }, /** * Fires when the window is resized and provides resize event buffering (50 milliseconds), passes new viewport width and height to handlers. * @param {Function} fn The method the event invokes * @param {Object} scope An object that becomes the scope of the handler * @param {Boolean} options */ onWindowResize: function (fn, scope, options) { EM.onWindowResize(fn, scope, options); }, /** * Removes an event handler from an element. The shorthand version {@link #un} is equivalent. Typically * you will use {@link ASC.Element#removeListener} directly on an Element in favor of calling this version.requires a CSS rule called .a-disabled
* @property DISABLE_CSS * @type String * @member ASC.Element * @static */ Ext.Element.DISABLE_CSS = (AC.disabledCSS || 'a-disabled'); /** * CSS class applied to hide an HTMLElement *requires a CSS rule called .x-hide-display
* @property VISIBILITY_CSS * @type String * @member ASC.Element * @static */ Ext.Element.VISIBILITY_CSS = (AC.visibilityCSS || 'x-hide-display'); Ext.override(Ext.Element, { /** * @ignore * @method _ext_original_setVisible */ _ext_original_setVisible: Ext.Element.prototype.setVisible, /** * Sets the visibility of the element (see details). If the visibilityMode is set to Element.DISPLAY, it will use * the display property to hide the element, else if it is set to Element.CLASS_NAME it will * add/remove the CSS class Element.VISIBILITY_CSS, otherwise it uses visibility. * The default is to hide and show using the visibility property. * @param {Boolean} visible Whether the element is visible * @param {Boolean/Object} [animate] Optional True for the default animation, or a standard Element animation config object * @return ASC.Element this */ setVisible: function (visible, animate) { //visible is optional default to true if (typeof visible === 'undefined') { visible = true; } if (this.visibilityMode !== Ext.Element.CSS_CLASS) { return this._ext_original_setVisible.apply(this, arguments); } if (!animate || !A) { this.switchClass(Ext.Element.VISIBILITY_CSS, !visible); } else { // closure for composites var dom = this.dom; //var visMode = this.visibilityMode; if (visible) { this.setOpacity(.01); this.switchClass(Ext.Element.VISIBILITY_CSS, false); } this.anim({opacity: { to: (visible?1:0) }}, this.preanim(arguments, 1), null, .35, 'easeIn', function () { if (!visible) { this.switchClass(Ext.Element.VISIBILITY_CSS, true); ASC.getEl(dom).setOpacity(1); } }); } return this; }, /** * Adds/Removes the specified classes from HTMLElement.based on the addClass param * @param {String} classStr The class to be added/removed from the element * @param {Boolean} addClass Flag to indicate if it should be added or removed */ switchClass: function (classStr, addClass) { if (addClass) { this.addClass(classStr); } else { this.removeClass(classStr); } return this; }, /** * Replace one class string with another * @param {String} find The class string to be removed from the element * @param {String} replace The class string to be added to the element * @param {Boolean} reverse Switch the order of the find and replace strings * el.replaceClassWith('open', 'closed', isOpen); */ replaceClassWith: function (find, replace, reverse) { if (typeof reverse !== 'boolean') { reverse = false; } this.removeClass(!reverse ? find : replace); this.addClass(!reverse ? replace : find); return this; }, /** * Return the value of the HTMLElement as an Integer * @param {Number/Object} [nanDefault] optional value to return if the string cannot be converted into a number * @param {String} [locale] optional Identify the language of Element's value * @type Number (Integer) * @return If value is NaN 0 is returned */ getInt: function (nanDefault, locale) { return UTIL.getInt(this.getValue(), nanDefault, locale); }, /** * Return the value of the HTMLElement as an Float * @param {Number/Object} [nanDefault] optional value to return if the string cannot be converted into a number * @param {String} [locale] optional Identify the language of Element's value * @type Number (Float) * @return If value is NaN 0 is returned */ getFloat: function (nanDefault, locale) { return UTIL.getFloat(this.getValue(), nanDefault, locale); }, /** * Compares the for the string value "true" and returns a boolean * @type Boolean */ getBool: function () { return UTIL.getBool(this.getValue()); }, /** * Retreive the value from the HTMLElement * @type String or String[] */ getValue: function () { var el = this.dom; //NOTE if this element is a select with multiple set to true this function //will return an array of the selected options if (UTIL.isHTMLElement(el, 'select')) { if (!el.multiple) { var idx = el.selectedIndex; return idx != -1 ? el.options[idx].value : ''; } else { var ret = []; for (var i=0; i* Requests made by this class are asynchronous, and will return immediately. No data from * the server will be available to the statement immediately following the request call. * To process returned data, use a callback in the request options object, or an event listener.
* @constructor
* @param {Object} config a configuration object.
*/
ASC.data.Connection = function (config)
{
Ext.apply(this, config);
this.addEvents(
/**
* @event beforerequest
* Fires before a network request is made to retrieve a data object.
* @param {Connection} conn This Connection object.
* @param {Object} options The options config object passed to the {@link #request} method.
*/
'beforerequest',
/**
* @event requestcomplete
* Fires if the request was successfully completed.
* @param {Connection} conn This Connection object.
* @param {Object} response The XHR object containing the response data.
* See The XMLHttpRequest Object
* for details.
* @param {Object} options The options config object passed to the {@link #request} method.
*/
'requestcomplete',
/**
* @event requestexception
* Fires if an error HTTP status was returned from the server.
* See HTTP Status Code Definitions
* for details of HTTP status codes.
* @param {Connection} conn This Connection object.
* @param {Object} response The XHR object containing the response data.
* See The XMLHttpRequest Object
* for details.
* @param {Object} options The options config object passed to the {@link #request} method.
*/
'requestexception'
);
ASC.data.Connection.superclass.constructor.call(this);
};
Ext.extend(ASC.data.Connection, Ext.util.Observable, {
/**
* @cfg {Boolean} autoAbort
* Whether a new request should abort any pending requests. (defaults to false)
*/
/**
* @cfg {String} method
* The default HTTP method to be used for requests
* Defaults to undefined; if not set but params are present a POST will be used otherwise a GET
*/
/**
* @cfg {Object} defaultHeaders
* (Optional) An objecting containing request headers which are added to each request made by this Connection
* Defaults to undefined
*/
/**
* @cfg {String} handleAsDefault
* Default return format of the Response (valid values are xml, json, text)
*/
/**
* @cfg {Boolean} disableCaching
* (Optional) When true a unique cache-buster param is appened to the Query String
* Defaults to true
*/
/**
* @cfg {Integer} timeout
* (Optional) The total length of time (in milliseconds) before a request is cancelled
* Defaults to 3000
*/
/**
* @cfg {String} url
* (Optional} The default URL to be used for the Request provided
* Defaults to undefined
*/
/**
* @cfg {Object} extraParams
* An object of additional parameters to be passed along with each request made by this Connection
*/
/**
* @property
* autoAbort Whether a new request should abort any pending requests. (defaults to false)
* @type Boolean
* @member ASC.data.Connection
*/
autoAbort: false,
/**
* @property
* method (Optional) The default HTTP method to be used for requests.
* Defaults to undefined; if not set but parms are present will use POST, otherwise GET
* @type String
*/
method: undefined,
/**
* @property
* defaultHeaders (Optional) An object containing request headers which are added to each request made by this Connection
* (defaults to undefined)
*/
defaultHeaders: undefined,
/**
* @property
* handleAsDefault Default return format from a sendRequest
* @type String
*/
handleAsDefault: 'text',
/**
* @property
* disableCaching (Optional) True to add a unique cache-buster param to GET requests. (defaults to true)
* @type Boolean
*/
disableCaching: true,
/**
* @property
* timeout (Optional) The timeout in milliseconds to be used for requests. (defaults to 30000)
* @type Integer
*/
timeout: 30000,
/**
* @property
* url (Optional) The default URL to be used for requests to the server. (defaults to undefined)
* @type String
*/
url: undefined,
/**
* @property
* extraParams (Optional) An object containing properties which are used as extra parameters to each request made by this object.
* Defaults to undefined
* @type Object
*/
extraParams: undefined,
/**
* @ignore
*/
abort: function ()
{
},
/**
* @ignore
*/
isLoading: function (connection)
{
if (typeof connection == 'object' && connection) {
return connection.isCallInProgress();
} else {
return false;
}
},
/**
*
Sends an HTTP request to a remote server.
*Important: Ajax server requests are asynchronous, and this call will * return before the response has been received. Process any returned data * in a callback function.
*To execute a callback function in the correct scope, use the scope option.
* @param {Object} options An object which may contain the following properties:The URL to
* which to send the request, or a function to call which returns a URL string. The scope (this reference) of the
* function is specified by the scope option. Defaults to configured URL.
*
The url config may be a function which returns the URL to use for the Ajax request. The scope
* (this reference) of the function is the scope option passed to the {@link #request} method.
True if the form object is a file upload (will be set automatically if the form was * configured with enctype "multipart/form-data").
*File uploads are not performed using normal "Ajax" techniques, that is they are not * performed using XMLHttpRequests. Instead the form is submitted in the standard manner with the * DOM <form> element temporarily modified to have its * target set to refer * to a dynamically generated, hidden <iframe> which is inserted into the document * but removed after the return data has been gathered.
*The server response is parsed by the browser to create the document for the IFRAME. If the * server is using JSON to send the return object, then the * Content-Type header * must be set to "text/html" in order to tell the browser to insert the text unchanged into the document body.
*The response text is retrieved from the document, and a fake XMLHttpRequest object * is created containing a responseText property in order to conform to the * requirements of event handlers and callbacks.
*Be aware that file upload packets are sent with the content type multipart/form * and some server technologies (notably JEE) may require some custom processing in order to * retrieve parameter names and parameter values from the packet content.
*The options object may also contain any other property which might be needed to perform * postprocessing in a callback because it is passed to callback functions.
* @return {Object} The Connection transaction object used to cancel the request. */ request: function (options) { var au = ASC.utils; if (this.fireEvent('beforerequest', this, options) !== false) { //Assign missing default values options = ASC.applyIf(options || {}, { timeout: this.timeout, disableCaching: this.disableCaching, handleAs: this.handleAsDefault }); var p = options.params; if (typeof p == 'function') { p = p.call(options.scope||window, options); } if (typeof p == 'string') { p = au.queryToObject(p); } var fp = {}; ASC.forEach(options.forms, function (form) { ASC.apply(fp, ASC.util.formToObject(form)); }); //This will overwrite any params found in the serialzed forms //with those passed in VIA the params collection ASC.apply(fp, p); p = ASC.util.objectToQuery(fp); delete fp; //Add any already escaped parameters to the params collection var ep = options.escapedParams; if (typeof ep == 'function') { ep = ep.call(options.scope||window, options); } if (typeof ep == 'object') { ep = au.objectToQuery(ep, false); } if (ep) { p = p ? (p + '&' + ep) : ep; } if (this.extraParams) { var extras = Ext.urlEncode(this.extraParams); p = p ? (p + '&' + extras) : extras; } var url = options.url || this.url; if(typeof url == 'function'){ url = url.call(options.scope||window, options); } /* if(options.form){ var form = Ext.getDom(options.form); url = url || form.action; //var enctype = form.getAttribute("enctype"); //if(options.isUpload || (enctype && enctype.toLowerCase() == 'multipart/form-data')){ // return this.doFormUpload(o, p, url); //} var f = Ext.lib.Ajax.serializeForm(form); p = p ? (p + '&' + f) : f; } */ var hs = options.headers; if (this.defaultHeaders) { hs = Ext.apply(hs || {}, this.defaultHeaders); if(!options.headers){ options.headers = hs; } } //Add an HTTP Header to indicate the expected response type of the ajax request options.headers = ASC.apply(options.headers || {}, { 'Handle-As': options.handleAs || this.handleAsDefault }); var cb = { success: this.handleResponse, failure: this.handleFailure, scope: this }; var method = options.method||this.method||(p ? 'POST' : 'GET'); if (typeof options.autoAbort == 'boolean') { // options gets top priority if (options.autoAbort) { this.abort(); } } else if (this.autoAbort !== false) { this.abort(); } /* if ((method == 'GET' || options.xmlData || options.jsonData) && p) { url += (url.indexOf('?') != -1 ? '&' : '?') + p; p = ''; } */ //Returns a connection object return ASC.lib.Ajax.request(method, url, cb, p, options); } else { Ext.callback(options.callback, options.scope, [options, null, null]); return null; } }, /** * @private * @nocode */ handleResponse: function (response) { var ioArgs = response.ioArgs; var options = ioArgs.options; //Add the relevant XMLHttpRequest object so caller has access to the Response headers, etc ioArgs.xhr = this.xhr(response); //this.transId = false; this.fireEvent('requestcomplete', this, response, ioArgs); Ext.callback(options.success, options.scope, [response, ioArgs]); Ext.callback(options.callback, options.scope, [response, true, ioArgs]); }, /** * @private * @ignore */ handleFailure: function (response) { var ioArgs = response.ioArgs; var options = ioArgs.options; //Add the relevant XMLHttpRequest object so caller has access to the Response headers, etc ioArgs.xhr = this.xhr(response); //this.transId = false; this.fireEvent('requestcomplete', this, response, ioArgs); Ext.callback(options.failure, options.scope, [response, ioArgs]); Ext.callback(options.callback, options.scope, [response, false, ioArgs]); }, //private xhr: function (response) { var hs = ''; if (response && response.getAllResponseHeaders) { hs = response.getAllResponseHeaders().split('\n'); } var _getValue = function (header) { if (header) { header = header.split(': '); var key = header.shift(); return { key: key, value: header.join(': ') }; } return null; }; var _headers = []; ASC.forEach(hs, function (header) { _headers.push(_getValue(header)); }); /** * @class ASC.data.ResponseHeaders */ var headers = { /** * Case-Insenstive lookup for a specifc HTTP Request Header * @param {String} header header key to look up * @return {String} * @method get * @member ASC.data.ResponseHeaders */ get: function (header) { var search = new RegExp('^' + header + '$', 'i'); for(var i=0; i<_headers.length; i++) { if (search.test(_headers[i].key)) { return _headers[i].value; } } return null; }, /** * Retrieve the entire Array of Response HTTP Headers * @return {Array} * @method getAll * @member ASC.data.ResponseHeaders */ getAll: function () { return _headers; } }; var err = ''; if (response.status < 200 || response.status >299) { err = response.status + ' ' + response.statusText; } return { headers: headers, statusText: response.statusText, status: response.status, error: (response.status !== 200 ? response.status + ' ' + response.statusText : ''), responseText: response.responseText }; } }); ASC.namespace('ASC.data.Ajax'); /** * Static class for handling all Ajax Requests * @class ASC.data.Ajax * @singleton * @extends ASC.data.Connection */ ASC.data.Ajax = new ASC.data.Connection({ /** * @property autoAbort * Whether a new request should abort any pending requests. (defaults to false) * @type Boolean */ autoAbort: false, /** * Serialize the passed form into a url encoded string * @param {String|HTMLElement} form * @return {String} */ serializeForm: function (form) { return ASC.util.formToQuery(form); } });/* * ASC JS Tookit * Copyright(c) 2010, Autodata Solutions * */ ASC.namespace('ASC.data.AjaxEngine'); (function () { var newRequestId = null; /** * Use a second closure to keep _requestId as a private variable only available * to the newRequestId method * @ignore */ (function () { var _requestId = 1; /** * Generate a unique identifer for an ajax request * @ignore * @private * @static */ newRequestId = function () { return 'aereq-' + (_requestId++); }; })(); /** * @class ASC.data.AjaxEngine * This class is used to send Ajax requests * @extends Ext.util.Observable */ /** * @param {Object} cfg * @constructor * @member ASC.data.AjaxEngine */ ASC.data.AjaxEngine = function (cfg) { /** * @cfg {String} method * The default HTTP method to be used for requests * Defaults to undefined; if not set but params are present a POST will be used otherwise a GET * @member ASC.data.AjaxEngine */ /** * @cfg {Object} defaultHeaders * (Optional) An objecting containing request headers which are added to each request made by this Connection * Defaults to undefined * @member ASC.data.AjaxEngine */ /** * @cfg {String} handleAsDefault * Default return format of the Response (valid values are xml, json, text) * @member ASC.data.AjaxEngine */ /** * @cfg {Boolean} disableCaching * (Optional) When true a unique cache-buster param is appened to the Query String * Defaults to true * @member ASC.data.AjaxEngine */ /** * @cfg {Integer} timeout * (Optional) The total length of time (in milliseconds) before a request is cancelled * Defaults to 3000 * @member ASC.data.AjaxEngine */ if (typeof cfg === 'undefined') { cfg = {}; } this.addEvents({ /** * @event engineComplete * An event that is fired when the Ajax Engine has finished processing a sendRequest * @member ASC.data.AjaxEngine * @param {Object} reserved Rserved for future use * @param {Object} ioArgs Object containing the parameters and options used for the request * @member ASC.data.AjaxEngine */ engineComplete: true, /** * @event failure * An event that is fired when a sendRequest did not complete successfully * @member ASC.data.AjaxEngine * @param {Object} errorResult Object containing the error and the result status * @param {Object} ioArgs Object containing the parameters and options used for the request * @member ASC.data.AjaxEngine */ failure: true }); this.initialConfig = cfg; ASC.apply(this, cfg); if(typeof ASC.addOnUnLoad !== 'undefined') { var me = this; ASC.addOnUnload(function () { me.cleanup(); }); } this.ajaxElements = []; this.ajaxObjects = []; this.requestURLS = []; this.activeRequests = []; ASC.data.AjaxEngine.superclass.constructor.apply(this); }; ASC.extend(ASC.data.AjaxEngine, Ext.util.Observable, { /** * @deprecated * @property * @private * @type Array * @member ASC.data.AjaxEngine */ ajaxElements: null, /** * @property * @private * @type Array * @member ASC.data.AjaxEngine */ ajaxObjects: null, /** * @property * @private * @type Array * @member ASC.data.AjaxEngine */ requestURLS: null, /** * @property * @private * @type Array * @member ASC.data.AjaxEngine */ activeRequests: null, /** * Default return format from a sendRequest * @property * @type String * @member ASC.data.AjaxEngine */ handleAsDefault: 'xml', /** * disableCache (Optional) True to add a unique cache-buster param to GET requests. (defaults to true) * @property * @type Boolean * @member ASC.data.AjaxEngine */ disableCache: true, /** * (Optional) An object containing request headers which are added to each request made by this object. * Defaults to undefined * @property * @member ASC.data.AjaxEngine */ defaultHeaders: undefined, /** * Associate a URL with an unique id. * Associating the URL with an ID makes it easier to update the URL * in one place instead of everywhere a sendRequest is issued to that URL * @param {String} id Unique identifer for a URL * @param {String} url URL * example *
* myAjaxEngine.registerRequest('SAVE', {@link ASC.cfg#getContextPath ASC.cfg.getContextPath()} + '/ajax/save.do');
* MyAjaxEngine.sendRequest('SAVE', {
params: {
id: 1,
name: 'John Smith'
},
requestComplete: {
fn: function (reserved, ioArgs) {
},
scope: obj
},
myDataForLater: {
acode: '1234567890abc'
}
}
* ['label1', 'value1', 'label2', 'value2', etc]
*
* ['label1', 'value1', 'label2', 'value2', etc]
*