public async Task <ProjectDto?> UpdateAsync(int id, UpdateProjectDto update, CancellationToken cancellationToken) { var entity = await DbSet .Where(e => e.Id == id) .SingleOrDefaultAsync(cancellationToken); if (entity is null) { return(null); } fMapper.Map(update, entity); await fContext.SaveChangesAsync(cancellationToken); // TODO: Think this over so it could be used with mapper return(new ProjectDto { Id = entity.Id, Description = entity.Description, Name = entity.Name, CurrencyType = entity.CurrencyType, // TODO: It will probably be allways own because no other person cound update it, but it should not rely on it UserPermission = PermissionType.Own }); }
public void UpdateProject(UpdateProjectDto UpdateProjectDto) { try { var project = Db.Projects.SingleOrDefault(x => x.Id == UpdateProjectDto.Id); project.TeamLeaderId = UpdateProjectDto.TeamLeaderId; project.ProjectName = UpdateProjectDto.ProjectName; project.Description = UpdateProjectDto.Description; var projectDev = Db.ProjectDevelopers.Where(x => x.ProjectId == UpdateProjectDto.Id); foreach (var item in projectDev) { Db.ProjectDevelopers.Remove(item); } foreach (var item in UpdateProjectDto.DeveloperIds) { Db.ProjectDevelopers.Add(new ProjectDeveloper { DeveloperId = item, ProjectId = project.Id }); Db.SaveChanges(); } } catch (Exception) { throw; } }
public override string Execute() { Console.WriteLine($"Trying to update project {Name}..."); string message; var project = _projectService.GetProjectByName(Name).Result; if (project != null) { var dto = new UpdateProjectDto { Id = project.Id, Name = Rename ?? project.Name, DisplayName = DisplayName ?? project.DisplayName, Client = Client ?? project.Client }; _projectService.UpdateProject(project.Id, dto).Wait(); message = $"Project {Name} has been updated successfully"; Logger.LogInformation(message); } else { message = $"Project {Name} was not found"; } return(message); }
public async Task <IActionResult> UpdateProject(int id, [FromBody] UpdateProjectDto project) { if (project == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var projectEntity = await _projectManagerRepository.GetProjectByIdAsync(id); if (projectEntity == null) { _logger.LogInformation($"No project found with id {id}"); return(NotFound()); } Mapper.Map(project, projectEntity); if (!await _projectManagerRepository.SaveAsync()) { _logger.LogError($"An error occured deleting project id: {id}"); return(StatusCode(500, "A problem happened while handling your request.")); } return(NoContent()); }
public async Task <IActionResult> UpdateProject(int projectId, UpdateProjectDto updatedProject) { _logger.LogRequest("Updating project {projectId}. Request body: {@updatedProject}", projectId, updatedProject); try { if (projectId != updatedProject.Id) { _logger.LogWarning("Project Id doesn't match"); return(BadRequest("Project Id doesn't match.")); } var entity = _mapper.Map <Project>(updatedProject); await _projectService.UpdateProject(entity); _logger.LogResponse("Project {projectId} updated", projectId); return(Ok()); } catch (DuplicateProjectException dupEx) { _logger.LogWarning(dupEx, "Duplicate project name"); return(BadRequest(dupEx.Message)); } }
public async Task UpdateAsync() { var updateProjectDto = new UpdateProjectDto { Name = "ABP vNext", Format = "md", DefaultDocumentName = "index", NavigationDocumentName = "docs-nav.json", MinimumVersion = "1", MainWebsiteUrl = "abp.io", LatestVersionBranchName = "", ExtraProperties = new Dictionary <string, object>() }; updateProjectDto.ExtraProperties.Add("test", "test"); var projectDto = await _projectAdminAppService.UpdateAsync(_testData.PorjectId, updateProjectDto); projectDto.ShouldNotBeNull(); projectDto.Name.ShouldBe(updateProjectDto.Name); projectDto.Format.ShouldBe(updateProjectDto.Format); projectDto.DefaultDocumentName.ShouldBe(updateProjectDto.DefaultDocumentName); projectDto.NavigationDocumentName.ShouldBe(updateProjectDto.NavigationDocumentName); projectDto.MinimumVersion.ShouldBe(updateProjectDto.MinimumVersion); projectDto.MainWebsiteUrl.ShouldBe(updateProjectDto.MainWebsiteUrl); projectDto.LatestVersionBranchName.ShouldBe(updateProjectDto.LatestVersionBranchName); projectDto.ExtraProperties.ShouldContainKey("test"); }
public void Update(UpdateProjectDto project) { Guid Id = new Guid(project.Id); Project projectToUpdate = _repository.GetByFilter <Project>(p => p.Id == Id); if (projectToUpdate == null) { return; } if (project.Name != null) { projectToUpdate.Name = project.Name; } if (project.StartDate != null) { projectToUpdate.StartDate = project.StartDate; } if (project.EndDate != null) { projectToUpdate.EndDate = project.EndDate; } if (project.TechnologyStack != null) { projectToUpdate.TechnologyStack = project.TechnologyStack; } _repository.Update(projectToUpdate); _repository.Save(); }
public void UpdateProject(UpdateProjectDto input) { Logger.Info("Updating a project for input: " + input); var project = _projectRepository.Get(input.Id); project.State = input.State; if (input.Name != project.Name || input.Description != project.Description || input.StartTime != project.StartTime || input.DeliverTime != project.DeliverTime || input.TeamLeaderId != project.TeamLeaderId) { PermissionChecker.Authorize(PermissionNames.Pages_Projects_EditOthers); } project.Name = input.Name; project.Description = input.Description; project.StartTime = input.StartTime; project.DeliverTime = input.DeliverTime; if (input.TeamLeaderId.HasValue) { var user = _userRepository.Get(ObjectMapper.Map <long>(input.TeamLeaderId)); if (input.TeamLeaderId != project.TeamLeaderId) { string message = "A new project -- \"" + input.Name + "\" has being assigned to u."; _notificationPublisher.Publish("New Project", new MessageNotificationData(message), null, NotificationSeverity.Info, new[] { user.ToUserIdentifier() }); } project.TeamLeaderId = input.TeamLeaderId; project.TeamLeader = user; } }
public virtual async Task <ProjectDto> UpdateAsync(Guid id, UpdateProjectDto input) { return(await RequestAsync <ProjectDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue { { typeof(Guid), id }, { typeof(UpdateProjectDto), input } })); }
public ActionResult Edit(UpdateProjectDto updateProjectDto) { _projectAppService.UpdateProject(updateProjectDto); var input = new ProjectSearchInputDto(); var output = _projectAppService.SearchProjects(input); return(PartialView("_ListProjects", output.Projects)); }
public void Update(UpdateProjectDto dto) { var ProjectModel = _ProjectRepository.GetByKeyId(dto.KeyId); var createTime = ProjectModel.CreatedAt; ProjectModel = Mapper.Map <ProjectModel>(dto); ProjectModel.UpdatedAt = DateTime.Now; ProjectModel.CreatedAt = createTime; _ProjectRepository.Update(ProjectModel); }
public async Task <RequestResult <ProjectModel> > UdpateProjectAsync(UpdateProjectDto projectDto, List <SimpleUserModel> oldMembersCollection, List <SimpleUserModel> newMembersCollection) { var projectUpdateTask = _webClient.ExecuteRequestAsync(webApi => webApi.UpdateProject(projectDto)); var addedMembersIds = newMembersCollection.Except(oldMembersCollection, _modelsByIdComparer).Select(u => u.Id).ToList(); var removedMembersIds = oldMembersCollection.Except(newMembersCollection, _modelsByIdComparer).Select(u => u.Id).ToList(); var tasks = new List <Task>(); tasks.Add(projectUpdateTask); foreach (var addedMemberId in addedMembersIds) { var addDto = new CreateUpdateProjectMemberDto { UserId = addedMemberId, ProjectId = projectDto.Id, Role = (int)ProjectMemberRole.Implementer }; string requestId = RequestIdProvider.GetRequestId(); var addMemberTask = _webClient.ExecuteRequestAsync(webApi => webApi.AddMemberToProject(requestId, addDto)); tasks.Add(addMemberTask); } foreach (var removingMemberId in removedMembersIds) { var removeDto = new DeleteProjectMemberDto { UserId = removingMemberId, ProjectId = projectDto.Id }; string requestId = RequestIdProvider.GetRequestId(); var removeMemberTask = _webClient.ExecuteRequestAsync(webApi => webApi.RemoveMemberFromProject(removeDto)); tasks.Add(removeMemberTask); } await Task.WhenAll(tasks); foreach (var task in tasks) { task.ThrowIfFaulted(); } return(projectUpdateTask.Result); }
public IActionResult Update([FromBody] UpdateProjectDto projectDto) { var currentUserId = _httpContextAccessor.GetCurrentUserId(); var currentUser = _userService.Read(currentUserId); var project = _projectService.UpdateProject(currentUser, projectDto.ProjectId, projectDto.Title, projectDto.Content); if (project == null) { return(BadRequest(new { Message = "Failed to update project with specified ID." })); } return(Ok(_mapper.Map <UpdateProjectDto>(project))); }
public async Task <ActionResult <Project> > Put(string id, string code, UpdateProjectDto project) { try { var updatedProject = await _projectService.UpdateAsync(id, code, _mapper.Map <Project>(project)); return(Ok(updatedProject)); } catch (NotFoundException ex) { return(NotFound(new { error = ex.Message })); } }
/// <summary> /// this method is used for updating Project details into database /// </summary> /// <param name="project">Id of the project </param> /// <returns>updates project object</returns> public async Task <Project> UpdateProjectDetailsAsync(UpdateProjectDto project) { var sameProject = await _projectRepository.GetProjectByIdAsync(project.Id); if (sameProject == null) { throw new Exception("Project does not exist.");; } sameProject.Name = project.Name; sameProject.EndDate = project.EndDate; sameProject.StartDate = project.StartDate; sameProject.ProjectClient = project.ProjectClient; sameProject.ProjectDescription = project.ProjectDescription; await _projectRepository.SaveChangesAsync(); return(sameProject); }
public IActionResult Edit(UpdateProjectDto updateProjectDto) { var id = updateProjectDto.Id; if (ModelState.IsValid) { projectManagerRepository.UpdateProject(updateProjectDto); return(Redirect("ShowProjects")); } else { ViewBag.userId = User.FindFirst(ClaimTypes.NameIdentifier).Value; ViewBag.TeamLeaders = userLeaderRepository.GetTeamLeaders(); ViewBag.Developers = userDeveloperRepository.GetDevelopers(); ViewBag.Project = projectManagerRepository.GetProjectById(id); return(View()); } }
public async Task <ReadProjectDto> UpdateAsync(int id, string userId, UpdateProjectDto model) { var project = await _unitOfWork.ProjectRepository.GetProjectByIdWithDetailsAsync(id, true); if (project == null) { throw new TaskException($"Can't find project with id = {id}", HttpStatusCode.NotFound); } if (project.ManagerId != userId) { throw new TaskException($"Don't have permission to edit this project.", HttpStatusCode.Forbidden); } project.Title = model.Title; project.EndDate = model.EndDate; await _unitOfWork.SaveAsync(); var updatedProject = await _unitOfWork.ProjectRepository.GetProjectByIdWithDetailsAsync(id, false); _logger.LogInfo($"Updated project with id = {project.Id}."); return(_mapper.Map <ReadProjectDto>(updatedProject)); }
public async Task <ActionResult <Project> > UpdateProjectAsync([FromBody] UpdateProjectDto projectDetails) { return(Ok(await _projectService.UpdateProjectDetailsAsync(projectDetails))); }
public async Task UpdateProject(int projectId, UpdateProjectDto dto) { var path = $"project/{projectId}"; await Api.Put(path, dto); }
public Task <ProjectDto> UpdateAsync(Guid id, UpdateProjectDto input) { return(_projectAppService.UpdateAsync(id, input)); }
public IActionResult Update([FromBody] UpdateProjectDto projectDto) { _projectLogic.Update(projectDto); return(NoContent()); }
public async Task <ActionResult <ControllerResponse <GetProjectDto> > > update(string id, UpdateProjectDto projectIn) { string userId = _httpContextAccessor.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier).ToString(); var project = await _projectService.getByIdAsync(id); if (project.userId != userId) { throw new UnauthorizedAccessException("Project don't belong to you"); } project = _mapper.Map <UpdateProjectDto, Project>(projectIn, project); await _projectService.updateAsync(id, project); return(Ok(new ControllerResponse <GetProjectDto> { data = _mapper.Map <GetProjectDto>(project) })); }