Ejemplo n.º 1
0
        public override IScriptCommand Execute(ParameterDic pm)
        {
            IProfile[] rootProfiles = pm.GetValue <IProfile[]>(ProfilesKey);
            if (rootProfiles == null || rootProfiles.Length == 0)
            {
                return(ResultCommand.Error(new ArgumentException(ProfilesKey)));
            }

            if (rootProfiles.Length == 1)
            {
                pm.SetValue(DestinationKey, rootProfiles[0]);
                return(NextCommand);
            }
            else
            {
                IWindowManager wm = pm.GetValue <IWindowManager>(WindowManagerKey) ?? new WindowManager();
                logger.Debug("Showing");
                SelectProfileViewModel spvm = new SelectProfileViewModel(rootProfiles);
                if (wm.ShowDialog(spvm).Value)
                {
                    logger.Info(String.Format("Selected {0}", spvm.SelectedRootProfile));
                    pm.SetValue(DestinationKey, spvm.SelectedRootProfile);
                    return(NextCommand);
                }
                else
                {
                    logger.Debug("Cancelled");
                    return(CancelCommand);
                }
            }
        }
Ejemplo n.º 2
0
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            var evm = pm.GetValue <IExplorerViewModel>(ExplorerKey);
            var dm  = DirectoryEntryKey == null ? null :
                      (await pm.GetValueAsEntryModelArrayAsync(DirectoryEntryKey)).FirstOrDefault();

            if (evm == null)
            {
                var events = pm.GetValue <IEventAggregator>(EventsKey);
                if (events != null)
                {
                    events.PublishOnUIThread(new DirectoryChangedEvent(this, dm, null));
                }
                else
                {
                    return(ResultCommand.Error(new ArgumentNullException(ExplorerKey)));
                }
            }
            else
            {
                await evm.GoAsync(dm);
            }

            logger.Info("Path = " + dm.FullPath);
            return(NextCommand);
        }
Ejemplo n.º 3
0
        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);
            }
        }
Ejemplo n.º 4
0
        public override IScriptCommand Execute(ParameterDic pm)
        {
            switch (Mode)
            {
            case RunMode.Parallel:
            case RunMode.Queue:
                ScriptRunner.RunScript(pm, ScriptCommands);
                break;

            case RunMode.Sequence:
                foreach (var cmd in ScriptCommands)
                {
                    ScriptRunner.RunScript(pm, cmd);
                    if (pm.Error != null)
                    {
                        return(ResultCommand.Error(pm.Error));
                    }
                }
                break;

            default:
                return(ResultCommand.Error(new NotSupportedException(Mode.ToString())));
            }

            if (pm.Error != null)
            {
                return(ResultCommand.Error(pm.Error));
            }
            else
            {
                return(NextCommand);
            }
        }
Ejemplo n.º 5
0
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            try
            {
                var srcProfile  = _srcModel.Profile as IDiskProfile;
                var destProfile = _destDirModel.Profile as IDiskProfile;
                var progress    = pm.ContainsKey("Progress") ? pm["Progress"] as IProgress <TransferProgress> : NullTransferProgress.Instance;

                var    destMapping  = (_destDirModel.Profile as IDiskProfile).DiskIO.Mapper[_destDirModel];
                var    srcMapping   = (_srcModel.Profile as IDiskProfile).DiskIO.Mapper[_srcModel];
                string destName     = PathFE.GetFileName(srcMapping.IOPath);
                string destFullName = destProfile.Path.Combine(_destDirModel.FullPath, destName); //PathFE.Combine(destMapping.IOPath, destName);


                if (_srcModel.IsDirectory)
                {
                    Func <IEntryModel, bool> filter       = em => !em.IsDirectory || (em is SzsRootModel);
                    Func <IEntryModel, bool> lookupFilter = em => em.IsDirectory && !(em is SzsRootModel);
                    return(WPFScriptCommands.List(_srcModel, filter, lookupFilter, true, ems =>
                                                  new SimpleScriptCommandAsync("BatchTransfer", pd => transferAsync(pm, ems, progress,
                                                                                                                    new NotifyChangedCommand(_destDirModel.Profile, destFullName,
                                                                                                                                             _srcModel.Profile, _srcModel.FullPath, Defines.ChangeType.Changed)))));
                }
                else
                {
                    return(IOScriptCommands.DiskTransfer(_srcModel, _destDirModel, _removeOriginal));
                }

                return(ResultCommand.NoError);
            }
            catch (Exception ex)
            {
                return(ResultCommand.Error(ex));
            }
        }
