| /******************************************************************************* |
| * Copyright (c) 2006, 2012 Steffen Pingel and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Steffen Pingel - initial API and implementation |
| * Benjamin Muskalla - bug 386920 |
| *******************************************************************************/ |
| |
| package org.eclipse.mylyn.internal.trac.core; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Date; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.Set; |
| import java.util.StringTokenizer; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.mylyn.commons.net.Policy; |
| import org.eclipse.mylyn.internal.trac.core.client.ITracClient; |
| import org.eclipse.mylyn.internal.trac.core.client.InvalidTicketException; |
| import org.eclipse.mylyn.internal.trac.core.model.TracAction; |
| import org.eclipse.mylyn.internal.trac.core.model.TracAttachment; |
| import org.eclipse.mylyn.internal.trac.core.model.TracComment; |
| 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.model.TracTicketField; |
| import org.eclipse.mylyn.internal.trac.core.util.TracUtil; |
| import org.eclipse.mylyn.tasks.core.ITask; |
| import org.eclipse.mylyn.tasks.core.ITaskMapping; |
| import org.eclipse.mylyn.tasks.core.RepositoryResponse; |
| import org.eclipse.mylyn.tasks.core.RepositoryResponse.ResponseKind; |
| import org.eclipse.mylyn.tasks.core.RepositoryStatus; |
| import org.eclipse.mylyn.tasks.core.TaskRepository; |
| import org.eclipse.mylyn.tasks.core.data.AbstractTaskDataHandler; |
| import org.eclipse.mylyn.tasks.core.data.TaskAttachmentMapper; |
| import org.eclipse.mylyn.tasks.core.data.TaskAttribute; |
| import org.eclipse.mylyn.tasks.core.data.TaskAttributeMapper; |
| import org.eclipse.mylyn.tasks.core.data.TaskAttributeMetaData; |
| import org.eclipse.mylyn.tasks.core.data.TaskCommentMapper; |
| import org.eclipse.mylyn.tasks.core.data.TaskData; |
| import org.eclipse.mylyn.tasks.core.data.TaskMapper; |
| import org.eclipse.mylyn.tasks.core.data.TaskOperation; |
| import org.eclipse.osgi.util.NLS; |
| |
| /** |
| * @author Steffen Pingel |
| * @author Benjamin Muskalla |
| */ |
| public class TracTaskDataHandler extends AbstractTaskDataHandler { |
| |
| private static final String TASK_TYPE_TASK = "task"; //$NON-NLS-1$ |
| |
| public static final String TASK_TYPE_STORY = "story"; //$NON-NLS-1$ |
| |
| private static final String TASK_DATA_VERSION = "2"; //$NON-NLS-1$ |
| |
| public static final String ATTRIBUTE_BLOCKED_BY = "blockedby"; //$NON-NLS-1$ |
| |
| public static final String ATTRIBUTE_BLOCKING = "blocking"; //$NON-NLS-1$ |
| |
| private static final String CC_DELIMETER = ", "; //$NON-NLS-1$ |
| |
| private static final String TRAC_KEY = "tracKey"; //$NON-NLS-1$ |
| |
| private final TracRepositoryConnector connector; |
| |
| public TracTaskDataHandler(TracRepositoryConnector connector) { |
| this.connector = connector; |
| } |
| |
| public TaskData getTaskData(TaskRepository repository, String taskId, IProgressMonitor monitor) |
| throws CoreException { |
| monitor = Policy.monitorFor(monitor); |
| try { |
| monitor.beginTask("Task Download", IProgressMonitor.UNKNOWN); //$NON-NLS-1$ |
| return downloadTaskData(repository, TracRepositoryConnector.getTicketId(taskId), monitor); |
| } finally { |
| monitor.done(); |
| } |
| } |
| |
| public TaskData downloadTaskData(TaskRepository repository, int taskId, IProgressMonitor monitor) |
| throws CoreException { |
| ITracClient client = connector.getClientManager().getTracClient(repository); |
| TracTicket ticket; |
| try { |
| client.updateAttributes(monitor, false); |
| ticket = client.getTicket(taskId, monitor); |
| } catch (OperationCanceledException e) { |
| throw e; |
| } catch (Exception e) { |
| // TODO catch TracException |
| throw new CoreException(TracCorePlugin.toStatus(e, repository)); |
| } |
| return createTaskDataFromTicket(client, repository, ticket, monitor); |
| } |
| |
| public TaskData createTaskDataFromTicket(ITracClient client, TaskRepository repository, TracTicket ticket, |
| IProgressMonitor monitor) throws CoreException { |
| TaskData taskData = new TaskData(getAttributeMapper(repository), TracCorePlugin.CONNECTOR_KIND, |
| repository.getRepositoryUrl(), ticket.getId() + ""); //$NON-NLS-1$ |
| taskData.setVersion(TASK_DATA_VERSION); |
| try { |
| if (!TracRepositoryConnector.hasRichEditor(repository)) { |
| createDefaultAttributes(taskData, client, true); |
| Set<TaskAttribute> changedAttributes = updateTaskData(repository, taskData, ticket); |
| // remove attributes that were not set, i.e. were not received from the server |
| List<TaskAttribute> attributes = new ArrayList<TaskAttribute>(taskData.getRoot() |
| .getAttributes() |
| .values()); |
| for (TaskAttribute attribute : attributes) { |
| if (!changedAttributes.contains(attribute) && !TracAttributeMapper.isInternalAttribute(attribute)) { |
| taskData.getRoot().removeAttribute(attribute.getId()); |
| } |
| } |
| taskData.setPartial(true); |
| } else { |
| createDefaultAttributes(taskData, client, true); |
| updateTaskData(repository, taskData, ticket); |
| } |
| removeEmptySingleSelectAttributes(taskData); |
| return taskData; |
| } catch (OperationCanceledException e) { |
| throw e; |
| } catch (Exception e) { |
| // TODO catch TracException |
| throw new CoreException(TracCorePlugin.toStatus(e, repository)); |
| } |
| } |
| |
| private void removeEmptySingleSelectAttributes(TaskData taskData) { |
| List<TaskAttribute> attributes = new ArrayList<TaskAttribute>(taskData.getRoot().getAttributes().values()); |
| for (TaskAttribute attribute : attributes) { |
| if (TaskAttribute.TYPE_SINGLE_SELECT.equals(attribute.getMetaData().getType()) |
| && attribute.getValue().length() == 0 && attribute.getOptions().isEmpty()) { |
| taskData.getRoot().removeAttribute(attribute.getId()); |
| } |
| } |
| } |
| |
| public static Set<TaskAttribute> updateTaskData(TaskRepository repository, TaskData data, TracTicket ticket) { |
| Set<TaskAttribute> changedAttributes = new HashSet<TaskAttribute>(); |
| |
| Date lastChanged = ticket.getLastChanged(); |
| if (lastChanged != null) { |
| TaskAttribute taskAttribute = data.getRoot().getAttribute(TracAttribute.CHANGE_TIME.getTracKey()); |
| taskAttribute.setValue(TracUtil.toTracTime(lastChanged) + ""); //$NON-NLS-1$ |
| changedAttributes.add(taskAttribute); |
| } |
| |
| if (ticket.getCreated() != null) { |
| TaskAttribute taskAttribute = data.getRoot().getAttribute(TracAttribute.TIME.getTracKey()); |
| taskAttribute.setValue(TracUtil.toTracTime(ticket.getCreated()) + ""); //$NON-NLS-1$ |
| changedAttributes.add(taskAttribute); |
| } |
| |
| Map<String, String> valueByKey = ticket.getValues(); |
| for (String key : valueByKey.keySet()) { |
| TaskAttribute taskAttribute = data.getRoot().getAttribute(key); |
| if (taskAttribute != null) { |
| if (Key.CC.getKey().equals(key)) { |
| StringTokenizer t = new StringTokenizer(valueByKey.get(key), CC_DELIMETER); |
| while (t.hasMoreTokens()) { |
| taskAttribute.addValue(t.nextToken()); |
| } |
| } else { |
| taskAttribute.setValue(valueByKey.get(key)); |
| } |
| changedAttributes.add(taskAttribute); |
| } else { |
| // TODO log missing attribute? |
| } |
| } |
| |
| TracComment[] comments = ticket.getComments(); |
| if (comments != null) { |
| int count = 1; |
| for (int i = 0; i < comments.length; i++) { |
| if (!"comment".equals(comments[i].getField()) || "".equals(comments[i].getNewValue())) { //$NON-NLS-1$ //$NON-NLS-2$ |
| continue; |
| } |
| |
| TaskCommentMapper mapper = new TaskCommentMapper(); |
| mapper.setAuthor(repository.createPerson(comments[i].getAuthor())); |
| mapper.setCreationDate(comments[i].getCreated()); |
| mapper.setText(comments[i].getNewValue()); |
| // TODO mapper.setUrl(); |
| mapper.setNumber(count); |
| |
| TaskAttribute attribute = data.getRoot().createAttribute(TaskAttribute.PREFIX_COMMENT + count); |
| mapper.applyTo(attribute); |
| count++; |
| } |
| } |
| |
| TracAttachment[] attachments = ticket.getAttachments(); |
| if (attachments != null) { |
| for (int i = 0; i < attachments.length; i++) { |
| TaskAttachmentMapper mapper = new TaskAttachmentMapper(); |
| mapper.setAuthor(repository.createPerson(attachments[i].getAuthor())); |
| mapper.setDescription(attachments[i].getDescription()); |
| mapper.setFileName(attachments[i].getFilename()); |
| mapper.setLength((long) attachments[i].getSize()); |
| if (attachments[i].getCreated() != null) { |
| if (lastChanged == null || attachments[i].getCreated().after(lastChanged)) { |
| lastChanged = attachments[i].getCreated(); |
| } |
| mapper.setCreationDate(attachments[i].getCreated()); |
| } |
| mapper.setUrl(repository.getRepositoryUrl() + ITracClient.TICKET_ATTACHMENT_URL + ticket.getId() + "/" //$NON-NLS-1$ |
| + TracUtil.encodeUrl(attachments[i].getFilename())); |
| mapper.setAttachmentId(i + ""); //$NON-NLS-1$ |
| |
| TaskAttribute attribute = data.getRoot().createAttribute(TaskAttribute.PREFIX_ATTACHMENT + (i + 1)); |
| mapper.applyTo(attribute); |
| } |
| } |
| |
| TracAction[] actions = ticket.getActions(); |
| if (actions != null) { |
| // add actions and set first as default |
| for (TracAction action : actions) { |
| addOperation(repository, data, ticket, action, action == actions[0]); |
| } |
| } |
| |
| return changedAttributes; |
| } |
| |
| private static void addOperation(TaskRepository repository, TaskData data, TracTicket ticket, TracAction action, |
| boolean setAsDefault) { |
| String label = action.getLabel(); |
| if (label == null) { |
| if ("leave".equals(action.getId())) { //$NON-NLS-1$ |
| String status = ticket.getValue(Key.STATUS); |
| if (status != null) { |
| String resolution = ticket.getValue(Key.RESOLUTION); |
| if (resolution != null) { |
| label = NLS.bind(Messages.TracTaskDataHandler_Leave_as_Status_Resolution, status, resolution); |
| } else { |
| label = NLS.bind(Messages.TracTaskDataHandler_Leave_as_Status, status); |
| } |
| } else { |
| label = Messages.TracTaskDataHandler_Leave; |
| } |
| } else if ("accept".equals(action.getId())) { //$NON-NLS-1$ |
| label = Messages.TracTaskDataHandler_Accept; |
| } else if ("resolve".equals(action.getId())) { //$NON-NLS-1$ |
| label = Messages.TracTaskDataHandler_Resolve_as; |
| } else if ("reopen".equals(action.getId())) { //$NON-NLS-1$ |
| label = Messages.TracTaskDataHandler_Reopen; |
| } else if ("reassign".equals(action.getId())) { //$NON-NLS-1$ |
| // do not add reassign for Trac 0.10 since the assigned to field is editable |
| } else { |
| label = action.getId(); |
| } |
| } |
| |
| if (label != null) { |
| TaskAttribute attribute = data.getRoot().createAttribute(TaskAttribute.PREFIX_OPERATION + action.getId()); |
| TaskOperation.applyTo(attribute, action.getId(), label); |
| if (!action.getFields().isEmpty()) { |
| // TODO support more than one field |
| TracTicketField field = action.getFields().get(0); |
| TaskAttribute fieldAttribute = createAttribute(data, field); |
| fieldAttribute.getMetaData().setKind(null); |
| attribute.getMetaData().putValue(TaskAttribute.META_ASSOCIATED_ATTRIBUTE_ID, fieldAttribute.getId()); |
| } else if ("resolve".equals(action.getId())) { //$NON-NLS-1$ |
| attribute.getMetaData().putValue(TaskAttribute.META_ASSOCIATED_ATTRIBUTE_ID, |
| TracAttribute.RESOLUTION.getTracKey()); |
| } |
| |
| if (setAsDefault) { |
| TaskAttribute operationAttribute = data.getRoot().createAttribute(TaskAttribute.OPERATION); |
| TaskOperation.applyTo(operationAttribute, action.getId(), label); |
| } |
| } |
| } |
| |
| public static void createDefaultAttributes(TaskData data, ITracClient client, boolean existingTask) { |
| data.setVersion(TASK_DATA_VERSION); |
| |
| createAttribute(data, client, TracAttribute.SUMMARY); |
| createAttribute(data, client, TracAttribute.DESCRIPTION); |
| if (existingTask) { |
| createAttribute(data, client, TracAttribute.TIME); |
| createAttribute(data, client, TracAttribute.CHANGE_TIME); |
| createAttribute(data, client, TracAttribute.STATUS); |
| TaskAttribute attribute = createAttribute(data, client, TracAttribute.RESOLUTION); |
| // reset default value to avoid "fixed" resolution on tasks created through web |
| attribute.setValue(""); //$NON-NLS-1$ |
| // internal attributes |
| createAttribute(data, null, TracAttribute.TOKEN); |
| } |
| createAttribute(data, client, TracAttribute.COMPONENT); |
| createAttribute(data, client, TracAttribute.VERSION); |
| createAttribute(data, client, TracAttribute.PRIORITY); |
| createAttribute(data, client, TracAttribute.SEVERITY); |
| createAttribute(data, client, TracAttribute.MILESTONE); |
| createAttribute(data, client, TracAttribute.TYPE); |
| createAttribute(data, client, TracAttribute.KEYWORDS); |
| // custom fields |
| TracTicketField[] fields = client.getTicketFields(); |
| if (fields != null) { |
| for (TracTicketField field : fields) { |
| if (field.isCustom()) { |
| createAttribute(data, field); |
| } |
| } |
| } |
| // people |
| createAttribute(data, client, TracAttribute.OWNER); |
| if (existingTask) { |
| createAttribute(data, client, TracAttribute.REPORTER); |
| } |
| createAttribute(data, client, TracAttribute.CC); |
| if (existingTask) { |
| data.getRoot() |
| .createAttribute(TracAttributeMapper.NEW_CC) |
| .getMetaData() |
| .setType(TaskAttribute.TYPE_SHORT_TEXT) |
| .setReadOnly(false); |
| data.getRoot().createAttribute(TracAttributeMapper.REMOVE_CC); |
| data.getRoot() |
| .createAttribute(TaskAttribute.COMMENT_NEW) |
| .getMetaData() |
| .setType(TaskAttribute.TYPE_LONG_RICH_TEXT) |
| .setReadOnly(false); |
| } |
| // operations |
| data.getRoot().createAttribute(TaskAttribute.OPERATION).getMetaData().setType(TaskAttribute.TYPE_OPERATION); |
| } |
| |
| private static TaskAttribute createAttribute(TaskData data, TracTicketField field) { |
| TaskAttribute attr = data.getRoot().createAttribute(field.getName()); |
| TaskAttributeMetaData metaData = attr.getMetaData(); |
| metaData.defaults(); |
| metaData.setLabel(field.getLabel() + ":"); //$NON-NLS-1$ |
| metaData.setKind(TaskAttribute.KIND_DEFAULT); |
| metaData.setReadOnly(false); |
| metaData.putValue(TRAC_KEY, field.getName()); |
| if (field.getType() == TracTicketField.Type.CHECKBOX) { |
| // attr.addOption("True", "1"); |
| // attr.addOption("False", "0"); |
| metaData.setType(TaskAttribute.TYPE_BOOLEAN); |
| attr.putOption("1", "1"); //$NON-NLS-1$ //$NON-NLS-2$ |
| attr.putOption("0", "0"); //$NON-NLS-1$ //$NON-NLS-2$ |
| if (field.getDefaultValue() != null) { |
| attr.setValue(field.getDefaultValue()); |
| } |
| } else if (field.getType() == TracTicketField.Type.SELECT || field.getType() == TracTicketField.Type.RADIO) { |
| metaData.setType(TaskAttribute.TYPE_SINGLE_SELECT); |
| String[] values = field.getOptions(); |
| if (values != null && values.length > 0) { |
| if (field.isOptional()) { |
| attr.putOption("", ""); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| for (String value : values) { |
| attr.putOption(value, value); |
| } |
| if (field.getDefaultValue() != null) { |
| try { |
| int index = Integer.parseInt(field.getDefaultValue()); |
| if (index > 0 && index < values.length) { |
| attr.setValue(values[index]); |
| } |
| } catch (NumberFormatException e) { |
| for (String value : values) { |
| if (field.getDefaultValue().equals(value.toString())) { |
| attr.setValue(value); |
| break; |
| } |
| } |
| } |
| } |
| } |
| } else if (field.getType() == TracTicketField.Type.TEXTAREA) { |
| metaData.setType(TaskAttribute.TYPE_LONG_TEXT); |
| if (field.getDefaultValue() != null) { |
| attr.setValue(field.getDefaultValue()); |
| } |
| } else { |
| metaData.setType(TaskAttribute.TYPE_SHORT_TEXT); |
| if (field.getDefaultValue() != null) { |
| attr.setValue(field.getDefaultValue()); |
| } |
| } |
| if (ATTRIBUTE_BLOCKED_BY.equals(field.getName()) || ATTRIBUTE_BLOCKING.equals(field.getName())) { |
| metaData.setType(TaskAttribute.TYPE_TASK_DEPENDENCY); |
| } |
| return attr; |
| } |
| |
| public static TaskAttribute createAttribute(TaskData data, TracAttribute tracAttribute) { |
| return createAttribute(data, null, tracAttribute); |
| } |
| |
| public static TaskAttribute createAttribute(TaskData data, ITracClient client, TracAttribute tracAttribute) { |
| TaskAttribute attr = data.getRoot().createAttribute(tracAttribute.getTracKey()); |
| TaskAttributeMetaData metaData = attr.getMetaData(); |
| metaData.setType(tracAttribute.getType()); |
| metaData.setKind(tracAttribute.getKind()); |
| metaData.setLabel(tracAttribute.toString()); |
| metaData.setReadOnly(tracAttribute.isReadOnly()); |
| metaData.putValue(TRAC_KEY, tracAttribute.getTracKey()); |
| if (client != null) { |
| TracTicketField field = client.getTicketFieldByName(tracAttribute.getTracKey()); |
| Map<String, String> values = TracAttributeMapper.getRepositoryOptions(client, attr.getId()); |
| if (values != null && values.size() > 0) { |
| boolean setDefault = field == null || !field.isOptional(); |
| for (Entry<String, String> value : values.entrySet()) { |
| attr.putOption(value.getKey(), value.getValue()); |
| // set first value as default, may get overwritten below |
| if (setDefault) { |
| attr.setValue(value.getKey()); |
| } |
| setDefault = false; |
| } |
| } else if (TaskAttribute.TYPE_SINGLE_SELECT.equals(tracAttribute.getType())) { |
| attr.getMetaData().setReadOnly(true); |
| } |
| if (field != null) { |
| String defaultValue = field.getDefaultValue(); |
| if (defaultValue != null && defaultValue.length() > 0) { |
| attr.setValue(defaultValue); |
| } |
| } |
| } |
| return attr; |
| } |
| |
| @Override |
| public RepositoryResponse postTaskData(TaskRepository repository, TaskData taskData, |
| Set<TaskAttribute> oldAttributes, IProgressMonitor monitor) throws CoreException { |
| try { |
| TracTicket ticket = TracTaskDataHandler.getTracTicket(repository, taskData); |
| ITracClient server = connector.getClientManager().getTracClient(repository); |
| if (taskData.isNew()) { |
| int id = server.createTicket(ticket, monitor); |
| return new RepositoryResponse(ResponseKind.TASK_CREATED, id + ""); //$NON-NLS-1$ |
| } else { |
| String newComment = ""; //$NON-NLS-1$ |
| TaskAttribute newCommentAttribute = taskData.getRoot().getMappedAttribute(TaskAttribute.COMMENT_NEW); |
| if (newCommentAttribute != null) { |
| newComment = newCommentAttribute.getValue(); |
| } |
| server.updateTicket(ticket, newComment, monitor); |
| return new RepositoryResponse(ResponseKind.TASK_UPDATED, ticket.getId() + ""); //$NON-NLS-1$ |
| } |
| } catch (OperationCanceledException e) { |
| throw e; |
| } catch (Exception e) { |
| // TODO catch TracException |
| throw new CoreException(TracCorePlugin.toStatus(e, repository)); |
| } |
| } |
| |
| @Override |
| public boolean initializeTaskData(TaskRepository repository, TaskData data, ITaskMapping initializationData, |
| IProgressMonitor monitor) throws CoreException { |
| monitor = Policy.monitorFor(monitor); |
| try { |
| ITracClient client = connector.getClientManager().getTracClient(repository); |
| client.updateAttributes(monitor, false); |
| createDefaultAttributes(data, client, false); |
| removeEmptySingleSelectAttributes(data); |
| return true; |
| } catch (OperationCanceledException e) { |
| throw e; |
| } catch (Exception e) { |
| // TODO catch TracException |
| throw new CoreException(TracCorePlugin.toStatus(e, repository)); |
| } |
| } |
| |
| @Override |
| public boolean initializeSubTaskData(TaskRepository repository, TaskData taskData, TaskData parentTaskData, |
| IProgressMonitor monitor) throws CoreException { |
| initializeTaskData(repository, taskData, null, monitor); |
| TaskAttribute blockingAttribute = taskData.getRoot().getMappedAttribute(ATTRIBUTE_BLOCKING); |
| if (blockingAttribute == null) { |
| throw new CoreException(new RepositoryStatus(repository, IStatus.ERROR, TracCorePlugin.ID_PLUGIN, |
| RepositoryStatus.ERROR_REPOSITORY, "The repository does not support subtasks")); //$NON-NLS-1$ |
| } |
| |
| TaskMapper mapper = new TaskMapper(taskData); |
| mapper.merge(new TaskMapper(parentTaskData)); |
| mapper.setDescription(""); //$NON-NLS-1$ |
| mapper.setSummary(""); //$NON-NLS-1$ |
| blockingAttribute.setValue(parentTaskData.getTaskId()); |
| TaskAttribute blockedByAttribute = taskData.getRoot().getMappedAttribute(ATTRIBUTE_BLOCKED_BY); |
| if (blockedByAttribute != null) { |
| blockedByAttribute.clearValues(); |
| } |
| // special handling for stories which should have tasks as subtasks |
| TaskAttribute typeAttribute = taskData.getRoot().getAttribute(TracAttribute.TYPE.getTracKey()); |
| if (typeAttribute != null && TASK_TYPE_STORY.equals(typeAttribute.getValue())) { |
| if (typeAttribute.getOptions().containsKey(TASK_TYPE_TASK)) { |
| typeAttribute.setValue(TASK_TYPE_TASK); |
| } |
| } |
| return true; |
| } |
| |
| @Override |
| public boolean canInitializeSubTaskData(TaskRepository taskRepository, ITask task) { |
| return Boolean.parseBoolean(task.getAttribute(TracRepositoryConnector.TASK_KEY_SUPPORTS_SUBTASKS)); |
| } |
| |
| // /** |
| // * Updates attributes of <code>taskData</code> from <code>ticket</code>. |
| // */ |
| // public void updateTaskDataFromTicket(TaskData taskData, TracTicket ticket, ITracClient client) { |
| // DefaultTaskSchema schema = new DefaultTaskSchema(taskData); |
| // if (ticket.getValue(Key.SUMMARY) != null) { |
| // schema.setSummary(ticket.getValue(Key.SUMMARY)); |
| // } |
| // |
| // if (TracRepositoryConnector.isCompleted(ticket.getValue(Key.STATUS))) { |
| // schema.setCompletionDate(ticket.getLastChanged()); |
| // } else { |
| // schema.setCompletionDate(null); |
| // } |
| // |
| // String priority = ticket.getValue(Key.PRIORITY); |
| // TracPriority[] tracPriorities = client.getPriorities(); |
| // schema.setPriority(TracRepositoryConnector.getTaskPriority(priority, tracPriorities)); |
| // |
| // if (ticket.getValue(Key.TYPE) != null) { |
| // TaskKind taskKind = TracRepositoryConnector.TaskKind.fromType(ticket.getValue(Key.TYPE)); |
| // schema.setTaskKind((taskKind != null) ? taskKind.toString() : ticket.getValue(Key.TYPE)); |
| // } |
| // |
| // if (ticket.getCreated() != null) { |
| // schema.setCreationDate(ticket.getCreated()); |
| // } |
| // |
| // if (ticket.getCustomValue(TracTaskDataHandler.ATTRIBUTE_BLOCKING) != null) { |
| // taskData.addAttribute(ATTRIBUTE_BLOCKED_BY, new TaskAttribute(ATTRIBUTE_BLOCKED_BY, "Blocked by", true)); |
| // } |
| // } |
| |
| @Override |
| public TaskAttributeMapper getAttributeMapper(TaskRepository repository) { |
| ITracClient client = connector.getClientManager().getTracClient(repository); |
| return new TracAttributeMapper(repository, client); |
| } |
| |
| public boolean supportsSubtasks(TaskData taskData) { |
| return taskData.getRoot().getAttribute(ATTRIBUTE_BLOCKED_BY) != null; |
| } |
| |
| public static TracTicket getTracTicket(TaskRepository repository, TaskData data) throws InvalidTicketException, |
| CoreException { |
| TracTicket ticket = (data.isNew()) ? new TracTicket() : new TracTicket( |
| TracRepositoryConnector.getTicketId(data.getTaskId())); |
| |
| Collection<TaskAttribute> attributes = data.getRoot().getAttributes().values(); |
| for (TaskAttribute attribute : attributes) { |
| if (TracAttributeMapper.isInternalAttribute(attribute) |
| || TracAttribute.RESOLUTION.getTracKey().equals(attribute.getId())) { |
| // ignore internal attributes, resolution is set through operations |
| } else if (!attribute.getMetaData().isReadOnly() || Key.TOKEN.getKey().equals(attribute.getId())) { |
| ticket.putValue(attribute.getId(), attribute.getValue()); |
| } |
| } |
| |
| // set cc value |
| StringBuilder sb = new StringBuilder(); |
| List<String> removeValues = TracRepositoryConnector.getAttributeValues(data, TracAttributeMapper.REMOVE_CC); |
| List<String> values = TracRepositoryConnector.getAttributeValues(data, TaskAttribute.USER_CC); |
| for (String user : values) { |
| if (!removeValues.contains(user)) { |
| if (sb.length() > 0) { |
| sb.append(","); //$NON-NLS-1$ |
| } |
| sb.append(user); |
| } |
| } |
| if (TracRepositoryConnector.getAttributeValue(data, TracAttributeMapper.NEW_CC).length() > 0) { |
| if (sb.length() > 0) { |
| sb.append(","); //$NON-NLS-1$ |
| } |
| sb.append(TracRepositoryConnector.getAttributeValue(data, TracAttributeMapper.NEW_CC)); |
| } |
| if (Boolean.TRUE.equals(TracRepositoryConnector.getAttributeValue(data, TaskAttribute.ADD_SELF_CC))) { |
| if (sb.length() > 0) { |
| sb.append(","); //$NON-NLS-1$ |
| } |
| sb.append(repository.getUserName()); |
| } |
| ticket.putBuiltinValue(Key.CC, sb.toString()); |
| |
| ticket.putValue("owner", TracRepositoryConnector.getAttributeValue(data, TaskAttribute.USER_ASSIGNED)); //$NON-NLS-1$ |
| |
| TaskAttribute operationAttribute = data.getRoot().getMappedAttribute(TaskAttribute.OPERATION); |
| if (operationAttribute != null) { |
| TaskOperation operation = TaskOperation.createFrom(operationAttribute); |
| String action = operation.getOperationId(); |
| if (!"leave".equals(action)) { //$NON-NLS-1$ |
| if ("accept".equals(action)) { //$NON-NLS-1$ |
| ticket.putValue("status", TracRepositoryConnector.TaskStatus.ASSIGNED.toStatusString()); //$NON-NLS-1$ |
| } else if ("resolve".equals(action)) { //$NON-NLS-1$ |
| ticket.putValue("status", TracRepositoryConnector.TaskStatus.CLOSED.toStatusString()); //$NON-NLS-1$ |
| ticket.putValue("resolution", TracRepositoryConnector.getAttributeValue(data, //$NON-NLS-1$ |
| TaskAttribute.RESOLUTION)); |
| } else if ("reopen".equals(action)) { //$NON-NLS-1$ |
| ticket.putValue("status", TracRepositoryConnector.TaskStatus.REOPENED.toStatusString()); //$NON-NLS-1$ |
| ticket.putValue("resolution", ""); //$NON-NLS-1$ //$NON-NLS-2$ |
| } else if ("reassign".equals(action)) { //$NON-NLS-1$ |
| ticket.putValue("status", TracRepositoryConnector.TaskStatus.NEW.toStatusString()); //$NON-NLS-1$ |
| } |
| } |
| ticket.putValue("action", action); //$NON-NLS-1$ |
| } |
| |
| Date lastChanged = TracUtil.parseDate(TracRepositoryConnector.getAttributeValue(data, |
| TracAttribute.CHANGE_TIME.getTracKey())); |
| ticket.setLastChanged(lastChanged); |
| |
| return ticket; |
| } |
| |
| @Override |
| public void migrateTaskData(TaskRepository taskRepository, TaskData taskData) { |
| int version = 0; |
| if (taskData.getVersion() != null) { |
| try { |
| version = Integer.parseInt(taskData.getVersion()); |
| } catch (NumberFormatException e) { |
| // ignore |
| } |
| } |
| |
| if (version < 1) { |
| TaskAttribute root = taskData.getRoot(); |
| List<TaskAttribute> attributes = new ArrayList<TaskAttribute>(root.getAttributes().values()); |
| for (TaskAttribute attribute : attributes) { |
| if (TaskAttribute.TYPE_OPERATION.equals(attribute.getMetaData().getType()) |
| && "reassign".equals(attribute.getValue())) { //$NON-NLS-1$ |
| root.removeAttribute(attribute.getId()); |
| } else if (TaskAttribute.OPERATION.equals(attribute.getId())) { |
| attribute.getMetaData().setType(TaskAttribute.TYPE_OPERATION); |
| } else if (TracAttributeMapper.NEW_CC.equals(attribute.getId())) { |
| attribute.getMetaData().setType(TaskAttribute.TYPE_SHORT_TEXT).setReadOnly(false); |
| } else { |
| TracAttribute tracAttribute = TracAttribute.getByTracKey(attribute.getId()); |
| if (tracAttribute != null) { |
| attribute.getMetaData().setType(tracAttribute.getType()); |
| attribute.getMetaData().setKind(tracAttribute.getKind()); |
| attribute.getMetaData().setReadOnly(tracAttribute.isReadOnly()); |
| } |
| } |
| } |
| if (root.getAttribute(TracAttributeMapper.REMOVE_CC) == null) { |
| root.createAttribute(TracAttributeMapper.REMOVE_CC); |
| } |
| if (root.getAttribute(TaskAttribute.COMMENT_NEW) == null) { |
| root.createAttribute(TaskAttribute.COMMENT_NEW) |
| .getMetaData() |
| .setType(TaskAttribute.TYPE_LONG_RICH_TEXT) |
| .setReadOnly(false); |
| } |
| } |
| if (version < 2) { |
| List<TaskAttribute> attributes = new ArrayList<TaskAttribute>(taskData.getRoot().getAttributes().values()); |
| for (TaskAttribute attribute : attributes) { |
| if (!TracAttributeMapper.isInternalAttribute(attribute)) { |
| TaskAttributeMetaData metaData = attribute.getMetaData(); |
| metaData.putValue(TRAC_KEY, attribute.getId()); |
| if (metaData.getType() == null) { |
| metaData.setType(TaskAttribute.TYPE_SHORT_TEXT); |
| } |
| } |
| } |
| taskData.setVersion(TASK_DATA_VERSION); |
| } |
| } |
| |
| } |
