Attachment #75245 for bug #189518

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





/**
 * @author Rob Elves
 * @author Jevgeni Holodkov
 */
public class TaskRepositoriesExternalizer {


				file.createNewFile();

			outputStream = new ZipOutputStream(new FileOutputStream(file));
			writeRepositoriesToZipEntry(repositories, outputStream);
			outputStream.putNextEntry(zipEntry);
			outputStream.setMethod(ZipOutputStream.DEFLATED);

			// OutputStream stream = new FileOutputStream(file);
			writer.setOutputStream(outputStream);
			writer.writeRepositoriesToStream(repositories);
			outputStream.flush();
			outputStream.closeEntry();
			outputStream.close();

		} catch (IOException e) {

		}
	}

	/**
	 * @param repositories
	 * @param outputStream
	 * @throws IOException
	 */
	public void writeRepositoriesToZipEntry(Collection<TaskRepository> repositories, ZipOutputStream outputStream)
			throws IOException {
		ZipEntry zipEntry = new ZipEntry(TaskRepositoryManager.OLD_REPOSITORIES_FILE);
		outputStream.putNextEntry(zipEntry);
		outputStream.setMethod(ZipOutputStream.DEFLATED);

		// OutputStream stream = new FileOutputStream(file);
		writer.setOutputStream(outputStream);
		writer.writeRepositoriesToStream(repositories);
		outputStream.flush();
		outputStream.closeEntry();
	}

	public Set<TaskRepository> readRepositoriesFromXML(File file) {

		if (!file.exists())

		InputStream inputStream = null;
		try {
			inputStream = new ZipInputStream(new FileInputStream(file));
			
			// search for REPOSITORIES entry
			ZipEntry entry = ((ZipInputStream) inputStream).getNextEntry();
			while (entry != null) {
				if (TaskRepositoryManager.OLD_REPOSITORIES_FILE.equals(entry.getName())) {
					break;
				}
				entry = ((ZipInputStream) inputStream).getNextEntry();
			}
			
			if (entry == null) {
				return null;
			}
			
			SaxRepositoriesContentHandler contentHandler = new SaxRepositoriesContentHandler();
			XMLReader reader = XMLReaderFactory.createXMLReader();
			reader.setContentHandler(contentHandler);

Lines 27-32 Link Here

(-)src/org/eclipse/mylyn/tasks/core/TaskRepositoryManager.java (+9 lines)
27	*	27	*
28	* @author Mik Kersten	28	* @author Mik Kersten
29	* @author Rob Elves	29	* @author Rob Elves
		30	* @author Jevgeni Holodkov
30	* @since 2.0	31	* @since 2.0
31	*/	32	*/
32	public class TaskRepositoryManager {	33	public class TaskRepositoryManager {
Lines 374-377 Link Here
374	listener.repositorySettingsChanged(repository);	375	listener.repositorySettingsChanged(repository);
375	}	376	}
376	}	377	}
		378
		379	public void insertRepositories(Set<TaskRepository> repositories, String repositoryFilePath) {
		380	for(TaskRepository repository : repositories) {
		381	if (getRepository(repository.getConnectorKind(), repository.getUrl()) == null) {
		382	addRepository(repository, repositoryFilePath);
		383	}
		384	}
		385	}
377	}	386	}

Lines 12-28 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/QueryExportImportTest.java (+67 lines)
12	package org.eclipse.mylyn.tasks.tests;	12	package org.eclipse.mylyn.tasks.tests;
13		13
14	import java.io.File;	14	import java.io.File;
		15	import java.io.FileInputStream;
15	import java.util.ArrayList;	16	import java.util.ArrayList;
16	import java.util.HashMap;	17	import java.util.HashMap;
17	import java.util.List;	18	import java.util.List;
18	import java.util.Map;	19	import java.util.Map;
19	import java.util.Set;	20	import java.util.Set;
		21	import java.util.zip.ZipEntry;
		22	import java.util.zip.ZipInputStream;
20		23
21	import junit.framework.TestCase;	24	import junit.framework.TestCase;
22		25
		26	import org.eclipse.mylyn.internal.tasks.core.TaskRepositoriesExternalizer;
		27	import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;
