コード例 #1
0
ファイル: FavoritePlugin.cs プロジェクト: nhtera/CrowdCMS
        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;
        }
コード例 #2
0
ファイル: ImageManagerPlugin.cs プロジェクト: nhtera/CrowdCMS
        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;
        }
コード例 #3
0
ファイル: ImageManagerPlugin.cs プロジェクト: nhtera/CrowdCMS
        private ResultSet CropImage(ManagerEngine man, Hashtable input)
        {
            ResultSet rs = new ResultSet(new string[]{"status", "file", "message"});
            IFile file, targetFile;
            ManagerConfig config;
            string tempName;
            int x, y, w, h;

            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;

            x = Convert.ToInt32(input["left"]);
            y = Convert.ToInt32(input["top"]);
            w = Convert.ToInt32(input["width"]);
            h = Convert.ToInt32(input["height"]);

            //man.Logger.Debug(x, y, w, h, file.AbsolutePath, targetFile.AbsolutePath);

            try {
                ImageUtils.CropImage(file.AbsolutePath, targetFile.AbsolutePath, x, y, w, h, config.GetInt("edit.jpeg_quality", 90));
                rs.Add("OK", man.EncryptPath(targetFile.AbsolutePath), "{#message.crop_success}");
            } catch (Exception ex) {
                man.Logger.Error(ex.ToString());
                rs.Add("FAILED", man.EncryptPath(targetFile.AbsolutePath), "{#error.crop_failed}");
            }

            return rs;
        }
コード例 #4
0
ファイル: CorePlugin.cs プロジェクト: nhtera/CrowdCMS
        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;
        }
コード例 #5
0
ファイル: CorePlugin.cs プロジェクト: nhtera/CrowdCMS
        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;
        }
コード例 #6
0
ファイル: CorePlugin.cs プロジェクト: nhtera/CrowdCMS
        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;
        }
コード例 #7
0
ファイル: CorePlugin.cs プロジェクト: nhtera/CrowdCMS
        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}");
            }
        }
コード例 #8
0
        /// <summary>
        ///
        /// </summary>
        public static void SerializeRPC(string id, object error, object obj, Stream stream)
        {
            JSONWriter writer = new JSONWriter(new StreamWriter(stream));

            // Start JSON output
            writer.WriteStartObject();
            writer.WritePropertyName("result");

            // Serialize result set
            if (obj is Moxiecode.Manager.Utils.ResultSet)
            {
                ResultSet rs = (ResultSet)obj;

                writer.WriteStartObject();

                // Write header
                writer.WritePropertyName("header");
                writer.WriteStartObject();

                foreach (string key in rs.Header.Keys)
                {
                    writer.WritePropertyName(key);
                    writer.WriteValue(rs.Header[key]);
                }

                writer.WriteEndObject();

                // Write columns
                writer.WritePropertyName("columns");
                writer.WriteStartArray();

                foreach (string col in rs.Columns)
                {
                    writer.WriteValue(col);
                }

                writer.WriteEndArray();

                // Write data
                writer.WritePropertyName("data");
                writer.WriteStartArray();

                foreach (ArrayList row in rs.Data)
                {
                    writer.WriteStartArray();

                    foreach (object item in row)
                    {
                        WriteValue(writer, item);
                    }

                    writer.WriteEndArray();
                }

                writer.WriteEndArray();

                // Write config
                if (rs.Config != null)
                {
                    writer.WritePropertyName("config");
                    writer.WriteStartObject();

                    foreach (string key in rs.Config.AllKeys)
                    {
                        writer.WritePropertyName(key);
                        writer.WriteValue(rs.Config[key]);
                    }

                    writer.WriteEndObject();
                }

                // End result
                writer.WriteEndObject();
            }
            else
            {
                WriteValue(writer, obj);
            }

            // Write id
            writer.WritePropertyName("id");
            writer.WriteValue(id);

            // Write error
            writer.WritePropertyName("error");
            writer.WriteValue(null);

            // Close
            writer.WriteEndObject();
            writer.Close();
        }
