public async Task <IActionResult> CreateProject(
[FromServices] CreateProject createProject,
ProjectViewModel vm)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var imagePath = await _fileManager.SaveImage(rootPath, vm.PrimaryImageFile);
var images = new List <string>();
if (vm.ImageFiles != null)
{
foreach (var image in vm.ImageFiles)
{
images.Add(await _fileManager.SaveImage(rootPath, image));
}
}
var request = new CreateProject.Request
{
Title = vm.Title,
Description = vm.Description,
Tags = vm.Tags,
PrimaryImage = imagePath,
Images = images
};
return(Ok(await createProject.Do(request)));
}
public void CanCreateEmptyRootProject()
{
var createProject = new CreateProject
{
Id = emptyRootProjectName,
Name = emptyRootProjectName
};
var response = Client.CreateProject(createProject);
Assert.That(response, Is.Not.Null);
Assert.That(response.Name, Is.Not.Null);
Assert.That(response.BuildTypes, Is.Not.Null);
Assert.That(response.Href, Is.Not.Null);
Assert.That(response.Id, Is.Not.Null);
Assert.That(response.Id, Is.EqualTo(createProject.Id));
Assert.That(response.Parameters, Is.Not.Null);
Assert.That(response.ParentProject, Is.Not.Null);
Assert.That(response.Templates, Is.Not.Null);
Assert.That(response.Projects, Is.Not.Null);
Assert.That(response.VcsRoots, Is.Not.Null);
Assert.That(response.WebUrl, Is.Not.Null);
Client.DeleteProject(new DeleteProject {
Locator = "id:" + response.Id
});
}
public void CanCreateBuildConfig()
{
var createProject = new CreateProject
{
Id = projectWithBuild,
Name = projectWithBuild,
};
var response = Client.CreateProject(createProject);
var createBuildConfig = new CreateBuildConfig
{
Locator = "id:" + createProject.Id,
Name = "BuildMe"
};
var buildConfigResponse = Client.CreateBuildConfig(createBuildConfig);
Assert.That(buildConfigResponse, Is.Not.Null);
Assert.That(buildConfigResponse.Name, Is.Not.Null);
Assert.That(buildConfigResponse.AgentRequirementsResponse, Is.Not.Null);
Assert.That(buildConfigResponse.ArtifactDependenciesResponse, Is.Not.Null);
Assert.That(buildConfigResponse.Builds, Is.Not.Null);
Assert.That(buildConfigResponse.FeaturesResponse, Is.Not.Null);
Assert.That(buildConfigResponse.SettingsResponse, Is.Not.Null);
Client.DeleteProject(new DeleteProject {
Locator = "id:" + response.Id
});
}
private CreateProject CreateNewProject()
{
CreateProject cp = new CreateProject();
cp.ShowDialog();
return(cp);
}
public async Task <bool> Create(CreateProject createProject, AppUser user)
{
string slug = createProject.ProjectName.ToLower().Replace(" ", "-");
Project project = new Project
{
ProjectName = createProject.ProjectName,
Slug = slug,
Author = user
};
project.UserProjects = new List <UserProject>
{
new UserProject
{
AppUser = user,
Project = project
}
};
await context.Projects.AddAsync(project);
int saveResult = await context.SaveChangesAsync();
System.Diagnostics.Debug.WriteLine(saveResult.ToString());
return(saveResult == 2);
}
public object Modify([FromBody] CreateProject createProject)
{
try
{
using (DDContext context = new DDContext())
{
context.Entry <CreateProject>(createProject).State = EntityState.Modified;
context.SaveChanges();
}
return(new NewErrorModel()
{
error = new Error(0, "修改成功！", "")
{
},
});
}
catch (Exception ex)
{
return(new NewErrorModel()
{
error = new Error(1, ex.Message, "")
{
},
});
}
}
public object Read(string taskId)
{
try
{
EFHelper <CreateProject> eFHelper = new EFHelper <CreateProject>();
CreateProject createProject = eFHelper.GetListBy(t => t.TaskId == taskId).ToList().First();
return(new NewErrorModel()
{
data = createProject,
error = new Error(0, "读取成功！", "")
{
},
});
}
catch (Exception ex)
{
return(new NewErrorModel()
{
error = new Error(1, ex.Message, "")
{
},
});
}
}
public void TestInitialize()
{
this.dbStub = new HatchlingCompanyDbContext(Effort.DbConnectionFactory.CreateTransient());
this.writerStub = new Mock <IWriter>();
this.mapperStub = new Mock <IMapper>();
this.createProjectService = new CreateProject(dbStub, writerStub.Object, mapperStub.Object);
}
public void CreateNewProject()
{
var project = new CreateProject("TestProject", "TestStarterKit");
Assert.AreEqual("TestProject", project.ProjectName);
Assert.AreEqual("TestStarterKit", project.StarterKit);
}
public void CreateProject_SupportedType_IsProject()
{
var writer = Substitute.For <IFileWriter>();
var sut = new CreateProject(writer);
sut.SupportedType.Should().Be <IProject>();
}
public Project CreateProject(CreateProject project)
{
entity.Project entity = mapper.Map <entity.Project>(project);
unitOfWork.ProjectRepository.Add(entity);
unitOfWork.Commit();
return(mapper.Map <dto.Project>(entity));
}
/// <summary>
/// Handles the specified <see cref="CreateProject"/> command.
/// </summary>
/// <param name="command">The command.</param>
/// <exception cref="System.ArgumentNullException">When projectId is null.</exception>
public void Handle(CreateProject command)
{
if (command.Id == null)
{
throw new ArgumentNullException("command", "ProjectId is null");
}
var project = this.GetOrCreateProject(command.Id);
var department = this.GetDepartment(command.DepartmentId);
var classification = this.GetPpsClassification(command.PpsClassificationId);
if (department == null)
{
throw new ArgumentNullException("department");
}
if (classification == null)
{
throw new ArgumentNullException("classification");
}
project.CreateProject(command.Name, command.Description, command.ProjectOrderer,
command.RecievingOrganization, command.Mandatory,
command.StartDate, command.EndDate, department, classification, command.OwnerId, command.Manager);
_projectRepository.Save(project);
}
public void Create(IOutput output, string?path = null, bool overwrite = false)
{
if (output is not ISolution solution)
{
throw new NotSupportedException($"{nameof(CreateSolution)} only supports {SupportedType.FullName} output types.");
}
path ??= string.Empty;
if (solution.Directory != null && !Path.IsPathRooted(solution.Directory))
{
solution.Directory = Path.Combine(path, solution.Directory);
}
if (!string.IsNullOrWhiteSpace(solution.Directory))
{
var s = new DirectoryInfo(solution.Directory);
if (!s.Exists)
{
s.Create();
}
}
foreach (var file in solution.Files)
{
var fileOutput = new CreateFile(_fileWriter);
fileOutput.Create(file, path);
}
foreach (var project in solution.Projects)
{
var projectOutput = new CreateProject(_fileWriter);
projectOutput.Create(project, path);
}
}
private async Task <CreateProjectResult> CreateProjectAsync(
CreateProject createProject,
CancellationToken cancellationToken)
{
if (!createProject.IsValid)
{
return(new CreateProjectResult(new ValidationError("Id or organization id is invalid")));
}
using (IDocumentSession session = _documentStore.OpenSession())
{
var data = new ProjectData
{
Id = createProject.Id,
OrganizationId = createProject.OrganizationId
};
session.Store(data);
await session.SaveChangesAsync(cancellationToken);
}
_logger.Information("Created project with id {Id}", createProject.Id);
return(new CreateProjectResult(createProject.Id));
}
public static CreateProjectViewModel CreateProjectViewModelFromCreateProject(CreateProject createProject)
{
CreateProjectViewModel createProjectViewModel = new CreateProjectViewModel();
createProjectViewModel.ProjectId = createProject.ProjectId;
createProjectViewModel.FirstName = createProject.FirstName;
createProjectViewModel.LastName = createProject.LastName;
createProjectViewModel.ObjectState = ObjectState.Unchanged;
foreach (CreateProjectItem createProjectItem in createProject.CreateProjectItems)
{
CreateProjectItemViewModel createProjectItemViewModel = new CreateProjectItemViewModel();
createProjectItemViewModel.ProjectItemId = createProjectItem.ProjectItemId;
createProjectItemViewModel.StartDate = createProjectItem.StartDate;
createProjectItemViewModel.EndDate = createProjectItem.EndDate;
createProjectItemViewModel.Credits = createProjectItem.Credits;
createProjectItemViewModel.ObjectState = ObjectState.Unchanged;
createProjectItem.ProjectId = createProjectItemViewModel.ProjectId;
createProjectViewModel.CreateProjectItems.Add(createProjectItemViewModel);
}
return(createProjectViewModel);
}
public void CreateProject(string directory, string name)
{
CreateProject ProjectCreator = new CreateProject(directory, name);
RenderFile.RenderWEHYControl();
RenderFile.RenderParaChay();
}
private dynamic CreateProject()
{
try
{
if (!isAuthenticated())
{
return(Unauthorized());
}
var data = this.Bind <Dictionary <string, string> >();
var cmd = new CreateProject(Guid.Parse(data["id"]), data["title"], data["category"], data["creator"]);
var validator = new CreateProjectValidator();
validator.Validate(cmd);
_service.CreateProject(cmd);
return(NotImplemented());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ActionResult CreateProject([FromBody] CreateProject createProject, [FromRoute] int teamId)
{
teamService.ValidTeam(teamId);
int id = service.CreateProject(createProject, teamId);
return(Created($"api/projects/{id}", null));
}
public void TestFilenameExistsExist()
{
CreateProject.CreateFolder(@"Model\exist");
LoadSave.ZipFolderRenameToDCIP(@"Model\exist");
Assert.True(ValidateInput.FileNameExists("exist", @"Model\"));
LoadSave.DeleteOriginalFolder(@"Model\exist");
System.IO.File.Delete(@"Model\exist.dcip");
}
public async Task <Model.Project> GenerateProject(CreateProject command)
{
var project = new Model.Project(Guid.NewGuid(), command.Name);
project.Created();
command.CreatedId = project.Id;
return(project);
}
private void Btn_Create_Click(object sender, RoutedEventArgs e)
{
CreateProject.CreateFolderStructure(Txt_Project.Text);
TxtCreatedProject.IsEnabled = true;
BtnProjectConfig.IsEnabled = true;
TxtCreatedProject.Text = Txt_Project.Text;
Txt_Project.Text = string.Empty;
}
public async Task <IActionResult> Create(CreateProject createProject)
{
var response = await azureDevOpsApi.CreateProject(createProject);
return(!response.IsSuccessStatusCode ?
StatusCode((int)response.StatusCode, response.Error) :
Ok(response.Content));
}
public void Post([FromBody] CreateProject command)
{
_eventEmitter.Emit(Feature, new ProjectCreated
{
Name = command.Name,
Id = command.Id
});
}
public void TestZipFolderRenameToDCIPOK()
{
Assert.False(File.Exists(@"Model\TestZipFolderRenameToDCIPOK.dcip"));
CreateProject.CreateFolder(@"Model\TestZipFolderRenameToDCIPOK");
LoadSave.ZipFolderRenameToDCIP(@"Model\TestZipFolderRenameToDCIPOK");
Assert.True(File.Exists(@"Model\TestZipFolderRenameToDCIPOK.dcip"));
Directory.Delete(@"Model\TestZipFolderRenameToDCIPOK");
File.Delete(@"Model\TestZipFolderRenameToDCIPOK.dcip");
}
public void CreateProject_Test()
{
var createProejct = new CreateProject();
projectRepoMock.Setup(x => x.CreateProject(It.IsAny <Project>())).Verifiable();
projectService.CreateProject(createProejct, 1);
projectRepoMock.Verify(x => x.CreateProject(It.IsAny <Project>()), Times.Once);
}
public void Post([FromBody] CreateProject command)
{
Apply(command.Id, new ProjectCreated
{
Name = command.Name,
Id = command.Id,
NationalSocietyId = command.NationalSocietyId,
DataOwnerId = command.DataOwnerId,
});
}
public bool CreateProject(CreateProject newProject)
{
var request = GetRequest(JiraObjectEnum.Projects, new Dictionary <string, string>(), new Dictionary <string, string>());
request.Method = Method.POST;
request.AddJsonBody(newProject);
var response = this.Client.Execute(request);
return(response.StatusCode == System.Net.HttpStatusCode.Created);
}
public void Post([FromBody] CreateProject command)
{
_eventEmitter.Emit(Feature, new ProjectCreated
{
Name = command.Name,
Id = command.Id,
NationalSocietyId = command.NationalSocietyId,
OwnerUserId = command.OwnerUserId
});
}
public async Task <IActionResult> CreateProject(CreateProject createProject)
{
await Task.Delay(100);
return(Ok(new Project
{
Id = Guid.NewGuid(),
Name = createProject.Name
}));
}
public int CreateProject(CreateProject createProject, int teamId)
{
Project project = mapper.Map <Project>(createProject);
project.OwnerTeamId = teamId;
projectRepository.CreateProject(project);
return(project.Id);
}
private static string GetProjectJson(CreateProject project, ProjectJson type)
{
var template = string.Empty;
List<string> references = new List<string>();
switch (type)
{
case ProjectJson.BusinessCodeGenerator:
template = Resources.CSharp.ProjectJsonCodeGenerator;
references.Add($"{project.Parameter.SolutionParam.SolutionName}.Business.Contract");
references.Add($"{project.Parameter.SolutionParam.SolutionName}.Business.Entity");
references.Add($"{project.Parameter.SolutionParam.SolutionName}.Business.Resource");
break;
case ProjectJson.BusinessConcrete:
template = Resources.CSharp.ProjectJsonConcrete;
references.Add($"{project.Parameter.SolutionParam.SolutionName}.Business.Contract");
references.Add($"{project.Parameter.SolutionParam.SolutionName}.Business.Data");
references.Add($"{project.Parameter.SolutionParam.SolutionName}.Business.Entity");
references.Add($"{project.Parameter.SolutionParam.SolutionName}.Business.Resource");
break;
case ProjectJson.BusinessContract:
template = Resources.CSharp.ProjectJsonContract;
references.Add($"{project.Parameter.SolutionParam.SolutionName}.Business.Entity");
break;
case ProjectJson.BusinessData:
template = Resources.CSharp.ProjectJsonData;
references.Add($"{project.Parameter.SolutionParam.SolutionName}.Business.Entity");
break;
case ProjectJson.BusinessEntity:
template = Resources.CSharp.ProjectJsonEntity;
break;
case ProjectJson.BusinessFactory:
template = Resources.CSharp.ProjectJsonFactory;
references.Add($"{project.Parameter.SolutionParam.SolutionName}.Business.Concrete");
references.Add($"{project.Parameter.SolutionParam.SolutionName}.Business.Contract");
references.Add($"{project.Parameter.SolutionParam.SolutionName}.Business.Data");
references.Add($"{project.Parameter.SolutionParam.SolutionName}.Business.Entity");
break;
case ProjectJson.BusinessResource:
template = Resources.CSharp.ProjectJsonResource;
break;
case ProjectJson.ViewWebSimple:
template = Resources.CSharp.ProjectJsonEntity;
break;
case ProjectJson.BusinessTest:
template = Resources.CSharp.ProjectJsonTest;
break;
default:
break;
}
return CommandExtencionsCommon.MergeProjectJson(template, references);
}
public static CreateProject AddAspNetProject(this CreateSolution solution, string name, bool full)
{
CreateProject project = new CreateProject(new CreateProjectParam(solution.Parameter, name) { Template = Resources.AspNet.ProjectXproj });
project
.AddAspNetProjectJson(full)
.AddAspNetWebConfig()
.AddAspNetStart(full)
.AddAspNetSettings();
solution.Add(project);
return project;
}
public void CanCreateEmptyRootProject()
{
var createProject = new CreateProject
{
Id = emptyRootProjectName,
Name = emptyRootProjectName
};
var response = Client.CreateProject(createProject);
Assert.That(response, Is.Not.Null);
Assert.That(response.Name, Is.Not.Null);
Assert.That(response.BuildTypes, Is.Not.Null);
Assert.That(response.Href, Is.Not.Null);
Assert.That(response.Id, Is.Not.Null);
Assert.That(response.Id, Is.EqualTo(createProject.Id));
Assert.That(response.Parameters, Is.Not.Null);
Assert.That(response.ParentProject, Is.Not.Null);
Assert.That(response.Templates, Is.Not.Null);
Assert.That(response.Projects, Is.Not.Null);
Assert.That(response.VcsRoots, Is.Not.Null);
Assert.That(response.WebUrl, Is.Not.Null);
Client.DeleteProject(new DeleteProject { Locator = "id:" + response.Id });
}
public void CanCreateBuildConfig()
{
var createProject = new CreateProject
{
Id = projectWithBuild,
Name = projectWithBuild,
};
var response = Client.CreateProject(createProject);
var createBuildConfig = new CreateBuildConfig
{
Locator = "id:" + createProject.Id,
Name = "BuildMe"
};
var buildConfigResponse = Client.CreateBuildConfig(createBuildConfig);
Assert.That(buildConfigResponse, Is.Not.Null);
Assert.That(buildConfigResponse.Name, Is.Not.Null);
Assert.That(buildConfigResponse.AgentRequirementsResponse, Is.Not.Null);
Assert.That(buildConfigResponse.ArtifactDependenciesResponse, Is.Not.Null);
Assert.That(buildConfigResponse.Builds, Is.Not.Null);
Assert.That(buildConfigResponse.FeaturesResponse, Is.Not.Null);
Assert.That(buildConfigResponse.SettingsResponse, Is.Not.Null);
Client.DeleteProject(new DeleteProject { Locator = "id:" + response.Id });
}
public void CreateNewProject()
{
var project = new CreateProject("TestProject", "TestStarterKit");
Assert.AreEqual("TestProject", project.ProjectName);
Assert.AreEqual("TestStarterKit", project.StarterKit);
}
private CreateProjectResponse CreateTeamCityProject(CreateSpaBuildProject request)
{
var createProject = new CreateProject
{
Name = request.Name,
ParentProject = new ProjectLocator
{
Locator = "id:_Root"
},
Id = "SS_" + request.OwnerName + "_" + request.Name
};
var createProjResponse = TeamCityClient.CreateProject(createProject);
return createProjResponse;
}
public void CanCreateTechStacksBuildConfig()
{
var createProject = new CreateProject { Name = "TestTS" };
var createProjResponse = Client.CreateProject(createProject);
var createVcs = new CreateVcsRoot
{
Name = "GitHub_Test1",
VcsName = VcsRootTypes.Git,
Project = new CreateVcsRootProject { Id = createProjResponse.Id },
Properties = new CreateVcsRootProperties
{
Properties = new List<CreateVcsRootProperty>
{
new CreateVcsRootProperty
{
Name = "url",
Value = "https://github.com/ServiceStackApps/TechStacks.git"
},
new CreateVcsRootProperty
{
Name = "authMethod",
Value = "ANONYMOUS"
},
new CreateVcsRootProperty
{
Name = "branch",
Value = "refs/heads/master"
}
}
}
};
var vcsResponse = Client.CreateVcsRoot(createVcs);
var createEmptyBuild = new CreateBuildConfig {Locator = "id:" + createProjResponse.Id, Name = "Build"};
var emptyBuildConfigResponse = Client.CreateBuildConfig(createEmptyBuild);
var attachRequest = new AttachVcsEntries
{
BuildTypeLocator = "id:" + emptyBuildConfigResponse.Id,
VcsRootEntries = new List<AttachVcsRootEntry>
{
new AttachVcsRootEntry
{
Id = vcsResponse.Id,
VcsRoot = new AttachVcsRoot
{
Id = vcsResponse.Id
}
}
}
};
var attachResponse = Client.AttachVcsEntries(attachRequest);
//Create build steps
var npmStepRequest = new CreateBuildStep
{
BuildTypeLocator = "id:" + emptyBuildConfigResponse.Id,
Name = "NPM Install",
TypeId = BuidStepTypes.Npm,
StepProperties = new CreateTeamCityProperties
{
Properties = new List<CreateTeamCityProperty>
{
new CreateTeamCityProperty
{
Name = "npm_commands",
Value = "install\ninstall bower\ninstall grunt\ninstall grunt-cli"
},
new CreateTeamCityProperty
{
Name = "teamcity.build.workingDir",
Value = "src/TechStacks/TechStacks"
},
new CreateTeamCityProperty
{
Name = "teamcity.step.mode",
Value = "default"
}
}
}
};
var npmStepResponse = Client.CreateBuildStep(npmStepRequest);
}
public void CanCreateNewVcsRoot()
{
var proj = new CreateProject
{
Name = "TestProj123"
};
CreateProjectResponse projRes = null;
try
{
projRes = Client.CreateProject(proj);
}
catch (Exception e)
{
Client.DeleteProject(new DeleteProject { Locator = "name:TestProj123" });
projRes = Client.CreateProject(proj);
}
var createVcs = new CreateVcsRoot
{
Name = "TestVcs1",
VcsName = "jetbrains.git",
Project = new CreateVcsRootProject { Id = projRes.Id },
Properties = new CreateVcsRootProperties
{
Properties = new List<CreateVcsRootProperty>
{
new CreateVcsRootProperty
{
Name = "url",
Value = "https://github.com/ServiceStackApps/StackApis.git"
},
new CreateVcsRootProperty
{
Name = "authMethod",
Value = "ANONYMOUS"
},
new CreateVcsRootProperty
{
Name = "branch",
Value = "refs/heads/master"
}
}
}
};
CreateVcsRootResponse response = null;
try
{
response = Client.CreateVcsRoot(createVcs);
}
catch (Exception e)
{
Client.DeleteProject( new DeleteProject { Locator = "id:" + projRes.Id });
throw;
}
Assert.That(response, Is.Not.Null);
Assert.That(response.Name, Is.EqualTo("TestVcs1"));
Assert.That(response.Href, Is.Not.Null);
Assert.That(response.Project, Is.Not.Null);
Assert.That(response.Properties, Is.Not.Null);
Assert.That(response.Properties.Count, Is.EqualTo(3));
Assert.That(response.VcsRootInstances, Is.Not.Null);
Client.DeleteProject(new DeleteProject { Locator = "id:" + projRes.Id });
}
public static CreateProject AddCSharpProject(this CreateSolution solution, string name)
{
CreateProject project = new CreateProject(new CreateProjectParam(solution.Parameter, name) { Template = Resources.CSharp.ProjectClassXproj });
solution.Add(project);
return project;
}
