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