Ordering.Infrastructure done

Author: mehmetozkaya

src/Ordering/Ordering.Core/Repositories/IOrderRepository.cs

@@ -7,6 +7,6 @@ namespace Ordering.Core.Repositories
 {
     public interface IOrderRepository : IRepository<Order>
     {
-        Task<IEnumerable<Order>> GetOrderListAsync();
+        Task<IEnumerable<Order>> GetOrdersByUserName(string userName);
     }
 }

src/Ordering/Ordering.Infrastructure/Class1.cs

@@ -0,0 +1,14 @@
+using Microsoft.EntityFrameworkCore;
+using Ordering.Core.Entities;
+
+namespace Ordering.Infrastructure.Data
+{
+    public class OrderContext : DbContext
+    {
+        public OrderContext(DbContextOptions options) : base(options)
+        {
+        }
+
+        public DbSet<Order> Orders { get; set; }
+    }
+}

src/Ordering/Ordering.Infrastructure/Data/OrderContext.cs

@@ -0,0 +1,50 @@
+using Microsoft.Extensions.Logging;
+using Ordering.Core.Entities;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Ordering.Infrastructure.Data
+{
+    public class OrderContextSeed
+    {
+        public static async Task SeedAsync(OrderContext aspnetrunContext, ILoggerFactory loggerFactory, int? retry = 0)
+        {
+            int retryForAvailability = retry.Value;
+
+            try
+            {
+                // TODO: Only run this if using a real database
+                // aspnetrunContext.Database.Migrate();
+                // aspnetrunContext.Database.EnsureCreated();
+
+                if (!aspnetrunContext.Orders.Any())
+                {
+                    aspnetrunContext.Orders.AddRange(GetPreconfiguredOrders());
+                    await aspnetrunContext.SaveChangesAsync();
+                }
+            }
+            catch (Exception exception)
+            {
+                if (retryForAvailability < 5)
+                {
+                    retryForAvailability++;
+                    var log = loggerFactory.CreateLogger<OrderContextSeed>();
+                    log.LogError(exception.Message);
+                    await SeedAsync(aspnetrunContext, loggerFactory, retryForAvailability);
+                }
+                throw;
+            }
+        }
+
+        private static IEnumerable<Order> GetPreconfiguredOrders()
+        {
+            return new List<Order>()
+            {
+                new Order() { FirstName = "swn", LastName = "swn" },
+                new Order() { FirstName = "swn2", LastName = "swn2" }                
+            };
+        }
+    }
+}

src/Ordering/Ordering.Infrastructure/Data/OrderContextSeed.cs

@@ -1,7 +1,25 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="3.1.3" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="3.1.3">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="3.1.3" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="3.1.3" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="3.1.3">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Ordering.Core\Ordering.Core.csproj" />
+  </ItemGroup>
+
 </Project>

src/Ordering/Ordering.Infrastructure/Ordering.Infrastructure.csproj

@@ -0,0 +1,84 @@
+using Microsoft.EntityFrameworkCore;
+using Ordering.Core.Entities.Base;
+using Ordering.Core.Repositories.Base;
+using Ordering.Infrastructure.Data;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace Ordering.Infrastructure.Repository.Base
+{
+    public class Repository<T> : IRepository<T> where T : Entity
+    {
+        protected readonly OrderContext _dbContext;
+
+        public Repository(OrderContext dbContext)
+        {
+            _dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
+        }
+
+        public async Task<IReadOnlyList<T>> GetAllAsync()
+        {
+            return await _dbContext.Set<T>().ToListAsync();
+        }
+
+        public async Task<IReadOnlyList<T>> GetAsync(Expression<Func<T, bool>> predicate)
+        {
+            return await _dbContext.Set<T>().Where(predicate).ToListAsync();
+        }
+
+        public async Task<IReadOnlyList<T>> GetAsync(Expression<Func<T, bool>> predicate = null, Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null, string includeString = null, bool disableTracking = true)
+        {
+            IQueryable<T> query = _dbContext.Set<T>();
+            if (disableTracking) query = query.AsNoTracking();
+
+            if (!string.IsNullOrWhiteSpace(includeString)) query = query.Include(includeString);
+
+            if (predicate != null) query = query.Where(predicate);
+
+            if (orderBy != null)
+                return await orderBy(query).ToListAsync();
+            return await query.ToListAsync();
+        }
+
+        public async Task<IReadOnlyList<T>> GetAsync(Expression<Func<T, bool>> predicate = null, Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null, List<Expression<Func<T, object>>> includes = null, bool disableTracking = true)
+        {
+            IQueryable<T> query = _dbContext.Set<T>();
+            if (disableTracking) query = query.AsNoTracking();
+
+            if (includes != null) query = includes.Aggregate(query, (current, include) => current.Include(include));
+
+            if (predicate != null) query = query.Where(predicate);
+
+            if (orderBy != null)
+                return await orderBy(query).ToListAsync();
+            return await query.ToListAsync();
+        }
+
+        public virtual async Task<T> GetByIdAsync(int id)
+        {
+            return await _dbContext.Set<T>().FindAsync(id);
+        }
+
+        public async Task<T> AddAsync(T entity)
+        {
+            _dbContext.Set<T>().Add(entity);
+            await _dbContext.SaveChangesAsync();
+            return entity;
+        }
+
+        public async Task UpdateAsync(T entity)
+        {
+            _dbContext.Entry(entity).State = EntityState.Modified;
+            await _dbContext.SaveChangesAsync();
+        }
+
+        public async Task DeleteAsync(T entity)
+        {
+            _dbContext.Set<T>().Remove(entity);
+            await _dbContext.SaveChangesAsync();
+        }
+    }
+}

src/Ordering/Ordering.Infrastructure/Repository/Base/Repository.cs

@@ -0,0 +1,27 @@
+using Microsoft.EntityFrameworkCore;
+using Ordering.Core.Entities;
+using Ordering.Core.Repositories;
+using Ordering.Infrastructure.Data;
+using Ordering.Infrastructure.Repository.Base;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Ordering.Infrastructure.Repository
+{
+    public class OrderRepository : Repository<Order>, IOrderRepository
+    {
+        public OrderRepository(OrderContext dbContext) : base(dbContext)
+        {
+        }
+
+        public async Task<IEnumerable<Order>> GetOrdersByUserName(string userName)
+        {
+            var orderList = await _dbContext.Orders
+                      .Where(o => o.UserName == userName)
+                      .ToListAsync();
+
+            return orderList;
+        }        
+    }
+}