private static void validateErrorThresholdValue(MetricDto metric, String errorThreshold, List<String> errors) { try { ValueType valueType = ValueType.valueOf(metric.getValueType()); switch (valueType) { case BOOL: case INT: case RATING: parseInt(errorThreshold); return; case MILLISEC: case WORK_DUR: parseLong(errorThreshold); return; case FLOAT: case PERCENT: parseDouble(errorThreshold); return; case STRING: case LEVEL: return; default: throw new IllegalArgumentException(format("Unsupported value type %s. Cannot convert condition value", valueType)); } } catch (Exception e) { errors.add(format("Invalid value '%s' for metric '%s'", errorThreshold, metric.getShortName())); } }
private static String measureValue(CustomMeasureDto measure, MetricDto metric) { Metric.ValueType metricType = Metric.ValueType.valueOf(metric.getValueType()); Double doubleValue = measure.getValue(); String stringValue = measure.getTextValue(); switch (metricType) { case BOOL: return doubleValue == 1.0d ? "true" : "false"; case INT: case MILLISEC: return String.valueOf(doubleValue.intValue()); case WORK_DUR: return String.valueOf(doubleValue.longValue()); case FLOAT: case PERCENT: case RATING: return String.valueOf(doubleValue); case LEVEL: case STRING: case DATA: case DISTRIB: return stringValue; default: throw new IllegalArgumentException("Unsupported metric type: " + metricType.name()); } }
private static boolean isAlertable(MetricDto metric) { return !metric.isHidden() && VALID_METRIC_TYPES.contains(ValueType.valueOf(metric.getValueType())) && !CoreMetrics.ALERT_STATUS_KEY.equals(metric.getKey()); }
public void setMeasureValue(CustomMeasureDto measure, String valueAsString, MetricDto metric) { Metric.ValueType metricType = Metric.ValueType.valueOf(metric.getValueType()); switch (metricType) { case BOOL: checkAndSetBooleanMeasureValue(measure, valueAsString); break; case INT: case MILLISEC: checkAndSetIntegerMeasureValue(measure, valueAsString); break; case WORK_DUR: checkAndSetLongMeasureValue(measure, valueAsString); break; case FLOAT: case PERCENT: case RATING: checkAndSetFloatMeasureValue(measure, valueAsString); break; case LEVEL: checkAndSetLevelMeasureValue(measure, valueAsString); break; case STRING: case DATA: case DISTRIB: measure.setTextValue(valueAsString); break; default: throw new IllegalArgumentException("Unsupported metric type:" + metricType.name()); } }
static String formatNumericalValue(double value, MetricDto metric) { Metric.ValueType metricType = Metric.ValueType.valueOf(metric.getValueType()); switch (metricType) { case BOOL: return formatBoolean(value); case INT: return formatInteger(value); case MILLISEC: case WORK_DUR: return formatLong(value); case FLOAT: case PERCENT: case RATING: return String.valueOf(value); case LEVEL: case STRING: case DATA: case DISTRIB: default: throw new IllegalArgumentException(String.format("Unsupported metric type '%s' for numerical value", metricType.name())); } }
static String formatMeasureValue(double doubleValue, @Nullable String stringValue, MetricDto metric) { Metric.ValueType metricType = Metric.ValueType.valueOf(metric.getValueType()); switch (metricType) { case BOOL: return formatBoolean(doubleValue); case INT: return formatInteger(doubleValue); case MILLISEC: case WORK_DUR: return formatLong(doubleValue); case FLOAT: case PERCENT: case RATING: return String.valueOf(doubleValue); case LEVEL: case STRING: case DATA: case DISTRIB: return stringValue; default: throw new IllegalArgumentException("Unsupported metric type: " + metricType.name()); } }
private void loadFromPaginatedWs(List<Metric> metrics) throws IOException { int page = 1; WsMetricsResponse response; do { GetRequest getRequest = new GetRequest(METRICS_SEARCH_URL + page); try (Reader reader = wsClient.call(getRequest).contentReader()) { response = GsonHelper.create().fromJson(reader, WsMetricsResponse.class); for (WsMetric metric : response.metrics) { metrics.add(new Metric.Builder(metric.getKey(), metric.getName(), ValueType.valueOf(metric.getType())) .create() .setDirection(metric.getDirection()) .setQualitative(metric.isQualitative()) .setUserManaged(metric.isCustom()) .setDescription(metric.getDescription()) .setId(metric.getId())); } } page++; } while (response.getP() < (response.getTotal() / response.getPs() + 1)); }
private static MetricDto newMetricTemplate(Request request) { String key = checkMetricKeyFormat(request.mandatoryParam(PARAM_KEY)); String name = request.mandatoryParam(PARAM_NAME); String type = Metric.ValueType.valueOf(request.mandatoryParam(PARAM_TYPE)).name(); String domain = request.param(PARAM_DOMAIN); String description = request.param(PARAM_DESCRIPTION); MetricDto metricTemplate = new MetricDto() .setKey(key) .setShortName(name) .setValueType(type); if (domain != null) { metricTemplate.setDomain(domain); } if (description != null) { metricTemplate.setDescription(description); } return metricTemplate; }
private static Ordering<ComponentDto> metricValueOrdering(ComponentTreeRequest wsRequest, List<MetricDto> metrics, Table<String, MetricDto, ComponentTreeData.Measure> measuresByComponentUuidAndMetric) { if (wsRequest.getMetricSort() == null) { return componentNameOrdering(wsRequest.getAsc()); } Map<String, MetricDto> metricsByKey = Maps.uniqueIndex(metrics, MetricDto::getKey); MetricDto metric = metricsByKey.get(wsRequest.getMetricSort()); boolean isAscending = wsRequest.getAsc(); ValueType metricValueType = ValueType.valueOf(metric.getValueType()); if (NUMERIC_VALUE_TYPES.contains(metricValueType)) { return numericalMetricOrdering(isAscending, metric, measuresByComponentUuidAndMetric); } else if (TEXTUAL_VALUE_TYPES.contains(metricValueType)) { return stringOrdering(isAscending, new ComponentDtoToTextualMeasureValue(metric, measuresByComponentUuidAndMetric)); } else if (ValueType.LEVEL.equals(ValueType.valueOf(metric.getValueType()))) { return levelMetricOrdering(isAscending, metric, measuresByComponentUuidAndMetric); } throw new IllegalStateException("Unrecognized metric value type: " + metric.getValueType()); }
private String generateSvg(MetricDto metric, LiveMeasureDto measure) { String metricType = metric.getValueType(); switch (ValueType.valueOf(metricType)) { case INT: return generateBadge(metric, formatNumeric(getNonNullValue(measure, LiveMeasureDto::getValue).longValue()), Color.DEFAULT); case PERCENT: return generateBadge(metric, formatPercent(getNonNullValue(measure, LiveMeasureDto::getValue)), Color.DEFAULT); case LEVEL: return generateQualityGate(metric, measure); case WORK_DUR: return generateBadge(metric, formatDuration(getNonNullValue(measure, LiveMeasureDto::getValue).longValue()), Color.DEFAULT); case RATING: return generateRating(metric, measure); default: throw new IllegalStateException(format("Invalid metric type '%s'", metricType)); } }
@Override public Metric apply(@Nonnull MetricDto dto) { Metric<Serializable> metric = new Metric<>(); metric.setId(dto.getId()); metric.setKey(dto.getKey()); metric.setDescription(dto.getDescription()); metric.setName(dto.getShortName()); metric.setBestValue(dto.getBestValue()); metric.setDomain(dto.getDomain()); metric.setEnabled(dto.isEnabled()); metric.setDirection(dto.getDirection()); metric.setHidden(dto.isHidden()); metric.setQualitative(dto.isQualitative()); metric.setType(Metric.ValueType.valueOf(dto.getValueType())); metric.setOptimizedBestValue(dto.isOptimizedBestValue()); metric.setUserManaged(dto.isUserManaged()); metric.setWorstValue(dto.getWorstValue()); return metric; } }
private static Ordering<ComponentDto> metricPeriodOrdering(ComponentTreeRequest wsRequest, List<MetricDto> metrics, Table<String, MetricDto, ComponentTreeData.Measure> measuresByComponentUuidAndMetric) { if (wsRequest.getMetricSort() == null || wsRequest.getMetricPeriodSort() == null) { return componentNameOrdering(wsRequest.getAsc()); } Map<String, MetricDto> metricsByKey = Maps.uniqueIndex(metrics, MetricDto::getKey); MetricDto metric = metricsByKey.get(wsRequest.getMetricSort()); ValueType metricValueType = ValueType.valueOf(metric.getValueType()); if (NUMERIC_VALUE_TYPES.contains(metricValueType)) { return numericalMetricPeriodOrdering(wsRequest, metric, measuresByComponentUuidAndMetric); } throw BadRequestException.create(format("Impossible to sort metric '%s' by measure period.", metric.getKey())); }
private IssueMetricFormula newRatingConstantFormula(Rating constant) { Metric metric = new Metric.Builder(ratingMetric.getKey(), ratingMetric.getShortName(), Metric.ValueType.valueOf(ratingMetric.getValueType())).create(); return new IssueMetricFormula(metric, false, (ctx, issues) -> { ctx.setValue(constant); }); }
private IssueMetricFormula newRatingLeakFormula(Rating rating) { Metric metric = new Metric.Builder(ratingMetric.getKey(), ratingMetric.getShortName(), Metric.ValueType.valueOf(ratingMetric.getValueType())).create(); return new IssueMetricFormula(metric, true, (ctx, issues) -> { ctx.setLeakValue(rating); }); }
private IssueMetricFormula newIncrementalFormula() { Metric metric = new Metric.Builder(intMetric.getKey(), intMetric.getShortName(), Metric.ValueType.valueOf(intMetric.getValueType())).create(); AtomicInteger counter = new AtomicInteger(); return new IssueMetricFormula(metric, false, (ctx, issues) -> { ctx.setValue((double) counter.incrementAndGet()); }); }
private IssueMetricFormula newQualifierBasedIntLeakFormula() { Metric metric = new Metric.Builder(intMetric.getKey(), intMetric.getShortName(), Metric.ValueType.valueOf(intMetric.getValueType())).create(); return new IssueMetricFormula(metric, true, (ctx, issues) -> { ctx.setLeakValue(ORDERED_BOTTOM_UP.indexOf(ctx.getComponent().qualifier())); }); }
private IssueMetricFormula newQualifierBasedIntFormula() { Metric metric = new Metric.Builder(intMetric.getKey(), intMetric.getShortName(), Metric.ValueType.valueOf(intMetric.getValueType())).create(); return new IssueMetricFormula(metric, false, (ctx, issues) -> { ctx.setValue(ORDERED_BOTTOM_UP.indexOf(ctx.getComponent().qualifier())); }); }
@Test public void exception_describes_context_when_a_formula_fails() { markProjectAsAnalyzed(project); Metric metric = new Metric.Builder(intMetric.getKey(), intMetric.getShortName(), Metric.ValueType.valueOf(intMetric.getValueType())).create(); expectedException.expect(IllegalStateException.class); expectedException.expectMessage("Fail to compute " + metric.getKey() + " on " + project.getDbKey()); run(project, new IssueMetricFormula(metric, false, (context, issueCounter) -> { throw new NullPointerException("BOOM"); })); }
@Override public Metric.ValueType getType() { return Metric.ValueType.valueOf(metric.getValueType()); }
private IssueMetricFormula newIntConstantFormula(double constant) { Metric metric = new Metric.Builder(intMetric.getKey(), intMetric.getShortName(), Metric.ValueType.valueOf(intMetric.getValueType())).create(); return new IssueMetricFormula(metric, false, (ctx, issues) -> { ctx.setValue(constant); }); }