private string CreateCacheFileName(IImageResizeSettings settings, IImageAssetRenderable asset)
{
const string format = "w{0}h{1}c{2}s{3}bg{4}a{5}";
string s = string.Format(format, settings.Width, settings.Height, settings.Mode, settings.Scale, settings.BackgroundColor, settings.Anchor);
s = WebUtility.UrlEncode(s);
return(Path.ChangeExtension(s, asset.FileExtension));
}
/// <summary>
/// Gets the url for an image asset, with optional resizing parameters
/// </summary>
/// <param name="asset">asset to get the url for</param>
/// <param name="settings">Optional resizing settings for the image</param>
public string ImageAsset(IImageAssetRenderable asset, IImageResizeSettings settings = null)
{
if (asset == null)
{
return(string.Empty);
}
SetDefaultCrop(asset, settings);
return(GetUrl(asset, settings));
}
/// <summary>
/// Gets the url for an image asset, with optional resizing parameters
/// </summary>
/// <param name="asset">asset to get the url for</param>
/// <param name="settings">Optional resizing settings for the image</param>
public string ImageAsset(IImageAssetRenderable asset, IImageResizeSettings settings = null)
{
if (asset == null)
{
return(string.Empty);
}
SetDefaultCrop(asset, settings);
return(ImageAsset(asset.ImageAssetId, asset.FileName, asset.Extension, settings));
}
/// <summary>
/// Gets the url for an image asset, with optional resizing parameters
/// </summary>
/// <param name="asset">asset to get the url for</param>
/// <param name="width">width to resize the image to</param>
/// <param name="height">height to resize the image to</param>
public string ImageAsset(IImageAssetRenderable asset, int?width, int?height = null)
{
if (asset == null)
{
return(string.Empty);
}
var settings = GetResizeSettings(asset, width, height);
return(GetUrl(asset, settings));
}
/// <summary>
/// Gets the url for an image asset, with optional resizing parameters
/// </summary>
/// <param name="asset">asset to get the url for</param>
/// <param name="width">width to resize the image to</param>
/// <param name="height">height to resize the image to</param>
public string ImageAsset(IImageAssetRenderable asset, int?width, int?height = null)
{
if (asset == null)
{
return(string.Empty);
}
var settings = GetResizeSettings(asset, width, height);
return(ImageAsset(asset.ImageAssetId, asset.FileName, asset.Extension, settings));
}
private static string GetUrl(IImageAssetRenderable asset, IImageResizeSettings settings = null)
{
var fileName = Path.ChangeExtension(SlugFormatter.ToSlug(asset.FileName), asset.FileExtension);
var pathPart = asset.ImageAssetId + "-" + asset.FileStamp + "-" + asset.VerificationToken;
var url = $"/assets/images/{pathPart}/{fileName}";
if (settings != null)
{
url += settings.ToQueryString();
}
return(url);
}
private static void SetDefaultCrop(IImageAssetRenderable asset, IImageResizeSettings settings)
{
if (settings == null)
{
return;
}
if (isDefinedAndChanged(settings.Width, asset.Width) || isDefinedAndChanged(settings.Height, asset.Height))
{
if (asset.DefaultAnchorLocation.HasValue)
{
settings.Anchor = asset.DefaultAnchorLocation.Value;
}
}
}
/// <summary>
/// Validates that the image asset can be resized using the settings
/// supplied by the client.
/// </summary>
/// <param name="settings">Settings to validate.</param>
/// <param name="asset">Asset attempting to be resized. Cannot be null.</param>
public void Validate(IImageResizeSettings settings, IImageAssetRenderable asset)
{
if (settings.RequiresResizing(asset) && _imageAssetsSettings.DisableResizing)
{
throw new InvalidImageResizeSettingsException("Image resizing has been requested but is disabled.", settings);
}
if (settings.Width > _imageAssetsSettings.MaxResizeWidth)
{
throw new InvalidImageResizeSettingsException($"Requested image width exceeds the maximum permitted value of {_imageAssetsSettings.MaxResizeWidth} pixels");
}
if (settings.Height > _imageAssetsSettings.MaxResizeHeight)
{
throw new InvalidImageResizeSettingsException($"Requested image height exceeds the maximum permitted value of {_imageAssetsSettings.MaxResizeHeight} pixels");
}
}
private static ImageResizeSettings GetResizeSettings(IImageAssetRenderable asset, int?width, int?height)
{
var settings = new ImageResizeSettings();
if (width.HasValue)
{
settings.Width = width.Value;
}
if (height.HasValue)
{
settings.Height = height.Value;
}
SetDefaultCrop(asset, settings);
return(settings);
}
/// <summary>
/// Determines if the settings indicate that an image asset should
/// be resized. If width and hight are not specified or the dimensions
/// in the settings are the same as the image then false will be returned.
/// </summary>
/// <param name="asset">The asset to check. Cannot be null.</param>
public static bool RequiresResizing(this IImageResizeSettings settings, IImageAssetRenderable asset)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (asset == null)
{
throw new ArgumentNullException(nameof(asset));
}
if ((settings.Width < 1 && settings.Height < 1) ||
(settings.Width == asset.Width && settings.Height == asset.Height))
{
return(false);
}
return(true);
}
/// <summary>
/// Gets the url for an image asset, with optional resizing parameters
/// </summary>
/// <param name="asset">asset to get the url for</param>
/// <param name="width">width to resize the image to</param>
/// <param name="height">height to resize the image to</param>
public string ImageAsset(IImageAssetRenderable asset, int?width, int?height = null)
{
if (asset == null)
{
return(string.Empty);
}
var settings = new ImageResizeSettings();
if (width.HasValue)
{
settings.Width = width.Value;
}
if (height.HasValue)
{
settings.Height = height.Value;
}
SetDefaultCrop(asset, settings);
return(ImageAsset(asset.ImageAssetId, asset.FileName, asset.Extension, settings));
}
/// <summary>
/// Gets the url for an image asset, with optional resizing parameters
/// </summary>
/// <param name="asset">asset to get the url for</param>
/// <param name="settings">Optional resizing settings for the image</param>
public string ImageAsset(IImageAssetRenderable image, IImageResizeSettings settings = null)
{
return(_imageAssetRouteLibrary.ImageAsset(image, settings));
}
public Task <Stream> GetAsync(IImageAssetRenderable asset, IImageResizeSettings inputSettings)
{
// Resizing only supported via plugin
return(GetFileStreamAsync(asset.ImageAssetId));
}
public Stream Get(IImageAssetRenderable asset, IImageResizeSettings inputSettings)
{
// Resizing only supported via plugin
return(GetFileStream(asset.ImageAssetId));
}
public async Task <Stream> GetAsync(IImageAssetRenderable asset, IImageResizeSettings inputSettings)
{
if ((inputSettings.Width < 1 && inputSettings.Height < 1) ||
(inputSettings.Width == asset.Width && inputSettings.Height == asset.Height))
{
return(await GetFileStreamAsync(asset.ImageAssetId));
}
if (_imageAssetsSettings.DisableResizing)
{
throw new InvalidImageResizeSettingsException("Image resizing has been requested but is disabled.", inputSettings);
}
var fullFileName = asset.FileNameOnDisk + "/" + CreateCacheFileName(inputSettings, asset);
Stream imageStream = null;
ValidateSettings(inputSettings);
if (await _fileService.ExistsAsync(IMAGE_ASSET_CACHE_CONTAINER_NAME, fullFileName))
{
return(await _fileService.GetAsync(IMAGE_ASSET_CACHE_CONTAINER_NAME, fullFileName));
}
else
{
imageStream = new MemoryStream();
IImageFormat imageFormat = null;
using (var originalStream = await GetFileStreamAsync(asset.ImageAssetId))
using (var image = Image.Load(originalStream, out imageFormat))
{
if (imageFormat == null)
{
throw new Exception("Unable to determine image type for image asset " + asset.ImageAssetId);
}
var encoder = Configuration.Default.ImageFormatsManager.FindEncoder(imageFormat);
if (encoder == null)
{
throw new InvalidOperationException("Encoder not found for image format " + imageFormat.Name);
}
var resizeOptions = ConvertSettings(inputSettings);
image.Mutate(cx =>
{
cx.Resize(resizeOptions);
if (!string.IsNullOrWhiteSpace(inputSettings.BackgroundColor))
{
var color = Rgba32.ParseHex(inputSettings.BackgroundColor);
cx.BackgroundColor(color);
}
else if (CanPad(resizeOptions))
{
if (SupportsTransparency(imageFormat))
{
cx.BackgroundColor(Color.Transparent);
encoder = EnsureEncoderSupportsTransparency(encoder);
}
else
{
// default background for jpg encoder is black, but white is a better default in most scenarios.
cx.BackgroundColor(Color.White);
}
}
});
image.Save(imageStream, encoder);
}
try
{
// Try and create the cache file, but don't throw an error if it fails - it will be attempted again on the next request
await _fileService.CreateIfNotExistsAsync(IMAGE_ASSET_CACHE_CONTAINER_NAME, fullFileName, imageStream);
}
catch (Exception ex)
{
if (Debugger.IsAttached)
{
throw;
}
else
{
_logger.LogError(0, ex, "Error creating image asset cache file. Container name {ContainerName}, {fullFileName}", IMAGE_ASSET_CACHE_CONTAINER_NAME, fullFileName);
}
}
imageStream.Position = 0;
return(imageStream);
}
}
