public async Task <ImageUploadResponse> AddAsset(ImageUploadInput arg)
{
ImageUploadResponse imageResponse = new ImageUploadResponse();
try
{
using (var uploadStream = arg.Upload.OpenReadStream())
{
fileVerifier.Validate(uploadStream, arg.Upload.FileName, arg.Upload.ContentType);
string autoFileFolder = "AutoUploads";
var autoFileFile = Guid.NewGuid().ToString() + Path.GetExtension(arg.Upload.FileName);
var autoPath = Path.Combine(autoFileFolder, autoFileFile);
using (Stream stream = fileFinder.WriteFile(autoPath))
{
await uploadStream.CopyToAsync(stream);
}
imageResponse.Uploaded = 1;
imageResponse.FileName = autoFileFile;
imageResponse.Url = pathBase + autoPath.EnsureStartingPathSlash();
}
}
catch (Exception ex)
{
imageResponse.Message = ex.Message;
imageResponse.Uploaded = 0;
}
return(imageResponse);
}
public void TestSuccessVerifier(String file, IFileVerifier verifier, String mimeType)
{
using (var stream = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
{
verifier.Validate(stream, file, mimeType);
}
}
//This test is commented out because it actually allows the really evil pdf through, that file is html, but starts
//with %PDF like a real pdf, all browsers refuse to open this file at the time of this writing (8-6-17), so that file
//is considered safe.
//[Fact]
//public void ReallyEvilPdf()
//{
// TestFailValidator("TestFiles/ReallyEvilPdf.pdf", new FileVerifier().AddPdf(), FileVerifierFactory.PdfMimeType);
//}
private static void TestFailValidator(string file, IFileVerifier verifier, string mimeType)
{
using (var stream = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
{
Assert.ThrowsAny <Exception>(new Action(() => verifier.Validate(stream, file, mimeType)));
}
}
public async Task Upload([FromForm] UploadInput input, [FromServices] IFileVerifier fileVerifier)
{
var fileInfo = fileInfoProvider.GetFileInfo(input.File, HttpContext.Request.PathBase);
using (var uploadStream = input.Content.OpenReadStream())
{
fileVerifier.Validate(uploadStream, fileInfo.DerivedFileName, input.Content.ContentType);
using (Stream stream = fileFinder.WriteFile(fileInfo.DerivedFileName))
{
await uploadStream.CopyToAsync(stream);
}
}
}
/// <summary>
/// Save a page.
/// </summary>
/// <param name="page">The file to save.</param>
/// <param name="content">The file content.</param>
public async Task Save(String page, IFormFile content)
{
var fileInfo = fileInfoProvider.GetFileInfo(page, pathBase);
if (fileInfo.IsProjectFile)
{
throw new ValidationException("Cannot update project files with the save function.");
}
using (var contentStream = content.OpenReadStream())
{
fileVerifier.Validate(contentStream, fileInfo.DerivedFileName, content.ContentType);
using (Stream stream = fileFinder.WriteFile(fileInfo.DerivedFileName))
{
await contentStream.CopyToAsync(stream);
}
}
}
/// <summary>
/// Resolve the conflicts on the file.
/// </summary>
/// <param name="file">The file to resolve.</param>
/// <param name="content">The file content.</param>
/// <returns></returns>
public async Task Resolve(String file, IFormFile content)
{
if (!repo.Index.Conflicts.Any(s => file == s.Ancestor.Path))
{
throw new InvalidOperationException($"No conflicts to resolve for {file}.");
}
var fileInfo = fileInfoProvider.GetFileInfo(file, pathBase);
using (var contentStream = content.OpenReadStream())
{
fileVerifier.Validate(contentStream, fileInfo.DerivedFileName, content.ContentType);
var repoPath = Path.Combine(repo.Info.WorkingDirectory, fileInfo.DerivedFileName);
using (var stream = fileFinder.WriteFile(fileFinder.GetProjectRelativePath(repoPath)))
{
await contentStream.CopyToAsync(stream);
}
}
//Staging clears the conflict status
Commands.Stage(repo, file);
}
public Task Validate(string fileName, string mimeType, Stream stream)
{
fileVerifier.Validate(stream, GetPhysicalPath(fileName), mimeType);
return(Task.FromResult(0));
}