/// <summary>
/// Initializes all the nested controls.
/// </summary>
private void SetupControls()
{
// Get media library info
if (LibraryInfo != null)
{
ucMetaFile.ObjectID = LibraryInfo.LibraryID;
ucMetaFile.SiteID = LibraryInfo.LibrarySiteID;
txtFolder.Enabled = false;
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(LibraryInfo, PERMISSION_MANAGE))
{
// Disable MetaFile uploader
ucMetaFile.Enabled = false;
}
}
else
{
ucMetaFile.ObjectID = 0;
txtFolder.Enabled = true;
}
ucMetaFile.ObjectType = MediaLibraryObjectType.MEDIALIBRARY;
ucMetaFile.Category = MetaFileInfoProvider.OBJECT_CATEGORY_THUMBNAIL;
ucMetaFile.OnAfterDelete += ucMetaFile_OnAfterDelete;
ucMetaFile.OnAfterUpload += ucMetaFile_OnAfterUpload;
ucMetaFile.ReloadData();
}
/// <summary>
/// Gets and bulk updates media libraries. Called when the "Get and bulk update libraries" button is pressed.
/// Expects the CreateMediaLibrary method to be run first.
/// </summary>
private bool GetAndBulkUpdateMediaLibraries()
{
// Prepare the parameters
string where = "LibraryName LIKE 'MyNew%'";
// Get the data
DataSet libraries = MediaLibraryInfoProvider.GetMediaLibraries(where, null);
if (!DataHelper.DataSourceIsEmpty(libraries))
{
// Loop through the individual items
foreach (DataRow libraryDr in libraries.Tables[0].Rows)
{
// Create object from DataRow
MediaLibraryInfo modifyLibrary = new MediaLibraryInfo(libraryDr);
// Update the property
modifyLibrary.LibraryDisplayName = modifyLibrary.LibraryDisplayName.ToUpper();
// Update the media library
MediaLibraryInfoProvider.SetMediaLibraryInfo(modifyLibrary);
}
return(true);
}
return(false);
}
/// <summary>
/// Handle all the necessary actions performed while file info is imported into the DB.
/// </summary>
/// <param name="importAll">Indicates whether the all files should be imported at once</param>
private void HandleFileImport(bool importAll)
{
// Check 'File create' permission
if (MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(LibraryInfo, "filecreate"))
{
// Get set of file paths
if (!string.IsNullOrEmpty(ImportFilePaths))
{
// Import single file
if (importAll)
{
// Import all files
HandleMultipleMediaFiles();
}
else
{
HandleSingleMediaFile();
}
}
else
{
// Inform user on error
RaiseOnAction("importnofiles", null);
}
}
else
{
RaiseOnAction("importerror", MediaLibraryHelper.GetAccessDeniedMessage("filecreate"));
}
}
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);
}
}
protected void Page_Load(object sender, EventArgs e)
{
// Get the media library ID
libraryId = QueryHelper.GetInteger("libraryId", 0);
// Get library info
MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(libraryId);
if (mli != null)
{
InitalizeMenu();
// Initialize the page title
string[,] breadcrumbs = new string[2, 3];
breadcrumbs[0, 0] = GetString("media.header.itemlistlink");
breadcrumbs[0, 1] = "~/CMSModules/MediaLibrary/Tools/Library_List.aspx";
breadcrumbs[0, 2] = "_parent";
breadcrumbs[1, 0] = mli.LibraryDisplayName;
breadcrumbs[1, 1] = "";
breadcrumbs[1, 2] = "";
this.CurrentMaster.Title.TitleText = GetString("media.header.headercaption");
this.CurrentMaster.Title.TitleImage = ResolveUrl(GetImageUrl("Objects/Media_Library/object.png"));
this.CurrentMaster.Title.Breadcrumbs = breadcrumbs;
this.CurrentMaster.Title.HelpTopicName = "library_files";
this.CurrentMaster.Title.HelpName = "helpTopic";
this.CurrentMaster.BodyClass += " MediaLibrary LightTabs";
}
}
public JsonResult Upload(string libraryName)
{
var dataContext = dataContextRetriever.Retrieve();
if (!dataContext.EditMode)
{
throw new HttpException(403, "It is allowed to upload an image only when the page builder is in the edit mode.");
}
var library = MediaLibraryInfo.Provider.Get(libraryName, SiteContext.CurrentSiteID);
if (library == null)
{
throw new InvalidOperationException($"The '{libraryName}' media library doesn't exist.");
}
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(library, "FileCreate", MembershipContext.AuthenticatedUser))
{
throw new HttpException(403, "You are not authorized to upload an image to the media library.");
}
var imageGuid = Guid.Empty;
foreach (string requestFileName in Request.Files)
{
imageGuid = AddMediaFile(requestFileName, library);
}
return(Json(new { guid = imageGuid }));
}
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);
}
/// <summary>
/// Reloads the data in the selector.
/// </summary>
public void ReloadData(bool forceReload)
{
string where = GetWhereConditionInternal();
uniSelector.IsLiveSite = IsLiveSite;
uniSelector.ReturnColumnName = (UseLibraryNameForSelection ? "LibraryName" : "LibraryID");
uniSelector.WhereCondition = where;
uniSelector.OnSelectionChanged += uniSelector_OnSelectionChanged;
uniSelector.DropDownSingleSelect.AutoPostBack = UseAutoPostBack;
bool noLibrary = DataHelper.DataSourceIsEmpty(MediaLibraryInfoProvider.GetMediaLibraries(where, null, 1, "LibraryID"));
// Insert '(none)' record if no library exists - only if '(none)' isn't inserted by default
uniSelector.AllowEmpty = (noLibrary && NoneWhenEmpty);
if (!uniSelector.AllowEmpty && AddCurrentLibraryRecord)
{
uniSelector.SpecialFields.Add(new SpecialField {
Text = GetString("media.current"), Value = MediaLibraryInfoProvider.CURRENT_LIBRARY
});
}
else
{
uniSelector.SpecialFields = null;
}
if (forceReload)
{
uniSelector.Reload(true);
}
}
/// <summary>
/// Adds role permission to media library. Called when the "Add role permission to library " button is pressed.
/// Expects the CreateMediaLibrary method to be run first.
/// </summary>
private bool AddRolePermissionToLibrary()
{
// Get the media library
MediaLibraryInfo mediaLibrary = MediaLibraryInfoProvider.GetMediaLibraryInfo("MyNewLibrary", SiteContext.CurrentSiteName);
// Get the role
RoleInfo libraryRole = RoleInfoProvider.GetRoleInfo("CMSDeskAdmin", SiteContext.CurrentSiteID);
// Get the permission
PermissionNameInfo libraryPermission = PermissionNameInfoProvider.GetPermissionNameInfo("FileCreate", "CMS.MediaLibrary", null);
if ((mediaLibrary != null) && (libraryRole != null) && (libraryPermission != null))
{
// Create a new media library role permision info
MediaLibraryRolePermissionInfo rolePermission = new MediaLibraryRolePermissionInfo();
// Set the values
rolePermission.LibraryID = mediaLibrary.LibraryID;
rolePermission.RoleID = libraryRole.RoleID;
rolePermission.PermissionID = libraryPermission.PermissionId;
// Add role permission to media library
MediaLibraryRolePermissionInfoProvider.SetMediaLibraryRolePermissionInfo(rolePermission);
return(true);
}
return(false);
}
protected void Page_Load(object sender, EventArgs e)
{
RaiseOnCheckPermissions(PERMISSION_READ, this);
MediaLibraryInfo libInfo = MediaLibraryInfoProvider.GetMediaLibraryInfo(LibraryID);
EditedObject = libInfo;
if (libInfo != null)
{
// Set the request timeout
Server.ScriptTimeout = AttachmentHelper.ScriptTimeout;
// Register script handling repeated media file creation
ltlPostBackScript.Text = ScriptHelper.GetScript("function LocalSaveAnother() {" + Page.ClientScript.GetPostBackEventReference(this, null) + "}"
+ " function SaveDocument(nodeId, createAnother){ if ( !createAnother ) { LocalSave(createAnother) } else { LocalSaveAnother() } }");
}
else
{
pnlMenu.Visible = false;
pnlForm.Visible = false;
lblError.Visible = true;
lblError.Text = GetString("media.newfile.librarynotexists");
}
// Register wopener script
ScriptHelper.RegisterWOpenerScript(Page);
}
/// <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>
/// Reload controls data.
/// </summary>
/// <param name="forceReload">Indicates if controls </param>
public override void ReloadData(bool forceReload)
{
// Check media file permissions
MediaLibraryInfo mli = (MediaLibraryInfo)MediaLibraryInfo;
// Check authorization to filemodify or manage
if ((mli != null) && ((MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "filemodify", CMSContext.CurrentUser) ||
MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "manage", CMSContext.CurrentUser)) || !CheckPermission))
{
Enabled = true;
// Check if module 'Community' is loaded
if (mli.LibraryGroupID > 0)
{
// Check 'GroupAdministrator' permission
Enabled = (GroupInfo != null) && CMSContext.CurrentUser.IsGroupAdministrator(mli.LibraryGroupID);
}
}
else
{
Enabled = false;
}
base.ReloadData(forceReload);
}
protected void Page_Load(object sender, EventArgs e)
{
// Get the media library ID
libraryId = QueryHelper.GetInteger("libraryId", 0);
groupId = QueryHelper.GetInteger("groupid", 0);
// Get library info
MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(libraryId);
if (mli != null)
{
InitalizeMenu();
// Initialize the page title
string[,] breadcrumbs = new string[2, 3];
breadcrumbs[0, 0] = GetString("media.header.itemlistlink");
breadcrumbs[0, 1] = "~/CMSModules/Groups/Tools/MediaLibrary/Library_List.aspx?groupid=" + groupId;
breadcrumbs[0, 2] = "_parent";
breadcrumbs[1, 0] = mli.LibraryDisplayName;
breadcrumbs[1, 1] = "";
breadcrumbs[1, 2] = "";
CurrentMaster.Title.Breadcrumbs = breadcrumbs;
CurrentMaster.Title.HelpTopicName = "library_files";
CurrentMaster.Title.HelpName = "helpTopic";
}
}
/// <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);
}
/// <summary>
/// Initializes the breadcrumbs controls.
/// </summary>
private void InitializeBreadcrumbs()
{
ucBreadcrumbs.Items.Clear();
ucBreadcrumbs.AddBreadcrumb(new BreadcrumbItem
{
Text = GetString("Group_General.MediaLibrary.BackToList"),
OnClientClick = ControlsHelper.GetPostBackEventReference(lnkBackHidden) + "; return false;"
});
string itemText = "";
if (LibraryID > 0)
{
MediaLibraryInfo library = MediaLibraryInfoProvider.GetMediaLibraryInfo(LibraryID);
if (library != null)
{
itemText = HTMLHelper.HTMLEncode(library.LibraryDisplayName);
}
}
else
{
itemText = GetString("Group_General.MediaLibrary.NewLibrary");
}
ucBreadcrumbs.AddBreadcrumb(new BreadcrumbItem {
Text = itemText,
});
}
string GetImageUrlFromMediaLibrary(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();
}
}
}
}
//get url
string url = MediaFileURLProvider.GetMediaFileUrl(imageGuid, fileName);
return(url);
}
/// <summary>
/// Reloads the data in the selector.
/// </summary>
public void ReloadData(bool forceReload)
{
uniSelector.IsLiveSite = IsLiveSite;
uniSelector.ReturnColumnName = (UseLibraryNameForSelection ? "LibraryName" : "LibraryID");
uniSelector.WhereCondition = GetCompleteWhereCondition();
uniSelector.OnSelectionChanged += uniSelector_OnSelectionChanged;
uniSelector.DropDownSingleSelect.AutoPostBack = UseAutoPostBack;
bool noLibrary = MediaLibraryInfoProvider.GetMediaLibraries()
.Where(GetGroupsWhereCondition())
.Count == 0;
// Empty value '(none)' is allowed when it is allowed from outside (property 'AllowEmpty') or no libraries was found and flag 'NoneWhenEmpty' is set
uniSelector.AllowEmpty |= (noLibrary && NoneWhenEmpty);
if (AddCurrentLibraryRecord)
{
uniSelector.SpecialFields.Add(new SpecialField {
Text = GetString("media.current"), Value = MediaLibraryInfoProvider.CURRENT_LIBRARY
});
}
if (forceReload)
{
uniSelector.Reload(true);
}
}
public static MediaLibraryInfo GetCachedMediaLibriaryInfo(String name)
{
var mediaLibraryInfo = CacheHelper.Cache(cs =>
{
try
{
var lib = MediaLibraryInfoProvider.GetMediaLibraryInfo(name, SiteContext.CurrentSiteName);
if (cs.Cached)
{
cs.CacheDependency = CacheHelper.GetCacheDependency("media.library|byguid|" + lib.LibraryGUID);
}
return(lib);
}
catch (Exception ex)
{
EventLogProvider.LogException("GetCachedMediaLibriaryInfo", EventType.INFORMATION, ex, SiteContext.CurrentSiteID, "Unabled to get media library: " + name);
}
return(null);
}, new CacheSettings(DefaultCacheMinutes, "custom|getcachedmedialibrary|" + name));
return(mediaLibraryInfo);
}
protected override void CreateChildControls()
{
// Hide the control if there is no MediaLibrary
if (MediaLibrary == null)
{
hidden = true;
Visible = false;
StopProcessing = true;
return;
}
if (StopProcessing)
{
folderTree.StopProcessing = true;
fileDataSource.StopProcessing = true;
UniPagerControl.PageControl = null;
}
else
{
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(MediaLibrary, "Read"))
{
// Check 'Media gallery access' permission
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(MediaLibrary, "libraryaccess"))
{
RaiseOnNotAllowed("libraryaccess");
return;
}
}
base.CreateChildControls();
InitializeInnerControls();
}
}
private void gridElem_OnAction(string actionName, object actionArgument)
{
switch (actionName.ToLowerCSafe())
{
case "edit":
SelectedItemID = ValidationHelper.GetInteger(actionArgument, 0);
RaiseOnEdit();
break;
case "delete":
MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(ValidationHelper.GetInteger(actionArgument, 0));
// Check 'Manage' permission
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, PERMISSION_MANAGE))
{
ShowError(MediaLibraryHelper.GetAccessDeniedMessage(PERMISSION_MANAGE));
return;
}
try
{
MediaLibraryInfoProvider.DeleteMediaLibraryInfo(ValidationHelper.GetInteger(actionArgument, 0));
}
catch (Exception ex)
{
EventLogProvider.LogException("Media library", "DELETEOBJ", ex, SiteContext.CurrentSiteID);
ShowError(ex.Message, EventLogProvider.GetExceptionLogMessage(ex), null);
}
break;
}
RaiseOnAction(actionName, actionArgument);
}
/// <summary>
/// Validates form entries.
/// </summary>
/// <param name="action">Action type</param>
/// <param name="siteName">Site name</param>
public string ValidateForm(string action, string siteName)
{
string newFolderName = txtFolderName.Text.Trim();
string errMsg = new Validator().NotEmpty(newFolderName, GetString("media.error.FolderNameIsEmpty")).
IsFolderName(newFolderName, GetString("media.error.FolderNameIsNotValid")).Result;
if (String.IsNullOrEmpty(errMsg))
{
// Check special folder names
if ((newFolderName == ".") || (newFolderName == ".."))
{
errMsg = GetString("media.error.FolderNameIsRelative");
}
if (String.IsNullOrEmpty(errMsg))
{
// Make a note that we are renaming existing folder
bool mustExist = String.IsNullOrEmpty(Action) || (Action.ToLowerCSafe().Trim() != "new");
// Check if folder with specified name exists already if required
if (mustExist)
{
// Existing folder is being renamed
if (!Directory.Exists(MediaLibraryInfoProvider.GetMediaLibraryFolderPath(siteName, DirectoryHelper.CombinePath(LibraryFolder, FolderPath))))
{
errMsg = GetString("media.error.FolderDoesNotExist");
}
}
if (String.IsNullOrEmpty(errMsg))
{
string hiddenFolderName = MediaLibraryHelper.GetMediaFileHiddenFolder(siteName);
// Check if folder name is not reserved
if (string.Equals(hiddenFolderName, newFolderName, StringComparison.InvariantCultureIgnoreCase) || ValidationHelper.IsSpecialFolderName(newFolderName))
{
errMsg = String.Format(GetString("media.error.FolderNameIsReserved"), newFolderName);
}
if (String.IsNullOrEmpty(errMsg))
{
// Get new folder path
GetNewFolderPath(mustExist);
if (Path.EnsureForwardSlashes(FolderPath) != Path.EnsureForwardSlashes(mNewFolderPath))
{
// Check if new folder doesn't exist yet
if (Directory.Exists(MediaLibraryInfoProvider.GetMediaLibraryFolderPath(siteName, DirectoryHelper.CombinePath(LibraryFolder, mNewFolderPath))))
{
errMsg = GetString("media.error.FolderExists");
}
}
}
}
}
}
return(errMsg);
}
/// <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>
/// Checks if the folder structure contains specified folder.
/// </summary>
/// <param name="path">Path of the folder to check</param>
public bool FolderExists(string path)
{
string libFolderPath = MediaLibraryInfoProvider.GetMediaLibraryFolderPath(MediaLibraryID);
libFolderPath = DirectoryHelper.CombinePath(libFolderPath, path);
return(Directory.Exists(libFolderPath));
}
private bool innermedia_GetModifyPermission(IDataContainer data)
{
if (mHasModify == null)
{
mHasModify = LibraryInfo != null?MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(LibraryInfo, "filemodify") : false;
}
return(mHasModify == true ? true : false);
}
protected void Page_Load(object sender, EventArgs e)
{
RaiseOnCheckPermissions(PERMISSION_READ, this);
if (!Visible)
{
EnableViewState = false;
}
if (MediaLibraryID > 0)
{
// Get information on current library
permissionArray.Add("filecreate");
permissionArray.Add("foldercreate");
permissionArray.Add("filedelete");
permissionArray.Add("folderdelete");
permissionArray.Add("filemodify");
permissionArray.Add("foldermodify");
permissionArray.Add("libraryaccess");
if ((ResLibrary != null) && (LibraryInfo != null))
{
// Retrieve permission matrix data
QueryDataParameters parameters = new QueryDataParameters();
parameters.Add("@ID", ResLibrary.ResourceID);
parameters.Add("@LibraryID", MediaLibraryID);
parameters.Add("@SiteID", LibraryInfo.LibrarySiteID);
// Exclude generic roles from matrix
string where = "(RoleName NOT IN ('_authenticated_', '_everyone_', '_notauthenticated_'))";
if (permissionArray != null)
{
where += " AND PermissionName IN (";
foreach (string permission in permissionArray)
{
where += "'" + permission + "',";
}
where = where.TrimEnd(',');
where += ") ";
}
// Setup matrix control
gridMatrix.QueryParameters = parameters;
gridMatrix.WhereCondition = where;
gridMatrix.CssClass = "permission-matrix";
gridMatrix.OnItemChanged += gridMatrix_OnItemChanged;
// Check 'Modify' permission
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(LibraryInfo, "manage"))
{
Enable = false;
gridMatrix.Enabled = false;
ShowError(String.Format(GetString("general.accessdeniedonpermissionname"), "Manage"));
}
}
}
}
public void RaisePostBackEvent(string eventArgument)
{
// Check 'Modify' permission
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(LibraryInfo, "manage"))
{
return;
}
string[] args = eventArgument.Split('|');
if (args.Length == 2)
{
// Get info on currently selected item
int permission = Convert.ToInt32(args[0]);
int access = Convert.ToInt32(args[1]);
if (LibraryInfo != null)
{
// Update library permission access information
switch (permission)
{
case 0:
LibraryInfo.FileCreate = ((SecurityAccessEnum)access);
break;
case 2:
LibraryInfo.FileDelete = (SecurityAccessEnum)access;
break;
case 4:
LibraryInfo.FileModify = ((SecurityAccessEnum)access);
break;
case 1:
LibraryInfo.FolderCreate = (SecurityAccessEnum)access;
break;
case 3:
LibraryInfo.FolderDelete = (SecurityAccessEnum)access;
break;
case 5:
LibraryInfo.FolderModify = (SecurityAccessEnum)access;
break;
case 6:
LibraryInfo.Access = (SecurityAccessEnum)access;
break;
default:
break;
}
// Save changes to the library
MediaLibraryInfoProvider.SetMediaLibraryInfo(LibraryInfo);
}
}
}
/// <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);
}
/// <summary>
/// OnCheckPermissions event handler.
/// </summary>
private void elemEdit_OnCheckPermissions(string permissionType, CMSAdminControl sender)
{
MediaLibraryInfo mli = (MediaLibraryInfo)EditedObject;
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "Read"))
{
RedirectToAccessDenied("cms.medialibrary", "Read");
}
}
/// <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));
}
}
}
private void librarySecurity_OnCheckPermissions(string permissionType, CMSAdminControl sender)
{
MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(libraryId);
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "Read"))
{
RedirectToAccessDenied("cms.medialibrary", "Read");
}
}
