var AjaxTCR = {};
AjaxTCR.comm = {
/* readyState constants as defined by w3c */
UNSENT : 0,
OPEN : 1,
SENT : 2,
LOADING : 3,
DONE : 4,
/* Default Request Content Type */
DEFAULT_CONTENT_TYPE : "application/x-www-form-urlencoded",
/* Default timeout in ms */
DEFAULT_TIMEOUT : false,
/* Default number of retries if retrying requests */
DEFAULT_RETRIES : false,
/* Default time to revisit our progress callback if monitoring progress */
DEFAULT_PROGRESS_INTERVAL : 1000,
DEFAULT_REQUEST_SIGNATURE : "X-Signature",
/* the request id counter */
_requestID : 0,
/* request counter shows outstanding requests */
_requestsOutstanding : 0,
/* the statuses for possible network errors */
/* 3507 = library error flag */
_networkErrorStatus : new Array(0, 408, 504, 3507, 12002, 12007, 12029, 12030, 12031, 12152),
/***************************************** GETTERS/SETTERS ***********************************/
setDefault : function(option, value){
AjaxTCR.comm[option] = value;
},
getDefault : function(option){
return AjaxTCR.comm[option]
},
/*
* _createXHR - private wrapper function from chapter 3
*/
_createXHR : function() {
try { return new XMLHttpRequest(); } catch(e) {}
try { return new ActiveXObject("Msxml2.XMLHTTP.6.0"); } catch (e) {}
try { return new ActiveXObject("Msxml2.XMLHTTP.3.0"); } catch (e) {}
try { return new ActiveXObject("Msxml2.XMLHTTP"); } catch (e) {}
try { return new ActiveXObject("Microsoft.XMLHTTP"); } catch (e) {}
return null;
},
/*
* sendRequest(url, object of communications options) - public method to create an Ajax request
*
*/
sendRequest : function (url,options) {
var request = new Object();
/* increment our requestId number */
request.requestID = ++AjaxTCR.comm._requestID;
/* basic communication defaults */
request.method = "GET";
request.async = true;
request.preventCache = false;
request.requestContentType = AjaxTCR.comm.DEFAULT_CONTENT_TYPE;
request.requestContentTransferEncoding = "";
request.payload = "";
/* header management */
request.headers = new Array();
request.supressHeaders = false;
/* standard callbacks */
request.onSuccess = function(){};
request.onFail = function(){};
/* callbacks associated with readyState changes */
request.onCreate = null;
request.onOpen = null;
request.onSent = null;
request.onLoading = null;
request.onReceived = null;
/* communication status flags */
request.abort = false;
request.inProgress = true;
request.received = false;
/* progress management */
request.showProgress = false;
request.progressInterval = AjaxTCR.comm.DEFAULT_PROGRESS_INTERVAL;
request.onProgress = function (){};
request.progressTimerID = null;
/* timeout parameters */
request.timespent = 0;
request.timeout = AjaxTCR.comm.DEFAULT_TIMEOUT;
request.onTimeout = function(){};
request.timeoutTimerID = null;
/* retry parameters */
request.retries = AjaxTCR.comm.DEFAULT_RETRIES;
request.retryCount = 1;
request.onRetry = function (){};
/* sequencing */
request.inQueue = false;
request.responseQueueID = 0;
request.enforceOrder = false;
/* cache management */
request.cacheResponse = false;
request.fromCache = false;
/* Prefetch */
request.onPrefetch = function(){};
request.isPrefetch = false;
/* payload serialization */
request.serializeForm = null;
request.hasFile = false;
/* output handling */
request.outputTarget = null;
request.useRaw = true;
/* transmission type */
request.oneway = false;
/* authentication */
request.username = null;
request.password = null;
/* security */
request.requestSignature = AjaxTCR.comm.DEFAULT_REQUEST_SIGNATURE;
request.signRequest = null;
request.signedResponse = false;
/* apply options defined by user */
for (option in options)
request[option] = options[option];
if (request.isPrefetch)
request.cacheResponse = true;
/* Serialize the given form if request.serialize is set */
if (request.serializeForm)
{
/* Serialize given form */
var newPayload = AjaxTCR.data.serializeForm(request.serializeForm,request.requestContentType);
/* check to see if we have a fileupload situation */
if (typeof(newPayload) == "string" && newPayload == "fileupload")
request.hasFile = true;
else
{
/* Check to see if payload exists */
if (request.payload)
{
/* If payload is an object, use serializeObject otherwise append to end of the new payload */
if (typeof(request.payload) == "object")
newPayload = AjaxTCR.data.serializeObject(newPayload, request.payload, request.requestContentType);
else if (request.requestContentType == AjaxTCR.comm.DEFAULT_CONTENT_TYPE)
newPayload += "&" + request.payload;
}
request.payload = newPayload;
/* Get all values into string format */
if (request.requestContentType == "application/json")
request.payload = AjaxTCR.data.encodeJSON(request.payload);
else if (request.requestContentType == "text/xml")
request.payload = AjaxTCR.data.serializeXML(request.payload);
/* Encode it in base64 if that's set */
if (request.requestContentTransferEncoding == "base64")
request.payload = AjaxTCR.data.encode64(request.payload);
}
}
/* If there is a file, we need to handle differently */
if (request.hasFile)
AjaxTCR.comm._sendFormWithFile(request);
else
{
/* address payload depending on method */
if (request.method.toUpperCase() == "GET")
request.url = url + "?" + request.payload;
else
request.url = url;
if (request.method.toUpperCase() == "POST")
request.postBody = request.payload;
else
request.postBody = null;
/* Add a queueID if necessary */
if (request.enforceOrder)
request.responseQueueID = AjaxTCR.comm.queue._responseQueue.maxID++;
var cachedResponse = null;
/* Check if the item is in the cache first */
if (request.cacheResponse)
{
/* Check to see if we have a key for our cache */
if (request.cacheKey == undefined)
request.cacheKey = request.url;
cachedResponse = AjaxTCR.comm.cache.get(request.cacheKey);
if (cachedResponse)
AjaxTCR.comm.cache._handleCacheResponse(request, cachedResponse);
}
/* invoke the request */
if (!cachedResponse)
AjaxTCR.comm._makeRequest(request);
}
/* return object for local control */
return request;
},
/*
* abortRequest(requestObj)
*
* Public method that will abort any passed request object and clean up
* any timers for showing requqest state
*
*/
abortRequest : function(request) {
/* set the abort flag */
request.abort = true;
/* clear inProgress flag */
request.inProgress = false;
/* abort the request */
request.xhr.abort();
/* decrement outstand request count */
AjaxTCR.comm._requestsOutstanding--;
/* clear any timeout timers */
clearTimeout(request.timeoutTimerID);
request.timeoutTimerID = null;
/* stop showing progress */
if (request.progressTimerID)
{
clearTimeout(request.progressTimerID);
request.progressTimerID = null;
}
/* Remove Progress Indicators */
if (request.statusIndicator)
AjaxTCR.comm._removeProgressStatus(request.statusIndicator);
},
/*
* _makeRequest(requestObj)
*
* Private method that actually creates XHR, binds callbacks and sends request
*
*/
_makeRequest : function (request) {
/* make basic XHR */
request.xhr = AjaxTCR.comm._createXHR();
if (!request.xhr)
{ /* raise exception */
return;
}
/* Increment total requests */
AjaxTCR.comm.stats._commResults.totalRequests++;
/* Display status and start Progress Callback */
if (!request.oneway)
AjaxTCR.comm._initSend(request);
/* Call back for ready state 0 if set */
if (request.onCreate)
request.onCreate(request);
/* open the request */
request.xhr.open(request.method, request.url, request.async, request.username, request.password);
/* clear an abort flag in case this is a retry */
request.abort = false;
/* set headers indicating we did this with Ajax and what
our transaction id is */
if (!request.supressHeaders)
{
request.xhr.setRequestHeader("X-Requested-By","XHR");
request.xhr.setRequestHeader("X-Request-Id",request.requestID);
}
/* set header(s) for POST */
if (request.method.toUpperCase() == "POST")
{
request.xhr.setRequestHeader("Content-Type", request.requestContentType);
if (request.requestContentTransferEncoding != "")
request.xhr.setRequestHeader("Content-Transfer-Encoding", request.requestContentTransferEncoding);
}
/* Prevent Caching if set */
if (request.preventCache)
request.xhr.setRequestHeader("If-Modified-Since", "Wed, 15 Nov 1995 04:58:08 GMT");
/* set user defined headers */
request.headerObj = {};
for (var i=0; i');
else
{
var iframe = document.createElement("iframe");
iframe.id = iframeID;
iframe.name = iframeID;
}
iframe.style.height = "1px";
iframe.style.visibility = "hidden";
document.body.appendChild(iframe);
var callback = function(){AjaxTCR.comm._handleIFrameResponse(request, iframe);};
/* IE does not recognize iframe.onload */
if(window.attachEvent)
iframe.attachEvent('onload', callback);
else
iframe.addEventListener('load', callback, false);
request.serializeForm.target = iframe.id;
request.serializeForm.submit();
},
_handleIFrameResponse : function(response, iframe){
response.xhr = {};
response.xhr.responseText = null;
response.xhr.status = 200;
if (iframe.contentWindow.document.body)
response.xhr.responseText = iframe.contentWindow.document.body.innerHTML;
if (iframe.contentWindow.document.XMLDocument)
response.xhr.responseXML = iframe.contentWindow.document.XMLDocument;
else
response.xhr.responseXML = iframe.contentWindow.document;
AjaxTCR.comm._handleResponse(response);
/* This line causes the page to not stop spinning */
//document.body.removeChild(iframe);
},
/*
* timeoutRequest(requestObject)
*
* Private method called if timeout set after 5000 ms or a user defined time.
* Uses public abortRequest method to clean up timers and invokes any special timeout
* callback that may be defined.
*
*/
_timeoutRequest : function(request) {
/* make sure it is a proper time to abort */
if (request.xhr.readyState != AjaxTCR.comm.DONE &&
request.xhr.readyState != AjaxTCR.comm.UNSENT)
{
/* abort the request */
AjaxTCR.comm.abortRequest(request);
/* Increment total timeouts */
AjaxTCR.comm.stats._commResults.totalTimeouts++;
/* do we need to retry? */
if (request.retries)
AjaxTCR.comm._retryRequest(request);
else
{
if (request.statusIndicator)
AjaxTCR.comm._setErrorStatus(request.statusIndicator);
request.onTimeout(request); /* invoke any timeout callback */
AjaxTCR.comm.queue._checkRequestQueue(request);
}
}
},
/*
* progressRequest(requestObject)
*
* Private method called each second if showProgress is set.
* Updates public timespent variable and invokes any special progress
* callback that may be defined.
*
*/
_progressRequest: function(request){
if (!request.abort && !request.received)
{
request.timespent = Math.round((request.timespent + (parseInt(request.progressInterval) / 1000)) * 1000) / 1000;
request.onProgress(request);
/* Yes it is ridiculous that we have to clear the timeout that we are in a callback for, but such is IE */
clearTimeout(request.progressTimerID);
request.progressTimerID = null;
request.progressTimerID = window.setTimeout( function(){AjaxTCR.comm._progressRequest(request);}, request.progressInterval);
}
},
_retryRequest : function (request) {
/* up our retry count */
request.retryCount++;
/* make sure we aren't done retrying */
if (request.retryCount <= request.retries)
{
if (request.statusIndicator)
AjaxTCR.comm._setRetryStatus(request.statusIndicator);
/* Increment total retries */
AjaxTCR.comm.stats._commResults.totalRetries++;
AjaxTCR.comm._makeRequest(request);
request.onRetry(request);
}
else /* stop trying and perform callback */
{
if (request.statusIndicator)
AjaxTCR.comm._setErrorStatus(request.statusIndicator);
request.onTimeout(request);
AjaxTCR.comm.queue._checkRequestQueue(request);
}
},
/*
* handleResponse(requestObject)
*
* Private method called after response comes back no matter what method of communication
*/
_handleResponse : function(response){
/* Record end time of request */
response.endTime = (new Date()).getTime();
/* set a received flag to ensure you don't perform a progress callback after received. */
response.received = true;
/* clear any timeouts */
if (response.timeoutTimerID)
{
clearTimeout(response.timeoutTimerID);
response.timeoutTimerID = null;
}
/* clear our progress indicator */
if (response.progressTimerID)
{
clearTimeout(response.progressTimerID);
response.progressTimerID = null;
}
/* decrement outstand request count */
AjaxTCR.comm._requestsOutstanding--;
/* Cache Response */
if (!response.fromCache && response.cacheResponse && response.xhr.status == 200 && !response.fail)
AjaxTCR.comm.cache.add(response.cacheKey, response.xhr.responseText);
/* Remove Progress Indicators */
if (response.statusIndicator)
{
AjaxTCR.comm._removeProgressStatus(response.statusIndicator);
AjaxTCR.comm._removeRetryStatus(response.statusIndicator);
}
/* Check to see if we need to wait for another request */
/* Otherwise just handle callbacks */
if (response.enforceOrder)
AjaxTCR.comm.queue._handleQueue(response);
else
AjaxTCR.comm._handleCallbacks(response);
/* If Request Queue is being used, send next request */
AjaxTCR.comm.queue._checkRequestQueue(response);
},
/*
* handleCallbacks(requestObject)
*
* Private method called after response comes in to run numerous callbacks.
* Checks http and response status to see which callbacks should be employed.
*/
_handleCallbacks : function(response) {
/* Danger: Firefox problems so we try-catch here */
try { response.httpStatus = response.xhr.status; response.httpStatusText = response.xhr.statusText} catch(e) {response.httpStatus=3507;response.httpStatusText="Unknown Loss";}
/* clear inProgress flag */
response.inProgress = false;
/* Check if user wants to automatically consume output */
if (response.outputTarget && response.useRaw)
{
var outputTarget = response.outputTarget;
if (outputTarget && typeof(outputTarget) == "string")
outputTarget = document.getElementById(outputTarget);
if (response.fail)
outputTarget.innerHTML = response.fail;
else
outputTarget.innerHTML = response.xhr.responseText;
}
/* check to see if the user wants a specific callback for this request */
if (response["on" + response.httpStatus])
response["on" + response.httpStatus](response);
/* see if it is one of our retry statuses */
if (response.retries)
{
for (var i=0;i= AjaxTCR.comm.cache._cacheOptions.size)
{
var algorithm = AjaxTCR.comm.cache._cacheOptions.algorithm;
//we need to remove an item before adding another one.
if ( algorithm == "FIFO")
AjaxTCR.comm.cache._cache.splice(0, 1);
else if (algorithm == "LFU")
{
var removeIndex = -1;
for (var i=0;i AjaxTCR.comm.cache._cache[i].totalAccessed)
removeIndex = i;
}
AjaxTCR.comm.cache._cache.splice(removeIndex,1);
}
else if (algorithm == "LRU")
{
var removeIndex = -1;
for (var i=0;i AjaxTCR.comm.cache._cache[i].lastAccessed)
removeIndex = i;
}
AjaxTCR.comm.cache._cache.splice(removeIndex,1);
}
}
var item = AjaxTCR.comm.cache._createCacheItem(key, val);
AjaxTCR.comm.cache._cache.push(item);
},
/**
* clear - Public method that resets the caches
*
*/
clear : function(){
AjaxTCR.comm.cache._cache = new Array();
},
/*
* get
*
* Public method to fetch an object based on the key
*
*/
get: function(key){
var cacheObject = null;
/* Search for item */
for (var i=0;i timeAdded)
{
AjaxTCR.comm.cache.remove(item.key);
cacheObject = null;
}
}
}
if (cacheObject)
return cacheObject.value;
else
return null;
},
getAll : function(){
return AjaxTCR.comm.cache._cache;
},
getSize : function(){
return AjaxTCR.comm.cache._cache.length;
},
/*
* remove
*
* Public method to remove an item from the cache based on the key
*
*/
remove : function(key){
for (var i=0;i= AjaxTCR.comm.queue.requestQueueConcurrentRequests)
{
var request = {url: url, options: options};
if (options.priority == "next")
AjaxTCR.comm.queue._requestQueue.unshift(request);
else if (priority && priority == "faster")
{
var set = false;
for (var i=0;i 0)
{
var nextRequest = AjaxTCR.comm.queue._requestQueue.shift();
AjaxTCR.comm.sendRequest(nextRequest.url, nextRequest.options);
}
},
/*
* handleQueue(requestObject)
*
* Private method called after response comes in if request is in queue.
* Adds response to queue and then calls callbacks for any that are able to move forward
*/
_handleQueue: function(response){
/* add response into queue */
AjaxTCR.comm.queue._responseQueue.queue[response.responseQueueID] = response;
/* loop thru queue handling any received requests up to current point */
while (AjaxTCR.comm.queue._responseQueue.queue[AjaxTCR.comm.queue._responseQueue.currentIndex] != undefined)
{
AjaxTCR.comm._handleCallbacks(AjaxTCR.comm.queue._responseQueue.queue[AjaxTCR.comm.queue._responseQueue.currentIndex]);
AjaxTCR.comm.queue._responseQueue.currentIndex++;
}
}
};
/************************************* AjaxTCR.comm.stats *****************************/
AjaxTCR.comm.stats = {
/* Collect data across all requests */
_commResults : {
totalRequests : 0,
totalTimeouts : 0,
totalRetries : 0,
totalSuccess : 0,
totalFails : 0,
requestFails : new Array()},
collect : function (url) {
var sendConnectionStats = function(){
var results = AjaxTCR.comm.stats.get();
if (results.totalRequests > 0)
{
var payload = AjaxTCR.data.encodeJSON(results);
AjaxTCR.comm.sendRequest(url, {method:"POST",payload:payload,requestContentType:"application/json",oneway:true});
}
};
if(window.attachEvent)
window.attachEvent('onunload', sendConnectionStats);
else
window.addEventListener('unload', sendConnectionStats, false);
},
get : function() {
return AjaxTCR.comm.stats._commResults;
},
/**
* getRequestCount - Public method acting as simple getter for the count of requests currently out
*
* @return - the number of outstanding requests
*/
getRequestCount : function(type) {
if (type == "queued")
return AjaxTCR.comm.queue.getSize();
else if (type == "active")
return AjaxTCR.comm._requestsOutstanding;
else
return (AjaxTCR.comm.queue.getSize() + AjaxTCR.comm._requestsOutstanding);
}
};
/************************************* AjaxTCR.comm.cookie *****************************/
AjaxTCR.comm.cookie = {
get : function(name){
var fullname = name + "=";
var cookies = document.cookie.split(';');
for(var i=0;i < cookies.length;i++)
{
var cookieNV = cookies[i];
while (cookieNV.charAt(0)==' ')
cookieNV = cookieNV.substring(1);
if (cookieNV.indexOf(fullname) == 0)
return cookieNV.substring(fullname.length);
}
return null;
}
};
AjaxTCR.data = {
/*
* encodeValue(str)
*
* Public method to encode passed string values to make the URL safe.
* Strictly encodes to x-www-urlencoded format vs. native methods.
*/
encodeValue : function(val) {
var encodedVal;
if (!encodeURIComponent)
{
encodedVal = escape(val);
/* fix the omissions */
encodedVal = encodedVal.replace(/@/g, '%40');
encodedVal = encodedVal.replace(/\//g, '%2F');
encodedVal = encodedVal.replace(/\+/g, '%2B');
}
else
{
encodedVal = encodeURIComponent(val);
/* fix the omissions */
encodedVal = encodedVal.replace(/~/g, '%7E');
encodedVal = encodedVal.replace(/!/g, '%21');
encodedVal = encodedVal.replace(/\(/g, '%28');
encodedVal = encodedVal.replace(/\)/g, '%29');
encodedVal = encodedVal.replace(/'/g, '%27');
}
/* clean up the spaces and return */
return encodedVal.replace(/\%20/g,'+');
} ,
/*
* encodeAsHTML(str)
*
* Public method to convert tag characters to < and > and change \n to
*/
encodeAsHTML : function(str) {
var convertedString = str.replace(/<([^>]*)>/g, "<$1>")
convertedString = convertedString.replace(/\n/g, "
");
return convertedString;
},
/*
* encode64(str)
*
* Public method to encode passed string values into base64.
*/
encode64 : function(inputStr)
{
var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
var outputStr = "";
var i = 0;
while (i> 2;
var enc2 = ((byte1 & 3) << 4) | (byte2 >> 4);
var enc3, enc4;
if (isNaN(byte2))
enc3 = enc4 = 64;
else
{
enc3 = ((byte2 & 15) << 2) | (byte3 >> 6);
if (isNaN(byte3))
enc4 = 64;
else
enc4 = byte3 & 63;
}
outputStr += b64.charAt(enc1) + b64.charAt(enc2) + b64.charAt(enc3) + b64.charAt(enc4);
}
return outputStr;
},
/*
* decode64(str)
*
* Public method to decode passed string values from base64.
*/
decode64 : function(inputStr)
{
var b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
var outputStr = "";
var i = 0;
inputStr = inputStr.replace(/[^A-Za-z0-9\+\/\=]/g, "");
while (i> 4);
var byte2 = ((dec2 & 15) << 4) | (dec3 >> 2);
var byte3 = ((dec3 & 3) << 6) | dec4;
outputStr += String.fromCharCode(byte1);
if (dec3 != 64)
outputStr += String.fromCharCode(byte2);
if (dec4 != 64)
outputStr += String.fromCharCode(byte3);
}
return outputStr;
},
/*
* serializeForm(form, encoding, trigger, evt)
*
* Public method to create a serialized payload based on the contents of a form and the specified encoding value.
* trigger and evt are optional and used to firm up the accuracy between what the browser would send and what we send.
*/
serializeForm : function(form, encoding, trigger, evt) {
if (typeof(form) == "string")
{
var formObject = document.forms[form];
if (formObject == null)
formObject = document.getElementById(form);
form = formObject;
}
var x=0,y=0;
if (trigger && trigger.type == "image" && trigger.name)
{
if (window.event)
{
x = window.event.offsetX;
y = window.event.offsetY;
}
else if (evt.target)
{
var coords = {x: 0, y: 0 };
var elmt = trigger;
while (elmt)
{
coords.x += elmt.offsetLeft;
coords.y += elmt.offsetTop;
elmt = elmt.offsetParent;
}
x = evt.clientX + window.scrollX - coords.x - 1 ;
y = evt.clientY + window.scrollY - coords.y - 1;
}
}
var formValues = AjaxTCR.data._beginEncode(encoding);
for (var i =0; i < form.elements.length; i++)
{
var currentField = form.elements[i];
var fieldName = currentField.name;
var fieldType = currentField.type;
/* Disabled and unnamed fields are not sent by browsers so ignore them */
if ((!currentField.disabled) && fieldName)
{
switch (fieldType)
{
case "text":
case "password":
case "hidden":
case "textarea": formValues = AjaxTCR.data._encode(formValues, fieldName, currentField.value, encoding);
break;
case "radio":
case "checkbox": if (currentField.checked)
formValues = AjaxTCR.data._encode(formValues, fieldName, currentField.value, encoding);
break;
case 'select-one':
case 'select-multiple': for (var j=0; j< currentField.options.length; j++)
if (currentField.options[j].selected)
{
formValues = AjaxTCR.data._encode(formValues, fieldName, (currentField.options[j].value) ? currentField.options[j].value : currentField.options[j].text , encoding);
}
break;
case "file": if (currentField.value)
return "fileupload";
else
formValues = AjaxTCR.data._encode(formValues, fieldName, currentField.value, encoding);
break;
case "submit": if (currentField == trigger)
formValues = AjaxTCR.data._encode(formValues, fieldName, currentField.value, encoding);
break;
default: continue; /* everything else like fieldset you don't want */
}
}
}
if (trigger && trigger.type == "image" && trigger.name)
{
/* this is where we need to insert the trigger image information */
formValues = AjaxTCR.data._encode(formValues, trigger.name + ".x", x, encoding);
formValues = AjaxTCR.data._encode(formValues, trigger.name + ".y", y, encoding);
formValues = AjaxTCR.data._encode(formValues, trigger.name, trigger.value, encoding);
}
/* Clean up payload string */
formValues = AjaxTCR.data._completeEncoding(formValues, encoding);
return formValues;
},
/*
* serializeObject(payload, obj, encoding)
*
* Public method to create/modify a serialized object based on an object
* payload is current object that will be appended to.
* obj is the object to add to the payload
* encoding is the encoding method
*/
serializeObject : function(payload, obj, encoding){
/* Take care of any necessary bits if payload isn't empty */
payload = AjaxTCR.data._continueEncoding(payload, encoding);
/* encode each value in the object */
for (var key in obj)
payload = AjaxTCR.data._encode(payload, key, obj[key], encoding);
/* Clean up payload string */
payload = AjaxTCR.data._completeEncoding(payload, encoding);
return payload;
},
/*
* serializeObject(payload, fieldName, fieldValue encoding)
*
* private method to encode one name/value pair and add it to a payload.
* payload is current object that will be appended to. It can be null.
* fieldName and fieldValue are the name/value pair.
* encoding is the encoding method
*/
_encode : function(payload, fieldName, fieldValue, encoding){
switch(encoding)
{
case "application/json":
payload[fieldName] = fieldValue;
break;
case "application/x-www-form-urlencoded":
payload+=AjaxTCR.data.encodeValue(fieldName)+"="+AjaxTCR.data.encodeValue(fieldValue)+"&"
break;
case "text/plain":
payload+=fieldName.replace(/,/g, "%2C") + "=" + fieldValue.replace(/,/g, "%2C") +","
break;
case "text/xml":
var node = payload.createElement(fieldName);
node.appendChild(payload.createTextNode(fieldValue));
payload.lastChild.appendChild(node);
break;
}
return payload;
},
/*
* beginEncode(encoding)
*
* private method to create the base for the encoding object
*/
_beginEncode : function(encoding){
switch(encoding)
{
case "application/json":
if (payload == null)
payload = {};
break;
case "application/x-www-form-urlencoded":
if (payload == null)
payload = "";
break;
case "text/plain":
if (payload == null)
payload = "";
break;
case "text/xml":
if (payload == null)
{
var payload = AjaxTCR.data._createXMLDocument();
if (window.navigator.userAgent.indexOf('Opera') == -1)
{
var xmlStmt = payload.createProcessingInstruction("xml"," version=\"1.0\" encoding=\"UTF-8\" ");
payload.appendChild(xmlStmt);
}
var root = payload.createElement("payload");
payload.appendChild(root);
}
break;
}
return payload;
},
/*
* completeEncoding(payload, encoding)
*
* private method to clean up payload string when finished encoding.
*/
_completeEncoding : function (payload, encoding ){
/* Trim off the end & but avoid edge case problems with an empty form */
if ((encoding == "application/x-www-form-urlencoded" || encoding == "text/plain") && payload.length > 0)
payload = payload.substring(0,payload.length-1);
return payload;
},
/*
* continueEncoding(payload, encoding)
*
* private method to get payload ready to be appended to.
*/
_continueEncoding : function(payload, encoding){
if (payload != "")
{
if (encoding == "application/x-www-form-urlencoded")
payload += "&";
else if (encoding == "text/plain")
payload += ",";
}
return payload;
},
/*
* createXMLDocument()
*
* Finds the best native or ActiveX object to use for an XML Document
*/
_createXMLDocument : function(){
var xmlDoc = null;
if (window.ActiveXObject)
{
var versions = ["Msxml2.DOMDocument.6.0", "Msxml2.DOMDocument.3.0", "MSXML2.DOMDocument", "MSXML.DOMDocument", "Microsoft.XMLDOM"];
for (var i=0;i 1 && jsonString.substring(0,2) == "/*")
jsonString = jsonString.substring(2,jsonString.lastIndexOf("*/"));
if (/^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/.
test(jsonString)) {
try {
j = eval('(' + jsonString + ')');
} catch (e) {
throw new SyntaxError('parseJSON');
}
} else {
throw new SyntaxError('parseJSON');
}
return j;
},
encodeJSON : function(o){
var useHasOwn = {}.hasOwnProperty ? true : false;
var pad = function(n) {
return n < 10 ? '0' + n : n;
};
var m = {
'\b': '\\b',
'\t': '\\t',
'\n': '\\n',
'\f': '\\f',
'\r': '\\r',
'"' : '\\"',
'\\': '\\\\'
};
if(typeof o == 'undefined' || o === null)
return 'null';
else if(o instanceof Array)
{
var a = ['['], b, i, l = o.length, v;
for (i = 0; i < l; i += 1) {
v = o[i];
switch (typeof v) {
case 'undefined':
case 'function':
case 'unknown':
break;
default:
if (b) {
a.push(',');
}
a.push(v === null ? "null" : AjaxTCR.data.encodeJSON(v));
b = true;
}
}
a.push(']');
return a.join('');
}
else if(o instanceof Date)
{
return '"' + o.getFullYear() + '-' +
pad(o.getMonth() + 1) + '-' +
pad(o.getDate()) + 'T' +
pad(o.getHours()) + ':' +
pad(o.getMinutes()) + ':' +
pad(o.getSeconds()) + '"';
}
else if(typeof o == 'string')
{
var s = o;
if (/["\\\x00-\x1f]/.test(s))
{
return '"' + s.replace(/([\x00-\x1f\\"])/g, function(a, b)
{
var c = m[b];
if(c){
return c;
}
c = b.charCodeAt();
return '\\u00' +
Math.floor(c / 16).toString(16) +
(c % 16).toString(16);
}) + '"';
}
return '"' + s + '"';
}
else if(typeof o == 'number')
{
return isFinite(o) ? String(o) : "null";
}
else if(typeof o == 'boolean')
{
return String(o);
}
else
{
var a = ['{'], b, i, v;
for (var i in o) {
if(!useHasOwn || o.hasOwnProperty(i)) {
v = o[i];
switch (typeof v) {
case 'undefined':
case 'function':
case 'unknown':
break;
default:
if(b)
a.push(',');
a.push(AjaxTCR.data.encodeJSON(i), ':', v === null ? "null" : AjaxTCR.data.encodeJSON(v));
b = true;
}
}
}
a.push('}');
return a.join('');
}
},
/*
* encodeMD5(string)
*
* public method to get md5 encode a string
* Based on Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* See http://pajhome.org.uk/crypt/md5 for more info.
*/
encodeMD5 : function(str){
var hexcase = 0; /* hex output format. 0 - lowercase; 1 - uppercase */
var b64pad = ""; /* base-64 pad character. "=" for strict RFC compliance */
var chrsz = 8; /* bits per input character. 8 - ASCII; 16 - Unicode */
var len = str.length * chrsz;
var x = Array();
var mask = (1 << chrsz) - 1;
for(var i = 0; i < len; i += chrsz)
x[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (i%32);
/* append padding */
x[len >> 5] |= 0x80 << ((len) % 32);
x[(((len + 64) >>> 9) << 4) + 14] = len;
var a = 1732584193;
var b = -271733879;
var c = -1732584194;
var d = 271733878;
for(var i = 0; i < x.length; i += 16)
{
var olda = a;
var oldb = b;
var oldc = c;
var oldd = d;
a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
c = md5_ff(c, d, a, b, x[i+ 2], 17, 606105819);
b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
d = md5_ff(d, a, b, c, x[i+ 5], 12, 1200080426);
c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
a = md5_ff(a, b, c, d, x[i+ 8], 7 , 1770035416);
d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
a = md5_ff(a, b, c, d, x[i+12], 7 , 1804603682);
d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
b = md5_ff(b, c, d, a, x[i+15], 22, 1236535329);
a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
c = md5_gg(c, d, a, b, x[i+11], 14, 643717713);
b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
d = md5_gg(d, a, b, c, x[i+10], 9 , 38016083);
c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
a = md5_gg(a, b, c, d, x[i+ 9], 5 , 568446438);
d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
b = md5_gg(b, c, d, a, x[i+ 8], 20, 1163531501);
a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
c = md5_gg(c, d, a, b, x[i+ 7], 14, 1735328473);
b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);
a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
c = md5_hh(c, d, a, b, x[i+11], 16, 1839030562);
b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
d = md5_hh(d, a, b, c, x[i+ 4], 11, 1272893353);
c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
a = md5_hh(a, b, c, d, x[i+13], 4 , 681279174);
d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
b = md5_hh(b, c, d, a, x[i+ 6], 23, 76029189);
a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
c = md5_hh(c, d, a, b, x[i+15], 16, 530742520);
b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);
a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
d = md5_ii(d, a, b, c, x[i+ 7], 10, 1126891415);
c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
a = md5_ii(a, b, c, d, x[i+12], 6 , 1700485571);
d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
a = md5_ii(a, b, c, d, x[i+ 8], 6 , 1873313359);
d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
b = md5_ii(b, c, d, a, x[i+13], 21, 1309151649);
a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
c = md5_ii(c, d, a, b, x[i+ 2], 15, 718787259);
b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);
a = safe_add(a, olda);
b = safe_add(b, oldb);
c = safe_add(c, oldc);
d = safe_add(d, oldd);
}
var binarray = Array(a, b, c, d);
var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
var str = "";
for(var i = 0; i < binarray.length * 4; i++)
{
str += hex_tab.charAt((binarray[i>>2] >> ((i%4)*8+4)) & 0xF) + hex_tab.charAt((binarray[i>>2] >> ((i%4)*8 )) & 0xF);
}
return str;
/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
*/
function safe_add(x, y)
{
var lsw = (x & 0xFFFF) + (y & 0xFFFF);
var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
return (msw << 16) | (lsw & 0xFFFF);
}
/*
* Bitwise rotate a 32-bit number to the left.
*/
function bit_rol(num, cnt)
{
return (num << cnt) | (num >>> (32 - cnt));
}
/*
* These functions implement the four basic operations the algorithm uses.
*/
function md5_cmn(q, a, b, x, s, t)
{
return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);
}
function md5_ff(a, b, c, d, x, s, t)
{
return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
}
function md5_gg(a, b, c, d, x, s, t)
{
return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
}
function md5_hh(a, b, c, d, x, s, t)
{
return md5_cmn(b ^ c ^ d, a, b, x, s, t);
}
function md5_ii(a, b, c, d, x, s, t)
{
return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
}
}
};
AjaxTCR.util = {};
AjaxTCR.util.DOM = {
enableDOMShorthand : true,
/**
* Find elements by class, will be overriden by native if found
* If startNode is specified, starts the search there, otherwise starts at document.
*
* @param classToFind the string class name to search for
* @param startNode the DOM node to start the search at. Default is the document node.
* @return array of elements that match the given class name.
*/
getElementsByClassName : function(classToFind,startNode){
if (document.getElementsByClassName)
return document.getElementsByClassName(classToFind,startNode);
/* find all the elements within a particular document or in the whole document */
var elements;
if (startNode)
elements = startNode.getElementsByTagName("*");
else
elements = document.getElementsByTagName("*");
var classElements = new Array();
var classCount = 0;
var pattern = new RegExp("(^|\\s)"+classToFind+"(\\s|$)");
/* look over the elements and find those who match the class passed */
for (var i = 0; i < elements.length; i++)
if (pattern.test(elements[i].className) )
classElements[classCount++] = elements[i];
return classElements;
},
/**
* Returns element or element array specified by given string or strings.
*
* @param element(s) strings to search for element.
* @param startNode the DOM node to start the search at. Default is the document node.
* @return if single string, it returns the element. Otherwise it returns an array of elements
*/
getElementsById : function(){
var elements = new Array();
var startNode = document;
var length = arguments.length;
if (typeof(arguments[length-1]) == "object" && arguments[length-1] != document)
{
startNode = arguments[length-1];
length--;
var allElements = startNode.getElementsByTagName("*");
for (var j=0; j 0)
return elements;
else
return null;
},
/**
* Modified version of getElementById to return single node match.
* If startNode is not set to document, it starts the search at the node
* If deepSearch is set to true, it does not use getElementById, but instead loops through the whole structure.
*
* @param id the string to match with the id attribute
* @param startNode the DOM node to start searching in the document
* @param deepSearch true if wanted to search node by node instead of document.getElementById
*/
getElementById : function(id, startNode, deepSearch){
if (!startNode)
startNode = document;
if (startNode == document && !deepSearch)
return document.getElementById(id);
else
{
var allElements = startNode.getElementsByTagName("*");
for (var j=0; j\+,])/g, " $1 ").replace(/[\s]+/g," ");
var selectors = selector.split(" ");
while (selectors.length > 0)
{
var curSelector = selectors.shift();
if (curSelector == "")
continue;
/* check for expressions */
var options = {};
switch(curSelector.charAt(0))
{
case(">"):
options.type = "childOnly";
break;
case("+"):
options.type = "nextSibling";
break;
case ("~"):
options.type = "futureSibling";
break;
case(","):
while(matches.length > 0)
savematches.push(matches.shift());
parents.length = 0;
if (treeRoot)
parents.push(treeRoot);
else
parents.push(document);
continue;
break;
}
if (options.type)
{
if (curSelector.length == 1)
curSelector = selectors.shift();
else
curSelector = curSelector.substring(1);
}
/* Check to see if we already looped though. If so, we have a different starting point */
if (matches.length)
{
parents.length = 0;
while(matches.length > 0)
parents.push(matches.shift());
}
/* Check for Pseudo-classes */
if (curSelector.indexOf(":") > -1)
{
var newSelector = curSelector.substring(0, curSelector.indexOf(":"));
var optionsType = curSelector.substring(curSelector.indexOf(":")+1);
curSelector = newSelector;
options.type = optionsType.toLowerCase();
if (options.type.indexOf("nth-child") == 0)
{
options.childNumber = options.type.substring(10,options.type.length-1);
options.type = "nth-child";
}
else if (options.type.indexOf("not") == 0)
{
//use optionsType to preserve case
options.notString = optionsType.substring(4,options.type.length-1).replace(/^\s+|\s+$/g,"");
options.type = "not";
var notSelector = curSelector;
if (notSelector == "*")
notSelector = "";
if (/^[:#\[\.].*/.test(options.notString))
options.notSelector = notSelector + options.notString;
else
options.notSelector = notSelector + " " + options.notString;
options.notObjects = AjaxTCR.util.DOM.getElementsBySelector(options.notSelector, parents);
}
}
/* Check for Attributes */
if (curSelector.indexOf("[") > -1)
{
var tokens = curSelector.split("[");
curSelector = tokens[0];
options.type = "attribute";
options.attribute = tokens[1].substring(0,tokens[1].length-1).toLowerCase();
}
if (curSelector == "")
curSelector = "*";
/* Inspect class selectors */
if (curSelector.indexOf(".") > -1)
{
/* Cases:
* p.class1
* .class2
* div.class1.class2
*/
var classNames = curSelector.split(".");
var elementName = classNames.shift();
/* First get the element at the beginning if necessary */
if (elementName != "")
{
for (var j=0;j 0)
{
/* if no element is specified, use getElementsByClassName for the first class */
var firstClass = classNames.shift();
for (var j=0;j=0;j--)
{
for (var k=0;k -1)
{
/* Cases:
* p#id1
* #id2
*/
var idNames = curSelector.split("#");
var elementName = idNames[0];
var id = idNames[1];
/* First get the element at the beginning if necessary */
if (elementName != "")
{
for (var j=0;j 0)
savematches.push(matches.shift());
while(savematches.length > 0)
matches.push(savematches.shift());
}
return matches;
},
/**
* Custom getElementsByTagName that takes various options into consideration before returning the values
*
* @param parentElm element to begin the search at
* @param tag string to match tagName to
* @param options
*/
_getElementsByTagName : function(parentElm, tag, options){
var matches = new Array();
if (!options.type)
return parentElm.getElementsByTagName(tag);
if (options.type == "nextSibling")
{
var elm = parentElm.nextSibling;
while (elm && elm.nodeType != 1)
elm = elm.nextSibling;
if (checkTagMatch(elm, tag))
matches.push(elm);
}
else if (options.type == "futureSibling")
{
var elm = parentElm.nextSibling;
while (elm)
{
if (checkTagMatch(elm, tag))
{
matches.push(elm);
//break;
}
elm = elm.nextSibling;
}
}
else
matches = parentElm.getElementsByTagName(tag);
function checkTagMatch(element, tag)
{
return (element && element.tagName && (tag == "*" || element.tagName.toUpperCase() == tag.toUpperCase()));
}
return matches;
}
};
AjaxTCR.util.event = {
/**
* addWindowLoadEvent - simple method to allow for safe addition of window.onload called functions. Assumes everyone else plays nicely though.
*
* @param newFunction - function to call upon page load
*/
addWindowLoadEvent: function(newFunction) {
var oldFunction = window.onload;
if (typeof window.onload != "function")
{
window.onload = newFunction;
}
else
{
window.onload = function () {
if (oldFunction)
{
oldFunction();
}
newFunction();
};
}
}
};
AjaxTCR.util.misc = {
/**
* generateUID : Generates a unique value. If 'prefix' is set to -1, only returns the numerical value.
* If prefix isn't set, it sets it to "AjaxTCR".
*
* @param prefix the string value to prepend to the uniquevalue
* @return the string consisting of the prefix and the uniquevalue
*/
generateUID : function(prefix){
if (prefix == "-1")
prefix = "";
else if (!prefix)
prefix = "AjaxTCR";
var uniquevalue = new Date().getTime().toString() + Math.floor(Math.random()*100);
return prefix + uniquevalue;
}
};
if (AjaxTCR.util.DOM.enableDOMShorthand)
{
if (typeof($id) == "undefined") $id = AjaxTCR.util.DOM.getElementsById;
if (typeof($class) == "undefined") $class = AjaxTCR.util.DOM.getElementsByClassName;
if (typeof($selector) == "undefined") $selector = AjaxTCR.util.DOM.getElementsBySelector;
}