/*
* Import all files in the image folder to the Kentico CMS Media library.
*/
public void Import(bool forceUpdate, string folder)
{
try
{
//Import files in current folder
string imagefolderpath = _image_root_folder + folder;
FileInfo[] fileInfos = (new DirectoryInfo(imagefolderpath)).GetFiles();
foreach (FileInfo fileInfo in fileInfos)
{
//Check if file exist
string relativefilepath = folder + fileInfo.Name;
MediaFileInfo existinginfo = MediaFileInfoProvider.GetMediaFileInfo(_libraryId, relativefilepath.TrimStart('\\'));
if (existinginfo == null)
{
//Import file
MediaFileInfo mediafileinfo = new MediaFileInfo(_image_root_folder + relativefilepath, _libraryId, "");
mediafileinfo.FilePath = relativefilepath.TrimStart('\\').Replace('\\', '/');
mediafileinfo.FileMimeType = string.Format("image/{0}", fileInfo.Extension.TrimStart('.'));
mediafileinfo.FileSiteID = _siteId;
MediaFileInfoProvider.ImportMediaFileInfo(mediafileinfo, _userid);
}
else
{
//Update existing file entry
if (forceUpdate) MediaFileInfoProvider.UpdateFilesPath(existinginfo.FilePath, relativefilepath, _libraryId);
}
}
//Import subfolders
DirectoryInfo[] dirInfos = (new DirectoryInfo(imagefolderpath)).GetDirectories();
foreach (DirectoryInfo dirInfo in dirInfos)
{
//import subfolder but exclude system folder i.e. __thumbnails
if (!dirInfo.Name.StartsWith("__")) Import(forceUpdate, folder + dirInfo.Name + "\\");
}
}
catch (Exception ex)
{
throw new Exception(string.Format("Media Library Error : Import - {0}", ex.Message));
}
}
private void PrepareMetaPropertiesModel(MetaPropertiesModel model, MediaFileInfo fileInfo)
{
model.Site = Url.RouteUrl("HomePage", null, Request.Url.Scheme);
model.SiteName = Services.StoreContext.CurrentStore.Name;
var imageUrl = fileInfo?.GetUrl();
if (fileInfo != null && imageUrl.HasValue())
{
imageUrl = WebHelper.GetAbsoluteUrl(imageUrl, Request, true);
model.ImageUrl = imageUrl;
model.ImageType = fileInfo.MimeType;
if (fileInfo.Alt.HasValue())
{
model.ImageAlt = fileInfo.Alt;
}
if (fileInfo.Dimensions.Width > 0 && fileInfo.Dimensions.Height > 0)
{
model.ImageWidth = fileInfo.Dimensions.Width;
model.ImageHeight = fileInfo.Dimensions.Height;
}
}
var socialSettings = Services.Settings.LoadSetting <SocialSettings>();
model.TwitterSite = socialSettings.TwitterSite;
model.FacebookAppId = socialSettings.FacebookAppId;
}
protected ActionResult CreateMediaFile(string filePathId, int mediaLibraryId, string imagePath, FileInfo fileInfo)
{
MediaFileInfo mediaFileInfo = null;
try
{
mediaFileInfo = CreateMediafileInfo(mediaLibraryId, fileInfo);
}
catch (Exception ex)
{
return(ErrorHelper.HandleException(
nameof(MediaLibraryUploaderController),
nameof(CreateMediaFile),
ex,
ErrorHelper.UnprocessableStatusCode));
}
try
{
CMS.IO.File.Delete(imagePath);
}
catch (Exception ex)
{
ErrorHelper.LogException(nameof(Upload), "", ex);
}
return(Json(new
{
filePathId,
fileGuid = mediaFileInfo.FileGUID.ToString()
}));
}
private static string GetContent(MediaFileInfo mfi)
{
if (mfi != null)
{
return(string.Empty);
}
var content = new StringBuilder();
content.Append(mfi.FileName);
content.Append(" ");
try
{
// see if we can use system extractor
var extractors = GetExtractors();
if (extractors.Contains(mfi.FileExtension.Trim('.').ToLower()))
{
var cachedValueUsed = false;
var data = CMS.Search.SearchHelper.GetBinaryDataSearchContent(mfi, new ExtractionContext(), out cachedValueUsed);
if (data != null)
{
content.Append(ValidationHelper.GetString(data.GetValue(SearchFieldsConstants.CONTENT), string.Empty));
}
}
}
catch (Exception ex)
{
EventLogProvider.LogException("MediaLibrarySearchIndex", "GetBinaryContentAsString", ex);
}
return(content.ToString());
}
/// <summary>
/// Execute -cp action for file f. Update database if needed.
/// </summary>
private void DownloadFiles(MediaDevice device, MediaFileInfo f, Dictionary <string, FileSpec> database)
{
var localFilename = Path.Combine(localFolder, f.Name.Substring(f.Name.LastIndexOf("\\") + 1));
Console.Error.WriteLine("writing: " + localFilename); // DEBUG msg
FileStream fs = File.Create(localFilename);
device.DownloadFile(f.FullName, fs);
FileSpec fspec = null;
if (removeDuplicates || splitFolders)
{
fspec = new FileSpec(localFilename, f.CreationTime);
}
if (removeDuplicates)
{
if (database.ContainsKey(fspec.ContentHash()))
{
Console.Error.WriteLine("ignoring duplicate file: " + localFilename);
File.Delete(localFilename);
}
else
{
database[fspec.ContentHash()] = fspec;
}
}
}
/// <summary>
/// Gets and bulk updates media files. Called when the "Get and bulk update files" button is pressed.
/// Expects the CreateMediaFile method to be run first.
/// </summary>
private bool GetAndBulkUpdateMediaFiles()
{
// Prepare the parameters
string where = "FileName LIKE 'MyNew%'";
// Get the data
DataSet files = MediaFileInfoProvider.GetMediaFiles(where, null);
if (!DataHelper.DataSourceIsEmpty(files))
{
// Loop through the individual items
foreach (DataRow fileDr in files.Tables[0].Rows)
{
// Create object from DataRow
MediaFileInfo modifyFile = new MediaFileInfo(fileDr);
// Update the property
modifyFile.FileName = modifyFile.FileName.ToUpper();
// Update the media file
MediaFileInfoProvider.SetMediaFileInfo(modifyFile);
}
return(true);
}
return(false);
}
public void FakeData()
{
Fake <MediaLibraryInfo, MediaLibraryInfoProvider>().WithData(
new MediaLibraryInfo()
{
LibraryID = 1,
LibraryFolder = LIBRARY_FOLDER
}
);
Fake <SiteInfo>();
site = new SiteInfo()
{
SiteID = 1,
SiteName = SITE_NAME,
DomainName = SITE_DOMAIN,
SitePresentationURL = SITE_PRESENTATION_URL,
SiteIsContentOnly = true
};
Fake <SiteInfo, SiteInfoProvider>().WithData(site);
Fake <MediaFileInfo>();
mediaFile = new MediaFileInfo
{
FileGUID = MEDIA_FILE_GUID,
FileName = MEDIA_FILE_NAME,
FileExtension = ".jpg",
FilePath = MEDIA_FILE_PATH,
FileSiteID = 1,
FileLibraryID = 1
};
}
public static string getMediaURL(string Imagepath)
{
string link_media = "";
string[] arr = null;
if (Imagepath.Trim() != "")
{
if (Imagepath.LastIndexOf("media") > 2 || Imagepath.LastIndexOf("images") == -1)
{
link_media = Imagepath.Trim().Split('?')[0];
arr = link_media.Split('/');
link_media = arr[arr.Length - 1];
MediaFileInfo mfi = MediaFileInfoProvider.GetMediaFileInfo(CMSContext.CurrentSiteName, link_media);
if (mfi != null)
{
return(link_media = "/getmedia/" + mfi.FileGUID.ToString() + "/" + mfi.FileName + ".aspx");
}
else
{
Imagepath = "";
}
}
}
return(Imagepath);
}
private static MvcHtmlString MediaInternal(
this HtmlHelper helper,
MediaFileInfo file,
bool renderViewer,
int size,
string extraCssClasses)
{
if (file?.File == null)
{
return(MvcHtmlString.Empty);
}
// Validate size parameter.
if (file.MediaType != "image" && !renderViewer)
{
Guard.IsPositive(size, nameof(size), $"The size must be greater than 0 to get a thumbnail for type '{file.MediaType.NaIfEmpty()}'.");
}
if (size > 0)
{
file.ThumbSize = size;
}
var f = file?.File;
var model = new MediaTemplateModel(file, renderViewer)
{
ExtraCssClasses = extraCssClasses,
Title = f?.GetLocalized(x => x.Title),
Alt = f?.GetLocalized(x => x.Alt)
};
return(helper.Partial("MediaTemplates/" + file.MediaType, model));
}
public void PrepareMetaPropertiesModel(MetaPropertiesModel model, MediaFileInfo fileInfo)
{
model.Site = _urlHelper.RouteUrl("HomePage", null, _httpRequest.Scheme);
model.SiteName = _storeContext.CurrentStore.Name;
var imageUrl = fileInfo?.GetUrl();
if (fileInfo != null && imageUrl.HasValue())
{
imageUrl = WebHelper.GetAbsoluteUrl(imageUrl, _httpRequest, true);
model.ImageUrl = imageUrl;
model.ImageType = fileInfo.MimeType;
if (fileInfo.Alt.HasValue())
{
model.ImageAlt = fileInfo.Alt;
}
if (fileInfo.Size.Width > 0 && fileInfo.Size.Height > 0)
{
model.ImageWidth = fileInfo.Size.Width;
model.ImageHeight = fileInfo.Size.Height;
}
}
model.TwitterSite = _socialSettings.TwitterSite;
model.FacebookAppId = _socialSettings.FacebookAppId;
}
public void AdjustVideoSpeedTest()
{
Action <VideoManipulator, MediaFileInfo, string, string, float, float, bool> changeVideoSpeedTestHelper = delegate(VideoManipulator vm, MediaFileInfo mfi, string inputPath, string outputPath, float newPlaybackRate, float newFrameRate, bool alsoChangeAudio)
{
double inputDuration = mfi.Format.Duration.Value;
vm.AdjustVideoSpeed(outputPath, inputPath, newPlaybackRate, newFrameRate, alsoChangeAudio);
double outputDuration = new MediaFileInfo(outputPath).Format.Duration.Value;
double expectedDuration = inputDuration / newPlaybackRate;
Assert.IsTrue(Math.Min(expectedDuration, outputDuration) / Math.Max(expectedDuration, outputDuration) > 0.95);
};
string inputFilepath = $"{TestMediaDirectory}twwbattles1.mp4";
string outputFilepath = $"{TestMediaDirectory}output.mp4";
VideoManipulator videoManipulator = new VideoManipulator();
MediaFileInfo mfiInput = new MediaFileInfo(inputFilepath);
changeVideoSpeedTestHelper(videoManipulator, mfiInput, inputFilepath, outputFilepath, 0.4f, 0, false);
changeVideoSpeedTestHelper(videoManipulator, mfiInput, inputFilepath, outputFilepath, 3, 0, false);
inputFilepath = $"{TestMediaDirectory}twwbattlesraw.mp4";
mfiInput = new MediaFileInfo(inputFilepath);
changeVideoSpeedTestHelper(videoManipulator, mfiInput, inputFilepath, outputFilepath, 0.5f, 0, true);
changeVideoSpeedTestHelper(videoManipulator, mfiInput, inputFilepath, outputFilepath, 2, 0, true);
try
{
changeVideoSpeedTestHelper(videoManipulator, mfiInput, inputFilepath, outputFilepath, 0.4f, 0, true);
throw new Exception();
} catch (ArgumentException) { }
try
{
changeVideoSpeedTestHelper(videoManipulator, mfiInput, inputFilepath, outputFilepath, 3, 0, true);
throw new Exception();
}
catch (ArgumentException) { }
}
public async Task <ImageModel> PrepareCategoryImageModelAsync(Category category, string localizedName, IDictionary <int, MediaFileInfo> fileLookup = null)
{
MediaFileInfo file = null;
if (fileLookup != null)
{
fileLookup.TryGetValue(category.MediaFileId ?? 0, out file);
}
else
{
if (category.MediaFile != null)
{
file = _mediaService.ConvertMediaFile(category.MediaFile);
}
else if (category.MediaFileId.HasValue)
{
file = await _mediaService.GetFileByIdAsync(category.MediaFileId.Value, MediaLoadFlags.AsNoTracking);
}
}
var model = new ImageModel
{
File = file,
ThumbSize = _mediaSettings.CategoryThumbPictureSize,
Title = file?.File?.GetLocalized(x => x.Title)?.Value.NullEmpty() ?? string.Format(T("Media.Category.ImageLinkTitleFormat"), localizedName),
Alt = file?.File?.GetLocalized(x => x.Alt)?.Value.NullEmpty() ?? string.Format(T("Media.Category.ImageAlternateTextFormat"), localizedName),
NoFallback = _catalogSettings.HideCategoryDefaultPictures
};
_services.DisplayControl.Announce(file?.File);
return(model);
}
/// <summary>
/// Returns a relative or an absolute URL for the given media file depending on the media library location.
/// Media library locations:
/// - current site -> relative URL
/// - different site / CDN -> absolute URL
/// </summary>
/// <param name="mediaFile">Media file for which the URL is generated.</param>
/// <param name="getUrlMethod">The method which generates a relative URL for the given <paramref name="mediaFile"/>.</param>
private static string GetMediaFileUrl(MediaFileInfo mediaFile, Func <MediaFileInfo, SiteInfo, string> getUrlMethod)
{
var mediaFileSite = SiteInfoProvider.GetSiteInfo(mediaFile.FileSiteID);
if (mediaFileSite == null)
{
return(null);
}
string relativeUrl = getUrlMethod(mediaFile, mediaFileSite);
if (!String.IsNullOrEmpty(relativeUrl))
{
bool mediaFileIsOnCurrentSite = (SiteContext.CurrentSiteName == mediaFileSite.SiteName);
if (!mediaFileIsOnCurrentSite)
{
return(GetAbsoluteUrl(relativeUrl, mediaFileSite));
}
return(relativeUrl);
}
return(null);
}
private bool SetJsonInfo()
{
// Create the sidecar json object
SidecarJson ??= new SidecarFileJsonSchema();
// Schema version
SidecarJson.SchemaVersion = SidecarFileJsonSchema.CurrentSchemaVersion;
// Media file info
MediaFileInfo.Refresh();
SidecarJson.MediaLastWriteTimeUtc = MediaFileInfo.LastWriteTimeUtc;
SidecarJson.MediaLength = MediaFileInfo.Length;
SidecarJson.MediaHash = ComputeHash();
// Tool version info
SidecarJson.FfProbeToolVersion = Tools.FfProbe.Info.Version;
SidecarJson.MkvMergeToolVersion = Tools.MkvMerge.Info.Version;
SidecarJson.MediaInfoToolVersion = Tools.MediaInfo.Info.Version;
// Compressed tool info
SidecarJson.FfProbeInfoData = StringCompression.Compress(FfProbeInfoJson);
SidecarJson.MkvMergeInfoData = StringCompression.Compress(MkvMergeInfoJson);
SidecarJson.MediaInfoData = StringCompression.Compress(MediaInfoXml);
// State
// TODO: Only update tool and file info if changed, else just update state
SidecarJson.State = State;
return(true);
}
/// <summary>
/// Gets HTML code of rendered DirectFileUploader control.
/// </summary>
/// <param name="mfi">Media file information</param>
public string GetWebDavHTML(MediaFileInfo mfi)
{
SiteInfo si = SiteInfoProvider.GetSiteInfo(mfi.FileSiteID);
if (si != null)
{
// If the WebDAV is enabled and windows authentication and extension is allowed
if (CMSContext.IsWebDAVEnabled(si.SiteName) && RequestHelper.IsWindowsAuthentication() && WebDAVSettings.IsExtensionAllowedForEditMode(mfi.FileExtension, si.SiteName))
{
StringBuilder sb = new StringBuilder();
using (StringWriter tw = new StringWriter(sb))
{
HtmlTextWriter hw = new HtmlTextWriter(tw);
WebDAVEditControl wabDavElem = Page.LoadUserControl("~/CMSModules/MediaLibrary/Controls/WebDAV/MediaFileWebDAVEditControl.ascx") as WebDAVEditControl;
if (wabDavElem != null)
{
// Initialize update control
innermedia.GetWebDAVEditControl(ref wabDavElem, mfi);
wabDavElem.ReloadData(true);
wabDavElem.RenderControl(hw);
}
}
return(sb.ToString());
}
}
return(null);
}
private dynamic ToDynamic(MediaFileInfo file, int thumbPictureSize, int detailsPictureSize, DataExporterContext ctx)
{
if (file == null)
{
return(null);
}
try
{
var host = ctx.Store.GetHost();
dynamic result = new DynamicEntity(file.File);
result._FileName = file.Name;
result._RelativeUrl = _mediaService.GetUrl(file, null, null);
result._ThumbImageUrl = _mediaService.GetUrl(file, thumbPictureSize, host);
result._ImageUrl = _mediaService.GetUrl(file, detailsPictureSize, host);
result._FullSizeImageUrl = _mediaService.GetUrl(file, null, host);
return(result);
}
catch (Exception ex)
{
ctx.Log.Error(ex, $"Failed to get details for file with ID {file.File.Id}.");
return(null);
}
}
/// <summary>
/// Stores new media file info into the DB.
/// </summary>
/// <param name="fi">Info on file to be stored</param>
/// <param name="description">Description of new media file</param>
/// <param name="name">Name of new media file</param>
public MediaFileInfo SaveNewFile(FileInfo fi, string title, string description, string name, string filePath)
{
string path = MediaLibraryHelper.EnsurePath(filePath);
string fileName = name;
string fullPath = fi.FullName;
string extension = URLHelper.GetSafeFileName(fi.Extension, CMSContext.CurrentSiteName);
// Check if filename is changed ad move file if necessary
if (fileName + extension != fi.Name)
{
string oldPath = path;
fullPath = MediaLibraryHelper.EnsureUniqueFileName(Path.GetDirectoryName(fullPath) + "\\" + fileName + extension);
path = MediaLibraryHelper.EnsurePath(Path.GetDirectoryName(path) + "/" + Path.GetFileName(fullPath)).TrimStart('/');
MediaFileInfoProvider.MoveMediaFile(CMSContext.CurrentSiteName, MediaLibraryID, oldPath, path, true);
fileName = Path.GetFileNameWithoutExtension(fullPath);
}
// Create media file info
MediaFileInfo fileInfo = new MediaFileInfo(fullPath, LibraryInfo.LibraryID, MediaLibraryHelper.EnsurePath(Path.GetDirectoryName(path)), 0, 0, 0);
fileInfo.FileTitle = title;
fileInfo.FileDescription = description;
// Save media file info
MediaFileInfoProvider.ImportMediaFileInfo(fileInfo);
// Save FileID in ViewState
FileID = fileInfo.FileID;
FilePath = fileInfo.FilePath;
return(fileInfo);
}
/// <inheritdoc/>
public IMediaFile GetMediaFile(int mediaFileId)
{
MediaFileInfo file = MediaFileInfoProvider.GetMediaFileInfo(mediaFileId);
file = SetFileBinary(file);
return(file?.ActLike <IMediaFile>());
}
protected override void DoStartRenderer()
{
if (renderMediaName == null || renderMediaName.Length <= 0)
{
return;
}
renderMediaInfo = MediaFileInfo.FromPath(renderMediaName, true);
GC.Collect();
InitMedia();
InitAudioAndVideo();
int hr = mediaPosition.put_Rate(1);
DsError.ThrowExceptionForHR(hr);
// Run the graph to play the media file
hr = mediaControl.Run();
DsError.ThrowExceptionForHR(hr);
// HACK: call GetMedialenght once here to ensure that durationScaleFactor is buuilt up
double len = GetMediaLength();
}
private async Task <ImageModel> PrepareOrderItemImageModelAsync(
Product product,
int pictureSize,
string productName,
ProductVariantAttributeSelection attributeSelection,
CatalogSettings catalogSettings)
{
Guard.NotNull(product, nameof(product));
MediaFileInfo file = null;
var combination = await _productAttributeMaterializer.FindAttributeCombinationAsync(product.Id, attributeSelection);
if (combination != null)
{
var mediaIds = combination.GetAssignedMediaIds();
if (mediaIds.Any())
{
file = await _mediaService.GetFileByIdAsync(mediaIds[0], MediaLoadFlags.AsNoTracking);
}
}
// No attribute combination image, then load product picture.
if (file == null)
{
var mediaFile = await _db.ProductMediaFiles
.AsNoTracking()
.Include(x => x.MediaFile)
.ApplyProductFilter(product.Id)
.FirstOrDefaultAsync();
if (mediaFile?.MediaFile != null)
{
file = _mediaService.ConvertMediaFile(mediaFile.MediaFile);
}
}
// Let's check whether this product has some parent "grouped" product.
if (file == null && product.Visibility == ProductVisibility.Hidden && product.ParentGroupedProductId > 0)
{
var mediaFile = await _db.ProductMediaFiles
.AsNoTracking()
.Include(x => x.MediaFile)
.ApplyProductFilter(product.ParentGroupedProductId)
.FirstOrDefaultAsync();
if (mediaFile?.MediaFile != null)
{
file = _mediaService.ConvertMediaFile(mediaFile.MediaFile);
}
}
return(new ImageModel
{
File = file,
ThumbSize = pictureSize,
Title = file?.File?.GetLocalized(x => x.Title)?.Value.NullEmpty() ?? T("Media.Product.ImageLinkTitleFormat", productName),
Alt = file?.File?.GetLocalized(x => x.Alt)?.Value.NullEmpty() ?? T("Media.Product.ImageAlternateTextFormat", productName),
NoFallback = catalogSettings.HideProductDefaultPictures
});
}
public void WritablePersistentUniqueIdTest()
{
var devices = MediaDevice.GetDevices();
var device = devices.FirstOrDefault(this.deviceSelect);
Assert.IsNotNull(device, "Device");
device.Connect();
UploadTestTree(device);
MediaDirectoryInfo dir = device.GetDirectoryInfo(Path.Combine(this.workingFolder, @"UploadTree\Aaa\Abb"));
string dirPui = dir.PersistentUniqueId;
MediaDirectoryInfo dirGet = device.GetFileSystemInfoFromPersistentUniqueId(dirPui) as MediaDirectoryInfo;
MediaFileInfo file = device.GetFileInfo(Path.Combine(this.workingFolder, @"UploadTree\Aaa\Abb\Acc\Ctest.txt"));
string filePui = file.PersistentUniqueId;
MediaFileInfo fileGet = device.GetFileSystemInfoFromPersistentUniqueId(filePui) as MediaFileInfo;
string tmp = Path.GetTempFileName();
device.DownloadFileFromPersistentUniqueId(filePui, tmp);
var text = File.ReadAllText(tmp);
device.Disconnect();
Assert.IsNotNull(dirPui, "dirPui");
Assert.AreEqual(dir, dirGet, "dirGet");
Assert.IsNotNull(filePui, "filePui");
Assert.AreEqual(file, fileGet, "fileGet");
Assert.AreEqual("test", text, "text");
}
/// <summary>
/// Gets media file info object representing the updated version of original file.
/// </summary>
/// <param name="originalFile">Original file data</param>
private MediaFileInfo GetUpdatedFile(IDataClass originalFile)
{
// Get info on media file from uploaded file
MediaFileInfo mediaFile = new MediaFileInfo(ucFileUpload.PostedFile, LibraryID, LibraryFolderPath, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize, LibraryInfo.LibrarySiteID);
// Create new file based on original
MediaFileInfo updatedMediaFile = new MediaFileInfo(originalFile);
// Update necessary information
updatedMediaFile.FileID = MediaFileID;
updatedMediaFile.FileName = mediaFile.FileName;
updatedMediaFile.FileExtension = mediaFile.FileExtension;
updatedMediaFile.FileSize = mediaFile.FileSize;
updatedMediaFile.FileMimeType = mediaFile.FileMimeType;
updatedMediaFile.FilePath = mediaFile.FilePath;
updatedMediaFile.FileCreatedWhen = mediaFile.FileCreatedWhen;
updatedMediaFile.FileCreatedByUserID = mediaFile.FileCreatedByUserID;
updatedMediaFile.FileModifiedByUserID = mediaFile.FileModifiedByUserID;
updatedMediaFile.FileBinary = mediaFile.FileBinary;
updatedMediaFile.FileImageHeight = mediaFile.FileImageHeight;
updatedMediaFile.FileImageWidth = mediaFile.FileImageWidth;
updatedMediaFile.FileBinaryStream = mediaFile.FileBinaryStream;
return(updatedMediaFile);
}
public async Task <MediaFileProcessingResult> Process(MediaFileInfo file, RssFeedDto feed, CancellationToken ct)
{
string tempDirectory = null;
try
{
tempDirectory = _tempDirectoryService.Create(feed.Id.ToString());
var alternativeFileName = Guid.NewGuid().ToString();
var downloadService = _fileDownloadResolver(feed.Type);
var tempFile = await downloadService
.DownloadMediaFile(file.Url, tempDirectory, alternativeFileName, ct)
.ConfigureAwait(false);
var fileResult = await ProcessFile(tempFile, tempDirectory, ct);
var newEntry = new MediaFileDto
{
FeedId = feed.Id,
Title = file.Name,
FileName = fileResult,
Url = file.VideoId
};
_context.MediaFiles.Add(newEntry);
await _context.SaveChangesAsync();
return(new MediaFileSuccessResult(feed.Url, newEntry.Id));
} catch (Exception ex)
{
return(new MediaFileErrorResult(feed.Url, ex));
}
}
static void ttclient_OnUserAudioFile(int nUserID, MediaFileInfo mediafileinfo)
{
User user = new User();
if (ttclient.GetUser(nUserID, ref user))
{
switch (mediafileinfo.nStatus)
{
case MediaFileStatus.MFS_ERROR:
Console.WriteLine("Failed to store audio file for #{0} {1}.",
user.nUserID, user.szNickname);
break;
case MediaFileStatus.MFS_STARTED:
Console.WriteLine("Storing audio from #{0} for {1} to file.",
user.nUserID, user.szNickname);
break;
case MediaFileStatus.MFS_FINISHED:
Console.WriteLine("Finished storing audio from #{0} {1} to file.",
user.nUserID, user.szNickname);
break;
case MediaFileStatus.MFS_ABORTED:
Console.WriteLine("Aborted storing audio from #{0} {1} to file.",
user.nUserID, user.szNickname);
break;
}
}
}
/// <summary>
/// Initializes media file info.
/// </summary>
/// <param name="objectGuid">Media file GUID</param>
/// <param name="siteName">Site name</param>
private void metaDataEditor_InitializeObject(Guid objectGuid, string siteName)
{
// Get mediafile
mediaFileInfo = MediaFileInfoProvider.GetMediaFileInfo(objectGuid, siteName);
// If media file is not null
if (mediaFileInfo != null)
{
MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(ValidationHelper.GetInteger(mediaFileInfo.FileLibraryID, 0));
// Check permission 'FileModify'
if (metaDataEditor.CheckPermissions && !MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "filemodify"))
{
RedirectToAccessDenied(GetString("metadata.errors.filemodify"));
}
// Fire event GetObjectExtension
if (GetObjectExtension != null)
{
GetObjectExtension(mediaFileInfo.FileExtension);
}
}
else
{
RedirectToInformation(GetString("editedobject.notexists"));
}
}
public static MvcHtmlString MediaViewer(
this HtmlHelper helper,
MediaFileInfo file,
string extraCssClasses = null)
{
return(MediaInternal(helper, file, true, 0, extraCssClasses));
}
protected async Task <ImageModel> PrepareCartItemPictureModelAsync(Product product, int pictureSize, string productName, ProductVariantAttributeSelection attributeSelection)
{
Guard.NotNull(product, nameof(product));
Guard.NotNull(attributeSelection, nameof(attributeSelection));
MediaFileInfo file = null;
var combination = await _productAttributeMaterializer.FindAttributeCombinationAsync(product.Id, attributeSelection);
if (combination != null)
{
var fileIds = combination.GetAssignedMediaIds();
if (fileIds?.Any() ?? false)
{
file = await _mediaService.GetFileByIdAsync(fileIds[0], MediaLoadFlags.AsNoTracking);
}
}
// No attribute combination image, then load product picture.
if (file == null)
{
var productMediaFile = await _db.ProductMediaFiles
.Include(x => x.MediaFile)
.Where(x => x.Id == product.Id)
.OrderBy(x => x.DisplayOrder)
.FirstOrDefaultAsync();
if (productMediaFile != null)
{
file = _mediaService.ConvertMediaFile(productMediaFile.MediaFile);
}
}
// Let's check whether this product has some parent "grouped" product.
if (file == null && product.Visibility == ProductVisibility.Hidden && product.ParentGroupedProductId > 0)
{
var productMediaFile = await _db.ProductMediaFiles
.Include(x => x.MediaFile)
.Where(x => x.Id == product.ParentGroupedProductId)
.OrderBy(x => x.DisplayOrder)
.FirstOrDefaultAsync();
if (productMediaFile != null)
{
file = _mediaService.ConvertMediaFile(productMediaFile.MediaFile);
}
}
var pm = new ImageModel
{
Id = file?.Id ?? 0,
ThumbSize = pictureSize,
Host = _mediaService.GetUrl(file, pictureSize, null, !_catalogSettings.HideProductDefaultPictures),
Title = file?.File?.GetLocalized(x => x.Title)?.Value.NullEmpty() ?? T("Media.Product.ImageLinkTitleFormat", productName),
Alt = file?.File?.GetLocalized(x => x.Alt)?.Value.NullEmpty() ?? T("Media.Product.ImageAlternateTextFormat", productName),
File = file
};
return(pm);
}
private Guid AddMediaFile(IFormFile requestFile, MediaLibraryInfo library)
{
var mediaFile = new MediaFileInfo(requestFile.ToUploadedFile(), library.LibraryID);
MediaFileInfo.Provider.Set(mediaFile);
return(mediaFile.FileGUID);
}
public static string BuildNewPathByDate(MediaFileInfo mediaFileInfo, DateInterval interval)
{
var newDirectoryName = mediaFileInfo.ModifiedDate.GetName(interval);
var fileInfo = new FileInfo(mediaFileInfo.CurrentPath);
var oldDirectoryPath = fileInfo.Directory?.FullName;
return(Path.Combine(oldDirectoryPath, newDirectoryName, fileInfo.Name));
}
public MediaTemplateModel(MediaFileInfo file, bool renderViewer)
{
Guard.NotNull(file, nameof(file));
Id = file.Id;
File = file;
RenderViewer = renderViewer;
}
public static MvcHtmlString MediaThumbnail(
this HtmlHelper helper,
MediaFileInfo file,
int size,
string extraCssClasses = null)
{
return(MediaInternal(helper, file, false, size, extraCssClasses));
}
/// <summary>
/// Initializes media file info.
/// </summary>
/// <param name="objectGuid">Media file GUID</param>
/// <param name="siteName">Site name</param>
private void metaDataEditor_InitializeObject(Guid objectGuid, string siteName)
{
// Get mediafile
mediaFileInfo = MediaFileInfoProvider.GetMediaFileInfo(objectGuid, siteName);
// If media file is not null
if (mediaFileInfo != null)
{
MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(ValidationHelper.GetInteger(mediaFileInfo.FileLibraryID, 0));
// Check permission 'FileModify'
if (metaDataEditor.CheckPermissions && !MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "filemodify"))
{
RedirectToAccessDenied(GetString("metadata.errors.filemodify"));
}
// Fire event GetObjectExtension
if (GetObjectExtension != null)
{
GetObjectExtension(mediaFileInfo.FileExtension);
}
}
else
{
RedirectToInformation(GetString("editedobject.notexists"));
}
}
/// <summary>
/// Performs actions necessary to select particular item from a list.
/// </summary>
private void SelectMediaItem(string argument)
{
if (!string.IsNullOrEmpty(argument) && (LibraryInfo != null))
{
Hashtable argTable = CMSModules_MediaLibrary_Controls_Dialogs_MediaView.GetArgumentsTable(argument);
if (argTable.Count >= 2)
{
// Get file name
string fileName = string.Empty;
if (DisplayOnlyImportedFiles)
{
if (argTable.Contains("extension"))
{
// File name + file extension
fileName = argTable["filename"].ToString() + argTable["extension"].ToString();
}
else
{
// File name + file extension
fileName = argTable["filename"].ToString() + argTable["fileextension"].ToString();
}
}
else
{
// File name - already contains extension
fileName = argTable["filename"].ToString();
}
// Get media file path
string filePath = CreateFilePath(fileName);
// Try to get media file info based on its path
FileInfo fi = FileInfo.New(MediaFileInfoProvider.GetMediaFilePath(LibrarySiteInfo.SiteName, LibraryInfo.LibraryFolder, filePath));
if (fi != null)
{
string path = MediaLibraryHelper.EnsurePath(filePath);
string where = String.Format("(FileLibraryID = {0}) AND (FilePath = N'{1}')", LibraryID, path.TrimStart('/').Replace("'", "''"));
// Try to get file from DB
using (DataSet ds = MediaFileInfoProvider.GetMediaFiles(where, null))
{
if (!DataHelper.DataSourceIsEmpty(ds))
{
// If in DB get file info
MediaFileInfo fileInfo = new MediaFileInfo(ds.Tables[0].Rows[0]);
if (fileInfo != null)
{
DisplayEditProperties(fileInfo);
}
}
}
// FileGUID for imported and FileName for non-imported media file
if (argTable.Contains("fileguid"))
{
ItemToColorize = argTable["fileguid"].ToString();
}
else
{
ItemToColorize = EnsureFileName(argTable["filename"].ToString());
}
}
}
}
wasLoaded = true;
}
/// <summary>
/// Provides operations necessary to create and store new library file.
/// </summary>
private void HandleLibrariesUpload()
{
// Get related library info
if (LibraryInfo != null)
{
MediaFileInfo mediaFile = null;
// Get the site name
string siteName = CMSContext.CurrentSiteName;
SiteInfo si = SiteInfoProvider.GetSiteInfo(LibraryInfo.LibrarySiteID);
if (si != null)
{
siteName = si.SiteName;
}
string message = string.Empty;
try
{
// Check the allowed extensions
CheckAllowedExtensions();
if (MediaFileID > 0)
{
#region "Check permissions"
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(LibraryInfo, "FileModify"))
{
throw new Exception(GetString("media.security.nofilemodify"));
}
#endregion
mediaFile = MediaFileInfoProvider.GetMediaFileInfo(MediaFileID);
if (mediaFile != null)
{
// Ensure object version
SynchronizationHelper.EnsureObjectVersion(mediaFile);
if (IsMediaThumbnail)
{
string newFileExt = Path.GetExtension(ucFileUpload.FileName).TrimStart('.');
if ((ImageHelper.IsImage(newFileExt)) && (newFileExt.ToLowerCSafe() != "ico") &&
(newFileExt.ToLowerCSafe() != "wmf"))
{
// Update or creation of Media File update
string previewSuffix = MediaLibraryHelper.GetMediaFilePreviewSuffix(siteName);
if (!String.IsNullOrEmpty(previewSuffix))
{
string previewExtension = Path.GetExtension(ucFileUpload.PostedFile.FileName);
string previewName = Path.GetFileNameWithoutExtension(MediaLibraryHelper.GetPreviewFileName(mediaFile.FileName, mediaFile.FileExtension, previewExtension, siteName, previewSuffix));
string previewFolder = DirectoryHelper.CombinePath(MediaLibraryHelper.EnsurePath(LibraryFolderPath.TrimEnd('/')), MediaLibraryHelper.GetMediaFileHiddenFolder(siteName));
byte[] previewFileBinary = new byte[ucFileUpload.PostedFile.ContentLength];
ucFileUpload.PostedFile.InputStream.Read(previewFileBinary, 0, ucFileUpload.PostedFile.ContentLength);
// Delete current preview thumbnails
MediaFileInfoProvider.DeleteMediaFilePreview(siteName, mediaFile.FileLibraryID, mediaFile.FilePath, false);
// Save preview file
MediaFileInfoProvider.SaveFileToDisk(siteName, LibraryInfo.LibraryFolder, previewFolder, previewName, previewExtension, mediaFile.FileGUID, previewFileBinary, false, false);
// Log synchronization task
SynchronizationHelper.LogObjectChange(mediaFile, TaskTypeEnum.UpdateObject);
}
// Drop the cache dependencies
CacheHelper.TouchKeys(MediaFileInfoProvider.GetDependencyCacheKeys(mediaFile, true));
}
else
{
message = GetString("media.file.onlyimgthumb");
}
}
else
{
// Delete existing media file
MediaFileInfoProvider.DeleteMediaFile(LibraryInfo.LibrarySiteID, LibraryInfo.LibraryID, mediaFile.FilePath, true, false);
// Update media file preview
if (MediaLibraryHelper.HasPreview(siteName, LibraryInfo.LibraryID, mediaFile.FilePath))
{
// Get new file path
string newPath = DirectoryHelper.CombinePath(Path.GetDirectoryName(mediaFile.FilePath).TrimEnd('/'), ucFileUpload.PostedFile.FileName);
newPath = MediaLibraryHelper.EnsureUniqueFileName(newPath);
// Get new unique file name
string newName = Path.GetFileName(newPath);
// Rename preview
MediaLibraryHelper.MoveMediaFilePreview(mediaFile, newName);
// Delete preview thumbnails
MediaFileInfoProvider.DeleteMediaFilePreviewThumbnails(mediaFile);
}
// Receive media info on newly posted file
mediaFile = GetUpdatedFile(mediaFile.Generalized.DataClass);
MediaFileInfoProvider.SetMediaFileInfo(mediaFile);
}
}
}
else
{
// Creation of new media file
#region "Check permissions"
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(LibraryInfo, "FileCreate"))
{
throw new Exception(GetString("media.security.nofilecreate"));
}
#endregion
// No file for upload specified
if (!ucFileUpload.HasFile)
{
throw new Exception(GetString("media.newfile.errorempty"));
}
// Create new media file record
mediaFile = new MediaFileInfo(ucFileUpload.PostedFile, LibraryID, LibraryFolderPath, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize, LibraryInfo.LibrarySiteID);
mediaFile.FileDescription = "";
// Save the new file info
MediaFileInfoProvider.SetMediaFileInfo(mediaFile);
}
}
catch (Exception ex)
{
// Creation of new media file failed
message = ex.Message;
}
finally
{
// Create media file info string
string mediaInfo = "";
if ((mediaFile != null) && (mediaFile.FileID > 0) && (IncludeNewItemInfo))
{
mediaInfo = mediaFile.FileID + "|" + LibraryFolderPath.Replace('\\', '>').Replace("'", "\\'");
}
// Ensure message text
message = HTMLHelper.EnsureLineEnding(message, " ");
// Call function to refresh parent window
ScriptHelper.RegisterStartupScript(Page, typeof(Page), "refresh", ScriptHelper.GetScript("if ((wopener.parent != null) && (wopener.parent.InitRefresh_" + ParentElemID + " != null)){wopener.parent.InitRefresh_" + ParentElemID + "(" + ScriptHelper.GetString(message.Trim()) + ", false" + ((mediaInfo != "") ? ", '" + mediaInfo + "'" : "") + (InsertMode ? ", 'insert'" : ", 'update'") + ");}CloseDialog();"));
}
}
}
/// <summary>
/// Initializes common properties used for processing image.
/// </summary>
void baseImageEditor_InitializeProperties()
{
// Process media file
if (baseImageEditor.ImageType == ImageHelper.ImageTypeEnum.MediaFile)
{
// Get mediafile
mfi = MediaFileInfoProvider.GetMediaFileInfo(mediafileGuid, this.CurrentSiteName);
// If file is not null
if (mfi != null)
{
MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(mfi.FileLibraryID);
if ((mli != null) && (MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "filemodify")))
{
// Load media file thumbnail
if (isPreview)
{
PreviewPath = MediaFileInfoProvider.GetPreviewFilePath(mfi);
if (PreviewPath != null)
{
OldPreviewExt = Path.GetExtension(PreviewPath);
try
{
// Get file contents from file system
previewFile = File.ReadAllBytes(PreviewPath);
}
catch (Exception ex)
{
EventLogProvider ev = new EventLogProvider();
ev.LogEvent("ImageEditor", "GetPreviewFile", ex);
}
if (previewFile != null)
{
baseImageEditor.ImgHelper = new ImageHelper(previewFile);
}
else
{
baseImageEditor.LoadingFailed = true;
baseImageEditor.LblLoadFailed.ResourceString = "img.errors.loading";
}
}
else
{
baseImageEditor.LoadingFailed = true;
baseImageEditor.LblLoadFailed.ResourceString = "img.errors.loading";
}
}
// Load media file
else
{
mfi.FileBinary = MediaFileInfoProvider.GetFile(mfi, mli.LibraryFolder, this.CurrentSiteName);
// Ensure metafile binary data
if (mfi.FileBinary != null)
{
baseImageEditor.ImgHelper = new ImageHelper(mfi.FileBinary);
}
else
{
baseImageEditor.LoadingFailed = true;
baseImageEditor.LblLoadFailed.ResourceString = "img.errors.loading";
}
}
}
else
{
baseImageEditor.LoadingFailed = true;
baseImageEditor.LblLoadFailed.ResourceString = "img.errors.filemodify";
}
}
else
{
baseImageEditor.LoadingFailed = true;
baseImageEditor.LblLoadFailed.ResourceString = "img.errors.loading";
}
}
// Check that image is in supported formats
if ((!baseImageEditor.LoadingFailed) && (baseImageEditor.ImgHelper.ImageFormatToString() == null))
{
baseImageEditor.LoadingFailed = true;
baseImageEditor.LblLoadFailed.ResourceString = "img.errors.format";
}
}
protected void Page_Load(object sender, EventArgs e)
{
mediafileGuid = QueryHelper.GetGuid("mediafileguid", Guid.Empty);
isPreview = QueryHelper.GetBoolean("isPreview", false);
// Get media file information
if (this.mfi == null)
{
mfi = MediaFileInfoProvider.GetMediaFileInfo(mediafileGuid, this.CurrentSiteName);
}
if (this.mfi != null)
{
// Get media library information
MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(mfi.FileLibraryID);
if (mli != null)
{
// Get path to media file folder
string path = Path.GetDirectoryName(DirectoryHelper.CombinePath(MediaLibraryInfoProvider.GetMediaLibraryFolderPath(mli.LibraryID), mfi.FilePath));
// Enable control if permissions are sufficient to edit image
this.Enabled = DirectoryHelper.CheckPermissions(path, false, true, true, true);
if (!this.Enabled)
{
// Set error message
this.baseImageEditor.LblLoadFailed.Visible = true;
this.baseImageEditor.LblLoadFailed.ResourceString = "img.errors.filesystempermissions";
}
}
}
// Enable or disable image editor
this.baseImageEditor.Enabled = this.Enabled;
baseImageEditor.LoadImageType += new CMSAdminControls_ImageEditor_BaseImageEditor.OnLoadImageType(baseImageEditor_LoadImageType);
baseImageEditor.InitializeProperties += new CMSAdminControls_ImageEditor_BaseImageEditor.OnInitializeProperties(baseImageEditor_InitializeProperties);
baseImageEditor.InitializeLabels += new CMSAdminControls_ImageEditor_BaseImageEditor.OnInitializeLabels(baseImageEditor_InitializeLabels);
baseImageEditor.SaveImage += new CMSAdminControls_ImageEditor_BaseImageEditor.OnSaveImage(baseImageEditor_SaveImage);
baseImageEditor.GetMetaData += new CMSAdminControls_ImageEditor_BaseImageEditor.OnGetMetaData(baseImageEditor_GetMetaData);
baseImageEditor.LoadImageUrl += new CMSAdminControls_ImageEditor_BaseImageEditor.OnLoadImageUrl(baseImageEditor_LoadImageUrl);
}
/// <summary>
/// Creates media file. Called when the "Create file" button is pressed.
/// Expects the CreateMediaLibrary method to be run first.
/// </summary>
private bool CreateMediaFile()
{
// Prepare the parameters
string filePath = "~/CMSAPIExamples/Code/Tools/MediaLibrary/Files/Powered_by_kentico2.gif";
// Get media library
MediaLibraryInfo library = MediaLibraryInfoProvider.GetMediaLibraryInfo("MyNewLibrary", CMSContext.CurrentSiteName);
if (library != null)
{
// Create new media file object
MediaFileInfo mediaFile = new MediaFileInfo(Server.MapPath(filePath), library.LibraryID);
// Create file info
FileInfo file = FileInfo.New(Server.MapPath(filePath));
if (file != null)
{
// Set the properties
mediaFile.FileName = "MyNewFile";
mediaFile.FileTitle = "My new file title";
mediaFile.FileDescription = "My new file description.";
mediaFile.FilePath = "MyNewFolder/MyNewFile.gif";
mediaFile.FileExtension = file.Extension;
mediaFile.FileMimeType = "image/gif";
mediaFile.FileSiteID = CMSContext.CurrentSiteID;
mediaFile.FileLibraryID = library.LibraryID;
mediaFile.FileSize = file.Length;
// Create the media file
MediaFileInfoProvider.SetMediaFileInfo(mediaFile);
return true;
}
}
return false;
}
/// <summary>
/// Gets media file info object representing the updated version of original file.
/// </summary>
/// <param name="originalFile">Original file data</param>
private MediaFileInfo GetUpdatedFile(IDataClass originalFile)
{
// Get info on media file from uploaded file
MediaFileInfo mediaFile = new MediaFileInfo(ucFileUpload.PostedFile, LibraryID, LibraryFolderPath, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize, LibraryInfo.LibrarySiteID);
// Create new file based on original
MediaFileInfo updatedMediaFile = new MediaFileInfo(originalFile)
{
// Update necessary information
FileName = mediaFile.FileName,
FileExtension = mediaFile.FileExtension,
FileSize = mediaFile.FileSize,
FileMimeType = mediaFile.FileMimeType,
FilePath = mediaFile.FilePath,
FileModifiedByUserID = mediaFile.FileModifiedByUserID,
FileBinary = mediaFile.FileBinary,
FileImageHeight = mediaFile.FileImageHeight,
FileImageWidth = mediaFile.FileImageWidth,
FileBinaryStream = mediaFile.FileBinaryStream
};
return updatedMediaFile;
}
public void LoadMediaFile(StorageFile file) {
IRandomAccessStream stream = file.OpenReadAsync().AsTask().Result;
if (stream == null) {
ShowMessageDialog(StringLoader.Get("Invalid_Media_File"));
return;
}
sourceFile = file;
mediaFileInfo = new MediaFileInfo(sourceFile);
if (UpdateMediaInfo(mediaFileInfo) == false) {
ShowMessageDialog(StringLoader.Get("Invalid_Media_File"));
mediaFileInfo = null;
sourceFile = null;
stream.Dispose();
stream = null;
return;
}
Preview.SetSource(stream, sourceFile.ContentType);
Stop();
double width = this.ActualWidth;
double height = this.ActualHeight;
Preview.Width = width;
Preview.Height = height;
SegmentSelector.Width = (width);
SegmentSelector.Reset();
Canvas.SetTop(SegmentSelector, height - 100);
}
private bool UpdateMediaInfo(MediaFileInfo mediaFileInfo) {
if (mediaFileInfo == null) {
return false;
}
string videoMimeType = "unknown";
string audioMimeType = "unknown";
videoFormat = mediaFileInfo.getVideoFormat();
audioFormat = mediaFileInfo.getAudioFormat();
try
{
videoMimeType = videoFormat.mimeType.asString();
}
catch (Exception)
{
videoFormat = null;
}
try
{
audioMimeType = audioFormat.mimeType.asString();
}
catch (Exception)
{
audioFormat = null;
}
if (videoFormat != null) {
float frameRate = videoFormat.frameRate.Numerator;
if (videoFormat.frameRate.Denominator != 0) {
frameRate /= videoFormat.frameRate.Denominator;
}
VideoCodecText.Text = videoMimeType;
ResolutionText.Text = String.Format("{0} x {1}", videoFormat.resolution.Width, videoFormat.resolution.Height);
FramerateText.Text = String.Format("{0}", frameRate);
BitrateVideoText.Text = String.Format("{0}", videoFormat.bitrate);
}
else {
ResolutionText.Text = "";
FramerateText.Text = "";
BitrateVideoText.Text = "";
}
if (audioFormat != null) {
AudioCodecText.Text = audioMimeType;
ChannelsText.Text = String.Format("{0}", audioFormat.channelCount);
SamplerateText.Text = String.Format("{0}", audioFormat.sampleRate);
BitspersampleText.Text = String.Format("{0}", audioFormat.bitsPerSample);
BitrateAudioText.Text = String.Format("{0}", audioFormat.bitrate);
}
if (videoFormat == null && audioFormat == null) {
return false;
}
Info.Visibility = Visibility.Visible;
return true;
}
/// <summary>
/// Initializes and displays file info properties.
/// </summary>
/// <param name="fileInfo">File to edit</param>
private void DisplayEditProperties(MediaFileInfo fileInfo)
{
plcFileEdit.Visible = true;
plcEditFolder.Visible = false;
folderEdit.StopProcessing = true;
plcMultipleImport.Visible = false;
plcImportFile.Visible = false;
plcCopyMove.Visible = false;
folderCopyMove.StopProcessing = true;
fileEdit.StopProcessing = false;
fileEdit.FileID = fileInfo.FileID;
fileEdit.IsLiveSite = IsLiveSite;
fileEdit.FileInfo = fileInfo;
fileEdit.FilePath = fileInfo.FilePath;
fileEdit.FolderPath = LastFolderPath;
fileEdit.LibraryInfo = LibraryInfo;
fileEdit.LibrarySiteInfo = LibrarySiteInfo;
fileEdit.MediaLibraryID = LibraryID;
fileEdit.IsLiveSite = IsLiveSite;
fileEdit.ReloadControl();
pnlUpdateProperties.Update();
}
/// <summary>
/// Initializes the control properties.
/// </summary>
public void ReloadData(bool forceReload)
{
if (!binded || forceReload)
{
if (this.mData != null)
{
MediaFileInfo mfi = new MediaFileInfo(this.mData);
if (mfi != null)
{
bool completeUrl = false;
// Get the site
SiteInfo si = null;
SiteInfo currentSite = CMSContext.CurrentSite;
if (mfi.FileSiteID == currentSite.SiteID)
{
si = currentSite;
}
else
{
si = SiteInfoProvider.GetSiteInfo(mfi.FileSiteID);
}
if (si != null)
{
// Complete URL only for other site than current
if (si.SiteID != currentSite.SiteID)
{
completeUrl = true;
}
string url = "";
if (this.UseSecureLinks)
{
if (completeUrl)
{
url = MediaFileInfoProvider.GetMediaFileAbsoluteUrl(si.SiteName, mfi.FileGUID, mfi.FileName);
}
else
{
url = MediaFileInfoProvider.GetMediaFileUrl(mfi.FileGUID, mfi.FileName);
}
}
else
{
MediaLibraryInfo li = MediaLibraryInfoProvider.GetMediaLibraryInfo(mfi.FileLibraryID);
if (li != null)
{
if (completeUrl)
{
url = MediaFileInfoProvider.GetMediaFileAbsoluteUrl(si.SiteName, li.LibraryFolder, mfi.FilePath);
}
else
{
url = MediaFileInfoProvider.GetMediaFileUrl(si.SiteName, li.LibraryFolder, mfi.FilePath);
}
}
}
if (this.DisplayActiveContent)
{
if (ImageHelper.IsImage(mfi.FileExtension) && File.Exists(MediaFileInfoProvider.GetMediaFilePath(mfi.FileLibraryID, mfi.FilePath)))
{
// Get new dimensions
int[] newDims = ImageHelper.EnsureImageDimensions(Width, Height, MaxSideSize, mfi.FileImageWidth, mfi.FileImageHeight);
// If dimensions changed use secure link
if ((newDims[0] != mfi.FileImageWidth) || (newDims[1] != mfi.FileImageHeight))
{
if (completeUrl)
{
url = MediaFileInfoProvider.GetMediaFileAbsoluteUrl(si.SiteName, mfi.FileGUID, mfi.FileName);
}
else
{
url = MediaFileInfoProvider.GetMediaFileUrl(mfi.FileGUID, mfi.FileName);
}
}
else
{
// Use width and height from properties in case dimensions are bigger than original
newDims[0] = Width;
newDims[1] = Height;
}
// Initialize image parameters
ImageParameters imgParams = new ImageParameters();
imgParams.Alt = mfi.FileDescription;
imgParams.Width = newDims[0];
imgParams.Height = newDims[1];
imgParams.Url = url;
this.ltlOutput.Text = CMS.GlobalHelper.MediaHelper.GetImage(imgParams);
}
else if (CMS.GlobalHelper.MediaHelper.IsFlash(mfi.FileExtension))
{
// Initialize flash parameters
FlashParameters flashParams = new FlashParameters();
flashParams.Url = url;
flashParams.Width = this.Width;
flashParams.Height = this.Height;
this.ltlOutput.Text = CMS.GlobalHelper.MediaHelper.GetFlash(flashParams);
}
else if (CMS.GlobalHelper.MediaHelper.IsAudio(mfi.FileExtension))
{
// Initialize audio/video parameters
AudioVideoParameters audioParams = new AudioVideoParameters();
audioParams.SiteName = CMSContext.CurrentSiteName;
audioParams.Url = url;
audioParams.Width = this.Width;
audioParams.Height = this.Height;
audioParams.Extension = mfi.FileExtension;
this.ltlOutput.Text = CMS.GlobalHelper.MediaHelper.GetAudioVideo(audioParams);
}
else if (CMS.GlobalHelper.MediaHelper.IsVideo(mfi.FileExtension))
{
// Initialize audio/video parameters
AudioVideoParameters videoParams = new AudioVideoParameters();
videoParams.SiteName = CMSContext.CurrentSiteName;
videoParams.Url = url;
videoParams.Width = this.Width;
videoParams.Height = this.Height;
videoParams.Extension = mfi.FileExtension;
this.ltlOutput.Text = CMS.GlobalHelper.MediaHelper.GetAudioVideo(videoParams);
}
else
{
this.ltlOutput.Text = MediaLibraryHelper.ShowPreviewOrIcon(mfi, this.Width, this.Height, this.MaxSideSize, this.PreviewSuffix, this.IconSet, this.Page, this.DefaultImageUrl);
}
}
else
{
this.ltlOutput.Text = MediaLibraryHelper.ShowPreviewOrIcon(mfi, this.Width, this.Height, this.MaxSideSize, this.PreviewSuffix, this.IconSet, this.Page, this.DefaultImageUrl);
}
}
}
}
binded = true;
}
}
/// <summary>
/// Stores new media file info into the DB.
/// </summary>
/// <param name="fi">Info on file to be stored</param>
/// <param name="description">Description of new media file</param>
/// <param name="name">Name of new media file</param>
private MediaFileInfo SaveNewFile(FileInfo fi, string title, string description, string name, string filePath)
{
string path = MediaLibraryHelper.EnsurePath(filePath);
string fileName = name;
string fullPath = fi.FullName;
string extension = URLHelper.GetSafeFileName(fi.Extension, CMSContext.CurrentSiteName);
// Check if filename is changed ad move file if necessary
if (fileName + extension != fi.Name)
{
string oldPath = path;
fullPath = MediaLibraryHelper.EnsureUniqueFileName(DirectoryHelper.CombinePath(Path.GetDirectoryName(fullPath), fileName) + extension);
path = MediaLibraryHelper.EnsurePath(Path.GetDirectoryName(path) + "/" + Path.GetFileName(fullPath)).TrimStart('/');
fileName = Path.GetFileNameWithoutExtension(fullPath);
// Rename file to new safe file name
File.Move(fi.FullName, fullPath);
}
// Create media file info
MediaFileInfo fileInfo = new MediaFileInfo(fullPath, LibraryInfo.LibraryID, MediaLibraryHelper.EnsurePath(Path.GetDirectoryName(path)));
fileInfo.FileTitle = title;
fileInfo.FileDescription = description;
// Save media file info
MediaFileInfoProvider.ImportMediaFileInfo(fileInfo);
// Save FileID in ViewState
fileEdit.FileID = fileInfo.FileID;
fileEdit.FilePath = fileInfo.FilePath;
return fileInfo;
}
//protected void printResults(WorldPayDirectDotNet.PaymentRequest.PaymentResult PaymentResult)
//{
// if(PaymentResult.PaymentSuccessful)
// {
// double giftAidTotal;
// giftAidTotal = (order.OrderTotalPrice / 100) * 25;
// if (ValidationHelper.GetBoolean(order.GetValue("IsGiftAid"),false))
// {
// giftAidTotal = Math.Truncate(giftAidTotal * 100) / 100;
// }
// else
// {
// giftAidTotal = 0;
// }
// double orderPriceTotal = Math.Truncate(order.OrderTotalPrice*100) /100;
// double total=0;
// pnlResult.Visible = true;
// litDonationAmmountRestult.Text = order.OrderTotalPrice.ToString("0.00");
// if (gift_aid.Checked && order.OrderTotalPrice !=0)
// {
// litGiftAidResult.Text = giftAidTotal.ToString("0.00");
// }
// else
// {
// litGiftAidResult.Text="0.00";
// }
// //Show total price
// total = giftAidTotal + orderPriceTotal;
// litTotalResult.Text = total.ToString("0.00");
// }else
// {
// pnlResultError.Visible = true;
// litReturnError.Text=PaymentResult.errorMessage.ToString();
// }
//}
protected void GetImagePath()
{
string filePath = "";
Guid filenameGuid = Guid.NewGuid();
if (docUpload.HasFile)
{
string fileName = Server.MapPath(docUpload.FileName);
MediaLibraryInfo libInfo = MediaLibraryInfoProvider.GetMediaLibraryInfo("COMPANYNAME", CMSContext.CurrentSiteName);
filePath = Server.MapPath(string.Format("//_MediaLibraries///DonationUploads//{0}{1}", filenameGuid, System.IO.Path.GetExtension(docUpload.FileName)));
File.WriteAllBytes(filePath, docUpload.FileBytes);
if (File.Exists(filePath))
{
string path = MediaLibraryHelper.EnsurePath(filePath);
MediaFileInfo fileInfo = new MediaFileInfo(filePath, libInfo.LibraryID, "");
fileInfo.FileSiteID = CMSContext.CurrentSiteID;
MediaFileInfoProvider.ImportMediaFileInfo(fileInfo);
}
ViewState["PhotoPath"]= "/_MediaLibraries/DonationUploads/" + filenameGuid + System.IO.Path.GetExtension(docUpload.FileName);
return;
}
ViewState["PhotoPath"]="";
return;
}
/// <summary>
/// Provides operations necessary to create and store new library file.
/// </summary>
private void HandleLibrariesUpload()
{
// Get related library info
if (LibraryInfo != null)
{
MediaFileInfo mediaFile = null;
// Get the site name
SiteInfo si = SiteInfoProvider.GetSiteInfo(LibraryInfo.LibrarySiteID);
string siteName = (si != null) ? si.SiteName : CMSContext.CurrentSiteName;
string message = string.Empty;
try
{
// Check the allowed extensions
CheckAllowedExtensions();
if (MediaFileID > 0)
{
#region "Check permissions"
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(LibraryInfo, "FileModify"))
{
throw new Exception(GetString("media.security.nofilemodify"));
}
#endregion
mediaFile = MediaFileInfoProvider.GetMediaFileInfo(MediaFileID);
if (mediaFile != null)
{
// Ensure object version
SynchronizationHelper.EnsureObjectVersion(mediaFile);
if (IsMediaThumbnail)
{
string newFileExt = Path.GetExtension(ucFileUpload.FileName).TrimStart('.');
if ((ImageHelper.IsImage(newFileExt)) && (newFileExt.ToLower() != "ico") &&
(newFileExt.ToLower() != "wmf"))
{
// Update or creation of Media File update
string previewSuffix = MediaLibraryHelper.GetMediaFilePreviewSuffix(siteName);
if (!String.IsNullOrEmpty(previewSuffix))
{
string previewExtension = Path.GetExtension(ucFileUpload.PostedFile.FileName);
string previewName = Path.GetFileNameWithoutExtension(MediaLibraryHelper.GetPreviewFileName(mediaFile.FileName, mediaFile.FileExtension, previewExtension, siteName, previewSuffix));
string previewFolder = DirectoryHelper.CombinePath(MediaLibraryHelper.EnsurePath(LibraryFolderPath.TrimEnd('/')), MediaLibraryHelper.GetMediaFileHiddenFolder(siteName));
byte[] previewFileBinary = new byte[ucFileUpload.PostedFile.ContentLength];
ucFileUpload.PostedFile.InputStream.Read(previewFileBinary, 0, ucFileUpload.PostedFile.ContentLength);
// Delete current preview thumbnails
MediaFileInfoProvider.DeleteMediaFilePreview(siteName, mediaFile.FileLibraryID, mediaFile.FilePath, false);
// Save preview file
MediaFileInfoProvider.SaveFileToDisk(siteName, LibraryInfo.LibraryFolder, previewFolder, previewName, previewExtension, mediaFile.FileGUID, previewFileBinary, false, false);
// Log synchronization task
SynchronizationHelper.LogObjectChange(mediaFile, TaskTypeEnum.UpdateObject);
}
// Drop the cache dependencies
CacheHelper.TouchKeys(MediaFileInfoProvider.GetDependencyCacheKeys(mediaFile, true));
}
else
{
message = GetString("media.file.onlyimgthumb");
}
}
else
{
// Get folder path
string path = Path.GetDirectoryName(DirectoryHelper.CombinePath(MediaLibraryInfoProvider.GetMediaLibraryFolderPath(this.LibraryInfo.LibraryID), mediaFile.FilePath));
// If file system permissions are sufficient for file update
if (DirectoryHelper.CheckPermissions(path, false, true, true, true))
{
// Delete existing media file
MediaFileInfoProvider.DeleteMediaFile(LibraryInfo.LibrarySiteID, LibraryInfo.LibraryID, mediaFile.FilePath, true, false);
// Update media file preview
if (MediaLibraryHelper.HasPreview(siteName, LibraryInfo.LibraryID, mediaFile.FilePath))
{
// Get new unique file name
string newName = URLHelper.GetSafeFileName(ucFileUpload.PostedFile.FileName, siteName);
// Get new file path
string newPath = DirectoryHelper.CombinePath(path, newName);
newPath = MediaLibraryHelper.EnsureUniqueFileName(newPath);
newName = Path.GetFileName(newPath);
// Rename preview
MediaLibraryHelper.MoveMediaFilePreview(mediaFile, newName);
// Delete preview thumbnails
MediaFileInfoProvider.DeleteMediaFilePreviewThumbnails(mediaFile);
}
// Receive media info on newly posted file
mediaFile = GetUpdatedFile(mediaFile.Generalized.DataClass);
// Save media file information
MediaFileInfoProvider.SetMediaFileInfo(mediaFile);
}
else
{
// Set error message
message = String.Format(GetString("media.accessdeniedtopath"), path);
}
}
}
}
else
{
#region "Check permissions"
// Creation of new media file
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(LibraryInfo, "FileCreate"))
{
throw new Exception(GetString("media.security.nofilecreate"));
}
#endregion
// No file for upload specified
if (!ucFileUpload.HasFile)
{
throw new Exception(GetString("media.newfile.errorempty"));
}
// Create new media file record
mediaFile = new MediaFileInfo(ucFileUpload.PostedFile, LibraryID, LibraryFolderPath, ResizeToWidth, ResizeToHeight, ResizeToMaxSideSize, LibraryInfo.LibrarySiteID);
mediaFile.FileDescription = "";
// Save the new file info
MediaFileInfoProvider.SetMediaFileInfo(mediaFile);
}
}
catch (Exception ex)
{
// Creation of new media file failed
message = ex.Message;
}
finally
{
// Create media file info string
string mediaInfo = "";
if ((mediaFile != null) && (mediaFile.FileID > 0) && (IncludeNewItemInfo))
{
mediaInfo = mediaFile.FileID + "|" + LibraryFolderPath.Replace('\\', '>').Replace("'", "\\'");
}
// Ensure message text
message = HTMLHelper.EnsureLineEnding(message, " ");
if (RaiseOnClick)
{
ScriptHelper.RegisterStartupScript(Page, typeof(Page), "UploaderOnClick", ScriptHelper.GetScript("if (parent.UploaderOnClick) { parent.UploaderOnClick('" + MediaFileName.Replace(" ", "").Replace(".", "").Replace("-", "") + "'); }"));
}
string script = String.Format(@"
if (typeof(parent.DFU) !== 'undefined') {{
parent.DFU.OnUploadCompleted('{0}');
}}
if ((window.parent != null) && (/parentelemid={1}/i.test(window.location.href)) && (window.parent.InitRefresh_{1} != null)){{
window.parent.InitRefresh_{1}({2}, false, '{3}'{4});
}}", QueryHelper.GetString("containerid", ""), ParentElemID, ScriptHelper.GetString(message.Trim()), mediaInfo, (InsertMode ? ", 'insert'" : ", 'update'"));
// Call function to refresh parent window
ScriptHelper.RegisterStartupScript(Page, typeof(Page), "RefreshParrent", ScriptHelper.GetScript(script));
}
}
}
/// <summary>
/// Stores new media file info into the DB.
/// </summary>
/// <param name="fi">Info on file to be stored</param>
/// <param name="title">Title of new media file</param>
/// <param name="description">Description of new media file</param>
/// <param name="name">Name of new media file</param>
/// <param name="filePath">File path</param>
public MediaFileInfo SaveNewFile(FileInfo fi, string title, string description, string name, string filePath)
{
string path = Path.EnsureSlashes(filePath);
string fileName = name;
string fullPath = fi.FullName;
string extension = URLHelper.GetSafeFileName(fi.Extension, SiteContext.CurrentSiteName);
// Check if filename is changed ad move file if necessary
if (fileName + extension != fi.Name)
{
string oldPath = path;
fullPath = MediaLibraryHelper.EnsureUniqueFileName(Path.GetDirectoryName(fullPath) + "\\" + fileName + extension);
path = Path.EnsureSlashes(Path.GetDirectoryName(path) + "/" + Path.GetFileName(fullPath)).TrimStart('/');
MediaFileInfoProvider.MoveMediaFile(SiteContext.CurrentSiteName, MediaLibraryID, oldPath, path, true);
}
// Create media file info
MediaFileInfo fileInfo = new MediaFileInfo(fullPath, LibraryInfo.LibraryID, Path.EnsureSlashes(Path.GetDirectoryName(path)), 0, 0, 0);
fileInfo.FileTitle = title;
fileInfo.FileDescription = description;
// Save media file info
MediaFileInfoProvider.ImportMediaFileInfo(fileInfo);
// Save FileID in ViewState
FileID = fileInfo.FileID;
FilePath = fileInfo.FilePath;
return fileInfo;
}
/// <summary>
/// Provides operations necessary to create and store new files in media library.
/// </summary>
/// <param name="args">Upload arguments.</param>
/// <param name="context">HttpContext instance.</param>
private void HandleMediaLibraryUpload(UploaderHelper args, HttpContext context)
{
string uploadPath = Path.Combine(MediaLibraryInfoProvider.GetMediaLibraryFolderPath(args.MediaLibraryArgs.LibraryID), args.MediaLibraryArgs.FolderPath);
string filePath = Path.Combine(uploadPath, args.FileName);
MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(args.MediaLibraryArgs.LibraryID);
if (mli != null)
{
MediaFileInfo mediaFile = null;
// Get the site name
SiteInfo si = SiteInfoProvider.GetSiteInfo(mli.LibrarySiteID);
string siteName = (si != null) ? si.SiteName : CMSContext.CurrentSiteName;
try
{
args.IsExtensionAllowed();
if (args.MediaLibraryArgs.MediaFileID > 0)
{
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "FileModify"))
{
throw new Exception(ResHelper.GetString("media.security.nofilemodify"));
}
mediaFile = MediaFileInfoProvider.GetMediaFileInfo(args.MediaLibraryArgs.MediaFileID);
if (mediaFile != null)
{
// Ensure object version
SynchronizationHelper.EnsureObjectVersion(mediaFile);
if (args.MediaLibraryArgs.IsMediaThumbnail)
{
if ((ImageHelper.IsImage(args.Extension)) && (args.Extension.ToLower() != "ico") && (args.Extension.ToLower() != "wmf"))
{
// Update or creation of Media File update
string previewSuffix = MediaLibraryHelper.GetMediaFilePreviewSuffix(siteName);
if (!String.IsNullOrEmpty(previewSuffix))
{
//string previewExtension = Path.GetExtension(ucFileUpload.PostedFile.FileName);
string previewName = Path.GetFileNameWithoutExtension(MediaLibraryHelper.GetPreviewFileName(mediaFile.FileName, mediaFile.FileExtension, args.Extension, siteName, previewSuffix));
string previewFolder = String.Format("{0}\\{1}", MediaLibraryHelper.EnsurePath(args.MediaLibraryArgs.FolderPath.TrimEnd('/')), MediaLibraryHelper.GetMediaFileHiddenFolder(siteName));
// This method is limited to 2^32 byte files (4.2 GB)
using (FileStream fs = File.OpenRead(args.FilePath))
{
byte[] previewFileBinary = new byte[fs.Length];
fs.Read(previewFileBinary, 0, Convert.ToInt32(fs.Length));
// Delete current preview thumbnails
MediaFileInfoProvider.DeleteMediaFilePreview(siteName, mediaFile.FileLibraryID, mediaFile.FilePath, false);
// Save preview file
MediaFileInfoProvider.SaveFileToDisk(siteName, mli.LibraryFolder, previewFolder, previewName, args.Extension, mediaFile.FileGUID, previewFileBinary, false, false);
// Log synchronization task
SynchronizationHelper.LogObjectChange(mediaFile, TaskTypeEnum.UpdateObject);
fs.Close();
}
}
// Drop the cache dependencies
CacheHelper.TouchKeys(MediaFileInfoProvider.GetDependencyCacheKeys(mediaFile, true));
}
else
{
args.Message = ResHelper.GetString("media.file.onlyimgthumb");
}
}
else
{
// Get folder path
string path = Path.GetDirectoryName(DirectoryHelper.CombinePath(MediaLibraryInfoProvider.GetMediaLibraryFolderPath(mli.LibraryID), mediaFile.FilePath));
// If file system permissions are sufficient for file update
if (DirectoryHelper.CheckPermissions(path, false, true, true, true))
{
// Delete existing media file
MediaFileInfoProvider.DeleteMediaFile(mli.LibrarySiteID, mli.LibraryID, mediaFile.FilePath, true, false);
// Update media file preview
if (MediaLibraryHelper.HasPreview(siteName, mli.LibraryID, mediaFile.FilePath))
{
// Get new unique file name
string newName = URLHelper.GetSafeFileName(Path.GetFileName(args.Name), siteName);
// Get new file path
string newPath = DirectoryHelper.CombinePath(path, newName);
newPath = MediaLibraryHelper.EnsureUniqueFileName(newPath);
newName = Path.GetFileName(newPath);
// Rename preview
MediaLibraryHelper.MoveMediaFilePreview(mediaFile, newName);
// Delete preview thumbnails
MediaFileInfoProvider.DeleteMediaFilePreviewThumbnails(mediaFile);
}
// Receive media info on newly posted file
mediaFile = GetUpdatedFile(mediaFile.Generalized.DataClass, args, mli);
MediaFileInfoProvider.SetMediaFileInfo(mediaFile);
}
}
}
}
else
{
// Check 'File create' permission
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "filecreate"))
{
throw new Exception(ResHelper.GetString("media.security.nofilecreate"));
}
mediaFile = new MediaFileInfo(args.FilePath, args.MediaLibraryArgs.LibraryID, args.MediaLibraryArgs.FolderPath, args.ResizeToWidth, args.ResizeToHeight, args.ResizeToMaxSide);
MediaFileInfoProvider.SetMediaFileInfo(mediaFile);
}
}
catch (Exception ex)
{
// Creation of new media file failed
args.Message = ex.Message;
}
finally
{
if (args.RaiseOnClick)
{
args.AfterScript += string.Format(@"
if(window.UploaderOnClick)
{{
window.UploaderOnClick('{0}');
}}", args.MediaLibraryArgs.MediaFileName.Replace(" ", "").Replace(".", "").Replace("-", ""));
}
// Create media library info string
string mediaInfo = ((mediaFile != null) && (mediaFile.FileID > 0) && (args.IncludeNewItemInfo)) ? String.Format("'{0}|{1}', ", mediaFile.FileID, args.MediaLibraryArgs.FolderPath.Replace('\\', '>').Replace("'", "\\'")) : "";
// Create after script and return it to the silverlight application, this script will be evaluated by the SL application in the end
args.AfterScript += string.Format(@"
if (window.InitRefresh_{0})
{{
window.InitRefresh_{0}('{1}', false, {2});
}}
else {{
if ('{1}' != '') {{
alert('{1}');
}}
}}", args.ParentElementID, ScriptHelper.GetString(args.Message.Trim(), false), mediaInfo + (args.IsInsertMode ? "'insert'" : "'update'"));
args.AddEventTargetPostbackReference();
context.Response.Write(args.AfterScript);
context.Response.Flush();
}
}
}
/// <summary>
/// Gets and bulk updates media files. Called when the "Get and bulk update files" button is pressed.
/// Expects the CreateMediaFile method to be run first.
/// </summary>
private bool GetAndBulkUpdateMediaFiles()
{
// Prepare the parameters
string where = "FileName LIKE 'MyNew%'";
// Get the data
DataSet files = MediaFileInfoProvider.GetMediaFiles(where, null);
if (!DataHelper.DataSourceIsEmpty(files))
{
// Loop through the individual items
foreach (DataRow fileDr in files.Tables[0].Rows)
{
// Create object from DataRow
MediaFileInfo modifyFile = new MediaFileInfo(fileDr);
// Update the property
modifyFile.FileName = modifyFile.FileName.ToUpper();
// Update the media file
MediaFileInfoProvider.SetMediaFileInfo(modifyFile);
}
return true;
}
return false;
}
/// <summary>
/// Gets HTML code of rendered DirectFileUploader control.
/// </summary>
/// <param name="mfi">Media file information</param>
public string GetWebDavHTML(MediaFileInfo mfi)
{
SiteInfo si = SiteInfoProvider.GetSiteInfo(mfi.FileSiteID);
if (si != null)
{
// If the WebDAV is enabled and windows authentication and extension is allowed
if (CMSContext.IsWebDAVEnabled(si.SiteName) && RequestHelper.IsWindowsAuthentication() && WebDAVSettings.IsExtensionAllowedForEditMode(mfi.FileExtension, si.SiteName))
{
StringBuilder sb = new StringBuilder();
using (StringWriter tw = new StringWriter(sb))
{
HtmlTextWriter hw = new HtmlTextWriter(tw);
WebDAVEditControl wabDavElem = Page.LoadControl("~/CMSModules/MediaLibrary/Controls/WebDAV/MediaFileWebDAVEditControl.ascx") as WebDAVEditControl;
if (wabDavElem != null)
{
// Initialize update control
innermedia.GetWebDAVEditControl(ref wabDavElem, mfi);
wabDavElem.ReloadData(true);
wabDavElem.RenderControl(hw);
}
}
return sb.ToString();
}
}
return null;
}
/// <summary>
/// Returns image name, title and description according to image type.
/// </summary>
/// <returns>Image name, title and description</returns>
void baseImageEditor_GetMetaData()
{
if (mfi == null)
{
mfi = MediaFileInfoProvider.GetMediaFileInfo(mediafileGuid, this.CurrentSiteName);
}
if (mfi != null)
{
string name = mfi.FileName;
baseImageEditor.GetNameResult = name;
baseImageEditor.GetTitleResult = mfi.FileTitle;
baseImageEditor.GetDescriptionResult = mfi.FileDescription;
}
}
/// <summary>
/// Gets HTML code of rendered DirectFileUploader control.
/// </summary>
/// <param name="mfi">Media file information</param>
public string GetDirectFileUploaderHTML(MediaFileInfo mfi)
{
StringBuilder sb = new StringBuilder();
using (StringWriter tw = new StringWriter(sb))
{
HtmlTextWriter hw = new HtmlTextWriter(tw);
DirectFileUploader dfuElem = Page.LoadControl("~/CMSModules/Content/Controls/Attachments/DirectFileUploader/DirectFileUploader.ascx") as DirectFileUploader;
if (dfuElem != null)
{
using (Panel updatePanel = new Panel())
{
// Initialize update control
innermedia.GetLibraryUpdateControl(ref dfuElem, mfi);
dfuElem.ReloadData();
updatePanel.Attributes["style"] = "height:16px;display:inline;";
updatePanel.Controls.Add(dfuElem);
updatePanel.RenderControl(hw);
}
}
}
return sb.ToString();
}
/// <summary>
/// Saves modified image data.
/// </summary>
/// <param name="name">Image name</param>
/// <param name="extension">Image extension</param>
/// <param name="mimetype">Image mimetype</param>
/// <param name="title">Image title</param>
/// <param name="description">Image description</param>
/// <param name="binary">Image binary data</param>
/// <param name="width">Image width</param>
/// <param name="height">Image height</param>
private void SaveImage(string name, string extension, string mimetype, string title, string description, byte[] binary, int width, int height)
{
// Process media file
if (mfi == null)
{
mfi = MediaFileInfoProvider.GetMediaFileInfo(mediafileGuid, this.CurrentSiteName);
}
if (mfi != null)
{
MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(mfi.FileLibraryID);
if (mli != null)
{
string path = Path.GetDirectoryName(DirectoryHelper.CombinePath(MediaLibraryInfoProvider.GetMediaLibraryFolderPath(mli.LibraryID), mfi.FilePath));
bool permissionsOK = DirectoryHelper.CheckPermissions(path, false, true, true, true);
if (permissionsOK)
{
MediaFileInfo originalMfi = mfi.Clone(true);
try
{
// Ensure object version
SynchronizationHelper.EnsureObjectVersion(mfi);
if (isPreview && !String.IsNullOrEmpty(PreviewPath))
{
SiteInfo si = SiteInfoProvider.GetSiteInfo(mfi.FileSiteID);
if (si != null)
{
string previewExt = (!String.IsNullOrEmpty(extension) && (extension != OldPreviewExt)) ? extension : OldPreviewExt;
string previewName = Path.GetFileNameWithoutExtension(PreviewPath);
string previewFolder = MediaLibraryHelper.EnsurePath(DirectoryHelper.CombinePath(Path.GetDirectoryName(mfi.FilePath).TrimEnd('/'), MediaLibraryHelper.GetMediaFileHiddenFolder(si.SiteName)));
// Delete old preview files with thumbnails
MediaFileInfoProvider.DeleteMediaFilePreview(CMSContext.CurrentSiteName, mli.LibraryID, mfi.FilePath, false);
MediaFileInfoProvider.DeleteMediaFilePreviewThumbnails(mfi);
// Save preview file
MediaFileInfoProvider.SaveFileToDisk(si.SiteName, mli.LibraryFolder, previewFolder, previewName, previewExt, mfi.FileGUID, binary, false, false);
// Log synchronization task
SynchronizationHelper.LogObjectChange(mfi, TaskTypeEnum.UpdateObject);
}
}
else
{
string newExt = null;
string newName = null;
if (!String.IsNullOrEmpty(extension))
{
newExt = extension;
}
if (!String.IsNullOrEmpty(mimetype))
{
mfi.FileMimeType = mimetype;
}
mfi.FileTitle = title;
mfi.FileDescription = description;
if (width > 0)
{
mfi.FileImageWidth = width;
}
if (height > 0)
{
mfi.FileImageHeight = height;
}
if (binary != null)
{
mfi.FileBinary = binary;
mfi.FileSize = binary.Length;
}
// Test all parameters to empty values and update new value if available
if (!String.IsNullOrEmpty(name))
{
newName = name;
}
// If filename changed move preview file and remove all ald thumbnails
if ((!String.IsNullOrEmpty(newName) && (mfi.FileName != newName)) || (!String.IsNullOrEmpty(newExt) && (mfi.FileExtension.ToLower() != newExt.ToLower())))
{
SiteInfo si = SiteInfoProvider.GetSiteInfo(mfi.FileSiteID);
if (si != null)
{
string fileName = (newName != null ? newName : mfi.FileName);
string fileExt = (newExt != null ? newExt : mfi.FileExtension);
string newPath = MediaFileInfoProvider.GetMediaFilePath(mfi.FileLibraryID, DirectoryHelper.CombinePath(Path.GetDirectoryName(mfi.FilePath), fileName) + fileExt);
string filePath = MediaFileInfoProvider.GetMediaFilePath(mfi.FileLibraryID, mfi.FilePath);
// Rename file only if file with same name does not exsists
if (!File.Exists(newPath))
{
// Ensure max length of file path
if (newPath.Length < 260)
{
// Remove old thumbnails
MediaFileInfoProvider.DeleteMediaFileThumbnails(mfi);
MediaFileInfoProvider.DeleteMediaFilePreviewThumbnails(mfi);
// Move media file
MediaFileInfoProvider.MoveMediaFile(si.SiteName, mli.LibraryID, mfi.FilePath, DirectoryHelper.CombinePath(Path.GetDirectoryName(mfi.FilePath), fileName) + fileExt, false);
// Set new file name or extension
mfi.FileName = fileName;
mfi.FileExtension = fileExt;
// Ensure new binary
if (binary != null)
{
mfi.FileBinary = binary;
mfi.FileSize = binary.Length;
}
}
else
{
throw new IOExceptions.PathTooLongException();
}
}
else
{
baseImageEditor.LblLoadFailed.Visible = true;
baseImageEditor.LblLoadFailed.ResourceString = "img.errors.fileexists";
SavingFailed = true;
return;
}
}
}
else
{
// Remove old thumbnails
MediaFileInfoProvider.DeleteMediaFileThumbnails(mfi);
// Remove original media file before save
string filePath = MediaFileInfoProvider.GetMediaFilePath(mfi.FileLibraryID, mfi.FilePath);
if (File.Exists(filePath))
{
File.Delete(filePath);
}
}
// Save new data
MediaFileInfoProvider.SetMediaFileInfo(mfi, false);
}
}
catch (Exception e)
{
// Log exception
EventLogProvider ev = new EventLogProvider();
ev.LogEvent("ImageEditor", "Save file", e);
baseImageEditor.LblLoadFailed.Visible = true;
baseImageEditor.LblLoadFailed.ResourceString = "img.errors.processing";
ScriptHelper.AppendTooltip(baseImageEditor.LblLoadFailed, e.Message, "help");
this.SavingFailed = true;
// Save original media file info
MediaFileInfoProvider.SetMediaFileInfo(originalMfi, false);
}
}
}
}
}
protected void btnUpload_Click(object sender, EventArgs e)
{
MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(LibraryID);
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "manage"))
{
// Check 'File create' permission
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "filecreate"))
{
RaiseOnNotAllowed("filecreate");
return;
}
}
if (!fileUploader.HasFile)
{
lblError.Text = GetString("media.selectfile");
lblError.Visible = true;
return;
}
// Check if preview file is image
if ((previewUploader.HasFile) &&
(!ImageHelper.IsImage(Path.GetExtension(previewUploader.FileName))) &&
(Path.GetExtension(previewUploader.FileName).ToLowerCSafe() != ".ico") &&
(Path.GetExtension(previewUploader.FileName).ToLowerCSafe() != ".tif") &&
(Path.GetExtension(previewUploader.FileName).ToLowerCSafe() != ".tiff") &&
(Path.GetExtension(previewUploader.FileName).ToLowerCSafe() != ".wmf"))
{
lblError.Text = GetString("Media.File.PreviewIsNotImage");
lblError.Visible = true;
return;
}
// Check if the preview file with given extension is allowed for library module
// Check if file with given extension is allowed for library module
string fileExt = Path.GetExtension(fileUploader.FileName).TrimStart('.');
string previewFileExt = Path.GetExtension(previewUploader.FileName).TrimStart('.');
// Check file extension
if (!MediaLibraryHelper.IsExtensionAllowed(fileExt))
{
lblError.Text = String.Format(GetString("media.newfile.extensionnotallowed"), fileExt);
lblError.Visible = true;
return;
}
// Check preview extension
if ((previewFileExt.Trim() != "") && !MediaLibraryHelper.IsExtensionAllowed(previewFileExt))
{
lblError.Text = String.Format(GetString("media.newfile.extensionnotallowed"), previewFileExt);
lblError.Visible = true;
return;
}
if (mli != null)
{
try
{
// Create new Media file
MediaFileInfo mfi = new MediaFileInfo(fileUploader.PostedFile, LibraryID, DestinationPath);
// Save preview if presented
if (previewUploader.HasFile)
{
// Get preview suffix if not set
if (String.IsNullOrEmpty(PreviewSuffix))
{
PreviewSuffix = MediaLibraryHelper.GetMediaFilePreviewSuffix(CMSContext.CurrentSiteName);
}
if (!String.IsNullOrEmpty(PreviewSuffix))
{
// Get physical path whithin the media library
String path = null;
if ((DestinationPath != null) && DestinationPath.TrimEnd('/') != "")
{
path = DirectoryHelper.CombinePath(DestinationPath.Trim('/').Replace('/', '\\'), MediaLibraryHelper.GetMediaFileHiddenFolder(CMSContext.CurrentSiteName));
}
else
{
path = MediaLibraryHelper.GetMediaFileHiddenFolder(CMSContext.CurrentSiteName);
}
string previewExtension = Path.GetExtension(previewUploader.PostedFile.FileName);
string previewName = Path.GetFileNameWithoutExtension(MediaLibraryHelper.GetPreviewFileName(mfi.FileName, mfi.FileExtension, previewExtension, CMSContext.CurrentSiteName, PreviewSuffix));
// Save preview file
MediaFileInfoProvider.SaveFileToDisk(CMSContext.CurrentSiteName, mli.LibraryFolder, path, previewName, previewExtension, mfi.FileGUID, previewUploader.PostedFile.InputStream, false);
}
}
// Save record to the database
MediaFileInfoProvider.SetMediaFileInfo(mfi);
// Clear cache
if (CMSControlsHelper.CurrentPageManager != null)
{
CMSControlsHelper.CurrentPageManager.ClearCache();
}
// Display info to the user
lblInfo.Text = GetString("media.fileuploaded");
lblInfo.Visible = true;
if (OnAfterFileUpload != null)
{
OnAfterFileUpload();
}
}
catch (Exception ex)
{
lblError.Visible = true;
lblError.Text = ex.Message;
lblError.ToolTip = ex.StackTrace;
}
}
}
/// <summary>
/// Returns URL of the media item according site settings.
/// </summary>
/// <param name="argument">Argument containing information on current media item</param>
/// <param name="data">Data row object holding all the data on the current file</param>
/// <param name="isPreview">Indicates whether the file has a preview file or not</param>
/// <param name="height">Specifies height of the image</param>
/// <param name="width">Specifies width of the image</param>
/// <param name="maxSideSize">Specifies maximum size of the image</param>
/// <param name="notAttachment">Indicates whether the file is attachment</param>
private string GetItemUrlInternal(string argument, IDataContainer data, bool isPreview, int height, int width, int maxSideSize, bool notAttachment)
{
MediaFileInfo mfi = null;
// Get filename with extension
string fileName;
if (data.ContainsColumn("FileExtension"))
{
string ext = ValidationHelper.GetString(data.GetValue("FileExtension"), "");
// In format 'name'
fileName = ValidationHelper.GetString(data.GetValue("FileName"), "");
fileName = AttachmentHelper.GetFullFileName(fileName, ext);
}
else
{
// In format 'name.ext'
fileName = data.GetValue("FileName").ToString();
}
// Try to get imported data row
DataRow importedRow = GetInformationInternal("fileisnotindatabase", fileName) as DataRow;
if (importedRow != null)
{
mfi = new MediaFileInfo(importedRow);
}
// If data row is not from DB check external library
if (!data.ContainsColumn("FileGUID"))
{
bool isExternal = false;
// Check if is external media library
if (data.ContainsColumn("FilePath"))
{
// Get file path
string filePath = ValidationHelper.GetString(data.GetValue("FilePath"), String.Empty);
if (!String.IsNullOrEmpty(filePath))
{
// Test if file path is inside system root folder
string rootPath = Server.MapPath("~/");
if (!filePath.StartsWithCSafe(rootPath))
{
isExternal = true;
}
}
}
if (isExternal && data.ContainsColumn("FileName"))
{
return (mfi != null ? GetItemUrl(mfi, isPreview, height, width, maxSideSize) : String.Empty);
}
}
// Files are obtained from the FS
if (data.ContainsColumn("FileURL"))
{
// Information comming from FileSystem (FS)
return URLHelper.GetAbsoluteUrl(data.GetValue("FileURL").ToString());
}
else
{
return (mfi != null ? GetItemUrl(mfi, isPreview, height, width, maxSideSize) : GetItemUrl(argument, isPreview, height, width, maxSideSize));
}
}
/// <summary>
/// Returns URL of the media item according site settings.
/// </summary>
/// <param name="fileInfo">Media file information</param>
/// <param name="isPreview">Indicates whether the file has a preview file or not</param>
/// <param name="height">Height of the requested image</param>
/// <param name="width">Width of the requested image</param>
/// <param name="maxSideSize">Maximum dimension for images displayed for thumbnails view</param>
public string GetItemUrl(MediaFileInfo fileInfo, bool isPreview, int height, int width, int maxSideSize)
{
if (fileInfo != null)
{
return GetItemUrl(fileInfo, LibrarySite, fileInfo.FileGUID, fileInfo.FileName, fileInfo.FileExtension, fileInfo.FilePath, isPreview, height, width, maxSideSize);
}
return "";
}
/// <summary>
/// Processes the specified file.
/// </summary>
/// <param name="fileGuid">File guid</param>
/// <param name="preview">Use preview</param>
protected void ProcessFile(Guid fileGuid, bool preview)
{
// Get the file info if doesn't retrieved yet
fileInfo = (fileInfo ?? MediaFileInfoProvider.GetMediaFileInfo(fileGuid, CurrentSiteName));
if (fileInfo != null)
{
if (preview)
{
// Get file path
string path = MediaFileInfoProvider.GetMediaFilePath(fileInfo.FileLibraryID, fileInfo.FilePath);
string pathDirectory = Path.GetDirectoryName(path);
string hiddenFolderPath = MediaLibraryHelper.GetMediaFileHiddenFolder(CurrentSiteName);
string folderPath = DirectoryHelper.CombinePath(pathDirectory, hiddenFolderPath);
// Ensure hidden folder exists
DirectoryHelper.EnsureDiskPath(folderPath, pathDirectory);
// Get preview file
string[] files = Directory.GetFiles(folderPath, MediaLibraryHelper.GetPreviewFileName(fileInfo.FileName, fileInfo.FileExtension, ".*", CurrentSiteName));
if (files.Length > 0)
{
bool resizeImage = (ImageHelper.IsImage(Path.GetExtension(files[0])) && MediaFileInfoProvider.CanResizeImage(files[0], Width, Height, MaxSideSize));
// Get the data
if ((outputFile == null) || (outputFile.MediaFile == null))
{
outputFile = NewOutputFile(fileInfo, null);
outputFile.UsePreview = true;
outputFile.Width = Width;
outputFile.Height = Height;
outputFile.MaxSideSize = MaxSideSize;
outputFile.Resized = resizeImage;
outputFile.FileExtension = Path.GetExtension(files[0]);
outputFile.MimeType = MimeTypeHelper.GetMimetype(outputFile.FileExtension);
}
}
}
else
{
bool resizeImage = (ImageHelper.IsImage(fileInfo.FileExtension) && MediaFileInfoProvider.CanResizeImage(fileInfo, Width, Height, MaxSideSize));
// Get the data
if ((outputFile == null) || (outputFile.MediaFile == null))
{
outputFile = NewOutputFile(fileInfo, null);
outputFile.Width = Width;
outputFile.Height = Height;
outputFile.MaxSideSize = MaxSideSize;
outputFile.Resized = resizeImage;
}
}
}
}
/// <summary>
/// Returns URL of the media item according site settings.
/// </summary>
/// <param name="fileInfo">File info object</param>
/// <param name="site">Information on site file belongs to</param>
/// <param name="fileGuid">GUID of the file URL is generated for</param>
/// <param name="fileName">Name of the file URL is generated for</param>
/// <param name="fileExtension">Extension of the file URL is generated for</param>
/// <param name="filePath">Media file path of the file URL is generated for</param>
/// <param name="isPreview">Indicates whether the file URL is generated for preview</param>
/// <param name="height">Specifies height of the image</param>
/// <param name="width">Specifies width of the image</param>
/// <param name="maxSideSize">Maximum dimension for images displayed for thumbnails view</param>
public string GetItemUrl(MediaFileInfo fileInfo, SiteInfo site, Guid fileGuid, string fileName, string fileExtension, string filePath, bool isPreview, int height, int width, int maxSideSize)
{
string result;
bool resize = (maxSideSize > 0);
fileName = UsePermanentUrls ? AttachmentHelper.GetFullFileName(fileName, fileExtension) : fileName;
bool generateFullURL = ValidationHelper.GetBoolean(SettingsHelper.AppSettings["CMSUseMediaFileAbsoluteURLs"], false);
if ((Config != null) && (Config.UseFullURL || generateFullURL || (SiteContext.CurrentSiteID != LibraryInfo.LibrarySiteID) || (SiteContext.CurrentSiteID != GetCurrentSiteId())))
{
// If permanent URLs should be generated
if (UsePermanentUrls || resize || isPreview)
{
// URL in format 'http://domainame/getmedia/123456-25245-45454-45455-5455555545/testfile.gif'
result = MediaFileURLProvider.GetMediaFileAbsoluteUrl(site.SiteName, fileGuid, fileName);
}
else
{
// URL in format 'http://domainame/cms/EcommerceSite/media/testlibrary/folder1/testfile.gif'
result = MediaFileURLProvider.GetMediaFileAbsoluteUrl(site.SiteName, LibraryInfo.LibraryFolder, filePath);
}
}
else
{
if (UsePermanentUrls || resize || isPreview)
{
// URL in format '/cms/getmedia/123456-25245-45454-45455-5455555545/testfile.gif'
result = MediaFileURLProvider.GetMediaFileUrl(fileGuid, fileName);
}
else
{
if (fileInfo != null)
{
result = MediaFileURLProvider.GetMediaFileUrl(fileInfo, SiteContext.CurrentSiteName, LibraryInfo.LibraryFolder);
}
else
{
// URL in format '/cms/EcommerceSite/media/testlibrary/folder1/testfile.gif'
result = MediaFileURLProvider.GetMediaFileUrl(SiteContext.CurrentSiteName, LibraryInfo.LibraryFolder, filePath);
}
}
}
// If image dimensions are specified
if (resize)
{
result = URLHelper.AddParameterToUrl(result, "maxsidesize", maxSideSize.ToString());
}
if (height > 0)
{
result = URLHelper.AddParameterToUrl(result, "height", height.ToString());
}
if (width > 0)
{
result = URLHelper.AddParameterToUrl(result, "width", width.ToString());
}
// Media selctor should returns non-resolved URL in all cases
bool isMediaSelector = (OutputFormat == OutputFormatEnum.URL) && (SelectableContent == SelectableContentEnum.OnlyMedia);
return (isMediaSelector ? result : URLHelper.ResolveUrl(result));
}
/// <summary>
/// Gets the new output MediaFile object.
/// </summary>
/// <param name="mfi">Media file info</param>
/// <param name="data">Output MediaFile data</param>
public CMSOutputMediaFile NewOutputFile(MediaFileInfo mfi, byte[] data)
{
CMSOutputMediaFile mf = new CMSOutputMediaFile(mfi, data)
{
Watermark = Watermark,
WatermarkPosition = WatermarkPosition
};
return mf;
}
/// <summary>
/// Returns the output data dependency based on the given attachment record.
/// </summary>
/// <param name="mi">MediaFile object</param>
protected CacheDependency GetOutputDataDependency(MediaFileInfo mi)
{
if (mi == null)
{
return null;
}
return CacheHelper.GetCacheDependency(MediaFileInfoProvider.GetDependencyCacheKeys(mi, Preview));
}
/// <summary>
/// Gets media file info object representing the updated version of original file
/// </summary>
private MediaFileInfo GetUpdatedFile(CMS.DataEngine.IDataClass origFileDataClass, UploaderHelper args, MediaLibraryInfo mli)
{
// Get info on media file from uploaded file
MediaFileInfo mediaFile = new MediaFileInfo(args.FilePath, args.MediaLibraryArgs.LibraryID, args.MediaLibraryArgs.FolderPath, args.ResizeToWidth, args.ResizeToHeight, args.ResizeToMaxSide);
// Create new file based on original
MediaFileInfo updatedMediaFile = new MediaFileInfo(origFileDataClass)
{
// Update necessary information
FileName = mediaFile.FileName,
FileExtension = mediaFile.FileExtension,
FileSize = mediaFile.FileSize,
FileMimeType = mediaFile.FileMimeType,
FilePath = mediaFile.FilePath,
FileModifiedByUserID = mediaFile.FileModifiedByUserID,
FileBinary = mediaFile.FileBinary,
FileImageHeight = mediaFile.FileImageHeight,
FileImageWidth = mediaFile.FileImageWidth,
FileBinaryStream = mediaFile.FileBinaryStream
};
return updatedMediaFile;
}
