private async Task <XRpcStruct> MetaWeblogNewMediaObjectAsync(string userName, string password, XRpcStruct file)
{
var user = await ValidateUserAsync(userName, password);
var name = file.Optional <string>("name");
var bits = file.Optional <byte[]>("bits");
var directoryName = Path.GetDirectoryName(name);
var filePath = _mediaFileStore.Combine(directoryName, Path.GetFileName(name));
Stream stream = null;
try
{
stream = new MemoryStream(bits);
filePath = await _mediaFileStore.CreateFileFromStreamAsync(filePath, stream);
}
finally
{
stream?.Dispose();
}
var publicUrl = _mediaFileStore.MapPathToPublicUrl(filePath);
return(new XRpcStruct() // Some clients require all optional attributes to be declared Wordpress responds in this way as well.
.Set("file", publicUrl)
.Set("url", publicUrl)
.Set("type", file.Optional <string>("type")));
}
public AttachedMediaFieldFileService(IMediaFileStore fileStore,
ILogger <AttachedMediaFieldFileService> logger)
{
_fileStore = fileStore;
_logger = logger;
MediaFieldsFolder = "mediafields";
MediaFieldsTempSubFolder = _fileStore.Combine(MediaFieldsFolder, "temp");
}
public async Task <IActionResult> CustomCss()
{
var model = new Editor();
var pathFile = _mediaFileStore.Combine("assets", "custom", "style.css");
var file = await _mediaFileStore.GetFileInfo(pathFile);
if (file != null)
{
model.Content = await _mediaFileStore.ReadAllText(pathFile);
}
if (string.IsNullOrEmpty(model.Content))
{
model.Content = "/* my custom style */";
}
return(View(model));
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="pictureRepository">Picture repository</param>
/// <param name="logger">Logger</param>
/// <param name="mediator">Mediator</param>
/// <param name="hostingEnvironment">hostingEnvironment</param>
/// <param name="workContext">Current context</param>
/// <param name="cacheBase">Cache manager</param>
/// <param name="mediaFileStore">Media file storage</param>
/// <param name="mediaSettings">Media settings</param>
public PictureService(IRepository <Picture> pictureRepository,
ILogger logger,
IMediator mediator,
IWebHostEnvironment hostingEnvironment,
IWorkContext workContext,
ICacheBase cacheBase,
IMediaFileStore mediaFileStore,
MediaSettings mediaSettings)
{
_pictureRepository = pictureRepository;
_logger = logger;
_mediator = mediator;
_hostingEnvironment = hostingEnvironment;
_workContext = workContext;
_cacheBase = cacheBase;
_mediaFileStore = mediaFileStore;
_mediaSettings = mediaSettings;
_imagePath = _mediaFileStore.Combine("assets", "images");
_thumbPath = _mediaFileStore.Combine("assets", "images", "thumbs");
}
public async Task <ActionResult <IEnumerable <IFileStoreEntry> > > GetFolders(string path)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageMedia))
{
return(Forbid());
}
if (string.IsNullOrEmpty(path))
{
path = "";
}
if (await _mediaFileStore.GetDirectoryInfoAsync(path) == null)
{
return(NotFound());
}
// create default folders if not exist
if (await _authorizationService.AuthorizeAsync(User, Permissions.ManageOwnMedia) &&
await _mediaFileStore.GetDirectoryInfoAsync(_mediaFileStore.Combine(_mediaOptions.AssetsUsersFolder, _userAssetFolderNameProvider.GetUserAssetFolderName(User))) == null)
{
await _mediaFileStore.TryCreateDirectoryAsync(_mediaFileStore.Combine(_mediaOptions.AssetsUsersFolder, _userAssetFolderNameProvider.GetUserAssetFolderName(User)));
}
var allowed = _mediaFileStore.GetDirectoryContentAsync(path)
.WhereAwait(async e => e.IsDirectory && await _authorizationService.AuthorizeAsync(User, Permissions.ManageMediaFolder, (object)e.Path));
return(Ok(await allowed.ToListAsync()));
}
/// <summary>
/// Get picture (thumb) physical path
/// </summary>
/// <param name="thumbFileName">Filename</param>
/// <returns>Local picture physical path</returns>
protected virtual async Task <string> GetThumbPhysicalPath(string thumbFileName)
{
var thumbFile = _mediaFileStore.Combine(_thumbPath, thumbFileName);
var fileInfo = await _mediaFileStore.GetFileInfo(thumbFile);
return(fileInfo?.PhysicalPath);
}
public async Task <ActionResult> UploadFileToMediaPost(IFormFile file)
{
// You can use the Combine method to combine paths which is pretty much equivalent to the built-in method.
var mediaFilePath = _mediaFileStore.Combine(UploadedFileFolderRelativePath, file.FileName);
// In this case you already have a stream so use it to create the file.
using (var stream = file.OpenReadStream())
{
await _mediaFileStore.CreateFileFromStreamAsync(mediaFilePath, stream);
}
_notifier.Information(H["Successfully uploaded file!"]);
return(RedirectToAction(nameof(UploadFileToMedia)));
}
private async Task <XRpcStruct> MetaWeblogNewMediaObjectAsync(string userName, string password, XRpcStruct file)
{
var user = await ValidateUserAsync(userName, password);
var name = file.Optional <string>("name");
var bits = file.Optional <byte[]>("bits");
string directoryName = Path.GetDirectoryName(name);
string filePath = _mediaFileStore.Combine(directoryName, Path.GetFileName(name));
bool saved = await _mediaFileStore.TrySaveStreamAsync(filePath, new MemoryStream(bits));
string publicUrl = _mediaFileStore.GetPublicUrl(filePath);
return(new XRpcStruct() // Some clients require all optional attributes to be declared Wordpress responds in this way as well.
.Set("file", publicUrl)
.Set("url", publicUrl)
.Set("type", file.Optional <string>("type")));
}
protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, PermissionRequirement requirement)
{
if (context.HasSucceeded)
{
// This handler is not revoking any pre-existing grants.
return;
}
if (requirement.Permission.Name != Permissions.ManageAttachedMediaFieldsFolder.Name)
{
return;
}
if (context.Resource == null)
{
return;
}
_pathSeparator = _fileStore.Combine("a", "b").Contains("/") ? "/" : "\\";
// ensure end trailing slash
_mediaFieldsFolder = _fileStore.NormalizePath(_attachedMediaFieldFileService.MediaFieldsFolder)
.TrimEnd(_pathSeparator.ToCharArray()) + _pathSeparator;
var path = context.Resource as string;
if (!IsMediaFieldsFolder(path) && !IsDescendantOfMediaFieldsFolder(path))
{
context.Succeed(requirement);
}
// If we get to here, the path is on the media fields folder and the user must have the ManageMediaFieldsFolder permission.
// Lazy load to prevent circular dependencies
var authorizationService = _serviceProvider.GetService <IAuthorizationService>();
if (await authorizationService.AuthorizeAsync(context.User, Permissions.ManageAttachedMediaFieldsFolder))
{
context.Succeed(requirement);
}
}
public virtual async Task <IActionResult> Index(string fileName)
{
if (!_commonSettings.AllowToReadLetsEncryptFile)
{
return(Content(""));
}
if (fileName == null)
{
return(Content(""));
}
var filepath = _mediaFileStore.Combine("assets", "acme", Path.GetFileName(fileName));
var fileInfo = await _mediaFileStore.GetFileInfo(filepath);
if (fileInfo != null)
{
return(File(await _mediaFileStore.ReadAllText(filepath), "text/plain"));
}
return(Content(""));
}
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
}));
}
}
public async Task <ActionResult <object> > Upload(
string path,
string contentType,
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: '{0}'", 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, stream);
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 <ActionResult <object> > Upload(
string path,
string contentType,
ICollection <IFormFile> files)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageOwnMedia))
{
return(Unauthorized());
}
if (string.IsNullOrEmpty(path))
{
path = "";
}
var section = _shellConfiguration.GetSection("OrchardCore.Media");
// var maxUploadSize = section.GetValue("MaxRequestBodySize", 100_000_000);
var maxFileSize = section.GetValue("MaxFileSize", 30_000_000);
var allowedFileExtensions = section.GetValue("AllowedFileExtensions", DefaultAllowedFileExtensions);
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 = T["This file extension is not allowed: {0}", Path.GetExtension(file.FileName)].ToString()
});
_logger.LogInformation($"File extension not allowed: '{file.FileName}'");
continue;
}
if (file.Length > maxFileSize)
{
result.Add(new
{
name = file.FileName,
size = file.Length,
folder = path,
error = T["The file {0} is too big. The limit is {1}MB", file.FileName, (int)Math.Floor((double)maxFileSize / 1024 / 1024)].ToString()
});
_logger.LogInformation($"File too big: '{file.FileName}' ({file.Length}B)");
continue;
}
try
{
var mediaFilePath = _mediaFileStore.Combine(path, file.FileName);
using (var stream = file.OpenReadStream())
{
await _mediaFileStore.CreateFileFromStream(mediaFilePath, stream);
}
var mediaFile = await _mediaFileStore.GetFileInfoAsync(mediaFilePath);
result.Add(CreateFileResult(mediaFile));
}
catch (Exception ex)
{
_logger.LogError(ex, "An error occured while uploading a media");
result.Add(new
{
name = file.FileName,
size = file.Length,
folder = path,
error = ex.Message
});
}
}
return(new { files = result.ToArray() });
}
// Newly added files
private async Task <object> MoveNewFilesToContentItemDirAndUpdatePaths1(IFormFile fileToUpload, ContentItem contentItem)
{
// Generate Random name.
string extension = Utils.GetFileExtension(fileToUpload.FileName);
// string name = $"{Utils.GenerateUniqueString()}.{extension}";
string uniqueName = Utils.GenerateUniqueString();
string name = $"{uniqueName}.{extension}";
// string link = fileRoute + name;
var targetDir = GetContentItemFolder(contentItem);
// var finalFileName = (await GetFileHashAsync(x.Path)) + GetFileExtension(x.Path);
var finalFileName = name;//(await GetFileHashAsync(uniqueName)) + extension;// GetFileExtension(x.Path);
var finalFilePath = _fileStore.Combine(targetDir, finalFileName);
// string link = finalFilePath;
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 = (await _fileStore.GetFileInfoAsync(x.Path)).DirectoryPath;
//var previousDirPath = (await _fileStore.GetFileInfoAsync(name)).DirectoryPath;
// fileName is a hash of the file. We preserve disk space by reusing the file.
//if (await _fileStore.GetFileInfoAsync(finalFilePath) == null)
//{
// Copy contents to memory stream.
Stream stream;
stream = new MemoryStream();
fileToUpload.CopyTo(stream);
stream.Position = 0;
// await _fileStore.MoveFileAsync(x.Path, finalFilePath);
await _fileStore.CreateFileFromStreamAsync(finalFilePath, stream); // ..MoveFileAsync(x.Path, finalFilePath);
//}
// x.Path = finalFilePath;
//await DeleteDirIfEmpty(previousDirPath);
string link = _fileStore.MapPathToPublicUrl(finalFilePath);
// Make sure it is compatible with ASP.NET Core.
return(new { link = link });
// return new { link = Path.Combine( "/media/" ,link) };
// return new { link = link.Replace("wwwroot/", "/") };
/*
* items.Where(x => !x.IsRemoved).ToList()
* .ForEach(async x =>
* {
* var targetDir = GetContentItemFolder(contentItem);
* var finalFileName = (await GetFileHashAsync(x.Path)) + GetFileExtension(x.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 = (await _fileStore.GetFileInfoAsync(x.Path)).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(x.Path, finalFilePath);
* }
*
* x.Path = finalFilePath;
*
* await DeleteDirIfEmpty(previousDirPath);
*
* });
*/
}
public virtual async Task <IActionResult> AsyncLogoUpload()
{
if (!await _permissionService.Authorize(StandardPermission.ManageSettings))
{
return(Content("Access denied"));
}
var form = await HttpContext.Request.ReadFormAsync();
var httpPostedFile = form.Files.FirstOrDefault();
if (httpPostedFile == null)
{
return(Json(new
{
success = false,
message = "No file uploaded",
}));
}
var qqFileNameParameter = "qqfilename";
var fileName = httpPostedFile.FileName;
if (String.IsNullOrEmpty(fileName) && form.ContainsKey(qqFileNameParameter))
{
fileName = form[qqFileNameParameter].ToString();
}
fileName = Path.GetFileName(fileName);
var contentType = httpPostedFile.ContentType;
var fileExtension = Path.GetExtension(fileName);
if (!String.IsNullOrEmpty(fileExtension))
{
fileExtension = fileExtension.ToLowerInvariant();
}
if (!GetAllowedFileTypes().Contains(fileExtension))
{
return(Json(new
{
success = false,
message = "File no allowed"
}));
}
//contentType is not always available
//that's why we manually update it here
//http://www.sfsu.edu/training/mimetype.htm
if (String.IsNullOrEmpty(contentType))
{
switch (fileExtension)
{
case ".bmp":
contentType = "image/bmp";
break;
case ".gif":
contentType = "image/gif";
break;
case ".jpeg":
case ".jpg":
case ".jpe":
case ".jfif":
case ".pjpeg":
case ".pjp":
contentType = "image/jpeg";
break;
case ".png":
contentType = "image/png";
break;
case ".tiff":
case ".tif":
contentType = "image/tiff";
break;
default:
break;
}
}
if (String.IsNullOrEmpty(contentType))
{
return(Json(new
{
success = false,
message = "Unknown content type"
}));
}
fileName = fileName.Replace(" ", "");
var fileInfo = await _mediaFileStore.GetFileInfo(fileName);
if (fileInfo == null)
{
try
{
var filepath = _mediaFileStore.GetDirectoryInfo("");
if (filepath != null)
{
using (var stream = new FileStream(_mediaFileStore.Combine(filepath.PhysicalPath, fileName), FileMode.OpenOrCreate))
{
httpPostedFile.CopyTo(stream);
}
return(Json(new
{
success = true,
imageUrl = fileName
}));
}
else
{
return(Json(new
{
success = false,
message = "Physical path not exist"
}));
}
}
catch (Exception ex)
{
return(Json(new
{
success = false,
message = ex.Message
}));
}
}
return(Json(new
{
success = false,
message = "This filename exists"
}));
}
public async Task <ActionResult> Upload(
string path,
string contentType,
ICollection <IFormFile> files)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageOwnMedia))
{
return(Unauthorized());
}
if (string.IsNullOrEmpty(path))
{
path = "";
}
var result = new List <object>();
// TODO: Validate file extensions
// Loop through each file in the request
foreach (var file in files)
{
// TODO: support clipboard
try
{
var mediaFilePath = _mediaFileStore.Combine(path, file.FileName);
using (var stream = file.OpenReadStream())
{
if (!await _mediaFileStore.TrySaveStreamAsync(mediaFilePath, stream))
{
result.Add(new
{
name = file.FileName,
size = file.Length,
folder = path,
error = "Couldn't copy the file in the media store"
});
}
}
var mediaFile = await _mediaFileStore.GetFileAsync(mediaFilePath);
result.Add(CreateFileResult(mediaFile));
}
catch (Exception ex)
{
_logger.LogError("An error occured while uploading a media: " + ex.Message);
result.Add(new
{
name = file.FileName,
size = file.Length,
folder = path,
error = ex.Message
});
}
}
return(Json(new { files = result.ToArray() }));
}
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));
}
