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)); }