Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   *
   * Copyright 2013 Red Hat, Inc. and/or its affiliates.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.picketlink.permission.internal;
 
 import java.util.Map;
 import java.util.Set;
 
 import  javax.enterprise.context.ApplicationScoped;
 import  javax.inject.Inject;
 
Manages a set of PermissionHandler instances that overall define a "policy" for how persistent resource permissions are mapped and managed.

Author(s):
Shane Bryzak
 
 @ApplicationScoped
 public class PermissionHandlerPolicy {
     private Map<Class<?>, PermissionHandlerhandlers = new ConcurrentHashMap<Class<?>, PermissionHandler>();
 
 
     @Inject
     public void create() {
         if (.isEmpty()) {
             // FIXME add back once ACL permissions are reinstated
             //registeredHandlers.add(new EntityPermissionHandler());
             .add(new ClassPermissionHandler());
         }
     }
 
     public String getGeneratedIdentifier(Object resource) {
         if (resource instanceof String) {
             return (Stringresource;
         }
 
         PermissionHandler handler = getHandlerForResource(resource);
 
         return handler != null ? handler.getGeneratedIdentifier(resource) : null;
     }
 
     public Object lookupResource(String identifierCollection<ObjectloadedResources) {
         Map<String,ObjectloadedResourceIdentifiers = loadResourceIdentifiers(loadedResources);
         if (loadedResourceIdentifiers.containsKey(identifier)) {
             return loadedResourceIdentifiers.get(identifier);
         }
         else {
             PermissionHandler handler = getHandlerForIdentifier(identifier);
             return handler != null ? handler.lookupResource(identifier) : null;
         }
     }
 
     private Map<String,ObjectloadResourceIdentifiers(Collection<Objectresources) {
         if (resources == null || resources.isEmpty()) {
             return null;
         }
 
         Map<String,Objectidentifiers = new HashMap<String,Object>();
 
         for (Object resourceresources) {
             PermissionHandler handler = getHandlerForResource(resource);
 
             if (handler != null) {
                 String identifier = handler.getGeneratedIdentifier(resource);
                 if (!identifiers.containsKey(identifier)) {
                     identifiers.put(identifierresource);
                 }
             }
         }
 
         return identifiers;
     }
 
     public Map<String,ObjectlookupResources(Collection<Stringidentifiers
             Collection<ObjectloadedResources) {
        Map<String,Objectresources = new HashMap<String,Object>();
        Map<String,ObjectloadedResourceIdentifiers = loadResourceIdentifiers(loadedResources);
        for (String identifier : identifiers) {
            if (loadedResourceIdentifiers.containsKey(identifier)) {
                resources.put(identifierloadedResourceIdentifiers.get(identifier));
            } else {
                PermissionHandler handler = getHandlerForIdentifier(identifier);
                if (handler != null) {
                    Object resource = handler.lookupResource(identifier);
                    if (resource != null) {
                        resources.put(identifierresource);
                    }
                }
           }
        }
        return resources;
    }
    public Serializable getNaturalIdentifier(Object resource) {
        PermissionHandler strategy = getHandlerForResource(resource);
        return strategy != null ? strategy.getNaturalIdentifier(resource) : null;
    }
    private PermissionHandler getHandlerForIdentifier(String identifier) {
        for (PermissionHandler handler : .values()) {
            if (handler.canLoadResource(identifier)) {
                return handler;
            }
        }
        for (PermissionHandler handler : ) {
            if (handler.canLoadResource(identifier)) {
                return handler;
            }
        }
        return null;
    }
    private PermissionHandler getHandlerForResource(Object resource) {
        PermissionHandler handler = .get(resource.getClass());
        if (handler == null) {
            if (resource.getClass().isAnnotationPresent(PermissionsHandledBy.class)) {
                Class<? extends PermissionHandlerhandlerClass =
                        resource.getClass().getAnnotation(PermissionsHandledBy.class).value();
                if (handlerClass != PermissionHandler.class) {
                    try {
                        handler = handlerClass.newInstance();
                        .put(resource.getClass(), handler);
                    }
                    catch (Exception ex) {
                        throw new RuntimeException("Error instantiating IdentifierStrategy for object " + resourceex);
                    }
                }
            }
            for (PermissionHandler s : ) {
                if (s.canHandle(resource.getClass())) {
                    handler = s;
                    .put(resource.getClass(), handler);
                    break;
                }
            }
        }
        return handler;
    }
    public Set<StringconvertResourcePermissions(Object resourceObject permissions) {
        PermissionHandler handler = getHandlerForResource(resource);
        return handler != null ? handler.convertResourcePermissions(resource.getClass(), permissions) : null;
    }
        return ;
    }
    public void setRegisteredHandlers(Set<PermissionHandlerregisteredHandlers) {
        this. = registeredHandlers;
    }
New to GrepCode? Check out our FAQ X