gvSIG projects pool

org.gvsig.report.lib.impl.ReportImplLibrary

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.report.lib.impl;

import java.io.File;

import java.io.IOException;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemStoreParameters;

import org.gvsig.tools.visitor.Visitor;

import org.json.JSONObject;

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

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.util.UnmodifiableBasicList64;

import org.gvsig.tools.util.UnmodifiableBasicList64Adapter;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.json.JSONArray;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("EqualsAndHashcode")

public class DefaultReportDataSet implements ReportDataSet {

    private final ReportServices services;

    private String name;

    private FeatureStore store;

    private String fullName;

    private File path;

    private int limit;

    private Expression filter;

    private boolean exposeGeometry;

    private final DefaultSelectionOfFeatures selectionOfFeatures;

    private FeatureQuery query;

    public DefaultReportDataSet(ReportServices services, String name, FeatureStore store) {

        this.services = services;

        this.name = name;

        this.store = store;

        this.selectionOfFeatures = new DefaultSelectionOfFeatures(this);

        if (store != null) {

            this.fullName = store.getFullName();

            DataStoreParameters parameters = this.store.getParameters();

            if (parameters instanceof FilesystemStoreParameters) {

                this.path = ((FilesystemStoreParameters) parameters).getFile();

            }

        }

        this.limit = FeatureQuery.NO_LIMIT;

        this.query = store.createFeatureQuery();

    }

    public DefaultReportDataSet(ReportServices services, String name, FeatureStore store, FeatureQuery query) {

        this(services, name, store);

        if (query == null) {

            this.query = store.createFeatureQuery();

        } else {

            this.query = query;

        }

    }

    public DefaultReportDataSet(ReportServices services, JSONObject jsonDataSet) {

        this.services = services;

        this.selectionOfFeatures = new DefaultSelectionOfFeatures(this);

        this.name = jsonDataSet.getString("name");

        this.fullName = jsonDataSet.getString("fullName");

        this.limit = jsonDataSet.getInt("limit");

        if (jsonDataSet.has("filter")) {

            this.filter = ExpressionUtils.createExpression();

            this.filter.fromJSON(jsonDataSet.getString("filter"));

        } else {

            this.filter = null;

        }

        this.exposeGeometry = jsonDataSet.getBoolean("exposeGeometry");

        if (jsonDataSet.has("path")) {

            this.path = this.services.derelativizeFile(

                    new File(jsonDataSet.getString("path"))

            );

        }

        this.store = null;

        if (jsonDataSet.has("features")) {

            JSONArray jsonFeatures = jsonDataSet.getJSONArray("features");

            for (Object x : jsonFeatures) {

                String referenceCode = (String) x;

                this.selectionOfFeatures.add(referenceCode);

            }

        }

    }

    JSONObject toJSON() {

        JSONObject jsonDataSet = new JSONObject();

        jsonDataSet.put("name", this.name);

        jsonDataSet.put("limit", this.limit);

        jsonDataSet.put("filter", this.filter);

        jsonDataSet.put("fullName", this.fullName);

        jsonDataSet.put("exposeGeometry", this.exposeGeometry);

        if (this.path != null) {

            jsonDataSet.put("path", this.services.relativizeFile(this.path).getPath());

        }

        if (!this.selectionOfFeatures.isEmpty()) {

            JSONArray jsonFeatures = new JSONArray();

            for (int i = 0; i < this.selectionOfFeatures.size64(); i++) {

                FeatureReference reference = this.selectionOfFeatures.getReference(i);

                jsonFeatures.put(reference.getCode());

            }

            jsonDataSet.put("features", jsonFeatures);

        }

        return jsonDataSet;

    }

    @Override

    public boolean equals(Object obj) {

        if (!(obj instanceof DefaultReportDataSet)) {

            return false;

        }

        DefaultReportDataSet other = (DefaultReportDataSet) obj;

        if (this.store != other.store) {

            return false;

        }

        if (!StringUtils.equals(this.getName(), other.getName())) {

            return false;

        }

        return true;

    }

    @Override

    public String getName() {

        return this.name;

    }

    @Override

    public void setName(String name) {

        this.name = name;

    }

    @Override

    @SuppressWarnings("UseSpecificCatch")

    public String toString() {

        try {

            FeatureAttributeDescriptor attr = this.getStore().getDefaultFeatureType().getDefaultGeometryAttribute();

            String geomType = attr.getGeomType().getName();

            return this.name + " (" + geomType + ")";

        } catch (Exception ex) {

            return this.name;

        }

    }

    @Override

    public FeatureStore getStore() {

        if (this.store == null) {

            this.store = this.services.getFeatureStore(this);

        }

        if (this.store != null) {

            DataStoreParameters parameters = this.store.getParameters();

            if (parameters instanceof FilesystemStoreParameters) {

                this.path = ((FilesystemStoreParameters) parameters).getFile();

            }

        }

        return this.store;

    }

    @Override

