gvSIG projects pool

org.gvsig.report.lib.impl.ReportImplLibrary

package org.gvsig.report.lib.impl;

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

import java.util.HashMap;

import java.util.Map;

import java.util.Objects;

import net.sf.jasperreports.engine.JREmptyDataSource;

import net.sf.jasperreports.engine.JRException;

import net.sf.jasperreports.engine.JRField;

import net.sf.jasperreports.engine.JRRewindableDataSource;

import net.sf.jasperreports.engine.JasperReportsContext;

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

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

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.StoresRepository;

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.dataTypes.CoercionContext;

import org.gvsig.tools.util.GetItem;

import org.gvsig.tools.util.GetItem64;

import org.gvsig.tools.util.Size;

import org.gvsig.tools.util.Size64;

import org.gvsig.tools.util.UnmodifiableBasicList64;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class JRFeatureStoreDataSource1

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

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

    private UnmodifiableBasicList64<Feature> features;

    private long index;

    private final StoresRepository storesRepository;

    private final JasperReportsContext context;

    protected String name;

    private Map<String, Coercion> coercions;

    private final FeatureType featureType;

    private final LabelsCacheForFieldValues labelsCacheForFieldValues;

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

        this.context = context;

        this.features = features;

        this.storesRepository = storesRepository;

        this.index = -1;

        this.name = "<unknown>";

        this.coercions = new HashMap<>();

        this.featureType = featureType;

        this.labelsCacheForFieldValues = DALLocator.getDataManager()

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

                    // FeatureType, Feature, String(fieldName)

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

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

                    return labelFormula;

        },null);

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

    }

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

        this(

                context,

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

                store.getStoresRepository(),

                store.getDefaultFeatureTypeQuietly()

        );

        this.name = store.getName();

    }

    @Override

    public boolean next() throws JRException {

        this.index++;

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

        return n;

    }

    public String getLabel(Feature feature, String fieldName) {

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

    }

    @Override

    public Object getFieldValue(JRField jrField) throws JRException {

        String fieldName = jrField.getName();

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

        try {

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

            Object value;

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

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

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

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

                value = this.getLabel(feature, fieldName);

            } else {

                value = feature.get(fieldName);

            }

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

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

                if (coercion == null) {

                    DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();

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

                    if (dataType == null) {

                        coercion = new DummyCoercion();

                    } else {

                        coercion = dataType.getCoercion();

                    }

                    this.coercions.put(fieldName, coercion);

                }

                try {

                    value = coercion.coerce(value);

                } catch (CoercionException ex) {

                }

            }

            return value;

        } catch (Exception ex) {

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

                return null;

            }

            throw new JRException(

                    EXCEPTION_MESSAGE_KEY_UNKNOWN_COLUMN_NAME,

                    new Object[]{fieldName},

                    ex

            );

        }

    }

    @Override

    public void moveFirst() throws JRException {

        this.index = -1;

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

    }

    @Override

    public long size64() {

        return this.features.size64();

    }

    @Override

    public int size() {

        long sz = this.features.size64();

        if (sz > Integer.MAX_VALUE) {

            return Integer.MAX_VALUE;

        }

        return (int) sz;

    }

    @Override

    public Feature get(int position) {

        return this.features.get64(position);

    }

    @Override

    public Feature get64(long position) {

        return this.features.get64(position);

    }

    @Override

    public JsonData subDataSource() throws JRException {

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

    }

    @Override

    public JsonData subDataSource(String selectExpression) throws JRException {

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

        if (StringUtils.isBlank(selectExpression)) {

            return new JREmptyJSonData(1, this.storesRepository);

        }

        String storeName;

        Expression filter = null;

        selectExpression = selectExpression.trim();

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

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

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

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

            }

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

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

            }

        }

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

        if (n < 0) {

            storeName = selectExpression.trim();

        } else {

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

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

        }

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

            return new JREmptyJSonData(1, this.storesRepository);

        }

        JRFeatureStoreDataSource1 x = new JRFeatureStoreDataSource1(

                this.context,

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

                filter

        );

        return x;

    }

    private class JREmptyJSonData extends JREmptyDataSource implements JsonData {

        JREmptyJSonData(int rows, StoresRepository storesRepository) {

            super(rows);

        }

        @Override

        public JsonData subDataSource() throws JRException {

            return JRFeatureStoreDataSource1.this.subDataSource();

        }

        @Override

        public JsonData subDataSource(String selectExpression) throws JRException {

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

            return JRFeatureStoreDataSource1.this.subDataSource(selectExpression);

        }

    }

    private static class DummyCoercion implements Coercion {

        @Override

        public Object coerce(Object o) throws CoercionException {

            return o;

        }

        @Override

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

            return value;

        }

    }

}

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

