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.util.Collection;

import java.util.LinkedHashMap;

import java.util.Map;

import javax.json.JsonObject;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.SymbolTable;

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

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

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

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

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

import org.json.JSONObject;

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

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

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

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

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

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

import org.gvsig.report.lib.api.commands.CommandFactory;

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

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

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

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

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

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

import org.gvsig.report.lib.impl.reportbuilder.DefaultReportBuilder;

import org.gvsig.tools.bookmarksandhistory.Bookmarks;

import org.gvsig.tools.bookmarksandhistory.History;

import org.gvsig.tools.bookmarksandhistory.impl.BaseBookmarks;

import org.gvsig.tools.bookmarksandhistory.impl.BaseHistory;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

/**

 *

 * @author jjdelcerro

 */

public class DefaultReportManager implements ReportManager {

    private ReportServer defaultServer = null;

    private final Map<String, CommandFactory> commandFactories;

    private Bookmarks<ReportBuilder> userDefinedReportBookmarks;

    private History<ReportBuilder> userDefinedReportHistory;

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public DefaultReportManager() {

        this.commandFactories = new LinkedHashMap<>();

        this.registerCommandFactory(new CaptureViewFactory());

        this.registerCommandFactory(new GetDatasetFactory());

        this.registerCommandFactory(new HelpFactory());

        this.registerCommandFactory(new ListDatasetsFactory());

        this.registerCommandFactory(new ListViewsFactory());

        this.registerCommandFactory(new GetImageFactory());

        this.userDefinedReportBookmarks = new BaseBookmarks<>();

        this.userDefinedReportHistory = new BaseHistory<>(20);

    }

    @Override

    public Collection<CommandFactory> getCommandFactories() {

        return commandFactories.values();

    }

    @Override

    public void registerCommandFactory(CommandFactory factory) {

        this.commandFactories.put(factory.getName(), factory);

    }

    @Override

    public ReportServer getDefaultServer() {

        return this.defaultServer;

    }

    @Override

    public void setDefaultServer(ReportServer server) {

        this.defaultServer = server;

    }

    @Override

    public ReportServer createServer(ReportServerConfig config) {

        DefaultReportServer server = new DefaultReportServer(this, config);

        if (this.defaultServer == null) {

            this.defaultServer = server;

        }

        return server;

    }

    @Override

    public ReportDataSet createDataSet(

            ReportServices services,

            String name,

            FeatureStore store

    ) {

        return new DefaultReportDataSet(services, name, store);

    }

    @Override

    public ReportServerConfig createServerConfig(ReportServices services) {

        DefaultReportServerConfig config = new DefaultReportServerConfig(this, services);

        return config;

    }

    @Override

    public ReportServerConfig createServerConfig(ReportServices services, String jsonConfig) {

        DefaultReportServerConfig config = new DefaultReportServerConfig(this, services);

        if (!StringUtils.isEmpty(jsonConfig)) {

            config.fromJSON(new JSONObject(jsonConfig));

        }

        return config;

    }

    @Override

    public ReportViewCapture createViewCapture(ReportServerConfig config) {

        return new DefaultReportViewCapture(config);

    }

    @Override

    public SymbolTable createReportSymbolTable() {

        return new ReportSymbolTable();

    }

    @Override

    public ReportBuilder createReportBuilder() {

        ReportBuilder r = new DefaultReportBuilder();

        return r;

    }

    @Override

    public Bookmarks<ReportBuilder> getUserDefinedReportBookmarks() {

        return this.userDefinedReportBookmarks;

    }

    @Override

    public History<ReportBuilder> getUserDefinedReportHistory() {

        return this.userDefinedReportHistory;

    }

    @Override

    public void setUserDefinedReportHistory(History<ReportBuilder> history) {

        this.userDefinedReportHistory = history;

    }

    @Override

    public void setUserDefinedReportBookmarks(Bookmarks<ReportBuilder> userDefinedReportBookmarks) {

        this.userDefinedReportBookmarks = userDefinedReportBookmarks;

    }

    @Override

    public ReportDataSet createDataSet(FeatureStore store) {

        return new DefaultReportDataSet(this.defaultServer.getServices(), store.getName(), store);

    }

    @Override

    public ReportDataSet createDataSet(FeatureStore store, FeatureQuery query) {

        return new DefaultReportDataSet(this.defaultServer.getServices(), store.getName(), store, query);

    }