    public FeatureType getFeatureType() {

        FeatureStore theStore = this.getStore();

        try {

            return theStore.getDefaultFeatureType();

        } catch (DataException ex) {

            return null;

        }

    }

    @Override

    public boolean hasThisStore(FeatureStore store) {

        if (store == null) {

            return false;

        }

        if (this.path != null) {

            try {

                DataStoreParameters parameters = store.getParameters();

                if (parameters instanceof FilesystemStoreParameters) {

                    File thePath = ((FilesystemStoreParameters) parameters).getFile();

                    if (this.path.getCanonicalPath().equals(thePath.getCanonicalPath())) {

                        return true;

                    }

                }

            } catch (IOException ex) {

            }

        }

        return StringUtils.equals(this.fullName, store.getFullName());

    }

    @Override

    public void accept(Visitor visitor) {

        this.accept(visitor, (Expression) null, null, true);

    }

    @Override

    public void accept(Visitor visitor, Expression filter) {

        this.accept(visitor, filter, null, true);

    }

    @Override

    public void accept(final Visitor visitor, String filter, String sortfields, boolean ascending) {

        this.accept(visitor, ExpressionUtils.createExpression(filter), sortfields, ascending);

    }

    @Override

    @SuppressWarnings("UseSpecificCatch")

    public void accept(final Visitor visitor, final Expression filter, String sortfields, boolean ascending) {

        try {

            if (this.selectionOfFeatures.isEmpty()) {

                FeatureQuery dataQuery = this.getQuery();

                if (filter != null) {

                    dataQuery.addFilter(filter);

                    dataQuery.retrievesAllAttributes();

                }

                if (!StringUtils.isEmpty(sortfields)) {

                    FeatureQueryOrder order = dataQuery.getOrder();

                    for (String field : StringUtils.split(sortfields, ',')) {

                        order.add(field, ascending);

                    }

                }

                FeatureStore st = this.getStore();

                st.accept(visitor, dataQuery);

                return;

            }

            if (filter == null) {

                this.selectionOfFeatures.accept(visitor);

                return;

            }

            DataManager manager = DALLocator.getDataManager();

            final FeatureSymbolTable featureSymbolTable = manager.createFeatureSymbolTable();

            this.selectionOfFeatures.accept(new Visitor() {

                @Override

                public void visit(Object o) throws VisitCanceledException, BaseException {

                    featureSymbolTable.setFeature((Feature) o);

                    Boolean r = (Boolean) filter.execute(featureSymbolTable);

                    if (r) {

                        visitor.visit(o);

                    }

                }

            });

        } catch (Exception ex) {

            throw new RuntimeException(ex);

        }

    }

    @Override

    public FeatureQuery getQuery() {

        return this.getQuery(null);

    }

    public FeatureQuery getQuery(Expression filter) {

        FeatureQuery dataQuery = this.query; 

        if (!ExpressionUtils.isPhraseEmpty(this.filter) && !ExpressionUtils.isPhraseEmpty(filter)) {

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            Expression f = ExpressionUtils.createExpression(

                    builder.and(filter, this.filter).toString()

            );

            dataQuery.addFilter(f);

            dataQuery.retrievesAllAttributes();

        } else if (!ExpressionUtils.isPhraseEmpty(this.filter)) {

            dataQuery.addFilter(this.filter);

            dataQuery.retrievesAllAttributes();

        } else if (!ExpressionUtils.isPhraseEmpty(filter)) {

            dataQuery.addFilter(filter);

            dataQuery.retrievesAllAttributes();

        }

        dataQuery.setLimit(limit);

        return dataQuery;

    }

    @Override

    public SelectionOfFeatures getSelectionOfFeatures() {

        return this.selectionOfFeatures;

    }

    @Override

    public UnmodifiableBasicList64<Feature> getFeatures() {

        return this.getFeatures(null);

    }

    @Override

    public UnmodifiableBasicList64<Feature> getFeatures(Expression filter) {

        List<Feature> r;

        if (this.selectionOfFeatures.isEmpty()) {

            FeatureStore theStore = this.getStore();

            FeatureQuery query = this.getQuery(filter);

            r = theStore.getFeatures(query);

            return new UnmodifiableBasicList64Adapter<>(r);

        }

        return this.getSelectionOfFeatures();

    }

    @Override

    public int getLimit() {

        return this.limit;

    }

    @Override

    public Expression getFilter() {

        return this.filter;

    }

    @Override

    public void setLimit(int limit) {

        this.limit = limit;

    }

    @Override

    public void setFilter(Expression filter) {

        this.filter = filter;

    }

    @Override

    public boolean getExposeGeometry() {

        return this.exposeGeometry;

    }

    @Override

    public void setExposeGeometry(boolean selected) {

        this.exposeGeometry = selected;

    }

    @Override

    public String getURLPath() {

        String p = "/dataset/" + this.getName();

        return p;

    }

}

package org.gvsig.report.lib.impl;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.URL;

