Skip to main content
summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to 'org.eclipse.mylyn.trac.core/src/org/eclipse/mylyn/internal/trac/core/TracRepositoryConnector.java')
-rw-r--r--org.eclipse.mylyn.trac.core/src/org/eclipse/mylyn/internal/trac/core/TracRepositoryConnector.java601
1 files changed, 406 insertions, 195 deletions
diff --git a/org.eclipse.mylyn.trac.core/src/org/eclipse/mylyn/internal/trac/core/TracRepositoryConnector.java b/org.eclipse.mylyn.trac.core/src/org/eclipse/mylyn/internal/trac/core/TracRepositoryConnector.java
index ec39c9a27..010db0431 100644
--- a/org.eclipse.mylyn.trac.core/src/org/eclipse/mylyn/internal/trac/core/TracRepositoryConnector.java
+++ b/org.eclipse.mylyn.trac.core/src/org/eclipse/mylyn/internal/trac/core/TracRepositoryConnector.java
@@ -10,9 +10,12 @@ package org.eclipse.mylyn.internal.trac.core;
import java.io.File;
import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Set;
+import java.util.StringTokenizer;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
@@ -23,50 +26,298 @@ import org.eclipse.core.runtime.Status;
import org.eclipse.mylyn.commons.net.AuthenticationCredentials;
import org.eclipse.mylyn.commons.net.AuthenticationType;
import org.eclipse.mylyn.commons.net.Policy;
-import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
-import org.eclipse.mylyn.internal.tasks.core.deprecated.AbstractAttachmentHandler;
-import org.eclipse.mylyn.internal.tasks.core.deprecated.AbstractLegacyRepositoryConnector;
-import org.eclipse.mylyn.internal.tasks.core.deprecated.AbstractTaskDataHandler;
-import org.eclipse.mylyn.internal.tasks.core.deprecated.LegacyTaskDataCollector;
-import org.eclipse.mylyn.internal.tasks.core.deprecated.RepositoryOperation;
-import org.eclipse.mylyn.internal.tasks.core.deprecated.RepositoryTaskAttribute;
-import org.eclipse.mylyn.internal.tasks.core.deprecated.RepositoryTaskData;
import org.eclipse.mylyn.internal.trac.core.ITracClient.Version;
-import org.eclipse.mylyn.internal.trac.core.TracAttributeFactory.Attribute;
-import org.eclipse.mylyn.internal.trac.core.TracTask.Kind;
import org.eclipse.mylyn.internal.trac.core.model.TracPriority;
+import org.eclipse.mylyn.internal.trac.core.model.TracSearch;
import org.eclipse.mylyn.internal.trac.core.model.TracTicket;
-import org.eclipse.mylyn.internal.trac.core.model.TracTicket.Key;
import org.eclipse.mylyn.internal.trac.core.util.TracUtils;
+import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.ITask;
+import org.eclipse.mylyn.tasks.core.ITaskMapping;
import org.eclipse.mylyn.tasks.core.RepositoryStatus;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.core.TaskRepositoryLocationFactory;
+import org.eclipse.mylyn.tasks.core.ITask.PriorityLevel;
+import org.eclipse.mylyn.tasks.core.data.AbstractTaskAttachmentHandler;
+import org.eclipse.mylyn.tasks.core.data.AbstractTaskDataHandler;
+import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
+import org.eclipse.mylyn.tasks.core.data.TaskData;
import org.eclipse.mylyn.tasks.core.data.TaskDataCollector;
+import org.eclipse.mylyn.tasks.core.data.TaskMapper;
+import org.eclipse.mylyn.tasks.core.data.TaskRelation;
import org.eclipse.mylyn.tasks.core.sync.ISynchronizationSession;
/**
* @author Steffen Pingel
*/
-public class TracRepositoryConnector extends AbstractLegacyRepositoryConnector {
+public class TracRepositoryConnector extends AbstractRepositoryConnector {
+
+ public enum TaskKind {
+ DEFECT, ENHANCEMENT, TASK;
+
+ public static TaskKind fromString(String type) {
+ if (type == null) {
+ return null;
+ }
+ if (type.equals("Defect")) {
+ return DEFECT;
+ }
+ if (type.equals("Enhancement")) {
+ return ENHANCEMENT;
+ }
+ if (type.equals("Task")) {
+ return TASK;
+ }
+ return null;
+ }
+
+ public static TaskKind fromType(String type) {
+ if (type == null) {
+ return null;
+ }
+ if (type.equals("defect")) {
+ return DEFECT;
+ }
+ if (type.equals("enhancement")) {
+ return ENHANCEMENT;
+ }
+ if (type.equals("task")) {
+ return TASK;
+ }
+ return null;
+ }
+
+ @Override
+ public String toString() {
+ switch (this) {
+ case DEFECT:
+ return "Defect";
+ case ENHANCEMENT:
+ return "Enhancement";
+ case TASK:
+ return "Task";
+ default:
+ return "";
+ }
+ }
+
+ }
+
+ public enum TaskStatus {
+ ASSIGNED, CLOSED, NEW, REOPENED;
+
+ public static TaskStatus fromStatus(String status) {
+ if (status == null) {
+ return null;
+ }
+ if (status.equals("new")) {
+ return NEW;
+ }
+ if (status.equals("assigned")) {
+ return ASSIGNED;
+ }
+ if (status.equals("reopened")) {
+ return REOPENED;
+ }
+ if (status.equals("closed")) {
+ return CLOSED;
+ }
+ return null;
+ }
+
+ public String toStatusString() {
+ switch (this) {
+ case NEW:
+ return "new";
+ case ASSIGNED:
+ return "assigned";
+ case REOPENED:
+ return "reopened";
+ case CLOSED:
+ return "closed";
+ default:
+ return "";
+ }
+ }
+
+ @Override
+ public String toString() {
+ switch (this) {
+ case NEW:
+ return "New";
+ case ASSIGNED:
+ return "Assigned";
+ case REOPENED:
+ return "Reopened";
+ case CLOSED:
+ return "Closed";
+ default:
+ return "";
+ }
+ }
+
+ }
+
+ public enum TracPriorityLevel {
+ BLOCKER, CRITICAL, MAJOR, MINOR, TRIVIAL;
+
+ public static TracPriorityLevel fromPriority(String priority) {
+ if (priority == null) {
+ return null;
+ }
+ if (priority.equals("blocker")) {
+ return BLOCKER;
+ }
+ if (priority.equals("critical")) {
+ return CRITICAL;
+ }
+ if (priority.equals("major")) {
+ return MAJOR;
+ }
+ if (priority.equals("minor")) {
+ return MINOR;
+ }
+ if (priority.equals("trivial")) {
+ return TRIVIAL;
+ }
+ return null;
+ }
+
+ public PriorityLevel toPriorityLevel() {
+ switch (this) {
+ case BLOCKER:
+ return PriorityLevel.P1;
+ case CRITICAL:
+ return PriorityLevel.P2;
+ case MAJOR:
+ return PriorityLevel.P3;
+ case MINOR:
+ return PriorityLevel.P4;
+ case TRIVIAL:
+ return PriorityLevel.P5;
+ default:
+ return null;
+ }
+ }
+
+ @Override
+ public String toString() {
+ switch (this) {
+ case BLOCKER:
+ return "blocker";
+ case CRITICAL:
+ return "critical";
+ case MAJOR:
+ return "major";
+ case MINOR:
+ return "minor";
+ case TRIVIAL:
+ return "trivial";
+ default:
+ return null;
+ }
+ }
+ }
private final static String CLIENT_LABEL = "Trac (supports 0.9 or 0.10 through Web and XML-RPC)";
- private TracClientManager clientManager;
+ private static int TASK_PRIORITY_LEVELS = 5;
- private final TracTaskDataHandler taskDataHandler = new TracTaskDataHandler(this);
+ public static final String TASK_KEY_SUPPORTS_SUBTASKS = "SupportsSubtasks";
+
+ public static String getDisplayUsername(TaskRepository repository) {
+ AuthenticationCredentials credentials = repository.getCredentials(AuthenticationType.REPOSITORY);
+ if (credentials != null && credentials.getUserName().length() > 0) {
+ return ITracClient.DEFAULT_USERNAME;
+ }
+ return repository.getUserName();
+ }
+
+ public static PriorityLevel getTaskPriority(String tracPriority) {
+ if (tracPriority != null) {
+ TracPriorityLevel priority = TracPriorityLevel.fromPriority(tracPriority);
+ if (priority != null) {
+ return priority.toPriorityLevel();
+ }
+ }
+ return PriorityLevel.getDefault();
+ }
+
+ public static PriorityLevel getTaskPriority(String priority, TracPriority[] tracPriorities) {
+ if (priority != null && tracPriorities != null && tracPriorities.length > 0) {
+ int minValue = tracPriorities[0].getValue();
+ int range = tracPriorities[tracPriorities.length - 1].getValue() - minValue;
+ for (TracPriority tracPriority : tracPriorities) {
+ if (priority.equals(tracPriority.getName())) {
+ float relativeValue = (float) (tracPriority.getValue() - minValue) / range;
+ int value = (int) (relativeValue * TASK_PRIORITY_LEVELS) + 1;
+ return PriorityLevel.fromLevel(value);
+ }
+ }
+ }
+ return getTaskPriority(priority);
+ }
+
+ public static int getTicketId(String taskId) throws CoreException {
+ try {
+ return Integer.parseInt(taskId);
+ } catch (NumberFormatException e) {
+ throw new CoreException(new Status(IStatus.ERROR, TracCorePlugin.ID_PLUGIN, IStatus.OK,
+ "Invalid ticket id: " + taskId, e));
+ }
+ }
+
+ static List<String> getAttributeValues(TaskData data, String attributeId) {
+ TaskAttribute attribute = data.getRoot().getMappedAttribute(attributeId);
+ if (attribute != null) {
+ return attribute.getValues();
+ } else {
+ return Collections.emptyList();
+ }
+ }
+
+ static String getAttributeValue(TaskData data, String attributeId) {
+ TaskAttribute attribute = data.getRoot().getMappedAttribute(attributeId);
+ if (attribute != null) {
+ return attribute.getValue();
+ } else {
+ return "";
+ }
+ }
+
+ public static boolean hasAttachmentSupport(TaskRepository repository, ITask task) {
+ return Version.XML_RPC.name().equals(repository.getVersion());
+ }
+
+ public static boolean hasChangedSince(TaskRepository repository) {
+ return Version.XML_RPC.name().equals(repository.getVersion());
+ }
+
+ public static boolean hasRichEditor(TaskRepository repository) {
+ return Version.XML_RPC.name().equals(repository.getVersion());
+ }
+
+ public static boolean hasRichEditor(TaskRepository repository, ITask task) {
+ return hasRichEditor(repository);
+ }
+
+ public static boolean isCompleted(String tracStatus) {
+ TaskStatus taskStatus = TaskStatus.fromStatus(tracStatus);
+ return taskStatus == TaskStatus.CLOSED;
+ }
private final TracAttachmentHandler attachmentHandler = new TracAttachmentHandler(this);
- private TaskRepositoryLocationFactory taskRepositoryLocationFactory = new TaskRepositoryLocationFactory();
+ private TracClientManager clientManager;
private File repositoryConfigurationCacheFile;
- public TracRepositoryConnector(File repositoryConfigurationCacheFile) {
- this.repositoryConfigurationCacheFile = repositoryConfigurationCacheFile;
+ private final TracTaskDataHandler taskDataHandler = new TracTaskDataHandler(this);
- }
+ private TaskRepositoryLocationFactory taskRepositoryLocationFactory = new TaskRepositoryLocationFactory();
+
+ private final TracWikiHandler wikiHandler = new TracWikiHandler(this);
public TracRepositoryConnector() {
if (TracCorePlugin.getDefault() != null) {
@@ -76,6 +327,11 @@ public class TracRepositoryConnector extends AbstractLegacyRepositoryConnector {
}
}
+ public TracRepositoryConnector(File repositoryConfigurationCacheFile) {
+ this.repositoryConfigurationCacheFile = repositoryConfigurationCacheFile;
+
+ }
+
@Override
public boolean canCreateNewTask(TaskRepository repository) {
return true;
@@ -86,19 +342,21 @@ public class TracRepositoryConnector extends AbstractLegacyRepositoryConnector {
return true;
}
- private final TracWikiHandler wikiHandler = new TracWikiHandler(this);
+ @Override
+ public AbstractTaskAttachmentHandler getTaskAttachmentHandler() {
+ return attachmentHandler;
+ }
- public boolean hasWiki(TaskRepository repository) {
- // check the access mode to validate Wiki support
- ITracClient client = getClientManager().getTracClient(repository);
- if (client instanceof ITracWikiClient) {
- return true;
+ public synchronized TracClientManager getClientManager() {
+ if (clientManager == null) {
+ clientManager = new TracClientManager(repositoryConfigurationCacheFile, taskRepositoryLocationFactory);
}
- return false;
+ return clientManager;
}
- public AbstractWikiHandler getWikiHandler() {
- return wikiHandler;
+ @Override
+ public String getConnectorKind() {
+ return TracCorePlugin.CONNECTOR_KIND;
}
@Override
@@ -107,8 +365,14 @@ public class TracRepositoryConnector extends AbstractLegacyRepositoryConnector {
}
@Override
- public String getConnectorKind() {
- return TracCorePlugin.REPOSITORY_KIND;
+ public TaskData getTaskData(TaskRepository repository, String taskId, IProgressMonitor monitor)
+ throws CoreException {
+ return taskDataHandler.getTaskData(repository, taskId, monitor);
+ }
+
+ @Override
+ public AbstractTaskDataHandler getTaskDataHandler() {
+ return taskDataHandler;
}
@Override
@@ -130,18 +394,30 @@ public class TracRepositoryConnector extends AbstractLegacyRepositoryConnector {
}
@Override
+ public String getTaskIdPrefix() {
+ return "#";
+ }
+
+ public TaskRepositoryLocationFactory getTaskRepositoryLocationFactory() {
+ return taskRepositoryLocationFactory;
+ }
+
+ @Override
public String getTaskUrl(String repositoryUrl, String taskId) {
return repositoryUrl + ITracClient.TICKET_URL + taskId;
}
- @Override
- public AbstractAttachmentHandler getAttachmentHandler() {
- return attachmentHandler;
+ public AbstractWikiHandler getWikiHandler() {
+ return wikiHandler;
}
- @Override
- public AbstractTaskDataHandler getLegacyTaskDataHandler() {
- return taskDataHandler;
+ public boolean hasWiki(TaskRepository repository) {
+ // check the access mode to validate Wiki support
+ ITracClient client = getClientManager().getTracClient(repository);
+ if (client instanceof ITracWikiClient) {
+ return true;
+ }
+ return false;
}
@Override
@@ -150,20 +426,22 @@ public class TracRepositoryConnector extends AbstractLegacyRepositoryConnector {
try {
monitor.beginTask("Querying repository", IProgressMonitor.UNKNOWN);
- final List<TracTicket> tickets = new ArrayList<TracTicket>();
+ TracSearch search = TracUtils.toTracSearch(query);
+ if (search == null) {
+ return new RepositoryStatus(repository.getRepositoryUrl(), IStatus.ERROR, TracCorePlugin.ID_PLUGIN,
+ RepositoryStatus.ERROR_REPOSITORY, "The query is invalid: \"" + query.getUrl() + "\"");
+ }
ITracClient client;
try {
client = getClientManager().getTracClient(repository);
- if (query instanceof TracRepositoryQuery) {
- client.search(((TracRepositoryQuery) query).getTracSearch(), tickets, monitor);
- }
+ final List<TracTicket> tickets = new ArrayList<TracTicket>();
+ client.search(search, tickets, monitor);
client.updateAttributes(monitor, false);
for (TracTicket ticket : tickets) {
- RepositoryTaskData taskData = taskDataHandler.createTaskDataFromTicket(client, repository, ticket,
- monitor);
- ((LegacyTaskDataCollector) resultCollector).accept(taskData);
+ TaskData taskData = taskDataHandler.createTaskDataFromTicket(client, repository, ticket, monitor);
+ resultCollector.accept(taskData);
}
} catch (Throwable e) {
return TracCorePlugin.toStatus(e, repository);
@@ -176,6 +454,34 @@ public class TracRepositoryConnector extends AbstractLegacyRepositoryConnector {
}
@Override
+ public void postSynchronization(ISynchronizationSession event, IProgressMonitor monitor) throws CoreException {
+ try {
+ monitor.beginTask("", 1);
+ if (event.isFullSynchronization()) {
+ Date date = getSynchronizationTimestamp(event);
+ if (date != null) {
+ event.getTaskRepository().setSynchronizationTimeStamp(TracUtils.toTracTime(date) + "");
+ }
+ }
+ } finally {
+ monitor.done();
+ }
+ }
+
+ private Date getSynchronizationTimestamp(ISynchronizationSession event) {
+ Date mostRecent = new Date(0);
+ Date mostRecentTimeStamp = TracUtils.parseDate(event.getTaskRepository().getSynchronizationTimeStamp());
+ for (ITask task : event.getChangedTasks()) {
+ Date taskModifiedDate = task.getModificationDate();
+ if (taskModifiedDate != null && taskModifiedDate.after(mostRecent)) {
+ mostRecent = taskModifiedDate;
+ mostRecentTimeStamp = task.getModificationDate();
+ }
+ }
+ return mostRecentTimeStamp;
+ }
+
+ @Override
public void preSynchronization(ISynchronizationSession session, IProgressMonitor monitor) throws CoreException {
monitor = Policy.monitorFor(monitor);
try {
@@ -250,70 +556,12 @@ public class TracRepositoryConnector extends AbstractLegacyRepositoryConnector {
}
}
- @Override
- public AbstractTask createTask(String repositoryUrl, String id, String summary) {
- TracTask tracTask = new TracTask(repositoryUrl, id, summary);
- tracTask.setCreationDate(new Date());
- return tracTask;
- }
-
- @Override
- public boolean updateTaskFromTaskData(TaskRepository taskRepository, ITask task, RepositoryTaskData taskData) {
- TracTask tracTask = (TracTask) task;
- ITracClient client = getClientManager().getTracClient(taskRepository);
-
- task.setSummary(taskData.getSummary());
- task.setOwner(taskData.getAttributeValue(RepositoryTaskAttribute.USER_ASSIGNED));
- if (TracTask.isCompleted(taskData.getStatus())) {
- task.setCompletionDate(TracUtils.parseDate(Integer.valueOf(taskData.getLastModified())));
- } else {
- task.setCompletionDate(null);
- }
- task.setUrl(taskRepository.getRepositoryUrl() + ITracClient.TICKET_URL + taskData.getTaskId());
-
- String priority = taskData.getAttributeValue(Attribute.PRIORITY.getTracKey());
- TracPriority[] tracPriorities = client.getPriorities();
- task.setPriority(TracTask.getTaskPriority(priority, tracPriorities).toString());
-
- Kind kind = TracTask.Kind.fromType(taskData.getAttributeValue(Attribute.TYPE.getTracKey()));
- task.setTaskKind((kind != null) ? kind.toString() : null);
-
- tracTask.setSupportsSubtasks(taskDataHandler.canInitializeSubTaskData(null, taskData));
-
- // TODO check return value
- return false;
- }
-
- public static int getTicketId(String taskId) throws CoreException {
- try {
- return Integer.parseInt(taskId);
- } catch (NumberFormatException e) {
- throw new CoreException(new Status(IStatus.ERROR, TracCorePlugin.ID_PLUGIN, IStatus.OK,
- "Invalid ticket id: " + taskId, e));
- }
- }
-
- public synchronized TracClientManager getClientManager() {
- if (clientManager == null) {
- clientManager = new TracClientManager(repositoryConfigurationCacheFile, taskRepositoryLocationFactory);
+ public synchronized void setTaskRepositoryLocationFactory(
+ TaskRepositoryLocationFactory taskRepositoryLocationFactory) {
+ this.taskRepositoryLocationFactory = taskRepositoryLocationFactory;
+ if (this.clientManager != null) {
+ clientManager.setTaskRepositoryLocationFactory(taskRepositoryLocationFactory);
}
- return clientManager;
- }
-
- public static boolean hasChangedSince(TaskRepository repository) {
- return Version.XML_RPC.name().equals(repository.getVersion());
- }
-
- public static boolean hasRichEditor(TaskRepository repository) {
- return Version.XML_RPC.name().equals(repository.getVersion());
- }
-
- public static boolean hasRichEditor(TaskRepository repository, ITask task) {
- return hasRichEditor(repository);
- }
-
- public static boolean hasAttachmentSupport(TaskRepository repository, ITask task) {
- return Version.XML_RPC.name().equals(repository.getVersion());
}
public void stop() {
@@ -333,110 +581,73 @@ public class TracRepositoryConnector extends AbstractLegacyRepositoryConnector {
}
}
- public static String getDisplayUsername(TaskRepository repository) {
- AuthenticationCredentials credentials = repository.getCredentials(AuthenticationType.REPOSITORY);
- if (credentials != null && credentials.getUserName().length() > 0) {
- return ITracClient.DEFAULT_USERNAME;
+ @Override
+ public void updateTaskFromTaskData(TaskRepository taskRepository, ITask task, TaskData taskData) {
+ TaskMapper mapper = getTaskMapper(taskRepository, taskData);
+ mapper.applyTo(task);
+ if (isCompleted(mapper.getStatus())) {
+ task.setCompletionDate(mapper.getModificationDate());
+ } else {
+ task.setCompletionDate(null);
}
- return repository.getUserName();
+ task.setUrl(taskRepository.getRepositoryUrl() + ITracClient.TICKET_URL + taskData.getTaskId());
+ task.setAttribute(TASK_KEY_SUPPORTS_SUBTASKS, Boolean.toString(taskDataHandler.supportsSubtasks(taskData)));
}
@Override
- public String getTaskIdPrefix() {
- return "#";
- }
-
- public static TracTicket getTracTicket(TaskRepository repository, RepositoryTaskData data)
- throws InvalidTicketException, CoreException {
- TracTicket ticket = new TracTicket(getTicketId(data.getTaskId()));
-
- List<RepositoryTaskAttribute> attributes = data.getAttributes();
- for (RepositoryTaskAttribute attribute : attributes) {
- if (TracAttributeFactory.isInternalAttribute(attribute.getId())) {
- // ignore
- } else if (!attribute.isReadOnly()) {
- ticket.putValue(attribute.getId(), attribute.getValue());
- }
- }
-
- // set cc value
- StringBuilder sb = new StringBuilder();
- List<String> removeValues = data.getAttributeValues(RepositoryTaskAttribute.REMOVE_CC);
- List<String> values = data.getAttributeValues(RepositoryTaskAttribute.USER_CC);
- for (String user : values) {
- if (!removeValues.contains(user)) {
- if (sb.length() > 0) {
- sb.append(",");
- }
- sb.append(user);
- }
- }
- if (data.getAttributeValue(RepositoryTaskAttribute.NEW_CC).length() > 0) {
- if (sb.length() > 0) {
- sb.append(",");
- }
- sb.append(data.getAttributeValue(RepositoryTaskAttribute.NEW_CC));
- }
- if (RepositoryTaskAttribute.TRUE.equals(data.getAttributeValue(RepositoryTaskAttribute.ADD_SELF_CC))) {
- if (sb.length() > 0) {
- sb.append(",");
- }
- sb.append(repository.getUserName());
- }
- ticket.putBuiltinValue(Key.CC, sb.toString());
-
- RepositoryOperation operation = data.getSelectedOperation();
- if (operation != null) {
- String action = operation.getKnobName();
- if (!"leave".equals(action)) {
- if ("accept".equals(action)) {
- ticket.putValue("status", TracTask.Status.ASSIGNED.toStatusString());
- ticket.putValue("owner", getDisplayUsername(repository));
- } else if ("resolve".equals(action)) {
- ticket.putValue("status", TracTask.Status.CLOSED.toStatusString());
- ticket.putValue("resolution", operation.getOptionSelection());
- } else if ("reopen".equals(action)) {
- ticket.putValue("status", TracTask.Status.REOPENED.toStatusString());
- ticket.putValue("resolution", "");
- } else if ("reassign".equals(operation.getKnobName())) {
- ticket.putValue("status", TracTask.Status.NEW.toStatusString());
- ticket.putValue("owner", operation.getInputValue());
- }
+ public boolean hasTaskChanged(TaskRepository taskRepository, ITask task, TaskData taskData) {
+ TaskMapper mapper = getTaskMapper(taskRepository, taskData);
+ if (taskData.isPartial()) {
+ return mapper.hasChanges(task);
+ } else {
+ Date repositoryDate = mapper.getModificationDate();
+ Date localDate = task.getModificationDate();
+ if (repositoryDate != null && repositoryDate.equals(localDate)) {
+ return false;
}
+ return true;
}
-
- return ticket;
}
- public TaskRepositoryLocationFactory getTaskRepositoryLocationFactory() {
- return taskRepositoryLocationFactory;
- }
-
- public synchronized void setTaskRepositoryLocationFactory(
- TaskRepositoryLocationFactory taskRepositoryLocationFactory) {
- this.taskRepositoryLocationFactory = taskRepositoryLocationFactory;
- if (this.clientManager != null) {
- clientManager.setTaskRepositoryLocationFactory(taskRepositoryLocationFactory);
+ @Override
+ public Collection<TaskRelation> getTaskRelations(TaskData taskData) {
+ TaskAttribute attribute = taskData.getRoot().getAttribute(TracTaskDataHandler.ATTRIBUTE_BLOCKED_BY);
+ if (attribute != null) {
+ List<TaskRelation> result = new ArrayList<TaskRelation>();
+ StringTokenizer t = new StringTokenizer(attribute.getValue(), ", ");
+ while (t.hasMoreTokens()) {
+ result.add(TaskRelation.subtask(t.nextToken()));
+ }
+ return result;
}
+ return Collections.emptySet();
}
@Override
- public RepositoryTaskData getLegacyTaskData(TaskRepository repository, String taskId, IProgressMonitor monitor)
- throws CoreException {
- return getLegacyTaskDataHandler().getTaskData(repository, taskId, monitor);
- }
+ public ITaskMapping getTaskMapping(TaskData taskData) {
+ return getTaskMapper(null, taskData);
+ }
+
+ public TaskMapper getTaskMapper(TaskRepository taskRepository, TaskData taskData) {
+ final ITracClient client = (taskRepository != null) ? getClientManager().getTracClient(taskRepository) : null;
+ return new TaskMapper(taskData) {
+ @Override
+ public PriorityLevel getPriorityLevel() {
+ if (client != null) {
+ String priority = getPriority();
+ TracPriority[] tracPriorities = client.getPriorities();
+ return getTaskPriority(priority, tracPriorities);
+ }
+ return null;
+ }
- @Override
- public void postSynchronization(ISynchronizationSession event, IProgressMonitor monitor) throws CoreException {
- try {
- monitor.beginTask("", 1);
- if (event.isFullSynchronization()) {
- event.getTaskRepository().setSynchronizationTimeStamp(
- getSynchronizationTimestamp(event.getTaskRepository(), event.getChangedTasks()));
+ @Override
+ public String getTaskKind() {
+ TaskKind taskKind = TaskKind.fromType(super.getTaskKind());
+ return (taskKind != null) ? taskKind.toString() : null;
}
- } finally {
- monitor.done();
- }
+
+ };
}
} \ No newline at end of file

Back to the top