// POST api/Todo
public HttpResponseMessage PostTodoItem(TodoItemDto todoItemDto)
{
if (!ModelState.IsValid)
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
TodoList todoList = db.TodoLists.Find(todoItemDto.TodoListId);
if (todoList == null)
{
return Request.CreateResponse(HttpStatusCode.NotFound);
}
if (todoList.UserId != User.Identity.Name)
{
// 사용자에게 속하지 않은 레코드를 추가하려고 시도합니다.
return Request.CreateResponse(HttpStatusCode.Unauthorized);
}
TodoItem todoItem = todoItemDto.ToEntity();
// JSON 직렬화가 이루어질 때 루프 참조 예외 발생을 방지하려면 분리해야 합니다.
db.Entry(todoList).State = EntityState.Detached;
db.TodoItems.Add(todoItem);
db.SaveChanges();
todoItemDto.TodoItemId = todoItem.TodoItemId;
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, todoItemDto);
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = todoItemDto.TodoItemId }));
return response;
}
// POST api/Todo
public HttpResponseMessage PostTodoItem(TodoItemDto todoItemDto)
{
if (!ModelState.IsValid)
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
TodoList todoList = db.TodoLists.Find(todoItemDto.TodoListId);
if (todoList == null)
{
return Request.CreateResponse(HttpStatusCode.NotFound);
}
if (todoList.UserId != User.Identity.Name)
{
// Trying to add a record that does not belong to the user
return Request.CreateResponse(HttpStatusCode.Unauthorized);
}
TodoItem todoItem = todoItemDto.ToEntity();
// Need to detach to avoid loop reference exception during JSON serialization
db.Entry(todoList).State = EntityState.Detached;
db.TodoItems.Add(todoItem);
db.SaveChanges();
todoItemDto.TodoItemId = todoItem.TodoItemId;
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, todoItemDto);
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = todoItemDto.TodoItemId }));
return response;
}
// DELETE api/Todo/5
public HttpResponseMessage DeleteTodoItem(int id)
{
TodoItem todoItem = db.TodoItems.Find(id);
if (todoItem == null)
{
return Request.CreateResponse(HttpStatusCode.NotFound);
}
if (db.Entry(todoItem.TodoList).Entity.UserId != User.Identity.Name)
{
// Trying to delete a record that does not belong to the user
return Request.CreateResponse(HttpStatusCode.Unauthorized);
}
TodoItemDto todoItemDto = new TodoItemDto(todoItem);
db.TodoItems.Remove(todoItem);
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
return Request.CreateResponse(HttpStatusCode.InternalServerError);
}
return Request.CreateResponse(HttpStatusCode.OK, todoItemDto);
}
// PUT api/Todo/5
public HttpResponseMessage PutTodoItem(int id, TodoItemDto todoItemDto)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
if (id != todoItemDto.TodoItemId)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
TodoItem todoItem = todoItemDto.ToEntity();
TodoList todoList = db.TodoLists.Find(todoItem.TodoListId);
if (todoList == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
if (todoList.UserId != User.Identity.Name)
{
// Trying to modify a record that does not belong to the user
return(Request.CreateResponse(HttpStatusCode.Unauthorized));
}
// Need to detach to avoid duplicate primary key exception when SaveChanges is called
db.Entry(todoList).State = EntityState.Detached;
db.Entry(todoItem).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
// PUT api/Todo/5
public HttpResponseMessage PutTodoItem(int id, TodoItemDto todoItemDto)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
if (id != todoItemDto.TodoItemId)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
TodoItem todoItem = todoItemDto.ToEntity();
TodoList todoList = db.TodoLists.Find(todoItem.TodoListId);
if (todoList == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
if (todoList.UserId != User.Identity.Name)
{
// 正在尝试修改不属于用户的记录
return(Request.CreateResponse(HttpStatusCode.Unauthorized));
}
// 需要分离，以避免在调用 SaveChanges 时发生重复主键异常
db.Entry(todoList).State = EntityState.Detached;
db.Entry(todoItem).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
// PUT api/Todo/5
public HttpResponseMessage PutTodoItem(int id, TodoItemDto todoItemDto)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
if (id != todoItemDto.TodoItemId)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
TodoItem todoItem = todoItemDto.ToEntity();
TodoList todoList = db.TodoLists.Find(todoItem.TodoListId);
if (todoList == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
if (todoList.UserId != User.Identity.Name)
{
// Intentando modificar un registro que no pertenece al usuario
return(Request.CreateResponse(HttpStatusCode.Unauthorized));
}
// Se debe desasociar para evitar que se produzca una excepción de clave primaria duplicada cuando se llame a SaveChanges
db.Entry(todoList).State = EntityState.Detached;
db.Entry(todoItem).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
public async Task <ActionResult <TodoItem> > CreateItemAsync(TodoItemDto todoItemDto)
{
var todoItem = new TodoItem
{
IsComplete = todoItemDto.IsComplete,
Name = todoItemDto.Name
//,Id= todoItemDto.Id
};
await _service.CreateItemAsync(todoItem);
var items =
(await _service.GetItemsAsync())
.Select(x => x.ToDto());
if (items.ToList().Count > 0)
{
}
return(CreatedAtAction(nameof(GetTodoItem), new { id = todoItem.Id }, todoItem.ToDto()));
}
public IActionResult Post([FromBody] TodoItemDto todoItemDto)
{
try
{
var command = new CreateTodoItemCommand(todoItemDto.Description, todoItemDto.IsCompleted);
command.Validate();
if (command.Invalid)
{
return(Ok(command));
}
_todoItemCommandHandler.Handle(command);
return(Ok());
}
catch (Exception e)
{
return(BadRequest(e));
}
}
public async Task UpdateTodoItem(TodoItemDto itemDto)
{
try
{
TodoItem item = await GetItem(itemDto.Id);
if (item == null)
{
throw new Exception($"Item con {itemDto.Id} not found.");
}
item.Name = itemDto.Name;
item.IsComplete = itemDto.IsComplete;
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
}
// PUT api/Todo/5
public HttpResponseMessage PutTodoItem(int id, TodoItemDto todoItemDto)
{
if (!ModelState.IsValid)
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
if (id != todoItemDto.TodoItemId)
{
return Request.CreateResponse(HttpStatusCode.BadRequest);
}
TodoItem todoItem = todoItemDto.ToEntity();
TodoList todoList = db.TodoLists.Find(todoItem.TodoListId);
if (todoList == null)
{
return Request.CreateResponse(HttpStatusCode.NotFound);
}
if (todoList.UserId != User.Identity.Name)
{
// Trying to modify a record that does not belong to the user
return Request.CreateResponse(HttpStatusCode.Unauthorized);
}
// Need to detach to avoid duplicate primary key exception when SaveChanges is called
db.Entry(todoList).State = EntityState.Detached;
db.Entry(todoItem).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
return Request.CreateResponse(HttpStatusCode.InternalServerError);
}
return Request.CreateResponse(HttpStatusCode.OK);
}
/// <summary>
/// Add a new TODO item to the system.
/// </summary>
/// <param name="item">The new item.</param>
/// <returns>The new item with up-to-date data.</returns>
public HttpResponseMessage Post(TodoItemDto item)
{
if (ModelState.IsValid)
{
var itemEntity = item.Map();
itemEntity.Owner = User.Identity.Name;
var newItem = repository.Insert(itemEntity);
Hub.Clients.All.itemAdded(ConnectionId, item);
var uri = Url.Link("DefaultApi", new { id = item.Id });
var response = Request.CreateResponse <TodoItemDto>(HttpStatusCode.Created, newItem.Map());
response.Headers.Location = new Uri(uri);
return(response);
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
}
public async void Post_BadRequest()
{
//Given
var client = _factory.WithWebHostBuilder(builder =>
{
builder.ConfigureTestServices(services =>
{
services.AddAuthentication("Test").AddScheme <AuthenticationSchemeOptions, TestAuthHandler>("Test", options => { });
});
}).CreateClient(new WebApplicationFactoryClientOptions
{
BaseAddress = new Uri("http://localhost/api/v1/TodoItems/")
});
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Test");
var todoItem = new TodoItemDto();
//When
var response = await client.PostAsync("", new StringContent(JsonConvert.SerializeObject(todoItem), Encoding.UTF8, "application/json"));
//Then
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
public async Task AddAsync_WithDataSourceThrowingException_ShouldReturnLeftInsertFailueAndThrownException()
{
// Arrange
var exception = new Exception("Test exception");
var itemToAdd = new TodoItemDto(Guid.NewGuid(), false, "Test");
_mockCollection
.Setup(svc => svc.InsertOneAsync(itemToAdd, It.IsAny <InsertOneOptions>(), _anyCancellationToken))
.Throws(exception);
var dataSource = CreateService();
// Act
var actual = dataSource.AddAsync(itemToAdd);
// Assert
await actual.ShouldBeLeft(failure => failure.ShouldBeOfType <DatabaseFailure.Insert>());
await actual.ShouldBeLeft(failure => failure.Error.Exception.ShouldBeSome());
await actual.ShouldBeLeft(failure => failure.Error.Exception.ShouldBe(exception));
}
public async Task Update_WithDataSourceReturningVoid_ShouldReturnRightUnit()
{
// Arrange
var itemToUpdate = new TodoItemDto(Guid.NewGuid(), false, "Test");
_mockCollection
.Setup(svc => svc.UpdateOneAsync(
It.IsAny <FilterDefinition <TodoItemDto> >(),
It.IsAny <UpdateDefinition <TodoItemDto> >(),
It.IsAny <UpdateOptions>(),
_anyCancellationToken))
.Returns(Task.FromResult((UpdateResult) new UpdateResult.Acknowledged(2, 2, "123")));
var dataSource = CreateService();
// Act
var actual = dataSource.Update(itemToUpdate);
// Assert
await actual.ShouldBeRight();
await actual.ShouldBeRight(u => u.ShouldBe(unit));
}
public async Task <IActionResult> UpdateTodoItem(long id, TodoItemDto todoItemDto)
{
if (id != todoItemDto.Id)
{
return(BadRequest());
}
try
{
await _todoItemsService.UpdateTodoItem(todoItemDto);
}
catch (Exception)
{
TodoItemDto itemGet = await _todoItemsService.GetTodoItem(todoItemDto.Id);
if (itemGet == null)
{
return(NotFound());
}
}
return(NoContent());
}
PutTodoItem(long id, TodoItemDto todoItemDto)
{
if (id != todoItemDto.Id)
{
return(BadRequest());
}
var todoItem = await _context !.TodoItems.FindAsync(id);
if (todoItem == null)
{
return(NotFound());
}
todoItem.Name = todoItemDto.Name;
todoItem.IsComplete = todoItemDto.IsComplete;
_context.Entry(todoItem).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TodoItemExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public IActionResult Get(int skip = 0, int top = 0)
{
var query = new GetAllTodoItemsQuery(skip, top);
query.Validate();
if (query.Invalid)
{
return(BadRequest(query));
}
var result = _todoItemQueryHandler.Handle(query);
var listDto = new List <TodoItemDto>();
foreach (var item in result)
{
var todoItemDto = new TodoItemDto();
todoItemDto.InjectFrom(item);
listDto.Add(todoItemDto);
}
return(Ok(listDto.AsEnumerable()));
}
public TodoItem UpdateItem(TodoItemDto updateItemDto)
{
var userId = CheckAuthentication();
return(todoItemRepository.UpdateItem(userId, updateItemDto));
}
/// <summary>
/// Maps the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <returns></returns>
public static TodoItem Map(this TodoItemDto item)
{
return(Mapper.Map <TodoItem> (item));
}
public Task <TodoItemDto> UpdateItemAsync(TodoItemDto item)
{
var dto = Repository.Update(item.AdaptAs <TodoItem>()).AdaptAs <TodoItemDto>();
return(Task.FromResult(dto));
}
public async Task <IActionResult> PutTodoItem(long id, TodoItemDto todoItemDto)
{
var result = await _handler.HandleUpdate(todoItemDto);
return(await Response(result));
}
public async Task <TodoItem> Put(TodoItemDto item, int id)
{
return(await _todoItemRepository.Toggle(item, id));
}
/// <summary>
/// updates specified item's description and status if changed
/// </summary>
/// <param name="itemDto"></param>
/// <returns>updated DTO</returns>
public async Task <TodoItemDto> UpdateItemAsync(TodoItemDto itemDto)
{
_logger.LogInformation($"In {nameof(UpdateItemAsync)}");
Guard.NotNull(itemDto, nameof(itemDto));
try
{
var updateStatus = !string.IsNullOrEmpty(itemDto.CurrentStatus);
var updateDescription = !string.IsNullOrEmpty(itemDto.Description);
using (var context = TodoContextFactory.Create())
{
// try to get requesetd item
var todoItem = await context.ToDoItems.FirstOrDefaultAsync(i => i.ItemId == itemDto.ItemId);
if (todoItem == null)
{
throw new ItemNotExistsException(itemDto.ItemId, "Failed to update to-do item.");
}
// check if discription is changed
if (updateDescription &&
!todoItem.Description.Equals(itemDto.Description, StringComparison.CurrentCultureIgnoreCase))
{
todoItem.Description = itemDto.Description;
}
// check if status has changed
if (updateStatus)
{
// check if new status is valid
if (!StatusValues.IsValid(itemDto.CurrentStatus))
{
throw new InvalidStatusException(itemDto.CurrentStatus,
"Failed to update to-do item status.");
}
// get current status string from to-do item entity, if exists
var currentSavedStatus = string.Empty;
if (todoItem.StatusHistory != null)
{
currentSavedStatus = todoItem.StatusHistory
.OrderByDescending(s => s.StatusDateTime)
.First()
?.Status;
}
// check if current saved status is the same as the new status, if not then update status
if (string.IsNullOrEmpty(currentSavedStatus) ||
!currentSavedStatus.Equals(itemDto.CurrentStatus, StringComparison.OrdinalIgnoreCase))
{
if (todoItem.StatusHistory == null)
{
todoItem.StatusHistory = new List <TodoItemStatus>();
}
// add new status entry
todoItem.StatusHistory.Add(new TodoItemStatus()
{
ItemId = todoItem.ItemId,
Status = itemDto.CurrentStatus,
StatusDateTime = DateTime.UtcNow
});
}
}
// save changes
await context.SaveChangesAsync();
// return updated to-do item
return(todoItem.ToDto());
}
}
catch (Exception)
{
throw;
}
finally
{
_logger.LogInformation($"Out {nameof(UpdateItemAsync)}");
}
}
public void Post([FromBody] TodoItemDto todo)
{
service.Create(todo);
}
public TodoItemDto Create(TodoItemDto todo)
{
return(mapper.Map <TodoItemDto>(repository.Add(mapper.Map <TodoItem>(todo))));
}
public async Task <ActionResult <TodoItemDto> > PostTodoItem(TodoItemDto todoItem)
{
var itemDto = await _todoItemService.createItemAsync(todoItem);
return(itemDto);
}
public async Task <IActionResult> Delete(TodoItemDto itemdto)
{
Todoitem item = _mapper.Map <Todoitem>(itemdto);
return(Ok(await _service.DeleteAsync(item)));
}
public async Task deleteItemAsync(TodoItemDto itemDto)
{
var itemModel = _mapper.Map <TodoItemDto, TodoItem>(itemDto);
await _todoItemRepository.deleteItem(itemModel);
}
// PUT api/Todo/5
public HttpResponseMessage PutTodoItem(int id, TodoItemDto todoItemDto)
{
if (!ModelState.IsValid)
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
if (id != todoItemDto.TodoItemId)
{
return Request.CreateResponse(HttpStatusCode.BadRequest);
}
TodoItem todoItem = todoItemDto.ToEntity();
TodoList todoList = db.TodoLists.Find(todoItem.TodoListId);
if (todoList == null)
{
return Request.CreateResponse(HttpStatusCode.NotFound);
}
if (todoList.UserId != User.Identity.Name)
{
// 사용자에게 속하지 않은 레코드를 수정하려고 시도합니다.
return Request.CreateResponse(HttpStatusCode.Unauthorized);
}
// SaveChanges가 호출될 때 중복 기본 키 예외 발생을 방지하려면 분리해야 합니다.
db.Entry(todoList).State = EntityState.Detached;
db.Entry(todoItem).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
return Request.CreateResponse(HttpStatusCode.InternalServerError);
}
return Request.CreateResponse(HttpStatusCode.OK);
}
/// <summary>
/// Updates a todo item.
/// </summary>
/// <param name="userId">User id</param>
/// <param name="updateObj">todo item to be updated</param>
/// <returns>Updated Todo item dto</returns>
public TodoItemDto UpdateItem(int userId, TodoItemDto updateObj)
{
var dbList = todoItemRepository.UpdateItem(userId, updateObj);
return(mapper.Map <TodoItemDto>(dbList));
}
public async Task <TodoItem> Create(TodoItemDto item)
{
return(await _todoItemRepository.Add(item));
}
