Пример #1
0
        private void ExecuteNewFolderCommand()
        {
            var items      = SourcePane.Items.Select(item => item.Name).ToList();
            var wkDirs     = DirectoryStructure.WellKnownDirectoriesOf(SourcePane.CurrentFolder.Path);
            var suggestion = wkDirs.Where(d => !items.Contains(d)).Select(d => new InputDialogOptionViewModel
            {
                Value       = d,
                DisplayName = TitleRecognizer.GetTitle(d)
            }).ToList();

            var name = WindowManager.ShowTextInputDialog(Resx.AddNewFolder, Resx.FolderName + Strings.Colon, string.Empty, suggestion);

            if (name == null)
            {
                return;
            }
            name = name.Trim();
            if (name == string.Empty)
            {
                WindowManager.ShowMessage(Resx.AddNewFolder, Resx.CannotCreateFolderWithNoName);
                return;
            }
            //var invalidChars = Path.GetInvalidFileNameChars();
            //if (invalidChars.Any(name.Contains))
            //{
            //    WindowManager.ShowMessage(Resx.AddNewFolder, Resx.CannotCreateFolderWithInvalidCharacters);
            //    return;
            //}
            var path = string.Format("{0}{1}", SourcePane.CurrentFolder.Path, name);

            WorkHandler.Run(() => SourcePane.CreateFolder(path), result => NewFolderSuccess(result, name), NewFolderError);
        }
        public void AbortTransfer()
        {
            if (SourcePane == null)
            {
                return;
            }

            _isAborted = true;
            if (_remoteCopy == RemoteCopyMode.Disabled)
            {
                SourcePane.Abort();
                if (TargetPane != null)
                {
                    TargetPane.Abort();
                }
            }
            lock (_queue)
            {
                var actualItem = _queue.Peek();
                _queue.Clear();
                _queue.Enqueue(actualItem);
            }
            if (_isPaused)
            {
                UIThread.BeginRun(FinishTransfer);
            }
        }
 private void ExecutePauseCommand()
 {
     IsPaused = true;
     SourcePane.Abort();
     if (TargetPane != null)
     {
         TargetPane.Abort();
     }
 }
        private void FinishTransfer()
        {
            _queue = null;
            _statistics.TimeSpentWithTransfer += _elapsedTimeMeter.Elapsed;
            if (_remoteCopy != RemoteCopyMode.Disabled)
            {
                CloseTelnetSession();
            }
            _elapsedTimeMeter.Stop();
            ProgressState = TaskbarItemProgressState.None;

            var args = new TransferFinishedEventArgs(this, SourcePane, TargetPane);

            if (_shutdown != Shutdown.Disabled && (UserAction == FileOperation.Copy || UserAction == FileOperation.Move))
            {
                ShutdownDialogViewModel vm;
                if (_shutdown.HasFlag(Shutdown.Xbox))
                {
                    var ftp = Pane <FtpContentViewModel>();
                    if (ftp == SourcePane)
                    {
                        _sourceChanged = false;
                    }
                    if (ftp == TargetPane)
                    {
                        _targetChanged = false;
                    }
                    vm = new ShutdownDialogViewModel(WindowManager, _shutdown, ftp);
                }
                else
                {
                    vm = new ShutdownDialogViewModel(WindowManager, _shutdown);
                }
                WindowManager.ShowModelessWindow <ShutdownDialog, ShutdownDialogViewModel>(vm);
            }

            if (_sourceChanged)
            {
                SourcePane.Refresh(false);
            }
            if (_targetChanged && TargetPane != null)
            {
                TargetPane.Refresh(false);
            }
            EventAggregator.GetEvent <TransferFinishedEvent>().Publish(args);

            SourcePane = null;
            TargetPane = null;
        }
Пример #5
0
 private void NewFolderSuccess(TransferResult result, string name)
 {
     if (result != TransferResult.Ok)
     {
         WindowManager.ShowMessage(Resx.AddNewFolder, string.Format(Resx.FolderAlreadyExists, name));
         return;
     }
     SourcePane.Refresh(false, () =>
     {
         var newFolder = SourcePane.Items.SingleOrDefault(item => item.Name == name);
         if (newFolder != null)
         {
             SourcePane.CurrentRow = newFolder;
         }
     });
 }
