Adds the baseline support to explore OData query options

Author: Chris Martinez

samples/aspnetcore/SwaggerODataSample/Configuration/PersonModelConfiguration.cs

@@ -17,7 +17,10 @@ public class PersonModelConfiguration : IModelConfiguration
         /// <param name="apiVersion">The <see cref="ApiVersion">API version</see> associated with the <paramref name="builder"/>.</param>
         public void Apply( ODataModelBuilder builder, ApiVersion apiVersion )
         {
-            var person = builder.EntitySet<Person>( "People" ).EntityType.HasKey( p => p.Id );
+            var person = builder.EntitySet<Person>( "People" ).EntityType;
+
+            person.HasKey( p => p.Id );
+            person.Select().OrderBy( "firstName", "lastName" );
 
             if ( apiVersion < ApiVersions.V3 )
             {

samples/aspnetcore/SwaggerODataSample/EnumerableExtensions.cs

@@ -0,0 +1,65 @@
+namespace Microsoft.Examples
+{
+    using System;
+    using System.Collections;
+
+    /// <summary>
+    /// Provides extension methods for the <see cref="IEnumerable"/> interface.
+    /// </summary>
+    public static class EnumerableExtensions
+    {
+        /// <summary>
+        /// Returns the first element from the specified sequence.
+        /// </summary>
+        /// <param name="enumerable">The <see cref="IEnumerable">sequence</see> to take an element from.</param>
+        /// <returns>The first element in the sequence or <c>null</c>.</returns>
+        public static object FirstOrDefault( this IEnumerable enumerable )
+        {
+            var iterator = enumerable.GetEnumerator();
+
+            try
+            {
+                if ( iterator.MoveNext() )
+                {
+                    return iterator.Current;
+                }
+            }
+            finally
+            {
+                ( iterator as IDisposable )?.Dispose();
+            }
+
+            return default( object );
+        }
+
+        /// <summary>
+        /// Returns a single element from the specified sequence.
+        /// </summary>
+        /// <param name="enumerable">The <see cref="IEnumerable">sequence</see> to take an element from.</param>
+        /// <returns>The single element in the sequence or <c>null</c>.</returns>
+        public static object SingleOrDefault( this IEnumerable enumerable )
+        {
+            var iterator = enumerable.GetEnumerator();
+            var result = default( object );
+
+            try
+            {
+                if ( iterator.MoveNext() )
+                {
+                    result = iterator.Current;
+
+                    if ( iterator.MoveNext() )
+                    {
+                        throw new InvalidOperationException( "The sequence contains more than one element." );
+                    }
+                }
+            }
+            finally
+            {
+                ( iterator as IDisposable )?.Dispose();
+            }
+
+            return result;
+        }
+    }
+}

samples/aspnetcore/SwaggerODataSample/Models/Order.cs

@@ -1,11 +1,14 @@
 namespace Microsoft.Examples.Models
 {
+    using Microsoft.AspNet.OData.Query;
     using System;
     using System.ComponentModel.DataAnnotations;
 
     /// <summary>
     /// Represents an order.
     /// </summary>
+    [Select]
+    [Select( "effectiveDate", SelectType = SelectExpandType.Disabled )]
     public class Order
     {
         /// <summary>

samples/aspnetcore/SwaggerODataSample/Startup.cs

@@ -2,14 +2,17 @@
 {
     using Microsoft.AspNet.OData.Builder;
     using Microsoft.AspNet.OData.Extensions;
+    using Microsoft.AspNet.OData.Query;
     using Microsoft.AspNetCore.Builder;
     using Microsoft.AspNetCore.Hosting;
     using Microsoft.AspNetCore.Mvc.ApiExplorer;
+    using Microsoft.Examples.Models;
     using Microsoft.Extensions.DependencyInjection;
     using Microsoft.Extensions.PlatformAbstractions;
     using Swashbuckle.AspNetCore.Swagger;
     using System.IO;
     using System.Reflection;
+    using static Microsoft.AspNet.OData.Query.AllowedQueryOptions;
 
     /// <summary>
     /// Represents the startup process for the application.
@@ -35,6 +38,13 @@ public void ConfigureServices( IServiceCollection services )
                     // note: this option is only necessary when versioning by url segment. the SubstitutionFormat
                     // can also be used to control the format of the API version in route templates
                     options.SubstituteApiVersionInUrl = true;
+
+                    // configure query options (which cannot otherwise be configured by OData conventions)
+                    options.QueryOptions.Controller<V2.PeopleController>()
+                                        .Action( c => c.Get( default( ODataQueryOptions<Person> ) ) ).Allow( Skip | Count ).AllowTop( 100 );
+
+                    options.QueryOptions.Controller<V3.PeopleController>()
+                                        .Action( c => c.Get( default( ODataQueryOptions<Person> ) ) ).Allow( Skip | Count ).AllowTop( 100 );
                 } );
             services.AddSwaggerGen(
                 options =>

samples/aspnetcore/SwaggerODataSample/V1/OrdersController.cs

@@ -4,6 +4,8 @@
     using Microsoft.AspNet.OData.Routing;
     using Microsoft.AspNetCore.Mvc;
     using Microsoft.Examples.Models;
+    using System.Linq;
+    using static Microsoft.AspNet.OData.Query.AllowedQueryOptions;
     using static Microsoft.AspNetCore.Http.StatusCodes;
 
     /// <summary>
@@ -21,11 +23,12 @@ public class OrdersController : ODataController
         /// <returns>The requested order.</returns>
         /// <response code="200">The order was successfully retrieved.</response>
         /// <response code="404">The order does not exist.</response>
+        [ODataRoute( "({key})" )]
         [Produces( "application/json" )]
         [ProducesResponseType( typeof( Order ), Status200OK )]
         [ProducesResponseType( Status404NotFound )]
-        [ODataRoute( "({key})" )]
-        public IActionResult Get( int key ) => Ok( new Order() { Id = key, Customer = "John Doe" } );
+        [EnableQuery( AllowedQueryOptions = Select )]
+        public SingleResult<Order> Get( int key ) => SingleResult.Create( new[] { new Order() { Id = key, Customer = "John Doe" } }.AsQueryable() );
 
         /// <summary>
         /// Places a new order.
@@ -34,10 +37,10 @@ public class OrdersController : ODataController
         /// <returns>The created order.</returns>
         /// <response code="201">The order was successfully placed.</response>
         /// <response code="400">The order is invalid.</response>
+        [ODataRoute]
         [MapToApiVersion( "1.0" )]
         [ProducesResponseType( typeof( Order ), Status201Created )]
         [ProducesResponseType( Status400BadRequest )]
-        [ODataRoute]
         public IActionResult Post( [FromBody] Order order )
         {
             if ( !ModelState.IsValid )
@@ -57,11 +60,12 @@ public IActionResult Post( [FromBody] Order order )
         /// <response code="200">The order was successfully retrieved.</response>
         /// <response code="404">The no orders exist.</response>
         [HttpGet]
+        [ODataRoute( "MostExpensive" )]
         [MapToApiVersion( "1.0" )]
         [Produces( "application/json" )]
         [ProducesResponseType( typeof( Order ), Status200OK )]
         [ProducesResponseType( Status404NotFound )]
-        [ODataRoute( "MostExpensive" )]
-        public IActionResult MostExpensive() => Ok( new Order() { Id = 42, Customer = "Bill Mei" } );
+        [EnableQuery( AllowedQueryOptions = Select )]
+        public SingleResult<Order> MostExpensive() => SingleResult.Create( new[] { new Order() { Id = 42, Customer = "Bill Mei" } }.AsQueryable() );
     }
 }

samples/aspnetcore/SwaggerODataSample/V1/PeopleController.cs

@@ -1,8 +1,10 @@
 namespace Microsoft.Examples.V1
 {
     using Microsoft.AspNet.OData;
+    using Microsoft.AspNet.OData.Query;
     using Microsoft.AspNetCore.Mvc;
     using Microsoft.Examples.Models;
+    using System.Linq;
     using static Microsoft.AspNetCore.Http.StatusCodes;
 
     /// <summary>
@@ -16,19 +18,34 @@ public class PeopleController : ODataController
         /// Gets a single person.
         /// </summary>
         /// <param name="key">The requested person identifier.</param>
+        /// <param name="options">The current OData query options.</param>
         /// <returns>The requested person.</returns>
         /// <response code="200">The person was successfully retrieved.</response>
         /// <response code="404">The person does not exist.</response>
         [HttpGet]
         [Produces( "application/json" )]
         [ProducesResponseType( typeof( Person ), Status200OK )]
         [ProducesResponseType( Status404NotFound )]
-        public IActionResult Get( int key ) =>
-            Ok( new Person()
+        public IActionResult Get( int key, ODataQueryOptions<Person> options )
+        {
+            var people = new[]
             {
-                Id = key,
-                FirstName = "John",
-                LastName = "Doe",
-            } );
+                new Person()
+                {
+                    Id = key,
+                    FirstName = "John",
+                    LastName = "Doe",
+                }
+            };
+
+            var person = options.ApplyTo( people.AsQueryable() ).SingleOrDefault();
+
+            if ( person == null )
+            {
+                return NotFound();
+            }
+
+            return Ok( person );
+        }
     }
 }

samples/aspnetcore/SwaggerODataSample/V2/OrdersController.cs

@@ -6,6 +6,8 @@
     using Microsoft.Examples.Models;
     using System;
     using System.Collections.Generic;
+    using System.Linq;
+    using static Microsoft.AspNet.OData.Query.AllowedQueryOptions;
     using static Microsoft.AspNetCore.Http.StatusCodes;
 
     /// <summary>
@@ -20,19 +22,20 @@ public class OrdersController : ODataController
         /// </summary>
         /// <returns>All available orders.</returns>
         /// <response code="200">The successfully retrieved orders.</response>
+        [ODataRoute]
         [Produces( "application/json" )]
         [ProducesResponseType( typeof( ODataValue<IEnumerable<Order>> ), Status200OK )]
-        [ODataRoute]
-        public IActionResult Get()
+        [EnableQuery( MaxTop = 100, AllowedQueryOptions = Select | Top | Skip | Count )]
+        public IQueryable<Order> Get()
         {
             var orders = new[]
             {
                 new Order(){ Id = 1, Customer = "John Doe" },
-                new Order(){ Id = 2, Customer = "Bob Smith" },
-                new Order(){ Id = 3, Customer = "Jane Doe", EffectiveDate = DateTime.UtcNow.AddDays( 7d ) },
+                new Order(){ Id = 2, Customer = "John Doe" },
+                new Order(){ Id = 3, Customer = "Jane Doe", EffectiveDate = DateTime.UtcNow.AddDays( 7d ) }
             };
 
-            return Ok( orders );
+            return orders.AsQueryable();
         }
 
         /// <summary>
@@ -42,11 +45,12 @@ public IActionResult Get()
         /// <returns>The requested order.</returns>
         /// <response code="200">The order was successfully retrieved.</response>
         /// <response code="404">The order does not exist.</response>
+        [ODataRoute( "({key})" )]
         [Produces( "application/json" )]
         [ProducesResponseType( typeof( Order ), Status200OK )]
         [ProducesResponseType( Status404NotFound )]
-        [ODataRoute( "({key})" )]
-        public IActionResult Get( int key ) => Ok( new Order() { Id = key, Customer = "John Doe" } );
+        [EnableQuery( AllowedQueryOptions = Select )]
+        public SingleResult<Order> Get( int key ) => SingleResult.Create( new[] { new Order() { Id = key, Customer = "John Doe" } }.AsQueryable() );
 
         /// <summary>
         /// Places a new order.
@@ -55,9 +59,9 @@ public IActionResult Get()
         /// <returns>The created order.</returns>
         /// <response code="201">The order was successfully placed.</response>
         /// <response code="400">The order is invalid.</response>
+        [ODataRoute]
         [ProducesResponseType( typeof( Order ), Status201Created )]
         [ProducesResponseType( Status400BadRequest )]
-        [ODataRoute]
         public IActionResult Post( [FromBody] Order order )
         {
             if ( !ModelState.IsValid )
@@ -79,10 +83,10 @@ public IActionResult Post( [FromBody] Order order )
         /// <response code="204">The order was successfully updated.</response>
         /// <response code="400">The order is invalid.</response>
         /// <response code="404">The order does not exist.</response>
+        [ODataRoute( "({key})" )]
         [ProducesResponseType( typeof( Order ), Status204NoContent )]
         [ProducesResponseType( Status400BadRequest )]
         [ProducesResponseType( Status404NotFound )]
-        [ODataRoute( "({key})" )]
         public IActionResult Patch( int key, Delta<Order> delta )
         {
             if ( !ModelState.IsValid )
@@ -104,11 +108,12 @@ public IActionResult Patch( int key, Delta<Order> delta )
         /// <response code="200">The order was successfully retrieved.</response>
         /// <response code="404">The no orders exist.</response>
         [HttpGet]
+        [ODataRoute( nameof( MostExpensive ) )]
         [Produces( "application/json" )]
         [ProducesResponseType( typeof( Order ), Status200OK )]
         [ProducesResponseType( Status404NotFound )]
-        [ODataRoute( nameof( MostExpensive ) )]
-        public IActionResult MostExpensive() => Ok( new Order() { Id = 42, Customer = "Bill Mei" } );
+        [EnableQuery( AllowedQueryOptions = Select )]
+        public SingleResult<Order> MostExpensive() => SingleResult.Create( new[] { new Order() { Id = 42, Customer = "Bill Mei" } }.AsQueryable() );
 
         /// <summary>
         /// Rates an order.
@@ -120,10 +125,10 @@ public IActionResult Patch( int key, Delta<Order> delta )
         /// <response code="400">The parameters are invalid.</response>
         /// <response code="404">The order does not exist.</response>
         [HttpPost]
+        [ODataRoute( "({key})/Rate" )]
         [ProducesResponseType( Status200OK )]
         [ProducesResponseType( Status400BadRequest )]
         [ProducesResponseType( Status404NotFound )]
-        [ODataRoute( "({key})/Rate" )]
         public IActionResult Rate( int key, ODataActionParameters parameters )
         {
             if ( !ModelState.IsValid )