    @Override

    public Report createReport(ReportConfig config) {

        DefaultReport r = new DefaultReport(config);

        return r;

    }

    @Override

    public ReportConfig createReportConfig() {

        DefaultReportConfig r = new DefaultReportConfig();

        return r;

    }

}

package org.gvsig.report.lib.impl;

import java.io.IOException;

import java.net.URLDecoder;

import java.util.Locale;

import org.apache.commons.lang3.StringUtils;

import org.apache.http.HttpException;

import org.apache.http.HttpRequest;

import org.apache.http.HttpResponse;

import org.apache.http.HttpStatus;

import org.apache.http.MethodNotSupportedException;

import org.apache.http.entity.ByteArrayEntity;

import org.apache.http.entity.ContentType;

import org.apache.http.nio.entity.NStringEntity;

import org.apache.http.nio.protocol.BasicAsyncRequestConsumer;

import org.apache.http.nio.protocol.BasicAsyncResponseProducer;

import org.apache.http.nio.protocol.HttpAsyncExchange;

import org.apache.http.nio.protocol.HttpAsyncRequestConsumer;

import org.apache.http.nio.protocol.HttpAsyncRequestHandler;

import org.apache.http.protocol.HttpContext;

import static org.gvsig.report.lib.api.ReportServer.INFO;

import static org.gvsig.report.lib.api.ReportServer.WARN;

import org.gvsig.report.lib.api.commands.Command;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public class HttpHandler implements HttpAsyncRequestHandler<HttpRequest> {

    private static final Logger LOG = LoggerFactory.getLogger(HttpHandler.class);

    private final DefaultReportServer server;

    public HttpHandler(DefaultReportServer server) {

        super();

        this.server = server;

    }

    @Override

    public HttpAsyncRequestConsumer<HttpRequest> processRequest(

            final HttpRequest request,

            final HttpContext context) {

        // Buffer request content in memory for simplicity

        return new BasicAsyncRequestConsumer();

    }

    @Override

    public void handle(

            final HttpRequest request,

            final HttpAsyncExchange httpexchange,

            final HttpContext context) throws HttpException, IOException {

        final HttpResponse response = httpexchange.getResponse();

        handleInternal(request, response, context);

        httpexchange.submitResponse(new BasicAsyncResponseProducer(response));

    }

    private void handleInternal(

            final HttpRequest request,

            final HttpResponse response,

            final HttpContext context) throws HttpException, IOException {

        final String method = request.getRequestLine().getMethod().toUpperCase(Locale.ENGLISH);

        if (!method.equals("GET")) {

            this.server.log(WARN, "Method not supported, Only GET supported.");

            throw new MethodNotSupportedException(method + " method not supported");

        }

        final String target = request.getRequestLine().getUri();

        final String line = URLDecoder.decode(target, "UTF-8");

        final String[] args = StringUtils.split(line, '/');

        final int argc = args.length -1;

        Command command = this.server.getCommand(args[0]);

        if( command == null) {

            this.server.log(WARN, "Command '"+line+"' not found.");

            response.setStatusCode(HttpStatus.SC_NOT_FOUND);

            final NStringEntity entity = new NStringEntity(

                    "<html><body><h1>Command " + line

                    + " not found</h1></body></html>",

                    ContentType.create("text/html", "UTF-8"));

            response.setEntity(entity);

            return;

        }

        if( !command.getNumArgs().contains(argc) ) {

            this.server.log(WARN, "Command '"+line+"', invalid number of arguments.");

            response.setStatusCode(HttpStatus.SC_BAD_REQUEST);

            final NStringEntity entity = new NStringEntity(

                    "<html><body><h1>Number of arguments invalid in " + line

                    + "</h1></body></html>",

                    ContentType.create("text/html", "UTF-8"));

            response.setEntity(entity);

            return;

        }

        Object ret;

        try {

            ret = command.call(argc, args);

        } catch(Exception ex) {

            LOG.warn("Can't server command '"+line+"'.", ex);

            this.server.log(WARN, "Command '"+line+"', error "+ex.getMessage()+".");

            response.setStatusCode(HttpStatus.SC_INTERNAL_SERVER_ERROR);

            final NStringEntity entity = new NStringEntity(

                    "<html><body><h1>Error processing " + line

                    + "</h1><p>"+ex.toString()+"</p></body></html>",

                    ContentType.create("text/html", "UTF-8"));

            response.setEntity(entity);

            return;

        }

        if( ret == null ) {

            this.server.log(WARN, "Command '"+line+"' return null.");

            response.setStatusCode(HttpStatus.SC_INTERNAL_SERVER_ERROR);

            final NStringEntity entity = new NStringEntity(

                    "<html><body><h1>Process " + line

                    + " return null</h1></body></html>",

                    ContentType.create("text/html", "UTF-8"));

            response.setEntity(entity);

            return;

        }

        if( ret instanceof byte[] ) {

            response.setStatusCode(HttpStatus.SC_OK);

            final ByteArrayEntity entity = new ByteArrayEntity(

                    (byte[]) ret,

                    ContentType.create(command.getMimeType(), "UTF-8"));

            response.setEntity(entity);

            this.server.log(INFO, "Command '"+line+"' ok.");

            return;

        }

        response.setStatusCode(HttpStatus.SC_OK);

        final NStringEntity entity = new NStringEntity(

                ret.toString(),

                ContentType.create(command.getMimeType(), "UTF-8"));

        response.setEntity(entity);

        this.server.log(INFO, "Command '"+line+"' ok.");

    }

}

