Subversion Repositories SmartDukaan

/**

 * 

 */

package in.shop2020.serving.auth;

import in.shop2020.thrift.clients.HelperClient;

import in.shop2020.utils.Agent;

import in.shop2020.utils.HelperService.Client;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.apache.shiro.authc.AuthenticationException;

import org.apache.shiro.authc.AuthenticationInfo;

import org.apache.shiro.authc.AuthenticationToken;

import org.apache.shiro.authc.SimpleAuthenticationInfo;

import org.apache.shiro.authc.UnknownAccountException;

import org.apache.shiro.authc.UsernamePasswordToken;

import org.apache.shiro.authz.AuthorizationException;

import org.apache.shiro.authz.AuthorizationInfo;

import org.apache.shiro.authz.SimpleAuthorizationInfo;

import org.apache.shiro.realm.AuthorizingRealm;

import org.apache.shiro.subject.PrincipalCollection;

import org.apache.thrift.TException;

/**

 * @author mandeep

 * 

 *         This class is realm for fetching authentication and authorization

 *         details for an agent.

 */

public class InventoryAuthorizingRealm extends AuthorizingRealm {

    private static final Log   log = LogFactory.getLog(InventoryAuthorizingRealm.class);

    private static Map<Long, Agent>   agentsMapById;

    private static Map<String, Agent> agentsMapByEmailId;

    @Override

    protected AuthorizationInfo doGetAuthorizationInfo(

            PrincipalCollection principals) {

        // null usernames are invalid

        if (principals == null) {

            throw new AuthorizationException(InventoryAuthorizingRealm.java

                    "PrincipalCollection method argument cannot be null.");

        }

        String username = (String) getAvailablePrincipal(principals);

        List<String> roleNames = null;

        Set<String> permissions = new HashSet<String>();

        try {

        	log.info("helper -- doGetAuthorizationInfo");

            Client client = new HelperClient().getClient();

            // Retrieve roles and permissions from database

            roleNames = client.getRoleNamesForAgent(username);

            for (String roleName : roleNames) {

                permissions.addAll(client

                        .getPermissionsForRoleName(roleName));

            }

        } catch (TException e) {

            throw new AuthorizationException(

                    "Error fetching roles' information", e);

        } catch (Exception e) {

            throw new AuthorizationException("Error creating Helper client", e);

        }

        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(

                new HashSet<String>(roleNames));

        info.setStringPermissions(permissions);

        log.info("Roles --- " + roleNames);

        log.info("Permissions --- " + permissions);

        return info;

    }

    @Override

    protected AuthenticationInfo doGetAuthenticationInfo(

            AuthenticationToken token) throws AuthenticationException {

        SimpleAuthenticationInfo info = null;

        try {

            UsernamePasswordToken upToken = (UsernamePasswordToken) token;

            String username = upToken.getUsername();

            log.info("Trying to fetch password for " + username);

            Agent agent = getAgent(username);

            if (agent != null) {

                info = new SimpleAuthenticationInfo(username, agent.getPassword().toCharArray(), getName());

            } else {

                throw new UnknownAccountException("No account found for user ["

                        + username + "]");

            }

        } catch (TException e) {

            log.info("Could not create Helper client", e);

        }

        return info;

    }

    public static Agent getAgent(String username) throws TException {

        if (agentsMapByEmailId == null || !agentsMapByEmailId.containsKey(username)) {

            loadAgents();

        }

        return agentsMapByEmailId.get(username);

    }

    public static Agent getAgent(long agentId) throws TException {

        if (agentsMapById == null || !agentsMapById.containsKey(agentId)) {

            loadAgents();

        }

        return agentsMapById.get(agentId);

    }

    private static void loadAgents() throws TException {

    	log.info("Loading agents");

        Client client = new HelperClient().getClient();

        List<in.shop2020.utils.Agent> agents = client.getAgents();

        Map<Long, Agent> agentsMapByIdLocal = new HashMap<Long, Agent>();

        Map<String, Agent> agentsMapByEmailIdLocal = new HashMap<String, Agent>();

        for (Agent agent : agents) {

            agentsMapByIdLocal.put(agent.getId(), agent);

            agentsMapByEmailIdLocal.put(agent.getEmailId(), agent);

        }

        synchronized(InventoryAuthorizingRealm.class) {

            agentsMapById = agentsMapByIdLocal;

            agentsMapByEmailId = agentsMapByEmailIdLocal;

        }

    }

    public static List<Agent> getAgents() {

        return new ArrayList<Agent>(agentsMapById.values());

    }

}