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.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) {

        FeatureStore st = this.getStore();

        FeatureQuery dataQuery = this.query; //st.createFeatureQuery();

        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);

        }

        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.reportbuilder;

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

import ar.com.fdvs.dj.domain.constants.Font;

import ar.com.fdvs.dj.domain.constants.HorizontalAlign;

import ar.com.fdvs.dj.domain.constants.Rotation;

import ar.com.fdvs.dj.domain.constants.Stretching;

import ar.com.fdvs.dj.domain.constants.Transparency;

import ar.com.fdvs.dj.domain.constants.VerticalAlign;

import java.awt.Color;

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

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

import org.gvsig.tools.persistence.PersistentState;

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

/**

 *

 * @author jjdelcerro

 */

public class DefaultStyleBuilder implements ReportBuilder.StyleBuilder {

    private Color textColor;

    private Color backgroundColor;

    private int rotation;

    private int stretching;

    private boolean stretchingWithOverflow;

    private boolean transparent;

    private int verticalAlign;

    private int horizontalAlign;

    private ReportBuilder.BorderBuilder borderTop;

    private ReportBuilder.BorderBuilder borderBottom;

    private ReportBuilder.BorderBuilder borderLeft;

    private ReportBuilder.BorderBuilder borderRight;

    private int paddingTop;

    private int paddingBottom;

    private int paddingLeft;

    private int paddingRight;

    private int font;

    private int fontSize;

    private int transparency;

    public DefaultStyleBuilder() {

        this.borderTop = new DefaultBorderBuilder();

        this.borderBottom = new DefaultBorderBuilder();

        this.borderLeft = new DefaultBorderBuilder();

        this.borderRight = new DefaultBorderBuilder();

        this.textColor = Color.BLACK;

        this.backgroundColor = Color.WHITE;

        this.transparency = StyleBuilder.TRANSPARENCY_OPAQUE;

        this.transparent = false;

        this.font = StyleBuilder.FONT_ARIAL;

        this.fontSize = 10;

        this.paddingBottom = 2;

        this.paddingLeft = 2;

        this.paddingRight = 2;

        this.paddingTop = 2;

        this.stretching = StyleBuilder.STRETCHING_RELATIVE_TO_TALLEST_OBJECT;

        this.stretchingWithOverflow = true;

    }

    @Override

    public ReportBuilder.StyleBuilder clone() throws CloneNotSupportedException {

        DefaultStyleBuilder other = (DefaultStyleBuilder) super.clone();

        other.borderTop = this.borderTop.clone();

        other.borderBottom = this.borderBottom.clone();

        other.borderLeft = this.borderLeft.clone();

        other.borderRight = this.borderRight.clone();

        return other;

    }

    @Override

    public void copyFrom(ReportBuilder.StyleBuilder other) {

        try {

            this.font = other.getFont();

            this.fontSize = other.getFontSize();

            this.textColor = other.getTextColor();

            this.backgroundColor = other.getBackgroundColor();

            this.rotation = other.getRotation();

            this.stretching = other.getStretching();

            this.stretchingWithOverflow = other.getStretchingWithOverflow();

            this.transparency = other.getTransparency();

            this.transparent = other.getTransparent();

            this.verticalAlign = other.getVerticalAlign();

            this.horizontalAlign = other.getHorizontalAlign();

            this.paddingTop = other.getPaddingTop();

            this.paddingBottom = other.getPaddingBottom();

            this.paddingLeft = other.getPaddingLeft();

            this.paddingRight = other.getPaddingRight();

            this.borderTop = other.getBorderTop().clone();

            this.borderBottom = other.getBorderBottom().clone();

            this.borderLeft = other.getBorderLeft().clone();

            this.borderRight = other.getBorderRight().clone();

        } catch (CloneNotSupportedException ex) {

            throw new RuntimeException("Can't copy Style", ex);

        }

    }

    @Override

    public Color getTextColor() {

        return this.textColor;

    }

    @Override

    public ReportBuilder.StyleBuilder textColor(Color textColor) {

        this.textColor = textColor;

        return this;

    }

    @Override

    public Color getBackgroundColor() {

        return this.backgroundColor;

    }

