private ResultSet ListFiles(ManagerEngine man, string cmd, Hashtable input)
{
ResultSet rs = new ResultSet(new string[] {"name","path","size","type","created","modified","attribs","custom"});
Hashtable customInfo;
ArrayList files = new ArrayList();
BasicFileFilter filter;
IFile listDir;
ManagerConfig config = man.Config;
bool onlyDirs, onlyFiles, remember, hasParent = false;
string type, attribs, path, rootPath, configPrefixes, name, tmpPath;
int pages, pageSize;
HttpRequest req = HttpContext.Current.Request;
HttpResponse resp = HttpContext.Current.Response;
// Handle remember_last_path state
if (input["remember_last_path"] != null) {
// URL specified
if (((string) input["path"]) == "{default}") {
if (input["url"] != null && (string) input["url"] != "")
input["path"] = man.ConvertURIToPath((string) input["url"]);
}
path = (string) input["path"];
if (input["remember_last_path"] is bool)
remember = (bool) input["remember_last_path"];
else if (((string) input["remember_last_path"]) != "auto")
remember = StringUtils.CheckBool((string) input["remember_last_path"]);
else
remember = config.GetBool("general.remember_last_path", false);
// Get/set cookie
if (remember) {
if (path == "{default}" && req.Cookies["MCManager_" + man.Prefix + "_lastPath"] != null) {
tmpPath = req.Cookies["MCManager_" + man.Prefix + "_lastPath"].Value;
if (tmpPath != null && man.GetFSFromPath(tmpPath) == "file")
input["path"] = tmpPath;
} else {
HttpCookie cookie = new HttpCookie("MCManager_" + man.Prefix + "_lastPath");
cookie.Expires = DateTime.Now.AddDays(30);
cookie.Value = path;
resp.Cookies.Remove("MCManager_" + man.Prefix + "_lastPath");
if (man.GetFSFromPath(path) == "file")
resp.Cookies.Add(cookie);
}
}
}
path = man.DecryptPath((string) input["path"]);
rootPath = man.DecryptPath((string) input["root_path"]);
onlyDirs = input["only_dirs"] != null && (bool) input["only_dirs"];
onlyFiles = input["only_files"] != null && (bool) input["only_files"];
configPrefixes = (string) input["config"];
if (man.GetFSFromPath(path) == "file" && !man.VerifyPath(path))
path = man.Config.Get("filesystem.path");
// Move path into rootpath
if (rootPath != null && !PathUtils.IsChildPath(rootPath, path) && man.GetFSFromPath(path) == "file")
path = rootPath;
listDir = man.GetFile(path);
// Use default path instead
if (!listDir.Exists) {
path = config["filesystem.path"];
listDir = man.GetFile(path);
}
rs.Header["path"] = man.EncryptPath(path);
rs.Header["visual_path"] = man.ToVisualPath(path, rootPath);
rs.Header["attribs"] = (listDir.CanRead ? "R" : "-") + (listDir.CanWrite ? "W" : "-");
// List files
if (listDir.IsDirectory) {
config = listDir.Config;
// Return part of the config
if (configPrefixes != null)
rs.Config = man.GetJSConfig(config, configPrefixes);
// Verify filesystem config
filter = new BasicFileFilter();
filter.IncludeDirectoryPattern = config["filesystem.include_directory_pattern"];
filter.ExcludeDirectoryPattern = config["filesystem.exclude_directory_pattern"];
filter.IncludeFilePattern = config["filesystem.include_file_pattern"];
filter.ExcludeFilePattern = config["filesystem.exclude_file_pattern"];
filter.IncludeExtensions = config["filesystem.extensions"];
filter.OnlyDirs = onlyDirs;
// Directory is hidden use parent dir
if (!filter.Accept(listDir)) {
listDir = listDir.ParentFile;
rs.Header["path"] = man.EncryptPath(listDir.AbsolutePath);
rs.Header["visual_path"] = man.ToVisualPath(listDir.AbsolutePath, rootPath);
}
if (input["filter"] != null)
filter.IncludeWildcardPattern = (string) input["filter"];
if (input["only_files"] != null)
filter.OnlyFiles = onlyFiles;
else if (!onlyDirs)
filter.OnlyFiles = !config.GetBool("filesystem.list_directories", false);
// Add parent
if (path != rootPath && input["only_files"] == null && (input["only_dirs"] != null || man.Config.GetBool("filesystem.list_directories", true))) {
if (man.VerifyPath(listDir.Parent)) {
hasParent = true;
rs.Add("..", man.EncryptPath(listDir.Parent), -1, "parent", "", "", "", new NameValueCollection());
}
}
// Setup input filter
BasicFileFilter inputFilter = new BasicFileFilter();
if (input["include_directory_pattern"] != null)
filter.IncludeDirectoryPattern = (string) input["include_directory_pattern"];
if (input["exclude_directory_pattern"] != null)
filter.ExcludeDirectoryPattern = (string) input["exclude_directory_pattern"];
if (input["include_file_pattern"] != null)
filter.IncludeFilePattern = (string) input["include_file_pattern"];
if (input["exclude_file_pattern"] != null)
filter.ExcludeFilePattern = (string) input["exclude_file_pattern"];
if (input["extensions"] != null)
filter.IncludeExtensions = (string) input["extensions"];
// Combine the filters
CombinedFileFilter combinedFilter = new CombinedFileFilter();
combinedFilter.AddFilter(inputFilter);
combinedFilter.AddFilter(filter);
files.AddRange(listDir.ListFilesFiltered(combinedFilter));
if (input["page_size"] != null) {
if (hasParent)
pageSize = Convert.ToInt32(input["page_size"]) - 1;
else
pageSize = Convert.ToInt32(input["page_size"]);
pages = (int) Math.Ceiling(files.Count / (double) pageSize);
// Setup response
rs.Header["pages"] = (pages > 1 ? pages : 1);
rs.Header["count"] = files.Count;
// Remove non visible files
int start = Convert.ToInt32(input["page"]) * pageSize;
int len = pageSize;
len = start + len > files.Count ? len - ((start + len) - files.Count) : len;
files = files.GetRange(start, len);
}
// Sort Files
files.Sort(new FileComparer());
// Output folders
foreach (IFile file in files) {
if (file.IsDirectory) {
// Setup attribs
attribs = "RW";
type = "folder";
// Fill custom info
customInfo = new Hashtable();
man.DispatchEvent(EventType.CustomInfo, file, "list", customInfo);
// Special treatment of roots
name = file.Name;
if (path == "root:///") {
if (man.RootNames[file.AbsolutePath] != null)
name = man.RootNames[file.AbsolutePath];
}
// Add to resultset
rs.Add(
name,
man.EncryptPath(file.AbsolutePath),
file.IsDirectory ? -1 : file.Length,
type,
StringUtils.GetDate(file.CreationDate, listDir.Config.Get("filesystem.datefmt", "yyyy-MM-dd HH:mm")),
StringUtils.GetDate(file.LastModified, listDir.Config.Get("filesystem.datefmt", "yyyy-MM-dd HH:mm")),
attribs,
customInfo
);
}
}
// Output files
foreach (IFile file in files) {
if (file.IsFile) {
// Setup attribs
attribs = "RW";
type = PathUtils.GetExtension(file.AbsolutePath).ToLower();
// Fill custom info
customInfo = new Hashtable();
man.DispatchEvent(EventType.CustomInfo, file, "list", customInfo);
// Add to resultset
rs.Add(
file.Name,
man.EncryptPath(file.AbsolutePath),
file.Length,
type,
StringUtils.GetDate(file.CreationDate, listDir.Config.Get("filesystem.datefmt", "yyyy-MM-dd HH:mm")),
StringUtils.GetDate(file.LastModified, listDir.Config.Get("filesystem.datefmt", "yyyy-MM-dd HH:mm")),
attribs,
customInfo
);
}
}
} else
throw new ManagerException("{#error.file_not_exists}");
return rs;
}
private ResultSet GetMediaInfo(ManagerEngine man, Hashtable input)
{
ResultSet rs = new ResultSet(new string[]{"name", "path", "url", "size", "type", "created", "modified", "width", "height", "attribs", "next", "prev", "custom"});
BasicFileFilter fileFilter;
IFile file, parent;
IFile[] files;
string prev, next, attribs, url, ext;
int width, height;
bool match;
Hashtable customInfo = new Hashtable();
ManagerConfig config;
if (input["url"] != null)
input["path"] = man.ConvertURIToPath(new Uri((string) input["url"]).AbsolutePath);
file = man.GetFile(man.DecryptPath((string) input["path"]));
config = file.Config;
parent = file.ParentFile;
if (parent.IsDirectory) {
// Setup file filter
fileFilter = new BasicFileFilter();
//fileFilter->setDebugMode(true);
fileFilter.IncludeDirectoryPattern = config["filesystem.include_directory_pattern"];
fileFilter.ExcludeDirectoryPattern = config["filesystem.exclude_directory_pattern"];
fileFilter.IncludeFilePattern = config["filesystem.include_file_pattern"];
fileFilter.ExcludeFilePattern = config["filesystem.exclude_file_pattern"];
fileFilter.IncludeExtensions = config["filesystem.extensions"];
fileFilter.OnlyFiles = true;
// List files
files = parent.ListFilesFiltered(fileFilter);
} else
throw new ManagerException("{#error.file_not_exists}");
match = false;
prev = "";
next = "";
// Find next and prev
foreach (IFile curFile in files) {
if (curFile.AbsolutePath == file.AbsolutePath) {
match = true;
continue;
} else if (!match)
prev = curFile.AbsolutePath;
if (match) {
next = curFile.AbsolutePath;
break;
}
}
ext = PathUtils.GetExtension(file.Name).ToLower();
// Input default size?
MediaInfo size = new MediaInfo(file.AbsolutePath);
width = size.Width != -1 ? size.Width : 425;
height = size.Height != -1 ? size.Height : 350;
// Get custom info
man.DispatchEvent(EventType.CustomInfo, file, "info", customInfo);
attribs = (file.CanRead && config.GetBool("filesystem.readable", true) ? "R" : "-") + (file.CanWrite && config.GetBool("filesystem.writable", true) ? "W" : "-");
url = PathUtils.RemoveTrailingSlash(config["preview.urlprefix"]) + man.ConvertPathToURI(file.AbsolutePath);
rs.Add(file.Name,
man.EncryptPath(file.AbsolutePath),
url,
file.Length,
ext,
StringUtils.GetDate(file.CreationDate, config.Get("filesystem.datefmt", "yyyy-MM-dd HH:mm")),
StringUtils.GetDate(file.LastModified, config.Get("filesystem.datefmt", "yyyy-MM-dd HH:mm")),
width,
height,
attribs,
man.EncryptPath(next),
man.EncryptPath(prev),
customInfo);
return rs;
}
/// <summary>
///
/// </summary>
/// <param name="file"></param>
/// <param name="action"></param>
/// <param name="config"></param>
/// <returns></returns>
public bool VerifyFile(IFile file, string action, ManagerConfig config)
{
BasicFileFilter filter;
// Verify filesystem config
filter = new BasicFileFilter();
filter.IncludeDirectoryPattern = config["filesystem.include_directory_pattern"];
filter.ExcludeDirectoryPattern = config["filesystem.exclude_directory_pattern"];
filter.IncludeFilePattern = config["filesystem.include_file_pattern"];
filter.ExcludeFilePattern = config["filesystem.exclude_file_pattern"];
filter.IncludeExtensions = config["filesystem.extensions"];
this.invalidFileMsg = "{#error.invalid_filename}";
if (!filter.Accept(file)) {
if (filter.Reason == FilterReason.InvalidFileName) {
if (file.IsDirectory)
this.invalidFileMsg = config["filesystem.invalid_directory_name_msg"];
else
this.invalidFileMsg = config["filesystem.invalid_file_name_msg"];
if (this.invalidFileMsg.Length == 0)
this.invalidFileMsg = "{#error.invalid_filename}";
}
return false;
}
// Verify action specific config
filter = new BasicFileFilter();
if (action != null) {
if (config[action + ".include_directory_pattern"] != null)
filter.IncludeDirectoryPattern = config[action + ".include_directory_pattern"];
if (config[action + ".exclude_directory_pattern"] != null)
filter.ExcludeDirectoryPattern = config[action + ".exclude_directory_pattern"];
if (config[action + ".include_file_pattern"] != null)
filter.IncludeFilePattern = config[action + ".include_file_pattern"];
if (config[action + ".exclude_file_pattern"] != null)
filter.ExcludeFilePattern = config[action + ".exclude_file_pattern"];
if (config[action + ".extensions"] != null)
filter.IncludeExtensions = config[action + ".extensions"];
}
if (!filter.Accept(file)) {
if (filter.Reason == FilterReason.InvalidFileName) {
if (file.IsDirectory)
this.invalidFileMsg = config[action + ".invalid_directory_name_msg"];
else
this.invalidFileMsg = config[action + ".invalid_file_name_msg"];
if (this.invalidFileMsg == null || this.invalidFileMsg.Length == 0)
this.invalidFileMsg = "{#error.invalid_filename}";
}
return false;
}
return true;
}
