internal static void CompileTemplate(EngineHost host, string projectRootFolder, string inputPath,
string rootNamespace, string newLine)
{
var className = Path.GetFileNameWithoutExtension(inputPath);
host.TemplateFile = Path.GetFileName(inputPath);
var targetFolder = Path.GetDirectoryName(inputPath);
var absoluteInputPath = Path.Combine(projectRootFolder, inputPath);
var inputText = File.ReadAllText(absoluteInputPath);
var fullNamespace = rootNamespace;
if (!String.IsNullOrEmpty(targetFolder))
{
fullNamespace += "." + ConvertPathToNamespace(targetFolder);
}
var fileName = "{0}.Generated.cs".FormatInvariant(className);
var relativeOutputPath = Path.Combine(targetFolder, fileName);
var absoluteOutputPath = Path.Combine(projectRootFolder, relativeOutputPath);
using (var writer = new StreamWriter(absoluteOutputPath, false, Encoding.UTF8))
{
writer.NewLine = newLine;
GenerateCode(host, inputText, fullNamespace, className, writer);
}
}
/// <summary>
/// Performs the template compilation.
/// </summary>
///
/// <returns>
/// <see langword="true"/> if the processing succeeded; <see langword="false"/> otherwise.
/// </returns>
public override bool Execute()
{
var host = new EngineHost();
var rootNamespace = RootNamespace;
var projectRootFolder = Environment.CurrentDirectory;
var newLine = Environment.NewLine;
foreach (var templateFile in TemplateFiles)
{
var inputPath = templateFile.ItemSpec;
Log.LogMessage(MessageImportance.Normal, "Compiling T4 template {0}", inputPath);
try
{
CompileTemplate(host, projectRootFolder, inputPath, rootNamespace, newLine);
}
catch (Exception e)
{
Log.LogErrorFromException(e);
}
}
foreach (CompilerError err in host.Errors)
{
Log.LogError("TemplateCompiler", err.ErrorNumber, null, err.FileName,
err.Line, err.Column, 0, 0, err.ErrorText);
}
return(!Log.HasLoggedErrors);
}
public ControllerForWebApp(BootstrapperContext bootstrapper)
{
if (bootstrapper == null)
{
throw new ArgumentNullException(nameof(bootstrapper));
}
_bootstrapper = bootstrapper;
_packageManager = new GitHubPackageManager(_bootstrapper.UserAgent);
_storageManager = new EngineStorageManager(_bootstrapper.Environment);
_engineHost = new EngineHost(_bootstrapper);
}
/// <summary>
/// Copie un projet d'un groupe vers un autre groupe
/// </summary>
/// <param name="iSourceGroup"></param>
/// <param name="iProjectNameToCopy"></param>
/// <param name="iSourceProjectPath"></param>
/// <param name="iDestinationProjectPath"></param>
public static void CopyProjetToOtherGroup(this Group iSourceGroup, string iProjectNameToCopy, EnvironmentEnum iDestinationGroupEnum)
{
var projectToCopy = iSourceGroup.Projects.GetProject(iProjectNameToCopy);
//Définition du dossier de destination
var destinationProjectPath = projectToCopy.Directory.Replace(iSourceGroup.GetEnvironment().GetProjectDirectory(), iDestinationGroupEnum.GetProjectDirectory());
if (!Directory.Exists(destinationProjectPath))
{
Directory.CreateDirectory(destinationProjectPath);
}
//Définition destination
var options = new CopyGroupOptions();
options.TargetFolder = destinationProjectPath;
//Ajout du projet à copier
options.Projects.Add(projectToCopy);
var fileOptions = new FilePickingOptions(projectToCopy.Directory);
options.FileOptions = fileOptions;
//Ouverture de l'autre groupe via un host
var host = new EngineHost(HostEnvironment.CreateDefaultEnvironment(false));
var groupManager = host.CreateGroupManager();
var destinationGroup = groupManager.OpenGroup(iDestinationGroupEnum);
//Process de copie
using (var copyProcess = CopyGroupProcess.CreateCopyGroupProcess(iSourceGroup, destinationGroup, options))
{
try
{
if (!copyProcess.Start())
{
throw new Exception("Erreur lors de l'importation du projet '{0}' dans le groupe '{1}'".FormatString(iProjectNameToCopy, destinationGroup.Name));
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
groupManager.CloseGroup();
}
}
}
void Generate(string input, string namespac, string className, string expectedOutput)
{
var host = new EngineHost();
string actualOutput;
using (var writer = new StringWriter())
{
Parent.TemplateCompiler.GenerateCode(host, input, namespac, className, writer);
actualOutput = writer.ToString();
}
Assert.AreEqual(0, host.Errors.Count);
var output = StripHeader(actualOutput);
Assert.AreEqual(expectedOutput, output);
}
public override bool OnStart()
{
this._host = this.BuildHost();
return(base.OnStart());
}
private static void Start(string[] args)
{
EngineHost = new EngineHost(typeof(Program).Assembly);
EngineHost.Initialize();
}
/**
*@brief constructor
*@remark this is where the actual engine host control gets created
*/
public EngineHostControl()
{
engine_ = new EngineHost((uint)ActualWidth, (uint)ActualHeight);
Child = engine_;
}
public List <Tuple <string, ProjectDetails, ImportedDataTable> > GetImportedDataTableFromPackage(EnvironmentEnum iSourceEnvironment, EnvironmentEnum iDestinationEnvironment, Package iPackageDeployToStaging)
{
var result = new List <Tuple <string, ProjectDetails, ImportedDataTable> >();
var host = new EngineHost(HostEnvironment.CreateDefaultEnvironment(false));
var sourceGroupManager = host.CreateGroupManager();
var sourceProjectManager = host.CreateProjectManager();
var sourceGroup = sourceGroupManager.OpenGroup(iSourceEnvironment);
var packageDistinctProjectGUIDList = iPackageDeployToStaging.SubTasks.Where(x => x.ProjectGUID != null).GroupBy(x => x.ProjectGUID).Select(x => (Guid?)x.First().ProjectGUID).ToList();
var packageDistinctProjectDetailsList = new List <ProjectDetails>();
foreach (var item in packageDistinctProjectGUIDList)
{
if (item != null)
{
packageDistinctProjectDetailsList.Add(sourceGroup.Projects.GetProject((Guid)item));
}
}
//Bouclage sur les projets source inclus dans le package
var projectDevCounter = 1;
foreach (var projectItem in packageDistinctProjectDetailsList.Enum())
{
var message = "Récupération des tables dev du package, Projet {0}/{1} : {2}".FormatString(projectDevCounter, packageDistinctProjectDetailsList.Count(), projectItem.Name);
ReportProgress(message);
sourceProjectManager.OpenProject(sourceGroup, projectItem);
var project = sourceProjectManager.Project;
var importedDataTables = project.GetImportedDataTableList();
foreach (var tableItem in importedDataTables.Enum())
{
result.Add(new Tuple <string, ProjectDetails, ImportedDataTable>(iSourceEnvironment.GetName("FR"), projectItem, tableItem));
}
sourceProjectManager.CloseProject(false);
projectDevCounter++;
}
//fermeture du groupe
sourceGroupManager.CloseGroup();
//Récupère les projets de la destination non impacté par le package
var destinationGroupManager = host.CreateGroupManager();
var destinationProjectManager = host.CreateProjectManager();
var destinationGroup = destinationGroupManager.OpenGroup(iDestinationEnvironment);
var openedStagingProjectlist = destinationGroup.GetOpenedProjectList();
if (openedStagingProjectlist.IsNotNullAndNotEmpty())
{
throw new Exception("Certains projets du groupe '{0}' sont ouverts. L'analyse n'est donc pas possible.".FormatString(destinationGroup.Name) + Environment.NewLine + Environment.NewLine + openedStagingProjectlist.Select(x => x.Name).Concat(Environment.NewLine));
}
var projectStagingComparator = new ListComparator <ProjectDetails, ProjectDetails>(destinationGroup.GetProjectList(), x => x.Name, packageDistinctProjectDetailsList, x => x.Name);
var projetPreprodCounter = 1;
foreach (var projectItem in projectStagingComparator.RemovedList.Enum())
{
var message = "Récupération des tables préprod du package, Projet {0}/{1} : {2}".FormatString(projetPreprodCounter, projectStagingComparator.RemovedList.Count(), projectItem.Name);
ReportProgress(message);
destinationProjectManager.OpenProject(destinationGroup, projectItem);
var project = destinationProjectManager.Project;
var importedDataTables = project.GetImportedDataTableList();
foreach (var tableItem in importedDataTables.Enum())
{
result.Add(new Tuple <string, ProjectDetails, ImportedDataTable>(iDestinationEnvironment.GetName("FR"), projectItem, tableItem));
}
destinationProjectManager.CloseProject(false);
projetPreprodCounter++;
}
//fermeture du groupe
destinationGroupManager.CloseGroup();
return(result);
}
