public async Task <ProjectShortDto> UpdateProject(ProjectUpdateDto update)
{
try
{
await database.Connect().ConfigureAwait(false);
var getFilter = new EqualityFilter <ObjectId>("_id", update.ProjectID);
Project project = (await database.Get(getFilter).ConfigureAwait(false)).FirstOrDefault();
if (project is null)
{
throw new ArgumentException("No project was found for given ID");
}
UpdateProject(project, update);
await database.Update(project).ConfigureAwait(false);
return(new ProjectShortDto(project));
}
catch (Exception ex) when(ex.GetType() != typeof(ArgumentException))
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
throw new DatabaseException("Error ocurred while updating project");
}
}
public async void UpdateProjectTest(Status expectedStatus)
{
var projectDto = new ProjectUpdateDto
{
Id = Guid.NewGuid(),
Title = RandomHelper.RandomString(),
Description = RandomHelper.RandomString(350)
};
var project = EntitiesFactory.NewProject(id: projectDto.Id).Get();
var projects = new[] { project }.AsQueryable().BuildMock();
_projectRepository.Setup(d => d.ExistAsync(projectDto.Id))
.ReturnsAsync(expectedStatus != Status.NotFund);
_projectRepository.Setup(d => d.Query())
.Returns(projects.Object);
_projectRepository.Setup(d => d.ExistByTitleAsync(projectDto.Title, projectDto.Id))
.ReturnsAsync(expectedStatus == Status.Conflict);
var service = new ProjectService(_projectRepository.Object, _workRepository.Object);
var result = await service.UpdateProjectAsync(projectDto);
Assert.Equal(expectedStatus, result.Status);
if (expectedStatus == Status.Success)
{
_projectRepository.Verify(d => d.UpdateAsync(project), Times.Once);
Assert.Equal(projectDto.Title, project.Title);
Assert.Equal(projectDto.Description, project.Description);
}
else
{
_projectRepository.Verify(d => d.UpdateAsync(project), Times.Never);
}
}
public async Task <Result> UpdateProjectAsync(ProjectUpdateDto projectDto)
{
var existProject = await _projectRepository.ExistAsync(projectDto.Id);
if (!existProject)
{
return(new Result(Status.NotFund, $"Project with {nameof(projectDto.Id)} does not exist"));
}
var existTitle = await _projectRepository.ExistByTitleAsync(projectDto.Title, projectDto.Id);
if (existTitle)
{
return(new Result(Status.Conflict, $"Project with {nameof(projectDto.Title)} already exist"));
}
var project = await _projectRepository.Query()
.Include(p => p.DeveloperProjects)
.FirstOrDefaultAsync(p => p.Id == projectDto.Id);
project.SetData(
title: projectDto.Title,
description: projectDto.Description,
developerProjects: GetDeveloperProjects(projectDto.DeveloperIds, project.Id)
);
await _projectRepository.UpdateAsync(project);
return(new Result());
}
public async Task <IActionResult> UpdateProject()
{
try
{
string requestBody = await requestService.GetRequestBody(Request).ConfigureAwait(false);
ProjectUpdateDto update = JsonConvert.DeserializeObject <ProjectUpdateDto>(requestBody);
ProjectShortDto updatedProject = await projectService.UpdateProject(update).ConfigureAwait(false);
return(new OkJson <ProjectShortDto>(updatedProject));
}
catch (FormatException ex)
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
return(new BadSentRequest <string>("One of query params was not in correct format"));
}
catch (ArgumentException ex)
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
return(new BadSentRequest <string>(ex.Message));
}
catch (DatabaseException ex)
{
return(new InternalServerError(ex.Message));
}
catch (Exception ex)
{
exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
return(new InternalServerError());
}
}
public async void UpdateProjectTest()
{
var developer = EntitiesFactory.NewDeveloper().Save();
var project = EntitiesFactory.NewProject().Save();
var projectDto = new ProjectUpdateDto
{
Id = project.Id,
Title = RandomHelper.RandomString(),
Description = RandomHelper.RandomString(490),
DeveloperIds = new[] { developer.Id }
};
var(status, result) = await Request.PutAsync <ResultTest>(new Uri($"{Uri}/{project.Id}"), projectDto);
var projectDb = await DbContext.Projects
.Include(p => p.DeveloperProjects)
.SingleAsync(p => p.Id == projectDto.Id);
await DbContext.Entry(projectDb).ReloadAsync();
Assert.Equal(Status.Success, status);
Assert.True(result.Success);
Assert.Equal(projectDto.Title, projectDb.Title);
Assert.Equal(projectDto.Description, projectDb.Description);
Assert.Single(projectDb.DeveloperProjects);
Assert.Contains(projectDb.DeveloperProjects, d => d.DeveloperId == developer.Id);
}
public async Task <bool> UpdateAsync(ProjectUpdateDto dto)
{
var dbSet = _context.Projects;
var entity = dbSet.FirstOrDefault(r => r.Id == dto.Id);
_mapper.Map(dto, entity);
return(await _context.SaveChangesAsync() > 0);
}
/// <inheritdoc/>
public Project UpdateProject(ProjectUpdateDto dto)
{
var now = DateUtil.Now;
var entity = _projectRepository.Read(new ProjectTableEntity {
ProjectId = dto.ProjectId
});
if (dto.ProjectCode != null)
{
entity.ProjectCode = dto.ProjectCode;
}
if (dto.Name != null)
{
entity.Name = dto.Name;
}
if (dto.Description != null)
{
entity.Description = dto.Description;
}
if (dto.Status != null)
{
entity.Status = dto.Status;
}
if (dto.SortNo != null)
{
entity.SortNo = dto.SortNo.Value;
}
entity.UpdateTime = now;
using (var tran = new TransactionScope())
{
_projectRepository.Update(entity);
if (dto.Tags != null)
{
_tagRepository.DeleteByTargetId(dto.ProjectId);
foreach (var tag in dto.Tags)
{
_tagRepository.Create(new TagTableEntity
{
TagId = Guid.NewGuid(),
TargetId = entity.ProjectId,
Value = tag,
TargetTable = "Project",
CreateTime = now,
});
}
}
tran.Complete();
}
return(_projectQueryService.GetProject(entity.ProjectId));
}
public ProjectDto UpdateProject(ProjectUpdateDto project, Guid id)
{
var projectEntity = Mapper.Map <Project>(project);
projectEntity.Id = id;
var updatedProject = ProjectRepository.UpdateProject(projectEntity);
ProjectRepository.SaveChanges();
return(Mapper.Map <ProjectDto>(updatedProject));
}
public async Task UpdateProject(ProjectUpdateDto projectUpdate)
{
//@TO-DO refactor with mapper
var res = await _projectRepository.GetById(projectUpdate.Id);
if (res == null)
{
throw new EntityNotFoundException("", "No such project exist");
}
await _projectRepository.UpdateProject(new Project { Id = projectUpdate.Id, Name = projectUpdate.Name });
}
public ActionResult <ProjectDto> UpdateClient(ProjectUpdateDto project, Guid id)
{
try
{
ProjectServices.UpdateProject(project, id);
return(NoContent());
}
catch (KeyNotFoundException)
{
return(NotFound());
}
}
public ActionResult Update(int id, ProjectUpdateDto projectUpdateDto)
{
var project = _projectRepo.GetProject(id);
if (project == null)
{
return(NotFound());
}
_mapper.Map(projectUpdateDto, project);
_projectRepo.UpdateProject(project);
_projectRepo.SaveChanges();
return(NoContent());
}
public async Task <ActionResult> UpdateProject(int projectId, [FromBody] ProjectUpdateDto projectUpdateDto)
{
var findProject = await _projectRepo.GetProjectByIdAsync(projectId);
if (findProject == null)
{
return(NotFound("Project doesn't exist"));
}
findProject.UpdateDate = DateTime.Now;
var project = _mapper.Map(projectUpdateDto, findProject);
_projectRepo.Update(project);
await _projectRepo.SaveAllAsync();
return(Ok());
}
//只支持变更名称、位置、区域和地域
public async Task <BaseResponse> UpdateProjectAsync(ProjectUpdateDto req, string account)
{
var data = await _pr.FindAsync(req.Id);
if (data == null)
{
return(new BaseResponse {
Success = false, Message = "输入的项目或者场站不存在"
});
}
//同一个项目下不能重名
var ret = await _pr.Find(a => a.ParentId == data.ParentId && a.Name == req.Name && a.Id != req.Id).FirstOrDefaultAsync();
if (ret != null)
{
return(new BaseResponse {
Success = false, Message = "已存在相同名称的项目获取场站"
});
}
try
{
var entity = _mapper.Map(req, data);
entity.Modify = account;
entity.ModifyTime = DateTime.Now;
await _pr.SaveAsync(entity);
_log.LogInformation($"{account}修改标示为{req.Id}的项目或者场站信息成功");
return(new BaseResponse {
Success = true, Message = "修改数据成功"
});
}
catch (Exception ex)
{
_log.LogError($"{account}修改标示为{req.Id}的项目或者场站失败，失败原因:{ex.Message}->{ex.StackTrace}->{ex.InnerException}");
return(new BaseResponse {
Success = false, Message = "修改数据失败，请联系管理员"
});
}
}
public async Task <ActionResult <BaseResponse> > UpdateProjectInfo(string GroupId, ProjectUpdateDto req)
{
var GId = User.Claims.FirstOrDefault(a => a.Type == "GroupId").Value;
string Account = User.Claims.FirstOrDefault(a => a.Type == "Account").Value;
string Code = User.Claims.FirstOrDefault(a => a.Type == "Code").Value;
var isAdmin = User.Claims.FirstOrDefault(a => a.Type == "IsAdmin").Value.ToLower() == "true" ? true : false;
string Roles = User.Claims.FirstOrDefault(a => a.Type == "Role").Value;
var pathId = await _ps.GetPathId(req.Id);
if (pathId == null)
{
return(new NotFoundResult());
}
else
{
pathId += "/" + req.Id;
}
if (GroupId != GId)
{
if (!(isAdmin && Code == _config["Group"]))
{
return(new ContentResult {
Content = "用户没有权限", ContentType = "text/plain", StatusCode = 401
});
}
}
else
{
if (!isAdmin)
{
var bAccess = await _rp.IsAuth(Roles, pathId, 2);
if (!bAccess)
{
return(new ContentResult {
Content = "用户没有权限", ContentType = "text/plain", StatusCode = 401
});
}
}
}
var rm = await _ps.UpdateProjectAsync(req, Account);
return(rm);
}
public async Task <IActionResult> Update(long id, [FromBody] ProjectUpdateDto updatedProject)
{
if (updatedProject == null)
{
return(BadRequest());
}
var oldProject = await _unitOfWork.Projects.SingleOrDefaultAsync(p => p.Id == id);
if (oldProject == null)
{
return(NotFound());
}
if (!oldProject.Name.Equals(updatedProject.Name))
{
if (await _unitOfWork.Projects.Exists(p => p.Name == updatedProject.Name && p.Id != oldProject.Id))
{
ModelState.AddModelError("Name", "The provided name already exists");
}
}
if (!Enum.IsDefined(typeof(ProjectType), Enum.ToObject(typeof(ProjectType), updatedProject.Type)))
{
ModelState.AddModelError("Type", "The provided type is not a valid project type.");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _unitOfWork.Users.SingleOrDefaultAsync(u => u.Id == updatedProject.UserId);
if (!_unitOfWork.Users.CanUserEdit(user))
{
return(Forbid());
}
Mapper.Map(updatedProject, oldProject);
oldProject.UpdateLastEditedDetails(user);
try
{
var existingUser = oldProject.ProjectUsers;
oldProject.ProjectUsers.Clear();
foreach (var userId in updatedProject.Users)
{
var newUser = await _unitOfWork.Users.SingleOrDefaultAsync(u => u.Id == userId);
if (newUser != null) // new user
{
oldProject.AssignUser(newUser);
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
if (await _unitOfWork.Complete() <= 0)
{
return(StatusCode(304));
}
var projectToReturn = Mapper.Map <ProjectReturnDto>(oldProject);
return(Ok(projectToReturn));
}
private static void UpdateProject(Project project, ProjectUpdateDto update)
{
if (update.Description is {})
public async Task <IActionResult> UpdateProject([FromBody] ProjectUpdateDto userModel)
{
await _projectService.UpdateProject(userModel);
return(Ok());
}
public async Task <Result> UpdateProjectAsync([FromBody] ProjectUpdateDto projectDto, [FromRoute] Guid id)
{
projectDto.Id = id;
return(GetResult(await _projectService.UpdateProjectAsync(projectDto)));
}
public UpdateProjectAction(int id, ProjectUpdateDto project) => (Id, Project) = (id, project);
