/// <summary>
/// Processes a request to determine if it matches a known image, otherwise it will generate it.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task Invoke(HttpContext context)
{
var path = context.Request.Path;
var extension = Path.GetExtension(path.Value);
if (!GenericHelpers.IsGetOrHeadMethod(context.Request.Method))
{
this.logger.LogRequestMethodNotSupported(context.Request.Method);
}
else if (!GenericHelpers.IsRequestFileTypeSupported(
extension,
this.options.OutputFormats.SelectMany(
x => x.FileEndings).ToArray()
)
)
{
this.logger.LogRequestFileTypeNotSupported(extension);
}
else if (!GenericHelpers.TryMatchPath(path, this.options.TargetFolder))
{
this.logger.LogPathMismatch(path);
}
else
{
// get the image location on disk
var imagePath = Path.Combine(
this.env.WebRootPath,
path.Value
.Replace('/', Path.DirectorySeparatorChar)
.TrimStart(Path.DirectorySeparatorChar)
);
if (!File.Exists(imagePath))
{
this.logger.LogProcessingImage(path.Value);
var size = Path.GetFileNameWithoutExtension(path.Value).ToLower();
var filename = Directory.GetParent(path.Value).Name;
// var imageSourcePath = Path.Combine(
// $"{this.env.ContentRootPath}{this.options.SourceFolder}",
// $"{filename}{extension}"
// );
FileInfo sourceImageFile;
var sourceImageFolder = new DirectoryInfo(Path.Combine(
$"{this.env.ContentRootPath}{this.options.SourceFolder}"
));
var sourceImageFiles = sourceImageFolder.GetFiles($"{filename}.*");
if (sourceImageFiles == null || sourceImageFiles.Length == 0)
{
// Image source not found!
// Hand over to the next middleware and return.
this.logger.LogSourceImageNotFound($"{filename}.*");
await this.next(context);
return;
}
else
{
if (sourceImageFiles.Length > 1)
{
this.logger.LogWarning(
$"Found multiple source images, take first one: {sourceImageFiles[0].Name}"
);
}
sourceImageFile = sourceImageFiles[0];
}
var targetDir = Path.Combine(
this.env.WebRootPath,
this.options.TargetFolder
.Replace('/', Path.DirectorySeparatorChar)
.TrimStart(Path.DirectorySeparatorChar),
filename
);
if (!Directory.Exists(targetDir))
{
this.logger.LogInformation($"Create Directory: \"{targetDir}\"");
Directory.CreateDirectory(targetDir);
}
var sizeSetting = this.options.Sizes.FirstOrDefault(
x => (x.Name ?? x.Width.ToString()).ToLower() == size
);
if (sizeSetting == null)
{
// Not supported size!
// Hand over to the next middleware and return.
this.logger.LogSizeNotSupported(size);
await this.next(context);
return;
}
var sourceImageFileExtension = sourceImageFile.Extension.Trim('.');
var isSourceFileSupported = Enum.TryParse <MagickFormat>(sourceImageFileExtension, true, out var format);
if (isSourceFileSupported)
{
using (var image = new MagickImage())
{
try
{
image.Read(sourceImageFile);
}
// Something went wrong while loading the image with ImageMagick
catch (MagickException exception)
{
this.logger.LogError($"Error while loading image: {exception}");
await this.next(context);
return;
}
image.Resize(sizeSetting.Width, sizeSetting.Height);
image.Strip();
if (sizeSetting.Quality >= 0)
{
this.logger.LogInformation($"Setting Quality to: \"{sizeSetting.Quality}\"");
image.Quality = sizeSetting.Quality;
}
if (sizeSetting.Progressive)
{
image.Format = MagickFormat.Pjpeg;
}
using (var stream = new MemoryStream())
{
image.Write(stream);
stream.Position = 0;
this.logger.LogInformation($"LosslessCompress before: {stream.Length / 1024} kb");
var imageOptimizer = new ImageOptimizer();
if (options.LosslessCompress)
{
imageOptimizer.LosslessCompress(stream);
}
else
{
imageOptimizer.Compress(stream);
}
this.logger.LogInformation($"LosslessCompress after: {stream.Length / 1024} kb");
using (
FileStream file = new FileStream(
imagePath,
FileMode.Create,
System.IO.FileAccess.Write
)
)
{
stream.WriteTo(file);
file.Flush();
}
}
}
}
else
{
this.logger.LogSourceFileTypeNotSupported($"{sourceImageFileExtension}");
await this.next(context);
return;
}
}
}
await this.next(context);
}