Application: gvSIG desktop

package org.gvsig.fmap.dal.store.jdbc2.spi;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.URL;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.FIELD_RESOURCES_NAME;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.FIELD_RESOURCES_RESOURCE;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_RESOURCES_NAME;

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

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

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

import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.resourcesstorage.AbstractResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class JDBCResourcesStorage extends AbstractResourcesStorage {

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

    private static class DataBaseResource implements Resource {

        private class ResourceInputStream extends InputStream {

            @Override

            public int read() throws IOException {

                return in.read();

            }

            @Override

            public void close() throws IOException {

                DataBaseResource.this.close();

            }

        }

        private class ResourceOutputStream extends OutputStream {

            @Override

            public void write(int b) throws IOException {

                out.write(b);

            }

            @Override

            public void flush() throws IOException {

                out.flush();

            }

            @Override

            public void close() throws IOException {

                DataBaseResource.this.close();

            }

        }

        private final JDBCStoreParameters storeParameters;

        private final String tableName;

        private final String name;

        private ByteArrayInputStream in;

        private ByteArrayOutputStream out;

        public DataBaseResource(JDBCStoreParameters storeParameters, String tableName, String name) {

            this.storeParameters = storeParameters;

            this.tableName = tableName;

            this.name = name;

        }

        @Override

        public boolean isReadOnly() {

            return false;

        }

        @Override

        public URL getURL() {

            try {

                String url = this.storeParameters.getUrl();

                return new URL(url + "&tableName=" + this.tableName + "&resourceName=" + this.name);

            } catch (Throwable ex) {

                return null;

            }

        }

        @Override

        public boolean exists() {

            FeatureStore store = null;

            try {

                DataManager dataManager = DALLocator.getDataManager();

                store = (FeatureStore) dataManager.openStore(

                        this.storeParameters.getDataStoreName(),

                        this.storeParameters

                );

                ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                String filter = builder.eq(

                        builder.column(FIELD_RESOURCES_NAME),

                        builder.constant(this.tableName+"."+this.name)

                ).toString();

                Feature feature = store.findFirst(filter);

                return feature!=null;

            } catch (Throwable ex) {

                LOGGER.warn("Can't access to the resoure '" + this.getURL() + "'.", ex);

            } finally {

                DisposeUtils.disposeQuietly(store);

            }

            return false;

        }

        @Override

        public InputStream asInputStream() throws IOException {

            if (this.in != null || this.out != null) {

                throw new IllegalStateException("Resource is already open (" + this.getURL() + ")");

            }

            FeatureStore store = null;

            try {

                DataManager dataManager = DALLocator.getDataManager();

                store = (FeatureStore) dataManager.openStore(

                        this.storeParameters.getDataStoreName(),

                        this.storeParameters

                );

                ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                String filter = builder.eq(

                        builder.column(FIELD_RESOURCES_NAME),

                        builder.constant(this.tableName+"."+this.name)

                ).toString();

                Feature feature = store.findFirst(filter);

                if (feature == null) {

                    return null;

                }

                byte[] resource = feature.getByteArray(FIELD_RESOURCES_RESOURCE);

                this.in = new ByteArrayInputStream(resource);

                return new ResourceInputStream();

            } catch (Throwable ex) {

                LOGGER.warn("Can't access to the resoure '" + this.getURL() + "'.", ex);

            } finally {

                DisposeUtils.disposeQuietly(store);

            }

            return null;

        }

        @Override

        public OutputStream asOutputStream() throws IOException {

            if (this.in != null || this.out != null) {

                throw new IllegalStateException("Resource is already open (" + this.getURL() + ").");

            }

            this.out = new ByteArrayOutputStream();

            return new ResourceOutputStream();

        }

        @Override

        public void close() {

            if (this.in != null) {

                IOUtils.closeQuietly(this.in);

                this.in = null;

            }

            if (this.out != null) {

                FeatureStore store = null;

                try {

                    DataManager dataManager = DALLocator.getDataManager();

                    store = (FeatureStore) dataManager.openStore(

                            this.storeParameters.getDataStoreName(),

                            this.storeParameters

                    );

                    store.edit();

                    ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                    String filter = builder.eq(

                            builder.column(FIELD_RESOURCES_NAME),

                            builder.constant(this.tableName+"."+this.name)

                    ).toString();

                    Feature feature = store.findFirst(filter);

                    EditableFeature efeature;

                    if (feature == null) {

                        efeature = store.createNewFeature();

                        efeature.set(FIELD_RESOURCES_NAME, this.tableName+"."+this.name);

                        efeature.set(FIELD_RESOURCES_RESOURCE, this.out.toByteArray());

                        store.insert(efeature);

                    } else {

                        efeature = feature.getEditable();

                        efeature.set(FIELD_RESOURCES_RESOURCE, this.out.toByteArray());

                        store.update(efeature);

                    }

                    store.finishEditing();

                } catch (Throwable ex) {

                    LOGGER.warn("Can't write the resoure '" + this.getURL() + "'.", ex);

                } finally {

                    DisposeUtils.disposeQuietly(store);

                }

            }

        }

    }

    private final ResourcesStorage alternativeStorge;

    private final JDBCStoreParameters resourcesStoreParameters;

    private final String tableName;

    public JDBCResourcesStorage(ResourcesStorage alternativeStorge, JDBCStoreParameters resourcesStoreParameters, String tableName) {

        this.alternativeStorge = alternativeStorge;

        if( StringUtils.equals(TABLE_RESOURCES_NAME, tableName) ) {

            // No podemos buscar recursos de la tabla de recursos, ya que si no

            // al abrise la tabla de recursos entraria en bucle.

            this.resourcesStoreParameters = null;

        } else {

            this.resourcesStoreParameters = resourcesStoreParameters;

        }

        this.tableName = tableName;

    }

    @Override

    public boolean isEmpty() {

        return this.resourcesStoreParameters == null;

    }

    @Override

    public Resource getResource(String name) {

        if( this.alternativeStorge!=null ) {

            Resource r = this.alternativeStorge.getResource(name);

            if( r.exists() ) {

                return r;

            }

        }

        if (this.resourcesStoreParameters == null) {

            return null;

        }

        return new DataBaseResource(

                this.resourcesStoreParameters, 

                this.tableName, 

                name

        );

    }

    @Override

    public List<Resource> getResources(String name) {

        if (this.resourcesStoreParameters == null) {

            return null;

        }

        if( this.alternativeStorge!=null ) {

            List<Resource> r = this.alternativeStorge.getResources(name);

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

                return r;

            }

        }

        FeatureStore store = null;

        try {

            DataManager dataManager = DALLocator.getDataManager();

            store = (FeatureStore) dataManager.openStore(

                    this.resourcesStoreParameters.getDataStoreName(),

                    this.resourcesStoreParameters

            );

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            List<ResourcesStorage.Resource> ress = new ArrayList<>();

            int n = 0;

            while (true) {

                String multiresourceName;

                if (n == 0) {

                    multiresourceName = name;

                } else {

                    multiresourceName = String.valueOf(n) + "." + name ;

                }

                String filter = builder.eq(

                        builder.column(FIELD_RESOURCES_NAME),

                        builder.constant(this.tableName+"."+multiresourceName)

                ).toString();

                Feature feature = store.findFirst(filter);

                if( feature==null ) {

                    break;

                }

                ress.add(new DataBaseResource(

                        this.resourcesStoreParameters, 

                        this.tableName,

                        multiresourceName

                    )

                );

                n++;

            }

            if (ress.isEmpty()) {

                return null;

            }

            return ress;

        } catch (Throwable ex) {

            LOGGER.warn("Can't get resources for '" + this.resourcesStoreParameters.getUrl()+"&resourceName="+name + "'.", ex);

            return null;

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

}