package org.gvsig.report.lib.impl;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.NoSuchElementException;

import org.apache.commons.collections.CollectionUtils;

import org.apache.commons.lang3.mutable.MutableInt;

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitable;

import org.gvsig.tools.visitor.Visitor;

/**

 *

 * @author jjdelcerro

 */

public class DefaultSelectionOfFeatures

        implements SelectionOfFeatures {

    private class FeatureReferenceIteratorToFeatureIteratorAdapter implements Iterator<Feature> {

        private final Iterator<FeatureReference> iterator;

        private int count;

        public FeatureReferenceIteratorToFeatureIteratorAdapter(Iterator<FeatureReference> iterator) {

            this.iterator = iterator;

            this.count = 0;

        }

        @Override

        public boolean hasNext() {

            int limit = dataSet.getLimit();

            if (limit < this.count) {

                return false;

            }

            return this.iterator.hasNext();

        }

        @Override

        public Feature next() {

            int limit = dataSet.getLimit();

            if (limit < this.count) {

                throw new NoSuchElementException();

            }

            this.count++;

            FeatureReference fr = this.iterator.next();

            try {

                return fr.getFeature();

            } catch (DataException ex) {

                throw new RuntimeException(ex);

            }

        }

    }

    private List<FeatureReference> references;

    private List<String> referenceCodes;

    private final DefaultReportDataSet dataSet;

    public DefaultSelectionOfFeatures(DefaultReportDataSet dataSet) {

        this.dataSet = dataSet;

        this.references = new ArrayList<>();

        this.referenceCodes = null;

    }

    private void resolveReferenceCodes() {

        if (this.referenceCodes == null) {

            return;

        }

        for (String referenceCode : this.referenceCodes) {

            FeatureReference reference = this.dataSet.getStore().getFeatureReference(referenceCode);

            this.references.add(reference);

        }

        this.referenceCodes = null;

    }

    @Override

    public Feature get64(long pos) {

        if (this.referenceCodes != null) {

            this.resolveReferenceCodes();

        }

        int limit = this.dataSet.getLimit();

        if (limit > 0 && pos > limit) {

            throw new ArrayIndexOutOfBoundsException((int) pos);

        }

        try {

            FeatureReference reference = this.references.get((int) pos);

            return reference.getFeature();

        } catch (DataException ex) {

            throw new RuntimeException("Can't retrieve feature from reference.", ex);

        }

    }

    public FeatureReference getReference(int pos) {

        if (this.referenceCodes != null) {

            this.resolveReferenceCodes();

        }

        FeatureReference reference = this.references.get(pos);

        return reference;

    }

    @Override

    public long size64() {

        int limit = this.dataSet.getLimit();

        int size;

        if (this.referenceCodes == null) {

            size = this.references.size();

        } else {

            size = this.referenceCodes.size();

        }

        if (limit > 0 && limit < size) {

            size = limit;

        }

        return size;

    }

    @Override

    public boolean isEmpty() {

        if (this.referenceCodes == null) {

            return this.references.isEmpty();

        }

        return this.referenceCodes.isEmpty();

    }

    @Override

    public Iterator<Feature> iterator() {

        if (this.referenceCodes != null) {

            this.resolveReferenceCodes();

        }

        return new FeatureReferenceIteratorToFeatureIteratorAdapter(this.references.iterator());

    }

    @Override

    public void accept(Visitor visitor) throws BaseException {

        if (this.referenceCodes != null) {

            this.resolveReferenceCodes();

        }

        int count = 0;

        int limit = this.dataSet.getLimit();

        for (FeatureReference reference : this.references) {

            try {

                if( limit>0 ) {

                    if( count >= limit ) {

                        break;

                    }

                    count++;

                }

                visitor.visit(reference.getFeature());

            } catch (VisitCanceledException ex) {

                break;

            } catch (Exception ex) {

            }

        }

    }

    @Override

    public void clear() {

        this.referenceCodes = null;

        this.references = new ArrayList<>();

    }

    @Override

    public void add(Feature feature) {

        this.add(feature.getReference());

    }

    @Override

    public void add(FeatureReference reference) {

        if (this.referenceCodes != null) {

            this.resolveReferenceCodes();

        }

        this.references.add(reference);

    }

    @Override

    public void add(String referenceCode) {

        if (CollectionUtils.isEmpty(this.references)) {

            if (this.referenceCodes == null) {

                this.referenceCodes = new ArrayList<>();

            }

            this.referenceCodes.add(referenceCode);

        } else {

            FeatureReference reference = this.dataSet.getStore().getFeatureReference(referenceCode);

            this.references.add(reference);

        }

    }

    @Override

    public void addAll(Iterator<Feature> features) {

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

        SimpleTaskStatus status = manager.createDefaultSimpleTaskStatus("DataSet");

        status.setIndeterminate();

        status.setAutoremove(true);

        status.add();

        int n = 0;

        try {

            if (this.referenceCodes != null) {

                this.resolveReferenceCodes();

            }

            while (features.hasNext()) {

                Feature f = features.next();

                this.references.add(f.getReference());

                status.setCurValue(n++);

            }

        } finally {

            status.terminate();

        }

    }

    @Override

    public void addAll(Visitable features) {

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

        final SimpleTaskStatus status = manager.createDefaultSimpleTaskStatus("DataSet");

        status.setIndeterminate();

        status.setAutoremove(true);

        status.add();

        final MutableInt n = new MutableInt(0);

        try {

            if (this.referenceCodes != null) {

                this.resolveReferenceCodes();

            }

            features.accept(new Visitor() {

                @Override

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

                    Feature f = (Feature) obj;

                    references.add(f.getReference());

                    status.setCurValue(n.intValue());

                    n.increment();

                }

            });

        } catch (BaseException ex) {

            throw new RuntimeException("Can't set features to dataset", ex);

        } finally {

            status.terminate();

        }

    }

    @Override

    public void addStoreSelection() {

        try {

            FeatureSet selection = this.dataSet.getStore().getFeatureSelection();

            this.addAll(selection);

        } catch (DataException ex) {

            throw new RuntimeException("Can't set features from current selection.", ex);

        }

    }

    @Override

    public List<Feature> toList() {

        List<Feature> adapter = new UnmodifiableBasicList64ToListAdapter<>(this);                

        return adapter;

    }

}

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

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

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

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 JRFeatureStoreDataSource

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

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

    private UnmodifiableBasicList64<Feature> features;

    private long index;

    private final StoresRepository storesRepository;

    private final JasperReportsContext context;

    protected String name;

    private Map<String, Coercion> coercions;

    public JRFeatureStoreDataSource(JasperReportsContext context, UnmodifiableBasicList64<Feature> features, StoresRepository storesRepository) {

        this.context = context;

        this.features = features;

        this.storesRepository = storesRepository;

        this.index = -1;

        this.name = "<unknown>";

        this.coercions = new HashMap<>();

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

    }

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

        this(

                context,

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

                store.getStoresRepository()

        );

        this.name = store.getName();