23	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;	28	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
24	import org.eclipse.mylyn.tasks.core.AbstractTaskListFactory;	29	import org.eclipse.mylyn.tasks.core.AbstractTaskListFactory;
25	import org.eclipse.mylyn.tasks.core.TaskRepository;	30	import org.eclipse.mylyn.tasks.core.TaskRepository;
		31	import org.eclipse.mylyn.tasks.core.TaskRepositoryManager;
26	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryConnector;	32	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryConnector;
27	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryQuery;	33	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryQuery;
28	import org.eclipse.mylyn.tasks.tests.connector.MockTaskListFactory;	34	import org.eclipse.mylyn.tasks.tests.connector.MockTaskListFactory;
Lines 70-76 Link Here
70	List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();	76	List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
71		77
72	MockRepositoryQuery query1 = new MockRepositoryQuery("Test Query");	78	MockRepositoryQuery query1 = new MockRepositoryQuery("Test Query");
		79	query1.setRepositoryUrl(MockRepositoryConnector.REPOSITORY_URL);
73	MockRepositoryQuery query2 = new MockRepositoryQuery("Test Query 2");	80	MockRepositoryQuery query2 = new MockRepositoryQuery("Test Query 2");
		81	query2.setRepositoryUrl(MockRepositoryConnector.REPOSITORY_URL);
74	queries.add(query1);	82	queries.add(query1);
75	queries.add(query2);	83	queries.add(query2);
76		84
Lines 237-242 Link Here
237	assertTrue("'Test Query' query inserted", queriesMap.containsKey("Test Query"));	245	assertTrue("'Test Query' query inserted", queriesMap.containsKey("Test Query"));
238	}	246	}
239		247
		248	public void testExportImportQueryWithRepositoryInfo() throws Exception {
		249	// prepare for test
		250	TasksUiPlugin.getTaskListManager().resetTaskList();
		251
		252	List<AbstractTaskListFactory> externalizers = new ArrayList<AbstractTaskListFactory>();
		253	externalizers.add(new MockTaskListFactory());
		254	TasksUiPlugin.getTaskListManager().getTaskListWriter().setDelegateExternalizers(externalizers);
		255
		256	TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL);
		257	TasksUiPlugin.getRepositoryManager().addRepository(repository, TasksUiPlugin.getDefault().getRepositoriesFilePath());
		258
		259	// create test data
		260	List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
		261	MockRepositoryQuery query1 = new MockRepositoryQuery("Test Query");
		262	query1.setRepositoryUrl(repository.getUrl());
		263	queries.add(query1);
		264
		265	File outFile = new File(dest, "test-repository-query.xml.zip");
		266
		267	TasksUiPlugin.getTaskListManager().getTaskListWriter().writeQueries(queries, outFile);
		268
		269	assertTrue(outFile.exists());
		270
		271	List<String> files = new ArrayList<String>();
		272	ZipInputStream inputStream = new ZipInputStream(new FileInputStream(outFile));
		273	ZipEntry entry = null;
		274	while ((entry = inputStream.getNextEntry()) != null) {
		275	files.add(entry.getName());
		276	}
		277	inputStream.close();
		278
		279	assertTrue("exported file contains a file with queries", files.contains(ITasksUiConstants.OLD_TASK_LIST_FILE));
		280	assertTrue("exported file contains a file with repositories", files.contains(TaskRepositoryManager.OLD_REPOSITORIES_FILE));
		281
		282
		283	TasksUiPlugin.getRepositoryManager().clearRepositories(TasksUiPlugin.getDefault().getRepositoriesFilePath());
		284	assertTrue("There are currently no repositories defined", TasksUiPlugin.getRepositoryManager().getRepository(
		285	MockRepositoryConnector.REPOSITORY_URL) == null);
		286
		287	List<AbstractRepositoryQuery> resultQueries = TasksUiPlugin.getTaskListManager().getTaskListWriter().readQueries(outFile);
		288	Set<TaskRepository> repositories = TasksUiPlugin.getTaskListManager().getTaskListWriter().readRepositories(outFile);
		289
		290	TasksUiPlugin.getRepositoryManager().insertRepositories(repositories, TasksUiPlugin.getDefault().getRepositoriesFilePath());
		291	TasksUiPlugin.getTaskListManager().insertQueries(resultQueries);
		292
		293	// extract results
		294	Set<AbstractRepositoryQuery> queriesSet = TasksUiPlugin.getTaskListManager().getTaskList().getQueries();
		295	Map<String, AbstractRepositoryQuery> queriesMap = new HashMap<String, AbstractRepositoryQuery>();
		296	for (AbstractRepositoryQuery query : queriesSet) {
		297	queriesMap.put(query.getHandleIdentifier(), query);
		298	}
		299
		300	// check that the actual result is correct
		301	assertTrue("'Test Query' query inserted", queriesMap.containsKey("Test Query"));
		302	assertTrue("1 repository is loaded", TasksUiPlugin.getRepositoryManager().getRepository(
		303	MockRepositoryConnector.REPOSITORY_URL) != null);
		304
		305	}
		306
