import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
private void persistAttachments (NbTaskDataModel model, TaskData td) {
    if (unsavedAttachments != null) {
        TaskAttribute parentTA = td.getRoot().getAttribute(IssueField.ATTACHMENTS.getKey());
        if (parentTA == null) {
            parentTA = td.getRoot().createAttribute(IssueField.ATTACHMENTS.getKey());
        }
        if (!unsavedAttachments.isEmpty()) {
            boolean copyToCentral = askCopyToCentralStorage(unsavedAttachments.size());
            for (AttachmentInfo att : unsavedAttachments) {
                File file = att.getFile();
                if (file != null) {
                    String desc = att.getDescription();
                    String contentType = att.getContentType();
                    boolean isPatch = att.isPatch();
                    addAttachment(model, parentTA, file, desc, contentType, isPatch, copyToCentral);
                }
            }
            unsavedAttachments.clear();
        }
    }
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
void removeTaskReference (String repositoryId, String taskId) {
    NbTaskDataModel model = getModel();
    TaskData taskData = model == null ? null : model.getLocalTaskData();
    if (taskData != null) {
        TaskAttribute parentTA = taskData.getRoot().getAttribute(IssueField.REFERENCES.getKey());
        if (parentTA != null) {
            for (TaskAttribute ta : parentTA.getAttributes().values()) {
                if (ta.getId().startsWith(NB_TASK_REFERENCE)) {
                    TaskReference ref = TaskReference.createFrom(ta);
                    if (repositoryId.equals(ref.getRepositoryId()) && taskId.equals(ref.getTaskId())) {
                        parentTA.removeAttribute(ta.getId());
                        break;
                    }
                }
            }
        }
        model.attributeChanged(parentTA);
    }
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
public void attachPatch (final File file, final String description) {
    if (file != null) {
        runWithModelLoaded(new Runnable() {

            @Override
            public void run () {
                NbTaskDataModel model = getModel();
                TaskData td = model == null ? null : model.getLocalTaskData();
                if (td != null) {
                    TaskAttribute parentTA = td.getRoot().getAttribute(IssueField.ATTACHMENTS.getKey());
                    if (parentTA == null) {
                        parentTA = td.getRoot().createAttribute(IssueField.ATTACHMENTS.getKey());
                    }
                    addAttachment(model, parentTA, file, description, null, true, true);
                    save();
                    modelStateChanged(false);
                    if (controller != null) {
                        controller.refreshViewData();
                    }
                }
            }
        });
    }
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
public boolean hasIncomingChanges (TaskAttribute taskAttribute, boolean includeConflicts) {
    TaskData repositoryData = workingCopy.getRepositoryData();
    if (repositoryData == null) {
        return false;
    }
    taskAttribute = repositoryData.getRoot().getMappedAttribute(taskAttribute.getPath());
    if (taskAttribute == null) {
        return false;
    }
    boolean incoming = delegateModel.hasIncomingChanges(taskAttribute);
    if (includeConflicts && !incoming && delegateModel.hasOutgoingChanges(taskAttribute)) {
        TaskData lastReadData = workingCopy.getLastReadData();
        if (lastReadData == null) {
            return true;
        }
        TaskAttribute oldAttribute = lastReadData.getRoot().getMappedAttribute(taskAttribute.getPath());
        if (oldAttribute == null) {
            return true;
        }
        return !repositoryData.getAttributeMapper().equals(taskAttribute, oldAttribute);
    }
    return incoming;
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
/**
 * Updates the model and all taskdata to keep track with external taskdata
 * changes (such as a task refresh)
 * @throws CoreException 
 */
public void refresh () throws CoreException {
    // refresh reverts all taskdata to the state on disk
    delegateModel.refresh(null);
    // also clear unsaved changes in the mylyn model
    // this is needed because after refresh() the unsaved changes no longer
    // belong to the local taskdata (they're reinstantiated)
    delegateModel.revert();
    if (workingCopy instanceof TaskDataState && workingCopy.getLastReadData() == null) {
        ((TaskDataState) workingCopy).setLastReadData(workingCopy.getRepositoryData());
    }
    Set<TaskAttribute> changedAttributes;
    synchronized (unsavedChangedAttributes) {
        changedAttributes = new HashSet<TaskAttribute>(unsavedChangedAttributes);
    }
    for (TaskAttribute ta : changedAttributes) {
        // there are still local unsaved changes, keep them in local taskdata
        TaskData td = getLocalTaskData();
        td.getRoot().deepAddCopy(ta);
        TaskAttribute attribute = td.getRoot().getAttribute(ta.getId());
        // now refill the unsaved changes so they belong to the correct local TD
        attributeChanged(attribute);
    }
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
public void save (IProgressMonitor monitor) throws CoreException {
    // clear delegate model changes
    delegateModel.save(monitor);
    // now bit of hacking
    // task attributes with same values as local changes must be reverted
    TaskData editsData = workingCopy.getEditsData();
    TaskData repositoryData = workingCopy.getRepositoryData();
    synchronized (unsavedChangedAttributes) {
        if (editsData != null && repositoryData != null) {
            for (Iterator<TaskAttribute> it = unsavedChangedAttributes.iterator(); it.hasNext(); ) {
                TaskAttribute ta = it.next();
                if (!editsDiffer(ta, repositoryData)) {
                    editsData.getRoot().removeAttribute(ta.getId());
                    it.remove();
                }
            }
        }
        // are there any edits 
        boolean noChanges = unsavedChangedAttributes.isEmpty() && !hasOutgoingChanged();
        if (noChanges) {
            task.discardLocalEdits();
        }
        delegateModel.revert();
        unsavedChangedAttributes.clear();
    }
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
protected static boolean attachmentAttributesDiffer (TaskAttribute ta1, TaskAttribute ta2) {
    if (ta2 == null) {
        return true;
    }
    String value1 = ta1.getValue();
    String value2 = ta2.getValue();
    boolean changes = !value1.equals(value2);
    if (!changes) {
        // is a child attribue changed??
        for (TaskAttribute childTA : ta1.getAttributes().values()) {
            if (attachmentAttributesDiffer(childTA, ta2.getAttribute(childTA.getId()))) {
                changes = true;
                break;
            }
        }
    }
    return changes;
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
@Override
public String toString() {
    if(stringValue == null) {
        StringBuilder sb = new StringBuilder();
        sb.append("AddAttachmentCommand [repository=");                     // NOI18N
        sb.append(repository.getUrl());
        sb.append(",id=");                                                  // NOI18N
        sb.append(id);
        sb.append(",comment=");                                             // NOI18N
        sb.append(comment);
        sb.append(",file=");                                                // NOI18N
        sb.append(file.getAbsolutePath());
        sb.append(",desc=");                                                // NOI18N
        TaskAttribute ta = attAttribute.getMappedAttribute(TaskAttribute.ATTACHMENT_DESCRIPTION);
        sb.append(ta != null ? ta.getValue() : "");                         // NOI18N
        sb.append(",patch=");                                               // NOI18N
        ta = attAttribute.getMappedAttribute(TaskAttribute.ATTACHMENT_IS_PATCH);
        sb.append(ta != null ? ta.getValue() : "");                         // NOI18N
        sb.append(",contentType=");                                         // NOI18N
        ta = attAttribute.getMappedAttribute(TaskAttribute.ATTACHMENT_CONTENT_TYPE);
        sb.append(ta != null ? ta.getValue() : "");                         // NOI18N
        sb.append("]");                                                     // NOI18N
        stringValue = sb.toString();
    }
    return stringValue;
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
private static String getFieldValue (TaskData taskData, IssueField f) {
    if (taskData == null) {
        return "";
    }
    if(f.isSingleAttribute()) {
        TaskAttribute a = taskData.getRoot().getMappedAttribute(f.getKey());
        if(a != null && a.getValues().size() > 1) {
            return listValues(a);
        }
        return a != null ? a.getValue() : ""; // NOI18N
    } else {
        List<TaskAttribute> attrs = taskData.getAttributeMapper().getAttributesByType(taskData, f.getKey());
        // returning 0 would set status MODIFIED instead of NEW
        return "" + ( attrs != null && attrs.size() > 0 ?  attrs.size() : ""); // NOI18N
    }
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
/**
 * Returns a comma separated list created
 * from the values returned by TaskAttribute.getValues()
 *
 * @param a
 * @return
 */
private static String listValues(TaskAttribute a) {
    if(a == null) {
        return "";                                                          // NOI18N
    }
    StringBuilder sb = new StringBuilder();
    List<String> l = a.getValues();
    for (int i = 0; i < l.size(); i++) {
        String s = l.get(i);
        sb.append(s);
        if(i < l.size() -1) {
            sb.append(",");                                                 // NOI18N
        }
    }
    return sb.toString();
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
private static List<String> getFieldValues(TaskData taskData, IssueField f) {
    if (taskData == null) {
        return Collections.<String>emptyList();
    }
    if(f.isSingleAttribute()) {
        TaskAttribute a = taskData.getRoot().getMappedAttribute(f.getKey());
        if(a != null) {
            return a.getValues();
        } else {
            return Collections.emptyList();
        }
    } else {
        List<String> ret = new ArrayList<>();
        ret.add(getFieldValue(taskData, f));
        return ret;
    }
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
/**
 * Returns a status value for the given field<br>
 * <ul>
 *  <li>{@link #FIELD_STATUS_IRELEVANT} - issue wasn't seen yet
 *  <li>{@link #FIELD_STATUS_UPTODATE} - field value wasn't changed
 *  <li>{@link #FIELD_STATUS_MODIFIED} - field value was changed in repository
 *  <li>{@link #FIELD_STATUS_OUTGOING} - field value was changed locally
 *  <li>{@link #FIELD_STATUS_CONFLICT} - field value was changed both locally and remotely
 * </ul>
 * @param f IssueField
 * @return a status value
 */
public int getFieldStatus(IssueField f) {
    NbTaskDataModel m = getModel();
    if (m == null) {
        return FIELD_STATUS_UPTODATE;
    }
    TaskAttribute ta = m.getLocalTaskData().getRoot().getMappedAttribute(f.getKey());
    boolean incoming = ta != null && m.hasIncomingChanges(ta, true);
    boolean outgoing = ta != null && m.hasOutgoingChanges(ta);
    if (ta == null) {
        return FIELD_STATUS_UPTODATE;
    } else if (incoming & outgoing) {
        return FIELD_STATUS_CONFLICT;
    } else if (incoming) {
        return FIELD_STATUS_MODIFIED;
    } else if (outgoing) {
        return FIELD_STATUS_OUTGOING;
    }
    return FIELD_STATUS_UPTODATE;
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
boolean canReassign() {
    NbTaskDataModel m = getModel();
    if (m == null) {
        return false;
    }
    BugzillaConfiguration rc = getRepository().getConfiguration();
    final BugzillaVersion installedVersion = rc != null ? rc.getInstalledVersion() : null;
    boolean oldRepository = installedVersion != null ? installedVersion.compareMajorMinorOnly(BugzillaVersion.BUGZILLA_3_2) < 0 : false;
    if (oldRepository) {
        TaskAttribute rta = m.getLocalTaskData().getRoot();
        TaskAttribute ta = rta.getMappedAttribute(BugzillaOperation.reassign.getInputId());
        return (ta != null);
    } else {
        return true;
    }
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
boolean canAssignToDefault() {
    NbTaskDataModel m = getModel();
    if (m == null) {
        return false;
    }
    BugzillaConfiguration rc = getRepository().getConfiguration();
    final BugzillaVersion installedVersion = rc != null ? rc.getInstalledVersion() : null;
    boolean pre4 = installedVersion != null ? installedVersion.compareMajorMinorOnly(BugzillaVersion.BUGZILLA_3_0) <= 0 : false;
    TaskData taskData = m.getLocalTaskData();
    if(pre4) {
        return BugzillaOperation.reassignbycomponent.getInputId() != null ? 
                    taskData.getRoot().getMappedAttribute(BugzillaOperation.reassignbycomponent.getInputId()) != null :
                    false;
    } else {
        TaskAttribute ta = taskData.getRoot().getAttribute(BugzillaAttribute.SET_DEFAULT_ASSIGNEE.getKey()); 
        return ta != null;
    }
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
Comment[] getComments() {
    final List<Comment> comments = new ArrayList<>();
    runWithModelLoaded(new Runnable() {
        @Override
        public void run() {
            NbTaskDataModel m = getModel();
            List<TaskAttribute> attrs = m == null ? null : m.getLocalTaskData()
                    .getAttributeMapper().getAttributesByType(m.getLocalTaskData(), TaskAttribute.TYPE_COMMENT);
            if (attrs != null) {
                for (TaskAttribute taskAttribute : attrs) {
                    comments.add(new Comment(taskAttribute));
                }
            }
        }
    });
    return comments.toArray(new Comment[comments.size()]);
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
public void addComment (final String comment) {
    if(comment != null && !comment.isEmpty()) {
        runWithModelLoaded(new Runnable() {
            @Override
            public void run () {
                Bugzilla.LOG.log(Level.FINER, "adding comment [{0}] to issue #{1}", new Object[]{comment, getID()});
                TaskAttribute ta = getModel().getLocalTaskData().getRoot().getMappedAttribute(IssueField.COMMENT.getKey());
                String value = ta.getValue();
                if (value == null || value.trim().isEmpty()) {
                    value = comment;
                } else {
                    value += "\n\n" + comment; //NOI18N
                }
                setValue(getModel(), ta, value);
            }
        });
    }
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
/**
 * Returns available operations for this issue
 * @return
 */
Map<String, TaskOperation> getAvailableOperations () {
    if (availableOperations == null) {
        HashMap<String, TaskOperation> operations = new HashMap<String, TaskOperation>(5);
        NbTaskDataModel model = getModel();
        List<TaskAttribute> allOperations = model.getLocalTaskData().getAttributeMapper().getAttributesByType(model.getLocalTaskData(), TaskAttribute.TYPE_OPERATION);
        for (TaskAttribute operation : allOperations) {
            // the test must be here, 'operation' (applying writable action) is also among allOperations
            if (operation.getId().startsWith(TaskAttribute.PREFIX_OPERATION)) {
                operations.put(operation.getId().substring(TaskAttribute.PREFIX_OPERATION.length()), TaskOperation.createFrom(operation));
            }
        }
        availableOperations = operations;
    }

    return availableOperations;
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
private void setValue (NbTaskDataModel model, TaskAttribute ta, String value) {
    TaskData repositoryTaskData = model.getRepositoryTaskData();
    if (value.isEmpty() && repositoryTaskData != null) {
        // should be empty or set to ""???
        TaskAttribute a = repositoryTaskData.getRoot().getAttribute(ta.getId());
        if (a == null || a.getValues().isEmpty()) {
            // repository value is also empty list, so let's set to the same
            ta.clearValues();
        } else {
            ta.setValue(value);
        }
    } else {
        ta.setValue(value);
    }
    model.attributeChanged(ta);
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
private void makeExternalChange (NbTask task, String newSummary) throws CoreException {
    MylynSupport supp = MylynSupport.getInstance();
    TaskData taskData = task.getTaskDataState().getRepositoryData();
    
    // edit the task externally
    TaskAttribute rta = taskData.getRoot();
    // now make an external change in summary
    TaskData external = new TaskData(taskData.getAttributeMapper(),
            taskData.getConnectorKind(),
            taskData.getRepositoryUrl(),
            taskData.getTaskId());
    external.setVersion(taskData.getVersion());
    for (TaskAttribute child : rta.getAttributes().values()) {
        external.getRoot().deepAddCopy(child);
    }
    external.getRoot().getMappedAttribute(TaskAttribute.SUMMARY).setValue(newSummary);
    SubmitCommand submitCmd = new SubmitCommand(Bugzilla.getInstance().getRepositoryConnector(), btr, external);
    br.getExecutor().execute(submitCmd);
}
 

import org.eclipse.mylyn.tasks.core.data.TaskAttribute; //导入依赖的package包/类
private void closeTask (String resolution) {
    TaskOperation taskOperation = null;
    TaskAttribute opAttr = model.getLocalTaskData().getRoot().getMappedAttribute(TaskAttribute.OPERATION);
    for (TaskOperation op : model.getLocalTaskData().getAttributeMapper().getTaskOperations(opAttr)) {
        if (BugzillaOperation.resolve.getLabel().equals(op.getLabel())) {
            taskOperation = op;
            break;
        }
    }
    assertNotNull(taskOperation);
    assertFalse(task.isCompleted());
    model.getLocalTaskData().getAttributeMapper().setTaskOperation(opAttr, taskOperation);
    model.attributeChanged(opAttr);
    TaskAttribute resolutionAttr = model.getLocalTaskData().getRoot().getMappedAttribute(BugzillaOperation.resolve.getInputId());
    resolutionAttr.setValue(resolution);
    model.attributeChanged(resolutionAttr);
}