public void CreateProject_ValidationError_すべての値が異常値()
{
var requestObject = new ProjectCreateRequest
{
ProjectCode = new String('Z', 21),
Name = new String('Z', 257),
Description = new String('Z', 1025),
Status = "ERROR",
SortNo = -1,
Tags = new List <string> {
new String('Z', 101)
},
};
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 error = JsonUtil.Deserialize <Error>(responseBody);
Assert.AreEqual(ErrorCodes.ValidationError, error.Code);
Assert.IsTrue(error.Details.Exists(e => e.Target.Equals("ProjectCode", StringComparison.OrdinalIgnoreCase)));
Assert.IsTrue(error.Details.Exists(e => e.Target.Equals("Name", StringComparison.OrdinalIgnoreCase)));
Assert.IsTrue(error.Details.Exists(e => e.Target.Equals("Description", StringComparison.OrdinalIgnoreCase)));
Assert.IsTrue(error.Details.Exists(e => e.Target.Equals("Status", StringComparison.OrdinalIgnoreCase)));
Assert.IsTrue(error.Details.Exists(e => e.Target.Equals("SortNo", StringComparison.OrdinalIgnoreCase)));
Assert.IsTrue(error.Details.Exists(e => e.Target.Equals("Tags", StringComparison.OrdinalIgnoreCase)));
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public void DeleteProject_OK_正常値で削除()
{
var requestObject = new ProjectCreateRequest
{
ProjectCode = new String('T', 20),
Name = new String('X', 256),
Description = new String('X', 1024),
Status = ProjectStatus.NORMAL.ToString(),
SortNo = int.MaxValue,
Tags = new List <string> {
new String('X', 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);
request = new HttpRequestMessage(HttpMethod.Delete, $"/api/v1/projects/{project.ProjectId}");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "normal-write");
response = _httpclient.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult();
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
public static ProjectCreateRequest GetProjectCreateRequest(CurrentOrganization organization, Project project)
{
var request = new ProjectCreateRequest(CurrentUserId, organization.Uid, project.Name,
project.Url, project.Description);
return(request);
}
public ProjectCreateResponse Create(ProjectCreateRequest request)
{
ProjectCreateResponse response = new ProjectCreateResponse();
ProjectEntity entityToInsert = ToEntity(request.Project);
using (var sqliteConn = ConnectionProvider.GetSqliteConn())
{
var count = sqliteConn.QuerySingle <int>("select count(1) from project where Name = @Name", new { Name = request.Project.Name });
if (count > 0)
{
response.Message = "应用名称已存在";
return(response);
}
}
using (var sqliteConn = ConnectionProvider.GetSqliteConn())
{
sqliteConn.Execute("insert into project(Name, Description, Repository, Params, TemplateName, DataStatus, CreateBy, CreateTime, LastUpdateBy, LastUpdateTime) values (@Name, @Description, @Repository, @Params, @TemplateName, @DataStatus, @CreateBy, @CreateTime, @LastUpdateBy, @LastUpdateTime)",
entityToInsert);
}
response.Status = 1;
return(response);
}
public static ProjectCreateRequest GetProjectCreateRequest()
{
var project = GetOrganizationOneProjectOne();
var request = new ProjectCreateRequest(CurrentUserId, project.OrganizationUid, project.Name,
project.Url, project.Description);
return(request);
}
public async Task <IActionResult> Create(string empID, [FromBody] ProjectCreateRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var projectID = await _projectService.Create(empID, request);
return(Ok(projectID));
}
public void Create(Project project)
{
var request = new ProjectCreateRequest();
ModelCopier.CopyModel(project, request);
var createdProject = Create(request);
project.Api = Api;
ModelCopier.CopyModel(createdProject, project);
}
public async Task <ActionResult> Create()
{
string token_header = null;
if (Session["token_header"] != null)
{
token_header = Session["token_header"].ToString();
}
CustomTranslatorAPIClient clientapp = new CustomTranslatorAPIClient();
ProjectCreateRequest newproject = new ProjectCreateRequest();
newproject.name = "..."; // Enter Project Name
newproject.languagePairId = 18; //Determined from the call to GetLanguagePairs
newproject.categoryid = 1; //Determined from the call to GetCategories
newproject.categoryDescriptor = "..."; // Enter Project Category Descriptor
newproject.label = "..."; // Enter Project Label
newproject.description = "..."; // Enter Project Decription
string categoryresult = await clientapp.GetCategories(token_header);
List <Category> categorylist = getCategoryList(categoryresult);
Category category = categorylist.Find(c => c.id == newproject.categoryid);
string lpresult = await clientapp.GetLanguagePairs(token_header);
List <LanguagePair> languagePairList = getLanguagePairList(lpresult);
LanguagePair languagePair = languagePairList.Find(lp => lp.id == newproject.languagePairId);
string result = await clientapp.CreateProject(token_header, newproject, Session["ws_id"].ToString());
string[] resultarray = result.Split('/');
if (resultarray.Length > 1)
{
string newprojectid = resultarray[resultarray.Length - 1];
Response.Write("<br/>New Project Created");
Response.Write("<br/>Project Id: " + newprojectid);
Response.Write("<br/>Project Name: " + newproject.name);
Response.Write("<br/>Language Pair: " + languagePair.sourceLanguage.displayName + " to " + languagePair.targetLanguage.displayName);
Response.Write("<br/>Project Category: " + category.name);
Response.Write("<br/>Project Label: " + newproject.label);
Response.Write("<br/>Project Description: " + newproject.description);
}
else
{
Response.Write("<br/>Could not create project: " + result);
}
return(View());
}
public ActionResult <Project> CreateProject([FromBody] ProjectCreateRequest request)
{
if (_projectQueryService.ExistsProjectCode(request.ProjectCode))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayProjectProjectCode),
"projectCode"));
}
var dto = _mapper.Map <ProjectCreateRequest, ProjectCreateDto>(request);
var entity = _projectService.CreateProject(dto);
return(_mapper.Map <Domain.Entities.Project, Project>(entity));
}
public async Task <IActionResult> Create([FromBody] ProjectCreateRequest request)
{
var client = await _context.Clients.FirstOrDefaultAsync(b => b.Id == request.ClientId);
if (client == null)
{
return(BadRequest());
}
var ent = await _context.Projects.AddAsync(_mapper.Map <Project>(request));
await _context.SaveChangesAsync();
return(Ok(await _context.Projects.ProjectTo <ProjectCreateResponse>(_mapper.ConfigurationProvider)
.FirstOrDefaultAsync(x => x.Id == ent.Entity.Id)));
}
public Project CreateEntityFromRequest(ProjectCreateRequest request, CurrentOrganization organization)
{
var entity = new Project();
entity.OrganizationId = organization.Id;
entity.OrganizationUid = organization.Uid;
entity.OrganizationName = organization.Name;
entity.Name = request.ProjectName;
entity.Description = request.Description;
entity.Url = request.Url;
entity.IsActive = true;
return(entity);
}
public ProjectCreate(ProjectCreateRequest request)
{
if (request != null)
{
if (string.IsNullOrWhiteSpace(request.Name))
{
Response = new ProjectCreateResponse
{
Type = ProjectCreateResponseType.NameEmpty
};
return;
}
using (var dbContext = new ApplicationDbContext())
{
if (dbContext.Projects.Any(aProject => aProject.Name.ToLower().Trim() == request.Name.ToLower().Trim()))
{
Response = new ProjectCreateResponse
{
Type = ProjectCreateResponseType.NameExists
};
return;
}
var projectNameWords = request.Name.Split(' ');
var projectKey = projectNameWords.Count() > 0
? string.Join("", projectNameWords.Select(aWord => aWord[0]))
: projectNameWords.Take(3).ToString();
if (dbContext.Projects.Any(aProject => aProject.Key == projectKey.ToUpper().Trim()))
{
throw new NotImplementedException();
}
var project = new Project();
project.Set(request, projectKey);
dbContext.Projects.Add(project);
dbContext.SaveChanges();
Response = new ProjectCreateResponse
{
Identifier = project.Identifier,
Type = ProjectCreateResponseType.Success,
};
}
}
}
public void Set(ProjectCreateRequest request, string key)
{
CreatedOnUtc = DateTime.UtcNow;
UpdatedOnUtc = DateTime.UtcNow;
CreatorIdentifier = request.CreatorIdentifier;
if (request.Name != null)
{
Name = request.Name.Trim();
}
if (key != null)
{
Key = key.ToUpper().Trim();
}
}
public void ExpressionUtils_GetConditions_Field_and_Variable_Are_Same_Name()
{
var request = new ProjectCreateRequest();
request.ProjectName = "test";
var value = request.ProjectName;
Expression <Func <Project, bool> > expression = x => "Url" == x.Url && x.Name == request.ProjectName;
var parameters = new Dictionary <string, DbParameterInfo>();
var filter = SystemUnderTest.GetConditions(expression.Body, parameters);
filter.ShouldBe("(:varprm_url = url) AND (project_name = :varprm_project_name)");
parameters.Count.ShouldBe(2);
parameters.Keys.ShouldContain(":varprm_url");
parameters.Keys.ShouldContain(":varprm_project_name");
parameters.Values.Select(x => x.Value).ShouldContain("Url");
parameters.Values.Select(x => x.Value).ShouldContain(value);
}
public async Task <ApiResult <int> > Create(string EmpID, ProjectCreateRequest request)
{
var project = _context.Projects.Find(request.ProjectID);
if (project != null)
{
project.ProjectName = request.ProjectName;
project.Description = request.Description;
project.Skateholder = request.Skateholder;
project.DateBegin = request.DateBegin;
project.DateEstimatedEnd = request.DateEstimatedEnd;
_context.Projects.Update(project);
var result = await _context.SaveChangesAsync();
if (result == 0)
{
return(new ApiErrorResult <int>("Update project failed"));
}
}
else
{
project = new Project()
{
ProjectName = request.ProjectName,
Description = request.Description,
Skateholder = request.Skateholder,
DateCreated = DateTime.Now,
DateBegin = request.DateBegin,
DateEstimatedEnd = request.DateEstimatedEnd,
Status = ProjectStatus.Pending
};
_context.Projects.Add(project);
var result = await _context.SaveChangesAsync();
if (result == 0)
{
return(new ApiErrorResult <int>("Create project failed"));
}
}
return(new ApiSuccessResult <int>(project.ProjectID));
}
public async Task <IActionResult> Create(ProjectCreateModel model)
{
if (model.IsNotValid())
{
model.SetInputModelValues();
return(View(model));
}
var request = new ProjectCreateRequest(CurrentUser.Id, model.OrganizationUid, model.Name, model.Url, model.Description);
var response = await _projectService.CreateProject(request);
if (response.Status.IsNotSuccess)
{
model.MapMessages(response);
model.SetInputModelValues();
return(View(model));
}
CurrentUser.IsActionSucceed = true;
return(Redirect($"/Project/Detail/{response.Item.Uid}"));
}
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 <ProjectCreateResponse> CreateProject(ProjectCreateRequest request)
{
var response = new ProjectCreateResponse();
var currentUser = _cacheManager.GetCachedCurrentUser(request.CurrentUserId);
if (!currentUser.IsAdmin)
{
response.SetInvalid();
return(response);
}
if (await _organizationRepository.Any(x => x.Id == currentUser.OrganizationId && !x.IsActive))
{
response.SetInvalidBecauseParentNotActive();
return(response);
}
if (await _projectRepository.Any(x => x.Name == request.ProjectName &&
x.OrganizationId == currentUser.OrganizationId))
{
response.ErrorMessages.Add("project_name_must_be_unique");
response.Status = ResponseStatus.Failed;
return(response);
}
var entity = _projectFactory.CreateEntityFromRequest(request, currentUser.Organization);
var uowResult = await _projectUnitOfWork.DoCreateWork(request.CurrentUserId, entity);
if (uowResult)
{
response.Item = _projectFactory.CreateDtoFromEntity(entity);
response.Status = ResponseStatus.Success;
return(response);
}
response.SetFailed();
return(response);
}
public Project Create(ProjectCreateRequest createRequest)
{
var content = Api.Post <Project>("/projects.json", createRequest);
return(content);
}
public async Task <dynamic> PostAsync([FromBody] ProjectCreateRequest request, CancellationToken cancellationToken)
{
var result = await _mediator.Send(request, cancellationToken);
return(new HRAssistActionResult(result));
}
public async Task CreateProjectAsync(ProjectCreateRequest projectRequest)
{
var project = await ProjectDomain.CreateProjectAsync(projectRequest.PlatformId, projectRequest.Name);
await project.SaveAsync();
}
public ProjectCreateResponse ProjectCreate(ProjectCreateRequest request) => new ProjectCreate(request).Response;
public static ProjectCreateRequest GetProjectCreateRequest()
{
var request = new ProjectCreateRequest(CurrentUserId, OrganizationOneUid, StringOne, HttpUrl, StringOne);
return(request);
}
