/// <summary>
/// Gets details of an uploaded file.
/// </summary>
/// <param name="file">Uploaded file contents.</param>
/// <param name="filePath">Path to store the file on the disk.</param>
/// <returns>The file details.</returns>
protected CMS.IO.FileInfo GetFileInfo(HttpPostedFileWrapper file, string filePath)
{
byte[] data = new byte[file.ContentLength];
file.InputStream.Seek(0, SeekOrigin.Begin);
file.InputStream.Read(data, 0, file.ContentLength);
CMS.IO.File.WriteAllBytes(filePath, data);
CMS.IO.FileInfo fileInfo = CMS.IO.FileInfo.New(filePath);
return(fileInfo);
}
public ActionResult Upload(string filePathId, int mediaLibraryId)
{
if (Request.Files[0] is HttpPostedFileWrapper file && file != null)
{
string directoryPath = null;
try
{
directoryPath = FileManagementHelper.EnsureUploadDirectory(TempPath);
}
catch (Exception ex)
{
return(ErrorHelper.HandleException(nameof(MediaLibraryUploaderController), nameof(Upload), ex));
}
if (!string.IsNullOrEmpty(directoryPath))
{
string imagePath = null;
try
{
imagePath = FileManagementHelper.GetTempFilePath(directoryPath, file.FileName);
}
catch (Exception ex)
{
return(ErrorHelper.HandleException(nameof(MediaLibraryUploaderController), nameof(Upload), ex));
}
if (!string.IsNullOrEmpty(imagePath))
{
FileInfo fileInfo = null;
try
{
fileInfo = GetFileInfo(file, imagePath);
}
catch (Exception ex)
{
return(ErrorHelper.HandleException(
nameof(MediaLibraryUploaderController),
nameof(Upload),
ex,
ErrorHelper.UnprocessableStatusCode));
}
if (fileInfo != null)
{
return(CreateMediaFile(filePathId, mediaLibraryId, imagePath, fileInfo));
}
}
}
}
return(new HttpStatusCodeResult(ErrorHelper.UnprocessableStatusCode));
}
protected MediaFileInfo CreateMediafileInfo(int mediaLibraryId, FileInfo fileInfo)
{
var mediaFile = new MediaFileInfo(fileInfo?.FullName, mediaLibraryId)
{
FileName = fileInfo.Name.Substring(0, fileInfo.Name.Length - fileInfo.Extension.Length),
FileExtension = fileInfo.Extension,
FileMimeType = MimeTypeHelper.GetMimetype(fileInfo.Extension),
FileSiteID = SiteContext.CurrentSiteID,
FileLibraryID = mediaLibraryId,
FileSize = fileInfo.Length
};
MediaFileInfoProvider.SetMediaFileInfo(mediaFile);
return(mediaFile);
}
/// <summary>
/// Insert image to Media Library
/// </summary>
/// <param name="productImage"></param>
/// <returns></returns>
public static string UploadImageToMeadiaLibrary(FileUpload productImage, string folderName)
{
string imagePath = string.Empty;
try
{
string folderPath = System.Web.HttpContext.Current.Server.MapPath("~/Uploads/");
if (!Directory.Exists(folderPath))
{
Directory.CreateDirectory(folderPath);
}
string filePath = Path.GetFileName(productImage.PostedFile.FileName);
productImage.PostedFile.SaveAs(System.Web.HttpContext.Current.Server.MapPath("~/Uploads/" + filePath));
MediaLibraryInfo library = MediaLibraryInfoProvider.GetMediaLibraryInfo(!string.IsNullOrEmpty(folderName) ? folderName.Replace(" ", "") : "CampaignProducts", SiteContext.CurrentSiteName);
if (library == null)
{
CreateMeadiaLiabrary(folderName);
library = MediaLibraryInfoProvider.GetMediaLibraryInfo(!string.IsNullOrEmpty(folderName) ? folderName.Replace(" ", "") : "CampaignProducts", SiteContext.CurrentSiteName);
}
filePath = System.Web.HttpContext.Current.Server.MapPath("~/Uploads/" + filePath);
CMS.IO.FileInfo file = CMS.IO.FileInfo.New(filePath);
if (file != null)
{
MediaFileInfo mediaFile = new MediaFileInfo(filePath, library.LibraryID);
mediaFile.FileName = Path.GetFileNameWithoutExtension(productImage.PostedFile.FileName);
mediaFile.FileTitle = Path.GetFileNameWithoutExtension(productImage.PostedFile.FileName);
mediaFile.FilePath = "Images/";
mediaFile.FileExtension = file.Extension;
mediaFile.FileMimeType = MimeTypeHelper.GetMimetype(file.Extension);
mediaFile.FileSiteID = SiteContext.CurrentSiteID;
mediaFile.FileLibraryID = library.LibraryID;
mediaFile.FileSize = file.Length;
MediaFileInfoProvider.SetMediaFileInfo(mediaFile);
File.Delete(filePath);
imagePath = MediaFileURLProvider.GetMediaFileUrl(mediaFile.FileGUID, mediaFile.FileName);
}
}
catch (Exception ex)
{
EventLogProvider.LogException("UploadImage", "UploadImageToMeadiaLibrary", ex, SiteContext.CurrentSite.SiteID, ex.Message);
}
return(imagePath);
}
/// <inheritdoc/>
public IMediaFile CreateMediaFile(int librarySiteID, string libraryName, string localFilePath, string fileName, string fileTitle, string fileDesc, string folder)
{
// Gets the media library
string siteName = SiteInfoProvider.GetSiteName(librarySiteID);
var existingLibrary = MediaLibraryInfoProvider.GetMediaLibraryInfo(libraryName, siteName);
if (existingLibrary != null)
{
// Prepares a CMS.IO.FileInfo object representing the local file
CMS.IO.FileInfo file = CMS.IO.FileInfo.New(localFilePath);
if (file != null)
{
// Creates a new media library file object
MediaFileInfo mediaFile = new MediaFileInfo(localFilePath, existingLibrary.LibraryID)
{
// Sets the media library file properties
FileName = fileName,
FileTitle = fileTitle,
FileDescription = fileDesc,
FilePath = $"{folder}/{fileName}", // Sets the path within the media library's folder structure
FileExtension = file.Extension,
FileMimeType = MimeTypeHelper.GetMimetype(file.Extension),
FileSiteID = librarySiteID,
FileLibraryID = existingLibrary.LibraryID,
FileSize = file.Length,
};
// Saves the media library file
MediaFileInfoProvider.SetMediaFileInfo(mediaFile);
return(mediaFile.ActLike <IMediaFile>());
}
}
return(null);
}
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()
}));
}