import 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() {

        ar.com.fdvs.dj.domain.builders.StyleBuilder builder = new ar.com.fdvs.dj.domain.builders.StyleBuilder(false);

        builder.setTextColor(textColor);

        builder.setBackgroundColor(backgroundColor);

        // Prepare font

        Font actualFont = new Font();

        switch (this.font) {

            case FONT_ARIAL:

            default:

                actualFont.setFontName(Font._FONT_ARIAL);

                break;

            case FONT_COMIC_SANS:

                actualFont.setFontName(Font._FONT_COMIC_SANS);

                break;

            case FONT_COURIER_NEW:

                actualFont.setFontName(Font._FONT_COURIER_NEW);

                break;

            case FONT_GEORGIA:

                actualFont.setFontName(Font._FONT_GEORGIA);

                break;

            case FONT_MONOSPACED:

                actualFont.setFontName(Font._FONT_MONOSPACED);

                break;

            case FONT_TIME_NEW_ROMAN:

                actualFont.setFontName(Font._FONT_TIMES_NEW_ROMAN);

                break;

            case FONT_VERDANA:

                actualFont.setFontName(Font._FONT_VERDANA);

                break;

        }

        actualFont.setFontSize(this.fontSize);

        builder.setFont(actualFont);

        //

        switch (this.rotation) {

            case ROTATION_NONE:

            default:

                builder.setRotation(Rotation.NONE);

                break;

            case ROTATION_LEFT:

                builder.setRotation(Rotation.LEFT);

                break;

            case ROTATION_RIGHT:

                builder.setRotation(Rotation.RIGHT);

                break;

        }

        switch (this.stretching) {

            case STRETCHING_NO_STRETCH:

            default:

                builder.setStretching(Stretching.NO_STRETCH);

                break;

            case STRETCHING_RELATIVE_TO_BAND_HEIGHT:

                builder.setStretching(Stretching.RELATIVE_TO_BAND_HEIGHT);

                builder.setStretchWithOverflow(this.stretchingWithOverflow);

                break;

            case STRETCHING_RELATIVE_TO_TALLEST_OBJECT:

                builder.setStretching(Stretching.RELATIVE_TO_TALLEST_OBJECT);

                builder.setStretchWithOverflow(this.stretchingWithOverflow);

                break;

        }

        switch (this.horizontalAlign) {

            case HORIZONTALALIGN_LEFT:

            default:

                builder.setHorizontalAlign(HorizontalAlign.LEFT);

                break;

            case HORIZONTALALIGN_CENTER:

                builder.setHorizontalAlign(HorizontalAlign.CENTER);

                break;

            case HORIZONTALALIGN_JUSTIFY:

                builder.setHorizontalAlign(HorizontalAlign.JUSTIFY);

                break;

            case HORIZONTALALIGN_RIGHT:

                builder.setHorizontalAlign(HorizontalAlign.RIGHT);

                break;

        }

        switch (this.verticalAlign) {

            case VERTICALALIGN_MIDDLE:

            default:

                builder.setVerticalAlign(VerticalAlign.MIDDLE);

                break;

            case VERTICALALIGN_BOTTOM:

                builder.setVerticalAlign(VerticalAlign.BOTTOM);

                break;

            case VERTICALALIGN_JUSTIFIED:

                builder.setVerticalAlign(VerticalAlign.JUSTIFIED);

                break;

            case VERTICALALIGN_TOP:

                builder.setVerticalAlign(VerticalAlign.TOP);

                break;

        }

        builder.setPaddingTop(this.paddingTop);

        builder.setPaddingBottom(this.paddingBottom);

        builder.setPaddingLeft(this.paddingLeft);

        builder.setPaddingRight(this.paddingRight);

        switch (this.transparency) {

            case TRANSPARENCY_OPAQUE:

            default:

                builder.setTransparency(Transparency.OPAQUE);

                break;

            case TRANSPARENCY_TRANSPARENT:

                builder.setTransparency(Transparency.TRANSPARENT);

                break;

        }

        builder.setTransparent(this.transparent);

        builder.setBorderTop(((DefaultBorderBuilder) this.borderTop).build());

        builder.setBorderBottom(((DefaultBorderBuilder) this.borderBottom).build());

        builder.setBorderLeft(((DefaultBorderBuilder) this.borderLeft).build());

        builder.setBorderRight(((DefaultBorderBuilder) this.borderRight).build());

        return builder.build();

    }

    @Override

    public int getFont() {

        return this.font;

    }

    @Override

    public ReportBuilder.StyleBuilder font(int font) {

        this.font = font;

        return this;

    }

    @Override

    public int getFontSize() {

        return this.fontSize;

    }

    @Override

    public ReportBuilder.StyleBuilder fontSize(int fontSize) {

        this.fontSize = fontSize;

        return this;

    }

}

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

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

