/// <summary>
/// Create WorkTask.
/// </summary>
/// <param name="workTaskDto">WorkTask information</param>
/// <returns></returns>
public async Task <Result> CreateWorkTaskAsync(WorkTaskDto workTaskDto,
WorkTaskUserDto manager)
{
Result methodResult = new Result();
var findedUser =
await _unitOfWork.WorkTaskUserRepository
.GetByMailAsync(manager.Mail);
if (findedUser != null)
{
if (findedUser.Role != (int)WorkTaskUserRoles.TaskManager)
{
methodResult.Message = "User are not a manager.";
return(methodResult);
}
var allManagerTasks = await _unitOfWork.WorkTaskRepository
.GetAllTasksByManagerIdAsync(findedUser.Id);
var taskExist = allManagerTasks
.FirstOrDefault(x => x.Name == workTaskDto.Name)
!= null;
if (taskExist)
{
methodResult.Message
= "Task with such name already exist.";
return(methodResult);
}
var taskEntity = _workTaskDtoMapper.Map(workTaskDto);
await Task.Run(() =>
{
try
{
_unitOfWork.WorkTaskRepository.Add(taskEntity);
}
catch (Exception ex)
{
methodResult.Success = false;
methodResult.Message = ex.Message;
}
});
await _unitOfWork.SaveChangesAsync();
methodResult.Success = true;
methodResult.Message = $"Manager({manager.Name}) " +
$"created Task({workTaskDto.Name})";
return(methodResult);
}
else
{
methodResult.Message = "User not found.";
return(methodResult);
}
}
/// <summary>
/// Change WorkTask Description.
/// </summary>
/// <param name="workTaskDto"> WorkTask information</param>
/// <param name="description"> Description</param>
/// <returns></returns>
public async Task <Result> ChangeDescriptionAsync
(WorkTaskDto workTaskDto, string description)
{
Result methodResult = new Result();
var findedTask = await _unitOfWork.WorkTaskRepository
.FirstAsync(x => x.Name == workTaskDto.Name);
if (findedTask != null)
{
findedTask.Description = description;
_unitOfWork.WorkTaskRepository.Update(findedTask);
methodResult.Success = true;
methodResult.Message = $"Description updated " +
$"in Task({findedTask.Name})";
await _unitOfWork.SaveChangesAsync();
}
else
{
methodResult.Message = "Task not fount.";
}
return(methodResult);
}
public WorkTaskAddView(WorkTasksController controller, WorkTaskDto entity) : this()
{
Entity = entity;
_controller = controller;
MainStackPanel.DataContext = Entity;
}
public void Add(WorkTaskDto entity)
{
_ctx.WorkTasks.Add((WorkTask)entity);
ListChanged?.Invoke();
_ctx.Save();
}
public async Task <Result> UpdateWorkTaskAsync(WorkTaskDto workTaskDto,
WorkTaskUserDto manager)
{
var result = new Result();
var findedUser = await _unitOfWork
.WorkTaskUserRepository.GetByMailAsync(manager.Mail);
var findedTask = await _unitOfWork.WorkTaskRepository
.FirstAsync(x => x.Name == workTaskDto.Name);
if (findedUser == null)
{
result.Message = "User not found";
return(result);
}
if (findedUser.Role != (int)WorkTaskUserRoles.TaskManager)
{
result.Message = $"User({findedUser.Name})" +
$"- is not a manager.";
return(result);
}
var managedTasks = await _unitOfWork.WorkTaskRepository
.GetAllTasksByManagerIdAsync(findedUser.Id);
bool isManagerOfCurrentTask = managedTasks
.FirstOrDefault(x => x.Id == findedTask.Id) != null;
if (isManagerOfCurrentTask)
{
if (!string.IsNullOrEmpty(workTaskDto.Name))
{
findedTask.Name = workTaskDto.Name;
}
if (!string.IsNullOrEmpty(workTaskDto.Description))
{
findedTask.Description = workTaskDto.Description;
}
_unitOfWork.WorkTaskRepository.Update(findedTask);
await _unitOfWork.SaveChangesAsync();
result.Message = $"Work task({findedTask.Name}), " +
$"deleted by user({findedUser.Name})";
result.Success = true;
}
else
{
result.Message = result.Message = $"User({findedUser.Name})" +
$"- is not a manager of work task({findedTask.Name}).";
}
return(result);
}
public override MailEntity GetMail(SystemMailEntity systemMail, object additionalTemplateData)
{
StringBuilder htmlBuilder = new StringBuilder();
WorkTaskDto workTaskDto = additionalTemplateData as WorkTaskDto;
SetAdditionalTemplateData(additionalTemplateData);
var subject = "TaskTracker Task Deadline.";
var html = htmlBuilder.Append
(@"<!DOCTYPE html>
<html>
<head>
<style> ")
.Append(TemplateStyleHolder.ICloudSuportedStyle)
.Append(@"</style>
</head>
<body>
<div class= 'message-header'>
<div class='title'>
TaskTracker
</div>
</div>
<div class='message-content'>
<div>
<h3>TaskTracker Team.</h3>
<hr>")
.Append($"Hello {systemMail.ToName}.<br>")
.Append(@"Welcome to TaskTracker!<br>
Hurry up!!! <br>
For deadline for your task ")
.Append($"({taskName}) will be on {taskDeadline}." +
$"You have only: {timeLeft} hr.")
.Append(@")
</div>
<div class='base-button-container'>
<a href='#...' class='base-button'>
Go To Task!</a>
</div>
</div>
<div class='message-footer'>
<div class='text'>
<h4>Contacts: </h4>
Phone number: xxx-xxx-xxx<br>
E-Mail: xxxx @mail.com
</div>
</div>
</body>
</html>").ToString();
return(_builder
.AddSystemPart(systemMail)
.AddSubject(subject)
.AddHtml(html)
.Build());
}
public WorkTaskAddView GetAddView(string name = null)
{
var entity = new WorkTaskDto()
{
WorkProjectId = _projectId,
Name = name
};
return(new WorkTaskAddView(this, entity));
}
public async Task <ActionResult <WorkTask> > CreateWorkTask(WorkTaskDto workTaskDto)
{
var work = await _unitOfWork.WorkRepository.GetWorkByIdAsync(workTaskDto.WorkId);
if (work == null)
{
return(BadRequest("There is no work with given id"));
}
var workTaskToAdd = _mapper.Map <WorkTask>(workTaskDto);
_unitOfWork.WorkRepository.AddWorkTask(workTaskToAdd);
if (await _unitOfWork.SaveAll())
{
return(CreatedAtRoute("work-tasks", new { workTaskId = workTaskToAdd.Id, workId = work.Id }, workTaskToAdd));
}
return(BadRequest("Saving work task didn't succeed"));
}
/// <summary>
/// Add WorkTaskPoint to the WorkTask.
/// </summary>
/// <param name="workTaskDto"> WorkTask information</param>
/// <param name="workTaskPointDto"> WorkTaskPoint information</param>
/// <returns></returns>
public async Task <Result> AddWorkTaskPointAsync(WorkTaskDto workTaskDto,
WorkTaskPointDto workTaskPointDto)
{
Result methodResult = new Result();
var findedTask = await _unitOfWork.WorkTaskRepository
.FirstAsync(x => x.Name == workTaskDto.Name);
if (findedTask != null)
{
var pointEntity = _workTaskPointDtoMapper.Map(workTaskPointDto);
var findedTaskPoint = await _unitOfWork.WorkTaskPointRepository
.FirstAsync(x => x.Name == pointEntity.Name &&
x.Description == pointEntity.Description);
if (findedTask != null)
{
findedTask.WorkTaskPoints.Add(pointEntity);
_unitOfWork.WorkTaskRepository.Update(findedTask);
methodResult.Message = $"Added new work " +
$"task point({pointEntity.Name})" +
$"to work task({findedTask.Name})";
methodResult.Success = true;
}
else
{
methodResult.Message = "Task not found.";
}
await _unitOfWork.SaveChangesAsync();
}
else
{
methodResult.Message = "Task not found.";
}
return(methodResult);
}
/// <summary>
/// Add performer to the task.
/// </summary>
/// <param name="workTaskDto">WorkTask</param>
/// <param name="performer"> Performer</param>
/// <returns>Return Result of adding performer.</returns>
public async Task <Result> AddPerformerAsync(WorkTaskDto workTaskDto,
WorkTaskUserDto performer)
{
Result methodResult = new Result();
var findedTask = await _unitOfWork.WorkTaskRepository
.FirstAsync(x => x.Name == workTaskDto.Name);
if (findedTask != null)
{
var findedUser = await _unitOfWork.WorkTaskUserRepository
.GetByMailAsync(performer.Mail);
bool ifUserExist = findedUser != null;
if (ifUserExist)
{
findedUser.WorkTasks.Add(findedTask);
findedTask.WorkTaskUsers.Add(findedUser);
_unitOfWork.WorkTaskUserRepository.Update(findedUser);
_unitOfWork.WorkTaskRepository.Update(findedTask);
}
else
{
methodResult.Success = false;
methodResult.Message = "User not found.";
}
methodResult.Success = true;
methodResult.Message = $"Added performer(Name: {performer.Name})" +
$" to work task(Name: {workTaskDto.Name}).";
await _unitOfWork.SaveChangesAsync();
}
else
{
methodResult.Message = "Task not found.";
}
return(methodResult);
}
/// <summary>
/// Change manager of the task.
/// </summary>
/// <param name="workTaskDto"> WorkTask information</param>
/// <param name="manager">Manager information</param>
/// <returns></returns>
public async Task <Result> ChangeManagerAsync(WorkTaskDto workTaskDto,
WorkTaskUserDto manager)
{
Result methodResult = new Result();
var taskEntity = _workTaskDtoMapper.Map(workTaskDto);
var findedTask = await _unitOfWork.WorkTaskRepository
.FirstAsync(x => x.Name == taskEntity.Name);
if (findedTask != null)
{
var findedUser = await _unitOfWork.WorkTaskUserRepository
.GetByMailAsync(manager.Mail);
bool userExist = findedUser != null;
if (userExist)
{
if (findedUser.Role != (int)WorkTaskUserRoles.TaskManager)
{
methodResult.Message = "User not a manager.";
return(methodResult);
}
var allManagerTask = await _unitOfWork.WorkTaskRepository
.GetAllTasksByManagerIdAsync(findedUser.Id);
bool taskManagedByUser = allManagerTask.FirstOrDefault
(x => x.Id == findedTask.Id) != null;
if (!taskManagedByUser)
{
methodResult.Message = "Task not managed by current User.";
return(methodResult);
}
findedUser.WorkTasks.Add(findedTask);
findedTask.Manager = findedUser;
_unitOfWork.WorkTaskUserRepository.Update(findedUser);
_unitOfWork.WorkTaskRepository.Update(findedTask);
}
else
{
methodResult.Success = false;
methodResult.Message = "User not found.";
return(methodResult);
}
methodResult.Success = true;
methodResult.Message = $"Added manager: {manager.Name}" +
$" to Task: {taskEntity.Name}.";
await _unitOfWork.SaveChangesAsync();
}
else
{
methodResult.Message = "Task not found.";
}
return(methodResult);
}
