public override IAsyncOperation <BaseStorageFolder> CreateFolderAsync(string desiredName, CreationCollisionOption options)
{
return(AsyncInfo.Run <BaseStorageFolder>(async(cancellationToken) =>
{
using var ftpClient = new FtpClient();
ftpClient.Host = FtpHelpers.GetFtpHost(Path);
ftpClient.Port = FtpHelpers.GetFtpPort(Path);
ftpClient.Credentials = FtpManager.Credentials.Get(ftpClient.Host, FtpManager.Anonymous);
if (!await ftpClient.EnsureConnectedAsync())
{
throw new IOException($"Failed to connect to FTP server.");
}
if (ftpClient.DirectoryExists($"{FtpPath}/{desiredName}"))
{
return new FtpStorageFolder(new StorageFileWithPath(null, $"{Path}/{desiredName}"));
}
if (!await ftpClient.CreateDirectoryAsync($"{FtpPath}/{desiredName}",
options == CreationCollisionOption.ReplaceExisting,
cancellationToken))
{
throw new IOException($"Failed to create folder {desiredName}.");
}
return new FtpStorageFolder(new StorageFileWithPath(null, $"{Path}/{desiredName}"));
}));
}
protected void OnExport(object sender, EventArgs e)
{
try
{
string fileName = TBFileName.Text;
fileName = Path.ChangeExtension(fileName, "csv");
byte[] fileBytes = null;
PalletStacking.Export(
DimCase, WeightCase,
DimPallet, WeightPallet,
MaxPalletHeight, BoxPositions,
ChkbMirrorLength.Checked, ChkbMirrorWidth.Checked,
ChkbInterlayerBottom.Checked, ChkbInterlayersIntermediate.Checked, ChkbInterlayerTop.Checked,
ref fileBytes);
if (FtpHelpers.Upload(fileBytes, ConfigSettings.FtpDirectory, fileName, ConfigSettings.FtpUsername, ConfigSettings.FtpPassword))
{
ScriptManager.RegisterStartupScript(this, GetType(), "alertMessage", $"alert('{fileName} was successfully exported!');", true);
}
}
catch (Exception ex)
{
ScriptManager.RegisterStartupScript(this, GetType(), "alertMessage", $"alert('{ex.Message}');", true);
}
}
public override IAsyncOperation <IReadOnlyList <IStorageItem> > GetItemsAsync()
{
return(AsyncInfo.Run(async(cancellationToken) =>
{
using var ftpClient = new FtpClient();
ftpClient.Host = FtpHelpers.GetFtpHost(Path);
ftpClient.Port = FtpHelpers.GetFtpPort(Path);
ftpClient.Credentials = FtpManager.Credentials.Get(ftpClient.Host, FtpManager.Anonymous);
if (!await ftpClient.EnsureConnectedAsync())
{
return null;
}
var items = new List <IStorageItem>();
var list = await ftpClient.GetListingAsync(FtpPath);
foreach (var item in list)
{
if (item.Type == FtpFileSystemObjectType.File)
{
items.Add(new FtpStorageFile(Path, item));
}
else if (item.Type == FtpFileSystemObjectType.Directory)
{
items.Add(new FtpStorageFolder(Path, item));
}
}
;
return (IReadOnlyList <IStorageItem>)items;
}));
}
public FtpStorageFile(string path, string name, DateTimeOffset dateCreated)
{
Path = path;
Name = name;
FtpPath = FtpHelpers.GetFtpPath(path);
DateCreated = dateCreated;
}
public override IAsyncOperation <BaseStorageFile> CreateFileAsync(string desiredName, CreationCollisionOption options)
{
return(AsyncInfo.Run <BaseStorageFile>(async(cancellationToken) =>
{
using var ftpClient = new FtpClient();
ftpClient.Host = FtpHelpers.GetFtpHost(Path);
ftpClient.Port = FtpHelpers.GetFtpPort(Path);
ftpClient.Credentials = FtpManager.Credentials.Get(ftpClient.Host, FtpManager.Anonymous);
if (!await ftpClient.EnsureConnectedAsync())
{
return null;
}
using var stream = new MemoryStream();
var result = await ftpClient.UploadAsync(stream, $"{FtpPath}/{desiredName}", options == CreationCollisionOption.ReplaceExisting ? FtpRemoteExists.Overwrite : FtpRemoteExists.Skip);
if (result == FtpStatus.Success)
{
return new FtpStorageFile(new StorageFileWithPath(null, $"{Path}/{desiredName}"));
}
if (result == FtpStatus.Skipped)
{
if (options == CreationCollisionOption.FailIfExists)
{
throw new IOException("File already exists.");
}
return null;
}
throw new IOException($"Failed to create file {FtpPath}/{desiredName}.");
}));
}
public FtpStorageFolder(FtpItem ftpItem)
{
DateCreated = ftpItem.ItemDateCreatedReal;
Name = ftpItem.ItemName;
Path = ftpItem.ItemPath;
FtpPath = FtpHelpers.GetFtpPath(ftpItem.ItemPath);
}
private async void FtpDataStreamingHandler(StreamedFileDataRequest request)
{
try
{
using var ftpClient = new FtpClient();
ftpClient.Host = FtpHelpers.GetFtpHost(Path);
ftpClient.Port = FtpHelpers.GetFtpPort(Path);
ftpClient.Credentials = FtpManager.Credentials.Get(ftpClient.Host, FtpManager.Anonymous);
if (!await ftpClient.EnsureConnectedAsync())
{
request.FailAndClose(StreamedFileFailureMode.CurrentlyUnavailable);
return;
}
using (var outStream = request.AsStreamForWrite())
{
await ftpClient.DownloadAsync(outStream, FtpPath);
await outStream.FlushAsync();
}
request.Dispose();
}
catch
{
request.FailAndClose(StreamedFileFailureMode.Incomplete);
}
}
public override IAsyncOperation <BaseStorageFile> CopyAsync(IStorageFolder destinationFolder, string desiredNewName, NameCollisionOption option)
{
return(AsyncInfo.Run(async(cancellationToken) =>
{
using var ftpClient = new FtpClient();
ftpClient.Host = FtpHelpers.GetFtpHost(Path);
ftpClient.Port = FtpHelpers.GetFtpPort(Path);
ftpClient.Credentials = FtpManager.Credentials.Get(ftpClient.Host, FtpManager.Anonymous);
if (!await ftpClient.EnsureConnectedAsync())
{
return null;
}
BaseStorageFolder destFolder = destinationFolder.AsBaseStorageFolder();
BaseStorageFile file = await destFolder.CreateFileAsync(desiredNewName, option.Convert());
var stream = await file.OpenStreamForWriteAsync();
if (await ftpClient.DownloadAsync(stream, FtpPath, token: cancellationToken))
{
return file;
}
return null;
}));
}
public override IAsyncAction RenameAsync(string desiredName, NameCollisionOption option)
{
return(AsyncInfo.Run(async(cancellationToken) =>
{
using var ftpClient = new FtpClient();
ftpClient.Host = FtpHelpers.GetFtpHost(Path);
ftpClient.Port = FtpHelpers.GetFtpPort(Path);
ftpClient.Credentials = FtpManager.Credentials.Get(ftpClient.Host, FtpManager.Anonymous);
if (!await ftpClient.EnsureConnectedAsync())
{
return;
}
if (!await ftpClient.MoveDirectoryAsync(FtpPath,
$"{PathNormalization.GetParentDir(FtpPath)}/{desiredName}",
option == NameCollisionOption.ReplaceExisting ? FtpRemoteExists.Overwrite : FtpRemoteExists.Skip,
cancellationToken))
{
if (option == NameCollisionOption.GenerateUniqueName)
{
// TODO: handle name generation
}
}
}));
}
public override IAsyncOperation <IRandomAccessStream> OpenAsync(FileAccessMode accessMode)
{
return(AsyncInfo.Run <IRandomAccessStream>(async(cancellationToken) =>
{
var ftpClient = new FtpClient();
ftpClient.Host = FtpHelpers.GetFtpHost(Path);
ftpClient.Port = FtpHelpers.GetFtpPort(Path);
ftpClient.Credentials = FtpManager.Credentials.Get(ftpClient.Host, FtpManager.Anonymous);
if (!await ftpClient.EnsureConnectedAsync())
{
return null;
}
if (accessMode == FileAccessMode.Read)
{
var inStream = await ftpClient.OpenReadAsync(FtpPath, cancellationToken);
return new NonSeekableRandomAccessStreamForRead(inStream, (ulong)inStream.Length)
{
DisposeCallback = () => ftpClient.Dispose()
};
}
else
{
return new NonSeekableRandomAccessStreamForWrite(await ftpClient.OpenWriteAsync(FtpPath, cancellationToken))
{
DisposeCallback = () => ftpClient.Dispose()
};
}
}));
}
public FtpStorageFolder(string folder, FtpListItem ftpItem)
{
DateCreated = ftpItem.RawCreated < DateTime.FromFileTimeUtc(0) ? DateTimeOffset.MinValue : ftpItem.RawCreated;
Name = ftpItem.Name;
Path = PathNormalization.Combine(folder, ftpItem.Name);
FtpPath = FtpHelpers.GetFtpPath(Path);
}
public override IAsyncOperation <IStorageItem> GetItemAsync(string name)
{
return(AsyncInfo.Run <IStorageItem>(async(cancellationToken) =>
{
using var ftpClient = new FtpClient();
ftpClient.Host = FtpHelpers.GetFtpHost(Path);
ftpClient.Port = FtpHelpers.GetFtpPort(Path);
ftpClient.Credentials = FtpManager.Credentials.Get(ftpClient.Host, FtpManager.Anonymous);
if (!await ftpClient.EnsureConnectedAsync())
{
return null;
}
var item = await ftpClient.GetObjectInfoAsync(FtpHelpers.GetFtpPath(PathNormalization.Combine(Path, name)));
if (item != null)
{
if (item.Type == FtpFileSystemObjectType.File)
{
return new FtpStorageFile(Path, item);
}
else if (item.Type == FtpFileSystemObjectType.Directory)
{
return new FtpStorageFolder(Path, item);
}
}
return null;
}));
}
private FtpClient GetFtpClient()
{
string host = FtpHelpers.GetFtpHost(Path);
ushort port = FtpHelpers.GetFtpPort(Path);
var credentials = FtpManager.Credentials.Get(host, FtpManager.Anonymous);
return(new(host, port, credentials));
}
public static IAsyncOperation <BaseStorageFolder> FromPathAsync(string path)
{
if (FtpHelpers.IsFtpPath(path) && FtpHelpers.VerifyFtpPath(path))
{
return(Task.FromResult <BaseStorageFolder>(new FtpStorageFolder(new StorageFolderWithPath(null, path))).AsAsyncOperation());
}
return(Task.FromResult <BaseStorageFolder>(null).AsAsyncOperation());
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
DropDownListFiles.DataSource = FtpHelpers.GetListOfFiles(ConfigSettings.FtpDirectory, ConfigSettings.FtpUsername, ConfigSettings.FtpPassword);
DropDownListFiles.DataBind();
DimCase = new Vector3D(300.0, 280.0, 275.0);
WeightCase = 1.0;
DimPallet = new Vector3D(1200.0, 1000.0, 155.0);
WeightPallet = 23.0;
MaxPalletHeight = 1700.0;
BoxPositions = new List <BoxPosition>();
}
}
public override IAsyncAction DeleteAsync()
{
return(AsyncInfo.Run(async(cancellationToken) =>
{
using var ftpClient = new FtpClient();
ftpClient.Host = FtpHelpers.GetFtpHost(Path);
ftpClient.Port = FtpHelpers.GetFtpPort(Path);
ftpClient.Credentials = FtpManager.Credentials.Get(ftpClient.Host, FtpManager.Anonymous);
if (!await ftpClient.EnsureConnectedAsync())
{
return;
}
await ftpClient.DeleteDirectoryAsync(FtpPath, cancellationToken);
}));
}
protected void OnOpenProject(object sender, EventArgs e)
{
// get selected file name
Vector3D dimCase = Vector3D.Zero;
double weightCase = 0.0;
Vector3D dimPallet = Vector3D.Zero;
double weightPallet = 0.0;
double maxPalletHeight = 0.0;
bool MirrorX = false, MirrorY = false;;
bool interlayerBottom = false, interlayerTop = false, interlayerMiddle = false;
List <BoxPosition> boxPositions = new List <BoxPosition>();
string filePath = DropDownListFiles.SelectedValue;
byte[] fileContent = null;
FtpHelpers.Download(ref fileContent, ConfigSettings.FtpDirectory, filePath, ConfigSettings.FtpUsername, ConfigSettings.FtpPassword);
ExporterCSV_TechBSA.Import(new MemoryStream(fileContent),
ref boxPositions,
ref dimCase, ref weightCase,
ref dimPallet, ref weightPallet,
ref maxPalletHeight,
ref MirrorX, ref MirrorY,
ref interlayerBottom, ref interlayerTop, ref interlayerMiddle);
DimCase = dimCase; WeightCase = weightCase;
DimPallet = dimPallet; WeightPallet = weightPallet;
MaxPalletHeight = maxPalletHeight;
BoxPositions = boxPositions;
LayersMirrorX = MirrorX;
LayersMirrorY = MirrorY;
InterlayerBottom = interlayerBottom;
InterlayerTop = interlayerTop;
InterlayersIntermadiate = interlayerMiddle;
FileName = filePath;
if (ConfigSettings.WebGLMode)
{
Response.Redirect("ValidationWebGL.axpx");
}
else
{
Response.Redirect("Validation.aspx");
}
}
public override IAsyncOperation <IInputStream> OpenSequentialReadAsync()
{
return(AsyncInfo.Run <IInputStream>(async(cancellationToken) =>
{
var ftpClient = new FtpClient();
ftpClient.Host = FtpHelpers.GetFtpHost(Path);
ftpClient.Port = FtpHelpers.GetFtpPort(Path);
ftpClient.Credentials = FtpManager.Credentials.Get(ftpClient.Host, FtpManager.Anonymous);
if (!await ftpClient.EnsureConnectedAsync())
{
return null;
}
var inStream = await ftpClient.OpenReadAsync(FtpPath, cancellationToken);
return new InputStreamWithDisposeCallback(inStream)
{
DisposeCallback = () => ftpClient.Dispose()
};
}));
}
public override IAsyncOperation <BaseBasicProperties> GetBasicPropertiesAsync()
{
return(AsyncInfo.Run <BaseBasicProperties>(async(cancellationToken) =>
{
using var ftpClient = new FtpClient();
ftpClient.Host = FtpHelpers.GetFtpHost(Path);
ftpClient.Port = FtpHelpers.GetFtpPort(Path);
ftpClient.Credentials = FtpManager.Credentials.Get(ftpClient.Host, FtpManager.Anonymous);
if (!await ftpClient.EnsureConnectedAsync())
{
return new BaseBasicProperties();
}
var item = await ftpClient.GetObjectInfoAsync(FtpPath);
if (item != null)
{
return new FtpFolderBasicProperties(item);
}
return new BaseBasicProperties();
}));
}
public override IAsyncOperation <IRandomAccessStreamWithContentType> OpenReadAsync()
{
return(AsyncInfo.Run <IRandomAccessStreamWithContentType>(async(cancellationToken) =>
{
var ftpClient = new FtpClient();
ftpClient.Host = FtpHelpers.GetFtpHost(Path);
ftpClient.Port = FtpHelpers.GetFtpPort(Path);
ftpClient.Credentials = FtpManager.Credentials.Get(ftpClient.Host, FtpManager.Anonymous);
if (!await ftpClient.EnsureConnectedAsync())
{
return null;
}
var inStream = await ftpClient.OpenReadAsync(FtpPath, cancellationToken);
var nsStream = new NonSeekableRandomAccessStreamForRead(inStream, (ulong)inStream.Length)
{
DisposeCallback = () => ftpClient.Dispose()
};
return new StreamWithContentType(nsStream);
}));
}
public virtual void CopyPathOfSelectedItem(RoutedEventArgs e)
{
try
{
if (SlimContentPage != null)
{
var path = SlimContentPage.SelectedItem != null ? SlimContentPage.SelectedItem.ItemPath : associatedInstance.FilesystemViewModel.WorkingDirectory;
if (FtpHelpers.IsFtpPath(path))
{
path = path.Replace("\\", "/", StringComparison.Ordinal);
}
DataPackage data = new DataPackage();
data.SetText(path);
Clipboard.SetContent(data);
Clipboard.Flush();
}
}
catch (Exception)
{
Debugger.Break();
}
}
public static IAsyncOperation <BaseStorageFile> FromPathAsync(string path)
=> FtpHelpers.IsFtpPath(path) && FtpHelpers.VerifyFtpPath(path)
? Task.FromResult <BaseStorageFile>(new FtpStorageFile(new StorageFileWithPath(null, path))).AsAsyncOperation()
: Task.FromResult <BaseStorageFile>(null).AsAsyncOperation();
public FtpStorageFolder(IStorageItemWithPath item)
{
Name = System.IO.Path.GetFileName(item.Path);
Path = item.Path;
FtpPath = FtpHelpers.GetFtpPath(item.Path);
}
public async Task <IStorageHistory> RestoreFromTrashAsync(IStorageItemWithPath source, string destination, IProgress <float> progress, IProgress <FileSystemStatusCode> errorCode, CancellationToken cancellationToken)
{
var connection = await AppServiceConnectionHelper.Instance;
if (connection == null || string.IsNullOrWhiteSpace(source.Path) || source.Path.StartsWith(@"\\?\", StringComparison.Ordinal) || string.IsNullOrWhiteSpace(destination) || destination.StartsWith(@"\\?\", StringComparison.Ordinal) || FtpHelpers.IsFtpPath(destination))
{
// Fallback to builtin file operations
return(await filesystemOperations.RestoreFromTrashAsync(source, destination, progress, errorCode, cancellationToken));
}
var operationID = Guid.NewGuid().ToString();
using var r = cancellationToken.Register(CancelOperation, operationID, false);
EventHandler <Dictionary <string, object> > handler = (s, e) => OnProgressUpdated(s, e, operationID, progress);
connection.RequestReceived += handler;
var moveResult = new ShellOperationResult();
var(status, response) = await connection.SendMessageForResponseAsync(new ValueSet()
{
{ "Arguments", "FileOperation" },
{ "fileop", "MoveItem" },
{ "operationID", operationID },
{ "filepath", source.Path },
{ "destpath", destination },
{ "overwrite", false },
{ "HWND", NativeWinApiHelper.CoreWindowHandle.ToInt64() }
});
var result = (FilesystemResult)(status == AppServiceResponseStatus.Success &&
response.Get("Success", false));
var shellOpResult = JsonConvert.DeserializeObject <ShellOperationResult>(response.Get("Result", ""));
moveResult.Items.AddRange(shellOpResult?.Items ?? Enumerable.Empty <ShellOperationItemResult>());
if (connection != null)
{
connection.RequestReceived -= handler;
}
result &= (FilesystemResult)moveResult.Items.All(x => x.Succeeded);
if (result)
{
progress?.Report(100.0f);
errorCode?.Report(FileSystemStatusCode.Success);
var movedSources = moveResult.Items.Where(x => new[] { source }.Select(s => s.Path).Contains(x.Source)).Where(x => x.Succeeded && x.Destination != null && x.Source != x.Destination);
if (movedSources.Any())
{
// Recycle bin also stores a file starting with $I for each item
await DeleteItemsAsync(movedSources.Select(src => StorageHelpers.FromPathAndType(
Path.Combine(Path.GetDirectoryName(src.Source), Path.GetFileName(src.Source).Replace("$R", "$I", StringComparison.Ordinal)),
new[] { source }.Single(s => s.Path == src.Source).ItemType)), null, null, true, cancellationToken);
return(new StorageHistory(FileOperationType.Restore, source,
StorageHelpers.FromPathAndType(movedSources.Single().Destination, source.ItemType)));
}
return(null); // Cannot undo overwrite operation
}
else
{
// Retry failed operations
return(await filesystemOperations.RestoreFromTrashAsync(source, destination, progress, errorCode, cancellationToken));
}
}
public async Task <IStorageHistory> CopyItemsAsync(IEnumerable <IStorageItemWithPath> source, IEnumerable <string> destination, IEnumerable <FileNameConflictResolveOptionType> collisions, IProgress <float> progress, IProgress <FileSystemStatusCode> errorCode, CancellationToken cancellationToken)
{
var connection = await AppServiceConnectionHelper.Instance;
if (connection == null || source.Any(x => string.IsNullOrWhiteSpace(x.Path) || x.Path.StartsWith(@"\\?\", StringComparison.Ordinal)) || destination.Any(x => string.IsNullOrWhiteSpace(x) || x.StartsWith(@"\\?\", StringComparison.Ordinal) || FtpHelpers.IsFtpPath(x)))
{
// Fallback to builtin file operations
return(await filesystemOperations.CopyItemsAsync(source, destination, collisions, progress, errorCode, cancellationToken));
}
source = source.Where((src, index) => collisions.ElementAt(index) != FileNameConflictResolveOptionType.Skip).ToList();
destination = destination.Where((src, index) => collisions.ElementAt(index) != FileNameConflictResolveOptionType.Skip).ToList();
collisions = collisions.Where(c => c != FileNameConflictResolveOptionType.Skip).ToList();
var operationID = Guid.NewGuid().ToString();
using var r = cancellationToken.Register(CancelOperation, operationID, false);
EventHandler <Dictionary <string, object> > handler = (s, e) => OnProgressUpdated(s, e, operationID, progress);
connection.RequestReceived += handler;
var sourceReplace = source.Where((src, index) => collisions.ElementAt(index) == FileNameConflictResolveOptionType.ReplaceExisting);
var destinationReplace = destination.Where((src, index) => collisions.ElementAt(index) == FileNameConflictResolveOptionType.ReplaceExisting);
var sourceRename = source.Where((src, index) => collisions.ElementAt(index) != FileNameConflictResolveOptionType.ReplaceExisting);
var destinationRename = destination.Where((src, index) => collisions.ElementAt(index) != FileNameConflictResolveOptionType.ReplaceExisting);
var result = (FilesystemResult)true;
var copyResult = new ShellOperationResult();
if (sourceRename.Any())
{
var(status, response) = await connection.SendMessageForResponseAsync(new ValueSet()
{
{ "Arguments", "FileOperation" },
{ "fileop", "CopyItem" },
{ "operationID", operationID },
{ "filepath", string.Join('|', sourceRename.Select(s => s.Path)) },
{ "destpath", string.Join('|', destinationRename) },
{ "overwrite", false },
{ "HWND", NativeWinApiHelper.CoreWindowHandle.ToInt64() }
});
result &= (FilesystemResult)(status == AppServiceResponseStatus.Success &&
response.Get("Success", false));
var shellOpResult = JsonConvert.DeserializeObject <ShellOperationResult>(response.Get("Result", ""));
copyResult.Items.AddRange(shellOpResult?.Items ?? Enumerable.Empty <ShellOperationItemResult>());
}
if (sourceReplace.Any())
{
var(status, response) = await connection.SendMessageForResponseAsync(new ValueSet()
{
{ "Arguments", "FileOperation" },
{ "fileop", "CopyItem" },
{ "operationID", operationID },
{ "filepath", string.Join('|', sourceReplace.Select(s => s.Path)) },
{ "destpath", string.Join('|', destinationReplace) },
{ "overwrite", true },
{ "HWND", NativeWinApiHelper.CoreWindowHandle.ToInt64() }
});
result &= (FilesystemResult)(status == AppServiceResponseStatus.Success &&
response.Get("Success", false));
var shellOpResult = JsonConvert.DeserializeObject <ShellOperationResult>(response.Get("Result", ""));
copyResult.Items.AddRange(shellOpResult?.Items ?? Enumerable.Empty <ShellOperationItemResult>());
}
if (connection != null)
{
connection.RequestReceived -= handler;
}
result &= (FilesystemResult)copyResult.Items.All(x => x.Succeeded);
if (result)
{
progress?.Report(100.0f);
errorCode?.Report(FileSystemStatusCode.Success);
var copiedSources = copyResult.Items.Where(x => sourceRename.Select(s => s.Path).Contains(x.Source)).Where(x => x.Succeeded && x.Destination != null && x.Source != x.Destination);
if (copiedSources.Any())
{
return(new StorageHistory(FileOperationType.Copy, copiedSources.Select(x => sourceRename.Single(s => s.Path == x.Source)),
copiedSources.Select(item => StorageHelpers.FromPathAndType(item.Destination, sourceRename.Single(s => s.Path == item.Source).ItemType))));
}
return(null); // Cannot undo overwrite operation
}
else
{
// Retry failed operations
var failedSources = copyResult.Items.Where(x => source.Select(s => s.Path).Contains(x.Source)).Where(x => !x.Succeeded);
var copyZip = source.Zip(destination, (src, dest) => new { src, dest }).Zip(collisions, (z1, coll) => new { z1.src, z1.dest, coll });
return(await filesystemOperations.CopyItemsAsync(
failedSources.Select(x => copyZip.Single(s => s.src.Path == x.Source).src),
failedSources.Select(x => copyZip.Single(s => s.src.Path == x.Source).dest),
failedSources.Select(x => copyZip.Single(s => s.src.Path == x.Source).coll), progress, errorCode, cancellationToken));
}
}
public async Task <IStorageHistory> RenameAsync(IStorageItemWithPath source, string newName, NameCollisionOption collision, IProgress <FileSystemStatusCode> errorCode, CancellationToken cancellationToken)
{
var connection = await AppServiceConnectionHelper.Instance;
if (connection == null || string.IsNullOrWhiteSpace(source.Path) || source.Path.StartsWith(@"\\?\", StringComparison.Ordinal) || FtpHelpers.IsFtpPath(source.Path))
{
// Fallback to builtin file operations
return(await filesystemOperations.RenameAsync(source, newName, collision, errorCode, cancellationToken));
}
var renameResult = new ShellOperationResult();
var(status, response) = await connection.SendMessageForResponseAsync(new ValueSet()
{
{ "Arguments", "FileOperation" },
{ "fileop", "RenameItem" },
{ "operationID", Guid.NewGuid().ToString() },
{ "filepath", source.Path },
{ "newName", newName },
{ "overwrite", collision == NameCollisionOption.ReplaceExisting }
});
var result = (FilesystemResult)(status == AppServiceResponseStatus.Success &&
response.Get("Success", false));
var shellOpResult = JsonConvert.DeserializeObject <ShellOperationResult>(response.Get("Result", ""));
renameResult.Items.AddRange(shellOpResult?.Items ?? Enumerable.Empty <ShellOperationItemResult>());
result &= (FilesystemResult)renameResult.Items.All(x => x.Succeeded);
if (result)
{
errorCode?.Report(FileSystemStatusCode.Success);
var renamedSources = renameResult.Items.Where(x => new[] { source }.Select(s => s.Path).Contains(x.Source)).Where(x => x.Succeeded && x.Destination != null && x.Source != x.Destination);
if (renamedSources.Any())
{
return(new StorageHistory(FileOperationType.Rename, source,
StorageHelpers.FromPathAndType(renamedSources.Single().Destination, source.ItemType)));
}
return(null); // Cannot undo overwrite operation
}
else
{
// Retry failed operations
return(await filesystemOperations.RenameAsync(source, newName, collision, errorCode, cancellationToken));
}
}
public FtpStorageFile(IStorageItemWithPath item)
{
Path = item.Path;
Name = IO.Path.GetFileName(item.Path);
FtpPath = FtpHelpers.GetFtpPath(item.Path);
}
public async Task <IStorageHistory> DeleteItemsAsync(IEnumerable <IStorageItemWithPath> source, IProgress <float> progress, IProgress <FileSystemStatusCode> errorCode, bool permanently, CancellationToken cancellationToken)
{
var connection = await AppServiceConnectionHelper.Instance;
if (connection == null || source.Any(x => string.IsNullOrWhiteSpace(x.Path) || x.Path.StartsWith(@"\\?\", StringComparison.Ordinal) || FtpHelpers.IsFtpPath(x.Path)))
{
// Fallback to builtin file operations
return(await filesystemOperations.DeleteItemsAsync(source, progress, errorCode, permanently, cancellationToken));
}
source = source.DistinctBy(x => x.Path); // #5771
var deleleFilePaths = source.Select(s => s.Path);
var deleteFromRecycleBin = source.Any() ? recycleBinHelpers.IsPathUnderRecycleBin(source.ElementAt(0).Path) : false;
permanently |= deleteFromRecycleBin;
if (deleteFromRecycleBin)
{
// Recycle bin also stores a file starting with $I for each item
deleleFilePaths = deleleFilePaths.Concat(source.Select(x => Path.Combine(Path.GetDirectoryName(x.Path), Path.GetFileName(x.Path).Replace("$R", "$I", StringComparison.Ordinal)))).Distinct();
}
var operationID = Guid.NewGuid().ToString();
using var r = cancellationToken.Register(CancelOperation, operationID, false);
EventHandler <Dictionary <string, object> > handler = (s, e) => OnProgressUpdated(s, e, operationID, progress);
connection.RequestReceived += handler;
var deleteResult = new ShellOperationResult();
var(status, response) = await connection.SendMessageForResponseAsync(new ValueSet()
{
{ "Arguments", "FileOperation" },
{ "fileop", "DeleteItem" },
{ "operationID", operationID },
{ "filepath", string.Join('|', deleleFilePaths) },
{ "permanently", permanently },
{ "HWND", NativeWinApiHelper.CoreWindowHandle.ToInt64() }
});
var result = (FilesystemResult)(status == AppServiceResponseStatus.Success &&
response.Get("Success", false));
var shellOpResult = JsonConvert.DeserializeObject <ShellOperationResult>(response.Get("Result", ""));
deleteResult.Items.AddRange(shellOpResult?.Items ?? Enumerable.Empty <ShellOperationItemResult>());
if (connection != null)
{
connection.RequestReceived -= handler;
}
result &= (FilesystemResult)deleteResult.Items.All(x => x.Succeeded);
if (result)
{
progress?.Report(100.0f);
errorCode?.Report(FileSystemStatusCode.Success);
foreach (var item in deleteResult.Items)
{
await associatedInstance.FilesystemViewModel.RemoveFileOrFolderAsync(item.Source);
}
var recycledSources = deleteResult.Items.Where(x => source.Select(s => s.Path).Contains(x.Source)).Where(x => x.Succeeded && x.Destination != null && x.Source != x.Destination);
if (recycledSources.Any())
{
return(new StorageHistory(FileOperationType.Recycle, recycledSources.Select(x => source.Single(s => s.Path == x.Source)),
recycledSources.Select(item => StorageHelpers.FromPathAndType(item.Destination, source.Single(s => s.Path == item.Source).ItemType))));
}
return(new StorageHistory(FileOperationType.Delete, source, null));
}
else
{
// Retry failed operations
var failedSources = deleteResult.Items.Where(x => source.Select(s => s.Path).Contains(x.Source))
.Where(x => !x.Succeeded && x.HResult != HResult.COPYENGINE_E_USER_CANCELLED && x.HResult != HResult.COPYENGINE_E_RECYCLE_BIN_NOT_FOUND);
return(await filesystemOperations.DeleteItemsAsync(
failedSources.Select(x => source.Single(s => s.Path == x.Source)), progress, errorCode, permanently, cancellationToken));
}
}
