Attachment #168854 for bug #178474

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

Lines 55-61 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/search/OpenSearchResultAction.java (-1 / +1 lines)
55	for (Iterator<AbstractTask> it = selection.iterator(); it.hasNext();) {	55	for (Iterator<AbstractTask> it = selection.iterator(); it.hasNext();) {
56	AbstractTask repositoryHit = it.next();	56	AbstractTask repositoryHit = it.next();
57	TasksUiUtil.openTask(repositoryHit.getRepositoryUrl(), repositoryHit.getTaskId(),	57	TasksUiUtil.openTask(repositoryHit.getRepositoryUrl(), repositoryHit.getTaskId(),
58	repositoryHit.getUrl());	58	repositoryHit.getUrl(), 0);
59	}	59	}
60		60
61	}	61	}

Lines 12-17 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/OpenRepositoryTaskJob.java (-3 / +33 lines)
12	package org.eclipse.mylyn.internal.tasks.ui;	12	package org.eclipse.mylyn.internal.tasks.ui;
13		13
14	import java.text.MessageFormat;	14	import java.text.MessageFormat;
		15	import java.util.Date;
		16	import java.util.List;
15		17
16	import org.eclipse.core.runtime.CoreException;	18	import org.eclipse.core.runtime.CoreException;
17	import org.eclipse.core.runtime.IProgressMonitor;	19	import org.eclipse.core.runtime.IProgressMonitor;
Lines 25-33 Link Here
25	import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;	27	import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
26	import org.eclipse.mylyn.tasks.core.ITask;	28	import org.eclipse.mylyn.tasks.core.ITask;
27	import org.eclipse.mylyn.tasks.core.TaskRepository;	29	import org.eclipse.mylyn.tasks.core.TaskRepository;
		30	import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
28	import org.eclipse.mylyn.tasks.core.data.TaskData;	31	import org.eclipse.mylyn.tasks.core.data.TaskData;
29	import org.eclipse.mylyn.tasks.ui.TasksUi;	32	import org.eclipse.mylyn.tasks.ui.TasksUi;
30	import org.eclipse.mylyn.tasks.ui.TasksUiUtil;	33	import org.eclipse.mylyn.tasks.ui.TasksUiUtil;
		34	import org.eclipse.mylyn.tasks.ui.editors.TaskEditor;
31	import org.eclipse.ui.IWorkbenchPage;	35	import org.eclipse.ui.IWorkbenchPage;
32	import org.eclipse.ui.PlatformUI;	36	import org.eclipse.ui.PlatformUI;
33		37
Lines 49-62 Link Here
49		53
50	private TaskOpenListener listener;	54	private TaskOpenListener listener;
51		55
		56	private final long timestamp;
		57