import org.gvsig.tools.persistence.PersistentState;

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

/**

 *

 * @author jjdelcerro

 */

public class DefaultMargins implements ReportBuilder.Margins {

    private int top;

    private int bottom;

    private int left;

    private int right;

    public DefaultMargins() {

    }

    @Override

    public void copyFrom(ReportBuilder.Margins other) {

        this.top = other.getTop();

        this.bottom = other.getBottom();

        this.left = other.getLeft();

        this.right = other.getRight();

    }

    @Override

    public int getTop() {

        return this.top;

    }

    @Override

    public int getBottom() {

        return this.bottom;

    }

    @Override

    public int getLeft() {

        return this.left;

    }

    @Override

    public int getRight() {

        return this.right;

    }

    @Override

    public ReportBuilder.Margins set(int top, int bottom, int left, int right) {

        this.top = top;

        this.bottom = bottom;

        this.left = left;

        this.right = right;

        return this;

    }

    @Override

    public ReportBuilder.Margins top(int top) {

        this.top = top;

        return this;

    }

    @Override

    public ReportBuilder.Margins bottom(int bottom) {

        this.bottom = bottom;

        return this;

    }

    @Override

    public ReportBuilder.Margins left(int left) {

        this.left = left;

        return this;

    }

    @Override

    public ReportBuilder.Margins right(int right) {

        this.right = right;

        return this;

    }

    @Override

    public ReportBuilder.Margins clone() throws CloneNotSupportedException {

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

        return other;

    }

    @Override

    public void saveToState(PersistentState ps) throws PersistenceException {

        // TODO

    }

    @Override

    public void loadFromState(PersistentState ps) throws PersistenceException {

        // TODO

    }

    public static void registerPersistence() {

        // TODO

    }

}

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

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

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

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

import ar.com.fdvs.dj.domain.builders.DynamicReportBuilder;

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

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

import ar.com.fdvs.dj.domain.entities.DJGroup;

import ar.com.fdvs.dj.domain.entities.columns.AbstractColumn;

import java.awt.Color;

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

