示例#1
0
        public FileExplorerResponse Remove(string[] names, string path)
        {
            FileExplorerResponse DeleteResponse = new FileExplorerResponse();

            try
            {
                string physicalPath = GetPath(path);
                List <FileAccessRules> FilesPermission = new List <FileAccessRules>();
                for (int i = 0; i < names.Length; i++)
                {
                    FileAccessRules permission = GetFilePermission(physicalPath, names[i], IsFile(CombineRelativePath(path, names[i])));
                    if (!permission.Read || !permission.Edit)
                    {
                        throw new ArgumentException("'" + path + names[i] + "' is not accessible. Access is denied.");
                    }
                    FilesPermission.Add(permission);
                }
                DeleteResponse = FileExplorerOperations.Remove(names, path);
                var items = DeleteResponse.files.ToArray();
                for (int i = 0; i < items.Length; i++)
                {
                    items[i].permission = FilesPermission[i];
                }
                DeleteResponse.files = items;
                return(DeleteResponse);
            }
            catch (Exception e)
            {
                DeleteResponse.error = e.GetType().FullName + ", " + e.Message;
                return(DeleteResponse);
            }
        }
示例#2
0
        public FileExplorerResponse Paste(string sourceDir, string backupDir, string[] names, string option, IEnumerable <CommonFileDetails> commonFiles)
        {
            FileExplorerResponse PasteResponse = new FileExplorerResponse();

            try
            {
                string phyPath = GetPath(sourceDir);
                for (int i = 0; i < names.Length; i++)
                {
                    FileAccessRules FilePermission = GetFilePermission(phyPath, names[i], IsFile(CombineRelativePath(sourceDir, names[i])));
                    if (!FilePermission.Read || !FilePermission.Copy)
                    {
                        throw new ArgumentException("'" + sourceDir + names[i] + "' is not accessible. Access is denied.");
                    }
                }
                FileAccessRules PathPermission = GetPathPermission(backupDir);
                if (!PathPermission.Read || !PathPermission.EditContents)
                {
                    throw new ArgumentException("'" + backupDir + "' is not accessible. Access is denied.");
                }
                PasteResponse       = FileExplorerOperations.Paste(sourceDir, backupDir, names, option, commonFiles);
                PasteResponse.files = SetPermission(backupDir, PasteResponse.files);
                return(PasteResponse);
            }
            catch (Exception e)
            {
                PasteResponse.error = e.GetType().FullName + ", " + e.Message;
                return(PasteResponse);
            }
        }
示例#3
0
 public FileAccessRules UpdateFileRules(FileAccessRules filePermission, AccessRule fileRule)
 {
     filePermission.Copy     = HasPermission(fileRule.Copy);
     filePermission.Download = HasPermission(fileRule.Download);
     filePermission.Edit     = HasPermission(fileRule.Edit);
     filePermission.Read     = HasPermission(fileRule.Read);
     return(filePermission);
 }
示例#4
0
 public FileAccessRules UpdateFolderRules(FileAccessRules filePermission, AccessRule folderRule)
 {
     filePermission.Copy         = HasPermission(folderRule.Copy);
     filePermission.Edit         = HasPermission(folderRule.Edit);
     filePermission.EditContents = HasPermission(folderRule.EditContents);
     filePermission.Read         = HasPermission(folderRule.Read);
     filePermission.Upload       = HasPermission(folderRule.Upload);
     return(filePermission);
 }
示例#5
0
        public void Upload(HttpFileCollection files, string path)
        {
            FileAccessRules PathPermission = GetPathPermission(path);

            if (!PathPermission.Read || !PathPermission.Upload)
            {
                throw new ArgumentNullException("'" + path + "' is not accessible. Access is denied.");
            }
            FileExplorerOperations.Upload(files, path);
        }
示例#6
0
        public void Download(string path, string[] names)
        {
            string physicalPath = GetPath(path);

            for (int i = 0; i < names.Length; i++)
            {
                FileAccessRules FilePermission = GetFilePermission(physicalPath, names[i], true);
                if (!FilePermission.Read || !FilePermission.Download)
                {
                    throw new ArgumentNullException("'" + path + names[i] + "' is not accessible. Access is denied.");
                }
            }
            FileExplorerOperations.Download(path, names);
        }
示例#7
0
        public FileExplorerResponse NewFolder(string path, string name)
        {
            FileExplorerResponse CreateResponse = new FileExplorerResponse();

            try
            {
                FileAccessRules PathPermission = GetPathPermission(path);
                if (!PathPermission.Read || !PathPermission.EditContents)
                {
                    throw new ArgumentException("'" + path + "' is not accessible. Access is denied.");
                }
                CreateResponse       = FileExplorerOperations.NewFolder(path, name);
                CreateResponse.files = SetPermission(path, CreateResponse.files);
                return(CreateResponse);
            }
            catch (Exception e)
            {
                CreateResponse.error = e.GetType().FullName + ", " + e.Message;
                return(CreateResponse);
            }
        }
