/// <summary> </summary>
JsonResult IDriver.Open(string target, bool tree, Hashtable posting_json_obj)
{
FullPath fullPath = ParsePath(target);
OpenResponse answer = new OpenResponse(DTOBase.Create(fullPath.Directory, fullPath.Root), fullPath);
foreach (var item in fullPath.Directory.GetFiles())
{
if (HttpContext.Current.Request.Params.AllKeys.Contains("mimes[]"))
{
if (file_mime.mime_type(item.Extension.Trim('.')).IndexOf(HttpContext.Current.Request.Params["mimes[]"]) > -1)
{
answer.AddResponse(DTOBase.Create(item, fullPath.Root, posting_json_obj));
}
}
else
{
answer.AddResponse(DTOBase.Create(item, fullPath.Root, posting_json_obj));
}
}
foreach (var item in fullPath.Directory.GetDirectories())
{
answer.AddResponse(DTOBase.Create(item, fullPath.Root));
}
return(Json(answer));
}
public AddResponse(DirInfo newDir, DirInfo parent, WebDavRoot root)
{
_added = new List <DTOBase>()
{
DTOBase.Create(newDir, parent, root)
};
}
JsonResult IDriver.Rename(string target, string name)
{
string oldTarget = target;
WebDavRoot lroot = this.GetRoot(target);
target = this.GetCorectTarget(target);
target = this.DecodeTarget(target);
DirInfo oldDirInfo = client.GetInfo(target);
if (oldDirInfo == null)
{
throw new ElFinderFileNotExists();
}
DirInfo parent = this.GetParent(oldDirInfo);
client.Rename(target, parent.RelPath + name);
DirInfo newDirInfo = client.GetInfo(parent.RelPath + name);
if (newDirInfo == null)
{
return(Error.Message("Невозможно переименовать файл. Задано некорректное имя."));
}
ReplaceResponse answer = new ReplaceResponse();
answer.Removed.Add(oldTarget);
answer.Added.Add(DTOBase.Create(newDirInfo, parent, lroot));
return(Json(answer));
}
public AddResponse(ResourceFolder newDir, Root root)
{
_added = new List <DTOBase>()
{
DTOBase.Create(newDir, root)
};
}
JsonResult IDriver.Rename(string target, string name)//done didnt tested
{
FullPath fullPath = ParsePath(target);
var answer = new ReplaceResponse();
answer.Removed.Add(target);
RemoveThumbs(fullPath);
if (fullPath.Directory != null)
{
var oldpathllist = new List <string>();
var oldfolderfiles = Directory.GetFiles(fullPath.Directory.FullName, "*", SearchOption.AllDirectories);
foreach (var oldfiles in oldfolderfiles)
{
oldpathllist.Add(oldfiles);
}
string newPath = Path.Combine(fullPath.Directory.Parent.FullName, name);
System.IO.Directory.Move(fullPath.Directory.FullName, newPath);
answer.Added.Add(DTOBase.Create(new DirectoryInfo(newPath), fullPath.Root));//when create new folder dont need add to it in index
var newfolderfiles = Directory.GetFiles(newPath, "*", SearchOption.AllDirectories);
var newpathllist = new List <string>();
foreach (var newfiles in newfolderfiles)
{
newpathllist.Add(newfiles);
}
BackgroundJob.Enqueue(() => IndexCRUD.OnRenameResponseFolder(oldpathllist, newpathllist));
}
else
{
string newPath = Path.Combine(fullPath.File.DirectoryName, name);
File.Move(fullPath.File.FullName, newPath);
IndexCRUD.OnRename(fullPath.File.FullName, newPath); //just rename and change create access time etc
answer.Added.Add(DTOBase.Create(new FileInfo(newPath), fullPath.Root));
}
return(Json(answer));
}
private void UserCheck(RequestBase request, DTOBase dto = null)
{
if (request.UserID <= 0)
{
throw new CustomException("کاربر درخواست کننده نامعتبر است.", $"UserID '{request.UserID}' is not valid");
}
var userReq = new UserRequest {
Filter = new UserFilter {
ID = request.UserID
}
};
var response = UserGet(userReq);
if (!(response?.Success == true))
{
throw new CustomException("کاربری با شناسه ارسالی یافت نشد", $"UserID '{request.UserID}' is not bound to any user.");
}
else if (dto != null)
{
if (dto.ID == 0)
{
dto.CreateUser = request.UserID;
}
else
{
dto.ModifyUser = request.UserID;
}
}
}
public AddResponse(ResourceFile newFile, Root root)
{
_added = new List <DTOBase>()
{
DTOBase.Create(newFile, root)
};
}
/// <summary> </summary>
public AddResponse(FileInfo newFile, Root root)
{
_added = new List <DTOBase>()
{
DTOBase.Create(newFile, root)
};
}
JsonResult IDriver.Tree(string target)
{
var fullPath = ParsePath(target);
var answer = new TreeResponse();
if (fullPath.Directory.ResourceId.Equals(Guid.Empty))
{
// Volumen path
var volume = ResourceManager.Instance.GetOrAddVolumeFolder(_project, fullPath.Directory.TypesOfResource);
if (volume != null)
{
foreach (var item in volume.Children.OfType <ResourceFolder>())
{
answer.Tree.Add(DTOBase.Create(item, fullPath.Root));
}
}
}
else
{
foreach (var item in ResourceManager.Instance.GetFolders(fullPath.Directory))
{
answer.Tree.Add(DTOBase.Create(item, fullPath.Root));
}
}
return(Json(answer));
}
/// <summary> </summary>
public AddResponse(DirectoryInfo newDir, Root root)
{
_added = new List <DTOBase>()
{
DTOBase.Create(newDir, root)
};
}
/// <summary> </summary>
JsonResult IDriver.Extract(string target, IEnumerable <string> targets)
{
FullPath dest = ParsePath(target);
var response = new AddResponse();
//this should move all files to a temp folder
//then extract then there
//then count them and get a list of the names
//move them all in mass to the target folder
//then respond with the file info
foreach (var item in targets)
{
FullPath fullPath = ParsePath(item);
FileInfo fileinfo = new FileInfo(fullPath.File.Name);
DirectoryInfo newDir = Directory.CreateDirectory(file_info.site_cache_path() + "/temp/");
file_handler.Decompress(fileinfo);
response.added.Add((FileDTO)DTOBase.Create(fileinfo, dest.Root));
}
return(Json(response));
}
JsonResult IDriver.Open(string target, bool tree)
{
WebDavRoot lroot = this.GetRoot(target);
target = this.GetCorectTarget(target);
target = this.DecodeTarget(target, lroot.Directory.RelPath);
List <DirInfo> filesFormWebFav = client.GetDirectories(target, true);
List <DirInfo> directories = filesFormWebFav.FindAll(d => d.IsDirectory);
DirInfo targetDirInfo = directories[0];
DirInfo parentDirInfo = this.GetParent(targetDirInfo);
targetDirInfo.HasSubDirectories = filesFormWebFav != null && directories != null && directories.Count > 1;
OpenResponseBase answer = new OpenResponseBase(DTOBase.Create(targetDirInfo, parentDirInfo, lroot));
if (filesFormWebFav != null)
{
filesFormWebFav.Remove(targetDirInfo);
foreach (DirInfo dirInfo in filesFormWebFav)
{
dirInfo.HasSubDirectories = IsConstainsChild(dirInfo);
answer.Files.Add(DTOBase.Create(dirInfo, targetDirInfo, lroot));
}
}
//HttpContext.Current.Session[RetTarget] = answer.CurrentWorkingDirectory.Hash;
return(Json(answer));
}
JsonResult IDriver.Filter(string target, string query)
{
WebDavRoot lroot = this.GetRoot(target);
target = this.GetCorectTarget(target);
target = this.DecodeTarget(target, lroot.Directory.RelPath);
List <DirInfo> filesFormWebFav = client.GetDirectories(target, true);
List <DirInfo> directories = filesFormWebFav.FindAll(d => d.IsDirectory);
DirInfo targetDirInfo = directories[0];
DirInfo parentDirInfo = this.GetParent(targetDirInfo);
targetDirInfo.HasSubDirectories = filesFormWebFav != null && directories != null && directories.Count > 1;
OpenResponseBase answer = new OpenResponseBase(DTOBase.Create(targetDirInfo, parentDirInfo, lroot));
if (filesFormWebFav != null)
{
filesFormWebFav.Remove(targetDirInfo);
foreach (DirInfo dirInfo in filesFormWebFav)
{
if (!Filter(dirInfo, query))
{
continue;
}
answer.Files.Add(DTOBase.Create(dirInfo, targetDirInfo, lroot));
}
}
var r = Json(answer);
return(r);
}
JsonResult IDriver.Duplicate(IEnumerable <string> targets)
{
AddResponse response = new AddResponse();
foreach (var target in targets)
{
FullPath fullPath = ParsePath(target);
if (fullPath.Directory != null)
{
var parentPath = fullPath.Directory.Parent.FullName;
var name = fullPath.Directory.Name;
var newName = string.Format(@"{0}\{1} copy", parentPath, name);
if (!Directory.Exists(newName))
{
DirectoryCopy(fullPath.Directory, newName, true);
}
else
{
for (int i = 1; i < 100; i++)
{
newName = string.Format(@"{0}\{1} copy {2}", parentPath, name, i);
if (!Directory.Exists(newName))
{
DirectoryCopy(fullPath.Directory, newName, true);
break;
}
}
}
response.Added.Add(DTOBase.Create(new DirectoryInfo(newName), fullPath.Root));
}
else
{
var parentPath = fullPath.File.Directory.FullName;
var name = fullPath.File.Name.Substring(0, fullPath.File.Name.Length - fullPath.File.Extension.Length);
var ext = fullPath.File.Extension;
var newName = string.Format(@"{0}\{1} copy{2}", parentPath, name, ext);
if (!File.Exists(newName))
{
fullPath.File.CopyTo(newName);
}
else
{
for (int i = 1; i < 100; i++)
{
newName = string.Format(@"{0}\{1} copy {2}{3}", parentPath, name, i, ext);
if (!File.Exists(newName))
{
fullPath.File.CopyTo(newName);
break;
}
}
}
response.Added.Add(DTOBase.Create(new FileInfo(newName), fullPath.Root));
}
}
return(Json(response));
}
/// <summary> </summary>
JsonResult IDriver.retrive_object(string target)
{
FullPath fullPath = ParsePath(target);
OpenResponse answer = new OpenResponse(DTOBase.Create(fullPath.File.Directory, fullPath.Root), fullPath);
answer.AddResponse(DTOBase.Create(fullPath.File, fullPath.Root));
return(Json(answer));
}
JsonResult IDriver.Rotate(string target, int degree)
{
FullPath path = ParsePath(target);
path.Root.PicturesEditor.Rotate(path.File.FullName, degree);
var output = new ChangedResponse();
output.Changed.Add((FileDTO)DTOBase.Create(path.File, path.Root));
return(Json(output));
}
JsonResult IDriver.Crop(string target, int x, int y, int width, int height)
{
var path = ParsePath(target);
path.Root.PicturesEditor.Crop(path.File.FullName, x, y, width, height);
var output = new ChangedResponse();
output.Changed.Add((FileDTO)DTOBase.Create(path.File, path.Root));
return(Json(output));
}
public JsonResult Upload(string target, string name, byte[] fileBytes)
{
FullPath dest = ParsePath(target);
var response = new AddResponse();
if (dest.Root.MaxUploadSize.HasValue)
{
if (fileBytes.Length > dest.Root.MaxUploadSize.Value)
{
return(Error.MaxUploadFileSize());
}
}
FileInfo path = new FileInfo(Path.Combine(dest.Directory.FullName, name));
if (path.Exists)
{
if (dest.Root.UploadOverwrite)
{
//if file already exist we rename the current file,
//and if upload is succesfully delete temp file, in otherwise we restore old file
string tmpPath = path.FullName + Guid.NewGuid();
bool uploaded = false;
try
{
File.WriteAllBytes(tmpPath, fileBytes);
uploaded = true;
}
catch { }
finally
{
if (uploaded)
{
File.Delete(path.FullName);
File.Move(tmpPath, path.FullName);
}
else
{
File.Delete(tmpPath);
}
}
}
else
{
File.WriteAllBytes(Path.Combine(path.DirectoryName, Helper.GetDuplicatedName(path)), fileBytes);
}
}
else
{
File.WriteAllBytes(path.FullName, fileBytes);
}
response.Added.Add((FileDTO)DTOBase.Create(new FileInfo(path.FullName), dest.Root));
return(Json(response));
}
JsonResult IDriver.Resize(string target, int width, int height)
{
FullPath path = ParsePath(target);
RemoveThumbs(path);
path.Root.PicturesEditor.Resize(path.File.FullName, width, height);
var output = new ChangedResponse();
output.Changed.Add((FileDTO)DTOBase.Create(path.File, path.Root));
return(Json(output));
}
/// <summary> </summary>
JsonResult IDriver.Put(string target, string content)
{
FullPath fullPath = ParsePath(target);
PutResponse answer = new PutResponse();
using (StreamWriter writer = new StreamWriter(fullPath.File.FullName, false)) {
writer.Write(content);
}
answer.changed.Add((FileDTO)DTOBase.Create(fullPath.File, fullPath.Root));
return(Json(answer));
}
JsonResult IDriver.Tree(string target)
{
FullPath fullPath = ParsePath(target);
TreeResponse answer = new TreeResponse();
foreach (var item in fullPath.Directory.GetDirectories())
{
answer.Tree.Add(DTOBase.Create(item, fullPath.Root));
}
return(Json(answer));
}
JsonResult IDriver.Init(string target)
{
FullPath fullPath;
if (string.IsNullOrEmpty(target))
{
Root root = _roots.FirstOrDefault(r => r.StartPath != null);
if (root == null)
{
root = _roots.First();
}
fullPath = new FullPath(root, root.StartPath ?? root.Directory);
}
else
{
fullPath = ParsePath(target);
}
InitResponse answer = new InitResponse(DTOBase.Create(fullPath.Directory, fullPath.Root), new Options(fullPath));
foreach (FileInfo item in fullPath.Directory.GetFiles())
{
if ((item.Attributes & FileAttributes.Hidden) != FileAttributes.Hidden)
{
answer.Files.Add(DTOBase.Create(item, fullPath.Root));
}
}
foreach (DirectoryInfo item in fullPath.Directory.GetDirectories())
{
if ((item.Attributes & FileAttributes.Hidden) != FileAttributes.Hidden)
{
answer.Files.Add(DTOBase.Create(item, fullPath.Root));
}
}
foreach (Root item in _roots)
{
answer.Files.Add(DTOBase.Create(item.Directory, item));
}
if (fullPath.Root.Directory.FullName != fullPath.Directory.FullName)
{
foreach (DirectoryInfo item in fullPath.Root.Directory.GetDirectories())
{
if ((item.Attributes & FileAttributes.Hidden) != FileAttributes.Hidden)
{
answer.Files.Add(DTOBase.Create(item, fullPath.Root));
}
}
}
if (fullPath.Root.MaxUploadSize.HasValue)
{
answer.UploadMaxSize = fullPath.Root.MaxUploadSizeInKb.Value + "K";
}
return(Json(answer));
}
JsonResult IDriver.Put(string target, string content)
{
var fullPath = ParsePath(target);
var answer = new ChangedResponse();
using (var blob = BlobFactory.GetBlobStorage(fullPath.File.ResourceId, BlobFactory.Container.Resources)) {
blob.Content = Encoding.ASCII.GetBytes(content);
blob.Save();
}
answer.Changed.Add((FileDTO)DTOBase.Create(fullPath.File, fullPath.Root));
return(Json(answer));
}
JsonResult IDriver.Duplicate(IEnumerable <string> targets)
{
AddResponse response = new AddResponse();
foreach (string target in targets)
{
WebDavRoot lroot = this.GetRoot(target);
string ext = "", path = "", nameWithoutExt = "";
string targetDecrypted = this.DecodeTarget(this.GetCorectTarget(target));
DirInfo targetInfo = client.GetInfo(targetDecrypted);
if (targetInfo == null)
{
throw new ElFinderFileNotExists();
}
string destinationFileName;
if (targetInfo.IsDirectory && targetDecrypted.EndsWith("/"))
{
destinationFileName = targetDecrypted.Substring(0, targetDecrypted.Length - 1) + " (1)";
}
else
{
path = targetDecrypted.Replace(targetInfo.DisplayName, "");
ext = Path.GetExtension(targetInfo.DisplayName);
nameWithoutExt = targetInfo.DisplayName.Replace(ext, "");
destinationFileName = string.Format("{0}{1} (1){2}", path, nameWithoutExt, ext);
}
DirInfo destInfo = client.GetInfo(destinationFileName);
int i = 2;
while (destInfo != null)
{
if (targetInfo.IsDirectory && targetDecrypted.EndsWith("/"))
{
destinationFileName = string.Format("{0} ({1})", targetDecrypted.Substring(0, targetDecrypted.Length - 1), i);
}
else
{
destinationFileName = string.Format("{0}{1} ({3}){2}", path, nameWithoutExt, ext, i);
}
destInfo = client.GetInfo(destinationFileName);
i++;
}
client.Copy(targetDecrypted, destinationFileName);
destInfo = client.GetInfo(destinationFileName);
DirInfo parent = this.GetParent(destInfo);
response.Added.Add(DTOBase.Create(destInfo, parent, lroot));
}
return(Json(response));
}
public JsonResult Tree(string target)
{
FullPath fullPath = ParsePath(target);
TreeResponse answer = new TreeResponse();
foreach (var item in fullPath.Directory.GetDirectories())
{
if ((item.Attributes & FileAttributes.Hidden) != FileAttributes.Hidden)
{
answer.Tree.Add(DTOBase.Create(item, fullPath.Root));
}
}
return(Json(answer));
}
JsonResult IDriver.Init(string target)
{
FullPath fullPath;
if (string.IsNullOrEmpty(target))
{
var root = _roots.FirstOrDefault(r => r.StartPath != null);
if (root == null)
{
root = _roots.First();
}
fullPath = new FullPath(root, root.Directory);
}
else
{
fullPath = ParsePath(target);
}
var answer = new InitResponse(DTOBase.Create(fullPath.Directory, fullPath.Root), new Options(fullPath));
foreach (var item in _roots)
{
answer.Files.Add(DTOBase.Create(item.Directory, item));
}
if (fullPath.Root.Directory.FullName != fullPath.Directory.FullName)
{
foreach (var item in ResourceManager.Instance.GetFiles(fullPath.Directory).Where(item => item.CanRead()))
{
answer.Files.Add(DTOBase.Create(item, fullPath.Root));
}
}
else
{
foreach (var item in ResourceManager.Instance.GetFiles(fullPath.Directory).Where(item => item.CanRead()))
{
fullPath.Root.Directory = fullPath.Directory;
answer.Files.Add(DTOBase.Create(item, fullPath.Root));
}
}
foreach (var item in ResourceManager.Instance.GetFolders(fullPath.Directory).Where(item => item.CanRead()))
{
//sfullPath.Root.Directory = fullPath.Directory;
answer.Files.Add(DTOBase.Create(item, fullPath.Root));
}
if (fullPath.Root.MaxUploadSize.HasValue)
{
answer.UploadMaxSize = fullPath.Root.MaxUploadSizeInKb.Value + "K";
}
return(Json(answer));
}
JsonResult IDriver.Paste(string source, string dest, IEnumerable <string> targets, bool isCut)
{
FullPath destPath = ParsePath(dest);
ReplaceResponse response = new ReplaceResponse();
foreach (var item in targets)
{
FullPath src = ParsePath(item);
if (src.Directory != null)
{
DirectoryInfo newDir = new DirectoryInfo(Path.Combine(destPath.Directory.FullName, src.Directory.Name));
if (newDir.Exists)
{
Directory.Delete(newDir.FullName, true);
}
if (isCut)
{
RemoveThumbs(src);
src.Directory.MoveTo(newDir.FullName);
response.Removed.Add(item);
}
else
{
DirectoryCopy(src.Directory, newDir.FullName, true);
}
response.Added.Add(DTOBase.Create(newDir, destPath.Root));
}
else
{
string newFilePath = Path.Combine(destPath.Directory.FullName, src.File.Name);
if (File.Exists(newFilePath))
{
File.Delete(newFilePath);
}
if (isCut)
{
RemoveThumbs(src);
src.File.MoveTo(newFilePath);
response.Removed.Add(item);
}
else
{
File.Copy(src.File.FullName, newFilePath);
}
response.Added.Add(DTOBase.Create(new FileInfo(newFilePath), destPath.Root));
}
}
return(Json(response));
}
JsonResult IDriver.Init(string target)
{
Root root;
DirectoryInfo dir;
if (string.IsNullOrEmpty(target))
{
root = _roots.FirstOrDefault(r => r.StartPath != null);
if (root == null)
{
root = _roots.First();
}
dir = root.StartPath == null ? root.Directory : root.StartPath;
}
else
{
FullPath fullPath = ParsePath(target);
root = fullPath.Root;
dir = fullPath.Directory;
}
InitResponse answer = new InitResponse(DTOBase.Create(dir, root));
foreach (var item in dir.GetFiles())
{
answer.AddResponse(DTOBase.Create(item, root));
}
foreach (var item in dir.GetDirectories())
{
answer.AddResponse(DTOBase.Create(item, root));
}
foreach (var item in _roots)
{
answer.AddResponse(DTOBase.Create(item.Directory, item));
}
if (root.Directory.FullName != dir.FullName)
{
foreach (var item in root.Directory.GetDirectories())
{
answer.AddResponse(DTOBase.Create(item, root));
}
}
string parentPath = string.IsNullOrEmpty(target) ? root.Alias : root.Alias + dir.FullName.Substring(root.Directory.FullName.Length).Replace('\\', '/');
answer.Options.Path = parentPath;
answer.Options.Url = root.Url;
answer.Options.ThumbnailsUrl = root.TmbUrl;
return(Json(answer));
}
JsonResult IDriver.Open(string target, bool tree)
{
FullPath fullPath = ParsePath(target);
OpenResponse answer = new OpenResponse(DTOBase.Create(fullPath.Directory, fullPath.Root), fullPath);
foreach (var item in fullPath.Directory.GetFiles())
{
answer.AddResponse(DTOBase.Create(item, fullPath.Root));
}
foreach (var item in fullPath.Directory.GetDirectories())
{
answer.AddResponse(DTOBase.Create(item, fullPath.Root));
}
return(Json(answer));
}
JsonResult IDriver.Rotate(string target, int degree)
{
WebDavRoot lroot = this.GetRoot(target);
target = this.GetCorectTarget(target);
string decodedTarget = this.DecodeTarget(target);
WebDavPicturesEditor pictureEditor = new WebDav.WebDavPicturesEditor(client);
pictureEditor.Rotate(decodedTarget, degree);
DirInfo targetInfo = client.GetInfo(decodedTarget);
DirInfo parentInfo = this.GetParent(targetInfo);
ChangedResponse response = new ChangedResponse();
response.Changed.Add((FileDTO)DTOBase.Create(targetInfo, parentInfo, lroot));
return(Json(response));
}
