microsoftajaxadonet.debug.js

ajax

    this._headers = httpHeaders || {};
    this._actionContext = actionContext;
    this._operation = operation;
}
    function Sys$Data$AdoNetActionResult$get_httpHeaders() {
        /// <value type="Object" locid="P:J#Sys.Data.AdoNetActionResult.httpHeaders"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._headers;
    }
    function Sys$Data$AdoNetActionResult$get_actionContext() {
        /// <value mayBeNull="true" locid="P:J#Sys.Data.AdoNetActionResult.actionContext"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._actionContext;
    }
    function Sys$Data$AdoNetActionResult$get_operation() {
        /// <value type="String" locid="P:J#Sys.Data.AdoNetActionResult.operation"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._operation;
    }
    function Sys$Data$AdoNetActionResult$get_result() {
        /// <value type="Object" mayBeNull="true" locid="P:J#Sys.Data.AdoNetActionResult.result"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._result;
    }
Sys.Data.AdoNetActionResult.prototype = {
    _actionContext: null,
    _operation: null,
    _result: null,
    _headers: null,
    get_httpHeaders: Sys$Data$AdoNetActionResult$get_httpHeaders,
    get_actionContext: Sys$Data$AdoNetActionResult$get_actionContext,
    get_operation: Sys$Data$AdoNetActionResult$get_operation,
    get_result: Sys$Data$AdoNetActionResult$get_result
}
Sys.Data.AdoNetActionResult.registerClass("Sys.Data.AdoNetActionResult");
Sys.Data.AdoNetActionSequence = function Sys$Data$AdoNetActionSequence(dataService) {
    /// <summary locid="M:J#Sys.Data.AdoNetActionSequence.#ctor" />
    /// <param name="dataService" type="Sys.Data.AdoNetServiceProxy"></param>
    var e = Function._validateParams(arguments, [
        {name: "dataService", type: Sys.Data.AdoNetServiceProxy}
    ]);
    if (e) throw e;
    this._actionQueue = [];
    this._dataService = dataService;
}
    function Sys$Data$AdoNetActionSequence$get_serviceProxy() {
        /// <value type="Sys.Data.AdoNetServiceProxy" locid="P:J#Sys.Data.AdoNetActionSequence.serviceProxy"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._dataService;
    }
    function Sys$Data$AdoNetActionSequence$addInsertAction(item, resourceSetUri, actionContext) {
        /// <summary locid="M:J#Sys.Data.AdoNetActionSequence.addInsertAction" />
        /// <param name="item" type="Object"></param>
        /// <param name="resourceSetUri" type="String" mayBeNull="true"></param>
        /// <param name="actionContext" mayBeNull="true" optional="true"></param>
        var e = Function._validateParams(arguments, [
            {name: "item", type: Object},
            {name: "resourceSetUri", type: String, mayBeNull: true},
            {name: "actionContext", mayBeNull: true, optional: true}
        ]);
        if (e) throw e;
        var queue = this._actionQueue;
        queue[queue.length] = [0, resourceSetUri, item, actionContext];
    }
    function Sys$Data$AdoNetActionSequence$addUpdateAction(item, updateItemUri, actionContext) {
        /// <summary locid="M:J#Sys.Data.AdoNetActionSequence.addUpdateAction" />
        /// <param name="item" type="Object"></param>
        /// <param name="updateItemUri" type="String" optional="true" mayBeNull="true"></param>
        /// <param name="actionContext" mayBeNull="true" optional="true"></param>
        var e = Function._validateParams(arguments, [
            {name: "item", type: Object},
            {name: "updateItemUri", type: String, mayBeNull: true, optional: true},
            {name: "actionContext", mayBeNull: true, optional: true}
        ]);
        if (e) throw e;
        var queue = this._actionQueue;
        queue[queue.length] = [1, updateItemUri || null, item, actionContext];
    }
    function Sys$Data$AdoNetActionSequence$addRemoveAction(item, actionContext) {
        /// <summary locid="M:J#Sys.Data.AdoNetActionSequence.addRemoveAction" />
        /// <param name="item" type="Object" mayBeNull="true"></param>
        /// <param name="actionContext" mayBeNull="true" optional="true"></param>
        var e = Function._validateParams(arguments, [
            {name: "item", type: Object, mayBeNull: true},
            {name: "actionContext", mayBeNull: true, optional: true}
        ]);
        if (e) throw e;
        var queue = this._actionQueue;
        queue[queue.length] = [2, null, item, actionContext];
    }
    function Sys$Data$AdoNetActionSequence$clearActions() {
        /// <summary locid="M:J#Sys.Data.AdoNetActionSequence.clearActions" />
        if (arguments.length !== 0) throw Error.parameterCount();
        this._actionQueue = [];
    }
    function Sys$Data$AdoNetActionSequence$execute(succeededCallback, failedCallback, userContext) {
        /// <summary locid="M:J#Sys.Data.AdoNetActionSequence.execute" />
        /// <param name="succeededCallback" type="Function" mayBeNull="true" optional="true"></param>
        /// <param name="failedCallback" type="Function" mayBeNull="true" optional="true"></param>
        /// <param name="userContext" mayBeNull="true" optional="true"></param>
        /// <returns type="Sys.Net.WebRequest"></returns>
        var e = Function._validateParams(arguments, [
            {name: "succeededCallback", type: Function, mayBeNull: true, optional: true},
            {name: "failedCallback", type: Function, mayBeNull: true, optional: true},
            {name: "userContext", mayBeNull: true, optional: true}
        ]);
        if (e) throw e;
        var queue = this._actionQueue,
            bw = new Sys.Data._AdoNetBatchWriter(window.location.host),
            ds = this._dataService;
        this._actionQueue = [];
        
        bw.startChangeSet();
        for (var i = 0, l = queue.length; i < l; i++) {
            var action = queue[i],
                uri = action[1],
                item = action[2],
                eTag = Sys.Data._AdoNetUtil.extractETag(item);
            switch (action[0]) {
                case 0:
                    action[0] = "insert";
                    bw.addChange(uri, eTag, "POST", Sys.Serialization.JavaScriptSerializer.serialize(item), i);
                    break;
                case 1:
                    action[0] = "edit";
                    if (!uri) {
                        uri = Sys.Data._AdoNetUtil.extractUri(item);
                    }
                    bw.addChange(uri, eTag, ds.get_replaceOnUpdate() ? "PUT" : "MERGE", Sys.Serialization.JavaScriptSerializer.serialize(item));
                    break;
                case 2:
                    action[0] = "remove";
                    uri = Sys.Data._AdoNetUtil.extractUri(item);
                    bw.addChange(uri, eTag, "DELETE", null);
                    break;
            }
        }
        bw.endChangeSet();
        var r = new Sys.Net.WebRequest();
        r.set_url(Sys.Data._AdoNetUtil.concatUris(ds.get_serviceUri(), "$batch"));
        r.get_headers()["Content-Type"] = "multipart/mixed; boundary=" + bw.get_topBoundary();
        r.set_httpVerb("POST");
        r.set_timeout(ds.get_timeout());
        r.set_body(bw.get_requestBody());
        r.set_userContext({ q: queue, bw: bw, c: userContext, s: succeededCallback, f: failedCallback });
        r.add_completed(Function.createDelegate(this, this._batchCompleted));
        r.invoke();
        return r;
    }
    function Sys$Data$AdoNetActionSequence$_batchCompleted(executor) {
        var data, responses, response,
            ctx = executor.get_webRequest().get_userContext(),
            queue = ctx.q,
            onFailed = ctx.f,
            onSuccess = ctx.s,
            userContext = ctx.c,
            bw = ctx.bw,
            dsError = this._dataService._checkForError(executor, "actionSequence", false);
            
        function checkPartForError() {
            var status = response.status ? parseFloat(response.status.code) : -1;
            if (status < 200 || status > 300) {
                var message;
                if (response.headers["Content-Type"] === "application/json") {
                    var errorObj = Sys.Serialization.JavaScriptSerializer.deserialize(response.body);
                    dsError = Sys.Data.AdoNetServiceError._getError(false, status, null, errorObj, "actionSequence");
                }
                else {
                    dsError = Sys.Data.AdoNetServiceError._getError(false, status, String.format(Sys.Data.AdoNetRes.operationFailed, "actionSequence"));
                }
            }
        }
        function doError() {
            if (onFailed) {
                onFailed(dsError, userContext, "actionSequence");
            }
            else {
                throw Sys.Data.AdoNetServiceProxy._createFailedError("actionSequence", dsError.get_message());
            }
        }
        
        if (dsError) {
            doError();
            return;
        }
        
        responses = Sys.Data._AdoNetBatchReader._parseResponse(executor);
        if (responses.length !== 1) {
            dsError = Sys.Data.AdoNetServiceError._getError(false, -1,
                String.format(Sys.Data.AdoNetRes.invalidBatchResponse, executor.get_webRequest().get_url()));
            doError();
            return;
        }
        responses = responses[0];
        if (responses.length === 1) {
            response = responses[0];
            checkPartForError();
            if (dsError) {
                doError();
                return;
            }
        }
        if (responses.length !== queue.length) {
            dsError = Sys.Data.AdoNetServiceError._getError(false, -1, 
                String.format(Sys.Data.AdoNetRes.invalidBatchResponse, executor.get_webRequest().get_url()));
            doError();
            return;
        }
        
        
        if (onSuccess) {
            var l = responses.length,
                results = new Array(l);
            for (var i = 0; i < l; i++) {
                response = responses[i], body = response.body;
                data = null;
                if (body) {
                    data = Sys.Serialization.JavaScriptSerializer.deserialize(body);
                    if (data && data.d) {
                        data = data.d;
                    }
                }
                var queueEntry = queue[i],
                    actionContext = queueEntry[3],
                    operation = queueEntry[0];
                if (typeof(actionContext) === "undefined") {
                    actionContext = null;
                }
                results[i] = new Sys.Data.AdoNetActionResult(data, response.headers, actionContext, operation);
            }
            onSuccess(results, userContext, "actionSequence");
        }
    }
