Java tutorial
/** * EasySOA Registry Copyright 2012 Open Wide * * 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, see <http://www.gnu.org/licenses/>. * * Contact : easysoa-dev@googlegroups.com */ package org.easysoa.registry.indicators.rest; import au.com.bytecode.opencsv.CSVWriter; import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.io.Reader; import java.io.StringWriter; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import javax.ws.rs.GET; import javax.ws.rs.Path; import javax.ws.rs.Produces; import javax.ws.rs.QueryParam; import javax.ws.rs.core.MediaType; import org.apache.commons.io.IOUtils; import org.apache.log4j.Logger; import org.easysoa.registry.SubprojectServiceImpl; import org.easysoa.registry.rest.EasysoaModuleRoot; import org.easysoa.registry.types.Actor; import org.easysoa.registry.types.BusinessService; import org.easysoa.registry.types.Component; import org.easysoa.registry.types.Deliverable; import org.easysoa.registry.types.DeployedDeliverable; import org.easysoa.registry.types.Endpoint; import org.easysoa.registry.types.EndpointConsumption; import org.easysoa.registry.types.InformationService; import org.easysoa.registry.types.RequirementsDocument; import org.easysoa.registry.types.ServiceConsumption; import org.easysoa.registry.types.ServiceImplementation; import org.easysoa.registry.types.SoaNode; import org.easysoa.registry.types.TaggingFolder; import org.easysoa.registry.utils.ContextData; import org.nuxeo.ecm.core.api.CoreSession; import org.nuxeo.ecm.webengine.jaxrs.session.SessionFactory; import org.nuxeo.ecm.webengine.model.WebObject; /** * Indicators * * TODO refactor init of providers & computing to dedicated IndicatorsService * * @author mdutoo * */ //XXX Slightly outdated after removal of Service doctype @WebObject(type = "EasySOA") @Path("easysoa/indicators") public class IndicatorsController extends EasysoaModuleRoot { // New category for indicators public static final String CATEGORY_STEERING = "steering"; // Or Governance ? public static final String CATEGORY_CARTOGRAPHY = "cartography"; public static final String CATEGORY_USAGE = "usage"; public static final String CATEGORY_MATCHING = "matching"; private static Logger logger = Logger.getLogger(IndicatorsController.class); private List<IndicatorProvider> indicatorProviders = new ArrayList<IndicatorProvider>(); private Map<String, IndicatorProvider> name2indicatorProviderMap = new HashMap<String, IndicatorProvider>(); /** * Init the indicator controller */ public IndicatorsController() { // CARTOGRAPHY // Document count by type addIndicatorProvider(new DoctypeCountProvider(SoaNode.ABSTRACT_DOCTYPE, CATEGORY_CARTOGRAPHY)); // TODO : replace all these providers by a unique provider addIndicatorProvider(new DoctypeCountProvider(BusinessService.DOCTYPE, CATEGORY_CARTOGRAPHY)); addIndicatorProvider(new DoctypeCountProvider(Actor.DOCTYPE, CATEGORY_CARTOGRAPHY)); addIndicatorProvider(new DoctypeCountProvider(RequirementsDocument.DOCTYPE, CATEGORY_CARTOGRAPHY)); //addIndicatorProvider(new DoctypeCountProvider(SoftwareComponent.DOCTYPE, CATEGORY_CARTOGRAPHY)); addIndicatorProvider(new DoctypeCountProvider(InformationService.DOCTYPE, CATEGORY_CARTOGRAPHY)); addIndicatorProvider(new DoctypeCountProvider(Component.DOCTYPE, CATEGORY_CARTOGRAPHY)); addIndicatorProvider(new DoctypeCountProvider(ServiceImplementation.DOCTYPE, CATEGORY_CARTOGRAPHY)); addIndicatorProvider(new DoctypeCountProvider(ServiceConsumption.DOCTYPE, CATEGORY_CARTOGRAPHY)); addIndicatorProvider(new DoctypeCountProvider(Deliverable.DOCTYPE, CATEGORY_CARTOGRAPHY)); addIndicatorProvider(new DoctypeCountProvider(DeployedDeliverable.DOCTYPE, CATEGORY_CARTOGRAPHY)); addIndicatorProvider(new DoctypeCountProvider(Endpoint.DOCTYPE, CATEGORY_CARTOGRAPHY)); addIndicatorProvider(new DoctypeCountProvider(EndpointConsumption.DOCTYPE, CATEGORY_CARTOGRAPHY)); addIndicatorProvider(new DoctypeCountProvider(TaggingFolder.DOCTYPE, CATEGORY_CARTOGRAPHY)); // Specific indicators addIndicatorProvider(new LastCodeDiscoveryIndicatorProvider(CATEGORY_CARTOGRAPHY)); addIndicatorProvider(new ServiceImplStateProvider(CATEGORY_CARTOGRAPHY)); // MATCHING //addIndicatorProvider(new PlaceholdersIndicatorProvider(InformationService.DOCTYPE, CATEGORY_MATCHING)); addIndicatorProvider(new PlaceholdersIndicatorProvider(ServiceImplementation.DOCTYPE, CATEGORY_MATCHING)); addIndicatorProvider(new PlaceholdersIndicatorProvider(Endpoint.DOCTYPE, CATEGORY_MATCHING)); //addIndicatorProvider(new PlaceholdersIndicatorProvider(SoaNode.DOCTYPE, CATEGORY_MATCHING)); // USAGE addIndicatorProvider(new ServiceDefaultCountIndicatorProvider(CATEGORY_USAGE)); // STEERING addIndicatorProvider(new ServiceConsumptionIndicatorProvider(CATEGORY_STEERING)); addIndicatorProvider(new ServiceStateProvider(CATEGORY_STEERING)); //addIndicatorProvider(new SoftwareComponentIndicatorProvider()); // Disabled, need to be updated addIndicatorProvider(new TagsIndicatorProvider(CATEGORY_STEERING)); addIndicatorProvider(new PhaseProgressIndicatorProvider(CATEGORY_STEERING)); } /** * Add an indicator provider in the indicator list * * @param indicator provider */ public void addIndicatorProvider(IndicatorProvider indicatorProvider) { if (name2indicatorProviderMap.containsKey(indicatorProvider.getName())) { throw new RuntimeException("Conflicting indicatorProvider names: " + indicatorProvider.getName()); } indicatorProviders.add(indicatorProvider); name2indicatorProviderMap.put(indicatorProvider.getName(), indicatorProvider); } public IndicatorProvider getIndicatorProvider(String name) { return name2indicatorProviderMap.get(name); } // TODO : add a method to compute indicators and to be callable from another controller // TODO : return a single map instead of 2 separed maps for percents and count values /** * * @param nbMap * @param percentMap * @param subprojectId The subproject (or version) ID * @param visibility Visibility used when computing the indicators * @return A map containing the indicators values * @throws Exception If a problem occurs */ public Map<String, IndicatorValue> computeIndicators(CoreSession session, HashMap<String, Long> nbMap, HashMap<String, Integer> percentMap, String subprojectId, String visibility) throws Exception { // using all subprojects or getting default one is let to indicator impls TODO better //subprojectId = SubprojectServiceImpl.getSubprojectIdOrCreateDefault(session, subprojectId); if ("".equals(subprojectId)) { subprojectId = null; } Map<String, IndicatorValue> indicators = computeIndicators(session, subprojectId, visibility); // Create and return view if (nbMap == null) { nbMap = new HashMap<String, Long>(); } if (percentMap == null) { percentMap = new HashMap<String, Integer>(); } for (Entry<String, IndicatorValue> indicator : indicators.entrySet()) { if (indicator.getValue().getCount() != -1) { nbMap.put(indicator.getKey(), indicator.getValue().getCount()); } if (indicator.getValue().getPercentage() != -1) { percentMap.put(indicator.getKey(), indicator.getValue().getPercentage()); } } return indicators; } /** * * @param subprojectId * @param visibility * @return The indicators view * @throws Exception */ @GET @Produces(MediaType.TEXT_HTML) public Object doGetHTML(@QueryParam("subprojectId") String subprojectId, @QueryParam("visibility") String visibility) throws Exception { CoreSession session = SessionFactory.getSession(request); // Init maps HashMap<String, Long> nbMap = new HashMap<String, Long>(); HashMap<String, Integer> percentMap = new HashMap<String, Integer>(); // Compute the indicators this.computeIndicators(session, nbMap, percentMap, subprojectId, visibility); // Set args for the template return getView("indicators").arg("nbMap", nbMap) // TODO : only one map containing the indicatorValue .arg("percentMap", percentMap) // TODO : only one map .arg("subprojectId", subprojectId).arg("visibility", visibility) .arg("contextInfo", ContextData.getVersionData(session, subprojectId)); } /** * * @param subprojectId * @param visibility * @return The indicators packaged in a json structure * @throws Exception */ @GET @Produces(MediaType.APPLICATION_JSON) public Object doGetJSON(@QueryParam("subproject") String subprojectId, @QueryParam("visibility") String visibility) throws Exception { CoreSession session = SessionFactory.getSession(request); subprojectId = SubprojectServiceImpl.getSubprojectIdOrCreateDefault(session, subprojectId); // TODO default or not ?? return computeIndicators(session, subprojectId, visibility); } //private Map<String, Map<String, IndicatorValue>> computeIndicators(String subprojectId, String visibility) throws Exception { private Map<String, IndicatorValue> computeIndicators(CoreSession session, String subprojectId, String visibility) throws Exception { //CoreSession session = SessionFactory.getSession(request); List<IndicatorProvider> computedProviders = new ArrayList<IndicatorProvider>(); List<IndicatorProvider> pendingProviders = new ArrayList<IndicatorProvider>(); Map<String, IndicatorValue> computedIndicators = new HashMap<String, IndicatorValue>(); //Map<String, Map<String, IndicatorValue>> indicatorsByCategory = new HashMap<String, Map<String, IndicatorValue>>(); HashSet<String> pendingRequiredIndicators = new HashSet<String>(indicatorProviders.size()); int previousComputedProvidersCount = -1; // Compute indicators in several passes, with respect to dependencies while (computedProviders.size() != previousComputedProvidersCount) { previousComputedProvidersCount = computedProviders.size(); /*for (Entry<String, List<IndicatorProvider>> indicatorProviderCategory : indicatorProviders.entrySet()) {*/ // Start or continue indicator category /*Map<String, IndicatorValue> categoryIndicators = indicatorsByCategory.get(indicatorProviderCategory.getKey()); if (categoryIndicators == null) { categoryIndicators = new HashMap<String, IndicatorValue>(); }*/ // Browse all providers //for (IndicatorProvider indicatorProvider : indicatorProviderCategory.getValue()) { for (IndicatorProvider indicatorProvider : indicatorProviders) { if (!computedProviders.contains(indicatorProvider)) { // Compute indicator only if the dependencies are already computed List<String> requiredIndicators = indicatorProvider.getRequiredIndicators(); boolean allRequirementsSatisfied = true; if (requiredIndicators != null) { for (String requiredIndicator : requiredIndicators) { if (!computedIndicators.containsKey(requiredIndicator)) { allRequirementsSatisfied = false; pendingRequiredIndicators.add(requiredIndicator); break; } } } // Actual indicator calculation if (allRequirementsSatisfied) { Map<String, IndicatorValue> indicators = null; try { indicators = indicatorProvider.computeIndicators(session, subprojectId, computedIndicators, visibility); } catch (Exception e) { logger.error("Failed to compute indicator '" + indicatorProvider.toString() + "': " + e.getMessage(), e); } if (indicators != null) { //categoryIndicators.putAll(indicators); computedIndicators.putAll(indicators); pendingRequiredIndicators.removeAll(indicators.entrySet()); // just in case there had been required } computedProviders.add(indicatorProvider); pendingProviders.remove(indicatorProvider); } else { pendingProviders.add(indicatorProvider); } } } //indicatorsByCategory.put(indicatorProviderCategory.getKey(), categoryIndicators); } /*}*/ // Warn if some indicators have been left pending for (IndicatorProvider pendingProvider : pendingProviders) { logger.warn(pendingProvider.getClass().getName() + " provider dependencies could not be satisfied (" + pendingProvider.getRequiredIndicators() + ")"); } if (!pendingRequiredIndicators.isEmpty()) { logger.warn("Pending required indicators : " + pendingRequiredIndicators); } //return indicatorsByCategory; return computedIndicators; } /** * Exports the indicators as a CSV file * @param subprojectId * @param visibility * @return * @throws Exception */ @GET @Path("export.csv") @Produces(MediaType.APPLICATION_OCTET_STREAM) public Object doGetExportIndicators(@QueryParam("subprojectId") String subprojectId, @QueryParam("visibility") String visibility, @QueryParam("category") String category) throws Exception { CoreSession session = SessionFactory.getSession(request); File exportFile = new File("indicators.csv"); CSVWriter writer = new CSVWriter(new FileWriter(exportFile), ';'); // Headers String[] entries = new String[4]; entries[0] = "Indicateur"; entries[1] = "Description"; entries[2] = "Valeur"; entries[3] = "Pourcentage"; writer.writeNext(entries); // values Map<String, IndicatorValue> indicators = computeIndicators(session, subprojectId, visibility); Set<String> indicatorNames = indicators.keySet(); for (String indicatorName : indicatorNames) { if (category != null && !"".equals(category)) { if (indicators.get(indicatorName).getCategories().contains(category)) { // return only the indicators with the correponding category writeEntry(writer, indicators.get(indicatorName)); } } else { // return all indicators writeEntry(writer, indicators.get(indicatorName)); } } writer.close(); Reader input = new FileReader(exportFile); StringWriter output = new StringWriter(); try { IOUtils.copy(input, output); } finally { input.close(); } return output.toString(); } /** * * @param writer * @param indicatorValue */ private void writeEntry(CSVWriter writer, IndicatorValue indicatorValue) { String[] entries = new String[4]; entries[0] = indicatorValue.getName(); entries[1] = indicatorValue.getDescription(); if (indicatorValue.getCount() == -1) { entries[2] = "N/A"; } else { entries[2] = String.valueOf(indicatorValue.getCount()); } if (indicatorValue.getPercentage() == -1) { entries[3] = "N/A"; } else { entries[3] = String.valueOf(indicatorValue.getPercentage()) + "%"; } writer.writeNext(entries); } }