org.sonar.report.pdf.entity.Project.java Source code

Java tutorial

Introduction

Here is the source code for org.sonar.report.pdf.entity.Project.java

Source

/*
 * Sonar PDF Report (Maven plugin)
 * Copyright (C) 2010 klicap - ingenieria del puzle
 * dev@sonar.codehaus.org
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02
 */

package org.sonar.report.pdf.entity;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import org.apache.commons.httpclient.HttpException;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Node;
import org.sonar.report.pdf.PDFReporter;
import org.sonar.report.pdf.entity.exception.ReportException;
import org.sonar.report.pdf.util.Logger;
import org.sonar.report.pdf.util.SonarAccess;
import org.sonar.report.pdf.util.UrlPath;

/**
 * This class encapsulates the Project info.
 */
public class Project {

    // Project info
    private short id;
    private String key;
    private String name;
    private String description;
    private List<String> links;

    // Measures
    private Measures measures;

    // Child projects
    private List<Project> subprojects;

    // Most violated rules
    private List<Rule> mostViolatedRules;

    // Most complex elements
    private List<FileInfo> mostComplexFiles;

    // Most violated files
    private List<FileInfo> mostViolatedFiles;

    // Most duplicated files
    private List<FileInfo> mostDuplicatedFiles;

    // PROJECT INFO XPATH
    private static final String PROJECT = "//resources/resource";
    private static final String KEY = "key";
    private static final String NAME = "name";

    // RULES INFO XPATH
    private static final String ALL_MEASURES = "msr";
    private static final String MEASURE_FRMT_VAL = "frmt_val";

    // VIOLATIONS (number)
    private static final String DESCRIPTION = "description";

    public Project(String key) {
        this.key = key;
    }

    /**
     * Initialize: - Project basic data - Project measures - Project categories violations - Project most violated rules -
     * Project most violated files - Project most duplicated files
     * 
     * @param sonarAccess
     * @throws HttpException
     * @throws IOException
     * @throws DocumentException
     * @throws ReportException
     */
    public void initializeProject(SonarAccess sonarAccess)
            throws HttpException, IOException, DocumentException, ReportException {
        Logger.info("Retrieving project info for " + this.key);
        Document parent = sonarAccess
                .getUrlAsDocument(UrlPath.RESOURCES + this.key + UrlPath.PARENT_PROJECT + UrlPath.XML_SOURCE);
        if (parent.selectSingleNode(PROJECT) != null) {
            initFromNode(parent.selectSingleNode(PROJECT));
            initMeasures(sonarAccess);
            initMostViolatedRules(sonarAccess);
            initMostViolatedFiles(sonarAccess);
            initMostComplexElements(sonarAccess);
            initMostDuplicatedFiles(sonarAccess);
            Logger.debug("Accessing Sonar: getting child projects");
            Document childs = sonarAccess
                    .getUrlAsDocument(UrlPath.RESOURCES + this.key + UrlPath.CHILD_PROJECTS + UrlPath.XML_SOURCE);
            List<Node> childNodes = childs.selectNodes(PROJECT);
            Iterator<Node> it = childNodes.iterator();
            setSubprojects(new ArrayList<Project>());
            if (!it.hasNext()) {
                Logger.debug(this.key + " project has no childs");
            }
            while (it.hasNext()) {
                Node childNode = it.next();
                if (childNode.selectSingleNode("scope").getText().equals("PRJ")) {
                    Project childProject = new Project(childNode.selectSingleNode(KEY).getText());
                    childProject.initializeProject(sonarAccess);
                    getSubprojects().add(childProject);
                }
            }
        } else {
            Logger.info("Can't retrieve project info. Have you set username/password in Sonar settings?");
            throw new ReportException("Can't retrieve project info. Parent project node is empty. Authentication?");
        }
    }

    /**
     * Initialize project object and his childs (except categories violations).
     */
    private void initFromNode(Node projectNode) {
        Node name = projectNode.selectSingleNode(NAME);
        if (name != null) {
            this.setName(name.getText());
        }
        Node description = projectNode.selectSingleNode(DESCRIPTION);
        if (description != null) {
            this.setDescription(description.getText());
        }
        this.setKey(projectNode.selectSingleNode(KEY).getText());
        this.setLinks(new LinkedList<String>());
        this.setSubprojects(new LinkedList<Project>());
        this.setMostViolatedRules(new LinkedList<Rule>());
        this.setMostComplexFiles(new LinkedList<FileInfo>());
        this.setMostDuplicatedFiles(new LinkedList<FileInfo>());
        this.setMostViolatedFiles(new LinkedList<FileInfo>());
    }

    private void initMeasures(SonarAccess sonarAccess) throws HttpException, IOException, DocumentException {
        Measures measures = new Measures();
        Logger.info("    Retrieving measures");
        measures.initMeasuresByProjectKey(sonarAccess, this.key);
        this.setMeasures(measures);
    }