Ejemplo n.º 6
0
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            DestinationKey = DestinationKey ?? "{Explorer}";
            var tevm = pm.GetValue <ITabbedExplorerViewModel>(TabbedExplorerKey);

            if (tevm == null)
            {
                return(ResultCommand.Error(new ArgumentNullException(TabbedExplorerKey)));
            }

            var dm = DirectoryEntryKey == null ? null :
                     (await pm.GetValueAsEntryModelArrayAsync(DirectoryEntryKey)).FirstOrDefault();

            if (dm != null && !dm.IsDirectory)
            {
                dm = null;
            }

            var destTab = tevm.OpenTab(dm);

            logger.Info(String.Format("New Tab #{0}", tevm.GetTabIndex(destTab)));
            logger.Debug(String.Format("{0} = {1}", DestinationKey, destTab));
            pm.SetValue(DestinationKey, destTab);
            return(NextCommand);
        }
        public override IScriptCommand Execute(ParameterDic pm)
        {
            IExplorerViewModel evm = pm.GetValue <IExplorerViewModel>(ExplorerKey);

            if (evm == null)
            {
                return(ResultCommand.Error(new KeyNotFoundException(ExplorerKey)));
            }

            ParameterDic startupParameters = new ParameterDic();

            foreach (var key in VariableKeys.Split(','))
            {
                var val = pm.GetValue(key);
                startupParameters.SetValue(key, val);
            }

            addStartupParameters(evm.Commands, startupParameters);
            addStartupParameters(evm.FileList.Commands, startupParameters);
            addStartupParameters(evm.DirectoryTree.Commands, startupParameters);
            addStartupParameters(evm.Navigation.Commands, startupParameters);
            addStartupParameters(evm.Breadcrumb.Commands, startupParameters);

            return(NextCommand);
        }
Ejemplo n.º 8
0
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            var flValue             = pm.GetValue(FileListKey);
            IFileListViewModel flvm = flValue is IExplorerViewModel ?
                                      (flValue as IExplorerViewModel).FileList :
                                      flValue as IFileListViewModel;

            if (flvm == null)
            {
                return(ResultCommand.Error(new KeyNotFoundException(FileListKey)));
            }

            IEntryModel[] value = new IEntryModel[] { };
            switch (AssignType)
            {
            case FileListAssignType.All:
                value = flvm.ProcessedEntries.EntriesHelper.AllNonBindable
                        .Select(evm => evm.EntryModel).ToArray();
                break;

            case FileListAssignType.Selected:
                value = flvm.Selection.SelectedItems.Select(evm => evm.EntryModel).ToArray();
                break;

            default:
                return(ResultCommand.Error(new NotSupportedException("AssignType")));
            }

            return(ScriptCommands.Assign(DestinationKey, value, false, NextCommand));
        }
Ejemplo n.º 9
0
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            IEntryModel entry = pm.GetValue <IEntryModel>(EntryKey);

            if (entry == null)
            {
                return(ResultCommand.Error(new KeyNotFoundException(EntryKey)));
            }
            IDiskProfile profile = entry.Profile as IDiskProfile;

            if (profile == null)
            {
                return(ResultCommand.Error(new ArgumentException(EntryKey + "'s Profile is not IDiskProfile")));
            }

            var entryMapping = profile.DiskIO.Mapper[entry];

            if (entryMapping.IsVirtual)
            {
                await profile.DiskIO.WriteToCacheAsync(entry, pm.CancellationToken, true);
            }

            if (ExecutableKey == null) //Default implementation
            {
                if (entry.IsDirectory)
                {
                    try { Process.Start(entryMapping.IOPath); }
                    catch (Exception ex) { return(ResultCommand.Error(ex)); }
                }
                else
                {
                    if (File.Exists(entryMapping.IOPath))
                    {
                        ProcessStartInfo psi = null;
                        if (ExecutableKey == "OpenAs")
                        {
                            psi           = new ProcessStartInfo("Rundll32.exe");
                            psi.Arguments = String.Format(" shell32.dll, OpenAs_RunDLL {0}", entryMapping.IOPath);
                        }
                        else
                        {
                            psi = new ProcessStartInfo(entryMapping.IOPath);
                        }

                        if (psi != null)
                        {
                            try { Process.Start(psi); }
                            catch (Exception ex) { return(ResultCommand.Error(ex)); }
                        }
                    }
                }
            }
            else
            {
            }

            return(NextCommand);
        }
