Web应用程序开发教程 - 第十章: 图书到作者的关系

关于本教程

在本系列教程中, 你将构建一个名为 Acme.BookStore 的用于管理书籍及其作者列表的基于ABP的应用程序. 它是使用以下技术开发的:

  • **** 做为ORM提供程序.
  • MVC / Razor Pages 做为UI框架.

本教程分为以下部分:

下载源码

本教程根据你的UI 和 数据库偏好有多个版本,我们准备了几种可供下载的源码组合:

如果你在Windows中遇到 “文件名太长” or “解压错误”, 很可能与Windows最大文件路径限制有关. Windows文件路径的最大长度为250字符. 为了解决这个问题,参阅 在Windows 10中启用长路径.

如果你遇到与Git相关的长路径错误, 尝试使用下面的命令在Windows中启用长路径. 参阅 https://github.com/msysgit/msysgit/wiki/Git-cannot-create-a-file-or-directory-with-a-long-path git config --system core.longpaths true

简介

我们已经为图书管理应用程序创建了 图书 和 作者 功能. 然而, 这些实体间还没有关联.

在本章, 我们会在 作者 和 图书 实体间建立 1 对 N 的关系.

在图书实体中加入关系

打开 Acme.BookStore.Domain 项目中的 Books/Book.cs, 在 Book 实体中加入下列属性:

  1. public Guid AuthorId { get; set; }

在本章中, 我们选择不在 Book 类中加入 Author 实体的 导航属性 (例如 public Author Author { get; set; }). 这是为了遵循 DDD 最佳实践 (规则: 仅通过id引用其它聚合对象). 但是, 你自己可以添加这样的导航属性, 并为EF Core配置它. 这样, 你在获取图书和它们的作者时就不需要写join查询了(如同下面我们做的一样), 这会使代码更简洁一些.

数据库 & 数据迁移

为 Book 实体新增一个不为空的 AuthorId 属性. 但是, 数据库中已存在的图书怎么办? 它们没有 AuthorIds, 当我们尝试运行应用程序时会出问题.

这是一个 典型的迁移问题, 解决方案依赖于你的具体情况;

  • 如果你还没有发布应用程序到生产环境, 你可以直接删除数据库中的图书数据, 甚至你可以删除开发环境中的整个数据库.
  • 你可以在数据迁移或生成种子阶段使用代码更新已有数据.
  • 你可以手工处理这些数据.

我们倾向于 删除数据库 (你可以在 Package Manager 控制台中运行 Drop-Database), 因为这只是个示例项目, 数据丢失并不要紧. 因为这个主题不是关于ABP框架的, 我们不会深入所有的场景.

更新 EF Core 映射

定位到 Acme.BookStore.EntityFrameworkCore 项目的 EntityFrameworkCore 文件夹下的 BookStoreDbContext 类的 OnModelCreating 方法, 修改 builder.Entity<Book> 部分如下:

  1. builder.Entity<Book>(b =>
  2. {
  3.     b.ToTable(BookStoreConsts.DbTablePrefix + "Books", BookStoreConsts.DbSchema);
  4.     b.ConfigureByConvention(); //auto configure for the base class props
  5.     b.Property(x => x.Name).IsRequired().HasMaxLength(128);
  7.     // ADD THE MAPPING FOR THE RELATION
  8.     b.HasOne<Author>().WithMany().HasForeignKey(x => x.AuthorId).IsRequired();
  9. });

新增 EF Core 迁移

启动解决方案被配置为使用 Entity Framework Core Code First Migrations. 因为我们修改了数据库映射配置, 我们需要新建一个迁移并应用于数据库.

在 Acme.BookStore.EntityFrameworkCore 项目的文件目录打开命令行终端, 输入命令:

  1. dotnet ef migrations add Added_AuthorId_To_Book

