Application: gvSIG desktop » gvSIG scripting

package org.gvsig.scripting.impl;

import java.io.File;

import java.io.IOException;

import java.net.URI;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import javax.script.ScriptContext;

import javax.script.ScriptEngine;

import javax.script.ScriptEngineFactory;

import javax.script.ScriptEngineManager;

import javax.script.SimpleBindings;

import javax.swing.ImageIcon;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.scripting.DataFolderFound;

import org.gvsig.scripting.ScriptingBaseScript;

import org.gvsig.scripting.ScriptingDialog;

import org.gvsig.scripting.ScriptingExternalFile;

import org.gvsig.scripting.ScriptingFolder;

import org.gvsig.scripting.ScriptingManager;

import org.gvsig.scripting.ScriptingScript;

import org.gvsig.scripting.ScriptingUnit;

import org.gvsig.tools.packageutils.Version;

import org.gvsig.tools.resourcesstorage.FilesResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.script.Script;

import org.gvsig.tools.service.spi.ProviderFactory;

import org.gvsig.tools.util.FolderSet;

import org.python.jsr223.MyPyScriptEngine;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class DefaultScriptingManager implements ScriptingManager {

    public static class RegisterSystemFolder {

        public String name;

        public File folder;

        public RegisterSystemFolder(String name, File folder) {

            this.name = name;

            this.folder = folder;

        }

    }

    static final Logger LOG = LoggerFactory

            .getLogger(DefaultScriptingManager.class);

    protected Map<String, ImageIcon> icons;

    protected List<RegisterSystemFolder> systemFolders = new ArrayList<>();

    protected ScriptEngineManager engineManager = null;

    private final SimpleBindings bindings = new SimpleBindings();

    private List<String> unitTypes = null;

    private ClassLoader classLoader = null;

    private final List<File> libFolders = new ArrayList<>();

    private File home = null;

    private final List<ScriptingFolder> alternativeUserFolders = new ArrayList<>();

    private Map<String, String> extensionOfLanguage = null;

    private Map<String, String> languageOfExtension = null;

    private File packagesFolder;

    private final Map properties = new HashMap();

    private final Map<String,ScriptEngine> engineGroups = new HashMap<>();

    private DataFolderManager dataFolderManager = null;

    private ScriptingFolder userFolder = null;

    private ScriptingFolder systemFolder = null;

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

    public DefaultScriptingManager() {

        this.classLoader = getClass().getClassLoader();

        this.setHomeFolder(null);

        this.bindings.put("ScriptingManager", this);

    }

    public DefaultScriptingManager(ClassLoader classLoader) {

        this();

        this.classLoader = classLoader;

    }

    @Override

    public Object getProperty(Object key) {

        return properties.get(key);

    }

    @Override

    public void setProperty(Object key, Object val) {

        properties.put(key, val);

    }

    @Override

    public Map getExtendedProperties() {

        return properties;

    }

    private void createFolder(File f) {

        if (!f.exists()) {

            try {

                FileUtils.forceMkdir(f);

                LOG.info("Created scripting folder '" + f.getAbsolutePath() + "'");

            } catch (Throwable e) {

                LOG.warn("Can't Create scripting folder '" + f.getAbsolutePath() + "'");

            }

        }

    }

    private void createDefaultFolders(File home) {

        createFolder(new File(home, "scripts"));

        createFolder(new File(home, "lib"));

        createFolder(new File(home, "data"));

    }

    @Override

    public File getHomeFolder() {

        if (!this.home.exists()) {

            createFolder(home);

            createDefaultFolders(home);

        }

        return this.home;

    }

    @Override

    public void setHomeFolder(File home) {

        if (home == null) {

            this.home = new File(System.getProperty("user.home"), ".gvsig-scripting");

        } else {

            this.home = home;

        }

        createDefaultFolders(this.home);

        LOG.info("Set scripting home to '" + this.home.getAbsolutePath() + "'");

        this.addLibFolder(new File(this.home, "lib"));

        FilesResourcesStorage resourcesStorage = new FilesResourcesStorage(this.home.getAbsolutePath());

        ExpressionEvaluatorManager expressionManager = ExpressionEvaluatorLocator.getManager();

        expressionManager.setScriptsResourcesStorage(resourcesStorage);

    }

    private DataFolderManager getDataFolderManager() {

        if( this.dataFolderManager==null ) {

            this.dataFolderManager = new DataFolderManager(this);

        }

        return this.dataFolderManager;

    }

    @Override

    public File getDataFolder(String id) {

        return this.getDataFolderManager().getDataFolder(id);

    }

    public void registerDataFolder(ScriptingFolder folderScript, String id ) {

        this.getDataFolderManager().registerDataFolder(folderScript, id);

    }

    @Override

    public List<DataFolderFound> searchOldVersions(Version currentVersion, FolderSet folder) {

        return this.getDataFolderManager().searchOldVersions(currentVersion, folder);

    }

    protected synchronized ScriptEngineManager getEngineManager() {

        if (this.engineManager == null) {

            this.engineManager

                    = classLoader == null ? new ScriptEngineManager()

                            : new ScriptEngineManager(classLoader);

            showEnginesInfo(engineManager);

        }

        return this.engineManager;

    }

    private void showEnginesInfo(ScriptEngineManager mgr) {

        if (LOG.isInfoEnabled()) {

            List<ScriptEngineFactory> factories = mgr.getEngineFactories();

            StringBuilder buffer = new StringBuilder();

            List<Object> values = new ArrayList<>();

            buffer.append("Scripting engines available:");

            for (ScriptEngineFactory factory : factories) {

                // Main engine info

                buffer

                        .append("\n- {}: version = {}, language = {}, langVersion = {}");

                values.add(factory.getEngineName());

                values.add(factory.getEngineVersion());

                values.add(factory.getLanguageName());

                values.add(factory.getLanguageVersion());

                // Aliases

                buffer.append("\n\t- Aliases: ");

                List<String> engNames = factory.getNames();

                int size = engNames.size();

                for (String name : engNames) {

                    size--;

                    buffer.append("{}");

                    if (size > 0) {

                        buffer.append(", ");

                    }

                    values.add(name);

                }

                buffer.append("\n\t- File extensions: ");

                List<String> extNames = factory.getExtensions();

                size = extNames.size();

                for (String name : extNames) {

                    size--;

                    buffer.append("{}");

                    if (size > 0) {

                        buffer.append(", ");

                    }

                    values.add(name);

                }

                buffer.append("\n\t- Mime types: ");

                List<String> mimeNames = factory.getMimeTypes();

                size = mimeNames.size();

                for (String name : mimeNames) {

                    size--;

                    buffer.append("{}");

                    if (size > 0) {

                        buffer.append(", ");

                    }

                    values.add(name);

                }

            }

            LOG.info(buffer.toString(), values.toArray());

        }

    }

    @Override

    public synchronized void loadEngines() {

        this.getEngineManager();

    }

    private ScriptEngine createJythonEngine() {

        ScriptEngineFactory factory = this.getEngineFactoryByLanguage(PYTHON_LANGUAGE_NAME);

        ScriptEngine engine = new MyPyScriptEngine(factory);

        return engine;

    }

    public ImageIcon getIcon(String name) {

        return this.icons.get(name);

    }

    @Override

    public String getEngineNameByLanguage(String langName) {

        ScriptEngineFactory factory = this.getEngineFactoryByLanguage(langName);

        if( factory == null ) {

            return null;

        }

        return factory.getEngineName();

    }

    public ScriptEngine getEngineByLanguage(String langName) {

        return this.getEngineByLanguage(langName, null);

    }

    public synchronized ScriptEngine getEngineByLanguage(String langName, String isolationGroup) {

        ScriptEngine engine = null;

        if( !StringUtils.isEmpty(isolationGroup) ) {

            isolationGroup += "-" + langName;

            engine = this.engineGroups.get(isolationGroup.toLowerCase());

        } 

        if( engine == null ) {

            if( PYTHON_LANGUAGE_NAME.equalsIgnoreCase(langName) ) {

                engine = createJythonEngine();

            } else {

                ScriptEngineFactory factory = this.getEngineFactoryByLanguage(langName);

                if( factory == null ) {

                    return null;

                }

                engine = factory.getScriptEngine();

            }

//            if( SCALA_LANGUAGE_NAME.equalsIgnoreCase(langName) ) {

//                try {

//                    // https://gist.github.com/takawitter/5479445

//                    Object settings = engine.getClass().getMethod("settings", new Class[0]).invoke(engine, new Object[0]);

//                    settings.getClass().getMethod("processArgumentString", new Class[] { String.class }).invoke(settings, new String[] { "-usejavacp"});

//                } catch(Throwable th) {

//                    LOG.warn("Can't initialice scala setting -usejavacp",th);

//                }

//            }            

            if( !StringUtils.isEmpty(isolationGroup) ) {

                this.engineGroups.put(isolationGroup.toLowerCase(), engine);

            }

        }

        engine.getBindings(ScriptContext.ENGINE_SCOPE).putAll(bindings);

        return engine;

    }

    @Override

    public synchronized Set<String> getEnginesIsolationGroups() {

        return this.engineGroups.keySet();

    }

    public ScriptEngineFactory getEngineFactoryByLanguage(String langName) {

        List<ScriptEngineFactory> factories

                = getEngineManager().getEngineFactories();

        for (ScriptEngineFactory factory : factories) {

            if (factory.getLanguageName().equalsIgnoreCase(langName)) {

                return factory;

            }

        }

        return null;

    }

    @Override

    public boolean validateUnitId(ScriptingFolder folder, String id) {

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

        return !f.exists();

    }

    public ScriptingScript createScript(ScriptingFolder folder, String id) {

        return this.createScript(folder, id, null);

    }

    @Override

    public Script createScript(String name, String code, String languaje) {

        ScriptingScript script = new DefaultScriptingScript(this.getUserFolder(), this, name, languaje);

        script.setCode(code);

        script.setSaved(true);

        return script;        

    }

    private ScriptingScript createScript(ScriptingFolder folder, String id, String language) {

        DefaultScriptingScript script = new DefaultScriptingScript(folder, this, id);

        if (!script.getFile().exists()) {

            script.create(folder, id, language);

        } else {

            script.load(folder, id);

        }

        return script;

    }

    public ScriptingDialog createDialog(ScriptingFolder folder, String id) {

        return this.createDialog(folder, id, null);

    }

    private ScriptingDialog createDialog(ScriptingFolder folder, String id, String language) {

        DefaultScriptingDialog dialog = new DefaultScriptingDialog(folder, this, id);

        if (!dialog.getFile().exists()) {

            dialog.create(folder, id, language);

        } else {

            dialog.load(folder, id);

        }

        return dialog;

    }

    public ScriptingFolder createFolder(ScriptingFolder folder, String id) {

        DefaultScriptingFolder unit = new DefaultScriptingFolder(folder, this, new File(folder.getFile(), id));

        unit.load(folder, id);

        if (!unit.getFile().exists()) {

            unit.create(folder, id);

        }

        return unit;

    }

    public ScriptingExternalFile createExternalFile(ScriptingFolder folder, String id) {

        DefaultScriptingExternalFile unit = new DefaultScriptingExternalFile(folder, this, id);

        if( unit.getExternalFile()!=null && !unit.getExternalFile().exists() ) {

            unit.create(folder, id);

        }

        return unit;

    }

    @Override

    public ScriptingBaseScript getScript(File file) {

        ScriptingBaseScript script = (ScriptingBaseScript) this.getUnit(file);

        if (script == null) {

            throw new ScriptNotFoundException(file);

        }

        return script;

    }

    @Override

    public Script loadScript(URI uri) {

        File f = new File(uri);

        try {

            return (Script) this.getScript(f);

        } catch(ScriptNotFoundException ex) {

            throw ex;

        } catch(Throwable th) {

            throw new ScriptNotFoundException(f);

        }

    }

    private static final Pattern RE_LANG = Pattern.compile(".*lang[:]\\s*([a-zA-Z_][a-zA-Z_0-9]*)");

    private static final Pattern RE_ENCODING = Pattern.compile(".*encoding[:]\\s*([a-zA-Z_][a-zA-Z_0-9]*)");

    public Script loadScript(ResourcesStorage storage, String name) {

        ResourcesStorage.Resource res = null;

        try {

            if( storage==null ) {

                return null;

            }

            res = storage.getResource(name);

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

                return null;

            }

            byte[] head_bytes = new byte[500];

            IOUtils.read(res.asInputStream(), head_bytes);

            IOUtils.closeQuietly(res);

            String head = new String(head_bytes);

            if( StringUtils.isEmpty(head) ) {

                return null;

            }

            head = head.split("\n")[0];

            String lang = "python";

            String encoding = null;

            Matcher m = RE_LANG.matcher(head);

            if( m.groupCount()==1 ) {

                String s = m.group(1);

                if( !StringUtils.isBlank(s) ) {

                    lang = s;

                }

            }

            m = RE_ENCODING.matcher(head);

            if( m.groupCount()==1 ) {

                String s = m.group(1);

                if( !StringUtils.isBlank(s) ) {

                    encoding = s;

                }

            }

            String source;

            if( StringUtils.isBlank(encoding) ) {

                source = IOUtils.toString(res.asInputStream());

            } else {

                source = IOUtils.toString(res.asInputStream(), encoding);

            }

            Script script = this.createScript(name, source, lang);

            return script;

        } catch (Exception ex) {

            LOG.warn("Can't load script from resources storage.", ex);

            return null;

        } finally {

            IOUtils.closeQuietly(res);

        }

    }

    @Override

    public ScriptingFolder getFolder(File file) {

        if( file == null ) {

            throw new IllegalArgumentException("file argument can't be null");

        }

        file = this.getLinkSource(file);

        if( FileUtils.isSameFile(this.getRootUserFolder(),file) ) {

            return this.getUserFolder();

        }

        ScriptingFolder folder = (ScriptingFolder) this.getUnit(file);

        if (folder == null) {

            throw new IllegalArgumentException("Can't get ScriptFolder from '"+file.getAbsolutePath()+"'.");

        }

        return folder;

    }

    public ScriptingUnit getUnit(String pathName) {

        ScriptingUnit unit = null;

        String[] parts = StringUtils.split(pathName, '/');

        if( parts[0].equals(this.getUserFolder().getName()) ) {

            unit = this.getUserFolder().getUnit( 

                    StringUtils.join(parts, "/", 1, parts.length) 

            );

        } else if( parts[0].equals(this.getSystemFolder().getName()) ) {

            unit = this.getSystemFolder().getUnit( 

                    StringUtils.join(parts, "/", 1, parts.length) 

            );

        } 

        return unit;

    }

    public ScriptingUnit getUnit(File file) {

        ScriptingFolder folder;

        ScriptingUnit unit;

        if (file.isAbsolute()) {

            if( FileUtils.isSameFile(this.getRootUserFolder(), file.getParentFile()) ) {

                folder = this.getUserFolder();

                // FIXME: que pasa si esta en SystemFolder ???

            } else {

                folder = new DefaultScriptingFolder(null, this, file.getParentFile());

            }

            unit = folder.getUnit(file);

            return unit;

        } else {

            folder = this.getUserFolder();

            unit = folder.getUnit(file);

            if (unit != null) {

                return unit;

            }

            folder = this.getSystemFolder();

            unit = folder.getUnit(file);

            if (unit != null) {

                return unit;

            }

        }

        return null;

    }

    @Override

    public ScriptingFolder getSystemFolder() {

        if( this.systemFolder == null ) {

            this.systemFolder = new SystemFolder(this);

        }

        return  this.systemFolder;

    }

    @Override

    public ScriptingFolder getUserFolder() {

        if( this.userFolder == null ) {

            this.userFolder = new UserFolder(this, this.getRootUserFolder());

        }

        return  this.userFolder;

    }

    @Override

    public ScriptingBaseScript getScript(String name) {

        return (ScriptingBaseScript) findScript(null, name);

    }

    @Override

    public Script locateScript(String name) {

        ScriptingUnit script = findScript(null, name);

        if( script instanceof Script ) {

            return (Script) script;

        }

        return null;

    }

    private ScriptingUnit findScript(ScriptingFolder folder, String name) {

        if (name == null) {

            return null;

        }

        if (name.trim().length() == 0) {

            return null;

        }

        ScriptingUnit unit;

        if (folder == null) {

            unit = findScript(this.getUserFolder(), name);

            if (unit != null) {

                return unit;

            }

            unit = findScript(this.getSystemFolder(), name);

            return unit;

        }

        List<ScriptingUnit> units = folder.getUnits();

        Iterator<ScriptingUnit> it = units.iterator();

        while (it.hasNext()) {

            unit = it.next();

            if (unit instanceof ScriptingFolder) {

                unit = findScript((ScriptingFolder) unit, name);

                if (unit != null) {

                    return unit;

                }

            } else if (unit instanceof ScriptingBaseScript) {

                if (name.equalsIgnoreCase(unit.getId())) {

                    return unit;

                }

            }

        }

        return null;

    }

    @Override

    public File getRootUserFolder() {

        return new File(this.getHomeFolder(), "scripts");

    }

    @Override

    public void registerSystemFolder(String name, File folder) {

        this.systemFolders.add(new RegisterSystemFolder(name, folder));

        LOG.info("Register system folder name '" + name + "' folder " + folder.getAbsolutePath() + "'");

    }

    public List<RegisterSystemFolder> getSystemFolders() {

        return this.systemFolders;

    }

    @Override

    public List<ScriptingFolder> getAlternativeUserFolders() {

        return this.alternativeUserFolders;

    }

    @Override

    public void addAlternativeUserFolder(File f, String name, String description) {

        UserFolder x = new UserFolder(this, f);

        x.setName(name);

        x.setDescription(description);

        x.setId("UserFolder_" + this.alternativeUserFolders.size() + 1);

        this.alternativeUserFolders.add(x);

    }

    private void initLanguages() {

        if (this.extensionOfLanguage == null) {

            Map<String, String> theExtensionOfLanguage = new HashMap<>();

            List<ScriptEngineFactory> factories = getEngineManager().getEngineFactories();

            for (ScriptEngineFactory factory : factories) {

                if( "ognl".equals(factory.getLanguageName()) ) {

                    continue;

                }

                List<String> extensions = factory.getExtensions();

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

                    theExtensionOfLanguage.put(

                            factory.getLanguageName().toLowerCase(),

                            extensions.get(0).toLowerCase()

                    );

                }

            }

            this.extensionOfLanguage = theExtensionOfLanguage;

        }

        if (this.languageOfExtension == null) {

            Map<String, String> theLanguageOfExtension = new HashMap<>();

            List<ScriptEngineFactory> factories = getEngineManager().getEngineFactories();

            for (ScriptEngineFactory factory : factories) {

                if( "ognl".equals(factory.getLanguageName()) ) {

                    continue;

                }

                List<String> extensions = factory.getExtensions();

                if (extensions != null) {

                    for (String extension1 : extensions) {

                        theLanguageOfExtension.put(

                                extension1.toLowerCase(),

                                factory.getLanguageName().toLowerCase()

                        );

                    }

                }

            }

            this.languageOfExtension = theLanguageOfExtension;

        }

    }

    @Override

    public String getExtensionOfLanguage(String langName) {

        if (langName == null) {

            return null;

        }

        langName = langName.toLowerCase();

        initLanguages();

        return this.extensionOfLanguage.get(langName);

    }

    @Override

    public List<String> getSupportedLanguages() {

        List<String> languages = new ArrayList<>();

        initLanguages();

        languages.addAll(this.extensionOfLanguage.keySet());

        Collections.sort(languages);

        return languages;

    }

    public String getLanguageOfExtension(String extension) {

        if (extension == null) {

            return null;

        }

        extension = extension.toLowerCase();

        if (extension.startsWith(".")) {

            extension = extension.substring(1);

        }

        initLanguages();

        return this.languageOfExtension.get(extension);

    }

    @Override

    public Object get(String key) {

        return this.bindings.get(key);

    }

    @Override

    public void put(String key, Object value) {

        this.bindings.put(key, value);

    }

    @Override

    public ScriptingUnit createUnit(String unitType, ScriptingFolder folder, String id) {

        return createUnit(unitType, folder, id, null);

    }

    @Override

    public ScriptingUnit createUnit(String unitType, ScriptingFolder folder, String id, String language) {

        if (unitType.equals(UNIT_SCRIPT)) {

            return this.createScript(folder, id, language);

        }

        if (unitType.equals(UNIT_DIALOG)) {

            return this.createDialog(folder, id, language);

        }

        if (unitType.equals(UNIT_FOLDER)) {

            return this.createFolder(folder, id);

        }

        if (unitType.equals(UNIT_EXTERNALFILE)) {

            return this.createExternalFile(folder, id);

        }

        return null;

    }

    @Override

    public List<String> getUnitTypes() {

        if (this.unitTypes == null) {

            this.unitTypes = new ArrayList<>();

            this.unitTypes.add(UNIT_SCRIPT);

            this.unitTypes.add(UNIT_DIALOG);

            this.unitTypes.add(UNIT_FOLDER);

            this.unitTypes.add(UNIT_EXTERNALFILE);

        }

        return this.unitTypes;

    }

    @Override

    public void addLibFolder(File lib) {

        if (lib.exists()) {

            LOG.info("Add scripting lib folder '" + lib.getAbsolutePath() + "'");

            this.libFolders.add(lib);

        } else {

            LOG.info("Skip add scripting lib folder '" + lib.getAbsolutePath() + "', folder don't exist");

        }

    }

    @Override

    public List<File> getLibFolders() {

        return new ArrayList(this.libFolders);

    }

    @Override

    public Map<String, String> getLibFoldersVersions() {

        Map<String, String>versions = new HashMap<>();

        List<File> folders = this.getLibFolders();

        for (File folder : folders) {

            File parent = folder.getParentFile();

            File libVersions = new File(parent,folder.getName()+".versions");

            if( libVersions.exists() ) {

                this.loadLibVersions(versions, libVersions);

            }

        }

        if( versions.isEmpty() ) {

            return null;

        }

        return versions;

    }

    private void loadLibVersions(Map<String,String>versions, File file) {

        List<String> lines;

        try {

            lines = FileUtils.readLines(file);

        } catch (IOException ex) {

            LOG.warn("Can't load lib versions from '"+file+".",ex);

            return;

        }

        for (String line : lines) {

            String[] x = line.split("=");

            if( x.length==2 ) {

                versions.put(x[0], x[1]);

            } 

        }

    }

    @Override

    public ProviderFactory getInstallerFactory() {

        return new ScriptingInstallerProviderFactory();

    }

    @Override

    public File getPackagesFolder() {

        return this.packagesFolder;

    }

    @Override

    public void setPackagesFolder(File folder) {

        this.packagesFolder = folder;

    }

    @Override

    public ScriptingFolder createLink(String name, File link, String targetPathName) {

        StringBuilder contents = new StringBuilder();        

        contents.append("[Unit]\n")

            .append("type = Folder\n")

            .append("name = ").append(name).append("\n")

            .append("description =\n")

            .append("createdBy =\n")

            .append("version =\n")

            .append("\n")

            .append("[Folder]\n")

            .append("path =").append(targetPathName).append("\n")

            .append("\n\n");

        if( link.isDirectory() ) {

            link = new File(link,name+".inf");

        } else if( !link.getName().endsWith(".inf") ) {

            link = new File( link.getPath() + ".inf");

        }

        if( !link.exists() ) {

            try {

                FileUtils.writeStringToFile(link, contents.toString());

            } catch (IOException ex) {

                LOG.warn("Can't create ScriptingFolder file in '" + link.getAbsolutePath() + "'.", ex);

            }

        }

        ScriptingFolder folder = this.getFolder(link);

        return folder;

    }

    @Override

    public ScriptingFolder createLink(String name, ScriptingFolder link, String targetPathName) {

        return this.createLink(name, link.getFile(), targetPathName);

    }

    private final Map<File,File> links = new HashMap<>();

    public void addLink(File source, File target) {    

        this.links.put(FileUtils.getRealFile(target), source);

    }

    public File getLinkSource(File target) {

        File source = this.links.get(FileUtils.getRealFile(target));

        if( source == null ) {

            return target;

        }

        if( source.exists() ) {

            return source;

        }

        return target;

    }

    public boolean isInUserFolder(File f) {

        if( FileUtils.isSubfolder(this.getRootUserFolder(), f) ) {

            return true;

        }

        for( File file : this.links.keySet()) {

            if( FileUtils.isSubfolder(file, f) ) {

                return true;

            }

        }

        return false;

    }

}