public HttpResponseMessage GetCount(ODataQueryOptions<ODataPackage> options)
        {
            var queryResults = (IQueryable<ODataPackage>)options.ApplyTo(Get());
            var count = queryResults.Count();

            return OkCount(count);
        }
        // GET: odata/References(5)
        public async Task<IHttpActionResult> GetReference([FromODataUri] int key, ODataQueryOptions<Reference> queryOptions)
        {
            //Get access token to SharePoint
            string accessToken = await _tokenProvider.GetSharePointAccessToken();
            if (accessToken == null)
            {
                throw new UnauthorizedAccessException();
            }

            // validate the query.
            try
            {
                queryOptions.Validate(_validationSettings);
            }
            catch (ODataException ex)
            {
                return BadRequest(ex.Message);
            }

            //Get reference from SharePoint
            string eTag = Request.Headers.IfNoneMatch.ToString();
            Reference reference = await _repository.GetReference(accessToken, key, eTag);

            //Check eTag
            if (reference.__eTag == eTag)
            {
                return new StatusCodeResult(HttpStatusCode.NotModified, Request);
            }
            
            return Ok(reference);
        }
示例#3
0
        public IHttpActionResult Get(int key, ODataQueryOptions<ETagsCustomer> queryOptions)
        {
            IEnumerable<ETagsCustomer> appliedCustomers = customers.Where(c => c.Id == key);

            if (appliedCustomers.Count() == 0)
            {
                return BadRequest("The key is not valid");
            }

            if (queryOptions.IfNoneMatch != null)
            {
                appliedCustomers = queryOptions.IfNoneMatch.ApplyTo(appliedCustomers.AsQueryable()).Cast<ETagsCustomer>();
            }

            if (queryOptions.IfMatch != null)
            {
                appliedCustomers = queryOptions.IfMatch.ApplyTo(appliedCustomers.AsQueryable()).Cast<ETagsCustomer>();
            }

            if (appliedCustomers.Count() == 0)
            {
                return StatusCode(HttpStatusCode.NotModified);
            }
            else
            {
                return Ok(new SingleResult<ETagsCustomer>(appliedCustomers.AsQueryable()));
            }
        }
 public IQueryable<ProductType> Get(ODataQueryOptions<Domain.ProductType> paramters)
 {
     var resultset = paramters.ApplyTo(_db.ProductTypes).AsQueryable() as IQueryable<Domain.ProductType>;
     // ReSharper disable once AssignNullToNotNullAttribute
     var productTypes = resultset.ToArray().Select(Mapper.Map<ProductType>).AsQueryable();
     return productTypes;
 }
        // GET: odata/Projects(5)
        public async Task<IHttpActionResult> GetProject([FromODataUri] int key, ODataQueryOptions<Project> queryOptions)
        {
            //Get access token to SharePoint
            string accessToken = ((Repository)_repository).GetAccessToken();
            if (accessToken == null)
            {
                throw new UnauthorizedAccessException();
            }

            // validate the query.
            try
            {
                queryOptions.Validate(_validationSettings);
            }
            catch (ODataException ex)
            {
                return BadRequest(ex.Message);
            }

            //Get project from SharePoint
            string eTag = Request.Headers.IfNoneMatch.ToString();
            Project project = await _repository.GetProject(accessToken, key, eTag);

            //Check eTag
            if (project.__eTag == eTag)
            {
                return new StatusCodeResult(HttpStatusCode.NotModified, Request);
            }
            else
            {
                return Ok<Project>(project);
            }
        }
        public static bool IsHijackable(ODataQueryOptions<V2FeedPackage> options, out HijackableQueryParameters hijackable)
        {
            // Check if we can process the filter clause
            if (!CanProcessFilterClause(options))
            {
                hijackable = null;
                return false;
            }

            // Build expression (this works around all internal classes in the OData library - all we want is an expression tree)
            var expression = options.ApplyTo(EmptyQueryable, QueryResultDefaults.DefaultQuerySettings).Expression;

            // Unravel the comparisons into a list we can reason about
            List<Tuple<Target, string>> comparisons = new List<Tuple<Target, string>>();
            Expression remnant = FindQueryableWhere(expression as MethodCallExpression);
            MethodCallExpression where;
            while (IsQueryableWhere(where = remnant as MethodCallExpression))
            {
                var extractedComparisons = ExtractComparison(where).ToList();
                if (!extractedComparisons.Any() || extractedComparisons.Any(c => c == null))
                {
                    hijackable = null;
                    return false;
                }
                else
                {
                    // We recognize this comparison, record it and keep iterating on the nested expression
                    comparisons.AddRange(extractedComparisons);
                    remnant = where.Arguments[0];
                }
            }

            // We should be able to hijack here
            if (comparisons.Any())
            {
                hijackable = new HijackableQueryParameters();
                foreach (var comparison in comparisons)
                {
                    if (comparison.Item1 == Target.Id)
                    {
                        hijackable.Id = comparison.Item2;
                    }
                    else if (comparison.Item1 == Target.Version)
                    {
                        hijackable.Version = comparison.Item2;
                    }
                    else
                    {
                        hijackable = null;
                        return false;
                    }
                }

                return true;
            }

            hijackable = null;
            return false;
        }
        /// <summary>
        /// All standard OData web api support is handled here (except select and expand).
        /// This method also handles nested orderby statements the the current ASP.NET web api does not yet support.
        /// This method is called by base.OnActionExecuted
        /// </summary>
        /// <param name="queryable"></param>
        /// <param name="queryOptions"></param>
        /// <returns></returns>
        public override IQueryable ApplyQuery(IQueryable queryable, ODataQueryOptions queryOptions)
        {
            var queryHelper = GetQueryHelper(queryOptions.Request);

              queryable = queryHelper.BeforeApplyQuery(queryable, queryOptions);
              queryable = queryHelper.ApplyQuery(queryable, queryOptions);
              return queryable;
        }
