Пример #1
0
        internal IQueryable ApplyPaging(IQueryable result, ODataQuerySettings querySettings)
        {
            int pageSize = -1;
            if (querySettings.PageSize.HasValue)
            {
                pageSize = querySettings.PageSize.Value;
            }
            else if (querySettings.ModelBoundPageSize.HasValue)
            {
                pageSize = querySettings.ModelBoundPageSize.Value;
            }

            int preferredPageSize = -1;
            if (RequestPreferenceHelpers.RequestPrefersMaxPageSize(Request.Headers, out preferredPageSize))
            {
                pageSize = Math.Min(pageSize, preferredPageSize);
            }

            ODataFeature odataFeature = Request.ODataFeature() as ODataFeature;
            if (pageSize > 0)
            {
                bool resultsLimited;
                result = LimitResults(result, pageSize, querySettings.EnableConstantParameterization, out resultsLimited);
                if (resultsLimited && Request.GetEncodedUrl() != null &&
                    odataFeature.NextLink == null)
                {
                    odataFeature.PageSize = pageSize;
                }
            }

            odataFeature.QueryOptions = this;

            return result;
        }
Пример #2
0
        internal static ODataQueryOptions GetQueryOptions(this HttpRequest request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull(nameof(request));
            }

            ODataFeature feature = request.ODataFeature() as ODataFeature;

            return(feature.QueryOptions);
        }
        /// <summary>
        /// Writes the given <paramref name="graph"/> using the given <paramref name="writer"/>.
        /// </summary>
        /// <param name="writer">The <see cref="ODataCollectionWriter"/> to use.</param>
        /// <param name="graph">The collection to write.</param>
        /// <param name="collectionType">The EDM type of the collection.</param>
        /// <param name="writeContext">The serializer context.</param>
        public virtual void WriteCollection(ODataCollectionWriter writer, object graph, IEdmTypeReference collectionType,
                                            ODataSerializerContext writeContext)
        {
            if (writer == null)
            {
                throw Error.ArgumentNull(nameof(writer));
            }

            if (writeContext == null)
            {
                throw Error.ArgumentNull(nameof(writeContext));
            }

            ODataCollectionStart collectionStart = new ODataCollectionStart {
                Name = writeContext.RootElementName
            };

            if (writeContext.Request != null)
            {
                ODataFeature odataFeature = writeContext.Request.ODataFeature() as ODataFeature;
                if (odataFeature.NextLink != null)
                {
                    collectionStart.NextPageLink = odataFeature.NextLink;
                }
                else if (odataFeature.QueryOptions != null)
                {
                    // Collection serializer is called only for collection of primitive values - A null object will be supplied since it is a non-entity value
                    SkipTokenHandler skipTokenHandler = writeContext.QueryOptions.Context.GetSkipTokenHandler();
                    collectionStart.NextPageLink = skipTokenHandler.GenerateNextPageLink(new Uri(writeContext.Request.GetEncodedUrl()), odataFeature.PageSize, null, writeContext);
                }

                if (odataFeature.TotalCount != null)
                {
                    collectionStart.Count = odataFeature.TotalCount;
                }
            }

            writer.WriteStart(collectionStart);

            if (graph != null)
            {
                ODataCollectionValue collectionValue = CreateODataValue(graph, collectionType, writeContext) as ODataCollectionValue;
                if (collectionValue != null)
                {
                    foreach (object item in collectionValue.Items)
                    {
                        writer.WriteItem(item);
                    }
                }
            }

            writer.WriteEnd();
        }
        /// <summary>
        /// Extension method to return the <see cref="IODataFeature"/> from the <see cref="HttpContext"/>.
        /// </summary>
        /// <param name="httpContext">The Http context.</param>
        /// <returns>The <see cref="IODataFeature"/>.</returns>
        public static IODataFeature ODataFeature(this HttpContext httpContext)
        {
            if (httpContext == null)
            {
                throw Error.ArgumentNull("httpContext");
            }

            IODataFeature odataFeature = httpContext.Features.Get <IODataFeature>();

            if (odataFeature == null)
            {
                odataFeature = new ODataFeature(httpContext);
                httpContext.Features.Set <IODataFeature>(odataFeature);
            }

            return(odataFeature);
        }
        /// <summary>
        /// Extension method to return the <see cref="IODataFeature"/> from the <see cref="HttpContext"/>.
        /// </summary>
        /// <param name="httpContext">The Http context.</param>
        /// <returns>The <see cref="IODataFeature"/>.</returns>
        public static IODataFeature ODataFeature(this HttpContext httpContext)
        {
            if (httpContext == null)
            {
                throw new ArgumentNullException(nameof(httpContext));
            }

            IODataFeature odataFeature = httpContext.Features.Get <IODataFeature>();

            if (odataFeature == null)
            {
                odataFeature = new ODataFeature();
                httpContext.Features.Set <IODataFeature>(odataFeature);
            }

            return(odataFeature);
        }
        public Task BindModelAsync(ModelBindingContext bindingContext)
        {
            if (bindingContext == null)
            {
                throw new ArgumentNullException(nameof(bindingContext));
            }

            if (bindingContext.ModelMetadata == null)
            {
                throw Error.Argument("bindingContext", SRResources.ModelBinderUtil_ModelMetadataCannotBeNull);
            }

            HttpContext httpContext = bindingContext.HttpContext;

            ODataFeature odataFeature           = httpContext.ODataFeature() as ODataFeature;
            IDictionary <string, object> values = odataFeature?.BodyValues;

            if (values == null)
            {
                values = ReadODataBody(bindingContext);
                if (values == null)
                {
                    values = new Dictionary <string, object>();
                }

                if (odataFeature != null)
                {
                    odataFeature.BodyValues = values;
                }
            }

            if (values.TryGetValue(bindingContext.ModelMetadata.Name, out object result))
            {
                //ValueProviderResult valueProviderResult = new ValueProviderResult(result);
                //bindingContext.ModelState.SetModelValue(bindingContext.ModelName, valueProviderResult);

                bindingContext.Result = ModelBindingResult.Success(result);
                return(Task.CompletedTask);
            }

            return(Task.CompletedTask);
        }