AMimpl test and OIDOperations class

gistfile1.java

package model;

import java.util.Map;

import java.util.logging.Level;

import model.common.AppModule;

import oracle.adf.share.logging.ADFLogger;

import oracle.jbo.JboException;
import oracle.jbo.server.ApplicationModuleImpl;

import oracle.security.idm.IMException;
import oracle.security.idm.IdentityStore;
import oracle.security.idm.ModProperty;
import oracle.security.idm.Role;
import oracle.security.idm.RoleManager;
import oracle.security.idm.User;
import oracle.security.idm.UserManager;
import oracle.security.idm.UserProfile;
// ---------------------------------------------------------------------
// ---    File generated by Oracle ADF Business Components Design Time.
// ---    Thu Nov 07 00:30:22 IST 2013
// ---    Custom code may be added to this class.
// ---    Warning: Do not modify method signatures of generated methods.
// ---------------------------------------------------------------------
public class AppModuleImpl extends ApplicationModuleImpl implements AppModule {
    
    public static final ADFLogger amLogger=ADFLogger.createADFLogger(AppModuleImpl.class);
    
    /**
     * This is the default constructor (do not remove).
     */
    public AppModuleImpl() {
    }

    /**
     * @param attributeMap
     * @return
     */
    public String createUser(Map userProperties){
        
            String methodName =
                java.lang.Thread.currentThread().getStackTrace()[1].getMethodName();
            IdentityStore store = OIDOperations.getStoreInstance();
            //user properties
            final String userId = (String)userProperties.get("userId");
            final String userName = (String)userProperties.get("userName");
            final String emailId = (String)userProperties.get("emailId");
//            final String userAddress = (String)userProperties.get("userAddress");
            final String userPassword = OIDOperations.generateRandomPassword();
            final String userMobile =(String) userProperties.get("mobileNumber");
//            final String dob = userProperties.get("dob").toString();
            
            UserManager um = null;
            User newUser = null;
            //called to drop the user if already present
         
                OIDOperations.dropUser(userId);
         
            try {
                um = store.getUserManager();
                newUser = um.createUser(userId, userPassword.toCharArray());
            } catch (IMException e) {
                amLogger.severe("[" + methodName + "]" +
                                "Could not register the vle in oid , Exception occured due to ",
                                e);

                throw new JboException("An error has occured in creating user");
            }
            try {
             
                UserProfile profile = newUser.getUserProfile();
                profile.setBusinessMobile(userMobile);
//                profile.setDateofBirth(dob);
                profile.setDisplayName(userName);
                profile.setUserID(userId);
                profile.setBusinessEmail(emailId);
//                profile.setBusinessPostalAddr(userAddress);
                
                RoleManager rm = store.getRoleManager();
                Role role =
                    store.searchRole(store.SEARCH_BY_NAME,"default");
                rm.grantRole(role, newUser.getPrincipal());
            
                if (amLogger.isLoggable(Level.INFO)) {
                    amLogger.info("[" + methodName + "] " +
                                  "Created vle in the OID with userId " + userId);
                }
            } catch (IMException e) {
                //Drop user in case of exception
                amLogger.severe("[" + methodName + "]" +
                                "Could not modify the user property in oid , Exception occured due to ",
                                e);
                amLogger.severe("[" + methodName + "]" +
                                "Now going to delete the user from oid");
                try {
                    um.dropUser(newUser);
                } catch (IMException e1) {

                    amLogger.severe("[" + methodName + "]" +
                                    "Unable to drop the user ");
                }
                throw new JboException("AN error has occured");

            }
            
            finally  {
              try{
              store.close();
                  }
                catch (IMException e) {
                amLogger.severe("Exception occured in closing store");
                }
              }
        return null;
        }

    /**
     * Container's getter for DeptVO1.
     * @return DeptVO1
     */
    public DeptVOImpl getDeptVO1() {
        return (DeptVOImpl)findViewObject("DeptVO1");
    }
}

gistfile2.java

package model;

import java.security.Principal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.logging.Level;

import oracle.adf.share.ADFContext;
import oracle.adf.share.logging.ADFLogger;
import oracle.adf.share.security.SecurityContext;
import oracle.jbo.JboException;

