Attachment #66006 for bug #144722

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

Lines 8-14 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.core/META-INF/MANIFEST.MF (-1 / +2 lines)
8	Require-Bundle: org.eclipse.core.runtime,	8	Require-Bundle: org.eclipse.core.runtime,
9	org.eclipse.mylar.context.core,	9	org.eclipse.mylar.context.core,
10	org.eclipse.mylar.tasks.core,	10	org.eclipse.mylar.tasks.core,
11	org.eclipse.search	11	org.eclipse.search,
		12	org.eclipse.mylar
12	Eclipse-LazyStart: true	13	Eclipse-LazyStart: true
13	Export-Package: com.itsolut.mantis.core,	14	Export-Package: com.itsolut.mantis.core,
14	com.itsolut.mantis.core.exception,	15	com.itsolut.mantis.core.exception,

Lines 21-26 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.core/src/com/itsolut/mantis/core/MantisAttachmentHandler.java (-1 / +2 lines)
21	import org.eclipse.core.runtime.CoreException;	21	import org.eclipse.core.runtime.CoreException;
22	import org.eclipse.core.runtime.IStatus;	22	import org.eclipse.core.runtime.IStatus;
23	import org.eclipse.core.runtime.Status;	23	import org.eclipse.core.runtime.Status;
		24	import org.eclipse.mylar.internal.tasks.core.RepositoryTaskHandleUtil;
