/// <summary>
/// Load the model from the underlying text buffer.
/// </summary>
private void LoadModelFromXmlModel()
{
try
{
XmlSerializer serializer = new XmlSerializer(typeof(VSTemplate));
using (XmlReader reader = GetParseTree().CreateReader())
{
_vstemplateModel = (VSTemplate)serializer.Deserialize(reader);
}
if (_vstemplateModel == null || _vstemplateModel.TemplateData == null)
{
throw new Exception(Resources.InvalidVsTemplateData);
}
}
catch (Exception e)
{
//Display error message
ErrorHandler.ThrowOnFailure(VsShellUtilities.ShowMessageBox(_serviceProvider,
Resources.InvalidVsTemplateData + e.Message,
Resources.ErrorMessageBoxTitle,
OLEMSGICON.OLEMSGICON_CRITICAL,
OLEMSGBUTTON.OLEMSGBUTTON_OK,
OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST));
}
BufferDirty = false;
if (ViewModelChanged != null)
{
// Update the Designer View
ViewModelChanged(this, new EventArgs());
}
}
public ProjectTemplate(VSTemplate projectTemplate, Uri templateLocation) : base(projectTemplate, templateLocation)
{
if (string.Compare(projectTemplate.Type, "Project", StringComparison.OrdinalIgnoreCase) != 0)
{
throw new ArgumentException("Not a valid project template.", "projectTemplate");
}
}
private VSTemplate CreateTemplateForSolution(string templateName)
{
var template = new VSTemplate {
TemplateData = new VSTemplateTemplateData()
};
template.TemplateData.Name = new NameDescriptionIcon {
Value = templateName
};
template.TemplateData.Description = new NameDescriptionIcon {
Value = ""
};
template.TemplateData.ProjectType = "CSharp";
template.TemplateData.ProjectSubType = "My Project Collection";
template.TemplateData.SortOrder = "1";
template.TemplateData.CreateNewFolder = true;
template.TemplateData.CreateNewFolderSpecified = true;
template.TemplateData.LocationFieldSpecified = true;
template.TemplateData.EnableLocationBrowseButton = true;
template.TemplateData.EnableLocationBrowseButtonSpecified = true;
template.TemplateData.BuildOnLoad = true;
template.Type = "ProjectGroup";
template.Version = "2.0.0";
template.TemplateContent = new VSTemplateTemplateContent();
return(template);
}
private void WriteTemplateToFile(VSTemplate template, string dir, string projectName)
{
dir = dir.Combine(GetSolutionParentDir());
string targetDir = Path.Combine(dir, projectName) + "\\";
string filename = Path.Combine(targetDir, projectName + ".vstemplate");
_fileSystem.CreateDirectory(targetDir);
template.Serialize(filename);
}
public static string GetSolutionVSTemplate(OptionsGui data)
{
var template = new VSTemplate {
Version = "3.0.0", Type = "ProjectGroup"
};
template.TemplateData.Name.Value = data.ProductName;
template.TemplateData.Description.Value = data.ProductDescription;
template.TemplateData.ProjectType = data.ProjectType;
template.TemplateData.ProjectSubType = data.ProjectSubType;
template.TemplateData.SortOrder = "1000";
template.TemplateData.CreateNewFolderSpecified = true;
template.TemplateData.CreateNewFolder = true;
template.TemplateData.DefaultName = data.ProductName;
template.TemplateData.ProvideDefaultNameSpecified = true;
template.TemplateData.ProvideDefaultName = true;
template.TemplateData.LocationFieldSpecified = true;
template.TemplateData.LocationField = VSTemplateTemplateDataLocationField.Enabled;
template.TemplateData.EnableLocationBrowseButtonSpecified = true;
template.TemplateData.EnableLocationBrowseButton = true;
template.TemplateData.Icon.Value = "__Template_small.png";
template.TemplateData.PreviewImage.Value = "__Template_large.png";
var projectCollection = new VSTemplateTemplateContentProjectCollection();
var projects = SolutionFileParser.GetSolutionProjects(data.SolutionPath);
foreach (var project in projects)
{
var name = project.ProjectName.Replace(data.DefaultNamespace, "$saferootprojectname$");
var link = new ProjectTemplateLink
{
ProjectName = name,
Value = string.Format("{0}\\MyTemplate.vstemplate", name),
ReplaceParameters = true
};
projectCollection.Items.Add(link);
}
template.TemplateContent.Items.Add(projectCollection);
template.WizardExtension = new List <VSTemplateWizardExtension>
{
new VSTemplateWizardExtension
{
Assembly = new List <object> {
typeof(SafeRootProjectWizard.RootWizard).Assembly.FullName
},
FullClassName = new List <object> {
typeof(SafeRootProjectWizard.RootWizard).FullName
}
}
};
return(Serializer.Serialize(template));
}
// Public Methods (1)
public static string GetProjectVSTemplate(OptionsGui data, string projectFilePath)
{
var regex = new Regex(@"[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Nl}\p{Mn}\p{Mc}\p{Cf}\p{Pc}\p{Lm}]");
var template = new VSTemplate
{
Type = "Project",
Version = "3.0.0"
};
template.TemplateData.Name.Value = data.ProductName;
template.TemplateData.Description.Value = data.ProductDescription;
template.TemplateData.ProjectType = data.ProjectType;
template.TemplateData.ProjectSubType = data.ProjectSubType;
template.TemplateData.SortOrder = "1000";
template.TemplateData.CreateNewFolderSpecified = true;
template.TemplateData.CreateNewFolder = true;
template.TemplateData.DefaultName = regex.Replace(data.ProductName, "");
template.TemplateData.ProvideDefaultNameSpecified = true;
template.TemplateData.ProvideDefaultName = true;
template.TemplateData.LocationFieldSpecified = true;
template.TemplateData.LocationField = VSTemplateTemplateDataLocationField.Enabled;
template.TemplateData.EnableLocationBrowseButtonSpecified = true;
template.TemplateData.EnableLocationBrowseButton = true;
template.TemplateData.Icon.Value = "__Template_small.png";
template.TemplateData.PreviewImage.Value = "__Template_large.png";
var contentProject = new VSTemplateTemplateContentProject
{
File = projectFilePath.GetFileName().replaceNamespace(data),
ReplaceParameters = true,
ReplaceParametersSpecified = true,
TargetFileName = projectFilePath.GetFileName().replaceNamespace(data)
};
var rootDir = projectFilePath.GetDirectoryName() + "\\";
addAllFiles(rootDir, rootDir, contentProject, data);
template.TemplateContent.Items.Add(contentProject);
template.WizardExtension = new List <VSTemplateWizardExtension>
{
new VSTemplateWizardExtension
{
Assembly = new List <object> {
typeof(SafeRootProjectWizard.ChildWizard).Assembly.FullName
},
FullClassName = new List <object> {
typeof(SafeRootProjectWizard.ChildWizard).FullName
}
}
};
return(Serializer.Serialize(template));
}
protected TemplateBase(VSTemplate template, Uri templateLocation)
{
if (templateLocation == null)
{
throw new ArgumentNullException("templateLocation");
}
if (template == null)
{
throw new ArgumentNullException("template");
}
this.Template = template;
this.TemplateLocation = templateLocation;
}
private void CreateSolutionTemplate(List <ProjectTemplateLink> templateLinks, string dir,
List <SolutionFolder> solutionFolder, string templateName,
string startupFileToExecute)
{
VSTemplate template = CreateTemplateForSolution(templateName);
template.TemplateContent.Items = CreateSolutionItems(templateLinks, solutionFolder);
template.WizardExtension = CreateWizardExtention();
template.WizardData = CreateSolutionWizardData(startupFileToExecute);
string target = Path.Combine(dir, "solution.vstemplate");
template.Serialize(target);
}
private VSTemplate GetProjectTemplate(Project project)
{
var template = new VSTemplate();
template.Type = "Project";
template.Type = "Project";
template.Version = "2.0.0";
template.TemplateData = new VSTemplateTemplateData
{
Name = new NameDescriptionIcon {
Value = project.Name
},
ProjectType = "CSharp",
Description = new NameDescriptionIcon {
Value = ""
},
Icon = new NameDescriptionIcon {
Value = "__TemplateIcon.ico"
},
DefaultName = project.Name,
ProvideDefaultName = true,
ProvideDefaultNameSpecified = true,
SortOrder = "1000",
CreateNewFolder = true,
CreateNewFolderSpecified = true,
};
template.TemplateContent = new VSTemplateTemplateContent();
template.TemplateContent.Items = new[]
{
new VSTemplateTemplateContentProject
{
File =
_fileSystem.GetFileNameWithExtension(
project.FileName),
Items = GetItems(project).ToArray(),
TargetFileName = _fileSystem.GetFileNameWithExtension(
project.FileName),
ReplaceParametersSpecified = true,
ReplaceParameters = true,
}
};
template.WizardExtension = CreateWizardExtention();
return(template);
}
private void CreateProjectTemplates(List <ProjectTemplateLink> templateLinks, List <VSTemplate> templates,
string dir)
{
foreach (Project project in _dte.Solution.Projects.GetCodeProjects())
{
try
{
VSTemplate template = GetProjectTemplate(project);
templates.Add(template);
templateLinks.Add(CreateProjectLink(project));
WriteTemplateToFile(template, dir, project.Name);
}
catch (Exception e)
{
_messageBox.ShowError(e.ToString());
}
}
}
/// <summary> Process this. </summary>
///
/// <remarks> Ken, 10/3/2020. </remarks>
public void Process()
{
var config = this.GeneratorConfiguration;
var assemblyLocation = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
var localTemplatesPath = Path.Combine(assemblyLocation, "Templates");
var directory = new DirectoryInfo(localTemplatesPath);
WriteLine("\r\n**** CurrentPass: {0} {1}\r\n", PrintMode.Any, config.CurrentPass, "*".Repeat(25));
foreach (var file in directory.GetFiles("*.sln"))
{
var rawFileRelativePath = file.Name.ReverseSlashes();
var tokenizedRelativePath = VSTemplate.ReplaceParameterText(rawFileRelativePath, GetTemplateParameters());
var fileName = Path.Combine(projectFolderRoot, tokenizedRelativePath);
WriteLine("{0}{1}", PrintMode.All, this.CurrentTabText, $"Creating solution { Path.GetFileNameWithoutExtension(fileName) }");
this.Indent();
}
foreach (var file in directory.GetFiles())
{
if (file.Extension == ".sln")
{
var rawFileRelativePath = file.Name.ReverseSlashes();
var tokenizedRelativePath = VSTemplate.ReplaceParameterText(rawFileRelativePath, GetTemplateParameters());
var fileName = Path.Combine(projectFolderRoot, tokenizedRelativePath);
var outputFile = new FileInfo(fileName);
WriteLine("{0}{1}", PrintMode.All, this.CurrentTabText, $"Creating solution file { Path.GetFileNameWithoutExtension(fileName) }");
using (var stream = System.IO.File.OpenRead(file.FullName))
{
var reader = new StreamReader(stream);
var content = reader.ReadToEnd();
content = VSTemplate.ReplaceParameterText(content, GetTemplateParameters());
if (config.CurrentPass == GeneratorPass.Files)
{
if (outputFile.Exists)
{
outputFile.MakeWritable();
}
System.IO.File.WriteAllText(outputFile.FullName, content);
}
}
}
else if (file.Extension == ".zip")
{
var rawProjectName = Path.GetFileNameWithoutExtension(file.Name);
var rawFileRelativePath = file.Name.ReverseSlashes();
var templateParameters = this.GeneratorConfiguration.GetTemplateParameters(rawProjectName);
var tokenizedRelativePath = VSTemplate.ReplaceParameterText(rawFileRelativePath, GetTemplateParameters());
var fileName = Path.Combine(projectFolderRoot, tokenizedRelativePath);
var outputFile = new FileInfo(fileName);
string rootFolder;
string projectName;
WriteLine("{0}{1}", PrintMode.All, this.CurrentTabText, $"Creating project { Path.GetFileNameWithoutExtension(fileName) }");
if (templateParameters.Count > 0)
{
var tokenizedProjectName = VSTemplate.ReplaceParameterText(rawProjectName, GetTemplateParameters());
projectName = tokenizedProjectName;
rootFolder = Path.Combine(projectFolderRoot, tokenizedProjectName);
}
else
{
projectName = rawProjectName;
rootFolder = Path.Combine(projectFolderRoot, rawProjectName);
}
if (!System.IO.Directory.Exists(rootFolder))
{
if (config.CurrentPass == GeneratorPass.Files)
{
System.IO.Directory.CreateDirectory(rootFolder);
}
}
using (var package = ZipPackage.Open(file.FullName, FileMode.Open))
{
var templatePart = package.GetParts().Single(p => Path.GetExtension(p.Uri.OriginalString) == ".vstemplate");
VSProjectTemplate template = null;
VSTemplateProject project = null;
using (var stream = templatePart.GetStream())
{
var reader = new StreamReader(stream);
var contents = reader.ReadToEnd();
template = (VSProjectTemplate)VSConfigProvider.ParseTemplate(new StringBuilder(contents));
project = (VSTemplateProject)template.Projects.Single();
}
foreach (var part in package.GetParts())
{
VSTemplateProjectItem projectItem = null;
IWorkspaceTemplate workspaceTemplate = null;
IWorkspaceFileTypeHandler fileTypeHandler;
rawFileRelativePath = part.Uri.OriginalString.ReverseSlashes();
templateParameters = this.GeneratorConfiguration.GetTemplateParameters(rawFileRelativePath);
if (template != null)
{
if (rawFileRelativePath.AsCaseless() == project.RelativePath)
{
workspaceTemplate = project;
}
else
{
projectItem = (VSTemplateProjectItem)project.ProjectItems.SingleOrDefault(i => i.RelativePath.AsCaseless() == rawFileRelativePath);
if (projectItem != null && projectItem.SubType != null)
{
var subTypes = projectItem.SubType.Split(",", StringSplitOptions.RemoveEmptyEntries);
if (subTypes.Where(t => t.StartsWith("GENERATOR_TOKEN_")).Any(s => !supportedTokens.Any(t => t == s)))
{
continue;
}
}
workspaceTemplate = projectItem;
}
}
if (templateParameters.Count > 0)
{
tokenizedRelativePath = template.ReplaceParameters(rawFileRelativePath, GetTemplateParameters(projectName));
fileName = Path.Combine(rootFolder, tokenizedRelativePath.RemoveStartIfMatches(@"\"));
}
else
{
fileName = Path.Combine(rootFolder, rawFileRelativePath.RemoveStartIfMatches(@"\"));
}
if (workspaceTemplate != null)
{
using (var stream = part.GetStream())
{
var reader = new StreamReader(stream);
var content = reader.ReadToEnd();
outputFile = new FileInfo(fileName);
if (workspaceTemplate.ReplaceParameters)
{
content = template.ReplaceParameters(content, GetTemplateParameters(projectName));
}
if (outputFile.Exists)
{
outputFile.MakeWritable();
}
fileTypeHandler = config.GetWorkspaceFileTypeHandler(fileName);
if (fileTypeHandler != null)
{
var tokenContentHandlers = new Dictionary <string, IWorkspaceTokenContentHandler>();
fileTypeHandler.PreProcess(projectType, appDescription, rawFileRelativePath, fileName, supportedTokens, content, config);
if (fileTypeHandler.TokensToProcess != null)
{
foreach (var token in fileTypeHandler.TokensToProcess)
{
var tokenContentHandler = config.GetTokenContentHandler(token);
if (tokenContentHandler != null)
{
tokenContentHandler.Process(projectType, appDescription, rawFileRelativePath, fileName, this.supportedTokens);
tokenContentHandlers.Add(token, tokenContentHandler);
}
}
}
fileTypeHandler.Process(tokenContentHandlers, workspaceTemplate, projectType, appDescription, rawFileRelativePath, fileName, content, config);
content = fileTypeHandler.OutputContent;
}
if (config.CurrentPass == GeneratorPass.Files)
{
if (!outputFile.Directory.Exists)
{
outputFile.Directory.Create();
}
System.IO.File.WriteAllText(outputFile.FullName, content);
}
}
}
}
}
}
}
this.Dedent();
}
public TemplateContext(string templateJsonContent, TemplateProperties templateJsonProps, VSTemplate vsTemplate)
{
TemplateJsonContent = templateJsonContent;
TemplateJsonProps = templateJsonProps;
VSTemplate = vsTemplate;
}