import oracle.security.idm.ComplexSearchFilter;
import oracle.security.idm.IMException;
import oracle.security.idm.Identity;
import oracle.security.idm.IdentityStore;
 
 
import oracle.security.idm.IdentityStoreFactory;
import oracle.security.idm.IdentityStoreFactoryBuilder;
import oracle.security.idm.ModProperty;
import oracle.security.idm.ObjectNotFoundException;
import oracle.security.idm.OperationNotSupportedException;
import oracle.security.idm.Role;
import oracle.security.idm.RoleManager;
import oracle.security.idm.RoleProfile;
import oracle.security.idm.SearchFilter;
import oracle.security.idm.SearchParameters;
import oracle.security.idm.SearchResponse;
import oracle.security.idm.SimpleSearchFilter;
import oracle.security.idm.User;
import oracle.security.idm.UserManager;
import oracle.security.idm.UserProfile;
import oracle.security.idm.providers.oid.OIDIdentityStoreFactory;
import oracle.security.idm.providers.openldap.OLdapIdentityStoreFactory;
/**
 *This class can be used to perform operation on OID using OPSS API
 * @author Ramandeep Nanda
 */
 
public class OIDOperations {
  public static final ADFLogger OIDLogger=ADFLogger.createADFLogger(OIDOperations.class);
  private static final ResourceBundle rb =
    ResourceBundle.getBundle("model.myresourcebundle");
    /**
     *
     * @return The store instance for OID store
     */
    public static IdentityStore getStoreInstance(){
        return IdentityStoreConfigurator.initializeDefaultStore();
        }
    public static IdentityStoreFactory getIdentityStoreFactory(){
        return IdentityStoreConfigurator.idStoreFactory;
        }
    /**
     * Returns the logged in User if using ADF security
     * @return The logged in User
     */
    public static String getLoggedInUser(){
          ADFContext ctxt=ADFContext.getCurrent();
          SecurityContext sctxt=ctxt.getSecurityContext();
        return   sctxt.getUserName();
        }
    
    /**
     * Assigns the specified role to the user
     * @param roleName the role to assign
     * @param userName the user to assign role to
     */
    public static void assignRoleToUser(String roleName,String userName){
       String methodName=Thread.currentThread().getStackTrace()[1].getMethodName();
      IdentityStore store=OIDOperations.getStoreInstance();
        try {
           Role role= store.searchRole(IdentityStore.SEARCH_BY_NAME,roleName);
           User user= store.searchUser(userName); 
           RoleManager rm=store.getRoleManager();
          if(!rm.isGranted(role, user.getPrincipal())){   
           rm.grantRole(role, user.getPrincipal()); 
          }
             
        } catch (IMException e) {
          OIDLogger.severe("Exception in "+methodName + "Could not assign role ["+roleName+"] to the user ["+userName +"] because of " +e.getMessage() +" ", e);
          throw new JboException("Could not assign role ["+roleName+"] to the user ["+userName +"] due to "+e.getMessage());
          
        }
        finally  {
            try{
            store.close();
                }
              catch (IMException e) {
              OIDLogger.severe("Exception occured in closing store");
              }
            }
    }
  /**
     * Assigns the specified role to the user
     * @param roleNames the roles to assign
     * @param userName the user to assign role to
     * @return the set of users who are assigned roles
     */
  public static Set assignRolesToUser(Set roleNames,String userName){
     Set rolesAssigned=new HashSet();
      
     String methodName=Thread.currentThread().getStackTrace()[1].getMethodName();
     IdentityStore store=OIDOperations.getStoreInstance();
     String roleName=null;
      try {
        User user= store.searchUser(userName); 
        Principal userPrincipal=user.getPrincipal(); 
        RoleManager rm=store.getRoleManager();
        Iterator it=roleNames.iterator();
        while(it.hasNext()){
         roleName=(String)it.next();
         Role role= store.searchRole(IdentityStore.SEARCH_BY_NAME,roleName);
          if(!rm.isGranted(role, user.getPrincipal())){   
         rm.grantRole(role,userPrincipal); 
         rolesAssigned.add(roleName);
          }
        }
      } catch (IMException e) {
           
        OIDLogger.severe("Exception in "+methodName + "Could not assign role ["+roleName+"] to the user ["+userName +"] because of " +e.getMessage() +" ", e);
        throw new JboException("Could not assign role ["+roleName+"] to the user ["+userName +"] due to "+e.getMessage());
         
         
      }
    finally  {
        try{
        store.close();
            }
          catch (IMException e) {
          OIDLogger.severe("Exception occured in closing store");
          }
        }
     
      return rolesAssigned;
  }
  /**
     * Assigns the specified role to the user
     * @param roleName the role to assign
     * @param users the users to assign role to
     * @return The users who are assigned the role
     */
  public static Set assignRoleToUsers(String roleName,Map users){
     Set usersAssigned=new HashSet();
     String methodName=Thread.currentThread().getStackTrace()[1].getMethodName();
     IdentityStore store=OIDOperations.getStoreInstance();
     
        Set entrySet = users.entrySet();
        Iterator it=entrySet.iterator();
        String userName=null;
   
      try {
         Role role= store.searchRole(IdentityStore.SEARCH_BY_NAME,roleName);
         RoleManager rm=store.getRoleManager();
        while(it.hasNext()){
          Map.Entry entry=(Map.Entry)it.next();     
          userName=(String)entry.getKey();
          User user= store.searchUser(userName); 
            if(!rm.isGranted(role, user.getPrincipal())){   
              rm.grantRole(role, user.getPrincipal()); 
              usersAssigned.add(user);
            }
        }  
      } catch (IMException e) {
        OIDLogger.severe("Exception in "+methodName + "Could not assign role ["+roleName+"] to the user ["+userName +"] because of " +e.getMessage() +" ", e);
       }
    finally  {
        try{
        store.close();
            }
          catch (IMException e) {
          OIDLogger.severe("Exception occured in closing store");
          }
        }
      return usersAssigned;
  }
 
//revoke sample below It is similar to the above mentioned assign case so mentioning a sample operation 
 