这会创建一个新的迁移类, 在它的 Up 方法中使用下列方法:

  1. migrationBuilder.AddColumn<Guid>(
  2.     name: "AuthorId",
  3.     table: "AppBooks",
  4.     nullable: false,
  5.     defaultValue: new Guid("00000000-0000-0000-0000-000000000000"));
  7. migrationBuilder.CreateIndex(
  8.     name: "IX_AppBooks_AuthorId",
  9.     table: "AppBooks",
  10.     column: "AuthorId");
  12. migrationBuilder.AddForeignKey(
  13.     name: "FK_AppBooks_AppAuthors_AuthorId",
  14.     table: "AppBooks",
  15.     column: "AuthorId",
  16.     principalTable: "AppAuthors",
  17.     principalColumn: "Id",
  18.     onDelete: ReferentialAction.Cascade);
  • AppBooks 表增加一个 AuthorId 字段 .
  • 根据 AuthorId 字段新建一个索引.
  • 声明到 AppAuthors 表的外键.

如果你使用 Visual Studio, 可能希望在 Package Manager Console (PMC) 使用 Add-Migration Added_AuthorId_To_Book -c BookStoreDbContext 和 Update-Database -Context BookStoreDbContext 命令. 如果这样, 保证 Acme.BookStore.Web 是启动项目并且在PMC中 Acme.BookStore.EntityFrameworkCore 是 默认项目 .

修改数据种子

因为 AuthorId 是 Book 实体的不可为空属性, 当前的数据种子代码不能工作. 打开 Acme.BookStore.Domain 项目中的 BookStoreDataSeederContributor, 修改成以下代码:

  1. using System;
  2. using System.Threading.Tasks;
  3. using Acme.BookStore.Authors;
  4. using Acme.BookStore.Books;
  5. using Volo.Abp.Data;
  6. using Volo.Abp.DependencyInjection;
  7. using Volo.Abp.Domain.Repositories;
  9. namespace Acme.BookStore
  10. {
  11.     public class BookStoreDataSeederContributor
  12.         : IDataSeedContributor, ITransientDependency
  13.     {
  14.         private readonly IRepository<Book, Guid> _bookRepository;
  15.         private readonly IAuthorRepository _authorRepository;
  16.         private readonly AuthorManager _authorManager;
  18.         public BookStoreDataSeederContributor(
  19.             IRepository<Book, Guid> bookRepository,
  20.             IAuthorRepository authorRepository,
  21.             AuthorManager authorManager)
  22.         {
  23.             _bookRepository = bookRepository;
  24.             _authorRepository = authorRepository;
  25.             _authorManager = authorManager;
  26.         }
  28.         public async Task SeedAsync(DataSeedContext context)
  29.         {
  30.             if (await _bookRepository.GetCountAsync() > 0)
  31.             {
  32.                 return;
  33.             }
  35.             var orwell = await _authorRepository.InsertAsync(
  36.                 await _authorManager.CreateAsync(
  37.                     "George Orwell",
  38.                     new DateTime(1903, 06, 25),
  39.                     "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)."
  40.                 )
  41.             );
  43.             var douglas = await _authorRepository.InsertAsync(
  44.                 await _authorManager.CreateAsync(
  45.                     "Douglas Adams",
  46.                     new DateTime(1952, 03, 11),
  47.                     "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'."
  48.                 )
  49.             );
  51.             await _bookRepository.InsertAsync(
  52.                 new Book
  53.                 {
  54.                     AuthorId = orwell.Id, // SET THE AUTHOR
  55.                     Name = "1984",
  56.                     Type = BookType.Dystopia,
  57.                     PublishDate = new DateTime(1949, 6, 8),
  58.                     Price = 19.84f
  59.                 },
  60.                 autoSave: true
  61.             );
  63.             await _bookRepository.InsertAsync(
  64.                 new Book
  65.                 {
  66.                     AuthorId = douglas.Id, // SET THE AUTHOR
  67.                     Name = "The Hitchhiker's Guide to the Galaxy",
  68.                     Type = BookType.ScienceFiction,
  69.                     PublishDate = new DateTime(1995, 9, 27),
  70.                     Price = 42.0f
  71.                 },
  72.                 autoSave: true
  73.             );
  74.         }
  75.     }
  76. }

唯一的区别是设置 Book 实体的 AuthorId 属性.

执行 DbMigrator 前删除已有图书或数据库. 参阅上面的 数据库 & 数据迁移 小节获取详细信息.

你现在可以运行 .DbMigrator 控制台应用程序, 迁移 数据库 schema 并生成 种子 初始数据.

应用层

我们将修改 BookAppService, 支持作者关系.

数据传输对象

让我们从DTOs开始.

BookDto

