mirror of https://github.com/abpframework/abp
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
228 lines
8.3 KiB
228 lines
8.3 KiB
# Web Application Development Tutorial - Part 7: Authors: Database Integration
|
|
````json
|
|
//[doc-params]
|
|
{
|
|
"UI": ["MVC","Blazor","NG"],
|
|
"DB": ["EF","Mongo"]
|
|
}
|
|
````
|
|
## About This Tutorial
|
|
|
|
In this tutorial series, you will build an ABP based web application named `Acme.BookStore`. This application is used to manage a list of books and their authors. It is developed using the following technologies:
|
|
|
|
* **{{DB_Value}}** as the ORM provider.
|
|
* **{{UI_Value}}** as the UI Framework.
|
|
|
|
This tutorial is organized as the following parts;
|
|
|
|
- [Part 1: Creating the server side](Part-1.md)
|
|
- [Part 2: The book list page](Part-2.md)
|
|
- [Part 3: Creating, updating and deleting books](Part-3.md)
|
|
- [Part 4: Integration tests](Part-4.md)
|
|
- [Part 5: Authorization](Part-5.md)
|
|
- [Part 6: Authors: Domain layer](Part-6.md)
|
|
- **Part 7: Authors: Database Integration (this part)**
|
|
- [Part 8: Authors: Application Layer](Part-8.md)
|
|
- [Part 9: Authors: User Interface](Part-9.md)
|
|
- [Part 10: Book to Author Relation](Part-10.md)
|
|
|
|
### Download the Source Code
|
|
|
|
This tutorial has multiple versions based on your **UI** and **Database** preferences. We've prepared a few combinations of the source code to be downloaded:
|
|
|
|
* [MVC (Razor Pages) UI with EF Core](https://github.com/abpframework/abp-samples/tree/master/BookStore-Mvc-EfCore)
|
|
* [Blazor UI with EF Core](https://github.com/abpframework/abp-samples/tree/master/BookStore-Blazor-EfCore)
|
|
* [Angular UI with MongoDB](https://github.com/abpframework/abp-samples/tree/master/BookStore-Angular-MongoDb)
|
|
|
|
## Introduction
|
|
|
|
This part explains how to configure the database integration for the `Author` entity introduced in the previous part.
|
|
|
|
{{if DB=="EF"}}
|
|
|
|
## DB Context
|
|
|
|
Open the `BookStoreDbContext` in the `Acme.BookStore.EntityFrameworkCore` project and add the following `DbSet` property:
|
|
|
|
````csharp
|
|
public DbSet<Author> Authors { get; set; }
|
|
````
|
|
|
|
Then open the `BookStoreDbContextModelCreatingExtensions` class in the same project and add the following lines to the end of the `ConfigureBookStore` method:
|
|
|
|
````csharp
|
|
builder.Entity<Author>(b =>
|
|
{
|
|
b.ToTable(BookStoreConsts.DbTablePrefix + "Authors",
|
|
BookStoreConsts.DbSchema);
|
|
|
|
b.ConfigureByConvention();
|
|
|
|
b.Property(x => x.Name)
|
|
.IsRequired()
|
|
.HasMaxLength(AuthorConsts.MaxNameLength);
|
|
|
|
b.HasIndex(x => x.Name);
|
|
});
|
|
````
|
|
|
|
This is just like done for the `Book` entity before, so no need to explain again.
|
|
|
|
## Create a new Database Migration
|
|
|
|
Open the **Package Manager Console** on Visual Studio and ensure that the **Default project** is `Acme.BookStore.EntityFrameworkCore.DbMigrations` in the Package Manager Console, as shown on the picture below. Also, set the `Acme.BookStore.Web` (or `Acme.BookStore.HttpApi.Host`, depending on your solution) as the **startup project** (right click it on the solution explorer and click to "Set as Startup Project").
|
|
|
|
Run the following command to create a new database migration:
|
|
|
|
````bash
|
|
Add-Migration "Added_Authors"
|
|
````
|
|
|
|
|
|
|
|
This will create a new migration class. Then run the `Update-Database` command to create the table on the database.
|
|
|
|
> See the [Microsoft's documentation](https://docs.microsoft.com/en-us/ef/core/managing-schemas/migrations/) for more about the EF Core database migrations.
|
|
|
|
{{else if DB=="Mongo"}}
|
|
|
|
## DB Context
|
|
|
|
Open the `BookStoreMongoDbContext` in the `MongoDb` folder of the `Acme.BookStore.MongoDB` project and add the following property to the class:
|
|
|
|
````csharp
|
|
public IMongoCollection<Author> Authors => Collection<Author>();
|
|
````
|
|
|
|
{{end}}
|
|
|
|
## Implementing the IAuthorRepository
|
|
|
|
{{if DB=="EF"}}
|
|
|
|
Create a new class, named `EfCoreAuthorRepository` inside the `Acme.BookStore.EntityFrameworkCore` project (in the `Authors` folder) and paste the following code:
|
|
|
|
````csharp
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Linq.Dynamic.Core;
|
|
using System.Threading.Tasks;
|
|
using Acme.BookStore.EntityFrameworkCore;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
|
|
using Volo.Abp.EntityFrameworkCore;
|
|
|
|
namespace Acme.BookStore.Authors
|
|
{
|
|
public class EfCoreAuthorRepository
|
|
: EfCoreRepository<BookStoreDbContext, Author, Guid>,
|
|
IAuthorRepository
|
|
{
|
|
public EfCoreAuthorRepository(
|
|
IDbContextProvider<BookStoreDbContext> dbContextProvider)
|
|
: base(dbContextProvider)
|
|
{
|
|
}
|
|
|
|
public async Task<Author> FindByNameAsync(string name)
|
|
{
|
|
var dbSet = await GetDbSetAsync();
|
|
return await dbSet.FirstOrDefaultAsync(author => author.Name == name);
|
|
}
|
|
|
|
public async Task<List<Author>> GetListAsync(
|
|
int skipCount,
|
|
int maxResultCount,
|
|
string sorting,
|
|
string filter = null)
|
|
{
|
|
var dbSet = await GetDbSetAsync();
|
|
return await dbSet
|
|
.WhereIf(
|
|
!filter.IsNullOrWhiteSpace(),
|
|
author => author.Name.Contains(filter)
|
|
)
|
|
.OrderBy(sorting)
|
|
.Skip(skipCount)
|
|
.Take(maxResultCount)
|
|
.ToListAsync();
|
|
}
|
|
}
|
|
}
|
|
````
|
|
|
|
* Inherited from the `EfCoreRepository`, so it inherits the standard repository method implementations.
|
|
* `WhereIf` is a shortcut extension method of the ABP Framework. It adds the `Where` condition only if the first condition meets (it filters by name, only if the filter was provided). You could do the same yourself, but these type of shortcut methods makes our life easier.
|
|
* `sorting` can be a string like `Name`, `Name ASC` or `Name DESC`. It is possible by using the [System.Linq.Dynamic.Core](https://www.nuget.org/packages/System.Linq.Dynamic.Core) NuGet package.
|
|
|
|
> See the [EF Core Integration document](../Entity-Framework-Core.md) for more information on the EF Core based repositories.
|
|
|
|
{{else if DB=="Mongo"}}
|
|
|
|
Create a new class, named `MongoDbAuthorRepository` inside the `Acme.BookStore.MongoDB` project (in the `Authors` folder) and paste the following code:
|
|
|
|
```csharp
|
|
using System;
|
|
using System.Linq;
|
|
using System.Linq.Dynamic.Core;
|
|
using System.Collections.Generic;
|
|
using System.Threading.Tasks;
|
|
using Acme.BookStore.MongoDB;
|
|
using MongoDB.Driver;
|
|
using MongoDB.Driver.Linq;
|
|
using Volo.Abp.Domain.Repositories.MongoDB;
|
|
using Volo.Abp.MongoDB;
|
|
|
|
namespace Acme.BookStore.Authors
|
|
{
|
|
public class MongoDbAuthorRepository
|
|
: MongoDbRepository<BookStoreMongoDbContext, Author, Guid>,
|
|
IAuthorRepository
|
|
{
|
|
public MongoDbAuthorRepository(
|
|
IMongoDbContextProvider<BookStoreMongoDbContext> dbContextProvider
|
|
) : base(dbContextProvider)
|
|
{
|
|
}
|
|
|
|
public async Task<Author> FindByNameAsync(string name)
|
|
{
|
|
var queryable = await GetMongoQueryableAsync();
|
|
return await queryable.FirstOrDefaultAsync(author => author.Name == name);
|
|
}
|
|
|
|
public async Task<List<Author>> GetListAsync(
|
|
int skipCount,
|
|
int maxResultCount,
|
|
string sorting,
|
|
string filter = null)
|
|
{
|
|
var queryable = await GetMongoQueryableAsync();
|
|
return await queryable
|
|
.WhereIf<Author, IMongoQueryable<Author>>(
|
|
!filter.IsNullOrWhiteSpace(),
|
|
author => author.Name.Contains(filter)
|
|
)
|
|
.OrderBy(sorting)
|
|
.As<IMongoQueryable<Author>>()
|
|
.Skip(skipCount)
|
|
.Take(maxResultCount)
|
|
.ToListAsync();
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
* Inherited from the `MongoDbRepository`, so it inherits the standard repository method implementations.
|
|
* `WhereIf` is a shortcut extension method of the ABP Framework. It adds the `Where` condition only if the first condition meets (it filters by name, only if the filter was provided). You could do the same yourself, but these type of shortcut methods makes our life easier.
|
|
* `sorting` can be a string like `Name`, `Name ASC` or `Name DESC`. It is possible by using the [System.Linq.Dynamic.Core](https://www.nuget.org/packages/System.Linq.Dynamic.Core) NuGet package.
|
|
|
|
> See the [MongoDB Integration document](../MongoDB.md) for more information on the MongoDB based repositories.
|
|
|
|
{{end}}
|
|
|
|
## The Next Part
|
|
|
|
See the [next part](Part-8.md) of this tutorial.
|