示例#8
0
 /// <summary>
 /// Gets the list of blog posts by specified filter.
 /// </summary>
 /// <param name="options">The options.</param>
 /// <param name="filter">The filter.</param>
 /// <returns>
 /// List of blog post service models.
 /// </returns>
 public DataListResponse<BlogPostModel> Get(ODataQueryOptions<BlogPostModel> options, [FromUri] GetBlogPostRequest filter)
 {
     using (var api = CmsContext.CreateApiContextOf<BlogsApiContext>())
     {
         var results = api.GetBlogPostsAsQueryable(filter);
         return results.ToDataListResponse(options);
     }
 }
示例#9
0
 /// <summary>
 /// Gets the list of blog posts by specified filter.
 /// </summary>
 /// <param name="options">The options.</param>
 /// <returns>
 /// List of blog post service models.
 /// </returns>
 public DataListResponse<AuthorModel> Get(ODataQueryOptions<AuthorModel> options)
 {
     using (var api = CmsContext.CreateApiContextOf<BlogsApiContext>())
     {
         var results = api.GetAuthorsAsQueryable();
         return results.ToDataListResponse(options);
     }
 }
示例#10
0
        public IHttpActionResult Get(ODataQueryOptions<V1FeedPackage> options)
        {
            var queryable = _packagesRepository.GetAll()
                .Where(p => !p.IsPrerelease && !p.Deleted)
                .WithoutVersionSort()
                .ToV1FeedPackageQuery(_configurationService.GetSiteRoot(UseHttps()));

            return QueryResult(options, queryable, MaxPageSize);
        }