import net.sf.jasperreports.engine.JRRuntimeException;

import net.sf.jasperreports.engine.util.JRLoader;

import net.sf.jasperreports.repo.InputStreamResource;

import net.sf.jasperreports.repo.ObjectResource;

import net.sf.jasperreports.repo.Resource;

import net.sf.jasperreports.repo.StreamRepositoryService;

import org.gvsig.report.lib.impl.commands.GetImage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class ResourcesRepositoryService implements StreamRepositoryService {

    private final ResourcesStorage resources;

    private final GetImage fetchFromField;

    private class GVResourceToJRInputStreamResourceAdapter extends InputStreamResource {

        private final ResourcesStorage.Resource resource;

        public GVResourceToJRInputStreamResourceAdapter(ResourcesStorage.Resource resource) {

            this.resource = resource;

        }

        @Override

        public InputStream getValue() {

            try {

                return this.resource.asInputStream();

            } catch (IOException ex) {

                return null;

            }

        }

    }

    private class URLToJRInputStreamResourceAdapter extends InputStreamResource {

        private final URL url;

        public URLToJRInputStreamResourceAdapter(URL url) {

            this.url = url;

        }

        @Override

        public InputStream getValue() {

            try {

                return this.url.openStream();

            } catch (IOException ex) {

                return null;

            }

        }

    }

    private class ByteArrayToJRInputStreamResourceAdapter extends InputStreamResource {

        private final byte[] data;

        public ByteArrayToJRInputStreamResourceAdapter(byte[] data) {

            this.data = data;

        }

        @Override

        public InputStream getValue() {

          ByteArrayInputStream is = new ByteArrayInputStream(this.data);

          return is;

        }

    }

    public ResourcesRepositoryService(ResourcesStorage resources) {

        this.resources = resources;

        this.fetchFromField = new GetImage();

    }

    @Override

    public InputStream getInputStream(String uri) {

        try {

            InputStream is;

            ResourcesStorage.Resource resource = this.resources.getResource(uri);

            if (resource != null) {

                is = resource.asInputStream();

            } else {

                URL url = new URL(uri);

                if( this.fetchFromField.canUse(url) ) {

                  byte[] image = this.fetchFromField.fetch(url);

                  is = new ByteArrayInputStream(image);

                } else {

                  is = url.openStream();

                }

            }

            return is;

        } catch (Exception ex) {

            throw new JRRuntimeException(ex);

        }

    }

    @Override

    public OutputStream getOutputStream(String uri) {

        return null;

    }

    @Override

    public Resource getResource(String uri) {

        try {

            Resource r;

            ResourcesStorage.Resource resource = this.resources.getResource(uri);

            if (resource != null) {

                r = new GVResourceToJRInputStreamResourceAdapter(resource);

                return r;

            } else {

                URL url = new URL(uri);

                if( this.fetchFromField.canUse(url) ) {

                  byte[] image = this.fetchFromField.fetch(url);

                  r = new ByteArrayToJRInputStreamResourceAdapter(image);

                } else {

                  r = new URLToJRInputStreamResourceAdapter(url);

                }

            }

            return r;

        } catch (Exception ex) {

            throw new JRRuntimeException(ex);

        }

    }

    @Override

    public void saveResource(String uri, Resource resource) {

    }

    @Override

    public <K extends Resource> K getResource(String uri, Class<K> resourceType) {

        try {

            ObjectResource r = (ObjectResource) resourceType.newInstance();

            r.setName(uri);

            ResourcesStorage.Resource resource = this.resources.getResource(uri);

            if (resource != null) {

                InputStream is = resource.asInputStream();

                if (is!=null) {

                    Object v = JRLoader.loadObject(is);

                    r.setValue(v);

                    return (K) r;

                }

            }

            URL url = new URL(uri);

            if (this.fetchFromField.canUse(url)) {

                byte[] image = this.fetchFromField.fetch(url);

                ByteArrayInputStream is = new ByteArrayInputStream(image);

                r.setValue(is);

            } else {

                r.setValue(url.openStream());

            }

            return (K) r;

        } catch (Throwable th) {

            return null;

        }

    }

}

package org.gvsig.report.lib.impl;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

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

import org.json.JSONArray;

import org.json.JSONObject;

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

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

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

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

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

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

/**

 *

 * @author jjdelcerro

 */

public class DefaultReportServerConfig implements ReportServerConfig {

    private int port;

    private int timeout;

    private String serverInfo;

    private ReportDataSets datasets;

    private boolean locked;

    private DefaultReportViewCaptures viewCaptures;

    private final PropertyChangeSupport propertyChangeSupport;

    private final ReportServices services;

    private final ReportManager manager;

    private boolean autostart;

