mirror of https://github.com/abpframework/abp
Yunus Emre Kalkan
5 years ago
commit
35e2a83a98
@ -1,26 +1,38 @@
|
||||
# COMMON PATHS
|
||||
$full = $args[0]
|
||||
|
||||
# COMMON PATHS
|
||||
|
||||
$rootFolder = (Get-Item -Path "./" -Verbose).FullName
|
||||
|
||||
# List of solutions
|
||||
# List of solutions used only in development mode
|
||||
$solutionPaths = @(
|
||||
"../framework",
|
||||
"../modules/users",
|
||||
"../modules/permission-management",
|
||||
"../modules/setting-management",
|
||||
"../modules/feature-management",
|
||||
"../modules/identity",
|
||||
"../modules/identityserver",
|
||||
"../modules/tenant-management",
|
||||
"../modules/audit-logging",
|
||||
"../modules/background-jobs",
|
||||
"../modules/account"
|
||||
)
|
||||
|
||||
$solutionPaths = (
|
||||
"../framework",
|
||||
"../modules/users",
|
||||
"../modules/permission-management",
|
||||
"../modules/setting-management",
|
||||
"../modules/feature-management",
|
||||
"../modules/identity",
|
||||
"../modules/identityserver",
|
||||
"../modules/tenant-management",
|
||||
"../modules/account",
|
||||
"../modules/docs",
|
||||
"../modules/blogging",
|
||||
"../modules/audit-logging",
|
||||
"../modules/background-jobs",
|
||||
"../modules/client-simulation",
|
||||
"../modules/virtual-file-explorer",
|
||||
"../templates/module/aspnet-core",
|
||||
"../templates/app/aspnet-core",
|
||||
"../abp_io/AbpIoLocalization"
|
||||
)
|
||||
if ($full -eq "-f")
|
||||
{
|
||||
# List of additional solutions required for full build
|
||||
$solutionPaths += (
|
||||
"../modules/client-simulation",
|
||||
"../modules/virtual-file-explorer",
|
||||
"../modules/docs",
|
||||
"../modules/blogging",
|
||||
"../templates/module/aspnet-core",
|
||||
"../templates/app/aspnet-core",
|
||||
"../abp_io/AbpIoLocalization"
|
||||
)
|
||||
}else{
|
||||
Write-host ""
|
||||
Write-host ":::::::::::::: !!! You are in development mode !!! ::::::::::::::" -ForegroundColor red -BackgroundColor yellow
|
||||
Write-host ""
|
||||
}
|
||||
|
||||
@ -0,0 +1,920 @@
|
||||
# Web Application Development Tutorial - Part 10: Book to Author Relation
|
||||
````json
|
||||
//[doc-params]
|
||||
{
|
||||
"UI": ["MVC","NG"],
|
||||
"DB": ["EF","Mongo"]
|
||||
}
|
||||
````
|
||||
{{
|
||||
if UI == "MVC"
|
||||
UI_Text="mvc"
|
||||
else if UI == "NG"
|
||||
UI_Text="angular"
|
||||
else
|
||||
UI_Text="?"
|
||||
end
|
||||
if DB == "EF"
|
||||
DB_Text="Entity Framework Core"
|
||||
else if DB == "Mongo"
|
||||
DB_Text="MongoDB"
|
||||
else
|
||||
DB_Text="?"
|
||||
end
|
||||
}}
|
||||
|
||||
## 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_Text}}** 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](Part-7.md)
|
||||
- [Part 8: Authors: Application Layer](Part-8.md)
|
||||
- [Part 9: Authors: User Interface](Part-9.md)
|
||||
- **Part 10: Book to Author Relation (this part)**
|
||||
|
||||
### Download the Source Code
|
||||
|
||||
This tutorials has multiple versions based on your **UI** and **Database** preferences. We've prepared two 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)
|
||||
* [Angular UI with MongoDB](https://github.com/abpframework/abp-samples/tree/master/BookStore-Angular-MongoDb)
|
||||
|
||||
## Introduction
|
||||
|
||||
We have created `Book` and `Author` functionalities for the book store application. However, currently there is no relation between these entities.
|
||||
|
||||
In this tutorial, we will establish a **1 to N** relation between the `Book` and the `Author`.
|
||||
|
||||
## Add Relation to The Book Entity
|
||||
|
||||
Open the `Books/Book.cs` in the `Acme.BookStore.Domain` project and add the following property to the `Book` entity:
|
||||
|
||||
````csharp
|
||||
public Guid AuthorId { get; set; }
|
||||
````
|
||||
|
||||
{{if DB=="EF"}}
|
||||
|
||||
> In this tutorial, we preferred to not add a **navigation property** to the `Author` entity (like `public Author Author { get; set; }`). This is due to follow the DDD best practices (rule: refer to other aggregates only by id). However, you can add such a navigation property and configure it for the EF Core. In this way, you don't need to write join queries while getting books with their entities (just like we will done below) which makes your application code simpler.
|
||||
|
||||
{{end}}
|
||||
|
||||
## Database & Data Migration
|
||||
|
||||
Added a new, required `AuthorId` property to the `Book` entity. But, what about the existing books on the database? They currently don't have `AuthorId`s and this will be a problem when we try to run the application.
|
||||
|
||||
This is a typical migration problem and the decision depends on your case;
|
||||
|
||||
* If you haven't published your application to the production yet, you can just delete existing books in the database, or you can even delete the entire database in your development environment.
|
||||
* You can do it programmatically on data migration or seed phase.
|
||||
* You can manually handle it on the database.
|
||||
|
||||
We prefer to delete the database {{if DB=="EF"}}(run the `Drop-Database` in the *Package Manager Console*){{end}} since this is just an example project and data loss is not important. Since this topic is not related to the ABP Framework, we don't go deeper for all the scenarios.
|
||||
|
||||
{{if DB=="EF"}}
|
||||
|
||||
### Update the EF Core Mapping
|
||||
|
||||
Open the `BookStoreDbContextModelCreatingExtensions` class under the `EntityFrameworkCore` folder of the `Acme.BookStore.EntityFrameworkCore` project and change the `builder.Entity<Book>` part as shown below:
|
||||
|
||||
````csharp
|
||||
builder.Entity<Book>(b =>
|
||||
{
|
||||
b.ToTable(BookStoreConsts.DbTablePrefix + "Books", BookStoreConsts.DbSchema);
|
||||
b.ConfigureByConvention(); //auto configure for the base class props
|
||||
b.Property(x => x.Name).IsRequired().HasMaxLength(128);
|
||||
|
||||
// ADD THE MAPPING FOR THE RELATION
|
||||
b.HasOne<Author>().WithMany().HasForeignKey(x => x.AuthorId).IsRequired();
|
||||
});
|
||||
````
|
||||
|
||||
### Add New EF Core Migration
|
||||
|
||||
Run the following command in the Package Manager Console (of the Visual Studio) to add a new database migration:
|
||||
|
||||
````bash
|
||||
Add-Migration "Added_AuthorId_To_Book"
|
||||
````
|
||||
|
||||
This should create a new migration class with the following code in its `Up` method:
|
||||
|
||||
````csharp
|
||||
migrationBuilder.AddColumn<Guid>(
|
||||
name: "AuthorId",
|
||||
table: "AppBooks",
|
||||
nullable: false,
|
||||
defaultValue: new Guid("00000000-0000-0000-0000-000000000000"));
|
||||
|
||||
migrationBuilder.CreateIndex(
|
||||
name: "IX_AppBooks_AuthorId",
|
||||
table: "AppBooks",
|
||||
column: "AuthorId");
|
||||
|
||||
migrationBuilder.AddForeignKey(
|
||||
name: "FK_AppBooks_AppAuthors_AuthorId",
|
||||
table: "AppBooks",
|
||||
column: "AuthorId",
|
||||
principalTable: "AppAuthors",
|
||||
principalColumn: "Id",
|
||||
onDelete: ReferentialAction.Cascade);
|
||||
````
|
||||
|
||||
* Adds an `AuthorId` field to the `AppBooks` table.
|
||||
* Creates an index on the `AuthorId` field.
|
||||
* Declares the foreign key to the `AppAuthors` table.
|
||||
|
||||
{{end}}
|
||||
|
||||
## Change the Data Seeder
|
||||
|
||||
Since the `AuthorId` is a required property of the `Book` entity, current data seeder code can not work. Open the `BookStoreDataSeederContributor` in the `Acme.BookStore.Domain` project and change as the following:
|
||||
|
||||
````csharp
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using Acme.BookStore.Authors;
|
||||
using Acme.BookStore.Books;
|
||||
using Volo.Abp.Data;
|
||||
using Volo.Abp.DependencyInjection;
|
||||
using Volo.Abp.Domain.Repositories;
|
||||
|
||||
namespace Acme.BookStore
|
||||
{
|
||||
public class BookStoreDataSeederContributor
|
||||
: IDataSeedContributor, ITransientDependency
|
||||
{
|
||||
private readonly IRepository<Book, Guid> _bookRepository;
|
||||
private readonly IAuthorRepository _authorRepository;
|
||||
private readonly AuthorManager _authorManager;
|
||||
|
||||
public BookStoreDataSeederContributor(
|
||||
IRepository<Book, Guid> bookRepository,
|
||||
IAuthorRepository authorRepository,
|
||||
AuthorManager authorManager)
|
||||
{
|
||||
_bookRepository = bookRepository;
|
||||
_authorRepository = authorRepository;
|
||||
_authorManager = authorManager;
|
||||
}
|
||||
|
||||
public async Task SeedAsync(DataSeedContext context)
|
||||
{
|
||||
if (await _bookRepository.GetCountAsync() > 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var orwell = await _authorRepository.InsertAsync(
|
||||
await _authorManager.CreateAsync(
|
||||
"George Orwell",
|
||||
new DateTime(1903, 06, 25),
|
||||
"Orwell produced literary criticism and poetry, fiction and polemical journalism; and is best known for the allegorical novella Animal Farm (1945) and the dystopian novel Nineteen Eighty-Four (1949)."
|
||||
)
|
||||
);
|
||||
|
||||
var douglas = await _authorRepository.InsertAsync(
|
||||
await _authorManager.CreateAsync(
|
||||
"Douglas Adams",
|
||||
new DateTime(1952, 03, 11),
|
||||
"Douglas Adams was an English author, screenwriter, essayist, humorist, satirist and dramatist. Adams was an advocate for environmentalism and conservation, a lover of fast cars, technological innovation and the Apple Macintosh, and a self-proclaimed 'radical atheist'."
|
||||
)
|
||||
);
|
||||
|
||||
await _bookRepository.InsertAsync(
|
||||
new Book
|
||||
{
|
||||
AuthorId = orwell.Id, // SET THE AUTHOR
|
||||
Name = "1984",
|
||||
Type = BookType.Dystopia,
|
||||
PublishDate = new DateTime(1949, 6, 8),
|
||||
Price = 19.84f
|
||||
},
|
||||
autoSave: true
|
||||
);
|
||||
|
||||
await _bookRepository.InsertAsync(
|
||||
new Book
|
||||
{
|
||||
AuthorId = douglas.Id, // SET THE AUTHOR
|
||||
Name = "The Hitchhiker's Guide to the Galaxy",
|
||||
Type = BookType.ScienceFiction,
|
||||
PublishDate = new DateTime(1995, 9, 27),
|
||||
Price = 42.0f
|
||||
},
|
||||
autoSave: true
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
The only change is that we set the `AuthorId` properties of the `Book` entities.
|
||||
|
||||
{{if DB=="EF"}}
|
||||
|
||||
You can now run the `.DbMigrator` console application to **migrate** the **database schema** and **seed** the initial data.
|
||||
|
||||
{{else if DB=="Mongo"}}
|
||||
|
||||
You can now run the `.DbMigrator` console application to **seed** the initial data.
|
||||
|
||||
{{end}}
|
||||
|
||||
## Application Layer
|
||||
|
||||
We will change the `BookAppService` to support the Author relation.
|
||||
|
||||
### Data Transfer Objects
|
||||
|
||||
Let's begin from the DTOs.
|
||||
|
||||
#### BookDto
|
||||
|
||||
Open the `BookDto` class in the `Books` folder of the `Acme.BookStore.Application.Contracts` project and add the following properties:
|
||||
|
||||
```csharp
|
||||
public Guid AuthorId { get; set; }
|
||||
public string AuthorName { get; set; }
|
||||
```
|
||||
|
||||
The final `BookDto` class should be following:
|
||||
|
||||
```csharp
|
||||
using System;
|
||||
using Volo.Abp.Application.Dtos;
|
||||
|
||||
namespace Acme.BookStore.Books
|
||||
{
|
||||
public class BookDto : AuditedEntityDto<Guid>
|
||||
{
|
||||
public Guid AuthorId { get; set; }
|
||||
|
||||
public string AuthorName { get; set; }
|
||||
|
||||
public string Name { get; set; }
|
||||
|
||||
public BookType Type { get; set; }
|
||||
|
||||
public DateTime PublishDate { get; set; }
|
||||
|
||||
public float Price { get; set; }
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### CreateUpdateBookDto
|
||||
|
||||
Open the `CreateUpdateBookDto` class in the `Books` folder of the `Acme.BookStore.Application.Contracts` project and add an `AuthorId` property as shown:
|
||||
|
||||
````csharp
|
||||
public Guid AuthorId { get; set; }
|
||||
````
|
||||
|
||||
#### AuthorLookupDto
|
||||
|
||||
Create a new class, `AuthorLookupDto`, inside the `Books` folder of the `Acme.BookStore.Application.Contracts` project:
|
||||
|
||||
````csharp
|
||||
using System;
|
||||
using Volo.Abp.Application.Dtos;
|
||||
|
||||
namespace Acme.BookStore.Books
|
||||
{
|
||||
public class AuthorLookupDto : EntityDto<Guid>
|
||||
{
|
||||
public string Name { get; set; }
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
This will be used in a new method will be added to the `IBookAppService`.
|
||||
|
||||
### IBookAppService
|
||||
|
||||
Open the `IBookAppService` interface in the `Books` folder of the `Acme.BookStore.Application.Contracts` project and add a new method, named `GetAuthorLookupAsync`, as shown below:
|
||||
|
||||
````csharp
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using Volo.Abp.Application.Dtos;
|
||||
using Volo.Abp.Application.Services;
|
||||
|
||||
namespace Acme.BookStore.Books
|
||||
{
|
||||
public interface IBookAppService :
|
||||
ICrudAppService< //Defines CRUD methods
|
||||
BookDto, //Used to show books
|
||||
Guid, //Primary key of the book entity
|
||||
PagedAndSortedResultRequestDto, //Used for paging/sorting
|
||||
CreateUpdateBookDto> //Used to create/update a book
|
||||
{
|
||||
// ADD the NEW METHOD
|
||||
Task<ListResultDto<AuthorLookupDto>> GetAuthorLookupAsync();
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
This new method will be used from the UI to get a list of authors and fill a dropdown list to select the author of a book.
|
||||
|
||||
### BookAppService
|
||||
|
||||
Open the `BookAppService` interface in the `Books` folder of the `Acme.BookStore.Application` project and replace the file content with the following code:
|
||||
|
||||
{{if DB=="EF"}}
|
||||
|
||||
```csharp
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Acme.BookStore.Authors;
|
||||
using Acme.BookStore.Permissions;
|
||||
using Microsoft.AspNetCore.Authorization;
|
||||
using Volo.Abp.Application.Dtos;
|
||||
using Volo.Abp.Application.Services;
|
||||
using Volo.Abp.Domain.Entities;
|
||||
using Volo.Abp.Domain.Repositories;
|
||||
|
||||
namespace Acme.BookStore.Books
|
||||
{
|
||||
[Authorize(BookStorePermissions.Books.Default)]
|
||||
public class BookAppService :
|
||||
CrudAppService<
|
||||
Book, //The Book entity
|
||||
BookDto, //Used to show books
|
||||
Guid, //Primary key of the book entity
|
||||
PagedAndSortedResultRequestDto, //Used for paging/sorting
|
||||
CreateUpdateBookDto>, //Used to create/update a book
|
||||
IBookAppService //implement the IBookAppService
|
||||
{
|
||||
private readonly IAuthorRepository _authorRepository;
|
||||
|
||||
public BookAppService(
|
||||
IRepository<Book, Guid> repository,
|
||||
IAuthorRepository authorRepository)
|
||||
: base(repository)
|
||||
{
|
||||
_authorRepository = authorRepository;
|
||||
GetPolicyName = BookStorePermissions.Books.Default;
|
||||
GetListPolicyName = BookStorePermissions.Books.Default;
|
||||
CreatePolicyName = BookStorePermissions.Books.Create;
|
||||
UpdatePolicyName = BookStorePermissions.Books.Edit;
|
||||
DeletePolicyName = BookStorePermissions.Books.Create;
|
||||
}
|
||||
|
||||
public override async Task<BookDto> GetAsync(Guid id)
|
||||
{
|
||||
//Prepare a query to join books and authors
|
||||
var query = from book in Repository
|
||||
join author in _authorRepository on book.AuthorId equals author.Id
|
||||
where book.Id == id
|
||||
select new { book, author };
|
||||
|
||||
//Execute the query and get the book with author
|
||||
var queryResult = await AsyncExecuter.FirstOrDefaultAsync(query);
|
||||
if (queryResult == null)
|
||||
{
|
||||
throw new EntityNotFoundException(typeof(Book), id);
|
||||
}
|
||||
|
||||
var bookDto = ObjectMapper.Map<Book, BookDto>(queryResult.book);
|
||||
bookDto.AuthorName = queryResult.author.Name;
|
||||
return bookDto;
|
||||
}
|
||||
|
||||
public override async Task<PagedResultDto<BookDto>>
|
||||
GetListAsync(PagedAndSortedResultRequestDto input)
|
||||
{
|
||||
//Prepare a query to join books and authors
|
||||
var query = from book in Repository
|
||||
join author in _authorRepository on book.AuthorId equals author.Id
|
||||
orderby input.Sorting
|
||||
select new {book, author};
|
||||
|
||||
query = query
|
||||
.Skip(input.SkipCount)
|
||||
.Take(input.MaxResultCount);
|
||||
|
||||
//Execute the query and get a list
|
||||
var queryResult = await AsyncExecuter.ToListAsync(query);
|
||||
|
||||
//Convert the query result to a list of BookDto objects
|
||||
var bookDtos = queryResult.Select(x =>
|
||||
{
|
||||
var bookDto = ObjectMapper.Map<Book, BookDto>(x.book);
|
||||
bookDto.AuthorName = x.author.Name;
|
||||
return bookDto;
|
||||
}).ToList();
|
||||
|
||||
//Get the total count with another query
|
||||
var totalCount = await Repository.GetCountAsync();
|
||||
|
||||
return new PagedResultDto<BookDto>(
|
||||
totalCount,
|
||||
bookDtos
|
||||
);
|
||||
}
|
||||
|
||||
public async Task<ListResultDto<AuthorLookupDto>> GetAuthorLookupAsync()
|
||||
{
|
||||
var authors = await _authorRepository.GetListAsync();
|
||||
|
||||
return new ListResultDto<AuthorLookupDto>(
|
||||
ObjectMapper.Map<List<Author>, List<AuthorLookupDto>>(authors)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Let's see the changes we've done:
|
||||
|
||||
* Added `[Authorize(BookStorePermissions.Books.Default)]` to authorize the methods we've newly added/overrode (remember, authorize attribute is valid for all the methods of the class when it is declared for a class).
|
||||
* Injected `IAuthorRepository` to query from the authors.
|
||||
* Overrode the `GetAsync` method of the base `CrudAppService`, which returns a single `BookDto` object with the given `id`.
|
||||
* Used a simple LINQ expression to join books and authors and query them together for the given book id.
|
||||
* Used `AsyncExecuter.FirstOrDefaultAsync(...)` to execute the query and get a result. `AsyncExecuter` was previously used in the `AuthorAppService`. Check the [repository documentation](../Repositories.md) to understand why we've used it.
|
||||
* Throws an `EntityNotFoundException` which results an `HTTP 404` (not found) result if requested book was not present in the database.
|
||||
* Finally, created a `BookDto` object using the `ObjectMapper`, then assigning the `AuthorName` manually.
|
||||
* Overrode the `GetListAsync` method of the base `CrudAppService`, which returns a list of books. The logic is similar to the previous method, so you can easily understand the code.
|
||||
* Created a new method: `GetAuthorLookupAsync`. This simple gets all the authors. The UI uses this method to fill a dropdown list and select and author while creating/editing books.
|
||||
|
||||
{{else if DB=="Mongo"}}
|
||||
|
||||
```csharp
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq.Dynamic.Core;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Acme.BookStore.Authors;
|
||||
using Acme.BookStore.Permissions;
|
||||
using Microsoft.AspNetCore.Authorization;
|
||||
using Volo.Abp.Application.Dtos;
|
||||
using Volo.Abp.Application.Services;
|
||||
using Volo.Abp.Domain.Repositories;
|
||||
|
||||
namespace Acme.BookStore.Books
|
||||
{
|
||||
[Authorize(BookStorePermissions.Books.Default)]
|
||||
public class BookAppService :
|
||||
CrudAppService<
|
||||
Book, //The Book entity
|
||||
BookDto, //Used to show books
|
||||
Guid, //Primary key of the book entity
|
||||
PagedAndSortedResultRequestDto, //Used for paging/sorting
|
||||
CreateUpdateBookDto>, //Used to create/update a book
|
||||
IBookAppService //implement the IBookAppService
|
||||
{
|
||||
private readonly IAuthorRepository _authorRepository;
|
||||
|
||||
public BookAppService(
|
||||
IRepository<Book, Guid> repository,
|
||||
IAuthorRepository authorRepository)
|
||||
: base(repository)
|
||||
{
|
||||
_authorRepository = authorRepository;
|
||||
GetPolicyName = BookStorePermissions.Books.Default;
|
||||
GetListPolicyName = BookStorePermissions.Books.Default;
|
||||
CreatePolicyName = BookStorePermissions.Books.Create;
|
||||
UpdatePolicyName = BookStorePermissions.Books.Edit;
|
||||
DeletePolicyName = BookStorePermissions.Books.Create;
|
||||
}
|
||||
|
||||
public override async Task<BookDto> GetAsync(Guid id)
|
||||
{
|
||||
var book = await Repository.GetAsync(id);
|
||||
var bookDto = ObjectMapper.Map<Book, BookDto>(book);
|
||||
|
||||
var author = await _authorRepository.GetAsync(book.AuthorId);
|
||||
bookDto.AuthorName = author.Name;
|
||||
|
||||
return bookDto;
|
||||
}
|
||||
|
||||
public override async Task<PagedResultDto<BookDto>>
|
||||
GetListAsync(PagedAndSortedResultRequestDto input)
|
||||
{
|
||||
//Set a default sorting, if not provided
|
||||
if (input.Sorting.IsNullOrWhiteSpace())
|
||||
{
|
||||
input.Sorting = nameof(Book.Name);
|
||||
}
|
||||
|
||||
//Get the books
|
||||
var books = await AsyncExecuter.ToListAsync(
|
||||
Repository
|
||||
.OrderBy(input.Sorting)
|
||||
.Skip(input.SkipCount)
|
||||
.Take(input.MaxResultCount)
|
||||
);
|
||||
|
||||
//Convert to DTOs
|
||||
var bookDtos = ObjectMapper.Map<List<Book>, List<BookDto>>(books);
|
||||
|
||||
//Get a lookup dictionary for the related authors
|
||||
var authorDictionary = await GetAuthorDictionaryAsync(books);
|
||||
|
||||
//Set AuthorName for the DTOs
|
||||
bookDtos.ForEach(bookDto => bookDto.AuthorName =
|
||||
authorDictionary[bookDto.AuthorId].Name);
|
||||
|
||||
//Get the total count with another query (required for the paging)
|
||||
var totalCount = await Repository.GetCountAsync();
|
||||
|
||||
return new PagedResultDto<BookDto>(
|
||||
totalCount,
|
||||
bookDtos
|
||||
);
|
||||
}
|
||||
|
||||
public async Task<ListResultDto<AuthorLookupDto>> GetAuthorLookupAsync()
|
||||
{
|
||||
var authors = await _authorRepository.GetListAsync();
|
||||
|
||||
return new ListResultDto<AuthorLookupDto>(
|
||||
ObjectMapper.Map<List<Author>, List<AuthorLookupDto>>(authors)
|
||||
);
|
||||
}
|
||||
|
||||
private async Task<Dictionary<Guid, Author>>
|
||||
GetAuthorDictionaryAsync(List<Book> books)
|
||||
{
|
||||
var authorIds = books
|
||||
.Select(b => b.AuthorId)
|
||||
.Distinct()
|
||||
.ToArray();
|
||||
|
||||
var authors = await AsyncExecuter.ToListAsync(
|
||||
_authorRepository.Where(a => authorIds.Contains(a.Id))
|
||||
);
|
||||
|
||||
return authors.ToDictionary(x => x.Id, x => x);
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Let's see the changes we've done:
|
||||
|
||||
* Added `[Authorize(BookStorePermissions.Books.Default)]` to authorize the methods we've newly added/overrode (remember, authorize attribute is valid for all the methods of the class when it is declared for a class).
|
||||
* Injected `IAuthorRepository` to query from the authors.
|
||||
* Overrode the `GetAsync` method of the base `CrudAppService`, which returns a single `BookDto` object with the given `id`.
|
||||
* Overrode the `GetListAsync` method of the base `CrudAppService`, which returns a list of books. This code separately queries the authors from database and sets the name of the authors in the application code. Instead, you could create a custom repository method and perform a join query or take the power of the MongoDB API to get the books and their authors in a single query, which would be more performant.
|
||||
* Created a new method: `GetAuthorLookupAsync`. This simple gets all the authors. The UI uses this method to fill a dropdown list and select and author while creating/editing books.
|
||||
|
||||
{{end}}
|
||||
|
||||
### Object to Object Mapping Configuration
|
||||
|
||||
Introduced the `AuthorLookupDto` class and used object mapping inside the `GetAuthorLookupAsync` method. So, we need to add a new mapping definition inside the `BookStoreApplicationAutoMapperProfile.cs` file of the `Acme.BookStore.Application` project:
|
||||
|
||||
````csharp
|
||||
CreateMap<Author, AuthorLookupDto>();
|
||||
````
|
||||
|
||||
## Unit Tests
|
||||
|
||||
Some of the unit tests will fail since we made some changed on the `AuthorAppService`. Open the `BookAppService_Tests` in the `Books` folder of the `Acme.BookStore.Application.Tests` project and change the content as the following:
|
||||
|
||||
```csharp
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Acme.BookStore.Authors;
|
||||
using Shouldly;
|
||||
using Volo.Abp.Application.Dtos;
|
||||
using Volo.Abp.Validation;
|
||||
using Xunit;
|
||||
|
||||
namespace Acme.BookStore.Books
|
||||
{ {{if DB=="Mongo"}}
|
||||
[Collection(BookStoreTestConsts.CollectionDefinitionName)]{{end}}
|
||||
public class BookAppService_Tests : BookStoreApplicationTestBase
|
||||
{
|
||||
private readonly IBookAppService _bookAppService;
|
||||
private readonly IAuthorAppService _authorAppService;
|
||||
|
||||
public BookAppService_Tests()
|
||||
{
|
||||
_bookAppService = GetRequiredService<IBookAppService>();
|
||||
_authorAppService = GetRequiredService<IAuthorAppService>();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Should_Get_List_Of_Books()
|
||||
{
|
||||
//Act
|
||||
var result = await _bookAppService.GetListAsync(
|
||||
new PagedAndSortedResultRequestDto()
|
||||
);
|
||||
|
||||
//Assert
|
||||
result.TotalCount.ShouldBeGreaterThan(0);
|
||||
result.Items.ShouldContain(b => b.Name == "1984" &&
|
||||
b.AuthorName == "George Orwell");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Should_Create_A_Valid_Book()
|
||||
{
|
||||
var authors = await _authorAppService.GetListAsync(new GetAuthorListDto());
|
||||
var firstAuthor = authors.Items.First();
|
||||
|
||||
//Act
|
||||
var result = await _bookAppService.CreateAsync(
|
||||
new CreateUpdateBookDto
|
||||
{
|
||||
AuthorId = firstAuthor.Id,
|
||||
Name = "New test book 42",
|
||||
Price = 10,
|
||||
PublishDate = System.DateTime.Now,
|
||||
Type = BookType.ScienceFiction
|
||||
}
|
||||
);
|
||||
|
||||
//Assert
|
||||
result.Id.ShouldNotBe(Guid.Empty);
|
||||
result.Name.ShouldBe("New test book 42");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Should_Not_Create_A_Book_Without_Name()
|
||||
{
|
||||
var exception = await Assert.ThrowsAsync<AbpValidationException>(async () =>
|
||||
{
|
||||
await _bookAppService.CreateAsync(
|
||||
new CreateUpdateBookDto
|
||||
{
|
||||
Name = "",
|
||||
Price = 10,
|
||||
PublishDate = DateTime.Now,
|
||||
Type = BookType.ScienceFiction
|
||||
}
|
||||
);
|
||||
});
|
||||
|
||||
exception.ValidationErrors
|
||||
.ShouldContain(err => err.MemberNames.Any(m => m == "Name"));
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
* Changed the assertion condition in the `Should_Get_List_Of_Books` from `b => b.Name == "1984"` to `b => b.Name == "1984" && b.AuthorName == "George Orwell"` to check if the author name was filled.
|
||||
* Changed the `Should_Create_A_Valid_Book` method to set the `AuthorId` while creating a new book, since it is required anymore.
|
||||
|
||||
## The User Interface
|
||||
|
||||
{{if UI=="MVC"}}
|
||||
|
||||
### The Book List
|
||||
|
||||
Book list page change is trivial. Open the `Pages/Books/Index.js` in the `Acme.BookStore.Web` project and add the following column definition between the `name` and `type` columns:
|
||||
|
||||
````js
|
||||
...
|
||||
{
|
||||
title: l('Name'),
|
||||
data: "name"
|
||||
},
|
||||
|
||||
// ADDED the NEW AUTHOR NAME COLUMN
|
||||
{
|
||||
title: l('Author'),
|
||||
data: "authorName"
|
||||
},
|
||||
|
||||
{
|
||||
title: l('Type'),
|
||||
data: "type",
|
||||
render: function (data) {
|
||||
return l('Enum:BookType:' + data);
|
||||
}
|
||||
},
|
||||
...
|
||||
````
|
||||
|
||||
When you run the application, you can see the *Author* column on the table:
|
||||
|
||||
|
||||
|
||||
### Create Modal
|
||||
|
||||
Open the `Pages/Books/CreateModal.cshtml.cs` in the `Acme.BookStore.Web` project and change the file content as shown below:
|
||||
|
||||
```csharp
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.ComponentModel;
|
||||
using System.ComponentModel.DataAnnotations;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Acme.BookStore.Books;
|
||||
using Microsoft.AspNetCore.Mvc;
|
||||
using Microsoft.AspNetCore.Mvc.Rendering;
|
||||
using Volo.Abp.AspNetCore.Mvc.UI.Bootstrap.TagHelpers.Form;
|
||||
|
||||
namespace Acme.BookStore.Web.Pages.Books
|
||||
{
|
||||
public class CreateModalModel : BookStorePageModel
|
||||
{
|
||||
[BindProperty]
|
||||
public CreateBookViewModel Book { get; set; }
|
||||
|
||||
public List<SelectListItem> Authors { get; set; }
|
||||
|
||||
private readonly IBookAppService _bookAppService;
|
||||
|
||||
public CreateModalModel(
|
||||
IBookAppService bookAppService)
|
||||
{
|
||||
_bookAppService = bookAppService;
|
||||
}
|
||||
|
||||
public async Task OnGetAsync()
|
||||
{
|
||||
Book = new CreateBookViewModel();
|
||||
|
||||
var authorLookup = await _bookAppService.GetAuthorLookupAsync();
|
||||
Authors = authorLookup.Items
|
||||
.Select(x => new SelectListItem(x.Name, x.Id.ToString()))
|
||||
.ToList();
|
||||
}
|
||||
|
||||
public async Task<IActionResult> OnPostAsync()
|
||||
{
|
||||
await _bookAppService.CreateAsync(
|
||||
ObjectMapper.Map<CreateBookViewModel, CreateUpdateBookDto>(Book)
|
||||
);
|
||||
return NoContent();
|
||||
}
|
||||
|
||||
public class CreateBookViewModel
|
||||
{
|
||||
[SelectItems(nameof(Authors))]
|
||||
[DisplayName("Author")]
|
||||
public Guid AuthorId { get; set; }
|
||||
|
||||
[Required]
|
||||
[StringLength(128)]
|
||||
public string Name { get; set; }
|
||||
|
||||
[Required]
|
||||
public BookType Type { get; set; } = BookType.Undefined;
|
||||
|
||||
[Required]
|
||||
[DataType(DataType.Date)]
|
||||
public DateTime PublishDate { get; set; } = DateTime.Now;
|
||||
|
||||
[Required]
|
||||
public float Price { get; set; }
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
* Changed type of the `Book` property from `CreateUpdateBookDto` to the new `CreateBookViewModel` class defined in this file. The main motivation of this change to customize the model class based on the User Interface (UI) requirements. We didn't want to use UI-related `[SelectItems(nameof(Authors))]` and `[DisplayName("Author")]` attributes inside the `CreateUpdateBookDto` class.
|
||||
* Added `Authors` property that is filled inside the `OnGetAsync` method using the `IBookAppService.GetAuthorLookupAsync` method defined before.
|
||||
* Changed the `OnPostAsync` method to map `CreateBookViewModel` object to a `CreateUpdateBookDto` object since `IBookAppService.CreateAsync` expects a parameter of this type.
|
||||
|
||||
### Edit Modal
|
||||
|
||||
Open the `Pages/Books/EditModal.cshtml.cs` in the `Acme.BookStore.Web` project and change the file content as shown below:
|
||||
|
||||
```csharp
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.ComponentModel;
|
||||
using System.ComponentModel.DataAnnotations;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Acme.BookStore.Books;
|
||||
using Microsoft.AspNetCore.Mvc;
|
||||
using Microsoft.AspNetCore.Mvc.Rendering;
|
||||
using Volo.Abp.AspNetCore.Mvc.UI.Bootstrap.TagHelpers.Form;
|
||||
|
||||
namespace Acme.BookStore.Web.Pages.Books
|
||||
{
|
||||
public class EditModalModel : BookStorePageModel
|
||||
{
|
||||
[BindProperty]
|
||||
public EditBookViewModel Book { get; set; }
|
||||
|
||||
public List<SelectListItem> Authors { get; set; }
|
||||
|
||||
private readonly IBookAppService _bookAppService;
|
||||
|
||||
public EditModalModel(IBookAppService bookAppService)
|
||||
{
|
||||
_bookAppService = bookAppService;
|
||||
}
|
||||
|
||||
public async Task OnGetAsync(Guid id)
|
||||
{
|
||||
var bookDto = await _bookAppService.GetAsync(id);
|
||||
Book = ObjectMapper.Map<BookDto, EditBookViewModel>(bookDto);
|
||||
|
||||
var authorLookup = await _bookAppService.GetAuthorLookupAsync();
|
||||
Authors = authorLookup.Items
|
||||
.Select(x => new SelectListItem(x.Name, x.Id.ToString()))
|
||||
.ToList();
|
||||
}
|
||||
|
||||
public async Task<IActionResult> OnPostAsync()
|
||||
{
|
||||
await _bookAppService.UpdateAsync(
|
||||
Book.Id,
|
||||
ObjectMapper.Map<EditBookViewModel, CreateUpdateBookDto>(Book)
|
||||
);
|
||||
|
||||
return NoContent();
|
||||
}
|
||||
|
||||
public class EditBookViewModel
|
||||
{
|
||||
[HiddenInput]
|
||||
public Guid Id { get; set; }
|
||||
|
||||
[SelectItems(nameof(Authors))]
|
||||
[DisplayName("Author")]
|
||||
public Guid AuthorId { get; set; }
|
||||
|
||||
[Required]
|
||||
[StringLength(128)]
|
||||
public string Name { get; set; }
|
||||
|
||||
[Required]
|
||||
public BookType Type { get; set; } = BookType.Undefined;
|
||||
|
||||
[Required]
|
||||
[DataType(DataType.Date)]
|
||||
public DateTime PublishDate { get; set; } = DateTime.Now;
|
||||
|
||||
[Required]
|
||||
public float Price { get; set; }
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
* Changed type of the `Book` property from `CreateUpdateBookDto` to the new `EditBookViewModel` class defined in this file, just like done before for the create modal above.
|
||||
* Moved the `Id` property inside the new `EditBookViewModel` class.
|
||||
* Added `Authors` property that is filled inside the `OnGetAsync` method using the `IBookAppService.GetAuthorLookupAsync` method.
|
||||
* Changed the `OnPostAsync` method to map `EditBookViewModel` object to a `CreateUpdateBookDto` object since `IBookAppService.UpdateAsync` expects a parameter of this type.
|
||||
|
||||
These changes require a small change in the `EditModal.cshtml`. Remove the `<abp-input asp-for="Id" />` tag since we no longer need to it (since moved it to the `EditBookViewModel`). The final content of the `EditModal.cshtml` should be following:
|
||||
|
||||
````html
|
||||
@page
|
||||
@using Acme.BookStore.Localization
|
||||
@using Acme.BookStore.Web.Pages.Books
|
||||
@using Microsoft.Extensions.Localization
|
||||
@using Volo.Abp.AspNetCore.Mvc.UI.Bootstrap.TagHelpers.Modal
|
||||
@model EditModalModel
|
||||
@inject IStringLocalizer<BookStoreResource> L
|
||||
@{
|
||||
Layout = null;
|
||||
}
|
||||
<abp-dynamic-form abp-model="Book" asp-page="/Books/EditModal">
|
||||
<abp-modal>
|
||||
<abp-modal-header title="@L["Update"].Value"></abp-modal-header>
|
||||
<abp-modal-body>
|
||||
<abp-form-content />
|
||||
</abp-modal-body>
|
||||
<abp-modal-footer buttons="@(AbpModalButtons.Cancel|AbpModalButtons.Save)"></abp-modal-footer>
|
||||
</abp-modal>
|
||||
</abp-dynamic-form>
|
||||
````
|
||||
|
||||
### Object to Object Mapping Configuration
|
||||
|
||||
The changes above requires to define some object to object mappings. Open the `BookStoreWebAutoMapperProfile.cs` in the `Acme.BookStore.Web` project and add the following mapping definitions inside the constructor:
|
||||
|
||||
```csharp
|
||||
CreateMap<Pages.Books.CreateModalModel.CreateBookViewModel, CreateUpdateBookDto>();
|
||||
CreateMap<BookDto, Pages.Books.EditModalModel.EditBookViewModel>();
|
||||
CreateMap<Pages.Books.EditModalModel.EditBookViewModel, CreateUpdateBookDto>();
|
||||
```
|
||||
|
||||
You can run the application and try to create a new book or update an existing book. You will see a drop down list on the create/update form to select the author of the book:
|
||||
|
||||
|
||||
|
||||
{{else if UI=="NG"}}
|
||||
|
||||
***Angular UI is being prepared...***
|
||||
|
||||
{{end}}
|
||||
@ -0,0 +1,289 @@
|
||||
# Web Application Development Tutorial - Part 6: Authors: Domain Layer
|
||||
````json
|
||||
//[doc-params]
|
||||
{
|
||||
"UI": ["MVC","NG"],
|
||||
"DB": ["EF","Mongo"]
|
||||
}
|
||||
````
|
||||
{{
|
||||
if UI == "MVC"
|
||||
UI_Text="mvc"
|
||||
else if UI == "NG"
|
||||
UI_Text="angular"
|
||||
else
|
||||
UI_Text="?"
|
||||
end
|
||||
if DB == "EF"
|
||||
DB_Text="Entity Framework Core"
|
||||
else if DB == "Mongo"
|
||||
DB_Text="MongoDB"
|
||||
else
|
||||
DB_Text="?"
|
||||
end
|
||||
}}
|
||||
|
||||
## 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_Text}}** 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 (this part)**
|
||||
- [Part 7: Authors: Database Integration](Part-7.md)
|
||||
- [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 tutorials has multiple versions based on your **UI** and **Database** preferences. We've prepared two 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)
|
||||
* [Angular UI with MongoDB](https://github.com/abpframework/abp-samples/tree/master/BookStore-Angular-MongoDb)
|
||||
|
||||
## Introduction
|
||||
|
||||
In the previous parts, we've used the ABP infrastructure to easily build some services;
|
||||
|
||||
* Used the [CrudAppService](../Application-Services.md) base class instead of manually developing an application service for standard create, read, update and delete operations.
|
||||
* Used [generic repositories](../Repositories.md) to completely automate the database layer.
|
||||
|
||||
For the "Authors" part;
|
||||
|
||||
* We will **do some of the things manually** to show how you can do it in case of need.
|
||||
* We will implement some **Domain Driven Design (DDD) best practices**.
|
||||
|
||||
> **The development will be done layer by layer to concentrate on an individual layer in one time. In a real project, you will develop your application feature by feature (vertical) as done in the previous parts. In this way, you will experience both approaches.**
|
||||
|
||||
## The Author Entity
|
||||
|
||||
Create an `Authors` folder (namespace) in the `Acme.BookStore.Domain` project and add an `Author` class inside it:
|
||||
|
||||
````csharp
|
||||
using System;
|
||||
using JetBrains.Annotations;
|
||||
using Volo.Abp;
|
||||
using Volo.Abp.Domain.Entities.Auditing;
|
||||
|
||||
namespace Acme.BookStore.Authors
|
||||
{
|
||||
public class Author : FullAuditedAggregateRoot<Guid>
|
||||
{
|
||||
public string Name { get; private set; }
|
||||
public DateTime BirthDate { get; set; }
|
||||
public string ShortBio { get; set; }
|
||||
|
||||
private Author()
|
||||
{
|
||||
/* This constructor is for deserialization / ORM purpose */
|
||||
}
|
||||
|
||||
internal Author(
|
||||
Guid id,
|
||||
[NotNull] string name,
|
||||
DateTime birthDate,
|
||||
[CanBeNull] string shortBio = null)
|
||||
: base(id)
|
||||
{
|
||||
SetName(name);
|
||||
BirthDate = birthDate;
|
||||
ShortBio = shortBio;
|
||||
}
|
||||
|
||||
internal Author ChangeName([NotNull] string name)
|
||||
{
|
||||
SetName(name);
|
||||
return this;
|
||||
}
|
||||
|
||||
private void SetName([NotNull] string name)
|
||||
{
|
||||
Name = Check.NotNullOrWhiteSpace(
|
||||
name,
|
||||
nameof(name),
|
||||
maxLength: AuthorConsts.MaxNameLength
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
* Inherited from `FullAuditedAggregateRoot<Guid>` which makes the entity [soft delete](../Data-Filtering.md) (that means when you delete it, it is not deleted in the database, but just marked as deleted) with all the [auditing](../Entities.md) properties.
|
||||
* `private set` for the `Name` property restricts to set this property from out of this class. There are two ways of setting the name (in both cases, we validate the name):
|
||||
* In the constructor, while creating a new author.
|
||||
* Using the `ChangeName` method to update the name later.
|
||||
* The `constructor` and the `ChangeName` method is `internal` to force to use these methods only in the domain layer, using the `AuthorManager` that will be explained later.
|
||||
* `Check` class is an ABP Framework utility class to help you while checking method arguments (it throws `ArgumentException` on an invalid case).
|
||||
|
||||
`AuthorConsts` is a simple class that is located under the `Authors` namespace (folder) of the `Acme.BookStore.Domain.Shared` project:
|
||||
|
||||
````csharp
|
||||
namespace Acme.BookStore.Authors
|
||||
{
|
||||
public static class AuthorConsts
|
||||
{
|
||||
public const int MaxNameLength = 64;
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
Created this class inside the `Acme.BookStore.Domain.Shared` project since we will re-use it on the [Data Transfer Objects](../Data-Transfer-Objects.md) (DTOs) later.
|
||||
|
||||
## AuthorManager: The Domain Service
|
||||
|
||||
`Author` constructor and `ChangeName` method is `internal`, so they can be usable only in the domain layer. Create an `AuthorManager` class in the `Authors` folder (namespace) of the `Acme.BookStore.Domain` project:
|
||||
|
||||
````csharp
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using JetBrains.Annotations;
|
||||
using Volo.Abp;
|
||||
using Volo.Abp.Domain.Services;
|
||||
|
||||
namespace Acme.BookStore.Authors
|
||||
{
|
||||
public class AuthorManager : DomainService
|
||||
{
|
||||
private readonly IAuthorRepository _authorRepository;
|
||||
|
||||
public AuthorManager(IAuthorRepository authorRepository)
|
||||
{
|
||||
_authorRepository = authorRepository;
|
||||
}
|
||||
|
||||
public async Task<Author> CreateAsync(
|
||||
[NotNull] string name,
|
||||
DateTime birthDate,
|
||||
[CanBeNull] string shortBio = null)
|
||||
{
|
||||
Check.NotNullOrWhiteSpace(name, nameof(name));
|
||||
|
||||
var existingAuthor = await _authorRepository.FindByNameAsync(name);
|
||||
if (existingAuthor != null)
|
||||
{
|
||||
throw new AuthorAlreadyExistsException(name);
|
||||
}
|
||||
|
||||
return new Author(
|
||||
GuidGenerator.Create(),
|
||||
name,
|
||||
birthDate,
|
||||
shortBio
|
||||
);
|
||||
}
|
||||
|
||||
public async Task ChangeNameAsync(
|
||||
[NotNull] Author author,
|
||||
[NotNull] string newName)
|
||||
{
|
||||
Check.NotNull(author, nameof(author));
|
||||
Check.NotNullOrWhiteSpace(newName, nameof(newName));
|
||||
|
||||
var existingAuthor = await _authorRepository.FindByNameAsync(newName);
|
||||
if (existingAuthor != null && existingAuthor.Id != author.Id)
|
||||
{
|
||||
throw new AuthorAlreadyExistsException(newName);
|
||||
}
|
||||
|
||||
author.ChangeName(newName);
|
||||
}
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
* `AuthorManager` forces to create an author and change name of an author in a controlled way. The application layer (will be introduced later) will use these methods.
|
||||
|
||||
> **DDD tip**: Do not introduce domain service methods unless they are really needed and perform some core business rules. For this case, we needed to this service to be able to force the unique name constraint.
|
||||
|
||||
Both methods checks if there is already an author with the given name and throws a special business exception, `AuthorAlreadyExistsException`, defined in the `Acme.BookStore.Domain` project as shown below:
|
||||
|
||||
````csharp
|
||||
using Volo.Abp;
|
||||
|
||||
namespace Acme.BookStore.Authors
|
||||
{
|
||||
public class AuthorAlreadyExistsException : BusinessException
|
||||
{
|
||||
public AuthorAlreadyExistsException(string name)
|
||||
: base(BookStoreDomainErrorCodes.AuthorAlreadyExists)
|
||||
{
|
||||
WithData("name", name);
|
||||
}
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
`BusinessException` is a special exception type. It is a good practice to throw domain related exceptions when needed. It is automatically handled by the ABP Framework and can be easily localized. `WithData(...)` method is used to provide additional data to the exception object that will later be used on the localization message or for some other purpose.
|
||||
|
||||
Open the `BookStoreDomainErrorCodes` in the `Acme.BookStore.Domain.Shared` project and change as shown below:
|
||||
|
||||
````csharp
|
||||
namespace Acme.BookStore
|
||||
{
|
||||
public static class BookStoreDomainErrorCodes
|
||||
{
|
||||
public const string AuthorAlreadyExists = "BookStore:00001";
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
This is a unique string represents the error code thrown by your application and can be handled by client applications. For users, you probably want to localize it. Open the `Localization/BookStore/en.json` inside the `Acme.BookStore.Domain.Shared` project and add the following entry:
|
||||
|
||||
````json
|
||||
"BookStore:00001": "There is already an author with the same name: {name}"
|
||||
````
|
||||
|
||||
Whenever you throw an `AuthorAlreadyExistsException`, the end use will see a nice error message on the UI.
|
||||
|
||||
## IAuthorRepository
|
||||
|
||||
`AuthorManager` injects the `IAuthorRepository`, so we need to define it. Create this new interface in the `Authors` folder (namespace) of the `Acme.BookStore.Domain` project:
|
||||
|
||||
````csharp
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using Volo.Abp.Domain.Repositories;
|
||||
|
||||
namespace Acme.BookStore.Authors
|
||||
{
|
||||
public interface IAuthorRepository : IRepository<Author, Guid>
|
||||
{
|
||||
Task<Author> FindByNameAsync(string name);
|
||||
|
||||
Task<List<Author>> GetListAsync(
|
||||
int skipCount,
|
||||
int maxResultCount,
|
||||
string sorting,
|
||||
string filter = null
|
||||
);
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
* `IAuthorRepository` extends the standard `IRepository<Author, Guid>` interface, so all the standard [repository](../Repositories.md) methods will also be available for the `IAuthorRepository`.
|
||||
* `FindByNameAsync` was used in the `AuthorManager` to query an author by name.
|
||||
* `GetListAsync` will be used in the application layer to get a listed, sorted and filtered list of authors to show on the UI.
|
||||
|
||||
We will implement this repository in the next part.
|
||||
|
||||
> Both of these methods might **seem unnecessary** since the standard repositories already `IQueryable` and you can directly use them instead of defining such custom methods. You're right and do it like in a real application. However, for this **"learning" tutorial**, it is useful to explain how to create custom repository methods when you really need it.
|
||||
|
||||
## Conclusion
|
||||
|
||||
This part covered the domain layer of the authors functionality of the book store application. The main files created/updated in this part was highlighted in the picture below:
|
||||
|
||||
|
||||
|
||||
## The Next Part
|
||||
|
||||
See the [next part](Part-7.md) of this tutorial.
|
||||
@ -0,0 +1,236 @@
|
||||
# Web Application Development Tutorial - Part 7: Authors: Database Integration
|
||||
````json
|
||||
//[doc-params]
|
||||
{
|
||||
"UI": ["MVC","NG"],
|
||||
"DB": ["EF","Mongo"]
|
||||
}
|
||||
````
|
||||
{{
|
||||
if UI == "MVC"
|
||||
UI_Text="mvc"
|
||||
else if UI == "NG"
|
||||
UI_Text="angular"
|
||||
else
|
||||
UI_Text="?"
|
||||
end
|
||||
if DB == "EF"
|
||||
DB_Text="Entity Framework Core"
|
||||
else if DB == "Mongo"
|
||||
DB_Text="MongoDB"
|
||||
else
|
||||
DB_Text="?"
|
||||
end
|
||||
}}
|
||||
|
||||
## 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_Text}}** 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 tutorials has multiple versions based on your **UI** and **Database** preferences. We've prepared two 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)
|
||||
* [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` 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:
|
||||
|
||||
|
||||
|
||||
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)
|
||||
{
|
||||
return await DbSet.FirstOrDefaultAsync(author => author.Name == name);
|
||||
}
|
||||
|
||||
public async Task<List<Author>> GetListAsync(
|
||||
int skipCount,
|
||||
int maxResultCount,
|
||||
string sorting,
|
||||
string filter = null)
|
||||
{
|
||||
return await DbSet
|
||||
.WhereIf(
|
||||
!filter.IsNullOrWhiteSpace(),
|
||||
author => author.Name.Contains(filter)
|
||||
)
|
||||
.OrderBy(sorting)
|
||||
.Skip(skipCount)
|
||||
.Take(maxResultCount)
|
||||
.ToListAsync();
|
||||
}
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
* Inherited from the `EfCoreAuthorRepository`, 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)
|
||||
{
|
||||
return await GetMongoQueryable()
|
||||
.FirstOrDefaultAsync(author => author.Name == name);
|
||||
}
|
||||
|
||||
public async Task<List<Author>> GetListAsync(
|
||||
int skipCount,
|
||||
int maxResultCount,
|
||||
string sorting,
|
||||
string filter = null)
|
||||
{
|
||||
return await GetMongoQueryable()
|
||||
.WhereIf<Author, IMongoQueryable<Author>>(
|
||||
!filter.IsNullOrWhiteSpace(),
|
||||
author => author.Name.Contains(filter)
|
||||
)
|
||||
.OrderBy(sorting)
|
||||
.As<IMongoQueryable<Author>>()
|
||||
.Skip(skipCount)
|
||||
.Take(maxResultCount)
|
||||
.ToListAsync();
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
* Inherited from the `MongoDbAuthorRepository`, 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.
|
||||
@ -0,0 +1,575 @@
|
||||
# Web Application Development Tutorial - Part 8: Authors: Application Layer
|
||||
````json
|
||||
//[doc-params]
|
||||
{
|
||||
"UI": ["MVC","NG"],
|
||||
"DB": ["EF","Mongo"]
|
||||
}
|
||||
````
|
||||
{{
|
||||
if UI == "MVC"
|
||||
UI_Text="mvc"
|
||||
else if UI == "NG"
|
||||
UI_Text="angular"
|
||||
else
|
||||
UI_Text="?"
|
||||
end
|
||||
if DB == "EF"
|
||||
DB_Text="Entity Framework Core"
|
||||
else if DB == "Mongo"
|
||||
DB_Text="MongoDB"
|
||||
else
|
||||
DB_Text="?"
|
||||
end
|
||||
}}
|
||||
|
||||
## 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_Text}}** 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](Part-7.md)
|
||||
- **Part 8: Author: Application Layer (this part)**
|
||||
- [Part 9: Authors: User Interface](Part-9.md)
|
||||
- [Part 10: Book to Author Relation](Part-10.md)
|
||||
|
||||
### Download the Source Code
|
||||
|
||||
This tutorials has multiple versions based on your **UI** and **Database** preferences. We've prepared two 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)
|
||||
* [Angular UI with MongoDB](https://github.com/abpframework/abp-samples/tree/master/BookStore-Angular-MongoDb)
|
||||
|
||||
## Introduction
|
||||
|
||||
This part explains to create an application layer for the `Author` entity created before.
|
||||
|
||||
## IAuthorAppService
|
||||
|
||||
We will first create the [application service](../Application-Services.md) interface and the related [DTO](../Data-Transfer-Objects.md)s. Create a new interface, named `IAuthorAppService`, in the `Authors` namespace (folder) of the `Acme.BookStore.Application.Contracts` project:
|
||||
|
||||
````csharp
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using Volo.Abp.Application.Dtos;
|
||||
using Volo.Abp.Application.Services;
|
||||
|
||||
namespace Acme.BookStore.Authors
|
||||
{
|
||||
public interface IAuthorAppService : IApplicationService
|
||||
{
|
||||
Task<AuthorDto> GetAsync(Guid id);
|
||||
|
||||
Task<PagedResultDto<AuthorDto>> GetListAsync(GetAuthorListDto input);
|
||||
|
||||
Task<AuthorDto> CreateAsync(CreateAuthorDto input);
|
||||
|
||||
Task UpdateAsync(Guid id, UpdateAuthorDto input);
|
||||
|
||||
Task DeleteAsync(Guid id);
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
* `IApplicationService` is a conventional interface that is inherited by all the application services, so the ABP Framework can identify the service.
|
||||
* Defined standard methods to perform CRUD operations on the `Author` entity.
|
||||
* `PagedResultDto` is a pre-defined DTO class in the ABP Framework. It has an `Items` collection and a `TotalCount` property to return a paged result.
|
||||
* Preferred to return an `AuthorDto` (for the newly created author) from the `CreateAsync` method, while it is not used by this application - just to show a different usage.
|
||||
|
||||
This interface is using the DTOs defined below (create them for your project).
|
||||
|
||||
### AuthorDto
|
||||
|
||||
````csharp
|
||||
using System;
|
||||
using Volo.Abp.Application.Dtos;
|
||||
|
||||
namespace Acme.BookStore.Authors
|
||||
{
|
||||
public class AuthorDto : EntityDto<Guid>
|
||||
{
|
||||
public string Name { get; set; }
|
||||
|
||||
public DateTime BirthDate { get; set; }
|
||||
|
||||
public string ShortBio { get; set; }
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
* `EntityDto<T>` simply has an `Id` property with the given generic argument. You could create an `Id` property yourself instead of inheriting the `EntityDto<T>`.
|
||||
|
||||
### GetAuthorListDto
|
||||
|
||||
````csharp
|
||||
using Volo.Abp.Application.Dtos;
|
||||
|
||||
namespace Acme.BookStore.Authors
|
||||
{
|
||||
public class GetAuthorListDto : PagedAndSortedResultRequestDto
|
||||
{
|
||||
public string Filter { get; set; }
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
* `Filter` is used to search authors. It can be `null` (or empty string) to get all the authors.
|
||||
* `PagedAndSortedResultRequestDto` has the standard paging and sorting properties: `int MaxResultCount`, `int SkipCount` and `string Sorting`.
|
||||
|
||||
> ABP Framework has such base DTO classes to simplify and standardize your DTOs. See the [DTO documentation](../Data-Transfer-Objects.md) for all.
|
||||
|
||||
### CreateAuthorDto
|
||||
|
||||
````csharp
|
||||
using System;
|
||||
using System.ComponentModel.DataAnnotations;
|
||||
|
||||
namespace Acme.BookStore.Authors
|
||||
{
|
||||
public class CreateAuthorDto
|
||||
{
|
||||
[Required]
|
||||
[StringLength(AuthorConsts.MaxNameLength)]
|
||||
public string Name { get; set; }
|
||||
|
||||
[Required]
|
||||
public DateTime BirthDate { get; set; }
|
||||
|
||||
public string ShortBio { get; set; }
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
Data annotation attributes can be used to validate the DTO. See the [validation document](../Validation.md) for details.
|
||||
|
||||
### UpdateAuthorDto
|
||||
|
||||
````csharp
|
||||
using System;
|
||||
using System.ComponentModel.DataAnnotations;
|
||||
|
||||
namespace Acme.BookStore.Authors
|
||||
{
|
||||
public class UpdateAuthorDto
|
||||
{
|
||||
[Required]
|
||||
[StringLength(AuthorConsts.MaxNameLength)]
|
||||
public string Name { get; set; }
|
||||
|
||||
[Required]
|
||||
public DateTime BirthDate { get; set; }
|
||||
|
||||
public string ShortBio { get; set; }
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
> We could share (re-use) the same DTO among the create and the update operations. While you can do it, we prefer to create different DTOs for these operations since we see they generally be different by the time. So, code duplication is reasonable here compared to a tightly coupled design.
|
||||
|
||||
## AuthorAppService
|
||||
|
||||
It is time to implement the `IAuthorAppService` interface. Create a new class, named `AuthorAppService` in the `Authors` namespace (folder) of the `Acme.BookStore.Application` project:
|
||||
|
||||
````csharp
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Acme.BookStore.Permissions;
|
||||
using Microsoft.AspNetCore.Authorization;
|
||||
using Volo.Abp.Application.Dtos;
|
||||
|
||||
namespace Acme.BookStore.Authors
|
||||
{
|
||||
[Authorize(BookStorePermissions.Authors.Default)]
|
||||
public class AuthorAppService : BookStoreAppService, IAuthorAppService
|
||||
{
|
||||
private readonly IAuthorRepository _authorRepository;
|
||||
private readonly AuthorManager _authorManager;
|
||||
|
||||
public AuthorAppService(
|
||||
IAuthorRepository authorRepository,
|
||||
AuthorManager authorManager)
|
||||
{
|
||||
_authorRepository = authorRepository;
|
||||
_authorManager = authorManager;
|
||||
}
|
||||
|
||||
//...SERVICE METHODS WILL COME HERE...
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
* `[Authorize(BookStorePermissions.Authors.Default)]` is a declarative way to check a permission (policy) to authorize the current user. See the [authorization document](../Authorization.md) for more. `BookStorePermissions` class will be updated below, don't worry for the compile error for now.
|
||||
* Derived from the `BookStoreAppService`, which is a simple base class comes with the startup template. It is derived from the standard `ApplicationService` class.
|
||||
* Implemented the `IAuthorAppService` which was defined above.
|
||||
* Injected the `IAuthorRepository` and `AuthorManager` to use in the service methods.
|
||||
|
||||
Now, we will introduce the service methods one by one. Copy the explained method into the `AuthorAppService` class.
|
||||
|
||||
### GetAsync
|
||||
|
||||
````csharp
|
||||
public async Task<AuthorDto> GetAsync(Guid id)
|
||||
{
|
||||
var author = await _authorRepository.GetAsync(id);
|
||||
return ObjectMapper.Map<Author, AuthorDto>(author);
|
||||
}
|
||||
````
|
||||
|
||||
This method simply gets the `Author` entity by its `Id`, converts to the `AuthorDto` using the [object to object mapper](../Object-To-Object-Mapping.md). This requires to configure the AutoMapper, which will be explained later.
|
||||
|
||||
### GetListAsync
|
||||
|
||||
````csharp
|
||||
public async Task<PagedResultDto<AuthorDto>> GetListAsync(GetAuthorListDto input)
|
||||
{
|
||||
if (input.Sorting.IsNullOrWhiteSpace())
|
||||
{
|
||||
input.Sorting = nameof(Author.Name);
|
||||
}
|
||||
|
||||
var authors = await _authorRepository.GetListAsync(
|
||||
input.SkipCount,
|
||||
input.MaxResultCount,
|
||||
input.Sorting,
|
||||
input.Filter
|
||||
);
|
||||
|
||||
var totalCount = await AsyncExecuter.CountAsync(
|
||||
_authorRepository.WhereIf(
|
||||
!input.Filter.IsNullOrWhiteSpace(),
|
||||
author => author.Name.Contains(input.Filter)
|
||||
)
|
||||
);
|
||||
|
||||
return new PagedResultDto<AuthorDto>(
|
||||
totalCount,
|
||||
ObjectMapper.Map<List<Author>, List<AuthorDto>>(authors)
|
||||
);
|
||||
}
|
||||
````
|
||||
|
||||
* Default sorting is "by author name" which is done in the beginning of the method in case of it wasn't sent by the client.
|
||||
* Used the `IAuthorRepository.GetListAsync` to get a paged, sorted and filtered list of authors from the database. We had implemented it in the previous part of this tutorial. Again, it actually was not needed to create such a method since we could directly query over the repository, but wanted to demonstrate how to create custom repository methods.
|
||||
* Directly queried from the `AuthorRepository` while getting the count of the authors. We preferred to use the `AsyncExecuter` service which allows us to perform async queries without depending on the EF Core. However, you could depend on the EF Core package and directly use the `_authorRepository.WhereIf(...).ToListAsync()` method. See the [repository document](../Repositories.md) to read the alternative approaches and the discussion.
|
||||
* Finally, returning a paged result by mapping the list of `Author`s to a list of `AuthorDto`s.
|
||||
|
||||
### CreateAsync
|
||||
|
||||
````csharp
|
||||
[Authorize(BookStorePermissions.Authors.Create)]
|
||||
public async Task<AuthorDto> CreateAsync(CreateAuthorDto input)
|
||||
{
|
||||
var author = await _authorManager.CreateAsync(
|
||||
input.Name,
|
||||
input.BirthDate,
|
||||
input.ShortBio
|
||||
);
|
||||
|
||||
await _authorRepository.InsertAsync(author);
|
||||
|
||||
return ObjectMapper.Map<Author, AuthorDto>(author);
|
||||
}
|
||||
````
|
||||
|
||||
* `CreateAsync` requires the `BookStorePermissions.Authors.Create` permission (in addition to the `BookStorePermissions.Authors.Default` declared for the `AuthorAppService` class).
|
||||
* Used the `AuthorManeger` (domain service) to create a new author.
|
||||
* Used the `IAuthorRepository.InsertAsync` to insert the new author to the database.
|
||||
* Used the `ObjectMapper` to return an `AuthorDto` representing the newly created author.
|
||||
|
||||
> **DDD tip**: Some developers may find useful to insert the new entity inside the `_authorManager.CreateAsync`. We think it is a better design to leave it to the application layer since it better knows when to insert it to the database (maybe it requires additional works on the entity before insert, which would require to an additional update if we perform the insert in the domain service). However, it is completely up to you.
|
||||
|
||||
### UpdateAsync
|
||||
|
||||
````csharp
|
||||
[Authorize(BookStorePermissions.Authors.Edit)]
|
||||
public async Task UpdateAsync(Guid id, UpdateAuthorDto input)
|
||||
{
|
||||
var author = await _authorRepository.GetAsync(id);
|
||||
|
||||
if (author.Name != input.Name)
|
||||
{
|
||||
await _authorManager.ChangeNameAsync(author, input.Name);
|
||||
}
|
||||
|
||||
author.BirthDate = input.BirthDate;
|
||||
author.ShortBio = input.ShortBio;
|
||||
|
||||
await _authorRepository.UpdateAsync(author);
|
||||
}
|
||||
````
|
||||
|
||||
* `UpdateAsync` requires the additional `BookStorePermissions.Authors.Edit` permission.
|
||||
* Used the `IAuthorRepository.GetAsync` to get the author entity from the database. `GetAsync` throws `EntityNotFoundException` if there is no author with the given id, which results a `404` HTTP status code in a web application. It is a good practice to always bring the entity on an update operation.
|
||||
* Used the `AuthorManager.ChangeNameAsync` (domain service method) to change the author name if it was requested to change by the client.
|
||||
* Directly updated the `BirthDate` and `ShortBio` since there is not any business rule to change these properties, they accept any value.
|
||||
* Finally, called the `IAuthorRepository.UpdateAsync` method to update the entity on the database.
|
||||
|
||||
{{if DB == "EF"}}
|
||||
|
||||
> **EF Core tip**: Entity Framework Core has a **change tracking** system and **automatically saves** any change to an entity at the end of the unit of work (You can simply think that the ABP Framework automatically calls `SaveChanges` at the end of the method). So, it will work as expected even if you don't call the `_authorRepository.UpdateAsync(...)` in the end of the method. If you don't consider to change the EF Core later, you can just remove this line.
|
||||
|
||||
{{end}}
|
||||
|
||||
### DeleteAsync
|
||||
|
||||
````csharp
|
||||
[Authorize(BookStorePermissions.Authors.Delete)]
|
||||
public async Task DeleteAsync(Guid id)
|
||||
{
|
||||
await _authorRepository.DeleteAsync(id);
|
||||
}
|
||||
````
|
||||
|
||||
* `DeleteAsync` requires the additional `BookStorePermissions.Authors.Delete` permission.
|
||||
* It simply uses the `DeleteAsync` method of the repository.
|
||||
|
||||
## Permission Definitions
|
||||
|
||||
You can't compile the code since it is expecting some constants declared in the `BookStorePermissions` class.
|
||||
|
||||
Open the `BookStorePermissions` class inside the `Acme.BookStore.Application.Contracts` project and change the content as shown below:
|
||||
|
||||
````csharp
|
||||
namespace Acme.BookStore.Permissions
|
||||
{
|
||||
public static class BookStorePermissions
|
||||
{
|
||||
public const string GroupName = "BookStore";
|
||||
|
||||
public static class Books
|
||||
{
|
||||
public const string Default = GroupName + ".Books";
|
||||
public const string Create = Default + ".Create";
|
||||
public const string Edit = Default + ".Edit";
|
||||
public const string Delete = Default + ".Delete";
|
||||
}
|
||||
|
||||
// *** ADDED a NEW NESTED CLASS ***
|
||||
public static class Authors
|
||||
{
|
||||
public const string Default = GroupName + ".Authors";
|
||||
public const string Create = Default + ".Create";
|
||||
public const string Edit = Default + ".Edit";
|
||||
public const string Delete = Default + ".Delete";
|
||||
}
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
Then open the `BookStorePermissionDefinitionProvider` in the same project and add the following lines at the end of the `Define` method:
|
||||
|
||||
````csharp
|
||||
var authorsPermission = bookStoreGroup.AddPermission(
|
||||
BookStorePermissions.Authors.Default, L("Permission:Authors"));
|
||||
|
||||
authorsPermission.AddChild(
|
||||
BookStorePermissions.Authors.Create, L("Permission:Authors.Create"));
|
||||
|
||||
authorsPermission.AddChild(
|
||||
BookStorePermissions.Authors.Edit, L("Permission:Authors.Edit"));
|
||||
|
||||
authorsPermission.AddChild(
|
||||
BookStorePermissions.Authors.Delete, L("Permission:Authors.Delete"));
|
||||
````
|
||||
|
||||
Finally, add the following entries to the `Localization/BookStore/en.json` inside the `Acme.BookStore.Domain.Shared` project, to localize the permission names:
|
||||
|
||||
````csharp
|
||||
"Permission:Authors": "Author Management",
|
||||
"Permission:Authors.Create": "Creating new authors",
|
||||
"Permission:Authors.Edit": "Editing the authors",
|
||||
"Permission:Authors.Delete": "Deleting the authors"
|
||||
````
|
||||
|
||||
## Object to Object Mapping
|
||||
|
||||
`AuthorAppService` is using the `ObjectMapper` to convert the `Author` objects to `AuthorDto` objects. So, we need to define this mapping in the AutoMapper configuration.
|
||||
|
||||
Open the `BookStoreApplicationAutoMapperProfile` class inside the `Acme.BookStore.Application` project and add the following line to the constructor:
|
||||
|
||||
````csharp
|
||||
CreateMap<Author, AuthorDto>();
|
||||
````
|
||||
|
||||
## Data Seeder
|
||||
|
||||
As just done for the books before, it would be good to have some initial author entities in the database. This will be good while running the application first time, but also it is very useful for the automated tests.
|
||||
|
||||
Open the `BookStoreDataSeederContributor` in the `Acme.BookStore.Domain` project and change the file content with the code below:
|
||||
|
||||
````csharp
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using Acme.BookStore.Authors;
|
||||
using Acme.BookStore.Books;
|
||||
using Volo.Abp.Data;
|
||||
using Volo.Abp.DependencyInjection;
|
||||
using Volo.Abp.Domain.Repositories;
|
||||
|
||||
namespace Acme.BookStore
|
||||
{
|
||||
public class BookStoreDataSeederContributor
|
||||
: IDataSeedContributor, ITransientDependency
|
||||
{
|
||||
private readonly IRepository<Book, Guid> _bookRepository;
|
||||
private readonly IAuthorRepository _authorRepository;
|
||||
private readonly AuthorManager _authorManager;
|
||||
|
||||
public BookStoreDataSeederContributor(
|
||||
IRepository<Book, Guid> bookRepository,
|
||||
IAuthorRepository authorRepository,
|
||||
AuthorManager authorManager)
|
||||
{
|
||||
_bookRepository = bookRepository;
|
||||
_authorRepository = authorRepository;
|
||||
_authorManager = authorManager;
|
||||
}
|
||||
|
||||
public async Task SeedAsync(DataSeedContext context)
|
||||
{
|
||||
if (await _bookRepository.GetCountAsync() > 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// ADDED SEED DATA FOR AUTHORS
|
||||
|
||||
await _authorRepository.InsertAsync(
|
||||
await _authorManager.CreateAsync(
|
||||
"George Orwell",
|
||||
new DateTime(1903, 06, 25),
|
||||
"Orwell produced literary criticism and poetry, fiction and polemical journalism; and is best known for the allegorical novella Animal Farm (1945) and the dystopian novel Nineteen Eighty-Four (1949)."
|
||||
)
|
||||
);
|
||||
|
||||
await _authorRepository.InsertAsync(
|
||||
await _authorManager.CreateAsync(
|
||||
"Douglas Adams",
|
||||
new DateTime(1952, 03, 11),
|
||||
"Douglas Adams was an English author, screenwriter, essayist, humorist, satirist and dramatist. Adams was an advocate for environmentalism and conservation, a lover of fast cars, technological innovation and the Apple Macintosh, and a self-proclaimed 'radical atheist'."
|
||||
)
|
||||
);
|
||||
|
||||
await _bookRepository.InsertAsync(
|
||||
new Book
|
||||
{
|
||||
Name = "1984",
|
||||
Type = BookType.Dystopia,
|
||||
PublishDate = new DateTime(1949, 6, 8),
|
||||
Price = 19.84f
|
||||
},
|
||||
autoSave: true
|
||||
);
|
||||
|
||||
await _bookRepository.InsertAsync(
|
||||
new Book
|
||||
{
|
||||
Name = "The Hitchhiker's Guide to the Galaxy",
|
||||
Type = BookType.ScienceFiction,
|
||||
PublishDate = new DateTime(1995, 9, 27),
|
||||
Price = 42.0f
|
||||
},
|
||||
autoSave: true
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
## Testing the Author Application Service
|
||||
|
||||
Finally, we can write some tests for the `IAuthorAppService`. Add a new class, named `AuthorAppService_Tests` in the `Authors` namespace (folder) of the `Acme.BookStore.Application.Tests` project:
|
||||
|
||||
````csharp
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using Shouldly;
|
||||
using Xunit;
|
||||
|
||||
namespace Acme.BookStore.Authors
|
||||
{ {{if DB=="Mongo"}}
|
||||
[Collection(BookStoreTestConsts.CollectionDefinitionName)]{{end}}
|
||||
public class AuthorAppService_Tests : BookStoreApplicationTestBase
|
||||
{
|
||||
private readonly IAuthorAppService _authorAppService;
|
||||
|
||||
public AuthorAppService_Tests()
|
||||
{
|
||||
_authorAppService = GetRequiredService<IAuthorAppService>();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Should_Get_All_Authors_Without_Any_Filter()
|
||||
{
|
||||
var result = await _authorAppService.GetListAsync(new GetAuthorListDto());
|
||||
|
||||
result.TotalCount.ShouldBeGreaterThanOrEqualTo(2);
|
||||
result.Items.ShouldContain(author => author.Name == "George Orwell");
|
||||
result.Items.ShouldContain(author => author.Name == "Douglas Adams");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Should_Get_Filtered_Authors()
|
||||
{
|
||||
var result = await _authorAppService.GetListAsync(
|
||||
new GetAuthorListDto {Filter = "George"});
|
||||
|
||||
result.TotalCount.ShouldBeGreaterThanOrEqualTo(1);
|
||||
result.Items.ShouldContain(author => author.Name == "George Orwell");
|
||||
result.Items.ShouldNotContain(author => author.Name == "Douglas Adams");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Should_Create_A_New_Author()
|
||||
{
|
||||
var authorDto = await _authorAppService.CreateAsync(
|
||||
new CreateAuthorDto
|
||||
{
|
||||
Name = "Edward Bellamy",
|
||||
BirthDate = new DateTime(1850, 05, 22),
|
||||
ShortBio = "Edward Bellamy was an American author..."
|
||||
}
|
||||
);
|
||||
|
||||
authorDto.Id.ShouldNotBe(Guid.Empty);
|
||||
authorDto.Name.ShouldBe("Edward Bellamy");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Should_Not_Allow_To_Create_Duplicate_Author()
|
||||
{
|
||||
await Assert.ThrowsAsync<AuthorAlreadyExistsException>(async () =>
|
||||
{
|
||||
await _authorAppService.CreateAsync(
|
||||
new CreateAuthorDto
|
||||
{
|
||||
Name = "Douglas Adams",
|
||||
BirthDate = DateTime.Now,
|
||||
ShortBio = "..."
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
//TODO: Test other methods...
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
Created some tests for the application service methods, which should be clear to understand.
|
||||
|
||||
## The Next Part
|
||||
|
||||
See the [next part](Part-9.md) of this tutorial.
|
||||
@ -0,0 +1,854 @@
|
||||
# Web Application Development Tutorial - Part 9: Authors: User Interface
|
||||
````json
|
||||
//[doc-params]
|
||||
{
|
||||
"UI": ["MVC","NG"],
|
||||
"DB": ["EF","Mongo"]
|
||||
}
|
||||
````
|
||||
{{
|
||||
if UI == "MVC"
|
||||
UI_Text="mvc"
|
||||
else if UI == "NG"
|
||||
UI_Text="angular"
|
||||
else
|
||||
UI_Text="?"
|
||||
end
|
||||
if DB == "EF"
|
||||
DB_Text="Entity Framework Core"
|
||||
else if DB == "Mongo"
|
||||
DB_Text="MongoDB"
|
||||
else
|
||||
DB_Text="?"
|
||||
end
|
||||
}}
|
||||
|
||||
## 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_Text}}** 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](Part-7.md)
|
||||
- [Part 8: Authors: Application Layer](Part-8.md)
|
||||
- **Part 9: Authors: User Interface (this part)**
|
||||
- [Part 10: Book to Author Relation](Part-10.md)
|
||||
|
||||
### Download the Source Code
|
||||
|
||||
This tutorials has multiple versions based on your **UI** and **Database** preferences. We've prepared two 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)
|
||||
* [Angular UI with MongoDB](https://github.com/abpframework/abp-samples/tree/master/BookStore-Angular-MongoDb)
|
||||
|
||||
## Introduction
|
||||
|
||||
This part explains how to create a CRUD page for the `Author` entity introduced in previous parts.
|
||||
|
||||
{{if UI == "MVC"}}
|
||||
|
||||
## The Book List Page
|
||||
|
||||
Create a new razor page, `Index.cshtml` under the `Pages/Authors` folder of the `Acme.BookStore.Web` project and change the content as given below.
|
||||
|
||||
### Index.cshtml
|
||||
|
||||
````html
|
||||
@page
|
||||
@using Acme.BookStore.Localization
|
||||
@using Acme.BookStore.Permissions
|
||||
@using Acme.BookStore.Web.Pages.Authors
|
||||
@using Microsoft.AspNetCore.Authorization
|
||||
@using Microsoft.Extensions.Localization
|
||||
@inject IStringLocalizer<BookStoreResource> L
|
||||
@inject IAuthorizationService AuthorizationService
|
||||
@model IndexModel
|
||||
|
||||
@section scripts
|
||||
{
|
||||
<abp-script src="/Pages/Authors/Index.js"/>
|
||||
}
|
||||
|
||||
<abp-card>
|
||||
<abp-card-header>
|
||||
<abp-row>
|
||||
<abp-column size-md="_6">
|
||||
<abp-card-title>@L["Authors"]</abp-card-title>
|
||||
</abp-column>
|
||||
<abp-column size-md="_6" class="text-right">
|
||||
@if (await AuthorizationService
|
||||
.IsGrantedAsync(BookStorePermissions.Authors.Create))
|
||||
{
|
||||
<abp-button id="NewAuthorButton"
|
||||
text="@L["NewAuthor"].Value"
|
||||
icon="plus"
|
||||
button-type="Primary"/>
|
||||
}
|
||||
</abp-column>
|
||||
</abp-row>
|
||||
</abp-card-header>
|
||||
<abp-card-body>
|
||||
<abp-table striped-rows="true" id="AuthorsTable"></abp-table>
|
||||
</abp-card-body>
|
||||
</abp-card>
|
||||
````
|
||||
|
||||
This is a simple page similar to the Books page we had created before. It imports a JavaScript file which will be introduced below.
|
||||
|
||||
### IndexModel.cshtml.cs
|
||||
|
||||
````csharp
|
||||
using Microsoft.AspNetCore.Mvc.RazorPages;
|
||||
|
||||
namespace Acme.BookStore.Web.Pages.Authors
|
||||
{
|
||||
public class IndexModel : PageModel
|
||||
{
|
||||
public void OnGet()
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
### Index.js
|
||||
|
||||
````js
|
||||
$(function () {
|
||||
var l = abp.localization.getResource('BookStore');
|
||||
var createModal = new abp.ModalManager(abp.appPath + 'Authors/CreateModal');
|
||||
var editModal = new abp.ModalManager(abp.appPath + 'Authors/EditModal');
|
||||
|
||||
var dataTable = $('#AuthorsTable').DataTable(
|
||||
abp.libs.datatables.normalizeConfiguration({
|
||||
serverSide: true,
|
||||
paging: true,
|
||||
order: [[1, "asc"]],
|
||||
searching: false,
|
||||
scrollX: true,
|
||||
ajax: abp.libs.datatables.createAjax(acme.bookStore.authors.author.getList),
|
||||
columnDefs: [
|
||||
{
|
||||
title: l('Actions'),
|
||||
rowAction: {
|
||||
items:
|
||||
[
|
||||
{
|
||||
text: l('Edit'),
|
||||
visible:
|
||||
abp.auth.isGranted('BookStore.Authors.Edit'),
|
||||
action: function (data) {
|
||||
editModal.open({ id: data.record.id });
|
||||
}
|
||||
},
|
||||
{
|
||||
text: l('Delete'),
|
||||
visible:
|
||||
abp.auth.isGranted('BookStore.Authors.Delete'),
|
||||
confirmMessage: function (data) {
|
||||
return l(
|
||||
'AuthorDeletionConfirmationMessage',
|
||||
data.record.name
|
||||
);
|
||||
},
|
||||
action: function (data) {
|
||||
acme.bookStore.authors.author
|
||||
.delete(data.record.id)
|
||||
.then(function() {
|
||||
abp.notify.info(
|
||||
l('SuccessfullyDeleted')
|
||||
);
|
||||
dataTable.ajax.reload();
|
||||
});
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
title: l('Name'),
|
||||
data: "name"
|
||||
},
|
||||
{
|
||||
title: l('BirthDate'),
|
||||
data: "birthDate",
|
||||
render: function (data) {
|
||||
return luxon
|
||||
.DateTime
|
||||
.fromISO(data, {
|
||||
locale: abp.localization.currentCulture.name
|
||||
}).toLocaleString();
|
||||
}
|
||||
}
|
||||
]
|
||||
})
|
||||
);
|
||||
|
||||
createModal.onResult(function () {
|
||||
dataTable.ajax.reload();
|
||||
});
|
||||
|
||||
editModal.onResult(function () {
|
||||
dataTable.ajax.reload();
|
||||
});
|
||||
|
||||
$('#NewAuthorButton').click(function (e) {
|
||||
e.preventDefault();
|
||||
createModal.open();
|
||||
});
|
||||
});
|
||||
````
|
||||
|
||||
Briefly, this JavaScript page;
|
||||
|
||||
* Creates a Data table with `Actions`, `Name` and `BirthDate` columns.
|
||||
* `Actions` column is used to add *Edit* and *Delete* actions.
|
||||
* `BirthDate` provides a `render` function to format the `DateTime` value using the [luxon](https://moment.github.io/luxon/) library.
|
||||
* Uses the `abp.ModalManager` to open *Create* and *Edit* modal forms.
|
||||
|
||||
This code is very similar to the Books page created before, so we will not explain it more.
|
||||
|
||||
### Localizations
|
||||
|
||||
This page uses some localization keys we need to declare. Open the `en.json` file under the `Localization/BookStore` folder of the `Acme.BookStore.Domain.Shared` project and add the following entries:
|
||||
|
||||
````json
|
||||
"Menu:Authors": "Authors",
|
||||
"Authors": "Authors",
|
||||
"AuthorDeletionConfirmationMessage": "Are you sure to delete the author '{0}'?",
|
||||
"BirthDate": "Birth date",
|
||||
"NewAuthor": "New author"
|
||||
````
|
||||
|
||||
Notice that we've added more keys. They will be used in the next sections.
|
||||
|
||||
### Add to the Main Menu
|
||||
|
||||
Open the `BookStoreMenuContributor.cs` in the `Menus` folder of the `Acme.BookStore.Web` project and add the following code in the end of the `ConfigureMainMenuAsync` method:
|
||||
|
||||
````csharp
|
||||
if (await context.IsGrantedAsync(BookStorePermissions.Authors.Default))
|
||||
{
|
||||
bookStoreMenu.AddItem(new ApplicationMenuItem(
|
||||
"BooksStore.Authors",
|
||||
l["Menu:Authors"],
|
||||
url: "/Authors"
|
||||
));
|
||||
}
|
||||
````
|
||||
|
||||
### Run the Application
|
||||
|
||||
Run and login to the application. **You can not see the menu item since you don't have permission yet.** Go to the `Identity/Roles` page, click to the *Actions* button and select the *Permissions* action for the **admin role**:
|
||||
|
||||
|
||||
|
||||
As you see, the admin role has no *Author Management* permissions yet. Click to the checkboxes and save the modal to grant the necessary permissions. You will see the *Authors* menu item under the *Book Store* in the main menu, after **refreshing the page**:
|
||||
|
||||
|
||||
|
||||
The page is fully working except *New author* and *Actions/Edit* since we haven't implemented them yet.
|
||||
|
||||
> **Tip**: If you run the `.DbMigrator` console application after defining a new permission, it automatically grants these new permissions to the admin role and you don't need to manually grant the permissions yourself.
|
||||
|
||||
## Create Modal
|
||||
|
||||
Create a new razor page, `CreateModal.cshtml` under the `Pages/Authors` folder of the `Acme.BookStore.Web` project and change the content as given below.
|
||||
|
||||
### CreateModal.cshtml
|
||||
|
||||
```html
|
||||
@page
|
||||
@using Acme.BookStore.Localization
|
||||
@using Acme.BookStore.Web.Pages.Authors
|
||||
@using Microsoft.Extensions.Localization
|
||||
@using Volo.Abp.AspNetCore.Mvc.UI.Bootstrap.TagHelpers.Modal
|
||||
@model CreateModalModel
|
||||
@inject IStringLocalizer<BookStoreResource> L
|
||||
@{
|
||||
Layout = null;
|
||||
}
|
||||
<form asp-page="/Authors/CreateModal">
|
||||
<abp-modal>
|
||||
<abp-modal-header title="@L["NewAuthor"].Value"></abp-modal-header>
|
||||
<abp-modal-body>
|
||||
<abp-input asp-for="Author.Name" />
|
||||
<abp-input asp-for="Author.BirthDate" />
|
||||
<abp-input asp-for="Author.ShortBio" />
|
||||
</abp-modal-body>
|
||||
<abp-modal-footer buttons="@(AbpModalButtons.Cancel|AbpModalButtons.Save)"></abp-modal-footer>
|
||||
</abp-modal>
|
||||
</form>
|
||||
```
|
||||
|
||||
We had used [dynamic forms](../UI/AspNetCore/Tag-Helpers/Dynamic-Forms.md) of the ABP Framework for the books page before. We could use the same approach here, but we wanted to show how to do it manually. Actually, not so manually, because we've used `abp-input` tag helper in this case to simplify creating the form elements.
|
||||
|
||||
You can definitely use the standard Bootstrap HTML structure, but it requires to write a lot of code. `abp-input` automatically adds validation, localization and other standard elements based on the data type.
|
||||
|
||||
### CreateModal.cshtml.cs
|
||||
|
||||
```csharp
|
||||
using System;
|
||||
using System.ComponentModel.DataAnnotations;
|
||||
using System.Threading.Tasks;
|
||||
using Acme.BookStore.Authors;
|
||||
using Microsoft.AspNetCore.Mvc;
|
||||
using Volo.Abp.AspNetCore.Mvc.UI.Bootstrap.TagHelpers.Form;
|
||||
|
||||
namespace Acme.BookStore.Web.Pages.Authors
|
||||
{
|
||||
public class CreateModalModel : BookStorePageModel
|
||||
{
|
||||
[BindProperty]
|
||||
public CreateAuthorViewModel Author { get; set; }
|
||||
|
||||
private readonly IAuthorAppService _authorAppService;
|
||||
|
||||
public CreateModalModel(IAuthorAppService authorAppService)
|
||||
{
|
||||
_authorAppService = authorAppService;
|
||||
}
|
||||
|
||||
public void OnGet()
|
||||
{
|
||||
Author = new CreateAuthorViewModel();
|
||||
}
|
||||
|
||||
public async Task<IActionResult> OnPostAsync()
|
||||
{
|
||||
var dto = ObjectMapper.Map<CreateAuthorViewModel, CreateAuthorDto>(Author);
|
||||
await _authorAppService.CreateAsync(dto);
|
||||
return NoContent();
|
||||
}
|
||||
|
||||
public class CreateAuthorViewModel
|
||||
{
|
||||
[Required]
|
||||
[StringLength(AuthorConsts.MaxNameLength)]
|
||||
public string Name { get; set; }
|
||||
|
||||
[Required]
|
||||
[DataType(DataType.Date)]
|
||||
public DateTime BirthDate { get; set; }
|
||||
|
||||
[TextArea]
|
||||
public string ShortBio { get; set; }
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
This page model class simply injects and uses the `IAuthorAppService` to create a new author. The main difference between the book creation model class is that this one is declaring a new class, `CreateAuthorViewModel`, for the view model instead of re-using the `CreateAuthorDto`.
|
||||
|
||||
The main reason of this decision was to show you how to use a different model class inside the page. But there is one more benefit: We added two attributes to the class members, which were not present in the `CreateAuthorDto`:
|
||||
|
||||
* Added `[DataType(DataType.Date)]` attribute to the `BirthDate` which shows a date picker on the UI for this property.
|
||||
* Added `[TextArea]` attribute to the `ShortBio` which shows a multi-line text area instead of a standard textbox.
|
||||
|
||||
In this way, you can specialize the view model class based on your UI requirements without touching to the DTO. As a result of this decision, we have used `ObjectMapper` to map `CreateAuthorViewModel` to `CreateAuthorDto`. To be able to do that, you need to add a new mapping code to the `BookStoreWebAutoMapperProfile` constructor:
|
||||
|
||||
````csharp
|
||||
using Acme.BookStore.Authors; // ADDED NAMESPACE IMPORT
|
||||
using Acme.BookStore.Books;
|
||||
using AutoMapper;
|
||||
|
||||
namespace Acme.BookStore.Web
|
||||
{
|
||||
public class BookStoreWebAutoMapperProfile : Profile
|
||||
{
|
||||
public BookStoreWebAutoMapperProfile()
|
||||
{
|
||||
CreateMap<BookDto, CreateUpdateBookDto>();
|
||||
|
||||
// ADD a NEW MAPPING
|
||||
CreateMap<Pages.Authors.CreateModalModel.CreateAuthorViewModel,
|
||||
CreateAuthorDto>();
|
||||
}
|
||||
}
|
||||
}
|
||||
````
|
||||
|
||||
"New author" button will work as expected and open a new model when you run the application again:
|
||||
|
||||
|
||||
|
||||
## Edit Modal
|
||||
|
||||
Create a new razor page, `EditModal.cshtml` under the `Pages/Authors` folder of the `Acme.BookStore.Web` project and change the content as given below.
|
||||
|
||||
### EditModal.cshtml
|
||||
|
||||
````html
|
||||
@page
|
||||
@using Acme.BookStore.Localization
|
||||
@using Acme.BookStore.Web.Pages.Authors
|
||||
@using Microsoft.Extensions.Localization
|
||||
@using Volo.Abp.AspNetCore.Mvc.UI.Bootstrap.TagHelpers.Modal
|
||||
@model EditModalModel
|
||||
@inject IStringLocalizer<BookStoreResource> L
|
||||
@{
|
||||
Layout = null;
|
||||
}
|
||||
<form asp-page="/Authors/EditModal">
|
||||
<abp-modal>
|
||||
<abp-modal-header title="@L["Update"].Value"></abp-modal-header>
|
||||
<abp-modal-body>
|
||||
<abp-input asp-for="Author.Id" />
|
||||
<abp-input asp-for="Author.Name" />
|
||||
<abp-input asp-for="Author.BirthDate" />
|
||||
<abp-input asp-for="Author.ShortBio" />
|
||||
</abp-modal-body>
|
||||
<abp-modal-footer buttons="@(AbpModalButtons.Cancel|AbpModalButtons.Save)"></abp-modal-footer>
|
||||
</abp-modal>
|
||||
</form>
|
||||
````
|
||||
|
||||
### EditModal.cshtml.cs
|
||||
|
||||
```csharp
|
||||
using System;
|
||||
using System.ComponentModel.DataAnnotations;
|
||||
using System.Threading.Tasks;
|
||||
using Acme.BookStore.Authors;
|
||||
using Microsoft.AspNetCore.Mvc;
|
||||
using Volo.Abp.AspNetCore.Mvc.UI.Bootstrap.TagHelpers.Form;
|
||||
|
||||
namespace Acme.BookStore.Web.Pages.Authors
|
||||
{
|
||||
public class EditModalModel : BookStorePageModel
|
||||
{
|
||||
[BindProperty]
|
||||
public EditAuthorViewModel Author { get; set; }
|
||||
|
||||
private readonly IAuthorAppService _authorAppService;
|
||||
|
||||
public EditModalModel(IAuthorAppService authorAppService)
|
||||
{
|
||||
_authorAppService = authorAppService;
|
||||
}
|
||||
|
||||
public async Task OnGetAsync(Guid id)
|
||||
{
|
||||
var authorDto = await _authorAppService.GetAsync(id);
|
||||
Author = ObjectMapper.Map<AuthorDto, EditAuthorViewModel>(authorDto);
|
||||
}
|
||||
|
||||
public async Task<IActionResult> OnPostAsync()
|
||||
{
|
||||
await _authorAppService.UpdateAsync(
|
||||
Author.Id,
|
||||
ObjectMapper.Map<EditAuthorViewModel, UpdateAuthorDto>(Author)
|
||||
);
|
||||
|
||||
return NoContent();
|
||||
}
|
||||
|
||||
public class EditAuthorViewModel
|
||||
{
|
||||
[HiddenInput]
|
||||
public Guid Id { get; set; }
|
||||
|
||||
[Required]
|
||||
[StringLength(AuthorConsts.MaxNameLength)]
|
||||
public string Name { get; set; }
|
||||
|
||||
[Required]
|
||||
[DataType(DataType.Date)]
|
||||
public DateTime BirthDate { get; set; }
|
||||
|
||||
[TextArea]
|
||||
public string ShortBio { get; set; }
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
This class is similar to the `CreateModal.cshtml.cs` while there are some main differences;
|
||||
|
||||
* Uses the `IAuthorAppService.GetAsync(...)` method to get the editing author from the application layer.
|
||||
* `EditAuthorViewModel` has an additional `Id` property which is marked with the `[HiddenInput]` attribute that creates a hidden input for this property.
|
||||
|
||||
This class requires to add two object mapping declarations to the `BookStoreWebAutoMapperProfile` class:
|
||||
|
||||
```csharp
|
||||
using Acme.BookStore.Authors;
|
||||
using Acme.BookStore.Books;
|
||||
using AutoMapper;
|
||||
|
||||
namespace Acme.BookStore.Web
|
||||
{
|
||||
public class BookStoreWebAutoMapperProfile : Profile
|
||||
{
|
||||
public BookStoreWebAutoMapperProfile()
|
||||
{
|
||||
CreateMap<BookDto, CreateUpdateBookDto>();
|
||||
|
||||
CreateMap<Pages.Authors.CreateModalModel.CreateAuthorViewModel,
|
||||
CreateAuthorDto>();
|
||||
|
||||
// ADD THESE NEW MAPPINGS
|
||||
CreateMap<AuthorDto, Pages.Authors.EditModalModel.EditAuthorViewModel>();
|
||||
CreateMap<Pages.Authors.EditModalModel.EditAuthorViewModel,
|
||||
UpdateAuthorDto>();
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
That's all! You can run the application and try to edit an author.
|
||||
|
||||
{{else if UI == "NG"}}
|
||||
|
||||
## The Author List Page, Create & Delete Authors
|
||||
|
||||
Run the following command line to create a new module, named `AuthorModule` in the root folder of the angular application:
|
||||
|
||||
```bash
|
||||
yarn ng generate module author --module app --routing --route authors
|
||||
```
|
||||
|
||||
This command should produce the following output:
|
||||
|
||||
```bash
|
||||
> yarn ng generate module author --module app --routing --route authors
|
||||
|
||||
yarn run v1.19.1
|
||||
$ ng generate module author --module app --routing --route authors
|
||||
CREATE src/app/author/author-routing.module.ts (344 bytes)
|
||||
CREATE src/app/author/author.module.ts (349 bytes)
|
||||
CREATE src/app/author/author.component.html (21 bytes)
|
||||
CREATE src/app/author/author.component.spec.ts (628 bytes)
|
||||
CREATE src/app/author/author.component.ts (276 bytes)
|
||||
CREATE src/app/author/author.component.scss (0 bytes)
|
||||
UPDATE src/app/app-routing.module.ts (1396 bytes)
|
||||
Done in 2.22s.
|
||||
```
|
||||
|
||||
### AuthorModule
|
||||
|
||||
Open the `/src/app/author/author.module.ts` and replace the content as shown below:
|
||||
|
||||
```js
|
||||
import { NgModule } from '@angular/core';
|
||||
import { SharedModule } from '../shared/shared.module';
|
||||
import { AuthorRoutingModule } from './author-routing.module';
|
||||
import { AuthorComponent } from './author.component';
|
||||
import { NgbDatepickerModule } from '@ng-bootstrap/ng-bootstrap';
|
||||
|
||||
@NgModule({
|
||||
declarations: [AuthorComponent],
|
||||
imports: [SharedModule, AuthorRoutingModule, NgbDatepickerModule],
|
||||
})
|
||||
export class AuthorModule {}
|
||||
```
|
||||
|
||||
- Added the `SharedModule`. `SharedModule` exports some common modules needed to create user interfaces.
|
||||
- `SharedModule` already exports the `CommonModule`, so we've removed the `CommonModule`.
|
||||
- Added `NgbDatepickerModule` that will be used later on the author create and edit forms.
|
||||
|
||||
### Menu Definition
|
||||
|
||||
Open the `src/app/route.provider.ts` file and add the following menu definition:
|
||||
|
||||
````js
|
||||
{
|
||||
path: '/authors',
|
||||
name: '::Menu:Authors',
|
||||
parentName: '::Menu:BookStore',
|
||||
layout: eLayoutType.application,
|
||||
requiredPolicy: 'BookStore.Authors',
|
||||
}
|
||||
````
|
||||
|
||||
The final `configureRoutes` function declaration should be following:
|
||||
|
||||
```js
|
||||
function configureRoutes(routes: RoutesService) {
|
||||
return () => {
|
||||
routes.add([
|
||||
{
|
||||
path: '/',
|
||||
name: '::Menu:Home',
|
||||
iconClass: 'fas fa-home',
|
||||
order: 1,
|
||||
layout: eLayoutType.application,
|
||||
},
|
||||
{
|
||||
path: '/book-store',
|
||||
name: '::Menu:BookStore',
|
||||
iconClass: 'fas fa-book',
|
||||
order: 2,
|
||||
layout: eLayoutType.application,
|
||||
},
|
||||
{
|
||||
path: '/books',
|
||||
name: '::Menu:Books',
|
||||
parentName: '::Menu:BookStore',
|
||||
layout: eLayoutType.application,
|
||||
requiredPolicy: 'BookStore.Books',
|
||||
},
|
||||
{
|
||||
path: '/authors',
|
||||
name: '::Menu:Authors',
|
||||
parentName: '::Menu:BookStore',
|
||||
layout: eLayoutType.application,
|
||||
requiredPolicy: 'BookStore.Authors',
|
||||
},
|
||||
]);
|
||||
};
|
||||
}
|
||||
```
|
||||
|
||||
### Service Proxy Generation
|
||||
|
||||
[ABP CLI](https://docs.abp.io/en/abp/latest/CLI) provides `generate-proxy` command that generates client proxies for your HTTP APIs to make easy to consume your HTTP APIs from the client side. Before running `generate-proxy` command, your host must be up and running.
|
||||
|
||||
Run the following command in the `angular` folder:
|
||||
|
||||
```bash
|
||||
abp generate-proxy
|
||||
```
|
||||
|
||||
This command generates the service proxy for the author service and the related model (DTO) classes:
|
||||
|
||||
|
||||
|
||||
### AuthorComponent
|
||||
|
||||
Open the `/src/app/author/author.component.ts` file and replace the content as below:
|
||||
|
||||
```js
|
||||
import { Component, OnInit } from '@angular/core';
|
||||
import { ListService, PagedResultDto } from '@abp/ng.core';
|
||||
import { AuthorDto } from './models';
|
||||
import { AuthorService } from './services';
|
||||
import { FormGroup, FormBuilder, Validators } from '@angular/forms';
|
||||
import { NgbDateNativeAdapter, NgbDateAdapter } from '@ng-bootstrap/ng-bootstrap';
|
||||
import { ConfirmationService, Confirmation } from '@abp/ng.theme.shared';
|
||||
|
||||
@Component({
|
||||
selector: 'app-author',
|
||||
templateUrl: './author.component.html',
|
||||
styleUrls: ['./author.component.scss'],
|
||||
providers: [ListService, { provide: NgbDateAdapter, useClass: NgbDateNativeAdapter }],
|
||||
})
|
||||
export class AuthorComponent implements OnInit {
|
||||
author = { items: [], totalCount: 0 } as PagedResultDto<AuthorDto>;
|
||||
|
||||
isModalOpen = false;
|
||||
|
||||
form: FormGroup;
|
||||
|
||||
selectedAuthor = new AuthorDto();
|
||||
|
||||
constructor(
|
||||
public readonly list: ListService,
|
||||
private authorService: AuthorService,
|
||||
private fb: FormBuilder,
|
||||
private confirmation: ConfirmationService
|
||||
) {}
|
||||
|
||||
ngOnInit(): void {
|
||||
const authorStreamCreator = (query) => this.authorService.getListByInput(query);
|
||||
|
||||
this.list.hookToQuery(authorStreamCreator).subscribe((response) => {
|
||||
this.author = response;
|
||||
});
|
||||
}
|
||||
|
||||
createAuthor() {
|
||||
this.selectedAuthor = new AuthorDto();
|
||||
this.buildForm();
|
||||
this.isModalOpen = true;
|
||||
}
|
||||
|
||||
editAuthor(id: string) {
|
||||
this.authorService.getById(id).subscribe((author) => {
|
||||
this.selectedAuthor = author;
|
||||
this.buildForm();
|
||||
this.isModalOpen = true;
|
||||
});
|
||||
}
|
||||
|
||||
buildForm() {
|
||||
this.form = this.fb.group({
|
||||
name: [this.selectedAuthor.name || '', Validators.required],
|
||||
birthDate: [
|
||||
this.selectedAuthor.birthDate ? new Date(this.selectedAuthor.birthDate) : null,
|
||||
Validators.required,
|
||||
],
|
||||
});
|
||||
}
|
||||
|
||||
save() {
|
||||
if (this.form.invalid) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.selectedAuthor.id) {
|
||||
this.authorService
|
||||
.updateByIdAndInput(this.form.value, this.selectedAuthor.id)
|
||||
.subscribe(() => {
|
||||
this.isModalOpen = false;
|
||||
this.form.reset();
|
||||
this.list.get();
|
||||
});
|
||||
} else {
|
||||
this.authorService.createByInput(this.form.value).subscribe(() => {
|
||||
this.isModalOpen = false;
|
||||
this.form.reset();
|
||||
this.list.get();
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
delete(id: string) {
|
||||
this.confirmation.warn('::AreYouSureToDelete', '::AreYouSure')
|
||||
.subscribe((status) => {
|
||||
if (status === Confirmation.Status.confirm) {
|
||||
this.authorService.deleteById(id).subscribe(() => this.list.get());
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Open the `/src/app/author/author.component.html` and replace the content as below:
|
||||
|
||||
````html
|
||||
<div class="card">
|
||||
<div class="card-header">
|
||||
<div class="row">
|
||||
<div class="col col-md-6">
|
||||
<h5 class="card-title">
|
||||
{%{{{ '::Menu:Authors' | abpLocalization }}}%}
|
||||
</h5>
|
||||
</div>
|
||||
<div class="text-right col col-md-6">
|
||||
<div class="text-lg-right pt-2">
|
||||
<button id="create" class="btn btn-primary" type="button" (click)="createAuthor()">
|
||||
<i class="fa fa-plus mr-1"></i>
|
||||
<span>{%{{{ '::NewAuthor' | abpLocalization }}}%}</span>
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="card-body">
|
||||
<ngx-datatable [rows]="author.items" [count]="author.totalCount" [list]="list" default>
|
||||
<ngx-datatable-column
|
||||
[name]="'::Actions' | abpLocalization"
|
||||
[maxWidth]="150"
|
||||
[sortable]="false"
|
||||
>
|
||||
<ng-template let-row="row" ngx-datatable-cell-template>
|
||||
<div ngbDropdown container="body" class="d-inline-block">
|
||||
<button
|
||||
class="btn btn-primary btn-sm dropdown-toggle"
|
||||
data-toggle="dropdown"
|
||||
aria-haspopup="true"
|
||||
ngbDropdownToggle
|
||||
>
|
||||
<i class="fa fa-cog mr-1"></i>{%{{{ '::Actions' | abpLocalization }}}%}
|
||||
</button>
|
||||
<div ngbDropdownMenu>
|
||||
<button ngbDropdownItem (click)="editAuthor(row.id)">
|
||||
{%{{{ '::Edit' | abpLocalization }}}%}
|
||||
</button>
|
||||
<button ngbDropdownItem (click)="delete(row.id)">
|
||||
{%{{{ '::Delete' | abpLocalization }}}%}
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
</ng-template>
|
||||
</ngx-datatable-column>
|
||||
<ngx-datatable-column [name]="'::Name' | abpLocalization" prop="name"></ngx-datatable-column>
|
||||
<ngx-datatable-column [name]="'::BirthDate' | abpLocalization">
|
||||
<ng-template let-row="row" ngx-datatable-cell-template>
|
||||
{%{{{ row.birthDate | date }}}%}
|
||||
</ng-template>
|
||||
</ngx-datatable-column>
|
||||
</ngx-datatable>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<abp-modal [(visible)]="isModalOpen">
|
||||
<ng-template #abpHeader>
|
||||
<h3>{%{{{ (selectedAuthor.id ? '::Edit' : '::NewAuthor') | abpLocalization }}}%}</h3>
|
||||
</ng-template>
|
||||
|
||||
<ng-template #abpBody>
|
||||
<form [formGroup]="form" (ngSubmit)="save()">
|
||||
<div class="form-group">
|
||||
<label for="author-name">Name</label><span> * </span>
|
||||
<input type="text" id="author-name" class="form-control" formControlName="name" autofocus />
|
||||
</div>
|
||||
|
||||
<div class="form-group">
|
||||
<label>Birth date</label><span> * </span>
|
||||
<input
|
||||
#datepicker="ngbDatepicker"
|
||||
class="form-control"
|
||||
name="datepicker"
|
||||
formControlName="birthDate"
|
||||
ngbDatepicker
|
||||
(click)="datepicker.toggle()"
|
||||
/>
|
||||
</div>
|
||||
</form>
|
||||
</ng-template>
|
||||
|
||||
<ng-template #abpFooter>
|
||||
<button type="button" class="btn btn-secondary" #abpClose>
|
||||
{%{{{ '::Close' | abpLocalization }}}%}
|
||||
</button>
|
||||
|
||||
<button class="btn btn-primary" (click)="save()" [disabled]="form.invalid">
|
||||
<i class="fa fa-check mr-1"></i>
|
||||
{%{{{ '::Save' | abpLocalization }}}%}
|
||||
</button>
|
||||
</ng-template>
|
||||
</abp-modal>
|
||||
````
|
||||
|
||||
### Localizations
|
||||
|
||||
This page uses some localization keys we need to declare. Open the `en.json` file under the `Localization/BookStore` folder of the `Acme.BookStore.Domain.Shared` project and add the following entries:
|
||||
|
||||
````json
|
||||
"Menu:Authors": "Authors",
|
||||
"Authors": "Authors",
|
||||
"AuthorDeletionConfirmationMessage": "Are you sure to delete the author '{0}'?",
|
||||
"BirthDate": "Birth date",
|
||||
"NewAuthor": "New author"
|
||||
````
|
||||
|
||||
### Run the Application
|
||||
|
||||
Run and login to the application. **You can not see the menu item since you don't have permission yet.** Go to the `identity/roles` page, click to the *Actions* button and select the *Permissions* action for the **admin role**:
|
||||
|
||||
|
||||
|
||||
As you see, the admin role has no *Author Management* permissions yet. Click to the checkboxes and save the modal to grant the necessary permissions. You will see the *Authors* menu item under the *Book Store* in the main menu, after **refreshing the page**:
|
||||
|
||||
|
||||
|
||||
That's all! This is a fully working CRUD page, you can create, edit and delete authors.
|
||||
|
||||
> **Tip**: If you run the `.DbMigrator` console application after defining a new permission, it automatically grants these new permissions to the admin role and you don't need to manually grant the permissions yourself.
|
||||
|
||||
{{end}}
|
||||
|
||||
## The Next Part
|
||||
|
||||
See the [next part](Part-10.md) of this tutorial.
|
||||
|
After Width: | Height: | Size: 29 KiB |
|
After Width: | Height: | Size: 51 KiB |
|
After Width: | Height: | Size: 78 KiB |
|
After Width: | Height: | Size: 36 KiB |
|
After Width: | Height: | Size: 46 KiB |
|
After Width: | Height: | Size: 25 KiB |
|
After Width: | Height: | Size: 75 KiB |
|
After Width: | Height: | Size: 76 KiB |
|
After Width: | Height: | Size: 65 KiB |
|
After Width: | Height: | Size: 62 KiB |
|
After Width: | Height: | Size: 19 KiB |
@ -0,0 +1,3 @@
|
||||
# Dynamic JavaScript HTTP API Proxies
|
||||
|
||||
TODO
|
||||
@ -1,12 +1,18 @@
|
||||
using System;
|
||||
using Volo.Abp.MultiTenancy;
|
||||
|
||||
namespace Volo.Abp.EventBus
|
||||
{
|
||||
public class MySimpleEventData
|
||||
public class MySimpleEventData : IMultiTenant
|
||||
{
|
||||
public int Value { get; set; }
|
||||
|
||||
public MySimpleEventData(int value)
|
||||
public Guid? TenantId { get; }
|
||||
|
||||
public MySimpleEventData(int value, Guid? tenantId = null)
|
||||
{
|
||||
Value = value;
|
||||
TenantId = tenantId;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,7 @@
|
||||
namespace Volo.Abp.IdentityServer
|
||||
{
|
||||
public class IdentityServerSecurityLogIdentityConsts
|
||||
{
|
||||
public static string IdentityServer { get; set; } = "IdentityServer";
|
||||
}
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue