gvSIG projects pool

        <version>2.0.409</version>

package org.gvsig.report.app.mainplugin;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.io.InputStream;

import java.net.URL;

import java.util.ArrayList;

import java.util.List;

import javax.json.Json;

import javax.json.JsonObject;

import javax.swing.AbstractAction;

import javax.swing.Action;

import javax.swing.JComponent;

import javax.swing.JMenuItem;

import javax.swing.JPopupMenu;

import org.apache.commons.io.IOUtils;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.project.DocumentsContainerNotification;

import org.gvsig.app.project.Project;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.feature.FeatureQuery;

import org.gvsig.fmap.dal.feature.FeatureSelection;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.dal.swing.DataSwingManager;

import org.gvsig.report.lib.api.Report;

import org.gvsig.report.lib.api.ReportDataSet;

import org.gvsig.report.lib.api.ReportLocator;

import org.gvsig.report.swing.api.JReport;

import org.gvsig.report.swing.api.ReportSwingLocator;

import org.gvsig.report.swing.api.ReportSwingManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

import org.gvsig.tools.swing.icontheme.IconTheme;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage.Resource;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.swing.DALActionFactory;

import org.gvsig.fmap.dal.swing.DALActionFactory.DALActionContext;

import org.gvsig.pdf.swing.api.DynamicTextReport;

import org.gvsig.pdf.swing.api.PDFSwingLocator;

import org.gvsig.pdf.swing.api.PDFSwingManager;

import org.gvsig.report.lib.api.ReportBuilder;

import org.gvsig.report.lib.api.ReportConfig;

import org.gvsig.report.lib.api.ReportManager;

import org.gvsig.report.swing.api.JReportBuilder;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.swing.api.windowmanager.Dialog;

import org.gvsig.tools.swing.api.windowmanager.WindowManager_v2;