    public DefaultReportServerConfig(ReportManager manager, ReportServices services) {

        this.services = services;

        this.manager = manager;

        this.port = 9876;

        this.timeout = 15000;

        this.serverInfo = "Test/1.1";

        this.locked = false;

        this.autostart = false;

        this.propertyChangeSupport = new PropertyChangeSupport(this);

        this.viewCaptures = new DefaultReportViewCaptures();

        this.viewCaptures.addPropertyChangeListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                propertyChangeSupport.firePropertyChange("viewCaptures", null, null);

            }

        });

        this.datasets = new DefaultReportDataSets(manager, services);

        this.datasets.addPropertyChangeListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                propertyChangeSupport.firePropertyChange("datasets", null, null);

            }

        });

    }

    @Override

    public ReportServices getServices() {

        return this.services;

    }

    public boolean isLocked() {

        return locked;

    }

    public void setLocked(boolean locked) {

        this.locked = locked;

    }

    @Override

    public int getPort() {

        return this.port;

    }

    @Override

    public ReportServerConfig setPort(int port) {

        int oldValue = this.port;

        this.port = port;

        this.propertyChangeSupport.firePropertyChange("port", oldValue, port);

        return this;

    }

    @Override

    public int getTimeout() {

        return this.timeout;

    }

    @Override

    public ReportServerConfig setTimeout(int timeout) {

        int oldValue = this.timeout;

        this.timeout = timeout;

        this.propertyChangeSupport.firePropertyChange("timeout", oldValue, timeout);

        return this;

    }

    @Override

    public String getServerInfo() {

        return this.serverInfo;

    }

    @Override

    public ReportServerConfig setServerInfo(String serverInfo) {

        String oldValue = this.serverInfo;

        this.serverInfo = serverInfo;

        this.propertyChangeSupport.firePropertyChange("serverInfo", oldValue, serverInfo);

        return this;

    }

    @Override

    public ReportDataSets getDatasets() {

        return this.datasets;

    }

    @Override

    public ReportDataSet getDataset(String name) {

        ReportDataSet dataset = this.datasets.get(name);

        if( dataset == null ) {

          DataManager dataManager = DALLocator.getDataManager();

          DataStore store = dataManager.getStoresRepository().getStore(name);

          if( store == null || !(store instanceof FeatureStore)) {

            return null;

          }

          dataset = new DefaultReportDataSet(services, name, (FeatureStore) store, null);

        }

        return dataset;

    }

    @Override

    public String toJSON() {

        JSONObject jsonconfig = new JSONObject();

        jsonconfig.put("port", this.port);

        jsonconfig.put("timeout", this.timeout);

        jsonconfig.put("serverInfo", this.serverInfo);

        jsonconfig.put("autostart", this.autostart);

        JSONArray jsondatasets = new JSONArray();

        jsonconfig.put("datasets", jsondatasets);

        for (ReportDataSet dataset : this.datasets) {

            jsondatasets.put(((DefaultReportDataSet) dataset).toJSON());

        }

        JSONArray jsonviewcaptures = new JSONArray();

        jsonconfig.put("viewcaptures", jsonviewcaptures);

        for (ReportViewCapture viewcapture : this.viewCaptures) {

            jsonviewcaptures.put(((DefaultReportViewCapture) viewcapture).toJSON());

        }

        return jsonconfig.toString();

    }

    public void fromJSON(JSONObject jsonConfig) {

        DefaultReportDataSets theDatasets = new DefaultReportDataSets(manager, services);

        DefaultReportViewCaptures theViewCaptures = new DefaultReportViewCaptures();

        if (jsonConfig.has("port")) {

            this.port = jsonConfig.getInt("port");

        }

        if (jsonConfig.has("timeout")) {

            this.timeout = jsonConfig.getInt("timeout");

        }

        if (jsonConfig.has("serverInfo")) {

            this.serverInfo = jsonConfig.getString("serverInfo");

        }

        if (jsonConfig.has("autostart")) {

            this.autostart = jsonConfig.getBoolean("autostart");

        }

        if (jsonConfig.has("datasets")) {

            JSONArray jsonDatasets = jsonConfig.getJSONArray("datasets");

            for (Object jsonDataset : jsonDatasets) {

                if( !(jsonDataset instanceof JSONObject) ) {

                    jsonDataset = new JSONObject(jsonDataset.toString());

                }

                ReportDataSet dataset = new DefaultReportDataSet(

                        this.getServices(),

                        (JSONObject) jsonDataset

                );

                theDatasets.add(dataset);

            }

        }

        theDatasets.addPropertyChangeListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                propertyChangeSupport.firePropertyChange("datasets", null, null);

            }

        });

        this.datasets = theDatasets;

        if (jsonConfig.has("viewcaptures")) {

            JSONArray jsonViewCaptures = jsonConfig.getJSONArray("viewcaptures");

            for (Object jsonViewCapture : jsonViewCaptures) {

                if( !(jsonViewCapture instanceof JSONObject) ) {

                    jsonViewCapture = new JSONObject(jsonViewCapture.toString());

                }

                ReportViewCapture viewCapture = new DefaultReportViewCapture(

                        this,

                        (JSONObject) jsonViewCapture

                );

                theViewCaptures.add(viewCapture);

            }

        }

        theViewCaptures.addPropertyChangeListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                propertyChangeSupport.firePropertyChange("viewcaptures", null, null);

            }

        });

        this.viewCaptures = theViewCaptures;

    }

    @Override

    public List<ReportViewCapture> getViewCaptures() {

        return this.viewCaptures;

    }

    @Override

    public ReportViewCapture getViewCapture(String name) {

        for (ReportViewCapture viewCapture : viewCaptures) {

            if( StringUtils.equalsIgnoreCase(name, viewCapture.getName()) ) {

                return viewCapture;

            }

        }

        return null;

    }

    @Override

    public void addPropertyChangeListener(PropertyChangeListener listener) {

        this.propertyChangeSupport.addPropertyChangeListener(listener);

    }

    @Override

    public void removePropertyChangeListener(PropertyChangeListener listener) {

        this.propertyChangeSupport.removePropertyChangeListener(listener);

    }

    @Override

    public boolean getAutostart() {

        return this.autostart;

    }

    @Override

    public void setAutostart(boolean autostart) {

        boolean oldValue = this.autostart;

        this.autostart = autostart;

        this.propertyChangeSupport.firePropertyChange("autostart", oldValue, this.autostart);

    }

}

