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 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 async Task <IViewComponentResult> InvokeAsync(string folderName, string filterText, MediaSettingKeys mediaSettingKeys)
{
MediaLibraryInfo libraryInfo = new MediaLibraryInfo();
MediaCategory mediaCategory = new MediaCategory(); //Get Username here later
if (string.IsNullOrEmpty(folderName))
{
mediaCategory.BaseCategory = (mediaSettingKeys.MediaReadLocation == MediaReadLocationType.System) ? "" : mediaSettingKeys.FolderName;
}
else
{
mediaCategory.BaseCategory = folderName;
}
MediaSettingController settingController = new MediaSettingController();
if (!string.IsNullOrEmpty(filterText))
{
libraryInfo.MediaCategories = MediaHelper.FileterDirectoryAndFiles(mediaCategory.BaseCategory, filterText);
}
else if (string.IsNullOrEmpty(mediaCategory.BaseCategory))
{
libraryInfo.MediaCategories = MediaHelper.GetMediaCategory(mediaCategory, mediaSettingKeys);
}
else
{
libraryInfo.MediaCategories = MediaHelper.GetMediaCategoryByPath(mediaCategory, mediaSettingKeys);
}
libraryInfo.MediaSettingKeys = mediaSettingKeys;
return(await Task.FromResult((IViewComponentResult)View("Default", libraryInfo)));
}
/// <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);
}
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);
}
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>
/// OnBeforeSave event handler.
/// </summary>
protected void editElem_OnBeforeSave(object sender, EventArgs e)
{
if (editElem.RedirectUrlAfterCreate == null)
{
editElem.RedirectUrlAfterCreate = String.Empty;
}
if (MediaLibraryGroupID > 0)
{
editElem.Data["LibraryGroupID"] = MediaLibraryGroupID;
}
// If creating new group library setup default security
if ((MediaLibraryGroupID > 0) && (MediaLibraryID == 0))
{
// Set default group media library security
MediaLibraryInfo library = (MediaLibraryInfo)editElem.EditedObject;
library.FileCreate = SecurityAccessEnum.GroupMembers;
library.FileDelete = SecurityAccessEnum.Nobody;
library.FileModify = SecurityAccessEnum.Nobody;
library.FolderCreate = SecurityAccessEnum.Nobody;
library.FolderDelete = SecurityAccessEnum.Nobody;
library.FolderModify = SecurityAccessEnum.Nobody;
library.Access = SecurityAccessEnum.GroupMembers;
}
}
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>
/// 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,
});
}
/// <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);
}
/// <summary>
/// Retrieves media files with the .jpg extension from the 'SampleMediaLibrary'.
/// </summary>
public IActionResult ShowMediaFiles()
{
// Gets an instance of the 'SampleMediaLibrary' media library for the current site
MediaLibraryInfo mediaLibrary = mediaLibraryInfoProvider.Get("SampleMediaLibrary", siteService.CurrentSite.SiteID);
// Gets a collection of media files with the .jpg extension from the media library
IEnumerable <MediaFileInfo> mediaLibraryFiles = mediaFileInfoProvider.Get()
.WhereEquals("FileLibraryID", mediaLibrary.LibraryID)
.WhereEquals("FileExtension", ".jpg");
// Prepares a collection of view models containing required data of the media files
IEnumerable <MediaFileViewModel> model = mediaLibraryFiles.Select(
mediaFile => {
IMediaFileUrl fileUrl = mediaFileUrlRetriever.Retrieve(mediaFile);
return(new MediaFileViewModel
{
FileTitle = mediaFile.FileTitle,
// Gets the relative path to the media file
RelativeUrl = fileUrl.RelativePath
});
}
);
// Passes the model to the view
return(View(model));
}
/// <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>
/// Fills editing form with selected library data.
/// </summary>
/// <param name="library">Library info holding data</param>
private void FillForm(MediaLibraryInfo library)
{
txtDisplayName.Text = library.LibraryDisplayName;
txtCodeName.Text = library.LibraryName;
txtDescription.Text = library.LibraryDescription;
txtFolder.Text = library.LibraryFolder;
txtFolder.Enabled = false;
}
private Guid AddMediaFile(IFormFile requestFile, MediaLibraryInfo library)
{
var mediaFile = new MediaFileInfo(requestFile.ToUploadedFile(), library.LibraryID);
MediaFileInfo.Provider.Set(mediaFile);
return(mediaFile.FileGUID);
}
/// <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");
}
}
private void librarySecurity_OnCheckPermissions(string permissionType, CMSAdminControl sender)
{
MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(libraryId);
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "Read"))
{
RedirectToAccessDenied("cms.medialibrary", "Read");
}
}
void librarySecurity_OnCheckPermissions(string permissionType, CMSAdminControl sender)
{
MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(QueryHelper.GetInteger("libraryid", 0));
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "Read"))
{
CMSPage.RedirectToCMSDeskAccessDenied("cms.medialibrary", "Read");
}
}
/// <summary>
/// Deletes media library. Called when the "Delete library" button is pressed.
/// Expects the CreateMediaLibrary method to be run first.
/// </summary>
private bool DeleteMediaLibrary()
{
// Get the media library
MediaLibraryInfo deleteLibrary = MediaLibraryInfoProvider.GetMediaLibraryInfo("MyNewLibrary", SiteContext.CurrentSiteName);
// Delete the media library
MediaLibraryInfoProvider.DeleteMediaLibraryInfo(deleteLibrary);
return(deleteLibrary != 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 value indicating whether the specified media library root folder name is unique.
/// </summary>
/// <param name="folderName">A name of the media library root folder.</param>
private bool IsFolderNameUnique(string folderName)
{
MediaLibraryInfo library = MediaLibraryInfoProvider.GetMediaLibraries()
.TopN(1)
.Column("LibraryID")
.WhereEquals("LibraryFolder", folderName)
.WhereEquals("LibrarySiteID", SiteContext.CurrentSiteID)
.FirstOrDefault();
return((library == null) || (MediaLibraryID == library.LibraryID));
}
/// <summary>
/// Page_Load event handler.
/// </summary>
protected void Page_Load(object sender, EventArgs e)
{
MediaLibraryInfo mli = (MediaLibraryInfo)EditedObject;
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "Read"))
{
RedirectToAccessDenied("cms.medialibrary", "Read");
}
elemEdit.OnCheckPermissions += new CMSAdminControl.CheckPermissionsEventHandler(elemEdit_OnCheckPermissions);
elemEdit.MediaLibraryID = mli.LibraryID;
}
protected void ucMetaFile_OnAfterUpload(object sender, EventArgs e)
{
if (MediaLibraryID > 0)
{
MediaLibraryInfo info = LibraryInfo;
if (info != null)
{
UpdateImagePath(info);
MediaLibraryInfoProvider.SetMediaLibraryInfo(info);
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
MediaLibraryInfo mli = MediaLibraryInfoProvider.GetMediaLibraryInfo(QueryHelper.GetInteger("libraryid", 0));
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(mli, "Read"))
{
RedirectToCMSDeskAccessDenied("cms.medialibrary", "Read");
}
EditedObject = mli;
elemEdit.MediaLibraryID = mli.LibraryID;
elemEdit.OnCheckPermissions += new CMSAdminControl.CheckPermissionsEventHandler(elemEdit_OnCheckPermissions);
}
private void libraryElem_OnCheckPermissions(string permissionType, CMSAdminControl sender)
{
MediaLibraryInfo MediaLibrary = MediaLibraryInfoProvider.GetMediaLibraryInfo(libraryId);
if (permissionType.ToLowerCSafe() == "read")
{
// Check 'Read' permission
if (!MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(MediaLibrary, permissionType))
{
RedirectToAccessDenied("cms.medialibrary", "Read");
}
}
}
protected void ucMetaFile_OnAfterDelete(object sender, EventArgs e)
{
if (MediaLibraryID > 0)
{
MediaLibraryInfo info = LibraryInfo;
if (info != null)
{
//info.LibraryTeaserPath = String.Empty;
//info.LibraryTeaserGuid = Guid.Empty;
UpdateImagePath(info);
MediaLibraryInfoProvider.SetMediaLibraryInfo(info);
}
}
}
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);
MediaFileInfo.Provider.Set(mediaFile);
return mediaFile.FileGUID;
}));
}
/// <summary>
/// Retrieves media files with the .jpg extension from the 'SampleMediaLibrary'.
/// </summary>
public ActionResult ShowMediaFiles()
{
//DocSection:GetMediaFiles
// Creates an instance of the 'SampleMediaLibrary' media library for the current site
MediaLibraryInfo mediaLibrary = MediaLibraryInfoProvider.GetMediaLibraryInfo("SampleMediaLibrary", SiteContext.CurrentSiteName);
// Gets a collection of media files with the .jpg extension from the media library
IEnumerable <MediaFileInfo> mediaLibraryFiles = MediaFileInfoProvider.GetMediaFiles()
.WhereEquals("FileLibraryID", mediaLibrary.LibraryID)
.WhereEquals("FileExtension", ".jpg");
//EndDocSection:GetMediaFiles
return(View(mediaLibraryFiles));
}
/// <summary>
/// Initializes the breadcrumbs controls.
/// </summary>
private void InitializeBreadcrumbs()
{
if (LibraryID > 0)
{
MediaLibraryInfo library = MediaLibraryInfoProvider.GetMediaLibraryInfo(LibraryID);
if (library != null)
{
lblEditBack.Text = " <span class=\"TitleBreadCrumbSeparator\"> </span> " + HTMLHelper.HTMLEncode(library.LibraryDisplayName);
}
}
else
{
lblEditBack.Text = " <span class=\"TitleBreadCrumbSeparator\"> </span> " + GetString("Group_General.MediaLibrary.NewLibrary");
}
}
/// <summary>
/// Deletes media folder. Called when the "Delete folder" button is pressed.
/// Expects the CreateMediaFolder method to be run first.
/// </summary>
private bool DeleteMediaFolder()
{
// Get media library
MediaLibraryInfo library = MediaLibraryInfoProvider.GetMediaLibraryInfo("MyNewLibrary", SiteContext.CurrentSiteName);
if (library != null)
{
// Delete new media folder object
MediaLibraryInfoProvider.DeleteMediaLibraryFolder(CurrentSiteName, library.LibraryID, "MyNewFolder", false);
return(true);
}
return(false);
}
/// <summary>
/// Creates group media library.
/// </summary>
/// <param name="group">Particular group info object</param>
private void CreateGroupMediaLibrary(GroupInfo group)
{
// Set general values
string codeName = "Library_group_" + group.GroupGUID;
// Check if library with same name already exists
MediaLibraryInfo mlInfo = MediaLibraryInfoProvider.GetMediaLibraryInfo(codeName, SiteContext.CurrentSiteID, group.GroupID);
if (mlInfo == null)
{
// Create new object (record) if needed
mlInfo = new MediaLibraryInfo();
const string suffix = " media";
mlInfo.LibraryDisplayName = TextHelper.LimitLength(@group.GroupDisplayName, 200 - suffix.Length, string.Empty) + suffix;
mlInfo.LibraryFolder = @group.GroupName;
mlInfo.LibraryName = codeName;
mlInfo.LibraryDescription = string.Empty;
mlInfo.LibraryGroupID = @group.GroupID;
mlInfo.LibrarySiteID = SiteContext.CurrentSiteID;
// Set security
mlInfo.FileCreate = SecurityAccessEnum.GroupMembers;
mlInfo.FileDelete = SecurityAccessEnum.GroupMembers;
mlInfo.FileModify = SecurityAccessEnum.GroupMembers;
mlInfo.FolderCreate = SecurityAccessEnum.GroupMembers;
mlInfo.FolderDelete = SecurityAccessEnum.GroupMembers;
mlInfo.FolderModify = SecurityAccessEnum.GroupMembers;
mlInfo.Access = SecurityAccessEnum.GroupMembers;
try
{
MediaLibraryInfoProvider.SetMediaLibraryInfo(mlInfo);
}
catch
{
}
// Create additional folders
//MediaLibraryInfoProvider.CreateMediaLibraryFolder(SiteContext.CurrentSiteName, mlInfo.LibraryID, "Videos", false);
//MediaLibraryInfoProvider.CreateMediaLibraryFolder(SiteContext.CurrentSiteName, mlInfo.LibraryID, "Other", false);
//MediaLibraryInfoProvider.CreateMediaLibraryFolder(SiteContext.CurrentSiteName, mlInfo.LibraryID, "Photos & Images", false);
}
}
/// <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>
/// Creates media library. Called when the "Create library" button is pressed.
/// </summary>
private bool CreateMediaLibrary()
{
// Create new media library object
MediaLibraryInfo newLibrary = new MediaLibraryInfo();
// Set the properties
newLibrary.LibraryDisplayName = "My new library";
newLibrary.LibraryName = "MyNewLibrary";
newLibrary.LibraryDescription = "My new library description";
newLibrary.LibraryFolder = "MyNewLibrary";
newLibrary.LibrarySiteID = CMSContext.CurrentSiteID;
newLibrary.LibraryGUID = Guid.NewGuid();
newLibrary.LibraryLastModified = DateTime.Now;
// Create the media library
MediaLibraryInfoProvider.SetMediaLibraryInfo(newLibrary);
return true;
}
/// <summary>
/// Creates department media library.
/// </summary>
/// <param name="departmentNode">Department node</param>
private void CreateDepartmentMediaLibrary(TreeNode departmentNode)
{
// Set general values
string departmentName = departmentNode.DocumentName;
string codeName = "Department_" + departmentNode.NodeGUID;
string suffix = "";
// Check if library with same name already exists
MediaLibraryInfo mlInfo = MediaLibraryInfoProvider.GetMediaLibraryInfo(codeName, CMSContext.CurrentSiteName);
if (mlInfo != null)
{
return;
}
// Create new object (record) if needed
mlInfo = new MediaLibraryInfo();
suffix = " media library";
mlInfo.LibraryDisplayName = TextHelper.LimitLength(departmentName, 200 - suffix.Length, "") + suffix;
mlInfo.LibraryFolder = departmentNode.NodeAlias;
mlInfo.LibraryDescription = "Media library for " + departmentName + " department.";
mlInfo.LibraryName = codeName;
mlInfo.LibrarySiteID = CMSContext.CurrentSiteID;
// Set security
mlInfo.FileCreate = SecurityAccessEnum.AuthorizedRoles;
mlInfo.FileDelete = SecurityAccessEnum.AuthorizedRoles;
mlInfo.FileModify = SecurityAccessEnum.AuthorizedRoles;
mlInfo.FolderCreate = SecurityAccessEnum.AuthorizedRoles;
mlInfo.FolderDelete = SecurityAccessEnum.AuthorizedRoles;
mlInfo.FolderModify = SecurityAccessEnum.AuthorizedRoles;
mlInfo.Access = SecurityAccessEnum.AuthorizedRoles;
try
{
MediaLibraryInfoProvider.SetMediaLibraryInfo(mlInfo);
}
catch
{
return;
}
// Create additional folders
//MediaLibraryInfoProvider.CreateMediaLibraryFolder(CMSContext.CurrentSiteName, mlInfo.LibraryID, "Videos", false);
//MediaLibraryInfoProvider.CreateMediaLibraryFolder(CMSContext.CurrentSiteName, mlInfo.LibraryID, "Other", false);
//MediaLibraryInfoProvider.CreateMediaLibraryFolder(CMSContext.CurrentSiteName, mlInfo.LibraryID, "Photos & Images", false);
}
/// <summary>
/// Updates metafile image path.
/// </summary>
private void UpdateImagePath(MediaLibraryInfo mli)
{
// Update image path according to its meta file
DataSet ds = MetaFileInfoProvider.GetMetaFiles(ucMetaFile.ObjectID, mli.TypeInfo.ObjectType);
if (!DataHelper.DataSourceIsEmpty(ds))
{
MetaFileInfo metaFile = new MetaFileInfo(ds.Tables[0].Rows[0]);
mli.LibraryTeaserPath = MetaFileInfoProvider.GetMetaFileUrl(metaFile.MetaFileGUID, metaFile.MetaFileName);
}
else
{
mli.LibraryTeaserPath = "";
}
}
protected void btnOK_Click(object sender, EventArgs e)
{
bool isAuthorized = false;
// Check 'Manage' permission for user
if (this.LibraryInfo != null)
{
isAuthorized = MediaLibraryInfoProvider.IsUserAuthorizedPerLibrary(this.LibraryInfo, "Manage");
}
else
{
if (CMSContext.CurrentUser.IsAuthorizedPerResource("CMS.MediaLibrary", "Manage"))
{
isAuthorized = true;
}
else
{
if ((this.MediaLibraryGroupID > 0) && (CMSContext.CurrentUser.IsGroupAdministrator(this.MediaLibraryGroupID)))
{
isAuthorized = true;
}
}
}
// If user isn't authorized let her now
if (!isAuthorized)
{
lblError.Text = MediaLibraryHelper.GetAccessDeniedMessage("Manage");
lblError.Visible = true;
return;
}
string codeName = txtCodeName.Text;
if (DisplayMode == ControlDisplayModeEnum.Simple)
{
if (this.MediaLibraryID == 0)
{
codeName = ValidationHelper.GetCodeName(txtDisplayName.Text, null, "_group_" + Guid.NewGuid());
}
else
{
codeName = this.LibraryInfo.LibraryName;
}
}
codeName = codeName.Trim();
// Validate input boxes
if (!ValidateForm(codeName))
{
return;
}
// Create new object (record) if needed
MediaLibraryInfo mli = null;
if (this.MediaLibraryID > 0)
{
mli = this.LibraryInfo;
}
else
{
mli = new MediaLibraryInfo();
}
mli.LibraryDisplayName = txtDisplayName.Text;
if (txtFolder.Enabled)
{
mli.LibraryFolder = txtFolder.Text;
}
mli.LibraryDescription = txtDescription.Text;
mli.LibraryName = codeName;
// If the library is group related
if (this.MediaLibraryGroupID > 0)
{
mli.LibraryGroupID = this.MediaLibraryGroupID;
// If creating new group library setup default security
if (this.MediaLibraryID == 0)
{
// Set default group media library security
mli.FileCreate = SecurityAccessEnum.GroupMembers;
mli.FileDelete = SecurityAccessEnum.Nobody;
mli.FileModify = SecurityAccessEnum.Nobody;
mli.FolderCreate = SecurityAccessEnum.Nobody;
mli.FolderDelete = SecurityAccessEnum.Nobody;
mli.FolderModify = SecurityAccessEnum.Nobody;
mli.Access = SecurityAccessEnum.GroupMembers;
}
}
mli.LibrarySiteID = CMSContext.CurrentSiteID;
try
{
MediaLibraryInfoProvider.SetMediaLibraryInfo(mli);
}
catch (Exception ex)
{
lblError.Text = ex.Message;
lblError.Visible = true;
return;
}
if ((mli != null) && (mli.LibraryID != 0))
{
// Add teaser image to media library
ucMetaFile.ObjectID = mli.LibraryID;
ucMetaFile.UploadFile();
UpdateImagePath(mli);
try
{
MediaLibraryInfoProvider.SetMediaLibraryInfo(mli);
}
catch (Exception ex)
{
lblError.Text = ex.Message;
lblError.Visible = true;
return;
}
// Update current media library id
this.MediaLibraryID = mli.LibraryID;
lblInfo.Visible = true;
lblInfo.Text = GetString("general.changessaved");
FillForm(mli);
this.RaiseOnSaved();
}
// Reload header if changes were saved
ScriptHelper.RefreshTabHeader(Page, GetString("general.general"));
}
/// <summary>
/// Fills editing form with selected library data.
/// </summary>
/// <param name="library">Library info holding data</param>
private void FillForm(MediaLibraryInfo library)
{
txtDisplayName.Text = library.LibraryDisplayName;
txtCodeName.Text = library.LibraryName;
txtDescription.Text = library.LibraryDescription;
txtFolder.Text = library.LibraryFolder;
txtFolder.Enabled = false;
}
/// <summary>
/// Updates metafile image path.
/// </summary>
private void UpdateImagePath(MediaLibraryInfo mli)
{
// Update image path according to its meta file
DataSet ds = MetaFileInfoProvider.GetMetaFiles(ucMetaFile.ObjectID, mli.TypeInfo.ObjectType, MetaFileInfoProvider.OBJECT_CATEGORY_THUMBNAIL, null, null);
if (!DataHelper.DataSourceIsEmpty(ds))
{
MetaFileInfo metaFile = new MetaFileInfo(ds.Tables[0].Rows[0]);
mli.LibraryTeaserGuid = metaFile.MetaFileGUID;
mli.LibraryTeaserPath = MetaFileInfoProvider.GetMetaFileUrl(metaFile.MetaFileGUID, metaFile.MetaFileName);
}
else
{
mli.LibraryTeaserGuid = Guid.Empty;
mli.LibraryTeaserPath = String.Empty;
}
}
/// <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;
}
