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); }