Ejemplo n.º 10
0
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            IEntryModel[] srcEntries = null;
            IEntryModel   destEntry  = null;

            try
            {
                srcEntries = await pm.GetValueAsEntryModelArrayAsync(SourceEntryKey);

                destEntry = await pm.GetValueAsEntryModelAsync(DestinationDirectoryEntryKey, null);
            }
            catch (ArgumentException ex)
            {
                return(ResultCommand.Error(ex));
            }

            if (!destEntry.IsDirectory)
            {
                return(ResultCommand.Error(new ArgumentException(DestinationDirectoryEntryKey + " is not a folder.")));
            }
            if (srcEntries.Length == 0)
            {
                return(ResultCommand.Error(new ArgumentException("Nothing to transfer.")));
            }

            var srcProfile  = srcEntries.First().Profile as IDiskProfile;
            var destProfile = destEntry.Profile as IDiskProfile;

            if (srcEntries == null || destProfile == null)
            {
                return(ResultCommand.Error(new ArgumentException("Either source or dest is not IDiskProfile.")));
            }

            var progress = pm.GetProgress() ?? NullTransferProgress.Instance;


            if (AllowCustomImplementation)
            {
                logger.Info(String.Format("{0} {1} -> {2} using CustomImplementation",
                                          RemoveOriginal ? "Move" : "Copy", srcEntries.GetDescription(), destEntry.Name));
                return(destProfile.DiskIO
                       .GetTransferCommand(SourceEntryKey, DestinationDirectoryEntryKey, DestinationKey, RemoveOriginal, NextCommand));
            }
            else
            {
                var srcMapper   = srcProfile.DiskIO.Mapper;
                var destMapping = destProfile.DiskIO.Mapper[destEntry];

                if (!destMapping.IsVirtual && RemoveOriginal && srcEntries.All(entry => !srcMapper[entry].IsVirtual))
                {
                    return(await transferSystemIOAsync(pm, srcEntries, destEntry, DestinationKey));
                }
                else
                {
                    return(await transferScriptCommandAsync(pm, srcEntries, destEntry, DestinationKey));
                }
            }
        }
Ejemplo n.º 11
0
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            var    pdv = pm.GetValue <IProgress <TransferProgress> >("{Progress}", NullTransferProgress.Instance);
            string url = pm.GetValue <string>(UrlKey);

            if (url == null)
            {
                return(ResultCommand.Error(new ArgumentException("Unspecified Url.")));
            }

            try
            {
                using (var httpClient =
                           pm.ContainsKey(HttpClientKey) && pm[HttpClientKey] is Func <HttpClient>?((Func <HttpClient>)pm[HttpClientKey])() :
                               new HttpClient())
                {
                    var response = await httpClient.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, pm.CancellationToken);

                    if (!response.IsSuccessStatusCode)
                    {
                        throw new WebException(String.Format("{0} when downloading {1}", response.StatusCode, url));
                    }

                    MemoryStream destStream = new MemoryStream();
                    logger.Info(String.Format("{0} = Stream of {1}", DestinationKey, url));
                    using (Stream srcStream = await response.Content.ReadAsStreamAsync())
                    {
                        pdv.Report(TransferProgress.From(url));
                        byte[] buffer         = new byte[1024];
                        ulong  totalBytesRead = 0;
                        ulong  totalBytes     = 0;
                        try { totalBytes = (ulong)srcStream.Length; }
                        catch (NotSupportedException) { }

                        int byteRead = await srcStream.ReadAsync(buffer, 0, buffer.Length, pm.CancellationToken);

                        while (byteRead > 0)
                        {
                            await destStream.WriteAsync(buffer, 0, byteRead, pm.CancellationToken);

                            totalBytesRead = totalBytesRead + (uint)byteRead;
                            short percentCompleted = (short)((float)totalBytesRead / (float)totalBytes * 100.0f);
                            pdv.Report(TransferProgress.UpdateCurrentProgress(percentCompleted));

                            byteRead = await srcStream.ReadAsync(buffer, 0, buffer.Length, pm.CancellationToken);
                        }
                        await destStream.FlushAsync();
                    }

                    pm.SetValue(DestinationKey, destStream.ToByteArray());
                    return(NextCommand);
                }
            }
            catch (Exception ex)
            {
                return(ResultCommand.Error(ex));
            }
        }