240		307
241	private void removeFiles(File root) {	308	private void removeFiles(File root) {
242	if (root.isDirectory()) {	309	if (root.isDirectory()) {

Lines 18-23 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/connector/MockTaskListFactory.java (+2 lines)
18		18
19	/**	19	/**
20	* @author Mik Kersten	20	* @author Mik Kersten
		21	* @author Jevgeni Holodkov
21	*/	22	*/
22	public class MockTaskListFactory extends AbstractTaskListFactory {	23	public class MockTaskListFactory extends AbstractTaskListFactory {
23		24
Lines 52-57 Link Here
52	@Override	53	@Override
53	public AbstractRepositoryQuery createQuery(String repositoryUrl, String queryString, String label, Element element) {	54	public AbstractRepositoryQuery createQuery(String repositoryUrl, String queryString, String label, Element element) {
54	MockRepositoryQuery query = new MockRepositoryQuery(label, queryString);	55	MockRepositoryQuery query = new MockRepositoryQuery(label, queryString);
		56	query.setRepositoryUrl(repositoryUrl);
55	return query;	57	return query;
56	}	58	}
57		59

Lines 17-22 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/util/TaskListWriter.java (-10 / +59 lines)
17	import java.util.ArrayList;	17	import java.util.ArrayList;
18	import java.util.Date;	18	import java.util.Date;
19	import java.util.HashMap;	19	import java.util.HashMap;
		20	import java.util.HashSet;
20	import java.util.List;	21	import java.util.List;
21	import java.util.Map;	22	import java.util.Map;
22	import java.util.Set;	23	import java.util.Set;
Lines 40-52 Link Here
40	import org.eclipse.jface.dialogs.MessageDialog;	41	import org.eclipse.jface.dialogs.MessageDialog;
41	import org.eclipse.mylyn.internal.tasks.core.TaskDataManager;	42	import org.eclipse.mylyn.internal.tasks.core.TaskDataManager;
42	import org.eclipse.mylyn.internal.tasks.core.TaskExternalizationException;	43	import org.eclipse.mylyn.internal.tasks.core.TaskExternalizationException;
		44	import org.eclipse.mylyn.internal.tasks.core.TaskRepositoriesExternalizer;
43	import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;	45	import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;
44	import org.eclipse.mylyn.monitor.core.StatusHandler;	46	import org.eclipse.mylyn.monitor.core.StatusHandler;
45	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;	47	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
46	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
47	import org.eclipse.mylyn.tasks.core.AbstractTask;	48	import org.eclipse.mylyn.tasks.core.AbstractTask;
		49	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
48	import org.eclipse.mylyn.tasks.core.AbstractTaskListFactory;	50	import org.eclipse.mylyn.tasks.core.AbstractTaskListFactory;
49	import org.eclipse.mylyn.tasks.core.TaskList;	51	import org.eclipse.mylyn.tasks.core.TaskList;
		52	import org.eclipse.mylyn.tasks.core.TaskRepository;
		53	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
50	import org.w3c.dom.Document;	54	import org.w3c.dom.Document;
51	import org.w3c.dom.Element;	55	import org.w3c.dom.Element;
52	import org.w3c.dom.Node;	56	import org.w3c.dom.Node;
Lines 82-87 Link Here
82	private List<AbstractTaskListFactory> externalizers;	86	private List<AbstractTaskListFactory> externalizers;
83		87
84	private DelegatingTaskExternalizer delagatingExternalizer;	88	private DelegatingTaskExternalizer delagatingExternalizer;
		89
		90	private TaskRepositoriesExternalizer repositoriesExternalizer;
85		91
86	private List<Node> orphanedTaskNodes = new ArrayList<Node>();	92	private List<Node> orphanedTaskNodes = new ArrayList<Node>();
87		93
Lines 93-98 Link Here
93		99
94	public TaskListWriter() {	100	public TaskListWriter() {
95	this.delagatingExternalizer = new DelegatingTaskExternalizer();	101	this.delagatingExternalizer = new DelegatingTaskExternalizer();
		102	this.repositoriesExternalizer = new TaskRepositoriesExternalizer();
96	}	103	}
97		104
98	public void setDelegateExternalizers(List<AbstractTaskListFactory> externalizers) {	105	public void setDelegateExternalizers(List<AbstractTaskListFactory> externalizers) {
Lines 196-208 Link Here
196	private void writeDOMtoFile(Document doc, File file) {	203	private void writeDOMtoFile(Document doc, File file) {
197	try {	204	try {
198	ZipOutputStream outputStream = new ZipOutputStream(new FileOutputStream(file));	205	ZipOutputStream outputStream = new ZipOutputStream(new FileOutputStream(file));
199	ZipEntry zipEntry = new ZipEntry(ITasksUiConstants.OLD_TASK_LIST_FILE);	206	writeTaskListToZipEntry(doc, outputStream);
200	outputStream.putNextEntry(zipEntry);
201	outputStream.setMethod(ZipOutputStream.DEFLATED);
202	// OutputStream outputStream = new FileOutputStream(file);
203	writeDOMtoStream(doc, outputStream);
204	outputStream.flush();
205	outputStream.closeEntry();
206	outputStream.close();	207	outputStream.close();
207	} catch (Exception fnfe) {	208	} catch (Exception fnfe) {
208	StatusHandler.log(fnfe, "TaskList could not be found");	209	StatusHandler.log(fnfe, "TaskList could not be found");
Lines 210-215 Link Here
210	}	211	}
211		212
212	/**	213	/**
		214	* @param doc
		215	* @param outputStream
		216	* @throws IOException
		217	*/
		218	private void writeTaskListToZipEntry(Document doc, ZipOutputStream outputStream) throws IOException {
		219	ZipEntry zipEntry = new ZipEntry(ITasksUiConstants.OLD_TASK_LIST_FILE);
		220	outputStream.putNextEntry(zipEntry);
		221	outputStream.setMethod(ZipOutputStream.DEFLATED);
		222	// OutputStream outputStream = new FileOutputStream(file);
		223	writeDOMtoStream(doc, outputStream);
		224	outputStream.flush();
		225	outputStream.closeEntry();
		226	}
		227
		228	/**
213	* Writes the provided XML document out to the specified output stream.	229	* Writes the provided XML document out to the specified output stream.
214	*	230	*
215	* doc - the document to be written outputStream - the stream to which the document is to be written	231	* doc - the document to be written outputStream - the stream to which the document is to be written
Lines 427-433 Link Here
427	if (inputFile.getName().endsWith(ITasksUiConstants.FILE_EXTENSION)) {	443	if (inputFile.getName().endsWith(ITasksUiConstants.FILE_EXTENSION)) {
428	// is zipped context	444	// is zipped context
429	inputStream = new ZipInputStream(new FileInputStream(inputFile));	445	inputStream = new ZipInputStream(new FileInputStream(inputFile));
430	((ZipInputStream) inputStream).getNextEntry();	446	// search for TaskList entry
		447	ZipEntry entry = ((ZipInputStream) inputStream).getNextEntry();
		448	while (entry != null) {
		449	if (ITasksUiConstants.OLD_TASK_LIST_FILE.equals(entry.getName())) {
		450	break;
		451	}
		452	entry = ((ZipInputStream) inputStream).getNextEntry();
		453	}
		454	if (entry == null) {
		455	return null;
		456	}
431	} else {	457	} else {
432	inputStream = new FileInputStream(inputFile);	458	inputStream = new FileInputStream(inputFile);
433	}	459	}
Lines 494-502 Link Here
494	}	520	}
495		521
496	public void writeQueries(List<AbstractRepositoryQuery> queries, File outFile) {	522	public void writeQueries(List<AbstractRepositoryQuery> queries, File outFile) {
		523	Set<TaskRepository> repositories = new HashSet<TaskRepository>();
		524	for (AbstractRepositoryQuery query : queries) {
		525	TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(query.getRepositoryUrl());
		526	if (repository != null) {
		527	repositories.add(repository);
		528	}
		529	}
		530
497	Document doc = createQueryDocument(queries);	531	Document doc = createQueryDocument(queries);
498	if (doc != null) {	532	if (doc != null) {
499	writeDOMtoFile(doc, outFile);	533	try {
		534	ZipOutputStream outputStream = new ZipOutputStream(new FileOutputStream(outFile));
		535	writeTaskListToZipEntry(doc, outputStream);
		536	repositoriesExternalizer.writeRepositoriesToZipEntry(repositories, outputStream);
		537	outputStream.close();
		538	} catch (Exception fnfe) {
		539	StatusHandler.log(fnfe, "TaskList could not be found");
		540	}
500	}	541	}
501	return;	542	return;
502	}	543	}
Lines 582-585 Link Here
582		623
583	return queries;	624	return queries;
584	}	625	}
		626
		627	public Set<TaskRepository> readRepositories(File file) {
		628	Set<TaskRepository> repository = repositoriesExternalizer.readRepositoriesFromXML(file);
		629	if (repository == null) {
		630	repository = new HashSet<TaskRepository>();
		631	}
		632	return repository;
		633	}
585	}	634	}

Lines 10-15 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/actions/QueryImportAction.java (-18 / +34 lines)
10		10
11	import java.io.File;	11	import java.io.File;
12	import java.util.List;	12	import java.util.List;
		13	import java.util.Set;
13		14
14	import org.eclipse.jface.action.Action;	15	import org.eclipse.jface.action.Action;
15	import org.eclipse.jface.action.IAction;	16	import org.eclipse.jface.action.IAction;
Lines 17-22 Link Here
17	import org.eclipse.jface.viewers.ISelection;	18	import org.eclipse.jface.viewers.ISelection;
18	import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;	19	import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;
19	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;	20	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
		21	import org.eclipse.mylyn.tasks.core.TaskRepository;
20	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;	22	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
21	import org.eclipse.swt.widgets.FileDialog;	23	import org.eclipse.swt.widgets.FileDialog;
22	import org.eclipse.swt.widgets.Shell;	24	import org.eclipse.swt.widgets.Shell;
Lines 58-82 Link Here
58	.getTaskListWriter()	60	.getTaskListWriter()
59	.readQueries(file);	61	.readQueries(file);
60		62
		63	Set<TaskRepository> repositories = TasksUiPlugin.getTaskListManager()
		64	.getTaskListWriter()
		65	.readRepositories(file);
		66
61	if (queries.size() > 0) {	67	if (queries.size() > 0) {
62	List<AbstractRepositoryQuery> badQueries = TasksUiPlugin.getTaskListManager().insertQueries(queries);	68	importQueries(queries, repositories, shell);
63
64	// notify user about importing
65	String message = "The following queries were imported successfully: ";
66	for(AbstractRepositoryQuery imported : queries) {
67	if(!badQueries.contains(imported)) {
68	message += "\n" + imported.getHandleIdentifier();
69	}
70	}
71
72	if(badQueries.size() > 0) {
73	message += "\n\n These queries were not imported, since their repository was not found: ";
74	for (AbstractRepositoryQuery bad : badQueries) {
75	message += "\n" + bad.getHandleIdentifier();
76	}
77	}
78
79	MessageDialog.openInformation(shell, "Query Export Completed", message);
80	} else {	69	} else {
81	MessageDialog.openError(shell, "Query Export Error",	70	MessageDialog.openError(shell, "Query Export Error",
82	"The specified file is not an exported query. Please, check that you have provided the correct file.");	71	"The specified file is not an exported query. Please, check that you have provided the correct file.");
Lines 87-90 Link Here
87	return;	76	return;
88	}	77	}
89		78
		79	/**
		80	* @param queries
		81	* @param repositories
		82	* @param shell
		83	*/
		84	public void importQueries(List<AbstractRepositoryQuery> queries, Set<TaskRepository> repositories, Shell shell) {
		85	TasksUiPlugin.getRepositoryManager().insertRepositories(repositories, TasksUiPlugin.getDefault().getRepositoriesFilePath());
		86	List<AbstractRepositoryQuery> badQueries = TasksUiPlugin.getTaskListManager().insertQueries(queries);
		87
		88	// notify user about importing
		89	String message = "The following queries were imported successfully: ";
		90	for(AbstractRepositoryQuery imported : queries) {
		91	if(!badQueries.contains(imported)) {
		92	message += "\n" + imported.getHandleIdentifier();
		93	}
		94	}
		95
		96	if(badQueries.size() > 0) {
		97	message += "\n\n These queries were not imported, since their repository was not found: ";
		98	for (AbstractRepositoryQuery bad : badQueries) {
		99	message += "\n" + bad.getHandleIdentifier();
		100	}
		101	}
		102
		103	MessageDialog.openInformation(shell, "Query Export Completed", message);
		104	}
		105
90	}	106	}




import java.io.File;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.mylyn.internal.tasks.ui.ITasksUiConstants;
import org.eclipse.mylyn.internal.tasks.ui.RetrieveTitleFromUrlJob;
import org.eclipse.mylyn.internal.tasks.ui.TaskTransfer;
import org.eclipse.mylyn.internal.tasks.ui.actions.QueryImportAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.TaskActivateAction;
import org.eclipse.mylyn.monitor.core.StatusHandler;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;

/**
 * @author Mik Kersten
 * @author Rob Elves (added URL based task creation support)
 * @author Jevgeni Holodkov
 */
public class TaskListDropAdapter extends ViewerDropAdapter {


		} else if (data instanceof String && createTaskFromString((String) data)) {
			tasksToMove.add(newTask);
		} else if (FileTransfer.getInstance().isSupportedType(currentTransfer)) {
			// transfer the context if the target is a Task
			if (getCurrentTarget() instanceof AbstractTask) {
				AbstractTask targetTask = (AbstractTask) getCurrentTarget();
			}
			if (targetTask != null) {
				final String[] names = (String[]) data;
				boolean confirmed = MessageDialog.openConfirm(getViewer().getControl().getShell(),
						ITasksUiConstants.TITLE_DIALOG, "Overwrite the context of the target task with the source's?");

						new TaskActivateAction().run(targetTask);
					}
				}
			} else {
				// otherwise it is queries
				final String[] names = (String[]) data;
				List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
				Set<TaskRepository> repositories = new HashSet<TaskRepository>();
				for (int i = 0; i < names.length; i++) {
					String path = names[i];
					File file = new File(path);
					if (file.isFile()) {
						queries.addAll(TasksUiPlugin.getTaskListManager().getTaskListWriter().readQueries(file));
						repositories.addAll(TasksUiPlugin.getTaskListManager().getTaskListWriter().readRepositories(file));
					}
				}
				if (queries.size() > 0) {
					new QueryImportAction().importQueries(queries, repositories, getViewer().getControl().getShell());
				}
			}
		}



		Object selectedObject = ((IStructuredSelection) ((TreeViewer) getViewer()).getSelection()).getFirstElement();
		if (FileTransfer.getInstance().isSupportedType(currentTransfer)) {
			// handle all files
			return true;
			}
		} else if (selectedObject != null && !(selectedObject instanceof AbstractRepositoryQuery)) {
			if (getCurrentTarget() instanceof TaskCategory || getCurrentTarget() instanceof UnfiledCategory) {
				return true;

Return to bug 189518