Attachment #124499 for bug #246149

Lines 42-50 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/actions/messages.properties (-1 / +5 lines)
42	DeleteAction_Permanently_delete_the_query=Permanently delete the query? Contained tasks will be moved to the Unmatched folder.	42	DeleteAction_Permanently_delete_the_query=Permanently delete the query? Contained tasks will be moved to the Unmatched folder.
43	DeleteAction_Permanently_delete_the_task_listed_below=Permanently delete the task listed below?	43	DeleteAction_Permanently_delete_the_task_listed_below=Permanently delete the task listed below?
44		44
		45
45	DeleteTaskRepositoryAction_Confirm_Delete=Confirm Delete	46	DeleteTaskRepositoryAction_Confirm_Delete=Confirm Delete
		47	DeleteTaskRepositoryAction_Delete_Specific_Task_Repository=Confirm the deletion of the {0} task repository
46	DeleteTaskRepositoryAction_Delete_Repository=Delete Repository	48	DeleteTaskRepositoryAction_Delete_Repository=Delete Repository
47	DeleteTaskRepositoryAction_Delete_the_selected_task_repositories=Delete the selected task repositories?	49	DeleteTaskRepositoryAction_Delete_Repository_In_Progress=Deleting repository and related artifacts
		50	DeleteTaskRepositoryAction_Delete_the_selected_task_repositories=This repository is being used by {0} tasks and {1} queries. Do you wish to delete the repository, tasks, and queries?
		51	DeleteTaskRepositoryAction_Delete_Task_Repository_Failed=Delete Task Repository Failed
48	DeleteTaskRepositoryAction_Repository_In_Use=Repository In Use	52	DeleteTaskRepositoryAction_Repository_In_Use=Repository In Use
49	DeleteTaskRepositoryAction_Repository_In_Use_MESSAGE=One or more of the selected repositories is being used by a query or a task and can not be deleted.	53	DeleteTaskRepositoryAction_Repository_In_Use_MESSAGE=One or more of the selected repositories is being used by a query or a task and can not be deleted.
50		54




import java.util.List;
import java.util.Set;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonsUiUtil;
import org.eclipse.mylyn.internal.provisional.commons.ui.ICoreRunnable;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.internal.tasks.core.ITaskListRunnable;
import org.eclipse.mylyn.internal.tasks.core.RepositoryQuery;
import org.eclipse.mylyn.internal.tasks.core.UnsubmittedTaskContainer;
import org.eclipse.mylyn.internal.tasks.ui.TaskRepositoryUtil;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.osgi.util.NLS;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.WorkbenchImages;
import org.eclipse.ui.texteditor.IWorkbenchActionDefinitionIds;

/**
 * @author Mik Kersten
 * @author David Shepherd
 * @author Steffen Pingel
 */
public class DeleteTaskRepositoryAction extends AbstractTaskRepositoryAction {


