Application: gvSIG desktop

/**

 * 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.fmap.dal.store.csv;

import java.io.File;

import java.io.IOException;

import java.io.Reader;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.FileHelper;

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

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.PerformEditingException;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.resource.ResourceAction;

import org.gvsig.fmap.dal.resource.spi.ResourceConsumer;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.fmap.dal.store.csv.simplereaders.CSVReaderSuperCSV;

import org.gvsig.fmap.dal.store.csv.simplereaders.FixedLenReader;

import org.gvsig.fmap.dal.store.simplereader.simplereaders.SimpleReader;

import org.gvsig.fmap.dal.store.simplereader.SimpleReaderFeatureTypeLoader;

import org.gvsig.fmap.dal.store.simplereader.SimpleReaderStoreParameters;

import org.gvsig.fmap.dal.store.simplereader.SimpleReaderStoreProvider;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.i18n.I18nManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.supercsv.prefs.CsvPreference;

@SuppressWarnings("UseSpecificCatch")

public class CSVStoreProvider extends SimpleReaderStoreProvider implements

        ResourceConsumer {

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

    public static final String NAME = DataStore.CSV_PROVIDER_NAME;

    public static final String DESCRIPTION = "CSV file";

    public static final String METADATA_DEFINITION_NAME = NAME;

    protected final CSVFeatureWriter writer;

    @SuppressWarnings({"OverridableMethodCallInConstructor", "LeakingThisInConstructor"})

    public CSVStoreProvider(

            CSVStoreParameters parameters,

            DataStoreProviderServices storeServices

        ) throws InitializeException {

        super(

                parameters,

                storeServices,

                FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME)

        );

        this.writer = new CSVFeatureWriter();

    }

    private CSVStoreParameters getCSVParameters() {

        return (CSVStoreParameters) this.getParameters();

    }

    @Override

    public String getProviderName() {

        return NAME;

    }

    @Override

    public boolean allowWrite() {

        return true;

    }

    @Override

    @SuppressWarnings("Convert2Lambda")

    public void performChanges(Iterator deleteds, Iterator inserteds, Iterator updateds, Iterator originalFeatureTypesUpdated) throws PerformEditingException {

        try {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.taskStatus.add();

            taskStatus.message(i18n.getTranslation("_Preparing_writing"));

            this.getResource().closeRequest();

            getResource().execute(new ResourceAction() {

                @Override

                public Object run() throws Exception {

                    FeatureSet features = null;

                    DisposableIterator it = null;

                    try {

                        File file = (File) resource.get();

                        features = getStoreServices().getFeatureStore().getFeatureSet();

                        taskStatus.message(i18n.getTranslation("_Writing_records"));

                        if (virtualrows == null) {

                            List<FeatureProvider> newdata = new ArrayList<>();

                            FeatureType ftype = getStoreServices().getDefaultFeatureType();

                            writer.initialize(getCSVParameters(), file, ftype, getCSVPreferences(), spatialIndexes);

                            writer.begin();

                            it = features.fastIterator();

                            taskStatus.setRangeOfValues(0, features.getSize());

                            taskStatus.setCurValue(0);

                            while (it.hasNext()) {

                                taskStatus.incrementCurrentValue();

                                FeatureProvider feature = getStoreServices().getFeatureProviderFromFeature(

                                        (org.gvsig.fmap.dal.feature.Feature) it.next());

                                writer.add(feature);

                                if (feature.getOID() == null) {

                                    LOGGER.warn("feature without OID");

                                    feature.setOID(createNewOID());

                                }

                                newdata.add(feature);

                            }

                            data = newdata;

                            if (writer.getEnvelopes() != null) {

                                envelopes = writer.getEnvelopes();

                            } else {

                                envelopes = null;

                            }

                            resource.notifyChanges();

                            writer.end();

                            bboxFileSave(envelopes);

                        } else {

                            CSVStoreParameters csvParams = getCSVParameters();

                            CSVStoreParameters tmpParams = (CSVStoreParameters) csvParams.getCopy();

                            String tmpBase = File.createTempFile("tmp_" + System.currentTimeMillis(), null).getAbsolutePath();

                            File tmpFile = new File(tmpBase + ".csv");

                            tmpParams.setFile(tmpFile);

                            FeatureType ftype = getStoreServices().getDefaultFeatureType();

                            writer.initialize(tmpParams, tmpFile, ftype, getCSVPreferences(),spatialIndexes);

                            writer.begin();

                            it = features.fastIterator();

                            taskStatus.setIndeterminate();

                            taskStatus.setCurValue(0);

                            while (it.hasNext()) {

                                taskStatus.incrementCurrentValue();

                                if( taskStatus.isCancellationRequested() ) {

                                    taskStatus.cancel();

                                    LOGGER.info("CSV writing canceled ("+getFullFileName()+")");

                                    break;

                                }

                                FeatureProvider feature = getStoreServices().getFeatureProviderFromFeature(

                                        (org.gvsig.fmap.dal.feature.Feature) it.next());

                                writer.add(feature);

                                if (feature.getOID() == null) {

                                    LOGGER.warn("feature without OID");

                                    feature.setOID(createNewOID());

                                }

                            }

                            if (writer.getEnvelopes() != null) {

                                envelopes = writer.getEnvelopes();

                            } else {

                                envelopes = null;

                            }

                            resource.notifyChanges();

                            writer.end();

                            if( !taskStatus.isCancelled() ) {

                                if (!csvParams.getFile().delete()) {

                                    LOGGER.debug("Can't delete csv file '" + csvParams.getFile() + "'.");

                                    throw new IOException("Can't delete csv '"

                                            + FilenameUtils.getBaseName(csvParams.getFile().getAbsolutePath())

                                            + "' file to replace with the new csv.\nThe new csv is in temporary file '" + tmpFile.getAbsolutePath()

                                            + "'");

                                }

                                File csvFile = csvParams.getFile();

                                FileUtils.moveFile(tmpParams.getFile(), csvFile);

                                FileUtils.delete(new File(FilenameUtils.removeExtension(csvFile.getAbsolutePath())+".idx"));

                                bboxFileSave(envelopes);

                                loadFeatures();

                            }

                        }

                    } finally {

                        if (it != null) {

                            it.dispose();

                        }

                        if (features != null) {

                            features.dispose();

                        }

                    }

                    return null;

                }

            });

            this.taskStatus.terminate();

        } catch (Exception e) {

            this.taskStatus.abort();

            throw new PerformEditingException(getResource().toString(), e);

        }

    }

    private CsvPreference getCSVPreferences() {

        CSVReaderSuperCSV reader = new CSVReaderSuperCSV(getCSVParameters());

        return reader.getCSVPreferences();

    }

    @Override

    public boolean supportsAppendMode() {

        return true;

    }

    @Override

    @SuppressWarnings("Convert2Lambda")

    public void append(final FeatureProvider featureProvider) {

        //todo

        getResource().execute(new ResourceAction() {

            @Override

            public Object run() throws Exception {

                //writer.append(getStoreServices().createFeature(featureProvider));

                writer.add(featureProvider);

                return null;

            }

        });

    }

    @Override

    @SuppressWarnings("Convert2Lambda")

    public void beginAppend() throws DataException {

        getResource().execute(new ResourceAction() {

            @Override

            public Object run() throws Exception {

                writer.initialize(getCSVParameters(),

                        getCSVParameters().getFile(),

                        getFeatureStore().getDefaultFeatureType(),

                        getCSVPreferences(),

                        spatialIndexes

                );

                writer.beginAppend();

                return null;

            }

        });

    }

    @Override

    @SuppressWarnings("Convert2Lambda")

    public void endAppend() {

        try {

            getResource().execute(new ResourceAction() {

                @Override

                public Object run() throws Exception {

                    writer.end();

                    resource.notifyChanges(); //resourcesNotifyChanges();

                    counterNewsOIDs = -1;

                    return null;

                }

            });

            if (writer.getEnvelopes() != null) {

                envelopes = writer.getEnvelopes();

            } else {

                envelopes = null;

            }

            writer.end();

            this.close();

            bboxFileSave(envelopes);            

        } catch (Exception ex) {

            LOGGER.warn("Not been able to end append '" + this.getFullName() + "'.", ex);

        }

    }

    @Override

    protected boolean mustFixFeatureType() {

        try {

            String param_types_def = CSVStoreParameters.getRawFieldTypes(this.getParameters());

            String[] pointDimensionNames = CSVStoreParameters.getPointDimensionNames(this.getParameters());

            String geometry_column = CSVStoreParameters.getGeometryColumn(this.getParameters());

            FeatureType dalFeatureType = this.getStoreServices().getDefaultFeatureType();

            if (StringUtils.isNotBlank(geometry_column)){

                FeatureAttributeDescriptor attr = dalFeatureType.getAttributeDescriptor(geometry_column);

                if(attr == null || attr.getType() !=  DataTypes.GEOMETRY){

                    return true;

                }

            }

            if (StringUtils.isNotBlank(param_types_def)

                    || pointDimensionNames != null) {

                for (FeatureAttributeDescriptor dalAttr : dalFeatureType) {

                    if(dalAttr.isComputed()){

                        continue;

                    }

                    FeatureAttributeDescriptor csvAttr = featureType.getAttributeDescriptor(dalAttr.getName());

                    if(csvAttr == null){

                        return true;

                    }

                    if(!dalAttr.get("all").equals(csvAttr.get("all"))){

                        return true;

                    }

                }

            }

        } catch (DataException ex) {

            LOGGER.warn("Can't check if should fix the feature type", ex);

        }

        return false;

    }

    @Override

    protected SimpleReader getSimpleReader(SimpleReaderStoreParameters parameters, Reader in) throws IOException {

        SimpleReader reader;

        if (CSVStoreParameters.getRawFieldsDefinition(parameters) != null) {

            reader = new FixedLenReader(in, (CSVStoreParameters) parameters);

        } else {

            reader = new CSVReaderSuperCSV(in, (CSVStoreParameters) parameters);

        }

        return reader;

    }

    @Override

    protected SimpleReaderFeatureTypeLoader getFeatureTypeLoader() {

        return new CSVFeatureTypeLoader(getCSVParameters());

    }

    @Override

    public List<String> getRowByIndex(long index) {

        List<String> line = super.getRowByIndex(index);

        if( line!=null ) {

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

                String s = line.get(i);

                line.set(i, CSVReaderSuperCSV.unescapeCRLF(s));

            }

        }      

        return line;

    }

}