This example demonstrates how to create a custom file system provider and assign permissions to each folder or file.
This example uses two tables. The first one - FileSystemItems - contains all the files and folders. The second one - PermissionsSet - contains all the permissions assigned to folders or files.
It is required only to create a custom FileSystem provider and additionally override the GetFilePermissions and GetFolderPermissions methods that are used to gather permissions.
Files to Review
- CustomFileSystemProvider.cs (VB: CustomFileSystemProvider.vb)
- DataProvider.cs (VB: DataProvider.vb)
- Model.cs (VB: Model.vb)
- Default.aspx (VB: Default.aspx)
- Default.aspx.cs (VB: Default.aspx.vb)
Documentation
Example Code
C#using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Web;
using DevExpress.Web;
public class CustomFileSystemProvider : FileSystemProviderBase {
public DataProvider Data { get; set; }
Dictionary<int, CacheEntry> FolderCache { get; set; }
FileSystemItem RootItem { get; set; }
public CustomFileSystemProvider(string rootFolder)
: base(rootFolder) {
var dbContext = new FilesDbContext();
Data = new DataProvider(dbContext);
RefreshFolderCache();
}
public override string RootFolderDisplayName { get { return RootItem.Name; } }
public override IEnumerable<FileManagerFile> GetFiles(FileManagerFolder folder) {
int folderId = GetItemId(folder);
return Data.FileSystemItems.
Join(Data.PermissionsSet, i => i.Id, p => p.Item.Id, (i, pi) => new {
Item = i,
Permissions = pi
}).
Where(dto => dto.Item.Parent != null && dto.Item.Parent.Id == folderId && !dto.Item.IsFolder).
ToList().
Select(dto => new FileManagerFile(this, folder, dto.Item.Name, dto.Item.Id.ToString(), new FileManagerFileProperties {
Permissions = GetFilePermissionsInternal(dto.Permissions)
}));
}
public override IEnumerable<FileManagerFolder> GetFolders(FileManagerFolder parentFolder) {
FileSystemItem folderItem = FindFolderItem(parentFolder);
return FolderCache.Values.
Where(entry => entry.Item.Parent == folderItem && entry.Item.IsFolder).
Select(entry => new FileManagerFolder(this, parentFolder, entry.Item.Name, entry.Item.Id.ToString(),
new FileManagerFolderProperties {
Permissions = GetFolderPermissionsInternal(entry.Permissions)
}));
}
public override FileManagerFilePermissions GetFilePermissions(FileManagerFile file) {
int fileId = int.Parse(file.Id);
Permissions permissions = Data.PermissionsSet.FirstOrDefault(p => p.Item.Id == fileId);
if(permissions == null)
return FileManagerFilePermissions.Default;
return GetFilePermissionsInternal(permissions);
}
public override FileManagerFolderPermissions GetFolderPermissions(FileManagerFolder folder) {
if(string.IsNullOrEmpty(folder.RelativeName))
return FileManagerFolderPermissions.Default;
int folderId = int.Parse(folder.Id);
Permissions permissions = Data.PermissionsSet.FirstOrDefault(p => p.Item.Id == folderId);
if(permissions == null)
return FileManagerFolderPermissions.Default;
return GetFolderPermissionsInternal(permissions);
}
FileManagerFilePermissions GetFilePermissionsInternal(Permissions permissions) {
return (permissions.Delete ? FileManagerFilePermissions.Delete : FileManagerFilePermissions.Default)
| (permissions.Move ? FileManagerFilePermissions.Move : FileManagerFilePermissions.Default)
| (permissions.Copy ? FileManagerFilePermissions.Copy : FileManagerFilePermissions.Default)
| (permissions.Rename ? FileManagerFilePermissions.Rename : FileManagerFilePermissions.Default)
| (permissions.Download ? FileManagerFilePermissions.Download : FileManagerFilePermissions.Default);
}
FileManagerFolderPermissions GetFolderPermissionsInternal(Permissions permissions) {
return (permissions.Delete ? FileManagerFolderPermissions.Delete : FileManagerFolderPermissions.Default)
| (permissions.Move ? FileManagerFolderPermissions.Move : FileManagerFolderPermissions.Default)
| (permissions.Copy ? FileManagerFolderPermissions.Copy : FileManagerFolderPermissions.Default)
| (permissions.Rename ? FileManagerFolderPermissions.Rename : FileManagerFolderPermissions.Default)
| (permissions.Create ? FileManagerFolderPermissions.Create : FileManagerFolderPermissions.Default)
| (permissions.Upload ? FileManagerFolderPermissions.Upload : FileManagerFolderPermissions.Default)
| (permissions.MoveOrCopyInto ? FileManagerFolderPermissions.MoveOrCopyInto : FileManagerFolderPermissions.Default);
}
public override bool Exists(FileManagerFile file) {
return FindFileItem(file) != null;
}
public override bool Exists(FileManagerFolder folder) {
return FindFolderItem(folder) != null;
}
public override Stream ReadFile(FileManagerFile file) {
FileSystemItem fileItem = FindFileItem(file);
return new MemoryStream(fileItem.Content.ToArray());
}
public override DateTime GetLastWriteTime(FileManagerFile file) {
FileSystemItem fileItem = FindFileItem(file);
return fileItem.LastWriteTime;
}
public override DateTime GetLastWriteTime(FileManagerFolder folder) {
FileSystemItem folderItem = FindFolderItem(folder);
return folderItem.LastWriteTime;
}
public override long GetLength(FileManagerFile file) {
FileSystemItem fileItem = FindFileItem(file);
return fileItem.Content.Length;
}
public override void CreateFolder(FileManagerFolder parent, string name) {
UpdateAndSaveChanges(parent, parentItem => Data.CreateFolder(parentItem, name));
}
public override void DeleteFile(FileManagerFile file) {
UpdateAndSubmitChanges(file, item => Data.Remove(item));
}
public override void DeleteFolder(FileManagerFolder folder) {
UpdateAndSaveChanges(folder, item => Data.Remove(item));
}
public override void MoveFile(FileManagerFile file, FileManagerFolder newParentFolder) {
UpdateAndSubmitChanges(file, item => item.Parent = FindFolderItem(newParentFolder));
}
public override void MoveFolder(FileManagerFolder folder, FileManagerFolder newParentFolder) {
UpdateAndSaveChanges(folder, item => item.Parent = FindFolderItem(newParentFolder));
}
public override void RenameFile(FileManagerFile file, string name) {
UpdateAndSubmitChanges(file, item => item.Name = name);
}
public override void RenameFolder(FileManagerFolder folder, string name) {
UpdateAndSaveChanges(folder, item => item.Name = name);
}
public override void UploadFile(FileManagerFolder folder, string fileName, Stream content) {
UpdateAndSaveChanges(folder, folderItem => Data.CreateFile(folderItem, fileName, content));
}
public override void CopyFile(FileManagerFile file, FileManagerFolder newParentFolder) {
FileSystemItem fileItem = FindFileItem(file);
CopyCore(fileItem, newParentFolder.RelativeName, false);
}
public override void CopyFolder(FileManagerFolder folder, FileManagerFolder newParentFolder) {
List<FileManagerFolder> folders = new List<FileManagerFolder>();
FillSubFoldersList(folder, folders);
int folderNameOffset = !string.IsNullOrEmpty(folder.Parent.RelativeName) ? folder.Parent.RelativeName.Length + 1 : 0;
foreach(FileManagerFolder copyingFolder in folders) {
FileSystemItem folderItem = FindFolderItem(copyingFolder);
string folderPath = newParentFolder.RelativeName;
if(copyingFolder != folder)
folderPath = Path.Combine(folderPath, copyingFolder.Parent.RelativeName.Substring(folderNameOffset));
CopyCore(folderItem, folderPath, true);
foreach(FileManagerFile currentFile in copyingFolder.GetFiles()) {
FileSystemItem fileItem = FindFileItem(currentFile);
CopyCore(fileItem, Path.Combine(folderPath, copyingFolder.Name), false);
}
}
}
void FillSubFoldersList(FileManagerFolder folder, List<FileManagerFolder> list) {
list.Add(folder);
foreach(FileManagerFolder subFolder in folder.GetFolders())
FillSubFoldersList(subFolder, list);
}
void CopyCore(FileSystemItem item, string path, bool isFolder) {
FileManagerFolder newParentFolder = new FileManagerFolder(this, path, (string)null);
UpdateAndSaveChanges(newParentFolder,
newParentItem => {
if(isFolder)
Data.CreateFolder(newParentItem, item.Name);
else
Data.CreateFile(newParentItem, item.Name, item.Content);
});
}
protected void UpdateAndSubmitChanges(FileManagerFile file, Action<FileSystemItem> update) {
UpdateAndSubmitChangesCore(FindFileItem(file), update);
}
protected void UpdateAndSaveChanges(FileManagerFolder folder, Action<FileSystemItem> update) {
UpdateAndSubmitChangesCore(FindFolderItem(folder), update);
}
protected void UpdateAndSubmitChangesCore(FileSystemItem item, Action<FileSystemItem> update) {
update(item);
Data.SaveChanges();
RefreshFolderCache();
}
protected FileSystemItem FindFileItem(FileManagerFile file) {
if(file.Id == null)
return FindFileItemByParentFolder(file.Name, file.Folder);
int fileId = GetItemId(file);
return Data.FindById(fileId);
}
protected FileSystemItem FindFolderItem(FileManagerFolder folder) {
if(folder.Id == null)
return FindFolderItemByRelativeName(folder);
int folderId = GetItemId(folder);
return FolderCache[folderId].Item;
}
protected FileSystemItem FindFileItemByParentFolder(string itemName, FileManagerFolder parentFolder) {
FileSystemItem parentItem = FindFolderItemByRelativeName(parentFolder);
return Data.FileSystemItems.FirstOrDefault(
item => item.Parent != null && item.Parent.Id == parentItem.Id && !item.IsFolder && item.Name == itemName);
}
protected int GetItemId(FileManagerItem fileManagerItem) {
if(string.IsNullOrEmpty(fileManagerItem.RelativeName))
return RootItem.Id;
return int.Parse(fileManagerItem.Id);
}
protected FileSystemItem FindFolderItemByRelativeName(FileManagerFolder folder) {
return FolderCache.Values.
Select(entry => entry.Item).
Where(item => item.IsFolder && GetRelativeName(item) == folder.RelativeName).
FirstOrDefault();
}
protected string GetRelativeName(FileSystemItem folderItem) {
if(folderItem.Parent == null)
return string.Empty;
if(folderItem.Parent.Parent == null)
return folderItem.Name;
string name = GetRelativeName(folderItem.Parent);
return Path.Combine(name, folderItem.Name);
}
protected void RefreshFolderCache() {
FolderCache = Data.FileSystemItems.
Join(Data.PermissionsSet, i => i.Id, p => p.Item.Id, (i, pi) => new {
Item = i,
Permissions = pi
}).
Where(dto => dto.Item.IsFolder).
ToDictionary(dto => dto.Item.Id, dto => new CacheEntry {
Item = dto.Item,
Permissions = dto.Permissions
});
RootItem = FolderCache.Values.
Select(entry => entry.Item).
First(item => item.Parent == null);
}
class CacheEntry {
public FileSystemItem Item { get; set; }
public Permissions Permissions { get; set; }
}
}
C#using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Web;
using System.Web.Configuration;
using System.Data.Common;
using System.Data.Entity;
using System.Data.Entity.SqlServer;
using System.Runtime.Remoting.Messaging;
public class FilesDbContext : DbContext {
const string ConnectionStringName = "FilesConnectionString";
static string ConnectionString {
get {
return WebConfigurationManager.ConnectionStrings[ConnectionStringName].ConnectionString;
}
}
public FilesDbContext()
: base(ConnectionString) {
Database.SetInitializer<FilesDbContext>(new SampleDataInitializer());
}
public DbSet<FileSystemItem> FileSystemItems { get; set; }
public DbSet<Permissions> PermissionsSet { get; set; }
protected override void OnModelCreating(DbModelBuilder modelBuilder) {
var itemConfig = modelBuilder.Entity<FileSystemItem>();
itemConfig.HasKey(i => i.Id);
itemConfig.Property(i => i.Name).IsRequired();
itemConfig.Property(i => i.IsFolder).IsRequired();
itemConfig.Property(i => i.LastWriteTime).IsRequired();
itemConfig.Property(i => i.Size).IsRequired();
itemConfig.Property(i => i.Content).IsOptional();
itemConfig.HasOptional(i => i.Parent);
var permissionConfig = modelBuilder.Entity<Permissions>();
permissionConfig.HasKey(p => p.Id);
permissionConfig.HasRequired(p => p.Item);
permissionConfig.Property(p => p.Rename).IsRequired();
permissionConfig.Property(p => p.Move).IsRequired();
permissionConfig.Property(p => p.Copy).IsRequired();
permissionConfig.Property(p => p.Delete).IsRequired();
permissionConfig.Property(p => p.Download).IsRequired();
permissionConfig.Property(p => p.Create).IsRequired();
permissionConfig.Property(p => p.MoveOrCopyInto).IsRequired();
base.OnModelCreating(modelBuilder);
}
}
public class DataProvider {
static Random Random { get; set; }
public FilesDbContext DbContext { get; set; }
public IQueryable<FileSystemItem> FileSystemItems { get { return DbContext.FileSystemItems; } }
public IQueryable<Permissions> PermissionsSet { get { return DbContext.PermissionsSet; } }
public DataProvider(FilesDbContext dbContext) {
DbContext = dbContext;
}
public void SaveChanges() {
DbContext.SaveChanges();
}
public FileSystemItem FindById(int id) {
return DbContext.FileSystemItems.Find(id);
}
public FileSystemItem CreateFolder(FileSystemItem parent, string name) {
var folder = new FileSystemItem { Name = name, Parent = parent, IsFolder = true, LastWriteTime = DateTime.UtcNow };
DbContext.FileSystemItems.Add(folder);
CreateRandomFolderPermissions(folder);
return folder;
}
//with permissions
public FileSystemItem CreateFolder(FileSystemItem parent, string name, Permissions permissions) {
var folder = new FileSystemItem { Name = name, Parent = parent, IsFolder = true, LastWriteTime = DateTime.UtcNow };
DbContext.FileSystemItems.Add(folder);
CreateFolderPermissions(folder, permissions);
return folder;
}
public FileSystemItem CreateFile(FileSystemItem parent, string name, string content, Permissions permissions) {
byte[] bytes = System.Text.Encoding.Default.GetBytes(content);
return CreateFile(parent, name, bytes, permissions);
}
public FileSystemItem CreateFile(FileSystemItem parent, string name, Stream content, Permissions permissions) {
byte[] bytes = ReadAllBytes(content);
return CreateFile(parent, name, bytes, permissions);
}
public FileSystemItem CreateFile(FileSystemItem parent, string name, byte[] content, Permissions permissions) {
var file = new FileSystemItem { Name = name, Parent = parent, LastWriteTime = DateTime.UtcNow };
file.Content = content;
file.Size = file.Content.Length;
DbContext.FileSystemItems.Add(file);
CreateFilePermissions(file, permissions);
return file;
}
//without permissions
public FileSystemItem CreateFile(FileSystemItem parent, string name, string content) {
byte[] bytes = System.Text.Encoding.Default.GetBytes(content);
return CreateFile(parent, name, bytes);
}
public FileSystemItem CreateFile(FileSystemItem parent, string name, Stream content) {
byte[] bytes = ReadAllBytes(content);
return CreateFile(parent, name, bytes);
}
public FileSystemItem CreateFile(FileSystemItem parent, string name, byte[] content) {
var file = new FileSystemItem { Name = name, Parent = parent, LastWriteTime = DateTime.UtcNow };
file.Content = content;
file.Size = file.Content.Length;
DbContext.FileSystemItems.Add(file);
CreateRandomFilePermissions(file);
return file;
}
public void Remove(FileSystemItem item) {
DbContext.FileSystemItems.Remove(item);
}
//with permissions
void CreateFolderPermissions(FileSystemItem folder, Permissions permissions) {
permissions.Item = folder;
DbContext.PermissionsSet.Add(permissions);
}
//without permissions and random permissions
void CreateRandomFolderPermissions(FileSystemItem folder) {
var permissions = new Permissions {
Rename = GetRandomBoolean(),
Move = GetRandomBoolean(),
Copy = GetRandomBoolean(),
Delete = GetRandomBoolean(),
Create = GetRandomBoolean(),
Upload = GetRandomBoolean(),
MoveOrCopyInto = GetRandomBoolean()
};
permissions.Item = folder;
DbContext.PermissionsSet.Add(permissions);
}
//with permissions
void CreateFilePermissions(FileSystemItem file, Permissions permissions) {
permissions.Item = file;
DbContext.PermissionsSet.Add(permissions);
}
//without permissions
void CreateRandomFilePermissions(FileSystemItem file) {
var permissions = new Permissions {
Rename = GetRandomBoolean(),
Move = GetRandomBoolean(),
Copy = GetRandomBoolean(),
Delete = GetRandomBoolean(),
Download = GetRandomBoolean()
};
permissions.Item = file;
DbContext.PermissionsSet.Add(permissions);
}
byte[] ReadAllBytes(Stream stream) {
using(MemoryStream ms = new MemoryStream()) {
stream.CopyTo(ms);
return ms.ToArray();
}
}
bool GetRandomBoolean() {
if(Random == null)
Random = new Random();
return Random.NextDouble() > 0.5;
}
}
public class SampleDataInitializer : CreateDatabaseIfNotExists<FilesDbContext> {
protected override void Seed(FilesDbContext context) {
base.Seed(context);
var data = new DataProvider(context);
FileSystemItem root = data.CreateFolder(null, "Root",
new Permissions() {
Rename = true,
Move = true,
Copy = false,
Delete = false,
Download = false,
Create = false,
Upload = false,
MoveOrCopyInto = true
});
FileSystemItem folder1 = data.CreateFolder(root, "Folder 1",
new Permissions() {
Rename = true,
Move = true,
Copy = false,
Delete = true,
Download = false,
Create = false,
Upload = false,
MoveOrCopyInto = true
});
FileSystemItem folder2 = data.CreateFolder(root, "Folder 2",
new Permissions() {
Rename = false,
Move = false,
Copy = false,
Delete = false,
Download = false,
Create = true,
Upload = true,
MoveOrCopyInto = true
});
FileSystemItem subFolder1 = data.CreateFolder(folder1, "Subfolder 1",
new Permissions() {
Rename = false,
Move = false,
Copy = false,
Delete = true,
Download = false,
Create = true,
Upload = true,
MoveOrCopyInto = true
});
data.CreateFile(folder1, "File 1.txt", "Content 1",
new Permissions() {
Rename = false,
Move = false,
Copy = false,
Delete = true,
Download = true,
Create = false,
Upload = false,
MoveOrCopyInto = false
});
data.CreateFile(folder1, "File 2.txt", "Content 2",
new Permissions() {
Rename = true,
Move = true,
Copy = false,
Delete = false,
Download = false,
Create = false,
Upload = false,
MoveOrCopyInto = true
});
data.CreateFile(folder1, "File 3.txt", "Content 3",
new Permissions() {
Rename = true,
Move = true,
Copy = false,
Delete = true,
Download = true,
Create = false,
Upload = false,
MoveOrCopyInto = false
});
data.CreateFile(folder2, "Project 1.txt", "Content 1",
new Permissions() {
Rename = false,
Move = false,
Copy = true,
Delete = true,
Download = true,
Create = false,
Upload = false,
MoveOrCopyInto = false
});
data.CreateFile(folder2, "Project 2.txt", "Content 2",
new Permissions() {
Rename = true,
Move = false,
Copy = true,
Delete = false,
Download = true,
Create = false,
Upload = false,
MoveOrCopyInto = false
});
data.CreateFile(folder2, "Project 3.txt", "Content 3",
new Permissions() {
Rename = false,
Move = false,
Copy = false,
Delete = true,
Download = true,
Create = false,
Upload = false,
MoveOrCopyInto = false
});
data.CreateFile(subFolder1, "Doc 1.txt", "Content 1",
new Permissions() {
Rename = true,
Move = false,
Copy = true,
Delete = true,
Download = false,
Create = false,
Upload = false,
MoveOrCopyInto = false
});
data.CreateFile(subFolder1, "Doc 2.txt", "Content 2",
new Permissions() {
Rename = false,
Move = false,
Copy = false,
Delete = false,
Download = true,
Create = false,
Upload = false,
MoveOrCopyInto = false
});
data.CreateFile(subFolder1, "Doc 3.txt", "Content 3",
new Permissions() {
Rename = true,
Move = false,
Copy = false,
Delete = false,
Download = false,
Create = false,
Upload = false,
MoveOrCopyInto = false
});
data.SaveChanges();
}
}
C#using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
public class FileSystemItem {
public int Id { get; set; }
public string Name { get; set; }
public bool IsFolder { get; set; }
public DateTime LastWriteTime { get; set; }
public long Size { get; set; }
public byte[] Content { get; set; }
public FileSystemItem Parent { get; set; }
}
public class Permissions {
public int Id { get; set; }
public virtual FileSystemItem Item { get; set; }
public bool Rename { get; set; }
public bool Move { get; set; }
public bool Copy { get; set; }
public bool Delete { get; set; }
public bool Download { get; set; }
public bool Create { get; set; }
public bool Upload { get; set; }
public bool MoveOrCopyInto { get; set; }
}
ASPx<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<%@ Register Assembly="DevExpress.Web.v17.2, Version=17.2.18.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a" Namespace="DevExpress.Web" TagPrefix="dx" %>
<%@ Register Assembly="DevExpress.Web.ASPxTreeList.v17.2, Version=17.2.18.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a" Namespace="DevExpress.Web.ASPxTreeList" TagPrefix="dx" %>
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
<script>
function onFocusedNodeChanged(s, e) {
grid.PerformCallback(s.GetFocusedNodeKey());
}
var command;
function onBeginCallback(s, e) {
if (e.command === "UPDATEEDIT")
command = e.command;
else
command = undefined;
}
function onEndCallback(s, e) {
if (command === "UPDATEEDIT")
fileManger.Refresh();
if (s.cp_SetVisible == true)
s.SetVisible(true);
else
s.SetVisible(false);
}
function onFileUploaded(s, e) {
RefreshTreeAndGrid();
}
function onFolderCreated(s, e) {
RefreshTreeAndGrid();
}
function onItemCopied(s, e) {
RefreshTreeAndGrid();
}
function onItemDeleted(s, e) {
RefreshTreeAndGrid();
}
function onItemMoved(s, e) {
RefreshTreeAndGrid();
}
function onItemRenamed(s, e) {
RefreshTreeAndGrid();
}
function RefreshTreeAndGrid() {
treeList.PerformCallback();
grid.Refresh();
}
</script>
</head>
<body>
<form id="form1" runat="server">
<dx:ASPxFileManager runat="server" ID="FileManager" ClientInstanceName="fileManger"
CustomFileSystemProviderTypeName="CustomFileSystemProvider" Height="340"
OnFileUploading="ASPxFileManager1_FileUploading"
OnFolderCreating="ASPxFileManager1_FolderCreating"
OnItemDeleting="ASPxFileManager1_ItemDeleting"
OnItemMoving="ASPxFileManager1_ItemMoving"
OnItemRenaming="ASPxFileManager1_ItemRenaming"
OnItemCopying="ASPxFileManager1_ItemCopying">
<Settings ThumbnailFolder="~/Thumb" />
<SettingsEditing AllowCopy="true" AllowMove="true" AllowRename="true" AllowDelete="true"
AllowCreate="true" AllowDownload="true" />
<SettingsUpload Enabled="true" />
<SettingsPermissions>
<AccessRules>
<dx:FileManagerFolderAccessRule Edit="Deny" />
<dx:FileManagerFileAccessRule Path="*" Download="Deny" />
</AccessRules>
</SettingsPermissions>
<ClientSideEvents FileUploaded="onFileUploaded" FolderCreated="onFolderCreated" ItemCopied="onItemCopied"
ItemDeleted="onItemDeleted" ItemMoved="onItemMoved" ItemRenamed="onItemRenamed" />
</dx:ASPxFileManager>
<br />
Use this treelist and grid to change permissions of files and folders on the fly
<br />
<br />
<table>
<tr>
<td>
<dx:ASPxTreeList ID="tree" runat="server" DataSourceID="ds" KeyFieldName="Id" ClientInstanceName="treeList"
ParentFieldName="Parent.Id"
AutoGenerateColumns="false" OnDataBound="tree_DataBound" Width="450" OnCustomCallback="tree_CustomCallback">
<Columns>
<dx:TreeListDataColumn FieldName="Name"></dx:TreeListDataColumn>
<dx:TreeListDataColumn FieldName="IsFolder"></dx:TreeListDataColumn>
</Columns>
<SettingsBehavior AllowFocusedNode="true" />
<ClientSideEvents FocusedNodeChanged="onFocusedNodeChanged" />
</dx:ASPxTreeList>
</td>
<td>
<br />
</td>
<td>
<dx:ASPxGridView ID="grid" runat="server" DataSourceID="dsPermissions" ClientInstanceName="grid" OnCustomCallback="grid_CustomCallback"
KeyFieldName="Id" AutoGenerateColumns="true" OnDataBound="grid_DataBound" OnBatchUpdate="grid_BatchUpdate" OnRowValidating="grid_RowValidating"
ClientVisible="false">
<SettingsEditing Mode="Batch"></SettingsEditing>
<ClientSideEvents BeginCallback="onBeginCallback" EndCallback="onEndCallback" />
</dx:ASPxGridView>
</td>
</tr>
</table>
<ef:EntityDataSource ID="ds" runat="server" ContextTypeName="FilesDbContext" EntitySetName="FileSystemItems"></ef:EntityDataSource>
<ef:EntityDataSource ID="dsPermissions" runat="server" ContextTypeName="FilesDbContext"
EntitySetName="PermissionsSet" Where="it.Item.Id = @IdParam" EnableUpdate="true">
<WhereParameters>
<asp:SessionParameter Name="IdParam" SessionField="IdParam" Type="Int32" DefaultValue="1" />
</WhereParameters>
</ef:EntityDataSource>
</form>
</body>
</html>
C#using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using DevExpress.Web;
using System.Data.SqlClient;
using System.Web.Configuration;
using System.Data;
public partial class _Default : System.Web.UI.Page {
protected void Page_Init(object sender, EventArgs e) {
}
protected void tree_DataBound(object sender, EventArgs e) {
tree.ExpandAll();
}
bool IsItemIdFocused = false;
protected void grid_CustomCallback(object sender, ASPxGridViewCustomCallbackEventArgs e) {
Session["IdParam"] = e.Parameters;
grid.DataBind();
}
protected void grid_DataBound(object sender, EventArgs e) {
grid.Columns["Id"].Visible = false;
grid.Columns["Item.Id"].Visible = false;
grid.Columns["Item"].Visible = false;
if((bool)tree.FocusedNode["IsFolder"]) {
grid.Columns["Download"].Visible = false;
grid.Columns["Create"].Visible = true;
grid.Columns["Upload"].Visible = true;
grid.Columns["MoveOrCopyInto"].Visible = true;
}
else {
grid.Columns["Download"].Visible = true;
grid.Columns["Create"].Visible = false;
grid.Columns["Upload"].Visible = false;
grid.Columns["MoveOrCopyInto"].Visible = false;
}
if (Session["IdParam"] == null || Session["IdParam"].ToString() == "1")
grid.JSProperties["cp_SetVisible"] = false;
else
grid.JSProperties["cp_SetVisible"] = true;
}
//the following operations are cancelled - to allow them, remove the ValidateSiteMode method
protected void ASPxFileManager1_ItemDeleting(object source, DevExpress.Web.FileManagerItemDeleteEventArgs e) {
ValidateSiteMode(e);
}
protected void ASPxFileManager1_ItemMoving(object source, DevExpress.Web.FileManagerItemMoveEventArgs e) {
ValidateSiteMode(e);
}
protected void ASPxFileManager1_ItemRenaming(object source, DevExpress.Web.FileManagerItemRenameEventArgs e) {
ValidateSiteMode(e);
}
protected void ASPxFileManager1_FolderCreating(object source, DevExpress.Web.FileManagerFolderCreateEventArgs e) {
ValidateSiteMode(e);
}
protected void ASPxFileManager1_FileUploading(object source, DevExpress.Web.FileManagerFileUploadEventArgs e) {
ValidateSiteMode(e);
}
protected void ASPxFileManager1_ItemCopying(object source, FileManagerItemCopyEventArgs e) {
ValidateSiteMode(e);
}
protected void ValidateSiteMode(FileManagerActionEventArgsBase e) {
e.Cancel = true;
e.ErrorText = "Data modifications are not allowed in the example.";
}
protected void grid_BatchUpdate(object sender, DevExpress.Web.Data.ASPxDataBatchUpdateEventArgs e) {
//data modifications are not allowed in examples - to enable them, remove the following code
e.Handled = true;
}
protected void grid_RowValidating(object sender, DevExpress.Web.Data.ASPxDataValidationEventArgs e) {
e.RowError = "Data modifications are not allowed in examples";
}
protected void tree_CustomCallback(object sender, DevExpress.Web.ASPxTreeList.TreeListCustomCallbackEventArgs e) {
tree.Nodes[0].Focus();
tree.DataBind();
}
}