/// <summary>
/// Returns a media file by its URL.
/// </summary>
/// <param name="urlPath">The media file relative URL path (no application path).</param>
/// <returns><see cref="MediaFileInfo"/> representing the media file, otherwise returns null.</returns>
/// <exception cref="ArgumentNullException"> if <paramref name="pageUrl"/> is <c>null</c>.</exception>
public MediaFileInfo GetMediaFile(string urlPath)
{
// Treat the URL as a permanent URL
if (urlPath.StartsWith("/getmedia/", StringComparison.OrdinalIgnoreCase))
{
Match m = GuidReg.Match(urlPath);
if (m.Success)
{
Guid guid = new Guid(m.Groups[0].Value);
return(MediaFileInfoProvider.GetMediaFileInfo(guid, siteName));
}
}
// Treat the URL as a direct URL
else
{
string mediaLibraryRootFolder = GetMediaFileLibraryRootFolder();
if (urlPath.StartsWith(mediaLibraryRootFolder, StringComparison.OrdinalIgnoreCase))
{
var mediaFilePathData = GetMediaFileDirectPathData(urlPath, mediaLibraryRootFolder);
if (mediaFilePathData != null)
{
return(MediaFileInfoProvider.GetMediaFileInfo(siteName, mediaFilePathData.MediaFilePath, mediaFilePathData.LibraryFolder));
}
}
}
return(null);
}
/// <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);
}
private byte[] GetFileBinary(BaseInfo image)
{
switch (image)
{
case MediaFileInfo mediaFile:
// For files with uploaded binary (new file or update)
if (mediaFile.FileBinary != null)
{
return(mediaFile.FileBinary);
}
// For existing files
var mediaLibrary = MediaLibraryInfoProvider.GetMediaLibraryInfo(mediaFile.FileLibraryID);
return(MediaFileInfoProvider.GetFile(mediaFile, mediaLibrary.LibraryFolder, SiteContext.CurrentSiteName));
case MetaFileInfo metaFile:
// For files with uploaded binary (new file or update)
if (metaFile.MetaFileBinary != null)
{
return(metaFile.MetaFileBinary);
}
// For existing files
return(MetaFileInfoProvider.GetFile(metaFile, SiteContext.CurrentSiteName));
case AttachmentInfo attachment:
return(attachment.AttachmentBinary);
case AttachmentHistoryInfo attachmentHistory:
return(attachmentHistory.AttachmentBinary);
default:
return(null);
}
}
/// <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 async Task UpsertAllMediaFiles(MediaLibraryInfo mediaLibrary)
{
try
{
SyncLog.Log($"Synchronizing files for media library {mediaLibrary.LibraryDisplayName}");
SyncLog.LogEvent(EventType.INFORMATION, "KenticoKontentPublishing", "UPSERTMEDIAFILES", mediaLibrary.LibraryDisplayName);
var mediaFiles = MediaFileInfoProvider.GetMediaFiles()
.WhereEquals("FileLibraryID", mediaLibrary.LibraryID)
.BinaryData(false);
var index = 0;
foreach (var mediaFile in mediaFiles)
{
index++;
SyncLog.Log($"Media file {mediaFile.FilePath} ({index}/{mediaFiles.Count})");
await SyncMediaFile(mediaFile);
}
}
catch (Exception ex)
{
SyncLog.LogException("KenticoKontentPublishing", "UPSERTMEDIAFILES", ex);
throw;
}
}
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);
}
public ActionResult Index()
{
var properties = GetProperties();
if (properties.Image?.Count > 0)
{
var fileguid = properties.Image.FirstOrDefault()?.FileGuid ?? Guid.Empty;
var fileInfo = MediaFileInfoProvider.GetMediaFileInfo(fileguid, SiteContext.CurrentSiteName);
string fileURL = MediaFileURLProvider.GetMediaFileUrl(fileInfo.FileGUID, fileInfo.FileName) ?? string.Empty;
return(PartialView("Widgets/EditableImageWidget/_EditableImageWidget", new EditableImageWidgetViewModel()
{
ImageURL = fileURL,
AlternateText = properties?.AlternateText,
ImageCSSClass = properties.ImagClass,
RenderAsLink = properties.ShowImageAsLink,
RedirectionURL = properties.RedirectionURL,
LinkCSSClass = properties.LinkClass,
Height = properties.Height > 0 ? properties.Height : fileInfo.FileImageHeight,
Width = properties.Width > 0 ? properties.Width : fileInfo.FileImageWidth
}));
}
else
{
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);
}
string GetDirectImageUrlFromMediaLibrary(Guid imageGuid)
{
//get filenale
string fileName = null;
var libs = MediaLibraryInfoProvider.GetMediaLibraries().ToList();
foreach (var lib in libs)
{
var folder = lib.Children.FirstOrDefault();
foreach (var image in folder)
{
if (!string.IsNullOrEmpty(image.GetProperty("Guid").ToString()))
{
if (image.GetProperty("Guid").ToString() == imageGuid.ToString())
{
fileName = image.GetProperty("FileName").ToString();
}
}
}
}
var siteName = SiteContext.CurrentSiteName;
var urlMediaFileInfo = MediaFileInfoProvider.GetMediaFileInfo(imageGuid, siteName);
string url = MediaLibraryHelper.GetDirectUrl(urlMediaFileInfo);
return(url);
}
public static MediaFileInfo GetCachedMediaFileInfo(Int32 libraryID, String path)
{
var mediaInfo = CacheHelper.Cache(cs =>
{
try
{
var file = MediaFileInfoProvider.GetMediaFiles()
.WhereEquals("FileLibraryID", libraryID)
.WhereEquals("FilePath", path)
.Columns("FileGUID", "FileName", "FileExtension")
.FirstObject;
if (cs.Cached)
{
cs.CacheDependency = CacheHelper.GetCacheDependency("mediafile|" + file.FileGUID);
}
return(file);
}
catch (Exception ex)
{
EventLogProvider.LogException("GetCachedMediaFileInfo", EventType.INFORMATION, ex, SiteContext.CurrentSiteID, "Unabled to get media file: " + path);
}
return(null);
}, new CacheSettings(DefaultCacheMinutes, "custom|getcachedmediafile|" + path));
return(mediaInfo);
}
/// <summary>
/// Gets direct path for preview image of currently edited media file.
/// </summary>
private string GetPrevDirectPath()
{
string prevUrl = "";
// Direct path
string previewPath = null;
string previewFolder = null;
if (Path.GetDirectoryName(FileInfo.FilePath).EndsWithCSafe(MediaLibraryHelper.GetMediaFileHiddenFolder(CMSContext.CurrentSiteName)))
{
previewFolder = Path.GetDirectoryName(FileInfo.FilePath) + "\\" + MediaLibraryHelper.GetPreviewFileName(FileInfo.FileName, FileInfo.FileExtension, ".*", CMSContext.CurrentSiteName);
previewPath = MediaLibraryInfoProvider.GetMediaLibraryFolderPath(FileInfo.FileLibraryID) + "\\" + previewFolder;
}
else
{
previewFolder = Path.GetDirectoryName(FileInfo.FilePath) + "\\" + MediaLibraryHelper.GetMediaFileHiddenFolder(CMSContext.CurrentSiteName) + "\\" + MediaLibraryHelper.GetPreviewFileName(FileInfo.FileName, FileInfo.FileExtension, ".*", CMSContext.CurrentSiteName);
previewPath = MediaLibraryInfoProvider.GetMediaLibraryFolderPath(FileInfo.FileLibraryID) + "\\" + previewFolder;
}
if (Directory.Exists(Path.GetDirectoryName(previewPath)))
{
string[] files = Directory.GetFiles(Path.GetDirectoryName(previewPath), Path.GetFileName(previewPath));
if (files.Length > 0)
{
previewFolder = Path.GetDirectoryName(previewFolder).Replace('\\', '/').TrimStart('/');
string prevFileName = Path.GetFileName(files[0]);
prevUrl = MediaFileInfoProvider.GetMediaFileUrl(CMSContext.CurrentSiteName, LibraryInfo.LibraryFolder, previewFolder + '/' + prevFileName);
prevUrl = URLHelper.ResolveUrl(prevUrl);
}
}
return(prevUrl);
}
/// <inheritdoc/>
public IMediaFile GetMediaFile(int mediaFileId)
{
MediaFileInfo file = MediaFileInfoProvider.GetMediaFileInfo(mediaFileId);
file = SetFileBinary(file);
return(file?.ActLike <IMediaFile>());
}
/// <summary>
/// UniGrid action buttons event handler.
/// </summary>
protected void GridOnAction(string actionName, object actionArgument)
{
// Process proper action
switch (actionName.ToLower())
{
case "delete":
if (this.IsMediaThumbnail)
{
// Delete thumbnail file
if (this.LibraryInfo != null)
{
// Check 'File delete' permission
if (MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(this.LibraryInfo, "filemodify"))
{
MediaFileInfoProvider.DeleteMediaFilePreview(CMSContext.CurrentSiteName, this.LibraryID, this.FileInfo.FilePath, false);
if (this.FileInfo != null)
{
SiteInfo si = SiteInfoProvider.GetSiteInfo(FileInfo.FileSiteID);
if (si != null)
{
// Log synchronization task
SynchronizationHelper.LogObjectChange(FileInfo, TaskTypeEnum.UpdateObject);
}
// Drop the cache dependencies
CacheHelper.TouchKeys(MediaFileInfoProvider.GetDependencyCacheKeys(this.FileInfo, true));
}
}
else
{
lblError.Text = MediaLibraryHelper.GetAccessDeniedMessage("filemodify");
}
}
// Ensure recent action is forgotten
this.gridAttachments.ClearActions();
}
else
{
if (this.LibraryInfo != null)
{
// Check 'File delete' permission
if (MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(this.LibraryInfo, "filedelete"))
{
// Delete Media File
if (this.FileInfo != null)
{
MediaFileInfoProvider.DeleteMediaFileInfo(this.FileInfo);
}
}
}
}
// Force reload data
ReloadData();
break;
}
}
/// <summary>
/// Setup general values.
/// </summary>
private void SetupFile()
{
// Get file and library info
if ((FileInfo != null) && (LibraryInfo != null))
{
formMediaFileCustomFields.IsLiveSite = IsLiveSite;
if (MediaLibraryHelper.IsExternalLibrary(SiteContext.CurrentSiteName, LibraryInfo.LibraryFolder))
{
plcDirPath.Visible = false;
}
else
{
string url = MediaFileInfoProvider.GetMediaFileUrl(LibrarySiteInfo.SiteName, LibraryInfo.LibraryFolder, FileInfo.FilePath);
ltrDirPathValue.Text = GetFileLinkHtml(ResolveUrl(url));
}
ltrPermaLinkValue.Text = GetFileLinkHtml(ResolveUrl(MediaFileInfoProvider.GetMediaFileUrl(FileInfo.FileGUID, FileInfo.FileName)));
if (ImageHelper.IsImage(FileInfo.FileExtension))
{
// Ensure max side size 200
int[] maxsize = ImageHelper.EnsureImageDimensions(0, 0, 200, FileInfo.FileImageWidth, FileInfo.FileImageHeight);
imagePreview.Width = maxsize[0];
imagePreview.Height = maxsize[1];
// If is Image show image properties
imagePreview.URL = URLHelper.AddParameterToUrl(MediaFileInfoProvider.GetMediaFileUrl(FileInfo.FileGUID, SiteContext.CurrentSiteName), "maxsidesize", "200");
imagePreview.URL = URLHelper.AddParameterToUrl(imagePreview.URL, "chset", Guid.NewGuid().ToString());
plcImagePreview.Visible = true;
plcMediaPreview.Visible = false;
pnlPrew.Visible = true;
}
else if (MediaHelper.IsAudioVideo(FileInfo.FileExtension))
{
mediaPreview.Height = MediaHelper.IsAudio(FileInfo.FileExtension) ? 45 : 180;
mediaPreview.Width = 270;
mediaPreview.AutoPlay = false;
mediaPreview.AVControls = true;
mediaPreview.Loop = false;
mediaPreview.Type = FileInfo.FileExtension;
// If is Image show image properties
mediaPreview.Url = MediaFileInfoProvider.GetMediaFileUrl(FileInfo.FileGUID, FileInfo.FileName);
plcMediaPreview.Visible = true;
plcImagePreview.Visible = false;
pnlPrew.Visible = true;
}
else
{
pnlPrew.Visible = false;
}
}
else
{
pnlPrew.Visible = false;
}
}
/// <summary>
/// Ensures the physical file.
/// </summary>
/// <param name="file">Output file</param>
public bool EnsurePhysicalFile(CMSOutputMediaFile file)
{
if (file == null)
{
return(false);
}
// Try to link to file system
if (String.IsNullOrEmpty(file.Watermark) && (file.MediaFile != null) && (file.MediaFile.FileID > 0))
{
SiteInfo si = SiteInfoProvider.GetSiteInfo(file.MediaFile.FileSiteID);
if (si != null)
{
bool generateThumbnails = ValidationHelper.GetBoolean(SettingsKeyInfoProvider.GetStringValue(si.SiteName + ".CMSGenerateThumbnails"), true);
string filePath = null;
string libraryFolder = Path.EnsureEndBackslash(MediaLibraryInfoProvider.GetMediaLibraryFolderPath(file.MediaFile.FileLibraryID));
if (file.Resized && generateThumbnails)
{
filePath = libraryFolder + MediaFileInfoProvider.EnsureThumbnailFile(file.MediaFile, file.SiteName, Width, Height, MaxSideSize, file.UsePreview);
}
else
{
if (file.UsePreview)
{
// Get file path
string path = MediaFileInfoProvider.GetMediaFilePath(file.MediaFile.FileLibraryID, file.MediaFile.FilePath);
string pathDirectory = Path.GetDirectoryName(path);
string hiddenFolderPath = MediaLibraryHelper.GetMediaFileHiddenFolder(CurrentSiteName);
string folderPath = String.Format("{0}\\{1}", pathDirectory, hiddenFolderPath);
// Ensure hidden folder exists
DirectoryHelper.EnsureDiskPath(folderPath, pathDirectory);
// Get preview file
string[] files = Directory.GetFiles(folderPath, MediaLibraryHelper.GetPreviewFileName(file.MediaFile.FileName, file.MediaFile.FileExtension, ".*", CurrentSiteName));
if (files.Length > 0)
{
filePath = files[0];
}
}
else
{
filePath = libraryFolder + file.MediaFile.FilePath;
}
}
if (filePath != null)
{
// Link to the physical file
file.PhysicalFile = filePath;
return(true);
}
}
}
file.PhysicalFile = "";
return(false);
}
public ActionResult Index()
{
var properties = GetProperties();
IEnumerable <Picture> pictures = new List <Picture>();
switch (properties.Type)
{
case Type.Attachments:
pictures = this.GetPage().Attachments.ToList().Where(a => a.AttachmentImageWidth > 0).Select(a => new Picture
{
Url = CMS.DocumentEngine.AttachmentURLProvider.GetAttachmentUrl(a.AttachmentName, this.GetPage().NodeAliasPath),
AltText = a.AttachmentTitle,
Thumbnail = $"{AttachmentURLProvider.GetAttachmentUrl(a.AttachmentName, this.GetPage().NodeAliasPath)}?maxsidesize=128"
});
break;
case Type.MediaLibraryFolder:
/*var library = MediaLibraryInfoProvider.GetMediaLibraryInfo(properties.MediaLibraryFolder, this.GetPage().NodeSiteName);
* if (string.IsNullOrEmpty(properties.MediaLibraryFolder))
* {
* properties.MediaLibraryFolder = "%";
* }
* var files = MediaFileInfoProvider.GetMediaFiles($"{nameof(MediaFileInfo.FileLibraryID)}={library.LibraryID} AND {nameof(MediaFileInfo.FilePath)} LIKE '{properties.MediaLibrarySubfolder}%'");
* pictures = files.ToList().Select(f => new Picture
* {
* Url = MediaLibraryHelper.GetMediaFileUrl(f.FileGUID, this.GetPage().NodeSiteName),
* AltText = f.FileTitle,
* Thumbnail = $"{MediaFileURLProvider.GetMediaFileAbsoluteUrl(this.GetPage().NodeSiteName, f.FileGUID, f.FileName)}?maxsidesize=120"
* });*/
if (properties.MediaFiles != null)
{
pictures = properties.MediaFiles.Select(m => new Picture
{
Url = MediaLibraryHelper.GetMediaFileUrl(m.FileGuid, this.GetPage().NodeSiteName),
AltText = MediaFileInfoProvider.GetMediaFileInfo(m.FileGuid, this.GetPage().NodeSiteName).FileTitle,
Thumbnail = $"{MediaFileURLProvider.GetMediaFileAbsoluteUrl(this.GetPage().NodeSiteName, m.FileGuid, MediaFileInfoProvider.GetMediaFileInfo(m.FileGuid, this.GetPage().NodeSiteName).FileName)}?maxsidesize=128"
});
}
break;
case Type.External:
pictures = properties.External.Split(new[] { Environment.NewLine }, StringSplitOptions.None).Select(f => new Picture
{
Url = f,
AltText = f,
Thumbnail = f
});
break;
}
var viewModel = new ViewModel
{
Pictures = pictures
};
return(PartialView("Widgets/_LightboxGallery", viewModel));
}
/// <summary>
/// Returns URL to media file which is rewritten to calling GetMediaFile.aspx page where user permissions are checked.
/// </summary>
/// <param name="fileGuid">File GUID</param>
/// <param name="fileName">File name</param>
public static string GetMediaFileUrl(object fileGuid, object fileName)
{
if (fileName != null)
{
return(MediaFileInfoProvider.GetMediaFileUrl(ValidationHelper.GetGuid(fileGuid, Guid.Empty), fileName.ToString()));
}
return("");
}
/// <summary>
/// Edit file event handler.
/// </summary>
protected void btnRefresh_Click(object sender, EventArgs e)
{
// Check 'File modify' permission
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(LibraryInfo, "filemodify"))
{
ShowError(MediaLibraryHelper.GetAccessDeniedMessage("filemodify"));
SetupFile();
return;
}
FileInfo fi = CMS.IO.FileInfo.New(MediaFileInfoProvider.GetMediaFilePath(CMSContext.CurrentSiteName, LibraryInfo.LibraryFolder, FilePath));
if ((fi != null) && (LibraryInfo != null))
{
if (FileInfo != null)
{
FileInfo.FileModifiedWhen = DateTime.Now;
// Set media file info
FileInfo.FileSize = fi.Length;
if (ImageHelper.IsImage(FileInfo.FileExtension))
{
ImageHelper ih = new ImageHelper();
ih.LoadImage(File.ReadAllBytes(fi.FullName));
FileInfo.FileImageWidth = ih.ImageWidth;
FileInfo.FileImageHeight = ih.ImageHeight;
}
FileInfo.FileTitle = txtEditTitle.Text.Trim();
FileInfo.FileDescription = txtEditDescription.Text.Trim();
// Save
MediaFileInfoProvider.SetMediaFileInfo(FileInfo);
// Remove old thumbnails
MediaFileInfoProvider.DeleteMediaFileThumbnails(FileInfo);
// Inform user on success
ShowConfirmation(GetString("media.refresh.success"));
SetupTexts();
SetupFile();
pnlUpdateGeneral.Update();
SetupPreview();
pnlUpdatePreviewDetails.Update();
SetupEdit();
pnlUpdateFileInfo.Update();
SetupVersions(false);
pnlUpdateVersions.Update();
RaiseOnAction("rehighlightitem", Path.GetFileName(FileInfo.FilePath));
}
}
}
/// <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>
/// Deletes media file. Called when the "Delete file" button is pressed.
/// Expects the CreateMediaFile method to be run first.
/// </summary>
private bool DeleteMediaFile()
{
// Get the media file
MediaFileInfo deleteFile = MediaFileInfoProvider.GetMediaFileInfo(SiteContext.CurrentSiteName, "MyNewFolder/MyNewFile.gif", null);
// Delete the media file
MediaFileInfoProvider.DeleteMediaFileInfo(deleteFile);
return(deleteFile != null);
}
/// <summary>
/// Returns direct URL to the media file, user permissions are not checked.
/// </summary>
/// <param name="libraryId">Media library ID</param>
/// <param name="filePath">File path</param>
public static string GetMediaFileDirectUrl(object libraryId, object filePath)
{
MediaLibraryInfo libInfo = MediaLibraryInfoProvider.GetMediaLibraryInfo(ValidationHelper.GetInteger(libraryId, 0));
if (libInfo != null)
{
return(MediaFileInfoProvider.GetMediaFileUrl(CMSContext.CurrentSiteName, libInfo.LibraryFolder, filePath.ToString()));
}
return(String.Empty);
}
/// <summary>
/// Returns a direct path for the given media file.
/// The method can return the following URL types:
/// ~/mediaLibraryFolder/filename.extension
/// ~/getazurefile.aspx?path=, ~/getmazonfile.aspx?path= ...
/// http://CDN/mediaLibraryFolder/filename.extension
/// </summary>
private static string GetDirectPath(MediaFileInfo mediaFile, SiteInfo mediaFileSite)
{
var mediaLibrary = MediaLibraryInfoProvider.GetMediaLibraryInfo(mediaFile.FileLibraryID);
if ((mediaLibrary != null) && (mediaFileSite != null))
{
return(MediaFileInfoProvider.GetMediaFileUrl(mediaFileSite.SiteName, mediaLibrary.LibraryFolder, mediaFile.FilePath));
}
return(null);
}
/// <inheritdoc/>
public void DeleteMediaFile(IMediaFile file)
{
MediaFileInfo mediaFileInfo = MediaFileInfoProvider.GetMediaFileInfo(file.FileID);
if (mediaFileInfo == null)
{
return;
}
// Deletes the media file
MediaFileInfoProvider.DeleteMediaFileInfo(mediaFileInfo);
}
/// <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>
/// Performs action itself.
/// </summary>
/// <param name="origDBFilePath">Path of the file specified in DB</param>
/// <param name="newDBFilePath">New path of the file being inserted into DB</param>
private void CopyMove(string origDBFilePath, string newDBFilePath)
{
switch (Action.ToLower())
{
case "move":
MediaFileInfoProvider.MoveMediaFile(CMSContext.CurrentSiteName, MediaLibraryID, origDBFilePath, newDBFilePath, false);
break;
case "copy":
MediaFileInfoProvider.CopyMediaFile(CMSContext.CurrentSiteName, MediaLibraryID, origDBFilePath, newDBFilePath, false, CurrentUser.UserID);
break;
}
}
/// <summary>
/// Returns all media files in the media library.
/// </summary>
public IEnumerable <MediaFileInfo> GetMediaFiles(string mediaLibraryName)
{
var mediaLibrary = GetByName(mediaLibraryName);
if (mediaLibrary == null)
{
throw new ArgumentException("Media library not found.", nameof(mediaLibraryName));
}
return(MediaFileInfoProvider.GetMediaFiles()
.WhereEquals("FileLibraryID", mediaLibrary.LibraryID)
.ToList());
}
/// <inheritdoc/>
public IMediaFile UpdateMediaFile(IMediaFile file)
{
MediaFileInfo mediaFileInfo = MediaFileInfoProvider.GetMediaFileInfo(file.FileID);
if (mediaFileInfo == null)
{
return(null);
}
MediaFileInfoProvider.SetMediaFileInfo(mediaFileInfo);
return(mediaFileInfo.ActLike <IMediaFile>());
}
private void MediaLibraryDeleting(object sender, ObjectEventArgs e)
{
if ((e.Object is MediaLibraryInfo mediaLibrary) && _assetSync.IsAtSynchronizedSite(mediaLibrary))
{
var mediaFiles = MediaFileInfoProvider.GetMediaFiles()
.WhereEquals("FileLibraryID", mediaLibrary.LibraryID)
.BinaryData(false)
.TypedResult
.ToList();
RunSynchronization(async() => await _assetSync.DeleteMediaFiles(null, mediaFiles, mediaLibrary.LibraryDisplayName));
}
}
private Guid AddMediaFile(string requestFileName, MediaLibraryInfo library)
{
if (!(Request.Files[requestFileName] is HttpPostedFileWrapper file))
{
return(Guid.Empty);
}
return(ImageUploaderHelper.Upload(file, path =>
{
var mediaFile = new MediaFileInfo(path, library.LibraryID);
MediaFileInfoProvider.SetMediaFileInfo(mediaFile);
return mediaFile.FileGUID;
}));
}
/// <summary>
/// Returns image name, title and description according to image type.
/// </summary>
/// <returns>Image name, title and description</returns>
private void baseImageEditor_GetMetaData()
{
if (mfi == null)
{
mfi = MediaFileInfoProvider.GetMediaFileInfo(mediafileGuid, CurrentSiteName);
}
if (mfi != null)
{
string name = mfi.FileName;
baseImageEditor.GetNameResult = name;
baseImageEditor.GetTitleResult = mfi.FileTitle;
baseImageEditor.GetDescriptionResult = mfi.FileDescription;
}
}
