public async Task Compile_Success()
{
var processor = new Compiler();
var context = new Mock <IAssetContext>().SetupAllProperties();
var asset = new Mock <IAsset>().SetupAllProperties();
var env = new Mock <IWebHostEnvironment>();
var fileProvider = new Mock <IFileProvider>();
var inputFile = new PhysicalFileInfo(new FileInfo("foo.less"));
context.Object.Content = new Dictionary <string, byte[]> {
{ "/file.less", "@foo: 1px; * {margin: @foo}".AsByteArray() },
};
context.Setup(s => s.HttpContext.RequestServices.GetService(typeof(IWebHostEnvironment)))
.Returns(env.Object);
context.SetupGet(s => s.Asset)
.Returns(asset.Object);
env.SetupGet(e => e.WebRootFileProvider)
.Returns(fileProvider.Object);
fileProvider.Setup(f => f.GetFileInfo(It.IsAny <string>()))
.Returns(inputFile);
await processor.ExecuteAsync(context.Object);
var result = context.Object.Content.First().Value;
Assert.Equal("* {\n margin: 1px;\n}", result.AsString().Trim());
}
public async Task<IActionResult> GetFile(Guid fileId)
{
if (!ModelState.IsValid)
{
throw new BadRequestException("File Id has to be specified");
}
var remoteFileId = (await _fileFacade.GetSafelyAsync(fileId)).LocationId;
if (_fileStorage is FileSystemStorage)
{
IFileInfo fileInfo = new PhysicalFileInfo(new FileInfo(remoteFileId));
HttpContext.Response.ContentType = GetContentType(fileInfo.Name);
var service = HttpContext.Features.Get<IHttpSendFileFeature>();
if (service != null)
{
await service.SendFileAsync(remoteFileId, 0, fileInfo.Length, CancellationToken.None);
}
else
{
await HttpContext.Response.SendFileAsync(fileInfo);
}
}
else
{
var result = await _fileStorage.GetAsync(remoteFileId);
return new FileStreamResult(result.Content, result.ContentType);
}
return new EmptyResult();
}
/// <summary>
/// Locate a file at the given path by directly mapping path segments to physical directories.
/// </summary>
/// <param name="subpath">A path under the root directory</param>
/// <param name="fileInfo">The discovered file, if any</param>
/// <returns>True if a file was discovered at the given path</returns>
public bool TryGetFileInfo(string subpath, out IFileInfo fileInfo)
{
try
{
if (subpath.StartsWith("/", StringComparison.Ordinal))
{
subpath = subpath.Substring(1);
}
string fullPath = GetFullPath(subpath);
if (fullPath != null)
{
var info = new FileInfo(fullPath);
if (info.Exists && !IsRestricted(info))
{
fileInfo = new PhysicalFileInfo(info);
return(true);
}
}
}
catch (ArgumentException)
{
}
fileInfo = null;
return(false);
}
public Task Invoke(HttpContext context)
{
if (IsGetMethod(context.Request.Method) && IsPluginMatchPath(context.Request.Path) && IsSupportContentType(context))
{
string filePath = GetAbsolutePath(context.Request.Path);
if (File.Exists(filePath))
{
var file = new PhysicalFileInfo(new FileInfo(filePath));
context.Response.ContentLength = file.Length;
context.Response.StatusCode = 200;
var sendFileFeature = context.Features.Get <IHttpSendFileFeature>();
if (sendFileFeature != null)
{
return(sendFileFeature.SendFileAsync(filePath, 0, file.Length, CancellationToken.None));
}
using (var readStream = file.CreateReadStream())
{
var task = StreamCopyOperation.CopyToAsync(readStream, context.Response.Body, file.Length, 64 * 1024, context.RequestAborted);
task.Wait();
return(task);
}
}
}
return(_next(context));
}
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);
});
});
}
public async Task Compile_SuccessAsync()
{
var processor = new Transformer("templates-main");
var pipeline = new Mock <IAssetPipeline>().SetupAllProperties();
var context = new Mock <IAssetContext>().SetupAllProperties();
var asset = new Mock <IAsset>().SetupAllProperties();
var env = new Mock <IHostingEnvironment>();
var fileProvider = new Mock <IFileProvider>();
context.Object.Content = new Dictionary <string, byte[]> {
{ "/other.html", @"<form ng-submit=ctrl.submitForm(ctrl.formData)>Name:<input type=text ng-model=ctrl.formData.name required><br> Last name:<input type=text ng-model=ctrl.formData.lastname required><br><input type=submit value=Submit></form><pre>{{ctrl.formData}}</pre>'}".AsByteArray() },
};
context.Setup(s => s.HttpContext.RequestServices.GetService(typeof(IHostingEnvironment)))
.Returns(env.Object);
string temp = Path.GetTempPath();
var inputFile = new PhysicalFileInfo(new FileInfo("other.html"));
context.SetupGet(s => s.Asset)
.Returns(asset.Object);
env.SetupGet(e => e.WebRootFileProvider)
.Returns(fileProvider.Object);
fileProvider.Setup(f => f.GetFileInfo(It.IsAny <string>()))
.Returns(inputFile);
await processor.ExecuteAsync(context.Object);
var result = context.Object.Content.First().Value;
Assert.Equal(@"angular.module('templates-main',[]).run(['$templateCache',function($templateCache){$templateCache.put('other.html','<form ng-submit=ctrl.submitForm(ctrl.formData)>Name:<input type=text ng-model=ctrl.formData.name required><br> Last name:<input type=text ng-model=ctrl.formData.lastname required><br><input type=submit value=Submit></form><pre>{{ctrl.formData}}</pre>\'}');}]);", result.AsString());
}
public async Task Compile_Success()
{
var processor = new Compiler();
var pipeline = new Mock <IAssetPipeline>().SetupAllProperties();
var context = new Mock <IAssetContext>().SetupAllProperties();
var asset = new Mock <IAsset>().SetupAllProperties();
var env = new Mock <IWebHostEnvironment>();
var fileProvider = new Mock <IFileProvider>();
context.Object.Content = new Dictionary <string, byte[]> {
{ "/file.css", "$bg: blue; div {background: $bg}".AsByteArray() },
};
context.Setup(s => s.HttpContext.RequestServices.GetService(typeof(IWebHostEnvironment)))
.Returns(env.Object);
string temp = Path.GetTempPath();
var inputFile = new PhysicalFileInfo(new FileInfo("site.css"));
context.SetupGet(s => s.Asset)
.Returns(asset.Object);
env.SetupGet(e => e.WebRootFileProvider)
.Returns(fileProvider.Object);
fileProvider.Setup(f => f.GetFileInfo(It.IsAny <string>()))
.Returns(inputFile);
await processor.ExecuteAsync(context.Object);
var result = context.Object.Content.First().Value;
Assert.Equal("div {\n background: blue; }\n", result.AsString());
}
public Task <IFileInfo> MoveTempFile(string tempFileName, string relativeFolderPath, string fileName, string extension, CancellationToken cancellationToken = default(CancellationToken))
{
ThrowIfContainsSlashes(tempFileName, nameof(tempFileName));
var tempFilePath = Path.Combine(tempFolderPath, tempFileName);
var tempFileInfo = new PhysicalFileInfo(new FileInfo(tempFilePath));
return(MoveFile(tempFileInfo, relativeFolderPath, fileName, extension, cancellationToken));
}
public static IConfigurationBuilder AddCsv(this IConfigurationBuilder configurationBuilder,
string fileName)
{
var file = new PhysicalFileInfo(new FileInfo(fileName));
configurationBuilder.Add(new CsvConfigurationSource {
Stream = file.CreateReadStream()
});
return(configurationBuilder);
}
public async Task UploadFile_FromFileInfo_ExpectedSkylink()
{
// Arrange
var file = new PhysicalFileInfo(new FileInfo("assets/test-file.json"));
// Act
var skylink = await _skynetWebPortal.UploadFile(file);
// Assert
Assert.That(skylink.ToString() == "AACcDsB0hiRosExg1JlERWIJP5MVYiAS2F5EkU8VLtlPrA");
}
public async Task CssImageInliner_Success(string url, string newUrl)
{
var processor = new CssImageInliner(5120);
var context = new Mock <IAssetContext>().SetupAllProperties();
var pipeline = new Mock <IAssetPipeline>().SetupAllProperties();
var asset = new Mock <IAsset>().SetupAllProperties();
var env = new Mock <IWebHostEnvironment>();
var fileProvider = new Mock <IFileProvider>();
string temp = Path.GetTempPath();
string path = Path.Combine(temp, "css", "img");
Directory.CreateDirectory(path);
string imagePath = Path.Combine(path, "test.png");
File.WriteAllText(imagePath, "empty");
File.SetLastWriteTime(imagePath, new DateTime(2017, 1, 1));
var inputFile = new PhysicalFileInfo(new FileInfo(Path.Combine(temp, "css", "site.css")));
var outputFile = new PhysicalFileInfo(new FileInfo(Path.Combine(temp, "dist", "all.css")));
context.SetupGet(s => s.Asset.Route)
.Returns("/my/route.css");
context.Setup(s => s.HttpContext.RequestServices.GetService(typeof(IAssetPipeline)))
.Returns(pipeline.Object);
context.Setup(s => s.HttpContext.RequestServices.GetService(typeof(IWebHostEnvironment)))
.Returns(env.Object);
context.SetupGet(s => s.Asset)
.Returns(asset.Object);
env.SetupGet(e => e.WebRootFileProvider)
.Returns(fileProvider.Object);
env.SetupGet(e => e.WebRootPath)
.Returns(temp);
fileProvider.SetupSequence(f => f.GetFileInfo(It.IsAny <string>()))
.Returns(inputFile)
.Returns(outputFile);
context.Object.Content = new Dictionary <string, byte[]> {
{ "css/site.css", url.AsByteArray() }
};
await processor.ExecuteAsync(context.Object);
string result = context.Object.Content.First().Value.AsString();
Assert.Equal(newUrl, result);
}
public async Task <FileEntryInfo> GetFileInfoAsync(string path)
{
var physicalPath = GetPhysicalPath(path);
var fileInfo = new PhysicalFileInfo(new FileInfo(physicalPath));
if (fileInfo.Exists)
{
return(await Task.FromResult(new FileEntryInfo(path, fileInfo)));
}
return(null);
}
public async Task UploadFile_FromUploadItemDifferentSkynetPath_ExpectedSkylink()
{
// Arrange
var file = new PhysicalFileInfo(new FileInfo("assets/test-file.json"));
var item = new UploadItem(file, skynetPath: "custom/directory/test-file.json");
// Act
var skylink = await _skynetWebPortal.UploadFile(item);
// Assert
Assert.That(skylink.ToString() == "AADoxsbpEVLgFTMco_fS3eiTAvtKx5WCfll5wqHEfyksrQ");
}
public async Task UploadFile_FromUploadItemDifferentContentType_ExpectedSkylink()
{
// Arrange
var file = new PhysicalFileInfo(new FileInfo("assets/test-file.json"));
var item = new UploadItem(file, contentType: new MediaTypeHeaderValue("text/xml"));
// Act
var skylink = await _skynetWebPortal.UploadFile(item);
// Assert
Assert.That(skylink.ToString() == "AABDI5UpS0B8tuxKBOiwwKEULV7V4Ln_aBdPPFLWpTlFhA");
}
private static IStyle parseTestStyle()
{
var fileInfo = new PhysicalFileInfo(new System.IO.FileInfo(@"C:\Playground\AbsoluteGraphicsPlatform\tests\TestFiles\TestStyle1.dss"));
var expressionExecutor = new ExpressionExecutor();
var dssParser = new DssParser();
var dssCompiler = new DssCompiler(expressionExecutor);
var sourceInfo = new SourceCodeInfo(fileInfo);
var instructions = dssParser.Parse(sourceInfo);
var style = dssCompiler.Compile(instructions);
return(style);
}
public static IFileInfo FindFile(string filePath)
{
var fileWithFullDirectoryPath = Path.GetFullPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, filePath));
IFileInfo fileInfo = null;
if (fileWithFullDirectoryPath.Equals(appConstantsPath, StringComparison.OrdinalIgnoreCase) && File.Exists(fileWithFullDirectoryPath))
{
fileInfo = new PhysicalFileInfo(new FileInfo(fileWithFullDirectoryPath));
}
return(fileInfo);
}
public Task <IFileStoreEntry> GetFileInfoAsync(string path)
{
var physicalPath = GetPhysicalPath(path);
var fileInfo = new PhysicalFileInfo(new FileInfo(physicalPath));
if (fileInfo.Exists)
{
return(Task.FromResult <IFileStoreEntry>(new FileSystemStoreEntry(path, fileInfo)));
}
return(Task.FromResult <IFileStoreEntry>(null));
}
/// <summary>
/// Enumerate a directory at the given path, if any.
/// </summary>
/// <param name="subpath">A path under the root directory</param>
/// <param name="contents">The discovered directories, if any</param>
/// <returns>True if a directory was discovered at the given path</returns>
public bool TryGetDirectoryContents(string subpath, out IEnumerable <IFileInfo> contents)
{
//Console.WriteLine("[LOG.FILE] ====> " + subpath);
try
{
if (subpath.StartsWith("/", StringComparison.Ordinal))
{
subpath = subpath.Substring(1);
}
var fullPath = GetFullPath(subpath);
if (fullPath != null)
{
var directoryInfo = new DirectoryInfo(fullPath);
if (!directoryInfo.Exists)
{
contents = null;
return(false);
}
FileSystemInfo[] physicalInfos = directoryInfo.GetFileSystemInfos();
var virtualInfos = new IFileInfo[physicalInfos.Length];
for (int index = 0; index != physicalInfos.Length; ++index)
{
var fileInfo = physicalInfos[index] as FileInfo;
if (fileInfo != null)
{
virtualInfos[index] = new PhysicalFileInfo(fileInfo);
}
else
{
virtualInfos[index] = new PhysicalDirectoryInfo((DirectoryInfo)physicalInfos[index]);
}
}
contents = virtualInfos;
return(true);
}
}
catch (ArgumentException)
{
}
catch (DirectoryNotFoundException)
{
}
catch (IOException)
{
}
contents = null;
return(false);
}
/// <summary>
/// 取得文件信息
/// </summary>
/// <param name="relativePath">相对路径</param>
/// <param name="rootPhysicalPath">物理根路径</param>
/// <returns>文件信息</returns>
public IFileEntity GetFileInfo(string relativePath, string rootPhysicalPath)
{
var path = GetFilePhysicalPath(relativePath, rootPhysicalPath);
var fileInfo = new PhysicalFileInfo(new FileInfo(path));
return(fileInfo.Exists ? new FileManageEntity
{
FilePhysicalPath = path,
IsDirectory = fileInfo.IsDirectory,
LastModified = fileInfo.LastModified.UtcDateTime,
Length = fileInfo.Length,
RelativePath = relativePath,
Name = fileInfo.Name
} : null);
}
public void GetPlainTextTestEmail_WhenInvoke_ShouldReturnNotNullEmailMessage()
{
_webHostEnvMock.DefaultValue = DefaultValue.Mock;
var provider = _webHostEnvMock.Object.ContentRootFileProvider;
var providerMock = Mock.Get(provider);
var fileMock = new PhysicalFileInfo
(new FileInfo(_fileInfoPath));
providerMock.Setup(x => x.GetFileInfo(It.IsAny <string>()))
.Returns(fileMock);
EmailTemplates.Initialize(_webHostEnvMock.Object);
DateTime testDate = new DateTime(2020, 1, 1);
string emailMessage = EmailTemplates.GetPlainTextTestEmail(testDate);
Assert.IsNotNull(emailMessage);
}
/// <summary>
///
/// </summary>
/// <param name="subpath">A path under the root directory</param>
/// <param name="contents">The discovered directories, if any</param>
/// <returns>True if a directory was discovered at the given path</returns>
public bool TryGetDirectoryContents(string subpath, out IEnumerable <IFileInfo> contents)
{
try
{
var fullPath = GetFullPath(subpath);
if (fullPath != null)
{
var directoryInfo = new DirectoryInfo(fullPath);
if (!directoryInfo.Exists)
{
contents = null;
return(false);
}
FileSystemInfo[] physicalInfos = directoryInfo.GetFileSystemInfos();
var virtualInfos = new IFileInfo[physicalInfos.Length];
for (int index = 0; index != physicalInfos.Length; ++index)
{
var fileInfo = physicalInfos[index] as FileInfo;
if (fileInfo != null)
{
virtualInfos[index] = new PhysicalFileInfo(fileInfo);
}
else
{
virtualInfos[index] = new PhysicalDirectoryInfo((DirectoryInfo)physicalInfos[index]);
}
}
contents = virtualInfos;
return(true);
}
}
catch (ArgumentException)
{
}
catch (DirectoryNotFoundException)
{
}
catch (IOException)
{
}
contents = null;
return(false);
}
public async Task UploadFiles_FromFileInfo_ExpectedSkylink()
{
// Arrange
var files = new PhysicalFileInfo[]
{
new PhysicalFileInfo(new FileInfo("assets/test-file.json")),
new PhysicalFileInfo(new FileInfo("assets/test-file.txt"))
};
var options = new MultiFileUploadOptions {
FileName = "integration-tests"
};
// Act
var skylink = await _skynetWebPortal.UploadFiles(files, options);
// Assert
Assert.That(skylink.ToString() == "AACVmVl_KyZTaaS2cdGANxedYtOGJu13urqfc_yQl5jL8w");
}
public IAsyncEnumerable <IFileStoreEntry> GetDirectoryContentAsync(string path = null, bool includeSubDirectories = false)
{
try
{
var physicalPath = GetPhysicalPath(path);
var results = new List <IFileStoreEntry>();
if (!Directory.Exists(physicalPath))
{
return(results.ToAsyncEnumerable());
}
// Add directories.
results.AddRange(
Directory
.GetDirectories(physicalPath, "*", includeSubDirectories ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly)
.Select(f =>
{
var fileSystemInfo = new PhysicalDirectoryInfo(new DirectoryInfo(f));
var fileRelativePath = f.Substring(_fileSystemPath.Length);
var filePath = this.NormalizePath(fileRelativePath);
return(new FileSystemStoreEntry(filePath, fileSystemInfo));
}));
// Add files.
results.AddRange(
Directory
.GetFiles(physicalPath, "*", includeSubDirectories ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly)
.Select(f =>
{
var fileSystemInfo = new PhysicalFileInfo(new FileInfo(f));
var fileRelativePath = f.Substring(_fileSystemPath.Length);
var filePath = this.NormalizePath(fileRelativePath);
return(new FileSystemStoreEntry(filePath, fileSystemInfo));
}));
return(results.ToAsyncEnumerable());
}
catch (Exception ex)
{
throw new FileStoreException($"Cannot get directory content with path '{path}'.", ex);
}
}
/// <summary>
/// Creates a file at the given path.
/// </summary>
/// <param name="subpath">A path under the root directory</param>
/// <returns>
/// The file information. Caller must check
/// <see cref="IFileInfo.Exists"/> property.
/// </returns>
public IFileInfo CreateFile(string subpath)
{
PhysicalFileInfo?physicalFileInfo = null;
var fileInfo = this.GetFileInfo(subpath);
if (!(fileInfo is NotFoundFileInfo))
{
var fileSystemInfo = new FileInfo(fileInfo.PhysicalPath);
if (!fileSystemInfo.Exists)
{
fileSystemInfo.Create();
fileSystemInfo.Refresh();
}
physicalFileInfo = new PhysicalFileInfo(fileSystemInfo);
}
return(physicalFileInfo ?? fileInfo);
}
public IList <IFileStoreEntry> GetDirectoryContent(string path = null, bool includeSubDirectories = false, bool listDirectories = true, bool listFiles = true)
{
var physicalPath = GetPhysicalPath(path);
var results = new List <IFileStoreEntry>();
if (!Directory.Exists(physicalPath))
{
return(results.ToList());
}
// Add directories.
if (listDirectories)
{
results.AddRange(
Directory
.GetDirectories(physicalPath, "*", includeSubDirectories ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly)
.Select(f =>
{
var fileSystemInfo = new PhysicalDirectoryInfo(new DirectoryInfo(f));
var fileRelativePath = f.Substring(_fileSystemPath.Length);
var filePath = this.NormalizePath(fileRelativePath);
return(new FileSystemStoreEntry(filePath, fileSystemInfo));
}));
}
// Add files.
if (listFiles)
{
results.AddRange(
Directory
.GetFiles(physicalPath, "*", includeSubDirectories ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly)
.Select(f =>
{
var fileSystemInfo = new PhysicalFileInfo(new FileInfo(f));
var fileRelativePath = f.Substring(_fileSystemPath.Length);
var filePath = this.NormalizePath(fileRelativePath);
return(new FileSystemStoreEntry(filePath, fileSystemInfo));
}));
}
return(results.ToList());
}
/// <summary>
/// 创建文件
/// </summary>
/// <param name="relativePath">相对路径</param>
/// <param name="rootPhysicalPath">物理根路径</param>
/// <param name="fileStream">文件流</param>
public async Task <IFileEntity> CreateFile(string relativePath, string rootPhysicalPath, Stream fileStream)
{
var path = GetFilePhysicalPath(relativePath, rootPhysicalPath);
using (var stream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write))
{
await fileStream.CopyToAsync(stream);
}
var fileInfo = new PhysicalFileInfo(new FileInfo(path));
return(new FileManageEntity
{
FilePhysicalPath = path,
IsDirectory = fileInfo.IsDirectory,
LastModified = fileInfo.LastModified.UtcDateTime,
Length = fileInfo.Length,
RelativePath = relativePath,
Name = fileInfo.Name
});
}
public Task <IFileStoreEntry> GetFileInfoAsync(string path)
{
try
{
var physicalPath = GetPhysicalPath(path);
var fileInfo = new PhysicalFileInfo(new FileInfo(physicalPath));
if (fileInfo.Exists)
{
return(Task.FromResult <IFileStoreEntry>(new FileSystemStoreEntry(path, fileInfo)));
}
return(Task.FromResult <IFileStoreEntry>(null));
}
catch (Exception ex)
{
throw new FileStoreException($"Cannot get file info with path '{path}'.", ex);
}
}
public void GetTestEmail_ForTestDate_ShouldReplaceTestDate()
{
_webHostEnvMock.DefaultValue = DefaultValue.Mock;
var provider = _webHostEnvMock.Object.ContentRootFileProvider;
var providerMock = Mock.Get(provider);
var fileMock = new PhysicalFileInfo
(new FileInfo(_fileInfoPath));
providerMock.Setup(x => x.GetFileInfo(It.IsAny <string>()))
.Returns(fileMock);
EmailTemplates.Initialize(_webHostEnvMock.Object);
string recipentName = "TestRecipent";
DateTime testDate = new DateTime(2020, 1, 1);
string textToReplace = "{testDate}";
string emailMessage = EmailTemplates.GetTestEmail(recipentName, testDate);
bool result = emailMessage.Contains(textToReplace);
Assert.IsFalse(result);
}
/// <summary>
///
/// </summary>
/// <param name="subpath">A path under the root directory</param>
/// <param name="fileInfo">The discovered file, if any</param>
/// <returns>True if a file was discovered at the given path</returns>
public bool TryGetFileInfo(string subpath, out IFileInfo fileInfo)
{
try
{
var fullPath = GetFullPath(subpath);
if (fullPath != null)
{
var info = new FileInfo(fullPath);
if (info.Exists)
{
fileInfo = new PhysicalFileInfo(info);
return(true);
}
}
}
catch (ArgumentException)
{
}
fileInfo = null;
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="subpath">A path under the root directory</param>
/// <param name="fileInfo">The discovered file, if any</param>
/// <returns>True if a file was discovered at the given path</returns>
public bool TryGetFileInfo(string subpath, out IFileInfo fileInfo)
{
try
{
var fullPath = GetFullPath(subpath);
if (fullPath != null)
{
var info = new FileInfo(fullPath);
if (info.Exists)
{
fileInfo = new PhysicalFileInfo(info);
return true;
}
}
}
catch (ArgumentException)
{
}
fileInfo = null;
return false;
}
public async Task AdjustRelativePaths_Success(string url, string newUrl)
{
var adjuster = new RelativePathAdjuster();
var context = new Mock <IAssetContext>().SetupAllProperties();
var pipeline = new Mock <IAssetPipeline>().SetupAllProperties();
var inputFile = new PhysicalFileInfo(new FileInfo(@"c:\source\css\site.css"));
var outputFile = new PhysicalFileInfo(new FileInfo(@"c:\source\dist\all.css"));
var asset = new Mock <IAsset>().SetupAllProperties();
var env = new Mock <IWebHostEnvironment>();
var fileProvider = new Mock <IFileProvider>();
context.SetupGet(s => s.Asset.Route)
.Returns("/my/route.css");
context.Setup(s => s.HttpContext.RequestServices.GetService(typeof(IAssetPipeline)))
.Returns(pipeline.Object);
context.Setup(s => s.HttpContext.RequestServices.GetService(typeof(IWebHostEnvironment)))
.Returns(env.Object);
context.SetupGet(s => s.Asset)
.Returns(asset.Object);
env.SetupGet(e => e.WebRootFileProvider)
.Returns(fileProvider.Object);
fileProvider.SetupSequence(f => f.GetFileInfo(It.IsAny <string>()))
.Returns(inputFile)
.Returns(outputFile);
context.Object.Content = new Dictionary <string, byte[]> {
{ "css/site.css", url.AsByteArray() }
};
await adjuster.ExecuteAsync(context.Object);
Assert.Equal(newUrl, context.Object.Content.First().Value.AsString());
Assert.Equal("", adjuster.CacheKey(new DefaultHttpContext()));
}
/// <summary>
/// Enumerate a directory at the given path, if any.
/// </summary>
/// <param name="subpath">A path under the root directory</param>
/// <param name="contents">The discovered directories, if any</param>
/// <returns>True if a directory was discovered at the given path</returns>
public bool TryGetDirectoryContents(string subpath, out IEnumerable<IFileInfo> contents)
{
try
{
if (subpath.StartsWith("/", StringComparison.Ordinal))
{
subpath = subpath.Substring(1);
}
var fullPath = GetFullPath(subpath);
if (fullPath != null)
{
var directoryInfo = new DirectoryInfo(fullPath);
if (!directoryInfo.Exists)
{
contents = null;
return false;
}
FileSystemInfo[] physicalInfos = directoryInfo.GetFileSystemInfos();
var virtualInfos = new IFileInfo[physicalInfos.Length];
for (int index = 0; index != physicalInfos.Length; ++index)
{
var fileInfo = physicalInfos[index] as FileInfo;
if (fileInfo != null)
{
virtualInfos[index] = new PhysicalFileInfo(fileInfo);
}
else
{
virtualInfos[index] = new PhysicalDirectoryInfo((DirectoryInfo)physicalInfos[index]);
}
}
contents = virtualInfos;
return true;
}
}
catch (ArgumentException)
{
}
catch (DirectoryNotFoundException)
{
}
catch (IOException)
{
}
contents = null;
return false;
}
/// <summary>
/// Locate a file at the given path by directly mapping path segments to physical directories.
/// </summary>
/// <param name="subpath">A path under the root directory</param>
/// <param name="fileInfo">The discovered file, if any</param>
/// <returns>True if a file was discovered at the given path</returns>
public bool TryGetFileInfo(string subpath, out IFileInfo fileInfo)
{
try
{
if (subpath.StartsWith("/", StringComparison.Ordinal))
{
subpath = subpath.Substring(1);
}
var fullPath = GetFullPath(subpath);
if (fullPath != null)
{
var info = new FileInfo(fullPath);
if (info.Exists && !IsRestricted(info))
{
fileInfo = new PhysicalFileInfo(info);
return true;
}
}
}
catch (ArgumentException)
{
}
fileInfo = null;
return false;
}