protected override string RenderTemplate(string content, PageContext pageData)
{
var serviceConfiguration = new TemplateServiceConfiguration
{
TemplateManager = new IncludesResolver(FileSystem, includesPath),
BaseTemplateType = typeof(ExtensibleTemplate <>),
DisableTempFileLocking = true,
CachingProvider = new DefaultCachingProvider(t => { }),
ConfigureCompilerBuilder = builder => ModelDirective.Register(builder)
};
serviceConfiguration.Activator = new ExtensibleActivator(serviceConfiguration.Activator, Filters, _allTags);
Engine.Razor = RazorEngineService.Create(serviceConfiguration);
content = Regex.Replace(content, "<p>(@model .*?)</p>", "$1");
var pageContent = pageData.Content;
pageData.Content = pageData.FullContent;
try
{
content = Engine.Razor.RunCompile(content, pageData.Page.File, typeof(PageContext), pageData);
pageData.Content = pageContent;
return(content);
}
catch (Exception e)
{
Tracing.Error(@"Failed to render template, falling back to direct content");
Tracing.Debug(e.Message);
Tracing.Debug(e.StackTrace);
return(content);
}
}
protected override void ExecuteCore(RazorCodeDocument codeDocument)
{
DocumentIntermediateNode documentNode = codeDocument.GetDocumentIntermediateNode();
NamespaceDeclarationIntermediateNode namespaceDeclaration =
documentNode.Children.OfType <NamespaceDeclarationIntermediateNode>().Single();
// Get the current model type, replacing default of dynamic with IDocument
string modelType = ModelDirective.GetModelType(documentNode);
modelType = modelType == "dynamic" ? "IDocument" : modelType;
// Set the base page type and perform default model type substitution here
ClassDeclarationIntermediateNode classDeclaration =
namespaceDeclaration.Children.OfType <ClassDeclarationIntermediateNode>().Single();
classDeclaration.BaseType = _baseType.Replace("<TModel>", "<" + modelType + ">");
// Add namespaces
int insertIndex = namespaceDeclaration.Children.IndexOf(
namespaceDeclaration.Children.OfType <UsingDirectiveIntermediateNode>().First());
foreach (string ns in _namespaces)
{
namespaceDeclaration.Children.Insert(
insertIndex,
new UsingDirectiveIntermediateNode()
{
Content = ns
});
}
codeDocument.SetDocumentIntermediateNode(documentNode);
}
private IList <ModelDirective> BuildDirectivesFromAttributes(ICustomAttributeProvider clrObjectInfo,
DirectiveLocation location, GraphQLModelObject owner)
{
var attrList = clrObjectInfo.GetCustomAttributes(inherit: true);
if (attrList.Length == 0)
{
return(ModelDirective.EmptyList);
}
var dirList = new List <ModelDirective>();
foreach (var attr in attrList)
{
if (!(attr is BaseDirectiveAttribute dirAttr))
{
continue;
}
var dirAttrType = dirAttr.GetType();
var dirDef = _model.Directives.Values.FirstOrDefault(def => def.DirInfo.AttributeType == dirAttrType);
if (dirDef == null)
{
AddError($"{clrObjectInfo}: directive attribute {dirAttrType} not registered.");
continue;
}
var dir = new ModelDirective()
{
Def = dirDef, ModelAttribute = dirAttr, Location = location
};
dirList.Add(dir);
}
return(dirList);
} //method
private RazorEngine GetRazorEngine()
{
var razorEngine = RazorEngine.Create(builder =>
{
InjectDirective.Register(builder);
ModelDirective.Register(builder);
NamespaceDirective.Register(builder);
PageDirective.Register(builder);
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
////builder.AddTargetExtension(new TemplateTargetExtension()
////{
//// TemplateTypeName = "global::Microsoft.AspNetCore.Mvc.Razor.HelperResult",
////});
////builder.Features.Add(new SuppressChecksumOptionsFeature());
builder.Features.Add(new ModelExpressionPass());
builder.Features.Add(new PagesPropertyInjectionPass());
builder.Features.Add(new ViewComponentTagHelperPass());
builder.Features.Add(new RazorPageDocumentClassifierPass());
builder.Features.Add(new MvcViewDocumentClassifierPass2(RuntimeTemplatesNamespace, BaseViewName));
builder.Features.Add(new AssemblyAttributeInjectionPass2());
if (!builder.DesignTime)
{
//builder.Features.Add(new InstrumentationPass());
}
});
return(razorEngine);
}
public static void Register(IRazorEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
EnsureDesignTime(builder);
InjectDirective.Register(builder);
ModelDirective.Register(builder);
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
builder.Features.Add(new DefaultTagHelperDescriptorProvider());
// Register section directive with the 1.x compatible target extension.
builder.AddDirective(SectionDirective.Directive);
builder.Features.Add(new SectionDirectivePass());
builder.AddTargetExtension(new LegacySectionTargetExtension());
builder.AddTargetExtension(new TemplateTargetExtension()
{
TemplateTypeName = "global::Microsoft.AspNetCore.Mvc.Razor.HelperResult",
});
builder.Features.Add(new ModelExpressionPass());
builder.Features.Add(new MvcViewDocumentClassifierPass());
}
public static void Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
InjectDirective.Register(builder);
ModelDirective.Register(builder);
InheritsDirective.Register(builder);
builder.Features.Add(new DefaultTagHelperDescriptorProvider());
// Register section directive with the 1.x compatible target extension.
builder.AddDirective(SectionDirective.Directive);
builder.Features.Add(new SectionDirectivePass());
builder.AddTargetExtension(new LegacySectionTargetExtension());
builder.AddTargetExtension(new TemplateTargetExtension()
{
TemplateTypeName = "global::Microsoft.AspNetCore.Mvc.Razor.HelperResult",
});
builder.Features.Add(new ModelExpressionPass());
builder.Features.Add(new MvcViewDocumentClassifierPass());
builder.Features.Add(new MvcImportProjectFeature());
// The default C# language version for what this Razor configuration supports.
builder.SetCSharpLanguageVersion(LanguageVersion.CSharp7_3);
}
protected override void ExecuteCore(RazorCodeDocument codeDocument, DocumentIntermediateNode documentNode)
{
if (documentNode.DocumentKind != RazorPageDocumentClassifierPass.RazorPageDocumentKind)
{
return;
}
var modelType = ModelDirective.GetModelType(documentNode);
var visitor = new Visitor();
visitor.Visit(documentNode);
var @class = visitor.Class;
var viewDataType = $"global::Microsoft.AspNetCore.Mvc.ViewFeatures.ViewDataDictionary<{modelType}>";
var vddProperty = new CSharpCodeIntermediateNode();
vddProperty.Children.Add(new IntermediateToken()
{
Kind = TokenKind.CSharp,
Content = $"public {viewDataType} ViewData => ({viewDataType})PageContext?.ViewData;",
});
@class.Children.Add(vddProperty);
var modelProperty = new CSharpCodeIntermediateNode();
modelProperty.Children.Add(new IntermediateToken()
{
Kind = TokenKind.CSharp,
Content = $"public {modelType} Model => ViewData.Model;",
});
@class.Children.Add(modelProperty);
}
public RuntimeDirective(ModelDirective modelDir, int index)
{
Source = modelDir;
Index = index;
Def = modelDir.Def;
Location = modelDir.Location;
StaticArgValues = modelDir.ArgValues;
}
public void ModelDirective_GetModelType_DefaultsToDynamic()
{
// Arrange
var codeDocument = CreateDocument(@" ");
var engine = CreateRuntimeEngine();
var irDocument = CreateIRDocument(engine, codeDocument);
// Act
var result = ModelDirective.GetModelType(irDocument);
// Assert
Assert.Equal("dynamic", result);
}
public async Task Handle_AddOneUsingToPageDirective()
{
// Arrange
var documentPath = "c:/Test.cshtml";
var documentUri = new Uri(documentPath);
var contents = $"@page{Environment.NewLine}@model IndexModel";
var projectItem = new TestRazorProjectItem("c:/Test.cshtml", "c:/Test.cshtml", "Test.cshtml")
{
Content = contents
};
var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, TestRazorProjectFileSystem.Empty, (builder) =>
{
PageDirective.Register(builder);
ModelDirective.Register(builder);
});
var codeDocument = projectEngine.Process(projectItem);
codeDocument.SetFileKind(FileKinds.Legacy);
var resolver = new AddUsingsCodeActionResolver(LegacyDispatcher, CreateDocumentResolver(documentPath, codeDocument));
var actionParams = new AddUsingsCodeActionParams
{
Uri = documentUri,
Namespace = "System"
};
var data = JObject.FromObject(actionParams);
// Act
var workspaceEdit = await resolver.ResolveAsync(data, default);
// Assert
Assert.NotNull(workspaceEdit);
Assert.NotNull(workspaceEdit.DocumentChanges);
Assert.Single(workspaceEdit.DocumentChanges);
var documentChanges = workspaceEdit.DocumentChanges.ToArray();
var addUsingsChange = documentChanges[0];
Assert.True(addUsingsChange.IsTextDocumentEdit);
var firstEdit = Assert.Single(addUsingsChange.TextDocumentEdit.Edits);
Assert.Equal(1, firstEdit.Range.Start.Line);
Assert.Equal($"@using System{Environment.NewLine}", firstEdit.NewText);
}
protected override void ExecuteCore(RazorCodeDocument codeDocument, DocumentIntermediateNode documentNode)
{
if (documentNode.DocumentKind != RazorPageDocumentClassifierPass.RazorPageDocumentKind &&
documentNode.DocumentKind != MvcViewDocumentClassifierPass.MvcViewDocumentKind)
{
// Not a MVC file. Skip.
return;
}
var visitor = new Visitor();
visitor.Visit(documentNode);
var modelType = ModelDirective.GetModelType(documentNode);
var properties = new HashSet <string>(StringComparer.Ordinal);
for (var i = visitor.Directives.Count - 1; i >= 0; i--)
{
var directive = visitor.Directives[i];
var tokens = directive.Tokens.ToArray();
if (tokens.Length < 2)
{
continue;
}
var typeName = tokens[0].Content;
var memberName = tokens[1].Content;
if (!properties.Add(memberName))
{
continue;
}
typeName = typeName.Replace("<TModel>", "<" + modelType + ">");
var injectNode = new InjectIntermediateNode()
{
TypeName = typeName,
MemberName = memberName,
};
visitor.Class.Children.Add(injectNode);
}
}
public void ModelDirective_GetModelType_GetsTypeFromFirstWellFormedDirective()
{
// Arrange
var codeDocument = CreateDocument(@"
@model Type1
@model Type2
@model
");
var engine = CreateRuntimeEngine();
var irDocument = CreateIRDocument(engine, codeDocument);
// Act
var result = ModelDirective.GetModelType(irDocument);
// Assert
Assert.Equal("Type1", result);
}
public static void Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
InjectDirective.Register(builder);
ModelDirective.Register(builder);
PageDirective.Register(builder);
SectionDirective.Register(builder);
builder.Features.Add(new DefaultTagHelperDescriptorProvider());
builder.Features.Add(new ViewComponentTagHelperDescriptorProvider());
builder.AddTargetExtension(new ViewComponentTagHelperTargetExtension());
builder.AddTargetExtension(new TemplateTargetExtension()
{
TemplateTypeName = "global::Microsoft.AspNetCore.Mvc.Razor.HelperResult",
});
builder.Features.Add(new ModelExpressionPass());
builder.Features.Add(new PagesPropertyInjectionPass());
builder.Features.Add(new ViewComponentTagHelperPass());
builder.Features.Add(new RazorPageDocumentClassifierPass(builder.Configuration.UseConsolidatedMvcViews));
builder.Features.Add(new MvcViewDocumentClassifierPass(builder.Configuration.UseConsolidatedMvcViews));
builder.Features.Add(new MvcImportProjectFeature());
// The default C# language version for what this Razor configuration supports.
builder.SetCSharpLanguageVersion(LanguageVersion.CSharp8);
if (builder.Configuration.LanguageVersion.CompareTo(RazorLanguageVersion.Version_6_0) >= 0)
{
builder.Features.Add(new CreateNewOnMetadataUpdateAttributePass());
}
}
public static void Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
FunctionsDirective.Register(builder);
InjectDirective.Register(builder);
ModelDirective.Register(builder);
NamespaceDirective.Register(builder);
PageDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
builder.Features.Add(new DefaultTagHelperDescriptorProvider());
builder.Features.Add(new ViewComponentTagHelperDescriptorProvider());
builder.AddTargetExtension(new ViewComponentTagHelperTargetExtension());
builder.AddTargetExtension(new TemplateTargetExtension()
{
TemplateTypeName = "global::Microsoft.AspNetCore.Mvc.Razor.HelperResult",
});
builder.Features.Add(new ModelExpressionPass());
builder.Features.Add(new PagesPropertyInjectionPass());
builder.Features.Add(new ViewComponentTagHelperPass());
builder.Features.Add(new RazorPageDocumentClassifierPass());
builder.Features.Add(new MvcViewDocumentClassifierPass());
builder.Features.Add(new AssemblyAttributeInjectionPass());
builder.Features.Add(new InstrumentationPass());
builder.Features.Add(new MvcImportProjectFeature());
// The default C# language version for what this Razor configuration supports.
builder.SetCSharpLanguageVersion(LanguageVersion.CSharp7_3);
}
public RuntimeModelDirective(ModelDirective modelDir) : base(modelDir.Def, modelDir.Location)
{
Directive = modelDir;
}
public async Task <ViewValidationException> ValidateAsync(string viewPath)
{
var fileSystem = RazorProjectFileSystem.Create(".");
var engine = RazorProjectEngine.Create(
RazorConfiguration.Default,
fileSystem,
(builder) =>
{
InheritsDirective.Register(builder);
ModelDirective.Register(builder);
});
var item = fileSystem.GetItem(viewPath);
var codeDocument = engine.Process(item);
var csharpDocument = codeDocument.GetCSharpDocument();
var csharpTree = CSharpSyntaxTree.ParseText(csharpDocument.GeneratedCode);
var rootNode = await csharpTree.GetRootAsync();
var memberAccesses = FetchChildrenRecursivelyFromNode(
rootNode,
SyntaxKind.SimpleMemberAccessExpression);
foreach (var memberAccess in memberAccesses)
{
var simpleMemberAccess = memberAccess as MemberAccessExpressionSyntax;
if (simpleMemberAccess == null)
{
continue;
}
while (simpleMemberAccess.Expression is MemberAccessExpressionSyntax)
{
simpleMemberAccess = (MemberAccessExpressionSyntax)simpleMemberAccess.Expression;
}
var identifier = simpleMemberAccess.Expression as IdentifierNameSyntax;
if (identifier == null)
{
continue;
}
var propertyName = identifier.Identifier.Text;
if (propertyName != "Model")
{
return(new ViewValidationException("The namespace " + propertyName + " is not allowed. You can only use Model when evaluating expressions."));
}
var methodName = simpleMemberAccess.Name;
var allowedMethodNames = new List <string>()
{
nameof(ApiModel.Get),
nameof(ApiModel.GetCollection)
};
if (!allowedMethodNames.Contains(methodName.Identifier.Text))
{
return(new ViewValidationException("The method " + methodName + " on the model object is not allowed. You can only call the following methods on that object: " + allowedMethodNames.Aggregate((a, b) => a + ", " + b) + "."));
}
}
return(null);
}