示例#11
0
 public override IQueryable BeforeApplyQuery(IQueryable queryable, ODataQueryOptions queryOptions)
 {
     var nhQueryable = queryable as IQueryableInclude;
     if (nhQueryable != null)
     {
         queryable = ApplyExpand(nhQueryable);
     }
     return queryable;
 }
        public IHttpActionResult GetSalesLeads(ODataQueryOptions<SalesLead> queryOptions)
        {
            try { queryOptions.Validate(_validationSettings); }
              catch (ODataException ex) { return BadRequest(ex.Message); }

              var queryResults = queryOptions.ApplyTo(SalesLeadFactory.GetSalesLeads()).Cast<SalesLead>();

              return Ok<IQueryable<SalesLead>>(queryResults);
        }
        // GET api/buildingupgrade
        public IQueryable<BuildingUpgrade> Get(ODataQueryOptions<Domain.BuildingUpgrade> paramters)
        {
            var logStart = LogHelper.StartLog("Started BuildingUpgradeController.Get", Logger);
            var resultset = paramters.ApplyTo(_db.BuildingUpgrades).AsQueryable() as IQueryable<Domain.BuildingUpgrade>;
            // ReSharper disable once AssignNullToNotNullAttribute

            var buildingUpgrades = resultset.ToArray().Where(x=>x.Name.StartsWith("Property") && x.Completed == false).OrderBy(x=>x.Name). Select(Mapper.Map<BuildingUpgrade>).AsQueryable();
            return LogHelper.EndLog(logStart, buildingUpgrades);
        }
        // GET api/PurchaseRequisitionDescription
        public IEnumerable<PurchaseRequisitionDescription> GetPurchaseRequisitionDescriptions(ODataQueryOptions Options)
        {
            //return db.PurchaseRequisitionDescriptions.Include(p=>p.Product).AsEnumerable();
            //return Options.ApplyTo(db.PurchaseRequisitionDescriptions.Include(p => p.Product) as IQueryable) as IEnumerable<PurchaseRequisitionDescription>;

            //db.PurchaseRequisitionDescriptions.Include(p => p.Product).Include()

            return Options.ApplyTo(db.PurchaseRequisitionDescriptions.AsQueryable().Include(p => p.Product).Include(p => p.Product.ProductCategory).Include(u => u.UOM)) as IEnumerable<PurchaseRequisitionDescription>;
        }
 public override IQueryable ApplyQuery(IQueryable queryable, ODataQueryOptions queryOptions)
 {
     var queryHelper = GetQueryHelper(queryOptions.Request);
     if (queryOptions.SelectExpand?.RawExpand != null)
     {
         queryOptions = QueryHelper.RemoveOptions(queryOptions, new List<string>() { "$expand" });
         //queryOptions = new ODataQueryOptions()
     }
     return queryHelper.ApplyQuery(queryable, queryOptions);
 }
        public void Ctor_SuccedsIfEntityTypesMatch()
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            builder.EntitySet<Customer>("Customers");

            ODataQueryContext context = new ODataQueryContext(builder.GetEdmModel(), typeof(Customer));

            ODataQueryOptions<Customer> query = new ODataQueryOptions<Customer>(context, new HttpRequestMessage(HttpMethod.Get, "http://server/?$top=10"));
            Assert.Equal("10", query.Top.RawValue);
        }
示例#17
0
        /// <summary>
        /// Overrides the method in QueryHelper to perform the $expands in NHibernate.
        /// Also populates the ExpandTypeMap that controls lazy initialization and serialization.
        /// </summary>
        /// <param name="queryable"></param>
        /// <param name="expandsQueryString"></param>
        /// <returns></returns>
        public override IQueryable ApplyExpand(IQueryable queryable, ODataQueryOptions queryOptions)
        {
            var expandQueryString = queryOptions.RawValues.Expand;
            if (string.IsNullOrWhiteSpace(expandQueryString)) return queryable;
            var session = GetSession(queryable);
            var fetcher = new NHEagerFetch(session.SessionFactory);
            queryable = fetcher.ApplyExpansions(queryable, expandQueryString, expandMap);

            return queryable;
        }
        public HttpResponseMessage CountSearch(
            [FromODataUri] string searchTerm,
            [FromODataUri] string targetFramework,
            [FromODataUri] bool includePrerelease,
            ODataQueryOptions<ODataPackage> options)
        {
            var queryResults = (IQueryable<ODataPackage>)options.ApplyTo(Search(searchTerm, targetFramework, includePrerelease, options));
            var count = queryResults.Count();

            return OkCount(count);
        }
