Update README.md

Author: mehmetozkaya

README.md

@@ -106,187 +106,100 @@ The below image represents aspnetrun approach of development architecture of run
 ![DDD_png_pure](https://user-images.githubusercontent.com/1147445/54773098-e1efe700-4c19-11e9-9150-74f7e770de42.png)
 
 ### Structure of Project
-Repository include layers divided by **4 project**;
-* Core
- * Entities 
- * Interfaces
- * Specifications
- * ValueObjects
- * Exceptions
-* Application 
- * Interfaces 
- * Services
- * Dtos
- * Mapper
- * Exceptions
-* Infrastructure
- * Data
- * Repository
- * Services
- * Migrations
- * Logging
- * Exceptions
-* Web
- * Interfaces
- * Services
- * Pages
- * ViewModels
- * Extensions
- * Mapper
-
-### Core Layer
-Development of Domain Logic with abstraction. Interfaces drives business requirements with light implementation. The Core project is the **center of the Clean Architecture** design, and all other project dependencies should point toward it. 
-
-#### Entities
-Includes Entity Framework Core Entities which creates sql table with **Entity Framework Core Code First Aproach**. Some Aggregate folders holds entity and aggregates.
-You can see example of **code-first** Entity definition as below;
-
-```csharp
-public class Product : BaseEntity
-{ 
- public string ProductName { get; set; }
- public string QuantityPerUnit { get; set; }
- public decimal? UnitPrice { get; set; }
- public short? UnitsInStock { get; set; }
- public short? UnitsOnOrder { get; set; }
- public short? ReorderLevel { get; set; }
- public bool Discontinued { get; set; }
- public int CategoryId { get; set; }
- public Category Category { get; set; }
-
- public static Product Create(int productId, int categoryId, string name, decimal? unitPrice = null, short? unitsInStock = null, short? unitsOnOrder = null, short? reorderLevel = null, bool discontinued = false)
- {
- var product = new Product
- {
- Id = productId,
- CategoryId = categoryId,
- ProductName = name,
- UnitPrice = unitPrice,
- UnitsInStock = unitsInStock,
- UnitsOnOrder = unitsOnOrder,
- ReorderLevel = reorderLevel,
- Discontinued = discontinued
- };
- return product;
- }
-}
-```
-Applying domain driven approach, Product class responsible to create Product instance. 
-
-#### Interfaces
-Abstraction of Repository - Domain repositories (IAsyncRepository - IProductRepository) - Specifications etc.. This interfaces include database operations without any application and ui responsibilities.
-
-#### Specifications
-This folder is implementation of **[specification pattern](https://en.wikipedia.org/wiki/Specification_pattern)**. Creates custom scripts with using **ISpecification** interface. Using BaseSpecification managing Criteria, Includes, OrderBy, Paging.
-This specs runs when EF commands working with passing spec. This specs implemented SpecificationEvaluator.cs and creates query to AspnetRunRepository.cs in ApplySpecification method.This helps create custom queries.
-
-### Infrastructure Layer
-Implementation of Core interfaces in this project with **Entity Framework Core** and other dependencies.
-Most of your application's dependence on external resources should be implemented in classes defined in the Infrastructure project. These classes must implement the interfaces defined in Core. If you have a very large project with many dependencies, it may make sense to have more than one Infrastructure project (eg Infrastructure.Data), but in most projects one Infrastructure project that contains folders works well.
-This could be includes, for example, **e-mail providers, file access, web api clients**, etc. For now this repository only dependend sample data access and basic domain actions, by this way there will be no direct links to your Core or UI projects.
-
-#### Data
+AspnetRunBasic has only **one solution** and into this solution only **one web application project** which include all components of project structure. The idea is that **fast implementation, minimum development, bootstrap your idea, create Minimum Viable Product (MVP), idea validation, startup development implementation** for a **limited time** and **limited resources** with using asp.net core and entity framework core. 
+
+Repository include folders for group implementations;
+* Data
+ * AspnetRunContext 
+ * AspnetRunContextSeed 
+* Entities
+ * Product 
+ * Category 
+* Migrations
+ * Generated by scaffolding from ef.core 
+* Pages
+ * Default Razor Web Application Template of Asp.Net Core
+* Repositories
+ * IProductRepository
+ * ProductRepository
+ 
+### Data Folder
 Includes **Entity Framework Core Context** and tables in this folder. When new entity created, it should add to context and configure in context.
 The Infrastructure project depends on Microsoft.**EntityFrameworkCore.SqlServer** and EF.Core related nuget packages, you can check nuget packages of Infrastructure layer. If you want to change your data access layer, it can easily be replaced with a lighter-weight ORM like Dapper. 
 
 #### Migrations
 EF add-migration classes.
 #### Repository
-EF Repository and Specification implementation. This class responsible to create queries, includes, where conditions etc..
-#### Services
-Custom services implementation, like email, cron jobs etc.
+EF Repository implementation. This class responsible to create queries, includes, where conditions etc..
 
-### Application Layer
-Development of **Domain Logic with implementation**. Interfaces drives business requirements and implementations in this layer.
-Application layer defines that user required actions in app services classes as below way;
+#### Entities Folder
+Includes Entity Framework Core Entities which creates sql table with **Entity Framework Core Code First Aproach**. Some Aggregate folders holds entity and aggregates.
+You can see example of **code-first** Entity definition as below;
 
 ```csharp
-public interface IProductAppService
-{
- Task<IEnumerable<ProductDto>> GetProductList();
- Task<ProductDto> GetProductById(int productId);
- Task<IEnumerable<ProductDto>> GetProductByName(string productName);
- Task<IEnumerable<ProductDto>> GetProductByCategory(int categoryId);
- Task<ProductDto> Create(ProductDto entityDto);
- Task Update(ProductDto entityDto);
- Task Delete(ProductDto entityDto);
-}
-```
-Also implementation located same places in order to choose different implementation at runtime when DI bootstrapped.
-```csharp
-public class ProductAppService : IProductAppService
-{
- private readonly IProductRepository _productRepository;
- private readonly IAppLogger<ProductAppService> _logger;
-
- public ProductAppService(IProductRepository productRepository, IAppLogger<ProductAppService> logger)
+public class Product
  {
- _productRepository = productRepository ?? throw new ArgumentNullException(nameof(productRepository));
- _logger = logger ?? throw new ArgumentNullException(nameof(logger));
- }
+ public int Id { get; set; }
 
- public async Task<IEnumerable<ProductDto>> GetProductList()
- {
- var productList = await _productRepository.GetProductListAsync();
- var mapped = ObjectMapper.Mapper.Map<IEnumerable<ProductDto>>(productList);
- return mapped;
+ [Required, StringLength(80)]
+ public string Name { get; set; }
+
+ [Required, StringLength(255)]
+ public string Description { get; set; }
+
+ public int UnitPrice { get; set; } 
+
+ public int CategoryId { get; set; }
+ public Category Category { get; set; }
  }
-}
 ```
-In this layer we can add validation , authorization, logging, exception handling etc. -- cross cutting activities should be handled in here.
 
-### Web Layer
-Development of UI Logic with implementation. Interfaces drives business requirements and implementations in this layer.
-The application's main **starting point** is the ASP.NET Core web project. This is a classical console application, with a public static void Main method in Program.cs. It currently uses the default **ASP.NET Core project template** which based on **Razor Pages** templates. This includes appsettings.json file plus environment variables in order to stored configuration parameters, and is configured in Startup.cs.
+### Repository Folder
+Implementation of Core interfaces in this project with **Entity Framework Core** and other dependencies.
+Most of your application's dependence on external resources should be implemented in classes defined in the Infrastructure project. These classes must implement the interfaces defined in Core. If you have a very large project with many dependencies, it may make sense to have more than one Infrastructure project (eg Infrastructure.Data), but in most projects one Infrastructure project that contains folders works well.
+This could be includes, for example, **e-mail providers, file access, web api clients**, etc. For now this repository only dependend sample data access and basic domain actions, by this way there will be no direct links to your Core or UI projects.
 
-Web layer defines that user required actions in page services classes as below way;
 ```csharp
-public interface IProductPageService
-{
- Task<IEnumerable<ProductViewModel>> GetProducts(string productName);
- Task<ProductViewModel> GetProductById(int productId);
- Task<IEnumerable<ProductViewModel>> GetProductByCategory(int categoryId);
- Task<IEnumerable<CategoryViewModel>> GetCategories();
- Task<ProductViewModel> CreateProduct(ProductViewModel productViewModel);
- Task UpdateProduct(ProductViewModel productViewModel);
- Task DeleteProduct(ProductViewModel productViewModel);
-}
+public interface IProductRepository
+ {
+ Task<IEnumerable<Product>> GetProductListAsync();
+ Task<Product> GetProductByIdAsync(int id);
+ Task<IEnumerable<Product>> GetProductByNameAsync(string name);
+ Task<IEnumerable<Product>> GetProductByCategoryAsync(int categoryId);
+ Task<Product> AddAsync(Product product);
+ Task UpdateAsync(Product product);
+ Task DeleteAsync(Product product);
+ Task<IEnumerable<Category>> GetCategories();
+ }
 ```
 Also implementation located same places in order to choose different implementation at runtime when DI bootstrapped.
 ```csharp
-public class ProductPageService : IProductPageService
-{
- private readonly IProductAppService _productAppService;
- private readonly ICategoryAppService _categoryAppService;
- private readonly IMapper _mapper;
- private readonly ILogger<ProductPageService> _logger;
-
- public ProductPageService(IProductAppService productAppService, ICategoryAppService categoryAppService, IMapper mapper, ILogger<ProductPageService> logger)
+ public class ProductRepository : IProductRepository
  {
- _productAppService = productAppService ?? throw new ArgumentNullException(nameof(productAppService));
- _categoryAppService = categoryAppService ?? throw new ArgumentNullException(nameof(categoryAppService));
- _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
- _logger = logger ?? throw new ArgumentNullException(nameof(logger));
- }
+ protected readonly AspnetRunContext _dbContext;
 
- public async Task<IEnumerable<ProductViewModel>> GetProducts(string productName)
- {
- if (string.IsNullOrWhiteSpace(productName))
+ public ProductRepository(AspnetRunContext dbContext)
  {
- var list = await _productAppService.GetProductList();
- var mapped = _mapper.Map<IEnumerable<ProductViewModel>>(list);
- return mapped;
+ _dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
  }
 
- var listByName = await _productAppService.GetProductByName(productName);
- var mappedByName = _mapper.Map<IEnumerable<ProductViewModel>>(listByName);
- return mappedByName;
- }
-}
+ public async Task<IEnumerable<Product>> GetProductListAsync()
+ {
+ return await _dbContext.Products.ToListAsync();
+ }
+
+ public async Task<Product> GetProductByIdAsync(int id)
+ {
+ return await _dbContext.Products
+ .Include(p => p.Category)
+ .FirstOrDefaultAsync(p => p.Id == id);
+ }
 ```
-### Test Layer
-For each layer, there is a test project which includes intended layer dependencies and mock classes. So that means Core-Application-Infrastructure and Web layer has their own test layer. By this way this test projects also divided by **unit, functional and integration tests** defined by in which layer it is implemented. 
-Test projects using **xunit and Mock libraries**. xunit, because that's what ASP.NET Core uses internally to test the product. Moq, because perform to create fake objects clearly and its very modular.
+
+
+### Pages Folder
+Development of UI Logic with implementation. Interfaces drives business requirements and implementations in this layer.
+The application's main **starting point** is the ASP.NET Core web project. This is a classical console application, with a public static void Main method in Program.cs. It currently uses the default **ASP.NET Core project template** which based on **Razor Pages** templates. This includes appsettings.json file plus environment variables in order to stored configuration parameters, and is configured in Startup.cs.
 
 
 ## Technologies
@@ -297,16 +210,14 @@ Test projects using **xunit and Mock libraries**. xunit, because that's what AS
 * Razor Pages
 * AutoMapper
 
-## Architecture
-* Clean Architecture
-* Full architecture with responsibility separation of concerns
-* SOLID and Clean Code
-* Domain Driven Design (Layers and Domain Model Pattern)
-* Unit of Work
-* Repository and Generic Repository
+## Used Components
+* Asp.Net Core
+* Entity Framework Core
+* Razor Pages
+* Repository Design Pattern
 * Multiple Page Web Application (MPA)
 * Monolitic Deployment Architecture
-* Specification Pattern
+* SOLID and Clean Code
 
 ## Disclaimer