public async Task <OperationDto> CreateProject(ProjectDto project, string organization = default, CancellationToken cancellationToken = default)
{
var request = new CreateProjectRequest(organization ?? _options.Value.DefaultOrganization, project);
request.Headers.Authorization = GetAuthZHeader();
var response = await SendAsync(request, cancellationToken);
var operationReferenceDto = await response.Content.ReadFromJsonAsync <OperationDto>(null, cancellationToken);
return(operationReferenceDto);
}
public IActionResult CreateProject([FromBody] CreateProjectRequest request)
{
using (var client = GetRestClient())
{
var newProject = new ProjectContract
{
Name = request.Name
};
var newProjectId = client.CreateProject(newProject);
return(Json(newProjectId));
}
}
public async Task <Project> AddProject(CreateProjectRequest request)
{
var rootGroup = new CharacterGroup()
{
IsPublic = true,
IsRoot = true,
//TODO[Localize]
CharacterGroupName = "Все роли",
IsActive = true,
ResponsibleMasterUserId = CurrentUserId,
HaveDirectSlots = true,
AvaiableDirectSlots = -1,
};
MarkCreatedNow(rootGroup);
var project = new Project()
{
Active = true,
IsAcceptingClaims = false,
CreatedDate = Now,
ProjectName = Required(request.ProjectName),
CharacterGroups = new List <CharacterGroup>()
{
rootGroup,
},
ProjectAcls = new List <ProjectAcl>()
{
ProjectAcl.CreateRootAcl(CurrentUserId, isOwner: true),
},
Details = new ProjectDetails(),
};
MarkTreeModified(project);
switch (request.ProjectType)
{
case ProjectTypeDto.Larp:
break;
case ProjectTypeDto.Convention:
project.Details.AutoAcceptClaims = true;
project.Details.EnableAccommodation = true;
project.Details.GenerateCharacterNamesFromPlayer = true;
break;
default:
throw new ArgumentOutOfRangeException();
}
UnitOfWork.GetDbSet <Project>().Add(project);
await UnitOfWork.SaveChangesAsync();
return(project);
}
public async Task CreateProjectAsync_NullRequestModelTitle_ShouldThrowArgumentNullException()
{
// Arrange
var createProjectRequest = new CreateProjectRequest(title: null);
var projectApi = this.fixture.GetProjectApi();
// Act
Func <Task> act = async() => await projectApi.CreateProjectAsync(createProjectRequest);
// Assert
await act.Should().ThrowAsync <ArgumentNullException>();
}
public IActionResult AddProject([FromBody] CreateProjectRequest project)
{
var id = HttpContext.User.Claims.Single(x => x.Type == "Id").Value;
var res = _projectService.Create(id, project);
if (!res.Success)
{
return(BadRequest(res));
}
return(Ok(res));
}
public void TestCreateProject_Test2()
{
CreateProjectRequest request = new CreateProjectRequest();
request.project.ProjectName = "Test2";
request.project.Host = "10.10.10.10";
request.project.Username = "******";
request.project.Password = "******";
request.project.Database = "MyDB";
CreateProjectResponse actual = bal.CreateProject(request);
Assert.AreEqual(StatusCodes.Status_Success, actual.StatusCode);
}
public async Task <ProjectResponse> ExecuteAsync(CreateProjectRequest request)
{
var sql = "insert into Projects (Id, Name, Description, TasksCount) values (@Id, @Name, @Description, @TasksCount)";
using (var connection = _factory.GetOpenedConnection())
{
var project = new Project {
Name = request.Name, Description = request.Description
};
return(await connection.QueryFirstOrDefaultAsync <ProjectResponse>
(sql, project));
}
}
public async Task <Project> CreateAsync(long userId, CreateProjectRequest request)
{
var project = await AddProjectAsync(userId, request);
if (request.TeamMembers != null && request.TeamMembers.Any())
{
UpdateTeamMembers(request.TeamMembers, project);
}
await _projectRepository.SaveChangesAsync();
return(project);
}
public async Task <string> CreateProject(string name, bool subToNotifications, bool restrictAccess)
{
CreateProjectRequest req = new CreateProjectRequest
{
Name = name,
Notification = subToNotifications,
Restricted = restrictAccess
};
var response = await Post <CreateProjectRequest, CreateProjectResponse>("projects", req);
return(response.Id);
}
public async Task <ProjectResponse> ExecuteAsync(CreateProjectRequest request, string username)
{
var project = _mapper.Map <CreateProjectRequest, Project>(request);
var user = await _factory
.CreateAsyncQueryable(_uow.Users.Query())
.FirstOrDefaultAsync(u => u.Login == username);
project.User = user;
_uow.Projects.Add(project);
await _uow.CommitAsync();
return(_mapper.Map <Project, ProjectResponse>(project));
}
public async Task <CreateProjectResponse> CreateTestProjectAsync(IProjectApi projectApi)
{
var title = $"{TestPrefix}{Guid.NewGuid().ToString()}";
var createProjectRequest = new CreateProjectRequest(title)
{
ProjectState = ProjectState.Planned,
};
var createProjectResponse = await projectApi.CreateProjectAsync(createProjectRequest);
return(createProjectResponse);
}
public CreateResponse <ProjectDTO> Create(string id, CreateProjectRequest req)
{
var res = new CreateResponse <ProjectDTO>();
var user = _userRepository.FindById(Guid.Parse(id));
Console.WriteLine(user);
if (user == null)
{
return((CreateResponse <ProjectDTO>)res.ReturnErrorResponseWith("User not found."));
}
var role = _roleRepository.FindRoleByName("PROJECT_MANAGER");
if (role == null)
{
return((CreateResponse <ProjectDTO>)res.ReturnErrorResponseWith("Error ocurred during asigning roles"));
}
var project = _projectDomainService.CreateProject(user,
req.Name,
req.Description,
req.Deadline,
role);
project.Validate();
if (project.GetBrokenRules().Count > 0)
{
return((CreateResponse <ProjectDTO>)res.ReturnErrorResponseWithMultiple(project.GetBrokenRules()));
}
_projectRepository.Save(project);
try
{
_uow.Commit();
}
catch (Exception ex)
{
return((CreateResponse <ProjectDTO>)res.ReturnErrorResponseWith(ex.Message));
}
res.Success = true;
res.EntityDTO = _mapper.Map <Project, ProjectDTO>(project);
return(res);
}
public async Task AddProjectWithDueDateEarlierThanNow()
{
var project = new CreateProjectRequest()
{
Name = "xyz",
Description = "This is project created for integration test",
DueDate = DateTime.UtcNow.AddDays(-1),
AssignedUsers = new List <CreateProjectAssignmentsDto>()
};
var response = await Client.PostAsync("/api/MyProjects", Utilities.GetRequestContent(project));
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public void CanBeConstructed()
{
//Arrange
CreateProjectRequest sut;
//Act
sut = new CreateProjectRequest("my-org");
//Assert
Assert.NotNull(sut);
Assert.Equal("6.0", sut.ApiVersion);
Assert.Equal(HttpMethod.Post, sut.Method);
Assert.Equal("https://dev.azure.com/my-org/_apis/projects?api-version=6.0", sut.RequestUri.AbsoluteUri);
}
public async Task <IActionResult> Create(CreateProjectRequest request)
{
if (!ModelState.IsValid)
{
return(View(request));
}
var project = request.CreateProject();
_dbContext.Projects.Add(project);
await _dbContext.SaveChangesAsync();
return(RedirectToAction("Index", "Project", new { id = project.Id }));
}
public async Task <ActionResult <ProjectDto> > Create(CreateProjectRequest createProject)
{
var createdProject = await this.projectService.CreateAsync(createProject.Name, createProject.Description, createProject.StartAt);
var dto = new ProjectDto
{
Id = createdProject.Id,
Name = createdProject.Name,
Description = createdProject.Description,
StartAt = createdProject.StartAt
};
return(Ok(dto));
}
public async Task PublishPackage()
{
var groupShareClient = Helper.GsClient;
var rawData = File.ReadAllBytes(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Resources\ProjectPackage.sdlppx"));
var createProjectRequest = new CreateProjectRequest(
"ProjectForPublish",
Helper.OrganizationId,
null,
DateTime.Today,
"7bf6410d-58a7-4817-a559-7aa8a3a99aa9",
rawData);
await groupShareClient.Project.PublishPackage(createProjectRequest);
}
public ActionResult CreateProject(string ProjectName, string Host, string Username, string Password, string Database)
{
IProjectBAL projectBAL = new ProjectBAL();
CreateProjectRequest request = new CreateProjectRequest();
request.project.ProjectName = ProjectName;
request.project.Host = Host;
request.project.Username = Username;
request.project.Password = Password;
request.project.Database = Database;
var response = projectBAL.CreateProject(request);
return(Json(response));
}
public async Task CreateProjectAsync(CreateProjectRequest createProjectRequest)
{
var projectEntity = createProjectRequest.ProjectEntity;
var projectNomination = new ProjectNomination
{
ProjectId = projectEntity.Id,
Project = projectEntity,
UserId = createProjectRequest.UserId
};
_unitOfWork.Projects.Add(projectEntity);
_unitOfWork.ProjectNominations.Add(projectNomination);
await _unitOfWork.SaveChangesAsync();
}
public async Task PublishPackage()
{
var groupShareClient = await Helper.GetGroupShareClient();
var rawData = File.ReadAllBytes(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Resources\ProjectPackage.sdlppx"));
var createProjectRequest = new CreateProjectRequest(
"ProjectForPublish",
"ee72759d-917e-4c60-ba30-1ed595699c4d",
null,
DateTime.Today,
"7bf6410d-58a7-4817-a559-7aa8a3a99aa9",
rawData);
await groupShareClient.Project.PublishPackage(createProjectRequest);
}
/// <summary>
/// 为用户提供新建项目的能力，用于集中管理产品和应用。
/// </summary>
/// <param name="req"><see cref="CreateProjectRequest"/></param>
/// <returns><see cref="CreateProjectResponse"/></returns>
public CreateProjectResponse CreateProjectSync(CreateProjectRequest req)
{
JsonResponseModel <CreateProjectResponse> rsp = null;
try
{
var strResp = this.InternalRequestSync(req, "CreateProject");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <CreateProjectResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
public async Task CreatedProjectCanBeUpdated()
{
var createRequest = CreateProjectRequest.FromName(GetRandomProjectName());
createRequest.Description = "description1";
createRequest.EnableContainerRegistry = true;
createRequest.EnableIssues = true;
createRequest.EnableJobs = true;
createRequest.EnableMergeRequests = true;
createRequest.PublicJobs = true;
createRequest.EnableWiki = true;
createRequest.EnableLfs = true;
createRequest.EnablePrintingMergeRequestLink = true;
createRequest.OnlyAllowMergeIfAllDiscussionsAreResolved = true;
createRequest.OnlyAllowMergeIfPipelineSucceeds = true;
createRequest.Visibility = ProjectVisibilityLevel.Internal;
var createdProject = await _sut.CreateAsync(createRequest);
ProjectIdsToClean.Add(createdProject.Id);
var updatedProject = await _sut.UpdateAsync(new UpdateProjectRequest(createdProject.Id.ToString(), createdProject.Name)
{
Description = "description11",
EnableContainerRegistry = false,
EnableIssues = false,
EnableJobs = false,
EnableMergeRequests = false,
PublicJobs = false,
EnableWiki = false,
EnableLfs = false,
OnlyAllowMergeIfAllDiscussionsAreResolved = false,
OnlyAllowMergeIfPipelineSucceeds = false,
Visibility = ProjectVisibilityLevel.Public
});
updatedProject.Should().Match <Project>(
p => p.Description == "description11" &&
!p.ContainerRegistryEnabled &&
!p.IssuesEnabled &&
!p.JobsEnabled &&
!p.MergeRequestsEnabled &&
p.PublicJobs &&
!p.WikiEnabled &&
p.OnlyAllowMergeIfAllDiscussionsAreResolved == false &&
p.OnlyAllowMergeIfPipelineSucceeds == false &&
p.Visibility == ProjectVisibilityLevel.Public);
}
public ProjectResponse CreateProject(CreateProjectRequest request)
{
var project = new Project();
project.Name = request.Name;
project.CustomerId = request.CustomerId;
project.CreatedAt = DateTime.Now;
project.CreatedBy = 1;
_unitOfWork.ProjectRepository.Insert(project);
_unitOfWork.ProjectRepository.Save();
return(new ProjectResponse {
Id = project.Id, Name = project.Name
});
}
public async Task CreateProject(CreateProjectRequest request)
{
User user = _userService.GetByIdentity(Context.UserIdentifier);
if (user is null)
{
Clients.Caller.SendAsync("CreateProject", StatusCodes.Status404NotFound);
}
if (user.Group == "Student")
{
Clients.Caller.SendAsync("CreateProject", StatusCodes.Status403Forbidden);
}
_projectService.Create(request.Project);
Clients.Caller.SendAsync("CreateProject", StatusCodes.Status200OK);
}
public async Task <ProjectResponse> ExecuteAsync(CreateProjectRequest request, string userId)
{
var project = new Project
{
Title = request.Title,
Description = request.Description,
OwnerId = Guid.Parse(userId)
};
await _context.Projects.AddAsync(project);
await _context.SaveChangesAsync();
return(new ProjectResponse {
Title = project.Title, Description = project.Description, Id = project.Id
});
}
public CreateProjectResponse CreateProject(CreateProjectRequest request)
{
var project = new Project
{
ProjectCollectionId = request.ProjectCollectionId,
ParentProjectId = request.ParentProjectId,
Name = request.Name
};
component.CreateProject(project);
return(new CreateProjectResponse
{
ProjectId = project.ProjectId
});
}
public async Task <IActionResult> Post([FromBody] CreateProjectRequest createProject)
{
var result = await this._responseGenerator.CreateResponseAsync(CmsOperation.CreateProject);
BasePayLoad payLoad = new BasePayLoad();
payLoad.Request = createProject;
SedaEvent sedaEvent = new SedaEvent(result._id, SedaService.Orchestrator, SedaService.CMS, EventType.Request, CmsOperation.CreateProject, Priority.One, payLoad);
await this._eventBusMessagePublisher.PublishAsync(sedaEvent);
BaseApiResponse apiResponse = new BaseApiResponse();
apiResponse.ResponseId = result._id;
return(Ok(apiResponse));
}
public async Task <IActionResult> CreateProjectAsync([FromBody] CreateProjectRequest request, [FromServices] ICreateProjectCommand command)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
ProjectResponse response = await command.ExecuteAsync(request);
return(Ok(response));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public VersionControlSystemInfo CreateRepositoryForProject(CreateProjectRequest request)
{
var project = new ProjectCreate
{
IssuesEnabled = false,
Description = request.Info,
MergeRequestsEnabled = false,
Name = request.Name,
VisibilityLevel = request.AccessLevel == AccessLevel.Public
? VisibilityLevel.Public
: VisibilityLevel.Private
};
var createdProject = _gitLabClient.Projects.Create(project);
return(new VersionControlSystemInfo(createdProject.Id, new Uri(createdProject.WebUrl)));
}
/// <summary>
/// Projects / Create Project
/// </summary>
public async Task <CreateProjectResponse> CreateProjectAsync(CreateProjectRequest request)
{
if (request == null)
{
throw new ArgumentNullException("Value cannot be null.", nameof(request));
}
if (string.IsNullOrEmpty(request.Name))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(request.Name));
}
if (request.Type == null)
{
throw new ArgumentNullException("Value cannot be null.", nameof(request.Type));
}
return(await ExecuteAsync <CreateProjectResponse>(CreateRequest <CreateProjectRequest>(PROJECTS_PATH, request)).ConfigureAwait(false));
}
