Application: gvSIG desktop » Library: org.gvsig.tools

package org.gvsig.tools.identitymanagement.spi;

import java.util.ArrayList;

import java.util.List;

import java.util.Objects;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOCase;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypeUtils;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.evaluator.EvaluatorException;

import org.gvsig.tools.evaluator.SimpleEvaluatorData;

import org.gvsig.tools.identitymanagement.Rule;

import org.gvsig.tools.identitymanagement.SimpleIdentity;

import org.gvsig.tools.util.GetItemByKey;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

public class GenericRule implements Rule {

    private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(GenericRule.class);

    protected String name;

    protected String description;

    protected String actionFilter;

    protected String resourceFilter;

    protected Evaluator filter;

    protected SimpleEvaluatorData filterSymbolTable;

    protected List<String> requires;

    public GenericRule(String name, String description, String actionFilter, String resourceFilter, Evaluator filter, String requires) {

        this(name, description, actionFilter, resourceFilter, filter, toList(requires));

    }

    public GenericRule(String name, String description, String actionFilter, String resourceFilter, Evaluator filter, List<String> requires) {

        this.name = name;

        this.description = description;

        this.actionFilter = actionFilter;

        if (StringUtils.isBlank(resourceFilter)) {

            this.resourceFilter = null;

        } else {

            this.resourceFilter = resourceFilter;

        }

        this.filter = filter;

        if (this.filter == null) {

            this.filterSymbolTable = null;

        } else {

            this.filterSymbolTable = new SimpleEvaluatorData();

        }

        this.requires = requires;

    }

    public GenericRule(GetItemByKey values) {

        String theName;

        String theDescription;

        String theActionFilter;

        String theResourceFilter;

        Object theFilter;

        String theRequires;

        theName = StringUtils.trimToNull(Objects.toString(values.get("Name")));

        theDescription = StringUtils.trimToNull(Objects.toString(values.get("Description")));

        theActionFilter = StringUtils.trimToNull(Objects.toString(values.get("Action")));

        theResourceFilter = StringUtils.trimToNull(Objects.toString(values.get("Resource")));

        theFilter= Objects.toString(values.get("filter"));

        theRequires = StringUtils.trimToNull(Objects.toString(values.get("Requires")));

        if (theName == null) {

            throw new IllegalArgumentException("'name' null not allowed in rule");

        }

        if (theActionFilter == null) {

            throw new IllegalArgumentException("'actionName' null not allowed in rule");

        }

        this.name = theName;

        this.description = theDescription;

        this.actionFilter = theActionFilter;

        if ( theResourceFilter==null ) {

            this.resourceFilter = null;

        } else {

            this.resourceFilter = theResourceFilter;

        }

        if( theFilter instanceof Evaluator ) {

            this.filter = (Evaluator) theFilter;

        } else if( theFilter instanceof CharSequence ) {

            this.filter = ToolsLocator.getScriptManager().createEvaluator(theFilter.toString());

        }

        if (this.filter == null) {

            this.filterSymbolTable = null;

        } else {

            this.filterSymbolTable = new SimpleEvaluatorData();

        }

        this.requires = toList(theRequires);

    }

    private static List<String> toList(String s) {

        if( StringUtils.isBlank(s) ) {

            return null;

        }

        try{

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

            String[] ss = StringUtils.split(s, ",");

            for (String s1 : ss) {

                if (StringUtils.isBlank(s1)) {

                    continue;

                }

                l.add(s1.trim().toLowerCase());

            }

            return l;

        } catch (Exception ex) {

            return null;

        }

    }

    @Override

    public String getName() {

        return this.name;

    }

    @Override

    public String getDescription() {

        return this.description;

    }

    @Override

    public boolean isAuthorized(SimpleIdentity identity, String actionName, Object resource, String resourceName) {

       if( !FilenameUtils.wildcardMatch(actionName, this.actionFilter, IOCase.INSENSITIVE) ) {

            // The rule don't apply to the action

            return true;

        }

        if (this.resourceFilter != null &&

            !FilenameUtils.wildcardMatch(resourceName, this.resourceFilter, IOCase.INSENSITIVE) ) {

            // The rule don't apply to the action+resourceName

            return true;

        }

        if (this.filter != null) {

            this.filterSymbolTable.set("rule", this);

            this.filterSymbolTable.set("identity", identity);

            this.filterSymbolTable.set("actionName", actionName);

            this.filterSymbolTable.set("resourceName", resourceName);

            this.filterSymbolTable.set("resource", resource);

            Object x = false;

            try {

                x = this.filter.evaluate(filterSymbolTable);

            } catch (EvaluatorException ex) {

                LOGGER.debug("Can't evaluate filter",ex);

            }

            if (!DataTypeUtils.toBoolean(x, false)) {

                // The rule don't apply to the action+resourceName+filter

                return true;

            }

        }

        // La regla aplica a action+resourceName+filter. asi que comprobamos

        // si el usuario tiene el rol necesario para acceder a ella.

        String identityId = identity.getID();

        for (String required : this.requires) {

            if( StringUtils.equals(required,"*") ) {

                return true;

            }

            if( required.startsWith("@") ) {

                int len = required.length();

                if( len>1 ) {

                    required = required.substring(1);

                    List<String> identityRoles = identity.getRoles();

                    if( identityRoles!=null ) {

                        for (String identityRole : identityRoles) {

                            if( FilenameUtils.wildcardMatch(identityRole, required, IOCase.INSENSITIVE) ) {

                                return true;

                            }

                        }

                    }

                }

            } else if( FilenameUtils.wildcardMatch(identityId, required, IOCase.INSENSITIVE) ) {

                return true;

            }

        }

        return false;

    }

    @Override

    public boolean accept(String actionName) {

       return FilenameUtils.wildcardMatch(actionName, this.actionFilter, IOCase.INSENSITIVE);

    }

}