public async Task <IActionResult> Create([Bind("Id,Title,Description,DeadlineDate,DeadlineTime,Priority")] CreateTaskDto givenTask)
{
if (ModelState.IsValid)
{
var now = DateTime.Now;
if (givenTask.DeadlineDate + givenTask.DeadlineTime < now)
{
return(View());
}
var task = new Task
{
CreatedAt = DateTime.Now,
ApplicationUserId = _userManager.GetUserId(User),
Deadline = givenTask.DeadlineDate.Date + givenTask.DeadlineTime,
Priority = givenTask.Priority,
Description = givenTask.Description,
Title = givenTask.Title,
};
_context.Add(task);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View());
}
// GET: Tasks/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var task = await _context.Tasks.FindAsync(id);
if (task == null)
{
return(NotFound());
}
var taskDto = new CreateTaskDto
{
Priority = task.Priority,
DeadlineDate = task.Deadline.Date,
DeadlineTime = task.Deadline.TimeOfDay,
Description = task.Description,
Title = task.Title
};
return(View(taskDto));
}
public async Task <UserTask> CreateTask(CreateTaskDto createTaskDto)
{
User userResult;
if (createTaskDto.UserId == 0)
{
userResult = null;
}
else
{
userResult = await _taskContext.Users.FirstOrDefaultAsync(x => x.UserId == createTaskDto.UserId);
}
UserTask userTask = new UserTask()
{
TaskName = createTaskDto.TaskName,
TaskDescription = createTaskDto.TaskDescription,
StartDate = createTaskDto.StartDate,
EndDate = createTaskDto.EndDate,
Status = TaskStatus.Active.ToString(),
IsOpen = true,
user = userResult
};
var taskResult = await _taskContext.UserTasks.AddAsync(userTask);
await _taskContext.SaveChangesAsync();
return(taskResult.Entity);
}
public async Task <IActionResult> CreateTask([FromBody] CreateTaskDto taskDto)
{
try
{
if (taskDto == null)
{
_logger.LogError("Object sent from client is null.");
return(BadRequest("Owner object is null"));
}
if (!ModelState.IsValid)
{
_logger.LogError("Invalid object sent from client.");
return(BadRequest("Invalid model object"));
}
await _taskRepository.CreateAsync(new TaskEntity
{
PartitionKey = taskDto.ProjectId,
RowKey = Guid.NewGuid().ToString().Substring(1, 7),
Name = taskDto.Name,
Description = taskDto.Description
});
return(Created("", taskDto));
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside task Create action: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public void CreateSprintTask(CreateTaskDto createTaskDto)
{
try
{
var task = new SprintTask
{
Title = createTaskDto.Title,
Description = createTaskDto.Description,
DeveloperId = createTaskDto.DeveloperId,
SprintId = createTaskDto.SprintId,
status = Status.Pendding
};
Db.SprintTasks.Add(task);
Db.SaveChanges();
var developers = Db.Developers.Where(x => x.Id == createTaskDto.DeveloperId).SingleOrDefault();
mail.SendMail(
developers.Email,
developers.FirstName,
"A New Task has been Created <br/>" +
"Title : " + createTaskDto.Title + "<br/>" +
"Description : " + createTaskDto.Description + "<br/>" +
"Best luck PMS bot"
);
}
catch (Exception)
{
throw;
}
}
public async Task CreateAsync_GroupIdAndValidData_CreatesTask()
{
//Arrange
var sut = CreateSut();
var dto = new CreateTaskDto("name", Guid.NewGuid(), DateTime.Now.AddDays(1));
Tools.SetupCurrentUserService(_mocker);
var taskId = Guid.NewGuid();
var task = new Mock <ITaskEntity>();
task.SetupGet(o => o.Name).Returns(dto.Name);
task.SetupGet(o => o.Id).Returns(taskId);
task.SetupGet(o => o.GroupId).Returns(dto.GroupId);
task.SetupGet(o => o.Deadline).Returns(dto.Deadline);
_mocker.GetMock <IEntityValidator>()
.Setup(o => o.IsGroupIdValidAsync(dto.GroupId.Value))
.ReturnsAsync(true);
_mocker.GetMock <ITaskAggregate>()
.Setup(o => o.Create(dto.Name, Tools.User.Id, dto.GroupId, dto.Deadline))
.Returns(task.Object);
//Act
var result = await sut.CreateAsync(dto);
//Assert
result.GroupId.ShouldBe(dto.GroupId);
result.Id.ShouldBe(task.Object.Id);
result.Name.ShouldBe(dto.Name);
result.IsComplete.ShouldBeFalse();
result.Deadline.ShouldBe(dto.Deadline);
}
public async Task <IActionResult> CreateTask(CreateTaskDto task)
{
await userService.CreateTaskAsync(task.Content, task.Due, Int32.Parse(httpContextAccessor.HttpContext.User
.FindFirst("Id").Value));
return(Ok());
}
public async Task <TaskDto> CreateAsync(CreateTaskDto createTaskDto)
{
var taskListEntity = await _tripFlipDbContext.TaskLists
.AsNoTracking()
.SingleOrDefaultAsync(t => t.Id == createTaskDto.TaskListId);
EntityValidationHelper
.ValidateEntityNotNull(taskListEntity, ErrorConstants.TaskListNotFound);
// Validate current user has route 'Admin' role.
await EntityValidationHelper.ValidateCurrentUserRouteRoleAsync(
currentUserService : _currentUserService,
tripFlipDbContext : _tripFlipDbContext,
routeId : taskListEntity.RouteId,
routeRoleToValidate : RouteRoles.Admin,
errorMessage : ErrorConstants.NotRouteAdmin);
var taskEntity = _mapper.Map <TaskEntity>(createTaskDto);
await _tripFlipDbContext.Tasks.AddAsync(taskEntity);
await _tripFlipDbContext.SaveChangesAsync();
var taskDto = _mapper.Map <TaskDto>(taskEntity);
return(taskDto);
}
public async Task <IActionResult> CreateTask([FromBody] CreateTaskDto data)
{
var session = HttpContext.Session.GetComplexData <UserViewModel>("logged_user_data");
if (session == null)
{
return(RedirectToAction("Index", "Login"));
}
var task = _mapper.Map <scrum_ui.Models.Task>(data);
task.UserId = session.Id;
await _taskRepository.CreateTask(task);
var tasks = await _taskRepository.GetTasksByGroupId(task.GroupId);
int totalScore = 0;
foreach (var item in tasks)
{
if (item.Score != null)
{
totalScore += item.Score.Value;
}
}
return(Json(new { Result = new { Task = task, TotalScore = totalScore, Count = tasks.Count } }));
}
public async Task RemoveTask_GivenAnExistingTask_ShouldRemoveTask()
{
var taskToRemove = new CreateTaskDto
{
AttendantId = ADMIN_PERSON_ID,
AuthorId = ADMIN_PERSON_ID,
Title = "new task",
Description = "new task",
StatusId = 1,
PriorityId = 1
};
var newTaskReq = await DoPostRequest("api/task/newtask", taskToRemove);
newTaskReq.EnsureSuccessStatusCode();
var newTaskResp = GetSingleResult <CreateTaskDto>(await newTaskReq.Content.ReadAsStringAsync());
var removeTaskReq = await DoPostRequest("api/task/removetask", newTaskResp.TaskId);
removeTaskReq.EnsureSuccessStatusCode();
var removeTaskResp = GetStructResult <bool>(await removeTaskReq.Content.ReadAsStringAsync());
Assert.AreEqual(HttpStatusCode.OK, removeTaskReq.StatusCode);
Assert.IsTrue(removeTaskResp);
}
public IActionResult CreateTask(CreateTaskDto createTaskDto)
{
var title = createTaskDto.Title;
teamLeaderRepository.CreateSprintTask(createTaskDto);
mail.SendMailForATask("*****@*****.**", "mohammad yahya ", User.Identity.Name, title);
return(Redirect("ShowProject"));
}
public async Task <CreateTaskDto> CreateNewTask(CreateTaskDto task)
{
var eTask = mapper.Map <Core.Entities.Task>(task);
await taskRepository.Create(eTask);
return(await taskRepository.SaveChanges() ? task : null);
}
public long CreateTask(CreateTaskDto createTask)
{
var command = createTask.ToCommand();
_commandDispatcher.Handle(command);
return(command.CreatedTaskId);
}
public Task CreateTask(CreateTaskDto taskDto)
{
var task = _mapper.Map <Task>(taskDto);
_unitOfWork.Repository <Task>().Add(task);
_unitOfWork.Complete();
return(task);
}
public async Task <ActionResult <TaskDto> > PostTask(CreateTaskDto createTaskDto)
{
var taskEntity = TaskMapper.mapFromCreateTask(createTaskDto);
_context.Tasks.Add(taskEntity);
await _context.SaveChangesAsync();
return(Ok(TaskMapper.mapToDto(taskEntity)));
}
public async Task <ActionResult <TaskDto> > CreateTask(CreateTaskDto createTaskDto)
{
var task = await _taskService.CreateTaskAsync(createTaskDto);
if (task == null)
{
return(BadRequest());
}
return(Ok(MapTaskToTaskDto(task)));
}
//Assign Task , with dropdown
public async System.Threading.Tasks.Task Create(CreateTaskDto input)
{
var task = ObjectMapper.Map <Task>(input);
if (task == null)
{
throw new UserFriendlyException("No data, Task cannot be created");
}
await _taskRepo.InsertAsync(task);
}
public void CreateSprintTask(CreateTaskDto createTask)
{
var task = new SprintTask
{
Title = createTask.Title,
Description = createTask.Description
};
db.SprintTasks.Add(task);
db.SaveChanges();
}
public static Task mapFromCreateTask(CreateTaskDto createTaskDto)
{
Task result = new Task();
result.Title = createTaskDto.Title;
result.Description = createTaskDto.Description;
result.Added = createTaskDto.Added;
result.Deadline = createTaskDto.Deadline;
result.Importance = (Importance)Enum.Parse(typeof(Importance), createTaskDto.Importance);
result.State = (State)Enum.Parse(typeof(State), createTaskDto.State);;
return(result);
}
public async Task <IActionResult> Post(CreateTaskDto taskDto)
{
var taskEntity = SimpleMapper.Map <CreateTaskDto, TaskEntity>(taskDto);
var createdId = await _taskService.CreateAsync(taskEntity);
if (createdId == Guid.Empty)
{
return(BadRequest());
}
return(Ok(createdId));
}
protected override async Task SendDtoAsync(CreateTaskDto dto)
{
var updateResult = await _tasksService.UpdateTaskAsync(dto as UpdateTaskDto);
if (!updateResult.IsSuccess)
{
ShowToast(updateResult.GetFullMessage());
return;
}
TaskSaved?.Invoke(this, EventArgs.Empty);
}
public TaskControllerTests()
{
newTask = new CreateTaskDto
{
AttendantId = ADMIN_PERSON_ID,
AuthorId = ADMIN_PERSON_ID,
Title = "new task",
Description = "new task",
StatusId = 1,
PriorityId = 1
};
}
public async Task <IActionResult> Create([FromBody] CreateTaskDto dto)
{
//not sure if this is the best way but can't think of a better way.
var usecase = new TaskCreatedUseCase(_taskRepository, _lifetimeScope.Resolve <ILogger <TaskCreatedUseCase> >());
var response = await usecase.Process(_mapper.Map <CreateTaskRequest>(dto));
if (response.Success)
{
return(new OkResult());
}
return(ApiHelpers.GetErrorResult(response.Errors, _mapper));
}
public async Task <ActionResult <IEnumerable <User> > > CreateTask(CreateTaskDto createTaskDto)
{
try
{
await _taskContext.CreateTask(createTaskDto);
return(Ok(createTaskDto));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Error while adding user task data to the database"));
}
}
public IActionResult InsertTask(CreateTaskDto taskDto)
{
if (ModelState.IsValid)
{
taskDto.SprintID = _sprintId;
taskRepository.InsertTask(taskDto);
return(RedirectToAction("ShowSprintTasks", new { @sprintId = _sprintId }));
}
else
{
return(RedirectToAction("Create"));
}
}
public async Task CreateNewTask_GivenAnInvalidTaskData_ShouldReturnBadRequest()
{
newTask = new CreateTaskDto
{
AttendantId = ADMIN_PERSON_ID,
AuthorId = ADMIN_PERSON_ID,
StatusId = 1,
PriorityId = 1
};
var response = await DoPostRequest("api/task/newtask", newTask);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
//Add A new Task
public void CreateSprintTask(CreateTaskDto createTask)
{
var task = new SprintTask
{
Title = createTask.Title,
Description = createTask.Description,
status = Status.Pendding,
DeveloperId = createTask.DeveloperId,
SprintId = createTask.SprintId
};
db.SprintTasks.Add(task);
db.SaveChanges();
}
public async Task <TaskDto> CreateAsync(CreateTaskDto dto)
{
if (dto.GroupId is not null && !await _entityValidator.IsGroupIdValidAsync(dto.GroupId.Value))
{
throw new GroupIdInvalidException();
}
var userId = _currentUserService.GetCurrentUser().Id;
var task = _taskAggregate.Create(dto.Name, userId, dto.GroupId, dto.Deadline);
await _taskRepository.CreateAsync(task);
return(new(task.Id, task.Name, task.Created, task.IsComplete, task.GroupId, task.Deadline));
}
public async Task <int> Post([FromBody] CreateTaskDto value)
{
var task = mapper.Map <PTask>(value);
task.TaskUsers = userService.GetAll()
.Where(x => value.UserNames.Contains(x.UserName))
.Select(user => new PTaskUser {
UserId = user.Id, Task = task
})
.ToList();
await taskService.Create(task);
return(task.Id);
}
public void InsertTask(CreateTaskDto tasktDto)
{
SprintTask task = new SprintTask()
{
SprintID = tasktDto.SprintID,
Title = tasktDto.Title,
Description = tasktDto.Description,
Status = Status.PendingApproval,
StartDate = tasktDto.StartDate,
EndDate = tasktDto.EndDate,
DeveloperID = tasktDto.DeveloperId
};
context.SprintTasks.Add(task);
context.SaveChanges();
}