打开 Acme.BookStore.Application.Contracts 项目的 Books 文件夹下的 BookDto 类, 添加如下属性:

  1. public Guid AuthorId { get; set; }
  2. public string AuthorName { get; set; }

最终的 BookDto 类应该如下:

  1. using System;
  2. using Volo.Abp.Application.Dtos;
  4. namespace Acme.BookStore.Books
  5. {
  6.     public class BookDto : AuditedEntityDto<Guid>
  7.     {
  8.         public Guid AuthorId { get; set; }
  10.         public string AuthorName { get; set; }
  12.         public string Name { get; set; }
  14.         public BookType Type { get; set; }
  16.         public DateTime PublishDate { get; set; }
  18.         public float Price { get; set; }
  19.     }
  20. }

CreateUpdateBookDto

打开 Acme.BookStore.Application.Contracts 项目的 Books 文件夹下的 CreateUpdateBookDto 类, 添加 AuthorId 属性:

  1. public Guid AuthorId { get; set; }

AuthorLookupDto

在 Acme.BookStore.Application.Contracts 项目的 Books 文件夹下新建一个类 AuthorLookupDto:

  1. using System;
  2. using Volo.Abp.Application.Dtos;
  4. namespace Acme.BookStore.Books
  5. {
  6.     public class AuthorLookupDto : EntityDto<Guid>
  7.     {
  8.         public string Name { get; set; }
  9.     }
  10. }

它会被一个将要添加到 IBookAppService 的新方法使用.

IBookAppService

打开 Acme.BookStore.Application.Contracts 项目的 Books 文件夹下的 IBookAppService 接口, 添加一个名为 GetAuthorLookupAsync 的新方法:

  1. using System;
  2. using System.Threading.Tasks;
  3. using Volo.Abp.Application.Dtos;
  4. using Volo.Abp.Application.Services;
  6. namespace Acme.BookStore.Books
  7. {
  8.     public interface IBookAppService :
  9.         ICrudAppService< //Defines CRUD methods
  10.             BookDto, //Used to show books
  11.             Guid, //Primary key of the book entity
  12.             PagedAndSortedResultRequestDto, //Used for paging/sorting
  13.             CreateUpdateBookDto> //Used to create/update a book
  14.     {
  15.         // ADD the NEW METHOD
  16.         Task<ListResultDto<AuthorLookupDto>> GetAuthorLookupAsync();
  17.     }
  18. }

这个新方法将被UI用来获取作者列表, 填充一个下拉框. 使用这个下拉框选择图书作者.

BookAppService

