private void sendMyNewIssuesNotification(NewIssuesStatistics statistics, Component project, long analysisDate, NotificationStatistics notificationStatistics) { Map<String, UserDto> userDtoByUuid = loadUserDtoByUuid(statistics); statistics.getAssigneesStatistics().entrySet() .stream() .filter(e -> e.getValue().hasIssuesOnLeak()) .forEach(e -> { String assigneeUuid = e.getKey(); NewIssuesStatistics.Stats assigneeStatistics = e.getValue(); MyNewIssuesNotification myNewIssuesNotification = newIssuesNotificationFactory .newMyNewIssuesNotification() .setAssignee(userDtoByUuid.get(assigneeUuid)); myNewIssuesNotification .setProject(project.getKey(), project.getName(), getBranchName(), getPullRequest()) .setProjectVersion(project.getProjectAttributes().getVersion()) .setAnalysisDate(new Date(analysisDate)) .setStatistics(project.getName(), assigneeStatistics) .setDebt(Duration.create(assigneeStatistics.effort().getOnLeak())); notificationStatistics.myNewIssuesDeliveries += service.deliver(myNewIssuesNotification); notificationStatistics.myNewIssues++; }); }
@Test public void add_counts_issue_per_assignee_off_leak_globally_and_per_assignee() { List<String> assignees = IntStream.range(0, 1 + new Random().nextInt(10)).mapToObj(i -> randomAlphabetic(3)).collect(Collectors.toList()); assignees.stream() .map(assignee -> new DefaultIssue().setType(randomRuleTypeExceptHotspot).setAssigneeUuid(assignee).setNew(false)) .forEach(underTest::add); DistributedMetricStatsInt globalDistribution = underTest.globalStatistics().getDistributedMetricStats(Metric.ASSIGNEE); assignees.forEach(assignee -> assertStats(globalDistribution, assignee, 0, 1, 1)); assignees.forEach(assignee -> { NewIssuesStatistics.Stats stats = underTest.getAssigneesStatistics().get(assignee); DistributedMetricStatsInt assigneeStats = stats.getDistributedMetricStats(Metric.ASSIGNEE); assertThat(assigneeStats.getOnLeak()).isEqualTo(0); assertThat(assigneeStats.getTotal()).isEqualTo(1); assignees.forEach(s -> { Optional<MetricStatsInt> forLabelOpts = assigneeStats.getForLabel(s); if (s.equals(assignee)) { assertThat(forLabelOpts.isPresent()).isTrue(); MetricStatsInt forLabel = forLabelOpts.get(); assertThat(forLabel.getOnLeak()).isEqualTo(0); assertThat(forLabel.getTotal()).isEqualTo(1); } else { assertThat(forLabelOpts.isPresent()).isFalse(); } }); }); }
private void setRuleStatistics(DbSession dbSession, NewIssuesStatistics.Stats stats) { Metric metric = Metric.RULE; List<Map.Entry<String, MetricStatsInt>> fiveBiggest = fiveBiggest(stats.getDistributedMetricStats(metric), MetricStatsInt::getOnLeak); Set<RuleKey> ruleKeys = fiveBiggest .stream() .map(Map.Entry::getKey) .map(RuleKey::parse) .collect(MoreCollectors.toSet(fiveBiggest.size())); Map<String, RuleDefinitionDto> ruleByRuleKey = dbClient.ruleDao().selectDefinitionByKeys(dbSession, ruleKeys) .stream() .collect(MoreCollectors.uniqueIndex(s -> s.getKey().toString())); int i = 1; for (Map.Entry<String, MetricStatsInt> ruleStats : fiveBiggest) { String ruleKey = ruleStats.getKey(); RuleDefinitionDto rule = Optional.ofNullable(ruleByRuleKey.get(ruleKey)) .orElseThrow(() -> new RowNotFoundException(String.format("Rule with key '%s' does not exist", ruleKey))); String name = rule.getName() + " (" + rule.getLanguage() + ")"; setFieldValue(metric + DOT + i + LABEL, name); setFieldValue(metric + DOT + i + COUNT, String.valueOf(ruleStats.getValue().getOnLeak())); i++; } }
private void setComponentsStatistics(DbSession dbSession, NewIssuesStatistics.Stats stats) { Metric metric = Metric.COMPONENT; int i = 1; List<Map.Entry<String, MetricStatsInt>> fiveBiggest = fiveBiggest(stats.getDistributedMetricStats(metric), MetricStatsInt::getOnLeak); Set<String> componentUuids = fiveBiggest .stream() .map(Map.Entry::getKey) .collect(MoreCollectors.toSet(fiveBiggest.size())); Map<String, ComponentDto> componentDtosByUuid = dbClient.componentDao().selectByUuids(dbSession, componentUuids) .stream() .collect(MoreCollectors.uniqueIndex(ComponentDto::uuid)); for (Map.Entry<String, MetricStatsInt> componentStats : fiveBiggest) { String uuid = componentStats.getKey(); String componentName = Optional.ofNullable(componentDtosByUuid.get(uuid)) .map(ComponentDto::name) .orElseThrow(() -> new RowNotFoundException(String.format("Component with uuid '%s' not found", uuid))); setFieldValue(metric + DOT + i + LABEL, componentName); setFieldValue(metric + DOT + i + COUNT, String.valueOf(componentStats.getValue().getOnLeak())); i++; } }
private void sendNewIssuesNotificationToAssignees(NewIssuesStatistics statistics, Component project, long analysisDate) { Map<String, UserDto> userDtoByUuid = loadUserDtoByUuid(statistics); statistics.getAssigneesStatistics().entrySet() .stream() .filter(e -> e.getValue().hasIssuesOnLeak()) .forEach(e -> { String assigneeUuid = e.getKey(); NewIssuesStatistics.Stats assigneeStatistics = e.getValue(); MyNewIssuesNotification myNewIssuesNotification = newIssuesNotificationFactory .newMyNewIssuesNotification() .setAssignee(userDtoByUuid.get(assigneeUuid)); myNewIssuesNotification .setProject(project.getPublicKey(), project.getName(), getBranchName(), getPullRequest()) .setProjectVersion(project.getReportAttributes().getVersion()) .setAnalysisDate(new Date(analysisDate)) .setStatistics(project.getName(), assigneeStatistics) .setDebt(Duration.create(assigneeStatistics.effort().getOnLeak())); service.deliver(myNewIssuesNotification); }); }
private void setAssigneesStatistics(DbSession dbSession, NewIssuesStatistics.Stats stats) { Metric metric = Metric.ASSIGNEE; List<Map.Entry<String, MetricStatsInt>> entries = fiveBiggest(stats.getDistributedMetricStats(metric), MetricStatsInt::getOnLeak); Set<String> assigneeUuids = entries.stream().map(Map.Entry::getKey).filter(Objects::nonNull).collect(toSet()); Map<String, UserDto> userDtoByUuid = dbClient.userDao().selectByUuids(dbSession, assigneeUuids).stream().collect(toMap(UserDto::getUuid, u -> u)); int i = 1; for (Map.Entry<String, MetricStatsInt> assigneeStats : entries) { String assigneeUuid = assigneeStats.getKey(); UserDto user = userDtoByUuid.get(assigneeUuid); String name = user == null ? assigneeUuid : user.getName(); setFieldValue(metric + DOT + i + LABEL, name); setFieldValue(metric + DOT + i + COUNT, String.valueOf(assigneeStats.getValue().getOnLeak())); i++; } }
public boolean hasIssues() { return getDistributedMetricStats(RULE_TYPE).getTotal() > 0; }
public boolean hasIssues() { return globalStatistics.hasIssues(); }
public boolean hasIssuesOffLeak() { return getDistributedMetricStats(RULE_TYPE).getOffLeak() > 0; }
public boolean hasIssuesOnLeak() { return getDistributedMetricStats(RULE_TYPE).getOnLeak() > 0; }
public boolean hasIssuesOnLeak() { return globalStatistics.hasIssuesOnLeak(); }
public NewIssuesStatistics(Predicate<DefaultIssue> onLeakPredicate) { this.onLeakPredicate = onLeakPredicate; this.globalStatistics = new Stats(onLeakPredicate); }
public boolean hasIssuesOffLeak() { return globalStatistics.hasIssuesOffLeak(); }
private void setRuleTypeStatistics(NewIssuesStatistics.Stats stats) { DistributedMetricStatsInt distributedMetricStats = stats.getDistributedMetricStats(RULE_TYPE); setFieldValue(RULE_TYPE + COUNT, String.valueOf(distributedMetricStats.getOnLeak())); Arrays.stream(RuleType.values()) .forEach(ruleType -> setFieldValue( RULE_TYPE + DOT + ruleType + COUNT, String.valueOf(distributedMetricStats.getForLabel(ruleType.name()).map(MetricStatsInt::getOnLeak).orElse(0)))); }
public NewIssuesNotification setStatistics(String projectName, NewIssuesStatistics.Stats stats) { setDefaultMessage(stats.getDistributedMetricStats(RULE_TYPE).getOnLeak() + " new issues on " + projectName + ".\n"); try (DbSession dbSession = dbClient.openSession(false)) { setRuleTypeStatistics(stats); setAssigneesStatistics(dbSession, stats); setTagsStatistics(stats); setComponentsStatistics(dbSession, stats); setRuleStatistics(dbSession, stats); } return this; }
private void sendNewIssuesNotification(NewIssuesStatistics statistics, Component project, long analysisDate) { NewIssuesStatistics.Stats globalStatistics = statistics.globalStatistics(); NewIssuesNotification notification = newIssuesNotificationFactory .newNewIssuesNotification() .setProject(project.getPublicKey(), project.getName(), getBranchName(), getPullRequest()) .setProjectVersion(project.getReportAttributes().getVersion()) .setAnalysisDate(new Date(analysisDate)) .setStatistics(project.getName(), globalStatistics) .setDebt(Duration.create(globalStatistics.effort().getOnLeak())); service.deliver(notification); }
private Map<String, UserDto> loadUserDtoByUuid(NewIssuesStatistics statistics) { List<Map.Entry<String, NewIssuesStatistics.Stats>> entriesWithIssuesOnLeak = statistics.getAssigneesStatistics().entrySet() .stream().filter(e -> e.getValue().hasIssuesOnLeak()).collect(toList()); List<String> assigneeUuids = entriesWithIssuesOnLeak.stream().map(Map.Entry::getKey).collect(toList()); try (DbSession dbSession = dbClient.openSession(false)) { return dbClient.userDao().selectByUuids(dbSession, assigneeUuids).stream().collect(toMap(UserDto::getUuid, u -> u)); } }
private void setTagsStatistics(NewIssuesStatistics.Stats stats) { Metric metric = Metric.TAG; int i = 1; for (Map.Entry<String, MetricStatsInt> tagStats : fiveBiggest(stats.getDistributedMetricStats(metric), MetricStatsInt::getOnLeak)) { setFieldValue(metric + DOT + i + COUNT, String.valueOf(tagStats.getValue().getOnLeak())); setFieldValue(metric + DOT + i + LABEL, tagStats.getKey()); i++; } }