// Newly added files
private async Task MoveNewFilesToContentItemDirAndUpdatePathsAsync(List <EditMediaFieldItemInfo> items, ContentItem contentItem)
{
foreach (var item in items.Where(i => !i.IsRemoved && !String.IsNullOrEmpty(i.Path)))
{
var fileInfo = await _fileStore.GetFileInfoAsync(item.Path);
if (fileInfo == null)
{
_logger.LogError("A file with the path '{Path}' does not exist.", item.Path);
return;
}
var targetDir = GetContentItemFolder(contentItem);
var finalFileName = (await GetFileHashAsync(item.Path)) + GetFileExtension(item.Path);
var finalFilePath = _fileStore.Combine(targetDir, finalFileName);
await _fileStore.TryCreateDirectoryAsync(targetDir);
// When there is a validation error before creating the content item we can end up with an empty folder
// because the content item is different on each form submit . We need to remove that empty folder.
var previousDirPath = fileInfo.DirectoryPath;
// fileName is a hash of the file. We preserve disk space by reusing the file.
if (await _fileStore.GetFileInfoAsync(finalFilePath) == null)
{
await _fileStore.MoveFileAsync(item.Path, finalFilePath);
}
item.Path = finalFilePath;
await DeleteDirIfEmptyAsync(previousDirPath);
}
}
// This action will demonstrate how to create a file in the Media folder and read it from there.
public async Task <string> CreateFileInMediaFolder()
{
// You need to initialize a stream if you have a specific text you want to write into the file. If you
// already have a stream for that just use it (you'll see it later)!
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes("Hi there!")))
{
// The third parameter here is optional - if true, it will override the file if already exists.
await _mediaFileStore.CreateFileFromStreamAsync(TestFileRelativePath, stream, true);
}
// Use this method to check if the file exists (it will be null if the file doesn't exist). It's similar to
// the built-in FileInfo class but not that robust.
var fileInfo = await _mediaFileStore.GetFileInfoAsync(TestFileRelativePath);
// The IMediaFileStore has its own specific methods such as mapping the file path to a public URL. Since
// the files in the Media folder are accessible from the outside this can be handy.
var publicUrl = _mediaFileStore.MapPathToPublicUrl(TestFileRelativePath);
return($"Successfully created file! File size: {fileInfo.Length} bytes. Public URL: {publicUrl}");
}
public async Task <ActionResult <object> > GetMediaItem(string path)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageMedia))
{
return(Forbid());
}
if (string.IsNullOrEmpty(path))
{
return(NotFound());
}
var f = await _mediaFileStore.GetFileInfoAsync(path);
if (f == null)
{
return(NotFound());
}
return(CreateFileResult(f));
}
/// <inheritdoc/>
public async Task <IImageResolver> GetAsync(HttpContext context)
{
// Path has already been correctly parsed before here.
var filePath = _mediaStore.MapPublicUrlToPath(context.Request.PathBase + context.Request.Path.Value);
// Check to see if the file exists.
var file = await _mediaStore.GetFileInfoAsync(filePath);
if (file == null)
{
return(null);
}
var metadata = new ImageMetaData(file.LastModifiedUtc);
return(new MediaFileResolver(_mediaStore, filePath, metadata));
}
public async Task <string> ReadFile()
{
var fileInfo = await _mediaFileStore.GetFileInfoAsync("Demo.txt");
if (fileInfo == null)
{
return("Not found :(");
}
using var stream = await _mediaFileStore.GetFileStreamAsync("Demo.txt");
using var streamReader = new StreamReader(stream);
var content = await streamReader.ReadToEndAsync();
return($"File info: size: {fileInfo.Length}, last modification UTC: {fileInfo.LastModifiedUtc}. Content: {content}");
}
public async Task <IContent> ImportMediaAsync(string path, string mimeType, string contentType)
{
var file = await _mediaFileStore.GetFileInfoAsync(path);
if (file == null)
{
return(null);
}
using (var stream = await _mediaFileStore.GetFileStreamAsync(path))
{
var mediaFactory = GetMediaFactory(stream, file.Name, mimeType, contentType);
if (mediaFactory == null)
{
return(null);
}
return(mediaFactory.CreateMedia(stream, file.Path, mimeType, file.Length, contentType));
}
}
public async Task <IActionResult> TemporaryUpload(string path, IFormFile file)
{
if (path == null)
{
path = "";
}
try
{
using (var stream = file.OpenReadStream())
{
var mediaFilePath = _mediaFileStore.Combine("temp", path, file.FileName);
mediaFilePath = await _mediaFileStore.CreateFileAsync(mediaFilePath, stream);
var mediaFile = await _mediaFileStore.GetFileInfoAsync(mediaFilePath);
return(Json(new
{
name = mediaFile.Name,
size = mediaFile.Length,
folder = mediaFile.DirectoryPath,
url = _mediaFileStore.MapPathToPublicUrl(mediaFile.Path),
mediaPath = mediaFile.Path,
mime = file.ContentType
}));
}
}
catch (Exception ex)
{
return(Json(new
{
name = file.FileName,
size = file.Length,
folder = path,
error = ex.Message
}));
}
}
/// <inheritdoc/>
public async Task <IByteBuffer> ResolveImageAsync(HttpContext context, ILogger logger)
{
// Path has already been correctly parsed before here.
var filePath = _mediaStore.MapPublicUrlToPath(context.Request.PathBase + context.Request.Path.Value);
var file = await _mediaStore.GetFileInfoAsync(filePath);
// Check to see if the file exists.
if (file == null)
{
return(null);
}
IByteBuffer buffer;
using (var stream = await _mediaStore.GetFileStreamAsync(filePath))
{
// Buffer is returned to the pool in the middleware
buffer = this.bufferManager.Allocate((int)stream.Length);
await stream.ReadAsync(buffer.Array, 0, buffer.Length);
}
return(buffer);
}
/// <inheritdoc/>
public async Task <byte[]> ResolveImageAsync(HttpContext context, ILogger logger)
{
// Path has already been correctly parsed before here.
var filePath = _mediaStore.MapPublicUrlToPath(context.Request.Path);
var file = await _mediaStore.GetFileInfoAsync(filePath);
// Check to see if the file exists.
if (file == null)
{
return(null);
}
byte[] buffer;
using (var stream = await _mediaStore.GetFileStreamAsync(filePath))
{
// Buffer is returned to the pool in the middleware
buffer = BufferDataPool.Rent((int)stream.Length);
await stream.ReadAsync(buffer, 0, (int)stream.Length);
}
return(buffer);
}
public async Task <ActionResult <object> > Upload(
string path,
ICollection <IFormFile> files)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageMedia))
{
return(Forbid());
}
if (string.IsNullOrEmpty(path))
{
path = "";
}
var result = new List <object>();
// Loop through each file in the request
foreach (var file in files)
{
// TODO: support clipboard
if (!_allowedFileExtensions.Contains(Path.GetExtension(file.FileName), StringComparer.OrdinalIgnoreCase))
{
result.Add(new
{
name = file.FileName,
size = file.Length,
folder = path,
error = S["This file extension is not allowed: {0}", Path.GetExtension(file.FileName)].ToString()
});
_logger.LogInformation("File extension not allowed: '{File}'", file.FileName);
continue;
}
var fileName = _mediaNameNormalizerService.NormalizeFileName(file.FileName);
Stream stream = null;
try
{
var mediaFilePath = _mediaFileStore.Combine(path, fileName);
stream = file.OpenReadStream();
mediaFilePath = await _mediaFileStore.CreateFileFromStreamAsync(mediaFilePath, await _tinyPngService.OptimiseAsync(stream, file.FileName));
var mediaFile = await _mediaFileStore.GetFileInfoAsync(mediaFilePath);
result.Add(CreateFileResult(mediaFile));
}
catch (Exception ex)
{
_logger.LogError(ex, "An error occurred while uploading a media");
result.Add(new
{
name = fileName,
size = file.Length,
folder = path,
error = ex.Message
});
}
finally
{
stream?.Dispose();
}
}
return(new { files = result.ToArray() });
}
public async Task <IActionResult> GetUserProfilePhotoSmall(string id)
{
var user = await _userManager.FindByNameAsync(id) as User;
if (user != null)
{
// byte[] file = null;
var userProfileMetadata = user.As <UserMetadata>();
if (userProfileMetadata != null)
{
var urlProfileImageUrl = userProfileMetadata.Avatar;
if (_mediaFileStore == null)
{
return(Content(urlProfileImageUrl));
}
// This way you can check if the given file exists.
if (await _mediaFileStore.GetFileInfoAsync(urlProfileImageUrl) != null)
{
await using (var stream = await _mediaFileStore.GetFileStreamAsync(urlProfileImageUrl))
{
// var resolvedAssetPath = mediaFileStore.MapPathToPublicUrl(urlProfileImageUrl);
using (var image = SixLabors.ImageSharp.Image.Load(stream))
{
// Resize the image in place and return it for chaining.
// 'x' signifies the current image processing context.
image.Mutate(x => x.Resize(50, 50));
await using (var ms = new MemoryStream())
{
image.Save(ms, new PngEncoder());
return(File(ms.ToArray(), MediaTypeNames.Application.Octet, true));
}
// The library automatically picks an encoder based on the file extensions then encodes and write the data to disk.
// return File(image.ToByteArray(), MediaTypeNames.Application.Octet, true);
}
}
// If you want to extract the content of the file use a StreamReader to read the stream.
/*using (var stream = await mediaFileStore.GetFileStreamAsync(urlProfileImageUrl))
*
* {
*
* file = new byte[stream.Length];
* int numBytesToRead = (int) stream.Length;
* int numBytesRead = 0;
* while (numBytesToRead > 0)
* {
* int n = stream.Read(file, numBytesRead, numBytesToRead);
* if (n == 0)
* {
* break;
* }
*
* numBytesRead += n;
* numBytesToRead -= n;
* }
*
* }
* return File(file, MediaTypeNames.Application.Octet, true);*/
}
// return Content( _orchardHelper.ImageResizeUrl(resolvedAssetPath, 40, 40,ResizeMode.Crop));
// var fileVersionProvider = _orchardHelper.HttpContext.RequestServices.GetService<IFileVersionProvider>();
// resizedUrl = fileVersionProvider.AddFileVersionToPath(orchardHelper.HttpContext.Request.PathBase, resizedUrl);
}
}
// var file = user.Avatar;
// if (file != null)
/*using (var image = new MagickImage(file))
* {
* image.Resize(40, 40);
*
* return File(image.ToByteArray(), MediaTypeNames.Application.Octet, true);
* }*/
return(NoContent());
}
public async Task <IActionResult> UploadMediaFromFroalaEditor()
{
// if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageOwnMedia))
// {
// return Forbid();
// }
var path = _attachedMediaToContentItemService.MediaFieldsTempSubFolder;
var fileToUpload = GetFileToUpload(null);
var result = new object();
// Loop through each file in the request
// foreach (var file in files)
//{
if (fileToUpload != null)
{
// TODO: support clipboard
if (!_allowedFileExtensions.Contains(Path.GetExtension(fileToUpload.FileName), StringComparer.OrdinalIgnoreCase))
{
result = new
{
name = fileToUpload.FileName,
size = fileToUpload.Length,
folder = path,
error = S["This file extension is not allowed: {0}", Path.GetExtension(fileToUpload.FileName)]
.ToString()
};
_logger.LogInformation("File extension not allowed: '{0}'", fileToUpload.FileName);
// continue;
}
else
{
Stream stream = null;
try
{
var mediaFilePath = _mediaFileStore.Combine(path, fileToUpload.FileName);
stream = fileToUpload.OpenReadStream();
mediaFilePath = await _mediaFileStore.CreateFileFromStreamAsync(mediaFilePath, stream);
var mediaFile = await _mediaFileStore.GetFileInfoAsync(mediaFilePath);
result = CreateFileResult(mediaFile);
}
catch (Exception ex)
{
_logger.LogError(ex, "An error occurred while uploading a media");
result = new { name = fileToUpload.FileName, size = fileToUpload.Length, folder = path, error = ex.Message };
}
finally
{
stream?.Dispose();
}
}
//}
}
return(Json(result));
}
/// <summary>
/// Processes a request to determine if it matches a known file from the media file store, and cache it locally.
/// </summary>
/// <param name="context"></param>
public async Task Invoke(HttpContext context)
{
// Support only Head requests or Get Requests.
if (!HttpMethods.IsGet(context.Request.Method) && !HttpMethods.IsHead(context.Request.Method))
{
await _next(context);
return;
}
var validatePath = context.Request.Path.StartsWithNormalizedSegments(_assetsRequestPath, StringComparison.OrdinalIgnoreCase, out var subPath);
if (!validatePath)
{
_logger.LogDebug("Request path {Path} does not match the assets request path {RequestPath}", subPath, _assetsRequestPath);
await _next(context);
return;
}
// subpath.Value returns an unescaped path value, subPath returns an escaped path value.
var subPathValue = subPath.Value;
var isFileCached = await _mediaFileStoreCache.IsCachedAsync(subPathValue);
if (isFileCached)
{
// When multiple requests occur for the same file the download
// may already be in progress so we wait for it to complete.
if (Workers.TryGetValue(subPathValue, out var writeTask))
{
await writeTask.Value;
}
await _next(context);
return;
}
// When multiple requests occur for the same file we use a Lazy<Task>
// to initialize the file store request once.
await Workers.GetOrAdd(subPathValue, x => new Lazy <Task>(async() =>
{
try
{
var fileStoreEntry = await _mediaFileStore.GetFileInfoAsync(subPathValue);
if (fileStoreEntry != null)
{
using (var stream = await _mediaFileStore.GetFileStreamAsync(fileStoreEntry))
{
await _mediaFileStoreCache.SetCacheAsync(stream, fileStoreEntry, context.RequestAborted);
}
}
}
catch (Exception ex)
{
// Log the error, and pass to pipeline to handle as 404.
// Multiple requests at the same time will all recieve the same 404
// as we use LazyThreadSafetyMode.ExecutionAndPublication.
_logger.LogError(ex, "Error retrieving file from media file store for request path {Path}", subPathValue);
}
finally
{
Workers.TryRemove(subPathValue, out var writeTask);
}
}, LazyThreadSafetyMode.ExecutionAndPublication)).Value;
// Always call next, this middleware always passes.
await _next(context);
return;
}
