public async Task <Result> UpdateWorkTaskUserAsync
(WorkTaskUserDto workTaskUserDto)
{
var result = new Result();
var findedUser = await _unitOfWork.WorkTaskUserRepository
.GetByMailAsync(workTaskUserDto.Mail);
if (findedUser == null)
{
result.Message = "User not found";
return(result);
}
var mappedUser = _userMapper.Map(workTaskUserDto);
mappedUser.Id = findedUser.Id;
_unitOfWork.WorkTaskUserRepository.Update(findedUser);
await _unitOfWork.SaveChangesAsync();
result.Success = true;
result.Message = $"User({workTaskUserDto.Name}) created.";
return(result);
}
/// <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);
}
}
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 async Task <IHttpActionResult> Register(RegisterUserViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApplicationUser()
{
UserName = model.Email, Email = model.Email
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
byte role = 1;
if (model.Role == "manager")
{
role = 2;
}
WorkTaskUserDto workTaskUserDto = new WorkTaskUserDto
{
Name = model.Name,
FullName = model.FullName,
Mail = model.Email,
Role = role
};
var creationResult = await userService.CreateWorkTaskUserAsync
(workTaskUserDto);
if (!creationResult.Success)
{
return(BadRequest());
}
return(Ok());
}
/// <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);
}
public async Task <Result> CreateWorkTaskUserAsync
(WorkTaskUserDto workTaskUserDto)
{
var result = new Result();
var workTaskUserEntity = _userMapper.Map(workTaskUserDto);
if (workTaskUserDto.Name == string.Empty ||
workTaskUserDto.Mail == string.Empty)
{
result.Message = "Can'nt create user. Mail or name are wrong.";
return(result);
}
_unitOfWork.WorkTaskUserRepository.Add(workTaskUserEntity);
await _unitOfWork.SaveChangesAsync();
result.Message = $"Created user (Name: {workTaskUserDto.Name}," +
$" Mail: {workTaskUserDto.Mail}).";
result.Success = true;
return(result);
}
/// <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);
}
