public void Save(MediaFile mediaFile, MediaStorageItem item) { Guard.NotNull(mediaFile, nameof(mediaFile)); // TODO: (?) if the new file extension differs from the old one then the old file never gets deleted var filePath = GetPath(mediaFile); if (item != null) { // Create folder if it does not exist yet var dir = Path.GetDirectoryName(filePath); if (!_fileSystem.FolderExists(dir)) { _fileSystem.CreateFolder(dir); } using (item) { using var outStream = _fileSystem.GetFile(filePath).OpenWrite(); item.SaveTo(outStream, mediaFile); } } else if (_fileSystem.FileExists(filePath)) { // Remove media storage if any _fileSystem.DeleteFile(filePath); } }
public void Save(MediaItem media, byte[] data) { Guard.NotNull(media, nameof(media)); // TODO: (?) if the new file extension differs from the old one then the old file never gets deleted var filePath = GetPicturePath(media); if (data != null && data.LongLength != 0) { _fileSystem.WriteAllBytes(filePath, data); } else if (_fileSystem.FileExists(filePath)) { _fileSystem.DeleteFile(filePath); } }
public void Save(MediaFile mediaFile, byte[] data) { Guard.NotNull(mediaFile, nameof(mediaFile)); // TODO: (?) if the new file extension differs from the old one then the old file never gets deleted var filePath = GetPath(mediaFile); if (data != null && data.LongLength > 0) { _fileSystem.WriteAllBytes(filePath, data); } else if (_fileSystem.FileExists(filePath)) { // Remove media storage if any _fileSystem.DeleteFile(filePath); } }
public virtual void Delete(MediaFile picture) { var filter = string.Format("{0}*.*", picture.Id.ToString(IdFormatString)); var files = _fileSystem.SearchFiles(_thumbsRootDir, filter); foreach (var file in files) { _fileSystem.DeleteFile(file); } }
private bool PrepareAddImageToCache(CachedImageResult cachedImage, byte[] buffer) { Guard.NotNull(cachedImage, nameof(cachedImage)); if (buffer == null || buffer.Length == 0) { return(false); } if (cachedImage.Exists) { _fileSystem.DeleteFile(BuildPath(cachedImage.Path)); } // create folder if needed string imageDir = System.IO.Path.GetDirectoryName(cachedImage.Path); if (imageDir.HasValue()) { _fileSystem.TryCreateFolder(BuildPath(imageDir)); } return(true); }
private bool PreparePut(CachedImage cachedImage, Stream stream) { Guard.NotNull(cachedImage, nameof(cachedImage)); if (stream == null) { return(false); } if (cachedImage.Exists) { _fileSystem.DeleteFile(BuildPath(cachedImage.Path)); } // create folder if needed string imageDir = System.IO.Path.GetDirectoryName(cachedImage.Path); if (imageDir.HasValue()) { _fileSystem.CreateFolder(BuildPath(imageDir)); } return(true); }
private void DeleteFile(string path) { path = GetRelativePath(path); var file = _fileSystem.GetFile(path); if (!file.Exists) { throw new FileNotFoundException($"File {path} does not exist.", path); } try { _fileSystem.DeleteFile(path); Response.Write(GetResultString()); } catch (Exception ex) { throw ex; } }
private void DeleteFile(string path) { path = GetRelativePath(path); if (!_fileSystem.FileExists(path)) { throw new Exception(LangRes("E_DeleteFileInvalidPath")); } try { _fileSystem.DeleteFile(path); Response.Write(GetResultString()); } catch { throw new Exception(LangRes("E_DeletеFile")); } }
private void UpdateMediaFile(IMedia media, bool obfuscate) { if (!media.Properties.Contains(Constants.Conventions.Media.File)) { // not a media file, so ignore return; } var file = media.Properties[Constants.Conventions.Media.File]; var fileSrc = file.GetValue()?.ToString(); if (fileSrc.DetectIsJson()) { fileSrc = JsonConvert.DeserializeObject <JObject>(fileSrc).GetValue("src")?.ToString(); } var fileDirectory = Path.GetDirectoryName(fileSrc); var fileName = Path.GetFileName(fileSrc); if (obfuscate && fileName.StartsWith(deletedMediaPrefix)) { // already renamed, nothing to do here return; } else if (!obfuscate && !fileName.StartsWith(deletedMediaPrefix)) { // doesn't have the prefix, nothing to do here return; } var oldFilePath = Path.Combine(fileDirectory, fileName); var newFilePath = Path.Combine(fileDirectory, (obfuscate ? deletedMediaPrefix + fileName : fileName.TrimStart(deletedMediaPrefix))); _mediaFileSystem.CopyFile(oldFilePath, newFilePath); _mediaFileSystem.DeleteFile(oldFilePath); file.SetValue(newFilePath); _mediaService.Save(media, raiseEvents: false); }
private void DeleteFile(string path) { path = GetRelativePath(path); var file = _fileSystem.GetFile(path); if (!file.Exists) { throw new Exception(LangRes("E_DeleteFileInvalidPath")); } try { _fileSystem.DeleteFile(path); _imageCache.Value.Delete(file); Response.Write(GetResultString()); } catch (Exception ex) { throw new Exception(LangRes("E_DeletеFile") + ": " + ex.Message); } }
/// <summary> /// Converts the value received from the editor into the value can be stored in the database. /// </summary> /// <param name="editorValue">The value received from the editor.</param> /// <param name="currentValue">The current value of the property</param> /// <returns>The converted value.</returns> /// <remarks> /// <para>The <paramref name="currentValue"/> is used to re-use the folder, if possible.</para> /// <para>editorValue.Value is used to figure out editorFile and, if it has been cleared, remove the old file - but /// it is editorValue.AdditionalData["files"] that is used to determine the actual file that has been uploaded.</para> /// </remarks> public override object FromEditor(ContentPropertyData editorValue, object currentValue) { // get the current path var currentPath = string.Empty; try { var svalue = currentValue as string; var currentJson = string.IsNullOrWhiteSpace(svalue) ? null : JObject.Parse(svalue); if (currentJson != null && currentJson["src"] != null) { currentPath = currentJson["src"].Value <string>(); } } catch (Exception ex) { // for some reason the value is invalid so continue as if there was no value there _logger.Warn <ImageCropperPropertyValueEditor>(ex, "Could not parse current db value to a JObject."); } if (string.IsNullOrWhiteSpace(currentPath) == false) { currentPath = _mediaFileSystem.GetRelativePath(currentPath); } // get the new json and path JObject editorJson = null; var editorFile = string.Empty; if (editorValue.Value != null) { editorJson = editorValue.Value as JObject; if (editorJson != null && editorJson["src"] != null) { editorFile = editorJson["src"].Value <string>(); } } // ensure we have the required guids var cuid = editorValue.ContentKey; if (cuid == Guid.Empty) { throw new Exception("Invalid content key."); } var puid = editorValue.PropertyTypeKey; if (puid == Guid.Empty) { throw new Exception("Invalid property type key."); } // editorFile is empty whenever a new file is being uploaded // or when the file is cleared (in which case editorJson is null) // else editorFile contains the unchanged value var uploads = editorValue.Files; if (uploads == null) { throw new Exception("Invalid files."); } var file = uploads.Length > 0 ? uploads[0] : null; if (file == null) // not uploading a file { // if editorFile is empty then either there was nothing to begin with, // or it has been cleared and we need to remove the file - else the // value is unchanged. if (string.IsNullOrWhiteSpace(editorFile) && string.IsNullOrWhiteSpace(currentPath) == false) { _mediaFileSystem.DeleteFile(currentPath); return(null); // clear } return(editorJson?.ToString()); // unchanged } // process the file var filepath = editorJson == null ? null : ProcessFile(editorValue, file, currentPath, cuid, puid); // remove all temp files foreach (var f in uploads) { File.Delete(f.TempFilePath); } // remove current file if replaced if (currentPath != filepath && string.IsNullOrWhiteSpace(currentPath) == false) { _mediaFileSystem.DeleteFile(currentPath); } // update json and return if (editorJson == null) { return(null); } editorJson["src"] = filepath == null ? string.Empty : _mediaFileSystem.GetUrl(filepath); return(editorJson.ToString()); }
/// <summary> /// Converts the value received from the editor into the value can be stored in the database. /// </summary> /// <param name="editorValue">The value received from the editor.</param> /// <param name="currentValue">The current value of the property</param> /// <returns>The converted value.</returns> /// <remarks> /// <para>The <paramref name="currentValue"/> is used to re-use the folder, if possible.</para> /// <para>The <paramref name="editorValue"/> is value passed in from the editor. We normally don't care what /// the editorValue.Value is set to because we are more interested in the files collection associated with it, /// however we do care about the value if we are clearing files. By default the editorValue.Value will just /// be set to the name of the file - but again, we just ignore this and deal with the file collection in /// editorValue.AdditionalData.ContainsKey("files")</para> /// <para>We only process ONE file. We understand that the current value may contain more than one file, /// and that more than one file may be uploaded, so we take care of them all, but we only store ONE file. /// Other places (FileUploadPropertyEditor...) do NOT deal with multiple files, and our logic for reusing /// folders would NOT work, etc.</para> /// </remarks> public override object FromEditor(ContentPropertyData editorValue, object currentValue) { var currentPath = currentValue as string; if (!currentPath.IsNullOrWhiteSpace()) { currentPath = _mediaFileSystem.GetRelativePath(currentPath); } string editorFile = null; if (editorValue.Value != null) { editorFile = editorValue.Value as string; } // ensure we have the required guids var cuid = editorValue.ContentKey; if (cuid == Guid.Empty) { throw new Exception("Invalid content key."); } var puid = editorValue.PropertyTypeKey; if (puid == Guid.Empty) { throw new Exception("Invalid property type key."); } var uploads = editorValue.Files; if (uploads == null) { throw new Exception("Invalid files."); } var file = uploads.Length > 0 ? uploads[0] : null; if (file == null) // not uploading a file { // if editorFile is empty then either there was nothing to begin with, // or it has been cleared and we need to remove the file - else the // value is unchanged. if (string.IsNullOrWhiteSpace(editorFile) && string.IsNullOrWhiteSpace(currentPath) == false) { _mediaFileSystem.DeleteFile(currentPath); return(null); // clear } return(currentValue); // unchanged } // process the file var filepath = editorFile == null ? null : ProcessFile(editorValue, file, currentPath, cuid, puid); // remove all temp files foreach (var f in uploads) { File.Delete(f.TempFilePath); } // remove current file if replaced if (currentPath != filepath && string.IsNullOrWhiteSpace(currentPath) == false) { _mediaFileSystem.DeleteFile(currentPath); } // update json and return if (editorFile == null) { return(null); } return(filepath == null ? string.Empty : _mediaFileSystem.GetUrl(filepath)); }