52	public OpenRepositoryTaskJob(String repositoryKind, String repositoryUrl, String taskId, String taskUrl,	58	public OpenRepositoryTaskJob(String repositoryKind, String repositoryUrl, String taskId, String taskUrl,
53	IWorkbenchPage page) {	59	long timestamp, IWorkbenchPage page) {
54	super(MessageFormat.format(Messages.OpenRepositoryTaskJob_Opening_repository_task_X, taskId));	60	super(MessageFormat.format(Messages.OpenRepositoryTaskJob_Opening_repository_task_X, taskId));
55		61
56	this.repositoryKind = repositoryKind;	62	this.repositoryKind = repositoryKind;
57	this.taskId = taskId;	63	this.taskId = taskId;
58	this.repositoryUrl = repositoryUrl;	64	this.repositoryUrl = repositoryUrl;
59	this.taskUrl = taskUrl;	65	this.taskUrl = taskUrl;
		66	this.timestamp = timestamp;
60	}	67	}
61		68
62	/**	69	/**
Lines 79-85 Link Here
79	if (repository == null) {	86	if (repository == null) {
80	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {	87	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
81	public void run() {	88	public void run() {
82	MessageDialog.openError(null, Messages.OpenRepositoryTaskJob_Repository_Not_Found,	89	MessageDialog.openError(
		90	null,
		91	Messages.OpenRepositoryTaskJob_Repository_Not_Found,
83	MessageFormat.format(	92	MessageFormat.format(
84	Messages.OpenRepositoryTaskJob_Could_not_find_repository_configuration_for_X,	93	Messages.OpenRepositoryTaskJob_Could_not_find_repository_configuration_for_X,
85	repositoryUrl)	94	repositoryUrl)
Lines 95-101 Link Here
95		104
96	AbstractRepositoryConnector connector = TasksUi.getRepositoryManager().getRepositoryConnector(repositoryKind);	105	AbstractRepositoryConnector connector = TasksUi.getRepositoryManager().getRepositoryConnector(repositoryKind);
97	try {	106	try {
98	TaskData taskData = connector.getTaskData(repository, taskId, monitor);	107	final TaskData taskData = connector.getTaskData(repository, taskId, monitor);
99	if (taskData != null) {	108	if (taskData != null) {
100	task = TasksUi.getRepositoryModel().createTask(repository, taskData.getTaskId());	109	task = TasksUi.getRepositoryModel().createTask(repository, taskData.getTaskId());
101	TasksUiPlugin.getTaskDataManager().putUpdatedTaskData(task, taskData, true);	110	TasksUiPlugin.getTaskDataManager().putUpdatedTaskData(task, taskData, true);
Lines 105-110 Link Here
105	if (listener != null && event != null) {	114	if (listener != null && event != null) {
106	listener.taskOpened(event);	115	listener.taskOpened(event);
107	}	116	}
		117	if (timestamp != 0 && event != null) {
		118	List<TaskAttribute> commentAttributes = taskData.getAttributeMapper().getAttributesByType(
		119	taskData, TaskAttribute.TYPE_COMMENT);
		120	if (commentAttributes.size() > 0) {
		121	for (TaskAttribute commentAttribute : commentAttributes) {
		122	TaskAttribute commentCreateDate = commentAttribute.getMappedAttribute(TaskAttribute.COMMENT_DATE);
		123	if (commentCreateDate != null) {
		124	Date dateValue = taskData.getAttributeMapper().getDateValue(commentCreateDate);
		125	if (dateValue.getTime() < timestamp) {
		126	continue;
		127	}
		128	TaskAttribute dn = commentAttribute.getMappedAttribute(TaskAttribute.COMMENT_NUMBER);
		129	TaskEditor editor = (TaskEditor) event.getEditor();
		130	if (dn != null) {
		131	editor.selectReveal(TaskAttribute.PREFIX_COMMENT + dn.getValue());
		132	}
		133	break;
		134	}
		135	}
		136	}
		137	}
108	}	138	}
109	});	139	});
110	} else {	140	} else {




	 */
	public static boolean openRepositoryTask(String connectorKind, String repositoryUrl, String id,
			TaskOpenListener listener) {
		return openRepositoryTask(connectorKind, repositoryUrl, id, listener, 0);
	}

	/**
	 * Only override if task should be opened by a custom editor, default behavior is to open with a rich editor,
	 * falling back to the web browser if not available.
	 * 
	 * @return true if the task was successfully opened
	 */
	public static boolean openRepositoryTask(String connectorKind, String repositoryUrl, String id,
			TaskOpenListener listener, long timestamp) {
		IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();
		AbstractRepositoryConnector connector = repositoryManager.getRepositoryConnector(connectorKind);
		String taskUrl = connector.getTaskUrl(repositoryUrl, id);

		}
		IWorkbenchPage page = window.getActivePage();

		OpenRepositoryTaskJob job = new OpenRepositoryTaskJob(connectorKind, repositoryUrl, id, taskUrl, timestamp,
				page);
		job.setListener(listener);
		job.schedule();


