/// <summary>
///
/// </summary>
/// <param name="man"></param>
/// <returns></returns>
public override bool OnInit(ManagerEngine man)
{
string fs = man.Config.Get("filesystem", "LocalFileFactory");
IFileFactory factory = null;
// Register local file system factroy
if (fs != "LocalFileFactory")
{
if (fs.IndexOf('.') == -1)
{
factory = (IFileFactory)InstanceFactory.CreateInstance("Moxiecode.Manager.FileSystems." + fs);
}
if (factory == null)
{
factory = (IFileFactory)InstanceFactory.CreateInstance(fs);
}
man.FileSystems["file"] = factory;
}
else
{
man.FileSystems["file"] = new LocalFileFactory();
}
man.FileSystems["root"] = new RootFileFactory();
return(true); // Pass to next
}
private ResultSet InsertFiles(ManagerEngine man, Hashtable input)
{
ResultSet rs = new ResultSet(new string[] { "name", "path", "url", "size", "type", "created", "modified", "attribs", "custom" });
for (int i = 0; input["path" + i] != null; i++)
{
Hashtable customInfo = new Hashtable();
IFile file;
string url, attribs;
file = man.GetFile(man.DecryptPath((string)input["path" + i]));
if (!file.Exists)
{
throw new ManagerException("{#error.file_not_exists}");
}
man.DispatchEvent(EventType.CustomInfo, file, "insert", customInfo);
man.DispatchEvent(EventType.InsertFile, file);
url = PathUtils.RemoveTrailingSlash(file.Config["preview.urlprefix"]) + man.ConvertPathToURI(file.AbsolutePath) + file.Config["preview.urlsuffix"];
attribs = "RW";
rs.Add(file.Name,
man.EncryptPath(file.AbsolutePath),
url,
file.Length,
PathUtils.GetExtension(file.Name).ToLower(),
StringUtils.GetDate(file.CreationDate, file.Config.Get("filesystem.datefmt", "yyyy-MM-dd HH:mm")),
StringUtils.GetDate(file.LastModified, file.Config.Get("filesystem.datefmt", "yyyy-MM-dd HH:mm")),
attribs,
customInfo);
}
return(rs);
}
/// <summary>
///
/// </summary>
/// <param name="man"></param>
/// <param name="cmd"></param>
/// <param name="input"></param>
/// <returns></returns>
public override object OnRPC(ManagerEngine man, string cmd, Hashtable input)
{
switch (cmd)
{
case "deleteFiles":
return(this.DeleteFiles(man, input));
case "listFiles":
return(this.ListFiles(man, cmd, input));
case "createDirs":
return(this.CreateDirs(man, input));
case "getConfig":
return(this.GetConfig(man, input));
case "insertFiles":
return(this.InsertFiles(man, input));
case "keepAlive":
return(this.KeepAlive(man, input));
case "loopBack":
return(this.LoopBack(man, input));
}
return(null);
}
private object AddFavorites(ManagerEngine man, Hashtable input)
{
ResultSet rs = new ResultSet(new string[]{"status", "file", "message"});
HttpResponse response = HttpContext.Current.Response;
HttpRequest request = HttpContext.Current.Request;
HttpCookie cookie;
ArrayList chunks;
if ((cookie = request.Cookies["fav"]) == null) {
cookie = new HttpCookie("fav");
chunks = new ArrayList();
} else
chunks = new ArrayList(cookie.Value.Split(new char[]{','}));
cookie.Expires = DateTime.Now.AddDays(30);
for (int i=0; input["path" + i] != null; i++) {
string path = (string) input["path" + i];
if (chunks.IndexOf(path) == -1)
chunks.Add(path);
rs.Add("OK", man.EncryptPath(path), "Path was added.");
}
cookie.Value = this.Implode(chunks, ",");
response.Cookies.Remove("fav");
response.Cookies.Add(cookie);
return rs;
}
/// <summary>
///
/// </summary>
/// <param name="man"></param>
/// <returns></returns>
public override bool OnInit(ManagerEngine man)
{
// Register local file system factroy
man.FileSystems["zip"] = new ZipFileFactory();
return true; // Pass to next
}
private object GetConfig(ManagerEngine man, Hashtable input)
{
string prefixes, path;
IFile file;
// Get input
prefixes = (string)input["prefixes"];
path = man.DecryptPath((string)input["path"]);
// Request all
if (prefixes == null)
{
prefixes = "*";
}
// Return config
file = man.GetFile(path);
if (!file.Exists)
{
throw new ManagerException("{#error.file_not_exists}");
}
return(man.GetJSConfig(file.Config, prefixes));
}
public override bool OnInsertFile(ManagerEngine man, IFile file)
{
HttpResponse response = HttpContext.Current.Response;
HttpRequest request = HttpContext.Current.Request;
HttpCookie cookie;
ArrayList chunks;
if ((cookie = request.Cookies["hist"]) == null)
cookie = new HttpCookie("hist");
cookie.Expires = DateTime.Now.AddDays(30);
if (cookie.Value != null) {
chunks = new ArrayList(cookie.Value.Split(new char[]{','}));
if (chunks.IndexOf(man.EncryptPath(file.AbsolutePath)) == -1)
chunks.Add(man.EncryptPath(file.AbsolutePath));
cookie.Value = this.Implode(chunks, ",");
} else
cookie.Value = man.EncryptPath(file.AbsolutePath);
response.Cookies.Remove("hist");
response.Cookies.Add(cookie);
return true;
}
/// <summary>
///
/// </summary>
/// <param name="man"></param>
/// <param name="cmd"></param>
/// <param name="input"></param>
/// <returns></returns>
public override object OnRPC(ManagerEngine man, string cmd, Hashtable input)
{
switch (cmd) {
case "deleteFiles":
return this.DeleteFiles(man, input);
case "listFiles":
return this.ListFiles(man, cmd, input);
case "createDirs":
return this.CreateDirs(man, input);
case "getConfig":
return this.GetConfig(man, input);
case "insertFiles":
return this.InsertFiles(man, input);
case "keepAlive":
return this.KeepAlive(man, input);
case "loopBack":
return this.LoopBack(man, input);
}
return null;
}
/// <summary>
/// Initializes a file instance by a absolute path, child name and type.
/// This can be userful when filtering non existing files.
/// </summary>
/// <param name="man">Reference to manager that requested the file.</param>
/// <param name="absolute_path">Absolute file/directory path.</param>
/// <param name="child_name">Name of child file for the directory.</param>
/// <param name="type">Type of file to create.</param>
public LocalFile(ManagerEngine man, string absolute_path, string child_name, FileType type)
{
this.manager = man;
if (child_name != "")
this.absPath = PathUtils.ToUnixPath(absolute_path + "/" + child_name);
else
this.absPath = PathUtils.ToUnixPath(absolute_path);
if (type == FileType.Directory)
this.dirInfo = new DirectoryInfo(PathUtils.ToOSPath(this.absPath));
else if (type == FileType.File)
this.fileInfo = new FileInfo(PathUtils.ToOSPath(this.absPath));
else {
// Create file info or dir info
this.fileInfo = new FileInfo(PathUtils.ToOSPath(this.absPath));
if (!this.fileInfo.Exists) {
this.dirInfo = new DirectoryInfo(PathUtils.ToOSPath(this.absPath));
this.fileInfo = null;
}
if (this.fileInfo != null)
this.absPath = PathUtils.ToUnixPath(this.fileInfo.FullName);
if (this.dirInfo != null)
this.absPath = PathUtils.RemoveTrailingSlash(PathUtils.ToUnixPath(this.dirInfo.FullName));
}
this.config = this.manager.Config;
this.configResolved = false;
this.triggerEvents = true;
}
private ResultSet DeleteFiles(ManagerEngine man, Hashtable input)
{
ResultSet rs = new ResultSet(new string[] { "status", "file", "message" });
ManagerConfig config;
IFile file;
for (int i = 0; input["path" + i] != null; i++)
{
file = man.GetFile(man.DecryptPath((string)input["path" + i]));
config = file.Config;
if (!man.IsToolEnabled("delete", config))
{
throw new ManagerException("{#error.no_access}");
}
// File exists
if (!file.Exists)
{
rs.Add("FAILED", man.EncryptPath(file.AbsolutePath), "{#error.file_not_exists}");
continue;
}
if (config.GetBool("general.demo", false))
{
rs.Add("FAILED", man.EncryptPath(file.AbsolutePath), "{#error.demo}");
continue;
}
if (!man.VerifyFile(file, "delete"))
{
rs.Add("FAILED", man.EncryptPath(file.AbsolutePath), man.InvalidFileMsg);
continue;
}
if (!file.CanWrite)
{
rs.Add("FAILED", man.EncryptPath(file.AbsolutePath), "{#error.no_write_access}");
continue;
}
if (!config.GetBool("filesystem.writable", true))
{
rs.Add("FAILED", man.EncryptPath(file.AbsolutePath), "{#error.no_write_access}");
continue;
}
if (file.Delete(config.GetBool("filesystem.delete_recursive", true)))
{
rs.Add("OK", man.EncryptPath(file.AbsolutePath), "{#message.delete_success}");
}
else
{
rs.Add("FAILED", man.EncryptPath(file.AbsolutePath), "{#error.delete_failed}");
}
}
return(rs);
}
/// <summary>
/// Initializes a file instance by a absolute path, child name and type.
/// This can be userful when filtering non existing files.
/// </summary>
/// <param name="man">Reference to manager that requested the file.</param>
/// <param name="absolute_path">Absolute file/directory path.</param>
/// <param name="child_name">Name of child file for the directory.</param>
/// <param name="type">Type of file to create.</param>
public BaseFile(ManagerEngine man, string absolute_path, string child_name, FileType type)
{
this.manager = man;
if (child_name != null && child_name != "")
this.absPath = PathUtils.ToUnixPath(absolute_path + "/" + child_name);
else
this.absPath = PathUtils.ToUnixPath(absolute_path);
}
private ResultSet KeepAlive(ManagerEngine man, Hashtable input)
{
ResultSet rs = new ResultSet(new string[] { "status", "time", "message" });
man.DispatchEvent(EventType.KeepAlive);
rs.Add("KEEPALIVE", DateTime.Now.Ticks, "{#message.keepalive}");
return(rs);
}
/// <summary>
///
/// </summary>
/// <param name="man"></param>
/// <param name="file"></param>
/// <param name="type"></param>
/// <param name="info"></param>
/// <returns></returns>
public override bool OnCustomInfo(ManagerEngine man, IFile file, string type, Hashtable info)
{
switch (type) {
case "list":
info["previewable"] = file.IsFile && man.VerifyFile(file, "preview");
info["editable"] = file.IsFile && man.VerifyFile(file, "edit");
break;
}
return true;
}
public override object OnRPC(ManagerEngine man, string cmd, Hashtable input)
{
switch (cmd) {
case "addFavorites":
return this.AddFavorites(man, input);
case "removeFavorites":
return this.RemoveFavorites(man, input);
}
return null;
}
/// <summary>
///
/// </summary>
/// <param name="man"></param>
/// <param name="cmd"></param>
/// <param name="input"></param>
/// <returns></returns>
public override object OnUpload(ManagerEngine man, string cmd, NameValueCollection input)
{
if (cmd == "upload")
{
ResultSet rs = new ResultSet(new string[] { "status", "file", "message" });
HttpRequest request = HttpContext.Current.Request;
ManagerConfig config;
IFile targetDir;
// Setup
targetDir = man.GetFile(man.DecryptPath(input["path"]));
config = targetDir.Config;
// Check access agains config
if (config.GetBool("general.demo", false))
{
rs.Add("FAILED", man.EncryptPath(targetDir.AbsolutePath), "{#error.demo}");
return(rs);
}
if (!config.GetBool("filesystem.writable", true))
{
rs.Add("FAILED", man.EncryptPath(targetDir.AbsolutePath), "{#error.no_write_access}");
return(rs);
}
if (config.HasItem("general.disabled_tools", "upload"))
{
rs.Add("FAILED", man.EncryptPath(targetDir.AbsolutePath), "{#error.demo}");
return(rs);
}
// Handle flash upload
if (request["html4"] == null)
{
this.HandleChunkedUpload(man, targetDir, request, request["name"], rs);
return(rs);
}
// Ok lets check the files array out.
for (int i = 0; request.Files["file" + i] != null; i++)
{
this.HandleUploadedFile(man, targetDir, request.Files["file" + i], input["name" + i], rs);
}
return(rs);
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="man"></param>
/// <param name="file"></param>
/// <param name="type"></param>
/// <param name="info"></param>
/// <returns></returns>
public override bool OnCustomInfo(ManagerEngine man, IFile file, string type, Hashtable info)
{
switch (type) {
case "insert":
// Can be used by the insert_templates like this {$custom.mycustomfield}
info["mycustomfield"] = file.Name.ToUpper();
// Will be used as title/alt in TinyMCE link/image dialogs
info["description"] = file.Name + "(" + StringUtils.GetSizeStr(file.Length) + ")";
break;
}
// Pass to next handler
return true;
}
/// <summary>
///
/// </summary>
/// <param name="man"></param>
/// <param name="action"></param>
/// <param name="file1"></param>
/// <param name="file2"></param>
/// <returns></returns>
public override bool OnBeforeFileAction(ManagerEngine man, FileAction action, IFile file1, IFile file2)
{
ManagerConfig config;
if (action == FileAction.Delete) {
config = file1.Config;
if (config.GetBool("filesystem.delete_format_images", false)) {
ImageUtils.DeleteFormatImages(file1.AbsolutePath, config.Get("upload.format"));
ImageUtils.DeleteFormatImages(file1.AbsolutePath, config.Get("edit.format"));
}
}
return true;
}
/// <summary>
///
/// </summary>
/// <param name="man"></param>
/// <returns></returns>
public override bool OnAuthenticate(ManagerEngine man)
{
HttpContext context = HttpContext.Current;
ManagerConfig config = man.Config;
string user = context.User.Identity.Name;
// Cleanup
user = user.Replace("\\", "");
user = user.Replace("/", "");
user = user.Replace(":", "");
// Replace all ${user} with current user
for (int i=0; i<config.Keys.Count; i++)
config[config.Keys[i]] = config[config.Keys[i]].Replace("${user}", user);
return context.User.Identity.IsAuthenticated;
}
/// <summary>
///
/// </summary>
/// <param name="man"></param>
/// <returns></returns>
public override bool OnInit(ManagerEngine man)
{
string fs = man.Config.Get("filesystem", "LocalFileFactory");
IFileFactory factory = null;
// Register local file system factroy
if (fs != "LocalFileFactory") {
if (fs.IndexOf('.') == -1)
factory = (IFileFactory) InstanceFactory.CreateInstance("Moxiecode.Manager.FileSystems." + fs);
if (factory == null)
factory = (IFileFactory) InstanceFactory.CreateInstance(fs);
man.FileSystems["file"] = factory;
} else
man.FileSystems["file"] = new LocalFileFactory();
man.FileSystems["root"] = new RootFileFactory();
return true; // Pass to next
}
/// <summary>
/// Gets called when the user selects a file and inserts it into TinyMCE or a form or similar.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="file">Implementation of the BaseFile class that was inserted/returned to external system.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual bool OnInsertFile(ManagerEngine man, IFile file)
{
return true;
}
/// <summary>
/// Gets called before the ManagerEngine is initialized. This method
/// can setup config and language pack data based on the prefix.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="prefix">Prefix to use when setting up config etc.</param>
/// <returns>true/false if the user is authenticated</returns>
public virtual bool OnPreInit(ManagerEngine man, string prefix)
{
return true;
}
/// <summary>
///
/// </summary>
/// <param name="man"></param>
/// <param name="file"></param>
/// <param name="type"></param>
/// <param name="info"></param>
/// <returns></returns>
public override bool OnCustomInfo(ManagerEngine man, IFile file, string type, Hashtable info)
{
string ext = PathUtils.GetExtension(file.Name).ToLower();
info["thumbnail"] = false;
switch (ext) {
case "gif":
case "jpeg":
case "jpg":
case "png":
MediaInfo imageSize = new MediaInfo(file.AbsolutePath);
ManagerConfig config = file.Config;
int thumbWidth, thumbHeight;
double scale;
// Constrain proportions
scale = Math.Min(config.GetInt("thumbnail.width", 90) / (double) imageSize.Width, config.GetInt("thumbnail.height", 90) / (double) imageSize.Height);
if (config.Get("thumbnail.scale_mode", "percentage") == "percentage") {
thumbWidth = scale > 1 ? imageSize.Width : (int) Math.Floor(imageSize.Width * scale);
thumbHeight = scale > 1 ? imageSize.Height : (int) Math.Floor(imageSize.Height * scale);
} else {
thumbWidth = config.GetInt("thumbnail.width", 90);
thumbHeight = config.GetInt("thumbnail.height", 90);
}
info["width"] = imageSize.Width;
info["height"] = imageSize.Height;
info["editable"] = true;
info["twidth"] = thumbWidth;
info["theight"] = thumbHeight;
info["thumbnail"] = true;
// Get thumbnail URL
if (type == "insert") {
IFile thumbFile = man.GetFile(file.Parent + "/" + config.Get("thumbnail.folder", "mcith") + "/" + config.Get("thumbnail.prefix", "mcith") + file.Name);
if (thumbFile.Exists)
info["thumbnail_url"] = man.ConvertPathToURI(thumbFile.AbsolutePath);
}
break;
}
return true;
}
/// <summary>
/// Gets called when custom data is to be added for a file custom data can for example be
/// plugin specific name value items that should get added into a file listning.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="file">File reference to add custom info/data to.</param>
/// <param name="type">Where is the info needed for example list or info.</param>
/// <param name="custom">Name/Value array to add custom items to.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual bool OnCustomInfo(ManagerEngine man, IFile file, string type, Hashtable custom)
{
return true;
}
private ResultSet RotateImage(ManagerEngine man, Hashtable input)
{
ResultSet rs = new ResultSet(new string[]{"status", "file", "message"});
IFile file, targetFile;
ManagerConfig config;
string tempName;
RotateFlipType rotateFlipType = RotateFlipType.Rotate90FlipNone;
file = man.GetFile(man.DecryptPath((string) input["path"]));
config = file.Config;
if (!man.IsToolEnabled("edit", config))
throw new ManagerException("{#error.no_access}");
if (!file.Exists) {
rs.Add("FAILED", man.EncryptPath(file.AbsolutePath), "{#error.file_not_exists}");
return rs;
}
if (file.Name.IndexOf("mcic_") != 0 && !man.VerifyFile(file, "edit")) {
rs.Add("FATAL", man.EncryptPath(file.AbsolutePath), man.InvalidFileMsg);
return rs;
}
if (input["temp"] != null && (bool) input["temp"]) {
tempName = "mcic_" + HttpContext.Current.Session.SessionID + "." + PathUtils.GetExtension(file.Name);
if (input["target"] != null)
targetFile = man.GetFile(man.DecryptPath((string) input["target"]), tempName);
else
targetFile = man.GetFile(file.Parent, tempName);
} else
targetFile = file;
switch (Convert.ToInt32(input["angle"])) {
case 90:
rotateFlipType = RotateFlipType.Rotate90FlipNone;
break;
case 180:
rotateFlipType = RotateFlipType.Rotate180FlipNone;
break;
case 270:
rotateFlipType = RotateFlipType.Rotate270FlipNone;
break;
}
try {
ImageUtils.RotateFlipImage(file.AbsolutePath, targetFile.AbsolutePath, rotateFlipType, config.GetInt("edit.jpeg_quality", 90));
rs.Add("OK", man.EncryptPath(targetFile.AbsolutePath), "{#message.rotate_success}");
} catch (Exception ex) {
man.Logger.Error(ex.ToString());
rs.Add("FAILED", man.EncryptPath(targetFile.AbsolutePath), "{#error.rotate_failed}");
}
return rs;
}
private ResultSet SaveImage(ManagerEngine man, Hashtable input)
{
ResultSet rs = new ResultSet(new string[]{"status", "file", "message"});
IFile file, targetFile;
ManagerConfig config;
file = man.GetFile(man.DecryptPath((string) input["path"]));
config = file.Config;
if (!man.IsToolEnabled("edit", config))
throw new ManagerException("{#error.no_access}");
if (config.GetBool("general.demo", false)) {
rs.Add("FAILED", man.EncryptPath(file.AbsolutePath), "{#error.demo}");
this.Cleanup(man, file.ParentFile);
return rs;
}
if (file.Name.IndexOf("mcic_") != 0 && !man.VerifyFile(file, "edit")) {
rs.Add("FAILED", man.EncryptPath(file.AbsolutePath), man.InvalidFileMsg);
this.Cleanup(man, file.ParentFile);
return rs;
}
targetFile = man.GetFile(file.Parent, (string) input["target"]);
if (file.AbsolutePath != targetFile.AbsolutePath) {
string fileExt = PathUtils.GetExtension(file.Name).ToLower();
string targetExt = PathUtils.GetExtension(targetFile.Name).ToLower();
if (fileExt != targetExt) {
rs.Add("FAILED", man.EncryptPath(targetFile.AbsolutePath), "{#error.invalid_filename}");
this.Cleanup(man, file.ParentFile);
return rs;
}
if (config.GetBool("filesystem.delete_format_images", false))
ImageUtils.DeleteFormatImages(targetFile.AbsolutePath, config.Get("edit.format"));
if (targetFile.Exists)
targetFile.Delete();
file.RenameTo(targetFile);
if (config.Get("edit.format") != null)
ImageUtils.FormatImage(targetFile.AbsolutePath, config.Get("edit.format"), config.GetInt("edit.jpeg_quality", 90));
this.Cleanup(man, file.ParentFile);
}
rs.Add("OK", man.EncryptPath(file.AbsolutePath), "{#message.save_success}");
return rs;
}
/// <summary>
/// Gets called when data is streamed to client. This method should setup HTTP headers, content type
/// etc and simply send out the binary data to the client and the return false ones that is done.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="cmd">Stream command that is to be performed.</param>
/// <param name="input">Array of input arguments.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual bool OnStream(ManagerEngine man, string cmd, NameValueCollection input)
{
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="man"></param>
/// <param name="path"></param>
/// <param name="child"></param>
/// <param name="type"></param>
public RootFile(ManagerEngine man, string path, string child, FileType type) : base(man, path, child, type)
{
}
/// <summary>
/// Gets called before a RPC command is handled.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="cmd">RPC Command to be executed.</param>
/// <param name="input">RPC input object data.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual bool OnBeforeRPC(ManagerEngine man, string cmd, Hashtable input)
{
return(true);
}
/// <summary>
/// Gets executed when a RPC command is to be executed.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="cmd">RPC Command to be executed.</param>
/// <param name="input">RPC input object data.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual object OnRPC(ManagerEngine man, string cmd, Hashtable input)
{
return(null);
}
/// <summary>
/// Gets called after a file action was perforem for example after a rename or copy.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="action">File action type.</param>
/// <param name="file1">File object 1 for example from in a copy operation.</param>
/// <param name="file2">File object 2 for example to in a copy operation. Might be null in for example a delete.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual bool OnFileAction(ManagerEngine man, FileAction action, IFile file1, IFile file2)
{
return(true);
}
private ResultSet CreateDirs(ManagerEngine man, Hashtable input)
{
ResultSet rs = new ResultSet(new string[] { "status", "file", "message" });
string path, name, template = null;
IFile dir, file, templateFile;
ManagerConfig config;
path = man.DecryptPath((string)input["path"]);
dir = man.GetFile(path);
config = dir.Config;
if (!man.IsToolEnabled("createdir", config))
{
throw new ManagerException("{#error.no_access}");
}
// Handle demo mode
if (config.GetBool("general.demo", false))
{
rs.Add("DEMO_ERROR", man.EncryptPath(dir.AbsolutePath), "{#error.demo}");
return(rs);
}
for (int i = 0; input["name" + i] != null; i++)
{
// Get dir info
name = (string)input["name" + i];
if (input["template" + i] != null && ((string)input["template" + i]) != "")
{
template = man.DecryptPath((string)input["template" + i]);
}
// Setup target file
file = man.GetFile(path, name, FileType.Directory);
// Check if valid target file
if (!man.VerifyFile(file, "createdir"))
{
rs.Add("FAILED", man.EncryptPath(file.AbsolutePath), man.InvalidFileMsg);
continue;
}
// Setup template dir
if (template != null)
{
templateFile = man.GetFile(template);
if (!man.VerifyFile(templateFile, "createdir"))
{
rs.Add("ACCESS_ERROR", man.EncryptPath(file.AbsolutePath), man.InvalidFileMsg);
continue;
}
if (!templateFile.Exists)
{
rs.Add("TEMPLATE_ERROR", man.EncryptPath(templateFile.AbsolutePath), "{#error.template_missing}");
continue;
}
}
else
{
templateFile = null;
}
// Check if target exists
if (file.Exists)
{
rs.Add("EXISTS_ERROR", man.EncryptPath(file.AbsolutePath), "{#error.folder_exists}");
continue;
}
// Create directory
if (templateFile != null)
{
templateFile.CopyTo(file);
}
else
{
file.MkDir();
}
rs.Add("OK", man.EncryptPath(file.AbsolutePath), "{#message.directory_ok}");
}
return(rs);
}
/// <summary>
///
/// </summary>
/// <param name="man"></param>
/// <param name="cmd"></param>
/// <param name="input"></param>
/// <returns></returns>
public override bool OnStream(ManagerEngine man, string cmd, NameValueCollection input)
{
HttpContext context = HttpContext.Current;
string path, contentType;
ManagerConfig config;
IFile file;
switch (cmd)
{
case "streamFile":
// Get input
path = man.DecryptPath(input["path"]);
// Get and stream file
file = man.GetFile(path);
config = file.Config;
if (file is LocalFile)
{
string url = PathUtils.RemoveTrailingSlash(config["preview.urlprefix"]) + man.ConvertPathToURI(file.AbsolutePath) + config["preview.urlsuffix"];
// Pass through rnd
if (input["rnd"] != null)
{
context.Response.Redirect(url + (url.IndexOf('?') == -1 ? ("?rnd=" + input["rnd"]) : ("&rnd" + input["rnd"])), true);
}
context.Response.Redirect(url, true);
}
else
{
// Verify that we can stream the file
if (!man.VerifyFile(file, "stream"))
{
throw new ManagerException("Requested resource could not be found. Or access was denied.");
}
// Set content type
contentType = man.MimeTypes[PathUtils.GetExtension(path).ToLower()];
if (contentType != null)
{
context.Response.ContentType = contentType;
}
IOUtils.StreamFromTo(file.Open(FileMode.Open), context.Response.OutputStream, 1024);
}
break;
case "download":
// Get input
path = man.DecryptPath(input["path"]);
// Get and stream file
file = man.GetFile(path);
config = file.Config;
// Verify that we can stream the file
if (!man.VerifyFile(file, "download"))
{
throw new ManagerException("Requested resource could not be found. Or access was denied.");
}
// Set content type
//contentType = man.MimeTypes[PathUtils.GetExtension(path).ToLower()];
context.Response.ContentType = "application/octet-stream";
context.Response.AddHeader("Content-Disposition:", "attachment; filename=\"" + file.Name + "\"");
//IOUtils.StreamFromTo(file.Open(FileMode.Open), context.Response.OutputStream, 4096);
byte[] buff = new byte[4096];
int len;
Stream inStream = file.Open(FileMode.Open), outStream = context.Response.OutputStream;
try {
while ((len = inStream.Read(buff, 0, buff.Length)) > 0)
{
outStream.Write(buff, 0, len);
outStream.Flush();
context.Response.Flush();
}
} finally {
if (inStream != null)
{
inStream.Close();
}
if (outStream != null)
{
outStream.Close();
}
}
break;
}
// Devkit commands
switch (cmd)
{
case "viewServerInfo":
if (!man.Config.GetBool("general.debug", false))
{
throw new ManagerException("You have to enable debugging in config by setting general.debug to true.");
}
context.Response.ContentType = "text/html";
context.Trace.IsEnabled = true;
context.Response.Write("<pre># Config from Web.config\r\n\r\n");
foreach (string key in man.Config.Keys)
{
context.Response.Write(key + "=" + man.Config[key] + "\r\n");
}
context.Response.Write("</pre>");
break;
case "downloadServerInfo":
if (!man.Config.GetBool("general.debug", false))
{
throw new ManagerException("You have to enable debugging in config by setting general.debug to true.");
}
context.Response.AppendHeader("Content-Disposition", "attachment; filename=trace.htm");
context.Response.ContentType = "text/html";
context.Trace.IsEnabled = true;
context.Response.Write("<pre># Config from Web.config\r\n\r\n");
foreach (string key in man.Config.Keys)
{
context.Response.Write(key + "=" + man.Config[key] + "\r\n");
}
context.Response.Write("</pre>");
break;
case "viewLog":
if (!man.Config.GetBool("general.debug", false))
{
throw new ManagerException("You have to enable debugging in config by setting general.debug to true.");
}
if (input["level"] == "debug")
{
if (File.Exists(man.MapPath("logs/debug.log")))
{
context.Response.WriteFile(man.MapPath("logs/debug.log"));
}
}
else
{
if (File.Exists(man.MapPath("logs/error.log")))
{
context.Response.WriteFile(man.MapPath("logs/error.log"));
}
}
break;
case "clearLog":
if (!man.Config.GetBool("general.debug", false))
{
throw new ManagerException("You have to enable debugging in config by setting general.debug to true.");
}
if (input["level"] == "debug")
{
File.Delete(man.MapPath("logs/debug.log"));
}
else
{
File.Delete(man.MapPath("logs/error.log"));
}
context.Response.Write("Log cleared.");
break;
}
return(true);
}
/// <summary>
/// Gets called when data is streamed to client. This method should setup HTTP headers, content type
/// etc and simply send out the binary data to the client and the return false ones that is done.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="cmd">Stream command that is to be performed.</param>
/// <param name="input">Array of input arguments.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual bool OnStream(ManagerEngine man, string cmd, NameValueCollection input)
{
return true;
}
/// <summary>
/// Gets called when data is streamed/uploaded from client. This method should take care of
/// any uploaded files and move them to the correct location.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="cmd">Upload command that is to be performed.</param>
/// <param name="input">Array of input arguments.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual object OnUpload(ManagerEngine man, string cmd, NameValueCollection input)
{
return(null);
}
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 object LoopBack(ManagerEngine man, Hashtable input)
{
return(input);
}
private IFile MakeThumb(ManagerEngine man, IFile file)
{
ManagerConfig config = file.Config;
IFile thumbFile;
int thumbWidth, thumbHeight;
int configWidth, configHeight;
double scale;
MediaInfo thumbSize = new MediaInfo();
// Is not enabled
if (!config.GetBool("thumbnail.enabled", true))
return file;
// Setup thumbnail path
IFile thumbDir = man.GetFile(file.Parent, config.Get("thumbnail.folder", "mcith"));
if (!thumbDir.Exists)
thumbDir.MkDir();
configWidth = config.GetInt("thumbnail.width", 90);
configHeight = config.GetInt("thumbnail.height", 90);
// Make thumbnail
thumbFile = man.GetFile(thumbDir.AbsolutePath, config.Get("thumbnail.prefix", "mcith") + file.Name);
MediaInfo imageSize = new MediaInfo(file.AbsolutePath);
// Need to scale?
if (imageSize.Width < configWidth && imageSize.Height < configHeight)
return file;
// To large
if (imageSize.Width > config.GetInt("thumbnail.max_width", 65535) || imageSize.Height > config.GetInt("thumbnail.max_height", 65535))
return file;
// Constrain proportions
scale = Math.Min(configWidth / (double) imageSize.Width, configHeight / (double) imageSize.Height);
if (config.Get("thumbnail.scale_mode", "percentage") == "percentage") {
thumbWidth = scale > 1 ? imageSize.Width : (int) Math.Floor(imageSize.Width * scale);
thumbHeight = scale > 1 ? imageSize.Height : (int) Math.Floor(imageSize.Height * scale);
} else {
thumbWidth = config.GetInt("thumbnail.width", 90);
thumbHeight = config.GetInt("thumbnail.height", 90);
}
if (thumbFile.Exists)
thumbSize = new MediaInfo(thumbFile.AbsolutePath);
if (!thumbFile.Exists || thumbSize.Width != thumbWidth || thumbSize.Height != thumbHeight || file.LastModified != thumbFile.LastModified)
ImageUtils.MakeThumbnail(file.AbsolutePath, thumbFile.AbsolutePath, thumbWidth, thumbHeight, file.LastModified, config.GetInt("thumbnail.jpeg_quality", 75));
return thumbFile;
}
/// <summary>
/// Gets called when custom data is to be added for a file custom data can for example be
/// plugin specific name value items that should get added into a file listning.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="file">File reference to add custom info/data to.</param>
/// <param name="type">Where is the info needed for example list or info.</param>
/// <param name="custom">Name/Value array to add custom items to.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual bool OnCustomInfo(ManagerEngine man, IFile file, string type, Hashtable custom)
{
return(true);
}
private void HandleChunkedUpload(ManagerEngine man, IFile target_dir, HttpRequest req, string file_name, ResultSet rs)
{
long maxSizeBytes;
IFile file;
ManagerConfig config;
int chunk = req["chunk"] == null ? 0 : Convert.ToInt32(req["chunk"]), chunks = req["chunks"] == null ? 1 : Convert.ToInt32(req["chunks"]);
try {
maxSizeBytes = StringUtils.GetSizeLong(target_dir.Config.Get("upload.maxsize", "10mb"), "10mb");
file = man.GetFile(target_dir.AbsolutePath, file_name, FileType.File);
config = file.Config;
if (!man.IsToolEnabled("upload", config))
{
throw new ManagerException("{#error.no_access}");
}
if (!man.VerifyFile(file, "upload"))
{
rs.Add("FILTER_ERROR", man.EncryptPath(file.AbsolutePath), man.InvalidFileMsg);
return;
}
// File exists
if (file.Exists && chunk == 0)
{
if (!config.GetBool("upload.overwrite", false))
{
rs.Add("OVERWRITE_ERROR", man.EncryptPath(file.AbsolutePath), "{#error.file_exists}");
return;
}
else if (file.Exists)
{
file.Delete();
}
}
Stream outStream = file.Open(chunk == 0 ? FileMode.Create : FileMode.Append);
byte[] buff = new byte[1024];
int len;
if (req.Files["file"] != null)
{
while ((len = req.Files["file"].InputStream.Read(buff, 0, buff.Length)) > 0)
{
outStream.Write(buff, 0, len);
}
}
else
{
while ((len = req.InputStream.Read(buff, 0, buff.Length)) > 0)
{
outStream.Write(buff, 0, len);
}
}
outStream.Close();
// To large
if (file.Length > maxSizeBytes)
{
rs.Add("SIZE_ERROR", man.EncryptPath(file.AbsolutePath), "{#error.error_to_large}");
file.Delete();
return;
}
rs.Add("OK", man.EncryptPath(file.AbsolutePath), "{#message.upload_ok}");
if (chunk == chunks - 1)
{
file.ImportFile(file.AbsolutePath); // Dispatch add
}
} catch (Exception e) {
man.Logger.Error(e.ToString());
rs.Add("FAILED", file_name, "{#error.upload_failed}");
}
}
/// <summary>
/// Gets called when the user selects a file and inserts it into TinyMCE or a form or similar.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="file">Implementation of the BaseFile class that was inserted/returned to external system.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual bool OnInsertFile(ManagerEngine man, IFile file)
{
return(true);
}
private bool StreamThumb(ManagerEngine man, NameValueCollection input)
{
HttpContext context = HttpContext.Current;
string path, contentType;
ManagerConfig config;
IFile file;
// Get input
path = man.DecryptPath((string) input["path"]);
// Find mime type
contentType = man.MimeTypes[PathUtils.GetExtension(path).ToLower()];
if (contentType != null)
context.Response.ContentType = contentType;
// Get and stream file
file = man.GetFile(path);
config = file.Config;
try {
path = MakeThumb(man, file).AbsolutePath;
} catch (Exception) {
// Ignore
}
// Stream thumbnail
if (file is LocalFile)
context.Response.WriteFile(path);
else
IOUtils.StreamFromTo(file.Open(FileMode.Open), context.Response.OutputStream, 1024);
return false;
}
/// <summary>
/// Gets called on a authenication request. This method should check sessions or simmilar to verify that the user has access to the backend.
/// This method should return true if the current request is authenicated or false if it's not.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <returns>true/false if the user is authenticated</returns>
public virtual bool OnAuthenticate(ManagerEngine man)
{
return(false);
}
/// <summary>
/// Gets called before a RPC command is handled.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="cmd">RPC Command to be executed.</param>
/// <param name="input">RPC input object data.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual bool OnBeforeRPC(ManagerEngine man, string cmd, Hashtable input)
{
return true;
}
/// <summary>
/// Gets called before the ManagerEngine is initialized. This method
/// can setup config and language pack data based on the prefix.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="prefix">Prefix to use when setting up config etc.</param>
/// <returns>true/false if the user is authenticated</returns>
public virtual bool OnPreInit(ManagerEngine man, string prefix)
{
return(true);
}
/// <summary>
/// Gets called after any authenication is performed and verified.
/// This method should return false if the execution chain is to be broken.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual bool OnInit(ManagerEngine man)
{
return true;
}
/// <summary>
/// Gets called when a user has logged out from the system. This event should be dispatched from the logout page.
/// These events is not fired internaly and should be fired/dispatched externally.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual bool OnLogout(ManagerEngine man)
{
return(true);
}
/// <summary>
/// Gets called when a user has logged out from the system. This event should be dispatched from the logout page.
/// These events is not fired internaly and should be fired/dispatched externally.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual bool OnLogout(ManagerEngine man)
{
return true;
}
/// <summary>
/// Gets called before data is streamed/uploaded from client.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="cmd">Upload command that is to was performed.</param>
/// <param name="input">Array of input arguments.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual bool OnAfterUpload(ManagerEngine man, string cmd, NameValueCollection input)
{
return true;
}
/// <summary>
/// Gets executed when a RPC command is to be executed.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="cmd">RPC Command to be executed.</param>
/// <param name="input">RPC input object data.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual object OnRPC(ManagerEngine man, string cmd, Hashtable input)
{
return null;
}
/// <summary>
/// Gets called before a file action occurs for example before a rename or copy.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="action">File action type.</param>
/// <param name="file1">File object 1 for example from in a copy operation.</param>
/// <param name="file2">File object 2 for example to in a copy operation. Might be null in for example a delete.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual bool OnBeforeFileAction(ManagerEngine man, FileAction action, IFile file1, IFile file2)
{
return true;
}
/// <summary>
/// Gets called when data is streamed/uploaded from client. This method should take care of
/// any uploaded files and move them to the correct location.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="cmd">Upload command that is to be performed.</param>
/// <param name="input">Array of input arguments.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual object OnUpload(ManagerEngine man, string cmd, NameValueCollection input)
{
return null;
}
private void HandleUploadedFile(ManagerEngine man, IFile target_dir, HttpPostedFile uploaded_file, string file_name, ResultSet rs)
{
long maxSizeBytes;
IFile file;
ManagerConfig config;
try {
maxSizeBytes = StringUtils.GetSizeLong(target_dir.Config.Get("upload.maxsize", "10mb"), "10mb");
if (file_name != null)
{
file = man.GetFile(target_dir.AbsolutePath, file_name + "." + PathUtils.GetExtension(uploaded_file.FileName), FileType.File);
}
else
{
file = man.GetFile(target_dir.AbsolutePath, uploaded_file.FileName, FileType.File);
}
config = file.Config;
if (!man.IsToolEnabled("upload", config))
{
throw new ManagerException("{#error.no_access}");
}
if (!man.VerifyFile(file, "upload"))
{
rs.Add("FILTER_ERROR", man.EncryptPath(file.AbsolutePath), man.InvalidFileMsg);
return;
}
// To large
if (uploaded_file.ContentLength > maxSizeBytes)
{
rs.Add("SIZE_ERROR", man.EncryptPath(file.AbsolutePath), "{#error.error_to_large}");
return;
}
// File exists
if (file.Exists)
{
if (!config.GetBool("upload.overwrite", false))
{
rs.Add("OVERWRITE_ERROR", man.EncryptPath(file.AbsolutePath), "{#error.file_exists}");
return;
}
else
{
file.Delete();
}
}
if (file is LocalFile)
{
uploaded_file.SaveAs(file.AbsolutePath);
file.ImportFile(file.AbsolutePath); // Dispatch add
}
else
{
Stream outStream = file.Open(FileMode.Create);
byte[] buff = new byte[1024];
int len;
while ((len = uploaded_file.InputStream.Read(buff, 0, buff.Length)) > 0)
{
outStream.Write(buff, 0, len);
}
outStream.Close();
}
rs.Add("OK", man.EncryptPath(file.AbsolutePath), "{#message.upload_ok}");
} catch (Exception e) {
man.Logger.Error(e.ToString());
rs.Add("FAILED", file_name, "{#error.upload_failed}");
}
}
/// <summary>
/// Gets called on a authenication request. This method should check sessions or simmilar to verify that the user has access to the backend.
/// This method should return true if the current request is authenicated or false if it's not.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <returns>true/false if the user is authenticated</returns>
public virtual bool OnAuthenticate(ManagerEngine man)
{
return false;
}
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>
/// Gets called before data is streamed/uploaded from client.
/// </summary>
/// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
/// <param name="cmd">Upload command that is to was performed.</param>
/// <param name="input">Array of input arguments.</param>
/// <returns>true/false if the execution of the event chain should continue execution.</returns>
public virtual bool OnAfterUpload(ManagerEngine man, string cmd, NameValueCollection input)
{
return(true);
}
/// <summary>
/// Returns a file based on path, child path and type.
/// </summary>
/// <param name="man">Manager engine reference.</param>
/// <param name="path">Absolute path to file or directory.</param>
/// <param name="child">Child path inside directory or empty string.</param>
/// <param name="type">File type, force it to be a file or directory.</param>
public IFile GetFile(ManagerEngine man, string path, string child, FileType type)
{
return(new RootFile(man, path, child, type));
}