public ChangeHistoryItem build() { return new ChangeHistoryItem(id, changeGroupId, projectId, issueId, issueKey, field, created, nextChangeCreated, fromValues, toValues, userKey); } }
public Builder fromChangeItemWithoutPreservingChanges(ChangeHistoryItem changeItem) { this.id = changeItem.getId(); this.projectId = changeItem.getProjectId(); this.changeGroupId = changeItem.getChangeGroupId(); this.issueId = changeItem.getIssueId(); this.issueKey = changeItem.getIssueKey(); this.field = changeItem.getField(); this.created = changeItem.getCreated(); this.userKey = changeItem.getUserKey(); this.nextChangeCreated = changeItem.getNextChangeCreated(); return this; }
public Builder addChangeItem(ChangeHistoryItem item) { Assertions.notNull(item); changeItems.add(item); if (issueId == 0) { id = item.getChangeGroupId(); issueId = item.getIssueId(); issueKey = item.getIssueKey(); projectId = item.getProjectId(); userKey = item.getUserKey(); created = item.getCreated(); } return this; }
@Override public int compareTo(ChangeHistoryItem other) { int result = created.compareTo(other.getCreated()); if (result == 0) { result = changeGroupId.compareTo(other.getChangeGroupId()); if (result == 0) { result = id.compareTo(other.getId()); } } return result; }
final String changedField = changeItem.getField(); builder.addField(encodeChangedField(changedField, DocumentConstants.CHANGE_DURATION), String.valueOf(changeItem.getDuration()), Field.Store.NO, Field.Index.NOT_ANALYZED_NO_NORMS) .addField(encodeChangedField(changedField, DocumentConstants.NEXT_CHANGE_DATE), LuceneUtils.dateToString(changeItem.getNextChangeCreated()), Field.Store.NO, Field.Index.NOT_ANALYZED_NO_NORMS); for (final String from : changeItem.getFroms().values()) for (final String to : changeItem.getTos().values()) for (final String fromValue : changeItem.getFroms().keySet()) for (final String toValue : changeItem.getTos().keySet())
changeItems.add(fixInitialChangeItem(initialChangeItem, items.get(0).getFroms(), items.get(0).getCreated())); PeekingIterator<ChangeHistoryItem> iterator = Iterators.peekingIterator(items.iterator()); while (iterator.hasNext()) if (iterator.hasNext()) changeItems.add(createChangeItem(nextItem,iterator.peek().getCreated())); changeItems.add(createChangeItem(nextItem, nextItem.getNextChangeCreated()));
final ChangeHistoryItem fixedInitialItem = fixInitialChangeItemToValue(items, initialChangeItem, items.get(0).getCreated()); changeItems.add(fixedInitialItem); Map<String, String> previousItemToValues = fixedInitialItem.getTos(); PeekingIterator<ChangeHistoryItem> iterator = Iterators.peekingIterator(items.iterator()); Map<String, String> removals = nextItem.getFroms(); Map <String, String> additions = nextItem.getTos(); Map <String, String> effectiveTos = Maps.newHashMap(); effectiveTos.putAll(previousItemToValues); nextChangeOn(iterator.peek().getCreated()).field(fieldName). withFroms(previousItemToValues).withTos(effectiveTos).build());
public Builder fromChangeItemPreservingToValues(ChangeHistoryItem changeItem) { this.fromChangeItemWithoutPreservingChanges(changeItem); this.toValues = Maps.newHashMap(changeItem.getTos()); return this; }
public Builder fromChangeItemPreservingFromValues(ChangeHistoryItem changeItem) { this.fromChangeItemWithoutPreservingChanges(changeItem); this.fromValues = Maps.newHashMap(changeItem.getFroms()); return this; }
public boolean apply(final ChangeHistoryItem input) { //add this field and id to the constants manager String fieldName = jqlChangeItemMapping.mapJqlClauseToFieldName(field.getFieldName()); return (input != null && fieldName.equals(input.getField())); } }));
private Iterable<ChangeHistoryGroup> createChangeGroupsFromChangeItems(final List<ChangeHistoryItem> changeHistoryItems, final Issue issue) { // need to maintain sorting order here, for this to work List<ChangeHistoryItem> filteredChangeItems = newArrayList(filterChangeItems(issue, changeHistoryItems)); Collections.sort(filteredChangeItems); long currentChangeGroup = -1; ChangeHistoryGroup.Builder builder = new ChangeHistoryGroup.Builder(); List<ChangeHistoryGroup.Builder> builders = newArrayList(builder); for (ChangeHistoryItem item : filteredChangeItems) { if (item.getChangeGroupId() != currentChangeGroup) { currentChangeGroup = item.getChangeGroupId(); builder = new ChangeHistoryGroup.Builder(); builders.add(builder); } builder.addChangeItem(item); } return Iterables.transform(builders, new Function<ChangeHistoryGroup.Builder, ChangeHistoryGroup>() { @Override public ChangeHistoryGroup apply(@Nullable ChangeHistoryGroup.Builder builder) { return builder.build(); } }); }
@Override public boolean equals(Object o) { if(o == null || !(o instanceof ChangeHistoryItem)) { return false; } ChangeHistoryItem rhs = (ChangeHistoryItem)o; return new EqualsBuilder() .append(getId(), rhs.getId()) .append(getChangeGroupId(), rhs.getChangeGroupId()) .append(getField(), rhs.getField()) .append(getUserKey(), rhs.getUserKey()) .append(getProjectId(), rhs.getProjectId()) .append(getIssueId(), rhs.getIssueId()) .append(getIssueKey(), rhs.getIssueKey()) .append(getCreated(), rhs.getCreated()) .append(getNextChangeCreated(), rhs.getNextChangeCreated()) .append(getFroms(), rhs.getFroms()) .append(getTos(), rhs.getTos()) .isEquals(); }
/** * * @param items The list of {@link com.atlassian.jira.issue.changehistory.ChangeHistoryItem}'s that represent all chnages in the current issue * @param initialChangeItem The synthetic ChangeHistoryItem previously built * @param created Timestamp of the first itrem in the list * @return The ChangeHistoryItem that accurately reflects the initial state of the issue * * The algorithm is pretty straightforward, revers the list and then iterate through reversing each change from the initial list. What is left is the * original state. */ private ChangeHistoryItem fixInitialChangeItemToValue(List <ChangeHistoryItem> items, ChangeHistoryItem initialChangeItem, Timestamp created) { Map<String, String> newToValues = Maps.newHashMap(initialChangeItem.getTos()); newToValues.remove(emptyValue); for (ChangeHistoryItem item : Lists.reverse(items)) { newToValues.putAll(item.getFroms()); for (String key: item.getTos().keySet()) { newToValues.remove(key); } } if (newToValues.isEmpty()) { newToValues.put(emptyValue, EMPTY_STRING); } return new ChangeHistoryItem.Builder().fromChangeItemWithoutPreservingChanges(initialChangeItem). withTos(newToValues).nextChangeOn(created).build(); }
public List<ChangeHistoryGroup> apply(final Issue issue) { final List<ChangeHistoryGroup> changeGroups = new ArrayList<ChangeHistoryGroup>(); try { // get a List<GenericValue> of changes final List<GenericValue> allChanges = issueManager.getEntitiesByIssueObject(IssueRelationConstants.CHANGE_GROUPS, issue); for (final GenericValue element : allChanges) { final List<ChangeHistoryItem> changes = new ArrayList<ChangeHistoryItem>(); final List<GenericValue> changeitems = element.getRelated("ChildChangeItem"); for (final GenericValue changeItem : changeitems) { changes.add(new ChangeHistoryItem(changeItem.getLong("id"), changeItem.getLong("group"), issue.getProjectObject().getId(),issue.getId(), issue.getKey(), "status", new Timestamp(System.currentTimeMillis()), changeItem.getString("oldstring"), changeItem.getString("newstring"), changeItem.getString("oldvalue"), changeItem.getString("newvalue"), element.getString("author"))); } changeGroups.add(new ChangeHistoryGroup(element.getLong("id"), issue.getProjectObject().getId(), issue.getId(), issue.getKey(), element.getString("author"), changes, element.getTimestamp("created"))); } } catch (final Exception e) { throw new DataAccessException(e); } return changeGroups; } }
@Override public int hashCode() { return new HashCodeBuilder() .append(getId()) .append(getChangeGroupId()) .append(getField()) .append(getUserKey()) .append(getProjectId()) .append(getIssueId()) .append(getIssueKey()) .append(getCreated()) .append(getNextChangeCreated()) .append(getFroms()) .append(getTos()) .toHashCode(); }
protected ChangeHistoryItem createChangeItem(ChangeHistoryItem changeItem, Timestamp nextChange) { ChangeHistoryItem.Builder builder = new ChangeHistoryItem.Builder().fromChangeItem(changeItem). nextChangeOn(nextChange); if (changeItem.getTos().isEmpty()) { builder.to("", emptyValue); } if (changeItem.getFroms().isEmpty()) { builder.changedFrom("", emptyValue); } return builder.build(); }