public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
{
IEntryModel entryModel = pm.GetValue <IEntryModel>(EntryKey);
if (entryModel == null)
{
return(ResultCommand.Error(new ArgumentException(EntryKey + " is not found or not IEntryModel")));
}
IDiskProfile profile = entryModel.Profile as IDiskProfile;
if (profile == null)
{
return(ResultCommand.Error(new NotSupportedException(EntryKey + "'s Profile is not IDiskProfile")));
}
using (var stream = await profile.DiskIO.OpenStreamAsync(entryModel, Access, pm.CancellationToken))
{
ParameterDic pmClone = pm.Clone();
pmClone.SetValue(StreamKey, stream);
logger.Debug(String.Format("{0} = Stream of {1}", StreamKey, EntryKey));
await ScriptRunner.RunScriptAsync(pmClone, NextCommand);
}
if (Access == FileAccess.ReadWrite || Access == FileAccess.Write)
{
return(CoreScriptCommands.NotifyEntryChangedProfile(ChangeType.Changed, null, EntryKey, ThenCommand));
}
else
{
return(ThenCommand);
}
}
public static IScriptCommand DiskDeleteMultiple(string entriesKey, bool notifyChange, IScriptCommand nextCommand = null)
{
if (notifyChange)
{
nextCommand = CoreScriptCommands.NotifyEntryChanged(Defines.ChangeType.Deleted, null, entriesKey, nextCommand);
}
return(ScriptCommands.ForEach(entriesKey, "{CurrentDeleteItem}",
CoreScriptCommands.DiskDelete("{CurrentDeleteItem}"), nextCommand));
}
public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
{
IEntryModel[] entryModels = DirectoryEntryKey == null ? new IEntryModel[] { } :
(await pm.GetValueAsEntryModelArrayAsync(DirectoryEntryKey));
object evnt = new RootChangedEvent(ChangeType, entryModels);;
return(CoreScriptCommands.BroadcastEvent(EventsKey, evnt, NextCommand));
}
/// <summary>
/// Download a web stream to a file.
/// </summary>
/// <param name="urlVariable">Url to access</param>
/// <param name="destinationFileVariable">Destination file name.</param>
/// <param name="nextCommand"></param>
/// <returns></returns>
public static IScriptCommand DownloadFile(string urlVariable = "{Url}",
string destinationProfileVariable = "{Profile}", string destinationFileVariable = "{DestinationFile}",
IScriptCommand nextCommand = null)
{
return(CoreScriptCommands.Download(urlVariable, "{DownloadStream}",
CoreScriptCommands.DiskParseOrCreateFile(destinationProfileVariable, destinationFileVariable, "{Destination}",
CoreScriptCommands.DiskOpenStream("{Destination}", "{DestinationStream}", FileExplorer.Defines.FileAccess.Write,
CoreScriptCommands.CopyStream("{DownloadStream}", "{DestinationStream}",
ScriptCommands.Reset(nextCommand, "{DownloadStream}", "{Destination}"))))));
}
/// <summary>
/// Not serializable, Copy contents from srcFile to destFile.
/// </summary>
/// <param name="srcFile"></param>
/// <param name="destFile"></param>
/// <param name="nextCommand"></param>
/// <returns></returns>
public static IScriptCommand DiskCopyFile(IEntryModel srcFile, IEntryModel destFile, IScriptCommand nextCommand = null)
{
return(ScriptCommands.Assign("{DiskCopyFile-Source}", srcFile, false,
ScriptCommands.Assign("{DiskCopyFile-Dest}", destFile, false,
CoreScriptCommands.DiskOpenStream(dcSourceVariable, "{SourceStream}", FileExplorer.Defines.FileAccess.Read,
CoreScriptCommands.DiskOpenStream(dcDestVariable, "{DestinationStream}", FileExplorer.Defines.FileAccess.Write,
CoreScriptCommands.CopyStream("{CopyStream-Source}", "{CopyStream-Dest}",
CoreScriptCommands.NotifyEntryChanged(ChangeType.Created, null, dcSourceVariable, null, dcDestVariable,
ScriptCommands.Reset(nextCommand, dcSourceVariable, dcDestVariable))))))));
}
public static IScriptCommand DiskTransferChild(string srcDirectoryVariable = "{Source}",
string destDirectoryVariable = "{DestinationDirectory}",
string mask = "*", ListOptions listOptions = ListOptions.File | ListOptions.Folder,
bool removeOriginal = false, bool allowCustomImplementation = true, IScriptCommand nextCommand = null)
{
return(CoreScriptCommands.List(srcDirectoryVariable, "{DTC-ItemToTransfer}", mask, listOptions,
ScriptCommands.ForEach("{DTC-ItemToTransfer}", "{DTC-CurrentItem}",
IOScriptCommands.DiskTransfer("{DTC-CurrentItem}", destDirectoryVariable, null, removeOriginal, allowCustomImplementation),
ScriptCommands.Reset(nextCommand, "{DTC-DestDirectory}", "{DTC-SrcDirectory}"))));
}
public static IScriptCommand DiskParseOrCreateArchive(string profileVariable = "{Profile}", string pathVariable = "{Path}", string destVariable = "{Entry}",
IScriptCommand nextCommand = null)
{
return
(CoreScriptCommands.ParsePath(profileVariable, pathVariable, destVariable,
nextCommand, //FoundCommand
//NotFoundCommand
CoreScriptCommands.DiskCreatePath(profileVariable, pathVariable, false, destVariable, NameGenerationMode.NoRename,
IOScriptCommands.AssignArchiveBytes(pathVariable, "{ArchiveBytes}",
CoreScriptCommands.DiskOpenStream(destVariable, "{DestStream}", FileAccess.Write,
CoreScriptCommands.CopyStream("{ArchiveBytes}", "{DestStream}"),
CoreScriptCommands.ParsePath(profileVariable, pathVariable, destVariable, nextCommand))))));
}
/// <summary>
/// Serializable, Copy contents from file1 to file2
/// </summary>
/// <param name="sourceFileVariable">Filepath of source</param>
/// <param name="destinationFileVariable">Filepath of destination</param>
/// <param name="nextCommand"></param>
/// <returns></returns>
public static IScriptCommand DiskCopyFile(string sourceProfileVariable = "{SourceProfile}", string sourceFileVariable = "{SourceFile}",
string destinationProfileVariable = "{DestinationProfile}", string destinationFileVariable = "{DestinationFile}",
IScriptCommand nextCommand = null)
{
return(CoreScriptCommands.ParsePath(sourceProfileVariable, sourceFileVariable, dcSourceVariable,
CoreScriptCommands.DiskParseOrCreateFile(destinationProfileVariable, destinationFileVariable, dcDestVariable,
CoreScriptCommands.DiskOpenStream(dcSourceVariable, "{SourceStream}", FileExplorer.Defines.FileAccess.Read,
CoreScriptCommands.DiskOpenStream(dcDestVariable, "{DestinationStream}", FileExplorer.Defines.FileAccess.Write,
CoreScriptCommands.CopyStream("{SourceStream}", "{DestinationStream}",
CoreScriptCommands.NotifyEntryChanged(ChangeType.Created, null, dcSourceVariable, null, dcDestVariable,
ScriptCommands.Reset(nextCommand, dcSourceVariable, dcDestVariable)))))),
ResultCommand.Error(new FileNotFoundException(sourceFileVariable))));
}
public static IScriptCommand DiskDelete(string entryKey, bool notifyChange,
IScriptCommand nextCommand = null)
{
if (notifyChange)
{
nextCommand = CoreScriptCommands.NotifyEntryChangedProfile(ChangeType.Deleted, null, entryKey, nextCommand);
}
return(new DiskDelete()
{
EntryKey = entryKey,
NextCommand = (ScriptCommandBase)nextCommand
});
}
public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
{
string path = pm.ReplaceVariableInsideBracketed(PathKey);
if (path == null)
{
return(ResultCommand.Error(new ArgumentException("Path not specified.")));
}
IDiskProfile profile = pm.GetValue <IDiskProfile>(ProfileKey);
if (profile == null)
{
return(ResultCommand.Error(new ArgumentException(ProfileKey + " is not assigned or not IDiskProfile.")));
}
string parentPath = profile.Path.GetDirectoryName(path);
IFileNameGenerator fNameGenerator = FileNameGenerator.FromNameGenerationMode(NameGenerationMode,
profile.Path.GetFileName(path));
string fileName = fNameGenerator.Generate();
while (fileName != null &&
await profile.ParseAsync(profile.Path.Combine(parentPath, fileName)) != null)
{
fileName = fNameGenerator.Generate();
}
if (fileName == null)
{
return(ResultCommand.Error(new ArgumentException("Already exists.")));
}
string newEntryPath = profile.Path.Combine(parentPath, fileName);
var createddModel = await profile.DiskIO.CreateAsync(newEntryPath, IsFolder, pm.CancellationToken);
logger.Info(String.Format("{0} = {1} ({2})", DestinationKey, createddModel.FullPath, IsFolder ? "Folder" : "File"));
pm.SetValue(DestinationKey, createddModel);
return(CoreScriptCommands.NotifyEntryChanged(ChangeType.Created, null, DestinationKey, NextCommand));
}
public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
{
Dictionary <string, Stream> compressDic = new Dictionary <string, Stream>();
try
{
IEntryModel[] srcEntries = await pm.GetValueAsEntryModelArrayAsync(SourceEntryKey);
ISzsItemModel destEntry = await pm.GetValueAsEntryModelAsync(DestinationDirectoryEntryKey, null) as ISzsItemModel;
//If destination is not SzsRoot, use DiskTransfer instead.
SzsProfile destProfile = destEntry.Profile as SzsProfile;
if (destProfile == null)
{
logger.Warn(String.Format("{0} isn't Szs based entry, DiskTransfer is used instead.", destEntry.Name));
return(IOScriptCommands.DiskTransfer(SourceEntryKey, DestinationDirectoryEntryKey, null, RemoveOriginal, false, NextCommand));
}
if (!destEntry.IsDirectory)
{
return(ResultCommand.Error(new ArgumentException(DestinationDirectoryEntryKey + " is not a folder.")));
}
Func <IEntryModel, bool> fileAndArchiveOnly = em => !em.IsDirectory || (em is SzsRootModel);
Func <IEntryModel, bool> lookupDirectoryNotArchiveFilter = em => em.IsDirectory && !(em is SzsRootModel);
IProgress <TransferProgress> progress = pm.GetProgress();
string archiveType = destProfile.Path.GetExtension((destEntry as ISzsItemModel).Root.Name);
logger.Info(String.Format("Compressing {0} -> {1} using SzsDiskTransfer",
srcEntries.GetDescription(), destEntry.Name));
await Task.Run(async() =>
{
#region OpenStream of files
foreach (var srcEntry in srcEntries)
{
IDiskProfile srcProfile = srcEntry.Profile as IDiskProfile;
if (srcProfile == null)
{
break;
}
if (fileAndArchiveOnly(srcEntry))
{
logger.Debug(String.Format("Added to Dictionary : {0} -> {1}", srcEntry.FullPath, srcEntry.Name));
progress.Report(TransferProgress.SetMessage(ProgressType.Running, srcEntry.Name));
compressDic.Add(srcEntry.Name, await srcProfile.DiskIO
.OpenStreamAsync(srcEntry, Defines.FileAccess.Read, pm.CancellationToken));
}
else
{
IList <IEntryModel> srcSubEntries = await srcProfile.ListRecursiveAsync(srcEntry, pm.CancellationToken,
fileAndArchiveOnly, lookupDirectoryNotArchiveFilter, false);
foreach (var srcSubEntry in srcSubEntries)
{
string relativePath =
destProfile.Path.Combine(
destEntry.RelativePath,
srcSubEntry.FullPath.Replace(srcEntry.Parent.FullPath, "").TrimStart('\\')
);
logger.Debug(String.Format("Added to Dictionary : {0} -> {1}", srcSubEntry.FullPath, relativePath));
progress.Report(TransferProgress.SetMessage(ProgressType.Running, relativePath));
compressDic.Add(relativePath, await srcProfile.DiskIO
.OpenStreamAsync(srcSubEntry, Defines.FileAccess.Read, pm.CancellationToken));
}
}
}
#endregion
Progress <Defines.ProgressEventArgs> progress1 = new Progress <Defines.ProgressEventArgs>(
(pea) =>
{
if (!String.IsNullOrEmpty(pea.Message))
{
progress.Report(TransferProgress.SetMessage(Defines.ProgressType.Running, pea.Message));
}
if (!String.IsNullOrEmpty(pea.File))
{
progress.Report(TransferProgress.From(pea.File));
}
if (pea.CurrentProgress != -1 && pea.TotalProgress != -1)
{
progress.Report(TransferProgress.UpdateCurrentProgress((short)((float)pea.CurrentProgress / (float)pea.TotalProgress * 100.0)));
}
}
);
progress.Report(TransferProgress.To(destEntry.Name));
using (await destProfile.WorkingLock.LockAsync())
using (var stream = await destProfile.DiskIO.OpenStreamAsync(destEntry, Defines.FileAccess.ReadWrite, pm.CancellationToken))
destProfile.Wrapper.CompressMultiple(archiveType, stream, compressDic, progress1);
logger.Info(String.Format("{0} items transfered", compressDic.Count()));
return(CoreScriptCommands.NotifyEntryChanged(ChangeType.Changed, destEntry, NextCommand));
});
return(NextCommand);
}
finally
{
#region Dispose Streams
if (compressDic != null)
{
foreach (var stream in compressDic.Values)
{
stream.Dispose();
}
}
#endregion
}
}
/// <summary>
/// Serializable, parse a path and go to specified directory.
/// </summary>
/// <param name="explorerVariable"></param>
/// <param name="profileVariable"></param>
/// <param name="pathOrPathVariable"></param>
/// <param name="nextCommand"></param>
/// <returns></returns>
public static IScriptCommand ExplorerParseAndGoTo(string explorerVariable = "{Explorer}",
string profileVariable = "{Profile}", string pathOrPathVariable = "", IScriptCommand nextCommand = null)
{
return(CoreScriptCommands.ParsePath(profileVariable, pathOrPathVariable, "{GoTo-Directory}",
ExplorerGoTo(explorerVariable, "{Goto-Directory}", nextCommand)));
}
/// <summary>
/// Serializable, For DiskProfile only, parse a path, if not exists create it, store to destVariable (default Entry), then call next command.
/// </summary>
/// <param name="pathVariable">Actual path or reference variable (if Bracketed), e.g. C:\Temp or {Path}.</param>
/// <param name="isFolder"></param>
/// <param name="destVariable"></param>
/// <param name="nameGenerationMode"></param>
/// <param name="nextCommand"></param>
/// <returns></returns>
public static IScriptCommand DiskParseOrCreatePath(string profileVariable = "{Profile}", string pathVariable = "{Path}", bool isFolder = false, string destVariable = "{Entry}",
IScriptCommand nextCommand = null)
{
return(ParsePath(profileVariable, pathVariable, destVariable, nextCommand, CoreScriptCommands.DiskCreatePath(profileVariable, pathVariable, isFolder, destVariable,
NameGenerationMode.NoRename, nextCommand)));
}
private async Task <IScriptCommand> transferScriptCommandAsync(ParameterDic pm, IEntryModel[] srcEntries, IEntryModel destEntry, string destinationKey)
{
var progress = pm.GetProgress() ?? NullTransferProgress.Instance;
var srcProfile = srcEntries.First().Profile as IDiskProfile;
var destProfile = destEntry.Profile as IDiskProfile;
var srcMapper = srcProfile.DiskIO.Mapper;
var destMapping = destProfile.DiskIO.Mapper[destEntry];
List <IScriptCommand> notifyChangeCommands = new List <IScriptCommand>();
List <string> changedPath = new List <string>();
progress.Report(TransferProgress.IncrementTotalEntries(srcEntries.Count()));
foreach (var srcEntry in srcEntries)
{
var srcMapping = srcMapper[srcEntry];
string destName = PathFE.GetFileName(srcMapping.IOPath);
string destFullName = destProfile.Path.Combine(destEntry.FullPath, destName);
progress.Report(TransferProgress.From(srcEntry.FullPath, destEntry.FullPath));
if (srcEntry.IsDirectory)
{
await ScriptRunner.RunScriptAsync(pm,
ScriptCommands.Assign("{DT-SrcDirectory}", srcEntry, false,
ScriptCommands.Assign("{DT-DestProfile}", destEntry.Profile, false,
CoreScriptCommands.DiskParseOrCreateFolder("{DT-DestProfile}", destFullName, "{DT-DestDirectory}",
IOScriptCommands.DiskTransferChild("{DT-SrcDirectory}", "{DT-DestDirectory}", RemoveOriginal, AllowCustomImplementation,
ScriptCommands.Reset(ResultCommand.NoError, "{DT-DestDirectory}", "{DT-SrcDirectory}"))))));
}
else
{
await ScriptRunner.RunScriptAsync(pm,
ScriptCommands.Assign("{DT-SrcFile}", srcEntry, false,
ScriptCommands.Assign("{DT-SrcProfile}", srcEntry.Profile, false,
ScriptCommands.Assign("{DT-DestProfile}", destEntry.Profile, false,
CoreScriptCommands.DiskParseOrCreateFile("{DT-DestProfile}", destFullName, "{DT-DestFile}",
CoreScriptCommands.DiskCopyFile("{DT-SrcProfile}", "{DT-SrcFile}", "{DT-DestProfile}", "{DT-DestFile}",
ScriptCommands.Reset(ResultCommand.NoError, "{DT-SrcFile}", "{DT-DestFile}")))))));
}
progress.Report(TransferProgress.IncrementProcessedEntries());
}
logger.Info(String.Format("{0} {1} -> {2} using ScriptCommand",
RemoveOriginal ? "Move" : "Copy", srcEntries.GetDescription(), destEntry.Name));
return(await GetAssignDestinationCommandAsync(pm, srcEntries, destEntry, destinationKey, NextCommand));
}
private async Task <IScriptCommand> transferSystemIOAsync(ParameterDic pm, IEntryModel[] srcEntries, IEntryModel destEntry, string destinationKey)
{
return(await Task.Run <IScriptCommand>(async() =>
{
var progress = pm.ContainsKey("Progress") ? pm["Progress"] as IProgress <TransferProgress> : NullTransferProgress.Instance;
var srcProfile = srcEntries.First().Profile as IDiskProfile;
var destProfile = destEntry.Profile as IDiskProfile;
var srcMapper = srcProfile.DiskIO.Mapper;
var destMapping = destProfile.DiskIO.Mapper[destEntry];
List <string> createdPath = new List <string>();
List <string> changedPath = new List <string>();
progress.Report(TransferProgress.IncrementTotalEntries(srcEntries.Count()));
foreach (var srcEntry in srcEntries)
{
var srcMapping = srcMapper[srcEntry];
string destName = PathFE.GetFileName(srcMapping.IOPath);
string destFullName = destProfile.Path.Combine(destEntry.FullPath, destName);
progress.Report(TransferProgress.From(srcEntry.FullPath, destEntry.FullPath));
if (srcEntry.IsDirectory)
{
if (Directory.Exists(destFullName))
{
changedPath.Add(destFullName);
//Directory.Delete(destFullName, true);
}
else
{
createdPath.Add(destFullName);
}
Directory.Move(srcMapping.IOPath, destFullName); //Move directly.
progress.Report(TransferProgress.IncrementProcessedEntries());
}
else
{
if (File.Exists(destFullName))
{
changedPath.Add(destFullName);
File.Delete(destFullName);
}
else
{
createdPath.Add(destFullName);
}
File.Move(srcMapping.IOPath, destFullName);
}
progress.Report(TransferProgress.IncrementProcessedEntries());
}
logger.Info(String.Format("{0} {1} -> {2} using System.IO",
RemoveOriginal ? "Move" : "Copy", srcEntries.GetDescription(), destEntry.Name));
return
await GetAssignDestinationCommandAsync(pm, srcEntries, destEntry, destinationKey,
ScriptCommands.RunParallel(NextCommand,
CoreScriptCommands.NotifyEntryChangedPath(ChangeType.Created, destEntry.Profile, createdPath.ToArray()),
CoreScriptCommands.NotifyEntryChangedPath(ChangeType.Changed, destEntry.Profile, changedPath.ToArray())
));
}));
}