打开 Acme.BookStore.Application 项目的 Books 文件夹下的 BookAppService 类, 更新为以下代码:

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Linq.Dynamic.Core;
  5. using System.Threading.Tasks;
  6. using Acme.BookStore.Authors;
  7. using Acme.BookStore.Permissions;
  8. using Microsoft.AspNetCore.Authorization;
  9. using Volo.Abp.Application.Dtos;
  10. using Volo.Abp.Application.Services;
  11. using Volo.Abp.Domain.Entities;
  12. using Volo.Abp.Domain.Repositories;
  14. namespace Acme.BookStore.Books
  15. {
  16.     [Authorize(BookStorePermissions.Books.Default)]
  17.     public class BookAppService :
  18.         CrudAppService<
  19.             Book, //The Book entity
  20.             BookDto, //Used to show books
  21.             Guid, //Primary key of the book entity
  22.             PagedAndSortedResultRequestDto, //Used for paging/sorting
  23.             CreateUpdateBookDto>, //Used to create/update a book
  24.         IBookAppService //implement the IBookAppService
  25.     {
  26.         private readonly IAuthorRepository _authorRepository;
  28.         public BookAppService(
  29.             IRepository<Book, Guid> repository,
  30.             IAuthorRepository authorRepository)
  31.             : base(repository)
  32.         {
  33.             _authorRepository = authorRepository;
  34.             GetPolicyName = BookStorePermissions.Books.Default;
  35.             GetListPolicyName = BookStorePermissions.Books.Default;
  36.             CreatePolicyName = BookStorePermissions.Books.Create;
  37.             UpdatePolicyName = BookStorePermissions.Books.Edit;
  38.             DeletePolicyName = BookStorePermissions.Books.Create;
  39.         }
  41.         public override async Task<BookDto> GetAsync(Guid id)
  42.         {
  43.             //Get the IQueryable<Book> from the repository
  44.             var queryable = await Repository.GetQueryableAsync();
  46.             //Prepare a query to join books and authors
  47.             var query = from book in queryable
  48.                 join author in await _authorRepository.GetQueryableAsync() on book.AuthorId equals author.Id
  49.                 where book.Id == id
  50.                 select new { book, author };
  52.             //Execute the query and get the book with author
  53.             var queryResult = await AsyncExecuter.FirstOrDefaultAsync(query);
  54.             if (queryResult == null)
  55.             {
  56.                 throw new EntityNotFoundException(typeof(Book), id);
  57.             }
  59.             var bookDto = ObjectMapper.Map<Book, BookDto>(queryResult.book);
  60.             bookDto.AuthorName = queryResult.author.Name;
  61.             return bookDto;
  62.         }
  64.         public override async Task<PagedResultDto<BookDto>> GetListAsync(PagedAndSortedResultRequestDto input)
  65.         {
  66.             //Get the IQueryable<Book> from the repository
  67.             var queryable = await Repository.GetQueryableAsync();
  69.             //Prepare a query to join books and authors
  70.             var query = from book in queryable
  71.                 join author in await _authorRepository.GetQueryableAsync() on book.AuthorId equals author.Id
  72.                 select new {book, author};
  74.             //Paging
  75.             query = query
  76.                 .OrderBy(NormalizeSorting(input.Sorting))
  77.                 .Skip(input.SkipCount)
  78.                 .Take(input.MaxResultCount);
  80.             //Execute the query and get a list
  81.             var queryResult = await AsyncExecuter.ToListAsync(query);
  83.             //Convert the query result to a list of BookDto objects
  84.             var bookDtos = queryResult.Select(x =>
  85.             {
  86.                 var bookDto = ObjectMapper.Map<Book, BookDto>(x.book);
  87.                 bookDto.AuthorName = x.author.Name;
  88.                 return bookDto;
  89.             }).ToList();
  91.             //Get the total count with another query
  92.             var totalCount = await Repository.GetCountAsync();
  94.             return new PagedResultDto<BookDto>(
  95.                 totalCount,
  96.                 bookDtos
  97.             );
  98.         }
  100.         public async Task<ListResultDto<AuthorLookupDto>> GetAuthorLookupAsync()
  101.         {
  102.             var authors = await _authorRepository.GetListAsync();
  104.             return new ListResultDto<AuthorLookupDto>(
  105.                 ObjectMapper.Map<List<Author>, List<AuthorLookupDto>>(authors)
  106.             );
  107.         }
  109.         private static string NormalizeSorting(string sorting)
  110.         {
  111.             if (sorting.IsNullOrEmpty())
  112.             {
  113.                 return $"book.{nameof(Book.Name)}";
  114.             }
  116.             if (sorting.Contains("authorName", StringComparison.OrdinalIgnoreCase))
  117.             {
  118.                 return sorting.Replace(
  119.                     "authorName",
  120.                     "author.Name",
  121.                     StringComparison.OrdinalIgnoreCase
  122.                 );
  123.             }
  125.             return $"book.{sorting}";
  126.         }
  127.     }
  128. }

我们做了以下修改:

  • 给所有新建/覆写的方法增加 [Authorize(BookStorePermissions.Books.Default)] 进行授权(当授权特性应用于类时, 它对这个类的所有方法有效).
  • 注入 IAuthorRepository, 从作者中查询.
  • 覆写基类 CrudAppService 的 GetAsync 方法. 这个方法根据给定的 id 返回单一 BookDto 对象.
    • 使用一个简单的LINQ表达式关联图书和作者, 根据给定的图书id查询, 查询结果同时包含图书和作者.
    • 使用 AsyncExecuter.FirstOrDefaultAsync(...) 执行查询并得到一个结果. 这是一种无需依赖database provider API, 使用异步LINQ扩展的方法. 参阅 repository文档以理解我们为什么使用它.
    • 如果请求的图书在数据库中不存在, 抛出一个 EntityNotFoundException, 这会导致一个 HTTP 404 (not found) 状态码.
    • 最后, 使用 ObjectMapper创建一个 BookDto 对象, 然后手工给 AuthorName 赋值.
  • 覆写 CrudAppService 基类的 GetListAsync 方法, 返回图书列表. 逻辑与前一个方法类似, 所以很容易理解.
  • 新建一个方法: GetAuthorLookupAsync. 这个方法只是简单地获取所有作者. UI使用这个方法填充一个下拉框, 当编辑图书时用来选择作者.

