//  Example stubs for TempRetriever operations.  This function is not intended 
//  to be called, but rather as a source for copy-and-paste development.

//  Note that this stub has been generated for use in DOM environments.


function stubs() {
    // callMyService operation
    try {
        /* string */ 
        var callMyServiceReturn = TempRetriever.callMyService(/* string */ param_input);
    } catch (e) {
        // fault handling
    }

}
stubs.visible = false;

var TempRetriever = new WebService("TempRetrieverSOAP12Endpoint");

TempRetriever.callMyService =
    function callMyService(/* string */ _input)
    {
        var isAsync, request, response, resultValue;
        this._options = new Array();
        isAsync = (this.callMyService.callback != null && typeof(this.callMyService.callback) == 'function');
        request = this.callMyService_payload(/* string */ _input);
        
        if (isAsync) {
            try {
                this._call(
                    "callMyService",
                    request,
                    function(thisRequest, callbacks) {
                        if (thisRequest.error != null) {
                            callbacks[1](thisRequest.error);
                        } else {
                            response = thisRequest.responseXML;
                            if (response == null) {
                                resultValue = null;
                            } else {
                                var extractedValue = WSRequest.util._stringValue(response.documentElement);
                                resultValue = /* string */ extractedValue;
                            }
                            callbacks[0](resultValue);
                        }
                    },
                    new Array(this.callMyService.callback, this.callMyService.onError)
                );
            } catch (e) {
                var error;
                if (WebServiceError.prototype.isPrototypeOf(e)) {
                    error = e;
                } else if (typeof(e) == "string") {
                    error = new WebServiceError(e, "Internal Error");
                } else {
                    error = new WebServiceError(e.description, e.number, e.number);
                }
                this.callMyService.onError(error);
            }
        } else {
            try {
                                response = this._call("callMyService", request);
                                var extractedValue = WSRequest.util._stringValue(response.documentElement);
                                resultValue = /* string */ extractedValue;
                                return resultValue;
            } catch (e) {
                if (typeof(e) == "string") throw(e);
                if (e.message) throw(e.message);
                throw (e.reason + e.detail);
            }
        }
        return null; // Suppress warnings when there is no return.
    }
TempRetriever.callMyService_payload =
    function (/* string */ _input) {
        
        return '<p:callMyService xmlns:p="http://services.mashup.wso2.org/TempRetriever?xsd">' +
                (_input == null ? '' : '<input>' + this._encodeXML(_input) + '</input>') +
            '</p:callMyService>' ;
    }
TempRetriever.callMyService_payload.visible = false;

TempRetriever.callMyService.callback = null;



