public ActionResult Index()
{
VirtualFileResult response = File("index.html", "text/html");
response.LastModified = DateTimeOffset.UtcNow;
return(response);
}
public async Task <FileResult> PayImage(string paymethod)
{
string fileName = string.Empty;
var configSection = _configuration.GetSection("SiteSettings:Payment");
if ("alipay".Equals(paymethod, StringComparison.InvariantCultureIgnoreCase))
{
string alipayBRCode = configSection.GetValue <string> ("alipayBRCode");
fileName = alipayBRCode;
logger.LogDebug($"alipayBRCode configured as: ${fileName}");
}
if ("wechatpay".Equals(paymethod, StringComparison.InvariantCultureIgnoreCase))
{
string wechatBRCode = configSection.GetValue <string> ("wechatBRCode");
fileName = wechatBRCode;
logger.LogDebug($"wechatBRCode configured as: ${fileName}");
}
string mimeType = "application/image";
new FileExtensionContentTypeProvider().TryGetContentType(fileName, out mimeType);
FileResult result = new VirtualFileResult(fileName, mimeType);
return(await Task.FromResult(result));
}
public void WithLastModified_GivenExpected_ShouldPass()
{
ActionResult result = new VirtualFileResult(string.Empty, TestContentType)
{
LastModified = TestLastModified
};
result.Should().BeVirtualFileResult().WithLastModified(TestLastModified);
}
public void WithEntityTag_GivenExpected_ShouldPass()
{
ActionResult result = new VirtualFileResult(string.Empty, TestContentType)
{
EntityTag = TestEntityTag
};
result.Should().BeVirtualFileResult().WithEntityTag(TestEntityTag);
}
public void WithFileDownloadName_GivenExpected_ShouldPass()
{
ActionResult result = new VirtualFileResult(string.Empty, TestContentType)
{
FileDownloadName = TestFileDownloadName
};
result.Should().BeVirtualFileResult().WithFileDownloadName(TestFileDownloadName);
}
private IFileProvider GetFileProvider(VirtualFileResult result)
{
if (result.FileProvider != null)
{
return(result.FileProvider);
}
result.FileProvider = _hostingEnvironment.WebRootFileProvider;
return(result.FileProvider);
}
public void Constructor_SetsFileName()
{
// Arrange
var path = Path.GetFullPath("helllo.txt");
// Act
var result = new VirtualFileResult(path, "text/plain");
// Assert
Assert.Equal(path, result.FileName);
}
public IActionResult DownloadFileWithFileName_WithEtag()
{
var file = new VirtualFileResult("/Greetings.txt", "text/plain")
{
FileProvider = new EmbeddedFileProvider(GetType().GetTypeInfo().Assembly, "FilesWebSite.EmbeddedResources"),
FileDownloadName = "downloadName.txt"
};
file.EntityTag = new Microsoft.Net.Http.Headers.EntityTagHeaderValue("\"Etag\"");
return(file);
}
private IFileProvider GetFileProvider(VirtualFileResult result)
{
if (result.FileProvider != null)
{
return result.FileProvider;
}
result.FileProvider = _hostingEnvironment.WebRootFileProvider;
return result.FileProvider;
}
public void WithLastModified_GivenNull_ShouldPass()
{
var actualLastModified = null as DateTimeOffset?;
var expectedLastModified = null as DateTimeOffset?;
ActionResult result = new VirtualFileResult(string.Empty, TestContentType)
{
LastModified = actualLastModified
};
result.Should().BeVirtualFileResult().WithLastModified(expectedLastModified);
}
protected override Task ExecuteAsync(HttpContext httpContext, string path, string contentType, DateTimeOffset?lastModified = null, EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false)
{
var result = new VirtualFileResult(path, contentType)
{
LastModified = lastModified,
EntityTag = entityTag,
EnableRangeProcessing = enableRangeProcessing,
};
return(result.ExecuteAsync(httpContext));
}
public IActionResult Index()
{
string host = HttpContext.Request.Host.Host;
VirtualFileResult response = !string.IsNullOrWhiteSpace(host) && host.TrimEnd('/').EndsWith(".onion", StringComparison.OrdinalIgnoreCase)
? File("onion-index.html", "text/html")
: File("index.html", "text/html");
response.LastModified = DateTimeOffset.UtcNow;
return(response);
}
public void WithContentType_GivenUnexpected_ShouldFail()
{
var actualContentType = TestContentType;
var expectedContentType = "xyz";
ActionResult result = new VirtualFileResult(string.Empty, actualContentType);
var failureMessage = FailureMessageHelper.ExpectedContextToBeXButY("VirtualFileResult.ContentType", expectedContentType, actualContentType);
Action a = () => result.Should().BeVirtualFileResult().WithContentType(expectedContentType, Reason, ReasonArgs);
a.Should().Throw <Exception>().WithMessage(failureMessage);
}
public void WithVirtualPath_GivenUnexpected_ShouldFail()
{
var actualFileName = TestFileName;
var expectedFileName = "xyz";
ActionResult result = new VirtualFileResult(actualFileName, TestContentType);
var failureMessage = FailureMessageHelper.ExpectedContextToBeXButY("VirtualFileResult.VirtualPath", expectedFileName, actualFileName);
Action a = () => result.Should().BeVirtualFileResult().WithVirtualPath(expectedFileName, Reason, ReasonArgs);
a.Should().Throw <Exception>().WithMessage(failureMessage);
}
public void WithEntityTag_GivenUnexpected_ShouldFail()
{
var actualEntityTag = TestEntityTag;
var expectedEntityTag = new EntityTagHeaderValue("\"1234\"");
ActionResult result = new VirtualFileResult(string.Empty, TestContentType)
{
EntityTag = actualEntityTag
};
var failureMessage = FailureMessageHelper.ExpectedContextToBeXButY("VirtualFileResult.EntityTag", expectedEntityTag, actualEntityTag);
Action a = () => result.Should().BeVirtualFileResult().WithEntityTag(expectedEntityTag, Reason, ReasonArgs);
a.Should().Throw <Exception>().WithMessage(failureMessage);
}
public void Constructor_SetsContentTypeAndParameters()
{
// Arrange
var path = Path.GetFullPath("helllo.txt");
var contentType = "text/plain; charset=us-ascii; p1=p1-value";
var expectedMediaType = contentType;
// Act
var result = new VirtualFileResult(path, contentType);
// Assert
Assert.Equal(path, result.FileName);
MediaTypeAssert.Equal(expectedMediaType, result.ContentType);
}
public void GetFileProvider_ReturnsFileProviderFromWebHostEnvironment()
{
// Arrange
var webHostFileProvider = Mock.Of <IFileProvider>();
var webHostEnvironment = Mock.Of <IWebHostEnvironment>(e => e.WebRootFileProvider == webHostFileProvider);
var result = new VirtualFileResult("some-path", "text/plain");
// Act
var fileProvider = VirtualFileResultExecutor.GetFileProvider(result, webHostEnvironment);
// Assert
Assert.Same(webHostFileProvider, fileProvider);
}
public void WithLastModified_GivenUnexpected_ShouldFail()
{
var actualLastModified = TestLastModified;
var expectedLastModified = TestLastModified.Value.AddMilliseconds(1);
ActionResult result = new VirtualFileResult(string.Empty, TestContentType)
{
LastModified = actualLastModified
};
var failureMessage = FailureMessageHelper.ExpectedContextToBeXButY("VirtualFileResult.LastModified", expectedLastModified, actualLastModified);
Action a = () => result.Should().BeVirtualFileResult().WithLastModified(expectedLastModified, Reason, ReasonArgs);
a.Should().Throw <Exception>().WithMessage(failureMessage);
}
private IFileInfo GetFileInformation(VirtualFileResult result)
{
var fileProvider = GetFileProvider(result);
var normalizedPath = result.FileName;
if (normalizedPath.StartsWith("~", StringComparison.Ordinal))
{
normalizedPath = normalizedPath.Substring(1);
}
var fileInfo = fileProvider.GetFileInfo(normalizedPath);
return(fileInfo);
}
protected override Task ExecuteAsync(HttpContext httpContext, string path, string contentType, DateTimeOffset?lastModified = null, EntityTagHeaderValue entityTag = null, bool enableRangeProcessing = false)
{
var webHostEnvironment = httpContext.RequestServices.GetRequiredService <IWebHostEnvironment>();
httpContext.RequestServices = new ServiceCollection()
.AddSingleton(webHostEnvironment)
.AddTransient <IActionResultExecutor <VirtualFileResult>, VirtualFileResultExecutor>()
.AddTransient <ILoggerFactory, NullLoggerFactory>()
.BuildServiceProvider();
var actionContext = new ActionContext(httpContext, new(), new());
var result = new VirtualFileResult(path, contentType)
{
LastModified = lastModified,
EntityTag = entityTag,
EnableRangeProcessing = enableRangeProcessing,
};
return(result.ExecuteResultAsync(actionContext));
}
protected virtual Task WriteFileAsync(ActionContext context, VirtualFileResult result, IFileInfo fileInfo, RangeItemHeaderValue range, long rangeLength)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
if (range != null && rangeLength == 0)
{
return(Task.CompletedTask);
}
var response = context.HttpContext.Response;
var physicalPath = fileInfo.PhysicalPath;
var sendFile = response.HttpContext.Features.Get <IHttpSendFileFeature>();
if (sendFile != null && !string.IsNullOrEmpty(physicalPath))
{
if (range != null)
{
return(sendFile.SendFileAsync(
physicalPath,
offset: range.From ?? 0L,
count: rangeLength,
cancellation: default(CancellationToken)));
}
return(sendFile.SendFileAsync(
physicalPath,
offset: 0,
count: null,
cancellation: default(CancellationToken)));
}
return(WriteFileAsync(context.HttpContext, GetFileStream(fileInfo), range, rangeLength));
}
private async Task WriteFileAsync(ActionContext context, VirtualFileResult result)
{
var response = context.HttpContext.Response;
var fileProvider = GetFileProvider(result);
var normalizedPath = result.FileName;
if (normalizedPath.StartsWith("~", StringComparison.Ordinal))
{
normalizedPath = normalizedPath.Substring(1);
}
var fileInfo = fileProvider.GetFileInfo(normalizedPath);
if (fileInfo.Exists)
{
var physicalPath = fileInfo.PhysicalPath;
var sendFile = response.HttpContext.Features.Get <IHttpSendFileFeature>();
if (sendFile != null && !string.IsNullOrEmpty(physicalPath))
{
await sendFile.SendFileAsync(
physicalPath,
offset : 0,
count : null,
cancellation : default(CancellationToken));
}
else
{
var fileStream = GetFileStream(fileInfo);
using (fileStream)
{
await fileStream.CopyToAsync(response.Body, DefaultBufferSize);
}
}
}
else
{
throw new FileNotFoundException(
Resources.FormatFileResult_InvalidPath(result.FileName), result.FileName);
}
}
private async Task WriteFileAsync(ActionContext context, VirtualFileResult result)
{
var response = context.HttpContext.Response;
var fileProvider = GetFileProvider(result);
var normalizedPath = result.FileName;
if (normalizedPath.StartsWith("~", StringComparison.Ordinal))
{
normalizedPath = normalizedPath.Substring(1);
}
var fileInfo = fileProvider.GetFileInfo(normalizedPath);
if (fileInfo.Exists)
{
var physicalPath = fileInfo.PhysicalPath;
var sendFile = response.HttpContext.Features.Get<IHttpSendFileFeature>();
if (sendFile != null && !string.IsNullOrEmpty(physicalPath))
{
await sendFile.SendFileAsync(
physicalPath,
offset: 0,
count: null,
cancellation: default(CancellationToken));
}
else
{
var fileStream = GetFileStream(fileInfo);
using (fileStream)
{
await fileStream.CopyToAsync(response.Body, DefaultBufferSize);
}
}
}
else
{
throw new FileNotFoundException(
Resources.FormatFileResult_InvalidPath(result.FileName), result.FileName);
}
}
public virtual Task ExecuteAsync(ActionContext context, VirtualFileResult result)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
var fileInfo = GetFileInformation(result);
if (!fileInfo.Exists)
{
throw new FileNotFoundException(
Resources.FormatFileResult_InvalidPath(result.FileName), result.FileName);
}
var lastModified = result.LastModified ?? fileInfo.LastModified;
var(range, rangeLength, serveBody) = SetHeadersAndLog(
context,
result,
fileInfo.Length,
lastModified,
result.EntityTag);
if (serveBody)
{
return(WriteFileAsync(context, result, fileInfo, range, rangeLength));
}
return(Task.CompletedTask);
}
public Task ExecuteAsync(ActionContext context, VirtualFileResult result)
{
SetHeadersAndLog(context, result);
return(WriteFileAsync(context, result));
}
public void WithContentType_GivenExpected_ShouldPass()
{
ActionResult result = new VirtualFileResult(string.Empty, TestContentType);
result.Should().BeVirtualFileResult().WithContentType(TestContentType);
}
public void WithVirtualPath_GivenExpected_ShouldPass()
{
ActionResult result = new VirtualFileResult(TestFileName, TestContentType);
result.Should().BeVirtualFileResult().WithVirtualPath(TestFileName);
}
public Task ExecuteAsync(ActionContext context, VirtualFileResult result)
{
SetHeadersAndLog(context, result);
return WriteFileAsync(context, result);
}
