Initial state

samples/angular/MusicStore/Infrastructure/ApiResult.cs

@@ -0,0 +1,63 @@
+using Microsoft.AspNet.Mvc;
+using Microsoft.AspNet.Mvc.ModelBinding;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace MusicStore.Infrastructure
+{
+    public class ApiResult : ActionResult
+    {
+        public ApiResult(ModelStateDictionary modelState)
+            : this()
+        {
+            if (modelState.Any(m => m.Value.Errors.Count > 0))
+            {
+                StatusCode = 400;
+                Message = "The model submitted was invalid. Please correct the specified errors and try again.";
+                ModelErrors = modelState
+                    .SelectMany(m => m.Value.Errors.Select(me => new ModelError
+                    {
+                        FieldName = m.Key,
+                        ErrorMessage = me.ErrorMessage
+                    }));
+            }
+        }
+
+        public ApiResult()
+        {
+
+        }
+
+        [JsonIgnore]
+        public int? StatusCode { get; set; }
+
+        public string Message { get; set; }
+
+        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+        public object Data { get; set; }
+
+        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+        public IEnumerable<ModelError> ModelErrors { get; set; }
+
+        public override Task ExecuteResultAsync(ActionContext context)
+        {
+            if (StatusCode.HasValue)
+            {
+                context.HttpContext.Response.StatusCode = StatusCode.Value;
+            }
+
+            var json = new JsonResult(this);
+            return json.ExecuteResultAsync(context);
+        }
+
+        public class ModelError
+        {
+            public string FieldName { get; set; }
+
+            public string ErrorMessage { get; set; }
+        }
+    }
+}

samples/angular/MusicStore/Infrastructure/NoCacheAttribute.cs

@@ -0,0 +1,19 @@
+using Microsoft.AspNet.Mvc;
+using System;
+using Microsoft.AspNet.Mvc.Filters;
+
+namespace MusicStore.Infrastructure
+{
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
+    public sealed class NoCacheAttribute : ActionFilterAttribute
+    {
+        public override void OnResultExecuting(ResultExecutingContext context)
+        {
+            context.HttpContext.Response.Headers["Cache-Control"] = "no-cache, no-store, max-age=0";
+            context.HttpContext.Response.Headers["Pragma"] = "no-cache";
+            context.HttpContext.Response.Headers["Expires"] = "-1";
+
+            base.OnResultExecuting(context);
+        }
+    }
+}

samples/angular/MusicStore/Infrastructure/PagedList.cs

@@ -0,0 +1,150 @@
+using Microsoft.Data.Entity;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace MusicStore.Infrastructure
+{
+    public interface IPagedList<T>
+    {
+        IEnumerable<T> Data { get; }
+
+        int Page { get; }
+
+        int PageSize { get; }
+
+        int TotalCount { get; }
+    }
+
+    internal class PagedList<T> : IPagedList<T>
+    {
+        public PagedList(IEnumerable<T> data, int page, int pageSize, int totalCount)
+        {
+            Data = data;
+            Page = page;
+            PageSize = pageSize;
+            TotalCount = totalCount;
+        }
+
+        public IEnumerable<T> Data { get; private set; }
+
+        public int Page { get; private set; }
+
+        public int PageSize { get; private set; }
+
+        public int TotalCount { get; private set; }
+    }
+
+    public static class PagedListExtensions
+    {
+        public static IPagedList<T> ToPagedList<T>(this IQueryable<T> query, int page, int pageSize)
+        {
+            if (query == null)
+            {
+                throw new ArgumentNullException("query");
+            }
+
+            var pagingConfig = new PagingConfig(page, pageSize);
+            var skipCount = ValidatePagePropertiesAndGetSkipCount(pagingConfig);
+
+            var data = query
+                .Skip(skipCount)
+                .Take(pagingConfig.PageSize)
+                .ToList();
+
+            if (skipCount > 0 && data.Count == 0)
+            {
+                // Requested page has no records, just return the first page
+                pagingConfig.Page = 1;
+                data = query
+                    .Take(pagingConfig.PageSize)
+                    .ToList();
+            }
+
+            return new PagedList<T>(data, pagingConfig.Page, pagingConfig.PageSize, query.Count());
+        }
+
+        public static Task<IPagedList<TModel>> ToPagedListAsync<TModel, TProperty>(this IQueryable<TModel> query, int page, int pageSize, string sortExpression, Expression<Func<TModel, TProperty>> defaultSortExpression, SortDirection defaultSortDirection = SortDirection.Ascending)
+            where TModel : class
+        {
+            return ToPagedListAsync<TModel, TProperty, TModel>(query, page, pageSize, sortExpression, defaultSortExpression, defaultSortDirection, null);
+        }
+
+        public static async Task<IPagedList<TResult>> ToPagedListAsync<TModel, TProperty, TResult>(this IQueryable<TModel> query, int page, int pageSize, string sortExpression, Expression<Func<TModel, TProperty>> defaultSortExpression, SortDirection defaultSortDirection, Func<TModel, TResult> selector)
+            where TModel : class
+            where TResult : class
+        {
+            if (query == null)
+            {
+                throw new ArgumentNullException("query");
+            }
+
+            var pagingConfig = new PagingConfig(page, pageSize);
+            var skipCount = ValidatePagePropertiesAndGetSkipCount(pagingConfig);
+            var dataQuery = query;
+
+            if (defaultSortExpression != null)
+            {
+                dataQuery = dataQuery
+                    .SortBy(sortExpression, defaultSortExpression);
+            }
+
+            var data = await dataQuery
+                .Skip(skipCount)
+                .Take(pagingConfig.PageSize)
+                .ToListAsync();
+
+            if (skipCount > 0 && data.Count == 0)
+            {
+                // Requested page has no records, just return the first page
+                pagingConfig.Page = 1;
+                data = await dataQuery
+                    .Take(pagingConfig.PageSize)
+                    .ToListAsync();
+            }
+
+            var count = await query.CountAsync();
+
+            var resultData = selector != null
+                ? data.Select(selector)
+                : data.Cast<TResult>();
+
+            return new PagedList<TResult>(resultData, pagingConfig.Page, pagingConfig.PageSize, count);
+        }
+
+        private static int ValidatePagePropertiesAndGetSkipCount(PagingConfig pagingConfig)
+        {
+            if (pagingConfig.Page < 1)
+            {
+                pagingConfig.Page = 1;
+            }
+
+            if (pagingConfig.PageSize < 10)
+            {
+                pagingConfig.PageSize = 10;
+            }
+
+            if (pagingConfig.PageSize > 100)
+            {
+                pagingConfig.PageSize = 100;
+            }
+
+            return pagingConfig.PageSize * (pagingConfig.Page - 1);
+        }
+
+        internal class PagingConfig
+        {
+            public PagingConfig(int page, int pageSize)
+            {
+                Page = page;
+                PageSize = pageSize;
+            }
+
+            public int Page { get; set; }
+
+            public int PageSize { get; set; }
+        }
+    }
+}

