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); }