refactor(data): use entity repository to access data

Author: jaredcnance

src/JsonApiDotNetCore/Controllers/JsonApiController.cs

@@ -1,9 +1,10 @@
 using System.Linq;
-using JsonApiDotNetCore.Extensions;
+using System.Threading.Tasks;
+using JsonApiDotNetCore.Data;
 using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Services;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.EntityFrameworkCore;
+using Microsoft.AspNetCore.Routing;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 
@@ -12,58 +13,56 @@ namespace JsonApiDotNetCore.Controllers
     public class JsonApiController<T> : JsonApiController<T, int> where T : class, IIdentifiable<int>
     {
         public JsonApiController(
-            ILoggerFactory loggerFactory,
-            DbContext context,
-            IJsonApiContext jsonApiContext)
-            : base(loggerFactory, context, jsonApiContext)
+            IJsonApiContext jsonApiContext,
+            IEntityRepository<T, int> entityRepository,
+            ILoggerFactory loggerFactory)
+            : base(jsonApiContext, entityRepository, loggerFactory)
         { }
     }
 
     public class JsonApiController<T, TId> : Controller where T : class, IIdentifiable<TId>
     {
-        private readonly DbContext _context;
-        private readonly DbSet<T> _dbSet;
+        private readonly IEntityRepository<T, TId> _entities;
         private readonly IJsonApiContext _jsonApiContext;
         private readonly ILogger _logger;
 
         public JsonApiController(
-            ILoggerFactory loggerFactory,
-            DbContext context,
-            IJsonApiContext jsonApiContext)
+            IJsonApiContext jsonApiContext,
+            IEntityRepository<T, TId> entityRepository,
+            ILoggerFactory loggerFactory)
         {
-            _context = context;
-            _dbSet = context.GetDbSet<T>();
             _jsonApiContext = jsonApiContext;
+            _entities = entityRepository;
 
             _logger = loggerFactory.CreateLogger<JsonApiController<T, TId>>();
             _logger.LogTrace($@"JsonApiController activated with ContextGraph: 
                 {JsonConvert.SerializeObject(jsonApiContext.ContextGraph)}");
         }
 
         public JsonApiController(
-            DbContext context,
-            IJsonApiContext jsonApiContext)
+            IJsonApiContext jsonApiContext,
+            IEntityRepository<T, TId> entityRepository)
         {
-            _context = context;
-            _dbSet = context.GetDbSet<T>();
             _jsonApiContext = jsonApiContext;
+            _entities = entityRepository;
         }
 
         [HttpGet]
         public virtual IActionResult Get()
         {
             ApplyContext();
 
-            var entities = _dbSet.ToList();
+            var entities = _entities.Get().ToList();
+
             return Ok(entities);
         }
 
         [HttpGet("{id}")]
-        public virtual IActionResult Get(TId id)
+        public virtual async Task<IActionResult> GetAsync(TId id)
         {
             ApplyContext();
 
-            var entity = _dbSet.FirstOrDefault(e => e.Id.Equals(id));
+            var entity = await _entities.GetAsync(id);
 
             if (entity == null)
                 return NotFound();
@@ -72,7 +71,7 @@ public virtual IActionResult Get(TId id)
         }
 
         [HttpGet("{id}/{relationshipName}")]
-        public virtual IActionResult GetRelationship(TId id, string relationshipName)
+        public virtual async Task<IActionResult> GetRelationshipAsync(TId id, string relationshipName)
         {
             ApplyContext();
 
@@ -81,9 +80,7 @@ public virtual IActionResult GetRelationship(TId id, string relationshipName)
             if (relationshipName == null)
                 return NotFound();
 
-            var entity = _dbSet
-                .Include(relationshipName)
-                .FirstOrDefault(e => e.Id.Equals(id));
+            var entity = await _entities.GetAndIncludeAsync(id, relationshipName);
 
             if (entity == null)
                 return NotFound();
@@ -100,41 +97,29 @@ public virtual IActionResult GetRelationship(TId id, string relationshipName)
         }
 
         [HttpPost]
-        public virtual IActionResult Post([FromBody] T entity)
+        public virtual async Task<IActionResult> PostAsync([FromBody] T entity)
         {
             ApplyContext();
 
             if (entity == null)
                 return BadRequest();
 
-            _dbSet.Add(entity);
-            _context.SaveChanges();
+            await _entities.CreateAsync(entity);
 
             return Created(HttpContext.Request.Path, entity);
         }
 
         [HttpPatch("{id}")]
