1 files changed, 667 insertions, 0 deletions
diff --git a/framework/Web/Javascripts/source/prado/activecontrols/ajax3.js b/framework/Web/Javascripts/source/prado/activecontrols/ajax3.js
new file mode 100644
index 00000000..dbf768a6
--- /dev/null
+++ b/framework/Web/Javascripts/source/prado/activecontrols/ajax3.js
@@ -0,0 +1,667 @@
+
+Prado.AjaxRequest = Class.create();
+Prado.AjaxRequest.prototype = Ajax.Request.prototype;
+
+
+/**
+ * Override Prototype's response implementation.
+ */
+Object.extend(Prado.AjaxRequest.prototype,
+{
+	/*initialize: function(request)
+	{
+		this.CallbackRequest = request;
+		this.transport = Ajax.getTransport();
+		this.setOptions(request.options);
+		this.request(request.url);
+	},*/
+
+	/**
+	 * Customize the response, dispatch onXXX response code events, and
+	 * tries to execute response actions (javascript statements).
+	 */
+	respondToReadyState : function(readyState)
+	{
+	    var event = Ajax.Request.Events[readyState];
+	    var transport = this.transport, json = this.getBodyDataPart(Prado.CallbackRequest.DATA_HEADER);
+
+	    if (event == 'Complete')
+	    {
+			var redirectUrl = this.getBodyContentPart(Prado.CallbackRequest.REDIRECT_HEADER);
+	    	if(redirectUrl)
+	    		document.location.href = redirectUrl;
+
+	      if ((this.getHeader('Content-type') || '').match(/^text\/javascript/i))
+	      {
+	        try
+			{
+	           json = eval('(' + transport.responseText + ')');
+	        }catch (e)
+			{
+				if(typeof(json) == "string")
+					json = Prado.CallbackRequest.decode(result);
+			}
+	      }
+
+	      try
+	      {
+	      	Prado.CallbackRequest.updatePageState(this,transport);
+			Ajax.Responders.dispatch('on' + transport.status, this, transport, json);
+			Prado.CallbackRequest.dispatchActions(transport,this.getBodyDataPart(Prado.CallbackRequest.ACTION_HEADER));
+
+	        (this.options['on' + this.transport.status]
+	         || this.options['on' + (this.success() ? 'Success' : 'Failure')]
+	         || Prototype.emptyFunction)(this, json);
+	  	      } catch (e) {
+	        this.dispatchException(e);
+	      }
+	    }
+
+	    try {
+	      (this.options['on' + event] || Prototype.emptyFunction)(this, json);
+	      Ajax.Responders.dispatch('on' + event, this, transport, json);
+	    } catch (e) {
+	      this.dispatchException(e);
+	    }
+
+	    /* Avoid memory leak in MSIE: clean up the oncomplete event handler */
+	    if (event == 'Complete')
+	      this.transport.onreadystatechange = Prototype.emptyFunction;
+	},
+
+	/**
+	 * Gets header data assuming JSON encoding.
+	 * @param string header name
+	 * @return object header data as javascript structures.
+	 */
+	getHeaderData : function(name)
+	{
+		return this.getJsonData(this.getHeader(name));
+	},
+
+	getBodyContentPart : function(name)
+	{
+		if(typeof(this.transport.responseText)=="string")
+			return Prado.Element.extractContent(this.transport.responseText, name);
+	},
+
+	getJsonData : function(json)
+	{
+		try
+		{
+			return eval('(' + json + ')');
+		}
+		catch (e)
+		{
+			if(typeof(json) == "string")
+				return Prado.CallbackRequest.decode(json);
+		}
+	},
+
+	getBodyDataPart : function(name)
+	{
+		return this.getJsonData(this.getBodyContentPart(name));
+	}
+});
+
+/**
+ * Prado Callback client-side request handler.
+ */
+Prado.CallbackRequest = Class.create();
+
+/**
+ * Static definitions.
+ */
+Object.extend(Prado.CallbackRequest,
+{
+	/**
+	 * Callback request target POST field name.
+	 */
+	FIELD_CALLBACK_TARGET : 'PRADO_CALLBACK_TARGET',
+	/**
+	 * Callback request parameter POST field name.
+	 */
+	FIELD_CALLBACK_PARAMETER : 'PRADO_CALLBACK_PARAMETER',
+	/**
+	 * Callback request page state field name,
+	 */
+	FIELD_CALLBACK_PAGESTATE : 'PRADO_PAGESTATE',
+
+	FIELD_POSTBACK_TARGET : 'PRADO_POSTBACK_TARGET',
+
+	FIELD_POSTBACK_PARAMETER : 'PRADO_POSTBACK_PARAMETER',
+
+	/**
+	 * List of form fields that will be collected during callback.
+	 */
+	PostDataLoaders : [],
+	/**
+	 * Response data header name.
+	 */
+	DATA_HEADER : 'X-PRADO-DATA',
+	/**
+	 * Response javascript execution statement header name.
+	 */
+	ACTION_HEADER : 'X-PRADO-ACTIONS',
+	/**
+	 * Response errors/exceptions header name.
+	 */
+	ERROR_HEADER : 'X-PRADO-ERROR',
+	/**
+	 * Page state header name.
+	 */
+	PAGESTATE_HEADER : 'X-PRADO-PAGESTATE',
+
+	REDIRECT_HEADER : 'X-PRADO-REDIRECT',
+
+	requestQueue : [],
+
+	//all request objects
+	requests : {},
+
+	getRequestById : function(id)
+	{
+		var requests = Prado.CallbackRequest.requests;
+		if(typeof(requests[id]) != "undefined")
+			return requests[id];
+	},
+
+	dispatch : function(id)
+	{
+		var requests = Prado.CallbackRequest.requests;
+		if(typeof(requests[id]) != "undefined")
+			requests[id].dispatch();
+	},
+
+	/**
+	 * Add ids of inputs element to post in the request.
+	 */
+	addPostLoaders : function(ids)
+	{
+		var self = Prado.CallbackRequest;
+		self.PostDataLoaders = self.PostDataLoaders.concat(ids);
+		var list = [];
+		self.PostDataLoaders.each(function(id)
+		{
+			if(list.indexOf(id) < 0)
+				list.push(id);
+		});
+		self.PostDataLoaders = list;
+	},
+
+	/**
+	 * Dispatch callback response actions.
+	 */
+	dispatchActions : function(transport,actions)
+	{
+		var self = Prado.CallbackRequest;
+		if(actions && actions.length > 0)
+			actions.each(self.__run.bind(self,transport));
+	},
+
+	/**
+	 * Prase and evaluate a Callback clien-side action
+	 */
+	__run : function(transport, command)
+	{
+		var self = Prado.CallbackRequest;
+		self.transport = transport;
+		for(var method in command)
+		{
+			try
+			{
+				method.toFunction().apply(self,command[method]);
+			}
+			catch(e)
+			{
+				if(typeof(Logger) != "undefined")
+					self.Exception.onException(null,e);
+			}
+		}
+	},
+
+	/**
+	 * Respond to Prado Callback request exceptions.
+	 */
+	Exception :
+	{
+		/**
+		 * Server returns 500 exception. Just log it.
+		 */
+		"on500" : function(request, transport, data)
+		{
+			var e = request.getHeaderData(Prado.CallbackRequest.ERROR_HEADER);
+			Logger.error("Callback Server Error "+e.code, this.formatException(e));
+		},
+
+		/**
+		 * Callback OnComplete event,logs reponse and data to console.
+		 */
+		'on200' : function(request, transport, data)
+		{
+			if(transport.status < 500)
+			{
+				var msg = 'HTTP '+transport.status+" with response : \n";
+				if(transport.responseText.trim().length >0)
+				{
+					var f = RegExp('(<!--X-PRADO[^>]+-->)([\\s\\S\\w\\W]*)(<!--//X-PRADO[^>]+-->)',"m");
+					msg += transport.responseText.replace(f,'') + "\n";
+				}
+				if(typeof(data)!="undefined" && data != null)
+					msg += "Data : \n"+inspect(data)+"\n";
+				data = request.getBodyDataPart(Prado.CallbackRequest.ACTION_HEADER);
+				if(data && data.length > 0)
+				{
+					msg += "Actions : \n";
+					data.each(function(action)
+					{
+						msg += inspect(action)+"\n";
+					});
+				}
+				Logger.info(msg);
+			}
+		},
+
+		/**
+		 * Uncaught exceptions during callback response.
+		 */
+		onException : function(request,e)
+		{
+			msg = "";
+			$H(e).each(function(item)
+			{
+				msg += item.key+": "+item.value+"\n";
+			})
+			Logger.error('Uncaught Callback Client Exception:', msg);
+		},
+
+		/**
+		 * Formats the exception message for display in console.
+		 */
+		formatException : function(e)
+		{
+			var msg = e.type + " with message \""+e.message+"\"";
+			msg += " in "+e.file+"("+e.line+")\n";
+			msg += "Stack trace:\n";
+			var trace = e.trace;
+			for(var i = 0; i<trace.length; i++)
+			{
+				msg += "  #"+i+" "+trace[i].file;
+				msg += "("+trace[i].line+"): ";
+				msg += trace[i]["class"]+"->"+trace[i]["function"]+"()"+"\n";
+			}
+			msg += e.version+" "+e.time+"\n";
+			return msg;
+		}
+	},
+
+	/**
+	 * @return string JSON encoded data.
+	 */
+	encode : function(data)
+	{
+		return Prado.JSON.stringify(data);
+	},
+
+	/**
+	 * @return mixed javascript data decoded from string using JSON decoding.
+	 */
+	decode : function(data)
+	{
+		if(typeof(data) == "string" && data.trim().length > 0)
+			return Prado.JSON.parse(data);
+		else
+			return null;
+	},
+
+	/**
+	 * Dispatch a normal request, no timeouts or aborting of requests.
+	 */
+	dispatchNormalRequest : function(callback)
+	{
+		//Logger.info("dispatching normal request");
+		//new Prado.AjaxRequest(callback);
+		callback.request(callback.url);
+		return true;
+	},
+
+	/**
+	 * Abort the current priority request in progress.
+	 */
+	tryNextRequest : function()
+	{
+		var self = Prado.CallbackRequest;
+		//Logger.debug('trying next request');
+		if(typeof(self.currentRequest) == 'undefined' || self.currentRequest==null)
+		{
+			if(self.requestQueue.length > 0)
+				return self.dispatchQueue();
+			//else
+				//Logger.warn('empty queque');
+		}
+//		else
+	//		Logger.warn('current request ' + self.currentRequest.id);
+	},
+
+	/**
+	 * Updates the page state. It will update only if EnablePageStateUpdate and
+	 * HasPriority options are both true.
+	 */
+	updatePageState : function(request, transport)
+	{
+		var self = Prado.CallbackRequest;
+		var pagestate = $(self.FIELD_CALLBACK_PAGESTATE);
+		var enabled = request.ActiveControl.EnablePageStateUpdate && request.ActiveControl.HasPriority;
+		var aborted = self.currentRequest == null;
+		if(enabled && !aborted && pagestate)
+		{
+			var data = request.getBodyContentPart(self.PAGESTATE_HEADER);
+			if(typeof(data) == "string" && data.length > 0)
+				pagestate.value = data;
+			else
+			{
+				if(typeof(Logger) != "undefined")
+					Logger.warn("Missing page state:"+data);
+//				Logger.warn('## bad state: setting current request to null');
+				self.endCurrentRequest();
+				//self.tryNextRequest();
+				return false;
+			}
+		}
+		self.endCurrentRequest();
+	//	Logger.warn('## state updated: setting current request to null');
+	//	self.tryNextRequest();
+		return true;
+	},
+
+	enqueue : function(callback)
+	{
+		var self = Prado.CallbackRequest;
+		self.requestQueue.push(callback);
+		//Logger.warn("equeued "+callback.id+", current queque length="+self.requestQueue.length);
+		self.tryNextRequest();
+	},
+
+	dispatchQueue : function()
+	{
+		var self = Prado.CallbackRequest;
+		//Logger.warn("dispatching queque, length="+self.requestQueue.length+" request="+self.currentRequest);
+		var callback = self.requestQueue.shift();
+		self.currentRequest = callback;
+
+		//get data
+		callback.options.postBody = callback._getPostData(),
+
+		//callback.request = new Prado.AjaxRequest(callback);
+		callback.request(callback.url);
+		callback.timeout = setTimeout(function()
+		{
+			//Logger.warn("priority timeout");
+			self.abortRequest(callback.id);
+		},callback.ActiveControl.RequestTimeOut);
+		//Logger.debug("dispatched "+self.currentRequest.id + " ...")
+	},
+
+	endCurrentRequest : function()
+	{
+		var self = Prado.CallbackRequest;
+		clearTimeout(self.currentRequest.timeout);
+		self.currentRequest=null;
+	},
+
+	abortRequest : function(id)
+	{
+		//Logger.warn("abort id="+id);
+		var self = Prado.CallbackRequest;
+		if(typeof(self.currentRequest) != 'undefined'
+			&& self.currentRequest != null && self.currentRequest.id == id)
+		{
+			var request = self.currentRequest;
+			if(request.transport.readyState < 4)
+				request.transport.abort();
+			//Logger.warn('## aborted: setting current request to null');
+			self.endCurrentRequest();
+		}
+		self.tryNextRequest();
+	}
+})
+
+/**
+ * Automatically aborts the current request when a priority request has returned.
+ */
+Ajax.Responders.register({onComplete : function(request)
+{
+	if(request.ActiveControl.HasPriority)
+		Prado.CallbackRequest.tryNextRequest();
+}});
+
+//Add HTTP exception respones when logger is enabled.
+Event.OnLoad(function()
+{
+	if(typeof Logger != "undefined")
+		Ajax.Responders.register(Prado.CallbackRequest.Exception);
+});
+
+/**
+ * Create and prepare a new callback request.
+ * Call the dispatch() method to start the callback request.
+ * <code>
+ * request = new Prado.CallbackRequest(UniqueID, callback);
+ * request.dispatch();
+ * </code>
+ */
+Prado.CallbackRequest.prototype = Object.extend(Prado.AjaxRequest.prototype,
+{
+
+	/**
+	 * Prepare and inititate a callback request.
+	 */
+	initialize : function(id, options)
+	{
+	/**
+	 * Callback URL, same url as the current page.
+	 */
+		this.url = this.getCallbackUrl();
+
+		this.transport = Ajax.getTransport();
+//		this.setOptions(request.options);
+//		this.request(request.url);
+		/**
+		 * Current callback request.
+		 */
+		//this.request = null;
+
+		this.Enabled = true;
+
+		this.id = id;
+		if(typeof(id)=="string")
+			Prado.CallbackRequest.requests[id] = this;
+
+		this.setOptions(Object.extend(
+		{
+			RequestTimeOut : 30000, // 30 second timeout.
+			EnablePageStateUpdate : true,
+			HasPriority : true,
+			CausesValidation : true,
+			ValidationGroup : null,
+			PostInputs : true
+		}, options || {}));
+
+		this.ActiveControl = this.options;
+	},
+
+	/**
+	 * Gets the url from the forms that contains the PRADO_PAGESTATE
+	 * @return {String} callback url.
+	 */
+	getCallbackUrl : function()
+	{
+		return $('PRADO_PAGESTATE').form.action;
+	},
+
+	/**
+	 * Sets the request parameter
+	 * @param {Object} parameter value
+	 */
+	setCallbackParameter : function(value)
+	{
+		this.ActiveControl['CallbackParameter'] = value;
+	},
+
+	/**
+	 * @return {Object} request paramater value.
+	 */
+	getCallbackParameter : function()
+	{
+		return this.ActiveControl['CallbackParameter'];
+	},
+
+	/**
+	 * Sets the callback request timeout.
+	 * @param {integer} timeout in  milliseconds
+	 */
+	setRequestTimeOut : function(timeout)
+	{
+		this.ActiveControl['RequestTimeOut'] = timeout;
+	},
+
+	/**
+	 * @return {integer} request timeout in milliseconds
+	 */
+	getRequestTimeOut : function()
+	{
+		return this.ActiveControl['RequestTimeOut'];
+	},
+
+	/**
+	 * Set true to enable validation on callback dispatch.
+	 * @param {boolean} true to validate
+	 */
+	setCausesValidation : function(validate)
+	{
+		this.ActiveControl['CausesValidation'] = validate;
+	},
+
+	/**
+	 * @return {boolean} validate on request dispatch
+	 */
+	getCausesValidation : function()
+	{
+		return this.ActiveControl['CausesValidation'];
+	},
+
+	/**
+	 * Sets the validation group to validate during request dispatch.
+	 * @param {string} validation group name
+	 */
+	setValidationGroup : function(group)
+	{
+		this.ActiveControl['ValidationGroup'] = group;
+	},
+
+	/**
+	 * @return {string} validation group name.
+	 */
+	getValidationGroup : function()
+	{
+		return this.ActiveControl['ValidationGroup'];
+	},
+
+	/**
+	 * Dispatch the callback request.
+	 */
+	dispatch : function()
+	{
+		//Logger.info("dispatching request");
+		//trigger tinyMCE to save data.
+		if(typeof tinyMCE != "undefined")
+			tinyMCE.triggerSave();
+
+		if(this.ActiveControl.CausesValidation && typeof(Prado.Validation) != "undefined")
+		{
+			var form =  this.ActiveControl.Form || Prado.Validation.getForm();
+			if(Prado.Validation.validate(form,this.ActiveControl.ValidationGroup,this) == false)
+				return false;
+		}
+
+		if(this.ActiveControl.onPreDispatch)
+			this.ActiveControl.onPreDispatch(this,null);
+
+		if(!this.Enabled)
+			return;
+
+		if(this.ActiveControl.HasPriority)
+		{
+			return Prado.CallbackRequest.enqueue(this);
+			//return Prado.CallbackRequest.dispatchPriorityRequest(this);
+		}
+		else
+			return Prado.CallbackRequest.dispatchNormalRequest(this);
+	},
+
+	abort : function()
+	{
+		return Prado.CallbackRequest.abortRequest(this.id);
+	},
+
+	/**
+	 * Collects the form inputs, encode the parameters, and sets the callback
+	 * target id. The resulting string is the request content body.
+	 * @return string request body content containing post data.
+	 */
+	_getPostData : function()
+	{
+		var data = {};
+		var callback = Prado.CallbackRequest;
+		if(this.ActiveControl.PostInputs != false)
+		{
+			callback.PostDataLoaders.each(function(name)
+			{
+				$A(document.getElementsByName(name)).each(function(element)
+				{
+					//IE will try to get elements with ID == name as well.
+					if(element.type && element.name == name)
+					{
+						value = $F(element);
+						if(typeof(value) != "undefined" && value != null)
+							data[name] = value;
+					}
+				})
+			})
+		}
+		if(typeof(this.ActiveControl.CallbackParameter) != "undefined")
+			data[callback.FIELD_CALLBACK_PARAMETER] = callback.encode(this.ActiveControl.CallbackParameter);
+		var pageState = $F(callback.FIELD_CALLBACK_PAGESTATE);
+		if(typeof(pageState) != "undefined")
+			data[callback.FIELD_CALLBACK_PAGESTATE] = pageState;
+		data[callback.FIELD_CALLBACK_TARGET] = this.id;
+		if(this.ActiveControl.EventTarget)
+			data[callback.FIELD_POSTBACK_TARGET] = this.ActiveControl.EventTarget;
+		if(this.ActiveControl.EventParameter)
+			data[callback.FIELD_POSTBACK_PARAMETER] = this.ActiveControl.EventParameter;
+		return $H(data).toQueryString();
+	}
+});
+
+/**
+ * Create a new callback request using default settings.
+ * @param string callback handler unique ID.
+ * @param mixed parameter to pass to callback handler on the server side.
+ * @param function client side onSuccess event handler.
+ * @param object additional request options.
+ * @return boolean always false.
+ */
+Prado.Callback = function(UniqueID, parameter, onSuccess, options)
+{
+	var callback =
+	{
+		'CallbackParameter' : parameter || '',
+		'onSuccess' : onSuccess || Prototype.emptyFunction
+	};
+
+	Object.extend(callback, options || {});
+
+	request = new Prado.CallbackRequest(UniqueID, callback);
+	request.dispatch();
+	return false;
+}