public void AddTodo(TodoDto input)
{
var exists = context.TodoItems.Any(ff => ff.Title.ToLower() == input.Title.ToLower());
if (exists)
{
throw new InvalidOperationException("Duplicate todo item");
}
var validator = new TodoDtoValidator(context);
validator.Validate(input);
// refactor to mapper
var todoEntity = new TodoItem
{
CreationDate = DateTime.Now,
Title = input.Title,
IsDone = false,
DueDate = input.DueDate
};
context.TodoItems.Add(todoEntity);
context.SaveChanges();
}
public IActionResult CreateTodo([FromBody] TodoDto tododto)
{
_unitOfWork.Todos.Add(new Todo(tododto.Name, tododto.DueDate, tododto.Priority));
_unitOfWork.Complete();
return(Ok());
}
public bool UpdateTodo(int todoOldId, TodoDto todoNewItem)
{
var success = false;
if (todoNewItem != null)
{
using (var scope = new TransactionScope())
{
var todo = _unitOfWork.TodoRepository.GetById(todoOldId);
if (todo != null)
{
todo.DateCreate = todoNewItem.DateCreate;
todo.Heading = todoNewItem.Heading;
todo.Text = todoNewItem.Text;
_unitOfWork.TodoRepository.Update(todo);
_unitOfWork.Save();
scope.Complete();
success = true;
}
}
}
return(success);
}
public async Task <IActionResult> ChangeTaskState([FromBody] TodoDto task)
{
if (task.Id != 0 && !String.IsNullOrEmpty(task.Title) && !String.IsNullOrEmpty(task.State))
{
if (await _context.Todos.AnyAsync(t => t.Id == task.Id))
{
var updatedTask = new Todo()
{
Id = task.Id,
Title = task.Title,
State = task.State,
isCompleted = task.State == TodoState.Completed.ToString()
};
_context.Update(updatedTask);
await _context.SaveChangesAsync();
return(Ok());
}
else
{
return(BadRequest("Task not found"));
}
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> CreateNew([FromBody] TodoDto todo)
{
if (ModelState.IsValid)
{
var count = await _context.Todos.CountAsync();
var newTask = new Todo()
{
Id = count + 1,
Title = todo.Title,
State = TodoState.Todo.ToString(),
isCompleted = false
};
await _context.Todos.AddAsync(newTask);
await _context.SaveChangesAsync();
return(Ok());
}
else
{
return(BadRequest());
}
}
public async Task <ActionResult <TodoDto> > EditTodo([FromRoute] int id, [FromBody] TodoDto todoDto)
{
var CurrentUserId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var CurrentUser = await _userManager.Users
.Include(u => u.Todos)
.SingleAsync(u => u.Id == CurrentUserId);
if (id != todoDto.Id)
{
return(BadRequest());
}
Todo todo = CurrentUser.Todos.Single(t => t.Id == id);
if (todo == null)
{
return(NotFound());;
}
todo.TodoNote = todoDto.TodoNote;
_context.Entry(todo).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(Ok(_mapper.Map <TodoDto>(todo)));
}
public IActionResult Put([FromBody] TodoDto model)
{
var result = new GenericResult();
var validatorResult = validator.Validate(model);
if (validatorResult.IsValid)
{
try
{
result.Success = appService.Update(model);
if (!result.Success)
{
throw new Exception($"Todo #{model.Id} not found to be edited");
}
}
catch (Exception ex)
{
result.Errors = new string[] { ex.Message };
}
}
else
{
result.Errors = validatorResult.GetErrors();
}
return(Ok(result));
}
public Results.GenericResult Put(int id, [FromBody] TodoDto model)
{
var result = new Results.GenericResult();
var validatorResult = validator.Validate(model);
if (validatorResult.IsValid)
{
try
{
result.Success = appService.Update(model);
if (!result.Success)
{
throw new Exception($"Todo {id} can't be updated");
}
}
catch (Exception ex)
{
result.Errors = new string[] { ex.Message };
}
}
else
{
result.Errors = validatorResult.GetErrors();
}
return(result);
}
public async Task <IActionResult> Update([FromRoute] int id, [FromBody] TodoDto request)
{
var user = await GetUser();
var todo = await _todoService.GetById(id);
if (todo == null)
{
return(BadRequest("Invalid id"));
}
if (user.Id != todo.User.Id)
{
return(Forbid());
}
todo.Title = request.Title;
todo.Description = request.Description;
todo.IsComplete = request.IsComplete;
todo.LastUpdate = DateTime.UtcNow;
var result = await _todoService.Update(todo);
return(Ok());
}
public async Task <IActionResult> Update([FromBody] TodoDto data)
{
var response = new ApiResponse();
try
{
var todo = await _service.UpdateTodo(data);
response.Data = todo;
return(Ok(response));
}
catch (Exception e)
{
response.Message = e.Message;
switch (e)
{
case KeyNotFoundException:
return(NotFound(response));
default:
return(BadRequest(response));
}
}
}
public async Task Test()
{
var todo = new TodoDto
{
Title = "Title",
Description = "Description",
Completed = true
};
var mapperConfiguration = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new AutoMapperProfileConfiguration());
});
var mapper = mapperConfiguration.CreateMapper();
var mockOptions = new Mock <DbContextOptions <ApplicationContext> >();
mockOptions.Setup(m => m.ContextType).Returns(typeof(ApplicationContext));
var mockDbSet = new Mock <DbSet <Todo> >();
var mockContext = new Mock <ApplicationContext>(mockOptions.Object);
mockContext.Setup(m => m.Todos).Returns(mockDbSet.Object);
mockContext.Setup(m => m.SaveChangesAsync(default(CancellationToken))).Returns(() => Task.Run(() => 1)).Verifiable();
var service = new TodoService(mockContext.Object, mapper);
var createdTodo = await service.Create(todo);
mockDbSet.Verify(m => m.Add(It.IsAny <Todo>()), Times.Once());
mockContext.Verify(m => m.SaveChangesAsync(default(CancellationToken)), Times.Once());
}
public async Task <ResponseMessageDto> Save(TodoDto dto)
{
try
{
var model = new Todo()
{
Name = dto.Name,
CreatedOn = DateTime.Now,
CreatedById = 1,
};
await _dbContext.Todos.AddAsync(model);
await _dbContext.SaveChangesAsync();
return(new ResponseMessageDto()
{
Success = true,
SuccessMessage = StaticStrings.TodoSuccess,
Failure = false,
FailureMessage = string.Empty
});
}
catch (Exception ex)
{
new ResponseMessageDto()
{
Success = false,
SuccessMessage = string.Empty,
Failure = true,
FailureMessage = StaticStrings.TodoFailure
};
throw ex;
}
}
public async Task <IActionResult> Delete([FromRoute] int id)
{
var user = await GetUser();
var todo = await _todoService.GetById(id);
if (todo == null)
{
return(BadRequest("Invalid id"));
}
if (user.Id != todo.User.Id)
{
return(Forbid());
}
todo = await _todoService.Delete(id);
var response = new TodoDto()
{
Title = todo.Title,
Description = todo.Description,
IsComplete = todo.IsComplete,
LastUpdate = todo.LastUpdate
};
return(Ok(response));
}
public void InsertTodo(TodoDto todoDto)
{
List <TodoDto> todoDtos = this.GetTodos().ToList();
todoDtos.Add(todoDto);
this.memoryCacheService.InsertCache(TodosKey, todoDtos, DateTime.Now.AddSeconds(CacheDurationInSeconds).TimeOfDay);
}
public async Task GivenAValidTodoDto_WhenCreate_ThenANewTodoIsCreated()
{
var options = CreateNewContextOptions();
var mapper = CreateMapper();
var todo = new TodoDto
{
Title = "Title",
Description = "Description",
Completed = true
};
using (var context = new ApplicationContext(options))
{
var service = new TodoService(context, mapper);
var createdTodo = await service.Create(todo);
Assert.True(createdTodo.Id > 0);
Assert.Equal(todo.Title, createdTodo.Title);
Assert.Equal(todo.Description, createdTodo.Description);
Assert.Equal(todo.Completed, createdTodo.Completed);
}
using (var context = new ApplicationContext(options))
{
Assert.Equal(1, context.Todos.Count());
var createdTodo = context.Todos.First();
Assert.True(createdTodo.Id > 0);
Assert.Equal(todo.Title, createdTodo.Title);
Assert.Equal(todo.Description, createdTodo.Description);
Assert.Equal(todo.Completed, createdTodo.Completed);
}
}
/// <inheritdoc/>
public async Task <TodoDto> CreateTodo(TodoDto dto)
{
TodoEntity newTodoEntity = _todoMapper.Map(dto);
TodoEntity createdTodoEntity = await _todoRepository.AddAsync(newTodoEntity);
return(_todoMapper.Map(createdTodoEntity));
}
public Results.GenericResult <TodoDto> Post([FromBody] TodoDto model)
{
var result = new Results.GenericResult <TodoDto>();
var validatorResult = validator.Validate(model);
if (validatorResult.IsValid)
{
try
{
result.Result = appService.Create(model);
result.Success = true;
}
catch (Exception ex)
{
result.Errors = new string[] { ex.Message };
}
}
else
{
result.Errors = validatorResult.GetErrors();
}
return(result);
}
public async Task <IActionResult> Save(TodoDto dto)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (dto.Id == 0)
{
await _todoServices.Save(dto);
}
else
{
await _todoServices.Update(dto);
}
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
Console.WriteLine(ex);
throw ex;
}
}
public IActionResult PostTodo([FromBody] TodoDto todo)
{
var mappedTodo = Mapper.Map <Todo>(todo);
var todoReturned = _todoRepository.Insert(mappedTodo);
return(Json(todoReturned));
}
public async Task <ApiResponse> Post([FromBody] TodoDto todo)
{
if (!ModelState.IsValid)
{
return(new ApiResponse(400, "Todo Model is Invalid"));
}
return(await _todoService.Create(todo));
}
public IActionResult Create([FromBody] TodoDto todo)
{
var result = _mediator.Send(new NewTodoCommand {
Todo = todo
});
return(CreatedAtRoute("GetTodos", null, result));
}
public async Task <IActionResult> Index()
{
var dto = new TodoDto();
var result = await _todoServices.Get();
dto.Todos = result;
return(View(dto));
}
public async Task <ApiResponse> Put([FromBody] TodoDto todo)
{
if (!ModelState.IsValid)
{
return(new ApiResponse(Status400BadRequest, "Todo Model is Invalid"));
}
return(await _todoService.Update(todo));
}
public async Task<ApiResponse> Put([FromBody] TodoDto todo)
{
if (!ModelState.IsValid)
{
return new ApiResponse(400, "Todo Model is Invalid");
}
return await _todoService.Update(todo);
}
public IActionResult Post(
[FromBody] TodoDto todo,
[FromServices] IAddTodoCommand command)
{
_executor.ExecuteCommand(command, todo);
return(NoContent());
}
public async Task <ActionResult <TodoResponseModel> > Get([FromRoute] Guid id)
{
TodoDto todoDto = await _todoService.GetTodo(id);
TodoResponseModel todoModel = _todoMapper.Map(todoDto);
return(Ok(todoModel));
}
public async Task <ActionResult <TodoResponseModel> > Create([FromBody] TodoRequestModel model)
{
TodoDto newTodoDto = _todoMapper.Map(model);
TodoDto createdTodoDto = await _todoService.CreateTodo(newTodoDto);
TodoResponseModel createdTodoModel = _todoMapper.Map(createdTodoDto);
return(Ok(createdTodoModel));
}
public async Task <ActionResult <TodoResponseModel> > Update([FromRoute] Guid id, [FromBody] TodoRequestModel model)
{
TodoDto updatableTodoDto = _todoMapper.Map(model);
TodoDto updatedTodoDto = await _todoService.UpdateTodo(id, updatableTodoDto);
TodoResponseModel updatedTodoModel = _todoMapper.Map(updatedTodoDto);
return(Ok(updatedTodoModel));
}
/// <inheritdoc/>
public async Task <TodoDto> UpdateTodo(Guid id, TodoDto dto)
{
TodoEntity existingTodoEntity = await _todoRepository.GetByIdAsync(id);
TodoEntity updatableTodoEntity = _todoMapper.Map(dto, existingTodoEntity);
await _todoRepository.UpdateAsync(updatableTodoEntity);
return(_todoMapper.Map(updatableTodoEntity));
}
public bool Put(int id, [FromBody] TodoDto value)
{
if (id > 0)
{
return(_todoService.UpdateTodo(id, value));
}
return(false);
}