//        System.out.println("DataSurce("+this.name+")");

    }

    @Override

    public boolean next() throws JRException {

        this.index++;

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

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

        return n;

    }

    @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 = feature.getLabelOfValue(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 JRFeatureStoreDataSource(this.context, this.features, this.storesRepository);

    }

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

        }

        JRFeatureStoreDataSource x = new JRFeatureStoreDataSource(

                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 JRFeatureStoreDataSource.this.subDataSource();

        }

        @Override

        public JsonData subDataSource(String selectExpression) throws JRException {

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

            return JRFeatureStoreDataSource.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;

import ar.com.fdvs.dj.core.DynamicJasperHelper;

import ar.com.fdvs.dj.core.layout.ClassicLayoutManager;

import ar.com.fdvs.dj.core.layout.ExtendedListLayoutManager;

import ar.com.fdvs.dj.core.layout.LayoutManager;

import ar.com.fdvs.dj.core.layout.ListLayoutManager;

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

import java.io.File;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import net.sf.jasperreports.engine.JRException;

import net.sf.jasperreports.engine.JasperExportManager;

import net.sf.jasperreports.engine.JasperPrint;

import net.sf.jasperreports.engine.JasperReport;

import net.sf.jasperreports.engine.SimpleJasperReportsContext;

import net.sf.jasperreports.engine.fill.FillListener;

import net.sf.jasperreports.engine.fill.JRFiller;

import net.sf.jasperreports.engine.fill.ReportFiller;

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

import net.sf.jasperreports.repo.FileRepositoryPersistenceServiceFactory;

import net.sf.jasperreports.repo.PersistenceServiceFactory;

import net.sf.jasperreports.repo.RepositoryService;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

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

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

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

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

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

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

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

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.util.UnmodifiableBasicList64;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultReport implements Report {

    private static final Logger LOG = LoggerFactory.getLogger(DefaultReport.class);

    private final ReportConfig config;

    private DynamicReport dynamicReport;

    private SimpleJasperReportsContext jasperContext;

    public DefaultReport(ReportConfig config) {

        this.config = config;

        this.dynamicReport = null;

        this.jasperContext = null;

    }

    public DefaultReport(ReportConfig config, DynamicReport dynamicReport) {

        this(config);

        this.dynamicReport = dynamicReport;

    }

    @Override

    public ReportConfig getConfig() {

        return this.config;

    }

    protected LayoutManager getLayoutManager() {

        switch (this.config.getLayoutManager()) {

            case LAYOUT_LIST:

                return new ListLayoutManager();

            case LAYOUT_EXTENDEDLIST:

                return new ExtendedListLayoutManager();

            case LAYOUT_CLASSIC:

            default:

                return new ClassicLayoutManager();

        }

    }

    @Override

    public String getName() {

        return this.config.getName();

    }

    private SimpleJasperReportsContext getJasperContext() {

        if (this.jasperContext == null) {

            this.jasperContext = new SimpleJasperReportsContext();

        }

        return this.jasperContext;

    }

    private JasperReport loadJasperReport(InputStream is) {

        JasperReport jasper = null;

        try {

            SimpleJasperReportsContext context = this.getJasperContext();

            ResourcesRepositoryService resourcesRepository = new ResourcesRepositoryService(

                    this.config.getResources()

            );

            context.setExtensions(

                    RepositoryService.class,

                    Collections.singletonList(resourcesRepository)

            );

            context.setExtensions(

                    PersistenceServiceFactory.class,

                    Collections.singletonList(

                            FileRepositoryPersistenceServiceFactory.getInstance()

                    )

            );

            jasper = (JasperReport) JRLoader.loadObject(is);

        } catch (IllegalStateException ex) {

            throw ex;

        } catch (Exception ex) {

            LOG.warn("Can't load report from config '" + config.toString() + "'.", ex);

        }

        return jasper; //this.dynamicReport; //TODO

    }

    @Override

    public Expression getPreparedFilter(Expression filter) {

        String prefix = this.config.getFilterFieldPrefix();

        if (StringUtils.isBlank(prefix)) {

            return filter;

        }

        final ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

        final List<Pair<ExpressionBuilder.Value, ExpressionBuilder.Value>> replaces = new ArrayList<>();

        ExpressionBuilder.Value filterValue = filter.getCode().toValue();

        filterValue.accept(new ExpressionBuilder.Visitor() {

            @Override

            public void visit(ExpressionBuilder.Visitable value0) {

                ExpressionBuilder.Variable value = (ExpressionBuilder.Variable) value0;

                ExpressionBuilder.Variable newvalue = builder.variable(prefix + value.name());

                replaces.add(new ImmutablePair(value, newvalue));

            }

        }, new ExpressionBuilder.ClassVisitorFilter(ExpressionBuilder.Variable.class));

        for (Pair<ExpressionBuilder.Value, ExpressionBuilder.Value> replace : replaces) {

            filterValue.replace(replace.getLeft(), replace.getRight());

        }

        return ExpressionUtils.createExpression(filterValue.toString());

    }

    @Override

    public synchronized Object generateReport(final SimpleTaskStatus status, Expression filter) {

        FeatureStore store = this.config.getDataSet().getStore();

        filter = this.getPreparedFilter(filter);

        UnmodifiableBasicList64<Feature> features = (UnmodifiableBasicList64<Feature>) store.getFeatures(filter);

        return this.generateReport(status, features);

    }

    @Override

    public synchronized Object generateReport(final SimpleTaskStatus status, UnmodifiableBasicList64<Feature> features) {

        InputStream is = null;

        try {

            Map parameters = new HashMap();

            status.message("Preparing data");

            FeatureStore store = this.config.getDataSet().getStore();

            SimpleJasperReportsContext context = this.getJasperContext();

            JRFeatureStoreDataSource dataSource = new JRFeatureStoreDataSource(

                    context,

                    features,

                    store.getStoresRepository()

            );

            final long records = dataSource.size64();

            status.message("Loading template");

            JasperReport jr; // = this.dynamicReport;

            if (dynamicReport == null) {

                is = this.config.getReportTemplateAsStream();

                if (is == null) {

                    throw new RuntimeException("Can't access to the input stream associated to the repor (" + this.config.toString() + ").");

                }

                jr = this.loadJasperReport(is);

            } else {

                jr = DynamicJasperHelper.generateJasperReport(

                        dynamicReport,

                        this.getLayoutManager(),

                        parameters);

            }

            ReportFiller filler = JRFiller.createReportFiller(context, jr);

            filler.addFillListener(new FillListener() {

                @Override

                public void pageGenerated(JasperPrint jasperPrint, int pageIndex) {

//                    LOG.info("Pagina generada " + pageIndex);

                    status.message("Created page " + pageIndex + " (records " + records + ")");

                    if (pageIndex > 100000) {

                        throw new RuntimeException("Too many pages in report.");

                    }

                }

                @Override

                public void pageUpdated(JasperPrint jasperPrint, int pageIndex) {

//                    LOG.info("Pagina actualizada " + pageIndex);

                }

            });

            status.message("Filling template");

            JasperPrint jasperPrint = filler.fill(

                    parameters,

                    dataSource

            );

            return jasperPrint;

        } catch (IllegalStateException ex) {

            throw ex;

        } catch (Exception ex) {

            throw new RuntimeException("Can't generate report.", ex);

        } finally {

            IOUtils.closeQuietly(is);

        }

    }

    @Override

    public File generatePDF(SimpleTaskStatus status, Expression filter, File pdf) {

        try {

            JasperPrint jasperPrint = (JasperPrint) this.generateReport(status, filter);

            JasperExportManager.exportReportToPdfFile(jasperPrint, pdf.getAbsolutePath());

            return pdf;

        } catch (JRException ex) {

            throw new RuntimeException("Can't export to PDF.", ex);

        }

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

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

import org.gvsig.report.lib.api.commands.AbstractCommand;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.math.NumberUtils;

import org.apache.commons.lang3.mutable.MutableBoolean;

import org.apache.commons.lang3.mutable.MutableInt;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.json.JSONArray;

import org.json.JSONObject;

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

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

import org.gvsig.report.lib.api.commands.CommandFactory;

/**

 *

 * @author jjdelcerro

 */

public class GetDataset extends AbstractCommand {

    public GetDataset(CommandFactory factory, ReportServer server) {

        super(factory,server);

    }

    @Override

    public Object call(int argc, String[] args) {

        final MutableBoolean withGeom = new MutableBoolean(false);

        final MutableInt limit = new MutableInt(-1);

        String filter = null;

        boolean ascending = true;

        String orderFields = null;

        int n = 1;

        String datasetName = args[n++];

        while( n<args.length ) {

            String option = args[n++].toLowerCase();

            switch(option) {

                case "withgeom":

                    withGeom.setTrue();

                    break;

                case "limit":

                    limit.setValue(NumberUtils.toInt(args[n++], -1));

                    break;

                case "filter":

                    filter = args[n++];

                    break;

                case "order":

                    orderFields = args[n++];

                    ascending = BooleanUtils.toBoolean(args[n++].toLowerCase(), "asc", "desc");

                    break;

                default:

                    throw new IllegalArgumentException("Option '"+option+"' not supported.");

            }

        }

        ReportDataSet dataset = this.getConfig().getDataset(datasetName);

        if (dataset == null) {

            throw new IllegalArgumentException("Dataset '" + datasetName + "' not exists.");

        }

        final MutableInt count = new MutableInt(0);

        final JSONArray json = new JSONArray();

        dataset.accept(new Visitor() {

            @Override

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

                Feature f = (Feature) o;

                JSONObject fjson = new JSONObject();

                FeatureType ft = f.getType();

                for (FeatureAttributeDescriptor desc : ft) {

                    if (desc.isComputed()) {

                        continue;

                    }

                    if (desc.getType() == DataTypes.GEOMETRY) {

                        if ( withGeom.isTrue() ) {

                            fjson.put(desc.getName(), f.getGeometry(desc.getIndex()).convertToWKT());

                        }

                    } else {

                        switch(desc.getType()) {

                            case DataTypes.BOOLEAN:

                                fjson.put(desc.getName(), f.getBoolean(desc.getIndex()));

                                break;

                            case DataTypes.BYTE:

                                fjson.put(desc.getName(), f.getByte(desc.getIndex()));

                                break;

                            case DataTypes.INT:

                                fjson.put(desc.getName(), f.getInt(desc.getIndex()));

                                break;

                            case DataTypes.LONG:

                                fjson.put(desc.getName(), f.getLong(desc.getIndex()));

                                break;

                            case DataTypes.DOUBLE:

                                fjson.put(desc.getName(), f.getDouble(desc.getIndex()));

                                break;

                            case DataTypes.FLOAT:

                                fjson.put(desc.getName(), f.getFloat(desc.getIndex()));

                                break;

                            case DataTypes.DATE:

                                fjson.put(desc.getName(), f.getDate(desc.getIndex()));

                                break;

                            default:

                                fjson.put(desc.getName(), f.get(desc.getIndex()));

                        }

                    }

                    if( desc.getAvailableValues()!=null ) {

                        fjson.put(desc.getName()+"@label", f.getLabelOfValue(desc.getName()));

                    }

                }

                json.put(fjson);

                count.increment();

                if( limit.intValue()>0 &&  count.intValue()>=limit.intValue() ) {

                    throw new VisitCanceledException();

                }

            }

        }, filter, orderFields, ascending);

        return json.toString();

    }

}

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

import org.apache.commons.lang3.Range;

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

import org.gvsig.report.lib.api.commands.AbstractCommandFactory;

import org.gvsig.report.lib.api.commands.Command;

/**

 *

 * @author jjdelcerro

 */

public class CaptureViewFactory extends AbstractCommandFactory {

    public CaptureViewFactory() {

        super(

            "captureview", 

            Range.between(1, 100), 

            "image/png",

            "captureview/<viename>\n\n" +

                "Options:\n" +

                "  zoom/<datasetname>/<filterexpression>\n" +    

                "  center/<datasetname>/<filterexpression>\n" +    

                "  select/<datasetname>/<filterexpression>\n" +    

                "  deselect/<datasetname>\n" +    

                "  margins/<integer>\n" +    

                "  width/<integer>\n" +    

                "  height/<integer>\n\n" +    

                "Retrieve the image of specified view with <viewname> as a png.\n" +

                "select and deselect options can be specified more than once.\n" 

        );        

    }

    @Override

    public Command create(ReportServer server) {

        return new CaptureView(this, server);

    }

}

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

import org.gvsig.report.lib.api.commands.Command;

import org.gvsig.report.lib.api.commands.AbstractCommand;

import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.htmlbuilder.HTMLBuilder;

import org.gvsig.htmlbuilder.HTMLBuilder.HTMLComplexElement;

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

import org.gvsig.report.lib.api.commands.CommandFactory;

import org.gvsig.tools.util.ToolsUtilLocator;

import org.json.JSONArray;

import org.json.JSONObject;

/**

 *

 * @author jjdelcerro

 */

public class Help extends AbstractCommand {

    public Help(CommandFactory factory,  ReportServer server) {

        super(factory,server);

    }

    @Override

    public Object call(int argc, String[] args) {

        Map<String, Command> commands = this.getServer().getCommands();

        if( argc>0 && StringUtils.equalsIgnoreCase("asjson", args[1]) ) {

            JSONArray json = new JSONArray();

            for (Command command : commands.values()) {

                json.put(this.getCommandDescription(command));

            }

            return json.toString();

        } else {

            HTMLBuilder builder = ToolsUtilLocator.getToolsUtilManager().createHTMLBuilder();

            HTMLComplexElement table = builder.table(

                0,1,4,

                builder.thead(

                    builder.tr(

                            builder.th("Return type"),

                            builder.th("Name"),

                            builder.th("Description")

                    )

                )

            );

            for (Command command : commands.values()) {

                HTMLComplexElement tr = builder.tr(HTMLBuilder.valign_top).contents(

                        builder.td(command.getMimeType()),

                        builder.td(command.getName()),

                        builder.td(

                                builder.plainWithNl(command.getDescription()+"\n\n")

                        )

                );

                table.contents(tr);

            }

            return table.toHTML();

        }

    }

    public JSONObject getCommandDescription(Command command) {

        JSONObject json = new JSONObject();

        json.put("Name", command.getName());

        json.put("NumArgs", command.getNumArgs().toString());

        json.put("MimeType", StringUtils.defaultString(command.getMimeType()));

        json.put("Description", StringUtils.defaultString(command.getDescription()));

        return json;

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

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

import org.gvsig.report.lib.api.commands.AbstractCommand;

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

import org.json.JSONArray;

import org.gvsig.report.lib.api.commands.CommandFactory;

/**

 *

 * @author jjdelcerro

 */

public class ListViews extends AbstractCommand {

    public ListViews(CommandFactory factory, ReportServer server) {

        super(factory, server);

    }

    @Override

    public Object call(int argc, String[] args) {

        JSONArray json = new JSONArray();

        for (String viewName : this.getServices().getViewNames() ) {

            json.put(viewName);

        }

        return json.toString();

    }

}

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

import org.apache.commons.lang3.Range;

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

import org.gvsig.report.lib.api.commands.AbstractCommandFactory;

import org.gvsig.report.lib.api.commands.Command;

/**

 *

 * @author jjdelcerro

 */

public class GetImageFactory extends AbstractCommandFactory {

    private static GetImageFactory INSTANCE = null;

    public static GetImageFactory getInstance() {

      if( INSTANCE==null ) {

        INSTANCE = new GetImageFactory();

      }

      return INSTANCE;

    } 

    public GetImageFactory() {

        super(

            "image", 

            Range.between(1, 8),

            "image/png",

            "image/<datasetname>/column/<columnname>\n" + 

                "image/<datasetname>/filter/<expression>\n" + 

                "image/<datasetname>/order/<fields>\n\n" + 

                "Retrieve the value of column as a image.\n" + 

                "If an order is specified, it accepts two more parameters. The first\n" +

                "is the list of fields by which to sort separated by commas."

        );

    }

    @Override

    public Command create(ReportServer server) {

        return new GetImage(this, server);

    }

}

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

import org.apache.commons.lang3.Range;

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

import org.gvsig.report.lib.api.commands.AbstractCommandFactory;

import org.gvsig.report.lib.api.commands.Command;

/**

 *

 * @author jjdelcerro

 */

public class ListDatasetsFactory extends AbstractCommandFactory {

    public ListDatasetsFactory() {

        super(

            "datasets", 

            Range.is(0),

            "application/json",

            "datasets\n\nList the datasets exposeds by the application.\n\n" + 

                "${host}/datasets"

        );        

    }

    @Override

    public Command create(ReportServer server) {

        return new ListDatasets(this, server);

    }

}

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

import org.apache.commons.lang3.Range;

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

import org.gvsig.report.lib.api.commands.AbstractCommandFactory;

import org.gvsig.report.lib.api.commands.Command;

/**

 *

 * @author jjdelcerro

 */

public class GetDatasetFactory extends AbstractCommandFactory {

    public GetDatasetFactory() {

        super(

            "dataset", 

            Range.between(1, 8),

            "application/json",

            "dataset/<datasetname>\n" +

                "dataset/<datasetname>/withgeom\n" +