public ResourceQuery setAllDepths() { return setDepth(DEPTH_UNLIMITED); }
public static ResourceQuery createForMetrics(String resourceKeyOrId, String... metricKeys) { return new ResourceQuery(resourceKeyOrId) .setMetrics(metricKeys); }
@Override public String getUrl() { StringBuilder url = new StringBuilder(BASE_URL); url.append('?'); appendUrlParameter(url, "resource", resourceKeyOrId); appendUrlParameter(url, "metrics", metrics); appendUrlParameter(url, "scopes", scopes); appendUrlParameter(url, "qualifiers", qualifiers); appendUrlParameter(url, "depth", depth); appendUrlParameter(url, "limit", limit); appendRuleField(url, "rules", excludeRules, rules); appendRuleField(url, "rule_priorities", excludeRuleSeverities, ruleSeverities); appendUrlParameter(url, "includetrends", includeTrends); appendUrlParameter(url, "characteristics", characteristicKeys); appendUrlParameter(url, "includealerts", includeAlerts); appendUrlParameter(url, "verbose", verbose); return url.toString(); }
private void initMostComplexElements(final Project project) throws IOException { LOG.info(" Retrieving most complex elements"); LOG.debug("Accessing Sonar: getting most complex elements"); ResourceQuery resourceQuery = ResourceQuery.createForMetrics( project.getKey(), MetricKeys.COMPLEXITY); resourceQuery.setScopes("FIL"); resourceQuery.setDepth(-1); resourceQuery.setLimit(5); List<Resource> resources = sonar.findAll(resourceQuery); project.setMostComplexFiles(FileInfoBuilder.initFromDocument(resources, FileInfo.CCN_CONTENT)); }
private void initMostViolatedRules(final Project project) throws IOException, ReportException { LOG.info(" Retrieving most violated rules"); LOG.debug("Accessing Sonar: getting most violated rules"); String[] priorities = Priority.getPrioritiesArray(); // Reverse iteration to get violations with upper level first int limit = 10; for (int i = priorities.length - 1; i >= 0 && limit > 0; i--) { ResourceQuery query = ResourceQuery.create(project.getKey()); query.setDepth(0); query.setLimit(limit); query.setMetrics(UrlPath.getViolationsLevelPath(priorities[i])); // "&filter_rules=false&filter_rules_cats=true" ?? query.setExcludeRules(false); // query.setExcludeRuleCategories(true); Resource mostViolatedRulesByLevel = sonar.find(query); if (mostViolatedRulesByLevel != null) { int count = initMostViolatedRulesFromNode(project, mostViolatedRulesByLevel); LOG.debug("\t " + count + " " + priorities[i] + " violations"); limit = limit - count; } else { LOG.debug("There is not result on select //resources/resource"); LOG.debug("There are no violations with level " + priorities[i]); } } }
/** * Add measures to this. */ private void addMeasures(final Measures measures, final List<String> measuresAsString, final String projectKey) throws HttpException, IOException { String[] measuresAsArray = measuresAsString .toArray(new String[measuresAsString.size()]); ResourceQuery query = ResourceQuery.createForMetrics(projectKey, measuresAsArray); query.setDepth(0); query.setIncludeTrends(true); Resource resource = sonar.find(query); if (resource != null) { this.addAllMeasuresFromDocument(measures, resource); } else { LOG.debug("Empty response when looking for measures: " + measuresAsString.toString()); } }
/** * {@inheritDoc} */ public Set<SourceCode> getChildren() { if (children == null) { ResourceQuery query = new ResourceQuery().setDepth(1).setResourceKeyOrId(getKey()); Collection<Resource> resources = index.getSonar().findAll(query); children = new HashSet<SourceCode>(); for (Resource resource : resources) { children.add(new RemoteSourceCode(resource.getKey(), resource.getName()).setRemoteSonarIndex(index)); } } return children; }
/** * {@inheritDoc} */ public List<Duplication> getDuplications() { Logs.INFO.info("Loading duplications for {}", getKey()); final Resource resource = index.getSonar().find(ResourceQuery.createForMetrics(getKey(), DuplicationUtils.DUPLICATIONS_DATA)); final Measure measure = resource.getMeasure(DuplicationUtils.DUPLICATIONS_DATA); if (measure == null) { return Collections.emptyList(); } final List<Duplication> duplications = DuplicationUtils.parse(measure.getData()); Logs.INFO.info("Loaded {} duplications: {}", duplications.size(), duplications); return DuplicationUtils.convertLines(duplications, getDiff()); }
private void loadMeasures(Resource resource) { ResourceQuery query = ResourceQuery.createForMetrics(resource.getKey(), metrics).setVerbose(true); Sonar.getInstance().find(query, new AbstractCallback<Resource>() { @Override protected void doOnResponse(Resource resource) { display(header, resource); } }); }
ResourceQuery rq = ResourceQuery.create(project.getKey()); rq.setDepth(0); Resource resource = sonar.find(rq); LOG.debug("Accessing Sonar: getting child projects"); ResourceQuery resourceQueryChild = ResourceQuery.create(project.getKey()); resourceQueryChild.setDepth(1); List<Resource> childNodes = sonar.findAll(resourceQueryChild);
/** * {@inheritDoc} */ public SourceCode search(String key) { Resource resource = sonar.find(new ResourceQuery().setResourceKeyOrId(key)); if (resource == null) { return null; } return new RemoteSourceCode(key).setRemoteSonarIndex(this); }
/** * @since 2.10 */ public static ResourceQuery create(String resourceKey) { return new ResourceQuery(resourceKey); } }
private void appendRuleField(StringBuilder url, String field, boolean excludeField, String[] list) { if (!excludeField) { if (list == null || list.length == 0) { appendUrlParameter(url, field, true); } else { appendUrlParameter(url, field, list); } } }
private void initMostViolatedFiles(final Project project) throws IOException { LOG.info(" Retrieving most violated files"); LOG.debug("Accessing Sonar: getting most violated files"); ResourceQuery resourceQuery = ResourceQuery.createForMetrics( project.getKey(), MetricKeys.VIOLATIONS); resourceQuery.setScopes("FIL"); resourceQuery.setDepth(-1); resourceQuery.setLimit(5); List<Resource> resources = sonar.findAll(resourceQuery); List<FileInfo> fileInfoList = FileInfoBuilder.initFromDocument(resources, FileInfo.VIOLATIONS_CONTENT); project.setMostViolatedFiles(fileInfoList); }
/** * {@inheritDoc} */ public List<IMeasure> getMeasures() { Map<String, Metric> metricsByKey = index.getMetrics(); Set<String> keys = metricsByKey.keySet(); String[] metricKeys = keys.toArray(new String[keys.size()]); ResourceQuery query = ResourceQuery.createForMetrics(getKey(), metricKeys); Resource resource = index.getSonar().find(query); List<IMeasure> result = Lists.newArrayList(); for (Measure measure : resource.getMeasures()) { final Metric metric = metricsByKey.get(measure.getMetricKey()); final String value = measure.getFormattedValue(); // Hacks around SONAR-1620 if ( !metric.getHidden() && !"DATA".equals(metric.getType()) && StringUtils.isNotBlank(measure.getFormattedValue())) { result.add(new MeasureData().setMetricDef(metric).setValue(value)); } } return result; }
/** * {@inheritDoc} */ public Collection<SourceCode> getProjects() { ArrayList<SourceCode> result = Lists.newArrayList(); for (Resource resource : sonar.findAll(new ResourceQuery())) { result.add(new RemoteSourceCode(resource.getKey(), resource.getName()).setRemoteSonarIndex(this)); } return result; }
private void initMostDuplicatedFiles(final Project project) throws IOException { LOG.info(" Retrieving most duplicated files"); LOG.debug("Accessing Sonar: getting most duplicated files"); ResourceQuery resourceQuery = ResourceQuery.createForMetrics( project.getKey(), MetricKeys.DUPLICATED_LINES); resourceQuery.setScopes("FIL"); resourceQuery.setDepth(-1); resourceQuery.setLimit(5); List<Resource> resources = sonar.findAll(resourceQuery); project.setMostDuplicatedFiles(FileInfoBuilder.initFromDocument(resources, FileInfo.DUPLICATIONS_CONTENT)); }
public static ResourceQuery createForResource(Resource resource, String... metricKeys) { Integer id = resource.getId(); if (id == null) { throw new IllegalArgumentException("id must be set"); } return new ResourceQuery(id.toString()) .setMetrics(metricKeys); }
/** * {@inheritDoc} */ public CoverageData getCoverage() { final Resource resource = index.getSonar().find( ResourceQuery.createForMetrics(getKey(), CoverageUtils.COVERAGE_LINE_HITS_DATA_KEY, CoverageUtils.BRANCH_COVERAGE_HITS_DATA_KEY)); final Measure measure = resource.getMeasure(CoverageUtils.COVERAGE_LINE_HITS_DATA_KEY); final Measure measure2 = resource.getMeasure(CoverageUtils.BRANCH_COVERAGE_HITS_DATA_KEY); if (measure2 != null) { return new CoverageData(CoverageUtils.unmarshall(measure.getData()), CoverageUtils.unmarshall(measure2.getData())); } else { return new CoverageData(CoverageUtils.unmarshall(measure.getData()), new HashMap<Integer, String>()); } }