    /**
     * To remove the role from user
     * @param roleName the role to remove/ revoke
     * @param userName the user from which to revoke role
     */
    public static void removeRoleFromUser(String roleName,String userName){
          String methodName=Thread.currentThread().getStackTrace()[1].getMethodName();
          IdentityStore store=OIDOperations.getStoreInstance();
           try {
              Role role= store.searchRole(IdentityStore.SEARCH_BY_NAME,roleName);
                
              User user= store.searchUser(userName); 
              RoleManager rm=store.getRoleManager();
             if(rm.isGranted(role, user.getPrincipal())){   
              rm.revokeRole(role, user.getPrincipal()); 
             }
           } catch (IMException e) {
             OIDLogger.severe("Exception in "+methodName + "Could not revoke role ["+roleName+"] from the user ["+userName +"] because of " +e.getMessage() +" ", e);
             throw new JboException("Could not remove role ["+roleName+"] from the user ["+userName +"] due to "+e.getMessage());
              
           }
          finally  {
              try{
              store.close();
                  }
                catch (IMException e) {
                OIDLogger.severe("Exception occured in closing store");
                }
              }
        }
    public static void dropUserWithRoles(String userId){
          UserManager um = null;
          IdentityStore store=null;
          User newUser = null;
           try {
              store=OIDOperations.getStoreInstance();
              User user = store.searchUser(IdentityStore.SEARCH_BY_NAME, userId);
              um=store.getUserManager();
              if (user != null) {
                  //drop user if already present
                  um.dropUser(user);
                  RoleManager rm = store.getRoleManager();
                  Principal userPrincipal= user.getPrincipal();
                  SearchResponse resp=rm.getGrantedRoles(userPrincipal, true);
                  while(resp.hasNext()){
                  rm.revokeRole((Role)resp.next(), user.getPrincipal());
                  }
                }
          }
          catch (IMException e) {
              OIDLogger.info("[dropUser]" +
                             
                            e);
 
          }
          finally  {
              try{
              store.close();
                  }
                catch (IMException e) {
                OIDLogger.severe("Exception occured in closing store");
                }
              }
        }
  public static void dropUser(String userId){
        UserManager um = null;
        User newUser = null;
        IdentityStore store=null;
 
        try {
           store =OIDOperations.getStoreInstance();
            User user = store.searchUser(IdentityStore.SEARCH_BY_NAME, userId);
            um=store.getUserManager();
            if (user != null) {
                //drop user if already present
                um.dropUser(user);
              }
        }
        catch (IMException e) {
            OIDLogger.info("[dropUser]" +
                          e);
 
        }
        finally  {
            try{
            store.close();
                }
              catch (IMException e) {
              OIDLogger.severe("Exception occured in closing store");
              }
            }
      }
 
