public async Task <int> SaveTaskStatusAsync(TaskStatusModel model)
{
TaskEntity taskEntity = await _taskRep.FirstOrDefaultWithDeletedAsync(m => m.Id == model.Id);
using (Microsoft.EntityFrameworkCore.Storage.IDbContextTransaction trs = await _uow.BeginTransactionAsync())
{
if (taskEntity != null)
{
//güncelleme
Mapper.Map(model, taskEntity);
taskEntity.TaskStatus = model.TaskStatus;
taskEntity.IsDeleted = false;
await _taskRep.UpdateAsync(taskEntity);
await _uow.SaveChangesAsync();
trs.Commit();
}
else
{
throw new NotFoundException("Task", model.Id);
}
}
return(taskEntity.Id);
}
public async Task <IHttpActionResult> ChangeTaskStatus([FromBody] TaskStatusModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = _context.Users.FirstOrDefault(u => u.UserName.Equals(User.Identity.Name));
if (user == null)
{
return(BadRequest("Invalid account data"));
}
var task = user.Projects.FirstOrDefault(p => p.ProjectId.Equals(model.ProjectId))
.Tasks.FirstOrDefault(t => t.TaskId.Equals(model.TaskId));
if (task == null)
{
return(BadRequest("Invavid task data"));
}
task.Status = model.Status;
await _context.SaveChangesAsync();
return(Ok());
}
public void ChangeStatus(TaskStatusModel model)
{
var task = _taskRepository.GetFirstOrDefault(predicate: a => a.MentifiTaskId == model.Id,
include: a => a.Include(b => b.MentifiChannelTask));
if (task == null)
{
throw new ApplicationException("The task id is invalid");
}
var modifiedSystemUSer =
_systemUserRepository.GetFirstOrDefault(predicate: a => a.SystemUserId == model.ModifiedBySystemUserId);
task.Status = model.Status;
task.ModifiedBy = modifiedSystemUSer.BusinessId;
task.ModifiedOn = DateTime.UtcNow;
_taskRepository.Update(task);
if (model.Status == MentifiTaskStatus.Completed)
{
CreateNotif(modifiedSystemUSer, Constant.MentifiNotification.TASK_COMPLETED,
modifiedSystemUSer.SystemUserId == task.MentifiChannelTask.MenteeId
? task.MentifiChannelTask.MentorId
: task.MentifiChannelTask.MenteeId);
}
_unitOfWork.SaveChanges();
}
public async Task AddTaskStatus(TaskStatusModel taskStatus)
{
var parameters = new
{
taskStatus.Name,
taskStatus.DisplayOrder
};
await _dataAccess.SaveDataAsync <dynamic>("spTasks_AddTaskStatus", parameters, ConnectionStringName);
}
public async Task <IActionResult> CompleteTask([FromBody] TaskStatusModel t)
{
int result = await _taskData.UpdateTask(t.id, t.isComplete);
if (result < 0)
{
return(BadRequest()); // To Test without
}
return(Ok(1));
}
public async Task <IActionResult> Put([FromBody] TaskStatusModel model)
{
try
{
var task = await _taskStatusService.UpdateAsync(_mapper.Map <TaskStatusDto>(model));
return(Ok(_mapper.Map <TaskStatusModel>(task)));
}
catch (ArgumentException ex)
{
return(BadRequest(ex.Message));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public Task <int> SaveTaskStatusAsync(TaskStatusModel model)
{
return(_taskDom.SaveTaskStatusAsync(model));
}
public SprintStatusModel BuildSprintStatus(int sprintId)
{
SprintModel sprint = _dataManager.FindSprintById(sprintId);
var taskDificultyLevels = _dataManager.TaskDificultyLevels;
var userList = _dataManager.UserList;
var tasklist = _dataManager.TaskList.Where(task => task.SprintId == sprint.Id).ToList();
int overallEffortEstimation = 0;
int overallWorkEffort = 0;
List <TaskStatusModel> taskStatusModelList = new List <TaskStatusModel>();
tasklist.ForEach(task =>
{
try
{
TaskStatusModel model = BuildTaskStatus(task, taskDificultyLevels, userList);
overallEffortEstimation += model.EffortEstimation;
overallWorkEffort += model.WorkEffort;
taskStatusModelList.Add(model);
}
catch (Exception e)
{
Console.WriteLine("Failed to calculate task status for task {0} {1} due to :{2}", task.Id, task.Name, e.Message);
}
});
int totalNumberOfTasks = taskStatusModelList.Count;
int numberOfFinishedTasks = 0;
taskStatusModelList.ForEach(task =>
{
if (task.Status.Equals(TaskState.Finished))
{
numberOfFinishedTasks++;
}
});
int percentageOfCompletion = 0;
try
{
percentageOfCompletion = numberOfFinishedTasks * 100 / totalNumberOfTasks;
}
catch (Exception)
{
//Devided by zero exception
}
SprintStatusModel sprintStatusModel = new SprintStatusModel()
{
Id = sprint.Id,
Name = sprint.Name,
TargetDate = sprint.TargetDate,
PercentageOfCompletion = percentageOfCompletion,
OverallEffortEstimation = overallEffortEstimation,
OverallWorkEffort = overallWorkEffort,
TaskStatusList = taskStatusModelList
};
return(sprintStatusModel);
}
public async Task AddTaskStatus(TaskStatusModel taskStatus)
{
await _taskData.AddTaskStatus(taskStatus);
}
public IActionResult ChangeTaskStatus([FromBody] TaskStatusModel taskStatusModel)
{
taskService.ChangeTaskStatus(taskStatusModel.TaskId, taskStatusModel.Status);
return(new NoContentResult());
}
