Application: gvSIG desktop

package org.gvsig.app.extension;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.nio.charset.Charset;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.zip.CRC32;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.IOUtils;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.PluginsManager;

import org.gvsig.featureform.swing.FeatureFormDefinitionsProvider;

import org.gvsig.featureform.swing.FeatureFormDefinitionsProvider.Entry;

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultFeatureFormDefinitionsProvider implements FeatureFormDefinitionsProvider {

    private class DefaultEntry implements Entry {

        private String key;

        private DynClass dynClass;

        private String xml;

        public DefaultEntry(String key, DynClass dynClass, String xml) {

            this.key = key;

            this.dynClass = dynClass;

            this.xml = xml;

        }

        public DefaultEntry(String key, DynClass dynClass) {

            this(key, dynClass, null);

        }

        public DefaultEntry(FeatureStore store) throws DataException {

            this(null, store.getDefaultFeatureType(), null);

            this.key = getFilename(store);

        }

        @Override

        public DynClass getDynClass() {

            return dynClass;

        }

        @Override

        public String getKey() {

            return key;

        }

        @Override

        public String getXml() {

            if (this.xml == null) {

                DynObjectManager dynObjectManager = ToolsLocator.getDynObjectManager();

                this.xml = dynObjectManager.exportSimpleDynClassDefinitions(this.getDynClass());

            }

            return this.xml;

        }

        public boolean setXml(String xml) {

            if (xml == null) {

                this.xml = null;

                return true;

            }

            Map classes;

            DynClass dynClass;

            DynObjectManager dynObjectManager = ToolsLocator.getDynObjectManager();

            try {

                InputStream is = IOUtils.toInputStream(xml, Charset.forName("UTF-8"));

                classes = dynObjectManager.importDynClassDefinitions(is, this.getClass().getClassLoader());

            } catch (Exception ex) {

                logger.warn("Can't parse xml definition.", ex);

                return false;

            }

            if (!classes.containsKey(this.getDynClass().getName())) {

                logger.warn("Can't load definition of '" + this.getDynClass().getName() + "' from xml.");

                return false;

            }

            this.xml = xml;

            return true;

        }

        public void setDynClass(DynClass dynClass) {

            this.dynClass = dynClass;

        }

        @Override

        public int compareTo(Entry t) {

            return this.getKey().compareTo(t.getKey());

        }

    }

    private static final Logger logger = LoggerFactory.getLogger(DefaultFeatureFormDefinitionsProvider.class);

    private File definitionsFolder = null;

    public File getDefinitionsFolder() throws IOException {

        if (this.definitionsFolder == null) {

            PluginsManager pluginManager = PluginsLocator.getManager();

            PluginServices plugin = pluginManager.getPlugin(CreateDefaultFormDefinitionExtension.class);

            File homeFolder = plugin.getPluginHomeFolder();

            File definitionsFolder = new File(homeFolder, "forms");

            if (!definitionsFolder.exists()) {

                FileUtils.forceMkdir(definitionsFolder);

            }

            this.definitionsFolder = definitionsFolder;

        }

        return this.definitionsFolder;

    }

    public long getCRC(FeatureType type) {

        StringBuilder buffer = new StringBuilder();

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

            FeatureAttributeDescriptor x = type.getAttributeDescriptor(i);

            buffer.append(x.getName());

            buffer.append(x.getDataTypeName());

            buffer.append(x.getSize());

        }

        CRC32 crc = new CRC32();

        byte[] data = buffer.toString().getBytes();

        crc.update(data);

        return crc.getValue();

    }

    public String getFilename(FeatureStore store) throws DataException {

        FeatureType type = store.getDefaultFeatureType();

        return store.getName() + "-" + Long.toHexString(getCRC(type)) + ".xml";

    }

    public Entry get(File definitionFile) {

        String xml;

        Map classes;

        DynClass dynClass;

        DynObjectManager dynObjectManager = ToolsLocator.getDynObjectManager();

        if (definitionFile == null || !definitionFile.exists()) {

            return null;

        }

        try {

            xml = FileUtils.readFileToString(definitionFile);

        } catch (Exception ex) {

            return null;

        }

        try {

            InputStream is = IOUtils.toInputStream(xml, Charset.forName("UTF-8"));

            classes = dynObjectManager.importDynClassDefinitions(is, this.getClass().getClassLoader());

        } catch (Exception ex) {

            logger.warn("Can't parse xml definition.", ex);

            return null;

        }

        try {

            dynClass = (DynClass) classes.values().iterator().next();

        } catch (Exception ex) {

            return null;

        }

        if (dynClass == null) {

            return null;

        }

        InputStream is;

        try {

            is = new FileInputStream(definitionFile);

        } catch (FileNotFoundException ex) {

            return null;

        }

        return new DefaultEntry(definitionFile.getName(), dynClass, xml);

    }

    @Override

    public Entry get(FeatureStore store) throws DataException {

        FeatureType type = store.getDefaultFeatureType();

        File f;

        try {

            f = new File(getDefinitionsFolder(), getFilename(store));

        } catch (IOException ex) {

            return new DefaultEntry(store);

        }

        Entry entry = this.get(f);

        return entry;

    }

    @Override

    public void put(Entry entry) throws DataException, IOException {

        if (!getDefinitionsFolder().exists()) {

            FileUtils.forceMkdir(getDefinitionsFolder());

        }

        File f = new File(getDefinitionsFolder(), entry.getKey());

        FileUtils.write(f, entry.getXml());

    }

    @Override

    public Iterator<Entry> iterator() {

        try {

            List<Entry> definitions = new ArrayList();

            File folder;

            folder = this.getDefinitionsFolder();

            for (File f : folder.listFiles()) {

                Entry entry = this.get(f);

                if (entry != null) {

                    definitions.add(entry);

                }

            }

            Collections.sort(definitions);

            return definitions.iterator();

        } catch (IOException ex) {

            logger.warn("Can't retrieve list of forms definitions.", ex);

            return null;

        }

    }

    @Override

    public void put(FeatureStore store) throws DataException, IOException {

        DefaultEntry entry = new DefaultEntry(store);

        this.put(entry);

    }

    @Override

    public DynClass getDynClass(FeatureStore store) throws DataException {

        Entry entry = this.get(store);

        if (entry == null) {

            return null;

        }

        return entry.getDynClass();

    }

}