| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| var utils = require('./../datajs.js').utils; |
| var oDataUtils = require('./utils.js'); |
| |
| // Imports. |
| var assigned = utils.assigned; |
| var extend = utils.extend; |
| var trimString = utils.trimString; |
| var maxVersion = oDataUtils.maxVersion; |
| var MAX_DATA_SERVICE_VERSION = "4.0"; |
| |
| /** Parses a string into an object with media type and properties. |
| * @param {String} str - String with media type to parse. |
| * @return null if the string is empty; an object with 'mediaType' and a 'properties' dictionary otherwise. |
| */ |
| var contentType = function (str) { |
| |
| if (!str) { |
| return null; |
| } |
| |
| var contentTypeParts = str.split(";"); |
| var properties = {}; |
| |
| var i, len; |
| for (i = 1, len = contentTypeParts.length; i < len; i++) { |
| var contentTypeParams = contentTypeParts[i].split("="); |
| properties[trimString(contentTypeParams[0])] = contentTypeParams[1]; |
| } |
| |
| return { mediaType: trimString(contentTypeParts[0]), properties: properties }; |
| }; |
| |
| /** Serializes an object with media type and properties dictionary into a string. |
| * @param contentType - Object with media type and properties dictionary to serialize. |
| * @return String representation of the media type object; undefined if contentType is null or undefined.</returns> |
| */ |
| var contentTypeToString = function (contentType) { |
| if (!contentType) { |
| return undefined; |
| } |
| |
| var result = contentType.mediaType; |
| var property; |
| for (property in contentType.properties) { |
| result += ";" + property + "=" + contentType.properties[property]; |
| } |
| return result; |
| }; |
| |
| /** Creates an object that is going to be used as the context for the handler's parser and serializer. |
| * @param contentType - Object with media type and properties dictionary. |
| * @param {String} dataServiceVersion - String indicating the version of the protocol to use. |
| * @param context - Operation context. |
| * @param handler - Handler object that is processing a resquest or response. |
| * @return Context object.</returns> |
| */ |
| var createReadWriteContext = function (contentType, dataServiceVersion, context, handler) { |
| |
| var rwContext = {}; |
| extend(rwContext, context); |
| extend(rwContext, { |
| contentType: contentType, |
| dataServiceVersion: dataServiceVersion, |
| handler: handler |
| }); |
| |
| return rwContext; |
| }; |
| |
| /** Sets a request header's value. If the header has already a value other than undefined, null or empty string, then this method does nothing. |
| * @param request - Request object on which the header will be set. |
| * @param {String} name - Header name. |
| * @param {String} value - Header value. |
| */ |
| var fixRequestHeader = function (request, name, value) { |
| if (!request) { |
| return; |
| } |
| |
| var headers = request.headers; |
| if (!headers[name]) { |
| headers[name] = value; |
| } |
| }; |
| |
| /** Sets the DataServiceVersion header of the request if its value is not yet defined or of a lower version. |
| * @param request - Request object on which the header will be set. |
| * @param {String} version - Version value. |
| * If the request has already a version value higher than the one supplied the this function does nothing. |
| */ |
| var fixDataServiceVersionHeader = function (request, version) { |
| |
| if (request) { |
| var headers = request.headers; |
| var dsv = headers["OData-Version"]; |
| headers["OData-Version"] = dsv ? maxVersion(dsv, version) : version; |
| } |
| }; |
| |
| /** Gets the value of a request or response header. |
| * @param requestOrResponse - Object representing a request or a response. |
| * @param {String} name - Name of the header to retrieve. |
| * @returns {String} String value of the header; undefined if the header cannot be found. |
| */ |
| var getRequestOrResponseHeader = function (requestOrResponse, name) { |
| |
| var headers = requestOrResponse.headers; |
| return (headers && headers[name]) || undefined; |
| }; |
| |
| /** Gets the value of the Content-Type header from a request or response. |
| * @param requestOrResponse - Object representing a request or a response. |
| * @returns {Object} Object with 'mediaType' and a 'properties' dictionary; null in case that the header is not found or doesn't have a value. |
| */ |
| var getContentType = function (requestOrResponse) { |
| |
| return contentType(getRequestOrResponseHeader(requestOrResponse, "Content-Type")); |
| }; |
| |
| var versionRE = /^\s?(\d+\.\d+);?.*$/; |
| /** Gets the value of the DataServiceVersion header from a request or response. |
| * @param requestOrResponse - Object representing a request or a response. |
| * @returns {String} Data service version; undefined if the header cannot be found. |
| */ |
| var getDataServiceVersion = function (requestOrResponse) { |
| |
| var value = getRequestOrResponseHeader(requestOrResponse, "OData-Version"); |
| if (value) { |
| var matches = versionRE.exec(value); |
| if (matches && matches.length) { |
| return matches[1]; |
| } |
| } |
| |
| // Fall through and return undefined. |
| }; |
| |
| /** Checks that a handler can process a particular mime type. |
| * @param handler - Handler object that is processing a resquest or response. |
| * @param cType - Object with 'mediaType' and a 'properties' dictionary. |
| * @returns {Boolean} True if the handler can process the mime type; false otherwise. |
| * |
| * The following check isn't as strict because if cType.mediaType = application/; it will match an accept value of "application/xml"; |
| * however in practice we don't not expect to see such "suffixed" mimeTypes for the handlers. |
| */ |
| var handlerAccepts = function (handler, cType) { |
| return handler.accept.indexOf(cType.mediaType) >= 0; |
| }; |
| |
| /** Invokes the parser associated with a handler for reading the payload of a HTTP response. |
| * @param handler - Handler object that is processing the response. |
| * @param {Function} parseCallback - Parser function that will process the response payload. |
| * @param response - HTTP response whose payload is going to be processed. |
| * @param context - Object used as the context for processing the response. |
| * @returns {Boolean} True if the handler processed the response payload and the response.data property was set; false otherwise. |
| */ |
| var handlerRead = function (handler, parseCallback, response, context) { |
| |
| if (!response || !response.headers) { |
| return false; |
| } |
| |
| var cType = getContentType(response); |
| var version = getDataServiceVersion(response) || ""; |
| var body = response.body; |
| |
| if (!assigned(body)) { |
| return false; |
| } |
| |
| if (handlerAccepts(handler, cType)) { |
| var readContext = createReadWriteContext(cType, version, context, handler); |
| readContext.response = response; |
| response.data = parseCallback(handler, body, readContext); |
| return response.data !== undefined; |
| } |
| |
| return false; |
| }; |
| |
| /** Invokes the serializer associated with a handler for generating the payload of a HTTP request. |
| * @param handler - Handler object that is processing the request. |
| * @param {Function} serializeCallback - Serializer function that will generate the request payload. |
| * @param response - HTTP request whose payload is going to be generated. |
| * @param context - Object used as the context for serializing the request. |
| * @returns {Boolean} True if the handler serialized the request payload and the request.body property was set; false otherwise. |
| */ |
| var handlerWrite = function (handler, serializeCallback, request, context) { |
| if (!request || !request.headers) { |
| return false; |
| } |
| |
| var cType = getContentType(request); |
| var version = getDataServiceVersion(request); |
| |
| if (!cType || handlerAccepts(handler, cType)) { |
| var writeContext = createReadWriteContext(cType, version, context, handler); |
| writeContext.request = request; |
| |
| request.body = serializeCallback(handler, request.data, writeContext); |
| |
| if (request.body !== undefined) { |
| fixDataServiceVersionHeader(request, writeContext.dataServiceVersion || "4.0"); |
| |
| fixRequestHeader(request, "Content-Type", contentTypeToString(writeContext.contentType)); |
| fixRequestHeader(request, "OData-MaxVersion", handler.maxDataServiceVersion); |
| return true; |
| } |
| } |
| |
| return false; |
| }; |
| |
| /** Creates a handler object for processing HTTP requests and responses. |
| * @param {Function} parseCallback - Parser function that will process the response payload. |
| * @param {Function} serializeCallback - Serializer function that will generate the request payload. |
| * @param {String} accept - String containing a comma separated list of the mime types that this handler can work with. |
| * @param {String} maxDataServiceVersion - String indicating the highest version of the protocol that this handler can work with. |
| * @returns {Object} Handler object. |
| */ |
| var handler = function (parseCallback, serializeCallback, accept, maxDataServiceVersion) { |
| |
| return { |
| accept: accept, |
| maxDataServiceVersion: maxDataServiceVersion, |
| |
| read: function (response, context) { |
| return handlerRead(this, parseCallback, response, context); |
| }, |
| |
| write: function (request, context) { |
| return handlerWrite(this, serializeCallback, request, context); |
| } |
| }; |
| }; |
| |
| var textParse = function (handler, body /*, context */) { |
| return body; |
| }; |
| |
| var textSerialize = function (handler, data /*, context */) { |
| if (assigned(data)) { |
| return data.toString(); |
| } else { |
| return undefined; |
| } |
| }; |
| |
| exports.textHandler = handler(textParse, textSerialize, "text/plain", MAX_DATA_SERVICE_VERSION); |
| |
| exports.contentType = contentType; |
| exports.contentTypeToString = contentTypeToString; |
| exports.handler = handler; |
| exports.createReadWriteContext = createReadWriteContext; |
| exports.fixRequestHeader = fixRequestHeader; |
| exports.getRequestOrResponseHeader = getRequestOrResponseHeader; |
| exports.getContentType = getContentType; |
| exports.getDataServiceVersion = getDataServiceVersion; |
| exports.MAX_DATA_SERVICE_VERSION = MAX_DATA_SERVICE_VERSION; |