internal static string DetermineAcceptType(ODataUri uri, string defaultAcceptType) { if (uri.IsNamedStream() || uri.IsMediaResource()) { return(MimeTypes.Any); } if (uri.IsCount()) { return(MimeTypes.TextPlain); } if (uri.IsPropertyValue()) { string propertyAcceptType = MimeTypes.Any; var propertySegment = uri.Segments[uri.Segments.Count - 2] as PropertySegment; ExceptionUtilities.CheckObjectNotNull(propertySegment, "Cannot get Property segment from uri"); var mimeTypeAnnotation = propertySegment.Property.Annotations.OfType <MimeTypeAnnotation>().SingleOrDefault(); if (mimeTypeAnnotation != null) { propertyAcceptType = mimeTypeAnnotation.MimeTypeValue; } return(propertyAcceptType); } return(defaultAcceptType); }
internal static DataServiceProtocolVersion CalculateUriResponseMinProtocolVersion(ODataUri requestUri, string contentType, DataServiceProtocolVersion maxProtocolVersion, DataServiceProtocolVersion maxDataServiceVersion) { DataServiceProtocolVersion expectedVersion = DataServiceProtocolVersion.V4; if (requestUri.IncludesInlineCountAllPages()) { expectedVersion = expectedVersion.IncreaseVersionIfRequired(DataServiceProtocolVersion.V4); } if (requestUri.IsCount()) { expectedVersion = expectedVersion.IncreaseVersionIfRequired(DataServiceProtocolVersion.V4); } else if (requestUri.IsProperty()) { var propertySegment = requestUri.LastSegment as PropertySegment; expectedVersion = expectedVersion.IncreaseVersionIfRequired(propertySegment.Property.CalculateProtocolVersion()); } else if (!requestUri.IsNamedStream()) { // Check service operations returning non-entity types if (requestUri.IsServiceOperation()) { var serviceOpSegment = requestUri.Segments.OfType <FunctionSegment>().Single(); DataType returnType = serviceOpSegment.Function.ReturnType; // Service ops returning complex values or bags of complex values, where the complex type has bag properties, are v3 var collectionType = returnType as CollectionDataType; if (collectionType != null) { // for service operations, the fact that a collection is returned does not mean it is a multivalue // so we unwrap the element type before calculating the version returnType = collectionType.ElementDataType; } expectedVersion = expectedVersion.IncreaseVersionIfRequired(returnType.CalculateDataTypeVersion()); } // Check entity types List <DataServiceProtocolVersion> dataServiceProtocolVersions = new List <DataServiceProtocolVersion>(); dataServiceProtocolVersions.Add(expectedVersion); if (!(requestUri.IsEntityReferenceLink() || requestUri.IsPropertyValue())) { foreach (EntitySet entitySet in requestUri.GetAllEntitySetsIncludingExpands()) { DataServiceProtocolVersion entitySetVersion = entitySet.CalculateEntitySetProtocolVersion(contentType, VersionCalculationType.Response, maxProtocolVersion, maxDataServiceVersion); dataServiceProtocolVersions.Add(entitySetVersion); if (entitySetVersion > maxDataServiceVersion) { return(VersionHelper.GetMaximumVersion(dataServiceProtocolVersions.ToArray())); } } } } return(expectedVersion); }
internal static DataServiceProtocolVersion CalculateUriMinRequestProtocolVersion(ODataUri requestUri, string contentType, DataServiceProtocolVersion maxProtocolVersion, DataServiceProtocolVersion maxDataServiceVersion) { DataServiceProtocolVersion expectedVersion = DataServiceProtocolVersion.V4; string inlineCount; if (requestUri.TryGetInlineCountValue(out inlineCount)) { expectedVersion = expectedVersion.IncreaseVersionIfRequired(DataServiceProtocolVersion.V4); } if (requestUri.SelectSegments.Count > 0) { expectedVersion = expectedVersion.IncreaseVersionIfRequired(DataServiceProtocolVersion.V4); } if (requestUri.HasAnyOrAllInFilter()) { expectedVersion = expectedVersion.IncreaseVersionIfRequired(DataServiceProtocolVersion.V4); } if (requestUri.IsCount()) { expectedVersion = expectedVersion.IncreaseVersionIfRequired(DataServiceProtocolVersion.V4); } else if (requestUri.IsProperty()) { var propertySegment = requestUri.LastSegment as PropertySegment; expectedVersion = expectedVersion.IncreaseVersionIfRequired(propertySegment.Property.CalculateProtocolVersion()); } else { EntitySet expectedEntitySet = null; if (requestUri.TryGetExpectedEntitySet(out expectedEntitySet)) { List <DataServiceProtocolVersion> dataServiceProtocolVersions = GetEntityTypes(expectedEntitySet).Select(et => et.CalculateEntityPropertyMappingProtocolVersion(VersionCalculationType.Request, contentType, maxProtocolVersion, maxDataServiceVersion)).ToList(); dataServiceProtocolVersions.Add(expectedVersion); expectedVersion = VersionHelper.GetMaximumVersion(dataServiceProtocolVersions.ToArray()); } } return(expectedVersion); }
/// <summary> /// Returns the strategy to use for serializing/deserialzing the given content type /// </summary> /// <param name="contentType">The content type</param> /// <param name="uri">The request uri</param> /// <returns>A serialization strategy</returns> public virtual IProtocolFormatStrategy GetStrategy(string contentType, ODataUri uri) { if (uri != null) { // if its a named stream or an MLE, handle the returned payload as a binary stream if (uri.IsNamedStream() || uri.IsMediaResource()) { return(this.BinaryValueStrategy); } // if its a raw $count request, we need to use a different strategy if (uri.IsCount() && IsPlainTextMimeType(contentType)) { return(this.CountStrategy); } } if (IsXmlMimeType(contentType)) { return(this.XmlStrategy); } if (IsJsonMimeType(contentType)) { return(this.JsonStrategy); } if (IsTextBasedMimeType(contentType)) { return(this.TextValueStrategy); } if (IsHtmlFormMimeType(contentType)) { return(this.HtmlFormStrategy); } return(this.BinaryValueStrategy); }
/// <summary> /// Calculates the protocol version based on the ODataUri provided /// </summary> /// <param name="uri">OData Uri to analyze</param> /// <param name="contentType">Content Type</param> /// <param name="maxProtocolVersion">The max protocol version</param> /// <param name="dataServiceVersion">The data service version of the request</param> /// <param name="maxDataServiceVersion">The max data service version of the request</param> /// <returns>Data Service Protocol Version</returns> public DataServiceProtocolVersion CalculateProtocolVersion(ODataUri uri, string contentType, DataServiceProtocolVersion maxProtocolVersion, DataServiceProtocolVersion dataServiceVersion, DataServiceProtocolVersion maxDataServiceVersion) { ExceptionUtilities.CheckArgumentNotNull(uri, "uri"); ExceptionUtilities.Assert(maxProtocolVersion != DataServiceProtocolVersion.Unspecified, "Max protocol version cannot be unspecified"); if (uri.IsMetadata()) { throw new TaupoNotSupportedException("Context uri should be processed by Entity Model Version Calculator instead"); } DataServiceProtocolVersion expectedVersion = DataServiceProtocolVersion.V4; if (uri.IncludesInlineCountAllPages()) { expectedVersion = VersionHelper.IncreaseVersionIfRequired(expectedVersion, DataServiceProtocolVersion.V4); } if (uri.IsCount()) { expectedVersion = VersionHelper.IncreaseVersionIfRequired(expectedVersion, DataServiceProtocolVersion.V4); } else if (uri.IsEntityReferenceLink() || uri.IsNamedStream() || uri.IsPropertyValue()) { // If the uri points to a Link, $value or a named stream their response DSV's are V1 because their payloads are understood by V1 expectedVersion = VersionHelper.IncreaseVersionIfRequired(expectedVersion, DataServiceProtocolVersion.V4); } else if (uri.HasOpenProperties()) { expectedVersion = VersionHelper.IncreaseVersionIfRequired(expectedVersion, VersionHelper.GetMinimumVersion(maxProtocolVersion, maxDataServiceVersion)); } else if (uri.IsProperty()) { var propertySegment = (PropertySegment)uri.LastSegment; expectedVersion = VersionHelper.IncreaseVersionIfRequired(expectedVersion, VersionHelper.CalculateProtocolVersion(propertySegment.Property)); } else if (uri.IsAction()) { var action = (FunctionSegment)uri.LastSegment; if (action.Function.ReturnType != null) { var collectionReturnType = action.Function.ReturnType as CollectionDataType; // If its a collection this doesn't bump things to V3 as this is normal behavior from ServiceOperations V1, so only determining version based on non data type DataType versionType = action.Function.ReturnType; var entityVersionType = action.Function.ReturnType as EntityDataType; if (collectionReturnType != null) { entityVersionType = collectionReturnType.ElementDataType as EntityDataType; if (entityVersionType != null) { versionType = entityVersionType; } } // Bump if its an open type if (entityVersionType != null && entityVersionType.Definition.IsOpen) { expectedVersion = VersionHelper.IncreaseVersionIfRequired(expectedVersion, VersionHelper.GetMinimumVersion(maxProtocolVersion, maxDataServiceVersion)); } expectedVersion = VersionHelper.IncreaseVersionIfRequired(expectedVersion, VersionHelper.CalculateDataTypeVersion(versionType)); } } else { ExceptionUtilities.CheckArgumentNotNull(contentType, "contentType"); List <DataServiceProtocolVersion> dataServiceProtocolVersions = uri.GetAllEntitySetsIncludingExpands().Select(es => es.CalculateEntitySetProtocolVersion(contentType, VersionCalculationType.Response, maxProtocolVersion, maxDataServiceVersion)).ToList(); dataServiceProtocolVersions.Add(expectedVersion); expectedVersion = VersionHelper.GetMaximumVersion(dataServiceProtocolVersions.ToArray()); } // determine if the uri MIGHT result in there being a next link, and increase version if so expectedVersion = VersionHelper.IncreaseVersionIfTrue(ResponseMightIncludeNextLink(uri), expectedVersion, DataServiceProtocolVersion.V4); return(expectedVersion); }
/// <summary> /// Processes the given uri and produces an expected value according to the conventions of an OData server implementation /// </summary> /// <param name="uri">The uri to process</param> /// <param name="applySelectAndExpand">A value indicating whether or not $select and $expand should be applied to the query values</param> /// <param name="applyPaging">A value indicating whether server-driven paging should be applied to the query values</param> /// <returns>The value resulting from processing the uri</returns> public QueryValue Evaluate(ODataUri uri, bool applySelectAndExpand, bool applyPaging) { this.applyPagingInExpands = applyPaging; ExceptionUtilities.CheckArgumentNotNull(uri, "uri"); ExceptionUtilities.CheckCollectionNotEmpty(uri.Segments, "uri.Segments"); ExceptionUtilities.CheckAllRequiredDependencies(this); this.currentUri = uri; this.shouldLastSegmentBeSingleton = false; applyPaging &= uri.TryGetExpectedEntitySet(out this.expectedEntitySet); if (applyPaging) { // compute the expected page size for this request based on the existence of a universal page size or set-specific page size this.expectedPageSize = this.expectedEntitySet.GetEffectivePageSize(); } else { this.expectedPageSize = null; } var query = this.BuildQueryFromSegments(); ExceptionUtilities.CheckObjectNotNull(query, "Could not build query from uri '{0}'", uri); // we explicitly do not process expand or select here because they do not affect the number of rows returned or their ordering query = this.ProcessFilter(query); ExceptionUtilities.CheckObjectNotNull(query, "Could not build query from uri '{0}'", uri); if (uri.IsEntitySet()) { // TODO: skip-token processing should happen before ordering query = this.ProcessOrderBy(query); ExceptionUtilities.CheckObjectNotNull(query, "Could not build query from uri '{0}'", uri); query = this.ProcessSkipAndTop(query); ExceptionUtilities.CheckObjectNotNull(query, "Could not build query from uri '{0}'", uri); } // handle $count requests if (uri.IsCount()) { query = query.LongCount(); } // need to resolve types since we constructed new QueryExpression tree var resolvedQuery = this.QueryResolver.Resolve(query); var value = this.Evaluator.Evaluate(resolvedQuery); ExceptionUtilities.CheckObjectNotNull(value, "Could not evaluate query '{0}'", query); ExceptionUtilities.Assert(value.EvaluationError == null, "Query evaluation produced an error: {0}", value.EvaluationError); // post-process the result to defer properties that were not expanded if (applySelectAndExpand) { value = this.ApplySelectAndExpand(uri, value); } // fixup for key expressions that should return singletons if (this.shouldLastSegmentBeSingleton) { value = EnsureLastSegmentIsSingletonOrNull(value); } this.currentUri = null; this.expectedEntitySet = null; this.expectedPageSize = null; return(value); }