private void RenameFiles(IFolderInfo folder, string newFolderPath) { var files = FolderManager.Instance.GetFiles(folder); foreach (var file in files) { file.Folder = newFolderPath; FileManager.Instance.UpdateFile(file); } }
public override string[] GetFiles(IFolderInfo folder) { Requires.NotNull("folder", folder); var fileNames = DirectoryWrapper.Instance.GetFiles(folder.PhysicalPath); for (var i = 0; i < fileNames.Length; i++) { var fileName = Path.GetFileName(fileNames[i]); if (!fileName.EndsWith(ProtectedExtension, StringComparison.InvariantCultureIgnoreCase)) { var destFileName = fileNames[i] + ProtectedExtension; if (FileWrapper.Instance.Exists(destFileName)) FileWrapper.Instance.Delete(destFileName); FileWrapper.Instance.Move(fileNames[i], destFileName); } else { fileName = fileName.Substring(0, fileName.LastIndexOf(ProtectedExtension, StringComparison.InvariantCultureIgnoreCase)); } fileNames[i] = fileName; } return fileNames; }
private static string CreateFile(IFolderInfo folder, string fileName, string contentType, Stream fileContent, bool unzip, bool overwrite, bool checkPermissions) { var strMessage = ""; var fileManager = FileManager.Instance; try { var file = fileManager.AddFile(folder, fileName, fileContent, overwrite, checkPermissions, contentType); if (unzip && file.Extension == "zip") { fileManager.UnzipFile(file, folder); } } catch (PermissionsNotMetException) { strMessage += "<br />" + string.Format(Localization.GetString("InsufficientFolderPermission"), folder.FolderPath); } catch (NoSpaceAvailableException) { strMessage += "<br />" + string.Format(Localization.GetString("DiskSpaceExceeded"), fileName); } catch (InvalidFileExtensionException) { strMessage += "<br />" + string.Format(Localization.GetString("RestrictedFileType"), fileName, Host.AllowedExtensionWhitelist.ToDisplayString()); } catch (Exception ex) { DnnLog.Error(ex); strMessage += "<br />" + string.Format(Localization.GetString("SaveFileError"), fileName); } return strMessage; }
/// <summary> /// Get the folder specified in App.Settings (BasePath) combined with the module's ID /// Will create the folder if it does not exist /// </summary> private IFolderInfo Folder(Guid entityGuid, string fieldName) { if (_folder == null) { var folderManager = FolderManager.Instance; var basePath = AdamAppRootFolder.Replace("[AppFolder]", App.Folder); var path = AdamFolderMask .Replace("[AppFolder]", App.Folder) .Replace("[Guid22]", GuidHelpers.Compress22(entityGuid)) .Replace("[FieldName]", fieldName); // create all folders to ensure they exist. Must do one-by-one because dnn must have it in the catalog var pathParts = path.Split('/'); var pathToCheck = ""; // pathParts[0]; for (var i = 0; i < pathParts.Length; i++) { pathToCheck += pathParts[i] + "/"; if (!folderManager.FolderExists(Dnn.Portal.PortalId, pathToCheck)) folderManager.AddFolder(Dnn.Portal.PortalId, pathToCheck); } _folder = folderManager.GetFolder(Dnn.Portal.PortalId, path); } return _folder; }
private void AddFolder(IFolderInfo fldr) { _folderIds.Add(fldr.FolderID); // track of the folder AddFilesInFolder(fldr); // keep track of the files foreach (var f in _fldm.GetFolders(fldr)) // then add subfolders AddFolder(f); }
public override void AddFile(IFolderInfo folder, string fileName, Stream content) { Requires.NotNull("folder", folder); Requires.NotNullOrEmpty("fileName", fileName); Requires.NotNull("content", content); UpdateFile(folder, fileName, content); }
private void MoveFolders(IFolderInfo folder, string newFolderPath) { var folderInfos = FolderManager.Instance.GetFolders(folder.PortalID).Where(f => f.FolderPath != string.Empty && f.FolderPath.StartsWith(folder.FolderPath)).ToList(); foreach (var folderInfo in folderInfos) { var folderPath = newFolderPath + folderInfo.FolderPath.Substring(folder.FolderPath.Length); MoveFolder(folderPath, folderInfo); } }
public static IEnumerable<IFolderInfo> GetFolderHierarchy(IFolderInfo folderInfo) { List<IFolderInfo> res = new List<IFolderInfo>(); while (folderInfo != null && folderInfo.Id != ""){ res.Add(folderInfo); folderInfo = (folderInfo as FolderInfo).GetParent(instance.baseDir); } res.Reverse(); return res; }
public AdamItem(IFolderInfo original) { IsFolder = true; Id = original.FolderID; ParentId = original.ParentID; Path = original.DisplayPath; Name = original.DisplayName; Size = 0; Type = "folder"; }
public IFolderInfo MoveFolder(IFolderInfo folder, string newFolderPath) { Requires.NotNull("folder", folder); Requires.NotNullOrEmpty("newFolderPath", newFolderPath); newFolderPath = PathUtils.Instance.FormatFolderPath(newFolderPath); if (folder.FolderPath == newFolderPath) return folder; MoveFolders(folder, newFolderPath); return FolderManager.Instance.GetFolder(folder.FolderID); }
public static void checkFolderPermissions(int PortalId, IFolderInfo theFolder, int theUserId, List<UserInfo> approvers) { // Get the write permission PermissionController pc = new PermissionController(); PermissionInfo w = (PermissionInfo)pc.GetPermissionByCodeAndKey("SYSTEM_FOLDER", "WRITE")[0]; // Get a list of all the folderPermissions we currently have FolderPermissionCollection folderPermissions = theFolder.FolderPermissions; // Set up the first permission FolderPermissionInfo permission = new FolderPermissionInfo(); // Set up some default values for the permission initFolderPermission(permission, theFolder.FolderID, PortalId, w.PermissionID); // Set the user id to be this user permission.UserID = theUserId; // Add folder permissions, with a check for duplicates. // This duplicate check (the 'True' parameter) will classify this as a "duplicate" if this permission // has the same PermissionID, UserID, and RoleID as a pre-existing one, and not add it if it is a duplicate folderPermissions.Add(permission, true); // Get all the possible approvers for this reimbursement try { foreach (var approver in approvers) { // Create a new permission for this approver permission = new FolderPermissionInfo(); // Initialize all the variables initFolderPermission(permission, theFolder.FolderID, PortalId, w.PermissionID); // Set the userid to the approver's id permission.UserID = approver.UserID; // Add permission for approver folderPermissions.Add(permission, true); } } catch { } // Finally, add permissions for the accounts team: try { permission = new FolderPermissionInfo(); // Initialize new folder permission initFolderPermission(permission, theFolder.FolderID, PortalId, w.PermissionID); // Set the role ID DotNetNuke.Security.Roles.RoleController rc = new DotNetNuke.Security.Roles.RoleController(); permission.RoleID = rc.GetRoleByName(PortalId, "Accounts Team").RoleID; folderPermissions.Add(permission, true); } catch { } // Once we're finished adding these folder permissions, save it all FolderPermissionController.SaveFolderPermissions(theFolder); }
protected override void OnInit(EventArgs e) { base.OnInit(e); ServicesFramework.Instance.RequestAjaxScriptSupport(); ServicesFramework.Instance.RequestAjaxAntiForgerySupport(); DotNetNuke.UI.Utilities.ClientAPI.RegisterClientVariable(Page, "oc_websiteRoot", HostingEnvironment.ApplicationVirtualPath, true); if (System.IO.File.Exists(Server.MapPath("~/Providers/HtmlEditorProviders/CKEditor/ckeditor.js"))) { ClientResourceManager.RegisterScript(Page, "~/Providers/HtmlEditorProviders/CKEditor/ckeditor.js", FileOrder.Js.DefaultPriority); DotNetNuke.UI.Utilities.ClientAPI.RegisterClientVariable(Page, "PortalId", PortalId.ToString(), true); CKDNNporid.Value = PortalId.ToString(); } var folderId = Convert.ToInt32(Request.Params["FolderId"]); Folder = FolderManager.Instance.GetFolder(folderId); }
// ReSharper disable LoopCanBeConvertedToQuery private List<Item> GetChildren(IFolderInfo folder, ICollection<string> extensions) { var everything = new List<Item>(); var folders = _folderManager.GetFolders(folder); foreach (var currentFolder in folders) { everything.Add(new Item { id = currentFolder.FolderID, name = currentFolder.DisplayName ?? currentFolder.FolderName, folder = true, parentId = folder.FolderID, children = GetChildren(currentFolder, extensions) }); } var files = _folderManager.GetFiles(folder); foreach (var file in files) { // list is empty or contains the file extension in question if (extensions.Count == 0 || extensions.Contains(file.Extension.ToLowerInvariant())) { everything.Add(new Item { id = file.FileId, name = file.FileName, folder = false, parentId = file.FolderId, thumb_url = GetThumbUrl(file), type = GetTypeName(file), size = GetFileSize(file.Size), modified = GetModifiedTime(file.LastModificationTime) }); } } return everything; }
public override string[] GetFiles(IFolderInfo folder) { Requires.NotNull("folder", folder); var fileNames = DirectoryWrapper.Instance.GetFiles(folder.PhysicalPath); for (var i = 0; i < fileNames.Length; i++) { var fileName = Path.GetFileName(fileNames[i]); if(!fileName.EndsWith(ProtectedExtension)) { FileWrapper.Instance.Move(fileNames[i], fileNames[i] + ProtectedExtension); } else { fileName = fileName.Substring(0, fileName.LastIndexOf(ProtectedExtension)); } fileNames[i] = fileName; } return fileNames; }
private List<Field> GetFolderPreviewFields(IFolderInfo folder) { var fields = new List<Field> { GetFolderSizeField(folder), GetTotalFilesField(folder) }; fields.AddRange(GetAuditFields((FolderInfo)folder, folder.PortalID)); return fields; }
private Field GetTotalFilesField(IFolderInfo folder) { var field = new Field(DefaultMetadataNames.TotalFiles); field.DisplayName = LocalizationHelper.GetString("Field" + field.Name + ".DisplayName"); var totalFiles = Convert.ToInt32(FolderManager.Instance.GetFiles(folder, true, false).Count()); field.Type = totalFiles.GetType(); field.Value = totalFiles; field.StringValue = field.Value.ToString(); return field; }
/// ----------------------------------------------------------------------------- /// <summary> /// SaveFolderPermissions updates a Folder's permissions /// </summary> /// <param name="folder">The Folder to update</param> /// <history> /// [cnurse] 04/15/2009 Created /// </history> /// ----------------------------------------------------------------------------- public virtual void SaveFolderPermissions(IFolderInfo folder) { if ((folder.FolderPermissions != null)) { FolderPermissionCollection folderPermissions = GetFolderPermissionsCollectionByFolder(folder.PortalID, folder.FolderPath); //Ensure that if role/user has been given a permission that is not Read/Browse then they also need Read/Browse var permController = new PermissionController(); ArrayList permArray = permController.GetPermissionByCodeAndKey("SYSTEM_FOLDER", "READ"); PermissionInfo readPerm = null; if (permArray.Count == 1) { readPerm = permArray[0] as PermissionInfo; } PermissionInfo browsePerm = null; permArray = permController.GetPermissionByCodeAndKey("SYSTEM_FOLDER", "BROWSE"); if (permArray.Count == 1) { browsePerm = permArray[0] as PermissionInfo; } var additionalPermissions = new FolderPermissionCollection(); foreach (FolderPermissionInfo folderPermission in folder.FolderPermissions) { if (folderPermission.PermissionKey != "BROWSE" && folderPermission.PermissionKey != "READ" && folderPermission.AllowAccess) { //Try to add Read permission var newFolderPerm = new FolderPermissionInfo(readPerm) { FolderID = folderPermission.FolderID, RoleID = folderPermission.RoleID, UserID = folderPermission.UserID, AllowAccess = true }; additionalPermissions.Add(newFolderPerm); //Try to add Browse permission newFolderPerm = new FolderPermissionInfo(browsePerm) { FolderID = folderPermission.FolderID, RoleID = folderPermission.RoleID, UserID = folderPermission.UserID, AllowAccess = true }; additionalPermissions.Add(newFolderPerm); } } foreach (FolderPermissionInfo folderPermission in additionalPermissions) { folder.FolderPermissions.Add(folderPermission, true); } if (!folderPermissions.CompareTo(folder.FolderPermissions)) { dataProvider.DeleteFolderPermissionsByFolderPath(folder.PortalID, folder.FolderPath); foreach (FolderPermissionInfo folderPermission in folder.FolderPermissions) { dataProvider.AddFolderPermission(folder.FolderID, folderPermission.PermissionID, folderPermission.RoleID, folderPermission.AllowAccess, folderPermission.UserID, UserController.GetCurrentUserInfo().UserID); } } } }
public override void RenameFolder(IFolderInfo folder, string newFolderName) { // The folder has already been moved in filesystem }
private string ExportModule(int moduleID, string fileName, IFolderInfo folder) { var strMessage = ""; if (Module != null) { if (!String.IsNullOrEmpty(Module.DesktopModule.BusinessControllerClass) && Module.DesktopModule.IsPortable) { try { var objObject = Reflection.CreateObject(Module.DesktopModule.BusinessControllerClass, Module.DesktopModule.BusinessControllerClass); //Double-check if (objObject is IPortable) { var content = Convert.ToString(((IPortable)objObject).ExportModule(moduleID)); if (!String.IsNullOrEmpty(content)) { //remove invalid chars in content content = Regex.Replace(content, _invalidCharsRegex, string.Empty); //add attributes to XML document content = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" + "<content type=\"" + CleanName(Module.DesktopModule.ModuleName) + "\" version=\"" + Module.DesktopModule.Version + "\">" + content + "</content>"; //First check the Portal limits will not be exceeded (this is approximate) var objPortalController = new PortalController(); var strFile = PortalSettings.HomeDirectoryMapPath + folder.FolderPath + fileName; if (objPortalController.HasSpaceAvailable(PortalId, content.Length)) { //add file to Files table using (var fileContent = new MemoryStream(Encoding.UTF8.GetBytes(content))) { FileManager.Instance.AddFile(folder, fileName, fileContent, true, true, "application/octet-stream"); } } else { strMessage += "<br>" + string.Format(Localization.GetString("DiskSpaceExceeded"), strFile); } } else { strMessage = Localization.GetString("NoContent", LocalResourceFile); } } else { strMessage = Localization.GetString("ExportNotSupported", LocalResourceFile); } } catch { strMessage = Localization.GetString("Error", LocalResourceFile); } } else { strMessage = Localization.GetString("ExportNotSupported", LocalResourceFile); } } return strMessage; }
protected virtual ItemViewModel GetItemViewModel(IFolderInfo folder) { var parentFolderId = Null.NullInteger; var parentFolderPath = string.Empty; var parentFolder = FolderManager.Instance.GetFolder(folder.ParentID); if (parentFolder != null) { parentFolderId = parentFolder.FolderID; parentFolderPath = parentFolder.FolderPath; } return new ItemViewModel { IsFolder = true, ItemID = folder.FolderID, ItemName = folder.FolderName, LastModifiedOnDate = folder.LastModifiedOnDate.ToString("g"), PortalID = folder.PortalID, IconUrl = GetFolderIconUrl(folder.PortalID, folder.FolderMappingID), Permissions = GetPermissionViewModelCollection(folder), ParentFolderID = parentFolderId, ParentFolder = parentFolderPath, FolderMappingID = folder.FolderMappingID, UnlinkAllowedStatus = GetUnlinkAllowedStatus(folder) }; }
public Export(AdamManager adm) { _manager = adm; _root = _manager.Root; }
public bool CanViewFolder(IFolderInfo folder) { return(FolderPermissionController.CanViewFolder((FolderInfo)folder)); }
private void Save_Click(object sender, EventArgs e) { if (GroupId > 0) { Security.PortalSecurity ps = Security.PortalSecurity.Instance; txtGroupName.Text = ps.InputFilter(txtGroupName.Text, Security.PortalSecurity.FilterFlag.NoScripting); txtGroupName.Text = ps.InputFilter(txtGroupName.Text, Security.PortalSecurity.FilterFlag.NoMarkup); txtDescription.Text = ps.InputFilter(txtDescription.Text, Security.PortalSecurity.FilterFlag.NoScripting); txtDescription.Text = ps.InputFilter(txtDescription.Text, Security.PortalSecurity.FilterFlag.NoMarkup); var roleInfo = RoleController.Instance.GetRoleById(PortalId, GroupId); if (roleInfo != null) { if (txtGroupName.Visible) //if this is visible assume that we're editing the groupname { if (txtGroupName.Text != roleInfo.RoleName) { if (RoleController.Instance.GetRoleByName(PortalId, txtGroupName.Text) != null) { lblInvalidGroupName.Visible = true; return; } } } if (!roleInfo.IsSystemRole) { roleInfo.RoleName = txtGroupName.Text; } roleInfo.Description = txtDescription.Text; roleInfo.IsPublic = rdAccessTypePublic.Checked; if (roleInfo.Settings.ContainsKey("ReviewMembers")) { roleInfo.Settings["ReviewMembers"] = chkMemberApproved.Checked.ToString(); } else { roleInfo.Settings.Add("ReviewMembers", chkMemberApproved.Checked.ToString()); } RoleController.Instance.UpdateRoleSettings(roleInfo, true); RoleController.Instance.UpdateRole(roleInfo); if (inpFile.PostedFile.ContentLength > 0) { IFileManager _fileManager = FileManager.Instance; IFolderManager _folderManager = FolderManager.Instance; var rootFolderPath = PathUtils.Instance.FormatFolderPath(PortalSettings.HomeDirectory); IFolderInfo groupFolder = _folderManager.GetFolder(PortalSettings.PortalId, "Groups/" + roleInfo.RoleID); if (groupFolder == null) { groupFolder = _folderManager.AddFolder(PortalSettings.PortalId, "Groups/" + roleInfo.RoleID); } if (groupFolder != null) { var fileName = Path.GetFileName(inpFile.PostedFile.FileName); var fileInfo = _fileManager.AddFile(groupFolder, fileName, inpFile.PostedFile.InputStream, true); roleInfo.IconFile = "FileID=" + fileInfo.FileId; RoleController.Instance.UpdateRole(roleInfo); } } //Clear Roles Cache DataCache.RemoveCache("GetRoles"); } Response.Redirect(_navigationManager.NavigateURL(TabId, "", new String[] { "groupid=" + GroupId.ToString() })); } }
private bool IsAccessibleByUser(IFolderInfo folder) { return(FolderPermissionController.Instance.CanAddFolder(folder)); }
public bool HasFolderPermission(IFolderInfo folder, string permissionKey) { return(UserController.Instance.GetCurrentUserInfo().IsSuperUser || FolderPermissionController.HasFolderPermission(folder.FolderPermissions, permissionKey)); }
private IFileInfo CreateGroupIconImage(IFileInfo groupIcon) { // determine the new width var intNewWidth = 124; if (groupIcon.Width <= intNewWidth) { intNewWidth = groupIcon.Width; } // determine the new height (aspect ratio from width) var intNewHeight = (int)(groupIcon.Height * intNewWidth / groupIcon.Width); if (intNewHeight > MAX_IMAGE_HEIGHT) { intNewWidth = (int)(groupIcon.Width * MAX_IMAGE_HEIGHT / groupIcon.Height); intNewHeight = MAX_IMAGE_HEIGHT; } Image oImage = null; try { // get an instance of the image from the file system oImage = Image.FromStream(FileManager.Instance.GetFileContent(groupIcon)); } catch (Exception ex) { Exceptions.LogException(ex); } if (oImage == null) { throw new NullReferenceException("The image could not be loaded from the file system."); } // create and save a thumbnail Image oThumbnail; // use the built-in thumbnail generation method //oThumbnail = oImage.GetThumbnailImage(intNewWidth, intNewHeight, ThumbnailCallback, IntPtr.Zero); oThumbnail = CreateThumbnailImage(oImage, intNewWidth, intNewHeight); // save the image in memory var ms = new MemoryStream(); // branch the save statement to avoid encoder errors switch (groupIcon.Extension.ToLower()) { case "jpg": oThumbnail.Save(ms, ImageFormat.Jpeg); break; case "gif": oThumbnail.Save(ms, ImageFormat.Gif); break; case "png": oThumbnail.Save(ms, ImageFormat.Png); break; default: throw new InvalidCastException("The image file is not in a supported format."); } // get an instance of the DNN folder IFolderInfo folder = FolderManager.Instance.GetFolder(PortalId, groupIcon.Folder); // generate a thumbnail name var thumbnailName = GetThumbnailName(groupIcon.FileName, false); // save the image in the DNN file system var newFile = FileManager.Instance.AddFile(folder, thumbnailName, ms); // return the new thumbnail image to the calling method return(newFile); }
public virtual PreviewInfoViewModel GetFolderPreviewInfo(IFolderInfo folder) { return new PreviewInfoViewModel { Title = LocalizationHelper.GetString("PreviewPanelTitle.Text"), ItemId = folder.FolderID, IsFolder = true, PreviewImageUrl = GetFolderIconUrl(folder.PortalID, folder.FolderMappingID), Fields = GetFolderPreviewFields(folder) }; }
/// <summary> /// Set Folder Permission /// </summary> /// <param name="folderInfo">The folder info.</param> private void SetFolderPermission(IFolderInfo folderInfo) { FolderManager.Instance.CopyParentFolderPermissions(folderInfo); }
protected ItemPathViewModel GetItemPathViewModel(IFolderInfo folder) { return new ItemPathViewModel { IsFolder = true, ItemID = folder.FolderID, DisplayPath = folder.DisplayPath, IconUrl = GetFolderIconUrl(folder.PortalID, folder.FolderMappingID) }; }
/// <summary> /// Renames the specified folder using the new foldername. /// </summary> public abstract void RenameFolder(IFolderInfo folder, string newFolderName);
/// <summary> /// Fill the Folder TreeView with all (Sub)Directories /// </summary> /// <param name="currentFolderInfo">The current folder information.</param> private void FillFolderTree(IFolderInfo currentFolderInfo) { this.FoldersTree.Nodes.Clear(); DirectoryInfo dirInfo = new DirectoryInfo(currentFolderInfo.PhysicalPath); RadTreeNode folderNode = new RadTreeNode { Text = dirInfo.Name, Value = dirInfo.FullName, ImageUrl = "Images/folder.gif", ExpandedImageUrl = "Images/folderOpen.gif" }; switch (this.GetStorageLocationType(currentFolderInfo.PhysicalPath)) { case FolderController.StorageLocationTypes.SecureFileSystem: { folderNode.ImageUrl = "Images/folderLocked.gif"; folderNode.ExpandedImageUrl = "Images/folderOpenLocked.gif"; } break; case FolderController.StorageLocationTypes.DatabaseSecure: { folderNode.ImageUrl = "Images/folderdb.gif"; folderNode.ExpandedImageUrl = "Images/folderdb.gif"; } break; } this.FoldersTree.Nodes.Add(folderNode); var folders = FolderManager.Instance.GetFolders(currentFolderInfo); foreach (RadTreeNode node in folders.Cast<FolderInfo>().Select(this.RenderFolder).Where(node => node != null)) { switch (this.GetStorageLocationType(Convert.ToInt32(node.ToolTip))) { case FolderController.StorageLocationTypes.SecureFileSystem: { node.ImageUrl = "Images/folderLocked.gif"; node.ExpandedImageUrl = "Images/folderOpenLocked.gif"; } break; case FolderController.StorageLocationTypes.DatabaseSecure: { node.ImageUrl = "Images/folderdb.gif"; node.ExpandedImageUrl = "Images/folderdb.gif"; } break; } folderNode.Nodes.Add(node); } }
private void MoveFolder(string folderPath, IFolderInfo folderInfo) { RenameFiles(folderInfo, folderPath); folderInfo.FolderPath = folderPath; FolderManager.Instance.UpdateFolder(folderInfo); }
/// <summary> /// Shows the files in directory. /// </summary> /// <param name="currentFolderInfo">The current folder information.</param> /// <param name="pagerChanged">if set to <c>true</c> [pager changed].</param> private void ShowFilesIn(IFolderInfo currentFolderInfo, bool pagerChanged = false) { this.CheckFolderAccess(currentFolderInfo.FolderID, false); if (!pagerChanged) { this.FilesTable = this.GetFiles(currentFolderInfo); this.GetDiskSpaceUsed(); } else { if (this.FilesTable == null) { this.FilesTable = this.GetFiles(currentFolderInfo); } } var filesPagedDataSource = new PagedDataSource { DataSource = this.FilesTable.DefaultView }; if (this.currentSettings.FileListPageSize > 0) { filesPagedDataSource.AllowPaging = true; filesPagedDataSource.PageSize = this.currentSettings.FileListPageSize; filesPagedDataSource.CurrentPageIndex = pagerChanged ? this.PagerFileLinks.CurrentPageIndex : 0; } this.PagerFileLinks.PageCount = filesPagedDataSource.PageCount; this.PagerFileLinks.RessourceFile = this.ResXFile; this.PagerFileLinks.LanguageCode = this.LanguageCode; this.PagerFileLinks.Visible = filesPagedDataSource.PageCount > 1; // this.FilesList.DataSource = this.GetFiles(directory); this.FilesList.DataSource = filesPagedDataSource; this.FilesList.DataBind(); }
protected abstract void DeleteFolderInternal(FolderMappingInfo folderMapping, IFolderInfo folder);
/// <summary> /// Gets a file Stream of the specified file. /// </summary> public abstract Stream GetFileStream(IFolderInfo folder, string fileName);
public bool IsFolderVersioned(IFolderInfo folder) { return(IsFileVersionEnabled(folder.PortalID) && folder.IsVersioned); }
/// <summary> /// Get actual path to a file in specified folder /// </summary> /// <param name="folder">The folder that contains the file</param> /// <param name="fileName">The file name</param> /// <returns>A windows supported path to the file</returns> protected virtual string GetActualPath(IFolderInfo folder, string fileName) { return(Path.Combine(folder.PhysicalPath, fileName)); }
private Stream GetVersionContent(FolderProvider provider, IFolderInfo folder, IFileInfo file, int version) { return(provider.GetFileStream(folder, file, version)); }
public override Stream GetFileStream(IFolderInfo folder, string fileName) { Requires.NotNull("folder", folder); Requires.NotNullOrEmpty("fileName", fileName); return(GetFileStreamInternal(GetActualPath(folder, fileName))); }
/// <remarks> /// No implementation needed /// </remarks> public override void DeleteFolder(IFolderInfo folder) { }
public override string[] GetFiles(IFolderInfo folder) { Requires.NotNull("folder", folder); return(FolderManager.Instance.GetFiles(folder).Select(file => file.FileName).ToArray()); }
public override Stream GetFileStream(IFolderInfo folder, IFileInfo file, int version) { Requires.NotNull("file", file); return(file != null?GetFileStreamInternal(DataProvider.Instance().GetFileVersionContent(file.FileId, version)) : null); }
private Field GetFolderSizeField(IFolderInfo folder) { var field = new Field(DefaultMetadataNames.Size); var size = FolderManager.Instance.GetFiles(folder, true, false).Sum(f => (long)f.Size); field.DisplayName = LocalizationHelper.GetString("Field" + field.Name + ".DisplayName"); field.Type = size.GetType(); field.Value = size; field.StringValue = string.Format(new FileSizeFormatProvider(), "{0:fs}", size); return field; }
public override void MoveFile(IFileInfo file, IFolderInfo destinationFolder) { }
private string GetUnlinkAllowedStatus(IFolderInfo folder) { if (AreMappedPathsSupported(folder.FolderMappingID) && folder.ParentID > 0 && GetFolder(folder.ParentID).FolderMappingID != folder.FolderMappingID) { return "onlyUnlink"; } if (AreMappedPathsSupported(folder.FolderMappingID)) { return "true"; } return "false"; }
public override void RenameFolder(IFolderInfo folder, string newFolderName) { }
public bool HasPermission(IFolderInfo folder, string permissionKey) { var hasPermision = PortalSettings.Current.UserInfo.IsSuperUser; if (!hasPermision && folder != null) { hasPermision = FolderPermissionController.HasFolderPermission(folder.FolderPermissions, permissionKey); } return hasPermision; }
/// <summary> /// Get actual path to a folder /// </summary> /// <param name="folder">The folder</param> /// <returns>A windows supported path to the folder</returns> protected virtual string GetActualPath(IFolderInfo folder) { return(folder.PhysicalPath); }
protected virtual FolderViewModel GetFolderViewModel(IFolderInfo folder) { var folderName = string.IsNullOrEmpty(folder.FolderName) ? LocalizationHelper.GetString("RootFolder.Text") : folder.FolderName; var folderViewModel = new FolderViewModel { FolderID = folder.FolderID, FolderMappingID = folder.FolderMappingID, FolderName = folderName, FolderPath = folder.FolderPath, PortalID = folder.PortalID, LastModifiedOnDate = folder.LastModifiedOnDate.ToString("g"), IconUrl = GetFolderIconUrl(folder.PortalID, folder.FolderMappingID), Permissions = GetPermissionViewModelCollection(folder), HasChildren = folder.HasChildren }; folderViewModel.Attributes.Add(new KeyValuePair<string, object>("UnlinkAllowedStatus", GetUnlinkAllowedStatus(folder))); return folderViewModel; }
/// <summary> /// Moves a file to a new folder. /// </summary> /// <param name="file"></param> public virtual void MoveFile(IFileInfo file, IFolderInfo destinationFolder) { throw new NotImplementedException("This provider does not implement MoveFile"); }
private IEnumerable<PermissionViewModel> GetPermissionViewModelCollection(IFolderInfo folder) { // TODO Split permission between CE and PE packages string[] permissionKeys = { "ADD", "BROWSE", "COPY", "READ", "WRITE", "DELETE", "MANAGE", "VIEW", "FULLCONTROL" }; return permissionKeys.Select(permissionKey => new PermissionViewModel { Key = permissionKey, Value = HasPermission(folder, permissionKey) }).ToList(); }
/// <summary> /// Adds a new file to the specified folder. /// </summary> /// <remarks> /// Do not close content Stream. /// </remarks> public abstract void AddFile(IFolderInfo folder, string fileName, Stream content);
/// <summary> /// Get all Files and Put them in a DataTable for the GridView /// </summary> /// <param name="currentFolderInfo">The current folder info.</param> /// <returns> /// The File Table /// </returns> public DataTable GetFiles(IFolderInfo currentFolderInfo) { var filesTable = new DataTable(); filesTable.Columns.Add(new DataColumn("FileName", typeof(string))); filesTable.Columns.Add(new DataColumn("PictureURL", typeof(string))); filesTable.Columns.Add(new DataColumn("Info", typeof(string))); filesTable.Columns.Add(new DataColumn("FileId", typeof(int))); HttpRequest httpRequest = HttpContext.Current.Request; var type = "Link"; if (!string.IsNullOrEmpty(httpRequest.QueryString["Type"])) { type = httpRequest.QueryString["Type"]; } // Get Folder Info Secure? var isSecure = this.GetStorageLocationType(currentFolderInfo.FolderID).Equals( FolderController.StorageLocationTypes.SecureFileSystem); var isDatabaseSecure = this.GetStorageLocationType(currentFolderInfo.FolderID).Equals( FolderController.StorageLocationTypes.DatabaseSecure); var files = (List<IFileInfo>)FolderManager.Instance.GetFiles(currentFolderInfo); if (this.SortFilesDescending) { Utility.SortDescending(files, item => item.FileName); } foreach (var fileItem in files) { // Check if File Exists /*if (!File.Exists(string.Format("{0}{1}", fileItem.PhysicalPath, isSecure ? ".resources" : string.Empty))) { continue; }*/ var item = fileItem; var name = fileItem.FileName; var extension = fileItem.Extension; if (isSecure) { name = GetFileNameCleaned(name); extension = Path.GetExtension(name); } switch (type) { case "Image": { foreach (DataRow dr in from sAllowExt in this.allowedImageExt where name.ToLower().EndsWith(sAllowExt) select filesTable.NewRow()) { if (isSecure || isDatabaseSecure) { var link = string.Format("fileID={0}", fileItem.FileId); dr["PictureURL"] = Globals.LinkClick(link, int.Parse(this.request.QueryString["tabid"]), Null.NullInteger); } else { dr["PictureURL"] = MapUrl(fileItem.PhysicalPath); } dr["FileName"] = name; dr["FileId"] = item.FileId; dr["Info"] = string.Format( "<span class=\"FileName\">{0}</span><br /><span class=\"FileInfo\">Size: {1}</span><br /><span class=\"FileInfo\">Created: {2}</span>", name, fileItem.Size, fileItem.LastModificationTime); filesTable.Rows.Add(dr); } } break; case "Flash": { foreach (DataRow dr in from sAllowExt in this.allowedFlashExt where name.ToLower().EndsWith(sAllowExt) select filesTable.NewRow()) { dr["PictureURL"] = "images/types/swf.png"; dr["Info"] = string.Format( "<span class=\"FileName\">{0}</span><br /><span class=\"FileInfo\">Size: {1}</span><br /><span class=\"FileInfo\">Created: {2}</span>", name, fileItem.Size, fileItem.LastModificationTime); dr["FileName"] = name; dr["FileId"] = item.FileId; filesTable.Rows.Add(dr); } } break; default: { if (extension.StartsWith(".")) { extension = extension.Replace(".", string.Empty); } if (extension.Count() <= 1 || !this.extensionWhiteList.Contains(extension.ToLower())) { continue; } DataRow dr = filesTable.NewRow(); var imageExtension = string.Format("images/types/{0}.png", extension); if (File.Exists(this.MapPath(imageExtension))) { dr["PictureURL"] = imageExtension; } else { dr["PictureURL"] = "images/types/unknown.png"; } if (this.allowedImageExt.Any(sAllowImgExt => name.ToLower().EndsWith(sAllowImgExt))) { if (isSecure || isDatabaseSecure) { var link = string.Format("fileID={0}", fileItem.FileId); dr["PictureURL"] = Globals.LinkClick(link, int.Parse(this.request.QueryString["tabid"]), Null.NullInteger); } else { dr["PictureURL"] = MapUrl(fileItem.PhysicalPath); } } dr["FileName"] = name; dr["FileId"] = fileItem.FileId; dr["Info"] = string.Format( "<span class=\"FileName\">{0}</span><br /><span class=\"FileInfo\">Size: {1}</span><br /><span class=\"FileInfo\">Created: {2}</span>", name, fileItem.Size, fileItem.LastModificationTime); filesTable.Rows.Add(dr); } break; } } return filesTable; }
/// <summary> /// Deletes the specified folder. /// </summary> public abstract void DeleteFolder(IFolderInfo folder);
/// <summary> /// Set Folder Permission for the Current User /// </summary> /// <param name="folderInfo">The folder info.</param> /// <param name="currentUserInfo">The current user info.</param> private void SetUserFolderPermission(IFolderInfo folderInfo, UserInfo currentUserInfo) { if (FolderPermissionController.CanManageFolder((FolderInfo)folderInfo)) { return; } foreach ( var folderPermission in from PermissionInfo permission in PermissionController.GetPermissionsByFolder() where permission.PermissionKey.ToUpper() == "READ" || permission.PermissionKey.ToUpper() == "WRITE" || permission.PermissionKey.ToUpper() == "BROWSE" select new FolderPermissionInfo(permission) { FolderID = folderInfo.FolderID, UserID = currentUserInfo.UserID, RoleID = Null.NullInteger, AllowAccess = true }) { folderInfo.FolderPermissions.Add(folderPermission); } FolderPermissionController.SaveFolderPermissions((FolderInfo)folderInfo); }
/// <summary> /// Checks the existence of the specified file in the underlying system. /// </summary> /// <returns></returns> public abstract bool FileExists(IFolderInfo folder, string fileName);
private void Create_Click(object sender, EventArgs e) { var ps = Security.PortalSecurity.Instance; txtGroupName.Text = ps.InputFilter(txtGroupName.Text, Security.PortalSecurity.FilterFlag.NoScripting); txtGroupName.Text = ps.InputFilter(txtGroupName.Text, Security.PortalSecurity.FilterFlag.NoMarkup); txtDescription.Text = ps.InputFilter(txtDescription.Text, Security.PortalSecurity.FilterFlag.NoScripting); txtDescription.Text = ps.InputFilter(txtDescription.Text, Security.PortalSecurity.FilterFlag.NoMarkup); if (RoleController.Instance.GetRoleByName(PortalId, txtGroupName.Text) != null) { lblInvalidGroupName.Visible = true; return; } var modRoles = new List <RoleInfo>(); var modUsers = new List <UserInfo>(); foreach (ModulePermissionInfo modulePermissionInfo in ModulePermissionController.GetModulePermissions(ModuleId, TabId)) { if (modulePermissionInfo.PermissionKey == "MODGROUP" && modulePermissionInfo.AllowAccess) { if (modulePermissionInfo.RoleID > int.Parse(Globals.glbRoleNothing)) { modRoles.Add(RoleController.Instance.GetRoleById(PortalId, modulePermissionInfo.RoleID)); } else if (modulePermissionInfo.UserID > Null.NullInteger) { modUsers.Add(UserController.GetUserById(PortalId, modulePermissionInfo.UserID)); } } } var roleInfo = new RoleInfo() { PortalID = PortalId, RoleName = txtGroupName.Text, Description = txtDescription.Text, SecurityMode = SecurityMode.SocialGroup, Status = RoleStatus.Approved, IsPublic = rdAccessTypePublic.Checked }; var userRoleStatus = RoleStatus.Pending; if (GroupModerationEnabled) { roleInfo.Status = RoleStatus.Pending; userRoleStatus = RoleStatus.Pending; } else { userRoleStatus = RoleStatus.Approved; } var objModulePermissions = new ModulePermissionCollection(CBO.FillCollection(DataProvider.Instance().GetModulePermissionsByModuleID(ModuleId, -1), typeof(ModulePermissionInfo))); if (ModulePermissionController.HasModulePermission(objModulePermissions, "MODGROUP")) { roleInfo.Status = RoleStatus.Approved; userRoleStatus = RoleStatus.Approved; } var roleGroupId = DefaultRoleGroupId; if (roleGroupId < Null.NullInteger) { roleGroupId = Null.NullInteger; } roleInfo.RoleGroupID = roleGroupId; roleInfo.RoleID = RoleController.Instance.AddRole(roleInfo); roleInfo = RoleController.Instance.GetRoleById(PortalId, roleInfo.RoleID); var groupUrl = Globals.NavigateURL(GroupViewTabId, "", new String[] { "groupid=" + roleInfo.RoleID.ToString() }); if (groupUrl.StartsWith("http://") || groupUrl.StartsWith("https://")) { const int startIndex = 8; // length of https:// groupUrl = groupUrl.Substring(groupUrl.IndexOf("/", startIndex, StringComparison.InvariantCultureIgnoreCase)); } roleInfo.Settings.Add("URL", groupUrl); roleInfo.Settings.Add("GroupCreatorName", UserInfo.DisplayName); roleInfo.Settings.Add("ReviewMembers", chkMemberApproved.Checked.ToString()); RoleController.Instance.UpdateRoleSettings(roleInfo, true); if (inpFile.PostedFile != null && inpFile.PostedFile.ContentLength > 0) { IFileManager _fileManager = FileManager.Instance; IFolderManager _folderManager = FolderManager.Instance; var rootFolderPath = PathUtils.Instance.FormatFolderPath(PortalSettings.HomeDirectory); IFolderInfo groupFolder = _folderManager.GetFolder(PortalSettings.PortalId, "Groups/" + roleInfo.RoleID); if (groupFolder == null) { groupFolder = _folderManager.AddFolder(PortalSettings.PortalId, "Groups/" + roleInfo.RoleID); } if (groupFolder != null) { var fileName = Path.GetFileName(inpFile.PostedFile.FileName); var fileInfo = _fileManager.AddFile(groupFolder, fileName, inpFile.PostedFile.InputStream, true); roleInfo.IconFile = "FileID=" + fileInfo.FileId; RoleController.Instance.UpdateRole(roleInfo); } } var notifications = new Notifications(); RoleController.Instance.AddUserRole(PortalId, UserId, roleInfo.RoleID, userRoleStatus, true, Null.NullDate, Null.NullDate); if (roleInfo.Status == RoleStatus.Pending) { //Send notification to Group Moderators to approve/reject group. notifications.AddGroupNotification(Constants.GroupPendingNotification, GroupViewTabId, ModuleId, roleInfo, UserInfo, modRoles, modUsers); } else { //Send notification to Group Moderators informing of new group. notifications.AddGroupNotification(Constants.GroupCreatedNotification, GroupViewTabId, ModuleId, roleInfo, UserInfo, modRoles, modUsers); //Add entry to journal. GroupUtilities.CreateJournalEntry(roleInfo, UserInfo); } Response.Redirect(Globals.NavigateURL(GroupViewTabId, "", new String[] { "groupid=" + roleInfo.RoleID.ToString() })); }
/// <summary> /// Gets the list of file names contained in the specified folder. /// </summary> /// <returns></returns> public abstract string[] GetFiles(IFolderInfo folder);
/// <summary> /// Gets a file Stream of the specified file. /// </summary> /// <returns></returns> public virtual Stream GetFileStream(IFolderInfo folder, IFileInfo file, int version) { return(this.GetFileStream(folder, FileVersionController.GetVersionedFilename(file, version))); }
internal static bool CanEdit(IFolderInfo folder) => folder != null && FolderPermissionController.CanAddFolder(folder as FolderInfo);