Merge pull request #50 from garethj-msft/master

Add linq-based select and expand overloads to requests. This looks good.

Author: MIchaelMainer

src/Microsoft.Graph.Core/Helpers/ExtractSelectHelper.cs

@@ -0,0 +1,104 @@
+// ------------------------------------------------------------------------------
+//  Copyright (c) Microsoft Corporation.  All Rights Reserved.  Licensed under the MIT License.  See License in the project root for license information.
+// ------------------------------------------------------------------------------
+
+namespace Microsoft.Graph
+{
+    using System;
+    using System.Linq;
+    using System.Linq.Expressions;
+    using System.Reflection;
+    
+    /// <summary>
+    /// Helper class to extract $select or $expand parameters from strongly-typed expressions.
+    /// </summary>
+    public static class ExpressionExtractHelper
+    {
+        /// <summary>
+        /// Extract referenced members of the type T from the given expression as a list of strings
+        /// </summary>
+        /// <param name="expression">The expression to search</param>
+        /// <param name="error">Message about what's wrong with the expression if return value is null</param>
+        /// <returns>A comma-separated list of strings or null</returns>
+        public static string ExtractMembers<T>(Expression<Func<T, object>> expression, out string error)
+        {
+            error = null;
+            if (expression == null)
+            {
+                throw new ArgumentNullException(nameof(expression));
+            }
+
+            // Search s => s.Foo
+            var memberExpression = expression.Body as MemberExpression;
+            if (memberExpression != null)
+            {
+                return ProcessSimpleMemberExpression<T>(memberExpression, ref error);
+            }
+
+            // Search s => s.BarFromBaseType 
+            // Property base type expressions introduce an intermediate conversion operator.
+            var convertExpression = expression.Body as UnaryExpression;
+            if (convertExpression?.NodeType == ExpressionType.Convert)
+            {
+                memberExpression = convertExpression.Operand as MemberExpression;
+                if (memberExpression != null)
+                {
+                    return ProcessSimpleMemberExpression<T>(memberExpression, ref error);
+                }
+            }
+
+            // Search s => new { [Foo = ]s.Foo, [bar = ]s.Bar }
+            // We'd prefer not to support the variant with named anonymous type members, but the expression trees don't differentiate, 
+            // between implicit and explicit naming, so there's no way to throw an error.
+            var newExpression = expression.Body as NewExpression;
+            if (newExpression != null)
+            {
+                if (newExpression.Arguments == null || newExpression.Arguments.Count == 0)
+                {
+                    error = "Lambda expression must provide initializer for new anonymous type.";
+                    return null;
+                }
+                if (newExpression.Arguments.Any(a =>
+                {
+                    var memberArgument = a as MemberExpression;
+                    return memberArgument == null ||
+                           !(memberArgument.Expression is ParameterExpression) ||
+                           !memberArgument.Member.DeclaringType.GetTypeInfo().IsAssignableFrom(typeof(T).GetTypeInfo());
+                }))
+                {
+                    error = $"Anonymous type in lambda expression may only be initialized with direct members of type {typeof(T).Name}";
+                    return null;
+                }
+
+                // Search only for direct members of the lambda's parameter
+                // Should already be validated above, but doesn't hurt to be sure.
+                var members = from m in newExpression.Arguments.OfType<MemberExpression>()
+                    where m.Expression is ParameterExpression && m.Member.DeclaringType.GetTypeInfo().IsAssignableFrom(typeof(T).GetTypeInfo())
+                    select GetMemberWireName(m.Member);
+                return string.Join(",", members);
+            }
+            error = "Unrecognized lambda expression.";
+            return null;
+        }
+
+        private static string ProcessSimpleMemberExpression<T>(MemberExpression memberExpression, ref string error)
+        {
+            if (!memberExpression.Member.DeclaringType.GetTypeInfo().IsAssignableFrom(typeof (T).GetTypeInfo()))
+            {
+                error = $"Anonymous type in lambda expression may only be initialized with direct members of type {typeof (T).Name}";
+                return null;
+            }
+            return GetMemberWireName(memberExpression.Member);
+        }
+
+        private static string GetMemberWireName(MemberInfo member)
+        {
+            var jsonProperty = member.GetCustomAttribute<Newtonsoft.Json.JsonPropertyAttribute>();
+            if (jsonProperty != null && !string.IsNullOrWhiteSpace(jsonProperty.PropertyName))
+            {
+                return jsonProperty.PropertyName;
+            }
+            return StringHelper.ConvertIdentifierToLowerCamelCase(member.Name);
+        }
+    }
+}

