private void resolveAssignee(IssueDto dbIssue, DefaultIssue issue) { issue.setAssigneeUuid(dbIssue.getAssigneeUuid()); } }
void collect(List<IssueDto> issues) { for (IssueDto issue : issues) { componentUuids.add(issue.getComponentUuid()); projectUuids.add(issue.getProjectUuid()); ruleIds.add(issue.getRuleId()); String issueAssigneeUuid = issue.getAssigneeUuid(); if (issueAssigneeUuid != null) { userUuids.add(issueAssigneeUuid); } collectComponentsFromIssueLocations(issue); } }
private void checkIssueAssignee(String issueKey, @Nullable String expectedAssignee) { IssueDto issueReloaded = dbClient.issueDao().selectByKey(db.getSession(), issueKey).get(); assertThat(issueReloaded.getAssigneeUuid()).isEqualTo(expectedAssignee); assertThat(issueReloaded.getIssueUpdateTime()).isEqualTo(NOW); assertThat(issueReloaded.getUpdatedAt()).isEqualTo(NOW); } }
.filter(issue -> issue.getAssigneeUuid() != null) .map(IssueDto::getAssigneeUuid) .collect(toList()); issue.setAssigneeUuid(userLoginsByUserUuids.get(issue.getAssigneeUuid())); handleIssue(issue, responseBuilder, keysByUUid, output); });
private static void handleIssue(IssueDto issue, ScannerInput.ServerIssue.Builder issueBuilder, Map<String, String> keysByUUid, OutputStream out) { issueBuilder.setKey(issue.getKey()); String moduleUuid = extractModuleUuid(issue); issueBuilder.setModuleKey(keysByUUid.get(moduleUuid)); ofNullable(issue.getFilePath()).ifPresent(issueBuilder::setPath); issueBuilder.setRuleRepository(issue.getRuleRepo()); issueBuilder.setRuleKey(issue.getRule()); ofNullable(issue.getChecksum()).ifPresent(issueBuilder::setChecksum); ofNullable(issue.getAssigneeUuid()).ifPresent(issueBuilder::setAssigneeLogin); ofNullable(issue.getLine()).ifPresent(issueBuilder::setLine); ofNullable(issue.getMessage()).ifPresent(issueBuilder::setMsg); issueBuilder.setSeverity(org.sonar.scanner.protocol.Constants.Severity.valueOf(issue.getSeverity())); issueBuilder.setManualSeverity(issue.isManualSeverity()); issueBuilder.setStatus(issue.getStatus()); ofNullable(issue.getResolution()).ifPresent(issueBuilder::setResolution); issueBuilder.setType(RuleType.valueOf(issue.getType()).name()); issueBuilder.setCreationDate(issue.getIssueCreationTime()); try { issueBuilder.build().writeDelimitedTo(out); } catch (IOException e) { throw new IllegalStateException("Unable to serialize issue", e); } issueBuilder.clear(); }
@Test public void should_not_sort_with_null_sort() { IssueDto issue1 = new IssueDto().setId(1L).setAssigneeUuid("perceval"); IssueDto issue2 = new IssueDto().setId(2L).setAssigneeUuid("arthur"); IssueDto issue3 = new IssueDto().setId(3L).setAssigneeUuid("vincent"); IssueDto issue4 = new IssueDto().setId(4L).setAssigneeUuid(null); List<IssueDto> dtoList = newArrayList(issue1, issue2, issue3, issue4); IssueQuery query = IssueQuery.builder().sort(null).build(); IssuesFinderSort issuesFinderSort = new IssuesFinderSort(dtoList, query); List<IssueDto> result = newArrayList(issuesFinderSort.sort()); assertThat(result).hasSize(4); assertThat(result.get(0).getAssigneeUuid()).isEqualTo("perceval"); assertThat(result.get(1).getAssigneeUuid()).isEqualTo("arthur"); assertThat(result.get(2).getAssigneeUuid()).isEqualTo("vincent"); assertThat(result.get(3).getAssigneeUuid()).isNull(); }
ofNullable(data.getUserByUuid(dto.getAssigneeUuid())).ifPresent(assignee -> issueBuilder.setAssignee(assignee.getLogin())); ofNullable(emptyToNull(dto.getResolution())).ifPresent(issueBuilder::setResolution); issueBuilder.setStatus(dto.getStatus());
@Test public void assign_to_me() { IssueDto issue = newIssueWithBrowsePermission(); ws.newRequest() .setParam("issue", issue.getKey()) .setParam("assignee", "_me") .execute(); checkIssueAssignee(issue.getKey(), CURRENT_USER_UUID); Optional<IssueDto> optionalIssueDto = dbClient.issueDao().selectByKey(session, issue.getKey()); assertThat(optionalIssueDto).isPresent(); assertThat(optionalIssueDto.get().getAssigneeUuid()).isEqualTo(CURRENT_USER_UUID); assertThat(issueChangePostProcessor.wasCalled()).isFalse(); }
@Test public void unassign() { IssueDto issue = newIssueWithBrowsePermission(); ws.newRequest() .setParam("issue", issue.getKey()) .execute(); checkIssueAssignee(issue.getKey(), null); Optional<IssueDto> optionalIssueDto = dbClient.issueDao().selectByKey(session, issue.getKey()); assertThat(optionalIssueDto).isPresent(); assertThat(optionalIssueDto.get().getAssigneeUuid()).isNull(); assertThat(issueChangePostProcessor.wasCalled()).isFalse(); }
@Test public void nothing_to_do_when_new_assignee_is_same_as_old_one() { UserDto user = insertUser("Bob"); IssueDto issue = newIssue(user.getUuid()); setUserWithBrowsePermission(issue); ws.newRequest() .setParam("issue", issue.getKey()) .setParam("assignee", user.getLogin()) .execute(); IssueDto issueReloaded = dbClient.issueDao().selectByKey(db.getSession(), issue.getKey()).get(); assertThat(issueReloaded.getAssigneeUuid()).isEqualTo(user.getUuid()); assertThat(issueReloaded.getUpdatedAt()).isEqualTo(PAST); assertThat(issueReloaded.getIssueUpdateTime()).isEqualTo(PAST); }
@Test public void assign_to_me_using_deprecated_me_param() { IssueDto issue = newIssueWithBrowsePermission(); ws.newRequest() .setParam("issue", issue.getKey()) .setParam("me", "true") .execute(); checkIssueAssignee(issue.getKey(), CURRENT_USER_UUID); Optional<IssueDto> optionalIssueDto = dbClient.issueDao().selectByKey(session, issue.getKey()); assertThat(optionalIssueDto).isPresent(); assertThat(optionalIssueDto.get().getAssigneeUuid()).isEqualTo(CURRENT_USER_UUID); }
@Test public void unassign_with_empty_assignee_param() { IssueDto issue = newIssueWithBrowsePermission(); ws.newRequest() .setParam("issue", issue.getKey()) .setParam("assignee", "") .execute(); checkIssueAssignee(issue.getKey(), null); Optional<IssueDto> optionalIssueDto = dbClient.issueDao().selectByKey(session, issue.getKey()); assertThat(optionalIssueDto).isPresent(); assertThat(optionalIssueDto.get().getAssigneeUuid()).isNull(); assertThat(issueChangePostProcessor.wasCalled()).isFalse(); }
@Test public void assign_to_someone() { IssueDto issue = newIssueWithBrowsePermission(); UserDto arthur = insertUser("arthur"); ws.newRequest() .setParam("issue", issue.getKey()) .setParam("assignee", "arthur") .execute(); checkIssueAssignee(issue.getKey(), arthur.getUuid()); Optional<IssueDto> optionalIssueDto = dbClient.issueDao().selectByKey(session, issue.getKey()); assertThat(optionalIssueDto).isPresent(); assertThat(optionalIssueDto.get().getAssigneeUuid()).isEqualTo(arthur.getUuid()); assertThat(issueChangePostProcessor.wasCalled()).isFalse(); }
assertThat(doc.getId()).isEqualTo(issue.getKey()); assertThat(doc.organizationUuid()).isEqualTo(organization.getUuid()); assertThat(doc.assigneeUuid()).isEqualTo(issue.getAssigneeUuid()); assertThat(doc.authorLogin()).isEqualTo(issue.getAuthorLogin()); assertThat(doc.componentUuid()).isEqualTo(file.uuid());
@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 remove_assignee() { UserDto user = db.users().insertUser(); userSession.logIn(user); ComponentDto project = db.components().insertPrivateProject(); ComponentDto file = db.components().insertComponent(newFileDto(project)); addUserProjectPermissions(user, project, USER, ISSUE_ADMIN); RuleDefinitionDto rule = db.rules().insert(); UserDto assignee = db.users().insertUser(); IssueDto issue = db.issues().insert(rule, project, file, i -> i.setAssigneeUuid(assignee.getUuid()) .setStatus(STATUS_OPEN).setResolution(null)); BulkChangeWsResponse response = call(builder() .setIssues(singletonList(issue.getKey())) .setAssign("") .build()); checkResponse(response, 1, 1, 0, 0); IssueDto reloaded = getIssueByKeys(issue.getKey()).get(0); assertThat(reloaded.getAssigneeUuid()).isNull(); assertThat(reloaded.getUpdatedAt()).isEqualTo(NOW); // no need to refresh measures verifyPostProcessorNotCalled(); }
private void resolveAssignee(IssueDto dbIssue, DefaultIssue issue) { issue.setAssigneeUuid(dbIssue.getAssigneeUuid()); } }
void collect(List<IssueDto> issues) { for (IssueDto issue : issues) { componentUuids.add(issue.getComponentUuid()); projectUuids.add(issue.getProjectUuid()); ruleIds.add(issue.getRuleId()); add(USERS, issue.getAssigneeUuid()); collectComponentsFromIssueLocations(issue); } }
private void loadUsers(SearchResponseData preloadedResponseData, Collector collector, DbSession dbSession, SearchResponseData result, @Nullable Facets facets) { Set<String> usersUuidToLoad = new HashSet<>(); // logged in user ofNullable(userSession.getUuid()).ifPresent(usersUuidToLoad::add); // add from issues (uuid -> login) result.getIssues().forEach(issue -> ofNullable(issue.getAssigneeUuid()).ifPresent(usersUuidToLoad::add)); // add from facets (uuid -> login) if (facets != null) { getAssigneesFacet(facets).forEach((key, value) -> usersUuidToLoad.add(key)); } // from facets if (collector.contains(USERS)) { usersUuidToLoad.addAll(collector.get(USERS)); } List<UserDto> preloadedUsers = firstNonNull(preloadedResponseData.getUsers(), emptyList()); result.addUsers(preloadedUsers); preloadedUsers.forEach(userDto -> usersUuidToLoad.remove(userDto.getUuid())); result.addUsers(dbClient.userDao().selectByUuids(dbSession, usersUuidToLoad)); }
private static void handleIssue(IssueDto issue, ScannerInput.ServerIssue.Builder issueBuilder, Map<String, String> keysByUUid, OutputStream out) { issueBuilder.setKey(issue.getKey()); String moduleUuid = extractModuleUuid(issue); issueBuilder.setModuleKey(keysByUUid.get(moduleUuid)); setNullable(issue.getFilePath(), issueBuilder::setPath); issueBuilder.setRuleRepository(issue.getRuleRepo()); issueBuilder.setRuleKey(issue.getRule()); setNullable(issue.getChecksum(), issueBuilder::setChecksum); setNullable(issue.getAssigneeUuid(), issueBuilder::setAssigneeLogin); setNullable(issue.getLine(), issueBuilder::setLine); setNullable(issue.getMessage(), issueBuilder::setMsg); issueBuilder.setSeverity(org.sonar.scanner.protocol.Constants.Severity.valueOf(issue.getSeverity())); issueBuilder.setManualSeverity(issue.isManualSeverity()); issueBuilder.setStatus(issue.getStatus()); setNullable(issue.getResolution(), issueBuilder::setResolution); issueBuilder.setType(RuleType.valueOf(issue.getType()).name()); issueBuilder.setCreationDate(issue.getIssueCreationTime()); try { issueBuilder.build().writeDelimitedTo(out); } catch (IOException e) { throw new IllegalStateException("Unable to serialize issue", e); } issueBuilder.clear(); }