示例#19
0
        private async Task<IHttpActionResult> GetCore(ODataQueryOptions<V1FeedPackage> options, string id, string version, bool return404NotFoundWhenNoResults)
        {
            var packages = _packagesRepository.GetAll()
                .Include(p => p.PackageRegistration)
                .Where(p => p.PackageRegistration.Id.Equals(id, StringComparison.OrdinalIgnoreCase) && !p.IsPrerelease && !p.Deleted);

            if (!string.IsNullOrEmpty(version))
            {
                packages = packages.Where(p => p.Version == version);
            }

            // try the search service
            try
            {
                var searchAdaptorResult = await SearchAdaptor.FindByIdAndVersionCore(
                    _searchService, GetTraditionalHttpContext().Request, packages, id, version, curatedFeed: null);

                // If intercepted, create a paged queryresult
                if (searchAdaptorResult.ResultsAreProvidedBySearchService)
                {
                    // Packages provided by search service
                    packages = searchAdaptorResult.Packages;

                    // Add explicit Take() needed to limit search hijack result set size if $top is specified
                    var totalHits = packages.LongCount();

                    if (return404NotFoundWhenNoResults && totalHits == 0)
                    {
                        return NotFound();
                    }

                    var pagedQueryable = packages
                        .Take(options.Top != null ? Math.Min(options.Top.Value, MaxPageSize) : MaxPageSize)
                        .ToV1FeedPackageQuery(GetSiteRoot());

                    return QueryResult(options, pagedQueryable, MaxPageSize, totalHits, (o, s, resultCount) =>
                       SearchAdaptor.GetNextLink(Request.RequestUri, resultCount, new { id }, o, s));
                }
            }
            catch (Exception ex)
            {
                // Swallowing Exception intentionally. If *anything* goes wrong in search, just fall back to the database.
                // We don't want to break package restores. We do want to know if this happens, so here goes:
                QuietLog.LogHandledException(ex);
            }

            if (return404NotFoundWhenNoResults && !packages.Any())
            {
                return NotFound();
            }

            var queryable = packages.ToV1FeedPackageQuery(GetSiteRoot());
            return QueryResult(options, queryable, MaxPageSize);
        }
示例#20
0
 // GET: odata/GeoCaches(1)
 public GeoCache GetGeoCache([FromODataUri] int key, ODataQueryOptions<GeoCache> queryOptions)
 {
     var geoCache = GeoCacheService.GetGeoCache(key);
     return new GeoCache
     {
         Id = geoCache.Id,
         Latitude = geoCache.Latitude,
         Longitude = geoCache.Longitude,
         Name = geoCache.Name
     };
 }
        //[Queryable]
        public IEnumerable<Member> GetMembers(
            ODataQueryOptions query)
        {
            var mappedQuery = query.Parse<Models.Member>(Request);
            var results = new List<Member>();

            foreach (var result in mappedQuery.ApplyTo(db.Members))
            {
                results.Add(Mapper.Map<Member>(result));
            }
            return results;
        }
        public async Task<IHttpActionResult> FindPackagesById(ODataQueryOptions<V2FeedPackage> options, string curatedFeedName, [FromODataUri]string id)
        {
            if (string.IsNullOrEmpty(curatedFeedName) || string.IsNullOrEmpty(id))
            {
                var emptyResult = Enumerable.Empty<Package>().AsQueryable()
                    .ToV2FeedPackageQuery(GetSiteRoot(), _configurationService.Features.FriendlyLicenses);

                return QueryResult(options, emptyResult, MaxPageSize);
            }

            return await GetCore(options, curatedFeedName, id, version: null, return404NotFoundWhenNoResults: false);
        }
        public void ApplyTo_Succeeds_If_QueryTypeMatchesOptionsType()
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            builder.EntitySet<Customer>("Customers");

            ODataQueryContext context = new ODataQueryContext(builder.GetEdmModel(), typeof(Customer));

            ODataQueryOptions<Customer> query = new ODataQueryOptions<Customer>(context, new HttpRequestMessage(HttpMethod.Get, "http://server/?$top=10"));

            Assert.DoesNotThrow(
                () => query.ApplyTo(Enumerable.Empty<Customer>().AsQueryable()));
        }