package org.gvsig.report.lib.impl;

import java.awt.Dimension;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.io.UnsupportedEncodingException;

import java.net.URLEncoder;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.Formatter;

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

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

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

import org.json.JSONObject;

/**

 *

 * @author jjdelcerro

 */

public class DefaultReportViewCapture implements ReportViewCapture {

    private static int counter = 0;

    private class DefaultReportViewCaptureFilter implements ReportViewCaptureFilter {

        private Expression expression;

        private String datasetName;

        private final PropertyChangeSupport propertyChangeSupport;

        public DefaultReportViewCaptureFilter() {

            this.propertyChangeSupport = new PropertyChangeSupport(this);

        }

        public DefaultReportViewCaptureFilter(JSONObject json) {

            this();

            if( json.has("expression") ) {

                this.expression = ExpressionUtils.createExpressionFromJSON(

                        json.getString("expression")

                );

            }

            if( json.has("datasetName") ) {

                this.datasetName = json.getString("datasetName");

            }

        }

        public JSONObject toJSON() {

            JSONObject me = new JSONObject();

            if( this.expression!=null ) {

                me.put("expression", this.expression.toJSON());

            }

            me.put("datasetName", StringUtils.defaultIfEmpty(this.datasetName,null));

            return me;

        }

        public String getURLPart() {

            if( StringUtils.isBlank(reportDataSetName) ) {

                return null;

            }

            ReportDataSet dataset = config.getDataset(reportDataSetName);

            if( dataset == null ) {

                return null;

            }

            Formatter reportformatter = new ReportExpressionCodeFormatter(

                    dataset.getFeatureType()

            );

            String s = expression.getCode().toString(reportformatter);

            s = s.replace(" ","+");

            return s;

        }

        @Override

        public String getDataSet() {

            return this.datasetName;

        }

        @Override

        public Expression getExpression() {

            return this.expression;

        }

        @Override

        public void setDataSet(String dataset) {

            this.datasetName = dataset;

            this.propertyChangeSupport.firePropertyChange("dataset", null, null);

        }

        @Override

        public void setDataSet(ReportDataSet dataset) {

            if( dataset == null ) {

                this.datasetName = null;

            } else {

                this.datasetName = dataset.getName();

            }

            this.propertyChangeSupport.firePropertyChange("dataset", null, null);

        }

        @Override

        public void setExpression(Expression expression) {

            this.expression = expression;

            this.propertyChangeSupport.firePropertyChange("expression", null, null);

        }

        @Override

        public boolean isEmpty() {

            return StringUtils.isEmpty(this.datasetName) || 

                    ExpressionUtils.isPhraseEmpty(this.expression);

        }

        public void addPropertyChangeListener(PropertyChangeListener listener) {

            this.propertyChangeSupport.addPropertyChangeListener(listener);

        }

        public void removePropertyChangeListener(PropertyChangeListener listener) {

            this.propertyChangeSupport.removePropertyChangeListener(listener);

        }

    }

    private DefaultReportViewCaptureFilter zoomFilter;

    private DefaultReportViewCaptureFilter centerFilter;

    private DefaultReportViewCaptureFilter selectFilter;

    private String name;

    private String viewName;

    private String reportDataSetName;

    private int margins;

    private boolean clearSelection;

    private Dimension dimensions;

    private int resolution;

    private final PropertyChangeSupport propertyChangeSupport;

    private final ReportServerConfig config;

