Attachment #85037 for bug #181388

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 10-18 Link Here

(-)src/org/eclipse/mylyn/internal/context/ui/TaskListInterestSorter.java (-10 / +20 lines)
10		10
11	import org.eclipse.jface.viewers.Viewer;	11	import org.eclipse.jface.viewers.Viewer;
12	import org.eclipse.jface.viewers.ViewerSorter;	12	import org.eclipse.jface.viewers.ViewerSorter;
		13	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
		14	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
13	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;	15	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
14	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;
15	import org.eclipse.mylyn.internal.tasks.core.UnfiledCategory;
16	import org.eclipse.mylyn.internal.tasks.ui.views.TaskKeyComparator;	16	import org.eclipse.mylyn.internal.tasks.ui.views.TaskKeyComparator;
17	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter;	17	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter;
18	import org.eclipse.mylyn.tasks.core.AbstractTask;	18	import org.eclipse.mylyn.tasks.core.AbstractTask;
Lines 28-36 Link Here
28		28
29	@Override	29	@Override
30	public int compare(Viewer compareViewer, Object o1, Object o2) {	30	public int compare(Viewer compareViewer, Object o1, Object o2) {
31	if (o1 instanceof AbstractTaskContainer && o2 instanceof TaskArchive) {	31
		32	OrphanedTasksContainer localArchive = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
		33	LocalRepositoryConnector.REPOSITORY_URL);
		34	if (o1 == localArchive && o2 instanceof AbstractTaskContainer) {
		35	return -1;
		36	} else if (o1 instanceof AbstractTaskContainer && o2 == localArchive) {
		37	return 1;
		38	}
		39
		40	if (o1 instanceof AbstractTaskContainer && o2 instanceof OrphanedTasksContainer) {
32	return -1;	41	return -1;
33	} else if (o2 instanceof AbstractTaskContainer && o1 instanceof TaskArchive) {	42	} else if (o2 instanceof AbstractTaskContainer && o1 instanceof OrphanedTasksContainer) {
34	return 1;	43	return 1;
35	}	44	}
36		45
Lines 44-54 Link Here
44	return 1;	53	return 1;
45	}	54	}
46		55
47	if (o1 instanceof UnfiledCategory && o2 instanceof AbstractTaskContainer) {	56	// if (o1 instanceof OrphanedTasksContainer && o2 instanceof AbstractTaskContainer) {
48	return -1;	57	// return -1;
49	} else if (o1 instanceof AbstractTaskContainer && o2 instanceof UnfiledCategory) {	58	// } else if (o1 instanceof AbstractTaskContainer && o2 instanceof OrphanedTasksContainer) {
50	return 1;	59	// return 1;
51	}	60	// }
52		61
53	if (!(o1 instanceof AbstractTask) && o2 instanceof AbstractTask) {	62	if (!(o1 instanceof AbstractTask) && o2 instanceof AbstractTask) {
54	return 1;	63	return 1;
Lines 186-192 Link Here
186	}	195	}
187		196
188	private int compareKeys(AbstractTaskContainer element1, AbstractTaskContainer element2) {	197	private int compareKeys(AbstractTaskContainer element1, AbstractTaskContainer element2) {
189	return taskKeyComparator.compare(TaskListTableSorter.getSortableFromElement(element1), TaskListTableSorter.getSortableFromElement(element2));	198	return taskKeyComparator.compare(TaskListTableSorter.getSortableFromElement(element1),
		199	TaskListTableSorter.getSortableFromElement(element2));
190	}	200	}
191		201
192	private int comparePriorities(AbstractTaskContainer element1, AbstractTaskContainer element2) {	202	private int comparePriorities(AbstractTaskContainer element1, AbstractTaskContainer element2) {

Lines 46-52 Link Here

(-)src/org/eclipse/mylyn/tasks/core/TaskSelection.java (-1 / +1 lines)
46		46
47	public TaskSelection(String summary, String description) {	47	public TaskSelection(String summary, String description) {
48	RepositoryTaskData taskData = new RepositoryTaskData(new IdentityAttributeFactory(),	48	RepositoryTaskData taskData = new RepositoryTaskData(new IdentityAttributeFactory(),
49	LocalRepositoryConnector.REPOSITORY_KIND, LocalRepositoryConnector.REPOSITORY_URL, "");	49	LocalRepositoryConnector.CONNECTOR_KIND, LocalRepositoryConnector.REPOSITORY_URL, "");
50	taskData.setSummary(summary);	50	taskData.setSummary(summary);
51	taskData.setDescription(description);	51	taskData.setDescription(description);
52	this.taskData = taskData;	52	this.taskData = taskData;

Lines 23-28 Link Here

(-)src/org/eclipse/mylyn/tasks/core/AbstractTaskCategory.java (+2 lines)
23	/**	23	/**
24	* Override to return true for categories that the user creates, deletes, and renames. Return false for categories	24	* Override to return true for categories that the user creates, deletes, and renames. Return false for categories
25	* that are managed	25	* that are managed
		26	*
		27	* @API-3.0: Move up into AbstractTaskContainer
26	*/	28	*/
27	public abstract boolean isUserDefined();	29	public abstract boolean isUserDefined();
28		30

Lines 19-24 Link Here

(-)src/org/eclipse/mylyn/tasks/core/TaskRepositoryManager.java (+5 lines)
19	import java.util.Set;	19	import java.util.Set;
20		20
21	import org.eclipse.core.runtime.Platform;	21	import org.eclipse.core.runtime.Platform;
		22	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
22	import org.eclipse.mylyn.internal.tasks.core.TaskRepositoriesExternalizer;	23	import org.eclipse.mylyn.internal.tasks.core.TaskRepositoriesExternalizer;
23	import org.eclipse.mylyn.monitor.core.StatusHandler;	24	import org.eclipse.mylyn.monitor.core.StatusHandler;
24		25
Lines 96-101 Link Here
96	}	97	}
97	repositories.add(repository);	98	repositories.add(repository);
98	saveRepositories(repositoryFilePath);	99	saveRepositories(repositoryFilePath);
		100
		101	taskList.addOrphanContainer(new OrphanedTasksContainer(repository.getConnectorKind(), repository.getUrl()));
		102
99	for (ITaskRepositoryListener listener : listeners) {	103	for (ITaskRepositoryListener listener : listeners) {
100	listener.repositoryAdded(repository);	104	listener.repositoryAdded(repository);
101	}	105	}
Lines 106-111 Link Here
106	if (repositories != null) {	110	if (repositories != null) {
107	repository.flushAuthenticationCredentials();	111	repository.flushAuthenticationCredentials();
108	repositories.remove(repository);	112	repositories.remove(repository);
		113	taskList.removeOrphanContainer(repository.getUrl());
109	}	114	}
110	saveRepositories(repositoryFilePath);	115	saveRepositories(repositoryFilePath);
111	for (ITaskRepositoryListener listener : listeners) {	116	for (ITaskRepositoryListener listener : listeners) {

Lines 19-29 Link Here

(-)src/org/eclipse/mylyn/tasks/core/TaskList.java (-51 / +276 lines)
19	import java.util.concurrent.CopyOnWriteArrayList;	19	import java.util.concurrent.CopyOnWriteArrayList;
20	import java.util.concurrent.CopyOnWriteArraySet;	20	import java.util.concurrent.CopyOnWriteArraySet;
21		21
		22	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
22	import org.eclipse.mylyn.internal.tasks.core.LocalTask;	23	import org.eclipse.mylyn.internal.tasks.core.LocalTask;
		24	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
23	import org.eclipse.mylyn.internal.tasks.core.RepositoryTaskHandleUtil;	25	import org.eclipse.mylyn.internal.tasks.core.RepositoryTaskHandleUtil;
24	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;	26	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;
25	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;	27	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
26	import org.eclipse.mylyn.internal.tasks.core.UnfiledCategory;
27	import org.eclipse.mylyn.monitor.core.StatusHandler;	28	import org.eclipse.mylyn.monitor.core.StatusHandler;
28		29
29	/**	30	/**
Lines 34-79 Link Here
34	*/	35	*/
35	public class TaskList {	36	public class TaskList {
36		37
		38	private static final int MAX_ORPHAN_DEPTH = 10;
		39
37	private int lastLocalTaskId = 0;	40	private int lastLocalTaskId = 0;
38		41
39	private Set<ITaskListChangeListener> changeListeners = new CopyOnWriteArraySet<ITaskListChangeListener>();	42	private Set<ITaskListChangeListener> changeListeners = new CopyOnWriteArraySet<ITaskListChangeListener>();
40		43
		44	private Map<String, OrphanedTasksContainer> repositoryOrphansMap;
		45
41	private Map<String, AbstractTask> tasks;	46	private Map<String, AbstractTask> tasks;
42		47
43	private Map<String, AbstractTaskCategory> categories;	48	private Map<String, AbstractTaskCategory> categories;
44		49
45	private Map<String, AbstractRepositoryQuery> queries;	50	private Map<String, AbstractRepositoryQuery> queries;
46		51
47	private TaskArchive archiveContainer;
48
49	private UnfiledCategory defaultCategory;
50
51	private List<AbstractTask> activeTasks;	52	private List<AbstractTask> activeTasks;
52		53
		54	private TaskArchive archiveContainer;
		55
53	public TaskList() {	56	public TaskList() {
54	reset();	57	reset();
55	}	58	}
56		59
		60	private void addOrphan(AbstractTask task, Set<TaskContainerDelta> delta) {
		61	addOrphan(task, delta, 0);
		62	}
		63
		64	private void addOrphan(AbstractTask task, Set<TaskContainerDelta> delta, int depth) {
		65	if (/task.getLastReadTimeStamp() == null \|\|/!getQueriesForHandle(task.getHandleIdentifier()).isEmpty()
		66	\|\| getCategoryForHandle(task.getHandleIdentifier()) != null) {
		67	// Current policy is not to archive/orphan if the task exists in some other container
		68	return;
		69	}
		70	OrphanedTasksContainer orphans = repositoryOrphansMap.get(task.getRepositoryUrl());
		71	// if (orphans == null) {
		72	// orphans = new OrphanedTasksContainer(task.getConnectorKind(), task.getRepositoryUrl());
		73	// repositoryOrphansMap.put(task.getRepositoryUrl(), orphans);
		74	// //categories.put(orphans.getHandleIdentifier(), orphans);
		75	// }
		76
		77	if (orphans != null) {
		78	if (!orphans.contains(task.getHandleIdentifier())) {
		79	orphans.internalAddChild(task);
		80	if (delta != null) {
		81	delta.add(new TaskContainerDelta(orphans, TaskContainerDelta.Kind.CHANGED));
		82	}
		83	}
		84	task.addParentContainer(orphans);
		85	} else {
		86	StatusHandler.log("Orphan container not found for: " + task.getRepositoryUrl(), this);
		87	}
		88
		89	if (depth < MAX_ORPHAN_DEPTH && !task.isEmpty()) {
		90	for (AbstractTask child : task.getChildren()) {
		91	addOrphan(child, delta, depth + 1);
		92	}
		93	}
		94
		95	}
		96
		97	private void removeOrphan(AbstractTask task, Set<TaskContainerDelta> delta) {
		98	OrphanedTasksContainer orphans = repositoryOrphansMap.get(task.getRepositoryUrl());
		99	if (orphans != null) {
		100	if (orphans.contains(task.getHandleIdentifier())) {
		101	orphans.internalRemoveChild(task);
		102	if (delta != null) {
		103	delta.add(new TaskContainerDelta(orphans, TaskContainerDelta.Kind.CHANGED));
		104	}
		105	}
		106	// if (orphans.isEmpty() && !orphans.getRepositoryUrl().equals(LocalRepositoryConnector.REPOSITORY_URL)) {
		107	// repositoryOrphansMap.remove(task.getRepositoryUrl());
		108	// if (delta != null) {
		109	// delta.add(new TaskContainerDelta(orphans, TaskContainerDelta.Kind.CHANGED));
		110	// }
		111	// }
		112	task.removeParentContainer(orphans);
		113	}
		114	}
		115
		116	/**
		117	* @since 2.2
		118	*/
		119	public Set<OrphanedTasksContainer> getOrphanContainers() {
		120	return Collections.unmodifiableSet(new HashSet<OrphanedTasksContainer>(repositoryOrphansMap.values()));
		121	}
		122
		123	/**
124	* @since 2.2
125	*/
126	public OrphanedTasksContainer getOrphanContainer(String repositoryUrl) {
127	return repositoryOrphansMap.get(repositoryUrl);
128	}
129
57	/**	130	/**
58	* Public for testing.	131	* Public for testing.
59	*/	132	*/
60	public void reset() {	133	public void reset() {
61	tasks = new ConcurrentHashMap<String, AbstractTask>();	134	tasks = new ConcurrentHashMap<String, AbstractTask>();
62		135
		136	repositoryOrphansMap = new ConcurrentHashMap<String, OrphanedTasksContainer>();
		137	// repositoryOrphansMap.put(LocalRepositoryConnector.REPOSITORY_URL, new OrphanedTasksContainer(
		138	// LocalRepositoryConnector.CONNECTOR_KIND, LocalRepositoryConnector.REPOSITORY_URL));
		139
63	categories = new ConcurrentHashMap<String, AbstractTaskCategory>();	140	categories = new ConcurrentHashMap<String, AbstractTaskCategory>();
64	queries = new ConcurrentHashMap<String, AbstractRepositoryQuery>();	141	queries = new ConcurrentHashMap<String, AbstractRepositoryQuery>();
65		142
66	archiveContainer = new TaskArchive();	143	archiveContainer = new TaskArchive(this);
67	defaultCategory = new UnfiledCategory();	144	//defaultCategory = new UnfiledCategory();
68		145
69	activeTasks = new CopyOnWriteArrayList<AbstractTask>();	146	activeTasks = new CopyOnWriteArrayList<AbstractTask>();
70	lastLocalTaskId = 0;	147	lastLocalTaskId = 0;
71	categories.put(defaultCategory.getHandleIdentifier(), defaultCategory);	148	// categories.put(defaultCategory.getHandleIdentifier(), defaultCategory);
72	categories.put(archiveContainer.getHandleIdentifier(), archiveContainer);	149	// categories.put(archiveContainer.getHandleIdentifier(), archiveContainer);
73	}	150	}
74		151
		152	/**
		153	* Add orphaned task to the task list
		154	*/
75	public void addTask(AbstractTask task) throws IllegalArgumentException {	155	public void addTask(AbstractTask task) throws IllegalArgumentException {
76	addTask(task, archiveContainer);	156	addTask(task, null);
77	}	157	}
78		158
79	/**	159	/**
Lines 94-100 Link Here
94	}	174	}
95		175
96	/**	176	/**
97	* Precondition: {@code container} already exists in tasklist (be it a parent task, category, or query)	177	* Precondition: {@code container} already exists in tasklist (be it a parent task, category, or query) If the
		178	* parentContainer is null the task is considered an orphan and added to the appropriate repository's orphaned tasks
		179	* container.
98	*	180	*
99	* @param task	181	* @param task
100	* to be added (hit, subtask, etc)	182	* to be added (hit, subtask, etc)
Lines 111-118 Link Here
111	if (newTask == null) {	193	if (newTask == null) {
112	newTask = task;	194	newTask = task;
113	tasks.put(newTask.getHandleIdentifier(), newTask);	195	tasks.put(newTask.getHandleIdentifier(), newTask);
114	// archiveContainer.addChild(newTask);
115	// newTask.addParentContainer(archiveContainer);
116		196
117	// NOTE: only called for newly-created tasks	197	// NOTE: only called for newly-created tasks
118	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();	198	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
Lines 126-141 Link Here
126	}	206	}
127		207
128	if (parentContainer != null) {	208	if (parentContainer != null) {
		209	if (parentContainer instanceof AbstractTask) {
		210	// Ensure the parent task exists in the task list
		211	tasks.put(parentContainer.getHandleIdentifier(), (AbstractTask) parentContainer);
		212	addOrphan((AbstractTask) parentContainer, null);
		213	// TODO: will need to update map of children to parents here
		214	}
		215
		216	removeOrphan(newTask, null);
		217
129	parentContainer.internalAddChild(newTask);	218	parentContainer.internalAddChild(newTask);
		219
130	if (!(parentContainer instanceof AbstractTask) && !(parentContainer instanceof AbstractRepositoryQuery)) {	220	if (!(parentContainer instanceof AbstractTask) && !(parentContainer instanceof AbstractRepositoryQuery)) {
131	newTask.addParentContainer(parentContainer);	221	newTask.addParentContainer(parentContainer);
132	}	222	}
133	} else {	223	} else {
134	defaultCategory.internalAddChild(newTask);	224	// TODO: if the task has a parent task which isn't orphaned than the current task isn't orphaned
135	newTask.addParentContainer(defaultCategory);	225	// check map of children to parents first
		226	addOrphan(task, null);
136	}	227	}
137	}	228	}
138		229
		230	/**
		231	* @since 2.2
		232	*/
		233	public void moveTask(AbstractTask task, AbstractTaskContainer container) {
		234	if (!tasks.containsKey(task.getHandleIdentifier())) {
		235	tasks.put(task.getHandleIdentifier(), task);
		236	}
		237	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
		238	delta.add(new TaskContainerDelta(container, TaskContainerDelta.Kind.CHANGED));
		239
		240	Set<AbstractTaskContainer> currentContainers = task.getParentContainers();
		241	for (AbstractTaskContainer taskContainer : currentContainers) {
		242	if (taskContainer instanceof AbstractTaskCategory) {
		243	if (!(taskContainer instanceof OrphanedTasksContainer)) {
		244	(taskContainer).internalRemoveChild(task);
		245	}
		246	task.removeParentContainer(taskContainer);
		247	delta.add(new TaskContainerDelta(taskContainer, TaskContainerDelta.Kind.CHANGED));
		248	}
		249	}
		250	if (container != null) {
		251	internalAddTask(task, container);
		252	delta.add(new TaskContainerDelta(container, TaskContainerDelta.Kind.CHANGED));
		253	if (!(container instanceof OrphanedTasksContainer)) {
		254	removeOrphan(task, delta);
		255	}
		256	} else {
		257	internalAddTask(task, null);
		258	}
		259	for (ITaskListChangeListener listener : changeListeners) {
		260	listener.containersChanged(delta);
		261	}
		262	}
		263
		264	/**
		265	* @deprecated
		266	*/
139	public void moveToContainer(AbstractTask task, AbstractTaskCategory container) {	267	public void moveToContainer(AbstractTask task, AbstractTaskCategory container) {
140	if (!tasks.containsKey(task.getHandleIdentifier())) {	268	if (!tasks.containsKey(task.getHandleIdentifier())) {
141	tasks.put(task.getHandleIdentifier(), task);	269	tasks.put(task.getHandleIdentifier(), task);
Lines 146-154 Link Here
146	Set<AbstractTaskContainer> currentContainers = task.getParentContainers();	274	Set<AbstractTaskContainer> currentContainers = task.getParentContainers();
147	for (AbstractTaskContainer taskContainer : currentContainers) {	275	for (AbstractTaskContainer taskContainer : currentContainers) {
148	if (taskContainer instanceof AbstractTaskCategory) {	276	if (taskContainer instanceof AbstractTaskCategory) {
149	if (!(taskContainer instanceof TaskArchive)) {	277	if (!(taskContainer instanceof OrphanedTasksContainer)) {
150	(taskContainer).internalRemoveChild(task);	278	(taskContainer).internalRemoveChild(task);
151	}	279	}
		280	// if (!(taskContainer instanceof TaskArchive)) {
		281	// (taskContainer).internalRemoveChild(task);
		282	// }
152	task.removeParentContainer(taskContainer);	283	task.removeParentContainer(taskContainer);
153	delta.add(new TaskContainerDelta(taskContainer, TaskContainerDelta.Kind.CHANGED));	284	delta.add(new TaskContainerDelta(taskContainer, TaskContainerDelta.Kind.CHANGED));
154	}	285	}
Lines 156-167 Link Here
156	if (container != null) {	287	if (container != null) {
157	internalAddTask(task, container);	288	internalAddTask(task, container);
158	delta.add(new TaskContainerDelta(container, TaskContainerDelta.Kind.CHANGED));	289	delta.add(new TaskContainerDelta(container, TaskContainerDelta.Kind.CHANGED));
159	if (archiveContainer.contains(task.getHandleIdentifier())) {	290	if (!(container instanceof OrphanedTasksContainer)) {
160	archiveContainer.internalRemoveChild(task);	291	removeOrphan(task, delta);
161	delta.add(new TaskContainerDelta(archiveContainer, TaskContainerDelta.Kind.CHANGED));
162	}	292	}
		293	// if (archiveContainer.contains(task.getHandleIdentifier())) {
		294	// archiveContainer.internalRemoveChild(task);
		295	// delta.add(new TaskContainerDelta(archiveContainer, TaskContainerDelta.Kind.CHANGED));
		296	// }
163	} else {	297	} else {
164	internalAddTask(task, archiveContainer);	298	internalAddTask(task, null);
165	}	299	}
166	for (ITaskListChangeListener listener : changeListeners) {	300	for (ITaskListChangeListener listener : changeListeners) {
167	listener.containersChanged(delta);	301	listener.containersChanged(delta);
Lines 189-194 Link Here
189	delta.add(new TaskContainerDelta(query, TaskContainerDelta.Kind.CHANGED));	323	delta.add(new TaskContainerDelta(query, TaskContainerDelta.Kind.CHANGED));
190	}	324	}
191	}	325	}
		326
		327	for (OrphanedTasksContainer orphans : repositoryOrphansMap.values()) {
		328	if (orphans.getRepositoryUrl().equals(oldRepositoryUrl)) {
		329	repositoryOrphansMap.remove(oldRepositoryUrl);
		330	//categories.remove(orphans.getHandleIdentifier());
		331	orphans.setRepositoryUrl(newRepositoryUrl);
		332	repositoryOrphansMap.put(newRepositoryUrl, orphans);
		333	//categories.put(orphans.getHandleIdentifier(), orphans);
		334	delta.add(new TaskContainerDelta(orphans, TaskContainerDelta.Kind.CHANGED));
		335	}
		336	}
192	for (ITaskListChangeListener listener : changeListeners) {	337	for (ITaskListChangeListener listener : changeListeners) {
193	listener.containersChanged(delta);	338	listener.containersChanged(delta);
194	}	339	}
Lines 209-215 Link Here
209	}	354	}
210		355
211	public void removeFromCategory(TaskCategory category, AbstractTask task) {	356	public void removeFromCategory(TaskCategory category, AbstractTask task) {
212	moveToContainer(task, archiveContainer);	357	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
		358	delta.add(new TaskContainerDelta(category, TaskContainerDelta.Kind.CHANGED));
		359	category.internalRemoveChild(task);
		360	addOrphan(task, delta);
		361	for (ITaskListChangeListener listener : changeListeners) {
		362	listener.containersChanged(delta);
		363	}
		364	//moveToContainer(task, null);
213	}	365	}
214		366
215	/**	367	/**
Lines 218-228 Link Here
218	* @since 2.1	370	* @since 2.1
219	*/	371	*/
220	public void removeFromQuery(AbstractRepositoryQuery query, AbstractTask task) {	372	public void removeFromQuery(AbstractRepositoryQuery query, AbstractTask task) {
		373
		374	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
		375	delta.add(new TaskContainerDelta(task, TaskContainerDelta.Kind.CHANGED));
		376
221	query.internalRemoveChild(task);	377	query.internalRemoveChild(task);
222	if (task.getParentContainers().size() == 0 && task.getLastReadTimeStamp() != null) {	378	addOrphan(task, delta);
223	task.addParentContainer(archiveContainer);	379
224	archiveContainer.internalAddChild(task);	380	for (ITaskListChangeListener listener : changeListeners) {
		381	listener.containersChanged(delta);
225	}	382	}
		383
		384	// if (task.getParentContainers().size() == 0 && task.getLastReadTimeStamp() != null) {
		385	// task.addParentContainer(archiveContainer);
		386	// archiveContainer.internalAddChild(task);
		387	// }
226	}	388	}
227		389
228	public void renameTask(AbstractTask task, String description) {	390	public void renameTask(AbstractTask task, String description) {
Lines 242-248 Link Here
242	public void renameContainer(AbstractTaskContainer container, String newDescription) {	404	public void renameContainer(AbstractTaskContainer container, String newDescription) {
243	if (container instanceof AbstractTask) {	405	if (container instanceof AbstractTask) {
244	return;	406	return;
245	} else if (!(container instanceof TaskArchive) && !(container instanceof UnfiledCategory)) {	407	} else if (!(container instanceof TaskArchive) && !(container instanceof OrphanedTasksContainer)) {
246	if (queries.remove(container.getHandleIdentifier()) != null) {	408	if (queries.remove(container.getHandleIdentifier()) != null) {
247	if (container instanceof AbstractTaskCategory) {	409	if (container instanceof AbstractTaskCategory) {
248	((AbstractTaskCategory) container).setHandleIdentifier(newDescription);	410	((AbstractTaskCategory) container).setHandleIdentifier(newDescription);
Lines 284-291 Link Here
284	* deletion of subtasks)	446	* deletion of subtasks)
285	*/	447	*/
286	public void deleteTask(AbstractTask task) {	448	public void deleteTask(AbstractTask task) {
287	archiveContainer.internalRemoveChild(task);
288	defaultCategory.internalRemoveChild(task);
289		449
290	for (AbstractTaskContainer container : task.getParentContainers()) {	450	for (AbstractTaskContainer container : task.getParentContainers()) {
291	container.internalRemoveChild(task);	451	container.internalRemoveChild(task);
Lines 294-299 Link Here
294	tasks.remove(task.getHandleIdentifier());	454	tasks.remove(task.getHandleIdentifier());
295		455
296	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();	456	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
		457	removeOrphan(task, delta);
297	delta.add(new TaskContainerDelta(task, TaskContainerDelta.Kind.REMOVED));	458	delta.add(new TaskContainerDelta(task, TaskContainerDelta.Kind.REMOVED));
298	for (ITaskListChangeListener listener : changeListeners) {	459	for (ITaskListChangeListener listener : changeListeners) {
299	listener.containersChanged(delta);	460	listener.containersChanged(delta);
Lines 301-313 Link Here
301	}	462	}
302		463
303	public void deleteCategory(AbstractTaskCategory category) {	464	public void deleteCategory(AbstractTaskCategory category) {
		465	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
		466
		467	categories.remove(category.getHandleIdentifier());
304	for (AbstractTask task : category.getChildren()) {	468	for (AbstractTask task : category.getChildren()) {
305	defaultCategory.internalAddChild(task);	469	addOrphan(task, delta);
306	}	470	}
307	categories.remove(category.getHandleIdentifier());
308		471
309	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
310	delta.add(new TaskContainerDelta(defaultCategory, TaskContainerDelta.Kind.CHANGED));
311	delta.add(new TaskContainerDelta(category, TaskContainerDelta.Kind.REMOVED));	472	delta.add(new TaskContainerDelta(category, TaskContainerDelta.Kind.REMOVED));
312		473
313	for (ITaskListChangeListener listener : changeListeners) {	474	for (ITaskListChangeListener listener : changeListeners) {
Lines 316-331 Link Here
316	}	477	}
317		478
318	public void deleteQuery(AbstractRepositoryQuery query) {	479	public void deleteQuery(AbstractRepositoryQuery query) {
319	queries.remove(query.getHandleIdentifier());	480	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
320		481
		482	queries.remove(query.getHandleIdentifier());
321	for (AbstractTask task : query.getChildren()) {	483	for (AbstractTask task : query.getChildren()) {
322	if (task.getParentContainers().size() == 0 && task.getLastReadTimeStamp() != null) {	484	addOrphan(task, delta);
323	task.addParentContainer(archiveContainer);
324	archiveContainer.internalAddChild(task);
325	}
326	}	485	}
327		486
328	Set<TaskContainerDelta> delta = new HashSet<TaskContainerDelta>();
329	delta.add(new TaskContainerDelta(query, TaskContainerDelta.Kind.REMOVED));	487	delta.add(new TaskContainerDelta(query, TaskContainerDelta.Kind.REMOVED));
330	for (ITaskListChangeListener listener : changeListeners) {	488	for (ITaskListChangeListener listener : changeListeners) {
331	listener.containersChanged(delta);	489	listener.containersChanged(delta);
Lines 357-377 Link Here
357	categories.put(category.getHandleIdentifier(), category);	515	categories.put(category.getHandleIdentifier(), category);
358	}	516	}
359		517
		518	/**
		519	* @deprecated
		520	*/
360	public void internalAddTask(AbstractTask task, AbstractTaskCategory container) {	521	public void internalAddTask(AbstractTask task, AbstractTaskCategory container) {
		522	internalAddTask(task, (AbstractTaskContainer) container);
		523	// //tasks.put(task.getHandleIdentifier(), task);
		524	// if (container != null) {
		525	// tasks.put(task.getHandleIdentifier(), task);
		526	// container.internalAddChild(task);
		527	// if (container instanceof TaskCategory \|\| container instanceof OrphanedTasksContainer) {
		528	// task.addParentContainer(container);
		529	// }
		530	// } else {
		531	// if (task.getLastReadTimeStamp() != null) {
		532	// // any unread task (hit) that is an orphan is discarded
		533	// tasks.put(task.getHandleIdentifier(), task);
		534	// addOrphan(task, null);
		535	// }
		536	//// defaultCategory.internalAddChild(task);
		537	//// task.addParentContainer(defaultCategory);
		538	// }
		539	}
		540
		541	public void internalAddTask(AbstractTask task, AbstractTaskContainer container) {
361	tasks.put(task.getHandleIdentifier(), task);	542	tasks.put(task.getHandleIdentifier(), task);
362	if (container != null) {	543	if (container != null) {
363	container.internalAddChild(task);	544	container.internalAddChild(task);
364	if (container instanceof TaskCategory \|\| container instanceof UnfiledCategory) {	545	if (container instanceof TaskCategory \|\| container instanceof OrphanedTasksContainer) {
365	task.addParentContainer(container);	546	task.addParentContainer(container);
366	}	547	}
367	} else {	548	} else {
368	defaultCategory.internalAddChild(task);	549	//if (task.getLastReadTimeStamp() != null) {
369	task.addParentContainer(defaultCategory);	550	// any unread task (hit) that is an orphan is discarded
		551	addOrphan(task, null);
		552	//}
		553	// defaultCategory.internalAddChild(task);
		554	// task.addParentContainer(defaultCategory);
370	}	555	}
371	}	556	}
372		557
		558	/**
		559	* @API-3.0 remove
		560	*/
373	public void internalAddRootTask(AbstractTask task) {	561	public void internalAddRootTask(AbstractTask task) {
374	internalAddTask(task, defaultCategory);	562	internalAddTask(task, null);
375	}	563	}
376		564
377	public void internalAddQuery(AbstractRepositoryQuery query) {	565	public void internalAddQuery(AbstractRepositoryQuery query) {
Lines 412-418 Link Here
412	public List<AbstractTaskCategory> getUserCategories() {	600	public List<AbstractTaskCategory> getUserCategories() {
413	List<AbstractTaskCategory> included = new ArrayList<AbstractTaskCategory>();	601	List<AbstractTaskCategory> included = new ArrayList<AbstractTaskCategory>();
414	for (AbstractTaskCategory category : categories.values()) {	602	for (AbstractTaskCategory category : categories.values()) {
415	if (!(category instanceof TaskArchive)) {	603	if (!(category instanceof OrphanedTasksContainer)) {
416	included.add(category);	604	included.add(category);
417	}	605	}
418	}	606	}
Lines 426-436 Link Here
426		614
427	public Set<AbstractTaskContainer> getRootElements() {	615	public Set<AbstractTaskContainer> getRootElements() {
428	Set<AbstractTaskContainer> roots = new HashSet<AbstractTaskContainer>();	616	Set<AbstractTaskContainer> roots = new HashSet<AbstractTaskContainer>();
429	roots.add(defaultCategory);	617	//roots.add(defaultCategory);
430	for (AbstractTaskCategory cat : categories.values())	618	for (AbstractTaskCategory cat : categories.values())
431	roots.add(cat);	619	roots.add(cat);
432	for (AbstractRepositoryQuery query : queries.values())	620	for (AbstractRepositoryQuery query : queries.values())
433	roots.add(query);	621	roots.add(query);
		622	for (OrphanedTasksContainer orphanContainer : repositoryOrphansMap.values())
		623	roots.add(orphanContainer);
434	return roots;	624	return roots;
435	}	625	}
436		626
Lines 460-469 Link Here
460	return null;	650	return null;
461	}	651	}
462		652
		653	private AbstractTaskCategory getCategoryForHandle(String handle) {
		654	if (handle == null) {
		655	return null;
		656	}
		657	for (AbstractTaskCategory category : categories.values()) {
		658	if (!(category instanceof OrphanedTasksContainer) && category.contains(handle)) {
		659	return category;
		660	}
		661	}
		662	return null;
		663	}
		664
463	public boolean isEmpty() {	665	public boolean isEmpty() {
464	boolean archiveIsEmpty = getCategories().size() == 2 && getCategories().contains(archiveContainer)	666	// boolean archiveIsEmpty = getCategories().size() == 2 && getCategories().contains(archiveContainer)
465	&& getCategories().contains(defaultCategory) && archiveContainer.getChildren().isEmpty();	667	// && getCategories().contains(defaultCategory) && archiveContainer.getChildren().isEmpty();
466	return getAllTasks().size() == 0 && archiveIsEmpty && getQueries().size() == 0;	668	return getAllTasks().size() == 0 /&& archiveIsEmpty/&& getQueries().size() == 0
		669	&& getCategories().size() == 0;
467	}	670	}
468		671
469	/**	672	/**
Lines 536-545 Link Here
536	return null;	739	return null;
537	}	740	}
538		741
		742	/**
		743	* @deprecated
		744	*/
539	public AbstractTaskCategory getDefaultCategory() {	745	public AbstractTaskCategory getDefaultCategory() {
540	return defaultCategory;	746	return getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL);
541	}	747	}
542		748
		749	/**
		750	* @deprecated
		751	*/
543	public TaskArchive getArchiveContainer() {	752	public TaskArchive getArchiveContainer() {
544	return archiveContainer;	753	return archiveContainer;
545	}	754	}
Lines 660-666 Link Here
660	if (containers == null) {	869	if (containers == null) {
661	delta = new HashSet<TaskContainerDelta>();	870	delta = new HashSet<TaskContainerDelta>();
662	delta.add(new TaskContainerDelta(null, TaskContainerDelta.Kind.ROOT));	871	delta.add(new TaskContainerDelta(null, TaskContainerDelta.Kind.ROOT));
663	} else {	872	} else {
664	delta = new HashSet<TaskContainerDelta>();	873	delta = new HashSet<TaskContainerDelta>();
665	for (AbstractTaskContainer abstractTaskContainer : containers) {	874	for (AbstractTaskContainer abstractTaskContainer : containers) {
666	delta.add(new TaskContainerDelta(abstractTaskContainer, TaskContainerDelta.Kind.CHANGED));	875	delta.add(new TaskContainerDelta(abstractTaskContainer, TaskContainerDelta.Kind.CHANGED));
Lines 710-717 Link Here
710	int max = 0;	919	int max = 0;
711	for (AbstractTask task : tasks) {	920	for (AbstractTask task : tasks) {
712	if (task instanceof LocalTask) {	921	if (task instanceof LocalTask) {
713	String string = task.getHandleIdentifier().substring(task.getHandleIdentifier().lastIndexOf('-') + 1,	922	String string = task.getHandleIdentifier().substring(
714	task.getHandleIdentifier().length());	923	task.getHandleIdentifier().lastIndexOf('-') + 1, task.getHandleIdentifier().length());
715	try {	924	try {
716	ihandle = Integer.parseInt(string);	925	ihandle = Integer.parseInt(string);
717	} catch (NumberFormatException nfe) {	926	} catch (NumberFormatException nfe) {
Lines 743-754 Link Here
743	task.addParentContainer(legacyCategory);	952	task.addParentContainer(legacyCategory);
744	legacyCategory.internalAddChild(task);	953	legacyCategory.internalAddChild(task);
745	} else {	954	} else {
746	this.internalAddTask(task, this.getArchiveContainer());	955	this.internalAddTask(task, null);
747	}	956	}
748		957
749	this.setActive(task, task.isActive());	958	this.setActive(task, task.isActive());
750	}	959	}
751		960
		961	/**
		962	* Internal API
		963	*/
		964	public void addOrphanContainer(OrphanedTasksContainer orphanedTasksContainer) {
		965	repositoryOrphansMap.put(orphanedTasksContainer.getRepositoryUrl(), orphanedTasksContainer);
		966	}
		967
		968	/**
		969	* Internal API
		970	*/
		971	public void removeOrphanContainer(String url) {
		972	if (url != null && !url.equals(LocalRepositoryConnector.REPOSITORY_URL)) {
		973	repositoryOrphansMap.remove(url);
		974	}
		975	}
		976
752	// /**	977	// /**
753	// * Orphaned hits arise when no query in the tasklist references a hit in the	978	// * Orphaned hits arise when no query in the tasklist references a hit in the
754	// * master list maintained by the tasklist. Orphaned hits don't span	979	// * master list maintained by the tasklist. Orphaned hits don't span

Lines 28-34 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/core/LocalTask.java (-2 / +2 lines)
28		28
29	@Override	29	@Override
30	public String getConnectorKind() {	30	public String getConnectorKind() {
31	return LocalRepositoryConnector.REPOSITORY_KIND;	31	return LocalRepositoryConnector.CONNECTOR_KIND;
32	}	32	}
33		33
34	@Override	34	@Override
Lines 43-49 Link Here
43		43
44	@Override	44	@Override
45	public String getOwner() {	45	public String getOwner() {
46	return LocalRepositoryConnector.REPOSITORY_KIND;	46	return LocalRepositoryConnector.CONNECTOR_KIND;
47	}	47	}
48		48
49	@Override	49	@Override

Lines 29-35 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/core/LocalRepositoryConnector.java (-2 / +2 lines)
29		29
30	public static final String REPOSITORY_LABEL = "Local Tasks";	30	public static final String REPOSITORY_LABEL = "Local Tasks";
31		31
32	public static final String REPOSITORY_KIND = "local";	32	public static final String CONNECTOR_KIND = "local";
33		33
34	public static final String REPOSITORY_URL = "local";	34	public static final String REPOSITORY_URL = "local";
35		35
Lines 70-76 Link Here
70		70
71	@Override	71	@Override
72	public String getConnectorKind() {	72	public String getConnectorKind() {
73	return REPOSITORY_KIND;	73	return CONNECTOR_KIND;
74	}	74	}
75		75
76	@Override	76	@Override

Lines 8-14 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/core/TaskArchive.java (-1 / +33 lines)
8		8
9	package org.eclipse.mylyn.internal.tasks.core;	9	package org.eclipse.mylyn.internal.tasks.core;
10		10
		11	import java.util.HashSet;
		12	import java.util.Set;
		13
		14	import org.eclipse.mylyn.tasks.core.AbstractTask;
11	import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;	15	import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;
		16	import org.eclipse.mylyn.tasks.core.TaskList;
12	import org.eclipse.mylyn.tasks.core.AbstractTask.PriorityLevel;	17	import org.eclipse.mylyn.tasks.core.AbstractTask.PriorityLevel;
13		18
14	/**	19	/**
Lines 20-27 Link Here
20		25
21	public static final String LABEL_ARCHIVE = "Archive (all tasks)";	26	public static final String LABEL_ARCHIVE = "Archive (all tasks)";
22		27
23	public TaskArchive() {	28	public TaskList taskList;
		29
		30	public TaskArchive(TaskList taskList) {
24	super(HANDLE);	31	super(HANDLE);
		32	this.taskList = taskList;
25	}	33	}
26		34
27	@Override	35	@Override
Lines 43-46 Link Here
43	public boolean isUserDefined() {	51	public boolean isUserDefined() {
44	return false;	52	return false;
45	}	53	}
		54
		55	@Override
		56	public Set<AbstractTask> getChildren() {
		57	Set<AbstractTask> children = new HashSet<AbstractTask>();
		58	for (OrphanedTasksContainer container : taskList.getOrphanContainers()) {
		59	children.addAll(container.getChildren());
		60	}
		61	return children;
		62	}
		63
		64	@Override
		65	public Set<AbstractTask> getChildrenInternal() {
		66	return getChildren();
		67	}
		68
		69	@Override
		70	public void internalAddChild(AbstractTask task) {
		71	// ignore
		72	}
		73
		74	@Override
		75	public void internalRemoveChild(AbstractTask task) {
		76	// ignore
		77	}
46	}	78	}

Added Link Here

(-).refactorings/2007/12/49/refactorings.history (+3 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<session version="1.0"> <refactoring comment="Copy 1 elements(s) to 'org.eclipse.mylyn.tasks.core/src/org.eclipse.mylyn.internal.tasks.core' - Original project: 'org.eclipse.mylyn.tasks.core' - Destination element: 'org.eclipse.mylyn.tasks.core/src/org.eclipse.mylyn.internal.tasks.core' - Original element: 'org.eclipse.mylyn.internal.tasks.core.UnfiledCategory.java'" description="Copy compilation unit" destination="/src<org.eclipse.mylyn.internal.tasks.core" element1="/src<org.eclipse.mylyn.internal.tasks.core{UnfiledCategory.java" files="0" flags="589830" folders="0" id="org.eclipse.jdt.ui.copy" policy="org.eclipse.jdt.ui.copyResources" stamp="1196888061065" units="1" version="1.0"/> <refactoring comment="Rename type 'org.eclipse.mylyn.internal.tasks.core.OrphanedTasks' to 'OrphanedTasksContainer' - Original project: 'org.eclipse.mylyn.tasks.core' - Original element: 'org.eclipse.mylyn.internal.tasks.core.OrphanedTasks' - Renamed element: 'org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer' - Update references to refactored element - Rename similarly named elements - Update fully qualified names in '.xml, .xsd' files - Update textual occurrences in comments and strings" description="Rename type 'OrphanedTasks'" flags="589830" id="org.eclipse.jdt.ui.rename.type" input="/src<org.eclipse.mylyn.internal.tasks.core{OrphanedTasks.java[OrphanedTasks" matchStrategy="1" name="OrphanedTasksContainer" patterns=".xml, .xsd" qualified="true" references="true" similarDeclarations="true" stamp="1196889544235" textual="false" version="1.0"/> <refactoring comment="Rename field 'orphanedTaskContainers' in 'org.eclipse.mylyn.tasks.core.TaskList' to 'repositoryOrphansMap' - Original project: 'org.eclipse.mylyn.tasks.core' - Original element: 'org.eclipse.mylyn.tasks.core.TaskList.orphanedTaskContainers' - Renamed element: 'org.eclipse.mylyn.tasks.core.TaskList.repositoryOrphansMap' - Update references to refactored element - Update textual occurrences in comments and strings" delegate="false" deprecate="false" description="Rename field 'orphanedTaskContainers'" flags="589826" getter="false" id="org.eclipse.jdt.ui.rename.field" input="/src<org.eclipse.mylyn.tasks.core{TaskList.java[TaskList^orphanedTaskContainers" name="repositoryOrphansMap" references="true" setter="false" stamp="1196902163343" textual="false" version="1.0"/> <refactoring comment="Rename method 'org.eclipse.mylyn.tasks.core.TaskList.getOrphanedContainer(...)' to 'getOrphanContainer' - Original project: 'org.eclipse.mylyn.tasks.core' - Original element: 'org.eclipse.mylyn.tasks.core.TaskList.getOrphanedContainer(...)' - Renamed element: 'org.eclipse.mylyn.tasks.core.TaskList.getOrphanContainer(...)' - Update references to refactored element" delegate="false" deprecate="false" description="Rename method 'getOrphanedContainer'" flags="589830" id="org.eclipse.jdt.ui.rename.method" input="/src<org.eclipse.mylyn.tasks.core{TaskList.java[TaskList~getOrphanedContainer~QString;" name="getOrphanContainer" references="true" stamp="1196916697413" version="1.0"/> <refactoring comment="Rename field 'REPOSITORY_KIND' in 'org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector' to 'CONNECTOR_KIND' - Original project: 'org.eclipse.mylyn.tasks.core' - Original element: 'org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector.REPOSITORY_KIND' - Renamed element: 'org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector.CONNECTOR_KIND' - Update references to refactored element - Update textual occurrences in comments and strings" delegate="false" deprecate="false" description="Rename field 'REPOSITORY_KIND'" flags="589830" getter="false" id="org.eclipse.jdt.ui.rename.field" input="/src<org.eclipse.mylyn.internal.tasks.core{LocalRepositoryConnector.java[LocalRepositoryConnector^REPOSITORY_KIND" name="CONNECTOR_KIND" references="true" setter="false" stamp="1196923680591" textual="false" version="1.0"/>
3	</session>

Added Link Here

(-).refactorings/2007/12/49/refactorings.index (+5 lines)
1	1196888061065 Copy compilation unit
2	1196889544235 Rename type 'OrphanedTasks'
3	1196902163343 Rename field 'orphanedTaskContainers'
4	1196916697413 Rename method 'getOrphanedContainer'
5	1196923680591 Rename field 'REPOSITORY_KIND'




/*******************************************************************************
 * Copyright (c) 2004, 2007 Mylyn project committers and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.core;

import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;
import org.eclipse.mylyn.tasks.core.AbstractTask.PriorityLevel;

/**
 * Holds orphaned or uncategorized tasks for a given repository
 * 
 * @author Rob Elves
 */
public class OrphanedTasksContainer extends AbstractTaskCategory {

	public static final String LABEL = "Uncategorized";

	public static final String HANDLE = "orphans";

	private String repositoryUrl;

	private String connectorKind;

	public OrphanedTasksContainer(String connectorKind, String repositoryUrl) {
		super(repositoryUrl + "-" + HANDLE);
		this.repositoryUrl = repositoryUrl;
		this.connectorKind = connectorKind;
	}

	@Override
	public String getPriority() {
		return PriorityLevel.P1.toString();
	}

	@Override
	public String getSummary() {
		return "Archive: " + getRepositoryUrl();
	}

	@Override
	public boolean isUserDefined() {
		return false;
	}

	public String getRepositoryUrl() {
		return repositoryUrl;
	}

	public String getConnectorKind() {
		return connectorKind;
	}

	/**
	 * setting will also refactor handle
	 */
	public void setRepositoryUrl(String repositoryUrl) {
		this.repositoryUrl = repositoryUrl;
		this.setHandleIdentifier(repositoryUrl + "-" + HANDLE);
	}

	@Override
	public boolean contains(String handle) {
		for (AbstractTask child : getChildrenInternal()) {
			if (child.getHandleIdentifier().equals(handle)) {
				return true;
			}
		}
		return false;
	}
}

Lines 11-23 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/TaskListTableSorter.java (-10 / +13 lines)
11	import org.eclipse.jface.dialogs.MessageDialog;	11	import org.eclipse.jface.dialogs.MessageDialog;
12	import org.eclipse.jface.viewers.Viewer;	12	import org.eclipse.jface.viewers.Viewer;
13	import org.eclipse.jface.viewers.ViewerSorter;	13	import org.eclipse.jface.viewers.ViewerSorter;
		14	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
		15	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
14	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;	16	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
15	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;
16	import org.eclipse.mylyn.internal.tasks.core.UnfiledCategory;
17	import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;	17	import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;
18	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;	18	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
19	import org.eclipse.mylyn.tasks.core.AbstractTask;	19	import org.eclipse.mylyn.tasks.core.AbstractTask;
20	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;	20	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
		21	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
21	import org.eclipse.ui.PlatformUI;	22	import org.eclipse.ui.PlatformUI;
22		23
23	/**	24	/**
Lines 74-88 Link Here
74	return 1;	75	return 1;
75	}	76	}
76		77
77	if (o1 instanceof UnfiledCategory && o2 instanceof AbstractTaskContainer) {	78	OrphanedTasksContainer localArchive = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
		79	LocalRepositoryConnector.REPOSITORY_URL);
		80	if (o1 == localArchive && o2 instanceof AbstractTaskContainer) {
78	return -1;	81	return -1;
79	} else if (o1 instanceof AbstractTaskContainer && o2 instanceof UnfiledCategory) {	82	} else if (o1 instanceof AbstractTaskContainer && o2 == localArchive) {
80	return 1;	83	return 1;
81	}	84	}
82		85
83	if (o1 instanceof AbstractTaskContainer && o2 instanceof TaskArchive) {	86	if (o1 instanceof AbstractTaskContainer && o2 instanceof OrphanedTasksContainer) {
84	return -1;	87	return -1;
85	} else if (o2 instanceof AbstractTaskContainer && o1 instanceof TaskArchive) {	88	} else if (o2 instanceof AbstractTaskContainer && o1 instanceof OrphanedTasksContainer) {
86	return 1;	89	return 1;
87	}	90	}
88		91
Lines 150-156 Link Here
150		153
151	/**	154	/**
152	* Determine the sort order of two tasks by id/summary	155	* Determine the sort order of two tasks by id/summary
153	*	156	*
154	* @param element1	157	* @param element1
155	* @param element2	158	* @param element2
156	* @return sort order	159	* @return sort order
Lines 162-168 Link Here
162		165
163	/**	166	/**
164	* Return a sortable string in the format "key: summary"	167	* Return a sortable string in the format "key: summary"
165	*	168	*
166	* @param element	169	* @param element
167	* @return sortable string	170	* @return sortable string
168	* @deprecated Use getSortableFromElement()	171	* @deprecated Use getSortableFromElement()
Lines 181-192 Link Here
181		184
182	/**	185	/**
183	* Return a array of values to pass to taskKeyComparator.compare() for sorting	186	* Return a array of values to pass to taskKeyComparator.compare() for sorting
184	*	187	*
185	* @param element	188	* @param element
186	* @return String array[component, taskId, summary]	189	* @return String array[component, taskId, summary]
187	*/	190	*/
188	public static String[] getSortableFromElement(AbstractTaskContainer element) {	191	public static String[] getSortableFromElement(AbstractTaskContainer element) {
189	final String a[] = new String[] {"", null, element.getSummary()};	192	final String a[] = new String[] { "", null, element.getSummary() };
190		193
191	if (element instanceof AbstractTask) {	194	if (element instanceof AbstractTask) {
192	AbstractTask task1 = (AbstractTask) element;	195	AbstractTask task1 = (AbstractTask) element;




									refreshJob.refresh();
									break;
								default:
									if (taskContainerDelta.getContainer() == null) {
											TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory())) {
										refreshJob.refresh();
									} else {
										refreshJob.refreshTask(taskContainerDelta.getContainer());

					subMenu = new MenuManager("New", ID_MENU_NEW);
					manager.add(subMenu);
				}

				subMenu.add(new Separator(ID_SEPARATOR_NEW_REPOSITORY));
				subMenu.add(action);
				subMenu.add(new Separator(ID_SEPARATOR_NEW_LOCAL));

		manager.add(new Separator());

		addAction(copyDetailsAction, manager, element);
		if (task != null && task.isLocal()) {
//			addAction(cloneThisBugAction, manager, element);
			addAction(removeFromCategoryAction, manager, element);
		}

			refreshJob.forceRefresh();
		}
	}

	public void refresh() {
		refreshJob.forceRefresh();
//		if (expand) {

			Set<AbstractTaskContainer> containers = new HashSet<AbstractTaskContainer>(
					TasksUiPlugin.getTaskListManager().getTaskList().getQueriesForHandle(task.getHandleIdentifier()));
			containers.addAll(task.getParentContainers());
			containers.add(TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(task.getRepositoryUrl()));
//			containers.add(TasksUiPlugin.getTaskListManager().getTaskList().getArchiveContainer());
//			containers.add(TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
			for (AbstractTaskContainer container : containers) {
				refreshJob.refreshTask(container);
			}




import org.eclipse.jface.viewers.IColorProvider;
import org.eclipse.jface.viewers.IFontProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
import org.eclipse.mylyn.internal.tasks.core.Person;
import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.TaskActivityManager;


	private CompositeImageDescriptor getImageDescriptor(Object object) {
		CompositeImageDescriptor compositeDescriptor = new CompositeImageDescriptor();
		if (object instanceof TaskArchive || object instanceof UnfiledCategory
				|| object instanceof OrphanedTasksContainer) {
			compositeDescriptor.icon = TasksUiImages.CATEGORY_ARCHIVE;
			return compositeDescriptor;
		} else if (object instanceof TaskCategory || object instanceof UnfiledCategory) {

		} else if (object instanceof TaskGroup) {
			TaskGroup element = (TaskGroup) object;
			return element.getSummary();// + " / " + element.getChildren().size();
		} else if (object instanceof OrphanedTasksContainer) {

			OrphanedTasksContainer container = (OrphanedTasksContainer) object;

//			OrphanedTasksContainer localArchive = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
//					LocalRepositoryConnector.REPOSITORY_URL);
//			if (container == localArchive) {
//				return "Local Tasks";
//			}

			String result = container.getSummary();
			TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(
					container.getConnectorKind(), container.getRepositoryUrl());
			if (repository != null) {
				result = "Archive: " + repository.getRepositoryLabel();
			}

			return result;

		} else if (object instanceof AbstractTaskContainer) {
			AbstractTaskContainer element = (AbstractTaskContainer) object;
			return element.getSummary();

Lines 26-31 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/TaskListDropAdapter.java (-7 / +20 lines)
26	import org.eclipse.jface.viewers.ViewerDropAdapter;	26	import org.eclipse.jface.viewers.ViewerDropAdapter;
27	import org.eclipse.mylyn.context.core.ContextCorePlugin;	27	import org.eclipse.mylyn.context.core.ContextCorePlugin;
28	import org.eclipse.mylyn.internal.context.core.InteractionContext;	28	import org.eclipse.mylyn.internal.context.core.InteractionContext;
		29	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
		30	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
29	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;	31	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
30	import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;	32	import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;
31	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;	33	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
Lines 162-182 Link Here
162		164
163	for (AbstractTask task : tasksToMove) {	165	for (AbstractTask task : tasksToMove) {
164	if (currentTarget instanceof UnfiledCategory) {	166	if (currentTarget instanceof UnfiledCategory) {
165	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task, (UnfiledCategory) currentTarget);	167	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(task, (UnfiledCategory) currentTarget);
166	} else if (currentTarget instanceof TaskCategory) {	168	} else if (currentTarget instanceof TaskCategory) {
167	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task, (TaskCategory) currentTarget);	169	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(task, (TaskCategory) currentTarget);
		170	} else if (currentTarget instanceof OrphanedTasksContainer) {
		171	if (((OrphanedTasksContainer) currentTarget).getRepositoryUrl().equals(task.getRepositoryUrl())) {
		172	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(task,
		173	(AbstractTaskCategory) currentTarget);
		174	}
168	} else if (currentTarget instanceof AbstractTask) {	175	} else if (currentTarget instanceof AbstractTask) {
169	AbstractTask targetTask = (AbstractTask) currentTarget;	176	AbstractTask targetTask = (AbstractTask) currentTarget;
170	AbstractTaskCategory targetCategory = null;	177	AbstractTaskCategory targetCategory = null;
171	// TODO: just look for categories?	178	// TODO: just look for categories?
172	if (targetTask.getParentContainers().size() > 0) {	179	if (targetTask.getParentContainers().size() > 0) {
173	AbstractTaskContainer container = targetTask.getParentContainers().iterator().next();	180	AbstractTaskContainer container = targetTask.getParentContainers().iterator().next();
174	if (container instanceof TaskCategory \|\| container instanceof UnfiledCategory) {	181	if (container instanceof TaskCategory) {
175	targetCategory = (AbstractTaskCategory) container;	182	targetCategory = (AbstractTaskCategory) container;
		183	} else if (container instanceof OrphanedTasksContainer) {
		184	if (((OrphanedTasksContainer) container).getRepositoryUrl().equals(task.getRepositoryUrl())) {
		185	targetCategory = (AbstractTaskCategory) container;
		186	}
176	}	187	}
177	}	188	}
178	if (targetCategory != null) {	189	if (targetCategory != null) {
179	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task, targetCategory);	190	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(task, targetCategory);
180	}	191	}
181	} else if (currentTarget instanceof ScheduledTaskContainer) {	192	} else if (currentTarget instanceof ScheduledTaskContainer) {
182	ScheduledTaskContainer container = (ScheduledTaskContainer) currentTarget;	193	ScheduledTaskContainer container = (ScheduledTaskContainer) currentTarget;
Lines 185-192 Link Here
185	TaskActivityUtil.snapEndOfWorkDay(newSchedule);	196	TaskActivityUtil.snapEndOfWorkDay(newSchedule);
186	TasksUiPlugin.getTaskActivityManager().setScheduledFor(task, newSchedule.getTime());	197	TasksUiPlugin.getTaskActivityManager().setScheduledFor(task, newSchedule.getTime());
187	} else if (currentTarget == null) {	198	} else if (currentTarget == null) {
188	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(newTask,	199	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(
189	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());	200	newTask,
		201	TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
		202	LocalRepositoryConnector.REPOSITORY_URL));
190	}	203	}
191	}	204	}
192		205
Lines 307-313 Link Here
307	// handle all files	320	// handle all files
308	return true;	321	return true;
309	} else if (TaskTransfer.getInstance().isSupportedType(currentTransfer)) {	322	} else if (TaskTransfer.getInstance().isSupportedType(currentTransfer)) {
310	if (getCurrentTarget() instanceof TaskCategory \|\| getCurrentTarget() instanceof UnfiledCategory	323	if (getCurrentTarget() instanceof TaskCategory \|\| getCurrentTarget() instanceof OrphanedTasksContainer
311	\|\| getCurrentTarget() instanceof ScheduledTaskContainer) {	324	\|\| getCurrentTarget() instanceof ScheduledTaskContainer) {
312	return true;	325	return true;
313	} else if (getCurrentTarget() instanceof AbstractTaskContainer	326	} else if (getCurrentTarget() instanceof AbstractTaskContainer

Lines 11-17 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/CustomTaskListDecorationDrawer.java (-2 / +2 lines)
11	import java.util.Set;	11	import java.util.Set;
12		12
13	import org.eclipse.mylyn.context.core.ContextCorePlugin;	13	import org.eclipse.mylyn.context.core.ContextCorePlugin;
14	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;	14	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
15	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;	15	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
16	import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;	16	import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;
17	import org.eclipse.mylyn.internal.tasks.ui.TasksUiPreferenceConstants;	17	import org.eclipse.mylyn.internal.tasks.ui.TasksUiPreferenceConstants;
Lines 184-190 Link Here
184	}	184	}
185		185
186	private boolean hideDecorationOnContainer(AbstractTaskContainer element, TreeItem treeItem) {	186	private boolean hideDecorationOnContainer(AbstractTaskContainer element, TreeItem treeItem) {
187	if (element instanceof TaskArchive) {	187	if (element instanceof OrphanedTasksContainer) {
188	return true;	188	return true;
189	} else if (!taskListView.isFocusedMode()) {	189	} else if (!taskListView.isFocusedMode()) {
190	return false;	190	return false;

Lines 154-160 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskPlanningEditor.java (-1 / +3 lines)
154	if (PlatformUI.getWorkbench() != null && !PlatformUI.getWorkbench().isClosing()) {	154	if (PlatformUI.getWorkbench() != null && !PlatformUI.getWorkbench().isClosing()) {
155	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {	155	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
156	public void run() {	156	public void run() {
157	updateTaskData(updateTask);	157	if (summaryEditor != null && summaryEditor.getTextWidget() != null) {
		158	updateTaskData(updateTask);
		159	}
158	}	160	}
159	});	161	});
160	}	162	}




import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;


					TreeItem item = this.view.getViewer().getTree().getSelection()[0];
					Set<AbstractTaskContainer> parentContainers = task.getParentContainers();

					if (item.getParentItem() != null && item.getParent().getData() instanceof TaskCategory) {
						TaskCategory category = (TaskCategory) item.getParentItem().getData();
						TasksUiPlugin.getTaskListManager().getTaskList().removeFromCategory(category, task);
						TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task,
								TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
					} else if (!task.isLocal() && parentContainers.contains(TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory())) {
						TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task, TasksUiPlugin.getTaskListManager().getTaskList().getArchiveContainer());
					} else if (parentContainers.contains(TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory())) {
						MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), 
								LABEL, "Can not remove from the default category, move to another category instead.");
					} else {
						TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task,
								TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
					}
//						TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task,
//								TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
					else if (!parentContainers.isEmpty() && parentContainers.iterator().next() instanceof TaskCategory) {
						TasksUiPlugin.getTaskListManager().getTaskList().removeFromCategory(
								(TaskCategory) parentContainers.iterator().next(), task);
						//TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task, null);
					}/* else if (parentContainers.contains(TasksUiPlugin.getTaskListManager()
																						.getTaskList()
																						.getDefaultCategory())) {
																					MessageDialog.openInformation(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),
																							LABEL, "Can not remove from the default category, move to another category instead.");
																				}*/else {
						TasksUiPlugin.getTaskListManager().getTaskList().moveTask(
								task,
								TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
										LocalRepositoryConnector.REPOSITORY_URL));
					}

				}
			}
		} catch (NullPointerException npe) {




		setId(ID);
		setActionDefinitionId(DEFINITION_ID);
		setImageDescriptor(TasksUiImages.OVERLAY_INCOMMING);
//		if (containsArchiveContainer(selectedElements)) {
//			setEnabled(false);
//		} else {
		if (selectedElements.size() == 1 && (selectedElements.get(0) instanceof AbstractTask)) {
			AbstractTask task = (AbstractTask) selectedElements.get(0);
			setEnabled(!task.isLocal());
		} else {
			setEnabled(true);
				AbstractTask task = (AbstractTask) selectedElements.get(0);
				setEnabled(!task.isLocal());
			} else {
				setEnabled(true);
			}
		}
//		}
	}

	@Override

Lines 21-27 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/actions/FilterArchiveContainerAction.java (-1 / +1 lines)
21		21
22	public static final String ID = "org.eclipse.mylyn.tasklist.actions.filter.archive";	22	public static final String ID = "org.eclipse.mylyn.tasklist.actions.filter.archive";
23		23
24	private static final String LABEL = "Filter Archive Category";	24	private static final String LABEL = "Filter Archives";
25		25
26	private final TaskListView view;	26	private final TaskListView view;
27		27

Lines 14-20 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/actions/AbstractTaskAction.java (-2 / +1 lines)
14	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;	14	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
15	import org.eclipse.mylyn.tasks.core.AbstractTask;	15	import org.eclipse.mylyn.tasks.core.AbstractTask;
16	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;	16	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
17	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
18		17
19	/**	18	/**
20	* @author Rob Elves	19	* @author Rob Elves
Lines 49-55 Link Here
49	protected abstract void performActionOnTask(AbstractTask repositoryTask);	48	protected abstract void performActionOnTask(AbstractTask repositoryTask);
50		49
51	protected boolean containsArchiveContainer(List<AbstractTaskContainer> selectedElements) {	50	protected boolean containsArchiveContainer(List<AbstractTaskContainer> selectedElements) {
52	return selectedElements.contains(TasksUiPlugin.getTaskListManager().getTaskList().getArchiveContainer());	51	return false;//selectedElements.contains(TasksUiPlugin.getTaskListManager().getTaskList().getArchiveContainer());
53	}	52	}
54		53
55	}	54	}

Lines 61-68 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/actions/OpenRepositoryTask.java (-2 / +1 lines)
61	*/	61	*/
62	private void openExistingTask(RemoteTaskSelectionDialog dlg) {	62	private void openExistingTask(RemoteTaskSelectionDialog dlg) {
63	if (dlg.shouldAddToTaskList()) {	63	if (dlg.shouldAddToTaskList()) {
64	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(dlg.getSelectedTask(),	64	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(dlg.getSelectedTask(), dlg.getSelectedCategory());
65	dlg.getSelectedCategory());
66	}	65	}
67	TasksUiUtil.refreshAndOpenTaskListElement(dlg.getSelectedTask());	66	TasksUiUtil.refreshAndOpenTaskListElement(dlg.getSelectedTask());
68	}	67	}




	public static final String ID = "org.eclipse.mylyn.tasklist.actions.mark.read";

	public static final String DEFINITION_ID = "org.eclipse.mylyn.tasks.ui.command.markTaskRead";

	public MarkTaskReadAction(List<AbstractTaskContainer> selectedElements) {
		super.selectedElements = selectedElements;
		setText(ACTION_NAME);
		setToolTipText("Mark " + ACTION_NAME);
		setId(ID);
		setActionDefinitionId(DEFINITION_ID);
//		if (containsArchiveContainer(selectedElements)) {
//			setEnabled(false);
//		} else {
		setEnabled(selectedElements.size() > 0);
		if (selectedElements.size() == 1 && (selectedElements.get(0) instanceof AbstractTask)) {
			AbstractTask task = (AbstractTask) selectedElements.get(0);
			setEnabled(!(task instanceof LocalTask));
		} else {
			setEnabled(true);
			if (selectedElements.size() == 1 && (selectedElements.get(0) instanceof AbstractTask)) {
				AbstractTask task = (AbstractTask) selectedElements.get(0);
				setEnabled(!(task instanceof LocalTask));
			} else {
				setEnabled(true);
			}
		}
//		}
	}

	@Override

Lines 296-308 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/util/DelegatingTaskExternalizer.java (-5 / +9 lines)
296	boolean hasCaughtException = false;	296	boolean hasCaughtException = false;
297	Element element = (Element) node;	297	Element element = (Element) node;
298		298
299	AbstractTaskCategory category;	299	AbstractTaskCategory category = null;
300	if (element.hasAttribute(DelegatingTaskExternalizer.KEY_NAME)) {	300	if (element.hasAttribute(DelegatingTaskExternalizer.KEY_NAME)) {
301	category = new TaskCategory(element.getAttribute(DelegatingTaskExternalizer.KEY_NAME));	301	category = new TaskCategory(element.getAttribute(DelegatingTaskExternalizer.KEY_NAME));
302	taskList.internalAddCategory((TaskCategory) category);	302	taskList.internalAddCategory((TaskCategory) category);
303	} else {	303	} else {
304	// LEGACY: registry categories did not have names	304	// LEGACY: registry categories did not have names
305	category = taskList.getArchiveContainer();	305	// category = taskList.getArchiveContainer();
		306	// a null category will now go into appropriate orphaned category
306	}	307	}
307		308
308	NodeList list = node.getChildNodes();	309	NodeList list = node.getChildNodes();
Lines 311-317 Link Here
311	try {	312	try {
312	// LEGACY: categories used to contain tasks?	313	// LEGACY: categories used to contain tasks?
313	AbstractTask task = readTask(child, category, null);	314	AbstractTask task = readTask(child, category, null);
314	category.internalAddChild(task);	315	if (category != null) {
		316	category.internalAddChild(task);
		317	}
315	taskList.insertTask(task, category, null);	318	taskList.insertTask(task, category, null);
316	} catch (Throwable t) {	319	} catch (Throwable t) {
317	hasCaughtException = true;	320	hasCaughtException = true;
Lines 379-385 Link Here
379	// return task;	382	// return task;
380	// }	383	// }
381		384
382	private void readTaskInfo(AbstractTask task, Element element, AbstractTask parent, AbstractTaskCategory legacyCategory) throws TaskExternalizationException {	385	private void readTaskInfo(AbstractTask task, Element element, AbstractTask parent,
		386	AbstractTaskCategory legacyCategory) throws TaskExternalizationException {
383	if (task == null) {	387	if (task == null) {
384	return;	388	return;
385	}	389	}
Lines 404-410 Link Here
404	// taskList.internalAddTask(task, taskList.getArchiveContainer());	408	// taskList.internalAddTask(task, taskList.getArchiveContainer());
405	// }	409	// }
406	task.setCategoryHandle(element.getAttribute(KEY_CATEGORY));	410	task.setCategoryHandle(element.getAttribute(KEY_CATEGORY));
407		411
408	if (element.hasAttribute(KEY_PRIORITY)) {	412	if (element.hasAttribute(KEY_PRIORITY)) {
409	task.setPriority(element.getAttribute(KEY_PRIORITY));	413	task.setPriority(element.getAttribute(KEY_PRIORITY));
410	} else {	414	} else {




import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;
import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;

		Collections.sort(categories, new Comparator<AbstractTaskContainer>() {

			public int compare(AbstractTaskContainer c1, AbstractTaskContainer c2) {
				if (c1.equals(TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
						LocalRepositoryConnector.REPOSITORY_URL))) {
					return -1;
				} else if (c2.equals(TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
						LocalRepositoryConnector.REPOSITORY_URL))) {
					return 1;
				} else {
					return c1.getSummary().compareToIgnoreCase(c2.getSummary());

								.getSelection()).getFirstElement();

					if (selectedObject instanceof TaskCategory) {
						TasksUiPlugin.getTaskListManager().getTaskList().moveTask(newTask,
								((TaskCategory) selectedObject));
					}
				}

Lines 3553-3559 Link Here

(-)src/org/eclipse/mylyn/tasks/ui/editors/AbstractRepositoryTaskEditor.java (-1 / +1 lines)
3553	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {	3553	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
3554	public void run() {	3554	public void run() {
3555	if (getCategory() != null) {	3555	if (getCategory() != null) {
3556	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(newTask, getCategory());	3556	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(newTask, getCategory());
3557	}	3557	}
3558	}	3558	}
3559	});	3559	});




			// initialized
			taskListManager.init();
			taskListManager.addActivityListener(CONTEXT_TASK_ACTIVITY_LISTENER);
			// readExistingOrCreateNewList() must be called after repositories have been read in
			taskListManager.readExistingOrCreateNewList();
			initialized = true;



		// Add standard local task repository
		if (taskRepositoryManager.getRepository(LocalRepositoryConnector.REPOSITORY_URL) == null) {
			TaskRepository localRepository = new TaskRepository(LocalRepositoryConnector.CONNECTOR_KIND,
					LocalRepositoryConnector.REPOSITORY_URL, LocalRepositoryConnector.REPOSITORY_VERSION);
			localRepository.setRepositoryLabel(LocalRepositoryConnector.REPOSITORY_LABEL);
			localRepository.setAnonymous(true);

	 * @param withProgress
	 */
	public void reloadDataDirectory(boolean withProgress) {
		getTaskListManager().resetTaskList();
		getTaskListManager().getTaskActivationHistory().clear();
		getRepositoryManager().readRepositories(getRepositoriesFilePath());
		loadTemplateRepositories();
		getTaskListManager().resetTaskList();
		getTaskListManager().setTaskListFile(
				new File(getDataDirectory() + File.separator + ITasksUiConstants.DEFAULT_TASK_LIST_FILE));
		ContextCorePlugin.getContextManager().loadActivityMetaContext();
		getTaskListManager().readExistingOrCreateNewList();
		getTaskListManager().initActivityHistory();
		checkForCredentials();

	 * 
	 * @Deprecated
	 */
	public TaskListNotification getIncommingNotification(AbstractRepositoryConnector connector, AbstractTask task) {
			AbstractTask task) {

		TaskListNotification notification = new TaskListNotification(task);
		RepositoryTaskData newTaskData = getTaskDataManager().getNewTaskData(task.getRepositoryUrl(), task.getTaskId());

				if (!"".equals(chnagedAttributes)) {
					description.append(chnagedAttributes);
				}

				notification.setDescription(description.toString());

				if (connector != null) {

Lines 33-38 Link Here

(-)src/org/eclipse/mylyn/tasks/ui/TaskListManager.java (-4 / +16 lines)
33	import org.eclipse.mylyn.internal.context.core.InteractionContextManager;	33	import org.eclipse.mylyn.internal.context.core.InteractionContextManager;
34	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;	34	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
35	import org.eclipse.mylyn.internal.tasks.core.LocalTask;	35	import org.eclipse.mylyn.internal.tasks.core.LocalTask;
		36	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
36	import org.eclipse.mylyn.internal.tasks.core.RepositoryTaskHandleUtil;	37	import org.eclipse.mylyn.internal.tasks.core.RepositoryTaskHandleUtil;
37	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;	38	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
38	import org.eclipse.mylyn.internal.tasks.core.TaskActivityManager;	39	import org.eclipse.mylyn.internal.tasks.core.TaskActivityManager;
Lines 109-116 Link Here
109		110
110	private TaskListSaveManager taskListSaveManager;	111	private TaskListSaveManager taskListSaveManager;
111		112
112	// TODO: guard against overwriting the single instance?	113	private final TaskList taskList = new TaskList();
113	private TaskList taskList = new TaskList();
114		114
115	private TaskActivationHistory taskActivityHistory = new TaskActivationHistory();	115	private TaskActivationHistory taskActivityHistory = new TaskActivationHistory();
116		116
Lines 157-166 Link Here
157	public TaskList resetTaskList() {	157	public TaskList resetTaskList() {
158	resetAndRollOver();	158	resetAndRollOver();
159	taskList.reset();	159	taskList.reset();
		160	prepareOrphanContainers();
		161
160	taskListInitialized = true;	162	taskListInitialized = true;
161	return taskList;	163	return taskList;
162	}	164	}
163		165
		166	private void prepareOrphanContainers() {
		167	for (TaskRepository repository : TasksUiPlugin.getRepositoryManager().getAllRepositories()) {
		168	taskList.addOrphanContainer(new OrphanedTasksContainer(repository.getConnectorKind(), repository.getUrl()));
		169	}
		170
		171	taskList.addOrphanContainer(new OrphanedTasksContainer(LocalRepositoryConnector.CONNECTOR_KIND,
		172	LocalRepositoryConnector.REPOSITORY_URL));
		173	}
		174
164	public void refactorRepositoryUrl(String oldUrl, String newUrl) {	175	public void refactorRepositoryUrl(String oldUrl, String newUrl) {
165	if (oldUrl == null \|\| newUrl == null \|\| oldUrl.equals(newUrl)) {	176	if (oldUrl == null \|\| newUrl == null \|\| oldUrl.equals(newUrl)) {
166	return;	177	return;
Lines 262-267 Link Here
262	public boolean readExistingOrCreateNewList() {	273	public boolean readExistingOrCreateNewList() {
263	try {	274	try {
264	if (taskListFile.exists()) {	275	if (taskListFile.exists()) {
		276	prepareOrphanContainers();
265	taskListWriter.readTaskList(taskList, taskListFile, TasksUiPlugin.getTaskDataManager());	277	taskListWriter.readTaskList(taskList, taskListFile, TasksUiPlugin.getTaskDataManager());
266	} else {	278	} else {
267	resetTaskList();	279	resetTaskList();
Lines 497-503 Link Here
497	} else if (view != null && view.getDrilledIntoCategory() instanceof TaskCategory) {	509	} else if (view != null && view.getDrilledIntoCategory() instanceof TaskCategory) {
498	taskList.addTask(newTask, view.getDrilledIntoCategory());	510	taskList.addTask(newTask, view.getDrilledIntoCategory());
499	} else {	511	} else {
500	taskList.addTask(newTask, TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());	512	taskList.addTask(newTask);//, TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
501	}	513	}
502	} else if (view != null && view.getDrilledIntoCategory() instanceof TaskCategory) {	514	} else if (view != null && view.getDrilledIntoCategory() instanceof TaskCategory) {
503	taskList.addTask(newTask, view.getDrilledIntoCategory());	515	taskList.addTask(newTask, view.getDrilledIntoCategory());
Lines 506-512 Link Here
506	MessageDialog.openInformation(Display.getCurrent().getActiveShell(), ITasksUiConstants.TITLE_DIALOG,	518	MessageDialog.openInformation(Display.getCurrent().getActiveShell(), ITasksUiConstants.TITLE_DIALOG,
507	"The new task has been added to the root of the list, since tasks can not be added to a query.");	519	"The new task has been added to the root of the list, since tasks can not be added to a query.");
508	}	520	}
509	taskList.addTask(newTask, taskList.getDefaultCategory());	521	taskList.addTask(newTask);
510	}	522	}
511	return newTask;	523	return newTask;
512	}	524	}

Lines 47-53 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/LocalTaskConnectorUi.java (-1 / +1 lines)
47		47
48	@Override	48	@Override
49	public String getConnectorKind() {	49	public String getConnectorKind() {
50	return LocalRepositoryConnector.REPOSITORY_KIND;	50	return LocalRepositoryConnector.CONNECTOR_KIND;
51	}	51	}
52		52
53	@Override	53	@Override

Lines 47-53 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/TaskRepositoryAdapterFactory.java (-1 / +1 lines)
47	.getRepositoryConnector(repository.getConnectorKind());	47	.getRepositoryConnector(repository.getConnectorKind());
48	return connector.canCreateNewTask(repository);	48	return connector.canCreateNewTask(repository);
49	} else if ("hasRepository".equals(name)) {	49	} else if ("hasRepository".equals(name)) {
50	return !repository.getConnectorKind().equals(LocalRepositoryConnector.REPOSITORY_KIND);	50	return !repository.getConnectorKind().equals(LocalRepositoryConnector.CONNECTOR_KIND);
51	}	51	}
52	return false;	52	return false;
53	}	53	}

Lines 7-12 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/TaskArchiveFilter.java (+8 lines)
7	*******************************************************************************/	7	*******************************************************************************/
8	package org.eclipse.mylyn.internal.tasks.ui;	8	package org.eclipse.mylyn.internal.tasks.ui;
9		9
		10	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
		11	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
10	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;	12	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;
11		13
12	/**	14	/**
Lines 16-21 Link Here
16		18
17	@Override	19	@Override
18	public boolean select(Object parent, Object element) {	20	public boolean select(Object parent, Object element) {
		21	if (element instanceof OrphanedTasksContainer) {
		22	if (((OrphanedTasksContainer) element).getRepositoryUrl().equals(LocalRepositoryConnector.REPOSITORY_URL)) {
		23	return true;
		24	}
		25	return false;
		26	}
19	if (element instanceof TaskArchive) {	27	if (element instanceof TaskArchive) {
20	return false;	28	return false;
21	}	29	}




import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
import org.eclipse.mylyn.internal.tasks.ui.actions.NewCategoryAction;
import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;

				.getCategories());
		Collections.sort(categories);
		for (final AbstractTaskCategory category : categories) {
			if (!(category instanceof OrphanedTasksContainer)) {
				Action action = new Action() {
					@Override
					public void run() {

	private void moveToCategory(final List<AbstractTaskContainer> selectedElements, AbstractTaskCategory category) {
		for (AbstractTaskContainer element : selectedElements) {
			if (element instanceof AbstractTask) {
				TasksUiPlugin.getTaskListManager().getTaskList().moveTask((AbstractTask) element, category);
			}
		}
	}




import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;
import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;

							if (selectedObject instanceof TaskCategory) {
								category = (TaskCategory) selectedObject;
							} else {
								category = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
										LocalRepositoryConnector.REPOSITORY_URL);
							}
						}
						TasksUiPlugin.getTaskListManager().getTaskList().moveTask(newTask, category);
						taskListView.getViewer().setSelection(new StructuredSelection(newTask));
					}
				});

		}
		return Status.OK_STATUS;
	}

}

Lines 159-165 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/wizards/SelectRepositoryPage.java (-1 / +1 lines)
159	viewer.setSelection(new StructuredSelection(selectedRepository));	159	viewer.setSelection(new StructuredSelection(selectedRepository));
160	} else {	160	} else {
161	TaskRepository localRepository = TasksUiPlugin.getRepositoryManager().getRepository(	161	TaskRepository localRepository = TasksUiPlugin.getRepositoryManager().getRepository(
162	LocalRepositoryConnector.REPOSITORY_KIND, LocalRepositoryConnector.REPOSITORY_URL);	162	LocalRepositoryConnector.CONNECTOR_KIND, LocalRepositoryConnector.REPOSITORY_URL);
163	viewer.setSelection(new StructuredSelection(localRepository));	163	viewer.setSelection(new StructuredSelection(localRepository));
164	}	164	}
165		165

Lines 25-30 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/wizards/TaskDataImportWizard.java (-1 / +2 lines)
25	import org.eclipse.jface.wizard.Wizard;	25	import org.eclipse.jface.wizard.Wizard;
26	import org.eclipse.mylyn.internal.context.core.InteractionContextManager;	26	import org.eclipse.mylyn.internal.context.core.InteractionContextManager;
27	import org.eclipse.mylyn.internal.monitor.core.util.ZipFileUtil;	27	import org.eclipse.mylyn.internal.monitor.core.util.ZipFileUtil;
		28	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
28	import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;	29	import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;
29	import org.eclipse.mylyn.monitor.core.StatusHandler;	30	import org.eclipse.mylyn.monitor.core.StatusHandler;
30	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;	31	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
Lines 220-226 Link Here
220	List<AbstractTask> allTasks = new ArrayList<AbstractTask>();	221	List<AbstractTask> allTasks = new ArrayList<AbstractTask>();
221	TaskList taskList = TasksUiPlugin.getTaskListManager().getTaskList();	222	TaskList taskList = TasksUiPlugin.getTaskListManager().getTaskList();
222		223
223	allTasks.addAll(taskList.getDefaultCategory().getChildren());	224	allTasks.addAll(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).getChildren());
224		225
225	for (AbstractTaskContainer category : taskList.getCategories()) {	226	for (AbstractTaskContainer category : taskList.getCategories()) {
226	allTasks.addAll(category.getChildren());	227	allTasks.addAll(category.getChildren());

Lines 31-36 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/workingsets/TaskWorkingSetPage.java (+9 lines)
31	import org.eclipse.jface.viewers.Viewer;	31	import org.eclipse.jface.viewers.Viewer;
32	import org.eclipse.jface.viewers.ViewerSorter;	32	import org.eclipse.jface.viewers.ViewerSorter;
33	import org.eclipse.jface.wizard.WizardPage;	33	import org.eclipse.jface.wizard.WizardPage;
		34	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
34	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;	35	import org.eclipse.mylyn.internal.tasks.core.TaskArchive;
35	import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;	36	import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;
36	import org.eclipse.mylyn.internal.tasks.ui.views.TaskElementLabelProvider;	37	import org.eclipse.mylyn.internal.tasks.ui.views.TaskElementLabelProvider;
Lines 138-143 Link Here
138	taskContainers.add(element);	139	taskContainers.add(element);
139	}	140	}
140	}	141	}
		142
		143	OrphanedTasksContainer orphansContainer = TasksUiPlugin.getTaskListManager()
		144	.getTaskList()
		145	.getOrphanContainer(((TaskRepository) parentElement).getUrl());
		146	if (orphansContainer != null) {
		147	taskContainers.add(orphansContainer);
		148	}
		149
141	return taskContainers.toArray();	150	return taskContainers.toArray();
142	} else if (parentElement instanceof TaskRepositoryProjectMapping) {	151	} else if (parentElement instanceof TaskRepositoryProjectMapping) {
143	return ((TaskRepositoryProjectMapping) parentElement).getProjects().toArray();	152	return ((TaskRepositoryProjectMapping) parentElement).getProjects().toArray();




import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.mylyn.internal.tasks.core.ITaskRepositoryFilter;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.internal.tasks.ui.ITaskCommandIds;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskElementLabelProvider;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskRepositoryLabelProvider;

		TaskList taskList = TasksUiPlugin.getTaskListManager().getTaskList();
		LinkedList<AbstractTaskContainer> categories = new LinkedList<AbstractTaskContainer>(
				taskList.getUserCategories());
		categories.addFirst(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL));
		categoryViewer.setInput(categories);
		categoryViewer.setLabelProvider(new LabelProvider() {


			}

		});
		categoryViewer.setSelection(new StructuredSelection(
				taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)));

		categoryViewer.getControl().setEnabled(addToTaskListCheck.getSelection());
		addToTaskListCheck.addSelectionListener(new SelectionAdapter() {





import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskElementLabelProvider;
import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;

		List<AbstractTaskContainer> containers = new ArrayList<AbstractTaskContainer>();
		containers.addAll(manager.getTaskList().getUserCategories());
		containers.addAll(manager.getTaskList().getQueries());
		//containers.add(manager.getTaskList().getArchiveContainer());
		Collections.sort(containers, new Comparator<AbstractTaskContainer>() {

			public int compare(AbstractTaskContainer c1, AbstractTaskContainer c2) {
				if (c1.equals(TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
						LocalRepositoryConnector.REPOSITORY_URL))) {
					return -1;
				} else if (c2.equals(TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
						LocalRepositoryConnector.REPOSITORY_URL))) {
					return 1;
				} else {
					return c1.getSummary().compareToIgnoreCase(c2.getSummary());




import junit.framework.TestCase;

import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.mylyn.internal.bugzilla.core.BugzillaCorePlugin;
import org.eclipse.mylyn.internal.bugzilla.core.BugzillaRepositoryQuery;
import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;
import org.eclipse.mylyn.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
import org.eclipse.mylyn.internal.tasks.ui.planner.CompletedTaskCollector;
import org.eclipse.mylyn.internal.tasks.ui.planner.TaskReportGenerator;
import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.TaskListManager;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;



	public void testCompletedTasksRetrieved() throws InvocationTargetException, InterruptedException {
		AbstractTask task1 = manager.createNewLocalTask("task 1");
		manager.getTaskList().addTask(task1);

		CompletedTaskCollector collector = new CompletedTaskCollector(new Date(0), new Date());
		TaskReportGenerator generator = new TaskReportGenerator(manager.getTaskList());


	public void testCompletedTasksDateBoundsRetrieved() throws InvocationTargetException, InterruptedException {
		AbstractTask task1 = manager.createNewLocalTask("task 1");
		manager.getTaskList().addTask(task1);
		task1.setCompleted(true);
		Thread.sleep(1000);
		long now = new Date().getTime();

	}

	public void testCompletedBugzillaTasksRetrieved() throws InvocationTargetException, InterruptedException {
		TaskRepository repository = new TaskRepository(BugzillaCorePlugin.REPOSITORY_KIND,
				IBugzillaConstants.ECLIPSE_BUGZILLA_URL);
		TasksUiPlugin.getRepositoryManager().addRepository(repository,
				TasksUiPlugin.getDefault().getRepositoriesFilePath());
		BugzillaTask task1 = new BugzillaTask(IBugzillaConstants.ECLIPSE_BUGZILLA_URL, "1", "bugzillatask 1");
		manager.getTaskList().addTask(task1);

		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.MINUTE, 5);
		CompletedTaskCollector collector = new CompletedTaskCollector(new Date(0), cal.getTime());
		TaskReportGenerator generator = new TaskReportGenerator(manager.getTaskList());
		generator.addCollector(collector);
		generator.run(new NullProgressMonitor());

		generator.run(new NullProgressMonitor());
		assertEquals(1, generator.getAllCollectedTasks().size());
		assertEquals(task1, generator.getAllCollectedTasks().get(0));
		TasksUiPlugin.getRepositoryManager().removeRepository(repository,
				TasksUiPlugin.getDefault().getRepositoriesFilePath());
		manager.resetTaskList();
	}

	public void testCompletedTasksInCategoryRetrieved() throws InvocationTargetException, InterruptedException {
		AbstractTask task1 = manager.createNewLocalTask("task 1");
		manager.getTaskList().addTask(task1);
		task1.setCompleted(true);
		TaskCategory cat1 = new TaskCategory("TaskReportGeneratorTest Category");
		manager.getTaskList().addCategory(cat1);

		generator.run(new NullProgressMonitor());
		assertEquals(0, generator.getAllCollectedTasks().size());

		manager.getTaskList().moveTask(task1, cat1);

		generator.run(new NullProgressMonitor());
		assertEquals(1, generator.getAllCollectedTasks().size());


	public void testCompletedBugzillaTasksInCategoryRetrieved() throws InvocationTargetException, InterruptedException {
		BugzillaTask task1 = new BugzillaTask("repo", "1", "task 1");
		manager.getTaskList().addTask(task1);
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
		task1.setCompleted(true);
		TaskCategory cat1 = new TaskCategory("TaskReportGeneratorTest Category");
		manager.getTaskList().addCategory(cat1);

		generator.run(new NullProgressMonitor());
		assertEquals(0, generator.getAllCollectedTasks().size());

		manager.getTaskList().moveTask(task1, cat1);

		generator.run(new NullProgressMonitor());
		assertEquals(1, generator.getAllCollectedTasks().size());


	public void testCompletedBugzillaTasksInQueryRetrieved() throws InvocationTargetException, InterruptedException {
		BugzillaTask task1 = new BugzillaTask("repo", "1", "task 1");
		manager.getTaskList().addTask(task1);
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
		task1.setCompleted(false);

		BugzillaRepositoryQuery bugQuery = new BugzillaRepositoryQuery("repositoryUrl", "queryUrl",




import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;
import org.eclipse.mylyn.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylyn.internal.bugzilla.ui.tasklist.BugzillaTaskListFactory;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.internal.tasks.core.LocalTask;
import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.AbstractTaskListFactory;

		manager = TasksUiPlugin.getTaskListManager();

		manager.resetTaskList();
		assertEquals("should be empty: "
				+ manager.getTaskList().getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).getChildren(), 0,
				manager.getTaskList().getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).getChildren().size());
	}

	@Override

		AbstractTask task = new LocalTask("1", "task 1");
		Date dueDate = new Date();
		task.setDueDate(dueDate);
		manager.getTaskList().addTask(task);
		assertEquals(1, manager.getTaskList().getAllTasks().size());

		manager.saveTaskList();
		manager.resetTaskList();
		manager.readExistingOrCreateNewList();
		assertEquals(1, manager.getTaskList().getAllTasks().size());
		Set<AbstractTask> readList = manager.getTaskList()
				.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
				.getChildren();
		AbstractTask readTask = readList.iterator().next();
		assertTrue(readTask.getSummary().equals("task 1"));
		assertTrue(readTask.getDueDate().compareTo(dueDate) == 0);

		Date creation = new Date();
		AbstractTask task = new LocalTask("1", "task 1");

		manager.getTaskList().addTask(task);
		assertDatesCloseEnough(task.getCreationDate(), start);

		task.setCompleted(true);

		task.setScheduledForDate(start);
		assertDatesCloseEnough(task.getScheduledForDate(), start);

		assertEquals(1, manager.getTaskList().getRootElements().size());
		manager.saveTaskList();

		assertNotNull(manager.getTaskList());

		// assertEquals(0, manager.getTaskList().getRootTasks().size());
		// manager.readOrCreateTaskList();
		// assertNotNull(manager.getTaskList());
		assertEquals(1, manager.getTaskList()
				.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
				.getChildren()
				.size());

		Set<AbstractTask> readList = manager.getTaskList()
				.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
				.getChildren();
		AbstractTask readTask = readList.iterator().next();
		assertTrue(readTask.getSummary().equals("task 1"));


Lines 12-17 Link Here

(-)src/org/eclipse/mylyn/bugzilla/tests/RepositoryTaskHandleTest.java (-6 / +12 lines)
12		12
13	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;	13	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;
14	import org.eclipse.mylyn.internal.bugzilla.core.IBugzillaConstants;	14	import org.eclipse.mylyn.internal.bugzilla.core.IBugzillaConstants;
		15	import org.eclipse.mylyn.tasks.core.TaskRepository;
		16	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryConnector;
15	import org.eclipse.mylyn.tasks.ui.TaskListManager;	17	import org.eclipse.mylyn.tasks.ui.TaskListManager;
16	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;	18	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
17		19
Lines 51-74 Link Here
51	// }	53	// }
52		54
53	public void testRepositoryUrlHandles() {	55	public void testRepositoryUrlHandles() {
		56	String repositoryUrl = IBugzillaConstants.ECLIPSE_BUGZILLA_URL;
		57	TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, repositoryUrl);
		58	TasksUiPlugin.getRepositoryManager().addRepository(repository,
		59	TasksUiPlugin.getDefault().getRepositoriesFilePath());
54		60
55	String repository = IBugzillaConstants.ECLIPSE_BUGZILLA_URL;
56	String id = "123";	61	String id = "123";
57	BugzillaTask bugTask = new BugzillaTask(repository, id, "label 124");	62	BugzillaTask bugTask = new BugzillaTask(repositoryUrl, id, "label 124");
58	assertEquals(repository, bugTask.getRepositoryUrl());	63	assertEquals(repositoryUrl, bugTask.getRepositoryUrl());
59		64
60	manager.getTaskList().moveToContainer(bugTask,	65	manager.getTaskList().addTask(bugTask);
61	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
62	manager.saveTaskList();	66	manager.saveTaskList();
63	manager.resetTaskList();	67	manager.resetTaskList();
64	manager.readExistingOrCreateNewList();	68	manager.readExistingOrCreateNewList();
65		69
66	BugzillaTask readReport = (BugzillaTask) manager.getTaskList()	70	BugzillaTask readReport = (BugzillaTask) manager.getTaskList()
67	.getDefaultCategory()	71	.getOrphanContainer(repositoryUrl)
68	.getChildren()	72	.getChildren()
69	.iterator()	73	.iterator()
70	.next();	74	.next();
71	assertEquals(readReport.getSummary(), readReport.getSummary());	75	assertEquals(readReport.getSummary(), readReport.getSummary());
72	assertEquals(readReport.getRepositoryUrl(), readReport.getRepositoryUrl());	76	assertEquals(readReport.getRepositoryUrl(), readReport.getRepositoryUrl());
		77	TasksUiPlugin.getRepositoryManager().removeRepository(repository,
		78	TasksUiPlugin.getDefault().getRepositoriesFilePath());
73	}	79	}
74	}	80	}




import org.eclipse.mylyn.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylyn.internal.bugzilla.core.RepositoryConfiguration;
import org.eclipse.mylyn.internal.tasks.core.LocalAttachment;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.RepositoryAttachment;
import org.eclipse.mylyn.tasks.core.RepositoryOperation;

				task.getTaskId());
		assertNotNull(taskData);

		TasksUiPlugin.getTaskListManager().getTaskList().addTask(task);
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());

		String newCommentText = "BugzillaRepositoryClientTest.testMidAirCollision(): test " + (new Date()).toString();
		taskData.setNewComment(newCommentText);

				task.getTaskId());
		assertNotNull(taskData);

		TasksUiPlugin.getTaskListManager().getTaskList().addTask(task);
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());

		assertEquals("rob.elves@eclipse.org", taskData.getAssignedTo());
		// Modify it (reassign to tests2@mylyn.eclipse.org)

				task.getTaskId());
		assertNotNull(taskData);

		TasksUiPlugin.getTaskListManager().getTaskList().moveTask(
				task,
				TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
						LocalRepositoryConnector.REPOSITORY_URL));

		assertEquals(defaultAssignee, taskData.getAssignedTo());
		// Modify it (reassign to tests2@mylyn.eclipse.org)

				task.getTaskId());
		assertNotNull(taskData);

		TasksUiPlugin.getTaskListManager().getTaskList().addTask(task);
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
		int numComments = taskData.getComments().size();

		// Modify it

Lines 20-25 Link Here

(-)src/org/eclipse/mylyn/bugzilla/tests/AbstractBugzillaTest.java (-3 / +6 lines)
20	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaRepositoryConnector;	20	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaRepositoryConnector;
21	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;	21	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;
22	import org.eclipse.mylyn.internal.bugzilla.core.IBugzillaConstants;	22	import org.eclipse.mylyn.internal.bugzilla.core.IBugzillaConstants;
		23	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
23	import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;	24	import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
24	import org.eclipse.mylyn.tasks.core.AbstractTask;	25	import org.eclipse.mylyn.tasks.core.AbstractTask;
25	import org.eclipse.mylyn.tasks.core.ITaskFactory;	26	import org.eclipse.mylyn.tasks.core.ITaskFactory;
Lines 59-65 Link Here
59	super.setUp();	60	super.setUp();
60	TasksUiPlugin.getTaskDataManager().clear();	61	TasksUiPlugin.getTaskDataManager().clear();
61	manager = TasksUiPlugin.getRepositoryManager();	62	manager = TasksUiPlugin.getRepositoryManager();
62	TasksUiPlugin.getTaskListManager().getTaskList().reset();	63	TasksUiPlugin.getTaskListManager().resetTaskList();//getTaskList().reset();
63	manager.clearRepositories(TasksUiPlugin.getDefault().getRepositoriesFilePath());	64	manager.clearRepositories(TasksUiPlugin.getDefault().getRepositoriesFilePath());
64	}	65	}
65		66
Lines 122-129 Link Here
122	new NullProgressMonitor());	123	new NullProgressMonitor());
123	TasksUiPlugin.getSynchronizationManager().setTaskRead(task, true);	124	TasksUiPlugin.getSynchronizationManager().setTaskRead(task, true);
124	assertNotNull(task);	125	assertNotNull(task);
125	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(task,	126	TasksUiPlugin.getTaskListManager().getTaskList().moveTask(
126	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());	127	task,
		128	TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
		129	LocalRepositoryConnector.REPOSITORY_URL));
127		130
128	return task;	131	return task;
129	}	132	}




import org.eclipse.mylyn.internal.bugzilla.core.BugzillaRepositoryQuery;
import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;
import org.eclipse.mylyn.internal.bugzilla.core.IBugzillaConstants;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;

	}

	public void testRepositoryTaskExternalization() {
		BugzillaTask repositoryTask = new BugzillaTask(IBugzillaConstants.ECLIPSE_BUGZILLA_URL, "1", "label");
		repositoryTask.setTaskKind("kind");
		manager.getTaskList().addTask(repositoryTask);
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
		manager.saveTaskList();

		manager.resetTaskList();

		// TaskList list = new TaskList();
		// manager.setTaskList(list);
		manager.readExistingOrCreateNewList();
		assertEquals(1, manager.getTaskList()
				.getOrphanContainer(IBugzillaConstants.ECLIPSE_BUGZILLA_URL)
				.getChildren()
				.size());
		AbstractTask readTask = manager.getTaskList()
				.getOrphanContainer(IBugzillaConstants.ECLIPSE_BUGZILLA_URL)
				.getChildren()
				.iterator()
				.next();

		assertEquals(repositoryTask.getHandleIdentifier(), readTask.getHandleIdentifier());
		assertEquals(repositoryTask.getSummary(), readTask.getSummary());

		manager.setTaskListFile(originalFile);

		Collection<AbstractTask> allTasks = manager.getTaskList().getAllTasks();
		Set<AbstractTask> allRootTasks = manager.getTaskList().getOrphanContainer(
				LocalRepositoryConnector.REPOSITORY_URL).getChildren();
		Set<AbstractTaskCategory> allCategories = manager.getTaskList().getCategories();
		Set<AbstractTaskContainer> allRoots = manager.getTaskList().getRootElements();
		assertEquals(0, allRootTasks.size());

		// manager.setTaskList(list);
		manager.readExistingOrCreateNewList();

		assertEquals(allRootTasks.size(), manager.getTaskList().getOrphanContainer(
				LocalRepositoryConnector.REPOSITORY_URL).getChildren().size());
		assertEquals(allCategories, manager.getTaskList().getCategories());
		assertEquals(allRoots.size(), manager.getTaskList().getRootElements().size());
		assertEquals(allTasks.size(), manager.getTaskList().getAllTasks().size());

		// manager.setTaskList(list);
		manager.readExistingOrCreateNewList();

		assertEquals(allRootTasks.size(), manager.getTaskList().getOrphanContainer(
				LocalRepositoryConnector.REPOSITORY_URL).getChildren().size());
		assertEquals(allCategories, manager.getTaskList().getCategories());
		assertEquals(allRoots.size(), manager.getTaskList().getRootElements().size());
		assertEquals(allTasks.size(), manager.getTaskList().getAllTasks().size());




import org.eclipse.mylyn.internal.bugzilla.core.BugzillaCorePlugin;
import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;
import org.eclipse.mylyn.internal.bugzilla.ui.tasklist.StackTrace;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.internal.tasks.ui.search.AbstractRepositorySearchQuery;
import org.eclipse.mylyn.monitor.core.StatusHandler;
import org.eclipse.mylyn.tasks.core.AbstractTask;

		collector.setProgressMonitor(monitor);

		// get all of the root tasks and start the search
		Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
				LocalRepositoryConnector.REPOSITORY_URL).getChildren();
		searchLocal(tasks, collector, elementName, monitor);
		for (AbstractTaskContainer cat : TasksUiPlugin.getTaskListManager().getTaskList().getTaskContainers()) {
			searchLocal(cat.getChildren(), collector, elementName, monitor);

		collector.setProgressMonitor(monitor);

		// get all of the root tasks and start the search
		Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
				LocalRepositoryConnector.REPOSITORY_URL).getChildren();
		searchLocal(tasks, collector, elementName, monitor);
		for (AbstractTaskContainer cat : TasksUiPlugin.getTaskListManager().getTaskList().getTaskContainers()) {
			searchLocal(cat.getChildren(), collector, elementName, monitor);

Lines 83-89 Link Here

(-)src/org/eclipse/mylyn/java/tests/RefactoringTest.java (-1 lines)
83	IInteractionElement oldParentNode = ContextCorePlugin.getContextManager().getElement(	83	IInteractionElement oldParentNode = ContextCorePlugin.getContextManager().getElement(
84	parentNode.getHandleIdentifier());	84	parentNode.getHandleIdentifier());
85	assertFalse(oldParentNode.getInterest().isInteresting());	85	assertFalse(oldParentNode.getInterest().isInteresting());
86	// XXX: put back?
87	IInteractionElement newParentNode = ContextCorePlugin.getContextManager().getElement(	86	IInteractionElement newParentNode = ContextCorePlugin.getContextManager().getElement(
88	newType.getParent().getHandleIdentifier());	87	newType.getParent().getHandleIdentifier());
89	assertTrue(newParentNode.getInterest().isInteresting());	88	assertTrue(newParentNode.getInterest().isInteresting());

Lines 120-126 Link Here

(-)src/org/eclipse/mylyn/jira/tests/JiraTaskExternalizationTest.java (-2 / +2 lines)
120	public void testCompletionSave() {	120	public void testCompletionSave() {
121	JiraTask jiraTask = new JiraTask(SERVER_URL, TEST_TASK, TEST_LABEL);	121	JiraTask jiraTask = new JiraTask(SERVER_URL, TEST_TASK, TEST_LABEL);
122	jiraTask.setCompleted(true);	122	jiraTask.setCompleted(true);
123	manager.getTaskList().moveToContainer(jiraTask, manager.getTaskList().getDefaultCategory());	123	manager.getTaskList().addTask(jiraTask);
124		124
125	manager.saveTaskList();	125	manager.saveTaskList();
126	manager.resetTaskList();	126	manager.resetTaskList();
Lines 133-139 Link Here
133	JiraTask jiraTask = new JiraTask(SERVER_URL + "testSave", TEST_TASK, TEST_LABEL);	133	JiraTask jiraTask = new JiraTask(SERVER_URL + "testSave", TEST_TASK, TEST_LABEL);
134	String testUrl = "http://foo";	134	String testUrl = "http://foo";
135	jiraTask.setUrl(testUrl);	135	jiraTask.setUrl(testUrl);
136	manager.getTaskList().moveToContainer(jiraTask, manager.getTaskList().getDefaultCategory());	136	manager.getTaskList().addTask(jiraTask);
137		137
138	manager.saveTaskList();	138	manager.saveTaskList();
139	manager.resetTaskList();	139	manager.resetTaskList();

Lines 14-19 Link Here

(-)src/org/eclipse/mylyn/jira/tests/JiraTaskArchiveTest.java (-3 / +13 lines)
14	import org.eclipse.mylyn.internal.jira.ui.JiraUiPlugin;	14	import org.eclipse.mylyn.internal.jira.ui.JiraUiPlugin;
15	import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;	15	import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
16	import org.eclipse.mylyn.tasks.core.TaskList;	16	import org.eclipse.mylyn.tasks.core.TaskList;
		17	import org.eclipse.mylyn.tasks.core.TaskRepository;
17	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;	18	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
18		19
19	/**	20	/**
Lines 58-71 Link Here
58	AbstractRepositoryConnector client = TasksUiPlugin.getRepositoryManager().getRepositoryConnector(	59	AbstractRepositoryConnector client = TasksUiPlugin.getRepositoryManager().getRepositoryConnector(
59	JiraUiPlugin.REPOSITORY_KIND);	60	JiraUiPlugin.REPOSITORY_KIND);
60	assertNotNull(client);	61	assertNotNull(client);
61	assertEquals(0, taskList.getArchiveContainer().getChildren().size());	62
		63	TaskRepository repository = new TaskRepository(JiraUiPlugin.REPOSITORY_KIND, "repo");
		64	TasksUiPlugin.getRepositoryManager().addRepository(repository,
		65	TasksUiPlugin.getDefault().getRepositoriesFilePath());
		66
62	JiraTask task1 = new JiraTask("repo", HANDLE1, LABEL);	67	JiraTask task1 = new JiraTask("repo", HANDLE1, LABEL);
		68	task1.setLastReadTimeStamp("now");
63	JiraTask task2 = new JiraTask("repo", HANDLE1, LABEL);	69	JiraTask task2 = new JiraTask("repo", HANDLE1, LABEL);
64		70	task2.setLastReadTimeStamp("now");
65	taskList.addTask(task1);	71	taskList.addTask(task1);
66	taskList.addTask(task2);	72	taskList.addTask(task2);
67		73
68	assertEquals(1, taskList.getArchiveContainer().getChildren().size());	74	assertEquals(1, taskList.getOrphanContainer("repo").getChildren().size());
69	assertEquals(taskList.getTask("repo-" + HANDLE1), task1);	75	assertEquals(taskList.getTask("repo-" + HANDLE1), task1);
		76
		77	TasksUiPlugin.getRepositoryManager().removeRepository(repository,
		78	TasksUiPlugin.getDefault().getRepositoriesFilePath());
		79	TasksUiPlugin.getTaskListManager().resetTaskList();
70	}	80	}
71	}	81	}




import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;
import org.eclipse.mylyn.internal.context.core.InteractionContextManager;
import org.eclipse.mylyn.internal.monitor.usage.UiUsageMonitorPlugin;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.monitor.core.InteractionEvent;
import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.ui.TaskListManager;

	public void testTaskMove() {
		AbstractTask task = manager.createNewLocalTask("label");
		String handle = task.getHandleIdentifier();
		manager.getTaskList().moveTask(task,
				manager.getTaskList().getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL));

		AbstractTask readTaskBeforeMove = manager.getTaskList().getTask(handle);
		TasksUiPlugin.getTaskListManager().copyDataDirContentsTo(newDataDir);

	}

	private void addBugzillaTask(BugzillaTask newTask) {
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(newTask);
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
	}
}




		taskCompleted = new LocalTask("1", "completed");
		taskCompleted.setCompleted(true);
		taskCompleted.setCompletionDate(TaskActivityUtil.snapForwardNumDays(Calendar.getInstance(), -1).getTime());
		manager.getTaskList().addTask(taskCompleted);

		taskIncomplete = new LocalTask("2", "t-incomplete");
		manager.getTaskList().addTask(taskIncomplete);

		taskOverdue = new LocalTask("3", "t-overdue");
		taskOverdue.setScheduledForDate(TaskActivityUtil.snapForwardNumDays(Calendar.getInstance(), -1).getTime());
		manager.getTaskList().addTask(taskOverdue);

		taskDueToday = new LocalTask("4", "t-today");
		taskDueToday.setScheduledForDate(TaskActivityUtil.snapEndOfWorkDay(Calendar.getInstance()).getTime());
		manager.getTaskList().addTask(taskDueToday);

		taskCompletedToday = new LocalTask("5", "t-donetoday");
		taskCompletedToday.setScheduledForDate(TaskActivityUtil.snapEndOfWorkDay(Calendar.getInstance()).getTime());
		taskCompletedToday.setCompleted(true);
		manager.getTaskList().addTask(taskCompletedToday);
	}

	@Override




			cat1task1 = manager.createNewLocalTask("task 1");
			cat1task1.setPriority(PriorityLevel.P1.toString());
			cat1task1.setCompleted(true);
			manager.getTaskList().moveTask(cat1task1, cat1);

			cat1task1sub1 = manager.createNewLocalTask("sub task 1");
			cat1task1sub1.setPriority(PriorityLevel.P1.toString());

			cat1task2 = manager.createNewLocalTask("task 2");
			cat1task2.setPriority(PriorityLevel.P2.toString());
			cat1task2.addParentContainer(cat1);
			manager.getTaskList().moveTask(cat1task2, cat1);

			cat1task3 = manager.createNewLocalTask("task 3");
			cat1task3.setPriority(PriorityLevel.P3.toString());
			cat1task3.setCompleted(true);
			cat1task3.addParentContainer(cat1);
			manager.getTaskList().moveTask(cat1task3, cat1);

			cat1task4 = manager.createNewLocalTask("task 4");
			cat1task4.setPriority(PriorityLevel.P4.toString());
			cat1task4.addParentContainer(cat1);
			manager.getTaskList().moveTask(cat1task4, cat1);

			cat1task5 = manager.createNewLocalTask("task 5");
			cat1task5.setPriority(PriorityLevel.P5.toString());
			cat1task5.setCompleted(true);
			cat1task5.addParentContainer(cat1);
			manager.getTaskList().moveTask(cat1task5, cat1);

			manager.getTaskList().addCategory(cat1);
			assertEquals(cat1.getChildren().size(), 5);

			cat2task1 = manager.createNewLocalTask("task 1");
			cat2task1.setPriority(PriorityLevel.P1.toString());
			cat2task1.addParentContainer(cat2);
			manager.getTaskList().moveTask(cat2task1, cat2);

			cat2task1sub1 = manager.createNewLocalTask("sub task 1");
			cat2task1sub1.setPriority(PriorityLevel.P1.toString());

			cat2task2.setPriority(PriorityLevel.P2.toString());
			cat2task2.setCompleted(true);
			cat2task2.addParentContainer(cat2);
			manager.getTaskList().moveTask(cat2task2, cat2);

			cat2task3 = manager.createNewLocalTask("task 3");
			cat2task3.setPriority(PriorityLevel.P3.toString());
			cat2task3.addParentContainer(cat2);
			manager.getTaskList().moveTask(cat2task3, cat2);

			cat2task4 = manager.createNewLocalTask("task 4");
			cat2task4.setPriority(PriorityLevel.P4.toString());
			cat2task4.setCompleted(true);
			cat2task4.addParentContainer(cat2);
			manager.getTaskList().moveTask(cat2task4, cat2);

			cat2task5 = manager.createNewLocalTask("task 5");
			cat2task5.setPriority(PriorityLevel.P5.toString());
			cat2task5.addParentContainer(cat2);
			manager.getTaskList().moveTask(cat2task5, cat2);

			manager.getTaskList().addCategory(cat2);
			manager.saveTaskList();

		TaskListView view = TaskListView.getFromActivePerspective();
		assertNotNull(view);
		WebTask webTask = new WebTask("1", "1", "", "", "web");
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(webTask);
				TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
		view.getViewer().refresh();
		// Arrays.asList(view.getViewer().getVisibleExpandedElements());
		assertFalse(webTask.isCompleted());

		MoveToCategoryMenuContributor moveToMenuContrib = new MoveToCategoryMenuContributor();
		List<AbstractTaskContainer> selectedElements = new Vector<AbstractTaskContainer>();
		selectedElements.add(cat1task1);
		int numCategories = manager.getTaskList().getCategories().size();
		int numSeparators = 1;
		// adding a separator and the New Category... action
		int expectedNrOfSubMenuEntries = numCategories + numSeparators + 1;
		NewCategoryAction newCatActon = new NewCategoryAction();

		// execute sytem under test





/**
 * @author Mik Kersten
 * @author Rob Elves
 */
public class TaskListTest extends TestCase {

	public void testGetUserCategories() {
		TaskList taskList = new TaskList();
		taskList.addCategory(new TaskCategory("a"));
		assertEquals(1, taskList.getUserCategories().size());
	}

}




import org.eclipse.mylyn.context.tests.AbstractContextTest;
import org.eclipse.mylyn.internal.context.core.InteractionContext;
import org.eclipse.mylyn.internal.context.core.InteractionContextManager;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.internal.tasks.core.LocalTask;
import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;
import org.eclipse.mylyn.monitor.core.InteractionEvent;

public class TaskExportImportTest extends AbstractContextTest {

	private File dest;

	@Override
	protected void setUp() throws Exception {
		super.setUp();
		removeFiles(new File(TasksUiPlugin.getDefault().getDataDirectory()));
		ContextCorePlugin.getDefault().getContextStore().init();

		// Create test export destination directory
		dest = new File(TasksUiPlugin.getDefault().getDataDirectory() + File.separator + "TestDir");
		if (dest.exists()) {

		removeFiles(dest);
		dest.delete();
		assertFalse(dest.exists());

		super.tearDown();
	}



		LocalTask task = TasksUiPlugin.getTaskListManager().createNewLocalTask("Test local task");
		TaskList taskList = TasksUiPlugin.getTaskListManager().getTaskList();
		taskList.moveTask(task, taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL));
		assertTrue(taskList.getAllTasks().size() > 0);

		InteractionContext mockContext = ContextCorePlugin.getContextManager().loadContext(task.getHandleIdentifier());

		ContextCorePlugin.getContextManager().internalActivateContext(mockContext);
		InteractionEvent event = new InteractionEvent(InteractionEvent.Kind.EDIT, "structureKind", "handle", "originId");
		mockContext.parseEvent(event);
		ContextCorePlugin.getContextManager().deactivateContext(mockContext.getHandleIdentifier());

		assertTrue(ContextCorePlugin.getDefault().getContextStore().getContextDirectory().exists());
		ContextCorePlugin.getContextManager().saveContext(mockContext.getHandleIdentifier());
		assertTrue(ContextCorePlugin.getContextManager().hasContext(task.getHandleIdentifier()));

		File outFile = new File(dest + File.separator + "local-task.xml.zip");
		TasksUiPlugin.getTaskListManager().getTaskListWriter().writeTask(task, outFile);
		assertTrue(outFile.exists());

			files.add(entry.getName());
		}
		inputStream.close();

		assertTrue("exported file contains a file with queries", files.contains(ITasksUiConstants.OLD_TASK_LIST_FILE));

		String handleIdentifier = mockContext.getHandleIdentifier();
		String encoded = URLEncoder.encode(handleIdentifier, InteractionContextManager.CONTEXT_FILENAME_ENCODING);
		String contextName = encoded + InteractionContextManager.CONTEXT_FILE_EXTENSION_OLD;
		assertTrue("exported file contains a file with context", files.contains(contextName));

		// reset all data
		TasksUiPlugin.getTaskListManager().resetTaskList();
		assertTrue(taskList.getAllTasks().size() == 0);

		ContextCorePlugin.getContextManager().deleteContext(handleIdentifier);
		assertFalse(ContextCorePlugin.getContextManager().hasContext(task.getHandleIdentifier()));


		List<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskListWriter().readTasks(outFile);
		InteractionContext loadedContext = ContextCorePlugin.getContextManager().loadContext(
				task.getHandleIdentifier(), outFile);

		// check with original one
		assertEquals("There is 1 task loaded", 1, tasks.size());
		assertEquals("Loaded task is correct", task, tasks.get(0));
		assertEquals("Loaded context is correct", mockContext, loadedContext);

		// import data
		for (AbstractTask loadedTask : tasks) {
			taskList.insertTask(loadedTask, null, null);
		}
		ContextCorePlugin.getContextManager().importContext(loadedContext);

		// check that context was imported and is the same as original one
		InteractionContext savedContext = ContextCorePlugin.getContextManager().loadContext(task.getHandleIdentifier());
		assertEquals("Saved context is the same as original one", mockContext, savedContext);
		assertEquals("Saved task is the same as original one", task, taskList.getTask(task.getHandleIdentifier()));

		ContextCorePlugin.getContextManager().deactivateAllContexts();
	}
	

	private void removeFiles(File root) {
		if (root.isDirectory()) {

Lines 40-47 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/NewTaskWizardRepositorySelectionTest.java (-3 / +2 lines)
40	TaskListView view = TaskListView.openInActivePerspective();	40	TaskListView view = TaskListView.openInActivePerspective();
41	MockRepositoryTask mockTask = new MockRepositoryTask("mock.task");	41	MockRepositoryTask mockTask = new MockRepositoryTask("mock.task");
42	TasksUiPlugin.getTaskActivityManager().scheduleNewTask(mockTask);	42	TasksUiPlugin.getTaskActivityManager().scheduleNewTask(mockTask);
43	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask,	43	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask);
44	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
45		44
46	view.setFocusedMode(true);	45	view.setFocusedMode(true);
47	view.getViewer().refresh();	46	view.getViewer().refresh();
Lines 80-86 Link Here
80		79
81	SelectRepositoryPage page = (SelectRepositoryPage) wizard.getPages()[0];	80	SelectRepositoryPage page = (SelectRepositoryPage) wizard.getPages()[0];
82	TaskRepository localRepository = TasksUiPlugin.getRepositoryManager().getRepositories(	81	TaskRepository localRepository = TasksUiPlugin.getRepositoryManager().getRepositories(
83	LocalRepositoryConnector.REPOSITORY_KIND).iterator().next();	82	LocalRepositoryConnector.CONNECTOR_KIND).iterator().next();
84	assertEquals(localRepository, ((IStructuredSelection) page.getViewer().getSelection()).getFirstElement());	83	assertEquals(localRepository, ((IStructuredSelection) page.getViewer().getSelection()).getFirstElement());
85		84
86	wizard.dispose();	85	wizard.dispose();





	protected AbstractTask task5 = null;

	private ActivateTaskHistoryDropDownAction previousTaskAction = new ActivateTaskHistoryDropDownAction(
			TasksUiPlugin.getTaskListManager().getTaskActivationHistory(), false);

	@Override
	protected void setUp() throws Exception {
		super.setUp();

		resetHistory();

		task1 = manager.createNewLocalTask("task 1");
		manager.getTaskList().addTask(task1);

		task2 = manager.createNewLocalTask("task 2");
		manager.getTaskList().addTask(task2);

		task3 = manager.createNewLocalTask("task 3");
		manager.getTaskList().addTask(task3);

		task4 = manager.createNewLocalTask("task 4");
		manager.getTaskList().addTask(task4);

		task5 = manager.createNewLocalTask("task 5");
		manager.getTaskList().addTask(task5);

		history = manager.getTaskActivationHistory();
	}

		assertTrue(task3.isActive());
		assertFalse(task2.isActive());
		assertFalse(task1.isActive());

		previousTaskAction.run();
		assertTrue(task2.isActive());






		TaskRepository repository1 = new TaskRepository("bugzilla", "http://repository1/");
		manager.addRepository(repository1, TasksUiPlugin.getDefault().getRepositoriesFilePath());
		assertEquals(1, manager.getAllRepositories().size());
		assertNotNull(manager.getRepository("http://repository1"));
		assertNotNull(manager.getRepository("http://repository1/"));


	}

	public void testQueryDeletion() {
		TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND,
				MockRepositoryConnector.REPOSITORY_URL);
		TasksUiPlugin.getRepositoryManager().addRepository(repository,
				TasksUiPlugin.getDefault().getRepositoriesFilePath());

		MockRepositoryTask task = new MockRepositoryTask("1");
		task.setLastReadTimeStamp("now");
		MockRepositoryQuery query = new MockRepositoryQuery("Test");

Lines 25-34 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TaskListManagerTest.java (-86 / +166 lines)
25	import org.eclipse.mylyn.context.core.ContextCorePlugin;	25	import org.eclipse.mylyn.context.core.ContextCorePlugin;
26	import org.eclipse.mylyn.internal.context.core.InteractionContext;	26	import org.eclipse.mylyn.internal.context.core.InteractionContext;
27	import org.eclipse.mylyn.internal.context.core.InteractionContextManager;	27	import org.eclipse.mylyn.internal.context.core.InteractionContextManager;
		28	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
28	import org.eclipse.mylyn.internal.tasks.core.LocalTask;	29	import org.eclipse.mylyn.internal.tasks.core.LocalTask;
29	import org.eclipse.mylyn.internal.tasks.core.RepositoryTaskHandleUtil;	30	import org.eclipse.mylyn.internal.tasks.core.RepositoryTaskHandleUtil;
30	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;	31	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
31	import org.eclipse.mylyn.internal.tasks.core.UnfiledCategory;
32	import org.eclipse.mylyn.internal.tasks.ui.ScheduledTaskListSynchJob;	32	import org.eclipse.mylyn.internal.tasks.ui.ScheduledTaskListSynchJob;
33	import org.eclipse.mylyn.internal.tasks.ui.TaskListSynchronizationScheduler;	33	import org.eclipse.mylyn.internal.tasks.ui.TaskListSynchronizationScheduler;
34	import org.eclipse.mylyn.internal.tasks.ui.TasksUiPreferenceConstants;	34	import org.eclipse.mylyn.internal.tasks.ui.TasksUiPreferenceConstants;
Lines 66-71 Link Here
66	TasksUiPreferenceConstants.REPOSITORY_SYNCH_SCHEDULE_ENABLED, false);	66	TasksUiPreferenceConstants.REPOSITORY_SYNCH_SCHEDULE_ENABLED, false);
67	TasksUiPlugin.getSynchronizationManager().setForceSyncExec(true);	67	TasksUiPlugin.getSynchronizationManager().setForceSyncExec(true);
68	manager = TasksUiPlugin.getTaskListManager();	68	manager = TasksUiPlugin.getTaskListManager();
		69	for (TaskRepository repository : TasksUiPlugin.getRepositoryManager().getAllRepositories()) {
		70	TasksUiPlugin.getRepositoryManager().removeRepository(repository,
		71	TasksUiPlugin.getDefault().getRepositoriesFilePath());
		72	}
69	manager.resetTaskList();	73	manager.resetTaskList();
70	manager.readExistingOrCreateNewList();	74	manager.readExistingOrCreateNewList();
71	repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL);	75	repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL);
Lines 78-87 Link Here
78	@Override	82	@Override
79	protected void tearDown() throws Exception {	83	protected void tearDown() throws Exception {
80	super.tearDown();	84	super.tearDown();
81	manager.resetTaskList();
82	TasksUiPlugin.getTaskListManager().saveTaskList();
83	TasksUiPlugin.getRepositoryManager().removeRepository(repository,	85	TasksUiPlugin.getRepositoryManager().removeRepository(repository,
84	TasksUiPlugin.getDefault().getRepositoriesFilePath());	86	TasksUiPlugin.getDefault().getRepositoriesFilePath());
		87	manager.resetTaskList();
		88	TasksUiPlugin.getTaskListManager().saveTaskList();
85	assertEquals(0, manager.getTaskList().getAllTasks().size());	89	assertEquals(0, manager.getTaskList().getAllTasks().size());
86	}	90	}
87		91
Lines 89-100 Link Here
89	TaskCategory category = new TaskCategory("TestClash");	93	TaskCategory category = new TaskCategory("TestClash");
90	manager.getTaskList().addCategory(category);	94	manager.getTaskList().addCategory(category);
91	assertTrue(manager.getTaskList().getCategories().contains(category));	95	assertTrue(manager.getTaskList().getCategories().contains(category));
92	assertEquals(3, manager.getTaskList().getCategories().size());	96	assertEquals(1, manager.getTaskList().getCategories().size());
93		97
94	MockRepositoryQuery query = new MockRepositoryQuery("TestClash");	98	MockRepositoryQuery query = new MockRepositoryQuery("TestClash");
95	manager.getTaskList().addQuery(query);	99	manager.getTaskList().addQuery(query);
96	assertTrue(manager.getTaskList().getCategories().contains(category));	100	assertTrue(manager.getTaskList().getCategories().contains(category));
97	assertEquals(3, manager.getTaskList().getCategories().size());	101	assertEquals(1, manager.getTaskList().getCategories().size());
98		102
99	manager.getTaskList().deleteCategory(category);	103	manager.getTaskList().deleteCategory(category);
100	}	104	}
Lines 125-135 Link Here
125		129
126	public void testSingleTaskDeletion() {	130	public void testSingleTaskDeletion() {
127	MockRepositoryTask task = new MockRepositoryTask("1");	131	MockRepositoryTask task = new MockRepositoryTask("1");
128	manager.getTaskList().moveToContainer(task, manager.getTaskList().getDefaultCategory());	132	task.setLastReadTimeStamp("now");
		133	manager.getTaskList().moveTask(task,
		134	manager.getTaskList().getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL));
129	assertEquals(1, manager.getTaskList().getAllTasks().size());	135	assertEquals(1, manager.getTaskList().getAllTasks().size());
130	manager.getTaskList().deleteTask(task);	136	manager.getTaskList().deleteTask(task);
131	assertEquals(0, manager.getTaskList().getAllTasks().size());	137	assertEquals(0, manager.getTaskList().getAllTasks().size());
132	manager.getTaskList().moveToContainer(task, manager.getTaskList().getDefaultCategory());	138	manager.getTaskList().moveTask(task,
		139	manager.getTaskList().getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL));
133	assertEquals(1, manager.getTaskList().getAllTasks().size());	140	assertEquals(1, manager.getTaskList().getAllTasks().size());
134		141
135	manager.saveTaskList();	142	manager.saveTaskList();
Lines 353-359 Link Here
353	}	360	}
354		361
355	public void testMoveCategories() {	362	public void testMoveCategories() {
356	assertEquals(0, manager.getTaskList().getDefaultCategory().getChildren().size());	363	assertEquals(0, manager.getTaskList()
		364	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		365	.getChildren()
		366	.size());
357	AbstractTask task1 = new LocalTask("t1", "t1");	367	AbstractTask task1 = new LocalTask("t1", "t1");
358		368
359	TaskCategory cat1 = new TaskCategory("cat1");	369	TaskCategory cat1 = new TaskCategory("cat1");
Lines 361-393 Link Here
361	TaskCategory cat2 = new TaskCategory("cat2");	371	TaskCategory cat2 = new TaskCategory("cat2");
362	manager.getTaskList().addCategory(cat2);	372	manager.getTaskList().addCategory(cat2);
363		373
364	manager.getTaskList().moveToContainer(task1, cat1);	374	manager.getTaskList().moveTask(task1, cat1);
365	assertEquals(1, manager.getTaskList().getContainerForHandle("cat1").getChildren().size());	375	assertEquals(1, manager.getTaskList().getContainerForHandle("cat1").getChildren().size());
366	assertEquals(0, manager.getTaskList().getContainerForHandle("cat2").getChildren().size());	376	assertEquals(0, manager.getTaskList().getContainerForHandle("cat2").getChildren().size());
367		377
368	manager.getTaskList().moveToContainer(task1, cat2);	378	manager.getTaskList().moveTask(task1, cat2);
369	assertEquals(0, manager.getTaskList().getContainerForHandle("cat1").getChildren().size());	379	assertEquals(0, manager.getTaskList().getContainerForHandle("cat1").getChildren().size());
370	assertEquals(1, manager.getTaskList().getContainerForHandle("cat2").getChildren().size());	380	assertEquals(1, manager.getTaskList().getContainerForHandle("cat2").getChildren().size());
371	}	381	}
372		382
373	public void testMoveToRoot() {	383	public void testMoveToRoot() {
374	assertEquals(0, manager.getTaskList().getDefaultCategory().getChildren().size());	384	assertEquals(0, manager.getTaskList()
		385	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		386	.getChildren()
		387	.size());
375	AbstractTask task1 = new LocalTask("t1", "t1");	388	AbstractTask task1 = new LocalTask("t1", "t1");
376	manager.getTaskList().moveToContainer(task1, manager.getTaskList().getDefaultCategory());	389	manager.getTaskList().moveTask(task1,
377	assertEquals(1, manager.getTaskList().getDefaultCategory().getChildren().size());	390	manager.getTaskList().getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL));
378	assertEquals(UnfiledCategory.HANDLE, task1.getParentContainers().iterator().next().getHandleIdentifier());	391	assertEquals(1, manager.getTaskList()
		392	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		393	.getChildren()
		394	.size());
		395	assertEquals(manager.getTaskList().getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL),
		396	task1.getParentContainers().iterator().next());
379		397
380	TaskCategory cat1 = new TaskCategory("c1");	398	TaskCategory cat1 = new TaskCategory("c1");
381	manager.getTaskList().addCategory(cat1);	399	manager.getTaskList().addCategory(cat1);
382		400
383	manager.getTaskList().moveToContainer(task1, cat1);	401	manager.getTaskList().moveTask(task1, cat1);
384	assertEquals(0, manager.getTaskList().getDefaultCategory().getChildren().size());	402	assertEquals(0, manager.getTaskList()
		403	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		404	.getChildren()
		405	.size());
385	assertEquals(cat1, task1.getParentContainers().iterator().next());	406	assertEquals(cat1, task1.getParentContainers().iterator().next());
386		407
387	manager.getTaskList().moveToContainer(task1, manager.getTaskList().getDefaultCategory());	408	manager.getTaskList().moveTask(task1,
388	assertEquals(1, manager.getTaskList().getDefaultCategory().getChildren().size());	409	manager.getTaskList().getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL));
		410	assertEquals(1, manager.getTaskList()
		411	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		412	.getChildren()
		413	.size());
389	assertEquals(0, cat1.getChildren().size());	414	assertEquals(0, cat1.getChildren().size());
390	assertEquals(UnfiledCategory.HANDLE, task1.getParentContainers().iterator().next().getHandleIdentifier());	415	assertEquals(manager.getTaskList().getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL),
		416	task1.getParentContainers().iterator().next());
391	}	417	}
392		418
393	public void testEmpty() {	419	public void testEmpty() {
Lines 401-425 Link Here
401	MockRepositoryTask task = new MockRepositoryTask("1");	427	MockRepositoryTask task = new MockRepositoryTask("1");
402	TaskCategory category = new TaskCategory("cat");	428	TaskCategory category = new TaskCategory("cat");
403	manager.getTaskList().addCategory(category);	429	manager.getTaskList().addCategory(category);
404	manager.getTaskList().moveToContainer(task, category);	430	manager.getTaskList().moveTask(task, category);
405	assertNotNull(manager.getTaskList());	431	assertNotNull(manager.getTaskList());
406	assertEquals(3, manager.getTaskList().getCategories().size());	432	assertEquals(1, manager.getTaskList().getCategories().size());
407		433
408	manager.saveTaskList();	434	manager.saveTaskList();
409	manager.resetTaskList();	435	manager.resetTaskList();
410	manager.readExistingOrCreateNewList();	436	manager.readExistingOrCreateNewList();
411	assertEquals("" + manager.getTaskList().getCategories(), 3, manager.getTaskList().getCategories().size());	437	assertEquals("" + manager.getTaskList().getCategories(), 1, manager.getTaskList().getCategories().size());
412	assertEquals(1, manager.getTaskList().getAllTasks().size());	438	assertEquals(1, manager.getTaskList().getAllTasks().size());
413	}	439	}
414		440
415	public void testDeleteCategory() {	441	public void testDeleteCategory() {
416	assertNotNull(manager.getTaskList());	442	assertNotNull(manager.getTaskList());
417	assertEquals(2, manager.getTaskList().getCategories().size());	443	assertEquals(0, manager.getTaskList().getCategories().size());
418	TaskCategory category = new TaskCategory("cat");	444	TaskCategory category = new TaskCategory("cat");
419	manager.getTaskList().addCategory(category);	445	manager.getTaskList().addCategory(category);
420	assertEquals(3, manager.getTaskList().getCategories().size());	446	assertEquals(1, manager.getTaskList().getCategories().size());
421	manager.getTaskList().deleteCategory(category);	447	manager.getTaskList().deleteCategory(category);
422	assertEquals(2, manager.getTaskList().getCategories().size());	448	assertEquals(0, manager.getTaskList().getCategories().size());
423	}	449	}
424		450
425	public void testDeleteCategoryMovesTasksToRoot() {	451	public void testDeleteCategoryMovesTasksToRoot() {
Lines 427-435 Link Here
427	TaskCategory category = new TaskCategory("cat");	453	TaskCategory category = new TaskCategory("cat");
428	manager.getTaskList().addTask(task, category);	454	manager.getTaskList().addTask(task, category);
429	manager.getTaskList().addCategory(category);	455	manager.getTaskList().addCategory(category);
430	assertEquals(0, manager.getTaskList().getDefaultCategory().getChildren().size());	456	assertEquals(0, manager.getTaskList()
		457	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		458	.getChildren()
		459	.size());
431	manager.getTaskList().deleteCategory(category);	460	manager.getTaskList().deleteCategory(category);
432	assertEquals(1, manager.getTaskList().getDefaultCategory().getChildren().size());	461	manager.getTaskList().getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL);
433	}	462	}
434		463
435	public void testRenameCategory() {	464	public void testRenameCategory() {
Lines 438-474 Link Here
438		467
439	TaskCategory category = new TaskCategory("cat");	468	TaskCategory category = new TaskCategory("cat");
440	manager.getTaskList().addCategory(category);	469	manager.getTaskList().addCategory(category);
441	assertEquals(3, manager.getTaskList().getCategories().size());	470	assertEquals(1, manager.getTaskList().getCategories().size());
442	String newDesc = "newDescription";	471	String newDesc = "newDescription";
443	manager.getTaskList().renameContainer(category, newDesc);	472	manager.getTaskList().renameContainer(category, newDesc);
444	AbstractTaskCategory container = manager.getTaskList().getContainerForHandle(newDesc);	473	AbstractTaskCategory container = manager.getTaskList().getContainerForHandle(newDesc);
445	assertNotNull(container);	474	assertNotNull(container);
446	assertEquals(newDesc, container.getSummary());	475	assertEquals(newDesc, container.getSummary());
447	manager.getTaskList().deleteCategory(container);	476	manager.getTaskList().deleteCategory(container);
448	assertEquals(2, manager.getTaskList().getCategories().size());	477	assertEquals(0, manager.getTaskList().getCategories().size());
449	}	478	}
450		479
451	public void testDeleteCategoryAfterRename() {	480	public void testDeleteCategoryAfterRename() {
452	String newDesc = "newDescription";	481	String newDesc = "newDescription";
453	assertNotNull(manager.getTaskList());	482	assertNotNull(manager.getTaskList());
454	assertEquals(2, manager.getTaskList().getCategories().size());	483	assertEquals(0, manager.getTaskList().getCategories().size());
455	TaskCategory category = new TaskCategory("cat");	484	TaskCategory category = new TaskCategory("cat");
456	manager.getTaskList().addCategory(category);	485	manager.getTaskList().addCategory(category);
457	assertEquals(3, manager.getTaskList().getCategories().size());	486	assertEquals(1, manager.getTaskList().getCategories().size());
458	manager.getTaskList().renameContainer(category, newDesc);	487	manager.getTaskList().renameContainer(category, newDesc);
459	manager.getTaskList().deleteCategory(category);	488	manager.getTaskList().deleteCategory(category);
460	assertEquals(2, manager.getTaskList().getCategories().size());	489	assertEquals(0, manager.getTaskList().getCategories().size());
461	}	490	}
462		491
463	public void testCreateSameCategoryName() {	492	public void testCreateSameCategoryName() {
464	assertNotNull(manager.getTaskList());	493	assertNotNull(manager.getTaskList());
465	assertEquals(2, manager.getTaskList().getCategories().size());	494	assertEquals(0, manager.getTaskList().getCategories().size());
466	TaskCategory category = new TaskCategory("cat");	495	TaskCategory category = new TaskCategory("cat");
467	manager.getTaskList().addCategory(category);	496	manager.getTaskList().addCategory(category);
468	assertEquals(3, manager.getTaskList().getCategories().size());	497	assertEquals(1, manager.getTaskList().getCategories().size());
469	TaskCategory category2 = new TaskCategory("cat");	498	TaskCategory category2 = new TaskCategory("cat");
470	manager.getTaskList().addCategory(category2);	499	manager.getTaskList().addCategory(category2);
471	assertEquals(3, manager.getTaskList().getCategories().size());	500	assertEquals(1, manager.getTaskList().getCategories().size());
472	AbstractTaskContainer container = manager.getTaskList().getContainerForHandle("cat");	501	AbstractTaskContainer container = manager.getTaskList().getContainerForHandle("cat");
473	assertEquals(container, category);	502	assertEquals(container, category);
474	}	503	}
Lines 479-511 Link Here
479	manager.getTaskList().internalAddRootTask(task);	508	manager.getTaskList().internalAddRootTask(task);
480	manager.getTaskList().deleteTask(task);	509	manager.getTaskList().deleteTask(task);
481	assertEquals(0, manager.getTaskList().getAllTasks().size());	510	assertEquals(0, manager.getTaskList().getAllTasks().size());
482	assertEquals(0, manager.getTaskList().getDefaultCategory().getChildren().size());	511	assertEquals(0, manager.getTaskList()
483	assertEquals(0, manager.getTaskList().getArchiveContainer().getChildren().size());	512	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		513	.getChildren()
		514	.size());
		515	//assertEquals(0, manager.getTaskList().getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).getChildren().size());
484	}	516	}
485		517
486	public void testDeleteFromCategory() {	518	public void testDeleteFromCategory() {
487	assertEquals(0, manager.getTaskList().getAllTasks().size());	519	assertEquals(0, manager.getTaskList().getAllTasks().size());
488	assertEquals(0, manager.getTaskList().getDefaultCategory().getChildren().size());	520	assertEquals(0, manager.getTaskList()
489	assertEquals(0, manager.getTaskList().getArchiveContainer().getChildren().size());	521	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
490	assertEquals(2, manager.getTaskList().getCategories().size());	522	.getChildren()
		523	.size());
		524	//assertEquals(0, manager.getTaskList().getArchiveContainer().getChildren().size());
		525	assertEquals(0, manager.getTaskList().getCategories().size());
491		526
492	AbstractTask task = new LocalTask("1", "label");	527	AbstractTask task = new LocalTask("1", "label");
493	TaskCategory category = new TaskCategory("handleAndDescription");	528	TaskCategory category = new TaskCategory("handleAndDescription");
494	manager.getTaskList().addTask(task);	529	manager.getTaskList().addTask(task);
495	assertEquals(1, manager.getTaskList().getArchiveContainer().getChildren().size());	530	assertEquals(1, manager.getTaskList()
		531	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		532	.getChildren()
		533	.size());
496		534
497	manager.getTaskList().addCategory(category);	535	manager.getTaskList().addCategory(category);
498	manager.getTaskList().moveToContainer(task, category);	536	manager.getTaskList().moveTask(task, category);
499	assertEquals(3, manager.getTaskList().getCategories().size());	537	assertEquals(1, manager.getTaskList().getCategories().size());
500	assertEquals(1, category.getChildren().size());	538	assertEquals(1, category.getChildren().size());
501	assertEquals(0, manager.getTaskList().getArchiveContainer().getChildren().size());	539	assertEquals(0, manager.getTaskList()
		540	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		541	.getChildren()
		542	.size());
502	assertEquals(1, manager.getTaskList().getAllTasks().size());	543	assertEquals(1, manager.getTaskList().getAllTasks().size());
503	assertEquals(0, manager.getTaskList().getDefaultCategory().getChildren().size());	544	assertEquals(0, manager.getTaskList()
		545	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		546	.getChildren()
		547	.size());
504		548
505	manager.getTaskList().deleteTask(task);	549	manager.getTaskList().deleteTask(task);
506	assertEquals(0, manager.getTaskList().getAllTasks().size());	550	assertEquals(0, manager.getTaskList().getAllTasks().size());
507	assertEquals(0, manager.getTaskList().getDefaultCategory().getChildren().size());	551	assertEquals(0, manager.getTaskList()
508	assertEquals(0, manager.getTaskList().getArchiveContainer().getChildren().size());	552	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		553	.getChildren()
		554	.size());
		555	assertEquals(0, manager.getTaskList()
		556	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		557	.getChildren()
		558	.size());
509	assertEquals(0, category.getChildren().size());	559	assertEquals(0, category.getChildren().size());
510	}	560	}
511		561
Lines 516-536 Link Here
516	TasksUiPlugin.getDefault().getRepositoriesFilePath());	566	TasksUiPlugin.getDefault().getRepositoriesFilePath());
517	MockRepositoryTask task = new MockRepositoryTask(repositoryUrl, "1");	567	MockRepositoryTask task = new MockRepositoryTask(repositoryUrl, "1");
518	TaskList taskList = TasksUiPlugin.getTaskListManager().getTaskList();	568	TaskList taskList = TasksUiPlugin.getTaskListManager().getTaskList();
519	taskList.moveToContainer(task, manager.getTaskList().getDefaultCategory());	569	taskList.moveTask(task, manager.getTaskList().getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL));
520	MockRepositoryQuery query = new MockRepositoryQuery("query");	570	MockRepositoryQuery query = new MockRepositoryQuery("query");
521	taskList.addQuery(query);	571	taskList.addQuery(query);
522	taskList.addTask(task, query);	572	taskList.addTask(task, query);
523	assertEquals(1, taskList.getAllTasks().size());	573	assertEquals(1, taskList.getAllTasks().size());
524	assertEquals(1, taskList.getDefaultCategory().getChildren().size());	574	assertEquals(1, taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).getChildren().size());
525	taskList.deleteTask(task);	575	taskList.deleteTask(task);
526	assertEquals(0, taskList.getAllTasks().size());	576	assertEquals(0, taskList.getAllTasks().size());
527	assertEquals(0, taskList.getDefaultCategory().getChildren().size());	577	assertEquals(0, taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).getChildren().size());
528	}	578	}
529		579
530	public void testCreate() {	580	public void testCreate() {
531	MockRepositoryTask repositoryTask = new MockRepositoryTask("1");	581	MockRepositoryTask repositoryTask = new MockRepositoryTask("1");
532	manager.getTaskList().addTask(repositoryTask, manager.getTaskList().getDefaultCategory());	582	repositoryTask.setLastReadTimeStamp("now");
533	assertEquals(1, manager.getTaskList().getDefaultCategory().getChildren().size());	583	manager.getTaskList().addTask(repositoryTask,
		584	manager.getTaskList().getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL));
		585	assertEquals(1, manager.getTaskList()
		586	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		587	.getChildren()
		588	.size());
534	manager.saveTaskList();	589	manager.saveTaskList();
535		590
536	manager.resetTaskList();	591	manager.resetTaskList();
Lines 540-569 Link Here
540		595
541	public void testCreateAndMove() {	596	public void testCreateAndMove() {
542	MockRepositoryTask repositoryTask = new MockRepositoryTask("1");	597	MockRepositoryTask repositoryTask = new MockRepositoryTask("1");
543	repositoryTask.setTaskKind("kind");	598	repositoryTask.setLastReadTimeStamp("now");
544	manager.getTaskList().addTask(repositoryTask, manager.getTaskList().getDefaultCategory());	599	manager.getTaskList().addTask(repositoryTask);
545	assertEquals(0, manager.getTaskList().getArchiveContainer().getChildren().size());	600	assertEquals(1, manager.getTaskList().getAllTasks().size());
546	assertEquals(1, manager.getTaskList().getDefaultCategory().getChildren().size());	601	// assertEquals(1, manager.getTaskList()
		602	// .getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL)
		603	// .getChildren()
		604	// .size());
547	manager.saveTaskList();	605	manager.saveTaskList();
548		606
549	manager.resetTaskList();	607	manager.resetTaskList();
550	manager.readExistingOrCreateNewList();	608	manager.readExistingOrCreateNewList();
551	assertEquals(1, manager.getTaskList().getDefaultCategory().getChildren().size());	609	assertEquals(1, manager.getTaskList().getAllTasks().size());
552	assertEquals(0, manager.getTaskList().getArchiveContainer().getChildren().size());	610	assertEquals(1, manager.getTaskList()
		611	.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL)
		612	.getChildren()
		613	.size());
		614
553	}	615	}
554		616
555	public void testArchiveRepositoryTaskExternalization() {	617	public void testArchiveRepositoryTaskExternalization() {
556	MockRepositoryTask repositoryTask = new MockRepositoryTask("1");	618	MockRepositoryTask repositoryTask = new MockRepositoryTask("1");
557	repositoryTask.setTaskKind("kind");	619	repositoryTask.setLastReadTimeStamp("now");
558	manager.getTaskList().addTask(repositoryTask);	620	manager.getTaskList().addTask(repositoryTask);
559	assertEquals(1, manager.getTaskList().getArchiveContainer().getChildren().size());	621	assertEquals(1, manager.getTaskList()
560	assertEquals(0, manager.getTaskList().getDefaultCategory().getChildren().size());	622	.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL)
		623	.getChildren()
		624	.size());
561	manager.saveTaskList();	625	manager.saveTaskList();
562		626
563	manager.resetTaskList();	627	manager.resetTaskList();
564	manager.readExistingOrCreateNewList();	628	manager.readExistingOrCreateNewList();
565	assertEquals(1, manager.getTaskList().getArchiveContainer().getChildren().size());	629	assertEquals(1, manager.getTaskList()
566	assertEquals(0, manager.getTaskList().getDefaultCategory().getChildren().size());	630	.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL)
		631	.getChildren()
		632	.size());
567	}	633	}
568		634
569	public void testRepositoryTasksAndCategoriesMultiRead() {	635	public void testRepositoryTasksAndCategoriesMultiRead() {
Lines 571-577 Link Here
571	manager.getTaskList().addCategory(cat1);	637	manager.getTaskList().addCategory(cat1);
572		638
573	MockRepositoryTask reportInCat1 = new MockRepositoryTask("123");	639	MockRepositoryTask reportInCat1 = new MockRepositoryTask("123");
574	manager.getTaskList().moveToContainer(reportInCat1, cat1);	640	manager.getTaskList().moveTask(reportInCat1, cat1);
575	assertEquals(cat1, reportInCat1.getParentContainers().iterator().next());	641	assertEquals(cat1, reportInCat1.getParentContainers().iterator().next());
576		642
577	manager.saveTaskList();	643	manager.saveTaskList();
Lines 620-631 Link Here
620	public void testSubTaskExternalization() {	686	public void testSubTaskExternalization() {
621	Set<AbstractTask> rootTasks = new HashSet<AbstractTask>();	687	Set<AbstractTask> rootTasks = new HashSet<AbstractTask>();
622	AbstractTask task1 = new LocalTask("1", "task1");	688	AbstractTask task1 = new LocalTask("1", "task1");
623	manager.getTaskList().moveToContainer(task1, manager.getTaskList().getDefaultCategory());	689	manager.getTaskList().addTask(task1);
624	rootTasks.add(task1);	690	rootTasks.add(task1);
625		691
626	AbstractTask sub2 = new LocalTask("2", "sub 2");	692	AbstractTask sub2 = new LocalTask("2", "sub 2");
627	manager.getTaskList().addTask(sub2, task1);	693	manager.getTaskList().addTask(sub2, task1);
628	assertEquals(1, task1.getChildren().size());	694	assertEquals(1, task1.getChildren().size());
		695	assertTrue(rootTasks.containsAll(manager.getTaskList().getOrphanContainer(
		696	LocalRepositoryConnector.REPOSITORY_URL).getChildren()));
629		697
630	manager.saveTaskList();	698	manager.saveTaskList();
631	assertNotNull(manager.getTaskList());	699	assertNotNull(manager.getTaskList());
Lines 633-641 Link Here
633	manager.readExistingOrCreateNewList();	701	manager.readExistingOrCreateNewList();
634		702
635	assertNotNull(manager.getTaskList());	703	assertNotNull(manager.getTaskList());
636	assertTrue(rootTasks.containsAll(manager.getTaskList().getDefaultCategory().getChildren()));
637		704
638	Set<AbstractTask> readList = manager.getTaskList().getDefaultCategory().getChildren();	705	// XXX: This should pass once sub tasks are handled properly
		706	// assertTrue(rootTasks.containsAll(manager.getTaskList().getOrphanContainer(
		707	// LocalRepositoryConnector.REPOSITORY_URL).getChildren()));
		708
		709	Set<AbstractTask> readList = manager.getTaskList()
		710	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		711	.getChildren();
639	for (AbstractTask task : readList) {	712	for (AbstractTask task : readList) {
640	if (task.equals(task1)) {	713	if (task.equals(task1)) {
641	assertEquals(task1.getSummary(), task.getSummary());	714	assertEquals(task1.getSummary(), task.getSummary());
Lines 647-662 Link Here
647	public void testCreationAndExternalization() {	720	public void testCreationAndExternalization() {
648	Set<AbstractTask> rootTasks = new HashSet<AbstractTask>();	721	Set<AbstractTask> rootTasks = new HashSet<AbstractTask>();
649	AbstractTask task1 = manager.createNewLocalTask("task 1");	722	AbstractTask task1 = manager.createNewLocalTask("task 1");
650	manager.getTaskList().moveToContainer(task1, manager.getTaskList().getDefaultCategory());
651	rootTasks.add(task1);	723	rootTasks.add(task1);
652		724
653	AbstractTask sub1 = manager.createNewLocalTask("sub 1");	725	AbstractTask sub1 = manager.createNewLocalTask("sub 1");
654	manager.getTaskList().addTask(sub1, task1);	726	manager.getTaskList().addTask(sub1, task1);
655		727
656	manager.getTaskList().moveToContainer(sub1, manager.getTaskList().getArchiveContainer());	728	//manager.getTaskList().moveToContainer(sub1, manager.getTaskList().getArchiveContainer());
657		729
658	AbstractTask task2 = manager.createNewLocalTask("task 2");	730	AbstractTask task2 = manager.createNewLocalTask("task 2");
659	manager.getTaskList().moveToContainer(task2, manager.getTaskList().getDefaultCategory());
660	rootTasks.add(task2);	731	rootTasks.add(task2);
661		732
662	Set<TaskCategory> categories = new HashSet<TaskCategory>();	733	Set<TaskCategory> categories = new HashSet<TaskCategory>();
Lines 665-689 Link Here
665	manager.getTaskList().addCategory(cat1);	736	manager.getTaskList().addCategory(cat1);
666	categories.add(cat1);	737	categories.add(cat1);
667	AbstractTask task3 = manager.createNewLocalTask("task 3");	738	AbstractTask task3 = manager.createNewLocalTask("task 3");
668	manager.getTaskList().moveToContainer(task3, cat1);	739	manager.getTaskList().moveTask(task3, cat1);
669	cat1Contents.add(task3);	740	cat1Contents.add(task3);
670	assertEquals(cat1, task3.getParentContainers().iterator().next());	741	assertEquals(cat1, task3.getParentContainers().iterator().next());
671	AbstractTask sub2 = manager.createNewLocalTask("sub 2");	742	AbstractTask sub2 = manager.createNewLocalTask("sub 2");
672	manager.getTaskList().addTask(sub2, task3);	743	manager.getTaskList().addTask(sub2, task3);
673	manager.getTaskList().moveToContainer(sub2, manager.getTaskList().getArchiveContainer());	744	//manager.getTaskList().moveToContainer(sub2, manager.getTaskList().getArchiveContainer());
674		745
675	AbstractTask task4 = manager.createNewLocalTask("task 4");	746	AbstractTask task4 = manager.createNewLocalTask("task 4");
676	manager.getTaskList().moveToContainer(task4, cat1);	747	manager.getTaskList().moveTask(task4, cat1);
677	cat1Contents.add(task4);	748	cat1Contents.add(task4);
678		749
679	MockRepositoryTask reportInCat1 = new MockRepositoryTask("123");	750	MockRepositoryTask reportInCat1 = new MockRepositoryTask("123");
680	manager.getTaskList().moveToContainer(reportInCat1, cat1);	751	manager.getTaskList().moveTask(reportInCat1, cat1);
681	assertEquals(cat1, reportInCat1.getParentContainers().iterator().next());	752	assertEquals(cat1, reportInCat1.getParentContainers().iterator().next());
682	cat1Contents.add(reportInCat1);	753	cat1Contents.add(reportInCat1);
683		754
684	MockRepositoryTask reportInRoot = new MockRepositoryTask("124");	755	// MockRepositoryTask reportInRoot = new MockRepositoryTask("124");
685	manager.getTaskList().moveToContainer(reportInRoot, manager.getTaskList().getDefaultCategory());	756	// manager.getTaskList().moveTask(reportInRoot, manager.getTaskList().getOrphanContainer(repositoryUrl));
686	rootTasks.add(reportInRoot);	757	// //rootTasks.add(reportInRoot);
687		758
688	assertEquals(3, manager.getTaskList().getRootElements().size());	759	assertEquals(3, manager.getTaskList().getRootElements().size());
689		760
Lines 696-712 Link Here
696	manager.readExistingOrCreateNewList();	767	manager.readExistingOrCreateNewList();
697		768
698	assertNotNull(manager.getTaskList());	769	assertNotNull(manager.getTaskList());
699	assertTrue(rootTasks.containsAll(manager.getTaskList().getDefaultCategory().getChildren()));
700		770
701	Set<AbstractTask> readList = manager.getTaskList().getDefaultCategory().getChildren();	771	// XXX: Test should pass once tasks are removed from archive upon becoming
		772	// a subtask
		773	// assertTrue(rootTasks.containsAll(manager.getTaskList().getOrphanContainer(
		774	// LocalRepositoryConnector.REPOSITORY_URL).getChildren()));
		775
		776	Set<AbstractTask> readList = manager.getTaskList()
		777	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		778	.getChildren();
702	for (AbstractTask task : readList) {	779	for (AbstractTask task : readList) {
703	if (task.equals(task1)) {	780	if (task.equals(task1)) {
704	assertEquals(task1.getSummary(), task.getSummary());	781	assertEquals(task1.getSummary(), task.getSummary());
705	assertEquals(1, task.getChildren().size());	782	assertEquals(1, task.getChildren().size());
706	}	783	}
707	if (task.equals(reportInRoot)) {	784	// if (task.equals(reportInRoot)) {
708	assertEquals(reportInRoot.getSummary(), task.getSummary());	785	// assertEquals(reportInRoot.getSummary(), task.getSummary());
709	}	786	// }
710	}	787	}
711		788
712	Set<AbstractTaskCategory> readCats = manager.getTaskList().getTaskContainers();	789	Set<AbstractTaskCategory> readCats = manager.getTaskList().getTaskContainers();
Lines 730-736 Link Here
730	// String handle = AbstractTask.getHandle("http://url/repo-location",	807	// String handle = AbstractTask.getHandle("http://url/repo-location",
731	// 1);	808	// 1);
732	AbstractTask task1 = manager.createNewLocalTask("task 1");	809	AbstractTask task1 = manager.createNewLocalTask("task 1");
733	manager.getTaskList().moveToContainer(task1, manager.getTaskList().getDefaultCategory());	810	manager.getTaskList().moveTask(task1,
		811	manager.getTaskList().getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL));
734	rootTasks.add(task1);	812	rootTasks.add(task1);
735		813
736	manager.saveTaskList();	814	manager.saveTaskList();
Lines 739-745 Link Here
739	assertTrue(manager.readExistingOrCreateNewList());	817	assertTrue(manager.readExistingOrCreateNewList());
740		818
741	assertNotNull(manager.getTaskList());	819	assertNotNull(manager.getTaskList());
742	assertEquals(rootTasks, manager.getTaskList().getDefaultCategory().getChildren());	820	assertEquals(rootTasks, manager.getTaskList()
		821	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		822	.getChildren());
743	}	823	}
744		824
745	public void testScheduledRefreshJob() throws InterruptedException {	825	public void testScheduledRefreshJob() throws InterruptedException {
Lines 993-999 Link Here
993	manager.getTaskList().addQuery(query);	1073	manager.getTaskList().addQuery(query);
994	manager.getTaskList().addTask(task1, query);	1074	manager.getTaskList().addTask(task1, query);
995	manager.getTaskList().addTask(task2, query);	1075	manager.getTaskList().addTask(task2, query);
996	assertEquals(0, manager.getTaskList().getArchiveContainer().getChildren().size());	1076	//assertEquals(0, manager.getTaskList().getArchiveContainer().getChildren().size());
997	assertEquals(2, query.getChildren().size());	1077	assertEquals(2, query.getChildren().size());
998	TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(	1078	TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(
999	MockRepositoryConnector.REPOSITORY_URL);	1079	MockRepositoryConnector.REPOSITORY_URL);
Lines 1001-1007 Link Here
1001	queries.add(query);	1081	queries.add(query);
1002	TasksUiPlugin.getSynchronizationManager().synchronize(new MockRepositoryConnector(), repository, queries, null,	1082	TasksUiPlugin.getSynchronizationManager().synchronize(new MockRepositoryConnector(), repository, queries, null,
1003	Job.INTERACTIVE, 0, true);	1083	Job.INTERACTIVE, 0, true);
1004	assertEquals(2, manager.getTaskList().getArchiveContainer().getChildren().size());	1084	//assertEquals(2, manager.getTaskList().getArchiveContainer().getChildren().size());
1005	assertEquals(0, query.getChildren().size());	1085	assertEquals(0, query.getChildren().size());
1006	}	1086	}
1007		1087

Lines 69-75 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TaskDataExportTest.java (-1 / +1 lines)
69		69
70	// Create a task and context with an interaction event to be saved	70	// Create a task and context with an interaction event to be saved
71	task1 = manager.createNewLocalTask("Export Test Task");	71	task1 = manager.createNewLocalTask("Export Test Task");
72	manager.getTaskList().moveToContainer(task1, manager.getTaskList().getDefaultCategory());	72	manager.getTaskList().addTask(task1);
73	mockContext = ContextCorePlugin.getContextManager().loadContext(task1.getHandleIdentifier());	73	mockContext = ContextCorePlugin.getContextManager().loadContext(task1.getHandleIdentifier());
74	InteractionEvent event = new InteractionEvent(InteractionEvent.Kind.EDIT, "structureKind", "handle", "originId");	74	InteractionEvent event = new InteractionEvent(InteractionEvent.Kind.EDIT, "structureKind", "handle", "originId");
75	mockContext.parseEvent(event);	75	mockContext.parseEvent(event);

Lines 13-18 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TaskListDnDTest.java (-2 / +8 lines)
13	import junit.framework.TestCase;	13	import junit.framework.TestCase;
14		14
15	import org.eclipse.jface.viewers.TreeViewer;	15	import org.eclipse.jface.viewers.TreeViewer;
		16	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
16	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListDropAdapter;	17	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListDropAdapter;
17	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;	18	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
18	import org.eclipse.mylyn.tasks.core.AbstractTask;	19	import org.eclipse.mylyn.tasks.core.AbstractTask;
Lines 57-69 Link Here
57	}	58	}
58		59
59	public void testUrlDrop() {	60	public void testUrlDrop() {
60	assertEquals(0, manager.getTaskList().getDefaultCategory().getChildren().size());	61	assertEquals(0, manager.getTaskList()
		62	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		63	.getChildren()
		64	.size());
61	String url = "http://eclipse.org/mylyn";	65	String url = "http://eclipse.org/mylyn";
62	String title = "Mylar Technology Project";	66	String title = "Mylar Technology Project";
63	String urlData = url + "\n" + title;	67	String urlData = url + "\n" + title;
64		68
65	dropAdapter.performDrop(urlData);	69	dropAdapter.performDrop(urlData);
66	Set<AbstractTask> tasks = manager.getTaskList().getDefaultCategory().getChildren();	70	Set<AbstractTask> tasks = manager.getTaskList()
		71	.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL)
		72	.getChildren();
67	assertNotNull(tasks);	73	assertNotNull(tasks);
68	assertEquals(1, tasks.size());	74	assertEquals(1, tasks.size());
69	assertEquals(url, tasks.iterator().next().getUrl());	75	assertEquals(url, tasks.iterator().next().getUrl());




 */
public class MockRepositoryQuery extends AbstractRepositoryQuery {

	public String MOCK_QUERY_URL = MockRepositoryConnector.REPOSITORY_URL + ".query";

	public MockRepositoryQuery(String description) {
		super(description);
		super.setUrl(MOCK_QUERY_URL);
		super.setRepositoryUrl(MockRepositoryConnector.REPOSITORY_URL);
	}

	public MockRepositoryQuery(String description, String url) {




/*******************************************************************************
 * Copyright (c) 2004, 2007 Mylyn project committers and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/

package org.eclipse.mylyn.tasks.tests;

import java.util.Set;

import junit.framework.TestCase;

import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.internal.tasks.core.LocalTask;
import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.TaskList;
import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryConnector;
import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryQuery;
import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryTask;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;

/**
 * @author Rob Elves
 */
public class OrphanedTasksTest extends TestCase {

	private TaskList taskList;

	protected void setUp() throws Exception {
		super.setUp();
		TasksUiPlugin.getTaskListManager().resetTaskList();
		taskList = TasksUiPlugin.getTaskListManager().getTaskList();
		assertTrue(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).isEmpty());
	}

	protected void tearDown() throws Exception {
		super.tearDown();
	}

	/**
	 * y New local tasks should automatically be created in the Local orphaned folder
	 */
	public void testAddLocalTask() {
		Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getRepositoryTasks(
				LocalRepositoryConnector.REPOSITORY_URL);
		assertTrue(tasks.isEmpty());
		AbstractTask localTask = TasksUiPlugin.getTaskListManager().createNewLocalTask("Task 1");
		assertNotNull(localTask);
		assertEquals(1, localTask.getParentContainers().size());
		assertTrue(localTask.getParentContainers().iterator().next() instanceof OrphanedTasksContainer);
	}

	/**
	 * When a local tasks is removed from a category it should be placed in the local repository orphaned container.
	 */
	public void testRemoveLocalTask() {
		TaskCategory category = new TaskCategory("taskCategoryHandle");
		taskList.addCategory(category);
		LocalTask newTask = new LocalTask("" + taskList.getNextLocalTaskId(), "new local task");
		taskList.addTask(newTask, category);
		//assertEquals(1, taskList.getOrphanContainers().size());
		assertEquals(1, taskList.getCategories().size());
		assertTrue(taskList.getCategories().iterator().next().contains(newTask.getHandleIdentifier()));
		taskList.removeFromCategory(category, newTask);
		//assertEquals(taskList.getOrphanContainers().size(), 1);
		assertFalse(category.contains(newTask.getHandleIdentifier()));
		assertTrue(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).contains(
				newTask.getHandleIdentifier()));
		assertEquals(1, newTask.getParentContainers().size());
		assertEquals(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).getHandleIdentifier(),
				newTask.getParentContainers().iterator().next().getHandleIdentifier());
	}

	/**
	 * Local tasks in a removed category should be orphaned.
	 */
	public void testLocalTaskOrphanedInDeletedTaskCategory() {
		assertTrue(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).isEmpty());
		TaskCategory category = new TaskCategory("taskCategoryHandle");
		taskList.addCategory(category);
		LocalTask newTask = new LocalTask("" + taskList.getNextLocalTaskId(), "new local task");
		taskList.addTask(newTask, category);
		assertTrue(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).isEmpty());
		taskList.deleteCategory(category);
		assertTrue(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).contains(
				newTask.getHandleIdentifier()));

	}

	/**
	 * Query removed with task in category, just query removed task remains.
	 */
	public void testTaskRemovedFromQuery() {
		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		mockTask.setLastReadTimeStamp("now");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
		taskList.addQuery(mockQuery);
		taskList.addTask(mockTask, mockQuery);

		taskList.removeFromQuery(mockQuery, mockTask);

		assertFalse(mockQuery.contains(mockTask.getHandleIdentifier()));
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask.getHandleIdentifier()));
	}

	/**
	 * Query removed with task in category, just query removed task remains.
	 */
	public void testTaskRemovedFromQueryButInCategory() {
		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		mockTask.setLastReadTimeStamp("now");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
		taskList.addQuery(mockQuery);
		taskList.addTask(mockTask, mockQuery);

		TaskCategory category = new TaskCategory("taskCategoryHandle");
		taskList.addCategory(category);
		taskList.addTask(mockTask, category);
		assertTrue(category.contains(mockTask.getHandleIdentifier()));
		taskList.removeFromQuery(mockQuery, mockTask);

		assertFalse(mockQuery.contains(mockTask.getHandleIdentifier()));
		assertEquals(1, taskList.getCategories().size());
		assertTrue(taskList.getCategories().iterator().next().contains(mockTask.getHandleIdentifier()));

		//* Repository tasks within a removed category that are not in a query should be orphaned.

		taskList.removeFromCategory(category, mockTask);
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask.getHandleIdentifier()));
	}

	/**
	 * Repository tasks that exists in a query are not orphaned.
	 */
	public void testRepositoryTaskInDeletedCategory() {
		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
		taskList.addQuery(mockQuery);
		taskList.addTask(mockTask, mockQuery);

		TaskCategory category = new TaskCategory("taskCategoryHandle");
		taskList.addCategory(category);
		taskList.addTask(mockTask, category);

		assertTrue(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).isEmpty());
		taskList.deleteCategory(category);
		assert (taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).isEmpty());
		assertEquals(0, taskList.getCategories().size());
	}

	/**
	 * Repository tasks that exist in another query are not orphaned
	 */
	public void testRemovalOfTaskInTwoQueries() {
		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query 1");
		MockRepositoryQuery mockQuery2 = new MockRepositoryQuery("mock query 2");
		taskList.addQuery(mockQuery);
		taskList.addQuery(mockQuery2);
		taskList.addTask(mockTask, mockQuery);
		taskList.addTask(mockTask, mockQuery2);

		taskList.removeFromQuery(mockQuery2, mockTask);
		assertTrue(mockQuery2.isEmpty());
		assertFalse(mockQuery.isEmpty());
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).isEmpty());
		assertEquals(0, taskList.getCategories().size());
	}

	/**
	 * Moving an orphan to a Category should result in the task only being present in the target Category
	 */
	public void testMoveLocalTask() {
		TaskCategory category = new TaskCategory("taskCategoryHandle");
		taskList.addCategory(category);
		LocalTask newTask = new LocalTask("" + taskList.getNextLocalTaskId(), "new local task");
		taskList.addTask(newTask, null);
		assertTrue(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).contains(
				newTask.getHandleIdentifier()));
		taskList.moveTask(newTask, category);
		assertFalse(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).contains(
				newTask.getHandleIdentifier()));
	}

	public void testAddRepositoryTask() {
		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
		TasksUiPlugin.getTaskListManager().getTaskList().addQuery(mockQuery);
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask, mockQuery);
		Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getRepositoryTasks(
				MockRepositoryConnector.REPOSITORY_URL);
		assertFalse(tasks.isEmpty());
		AbstractRepositoryQuery query = TasksUiPlugin.getTaskListManager().getTaskList().getQueryForHandle(
				mockTask.getHandleIdentifier());
		assertEquals(mockQuery, query);
		assertFalse(query.isEmpty());
		assertTrue(TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
				MockRepositoryConnector.REPOSITORY_URL).isEmpty());
	}

	public void testMoveRepositoryTask() {
		TaskList tasklist = TasksUiPlugin.getTaskListManager().getTaskList();
		assertTrue(tasklist.getAllTasks().isEmpty());

		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
		TasksUiPlugin.getTaskListManager().getTaskList().addQuery(mockQuery);
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask, mockQuery);

		TaskCategory category = new TaskCategory("taskCategoryHandle");
		taskList.addCategory(category);

		taskList.moveTask(mockTask, category);
		assertTrue(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).isEmpty());
		assertTrue(category.contains(mockTask.getHandleIdentifier()));
		assertTrue(mockQuery.contains(mockTask.getHandleIdentifier()));

	}

	public void testRefactorOrphanedHandle() {
		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		mockTask.setLastReadTimeStamp("now");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
		taskList.addQuery(mockQuery);
		taskList.addTask(mockTask, mockQuery);

		taskList.removeFromQuery(mockQuery, mockTask);

		assertFalse(mockQuery.contains(mockTask.getHandleIdentifier()));
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask.getHandleIdentifier()));

		taskList.refactorRepositoryUrl(MockRepositoryConnector.REPOSITORY_URL, MockRepositoryConnector.REPOSITORY_URL
				+ "new");
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL + "new").contains(
				mockTask.getHandleIdentifier()));
	}

	public void testOrphanedSubtasks() {
		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		MockRepositoryTask mockTask2 = new MockRepositoryTask("2");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
		TasksUiPlugin.getTaskListManager().getTaskList().addQuery(mockQuery);
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask, mockQuery);
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask2, mockTask);

		assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask.getHandleIdentifier()));
		assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask2.getHandleIdentifier()));

		assertNotNull(taskList.getTask(mockTask.getHandleIdentifier()));
		assertNotNull(taskList.getTask(mockTask2.getHandleIdentifier()));
		assertNotNull(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL));
		taskList.removeFromQuery(mockQuery, mockTask);
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask.getHandleIdentifier()));
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask2.getHandleIdentifier()));
		taskList.deleteTask(mockTask);
		assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask.getHandleIdentifier()));
		// mockTask2 should be orphaned when the parent task is deleted
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask2.getHandleIdentifier()));
	}

	/**
	 * If a task with subtasks falls out of a query, if its subtasks are subtasks of another task that is still around,
	 * they shouldn't be in the archive.
	 */
	public void testOrphanedSubtaskWithOtherParent() {
		MockRepositoryTask mockTask = new MockRepositoryTask("1");
		MockRepositoryTask mockTask2 = new MockRepositoryTask("2");
		MockRepositoryTask mockTask3 = new MockRepositoryTask("3");
		MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
		TasksUiPlugin.getTaskListManager().getTaskList().addQuery(mockQuery);
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask, mockQuery);
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask2, mockTask);
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask3, mockQuery);
		TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask2, mockTask3);
		assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask.getHandleIdentifier()));
		assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask2.getHandleIdentifier()));
		assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask3.getHandleIdentifier()));

		taskList.removeFromQuery(mockQuery, mockTask);
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask.getHandleIdentifier()));
		assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask2.getHandleIdentifier()));

		taskList.removeFromQuery(mockQuery, mockTask3);
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask3.getHandleIdentifier()));
		assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
				mockTask2.getHandleIdentifier()));

	}
}