samples/angular/MusicStore/Infrastructure/SortDirection.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace MusicStore.Infrastructure
+{
+    public enum SortDirection
+    {
+        Ascending,
+        Descending
+    }
+}

samples/angular/MusicStore/Infrastructure/SortExpression.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+using Microsoft.AspNet.Mvc.ViewFeatures;
+
+namespace MusicStore.Infrastructure
+{
+    public static class SortExpression
+    {
+        private const string SORT_DIRECTION_DESC = " DESC";
+
+        public static IQueryable<TModel> SortBy<TModel, TProperty>(this IQueryable<TModel> query, string sortExpression, Expression<Func<TModel, TProperty>> defaultSortExpression, SortDirection defaultSortDirection = SortDirection.Ascending) where TModel : class
+        {
+            return SortBy(query, sortExpression ?? Create(defaultSortExpression, defaultSortDirection));
+        }
+
+        public static string Create<TModel, TProperty>(Expression<Func<TModel, TProperty>> expression, SortDirection sortDirection = SortDirection.Ascending) where TModel : class
+        {
+            var expressionText = ExpressionHelper.GetExpressionText(expression);
+            // TODO: Validate the expression depth, etc.
+
+            var sortExpression = expressionText;
+
+            if (sortDirection == SortDirection.Descending)
+            {
+                sortExpression += SORT_DIRECTION_DESC;
+            }
+
+            return sortExpression;
+        }
+
+        public static IQueryable<T> SortBy<T>(this IQueryable<T> source, string sortExpression) where T : class
+        {
+            if (source == null)
+            {
+                throw new ArgumentNullException("source");
+            }
+
+            if (String.IsNullOrWhiteSpace(sortExpression))
+            {
+                return source;
+            }
+
+            sortExpression = sortExpression.Trim();
+            var isDescending = false;
+
+            // DataSource control passes the sort parameter with a direction
+            // if the direction is descending
+            if (sortExpression.EndsWith(SORT_DIRECTION_DESC, StringComparison.OrdinalIgnoreCase))
+            {
+                isDescending = true;
+                var descIndex = sortExpression.Length - SORT_DIRECTION_DESC.Length;
+                sortExpression = sortExpression.Substring(0, descIndex).Trim();
+            }
+
+            if (string.IsNullOrEmpty(sortExpression))
+            {
+                return source;
+            }
+
+            ParameterExpression parameter = Expression.Parameter(source.ElementType, String.Empty);
+
+            // Build up the property expression, e.g.: (m => m.Foo.Bar)
+            var sortExpressionParts = sortExpression.Split('.');
+            Expression propertyExpression = parameter;
+            foreach (var property in sortExpressionParts)
+            {
+                propertyExpression = Expression.Property(propertyExpression, property);
+            }
+
+            LambdaExpression lambda = Expression.Lambda(propertyExpression, parameter);
+
+            var methodName = (isDescending) ? "OrderByDescending" : "OrderBy";
+
+            Expression methodCallExpression = Expression.Call(
+                typeof(Queryable),
+                methodName,
+                new[] { source.ElementType, propertyExpression.Type },
+                source.Expression,
+                Expression.Quote(lambda));
+
+            return (IQueryable<T>)source.Provider.CreateQuery(methodCallExpression);
+        }
+    }
+}