public void update(DbSession session, IssueDto dto) { mapper(session).update(dto); }
public Optional<IssueDto> selectByKey(DbSession session, String key) { return Optional.ofNullable(mapper(session).selectByKey(key)); }
private void persistUpdatedIssues(IssueStatistics statistics, List<DefaultIssue> updatedIssues, IssueMapper mapper, IssueChangeMapper changeMapper) { if (updatedIssues.isEmpty()) { return; } long now = system2.now(); updatedIssues.forEach(i -> { IssueDto dto = IssueDto.toDtoForUpdate(i, now); mapper.updateIfBeforeSelectedDate(dto); statistics.updates++; }); // retrieve those of the updatedIssues which have not been updated and apply conflictResolver on them List<String> updatedIssueKeys = updatedIssues.stream().map(DefaultIssue::key).collect(toList(updatedIssues.size())); List<IssueDto> conflictIssueKeys = mapper.selectByKeysIfNotUpdatedAt(updatedIssueKeys, now); if (!conflictIssueKeys.isEmpty()) { Map<String, DefaultIssue> issuesByKeys = updatedIssues.stream().collect(uniqueIndex(DefaultIssue::key, updatedIssues.size())); conflictIssueKeys .forEach(dbIssue -> { DefaultIssue updatedIssue = issuesByKeys.get(dbIssue.getKey()); conflictResolver.resolve(updatedIssue, dbIssue, mapper); statistics.merged++; }); } updatedIssues.forEach(i -> issueStorage.insertChanges(changeMapper, i)); }
public void resolve(DefaultIssue issue, IssueMapper mapper) { LOG.debug("Resolve conflict on issue {}", issue.key()); IssueDto dbIssue = mapper.selectByKey(issue.key()); if (dbIssue != null) { mergeFields(dbIssue, issue); mapper.update(IssueDto.toDtoForUpdate(issue, System.currentTimeMillis())); } }
private static List<DefaultIssue> loadClosedIssues(DbSession dbSession, String componentUuid, long closeDateAfter) { ClosedIssuesResultHandler handler = new ClosedIssuesResultHandler(); dbSession.getMapper(IssueMapper.class).scrollClosedByComponentUuid(componentUuid, closeDateAfter, handler); return ImmutableList.copyOf(handler.issues); }
public Set<String> selectComponentUuidsOfOpenIssuesForProjectUuid(DbSession session, String projectUuid) { return mapper(session).selectComponentUuidsOfOpenIssuesForProjectUuid(projectUuid); }
private List<DefaultIssue> loadOpenIssues(String componentUuid, DbSession dbSession) { List<DefaultIssue> result = new ArrayList<>(); dbSession.getMapper(IssueMapper.class).scrollNonClosedByComponentUuid(componentUuid, resultContext -> { DefaultIssue issue = (resultContext.getResultObject()).toDefaultIssue(); Rule rule = ruleRepository.getByKey(issue.ruleKey()); // TODO this field should be set outside this class if ((!rule.isExternal() && !isActive(issue.ruleKey())) || rule.getStatus() == RuleStatus.REMOVED) { issue.setOnDisabledRule(true); // TODO to be improved, why setOnDisabledRule(true) is not enough ? issue.setBeingClosed(true); } // FIXME issue.setSelectedAt(System.currentTimeMillis()); result.add(issue); }); return ImmutableList.copyOf(result); }
private void persistChangedIssue(IssueMapper mapper, DefaultIssue issue) { IssueDto dto = IssueDto.toDtoForUpdate(issue, system2.now()); int updateCount = mapper.updateIfBeforeSelectedDate(dto); if (updateCount == 0) { // End-user and scan changed the issue at the same time. // See https://jira.sonarsource.com/browse/SONAR-4309 conflictResolver.resolve(issue, mapper); } }
@Test public void scrollClosedByComponentUuid_returns_empty_when_no_issue_for_component() { String componentUuid = randomAlphabetic(10); RecorderResultHandler resultHandler = new RecorderResultHandler(); underTest.scrollClosedByComponentUuid(componentUuid, new Date().getTime(), resultHandler); assertThat(resultHandler.issues).isEmpty(); }
public Set<String> selectComponentUuidsOfOpenIssuesForProjectUuid(DbSession session, String projectUuid) { return mapper(session).selectComponentUuidsOfOpenIssuesForProjectUuid(projectUuid); }
private List<DefaultIssue> loadForComponentUuid(String componentUuid, DbSession dbSession) { List<DefaultIssue> result = new ArrayList<>(); dbSession.getMapper(IssueMapper.class).scrollNonClosedByComponentUuid(componentUuid, resultContext -> { DefaultIssue issue = (resultContext.getResultObject()).toDefaultIssue(); Rule rule = ruleRepository.getByKey(issue.ruleKey()); // TODO this field should be set outside this class if ((!rule.isExternal() && !isActive(issue.ruleKey())) || rule.getStatus() == RuleStatus.REMOVED) { issue.setOnDisabledRule(true); // TODO to be improved, why setOnDisabledRule(true) is not enough ? issue.setBeingClosed(true); } // FIXME issue.setSelectedAt(System.currentTimeMillis()); result.add(issue); }); return result; }
public void insert(DbSession session, IssueDto dto) { mapper(session).insert(dto); }
public void resolve(DefaultIssue issue, IssueDto dbIssue, IssueMapper mapper) { LOG.debug("Resolve conflict on issue {}", issue.key()); mergeFields(dbIssue, issue); mapper.update(IssueDto.toDtoForUpdate(issue, System.currentTimeMillis())); }
@Test @UseDataProvider("closedIssuesSupportedRuleTypes") public void scrollClosedByComponentUuid_returns_closed_issues_with_at_least_one_diff_to_CLOSED(RuleType ruleType) { OrganizationDto organization = dbTester.organizations().insert(); ComponentDto component = randomComponent(organization); IssueDto expected = insertNewClosedIssue(component, ruleType); IssueChangeDto changeDto = insertToClosedDiff(expected); RecorderResultHandler resultHandler = new RecorderResultHandler(); underTest.scrollClosedByComponentUuid(component.uuid(), NO_FILTERING_ON_CLOSE_DATE, resultHandler); assertThat(resultHandler.issues).hasSize(1); IssueDto issue = resultHandler.issues.iterator().next(); assertThat(issue.getKey()).isEqualTo(issue.getKey()); assertThat(issue.getClosedChangeData()).contains(changeDto.getChangeData()); }
public java.util.Optional<IssueDto> selectByKey(DbSession session, String key) { return java.util.Optional.ofNullable(mapper(session).selectByKey(key)); }
private void persistNewIssues(IssueStatistics statistics, List<DefaultIssue> addedIssues, IssueMapper mapper, IssueChangeMapper changeMapper) { if (addedIssues.isEmpty()) { return; } long now = system2.now(); addedIssues.forEach(i -> { int ruleId = ruleRepository.getByKey(i.ruleKey()).getId(); IssueDto dto = IssueDto.toDtoForComputationInsert(i, ruleId, now); mapper.insert(dto); statistics.inserts++; }); addedIssues.forEach(i -> issueStorage.insertChanges(changeMapper, i)); }
@Test public void should_reload_issue_and_resolve_conflict() { DefaultIssue issue = new DefaultIssue() .setKey("ABCDE") .setType(CODE_SMELL) .setRuleKey(RuleKey.of("squid", "AvoidCycles")) .setProjectUuid("U1") .setComponentUuid("U2") .setNew(false) .setStatus(STATUS_OPEN); // Issue as seen and changed by end-user IssueMapper mapper = mock(IssueMapper.class); IssueDto issueDto = new IssueDto() .setKee("ABCDE") .setType(CODE_SMELL) .setRuleId(10) .setRuleKey("squid", "AvoidCycles") .setProjectUuid("U1") .setComponentUuid("U2") .setLine(10) .setStatus(STATUS_OPEN) // field changed by user .setAssigneeUuid("arthur-uuid"); new UpdateConflictResolver().resolve(issue, issueDto, mapper); ArgumentCaptor<IssueDto> argument = ArgumentCaptor.forClass(IssueDto.class); verify(mapper).update(argument.capture()); IssueDto updatedIssue = argument.getValue(); assertThat(updatedIssue.getKee()).isEqualTo("ABCDE"); assertThat(updatedIssue.getAssigneeUuid()).isEqualTo("arthur-uuid"); }
@Test public void scrollClosedByComponentUuid_does_not_return_closed_issues_without_close_date() { RuleType ruleType = randomSupportedRuleType(); OrganizationDto organization = dbTester.organizations().insert(); ComponentDto component = randomComponent(organization); IssueDto issueWithoutCloseDate = insertNewClosedIssue(component, ruleType, t -> t.setIssueCloseDate(null)); insertToClosedDiff(issueWithoutCloseDate); IssueDto issueCloseDate = insertNewClosedIssue(component, ruleType); IssueChangeDto changeDto = insertToClosedDiff(issueCloseDate); RecorderResultHandler resultHandler = new RecorderResultHandler(); underTest.scrollClosedByComponentUuid(component.uuid(), NO_FILTERING_ON_CLOSE_DATE, resultHandler); assertThat(resultHandler.issues).hasSize(1); IssueDto issue = resultHandler.issues.iterator().next(); assertThat(issue.getKey()).isEqualTo(issue.getKey()); assertThat(issue.getClosedChangeData()).contains(changeDto.getChangeData()); }
@SafeVarargs private final IssueDto insertNewClosedIssue(ComponentDto component, RuleDefinitionDto rule, long issueCloseTime, Consumer<IssueDto>... consumers) { IssueDto res = new IssueDto() .setKee(UuidFactoryFast.getInstance().create()) .setRuleId(rule.getId()) .setType(rule.getType()) .setComponentUuid(component.uuid()) .setProjectUuid(component.projectUuid()) .setStatus(Issue.STATUS_CLOSED) .setIssueCloseTime(issueCloseTime); Arrays.asList(consumers).forEach(c -> c.accept(res)); underTest.insert(res); dbSession.commit(); return res; }