public ActionResult <Project> UpdateProject(
[FromRoute]
[Required(ErrorMessage = "DataAnnotationRequired")]
[Guid(ErrorMessage = "DataAnnotationGuid")]
string projectId,
[FromBody] ProjectUpdateRequest request)
{
var projectGuid = Guid.Parse(projectId);
var project = _projectService.GetProject(projectGuid);
if (project == null)
{
return(ErrorObjectResultFactory.NotFound());
}
if (request.ProjectCode != null &&
request.ProjectCode != project.ProjectCode &&
_projectQueryService.ExistsProjectCode(request.ProjectCode))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayProjectProjectCode),
"projectCode"));
}
var dto = _mapper.Map <ProjectUpdateRequest, ProjectUpdateDto>(request);
dto.ProjectId = projectGuid;
var entity = _projectService.UpdateProject(dto);
return(_mapper.Map <Domain.Entities.Project, Project>(entity));
}
public async Task UpdateProjectAsync_ShouldUpdateProjectAndReturnProjectImplDto()
{
var projectRequest = new ProjectRequest
{
Name = "Test project " + Guid.NewGuid(),
Color = "#FF00FF"
};
var createResult = await _client.CreateProjectAsync(_workspaceId, projectRequest);
createResult.IsSuccessful.Should().BeTrue();
createResult.Data.Should().NotBeNull();
var projectUpdateRequest = new ProjectUpdateRequest {
Name = "Updated project " + Guid.NewGuid(),
Archived = true,
Billable = true,
Color = "#000000",
Note = "Test note" + Guid.NewGuid(),
IsPublic = true
};
var updateProjectAsync = await _client.UpdateProjectAsync(_workspaceId, createResult.Data.Id, projectUpdateRequest);
updateProjectAsync.IsSuccessful.Should().BeTrue();
updateProjectAsync.Data.Name.Should().Be(projectUpdateRequest.Name);
updateProjectAsync.Data.Archived.Should().Be(projectUpdateRequest.Archived);
updateProjectAsync.Data.Billable.Should().Be(projectUpdateRequest.Billable);
updateProjectAsync.Data.Color.Should().Be(projectUpdateRequest.Color);
updateProjectAsync.Data.Note.Should().Be(projectUpdateRequest.Note);
updateProjectAsync.Data.Public.Should().Be(projectUpdateRequest.IsPublic);
var deleteProject = await _client.ArchiveAndDeleteProject(_workspaceId, createResult.Data.Id);
deleteProject.IsSuccessful.Should().BeTrue();
}
public ProjectUpdate(ProjectUpdateRequest request)
{
if (request != null)
{
using (var dbContext = new ApplicationDbContext())
{
var project = dbContext.Projects.SingleOrDefault(aProject => aProject.Identifier == request.ProjectsIdentifier);
if (project == null)
{
Response = new ProjectUpdateResponse
{
Type = ProjectUpdateResponseType.ProjectDoesNotExist
};
return;
}
project.Set(request);
dbContext.SaveChanges();
Response = new ProjectUpdateResponse
{
Type = ProjectUpdateResponseType.Success
};
}
}
}
public void Set(ProjectUpdateRequest request)
{
UpdatedOnUtc = DateTime.UtcNow;
if (request.Name != null)
{
Name = request.Name.Trim();
}
}
public HttpResponseMessage Update(ProjectUpdateRequest model)
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState));
}
ProjectService.Update(model);
SuccessResponse response = new SuccessResponse();
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
public static async Task <IRestResponse> ArchiveAndDeleteProject(this ClockifyClient client, string workspaceId, string projectId)
{
var projectUpdateRequest = new ProjectUpdateRequest {
Archived = true
};
var archiveProjectResponse = await client.UpdateProjectAsync(workspaceId, projectId, projectUpdateRequest);
if (!archiveProjectResponse.IsSuccessful)
{
return(archiveProjectResponse);
}
return(await client.DeleteProjectAsync(workspaceId, projectId));
}
public void UpdateProject_OK_すべての値を正常値で更新()
{
var requestObject = new ProjectCreateRequest
{
ProjectCode = new String('U', 20),
Name = new String('U', 256),
Description = new String('U', 1024),
Status = ProjectStatus.NORMAL.ToString(),
SortNo = int.MaxValue,
Tags = new List <string> {
new String('U', 100)
},
};
var request = new HttpRequestMessage(HttpMethod.Post, "/api/v1/projects");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "normal-write");
request.Content = new StringContent(JsonUtil.Serialize(requestObject), Encoding.UTF8, "application/json");
var response = _httpclient.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult();
var responseBody = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
var project = JsonUtil.Deserialize <Project>(responseBody);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var updateRequestObject = new ProjectUpdateRequest
{
ProjectCode = new String('V', 20),
Name = new String('V', 256),
Description = new String('V', 1024),
Status = ProjectStatus.SUSPENDED.ToString(),
SortNo = 0,
Tags = new List <string> {
new String('V', 100)
},
};
request = new HttpRequestMessage(HttpMethod.Patch, $"/api/v1/projects/{project.ProjectId}");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "normal-write");
request.Content = new StringContent(JsonUtil.Serialize(updateRequestObject), Encoding.UTF8, "application/json");
response = _httpclient.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult();
responseBody = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
project = JsonUtil.Deserialize <Project>(responseBody);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual(project.ProjectCode, new String('V', 20));
Assert.AreEqual(project.Name, new String('V', 256));
Assert.AreEqual(project.Description, new String('V', 1024));
Assert.AreEqual(project.Status, ProjectStatus.SUSPENDED.ToString());
Assert.AreEqual(project.SortNo, 0);
Assert.AreEqual(project.Tags[0], new String('V', 100));
}
public async Task <IActionResult> Update(int projectID, [FromBody] ProjectUpdateRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var result = await _projectService.Update(projectID, request);
if (!result.IsSuccessed)
{
return(BadRequest(result));
}
return(Ok(result));
}
public ProjectUpdateResponse Update(ProjectUpdateRequest request)
{
ProjectUpdateResponse response = new ProjectUpdateResponse();
ProjectEntity entityToUpdate = ToEntity(request.Project);
using (var sqliteConn = ConnectionProvider.GetSqliteConn())
{
sqliteConn.Execute("update project set Description = @Description, Repository = @Repository, Params = @Params, TemplateName = @TemplateName, LastUpdateBy = @LastUpdateBy, LastUpdateTime = @LastUpdateTime where Id = @Id",
entityToUpdate);
}
response.Status = 1;
return(response);
}
public void UpdateProject_NotFound_ProjectIDの指定が存在しない()
{
var projectId = "00000000-0000-0000-0000-000000000000";
var requestObject = new ProjectUpdateRequest
{
ProjectCode = new String('Z', 20),
};
var request = new HttpRequestMessage(HttpMethod.Patch, $"/api/v1/projects/{projectId}");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "normal-write");
request.Content = new StringContent(JsonUtil.Serialize(requestObject), Encoding.UTF8, "application/json");
var response = _httpclient.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult();
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
}
public static void Update(ProjectUpdateRequest model)
{
using (SqlConnection conn = new SqlConnection(WebConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString))
{
conn.Open();
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = conn;
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.CommandText = "dbo.Project_Update";
cmd.Parameters.AddWithValue("@Id", model.Id);
MapCommonProjectParameters(model, cmd);
cmd.ExecuteNonQuery();
}
conn.Close();
}
}
public async Task <ApiResult <bool> > Update(int projectID, ProjectUpdateRequest request)
{
var project = await _context.Projects.FindAsync(projectID);
if (project == null)
{
return(new ApiErrorResult <bool>("Project does not exist"));
}
project.ProjectName = request.ProjectName;
project.Description = request.Description;
project.Skateholder = request.Skateholder;
var result = await _context.SaveChangesAsync();
if (result == 0)
{
return(new ApiErrorResult <bool>("Update project failed"));
}
return(new ApiSuccessResult <bool>());
}
public void UpdateProject_ValidationError_ProjectCodeを重複する値で更新()
{
var requestObject = new ProjectCreateRequest
{
ProjectCode = new String('W', 20),
Name = new String('W', 256),
Description = new String('W', 1024),
Status = ProjectStatus.NORMAL.ToString(),
SortNo = int.MaxValue,
Tags = new List <string> {
new String('W', 100)
},
};
var request = new HttpRequestMessage(HttpMethod.Post, "/api/v1/projects");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "normal-write");
request.Content = new StringContent(JsonUtil.Serialize(requestObject), Encoding.UTF8, "application/json");
var response = _httpclient.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult();
var responseBody = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
var project = JsonUtil.Deserialize <Project>(responseBody);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var updateRequestObject = new ProjectUpdateRequest
{
ProjectCode = "00001",
};
request = new HttpRequestMessage(HttpMethod.Patch, $"/api/v1/projects/{project.ProjectId}");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "normal-write");
request.Content = new StringContent(JsonUtil.Serialize(updateRequestObject), Encoding.UTF8, "application/json");
response = _httpclient.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult();
responseBody = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
var error = JsonUtil.Deserialize <Error>(responseBody);
Assert.AreEqual(ErrorCodes.ValidationError, error.Code);
Assert.IsTrue(error.Details.Exists(e => e.Target.Equals("ProjectCode", StringComparison.OrdinalIgnoreCase)));
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public async Task DeleteProjectAsync_ShouldDeleteProject()
{
// Create project to delete
var projectRequest = new ProjectRequest {
Name = "DeleteProjectTest " + Guid.NewGuid(), Color = "#FFFFFF"
};
var response = await _client.CreateProjectAsync(_workspaceId, projectRequest);
response.IsSuccessful.Should().BeTrue();
var projectId = response.Data.Id;
// Archive project
var projectUpdateRequest = new ProjectUpdateRequest {
Archived = true
};
var archiveProjectResponse = await _client.UpdateProjectAsync(_workspaceId, projectId, projectUpdateRequest);
archiveProjectResponse.IsSuccessful.Should().BeTrue();
// Delete project
var del = await _client.DeleteProjectAsync(_workspaceId, projectId);
del.IsSuccessful.Should().BeTrue();
}
/// <summary>
/// 修改项目
/// </summary>
/// <returns></returns>
public ProjectUpdateResponse UpdateProject(ProjectUpdateRequest request)
{
ProjectUpdateResponse response = new ProjectUpdateResponse();
ProjectInfo info = new ProjectInfo()
{
ProjectId = request.ProjectId,
ProjectNumber = request.ProjectNumber,
ProjectName = request.ProjectName,
ProjectDescribe = request.ProjectDescribe,
ProjectStaffId = request.ProjectStaffId,
TechStaffId = request.TechStaffId,
ProductStaffId = request.ProductStaffId,
TestStaffId = request.TestStaffId,
MarketStaffId = request.MarketStaffId,
ProjectStage = request.ProjectStage,
ProjectStartTime = request.ProjectStartTime,
ProjectOutTime = request.ProjectOutTime,
ProjectStaus = 1
};
var result = dal.UpdateProject(info);
if (result > 0)
{
response.Message = "项目修改成功";
response.IsRegistSuccess = true;
}
else
{
response.Message = "修改项目失败";
response.IsRegistSuccess = false;
}
return(response);
}
/// <summary>
/// Update project on workspace.
/// </summary>
public Task <IRestResponse <ProjectDtoImpl> > UpdateProjectAsync(string workspaceId, string projectId, ProjectUpdateRequest project)
{
var request = new RestRequest($"workspaces/{workspaceId}/projects/{projectId}");
request.AddJsonBody(project);
return(_client.ExecuteAsync <ProjectDtoImpl>(request, Method.PUT));
}
/// <summary>
/// 修改项目
/// </summary>
/// <returns></returns>
public ProjectUpdateResponse UpdateProject(ProjectUpdateRequest request)
{
return(ProjectBll.Instance.UpdateProject(request));
}
/// <summary>
/// 修改项目
/// </summary>
/// <returns></returns>
public JsonResult UpdateProject(ProjectUpdateRequest request)
{
return(Json(bll.UpdateProject(request)));
}
public Task CreateProjectAsync(ProjectUpdateRequest request)
{
return(SendAsync <Nothing>(HttpMethod.Post, "projects.json", request: request));
}
public Task UpdateProjectAsync(long id, ProjectUpdateRequest request)
{
return(SendAsync <Nothing>(HttpMethod.Put, $"projects/{id}.json", request: request));
}
/// <summary>
/// 修改项目
/// </summary>
/// <returns></returns>
public ProjectUpdateResponse UpdateProject(ProjectUpdateRequest request)
{
return(ApiRequestHelp.Post <ProjectUpdateRequest, ProjectUpdateResponse>(request));
}
