EDIT

/**

* Copyright (C) 2009 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

import java.io.Serializable;

import java.lang.reflect.InvocationTargetException;

import org.springframework.security.core.GrantedAuthority;

import eu.etaxonomy.cdm.model.common.CdmBase;

/**

 * @author k.luther

    public AccessDecisionManager getAccessDecisionManager() {

        return accessDecisionManager;

    }

    }

        this.accessDecisionManager = accessDecisionManager;

    }

            Serializable targetId, String targetType, Object permission) {

        return false;

    }

        if(targetDomainObject instanceof CdmBase){

            cdmEntitiyStates = new TargetEntityStates((CdmBase)targetDomainObject);

        } else {

            cdmEntitiyStates = (TargetEntityStates)targetDomainObject;

        }

        } catch (IllegalArgumentException e) {

            logger.debug("permission string '"+ permission.toString() + "' not parsable => true");

    }

    /**

     * @param authentication

     * @param targetDomainObject

     * @param requiredOperation

     * @return

     */

    @Override

        return hasPermission(authentication, new TargetEntityStates(targetEntity), requiredOperation);

    }

    /**

     * @param authentication

     * @param targetDomainObject

     * @param requiredOperation

     * @return

     */

    @Override

    public boolean hasPermission(Authentication authentication, TargetEntityStates targetEntityStates, EnumSet<CRUD> requiredOperation) {

        if(authentication == null) {

            return false;

        }

    @Override

    public <T extends CdmBase> boolean hasPermission(Authentication authentication, Class<T> targetDomainObjectClass,

            EnumSet<CRUD> requiredOperations) {

        if(authentication == null) {

            return false;

        }

        if(logger.isDebugEnabled()){

            String targteDomainObjClassText = "  Cdm-Type: " + targetDomainObjectClass.getSimpleName();

            logUserAndRequirement(authentication, requiredOperations.toString(), targteDomainObjClassText);

        }

        CdmAuthority evalPermission = new CdmAuthority(CdmPermissionClass.getValueOf(targetDomainObjectClass), null, requiredOperations, null);

        T instance;

        try {

            Constructor<T> c = targetDomainObjectClass.getDeclaredConstructor();

            c.setAccessible(true);

            instance = c.newInstance();

        } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {

            logger.error("Error while creating permission test instance ==> will deny", e);

            return false;

        }

    /**

     * @param authentication

     * @param permission

     * @param targteDomainObjText

     */

    protected void logUserAndRequirement(Authentication authentication, String permissions, String targteDomainObjText) {

        StringBuilder grantedAuthoritiesTxt = new StringBuilder();

        for(GrantedAuthority ga : authentication.getAuthorities()){

            grantedAuthoritiesTxt.append("    - ").append(ga.getAuthority()).append("\n");

        }

        if(grantedAuthoritiesTxt.length() == 0){

            grantedAuthoritiesTxt.append("    - ").append("<No GrantedAuthority given>").append("\n");

        }

        logger.debug("hasPermission()\n"

                + "  User '" + authentication.getName() + "':\n"

                + grantedAuthoritiesTxt

                + targteDomainObjText + "\n"

                + "  Permission: " + permissions);

    }

    /**

     * @param permission

     * @return

     */

    protected EnumSet<CRUD> operationFrom(Object permission) {

        EnumSet<CRUD> requiredOperation;

        // FIXME refactor into Operation ======

        if (Operation.isOperation(permission)){

            requiredOperation = (EnumSet<CRUD>)permission;

        } else {

            // try to treat as string

            requiredOperation = Operation.fromString(permission.toString());

        }

        // =======================================

        return requiredOperation;

    }

     * @param targetEntity

     * @param requiredOperation

     * @return

     */

    private CdmAuthority authorityRequiredFor(CdmBase targetEntity, EnumSet<CRUD> requiredOperation) {

    }

     * @param authorities

     * @param evalPermission

     * @param targetDomainObject

     * @return

     */

            return true;

        }

        Collection<ConfigAttribute> attributes = new HashSet<ConfigAttribute>();

        attributes.add(evalPermission);

            logger.debug("AccessDecisionManager denied by " + e, e);

            return false;

        } catch (AccessDeniedException e) {

            logger.debug("AccessDecisionManager denied by " + e, e);

            return false;

        }

     * @param authentication

     */

        for (GrantedAuthority authority: authentication.getAuthorities()){

            for(Role role : roles){

                         logger.debug(role.getAuthority() + " found => true");

                     }

                     return true;

                 }

            }

         }

        return false;

    }