public async Task <Response <ProjectDTO> > Update(Guid projectId, ProjectUpdateDTO dto, ClaimsPrincipal claims)
{
var result = await _service.Update(projectId, claims.GetUserId(), dto);
// await BroadcastChanges(result, ChangesType.Updated);
return(result);
}
/// <summary>
/// Updates the details of a project.
/// </summary>
/// <param name="project">The project details that need to be updated.</param>
/// <param name="userObjectId">The user object id who is going to update a project.</param>
/// <returns>Return true if project is updated, else return false.</returns>
public async Task <bool> UpdateProjectAsync(ProjectUpdateDTO project, Guid userObjectId)
{
project = project ?? throw new ArgumentException("The project details must be provided.");
// Null check is not required, policy has already taken care of it.
var projectDetails = await this.repositoryAccessors.ProjectRepository.GetProjectByIdAsync(project.Id, userObjectId);
this.projectMapper.MapForUpdateModel(project, projectDetails);
using (var transaction = this.repositoryAccessors.Context.Database.BeginTransaction())
{
try
{
this.repositoryAccessors.ProjectRepository.Update(projectDetails);
if (await this.context.SaveChangesAsync() > 0)
{
transaction.Commit();
return(true);
}
}
#pragma warning disable CA1031 // Catching general exception to roll-back transaction.
catch
#pragma warning restore CA1031 // Catching general exception to roll-back transaction.
{
transaction.Rollback();
}
}
return(false);
}
public async Task <ProjectDTO> UpdateProject(ProjectUpdateDTO projectDto)
{
var projectEntity = await repository.GetById(projectDto.Id);
if (projectEntity == null)
{
throw new NotFoundException(nameof(Project), projectDto.Id);
}
if (projectEntity.Deadline <= projectEntity.CreatedAt)
{
throw new ArgumentException("Deadline of a created project must be later then created date");
}
await teamService.GetTeamById(projectDto.TeamId);
await userService.GetUserById(projectDto.AuthorId);
projectEntity.Name = projectDto.Name;
projectEntity.Description = projectDto.Description;
projectEntity.Deadline = projectDto.Deadline;
projectEntity.AuthorId = projectDto.AuthorId;
projectEntity.TeamId = projectDto.TeamId;
await repository.Update(projectEntity);
await unitOfWork.SaveChangesAsync();
return((await GetAllProjects()).FirstOrDefault(p => p.Id == projectEntity.Id));
}
public ActionResult UpdateProject(int id, ProjectUpdateDTO projectUpdateDto)
{
var projectModelfromRepo = _repository.GetProjectDataById(id);
if (projectModelfromRepo == null)
{
_logger.LogError("The project with ID: " + id + " doesn't exist.");
return(NotFound(_repository.ErrorDescription(HttpStatusCode.NotFound)));
}
else
{
_mapper.Map(projectUpdateDto, projectModelfromRepo);
_logger.LogInformation("Updating project " + projectModelfromRepo.Name + ".");
_repository.UpdateProject(projectModelfromRepo, id);
if (!_repository.SaveChanges())
{
return(StatusCode(500, new { message = "Internal Server error 500." + "Something went wrong" }));
}
else
{
return(NoContent());
}
}
}
public async Task <ActionResult <ProjectInfoDTO> > UpdateProject([FromBody] ProjectUpdateDTO project)
{
var updatedProject = await _projectService.UpdateProject(project);
_logger.LogInformation(LoggingEvents.UpdateItem, $"Project updated {project.Id}");
return(Ok(updatedProject));
}
public async Task <ProjectDTO> UpdateProject(ProjectUpdateDTO project)
{
var response = await client.PutAsJsonAsync($"{baseUrl}/api/projects", project);
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
throw new Exception($"{response.StatusCode} : {await response.Content.ReadAsStringAsync()}");
}
return(await response.Content.ReadAsAsync <ProjectDTO>());
}
/// <summary>
/// Gets project model to be updated in database.
/// </summary>
/// <param name="projectViewModel">Project entity view model.</param>
/// <param name="projectModel">Project entity model.</param>
/// <returns>Returns a project entity model.</returns>
public Project MapForUpdateModel(ProjectUpdateDTO projectViewModel, Project projectModel)
{
projectViewModel = projectViewModel ?? throw new ArgumentNullException(nameof(projectViewModel));
projectModel = projectModel ?? throw new ArgumentNullException(nameof(projectModel));
projectModel.BillableHours = projectViewModel.BillableHours;
projectModel.ClientName = projectViewModel.ClientName;
projectModel.EndDate = projectViewModel.EndDate;
projectModel.NonBillableHours = projectViewModel.NonBillableHours;
projectModel.StartDate = projectViewModel.StartDate;
projectModel.Title = projectViewModel.Title;
return(projectModel);
}
public async Task <ActionResult <ProjectDTO> > UpdateAsync([FromBody] ProjectUpdateDTO project)
{
try
{
return(Ok(await service.UpdateAsync(project)));
}
catch (NotFoundException e)
{
return(NotFound(new { Id = e.Key, e.Message }));
}
catch (ValidationException e)
{
return(BadRequest(e.ValidationErrors));
}
}
public async Task UpdateProject_WhenProjectDetailsAreNull_ShouldThrowArgumentException()
{
// ARRANGE
this.repositoryAccessors.Setup(repositoryAccessor => repositoryAccessor.ProjectRepository).Returns(() => this.projectRepository.Object);
ProjectUpdateDTO nullProjectUpdateDTO = null;
var managerId = Guid.NewGuid();
try
{
// ACT
var isUpdated = await this.projectHelper.UpdateProjectAsync(nullProjectUpdateDTO, managerId);
}
catch (ArgumentException exception)
{
// ASSERT
Assert.AreEqual("The project details must be provided.", exception.Message);
this.projectRepository.Verify(projectRepo => projectRepo.GetProjectByIdAsync(It.IsAny <Guid>(), It.IsAny <Guid>()), Times.Never());
this.projectRepository.Verify(projectRepo => projectRepo.Update(It.IsAny <Project>()), Times.Never());
}
}
public ActionResult UpdateProject([FromRoute] Guid projectId, [FromBody] ProjectUpdateDTO projectData)
{
if (projectId == null || projectId == new Guid())
{
return(BadRequest(new { Message = $"Error: el parametro {nameof(projectId)} no puede ser nulo." }));
}
if (!ModelState.IsValid)
{
return(BadRequest(new
{
Message = "La informacion de registro de skills de usuario invalidos.",
ErrorsCount = ModelState.ErrorCount,
Errors = ModelState.Select(x => x.Value.Errors)
}));
}
var projectToUpdate = this._appDBContext.Projects.FirstOrDefault(item => item.Id == projectId);
if (projectToUpdate != null)
{
this._mapper.Map <ProjectUpdateDTO, Project>(projectData, projectToUpdate);
var tempProjectToUpdate = this._appDBContext.Projects.Update(projectToUpdate);
this._appDBContext.SaveChanges();
var projectModel = this._mapper.Map <ProjectResponseDTO>(tempProjectToUpdate.Entity);
return(Ok(new
{
Message = "Ok",
Result = projectModel
}));
}
else
{
return(NotFound(new { Message = "El recurso a actualizar no ha sido encontrado." }));
}
}
public async Task <ProjectInfoDTO> UpdateProject(ProjectUpdateDTO projectUpdateDTO)
{
var targetProject = await _context.Projects.SingleOrDefaultAsync(p => p.Id == projectUpdateDTO.Id);
if (targetProject == null)
{
_logger.LogWarning(LoggingEvents.HaveException, $"update project not found");
throw new NotFoundException(nameof(targetProject), projectUpdateDTO.Id);
}
targetProject.Name = projectUpdateDTO.Name;
targetProject.Description = projectUpdateDTO.Description;
targetProject.CountOfBuildAttempts = projectUpdateDTO.CountOfBuildAttempts;
targetProject.CountOfSaveBuilds = projectUpdateDTO.CountOfSaveBuilds;
targetProject.AccessModifier = projectUpdateDTO.AccessModifier;
targetProject.Color = projectUpdateDTO.Color;
_context.Projects.Update(targetProject);
await _context.SaveChangesAsync();
_logger.LogInformation($"project updated {projectUpdateDTO.Id}");
return(await GetProjectById(projectUpdateDTO.Id));
}
public async Task <IActionResult> UpdateProjectAsync([FromQuery] Guid projectId, [FromBody] ProjectUpdateDTO projectDetails)
{
this.RecordEvent("Update project- The HTTP PATCH call has initiated.", RequestType.Initiated, new Dictionary <string, string>
{
{ "projectId", Convert.ToString(projectId, CultureInfo.InvariantCulture) },
});
#pragma warning disable CA1062 // Null check is handled by data annotations.
projectDetails.Id = projectId;
#pragma warning restore CA1062 // Null check is handled by data annotations.
try
{
var updateResult = await this.projectHelper.UpdateProjectAsync(projectDetails, Guid.Parse(this.UserAadId));
if (!updateResult)
{
this.RecordEvent("Update project- The HTTP PATCH call has failed.", RequestType.Failed);
return(this.StatusCode((int)HttpStatusCode.InternalServerError, new ErrorResponse {
Message = "Error occurred while updating project."
}));
}
this.RecordEvent("Update project- The HTTP PATCH call has succeeded.", RequestType.Succeeded);
return(this.NoContent());
}
catch (Exception ex)
{
this.RecordEvent("Update project- The HTTP PATCH call has failed.", RequestType.Failed);
this.logger.LogError(ex, "Error occurred while updating project.");
throw;
}
}
public async Task <Response <ProjectDTO> > Update(Guid projectId, Guid userId, ProjectUpdateDTO dto)
{
var projectEntity = await _repository.GetById(projectId);
if (projectEntity == null)
{
return(new BusinessConflictErrorResponse <ProjectDTO>(new []
{
new Error
{
Code = ErrorCodes.Common.NotFound,
Message = ErrorMessages.Common.NotFound,
Field = "projectId"
}
}));
}
var projectUser = await _projectsUsersRepository.GetProjectUser(projectId, userId);
if (projectUser == null)
{
return(new BusinessConflictErrorResponse <ProjectDTO>(new []
{
new Error
{
Code = ErrorCodes.Common.NotFound,
Message = ErrorMessages.Common.NotFound,
Field = "userId"
}
}));
}
if (projectUser.Status != MembershipStatus.SuperAdmin)
{
return(new ForbiddenErrorResponse <ProjectDTO>(new []
{
new Error
{
Code = ErrorCodes.Security.Forbidden,
Message = ErrorMessages.Security.Forbidden
}
}));
}
projectEntity.Name = dto.Name;
projectEntity.ColorHex = dto.ColorHex;
projectEntity = await _repository.Update(projectEntity);
var result = _mapper.Map <ProjectModel, ProjectDTO>(projectEntity);
return(new Response <ProjectDTO>
{
Data = result
});
}
public async Task <ActionResult <ProjectDTO> > Put([FromBody] ProjectUpdateDTO team)
{
return(Ok(await projectService.UpdateProject(team)));
}
public async static Task <HttpResponseMessage> EditProject(this HttpClient client, ProjectUpdateDTO project)
{
var payload = JsonConvert.SerializeObject(project);
var httpContent = new StringContent(payload, Encoding.UTF8, "application/json");
var response = await client.PutAsync("api/projects/edit", httpContent);
response.EnsureSuccessStatusCode();
return(response);
}
public async Task <Response <ProjectDTO> > UpdateProject([Required, FromRoute] Guid id, [Required, FromBody] ProjectUpdateDTO dto)
{
return(await _handler.Update(id, dto, User));
}