    /**
     * Gets the userProfile of the logged in user if using ADF security
     * @param approverUser
     * @return
     */
    public static oracle.security.idm.UserProfile getUserProfile(String approverUser) {
      IdentityStore store=OIDOperations.getStoreInstance();
       oracle.security.idm.UserProfile profile=null;
        try {
           User user= store.searchUser(approverUser);
           profile=user.getUserProfile();
             
        } catch (IMException e) {
            OIDLogger.info("Could not find user in OID with supplied Id"+approverUser);
          throw new JboException(e.getMessage());
        }
      finally  {
          try{
          store.close();
              }
            catch (IMException e) {
            OIDLogger.severe("Exception occured in closing store");
            }
          }
        return profile;
    }
    /**
     * Gets all the roles 
     * @return
     */
    public static List getAllRoles(){
          String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
          List returnList=new ArrayList();
          IdentityStore store=OIDOperations.getStoreInstance();
 
          try{
             SimpleSearchFilter filter=store.getSimpleSearchFilter(RoleProfile.NAME,SimpleSearchFilter.TYPE_EQUAL,null);
             String wildCardChar=filter.getWildCardChar();
            // Here the default_role is a property this is just a placeholder can be  any pattern you want to search
            filter.setValue(wildCardChar+rb.getString("DEFAULT_ROLE")+wildCardChar);
                       SearchParameters parameters=new SearchParameters(filter,SearchParameters.SEARCH_ROLES_ONLY) ;
             SearchResponse resp=store.searchRoles(Role.SCOPE_ANY,parameters);
             while(resp.hasNext()){
                 Role role=(Role)resp.next();
                           String tempRole=role.getPrincipal().getName();
                           returnList.add(tempRole);
                          }
             store.close();  
           }catch(IMException e){
                 OIDLogger.severe("Exception in "+methodName + " " +e.getMessage() +" ", e);
                 throw new JboException(e.getMessage());
                 }
          finally  {
              try{
              store.close();
                  }
                catch (IMException e) {
                OIDLogger.severe("Exception occured in closing store");
                }
              }
             
           return returnList;
        }
    /**
     * Fetches all the roles assigned to the user
     * @param userName
     * @return
     */
    public static List getAllUserRoles(String userName, String searchPath) {
      String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
      List returnList=new ArrayList();
      IdentityStoreFactory storeFactory = OIDOperations.getIdentityStoreFactory();
      IdentityStore store=null;
      String[] userSearchBases=   {rb.getString(searchPath)};    
      String[] groupSearchBases=     {rb.getString("group.search.bases")};  
      Hashtable storeEnv=new Hashtable();
      storeEnv.put(OLdapIdentityStoreFactory.ADF_IM_SUBSCRIBER_NAME,rb.getString("oidsubscribername"));
      storeEnv.put(OLdapIdentityStoreFactory.RT_USER_SEARCH_BASES,userSearchBases);
      storeEnv.put(OLdapIdentityStoreFactory.RT_GROUP_SEARCH_BASES,groupSearchBases);
      
       try{
          store = storeFactory.getIdentityStoreInstance(storeEnv);
          User user= store.searchUser(IdentityStore.SEARCH_BY_NAME,userName);
          RoleManager mgr=store.getRoleManager();
          SearchResponse resp= mgr.getGrantedRoles(user.getPrincipal(), false);
           while(resp.hasNext()){
              String name= resp.next().getName();
              returnList.add(name);
               }
     
        }catch(IMException e){
              OIDLogger.severe("Exception in "+methodName + " " +e.getMessage() +" ", e);
              throw new JboException(e.getMessage());
              }
      finally  {
          try{
          store.close();
              }
            catch (IMException e) {
            OIDLogger.severe("Exception occured in closing store");
            }
          }
          
        return returnList;
    }
 
