| /* |
| * 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. |
| */ |
| |
| /* { |
| oldname:'odata-json.js', |
| updated:'20140514 12:59' |
| }*/ |
| |
| var utils = require('./../datajs.js').utils; |
| var oDataUtils = require('./utils.js'); |
| var oDataHandler = require('./handler.js'); |
| |
| var odataNs = "odata"; |
| var odataAnnotationPrefix = odataNs + "."; |
| var contextUrlAnnotation = "@" + odataAnnotationPrefix + "context"; |
| |
| var assigned = utils.assigned; |
| var defined = utils.defined; |
| var extend = utils.extend; |
| var isArray = utils.isArray; |
| var isDate = utils.isDate; |
| var isObject = utils.isObject; |
| var normalizeURI = utils.normalizeURI; |
| var parseInt10 = utils.parseInt10; |
| |
| var contentType = oDataUtils.contentType; |
| var formatDateTimeOffset = oDataUtils.formatDateTimeOffset; |
| var formatDuration = oDataUtils.formatDuration; |
| var formatJsonLight = oDataUtils.formatJsonLight; |
| var formatNumberWidth = oDataUtils.formatNumberWidth; |
| var getCanonicalTimezone = oDataUtils.getCanonicalTimezone; |
| var handler = oDataUtils.handler; |
| var isComplex = oDataUtils.isComplex; |
| var isCollectionType = oDataUtils.isCollectionType; |
| var lookupComplexType = oDataUtils.lookupComplexType; |
| var lookupEntityType = oDataUtils.lookupEntityType; |
| var lookupSingleton = oDataUtils.lookupSingleton; |
| var lookupEntitySet = oDataUtils.lookupEntitySet; |
| var lookupDefaultEntityContainer = oDataUtils.lookupDefaultEntityContainer; |
| var lookupProperty = oDataUtils.lookupProperty; |
| var MAX_DATA_SERVICE_VERSION = oDataUtils.MAX_DATA_SERVICE_VERSION; |
| var maxVersion = oDataUtils.maxVersion; |
| var parseDateTime = oDataUtils.parseDateTime; |
| var parseDuration = oDataUtils.parseDuration; |
| var parseTimezone = oDataUtils.parseTimezone; |
| var payloadTypeOf = oDataUtils.payloadTypeOf; |
| var traverse = oDataUtils.traverse; |
| |
| // CONTENT START |
| |
| var PAYLOADTYPE_FEED = "f"; |
| var PAYLOADTYPE_ENTRY = "e"; |
| var PAYLOADTYPE_PROPERTY = "p"; |
| var PAYLOADTYPE_COLLECTION = "c"; |
| var PAYLOADTYPE_ENUMERATION_PROPERTY = "enum"; |
| var PAYLOADTYPE_SVCDOC = "s"; |
| var PAYLOADTYPE_ENTITY_REF_LINK = "erl"; |
| var PAYLOADTYPE_ENTITY_REF_LINKS = "erls"; |
| |
| var PAYLOADTYPE_VALUE = "v"; |
| |
| var PAYLOADTYPE_DELTA = "d"; |
| var DELTATYPE_FEED = "f"; |
| var DELTATYPE_DELETED_ENTRY = "de"; |
| var DELTATYPE_LINK = "l"; |
| var DELTATYPE_DELETED_LINK = "dl"; |
| |
| var jsonMediaType = "application/json"; |
| var jsonContentType = oDataHandler.contentType(jsonMediaType); |
| |
| |
| // The regular expression corresponds to something like this: |
| // /Date(123+60)/ |
| // |
| // This first number is date ticks, the + may be a - and is optional, |
| // with the second number indicating a timezone offset in minutes. |
| // |
| // On the wire, the leading and trailing forward slashes are |
| // escaped without being required to so the chance of collisions is reduced; |
| // however, by the time we see the objects, the characters already |
| // look like regular forward slashes. |
| var jsonDateRE = /^\/Date\((-?\d+)(\+|-)?(\d+)?\)\/$/; |
| |
| var minutesToOffset = function (minutes) { |
| /// <summary>Formats the given minutes into (+/-)hh:mm format.</summary> |
| /// <param name="minutes" type="Number">Number of minutes to format.</param> |
| /// <returns type="String">The minutes in (+/-)hh:mm format.</returns> |
| |
| var sign; |
| if (minutes < 0) { |
| sign = "-"; |
| minutes = -minutes; |
| } else { |
| sign = "+"; |
| } |
| |
| var hours = Math.floor(minutes / 60); |
| minutes = minutes - (60 * hours); |
| |
| return sign + formatNumberWidth(hours, 2) + ":" + formatNumberWidth(minutes, 2); |
| }; |
| |
| var parseJsonDateString = function (value) { |
| /// <summary>Parses the JSON Date representation into a Date object.</summary> |
| /// <param name="value" type="String">String value.</param> |
| /// <returns type="Date">A Date object if the value matches one; falsy otherwise.</returns> |
| |
| var arr = value && jsonDateRE.exec(value); |
| if (arr) { |
| // 0 - complete results; 1 - ticks; 2 - sign; 3 - minutes |
| var result = new Date(parseInt10(arr[1])); |
| if (arr[2]) { |
| var mins = parseInt10(arr[3]); |
| if (arr[2] === "-") { |
| mins = -mins; |
| } |
| |
| // The offset is reversed to get back the UTC date, which is |
| // what the API will eventually have. |
| var current = result.getUTCMinutes(); |
| result.setUTCMinutes(current - mins); |
| result.__edmType = "Edm.DateTimeOffset"; |
| result.__offset = minutesToOffset(mins); |
| } |
| if (!isNaN(result.valueOf())) { |
| return result; |
| } |
| } |
| |
| // Allow undefined to be returned. |
| }; |
| |
| // Some JSON implementations cannot produce the character sequence \/ |
| // which is needed to format DateTime and DateTimeOffset into the |
| // JSON string representation defined by the OData protocol. |
| // See the history of this file for a candidate implementation of |
| // a 'formatJsonDateString' function. |
| |
| var jsonParser = function (handler, text, context) { |
| /// <summary>Parses a JSON OData payload.</summary> |
| /// <param name="handler">This handler.</param> |
| /// <param name="text">Payload text (this parser also handles pre-parsed objects).</param> |
| /// <param name="context" type="Object">Object with parsing context.</param> |
| /// <returns>An object representation of the OData payload.</returns> |
| |
| var recognizeDates = defined(context.recognizeDates, handler.recognizeDates); |
| var inferJsonLightFeedAsObject = defined(context.inferJsonLightFeedAsObject, handler.inferJsonLightFeedAsObject); |
| var model = context.metadata; |
| var dataServiceVersion = context.dataServiceVersion; |
| var json = (typeof text === "string") ? JSON.parse(text) : text; |
| var metadataMap = { none : 0, minimal : 1, full : 2, all : 3 }; |
| |
| var payloadFormat = 1;//minmal |
| try { |
| payloadFormat = metadataMap[context.contentType.properties["odata.metadata"]];//TODO convert to lower before comparism |
| } catch(err) { |
| payloadFormat = 1; |
| } |
| payloadFormat = (payloadFormat === undefined) ? 1 : payloadFormat; |
| |
| var demandedFormat = 1;//minmal |
| try { |
| demandedFormat = metadataMap[context.extendMetadataToLevel]; //TODO convert to lower before comparism |
| } catch(err) { |
| demandedFormat = 1; |
| } |
| demandedFormat = (demandedFormat === undefined) ? 1 : demandedFormat; |
| |
| if ( payloadFormat >= demandedFormat) { |
| //there is no need to add additional metadata |
| if (recognizeDates) { |
| if (payloadFormat === 0) { |
| //error no typeinformation in payload, conversion of dates not possible |
| } else if (payloadFormat === 1) { //minimal |
| //TODO use metadata in context to determine which properties need to be converted |
| } else { |
| return convertPrimitivetypesOnMetadataFull(json); //should be fast |
| } |
| } else { |
| return json; |
| } |
| } else { |
| if (payloadFormat === 2) { |
| //demandedFormat is all |
| //metaData=full, no metadata in context required |
| //insert the missing type information for strings, bool, etc. |
| //guess types for nummber as defined in the odata-json-format-v4.0.doc specification |
| return extendMetadataFromPayload(json,context,recognizeDates); |
| } else if (payloadFormat === 1) { //minmal |
| if (!utils.isArray(model)) { // array was default for model in datajsV3 3.0 |
| //TODO use metadata in context to determine which properties need to be converted |
| // and extend the metadata |
| return extendMetadataFromContext(json,context,model,demandedFormat, recognizeDates); |
| } else { |
| //error metadata in context required, TODO: throw a to be defined exception |
| } |
| } else { |
| // the payload contains no context url only guessing possible |
| return json; |
| } |
| } |
| }; |
| |
| var extendMetadataFromContext = function(json,context, model,demandedFormat,recognizeDates) { |
| return jsonLightReadPayload(json, model, demandedFormat,recognizeDates, false, context.contentType.properties['odata.metadata']); |
| }; |
| |
| var convertPrimitivetypesOnMetadataFull = function(data) { |
| /// <summary>Converts some primitive data types in payload</summary> |
| /// <param name="data">Date which will be extendet</param> |
| /// <returns>An object representation of the OData payload.</returns> |
| |
| if ( utils.isObject(data) ) { |
| for (var key in data) { |
| if (data.hasOwnProperty(key)) { |
| if (key.indexOf('@') === -1) { |
| if (utils.isArray(data[key])) { |
| for ( var i = 0; i < data[key].length; ++i) { |
| convertPrimitivetypesOnMetadataFull(data[key][i]); |
| } |
| } else if (utils.isObject(data[key])) { |
| if (data[key] !== null) { |
| convertPrimitivetypesOnMetadataFull(data[key]); |
| } |
| } else { |
| var type = data[key+'@odata.type']; |
| if ( type === undefined ) { |
| var typeFromObject = typeof data[key]; |
| //TODO check the datatype |
| } else if ( type === '#DateTimeOffset' ) { |
| data[key] = oDataUtils.parseDateTimeOffset(data[key],true); |
| } else if ( type === '#DateTime' ) { |
| data[key] = oDataUtils.parseDateTimeOffset(data[key],true); |
| } |
| //TODO handle more types there |
| } |
| } |
| } |
| } |
| } |
| return data; |
| }; |
| |
| |
| var addType = function(data, name, value ) { |
| var fullName = name+'@odata.type'; |
| |
| if ( data[fullName] === undefined) { |
| data[fullName] = value; |
| } |
| }; |
| |
| var extendMetadataFromPayload = function(data,context,recognizeDates) { |
| /// <summary>Adds typeinformation for String, Boolean and numerical EDM-types. |
| /// The type is determined from the odata-json-format-v4.0.doc specification |
| ///</summary> |
| /// <param name="data">Date which will be extendet</param> |
| /// <param name="context" type="Object">Object with parsing context.</param> |
| /// <param name="recognizeDates" type="Boolean"> |
| /// True if strings formatted as datetime values should be treated as datetime values. False otherwise. |
| /// </param> |
| /// <returns>An object representation of the OData payload.</returns> |
| |
| if ( utils.isObject(data) ) { |
| for (var key in data) { |
| if (data.hasOwnProperty(key)) { |
| if (key.indexOf('@') === -1) { |
| if (utils.isArray(data[key])) { |
| for ( var i = 0; i < data[key].length; ++i) { |
| extendMetadataFromPayload(data[key][i], context, recognizeDates); |
| } |
| } else if (utils.isObject(data[key])) { |
| if (data[key] !== null) { |
| extendMetadataFromPayload(data[key],context, recognizeDates); |
| } |
| } else { |
| if (recognizeDates) { |
| var type = data[key+'@odata.type']; |
| if ( type === undefined ) { |
| var typeFromObject = typeof data[key]; |
| //TODO check the datatype |
| } else if ( type === '#DateTimeOffset' ) { |
| data[key] = oDataUtils.parseDateTimeOffset(data[key],true); |
| } else if ( type === '#DateTime' ) { |
| data[key] = oDataUtils.parseDateTimeOffset(data[key],true); |
| } |
| //TODO handle more types there |
| } |
| var typeFromObject = typeof data[key]; |
| if ( typeFromObject === 'string' ) { |
| addType(data,key,'#String'); |
| } else if (typeFromObject ==='boolean') { |
| addType(data,key,'#Bool'); |
| } else if (typeFromObject ==='number') { |
| if ( data[key] % 1 === 0 ) { // has fraction |
| addType(data,key,'#Integer');// the biggst integer |
| } else { |
| addType(data,key,'#Decimal');// the biggst float single,doulbe,decimal |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| return data; |
| }; |
| |
| |
| |
| /* |
| var jsonToString = function (data) { |
| /// <summary>Converts the data into a JSON string.</summary> |
| /// <param name="data">Data to serialize.</param> |
| /// <returns type="String">The JSON string representation of data.</returns> |
| |
| var result; // = undefined; |
| // Save the current date.toJSON function |
| var dateToJSON = Date.prototype.toJSON; |
| try { |
| // Set our own date.toJSON function |
| Date.prototype.toJSON = function () { |
| return formatDateTimeOffsetJSON(this); |
| }; |
| result = JSON.stringify(data, jsonReplacer); |
| result = result.replace(/\/Date\(([0-9.+-]+)\)\//g, "\\/Date($1)\\/"); |
| } finally { |
| // Restore the original toJSON function |
| Date.prototype.toJSON = dateToJSON; |
| } |
| return result; |
| };*/ |
| |
| var jsonSerializer = function (handler, data, context) { |
| /// <summary>Serializes the data by returning its string representation.</summary> |
| /// <param name="handler">This handler.</param> |
| /// <param name="data">Data to serialize.</param> |
| /// <param name="context" type="Object">Object with serialization context.</param> |
| /// <returns type="String">The string representation of data.</returns> |
| |
| var dataServiceVersion = context.dataServiceVersion || "4.0"; |
| var cType = context.contentType = context.contentType || jsonContentType; |
| |
| if (cType && cType.mediaType === jsonContentType.mediaType) { |
| context.dataServiceVersion = maxVersion(dataServiceVersion, "4.0"); |
| var newdata = formatJsonLightRequestPayload(data); |
| if (newdata) { |
| return JSON.stringify(newdata); |
| } |
| } |
| |
| return undefined; |
| }; |
| |
| var formatJsonLightRequestPayload = function (data) { |
| if (!data) { |
| return data; |
| } |
| |
| if (isPrimitive(data)) { |
| return data; |
| } |
| |
| if (isArray(data)) { |
| var newArrayData = []; |
| var i, len; |
| for (i = 0, len = data.length; i < len; i++) { |
| newArrayData[i] = formatJsonLightRequestPayload(data[i]); |
| } |
| |
| return newArrayData; |
| } |
| |
| var newdata = {}; |
| for (var property in data) { |
| if (isJsonLightSerializableProperty(property)) { |
| newdata[property] = formatJsonLightRequestPayload(data[property]); |
| } |
| } |
| |
| return newdata; |
| }; |
| var jsonReplacer = function (_, value) { |
| /// <summary>JSON replacer function for converting a value to its JSON representation.</summary> |
| /// <param value type="Object">Value to convert.</param> |
| /// <returns type="String">JSON representation of the input value.</returns> |
| /// <remarks> |
| /// This method is used during JSON serialization and invoked only by the JSON.stringify function. |
| /// It should never be called directly. |
| /// </remarks> |
| |
| if (value && value.__edmType === "Edm.Time") { |
| return formatDuration(value); |
| } else { |
| return value; |
| } |
| }; |
| |
| |
| var jsonLightMakePayloadInfo = function (kind, type) { |
| /// <summary>Creates an object containing information for the json light payload.</summary> |
| /// <param name="kind" type="String">JSON light payload kind, one of the PAYLOADTYPE_XXX constant values.</param> |
| /// <param name="typeName" type="String">Type name of the JSON light payload.</param> |
| /// <returns type="Object">Object with kind and type fields.</returns> |
| |
| /// <field name="kind" type="String">Kind of the JSON light payload. One of the PAYLOADTYPE_XXX constant values.</field> |
| /// <field name="type" type="String">Data type of the JSON light payload.</field> |
| |
| return { kind: kind, type: type || null }; |
| }; |
| |
| /// <summary>Creates an object containing information for the context</summary> |
| /// ... |
| /// <returns type="Object">Object with type information |
| /// attribute detectedPayloadKind(optional): see constants starting with PAYLOADTYPE_ |
| /// attribute deltaKind(optional): deltainformation, one of the following valus DELTATYPE_FEED | DELTATYPE_DELETED_ENTRY | DELTATYPE_LINK | DELTATYPE_DELETED_LINK |
| /// attribute typeName(optional): name of the type |
| /// attribute type(optional): object containing type information for entity- and complex-types ( null if a typeName is a primitive) |
| /// </returns> |
| var parseContextUriFragment = function( fragments, model ) { |
| var ret = {}; |
| |
| |
| if (fragments.indexOf('/') === -1 ) { |
| if (fragments.length === 0) { |
| // Capter 10.1 |
| ret.detectedPayloadKind = PAYLOADTYPE_SVCDOC; |
| return ret; |
| } else if (fragments === 'Edm.Null') { |
| // Capter 10.15 |
| ret.detectedPayloadKind = PAYLOADTYPE_VALUE; |
| ret.isNullProperty = true; |
| return ret; |
| } else if (fragments === 'Collection($ref)') { |
| // Capter 10.11 |
| ret.detectedPayloadKind = PAYLOADTYPE_ENTITY_REF_LINKS; |
| return ret; |
| } else if (fragments === '$ref') { |
| // Capter 10.12 |
| ret.detectedPayloadKind = PAYLOADTYPE_ENTITY_REF_LINK; |
| return ret; |
| } else { |
| //TODO check for navigation resource |
| } |
| } |
| |
| ret.type = undefined; |
| ret.typeName = undefined; |
| |
| var fragmentParts = fragments.split("/"); |
| |
| for(var i = 0; i < fragmentParts.length; ++i) { |
| var fragment = fragmentParts[i]; |
| if (ret.typeName === undefined) { |
| //preparation |
| if ( fragment.indexOf('(') !== -1 ) { |
| //remove the query function, cut fragment to matching '(' |
| var index = fragment.length - 2 ; |
| for ( var rCount = 1; rCount > 0 && index > 0; --index) { |
| if ( fragment.charAt(index)=='(') { |
| rCount --; |
| } else if ( fragment.charAt(index)==')') { |
| rCount ++; |
| } |
| } |
| |
| if (index === 0) { |
| //TODO throw error |
| } |
| |
| //remove the projected entity from the fragment; TODO decide if we want to store the projected entity |
| var inPharenthesis = fragment.substring(index+2,fragment.length - 1); |
| fragment = fragment.substring(0,index+1); |
| |
| if (utils.startsWith(fragment, 'Collection')) { |
| ret.detectedPayloadKind = PAYLOADTYPE_COLLECTION; |
| // Capter 10.14 |
| ret.typeName = inPharenthesis; |
| |
| var type = lookupEntityType(ret.typeName, model); |
| if ( type !== null) { |
| ret.type = type; |
| continue; |
| } |
| type = lookupComplexType(ret.typeName, model); |
| if ( type !== null) { |
| ret.type = type; |
| continue; |
| } |
| |
| ret.type = null;//in case of #Collection(Edm.String) only lastTypeName is filled |
| continue; |
| } else { |
| // projection: Capter 10.7, 10.8 and 10.9 |
| ret.projection = inPharenthesis; |
| } |
| } |
| |
| var container = lookupDefaultEntityContainer(model); |
| |
| //check for entity |
| var entitySet = lookupEntitySet(container.entitySet, fragment); |
| if ( entitySet !== null) { |
| ret.typeName = entitySet.entityType; |
| ret.type = lookupEntityType( ret.typeName, model); |
| ret.name = fragment; |
| ret.detectedPayloadKind = PAYLOADTYPE_FEED; |
| // Capter 10.2 |
| continue; |
| } |
| |
| //check for singleton |
| var singleton = lookupSingleton(container.singleton, fragment); |
| if ( singleton !== null) { |
| ret.typeName = singleton.entityType; |
| ret.type = lookupEntityType( ret.typeName, model); |
| ret.name = fragment; |
| ret.detectedPayloadKind = PAYLOADTYPE_ENTRY; |
| // Capter 10.4 |
| continue; |
| } |
| |
| if (jsonLightIsPrimitiveType(fragment)) { |
| ret.typeName = fragment; |
| ret.type = null; |
| ret.detectedPayloadKind = PAYLOADTYPE_VALUE; |
| continue; |
| } |
| |
| //TODO throw ERROR |
| } else { |
| //check for $entity |
| if (utils.endsWith(fragment, '$entity') && (ret.detectedPayloadKind === PAYLOADTYPE_FEED)) { |
| //TODO ret.name = fragment; |
| ret.detectedPayloadKind = PAYLOADTYPE_ENTRY; |
| // Capter 10.3 and 10.6 |
| continue; |
| } |
| |
| //check for derived types |
| if (fragment.indexOf('.') !== -1) { |
| // Capter 10.6 |
| ret.typeName = fragment; |
| var type = lookupEntityType(ret.typeName, model); |
| if ( type !== null) { |
| ret.type = type; |
| continue; |
| } |
| type = lookupComplexType(ret.typeName, model); |
| if ( type !== null) { |
| ret.type = type; |
| continue; |
| } |
| |
| //TODO throw ERROR invalid type |
| } |
| |
| //check for property value |
| if ( ret.detectedPayloadKind === PAYLOADTYPE_FEED || ret.detectedPayloadKind === PAYLOADTYPE_ENTRY) { |
| var property = lookupProperty(ret.type.property, fragment); |
| if (property !== null) { |
| ret.typeName = property.type; |
| ret.type = lookupComplexType(ret.typeName, model); |
| ret.name = fragment; |
| ret.detectedPayloadKind = PAYLOADTYPE_PROPERTY; |
| // Capter 10.15 |
| } |
| continue; |
| } |
| |
| if (fragment === '$delta') { |
| ret.deltaKind = DELTATYPE_FEED; |
| continue; |
| } else if (utils.endsWith(fragment, '/$deletedEntity')) { |
| ret.deltaKind = DELTATYPE_DELETED_ENTRY; |
| continue; |
| } else if (utils.endsWith(fragment, '/$link')) { |
| ret.deltaKind = DELTATYPE_LINK; |
| continue; |
| } else if (utils.endsWith(fragment, '/$deletedLink')) { |
| ret.deltaKind = DELTATYPE_DELETED_LINK; |
| continue; |
| } |
| //TODO throw ERROr |
| } |
| } |
| return ret; |
| }; |
| |
| var jsonLightPayloadInfo = function (data, model) { |
| /// <summary>Infers the information describing the JSON light payload from its metadata annotation, structure, and data model.</summary> |
| /// <param name="data" type="Object">Json light response payload object.</param> |
| /// <param name="model" type="Object">Object describing an OData conceptual schema.</param> |
| /// <remarks> |
| /// If the arguments passed to the function don't convey enough information about the payload to determine without doubt that the payload is a feed then it |
| /// will try to use the payload object structure instead. If the payload looks like a feed (has value property that is an array or non-primitive values) then |
| /// the function will report its kind as PAYLOADTYPE_FEED unless the inferFeedAsComplexType flag is set to true. This flag comes from the user request |
| /// and allows the user to control how the library behaves with an ambigous JSON light payload. |
| /// </remarks> |
| /// <returns type="Object"> |
| /// Object with kind and type fields. Null if there is no metadata annotation or the payload info cannot be obtained.. |
| /// </returns> |
| |
| var metadataUri = data[contextUrlAnnotation]; |
| if (!metadataUri || typeof metadataUri !== "string") { |
| return null; |
| } |
| |
| var fragmentStart = metadataUri.lastIndexOf("#"); |
| if (fragmentStart === -1) { |
| return jsonLightMakePayloadInfo(PAYLOADTYPE_SVCDOC); |
| } |
| |
| var fragment = metadataUri.substring(fragmentStart + 1); |
| return parseContextUriFragment(fragment,model); |
| }; |
| |
| var jsonLightReadPayload = function (data, model, demandedFormat,recognizeDates, inferFeedAsComplexType, contentTypeOdata) { |
| /// <summary>Converts a JSON light response payload object into its library's internal representation.</summary> |
| /// <param name="data" type="Object">Json light response payload object.</param> |
| /// <param name="model" type="Object">Object describing an OData conceptual schema.</param> |
| /// <param name="recognizeDates" type="Boolean" optional="true">Flag indicating whether datetime literal strings should be converted to JavaScript Date objects.</param> |
| /// <param name="inferFeedAsComplexType" type="Boolean">True if a JSON light payload that looks like a feed should be reported as a complex type property instead.</param> |
| /// <param name="contentTypeOdata" type="string">Includes the type of json ( minimalmetadata, fullmetadata .. etc )</param> |
| /// <returns type="Object">Object in the library's representation.</returns> |
| |
| if (!isComplex(data)) { |
| return data; |
| } |
| |
| contentTypeOdata = contentTypeOdata || "minimal"; |
| var baseURI = data[contextUrlAnnotation]; |
| var payloadInfo = jsonLightPayloadInfo(data, model, inferFeedAsComplexType); |
| if (assigned(payloadInfo)) { |
| payloadInfo.contentTypeOdata = contentTypeOdata; |
| } |
| var typeName = null; |
| if (payloadInfo) { |
| delete data[contextUrlAnnotation]; |
| |
| typeName = payloadInfo.type; |
| switch (payloadInfo.detectedPayloadKind) { |
| case PAYLOADTYPE_FEED: |
| return jsonLightReadFeed(data, payloadInfo, baseURI, model, demandedFormat,recognizeDates); |
| case PAYLOADTYPE_COLLECTION: |
| return jsonLightReadTopCollectionProperty(data, typeName, baseURI, model, recognizeDates); |
| case PAYLOADTYPE_PRIMITIVE: |
| return jsonLightReadTopPrimitiveProperty(data, typeName, baseURI, recognizeDates); |
| case PAYLOADTYPE_SVCDOC: |
| return jsonLightReadSvcDocument(data, baseURI); |
| case PAYLOADTYPE_LINKS: |
| return jsonLightReadLinksDocument(data, baseURI); |
| } |
| } |
| return jsonLightReadObject(data, payloadInfo, baseURI, model, recognizeDates); |
| }; |
| |
| var jsonLightGetEntryKey = function (data, entityModel) { |
| /// <summary>Gets the key of an entry.</summary> |
| /// <param name="data" type="Object">JSON light entry.</param> |
| /// <param name="entityModel" type="String">Object describing the entry Model</param> |
| /// <returns type="string">Entry instance key.</returns> |
| |
| var entityInstanceKey; |
| var entityKeys = entityModel.key[0].propertyRef; |
| var type; |
| entityInstanceKey = "("; |
| if (entityKeys.length == 1) { |
| type = lookupProperty(entityModel.property, entityKeys[0].name).type; |
| entityInstanceKey += formatLiteral(data[entityKeys[0].name], type); |
| } else { |
| var first = true; |
| for (var i = 0; i < entityKeys.length; i++) { |
| if (!first) { |
| entityInstanceKey += ","; |
| } else { |
| first = false; |
| } |
| type = lookupProperty(entityModel.property, entityKeys[i].name).type; |
| entityInstanceKey += entityKeys[i].name + "=" + formatLiteral(data[entityKeys[i].name], type); |
| } |
| } |
| entityInstanceKey += ")"; |
| return entityInstanceKey; |
| }; |
| |
| |
| |
| var jsonLightReadFeed = function (data, feedInfo, baseURI, model, demandedFormat,recognizeDates) { |
| var entries = []; |
| var items = data.value; |
| for (i = 0, len = items.length; i < len; i++) { |
| //TODO SK check if items[i] has @odata.type and use this type instead of feedinfo |
| |
| if ( items[i]['@odata.type'] !== undefined) { |
| var typeName = items[i]['@odata.type'].substring(1); |
| var type = lookupEntityType( typeName, model); |
| var entryInfo = { |
| contentTypeOdata : feedInfo.contentTypeOdata, |
| detectedPayloadKind : feedInfo.detectedPayloadKind, |
| name : feedInfo.name, |
| type : type, |
| typeName : typeName |
| }; |
| |
| entry = jsonLightReadObject(items[i], entryInfo, baseURI, model, demandedFormat,recognizeDates); |
| } else { |
| entry = jsonLightReadObject(items[i], feedInfo, baseURI, model, demandedFormat,recognizeDates); |
| } |
| |
| entries.push(entry); |
| } |
| data.value = entries; |
| return data; |
| }; |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| /* |
| var jsonNormalizeData = function (data, baseURI) { |
| /// <summary> |
| /// Normalizes the specified data into an intermediate representation. |
| /// like the latest supported version. |
| /// </summary> |
| /// <param name="data" optional="false">Data to update.</param> |
| /// <param name="baseURI" optional="false">URI to use as the base for normalizing references.</param> |
| |
| var isSvcDoc = isComplex(data) && !data.__metadata && isArray(data.EntitySets); |
| return isSvcDoc ? normalizeServiceDocument(data, baseURI) : data; |
| };*/ |
| |
| var formatLiteral = function (value, type) { |
| /// <summary>Formats a value according to Uri literal format</summary> |
| /// <param name="value">Value to be formatted.</param> |
| /// <param name="type">Edm type of the value</param> |
| /// <returns type="string">Value after formatting</returns> |
| |
| value = "" + formatRowLiteral(value, type); |
| value = encodeURIComponent(value.replace("'", "''")); |
| switch ((type)) { |
| case "Edm.Binary": |
| return "X'" + value + "'"; |
| case "Edm.DateTime": |
| return "datetime" + "'" + value + "'"; |
| case "Edm.DateTimeOffset": |
| return "datetimeoffset" + "'" + value + "'"; |
| case "Edm.Decimal": |
| return value + "M"; |
| case "Edm.Guid": |
| return "guid" + "'" + value + "'"; |
| case "Edm.Int64": |
| return value + "L"; |
| case "Edm.Float": |
| return value + "f"; |
| case "Edm.Double": |
| return value + "D"; |
| case "Edm.Geography": |
| return "geography" + "'" + value + "'"; |
| case "Edm.Geometry": |
| return "geometry" + "'" + value + "'"; |
| case "Edm.Time": |
| return "time" + "'" + value + "'"; |
| case "Edm.String": |
| return "'" + value + "'"; |
| default: |
| return value; |
| } |
| }; |
| |
| var formatRowLiteral = function (value, type) { |
| switch (type) { |
| case "Edm.Binary": |
| return convertByteArrayToHexString(value); |
| default: |
| return value; |
| } |
| }; |
| |
| |
| |
| |
| |
| var checkProperties = function(data,objectInfoType,baseURI,model, demandedFormat, recognizeDates) { |
| for (var name in data) { |
| if (name.indexOf("@") === -1) { |
| var curType = objectInfoType; |
| var propertyValue = data[name]; |
| var property = lookupProperty(curType.property,name); //TODO SK add check for parent type |
| |
| while (( property === null) && (curType.baseType !== undefined)) { |
| curType = lookupEntityType(curType.baseType, model); |
| property = lookupProperty(curType.property,name); |
| } |
| |
| if ( isArray(propertyValue)) { |
| data[name+'@odata.type'] = '#' + property.type; |
| for ( var i = 0; i < propertyValue.length; i++) { |
| jsonLightReadComplexObject(propertyValue[0], property,baseURI,model,demandedFormat, recognizeDates); |
| } |
| } else if (isObject(propertyValue) && (propertyValue !== null)) { |
| jsonLightReadComplexObject(propertyValue, property,baseURI,model,demandedFormat, recognizeDates); |
| } else { |
| if (demandedFormat === 3) { |
| data[name+'@odata.type'] = '#' + property.type; |
| } else { |
| if ( property.type != "Edm.String" && |
| property.type != "Edm.Boolean" && |
| property.type != "Edm.Int32" && |
| property.type != "Edm.Single" && |
| property.type != "Edm.Double" ) { |
| data[name+'@odata.type'] = '#' + property.type; |
| } |
| } |
| } |
| } |
| } |
| }; |
| |
| var jsonLightReadComplexObject = function (data, property, baseURI, model, demandedFormat, recognizeDates) { |
| var type = property.type; |
| if (isCollectionType(property.type)) { |
| type =property.type.substring(11,property.type.length-1); |
| } |
| |
| data['@odata.type'] = '#'+type; |
| |
| |
| |
| var propertyType = lookupComplexType(type, model); |
| if (propertyType === null) { |
| return; //TODO check what to do if the type is not known e.g. type #GeometryCollection |
| } |
| |
| |
| checkProperties(data,propertyType ,baseURI,model, demandedFormat, recognizeDates); |
| }; |
| |
| var jsonLightReadObject = function (data, objectInfo, baseURI, model, demandedFormat, recognizeDates) { |
| //var obj = {}; |
| |
| data['@odata.type'] = '#'+objectInfo.typeName; |
| |
| var keyType = objectInfo.type; |
| while (( keyType.key === undefined) && (keyType.baseType !== undefined)) { |
| keyType = lookupEntityType(keyType.baseType, model); |
| } |
| |
| var lastIdSegment = objectInfo.name + jsonLightGetEntryKey(data, keyType); |
| data['@odata.id'] = baseURI.substring(0, baseURI.lastIndexOf("$metadata")) + lastIdSegment; |
| data['@odata.editLink'] = lastIdSegment; |
| |
| var serviceURI = baseURI.substring(0, baseURI.lastIndexOf("$metadata")); |
| //jsonLightComputeUrisIfMissing(data, entryInfo, actualType, serviceURI, dataModel, baseTypeModel); |
| |
| checkProperties(data,objectInfo.type,baseURI,model, demandedFormat, recognizeDates); |
| |
| return data; |
| }; |
| |
| |
| var jsonHandler = oDataHandler.handler(jsonParser, jsonSerializer, jsonMediaType, MAX_DATA_SERVICE_VERSION); |
| jsonHandler.recognizeDates = false; |
| jsonHandler.useJsonLight = true; |
| jsonHandler.inferJsonLightFeedAsObject = false; |
| |
| exports.jsonHandler = jsonHandler; |
| |
| // DATAJS INTERNAL START |
| exports.jsonParser = jsonParser; |
| exports.jsonSerializer = jsonSerializer; |
| |
| exports.parseJsonDateString = parseJsonDateString; |
| exports.jsonLightPayloadInfo = jsonLightPayloadInfo; |
| // DATAJS INTERNAL END |
| |
| //exports.jsonNormalizeData = jsonNormalizeData; |
| //exports.normalizeServiceDocument = normalizeServiceDocument; |
| |
| /* |
| var jsonReadAdvertisedActionsOrFunctions = function (value) { |
| /// <summary>Reads and object containing action or function metadata and maps them into a single array of objects.</summary> |
| /// <param name="value" type="Object">Object containing action or function metadata.</param> |
| /// <returns type="Array">Array of objects containing metadata for the actions or functions specified in value.</returns> |
| |
| var result = []; |
| for (var name in value) { |
| var i, len; |
| for (i = 0, len = value[name].length; i < len; i++) { |
| result.push(extend({ metadata: name }, value[name][i])); |
| } |
| } |
| return result; |
| };*/ |
| |
| /* |
| var jsonApplyMetadata = function (value, metadata, dateParser, recognizeDates) { |
| /// <summary>Applies metadata coming from both the payload and the metadata object to the value.</summary> |
| /// <param name="value" type="Object">Data on which the metada is going to be applied.</param> |
| /// <param name="metadata">Metadata store; one of edmx, schema, or an array of any of them.</param> |
| /// <param name="dateParser" type="function">Function used for parsing datetime values.</param> |
| /// <param name="recognizeDates" type="Boolean"> |
| /// True if strings formatted as datetime values should be treated as datetime values. False otherwise. |
| /// </param> |
| /// <returns type="Object">Transformed data.</returns> |
| |
| if (value && typeof value === "object") { |
| var dataTypeName; |
| var valueMetadata = value.__metadata; |
| |
| if (valueMetadata) { |
| if (valueMetadata.actions) { |
| valueMetadata.actions = jsonReadAdvertisedActionsOrFunctions(valueMetadata.actions); |
| } |
| if (valueMetadata.functions) { |
| valueMetadata.functions = jsonReadAdvertisedActionsOrFunctions(valueMetadata.functions); |
| } |
| dataTypeName = valueMetadata && valueMetadata.type; |
| } |
| |
| var dataType = lookupEntityType(dataTypeName, metadata) || lookupComplexType(dataTypeName, metadata); |
| var propertyValue; |
| if (dataType) { |
| var properties = dataType.property; |
| if (properties) { |
| var i, len; |
| for (i = 0, len = properties.length; i < len; i++) { |
| var property = properties[i]; |
| var propertyName = property.name; |
| propertyValue = value[propertyName]; |
| |
| if (property.type === "Edm.DateTime" || property.type === "Edm.DateTimeOffset") { |
| if (propertyValue) { |
| propertyValue = dateParser(propertyValue); |
| if (!propertyValue) { |
| throw { message: "Invalid date/time value" }; |
| } |
| value[propertyName] = propertyValue; |
| } |
| } else if (property.type === "Edm.Time") { |
| if (propertyValue) { |
| value[propertyName] = parseDuration(propertyValue); |
| } |
| } |
| } |
| } |
| } else if (recognizeDates) { |
| for (var name in value) { |
| propertyValue = value[name]; |
| if (typeof propertyValue === "string") { |
| value[name] = dateParser(propertyValue) || propertyValue; |
| } |
| } |
| } |
| } |
| return value; |
| };*/ |
| /* |
| var isJsonLight = function (contentType) { |
| /// <summary>Tests where the content type indicates a json light payload.</summary> |
| /// <param name="contentType">Object with media type and properties dictionary.</param> |
| /// <returns type="Boolean">True is the content type indicates a json light payload. False otherwise.</returns> |
| |
| if (contentType) { |
| var odata = contentType.properties["odata.metadata"]; |
| return odata === "none" || odata === "minimal" || odata === "full"; |
| } |
| return false; |
| };*/ |
| /* |
| var normalizeServiceDocument = function (data, baseURI) { |
| /// <summary>Normalizes a JSON service document to look like an ATOM service document.</summary> |
| /// <param name="data" type="Object">Object representation of service documents as deserialized.</param> |
| /// <param name="baseURI" type="String">Base URI to resolve relative URIs.</param> |
| /// <returns type="Object">An object representation of the service document.</returns> |
| var workspace = { collections: [] }; |
| |
| var i, len; |
| for (i = 0, len = data.EntitySets.length; i < len; i++) { |
| var title = data.EntitySets[i]; |
| var collection = { |
| title: title, |
| href: normalizeURI(title, baseURI) |
| }; |
| |
| workspace.collections.push(collection); |
| } |
| |
| return { workspaces: [workspace] }; |
| };*/ |