import org.apache.commons.lang3.StringUtils;

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

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

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

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

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

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

import org.gvsig.report.lib.impl.DefaultReport;

import org.gvsig.report.lib.impl.DefaultReportConfig;

import org.gvsig.tools.persistence.PersistentState;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultReportBuilder implements ReportBuilder {

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

    private String title;

    private String subtitle;

    private boolean printBackgroundOnOddRows;

    private boolean useFullPageWith;

    private int detailHeight;

    private int columnsPerPage;

    private Margins margins;

    private List<ColumnBuilder> columns;

    private List<GroupBuilder> groups;

    private StyleBuilder titleStyle;

    private StyleBuilder subtitleStyle;

    private boolean printColumnNames;

    private int layout;

    private int pageFormat;

    private boolean showDetailBand;

    private Style oddRowBackgroundStyle;

    public DefaultReportBuilder() { 

        this.initValues();

    }

    private void initValues() {

        this.columns = new ArrayList<>();

        this.groups = new ArrayList<>();

        this.titleStyle = null;

        this.subtitleStyle = null;

        this.layout = LAYOUT_CLASSIC;

        this.detailHeight = 15;

        this.margins = null;

        this.useFullPageWith = true;

        this.columnsPerPage = 1;

        this.printBackgroundOnOddRows = true;

        this.printColumnNames = true;

        this.showDetailBand = true;

        this.oddRowBackgroundStyle = new ar.com.fdvs.dj.domain.builders.StyleBuilder(false, "defaultOddRowStyle")

                .setBackgroundColor(new Color(200, 200, 200, 80))

                .setTransparency(Transparency.TRANSPARENT).setTransparent(true)

                .build();

    }

    @Override

    public void clean() {

        this.initValues();

    }

    @Override

    public Margins createMargins() {

        return new DefaultMargins();

    }

    @Override

    public ColumnBuilder createColumn() {

        return new DefaultColumnBuilder();

    }

    @Override

    public StyleBuilder createStyle() {

        return new DefaultStyleBuilder();

    }

    @Override

    public BorderBuilder createBorder() {

        return new DefaultBorderBuilder();

    }

    @Override

    public GroupBuilder createGroup(ColumnBuilder columnBuilder) {

        return new DefaultGroupBuilder(columnBuilder);

    }

    @Override

    public String getTitle() {

        return this.title;

    }

    @Override

    public String getSubtitle() {

        return this.subtitle;

    }

    @Override

    public boolean getPrintBackgroundOnOddRows() {

        return this.printBackgroundOnOddRows;

    }

    @Override

    public boolean getUseFullPageWith() {

        return this.useFullPageWith;

    }

    @Override

    public boolean getShowDetailBand() {

        return this.showDetailBand;

    }

    @Override

    public int getDetailHeight() {

        return this.detailHeight;

    }

    @Override

    public int getColumnsPerPage() {

        return this.columnsPerPage;

    }

    @Override

    public Margins getMargins() {

        return this.margins;

    }

    @Override

    public List<ColumnBuilder> getColumns() {

        return this.columns;

    }

    @Override

    public List<GroupBuilder> getGroups() {

        return this.groups;

    }

    @Override

    public StyleBuilder titleStyle() {

        if (this.titleStyle == null) {

            this.titleStyle = this.createStyle();

            this.titleStyle.fontSize(16);

        }

        return this.titleStyle;

    }

    @Override

    public StyleBuilder subtitleStyle() {

        if (this.subtitleStyle == null) {

            this.subtitleStyle = this.createStyle();

            this.subtitleStyle.fontSize(12);

        }

        return this.subtitleStyle;

    }

    @Override

    public ReportBuilder title(String title) {

        this.title = title;

        return this;

    }

    @Override

    public ReportBuilder subtitle(String subtitle) {

        this.subtitle = subtitle;

        return this;

    }

    @Override

    public ReportBuilder printBackgroundOnOddRows(boolean printBackgroundOnOddRows) {

        this.printBackgroundOnOddRows = printBackgroundOnOddRows;

        return this;

    }

    @Override

    public ReportBuilder useFullPageWith(boolean useFullPageWith) {

        this.useFullPageWith = useFullPageWith;

        return this;

    }

    @Override

    public ReportBuilder showDetailBand(boolean showDetailBand) {

        this.showDetailBand = showDetailBand;

        return this;

    }

    @Override

    public ReportBuilder detailHeight(int detailHeight) {

        this.detailHeight = detailHeight;

        return this;

    }

    @Override

    public ReportBuilder columnsPerPage(int columnsPerPage) {

        this.columnsPerPage = columnsPerPage;

        return this;

    }

    @Override

    public ColumnBuilder add_column() {

        ColumnBuilder column = this.createColumn();

        this.columns.add(column);

        return column;

    }

    @Override

    public ReportBuilder margins(int top, int bottom, int left, int right) {

        if (this.margins == null) {

            this.margins = this.createMargins();

        }

        this.margins.set(top, bottom, left, right);

        return this;

    }

    @Override

    public int getLayout() {

        return this.layout;

    }

    @Override

    public boolean getPrintColumnNames() {

        return this.printColumnNames;

    }

    @Override

    public ReportBuilder printColumnNames(boolean printColumnNames) {

        this.printColumnNames = printColumnNames;

        return this;

    }

    @Override

    public int getPageFormat() {

        return this.pageFormat;

    }

    @Override

    public ReportBuilder pageFormat(int pageFormat) {

        this.pageFormat = pageFormat;

        return this;

    }

    @Override

    public ReportBuilder layout(int layout) {

        this.layout = layout;

        return this;

    }

    private LayoutManager getLayoutManager() {

        switch (this.layout) {

            case LAYOUT_LIST:

                return new ListLayoutManager();

            case LAYOUT_EXTENDEDLIST:

                return new ExtendedListLayoutManager();

            case LAYOUT_CLASSIC:

            default:

                return new ClassicLayoutManager();

        }

    }

    @Override

    public ReportBuilder clone() throws CloneNotSupportedException {

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

        if (this.margins != null) {

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

        }

        if (this.titleStyle != null) {

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

        }

        if (this.subtitleStyle != null) {

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

        }

        other.columns.retainAll(Collections.EMPTY_LIST);

        for (ColumnBuilder column : this.columns) {

            other.columns.add(column.clone());

        }

        return other;

    }

    @Override

    public void copyFrom(ReportBuilder other) {

        try {

            this.title = other.getTitle();

            this.subtitle = other.getSubtitle();

            this.printBackgroundOnOddRows = other.getPrintBackgroundOnOddRows();

            this.useFullPageWith = other.getUseFullPageWith();

            this.showDetailBand = other.getShowDetailBand();

            this.detailHeight = other.getDetailHeight();

            this.columnsPerPage = other.getColumnsPerPage();

            this.printColumnNames = other.getPrintColumnNames();

            this.layout = other.getLayout();

            this.pageFormat = other.getPageFormat();

            if (other.getMargins() != null) {

                this.margins = other.getMargins().clone();

            }

            if (other.titleStyle() != null) {

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

            }

            if (other.subtitleStyle() != null) {

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

            }

            this.columns.retainAll(Collections.EMPTY_LIST);

            for (ColumnBuilder column : other.getColumns()) {

                this.columns.add(column.clone());

            }

        } catch (CloneNotSupportedException ex) {

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

        }

    }

    public Report toReport(ReportDataSet dataSet) {

        DynamicReportBuilder builder = new DynamicReportBuilder();

        if (!StringUtils.isBlank(this.title)) {

            builder.setTitle(this.title);

            if (this.titleStyle != null) {

                builder.setTitleStyle(((DefaultStyleBuilder) this.titleStyle).build());

            }

        }

        if (!StringUtils.isBlank(this.subtitle)) {

            builder.setSubtitle(this.subtitle);

            if (this.subtitleStyle != null) {

                builder.setSubtitleStyle(((DefaultStyleBuilder) this.subtitleStyle).build());

            }

        }

        builder.setColumnsPerPage(this.columnsPerPage);

        if (this.detailHeight > 0) {

            builder.setDetailHeight(this.detailHeight);

        }

        builder.setUseFullPageWidth(this.useFullPageWith);

        builder.setPrintBackgroundOnOddRows(this.printBackgroundOnOddRows);

        builder.setOddRowBackgroundStyle(this.oddRowBackgroundStyle);

        if (this.margins != null) {

            builder.setMargins(

                    this.margins.getTop(),

                    this.margins.getBottom(),

                    this.margins.getLeft(),

                    this.margins.getRight()

            );

        }

        builder.setPrintColumnNames(this.printColumnNames);

        switch (this.pageFormat) {

            case PAGE_A4_PORTRAIT:

            default:

                builder.setPageSizeAndOrientation(Page.Page_A4_Portrait());

                break;

            case PAGE_A4_LANDSCAPE:

                builder.setPageSizeAndOrientation(Page.Page_A4_Landscape());

                break;

            case PAGE_LEGAL_PORTRAIT:

                builder.setPageSizeAndOrientation(Page.Page_Legal_Portrait());

                break;

            case PAGE_LEGAL_LANDSCAPE:

                builder.setPageSizeAndOrientation(Page.Page_Legal_Landscape());

                break;

            case PAGE_LETTER_PORTRAIT:

                builder.setPageSizeAndOrientation(Page.Page_Letter_Portrait());

                break;

            case PAGE_LETTER_LANDSCAPE:

                builder.setPageSizeAndOrientation(Page.Page_Letter_Landscape());

                break;

        }

        // Style column builder

        HashMap<String, AbstractColumn> mapColumns = new HashMap<String, AbstractColumn>();

        for (ColumnBuilder column : this.columns) {

            DefaultColumnBuilder columnBuilder = (DefaultColumnBuilder) column;

            AbstractColumn columnState = columnBuilder.build();

            mapColumns.put(column.getColumnName(), columnState);

            builder.addColumn(columnState);

        }

        // GroupBy builder

        for (GroupBuilder group : this.groups) {

            DJGroup groupBuilder = ((DefaultGroupBuilder) group).build(mapColumns, this.columns);

            builder.addGroup(groupBuilder);

        }

        builder.setShowDetailBand(this.showDetailBand);

        builder.addAutoText(AutoText.AUTOTEXT_PAGE_X_SLASH_Y, AutoText.POSITION_FOOTER, AutoText.ALIGNMENT_RIGHT);

        Map params = new HashMap();

        try {

            DynamicReport dynamicReport = builder.build();

            JasperReport jasperReport = DynamicJasperHelper.generateJasperReport(

                    dynamicReport,

                    this.getLayoutManager(),

                    params

            );

            ReportManager reportManager = ReportLocator.getReportManager();

            ReportConfig config = new DefaultReportConfig();

            config.setDataSet(dataSet);

            config.setName(this.title);

            config.setLayoutManager(this.layout);

            Report report = new DefaultReport(config, dynamicReport);

            return report;

        } catch (Exception ex) {

            LOG.warn("Can't create report.", ex);

            return null;

        }

    }

    @Override

    public void saveToState(PersistentState ps) throws PersistenceException {

        // TODO: Guardar en el state

    }

    @Override

    public void loadFromState(PersistentState ps) throws PersistenceException {

        // TODO: Cargar desde el state

    }

    public static void selfRegister() {

        // TODO: Registrar la persistencia

    }

    @Override

    public GroupBuilder add_group(ColumnBuilder columnBuilder) {

        GroupBuilder group = this.createGroup(columnBuilder);

        this.groups.add(group);

        return group;

    }

}

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

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

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

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

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

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

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