Ejemplo n.º 12
0
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            IWindowManager   wm     = pm.GetValue <IWindowManager>(WindowManagerKey) ?? new WindowManager();
            IEventAggregator events = pm.GetValue <IEventAggregator>(EventAggregatorKey) ?? new EventAggregator();

            IExplorerInitializer initializer = new ScriptCommandInitializer()
            {
                StartupParameters = pm,
                WindowManager     = wm,
                Events            = events,
                OnModelCreated    = ScriptCommands.Run(OnModelCreatedKey),
                OnViewAttached    = ScriptCommands.Run(OnViewAttachedKey)
            };

            ExplorerViewModel evm = null;

            switch (ExplorerMode)
            {
            case Script.ExplorerMode.Normal:
                evm = new ExplorerViewModel(wm, events)
                {
                    Initializer = initializer
                };
                break;

            case Script.ExplorerMode.FileOpen:
                evm = new FilePickerViewModel(wm, events)
                {
                    Initializer = initializer,
                    PickerMode  = FilePickerMode.Open
                };
                break;

            case Script.ExplorerMode.FileSave:
                evm = new FilePickerViewModel(wm, events)
                {
                    Initializer = initializer,
                    PickerMode  = FilePickerMode.Save
                };
                break;

            case Script.ExplorerMode.DirectoryOpen:
                evm = new DirectoryPickerViewModel(wm, events)
                {
                    Initializer = initializer
                };
                break;

            default:
                return(ResultCommand.Error(new NotSupportedException(ExplorerMode.ToString())));
            }

            logger.Info(String.Format("Creating {0}", evm));
            pm.SetValue(DestinationKey, evm, false);

            return(NextCommand);
        }
Ejemplo n.º 13
0
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            VM evm = (VM)pm[_viewModelName];

            if (evm == null)
            {
                return(ResultCommand.Error(new ArgumentException(_viewModelName)));
            }
            return(await _commandFunc(evm, pm));
        }
 public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
 {
     if (CanExecute(pm))
     {
         return(NextCommand);
     }
     else
     {
         return(ResultCommand.Error(pm.Error ?? new ArgumentException("pm")));
     }
 }
Ejemplo n.º 15
0
 public override IScriptCommand Execute(ParameterDic pm)
 {
     ScriptRunner.RunScript(pm, ScriptCommands);
     if (pm.Error != null)
     {
         return(ResultCommand.Error(pm.Error));
     }
     else
     {
         return(_nextCommand);
     }
 }
Ejemplo n.º 16
0
        public override IScriptCommand Execute(ParameterDic pm)
        {
            IScriptCommand command = pm.GetValue <IScriptCommand>(CommandKey);

            if (command == null && ThrowIfError)
            {
                return(ResultCommand.Error(new ArgumentNullException(CommandKey)));
            }
            command = command ?? ResultCommand.NoError;

            logger.Info("Running " + CommandKey);
            return(ScriptCommands.RunQueue(NextCommand, command));
        }
Ejemplo n.º 17
0
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            await ScriptRunner.RunScriptAsync(pm, ScriptCommands);

            if (pm.Error != null)
            {
                return(ResultCommand.Error(pm.Error));
            }
            else
            {
                return(_nextCommand);
            }
        }
Ejemplo n.º 18
0
 /// <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))));
 }
Ejemplo n.º 19
0
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            var events = pm.GetValue <IEventAggregator>(EventsKey);

            if (events == null)
            {
                return(ResultCommand.Error(new ArgumentNullException(EventsKey)));
            }

            logger.Info(String.Format("Broadcasting {0}", Event));
            events.PublishOnUIThread(Event);

            return(NextCommand);
        }
Ejemplo n.º 20
0
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            var evm = pm.GetValue <IExplorerViewModel>(ExplorerKey);

            if (evm == null)
            {
                return(ResultCommand.Error(new KeyNotFoundException(ExplorerKey)));
            }

            return
                (Direction == ParameterDirection.Set ?
                 await setParameterAsync(pm, evm) :
                 await getParameterAsync(pm, evm));
        }
Ejemplo n.º 21
0
        public static IScriptCommand ParseOrCreateArchive(IDiskProfile profile, string path, Func <IEntryModel, IScriptCommand> thenFunc)
        {
            string type = profile.Path.GetExtension(path).ToLower();

            byte[] bytes = SevenZipWrapper.GetArchiveBytes(type);

            if (bytes == null)
            {
                return(ResultCommand.Error(new ArgumentException(type + " is not recognized type.")));
            }

            return(WPFScriptCommands.ParseOrCreatePath(profile, path, false,
                                                       em => WPFScriptCommands.WriteBytes(em, bytes, thenFunc)));
        }