    @Override

    public ReportBuilder.StyleBuilder backgroundColor(Color backgroundColor) {

        this.backgroundColor = backgroundColor;

        return this;

    }

    @Override

    public int getRotation() {

        return this.rotation;

    }

    @Override

    public ReportBuilder.StyleBuilder rotation(int rotation) {

        this.rotation = rotation;

        return this;

    }

    @Override

    public int getStretching() {

        return this.stretching;

    }

    @Override

    public ReportBuilder.StyleBuilder stretching(int stretching) {

        this.stretching = stretching;

        return this;

    }

    @Override

    public boolean getStretchingWithOverflow() {

        return this.stretchingWithOverflow;

    }

    @Override

    public ReportBuilder.StyleBuilder stretchingWithOverflow(boolean stretchingWithOverflow) {

        this.stretchingWithOverflow = stretchingWithOverflow;

        return this;

    }

    @Override

    public boolean getTransparent() {

        return this.transparent;

    }

    @Override

    public ReportBuilder.StyleBuilder transparent(boolean transparent) {

        this.transparent = transparent;

        return this;

    }

    @Override

    public int getTransparency() {

        return this.transparency;

    }

    @Override

    public ReportBuilder.StyleBuilder transparency(int transparency) {

        this.transparency = transparency;

        return this;

    }

    @Override

    public int getVerticalAlign() {

        return this.verticalAlign;

    }

    @Override

    public ReportBuilder.StyleBuilder verticalAlign(int verticalAlign) {

        this.verticalAlign = verticalAlign;

        return this;

    }

    @Override

    public int getHorizontalAlign() {

        return this.horizontalAlign;

    }

    @Override

    public ReportBuilder.StyleBuilder horizontalAlign(int horizontalAlign) {

        this.horizontalAlign = horizontalAlign;

        return this;

    }

    @Override

    public ReportBuilder.BorderBuilder getBorderTop() {

        return this.borderTop;

    }

    @Override

    public ReportBuilder.StyleBuilder borderTop(ReportBuilder.BorderBuilder border) {

        this.borderTop = border;

        return this;

    }

    @Override

    public ReportBuilder.BorderBuilder getBorderBottom() {

        return this.borderBottom;

    }

    @Override

    public ReportBuilder.StyleBuilder borderBottom(ReportBuilder.BorderBuilder border) {

        this.borderBottom = border;

        return this;

    }

    @Override

    public ReportBuilder.BorderBuilder getBorderLeft() {

        return this.borderLeft;

    }

    @Override

    public ReportBuilder.StyleBuilder borderLeft(ReportBuilder.BorderBuilder border) {

        this.borderLeft = border;

        return this;

    }

    @Override

    public ReportBuilder.BorderBuilder getBorderRight() {

        return this.borderRight;

    }

    @Override

    public ReportBuilder.StyleBuilder borderRight(ReportBuilder.BorderBuilder border) {

        this.borderRight = border;

        return this;

    }

    @Override

    public int getPaddingTop() {

        return this.paddingTop;

    }

    @Override

    public ReportBuilder.StyleBuilder paddingTop(int padding) {

        this.paddingTop = padding;

        return this;

    }

    @Override

    public int getPaddingBottom() {

        return this.paddingBottom;

    }

    @Override

    public ReportBuilder.StyleBuilder paddingBottom(int padding) {

        this.paddingBottom = padding;

        return this;

    }

    @Override

    public int getPaddingLeft() {

        return this.paddingLeft;

    }

    @Override

    public ReportBuilder.StyleBuilder paddingLeft(int padding) {

        this.paddingLeft = padding;

        return this;

    }

    @Override

    public int getPaddingRight() {

        return this.paddingRight;

    }

    @Override

    public ReportBuilder.StyleBuilder paddingRight(int padding) {

        this.paddingRight = padding;

        return this;

    }

    @Override

    public void saveToState(PersistentState ps) throws PersistenceException {

        // TODO

    }

    @Override

    public void loadFromState(PersistentState ps) throws PersistenceException {

        // TODO

    }

    public static void registerPersistence() {

        // TODO

    }

    Style build() {