public async Task <ActionResult <TaskViewModel> > RemoveTaskFromProjectAsync(Guid projectId, Guid taskId)
{
if (projectId == Guid.Empty || taskId == Guid.Empty)
{
return(BadRequest("No valid id received"));
}
try
{
ProjectTask projectTask = (await taskService.GetProjectTaskAsync(projectId, taskId)).Data;
if (projectTask == null)
{
return(NotFound("ProjectTask not found"));
}
TaskResult <ProjectTask> result = await taskService.RemoveProjectTaskAsync(projectTask);
return(!result.Succeeded
? UnprocessableEntity(new ErrorViewModel
{
Type = Type.Error, Message = result.Message
})
: Ok(TaskViewModel.CreateVm(result.Data.Task)));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(RemoveTaskFromProjectAsync);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
public async Task <ActionResult <TaskViewModel> > GetTaskAsync(Guid id)
{
if (id == Guid.Empty)
{
return(BadRequest("No valid id."));
}
try
{
TaskResult <Task> result = await taskService.GetTaskAsync(id);
if (!result.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = result.Message
}));
}
if (result.Data == null)
{
return(NotFound());
}
return(Ok(TaskViewModel.CreateVm(result.Data)));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(GetTaskAsync);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
public async Task <ActionResult <TaskViewModel> > SaveTaskAsync(TaskViewModel taskViewModel)
{
if (taskViewModel == null)
{
return(BadRequest("No valid task received"));
}
if (string.IsNullOrEmpty(taskViewModel.Name))
{
return(BadRequest("Name of a Task cannot be empty"));
}
if (taskViewModel.Category == null)
{
return(BadRequest("Category of a Task cannot be empty"));
}
try
{
Task task = TaskViewModel.CreateTask(taskViewModel);
if (task == null)
{
return(BadRequest("Unable to convert TaskViewModel to Task"));
}
string oid = IdentityHelper.GetOid(HttpContext.User.Identity as ClaimsIdentity);
task.LastEditBy = oid;
task.Category = null;
task.Instruction = null;
TaskResult <Task> result;
if (task.Id == Guid.Empty)
{
result = await taskService.CreateTaskAsync(task);
}
else
{
return(BadRequest("Cannot update existing Task with post method"));
}
if (!result.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = result.Message
}));
}
return(Ok(TaskViewModel.CreateVm(result.Data)));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(SaveTaskAsync);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
public async Task <ActionResult <TaskViewModel> > AddTaskToProjectAsync(ProjectTaskViewModel projectTaskViewModel)
{
if (projectTaskViewModel == null)
{
return(BadRequest("No valid ProjectTask received"));
}
if (projectTaskViewModel.ProjectId == Guid.Empty || projectTaskViewModel.TaskId == Guid.Empty)
{
return(BadRequest("Project and/or Task Ids cannot be empty"));
}
try
{
ProjectTask projectTask = ProjectTaskViewModel.CreateProjectTask(projectTaskViewModel);
if (projectTask == null)
{
return(BadRequest("Unable to convert ProjectTaskViewModel to ProjectTask"));
}
projectTask.Task = (await taskService.GetTaskAsync(projectTask.TaskId)).Data;
projectTask.Project = (await projectService.GetProjectDetailsAsync(projectTask.ProjectId)).Data;
if (projectTask.Task == null || projectTask.Project == null)
{
return(BadRequest("Unable to add project and or task to projecttask"));
}
string oid = IdentityHelper.GetOid(HttpContext.User.Identity as ClaimsIdentity);
projectTask.LastEditBy = oid;
TaskResult <ProjectTask> result;
if (projectTask.Id == Guid.Empty)
{
result = await taskService.AddTaskToProjectAsync(projectTask);
}
else
{
return(BadRequest("Cannot update existing ProjectTask with post method"));
}
if (!result.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = result.Message
}));
}
return(Ok(TaskViewModel.CreateVm(result.Data.Task)));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(AddTaskToProjectAsync);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
public async Task <ActionResult <List <TaskViewModel> > > GetAllProjectTasksAsync(Guid projectId)
{
if (projectId == Guid.Empty)
{
return(BadRequest("No valid id."));
}
try
{
TaskListResult <ProjectTask> result = await taskService.GetAllProjectTasksAsync(projectId);
if (!result.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = result.Message
}));
}
if (result.Data.Count == 0)
{
return(Ok(new List <ProjectTaskViewModel>()));
}
List <TaskViewModel> taskViewModels =
result.Data.Select(projectTask => TaskViewModel.CreateVm(projectTask.Task)).ToList();
return(Ok(taskViewModels));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(GetAllProjectTasksAsync);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
public async Task <ActionResult <AvailabilityDataViewModel> > GetAvailabilityData(Guid projectId)
{
if (projectId == Guid.Empty)
{
return(BadRequest("No valid projectId."));
}
try
{
TaskListResult <ProjectTask> taskResult = await taskService.GetAllProjectTasksAsync(projectId);
TaskListResult <Shift> shiftResult =
await shiftService.GetShiftsWithAvailabilitiesAsync(projectId);
if (!taskResult.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel
{
Type = Type.Error, Message = taskResult.Message
}));
}
if (!shiftResult.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel
{
Type = Type.Error, Message = shiftResult.Message
}));
}
List <Schedule> knownAvailabilities = new List <Schedule>();
foreach (IGrouping <DateTime, Shift> grouping in shiftResult.Data.GroupBy(s => s.Date))
{
List <AvailabilityStatus> dateStatus = new List <AvailabilityStatus>();
foreach (Shift shift in grouping)
{
int numberOfAvailabilities =
shift.Availabilities.Where(a => a.Type == AvailibilityType.Ok).Count();
int numberOfSchedule = shift.Availabilities.Count(a => a.Type == AvailibilityType.Scheduled);
if (numberOfSchedule >= shift.ParticipantsRequired)
{
dateStatus.Add(AvailabilityStatus.Scheduled);
}
else if (numberOfAvailabilities >= shift.ParticipantsRequired)
{
dateStatus.Add(AvailabilityStatus.Complete);
}
else
{
dateStatus.Add(AvailabilityStatus.Incomplete);
}
}
Schedule schedule = new Schedule(grouping.Key, AvailabilityStatus.Incomplete);
if (dateStatus.All(a => a == AvailabilityStatus.Complete || a == AvailabilityStatus.Scheduled))
{
schedule.Status = AvailabilityStatus.Complete;
}
if (dateStatus.All(a => a == AvailabilityStatus.Scheduled))
{
schedule.Status = AvailabilityStatus.Scheduled;
}
knownAvailabilities.Add(schedule);
}
List <TaskViewModel> taskViewModels = taskResult.Data
.Select(projectTask => TaskViewModel.CreateVm(projectTask.Task)).ToList();
AvailabilityDataViewModel vm = new AvailabilityDataViewModel
{
ProjectTasks = taskViewModels,
KnownAvailabilities = knownAvailabilities
};
return(Ok(vm));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(GetAvailabilityData);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
public async Task <ActionResult <AvailabilityDataViewModel> > GetAvailabilityData(Guid projectId, Guid userId)
{
if (projectId == Guid.Empty)
{
return(BadRequest("No valid projectId."));
}
if (userId == Guid.Empty)
{
return(BadRequest("No valid userId."));
}
try
{
TaskListResult <ProjectTask> taskResult = await taskService.GetAllProjectTasksAsync(projectId);
TaskListResult <Shift> shiftResult =
await shiftService.GetShiftsWithAvailabilitiesAsync(projectId, userId);
TaskResult <Person> person = await personService.GetPersonAsync(userId);
if (!taskResult.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel
{
Type = Type.Error, Message = taskResult.Message
}));
}
if (!shiftResult.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel
{
Type = Type.Error, Message = shiftResult.Message
}));
}
if (!person.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel
{
Type = Type.Error, Message = person.Message
}));
}
List <Schedule> knownAvailabilities = new List <Schedule>();
foreach (IGrouping <DateTime, Shift> grouping in shiftResult.Data.GroupBy(s => s.Date))
{
int numberOfShifts = grouping.Count();
int numberOfAvailabilities = 0;
bool scheduled = false;
bool anyAvailable = false;
foreach (Shift shift in grouping)
{
if (shift.Availabilities.Count <= 0)
{
continue;
}
numberOfAvailabilities++;
shift.Availabilities.ForEach(a =>
{
if (a.Type == AvailibilityType.Scheduled)
{
scheduled = true;
}
else if (a.Type == AvailibilityType.Ok)
{
anyAvailable = true;
}
});
}
if (scheduled)
{
knownAvailabilities.Add(new Schedule(grouping.Key, AvailabilityStatus.Scheduled));
}
else if (anyAvailable)
{
knownAvailabilities.Add(new Schedule(grouping.Key, AvailabilityStatus.Complete));
}
else if (numberOfAvailabilities > 0 && !anyAvailable)
{
knownAvailabilities.Add(new Schedule(grouping.Key, AvailabilityStatus.Unavailable));
}
else
{
knownAvailabilities.Add(new Schedule(grouping.Key, AvailabilityStatus.Incomplete));
}
}
List <TaskViewModel> taskViewModels = taskResult.Data
.Where(t => t.Task.Requirements
.All(r => person.Data.Certificates
.Where(c => c.DateExpired == null || c.DateExpired > DateTime.UtcNow)
.Select(c => c.CertificateTypeId)
.Contains(r.CertificateTypeId)))
.Select(projectTask => TaskViewModel
.CreateVm(projectTask.Task))
.ToList();
AvailabilityDataViewModel vm = new AvailabilityDataViewModel
{
ProjectTasks = taskViewModels,
KnownAvailabilities = knownAvailabilities
};
return(Ok(vm));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(GetAvailabilityData);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
public async Task <ActionResult <TaskViewModel> > UpdateTaskAsync(TaskViewModel taskViewModel)
{
if (taskViewModel == null || taskViewModel.Id == Guid.Empty)
{
return(BadRequest("No valid project received"));
}
if (string.IsNullOrEmpty(taskViewModel.Name))
{
return(BadRequest("Name of a Task cannot be empty"));
}
if (taskViewModel.Category == null)
{
return(BadRequest("Category of a Task cannot be empty"));
}
try
{
Task oldTask = (await taskService.GetTaskAsync(taskViewModel.Id)).Data;
if (oldTask == null)
{
return(NotFound("Task not found"));
}
if (!oldTask.RowVersion.SequenceEqual(taskViewModel.RowVersion))
{
return(BadRequest("Outdated entity received"));
}
Task updatedTask = TaskViewModel.CreateTask(taskViewModel);
if (updatedTask == null)
{
return(BadRequest("Unable to convert TaskViewModel to Task"));
}
oldTask.Color = updatedTask.Color;
oldTask.Description = updatedTask.Description;
oldTask.Name = updatedTask.Name;
oldTask.ProjectTasks = updatedTask.ProjectTasks;
if (updatedTask.Instruction != null)
{
oldTask.Instruction =
(await documentService.GetDocumentAsync(updatedTask.InstructionId ?? Guid.Empty))
.Data;
oldTask.InstructionId = oldTask.Instruction.Id;
}
if (updatedTask.CategoryId != Guid.Empty && oldTask.CategoryId != updatedTask.CategoryId)
{
oldTask.Category = (await taskService.GetCategoryAsync(updatedTask.CategoryId ?? Guid.Empty)).Data;
oldTask.CategoryId = oldTask.Category.Id;
}
string oid = IdentityHelper.GetOid(HttpContext.User.Identity as ClaimsIdentity);
oldTask.LastEditBy = oid;
TaskResult <Task> result = await taskService.UpdateTaskAsync(oldTask);
if (!result.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = result.Message
}));
}
return(Ok(TaskViewModel.CreateVm(result.Data)));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(UpdateTaskAsync);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
