Application: gvSIG desktop

package org.gvsig.export.impl.service;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.function.Function;

import org.apache.commons.collections.CollectionUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.export.ExportAttributes;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.namestranslator.NamesTranslator;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public final class DefaultExportAttributes implements ExportAttributes {

    private List<ExportAttribute> exportAttributes;

    private NamesTranslator namesTranslator = null;

    private FeatureType sourceFeatureType;

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

    private boolean active;

    private FeatureQuery query = null;

    public DefaultExportAttributes() {

        this.namesTranslator = NamesTranslator.createBaseTranslator();

        this.active = false;

    }

    public void fillExportAttributes(FeatureType ftype, FeatureQuery query) {

        ArrayList attrs = new ArrayList();

        if (ftype != null) {

            for (FeatureAttributeDescriptor fad : ftype) {

                DefaultExportAttribute exportAttribute = new DefaultExportAttribute(fad.getCopy(), this.getNamesTranslator());

                exportAttribute.setNewType(fad.getDataType().getType());

                exportAttribute.setSize(fad.getSize());

                if (query == null || (query != null && query.getGroupByColumns().isEmpty())) {

                    exportAttribute.setExported(isShowableDataType(fad.getDataType()));

                } else {

                    if (query.getAggregate(fad.getName()) != null || query.getGroupByColumns().contains(fad.getName())) {

                        exportAttribute.setExported(isShowableDataType(fad.getDataType()));

                    } else {

                        exportAttribute.setExported(false);

                    }

                }

                attrs.add(exportAttribute);

            }

        }

        if (query != null && query.getExtraColumn().getColumns() != null && !query.getExtraColumn().getColumns().isEmpty()) {

            for (FeatureAttributeDescriptor fad : query.getExtraColumn().getColumns()) {

                DefaultExportAttribute exportAttribute = new DefaultExportAttribute(fad.getCopy(), this.getNamesTranslator());

                this.getNamesTranslator().addSource(fad.getName());

                exportAttribute.setNewType(fad.getDataType().getType());

                exportAttribute.setSize(fad.getSize());

                if (attributeAsComputedAndGroupBy(query, fad.getName())) {

                    exportAttribute.setComputed(false);

                }

                exportAttribute.setExported(isShowableDataType(fad.getDataType()));

                attrs.add(exportAttribute);

            }

        }

        this.setExportAttributes(attrs);

    }

    protected boolean attributeAsComputedAndGroupBy(FeatureQuery query, String attr) {

        if (!query.hasGroupByColumns()) {

            return false;

        }

        List<String> groupByCols = query.getGroupByColumns();

        if (groupByCols.isEmpty()) {

            return false;

        }

        return groupByCols.contains(attr);

    }

    protected boolean isShowableDataType(DataType dataType) {

        if ( dataType.getType() != DataTypes.GEOMETRY && (

                 dataType.isContainer()

                || dataType.isObject()

                || dataType.getType() == DataTypes.ARRAY)) {

            return false;

        } else {

            return true;

        }

    }

    @Override

    public void setNamesTranslator(NamesTranslator namesTranslator) {

        if (this.namesTranslator != namesTranslator) {

            this.namesTranslator = namesTranslator;

            if (this.sourceFeatureType != null) {

                this.namesTranslator.rebuild();

            }

        }

    }

    @Override

    public NamesTranslator getNamesTranslator() {

        return this.namesTranslator;

    }

    @Override

    public List<ExportAttribute> toList() {

        return this.exportAttributes;

    }

    @Override

    public boolean isEmpty() {

        return this.exportAttributes.isEmpty();

    }

    @Override

    public int size() {

        return this.exportAttributes.size();

    }

    @Override

    public Iterator<ExportAttribute> iterator() {

        return this.exportAttributes.iterator();

    }

    @Override

    public ExportAttribute get(int position) {

        return this.exportAttributes.get(position);

    }

    @Override

    public ExportAttribute getExportAttribute(String name) {

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (StringUtils.equals(exportAttribute.getName(), name)) {

                return exportAttribute;

            }

        }

        return null;

    }

    @Override

    public FeatureType getTargetFeatureType() {

        EditableFeatureType targetFeatureType = DALLocator.getDataManager().createFeatureType();

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (!exportAttribute.isExported()) {

                continue;

            }

            FeatureAttributeDescriptor descriptor = exportAttribute.getDescriptor();//.getCopy();

            EditableFeatureAttributeDescriptor targetDescriptor = DALLocator.getDataManager().createFeatureAttributeDescriptor(

                    descriptor.getName(),

                    descriptor.getType()

            );

            targetDescriptor.copyFrom(descriptor);

            targetDescriptor.setName(exportAttribute.getNewName());

            if (targetDescriptor.isComputed() && !exportAttribute.isComputed()) {

                targetDescriptor.setFeatureAttributeEmulator((FeatureAttributeEmulator) null);

            }

            if (targetDescriptor.getType() != exportAttribute.getNewDataType()) {

                targetDescriptor.setDefaultValue(null);

            }

            targetDescriptor.setDataType(exportAttribute.getNewDataType());

            targetDescriptor.setSize(exportAttribute.getSize());

            targetFeatureType.addLike(targetDescriptor);

        }

        Tags srcTags = sourceFeatureType.getTags();

        if( srcTags!=null && !srcTags.isEmpty() ) {

            Tags targetTags = targetFeatureType.getTags();

            for (String tagName : srcTags) {

                targetTags.set(tagName, srcTags.get(tagName));

            }

        }

        return targetFeatureType.getNotEditableCopy();

    }

    @Override

    public void setSourceFeatureType(FeatureType sourceFeatureType, FeatureQuery query) {

        this.query = query;

        if (!sourceFeatureType.equals(this.sourceFeatureType)) {

            this.sourceFeatureType = sourceFeatureType;

            this.getNamesTranslator().updateSourceNames(sourceFeatureType, new Function() {

                @Override

                public Object apply(Object t) {

                    FeatureAttributeDescriptor attr = (FeatureAttributeDescriptor) t;

                    return attr.getName();

                }

            });

            this.fillExportAttributes(this.sourceFeatureType, query);

        }

    }

    @Override

    public FeatureType getSourceFeatureType() {

        return this.sourceFeatureType;

    }

    @Override

    public String getTargetName(String name) {

        for (int i = 0; i < exportAttributes.size(); i++) {

            ExportAttribute exportAttribute = exportAttributes.get(i);

            if (StringUtils.equals(exportAttribute.getName(), name)) {

                String newName = exportAttribute.getNewName();

                return newName;

            }

        }

        return null;

    }

    @Override

    public String getSourceName(String name) {

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (StringUtils.equalsIgnoreCase(exportAttribute.getNewName(), name)) {

                return exportAttribute.getName();

            }

        }

        return null;

    }

    @Override

    public int getTargetType(String name) {

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (StringUtils.equals(exportAttribute.getName(), name)) {

                return exportAttribute.getNewDataType();

            }

        }

        return 0;

    }

    @Override

    public int getSourceType(String name) {

        for (ExportAttribute exportAttribute : this.exportAttributes) {

            if (StringUtils.equals(exportAttribute.getNewName(), name)) {

                return exportAttribute.getDataType();

            }

        }

        return 0;

    }

    @Override

    public ExportAttributes clone() throws CloneNotSupportedException {

        DefaultExportAttributes clone = (DefaultExportAttributes) super.clone();

        clone.namesTranslator = this.namesTranslator.clone();

        List cloneListAttribute = new ArrayList();

        for (ExportAttribute exportAttribute : exportAttributes) {

            cloneListAttribute.add(exportAttribute.clone());

        }

        clone.setExportAttributes(cloneListAttribute);

        return clone;

    }

    @Override

    public void setExportAttributes(List<ExportAttribute> exportAttributes) {

        this.exportAttributes = exportAttributes;

    }

    @Override

    public void setActive(boolean active) {

        this.active = active;

    }

    @Override

    public boolean isActive() {

        return this.active;

    }

    public static void registerPersistence() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition("ExportAttributes") == null) {

            DynStruct definition = manager.addDefinition(DefaultExportAttributes.class,

                    "ExportAttributes", "ExportAttributes persistence definition", null, null);

            definition.addDynFieldList("exportAttributes").setClassOfItems(ExportAttribute.class);

            definition.addDynFieldObject("namesTranslator").setClassOfValue(NamesTranslator.class);

            definition.addDynFieldObject("sourceFeatureType").setClassOfValue(FeatureType.class);

            definition.addDynFieldBoolean("active");

        }

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("exportAttributes", this.exportAttributes.iterator());

        state.set("namesTranslator", this.namesTranslator);

        state.set("sourceFeatureType", this.sourceFeatureType);

        state.set("active", this.active);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        Iterator it = state.getIterator("exportAttributes");

        List<ExportAttribute> data = new ArrayList<>();

        while (it.hasNext()) {

            ExportAttribute ref = (ExportAttribute) it.next();

            data.add(ref);

        }

        this.exportAttributes = data;

        NamesTranslator nameTranslatorState = (NamesTranslator) state.get("namesTranslator");

        if (nameTranslatorState != null) {

            this.namesTranslator = nameTranslatorState;

        }

        this.sourceFeatureType = (FeatureType) state.get("sourceFeatureType");

        this.active = state.getBoolean("active");

    }

}