/// <summary>
/// Sets pathes for archive image.
/// </summary>
/// <param name="archivedImage">The archived image object.</param>
/// <param name="folderName">The folder name.</param>
/// <param name="fileName">The file name.</param>
public void SetPathForArchive(MediaImage archivedImage, string folderName, string fileName)
{
archivedImage.FileUri = mediaFileService.GetFileUri(MediaType.Image, folderName, fileName);
archivedImage.PublicUrl = mediaFileService.GetPublicFileUrl(MediaType.Image, folderName, fileName);
if (!archivedImage.IsEdited())
{
archivedImage.OriginalUri = mediaFileService.GetFileUri(MediaType.Image, folderName, MediaImageHelper.OriginalImageFilePrefix + fileName);
archivedImage.PublicOriginallUrl = mediaFileService.GetPublicFileUrl(MediaType.Image, folderName, MediaImageHelper.OriginalImageFilePrefix + fileName);
}
archivedImage.ThumbnailUri = mediaFileService.GetFileUri(MediaType.Image, folderName, ThumbnailImageFilePrefix + Path.GetFileNameWithoutExtension(fileName) + ".png");
archivedImage.PublicThumbnailUrl = mediaFileService.GetPublicFileUrl(MediaType.Image, folderName, ThumbnailImageFilePrefix + Path.GetFileNameWithoutExtension(fileName) + ".png");
}
/// <summary>
/// Upload image from the stream.
/// </summary>
/// <param name="request">The upload image request.</param>
/// <returns>The upload image response.</returns>
public UploadImageResponse Post(UploadImageRequest request)
{
MediaFolder parentFolder = null;
if (request.Data.FolderId.HasValue)
{
parentFolder = repository.AsQueryable<MediaFolder>()
.Where(c => c.Id == request.Data.FolderId.Value && !c.IsDeleted)
.FirstOne();
if (parentFolder.Type != Module.MediaManager.Models.MediaType.Image)
{
throw new CmsApiValidationException("Folder must be type of an image.");
}
}
var maxLength = configuration.Storage.MaximumFileNameLength > 0 ? configuration.Storage.MaximumFileNameLength : 100;
// Fix for IIS express + IE (if full path is returned)
var fileName = Path.GetFileName(request.Data.FileName);
if (fileName.Length > maxLength)
{
fileName = string.Concat(Path.GetFileNameWithoutExtension(fileName.Substring(0, maxLength)), Path.GetExtension(fileName));
}
var mediaImage = new MediaImage
{
Id = request.Data.Id.GetValueOrDefault(),
Type = Module.MediaManager.Models.MediaType.Image,
Caption = request.Data.Caption,
Title = request.Data.Title ?? fileName,
Description = request.Data.Description,
Size = request.Data.FileStream.Length,
Folder = parentFolder,
OriginalFileName = fileName,
OriginalFileExtension = Path.GetExtension(fileName)
};
var savedImage = mediaImageService.UploadImageWithStream(request.Data.FileStream, mediaImage, request.Data.WaitForUploadResult);
if (savedImage != null)
{
Events.MediaManagerEvents.Instance.OnMediaFileUploaded(savedImage);
}
return new UploadImageResponse
{
Data = savedImage.Id,
};
}
/// <summary>
/// Upload image from the stream.
/// </summary>
/// <param name="request">The upload image request.</param>
/// <returns>The upload image response.</returns>
public UploadImageResponse Post(UploadImageRequest request)
{
MediaFolder parentFolder = null;
if (request.Data.FolderId.HasValue)
{
parentFolder = repository.AsQueryable<MediaFolder>()
.Where(c => c.Id == request.Data.FolderId.Value && !c.IsDeleted)
.FirstOne();
if (parentFolder.Type != Module.MediaManager.Models.MediaType.Image)
{
throw new CmsApiValidationException("Folder must be type of an image.");
}
}
var mediaImage = new MediaImage
{
Id = request.Data.Id.GetValueOrDefault(),
Type = Module.MediaManager.Models.MediaType.Image,
Caption = request.Data.Caption,
Title = request.Data.Title ?? Path.GetFileName(request.Data.FileName),
Description = request.Data.Description,
Size = request.Data.FileStream.Length,
Folder = parentFolder,
OriginalFileName = request.Data.FileName,
OriginalFileExtension = Path.GetExtension(request.Data.FileName)
};
var savedImage = mediaImageService.UploadImageWithStream(request.Data.FileStream, mediaImage, request.Data.WaitForUploadResult);
if (savedImage != null)
{
Events.MediaManagerEvents.Instance.OnMediaFileUploaded(savedImage);
}
return new UploadImageResponse
{
Data = savedImage.Id,
};
}
/// <summary>
/// Sets pathes for new original image.
/// </summary>
/// <param name="newOriginalImage">The new original image object.</param>
/// <param name="folderName">The folder name.</param>
/// <param name="fileName">The file name.</param>
/// <param name="archivedImageOriginalUri">The original Uri for archived image.</param>
/// <param name="archivedImagePublicOriginalUrl">The public original Url for archived image.</param>
public void SetPathForNewOriginal(MediaImage newOriginalImage, string folderName, string fileName, Uri archivedImageOriginalUri = null, string archivedImagePublicOriginalUrl = "")
{
newOriginalImage.FileUri = mediaFileService.GetFileUri(MediaType.Image, folderName, fileName);
newOriginalImage.PublicUrl = mediaFileService.GetPublicFileUrl(MediaType.Image, folderName, fileName);
if (!newOriginalImage.IsEdited())
{
newOriginalImage.OriginalUri = mediaFileService.GetFileUri(MediaType.Image, folderName, MediaImageHelper.OriginalImageFilePrefix + fileName);
newOriginalImage.PublicOriginallUrl = mediaFileService.GetPublicFileUrl(MediaType.Image, folderName, MediaImageHelper.OriginalImageFilePrefix + fileName);
}
else
{
if(archivedImageOriginalUri == null || archivedImagePublicOriginalUrl == null)
throw new CmsException("Not valid Url or Uri for original image");
newOriginalImage.OriginalUri = archivedImageOriginalUri;
newOriginalImage.PublicOriginallUrl = archivedImagePublicOriginalUrl;
}
newOriginalImage.ThumbnailUri = mediaFileService.GetFileUri(MediaType.Image, folderName, ThumbnailImageFilePrefix + Path.GetFileNameWithoutExtension(fileName) + ".png");
newOriginalImage.PublicThumbnailUrl = mediaFileService.GetPublicFileUrl(MediaType.Image, folderName, ThumbnailImageFilePrefix + Path.GetFileNameWithoutExtension(fileName) + ".png");
}
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;
}
private MediaImage RevertChanges(MediaImage canceledImage)
{
var previousOriginal =
repository.AsQueryable<MediaImage>().OrderByDescending(i => i.PublishedOn).FirstOrDefault(f => f.Original != null && f.Original.Id == canceledImage.Id);
if (previousOriginal != null)
{
var folderName = Path.GetFileName(Path.GetDirectoryName(previousOriginal.FileUri.OriginalString));
var publicFileName = MediaImageHelper.CreatePublicFileName(previousOriginal.OriginalFileName, previousOriginal.OriginalFileExtension);
// Get original file stream
using (var fileStream = DownloadFileStream(previousOriginal.PublicUrl))
{
// Get thumbnail file stream
using (var thumbnailFileStream = DownloadFileStream(previousOriginal.PublicThumbnailUrl))
{
previousOriginal.CopyDataTo(canceledImage);
mediaImageVersionPathService.SetPathForArchive(canceledImage, folderName, publicFileName);
StartTasksForImage(canceledImage, fileStream, thumbnailFileStream, previousOriginal.IsEdited());
canceledImage.Original = null;
unitOfWork.BeginTransaction();
repository.Save(canceledImage);
unitOfWork.Commit();
}
}
}
return previousOriginal;
}
/// <summary>
/// Moves current original image to history.
/// </summary>
/// <param name="originalImage">The current original image.</param>
/// <returns>The archived image.</returns>
public MediaImage MoveToHistory(MediaImage originalImage)
{
var clonnedOriginalImage = (MediaImage)originalImage.Clone();
clonnedOriginalImage.Original = originalImage;
var historicalFileName = MediaImageHelper.CreateHistoricalVersionedFileName(
originalImage.OriginalFileName,
originalImage.OriginalFileExtension);
var folderName = Path.GetFileName(Path.GetDirectoryName(originalImage.FileUri.OriginalString));
using (var originalFileStream = DownloadFileStream(clonnedOriginalImage.PublicUrl))
{
using (var originalThumbnailFileStream = DownloadFileStream(clonnedOriginalImage.PublicThumbnailUrl))
{
mediaImageVersionPathService.SetPathForArchive(clonnedOriginalImage, folderName, historicalFileName);
unitOfWork.BeginTransaction();
repository.Save(clonnedOriginalImage);
unitOfWork.Commit();
StartTasksForImage(clonnedOriginalImage, originalFileStream, originalThumbnailFileStream, originalImage.IsEdited());
}
}
return clonnedOriginalImage;
}
/// <summary>
/// Updates the thumbnail.
/// </summary>
/// <param name="mediaImage">The media image.</param>
/// <param name="size">The size.</param>
public void UpdateThumbnail(MediaImage mediaImage, Size size)
{
if (size.IsEmpty)
{
size = ThumbnailSize;
}
var downloadResponse = storageService.DownloadObject(mediaImage.FileUri);
var imageType = ImageHelper.GetImageType(mediaImage.OriginalFileExtension);
using (var memoryStream = new MemoryStream())
{
if (imageType == ImageType.Raster)
{
CreatePngThumbnail(downloadResponse.ResponseStream, memoryStream, size);
}
else
{
CreateSvgThumbnail(downloadResponse.ResponseStream, memoryStream, size);
}
mediaImage.ThumbnailWidth = size.Width;
mediaImage.ThumbnailHeight = size.Height;
mediaImage.ThumbnailSize = memoryStream.Length;
storageService.UploadObject(new UploadRequest { InputStream = memoryStream, Uri = mediaImage.ThumbnailUri, IgnoreAccessControl = true});
}
}
/// <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;
}
}
private void OnAfterUploadCompleted(MediaImage media, bool shouldNotUploadOriginal)
{
var isUploaded = (media.IsUploaded.HasValue && media.IsUploaded.Value) || (media.IsThumbnailUploaded.HasValue && media.IsThumbnailUploaded.Value)
|| ((media.IsOriginalUploaded.HasValue && media.IsOriginalUploaded.Value) && shouldNotUploadOriginal);
if (media.IsCanceled && isUploaded)
{
RemoveImageWithFiles(media.Id, media.Version, false, shouldNotUploadOriginal);
}
}
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);
}
/// <summary>
/// Updates the thumbnail.
/// </summary>
/// <param name="mediaImage">The media image.</param>
/// <param name="size">The size.</param>
private void UpdateThumbnail(MediaImage mediaImage, Size size)
{
var downloadResponse = storageService.DownloadObject(mediaImage.FileUri);
using (var memoryStream = new MemoryStream())
{
ResizeImageAndCropToFit(downloadResponse.ResponseStream, memoryStream, size);
storageService.UploadObject(new UploadRequest { InputStream = memoryStream, Uri = mediaImage.ThumbnailUri });
mediaImage.ThumbnailWidth = size.Width;
mediaImage.ThumbnailHeight = size.Height;
mediaImage.ThumbnailSize = memoryStream.Length;
}
}
/// <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)
{
string folderName = mediaFileService.CreateRandomFolderName();
Size size = GetImageSize(fileStream);
using (var thumbnailImage = new MemoryStream())
{
ResizeImageAndCropToFit(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.FileName = fileName;
image.FileExtension = 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, fileName);
image.PublicUrl = mediaFileService.GetPublicFileUrl(MediaType.Image, folderName, fileName);
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, OriginalImageFilePrefix + fileName);
image.PublicOriginallUrl = mediaFileService.GetPublicFileUrl(MediaType.Image, folderName, OriginalImageFilePrefix + fileName);
image.ThumbnailWidth = ThumbnailSize.Width;
image.ThumbnailHeight = ThumbnailSize.Height;
image.ThumbnailSize = thumbnailImage.Length;
image.ThumbnailUri = mediaFileService.GetFileUri(MediaType.Image, folderName, ThumbnailImageFilePrefix + Path.GetFileNameWithoutExtension(fileName) + ".png");
image.PublicThumbnailUrl = mediaFileService.GetPublicFileUrl(MediaType.Image, folderName, ThumbnailImageFilePrefix + Path.GetFileNameWithoutExtension(fileName) + ".png");
image.ImageAlign = null;
image.IsTemporary = true;
image.IsUploaded = false;
image.IsThumbnailUploaded = false;
image.IsOriginalUploaded = false;
unitOfWork.BeginTransaction();
repository.Save(image);
unitOfWork.Commit();
Task imageUpload = mediaFileService.UploadMediaFileToStorage<MediaImage>(fileStream, image.FileUri, image.Id, img => { img.IsUploaded = true; });
Task originalUpload = mediaFileService.UploadMediaFileToStorage<MediaImage>(fileStream, image.OriginalUri, image.Id, img => { img.IsOriginalUploaded = true; });
Task thumbnailUpload = mediaFileService.UploadMediaFileToStorage<MediaImage>(thumbnailImage, image.ThumbnailUri, image.Id, img => { img.IsThumbnailUploaded = 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);
if (media.IsCanceled && (media.IsUploaded || media.IsThumbnailUploaded || media.IsOriginalUploaded))
{
RemoveImageWithFiles(media.Id, media.Version);
}
});
});
imageUpload.Start();
originalUpload.Start();
thumbnailUpload.Start();
return image;
}
}
/// <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)
{
}
private void SetThumbnailParameters(MediaImage image, Size size, long length)
{
image.ThumbnailWidth = size.Width;
image.ThumbnailHeight = size.Height;
image.ThumbnailSize = length;
}
private int GetVersion(MediaImage image)
{
var versionsCount = repository.AsQueryable<MediaImage>().Count(i => i.Original != null && i.Original.Id == image.Id);
return versionsCount;
}
private void StartTasksForImage(
MediaImage mediaImage,
Stream fileStream,
MemoryStream thumbnailFileStream,
bool shouldNotUploadOriginal = false,
bool waitForUploadResult = false)
{
if (waitForUploadResult)
{
StartTasksForImageSync(mediaImage, fileStream, thumbnailFileStream, shouldNotUploadOriginal);
}
else
{
StartTasksForImageAsync(mediaImage, fileStream, thumbnailFileStream, shouldNotUploadOriginal);
}
}
public MediaImage UploadImageWithStream(Stream fileStream, MediaImage image, bool waitForUploadResult = false)
{
using (var thumbnailFileStream = new MemoryStream())
{
fileStream = RotateImage(fileStream);
var size = GetSize(fileStream);
CreatePngThumbnail(fileStream, thumbnailFileStream, ThumbnailSize);
var folderName = mediaFileService.CreateRandomFolderName();
var publicFileName = MediaImageHelper.CreatePublicFileName(image.OriginalFileName, image.OriginalFileExtension);
// Create new original image and upload file stream to the storage
var originalImage = CreateImage(null, image.OriginalFileName, image.OriginalFileExtension, image.Title, size, image.Size, thumbnailFileStream.Length, image);
mediaImageVersionPathService.SetPathForNewOriginal(originalImage, folderName, publicFileName);
unitOfWork.BeginTransaction();
repository.Save(originalImage);
if (!waitForUploadResult)
{
unitOfWork.Commit();
}
StartTasksForImage(originalImage, fileStream, thumbnailFileStream, false, waitForUploadResult);
if (waitForUploadResult)
{
unitOfWork.Commit();
Events.MediaManagerEvents.Instance.OnMediaFileUpdated(originalImage);
}
return originalImage;
}
}
private void StartTasksForImageAsync(
MediaImage mediaImage,
Stream fileStream,
MemoryStream thumbnailFileStream,
bool shouldNotUploadOriginal = false)
{
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);
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);
var allTasks = new List<Task> { publicImageUpload, 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();
}
publicThumbnailUpload.Start();
}
/// <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 = MediaImageHelper.CreateVersionedFileName(originalImage.OriginalFileName, GetVersion(originalImage));
mediaImageVersionPathService.SetPathForNewOriginal(originalImage, folderName, publicFileName, 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>
/// 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;
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>
/// Saves edited image as original.
/// </summary>
/// <param name="image">The edited image.</param>
/// <param name="archivedImage">The archived image.</param>
/// <param name="croppedImageFileStream">The stream with edited image.</param>
/// <param name="overrideUrl">To override public url or not.</param>
public void SaveEditedImage(MediaImage image, MediaImage archivedImage, MemoryStream croppedImageFileStream, bool overrideUrl = true)
{
overrideUrl = false; // TODO: temporary disabling feature #1055.
var folderName = Path.GetFileName(Path.GetDirectoryName(image.FileUri.OriginalString));
using (var fileStream = croppedImageFileStream ?? DownloadFileStream(image.PublicUrl))
{
image.Original = null;
image.PublishedOn = DateTime.Now;
if (!overrideUrl)
{
var publicFileName = MediaImageHelper.CreateVersionedFileName(image.OriginalFileName, GetVersion(image));
mediaImageVersionPathService.SetPathForNewOriginal(image, folderName, publicFileName, archivedImage.OriginalUri, archivedImage.PublicOriginallUrl);
}
unitOfWork.BeginTransaction();
repository.Save(image);
unitOfWork.Commit();
storageService.UploadObject(new UploadRequest { InputStream = fileStream, Uri = image.FileUri, IgnoreAccessControl = true });
UpdateThumbnail(image, Size.Empty);
}
}
/// <summary>
/// Updates the thumbnail.
/// </summary>
/// <param name="mediaImage">The media image.</param>
/// <param name="size">The size.</param>
public void UpdateThumbnail(MediaImage mediaImage, Size size)
{
if (size.IsEmpty)
{
size = ThumbnailSize;
}
var downloadResponse = storageService.DownloadObject(mediaImage.FileUri);
using (var memoryStream = new MemoryStream())
{
CreatePngThumbnail(downloadResponse.ResponseStream, memoryStream, size);
mediaImage.ThumbnailWidth = size.Width;
mediaImage.ThumbnailHeight = size.Height;
mediaImage.ThumbnailSize = memoryStream.Length;
storageService.UploadObject(new UploadRequest { InputStream = memoryStream, Uri = mediaImage.ThumbnailUri, IgnoreAccessControl = true});
}
}
public void SaveImage(MediaImage image)
{
unitOfWork.BeginTransaction();
repository.Save(image);
unitOfWork.Commit();
}