Lines 208-214 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/TaskListDropAdapter.java (-1 / +1 lines)
208	if (repositoryUrl != null && taskId != null) {	208	if (repositoryUrl != null && taskId != null) {
209	// attempt to open task in background	209	// attempt to open task in background
210	// TODO: consider attaching a listener to OpenRepsitoryTaskJob to move task to drop target	210	// TODO: consider attaching a listener to OpenRepsitoryTaskJob to move task to drop target
211	TasksUiInternal.openRepositoryTask(connector.getConnectorKind(), repositoryUrl, taskId);	211	TasksUiInternal.openRepositoryTask(connector.getConnectorKind(), repositoryUrl, taskId, null, 0);
212	}	212	}
213	} else {	213	} else {
214	// create local task, using title of web page as a summary	214	// create local task, using title of web page as a summary




	/**
	 * Either pass in a repository and taskId, or fullUrl, or all of them
	 * 
	 * @deprecated Use {@link #openTask(String,String,String,long)} instead
	 */
	@Deprecated
	public static boolean openRepositoryTask(String repositoryUrl, String taskId, String fullUrl) {
		return openTask(repositoryUrl, taskId, fullUrl, 0);
	}

	/**

	 * Either pass in a repository and taskId, or fullUrl, or all of them
	 * 
	 * @since 3.0
	 * @deprecated Use {@link #openTask(String,String,String,long)} instead
	 */
	@Deprecated
	public static boolean openTask(String repositoryUrl, String taskId, String fullUrl) {
		return openTask(repositoryUrl, taskId, fullUrl, 0);
	}

	/**
	 * Either pass in a repository and taskId, or fullUrl, or all of them the timestamp is used for seleting the correct
	 * comment
	 * 
	 * @since 3.4
	 */
	public static boolean openTask(String repositoryUrl, String taskId, String fullUrl, long timestamp) {
		AbstractTask task = TasksUiInternal.getTask(repositoryUrl, taskId, fullUrl);

		if (task != null) {

				fullUrl);
		if (connector != null) {
			if (repositoryUrl != null && taskId != null) {
				opened = TasksUiInternal.openRepositoryTask(connector.getConnectorKind(), repositoryUrl, taskId, null,
						timestamp);
			} else {
				repositoryUrl = connector.getRepositoryUrlFromTaskUrl(fullUrl);
				taskId = connector.getTaskIdFromTaskUrl(fullUrl);
				if (repositoryUrl != null && taskId != null) {
					opened = TasksUiInternal.openRepositoryTask(connector.getConnectorKind(), repositoryUrl, taskId,
							null, timestamp);
				}
			}
		}

Lines 23-28 Link Here

(-)plugin.xml (+5 lines)
23	class="org.eclipse.mylyn.internal.team.ccvs.CvsLinkedTaskInfoAdapterFactory">	23	class="org.eclipse.mylyn.internal.team.ccvs.CvsLinkedTaskInfoAdapterFactory">
24	<adapter type="org.eclipse.mylyn.team.ui.AbstractTaskReference"/>	24	<adapter type="org.eclipse.mylyn.team.ui.AbstractTaskReference"/>
25	</factory>	25	</factory>
		26
		27	<factory adaptableType="org.eclipse.team.internal.ccvs.core.filehistory.CVSFileRevision"
		28	class="org.eclipse.mylyn.internal.team.ccvs.CvsLinkedTaskInfoAdapterFactory">
		29	<adapter type="org.eclipse.mylyn.team.ui.AbstractTaskReference"/>
		30	</factory>
26		31
27	<!--	32	<!--
28	<factory adaptableType="org.eclipse.mylyn.internal.team.ui.ContextChangeSet"	33	<factory adaptableType="org.eclipse.mylyn.internal.team.ui.ContextChangeSet"

Lines 17-28 Link Here

(-)src/org/eclipse/mylyn/internal/team/ccvs/CvsLinkedTaskInfoAdapterFactory.java (-2 / +17 lines)
17	import org.eclipse.mylyn.internal.team.ui.LinkedTaskInfo;	17	import org.eclipse.mylyn.internal.team.ui.LinkedTaskInfo;
18	import org.eclipse.mylyn.tasks.core.TaskRepository;	18	import org.eclipse.mylyn.tasks.core.TaskRepository;
19	import org.eclipse.mylyn.team.ui.AbstractTaskReference;	19	import org.eclipse.mylyn.team.ui.AbstractTaskReference;
		20	import org.eclipse.mylyn.team.ui.IContextChangeSet;
		21	import org.eclipse.team.core.history.IFileRevision;
20	import org.eclipse.team.core.variants.IResourceVariant;	22	import org.eclipse.team.core.variants.IResourceVariant;
21	import org.eclipse.team.internal.ccvs.core.CVSException;	23	import org.eclipse.team.internal.ccvs.core.CVSException;
22	import org.eclipse.team.internal.ccvs.core.ICVSResource;	24	import org.eclipse.team.internal.ccvs.core.ICVSResource;
23	import org.eclipse.team.internal.ccvs.core.client.listeners.LogEntry;	25	import org.eclipse.team.internal.ccvs.core.client.listeners.LogEntry;
		26	import org.eclipse.team.internal.ccvs.core.filehistory.CVSFileRevision;
24	import org.eclipse.team.internal.ccvs.core.resources.CVSWorkspaceRoot;	27	import org.eclipse.team.internal.ccvs.core.resources.CVSWorkspaceRoot;
25	import org.eclipse.team.internal.ccvs.core.resources.RemoteResource;	28	import org.eclipse.team.internal.ccvs.core.resources.RemoteResource;
		29	import org.eclipse.team.internal.core.subscribers.DiffChangeSet;
26		30
27	/**	31	/**
28	* @author Eugene Kuleshov	32	* @author Eugene Kuleshov
Lines 51-61 Link Here
51	return null;	55	return null;
52	}	56	}
53		57
		58	long timestamp = 0;
		59	if (object instanceof CVSFileRevision) {
		60	timestamp = ((CVSFileRevision) object).getTimestamp();
		61	}
		62
54	IResource resource = getResourceForElement(object);	63	IResource resource = getResourceForElement(object);
55	if (resource != null) {	64	if (resource != null) {
56	TaskRepository repository = TasksUiPlugin.getDefault().getRepositoryForResource(resource);	65	TaskRepository repository = TasksUiPlugin.getDefault().getRepositoryForResource(resource);
57	if (repository != null) {	66	if (repository != null) {
58	return new LinkedTaskInfo(repository.getRepositoryUrl(), null, null, comment);	67	return new LinkedTaskInfo(repository.getRepositoryUrl(), null, null, comment, timestamp);
59	}	68	}
60	}	69	}
61		70
Lines 63-70 Link Here
63	}	72	}
64		73
65	private static String getCommentForElement(Object element) {	74	private static String getCommentForElement(Object element) {
66	if (element instanceof LogEntry) {	75	if (element instanceof IContextChangeSet) {
		76	return ((IContextChangeSet) element).getComment(false);
		77	} else if (element instanceof DiffChangeSet) {
		78	return ((DiffChangeSet) element).getComment();
		79	} else if (element instanceof LogEntry) {
67	return ((LogEntry) element).getComment();	80	return ((LogEntry) element).getComment();
		81	} else if (element instanceof IFileRevision) {
		82	return ((IFileRevision) element).getComment();
68	}	83	}
69	return null;	84	return null;
70	}	85	}





	private ChangeSet changeSet = null;

	private long timestamp = 0;

	public LinkedTaskInfo(String repositoryUrl, String taskId, String taskFullUrl, String comment, long timestamp) {
		this.repositoryUrl = repositoryUrl;
		this.taskId = taskId;
		this.taskFullUrl = taskFullUrl;
		this.comment = comment;
		this.timestamp = timestamp;
	}

	public LinkedTaskInfo(ITask task, ChangeSet changeSet) {
		this.task = task;
		this.changeSet = changeSet;
	}

	public LinkedTaskInfo(ITask task, ChangeSet changeSet, long timestamp) {
		this.task = task;
		this.changeSet = changeSet;
		this.timestamp = timestamp;
	}

	public LinkedTaskInfo(String taskFullUrl) {
		this.taskFullUrl = taskFullUrl;
	}

		return changeSet;
	}

	public long getTimestamp() {
		return timestamp;
	}
}




import org.eclipse.ui.internal.ObjectPluginAction;

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

	}

	/**
	 * Reconcile <code>ILinkedTaskInfo</code> data. This is used in order to keep LinkedTaskInfo lightweight with
	 * minimal dependencies.
	 * 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) {

				}
			}
		}
		if (task != null) {
			return new LinkedTaskInfo(task, null);
		}

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

	public static String getUrlFromComment(String comment) {

			if (info != null) {
				info = reconcile(info);
				final ITask task;
				final long timestamp;
				if (info instanceof LinkedTaskInfo) {
					task = ((LinkedTaskInfo) info).getTask();
					timestamp = ((LinkedTaskInfo) info).getTimestamp();
				} else {
					task = null;
					timestamp = 0;
				}
				if (task != null) {
					PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {

						AbstractRepositoryConnectorUi connectorUi = TasksUiPlugin.getConnectorUi(repository.getConnectorKind());
						if (connectorUi != null) {
							TasksUiInternal.openRepositoryTask(connectorUi.getConnectorKind(),
									repository.getRepositoryUrl(), taskId, null, timestamp);
							return Status.OK_STATUS;
						}
					}

Return to bug 178474

Lines 958-963 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/util/TasksUiInternal.java (-1 / +13 lines)
958	*/	958	*/
959	public static boolean openRepositoryTask(String connectorKind, String repositoryUrl, String id,	959	public static boolean openRepositoryTask(String connectorKind, String repositoryUrl, String id,
960	TaskOpenListener listener) {	960	TaskOpenListener listener) {
		961	return openRepositoryTask(connectorKind, repositoryUrl, id, listener, 0);
		962	}
		963
		964	/**
		965	* Only override if task should be opened by a custom editor, default behavior is to open with a rich editor,
		966	* falling back to the web browser if not available.
		967	*
		968	* @return true if the task was successfully opened
		969	*/
		970	public static boolean openRepositoryTask(String connectorKind, String repositoryUrl, String id,
		971	TaskOpenListener listener, long timestamp) {
961	IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();	972	IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();
962	AbstractRepositoryConnector connector = repositoryManager.getRepositoryConnector(connectorKind);	973	AbstractRepositoryConnector connector = repositoryManager.getRepositoryConnector(connectorKind);
963	String taskUrl = connector.getTaskUrl(repositoryUrl, id);	974	String taskUrl = connector.getTaskUrl(repositoryUrl, id);
Lines 977-983 Link Here
977	}	988	}
978	IWorkbenchPage page = window.getActivePage();	989	IWorkbenchPage page = window.getActivePage();
979		990
980	OpenRepositoryTaskJob job = new OpenRepositoryTaskJob(connectorKind, repositoryUrl, id, taskUrl, page);	991	OpenRepositoryTaskJob job = new OpenRepositoryTaskJob(connectorKind, repositoryUrl, id, taskUrl, timestamp,
		992	page);
981	job.setListener(listener);	993	job.setListener(listener);
982	job.schedule();	994	job.schedule();
983		995

Lines 258-268 Link Here

(-)src/org/eclipse/mylyn/tasks/ui/TasksUiUtil.java (-4 / +18 lines)
258	/**	258	/**
259	* Either pass in a repository and taskId, or fullUrl, or all of them	259	* Either pass in a repository and taskId, or fullUrl, or all of them
260	*	260	*
261	* @deprecated Use {@link #openTask(String,String,String)} instead	261	* @deprecated Use {@link #openTask(String,String,String,long)} instead
262	*/	262	*/
263	@Deprecated	263	@Deprecated
264	public static boolean openRepositoryTask(String repositoryUrl, String taskId, String fullUrl) {	264	public static boolean openRepositoryTask(String repositoryUrl, String taskId, String fullUrl) {
265	return openTask(repositoryUrl, taskId, fullUrl);	265	return openTask(repositoryUrl, taskId, fullUrl, 0);
266	}	266	}
267		267
268	/**	268	/**
Lines 318-325 Link Here
318	* Either pass in a repository and taskId, or fullUrl, or all of them	318	* Either pass in a repository and taskId, or fullUrl, or all of them
319	*	319	*
320	* @since 3.0	320	* @since 3.0
		321	* @deprecated Use {@link #openTask(String,String,String,long)} instead
321	*/	322	*/
		323	@Deprecated
322	public static boolean openTask(String repositoryUrl, String taskId, String fullUrl) {	324	public static boolean openTask(String repositoryUrl, String taskId, String fullUrl) {
		325	return openTask(repositoryUrl, taskId, fullUrl, 0);
		326	}
		327
		328	/**
		329	* Either pass in a repository and taskId, or fullUrl, or all of them the timestamp is used for seleting the correct
		330	* comment
		331	*
		332	* @since 3.4
		333	*/
		334	public static boolean openTask(String repositoryUrl, String taskId, String fullUrl, long timestamp) {
323	AbstractTask task = TasksUiInternal.getTask(repositoryUrl, taskId, fullUrl);	335	AbstractTask task = TasksUiInternal.getTask(repositoryUrl, taskId, fullUrl);
324		336
325	if (task != null) {	337	if (task != null) {
Lines 332-343 Link Here
332	fullUrl);	344	fullUrl);
333	if (connector != null) {	345	if (connector != null) {
334	if (repositoryUrl != null && taskId != null) {	346	if (repositoryUrl != null && taskId != null) {
335	opened = TasksUiInternal.openRepositoryTask(connector.getConnectorKind(), repositoryUrl, taskId);	347	opened = TasksUiInternal.openRepositoryTask(connector.getConnectorKind(), repositoryUrl, taskId, null,
		348	timestamp);
336	} else {	349	} else {
337	repositoryUrl = connector.getRepositoryUrlFromTaskUrl(fullUrl);	350	repositoryUrl = connector.getRepositoryUrlFromTaskUrl(fullUrl);
338	taskId = connector.getTaskIdFromTaskUrl(fullUrl);	351	taskId = connector.getTaskIdFromTaskUrl(fullUrl);
339	if (repositoryUrl != null && taskId != null) {	352	if (repositoryUrl != null && taskId != null) {
340	opened = TasksUiInternal.openRepositoryTask(connector.getConnectorKind(), repositoryUrl, taskId);	353	opened = TasksUiInternal.openRepositoryTask(connector.getConnectorKind(), repositoryUrl, taskId,
		354	null, timestamp);
341	}	355	}
342	}	356	}
343	}	357	}

Lines 35-45 Link Here

(-)src/org/eclipse/mylyn/internal/team/ui/LinkedTaskInfo.java (+19 lines)
35		35
36	private ChangeSet changeSet = null;	36	private ChangeSet changeSet = null;
37		37
		38	private long timestamp = 0;
		39
		40	public LinkedTaskInfo(String repositoryUrl, String taskId, String taskFullUrl, String comment, long timestamp) {
		41	this.repositoryUrl = repositoryUrl;
		42	this.taskId = taskId;
		43	this.taskFullUrl = taskFullUrl;
		44	this.comment = comment;
		45	this.timestamp = timestamp;
		46	}
		47
38	public LinkedTaskInfo(ITask task, ChangeSet changeSet) {	48	public LinkedTaskInfo(ITask task, ChangeSet changeSet) {
39	this.task = task;	49	this.task = task;
40	this.changeSet = changeSet;	50	this.changeSet = changeSet;
41	}	51	}
42		52
		53	public LinkedTaskInfo(ITask task, ChangeSet changeSet, long timestamp) {
		54	this.task = task;
		55	this.changeSet = changeSet;
		56	this.timestamp = timestamp;
		57	}
		58
43	public LinkedTaskInfo(String taskFullUrl) {	59	public LinkedTaskInfo(String taskFullUrl) {
44	this.taskFullUrl = taskFullUrl;	60	this.taskFullUrl = taskFullUrl;
45	}	61	}
Lines 79-82 Link Here
79	return changeSet;	95	return changeSet;
80	}	96	}
81		97
		98	public long getTimestamp() {
		99	return timestamp;
		100	}
82	}	101	}

