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