import org.gvsig.tools.swing.impl.windowmanager.DefaultDialog;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class StoreReportsAction

        extends AbstractAction {

    public static String ACTION_NAME = "Reports";

    public static class ReportsActionFactory implements DALActionFactory {

        @Override

        public String getName() {

            return ACTION_NAME;

        }

        @Override

        public Action createAction(DALActionContext context) {

            return new StoreReportsAction(context);

        }

	@Override

        public boolean isApplicable(Object... args) {

            return true;

        }

        public static void selfRegister() {

            DataSwingManager dalSwingManager = DALSwingLocator.getSwingManager();

            dalSwingManager.registerStoreAction(new ReportsActionFactory());

            String[][] iconNames = new String[][]{

                new String[]{"Report", "report-select-reports"}

            };

            IconTheme theme = ToolsSwingLocator.getIconThemeManager().getCurrent();

            for (String[] icon : iconNames) {

                URL url = StoreReportsAction.class.getResource("/images/report/" + icon[1] + ".png");

                theme.registerDefault("Report", icon[0], icon[1], null, url);

            }

        }

    }

    private static final Logger LOGGER = LoggerFactory.getLogger(StoreReportsAction.class);

    private final DALActionContext context;

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public StoreReportsAction(DALActionContext context) {

        this.context = context;

        I18nManager i18n = ToolsLocator.getI18nManager();

        this.putValue(

                Action.ACTION_COMMAND_KEY,

                ACTION_NAME

        );

        this.putValue(

                Action.SHORT_DESCRIPTION,

                i18n.getTranslation("_Reports")

        );

        this.putValue(

                Action.SMALL_ICON,

                ToolsSwingLocator.getIconThemeManager().getCurrent().get("report-select-reports")

        );

        Project project = ApplicationLocator.getProjectManager().getCurrentProject();

        project.addObserver((Observable observable, Object notification) -> {

            if (notification instanceof DocumentsContainerNotification) {

                DocumentsContainerNotification n = (DocumentsContainerNotification) notification;

                switch (n.getNotificationType()) {

                    case DocumentsContainerNotification.AFTER_ADD_DOCUMENT:

                    case DocumentsContainerNotification.AFTER_REMOVE_DOCUMENT:

                        updateEnabled();

                }

            }

        });

        updateEnabled();

    }

    private List<JsonObject> getReports(Project project, FeatureStore store) {

        List<JsonObject> reports = new ArrayList<>();

        ResourcesStorage resources = null;

        try {

            resources = store.getResourcesStorage();

            if (resources != null) {

                List<Resource> reportsResources = resources.getResources("report");

                if (reportsResources != null && !reportsResources.isEmpty()) {

                    for (Resource resource : reportsResources) {

                        InputStream is = null;

                        try {

                            is = resource.asInputStream();

                            JsonObject json = Json.createReader(is).readObject();

                            String type = json.getString("type", "jasper").trim().toLowerCase();

                            switch(type) {

                                case "jasper":

                                    reports.add(json);

                                    break;

                                case "dynamictext":

                                    reports.add(json);

                                    break;

                            }

                        } catch (Exception ex) {

                            LOGGER.warn("Can't load report form resource (" + resource.getURL() + ")", ex);

                        } finally {

                            IOUtils.closeQuietly(is);

                        }

                    }

                }

            }

        } finally {

            DisposeUtils.disposeQuietly(resources);

        }

        if (reports.isEmpty()) {

            return null;

        }

        return reports;

    }

    private void updateEnabled() {

        Project project = ApplicationLocator.getProjectManager().getCurrentProject();

        DataStore store = this.context.getStore();

        if (!(store instanceof FeatureStore)) {

            return;

        }

        List<JsonObject> reports = this.getReports(project, (FeatureStore) store);

        if (reports == null || reports.isEmpty()) {

            this.setEnabled(false);

        } else {

            this.setEnabled(true);

        }

    }

    @Override

    public void actionPerformed(ActionEvent e) {

        try {

            this.setEnabled(false);

            DataStore store = this.context.getStore();

            if (!(store instanceof FeatureStore)) {

                return;

            }

            JPopupMenu popup = new JPopupMenu();

            Project project = ApplicationLocator.getProjectManager().getCurrentProject();

            List<JsonObject> reports = this.getReports(project, (FeatureStore) store);

            if (reports != null && !reports.isEmpty()) {

                for (JsonObject json : reports) {

                    popup.add(this.createItem((FeatureStore) store, this.context.getQuery(), this.context.getSelecteds(), json));

                }

                popup.addSeparator();

            }

            popup.add(this.createReportBuilderItem());

            JComponent button = this.context.getActionButton(ACTION_NAME);

            popup.show(button, 0, button.getHeight());

        } catch (Exception ex) {

            LOGGER.warn("Can't show form", ex);

        } finally {

            this.setEnabled(true);

        }

    }

    private JMenuItem createItem(FeatureStore store, FeatureQuery query, FeatureSelection selecteds, final  JsonObject json) {

        JMenuItem item = null;

        String type = json.getString("type", "jasper").trim().toLowerCase();

        switch(type) {

            case "jasper":

                org.gvsig.report.lib.api.ReportManager manager = ReportLocator.getReportManager();                

                ReportConfig reportConfig = manager.createReportConfig();

                reportConfig.fromJSON(json);

                if (!reportConfig.hasDataSet()) {

                    reportConfig.setDataSet(manager.createDataSet(store, query));

                }

                item = new JMenuItem(reportConfig.getName());

                item.addActionListener((ActionEvent e) -> {

                    Report report = reportConfig.createReport();

                    doShowReport(report);

                });

                item.setEnabled(reportConfig.isValid(null));

                break;

            case "dynamictext":

                PDFSwingManager pdfSwingManager = PDFSwingLocator.getPDFSwingManager();

                DynamicTextReport dtreport = pdfSwingManager.createDynamicTextReport(store, query, selecteds, json);

                item = new JMenuItem(dtreport.getName());

                item.addActionListener((ActionEvent e) -> {

                    dtreport.show();

                });

                item.setEnabled(dtreport.isValid());

                break;

        }

        return item;

    }

    private JMenuItem createReportBuilderItem() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        JMenuItem item = new JMenuItem(i18n.getTranslation("_User_defined"));

        item.addActionListener((ActionEvent e) -> {

            WindowManager_v2 winmgr = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

            ReportSwingManager reportSwingManager = ReportSwingLocator.getReportSwingManager();

            final ReportManager reportManager = ReportLocator.getReportManager();

            final FeatureStore store = (FeatureStore) context.getStore();

            FeatureType featureType;

            try {

                featureType = store.getDefaultFeatureType();

            } catch (Exception ex) {

                // TODO: Deberia hacer algo mas?

                LOGGER.warn("Can't get feature type to make JReportBuilder", ex);

                return;

            }

            final ReportBuilder builder = reportManager.createReportBuilder();

            final JReportBuilder panel = reportSwingManager.createJReportBuilder();

            panel.setFeatureType(featureType);

            builder.title(store.getName());

            panel.put(builder);

            final Dialog dialog = winmgr.createDialog(

                    panel.asJComponent(),

                    i18n.getTranslation("_Report_builder"),

                    null,

                    WindowManager_v2.BUTTONS_APPLY_OK_CANCEL

            );

            dialog.setAutoclose(false);

            dialog.addActionListener((ActionEvent e1) -> {

                if (dialog.getAction() == WindowManager_v2.BUTTON_CANCEL) {

                    ((DefaultDialog) dialog).setVisible(false);

                    return;

                }

                StringBuilder msg = new StringBuilder();

                FeatureQuery fquery = context.getQuery().getCopy();

                panel.setFeatureQuery(fquery);

                if (!panel.checkPanel(msg)) {

                    return;

                }

                ReportBuilder fetchBuilder = reportManager.createReportBuilder();

                panel.fetch(fetchBuilder);

                if (dialog.getAction() == WindowManager_v2.BUTTONS_OK) {

                    ((DefaultDialog) dialog).setVisible(false);

                }

                ReportDataSet reportDataSet = reportManager.createDataSet(store, fquery);

                Report report = fetchBuilder.toReport(reportDataSet);

                doShowReport(report);

            });

            dialog.show(WindowManager.MODE.WINDOW);

        });

        return item;

    }

    private void doShowReport(Report report) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        WindowManager winManager = ToolsSwingLocator.getWindowManager();

        ReportSwingManager swingManager = ReportSwingLocator.getReportSwingManager();

        FeatureQuery query = this.context.getQuery().getCopy();

        Expression filter;

        if (this.context.getSelectedsCount() > 0) {

            filter = this.context.getFilterForSelecteds();

        } else {

            filter = query.getExpressionFilter();

        }

        query.retrievesAllAttributes();

        JReport reportPanel = swingManager.createJReport(report, filter);

        reportPanel.asJComponent().setPreferredSize(new Dimension(800, 500));

        winManager.showWindow(

                reportPanel.asJComponent(),

                i18n.getTranslation("_Report") + ": " + report.getName(),

                WindowManager.MODE.WINDOW

        );

    }

}

        StoreReportsAction.ReportsActionFactory.selfRegister();