-        public virtual IActionResult Patch(int id, [FromBody] T entity)
+        public virtual async Task<IActionResult> PatchAsync(TId id, [FromBody] T entity)
         {
             ApplyContext();
 
             if (entity == null)
                 return BadRequest();
 
-            var oldEntity = _dbSet.FirstOrDefault(e => e.Id.Equals(id));
-            if (oldEntity == null)
-                return NotFound();
-
-            var requestEntity = _jsonApiContext.RequestEntity;
-
-            requestEntity.Attributes.ForEach(attr =>
-            {
-                attr.SetValue(oldEntity, attr.GetValue(entity));
-            });
+            var updatedEntity = await _entities.UpdateAsync(id, entity);
 
-            _context.SaveChanges();
-
-            return Ok(oldEntity);
+            return Ok(updatedEntity);
         }
 
         // [HttpPatch("{id}/{relationship}")]
@@ -144,16 +129,14 @@ public virtual IActionResult Patch(int id, [FromBody] T entity)
         // }
 
         [HttpDelete("{id}")]
-        public virtual IActionResult Delete(TId id)
+        public virtual async Task<IActionResult> DeleteAsync(TId id)
         {
             ApplyContext();
 
-            var entity = _dbSet.FirstOrDefault(e => e.Id.Equals(id));
-            if (entity == null)
-                return NotFound();
+            var wasDeleted = await _entities.DeleteAsync(id);
 
-            _dbSet.Remove(entity);
-            _context.SaveChanges();
+            if (!wasDeleted)
+                return NotFound();
 
             return Ok();
         }
@@ -166,6 +149,7 @@ public virtual IActionResult Delete(TId id)
 
         private void ApplyContext()
         {
+            var routeData = HttpContext.GetRouteData();
             _jsonApiContext.RequestEntity = _jsonApiContext.ContextGraph.GetContextEntity(typeof(T));
             _jsonApiContext.ApplyContext(HttpContext);
         }

src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs

@@ -0,0 +1,86 @@
+using System.Linq;
+using System.Threading.Tasks;
+using JsonApiDotNetCore.Extensions;
+using JsonApiDotNetCore.Models;
+using JsonApiDotNetCore.Services;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace JsonApiDotNetCore.Data
+{
+    public class DefaultEntityRepository<TEntity, TId> 
+        : IEntityRepository<TEntity, TId> 
+        where TEntity : class, IIdentifiable<TId>
+    {
+        private readonly DbContext _context;
+        private readonly DbSet<TEntity> _dbSet;
+        private readonly ILogger _logger;
+        private readonly IJsonApiContext _jsonApiContext;
+
+        public DefaultEntityRepository(
+            DbContext context,
+            ILoggerFactory loggerFactory,
+            IJsonApiContext jsonApiContext)
+        {
+            _context = context;
+            _dbSet = context.GetDbSet<TEntity>();
+            _jsonApiContext = jsonApiContext;
+            _logger = loggerFactory.CreateLogger<DefaultEntityRepository<TEntity, TId>>();
+        }
+
+        public IQueryable<TEntity> Get()
+        {
+            return _dbSet;
+        }
+
+        public async Task<TEntity> GetAsync(TId id)
+        {
+            return await _dbSet.FirstOrDefaultAsync(e => e.Id.Equals(id));
+        }
+
+        public async Task<TEntity> GetAndIncludeAsync(TId id, string relationshipName)
+        {
+            return await _dbSet
+                .Include(relationshipName)
+                .FirstOrDefaultAsync(e => e.Id.Equals(id));
+        }
+
+        public async Task<TEntity> CreateAsync(TEntity entity)
+        {
+            _dbSet.Add(entity);
+            await _context.SaveChangesAsync();
+            return entity;
+        }
+
+        public async Task<TEntity> UpdateAsync(TId id, TEntity entity)
+        {
+            var oldEntity = await GetAsync(id);
+
+            if (oldEntity == null)
+                return null;
+
+            _jsonApiContext.RequestEntity.Attributes.ForEach(attr =>
+            {
+                attr.SetValue(oldEntity, attr.GetValue(entity));
+            });
+
+            await _context.SaveChangesAsync();
+
+            return entity;
+        }
+
+        public async Task<bool> DeleteAsync(TId id)
+        {
+            var entity = await GetAsync(id);
+
+            if (entity == null)
+                return false;
+
+            _dbSet.Remove(entity);
+
+            await _context.SaveChangesAsync();
+
+            return true;
+        }
+    }
+}