    public DefaultReportViewCapture(ReportServerConfig config) {

        this.config = config;

        this.centerFilter = new DefaultReportViewCaptureFilter();

        this.centerFilter.addPropertyChangeListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                propertyChangeSupport.firePropertyChange("centerFilter", null, null);

            }

        });

        this.zoomFilter = new DefaultReportViewCaptureFilter();

        this.zoomFilter.addPropertyChangeListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                propertyChangeSupport.firePropertyChange("zoomFilter", null, null);

            }

        });

        this.selectFilter = new DefaultReportViewCaptureFilter();

        this.selectFilter.addPropertyChangeListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                propertyChangeSupport.firePropertyChange("selectFilter", null, null);

            }

        });

        this.resolution = 72;

        this.clearSelection = false;

        this.name = "capture"+counter++;

        this.viewName = null;

        this.margins = 0;

        this.dimensions = new Dimension();

        this.propertyChangeSupport = new PropertyChangeSupport(this);

    }

    public DefaultReportViewCapture(ReportServerConfig config, JSONObject json) {

        this(config);

        this.fromJSON(json);

    }

    @Override

    public boolean isEmpty() {

        return StringUtils.isBlank(this.viewName);

    }

    @Override

    public String getReportDataSet() {

        return reportDataSetName;

    }

    @Override

    public void setReportDataSet(String reportDataSet) {

        this.reportDataSetName = reportDataSet;

    }

    @Override

    public String toString() {

        return this.getName();

    }

    @Override

    public String getName() {

        return this.name;

    }

    @Override

    public void setName(String name) {

        this.name = name;

        this.propertyChangeSupport.firePropertyChange("name", null, null);

    }

    @Override

    public String getView() {

        return this.viewName;

    }

    @Override

    public void setView(String view) {

        this.viewName = view;

        this.propertyChangeSupport.firePropertyChange("view", null, null);

    }

    private static String encodeForURL(String s) {

        try {

            return URLEncoder.encode(s, "UTF8");

        } catch (UnsupportedEncodingException ex) {

            return s;

        }

    }

    @Override

    public String getFullURLPath() {

        StringBuilder builder = new StringBuilder();

        builder.append("/captureview/captureName/");

        builder.append(encodeForURL(this.name));

        builder.append("/viewName/");

        builder.append(encodeForURL(this.viewName));

        if( this.getResolution()>0 ) {

            builder.append("/DPI/");

            builder.append(this.getResolution());

        }

        if (!this.centerFilter.isEmpty()) {

            builder.append("/center/");

            builder.append(this.centerFilter.getDataSet());

            builder.append("/");

            builder.append(this.centerFilter.getURLPart());

        }

        if (!this.zoomFilter.isEmpty()) {

            builder.append("/zoom/");

            builder.append(this.zoomFilter.getDataSet());

            builder.append("/");

            builder.append(this.zoomFilter.getURLPart());

        }

        if (!this.selectFilter.isEmpty()) {

            builder.append("/select/");

            builder.append(this.selectFilter.getDataSet());

            builder.append("/");

            builder.append(this.selectFilter.getURLPart());

        }

        if (this.margins > 0) {

            builder.append("/margins/");

            builder.append(this.margins);

        }

        if (this.clearSelection) {

            builder.append("/clearselection");

        }

        if (this.hasDimensions()) {

            builder.append("/width/");

            builder.append(this.dimensions.width);

            builder.append("/height/");

            builder.append(this.dimensions.height);

        }

        return builder.toString();

    }

    @Override

    public boolean hasDimensions() {

        return this.dimensions.height > 0 || this.dimensions.width > 0;

    }

    @Override

    public Dimension getDimensions() {

        return this.dimensions;

    }

    @Override

    public ReportViewCaptureFilter getZoomFilter() {

        return this.zoomFilter;

    }

    @Override

    public ReportViewCaptureFilter getCenterFilter() {

        return this.centerFilter;

    }

    @Override

    public ReportViewCaptureFilter getSelectionFilter() {

        return this.selectFilter;

    }

    @Override

    public int getMargins() {

        return this.margins;

    }

    @Override

    public void setMargins(int margins) {

        this.margins = margins;

        this.propertyChangeSupport.firePropertyChange("margins", null, null);

    }

    @Override

    public boolean getClearSelection() {

        return this.clearSelection;

    }

    @Override

    public void setClearSelection(boolean clearSelection) {

        this.clearSelection = clearSelection;

        this.propertyChangeSupport.firePropertyChange("clearSelection", null, null);

    }

    public void addPropertyChangeListener(PropertyChangeListener listener) {

        this.propertyChangeSupport.addPropertyChangeListener(listener);

    }

    public void removePropertyChangeListener(PropertyChangeListener listener) {

        this.propertyChangeSupport.removePropertyChangeListener(listener);

    }

    public JSONObject toJSON() {

        JSONObject me = new JSONObject();

        me.put("zoomFilter", this.zoomFilter.toJSON());

        me.put("centerFilter", this.centerFilter.toJSON());

        me.put("selectFilter", this.selectFilter.toJSON());

        me.put("viewName", this.viewName);

        me.put("reportDataSetName", this.reportDataSetName);

        me.put("clearSelection", this.clearSelection);

        me.put("dimension.width", this.dimensions.width);

        me.put("dimension.height", this.dimensions.height);

        return me;

    }

    public void fromJSON(JSONObject json) {

        this.zoomFilter = new DefaultReportViewCaptureFilter(json.getJSONObject("zoomFilter"));

        this.centerFilter = new DefaultReportViewCaptureFilter(json.getJSONObject("centerFilter"));

        this.selectFilter = new DefaultReportViewCaptureFilter(json.getJSONObject("selectFilter"));

        if( json.has("viewName") ) {

            this.viewName = json.getString("viewName");

        }

        if( json.has("reportDataSetName") ) {

            this.reportDataSetName = json.getString("reportDataSetName");

        }

        if( json.has("clearSelection") ) {

            this.clearSelection = json.getBoolean("clearSelection");

        }

        int width = 0;

        int height = 0;

        if( json.has("dimension.width") ) {

            width = json.getInt("dimension.width");

        }

        if( json.has("dimension.height") ) {

            height = json.getInt("dimension.height");

        }

        this.dimensions = new Dimension(width, height);

    }

    @Override

    public int getResolution() {

        return this.resolution;

    }

    @Override

    public void setResolution(int resolution) {

        this.resolution = resolution;

    }

}