src/Microsoft.Graph.Core/Helpers/StringHelper.cs

@@ -41,5 +41,19 @@ public static string ConvertTypeToLowerCamelCase(string typeString)
 
             return typeString;
         }
+
+        /// <summary>
+        /// Converts the identifier string to lower camel case.
+        /// </summary>
+        /// <param name="identifierString">The identifier string.</param>
+        /// <returns>The converted string.</returns>
+        public static string ConvertIdentifierToLowerCamelCase(string identifierString)
+        {
+            if (!string.IsNullOrEmpty(identifierString))
+            {
+                return string.Concat(identifierString.Substring(0, 1).ToLowerInvariant(), identifierString.Substring(1));
+            }
+            return identifierString;
+        }
     }
 }

src/Microsoft.Graph.Core/Microsoft.Graph.Core.csproj

@@ -46,6 +46,7 @@
     <Compile Include="Exceptions\ErrorConstants.cs" />
     <Compile Include="Exceptions\ErrorResponse.cs" />
     <Compile Include="Exceptions\ServiceException.cs" />
+    <Compile Include="Helpers\ExtractSelectHelper.cs" />
     <Compile Include="Helpers\StringHelper.cs" />
     <Compile Include="Helpers\UrlHelper.cs" />
     <Compile Include="Models\AsyncOperationStatus.cs" />

src/Microsoft.Graph/Requests/Generated/AttachmentRequest.cs

@@ -12,6 +12,7 @@ namespace Microsoft.Graph
     using System.IO;
     using System.Net.Http;
     using System.Threading;
+    using System.Linq.Expressions;
 
     /// <summary>
     /// The type AttachmentRequest.
@@ -135,6 +136,30 @@ public IAttachmentRequest Expand(string value)
             return this;
         }
 
+        /// <summary>
+        /// Adds the specified expand value to the request.
+        /// </summary>
+        /// <param name="expandExpression">The expression from which to calculate the expand value.</param>
+        /// <returns>The request object to send.</returns>
+        public IAttachmentRequest Expand(Expression<Func<Attachment, object>> expandExpression)
+        {
+		    if (expandExpression == null)
+            {
+                throw new ArgumentNullException(nameof(expandExpression));
+            }
+            string error;
+            string value = ExpressionExtractHelper.ExtractMembers(expandExpression, out error);
+            if (value == null)
+            {
+                throw new ArgumentException(error, nameof(expandExpression));
+            }
+            else
+            {
+                this.QueryOptions.Add(new QueryOption("$expand", value));
+            }
+            return this;
+        }
+
         /// <summary>
         /// Adds the specified select value to the request.
         /// </summary>
@@ -146,6 +171,30 @@ public IAttachmentRequest Select(string value)
             return this;
         }
 
+        /// <summary>
+        /// Adds the specified select value to the request.
+        /// </summary>
+        /// <param name="selectExpression">The expression from which to calculate the select value.</param>
+        /// <returns>The request object to send.</returns>
+        public IAttachmentRequest Select(Expression<Func<Attachment, object>> selectExpression)
+        {
+            if (selectExpression == null)
+            {
+                throw new ArgumentNullException(nameof(selectExpression));
+            }
+            string error;
+            string value = ExpressionExtractHelper.ExtractMembers(selectExpression, out error);
+            if (value == null)
+            {
+                throw new ArgumentException(error, nameof(selectExpression));
+            }
+            else
+            {
+                this.QueryOptions.Add(new QueryOption("$select", value));
+            }
+            return this;
+        }
+
         /// <summary>
         /// Initializes any collection properties after deserialization, like next requests for paging.
         /// </summary>

src/Microsoft.Graph/Requests/Generated/CalendarCalendarViewCollectionRequest.cs

@@ -11,6 +11,7 @@ namespace Microsoft.Graph
     using System.Collections.Generic;
     using System.Net.Http;
     using System.Threading;
+    using System.Linq.Expressions;
 
     /// <summary>
     /// The type CalendarCalendarViewCollectionRequest.
