Application: gvSIG desktop » gvSIG scripting

package org.gvsig.scripting.impl;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.io.File;

import java.io.IOException;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.logging.Level;

import org.ini4j.Ini;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.BooleanUtils;

import org.gvsig.scripting.ScriptingFolder;

import org.gvsig.scripting.ScriptingManager;

import org.gvsig.scripting.ScriptingUnit;

import org.ini4j.Profile.Section;

public abstract class AbstractUnit implements ScriptingUnit, Unit {

    protected static final Logger logger = LoggerFactory.getLogger(AbstractUnit.class);

    protected DefaultScriptingManager manager;

    protected String id;

    protected String name = null;

    protected String description;

    protected String createdBy;

    protected String version;

    protected ScriptingFolder parent;

    protected String typename;

    protected Set<PropertyChangeListener> changeListener;

    protected boolean saved;

    private Map<String,String> properties;

    public AbstractUnit(ScriptingFolder parent, String typename, ScriptingManager manager, String id) {

        this.parent = parent;

        this.manager = (DefaultScriptingManager) manager;

        this.typename = typename;

        this.id = id;

        this.changeListener = null;

        this.properties = null;

    }

    @Override

    public void addPropertyChangeListener(PropertyChangeListener listener) {

        if( this.changeListener==null ) {

            this.changeListener = new HashSet<>();

        }

        this.changeListener.add(listener);

    }

    public void firePropertyChange(PropertyChangeEvent event) {

        if( this.changeListener==null ) {

            return;

        }

        for( PropertyChangeListener listener : this.changeListener ) {

            try {

                if( listener != null ) {

                    listener.propertyChange(event);

                }

            } catch(Exception ex) {

                logger.warn("Problems firing PropertyChangeListener to listener "+listener+".",ex);

            }

        }

    }

    public void firePropertyChangeListener(String name, Object oldValue, Object newValue) {

        PropertyChangeEvent event = new PropertyChangeEvent(this,name, oldValue, newValue);

        firePropertyChange(event);

    }

    @Override

    public String getTypeName() {

        return typename;

    }

    @Override

    public abstract void load(ScriptingFolder folder, String id);

    @Override

    public void reload() {

        this.load( this.getParent(), this.getId());

    }

    @Override

    public String toString() {

        if (this.getName() == null) {

            return "(" + this.getClass().getSimpleName() + ")";

        }

        return this.getName();

    }

    protected void setParent(ScriptingFolder parent) {

        this.parent = parent;

    }

    public ScriptingManager getManager() {

        return this.manager;

    }

    protected File getFileResource(String extension) {

        return new File(this.getParent().getFile(), this.id + extension).getAbsoluteFile();

    }

    @Override

    public String getDescription() {

        return this.description;

    }

    @Override

    public String getCreatedBy() {

        return this.createdBy;

    }

    @Override

    public String getVersion() {

        return this.version;

    }

    @Override

    public String getId() {

        return this.id;

    }

    @Override

    public String getName() {

        if (this.name == null) {

            return this.id;

        }

        return this.name;

    }

    @Override

    public void setDescription(String description) {

        firePropertyChangeListener("description", description, this.description);

        this.description = description;

    }

    @Override

    public void setCreatedBy(String createdBy) {

        firePropertyChangeListener("createdBy", createdBy, this.createdBy);

        this.createdBy = createdBy;

    }

    @Override

    public void setVersion(String version) {

        firePropertyChangeListener("version", version, this.version);

        this.version = version;

    }

    @Override

    public void setId(String id) {

        firePropertyChangeListener("id", id, this.id);

        if (this instanceof ScriptingFolder) {

            this.id = id;

        } else {

            this.id = FilenameUtils.getBaseName(id);

        }

    }

   @Override

    public void setName(String name) {

        firePropertyChangeListener("name", name, this.name);

        this.name = name;

    }

    @Override

    public ScriptingFolder getParent() {

        return this.parent;

    }

    private String toStringNotNull(String s) {

        if (s == null) {

            return "";

        }

        return s;

    }

    protected void save(Ini prefs) {

        prefs.put("Unit", "type", toStringNotNull(this.getTypeName()));

        prefs.put("Unit", "name", this.getName());

        prefs.put("Unit", "description", toStringNotNull(this.getDescription()));

        prefs.put("Unit", "createdBy", toStringNotNull(this.getCreatedBy()));

        prefs.put("Unit", "version", toStringNotNull(this.getVersion()));

        if( this.properties!=null ) {

            for (Map.Entry<String, String> property : properties.entrySet()) {

                String name = property.getKey();

                String value = property.getValue();

                prefs.put("properties", name, value);

            }

        }

        try {

            prefs.store();

        } catch (IOException e) {

            File f = prefs.getFile();

            String fname = (f == null) ? "(null)" : f.getAbsolutePath();

            logger.warn("Can't save inf file '" + fname + "'.");

        }

    }

