public Task <Stream> Consent(ConsentViewModel model, ValidatedAuthorizeRequest authorizeRequest) { // return Render(model, "consent"); var stream = StringToStream(RazorExtensions.RenderCustomView("consent", "home", model)); return(Task.FromResult(stream)); }
private static RazorProjectEngineFactoryService CreateTemplateEngineFactory( string path = TestLinePragmaFileName, IEnumerable <TagHelperDescriptor> tagHelpers = null) { var fileSystem = new TestRazorProjectFileSystem(); var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, builder => { RazorExtensions.Register(builder); builder.AddDefaultImports(new TestRazorProjectItem("_TestImports.cshtml") { Content = "@addTagHelper *, Test" }); if (tagHelpers != null) { builder.AddTagHelpers(tagHelpers); } }); var projectEngineFactoryService = Mock.Of <RazorProjectEngineFactoryService>( service => service.Create(It.IsAny <string>(), It.IsAny <Action <RazorProjectEngineBuilder> >()) == projectEngine); return(projectEngineFactoryService); }
public virtual Task <System.IO.Stream> Error(ErrorViewModel model) { // return Render(model, "error"); var stream = StringToStream(RazorExtensions.RenderCustomView("error", "home", model)); return(Task.FromResult(stream)); }
public Task <Stream> LoggedOut(LoggedOutViewModel model, SignOutMessage message) { // return Render(model, "loggedOut"); var stream = StringToStream(RazorExtensions.RenderCustomView("loggedOut", "home", model)); return(Task.FromResult(stream)); }
protected override async Task <UpgradeStepInitializeResult> InitializeImplAsync(IUpgradeContext context, CancellationToken token) { if (context is null) { throw new ArgumentNullException(nameof(context)); } _razorEngine = RazorProjectEngine.Create(RazorConfiguration.Default, GetRazorFileSystem(context.CurrentProject.Required()), builder => { // Add useful "MVC View-isms" like _ViewImports support, page models, etc. // https://github.com/dotnet/aspnetcore/blob/main/src/Razor/Microsoft.AspNetCore.Mvc.Razor.Extensions/src/RazorExtensions.cs RazorExtensions.Register(builder); }); // Process all Razor documents initially // SubSteps can call ProcessRazorDocuments with specific files that have changed later to re-process specific documents ProcessRazorDocuments(null); foreach (var step in SubSteps) { await step.InitializeAsync(context, token).ConfigureAwait(false); } var incompleteSubSteps = SubSteps.Count(s => !s.IsDone); return(incompleteSubSteps == 0 ? new UpgradeStepInitializeResult(UpgradeStepStatus.Complete, "No Razor updaters need applied", BuildBreakRisk.None) : new UpgradeStepInitializeResult(UpgradeStepStatus.Incomplete, $"{incompleteSubSteps} Razor updaters need applied", SubSteps.Where(s => !s.IsDone).Max(s => s.Risk))); }
public override RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure) { return(RazorProjectEngine.Create(configuration, fileSystem, b => { RazorExtensions.Register(b); })); }
private static RazorProjectEngine GetDeclarationProjectEngine( SourceGeneratorProjectItem item, IEnumerable <SourceGeneratorProjectItem> imports, RazorSourceGenerationOptions razorSourceGeneratorOptions) { var fileSystem = new VirtualRazorProjectFileSystem(); fileSystem.Add(item); foreach (var import in imports) { fileSystem.Add(import); } var discoveryProjectEngine = RazorProjectEngine.Create(razorSourceGeneratorOptions.Configuration, fileSystem, b => { b.Features.Add(new DefaultTypeNameFeature()); b.Features.Add(new ConfigureRazorCodeGenerationOptions(options => { options.SuppressPrimaryMethodBody = true; options.SuppressChecksum = true; })); b.SetRootNamespace(razorSourceGeneratorOptions.RootNamespace); CompilerFeatures.Register(b); RazorExtensions.Register(b); b.SetCSharpLanguageVersion(razorSourceGeneratorOptions.CSharpLanguageVersion); }); return(discoveryProjectEngine); }
private static RazorTemplateEngineFactoryService CreateTemplateEngineFactory( string path = TestLinePragmaFileName, IEnumerable <TagHelperDescriptor> tagHelpers = null) { var engine = RazorEngine.CreateDesignTime(builder => { RazorExtensions.Register(builder); if (tagHelpers != null) { builder.AddTagHelpers(tagHelpers); } }); // GetImports on RazorTemplateEngine will at least check that the item exists, so we need to pretend // that it does. var items = new List <RazorProjectItem>(); items.Add(new TestRazorProjectItem(path)); var project = new TestRazorProject(items); var templateEngine = new RazorTemplateEngine(engine, project); templateEngine.Options.DefaultImports = RazorSourceDocument.Create("@addTagHelper *, Test", "_TestImports.cshtml"); var templateEngineFactory = Mock.Of <RazorTemplateEngineFactoryService>( service => service.Create(It.IsAny <string>(), It.IsAny <Action <IRazorEngineBuilder> >()) == templateEngine); return(templateEngineFactory); }
public RazorTagHelperParsingBenchmark() { var current = new DirectoryInfo(AppContext.BaseDirectory); while (current != null && !File.Exists(Path.Combine(current.FullName, "taghelpers.json"))) { current = current.Parent; } var root = current; var tagHelpers = ReadTagHelpers(Path.Combine(root.FullName, "taghelpers.json")); var tagHelperFeature = new StaticTagHelperFeature(tagHelpers); var blazorServerTagHelpersFilePath = Path.Combine(root.FullName, "BlazorServerTagHelpers.razor"); var fileSystem = RazorProjectFileSystem.Create(root.FullName); ProjectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, b => { RazorExtensions.Register(b); b.Features.Add(tagHelperFeature); }); BlazorServerTagHelpersDemoFile = fileSystem.GetItem(Path.Combine(blazorServerTagHelpersFilePath), FileKinds.Component); ComponentDirectiveVisitor = new ComponentDirectiveVisitor(blazorServerTagHelpersFilePath, tagHelpers, currentNamespace: null); var codeDocument = ProjectEngine.ProcessDesignTime(BlazorServerTagHelpersDemoFile); SyntaxTree = codeDocument.GetSyntaxTree(); }
private static RazorTemplateEngine CreateTemplateEngine( string path = "C:\\This\\Path\\Is\\Just\\For\\Line\\Pragmas.cshtml", IEnumerable <TagHelperDescriptor> tagHelpers = null) { var engine = RazorEngine.CreateDesignTime(builder => { RazorExtensions.Register(builder); if (tagHelpers != null) { builder.AddTagHelpers(tagHelpers); } }); // GetImports on RazorTemplateEngine will at least check that the item exists, so we need to pretend // that it does. var items = new List <RazorProjectItem>(); items.Add(new TestRazorProjectItem(path)); var project = new TestRazorProject(items); var templateEngine = new RazorTemplateEngine(engine, project); templateEngine.Options.DefaultImports = RazorSourceDocument.Create("@addTagHelper *, Test", "_TestImports.cshtml"); return(templateEngine); }
public void Execute(GeneratorExecutionContext context) { var razorContext = RazorSourceGenerationContext.Create(context); if (razorContext is null || (razorContext.RazorFiles.Count == 0 && razorContext.CshtmlFiles.Count == 0)) { return; } HandleDebugSwitch(razorContext.WaitForDebugger); var tagHelpers = ResolveTagHelperDescriptors(context, razorContext); var projectEngine = RazorProjectEngine.Create(razorContext.Configuration, razorContext.FileSystem, b => { b.Features.Add(new DefaultTypeNameFeature()); b.SetRootNamespace(razorContext.RootNamespace); b.Features.Add(new StaticTagHelperFeature { TagHelpers = tagHelpers, }); b.Features.Add(new DefaultTagHelperDescriptorProvider()); CompilerFeatures.Register(b); RazorExtensions.Register(b); b.SetCSharpLanguageVersion(((CSharpParseOptions)context.ParseOptions).LanguageVersion); }); CodeGenerateRazorComponents(context, razorContext, projectEngine); GenerateViews(context, razorContext, projectEngine); }
private static TestRazorViewCompiler GetViewCompiler( TestFileProvider fileProvider = null, PublicRazorReferenceManager referenceManager = null, IList <CompiledViewDescriptor> precompiledViews = null, PublicCSharpCompiler csharpCompiler = null) { fileProvider = fileProvider ?? new TestFileProvider(); var options = Options.Create(new MvcRazorRuntimeCompilationOptions { FileProviders = { fileProvider } }); var compilationFileProvider = new PublicRuntimeCompilationFileProvider(options); referenceManager = referenceManager ?? CreateReferenceManager(); precompiledViews = precompiledViews ?? Array.Empty <CompiledViewDescriptor>(); var hostingEnvironment = Mock.Of <IWebHostEnvironment>(e => e.ContentRootPath == "BasePath"); var fileSystem = new PublicFileProviderRazorProjectFileSystem(compilationFileProvider); var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, builder => { RazorExtensions.Register(builder); }); csharpCompiler = csharpCompiler ?? new PublicCSharpCompiler(referenceManager, hostingEnvironment); return(new TestRazorViewCompiler( projectEngine, csharpCompiler, precompiledViews)); }
public Task <Stream> ClientPermissions(ClientPermissionsViewModel model) { // return Render(model, "permissions"); var stream = StringToStream(RazorExtensions.RenderCustomView("permissions", "home", model)); return(Task.FromResult(stream)); }
// Internal for testing. internal static void AddRazorViewEngineServices(IServiceCollection services) { services.TryAddSingleton <CSharpCompiler>(); services.TryAddSingleton <RazorReferenceManager, DefaultRazorReferenceManager>(); services.TryAddEnumerable( ServiceDescriptor.Transient <IConfigureOptions <MvcViewOptions>, MvcRazorMvcViewOptionsSetup>()); services.TryAddEnumerable( ServiceDescriptor.Transient <IConfigureOptions <RazorViewEngineOptions>, RazorViewEngineOptionsSetup>()); services.TryAddSingleton < IRazorViewEngineFileProviderAccessor, DefaultRazorViewEngineFileProviderAccessor>(); services.TryAddSingleton <IRazorViewEngine, RazorViewEngine>(); services.TryAddSingleton <IViewCompilerProvider, RazorViewCompilerProvider>(); // In the default scenario the following services are singleton by virtue of being initialized as part of // creating the singleton RazorViewEngine instance. services.TryAddTransient <IRazorPageFactoryProvider, DefaultRazorPageFactoryProvider>(); // // Razor compilation infrastructure // services.TryAddSingleton <RazorProject, FileProviderRazorProject>(); services.TryAddSingleton <RazorTemplateEngine, MvcRazorTemplateEngine>(); services.TryAddSingleton <LazyMetadataReferenceFeature>(); services.TryAddSingleton(s => { return(RazorEngine.Create(b => { RazorExtensions.Register(b); // Roslyn + TagHelpers infrastructure var metadataReferenceFeature = s.GetRequiredService <LazyMetadataReferenceFeature>(); b.Features.Add(metadataReferenceFeature); b.Features.Add(new Microsoft.CodeAnalysis.Razor.CompilationTagHelperFeature()); // TagHelperDescriptorProviders (actually do tag helper discovery) b.Features.Add(new Microsoft.CodeAnalysis.Razor.DefaultTagHelperDescriptorProvider()); b.Features.Add(new ViewComponentTagHelperDescriptorProvider()); })); }); // This caches Razor page activation details that are valid for the lifetime of the application. services.TryAddSingleton <IRazorPageActivator, RazorPageActivator>(); // Only want one ITagHelperActivator so it can cache Type activation information. Types won't conflict. services.TryAddSingleton <ITagHelperActivator, DefaultTagHelperActivator>(); services.TryAddSingleton <ITagHelperFactory, DefaultTagHelperFactory>(); // TagHelperComponents manager services.TryAddScoped <ITagHelperComponentManager, TagHelperComponentManager>(); // Consumed by the Cache tag helper to cache results across the lifetime of the application. services.TryAddSingleton <IMemoryCache, MemoryCache>(); }
public async Task <TemplateResult> RunTemplateAsync(string content, dynamic templateModel) { // Don't care about the RazorProject as we already have the content of the .cshtml file // and don't need to deal with imports. var fileSystem = RazorProjectFileSystem.Create(Directory.GetCurrentDirectory()); var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, (builder) => { RazorExtensions.Register(builder); builder.AddDefaultImports(@" @using System @using System.Threading.Tasks "); }); var templateItem = new TemplateRazorProjectItem(content); var codeDocument = projectEngine.Process(templateItem); var generatorResults = codeDocument.GetCSharpDocument(); if (generatorResults.Diagnostics.Any()) { var messages = generatorResults.Diagnostics.Select(d => d.GetMessage()); return(new TemplateResult() { GeneratedText = string.Empty, ProcessingException = new TemplateProcessingException(messages, generatorResults.GeneratedCode) }); } var templateResult = _compilationService.Compile(generatorResults.GeneratedCode); if (templateResult.Messages.Any()) { return(new TemplateResult() { GeneratedText = string.Empty, ProcessingException = new TemplateProcessingException(templateResult.Messages, generatorResults.GeneratedCode) }); } var compiledObject = Activator.CreateInstance(templateResult.CompiledType); var razorTemplate = compiledObject as RazorTemplateBase; string result = String.Empty; if (razorTemplate != null) { razorTemplate.Model = templateModel; //ToDo: If there are errors executing the code, they are missed here. result = await razorTemplate.ExecuteTemplate(); } return(new TemplateResult() { GeneratedText = result, ProcessingException = null }); }
private static (RazorCodeDocument, DocumentSnapshot) CreateCodeDocumentAndSnapshot(SourceText text, string path, IReadOnlyList <TagHelperDescriptor>?tagHelpers = null, string?fileKind = default, bool allowDiagnostics = false) { fileKind ??= FileKinds.Component; tagHelpers ??= Array.Empty <TagHelperDescriptor>(); if (fileKind == FileKinds.Component) { tagHelpers = tagHelpers.Concat(s_defaultComponents).ToArray(); } var sourceDocument = text.GetRazorSourceDocument(path, path); // Yes I know "BlazorServer_31 is weird, but thats what is in the taghelpers.json file const string DefaultImports = @" @using BlazorServer_31 @using BlazorServer_31.Pages @using BlazorServer_31.Shared @using Microsoft.AspNetCore.Components @using Microsoft.AspNetCore.Components.Authorization @using Microsoft.AspNetCore.Components.Routing @using Microsoft.AspNetCore.Components.Web "; var importsPath = new Uri("file:///path/to/_Imports.razor").AbsolutePath; var importsSourceText = SourceText.From(DefaultImports); var importsDocument = importsSourceText.GetRazorSourceDocument(importsPath, importsPath); var importsSnapshot = new Mock <DocumentSnapshot>(MockBehavior.Strict); importsSnapshot.Setup(d => d.GetTextAsync()).Returns(Task.FromResult(importsSourceText)); importsSnapshot.Setup(d => d.FilePath).Returns(importsPath); importsSnapshot.Setup(d => d.TargetPath).Returns(importsPath); var projectEngine = RazorProjectEngine.Create(builder => { builder.SetRootNamespace("Test"); builder.Features.Add(new DefaultTypeNameFeature()); RazorExtensions.Register(builder); }); var codeDocument = projectEngine.ProcessDesignTime(sourceDocument, fileKind, new[] { importsDocument }, tagHelpers); if (!allowDiagnostics) { Assert.False(codeDocument.GetCSharpDocument().Diagnostics.Any(), "Error creating document:" + Environment.NewLine + string.Join(Environment.NewLine, codeDocument.GetCSharpDocument().Diagnostics)); } var documentSnapshot = new Mock <DocumentSnapshot>(MockBehavior.Strict); documentSnapshot.Setup(d => d.GetGeneratedOutputAsync()).Returns(Task.FromResult(codeDocument)); documentSnapshot.Setup(d => d.GetImports()).Returns(new[] { importsSnapshot.Object }); documentSnapshot.Setup(d => d.Project.GetProjectEngine()).Returns(projectEngine); documentSnapshot.Setup(d => d.FilePath).Returns(path); documentSnapshot.Setup(d => d.TargetPath).Returns(path); documentSnapshot.Setup(d => d.Project.TagHelpers).Returns(tagHelpers); documentSnapshot.Setup(d => d.FileKind).Returns(fileKind); return(codeDocument, documentSnapshot.Object); }
public void Execute(GeneratorExecutionContext context) { var _razorContext = new RazorSourceGenerationContext(context); if (_razorContext is null) { context.ReportDiagnostic(Diagnostic.Create(RazorDiagnostics.InvalidRazorContextComputedDescriptor, Location.None)); return; } if (_razorContext.RazorFiles.Count == 0 && _razorContext.CshtmlFiles.Count == 0) { return; } if (_razorContext.SuppressRazorSourceGenerator) { return; } HandleDebugSwitch(_razorContext.WaitForDebugger); var tagHelpers = ResolveTagHelperDescriptors(context, _razorContext); AssertOrFailFast(tagHelpers.Count == 0, "No tag helpers resolved."); var projectEngine = RazorProjectEngine.Create(_razorContext.Configuration, _razorContext.FileSystem, b => { b.Features.Add(new DefaultTypeNameFeature()); b.SetRootNamespace(_razorContext.RootNamespace); b.Features.Add(new ConfigureRazorCodeGenerationOptions(options => { options.SuppressMetadataSourceChecksumAttributes = !_razorContext.GenerateMetadataSourceChecksumAttributes; })); b.Features.Add(new StaticTagHelperFeature { TagHelpers = tagHelpers, }); b.Features.Add(new DefaultTagHelperDescriptorProvider()); CompilerFeatures.Register(b); RazorExtensions.Register(b); b.SetCSharpLanguageVersion(((CSharpParseOptions)context.ParseOptions).LanguageVersion); }); if (_razorContext.CshtmlFiles.Count != 0) { context.AddSource($"{context.Compilation.AssemblyName}.UnifiedAssembly.Info.g.cs", ProvideApplicationPartFactoryAttributeSourceText); } RazorGenerateForSourceTexts(_razorContext.CshtmlFiles, context, projectEngine); RazorGenerateForSourceTexts(_razorContext.RazorFiles, context, projectEngine); }
public IHttpActionResult SpgatewayNotify() { // 取法同SpgatewayResult var httpRequestBase = new HttpRequestWrapper(HttpContext.Current.Request); RazorExtensions.LogFormData(httpRequestBase, "SpgatewayNotify(支付完成)"); // Status 回傳狀態 // MerchantID 回傳訊息 // TradeInfo 交易資料AES 加密 // TradeSha 交易資料SHA256 加密 // Version 串接程式版本 NameValueCollection collection = HttpContext.Current.Request.Form; if (collection["MerchantID"] != null && string.Equals(collection["MerchantID"], _bankInfoModel.MerchantID) && collection["TradeInfo"] != null && string.Equals(collection["TradeSha"], CryptoUtil.EncryptSHA256($"HashKey={_bankInfoModel.HashKey}&{collection["TradeInfo"]}&HashIV={_bankInfoModel.HashIV}"))) { var decryptTradeInfo = CryptoUtil.DecryptAESHex(collection["TradeInfo"], _bankInfoModel.HashKey, _bankInfoModel.HashIV); // 取得回傳參數(ex:key1=value1&key2=value2),儲存為NameValueCollection NameValueCollection decryptTradeCollection = HttpUtility.ParseQueryString(decryptTradeInfo); SpgatewayOutputDataModel convertModel = LambdaUtil.DictionaryToObject <SpgatewayOutputDataModel>(decryptTradeCollection.AllKeys.ToDictionary(k => k, k => decryptTradeCollection[k])); //LogUtil.WriteLog(JsonConvert.SerializeObject(convertModel)); // TODO 將回傳訊息寫入資料庫 VipOrder pay = db.VipOrders.Find(Convert.ToInt32(convertModel.MerchantOrderNo)); pay.Message = convertModel.Message; pay.Status = convertModel.Status; db.VipOrders.Add(pay); // return Content(JsonConvert.SerializeObject(convertModel)); if (pay.Status == "SUCCESS") { //MerchantOrderNo = "O202009100034" //convertModel.MerchantOrderNo VipOrder vip = db.VipOrders.Find(pay.BrandId); vip.Status = "已付款成功"; db.Entry(vip).State = EntityState.Modified; db.SaveChanges(); } else//付款失敗 { } return(Ok()); } else { //LogUtil.WriteLog("MerchantID/TradeSha驗證錯誤"); } return(Ok()); }
// Internal for testing. internal static void AddServices(IServiceCollection services) { services.TryAddEnumerable( ServiceDescriptor.Transient <IConfigureOptions <MvcRazorRuntimeCompilationOptions>, MvcRazorRuntimeCompilationOptionsSetup>()); var compilerProvider = services.FirstOrDefault(f => f.ServiceType == typeof(IViewCompilerProvider) && f.ImplementationType?.Assembly == typeof(IViewCompilerProvider).Assembly && f.ImplementationType.FullName == "Microsoft.AspNetCore.Mvc.Razor.Compilation.DefaultViewCompilerProvider"); if (compilerProvider != null) { // Replace the default implementation of IViewCompilerProvider services.Remove(compilerProvider); } services.TryAddSingleton <IViewCompilerProvider, RuntimeViewCompilerProvider>(); services.TryAddSingleton <RuntimeCompilationFileProvider>(); services.TryAddSingleton <RazorReferenceManager>(); services.TryAddSingleton <CSharpCompiler>(); services.TryAddSingleton <RazorProjectFileSystem, FileProviderRazorProjectFileSystem>(); services.TryAddSingleton(s => { var fileSystem = s.GetRequiredService <RazorProjectFileSystem>(); var csharpCompiler = s.GetRequiredService <CSharpCompiler>(); var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, builder => { RazorExtensions.Register(builder); // Roslyn + TagHelpers infrastructure var referenceManager = s.GetRequiredService <RazorReferenceManager>(); builder.Features.Add(new LazyMetadataReferenceFeature(referenceManager)); builder.Features.Add(new CompilationTagHelperFeature()); // TagHelperDescriptorProviders (actually do tag helper discovery) builder.Features.Add(new DefaultTagHelperDescriptorProvider()); builder.Features.Add(new ViewComponentTagHelperDescriptorProvider()); builder.SetCSharpLanguageVersion(csharpCompiler.ParseOptions.LanguageVersion); }); return(projectEngine); }); // // Razor Pages // services.TryAddEnumerable( ServiceDescriptor.Singleton <IPageRouteModelProvider, RazorProjectPageRouteModelProvider>()); services.TryAddEnumerable( ServiceDescriptor.Singleton <IActionDescriptorChangeProvider, PageActionDescriptorChangeProvider>()); }
protected RazorEngine CreateRuntimeEngine(CSharpCompilation compilation) { var references = compilation.References.Concat(new[] { compilation.ToMetadataReference() }); return(RazorEngine.Create(b => { RazorExtensions.Register(b); b.Features.Add(GetMetadataReferenceFeature(references)); b.Features.Add(new CompilationTagHelperFeature()); })); }
private int ExecuteCore( string projectDirectory, string tagHelperManifest, List <string> sources, List <string> outputs, List <string> relativePaths) { tagHelperManifest = Path.Combine(projectDirectory, tagHelperManifest); var tagHelpers = GetTagHelpers(tagHelperManifest); var engine = RazorEngine.Create(b => { RazorExtensions.Register(b); b.Features.Add(new StaticTagHelperFeature() { TagHelpers = tagHelpers, }); }); var inputItems = GetInputItems(projectDirectory, sources, outputs, relativePaths); var compositeProject = new CompositeRazorProjectFileSystem( new[] { GetVirtualRazorProjectSystem(inputItems), RazorProjectFileSystem.Create(projectDirectory), }); var templateEngine = new MvcRazorTemplateEngine(engine, compositeProject); var results = GenerateCode(templateEngine, inputItems); var success = true; foreach (var result in results) { if (result.CSharpDocument.Diagnostics.Count > 0) { success = false; foreach (var error in result.CSharpDocument.Diagnostics) { Console.Error.WriteLine(error.ToString()); } } var outputFilePath = result.InputItem.OutputPath; File.WriteAllText(outputFilePath, result.CSharpDocument.GeneratedCode); } return(success ? 0 : -1); }
public virtual async Task <System.IO.Stream> Login(LoginViewModel model, SignInMessage message) { var client = await clientStore.FindClientByIdAsync(message.ClientId); var name = client != null ? client.ClientName : null; // return await Render(model, "login", name); model.ClientName = name; var stream = StringToStream(RazorExtensions.RenderCustomView("login", "home", model)); return(stream); }
private int ExecuteCore(string projectDirectory, string outputFilePath, string[] assemblies) { outputFilePath = Path.Combine(projectDirectory, outputFilePath); var metadataReferences = new MetadataReference[assemblies.Length]; for (var i = 0; i < assemblies.Length; i++) { metadataReferences[i] = MetadataReference.CreateFromFile(assemblies[i]); } var engine = RazorEngine.Create((b) => { RazorExtensions.Register(b); b.Features.Add(new DefaultMetadataReferenceFeature() { References = metadataReferences }); b.Features.Add(new CompilationTagHelperFeature()); // TagHelperDescriptorProviders (actually do tag helper discovery) b.Features.Add(new DefaultTagHelperDescriptorProvider()); b.Features.Add(new ViewComponentTagHelperDescriptorProvider()); }); var feature = engine.Features.OfType <ITagHelperFeature>().Single(); var tagHelpers = feature.GetDescriptors(); using (var stream = new MemoryStream()) { Serialize(stream, tagHelpers); stream.Position = 0L; var newHash = Hash(stream); var existingHash = Hash(outputFilePath); if (!HashesEqual(newHash, existingHash)) { stream.Position = 0; using (var output = File.OpenWrite(outputFilePath)) { stream.CopyTo(output); } } } return(0); }
protected RazorProjectEngine CreateEngine(CSharpCompilation compilation) { var references = compilation.References.Concat(new[] { compilation.ToMetadataReference() }); return(CreateProjectEngine(b => { RazorExtensions.Register(b); var existingImportFeature = b.Features.OfType <IImportProjectFeature>().Single(); b.SetImportFeature(new NormalizedDefaultImportFeature(existingImportFeature)); b.Features.Add(GetMetadataReferenceFeature(references)); b.Features.Add(new CompilationTagHelperFeature()); })); }
public override void Initialize(RazorProjectEngineBuilder builder) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } if (builder.Configuration.ConfigurationName == "MVC-1.0") { RazorExtensions.Register(builder); } else if (builder.Configuration.ConfigurationName == "MVC-1.1") { RazorExtensions.Register(builder); RazorExtensions.RegisterViewComponentTagHelpers(builder); } }
private static RazorProjectEngine CreateProjectEngine( IEnumerable <TagHelperDescriptor> tagHelpers = null) { var fileSystem = new TestRazorProjectFileSystem(); var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, builder => { RazorExtensions.Register(builder); builder.AddDefaultImports("@addTagHelper *, Test"); if (tagHelpers != null) { builder.AddTagHelpers(tagHelpers); } }); return(projectEngine); }
private static RazorProjectEngine GetDiscoveryProjectEngine( IReadOnlyList <MetadataReference> references, StaticCompilationTagHelperFeature tagHelperFeature) { var discoveryProjectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, new VirtualRazorProjectFileSystem(), b => { b.Features.Add(new DefaultMetadataReferenceFeature { References = references }); b.Features.Add(tagHelperFeature); b.Features.Add(new DefaultTagHelperDescriptorProvider()); CompilerFeatures.Register(b); RazorExtensions.Register(b); }); return(discoveryProjectEngine); }
protected RazorEngine CreateRuntimeEngine(IEnumerable <MetadataReference> references) { return(RazorEngine.Create(b => { RazorExtensions.Register(b); b.Features.Add(GetMetadataReferenceFeature(references)); b.Features.Add(new CompilationTagHelperFeature()); b.Features.Add(new DefaultTagHelperDescriptorProvider() { DesignTime = true }); b.Features.Add(new ViewComponentTagHelperDescriptorProvider() { ForceEnabled = true }); })); }
private static RazorProjectEngine CreateProjectEngine( string path = "C:\\This\\Path\\Is\\Just\\For\\Line\\Pragmas.cshtml", IEnumerable <TagHelperDescriptor> tagHelpers = null) { var fileSystem = new TestRazorProjectFileSystem(); var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, builder => { RazorExtensions.Register(builder); builder.AddDefaultImports("@addTagHelper *, Test"); if (tagHelpers != null) { builder.AddTagHelpers(tagHelpers); } }); return(projectEngine); }
private static RazorProjectEngine GetEngine() { var options = Options.Create(new MvcRazorRuntimeCompilationOptions { FileProviders = { new TestFileProvider() } }); var compilationFileProvider = new PublicRuntimeCompilationFileProvider(options); var referenceManager = CreateReferenceManager(); var precompiledViews = Array.Empty <CompiledViewDescriptor>(); var hostingEnvironment = Mock.Of <IWebHostEnvironment>(e => e.ContentRootPath == "BasePath"); var fileSystem = new PublicFileProviderRazorProjectFileSystem(compilationFileProvider); var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, builder => { RazorExtensions.Register(builder); }); return(projectEngine); }