Пример #6
0
        private void DoTransform()
        {
            try
            {
                if (_preferences.SaveOnTransform)
                {
                    SourcePane.SaveFile("Sources");
                    TransformPane.SaveFile("Transforms");
                    DocumentsPane.SaveFile("Documents");
                    IncludesPane.SaveFile("Includes");
                }

                var source    = SourcePane.JsonContent;
                var transform = TransformPane.JsonContent;

                if (string.IsNullOrWhiteSpace(source))
                {
                    MessageBox.Show("Load or enter in a source document", "JTranEdit", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

                if (string.IsNullOrWhiteSpace(transform))
                {
                    MessageBox.Show("Load or enter in a transform", "JTranEdit", MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

                var transformer = new Transformer(_preferences);
                var result      = transformer.Transform(source, transform);

                OutputPane.JsonContent = result;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "JTranEdit", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }
        internal TransferErrorDialogResult ShowCorrespondingErrorDialog(Exception exception, bool feedbackNeeded = true)
        {
            var transferException = exception as TransferException;
            var exceptionType     = transferException != null ? transferException.Type : TransferErrorType.NotSpecified;

            _elapsedTimeMeter.Stop();

            var result = new TransferErrorDialogResult(ErrorResolutionBehavior.Cancel);

            switch (exceptionType)
            {
            case TransferErrorType.NotSpecified:
            {
                if (feedbackNeeded)
                {
                    result = _skipAll ?? WindowManager.ShowIoErrorDialog(exception);
                }
                else
                {
                    WindowManager.ShowMessage(Resx.IOError, exception.Message);
                }
            }
            break;

            case TransferErrorType.WriteAccessError:
            case TransferErrorType.NotSupporterCharactersInPath:
            case TransferErrorType.NameIsTooLong:
            case TransferErrorType.PathIsTooLong:
            {
                if (_skipAll != null)
                {
                    result = _skipAll;
                }
                else
                {
                    if (_queue == null)
                    {
                        WindowManager.ShowMessage(Resx.IOError, exception.Message);
                    }
                    else
                    {
                        var sourceFile = _queue.Peek().FileSystemItem;
                        var viewModel  = WindowManager.GetWriteErrorDialogViewModel(transferException);
                        if (exceptionType == TransferErrorType.WriteAccessError)
                        {
                            if (IsResumeSupported && sourceFile.Size > transferException.TargetFileSize)
                            {
                                viewModel.IsResumeEnabled    = true;
                                viewModel.IsResumeAllEnabled = true;
                            }
                            if (transferException.TargetFile != null)
                            {
                                TargetPane.GetItemViewModel(transferException.TargetFile);
                            }
                        }
                        SourcePane.GetItemViewModel(sourceFile.Path);
                        result = WindowManager.ShowWriteErrorDialog(viewModel);
                    }
                }
            }
            break;

            case TransferErrorType.LostConnection:
                var ftp = (FtpContentViewModel)transferException.Pane;
                if (WindowManager.ShowReconnectionDialog(exception) == true)
                {
                    try
                    {
                        ftp.RestoreConnection();
                        ftp.Refresh(false);
                    }
                    catch (Exception ex)
                    {
                        WindowManager.ShowMessage(Resx.ConnectionFailed, string.Format(Resx.CannotReestablishConnection, ex.Message));
                        ftp.CloseCommand.Execute();
                    }
                }
                else
                {
                    ftp.CloseCommand.Execute();
                }
                break;

            default:
                throw new NotSupportedException("Invalid transfer error type: " + exceptionType);
            }

            //TODO: refactor scoping
            if (result.Scope == CopyActionScope.All)
            {
                if (result.Action.HasValue)
                {
                    _rememberedCopyAction = result.Action.Value;
                }
                if (result.Behavior == ErrorResolutionBehavior.Skip)
                {
                    _skipAll = result;
                }
            }
            _elapsedTimeMeter.Start();
            return(result);
        }
 private OperationResult ExecuteDelete(QueueItem item)
 {
     return(new OperationResult(SourcePane.Delete(item.FileSystemItem)));
 }
        private OperationResult ExecuteCopy(QueueItem queueitem, CopyAction?action, string rename)
        {
            var            item       = queueitem.FileSystemItem;
            var            sourcePath = item.GetRelativePath(SourcePane.CurrentFolder.Path);
            var            targetPath = TargetPane.GetTargetPath(sourcePath);
            TransferResult result;

            switch (item.Type)
            {
            case ItemType.Directory:
            case ItemType.Link:
                if (TargetPane.CreateFolder(targetPath) == TransferResult.Ok)
                {
                    var       i = 1;
                    QueueItem qi;
                    while (i < _queue.Count && (qi = _queue.ElementAt(i)) != null && qi.FileSystemItem.Path.StartsWith(item.Path))
                    {
                        qi.CopyAction = CopyAction.Overwrite;
                        i++;
                    }
                }
                result = TransferResult.Ok;
                break;

            case ItemType.File:
                if (action == CopyAction.Rename && !string.IsNullOrEmpty(rename))
                {
                    var r = new Regex(string.Format(RenameFromPattern, item.Name), RegexOptions.IgnoreCase);
                    targetPath = r.Replace(targetPath, string.Format(RenameToPattern, rename));
                    action     = CopyAction.CreateNew;
                }

                var a = action ?? _rememberedCopyAction;

                FileMode          mode;
                FileExistenceInfo exists;
                long startPosition = 0;
                switch (a)
                {
                case CopyAction.CreateNew:
                    //TODO: check what happens if targetPath contains spec.char
                    exists = TargetPane.FileExists(targetPath);
                    if (exists)
                    {
                        throw new TransferException(TransferErrorType.WriteAccessError, Resx.TargetAlreadyExists)
                              {
                                  SourceFile     = item.Path,
                                  TargetFile     = targetPath,
                                  TargetFileSize = exists.Size
                              }
                    }
                    ;
                    mode = FileMode.CreateNew;
                    break;

                case CopyAction.Overwrite:
                    mode = FileMode.Create;
                    break;

                case CopyAction.OverwriteSmaller:
                    var target = TargetPane.FileExists(targetPath);
                    if (target.Exists && target.Size >= item.Size)
                    {
                        return(new OperationResult(TransferResult.Skipped, targetPath));
                    }
                    mode = FileMode.Create;
                    break;

                case CopyAction.Resume:
                    mode   = FileMode.Append;
                    exists = TargetPane.FileExists(targetPath);
                    if (exists)
                    {
                        startPosition = exists.Size;
                    }
                    break;

                default:
                    throw new ArgumentException("Invalid Copy action: " + action);
                }

                UIThread.Run(() => { TransferAction = GetCopyActionText(); });

                switch (_remoteCopy)
                {
                case RemoteCopyMode.Disabled:
                    using (var targetStream = TargetPane.GetStream(targetPath, mode, FileAccess.Write, startPosition))
                    {
                        result = SourcePane.CopyStream(item, targetStream, startPosition) ? TransferResult.Ok : TransferResult.Aborted;
                    }
                    break;

                case RemoteCopyMode.Download:
                    var sourceName = RemoteChangeDirectory(item.Path);
                    Telnet.Download(sourceName, targetPath, item.Size ?? 0, startPosition, (p, t, total, sp) => OnTransferProgressChanged(new TransferProgressChangedEventArgs(p, t, total, sp)));
                    result = TransferResult.Ok;
                    break;

                case RemoteCopyMode.Upload:
                    var targetName = RemoteChangeDirectory(targetPath);
                    Telnet.Upload(targetName, item.Path, item.Size ?? 0, startPosition, (p, t, total, sp) => OnTransferProgressChanged(new TransferProgressChangedEventArgs(p, t, total, sp)));
                    result = TransferResult.Ok;
                    break;

                default:
                    throw new NotSupportedException();
                }
                break;

            default:
                throw new NotSupportedException();
            }
            return(new OperationResult(result, targetPath));
        }