public override async System.Threading.Tasks.Task ExecuteAsync(object parameter) { _todayViewModel.ErrorMessage = string.Empty; Domain.Models.Task task = new Domain.Models.Task() { Account = _accountStore.CurrentAccount, Header = _todayViewModel.Task, Category = _todayViewModel.Category, Priority = _todayViewModel.Priority, Description = "", Deadline = DateTime.Now, isCompleted = false, Images = null, Files = null, Subtasks = null }; _accountStore.CurrentAccount.Tasks.Add(task); try { } catch (Exception e) { _todayViewModel.ErrorMessage = "All fields must be specified to create a task"; } }
public TaskController_UnitTest() { var task = new Domain.Models.Task() { Id = 1, Name = "Test Unit Task", StartDate = new DateTime(2019, 8, 8), EndDate = new DateTime(2019, 8, 12), Description = "This is a unit test", Status = EStatus.NotStarted, TenantId = Guid.NewGuid(), ProjectId = 1, OwnerId = 1 }; var tasks = new List <Domain.Models.Task>() { task }; var mockTaskService = new Mock <ITaskService>(); mockTaskService.Setup(service => service.GetTasks(It.IsAny <Guid>())).ReturnsAsync(tasks); mockTaskService.Setup(service => service.GetTask(It.IsAny <long>(), It.IsAny <Guid>())).ReturnsAsync(task); mockTaskService.Setup(service => service.CreateTask(It.IsAny <Domain.Models.Task>())).ReturnsAsync(true); mockTaskService.Setup(service => service.UpdateTask(It.IsAny <long>(), It.IsAny <Domain.Models.Task>())).ReturnsAsync(true); mockTaskService.Setup(service => service.DeleteTask(It.IsAny <long>())).ReturnsAsync(true); var mockMapper = new Mock <IMapper>(); sut = new TaskController(mockTaskService.Object, mockMapper.Object); }
public TaskService_UnitTest() { _task = new Domain.Models.Task() { Id = 1, Name = "Test Unit Task", StartDate = new DateTime(2019, 8, 8), EndDate = new DateTime(2019, 8, 12), Description = "This is a unit test", Status = EStatus.NotStarted, TenantId = Guid.NewGuid(), ProjectId = 1, OwnerId = 1 }; _tasks = new List <Domain.Models.Task>() { _task }; var mockTaskRepository = new Mock <ITaskRepository>(); mockTaskRepository.Setup(repository => repository.GetTasks(It.IsAny <Guid>())).ReturnsAsync(_tasks); mockTaskRepository.Setup(repository => repository.GetTask(It.IsAny <long>(), It.IsAny <Guid>())).ReturnsAsync(_task); mockTaskRepository.Setup(repository => repository.CreateTask(It.IsAny <Domain.Models.Task>())).ReturnsAsync(true); mockTaskRepository.Setup(repository => repository.UpdateTask(It.IsAny <long>(), It.IsAny <Domain.Models.Task>())).ReturnsAsync(true); mockTaskRepository.Setup(repository => repository.DeleteTask(It.IsAny <long>())).ReturnsAsync(true); sut = new TaskService(mockTaskRepository.Object); }
public async Task <ActionResult <TaskDto> > Create([FromBody] Domain.Models.Task task) { _context.Task.Add(task); await _context.SaveChangesAsync(); return(Ok(task)); }
public void AddTask(AddUpdateTaskCommand taskCommand) { if (taskCommand != null) { Domain.Models.Task task = new Domain.Models.Task(taskCommand.Title, taskCommand.Details, taskCommand.UserId, taskCommand.Date); _taskRepository.AddTask(task); } }
public async Task SaveTask_Success() { var model = new Domain.Models.Task { Name = "TestTask", Description = "TestTask description" }; var request = new SaveTaskRequest(model); var handler = new SaveTaskRequestHandler(_trackingContext, Mapper.Instance); var result = await handler.Handle(request, default(CancellationToken)); Assert.AreEqual(result, Unit.Value); }
public TaskViewModel GetTask(Guid taskId) { TaskViewModel taskView = null; Domain.Models.Task task = _taskRepository.GetTaskById(taskId); if (task != null) { taskView = new TaskViewModel(task.Id, task.Title, task.Details, task.Date, task.User.Name, task.UserId); } return(taskView); }
public void UpdateTask(AddUpdateTaskCommand taskCommand) { if (taskCommand != null && taskCommand.Id.HasValue) { Domain.Models.Task task = _taskRepository.GetTaskById(taskCommand.Id.Value); task.Title = taskCommand.Title; task.Details = taskCommand.Details; task.UserId = taskCommand.UserId; task.Date = taskCommand.Date; _taskRepository.UpdateTask(task); } }
public async Task <Domain.Models.Task> Get(int id) { using (ToDoDbContext context = _contextFactory.CreateDbContext()) { // include tasks Domain.Models.Task entity = await context.Tasks .Include(a => a.Subtasks) .Include(a => a.Images) .Include(a => a.Files) .FirstOrDefaultAsync((entity) => entity.Id == id); return(entity); } }
public async Task <ActionResult> UpdateTask(long id, Domain.Models.Task task) { if (id != task.Id) { return(NotFound()); } bool success = await _taskService.UpdateTask(id, task); if (!success) { return(NotFound()); } return(NoContent()); }
public async Task UpdateTask_Success() { var dataGenerationResult = _trackingContext.AddTestData <Domain.Entities.Task>(5); var selectedId = dataGenerationResult.Item2[1]; var updatedModel = new Domain.Models.Task { Id = selectedId, Name = "NewTaskName" }; var request = new UpdateTaskRequest(selectedId, updatedModel); var handler = new UpdateTaskRequestHandler(_trackingContext, Mapper.Instance); var result = await handler.Handle(request, default(CancellationToken)); Assert.AreEqual(Unit.Value, result); }
public async Task UpdateTaskList_Validation(int id, string taskName, bool instantiateModel, bool isValid) { Domain.Models.Task model = null; if (instantiateModel) { model = new Domain.Models.Task { Name = taskName }; } var request = new UpdateTaskRequest(id, model); var validator = new UpdateTaskValidator(); var validationResult = await validator.ValidateAsync(request); Assert.AreEqual(isValid, validationResult.IsValid); }
public async Task <bool> CreateTask(Domain.Models.Task task) { try { _context.Tasks.Add(task); await _context.SaveChangesAsync(); return(true); } catch (Exception e) { Console.WriteLine(e.Message); throw; } }
public async Task <ActionResult <TaskDto> > Update(int id, [FromBody] Domain.Models.Task task) { if (id != task.Id) { return(BadRequest()); } var update = await _context.Task.FindAsync(id); if (update == null) { return(NotFound()); } update.Name = task.Name; await _context.SaveChangesAsync(); return(Ok(update)); }
public async Task <bool> UpdateTask(long id, Domain.Models.Task task) { var foundTask = await _context.Tasks.AsNoTracking().FirstOrDefaultAsync(t => t.Id == id); if (foundTask == null) { return(false); } try { _context.Entry(task).State = EntityState.Modified; await _context.SaveChangesAsync(); return(true); } catch (Exception e) { Console.WriteLine(e.Message); throw; } }
public async System.Threading.Tasks.Task UpdateTask_Returns_NoContentResult() { // Arrange var tenantId = Guid.NewGuid(); var task = new Domain.Models.Task() { Id = 1, Name = "Test Unit Task Update", StartDate = new DateTime(2019, 8, 8), EndDate = new DateTime(2019, 8, 12), Description = "This is a unit test update", Status = EStatus.NotStarted, TenantId = tenantId, ProjectId = 1, OwnerId = 1 }; // Act var response = await sut.UpdateTask(task.Id, task); // Assert Assert.IsType <NoContentResult>(response); }
protected async Task <Domain.Models.Task> CreateTestTask() { var user = await CreateTestUser(); var project = await CreateTestProject(); var task = new Domain.Models.Task() { Name = "Test Integration Task", StartDate = new DateTime(2019, 8, 8), EndDate = new DateTime(2019, 8, 12), Description = "This is an integration test", Status = EStatus.NotStarted, TenantId = Guid.NewGuid(), OwnerId = user.Id, ProjectId = project.Id }; var taskRequest = new StringContent(JsonConvert.SerializeObject(task), Encoding.UTF8, "application/json"); var response = await _client.PostAsync($"/api/v1/task", taskRequest); response.EnsureSuccessStatusCode(); return(JsonConvert.DeserializeObject <Domain.Models.Task>(await response.Content.ReadAsStringAsync())); }
public async System.Threading.Tasks.Task CreateTask_Returns_True() { // Arrange var tenantId = Guid.NewGuid(); var task = new Domain.Models.Task() { Id = 1, Name = "Test Unit Task", StartDate = new DateTime(2019, 8, 8), EndDate = new DateTime(2019, 8, 12), Description = "This is a unit test", Status = EStatus.NotStarted, TenantId = tenantId, ProjectId = 1, OwnerId = 1 }; var expectedResult = true; // Act var response = await sut.CreateTask(task); // Assert Assert.Equal(expectedResult, response); }
public async Task <int> UpdateAsync(Domain.Models.Task entity) { try { int result = await _tasksHttpClient.UpdateAsync(_authenticator.GetAccess(), entity); return(result); } catch (UnauthorizedException) { bool refreshResult = await _authenticator.RefreshAccessToken(); if (refreshResult == false) { _loginRenavigator.Renavigate(); return(-1); } int result = await _tasksHttpClient.UpdateAsync(_authenticator.GetAccess(), entity); return(result); } catch (Exception) { _loginRenavigator.Renavigate(); return(-1); } }
public async Task <bool> RegisterUser(string email, string displayName, string password) { if (displayName == null || displayName.Length > 30) { // TODO Add proper exception throw new InvalidOperationException(); } User user = new User { UserName = email, Email = email, DisplayName = displayName }; var result = await _userManager.CreateAsync(user, password); var registeredUser = await FindUser(email, password); var defaultTeam = new Team { CreatedByUserId = registeredUser.Id, Description = "", Default = true, Name = "My Boards" }; var team = _dbContext.Teams.Add(defaultTeam); var userInTeam = new UserInTeam { Role = Domain.Enums.UserRoleInTeam.Normal, TeamId = team.Id, UserId = registeredUser.Id }; _dbContext.UserInTeams.Add(userInTeam); var welcomeBoard = new Board { CreatedByUserId = registeredUser.Id, Name = "Welcome Board" }; var board = _dbContext.Boards.Add(welcomeBoard); var boardInTeam = new BoardInTeam { BoardId = board.Id, TeamId = team.Id }; _dbContext.BoardInTeams.Add(boardInTeam); var tag = new Tag { BoardId = board.Id, Name = "Getting started", CreatedByUserId = registeredUser.Id }; _dbContext.Tags.Add(tag); var task1 = new Domain.Models.Task { CreatedByUserId = registeredUser.Id, Title = "Edit this board with tags that fit you", Description = "Example description... blah blah...", TagId = tag.Id }; _dbContext.Tasks.Add(task1); var task2 = new Domain.Models.Task { CreatedByUserId = registeredUser.Id, Title = "Create to-do tasks of tasks you need to get done", Description = "Example description... blah blah...", TagId = tag.Id }; _dbContext.Tasks.Add(task2); _dbContext.SaveChanges(); return(result.Succeeded); }
public async Task <ActionResult> CreateTask(Domain.Models.Task task) { bool success = await _taskService.CreateTask(task); return(CreatedAtAction(nameof(GetTask), new { id = task.Id }, task)); }
public async Task <Domain.Models.Task> Update(int id, Domain.Models.Task entity) { return(await _nonQueryDataService.Update(id, entity)); }
public void Remove(Domain.Models.Task task) { _context.Tasks.Remove(task); }
public async Task Update(int id, [FromBody] Domain.Models.Task model) { await _mediator.Send(new UpdateTaskRequest(id, model)); }
public async Task <bool> CreateTask(Domain.Models.Task task) => await _taskRepository.CreateTask(task);
public async Task <bool> UpdateTask(long id, Domain.Models.Task task) => await _taskRepository.UpdateTask(id, task);
public async Task AddAsync(Domain.Models.Task task) { await _context.Tasks.AddAsync(task); }
public async Task Create([FromBody] Domain.Models.Task model) { await _mediator.Send(new SaveTaskRequest(model)); }
public void Update(Domain.Models.Task task) { _context.Tasks.Update(task); }
public async Task <Domain.Models.Task> Create(Domain.Models.Task entity) { return(await _nonQueryDataService.Create(entity)); }