示例#8
0
        public FileExplorerResponse Rename(string path, string oldName, string newName, IEnumerable <CommonFileDetails> commonFiles)
        {
            FileExplorerResponse RenameResponse = new FileExplorerResponse();

            try
            {
                FileAccessRules FilePermission = GetFilePermission(GetPath(path), oldName, IsFile(CombineRelativePath(path, oldName)));
                if (!FilePermission.Read || !FilePermission.Edit)
                {
                    throw new ArgumentException("'" + path + oldName + "' is not accessible. Access is denied.");
                }
                RenameResponse       = FileExplorerOperations.Rename(path, oldName, newName, commonFiles);
                RenameResponse.files = SetPermission(path, RenameResponse.files);
                return(RenameResponse);
            }
            catch (Exception e)
            {
                RenameResponse.error = e.GetType().FullName + ", " + e.Message;
                return(RenameResponse);
            }
        }
示例#9
0
        public FileExplorerResponse Search(string path, string filter, string searchString, bool caseSensitive)
        {
            FileExplorerResponse SearchResponse = new FileExplorerResponse();

            try
            {
                string          physicalPath   = GetPath(path);
                FileAccessRules RootPermission = GetPathPermission(path);
                if (!RootPermission.Read)
                {
                    throw new ArgumentException("'" + path + "' is not accessible. Access is denied.");
                }
                SearchResponse = FileExplorerOperations.Search(path, filter, searchString, caseSensitive);
                var items = SearchResponse.files.ToArray();
                for (int i = 0; i < items.Length; i++)
                {
                    FileAccessRules PathPermission = GetPathPermission(path + items[i].filterPath.Replace("\\", "/"));
                    if (!PathPermission.Read)
                    {
                        items = items.Where((val, idx) => idx != i).ToArray();
                        i--;
                        continue;
                    }
                    items[i].permission = GetFilePermission(physicalPath + items[i].filterPath, items[i].name, items[i].isFile);
                    if (items[i].isFile)
                    {
                        items[i].permission.EditContents = PathPermission.EditContents;
                        items[i].permission.Upload       = PathPermission.Upload;
                    }
                }
                SearchResponse.files = items;
                return(SearchResponse);
            }
            catch (Exception e)
            {
                SearchResponse.error = e.GetType().FullName + ", " + e.Message;
                return(SearchResponse);
            }
        }
示例#10
0
        public FileAccessRules GetFilePermission(string location, string name, bool isFile)
        {
            FileAccessRules FilePermission = new FileAccessRules();

            if (isFile)
            {
                string nameExtension = Path.GetExtension(name).ToLower();
                foreach (AccessRule fileRule in AccessRules.Rules)
                {
                    if (!string.IsNullOrEmpty(fileRule.Path) && Path.HasExtension(fileRule.Path) && (fileRule.Role == null || fileRule.Role == AccessRules.Role))
                    {
                        var pathExtension = Path.GetExtension(fileRule.Path).ToLower();
                        if (fileRule.Path.IndexOf("*.*") > -1)
                        {
                            string parentPath = fileRule.Path.Substring(0, fileRule.Path.IndexOf("*.*"));
                            if (location.IndexOf(GetPath(AccessRules.RootPath + parentPath)) == 0 || parentPath == "")
                            {
                                FilePermission = UpdateFileRules(FilePermission, fileRule);
                            }
                        }
                        else if (fileRule.Path.IndexOf("*.") > -1)
                        {
                            string parentPath = fileRule.Path.Substring(0, fileRule.Path.IndexOf("*."));
                            if ((GetPath(AccessRules.RootPath + parentPath) == location || parentPath == "") && nameExtension == pathExtension)
                            {
                                FilePermission = UpdateFileRules(FilePermission, fileRule);
                            }
                        }
                        else if (GetPath(AccessRules.RootPath + fileRule.Path) == (location + name))
                        {
                            FilePermission = UpdateFileRules(FilePermission, fileRule);
                        }
                    }
                }
                return(FilePermission);
            }
            else
            {
                foreach (AccessRule folderRule in AccessRules.Rules)
                {
                    if (folderRule.Path != null && !Path.HasExtension(folderRule.Path) && (folderRule.Role == null || folderRule.Role == AccessRules.Role))
                    {
                        if (folderRule.Path.IndexOf("*") > -1)
                        {
                            string parentPath = folderRule.Path.Substring(0, folderRule.Path.IndexOf("*"));
                            if ((location + name).IndexOf(GetPath(AccessRules.RootPath + parentPath)) == 0 || parentPath == "")
                            {
                                FilePermission = UpdateFolderRules(FilePermission, folderRule);
                            }
                        }
                        else if (GetPath(AccessRules.RootPath + folderRule.Path) == (location + name) || GetPath(AccessRules.RootPath + folderRule.Path) == (location + name + "\\"))
                        {
                            FilePermission = UpdateFolderRules(FilePermission, folderRule);
                        }
                        else if ((location + name).IndexOf(GetPath(AccessRules.RootPath + folderRule.Path)) == 0)
                        {
                            FilePermission.Edit         = HasPermission(folderRule.EditContents);
                            FilePermission.EditContents = HasPermission(folderRule.EditContents);
                        }
                    }
                }
                FilePermission.Download = false;
                return(FilePermission);
            }
        }