		setId(ID);
		setEnabled(false);
		setActionDefinitionId(IWorkbenchActionDefinitionIds.DELETE);
		setSingleSelect(true);
	}

	public void init(IViewPart view) {


	@Override
	public void run() {
		final TaskRepository repositoryToDelete = getTaskRepository(getStructuredSelection());
		if (repositoryToDelete == null) {
			return;
		}
		final List<IRepositoryQuery> queriesToDelete = new ArrayList<IRepositoryQuery>();
		final List<AbstractTask> tasksToDelete = new ArrayList<AbstractTask>();

		// check for queries over this repository			
		Set<RepositoryQuery> queries = TasksUiInternal.getTaskList().getQueries();
		for (IRepositoryQuery query : queries) {
			if (repositoryToDelete.getRepositoryUrl().equals(query.getRepositoryUrl())
					&& repositoryToDelete.getConnectorKind().equals(query.getConnectorKind())) {
				queriesToDelete.add(query);
			}
		}

		// check for tasks from this repository
		final Set<ITask> tasks = TasksUiPlugin.getTaskList().getTasks(repositoryToDelete.getRepositoryUrl());
		for (ITask task : tasks) {
			if (repositoryToDelete.getRepositoryUrl().equals(task.getRepositoryUrl())
					&& repositoryToDelete.getConnectorKind().equals(task.getConnectorKind())) {
				tasksToDelete.add((AbstractTask) task);
			}
		}

		//add tasks that were created for this repo but not submitted
		UnsubmittedTaskContainer unsubmitted = TasksUiPlugin.getTaskList().getUnsubmittedContainer(
				repositoryToDelete.getRepositoryUrl());
		if (unsubmitted != null) {
			Collection<ITask> children = unsubmitted.getChildren();
			if (children != null) {
				for (ITask task : children) {
					tasksToDelete.add((AbstractTask) task);
				}
			}
		}

		// confirm that the user wants to delete all tasks and queries that are associated
		boolean deleteConfirmed = false;

		if (queriesToDelete.size() > 0 || tasksToDelete.size() > 0) {
			deleteConfirmed = MessageDialog.openQuestion(TasksUiInternal.getShell(),
					Messages.DeleteTaskRepositoryAction_Confirm_Delete, NLS.bind(
							Messages.DeleteTaskRepositoryAction_Delete_the_selected_task_repositories, new Integer[] {
									tasksToDelete.size(), queriesToDelete.size() }));
		} else {
			deleteConfirmed = MessageDialog.openQuestion(TasksUiInternal.getShell(),
					Messages.DeleteTaskRepositoryAction_Confirm_Delete, NLS.bind(
							Messages.DeleteTaskRepositoryAction_Delete_Specific_Task_Repository,
							new String[] { repositoryToDelete.getRepositoryLabel() }));

		}
		if (deleteConfirmed) {
			ICoreRunnable op = new ICoreRunnable() {
				public void run(IProgressMonitor monitor) throws CoreException {
					try {
						monitor.beginTask(Messages.DeleteTaskRepositoryAction_Delete_Repository_In_Progress,
								IProgressMonitor.UNKNOWN);
						TasksUiPlugin.getTaskList().run(new ITaskListRunnable() {
							public void execute(IProgressMonitor monitor) throws CoreException {
								// delete tasks
								for (AbstractTask abstractTask : tasksToDelete) {
									TasksUiPlugin.getTaskList().deleteTask(abstractTask);
								}
								// delete queries
								for (IRepositoryQuery query : queriesToDelete) {
									TasksUiPlugin.getTaskList().deleteQuery((RepositoryQuery) query);
								}
								// delete repository
								TasksUiPlugin.getRepositoryManager().removeRepository(repositoryToDelete,
										TasksUiPlugin.getDefault().getRepositoriesFilePath());
								// if repository is contributed via template, ensure it isn't added again
								TaskRepositoryUtil.disableAddAutomatically(repositoryToDelete.getRepositoryUrl());
							}
						}, monitor);
					} finally {
						monitor.done();
						}
					}
				}
			};
			try {
				CommonsUiUtil.busyCursorWhile(op);
			} catch (CoreException e) {
				Status status = new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN, NLS.bind(
						"Problems encountered deleting task repository: {0}", e.getMessage()), e); //$NON-NLS-1$
				TasksUiInternal.logAndDisplayStatus(Messages.DeleteTaskRepositoryAction_Delete_Task_Repository_Failed,
						status);
			} catch (OperationCanceledException e) {
				// canceled
							Messages.DeleteTaskRepositoryAction_Repository_In_Use,
							Messages.DeleteTaskRepositoryAction_Repository_In_Use_MESSAGE);
				}
			}
		} catch (Exception e) {
			StatusHandler.fail(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN, e.getMessage(), e));
		}
	}
}

Lines 95-100 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/actions/Messages.java (+6 lines)
95		95
96	public static String DeleteTaskRepositoryAction_Confirm_Delete;	96	public static String DeleteTaskRepositoryAction_Confirm_Delete;
97		97
		98	public static String DeleteTaskRepositoryAction_Delete_Specific_Task_Repository;
		99
