/// <summary>
/// Executes this command.
/// </summary>
/// <param name="imageId">The image id.</param>
/// <returns>The view model.</returns>
public ImageViewModel Execute(Guid imageId)
{
var image = Repository.First <MediaImage>(imageId);
var dimensionsCalculator = new ImageDimensionsCalculator(image);
return(new ImageViewModel
{
Id = image.Id.ToString(),
Caption = image.Caption,
Title = image.Title,
Description = image.Description,
Url = FileUrlResolver.EnsureFullPathUrl(image.PublicUrl),
ThumbnailUrl = FileUrlResolver.EnsureFullPathUrl(image.PublicThumbnailUrl),
Version = image.Version.ToString(CultureInfo.InvariantCulture),
FileName = image.OriginalFileName,
FileExtension = image.OriginalFileExtension,
FileSize = image.SizeAsText(),
ImageWidth = image.Width,
ImageHeight = image.Height,
CroppedWidth = dimensionsCalculator.ResizedCroppedWidth,
CroppedHeight = dimensionsCalculator.ResizedCroppedHeight,
OriginalImageWidth = image.OriginalWidth,
OriginalImageHeight = image.OriginalHeight,
ImageAlign = image.ImageAlign.HasValue ? image.ImageAlign.Value : MediaImageAlign.Center,
CropCoordX1 = image.CropCoordX1.HasValue ? image.CropCoordX1.Value : 0,
CropCoordY1 = image.CropCoordY1.HasValue ? image.CropCoordY1.Value : 0,
CropCoordX2 = image.CropCoordX2.HasValue ? image.CropCoordX2.Value : image.OriginalWidth,
CropCoordY2 = image.CropCoordY2.HasValue ? image.CropCoordY2.Value : image.OriginalHeight,
OriginalImageUrl = FileUrlResolver.EnsureFullPathUrl(image.PublicOriginallUrl + string.Format("?{0}", DateTime.Now.ToString(MediaManagerModuleDescriptor.HardLoadImageDateTimeFormat))),
FolderId = image.Folder != null ? image.Folder.Id : (Guid?)null,
Tags = TagService.GetMediaTagNames(imageId)
});
}
/// <summary>
/// Creates the image view model.
/// </summary>
/// <param name="media">The media.</param>
/// <returns>Created image view model</returns>
protected override MediaViewModel ToViewModel(Media media)
{
var image = media as MediaImage;
if (image != null)
{
var model = new MediaImageViewModel();
FillMediaFileViewModel(model, image);
var dimensionsCalculator = new ImageDimensionsCalculator(image);
model.Tooltip = image.Caption;
model.ThumbnailUrl = FileUrlResolver.EnsureFullPathUrl(image.PublicThumbnailUrl + string.Format("?{0}", DateTime.Now.ToString(MediaManagerModuleDescriptor.HardLoadImageDateTimeFormat)));
model.IsProcessing = image.IsUploaded == null || image.IsThumbnailUploaded == null || image.IsOriginalUploaded == null;
model.IsFailed = image.IsUploaded == false || image.IsThumbnailUploaded == false || image.IsOriginalUploaded == false;
model.Height = dimensionsCalculator.ResizedCroppedHeight;
model.Width = dimensionsCalculator.ResizedCroppedWidth;
return(model);
}
throw new InvalidOperationException("Cannot convert image media to image view model. Wrong entity passed.");
}
/// <summary>
/// Resizes and crops the image.
/// </summary>
/// <param name="mediaImage">The image.</param>
/// <param name="request">The request.</param>
private MemoryStream ResizeAndCropImage(MediaImage mediaImage, ImageViewModel request)
{
int?x1 = request.CropCoordX1;
int?x2 = request.CropCoordX2;
int?y1 = request.CropCoordY1;
int?y2 = request.CropCoordY2;
var cropped = true;
if ((x1 <= 0 && y1 <= 0 && ((x2 >= mediaImage.OriginalWidth && y2 >= mediaImage.OriginalHeight) || (x2 <= 0 && y2 <= 0))))
{
x1 = y1 = 0;
x2 = mediaImage.OriginalWidth;
y2 = mediaImage.OriginalHeight;
cropped = false;
}
var newWidth = request.ImageWidth;
var newHeight = request.ImageHeight;
var resized = (newWidth != mediaImage.OriginalWidth || newHeight != mediaImage.OriginalHeight);
MemoryStream memoryStream = null;
var hasChanges = (mediaImage.Width != newWidth ||
mediaImage.Height != newHeight ||
x1 != mediaImage.CropCoordX1 ||
x2 != mediaImage.CropCoordX2 ||
y1 != mediaImage.CropCoordY1 ||
y2 != mediaImage.CropCoordY2);
if (hasChanges)
{
DownloadResponse downloadResponse = StorageService.DownloadObject(mediaImage.OriginalUri);
var dimensionsCalculator = new ImageDimensionsCalculator(newWidth, newHeight, mediaImage.OriginalWidth, mediaImage.OriginalHeight, x1, x2, y1, y2);
using (var image = Image.FromStream(downloadResponse.ResponseStream))
{
var destination = image;
var codec = ImageHelper.GetImageCodec(destination);
if (resized)
{
destination = ImageHelper.Resize(destination, new Size {
Width = newWidth, Height = newHeight
});
}
if (cropped)
{
var width = dimensionsCalculator.ResizedCroppedWidth;
var heigth = dimensionsCalculator.ResizedCroppedHeight;
var cropX12 = dimensionsCalculator.ResizedCropCoordX1.Value;
var cropY12 = dimensionsCalculator.ResizedCropCoordY1.Value;
Rectangle rec = new Rectangle(cropX12, cropY12, width, heigth);
destination = ImageHelper.Crop(destination, rec);
}
memoryStream = new MemoryStream();
destination.Save(memoryStream, codec, null);
mediaImage.Size = memoryStream.Length;
}
mediaImage.CropCoordX1 = x1;
mediaImage.CropCoordY1 = y1;
mediaImage.CropCoordX2 = x2;
mediaImage.CropCoordY2 = y2;
mediaImage.Width = newWidth;
mediaImage.Height = newHeight;
}
return(memoryStream);
}
/// <summary>
/// Executes the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Media preview.</returns>
public MediaPreviewViewModel Execute(Guid request)
{
var response = new MediaPreviewViewModel();
var media = Repository.AsQueryable <Media>(m => m.Id == request).Fetch(m => m.Original).FirstOne();
var file = media as MediaFile;
if (file != null)
{
var image = media as MediaImage;
if (cmsConfiguration.Security.AccessControlEnabled)
{
AccessControlService.DemandAccess(file.Original as MediaFile ?? file, Context.Principal, AccessLevel.Read);
}
response.AddProperty(MediaGlobalization.MediaHistory_Preview_Properties_Title, file.Title);
if (image != null)
{
response.AddProperty(MediaGlobalization.MediaHistory_Preview_Properties_Caption, image.Caption);
}
var publicUrl = fileService.GetDownloadFileUrl(MediaType.File, file.Id, fileUrlResolver.EnsureFullPathUrl(file.PublicUrl));
response.AddUrl(MediaGlobalization.MediaHistory_Preview_Properties_PublicUrl, publicUrl);
if (image != null)
{
response.AddUrl(
MediaGlobalization.MediaHistory_Preview_Properties_PublicThumbnailUrl,
fileUrlResolver.EnsureFullPathUrl(
image.PublicThumbnailUrl + string.Format("?{0}", DateTime.Now.ToString(MediaManagerModuleDescriptor.HardLoadImageDateTimeFormat))));
}
response.AddProperty(MediaGlobalization.MediaHistory_Preview_Properties_FileSize, file.SizeAsText());
if (image != null)
{
var dimensionCalculator = new ImageDimensionsCalculator(image);
if (dimensionCalculator.Height != dimensionCalculator.ResizedCroppedHeight || dimensionCalculator.Width != dimensionCalculator.ResizedCroppedWidth)
{
response.AddProperty(MediaGlobalization.MediaHistory_Preview_Properties_CroppedImageDimensions,
string.Format("{0} x {1}", dimensionCalculator.ResizedCroppedWidth, dimensionCalculator.ResizedCroppedHeight));
}
response.AddProperty(MediaGlobalization.MediaHistory_Preview_Properties_ImageDimensions,
string.Format("{0} x {1}", dimensionCalculator.Width, dimensionCalculator.Height));
}
if (!string.IsNullOrWhiteSpace(file.Description))
{
response.AddProperty(MediaGlobalization.MediaHistory_Preview_Properties_Description, file.Description);
}
if (media.Image != null)
{
response.AddImage(
media.Image.Caption,
fileUrlResolver.EnsureFullPathUrl(
media.Image.PublicUrl + string.Format("?{0}", DateTime.Now.ToString(MediaManagerModuleDescriptor.HardLoadImageDateTimeFormat))));
}
if (image != null)
{
response.AddImage(
image.Caption,
fileUrlResolver.EnsureFullPathUrl(
image.PublicUrl + string.Format("?{0}", DateTime.Now.ToString(MediaManagerModuleDescriptor.HardLoadImageDateTimeFormat))));
}
}
return(response);
}
/// <summary>
/// Resizes and crops the image.
/// </summary>
/// <param name="mediaImage">The image.</param>
/// <param name="request">The request.</param>
private void ResizeAndCropImage(MediaImage mediaImage, ImageViewModel request)
{
int?x1 = request.CropCoordX1;
int?x2 = request.CropCoordX2;
int?y1 = request.CropCoordY1;
int?y2 = request.CropCoordY2;
var cropped = true;
if ((x1 <= 0 && y1 <= 0 && ((x2 >= mediaImage.OriginalWidth && y2 >= mediaImage.OriginalHeight) || (x2 <= 0 && y2 <= 0))))
{
x1 = y1 = x2 = y2 = null;
cropped = false;
}
var newWidth = request.ImageWidth;
var newHeight = request.ImageHeight;
var resized = (newWidth != mediaImage.OriginalWidth || newHeight != mediaImage.OriginalHeight);
var hasChanges = (mediaImage.Width != newWidth ||
mediaImage.Height != newHeight ||
x1 != mediaImage.CropCoordX1 ||
x2 != mediaImage.CropCoordX2 ||
y1 != mediaImage.CropCoordY1 ||
y2 != mediaImage.CropCoordY2);
if (hasChanges)
{
var downloadResponse = StorageService.DownloadObject(mediaImage.OriginalUri);
var dimensionsCalculator = new ImageDimensionsCalculator(newWidth, newHeight, mediaImage.OriginalWidth, mediaImage.OriginalHeight, x1, x2, y1, y2);
using (var image = Image.FromStream(downloadResponse.ResponseStream))
{
var destination = image;
var codec = ImageHelper.GetImageCodec(destination);
if (resized)
{
destination = ImageHelper.Resize(destination, new Size {
Width = newWidth, Height = newHeight
});
}
if (cropped)
{
var width = dimensionsCalculator.ResizedCroppedWidth;
var heigth = dimensionsCalculator.ResizedCroppedHeight;
var cropX12 = dimensionsCalculator.ResizedCropCoordX1.Value;
var cropY12 = dimensionsCalculator.ResizedCropCoordY1.Value;
Rectangle rec = new Rectangle(cropX12, cropY12, width, heigth);
destination = ImageHelper.Crop(destination, rec);
}
// Change image file names depending on file version
var newVersion = mediaImage.Version + 1;
mediaImage.FileUri = ApplyVersionToFileUri(mediaImage.FileUri, mediaImage.OriginalFileName, newVersion);
mediaImage.PublicUrl = ApplyVersionToFileUrl(mediaImage.PublicUrl, mediaImage.OriginalFileName, newVersion);
mediaImage.ThumbnailUri = ApplyVersionToFileUri(mediaImage.ThumbnailUri, mediaImage.OriginalFileName, newVersion);
mediaImage.PublicThumbnailUrl = ApplyVersionToFileUrl(mediaImage.PublicThumbnailUrl, mediaImage.OriginalFileName, newVersion);
// Upload image to storage
var memoryStream = new MemoryStream();
destination.Save(memoryStream, codec, null);
mediaImage.Size = memoryStream.Length;
StorageService.UploadObject(new UploadRequest {
InputStream = memoryStream, Uri = mediaImage.FileUri, IgnoreAccessControl = true
});
// Update thumbnail
MediaImageService.UpdateThumbnail(mediaImage, Size.Empty);
}
}
mediaImage.CropCoordX1 = x1;
mediaImage.CropCoordY1 = y1;
mediaImage.CropCoordX2 = x2;
mediaImage.CropCoordY2 = y2;
mediaImage.Width = newWidth;
mediaImage.Height = newHeight;
}
/// <summary>
/// Resizes and crops the image.
/// </summary>
/// <param name="mediaImage">The image.</param>
/// <param name="request">The request.</param>
private void ResizeAndCropImage(MediaImage mediaImage, ImageViewModel request)
{
int?x1 = request.CropCoordX1;
int?x2 = request.CropCoordX2;
int?y1 = request.CropCoordY1;
int?y2 = request.CropCoordY2;
Byte[] bytes = null;
var cropped = true;
if ((x1 <= 0 && y1 <= 0 && ((x2 >= mediaImage.OriginalWidth && y2 >= mediaImage.OriginalHeight) || (x2 <= 0 && y2 <= 0))))
{
x1 = y1 = x2 = y2 = null;
cropped = false;
}
var newWidth = request.ImageWidth;
var newHeight = request.ImageHeight;
var resized = (newWidth != mediaImage.OriginalWidth || newHeight != mediaImage.OriginalHeight);
var hasChanges = (mediaImage.Width != newWidth ||
mediaImage.Height != newHeight ||
x1 != mediaImage.CropCoordX1 ||
x2 != mediaImage.CropCoordX2 ||
y1 != mediaImage.CropCoordY1 ||
y2 != mediaImage.CropCoordY2);
if (hasChanges)
{
var downloadResponse = StorageService.DownloadObject(mediaImage.OriginalUri);
var image = new WebImage(downloadResponse.ResponseStream);
var dimensionsCalculator = new ImageDimensionsCalculator(newWidth, newHeight, mediaImage.OriginalWidth, mediaImage.OriginalHeight, x1, x2, y1, y2);
ImageFormat format = null;
if (DefaultMediaImageService.transparencyFormats.TryGetValue(image.ImageFormat, out format))
{
using (Image resizedBitmap = new Bitmap(newWidth, newHeight))
{
using (Bitmap source = new Bitmap(new MemoryStream(image.GetBytes())))
{
using (Graphics g = Graphics.FromImage(resizedBitmap))
{
if (resized)
{
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
g.DrawImage(source, 0, 0, newWidth, newHeight);
using (MemoryStream ms = new MemoryStream())
{
resizedBitmap.Save(ms, format);
image = new WebImage(ms.ToArray());
}
}
}
}
}
if (cropped)
{
var width = dimensionsCalculator.ResizedCroppedWidth;
var heigth = dimensionsCalculator.ResizedCroppedHeight;
var cropX12 = dimensionsCalculator.CropCoordX1.Value;
var cropY12 = dimensionsCalculator.CropCoordY1.Value;
Rectangle rec = new Rectangle(cropX12, cropY12, width, heigth);
using (Bitmap source = new Bitmap(new MemoryStream(image.GetBytes())))
{
var resizedBitmap = source.Clone(rec, source.PixelFormat);
using (MemoryStream ms = new MemoryStream())
{
resizedBitmap.Save(ms, format);
image = new WebImage(ms.ToArray());
resizedBitmap.Dispose();
}
}
}
}
else
{
if (resized)
{
image = image.Resize(newWidth, newHeight, false);
}
if (cropped)
{
var cropX1 = dimensionsCalculator.ResizedCropCoordX1.Value;
var cropY1 = dimensionsCalculator.ResizedCropCoordY1.Value;
var cropX2 = image.Width - dimensionsCalculator.ResizedCropCoordX2.Value;
var cropY2 = image.Height - dimensionsCalculator.ResizedCropCoordY2.Value;
// Fix for small resized images
if (cropX2 - cropX1 < image.Width && cropY2 - cropY1 < image.Height)
{
image = image.Crop(cropY1, cropX1, cropY2, cropX2);
}
}
}
// Change image file names depending on file version
var newVersion = mediaImage.Version + 1;
mediaImage.FileUri = ApplyVersionToFileUri(mediaImage.FileUri, mediaImage.OriginalFileName, newVersion);
mediaImage.PublicUrl = ApplyVersionToFileUrl(mediaImage.PublicUrl, mediaImage.OriginalFileName, newVersion);
mediaImage.ThumbnailUri = ApplyVersionToFileUri(mediaImage.ThumbnailUri, mediaImage.OriginalFileName, newVersion);
mediaImage.PublicThumbnailUrl = ApplyVersionToFileUrl(mediaImage.PublicThumbnailUrl, mediaImage.OriginalFileName, newVersion);
// Upload image to storage
bytes = image.GetBytes();
var memoryStream = new MemoryStream(bytes);
StorageService.UploadObject(new UploadRequest {
InputStream = memoryStream, Uri = mediaImage.FileUri, IgnoreAccessControl = true
});
mediaImage.Size = bytes.Length;
// Update thumbnail
MediaImageService.UpdateThumbnail(mediaImage, Size.Empty);
}
mediaImage.CropCoordX1 = x1;
mediaImage.CropCoordY1 = y1;
mediaImage.CropCoordX2 = x2;
mediaImage.CropCoordY2 = y2;
mediaImage.Width = newWidth;
mediaImage.Height = newHeight;
}
