Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojo._base.xhr"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojo._base.xhr"] = true;
dojo.provide("dojo._base.xhr");
dojo.require("dojo._base.Deferred");
dojo.require("dojo._base.json");
dojo.require("dojo._base.lang");
dojo.require("dojo._base.query");

(function(){
        var _d = dojo;
        function setValue(/*Object*/obj, /*String*/name, /*String*/value){
                //summary:
                //              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.
                var val = obj[name];
                if(_d.isString(val)){
                        obj[name] = [val, value];
                }else if(_d.isArray(val)){
                        val.push(value);
                }else{
                        obj[name] = value;
                }
        }

        dojo.formToObject = function(/*DOMNode||String*/ formNode){
                // summary:
                //              dojo.formToObject returns the values encoded in an HTML form as
                //              string properties in an object which it then returns. Disabled form
                //              elements, buttons, and other non-value form elements are skipped.
                //              Multi-select elements are returned as an array of string values.
                // description:
                //              This form:
                //
                //                      <form id="test_form">
                //                              <input type="text" name="blah" value="blah">
                //                              <input type="text" name="no_value" value="blah" disabled>
                //                              <input type="button" name="no_value2" value="blah">
                //                              <select type="select" multiple name="multi" size="5">
                //                                      <option value="blah">blah</option>
                //                                      <option value="thud" selected>thud</option>
                //                                      <option value="thonk" selected>thonk</option>
                //                              </select>
                //                      </form>
                //
                //              yields this object structure as the result of a call to
                //              formToObject():
                //
                //                      { 
                //                              blah: "blah",
                //                              multi: [
                //                                      "thud",
                //                                      "thonk"
                //                              ]
                //                      };
        
                var ret = {};
                var iq = "input:not([type=file]):not([type=submit]):not([type=image]):not([type=reset]):not([type=button]), select, textarea";
                _d.query(iq, formNode).filter(function(node){
                        return (!node.disabled);
                }).forEach(function(item){
                        var _in = item.name;
                        var type = (item.type||"").toLowerCase();
                        if(type == "radio" || type == "checkbox"){
                                if(item.checked){ setValue(ret, _in, item.value); }
                        }else if(item.multiple){
                                ret[_in] = [];
                                _d.query("option", item).forEach(function(opt){
                                        if(opt.selected){
                                                setValue(ret, _in, opt.value);
                                        }
                                });
                        }else{ 
                                setValue(ret, _in, item.value);
                                if(type == "image"){
                                        ret[_in+".x"] = ret[_in+".y"] = ret[_in].x = ret[_in].y = 0;
                                }
                        }
                });
                return ret; // Object
        }

        dojo.objectToQuery = function(/*Object*/ map){
                //      summary:
                //              takes a key/value mapping object and returns a string representing
                //              a URL-encoded version of that object.
                //      example:
                //              this object:
                //
                //              |       { 
                //              |               blah: "blah",
                //              |               multi: [
                //              |                       "thud",
                //              |                       "thonk"
                //              |               ]
                //              |       };
                //
                //      yeilds the following query string:
                //      
                //      |       "blah=blah&multi=thud&multi=thonk"


                // FIXME: need to implement encodeAscii!!
                var ec = encodeURIComponent;
                var ret = "";
                var backstop = {};
                for(var x in map){
                        if(map[x] != backstop[x]){
                                if(_d.isArray(map[x])){
                                        for(var y=0; y<map[x].length; y++){
                                                ret += ec(x) + "=" + ec(map[x][y]) + "&";
                                        }
                                }else{
                                        ret += ec(x) + "=" + ec(map[x]) + "&";
                                }
                        }
                }
                if(ret.length && ret.charAt(ret.length-1) == "&"){
                        ret = ret.substr(0, ret.length-1);
                }
                return ret; // String
        }

        dojo.formToQuery = function(/*DOMNode||String*/ formNode){
                // summary:
                //              return URL-encoded string representing the form passed as either a
                //              node or string ID identifying the form to serialize
                return _d.objectToQuery(_d.formToObject(formNode)); // String
        }

        dojo.formToJson = function(/*DOMNode||String*/ formNode, /*Boolean?*/prettyPrint){
                // summary:
                //              return a serialized JSON string from a form node or string
                //              ID identifying the form to serialize
                return _d.toJson(_d.formToObject(formNode), prettyPrint); // String
        }

        dojo.queryToObject = function(/*String*/ str){
                // summary:
                //              returns an object representing a de-serialized query section of a
                //              URL. Query keys with multiple values are returned in an array.
                // description:
                //              This string:
                //
                //                      "foo=bar&foo=baz&thinger=%20spaces%20=blah&zonk=blarg&"
                //              
                //              returns this object structure:
                //
                //                      {
                //                              foo: [ "bar", "baz" ],
                //                              thinger: " spaces =blah",
                //                              zonk: "blarg"
                //                      }
                //      
                //              Note that spaces and other urlencoded entities are correctly
                //              handled.

                // FIXME: should we grab the URL string if we're not passed one?
                var ret = {};
                var qp = str.split("&");
                var dc = decodeURIComponent;
                _d.forEach(qp, function(item){
                        if(item.length){
                                var parts = item.split("=");
                                var name = dc(parts.shift());
                                var val = dc(parts.join("="));
                                if(_d.isString(ret[name])){
                                        ret[name] = [ret[name]];
                                }
                                if(_d.isArray(ret[name])){
                                        ret[name].push(val);
                                }else{
                                        ret[name] = val;
                                }
                        }
                });
                return ret; // Object
        }

        /*
                from refactor.txt:

                all bind() replacement APIs take the following argument structure:

                        {
                                url: "blah.html",

                                // all below are optional, but must be supported in some form by
                                // every IO API
                                timeout: 1000, // milliseconds
                                handleAs: "text", // replaces the always-wrong "mimetype"
                                content: { 
                                        key: "value"
                                },

                                // browser-specific, MAY be unsupported
                                sync: true, // defaults to false
                                form: dojo.byId("someForm") 
                        }
        */

        // need to block async callbacks from snatching this thread as the result
        // of an async callback might call another sync XHR, this hangs khtml forever
        // must checked by watchInFlight()

        dojo._blockAsync = false;

        dojo._contentHandlers = {
                "text": function(xhr){ return xhr.responseText; },
                "json": function(xhr){
                        if(!djConfig.usePlainJson){
                                console.debug("Consider using mimetype:text/json-comment-filtered"
                                        + " to avoid potential security issues with JSON endpoints"
                                        + " (use djConfig.usePlainJson=true to turn off this message)");
                        }
                        return _d.fromJson(xhr.responseText);
                },
                "json-comment-filtered": function(xhr){ 
                        // NOTE: we provide the json-comment-filtered option as one solution to
                        // the "JavaScript Hijacking" issue noted by Fortify and others. It is
                        // not appropriate for all circumstances.

                        var value = xhr.responseText;
                        var cStartIdx = value.indexOf("\/*");
                        var cEndIdx = value.lastIndexOf("*\/");
                        if(cStartIdx == -1 || cEndIdx == -1){
                                throw new Error("JSON was not comment filtered");
                        }
                        return _d.fromJson(value.substring(cStartIdx+2, cEndIdx));
                },
                "javascript": function(xhr){ 
                        // FIXME: try Moz and IE specific eval variants?
                        return _d.eval(xhr.responseText);
                },
                "xml": function(xhr){ 
                        if(_d.isIE && !xhr.responseXML){
                                _d.forEach(["MSXML2", "Microsoft", "MSXML", "MSXML3"], function(i){
                                        try{
                                                var doc = new ActiveXObject(prefixes[i]+".XMLDOM");
                                                doc.async = false;
                                                doc.loadXML(xhr.responseText);
                                                return doc;     //      DOMDocument
                                        }catch(e){ /* squelch */ };
                                });
                        }else{
                                return xhr.responseXML;
                        }
                }
        };

        dojo._contentHandlers["json-comment-optional"] = function(xhr){
                var handlers = _d._contentHandlers;
                try{
                        return handlers["json-comment-filtered"](xhr);
                }catch(e){
                        return handlers["json"](xhr);
                }
        };

        /*=====
        dojo.__ioArgs = function(kwArgs){
                //      url: String
                //              URL to server endpoint.
                //      content: Object?
                //              Contains properties with string values. These
                //              properties will be serialized as name1=value2 and
                //              passed in the request.
                //      timeout: Integer?
                //              Milliseconds to wait for the response. If this time
                //              passes, the then error callbacks are called.
                //      form: DOMNode?
                //              DOM node for a form. Used to extract the form values
                //              and send to the server.
                //      preventCache: Boolean?
                //              Default is false. If true, then a
                //              "dojo.preventCache" parameter is sent in the request
                //              with a value that changes with each request
                //              (timestamp). Useful only with GET-type requests.
                //      handleAs: String?
                //              Acceptable values depend on the type of IO
                //              transport (see specific IO calls for more information).
                //      load: Function?
                //              function(response, ioArgs){}. response is an Object, ioArgs
                //              is of type dojo.__ioCallbackArgs. The load function will be
                //              called on a successful response.
                //      error: Function?
                //              function(response, ioArgs){}. response is an Object, ioArgs
                //              is of type dojo.__ioCallbackArgs. The error function will
                //              be called in an error case. 
                //      handle: Function
                //              function(response, ioArgs){}. response is an Object, ioArgs
                //              is of type dojo.__ioCallbackArgs. The handle function will
                //              be called in either the successful or error case.  For
                //              the load, error and handle functions, the ioArgs object
                //              will contain the following properties: 
        }
        =====*/

        /*=====
        dojo.__ioCallbackArgs = function(kwArgs){
                //      args: Object
                //              the original object argument to the IO call.
                //      xhr: XMLHttpRequest
                //              For XMLHttpRequest calls only, the
                //              XMLHttpRequest object that was used for the
                //              request.
                //      url: String
                //              The final URL used for the call. Many times it
                //              will be different than the original args.url
                //              value.
                //      query: String
                //              For non-GET requests, the
                //              name1=value1&name2=value2 parameters sent up in
                //              the request.
                //      handleAs: String
                //              The final indicator on how the response will be
                //              handled.
                //      id: String
                //              For dojo.io.script calls only, the internal
                //              script ID used for the request.
                //      canDelete: Boolean
                //              For dojo.io.script calls only, indicates
                //              whether the script tag that represents the
                //              request can be deleted after callbacks have
                //              been called. Used internally to know when
                //              cleanup can happen on JSONP-type requests.
                //      json: Object
                //              For dojo.io.script calls only: holds the JSON
                //              response for JSONP-type requests. Used
                //              internally to hold on to the JSON responses.
                //              You should not need to access it directly --
                //              the same object should be passed to the success
                //              callbacks directly.
        }
        =====*/



        dojo._ioSetArgs = function(/*dojo.__ioArgs*/args,
                        /*Function*/canceller,
                        /*Function*/okHandler,
                        /*Function*/errHandler){
                //      summary: 
                //              sets up the Deferred and ioArgs property on the Deferred so it
                //              can be used in an io call.
                //      args:
                //              The args object passed into the public io call. Recognized properties on
                //              the args object are:
                //      canceller:
                //              The canceller function used for the Deferred object. The function
                //              will receive one argument, the Deferred object that is related to the
                //              canceller.
                //      okHandler:
                //              The first OK callback to be registered with Deferred. It has the opportunity
                //              to transform the OK response. It will receive one argument -- the Deferred
                //              object returned from this function.
                //      errHandler:
                //              The first error callback to be registered with Deferred. It has the opportunity
                //              to do cleanup on an error. It will receive two arguments: error (the 
                //              Error object) and dfd, the Deferred object returned from this function.

                var ioArgs = {args: args, url: args.url};

                //Get values from form if requestd.
                var formObject = null;
                if(args.form){ 
                        var form = _d.byId(args.form);
                        //IE requires going through getAttributeNode instead of just getAttribute in some form cases, 
                        //so use it for all.  See #2844
                        var actnNode = form.getAttributeNode("action");
                        ioArgs.url = ioArgs.url || (actnNode ? actnNode.value : null); 
                        formObject = _d.formToObject(form);
                }

                // set up the query params
                var miArgs = [{}];
        
                if(formObject){
                        // potentially over-ride url-provided params w/ form values
                        miArgs.push(formObject);
                }
                if(args.content){
                        // stuff in content over-rides what's set by form
                        miArgs.push(args.content);
                }
                if(args.preventCache){
                        miArgs.push({"dojo.preventCache": new Date().valueOf()});
                }
                ioArgs.query = _d.objectToQuery(_d.mixin.apply(null, miArgs));
        
                // .. and the real work of getting the deferred in order, etc.
                ioArgs.handleAs = args.handleAs || "text";
                var d = new _d.Deferred(canceller);
                d.addCallbacks(okHandler, function(error){
                        return errHandler(error, d);
                });

                //Support specifying load, error and handle callback functions from the args.
                //For those callbacks, the "this" object will be the args object.
                //The callbacks will get the deferred result value as the
                //first argument and the ioArgs object as the second argument.
                var ld = args.load;
                if(ld && _d.isFunction(ld)){
                        d.addCallback(function(value){
                                return ld.call(args, value, ioArgs);
                        });
                }
                var err = args.error;
                if(err && _d.isFunction(err)){
                        d.addErrback(function(value){
                                return err.call(args, value, ioArgs);
                        });
                }
                var handle = args.handle;
                if(handle && _d.isFunction(handle)){
                        d.addBoth(function(value){
                                return handle.call(args, value, ioArgs);
                        });
                }
                
                d.ioArgs = ioArgs;
        
                // FIXME: need to wire up the xhr object's abort method to something
                // analagous in the Deferred
                return d;
        }

        var _deferredCancel = function(/*Deferred*/dfd){
                //summary: canceller function for dojo._ioSetArgs call.
                
                dfd.canceled = true;
                var xhr = dfd.ioArgs.xhr;
                var _at = (typeof xhr.abort);
                if((_at == "function")||(_at == "unknown")){
                        xhr.abort();
                }
                var err = new Error("xhr cancelled");
                err.dojoType = "cancel";
                return err;
        }
        var _deferredOk = function(/*Deferred*/dfd){
                //summary: okHandler function for dojo._ioSetArgs call.

                return _d._contentHandlers[dfd.ioArgs.handleAs](dfd.ioArgs.xhr);
        }
        var _deferError = function(/*Error*/error, /*Deferred*/dfd){
                //summary: errHandler function for dojo._ioSetArgs call.
                
                // console.debug("xhr error in:", dfd.ioArgs.xhr);
                console.debug(error);
                return error;
        }

        var _makeXhrDeferred = function(/*dojo.__xhrArgs*/args){
                //summary: makes the Deferred object for this xhr request.
                var dfd = _d._ioSetArgs(args, _deferredCancel, _deferredOk, _deferError);
                //Pass the args to _xhrObj, to allow xhr iframe proxy interceptions.
                dfd.ioArgs.xhr = _d._xhrObj(dfd.ioArgs.args);
                return dfd;
        }

        // avoid setting a timer per request. It degrades performance on IE
        // something fierece if we don't use unified loops.
        var _inFlightIntvl = null;
        var _inFlight = [];
        var _watchInFlight = function(){
                //summary: 
                //              internal method that checks each inflight XMLHttpRequest to see
                //              if it has completed or if the timeout situation applies.
                
                var now = (new Date()).getTime();
                // make sure sync calls stay thread safe, if this callback is called
                // during a sync call and this results in another sync call before the
                // first sync call ends the browser hangs
                if(!_d._blockAsync){
                        // we need manual loop because we often modify _inFlight (and therefore 'i') while iterating
                        // note: the second clause is an assigment on purpose, lint may complain
                        for(var i=0, tif; (i<_inFlight.length)&&(tif=_inFlight[i]); i++){
                                var dfd = tif.dfd;
                                try{
                                        if(!dfd || dfd.canceled || !tif.validCheck(dfd)){
                                                _inFlight.splice(i--, 1); 
                                        }else if(tif.ioCheck(dfd)){
                                                _inFlight.splice(i--, 1);
                                                tif.resHandle(dfd);
                                        }else if(dfd.startTime){
                                                //did we timeout?
                                                if(dfd.startTime + (dfd.ioArgs.args.timeout||0) < now){
                                                        _inFlight.splice(i--, 1);
                                                        var err = new Error("timeout exceeded");
                                                        err.dojoType = "timeout";
                                                        dfd.errback(err);
                                                        //Cancel the request so the io module can do appropriate cleanup.
                                                        dfd.cancel();
                                                }
                                        }
                                }catch(e){
                                        // FIXME: make sure we errback!
                                        console.debug(e);
                                        dfd.errback(new Error("_watchInFlightError!"));
                                }
                        }
                }

                if(!_inFlight.length){
                        clearInterval(_inFlightIntvl);
                        _inFlightIntvl = null;
                        return;
                }

        }

        dojo._ioCancelAll = function(){
                //summary: Cancels all pending IO requests, regardless of IO type
                //(xhr, script, iframe).
                try{
                        _d.forEach(_inFlight, function(i){
                                i.dfd.cancel();
                        });
                }catch(e){/*squelch*/}
        }

        //Automatically call cancel all io calls on unload
        //in IE for trac issue #2357.
        if(_d.isIE){
                _d.addOnUnload(_d._ioCancelAll);
        }

        _d._ioWatch = function(/*Deferred*/dfd,
                /*Function*/validCheck,
                /*Function*/ioCheck,
                /*Function*/resHandle){
                //summary: watches the io request represented by dfd to see if it completes.
                //dfd:
                //              The Deferred object to watch.
                //validCheck:
                //              Function used to check if the IO request is still valid. Gets the dfd
                //              object as its only argument.
                //ioCheck:
                //              Function used to check if basic IO call worked. Gets the dfd
                //              object as its only argument.
                //resHandle:
                //              Function used to process response. Gets the dfd
                //              object as its only argument.
                if(dfd.ioArgs.args.timeout){
                        dfd.startTime = (new Date()).getTime();
                }
                _inFlight.push({dfd: dfd, validCheck: validCheck, ioCheck: ioCheck, resHandle: resHandle});
                if(!_inFlightIntvl){
                        _inFlightIntvl = setInterval(_watchInFlight, 50);
                }
                _watchInFlight(); // handle sync requests
        }

        var _defaultContentType = "application/x-www-form-urlencoded";

        var _validCheck = function(/*Deferred*/dfd){
                return dfd.ioArgs.xhr.readyState; //boolean
        }
        var _ioCheck = function(/*Deferred*/dfd){
                return 4 == dfd.ioArgs.xhr.readyState; //boolean
        }
        var _resHandle = function(/*Deferred*/dfd){
                if(_d._isDocumentOk(dfd.ioArgs.xhr)){
                        dfd.callback(dfd);
                }else{
                        dfd.errback(new Error("bad http response code:" + dfd.ioArgs.xhr.status));
                }
        }

        var _doIt = function(/*String*/type, /*Deferred*/dfd){
                // IE 6 is a steaming pile. It won't let you call apply() on the native function (xhr.open).
                // workaround for IE6's apply() "issues"
                var ioArgs = dfd.ioArgs;
                var args = ioArgs.args;
                ioArgs.xhr.open(type, ioArgs.url, args.sync !== true, args.user || undefined, args.password || undefined);
                if(args.headers){
                        for(var hdr in args.headers){
                                if(hdr.toLowerCase() === "content-type" && !args.contentType){
                                        args.contentType = args.headers[hdr];
                                }else{
                                        ioArgs.xhr.setRequestHeader(hdr, args.headers[hdr]);
                                }
                        }
                }
                // FIXME: is this appropriate for all content types?
                ioArgs.xhr.setRequestHeader("Content-Type", (args.contentType||_defaultContentType));
                // FIXME: set other headers here!
                try{
                        ioArgs.xhr.send(ioArgs.query);
                }catch(e){
                        dfd.cancel();
                }
                _d._ioWatch(dfd, _validCheck, _ioCheck, _resHandle);
                return dfd; //Deferred
        }

        dojo._ioAddQueryToUrl = function(/*dojo.__ioCallbackArgs*/ioArgs){
                //summary: Adds query params discovered by the io deferred construction to the URL.
                //Only use this for operations which are fundamentally GET-type operations.
                if(ioArgs.query.length){
                        ioArgs.url += (ioArgs.url.indexOf("?") == -1 ? "?" : "&") + ioArgs.query;
                        ioArgs.query = null;
                }               
        }

        /*=====
        dojo.__xhrArgs = function(kwArgs){
                //      summary:
                //              In addition to the properties listed for the dojo.__ioArgs type,
                //              the following properties are allowed for dojo.xhr* methods.
                //      handleAs: 
                //              String. Acceptable values are:
                //                      "text" (default)
                //                      "json"
                //                      "json-comment-optional"
                //                      "json-comment-filtered"
                //                      "javascript"
                //                      "xml"
                //      sync:
                //              Boolean. false is default. Indicates whether the request should
                //              be a synchronous (blocking) request.
                //      headers:
                //              Object. Additional HTTP headers to send in the request.
        }
        =====*/

        dojo.xhrGet = function(/*dojo.__xhrArgs*/ args){
                //      summary: 
                //              Sends an HTTP GET request to the server.
                var dfd = _makeXhrDeferred(args);
                _d._ioAddQueryToUrl(dfd.ioArgs);
                return _doIt("GET", dfd); // dojo.Deferred
        }

        dojo.xhrPost = function(/*dojo.__xhrArgs*/ args){
                //summary: 
                //              Sends an HTTP POST request to the server.
                return _doIt("POST", _makeXhrDeferred(args)); // dojo.Deferred
        }

        dojo.rawXhrPost = function(/*dojo.__xhrArgs*/ args){
                //      summary:
                //              Sends an HTTP POST request to the server. In addtion to the properties
                //              listed for the dojo.__xhrArgs type, the following property is allowed:
                //      postData:
                //              String. The raw data to send in the body of the POST request.
                var dfd = _makeXhrDeferred(args);
                dfd.ioArgs.query = args.postData;
                return _doIt("POST", dfd); // dojo.Deferred
        }

        dojo.xhrPut = function(/*dojo.__xhrArgs*/ args){
                //      summary:
                //              Sends an HTTP PUT request to the server.
                return _doIt("PUT", _makeXhrDeferred(args)); // dojo.Deferred
        }

        dojo.rawXhrPut = function(/*dojo.__xhrArgs*/ args){
                //      summary:
                //              Sends an HTTP PUT request to the server. In addtion to the properties
                //              listed for the dojo.__xhrArgs type, the following property is allowed:
                //      putData:
                //              String. The raw data to send in the body of the PUT request.
                var dfd = _makeXhrDeferred(args);
                var ioArgs = dfd.ioArgs;
                if(args["putData"]){
                        ioArgs.query = args.putData;
                        args.putData = null;
                }
                return _doIt("PUT", dfd); // dojo.Deferred
        }

        dojo.xhrDelete = function(/*dojo.__xhrArgs*/ args){
                //      summary:
                //              Sends an HTTP DELETE request to the server.
                var dfd = _makeXhrDeferred(args);
                _d._ioAddQueryToUrl(dfd.ioArgs);
                return _doIt("DELETE", dfd); // dojo.Deferred
        }

        /*
        dojo.wrapForm = function(formNode){
                //summary:
                //              A replacement for FormBind, but not implemented yet.

                // FIXME: need to think harder about what extensions to this we might
                // want. What should we allow folks to do w/ this? What events to
                // set/send?
                throw new Error("dojo.wrapForm not yet implemented");
        }
        */
})();

}