import ar.com.fdvs.dj.domain.entities.DJGroup;

import ar.com.fdvs.dj.domain.entities.columns.AbstractColumn;

import ar.com.fdvs.dj.domain.entities.columns.PropertyColumn;

import java.util.HashMap;

import java.util.List;

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

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

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

import org.gvsig.tools.persistence.PersistentState;

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

/**

 *

 * @author osc

 */

public class DefaultGroupBuilder implements ReportBuilder.GroupBuilder {

    private int groupLayout;

    private boolean startInNewColumn;

    private boolean startInNewPage;

    private final ColumnBuilder columnBuilder;

    public DefaultGroupBuilder(ColumnBuilder columnBuilder) {

        this.columnBuilder = columnBuilder;

        this.startInNewColumn = false;

        this.startInNewPage = false;

        this.groupLayout = GroupBuilder.GROUP_LAYOUT_VALUE_IN_HEADER;

    }

    @Override

    public ColumnBuilder getColumnBuilder() {

        return this.columnBuilder;

    }

    public DJGroup build(HashMap<String, AbstractColumn> mapColumns, List<ColumnBuilder> columnBuilders) {

        ar.com.fdvs.dj.domain.builders.GroupBuilder gb1 = new ar.com.fdvs.dj.domain.builders.GroupBuilder();

        AbstractColumn abstractColumn = mapColumns.get(this.columnBuilder.getColumnName());

        gb1.setCriteriaColumn((PropertyColumn) abstractColumn);

        Style headerVariables = new Style();

        headerVariables.setFont(Font.ARIAL_MEDIUM_BOLD);

        headerVariables.setHorizontalAlign(HorizontalAlign.RIGHT);

        headerVariables.setVerticalAlign(VerticalAlign.MIDDLE);

        for (ColumnBuilder col : columnBuilders) {

            if (col.showGroupByField()) {

                DJCalculation operation = getDJOperation(col.getGroupByOperation());

                AbstractColumn columnValue = mapColumns.get(col.getColumnName());

                gb1.addFooterVariable(columnValue, operation, headerVariables);

            }

        }

        GroupLayout dynamicJasperGroupLayout;

        switch (groupLayout) {

            case GroupBuilder.GROUP_LAYOUT_DEFAULT:

            default:

                dynamicJasperGroupLayout = GroupLayout.DEFAULT;

                break;

            case GroupBuilder.GROUP_LAYOUT_DEFAULT_WITH_HEADER:

                dynamicJasperGroupLayout = GroupLayout.DEFAULT_WITH_HEADER;

                break;

            case GroupBuilder.GROUP_LAYOUT_EMPTY:

                dynamicJasperGroupLayout = GroupLayout.EMPTY;

                break;

            case GroupBuilder.GROUP_LAYOUT_VALUE_FOR_EACH:

                dynamicJasperGroupLayout = GroupLayout.VALUE_FOR_EACH;

                break;

            case GroupBuilder.GROUP_LAYOUT_VALUE_FOR_EACH_WITH_HEADERS:

                dynamicJasperGroupLayout = GroupLayout.VALUE_FOR_EACH_WITH_HEADERS;

                break;

            case GroupBuilder.GROUP_LAYOUT_VALUE_IN_HEADER:

                dynamicJasperGroupLayout = GroupLayout.VALUE_IN_HEADER;

                break;

            case GroupBuilder.GROUP_LAYOUT_VALUE_IN_HEADER_AND_FOR_EACH:

                dynamicJasperGroupLayout = GroupLayout.VALUE_IN_HEADER_AND_FOR_EACH;

                break;

            case GroupBuilder.GROUP_LAYOUT_VALUE_IN_HEADER_AND_FOR_EACH_WITH_HEADERS:

                dynamicJasperGroupLayout = GroupLayout.VALUE_IN_HEADER_AND_FOR_EACH_WITH_HEADERS;

                break;

            case GroupBuilder.GROUP_LAYOUT_VALUE_IN_HEADER_WITH_HEADERS:

                dynamicJasperGroupLayout = GroupLayout.VALUE_IN_HEADER_WITH_HEADERS;

                break;

            case GroupBuilder.GROUP_LAYOUT_VALUE_IN_HEADER_WITH_HEADERS_AND_COLUMN_NAME:

                dynamicJasperGroupLayout = GroupLayout.VALUE_IN_HEADER_WITH_HEADERS_AND_COLUMN_NAME;

                break;

        }

        gb1.setGroupLayout(dynamicJasperGroupLayout);

        return gb1.build();

    }