// WebService object.
function WebService(endpointName)
{
    this.readyState = 0;
    this.onreadystatechange = null;
    
    //public accessors for manually intervening in setting the address (e.g. supporting tcpmon)
    this.getAddress = function (endpointName)
    {
        return this._endpointDetails[endpointName].address;
    }
    
    this.setAddress = function (endpointName, address)
    {
        this._endpointDetails[endpointName].address = address;
    }

    // private helper functions
    this._getWSRequest = function()
    {
        var wsrequest;
        try {
            wsrequest = new WSRequest();
        } catch(e) {
            try {
                wsrequest = new ActiveXObject("WSRequest");
            } catch(e) {
                try {
                    wsrequest = new SOAPHttpRequest();
                    netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
                } catch (e) {
                    throw new WebServiceError("WSRequest object not defined.", "WebService._getWSRequest() cannot instantiate WSRequest object.");
                }
            }
        }
        return wsrequest;
    }
        
    this._endpointDetails = 
        {
            "TempRetrieverSOAP12Endpoint": {
                "type" : "SOAP12",
                "address" : "http://zneta:7762/services/kshaikh/TempRetriever",
                "action" : {
                    "callMyService" : "http://services.mashup.wso2.org/TempRetriever/ServiceInterface/callMyServiceRequest"
                },
                "soapaction" : {
                    "callMyService" : "http://services.mashup.wso2.org/TempRetriever/ServiceInterface/callMyServiceRequest"
                },
                "httplocation" : {
                    "callMyService" : "TempRetriever/callMyService"
                }
            },
            "SecureTempRetrieverSOAP12Endpoint": {
                "type" : "SOAP12",
                "address" : "https://zneta:7443/services/kshaikh/TempRetriever",
                "action" : {
                    "callMyService" : "http://services.mashup.wso2.org/TempRetriever/ServiceInterface/callMyServiceRequest"
                },
                "soapaction" : {
                    "callMyService" : "http://services.mashup.wso2.org/TempRetriever/ServiceInterface/callMyServiceRequest"
                },
                "httplocation" : {
                    "callMyService" : "TempRetriever/callMyService"
                }
            },
            "TempRetrieverSOAP11Endpoint": {
                "type" : "SOAP11",
                "address" : "http://zneta:7762/services/kshaikh/TempRetriever",
                "action" : {
                    "callMyService" : "http://services.mashup.wso2.org/TempRetriever/ServiceInterface/callMyServiceRequest"
                },
                "soapaction" : {
                    "callMyService" : "http://services.mashup.wso2.org/TempRetriever/ServiceInterface/callMyServiceRequest"
                },
                "httplocation" : {
                    "callMyService" : "TempRetriever/callMyService"
                }
            },
            "SecureTempRetrieverSOAP11Endpoint": {
                "type" : "SOAP11",
                "address" : "https://zneta:7443/services/kshaikh/TempRetriever",
                "action" : {
                    "callMyService" : "http://services.mashup.wso2.org/TempRetriever/ServiceInterface/callMyServiceRequest"
                },
                "soapaction" : {
                    "callMyService" : "http://services.mashup.wso2.org/TempRetriever/ServiceInterface/callMyServiceRequest"
                },
                "httplocation" : {
                    "callMyService" : "TempRetriever/callMyService"
                }
            },
            "TempRetrieverHTTPEndpoint": {
                "type" : "HTTP",
                "address" : "http://zneta:7762/services/kshaikh/TempRetriever",
                "httplocation" : {
                    "callMyService" : "TempRetriever/callMyService"
                },
                "httpmethod" : {
                        "callMyService" : "POST"
                },
                "fitsInURLParams" : {
                        "callMyService" : true
                }
            },
            "SecureTempRetrieverHTTPEndpoint": {
                "type" : "HTTP",
                "address" : "https://zneta:7443/services/kshaikh/TempRetriever",
                "httplocation" : {
                    "callMyService" : "TempRetriever/callMyService"
                },
                "httpmethod" : {
                        "callMyService" : "POST"
                },
                "fitsInURLParams" : {
                        "callMyService" : true
                }
            }
    };
    this.endpoint = endpointName;

    this._encodeXML = function (value) {
        var str = value.toString();
        str = str.replace(/&/g, "&amp;");
        str = str.replace(/</g, "&lt;");
        return(str);
    };

    this._setOptions = function (details, opName) {
        var options = new Array();

        if (details.type == 'SOAP12') options.useSOAP = 1.2;
        else if (details.type == 'SOAP11') options.useSOAP = 1.1;
        else if (details.type == 'HTTP') options.useSOAP = false;

        if (details.action != null) {
            options.useWSA = true;
            options.action = details.action[opName];
        } else if (details.soapaction != null) {
            options.useWSA = false;
            options.action = details.soapaction[opName];
        } else {
            options.useWSA = false;
            options.action = undefined;
        }

        if (details["httpmethod"] != null) {
            options.HTTPMethod = details.httpmethod[opName];
        } else {
            options.HTTPMethod = null;
        }

        if (details["httpinputSerialization"] != null) {
            options.HTTPInputSerialization = details.httpinputSerialization[opName];
        } else {
            options.HTTPInputSerialization= null;
        }

        if (details["httplocation"] != null) {
            options.HTTPLocation = details.httplocation[opName];
        } else {
            options.HTTPLocation = null;
        }

        if (details["httpignoreUncited"] != null) {
            options.HTTPLocationIgnoreUncited = details.httpignoreUncited[opName];
        } else {
            options.HTTPLocationIgnoreUncited = null;
        }

        if (details["httpqueryParameterSeparator"] != null) {
            options.HTTPQueryParameterSeparator = details.httpqueryParameterSeparator[opName];
        } else {
            options.HTTPQueryParameterSeparator = null;
        }

        return options;
    };

    this._call = function (opName, reqContent, callback, userdata)
    {
        var details = this._endpointDetails[this.endpoint];
        this._options = this._setOptions(details, opName);

        var isAsync = (typeof(callback) == 'function');
        
        var thisRequest = this._getWSRequest();
        if (isAsync) {
            thisRequest._userdata = userdata;
            thisRequest.onreadystatechange = 
                function() {
                    if (thisRequest.readyState == 4) {
                        callback(thisRequest, userdata);
                    }
                }
        }
        thisRequest.open(this._options, details.address, isAsync);
        thisRequest.send(reqContent);
        if (isAsync) {
            return "";
        } else {
            try {
                var resultContent = thisRequest.responseText;
                if (resultContent == "") { 
                    throw new WebServiceError("No response", "WebService._call() did not recieve a response to a synchronous request.");
                }
                var resultXML = thisRequest.responseXML;
            } catch (e) {
                throw new WebServiceError(e);
            }
            return resultXML;
        }
    };
}
WebService.visible = false;

