713 lines
32 KiB
C#
713 lines
32 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using LightInject;
|
|
using Umbraco.Core.Configuration;
|
|
using Umbraco.Core.Configuration.UmbracoSettings;
|
|
using Umbraco.Core.Composing;
|
|
using Umbraco.Core.Exceptions;
|
|
using Umbraco.Core.Logging;
|
|
using Umbraco.Core.Media;
|
|
using Umbraco.Core.Media.Exif;
|
|
using Umbraco.Core.Models;
|
|
|
|
namespace Umbraco.Core.IO
|
|
{
|
|
/// <summary>
|
|
/// A custom file system provider for media
|
|
/// </summary>
|
|
[FileSystemProvider("media")]
|
|
public class MediaFileSystem : FileSystemWrapper
|
|
{
|
|
private readonly object _folderCounterLock = new object();
|
|
private long _folderCounter;
|
|
private bool _folderCounterInitialized;
|
|
|
|
// fixme - remove
|
|
//private static readonly Dictionary<int, string> DefaultSizes = new Dictionary<int, string>
|
|
//{
|
|
// { 100, "thumb" },
|
|
// { 500, "big-thumb" }
|
|
//};
|
|
|
|
public MediaFileSystem(IFileSystem wrapped)
|
|
: base(wrapped)
|
|
{
|
|
// due to how FileSystems is written at the moment, the ctor cannot be used to inject
|
|
// dependencies, so we have to rely on property injection for anything we might need
|
|
Current.Container.InjectProperties(this);
|
|
|
|
UploadAutoFillProperties = new UploadAutoFillProperties(this, Logger, ContentConfig);
|
|
}
|
|
|
|
[Inject]
|
|
internal IContentSection ContentConfig { get; set; }
|
|
|
|
[Inject]
|
|
internal ILogger Logger { get; set; }
|
|
|
|
internal UploadAutoFillProperties UploadAutoFillProperties { get; }
|
|
|
|
// note - this is currently experimental / being developed
|
|
//public static bool UseTheNewMediaPathScheme { get; set; }
|
|
public const bool UseTheNewMediaPathScheme = false;
|
|
|
|
/// <summary>
|
|
/// Deletes all files passed in.
|
|
/// </summary>
|
|
/// <param name="files"></param>
|
|
/// <param name="onError"></param>
|
|
/// <returns></returns>
|
|
internal bool DeleteFiles(IEnumerable<string> files, Action<string, Exception> onError = null)
|
|
{
|
|
//ensure duplicates are removed
|
|
files = files.Distinct();
|
|
|
|
var allsuccess = true;
|
|
var rootRelativePath = GetRelativePath("/");
|
|
|
|
Parallel.ForEach(files, file =>
|
|
{
|
|
try
|
|
{
|
|
if (file.IsNullOrWhiteSpace()) return;
|
|
|
|
var relativeFilePath = GetRelativePath(file);
|
|
if (FileExists(relativeFilePath) == false) return;
|
|
|
|
var parentDirectory = Path.GetDirectoryName(relativeFilePath);
|
|
|
|
// don't want to delete the media folder if not using directories.
|
|
if (ContentConfig.UploadAllowDirectories && parentDirectory != rootRelativePath)
|
|
{
|
|
//issue U4-771: if there is a parent directory the recursive parameter should be true
|
|
DeleteDirectory(parentDirectory, string.IsNullOrEmpty(parentDirectory) == false);
|
|
}
|
|
else
|
|
{
|
|
DeleteFile(file);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
onError?.Invoke(file, e);
|
|
allsuccess = false;
|
|
}
|
|
});
|
|
|
|
return allsuccess;
|
|
}
|
|
|
|
public void DeleteMediaFiles(IEnumerable<string> files)
|
|
{
|
|
files = files.Distinct();
|
|
|
|
Parallel.ForEach(files, file =>
|
|
{
|
|
try
|
|
{
|
|
if (file.IsNullOrWhiteSpace()) return;
|
|
if (FileExists(file) == false) return;
|
|
DeleteFile(file);
|
|
|
|
#pragma warning disable 162 // unreachable code
|
|
// Not implemented yet, so need to disable warnings
|
|
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
|
|
if (UseTheNewMediaPathScheme == false)
|
|
{
|
|
// old scheme: filepath is "<int>/<filename>" OR "<int>-<filename>"
|
|
// remove the directory if any
|
|
var dir = Path.GetDirectoryName(file);
|
|
if (string.IsNullOrWhiteSpace(dir) == false)
|
|
DeleteDirectory(dir, true);
|
|
}
|
|
else
|
|
{
|
|
// new scheme: path is "<xuid>/<filename>" where xuid is a combination of cuid and puid
|
|
// remove the directory
|
|
var dir = Path.GetDirectoryName(file);
|
|
DeleteDirectory(dir, true);
|
|
}
|
|
#pragma warning restore 162
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logger.Error<MediaFileSystem>("Failed to delete attached file \"" + file + "\".", e);
|
|
}
|
|
});
|
|
}
|
|
|
|
#region Media Path
|
|
|
|
/// <summary>
|
|
/// Gets the file path of a media file.
|
|
/// </summary>
|
|
/// <param name="filename">The file name.</param>
|
|
/// <param name="cuid">The unique identifier of the content/media owning the file.</param>
|
|
/// <param name="puid">The unique identifier of the property type owning the file.</param>
|
|
/// <returns>The filesystem-relative path to the media file.</returns>
|
|
/// <remarks>With the old media path scheme, this CREATES a new media path each time it is invoked.</remarks>
|
|
public string GetMediaPath(string filename, Guid cuid, Guid puid)
|
|
{
|
|
filename = Path.GetFileName(filename);
|
|
if (filename == null) throw new ArgumentException("Cannot become a safe filename.", nameof(filename));
|
|
filename = IOHelper.SafeFileName(filename.ToLowerInvariant());
|
|
|
|
string folder;
|
|
#pragma warning disable 162 // unreachable code
|
|
// Not implemented yet, so need to disable warnings
|
|
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
|
|
if (UseTheNewMediaPathScheme == false)
|
|
{
|
|
// old scheme: filepath is "<int>/<filename>" OR "<int>-<filename>"
|
|
// default media filesystem maps to "~/media/<filepath>"
|
|
folder = GetNextFolder();
|
|
}
|
|
else
|
|
{
|
|
// new scheme: path is "<xuid>/<filename>" where xuid is a combination of cuid and puid
|
|
// default media filesystem maps to "~/media/<filepath>"
|
|
// assumes that cuid and puid keys can be trusted - and that a single property type
|
|
// for a single content cannot store two different files with the same name
|
|
folder = Combine(cuid, puid).ToHexString(/*'/', 2, 4*/); // could use ext to fragment path eg 12/e4/f2/...
|
|
}
|
|
#pragma warning restore 162
|
|
|
|
var filepath = UmbracoConfig.For.UmbracoSettings().Content.UploadAllowDirectories
|
|
? Path.Combine(folder, filename).Replace('\\', '/')
|
|
: folder + "-" + filename;
|
|
|
|
return filepath;
|
|
}
|
|
|
|
private static byte[] Combine(Guid guid1, Guid guid2)
|
|
{
|
|
var bytes1 = guid1.ToByteArray();
|
|
var bytes2 = guid2.ToByteArray();
|
|
var bytes = new byte[bytes1.Length];
|
|
for (var i = 0; i < bytes1.Length; i++)
|
|
bytes[i] = (byte) (bytes1[i] ^ bytes2[i]);
|
|
return bytes;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the file path of a media file.
|
|
/// </summary>
|
|
/// <param name="filename">The file name.</param>
|
|
/// <param name="prevpath">A previous file path.</param>
|
|
/// <param name="cuid">The unique identifier of the content/media owning the file.</param>
|
|
/// <param name="puid">The unique identifier of the property type owning the file.</param>
|
|
/// <returns>The filesystem-relative path to the media file.</returns>
|
|
/// <remarks>In the old, legacy, number-based scheme, we try to re-use the media folder
|
|
/// specified by <paramref name="prevpath"/>. Else, we CREATE a new one. Each time we are invoked.</remarks>
|
|
public string GetMediaPath(string filename, string prevpath, Guid cuid, Guid puid)
|
|
{
|
|
if (UseTheNewMediaPathScheme || string.IsNullOrWhiteSpace(prevpath))
|
|
return GetMediaPath(filename, cuid, puid);
|
|
|
|
filename = Path.GetFileName(filename);
|
|
if (filename == null) throw new ArgumentException("Cannot become a safe filename.", nameof(filename));
|
|
filename = IOHelper.SafeFileName(filename.ToLowerInvariant());
|
|
|
|
// old scheme, with a previous path
|
|
// prevpath should be "<int>/<filename>" OR "<int>-<filename>"
|
|
// and we want to reuse the "<int>" part, so try to find it
|
|
|
|
var sep = UmbracoConfig.For.UmbracoSettings().Content.UploadAllowDirectories ? "/" : "-";
|
|
var pos = prevpath.IndexOf(sep, StringComparison.Ordinal);
|
|
var s = pos > 0 ? prevpath.Substring(0, pos) : null;
|
|
|
|
var folder = (pos > 0 && int.TryParse(s, out _)) ? s : GetNextFolder();
|
|
|
|
// ReSharper disable once AssignNullToNotNullAttribute
|
|
var filepath = UmbracoConfig.For.UmbracoSettings().Content.UploadAllowDirectories
|
|
? Path.Combine(folder, filename)
|
|
: folder + "-" + filename;
|
|
|
|
return filepath;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the next media folder in the original number-based scheme.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
/// <remarks>Should be private, is internal for legacy FileHandlerData which is obsolete.</remarks>
|
|
internal string GetNextFolder()
|
|
{
|
|
EnsureFolderCounterIsInitialized();
|
|
return Interlocked.Increment(ref _folderCounter).ToString(CultureInfo.InvariantCulture);
|
|
}
|
|
|
|
private void EnsureFolderCounterIsInitialized()
|
|
{
|
|
lock (_folderCounterLock)
|
|
{
|
|
if (_folderCounterInitialized) return;
|
|
|
|
_folderCounter = 1000; // seed
|
|
var directories = GetDirectories("");
|
|
foreach (var directory in directories)
|
|
{
|
|
if (long.TryParse(directory, out var folderNumber) && folderNumber > _folderCounter)
|
|
_folderCounter = folderNumber;
|
|
}
|
|
|
|
// note: not multi-domains ie LB safe as another domain could create directories
|
|
// while we read and parse them - don't fix, move to new scheme eventually
|
|
|
|
_folderCounterInitialized = true;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Associated Media Files
|
|
|
|
/// <summary>
|
|
/// Stores a media file associated to a property of a content item.
|
|
/// </summary>
|
|
/// <param name="content">The content item owning the media file.</param>
|
|
/// <param name="propertyType">The property type owning the media file.</param>
|
|
/// <param name="filename">The media file name.</param>
|
|
/// <param name="filestream">A stream containing the media bytes.</param>
|
|
/// <param name="oldpath">An optional filesystem-relative filepath to the previous media file.</param>
|
|
/// <returns>The filesystem-relative filepath to the media file.</returns>
|
|
/// <remarks>
|
|
/// <para>The file is considered "owned" by the content/propertyType.</para>
|
|
/// <para>If an <paramref name="oldpath"/> is provided then that file (and associated thumbnails if any) is deleted
|
|
/// before the new file is saved, and depending on the media path scheme, the folder may be reused for the new file.</para>
|
|
/// </remarks>
|
|
public string StoreFile(IContentBase content, PropertyType propertyType, string filename, Stream filestream, string oldpath)
|
|
{
|
|
if (content == null) throw new ArgumentNullException(nameof(content));
|
|
if (propertyType == null) throw new ArgumentNullException(nameof(propertyType));
|
|
if (string.IsNullOrWhiteSpace(filename)) throw new ArgumentNullOrEmptyException(nameof(filename));
|
|
if (filestream == null) throw new ArgumentNullException(nameof(filestream));
|
|
|
|
// clear the old file, if any
|
|
if (string.IsNullOrWhiteSpace(oldpath) == false)
|
|
DeleteFile(oldpath);
|
|
|
|
// get the filepath, store the data
|
|
// use oldpath as "prevpath" to try and reuse the folder, in original number-based scheme
|
|
var filepath = GetMediaPath(filename, oldpath, content.Key, propertyType.Key);
|
|
AddFile(filepath, filestream);
|
|
return filepath;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies a media file as a new media file, associated to a property of a content item.
|
|
/// </summary>
|
|
/// <param name="content">The content item owning the copy of the media file.</param>
|
|
/// <param name="propertyType">The property type owning the copy of the media file.</param>
|
|
/// <param name="sourcepath">The filesystem-relative path to the source media file.</param>
|
|
/// <returns>The filesystem-relative path to the copy of the media file.</returns>
|
|
public string CopyFile(IContentBase content, PropertyType propertyType, string sourcepath)
|
|
{
|
|
if (content == null) throw new ArgumentNullException(nameof(content));
|
|
if (propertyType == null) throw new ArgumentNullException(nameof(propertyType));
|
|
if (string.IsNullOrWhiteSpace(sourcepath)) throw new ArgumentNullOrEmptyException(nameof(sourcepath));
|
|
|
|
// ensure we have a file to copy
|
|
if (FileExists(sourcepath) == false) return null;
|
|
|
|
// get the filepath
|
|
var filename = Path.GetFileName(sourcepath);
|
|
var filepath = GetMediaPath(filename, content.Key, propertyType.Key);
|
|
this.CopyFile(sourcepath, filepath);
|
|
return filepath;
|
|
}
|
|
|
|
// gets or creates a property for a content item.
|
|
private static Property GetProperty(IContentBase content, string propertyTypeAlias)
|
|
{
|
|
var property = content.Properties.FirstOrDefault(x => x.Alias.InvariantEquals(propertyTypeAlias));
|
|
if (property != null) return property;
|
|
|
|
var propertyType = content.GetContentType().CompositionPropertyTypes
|
|
.FirstOrDefault(x => x.Alias.InvariantEquals(propertyTypeAlias));
|
|
if (propertyType == null)
|
|
throw new Exception("No property type exists with alias " + propertyTypeAlias + ".");
|
|
|
|
property = new Property(propertyType);
|
|
content.Properties.Add(property);
|
|
return property;
|
|
}
|
|
|
|
// fixme - what's below belongs to the upload property editor, not the media filesystem!
|
|
|
|
public void SetUploadFile(IContentBase content, string propertyTypeAlias, string filename, Stream filestream, string culture = null, string segment = null)
|
|
{
|
|
var property = GetProperty(content, propertyTypeAlias);
|
|
var oldpath = property.GetValue(culture, segment) is string svalue ? GetRelativePath(svalue) : null;
|
|
var filepath = StoreFile(content, property.PropertyType, filename, filestream, oldpath);
|
|
property.SetValue(GetUrl(filepath), culture, segment);
|
|
SetUploadFile(content, property, filepath, filestream, culture, segment);
|
|
}
|
|
|
|
public void SetUploadFile(IContentBase content, string propertyTypeAlias, string filepath, string culture = null, string segment = null)
|
|
{
|
|
var property = GetProperty(content, propertyTypeAlias);
|
|
// fixme delete?
|
|
var oldpath = property.GetValue(culture, segment) is string svalue ? GetRelativePath(svalue) : null;
|
|
if (string.IsNullOrWhiteSpace(oldpath) == false && oldpath != filepath)
|
|
DeleteFile(oldpath);
|
|
property.SetValue(GetUrl(filepath), culture, segment);
|
|
using (var filestream = OpenFile(filepath))
|
|
{
|
|
SetUploadFile(content, property, filepath, filestream, culture, segment);
|
|
}
|
|
}
|
|
|
|
// sets a file for the FileUpload property editor
|
|
// ie generates thumbnails and populates autofill properties
|
|
private void SetUploadFile(IContentBase content, Property property, string filepath, Stream filestream, string culture = null, string segment = null)
|
|
{
|
|
// will use filepath for extension, and filestream for length
|
|
UploadAutoFillProperties.Populate(content, property.Alias, filepath, filestream, culture, segment);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Image
|
|
|
|
/// <summary>
|
|
/// Gets a value indicating whether the file extension corresponds to an image.
|
|
/// </summary>
|
|
/// <param name="extension">The file extension.</param>
|
|
/// <returns>A value indicating whether the file extension corresponds to an image.</returns>
|
|
public bool IsImageFile(string extension)
|
|
{
|
|
if (extension == null) return false;
|
|
extension = extension.TrimStart('.');
|
|
return ContentConfig.ImageFileTypes.InvariantContains(extension);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the dimensions of an image.
|
|
/// </summary>
|
|
/// <param name="stream">A stream containing the image bytes.</param>
|
|
/// <returns>The dimension of the image.</returns>
|
|
/// <remarks>First try with EXIF as it is faster and does not load the entire image
|
|
/// in memory. Fallback to GDI which means loading the image in memory and thus
|
|
/// use potentially large amounts of memory.</remarks>
|
|
public Size GetDimensions(Stream stream)
|
|
{
|
|
//Try to load with exif
|
|
try
|
|
{
|
|
var jpgInfo = ImageFile.FromStream(stream);
|
|
|
|
if (jpgInfo.Format != ImageFileFormat.Unknown
|
|
&& jpgInfo.Properties.ContainsKey(ExifTag.PixelYDimension)
|
|
&& jpgInfo.Properties.ContainsKey(ExifTag.PixelXDimension))
|
|
{
|
|
var height = Convert.ToInt32(jpgInfo.Properties[ExifTag.PixelYDimension].Value);
|
|
var width = Convert.ToInt32(jpgInfo.Properties[ExifTag.PixelXDimension].Value);
|
|
if (height > 0 && width > 0)
|
|
{
|
|
return new Size(width, height);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//We will just swallow, just means we can't read exif data, we don't want to log an error either
|
|
}
|
|
|
|
//we have no choice but to try to read in via GDI
|
|
using (var image = Image.FromStream(stream))
|
|
{
|
|
|
|
var fileWidth = image.Width;
|
|
var fileHeight = image.Height;
|
|
return new Size(fileWidth, fileHeight);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
// fixme - remove
|
|
|
|
//#region Manage thumbnails
|
|
|
|
//// note: this does not find 'custom' thumbnails?
|
|
//// will find _thumb and _big-thumb but NOT _custom?
|
|
//public IEnumerable<string> GetThumbnails(string path)
|
|
//{
|
|
// var parentDirectory = Path.GetDirectoryName(path);
|
|
// var extension = Path.GetExtension(path);
|
|
|
|
// return GetFiles(parentDirectory)
|
|
// .Where(x => x.StartsWith(path.TrimEnd(extension) + "_thumb") || x.StartsWith(path.TrimEnd(extension) + "_big-thumb"))
|
|
// .ToList();
|
|
//}
|
|
|
|
//public void DeleteFile(string path, bool deleteThumbnails)
|
|
//{
|
|
// base.DeleteFile(path);
|
|
|
|
// if (deleteThumbnails == false)
|
|
// return;
|
|
|
|
// DeleteThumbnails(path);
|
|
//}
|
|
|
|
//public void DeleteThumbnails(string path)
|
|
//{
|
|
// GetThumbnails(path)
|
|
// .ForEach(x => base.DeleteFile(x));
|
|
//}
|
|
|
|
//public void CopyThumbnails(string sourcePath, string targetPath)
|
|
//{
|
|
// var targetPathBase = Path.GetDirectoryName(targetPath) ?? "";
|
|
// foreach (var sourceThumbPath in GetThumbnails(sourcePath))
|
|
// {
|
|
// var sourceThumbFilename = Path.GetFileName(sourceThumbPath) ?? "";
|
|
// var targetThumbPath = Path.Combine(targetPathBase, sourceThumbFilename);
|
|
// this.CopyFile(sourceThumbPath, targetThumbPath);
|
|
// }
|
|
//}
|
|
|
|
//#endregion
|
|
|
|
//#region GenerateThumbnails
|
|
|
|
//public IEnumerable<ResizedImage> GenerateThumbnails(Image image, string filepath, string preValue)
|
|
//{
|
|
// if (string.IsNullOrWhiteSpace(preValue))
|
|
// return GenerateThumbnails(image, filepath);
|
|
|
|
// var additionalSizes = new List<int>();
|
|
// var sep = preValue.Contains(",") ? "," : ";";
|
|
// var values = preValue.Split(new[] { sep }, StringSplitOptions.RemoveEmptyEntries);
|
|
// foreach (var value in values)
|
|
// {
|
|
// int size;
|
|
// if (int.TryParse(value, out size))
|
|
// additionalSizes.Add(size);
|
|
// }
|
|
|
|
// return GenerateThumbnails(image, filepath, additionalSizes);
|
|
//}
|
|
|
|
//public IEnumerable<ResizedImage> GenerateThumbnails(Image image, string filepath, IEnumerable<int> additionalSizes = null)
|
|
//{
|
|
// var w = image.Width;
|
|
// var h = image.Height;
|
|
|
|
// var sizes = additionalSizes == null ? DefaultSizes.Keys : DefaultSizes.Keys.Concat(additionalSizes);
|
|
|
|
// // start with default sizes,
|
|
// // add additional sizes,
|
|
// // filter out duplicates,
|
|
// // filter out those that would be larger that the original image
|
|
// // and create the thumbnail
|
|
// return sizes
|
|
// .Distinct()
|
|
// .Where(x => w >= x && h >= x)
|
|
// .Select(x => GenerateResized(image, filepath, DefaultSizes.ContainsKey(x) ? DefaultSizes[x] : "", x))
|
|
// .ToList(); // now
|
|
//}
|
|
|
|
//public IEnumerable<ResizedImage> GenerateThumbnails(Stream filestream, string filepath, PropertyType propertyType)
|
|
//{
|
|
// // get the original image from the original stream
|
|
// if (filestream.CanSeek) filestream.Seek(0, 0); // fixme - what if we cannot seek?
|
|
// using (var image = Image.FromStream(filestream))
|
|
// {
|
|
// return GenerateThumbnails(image, filepath, propertyType);
|
|
// }
|
|
//}
|
|
|
|
//public IEnumerable<ResizedImage> GenerateThumbnails(Image image, string filepath, PropertyType propertyType)
|
|
//{
|
|
// // if the editor is an upload field, check for additional thumbnail sizes
|
|
// // that can be defined in the prevalue for the property data type. otherwise,
|
|
// // just use the default sizes.
|
|
// var sizes = propertyType.PropertyEditorAlias == Constants.PropertyEditors.UploadFieldAlias
|
|
// ? DataTypeService
|
|
// .GetPreValuesByDataTypeId(propertyType.DataTypeDefinitionId)
|
|
// .FirstOrDefault()
|
|
// : string.Empty;
|
|
|
|
// return GenerateThumbnails(image, filepath, sizes);
|
|
//}
|
|
|
|
//#endregion
|
|
|
|
//#region GenerateResized - Generate at resized filepath derived from origin filepath
|
|
|
|
//public ResizedImage GenerateResized(Image originImage, string originFilepath, string sizeName, int maxWidthHeight)
|
|
//{
|
|
// return GenerateResized(originImage, originFilepath, sizeName, maxWidthHeight, -1, -1);
|
|
//}
|
|
|
|
//public ResizedImage GenerateResized(Image originImage, string originFilepath, string sizeName, int fixedWidth, int fixedHeight)
|
|
//{
|
|
// return GenerateResized(originImage, originFilepath, sizeName, -1, fixedWidth, fixedHeight);
|
|
//}
|
|
|
|
//public ResizedImage GenerateResized(Image originImage, string originFilepath, string sizeName, int maxWidthHeight, int fixedWidth, int fixedHeight)
|
|
//{
|
|
// if (string.IsNullOrWhiteSpace(sizeName))
|
|
// sizeName = "UMBRACOSYSTHUMBNAIL";
|
|
// var extension = Path.GetExtension(originFilepath) ?? string.Empty;
|
|
// var filebase = originFilepath.TrimEnd(extension);
|
|
// var resizedFilepath = filebase + "_" + sizeName + extension;
|
|
|
|
// return GenerateResizedAt(originImage, resizedFilepath, maxWidthHeight, fixedWidth, fixedHeight);
|
|
//}
|
|
|
|
//#endregion
|
|
|
|
//#region GenerateResizedAt - Generate at specified resized filepath
|
|
|
|
//public ResizedImage GenerateResizedAt(Image originImage, string resizedFilepath, int maxWidthHeight)
|
|
//{
|
|
// return GenerateResizedAt(originImage, resizedFilepath, maxWidthHeight, -1, -1);
|
|
//}
|
|
|
|
//public ResizedImage GenerateResizedAt(Image originImage, int fixedWidth, int fixedHeight, string resizedFilepath)
|
|
//{
|
|
// return GenerateResizedAt(originImage, resizedFilepath, -1, fixedWidth, fixedHeight);
|
|
//}
|
|
|
|
//public ResizedImage GenerateResizedAt(Image originImage, string resizedFilepath, int maxWidthHeight, int fixedWidth, int fixedHeight)
|
|
//{
|
|
// // target dimensions
|
|
// int width, height;
|
|
|
|
// // if maxWidthHeight then get ratio
|
|
// if (maxWidthHeight > 0)
|
|
// {
|
|
// var fx = (float)originImage.Size.Width / maxWidthHeight;
|
|
// var fy = (float)originImage.Size.Height / maxWidthHeight;
|
|
// var f = Math.Max(fx, fy); // fit in thumbnail size
|
|
// width = (int)Math.Round(originImage.Size.Width / f);
|
|
// height = (int)Math.Round(originImage.Size.Height / f);
|
|
// if (width == 0) width = 1;
|
|
// if (height == 0) height = 1;
|
|
// }
|
|
// else if (fixedWidth > 0 && fixedHeight > 0)
|
|
// {
|
|
// width = fixedWidth;
|
|
// height = fixedHeight;
|
|
// }
|
|
// else
|
|
// {
|
|
// width = height = 1;
|
|
// }
|
|
|
|
// // create new image with best quality settings
|
|
// using (var bitmap = new Bitmap(width, height))
|
|
// using (var graphics = Graphics.FromImage(bitmap))
|
|
// {
|
|
// // if the image size is rather large we cannot use the best quality interpolation mode
|
|
// // because we'll get out of mem exceptions. So we detect how big the image is and use
|
|
// // the mid quality interpolation mode when the image size exceeds our max limit.
|
|
// graphics.InterpolationMode = originImage.Width > 5000 || originImage.Height > 5000
|
|
// ? InterpolationMode.Bilinear // mid quality
|
|
// : InterpolationMode.HighQualityBicubic; // best quality
|
|
|
|
// // everything else is best-quality
|
|
// graphics.SmoothingMode = SmoothingMode.HighQuality;
|
|
// graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
|
|
// graphics.CompositingQuality = CompositingQuality.HighQuality;
|
|
|
|
// // copy the old image to the new and resize
|
|
// var rect = new Rectangle(0, 0, width, height);
|
|
// graphics.DrawImage(originImage, rect, 0, 0, originImage.Width, originImage.Height, GraphicsUnit.Pixel);
|
|
|
|
// // copy metadata
|
|
// // fixme - er... no?
|
|
|
|
// // get an encoder - based upon the file type
|
|
// var extension = (Path.GetExtension(resizedFilepath) ?? "").TrimStart('.').ToLowerInvariant();
|
|
// var encoders = ImageCodecInfo.GetImageEncoders();
|
|
// ImageCodecInfo encoder;
|
|
// switch (extension)
|
|
// {
|
|
// case "png":
|
|
// encoder = encoders.Single(t => t.MimeType.Equals("image/png"));
|
|
// break;
|
|
// case "gif":
|
|
// encoder = encoders.Single(t => t.MimeType.Equals("image/gif"));
|
|
// break;
|
|
// case "tif":
|
|
// case "tiff":
|
|
// encoder = encoders.Single(t => t.MimeType.Equals("image/tiff"));
|
|
// break;
|
|
// case "bmp":
|
|
// encoder = encoders.Single(t => t.MimeType.Equals("image/bmp"));
|
|
// break;
|
|
// // TODO: this is dirty, defaulting to jpg but the return value of this thing is used all over the
|
|
// // place so left it here, but it needs to not set a codec if it doesn't know which one to pick
|
|
// // Note: when fixing this: both .jpg and .jpeg should be handled as extensions
|
|
// default:
|
|
// encoder = encoders.Single(t => t.MimeType.Equals("image/jpeg"));
|
|
// break;
|
|
// }
|
|
|
|
// // set compresion ratio to 90%
|
|
// var encoderParams = new EncoderParameters();
|
|
// encoderParams.Param[0] = new EncoderParameter(Encoder.Quality, 90L);
|
|
|
|
// // save the new image
|
|
// using (var stream = new MemoryStream())
|
|
// {
|
|
// bitmap.Save(stream, encoder, encoderParams);
|
|
// stream.Seek(0, 0);
|
|
// if (resizedFilepath.Contains("UMBRACOSYSTHUMBNAIL"))
|
|
// {
|
|
// var filepath = resizedFilepath.Replace("UMBRACOSYSTHUMBNAIL", maxWidthHeight.ToInvariantString());
|
|
// AddFile(filepath, stream);
|
|
// if (extension != "jpg")
|
|
// {
|
|
// filepath = filepath.TrimEnd(extension) + "jpg";
|
|
// stream.Seek(0, 0);
|
|
// AddFile(filepath, stream);
|
|
// }
|
|
// // TODO: Remove this, this is ONLY here for backwards compatibility but it is essentially completely unusable see U4-5385
|
|
// stream.Seek(0, 0);
|
|
// resizedFilepath = resizedFilepath.Replace("UMBRACOSYSTHUMBNAIL", width + "x" + height);
|
|
// }
|
|
|
|
// AddFile(resizedFilepath, stream);
|
|
// }
|
|
|
|
// return new ResizedImage(resizedFilepath, width, height);
|
|
// }
|
|
//}
|
|
|
|
//#endregion
|
|
|
|
//#region Inner classes
|
|
|
|
//public class ResizedImage
|
|
//{
|
|
// public ResizedImage()
|
|
// { }
|
|
|
|
// public ResizedImage(string filepath, int width, int height)
|
|
// {
|
|
// Filepath = filepath;
|
|
// Width = width;
|
|
// Height = height;
|
|
// }
|
|
|
|
// public string Filepath { get; set; }
|
|
// public int Width { get; set; }
|
|
// public int Height { get; set; }
|
|
//}
|
|
|
|
//#endregion
|
|
}
|
|
}
|