24	import org.eclipse.mylar.tasks.core.AbstractRepositoryConnector;	25	import org.eclipse.mylar.tasks.core.AbstractRepositoryConnector;
25	import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;	26	import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;
26	import org.eclipse.mylar.tasks.core.IAttachmentHandler;	27	import org.eclipse.mylar.tasks.core.IAttachmentHandler;
Lines 72-78 Link Here
72		73
73	try {	74	try {
74	IMantisClient client = connector.getClientManager().getRepository(repository);	75	IMantisClient client = connector.getClientManager().getRepository(repository);
75	int id = Integer.parseInt(AbstractRepositoryTask.getTaskId(task.getHandleIdentifier()));	76	int id = Integer.parseInt(RepositoryTaskHandleUtil.getTaskId(task.getHandleIdentifier()));
76	byte[] data = readData(file);	77	byte[] data = readData(file);
77		78
78	//hack since context methods are final in superclasses & Mantis does not have a description column	79	//hack since context methods are final in superclasses & Mantis does not have a description column





import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.mylar.core.MylarStatusHandler;
import org.eclipse.mylar.internal.tasks.core.RepositoryTaskHandleUtil;
import org.eclipse.mylar.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;
import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;

import com.itsolut.mantis.core.exception.InvalidTicketException;
import com.itsolut.mantis.core.model.MantisTicket;
import com.itsolut.mantis.core.model.MantisTicket.Key;
import com.itsolut.mantis.core.util.MantisUtils;

/**
 * @author Steffen Pingel


	private final static String CLIENT_LABEL = "Mantis (supports connector 0.0.5 only)";

	private List<String> supportedVersions;

	private MantisClientManager clientManager;

	private MantisOfflineTaskHandler offlineTaskHandler = new MantisOfflineTaskHandler(this);

		return repositoryUrl + IMantisClient.TICKET_URL + taskId;
	}

	
	@Override
	public List<String> getSupportedVersions() {
		if (supportedVersions == null) {
			supportedVersions = new ArrayList<String>();
			for (Version version : Version.values()) {
				supportedVersions.add(version.toString());
			}
		}
		return supportedVersions;
	}

	@Override
	public IAttachmentHandler getAttachmentHandler() {
		return attachmentHandler;
	}

	@Override
	public void updateTask(TaskRepository repository, AbstractRepositoryTask repositoryTask) throws CoreException {
		if (repositoryTask instanceof MantisTask) {
			String id = RepositoryTaskHandleUtil.getTaskId(repositoryTask.getHandleIdentifier());
			try {
				IMantisClient connection = getClientManager().getRepository(repository);
				MantisTicket ticket = connection.getTicket(Integer.parseInt(id));


		return Status.OK_STATUS;
	}
	
	@Override
	public AbstractRepositoryTask createTaskFromExistingKey(TaskRepository repository, String taskId) throws CoreException {
		int bugId = -1;
		try {
			bugId = Integer.parseInt(taskId);
		} catch (NumberFormatException e) {
			throw new CoreException(new Status(IStatus.ERROR, MantisCorePlugin.PLUGIN_ID, IStatus.OK,
						"Invalid ticket id: " + taskId, e));
		}
		
		String handle = AbstractRepositoryTask.getHandle(repository.getUrl(), bugId);
		
		MantisTask task;
		ITask existingTask = taskList.getTask(repository.getUrl(), taskId);
		if (existingTask instanceof MantisTask) {
			task = (MantisTask) existingTask;
		} else {
			RepositoryTaskData taskData = offlineTaskHandler.downloadTaskData(repository, bugId);
//			if (taskData != null) {
				task = new MantisTask(repository.getUrl(), taskId, getTicketDescription(taskData), true);
				task.setTaskData(taskData);
				taskList.addTask(task);
//			} else {

		return clientManager;
	}

	public MantisTask createTask(MantisTicket ticket, String repositoryUrl, String taskId) {
		MantisTask task;
		ITask existingTask = taskList.getTask(repositoryUrl, taskId);
		if (existingTask instanceof MantisTask) {
			task = (MantisTask) existingTask;
		} else {
			task = new MantisTask(repositoryUrl, taskId, getTicketDescription(ticket), true);
			taskList.addTask(task);
		}
		return task;

		return ticket;
	}
	
//TODO: not changed for Mantis yet...
	@Override
	public Set<AbstractRepositoryTask> getChangedSinceLastSync(TaskRepository repository, Set<AbstractRepositoryTask> tasks) throws CoreException {
		if (repository.getSyncTimeStamp() == null) {
			return tasks;
		}

		if (!MantisRepositoryConnector.hasChangedSince(repository)) {
			// return an empty list to avoid causing all tasks to synchronized
			return Collections.emptySet();
		}

		Date since = new Date(0);
		try {
			since = MantisUtils.parseDate(Integer.parseInt(repository.getSyncTimeStamp()));
		} catch (NumberFormatException e) {
		}

		IMantisClient client;
		try {
			client = getClientManager().getRepository(repository);
			Set<Integer> ids = client.getChangedTickets(since);

			Set<AbstractRepositoryTask> result = new HashSet<AbstractRepositoryTask>();
			if (!ids.isEmpty()) {
				for (AbstractRepositoryTask task : tasks) {
					Integer id = Integer.parseInt(RepositoryTaskHandleUtil.getTaskId(task.getHandleIdentifier()));
					if (ids.contains(id)) {
						result.add(task);
					}
				}
			}
			return result;
		} catch (Exception e) {
			throw new CoreException(new Status(IStatus.ERROR, MantisCorePlugin.PLUGIN_ID, IStatus.OK, "could not determine changed tasks", e));
		}
	}
	
}





package com.itsolut.mantis.core;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;


import org.eclipse.mylar.tasks.core.RepositoryTaskAttribute;

import com.itsolut.mantis.core.model.MantisTicket.Key;
import com.itsolut.mantis.core.util.MantisUtils;

/**
 * Provides a mapping from Mylar task keys to Mantis ticket keys. 

	}

	static boolean isInternalAttribute(String id) {
		return RepositoryTaskAttribute.REMOVE_CC.equals(id) || RepositoryTaskAttribute.NEW_CC.equals(id) || RepositoryTaskAttribute.ADD_SELF_CC.equals(id) || RepositoryTaskAttribute.COMMENT_NEW.equals(id);
	}

	@Override
	public Date getDateForAttributeType(String attributeKey, String dateString) {
		if (dateString == null || dateString.length() == 0) {
			return null;
		}

		try {
			String mappedKey = mapCommonAttributeKey(attributeKey);
			if (mappedKey.equals(Attribute.DATE_SUBMITTED.getMantisKey()) || mappedKey.equals(Attribute.LAST_UPDATED.getMantisKey())) {
				return MantisUtils.parseDate(Integer.valueOf(dateString));
			}
		} catch (Exception e) {
		}
		return null;
	}

}

Lines 30-40 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.core/src/com/itsolut/mantis/core/MantisTask.java (-5 / +4 lines)
30	*/	30	*/
31	public class MantisTask extends AbstractRepositoryTask {	31	public class MantisTask extends AbstractRepositoryTask {
32		32
33	public MantisTask(String handle, String label, boolean newTask) {	33	public MantisTask(String repositoryUrl, String taskId, String label, boolean newTask) {
34	super(handle, label, newTask);	34	super(repositoryUrl, taskId, label, newTask);
35		35
36	setUrl(AbstractRepositoryTask.getRepositoryUrl(handle) + IMantisClient.TICKET_URL	36	setTaskUrl(repositoryUrl + IMantisClient.TICKET_URL + taskId);
37	+ AbstractRepositoryTask.getTaskId(handle));
38	}	37	}
39		38
40	@Override	39	@Override





package com.itsolut.mantis.core;

import java.io.UnsupportedEncodingException;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.mylar.tasks.core.AbstractAttributeFactory;
import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;
import org.eclipse.mylar.tasks.core.ITaskDataHandler;
import org.eclipse.mylar.tasks.core.RepositoryAttachment;
import org.eclipse.mylar.tasks.core.RepositoryTaskAttribute;
import org.eclipse.mylar.tasks.core.RepositoryTaskData;
import org.eclipse.mylar.tasks.core.Task;
import org.eclipse.mylar.tasks.core.TaskComment;
import org.eclipse.mylar.tasks.core.TaskRepository;


import com.itsolut.mantis.core.exception.MantisException;
import com.itsolut.mantis.core.model.MantisAttachment;
import com.itsolut.mantis.core.model.MantisComment;
import com.itsolut.mantis.core.model.MantisProject;
import com.itsolut.mantis.core.model.MantisProjectCategory;
import com.itsolut.mantis.core.model.MantisTicket;
import com.itsolut.mantis.core.util.MantisUtils;

		}

		try {
			RepositoryTaskData data = new RepositoryTaskData(attributeFactory, MantisCorePlugin.REPOSITORY_KIND, repository.getUrl(), id + "", Task.DEFAULT_TASK_KIND);
			IMantisClient client = connector.getClientManager().getRepository(repository);
			client.updateAttributes(new NullProgressMonitor(), false);
			MantisTicket ticket = client.getTicket(id);

		}
	}

	public AbstractAttributeFactory getAttributeFactory(String repositoryUrl, String repositoryKind, String taskKind) {
		return attributeFactory;
	}

	public Date getDateForAttributeType(String attributeKey, String dateString) {
		if (dateString == null || dateString.length() == 0) {
			return null;
		}

		try {
			String mappedKey = attributeFactory.mapCommonAttributeKey(attributeKey);
			if (mappedKey.equals(Attribute.DATE_SUBMITTED.getMantisKey()) || mappedKey.equals(Attribute.LAST_UPDATED.getMantisKey())) {
				return MantisUtils.parseDate(Integer.valueOf(dateString));
			}
		} catch (Exception e) {
		}
		return null;
	}

	public static void updateTaskData(TaskRepository repository, AbstractAttributeFactory factory, RepositoryTaskData data, 
			                          IMantisClient client, MantisTicket ticket) throws CoreException {
		

		data.addAttribute(attribute.getMantisKey(), attr);
		return attr;
	}
	
	//TODO: not changed for Mantis yet...
	public Set<AbstractRepositoryTask> getChangedSinceLastSync(TaskRepository repository, Set<AbstractRepositoryTask> tasks) throws CoreException, UnsupportedEncodingException {
		if (repository.getSyncTimeStamp() == null) {
			return tasks;
		}

	public String postTaskData(TaskRepository repository, RepositoryTaskData taskData) throws CoreException {		
			// return an empty list to avoid causing all tasks to synchronized
			return Collections.emptySet();
		}

		Date since = new Date(0);
		try {
			MantisTicket ticket = MantisRepositoryConnector.getMantisTicket(repository, taskData);
			IMantisClient server = ((MantisRepositoryConnector) connector).getClientManager().getRepository(repository);
			if (taskData.isNew()) {
				int id = server.createTicket(ticket);
				return Integer.toString(id);
			} else {
								
				String comment = taskData.getNewComment();
				// XXX: new comment is now an attribute
				taskData.removeAttribute(RepositoryTaskAttribute.COMMENT_NEW);
				server.updateTicket(ticket, comment);
				return null;
					Integer id = Integer.parseInt(AbstractRepositoryTask.getTaskId(task.getHandleIdentifier()));
					if (ids.contains(id)) {
						result.add(task);
					}
				}
			}
			return result;
		} catch (Exception e) {
			throw new CoreException(MantisCorePlugin.toStatus(e));
		}
	}

	public boolean initializeTaskData(TaskRepository repository,
			RepositoryTaskData data, IProgressMonitor monitor) throws CoreException {
		// TODO Auto-generated method stub
		return false;
	}
}

