org.eclipse.mylyn.team.ui/src/org/eclipse/mylyn/internal/team/ui/actions/TaskFinder.java - mylyn/org.eclipse.mylyn.context - Git at Google

 /*******************************************************************************
  * Copyright (c) 2004, 2016 Tasktop Technologies 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
  *
  * Contributors:
  *     Tasktop Technologies - initial API and implementation
  *     Eugene Kuleshov - improvements
  *******************************************************************************/

 package org.eclipse.mylyn.internal.team.ui.actions;

 import java.net.URL;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Set;

 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.jface.dialogs.MessageDialog;
 import org.eclipse.mylyn.commons.workbench.EditorHandle;
 import org.eclipse.mylyn.internal.tasks.core.RepositoryTaskHandleUtil;
 import org.eclipse.mylyn.internal.tasks.core.TaskList;
 import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryManager;
 import org.eclipse.mylyn.internal.tasks.ui.OpenRepositoryTaskJob;
 import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
 import org.eclipse.mylyn.internal.tasks.ui.actions.OpenRepositoryTaskAction;
 import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
 import org.eclipse.mylyn.internal.team.ui.FocusedTeamUiPlugin;
 import org.eclipse.mylyn.internal.team.ui.LinkedTaskInfo;
 import org.eclipse.mylyn.internal.team.ui.templates.CommitTemplateManager;
 import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
 import org.eclipse.mylyn.tasks.core.ITask;
 import org.eclipse.mylyn.tasks.core.TaskRepository;
 import org.eclipse.mylyn.tasks.ui.AbstractRepositoryConnectorUi;
 import org.eclipse.mylyn.tasks.ui.TasksUi;
 import org.eclipse.mylyn.tasks.ui.TasksUiUtil;
 import org.eclipse.mylyn.team.ui.AbstractTaskReference;
 import org.eclipse.ui.IWorkbenchPage;
 import org.eclipse.ui.IWorkbenchWindow;
 import org.eclipse.ui.PlatformUI;

 /**
  * Action used to open linked task. TODO: this class has evolved into a complete mess and has to be fixed.
  *
  * @author Mik Kersten
  * @author Eugene Kuleshov
  */
 public class TaskFinder {

 	private static final String PREFIX_HTTP = "http://"; //$NON-NLS-1$

 	private static final String PREFIX_HTTPS = "https://"; //$NON-NLS-1$

 	public static String getTaskIdFromLegacy07Label(String comment) {
 		String PREFIX_DELIM = ":"; //$NON-NLS-1$
 		String PREFIX_START_1 = Messages.OpenCorrespondingTaskAction_Progress_on;
 		String PREFIX_START_2 = Messages.OpenCorrespondingTaskAction_Completed;
 		String usedPrefix = PREFIX_START_1;
 		int firstDelimIndex = comment.indexOf(PREFIX_START_1);
 		if (firstDelimIndex == -1) {
 			firstDelimIndex = comment.indexOf(PREFIX_START_2);
 			usedPrefix = PREFIX_START_2;
 		}
 		if (firstDelimIndex != -1) {
 			int idStart = firstDelimIndex + usedPrefix.length();
 			int idEnd = comment.indexOf(PREFIX_DELIM, firstDelimIndex + usedPrefix.length());// comment.indexOf(PREFIX_DELIM);
 			if (idEnd != -1 && idStart < idEnd) {
 				String id = comment.substring(idStart, idEnd);
 				if (id != null) {
 					return id.trim();
 				}
 			} else {
 				return comment.substring(0, firstDelimIndex);
 			}
 		}
 		return null;
 	}

 	public static String getUrlFromComment(String comment) {
 		int httpIndex = comment.indexOf(PREFIX_HTTP);
 		int httpsIndex = comment.indexOf(PREFIX_HTTPS);
 		int idStart = -1;
 		if (httpIndex != -1) {
 			idStart = httpIndex;
 		} else if (httpsIndex != -1) {
 			idStart = httpsIndex;
 		}
 		if (idStart != -1) {
 			int idEnd;
 			for (idEnd = idStart; idEnd < comment.length() && !Character.isWhitespace(comment.charAt(idEnd)); idEnd++) {
 				;
 			}
 			return comment.substring(idStart, idEnd);
 		}
 		return null;
 	}

 	/**
 	 * Reconcile <code>ILinkedTaskInfo</code> data. This is used in order to keep LinkedTaskInfo lightweight with
 	 * minimal dependencies.
 	 */
 	private static AbstractTaskReference reconcile(AbstractTaskReference info) {
 		ITask task;
 		long timestamp;

 		if (info instanceof LinkedTaskInfo) {
 			task = ((LinkedTaskInfo) info).getTask();
 			timestamp = ((LinkedTaskInfo) info).getTimestamp();
 		} else {
 			task = null;
 			timestamp = 0;
 		}

 		if (task != null) {
 			return info;
 		}

 		String repositoryUrl = info.getRepositoryUrl();
 		String taskId = info.getTaskId();
 		String taskFullUrl = info.getTaskUrl();
 		String comment = info.getText();

 		TaskRepositoryManager repositoryManager = TasksUiPlugin.getRepositoryManager();

 		TaskRepository repository = null;
 		if (repositoryUrl != null) {
 			repository = repositoryManager.getRepository(repositoryUrl);
 		}

 		if (taskFullUrl == null && comment != null) {
 			taskFullUrl = getUrlFromComment(comment);
 		}

 		AbstractRepositoryConnector connector = null;
 		if (taskFullUrl != null) {
 			connector = repositoryManager.getConnectorForRepositoryTaskUrl(taskFullUrl);
 		}
 		if (connector == null && repository != null) {
 			connector = repositoryManager.getRepositoryConnector(repository.getConnectorKind());
 		}

 		if (repositoryUrl == null && connector != null) {
 			repositoryUrl = connector.getRepositoryUrlFromTaskUrl(taskFullUrl);
 			if (repository == null) {
 				repository = repositoryManager.getRepository(repositoryUrl);
 			}
 		}

 		if (taskId == null && connector != null) {
 			taskId = connector.getTaskIdFromTaskUrl(taskFullUrl);
 		}

 		// XXX: clean up and remove break to label
 		if (taskId == null && comment != null) {
 			Collection<AbstractRepositoryConnector> connectors = connector != null
 					? Collections.singletonList(connector)
 					: TasksUi.getRepositoryManager().getRepositoryConnectors();
 			REPOSITORIES: for (AbstractRepositoryConnector c : connectors) {
 				Collection<TaskRepository> repositories = repository != null
 						? Collections.singletonList(repository)
 						: TasksUi.getRepositoryManager().getRepositories(c.getConnectorKind());
 				for (TaskRepository r : repositories) {
 					String[] ids = c.getTaskIdsFromComment(r, comment);
 					if (ids != null && ids.length > 0) {
 						taskId = ids[0];
 						connector = c;
 						repository = r;
 						repositoryUrl = r.getRepositoryUrl();
 						break REPOSITORIES;
 					}
 				}
 			}
 		}
 		if (taskId == null && comment != null) {
 			CommitTemplateManager commitTemplateManager = FocusedTeamUiPlugin.getDefault().getCommitTemplateManager();
 			taskId = commitTemplateManager.getTaskIdFromCommentOrLabel(comment);
 			if (taskId == null) {
 				taskId = getTaskIdFromLegacy07Label(comment);
 			}
 		}

 		if (taskFullUrl == null && repositoryUrl != null && taskId != null && connector != null) {
 			taskFullUrl = connector.getTaskUrl(repositoryUrl, taskId);
 		}

 		if (task == null) {
 			if (taskId != null && repositoryUrl != null) {
 				// XXX fix this hack (jira ids don't work here)
 				if (!taskId.contains(RepositoryTaskHandleUtil.HANDLE_DELIM)) {
 					task = TasksUiInternal.getTaskList().getTask(repositoryUrl, taskId);
 				}
 			}
 			if (task == null && taskFullUrl != null) {
 				task = TasksUiInternal.getTaskByUrl(taskFullUrl);
 			}
 		}

 		return new LinkedTaskInfo(repositoryUrl, taskId, taskFullUrl, comment, timestamp, task);
 	}

 	private final AbstractTaskReference reference;

 	private ITask task;

 	private long timestamp;

 	public TaskFinder(Object element) {
 		this.reference = initialize(element);
 	}

 	public AbstractTaskReference getReference() {
 		return reference;
 	}

 	public ITask getTask() {
 		return task;
 	}

 	private AbstractTaskReference initialize(Object element) {
 		AbstractTaskReference info = null;
 		if (element instanceof AbstractTaskReference) {
 			info = (AbstractTaskReference) element;
 		} else if (element instanceof IAdaptable) {
 			info = (AbstractTaskReference) ((IAdaptable) element).getAdapter(AbstractTaskReference.class);
 		}
 		if (info == null) {
 			info = (AbstractTaskReference) Platform.getAdapterManager().getAdapter(element,
 					AbstractTaskReference.class);
 		}

 		if (info != null) {
 			info = reconcile(info);
 			if (info instanceof LinkedTaskInfo) {
 				task = ((LinkedTaskInfo) info).getTask();
 				timestamp = ((LinkedTaskInfo) info).getTimestamp();
 			}
 		}
 		return info;
 	}

 	public EditorHandle openTaskByKey(IWorkbenchPage page) {
 		if (reference != null) {
 			String taskUrl = reference.getTaskUrl();
 			if (taskUrl != null && openTaskByKey(page, taskUrl)) {
 				return new EditorHandle(Status.OK_STATUS);
 			}
 		}
 		return null;
 	}

 	public IStatus open() {
 		if (reference != null) {
 			if (task != null) {
 				PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
 					public void run() {
 						TasksUiUtil.openTask(task);
 					}
 				});
 				return Status.OK_STATUS;
 			}

 			if (reference.getRepositoryUrl() != null && reference.getTaskId() != null) {
 				TaskRepository repository = TasksUiPlugin.getRepositoryManager()
 						.getRepository(reference.getRepositoryUrl());
 				String taskId = reference.getTaskId();
 				if (repository != null && taskId != null) {
 					AbstractRepositoryConnectorUi connectorUi = TasksUiPlugin
 							.getConnectorUi(repository.getConnectorKind());
 					if (connectorUi != null) {
 						TasksUiInternal.openRepositoryTask(connectorUi.getConnectorKind(),
 								repository.getRepositoryUrl(), taskId, null, timestamp);
 						return Status.OK_STATUS;
 					}
 				}
 			}

 			final String taskFullUrl = reference.getTaskUrl();
 			if (taskFullUrl != null) {
 				if (!openTaskByKey(getActivePage(), taskFullUrl)) {
 					PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
 						public void run() {
 							TasksUiUtil.openUrl(taskFullUrl);
 						}
 					});
 				}
 				return Status.OK_STATUS;
 			}
 		}

 		// task not found
 		PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
 			public void run() {
 				IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
 				boolean openDialog = MessageDialog.openQuestion(window.getShell(),
 						Messages.OpenCorrespondingTaskAction_Open_Task,
 						Messages.OpenCorrespondingTaskAction_Unable_to_match_task);
 				if (openDialog) {
 					new OpenRepositoryTaskAction().run(null);
 				}
 			}
 		});
 		return Status.OK_STATUS;
 	}

 	private boolean openTaskByKey(IWorkbenchPage page, final String taskFullUrl) {
 		String taskKey = null;
 		TaskRepository repository = guessRepository(taskFullUrl);
 		if (repository != null) {
 			AbstractRepositoryConnector connector = TasksUiPlugin.getRepositoryManager()
 					.getRepositoryConnector(repository.getConnectorKind());
 			if (connector != null) {
 				taskKey = guessTaskKey(connector, repository, taskFullUrl);
 			}
 		}
 		if (taskKey != null && page != null) {
 			new OpenRepositoryTaskJob(repository, taskKey, taskFullUrl, page).schedule();
 			return true;
 		}
 		return false;
 	}

 	private IWorkbenchPage getActivePage() {
 		IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
 		if (window != null) {
 			return window.getActivePage();
 		}
 		return null;
 	}

 	private TaskRepository guessRepository(String taskFullUrl) {
 		for (TaskRepository repository : TasksUi.getRepositoryManager().getAllRepositories()) {
 			if (taskFullUrl.startsWith(repository.getRepositoryUrl())) {
 				return repository;
 			}
 		}
 		return null;
 	}

 	/**
 	 * Using a task for which we know the task key and browser URL, try to guess the task key from the given URL.
 	 */
 	private static String guessTaskKey(AbstractRepositoryConnector connector, TaskRepository repository,
 			String taskFullUrl) {
 		Set<ITask> tasks = ((TaskList) TasksUiInternal.getTaskList()).getTasks(repository.getRepositoryUrl());
 		if (!tasks.isEmpty()) {
 			ITask task = tasks.iterator().next();
 			URL browserUrl = connector.getBrowserUrl(repository, task);
 			if (browserUrl != null) {
 				return guessTaskKey(taskFullUrl, browserUrl.toExternalForm(), task.getTaskKey());
 			}
 		}
 		return null;
 	}

 	/**
 	 * @noreference This method is not intended to be referenced by clients.
 	 */
 	public static String guessTaskKey(String taskFullUrl, String knownTaskUrl, String knownTaskKey) {
 		int index = knownTaskUrl.indexOf(knownTaskKey);
 		if (index != -1) {
 			String prefix = knownTaskUrl.substring(0, index);
 			String postfix = knownTaskUrl.substring(index + knownTaskKey.length());
 			return extractTaskId(taskFullUrl, prefix, postfix);
 		}
 		return null;
 	}

 	/**
 	 * @noreference This method is not intended to be referenced by clients.
 	 */
 	public static String extractTaskId(String taskFullUrl, String prefix, String postfix) {
 		if (!prefix.isEmpty() && taskFullUrl.startsWith(prefix) && taskFullUrl.endsWith(postfix)) {
 			return taskFullUrl.substring(prefix.length(), taskFullUrl.length() - postfix.length());
 		}
 		return null;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2004, 2016 Tasktop Technologies 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
	*
	* Contributors:
	* Tasktop Technologies - initial API and implementation
	* Eugene Kuleshov - improvements
	*******************************************************************************/

	package org.eclipse.mylyn.internal.team.ui.actions;

	import java.net.URL;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.Set;

	import org.eclipse.core.runtime.IAdaptable;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.Platform;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.jface.dialogs.MessageDialog;
	import org.eclipse.mylyn.commons.workbench.EditorHandle;
	import org.eclipse.mylyn.internal.tasks.core.RepositoryTaskHandleUtil;
	import org.eclipse.mylyn.internal.tasks.core.TaskList;
	import org.eclipse.mylyn.internal.tasks.core.TaskRepositoryManager;
	import org.eclipse.mylyn.internal.tasks.ui.OpenRepositoryTaskJob;
	import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
	import org.eclipse.mylyn.internal.tasks.ui.actions.OpenRepositoryTaskAction;
	import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
	import org.eclipse.mylyn.internal.team.ui.FocusedTeamUiPlugin;
	import org.eclipse.mylyn.internal.team.ui.LinkedTaskInfo;
	import org.eclipse.mylyn.internal.team.ui.templates.CommitTemplateManager;
	import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
	import org.eclipse.mylyn.tasks.core.ITask;
	import org.eclipse.mylyn.tasks.core.TaskRepository;
	import org.eclipse.mylyn.tasks.ui.AbstractRepositoryConnectorUi;
	import org.eclipse.mylyn.tasks.ui.TasksUi;
	import org.eclipse.mylyn.tasks.ui.TasksUiUtil;
	import org.eclipse.mylyn.team.ui.AbstractTaskReference;
	import org.eclipse.ui.IWorkbenchPage;
	import org.eclipse.ui.IWorkbenchWindow;
	import org.eclipse.ui.PlatformUI;

	/**
	* Action used to open linked task. TODO: this class has evolved into a complete mess and has to be fixed.
	*
	* @author Mik Kersten
	* @author Eugene Kuleshov
	*/
	public class TaskFinder {

	private static final String PREFIX_HTTP = "http://"; //$NON-NLS-1$

	private static final String PREFIX_HTTPS = "https://"; //$NON-NLS-1$

	public static String getTaskIdFromLegacy07Label(String comment) {
	String PREFIX_DELIM = ":"; //$NON-NLS-1$
	String PREFIX_START_1 = Messages.OpenCorrespondingTaskAction_Progress_on;
	String PREFIX_START_2 = Messages.OpenCorrespondingTaskAction_Completed;
	String usedPrefix = PREFIX_START_1;
	int firstDelimIndex = comment.indexOf(PREFIX_START_1);
	if (firstDelimIndex == -1) {
	firstDelimIndex = comment.indexOf(PREFIX_START_2);
	usedPrefix = PREFIX_START_2;
	}
	if (firstDelimIndex != -1) {
	int idStart = firstDelimIndex + usedPrefix.length();
	int idEnd = comment.indexOf(PREFIX_DELIM, firstDelimIndex + usedPrefix.length());// comment.indexOf(PREFIX_DELIM);
	if (idEnd != -1 && idStart < idEnd) {
	String id = comment.substring(idStart, idEnd);
	if (id != null) {
	return id.trim();
	}
	} else {
	return comment.substring(0, firstDelimIndex);
	}
	}
	return null;
	}

	public static String getUrlFromComment(String comment) {
	int httpIndex = comment.indexOf(PREFIX_HTTP);
	int httpsIndex = comment.indexOf(PREFIX_HTTPS);
	int idStart = -1;
	if (httpIndex != -1) {
	idStart = httpIndex;
	} else if (httpsIndex != -1) {
	idStart = httpsIndex;
	}
	if (idStart != -1) {
	int idEnd;
	for (idEnd = idStart; idEnd < comment.length() && !Character.isWhitespace(comment.charAt(idEnd)); idEnd++) {
	;
	}
	return comment.substring(idStart, idEnd);
	}
	return null;
	}

	/**
	* Reconcile <code>ILinkedTaskInfo</code> data. This is used in order to keep LinkedTaskInfo lightweight with
	* minimal dependencies.
	*/
	private static AbstractTaskReference reconcile(AbstractTaskReference info) {
	ITask task;
	long timestamp;

	if (info instanceof LinkedTaskInfo) {
	task = ((LinkedTaskInfo) info).getTask();
	timestamp = ((LinkedTaskInfo) info).getTimestamp();
	} else {
	task = null;
	timestamp = 0;
	}

	if (task != null) {
	return info;
	}

	String repositoryUrl = info.getRepositoryUrl();
	String taskId = info.getTaskId();
	String taskFullUrl = info.getTaskUrl();
	String comment = info.getText();

	TaskRepositoryManager repositoryManager = TasksUiPlugin.getRepositoryManager();

	TaskRepository repository = null;
	if (repositoryUrl != null) {
	repository = repositoryManager.getRepository(repositoryUrl);
	}

	if (taskFullUrl == null && comment != null) {
	taskFullUrl = getUrlFromComment(comment);
	}

	AbstractRepositoryConnector connector = null;
	if (taskFullUrl != null) {
	connector = repositoryManager.getConnectorForRepositoryTaskUrl(taskFullUrl);
	}
	if (connector == null && repository != null) {
	connector = repositoryManager.getRepositoryConnector(repository.getConnectorKind());
	}

	if (repositoryUrl == null && connector != null) {
	repositoryUrl = connector.getRepositoryUrlFromTaskUrl(taskFullUrl);
	if (repository == null) {
	repository = repositoryManager.getRepository(repositoryUrl);
	}
	}

	if (taskId == null && connector != null) {
	taskId = connector.getTaskIdFromTaskUrl(taskFullUrl);
	}

	// XXX: clean up and remove break to label
	if (taskId == null && comment != null) {
	Collection<AbstractRepositoryConnector> connectors = connector != null
	? Collections.singletonList(connector)
	: TasksUi.getRepositoryManager().getRepositoryConnectors();
	REPOSITORIES: for (AbstractRepositoryConnector c : connectors) {
	Collection<TaskRepository> repositories = repository != null
	? Collections.singletonList(repository)
	: TasksUi.getRepositoryManager().getRepositories(c.getConnectorKind());
	for (TaskRepository r : repositories) {
	String[] ids = c.getTaskIdsFromComment(r, comment);
	if (ids != null && ids.length > 0) {
	taskId = ids[0];
	connector = c;
	repository = r;
	repositoryUrl = r.getRepositoryUrl();
	break REPOSITORIES;
	}
	}
	}
	}
	if (taskId == null && comment != null) {
	CommitTemplateManager commitTemplateManager = FocusedTeamUiPlugin.getDefault().getCommitTemplateManager();
	taskId = commitTemplateManager.getTaskIdFromCommentOrLabel(comment);
	if (taskId == null) {
	taskId = getTaskIdFromLegacy07Label(comment);
	}
	}

	if (taskFullUrl == null && repositoryUrl != null && taskId != null && connector != null) {
	taskFullUrl = connector.getTaskUrl(repositoryUrl, taskId);
	}

	if (task == null) {
	if (taskId != null && repositoryUrl != null) {
	// XXX fix this hack (jira ids don't work here)
	if (!taskId.contains(RepositoryTaskHandleUtil.HANDLE_DELIM)) {
	task = TasksUiInternal.getTaskList().getTask(repositoryUrl, taskId);
	}
	}
	if (task == null && taskFullUrl != null) {
	task = TasksUiInternal.getTaskByUrl(taskFullUrl);
	}
	}

	return new LinkedTaskInfo(repositoryUrl, taskId, taskFullUrl, comment, timestamp, task);
	}

	private final AbstractTaskReference reference;

	private ITask task;

	private long timestamp;

	public TaskFinder(Object element) {
	this.reference = initialize(element);
	}

	public AbstractTaskReference getReference() {
	return reference;
	}

	public ITask getTask() {
	return task;
	}

	private AbstractTaskReference initialize(Object element) {
	AbstractTaskReference info = null;
	if (element instanceof AbstractTaskReference) {
	info = (AbstractTaskReference) element;
	} else if (element instanceof IAdaptable) {
	info = (AbstractTaskReference) ((IAdaptable) element).getAdapter(AbstractTaskReference.class);
	}
	if (info == null) {
	info = (AbstractTaskReference) Platform.getAdapterManager().getAdapter(element,
	AbstractTaskReference.class);
	}

	if (info != null) {
	info = reconcile(info);
	if (info instanceof LinkedTaskInfo) {
	task = ((LinkedTaskInfo) info).getTask();
	timestamp = ((LinkedTaskInfo) info).getTimestamp();
	}
	}
	return info;
	}

	public EditorHandle openTaskByKey(IWorkbenchPage page) {
	if (reference != null) {
	String taskUrl = reference.getTaskUrl();
	if (taskUrl != null && openTaskByKey(page, taskUrl)) {
	return new EditorHandle(Status.OK_STATUS);
	}
	}
	return null;
	}

	public IStatus open() {
	if (reference != null) {
	if (task != null) {
	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
	public void run() {
	TasksUiUtil.openTask(task);
	}
	});
	return Status.OK_STATUS;
	}

	if (reference.getRepositoryUrl() != null && reference.getTaskId() != null) {
	TaskRepository repository = TasksUiPlugin.getRepositoryManager()
	.getRepository(reference.getRepositoryUrl());
	String taskId = reference.getTaskId();
	if (repository != null && taskId != null) {
	AbstractRepositoryConnectorUi connectorUi = TasksUiPlugin
	.getConnectorUi(repository.getConnectorKind());
	if (connectorUi != null) {
	TasksUiInternal.openRepositoryTask(connectorUi.getConnectorKind(),
	repository.getRepositoryUrl(), taskId, null, timestamp);
	return Status.OK_STATUS;
	}
	}
	}

	final String taskFullUrl = reference.getTaskUrl();
	if (taskFullUrl != null) {
	if (!openTaskByKey(getActivePage(), taskFullUrl)) {
	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
	public void run() {
	TasksUiUtil.openUrl(taskFullUrl);
	}
	});
	}
	return Status.OK_STATUS;
	}
	}

	// task not found
	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
	public void run() {
	IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
	boolean openDialog = MessageDialog.openQuestion(window.getShell(),
	Messages.OpenCorrespondingTaskAction_Open_Task,
	Messages.OpenCorrespondingTaskAction_Unable_to_match_task);
	if (openDialog) {
	new OpenRepositoryTaskAction().run(null);
	}
	}
	});
	return Status.OK_STATUS;
	}

	private boolean openTaskByKey(IWorkbenchPage page, final String taskFullUrl) {
	String taskKey = null;
	TaskRepository repository = guessRepository(taskFullUrl);
	if (repository != null) {
	AbstractRepositoryConnector connector = TasksUiPlugin.getRepositoryManager()
	.getRepositoryConnector(repository.getConnectorKind());
	if (connector != null) {
	taskKey = guessTaskKey(connector, repository, taskFullUrl);
	}
	}
	if (taskKey != null && page != null) {
	new OpenRepositoryTaskJob(repository, taskKey, taskFullUrl, page).schedule();
	return true;
	}
	return false;
	}

	private IWorkbenchPage getActivePage() {
	IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
	if (window != null) {
	return window.getActivePage();
	}
	return null;
	}

	private TaskRepository guessRepository(String taskFullUrl) {
	for (TaskRepository repository : TasksUi.getRepositoryManager().getAllRepositories()) {
	if (taskFullUrl.startsWith(repository.getRepositoryUrl())) {
	return repository;
	}
	}
	return null;
	}

	/**
	* Using a task for which we know the task key and browser URL, try to guess the task key from the given URL.
	*/
	private static String guessTaskKey(AbstractRepositoryConnector connector, TaskRepository repository,
	String taskFullUrl) {
	Set<ITask> tasks = ((TaskList) TasksUiInternal.getTaskList()).getTasks(repository.getRepositoryUrl());
	if (!tasks.isEmpty()) {
	ITask task = tasks.iterator().next();
	URL browserUrl = connector.getBrowserUrl(repository, task);
	if (browserUrl != null) {
	return guessTaskKey(taskFullUrl, browserUrl.toExternalForm(), task.getTaskKey());
	}
	}
	return null;
	}

	/**
	* @noreference This method is not intended to be referenced by clients.
	*/
	public static String guessTaskKey(String taskFullUrl, String knownTaskUrl, String knownTaskKey) {
	int index = knownTaskUrl.indexOf(knownTaskKey);
	if (index != -1) {
	String prefix = knownTaskUrl.substring(0, index);
	String postfix = knownTaskUrl.substring(index + knownTaskKey.length());
	return extractTaskId(taskFullUrl, prefix, postfix);
	}
	return null;
	}

	/**
	* @noreference This method is not intended to be referenced by clients.
	*/
	public static String extractTaskId(String taskFullUrl, String prefix, String postfix) {
	if (!prefix.isEmpty() && taskFullUrl.startsWith(prefix) && taskFullUrl.endsWith(postfix)) {
	return taskFullUrl.substring(prefix.length(), taskFullUrl.length() - postfix.length());
	}
	return null;
	}
	}