| /******************************************************************************* |
| * Copyright (c) 2013 Frank Becker 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: |
| * Frank Becker - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.mylyn.internal.bugzilla.rest.core; |
| |
| import java.io.Serializable; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.SortedSet; |
| import java.util.TreeSet; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jdt.annotation.NonNull; |
| import org.eclipse.mylyn.commons.core.StatusHandler; |
| import org.eclipse.mylyn.internal.bugzilla.rest.core.response.data.Component; |
| import org.eclipse.mylyn.internal.bugzilla.rest.core.response.data.Field; |
| import org.eclipse.mylyn.internal.bugzilla.rest.core.response.data.FieldValues; |
| import org.eclipse.mylyn.internal.bugzilla.rest.core.response.data.FlagType; |
| import org.eclipse.mylyn.internal.bugzilla.rest.core.response.data.FlagTypes; |
| import org.eclipse.mylyn.internal.bugzilla.rest.core.response.data.Parameters; |
| import org.eclipse.mylyn.internal.bugzilla.rest.core.response.data.Product; |
| import org.eclipse.mylyn.internal.bugzilla.rest.core.response.data.SortableActiveEntry; |
| import org.eclipse.mylyn.internal.bugzilla.rest.core.response.data.StatusTransition; |
| import org.eclipse.mylyn.tasks.core.data.TaskAttribute; |
| import org.eclipse.mylyn.tasks.core.data.TaskData; |
| import org.eclipse.mylyn.tasks.core.data.TaskOperation; |
| |
| import com.google.common.base.Function; |
| import com.google.common.base.Functions; |
| import com.google.common.collect.ImmutableSortedMap; |
| import com.google.common.collect.Ordering; |
| |
| public class BugzillaRestConfiguration implements Serializable { |
| |
| private static final BugzillaRestCreateTaskSchema SCHEMA = BugzillaRestCreateTaskSchema.getDefault(); |
| |
| private static final long serialVersionUID = 4173223872076958202L; |
| |
| private final String repositoryId; |
| |
| private Map<String, Field> fields; |
| |
| private Map<String, Product> products; |
| |
| private Parameters parameters; |
| |
| public BugzillaRestConfiguration(String repositoryId) { |
| this.repositoryId = repositoryId; |
| } |
| |
| public String getRepositoryId() { |
| return repositoryId; |
| } |
| |
| void setFields(Map<String, Field> fields) { |
| Function<Field, String> getName = new Function<Field, String>() { |
| public String apply(Field item) { |
| return item.getName(); |
| } |
| }; |
| Function<String, String> comparatorFunction = Functions.compose(getName, Functions.forMap(fields)); |
| Ordering<String> comparator = Ordering.natural().onResultOf(comparatorFunction); |
| this.fields = ImmutableSortedMap.copyOf(fields, comparator); |
| } |
| |
| public Map<String, Field> getFields() { |
| return fields; |
| } |
| |
| public Field getFieldWithName(String fieldName) { |
| return fields.get(fieldName); |
| } |
| |
| void setProducts(Map<String, Product> products) { |
| Function<Product, String> getName = new Function<Product, String>() { |
| public String apply(Product item) { |
| return item.getName(); |
| } |
| }; |
| Function<String, String> comparatorFunction = Functions.compose(getName, Functions.forMap(products)); |
| Ordering<String> comparator = Ordering.natural().onResultOf(comparatorFunction); |
| this.products = ImmutableSortedMap.copyOf(products, comparator); |
| } |
| |
| public Map<String, Product> getProducts() { |
| return products; |
| } |
| |
| public Product getProductWithName(String productName) { |
| return products.get(productName); |
| } |
| |
| void setParameters(Parameters parameters) { |
| this.parameters = parameters; |
| } |
| |
| public Parameters getParameters() { |
| return parameters; |
| } |
| |
| private Component getProductComponentWithName(@NonNull Product product, String name) { |
| return product.getComponentWithName(name); |
| } |
| |
| public void updateInitialTaskData(TaskData data) throws CoreException { |
| setProductOptions(data); |
| updateProductOptions(data); |
| for (String key : data.getRoot().getAttributes().keySet()) { |
| if (key.equals(BugzillaRestTaskSchema.getDefault().ADD_SELF_CC.getKey()) |
| || key.equals(BugzillaRestTaskSchema.getDefault().NEW_COMMENT.getKey()) |
| || key.equals(BugzillaRestTaskSchema.getDefault().DUPE_OF.getKey()) |
| || key.equals(TaskAttribute.OPERATION) |
| || key.equals(BugzillaRestTaskSchema.getDefault().DATE_MODIFICATION.getKey()) |
| || key.equals(BugzillaRestTaskSchema.getDefault().RESET_ASSIGNED_TO.getKey())) { |
| continue; |
| } |
| TaskAttribute attribute = data.getRoot().getAttribute(key); |
| if (!key.equals(SCHEMA.PRODUCT.getKey())) { |
| String configName = mapTaskAttributeKey2ConfigurationFields(key); |
| if ("addCC".equals(configName) || "removeCC".equals(configName) |
| || "reset_qa_contact".equals(configName)) { |
| continue; |
| } |
| Field configField = getFieldWithName(configName); |
| if (configField == null) { |
| continue; |
| } |
| if (configName.equals("component") || configName.equals("version") |
| || configName.equals("target_milestone")) { |
| if (attribute.getOptions().size() == 1 && attribute.getValue().isEmpty()) { |
| attribute.setValue((String) attribute.getOptions().values().toArray()[0]); |
| } |
| } else { |
| FieldValues[] val = configField.getValues(); |
| if (val != null && val.length > 0) { |
| for (FieldValues fieldValues : val) { |
| if (configName.equals("bug_status")) { |
| if (fieldValues.getName() == null) { |
| for (StatusTransition bugzillaRestBugStatusTransition : fieldValues |
| .getCanChangeTo()) { |
| attribute.putOption(bugzillaRestBugStatusTransition.getName(), |
| bugzillaRestBugStatusTransition.getName()); |
| } |
| } |
| } else { |
| attribute.putOption(fieldValues.getName(), fieldValues.getName()); |
| } |
| |
| } |
| } |
| } |
| } |
| if (attribute.getValue().isEmpty()) { |
| String newValue = getValueFromParameter(key); |
| if (newValue != null) { |
| attribute.setValue(getValueFromParameter(key)); |
| } |
| } |
| |
| } |
| for (Field Field : fields.values()) { |
| if (Field.isCustom() && Field.isOnBugEntry()) { |
| TaskAttribute attribute = data.getRoot().createAttribute(Field.getName()); |
| if (attribute != null) { |
| attribute.getMetaData().defaults().setLabel(Field.getDisplayName()); |
| attribute.getMetaData().setKind(TaskAttribute.KIND_DEFAULT); |
| String type = getAttributeTypFromFieldTyp(Field.getType()); |
| attribute.getMetaData().setType(type); |
| if (type.equals(TaskAttribute.TYPE_SINGLE_SELECT)) { |
| attribute.getMetaData().setRequired(true); |
| } |
| |
| FieldValues[] values1 = Field.getValues(); |
| if (values1 != null) { |
| for (FieldValues FieldValues : values1) { |
| attribute.putOption(FieldValues.getName(), FieldValues.getName()); |
| } |
| } |
| attribute.getMetaData().setReadOnly(false); |
| } |
| } |
| } |
| updateKeyword(data); |
| } |
| |
| private String getValueFromParameter(String attributeId) { |
| if (attributeId.equals(TaskAttribute.PRIORITY)) { |
| return getParameters().getDefaultpriority(); |
| } else if (attributeId.equals(TaskAttribute.SEVERITY)) { |
| return getParameters().getDefaultseverity(); |
| } else if (attributeId.equals("platform")) { |
| if (getParameters().getDefaultplatform() == null || getParameters().getDefaultplatform().isEmpty()) { |
| return "All"; |
| } else { |
| return getParameters().getDefaultplatform(); |
| } |
| } else if (attributeId.equals("os")) { |
| if (getParameters().getDefaultopsys() == null || getParameters().getDefaultopsys().isEmpty()) { |
| return "All"; |
| } else { |
| return getParameters().getDefaultopsys(); |
| } |
| } |
| return ""; |
| } |
| |
| private String getAttributeTypFromFieldTyp(int fieldTyp) throws CoreException { |
| switch (fieldTyp) { |
| case 1://Free Text |
| return TaskAttribute.TYPE_SHORT_TEXT; |
| case 2: //DropDown |
| return TaskAttribute.TYPE_SINGLE_SELECT; |
| case 3: //Multiple-Selection Box |
| return TaskAttribute.TYPE_MULTI_SELECT; |
| case 4: //Large Text Box |
| return TaskAttribute.TYPE_LONG_TEXT; |
| case 5: //Date/Time |
| return TaskAttribute.TYPE_DATETIME; |
| case 6: //Bug Id |
| return TaskAttribute.TYPE_INTEGER; |
| case 7: //Bug URLs |
| return TaskAttribute.TYPE_URL; |
| default: |
| Status status = new Status(IStatus.INFO, BugzillaRestCore.ID_PLUGIN, |
| "unknown custom field type " + fieldTyp); |
| StatusHandler.log(status); |
| throw new CoreException(status); |
| } |
| } |
| |
| private String mapTaskAttributeKey2ConfigurationFields(String taskAttributeKey) { |
| String resultString; |
| if (taskAttributeKey.equals("task.common.summary")) { |
| resultString = "short_desc"; |
| } else if (taskAttributeKey.equals(TaskAttribute.PRODUCT) // |
| || taskAttributeKey.equals(TaskAttribute.RESOLUTION) // |
| || taskAttributeKey.equals(TaskAttribute.PRIORITY) // |
| || taskAttributeKey.equals(TaskAttribute.COMPONENT) // |
| || taskAttributeKey.equals(TaskAttribute.VERSION)) { |
| resultString = taskAttributeKey.substring(12); |
| } else if (taskAttributeKey.equals(TaskAttribute.STATUS)) { |
| resultString = "bug_status"; |
| } else if (taskAttributeKey.equals(TaskAttribute.USER_ASSIGNED)) { |
| resultString = "assigned_to"; |
| } else if (taskAttributeKey.equals(TaskAttribute.USER_CC)) { |
| resultString = "cc"; |
| } else if (taskAttributeKey.equals(TaskAttribute.DESCRIPTION)) { |
| resultString = "longdesc"; |
| } else if (taskAttributeKey.equals("description_is_private")) { |
| resultString = "longdescs.isprivate"; |
| } else if (taskAttributeKey.equals("os")) { |
| resultString = "op_sys"; |
| } else if (taskAttributeKey.equals("platform")) { |
| resultString = "rep_platform"; |
| } else if (taskAttributeKey.equals(TaskAttribute.SEVERITY)) { |
| resultString = "bug_severity"; |
| } else if (taskAttributeKey.equals("comment")) { |
| resultString = "longdesc"; |
| } else if (taskAttributeKey.equals("blocks")) { |
| resultString = "blocked"; |
| } else if (taskAttributeKey.equals("depends_on")) { |
| resultString = "dependson"; |
| } else { |
| |
| resultString = taskAttributeKey; |
| } |
| return resultString; |
| } |
| |
| private void setAttributeOptionsForProduct(TaskAttribute taskAttribute, Product actualProduct) { |
| taskAttribute.clearOptions(); |
| if (taskAttribute.getId().equals(SCHEMA.TARGET_MILESTONE.getKey())) { |
| internalSetAttributeOptions(taskAttribute, actualProduct.getMilestones()); |
| } else if (taskAttribute.getId().equals(SCHEMA.VERSION.getKey())) { |
| internalSetAttributeOptions(taskAttribute, actualProduct.getVersions()); |
| } else if (taskAttribute.getId().equals(SCHEMA.COMPONENT.getKey())) { |
| internalSetAttributeOptions(taskAttribute, actualProduct.getComponents()); |
| } |
| } |
| |
| private void internalSetAttributeOptions(TaskAttribute taskAttribute, SortableActiveEntry[] actualProductEntry) { |
| boolean found = false; |
| String actualValue = taskAttribute.getValue(); |
| for (SortableActiveEntry SortableActiveEntry : actualProductEntry) { |
| if (SortableActiveEntry.isActive()) { |
| taskAttribute.putOption(SortableActiveEntry.getName(), SortableActiveEntry.getName()); |
| if (!found) { |
| found = actualValue.equals(SortableActiveEntry.getName()); |
| } |
| } |
| } |
| if (!found) { |
| taskAttribute.setValue(""); //$NON-NLS-1$ |
| } |
| } |
| |
| public boolean setProductOptions(@NonNull TaskData taskData) { |
| TaskAttribute attributeProduct = taskData.getRoot().getMappedAttribute(SCHEMA.PRODUCT.getKey()); |
| if (attributeProduct != null) { |
| SortedSet<String> products = new TreeSet<String>(); |
| Field configFieldComponent = getFieldWithName("component"); //$NON-NLS-1$ |
| FieldValues[] val = configFieldComponent.getValues(); |
| if (val != null && val.length > 0) { |
| for (FieldValues fieldValues : val) { |
| for (String visibilityValue : fieldValues.getVisibilityValues()) { |
| if (!products.contains(visibilityValue)) { |
| products.add(visibilityValue); |
| } |
| } |
| } |
| attributeProduct.clearOptions(); |
| for (String productName : products) { |
| attributeProduct.putOption(productName, productName); |
| } |
| } |
| |
| return true; |
| } |
| return false; |
| } |
| |
| public boolean updateProductOptions(@NonNull TaskData taskData) { |
| if (taskData == null) { |
| return false; |
| } |
| TaskAttribute attributeProduct = taskData.getRoot().getMappedAttribute(SCHEMA.PRODUCT.getKey()); |
| if (attributeProduct == null) { |
| return false; |
| } |
| if (!attributeProduct.getValue().isEmpty()) { |
| Product actualProduct = getProductWithName(attributeProduct.getValue()); |
| |
| TaskAttribute attributeComponent = taskData.getRoot().getMappedAttribute(SCHEMA.COMPONENT.getKey()); |
| if (attributeComponent != null) { |
| setAttributeOptionsForProduct(attributeComponent, actualProduct); |
| } |
| TaskAttribute attributeVersion = taskData.getRoot().getMappedAttribute(SCHEMA.VERSION.getKey()); |
| if (attributeVersion != null) { |
| setAttributeOptionsForProduct(attributeVersion, actualProduct); |
| } |
| TaskAttribute attributeTargetMilestone = taskData.getRoot() |
| .getMappedAttribute(SCHEMA.TARGET_MILESTONE.getKey()); |
| if (attributeTargetMilestone != null) { |
| setAttributeOptionsForProduct(attributeTargetMilestone, actualProduct); |
| } |
| } else { |
| for (Product product : getProducts().values()) { |
| attributeProduct.putOption(product.getName(), product.getName()); |
| } |
| TaskAttribute attributeComponent = taskData.getRoot().getMappedAttribute(SCHEMA.COMPONENT.getKey()); |
| if (attributeComponent != null) { |
| setAllAttributeOptions(attributeComponent, getFieldWithName("component")); //$NON-NLS-1$ |
| } |
| TaskAttribute attributeVersion = taskData.getRoot().getMappedAttribute(SCHEMA.VERSION.getKey()); |
| if (attributeVersion != null) { |
| setAllAttributeOptions(attributeVersion, getFieldWithName("version")); //$NON-NLS-1$ |
| } |
| TaskAttribute attributeTargetMilestone = taskData.getRoot() |
| .getMappedAttribute(SCHEMA.TARGET_MILESTONE.getKey()); |
| if (attributeTargetMilestone != null) { |
| setAllAttributeOptions(attributeTargetMilestone, getFieldWithName("target_milestone")); //$NON-NLS-1$ |
| } |
| } |
| return true; |
| } |
| |
| private void setAllAttributeOptions(TaskAttribute updateAttribute, Field configField) { |
| FieldValues[] val = configField.getValues(); |
| if (val != null && val.length > 0) { |
| for (FieldValues fieldValues : val) { |
| updateAttribute.putOption(fieldValues.getName(), fieldValues.getName()); |
| } |
| } |
| } |
| |
| public void addValidOperations(TaskData bugReport) { |
| TaskAttribute attributeStatus = bugReport.getRoot().getMappedAttribute(TaskAttribute.STATUS); |
| String attributeStatusValue = attributeStatus.getValue(); |
| TaskAttribute operationAttribute = bugReport.getRoot().getAttribute(TaskAttribute.OPERATION); |
| if (operationAttribute == null) { |
| operationAttribute = bugReport.getRoot().createAttribute(TaskAttribute.OPERATION); |
| } |
| TaskAttribute attribute = bugReport.getRoot() |
| .createAttribute(TaskAttribute.PREFIX_OPERATION + attributeStatusValue); |
| if (attributeStatusValue.equals("RESOLVED")) { |
| attribute.getMetaData().putValue(TaskAttribute.META_ASSOCIATED_ATTRIBUTE_ID, |
| BugzillaRestTaskSchema.getDefault().RESOLUTION.getKey()); |
| } |
| |
| TaskOperation.applyTo(attribute, attributeStatusValue, attributeStatusValue); |
| // set as default |
| TaskOperation.applyTo(operationAttribute, attributeStatusValue, attributeStatusValue); |
| Field status = getFieldWithName("bug_status"); |
| for (FieldValues fieldValues : status.getValues()) { |
| if (((attributeStatusValue == null || attributeStatusValue.isEmpty()) && fieldValues.getName() == null) |
| || (attributeStatusValue != null && attributeStatusValue.equals(fieldValues.getName()))) { |
| for (StatusTransition statusTransition : fieldValues.getCanChangeTo()) { |
| attribute = bugReport.getRoot() |
| .createAttribute(TaskAttribute.PREFIX_OPERATION + statusTransition.name); |
| TaskOperation.applyTo(attribute, statusTransition.name, statusTransition.name); |
| if (statusTransition.name != null && statusTransition.name.equals("RESOLVED")) { |
| TaskAttribute attrResolvedInput = attribute.getTaskData().getRoot().createAttribute( |
| "resolutionInput"); |
| attrResolvedInput.getMetaData().setType(TaskAttribute.TYPE_SINGLE_SELECT); |
| attribute.getMetaData().putValue(TaskAttribute.META_ASSOCIATED_ATTRIBUTE_ID, "resolutionInput"); |
| Field resolution = getFieldWithName("resolution"); |
| for (FieldValues resolutionValues : resolution.getValues()) { |
| if (resolutionValues.getName().compareTo("DUPLICATE") != 0) { |
| attrResolvedInput.putOption(resolutionValues.getName(), resolutionValues.getName()); |
| } |
| } |
| } |
| } |
| } |
| } |
| attribute = bugReport.getRoot().createAttribute(TaskAttribute.PREFIX_OPERATION + "duplicate"); |
| TaskOperation.applyTo(attribute, "duplicate", "Mark as Duplicate"); |
| TaskAttribute attrResolvedInput = attribute.getTaskData().getRoot().getAttribute( |
| BugzillaRestTaskSchema.getDefault().DUPE_OF.getKey()); |
| if (attrResolvedInput == null) { |
| attrResolvedInput = attribute.getTaskData().getRoot().createAttribute( |
| BugzillaRestTaskSchema.getDefault().DUPE_OF.getKey()); |
| } |
| attrResolvedInput.getMetaData().setType(TaskAttribute.TYPE_TASK_DEPENDENCY); |
| attribute.getMetaData().putValue(TaskAttribute.META_ASSOCIATED_ATTRIBUTE_ID, attrResolvedInput.getId()); |
| } |
| |
| public boolean updateFlags(@NonNull TaskData taskData) { |
| List<String> existingFlags = new ArrayList<String>(); |
| TaskAttribute attributeProduct = taskData.getRoot().getMappedAttribute(SCHEMA.PRODUCT.getKey()); |
| TaskAttribute attributeComponent = taskData.getRoot().getMappedAttribute(SCHEMA.COMPONENT.getKey()); |
| Product actualProduct = getProductWithName(attributeProduct.getValue()); |
| Component actualComponent = getProductComponentWithName(actualProduct, attributeComponent.getValue()); |
| FlagTypes flagTypes = actualComponent.getFlagTypes(); |
| |
| for (TaskAttribute attribute : taskData.getRoot().getAttributes().values()) { |
| if (attribute.getId().startsWith(TaskAttribute.PREFIX_ATTACHMENT) |
| || attribute.getId().equals(TaskAttribute.NEW_ATTACHMENT)) { |
| List<String> existingAttachmentFlags = new ArrayList<String>(); |
| for (TaskAttribute attachmentAttribute : attribute.getAttributes().values()) { |
| updateFlag(flagTypes.getAttachment(), existingAttachmentFlags, attachmentAttribute); |
| } |
| addMissingFlagsInternal(attribute, flagTypes.getAttachment(), existingAttachmentFlags); |
| } else { |
| updateFlag(flagTypes.getBug(), existingFlags, attribute); |
| } |
| } |
| addMissingFlagsInternal(taskData.getRoot(), flagTypes.getBug(), existingFlags); |
| |
| return false; |
| } |
| |
| private void updateFlag(FlagType[] flagTypes, List<String> existingAttachmentFlags, TaskAttribute flagAttribute) { |
| if (flagAttribute.getId().startsWith(IBugzillaRestConstants.KIND_FLAG)) { |
| TaskAttribute stateAttribute = flagAttribute.getAttribute("state"); //$NON-NLS-1$)) |
| stateAttribute.putOption("", ""); //$NON-NLS-1$ //$NON-NLS-2$ |
| String flagName = stateAttribute.getMetaData().getLabel(); |
| if (!existingAttachmentFlags.contains(flagName)) { |
| existingAttachmentFlags.add(flagName); |
| } |
| for (FlagType flagType : flagTypes) { |
| if (flagType.getName().equals(flagName)) { |
| if (flagType.isRequestable()) { |
| stateAttribute.putOption("?", "?"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| updateRequestee(flagAttribute, flagType); |
| break; |
| } |
| } |
| stateAttribute.putOption("-", "-"); //$NON-NLS-1$ //$NON-NLS-2$ |
| stateAttribute.putOption("+", "+"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| } |
| |
| public void addMissingFlags(TaskData taskData) { |
| List<String> existingFlags = new ArrayList<String>(); |
| TaskAttribute attributeProduct = taskData.getRoot().getMappedAttribute(SCHEMA.PRODUCT.getKey()); |
| TaskAttribute attributeComponent = taskData.getRoot().getMappedAttribute(SCHEMA.COMPONENT.getKey()); |
| if (attributeProduct.getValue().equals("") || attributeComponent.getValue().equals("")) { //$NON-NLS-1$ //$NON-NLS-2$ |
| return; |
| } |
| Product actualProduct = getProductWithName(attributeProduct.getValue()); |
| Component actualComponent = getProductComponentWithName(actualProduct, attributeComponent.getValue()); |
| FlagTypes flagTypes = actualComponent.getFlagTypes(); |
| addMissingFlagsInternal(taskData.getRoot(), flagTypes.getBug(), existingFlags); |
| } |
| |
| private void addMissingFlagsInternal(TaskAttribute rootTaskAttribute, FlagType[] flagTypes, |
| List<String> existingFlags) { |
| for (FlagType flagType : flagTypes) { |
| if (existingFlags.contains(flagType.getName()) && !flagType.isMultiplicable()) { |
| continue; |
| } |
| BugzillaRestFlagMapper mapper = new BugzillaRestFlagMapper(); |
| mapper.setRequestee(""); //$NON-NLS-1$ |
| mapper.setSetter(""); //$NON-NLS-1$ |
| mapper.setState(" "); //$NON-NLS-1$ |
| mapper.setName(flagType.getName()); |
| mapper.setNumber(0); |
| mapper.setDescription(flagType.getDescription()); |
| mapper.setTypeId(flagType.getId()); |
| TaskAttribute attribute = rootTaskAttribute |
| .createAttribute(IBugzillaRestConstants.KIND_FLAG_TYPE + flagType.getId()); |
| mapper.applyTo(attribute); |
| TaskAttribute stateAttribute = attribute.getAttribute("state"); //$NON-NLS-1$)) |
| stateAttribute.putOption("", ""); //$NON-NLS-1$ //$NON-NLS-2$ |
| if (flagType.isRequestable()) { |
| stateAttribute.putOption("?", "?"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| updateRequestee(attribute, flagType); |
| attribute.getMetaData().putValue(TaskAttribute.META_DESCRIPTION, flagType.getDescription()); |
| stateAttribute.putOption("-", "-"); //$NON-NLS-1$ //$NON-NLS-2$ |
| stateAttribute.putOption("+", "+"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| } |
| |
| public void updateRequestee(TaskAttribute attribute, FlagType flagType) { |
| TaskAttribute requestee = attribute.getAttribute("requestee"); //$NON-NLS-1$ |
| if (requestee == null) { |
| requestee = attribute.createMappedAttribute("requestee"); //$NON-NLS-1$ |
| requestee.getMetaData().defaults().setType(TaskAttribute.TYPE_PERSON); |
| requestee.setValue(""); //$NON-NLS-1$ |
| } |
| requestee.getMetaData().setReadOnly(!flagType.isRequesteeble()); |
| } |
| |
| public void updateAttachmentFlags(@NonNull TaskAttribute attribute) { |
| TaskAttribute attributeProduct = attribute.getParentAttribute().getMappedAttribute(SCHEMA.PRODUCT.getKey()); |
| TaskAttribute attributeComponent = attribute.getParentAttribute().getMappedAttribute(SCHEMA.COMPONENT.getKey()); |
| Product actualProduct = getProductWithName(attributeProduct.getValue()); |
| Component actualComponent = getProductComponentWithName(actualProduct, attributeComponent.getValue()); |
| FlagTypes flagTypes = actualComponent.getFlagTypes(); |
| |
| List<String> existingAttachmentFlags = new ArrayList<String>(); |
| for (TaskAttribute attachmentAttribute : attribute.getAttributes().values()) { |
| updateFlag(flagTypes.getAttachment(), existingAttachmentFlags, attachmentAttribute); |
| } |
| addMissingFlagsInternal(attribute, flagTypes.getAttachment(), existingAttachmentFlags); |
| } |
| |
| public void updateKeyword(TaskData taskData) { |
| TaskAttribute attributeKeywords = taskData.getRoot().getMappedAttribute(SCHEMA.KEYWORDS.getKey()); |
| Field keywords = getFieldWithName("keywords"); |
| FieldValues[] keywordList = keywords.getValues(); |
| attributeKeywords.clearOptions(); |
| for (FieldValues fieldValues : keywordList) { |
| attributeKeywords.putOption(fieldValues.getName(), fieldValues.getDescription()); |
| } |
| } |
| |
| } |
