private ResultSet ResizeImage(ManagerEngine man, Hashtable input)
{
ResultSet rs = new ResultSet(new string[] { "status", "file", "message" });
IFile file, targetFile;
ManagerConfig config;
string tempName;
int 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;
}
w = Convert.ToInt32(input["width"]);
h = Convert.ToInt32(input["height"]);
try {
ImageUtils.ResizeImage(file.AbsolutePath, targetFile.AbsolutePath, w, h, config.GetInt("edit.jpeg_quality", 90));
rs.Add("OK", man.EncryptPath(targetFile.AbsolutePath), "{#message.resize_success}");
} catch (Exception ex) {
man.Logger.Error(ex.ToString());
rs.Add("FAILED", man.EncryptPath(targetFile.AbsolutePath), "{#error.resize_failed}");
}
return(rs);
}
/// <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);
}
private object RemoveFavorites(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)
{
return(rs);
}
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];
chunks.RemoveAt(chunks.IndexOf(path));
rs.Add("OK", man.EncryptPath(path), "Path was removed.");
}
cookie.Value = this.Implode(chunks, ",");
response.Cookies.Remove("fav");
response.Cookies.Add(cookie);
return(rs);
}
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);
}
public DataReader ExecuteReader()
{
var cursor = MongoConnection.MongoDatabase.GetCollection(CollectionName).FindAll();
Result result = new Result(cursor);
ResultSet resultSet = new ResultSet();
resultSet.Add(result);
DataReader reader = new DataReader(resultSet);
return reader;
}
public void CountTest()
{
ResultSet results = new ResultSet();
Assert.AreEqual(results.Count(), 0);
results.Add(new HashSet <int> {
1, 3
});
Assert.AreEqual(results.Count(), 1);
results.Add(new HashSet <int> {
2
});
Assert.AreEqual(results.Count(), 2);
}
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);
}
public void AddTest()
{
ResultSet results = new ResultSet();
results.Add(new HashSet <int> {
1, 3
});
Assert.IsTrue(results.Contains(1));
Assert.IsTrue(results.Contains(3));
Assert.IsFalse(results.Contains(2));
results.Add(new HashSet <int> {
2
});
Assert.IsTrue(results.Contains(2));
}
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);
}
public ResultSet BuildResultSet(SqlQuery query, IEnumerable<Entity> entities)
{
var entityType = Type.GetType(String.Format("{0}.{1}", typeof(Entity).Namespace, query.Entity), true, true);
var columnHeaders = GetColumnHeaders(query, entityType);
var set = new ResultSet(columnHeaders);
foreach (var entity in entities)
set.Add(BuildResultSetRow(columnHeaders, entity).ToList());
return set;
}
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);
}
/// <summary>
/// <paramref name="reader"/>를 읽어, <see cref="ResultRow"/>의 컬렉션인 <see cref="ResultSet"/>을 빌드합니다.
/// </summary>
/// <param name="reader">DataReader</param>
/// <param name="nameMapper">컬럼명을 속성명으로 매핑해주는 매퍼입니다.</param>
/// <param name="firstResult">첫번째 레코드 인덱스 (0부터 시작)</param>
/// <param name="maxResults">최대 레코드 수</param>
/// <returns><see cref="ResultSet"/> 인스턴스</returns>
public static ResultSet CreateResultSet(this IDataReader reader, INameMapper nameMapper, int firstResult, int maxResults)
{
reader.ShouldNotBeNull("reader");
if (nameMapper == null)
{
nameMapper = new SameNameMapper();
}
if (IsDebugEnabled)
{
log.Debug("IDataReader로부터 정보를 읽어 ResultRow들을 만들어 ResultSet 으로 빌드합니다...");
}
var resultSet = new ResultSet();
while (firstResult-- > 0)
{
if (reader.Read() == false)
{
return(resultSet);
}
}
if (maxResults <= 0)
{
maxResults = int.MaxValue;
}
resultSet.FieldNames = reader.GetFieldNames();
var rowIndex = 0;
while (reader.Read() && rowIndex++ < maxResults)
{
var row = new ResultRow();
foreach (var fieldName in resultSet.FieldNames)
{
row.Add(nameMapper.MapToPropertyName(fieldName), reader.AsValue(fieldName));
}
resultSet.Add(row);
}
if (IsDebugEnabled)
{
log.Debug("IDataReader로부터 정보를 읽어 ResultSet을 빌드했습니다!!! Row Count=[{0}]", resultSet.Count);
}
return(resultSet);
}
// Calculate expressions / Results / Percentage
private void Calc(string expresion, List <string> objectExpresion, int idx)
{
if (idx == objectExpresion.Count)
{
int numResult = (int)new DataTable().Compute(expresion, null);
ResultSet.Add(new Result(expresion.TrimStart(), numResult, Math.Round((1 / NumberOfExpressions) * 100, 2)));
return;
}
if (objectExpresion[idx].Equals("Dice"))
{
for (int i = 0; i < DiceDict[idx].Count; i++)
{
Calc($"{expresion} {DiceDict[idx][i]}", objectExpresion, idx + 1);
}
}
else
{
Calc($"{expresion} {objectExpresion[idx]}", objectExpresion, idx + 1);
}
}
public override bool Run()
{
_resultSet = new ResultSet();
var result = Environment.Market.GetAllData();
foreach (var x in result)
{
if (x.Value.GetType() == typeof(ScalarDate))
{
_resultSet.Add(x.Key.Key, x.Key.Value, (ScalarDate)x.Value);
continue;
}
if (x.Value.GetType() == typeof(ScalarEnum))
{
_resultSet.Add(x.Key.Key, x.Key.Value, (ScalarEnum)x.Value);
continue;
}
if (x.Value.GetType() == typeof(ScalarNum))
{
_resultSet.Add(x.Key.Key, x.Key.Value, (ScalarNum)x.Value);
continue;
}
if (x.Value.GetType() == typeof(ScalarStr))
{
_resultSet.Add(x.Key.Key, x.Key.Value, (ScalarStr)x.Value);
continue;
}
if (x.Value.GetType() == typeof(TimeSeries))
{
_resultSet.Add(x.Key.Key, (TimeSeries)x.Value);
//_resultSet.Add(x.Key.Key, (TimeSeries)x.Value);
continue;
}
if (x.Value.GetType() == typeof(CashFlow))
{
_resultSet.Add(x.Key.Key, x.Key.Value, (CashFlow)x.Value);
continue;
}
}
return(true);
}
private void AddToResultSet(ResultSet r, int i)
{
r.Add(new HashSet <int> {
i
});
}
/// <summary>
/// <paramref name="reader"/>를 읽어, <see cref="ResultRow"/>의 컬렉션인 <see cref="ResultSet"/>을 빌드합니다.
/// </summary>
/// <param name="reader">DataReader</param>
/// <param name="nameMapper">컬럼명을 속성명으로 매핑해주는 매퍼입니다.</param>
/// <param name="firstResult">첫번째 레코드 인덱스 (0부터 시작)</param>
/// <param name="maxResults">최대 레코드 수</param>
/// <returns><see cref="ResultSet"/> 인스턴스</returns>
public static ResultSet CreateResultSet(this IDataReader reader, INameMapper nameMapper, int firstResult, int maxResults) {
reader.ShouldNotBeNull("reader");
if(nameMapper == null)
nameMapper = new SameNameMapper();
if(IsDebugEnabled)
log.Debug("IDataReader로부터 정보를 읽어 ResultRow들을 만들어 ResultSet 으로 빌드합니다...");
var resultSet = new ResultSet();
while(firstResult-- > 0) {
if(reader.Read() == false)
return resultSet;
}
if(maxResults <= 0)
maxResults = int.MaxValue;
resultSet.FieldNames = reader.GetFieldNames();
var rowIndex = 0;
while(reader.Read() && rowIndex++ < maxResults) {
var row = new ResultRow();
foreach(var fieldName in resultSet.FieldNames)
row.Add(nameMapper.MapToPropertyName(fieldName), reader.AsValue(fieldName));
resultSet.Add(row);
}
if(IsDebugEnabled)
log.Debug("IDataReader로부터 정보를 읽어 ResultSet을 빌드했습니다!!! Row Count=[{0}]", resultSet.Count);
return resultSet;
}
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);
}
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}");
}
}
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);
}
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}");
}
}
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);
}
/// <summary>
/// Execute a select statement and return the results
/// @TODO: Clean up console writelines
/// </summary>
/// <param name="query"></param>
/// <param name="bindings"></param>
/// <returns></returns>
public ResultSet Select(string query, BindingsDict bindings)
{
IDbCommand cmd = PrepareCommand(query, bindings);
ResultSet results = new ResultSet();
try
{
if (_useTimer)
{
_execTimer.Start();
}
IDataReader dataReader = cmd.ExecuteReader();
Console.WriteLine("\nReading dataresult\n----------------------------");
while (dataReader.Read())
{
Row row = new Row();
for (int i = 0; i < dataReader.FieldCount; i++)
{
// Add this column to the current result row
Column newCol = new Column(dataReader.GetName(i), dataReader[i], dataReader[i].GetSqlValueType());
row.Add(newCol);
Console.WriteLine("[{0}]: '{1}'", dataReader.GetName(i), dataReader[i].ToString());
}
// Add the row to our final result set
results.Add(row);
}
#region Debug - Write out command text
// Print out all the parameters we added to the Command object
Console.WriteLine("\nUsing:\n[CommandText]: '{0}'", cmd.CommandText);
foreach (IDbDataParameter param in cmd.Parameters)
{
Console.WriteLine("[" + param.DbType.ToString() + "] Name: '" + param.ParameterName + "', Value: " + param.Value.ToString());
}
Console.WriteLine("-");
#endregion
dataReader.Close();
if (_useTimer)
{
_execTimer.Stop();
}
}
catch (Exception ex)
{
if (_useTimer)
{
_execTimer.Stop();
}
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
throw new DBException("Failed to execute reader on Select query!", ex);
}
return(results);
}
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);
}
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);
}
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);
}
private ResultSet Finalize(ZaagContext context)
{
int counter = 1;
foreach (var item in context.Cuts)
{
item.Source.Identity = counter++;
item.Result.Identity = counter++;
item.Remainder.Identity = counter++;
}
var allResults = new ResultSet(ResultType.Heading, "Resultaten: ");
var cutReport = new ResultSet(ResultType.Heading, "Zaagsnedes: ");
allResults.Add(cutReport);
foreach (Cut item in context.Cuts)
{
string worh = "Breedte";
if (item.WorH == 'h')
{
worh = "Diepte";
}
cutReport.Add(new ResultSet(ResultType.Dimension, string.Format(
"Zaag plank {10} van {0}x{1} " +
"over de {2} op {3} om " +
"plank {8} van {4}x{5} en " +
"plank {9} {6}x{7} te krijgen",
item.Source.Width, item.Source.Height,
worh, item.Position,
item.Result.Width, item.Result.Height,
item.Remainder.Width, item.Remainder.Height,
item.Result.Identity, item.Remainder.Identity,
item.Source.Identity)));
}
var remainderReport = new ResultSet(ResultType.Heading, "Reststukken: ");
allResults.Add(remainderReport);
foreach (var item in context.Remainders)
{
remainderReport.Add(new ResultSet(ResultType.Good, string.Format(
"plank {2} van {0}x{1}",
item.Width, item.Height, item.Identity)));
}
var resultReport = new ResultSet(ResultType.Heading, "Producten: ");
allResults.Add(resultReport);
foreach (var item in context.ReachedTargets)
{
resultReport.Add(new ResultSet(ResultType.Dimension, string.Format(
"plank {2} van {0}x{1}",
item.Width, item.Height, item.Identity)));
}
var unableReport = new ResultSet(ResultType.Heading, "Niet te maken: ");
allResults.Add(unableReport);
foreach (var item in context.PendingTargets)
{
unableReport.Add(new ResultSet(ResultType.Bad, string.Format(
"plank {2} van {0}x{1}",
item.Width, item.Height, item.Identity)));
}
return(allResults);
}