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)); }