public HttpResponseMessage GetFileDetails(int fileId)
{
var file = FileManager.Instance.GetFile(fileId);
if (file == null)
{
return(this.Request.CreateResponse(HttpStatusCode.NotFound, new { }));
}
var folder = FolderManager.Instance.GetFolder(file.FolderId);
if (!FolderPermissionController.CanViewFolder((FolderInfo)folder))
{
return(this.Request.CreateResponse(
HttpStatusCode.InternalServerError,
new { message = LocalizationHelper.GetString("UserHasNoPermissionToReadFileProperties.Error") }));
}
var createdBy = file.CreatedByUser(this.PortalSettings.PortalId);
var lastModifiedBy = file.LastModifiedByUser(this.PortalSettings.PortalId);
return(this.Request.CreateResponse(HttpStatusCode.OK, new
{
fileId = file.FileId,
fileName = file.FileName,
title = file.Title,
description = file.Description ?? string.Empty,
size = string.Format(new FileSizeFormatProvider(), "{0:fs}", file.Size),
createdOnDate = file.CreatedOnDate.ToShortDateString(),
createdBy = createdBy != null ? createdBy.Username : string.Empty,
lastModifiedOnDate = file.LastModifiedOnDate.ToShortDateString(),
lastModifiedBy = lastModifiedBy != null ? lastModifiedBy.Username : string.Empty,
url = FileManager.Instance.GetUrl(file),
}));
}
bool CanView(string url)
{
switch (Globals.GetURLType(url))
{
case TabType.File:
if (url.IndexOf("fileid=", StringComparison.InvariantCultureIgnoreCase) >= 0)
{
var file = FileManager.Instance.GetFile(int.Parse(url.Split('=') [1]));
if (file != null)
{
var folder = FolderManager.Instance.GetFolder(file.FolderId);
if (folder != null && FolderPermissionController.CanViewFolder((FolderInfo)folder))
{
return(true);
}
}
}
break;
case TabType.Tab:
var tab = TabController.Instance.GetTab(int.Parse(url), PortalId);
if (tab != null && TabPermissionController.CanViewPage(tab))
{
return(true);
}
break;
default:
return(true);
}
return(false);
}
private string Check_CanDeleteFolder(string virtualPath, bool isFileCheck, bool logDetail)
{
var dnnFolder = GetDNNFolder(virtualPath);
if (dnnFolder == null)
{
return(LogDetailError(ErrorCodes.FolderDoesNotExist, virtualPath, logDetail));
}
//skip additional folder checks when it is a file
if (!isFileCheck)
{
//Don't allow delete of root folder, root is a protected folder, but show a special message
if (dnnFolder.FolderPath == DBHomeDirectory)
{
return(LogDetailError(ErrorCodes.DeleteFolder_Root, ToVirtualPath(dnnFolder.FolderPath)));
}
//Don't allow deleting of any protected folder
if (dnnFolder.IsProtected)
{
return(LogDetailError(ErrorCodes.DeleteFolder_Protected, ToVirtualPath(dnnFolder.FolderPath), logDetail));
}
}
//check permissions
if (!(FolderPermissionController.CanDeleteFolder(dnnFolder)))
{
return(LogDetailError(ErrorCodes.DeleteFolder_NoPermission, ToVirtualPath(dnnFolder.FolderPath), logDetail));
}
return(string.Empty);
}
protected override void OnLoad(EventArgs e)
{
try
{
if (!this.Page.IsPostBack)
{
this.SetupPermissionGrid();
this.PrepareFolderProperties();
this.SetPropertiesAvailability(FolderPermissionController.CanManageFolder((FolderInfo)this.Folder));
}
if (!FolderPermissionController.CanViewFolder((FolderInfo)this.Folder))
{
this.SaveButton.Visible = false;
this.SetPropertiesVisibility(false);
UI.Skins.Skin.AddModuleMessage(this, this.LocalizeString("UserCannotReadFolderError"), ModuleMessage.ModuleMessageType.RedError);
}
else
{
this.SaveButton.Visible = FolderPermissionController.CanViewFolder((FolderInfo)this.Folder) && FolderPermissionController.CanManageFolder((FolderInfo)this.Folder);
}
}
catch (DotNetNukeException dnnex)
{
UI.Skins.Skin.AddModuleMessage(this, dnnex.Message, ModuleMessage.ModuleMessageType.RedError);
}
catch (Exception exc)
{
Exceptions.ProcessModuleLoadException(this, exc);
}
}
public HttpResponseMessage GetFolderDetails(int folderId)
{
var folder = FolderManager.Instance.GetFolder(folderId);
if (!FolderPermissionController.CanManageFolder((FolderInfo)folder))
{
return(this.Request.CreateResponse(
HttpStatusCode.InternalServerError,
new { message = LocalizationHelper.GetString("UserHasNoPermissionToManageFolder.Error") }));
}
var createdBy = folder.CreatedByUser(this.PortalSettings.PortalId);
var lastModifiedBy = folder.LastModifiedByUser(this.PortalSettings.PortalId);
return(this.Request.CreateResponse(HttpStatusCode.OK, new
{
folderId = folder.FolderID,
folderName = folder.FolderName,
createdOnDate = folder.CreatedOnDate.ToShortDateString(),
createdBy = createdBy != null ? createdBy.Username : string.Empty,
lastModifiedOnDate = folder.LastModifiedOnDate.ToShortDateString(),
lastModifiedBy = lastModifiedBy != null ? lastModifiedBy.Username : string.Empty,
type = FolderMappingController.Instance.GetFolderMapping(folder.FolderMappingID).MappingName,
isVersioned = folder.IsVersioned,
permissions = new FolderPermissions(true, folder.FolderPermissions),
}));
}
internal static bool CanEdit(IFolderInfo folder)
{
if (folder == null)
{
return(false);
}
return(FolderPermissionController.CanAddFolder(folder as FolderInfo));
}
public virtual bool CanDeleteFolder(FolderInfo dnnFolder)
{
if (!(FolderPermissionController.CanDeleteFolder(dnnFolder)))
{
return(false);
}
return(true);
}
public PageViewModel GetFolderContent(int moduleId, int folderId, int startIndex, int numItems, string sortExpression)
{
var folder = GetFolderInfo(folderId);
if (!FolderPermissionController.CanBrowseFolder((FolderInfo)folder))
{
//The user cannot access the content
return(new PageViewModel
{
Folder = GetFolderViewModel(folder),
Items = new List <ItemViewModel>(),
TotalCount = 0
});
}
var sortProperties = SortProperties.Parse(sortExpression);
List <IFolderInfo> folders;
var subfolderFilter = SettingsRepository.GetSubfolderFilter(moduleId);
if (subfolderFilter != SubfolderFilter.IncludeSubfoldersFolderStructure)
{
folders = new List <IFolderInfo>();
}
else
{
folders = GetFolders(folder, sortProperties.Column == "ItemName" ? "FolderName" : sortProperties.Column, sortProperties.Ascending).ToList();
}
var recursive = subfolderFilter == SubfolderFilter.IncludeSubfoldersFilesOnly;
var files = GetFiles(folder, sortProperties, startIndex, recursive).ToList();
IEnumerable <ItemViewModel> content;
if (startIndex + numItems <= folders.Count())
{
content = folders.Skip(startIndex).Take(numItems).Select(GetItemViewModel);
}
else if (startIndex >= folders.Count())
{
content = files.Skip(startIndex - folders.Count).Take(numItems).Select(GetItemViewModel);
}
else
{
var numFiles = numItems - (folders.Count - startIndex);
content = folders.Skip(startIndex).Select(GetItemViewModel).Union(files.Take(numFiles).Select(GetItemViewModel));
}
return(new PageViewModel
{
Folder = GetFolderViewModel(folder),
Items = content.ToList(),
TotalCount = folders.Count() + files.Count()
});
}
public override bool CanEditFolder(IAsset item)
{
var id = (item as IFolder)?.Id
?? (item as IFile)?.ParentId
?? throw new ArgumentException("Should be a DNN asset", nameof(item));
var folder = FolderManager.Instance.GetFolder(id);
return(folder != null && FolderPermissionController.CanAddFolder(folder as FolderInfo));
}
private bool CanUserViewFile(IFileInfo file)
{
if (file == null)
{
return(false);
}
var folder = (FolderInfo)FolderManager.Instance.GetFolder(file.FolderId);
return(FolderPermissionController.CanViewFolder(folder));
}
protected bool HasPermission(IFolderInfo folder, string permissionKey)
{
var hasPermision = PortalSettings.Current.UserInfo.IsSuperUser;
if (!hasPermision && folder != null)
{
hasPermision = FolderPermissionController.HasFolderPermission(folder.FolderPermissions, permissionKey);
}
return(hasPermision);
}
private void SavePermissions()
{
if (!this.CanManageFolder)
{
throw new DotNetNukeException(this.LocalizeString("UserCannotChangePermissionsError"));
}
this.Folder = FolderManager.Instance.GetFolder(this.Folder.FolderID);
this.Folder.FolderPermissions.Clear();
this.Folder.FolderPermissions.AddRange(this.PermissionsGrid.Permissions);
FolderPermissionController.SaveFolderPermissions(this.Folder);
}
public void SyncFolderContent(int folderId, bool recursive)
{
var folder = GetFolderInfo(folderId);
if (!FolderPermissionController.CanBrowseFolder((FolderInfo)folder))
{
//The user cannot access the content
return;
}
FolderManager.Instance.Synchronize(folder.PortalID, folder.FolderPath, recursive, true);
}
private void cmdCopyPerm_Click(object sender, EventArgs e)
{
try
{
FolderPermissionController.CopyPermissionsToSubfolders(this.Folder, this.PermissionsGrid.Permissions);
UI.Skins.Skin.AddModuleMessage(this, this.LocalizeString("PermissionsCopied"), ModuleMessage.ModuleMessageType.GreenSuccess);
}
catch (Exception ex)
{
UI.Skins.Skin.AddModuleMessage(this, this.LocalizeString("PermissionCopyError"), ModuleMessage.ModuleMessageType.RedError);
Exceptions.ProcessModuleLoadException(this, ex);
}
}
public ContentPage GetFolderContent(int folderId, int startIndex, int numItems, string sortExpression = null, SubfolderFilter subfolderFilter = SubfolderFilter.IncludeSubfoldersFolderStructure)
{
var folder = this.GetFolderInfo(folderId);
if (!FolderPermissionController.CanBrowseFolder((FolderInfo)folder))
{
throw new AssetManagerException(Localization.GetExceptionMessage("UserHasNoPermissionToBrowseFolder", UserHasNoPermissionToBrowseFolderDefaultMessage));
}
var sortProperties = SortProperties.Parse(sortExpression);
List <IFolderInfo> folders;
if (subfolderFilter != SubfolderFilter.IncludeSubfoldersFolderStructure)
{
folders = new List <IFolderInfo>();
}
else
{
folders = this.GetFolders(folder, sortProperties.Column == "ItemName" ? "FolderName" : sortProperties.Column, sortProperties.Ascending).ToList();
}
var recursive = subfolderFilter == SubfolderFilter.IncludeSubfoldersFilesOnly;
var files = this.GetFiles(folder, sortProperties, startIndex, recursive).ToList();
IEnumerable <object> content;
if (startIndex + numItems <= folders.Count())
{
content = folders.Skip(startIndex).Take(numItems);
}
else if (startIndex >= folders.Count())
{
content = files.Skip(startIndex - folders.Count).Take(numItems);
}
else
{
var numFiles = numItems - (folders.Count - startIndex);
content = folders.Skip(startIndex);
content = content.Union(files.Take(numFiles));
}
return(new ContentPage
{
Folder = folder,
Items = content.ToList(),
TotalCount = folders.Count() + files.Count(),
});
}
/// <summary>
/// Serializes all Folder Permissions
/// </summary>
/// <param name="xmlTemplate">Reference to XmlDocument context</param>
/// <param name="nodePermissions"></param>
/// <param name="objportal">Portal to serialize</param>
/// <param name="folderPath">The folder containing the files</param>
/// <remarks>
/// The serialization uses the xml attributes defined in FolderInfo class.
/// </remarks>
/// <history>
/// [cnurse] 11/08/2004 Created
/// </history>
public void SerializeFolderPermissions(XmlDocument xmlTemplate, XmlNode nodePermissions, PortalInfo objportal, string folderPath)
{
FolderPermissionController objPermissions = new FolderPermissionController();
ArrayList arrPermissions = objPermissions.GetFolderPermissionsByFolder(objportal.PortalID, folderPath);
foreach (FolderPermissionInfo objPermission in arrPermissions)
{
XmlElement nodePermission = xmlTemplate.CreateElement("permission");
nodePermission.AppendChild(XmlUtils.CreateElement(xmlTemplate, "permissioncode", objPermission.PermissionCode));
nodePermission.AppendChild(XmlUtils.CreateElement(xmlTemplate, "permissionkey", objPermission.PermissionKey));
nodePermission.AppendChild(XmlUtils.CreateElement(xmlTemplate, "rolename", objPermission.RoleName));
nodePermission.AppendChild(XmlUtils.CreateElement(xmlTemplate, "allowaccess", objPermission.AllowAccess.ToString().ToLower()));
nodePermissions.AppendChild(nodePermission);
}
}
private string Check_CanCopyFolder(FolderInfo dnnFolder, bool isFileCheck, bool logDetail)
{
if (dnnFolder == null)
{
return(LogDetailError(ErrorCodes.FolderDoesNotExist, ToVirtualPath(dnnFolder.FolderPath), logDetail));
}
//check permissions
if (!(FolderPermissionController.CanCopyFolder(dnnFolder)))
{
return(LogDetailError(ErrorCodes.CopyFolder_NoPermission, ToVirtualPath(dnnFolder.FolderPath), logDetail));
}
return(string.Empty);
}
/// <summary>
/// Checks if user has write access to the folder.
/// </summary>
/// <param name="folderId">The folder id.</param>
/// <param name="portalSettings">The portal settings.</param>
/// <returns>
/// Returns if the user has write access to the folder.
/// </returns>
public static bool CheckIfUserHasFolderWriteAccess(int folderId, PortalSettings portalSettings)
{
try
{
var checkFolder = folderId.Equals(-1)
? ConvertFilePathToFolderInfo(portalSettings.HomeDirectoryMapPath, portalSettings)
: FolderManager.Instance.GetFolder(folderId);
return(FolderPermissionController.HasFolderPermission(checkFolder.FolderPermissions, "WRITE"));
}
catch (Exception)
{
return(false);
}
}
private IEnumerable <IFolderInfo> GetChildFolders(int folderID)
{
var parentFolder = FolderManager.Instance.GetFolder(folderID);
var folders = FolderManager.Instance.GetFolders(parentFolder);
var viewableFolders = new List <FolderInfo>();
foreach (FolderInfo folder in folders)
{
if (FolderPermissionController.CanViewFolder(folder) == true)
{
viewableFolders.Add(folder);
}
}
return(viewableFolders);
}
/// <inheritdoc/>
public bool HasDeletePermission(int moduleMode, int folderId)
{
if (!this.HasGroupFolderOwnerPermission(folderId))
{
return(false);
}
if (moduleMode == (int)Constants.ModuleModes.User && !this.IsUserFolder(folderId))
{
return(false);
}
var folder = this.folderManager.GetFolder(folderId);
return(FolderPermissionController.CanDeleteFolder((FolderInfo)folder));
}
private string Check_CanCopyFolder(string virtualPath, bool logDetail)
{
var dnnFolder = GetDNNFolder(virtualPath);
if (dnnFolder == null)
{
return(LogDetailError(ErrorCodes.FolderDoesNotExist, virtualPath, logDetail));
}
//check permissions
if (!(FolderPermissionController.CanCopyFolder(dnnFolder)))
{
return(LogDetailError(ErrorCodes.CopyFolder_NoPermission, ToVirtualPath(dnnFolder.FolderPath), logDetail));
}
return(string.Empty);
}
public IEnumerable <FolderViewModel> GetFolders(int moduleId, int folderId)
{
var subfolderFilter = SettingsRepository.GetSubfolderFilter(moduleId);
if (subfolderFilter != SubfolderFilter.IncludeSubfoldersFolderStructure)
{
return(new List <FolderViewModel>());
}
var folder = GetFolderInfo(folderId);
if (!FolderPermissionController.CanBrowseFolder((FolderInfo)folder))
{
//The user cannot access the content
return(new List <FolderViewModel>());
}
return(AssetManager.Instance.GetFolders(folder, "FolderName", true).Select(GetFolderViewModel));
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Serializes all Folder Permissions
/// </summary>
/// <param name="objportal">Portal to serialize</param>
/// <param name="folderPath">The folder containing the files</param>
/// <remarks>
/// The serialization uses the xml attributes defined in FolderInfo class.
/// </remarks>
/// <history>
/// [cnurse] 11/08/2004 Created
/// </history>
/// -----------------------------------------------------------------------------
private void SerializeFolderPermissions(XmlWriter writer, PortalInfo objportal, string folderPath)
{
FolderPermissionCollection permissions = FolderPermissionController.GetFolderPermissionsCollectionByFolder(objportal.PortalID, folderPath);
writer.WriteStartElement("folderpermissions");
foreach (FolderPermissionInfo permission in permissions)
{
writer.WriteStartElement("permission");
writer.WriteElementString("permissioncode", permission.PermissionCode);
writer.WriteElementString("permissionkey", permission.PermissionKey);
writer.WriteElementString("rolename", permission.RoleName);
writer.WriteElementString("allowaccess", permission.AllowAccess.ToString().ToLowerInvariant());
writer.WriteEndElement();
}
writer.WriteEndElement();
}
public static PathPermissions TelerikPermissions(IFolderInfo folder)
{
var folderPermissions = PathPermissions.Read;
if (FolderPermissionController.CanViewFolder((FolderInfo)folder))
{
if (FolderPermissionController.CanAddFolder((FolderInfo)folder))
{
folderPermissions = folderPermissions | PathPermissions.Upload;
}
if (FolderPermissionController.CanDeleteFolder((FolderInfo)folder))
{
folderPermissions = folderPermissions | PathPermissions.Delete;
}
}
return(folderPermissions);
}
public virtual bool CanViewFilesInFolder(FolderInfo dnnFolder)
{
if ((dnnFolder == null))
{
return(false);
}
if (!(CanViewFolder(dnnFolder)))
{
return(false);
}
if (!(FolderPermissionController.CanViewFolder(dnnFolder)))
{
return(false);
}
return(true);
}
public HttpResponseMessage SaveFolderDetails(FolderDetailsRequest folderDetails)
{
var folder = FolderManager.Instance.GetFolder(folderDetails.FolderId);
if (folder == null)
{
return(this.Request.CreateResponse(HttpStatusCode.NotFound, new { message = "Folder doesn't exist." }));
}
if (!FolderPermissionController.CanManageFolder((FolderInfo)folder))
{
return(this.Request.CreateResponse(
HttpStatusCode.InternalServerError,
new { message = LocalizationHelper.GetString("UserHasNoPermissionToManageFolder.Error") }));
}
ItemsManager.Instance.SaveFolderDetails(folder, folderDetails);
return(this.Request.CreateResponse(HttpStatusCode.OK, new { Status = 0 }));
}
/// -----------------------------------------------------------------------------
/// <summary>
/// This routine populates the Folder List Drop Down
/// There is no reference to permissions here as all folders should be available to the admin.
/// </summary>
/// <remarks>
/// </remarks>
/// <history>
/// [Philip Beadle] 5/10/2004 Added
/// [cnurse] 04/24/2006 Converted to use Database as folder source
/// </history>
/// -----------------------------------------------------------------------------
private void LoadFolders()
{
ddlFolders.Items.Clear();
var user = UserController.GetCurrentUserInfo();
var folders = FolderManager.Instance.GetFolders(FolderPortalID, "ADD", user.UserID);
foreach (FolderInfo folder in folders)
{
if (FolderPermissionController.CanAddFolder(folder))
{
var FolderItem = new ListItem();
if (folder.FolderPath == Null.NullString)
{
if (IsHostMenu)
{
FolderItem.Text = Localization.GetString("HostRoot", LocalResourceFile);
}
else
{
FolderItem.Text = Localization.GetString("PortalRoot", LocalResourceFile);
}
}
else
{
FolderItem.Text = PathUtils.Instance.RemoveTrailingSlash(folder.DisplayPath);
}
FolderItem.Value = folder.FolderPath;
ddlFolders.AddItem(FolderItem.Text, FolderItem.Value);
}
}
if (!String.IsNullOrEmpty(DestinationFolder))
{
if (ddlFolders.FindItemByText(DestinationFolder) != null)
{
ddlFolders.FindItemByText(DestinationFolder).Selected = true;
}
}
}
public object GetFileByPath(string relativePath)
{
var dnnDynamicCode = new DnnDynamicCode().Init(GetBlock(), Log);
var portal = dnnDynamicCode.Dnn.Portal;
relativePath = relativePath.Replace(portal.HomeDirectory, "");
var file = FileManager.Instance.GetFile(portal.PortalId, relativePath);
if (file == null)
{
return(null);
}
var folder = (FolderInfo)FolderManager.Instance.GetFolder(file.FolderId);
return(FolderPermissionController.CanViewFolder(folder)
? new
{
file.FileId
}
: null);
}
protected override void OnInit(EventArgs e)
{
try
{
base.OnInit(e);
JavaScript.RequestRegistration(CommonJs.DnnPlugins);
var folderId = Convert.ToInt32(this.Request.Params["FolderId"]);
this.Folder = FolderManager.Instance.GetFolder(folderId);
this.HasFullControl = this.UserInfo.IsSuperUser || FolderPermissionController.HasFolderPermission(this.Folder.FolderPermissions, "FULLCONTROL");
FolderViewModel rootFolder;
switch (SettingsRepository.GetMode(this.ModuleId))
{
case DigitalAssestsMode.Group:
var groupId = Convert.ToInt32(this.Request.Params["GroupId"]);
rootFolder = this.controller.GetGroupFolder(groupId, this.PortalSettings);
if (rootFolder == null)
{
throw new Exception("Invalid group folder");
}
break;
case DigitalAssestsMode.User:
rootFolder = this.controller.GetUserFolder(this.PortalSettings.UserInfo);
break;
default:
rootFolder = this.controller.GetRootFolder(this.ModuleId);
break;
}
this.isRootFolder = rootFolder.FolderID == folderId;
this.folderViewModel = this.isRootFolder ? rootFolder : this.controller.GetFolder(folderId);
// Setup controls
this.CancelButton.Click += this.OnCancelClick;
this.SaveButton.Click += this.OnSaveClick;
this.PrepareFolderPreviewInfo();
this.cmdCopyPerm.Click += this.cmdCopyPerm_Click;
var mef = new ExtensionPointManager();
var folderFieldsExtension = mef.GetUserControlExtensionPointFirstByPriority("DigitalAssets", "FolderFieldsControlExtensionPoint");
if (folderFieldsExtension != null)
{
this.folderFieldsControl = this.Page.LoadControl(folderFieldsExtension.UserControlSrc);
this.folderFieldsControl.ID = this.folderFieldsControl.GetType().BaseType.Name;
this.FolderDynamicFieldsContainer.Controls.Add(this.folderFieldsControl);
var fieldsControl = this.folderFieldsControl as IFieldsControl;
if (fieldsControl != null)
{
fieldsControl.SetController(this.controller);
fieldsControl.SetItemViewModel(new ItemViewModel
{
ItemID = this.folderViewModel.FolderID,
IsFolder = true,
PortalID = this.folderViewModel.PortalID,
ItemName = this.folderViewModel.FolderName,
});
}
}
}
catch (Exception exc)
{
Exceptions.ProcessModuleLoadException(this, exc);
}
}
/// <summary>
/// Determines whether [has write permission] [the specified relative path].
/// </summary>
/// <param name="relativePath">The relative path.</param>
/// <returns>
/// <c>true</c> if [has write permission] [the specified relative path]; otherwise, <c>false</c>.
/// </returns>
private bool HasWritePermission(string relativePath)
{
var portalId = PortalSettings.Current.PortalId;
return(FolderPermissionController.HasFolderPermission(portalId, relativePath, "WRITE"));
}
/// <summary>
/// Gets the TabPermissions from the Data Store
/// </summary>
private void GetFolderPermissions()
{
FolderPermissionController objFolderPermissionController = new FolderPermissionController();
FolderPermissions = objFolderPermissionController.GetFolderPermissionsCollectionByFolderPath(PortalId, this.FolderPath);
}