package org.gvsig.report.lib.impl;

import ar.com.fdvs.dj.domain.CustomExpression;

import java.util.HashMap;

import java.util.Map;

import java.util.Objects;

import net.sf.jasperreports.engine.JREmptyDataSource;

import net.sf.jasperreports.engine.JRException;

import net.sf.jasperreports.engine.JRField;

import net.sf.jasperreports.engine.JRRewindableDataSource;

import net.sf.jasperreports.engine.JasperReportsContext;

import static net.sf.jasperreports.engine.data.JRTableModelDataSource.EXCEPTION_MESSAGE_KEY_UNKNOWN_COLUMN_NAME;

import net.sf.jasperreports.engine.data.JsonData;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.StoresRepository;

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

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

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

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

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

import static org.gvsig.report.lib.impl.ReportImplLibrary.TAG_REPORT_ATTR_LABEL;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.dataTypes.CoercionContext;

import org.gvsig.tools.util.GetItem;

import org.gvsig.tools.util.GetItem64;

import org.gvsig.tools.util.Size;

import org.gvsig.tools.util.Size64;

import org.gvsig.tools.util.UnmodifiableBasicList64;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class JRFeatureStoreDataSource1

        implements JRRewindableDataSource, JsonData, Size64, Size, GetItem<Feature>, GetItem64<Feature> {

    protected static final Logger LOGGER = LoggerFactory.getLogger(JRFeatureStoreDataSource1.class);

    private UnmodifiableBasicList64<Feature> features;

    private long index;

    private final StoresRepository storesRepository;

    private final JasperReportsContext context;

    protected String name;

    private Map<String, Coercion> coercions;

    private final FeatureType featureType;

    private final LabelsCacheForFieldValues labelsCacheForFieldValues;

    public JRFeatureStoreDataSource1(JasperReportsContext context, UnmodifiableBasicList64<Feature> features, StoresRepository storesRepository, FeatureType featureType) {

        this.context = context;

        this.features = features;

        this.storesRepository = storesRepository;

        this.index = -1;

        this.name = "<unknown>";

        this.coercions = new HashMap<>();

        this.featureType = featureType;

        this.labelsCacheForFieldValues = DALLocator.getDataManager()

                .createLabelsCacheForFieldValues((Object... args) -> {

                    // FeatureType, Feature, String(fieldName)

                    FeatureAttributeDescriptor attr = ((FeatureType)args[0]).getAttributeDescriptor((String)args[2]);

                    String labelFormula = attr.getTags().getString(TAG_REPORT_ATTR_LABEL, null);

                    return labelFormula;

        },null);

        LOGGER.info("DataSource(" + this.name + ")");

    }

    public JRFeatureStoreDataSource1(JasperReportsContext context, FeatureStore store, Expression filter) {

        this(

                context,

                (UnmodifiableBasicList64<Feature>) store.getFeatures(filter),

                store.getStoresRepository(),

                store.getDefaultFeatureTypeQuietly()

        );

        this.name = store.getName();

    }

    @Override

    public boolean next() throws JRException {

        this.index++;

        boolean n = this.index < this.features.size64();

        return n;

    }

    public String getLabel(Feature feature, String fieldName) {

        return this.labelsCacheForFieldValues.getLabelForFieldValue(feature, fieldName);

    }

    @Override

    public Object getFieldValue(JRField jrField) throws JRException {

        String fieldName = jrField.getName();

//        System.out.println("DataSurce("+this.name+") ["+this.index+"] getFieldValue("+fieldName+").");

        try {

            Feature feature = this.features.get64(index);

            Object value;

            if (fieldName.startsWith("COLUMN_")) {

                value = feature.get(Integer.parseInt(fieldName.substring(7)));

            } else if (fieldName.endsWith("@label")) {

                fieldName = StringUtils.removeEnd(fieldName, "@label");

                value = this.getLabel(feature, fieldName);

            } else {

                value = feature.get(fieldName);

            }

            if (jrField.getValueClass() != null && !jrField.getValueClass().isInstance(value)) {

                Coercion coercion = this.coercions.get(fieldName);

                if (coercion == null) {

                    DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();

                    DataType dataType = dataTypesManager.getDataType(jrField.getValueClass());

                    if (dataType == null) {

                        coercion = new DummyCoercion();

                    } else {

                        coercion = dataType.getCoercion();

                    }

                    this.coercions.put(fieldName, coercion);

                }

                try {

                    value = coercion.coerce(value);

                } catch (CoercionException ex) {

                }

            }

            return value;

        } catch (Exception ex) {

            if (CustomExpression.class.isAssignableFrom(jrField.getValueClass())) {

                return null;

            }

            throw new JRException(

                    EXCEPTION_MESSAGE_KEY_UNKNOWN_COLUMN_NAME,

                    new Object[]{fieldName},

                    ex

            );

        }

    }

    @Override

    public void moveFirst() throws JRException {

        this.index = -1;

//        System.out.println("DataSurce("+this.name+") ["+this.index+"] moveFirst().");

    }

    @Override

    public long size64() {

        return this.features.size64();

    }

    @Override

    public int size() {

        long sz = this.features.size64();

        if (sz > Integer.MAX_VALUE) {

            return Integer.MAX_VALUE;

        }

        return (int) sz;

    }

    @Override

    public Feature get(int position) {

        return this.features.get64(position);

    }

    @Override

    public Feature get64(long position) {

        return this.features.get64(position);

    }

    @Override

    public JsonData subDataSource() throws JRException {

        return new JRFeatureStoreDataSource1(this.context, this.features, this.storesRepository, this.featureType);

    }

    @Override

    public JsonData subDataSource(String selectExpression) throws JRException {

        LOGGER.info("DataSurce(" + this.name + ").subDataSource(" + Objects.toString(selectExpression, "null") + ").");

        if (StringUtils.isBlank(selectExpression)) {

            return new JREmptyJSonData(1, this.storesRepository);

        }

        String storeName;

        Expression filter = null;

        selectExpression = selectExpression.trim();

        if (selectExpression.toUpperCase().startsWith("SELECT ")) {

            selectExpression = selectExpression.substring(7).trim();

            if (selectExpression.startsWith("* ")) {

                selectExpression = selectExpression.substring(2).trim();

            }

            if (selectExpression.toUpperCase().startsWith("FROM ")) {

                selectExpression = selectExpression.substring(5).trim();

            }

        }

        int n = selectExpression.indexOf(" WHERE ");

        if (n < 0) {

            storeName = selectExpression.trim();

        } else {

            storeName = selectExpression.substring(0, n).trim();

            filter = ExpressionUtils.createExpression(selectExpression.substring(n + 6).trim());

        }

        if (this.storesRepository.get(storeName) == null) {

            return new JREmptyJSonData(1, this.storesRepository);

        }

        JRFeatureStoreDataSource1 x = new JRFeatureStoreDataSource1(

                this.context,

                (FeatureStore) this.storesRepository.getStore(storeName),

                filter

        );

        return x;

    }

    private class JREmptyJSonData extends JREmptyDataSource implements JsonData {

        JREmptyJSonData(int rows, StoresRepository storesRepository) {

            super(rows);

        }

        @Override

        public JsonData subDataSource() throws JRException {

            return JRFeatureStoreDataSource1.this.subDataSource();

        }

        @Override

        public JsonData subDataSource(String selectExpression) throws JRException {

            LOGGER.info("DataSurce(<Empty>) subDataSource(" + Objects.toString(selectExpression, "null") + ")");

            return JRFeatureStoreDataSource1.this.subDataSource(selectExpression);

        }

    }

    private static class DummyCoercion implements Coercion {

        @Override

        public Object coerce(Object o) throws CoercionException {

            return o;

        }

        @Override

        public Object coerce(Object value, CoercionContext context) throws CoercionException {

            return value;

        }

    }

}

package org.gvsig.report.lib.impl.reportbuilder;

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

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 *

 * @author jjdelcerro

 */

public class DefaultMargins implements ReportBuilder.Margins {

    private int top;

    private int bottom;

    private int left;

    private int right;

    public DefaultMargins() {

    }

    @Override

    public void copyFrom(ReportBuilder.Margins other) {

        this.top = other.getTop();

        this.bottom = other.getBottom();

        this.left = other.getLeft();

        this.right = other.getRight();

    }

    @Override

    public int getTop() {

        return this.top;

    }

    @Override

    public int getBottom() {

        return this.bottom;

    }

    @Override

    public int getLeft() {

        return this.left;

    }

    @Override

    public int getRight() {

        return this.right;

    }

    @Override