对象到对象映射映射

引入 AuthorLookupDto 类, 在 GetAuthorLookupAsync 方法中使用对象映射. 所以, 我们需要在 Acme.BookStore.Application 项目的 BookStoreApplicationAutoMapperProfile.cs 文件中加入一个新的映射定义.

  1. CreateMap<Author, AuthorLookupDto>();

单元测试

因为修改了 AuthorAppService, 一些单元测试失败了. 打开 Acme.BookStore.Application.Tests 项目的 Books 目录中的 BookAppService_Tests, 修改成以下代码:

  1. using System;
  2. using System.Linq;
  3. using System.Threading.Tasks;
  4. using Acme.BookStore.Authors;
  5. using Shouldly;
  6. using Volo.Abp.Application.Dtos;
  7. using Volo.Abp.Validation;
  8. using Xunit;
  10. namespace Acme.BookStore.Books
  11. { 
  12.     public class BookAppService_Tests : BookStoreApplicationTestBase
  13.     {
  14.         private readonly IBookAppService _bookAppService;
  15.         private readonly IAuthorAppService _authorAppService;
  17.         public BookAppService_Tests()
  18.         {
  19.             _bookAppService = GetRequiredService<IBookAppService>();
  20.             _authorAppService = GetRequiredService<IAuthorAppService>();
  21.         }
  23.         [Fact]
  24.         public async Task Should_Get_List_Of_Books()
  25.         {
  26.             //Act
  27.             var result = await _bookAppService.GetListAsync(
  28.                 new PagedAndSortedResultRequestDto()
  29.             );
  31.             //Assert
  32.             result.TotalCount.ShouldBeGreaterThan(0);
  33.             result.Items.ShouldContain(b => b.Name == "1984" &&
  34.                                        b.AuthorName == "George Orwell");
  35.         }
  37.         [Fact]
  38.         public async Task Should_Create_A_Valid_Book()
  39.         {
  40.             var authors = await _authorAppService.GetListAsync(new GetAuthorListDto());
  41.             var firstAuthor = authors.Items.First();
  43.             //Act
  44.             var result = await _bookAppService.CreateAsync(
  45.                 new CreateUpdateBookDto
  46.                 {
  47.                     AuthorId = firstAuthor.Id,
  48.                     Name = "New test book 42",
  49.                     Price = 10,
  50.                     PublishDate = System.DateTime.Now,
  51.                     Type = BookType.ScienceFiction
  52.                 }
  53.             );
  55.             //Assert
  56.             result.Id.ShouldNotBe(Guid.Empty);
  57.             result.Name.ShouldBe("New test book 42");
  58.         }
  60.         [Fact]
  61.         public async Task Should_Not_Create_A_Book_Without_Name()
  62.         {
  63.             var exception = await Assert.ThrowsAsync<AbpValidationException>(async () =>
  64.             {
  65.                 await _bookAppService.CreateAsync(
  66.                     new CreateUpdateBookDto
  67.                     {
  68.                         Name = "",
  69.                         Price = 10,
  70.                         PublishDate = DateTime.Now,
  71.                         Type = BookType.ScienceFiction
  72.                     }
  73.                 );
  74.             });
  76.             exception.ValidationErrors
  77.                 .ShouldContain(err => err.MemberNames.Any(m => m == "Name"));
  78.         }
  79.     }
  80. }
  • 修改 Should_Get_List_Of_Books 中的断言条件, 从 b => b.Name == "1984" 修改为 b => b.Name == "1984" && b.AuthorName == "George Orwell", 检查用户名是否被填充.
  • 修改 Should_Create_A_Valid_Book 方法, 当新建图书时, 设置 AuthorId, 因为它现在是不可为空的了.

用户页面

图书列表

