| /******************************************************************************* |
| * Copyright (c) 2004, 2013 Tasktop Technologies 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: |
| * Tasktop Technologies - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.mylyn.internal.bugzilla.core; |
| |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.List; |
| 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.Status; |
| import org.eclipse.core.runtime.SubProgressMonitor; |
| 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.bugzilla.core.BugzillaCustomField.FieldType; |
| import org.eclipse.mylyn.internal.bugzilla.core.IBugzillaConstants.BUGZILLA_REPORT_STATUS_4_0; |
| 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.RepositoryStatus; |
| import org.eclipse.mylyn.tasks.core.TaskRepository; |
| import org.eclipse.mylyn.tasks.core.data.AbstractTaskDataHandler; |
| import org.eclipse.mylyn.tasks.core.data.TaskAttribute; |
| import org.eclipse.mylyn.tasks.core.data.TaskAttributeMapper; |
| import org.eclipse.mylyn.tasks.core.data.TaskData; |
| import org.eclipse.mylyn.tasks.core.data.TaskDataCollector; |
| import org.eclipse.mylyn.tasks.core.data.TaskMapper; |
| |
| /** |
| * @author Mik Kersten |
| * @author Rob Elves |
| */ |
| public class BugzillaTaskDataHandler extends AbstractTaskDataHandler { |
| |
| private enum TaskDataVersion { |
| |
| VERSION_0(0f) { |
| @Override |
| void migrate(TaskRepository repository, TaskData data, BugzillaRepositoryConnector connector) { |
| // ignore |
| } |
| }, |
| |
| VERSION_1_0(1.0f) { |
| @Override |
| void migrate(TaskRepository repository, TaskData data, BugzillaRepositoryConnector connector) { |
| // 1: the value was stored in the attribute rather than the key |
| for (TaskAttribute attribute : new ArrayList<TaskAttribute>(data.getRoot().getAttributes().values())) { |
| if (attribute.getId().equals(BugzillaAttribute.DESC.getKey())) { |
| TaskAttribute attrLongDesc = createAttribute(data, BugzillaAttribute.LONG_DESC); |
| attrLongDesc.setValue(attribute.getValue()); |
| data.getRoot().removeAttribute(BugzillaAttribute.DESC.getKey()); |
| } |
| } |
| // Old actions not saved so recreate them upon migration |
| // delete legacy operations: |
| Set<TaskAttribute> operationsToRemove = new HashSet<TaskAttribute>(); |
| for (TaskAttribute attribute : data.getAttributeMapper().getAttributesByType(data, |
| TaskAttribute.TYPE_OPERATION)) { |
| operationsToRemove.add(attribute); |
| } |
| for (TaskAttribute taskAttribute : operationsToRemove) { |
| data.getRoot().removeAttribute(taskAttribute.getId()); |
| } |
| RepositoryConfiguration configuration = connector.getRepositoryConfiguration(repository.getRepositoryUrl()); |
| if (configuration != null) { |
| configuration.addValidOperations(data); |
| } |
| } |
| }, |
| VERSION_2_0(2.0f) { |
| @Override |
| void migrate(TaskRepository repository, TaskData data, BugzillaRepositoryConnector connector) { |
| updateAttribute(data, BugzillaAttribute.LONG_DESC); |
| } |
| }, |
| VERSION_3_0(3.0f) { |
| @Override |
| void migrate(TaskRepository repository, TaskData data, BugzillaRepositoryConnector connector) { |
| updateAttribute(data, BugzillaAttribute.NEW_COMMENT); |
| } |
| }, |
| VERSION_4_0(4.0f) { |
| @Override |
| void migrate(TaskRepository repository, TaskData data, BugzillaRepositoryConnector connector) { |
| updateAttribute(data, BugzillaAttribute.DEADLINE); |
| updateAttribute(data, BugzillaAttribute.ACTUAL_TIME); |
| } |
| }, |
| VERSION_4_1(4.1f) { |
| @Override |
| void migrate(TaskRepository repository, TaskData data, BugzillaRepositoryConnector connector) { |
| updateAttribute(data, BugzillaAttribute.VOTES); |
| TaskAttribute attrDeadline = data.getRoot().getMappedAttribute(BugzillaAttribute.VOTES.getKey()); |
| if (attrDeadline != null) { |
| attrDeadline.getMetaData().setType(BugzillaAttribute.VOTES.getType()); |
| } |
| } |
| }, |
| VERSION_4_2(4.2f) { |
| @Override |
| void migrate(TaskRepository repository, TaskData data, BugzillaRepositoryConnector connector) { |
| updateAttribute(data, BugzillaAttribute.CC); |
| updateAttribute(data, BugzillaAttribute.DEPENDSON); |
| updateAttribute(data, BugzillaAttribute.BLOCKED); |
| updateAttribute(data, BugzillaAttribute.BUG_FILE_LOC); |
| updateAttribute(data, BugzillaAttribute.KEYWORDS); |
| updateAttribute(data, BugzillaAttribute.STATUS_WHITEBOARD); |
| updateAttribute(data, BugzillaAttribute.QA_CONTACT); |
| updateAttribute(data, BugzillaAttribute.NEWCC); |
| } |
| }, |
| VERSION_4_3(4.3f) { |
| @Override |
| void migrate(TaskRepository repository, TaskData data, BugzillaRepositoryConnector connector) { |
| // migrate custom attributes |
| for (TaskAttribute attribute : data.getRoot().getAttributes().values()) { |
| if (attribute.getId().startsWith(BugzillaCustomField.CUSTOM_FIELD_PREFIX)) { |
| attribute.getMetaData().setKind(TaskAttribute.KIND_DEFAULT); |
| attribute.getMetaData().setReadOnly(false); |
| if (attribute.getOptions().size() > 0) { |
| attribute.getMetaData().setType(TaskAttribute.TYPE_SINGLE_SELECT); |
| } else { |
| attribute.getMetaData().setType(TaskAttribute.TYPE_SHORT_TEXT); |
| } |
| } |
| } |
| } |
| }, |
| VERSION_4_4(4.4f) { |
| @Override |
| void migrate(TaskRepository repository, TaskData data, BugzillaRepositoryConnector connector) { |
| // summary didn't have spell checking, update to short rich text |
| updateAttribute(data, BugzillaAttribute.SHORT_DESC); |
| } |
| }, |
| VERSION_4_5(4.5f) { |
| @Override |
| void migrate(TaskRepository repository, TaskData data, BugzillaRepositoryConnector connector) { |
| // migrate custom attributes |
| RepositoryConfiguration configuration = connector.getRepositoryConfiguration(repository.getRepositoryUrl()); |
| |
| if (configuration == null) { |
| return; |
| } |
| |
| for (TaskAttribute attribute : data.getRoot().getAttributes().values()) { |
| if (attribute.getId().startsWith(BugzillaCustomField.CUSTOM_FIELD_PREFIX)) { |
| |
| BugzillaCustomField customField = null; |
| String actName = attribute.getId(); |
| for (BugzillaCustomField bugzillaCustomField : configuration.getCustomFields()) { |
| if (actName.equals(bugzillaCustomField.getName())) { |
| customField = bugzillaCustomField; |
| break; |
| } |
| } |
| if (customField != null) { |
| String desc = customField.getDescription(); |
| attribute.getMetaData().defaults().setLabel(desc).setReadOnly(false); |
| attribute.getMetaData().setKind(TaskAttribute.KIND_DEFAULT); |
| attribute.getMetaData().setType(TaskAttribute.TYPE_SHORT_TEXT); |
| switch (customField.getFieldType()) { |
| case FreeText: |
| attribute.getMetaData().setType(TaskAttribute.TYPE_SHORT_TEXT); |
| break; |
| case DropDown: |
| attribute.getMetaData().setType(TaskAttribute.TYPE_SINGLE_SELECT); |
| break; |
| case MultipleSelection: |
| attribute.getMetaData().setType(TaskAttribute.TYPE_MULTI_SELECT); |
| break; |
| case LargeText: |
| attribute.getMetaData().setType(TaskAttribute.TYPE_LONG_TEXT); |
| break; |
| case DateTime: |
| attribute.getMetaData().setType(TaskAttribute.TYPE_DATETIME); |
| break; |
| |
| default: |
| List<String> options = customField.getOptions(); |
| if (options.size() > 0) { |
| attribute.getMetaData().setType(TaskAttribute.TYPE_SINGLE_SELECT); |
| } else { |
| attribute.getMetaData().setType(TaskAttribute.TYPE_SHORT_TEXT); |
| } |
| } |
| attribute.getMetaData().setReadOnly(false); |
| } |
| } |
| } |
| } |
| }, |
| VERSION_4_6(4.6f) { |
| @Override |
| void migrate(TaskRepository repository, TaskData data, BugzillaRepositoryConnector connector) { |
| // set kind for flags |
| String bugzillaVersionString = repository.getVersion(); |
| BugzillaVersion bugzillaVersion = new BugzillaVersion(bugzillaVersionString); |
| |
| if (bugzillaVersion.compareTo(BugzillaVersion.BUGZILLA_3_2) >= 0) { |
| for (TaskAttribute attribute : data.getRoot().getAttributes().values()) { |
| if (attribute.getId().startsWith(BugzillaAttribute.KIND_FLAG)) { |
| attribute.getMetaData().setKind(BugzillaAttribute.KIND_FLAG); |
| } |
| } |
| } |
| } |
| }, |
| VERSION_4_7(4.7f) { |
| @Override |
| void migrate(TaskRepository repository, TaskData data, BugzillaRepositoryConnector connector) { |
| TaskAttribute exporter = data.getRoot().getAttribute(BugzillaAttribute.EXPORTER_NAME.getKey()); |
| if (exporter == null) { |
| String exporterName = repository.getUserName(); |
| if (exporterName != null && !exporterName.equals("")) { //$NON-NLS-1$ |
| exporter = data.getRoot().createAttribute(BugzillaAttribute.EXPORTER_NAME.getKey()); |
| exporter.setValue(exporterName); |
| } |
| } |
| } |
| }, |
| VERSION_CURRENT(4.8f) { |
| @Override |
| void migrate(TaskRepository repository, TaskData data, BugzillaRepositoryConnector connector) { |
| data.setVersion(TaskDataVersion.VERSION_CURRENT.toString()); |
| } |
| }; |
| |
| private float versionNumber = 0; |
| |
| TaskDataVersion(float verNum) { |
| versionNumber = verNum; |
| } |
| |
| public float getVersionNum() { |
| return versionNumber; |
| } |
| |
| abstract void migrate(TaskRepository repository, TaskData data, BugzillaRepositoryConnector connector); |
| |
| @Override |
| public String toString() { |
| return "" + getVersionNum(); //$NON-NLS-1$ |
| } |
| |
| private static void updateAttribute(TaskData data, BugzillaAttribute bugAttribute) { |
| TaskAttribute attribute = data.getRoot().getMappedAttribute(bugAttribute.getKey()); |
| if (attribute != null) { |
| attribute.getMetaData().setType(bugAttribute.getType()); |
| attribute.getMetaData().setReadOnly(bugAttribute.isReadOnly()); |
| attribute.getMetaData().setKind(bugAttribute.getKind()); |
| } |
| } |
| } |
| |
| protected final BugzillaRepositoryConnector connector; |
| |
| public BugzillaTaskDataHandler(BugzillaRepositoryConnector connector) { |
| this.connector = connector; |
| } |
| |
| public TaskData getTaskData(TaskRepository repository, String taskId, IProgressMonitor monitor) |
| throws CoreException { |
| |
| Set<String> taskIds = new HashSet<String>(); |
| taskIds.add(taskId); |
| final TaskData[] retrievedData = new TaskData[1]; |
| TaskDataCollector collector = new TaskDataCollector() { |
| |
| @Override |
| public void accept(TaskData taskData) { |
| retrievedData[0] = taskData; |
| } |
| }; |
| getMultiTaskData(repository, taskIds, collector, monitor); |
| |
| if (retrievedData[0] == null) { |
| throw new CoreException(new Status(IStatus.ERROR, BugzillaCorePlugin.ID_PLUGIN, |
| "Task data could not be retrieved. Please re-synchronize task")); //$NON-NLS-1$ |
| } |
| return retrievedData[0]; |
| |
| // monitor = Policy.monitorFor(monitor); |
| // try { |
| // monitor.beginTask("Receiving task", IProgressMonitor.UNKNOWN); |
| // BugzillaClient client = connector.getClientManager().getClient(repository, monitor); |
| // int bugId = BugzillaRepositoryConnector.getBugId(taskId); |
| // TaskData taskData = client.getTaskData(bugId, getAttributeMapper(repository), monitor); |
| // if (taskData == null) { |
| // throw new CoreException(new Status(IStatus.ERROR, BugzillaCorePlugin.ID_PLUGIN, |
| // "Task data could not be retrieved. Please re-synchronize task")); |
| // } |
| // return taskData; |
| // } catch (IOException e) { |
| // throw new CoreException(new BugzillaStatus(IStatus.ERROR, BugzillaCorePlugin.ID_PLUGIN, |
| // RepositoryStatus.ERROR_IO, repository.getRepositoryUrl(), e)); |
| // } finally { |
| // monitor.done(); |
| // } |
| } |
| |
| @Override |
| public void getMultiTaskData(final TaskRepository repository, Set<String> taskIds, |
| final TaskDataCollector collector, IProgressMonitor monitor) throws CoreException { |
| |
| monitor = Policy.monitorFor(monitor); |
| |
| try { |
| monitor.beginTask(Messages.BugzillaTaskDataHandler_Receiving_tasks, taskIds.size()); |
| final BugzillaClient client = connector.getClientManager().getClient(repository, monitor); |
| final CoreException[] collectionException = new CoreException[1]; |
| final Boolean[] updateConfig = new Boolean[1]; |
| |
| class CollectorWrapper extends TaskDataCollector { |
| |
| private final IProgressMonitor monitor2; |
| |
| private final TaskDataCollector collector; |
| |
| @Override |
| public void failed(String taskId, IStatus status) { |
| collector.failed(taskId, status); |
| } |
| |
| public CollectorWrapper(TaskDataCollector collector, IProgressMonitor monitor2) { |
| this.collector = collector; |
| this.monitor2 = monitor2; |
| } |
| |
| @Override |
| public void accept(TaskData taskData) { |
| try { |
| initializeTaskData(repository, taskData, null, new SubProgressMonitor(monitor2, 1)); |
| } catch (CoreException e) { |
| // this info CoreException is only used internal |
| if (e.getStatus().getCode() == IStatus.INFO && e.getMessage().contains("Update Config")) { //$NON-NLS-1$ |
| if (updateConfig[0] == null) { |
| updateConfig[0] = new Boolean(true); |
| } |
| } else if (collectionException[0] == null) { |
| collectionException[0] = e; |
| } |
| } |
| collector.accept(taskData); |
| monitor2.worked(1); |
| } |
| } |
| |
| TaskDataCollector collector2 = new CollectorWrapper(collector, monitor); |
| |
| client.getTaskData(taskIds, collector2, getAttributeMapper(repository), monitor); |
| |
| if (collectionException[0] != null) { |
| throw collectionException[0]; |
| } |
| if (updateConfig[0] != null) { |
| SubProgressMonitor subMonitor = new SubProgressMonitor(monitor, 1); |
| client.getRepositoryConfiguration(subMonitor, null); |
| subMonitor.done(); |
| } |
| } catch (IOException e) { |
| throw new CoreException(new BugzillaStatus(IStatus.ERROR, BugzillaCorePlugin.ID_PLUGIN, |
| RepositoryStatus.ERROR_IO, repository.getRepositoryUrl(), e)); |
| } finally { |
| monitor.done(); |
| } |
| } |
| |
| @Override |
| public void migrateTaskData(TaskRepository taskRepository, TaskData taskData) { |
| |
| float bugzillaTaskDataVersion = 0; |
| { |
| String taskDataVersion = taskData.getVersion(); |
| if (taskDataVersion != null) { |
| try { |
| bugzillaTaskDataVersion = Float.parseFloat(taskDataVersion); |
| } catch (NumberFormatException e) { |
| bugzillaTaskDataVersion = 0; |
| } |
| } |
| } |
| |
| for (TaskDataVersion version : TaskDataVersion.values()) { |
| if (bugzillaTaskDataVersion <= version.getVersionNum()) { |
| version.migrate(taskRepository, taskData, connector); |
| } |
| } |
| } |
| |
| @Override |
| public RepositoryResponse postTaskData(TaskRepository repository, TaskData taskData, |
| Set<TaskAttribute> changedAttributes, IProgressMonitor monitor) throws CoreException { |
| monitor = Policy.monitorFor(monitor); |
| try { |
| monitor.beginTask(Messages.BugzillaTaskDataHandler_Submitting_task, IProgressMonitor.UNKNOWN); |
| BugzillaClient client = connector.getClientManager().getClient(repository, monitor); |
| try { |
| return client.postTaskData(taskData, monitor); |
| } catch (CoreException e) { |
| throw e; |
| } |
| } catch (IOException e) { |
| throw new CoreException(new BugzillaStatus(IStatus.ERROR, BugzillaCorePlugin.ID_PLUGIN, |
| RepositoryStatus.ERROR_IO, repository.getRepositoryUrl(), e)); |
| } finally { |
| monitor.done(); |
| } |
| } |
| |
| @Override |
| public boolean initializeTaskData(TaskRepository repository, TaskData taskData, ITaskMapping initializationData, |
| IProgressMonitor monitor) throws CoreException { |
| |
| // Note: setting current version to latest assumes the data arriving here is either for a new task or is |
| // fresh from the repository (not locally stored data that may not have been migrated). |
| taskData.setVersion(TaskDataVersion.VERSION_CURRENT.toString()); |
| try { |
| monitor = Policy.monitorFor(monitor); |
| |
| monitor.beginTask("Initialize Task Data", IProgressMonitor.UNKNOWN); //$NON-NLS-1$ |
| |
| RepositoryConfiguration repositoryConfiguration = connector.getRepositoryConfiguration(repository, false, |
| monitor); |
| |
| if (repositoryConfiguration == null) { |
| throw new CoreException(new BugzillaStatus(IStatus.ERROR, BugzillaCorePlugin.ID_PLUGIN, |
| RepositoryStatus.ERROR_REPOSITORY_LOGIN, repository.getRepositoryUrl(), |
| "Retrieving repository configuration failed.")); //$NON-NLS-1$ |
| } |
| |
| if (taskData.isNew()) { |
| String product = null; |
| String component = null; |
| if (initializationData == null || initializationData.getProduct() == null) { |
| if (repositoryConfiguration.getOptionValues(BugzillaAttribute.PRODUCT).size() > 0) { |
| product = repositoryConfiguration.getOptionValues(BugzillaAttribute.PRODUCT).get(0); |
| } |
| } else { |
| product = initializationData.getProduct(); |
| } |
| |
| if (product == null) { |
| return false; |
| } |
| |
| if (initializationData != null && initializationData.getComponent() != null |
| && initializationData.getComponent().length() > 0) { |
| component = initializationData.getComponent(); |
| } |
| |
| initializeNewTaskDataAttributes(repositoryConfiguration, taskData, product, component, monitor); |
| if (connector != null) { |
| connector.setPlatformDefaultsOrGuess(repository, taskData); |
| } |
| return true; |
| |
| } else { |
| boolean shortLogin = Boolean.parseBoolean(repository.getProperty(IBugzillaConstants.REPOSITORY_SETTING_SHORT_LOGIN)); |
| repositoryConfiguration.configureTaskData(taskData, shortLogin, connector); |
| } |
| // boolean updateConfig = false; |
| for (TaskAttribute taskAttribute : taskData.getRoot().getAttributes().values()) { |
| Map<String, String> opt = taskAttribute.getOptions(); |
| if (opt != null && !opt.isEmpty()) { |
| List<String> values = taskAttribute.getValues(); |
| for (String value : values) { |
| if (!opt.containsKey(value)) { |
| taskAttribute.putOption(value, value); |
| // updateConfig = true; |
| } |
| } |
| } |
| } |
| //TODO: enable this if we want to do the Configuration update |
| // if (updateConfig) { |
| // // this info CoreException is only used internal |
| // throw new CoreException(new BugzillaStatus(IStatus.INFO, BugzillaCorePlugin.ID_PLUGIN, IStatus.INFO, |
| // repository.getRepositoryUrl(), "Update Config")); //$NON-NLS-1$ |
| // } |
| |
| } finally { |
| monitor.done(); |
| } |
| return true; |
| } |
| |
| /** |
| * Only new, unsubmitted task data or freshly received task data from the repository can be passed in here. |
| * |
| * @param component |
| */ |
| private boolean initializeNewTaskDataAttributes(RepositoryConfiguration repositoryConfiguration, TaskData taskData, |
| String product, String component, IProgressMonitor monitor) { |
| |
| TaskAttribute productAttribute = createAttribute(taskData, BugzillaAttribute.PRODUCT); |
| productAttribute.setValue(product); |
| |
| List<String> optionValues = repositoryConfiguration.getOptionValues(BugzillaAttribute.PRODUCT); |
| Collections.sort(optionValues); |
| for (String optionValue : optionValues) { |
| productAttribute.putOption(optionValue, optionValue); |
| } |
| |
| TaskAttribute attributeStatus = createAttribute(taskData, BugzillaAttribute.BUG_STATUS); |
| optionValues = repositoryConfiguration.getOptionValues(BugzillaAttribute.BUG_STATUS); |
| for (String option : optionValues) { |
| attributeStatus.putOption(option, option); |
| } |
| |
| BugzillaVersion bugzillaVersion = repositoryConfiguration.getInstallVersion(); |
| if (bugzillaVersion == null) { |
| bugzillaVersion = BugzillaVersion.MIN_VERSION; |
| } |
| if (bugzillaVersion.compareMajorMinorOnly(BugzillaVersion.BUGZILLA_4_0) < 0) { |
| attributeStatus.setValue(repositoryConfiguration.getStartStatus()); |
| } else { |
| if (repositoryConfiguration.getOptionValues(BugzillaAttribute.BUG_STATUS).contains( |
| BUGZILLA_REPORT_STATUS_4_0.IN_PROGRESS.toString()) |
| || repositoryConfiguration.getOptionValues(BugzillaAttribute.BUG_STATUS).contains( |
| BUGZILLA_REPORT_STATUS_4_0.CONFIRMED.toString())) { |
| |
| attributeStatus.setValue(IBugzillaConstants.BUGZILLA_REPORT_STATUS_4_0.START.toString()); |
| repositoryConfiguration.addValidOperations(taskData); |
| } else { |
| attributeStatus.setValue(repositoryConfiguration.getStartStatus()); |
| } |
| } |
| |
| createAttribute(taskData, BugzillaAttribute.SHORT_DESC); |
| |
| TaskAttribute attributeVersion = createAttribute(taskData, BugzillaAttribute.VERSION); |
| optionValues = repositoryConfiguration.getProductOptionValues(BugzillaAttribute.VERSION, |
| productAttribute.getValue()); |
| Collections.sort(optionValues); |
| for (String option : optionValues) { |
| attributeVersion.putOption(option, option); |
| } |
| if (optionValues.size() > 0) { |
| attributeVersion.setValue(optionValues.get(optionValues.size() - 1)); |
| } |
| |
| TaskAttribute attributeComponent = createAttribute(taskData, BugzillaAttribute.COMPONENT); |
| optionValues = repositoryConfiguration.getProductOptionValues(BugzillaAttribute.COMPONENT, |
| productAttribute.getValue()); |
| Collections.sort(optionValues); |
| for (String option : optionValues) { |
| attributeComponent.putOption(option, option); |
| } |
| if (optionValues.size() == 1) { |
| attributeComponent.setValue(optionValues.get(0)); |
| } |
| if (component != null && optionValues.contains(component)) { |
| attributeComponent.setValue(component); |
| } |
| |
| TaskRepository taskRepository = taskData.getAttributeMapper().getTaskRepository(); |
| if (BugzillaUtil.getTaskPropertyWithDefaultTrue(taskRepository, |
| IBugzillaConstants.BUGZILLA_PARAM_USETARGETMILESTONE)) { |
| optionValues = repositoryConfiguration.getProductOptionValues(BugzillaAttribute.TARGET_MILESTONE, |
| productAttribute.getValue()); |
| if (optionValues.size() > 0) { |
| TaskAttribute attributeTargetMilestone = createAttribute(taskData, BugzillaAttribute.TARGET_MILESTONE); |
| for (String option : optionValues) { |
| attributeTargetMilestone.putOption(option, option); |
| } |
| if (product != null && !product.equals("")) { //$NON-NLS-1$ |
| String defaultMilestone = repositoryConfiguration.getDefaultMilestones(product); |
| if (defaultMilestone != null) { |
| attributeTargetMilestone.setValue(defaultMilestone); |
| } else { |
| if (optionValues.contains("---")) { //$NON-NLS-1$ |
| attributeTargetMilestone.setValue("---"); //$NON-NLS-1$ |
| } |
| } |
| } else { |
| if (optionValues.contains("---")) { //$NON-NLS-1$ |
| attributeTargetMilestone.setValue("---"); //$NON-NLS-1$ |
| } |
| } |
| } |
| } |
| TaskAttribute attributePlatform = createAttribute(taskData, BugzillaAttribute.REP_PLATFORM); |
| optionValues = repositoryConfiguration.getOptionValues(BugzillaAttribute.REP_PLATFORM); |
| for (String option : optionValues) { |
| attributePlatform.putOption(option, option); |
| } |
| if (optionValues.size() > 0) { |
| // bug 159397 choose first platform: All |
| attributePlatform.setValue(optionValues.get(0)); |
| } |
| |
| TaskAttribute attributeOPSYS = createAttribute(taskData, BugzillaAttribute.OP_SYS); |
| optionValues = repositoryConfiguration.getOptionValues(BugzillaAttribute.OP_SYS); |
| for (String option : optionValues) { |
| attributeOPSYS.putOption(option, option); |
| } |
| if (optionValues.size() > 0) { |
| // bug 159397 change to choose first op_sys All |
| attributeOPSYS.setValue(optionValues.get(0)); |
| } |
| |
| TaskAttribute attributePriority = createAttribute(taskData, BugzillaAttribute.PRIORITY); |
| optionValues = repositoryConfiguration.getOptionValues(BugzillaAttribute.PRIORITY); |
| for (String option : optionValues) { |
| attributePriority.putOption(option, option); |
| } |
| if (optionValues.size() > 0) { |
| // choose middle priority |
| attributePriority.setValue(optionValues.get((optionValues.size() / 2))); |
| } |
| |
| TaskAttribute attributeSeverity = createAttribute(taskData, BugzillaAttribute.BUG_SEVERITY); |
| optionValues = repositoryConfiguration.getOptionValues(BugzillaAttribute.BUG_SEVERITY); |
| for (String option : optionValues) { |
| attributeSeverity.putOption(option, option); |
| } |
| if (optionValues.size() > 0) { |
| // choose middle severity |
| attributeSeverity.setValue(optionValues.get((optionValues.size() / 2))); |
| } |
| |
| TaskAttribute attributeAssignedTo = createAttribute(taskData, BugzillaAttribute.ASSIGNED_TO); |
| attributeAssignedTo.setValue(""); //$NON-NLS-1$ |
| |
| if (BugzillaUtil.getTaskPropertyWithDefaultTrue(taskRepository, IBugzillaConstants.BUGZILLA_PARAM_USEQACONTACT)) { |
| TaskAttribute attributeQAContact = createAttribute(taskData, BugzillaAttribute.QA_CONTACT); |
| attributeQAContact.setValue(""); //$NON-NLS-1$ |
| } |
| TaskAttribute attributeBugFileLoc = createAttribute(taskData, BugzillaAttribute.BUG_FILE_LOC); |
| attributeBugFileLoc.setValue("http://"); //$NON-NLS-1$ |
| |
| createAttribute(taskData, BugzillaAttribute.DEPENDSON); |
| createAttribute(taskData, BugzillaAttribute.BLOCKED); |
| createAttribute(taskData, BugzillaAttribute.NEWCC); |
| createAttribute(taskData, BugzillaAttribute.LONG_DESC); |
| |
| List<String> keywords = repositoryConfiguration.getOptionValues(BugzillaAttribute.KEYWORDS); |
| if (keywords.size() > 0) { |
| createAttribute(taskData, BugzillaAttribute.KEYWORDS); |
| } |
| |
| TaskAttribute attrDescription = taskData.getRoot().getMappedAttribute(TaskAttribute.DESCRIPTION); |
| if (attrDescription != null) { |
| attrDescription.getMetaData().setReadOnly(false); |
| } |
| TaskAttribute attrOwner = taskData.getRoot().getMappedAttribute(TaskAttribute.USER_ASSIGNED); |
| if (attrOwner != null) { |
| attrOwner.getMetaData().setReadOnly(false); |
| } |
| TaskAttribute attrAddSelfToCc = taskData.getRoot().getMappedAttribute(TaskAttribute.ADD_SELF_CC); |
| if (attrAddSelfToCc != null) { |
| attrAddSelfToCc.getMetaData().setKind(null); |
| } |
| |
| List<BugzillaCustomField> customFields = new ArrayList<BugzillaCustomField>(); |
| if (repositoryConfiguration != null) { |
| customFields = repositoryConfiguration.getCustomFields(); |
| } |
| for (BugzillaCustomField bugzillaCustomField : customFields) { |
| if (bugzillaCustomField.isEnterBug()) { |
| List<String> options = bugzillaCustomField.getOptions(); |
| FieldType fieldType = bugzillaCustomField.getFieldType(); |
| if (options.size() < 1 |
| && (fieldType.equals(FieldType.DropDown) || fieldType.equals(FieldType.MultipleSelection))) { |
| continue; |
| } |
| TaskAttribute attribute = taskData.getRoot().createAttribute(bugzillaCustomField.getName()); |
| if (attribute != null) { |
| attribute.getMetaData().defaults().setLabel(bugzillaCustomField.getDescription()); |
| attribute.getMetaData().setKind(TaskAttribute.KIND_DEFAULT); |
| |
| switch (bugzillaCustomField.getFieldType()) { |
| case FreeText: |
| attribute.getMetaData().setType(TaskAttribute.TYPE_SHORT_TEXT); |
| break; |
| case DropDown: |
| attribute.getMetaData().setType(TaskAttribute.TYPE_SINGLE_SELECT); |
| break; |
| case MultipleSelection: |
| attribute.getMetaData().setType(TaskAttribute.TYPE_MULTI_SELECT); |
| break; |
| case LargeText: |
| attribute.getMetaData().setType(TaskAttribute.TYPE_LONG_TEXT); |
| break; |
| case DateTime: |
| attribute.getMetaData().setType(TaskAttribute.TYPE_DATETIME); |
| break; |
| |
| default: |
| if (options.size() > 0) { |
| attribute.getMetaData().setType(TaskAttribute.TYPE_SINGLE_SELECT); |
| } else { |
| attribute.getMetaData().setType(TaskAttribute.TYPE_SHORT_TEXT); |
| } |
| } |
| attribute.getMetaData().setReadOnly(false); |
| |
| for (String option : options) { |
| attribute.putOption(option, option); |
| } |
| |
| if (bugzillaCustomField.getFieldType() == BugzillaCustomField.FieldType.DropDown |
| && options.size() > 0) { |
| attribute.setValue(options.get(0)); |
| } |
| |
| } |
| } |
| } |
| return true; |
| } |
| |
| @Override |
| public boolean canGetMultiTaskData(TaskRepository taskRepository) { |
| return true; |
| } |
| |
| @Override |
| public boolean canInitializeSubTaskData(TaskRepository taskRepository, ITask task) { |
| return true; |
| } |
| |
| @Override |
| public boolean initializeSubTaskData(TaskRepository repository, TaskData subTaskData, TaskData parentTaskData, |
| IProgressMonitor monitor) throws CoreException { |
| TaskMapper mapper = new TaskMapper(parentTaskData); |
| if (initializeTaskData(repository, subTaskData, mapper, monitor)) { |
| new TaskMapper(subTaskData).merge(mapper); |
| subTaskData.getRoot().getMappedAttribute(BugzillaAttribute.DEPENDSON.getKey()).setValue(""); //$NON-NLS-1$ |
| subTaskData.getRoot().getMappedAttribute(TaskAttribute.DESCRIPTION).setValue(""); //$NON-NLS-1$ |
| subTaskData.getRoot().getMappedAttribute(TaskAttribute.SUMMARY).setValue(""); //$NON-NLS-1$ |
| TaskAttribute keywords = subTaskData.getRoot().getMappedAttribute(TaskAttribute.KEYWORDS); |
| if (keywords != null) { |
| // only if the repository has keywords this attribut exists |
| keywords.setValue(""); //$NON-NLS-1$ |
| } |
| subTaskData.getRoot().getAttribute(BugzillaAttribute.BLOCKED.getKey()).setValue(parentTaskData.getTaskId()); |
| TaskAttribute parentAttributeAssigned = parentTaskData.getRoot().getMappedAttribute( |
| TaskAttribute.USER_ASSIGNED); |
| subTaskData.getRoot() |
| .getAttribute(BugzillaAttribute.ASSIGNED_TO.getKey()) |
| .setValue(parentAttributeAssigned.getValue()); |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| @Override |
| public TaskAttributeMapper getAttributeMapper(TaskRepository taskRepository) { |
| return new BugzillaAttributeMapper(taskRepository, connector); |
| } |
| |
| public static TaskAttribute createAttribute(TaskData data, BugzillaAttribute key) { |
| return createAttribute(data.getRoot(), key); |
| } |
| |
| public static TaskAttribute createAttribute(TaskAttribute parent, BugzillaAttribute key) { |
| TaskAttribute attribute = parent.createAttribute(key.getKey()); |
| attribute.getMetaData() |
| .defaults() |
| .setReadOnly(key.isReadOnly()) |
| .setKind(key.getKind()) |
| .setLabel(key.toString()) |
| .setType(key.getType()); |
| |
| if (key == BugzillaAttribute.STATUS_WHITEBOARD) { |
| attribute.getMetaData().putValue(TaskAttribute.META_INDEXED_AS_CONTENT, Boolean.TRUE.toString()); |
| } |
| |
| return attribute; |
| } |
| |
| public void postUpdateAttachment(TaskRepository repository, TaskAttribute taskAttribute, String action, |
| IProgressMonitor monitor) throws CoreException { |
| monitor = Policy.monitorFor(monitor); |
| try { |
| monitor.beginTask(Messages.BugzillaTaskDataHandler_updating_attachment, IProgressMonitor.UNKNOWN); |
| BugzillaClient client = connector.getClientManager().getClient(repository, monitor); |
| try { |
| client.postUpdateAttachment(taskAttribute, action, monitor); |
| } catch (CoreException e) { |
| // TODO: Move retry handling into client |
| if (e.getStatus().getCode() == RepositoryStatus.ERROR_REPOSITORY_LOGIN) { |
| AuthenticationCredentials creds = repository.getCredentials(AuthenticationType.REPOSITORY); |
| if (creds != null && creds.getUserName() != null && creds.getUserName().length() > 0) { |
| client.postUpdateAttachment(taskAttribute, action, monitor); |
| } else { |
| throw e; |
| } |
| } else { |
| throw e; |
| } |
| } |
| } catch (IOException e) { |
| throw new CoreException(new BugzillaStatus(IStatus.ERROR, BugzillaCorePlugin.ID_PLUGIN, |
| RepositoryStatus.ERROR_IO, repository.getRepositoryUrl(), e)); |
| } finally { |
| monitor.done(); |
| } |
| } |
| |
| } |