コード例 #9
0
ファイル: CorePlugin.cs プロジェクト: nhtera/CrowdCMS
        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;
        }
コード例 #10
0
ファイル: CorePlugin.cs プロジェクト: nhtera/CrowdCMS
        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;
        }
コード例 #11
0
ファイル: CorePlugin.cs プロジェクト: nhtera/CrowdCMS
        /// <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;
        }
コード例 #12
0
ファイル: FileManagerPlugin.cs プロジェクト: nhtera/CrowdCMS
        private ResultSet MoveFiles(ManagerEngine man, Hashtable input)
        {
            ResultSet rs = new ResultSet(new string[]{"status", "fromfile", "tofile", "message"});
            IFile fromFile, toFile;
            ManagerConfig toConfig;
            FileType fromType;

            for (int i=0; input["frompath" + i] != null; i++) {
                fromFile = man.GetFile(man.DecryptPath((string) input["frompath" + i]));
                fromType = fromFile.IsFile ? FileType.File : FileType.Directory;

                if (input["topath" + i] != null)
                    toFile = man.GetFile(man.DecryptPath((string) input["topath" + i]), "", fromType);
                else {
                    if (input["toname" + i] != null)
                        toFile = man.GetFile(fromFile.Parent, (string) input["toname" + i], fromType);
                    else
                        toFile = man.GetFile(man.DecryptPath((string) input["topath"]), fromFile.Name, fromType);
                }

                toConfig = toFile.Config;

                if (!man.IsToolEnabled("cut", toConfig) && !man.IsToolEnabled("rename", toConfig))
                    throw new ManagerException("{#error.no_access}");

                // From file missing
                if (!fromFile.Exists) {
                    rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), "{#error.no_from_file}");
                    continue;
                }

                // User tried to change extension
                if (fromFile.IsFile && PathUtils.GetExtension(fromFile.Name) != PathUtils.GetExtension(toFile.Name)) {
                    rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), "{#error.move_failed}");
                    continue;
                }

                if (toConfig.GetBool("general.demo", false)) {
                    rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), "{#error.demo}");
                    continue;
                }

                if (!man.VerifyFile(toFile, "rename")) {
                    rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), man.InvalidFileMsg);
                    continue;
                }

                if (!toFile.CanWrite) {
                    rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), "{#error.no_write_access}");
                    continue;
                }

                if (!toConfig.GetBool("filesystem.writable", true)) {
                    rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), "{#error.no_write_access}");
                    continue;
                }

                // To file there
                if (toFile.Exists) {
                    rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), "{#error.tofile_exists}");
                    continue;
                }

                // Zip check
                if (toFile is ZipFileImpl) {
                    if (!man.VerifyFile(fromFile, "zip")) {
                        rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), man.InvalidFileMsg);
                        continue;
                    }
                }

                // Unzip check
                if (fromFile is ZipFileImpl) {
                    if (!man.VerifyFile(toFile, "unzip")) {
                        rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), man.InvalidFileMsg);
                        continue;
                    }
                }

                string fromPath = fromFile.AbsolutePath;

                if (fromFile.RenameTo(toFile))
                    rs.Add("OK", man.EncryptPath(fromPath), man.EncryptPath(toFile.AbsolutePath), "{#message.move_success}");
                else
                    rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), "{#error.move_failed}");
            }

            return rs;
        }