98	public static String DeleteTaskRepositoryAction_Delete_Repository;	100	public static String DeleteTaskRepositoryAction_Delete_Repository;
99		101
100	public static String DeleteTaskRepositoryAction_Delete_the_selected_task_repositories;	102	public static String DeleteTaskRepositoryAction_Delete_the_selected_task_repositories;
Lines 103-108 Link Here
103		105
104	public static String DeleteTaskRepositoryAction_Repository_In_Use_MESSAGE;	106	public static String DeleteTaskRepositoryAction_Repository_In_Use_MESSAGE;
105		107
		108	public static String DeleteTaskRepositoryAction_Delete_Repository_In_Progress;
		109
		110	public static String DeleteTaskRepositoryAction_Delete_Task_Repository_Failed;
		111
106	public static String EditRepositoryPropertiesAction_Properties;	112	public static String EditRepositoryPropertiesAction_Properties;
107		113
108	public static String ExpandAllAction_Expand_All;	114	public static String ExpandAllAction_Expand_All;

Return to bug 246149

Lines 16-42 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/actions/DeleteTaskRepositoryAction.java (-60 / +93 lines)
16	import java.util.List;	16	import java.util.List;
17	import java.util.Set;	17	import java.util.Set;
18		18
		19	import org.eclipse.core.runtime.CoreException;
		20	import org.eclipse.core.runtime.IProgressMonitor;
19	import org.eclipse.core.runtime.IStatus;	21	import org.eclipse.core.runtime.IStatus;
		22	import org.eclipse.core.runtime.OperationCanceledException;
20	import org.eclipse.core.runtime.Status;	23	import org.eclipse.core.runtime.Status;
21	import org.eclipse.jface.dialogs.MessageDialog;	24	import org.eclipse.jface.dialogs.MessageDialog;
22	import org.eclipse.jface.viewers.IStructuredSelection;	25	import org.eclipse.mylyn.internal.provisional.commons.ui.CommonsUiUtil;
23	import org.eclipse.mylyn.commons.core.StatusHandler;	26	import org.eclipse.mylyn.internal.provisional.commons.ui.ICoreRunnable;
24	import org.eclipse.mylyn.internal.tasks.core.AbstractTask;	27	import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
		28	import org.eclipse.mylyn.internal.tasks.core.ITaskListRunnable;
25	import org.eclipse.mylyn.internal.tasks.core.RepositoryQuery;	29	import org.eclipse.mylyn.internal.tasks.core.RepositoryQuery;
		30	import org.eclipse.mylyn.internal.tasks.core.UnsubmittedTaskContainer;
26	import org.eclipse.mylyn.internal.tasks.ui.TaskRepositoryUtil;	31	import org.eclipse.mylyn.internal.tasks.ui.TaskRepositoryUtil;
27	import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;	32	import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
28	import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;	33	import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
29	import org.eclipse.mylyn.tasks.core.IRepositoryQuery;	34	import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
30	import org.eclipse.mylyn.tasks.core.ITask;	35	import org.eclipse.mylyn.tasks.core.ITask;
31	import org.eclipse.mylyn.tasks.core.TaskRepository;	36	import org.eclipse.mylyn.tasks.core.TaskRepository;
		37	import org.eclipse.osgi.util.NLS;