示例#24
0
        public IQueryable<LessonViewModel> Get(ODataQueryOptions<LessonViewModel> queryOptions)
        {
            var result =  _lessonService.GetLessons().Select(l => new LessonViewModel
            {
                Date = l.Date,
                GroupId = l.Group.GroupId,
                LessonId = l.LessonId,
                GroupDisplayName = l.Group.GroupNumber + " (" + l.Group.Year + ")"
            });

            var filteredResult = ((IQueryable<LessonViewModel>)queryOptions.ApplyTo(result));
            return filteredResult;
        }
        public IHttpActionResult Get(ODataQueryOptions<V2FeedPackage> options, string curatedFeedName)
        {
            if (!_entities.CuratedFeeds.Any(cf => cf.Name == curatedFeedName))
            {
                return NotFound();
            }

            var queryable = _curatedFeedService.GetPackages(curatedFeedName)
                .ToV2FeedPackageQuery(_configurationService.GetSiteRoot(UseHttps()), _configurationService.Features.FriendlyLicenses)
                .InterceptWith(new NormalizeVersionInterceptor());

            return QueryResult(options, queryable, MaxPageSize);
        }
示例#26
0
        public IQueryable<Facet> GetFacets(ODataQueryOptions<Car> options)
        {
            if (options.RawValues.Expand.IsNullOrEmpty())
            {
                return new Facet[0].AsQueryable();
            }

            IQueryable results = options.ApplyTo(SearchContext.GetQueryable<Car>());
            string[] facets = StringUtil.Split(options.RawValues.Expand, '|', true);
            var query = results as IQueryable<Car>;

            return SearchService.GetFacets(query, facets);
        }
        public void ApplyTo_ThrowsInvalidOp_If_QueryTypeDoesnotMatch()
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            builder.EntitySet<Customer>("Customers");

            ODataQueryContext context = new ODataQueryContext(builder.GetEdmModel(), typeof(Customer));

            ODataQueryOptions<Customer> query = new ODataQueryOptions<Customer>(context, new HttpRequestMessage(HttpMethod.Get, "http://server/?$top=10"));

            Assert.Throws<InvalidOperationException>(
                () => query.ApplyTo(Enumerable.Empty<int>().AsQueryable()),
                "Cannot apply ODataQueryOptions of 'System.Web.Http.OData.TestCommon.Models.Customer' to IQueryable of 'System.Int32'.");
        }
        public IEnumerable<Customer> GetCustomers(ODataQueryOptions<Customer> queryOptions)
        {
            // validate the query.
            queryOptions.Validate(_validationSettings);

            // Apply the query.
            IQuery query = queryOptions.ApplyTo(_db);

            Console.WriteLine("Executing HQL:\t" + query);
            Console.WriteLine();

            return query.List<Customer>();
        }
        public IHttpActionResult Get(int key, ODataQueryOptions<StoreGeneratedPatternCustomer> queryOptions)
        {
            IEnumerable<StoreGeneratedPatternCustomer> appliedCustomers = customers.Where(c => c.Id == key);

            if (appliedCustomers.Count() == 0)
            {
                return BadRequest("The key is not valid");
            }
            else
            {
                return Ok(new SingleResult<StoreGeneratedPatternCustomer>(appliedCustomers.AsQueryable()));
            }
        }
        public PageResult<Order> GetOrders(ODataQueryOptions<Order> options)
        {
            var settings = new ODataQuerySettings();

            var fromDatabase = _context.Orders.Where(order => order.Freight != 123);

            var results = options.ApplyTo(fromDatabase.AsQueryable(), settings);

            return new PageResult<Order>(
                results as IQueryable<Order>,
                Request.ODataProperties().NextLink,
                Request.ODataProperties().TotalCount);
        }
        public IQueryable <Object> CompanyInfoAndOrders(System.Web.Http.OData.Query.ODataQueryOptions options)
        {
            // Need to handle this specially for NH, to prevent $top being applied to Orders
            var query       = ContextProvider.Context.Customers;
            var queryHelper = new NHQueryHelper();

            // apply the $filter, $skip, $top to the query
            var query2 = queryHelper.ApplyQuery(query, options);

            // execute query, then expand the Orders
            var r = query2.Cast <Customer>().ToList();

            NHInitializer.InitializeList(r, "Orders");

            // after all is loaded, create the projection
            var stuff = r.AsQueryable().Select(c => new { c.CompanyName, c.CustomerID, c.Orders });

            queryHelper.ConfigureFormatter(Request, query);
示例#32
0
 public List <RedmondCustomer> GetListOfCustomer(ODataQueryOptions options)
 {
     throw new NotImplementedException();
 }
示例#33
0
 public CustomerCollection GetStronglyTypedCustomer(ODataQueryOptions options)
 {
     throw new NotImplementedException();
 }
示例#34
0
 public IQueryable <Customer> Get(ODataQueryOptions options)
 {
     throw new NotImplementedException();
 }
示例#35
0
 public object GetObject_WithODataQueryOptionsOfT(ODataQueryOptions <Customer> options)
 {
     // this can return Customer or BellevueCustomer
     throw new NotImplementedException();
 }
示例#36
0
 public IEnumerable GetNonQueryable_WithODataQueryOptionsOfT(ODataQueryOptions <Customer> options)
 {
     throw new NotImplementedException();
 }
示例#37
0
 public TwoGenericsCollection GetTwoGenericsCollection_WithODataQueryOptionsOfT(ODataQueryOptions <Customer> options)
 {
     throw new NotImplementedException();
 }
示例#38
0
 public void GetVoidReturn_WithODataQueryOptionsOfT(ODataQueryOptions <Customer> options)
 {
     throw new NotImplementedException();
 }
示例#39
0
 public Collection <SeattleCustomer> GetCollectionOfCustomer(ODataQueryOptions options)
 {
     throw new NotImplementedException();
 }
示例#40
0
 public void GetVoidReturn(ODataQueryOptions options)
 {
     throw new NotImplementedException();
 }
示例#41
0
 public IEnumerable <BellevueCustomer> GetIEnumerableOfCustomer(ODataQueryOptions options)
 {
     throw new NotImplementedException();
 }
示例#42
0
 public TwoGenericsCollection GetTwoGenericsCollection(ODataQueryOptions options)
 {
     throw new NotImplementedException();
 }
        public void GetNextPageLink_ThatTakesUri_GetsNextPageLink()
        {
            Uri nextPageLink = ODataQueryOptions.GetNextPageLink(new Uri("http://localhost/Customers?$filter=Age ge 18"), 10);

            Assert.Equal("http://localhost/Customers?$filter=Age%20ge%2018&$skip=10", nextPageLink.AbsoluteUri);
        }
示例#44
0
 public IEnumerable GetNonQueryable(ODataQueryOptions options)
 {
     throw new NotImplementedException();
 }
 public void IsSystemQueryOption_Returns_True_For_All_Supported_Query_Names(string queryName)
 {
     // Arrange & Act & Assert
     Assert.True(ODataQueryOptions.IsSystemQueryOption(queryName));
 }
 public void IsSystemQueryOption_Returns_False_For_Unrecognized_Query_Name()
 {
     // Arrange & Act & Assert
     Assert.False(ODataQueryOptions.IsSystemQueryOption("$invalidqueryname"));
 }