diff options
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.java | 601 |
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 |