/// <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);
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 xRatio2 = (decimal)newWidth / (mediaImage.OriginalWidth == 0 ? newWidth : mediaImage.OriginalWidth);
var yRatio2 = (decimal)newHeight / (mediaImage.OriginalHeight == 0 ? newHeight : mediaImage.OriginalHeight);
var weigth = (int)((x2.Value - x1.Value) * xRatio2);
var heigth = (int)((y2.Value - y1.Value) * yRatio2);
var cropX12 = (int)Math.Floor(x1.Value * xRatio2);
var cropY12 = (int)Math.Floor(y1.Value * yRatio2);
Rectangle rec = new Rectangle(cropX12, cropY12, weigth, 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 xRatio = (decimal)newWidth / (mediaImage.OriginalWidth == 0 ? newWidth : mediaImage.OriginalWidth);
var yRatio = (decimal)newHeight / (mediaImage.OriginalHeight == 0 ? newHeight : mediaImage.OriginalHeight);
var cropX1 = (int)Math.Floor(x1.Value * xRatio);
var cropY1 = (int)Math.Floor(y1.Value * yRatio);
var cropX2 = image.Width - (int)Math.Floor(x2.Value * xRatio);
var cropY2 = image.Height - (int)Math.Floor(y2.Value * yRatio);
// 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;
}
/// <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)
{
MemoryStream memoryStream = null;
var newWidth = request.ImageWidth;
var newHeight = request.ImageHeight;
if (request.ImageType == ImageType.Raster)
{
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 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)
{
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);
}
private void StartTasksForImageSync(
MediaImage mediaImage,
Stream fileStream,
MemoryStream thumbnailFileStream,
bool shouldNotUploadOriginal = false)
{
mediaFileService.UploadMediaFileToStorageSync(
fileStream,
mediaImage.FileUri,
mediaImage,
img =>
{
if (img != null)
{
img.IsUploaded = true;
}
},
img =>
{
if (img != null)
{
img.IsUploaded = false;
}
},
true);
if (!shouldNotUploadOriginal)
{
mediaFileService.UploadMediaFileToStorageSync(
fileStream,
mediaImage.OriginalUri,
mediaImage,
img =>
{
if (img != null)
{
img.IsOriginalUploaded = true;
}
},
img =>
{
if (img != null)
{
img.IsOriginalUploaded = false;
}
},
true);
}
mediaFileService.UploadMediaFileToStorageSync(
thumbnailFileStream,
mediaImage.ThumbnailUri,
mediaImage,
img =>
{
if (img != null)
{
img.IsThumbnailUploaded = true;
}
},
img =>
{
if (img != null)
{
img.IsThumbnailUploaded = false;
}
},
true);
OnAfterUploadCompleted(mediaImage, shouldNotUploadOriginal);
}
private void StartTasksForImageAsync(
MediaImage mediaImage,
Stream fileStream,
MemoryStream thumbnailFileStream,
bool shouldNotUploadOriginal = false)
{
var publicImageUpload = mediaFileService.UploadMediaFileToStorageAsync <MediaImage>(
fileStream,
mediaImage.FileUri,
mediaImage.Id,
img =>
{
if (img != null)
{
img.IsUploaded = true;
}
},
img =>
{
if (img != null)
{
img.IsUploaded = false;
}
},
true);
var publicThumbnailUpload = mediaFileService.UploadMediaFileToStorageAsync <MediaImage>(
thumbnailFileStream,
mediaImage.ThumbnailUri,
mediaImage.Id,
img =>
{
if (img != null)
{
img.IsThumbnailUploaded = true;
}
},
img =>
{
if (img != null)
{
img.IsThumbnailUploaded = false;
}
},
true);
var allTasks = new List <Task> {
publicImageUpload, publicThumbnailUpload
};
Task publicOriginalUpload = null;
if (!shouldNotUploadOriginal)
{
publicOriginalUpload = mediaFileService.UploadMediaFileToStorageAsync <MediaImage>(
fileStream,
mediaImage.OriginalUri,
mediaImage.Id,
img =>
{
if (img != null)
{
img.IsOriginalUploaded = true;
}
},
img =>
{
if (img != null)
{
img.IsOriginalUploaded = false;
}
},
true);
allTasks.Add(publicOriginalUpload);
}
Task.Factory.ContinueWhenAll(
allTasks.ToArray(),
result => ExecuteActionOnThreadSeparatedSessionWithNoConcurrencyTracking(
session =>
{
var media = session.Get <MediaImage>(mediaImage.Id);
if (media != null)
{
OnAfterUploadCompleted(media, shouldNotUploadOriginal);
}
}));
publicImageUpload.Start();
if (publicOriginalUpload != null)
{
publicOriginalUpload.Start();
}
publicThumbnailUpload.Start();
}
/// <summary>
/// Gets the isFailed field condition where restriction.
/// </summary>
/// <param name="alias">The table alias.</param>
/// <returns>nHybernate criterion</returns>
private static ICriterion GetIsFailedConditionCriterion(MediaImage alias)
{
return Restrictions.Where(() => alias.IsUploaded == false || alias.IsThumbnailUploaded == false || alias.IsOriginalUploaded == false);
}
/// <summary>
/// Gets the isProcessing field condition where restriction.
/// </summary>
/// <param name="alias">The table alias.</param>
/// <returns>nHybernate criterion</returns>
private static ICriterion GetIsProcessingConditionCriterion(MediaImage alias)
{
return(Restrictions.Where(() => alias.IsUploaded == null || alias.IsThumbnailUploaded == null || alias.IsOriginalUploaded == null));
}
/// <summary>
/// Replaces the image or if it doesn't exist, creates it.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// <c>PutImageResponse</c> with a image id.
/// </returns>
public PutImageResponse Put(PutImageRequest request)
{
IEnumerable <MediaFolder> parentFolderFuture = null;
if (request.Data.FolderId.HasValue)
{
parentFolderFuture = repository.AsQueryable <MediaFolder>()
.Where(c => c.Id == request.Data.FolderId.Value && !c.IsDeleted)
.ToFuture();
}
var mediaImage = repository.AsQueryable <MediaImage>()
.Where(file => file.Id == request.Id)
.ToFuture()
.FirstOrDefault();
MediaFolder parentFolder = null;
if (parentFolderFuture != null)
{
parentFolder = parentFolderFuture.First();
if (parentFolder.Type != Module.MediaManager.Models.MediaType.Image)
{
throw new CmsApiValidationException("Folder must be type of an image.");
}
}
var createImage = mediaImage == null;
if (createImage)
{
mediaImage = new MediaImage
{
Id = request.Id.GetValueOrDefault(),
Type = Module.MediaManager.Models.MediaType.Image
};
}
else if (request.Data.Version > 0)
{
mediaImage.Version = request.Data.Version;
}
unitOfWork.BeginTransaction();
if (!createImage)
{
repository.Save(mediaImage.CreateHistoryItem());
}
mediaImage.Title = request.Data.Title;
mediaImage.Description = request.Data.Description;
mediaImage.Caption = request.Data.Caption;
mediaImage.Size = request.Data.FileSize;
mediaImage.PublicUrl = request.Data.ImageUrl;
mediaImage.Width = request.Data.Width;
mediaImage.Height = request.Data.Height;
mediaImage.PublicThumbnailUrl = request.Data.ThumbnailUrl;
mediaImage.ThumbnailWidth = request.Data.ThumbnailWidth;
mediaImage.ThumbnailHeight = request.Data.ThumbnailHeight;
mediaImage.ThumbnailSize = request.Data.ThumbnailSize;
mediaImage.Folder = parentFolder;
mediaImage.PublishedOn = request.Data.PublishedOn;
mediaImage.OriginalFileName = request.Data.OriginalFileName;
mediaImage.OriginalFileExtension = request.Data.OriginalFileExtension;
mediaImage.OriginalWidth = request.Data.OriginalWidth;
mediaImage.OriginalHeight = request.Data.OriginalHeight;
mediaImage.OriginalSize = request.Data.OriginalSize;
mediaImage.PublicOriginallUrl = request.Data.OriginalUrl;
mediaImage.FileUri = new Uri(request.Data.FileUri);
mediaImage.IsUploaded = request.Data.IsUploaded;
mediaImage.IsTemporary = request.Data.IsTemporary;
mediaImage.IsCanceled = request.Data.IsCanceled;
mediaImage.OriginalUri = new Uri(request.Data.OriginalUri);
mediaImage.ThumbnailUri = new Uri(request.Data.ThumbnailUri);
var archivedMedias = new List <Media>();
var unarchivedMedias = new List <Media>();
if (mediaImage.IsArchived != request.Data.IsArchived)
{
if (request.Data.IsArchived)
{
archivedMedias.Add(mediaImage);
mediaService.ArchiveSubMedias(mediaImage, archivedMedias);
}
else
{
unarchivedMedias.Add(mediaImage);
mediaService.UnarchiveSubMedias(mediaImage, unarchivedMedias);
}
}
mediaImage.IsArchived = request.Data.IsArchived;
if (request.Data.Categories != null)
{
categoryService.CombineEntityCategories <Media, MediaCategory>(mediaImage, request.Data.Categories);
}
repository.Save(mediaImage);
IList <Tag> newTags = null;
if (request.Data.Tags != null)
{
tagService.SaveMediaTags(mediaImage, request.Data.Tags, out newTags);
}
unitOfWork.Commit();
// Fire events.
Events.RootEvents.Instance.OnTagCreated(newTags);
if (createImage)
{
Events.MediaManagerEvents.Instance.OnMediaFileUploaded(mediaImage);
}
else
{
Events.MediaManagerEvents.Instance.OnMediaFileUpdated(mediaImage);
}
foreach (var archivedMedia in archivedMedias.Distinct())
{
Events.MediaManagerEvents.Instance.OnMediaArchived(archivedMedia);
}
foreach (var archivedMedia in unarchivedMedias.Distinct())
{
Events.MediaManagerEvents.Instance.OnMediaUnarchived(archivedMedia);
}
return(new PutImageResponse
{
Data = mediaImage.Id
});
}
/// <summary>
/// Makes image as original.
/// </summary>
/// <param name="image">The new original image.</param>
/// <param name="originalImage">The current original image.</param>
/// <param name="archivedImage">The archived image.</param>
/// <param name="overrideUrl">To override public Url ot not.</param>
/// <returns>The new original image.</returns>
public MediaImage MakeAsOriginal(MediaImage image, MediaImage originalImage, MediaImage archivedImage, bool overrideUrl = true)
{
overrideUrl = false; // TODO: temporary disabling feature #1055.
var folderName = Path.GetFileName(Path.GetDirectoryName(originalImage.FileUri.OriginalString));
using (var fileStream = DownloadFileStream(image.PublicUrl))
{
string publicUrlTemp = string.Empty,
publicThumbnailUrlTemp = string.Empty,
publicOriginallUrlTemp = string.Empty;
Uri fileUriTemp = null, thumbnailUriTemp = null, originalUriTemp = null;
if (overrideUrl)
{
publicUrlTemp = originalImage.PublicUrl;
fileUriTemp = originalImage.FileUri;
publicThumbnailUrlTemp = originalImage.PublicThumbnailUrl;
thumbnailUriTemp = originalImage.ThumbnailUri;
publicOriginallUrlTemp = originalImage.PublicOriginallUrl;
originalUriTemp = originalImage.OriginalUri;
}
image.CopyDataTo(originalImage, false);
MediaHelper.SetCollections(repository, image, originalImage);
if (!overrideUrl)
{
var publicFileName = MediaHelper.RemoveInvalidPathSymbols(MediaImageHelper.CreateVersionedFileName(originalImage.OriginalFileName, GetVersion(originalImage)));
mediaImageVersionPathService.SetPathForNewOriginal(originalImage, folderName, publicFileName, ImageHelper.GetImageType(originalImage.OriginalFileExtension), archivedImage.OriginalUri, archivedImage.PublicOriginallUrl);
}
else
{
originalImage.PublicUrl = publicUrlTemp;
originalImage.FileUri = fileUriTemp;
originalImage.PublicThumbnailUrl = publicThumbnailUrlTemp;
originalImage.ThumbnailUri = thumbnailUriTemp;
originalImage.PublicOriginallUrl = publicOriginallUrlTemp;
originalImage.OriginalUri = originalUriTemp;
}
originalImage.Original = null;
originalImage.PublishedOn = DateTime.Now;
if (image.IsEdited())
{
originalImage.PublicOriginallUrl = image.PublicOriginallUrl;
originalImage.OriginalUri = image.OriginalUri;
}
unitOfWork.BeginTransaction();
repository.Save(originalImage);
unitOfWork.Commit();
if (!image.IsEdited())
{
using (var fileStreamReplica = new MemoryStream())
{
fileStream.CopyTo(fileStreamReplica);
storageService.UploadObject(new UploadRequest {
InputStream = fileStreamReplica, Uri = originalImage.OriginalUri, IgnoreAccessControl = true
});
}
}
storageService.UploadObject(new UploadRequest {
InputStream = fileStream, Uri = originalImage.FileUri, IgnoreAccessControl = true
});
UpdateThumbnail(originalImage, Size.Empty);
return(originalImage);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ImageDimensionsCalculator" /> class.
/// </summary>
/// <param name="image">The image.</param>
public ImageDimensionsCalculator(MediaImage image)
: this(image.Width, image.Height, image.OriginalWidth, image.OriginalHeight, image.CropCoordX1, image.CropCoordX2, image.CropCoordY1, image.CropCoordY2)
{
}
/// <summary>
/// Uploads the image.
/// </summary>
/// <param name="rootFolderId">The root folder id.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="fileLength">Length of the file.</param>
/// <param name="fileStream">The file stream.</param>
/// <returns>Image entity.</returns>
public MediaImage UploadImage(Guid rootFolderId, string fileName, long fileLength, Stream fileStream, Guid reuploadMediaId)
{
MediaImage originalMedia;
string folderName;
string versionedFileName;
Size size;
if (!reuploadMediaId.HasDefaultValue())
{
originalMedia = repository.First <MediaImage>(image => image.Id == reuploadMediaId);
fileName = string.Concat(Path.GetFileNameWithoutExtension(originalMedia.OriginalFileName), Path.GetExtension(fileName));
folderName = Path.GetFileName(Path.GetDirectoryName(originalMedia.FileUri.OriginalString));
versionedFileName = MediaImageHelper.CreateVersionedFileName(fileName, originalMedia.Version + 1);
}
else
{
folderName = mediaFileService.CreateRandomFolderName();
versionedFileName = MediaImageHelper.CreateVersionedFileName(fileName, 1);
}
try
{
size = GetImageSize(fileStream);
}
catch (ImagingException ex)
{
var message = MediaGlobalization.MultiFileUpload_ImageFormatNotSuported;
const string logMessage = "Failed to get image size.";
throw new ValidationException(() => message, logMessage, ex);
}
using (var thumbnailImage = new MemoryStream())
{
CreatePngThumbnail(fileStream, thumbnailImage, ThumbnailSize);
MediaImage image = new MediaImage();
if (!rootFolderId.HasDefaultValue())
{
image.Folder = repository.AsProxy <MediaFolder>(rootFolderId);
}
image.Title = Path.GetFileName(fileName);
image.Caption = null;
image.OriginalFileName = fileName;
image.OriginalFileExtension = Path.GetExtension(fileName);
image.Type = MediaType.Image;
image.Width = size.Width;
image.Height = size.Height;
image.Size = fileLength;
image.FileUri = mediaFileService.GetFileUri(MediaType.Image, folderName, versionedFileName);
image.PublicUrl = mediaFileService.GetPublicFileUrl(MediaType.Image, folderName, versionedFileName);
image.CropCoordX1 = null;
image.CropCoordY1 = null;
image.CropCoordX2 = null;
image.CropCoordY2 = null;
image.OriginalWidth = size.Width;
image.OriginalHeight = size.Height;
image.OriginalSize = fileLength;
image.OriginalUri = mediaFileService.GetFileUri(MediaType.Image, folderName, MediaImageHelper.OriginalImageFilePrefix + versionedFileName);
image.PublicOriginallUrl = mediaFileService.GetPublicFileUrl(MediaType.Image, folderName, MediaImageHelper.OriginalImageFilePrefix + versionedFileName);
image.ThumbnailWidth = ThumbnailSize.Width;
image.ThumbnailHeight = ThumbnailSize.Height;
image.ThumbnailSize = thumbnailImage.Length;
image.ThumbnailUri = mediaFileService.GetFileUri(MediaType.Image, folderName, ThumbnailImageFilePrefix + Path.GetFileNameWithoutExtension(versionedFileName) + ".png");
image.PublicThumbnailUrl = mediaFileService.GetPublicFileUrl(MediaType.Image, folderName, ThumbnailImageFilePrefix + Path.GetFileNameWithoutExtension(versionedFileName) + ".png");
image.ImageAlign = null;
image.IsTemporary = true;
image.IsUploaded = null;
image.IsThumbnailUploaded = null;
image.IsOriginalUploaded = null;
unitOfWork.BeginTransaction();
repository.Save(image);
unitOfWork.Commit();
Task imageUpload = mediaFileService.UploadMediaFileToStorage <MediaImage>(fileStream, image.FileUri, image.Id, img => { img.IsUploaded = true; }, img => { img.IsUploaded = false; }, true);
Task originalUpload = mediaFileService.UploadMediaFileToStorage <MediaImage>(fileStream, image.OriginalUri, image.Id, img => { img.IsOriginalUploaded = true; }, img => { img.IsOriginalUploaded = false; }, true);
Task thumbnailUpload = mediaFileService.UploadMediaFileToStorage <MediaImage>(thumbnailImage, image.ThumbnailUri, image.Id, img => { img.IsThumbnailUploaded = true; }, img => { img.IsThumbnailUploaded = false; }, true);
Task.Factory.ContinueWhenAll(
new[]
{
imageUpload,
originalUpload,
thumbnailUpload
},
result =>
{
// During uploading progress Cancel action can by executed. Need to remove uploaded images from the storage.
ExecuteActionOnThreadSeparatedSessionWithNoConcurrencyTracking(session =>
{
var media = session.Get <MediaImage>(image.Id);
var isUploaded = (media.IsUploaded.HasValue && media.IsUploaded.Value) ||
(media.IsThumbnailUploaded.HasValue && media.IsThumbnailUploaded.Value) ||
(media.IsOriginalUploaded.HasValue && media.IsOriginalUploaded.Value);
if (media.IsCanceled && isUploaded)
{
RemoveImageWithFiles(media.Id, media.Version);
}
});
});
imageUpload.Start();
originalUpload.Start();
thumbnailUpload.Start();
return(image);
}
}
public async Task SeedAsync(ApplicationDbContext dbContext, IServiceProvider serviceProvider, string rootPath)
{
var posterPath = rootPath + "\\images\\posters\\";
var backdropPath = rootPath + "\\images\\backdrops\\";
if (dbContext.Movies.Any())
{
return;
}
string posterDir = rootPath + "\\images\\posters\\";
if (!Directory.Exists(posterDir))
{
Directory.CreateDirectory(posterDir);
}
for (int i = 1; i <= Pages; i++)
{
var result = await this.GetMediaJsonAsync(i);
foreach (var movie in result.Movies)
{
Movie dbMovie = new Movie()
{
Title = movie.Title,
Overview = movie.Overview,
MovieApiId = movie.MovieApiId,
};
if (!DateTime.TryParse(movie.ReleaseDate, out DateTime movieReleaseDate))
{
dbMovie.ReleaseDate = null;
}
else
{
dbMovie.ReleaseDate = movieReleaseDate;
}
var genres = dbContext.Genres.Where(x => movie.GenresIds.Contains(x.ApiId));
foreach (var genre in genres)
{
dbMovie.Genres.Add(new MediaGenre()
{
Genre = genre,
Media = dbMovie,
});
}
await dbContext.Movies.AddAsync(dbMovie);
var imagePath = await this.DownloadImageAsync("https://image.tmdb.org/t/p/w500/" + movie.PosterPath, dbMovie.Id);
MediaImage image = new MediaImage()
{
Media = dbMovie,
ImageType = Data.Models.Enums.ImageType.Poster,
Path = imagePath,
Extension = System.IO.Path.GetExtension(imagePath),
Title = dbMovie.Title + " - Poster",
};
await dbContext.MediaImages.AddAsync(image);
await dbContext.SaveChangesAsync();
}
}
}
/// <summary>
/// Gets the isProcessing field conditions.
/// </summary>
/// <param name="alias">The table alias.</param>
/// <returns>Conditional nHybernate projection</returns>
public static IProjection GetIsProcessingConditions(this MediaImage alias)
{
return(Projections.Conditional(GetIsProcessingConditionCriterion(alias),
Projections.Constant(true, NHibernateUtil.Boolean),
Projections.Constant(false, NHibernateUtil.Boolean)));
}
/// <summary>
/// Gets the isFailed field condition where restriction.
/// </summary>
/// <param name="alias">The table alias.</param>
/// <returns>nHybernate criterion</returns>
private static ICriterion GetIsFailedConditionCriterion(MediaImage alias)
{
return(Restrictions.Where(() => alias.IsUploaded == false || alias.IsThumbnailUploaded == false || alias.IsOriginalUploaded == false));
}
private void StartTasksForImageAsync(
MediaImage mediaImage,
Stream fileStream,
MemoryStream thumbnailFileStream,
bool shouldNotUploadOriginal = false)
{
var allTasks = new List <Task>();
var publicImageUpload = mediaFileService.UploadMediaFileToStorageAsync <MediaImage>(
fileStream,
mediaImage.FileUri,
mediaImage.Id,
(img, session) =>
{
if (img != null)
{
img.IsUploaded = true;
}
},
img =>
{
if (img != null)
{
img.IsUploaded = false;
}
},
true);
allTasks.Add(publicImageUpload);
var publicThumbnailUpload = mediaFileService.UploadMediaFileToStorageAsync <MediaImage>(
thumbnailFileStream,
mediaImage.ThumbnailUri,
mediaImage.Id,
(img, session) =>
{
if (img != null)
{
img.IsThumbnailUploaded = true;
}
},
img =>
{
if (img != null)
{
img.IsThumbnailUploaded = false;
}
},
true);
allTasks.Add(publicThumbnailUpload);
Task publicOriginalUpload = null;
if (!shouldNotUploadOriginal)
{
publicOriginalUpload = mediaFileService.UploadMediaFileToStorageAsync <MediaImage>(
fileStream,
mediaImage.OriginalUri,
mediaImage.Id,
(img, session) =>
{
if (img != null)
{
img.IsOriginalUploaded = true;
}
},
img =>
{
if (img != null)
{
img.IsOriginalUploaded = false;
}
},
true);
allTasks.Add(publicOriginalUpload);
}
allTasks.ForEach(task => task.ContinueWith((t) => { Log.Error("Error observed while executing parallel task during image upload.", t.Exception); }, TaskContinuationOptions.OnlyOnFaulted));
Task.Factory.ContinueWhenAll(
allTasks.ToArray(),
result =>
{
try
{
ExecuteActionOnThreadSeparatedSessionWithNoConcurrencyTracking(
session =>
{
var media = session.Get <MediaImage>(mediaImage.Id);
if (media != null)
{
OnAfterUploadCompleted(media, shouldNotUploadOriginal);
}
});
}
catch (Exception ex)
{
Log.Error("Failed to finalize upload.", ex);
}
});
publicImageUpload.Start();
if (publicOriginalUpload != null)
{
publicOriginalUpload.Start();
}
if (publicThumbnailUpload != null)
{
publicThumbnailUpload.Start();
}
}
/// <summary>
/// Uploads the image.
/// </summary>
/// <param name="rootFolderId">The root folder id.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="fileLength">Length of the file.</param>
/// <param name="fileStream">The file stream.</param>
/// <param name="reuploadMediaId">The reupload media identifier.</param>
/// <param name="overrideUrl">if set to <c>true</c> override URL.</param>
/// <returns>
/// Image entity.
/// </returns>
public MediaImage UploadImage(Guid rootFolderId, string fileName, long fileLength, Stream fileStream, Guid reuploadMediaId, bool overrideUrl = true)
{
overrideUrl = false; // TODO: temporary disabling feature #1055.
using (var thumbnailFileStream = new MemoryStream())
{
MediaImage originalImage;
string folderName;
string publicFileName;
fileStream = RotateImage(fileStream);
var size = GetSize(fileStream);
CreatePngThumbnail(fileStream, thumbnailFileStream, ThumbnailSize);
if (!reuploadMediaId.HasDefaultValue())
{
// Re-uploading image: Get original image, folder name, file extension, file name
originalImage = repository.First <MediaImage>(image => image.Id == reuploadMediaId);
folderName = Path.GetFileName(Path.GetDirectoryName(originalImage.FileUri.OriginalString));
MediaImage clonedOriginalImage = (MediaImage)originalImage.Clone();
clonedOriginalImage.Original = originalImage;
// Get original file stream
using (var originalFileStream = DownloadFileStream(originalImage.PublicUrl))
{
// Get thumbnail file stream
using (var originalThumbnailFileStream = DownloadFileStream(originalImage.PublicThumbnailUrl))
{
// Check is re-uploaded image has the same extension as original
var reuploadedFileExtension = Path.GetExtension(fileName);
if (reuploadedFileExtension != null && !reuploadedFileExtension.Equals(originalImage.OriginalFileExtension))
{
fileStream = UpdateCodec(fileStream, originalFileStream);
}
// Create version file name for current original image
var historicalUrl = MediaImageHelper.CreateHistoricalVersionedFileName(
clonedOriginalImage.OriginalFileName,
clonedOriginalImage.OriginalFileExtension);
// Update urls with version file name
mediaImageVersionPathService.SetPathForArchive(clonedOriginalImage, folderName, historicalUrl);
unitOfWork.BeginTransaction();
repository.Save(clonedOriginalImage);
unitOfWork.Commit();
// Re-upload original and thumbnail images to version urls
StartTasksForImage(clonedOriginalImage, originalFileStream, originalThumbnailFileStream, originalImage.IsEdited());
}
}
UpdateImageProperties(originalImage, rootFolderId, originalImage.OriginalFileName, originalImage.OriginalFileExtension, originalImage.Title, size, fileLength,
thumbnailFileStream.Length);
if (!overrideUrl)
{
publicFileName = MediaImageHelper.CreateVersionedFileName(originalImage.OriginalFileName, GetVersion(originalImage));
mediaImageVersionPathService.SetPathForNewOriginal(originalImage, folderName, publicFileName);
}
}
else
{
// Uploading new image
folderName = mediaFileService.CreateRandomFolderName();
publicFileName = MediaImageHelper.CreatePublicFileName(fileName, Path.GetExtension(fileName));
// Create new original image and upload file stream to the storage
originalImage = CreateImage(rootFolderId, fileName, Path.GetExtension(fileName), fileName, size, fileLength, thumbnailFileStream.Length);
mediaImageVersionPathService.SetPathForNewOriginal(originalImage, folderName, publicFileName);
}
unitOfWork.BeginTransaction();
repository.Save(originalImage);
unitOfWork.Commit();
StartTasksForImage(originalImage, fileStream, thumbnailFileStream, false);
return(originalImage);
}
}
/// <summary>
/// Uploads the image.
/// </summary>
/// <param name="rootFolderId">The root folder id.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="fileLength">Length of the file.</param>
/// <param name="fileStream">The file stream.</param>
/// <param name="reuploadMediaId">The reupload media identifier.</param>
/// <param name="overrideUrl">if set to <c>true</c> override URL.</param>
/// <returns>
/// Image entity.
/// </returns>
public MediaImage UploadImage(Guid rootFolderId, string fileName, long fileLength, Stream fileStream, Guid reuploadMediaId, bool overrideUrl = true)
{
overrideUrl = false; // TODO: temporary disabling feature #1055.
var folderName = mediaFileService.CreateRandomFolderName();
var publicFileName = MediaHelper.RemoveInvalidPathSymbols(MediaImageHelper.CreatePublicFileName(fileName, Path.GetExtension(fileName)));
var fileExtension = Path.GetExtension(fileName);
var imageType = ImageHelper.GetImageType(fileExtension);
MediaImage uploadImage = null;
MemoryStream thumbnailFileStream = new MemoryStream();
Size size;
Size thumbnailSize = ThumbnailSize;
long thumbnailImageLength;
/* Upload standard raster type images */
if (imageType == ImageType.Raster)
{
fileStream = RotateImage(fileStream);
size = GetSize(fileStream);
CreatePngThumbnail(fileStream, thumbnailFileStream, ThumbnailSize);
thumbnailImageLength = thumbnailFileStream.Length;
}
/* Upload vector graphics images */
else
{
size = Size.Empty;
ReadParametersFormVectorImage(fileStream, ref size);
thumbnailImageLength = fileStream.Length;
CreateSvgThumbnail(fileStream, thumbnailFileStream, ThumbnailSize);
}
try
{
if (!reuploadMediaId.HasDefaultValue())
{
// Re-uploading image: Get original image, folder name, file extension, file name
uploadImage = (MediaImage)repository.First <MediaImage>(image => image.Id == reuploadMediaId).Clone();
uploadImage.IsTemporary = true;
// Create new original image and upload file stream to the storage
uploadImage = CreateImage(rootFolderId, fileName, fileExtension, Path.GetFileName(fileName), size, fileLength);
}
else
{
// Uploading new image
// Create new original image and upload file stream to the storage
uploadImage = CreateImage(
rootFolderId,
fileName,
fileExtension,
Path.GetFileName(fileName),
size,
fileLength);
}
SetThumbnailParameters(uploadImage, thumbnailSize, thumbnailImageLength);
mediaImageVersionPathService.SetPathForNewOriginal(uploadImage, folderName, publicFileName, imageType);
unitOfWork.BeginTransaction();
repository.Save(uploadImage);
unitOfWork.Commit();
StartTasksForImage(uploadImage, fileStream, thumbnailFileStream, false);
}
finally
{
if (thumbnailFileStream != null)
{
thumbnailFileStream.Dispose();
}
}
return(uploadImage);
}
private MediaImage CreateImage(
Guid?rootFolderId,
string fileName,
string extension,
string imageTitle,
Size size,
long fileLength,
long thumbnailImageLength,
MediaImage filledInImage = null)
{
MediaImage image;
if (filledInImage == null)
{
image = new MediaImage();
if (rootFolderId != null && !((Guid)rootFolderId).HasDefaultValue())
{
image.Folder = repository.AsProxy <MediaFolder>((Guid)rootFolderId);
}
image.Title = Path.GetFileName(imageTitle);
image.Caption = null;
image.Size = fileLength;
image.IsTemporary = true;
}
else
{
image = filledInImage;
}
image.OriginalFileName = fileName;
image.OriginalFileExtension = extension;
image.Type = MediaType.Image;
image.Width = size.Width;
image.Height = size.Height;
image.CropCoordX1 = null;
image.CropCoordY1 = null;
image.CropCoordX2 = null;
image.CropCoordY2 = null;
image.OriginalWidth = size.Width;
image.OriginalHeight = size.Height;
image.OriginalSize = fileLength;
image.ThumbnailWidth = ThumbnailSize.Width;
image.ThumbnailHeight = ThumbnailSize.Height;
image.ThumbnailSize = thumbnailImageLength;
image.ImageAlign = null;
image.IsUploaded = null;
image.IsThumbnailUploaded = null;
image.IsOriginalUploaded = null;
return(image);
}
public void SaveImage(MediaImage image)
{
unitOfWork.BeginTransaction();
repository.Save(image);
unitOfWork.Commit();
}
private int GetVersion(MediaImage image)
{
var versionsCount = repository.AsQueryable <MediaImage>().Count(i => i.Original != null && i.Original.Id == image.Id);
return(versionsCount);
}
/// <summary>
/// Gets the isProcessing field condition where restriction.
/// </summary>
/// <param name="alias">The table alias.</param>
/// <returns>nHybernate criterion</returns>
private static ICriterion GetIsProcessingConditionCriterion(MediaImage alias)
{
return Restrictions.Where(() => alias.IsUploaded == null || alias.IsThumbnailUploaded == null || alias.IsOriginalUploaded == null);
}
/// <summary>
/// Uploads the image.
/// </summary>
/// <param name="rootFolderId">The root folder id.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="fileLength">Length of the file.</param>
/// <param name="fileStream">The file stream.</param>
/// <returns>Image entity.</returns>
public MediaImage UploadImage(Guid rootFolderId, string fileName, long fileLength, Stream fileStream, Guid reuploadMediaId, MediaImage filledInImage = null)
{
var size = GetSize(fileStream);
using (var thumbnailFileStream = new MemoryStream())
{
MediaImage publicImage;
string folderName;
string publicFileName;
fileStream = RotateImage(fileStream);
CreatePngThumbnail(fileStream, thumbnailFileStream, ThumbnailSize);
if (!reuploadMediaId.HasDefaultValue())
{
// Re-uploading image: Get original image, folder name, file extension, file name
var originalImage = repository.First <MediaImage>(image => image.Id == reuploadMediaId);
folderName = Path.GetFileName(Path.GetDirectoryName(originalImage.FileUri.OriginalString));
publicFileName = MediaImageHelper.CreatePublicFileName(originalImage.OriginalFileName, originalImage.OriginalFileExtension);
// Get original file stream
using (var originalFileStream = DownloadFileStream(originalImage.PublicUrl))
{
// Get thumbnail file stream
using (var originalThumbnailFileStream = DownloadFileStream(originalImage.PublicThumbnailUrl))
{
// Check is re-uploaded image has the same extension as original
var reuploadedFileExtension = Path.GetExtension(fileName);
if (reuploadedFileExtension != null && !reuploadedFileExtension.Equals(originalImage.OriginalFileExtension))
{
fileStream = UpdateCodec(fileStream, originalFileStream);
}
// Create version file name for current original image
var versionedFileName = MediaImageHelper.CreateVersionedFileName(
originalImage.OriginalFileName, originalImage.OriginalFileExtension, GetVersion(originalImage));
// Update urls with version file name
mediaImageVersionPathService.SetPathForArchive(originalImage, folderName, versionedFileName);
// Re-upload original and thumbnail images to version urls
StartTasksForImage(originalImage, originalFileStream, originalThumbnailFileStream, originalImage.IsEdited());
}
}
publicImage = CreateImage(rootFolderId, originalImage.OriginalFileName, originalImage.OriginalFileExtension, originalImage.Title, size, fileLength,
thumbnailFileStream.Length);
mediaImageVersionPathService.SetPathForNewOriginal(publicImage, folderName, publicFileName);
}
else
{
// Uploading new image
folderName = mediaFileService.CreateRandomFolderName();
publicFileName = MediaImageHelper.CreatePublicFileName(fileName, Path.GetExtension(fileName));
// Create new original image and upload file stream to the storage
publicImage = CreateImage(rootFolderId, fileName, Path.GetExtension(fileName), fileName, size, fileLength, thumbnailFileStream.Length, filledInImage);
mediaImageVersionPathService.SetPathForNewOriginal(publicImage, folderName, publicFileName);
}
unitOfWork.BeginTransaction();
repository.Save(publicImage);
unitOfWork.Commit();
StartTasksForImage(publicImage, fileStream, thumbnailFileStream);
if (!reuploadMediaId.HasDefaultValue())
{
// Update original id for version image
var originalMedia = repository.First <MediaImage>(image => image.Id == reuploadMediaId);
originalMedia.Original = publicImage;
unitOfWork.BeginTransaction();
while (true)
{
var preOriginalId = originalMedia.Id;
var prePreOriginal = repository.FirstOrDefault <MediaImage>(i => i.Original != null && i.Original.Id == preOriginalId);
if (prePreOriginal != null)
{
prePreOriginal.Original = publicImage;
repository.Save(prePreOriginal);
preOriginalId = prePreOriginal.Id;
}
else
{
break;
}
}
repository.Save(originalMedia);
unitOfWork.Commit();
}
return(publicImage);
}
}