Lines 27-33 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.core/src/com/itsolut/mantis/core/model/MantisTicket.java (-1 lines)
27	import java.util.List;	27	import java.util.List;
28	import java.util.Map;	28	import java.util.Map;
29		29
30	import com.itsolut.mantis.core.MantisCorePlugin;
31	import com.itsolut.mantis.core.exception.InvalidTicketException;	30	import com.itsolut.mantis.core.exception.InvalidTicketException;
32		31
33	/**	32	/**

Lines 19-25 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.core/src/com/itsolut/mantis/core/model/MantisSearch.java (-1 / +1 lines)
19	import java.util.List;	19	import java.util.List;
20	import java.util.Map;	20	import java.util.Map;
21		21
22	import org.eclipse.mylar.context.core.MylarStatusHandler;	22	import org.eclipse.mylar.core.MylarStatusHandler;
23		23
24	import com.itsolut.mantis.core.IMantisClient;	24	import com.itsolut.mantis.core.IMantisClient;
25	import com.itsolut.mantis.core.model.MantisSearchFilter.CompareOperator;	25	import com.itsolut.mantis.core.model.MantisSearchFilter.CompareOperator;

Lines 15-21 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.core/src/com/itsolut/mantis/core/MantisRepositoryQuery.java (-1 / +1 lines)
15	import java.net.URLDecoder;	15	import java.net.URLDecoder;
16	import java.util.StringTokenizer;	16	import java.util.StringTokenizer;
17		17
18	import org.eclipse.mylar.context.core.MylarStatusHandler;	18	import org.eclipse.mylar.core.MylarStatusHandler;
19	import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;	19	import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;
20	import org.eclipse.mylar.tasks.core.TaskList;	20	import org.eclipse.mylar.tasks.core.TaskList;
21		21




		super(taskList, repositoryUrl, description, id);
	}

	public MantisQueryHit(TaskList taskList, String handle) {
		super(taskList, AbstractRepositoryTask.getRepositoryUrl(handle), "", AbstractRepositoryTask.getTaskId(handle));
	} 

	@Override
	protected AbstractRepositoryTask createTask() {
		MantisTask newTask = new MantisTask(this.getRepositoryUrl(), this.getTaskId(), getSummary(), true);
		newTask.setPriority(priority);
		return newTask;
	}

	@Override
	public String getUrl() {
		return getRepositoryUrl() + IMantisClient.TICKET_URL + getTaskId();
	}

}

Return to bug 144722

Lines 23-35 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.core/src/com/itsolut/mantis/core/MantisRepositoryConnector.java (-27 / +55 lines)
23		23
24	import java.io.File;	24	import java.io.File;
25	import java.util.ArrayList;	25	import java.util.ArrayList;
		26	import java.util.Collections;
		27	import java.util.Date;
		28	import java.util.HashSet;
26	import java.util.List;	29	import java.util.List;
		30	import java.util.Set;
27		31
28	import org.eclipse.core.runtime.CoreException;	32	import org.eclipse.core.runtime.CoreException;
29	import org.eclipse.core.runtime.IProgressMonitor;	33	import org.eclipse.core.runtime.IProgressMonitor;
30	import org.eclipse.core.runtime.IStatus;	34	import org.eclipse.core.runtime.IStatus;
31	import org.eclipse.core.runtime.Status;	35	import org.eclipse.core.runtime.Status;
32	import org.eclipse.mylar.context.core.MylarStatusHandler;	36	import org.eclipse.mylar.core.MylarStatusHandler;
		37	import org.eclipse.mylar.internal.tasks.core.RepositoryTaskHandleUtil;
33	import org.eclipse.mylar.tasks.core.AbstractRepositoryConnector;	38	import org.eclipse.mylar.tasks.core.AbstractRepositoryConnector;
34	import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;	39	import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;
35	import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;	40	import org.eclipse.mylar.tasks.core.AbstractRepositoryTask;
Lines 46-51 Link Here
46	import com.itsolut.mantis.core.exception.InvalidTicketException;	51	import com.itsolut.mantis.core.exception.InvalidTicketException;
47	import com.itsolut.mantis.core.model.MantisTicket;	52	import com.itsolut.mantis.core.model.MantisTicket;
48	import com.itsolut.mantis.core.model.MantisTicket.Key;	53	import com.itsolut.mantis.core.model.MantisTicket.Key;
		54	import com.itsolut.mantis.core.util.MantisUtils;
49		55
50	/**	56	/**
51	* @author Steffen Pingel	57	* @author Steffen Pingel
Lines 55-62 Link Here
55		61
56	private final static String CLIENT_LABEL = "Mantis (supports connector 0.0.5 only)";	62	private final static String CLIENT_LABEL = "Mantis (supports connector 0.0.5 only)";
57		63
58	private List<String> supportedVersions;
59
60	private MantisClientManager clientManager;	64	private MantisClientManager clientManager;
61		65
62	private MantisOfflineTaskHandler offlineTaskHandler = new MantisOfflineTaskHandler(this);	66	private MantisOfflineTaskHandler offlineTaskHandler = new MantisOfflineTaskHandler(this);
Lines 109-127 Link Here
109	return repositoryUrl + IMantisClient.TICKET_URL + taskId;	113	return repositoryUrl + IMantisClient.TICKET_URL + taskId;
110	}	114	}
111		115
112
113	@Override	116	@Override
114	public List<String> getSupportedVersions() {
115	if (supportedVersions == null) {
116	supportedVersions = new ArrayList<String>();
117	for (Version version : Version.values()) {
118	supportedVersions.add(version.toString());
119	}
120	}
121	return supportedVersions;
122	}
123
124	@Override
125	public IAttachmentHandler getAttachmentHandler() {	117	public IAttachmentHandler getAttachmentHandler() {
126	return attachmentHandler;	118	return attachmentHandler;
127	}	119	}
Lines 134-140 Link Here
134	@Override	126	@Override
135	public void updateTask(TaskRepository repository, AbstractRepositoryTask repositoryTask) throws CoreException {	127	public void updateTask(TaskRepository repository, AbstractRepositoryTask repositoryTask) throws CoreException {
136	if (repositoryTask instanceof MantisTask) {	128	if (repositoryTask instanceof MantisTask) {
137	String id = AbstractRepositoryTask.getTaskId(repositoryTask.getHandleIdentifier());	129	String id = RepositoryTaskHandleUtil.getTaskId(repositoryTask.getHandleIdentifier());
138	try {	130	try {
139	IMantisClient connection = getClientManager().getRepository(repository);	131	IMantisClient connection = getClientManager().getRepository(repository);
140	MantisTicket ticket = connection.getTicket(Integer.parseInt(id));	132	MantisTicket ticket = connection.getTicket(Integer.parseInt(id));
Lines 171-197 Link Here
171		163
172	return Status.OK_STATUS;	164	return Status.OK_STATUS;
173	}	165	}
174		166
175	@Override	167	@Override
176	public AbstractRepositoryTask createTaskFromExistingKey(TaskRepository repository, String id) throws CoreException {	168	public AbstractRepositoryTask createTaskFromExistingKey(TaskRepository repository, String taskId) throws CoreException {
177	int bugId = -1;	169	int bugId = -1;
178	try {	170	try {
179	bugId = Integer.parseInt(id);	171	bugId = Integer.parseInt(taskId);
180	} catch (NumberFormatException e) {	172	} catch (NumberFormatException e) {
181	throw new CoreException(new Status(IStatus.ERROR, MantisCorePlugin.PLUGIN_ID, IStatus.OK,	173	throw new CoreException(new Status(IStatus.ERROR, MantisCorePlugin.PLUGIN_ID, IStatus.OK,
182	"Invalid ticket id: " + id, e));	174	"Invalid ticket id: " + taskId, e));
183	}	175	}
184		176
185	String handle = AbstractRepositoryTask.getHandle(repository.getUrl(), bugId);
186
187	MantisTask task;	177	MantisTask task;
188	ITask existingTask = taskList.getTask(handle);	178	ITask existingTask = taskList.getTask(repository.getUrl(), taskId);
189	if (existingTask instanceof MantisTask) {	179	if (existingTask instanceof MantisTask) {
190	task = (MantisTask) existingTask;	180	task = (MantisTask) existingTask;
191	} else {	181	} else {
192	RepositoryTaskData taskData = offlineTaskHandler.downloadTaskData(repository, bugId);	182	RepositoryTaskData taskData = offlineTaskHandler.downloadTaskData(repository, bugId);
193	// if (taskData != null) {	183	// if (taskData != null) {
194	task = new MantisTask(handle, getTicketDescription(taskData), true);	184	task = new MantisTask(repository.getUrl(), taskId, getTicketDescription(taskData), true);
195	task.setTaskData(taskData);	185	task.setTaskData(taskData);
196	taskList.addTask(task);	186	taskList.addTask(task);
197	// } else {	187	// } else {
Lines 222-234 Link Here
222	return clientManager;	212	return clientManager;
223	}	213	}
224		214
225	public MantisTask createTask(MantisTicket ticket, String handleIdentifier) {	215	public MantisTask createTask(MantisTicket ticket, String repositoryUrl, String taskId) {
226	MantisTask task;	216	MantisTask task;
227	ITask existingTask = taskList.getTask(handleIdentifier);	217	ITask existingTask = taskList.getTask(repositoryUrl, taskId);
228	if (existingTask instanceof MantisTask) {	218	if (existingTask instanceof MantisTask) {
229	task = (MantisTask) existingTask;	219	task = (MantisTask) existingTask;
230	} else {	220	} else {
231	task = new MantisTask(handleIdentifier, getTicketDescription(ticket), true);	221	task = new MantisTask(repositoryUrl, taskId, getTicketDescription(ticket), true);
232	taskList.addTask(task);	222	taskList.addTask(task);
233	}	223	}
234	return task;	224	return task;
Lines 375-378 Link Here
375	return ticket;	365	return ticket;
376	}	366	}
377		367
		368	//TODO: not changed for Mantis yet...
		369	@Override
		370	public Set<AbstractRepositoryTask> getChangedSinceLastSync(TaskRepository repository, Set<AbstractRepositoryTask> tasks) throws CoreException {
		371	if (repository.getSyncTimeStamp() == null) {
		372	return tasks;
		373	}
		374
		375	if (!MantisRepositoryConnector.hasChangedSince(repository)) {
		376	// return an empty list to avoid causing all tasks to synchronized
		377	return Collections.emptySet();
		378	}
		379
		380	Date since = new Date(0);
		381	try {
		382	since = MantisUtils.parseDate(Integer.parseInt(repository.getSyncTimeStamp()));
		383	} catch (NumberFormatException e) {
		384	}
		385
		386	IMantisClient client;
		387	try {
		388	client = getClientManager().getRepository(repository);
		389	Set<Integer> ids = client.getChangedTickets(since);
		390
		391	Set<AbstractRepositoryTask> result = new HashSet<AbstractRepositoryTask>();
		392	if (!ids.isEmpty()) {
		393	for (AbstractRepositoryTask task : tasks) {
		394	Integer id = Integer.parseInt(RepositoryTaskHandleUtil.getTaskId(task.getHandleIdentifier()));
		395	if (ids.contains(id)) {
		396	result.add(task);
		397	}
		398	}
		399	}
		400	return result;
		401	} catch (Exception e) {
		402	throw new CoreException(new Status(IStatus.ERROR, MantisCorePlugin.PLUGIN_ID, IStatus.OK, "could not determine changed tasks", e));
		403	}
		404	}
		405
378	}	406	}

Lines 21-26 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.core/src/com/itsolut/mantis/core/MantisAttributeFactory.java (-1 / +19 lines)
21		21
22	package com.itsolut.mantis.core;	22	package com.itsolut.mantis.core;
23		23
		24	import java.util.Date;
24	import java.util.HashMap;	25	import java.util.HashMap;
25	import java.util.Map;	26	import java.util.Map;
26		27
Lines 28-33 Link Here
28	import org.eclipse.mylar.tasks.core.RepositoryTaskAttribute;	29	import org.eclipse.mylar.tasks.core.RepositoryTaskAttribute;
29		30
30	import com.itsolut.mantis.core.model.MantisTicket.Key;	31	import com.itsolut.mantis.core.model.MantisTicket.Key;
		32	import com.itsolut.mantis.core.util.MantisUtils;
31		33
32	/**	34	/**
33	* Provides a mapping from Mylar task keys to Mantis ticket keys.	35	* Provides a mapping from Mylar task keys to Mantis ticket keys.
Lines 161-167 Link Here
161	}	163	}
162		164
163	static boolean isInternalAttribute(String id) {	165	static boolean isInternalAttribute(String id) {
164	return RepositoryTaskAttribute.REMOVE_CC.equals(id) \|\| RepositoryTaskAttribute.NEW_CC.equals(id) \|\| RepositoryTaskAttribute.ADD_SELF_CC.equals(id);	166	return RepositoryTaskAttribute.REMOVE_CC.equals(id) \|\| RepositoryTaskAttribute.NEW_CC.equals(id) \|\| RepositoryTaskAttribute.ADD_SELF_CC.equals(id) \|\| RepositoryTaskAttribute.COMMENT_NEW.equals(id);
165	}	167	}
166		168
		169	@Override
		170	public Date getDateForAttributeType(String attributeKey, String dateString) {
		171	if (dateString == null \|\| dateString.length() == 0) {
		172	return null;
		173	}
		174
		175	try {
		176	String mappedKey = mapCommonAttributeKey(attributeKey);
		177	if (mappedKey.equals(Attribute.DATE_SUBMITTED.getMantisKey()) \|\| mappedKey.equals(Attribute.LAST_UPDATED.getMantisKey())) {
		178	return MantisUtils.parseDate(Integer.valueOf(dateString));
		179	}
		180	} catch (Exception e) {
		181	}
		182	return null;
		183	}
		184
167	}	185	}

Lines 24-43 Link Here

(-)D:/dev/Eclipse/workspace/Mylar Mantis Connector/com.itsolut.mantis.core/src/com/itsolut/mantis/core/MantisQueryHit.java (-6 / +2 lines)
24	super(taskList, repositoryUrl, description, id);	24	super(taskList, repositoryUrl, description, id);
25	}	25	}
26		26
27	public MantisQueryHit(TaskList taskList, String handle) {
28	super(taskList, AbstractRepositoryTask.getRepositoryUrl(handle), "", AbstractRepositoryTask.getTaskId(handle));
29	}
30
31	@Override	27	@Override
32	protected AbstractRepositoryTask createTask() {	28	protected AbstractRepositoryTask createTask() {
33	MantisTask newTask = new MantisTask(getHandleIdentifier(), getSummary(), true);	29	MantisTask newTask = new MantisTask(this.getRepositoryUrl(), this.getTaskId(), getSummary(), true);
34	newTask.setPriority(priority);	30	newTask.setPriority(priority);
35	return newTask;	31	return newTask;
36	}	32	}
37		33
38	@Override	34	@Override
39	public String getUrl() {	35	public String getUrl() {
40	return getRepositoryUrl() + IMantisClient.TICKET_URL + getId();	36	return getRepositoryUrl() + IMantisClient.TICKET_URL + getTaskId();
41	}	37	}
42		38
43	}	39	}