Application: gvSIG desktop

package org.gvsig.app.extension;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.nio.charset.Charset;

import java.util.HashMap;

import java.util.Map;

import java.util.Properties;

import java.util.zip.CRC32;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.PluginsManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.complements.RelatedFeatures;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynform.JDynForm;

import static org.gvsig.tools.dynform.spi.DynFormSPIManager.TAG_DYNFORM_LAYOUTMODE;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynClass_v2;

import org.gvsig.tools.dynobject.DynField_v2;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.util.HasAFile;

import org.gvsig.tools.util.ResourcesStorage.Resource;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class DefaultFeatureTypeDefinitionsManager extends AbstractFeatureTypeDefinitionsManager implements FeatureTypeDefinitionsManager {

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

    private static final String FILE_EXTENSION = "form";

    private File definitionsFolder = null;

    private final Map<String, DynClass> dynClasses;

    public DefaultFeatureTypeDefinitionsManager() {

        this.dynClasses = new HashMap<>();

    }

    protected Map<String, DynClass> getDynClasses() {

        return this.dynClasses;

    }

    protected 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, "schemas");

            if (!definitionsFolder.exists()) {

                FileUtils.forceMkdir(definitionsFolder);

            }

            this.definitionsFolder = definitionsFolder;

        }

        return this.definitionsFolder;

    }

    protected long getCRC(FeatureType type) {

        StringBuilder buffer = new StringBuilder();

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

            FeatureAttributeDescriptor x = type.getAttributeDescriptor(i);

            if( !x.isComputed() ) {

                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();

    }

    protected String getKey(FeatureStore store, FeatureType featureType) {

        return store.getName() + "_" + Long.toHexString(getCRC(featureType));

    }

    protected String getKey(FeatureStore store, FeatureType featureType, String name) {

        CRC32 crc = new CRC32();

        crc.update(name.getBytes());

        crc.getValue();

        if( !StringUtils.isAlphanumeric(name) ) {

            name = StringUtils.removeAll(name, "[^a-zA-Z0-9_]");

        }

        return store.getName() + name + "_" + Long.toHexString(getCRC(featureType))+Long.toHexString(crc.getValue()) ;

    }

    protected File getDefinitionFile(String key) {

        File folder;

        try {

            folder = getDefinitionsFolder();

        } catch (IOException ex) {

            return null;

        }

        File f = new File(folder, key + "."+FILE_EXTENSION);

        if (f.exists()) {

            return f;

        }

        Properties prop = new Properties();

        FileInputStream fin = null;

        try {

            fin = new FileInputStream(new File(folder, "index.properties"));

            prop.load(fin);

        } catch (IOException ex) {

            return null;

        } finally {

            IOUtils.closeQuietly(fin);

        }

        String s = prop.getProperty(key, null);

        if (s == null) {

            return null;

        }

        f = new File(folder, s);

        if (f.exists()) {

            return f;

        }

        f = new File(s);

        if (f.exists()) {

            return f;

        }

        return null;

    }

    @Override

    public DynClass get(FeatureStore store, FeatureType featureType) {

        String key = this.getKey(store, featureType);

        DynClass dynClass = this.getDynClasses().get(key);

        if (dynClass != null) {

            return dynClass;

        }

        String xml = null;

        File definitionFile = getDefinitionFile(key);

        if (definitionFile == null) {

            DataServerExplorer explorer = null;

            Resource resource = null;

            try {

                explorer = store.getExplorer();

                resource = explorer.getResource(store, FILE_EXTENSION);

                if( resource !=null && resource.exists() ) {

                    xml = IOUtils.toString(resource.asInputStream());

                } else {

                    return this.getDynClass(store, featureType);

                }

            } catch(Exception ex) {

                // Do nothing, leave xml to null

            } finally {

                IOUtils.closeQuietly(resource);

                DisposeUtils.disposeQuietly(explorer);

            }

        }

        DynObjectManager dynObjectManager = ToolsLocator.getDynObjectManager();

        try {

            if( xml!=null ) {

                xml = FileUtils.readFileToString(definitionFile);

                xml = xml.replaceAll("[$][{]CWD[}]",definitionFile.getParentFile().getAbsolutePath());

            }

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

            Map<String, DynClass> dynClasses = dynObjectManager.importDynClassDefinitions(is, this.getClass().getClassLoader());

            for (DynClass aDynClass : dynClasses.values()) {

                this.getDynClasses().put(aDynClass.getName(), aDynClass);

            }

        } catch (Exception ex) {

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

            return null;

        }

        dynClass = this.getDynClasses().get(key);

        if (dynClass != null) {

            return dynClass;

        }

        return this.getDynClass(store, featureType);

    }

    @Override

    public boolean contains(FeatureStore store, FeatureType featureType) {

        String key = this.getKey(store, featureType);

        return this.getDynClasses().containsKey(key);

    }

    @Override

    public void add(FeatureStore store, FeatureType featureType, DynClass dynClass) {

        try {

            if( dynClass instanceof FeatureType ) {

                dynClass = this.getDynClass(store, (FeatureType) dynClass);

            }

            String key = this.getKey(store, featureType);

            File f = new File(getDefinitionsFolder(), key + "."+FILE_EXTENSION);

            DynObjectManager dynObjectManager = ToolsLocator.getDynObjectManager();

            String xml = dynObjectManager.exportSimpleDynClassDefinitions(dynClass);

            FileUtils.write(f, xml);

            this.getDynClasses().put(key, dynClass);

        } catch (IOException ex) {

            throw new RuntimeException(ex);

        }

    }

    @Override

    public void remove(FeatureStore store, FeatureType featureType) {

        String key = this.getKey(store, featureType);

        this.getDynClasses().remove(key);

    }

    @Override

    public void addModel(File model) {

              DynObjectManager dynObjectManager = ToolsLocator.getDynObjectManager();

          try {

              String xml = FileUtils.readFileToString(model);

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

              Map<String, DynClass> dynClasses = dynObjectManager.importDynClassDefinitions(is, this.getClass().getClassLoader());

              File folder;

              try {

                  folder = getDefinitionsFolder();

              } catch (IOException ex) {

                  return ;

              }

              Properties prop = new Properties();

              FileInputStream fin = null;

              try {

                  fin = new FileInputStream(new File(folder, "index.properties"));

                  prop.load(fin);

              } catch (IOException ex) {

              } finally {

                  IOUtils.closeQuietly(fin);

              }

              for (DynClass aDynClass : dynClasses.values()) {

                      String className = aDynClass.getName();

                      prop.setProperty(className, model.getAbsolutePath());

              }

              FileOutputStream fout = null;

              try {

                      fout = new FileOutputStream(new File(folder, "index.properties"));

                  prop.store(fout, "");

              } catch (IOException ex) {

              } finally {

                  IOUtils.closeQuietly(fout);

              }

          } catch (Exception ex) {

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

          }

    }

    private DynClass getDynClass(FeatureStore store, FeatureType featureType) {

        DynObjectManager manager = ToolsLocator.getDynObjectManager();

        DynClass_v2 definition = (DynClass_v2) manager.createCopy(featureType);

        File path = null;

        if( store!=null ) {

            try {

                String label = featureType.getLabel();

                if( StringUtils.isEmpty(label) ) {

                    definition.setLabel(store.getName());

                } else {

                    definition.setLabel(label);

                }

                DataStoreParameters params = store.getParameters();

                if( params instanceof HasAFile ) {

                    File f = ((HasAFile)params).getFile();

                    if( f!=null ) {

                        path = f.getParentFile();

                    }

                }

            } catch (Exception ex) {

            }

        }

        boolean calculateLayout = true;

        if( featureType.getTags().has(TAG_DYNFORM_LAYOUTMODE) ) {

            calculateLayout = false;

        }

        for (FeatureAttributeDescriptor descriptor : featureType) {

            DynField_v2 definitionField = (DynField_v2) definition.getDynField(descriptor.getName());

            String profileName = descriptor.getDataProfileName();

            if( !StringUtils.isBlank(profileName) ) {

                definitionField.setSubtype(profileName);

            }

            if( path!=null && definitionField.getType()==DataTypes.FILE ) {

                Tags tags = definitionField.getTags();

                if (!tags.has("path")) {    

                    tags.set("path", path);

                }

            }

            if( calculateLayout ) {

                RelatedFeatures complement = (RelatedFeatures) ToolsLocator.getComplementsManager().get(

                        RelatedFeatures.COMPLEMENT_MANE, descriptor

                );

                if( complement.isRelatedFeatures() ) {

                    definition.getTags().set(TAG_DYNFORM_LAYOUTMODE, JDynForm.USE_TABS);

                    definitionField.setGroup(descriptor.getLabel());

                }

            }

        }

        return definition;

    }

}