public async Task <ActionResult> Put([FromRoute] int id, [FromBody] BookEditDto bookEditDto)
{
bookEditDto.Id = id;
await _bookService.EditAsync(_mapper.Map <Book>(bookEditDto));
return(Ok(new { message = MessagesResource.SUCCESS_MESSAGE }));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Title,Description,ReleaseDate,Score,AuthorsIds,Authors")] BookEditDto book)
{
if (id != book.Id)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(book));
}
var sameBook = await _bookService.Get(book.Title, book.ReleaseDate);
if (sameBook != null && sameBook.Id != id)
{
ModelState.AddModelError("", $"{book.Title} released {book.ReleaseDate:dd/MM/yyy} already exists");
return(View(book));
}
await _bookService.Update(book);
ViewData["AuthorId"] = AuthorsSelectList(await _authorService.GetAll(), book.AuthorsIds);
return(RedirectToAction(nameof(Index)));
}
protected virtual async Task <BookEditDto> CreateBookAsync(BookEditDto input)
{
//TODO:新增前的逻辑判断，是否允许新增
var entity = ObjectMapper.Map <Book>(input);
entity = await _bookRepository.InsertAsync(entity);
return(entity.MapTo <BookEditDto>());
}
public async void Update_ShouldReturnBadRequest_WhenBookIdIsDifferentThenParameterId()
{
var bookEditDto = new BookEditDto()
{
Id = 1, Name = "Test"
};
var result = await _booksController.Update(2, bookEditDto);
Assert.IsType <BadRequestResult>(result);
}
protected virtual async Task Update(BookEditDto input)
{
//TODO:更新前的逻辑判断，是否允许更新
var entity = await _entityRepository.GetAsync(input.Id.Value);
input.MapTo(entity);
// ObjectMapper.Map(input, entity);
await _entityRepository.UpdateAsync(entity);
}
public async void Update_ShouldReturnBadRequest_WhenModelStateIsInvalid()
{
var bookEditDto = new BookEditDto()
{
Id = 1
};
_booksController.ModelState.AddModelError("Name", "The field name is required");
var result = await _booksController.Update(1, bookEditDto);
Assert.IsType <BadRequestResult>(result);
}
protected virtual async Task Update(BookEditDto input, List <long> tagIds)
{
//TODO:更新前的逻辑判断，是否允许更新
var entity = await _entityRepository.GetAsync(input.Id.Value);
input.MapTo(entity);
// ObjectMapper.Map(input, entity);
await _entityRepository.UpdateAsync(entity);
await _entityManager.CreateBookAndBookTagRelationship(entity.Id, tagIds);
}
protected virtual async Task Update(BookEditDto input, ICollection <long> tagIds)
{
//TODO:更新前的逻辑判断，是否允许更新
var entity = await _bookRepository.GetAsync(input.Id.Value);
// input.MapTo(entity);
//将input属性的值赋值到entity中
ObjectMapper.Map(input, entity);
await _bookManager.UpdateAsync(entity);
await _bookManager.CreateBookAndBookTag(entity.Id, tagIds);
}
public async Task UpdateBookAsync(BookEditDto bookEditDto)
{
Genre genre = await _genreRepository.GetByIdAsync(bookEditDto.GenreId);
if (genre == null)
{
throw new Exception($"Genre with Id: {bookEditDto.GenreId} could not be found");
}
//_bookRepository.UpdateBookByAttach(bookEditDto, genre);
await _bookRepository.UpdateBookAsync(bookEditDto, genre);
await _bookRepository.SaveChangesAsync();
}
protected virtual async Task <BookEditDto> Create(BookEditDto input, List <long> tagIds) //添加参数, List<long> tagIds
{
//TODO:新增前的逻辑判断，是否允许新增
var entity = input.MapTo <Book>();
var entityId = await _entityRepository.InsertAndGetIdAsync(entity);
// 创建关联关系
if (tagIds.Count > 0)
{
await _entityManager.CreateBookAndBookTagRelationship(entityId, tagIds);
}
return(entity.MapTo <BookEditDto>());
}
public async void Update_ShouldCallUpdateFromService_OnlyOnce()
{
var book = CreateBook();
var bookEditDto = new BookEditDto()
{
Id = book.Id, Name = "Test"
};
_mapperMock.Setup(m => m.Map <Book>(It.IsAny <BookEditDto>())).Returns(book);
_bookServiceMock.Setup(c => c.GetById(book.Id)).ReturnsAsync(book);
_bookServiceMock.Setup(c => c.Update(book)).ReturnsAsync(book);
await _booksController.Update(bookEditDto.Id, bookEditDto);
_bookServiceMock.Verify(mock => mock.Update(book), Times.Once);
}
public async void Update_ShouldReturnOk_WhenBookIsUpdatedCorrectly()
{
var book = CreateBook();
var bookEditDto = new BookEditDto()
{
Id = book.Id, Name = "Test"
};
_mapperMock.Setup(m => m.Map <Book>(It.IsAny <BookEditDto>())).Returns(book);
_bookServiceMock.Setup(c => c.GetById(book.Id)).ReturnsAsync(book);
_bookServiceMock.Setup(c => c.Update(book)).ReturnsAsync(book);
var result = await _booksController.Update(bookEditDto.Id, bookEditDto);
Assert.IsType <OkObjectResult>(result);
}
public async Task <IActionResult> Update(int id, BookEditDto bookDto)
{
if (id != bookDto.Id)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
await _bookService.Update(_mapper.Map <Book>(bookDto));
return(Ok(bookDto));
}
protected virtual async Task <BookEditDto> Create(BookEditDto input, ICollection <long> tagIds)
{
//TODO:新增前的逻辑判断，是否允许新增
var entity = ObjectMapper.Map <Book>(input);
//调用领域服务
entity = await _bookManager.CreateAsync(entity);
if (tagIds.Count > 0)
{
await _bookManager.CreateBookAndBookTag(entity.Id, tagIds);
}
var dto = ObjectMapper.Map <BookEditDto>(entity);
return(dto);
}
public async Task SaveAsync(BookEditDto dto)
{
using var tran = Db.BeginTransaction();
// Handle Books
Book book;
if (dto.Id == 0)
{
book = dto.Adapt <Book>();
await Db.InsertAsync(book);
}
else
{
book = await Db.FindAsync <Book>(new { dto.Id });
dto.Adapt(book);
await Db.UpdateAsync(book);
}
// Handle Tags
var existTags = Db.Query <Tag>(
"SELECT * FROM Tag WHERE Name IN @Tags", new { dto.Tags });
var newTags = dto.Tags
.Where(x => !existTags.Any(y => y.Name == x))
.Select(x => new Tag {
Id = IdGen.NewId(), Name = x
}).ToList();
//foreach (var tag in newTags)
//{
// tag.Id = IdGen.NewId();
//}
await Db.InsertBatchAsync(newTags);
// Handle BookTags
var bookTags = existTags.Concat(newTags)
.Select(x => new BookTag {
BookId = book.Id, TagId = x.Id
});
await Db.DeleteAsync <BookTag>(new { BookId = dto.Id });
await Db.InsertBatchAsync(bookTags);
tran.Commit();
}
protected virtual async Task Update(BookEditDto input, List <long> tagIds)
{
//TODO:更新前的逻辑判断，是否允许更新
var entity = await _entityRepository.GetAsync(input.Id.Value);
input.MapTo(entity);
// ObjectMapper.Map(input, entity);
await _entityRepository.UpdateAsync(entity);
// 创建标签关联
if (tagIds != null)
{
// 过滤掉不符合条件的数据
tagIds = tagIds.Where(o => o > 0).ToList();
await _bookAndBookTagRelationshipManager.CreateRelationship(entity.Id, tagIds);
}
}
protected virtual async Task <BookEditDto> Create(BookEditDto input, List <long> tagIds)
{
//TODO:新增前的逻辑判断，是否允许新增
// var entity = ObjectMapper.Map <Book>(input);
var entity = input.MapTo <Book>();
var entityId = await _entityRepository.InsertAndGetIdAsync(entity);
// 创建标签关联
if (tagIds != null)
{
// 过滤掉不符合条件的数据
tagIds = tagIds.Where(o => o > 0).ToList();
await _bookAndBookTagRelationshipManager.CreateRelationship(entity.Id, tagIds);
}
return(entity.MapTo <BookEditDto>());
}
public async Task <GetBookForEditOutput> GetForEdit(NullableIdDto <long> input)
{
var output = new GetBookForEditOutput();
BookEditDto editDto;
if (input.Id.HasValue)
{
var entity = await _entityRepository.GetAsync(input.Id.Value);
editDto = entity.MapTo <BookEditDto>();
//bookEditDto = ObjectMapper.Map<List<bookEditDto>>(entity);
}
else
{
editDto = new BookEditDto();
}
output.Book = editDto;
return(output);
}
public async Task <GetBookForEditOutput> GetForEdit(NullableIdDto <long> input)
{
var output = new GetBookForEditOutput();
BookEditDto editDto;
// 已选中的标签Id
List <long> bookTagIds = null;
// 所有标签
var allbookTag = (await _bookTagManager.GetAll()).MapTo <List <BookTagSelectListDto> >();
if (input.Id.HasValue)
{
var entity = await _entityRepository.GetAsync(input.Id.Value);
editDto = entity.MapTo <BookEditDto>();
bookTagIds = (await _bookAndBookTagRelationshipManager.GetByBookId(input.Id.Value))
.Select(o => o.BookTagId)
.ToList();
foreach (var bookTag in allbookTag)
{
if (bookTagIds.Exists(o => o == bookTag.Id))
{
bookTag.IsSelected = true;
}
}
}
else
{
editDto = new BookEditDto();
}
output.Book = editDto;
output.BookTags = allbookTag;
return(output);
}
public async Task <GetBookForEditOutput> GetForEdit(NullableIdDto <long> input)
{
var output = new GetBookForEditOutput();
BookEditDto editDto;
List <long> tagIds = null;
//获取所有标签
//哪些是选择了的，哪些是没有选择的
var booktagListDtos = (await _bookTagManager.GetAll()).MapTo <List <BookTagSelectListDto> >();
if (input.Id.HasValue)
{
var entity = await _entityRepository.GetAsync(input.Id.Value);
editDto = entity.MapTo <BookEditDto>();
//bookEditDto = ObjectMapper.Map<List<bookEditDto>>(entity);
tagIds = (await _entityManager.GetTagsByBookId(entity.Id)).Select(a => a.BookTagId).ToList();
foreach (var bookTag in booktagListDtos)
{
if (tagIds.Exists(a => a == bookTag.Id))
{
bookTag.IsSelected = true;
}
}
}
else
{
editDto = new BookEditDto();
}
output.Book = editDto;
output.BookTags = booktagListDtos;
return(output);
}
public async Task Update(BookEditDto book)
{
var bookDb = await _bookRepo
.GetAll()
.FirstOrDefaultAsync(b => b.Id == book.Id);
_mapper.Map(book, bookDb);
_bookRepo.Update(bookDb);
await _bookRepo.SaveChangesAsync();
var oldBookAuthors = await _authorBookRepo
.GetAll()
.Where(ab => ab.BookId == book.Id)
.ToListAsync();
foreach (var ab in oldBookAuthors)
{
_authorBookRepo.Delete(ab);
}
await _authorBookRepo.SaveChangesAsync();
var newBookAuthors = book
.AuthorsIds
.Select(aId => new AuthorBook {
AuthorId = aId, BookId = bookDb.Id
});
foreach (var ab in newBookAuthors)
{
await _authorBookRepo.CreateAsync(ab);
}
await _authorBookRepo.SaveChangesAsync();
}
public async Task <GetBookForEditOutput> GetForEdit(NullableIdDto <long> input)
{
var output = new GetBookForEditOutput();
BookEditDto editDto;
List <long> allSelectedTagIds = null;
var allBookTags = ObjectMapper
.Map <List <BookTagSelectedListDto> >((await _bookTagManager.GetAllBookTags()));
if (input.Id.HasValue)
{
var entity = await _bookRepository.GetAsync(input.Id.Value);
editDto = ObjectMapper.Map <BookEditDto>(entity);
allSelectedTagIds = (await _bookManager.GetBookTagsByBookId(editDto.Id)).Select(b => b.TagId).ToList();
if (allSelectedTagIds.Count > 0)
{
foreach (var bookTag in allBookTags)
{
if (allSelectedTagIds.Any(b => b == bookTag.Id))
{
bookTag.IsSelected = true;
}
}
}
}
else
{
editDto = new BookEditDto();
}
output.Book = editDto;
output.BookTags = allBookTags;
return(output);
}
public Task Save(BookEditDto dto)
{
return(_bookService.SaveAsync(dto));
}