src/JsonApiDotNetCore/Data/IEntityRepository.cs

@@ -0,0 +1,22 @@
+using System.Linq;
+using System.Threading.Tasks;
+using JsonApiDotNetCore.Models;
+
+namespace JsonApiDotNetCore.Data
+{
+    public interface IEntityRepository<TEntity, in TId>
+        where TEntity : class, IIdentifiable<TId>
+    {
+        IQueryable<TEntity> Get();
+
+        Task<TEntity> GetAsync(TId id);
+
+        Task<TEntity> GetAndIncludeAsync(TId id, string relationshipName);
+
+        Task<TEntity> CreateAsync(TEntity entity);
+
+        Task<TEntity> UpdateAsync(TId id, TEntity entity);
+
+        Task<bool> DeleteAsync(TId id);
+    }
+}

src/JsonApiDotNetCore/Extensions/IApplicationBuilderExtensions.cs

@@ -0,0 +1,36 @@
+using System;
+using JsonApiDotNetCore.Internal;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Mvc.Infrastructure;
+using Microsoft.AspNetCore.Mvc.Internal;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace JsonApiDotNetCore.Routing
+{
+    public static class IApplicationBuilderExtensions
+    {
+        public static IApplicationBuilder UseJsonApi(this IApplicationBuilder app)
+        {
+            if (app == null)
+                throw new ArgumentNullException(nameof(app));
+
+            // Verify if AddMvc was done before calling UseMvc
+            // We use the MvcMarkerService to make sure if all the services were added.
+            if (app.ApplicationServices.GetService(typeof(MvcMarkerService)) == null)
+                throw new InvalidOperationException();
+
+            var middlewarePipelineBuilder = app.ApplicationServices.GetRequiredService<MiddlewareFilterBuilder>();
+            middlewarePipelineBuilder.ApplicationBuilder = app.New();
+
+            var routes = new RouteBuilder(app)
+            {
+                DefaultHandler = app.ApplicationServices.GetRequiredService<JsonApiRouteHandler>(),
+            };
+
+            routes.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(app.ApplicationServices));
+
+            return app.UseRouter(routes.Build());
+        }
+    }
+}

src/JsonApiDotNetCore/Extensions/ServiceProviderExtensions.cs

@@ -1,3 +1,4 @@
+using JsonApiDotNetCore.Data;
 using JsonApiDotNetCore.Formatters;
 using JsonApiDotNetCore.Internal;
 using JsonApiDotNetCore.Services;
@@ -9,26 +10,34 @@ namespace JsonApiDotNetCore.Extensions
 {
     public static class ServiceProviderExtensions
     {
-        public static void AddJsonApi<T>(this IServiceCollection services) where T : DbContext
+        public static void AddJsonApi<TContext>(this IServiceCollection services) 
+            where TContext : DbContext
         {
-            services.AddJsonApiInternals<T>();
+            services.AddJsonApiInternals<TContext>();
             services.AddMvc()
                 .AddMvcOptions(options => options.SerializeAsJsonApi());
         }
 
-        public static void AddJsonApiInternals<T>(this IServiceCollection services) where T : DbContext
+        public static void AddJsonApiInternals<TContext>(this IServiceCollection services) 
+            where TContext : DbContext
         {
-            var contextGraphBuilder = new ContextGraphBuilder<T>();
+            var contextGraphBuilder = new ContextGraphBuilder<TContext>();
             var contextGraph = contextGraphBuilder.Build();
 
+            services.AddScoped(typeof(DbContext), typeof(TContext));
+
+            services.AddScoped(typeof(IEntityRepository<,>), typeof(DefaultEntityRepository<,>));
+            // services.AddScoped(typeof(IEntityRepository<,>), typeof(DefaultEntityRepository<,>));
+
             services.AddSingleton<IContextGraph>(contextGraph);
             services.AddSingleton<IJsonApiContext, JsonApiContext>();
+            services.AddScoped<JsonApiRouteHandler>();
         }
 
         public static void SerializeAsJsonApi(this MvcOptions options)
         {
             options.InputFormatters.Insert(0, new JsonApiInputFormatter());
-
+            
             options.OutputFormatters.Insert(0, new JsonApiOutputFormatter());
         }
     }