图书列表页面的修改很小. 打开 Acme.BookStore.Web 项目上的 Pages/Books/Index.js, 在 name and type 列之间加入如下列定义:

  1. ...
  2. {
  3.     title: l('Name'),
  4.     data: "name"
  5. },
  7. // ADDED the NEW AUTHOR NAME COLUMN
  8. {
  9.     title: l('Author'),
  10.     data: "authorName"
  11. },
  13. {
  14.     title: l('Type'),
  15.     data: "type",
  16.     render: function (data) {
  17.         return l('Enum:BookType:' + data);
  18.     }
  19. },
  20. ...

运行应用程序, 你会在表格中看到 Author 列:

bookstore-added-author-to-book-list

新建模态窗口

打开 Acme.BookStore.Web 项目中的 Pages/Books/CreateModal.cshtml.cs, 修改文件内容为:

  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.ComponentModel.DataAnnotations;
  5. using System.Linq;
  6. using System.Threading.Tasks;
  7. using Acme.BookStore.Books;
  8. using Microsoft.AspNetCore.Mvc;
  9. using Microsoft.AspNetCore.Mvc.Rendering;
  10. using Volo.Abp.AspNetCore.Mvc.UI.Bootstrap.TagHelpers.Form;
  12. namespace Acme.BookStore.Web.Pages.Books
  13. {
  14.     public class CreateModalModel : BookStorePageModel
  15.     {
  16.         [BindProperty]
  17.         public CreateBookViewModel Book { get; set; }
  19.         public List<SelectListItem> Authors { get; set; }
  21.         private readonly IBookAppService _bookAppService;
  23.         public CreateModalModel(
  24.             IBookAppService bookAppService)
  25.         {
  26.             _bookAppService = bookAppService;
  27.         }
  29.         public async Task OnGetAsync()
  30.         {
  31.             Book = new CreateBookViewModel();
  33.             var authorLookup = await _bookAppService.GetAuthorLookupAsync();
  34.             Authors = authorLookup.Items
  35.                 .Select(x => new SelectListItem(x.Name, x.Id.ToString()))
  36.                 .ToList();
  37.         }
  39.         public async Task<IActionResult> OnPostAsync()
  40.         {
  41.             await _bookAppService.CreateAsync(
  42.                 ObjectMapper.Map<CreateBookViewModel, CreateUpdateBookDto>(Book)
  43.                 );
  44.             return NoContent();
  45.         }
  47.         public class CreateBookViewModel
  48.         {
  49.             [SelectItems(nameof(Authors))]
  50.             [DisplayName("Author")]
  51.             public Guid AuthorId { get; set; }
  53.             [Required]
  54.             [StringLength(128)]
  55.             public string Name { get; set; }
  57.             [Required]
  58.             public BookType Type { get; set; } = BookType.Undefined;
  60.             [Required]
  61.             [DataType(DataType.Date)]
  62.             public DateTime PublishDate { get; set; } = DateTime.Now;
  64.             [Required]
  65.             public float Price { get; set; }
  66.         }
  67.     }
  68. }
  • 将 Book 属性的类型从 CreateUpdateBookDto 修改为这个文件中新定义的 CreateBookViewModel 类. 这个修改的主要动机是根据UI需求自定义模型类. 我们不希望在 CreateUpdateBookDto 类中使用UI相关的 [SelectItems(nameof(Authors))] 和 [DisplayName("Author")] 特性.
  • 新增 Authors 属性, 在 OnGetAsync 方法中使用前面定义的 IBookAppService.GetAuthorLookupAsync 方法填充它.
  • 修改 OnPostAsync 方法, 映射 CreateBookViewModel 对象到 CreateUpdateBookDto 对象, 因为 IBookAppService.CreateAsync 需要一个这种类型的参数.

编辑模态窗口