    private DJCalculation getDJOperation(int operation) {

        switch (operation) {

            case ReportBuilder.GROUPBY_OPERATION_AVERAGE:

            default:

                return DJCalculation.AVERAGE;

            case ReportBuilder.GROUPBY_OPERATION_COUNT:

                return DJCalculation.COUNT;

            case ReportBuilder.GROUPBY_OPERATION_FIRST:

                return DJCalculation.FIRST;

            case ReportBuilder.GROUPBY_OPERATION_HIGHEST:

                return DJCalculation.HIGHEST;

            case ReportBuilder.GROUPBY_OPERATION_LOWEST:

                return DJCalculation.LOWEST;

            case ReportBuilder.GROUPBY_OPERATION_NOTHING:

                return DJCalculation.NOTHING;

            case ReportBuilder.GROUPBY_OPERATION_STANDARD_DEVIATION:

                return DJCalculation.STANDARD_DEVIATION;

            case ReportBuilder.GROUPBY_OPERATION_SUM:

                return DJCalculation.SUM;

            case ReportBuilder.GROUPBY_OPERATION_SYSTEM:

                return DJCalculation.SYSTEM;

            case ReportBuilder.GROUPBY_OPERATION_VARIANCE:

                return DJCalculation.VARIANCE;

        }

    }