@@ -109,6 +110,30 @@ public ICalendarCalendarViewCollectionRequest Expand(string value)
             return this;
         }
 
+        /// <summary>
+        /// Adds the specified expand value to the request.
+        /// </summary>
+        /// <param name="expandExpression">The expression from which to calculate the expand value.</param>
+        /// <returns>The request object to send.</returns>
+        public ICalendarCalendarViewCollectionRequest Expand(Expression<Func<Event, object>> expandExpression)
+        {
+            if (expandExpression == null)
+            {
+                throw new ArgumentNullException(nameof(expandExpression));
+            }
+            string error;
+            string value = ExpressionExtractHelper.ExtractMembers(expandExpression, out error);
+            if (value == null)
+            {
+                throw new ArgumentException(error, nameof(expandExpression));
+            }
+            else
+            {
+                this.QueryOptions.Add(new QueryOption("$expand", value));
+            }
+            return this;
+        }
+
         /// <summary>
         /// Adds the specified select value to the request.
         /// </summary>
@@ -120,6 +145,30 @@ public ICalendarCalendarViewCollectionRequest Select(string value)
             return this;
         }
 
+        /// <summary>
+        /// Adds the specified select value to the request.
+        /// </summary>
+        /// <param name="selectExpression">The expression from which to calculate the select value.</param>
+        /// <returns>The request object to send.</returns>
+        public ICalendarCalendarViewCollectionRequest Select(Expression<Func<Event, object>> selectExpression)
+        {
+            if (selectExpression == null)
+            {
+                throw new ArgumentNullException(nameof(selectExpression));
+            }
+            string error;
+            string value = ExpressionExtractHelper.ExtractMembers(selectExpression, out error);
+            if (value == null)
+            {
+                throw new ArgumentException(error, nameof(selectExpression));
+            }
+            else
+            {
+                this.QueryOptions.Add(new QueryOption("$select", value));
+            }
+            return this;
+        }
+
         /// <summary>
         /// Adds the specified top value to the request.
         /// </summary>

src/Microsoft.Graph/Requests/Generated/CalendarEventsCollectionRequest.cs

@@ -11,6 +11,7 @@ namespace Microsoft.Graph
     using System.Collections.Generic;
     using System.Net.Http;
     using System.Threading;
+    using System.Linq.Expressions;
 
     /// <summary>
     /// The type CalendarEventsCollectionRequest.
@@ -109,6 +110,30 @@ public ICalendarEventsCollectionRequest Expand(string value)
             return this;
         }
 
+        /// <summary>
+        /// Adds the specified expand value to the request.
+        /// </summary>
+        /// <param name="expandExpression">The expression from which to calculate the expand value.</param>
+        /// <returns>The request object to send.</returns>
+        public ICalendarEventsCollectionRequest Expand(Expression<Func<Event, object>> expandExpression)
+        {
+            if (expandExpression == null)
+            {
+                throw new ArgumentNullException(nameof(expandExpression));
+            }
+            string error;
+            string value = ExpressionExtractHelper.ExtractMembers(expandExpression, out error);
+            if (value == null)
+            {
+                throw new ArgumentException(error, nameof(expandExpression));
+            }
+            else
+            {
+                this.QueryOptions.Add(new QueryOption("$expand", value));
+            }
+            return this;
+        }
+
         /// <summary>
         /// Adds the specified select value to the request.
         /// </summary>
@@ -120,6 +145,30 @@ public ICalendarEventsCollectionRequest Select(string value)
             return this;
         }
 
+        /// <summary>
+        /// Adds the specified select value to the request.
+        /// </summary>
+        /// <param name="selectExpression">The expression from which to calculate the select value.</param>
+        /// <returns>The request object to send.</returns>
+        public ICalendarEventsCollectionRequest Select(Expression<Func<Event, object>> selectExpression)
+        {
+            if (selectExpression == null)
+            {
+                throw new ArgumentNullException(nameof(selectExpression));
+            }
+            string error;
+            string value = ExpressionExtractHelper.ExtractMembers(selectExpression, out error);
+            if (value == null)
+            {
+                throw new ArgumentException(error, nameof(selectExpression));
+            }
+            else
+            {
+                this.QueryOptions.Add(new QueryOption("$select", value));
+            }
+            return this;
+        }
+
         /// <summary>
         /// Adds the specified top value to the request.
         /// </summary>