public IActionResult ShowEditProject(int projectId)
{
var project = projectRepository.GetProject(projectId);
var projectDevelopers = project.ProjectsDevelopers.Select(x => x.Developer).ToList();
var developers = developerRepository.GetDevelopers();
var teamLeaders = teamLeaderRepository.GetTeamLeaders();
List <string> Ids = new List <string>();
foreach (var developer in project.ProjectsDevelopers)
{
developers.Remove(developer.Developer);
}
foreach (var developer in project.ProjectsDevelopers)
{
Ids.Add(developer.DeveloperID);
}
ViewBag.unselectedDevelopers = developers;
ViewBag.selectedDevelopers = projectDevelopers;
teamLeaders.Remove(project.TeamLeader);
ViewBag.unselectedLeaders = teamLeaders;
var projectDto = new EditProjectDto()
{
ID = project.ID,
ProjectTitle = project.ProjectTitle,
Description = project.Description,
Status = project.Status,
TeamLeader = project.TeamLeader,
TeamLeaderID = project.TeamLeaderID,
ProjectManagerID = project.ProjectManagerID,
developersIds = Ids
};
return(View("Edit", projectDto));
}
public void Add_ShouldReturnProjectDto()
{
// Arrange
var mock = new Mock <IProjectRepository>();
mock.Setup(x => x.Add(It.IsAny <Project>()));
mock.Setup(x => x.Save()).Returns(true);
var service = new ProjectService(mock.Object, _mapper);
var editProjectDto = new EditProjectDto
{
Code = "FGDGDF",
Name = "Project test name",
StartDate = new DateTime(2019, 5, 10),
FinishDate = new DateTime(2019, 5, 20)
};
// Act
var projectDto = service.Add(editProjectDto);
// Assert
Assert.AreEqual("FGDGDF", projectDto.Code);
Assert.AreEqual("Project test name", projectDto.Name);
Assert.AreEqual(new DateTime(2019, 5, 10), projectDto.StartDate);
Assert.AreEqual(new DateTime(2019, 5, 20), projectDto.FinishDate);
}
public void Update_ShouldThrowExceptionIfUpdateWasNotSucceed()
{
// Arrange
var mock = new Mock <IProjectRepository>();
mock.Setup(x => x.Update(It.IsAny <Project>()));
mock.Setup(x => x.Save()).Returns(false);
mock.Setup(x => x.Get(5)).Returns(new Project
{
Id = 5,
Code = "JHGGGGG",
Name = "Old project name",
State = ProjectState.Completed,
ParentId = 2,
StartDate = new DateTime(2019, 2, 10),
FinishDate = new DateTime(2019, 2, 20)
});
var service = new ProjectService(mock.Object, _mapper);
var editProjectDto = new EditProjectDto
{
Code = "FGDGDF",
Name = "Project test name",
StartDate = new DateTime(2019, 5, 10),
FinishDate = new DateTime(2019, 5, 20)
};
// Assert
Assert.Throws <PmsException>(() => service.Update(5, editProjectDto));
}
public void EditProject(EditProjectDto editProject)
{
var project = db.Projects.Where(x => x.Id == editProject.Id).SingleOrDefault();
project.Title = editProject.Title;
project.Description = editProject.Description;
project.TeamleaderId = editProject.TeamLeaderId;
db.SaveChanges();
//***********Developer***********
var dev = db.ProjectDevelopers.Where(x => x.ProjectId == editProject.Id).ToList();
db.SaveChanges();
foreach (var item in dev)
{
db.ProjectDevelopers.Remove(item);
}
db.SaveChanges();
foreach (var item in editProject.DeveloperIds)
{
db.ProjectDevelopers.Add(new ProjectDeveloper {
ProjectId = editProject.Id, DeveloperId = item
});
}
db.SaveChanges();
}
private async Task UpdateProjectWallModeratorAsync(EditProjectDto dto, Project project)
{
if (project.Wall.Moderators.Any())
{
var currentModeratorId = project.Wall.Moderators.First().UserId;
if (currentModeratorId == dto.OwningUserId)
{
return;
}
if (!dto.MembersIds.Contains(currentModeratorId))
{
await _wallService.RemoveMemberFromWallAsync(currentModeratorId, project.WallId);
}
await _wallService.RemoveModeratorAsync(project.WallId, project.Wall.Moderators.First().UserId, dto);
await _wallService.AddModeratorAsync(project.WallId, dto.OwningUserId, dto);
}
else
{
await _wallService.AddModeratorAsync(project.WallId, dto.OwningUserId, dto);
}
}
public void EditProject(EditProjectDto projectDto)
{
var project = GetProject(projectDto.ID);
project.ProjectTitle = projectDto.ProjectTitle;
project.Description = projectDto.Description;
project.TeamLeaderID = projectDto.TeamLeaderID;
project.ProjectManagerID = projectDto.ProjectManagerID;
foreach (var projectDeveloper in project.ProjectsDevelopers)
{
context.ProjectsDevelopers.Remove(projectDeveloper);
}
context.SaveChanges();
foreach (var developerId in projectDto.developersIds)
{
context.ProjectsDevelopers.Add(new ProjectsDevelopers()
{
DeveloperID = developerId,
ProjectID = project.ID
});
}
context.SaveChanges();
context.Projects.Update(project);
context.SaveChanges();
}
public IActionResult ApplayEdit(EditProjectDto projectDto)
{
var userId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
projectDto.ProjectManagerID = userId;
projectRepository.EditProject(projectDto);
return(RedirectToAction("ShowProjectManagerProjects"));
}
public IActionResult EditProject(int projectId, [FromBody] EditProjectDto projectDto)
{
try
{
projectRepository.EditProject(projectDto);
return(Ok());
}
catch (Exception)
{
return(BadRequest("Invalid data."));
}
}
private void UpdateWall(EditProjectDto dto, int wallId)
{
var updateWallDto = new UpdateWallDto
{
Id = wallId,
Description = dto.Description,
Logo = dto.Logo,
Name = dto.Title,
OrganizationId = dto.OrganizationId,
UserId = dto.UserId
};
_wallService.UpdateWall(updateWallDto);
}
public ProjectDto Add(EditProjectDto projectDto)
{
var project = _mapper.Map <Project>(projectDto);
project.State = ProjectState.Planned;
_projectRepository.Add(project);
if (!_projectRepository.Save())
{
throw new PmsException("Create a project failed on save");
}
return(_mapper.Map <ProjectDto>(project));
}
private async Task UpdateWallAsync(EditProjectDto dto, int wallId)
{
var updateWallDto = new UpdateWallDto
{
Id = wallId,
Description = dto.Description,
Logo = dto.Logo,
Name = dto.Title,
OrganizationId = dto.OrganizationId,
UserId = dto.UserId
};
await _wallService.UpdateWallAsync(updateWallDto);
}
public void Update(int id, EditProjectDto projectDto)
{
var project = _projectRepository.Get(id);
project.Code = projectDto.Code;
project.Name = projectDto.Name;
project.StartDate = projectDto.StartDate;
project.FinishDate = projectDto.FinishDate;
_projectRepository.Update(project);
if (!_projectRepository.Save())
{
throw new PmsException($"Updating project {project.Id} failed on save.");
}
}
public ActionResult CreateProject([FromBody] EditProjectDto projectDto)
{
if (projectDto == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
var addedProject = _projectService.Add(projectDto);
return(CreatedAtAction("CreateProject", new { id = addedProject.Id }, addedProject));
}
public async Task EditProject(EditProjectDto dto)
{
var project = await _projectsDbSet
.Include(p => p.Members)
.Include(p => p.Wall.Members)
.Include(p => p.Wall.Moderators)
.Include(p => p.Attributes)
.FirstOrDefaultAsync(p =>
p.Id == dto.Id &&
p.OrganizationId == dto.OrganizationId);
if (project == null)
{
throw new ValidationException(ErrorCodes.ContentDoesNotExist, "Project not found");
}
ValidateOwnershipPermissions(project.OwnerId, dto);
if (project.OwnerId != dto.OwningUserId)
{
var owningUserExists = await _usersDbSet.AnyAsync(u => u.Id == dto.OwningUserId && u.OrganizationId == dto.OrganizationId);
if (!owningUserExists)
{
throw new ValidationException(ErrorCodes.ContentDoesNotExist, "User not found");
}
}
project.Members = await _usersDbSet.Where(x => dto.MembersIds.Contains(x.Id)).ToListAsync();
_wallService.ReplaceMembersInWall(project.Members.ToList(), project.WallId, dto.UserId);
var completeListOfAttributes = await ManageProjectAttributes(dto.Attributes);
project.Name = dto.Title;
project.Desc = dto.Description;
project.Logo = dto.Logo;
project.OwnerId = dto.OwningUserId;
project.Attributes = completeListOfAttributes.ToList();
UpdateProjectWallModerator(dto, project);
UpdateWall(dto, project.WallId);
await _uow.SaveChangesAsync(dto.UserId);
}
public IActionResult Edit(EditProjectDto editProjectDto)
{
var id = editProjectDto.Id;
if (ModelState.IsValid)
{
managerRepository.EditProject(editProjectDto);
return(Redirect("ShowProjets"));
}
else
{
ViewBag.userId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
ViewBag.Developers = userDeveloperRepository.GetAllDevelopers();
ViewBag.TeamLeaders = userTeamLeaderRepository.GetAllTeamLeaders();
ViewBag.project = userManagerRepository.GetProjectById(id);
return(View());
}
}
public IActionResult UpdateProject(Guid projectId, [FromBody] EditProjectDto projectDto)
{
if (projectDto == null || projectId != projectDto.Id || !ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var projectExists = _db.Projects.Any(x => x.Id == projectId);
if (!projectExists)
{
return(NotFound("پروژه یافت نشد."));
}
var projectNameExists = _db.Projects.Any(x => x.Id != projectDto.Id && x.Name == projectDto.Name);
if (projectNameExists)
{
ModelState.AddModelError("", "نام پروژه تکراری می باشد.");
return(StatusCode(409, ModelState));
}
if (!Enum.IsDefined(typeof(Priority), projectDto.Priority))
{
ModelState.AddModelError("", "اولویت پروژه مشخص نشده است.");
return(StatusCode(400, ModelState));
}
var project = _mapper.Map <Project>(projectDto);
try
{
_db.Projects.Update(project);
_db.SaveChanges();
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(StatusCode(500, ModelState));
}
return(NoContent());
}
public void Add_ShouldThrowExceptionIfSaveWasNotSucceed()
{
// Arrange
var mock = new Mock <IProjectRepository>();
mock.Setup(x => x.Add(It.IsAny <Project>()));
mock.Setup(x => x.Save()).Returns(false);
var service = new ProjectService(mock.Object, _mapper);
var editProjectDto = new EditProjectDto
{
Code = "FGDGDF",
Name = "Project test name",
StartDate = new DateTime(2019, 5, 10),
FinishDate = new DateTime(2019, 5, 20)
};
// Assert
Assert.Throws <PmsException>(() => service.Add(editProjectDto));
}
public ActionResult UpdateProject(int id, [FromBody] EditProjectDto projectDto)
{
if (projectDto == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
if (!_projectService.Exist(id))
{
return(NotFound());
}
_projectService.Update(id, projectDto);
return(NoContent());
}
public void Update_ShouldPassProjectToRepositoryMethod()
{
// Arrange
var updatedProject = new Project();
var mock = new Mock <IProjectRepository>();
mock.Setup(x => x.Update(It.IsAny <Project>()))
.Callback <Project>(proj => updatedProject = proj);
mock.Setup(x => x.Save()).Returns(true);
mock.Setup(x => x.Get(5)).Returns(new Project
{
Id = 5,
Code = "JHGGGGG",
Name = "Old project name",
State = ProjectState.Completed,
ParentId = 2,
StartDate = new DateTime(2019, 2, 10),
FinishDate = new DateTime(2019, 2, 20)
});
var service = new ProjectService(mock.Object, _mapper);
var editProjectDto = new EditProjectDto
{
Code = "FGDGDF",
Name = "Project test name",
StartDate = new DateTime(2019, 5, 10),
FinishDate = new DateTime(2019, 5, 20)
};
// Act
service.Update(5, editProjectDto);
// Assert
Assert.AreEqual("FGDGDF", updatedProject.Code);
Assert.AreEqual("Project test name", updatedProject.Name);
Assert.AreEqual(new DateTime(2019, 5, 10), updatedProject.StartDate);
Assert.AreEqual(new DateTime(2019, 5, 20), updatedProject.FinishDate);
Assert.AreEqual(5, updatedProject.Id);
Assert.AreEqual(ProjectState.Completed, updatedProject.State);
Assert.AreEqual(2, updatedProject.ParentId);
}
private void UpdateProjectWallModerator(EditProjectDto dto, Project project)
{
if (project.Wall.Moderators.Any())
{
var currentModeratorId = project.Wall.Moderators.First().UserId;
if (currentModeratorId != dto.OwningUserId)
{
if (!dto.MembersIds.Contains(currentModeratorId))
{
_wallService.RemoveMemberFromWall(currentModeratorId, project.WallId);
}
_wallService.RemoveModerator(project.WallId, project.Wall.Moderators.First().UserId, dto);
_wallService.AddModerator(project.WallId, dto.OwningUserId, dto);
}
}
else
{
_wallService.AddModerator(project.WallId, dto.OwningUserId, dto);
}
}
public IActionResult Edit(EditProjectDto editProjectDto)
{
projectRepository.EditProject(editProjectDto);
return(Redirect("AllProjects"));
}