打开 Acme.BookStore.Web 项目中的 Pages/Books/EditModal.cshtml.cs, 修改文件内容为:

  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.ComponentModel.DataAnnotations;
  5. using System.Linq;
  6. using System.Threading.Tasks;
  7. using Acme.BookStore.Books;
  8. using Microsoft.AspNetCore.Mvc;
  9. using Microsoft.AspNetCore.Mvc.Rendering;
  10. using Volo.Abp.AspNetCore.Mvc.UI.Bootstrap.TagHelpers.Form;
  12. namespace Acme.BookStore.Web.Pages.Books
  13. {
  14.     public class EditModalModel : BookStorePageModel
  15.     {
  16.         [BindProperty]
  17.         public EditBookViewModel Book { get; set; }
  19.         public List<SelectListItem> Authors { get; set; }
  21.         private readonly IBookAppService _bookAppService;
  23.         public EditModalModel(IBookAppService bookAppService)
  24.         {
  25.             _bookAppService = bookAppService;
  26.         }
  28.         public async Task OnGetAsync(Guid id)
  29.         {
  30.             var bookDto = await _bookAppService.GetAsync(id);
  31.             Book = ObjectMapper.Map<BookDto, EditBookViewModel>(bookDto);
  33.             var authorLookup = await _bookAppService.GetAuthorLookupAsync();
  34.             Authors = authorLookup.Items
  35.                 .Select(x => new SelectListItem(x.Name, x.Id.ToString()))
  36.                 .ToList();
  37.         }
  39.         public async Task<IActionResult> OnPostAsync()
  40.         {
  41.             await _bookAppService.UpdateAsync(
  42.                 Book.Id,
  43.                 ObjectMapper.Map<EditBookViewModel, CreateUpdateBookDto>(Book)
  44.             );
  46.             return NoContent();
  47.         }
  49.         public class EditBookViewModel
  50.         {
  51.             [HiddenInput]
  52.             public Guid Id { get; set; }
  54.             [SelectItems(nameof(Authors))]
  55.             [DisplayName("Author")]
  56.             public Guid AuthorId { get; set; }
  58.             [Required]
  59.             [StringLength(128)]
  60.             public string Name { get; set; }
  62.             [Required]
  63.             public BookType Type { get; set; } = BookType.Undefined;
  65.             [Required]
  66.             [DataType(DataType.Date)]
  67.             public DateTime PublishDate { get; set; } = DateTime.Now;
  69.             [Required]
  70.             public float Price { get; set; }
  71.         }
  72.     }
  73. }
  • 将 Book 属性的类型从 CreateUpdateBookDto 修改为这个文件中新定义的 EditBookViewModel 类, 和我们前面所做的创建模型的修改一样.
  • 移动新类 EditBookViewModel 的 Id 属性.
  • 新增 Authors 属性, 在 OnGetAsync 方法中使用前面定义的 IBookAppService.GetAuthorLookupAsync 方法填充它.
  • 修改 OnPostAsync 方法, 映射 EditBookViewModel 对象到 CreateUpdateBookDto 对象, 因为 IBookAppService.UpdateAsync 需要一个这种类型的参数.

这些修改需要对 EditModal.cshtml 进行一些小修改. 移除 <abp-input asp-for="Id" /> 标签, 因为我们不再需要它了 (因为它被移动到 EditBookViewModel 中了). EditModal.cshtml 的最终内容应为:

  1. @page
  2. @using Acme.BookStore.Localization
  3. @using Acme.BookStore.Web.Pages.Books
  4. @using Microsoft.Extensions.Localization
  5. @using Volo.Abp.AspNetCore.Mvc.UI.Bootstrap.TagHelpers.Modal
  6. @model EditModalModel
  7. @inject IStringLocalizer<BookStoreResource> L
  8. @{
  9.     Layout = null;
  10. }
  11. <abp-dynamic-form abp-model="Book" asp-page="/Books/EditModal">
  12.     <abp-modal>
  13.         <abp-modal-header title="@L["Update"].Value"></abp-modal-header>
  14.         <abp-modal-body>
  15.             <abp-form-content />
  16.         </abp-modal-body>
  17.         <abp-modal-footer buttons="@(AbpModalButtons.Cancel|AbpModalButtons.Save)"></abp-modal-footer>
  18.     </abp-modal>
  19. </abp-dynamic-form>

对象到对象映射配置

以下修改需要定义一些对象到对象映射. 打开 Acme.BookStore.Web 项目中的 BookStoreWebAutoMapperProfile.cs, 在构造函数中添加下列映射定义:

  1. CreateMap<Pages.Books.CreateModalModel.CreateBookViewModel, CreateUpdateBookDto>();
  2. CreateMap<BookDto, Pages.Books.EditModalModel.EditBookViewModel>();
  3. CreateMap<Pages.Books.EditModalModel.EditBookViewModel, CreateUpdateBookDto>();

你可以运行应用程序, 尝试新建或更新一本书. 你将在新建/更新表单上看到一个下拉框, 使用它指定图书的作者:

bookstore-added-authors-to-modals