public long CreateProject(NewProjectDto project)
{
var command = project.ToCommand();
_commandDispatcher.Handle(command);
return(command.CreatedProjectId);
}
public async Task <IActionResult> PostNewProject([FromForm] NewProjectDto newProj, [FromRoute] string orgId)
{
try
{
_unitOfWorkManager.StartUnitOfWork();
Project p = _projectManager.AddProject(
newProj.Title,
newProj.StartDate,
newProj.EndDate,
newProj.OrganisationId);
foreach (var video in newProj.Videos)
{
string imgLocation = await _fileService.ConvertFileToLocation(video);
_ideationManager.AddFieldToProject(FieldType.Video, imgLocation, p.ProjectId);
}
foreach (var image in newProj.Images)
{
string imgLocation = await _fileService.ConvertFileToLocation(image);
_ideationManager.AddFieldToProject(FieldType.Picture, imgLocation, p.ProjectId);
}
foreach (var textfield in newProj.Texts)
{
_ideationManager.AddFieldToProject(FieldType.Text, textfield, p.ProjectId);
}
foreach (var location in newProj.Locations)
{
_ideationManager.AddFieldToProject(FieldType.Location, location, p.ProjectId);
}
foreach (var link in newProj.Links)
{
_ideationManager.AddFieldToProject(FieldType.Link, link, p.ProjectId);
}
_unitOfWorkManager.EndUnitOfWork();
return(CreatedAtAction(
"GetProject",
new { orgId, id = p.ProjectId },
_mapper.Map <ProjectDto>(p)));
}
catch (ValidationException ve)
{
return(UnprocessableEntity($"Invalid input data: {ve.ValidationResult.ErrorMessage}"));
}
catch (Exception e)
{
return(BadRequest($"Something went wrong in creating the project: {e.Message}."));
}
}
public override string Execute()
{
Console.WriteLine($"Trying to create project \"{Name}\"...");
bool promptAllConfig;
NewProjectDto projectDto;
if (!string.IsNullOrEmpty(Template))
{
var projectTemplate = _templateWriter.Read(Template);
projectDto = DeserializeYaml <NewProjectDto>(projectTemplate);
projectDto.Name = Name;
projectDto.DisplayName = DisplayName;
projectDto.Client = Client;
promptAllConfig = Console.GetYesNo("Do you want to complete the job definition configuration now?", false);
}
else
{
promptAllConfig = true;
projectDto = new NewProjectDto
{
Name = Name,
Client = Client,
DisplayName = DisplayName,
Members = new List <NewProjectMemberDto>()
};
}
projectDto.Members = projectDto.Members ?? new List <NewProjectMemberDto>();
projectDto.Models = projectDto.Models ?? new List <CreateProjectDataModelWithPropertiesDto>();
projectDto.Jobs = projectDto.Jobs ?? new List <CreateJobDefinitionWithTasksDto>();
string message;
if (promptAllConfig)
{
message = ValidateTask(projectDto.Jobs);
if (!string.IsNullOrEmpty(message))
{
return(message);
}
}
var project = _projectService.CreateProject(projectDto).Result;
message = project.ToCliString(promptAllConfig ?
"Project created:" :
"The project has been successfully created. However, you cannot queue the Default job until you complete the configuration");
Logger.LogInformation(message);
RefreshToken();
return(message);
}
public async Task NewProject(NewProjectDto dto)
{
var owningUserExists = await _usersDbSet
.AnyAsync(u => u.Id == dto.OwningUserId && u.OrganizationId == dto.OrganizationId);
if (!owningUserExists)
{
throw new ValidationException(ErrorCodes.ContentDoesNotExist, "Incorrect user");
}
var members = await _usersDbSet
.Where(u => dto.MembersIds.Contains(u.Id))
.ToListAsync();
var completeListOfAttributes = await ManageProjectAttributes(dto.Attributes);
var project = new Project
{
Name = dto.Title,
Desc = dto.Description,
OwnerId = dto.OwningUserId,
OrganizationId = dto.OrganizationId,
Logo = dto.Logo,
Attributes = completeListOfAttributes.ToList(),
Members = members
};
var wall = new CreateWallDto
{
Name = dto.Title,
UserId = dto.OwningUserId,
OrganizationId = dto.OrganizationId,
Type = WallType.Project,
Description = dto.Description,
Logo = dto.Logo,
Access = WallAccess.Public,
MembersIds = members.Select(m => m.Id).Concat(new List <string> {
dto.OwningUserId
}),
ModeratorsIds = new List <string> {
dto.OwningUserId
}
};
_projectsDbSet.Add(project);
await _wallService.CreateNewWall(wall);
await _uow.SaveChangesAsync(dto.UserId);
}
public async void CreateProject_ReturnsCreatedProject()
{
_projectService
.Setup(s => s.CreateProject(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(),
It.IsAny <List <(int, int)> >(), It.IsAny <List <ProjectDataModel> >(), It.IsAny <List <JobDefinition> >(),
It.IsAny <int>(), It.IsAny <CancellationToken>()))
.ReturnsAsync((string projectName, string displayName, string client, List <(int, int)> projectMembers,
List <ProjectDataModel> models, List <JobDefinition> jobs, int currentUserId, CancellationToken cancellationToken) =>
new Project
{
Id = 1,
Name = projectName,
Client = client,
Models = models,
Jobs = jobs
});
var httpContext = new DefaultHttpContext()
{
User = new ClaimsPrincipal(new[]
{
new ClaimsIdentity(new[] { new Claim(ClaimTypes.NameIdentifier, "1") })
})
};
var controller = new ProjectController(_projectService.Object, _mapper, _logger.Object)
{
ControllerContext = new ControllerContext {
HttpContext = httpContext
}
};
var dto = new NewProjectDto
{
Name = "Project01",
Members = new List <Shared.Dto.NewProjectMemberDto>(),
Models = new List <Shared.Dto.ProjectDataModel.CreateProjectDataModelWithPropertiesDto>(),
Jobs = new List <Shared.Dto.JobDefinition.CreateJobDefinitionWithTasksDto>()
};
var result = await controller.CreateProject(dto);
var createAtRouteActionResult = Assert.IsType <CreatedAtRouteResult>(result);
var returnValue = Assert.IsType <ProjectDto>(createAtRouteActionResult.Value);
Assert.Equal(1, returnValue.Id);
Assert.Equal("Project01", returnValue.Name);
}
public override string Execute()
{
Console.WriteLine($"Trying to create project \"{Name}\"...");
NewProjectDto projectDto;
if (!string.IsNullOrEmpty(Template))
{
var projectTemplate = _templateWriter.Read(Template);
projectDto = DeserializeYaml <NewProjectDto>(projectTemplate);
projectDto.Name = Name;
projectDto.DisplayName = DisplayName;
projectDto.Client = Client;
}
else
{
projectDto = new NewProjectDto
{
Name = Name,
Client = Client,
DisplayName = DisplayName,
Members = new List <NewProjectMemberDto>()
};
}
projectDto.Members = projectDto.Members ?? new List <NewProjectMemberDto>();
projectDto.Models = projectDto.Models ?? new List <CreateProjectDataModelWithPropertiesDto>();
projectDto.Jobs = projectDto.Jobs ?? new List <CreateJobDefinitionWithTasksDto>();
var message = ValidateTask(projectDto.Jobs);
if (!string.IsNullOrEmpty(message))
{
return(message);
}
var project = _projectService.CreateProject(projectDto).Result;
message = project.ToCliString("Project created:");
Logger.LogInformation(message);
RefreshToken();
return(message);
}
public IActionResult UpdateProject(int id, NewProjectDto updatedValues)
{
try
{
_unitOfWorkManager.StartUnitOfWork();
Project updatedProject = _projectManager.ChangeProject(
id,
updatedValues.Title,
updatedValues.StartDate,
updatedValues.EndDate,
updatedValues.OrganisationId);
_unitOfWorkManager.EndUnitOfWork();
if (updatedProject == null)
{
return(BadRequest("Something went wrong while updating the project."));
}
return(Ok(_mapper.Map <ProjectDto>(updatedProject)));
}
catch (ValidationException ve)
{
return(UnprocessableEntity($"Invalid input data: {ve.ValidationResult.ErrorMessage}"));
}
catch (ArgumentException e)
{
switch (e.ParamName)
{
case "id":
return(NotFound(e.Message));
case "organisationId":
return(UnprocessableEntity(e.Message));
default:
return(BadRequest(e.Message));
}
}
}
public async Task <ProjectDto> CreateProject(NewProjectDto newProject)
{
var path = $"project";
return(await Api.Post <NewProjectDto, ProjectDto>(path, newProject));
}
public async Task <IActionResult> CreateProject(NewProjectDto newProject)
{
// exclude task's additional configs since it may contain secret values
var requestBodyToLog = new NewProjectDto
{
Name = newProject.Name,
Members = newProject.Members,
Client = newProject.Client,
Models = newProject.Models,
Jobs = newProject.Jobs?.Select(j => new CreateJobDefinitionWithTasksDto
{
Name = j.Name,
Tasks = j.Tasks?.Select(t => new CreateJobTaskDefinitionDto
{
Name = t.Name,
Configs = t.Configs,
Provider = t.Provider,
Sequence = t.Sequence,
Type = t.Type
}).ToList()
}).ToList()
};
_logger.LogRequest("Creating project. Request body: {@requestBodyToLog}", requestBodyToLog);
try
{
var projectMembers = newProject.Members?.Select(m => (m.UserId, m.ProjectMemberRoleId)).ToList();
var currentUserId = User.GetUserId();
List <ProjectDataModel> models = null;
List <JobDefinition> jobs = null;
if (newProject.Models != null)
{
models = _mapper.Map <List <ProjectDataModel> >(newProject.Models);
}
if (newProject.Jobs != null)
{
jobs = _mapper.Map <List <JobDefinition> >(newProject.Jobs);
}
var createdProject = await _projectService.CreateProject(newProject.Name, newProject.DisplayName, newProject.Client, projectMembers, models, jobs, currentUserId);
var project = _mapper.Map <ProjectDto>(createdProject);
_logger.LogResponse("Project created. Response body: {@project}", project);
return(CreatedAtRoute("GetProjectById", new { projectId = project.Id }, project));
}
catch (DuplicateProjectException dupEx)
{
_logger.LogWarning(dupEx, "Duplicate project name");
return(BadRequest(dupEx.Message));
}
catch (ProjectDataModelNotFoundException modelEx)
{
_logger.LogWarning(modelEx, "Project data model not found");
return(BadRequest(modelEx.Message));
}
catch (DuplicateJobTaskDefinitionException dupTaskEx)
{
_logger.LogWarning(dupTaskEx, "Duplicate task name");
return(BadRequest(dupTaskEx.Message));
}
catch (InvalidTaskProviderTypeException providerTypeEx)
{
_logger.LogWarning(providerTypeEx, "Invalid provider type");
return(BadRequest(providerTypeEx.Message));
}
catch (TaskProviderNotInstalledException provEx)
{
_logger.LogWarning(provEx, "Provider not installed");
return(BadRequest(provEx.Message));
}
catch (ExternalServiceRequiredException esrEx)
{
_logger.LogWarning(esrEx, "External service required");
return(BadRequest(esrEx.Message));
}
catch (ExternalServiceNotFoundException esnfEx)
{
_logger.LogWarning(esnfEx, "External service not found");
return(BadRequest(esnfEx.Message));
}
catch (IncorrectExternalServiceTypeException iestEx)
{
_logger.LogWarning(iestEx, "Incorrect external service type");
return(BadRequest(iestEx.Message));
}
catch (JobTaskDefinitionTypeException taskEx)
{
_logger.LogWarning(taskEx, "Incorrect task definition type");
return(BadRequest(taskEx.Message));
}
}
public static CreateProjectCommand ToCommand(this NewProjectDto dto) => new CreateProjectCommand
{
Alias = dto.Alias,
DefaultBranchName = dto.DefaultBranchName,
Name = dto.Name
};