WebService.utils = {
    toXSdate : function (thisDate) {
        var year = thisDate.getUTCFullYear();
        var month = thisDate.getUTCMonth() + 1;
        var day = thisDate.getUTCDate();

        return year + "-" +
            (month < 10 ? "0" : "") + month + "-" +
            (day < 10 ? "0" : "") + day + "Z";
    },

    toXStime : function (thisDate) {
        var hours = thisDate.getUTCHours();
        var minutes = thisDate.getUTCMinutes();
        var seconds = thisDate.getUTCSeconds();
        var milliseconds = thisDate.getUTCMilliseconds();

        return (hours < 10 ? "0" : "") + hours + ":" +
            (minutes < 10 ? "0" : "") + minutes + ":" +
            (seconds < 10 ? "0" : "") + seconds +
            (milliseconds == 0 ? "" : (milliseconds/1000).toString().substring(1)) + "Z";
    },

    toXSdateTime : function (thisDate) {
        var year = thisDate.getUTCFullYear();
        var month = thisDate.getUTCMonth() + 1;
        var day = thisDate.getUTCDate();
        var hours = thisDate.getUTCHours();
        var minutes = thisDate.getUTCMinutes();
        var seconds = thisDate.getUTCSeconds();
        var milliseconds = thisDate.getUTCMilliseconds();

        return year + "-" +
            (month < 10 ? "0" : "") + month + "-" +
            (day < 10 ? "0" : "") + day + "T" +
            (hours < 10 ? "0" : "") + hours + ":" +
            (minutes < 10 ? "0" : "") + minutes + ":" +
            (seconds < 10 ? "0" : "") + seconds +
            (milliseconds == 0 ? "" : (milliseconds/1000).toString().substring(1)) + "Z";
    },

    parseXSdateTime : function (dateTime) {
        var buffer = dateTime;
        var p = 0; // pointer to current parse location in buffer.

        var era, year, month, day, hour, minute, second, millisecond;

        // parse date, if there is one.
        if (buffer.substr(p,1) == '-')
        {
            era = -1;
            p++;
        } else {
            era = 1;
        }

        if (buffer.charAt(p+2) != ':')
        {
            year = era * buffer.substr(p,4);
            p += 5;
            month = buffer.substr(p,2);
            p += 3;
            day = buffer.substr(p,2);
            p += 3;
        } else {
            year = 1970;
            month = 1;
            day = 1;
        }

        // parse time, if there is one
        if (buffer.charAt(p) != '+' && buffer.charAt(p) != '-')
        {
            hour = buffer.substr(p,2);
            p += 3;
            minute = buffer.substr(p,2);
            p += 3;
            second = buffer.substr(p,2);
            p += 2;
            if (buffer.charAt(p) == '.')
            {
                millisecond = parseFloat(buffer.substr(p))*1000;
                // Note that JS fractional seconds are significant to 3 places - xs:time is significant to more -
                // though implementations are only required to carry 3 places.
                p++;
                while (buffer.charCodeAt(p) >= 48 && buffer.charCodeAt(p) <= 57) p++;
            } else {
                millisecond = 0;
            }
        } else {
            hour = 0;
            minute = 0;
            second = 0;
            millisecond = 0;
        }

        var tzhour = 0;
        var tzminute = 0;
        // parse time zone
        if (buffer.charAt(p) != 'Z' && buffer.charAt(p) != '') {
            var sign = (buffer.charAt(p) == '-' ? -1 : +1);
            p++;
            tzhour = sign * buffer.substr(p,2);
            p += 3;
            tzminute = sign * buffer.substr(p,2);
        }

        var thisDate = new Date();
        thisDate.setUTCFullYear(year);
        thisDate.setUTCMonth(month-1);
        thisDate.setUTCDate(day);
        thisDate.setUTCHours(hour);
        thisDate.setUTCMinutes(minute);
        thisDate.setUTCSeconds(second);
        thisDate.setUTCMilliseconds(millisecond);
        thisDate.setUTCHours(thisDate.getUTCHours() - tzhour);
        thisDate.setUTCMinutes(thisDate.getUTCMinutes() - tzminute);
        return thisDate;
    },

    _nextPrefixNumber : 0,

    _QNameNamespaceDecl : function (qn) {
        if (qn.uri == null) return "";
        var prefix = qn.localName.substring(0, qn.localName.indexOf(":"));
        if (prefix == "") {
            prefix = "n" + ++this.utils._nextPrefixNumber;
        }
        return ' xmlns:' + prefix + '="' + qn.uri + '"';
    },

    _QNameValue : function(qn) {
        if (qn.uri == null) return qn.localName;
        var prefix, localName;
        if (qn.localName.indexOf(":") >= 0) {
            prefix = qn.localName.substring(0, qn.localName.indexOf(":"));
            localName = qn.localName.substring(qn.localName.indexOf(":")+1);
        } else {
            prefix = "n" + this.utils._nextPrefixNumber;
            localName = qn.localName;
        }
        return prefix + ":" + localName;
    },

    scheme : function (url) {
        var s = url.substring(0, url.indexOf(':'));
        return s;
    },

    domain : function (url) {
        var d = url.substring(url.indexOf('://') + 3, url.indexOf('/',url.indexOf('://')+3));
        return d;
    },

    domainNoPort : function (url) {
        var d = this.domain(url);
        if (d.indexOf(":") >= 0)
        d = d.substring(0, d.indexOf(':'));
        return d;
    }


};
        
