public async Task <ActionResult <List <ManagerViewModel> > > GetProjectManagersAsync(Guid projectId)
{
if (projectId == Guid.Empty)
{
return(BadRequest("No valid id received"));
}
try
{
TaskListResult <Manager> result = await personService.GetManagersAsync(projectId);
//get users from b2c and add tot DTO
foreach (Manager manager in result.Data)
{
User temp = (await personService.GetUserAsync(manager.PersonId)).Data;
if (temp == null)
{
continue;
}
PersonViewModel vm =
PersonViewModel.CreateVmFromUser(temp, Extensions.GetInstance(b2CExtentionApplicationId));
if (vm == null)
{
continue;
}
Person person = PersonViewModel.CreatePerson(vm);
manager.Person = person;
}
if (!result.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = result.Message
}));
}
if (result.Data == null || result.Data.Count == 0)
{
return(Ok(new List <ManagerViewModel>()));
}
List <ManagerViewModel> managerVmList = result.Data.Select(ManagerViewModel.CreateVm).ToList();
return(Ok(managerVmList));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(GetProjectManagersAsync);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
public async Task <ActionResult <PersonViewModel> > MakeManagerAsync(Guid projectId, Guid userId)
{
if (projectId == Guid.Empty || userId == Guid.Empty)
{
BadRequest("No valid Ids received.");
}
try
{
Project project = (await projectService.GetProjectDetailsAsync(projectId)).Data;
if (project == null)
{
return(BadRequest("Could not find project"));
}
User user = (await personService.GetUserAsync(userId)).Data;
if (user == null)
{
return(BadRequest("Could not find user"));
}
Person person = (await personService.GetPersonAsync(userId)).Data;
if (person == null)
{
return(BadRequest("Could not find person in DB"));
}
Manager manager = (await personService.GetManagerAsync(projectId, userId)).Data;
if (manager != null)
{
return(BadRequest("User already manages this project"));
}
PersonViewModel viewModel = PersonViewModel.CreateVmFromUserAndPerson(user, person,
Extensions.GetInstance(b2CExtentionApplicationId));
if (viewModel == null)
{
return(BadRequest("Unable to create manager"));
}
string oid = IdentityHelper.GetOid(HttpContext.User.Identity as ClaimsIdentity);
manager = new Manager
{
ProjectId = project.Id,
Project = project,
PersonId = person.Id,
Person = person,
LastEditBy = oid
};
TaskResult <Manager> result = await personService.MakeManagerAsync(manager);
if (viewModel.UserRole != "Boardmember")
{
await ModAdminAsync(userId, 2); //make user a manager in B2C
}
if (!result.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = result.Message
}));
}
return(Ok(PersonViewModel.CreateVmFromUser(user, Extensions.GetInstance(b2CExtentionApplicationId))));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(MakeManagerAsync);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
public async Task <ActionResult <PersonViewModel> > UpdatePerson(PersonViewModel personViewModel)
{
if (personViewModel == null || personViewModel.Id == Guid.Empty)
{
return(BadRequest("Invalid Person"));
}
try
{
TaskResult <Person> personResult = await personService.GetPersonAsync(personViewModel.Id);
if (personResult == null)
{
return(NotFound("Person not found in database"));
}
if (!personResult.Data.RowVersion.SequenceEqual(personViewModel.RowVersion))
{
return(BadRequest("Outdated entity received"));
}
Person person = personResult.Data;
bool userIsCommitteemember = UserHasRole(UserRole.Committeemember,
(ClaimsIdentity)HttpContext.User.Identity);
bool userIsBoardmember = UserHasRole(UserRole.Boardmember,
(ClaimsIdentity)HttpContext.User.Identity);
person.PushDisabled = personViewModel.PushDisabled;
person.PersonalRemark = personViewModel.PersonalRemark;
foreach (Certificate certificate in person.Certificates)
{
certificate.CertificateType = null;
}
if (userIsBoardmember || userIsCommitteemember) //staff
{
person.StaffRemark = personViewModel.StaffRemark;
}
if (personViewModel.ProfilePicture != null)
{
person.ProfilePictureId = personViewModel.ProfilePicture.Id;
}
TaskResult <Person> result = await personService.UpdatePersonAsync(person);
if (!result.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = result.Message
}));
}
personViewModel.LastEditBy = result.Data.LastEditBy;
personViewModel.LastEditDate = result.Data.LastEditDate;
personViewModel.RowVersion = result.Data.RowVersion;
return(Ok(personViewModel));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(UpdatePerson);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