32	import org.eclipse.ui.ISharedImages;	38	import org.eclipse.ui.ISharedImages;
33	import org.eclipse.ui.IViewPart;	39	import org.eclipse.ui.IViewPart;
34	import org.eclipse.ui.PlatformUI;
35	import org.eclipse.ui.internal.WorkbenchImages;	40	import org.eclipse.ui.internal.WorkbenchImages;
36	import org.eclipse.ui.texteditor.IWorkbenchActionDefinitionIds;	41	import org.eclipse.ui.texteditor.IWorkbenchActionDefinitionIds;
37		42
38	/**	43	/**
39	* @author Mik Kersten	44	* @author Mik Kersten
		45	* @author David Shepherd
		46	* @author Steffen Pingel
40	*/	47	*/
41	public class DeleteTaskRepositoryAction extends AbstractTaskRepositoryAction {	48	public class DeleteTaskRepositoryAction extends AbstractTaskRepositoryAction {
42		49
Lines 48-53 Link Here
48	setId(ID);	55	setId(ID);
49	setEnabled(false);	56	setEnabled(false);
50	setActionDefinitionId(IWorkbenchActionDefinitionIds.DELETE);	57	setActionDefinitionId(IWorkbenchActionDefinitionIds.DELETE);
		58	setSingleSelect(true);
51	}	59	}
52		60
53	public void init(IViewPart view) {	61	public void init(IViewPart view) {
Lines 56-126 Link Here
56		64
57	@Override	65	@Override
58	public void run() {	66	public void run() {
59	try {	67	final TaskRepository repositoryToDelete = getTaskRepository(getStructuredSelection());
		68	if (repositoryToDelete == null) {
		69	return;
		70	}
		71	final List<IRepositoryQuery> queriesToDelete = new ArrayList<IRepositoryQuery>();
		72	final List<AbstractTask> tasksToDelete = new ArrayList<AbstractTask>();
60		73
61	boolean deleteConfirmed = MessageDialog.openQuestion(PlatformUI.getWorkbench()	74	// check for queries over this repository
62	.getActiveWorkbenchWindow()	75	Set<RepositoryQuery> queries = TasksUiInternal.getTaskList().getQueries();
63	.getShell(), Messages.DeleteTaskRepositoryAction_Confirm_Delete, Messages.DeleteTaskRepositoryAction_Delete_the_selected_task_repositories);	76	for (IRepositoryQuery query : queries) {
64	if (deleteConfirmed) {	77	if (repositoryToDelete.getRepositoryUrl().equals(query.getRepositoryUrl())
65	IStructuredSelection selection = getStructuredSelection();	78	&& repositoryToDelete.getConnectorKind().equals(query.getConnectorKind())) {
66		79	queriesToDelete.add(query);
67	// check for queries over this repository	80	}
68	Set<RepositoryQuery> queries = TasksUiInternal.getTaskList().getQueries();	81	}
69	List<TaskRepository> repositoriesInUse = new ArrayList<TaskRepository>();	82
70	List<TaskRepository> repositoriesToDelete = new ArrayList<TaskRepository>();	83	// check for tasks from this repository
71	for (Object selectedObject : selection.toList()) {	84	final Set<ITask> tasks = TasksUiPlugin.getTaskList().getTasks(repositoryToDelete.getRepositoryUrl());
72	if (selectedObject instanceof TaskRepository) {	85	for (ITask task : tasks) {
73	TaskRepository taskRepository = (TaskRepository) selectedObject;	86	if (repositoryToDelete.getRepositoryUrl().equals(task.getRepositoryUrl())
74	if (queries != null && queries.size() > 0) {	87	&& repositoryToDelete.getConnectorKind().equals(task.getConnectorKind())) {
75	for (IRepositoryQuery query : queries) {	88	tasksToDelete.add((AbstractTask) task);
76	if (query.getRepositoryUrl().equals(taskRepository.getRepositoryUrl())) {	89	}
77	repositoriesInUse.add(taskRepository);	90	}
78	break;	91
79	}	92	//add tasks that were created for this repo but not submitted
80	}	93	UnsubmittedTaskContainer unsubmitted = TasksUiPlugin.getTaskList().getUnsubmittedContainer(
81	}	94	repositoryToDelete.getRepositoryUrl());
82	if (!repositoriesInUse.contains(taskRepository)) {	95	if (unsubmitted != null) {
83	repositoriesToDelete.add(taskRepository);	96	Collection<ITask> children = unsubmitted.getChildren();
84	}	97	if (children != null) {
85	}	98	for (ITask task : children) {
		99	tasksToDelete.add((AbstractTask) task);
86	}	100	}
		101	}
		102	}
		103
		104	// confirm that the user wants to delete all tasks and queries that are associated
		105	boolean deleteConfirmed = false;
87		106
88	// check for tasks from this repository	107	if (queriesToDelete.size() > 0 \|\| tasksToDelete.size() > 0) {
89	// bug 243975	108	deleteConfirmed = MessageDialog.openQuestion(TasksUiInternal.getShell(),
90	Collection<AbstractTask> tasks = TasksUiPlugin.getTaskList().getAllTasks();	109	Messages.DeleteTaskRepositoryAction_Confirm_Delete, NLS.bind(
91	for (Object selectedObject : selection.toList()) {	110	Messages.DeleteTaskRepositoryAction_Delete_the_selected_task_repositories, new Integer[] {
92	if (selectedObject instanceof TaskRepository) {	111	tasksToDelete.size(), queriesToDelete.size() }));
93	TaskRepository taskRepository = (TaskRepository) selectedObject;	112	} else {
94	if (tasks != null && tasks.size() > 0) {	113	deleteConfirmed = MessageDialog.openQuestion(TasksUiInternal.getShell(),
95	for (ITask task : tasks) {	114	Messages.DeleteTaskRepositoryAction_Confirm_Delete, NLS.bind(
96	if (task.getRepositoryUrl() != null	115	Messages.DeleteTaskRepositoryAction_Delete_Specific_Task_Repository,
97	&& task.getRepositoryUrl().equals(taskRepository.getRepositoryUrl())) {	116	new String[] { repositoryToDelete.getRepositoryLabel() }));
98	repositoriesInUse.add(taskRepository);	117
99	break;	118	}
		119	if (deleteConfirmed) {
		120	ICoreRunnable op = new ICoreRunnable() {
		121	public void run(IProgressMonitor monitor) throws CoreException {
		122	try {
		123	monitor.beginTask(Messages.DeleteTaskRepositoryAction_Delete_Repository_In_Progress,
		124	IProgressMonitor.UNKNOWN);
		125	TasksUiPlugin.getTaskList().run(new ITaskListRunnable() {
		126	public void execute(IProgressMonitor monitor) throws CoreException {
		127	// delete tasks
		128	for (AbstractTask abstractTask : tasksToDelete) {
		129	TasksUiPlugin.getTaskList().deleteTask(abstractTask);
100	}	130	}
		131	// delete queries
		132	for (IRepositoryQuery query : queriesToDelete) {
		133	TasksUiPlugin.getTaskList().deleteQuery((RepositoryQuery) query);
		134	}
		135	// delete repository
		136	TasksUiPlugin.getRepositoryManager().removeRepository(repositoryToDelete,
		137	TasksUiPlugin.getDefault().getRepositoriesFilePath());
		138	// if repository is contributed via template, ensure it isn't added again
		139	TaskRepositoryUtil.disableAddAutomatically(repositoryToDelete.getRepositoryUrl());
101	}	140	}
102	}	141	}, monitor);
103	if (repositoriesInUse.contains(taskRepository)) {	142	} finally {
104	repositoriesToDelete.remove(taskRepository);	143	monitor.done();
105	}
106	}	144	}
107	}	145	}
108		146	};
109	for (TaskRepository taskRepository : repositoriesToDelete) {	147	try {
110	TasksUiPlugin.getRepositoryManager().removeRepository(taskRepository,	148	CommonsUiUtil.busyCursorWhile(op);
111	TasksUiPlugin.getDefault().getRepositoriesFilePath());	149	} catch (CoreException e) {
112	// if repository is contributed via template, ensure it isn't added again	150	Status status = new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN, NLS.bind(
113	TaskRepositoryUtil.disableAddAutomatically(taskRepository.getRepositoryUrl());	151	"Problems encountered deleting task repository: {0}", e.getMessage()), e); //$NON-NLS-1$
114	}	152	TasksUiInternal.logAndDisplayStatus(Messages.DeleteTaskRepositoryAction_Delete_Task_Repository_Failed,
115		153	status);
116	if (repositoriesInUse.size() > 0) {	154	} catch (OperationCanceledException e) {
117	MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),	155	// canceled
118	Messages.DeleteTaskRepositoryAction_Repository_In_Use,
119	Messages.DeleteTaskRepositoryAction_Repository_In_Use_MESSAGE);
120	}
121	}	156	}
122	} catch (Exception e) {
123	StatusHandler.fail(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN, e.getMessage(), e));
124	}	157	}
125	}	158	}
126	}	159	}