 /**
*Use to change the passoword for logged in user It uses ADF Security Context to get logged in user
*
**/
  public static void changePasswordForUser(String oldPassword,String newPassword, String userName){
        String methodName =
            java.lang.Thread.currentThread().getStackTrace()[1].getMethodName();
        SecurityContext securityContext =
            ADFContext.getCurrent().getSecurityContext();
        String user = securityContext.getUserName();
      IdentityStore oidStore=null;
         oidStore= OIDOperations.getStoreInstance();
        try {
            UserManager uMgr = oidStore.getUserManager();
            User authUser =
                uMgr.authenticateUser(user, oldPassword.toCharArray());
 
            if (authUser != null) {
                UserProfile profile = authUser.getUserProfile();
 
                profile.setPassword( oldPassword.toCharArray(),
                                    newPassword.toCharArray());
              }
        } catch (IMException e) {
            if (OIDLogger.isLoggable(Level.SEVERE)) {
                OIDLogger.severe("[" + methodName +
                                "]  Exception occured due to " + e.getCause(),
                                e);
            }
            throw new JboException(e.getMessage());
        }
      finally  {
          try{
          oidStore.close();
              }
            catch (IMException e) {
            OIDLogger.severe("Exception occured in closing store");
            }
          }
 
 
}
    /**
     * It is used to generate a random password
     *@code{
     * generateRandomPassword();
     * }
     * @return
     */
    public static String generateRandomPassword() {
        String password =
            Long.toHexString(Double.doubleToLongBits(Math.random()));
        int passLength = password.length();
        if (passLength >= 8) {
            password = password.substring(passLength - 8, passLength);
        }

        return password;
    }

/**
* Resets the password for user 
*
**/
public static void resetPasswordForUser(String userId)
{
        String methodName =
            java.lang.Thread.currentThread().getStackTrace()[1].getMethodName();
        IdentityStore oidStore = OIDOperations.getStoreInstance();
        User user = null;
        try {
            user = oidStore.searchUser(userId);
            if (user != null) {
                UserProfile userProfile = user.getUserProfile();
                List passwordValues =
                    userProfile.getProperty("userpassword").getValues();
             ModProperty prop =
                    new ModProperty("PASSWORD", passwordValues.get(0),
                                    ModProperty.REMOVE);
                userProfile.setProperty(prop);
                String randomPassword = generateRandomPassword();
                userProfile.setPassword(null, randomPassword.toCharArray());
            }
        } catch (IMException e) {
            OIDLogger.severe("[" + methodName + "]" +
                            "Exception occured due to ", e);
          
        }
      finally  {
          try{
          oidStore.close();
              }
            catch (IMException e) {
            OIDLogger.severe("Exception occured in closing store");
            }
          }
 
}
 
 
    /**
     * This nested private class is used for configuring and initializing a store instance
     * @author Ramandeep Nanda
     */
  private static final class IdentityStoreConfigurator {
                              private static final IdentityStoreFactory idStoreFactory=initializeFactory();
                            
   
                             private static IdentityStoreFactory initializeFactory(){
                                       String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
                                       IdentityStoreFactoryBuilder builder = new
                                       IdentityStoreFactoryBuilder();
                                       IdentityStoreFactory oidFactory = null;
                                             try {
                                       Hashtable factEnv = new Hashtable();
                                       factEnv.put(OLdapIdentityStoreFactory.ST_SECURITY_PRINCIPAL,rb.getString("oidusername"));
                                       factEnv.put(OLdapIdentityStoreFactory.ST_SECURITY_CREDENTIALS, rb.getString("oiduserpassword"));
                                       factEnv.put(OLdapIdentityStoreFactory.ST_SUBSCRIBER_NAME,rb.getString("oidsubscribername"));
                                       factEnv.put(OLdapIdentityStoreFactory.ST_LDAP_URL,rb.getString("ldap.url"));
                                       factEnv.put(OLdapIdentityStoreFactory.ST_USER_NAME_ATTR,rb.getString("username.attr"));       
                                       oidFactory = builder.getIdentityStoreFactory("oracle.security.idm.providers.openldap.OLdapIdentityStoreFactory", factEnv);
                                          }
                                       catch (IMException e) { 
                                               OIDLogger.severe("Exception in "+methodName + " " +e.getMessage() +" ", e);
                                     //re throw exception here
                                       }
                                      return oidFactory;       
                                     }    
                             private static  IdentityStore initializeDefaultStore(){
                                       IdentityStore store=null;
                                       String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
                                       String[] userSearchBases=   {rb.getString("user.search.bases")};    
                                       String[] groupCreateBases=     {rb.getString("group.search.bases")};  
                                       String []usercreate={rb.getString("user.create.bases")};
                                       String [] groupClass={rb.getString("GROUP_CLASSES")};
                                       Hashtable storeEnv=new Hashtable();
                                       storeEnv.put(OLdapIdentityStoreFactory.ADF_IM_SUBSCRIBER_NAME,rb.getString("oidsubscribername"));
                                       storeEnv.put(OLdapIdentityStoreFactory.RT_USER_SEARCH_BASES,userSearchBases);
                                       storeEnv.put(OLdapIdentityStoreFactory.RT_GROUP_SEARCH_BASES,groupCreateBases);
                                       storeEnv.put(OLdapIdentityStoreFactory.RT_USER_CREATE_BASES,usercreate);
                                       storeEnv.put(OLdapIdentityStoreFactory.RT_USER_SELECTED_CREATEBASE,rb.getString("user.create.bases"));
                                       storeEnv.put(OLdapIdentityStoreFactory.RT_GROUP_OBJECT_CLASSES,groupClass); 
                                       try{
                                       store = model.OIDOperations.IdentityStoreConfigurator.idStoreFactory.getIdentityStoreInstance(storeEnv);
                                       }  
                               catch (IMException e) { 
                                       OIDLogger.severe("Exception in "+methodName + " " +e.getMessage() +" ", e);
                                     // re throw exception here
                 
            }
          return  store;
 
        }
                              
 
}
}