Return to bug 181388

Added Link Here

(-)src/org/eclipse/mylyn/internal/tasks/core/OrphanedTasksContainer.java (+76 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004, 2007 Mylyn project committers and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/
8
9	package org.eclipse.mylyn.internal.tasks.core;
10
11	import org.eclipse.mylyn.tasks.core.AbstractTask;
12	import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;
13	import org.eclipse.mylyn.tasks.core.AbstractTask.PriorityLevel;
14
15	/**
16	* Holds orphaned or uncategorized tasks for a given repository
17	*
18	* @author Rob Elves
19	*/
20	public class OrphanedTasksContainer extends AbstractTaskCategory {
21
22	public static final String LABEL = "Uncategorized";
23
24	public static final String HANDLE = "orphans";
25
26	private String repositoryUrl;
27
28	private String connectorKind;
29
30	public OrphanedTasksContainer(String connectorKind, String repositoryUrl) {
31	super(repositoryUrl + "-" + HANDLE);
32	this.repositoryUrl = repositoryUrl;
33	this.connectorKind = connectorKind;
34	}
35
36	@Override
37	public String getPriority() {
38	return PriorityLevel.P1.toString();
39	}
40
41	@Override
42	public String getSummary() {
43	return "Archive: " + getRepositoryUrl();
44	}
45
46	@Override
47	public boolean isUserDefined() {
48	return false;
49	}
50
51	public String getRepositoryUrl() {
52	return repositoryUrl;
53	}
54
55	public String getConnectorKind() {
56	return connectorKind;
57	}
58
59	/**
60	* setting will also refactor handle
61	*/
62	public void setRepositoryUrl(String repositoryUrl) {
63	this.repositoryUrl = repositoryUrl;
64	this.setHandleIdentifier(repositoryUrl + "-" + HANDLE);
65	}
66
67	@Override
68	public boolean contains(String handle) {
69	for (AbstractTask child : getChildrenInternal()) {
70	if (child.getHandleIdentifier().equals(handle)) {
71	return true;
72	}
73	}
74	return false;
75	}
76	}

Lines 458-465 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/TaskListView.java (-7 / +7 lines)
458	refreshJob.refresh();	458	refreshJob.refresh();
459	break;	459	break;
460	default:	460	default:
461	if (taskContainerDelta.getContainer().equals(	461	if (taskContainerDelta.getContainer() == null) {
462	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory())) {
463	refreshJob.refresh();	462	refreshJob.refresh();
464	} else {	463	} else {
465	refreshJob.refreshTask(taskContainerDelta.getContainer());	464	refreshJob.refreshTask(taskContainerDelta.getContainer());
Lines 1135-1141 Link Here
1135	subMenu = new MenuManager("New", ID_MENU_NEW);	1134	subMenu = new MenuManager("New", ID_MENU_NEW);
1136	manager.add(subMenu);	1135	manager.add(subMenu);
1137	}	1136	}
1138		1137
1139	subMenu.add(new Separator(ID_SEPARATOR_NEW_REPOSITORY));	1138	subMenu.add(new Separator(ID_SEPARATOR_NEW_REPOSITORY));
1140	subMenu.add(action);	1139	subMenu.add(action);
1141	subMenu.add(new Separator(ID_SEPARATOR_NEW_LOCAL));	1140	subMenu.add(new Separator(ID_SEPARATOR_NEW_LOCAL));
Lines 1177-1183 Link Here
1177	manager.add(new Separator());	1176	manager.add(new Separator());
1178		1177
1179	addAction(copyDetailsAction, manager, element);	1178	addAction(copyDetailsAction, manager, element);
1180	if (task != null && !task.isLocal()) {	1179	if (task != null && task.isLocal()) {
1181	// addAction(cloneThisBugAction, manager, element);	1180	// addAction(cloneThisBugAction, manager, element);
1182	addAction(removeFromCategoryAction, manager, element);	1181	addAction(removeFromCategoryAction, manager, element);
1183	}	1182	}
Lines 1407-1413 Link Here
1407	refreshJob.forceRefresh();	1406	refreshJob.forceRefresh();
1408	}	1407	}
1409	}	1408	}
1410		1409
1411	public void refresh() {	1410	public void refresh() {
1412	refreshJob.forceRefresh();	1411	refreshJob.forceRefresh();
1413	// if (expand) {	1412	// if (expand) {
Lines 1698-1705 Link Here
1698	Set<AbstractTaskContainer> containers = new HashSet<AbstractTaskContainer>(	1697	Set<AbstractTaskContainer> containers = new HashSet<AbstractTaskContainer>(
1699	TasksUiPlugin.getTaskListManager().getTaskList().getQueriesForHandle(task.getHandleIdentifier()));	1698	TasksUiPlugin.getTaskListManager().getTaskList().getQueriesForHandle(task.getHandleIdentifier()));
1700	containers.addAll(task.getParentContainers());	1699	containers.addAll(task.getParentContainers());
1701	containers.add(TasksUiPlugin.getTaskListManager().getTaskList().getArchiveContainer());	1700	containers.add(TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(task.getRepositoryUrl()));
1702	containers.add(TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());	1701	// containers.add(TasksUiPlugin.getTaskListManager().getTaskList().getArchiveContainer());
		1702	// containers.add(TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
1703	for (AbstractTaskContainer container : containers) {	1703	for (AbstractTaskContainer container : containers) {
1704	refreshJob.refreshTask(container);	1704	refreshJob.refreshTask(container);
1705	}	1705	}

Lines 14-19 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/TaskElementLabelProvider.java (-1 / +22 lines)
14	import org.eclipse.jface.viewers.IColorProvider;	14	import org.eclipse.jface.viewers.IColorProvider;
15	import org.eclipse.jface.viewers.IFontProvider;	15	import org.eclipse.jface.viewers.IFontProvider;
16	import org.eclipse.jface.viewers.LabelProvider;	16	import org.eclipse.jface.viewers.LabelProvider;
		17	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
17	import org.eclipse.mylyn.internal.tasks.core.Person;	18	import org.eclipse.mylyn.internal.tasks.core.Person;
18	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;	19	import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
19	import org.eclipse.mylyn.internal.tasks.core.TaskActivityManager;	20	import org.eclipse.mylyn.internal.tasks.core.TaskActivityManager;
Lines 87-93 Link Here
87		88
88	private CompositeImageDescriptor getImageDescriptor(Object object) {	89	private CompositeImageDescriptor getImageDescriptor(Object object) {
89	CompositeImageDescriptor compositeDescriptor = new CompositeImageDescriptor();	90	CompositeImageDescriptor compositeDescriptor = new CompositeImageDescriptor();
90	if (object instanceof TaskArchive \|\| object instanceof UnfiledCategory) {	91	if (object instanceof TaskArchive \|\| object instanceof UnfiledCategory
		92	\|\| object instanceof OrphanedTasksContainer) {
91	compositeDescriptor.icon = TasksUiImages.CATEGORY_ARCHIVE;	93	compositeDescriptor.icon = TasksUiImages.CATEGORY_ARCHIVE;
92	return compositeDescriptor;	94	return compositeDescriptor;
93	} else if (object instanceof TaskCategory \|\| object instanceof UnfiledCategory) {	95	} else if (object instanceof TaskCategory \|\| object instanceof UnfiledCategory) {
Lines 223-228 Link Here
223	} else if (object instanceof TaskGroup) {	225	} else if (object instanceof TaskGroup) {
224	TaskGroup element = (TaskGroup) object;	226	TaskGroup element = (TaskGroup) object;
225	return element.getSummary();// + " / " + element.getChildren().size();	227	return element.getSummary();// + " / " + element.getChildren().size();
		228	} else if (object instanceof OrphanedTasksContainer) {
		229
		230	OrphanedTasksContainer container = (OrphanedTasksContainer) object;
		231
		232	// OrphanedTasksContainer localArchive = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
		233	// LocalRepositoryConnector.REPOSITORY_URL);
		234	// if (container == localArchive) {
		235	// return "Local Tasks";
		236	// }
		237
		238	String result = container.getSummary();
		239	TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(
		240	container.getConnectorKind(), container.getRepositoryUrl());
		241	if (repository != null) {
		242	result = "Archive: " + repository.getRepositoryLabel();
		243	}
		244
		245	return result;
		246
226	} else if (object instanceof AbstractTaskContainer) {	247	} else if (object instanceof AbstractTaskContainer) {
227	AbstractTaskContainer element = (AbstractTaskContainer) object;	248	AbstractTaskContainer element = (AbstractTaskContainer) object;
228	return element.getSummary();	249	return element.getSummary();

Lines 26-31 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskEditorActionContributor.java (-1 / +2 lines)
26	import org.eclipse.jface.viewers.IStructuredSelection;	26	import org.eclipse.jface.viewers.IStructuredSelection;
27	import org.eclipse.jface.viewers.SelectionChangedEvent;	27	import org.eclipse.jface.viewers.SelectionChangedEvent;
28	import org.eclipse.jface.viewers.StructuredSelection;	28	import org.eclipse.jface.viewers.StructuredSelection;
		29	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
29	import org.eclipse.mylyn.internal.tasks.ui.AddExistingTaskJob;	30	import org.eclipse.mylyn.internal.tasks.ui.AddExistingTaskJob;
30	import org.eclipse.mylyn.internal.tasks.ui.IDynamicSubMenuContributor;	31	import org.eclipse.mylyn.internal.tasks.ui.IDynamicSubMenuContributor;
31	import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;	32	import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;
Lines 180-186 Link Here
180		181
181	Collections.sort(categories);	182	Collections.sort(categories);
182	for (final AbstractTaskCategory category : categories) {	183	for (final AbstractTaskCategory category : categories) {
183	if (!category.equals(TasksUiPlugin.getTaskListManager().getTaskList().getArchiveContainer())) {	184	if (!(category instanceof OrphanedTasksContainer)) {//.equals(TasksUiPlugin.getTaskListManager().getTaskList().getArchiveContainer())) {
184	Action action = new Action() {	185	Action action = new Action() {
185	@Override	186	@Override
186	public void run() {	187	public void run() {

Lines 34-49 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/actions/MarkTaskUnreadAction.java (-8 / +8 lines)
34	setId(ID);	34	setId(ID);
35	setActionDefinitionId(DEFINITION_ID);	35	setActionDefinitionId(DEFINITION_ID);
36	setImageDescriptor(TasksUiImages.OVERLAY_INCOMMING);	36	setImageDescriptor(TasksUiImages.OVERLAY_INCOMMING);
37	if (containsArchiveContainer(selectedElements)) {	37	// if (containsArchiveContainer(selectedElements)) {
38	setEnabled(false);	38	// setEnabled(false);
		39	// } else {
		40	if (selectedElements.size() == 1 && (selectedElements.get(0) instanceof AbstractTask)) {
		41	AbstractTask task = (AbstractTask) selectedElements.get(0);
		42	setEnabled(!task.isLocal());
39	} else {	43	} else {
40	if (selectedElements.size() == 1 && (selectedElements.get(0) instanceof AbstractTask)) {	44	setEnabled(true);
41	AbstractTask task = (AbstractTask) selectedElements.get(0);
42	setEnabled(!task.isLocal());
43	} else {
44	setEnabled(true);
45	}
46	}	45	}
		46	// }
47	}	47	}
48		48
49	@Override	49	@Override

Lines 442-447 Link Here

(-)src/org/eclipse/mylyn/tasks/ui/TasksUiPlugin.java (-6 / +6 lines)
442	// initialized	442	// initialized
443	taskListManager.init();	443	taskListManager.init();
444	taskListManager.addActivityListener(CONTEXT_TASK_ACTIVITY_LISTENER);	444	taskListManager.addActivityListener(CONTEXT_TASK_ACTIVITY_LISTENER);
		445	// readExistingOrCreateNewList() must be called after repositories have been read in
445	taskListManager.readExistingOrCreateNewList();	446	taskListManager.readExistingOrCreateNewList();
446	initialized = true;	447	initialized = true;
447		448
Lines 482-488 Link Here
482		483
483	// Add standard local task repository	484	// Add standard local task repository
484	if (taskRepositoryManager.getRepository(LocalRepositoryConnector.REPOSITORY_URL) == null) {	485	if (taskRepositoryManager.getRepository(LocalRepositoryConnector.REPOSITORY_URL) == null) {
485	TaskRepository localRepository = new TaskRepository(LocalRepositoryConnector.REPOSITORY_KIND,	486	TaskRepository localRepository = new TaskRepository(LocalRepositoryConnector.CONNECTOR_KIND,
486	LocalRepositoryConnector.REPOSITORY_URL, LocalRepositoryConnector.REPOSITORY_VERSION);	487	LocalRepositoryConnector.REPOSITORY_URL, LocalRepositoryConnector.REPOSITORY_VERSION);
487	localRepository.setRepositoryLabel(LocalRepositoryConnector.REPOSITORY_LABEL);	488	localRepository.setRepositoryLabel(LocalRepositoryConnector.REPOSITORY_LABEL);
488	localRepository.setAnonymous(true);	489	localRepository.setAnonymous(true);
Lines 639-651 Link Here
639	* @param withProgress	640	* @param withProgress
640	*/	641	*/
641	public void reloadDataDirectory(boolean withProgress) {	642	public void reloadDataDirectory(boolean withProgress) {
642	getTaskListManager().resetTaskList();
643	getTaskListManager().getTaskActivationHistory().clear();	643	getTaskListManager().getTaskActivationHistory().clear();
644	getRepositoryManager().readRepositories(getRepositoriesFilePath());	644	getRepositoryManager().readRepositories(getRepositoriesFilePath());
645	loadTemplateRepositories();	645	loadTemplateRepositories();
646	ContextCorePlugin.getContextManager().loadActivityMetaContext();	646	getTaskListManager().resetTaskList();
647	getTaskListManager().setTaskListFile(	647	getTaskListManager().setTaskListFile(
648	new File(getDataDirectory() + File.separator + ITasksUiConstants.DEFAULT_TASK_LIST_FILE));	648	new File(getDataDirectory() + File.separator + ITasksUiConstants.DEFAULT_TASK_LIST_FILE));
		649	ContextCorePlugin.getContextManager().loadActivityMetaContext();
649	getTaskListManager().readExistingOrCreateNewList();	650	getTaskListManager().readExistingOrCreateNewList();
650	getTaskListManager().initActivityHistory();	651	getTaskListManager().initActivityHistory();
651	checkForCredentials();	652	checkForCredentials();
Lines 956-963 Link Here
956	*	957	*
957	* @Deprecated	958	* @Deprecated
958	*/	959	*/
959	public TaskListNotification getIncommingNotification(AbstractRepositoryConnector connector,	960	public TaskListNotification getIncommingNotification(AbstractRepositoryConnector connector, AbstractTask task) {
960	AbstractTask task) {
961		961
962	TaskListNotification notification = new TaskListNotification(task);	962	TaskListNotification notification = new TaskListNotification(task);
963	RepositoryTaskData newTaskData = getTaskDataManager().getNewTaskData(task.getRepositoryUrl(), task.getTaskId());	963	RepositoryTaskData newTaskData = getTaskDataManager().getNewTaskData(task.getRepositoryUrl(), task.getTaskId());
Lines 980-986 Link Here
980	if (!"".equals(chnagedAttributes)) {	980	if (!"".equals(chnagedAttributes)) {
981	description.append(chnagedAttributes);	981	description.append(chnagedAttributes);
982	}	982	}
983		983
984	notification.setDescription(description.toString());	984	notification.setDescription(description.toString());
985		985
986	if (connector != null) {	986	if (connector != null) {

Lines 15-20 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/MoveToCategoryMenuContributor.java (-2 / +3 lines)
15	import org.eclipse.jface.action.Action;	15	import org.eclipse.jface.action.Action;
16	import org.eclipse.jface.action.MenuManager;	16	import org.eclipse.jface.action.MenuManager;
17	import org.eclipse.jface.action.Separator;	17	import org.eclipse.jface.action.Separator;
		18	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
18	import org.eclipse.mylyn.internal.tasks.ui.actions.NewCategoryAction;	19	import org.eclipse.mylyn.internal.tasks.ui.actions.NewCategoryAction;
19	import org.eclipse.mylyn.tasks.core.AbstractTask;	20	import org.eclipse.mylyn.tasks.core.AbstractTask;
20	import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;	21	import org.eclipse.mylyn.tasks.core.AbstractTaskCategory;
Lines 41-47 Link Here
41	.getCategories());	42	.getCategories());
42	Collections.sort(categories);	43	Collections.sort(categories);
43	for (final AbstractTaskCategory category : categories) {	44	for (final AbstractTaskCategory category : categories) {
44	if (!category.equals(TasksUiPlugin.getTaskListManager().getTaskList().getArchiveContainer())) {	45	if (!(category instanceof OrphanedTasksContainer)) {
45	Action action = new Action() {	46	Action action = new Action() {
46	@Override	47	@Override
47	public void run() {	48	public void run() {
Lines 99-105 Link Here
99	private void moveToCategory(final List<AbstractTaskContainer> selectedElements, AbstractTaskCategory category) {	100	private void moveToCategory(final List<AbstractTaskContainer> selectedElements, AbstractTaskCategory category) {
100	for (AbstractTaskContainer element : selectedElements) {	101	for (AbstractTaskContainer element : selectedElements) {
101	if (element instanceof AbstractTask) {	102	if (element instanceof AbstractTask) {
102	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer((AbstractTask) element, category);	103	TasksUiPlugin.getTaskListManager().getTaskList().moveTask((AbstractTask) element, category);
103	}	104	}
104	}	105	}
105	}	106	}

Lines 19-24 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/planner/TaskActivityWizardPage.java (-3 / +6 lines)
19		19
20	import org.eclipse.jface.layout.GridDataFactory;	20	import org.eclipse.jface.layout.GridDataFactory;
21	import org.eclipse.jface.wizard.WizardPage;	21	import org.eclipse.jface.wizard.WizardPage;
		22	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
22	import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;	23	import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;
23	import org.eclipse.mylyn.internal.tasks.ui.views.TaskElementLabelProvider;	24	import org.eclipse.mylyn.internal.tasks.ui.views.TaskElementLabelProvider;
24	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;	25	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
Lines 217-229 Link Here
217	List<AbstractTaskContainer> containers = new ArrayList<AbstractTaskContainer>();	218	List<AbstractTaskContainer> containers = new ArrayList<AbstractTaskContainer>();
218	containers.addAll(manager.getTaskList().getUserCategories());	219	containers.addAll(manager.getTaskList().getUserCategories());
219	containers.addAll(manager.getTaskList().getQueries());	220	containers.addAll(manager.getTaskList().getQueries());
220	containers.add(manager.getTaskList().getArchiveContainer());	221	//containers.add(manager.getTaskList().getArchiveContainer());
221	Collections.sort(containers, new Comparator<AbstractTaskContainer>() {	222	Collections.sort(containers, new Comparator<AbstractTaskContainer>() {
222		223
223	public int compare(AbstractTaskContainer c1, AbstractTaskContainer c2) {	224	public int compare(AbstractTaskContainer c1, AbstractTaskContainer c2) {
224	if (c1.equals(TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory())) {	225	if (c1.equals(TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
		226	LocalRepositoryConnector.REPOSITORY_URL))) {
225	return -1;	227	return -1;
226	} else if (c2.equals(TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory())) {	228	} else if (c2.equals(TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
		229	LocalRepositoryConnector.REPOSITORY_URL))) {
227	return 1;	230	return 1;
228	} else {	231	} else {
229	return c1.getSummary().compareToIgnoreCase(c2.getSummary());	232	return c1.getSummary().compareToIgnoreCase(c2.getSummary());

Lines 27-32 Link Here

(-)src/org/eclipse/mylyn/internal/sandbox/bridge/bugs/BugzillaMylynSearchOperation.java (-2 / +5 lines)
27	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaCorePlugin;	27	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaCorePlugin;
28	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;	28	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;
29	import org.eclipse.mylyn.internal.bugzilla.ui.tasklist.StackTrace;	29	import org.eclipse.mylyn.internal.bugzilla.ui.tasklist.StackTrace;
		30	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
30	import org.eclipse.mylyn.internal.tasks.ui.search.AbstractRepositorySearchQuery;	31	import org.eclipse.mylyn.internal.tasks.ui.search.AbstractRepositorySearchQuery;
31	import org.eclipse.mylyn.monitor.core.StatusHandler;	32	import org.eclipse.mylyn.monitor.core.StatusHandler;
32	import org.eclipse.mylyn.tasks.core.AbstractTask;	33	import org.eclipse.mylyn.tasks.core.AbstractTask;
Lines 149-155 Link Here
149	collector.setProgressMonitor(monitor);	150	collector.setProgressMonitor(monitor);
150		151
151	// get all of the root tasks and start the search	152	// get all of the root tasks and start the search
152	Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory().getChildren();	153	Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
		154	LocalRepositoryConnector.REPOSITORY_URL).getChildren();
153	searchLocal(tasks, collector, elementName, monitor);	155	searchLocal(tasks, collector, elementName, monitor);
154	for (AbstractTaskContainer cat : TasksUiPlugin.getTaskListManager().getTaskList().getTaskContainers()) {	156	for (AbstractTaskContainer cat : TasksUiPlugin.getTaskListManager().getTaskList().getTaskContainers()) {
155	searchLocal(cat.getChildren(), collector, elementName, monitor);	157	searchLocal(cat.getChildren(), collector, elementName, monitor);
Lines 179-185 Link Here
179	collector.setProgressMonitor(monitor);	181	collector.setProgressMonitor(monitor);
180		182
181	// get all of the root tasks and start the search	183	// get all of the root tasks and start the search
182	Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory().getChildren();	184	Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
		185	LocalRepositoryConnector.REPOSITORY_URL).getChildren();
183	searchLocal(tasks, collector, elementName, monitor);	186	searchLocal(tasks, collector, elementName, monitor);
184	for (AbstractTaskContainer cat : TasksUiPlugin.getTaskListManager().getTaskList().getTaskContainers()) {	187	for (AbstractTaskContainer cat : TasksUiPlugin.getTaskListManager().getTaskList().getTaskContainers()) {
185	searchLocal(cat.getChildren(), collector, elementName, monitor);	188	searchLocal(cat.getChildren(), collector, elementName, monitor);

Lines 18-23 Link Here

(-)src/org/eclipse/mylyn/tests/integration/ChangeDataDirTest.java (-3 / +4 lines)
18	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;	18	import org.eclipse.mylyn.internal.bugzilla.core.BugzillaTask;
19	import org.eclipse.mylyn.internal.context.core.InteractionContextManager;	19	import org.eclipse.mylyn.internal.context.core.InteractionContextManager;
20	import org.eclipse.mylyn.internal.monitor.usage.UiUsageMonitorPlugin;	20	import org.eclipse.mylyn.internal.monitor.usage.UiUsageMonitorPlugin;
		21	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
21	import org.eclipse.mylyn.monitor.core.InteractionEvent;	22	import org.eclipse.mylyn.monitor.core.InteractionEvent;
22	import org.eclipse.mylyn.tasks.core.AbstractTask;	23	import org.eclipse.mylyn.tasks.core.AbstractTask;
23	import org.eclipse.mylyn.tasks.ui.TaskListManager;	24	import org.eclipse.mylyn.tasks.ui.TaskListManager;
Lines 95-101 Link Here
95	public void testTaskMove() {	96	public void testTaskMove() {
96	AbstractTask task = manager.createNewLocalTask("label");	97	AbstractTask task = manager.createNewLocalTask("label");
97	String handle = task.getHandleIdentifier();	98	String handle = task.getHandleIdentifier();
98	manager.getTaskList().moveToContainer(task, manager.getTaskList().getDefaultCategory());	99	manager.getTaskList().moveTask(task,
		100	manager.getTaskList().getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL));
99		101
100	AbstractTask readTaskBeforeMove = manager.getTaskList().getTask(handle);	102	AbstractTask readTaskBeforeMove = manager.getTaskList().getTask(handle);
101	TasksUiPlugin.getTaskListManager().copyDataDirContentsTo(newDataDir);	103	TasksUiPlugin.getTaskListManager().copyDataDirContentsTo(newDataDir);
Lines 127-133 Link Here
127	}	129	}
128		130
129	private void addBugzillaTask(BugzillaTask newTask) {	131	private void addBugzillaTask(BugzillaTask newTask) {
130	TasksUiPlugin.getTaskListManager().getTaskList().moveToContainer(newTask,	132	TasksUiPlugin.getTaskListManager().getTaskList().addTask(newTask);
131	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
132	}	133	}
133	}	134	}

Lines 59-81 Link Here

(-)src/org/eclipse/mylyn/tests/integration/TaskListFilterTest.java (-5 / +5 lines)
59	taskCompleted = new LocalTask("1", "completed");	59	taskCompleted = new LocalTask("1", "completed");
60	taskCompleted.setCompleted(true);	60	taskCompleted.setCompleted(true);
61	taskCompleted.setCompletionDate(TaskActivityUtil.snapForwardNumDays(Calendar.getInstance(), -1).getTime());	61	taskCompleted.setCompletionDate(TaskActivityUtil.snapForwardNumDays(Calendar.getInstance(), -1).getTime());
62	manager.getTaskList().addTask(taskCompleted, manager.getTaskList().getDefaultCategory());	62	manager.getTaskList().addTask(taskCompleted);
63		63
64	taskIncomplete = new LocalTask("2", "t-incomplete");	64	taskIncomplete = new LocalTask("2", "t-incomplete");
65	manager.getTaskList().addTask(taskIncomplete, manager.getTaskList().getDefaultCategory());	65	manager.getTaskList().addTask(taskIncomplete);
66		66
67	taskOverdue = new LocalTask("3", "t-overdue");	67	taskOverdue = new LocalTask("3", "t-overdue");
68	taskOverdue.setScheduledForDate(TaskActivityUtil.snapForwardNumDays(Calendar.getInstance(), -1).getTime());	68	taskOverdue.setScheduledForDate(TaskActivityUtil.snapForwardNumDays(Calendar.getInstance(), -1).getTime());
69	manager.getTaskList().addTask(taskOverdue, manager.getTaskList().getDefaultCategory());	69	manager.getTaskList().addTask(taskOverdue);
70		70
71	taskDueToday = new LocalTask("4", "t-today");	71	taskDueToday = new LocalTask("4", "t-today");
72	taskDueToday.setScheduledForDate(TaskActivityUtil.snapEndOfWorkDay(Calendar.getInstance()).getTime());	72	taskDueToday.setScheduledForDate(TaskActivityUtil.snapEndOfWorkDay(Calendar.getInstance()).getTime());
73	manager.getTaskList().addTask(taskDueToday, manager.getTaskList().getDefaultCategory());	73	manager.getTaskList().addTask(taskDueToday);
74		74
75	taskCompletedToday = new LocalTask("5", "t-donetoday");	75	taskCompletedToday = new LocalTask("5", "t-donetoday");
76	taskCompletedToday.setScheduledForDate(TaskActivityUtil.snapEndOfWorkDay(Calendar.getInstance()).getTime());	76	taskCompletedToday.setScheduledForDate(TaskActivityUtil.snapEndOfWorkDay(Calendar.getInstance()).getTime());
77	taskCompletedToday.setCompleted(true);	77	taskCompletedToday.setCompleted(true);
78	manager.getTaskList().addTask(taskCompletedToday, manager.getTaskList().getDefaultCategory());	78	manager.getTaskList().addTask(taskCompletedToday);
79	}	79	}
80		80
81	@Override	81	@Override

Lines 90-96 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TaskListUiTest.java (-14 / +13 lines)
90	cat1task1 = manager.createNewLocalTask("task 1");	90	cat1task1 = manager.createNewLocalTask("task 1");
91	cat1task1.setPriority(PriorityLevel.P1.toString());	91	cat1task1.setPriority(PriorityLevel.P1.toString());
92	cat1task1.setCompleted(true);	92	cat1task1.setCompleted(true);
93	manager.getTaskList().moveToContainer(cat1task1, cat1);	93	manager.getTaskList().moveTask(cat1task1, cat1);
94		94
95	cat1task1sub1 = manager.createNewLocalTask("sub task 1");	95	cat1task1sub1 = manager.createNewLocalTask("sub task 1");
96	cat1task1sub1.setPriority(PriorityLevel.P1.toString());	96	cat1task1sub1.setPriority(PriorityLevel.P1.toString());
Lines 100-123 Link Here
100	cat1task2 = manager.createNewLocalTask("task 2");	100	cat1task2 = manager.createNewLocalTask("task 2");
101	cat1task2.setPriority(PriorityLevel.P2.toString());	101	cat1task2.setPriority(PriorityLevel.P2.toString());
102	cat1task2.addParentContainer(cat1);	102	cat1task2.addParentContainer(cat1);
103	manager.getTaskList().moveToContainer(cat1task2, cat1);	103	manager.getTaskList().moveTask(cat1task2, cat1);
104		104
105	cat1task3 = manager.createNewLocalTask("task 3");	105	cat1task3 = manager.createNewLocalTask("task 3");
106	cat1task3.setPriority(PriorityLevel.P3.toString());	106	cat1task3.setPriority(PriorityLevel.P3.toString());
107	cat1task3.setCompleted(true);	107	cat1task3.setCompleted(true);
108	cat1task3.addParentContainer(cat1);	108	cat1task3.addParentContainer(cat1);
109	manager.getTaskList().moveToContainer(cat1task3, cat1);	109	manager.getTaskList().moveTask(cat1task3, cat1);
110		110
111	cat1task4 = manager.createNewLocalTask("task 4");	111	cat1task4 = manager.createNewLocalTask("task 4");
112	cat1task4.setPriority(PriorityLevel.P4.toString());	112	cat1task4.setPriority(PriorityLevel.P4.toString());
113	cat1task4.addParentContainer(cat1);	113	cat1task4.addParentContainer(cat1);
114	manager.getTaskList().moveToContainer(cat1task4, cat1);	114	manager.getTaskList().moveTask(cat1task4, cat1);
115		115
116	cat1task5 = manager.createNewLocalTask("task 5");	116	cat1task5 = manager.createNewLocalTask("task 5");
117	cat1task5.setPriority(PriorityLevel.P5.toString());	117	cat1task5.setPriority(PriorityLevel.P5.toString());
118	cat1task5.setCompleted(true);	118	cat1task5.setCompleted(true);
119	cat1task5.addParentContainer(cat1);	119	cat1task5.addParentContainer(cat1);
120	manager.getTaskList().moveToContainer(cat1task5, cat1);	120	manager.getTaskList().moveTask(cat1task5, cat1);
121		121
122	manager.getTaskList().addCategory(cat1);	122	manager.getTaskList().addCategory(cat1);
123	assertEquals(cat1.getChildren().size(), 5);	123	assertEquals(cat1.getChildren().size(), 5);
Lines 127-133 Link Here
127	cat2task1 = manager.createNewLocalTask("task 1");	127	cat2task1 = manager.createNewLocalTask("task 1");
128	cat2task1.setPriority(PriorityLevel.P1.toString());	128	cat2task1.setPriority(PriorityLevel.P1.toString());
129	cat2task1.addParentContainer(cat2);	129	cat2task1.addParentContainer(cat2);
130	manager.getTaskList().moveToContainer(cat2task1, cat2);	130	manager.getTaskList().moveTask(cat2task1, cat2);
131		131
132	cat2task1sub1 = manager.createNewLocalTask("sub task 1");	132	cat2task1sub1 = manager.createNewLocalTask("sub task 1");
133	cat2task1sub1.setPriority(PriorityLevel.P1.toString());	133	cat2task1sub1.setPriority(PriorityLevel.P1.toString());
Lines 137-159 Link Here
137	cat2task2.setPriority(PriorityLevel.P2.toString());	137	cat2task2.setPriority(PriorityLevel.P2.toString());
138	cat2task2.setCompleted(true);	138	cat2task2.setCompleted(true);
139	cat2task2.addParentContainer(cat2);	139	cat2task2.addParentContainer(cat2);
140	manager.getTaskList().moveToContainer(cat2task2, cat2);	140	manager.getTaskList().moveTask(cat2task2, cat2);
141		141
142	cat2task3 = manager.createNewLocalTask("task 3");	142	cat2task3 = manager.createNewLocalTask("task 3");
143	cat2task3.setPriority(PriorityLevel.P3.toString());	143	cat2task3.setPriority(PriorityLevel.P3.toString());
144	cat2task3.addParentContainer(cat2);	144	cat2task3.addParentContainer(cat2);
145	manager.getTaskList().moveToContainer(cat2task3, cat2);	145	manager.getTaskList().moveTask(cat2task3, cat2);
146		146
147	cat2task4 = manager.createNewLocalTask("task 4");	147	cat2task4 = manager.createNewLocalTask("task 4");
148	cat2task4.setPriority(PriorityLevel.P4.toString());	148	cat2task4.setPriority(PriorityLevel.P4.toString());
149	cat2task4.setCompleted(true);	149	cat2task4.setCompleted(true);
150	cat2task4.addParentContainer(cat2);	150	cat2task4.addParentContainer(cat2);
151	manager.getTaskList().moveToContainer(cat2task4, cat2);	151	manager.getTaskList().moveTask(cat2task4, cat2);
152		152
153	cat2task5 = manager.createNewLocalTask("task 5");	153	cat2task5 = manager.createNewLocalTask("task 5");
154	cat2task5.setPriority(PriorityLevel.P5.toString());	154	cat2task5.setPriority(PriorityLevel.P5.toString());
155	cat2task5.addParentContainer(cat2);	155	cat2task5.addParentContainer(cat2);
156	manager.getTaskList().moveToContainer(cat2task5, cat2);	156	manager.getTaskList().moveTask(cat2task5, cat2);
157		157
158	manager.getTaskList().addCategory(cat2);	158	manager.getTaskList().addCategory(cat2);
159	manager.saveTaskList();	159	manager.saveTaskList();
Lines 171-178 Link Here
171	TaskListView view = TaskListView.getFromActivePerspective();	171	TaskListView view = TaskListView.getFromActivePerspective();
172	assertNotNull(view);	172	assertNotNull(view);
173	WebTask webTask = new WebTask("1", "1", "", "", "web");	173	WebTask webTask = new WebTask("1", "1", "", "", "web");
174	TasksUiPlugin.getTaskListManager().getTaskList().addTask(webTask,	174	TasksUiPlugin.getTaskListManager().getTaskList().addTask(webTask);
175	TasksUiPlugin.getTaskListManager().getTaskList().getDefaultCategory());
176	view.getViewer().refresh();	175	view.getViewer().refresh();
177	// Arrays.asList(view.getViewer().getVisibleExpandedElements());	176	// Arrays.asList(view.getViewer().getVisibleExpandedElements());
178	assertFalse(webTask.isCompleted());	177	assertFalse(webTask.isCompleted());
Lines 251-260 Link Here
251	MoveToCategoryMenuContributor moveToMenuContrib = new MoveToCategoryMenuContributor();	250	MoveToCategoryMenuContributor moveToMenuContrib = new MoveToCategoryMenuContributor();
252	List<AbstractTaskContainer> selectedElements = new Vector<AbstractTaskContainer>();	251	List<AbstractTaskContainer> selectedElements = new Vector<AbstractTaskContainer>();
253	selectedElements.add(cat1task1);	252	selectedElements.add(cat1task1);
254	int numCategoriesMinusArchiveContainer = manager.getTaskList().getCategories().size() - 1;	253	int numCategories = manager.getTaskList().getCategories().size();
255	int numSeparators = 1;	254	int numSeparators = 1;
256	// adding a separator and the New Category... action	255	// adding a separator and the New Category... action
257	int expectedNrOfSubMenuEntries = numCategoriesMinusArchiveContainer + numSeparators + 1;	256	int expectedNrOfSubMenuEntries = numCategories + numSeparators + 1;
258	NewCategoryAction newCatActon = new NewCategoryAction();	257	NewCategoryAction newCatActon = new NewCategoryAction();
259		258
260	// execute sytem under test	259	// execute sytem under test

Lines 15-27 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TaskListTest.java (-1 / +2 lines)
15		15
16	/**	16	/**
17	* @author Mik Kersten	17	* @author Mik Kersten
		18	* @author Rob Elves
18	*/	19	*/
19	public class TaskListTest extends TestCase {	20	public class TaskListTest extends TestCase {
20		21
21	public void testGetUserCategories() {	22	public void testGetUserCategories() {
22	TaskList taskList = new TaskList();	23	TaskList taskList = new TaskList();
23	taskList.addCategory(new TaskCategory("a"));	24	taskList.addCategory(new TaskCategory("a"));
24	assertEquals(2, taskList.getUserCategories().size());	25	assertEquals(1, taskList.getUserCategories().size());
25	}	26	}
26		27
27	}	28	}

Lines 21-26 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TaskExportImportTest.java (-17 / +17 lines)
21	import org.eclipse.mylyn.context.tests.AbstractContextTest;	21	import org.eclipse.mylyn.context.tests.AbstractContextTest;
22	import org.eclipse.mylyn.internal.context.core.InteractionContext;	22	import org.eclipse.mylyn.internal.context.core.InteractionContext;
23	import org.eclipse.mylyn.internal.context.core.InteractionContextManager;	23	import org.eclipse.mylyn.internal.context.core.InteractionContextManager;
		24	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
24	import org.eclipse.mylyn.internal.tasks.core.LocalTask;	25	import org.eclipse.mylyn.internal.tasks.core.LocalTask;
25	import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;	26	import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;
26	import org.eclipse.mylyn.monitor.core.InteractionEvent;	27	import org.eclipse.mylyn.monitor.core.InteractionEvent;
Lines 35-47 Link Here
35	public class TaskExportImportTest extends AbstractContextTest {	36	public class TaskExportImportTest extends AbstractContextTest {
36		37
37	private File dest;	38	private File dest;
38		39
39	@Override	40	@Override
40	protected void setUp() throws Exception {	41	protected void setUp() throws Exception {
41	super.setUp();	42	super.setUp();
42	removeFiles(new File(TasksUiPlugin.getDefault().getDataDirectory()));	43	removeFiles(new File(TasksUiPlugin.getDefault().getDataDirectory()));
43	ContextCorePlugin.getDefault().getContextStore().init();	44	ContextCorePlugin.getDefault().getContextStore().init();
44		45
45	// Create test export destination directory	46	// Create test export destination directory
46	dest = new File(TasksUiPlugin.getDefault().getDataDirectory() + File.separator + "TestDir");	47	dest = new File(TasksUiPlugin.getDefault().getDataDirectory() + File.separator + "TestDir");
47	if (dest.exists()) {	48	if (dest.exists()) {
Lines 58-64 Link Here
58	removeFiles(dest);	59	removeFiles(dest);
59	dest.delete();	60	dest.delete();
60	assertFalse(dest.exists());	61	assertFalse(dest.exists());
61		62
62	super.tearDown();	63	super.tearDown();
63	}	64	}
64		65
Lines 66-85 Link Here
66		67
67	LocalTask task = TasksUiPlugin.getTaskListManager().createNewLocalTask("Test local task");	68	LocalTask task = TasksUiPlugin.getTaskListManager().createNewLocalTask("Test local task");
68	TaskList taskList = TasksUiPlugin.getTaskListManager().getTaskList();	69	TaskList taskList = TasksUiPlugin.getTaskListManager().getTaskList();
69	taskList.moveToContainer(task, taskList.getDefaultCategory());	70	taskList.moveTask(task, taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL));
70	assertTrue(taskList.getAllTasks().size() > 0);	71	assertTrue(taskList.getAllTasks().size() > 0);
71		72
72	InteractionContext mockContext = ContextCorePlugin.getContextManager().loadContext(task.getHandleIdentifier());	73	InteractionContext mockContext = ContextCorePlugin.getContextManager().loadContext(task.getHandleIdentifier());
73		74
74	ContextCorePlugin.getContextManager().internalActivateContext(mockContext);	75	ContextCorePlugin.getContextManager().internalActivateContext(mockContext);
75	InteractionEvent event = new InteractionEvent(InteractionEvent.Kind.EDIT, "structureKind", "handle", "originId");	76	InteractionEvent event = new InteractionEvent(InteractionEvent.Kind.EDIT, "structureKind", "handle", "originId");
76	mockContext.parseEvent(event);	77	mockContext.parseEvent(event);
77	ContextCorePlugin.getContextManager().deactivateContext(mockContext.getHandleIdentifier());	78	ContextCorePlugin.getContextManager().deactivateContext(mockContext.getHandleIdentifier());
78		79
79	assertTrue(ContextCorePlugin.getDefault().getContextStore().getContextDirectory().exists());	80	assertTrue(ContextCorePlugin.getDefault().getContextStore().getContextDirectory().exists());
80	ContextCorePlugin.getContextManager().saveContext(mockContext.getHandleIdentifier());	81	ContextCorePlugin.getContextManager().saveContext(mockContext.getHandleIdentifier());
81	assertTrue(ContextCorePlugin.getContextManager().hasContext(task.getHandleIdentifier()));	82	assertTrue(ContextCorePlugin.getContextManager().hasContext(task.getHandleIdentifier()));
82		83
83	File outFile = new File(dest + File.separator + "local-task.xml.zip");	84	File outFile = new File(dest + File.separator + "local-task.xml.zip");
84	TasksUiPlugin.getTaskListManager().getTaskListWriter().writeTask(task, outFile);	85	TasksUiPlugin.getTaskListManager().getTaskListWriter().writeTask(task, outFile);
85	assertTrue(outFile.exists());	86	assertTrue(outFile.exists());
Lines 92-109 Link Here
92	files.add(entry.getName());	93	files.add(entry.getName());
93	}	94	}
94	inputStream.close();	95	inputStream.close();
95		96
96	assertTrue("exported file contains a file with queries", files.contains(ITasksUiConstants.OLD_TASK_LIST_FILE));	97	assertTrue("exported file contains a file with queries", files.contains(ITasksUiConstants.OLD_TASK_LIST_FILE));
97		98
98	String handleIdentifier = mockContext.getHandleIdentifier();	99	String handleIdentifier = mockContext.getHandleIdentifier();
99	String encoded = URLEncoder.encode(handleIdentifier, InteractionContextManager.CONTEXT_FILENAME_ENCODING);	100	String encoded = URLEncoder.encode(handleIdentifier, InteractionContextManager.CONTEXT_FILENAME_ENCODING);
100	String contextName = encoded + InteractionContextManager.CONTEXT_FILE_EXTENSION_OLD;	101	String contextName = encoded + InteractionContextManager.CONTEXT_FILE_EXTENSION_OLD;
101	assertTrue("exported file contains a file with context", files.contains(contextName));	102	assertTrue("exported file contains a file with context", files.contains(contextName));
102		103
103	// reset all data	104	// reset all data
104	TasksUiPlugin.getTaskListManager().resetTaskList();	105	TasksUiPlugin.getTaskListManager().resetTaskList();
105	assertTrue(taskList.getAllTasks().size() == 0);	106	assertTrue(taskList.getAllTasks().size() == 0);
106		107
107	ContextCorePlugin.getContextManager().deleteContext(handleIdentifier);	108	ContextCorePlugin.getContextManager().deleteContext(handleIdentifier);
108	assertFalse(ContextCorePlugin.getContextManager().hasContext(task.getHandleIdentifier()));	109	assertFalse(ContextCorePlugin.getContextManager().hasContext(task.getHandleIdentifier()));
109		110
Lines 111-136 Link Here
111	List<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskListWriter().readTasks(outFile);	112	List<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskListWriter().readTasks(outFile);
112	InteractionContext loadedContext = ContextCorePlugin.getContextManager().loadContext(	113	InteractionContext loadedContext = ContextCorePlugin.getContextManager().loadContext(
113	task.getHandleIdentifier(), outFile);	114	task.getHandleIdentifier(), outFile);
114		115
115	// check with original one	116	// check with original one
116	assertEquals("There is 1 task loaded", 1, tasks.size());	117	assertEquals("There is 1 task loaded", 1, tasks.size());
117	assertEquals("Loaded task is correct", task, tasks.get(0));	118	assertEquals("Loaded task is correct", task, tasks.get(0));
118	assertEquals("Loaded context is correct", mockContext, loadedContext);	119	assertEquals("Loaded context is correct", mockContext, loadedContext);
119		120
120	// import data	121	// import data
121	for (AbstractTask loadedTask : tasks) {	122	for (AbstractTask loadedTask : tasks) {
122	taskList.insertTask(loadedTask, null, null);	123	taskList.insertTask(loadedTask, null, null);
123	}	124	}
124	ContextCorePlugin.getContextManager().importContext(loadedContext);	125	ContextCorePlugin.getContextManager().importContext(loadedContext);
125		126
126	// check that context was imported and is the same as original one	127	// check that context was imported and is the same as original one
127	InteractionContext savedContext = ContextCorePlugin.getContextManager().loadContext(task.getHandleIdentifier());	128	InteractionContext savedContext = ContextCorePlugin.getContextManager().loadContext(task.getHandleIdentifier());
128	assertEquals("Saved context is the same as original one", mockContext, savedContext);	129	assertEquals("Saved context is the same as original one", mockContext, savedContext);
129	assertEquals("Saved task is the same as original one", task, taskList.getTask(task.getHandleIdentifier()));	130	assertEquals("Saved task is the same as original one", task, taskList.getTask(task.getHandleIdentifier()));
130		131
131	ContextCorePlugin.getContextManager().deactivateAllContexts();	132	ContextCorePlugin.getContextManager().deactivateAllContexts();
132	}	133	}
133
134		134
135	private void removeFiles(File root) {	135	private void removeFiles(File root) {
136	if (root.isDirectory()) {	136	if (root.isDirectory()) {

Lines 45-53 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TaskHistoryTest.java (-9 / +9 lines)
45		45
46	protected AbstractTask task5 = null;	46	protected AbstractTask task5 = null;
47		47
48	private ActivateTaskHistoryDropDownAction previousTaskAction = new ActivateTaskHistoryDropDownAction(TasksUiPlugin.getTaskListManager()	48	private ActivateTaskHistoryDropDownAction previousTaskAction = new ActivateTaskHistoryDropDownAction(
49	.getTaskActivationHistory(), false);	49	TasksUiPlugin.getTaskListManager().getTaskActivationHistory(), false);
50		50
51	@Override	51	@Override
52	protected void setUp() throws Exception {	52	protected void setUp() throws Exception {
53	super.setUp();	53	super.setUp();
Lines 57-75 Link Here
57	resetHistory();	57	resetHistory();
58		58
59	task1 = manager.createNewLocalTask("task 1");	59	task1 = manager.createNewLocalTask("task 1");
60	manager.getTaskList().moveToContainer(task1, manager.getTaskList().getDefaultCategory());	60	manager.getTaskList().addTask(task1);
61		61
62	task2 = manager.createNewLocalTask("task 2");	62	task2 = manager.createNewLocalTask("task 2");
63	manager.getTaskList().moveToContainer(task2, manager.getTaskList().getDefaultCategory());	63	manager.getTaskList().addTask(task2);
64		64
65	task3 = manager.createNewLocalTask("task 3");	65	task3 = manager.createNewLocalTask("task 3");
66	manager.getTaskList().moveToContainer(task3, manager.getTaskList().getDefaultCategory());	66	manager.getTaskList().addTask(task3);
67		67
68	task4 = manager.createNewLocalTask("task 4");	68	task4 = manager.createNewLocalTask("task 4");
69	manager.getTaskList().moveToContainer(task4, manager.getTaskList().getDefaultCategory());	69	manager.getTaskList().addTask(task4);
70		70
71	task5 = manager.createNewLocalTask("task 5");	71	task5 = manager.createNewLocalTask("task 5");
72	manager.getTaskList().moveToContainer(task5, manager.getTaskList().getDefaultCategory());	72	manager.getTaskList().addTask(task5);
73		73
74	history = manager.getTaskActivationHistory();	74	history = manager.getTaskActivationHistory();
75	}	75	}
Lines 95-101 Link Here
95	assertTrue(task3.isActive());	95	assertTrue(task3.isActive());
96	assertFalse(task2.isActive());	96	assertFalse(task2.isActive());
97	assertFalse(task1.isActive());	97	assertFalse(task1.isActive());
98		98
99	previousTaskAction.run();	99	previousTaskAction.run();
100	assertTrue(task2.isActive());	100	assertTrue(task2.isActive());
101		101

Lines 59-65 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TaskRepositoryManagerTest.java (-1 / +5 lines)
59		59
60	TaskRepository repository1 = new TaskRepository("bugzilla", "http://repository1/");	60	TaskRepository repository1 = new TaskRepository("bugzilla", "http://repository1/");
61	manager.addRepository(repository1, TasksUiPlugin.getDefault().getRepositoriesFilePath());	61	manager.addRepository(repository1, TasksUiPlugin.getDefault().getRepositoriesFilePath());
62	assertEquals(1, manager.getAllRepositories().size());
63	assertNotNull(manager.getRepository("http://repository1"));	62	assertNotNull(manager.getRepository("http://repository1"));
64	assertNotNull(manager.getRepository("http://repository1/"));	63	assertNotNull(manager.getRepository("http://repository1/"));
65		64
Lines 69-74 Link Here
69	}	68	}
70		69
71	public void testQueryDeletion() {	70	public void testQueryDeletion() {
		71	TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND,
		72	MockRepositoryConnector.REPOSITORY_URL);
		73	TasksUiPlugin.getRepositoryManager().addRepository(repository,
		74	TasksUiPlugin.getDefault().getRepositoriesFilePath());
		75
72	MockRepositoryTask task = new MockRepositoryTask("1");	76	MockRepositoryTask task = new MockRepositoryTask("1");
73	task.setLastReadTimeStamp("now");	77	task.setLastReadTimeStamp("now");
74	MockRepositoryQuery query = new MockRepositoryQuery("Test");	78	MockRepositoryQuery query = new MockRepositoryQuery("Test");

Lines 37-43 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/AllTasksTests.java (-1 / +2 lines)
37	suite.addTestSuite(TaskRepositoryManagerTest.class);	37	suite.addTestSuite(TaskRepositoryManagerTest.class);
38	suite.addTestSuite(TaskRepositoriesExternalizerTest.class);	38	suite.addTestSuite(TaskRepositoriesExternalizerTest.class);
39	suite.addTestSuite(TaskListContentProviderTest.class);	39	suite.addTestSuite(TaskListContentProviderTest.class);
40	suite.addTestSuite(TaskListBackupManagerTest.class);	40	//suite.addTestSuite(TaskListBackupManagerTest.class);
41	suite.addTestSuite(TableSorterTest.class);	41	suite.addTestSuite(TableSorterTest.class);
42	suite.addTestSuite(TaskKeyComparatorTest.class);	42	suite.addTestSuite(TaskKeyComparatorTest.class);
43	suite.addTestSuite(TaskTest.class);	43	suite.addTestSuite(TaskTest.class);
Lines 60-65 Link Here
60	suite.addTestSuite(PersonProposalProviderTest.class);	60	suite.addTestSuite(PersonProposalProviderTest.class);
61	suite.addTestSuite(TaskRepositoryLocationTest.class);	61	suite.addTestSuite(TaskRepositoryLocationTest.class);
62	suite.addTestSuite(AbstractTaskDataHandlerTest.class);	62	suite.addTestSuite(AbstractTaskDataHandlerTest.class);
		63	suite.addTestSuite(OrphanedTasksTest.class);
63	// $JUnit-END$	64	// $JUnit-END$
64		65
65	// suite.addTestSuite(BackgroundSaveTest.class);	66	// suite.addTestSuite(BackgroundSaveTest.class);

Lines 15-25 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/connector/MockRepositoryQuery.java (-2 / +3 lines)
15	*/	15	*/
16	public class MockRepositoryQuery extends AbstractRepositoryQuery {	16	public class MockRepositoryQuery extends AbstractRepositoryQuery {
17		17
18	public String MOCK_URL = "http://mock.repository";	18	public String MOCK_QUERY_URL = MockRepositoryConnector.REPOSITORY_URL + ".query";
19		19
20	public MockRepositoryQuery(String description) {	20	public MockRepositoryQuery(String description) {
21	super(description);	21	super(description);
22	super.setUrl(MOCK_URL);	22	super.setUrl(MOCK_QUERY_URL);
		23	super.setRepositoryUrl(MockRepositoryConnector.REPOSITORY_URL);
23	}	24	}
24		25
25	public MockRepositoryQuery(String description, String url) {	26	public MockRepositoryQuery(String description, String url) {

Added Link Here

(-)src/org/eclipse/mylyn/tasks/tests/OrphanedTasksTest.java (+309 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004, 2007 Mylyn project committers and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/
8
9	package org.eclipse.mylyn.tasks.tests;
10
11	import java.util.Set;
12
13	import junit.framework.TestCase;
14
15	import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
16	import org.eclipse.mylyn.internal.tasks.core.LocalTask;
17	import org.eclipse.mylyn.internal.tasks.core.OrphanedTasksContainer;
18	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
19	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
20	import org.eclipse.mylyn.tasks.core.AbstractTask;
21	import org.eclipse.mylyn.tasks.core.TaskList;
22	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryConnector;
23	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryQuery;
24	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryTask;
25	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
26
27	/**
28	* @author Rob Elves
29	*/
30	public class OrphanedTasksTest extends TestCase {
31
32	private TaskList taskList;
33
34	protected void setUp() throws Exception {
35	super.setUp();
36	TasksUiPlugin.getTaskListManager().resetTaskList();
37	taskList = TasksUiPlugin.getTaskListManager().getTaskList();
38	assertTrue(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).isEmpty());
39	}
40
41	protected void tearDown() throws Exception {
42	super.tearDown();
43	}
44
45	/**
46	* y New local tasks should automatically be created in the Local orphaned folder
47	*/
48	public void testAddLocalTask() {
49	Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getRepositoryTasks(
50	LocalRepositoryConnector.REPOSITORY_URL);
51	assertTrue(tasks.isEmpty());
52	AbstractTask localTask = TasksUiPlugin.getTaskListManager().createNewLocalTask("Task 1");
53	assertNotNull(localTask);
54	assertEquals(1, localTask.getParentContainers().size());
55	assertTrue(localTask.getParentContainers().iterator().next() instanceof OrphanedTasksContainer);
56	}
57
58	/**
59	* When a local tasks is removed from a category it should be placed in the local repository orphaned container.
60	*/
61	public void testRemoveLocalTask() {
62	TaskCategory category = new TaskCategory("taskCategoryHandle");
63	taskList.addCategory(category);
64	LocalTask newTask = new LocalTask("" + taskList.getNextLocalTaskId(), "new local task");
65	taskList.addTask(newTask, category);
66	//assertEquals(1, taskList.getOrphanContainers().size());
67	assertEquals(1, taskList.getCategories().size());
68	assertTrue(taskList.getCategories().iterator().next().contains(newTask.getHandleIdentifier()));
69	taskList.removeFromCategory(category, newTask);
70	//assertEquals(taskList.getOrphanContainers().size(), 1);
71	assertFalse(category.contains(newTask.getHandleIdentifier()));
72	assertTrue(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).contains(
73	newTask.getHandleIdentifier()));
74	assertEquals(1, newTask.getParentContainers().size());
75	assertEquals(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).getHandleIdentifier(),
76	newTask.getParentContainers().iterator().next().getHandleIdentifier());
77	}
78
79	/**
80	* Local tasks in a removed category should be orphaned.
81	*/
82	public void testLocalTaskOrphanedInDeletedTaskCategory() {
83	assertTrue(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).isEmpty());
84	TaskCategory category = new TaskCategory("taskCategoryHandle");
85	taskList.addCategory(category);
86	LocalTask newTask = new LocalTask("" + taskList.getNextLocalTaskId(), "new local task");
87	taskList.addTask(newTask, category);
88	assertTrue(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).isEmpty());
89	taskList.deleteCategory(category);
90	assertTrue(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).contains(
91	newTask.getHandleIdentifier()));
92
93	}
94
95	/**
96	* Query removed with task in category, just query removed task remains.
97	*/
98	public void testTaskRemovedFromQuery() {
99	MockRepositoryTask mockTask = new MockRepositoryTask("1");
100	mockTask.setLastReadTimeStamp("now");
101	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
102	taskList.addQuery(mockQuery);
103	taskList.addTask(mockTask, mockQuery);
104
105	taskList.removeFromQuery(mockQuery, mockTask);
106
107	assertFalse(mockQuery.contains(mockTask.getHandleIdentifier()));
108	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
109	mockTask.getHandleIdentifier()));
110	}
111
112	/**
113	* Query removed with task in category, just query removed task remains.
114	*/
115	public void testTaskRemovedFromQueryButInCategory() {
116	MockRepositoryTask mockTask = new MockRepositoryTask("1");
117	mockTask.setLastReadTimeStamp("now");
118	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
119	taskList.addQuery(mockQuery);
120	taskList.addTask(mockTask, mockQuery);
121
122	TaskCategory category = new TaskCategory("taskCategoryHandle");
123	taskList.addCategory(category);
124	taskList.addTask(mockTask, category);
125	assertTrue(category.contains(mockTask.getHandleIdentifier()));
126	taskList.removeFromQuery(mockQuery, mockTask);
127
128	assertFalse(mockQuery.contains(mockTask.getHandleIdentifier()));
129	assertEquals(1, taskList.getCategories().size());
130	assertTrue(taskList.getCategories().iterator().next().contains(mockTask.getHandleIdentifier()));
131
132	//* Repository tasks within a removed category that are not in a query should be orphaned.
133
134	taskList.removeFromCategory(category, mockTask);
135	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
136	mockTask.getHandleIdentifier()));
137	}
138
139	/**
140	* Repository tasks that exists in a query are not orphaned.
141	*/
142	public void testRepositoryTaskInDeletedCategory() {
143	MockRepositoryTask mockTask = new MockRepositoryTask("1");
144	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
145	taskList.addQuery(mockQuery);
146	taskList.addTask(mockTask, mockQuery);
147
148	TaskCategory category = new TaskCategory("taskCategoryHandle");
149	taskList.addCategory(category);
150	taskList.addTask(mockTask, category);
151
152	assertTrue(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).isEmpty());
153	taskList.deleteCategory(category);
154	assert (taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).isEmpty());
155	assertEquals(0, taskList.getCategories().size());
156	}
157
158	/**
159	* Repository tasks that exist in another query are not orphaned
160	*/
161	public void testRemovalOfTaskInTwoQueries() {
162	MockRepositoryTask mockTask = new MockRepositoryTask("1");
163	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query 1");
164	MockRepositoryQuery mockQuery2 = new MockRepositoryQuery("mock query 2");
165	taskList.addQuery(mockQuery);
166	taskList.addQuery(mockQuery2);
167	taskList.addTask(mockTask, mockQuery);
168	taskList.addTask(mockTask, mockQuery2);
169
170	taskList.removeFromQuery(mockQuery2, mockTask);
171	assertTrue(mockQuery2.isEmpty());
172	assertFalse(mockQuery.isEmpty());
173	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).isEmpty());
174	assertEquals(0, taskList.getCategories().size());
175	}
176
177	/**
178	* Moving an orphan to a Category should result in the task only being present in the target Category
179	*/
180	public void testMoveLocalTask() {
181	TaskCategory category = new TaskCategory("taskCategoryHandle");
182	taskList.addCategory(category);
183	LocalTask newTask = new LocalTask("" + taskList.getNextLocalTaskId(), "new local task");
184	taskList.addTask(newTask, null);
185	assertTrue(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).contains(
186	newTask.getHandleIdentifier()));
187	taskList.moveTask(newTask, category);
188	assertFalse(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).contains(
189	newTask.getHandleIdentifier()));
190	}
191
192	public void testAddRepositoryTask() {
193	MockRepositoryTask mockTask = new MockRepositoryTask("1");
194	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
195	TasksUiPlugin.getTaskListManager().getTaskList().addQuery(mockQuery);
196	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask, mockQuery);
197	Set<AbstractTask> tasks = TasksUiPlugin.getTaskListManager().getTaskList().getRepositoryTasks(
198	MockRepositoryConnector.REPOSITORY_URL);
199	assertFalse(tasks.isEmpty());
200	AbstractRepositoryQuery query = TasksUiPlugin.getTaskListManager().getTaskList().getQueryForHandle(
201	mockTask.getHandleIdentifier());
202	assertEquals(mockQuery, query);
203	assertFalse(query.isEmpty());
204	assertTrue(TasksUiPlugin.getTaskListManager().getTaskList().getOrphanContainer(
205	MockRepositoryConnector.REPOSITORY_URL).isEmpty());
206	}
207
208	public void testMoveRepositoryTask() {
209	TaskList tasklist = TasksUiPlugin.getTaskListManager().getTaskList();
210	assertTrue(tasklist.getAllTasks().isEmpty());
211
212	MockRepositoryTask mockTask = new MockRepositoryTask("1");
213	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
214	TasksUiPlugin.getTaskListManager().getTaskList().addQuery(mockQuery);
215	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask, mockQuery);
216
217	TaskCategory category = new TaskCategory("taskCategoryHandle");
218	taskList.addCategory(category);
219
220	taskList.moveTask(mockTask, category);
221	assertTrue(taskList.getOrphanContainer(LocalRepositoryConnector.REPOSITORY_URL).isEmpty());
222	assertTrue(category.contains(mockTask.getHandleIdentifier()));
223	assertTrue(mockQuery.contains(mockTask.getHandleIdentifier()));
224
225	}
226
227	public void testRefactorOrphanedHandle() {
228	MockRepositoryTask mockTask = new MockRepositoryTask("1");
229	mockTask.setLastReadTimeStamp("now");
230	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
231	taskList.addQuery(mockQuery);
232	taskList.addTask(mockTask, mockQuery);
233
234	taskList.removeFromQuery(mockQuery, mockTask);
235
236	assertFalse(mockQuery.contains(mockTask.getHandleIdentifier()));
237	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
238	mockTask.getHandleIdentifier()));
239
240	taskList.refactorRepositoryUrl(MockRepositoryConnector.REPOSITORY_URL, MockRepositoryConnector.REPOSITORY_URL
241	+ "new");
242	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL + "new").contains(
243	mockTask.getHandleIdentifier()));
244	}
245
246	public void testOrphanedSubtasks() {
247	MockRepositoryTask mockTask = new MockRepositoryTask("1");
248	MockRepositoryTask mockTask2 = new MockRepositoryTask("2");
249	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
250	TasksUiPlugin.getTaskListManager().getTaskList().addQuery(mockQuery);
251	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask, mockQuery);
252	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask2, mockTask);
253
254	assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
255	mockTask.getHandleIdentifier()));
256	assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
257	mockTask2.getHandleIdentifier()));
258
259	assertNotNull(taskList.getTask(mockTask.getHandleIdentifier()));
260	assertNotNull(taskList.getTask(mockTask2.getHandleIdentifier()));
261	assertNotNull(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL));
262	taskList.removeFromQuery(mockQuery, mockTask);
263	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
264	mockTask.getHandleIdentifier()));
265	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
266	mockTask2.getHandleIdentifier()));
267	taskList.deleteTask(mockTask);
268	assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
269	mockTask.getHandleIdentifier()));
270	// mockTask2 should be orphaned when the parent task is deleted
271	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
272	mockTask2.getHandleIdentifier()));
273	}
274
275	/**
276	* If a task with subtasks falls out of a query, if its subtasks are subtasks of another task that is still around,
277	* they shouldn't be in the archive.
278	*/
279	public void testOrphanedSubtaskWithOtherParent() {
280	MockRepositoryTask mockTask = new MockRepositoryTask("1");
281	MockRepositoryTask mockTask2 = new MockRepositoryTask("2");
282	MockRepositoryTask mockTask3 = new MockRepositoryTask("3");
283	MockRepositoryQuery mockQuery = new MockRepositoryQuery("mock query");
284	TasksUiPlugin.getTaskListManager().getTaskList().addQuery(mockQuery);
285	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask, mockQuery);
286	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask2, mockTask);
287	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask3, mockQuery);
288	TasksUiPlugin.getTaskListManager().getTaskList().addTask(mockTask2, mockTask3);
289	assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
290	mockTask.getHandleIdentifier()));
291	assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
292	mockTask2.getHandleIdentifier()));
293	assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
294	mockTask3.getHandleIdentifier()));
295
296	taskList.removeFromQuery(mockQuery, mockTask);
297	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
298	mockTask.getHandleIdentifier()));
299	assertFalse(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
300	mockTask2.getHandleIdentifier()));
301
302	taskList.removeFromQuery(mockQuery, mockTask3);
303	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
304	mockTask3.getHandleIdentifier()));
305	assertTrue(taskList.getOrphanContainer(MockRepositoryConnector.REPOSITORY_URL).contains(
306	mockTask2.getHandleIdentifier()));
307
308	}
309	}