コード例 #13
0
ファイル: FileManagerPlugin.cs プロジェクト: nhtera/CrowdCMS
        private ResultSet CreateZip(ManagerEngine man, Hashtable input)
        {
            ResultSet rs = new ResultSet(new string[]{"status", "fromfile", "tofile", "message"});

            if (man.GetFile(man.DecryptPath((string) input["topath"]), (string) input["toname"] + ".zip").Exists)
                throw new ManagerException("{#error.tofile_exists}");

            for (int i=0; input["frompath" + i] != null; i++) {
                IFile fromFile = man.GetFile(man.DecryptPath((string) input["frompath" + i]));
                IFile toFile = man.GetFile("zip://" + PathUtils.AddTrailingSlash(man.DecryptPath((string) input["topath"])) + input["toname"] + ".zip", fromFile.Name);

                if (!man.IsToolEnabled("zip", toFile.Config))
                    throw new ManagerException("{#error.no_access}");

                if (!fromFile.Exists) {
                    rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), "{#error.no_from_file}");
                    continue;
                }

                // Zip check
                if (!man.VerifyFile(fromFile, "zip")) {
                    rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), man.InvalidFileMsg);
                    continue;
                }

                if (fromFile.CopyTo(toFile))
                    rs.Add("OK", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), "{#message.zip_success}");
            }

            return rs;
        }
コード例 #14
0
ファイル: FileManagerPlugin.cs プロジェクト: nhtera/CrowdCMS
        private ResultSet CreateDocs(ManagerEngine man, Hashtable input)
        {
            ResultSet rs = new ResultSet(new string[]{"status", "fromfile", "tofile", "message"});
            IFile fromFile, toFile;
            ManagerConfig toConfig;
            string ext;
            Hashtable fields;

            for (int i=0; input["frompath" + i] != null && input["toname" + i] != null; i++) {
                fromFile = man.GetFile(man.DecryptPath((string) input["frompath" + i]));
                ext = PathUtils.GetExtension(fromFile.Name);
                toFile = man.GetFile(man.DecryptPath((string) input["topath" + i]), (string) input["toname" + i] + "." + ext, FileType.File);
                toConfig = toFile.Config;

                if (!man.IsToolEnabled("createdoc", toConfig))
                    throw new ManagerException("{#error.no_access}");

                if (toConfig.GetBool("general.demo", false)) {
                    rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), "{#error.demo}");
                    continue;
                }

                if (!fromFile.Exists) {
                    rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), "{#error.template_missing}");
                    continue;
                }

                if (!man.VerifyFile(toFile, "createdoc")) {
                    rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), man.InvalidFileMsg);
                    continue;
                }

                if (!toFile.CanWrite) {
                    rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), "{#error.no_write_access}");
                    continue;
                }

                if (!toConfig.GetBool("filesystem.writable", true)) {
                    rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), "{#error.no_write_access}");
                    continue;
                }

                if (fromFile.CopyTo(toFile)) {
                    // Replace title
                    fields = (Hashtable) input["fields"];

                    // Replace all fields
                    if (fields != null) {
                        // Read all data
                        StreamReader reader = new StreamReader(toFile.Open(FileMode.Open));
                        string fileData = reader.ReadToEnd();
                        reader.Close();

                        // Replace fields
                        foreach (string name in fields.Keys)
                            fileData = fileData.Replace("${" + name + "}", (string) fields[name]);

                        // Write file data
                        StreamWriter writer = new StreamWriter(toFile.Open(FileMode.Create));
                        writer.Write(fileData);
                        writer.Close();
                    }

                    rs.Add("OK", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), "{#message.createdoc_success}");
                } else
                    rs.Add("FAILED", man.EncryptPath(fromFile.AbsolutePath), man.EncryptPath(toFile.AbsolutePath), "{#error.createdoc_failed}");
            }

            return rs;
        }
コード例 #15
0
ファイル: ImageManagerPlugin.cs プロジェクト: nhtera/CrowdCMS
        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;
        }
コード例 #16
0
ファイル: ImageManagerPlugin.cs プロジェクト: nhtera/CrowdCMS
        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;
        }
コード例 #17
0
ファイル: CorePlugin.cs プロジェクト: nhtera/CrowdCMS
        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}");
            }
        }