// library function for dynamically serializing an anyType value in xml, including setting xsi:type.
function serializeAnytype(name, value, namespace) {
    var type = "xs:string";
    if (value == null) {
        value = "";
    } else if (typeof(value) == "number") {
        type = "xs:double";
    } else if (typeof(value) == "object" && value.nodeType != undefined) {
        type = "xs:anyType";
        value = serializeXML(value);
    } else if (typeof(value) == "boolean") {
        type = "xs:boolean";
    } else if (typeof(value) == "object" && Date.prototype.isPrototypeOf(value)) {
        type = "xs:dateTime";
        value = WebService.utils.toXSdateTime(value);
    } else if (value.match(/^\s*true\s*$/g) != null) {
        type = "xs:boolean";
    } else if (value.match(/^\s*false\s*$/g) != null) {
        type = "xs:boolean";
    } else if (!isNaN(Date.parse(value))) {
        type = "xs:dateTime";
        value = WebService.utils.toXSdateTime(new Date(Date.parse(value)));
    } else if (value.match(/^\s*\-?\d*\-\d\d\-\d\dZ?\s*$/g) != null) {
        type = "xs:date";
    } else if (value.match(/^\s*\-?\d*\-\d\d\-\d\d[\+\-]\d\d:\d\d\s*$/g) != null) {
        type = "xs:date";
    } else if (value.match(/^\s*\d\d:\d\d:\d\d\.?\d*Z?\s*$/g) != null) {
        type = "xs:time";
    } else if (value.match(/^\s*\d\d:\d\d:\d\d\.?\d*[\+\-]\d\d:\d\d\s*$/g) != null) {
        type = "xs:time";
    } else if (value.match(/^\s*\-?\d*\-\d\d\-\d\dT\d\d:\d\d:\d\d\.?\d*Z?\s*$/g) != null) {
        type = "xs:dateTime";
    } else if (value.match(/^\s*\-?\d*\-\d\d\-\d\dT\d\d:\d\d:\d\d\.?\d*[\+\-]\d\d:\d\d\s*$/g) != null) {
        type = "xs:dateTime";
    } else if (value.match(/^\s*\d\d*\.?\d*\s*$/g) != null) {
        type = "xs:double";
    } else if (value.match(/^\s*\d*\.?\d\d*\s*$/g) != null) {
        type = "xs:double";
    } else if (value.match(/^\s*\</g) != null) {

        var browser = WSRequest.util._getBrowser();
        var parseTest;
        if (browser == "ie" || browser == "ie7") {
            parseTest = new ActiveXObject("Microsoft.XMLDOM");
            parseTest.loadXML(value);
            if (parseTest.parseError == 0)
                type = "xs:anyType";
        } else {
            var parser = new DOMParser();
            parseTest = parser.parseFromString(value,"text/xml");
            if (parseTest.documentElement.nodeName != "parsererror" || parseTest.documentElement.namespaceURI != "http://www.mozilla.org/newlayout/xml/parsererror.xml")
                type = "xs:anyType";
        }
    
    }
    if (type == "xs:string") {
        value = TempRetriever._encodeXML(value);
    }
    var starttag =   "<" + name +
                 (namespace == "" ? "" : " xmlns='" + namespace + "'") +
                 " xsi:type='" + type + "'" +
                 " xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'" +
                 ">";
    var endtag = "</" + name + ">";
    return starttag + value + endtag;
}
serializeAnytype.visible = false;

