@Override public boolean matches(Issue issue) { return types.contains(((DefaultIssue) issue).type()); } }
@Override public boolean matches(Issue issue) { return ((DefaultIssue) issue).type() != RuleType.SECURITY_HOTSPOT && !((DefaultIssue) issue).isFromHotspot(); } }
@Override public boolean matches(Issue issue) { return ((DefaultIssue) issue).type() == RuleType.VULNERABILITY && ((DefaultIssue) issue).isFromHotspot(); } }
private void fillExistingOpenIssues(Component component, Map<DefaultIssue, DefaultIssue> matched, DiskCache<DefaultIssue>.DiskAppender cacheAppender) { for (Map.Entry<DefaultIssue, DefaultIssue> entry : matched.entrySet()) { DefaultIssue raw = entry.getKey(); DefaultIssue base = entry.getValue(); issueLifecycle.mergeExistingOpenIssue(raw, base); if (analysisMetadataHolder.isLongLivingBranch() || raw.type() != RuleType.SECURITY_HOTSPOT) { process(component, raw, cacheAppender); } } }
private ChangedIssueImpl(DefaultIssue issue) { this.key = issue.key(); this.status = statusOf(issue); this.type = issue.type(); }
void add(DefaultIssue issue, Period period) { long newEffort = calculate(issue, period); switch (issue.type()) { case CODE_SMELL: maintainabilitySum.add(newEffort); break; case BUG: reliabilitySum.add(newEffort); break; case VULNERABILITY: securitySum.add(newEffort); break; case SECURITY_HOTSPOT: // Not counted break; default: throw new IllegalStateException(String.format("Unknown type '%s'", issue.type())); } }
public AssignAction(DbClient dbClient, IssueFieldsSetter issueFieldsSetter) { super(ASSIGN_KEY); this.dbClient = dbClient; this.issueFieldsSetter = issueFieldsSetter; super.setConditions(new IsUnResolved(), issue -> ((DefaultIssue) issue).type() != RuleType.SECURITY_HOTSPOT); }
public boolean setType(DefaultIssue issue, RuleType type, IssueChangeContext context) { if (!Objects.equals(type, issue.type())) { issue.setFieldChange(context, TYPE, issue.type(), type); issue.setType(type); issue.setUpdateDate(context.date()); issue.setChanged(true); return true; } return false; }
private boolean isCurrentUserIssueAdminAndNotSecurityHotspot(Issue issue) { DefaultIssue defaultIssue = (DefaultIssue) issue; return (defaultIssue.type() != RuleType.SECURITY_HOTSPOT && userSession.hasComponentUuidPermission(ISSUE_ADMIN, issue.projectUuid())); }
private void processIssues(Component component, Path<Counter> path) { componentIssuesRepository.getIssues(component) .stream() .filter(issue -> issue.resolution() == null) .filter(issue -> issue.type().equals(BUG) || issue.type().equals(VULNERABILITY)) .forEach(issue -> path.current().processIssue(issue, periodHolder.getPeriod())); }
private void processIssues(Component component, Path<Counter> path) { componentIssuesRepository.getIssues(component) .stream() .filter(issue -> issue.resolution() == null) .forEach(issue -> { Rating rating = RATING_BY_SEVERITY.get(issue.severity()); if (issue.type().equals(BUG)) { path.current().ratingValueByMetric.get(RELIABILITY_RATING_KEY).increment(rating); } else if (issue.type().equals(VULNERABILITY)) { path.current().ratingValueByMetric.get(SECURITY_RATING_KEY).increment(rating); } }); }
private Consumer<DefaultIssue> sendNotification(BulkChangeData bulkChangeData, Map<String, UserDto> userDtoByUuid, UserDto author) { return issue -> { if (bulkChangeData.sendNotification && issue.type() != RuleType.SECURITY_HOTSPOT) { notificationService.scheduleForSending(new IssueChangeNotification() .setIssue(issue) .setAssignee(userDtoByUuid.get(issue.assignee())) .setChangeAuthor(author) .setRuleName(bulkChangeData.rulesByKey.get(issue.ruleKey()).getName()) .setProject(bulkChangeData.projectsByUuid.get(issue.projectUuid())) .setComponent(bulkChangeData.componentsByUuid.get(issue.componentUuid()))); } }; }
private SearchResponseData assign(String issueKey, @Nullable String login) { try (DbSession dbSession = dbClient.openSession(false)) { IssueDto issueDto = issueFinder.getByKey(dbSession, issueKey); DefaultIssue issue = issueDto.toDefaultIssue(); checkArgument(issue.type() != RuleType.SECURITY_HOTSPOT,"It is not allowed to assign a security hotspot"); UserDto user = getUser(dbSession, login); if (user != null) { checkMembership(dbSession, issueDto, user); } IssueChangeContext context = IssueChangeContext.createUser(new Date(system2.now()), userSession.getUuid()); if (issueFieldsSetter.assign(issue, user, context)) { return issueUpdater.saveIssueAndPreloadSearchResponseData(dbSession, issue, context, null, false); } return new SearchResponseData(issueDto); } }
private void setType(DefaultIssue issue) { if (!issue.isFromExternalRuleEngine()) { Rule rule = ruleRepository.getByKey(issue.ruleKey()); issue.setType(rule.getType()); } issue.setIsFromHotspot(issue.type() == RuleType.SECURITY_HOTSPOT); }
@Override public void onIssue(Component component, DefaultIssue issue) { if (issue.type() == RuleType.SECURITY_HOTSPOT) { return; } currentCounters.add(issue); if (!periodHolder.hasPeriod()) { return; } Period period = periodHolder.getPeriod(); // Add one second to not take into account issues created during current analysis if (issue.creationDate().getTime() > truncateToSeconds(period.getSnapshotDate())) { currentCounters.addOnPeriod(issue); } }
private void verifyListenerCalled(QGChangeEventListener listener, QGChangeEvent changeEvent, DefaultIssue... issues) { ArgumentCaptor<Set<ChangedIssue>> changedIssuesCaptor = newSetCaptor(); verify(listener).onIssueChanges(same(changeEvent), changedIssuesCaptor.capture()); Set<ChangedIssue> changedIssues = changedIssuesCaptor.getValue(); Tuple[] expected = Arrays.stream(issues) .map(issue -> tuple(issue.key(), ChangedIssueImpl.statusOf(issue), issue.type())) .toArray(Tuple[]::new); assertThat(changedIssues) .hasSize(issues.length) .extracting(ChangedIssue::getKey, t -> t.getStatus(), ChangedIssue::getType) .containsOnly(expected); }
public void initNewOpenIssue(DefaultIssue issue) { Preconditions.checkArgument(issue.isFromExternalRuleEngine() != (issue.type() == null), "At this stage issue type should be set for and only for external issues"); issue.setKey(Uuids.create()); issue.setCreationDate(changeContext.date()); issue.setUpdateDate(changeContext.date()); issue.setStatus(Issue.STATUS_OPEN); issue.setEffort(debtCalculator.calculate(issue)); setType(issue); }
@Test public void set_type() { IssueDto issueDto = newIssue().setType(BUG); DefaultIssue issue = issueDto.toDefaultIssue(); setUserWithBrowseAndAdministerIssuePermission(issueDto); action.execute(ImmutableMap.of("type", VULNERABILITY.name()), new BulkChangeAction.ActionContext(issue, IssueChangeContext.createUser(NOW, userSession.getUuid()), null)); assertThat(issue.type()).isEqualTo(VULNERABILITY); assertThat(issue.isChanged()).isTrue(); assertThat(issue.updateDate()).isEqualTo(NOW); assertThat(issue.mustSendNotifications()).isFalse(); Map<String, FieldDiffs.Diff> change = issue.currentChange().diffs(); assertThat(change.get("type").newValue()).isEqualTo(VULNERABILITY); assertThat(change.get("type").oldValue()).isEqualTo(BUG); }
private void processIssues(NewIssuesStatistics newIssuesStats, CloseableIterator<DefaultIssue> issues, Component project, Map<String, UserDto> usersDtoByUuids, NotificationStatistics notificationStatistics) { while (issues.hasNext()) { DefaultIssue issue = issues.next(); if (issue.type() != RuleType.SECURITY_HOTSPOT) { if (issue.isNew() && issue.resolution() == null) { newIssuesStats.add(issue); } else if (issue.isChanged() && issue.mustSendNotifications()) { sendIssueChangeNotification(issue, project, usersDtoByUuids, notificationStatistics); } } } }
private void copyFields(DefaultIssue toIssue, DefaultIssue fromIssue) { toIssue.setType(fromIssue.type()); toIssue.setCreationDate(fromIssue.creationDate()); toIssue.setUpdateDate(fromIssue.updateDate()); toIssue.setCloseDate(fromIssue.closeDate()); toIssue.setResolution(fromIssue.resolution()); toIssue.setStatus(fromIssue.status()); toIssue.setAssigneeUuid(fromIssue.assignee()); toIssue.setAuthorLogin(fromIssue.authorLogin()); toIssue.setTags(fromIssue.tags()); toIssue.setAttributes(fromIssue.attributes()); toIssue.setEffort(debtCalculator.calculate(toIssue)); toIssue.setOnDisabledRule(fromIssue.isOnDisabledRule()); toIssue.setSelectedAt(fromIssue.selectedAt()); } }