/// <summary>
/// <para>TodoItemのデータを更新します.</para>
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public TodoItemUpdateResultModel UpdateTodoItem(UpdateTodoItemModel model)
{
UpdateResult result = UpdateResult.Success;
ValidationErrors validErrors = ValidationErrors.Create();
try
{
var todoItem = DbContext.TodoItems.FirstOrDefault(e => e.Id == model.Id);
if (todoItem == null)
{
result = UpdateResult.NotExist;
}
else
{
model.ReflectTodoItem(todoItem);
DbContext.SaveChanges();
}
}
catch (TemplateValidationException e)
{
result = UpdateResult.ValidError;
validErrors = e.ValidErrors;
}
catch
{
result = UpdateResult.Failed;
}
return(TodoItemUpdateResultModel.Create(model, result, validErrors));
}
public async Task <UpdateTodoItemResponseModel> UpdateAsync(Guid id, UpdateTodoItemModel updateTodoItemModel)
{
var todoList = await _todoListRepository.GetFirstAsync(tl => tl.Id == updateTodoItemModel.TodoListId);
if (todoList == null)
{
throw new NotFoundException("List does not exist anymore");
}
var todoItem = await _todoItemRepository.GetFirstAsync(ti => ti.Id == id);
if (todoItem == null)
{
throw new NotFoundException("Todo item does not exist anymore");
}
todoItem.Title = updateTodoItemModel.Title;
todoItem.Body = updateTodoItemModel.Body;
todoItem.IsDone = updateTodoItemModel.IsDone;
return(new UpdateTodoItemResponseModel
{
Id = (await _todoItemRepository.UpdateAsync(todoItem)).Id
});
}
public async Task <UpdateTodoItemResponseModel> UpdateAsync(Guid id, UpdateTodoItemModel updateTodoItemModel,
CancellationToken cancellationToken = default)
{
var todoItem = await _todoItemRepository.GetFirstAsync(ti => ti.Id == id);
_mapper.Map(updateTodoItemModel, todoItem);
return(new UpdateTodoItemResponseModel
{
Id = (await _todoItemRepository.UpdateAsync(todoItem)).Id
});
}
// GET: TodoItems/Edit/5
public async Task <IActionResult> Edit(Guid id)
{
var todoItem = await this.todoItemService.GetTodoItemAsync(id);
if (todoItem == null)
{
return(NotFound());
}
var model = new UpdateTodoItemModel(todoItem.Id, todoItem.Description, todoItem.Title);
return(View(model));
}
public void Validator_Should_Have_Error_When_Body_Is_Empty()
{
// Arrange
var updateTodoItemModel = new UpdateTodoItemModel {
Body = string.Empty
};
// Act
var result = _sut.TestValidate(updateTodoItemModel);
// Assert
result.ShouldHaveValidationErrorFor(uti => uti.Body);
}
public async Task <IActionResult> Edit(Guid id, [Bind("Id, Description, Title")] UpdateTodoItemModel model)
{
if (id != model.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
await this.todoItemService.UpdateTodoItemAsync(id, model.Title, model.Description, this.User.GetUserId());
}
return(View(model));
}
public async Task <IActionResult> UpdateAsync(long id, [FromBody] UpdateTodoItemModel updateTodoItemModel)
{
var updateTodoItemInfo = new UpdateTodoItemInfo
{
Id = id,
IsComplete = updateTodoItemModel.IsComplete,
Name = updateTodoItemModel.Name,
User = User
};
await todoService.UpdateAsync(updateTodoItemInfo).ConfigureAwait(false);
return(NoContent());
}
public async Task <IActionResult> UpdateAsync(long id, [FromBody] UpdateTodoItemModel updateTodoItemModel)
{
var updateTodoItemInfo = new UpdateTodoItemInfo
{
Id = id,
IsComplete = updateTodoItemModel.IsComplete,
Name = updateTodoItemModel.Name,
Owner = User
};
await updateTodoItemFlow.ExecuteAsync(updateTodoItemInfo, User);
return(NoContent());
}
public async Task UpdateAsync_UsingNoJsonWebToken_ReturnsUnauthorizedHttpStatusCode()
{
// Arrange
using HttpClient httpClient = webApplicationFactory.CreateClient();
long?id = int.MaxValue;
var updateTodoItemModel = new UpdateTodoItemModel();
// Act
HttpResponseMessage response = await httpClient.PutAsJsonAsync($"{BaseUrl}/{id}", updateTodoItemModel);
// Assert
using (new AssertionScope())
{
response.IsSuccessStatusCode.Should().BeFalse(BecauseCurrentRequestHasNoJwt);
response.StatusCode.Should().Be(HttpStatusCode.Unauthorized, BecauseCurrentRequestHasNoJwt);
}
}
public async Task UpdateAsync_UsingNewlyCreatedTodoItem_MustSucceed()
{
// Arrange
using HttpClient httpClient =
await testWebApplicationFactory.CreateClientWithJwtToken().ConfigureAwait(false);
long?id = null;
try
{
string name = $"it--{nameof(UpdateAsync_UsingNewlyCreatedTodoItem_MustSucceed)}--{Guid.NewGuid():N}";
bool isComplete = DateTime.UtcNow.Ticks % 2 == 0;
var newTodoItemInfo = new NewTodoItemModel
{
Name = name,
IsComplete = isComplete
};
HttpResponseMessage response =
await httpClient.PostAsJsonAsync(BaseUrl, newTodoItemInfo).ConfigureAwait(false);
response.IsSuccessStatusCode.Should().BeTrue("a new entity has been created");
id = await response.Content.ReadAsAsync <long>().ConfigureAwait(false);
var updateTodoItemModel = new UpdateTodoItemModel
{
IsComplete = !newTodoItemInfo.IsComplete,
Name = $"CHANGED--{newTodoItemInfo.Name}"
};
// Act
response = await httpClient.PutAsJsonAsync($"{BaseUrl}/{id}", updateTodoItemModel)
.ConfigureAwait(false);
// Assert
response.IsSuccessStatusCode.Should().BeTrue("an entity has been previously created");
response.StatusCode.Should().Be(HttpStatusCode.NoContent);
response = await httpClient.GetAsync($"{BaseUrl}/{id}").ConfigureAwait(false);
response.IsSuccessStatusCode.Should().BeTrue("an entity has been previously update");
response.StatusCode.Should().Be(HttpStatusCode.OK);
TodoItemModel todoItemModel =
await response.Content.ReadAsAsync <TodoItemModel>().ConfigureAwait(false);
todoItemModel.Should().NotBeNull("an entity has been previously created");
todoItemModel.Id.Should().Be(id);
todoItemModel.IsComplete.Should().Be(updateTodoItemModel.IsComplete.Value);
todoItemModel.Name.Should().Be(updateTodoItemModel.Name);
}
finally
{
if (id.HasValue)
{
HttpResponseMessage response =
await httpClient.DeleteAsync($"{BaseUrl}/{id}").ConfigureAwait(false);
response.IsSuccessStatusCode.Should().BeTrue("cleanup must succeed");
}
}
}
public async Task <IActionResult> UpdateAsync(Guid id, UpdateTodoItemModel updateTodoItemModel)
{
return(Ok(ApiResult <UpdateTodoItemResponseModel> .Success(
await _todoItemService.UpdateAsync(id, updateTodoItemModel))));
}
