public static void RemoveAllThatOutdates(string directory, int outdatedDays, FileOrDirectory fileOrDirectory)
{
var dirs = fileOrDirectory == FileOrDirectory.Directory
? Directory.GetDirectories(directory)
: Directory.GetFiles(directory);
foreach (var f in dirs)
{
var dt = fileOrDirectory == FileOrDirectory.Directory
? Directory.GetCreationTime(f)
: File.GetCreationTime(f);
var ts = DateTime.Now - dt;
if (ts.Days <= outdatedDays)
{
continue;
}
if (fileOrDirectory == FileOrDirectory.Directory)
{
Directory.Delete(f, true);
}
else
{
File.Delete(f);
}
}
}
public static void Main(string[] args)
{
var window = new Window();
var left = window.SplitLeft("left");
var right = window.SplitRight("right");
var cd = new DirectoryInfo(Environment.CurrentDirectory);
var dir = cd.Parent.Parent.Parent;
IEnumerable <FileOrDirectory> items = FileOrDirectory.ReadDir(dir);
var listview = new ListView <FileOrDirectory>(left, items, i => new[] {
i.Name,
i.Size.ToString(),
i.LastModifiedUTC.ToString("dd MMM yyyy hh:mm")
}, ("Name", 0), ("Size", 20), ("Modified", 22)); // get algorithm from SplitRows and SplitColumns
listview.Refresh();
Console.ReadKey(true);
// list needs to scroll
// needs to have a current item
// needs to highlight items
// needs to react to arrow keys up and down (to start with)
// window.Keyboard.OnUp(()=> )
// window.Keyboard.OnDown(()=> );
// will need to define exit? to stop
// window.clear to remove list?
}
public PathDataType(ScriptParameter p, XmlNode DataTypeNode)
{
m_Parameter = p;
m_Path = p.ParameterValue;
XmlNode ChildNode = DataTypeNode.FirstChild;
m_FileOrDirectory = ChildNode.Name == "file" ? FileOrDirectory.File : FileOrDirectory.Directory;
m_InputOrOutput = ChildNode.Attributes.GetNamedItem("type").Value == "input" ? InputOrOutput.input : InputOrOutput.output;
}
public FtpDirectory(Sync sync, FileOrDirectory parent, Uri url)
{
Sync = sync;
Parent = parent;
if (url.Scheme != "ftp" && url.Scheme != "ftps") throw new NotSupportedException();
Url = url;
Name = url.File();
Class = ObjectClass.Directory;
Changed = DateTime.Now.AddDays(2);
if (parent is FtpDirectory) TransferProgress = ((FtpDirectory)parent).TransferProgress;
}
public IDirectory CreateDirectory(FileOrDirectory src)
{
try {
string path;
if (src == null) path = Path;
else path = System.IO.Path.Combine(Path, src.Name);
System.IO.Directory.CreateDirectory(path);
return new LocalDirectory(Sync, this, new Uri(path));
} catch (Exception ex) {
Sync.Failure(src, ex);
}
return null;
}
public void CreateFile(string path)
{
var dir = NormalizeDirectory(
Path.GetDirectoryName(path));
CreateDirectory(dir);
var file = new FileOrDirectory
{
isDirectory = false,
path = path.ToUpperInvariant(),
};
fileSystem[dir].Add(file);
}
public LocalDirectory(Sync sync, FileOrDirectory parent, Uri url)
{
Sync = sync;
Parent = parent;
if (!url.ToString().Contains(':')) {
if (url.ToString() == ".") url = new Uri(Environment.CurrentDirectory);
else url = new Uri(System.IO.Path.Combine(Environment.CurrentDirectory, url.ToString()));
}
if (!url.IsFile) throw new NotSupportedException("url is no local file.");
Url = url;
var info = new DirectoryInfo(Path);
Name = info.Name;
Class = ObjectClass.Directory;
ChangedUtc = info.LastWriteTimeUtc;
}
public async override Task <List <string> > AllChildrenToString(string space)
{
_theExtension = this.IsFilterByExpension.TheExtension.Substring(this.IsFilterByExpension.TheExtension.IndexOf('.'), this.IsFilterByExpension.TheExtension.Length - this.IsFilterByExpension.TheExtension.IndexOf('.'));
space += "";
return(await Task.Run(async() =>
{
List <string> toReturn = new List <string>();
string tmpStr = string.Empty;
foreach (Component s in _children)
{
List <string> strLst = await s.AllChildrenToString(space);
foreach (string ss in strLst)
{
if (!string.IsNullOrWhiteSpace(ss) && !string.IsNullOrEmpty(ss) && ss != Environment.NewLine && ss != "\n" && ss != "\r")
{
if (this.IsFilterByExpension.IsToFilter == false)
{
toReturn.Add(ss);
}
else
{
if (ss.Contains(_theExtension))
{
toReturn.Add(ss);
}
}
//addPathEvent?.Invoke(this, ss);
}
}
}
if (this.IsFilterByExpension.IsToFilter == false)
{
toReturn.Add(FileOrDirectory);
}
else
{
if (FileOrDirectory.Contains(_theExtension))
{
toReturn.Add(FileOrDirectory);
}
}
//addPathEvent?.Invoke(this, FileOrDirectory);
return toReturn;
}));
}
public PathDataType(ScriptParameter p, XmlNode DataTypeNode)
{
m_Parameter = p;
m_Path = p.ParameterValue;
XmlNode ChildNode = DataTypeNode.FirstChild;
if (ChildNode.Name == "file")
{
m_FileOrDirectory = FileOrDirectory.File;
FileExtenssion = GetFileExtensionFromFileNode(ChildNode);
}
else
{
m_FileOrDirectory = FileOrDirectory.Directory;
}
m_InputOrOutput = ChildNode.Attributes.GetNamedItem("type").Value == "input" ? InputOrOutput.input : InputOrOutput.output;
}
/// <summary>
/// <para>when path does not exist, it returns the closest directory to the specified path</para>
/// this function is usefull when starting a browse file / directory dialog.
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
/// <example>
/// <code lang="cs">
/// string s = GetExistingPath(@"D:\temp\test");
///
/// // returns: "E:\temp\test" when test exists
/// // returns: "E:\temp" when test does not exist.
/// // returns: "E:" when temp does not exist.
/// // returns: Environment.CurrentDirectory when path is null or empty.
/// // returns: Environment.CurrentDirectory when E: does not exist
/// // returns: DesktopDirectory when Environment.CurrentDirectory does not exist
/// </code>
/// </example>
public static string GetExistingPath(string path)
{
// Remove invalid chars
path = NormalizeFullPath(path, ' ');
if (string.IsNullOrEmpty(path))
{
// Get currentdirectory when empty
path = Environment.CurrentDirectory;
}
if (string.IsNullOrEmpty(path))
{
// when still empty get desktop directory.
path = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
}
// use FormatPath object to itterate through parts.
string[] items = SplitPath(path);
// while not exist shrink the path.
foreach (string p in items)
{
FileOrDirectory exist = IsFileOrDirectory(p);
if (exist == FileOrDirectory.Directory || exist == FileOrDirectory.File)
{
path = p;
}
}
if (string.IsNullOrEmpty(path))
{
// apperently the path was not valid in it's whole.
path = Environment.CurrentDirectory;
}
if (string.IsNullOrEmpty(path))
{
path = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
}
return(path);
}
public void DeleteDirectory(FileOrDirectory dest)
{
FtpClient ftp = null;
try {
var dir = (FtpDirectory)dest;
int con = FtpConnections.Count(IsSource, dir.url);
if (con == 0) con = 1;
var list = dir.List();
Parallel.ForEach<FtpDirectory>(list.OfType<FtpDirectory>(), new ParallelOptions { MaxDegreeOfParallelism = con }, (d) => { d.DeleteDirectory(d); });
ftp = FtpConnections.Open(IsSource, ref dir.url);
con = FtpConnections.Count(IsSource, dir.url);
if (con == 0) con = 1;
foreach (var file in list.Where(f => f.Class == ObjectClass.File)) ftp.DeleteFile(file.Name);
ftp.ChangeDirectory(ftp.CorrectPath("/" + dest.RelativePath));
ftp.ChangeDirectoryUp();
ftp.DeleteDirectory(dest.Name);
} catch (Exception ex) {
Sync.Failure(dest, ex, ftp);
} finally {
if (ftp != null) FtpConnections.Pass(ftp);
}
}
public void Delete(FileOrDirectory dest)
{
if (dest.Class == ObjectClass.File) DeleteFile(dest);
else DeleteDirectory(dest);
}
/// <summary>
/// Search Exection
/// </summary>
/// <param name="uncDirectoryPath">Start directory path</param>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption">
/// <see cref="SearchOption" />
/// </param>
/// <param name="enumerateOptions">The enumeration options for exception handling</param>
/// <param name="pathFormatReturn">Specifies the type of path to return.</param>
/// <param name="filterType">
/// <see cref="FileOrDirectory" />
/// </param>
/// <returns>Collection of path</returns>
static IEnumerable<String> FindPaths(String uncDirectoryPath, String pattern = "*", SearchOption searchOption = SearchOption.TopDirectoryOnly, FileOrDirectory? filterType = null, SuppressExceptions enumerateOptions = SuppressExceptions.None, UncOrRegular pathFormatReturn = UncOrRegular.Regular)
{
// Result Container
var results = new List<String>();
// Match for start of search
string currentPath = PathTools.Combine(uncDirectoryPath, pattern);
// Find First file
var win32FindData = new Win32FindData();
int win32Error;
using (var fileHandle = FindFirstSafeFileHandle(currentPath, win32FindData, out win32Error))
{
// Take care of invalid handles
if (fileHandle.IsInvalid && EnumerationHandleInvalidFileHandle(uncDirectoryPath, enumerateOptions, win32Error))
{
return new List<String>();
}
do
{
// Ignore . and .. directories
if (IsSystemDirectoryEntry(win32FindData))
{
continue;
}
// Create hit for current search result
string resultPath = PathTools.Combine(uncDirectoryPath, win32FindData.cFileName);
// if it's a file, add to the collection
if (!ContainsFileAttribute(win32FindData.dwFileAttributes, FileAttributes.Directory))
{
if (filterType == null || ((FileOrDirectory)filterType == FileOrDirectory.File))
{
// It's a file
results.Add(FormatPathByType(pathFormatReturn, resultPath));
}
}
else
{
// It's a directory
// Check for search searchFocus directories
if (filterType != null && ((FileOrDirectory)filterType == FileOrDirectory.Directory))
{
results.Add(FormatPathByType(pathFormatReturn, resultPath));
}
// SubFolders?!
if (searchOption == SearchOption.AllDirectories)
{
var r = new List<String>(FindPaths(resultPath, pattern, searchOption, filterType, enumerateOptions));
if (r.Count > 0)
{
results.AddRange(r);
}
}
}
// Create new FindData object for next result
win32FindData = new Win32FindData();
} // Search for next entry
while (Win32SafeNativeMethods.FindNextFile(fileHandle, win32FindData));
}
// Return result;
return results;
}
private static string[] FindPaths(FileOrDirectory FileOrDirectory, string directory, string wildCard)
{
if (FileOrDirectory == FileSystem.FileOrDirectory.Directory)
{
if (wildCard == "")
{
return Directory.GetDirectories(directory);
}
return Directory.GetDirectories(directory, wildCard);
}
if (wildCard == "")
{
return Directory.GetFiles(directory);
}
return Directory.GetFiles(directory, wildCard);
}
public Stream ReadFile(FileOrDirectory src)
{
try {
var path = System.IO.Path.Combine(Path, src.Name);
return File.OpenRead(path);
} catch (Exception ex) {
Sync.Failure(src, ex);
}
return null;
}
public IDirectory CreateDirectory(FileOrDirectory dest)
{
FtpClient ftp = null;
try {
ftp = FtpConnections.Open(IsSource, ref url);
//var path = ftp.CorrectPath(Url.Path());
//if (dest != null) path = path + "/" + dest.Name;
//var curpath = ftp.CurrentDirectory;
//var ps = path.Split('/');
//var cs = curpath.Split('/');
//var j = cs.Length-1;
//var i = Math.Min(ps.Length, j+1);
//while (j > i-1) { ftp.ChangeDirectoryUp(); j--; }
//while (j > 0 && ps[j] != cs[j]) { ftp.ChangeDirectoryUp(); j--; i = j+1; }
//while (i < ps.Length) { str.Append("/"); str.Append(ps[i++]); }
//var dir = str.ToString();
ftp.MakeDirectory(dest.Name);
//if (url.Query()["old"] != null) ftp.ChangeDirectoryMultiPath(path);
//else ftp.ChangeDirectory(path);
if (dest != null) return new FtpDirectory(Sync, this, Url.Relative(dest.Name));
else return this;
} catch (Exception ex) {
Sync.Failure(dest, ex, ftp);
} finally {
if (ftp != null) FtpConnections.Pass(ftp);
}
return null;
}
public void WriteFile(System.IO.Stream file, FileOrDirectory src)
{
FtpClient ftp = null;
try {
if (file == null) return;
ftp = FtpConnections.Open(IsSource, ref url);
var path = Url.Path() + "/" + src.Name;
var start = DateTime.Now;
if (!UseFXP) {
if (ftp.FileTransferType != TransferType.Binary) ftp.FileTransferType = TransferType.Binary;
if (TransferProgress) {
progress[ftp] = new ProgressData { ElapsedTime = new TimeSpan(0), Path = path, Size = src.Size };
ftp.TransferProgress += ShowProgress;
}
ftp.PutFile(file, src.Name, FileAction.Create);
} else { // use FXP for direct server to server transfer.
var srcftp = (FtpStream)file;
srcftp.Client.FxpCopy(src.Name, ftp);
}
ftp.SetDateTime(src.Name, src.ChangedUtc);
Log.Upload(path, src.Size, DateTime.Now - start);
} catch (Exception e) {
Sync.Failure(src, e, ftp);
} finally {
if (ftp != null) {
if (TransferProgress) {
ftp.TransferProgress -= ShowProgress;
progress.Remove(ftp);
}
FtpConnections.Pass(ftp);
}
}
}
public void DeleteFile(FileOrDirectory dest)
{
try {
var path = System.IO.Path.Combine(Path, dest.Name);
if (path != Sync.Log.LogFile) System.IO.File.Delete(path);
} catch (Exception ex) {
Sync.Failure(dest, ex);
}
}
public void DeleteDirectory(FileOrDirectory dest)
{
try {
System.IO.Directory.Delete(((LocalDirectory)dest).Path, true);
} catch (Exception ex) {
Sync.Failure(dest, ex);
}
}
private static ReadOnlyCollection<string> FindFilesOrDirectories(FileOrDirectory FileOrDirectory, string directory, Microsoft.VisualBasic.FileIO.SearchOption searchType, string[] wildcards)
{
Collection<string> results = new Collection<string>();
FindFilesOrDirectories(FileOrDirectory, directory, searchType, wildcards, results);
return new ReadOnlyCollection<string>(results);
}
private static void ShellFileOperation(Microsoft.VisualBasic.CompilerServices.NativeMethods.SHFileOperationType OperationType, Microsoft.VisualBasic.CompilerServices.NativeMethods.ShFileOperationFlags OperationFlags, string FullSource, string FullTarget, UICancelOption OnUserCancel, FileOrDirectory FileOrDirectory)
{
int num;
new UIPermission(UIPermissionWindow.SafeSubWindows).Demand();
FileIOPermissionAccess noAccess = FileIOPermissionAccess.NoAccess;
if (OperationType == Microsoft.VisualBasic.CompilerServices.NativeMethods.SHFileOperationType.FO_COPY)
{
noAccess = FileIOPermissionAccess.Read;
}
else if (OperationType == Microsoft.VisualBasic.CompilerServices.NativeMethods.SHFileOperationType.FO_MOVE)
{
noAccess = FileIOPermissionAccess.Write | FileIOPermissionAccess.Read;
}
else if (OperationType == Microsoft.VisualBasic.CompilerServices.NativeMethods.SHFileOperationType.FO_DELETE)
{
noAccess = FileIOPermissionAccess.Write;
}
string fullDirectoryPath = FullSource;
if (((OperationType == Microsoft.VisualBasic.CompilerServices.NativeMethods.SHFileOperationType.FO_COPY) || (OperationType == Microsoft.VisualBasic.CompilerServices.NativeMethods.SHFileOperationType.FO_MOVE)) && fullDirectoryPath.EndsWith("*", StringComparison.Ordinal))
{
fullDirectoryPath = RemoveEndingSeparator(FullSource.TrimEnd(new char[] { '*' }));
}
if (FileOrDirectory == FileSystem.FileOrDirectory.Directory)
{
DemandDirectoryPermission(fullDirectoryPath, noAccess);
}
else
{
new FileIOPermission(noAccess, fullDirectoryPath).Demand();
}
if (OperationType != Microsoft.VisualBasic.CompilerServices.NativeMethods.SHFileOperationType.FO_DELETE)
{
if (FileOrDirectory == FileSystem.FileOrDirectory.Directory)
{
DemandDirectoryPermission(FullTarget, FileIOPermissionAccess.Write);
}
else
{
new FileIOPermission(FileIOPermissionAccess.Write, FullTarget).Demand();
}
}
Microsoft.VisualBasic.CompilerServices.NativeMethods.SHFILEOPSTRUCT lpFileOp = GetShellOperationInfo(OperationType, OperationFlags, FullSource, FullTarget);
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert();
try
{
num = Microsoft.VisualBasic.CompilerServices.NativeMethods.SHFileOperation(ref lpFileOp);
Microsoft.VisualBasic.CompilerServices.NativeMethods.SHChangeNotify(0x2381f, 3, IntPtr.Zero, IntPtr.Zero);
}
catch (Exception)
{
throw;
}
finally
{
CodeAccessPermission.RevertAssert();
}
if (lpFileOp.fAnyOperationsAborted)
{
if (OnUserCancel == UICancelOption.ThrowException)
{
throw new OperationCanceledException();
}
}
else if (num != 0)
{
ThrowWinIOError(num);
}
}
private static void ShellDelete(string FullPath, UIOptionInternal ShowUI, RecycleOption recycle, UICancelOption OnUserCancel, FileOrDirectory FileOrDirectory)
{
Microsoft.VisualBasic.CompilerServices.NativeMethods.ShFileOperationFlags operationFlags = GetOperationFlags(ShowUI);
if (recycle == RecycleOption.SendToRecycleBin)
{
operationFlags |= Microsoft.VisualBasic.CompilerServices.NativeMethods.ShFileOperationFlags.FOF_ALLOWUNDO;
}
ShellFileOperation(Microsoft.VisualBasic.CompilerServices.NativeMethods.SHFileOperationType.FO_DELETE, operationFlags, FullPath, null, OnUserCancel, FileOrDirectory);
}
private static void ShellCopyOrMove(CopyOrMove Operation, FileOrDirectory TargetType, string FullSourcePath, string FullTargetPath, UIOptionInternal ShowUI, UICancelOption OnUserCancel)
{
Microsoft.VisualBasic.CompilerServices.NativeMethods.SHFileOperationType type;
if (Operation == CopyOrMove.Copy)
{
type = Microsoft.VisualBasic.CompilerServices.NativeMethods.SHFileOperationType.FO_COPY;
}
else
{
type = Microsoft.VisualBasic.CompilerServices.NativeMethods.SHFileOperationType.FO_MOVE;
}
Microsoft.VisualBasic.CompilerServices.NativeMethods.ShFileOperationFlags operationFlags = GetOperationFlags(ShowUI);
string fullSource = FullSourcePath;
if (TargetType == FileOrDirectory.Directory)
{
if (Directory.Exists(FullTargetPath))
{
fullSource = Path.Combine(FullSourcePath, "*");
}
else
{
Directory.CreateDirectory(GetParentPath(FullTargetPath));
}
}
ShellFileOperation(type, operationFlags, fullSource, FullTargetPath, OnUserCancel, TargetType);
if ((((Operation == CopyOrMove.Move) & (TargetType == FileOrDirectory.Directory)) && Directory.Exists(FullSourcePath)) && ((Directory.GetDirectories(FullSourcePath).Length == 0) && (Directory.GetFiles(FullSourcePath).Length == 0)))
{
Directory.Delete(FullSourcePath, false);
}
}
public void DeleteFile(FileOrDirectory dest)
{
FtpClient ftp = null;
try {
ftp = FtpConnections.Open(IsSource, ref url);
ftp.DeleteFile(dest.Name);
} catch (Exception ex) {
Sync.Failure(dest, ex, ftp);
} finally {
if (ftp != null) FtpConnections.Pass(ftp);
}
}
public System.IO.Stream ReadFile(FileOrDirectory src)
{
FtpClient ftp = null;
Task task = null;
try {
ftp = FtpConnections.Open(IsSource, ref url);
if (ftp.FileTransferType != TransferType.Binary) ftp.FileTransferType = TransferType.Binary;
var file = new FtpStream();
file.Client = ftp;
file.Path = Url.Path() + "/" + src.Name;
file.Size = src.Size;
file.File = src;
file.Log = Log;
if (!UseFXP) {
task = Services.Tasks.Do(() => {
using (file) {
try {
if (TransferProgress) {
progress[file.Client] = new ProgressData { ElapsedTime = new TimeSpan(0), Path = file.Path, Size = file.Size };
file.Client.TransferProgress += ShowProgress;
}
file.Start = DateTime.Now;
ftp.GetFile(file.File.Name, file, false);
} catch (Exception ex) {
file.Exception(ex);
Sync.Failure(file.File, ex, file.Client);
} finally {
if (TransferProgress) {
file.Client.TransferProgress -= ShowProgress;
progress.Remove(file.Client);
}
}
}
});
}
return file;
} catch (Exception e) {
Sync.Failure(src, e, ftp);
} finally {
if (task == null && ftp != null) FtpConnections.Pass(ftp);
}
return null;
}
public static void ShellFileOperation(SHFileOperationType OperationType, ShFileOperationFlags OperationFlags, string FullSource, string FullTarget, UICancelOption OnUserCancel, FileOrDirectory FileOrDirectory)
{
int num;
new UIPermission(UIPermissionWindow.SafeSubWindows).Demand();
FileIOPermissionAccess noAccess = FileIOPermissionAccess.NoAccess;
if (OperationType == SHFileOperationType.FO_COPY)
{
noAccess = FileIOPermissionAccess.Read;
}
else if (OperationType == SHFileOperationType.FO_MOVE)
{
noAccess = FileIOPermissionAccess.Write | FileIOPermissionAccess.Read;
}
else if (OperationType == SHFileOperationType.FO_DELETE)
{
noAccess = FileIOPermissionAccess.Write;
}
string fullDirectoryPath = FullSource;
if (((OperationType == SHFileOperationType.FO_COPY) || (OperationType == SHFileOperationType.FO_MOVE)) && fullDirectoryPath.EndsWith("*", StringComparison.Ordinal))
{
fullDirectoryPath = RemoveEndingSeparator(FullSource.TrimEnd(new char[] { '*' }));
}
if (FileOrDirectory == FileOrDirectory.Directory)
{
DemandDirectoryPermission(fullDirectoryPath, noAccess);
}
else
{
new FileIOPermission(noAccess, fullDirectoryPath).Demand();
}
if (OperationType != SHFileOperationType.FO_DELETE)
{
if (FileOrDirectory == FileOrDirectory.Directory)
{
DemandDirectoryPermission(FullTarget, FileIOPermissionAccess.Write);
}
else
{
new FileIOPermission(FileIOPermissionAccess.Write, FullTarget).Demand();
}
}
SHFILEOPSTRUCT lpFileOp = GetShellOperationInfo(OperationType, OperationFlags, FullSource, FullTarget);
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert();
try
{
num = SHFileOperation(ref lpFileOp);
SHChangeNotify(145439, 3, IntPtr.Zero, IntPtr.Zero);
}
catch (Exception)
{
throw;
}
finally
{
CodeAccessPermission.RevertAssert();
}
if (lpFileOp.fAnyOperationsAborted)
{
if (OnUserCancel == UICancelOption.ThrowException)
{
throw new OperationCanceledException();
}
}
else if (num != 0)
{
ThrowWinIOError(num);
}
}
public void Delete(FileOrDirectory dest)
{
try {
var path = System.IO.Path.Combine(Path, dest.Name);
if (dest.Class == ObjectClass.File) {
if (path != Sync.Log.LogFile) System.IO.File.Delete(path);
} else System.IO.Directory.Delete(path, true);
} catch (Exception ex) {
Sync.Failure(dest, ex);
}
}
public void Failure(FileOrDirectory file, Exception ex, FtpClient ftp)
{
lock (Failures) Failures.Enqueue(new FailureInfo { File=file, Exception = ex }); Log.Exception(ftp, ex);
}
public void WriteFile(Stream sstream, FileOrDirectory src)
{
if (sstream == null) return;
try {
var path = System.IO.Path.Combine(Path, src.Name);
using (var dstream = File.Create(path)) {
if (sstream is Silversite.Services.PipeStream) {
((Silversite.Services.PipeStream)sstream).CopyTo(dstream);
} else {
Streams.Copy(sstream, dstream);
}
}
File.SetLastAccessTimeUtc(path, src.ChangedUtc);
} catch (Exception ex) {
Sync.Failure(src, ex);
}
}
IDirectory Root(FileOrDirectory fd)
{
if (fd.Parent == null) return (IDirectory)fd; else return Root(fd.Parent);
}
public static void ShellDelete(string FullPath, RecycleOption recycle, UICancelOption OnUserCancel, FileOrDirectory FileOrDirectory)
{
ShFileOperationFlags operationFlags = ShFileOperationFlags.FOF_SILENT | ShFileOperationFlags.FOF_NOCONFIRMATION;
if (recycle == RecycleOption.SendToRecycleBin)
{
operationFlags |= ShFileOperationFlags.FOF_ALLOWUNDO;
}
ShellFileOperation(SHFileOperationType.FO_DELETE, operationFlags, FullPath, null, OnUserCancel, FileOrDirectory);
}
private static void FindFilesOrDirectories(FileOrDirectory FileOrDirectory, string directory, Microsoft.VisualBasic.FileIO.SearchOption searchType, string[] wildcards, Collection<string> Results)
{
VerifySearchOption("searchType", searchType);
directory = NormalizePath(directory);
if (wildcards != null)
{
foreach (string str in wildcards)
{
if (str.TrimEnd(new char[0]) == "")
{
throw ExceptionUtils.GetArgumentNullException("wildcards", "IO_GetFiles_NullPattern", new string[0]);
}
}
}
if ((wildcards == null) || (wildcards.Length == 0))
{
AddToStringCollection(Results, FindPaths(FileOrDirectory, directory, null));
}
else
{
foreach (string str2 in wildcards)
{
AddToStringCollection(Results, FindPaths(FileOrDirectory, directory, str2));
}
}
if (searchType == Microsoft.VisualBasic.FileIO.SearchOption.SearchAllSubDirectories)
{
foreach (string str3 in Directory.GetDirectories(directory))
{
FindFilesOrDirectories(FileOrDirectory, str3, searchType, wildcards, Results);
}
}
}