Lines 50-58 Link Here

(-)src/org/eclipse/mylyn/internal/team/ui/actions/OpenCorrespondingTaskAction.java (-11 / +12 lines)
50	import org.eclipse.ui.internal.ObjectPluginAction;	50	import org.eclipse.ui.internal.ObjectPluginAction;
51		51
52	/**	52	/**
53	* Action used to open linked task.	53	* Action used to open linked task. TODO: this class has evolved into a complete mess and has to be fixed.
54	*
55	* TODO: this class has evolved into a complete mess and has to be fixed.
56	*	54	*
57	* @author Mik Kersten	55	* @author Mik Kersten
58	* @author Eugene Kuleshov	56	* @author Eugene Kuleshov
Lines 106-121 Link Here
106	}	104	}
107		105
108	/**	106	/**
109	* Reconcile <code>ILinkedTaskInfo</code> data.	107	* Reconcile <code>ILinkedTaskInfo</code> data. This is used in order to keep LinkedTaskInfo lightweight with
110	*	108	* minimal dependencies.
111	* This is used in order to keep LinkedTaskInfo lightweight with minimal dependencies.
112	*/	109	*/
113	private static AbstractTaskReference reconcile(AbstractTaskReference info) {	110	private static AbstractTaskReference reconcile(AbstractTaskReference info) {
114	ITask task;	111	ITask task;
		112	long timestamp;
		113
115	if (info instanceof LinkedTaskInfo) {	114	if (info instanceof LinkedTaskInfo) {
116	task = ((LinkedTaskInfo) info).getTask();	115	task = ((LinkedTaskInfo) info).getTask();
		116	timestamp = ((LinkedTaskInfo) info).getTimestamp();
117	} else {	117	} else {
118	task = null;	118	task = null;
		119	timestamp = 0;
119	}	120	}
120		121
121	if (task != null) {	122	if (task != null) {
Lines 208-218 Link Here
208	}	209	}
209	}	210	}
210	}	211	}
211	if (task != null) {
212	return new LinkedTaskInfo(task, null);
213	}
214		212
215	return new LinkedTaskInfo(repositoryUrl, taskId, taskFullUrl, comment);	213	return new LinkedTaskInfo(repositoryUrl, taskId, taskFullUrl, comment, timestamp);
216	}	214	}
217		215
218	public static String getUrlFromComment(String comment) {	216	public static String getUrlFromComment(String comment) {
Lines 284-293 Link Here
284	if (info != null) {	282	if (info != null) {
285	info = reconcile(info);	283	info = reconcile(info);
286	final ITask task;	284	final ITask task;
		285	final long timestamp;
287	if (info instanceof LinkedTaskInfo) {	286	if (info instanceof LinkedTaskInfo) {
288	task = ((LinkedTaskInfo) info).getTask();	287	task = ((LinkedTaskInfo) info).getTask();
		288	timestamp = ((LinkedTaskInfo) info).getTimestamp();
289	} else {	289	} else {
290	task = null;	290	task = null;
		291	timestamp = 0;
291	}	292	}
292	if (task != null) {	293	if (task != null) {
293	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {	294	PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
Lines 305-311 Link Here
305	AbstractRepositoryConnectorUi connectorUi = TasksUiPlugin.getConnectorUi(repository.getConnectorKind());	306	AbstractRepositoryConnectorUi connectorUi = TasksUiPlugin.getConnectorUi(repository.getConnectorKind());
306	if (connectorUi != null) {	307	if (connectorUi != null) {
307	TasksUiInternal.openRepositoryTask(connectorUi.getConnectorKind(),	308	TasksUiInternal.openRepositoryTask(connectorUi.getConnectorKind(),
308	repository.getRepositoryUrl(), taskId);	309	repository.getRepositoryUrl(), taskId, null, timestamp);
309	return Status.OK_STATUS;	310	return Status.OK_STATUS;
310	}	311	}
311	}	312	}