    @Override

    public int getGroupLayout() {

        return this.groupLayout;

    }

    @Override

    public void groupLayout(int groupLayout) {

        this.groupLayout = groupLayout;

    }

    @Override

    public boolean getStartInNewColumn() {

        return this.startInNewColumn;

    }

    @Override

    public void startInNewColumn(boolean startInNewColumn) {

        this.startInNewColumn = startInNewColumn;

    }

    @Override

    public boolean getStartInNewPage() {

        return this.startInNewPage;

    }

    @Override

    public void startInNewPage(boolean startInNewPage) {

        this.startInNewPage = startInNewPage;

    }

    @Override

    public ReportBuilder.GroupBuilder clone() throws CloneNotSupportedException {

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

        return other;

    }

    @Override

    public void copyFrom(ReportBuilder.GroupBuilder other) {

        this.groupLayout = other.getGroupLayout();

        this.startInNewColumn = other.getStartInNewColumn();

        this.startInNewPage = other.getStartInNewPage();

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        //todo

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        // todo

    }

}

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

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

import java.awt.Color;

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

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

import org.gvsig.tools.persistence.PersistentState;

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

/**

 *

 * @author jjdelcerro

 */

public class DefaultBorderBuilder implements ReportBuilder.BorderBuilder {

    private Color color;

    private int lineStyle;

    private int width;

    public DefaultBorderBuilder() {

        this.color = Color.BLACK;

        this.width = 0;

        this.lineStyle = BorderBuilder.WIDTH_1POINT;

    }

    @Override

    public BorderBuilder clone() throws CloneNotSupportedException {

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

        return other;

    }

    @Override

    public void copyFrom(BorderBuilder other) {

        this.color = other.getColor();

        this.width = other.getWidth();

        this.lineStyle = other.getLineStyle();

    }