protected virtual void OkClicked(object sender, System.EventArgs e)
{
ReplaceResponse response = ReplaceResponse.Abort;
bool all = applyAll.Active;
if (radioKeep.Active && all)
{
response = ReplaceResponse.SkipAll;
}
else if (radioKeep.Active)
{
response = ReplaceResponse.Skip;
}
else if (radioReplace.Active && all)
{
response = ReplaceResponse.ReplaceAll;
}
else if (radioReplace.Active)
{
response = ReplaceResponse.Replace;
}
else if (radioNewest.Active && all)
{
response = ReplaceResponse.ReplaceOlderAll;
}
else if (radioNewest.Active)
{
response = ReplaceResponse.ReplaceOlder;
}
Respond((int)response);
}
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));
}
void SetState(ReplaceResponse response)
{
switch (response)
{
case ReplaceResponse.Replace:
case ReplaceResponse.ReplaceAll:
radioNewest.Active = true;
break;
case ReplaceResponse.Skip:
case ReplaceResponse.SkipAll:
radioKeep.Active = true;
break;
case ReplaceResponse.ReplaceOlder:
case ReplaceResponse.ReplaceOlderAll:
radioNewest.Active = true;
break;
}
if (response == ReplaceResponse.ReplaceOlderAll || response == ReplaceResponse.SkipAll)
{
applyAll.Active = true;
}
}
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));
}
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));
}
public FileReplaceDialog(ReplaceResponse preSelect, string sourceName, string sourceModified, string targetName, string targetModified)
{
this.Build();
//WORKAROUND: Stetic doesn't yet support setting mnemonics in markup so had to handle it here
replaceLabel.MarkupWithMnemonic = GettextCatalog.GetString("<b>_Replace with source file</b>");
keepLabel.MarkupWithMnemonic = GettextCatalog.GetString("<b>_Keep existing target file</b>");
newestLabel.MarkupWithMnemonic = GettextCatalog.GetString("<b>Use the _newest file</b>");
this.sourceName.Text = sourceName;
this.sourceModified.Text = sourceModified;
this.targetName.Text = targetName;
this.targetModified.Text = targetModified;
SetState(preSelect);
okButton.GrabFocus();
this.Resize(1, 1); // make window as small as widgets allow
}
public FileReplaceDialog (ReplaceResponse preSelect, string sourceName, string sourceModified, string targetName, string targetModified)
{
this.Build();
//WORKAROUND: Stetic doesn't yet support setting mnemonics in markup so had to handle it here
replaceLabel.MarkupWithMnemonic = GettextCatalog.GetString ("<b>_Replace with source file</b>");
keepLabel.MarkupWithMnemonic = GettextCatalog.GetString ("<b>_Keep existing target file</b>");
newestLabel.MarkupWithMnemonic = GettextCatalog.GetString ("<b>Use the _newest file</b>");
this.sourceName.Text = sourceName;
this.sourceModified.Text = sourceModified;
this.targetName.Text = targetName;
this.targetModified.Text = targetModified;
SetState (preSelect);
okButton.GrabFocus ();
this.Resize (1, 1); // make window as small as widgets allow
}
JsonResult IDriver.Rename(string target, string name)
{
var fullPath = ParsePath(target);
var answer = new ReplaceResponse();
answer.Removed.Add(target);
if (fullPath.Directory != null)
{
var folder = ResourceManager.Instance.GetFolder(fullPath.Directory.ResourceId);
ResourceManager.Instance.RenameResource(folder, name);
answer.Added.Add(DTOBase.Create(folder, fullPath.Root));
}
else
{
var file = ResourceManager.Instance.GetFile(fullPath.File.ResourceId);
ResourceManager.Instance.RenameResource(file, name);
answer.Added.Add(DTOBase.Create(new ResourceFile(), fullPath.Root));
}
return(Json(answer));
}
void SetState (ReplaceResponse response)
{
switch (response) {
case ReplaceResponse.Replace:
case ReplaceResponse.ReplaceAll:
radioNewest.Active = true;
break;
case ReplaceResponse.Skip:
case ReplaceResponse.SkipAll:
radioKeep.Active = true;
break;
case ReplaceResponse.ReplaceOlder:
case ReplaceResponse.ReplaceOlderAll:
radioNewest.Active = true;
break;
}
if (response == ReplaceResponse.ReplaceOlderAll || response == ReplaceResponse.SkipAll)
applyAll.Active = true;
}
JsonResult IDriver.Rename(string target, string name)
{
FullPath fullPath = ParsePath(target);
var answer = new ReplaceResponse();
answer.Removed.Add(target);
if (fullPath.Directory != null)
{
fullPath.Directory.MoveTo(Path.Combine(fullPath.Directory.Parent.FullName, name));
var newDir = new DirectoryInfo(Path.Combine(fullPath.Directory.Parent.FullName, name));
answer.Added.Add(DTOBase.Create(newDir, fullPath.Root));
}
else
{
fullPath.File.MoveTo(Path.Combine(fullPath.File.Directory.FullName, name));
var newFile = new FileInfo(Path.Combine(fullPath.File.Directory.FullName, name));
answer.Added.Add(DTOBase.Create(newFile, fullPath.Root));
}
return(Json(answer));
}
public JsonResult Rename(string target, string name)
{
FullPath fullPath = ParsePath(target);
var answer = new ReplaceResponse();
answer.Removed.Add(target);
RemoveThumbs(fullPath);
if (fullPath.Directory != null)
{
string newPath = Path.Combine(fullPath.Directory.Parent.FullName, name);
Directory.Move(fullPath.Directory.FullName, newPath);
answer.Added.Add(DTOBase.Create(new DirectoryInfo(newPath), fullPath.Root));
}
else
{
string newPath = Path.Combine(fullPath.File.DirectoryName, name);
File.Move(fullPath.File.FullName, newPath);
answer.Added.Add(DTOBase.Create(new FileInfo(newPath), fullPath.Root));
}
return(Json(answer));
}
public JsonResult Rename(string target, string name)
{
if (!string.IsNullOrEmpty(target))
{
var path = Helper.DecodePath(target).Replace("\\", "/").Replace(@"\", "/").Replace("//", "/");
if (string.IsNullOrEmpty(Path.GetExtension(path)))
{
throw new NotImplementedException("Cannot found process rename folder.");
}
var index = path.LastIndexOf('/');
var folder = string.Empty;
var fileName = string.Empty;
if (index > -1)
{
folder = path.Substring(0, index);
fileName = path.Replace(folder, string.Empty);
}
var answer = new ReplaceResponse();
mediaService.RenameFile(folder, fileName, name);
answer.Removed.Add(target);
var relativePath = storageProvider.Combine(folder, name);
var file = storageProvider.GetFile(relativePath);
var mediaFile = new MediaFile
{
Name = name,
Size = file.GetSize(),
LastUpdated = file.GetLastUpdated(),
Type = file.GetFileType(),
FolderName = folder,
MediaPath = mediaService.GetMediaPublicUrl(folder, name)
};
answer.Added.Add(CreateDto(mediaFile));
return(Json(answer));
}
throw new NotImplementedException();
}
JsonResult IDriver.Paste(string source, string dest, IEnumerable <string> targets, bool isCut, IList <int> dublicateIndexes = null)
{
ReplaceResponse response = new ReplaceResponse();
string destDecrypted = this.DecodeTarget(this.GetCorectTarget(dest));
DirInfo destInfo = client.GetInfo(destDecrypted);
int ind = 0;
foreach (string target in targets)
{
WebDavRoot lroot = this.GetRoot(dest);
string targetDecrypted = this.DecodeTarget(this.GetCorectTarget(target));
DirInfo targetInfo = client.GetInfo(targetDecrypted);
if (targetInfo == null)
{
throw new ElFinderFileNotExists();
}
if (isCut)
{
response.Removed.Add(this.GetCorectTarget(target));
client.Move(targetDecrypted, destDecrypted + targetInfo.DisplayName);
targetInfo = client.GetInfo(destInfo.RelPath + targetInfo.DisplayName);
response.Added.Add(DTOBase.Create(targetInfo, destInfo, lroot));
}
else
{
string destinationFileName = dublicateIndexes != null && dublicateIndexes.Contains(ind)
? GetCorrectDestinationFileName(destInfo.RelPath + targetInfo.DisplayName)
: destInfo.RelPath + targetInfo.DisplayName;
client.Copy(targetDecrypted, destinationFileName);
targetInfo = client.GetInfo(destinationFileName);
DirInfo parent = this.GetParent(targetInfo);
response.Added.Add(DTOBase.Create(targetInfo, parent, lroot));
}
ind++;
}
return(Json(response));
}
JsonResult IDriver.Paste(string source, string dest, IEnumerable <string> targets, bool isCut)
{
var destPath = ParsePath(dest);
var response = new ReplaceResponse();
foreach (var item in targets)
{
var src = ParsePath(item);
if (src.Directory != null)
{
if (isCut)
{
ResourceManager.Instance.MoveFolder(src.Directory, destPath.Directory);
response.Removed.Add(item);
}
else
{
DirectoryCopy(src.Directory, destPath.Directory, item, true);
}
response.Added.Add(DTOBase.Create(destPath.Directory, destPath.Root));
}
else
{
ResourceFile newFile;
if (isCut)
{
newFile = ResourceManager.Instance.MoveFile(src.File, destPath.Directory);
response.Removed.Add(item);
}
else
{
newFile = ResourceManager.Instance.CopyFile(src.File, destPath.Directory);
}
response.Added.Add(DTOBase.Create(newFile, destPath.Root));
}
}
return(Json(response));
}
JsonResult IDriver.Paste(string source, string dest, IEnumerable <string> targets, bool isCut)//todo:gonna look at that later !!!!!!!!!!!
{
FullPath destPath = ParsePath(dest);
ReplaceResponse response = new ReplaceResponse();
foreach (var item in targets)
{
FullPath src = ParsePath(item);
string oldpathname = null;
if (src.Directory == null)
{
oldpathname = src.File.FullName;
}
if (src.Directory != null)
{
DirectoryInfo newDir = new DirectoryInfo(Path.Combine(destPath.Directory.FullName, src.Directory.Name));
if (newDir.Exists)
{
var filesindirdest = Directory.GetFiles(newDir.FullName, "*", SearchOption.AllDirectories);
Directory.Delete(newDir.FullName, true);
foreach (var fileindirdest in filesindirdest)
{
IndexCRUD.DeleteLuceneIndex(fileindirdest);
}
}
if (isCut)
{
RemoveThumbs(src);
var filesindirsrc = Directory.GetFiles(src.Directory.FullName, "*", SearchOption.AllDirectories);
src.Directory.MoveTo(newDir.FullName);
var filesindirdestnew = Directory.GetFiles(newDir.FullName, "*", SearchOption.AllDirectories);
for (int i = 0; i < filesindirsrc.Count(); i++)
{
IndexCRUD.OnMove(filesindirdestnew[i], filesindirsrc[i], isCut);
}
response.Removed.Add(item);
}
else
{
var filesindirsrc = Directory.GetFiles(src.Directory.FullName, "*", SearchOption.AllDirectories);
DirectoryCopy(src.Directory, newDir.FullName, true);
var filesindirdestnew = Directory.GetFiles(newDir.FullName, "*", SearchOption.AllDirectories);
for (int i = 0; i < filesindirsrc.Count(); i++)
{
IndexCRUD.OnMove(filesindirdestnew[i], filesindirsrc[i], isCut);
}
}
response.Added.Add(DTOBase.Create(newDir, destPath.Root));
}
else
{
string newFilePath = Path.Combine(destPath.Directory.FullName, Path.GetFileName(oldpathname));
if (File.Exists(newFilePath))
{
//if(LuceneIndexController.CalculateMD5(newFilePath)==LuceneIndexController.CalculateMD5(src.File.FullName))
//{
File.Delete(newFilePath);
IndexCRUD.DeleteLuceneIndex(newFilePath);
}
if (isCut)
{
RemoveThumbs(src);
src.File.MoveTo(newFilePath);
IndexCRUD.OnMove(newFilePath, oldpathname, isCut);
response.Removed.Add(item);
}
else
{
File.Copy(src.File.FullName, newFilePath);
IndexCRUD.OnMove(newFilePath, oldpathname, isCut);
}
response.Added.Add(DTOBase.Create(new FileInfo(newFilePath), destPath.Root));
}
}
return(Json(response));
}
public void Init()
{
instance = new ReplaceResponse();
}