Ejemplo n.º 22
0
        public override IScriptCommand Execute(ParameterDic pm)
        {
            IExplorerViewModel evm = pm.GetValue <IExplorerViewModel>(ExplorerKey);

            if (evm == null)
            {
                return(ResultCommand.Error(new KeyNotFoundException(ExplorerKey)));
            }

            DoAction(evm);
            logger.Info("Completed");

            return(NextCommand);
        }
Ejemplo n.º 23
0
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            IWindowManager     wm  = pm.GetValue <IWindowManager>(WindowManagerKey) ?? new WindowManager();
            IExplorerViewModel evm = pm.GetValue <IExplorerViewModel>(ExplorerKey);

            if (evm == null)
            {
                return(ResultCommand.Error(new KeyNotFoundException(ExplorerKey)));
            }
            logger.Info(String.Format("Showing {0}", evm));

            if (evm is DirectoryPickerViewModel)
            {
                DirectoryPickerViewModel dpvm = evm as DirectoryPickerViewModel;
                bool result = wm.ShowDialog(dpvm).Value;
                pm.SetValue(DialogResultKey, result);

                if (result)
                {
                    pm.SetValue(SelectionPathsKey, dpvm.SelectedDirectory.FullPath);
                    pm.SetValue(SelectionEntriesKey, dpvm.SelectedDirectory);
                }
            }
            else if (evm is FilePickerViewModel)
            {
                FilePickerViewModel fpvm = evm as FilePickerViewModel;
                bool result = wm.ShowDialog(fpvm).Value;
                pm.SetValue(DialogResultKey, result);
                if (result)
                {
                    switch (fpvm.PickerMode)
                    {
                    case FilePickerMode.Save:
                        pm.SetValue(SelectionPathsKey, fpvm.FileName);
                        break;

                    case FilePickerMode.Open:
                        pm.SetValue(SelectionPathsKey, fpvm.SelectedFiles.Select(m => m.FullPath).ToArray());
                        pm.SetValue(SelectionEntriesKey, fpvm.SelectedFiles);
                        break;
                    }
                }
            }
            else
            {
                wm.ShowWindow(evm);
            }

            return(NextCommand);
        }
        public static IScriptCommand CreatePath(IProfile profile, string path, bool isFolder, bool renameIfExists,
                                                Func <IEntryModel, IScriptCommand> thenFunc)
        {
            if (profile is IDiskProfile)
            {
                string parentPath = profile.Path.GetDirectoryName(path);
                string name       = profile.Path.GetFileName(path);

                return(new DiskCreateCommand(profile as IDiskProfile,
                                             parentPath,
                                             renameIfExists ? FileNameGenerator.Rename(name) : FileNameGenerator.NoRename(name),
                                             isFolder, thenFunc));
            }
            return(ResultCommand.Error(new NotSupportedException("Profile is not IDiskProfile.")));
        }
Ejemplo n.º 25
0
        public static IScriptCommand CreateArchive(IEntryModel entryModel, string name, bool renameIfExists,
                                                   Func <IEntryModel, IScriptCommand> thenFunc)
        {
            string type = entryModel.Profile.Path.GetExtension(name).ToLower();

            byte[] bytes = SevenZipWrapper.GetArchiveBytes(type);

            if (bytes == null)
            {
                return(ResultCommand.Error(new ArgumentException(type + " is not recognized type.")));
            }

            return(WPFScriptCommands.CreatePath(entryModel, name, false, renameIfExists,
                                                em => WPFScriptCommands.WriteBytes(em, bytes, thenFunc)));
        }
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            var flValue             = pm.GetValue(FileListKey);
            IFileListViewModel flvm = flValue is IExplorerViewModel ?
                                      (flValue as IExplorerViewModel).FileList :
                                      flValue as IFileListViewModel;

            if (flvm == null)
            {
                return(ResultCommand.Error(new KeyNotFoundException(FileListKey)));
            }

            return(ScriptCommands.Assign(DestinationKey,
                                         flvm.Selection.SelectedItems.Select(evm => evm.EntryModel).ToArray(), false, NextCommand));
        }
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            var         flValue = pm.GetValue(ExplorerKey);
            IEntryModel em      = flValue is IExplorerViewModel ? (flValue as IExplorerViewModel).CurrentDirectory.EntryModel :
                                  flValue is IFileListViewModel ? (flValue as IFileListViewModel).CurrentDirectory :
                                  flValue is IDirectoryTreeViewModel ? (flValue as IDirectoryTreeViewModel).Selection.SelectedChild :
                                  flValue is IBreadcrumbViewModel ? (flValue as IBreadcrumbViewModel).Selection.SelectedChild : null;

            if (em == null)
            {
                return(ResultCommand.Error(new KeyNotFoundException(ExplorerKey)));
            }

            pm.SetValue(DestinationKey, em, true);
            return(NextCommand);
        }
