gvSIG projects pool

/**

 * 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.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.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.evaluator.Evaluator;

import org.gvsig.tools.evaluator.EvaluatorData;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.util.UnmodifiableTuple;

import org.gvsig.tools.util.UnmodifiableTupleListAdapter;

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 String filter;

    private boolean exposeGeometry;

    private final DefaultSelectionOfFeatures selectionOfFeatures;

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

            }

        }

    }

    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 = 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.size(); 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, null, null, true);

    }

    @Override

    public void accept(Visitor visitor, String filter) {

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

    }

    @Override

    @SuppressWarnings("UseSpecificCatch")

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

        try {

            if (this.selectionOfFeatures.isEmpty()) {

                FeatureQuery dataQuery = this.getQuery();

                if (!StringUtils.isEmpty(filter)) {

                    dataQuery.addFilter(filter);

                }

                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 (StringUtils.isEmpty(filter)) {

                this.selectionOfFeatures.accept(visitor);

                return;

            }

            DataManager manager = DALLocator.getDataManager();

            final Evaluator eval = manager.createExpresion(filter);

            this.selectionOfFeatures.accept(new Visitor() {

                @Override

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

                    Feature f = (Feature)o;

                    Boolean r = (Boolean) eval.evaluate((EvaluatorData) f);

                    if( r ) {

                        visitor.visit(f);

                    }

                }

            });

        } catch (Exception ex) {

            throw new RuntimeException(ex);

        }

    }

    @Override

    public FeatureQuery getQuery() {

        FeatureStore st = this.getStore();

        FeatureQuery dataQuery = st.createFeatureQuery();

        if (!StringUtils.isEmpty(this.filter)) {

            dataQuery.addFilter(this.filter);

        }

        dataQuery.setLimit(limit);

        return dataQuery;

    }

    @Override

    public SelectionOfFeatures getSelectionOfFeatures() {

        return this.selectionOfFeatures;

    }

    @Override

    public UnmodifiableTuple<Feature> getFeatures() {

        List<Feature> r;

        if (this.selectionOfFeatures.isEmpty()) {

            FeatureStore theStore = this.getStore();

            FeatureQuery query = this.getQuery();

            r = theStore.getFeatures(query);

            return new UnmodifiableTupleListAdapter(r);

        }

        return this.getSelectionOfFeatures();

    }

    @Override

    public int getLimit() {

        return this.limit;

    }

    @Override

    public String getFilter() {

        return this.filter;

    }

    @Override

    public void setLimit(int limit) {

        this.limit = limit;

    }

    @Override

    public void setFilter(String filter) {

        this.filter = filter;

    }

    @Override

    public boolean getExposeGeometry() {

        return this.exposeGeometry;

    }

    @Override

    public void setExposeGeometry(boolean selected) {

        this.exposeGeometry = selected;

    }

}