Sys.Data.AdoNetActionSequence.prototype = {
    get_serviceProxy: Sys$Data$AdoNetActionSequence$get_serviceProxy,
    addInsertAction: Sys$Data$AdoNetActionSequence$addInsertAction,
    addUpdateAction: Sys$Data$AdoNetActionSequence$addUpdateAction,
    addRemoveAction: Sys$Data$AdoNetActionSequence$addRemoveAction,
    clearActions: Sys$Data$AdoNetActionSequence$clearActions,
    execute: Sys$Data$AdoNetActionSequence$execute,
    _batchCompleted: Sys$Data$AdoNetActionSequence$_batchCompleted
}
Sys.Data.AdoNetActionSequence.registerClass("Sys.Data.AdoNetActionSequence");
Sys.Data.AdoNetInvokeParametersBuilder = function Sys$Data$AdoNetInvokeParametersBuilder() {
    /// <summary locid="M:J#Sys.Data.AdoNetInvokeParametersBuilder.#ctor" />
    if (arguments.length !== 0) throw Error.parameterCount();
    
    this._queryBuilder = new Sys.Data.AdoNetQueryBuilder("");
    this._parameters = this._queryBuilder.get_queryParameters();
}
    function Sys$Data$AdoNetInvokeParametersBuilder$get_parameters() {
        /// <value locid="P:J#Sys.Data.AdoNetInvokeParametersBuilder.parameters"></value>
        if (arguments.length !== 0) throw Error.parameterCount();
        return this._parameters;
    }
    function Sys$Data$AdoNetInvokeParametersBuilder$addBoolean(name, value) {
        /// <summary locid="M:J#Sys.Data.AdoNetInvokeParametersBuilder.addBoolean" />