Ejemplo n.º 28
0
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            var flValue             = pm.GetValue(FileListKey);
            IFileListViewModel flvm = flValue is IExplorerViewModel ?
                                      (flValue as IExplorerViewModel).FileList :
                                      flValue as IFileListViewModel;

            if (flvm == null)
            {
                return(ResultCommand.Error(new KeyNotFoundException(FileListKey)));
            }

            await flvm.ProcessedEntries.EntriesHelper.LoadAsync(UpdateMode.Update, Force);

            return(NextCommand);
        }
Ejemplo n.º 29
0
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            IEnumerable e = pm.GetValue <IEnumerable>(ItemsKey);

            if (e == null)
            {
                return(ResultCommand.Error(new ArgumentException(ItemsKey)));
            }

            IProgress <TransferProgress> progress = NullTransferProgress.Instance;

            if (IsProgressEnabled)
            {
                List <object> list;
                e        = list = e.Cast <object>().ToList();
                progress = pm.GetProgress();
                progress.Report(TransferProgress.IncrementTotalEntries(list.Count));
            }

            uint counter = 0;

            pm.SetValue <bool>(BreakKey, false);
            foreach (var item in e)
            {
                if (pm.GetValue <bool>(BreakKey))
                {
                    break;
                }

                counter++;
                pm.SetValue(CurrentItemKey, item);
                await ScriptRunner.RunScriptAsync(pm, NextCommand);

                progress.Report(TransferProgress.IncrementProcessedEntries());
                if (pm.Error != null)
                {
                    pm.SetValue <Object>(CurrentItemKey, null);
                    return(ResultCommand.Error(pm.Error));
                }
            }
            logger.Info("Looped {0} items", counter);
            pm.SetValue <Object>(CurrentItemKey, null);

            return(ThenCommand);
        }
Ejemplo n.º 30
0
        public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
        {
            var destProfile = _destDirModel.Profile as IDiskProfile;

            var    destMapping  = (_destDirModel.Profile as IDiskProfile).DiskIO.Mapper[_destDirModel];
            var    srcMapping   = (_srcModel.Profile as IDiskProfile).DiskIO.Mapper[_srcModel];
            string destName     = PathFE.GetFileName(srcMapping.IOPath);
            string destFullName = destProfile.Path.Combine(_destDirModel.FullPath, destName); //PathFE.Combine(destMapping.IOPath, destName);

            IEntryModel destModel = await _destDirModel.Profile.ParseAsync(destFullName);

            if (destModel == null)
            {
                destModel = await destProfile.DiskIO.CreateAsync(destFullName, true, pm.CancellationToken);

                destModel = (await _destDirModel.Profile.ListAsync(_destDirModel, CancellationToken.None, em =>
                                                                   em.FullPath.Equals(destFullName,
                                                                                      StringComparison.CurrentCultureIgnoreCase), true)).FirstOrDefault();
                _destDirModel.Profile.Events.PublishOnUIThread(new EntryChangedEvent(ChangeType.Created, destFullName));
            }

            if (destModel == null)
            {
                return(ResultCommand.Error(new Exception("Cannot construct destination " + destFullName)));
            }
            else
            {
                _progress.Report(TransferProgress.From(_srcModel.FullPath, destFullName));
                _progress.Report(TransferProgress.IncrementProcessedEntries()); //dest directory created
            }
            var srcSubModels = (await _srcModel.Profile.ListAsync(_srcModel, CancellationToken.None)).ToList();

            _progress.Report(TransferProgress.IncrementTotalEntries(srcSubModels.Count())); //source entries

            var resultCommands = srcSubModels.Select(m =>
                                                     (IScriptCommand) new FileTransferScriptCommand(m, destModel, _removeOriginal)).ToList();

            resultCommands.Add(new NotifyChangedCommand(_destDirModel.Profile, destFullName, ChangeType.Created));

            //if (_removeOriginal)
            //    resultCommands.Add(new DeleteEntryCommand(_srcModel));

            return(new RunInSequenceScriptCommand(resultCommands.ToArray()));
        }