public void CreateProject(IProjectGenerator projectGenerator)
{
var folder = Path.Combine(_outputFolder, projectGenerator.ProjectName);
var csProjFile = Path.Combine(folder, projectGenerator.ProjectName + ".csproj");
//Do not overgen the project file
if (File.Exists(csProjFile))
{
return;
}
//If the project file does not exist then create it
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
var projectFileName = projectGenerator.ProjectTemplate.Replace(".vstemplate", ".csproj");
var embedPath = System.Reflection.Assembly.GetExecutingAssembly().GetName().Name + $".Resources.{projectFileName}";
var content = GetResource(embedPath);
//Copy the template and project file to a temp folder and perform replacements
var tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
Directory.CreateDirectory(tempPath);
File.WriteAllText(csProjFile, content);
projectGenerator.OnAfterGenerate();
}
private async Task <int> HandleAndReturnExitCodeAsync(CreateOptions options)
{
if (options.UnitTest)
{
options.ProjectType += "UnitTest";
}
if (!(await _projectGeneratorFactory.SupportsProjectType(options.ProjectType)))
{
_logger.Warn("Project type {ProjectType} not supported.", options.ProjectType);
return(-1);
}
_projectDirectoryProvider.SolutionDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, options.Name);
_logger.Info($"Generating solution directory \"{options.Name}\".");
_directoryManipulator.CreateDirectory(_projectDirectoryProvider.SolutionDirectory);
IProjectGenerator projectGenerator = _projectGeneratorFactory.CreateGeneratorFor(options.ProjectType);
try
{
await projectGenerator.GenerateProject(options.Name);
if (options.InitGit)
{
projectGenerator.InitGit();
if (options.UseGitMetadata)
{
await projectGenerator.AddGitMetadata();
}
if (options.ReadmeDescription != null)
{
projectGenerator.AddReadme(options.Name, options.ReadmeDescription);
}
if (options.CommitMessage != null)
{
projectGenerator.Commit(options.CommitMessage);
}
if (options.GitRemote != null)
{
projectGenerator.AddRemote(options.GitRemote);
if (options.Push)
{
projectGenerator.Push();
}
}
}
}
catch (Exception)
{
_logger.Error("An error ocurred during project generation.");
}
return(0);
}
private int GetFileCount(IProjectGenerator projectGenerator, System.Type[] generatorTypes)
{
var retval = 0;
try
{
var projectItemGenerators = GetProjectItemGenerators(projectGenerator);
foreach (var projectItemGeneratorType in projectItemGenerators)
{
try
{
retval += GetFileCount(projectItemGeneratorType, generatorTypes);
}
catch (Exception ex)
{
nHydrateLog.LogWarning(ex);
}
}
return(retval);
}
catch (Exception ex)
{
throw;
}
}
void IProjectGeneratorProjectCreator.CreateProject(IProjectGenerator projectGenerator)
{
try
{
//If there is no project defined then do nothing
if (string.IsNullOrEmpty(projectGenerator.ProjectTemplate))
{
return;
}
var newProject = EnvDTEHelper.Instance.GetProject(projectGenerator.ProjectName);
if (newProject != null)
{
newProject.Delete();
}
var templateFullName = Path.Combine(AddinAppData.Instance.ExtensionDirectory, projectGenerator.ProjectTemplate);
//Copy the template and project file to a temp folder and perform replacements
var tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
Directory.CreateDirectory(tempPath);
//Copy template
var fi = new FileInfo(templateFullName);
var targetFile = Path.Combine(tempPath, fi.Name);
File.Copy(templateFullName, targetFile, true);
//Copy project
var sourceFile = templateFullName.Replace(".vstemplate", ".csproj");
fi = new FileInfo(sourceFile);
if (File.Exists(sourceFile))
{
targetFile = Path.Combine(tempPath, fi.Name);
File.Copy(sourceFile, targetFile, true);
fi = new FileInfo(targetFile);
projectGenerator.GenerateCompanySpecificFile(tempPath, fi.Name);
}
//Copy the assembly file over
sourceFile = Path.Combine(AddinAppData.Instance.ExtensionDirectory, "AssemblyInfo.cs");
if (File.Exists(sourceFile))
{
var propertyPath = Path.Combine(tempPath, "Properties");
Directory.CreateDirectory(propertyPath);
var t = Path.Combine(propertyPath, "AssemblyInfo.cs");
File.Copy(sourceFile, t, true);
fi = new FileInfo(t);
projectGenerator.GenerateCompanySpecificFile(propertyPath, fi.Name);
}
newProject = EnvDTEHelper.Instance.CreateProjectFromTemplate(targetFile, projectGenerator.ProjectName, projectGenerator.Model.OutputTarget);
Directory.Delete(tempPath, true);
projectGenerator.OnAfterGenerate();
}
catch (Exception ex)
{
throw;
}
}
private void GenerateProject(GeneratorOptions generatorOptions)
{
generatorOptions.CreatedFor = $"{FeatureContext.FeatureInfo.Title}_{ScenarioContext.ScenarioInfo.Title}";
generatorOptions._TargetFolder = Path.Combine(TestFolders.TempFolder, @"DeveroomTest\DS_{options}");
generatorOptions.FallbackNuGetPackageSource = TestFolders.GetInputFilePath("ExternalPackages");
_projectGenerator = generatorOptions.CreateProjectGenerator(s => _outputHelper.WriteLine(s));
_projectGenerator.Generate();
}
/* ----------------------------------------------------------------- *
* constructors *
* ----------------------------------------------------------------- */
/// <summary>
/// Initializes a new instance of the <see cref="ProjectController"/> class.
/// </summary>
/// <param name="uiConfigService">Injected Initializr configuration service.</param>
/// <param name="projectGenerator">Injected project generator.</param>
/// <param name="logger">Injected logger.</param>
public ProjectController(
IUiConfigService uiConfigService,
IProjectGenerator projectGenerator,
ILogger <ProjectController> logger)
: base(logger)
{
_uiConfigService = uiConfigService;
_projectGenerator = projectGenerator;
}
public GenerateProjectsTask(
IProjectLoader projectLoader,
IProjectGenerator projectGenerator,
ISolutionGenerator solutionGenerator,
IJSILProvider jsilProvider)
{
this.m_ProjectLoader = projectLoader;
this.m_ProjectGenerator = projectGenerator;
this.m_SolutionGenerator = solutionGenerator;
this.m_JSILProvider = jsilProvider;
}
/* ----------------------------------------------------------------- *
* constructors *
* ----------------------------------------------------------------- */
/// <summary>
/// Initializes a new instance of the <see cref="ProjectController"/> class.
/// </summary>
/// <param name="configService">Injected Initializr configuration service.</param>
/// <param name="projectGenerator">Injected project generator.</param>
/// <param name="archiverRegistry">Injected archiver registry.</param>
/// <param name="logger">Injected logger.</param>
public ProjectController(
IInitializrConfigService configService,
IProjectGenerator projectGenerator,
IArchiverRegistry archiverRegistry,
ILogger <ProjectController> logger)
: base(logger)
{
_configService = configService;
_projectGenerator = projectGenerator;
_archiverRegistry = archiverRegistry;
}
private void OnGenerate(object sender, EventArgs e)
{
using (GenCodeDialog dialog = new GenCodeDialog(Model))
{
if (dialog.ShowDialog(Workspace.ActiveWindow) == DialogResult.OK)
{
IProjectGenerator gen = ServiceRegistry.Instance[typeof(IProjectGenerator)] as IProjectGenerator;
gen.Generate(Model.CurrentProject);
}
}
}
public Worker(
ILogger <Worker> logger,
IConfigService configService,
IProjectGenerator projectGenerator,
IProjectRunner projectRunner
)
{
_logger = logger;
_configService = configService;
_projectGenerator = projectGenerator;
_projectRunner = projectRunner;
}
public GenerateProjectsTask(
IProjectLoader projectLoader,
IProjectGenerator projectGenerator,
ISolutionGenerator solutionGenerator,
IJSILProvider jsilProvider,
IPackageRedirector packageRedirector)
{
this.m_ProjectLoader = projectLoader;
this.m_ProjectGenerator = projectGenerator;
this.m_SolutionGenerator = solutionGenerator;
this.m_JSILProvider = jsilProvider;
this.m_PackageRedirector = packageRedirector;
}
/// <summary>
/// Initializes a new instance of the <see cref="CSharpTestProjectBuilder"/> class.
/// </summary>
/// <param name="sbs">The system wide build system.</param>
/// <param name="buildData">The build data properties.</param>
/// <param name="projectGenerator">The project generator.</param>
/// <param name="createGeneratorCallback">The callback to create new code
/// generators per test class <see cref="CodeNamespace"/>.</param>
/// <param name="logger">The logging method.</param>
public CSharpTestProjectBuilder(
IBuildSystem sbs,
IBuildDataDictionary buildData,
IProjectGenerator projectGenerator,
Func <IBuildSystem, IBuildDataDictionary, ICodeGeneratorParameters, CodeNamespace, ICodeGenerator> createGeneratorCallback,
Action <string> logger)
: base(sbs, projectGenerator, OldOnCreateCodeGenerator, logger)
{
Guard.NotNull(() => buildData, buildData);
Guard.NotNull(() => createGeneratorCallback, createGeneratorCallback);
this.createGeneratorCallback = createGeneratorCallback;
// properties = SetUpBuildProperties();
this.properties = SetUpBuildProperties(buildData);
}
/// <summary>
/// Initializes a new instance of the <see cref="TestProjectBuilder"/> class.
/// </summary>
/// <param name="sbs">The system wide build system.</param>
/// <param name="projectGenerator">The project generator.</param>
/// <param name="createGeneratorCallback">The callback to create new code
/// generators per test class <see cref="CodeNamespace"/>.</param>
/// <param name="logger">The logging method.</param>
public TestProjectBuilder(
IBuildSystem sbs,
IProjectGenerator projectGenerator,
Func<IBuildSystem, ICodeGeneratorParameters, CodeNamespace, ICodeGenerator> createGeneratorCallback,
Action<string> logger)
{
Guard.NotNull(() => sbs, sbs);
Guard.NotNull(() => projectGenerator, projectGenerator);
Guard.NotNull(() => createGeneratorCallback, createGeneratorCallback);
// Guard.NotNull(() => logger, logger);
this.sbs = sbs;
this.logger = logger;
this.csharpProjectGenerator = projectGenerator;
this.createGeneratorCallback = createGeneratorCallback;
}
/// <summary>
/// Initializes a new instance of the <see cref="TestProjectBuilder"/> class.
/// </summary>
/// <param name="sbs">The system wide build system.</param>
/// <param name="projectGenerator">The project generator.</param>
/// <param name="createGeneratorCallback">The callback to create new code
/// generators per test class <see cref="CodeNamespace"/>.</param>
/// <param name="logger">The logging method.</param>
public TestProjectBuilder(
IBuildSystem sbs,
IProjectGenerator projectGenerator,
Func <IBuildSystem, ICodeGeneratorParameters, CodeNamespace, ICodeGenerator> createGeneratorCallback,
Action <string> logger)
{
Guard.NotNull(() => sbs, sbs);
Guard.NotNull(() => projectGenerator, projectGenerator);
Guard.NotNull(() => createGeneratorCallback, createGeneratorCallback);
// Guard.NotNull(() => logger, logger);
this.sbs = sbs;
this.logger = logger;
this.csharpProjectGenerator = projectGenerator;
this.createGeneratorCallback = createGeneratorCallback;
}
protected void GenerateProjectItems(IProjectGenerator projectGenerator)
{
var projectItemGenerators = GetProjectItemGenerators(projectGenerator);
foreach (var projectItemGeneratorType in projectItemGenerators)
{
try
{
GenerateProjectItems(projectItemGeneratorType);
}
catch (Exception ex)
{
nHydrateLog.LogWarning(ex);
}
}
}
public GenerateProjectsTask(
IProjectLoader projectLoader,
IProjectGenerator projectGenerator,
ISolutionGenerator solutionGenerator,
IJSILProvider jsilProvider,
IPackageRedirector packageRedirector,
IModuleExecution moduleExecution,
IFeatureManager featureManager)
{
m_ProjectLoader = projectLoader;
m_ProjectGenerator = projectGenerator;
m_SolutionGenerator = solutionGenerator;
m_JSILProvider = jsilProvider;
m_PackageRedirector = packageRedirector;
_moduleExecution = moduleExecution;
_featureManager = featureManager;
}
public ConsoleClient(
IDepartmentGenerator departmentGenerator,
IEmployeeGenerator employeeGenerator,
IProjectGenerator projectGenerator,
IReportGenerator reportGenerator,
ICompanyContext companyContext,
IWorkUnit unitOfWork,
IXmlProvider xmlProvider)
{
this.departmentGenerator = departmentGenerator;
this.employeeGenerator = employeeGenerator;
this.projectGenerator = projectGenerator;
this.reportGenerator = reportGenerator;
this.companyContext = companyContext;
this.unitOfWork = unitOfWork;
this.xmlProvider = xmlProvider;
}
public GenerateProjectsTask(
IProjectLoader projectLoader,
IProjectGenerator projectGenerator,
ISolutionGenerator solutionGenerator,
IJSILProvider jsilProvider,
IPackageRedirector packageRedirector,
IModuleExecution moduleExecution,
IFeatureManager featureManager)
{
m_ProjectLoader = projectLoader;
m_ProjectGenerator = projectGenerator;
m_SolutionGenerator = solutionGenerator;
m_JSILProvider = jsilProvider;
m_PackageRedirector = packageRedirector;
_moduleExecution = moduleExecution;
_featureManager = featureManager;
}
internal ProjectController Build()
{
if (_config is null)
{
_config = new InitializrConfig
{
ProjectMetadata = new ProjectMetadata
{
Packaging = new ProjectMetadata.SingleSelectList
{
Default = "myarchive",
},
},
ProjectTemplates = new ProjectTemplateConfiguration[0],
};
}
if (_generator is null)
{
_generator = new TestProjectGenerator();
}
if (_registry is null)
{
var mock = new Mock <IArchiverRegistry>();
mock.Setup(reg => reg.Lookup(It.Is <string>(s => s.Equals("myarchive"))))
.Returns(new TestArchiver());
_registry = mock.Object;
}
var configurationService = new Mock <IInitializrConfigService>();
configurationService.Setup(svc => svc.GetInitializrConfig()).Returns(_config);
var logger = new NullLogger <ProjectController>();
var projectController =
new ProjectController(configurationService.Object, _generator, _registry, logger)
{
ControllerContext =
{
HttpContext = new DefaultHttpContext()
}
};
return(projectController);
}
public ActionResult Get([FromServices] IProjectGenerator generator, [FromBody] ProjectMetadata metadata)
{
if (metadata.Tags != null)
{
foreach (var kvp in metadata.Tags.Where(x => x.Value is JsonElement).ToList())
{
var jsonElem = (JsonElement)kvp.Value;
if (jsonElem.ValueKind == JsonValueKind.True)
{
metadata.Tags[kvp.Key] = true;
}
else if (jsonElem.ValueKind == JsonValueKind.False)
{
metadata.Tags[kvp.Key] = false;
}
else
{
metadata.Tags[kvp.Key] = jsonElem.ToString();
}
}
}
try
{
byte[] templateBytes = generator.Generate(metadata);
return(new FileContentResult(templateBytes, "application/zip")
{
FileDownloadName = $"{metadata.ProjectName}.zip"
});
}
catch (TemplateException ex)
{
Response.StatusCode = (int)HttpStatusCode.InternalServerError;
return(Content(ex.Message));
}
catch (Exception ex)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(Content(ex.Message));
}
}
public SolutionGenerator(IFileSystem fileSystem, IProjectGenerator projectGenerator)
{
this.fileSystem = fileSystem;
this.projectGenerator = projectGenerator;
}
private List <Type> GetProjectItemGenerators(IProjectGenerator projectGenerator)
{
return(GetGeneratorsImpl(projectGenerator));
}
public void Generate(int projectCount, IProjectGenerator generator, IEnumerable <IProjectModifier> modifiers, string solutionPath)
{
var projects = new List <IProject>();
for (var i = 0; i < projectCount; i++)
{
var project = generator.Generate(i);
Directory.CreateDirectory(Path.Combine(solutionPath, project.RelativeProjectPath));
foreach (var modifier in modifiers)
{
modifier.Modify(project, projects, solutionPath);
}
using var stream = new FileStream(Path.Combine(solutionPath, project.RelativeProjectFilePath), FileMode.Create);
using var writer = XmlWriter.Create(stream, new XmlWriterSettings { OmitXmlDeclaration = true, Indent = true, IndentChars = " " });
project.ProjectXml.Save(writer);
projects.Add(project);
}
using (var stream = File.OpenWrite(Path.Combine(solutionPath, $"{Path.GetFileName(solutionPath)}.sln")))
using (var writer = new StreamWriter(stream, Encoding.ASCII))
{
writer.WriteLine();
writer.WriteLine(@"Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
VisualStudioVersion = 15.0.28010.2019
MinimumVisualStudioVersion = 10.0.40219.1");
foreach (IProject project in projects)
{
writer.WriteLine(
$@"Project(""{project.ProjectType:B}"") = ""{project.ProjectName}"", ""{project.RelativeProjectFilePath}"", ""{project.ProjectGuid:B}""
EndProject");
}
writer.WriteLine(
@"Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution");
foreach (var project in projects)
{
writer.WriteLine(
$@" {project.ProjectGuid:B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{project.ProjectGuid:B}.Debug|Any CPU.Build.0 = Debug|Any CPU
{project.ProjectGuid:B}.Release|Any CPU.ActiveCfg = Release|Any CPU
{project.ProjectGuid:B}.Release|Any CPU.Build.0 = Release|Any CPU");
}
writer.WriteLine(
$@" EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {Guid.NewGuid():B}
EndGlobalSection
EndGlobal");
}
}
private List<Type> GetProjectItemGenerators(IProjectGenerator projectGenerator)
{
return GetGeneratorsImpl(projectGenerator);
}
private int GetFileCount(IProjectGenerator projectGenerator, System.Type[] generatorTypes)
{
var retval = 0;
try
{
var projectItemGenerators = GetProjectItemGenerators(projectGenerator);
foreach (var projectItemGeneratorType in projectItemGenerators)
{
try
{
retval += GetFileCount(projectItemGeneratorType, generatorTypes);
}
catch (Exception ex)
{
nHydrateLog.LogWarning(ex);
}
}
return retval;
}
catch (Exception ex)
{
throw;
}
}
private void GenerateProjectItems(IProjectGenerator projectGenerator)
{
try
{
var projectItemGenerators = GetProjectItemGenerators(projectGenerator);
foreach (var projectItemGeneratorType in projectItemGenerators)
{
try
{
GenerateProjectItems(projectItemGeneratorType);
}
catch (Exception ex)
{
nHydrateLog.LogWarning(ex);
}
}
}
catch (Exception ex)
{
throw;
}
}
protected List <Type> GetProjectItemGenerators(IProjectGenerator projectGenerator) => GetGeneratorsImpl(projectGenerator);