// library function for dynamically converting an element with js:type annotation to a Javascript type.
function convertJSType(element, isWrapped) {
    if (element == null) return "";
    var extractedValue = WSRequest.util._stringValue(element);
    var resultValue, i;
    var type = element.getAttribute("js:type");
    if (type == null) {
        type = "xml";
    } else {
        type = type.toString();
    }
    switch (type) {
        case "string":
            return extractedValue;
            break;
        case "number":
            return parseFloat(extractedValue);
            break;
        case "boolean":
            return extractedValue == "true" || extractedValue == "1";
            break;
        case "date":
            return WebService.utils.parseXSdateTime(extractedValue);
            break;
        case "array":
            resultValue = new Array();
            for (i=0; i<element.childNodes.length; i++) {
                resultValue = resultValue.concat(convertJSType(element.childNodes[i]));
            }
            return(resultValue);
            break;
        case "object":
            resultValue = new Object();
            for (i=0; i<element.childNodes.length; i++) {
                resultValue[element.childNodes[i].tagName] = convertJSType(element.childNodes[i]);
            }
            return(resultValue);
            break;
        case "xmlList":
            return element.childNodes;
            break;
        case "xml":
        default:
            if (isWrapped == true)
                return element.firstChild;
            else return element;
            break;
    }
}
convertJSType.visible = false;

// URL fixup code for a browser.  All variables prefixed with "_fix_" to avoid conflicts with user's local variables.
try {
    var _fix_secureEndpoint = "";
    var _fix_pageUrl = document.URL;
    var _fix_pageScheme = WebService.utils.scheme(_fix_pageUrl);
    // only attempt fixup if we're from an http/https domain ('file:' works fine on IE without fixup)
    if (_fix_pageScheme == "http" || _fix_pageScheme == "https") {
        var _fix_pageDomain = WebService.utils.domain(_fix_pageUrl);
        var _fix_pageDomainNoPort = WebService.utils.domainNoPort(_fix_pageUrl);
        var _fix_endpoints = TempRetriever._endpointDetails;
        // loop through each available endpoint
        for (var _fix_i in _fix_endpoints) {
            var _fix_address = _fix_endpoints[_fix_i].address;
            // if we're in a secure domain, set the endpoint to the first secure endpoint we come across
            if (_fix_secureEndpoint == "" && _fix_pageScheme == "https" && WebService.utils.scheme(_fix_address) == "https") {
                _fix_secureEndpoint = _fix_i;
                TempRetriever.endpoint = _fix_secureEndpoint;
            }
            // if we're in a known localhost domain, rewrite the endpoint domain so that we won't get
            //  a bogus xss violation
            if (_fix_pageDomainNoPort.indexOf('localhost') == 0 || _fix_pageDomainNoPort.indexOf('127.0.0.1') == 0 ) {
                    _fix_endpoints[_fix_i].address = _fix_address.replace(WebService.utils.domainNoPort(_fix_address), _fix_pageDomainNoPort);
            }
        }
    }
} catch (e) { }