    protected void loadInf(Ini prefs) {

        String typename = getInfString(prefs, "Unit", "type", this.getTypeName());

        if (!this.getTypeName().equalsIgnoreCase(typename)) {

            File f = prefs.getFile();

            String fname = (f == null) ? "(null)" : f.getAbsolutePath();

            logger.warn("inconsistent type in inf file '" + fname + "'. Curent type '" + this.getTypeName() + "', type from inf file '" + typename + "'.");

        }

        this.setName(getInfString(prefs, "Unit", "name", this.getName()));

        this.setDescription(getInfString(prefs, "Unit", "description", null));

        this.setCreatedBy(getInfString(prefs, "Unit", "createdBy", null));

        this.setVersion(getInfString(prefs, "Unit", "version", null));

        Section sec = prefs.get("properties");

        if( sec != null ) {

            for(Map.Entry<String,String> entry : sec.entrySet() ) {

                this.setProperty(entry.getKey(), entry.getValue());

            }

        }

    }

    protected Object getInfValue(Ini prefs, String section, String option, Object defaultValue) {

        Object r = prefs.get(section, option);

        if (r == null) {

            return defaultValue;

        } else {

            return r;

        }

    }

    protected String getInfString(Ini prefs, String section, String option, Object defaultValue) {

        String s = (String) getInfValue(prefs, section, option, defaultValue);

        if (s != null && s.trim().length() < 1) {

            return null;

        }

        return s;

    }

    protected int getInfInt(Ini prefs, String section, String option, int defaultValue) {

        String s = (String) getInfValue(prefs, section, option, String.valueOf(defaultValue));

        if (s != null && s.trim().length() < 1) {

            return defaultValue;

        }

        return Integer.parseInt(s);

    }

    protected boolean getInfBoolean(Ini prefs, String section, String option, boolean defaultValue) {

        String s = (String) prefs.get(section, option);

        if( s == null ) {

            return defaultValue;

        }

        return BooleanUtils.toBoolean(s);

    }

    protected void console_println(String s) {

        logger.info(s);

    }

    public void create(ScriptingFolder folder, String id) {

        this.setParent(folder);

        this.setId(id);

        File file = new File(folder.getFile(), id + ".inf");

        try {

            file.createNewFile();

        } catch (IOException e) {

            logger.warn("Can't create inf file in '" + file.getAbsolutePath() + "'.", e);

        }

    }

    @Override

    public File getFile() {

        if (this.getId() == null) {

            return null;

        }

        if (this.getParent() == null) {

            return null;

        }

        if (this.getParent().getFile() == null) {

            return null;

        }

        return new File(getParent().getFile(), this.getId() + ".inf");

    }

    @Override

    public boolean isSaved() {

        return this.saved;

    }

    @Override

    public void setSaved(boolean saved) {

        this.saved = saved;

    }

    @Override

    public void setProperty(String name, String value) {

        if( this.properties == null ) {

            this.properties = new HashMap<>();

        }

        this.properties.put(name, value);

    }

    @Override

    public String getProperty(String name) {

        if( this.properties == null ) {

            return null;

        }

        return this.properties.get(name);

    }

    @Override

    public Map<String,String> getProperties() {

        return this.properties;

    }

    @Override

    public boolean isASystemUnit() {

        String pathUnit;

        try {

            pathUnit = this.getParent().getFile().getCanonicalPath();

        } catch (IOException ex) {

            pathUnit = this.getParent().getFile().getAbsolutePath();

        }

        if( !pathUnit.endsWith(File.separator) ) {

            pathUnit = pathUnit + File.separator;

        }

        List<File> libs = this.getManager().getLibFolders();

        for( File lib : libs ) {

            String pathLib;

            try {

                pathLib = lib.getCanonicalPath();

            } catch (IOException ex) {

                pathLib = lib.getAbsolutePath();

            }

            if( !pathLib.endsWith(File.separator) ) {

                pathLib = pathLib + File.separator;

            }

            if( pathUnit.startsWith(pathLib) ) {

                return true;

            }

        }

        return false;

    }

}