private static void mapStorage(IApplicationBuilder appBuilder)
{
var manifestEmbeddedProvider =
new ManifestEmbeddedFileProvider(Assembly.GetExecutingAssembly());
appBuilder.Map("/blocklyStorage", app =>
{
app.Run(async cnt =>
{
string nameFile = "extensions/SaveToLocalStorage.js";
IFileInfo f = new PhysicalFileInfo(new FileInfo("wwwroot/" + nameFile));
if (!f.Exists)
{
f = manifestEmbeddedProvider.GetFileInfo("blocklyFiles/" + nameFile);
}
//TODO: add corect mime type for js files
using var stream = new MemoryStream();
using var cs = f.CreateReadStream();
byte[] buffer = new byte[2048]; // read in chunks of 2KB
int bytesRead;
while ((bytesRead = cs.Read(buffer, 0, buffer.Length)) > 0)
{
stream.Write(buffer, 0, bytesRead);
}
byte[] result = stream.ToArray();
// TODO: do something with the result
var m = new Memory <byte>(result);
await cnt.Response.BodyWriter.WriteAsync(m);
});
});
}
private static void UseFileServer(this IApplicationBuilder app, QuartzminOptions options)
{
IFileProvider fs;
if (string.IsNullOrEmpty(options.ContentRootDirectory))
{
fs = new ManifestEmbeddedFileProvider(Assembly.GetExecutingAssembly(), "Content");
}
else
{
fs = new PhysicalFileProvider(options.ContentRootDirectory);
}
var fsOptions = new FileServerOptions()
{
#if NETCOREAPP
RequestPath = new PathString("/Quartzmin/Content"),
#else
RequestPath = new PathString("/Content"),
#endif
EnableDefaultFiles = false,
EnableDirectoryBrowsing = false,
FileProvider = fs
};
app.UseFileServer(fsOptions);
}
public static void UseBlocklyUI(this IApplicationBuilder appBuilder, IWebHostEnvironment environment)
{
if (FileProvider == null)
{
var manifestEmbeddedProvider =
new ManifestEmbeddedFileProvider(Assembly.GetExecutingAssembly());
var service = appBuilder.ApplicationServices;
FileProvider = manifestEmbeddedProvider;
if (environment != null)
{
var originalProvider = environment.ContentRootFileProvider;
var pRoot = originalProvider as PhysicalFileProvider;
if (pRoot != null)
{
//try to add wwwroot for standalone
string wwwrootFolder = Path.Combine(pRoot.Root, "wwwroot");
if (Directory.Exists(wwwrootFolder))
{
pRoot = new PhysicalFileProvider(wwwrootFolder);
}
FileProvider =
new CompositeFileProvider(pRoot, manifestEmbeddedProvider);
}
else if (originalProvider != null)
{
FileProvider =
new CompositeFileProvider(originalProvider, manifestEmbeddedProvider);
}
}
}
mapFile("BlocklyAutomation", FileProvider, appBuilder);
}
/// <summary>
/// Uses the cli.
/// </summary>
/// <param name="appBuilder">The application builder.</param>
public static void UseBlocklyUI(this IApplicationBuilder appBuilder)
{
var manifestEmbeddedProvider =
new ManifestEmbeddedFileProvider(Assembly.GetExecutingAssembly());
mapFile("blocklyFiles", manifestEmbeddedProvider, appBuilder);
}
/// <summary>提交配置</summary>
/// <param name="name"></param>
/// <param name="options"></param>
public void PostConfigure(String name, StaticFileOptions options)
{
if (name.IsNullOrEmpty())
{
throw new ArgumentException(nameof(name));
}
if (options == null)
{
throw new ArgumentException(nameof(options));
}
// 如果没有被其他组件初始化，在这里初始化
options.ContentTypeProvider ??= new FileExtensionContentTypeProvider();
if (options.FileProvider == null && Environment.ContentRootFileProvider == null)
{
throw new InvalidOperationException("缺少FileProvider");
}
options.FileProvider ??= Environment.ContentRootFileProvider;
// 添加我们的文件提供者
// 第二个参数指定开始查找的文件夹，比如文件都放在wwwroot，就填“wwwroot”
var filesProvider = new ManifestEmbeddedFileProvider(GetType().Assembly, Setting.Current.WebRootPath);
options.FileProvider = new CompositeFileProvider(options.FileProvider, filesProvider);
}
public void GetDirectoryContents_CanEnumerateExistingFolders()
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.Directory("wwwroot",
TestEntry.File("jquery.validate.js"),
TestEntry.File("jquery.min.js"),
TestEntry.File("site.css"))));
var provider = new ManifestEmbeddedFileProvider(assembly);
var expectedContents = new[]
{
CreateTestFileInfo("jquery.validate.js"),
CreateTestFileInfo("jquery.min.js"),
CreateTestFileInfo("site.css")
};
// Act
var contents = provider.GetDirectoryContents("wwwroot").ToArray();
// Assert
Assert.Equal(expectedContents, contents, FileInfoComparer.Instance);
}
/// <summary>
/// Uses the cli.
/// </summary>
/// <param name="appBuilder">The application builder.</param>
/// <param name="options">The application builder.</param>
public static void UseBlocklyUI(this IApplicationBuilder appBuilder, BlocklyUIOptions options = null)
{
var manifestEmbeddedProvider =
new ManifestEmbeddedFileProvider(Assembly.GetExecutingAssembly());
var service = appBuilder.ApplicationServices;
mapFile("blocklyFiles", manifestEmbeddedProvider, appBuilder);
#region map options
options = options ?? new BlocklyUIOptions();
appBuilder.Map("/BlocklyOptions", app =>
{
app.Run(async cnt =>
{
var data = options.StartBlocks?.Replace("`", @"\`");
var str = $"var startBlocksStr=`{data}`;";
data = options.HeaderName?.Replace("`", @"\`");
str += $"{Environment.NewLine}var optHeaderName = `{data}`;";
data = options.CustomBlocks?.Replace("`", @"\`");
str += $"{Environment.NewLine}var customBlocks = `{data}`;";
str += $"{Environment.NewLine}{options.RunTimeString?.Invoke(service)};";
var result = Encoding.UTF8.GetBytes(str);
var m = new Memory <byte>(result);
await cnt.Response.BodyWriter.WriteAsync(m);
});
});
#endregion
}
/// <summary>
/// Enables static file serving using the resource assembly that contains static web resources for the
/// web portion of the application. The resources must be embedded in an assembly that directly
/// references the <c>Microsoft.Extensions.FileProviders.Embedded</c> NuGet package and specifies
/// <c><GenerateEmbeddedFilesManifest>true</GenerateEmbeddedFilesManifest></c>
/// in the project settings.
/// </summary>
/// <param name="hostBuilder">The <see cref="IHostBuilder"/> to configure.</param>
/// <param name="resourceAssembly">An assembly that contains static web assets as embedded resources.</param>
public static IHostBuilder UseResourceAssembly(this IHostBuilder hostBuilder, Assembly resourceAssembly)
{
if (hostBuilder is null)
{
throw new ArgumentNullException(nameof(hostBuilder));
}
IFileProvider rootProvider = null;
hostBuilder.ConfigureAppConfiguration((hostBuilderContext, configurationBuilder) =>
{
if (!configurationBuilder.Properties.TryGetValue(BlazorHybridDefaults.WebRootKey, out object webRoot))
{
throw new KeyNotFoundException("WebRoot not set.");
}
rootProvider = new ManifestEmbeddedFileProvider(resourceAssembly, (string)webRoot);
configurationBuilder.Properties[BlazorHybridDefaults.WebRootFileProvider] = rootProvider;
});
return(hostBuilder.ConfigureServices(serviceCollection =>
{
serviceCollection.AddSingleton <IFileProvider>(rootProvider);
}));
}
public override void OnApplicationInitialization(CafApplicationContext context)
{
context.ServiceProvider.GetService <SchedulerCenter>()?.Init();//初始化Job
var app = context.ServiceProvider.GetRequiredService <ObjectWrapper <IApplicationBuilder> >().Value;
app.Use(async(context, next) =>
{
if (context.Request.Path.Value.ToLower().StartsWith("/jobui"))
{
context.Request.Path = "/index.html";
await next();
}
else
{
await next();
}
});
var manifestEmbeddedProvider =
new ManifestEmbeddedFileProvider(typeof(CafJobModule).Assembly, "UI");
app.UseStaticFiles(new StaticFileOptions
{
FileProvider = manifestEmbeddedProvider
});
}
private void StartWebViewCoreIfPossible()
{
if (!RequiredStartupPropertiesSet ||
_webviewManager != null)
{
return;
}
if (NativeView == null)
{
throw new InvalidOperationException($"Can't start {nameof(BlazorWebView)} without native web view instance.");
}
var assetConfig = Services !.GetRequiredService <BlazorAssetsAssemblyConfiguration>() !;
// We assume the host page is always in the root of the content directory, because it's
// unclear there's any other use case. We can add more options later if so.
var contentRootDir = Path.GetDirectoryName(HostPage !) ?? string.Empty;
var hostPageRelativePath = Path.GetRelativePath(contentRootDir, HostPage !);
var fileProvider = new ManifestEmbeddedFileProvider(assetConfig.AssetsAssembly, root: contentRootDir);
_webviewManager = new WebView2WebViewManager(new WinUIWebView2Wrapper(NativeView), Services !, MauiDispatcher.Instance, fileProvider, hostPageRelativePath);
if (RootComponents != null)
{
foreach (var rootComponent in RootComponents)
{
// Since the page isn't loaded yet, this will always complete synchronously
_ = rootComponent.AddToWebViewManagerAsync(_webviewManager);
}
}
_webviewManager.Navigate("/");
}
private static void AddModuleWebAsset(this IMvcBuilder mvcBuilder, string moduleAssemblyFileName = @"*.Services.dll")
{
#region Contracts
if (mvcBuilder == null)
{
throw new ArgumentException(nameof(mvcBuilder));
}
if (string.IsNullOrEmpty(moduleAssemblyFileName) == true)
{
throw new ArgumentException(nameof(moduleAssemblyFileName));
}
#endregion
// ModuleAssembly
var moduleAssemblyList = CLK.Reflection.Assembly.GetAllAssembly(moduleAssemblyFileName);
if (moduleAssemblyList == null)
{
throw new InvalidOperationException($"{nameof(moduleAssemblyList)}=null");
}
// FileProviderList
var fileProviderList = new List <IFileProvider>();
foreach (var moduleAssembly in moduleAssemblyList)
{
// FileProvider
IFileProvider fileProvider = null;
try
{
fileProvider = new ManifestEmbeddedFileProvider(moduleAssembly, @"wwwroot");
}
catch
{
fileProvider = null;
}
// Add
if (fileProvider != null)
{
fileProviderList.Add(fileProvider);
}
}
// Add
mvcBuilder.Services.AddOptions <StaticFileOptions>().Configure <IWebHostEnvironment>((options, hostEnvironment) =>
{
// FileProvider
if (hostEnvironment.WebRootFileProvider != null)
{
fileProviderList.Insert(0, hostEnvironment.WebRootFileProvider);
}
// Attach
options.FileProvider = new CompositeFileProvider
(
fileProviderList
);
});
}
/// <summary>
/// Enable the KafkaFlow dashboard
/// </summary>
/// <param name="app">Instance of <see cref="IApplicationBuilder"/></param>
/// <returns></returns>
public static IApplicationBuilder UseKafkaFlowDashboard(this IApplicationBuilder app)
{
app.Map(
"/kafka-flow",
builder =>
{
var provider = new ManifestEmbeddedFileProvider(
Assembly.GetAssembly(typeof(ApplicationBuilderExtensions)),
"ClientApp/dist");
builder.UseStaticFiles(new StaticFileOptions {
FileProvider = provider
});
builder.Run(
async context =>
{
if (context.Request.Path == "/" || context.Request.Path == string.Empty)
{
await context.Response.SendFileAsync(provider.GetFileInfo("index.html"));
}
});
});
return(app);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
//
//ManifestEmbeddedFileProvider
//IFileProvider fileProvider = new EmbeddedFileProvider(Assembly.GetEntryAssembly());
IFileProvider fileProvider = new ManifestEmbeddedFileProvider(Assembly.GetEntryAssembly());
app.UseStaticFiles(new StaticFileOptions {
FileProvider = fileProvider
});
app.UseCookiePolicy();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
private static void mapStorage(IApplicationBuilder appBuilder)
{
var manifestEmbeddedProvider =
new ManifestEmbeddedFileProvider(Assembly.GetExecutingAssembly());
appBuilder.Map("/blocklyStorage", app =>
{
app.Run(async cnt =>
{
cnt.Response.ContentType = "application/javascript";
string nameFile = "extensions/SaveToSqliteStorage.js";
var f = manifestEmbeddedProvider.GetFileInfo("blocklyFiles/" + nameFile);
using var stream = new MemoryStream();
using var cs = f.CreateReadStream();
byte[] buffer = new byte[2048]; // read in chunks of 2KB
int bytesRead;
while ((bytesRead = cs.Read(buffer, 0, buffer.Length)) > 0)
{
stream.Write(buffer, 0, bytesRead);
}
byte[] result = stream.ToArray();
var m = new ReadOnlyMemory <byte>(result);
await cnt.Response.BodyWriter.WriteAsync(m);
});
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.AddDbContext <ArchivesDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
services.AddScoped <IMediaRecordCommentsRepository, MediaRecordCommentsRepository>();
services.AddScoped <IOrderRepository, OrderRepository>();
//services.AddArchiveWebSitesCoreLibrary();
services.AddScoped <ShoppingCart>(sp => ShoppingCart.GetCart(sp));
services.AddHttpContextAccessor();
services.AddSession(opts =>
{
opts.Cookie.IsEssential = true; // make the session cookie Essential
});
var coreAssembly = AppDomain.CurrentDomain.GetAssemblies()
.SingleOrDefault(assembly => assembly.GetName().Name == "CE.ArchiveWebSites.Core");
var filesProvider = new ManifestEmbeddedFileProvider(coreAssembly);
services.AddControllersWithViews()
.AddApplicationPart(coreAssembly);
}
private static ImmutableList <QuestionModel> Init()
{
var cfg = new Configuration()
{
Encoding = Encoding.UTF8,
HasHeaderRecord = false,
Delimiter = ",",
Quote = '"',
};
var qm = new List <QuestionModel>();
var id = 1;
var fp = new ManifestEmbeddedFileProvider(typeof(StaticQuestionFactory).Assembly);
var fi = fp.GetFileInfo("questions.csv");
using (var fs = fi.CreateReadStream())
using (var sr = new StreamReader(fs, cfg.Encoding)) {
var cr = new CsvReader(sr, cfg);
while (cr.Read())
{
qm.Add(new QuestionModel {
Id = id++,
Question = cr.GetField <string>(0),
YesConclusion = cr.GetField <string>(1),
NoConclusion = cr.GetField <string>(2),
});
}
}
return(qm.ToImmutableList());
}
private IActionResult GetFile(string fileName, string downloadName = null, string contentType = null)
{
var fp = new ManifestEmbeddedFileProvider(typeof(StaticQuestionFactory).Assembly);
var fi = fp.GetFileInfo(fileName);
var stream = fi.CreateReadStream();
return(File(stream, contentType ?? "application/vnd.android.package-archive", downloadName ?? fileName));
}
private static WebApplication BuildWebApplication(
Application application,
string[] args,
ILogEventSink?sink)
{
var builder = WebApplication.CreateBuilder(args);
// Logging for this application
builder.Host.UseSerilog((context, configuration) =>
{
configuration
.MinimumLevel.Verbose()
.Filter.ByExcluding(Matching.FromSource("Microsoft.AspNetCore"))
.Filter.ByExcluding(Matching.FromSource("Microsoft.Extensions"))
.Filter.ByExcluding(Matching.FromSource("Microsoft.Hosting"))
.Enrich
.FromLogContext()
.WriteTo
.Console();
if (sink is object)
{
configuration.WriteTo.Sink(sink, LogEventLevel.Verbose);
}
});
builder.Services.AddRazorPages(o => o.RootDirectory = "/Dashboard/Pages");
builder.Services.AddServerSideBlazor();
builder.Services.AddOptions <StaticFileOptions>()
.PostConfigure(o =>
{
var fileProvider = new ManifestEmbeddedFileProvider(typeof(TyeHost).Assembly, "wwwroot");
// Make sure we don't remove the existing file providers (blazor needs this)
o.FileProvider = new CompositeFileProvider(o.FileProvider, fileProvider);
});
builder.Services.AddCors(
options =>
{
options.AddPolicy(
"default",
policy =>
{
policy
.AllowAnyOrigin()
.AllowAnyHeader()
.AllowAnyMethod();
});
});
builder.Services.AddSingleton(application);
var app = builder.Build();
return(app);
}
public static IFileInfo GetFileInfo(Assembly assembly, string fileName)
{
var manifestEmbeddedProvider =
new ManifestEmbeddedFileProvider(assembly);
var fileInfo = manifestEmbeddedProvider.GetFileInfo(fileName);
return(fileInfo);
}
/// <summary>
/// Used to create <see cref="StaticFileOptions"/> for serving Gemstone.Web embedded javascript and css stylesheets.
/// </summary>
/// <returns><see cref="StaticFileOptions"/></returns>
public static StaticFileOptions StaticFileEmbeddedResources()
{
ManifestEmbeddedFileProvider embeddedFileProvider = new ManifestEmbeddedFileProvider(Assembly.GetExecutingAssembly(), "Shared");
return(new StaticFileOptions()
{
FileProvider = embeddedFileProvider,
RequestPath = new PathString("/@Gemstone")
});
}
public static IConfigurationBuilder AddTestConfigurationSources(this IConfigurationBuilder builder)
{
var fileProvider = new ManifestEmbeddedFileProvider(typeof(ConfigurationBuilderExtensions).Assembly);
builder
.AddJsonFile(fileProvider, "appsettings.Testing.json", optional: false, reloadOnChange: false)
.AddUserSecrets(typeof(ConfigurationBuilderExtensions).Assembly)
.AddEnvironmentVariables();
return(builder);
}
private void SaveEmbeddedFilesToTempFolder(params string[] embeddedFileNames)
{
var executingAssembly = Assembly.GetExecutingAssembly();
var embeddedFileProvider = new ManifestEmbeddedFileProvider(executingAssembly);
foreach (var embeddedFileName in embeddedFileNames)
{
using var reader = embeddedFileProvider.GetFileInfo(embeddedFileName).CreateReadStream();
using var writer = new StreamWriter(Path.Combine(CollectionFolder, Path.GetFileName(embeddedFileName)));
reader.CopyTo(writer.BaseStream);
}
}
public void PostConfigure(string name, StaticFileOptions options)
{
options.ContentTypeProvider = options.ContentTypeProvider ?? new FileExtensionContentTypeProvider();
if (options.FileProvider == null && _environment.WebRootFileProvider == null)
{
throw new InvalidOperationException("Missing FileProvider.");
}
options.FileProvider = options.FileProvider ?? _environment.WebRootFileProvider;
var filesProvider = new ManifestEmbeddedFileProvider(GetType().Assembly, "pages");
options.FileProvider = new CompositeFileProvider(options.FileProvider, filesProvider);
}
// *******************************************************************
// Constructors.
// *******************************************************************
#region Constructors
/// <summary>
/// This constructor creates a new instance of the <see cref="ManifestEmbeddedFileProviderEx"/>
/// class.
/// </summary>
/// <param name="assembly">The assembly to use with the provider.</param>
public ManifestEmbeddedFileProviderEx(
Assembly assembly
)
{
// Validate the parameters before attempting to use them.
Guard.Instance().ThrowIfNull(assembly, nameof(assembly));
// Create the innder provider.
InnerProvider = new ManifestEmbeddedFileProvider(
assembly
);
}
public void PostConfigure(string name, StaticFileOptions options)
{
options.ContentTypeProvider = options.ContentTypeProvider ?? new FileExtensionContentTypeProvider();
if (options.FileProvider == null && _environment.WebRootFileProvider == null)
{
return;
}
options.FileProvider = options.FileProvider ?? _environment.WebRootFileProvider;
var filesProvider = new ManifestEmbeddedFileProvider(GetType().Assembly, "wwwroot");
options.FileProvider = new CompositeFileProvider(options.FileProvider, filesProvider);
}
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
#region snippet1
var physicalProvider = _env.ContentRootFileProvider;
var manifestEmbeddedProvider =
new ManifestEmbeddedFileProvider(Assembly.GetEntryAssembly());
var compositeProvider =
new CompositeFileProvider(physicalProvider, manifestEmbeddedProvider);
services.AddSingleton <IFileProvider>(compositeProvider);
#endregion
}
public void ConfigureServices(IServiceCollection services)
{
services.AddRazorPages();
#region snippet1
var physicalProvider = _env.ContentRootFileProvider;
var manifestEmbeddedProvider =
new ManifestEmbeddedFileProvider(typeof(Program).Assembly);
var compositeProvider =
new CompositeFileProvider(physicalProvider, manifestEmbeddedProvider);
services.AddSingleton <IFileProvider>(compositeProvider);
#endregion
}
public void PostConfigure(string name, StaticFileOptions options)
{
// Basic initialization in case the options weren't initialized by any other component
options.ContentTypeProvider = options.ContentTypeProvider ?? new FileExtensionContentTypeProvider();
if (options.FileProvider == null && _environment.WebRootFileProvider == null)
{
throw new InvalidOperationException("Missing FileProvider.");
}
options.FileProvider = options.FileProvider ?? _environment.WebRootFileProvider;
// Add our provider
var filesProvider = new ManifestEmbeddedFileProvider(GetType().Assembly, "wwwroot");
options.FileProvider = new CompositeFileProvider(options.FileProvider, filesProvider);
}
/// <summary>
/// Registers a <see cref="CompositeFileProvider"/> for each dynamically loaded assembly.
/// </summary>
void RegisterDynamicLibariesStaticFiles(IWebHostEnvironment env)
{
IFileProvider FileProvider;
foreach (Assembly A in _dynamicallyLoadedLibraries)
{
// create a "web root" file provider for the embedded static files found on wwwroot folder
FileProvider = new ManifestEmbeddedFileProvider(A, "wwwroot");
// register a new composite provider containing
// the old web root file provider
// and the new one we just created
env.WebRootFileProvider = new CompositeFileProvider(env.WebRootFileProvider, FileProvider);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddRazorPages();
services.AddServerSideBlazor();
services.AddBlazoredModal();
services.AddOptions <StaticFileOptions>()
.PostConfigure(o =>
{
var fileProvider = new ManifestEmbeddedFileProvider(typeof(Startup).Assembly, "wwwroot");
// Make sure we don't remove the existing file providers (blazor needs this)
o.FileProvider = new CompositeFileProvider(o.FileProvider, fileProvider);
});
}
