private static void AddCommentsToItem(CodeTypeDeclaration entity, ITemplateInfo template)
{
if (!string.IsNullOrEmpty(template.HelpText))
entity.Comments.Add(new CodeCommentStatement("<summary>" + template.HelpText + "</summary>", true));
else
entity.Comments.Add(new CodeCommentStatement(string.Format("<summary>Represents the {0} template</summary>", template.FullPath), true));
}
/// <summary>
/// Adds a concrete template to the state collection
/// </summary>
public TemplateInfo AddConcrete(ITemplateInfo item)
{
var templateInfo = new TemplateInfo(item, _parameters.ItemNamespace);
templateInfo.FullName = _templateNovelizer.GetNovelFullTypeName(item.Name, item.FullPath);
_templateLookup.Add(item.TemplateId, templateInfo);
_templates.Add(templateInfo);
return templateInfo;
}
protected virtual string GenerateTextSignature(ITemplateInfo templateItem)
{
List<string> keyElements = new List<string>();
keyElements.Add(templateItem.FullPath); // full path will cover us for namespace changes
keyElements.Add(templateItem.TemplateId.ToString()); // ID is used for creating new items and syncing
foreach (var field in templateItem.OwnFields)
{
keyElements.Add(field.Name); // name determines property names
keyElements.Add(field.Id.ToString()); // ID determines internal property lookups for speed
keyElements.Add(field.Type); // type determines property Type
}
keyElements.Sort(); // sorting these gives us a standard order, so that merely reordering fields doesn't potentially invalidate the signature
return string.Join("|", keyElements.ToArray());
}
public static string GetDefaultName(ITemplateInfo template)
{
return(template.GetDefaultName());
}
// Attempts to invoke the template.
// Warning: The _commandInput cannot be assumed to be in a state that is parsed for the template being invoked.
// So be sure to only get template-agnostic information from it. Anything specific to the template must be gotten from the ITemplateMatchInfo
// Or do a reparse if necessary (currently occurs in one error case).
private async Task <CreationResultStatus> CreateTemplateAsync(ITemplateMatchInfo templateMatchDetails)
{
ITemplateInfo template = templateMatchDetails.Info;
string fallbackName = new DirectoryInfo(_commandInput.OutputPath ?? Directory.GetCurrentDirectory()).Name;
if (string.IsNullOrEmpty(fallbackName) || string.Equals(fallbackName, "/", StringComparison.Ordinal))
{ // DirectoryInfo("/").Name on *nix returns "/", as opposed to null or "".
fallbackName = null;
}
TemplateCreationResult instantiateResult;
try
{
instantiateResult = await _templateCreator.InstantiateAsync(template, _commandInput.Name, fallbackName, _commandInput.OutputPath, templateMatchDetails.GetValidTemplateParameters(), _commandInput.SkipUpdateCheck, _commandInput.IsForceFlagSpecified, _commandInput.BaselineName).ConfigureAwait(false);
}
catch (ContentGenerationException cx)
{
Reporter.Error.WriteLine(cx.Message.Bold().Red());
if (cx.InnerException != null)
{
Reporter.Error.WriteLine(cx.InnerException.Message.Bold().Red());
}
return(CreationResultStatus.CreateFailed);
}
catch (TemplateAuthoringException tae)
{
Reporter.Error.WriteLine(tae.Message.Bold().Red());
return(CreationResultStatus.CreateFailed);
}
string resultTemplateName = string.IsNullOrEmpty(instantiateResult.TemplateFullName) ? TemplateName : instantiateResult.TemplateFullName;
switch (instantiateResult.Status)
{
case CreationResultStatus.Success:
Reporter.Output.WriteLine(string.Format(LocalizableStrings.CreateSuccessful, resultTemplateName));
if (!string.IsNullOrEmpty(template.ThirdPartyNotices))
{
Reporter.Output.WriteLine(string.Format(LocalizableStrings.ThirdPartyNotices, template.ThirdPartyNotices));
}
HandlePostActions(instantiateResult);
break;
case CreationResultStatus.CreateFailed:
Reporter.Error.WriteLine(string.Format(LocalizableStrings.CreateFailed, resultTemplateName, instantiateResult.Message).Bold().Red());
break;
case CreationResultStatus.MissingMandatoryParam:
if (string.Equals(instantiateResult.Message, "--name", StringComparison.Ordinal))
{
Reporter.Error.WriteLine(string.Format(LocalizableStrings.MissingRequiredParameter, instantiateResult.Message, resultTemplateName).Bold().Red());
}
else
{
// TODO: rework to avoid having to reparse.
// The canonical info could be in the ITemplateMatchInfo, but currently isn't.
TemplateListResolver.ParseTemplateArgs(template, _hostDataLoader, _commandInput);
IReadOnlyList <string> missingParamNamesCanonical = instantiateResult.Message.Split(new[] { ',' })
.Select(x => _commandInput.VariantsForCanonical(x.Trim())
.DefaultIfEmpty(x.Trim()).First())
.ToList();
string fixedMessage = string.Join(", ", missingParamNamesCanonical);
Reporter.Error.WriteLine(string.Format(LocalizableStrings.MissingRequiredParameter, fixedMessage, resultTemplateName).Bold().Red());
}
break;
case CreationResultStatus.OperationNotSpecified:
break;
case CreationResultStatus.InvalidParamValues:
TemplateUsageInformation usageInformation = TemplateUsageHelp.GetTemplateUsageInformation(template, EnvironmentSettings, _commandInput, _hostDataLoader, _templateCreator);
string invalidParamsError = InvalidParameterInfo.InvalidParameterListToString(usageInformation.InvalidParameters);
Reporter.Error.WriteLine(invalidParamsError.Bold().Red());
Reporter.Error.WriteLine(string.Format(LocalizableStrings.RunHelpForInformationAboutAcceptedParameters, $"{CommandName} {TemplateName}").Bold().Red());
break;
default:
break;
}
return(instantiateResult.Status);
}
/// <summary>
/// Adds the versioning control attribute to the interface
/// </summary>
/// <example>[RepresentsSitecoreTemplate("{76036F5E-CBCE-46D1-AF0A-4143F9B557AA}", "Dn8cOiiO0ckeD/NPjd9Q8nJuPSk=")]</example>
private void AddVersionAttributeToInterface(CodeTypeDeclaration interfaceType, ITemplateInfo template)
{
var attribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(RepresentsSitecoreTemplateAttribute)));
attribute.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(template.TemplateId.ToString())));
attribute.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(_signatureProvider.GenerateTemplateSignature(template))));
attribute.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(_parameters.ConfigurationName)));
interfaceType.CustomAttributes.Add(attribute);
}
public async Task <TemplateCreationResult> InstantiateAsync(ITemplateInfo templateInfo, string name, string fallbackName, string outputPath, IReadOnlyDictionary <string, string> inputParameters, bool skipUpdateCheck, bool forceCreation)
{
// SettingsLoader.LoadTemplate is where the loc info should be read!!!
// templateInfo knows enough to get at the loc, if any
ITemplate template = _environmentSettings.SettingsLoader.LoadTemplate(templateInfo);
if (template == null)
{
return(new TemplateCreationResult("Could not load template", CreationResultStatus.NotFound, templateInfo.Name));
}
string realName = name ?? template.DefaultName ?? fallbackName;
// there should never be param errors here. If there are, the template is malformed, or the host gave an invalid value.
IParameterSet templateParams = SetupDefaultParamValuesFromTemplateAndHost(template, realName, out IList <string> defaultParamsWithInvalidValues);
if (defaultParamsWithInvalidValues.Any())
{
string message = string.Join(", ", defaultParamsWithInvalidValues);
return(new TemplateCreationResult(message, CreationResultStatus.InvalidParamValues, template.Name));
}
ResolveUserParameters(template, templateParams, inputParameters, out IList <string> userParamsWithInvalidValues);
if (userParamsWithInvalidValues.Any())
{
string message = string.Join(", ", userParamsWithInvalidValues);
return(new TemplateCreationResult(message, CreationResultStatus.InvalidParamValues, template.Name));
}
bool missingParams = CheckForMissingRequiredParameters(templateParams, out IList <string> missingParamNames);
if (missingParams)
{
return(new TemplateCreationResult(string.Join(", ", missingParamNames), CreationResultStatus.MissingMandatoryParam, template.Name));
}
if (template.IsNameAgreementWithFolderPreferred && string.IsNullOrEmpty(outputPath))
{
outputPath = name;
}
ICreationResult creationResult = null;
string targetDir = outputPath ?? _environmentSettings.Host.FileSystem.GetCurrentDirectory();
try
{
_paths.CreateDirectory(targetDir);
Stopwatch sw = Stopwatch.StartNew();
IComponentManager componentManager = _environmentSettings.SettingsLoader.Components;
IReadOnlyList <IFileChange> changes = template.Generator.GetFileChanges(_environmentSettings, template, templateParams, componentManager, targetDir);
IReadOnlyList <IFileChange> destructiveChanges = changes.Where(x => x.ChangeKind != ChangeKind.Create).ToList();
if (!forceCreation && destructiveChanges.Count > 0)
{
if (!_environmentSettings.Host.OnPotentiallyDestructiveChangesDetected(changes, destructiveChanges))
{
return(new TemplateCreationResult("Cancelled", CreationResultStatus.Cancelled, template.Name));
}
}
creationResult = await template.Generator.CreateAsync(_environmentSettings, template, templateParams, componentManager, targetDir).ConfigureAwait(false);
sw.Stop();
_environmentSettings.Host.OnTimingCompleted("Content generation time", sw.Elapsed);
return(new TemplateCreationResult(string.Empty, CreationResultStatus.Success, template.Name, creationResult, outputPath));
}
catch (ContentGenerationException cx)
{
string message = cx.Message;
if (cx.InnerException != null)
{
message += Environment.NewLine + cx.InnerException.Message;
}
return(new TemplateCreationResult(message, CreationResultStatus.CreateFailed, template.Name));
}
catch (Exception ex)
{
return(new TemplateCreationResult(ex.Message, CreationResultStatus.CreateFailed, template.Name));
}
}
public Task <TemplateCreationResult> InstantiateAsync(ITemplateInfo templateInfo, string name, string fallbackName, string outputPath, IReadOnlyDictionary <string, string> inputParameters, bool skipUpdateCheck, bool forceCreation, string baselineName)
{
return(InstantiateAsync(templateInfo, name, fallbackName, outputPath, inputParameters, skipUpdateCheck, forceCreation, baselineName, false));
}
protected virtual IEnumerable <TextFile> ProcessMethodsWithBody(ITemplateInfo templateInfo)
{
return(this.ProcessMethods(templateInfo, this.MethodsWithBody));
}
/// <summary>
/// Check's whether a template should be reloaded or not.
/// </summary>
/// <param name="info">template information</param>
/// <returns>
/// true if template is OK; false if it do not exist or are old.
/// </returns>
public bool CheckTemplate(ITemplateInfo info)
{
if(HasTemplate(info.Filename))
return File.GetLastWriteTime(_pathPrefix + info.Filename) <= info.CompiledWhen;
return false;
}
private static bool IsTemplateHiddenByHostFile(ITemplateInfo templateInfo, IHostSpecificDataLoader hostDataLoader)
{
HostSpecificTemplateData hostData = hostDataLoader.ReadHostSpecificTemplateData(templateInfo);
return(hostData.IsHidden);
}
private ITemplateEngineHost LoadHostWithLocalizationTemplates(string locale, out ISettingsLoader settingsLoaderOut, out ITemplateInfo localizationTemplate)
{
var env = _helper.CreateEnvironment(locale);
env.SettingsLoader.Components.Register(typeof(TemplatesFactory));
settingsLoaderOut = env.SettingsLoader;
IReadOnlyList <ITemplateInfo> localizedTemplates = settingsLoaderOut.GetTemplatesAsync(default).Result;
private Func <ITextTemplatingEngineHost, string> PreProcessTemplate(ITemplateInfo templateInfo)
{
var templateContent = File.ReadAllText(templateInfo.FullPath);
string language;
string[] references;
var className = templateInfo.TemplateName.Replace(".", "_");
var dummyHost = new CustomT4Host(templateInfo, this.TemplatesDirectory, null, null);
var generatedCode = this.T4Engine.PreprocessTemplate(templateContent, dummyHost, className, RuntimeTemplatesNamespace, out language, out references);
var parameters = new CompilerParameters
{
OutputAssembly = templateInfo.TemplateName + ".dll",
GenerateInMemory = false,
GenerateExecutable = false,
IncludeDebugInformation = true,
};
var assemblyLocations = AppDomain.CurrentDomain
.GetAssemblies()
.Where(a => !a.IsDynamic)
.Select(a => a.Location);
parameters.ReferencedAssemblies.AddRange(assemblyLocations.ToArray());
parameters.TreatWarningsAsErrors = false;
var provider = new CSharpCodeProvider();
var results = provider.CompileAssemblyFromSource(parameters, generatedCode);
if (results.Errors.Count > 0)
{
var realError = false;
for (int i = 0; i < results.Errors.Count; i++)
{
if (!results.Errors[i].IsWarning)
{
realError = true;
}
Console.WriteLine((results.Errors[i].IsWarning?"Warning":"Error") + "(" + i.ToString() + "): " + results.Errors[i].ToString());
}
if (realError)
{
throw new InvalidOperationException("Template error.");
}
}
var assembly = results.CompiledAssembly;
var templateClassType = assembly.GetType(RuntimeTemplatesNamespace + "." + className);
dynamic templateClassInstance = Activator.CreateInstance(templateClassType);
return((ITextTemplatingEngineHost host) =>
{
templateClassInstance.Host = host;
return templateClassInstance.TransformText();
});
}
public static void ParseTemplateArgs(ITemplateInfo templateInfo, IHostSpecificDataLoader hostDataLoader, INewCommandInput commandInput)
{
HostSpecificTemplateData hostData = hostDataLoader.ReadHostSpecificTemplateData(templateInfo);
commandInput.ReparseForTemplate(templateInfo, hostData);
}
protected IEnumerable <TextFile> ProcessTemplate(ITemplateInfo templateInfo)
{
yield return(this.ProcessTemplate(templateInfo, null, templateInfo.BaseFileName()));
}
private IEnumerable <TextFile> ProcessTypes(ITemplateInfo templateInfo, Func <IEnumerable <OdcmObject> > modelMethod)
{
return(this.FilterOdcmEnumerable(templateInfo, modelMethod)
.Select(odcmType => this.ProcessTemplate(templateInfo, odcmType, className: odcmType.Name)));
}
protected virtual IEnumerable <TextFile> ProcessNonCollectionMethods(ITemplateInfo templateInfo)
{
return(this.ProcessMethods(templateInfo, this.NonCollectionMethods));
}
public static string GetCompositionFilter(this ITemplateInfo ti)
{
return(GetValueFromTag(ti, TagPrefix + "compositionFilter"));
}
public async Task <ICreationResult> CreateAsync(ITemplateInfo info, string name, string outputPath, IReadOnlyDictionary <string, string> parameters, bool skipUpdateCheck, string baselineName)
{
TemplateCreationResult instantiateResult = await _templateCreator.InstantiateAsync(info, name, name, outputPath, parameters, skipUpdateCheck, forceCreation : false, baselineName : baselineName).ConfigureAwait(false);
return(instantiateResult.ResultInfo);
}
public virtual string GenerateTemplateSignature(ITemplateInfo templateItem)
{
string signatureText = GenerateTextSignature(templateItem);
return HashTextSignature(signatureText);
}
/// <summary>
/// Adds the versioning control attribute to the interface
/// </summary>
/// <example>[RepresentsSitecoreTemplate("{76036F5E-CBCE-46D1-AF0A-4143F9B557AA}", "Dn8cOiiO0ckeD/NPjd9Q8nJuPSk=")]</example>
private void AddVersionAttributeToInterface(CodeTypeDeclaration interfaceType, ITemplateInfo template)
{
var attribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(RepresentsSitecoreTemplateAttribute)));
attribute.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(template.TemplateId.ToString())));
attribute.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(_signatureProvider.GenerateTemplateSignature(template))));
attribute.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(_parameters.ConfigurationName)));
interfaceType.CustomAttributes.Add(attribute);
}
public static void BuilderTemplate(ITemplateInfo templateinfo,ITemplateHost host)
{
Type type = host.BaseType;
string typename = "_" + Guid.NewGuid().ToString("N");
RazorTemplateEngine engine = CreateHost(type, "_" + type.Name, typename);
AddNamespace(type.Namespace);
GeneratorResults razorResults = null;
using (System.IO.StreamReader reader = templateinfo.GetCode())
{
razorResults = engine.GenerateCode(reader);
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CodeGeneratorOptions options = new CodeGeneratorOptions();
string LastGeneratedCode = null;
using (StringWriter writer = new StringWriter())
{
codeProvider.GenerateCodeFromCompileUnit(razorResults.GeneratedCode, writer, options);
templateinfo.Host.LastCompileSource = writer.ToString();
}
CompilerParameters compilerParameters = new CompilerParameters(new string[0]);
compilerParameters.OutputAssembly = "tmp_assembly" + typename;
compilerParameters.GenerateInMemory = false;
AddDomainAssemblies();
foreach (string item in ReferencedAssemblies)
compilerParameters.ReferencedAssemblies.Add(item);
compilerParameters.GenerateInMemory = true;
CompilerResults compilerResults = codeProvider.CompileAssemblyFromDom(compilerParameters, razorResults.GeneratedCode);
if (compilerResults.Errors.Count > 0)
{
string errormessage = null;
int throwindex = 1;
System.Text.StringBuilder sb = new System.Text.StringBuilder();
reader.BaseStream.Seek(0, SeekOrigin.Begin);
using (System.IO.StreamReader line = new StreamReader(reader.BaseStream, reader.CurrentEncoding))
{
ParserResults presult = engine.ParseTemplate(line);
if (presult.ParserErrors.Count > 0)
{
throwindex = presult.ParserErrors[0].Location.LineIndex + 1;
errormessage = presult.ParserErrors[0].Message;
reader.BaseStream.Seek(0, SeekOrigin.Begin);
using (System.IO.StreamReader readcode = new StreamReader(reader.BaseStream, reader.CurrentEncoding))
{
string code = readcode.ReadLine();
while (code != null)
{
sb.AppendLine(code);
code = readcode.ReadLine();
}
}
}
else
{
throwindex = compilerResults.Errors[0].Line;
errormessage = compilerResults.Errors[0].ErrorText;
sb.Append(LastGeneratedCode);
}
}
templateinfo.CompileError = errormessage;
throw new RazorException(templateinfo.CompileError);
}
templateinfo.Assembly = compilerResults.CompiledAssembly;
templateinfo.TemplateType = compilerResults.CompiledAssembly.GetType("_" + type.Name + "." + typename);
}
}
protected virtual IEnumerable <TextFile> ProcessStreamProperties(ITemplateInfo templateInfo)
{
return(this.ProcessProperties(templateInfo, this.CurrentModel.GetStreamProperties));
}
protected virtual IEnumerable <TextFile> ProcessEntityReferenceProperties(ITemplateInfo templateInfo)
{
return(this.ProcessTypes(templateInfo, this.CurrentModel.GetEntityReferenceTypes));
}
/// <summary>
/// Adds static and instance properties to an entity type to allow access to its TemplateID programmatically
/// </summary>
private static void AddTemplateIdPropertiesToEntity(CodeTypeDeclaration entity, ITemplateInfo template)
{
var templateNameStaticProperty = new CodeMemberProperty
{
Type = new CodeTypeReference(typeof(string)),
Name = "TemplateName",
HasGet = true,
HasSet = false,
// ReSharper disable BitwiseOperatorOnEnumWithoutFlags
Attributes = MemberAttributes.Public | MemberAttributes.Static
// ReSharper restore BitwiseOperatorOnEnumWithoutFlags
};
templateNameStaticProperty.Comments.Add(new CodeCommentStatement("<summary>The name of the Sitecore Template that this class represents</summary>", true));
templateNameStaticProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(template.Name)));
entity.Members.Add(templateNameStaticProperty);
var templateIdStaticProperty = new CodeMemberProperty
{
Type = new CodeTypeReference(typeof(ID)),
Name = "ItemTemplateId",
HasGet = true,
HasSet = false,
// ReSharper disable BitwiseOperatorOnEnumWithoutFlags
Attributes = MemberAttributes.Public | MemberAttributes.Static
// ReSharper restore BitwiseOperatorOnEnumWithoutFlags
};
templateIdStaticProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeSnippetExpression("new Sitecore.Data.ID(\"" + template.TemplateId + "\")")));
templateIdStaticProperty.Comments.Add(new CodeCommentStatement("<summary>The ID of the Sitecore Template that this class represents</summary>", true));
entity.Members.Add(templateIdStaticProperty);
var templateIdInstanceProperty = new CodeMemberProperty
{
Type = new CodeTypeReference(typeof(ID)),
Name = "TemplateId",
HasGet = true,
HasSet = false,
// ReSharper disable BitwiseOperatorOnEnumWithoutFlags
Attributes = MemberAttributes.Public | MemberAttributes.Override
// ReSharper restore BitwiseOperatorOnEnumWithoutFlags
};
templateIdInstanceProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeSnippetExpression("ItemTemplateId")));
templateIdInstanceProperty.Comments.Add(new CodeCommentStatement("<summary>The ID of the Sitecore Template that this class represents</summary>", true));
entity.Members.Add(templateIdInstanceProperty);
}
#pragma warning disable RECS0154 // Parameter is never used - but used by method which takes an action which is passed a template
public static string GetRandomName(ITemplateInfo template)
#pragma warning restore RECS0154 // Parameter is never used
{
return(Path.GetRandomFileName().Replace(".", ""));
}
/// <summary>
/// Check's whether a template should be reloaded or not.
/// </summary>
/// <param name="info">template information</param>
/// <returns>
/// true if template is OK; false if it do not exist or are old.
/// </returns>
public bool CheckTemplate(ITemplateInfo info)
{
return HasTemplate (info.Filename);
}
public async Task <TemplateCreationResult> InstantiateAsync(ITemplateInfo templateInfo, string name, string fallbackName, string outputPath, IReadOnlyDictionary <string, string> inputParameters, bool skipUpdateCheck, bool forceCreation, string baselineName, bool dryRun)
{
// SettingsLoader.LoadTemplate is where the loc info should be read!!!
// templateInfo knows enough to get at the loc, if any
ITemplate template = _environmentSettings.SettingsLoader.LoadTemplate(templateInfo, baselineName);
try
{
if (template == null)
{
return(new TemplateCreationResult("Could not load template", CreationResultStatus.NotFound, templateInfo.Name));
}
string realName = name ?? fallbackName ?? template.DefaultName;
if (string.IsNullOrEmpty(realName))
{
return(new TemplateCreationResult("--name", CreationResultStatus.MissingMandatoryParam, template.Name));
}
if (template.IsNameAgreementWithFolderPreferred && string.IsNullOrEmpty(outputPath))
{
outputPath = name;
}
ICreationResult creationResult = null;
string targetDir = outputPath ?? _environmentSettings.Host.FileSystem.GetCurrentDirectory();
try
{
if (!dryRun)
{
_paths.CreateDirectory(targetDir);
}
Stopwatch sw = Stopwatch.StartNew();
IComponentManager componentManager = _environmentSettings.SettingsLoader.Components;
// setup separate sets of parameters to be used for GetCreationEffects() and by CreateAsync().
if (!TryCreateParameterSet(template, realName, inputParameters, out IParameterSet effectParams, out TemplateCreationResult resultIfParameterCreationFailed))
{
return(resultIfParameterCreationFailed);
}
ICreationEffects creationEffects = template.Generator.GetCreationEffects(_environmentSettings, template, effectParams, componentManager, targetDir);
IReadOnlyList <IFileChange> changes = creationEffects.FileChanges;
IReadOnlyList <IFileChange> destructiveChanges = changes.Where(x => x.ChangeKind != ChangeKind.Create).ToList();
if (!forceCreation && destructiveChanges.Count > 0)
{
if (!_environmentSettings.Host.OnPotentiallyDestructiveChangesDetected(changes, destructiveChanges))
{
return(new TemplateCreationResult("Cancelled", CreationResultStatus.Cancelled, template.Name));
}
}
if (!TryCreateParameterSet(template, realName, inputParameters, out IParameterSet creationParams, out resultIfParameterCreationFailed))
{
return(resultIfParameterCreationFailed);
}
if (!dryRun)
{
creationResult = await template.Generator.CreateAsync(_environmentSettings, template, creationParams, componentManager, targetDir).ConfigureAwait(false);
}
sw.Stop();
_environmentSettings.Host.LogTiming("Content generation time", sw.Elapsed, 0);
return(new TemplateCreationResult(string.Empty, CreationResultStatus.Success, template.Name, creationResult, targetDir, creationEffects));
}
catch (ContentGenerationException cx)
{
string message = cx.Message;
if (cx.InnerException != null)
{
message += Environment.NewLine + cx.InnerException.Message;
}
return(new TemplateCreationResult(message, CreationResultStatus.CreateFailed, template.Name));
}
catch (Exception ex)
{
return(new TemplateCreationResult(ex.Message, CreationResultStatus.CreateFailed, template.Name));
}
}
finally
{
ReleaseMountPoints(template);
}
}
private async Task TrackItemGenAsync(string eventToTrack, ITemplateInfo template, GenSourceEnum genSource, string appProjectType, string appFx, TemplateCreationResult result)
{
GenStatusEnum telemetryStatus = result.Status == CreationResultStatus.Success ? GenStatusEnum.Completed : GenStatusEnum.Error;
await TrackItemGenAsync(eventToTrack, telemetryStatus, appProjectType, appFx, template.Name, genSource, result.Status, result.Message);
}
/// <summary>
/// Adds static and instance properties to an entity type to allow access to its TemplateID programmatically
/// </summary>
private static void AddTemplateIdPropertiesToEntity(CodeTypeDeclaration entity, ITemplateInfo template)
{
var templateNameStaticProperty = new CodeMemberProperty
{
Type = new CodeTypeReference(typeof(string)),
Name = "TemplateName",
HasGet = true,
HasSet = false,
// ReSharper disable BitwiseOperatorOnEnumWithoutFlags
Attributes = MemberAttributes.Public | MemberAttributes.Static
// ReSharper restore BitwiseOperatorOnEnumWithoutFlags
};
templateNameStaticProperty.Comments.Add(new CodeCommentStatement("<summary>The name of the Sitecore Template that this class represents</summary>", true));
templateNameStaticProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(template.Name)));
entity.Members.Add(templateNameStaticProperty);
var templateIdStaticProperty = new CodeMemberProperty
{
Type = new CodeTypeReference(typeof(ID)),
Name = "ItemTemplateId",
HasGet = true,
HasSet = false,
// ReSharper disable BitwiseOperatorOnEnumWithoutFlags
Attributes = MemberAttributes.Public | MemberAttributes.Static
// ReSharper restore BitwiseOperatorOnEnumWithoutFlags
};
templateIdStaticProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeSnippetExpression("new Sitecore.Data.ID(\"" + template.TemplateId + "\")")));
templateIdStaticProperty.Comments.Add(new CodeCommentStatement("<summary>The ID of the Sitecore Template that this class represents</summary>", true));
entity.Members.Add(templateIdStaticProperty);
var templateIdInstanceProperty = new CodeMemberProperty
{
Type = new CodeTypeReference(typeof(ID)),
Name = "TemplateId",
HasGet = true,
HasSet = false,
// ReSharper disable BitwiseOperatorOnEnumWithoutFlags
Attributes = MemberAttributes.Public | MemberAttributes.Override
// ReSharper restore BitwiseOperatorOnEnumWithoutFlags
};
templateIdInstanceProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeSnippetExpression("ItemTemplateId")));
templateIdInstanceProperty.Comments.Add(new CodeCommentStatement("<summary>The ID of the Sitecore Template that this class represents</summary>", true));
entity.Members.Add(templateIdInstanceProperty);
}
public FilteredTemplateInfo(ITemplateInfo info, IReadOnlyList <MatchInfo> matchDisposition)
{
Info = info;
MatchDisposition = matchDisposition;
}
private IReadOnlyDictionary <string, ICacheParameter> LocalizeCacheParameters(ITemplateInfo template, ILocalizationLocator localizationInfo)
{
if (localizationInfo == null || localizationInfo.ParameterSymbols == null)
{
return(template.CacheParameters);
}
IReadOnlyDictionary <string, ICacheParameter> templateCacheParameters = template.CacheParameters;
IReadOnlyDictionary <string, IParameterSymbolLocalizationModel> localizedParameterSymbols = localizationInfo.ParameterSymbols;
Dictionary <string, ICacheParameter> localizedCacheParams = new Dictionary <string, ICacheParameter>();
foreach (KeyValuePair <string, ICacheParameter> templateParam in templateCacheParameters)
{
if (localizedParameterSymbols.TryGetValue(templateParam.Key, out IParameterSymbolLocalizationModel localizationForParam))
{ // there is loc info for this symbol
ICacheParameter localizedParam = new CacheParameter
{
DataType = templateParam.Value.DataType,
DefaultValue = templateParam.Value.DefaultValue,
Description = localizationForParam.Description ?? templateParam.Value.Description
};
localizedCacheParams.Add(templateParam.Key, localizedParam);
}
else
{
localizedCacheParams.Add(templateParam.Key, templateParam.Value);
}
}
return(localizedCacheParams);
}
public ItemTemplateFieldInfo(TemplateFieldItem field, ITemplateInfo template) : this(field)
{
Assert.ArgumentNotNull(template, "template");
Template = template;
}
private static bool AlreadyAdded(UserSelection userSelection, ITemplateInfo item)
{
return(userSelection.Pages.Any(p => p.template.Identity == item.Identity) || userSelection.Features.Any(f => f.template.Identity == item.Identity));
}
/// <summary>
/// Adds a interface template to the state collection
/// </summary>
public TemplateInfo AddInterface(ITemplateInfo item, string interfaceSuffix)
{
if (_friendInterfaceLookup.ContainsKey(item.TemplateId)) throw new InvalidOperationException("The template " + item.FullPath + " is already added as a friend interface and cannot be added again.");
var templateInfo = new TemplateInfo(item, _parameters.InterfaceNamespace);
string interfaceName = "I" + item.Name.AsIdentifier() + interfaceSuffix;
string interfaceFullPath = item.FullPath.Substring(0, item.FullPath.LastIndexOf('/') + 1) + interfaceName;
templateInfo.FullName = _interfaceNovelizer.GetNovelFullTypeName(interfaceName, interfaceFullPath);
_interfaceLookup.Add(item.TemplateId, templateInfo);
_interfaces.Add(templateInfo);
return templateInfo;
}
private List<ITemplateInfo> GetRecursiveBaseTemplates(ITemplateInfo parent)
{
// let's keep it our little secret that this is an iterative method, not recursive ;)
var parentBases = new Queue<ITemplateInfo>(parent.BaseTemplates.Where(x => x.Name.ToUpperInvariant() != "STANDARD TEMPLATE")); // we just want NON-standard base templates
var bases = new Dictionary<ID, ITemplateInfo>();
while (parentBases.Count > 0)
{
var currentBase = parentBases.Dequeue();
// already processed this template; skip it (e.g. a template cycle), or if it's the parent template
if (bases.ContainsKey(currentBase.TemplateId) || currentBase.TemplateId.Equals(parent.TemplateId)) continue;
// add grandparent base templates to processing queue
var newBases = currentBase.BaseTemplates.Where(x => x.Name.ToUpperInvariant() != "STANDARD TEMPLATE");
foreach(var newBase in newBases) parentBases.Enqueue(newBase);
// add parent base template to bases
bases.Add(currentBase.TemplateId, currentBase);
}
return bases.Values.ToList();
}
private static void LoadAndStoreTemplate(ITemplateInfo template, Encoding encoding = null)
{
template.Template = encoding != null ? Reader.Read(template.Path, encoding) : Reader.Read(template.Path);
if (CachedTemplates.ContainsKey(template.Path))
{
CachedTemplates[template.Path] = template;
}
else
{
CachedTemplates.Add(template.Path, template);
}
}
private static bool Match(IEnumerable <QueryNode> query, ITemplateInfo template)
{
return(Match(query, template.GetQueryableProperties()));
}
protected virtual IEnumerable <TextFile> ProcessMethods(ITemplateInfo templateInfo)
{
return(this.ProcessMethods(templateInfo, this.CurrentModel.GetMethods));
}
/// <summary>
/// Checks the template.
/// </summary>
/// <param name="info">Template information, filename must be set.</param>
/// <returns>true if template exists and have been compiled.</returns>
private bool CheckTemplate(ITemplateInfo info)
{
if (info == null)
return false;
foreach (ITemplateLoader loader in _templateLoaders)
if (loader.HasTemplate(info.Filename))
return loader.CheckTemplate(info);
return false;
}
internal static string GetTemplateHelpCommand(string commandName, ITemplateInfo template)
{
return(GetTemplateHelpCommand(commandName, template.ShortName));
}
public static IEnumerable <ITemplateInfo> GetAllDependencies(ITemplateInfo template, string framework, string platform)
{
return(GetDependencies(template, framework, platform, new List <ITemplateInfo>()));
}
internal static string GetTemplateHelpCommand(string commandName, ITemplateInfo template)
{
return($"dotnet {commandName} {template.ShortName} --help");
}
public bool IsStale(ITemplateInfo template)
{
var storedTemplate = CachedTemplates[template.Path];
return template.LastWriteTime > storedTemplate.LastWriteTime;
}
/// <summary>
/// Checks if a given Sitecore template has a corresponding interface. This method does NOT check any base templates this template may have for synchronization.
/// </summary>
public TemplateComparisonResult IsTemplateSynchronized(ITemplateInfo template)
{
var signature = _signatureProvider.GenerateTemplateSignature(template);
ModelTemplateReference reference;
if (ModelDictionary.TryGetValue(template.TemplateId.ToString(), out reference))
return new TemplateComparisonResult(
template.TemplateId.ToString(),
GetTemplateName(template),
GetModelName(reference),
signature,
reference.Metadata.VersionSignature);
return new TemplateComparisonResult(template.TemplateId.ToString(), GetTemplateName(template), null, signature, null);
}
/// <summary>
/// Always returns true since a resource won't be updated during execution
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public bool CheckTemplate(ITemplateInfo info)
{
return true;
}
protected static string GetTemplateName(ITemplateInfo template)
{
return template.FullPath.Substring("/sitecore/templates".Length);
}
/// <summary>
/// Generates an interface for each template that the current template derives from, recursively.
/// </summary>
private TemplateInfo GenerateInheritedInterfaces(ITemplateInfo template, TemplateGenerationMetadata templateData)
{
var existingInterface = templateData.GetInterface(template.TemplateId);
if (existingInterface != null) return existingInterface;
var interfaceInfo = templateData.AddInterface(template, _parameters.InterfaceSuffix);
var fieldKeys = GetBaseFieldSet();
fieldKeys.Add(interfaceInfo.TypeName); // member names cannot be the same as their enclosing type
fieldKeys.Add(template.Name.AsIdentifier()); // prevent any fields from being generated that would conflict with a concrete item name as well as the interface name
// create interface properties
foreach (var field in template.OwnFields)
{
if (_templateInputProvider.IsFieldIncluded(field.Id))
{
string propertyName = field.Name.AsNovelIdentifier(fieldKeys);
var fieldInfo = new FieldPropertyInfo(field);
fieldInfo.FieldPropertyName = propertyName;
fieldInfo.SearchFieldName = _indexFieldNameTranslator.GetIndexFieldName(field.Name);
fieldInfo.FieldType = _fieldMappingProvider.GetFieldType(field);
if (fieldInfo.FieldType == null)
{
Log.Warn("Synthesis: Field type resolution for " + field.Template.Name + "::" + field.Name + " failed; no mapping found for field type " + field.Type, this);
continue; // skip adding the field for generation
}
// record usage of the property name
fieldKeys.Add(propertyName);
// add the field to the metadata
interfaceInfo.FieldsToGenerate.Add(fieldInfo);
}
}
// add base interface inheritance
foreach (var baseTemplate in template.BaseTemplates)
{
if (baseTemplate.Name.ToUpperInvariant() != StandardTemplate)
{
// recursively generate base templates' interfaces as needed
var baseInterface = GenerateInheritedInterfaces(baseTemplate, templateData);
if (baseInterface != null)
interfaceInfo.InterfacesImplemented.Add(baseInterface); // assign interface implementation
}
}
return interfaceInfo;
}
protected virtual IEnumerable <TextFile> ProcessCollectionReferences(ITemplateInfo templateInfo)
{
return(this.ProcessProperties(templateInfo, this.CollectionReferenceProperties));
}
