internal void QueueUpdate(UpdateLocalVersion update)
 {
     if (!this.updates.Any(u => u.ItemId == update.ItemId && u.LocalVersion == update.LocalVersion && string.Equals(u.TargetLocalItem, update.TargetLocalItem)))
     {
         this.updates.Add(update);
     }
 }
        public void ResetDownloadStatus(int itemId)
        {
            var updateVer = new UpdateLocalVersion(itemId, string.Empty, 0);
            var queue     = new UpdateLocalVersionQueue(this);

            queue.QueueUpdate(updateVer);
            queue.Flush();
        }
        private void UndoGetOperations(List <GetOperation> getOperations, IProgressMonitor monitor = null)
        {
            if (getOperations == null || getOperations.Count == 0)
            {
                return;
            }
            var downloadService       = this.VersionControlService.Collection.GetService <VersionControlDownloadService>();
            IProgressMonitor progress = monitor ?? new MonoDevelop.Ide.ProgressMonitoring.MessageDialogProgressMonitor(DispatchService.IsGuiThread, false, false);

            try
            {
                progress.BeginTask("Undo", getOperations.Count);
                UpdateLocalVersionQueue updates = new UpdateLocalVersionQueue(this);
                foreach (var operation in getOperations)
                {
                    try
                    {
                        if (progress.IsCancelRequested)
                        {
                            break;
                        }
                        string stepName = operation.ChangeType == ChangeType.None ? "Undo " : operation.ChangeType.ToString();
                        progress.BeginTask(stepName + " " + operation.TargetLocalItem, 1);
                        UpdateLocalVersion update = null;

                        if (operation.IsAdd)
                        {
                            update = ProcessAdd(operation, ProcessDirection.Undo);
                            if (update != null)
                            {
                                updates.QueueUpdate(update);
                            }
                            continue;
                        }

                        if (operation.IsDelete)
                        {
                            update = ProcessDelete(operation, downloadService, ProcessDirection.Undo, ProcessType.Delete);
                            if (update != null)
                            {
                                updates.QueueUpdate(update);
                            }
                        }

                        if (operation.IsRename)
                        {
                            update = ProcessRename(operation, ProcessDirection.Undo, progress);
                            if (update != null)
                            {
                                updates.QueueUpdate(update);
                            }
                        }
                        if (operation.IsEdit || operation.IsEncoding)
                        {
                            update = ProcessEdit(operation, downloadService, ProcessDirection.Undo);
                            if (update != null)
                            {
                                updates.QueueUpdate(update);
                            }
                        }
                    }
                    finally
                    {
                        progress.EndTask();
                    }
                }
                updates.Flush();
                progress.EndTask();
            }
            finally
            {
                if (monitor == null && progress != null)
                {
                    progress.Dispose();
                }
            }
        }
        private void ProcessGetOperations(List <GetOperation> getOperations, ProcessType processType, IProgressMonitor monitor = null)
        {
            if (getOperations == null || getOperations.Count == 0)
            {
                return;
            }
            var downloadService       = this.VersionControlService.Collection.GetService <VersionControlDownloadService>();
            IProgressMonitor progress = monitor ?? new MonoDevelop.Ide.ProgressMonitoring.MessageDialogProgressMonitor(DispatchService.IsGuiThread, false, false);

            try
            {
                progress.BeginTask("Process", getOperations.Count);
                UpdateLocalVersionQueue updates = new UpdateLocalVersionQueue(this);
                foreach (var operation in getOperations)
                {
                    try
                    {
                        if (progress.IsCancelRequested)
                        {
                            break;
                        }
                        progress.BeginTask(processType + " " + operation.TargetLocalItem, 1);
                        UpdateLocalVersion update = null;

                        switch (processType)
                        {
                        case ProcessType.Add:
                            update = ProcessAdd(operation, ProcessDirection.Normal);
                            break;

                        case ProcessType.Edit:
                            update = ProcessEdit(operation, downloadService, ProcessDirection.Normal);
                            break;

                        case ProcessType.Get:
                            update = ProcessGet(operation, downloadService, ProcessDirection.Normal);
                            break;

                        case ProcessType.Rename:
                            update = ProcessRename(operation, ProcessDirection.Normal, progress);
                            break;

                        case ProcessType.Delete:
                        case ProcessType.DeleteKeep:
                            update = ProcessDelete(operation, downloadService, ProcessDirection.Normal, processType);
                            break;

                        default:
                            update = ProcessGet(operation, downloadService, ProcessDirection.Normal);
                            break;
                        }

                        if (update != null)
                        {
                            updates.QueueUpdate(update);
                        }
                    }
                    finally
                    {
                        progress.EndTask();
                    }
                }
                updates.Flush();
                progress.EndTask();
            }
            finally
            {
                if (monitor == null && progress != null)
                {
                    progress.Dispose();
                }
            }
        }
 internal void QueueUpdate(UpdateLocalVersion update)
 {
     if (!this.updates.Any(u => u.ItemId == update.ItemId && u.LocalVersion == update.LocalVersion && string.Equals(u.TargetLocalItem, update.TargetLocalItem)))
         this.updates.Add(update);
 }