    private void initMostViolatedRules(SonarAccess sonarAccess)
            throws HttpException, IOException, DocumentException, ReportException {
        Logger.info("    Retrieving most violated rules");
        Logger.debug("Accessing Sonar: getting most violated rules");
        Document mostViolatedRules = sonarAccess.getUrlAsDocument(UrlPath.RESOURCES + this.key
                + UrlPath.PARENT_PROJECT + UrlPath.MOST_VIOLATED_RULES + UrlPath.XML_SOURCE);
        if (mostViolatedRules.selectSingleNode(PROJECT) != null) {
            initMostViolatedRulesFromNode(mostViolatedRules.selectSingleNode(PROJECT), sonarAccess);
        } else {
            Logger.warn("There is not result on select //resources/resource");
        }
    }

    private void initMostViolatedFiles(SonarAccess sonarAccess)
            throws HttpException, IOException, DocumentException {
        Logger.info("    Retrieving most violated files");
        Logger.debug("Accessing Sonar: getting most violated files");
        Document mostViolatedFilesDoc = sonarAccess
                .getUrlAsDocument(UrlPath.RESOURCES + this.key + UrlPath.MOST_VIOLATED_FILES + UrlPath.XML_SOURCE);
        this.setMostViolatedFiles(FileInfo.initFromDocument(mostViolatedFilesDoc, FileInfo.VIOLATIONS_CONTENT));

    }

    private void initMostComplexElements(SonarAccess sonarAccess)
            throws HttpException, IOException, DocumentException {
        Logger.info("    Retrieving most complex elements");
        Logger.debug("Accessing Sonar: getting most complex elements");
        Document mostComplexFilesDoc = sonarAccess
                .getUrlAsDocument(UrlPath.RESOURCES + this.key + UrlPath.MOST_COMPLEX_FILES + UrlPath.XML_SOURCE);
        this.setMostComplexFiles(FileInfo.initFromDocument(mostComplexFilesDoc, FileInfo.CCN_CONTENT));
    }

    private void initMostDuplicatedFiles(SonarAccess sonarAccess)
            throws HttpException, IOException, DocumentException {
        Logger.info("    Retrieving most duplicated files");
        Logger.debug("Accessing Sonar: getting most duplicated files");
        Document mostDuplicatedFilesDoc = sonarAccess.getUrlAsDocument(
                UrlPath.RESOURCES + this.key + UrlPath.MOST_DUPLICATED_FILES + UrlPath.XML_SOURCE);
        this.setMostDuplicatedFiles(
                FileInfo.initFromDocument(mostDuplicatedFilesDoc, FileInfo.DUPLICATIONS_CONTENT));
    }

    public Measure getMeasure(String measureKey) {
        if (measures.containsMeasure(measureKey)) {
            return measures.getMeasure(measureKey);
        } else {
            return new Measure(null, "N/A");
        }
    }

    private void initMostViolatedRulesFromNode(Node mostViolatedNode, SonarAccess sonarAccess)
            throws HttpException, ReportException, IOException, DocumentException {
        List<Node> measures = mostViolatedNode.selectNodes(ALL_MEASURES);
        Iterator<Node> it = measures.iterator();
        if (!it.hasNext()) {
            Logger.warn("There is not result on select //resources/resource/msr");
        }
        while (it.hasNext()) {
            Node measure = it.next();
            if (!measure.selectSingleNode(MEASURE_FRMT_VAL).getText().equals("0")) {
                Rule rule = Rule.initFromNode(measure);
                if (PDFReporter.reportType.equals("workbook")) {
                    rule.loadViolatedResources(sonarAccess, this.key);
                }
                this.mostViolatedRules.add(rule);
            }
        }
    }

    public Project getChildByKey(String key) {
        Iterator<Project> it = this.subprojects.iterator();
        while (it.hasNext()) {
            Project child = it.next();
            if (child.getKey().equals(key)) {
                return child;
            }
        }
        return null;
    }

    public void setId(short id) {
        this.id = id;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public void setLinks(List<String> links) {
        this.links = links;
    }

    public short getId() {
        return id;
    }

    public String getKey() {
        return key;
    }

    public String getName() {
        return name;
    }

    public String getDescription() {
        return description;
    }

    public List<String> getLinks() {
        return links;
    }

    public List<Project> getSubprojects() {
        return subprojects;
    }

    public void setSubprojects(List<Project> subprojects) {
        this.subprojects = subprojects;
    }

    public Measures getMeasures() {
        return measures;
    }

    public void setMeasures(Measures measures) {
        this.measures = measures;
    }

    public List<Rule> getMostViolatedRules() {
        return mostViolatedRules;
    }

    public List<FileInfo> getMostViolatedFiles() {
        return mostViolatedFiles;
    }

    public void setMostViolatedRules(List<Rule> mostViolatedRules) {
        this.mostViolatedRules = mostViolatedRules;
    }

    public void setMostViolatedFiles(List<FileInfo> mostViolatedFiles) {
        this.mostViolatedFiles = mostViolatedFiles;
    }

    public void setMostComplexFiles(List<FileInfo> mostComplexFiles) {
        this.mostComplexFiles = mostComplexFiles;
    }

    public List<FileInfo> getMostComplexFiles() {
        return mostComplexFiles;
    }

    public List<FileInfo> getMostDuplicatedFiles() {
        return mostDuplicatedFiles;
    }

    public void setMostDuplicatedFiles(List<FileInfo> mostDuplicatedFiles) {
        this.mostDuplicatedFiles = mostDuplicatedFiles;
    }
}