diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000..7b016a8
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,3 @@
+{
+    "java.compile.nullAnalysis.mode": "automatic"
+}
\ No newline at end of file
diff --git a/src/main/java/UsernameGenerator.java b/src/main/java/UsernameGenerator.java
index 7198936..6a0fccf 100644
--- a/src/main/java/UsernameGenerator.java
+++ b/src/main/java/UsernameGenerator.java
@@ -17,6 +17,7 @@ public class UsernameGenerator {
     int MAX_USERNAME_LENGTH = 12;
 
 
+    @SuppressWarnings("null")
     public String generateUsername(String firstName, String lastName) throws GeneralException {
         firstName = StringUtils.trimToNull(firstName);
         lastName = StringUtils.trimToNull(lastName);
@@ -46,7 +47,7 @@ public String generateUsername(String firstName, String lastName) throws General
         String username = null;
         String fullName = firstName + "." + lastName;
 
-        if(fullName.length() > MAX_USERNAME_LENGTH) {
+        if(fullName.length() > MAX_USERNAME_LENGTH && fullName!=null) {
             int firstNameLength = firstName.length();
 
             if(firstNameLength > (MAX_USERNAME_LENGTH - 2)) {
diff --git a/src/main/resources/rules/Rule - AttribueGenerator - GenerateUniqueDN.xml b/src/main/resources/rules/Rule - AttribueGenerator - GenerateUniqueDN.xml
new file mode 100644
index 0000000..0eb4d0c
--- /dev/null
+++ b/src/main/resources/rules/Rule - AttribueGenerator - GenerateUniqueDN.xml	
@@ -0,0 +1,127 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!DOCTYPE Rule PUBLIC "sailpoint.dtd" "sailpoint.dtd">
+<Rule name="GenerateUniqueDN" type="AttributeGenerator">
+    <Description>Generate a unique email address for Active Directory.</Description>
+    <Source><![CDATA[
+
+import sailpoint.object.Identity;
+import sailpoint.object.Attributes;
+import sailpoint.tools.GeneralException;
+import sailpoint.object.AttributeDefinition;
+import sailpoint.api.SailPointContext;
+import org.apache.commons.lang.StringUtils;
+import sailpoint.tools.Util;
+
+
+
+public String getAccountName(int option, String firstName, String lastName, String middleName) {
+	String firstInit = StringUtils.substring(firstName, 0, 1);
+	String lastInit = StringUtils.substring(lastName, 0, 1);
+	String middleInit = null;
+	boolean hasMiddleName = false;
+	if (Util.isNotNullOrEmpty(middleName)) {
+	  middleInit = StringUtils.substring(middleName, 0, 1);
+	  hasMiddleName = true;
+	}
+	switch (option) {
+	case 1:
+	  return firstName + lastName;
+	case 2:
+	  if (hasMiddleName) {
+		return firstName + middleInit + lastName;
+	  }
+	  return null;
+	case 3:
+	  return firstInit + lastName;
+	case 4:
+	  if (hasMiddleName) {
+		return firstInit + middleInit + lastName;
+	  }
+	  return null;
+	case 5:
+	  return firstName + lastInit;
+	case 6:
+	  if (hasMiddleName) {
+		return firstName + middleInit + lastInit;
+	  }
+	  return null;
+	default:
+	  if (accountIteration < firstName.length() && accountIteration <= 50) {
+		accountIteration = accountIteration + 1;
+		String addInit = StringUtils.substring(firstName, 0, accountIteration);
+		return addInit + lastName;
+	  }
+	  accountIteration = accountIteration + 1;
+	  return firstInit + lastName + (accountIteration - firstName.length());
+	}
+}
+
+public String formatString(String value) {
+    value = StringUtils.trimToNull(value);
+	if (Util.isNotNullOrEmpty(value)) {
+	  value = value.replaceAll(\"\\\\W\", \"\").replaceAll(\"\\\\'\", \"\").toLowerCase().replaceAll(\"[^a-zA-Z0-9]\", \"\");
+	}
+	return value;
+}
+
+public boolean isUnique(Identity identity, String username) {
+    String sourceId = ""; 
+    String attributeName = "displayName"; 
+    String attributeValue = formatString(username);
+
+ 
+    return identity.isUniqueAttributeValue(sourceId, attributeName, attributeValue);
+}
+
+
+public String generateUniqueDN(SailPointContext context, Identity identity) throws GeneralException {
+    String firstName = (String) identity.getAttribute("firstName");
+    String lastName = (String) identity.getAttribute("lastName");
+    String middleName = (String) identity.getAttribute("middleName");
+    String displayName = (String) identity.getAttribute("displayName");
+	String UserOU = (String) identity.getAttribute("ou");
+
+    String uniqueDN = null;
+
+    if (Util.isNullOrEmpty(displayName)) {
+        displayName = getAccountName(1, firstName, lastName, middleName);
+    } else {
+        displayName = formatString(displayName);
+    }
+	boolean uniqueNameFound = false;
+    if (isUnique(identity, displayName)) {
+        uniqueDN = "CN=" + displayName + UserOU; 
+		uniqueNameFound = true;
+    } 
+	if(!uniqueNameFound){
+        int option = 1;
+        while (option <= 6) {
+            String username = getAccountName(option, firstName, lastName, middleName);
+            if (username != null && isUnique(identity, username)) {
+                uniqueDN = "CN=" + username + UserOU; 
+				uniqueNameFound = true; 
+                break;
+            }
+            option++;
+        }
+    }
+	if(!uniqueNameFound)
+	{
+		int accountIteration = 1;
+        while (accountIteration <= 50) {
+            String username = getAccountName(1, firstName, lastName, middleName) + accountIteration;
+            if (username != null && isUnique(identity, username)) {
+                uniqueDN = "CN=" + username + UserOU; 
+				uniqueNameFound = true; 
+                break;
+            }
+            accountIteration++;
+        }
+	}
+
+    return uniqueDN;
+}
+
+return generateUniqueDN(context, identity);
+]]></Source>
+</Rule>
diff --git a/src/main/resources/rules/Rule - AttributeGenerator - EmailGenerator.xml b/src/main/resources/rules/Rule - AttributeGenerator - EmailGenerator.xml
new file mode 100644
index 0000000..7adee0e
--- /dev/null
+++ b/src/main/resources/rules/Rule - AttributeGenerator - EmailGenerator.xml	
@@ -0,0 +1,190 @@
+<Rule name="EmailGenerator" type="AttributeGenerator">
+    <Description>Generate a unique email address for Active Directory.</Description>
+    <Source><![CDATA[
+import sailpoint.tools.GeneralException;
+import sailpoint.object.Identity;
+import sailpoint.object.Application;
+import sailpoint.object.ProvisioningPlan.AccountRequest;
+import sailpoint.object.ProvisioningPlan.AccountRequest.Operation;
+import sailpoint.object.ProvisioningPlan.AttributeRequest;
+import sailpoint.object.ProvisioningPlan;
+import sailpoint.object.ProvisioningPlan.Operation;
+import java.util.Random;
+import org.apache.commons.lang.StringUtils;
+import java.util.List;
+import java.util.ArrayList;
+import sailpoint.tools.Util;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+log.info("EMAIL GENERATOR RULE AD || 1: Entering the RULE - EmailGenerator");
+
+String companyID = identity.getAttribute("companyId");
+log.info("EMAIL GENERATOR RULE AD || 3: Retrieved COMPANY_ID is: " + companyID);
+
+// Check for empty company ID, first name, or last name and throw an exception
+if (Util.isNullOrEmpty(companyID)) {
+    String errorMessage = "EMAIL GENERATOR RULE AD || 4: Company ID is empty. Throwing exception.";
+    log.error(errorMessage);
+    throw new GeneralException(errorMessage);
+}
+
+String firstName = identity.getFirstname();
+String lastName = identity.getLastname();
+String isAssociate = identity.getAttribute("isAssociate");
+
+// Check if first name or last name is empty and throw an exception
+if (Util.isNullOrEmpty(firstName)) {
+    String errorMessage = "EMAIL GENERATOR RULE AD || 5: First name is empty. Throwing exception.";
+    log.error(errorMessage);
+    throw new GeneralException(errorMessage);
+}
+if (Util.isNullOrEmpty(lastName)) {
+    String errorMessage = "EMAIL GENERATOR RULE AD || 6: Last name is empty. Throwing exception.";
+    log.error(errorMessage);
+    throw new GeneralException(errorMessage);
+}
+
+/**
+ * Method to retrieve the email domain based on the company ID.
+ */
+public static String getDomainByCompanyID(String companyID) {
+    log.info("EMAIL GENERATOR RULE AD || 7: Entering getDomainByCompanyID method with companyID: " + companyID);
+
+    // Initialize the map with CompanyID and Email Domain pairs
+    Map companyDomains = new HashMap();
+    companyDomains.put("98", "jmfamily.com");
+    companyDomains.put("10", "jmfamily.com");
+    companyDomains.put("100", "jmfamily.com");
+    companyDomains.put("101", "jmfamily.com");
+    companyDomains.put("160", "jmfamilyholdings.com");
+    companyDomains.put("200", "setoyota.com");
+    companyDomains.put("250", "setoyota.com");
+    companyDomains.put("290", "setoyota.com");
+    companyDomains.put("300", "jmagroup.com");
+    companyDomains.put("301", "jmagroup.com");
+    companyDomains.put("303", "jmagroup.com");
+    companyDomains.put("305", "jmagroup.com");
+    companyDomains.put("307", "jmagroup.com");
+    companyDomains.put("400", "setf.com");
+    companyDomains.put("40011", "wofco.com");
+    companyDomains.put("40013", "ctrone.com");
+    companyDomains.put("40014", "yatc.org");
+    companyDomains.put("40015", "centurywarranty.com");
+    companyDomains.put("40016", "fiasolutions.com");
+    companyDomains.put("40017", "dsfs.ca");
+    companyDomains.put("40018", "mmsa.com");
+    companyDomains.put("40019", "jmcustomcreations.com");
+    companyDomains.put("40020", "dsfs.com");
+    companyDomains.put("421", "onedatascan.com");
+    companyDomains.put("422", "onedatascan.com");
+    companyDomains.put("424", "onedatascan.ca");
+    companyDomains.put("464", "onedatascan.com");
+    companyDomains.put("470", "onedatascan.com");
+    companyDomains.put("495", "onedatascan.ca");
+    companyDomains.put("700", "jmlexus.com");
+    companyDomains.put("997", "bellsouth.net");
+
+    // Return the domain for the given CompanyID, or a message if not found
+    String domain = companyDomains.getOrDefault(companyID, "Domain Not Found For Specific company ID");
+    log.info("EMAIL GENERATOR RULE AD || 8: Exiting getDomainByCompanyID method with domain: " + domain);
+    return domain;
+}
+
+log.info("EMAIL GENERATOR RULE AD || 9: Retrieved domain: " + getDomainByCompanyID(companyID));
+
+/**
+ * Method to check if the generated email is unique.
+ */
+public boolean isUnique(String email, String identityId, String applicationName, String attributeName) throws GeneralException {
+    log.info("EMAIL GENERATOR RULE AD || 10: Entering isUnique method with email: " + email);
+
+    try {
+        boolean isUnique = idn.isUniqueLDAPValue(identityId, applicationName, attributeName, email);
+        log.info("EMAIL GENERATOR RULE AD || 11: Exiting isUnique method with result: " + isUnique);
+        return isUnique;
+    } catch (Exception e) {
+        log.error("EMAIL GENERATOR RULE AD || 12: Error in isUnique method: " + e.getMessage());
+        throw new GeneralException("Error in isUnique method", e);
+    }
+}
+
+/**
+ * Method to generate a valid and unique email address.
+ */
+public String generateEmail() throws GeneralException {
+
+    log.info("EMAIL GENERATOR RULE AD || 13: Entering generateEmail method");
+
+    String firstName = identity.getFirstname();
+    String lastName = identity.getLastname();
+    String companyId = identity.getAttribute("companyId");
+    String isAssociate = identity.getAttribute("isAssociate");
+
+    if (Util.isNullOrEmpty(firstName) || Util.isNullOrEmpty(lastName)) {
+        String errorMessage = "EMAIL GENERATOR RULE AD || 14: First name or last name is empty.";
+        log.error(errorMessage);
+        throw new GeneralException(errorMessage);
+    }
+
+    log.info("EMAIL GENERATOR RULE AD || 15: First name: " + firstName + ", Last name: " + lastName);
+
+    try {
+        String domain = getDomainByCompanyID(companyId);
+        if(domain.equalsIgnoreCase("Domain Not Found For Specific company ID")){
+            String errorMessage = "EMAIL GENERATOR RULE AD || 16: Invalid company ID, domain not found.";
+            log.error(errorMessage);
+            throw new GeneralException(errorMessage);
+        }
+        
+        // Determine the base email structure
+        String baseEmail = firstName + "." + lastName;
+        if ("N".equalsIgnoreCase(isAssociate)) {
+            baseEmail += "_contractor"; // Add _contractor suffix for associates
+        }
+
+        String generatedEmail = baseEmail + "@" + domain;
+        log.info("EMAIL GENERATOR RULE AD || 17: Generated email: " + generatedEmail);
+
+        // Check if the generated email is unique
+        if (isUnique(generatedEmail, identity.getId(), application.getName(), "mail")) {
+            log.info("EMAIL GENERATOR RULE AD || 18: Exiting generateEmail method with result: " + generatedEmail.toLowerCase());
+            return generatedEmail.toLowerCase();
+        } else {
+            log.warn("EMAIL GENERATOR RULE AD || 19: Generated email is not unique. Adding iteration.");
+        }
+
+        // Fallback logic with iteration for both isAssociate == "N" and not "N"
+        int iteration = 1;
+        while (iteration < 100) {
+            String emailWithIteration = firstName + "." + lastName + iteration;
+            if ("N".equalsIgnoreCase(isAssociate)) {
+                emailWithIteration += "_contractor"; // Add _contractor suffix for associates
+            }
+            emailWithIteration += "@" + domain;
+
+            if (isUnique(emailWithIteration, identity.getId(), application.getName(), "mail")) {
+                log.info("EMAIL GENERATOR RULE AD || 20: Exiting generateEmail method with result: " + emailWithIteration.toLowerCase());
+                return emailWithIteration.toLowerCase();
+            }
+            iteration++;
+        }
+
+        String errorMessage = "EMAIL GENERATOR RULE AD || 21: Cannot generate email after 100 attempts";
+        log.error(errorMessage);
+        throw new GeneralException(errorMessage);
+
+    } catch (Exception e) {
+        String errorMessage = "EMAIL GENERATOR RULE AD || 22: Error in generateEmail method: " + e.getMessage();
+        log.error(errorMessage);
+        throw new GeneralException(errorMessage, e);
+    }
+}
+
+log.info("EMAIL GENERATOR RULE AD || 23: Exiting EmailGenerator rule");
+
+return generateEmail();
+
+]]></Source>
+</Rule>
diff --git a/src/main/resources/rules/Rule - AttributeGenerator - UsernameGenerator.xml b/src/main/resources/rules/Rule - AttributeGenerator - UsernameGenerator.xml
index 5b10ce0..049a938 100644
--- a/src/main/resources/rules/Rule - AttributeGenerator - UsernameGenerator.xml	
+++ b/src/main/resources/rules/Rule - AttributeGenerator - UsernameGenerator.xml	
@@ -1,95 +1,182 @@
 <?xml version='1.0' encoding='UTF-8'?>
 <!DOCTYPE Rule PUBLIC "sailpoint.dtd" "sailpoint.dtd">
-<Rule name="UsernameGenerator" type="AttributeGenerator">
-    <Description>Generate a unique username for Active Directory.</Description>
+<Rule name="EmailGenerator" type="AttributeGenerator">
+    <Description>Generate a unique email address for Active Directory.</Description>
     <Source><![CDATA[
+import sailpoint.tools.GeneralException;
+import sailpoint.object.Identity;
+import sailpoint.object.Application;
+import sailpoint.object.ProvisioningPlan.AccountRequest;
+import sailpoint.object.ProvisioningPlan.AccountRequest.Operation;
+import sailpoint.object.ProvisioningPlan.AttributeRequest;
+import sailpoint.object.ProvisioningPlan;
+import sailpoint.object.ProvisioningPlan.Operation;
+import java.util.Random;
+import org.apache.commons.lang.StringUtils;
+import java.util.List;
+import java.util.ArrayList;
+import sailpoint.tools.Util;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
 
-    import sailpoint.tools.GeneralException;
-    import sailpoint.object.*;
-    import java.util.ArrayList;
-    import sailpoint.api.*;
-    import java.util.List;
-    import org.apache.commons.lang.StringUtils;
-    import java.text.Normalizer;
+log.info("EMAIL GENERATOR RULE AD || 1: Entering the RULE - EmailGenerator");
 
-    int MAX_USERNAME_LENGTH = 12;
+String ntId = identity.getAttribute("networkId");
+log.info("EMAIL GENERATOR RULE AD || 2: Retrieved NETWORK_ID is: " + ntId);
 
-    public String generateUsername(String firstName, String lastName) throws GeneralException {
-        firstName = StringUtils.trimToNull(firstName);
-        lastName = StringUtils.trimToNull(lastName);
+String companyID = identity.getAttribute("companyId");
+log.info("EMAIL GENERATOR RULE AD || 3: Retrieved COMPANY_ID is: " + companyID);
 
-        if(firstName != null) {
-            firstName = (Normalizer.normalize(firstName, Normalizer.Form.NFD).replaceAll("\\p{InCombiningDiacriticalMarks}+", ""));
-            firstName = firstName.replaceAll("[^a-zA-Z0-9]", "");
-        }
+/**
+ * Method to retrieve the email domain based on the company ID.
+ * It maps a given company ID to a corresponding domain. If no match is found, 
+ * a default message is returned.
+ * 
+ * @param companyID The company ID for which the domain needs to be retrieved.
+ * @return The corresponding domain for the company ID.
+ */
+public static String getDomainByCompanyID(int companyID) {
+    log.info("EMAIL GENERATOR RULE AD || 4: Entering getDomainByCompanyID method with companyID: " + companyID);
 
-        if(lastName != null) {
-            lastName = (Normalizer.normalize(lastName, Normalizer.Form.NFD).replaceAll("\\p{InCombiningDiacriticalMarks}+", ""));
-            lastName = lastName.replaceAll("[^a-zA-Z0-9]", "");
-        }
+    // Initialize the map with CompanyID and Email Domain pairs
+    Map<Integer, String> companyDomains = new HashMap<>();
+    companyDomains.put(98, "jmfamily.com");
+    companyDomains.put(10, "jmfamily.com");
+    companyDomains.put(100, "jmfamily.com");
+    companyDomains.put(101, "jmfamily.com");
+    companyDomains.put(160, "jmfamilyholdings.com");
+    companyDomains.put(200, "setoyota.com");
+    companyDomains.put(250, "setoyota.com");
+    companyDomains.put(290, "setoyota.com");
+    companyDomains.put(300, "jmagroup.com");
+    companyDomains.put(301, "jmagroup.com");
+    companyDomains.put(303, "jmagroup.com");
+    companyDomains.put(305, "jmagroup.com");
+    companyDomains.put(307, "jmagroup.com");
+    companyDomains.put(400, "setf.com");
+    companyDomains.put(40011, "wofco.com");
+    companyDomains.put(40013, "ctrone.com");
+    companyDomains.put(40014, "yatc.org");
+    companyDomains.put(40015, "centurywarranty.com");
+    companyDomains.put(40016, "fiasolutions.com");
+    companyDomains.put(40017, "dsfs.ca");
+    companyDomains.put(40018, "mmsa.com");
+    companyDomains.put(40019, "jmcustomcreations.com");
+    companyDomains.put(40020, "dsfs.com");
+    companyDomains.put(421, "onedatascan.com");
+    companyDomains.put(422, "onedatascan.com");
+    companyDomains.put(424, "onedatascan.ca");
+    companyDomains.put(464, "onedatascan.com");
+    companyDomains.put(470, "onedatascan.com");
+    companyDomains.put(495, "onedatascan.ca");
+    companyDomains.put(700, "jmlexus.com");
+    companyDomains.put(997, "bellsouth.net");
 
-        if((firstName == null) || (lastName == null)) {
-            log.debug( "AD Create User Name | Exit from generateUsername method. No last name and first name for user" );
-            return null;
-        }
+    // Return the domain for the given CompanyID, or a message if not found
+    String domain = companyDomains.getOrDefault(companyID, "CompanyID not found!");
+    log.info("EMAIL GENERATOR RULE AD || 5: Exiting getDomainByCompanyID method with domain: " + domain);
+    return domain;
+}
 
-        String username = null;
-        String fullName = firstName + "." + lastName;
+log.info("EMAIL GENERATOR RULE AD || 6: COMPANY ID IS: " + getDomainByCompanyID(identity.getAttribute("companyId")));
 
-        if(fullName.length() > MAX_USERNAME_LENGTH) {
-            int firstNameLength = firstName.length();
+/**
+ * Method to check if the generated email is unique.
+ * It validates if the generated email already exists in LDAP for the given identity and application.
+ * 
+ * @param email The generated email to check for uniqueness.
+ * @param identityId The identity ID of the user.
+ * @param applicationName The name of the application.
+ * @param attributeName The LDAP attribute name to check.
+ * @return true if the email is unique, false otherwise.
+ * @throws GeneralException If there is an error during the check.
+ */
+public boolean isUnique(String email, String identityId, String applicationName, String attributeName) throws GeneralException {
+    log.info("EMAIL GENERATOR RULE AD || 7: Entering isUnique method with email: " + email);
 
-            if(firstNameLength > (MAX_USERNAME_LENGTH - 2)) {
-                for(int lastNameLength = 0; lastNameLength < lastName.length(); lastNameLength++) {
-                    username = firstName.substring(0, (MAX_USERNAME_LENGTH - 2)) + "." + lastName.charAt(lastNameLength);
-                    username = username.toLowerCase();
-                    if (isUnique(username)) {
-                        log.debug( "AD Create User Name | Unique username generated: " + username);
-                        log.debug( "AD Create User Name | Exit from the  GenerateUsername Method" );
-                        return username;
-                    }
-                }
-            } else {
-                for(int lastNameLength = 0; lastNameLength < lastName.length(); lastNameLength++) {
-                    username = firstName + "." + lastName.charAt(lastNameLength);
-                    username = username.toLowerCase();
-                    if (isUnique(username)) {
-                        log.debug( "AD Create User Name | Unique username generated: " + username);
-                        log.debug( "AD Create User Name | Exit from the  GenerateUsername Method" );
-                        return username;
+    try {
+        boolean isUnique = idn.isUniqueLDAPValue(identityId, applicationName, attributeName, email);
+        log.info("EMAIL GENERATOR RULE AD || 8: Exiting isUnique method with result: " + isUnique);
+        return isUnique;
+    } catch (Exception e) {
+        log.error("EMAIL GENERATOR RULE AD || 9: Error in isUnique method: " + e.getMessage());
+        throw new GeneralException("Error in isUnique method", e);
+    }
+}
+
+/**
+ * Method to generate a valid and unique email address for the user based on their first name, 
+ * last name, and company ID.
+ * It first tries to generate a basic email and check its uniqueness. If the email is not unique, 
+ * it appends a number to create a unique version.
+ * 
+ * @param firstName The first name of the user.
+ * @param lastName The last name of the user.
+ * @param companyId The company ID of the user to generate domain.
+ * @return The generated unique email address.
+ * @throws GeneralException If the email cannot be generated after 100 attempts.
+ */
+public String generateEmail() throws GeneralException {
+    
+    String firstName = identity.getFirstname();
+    String lastName = identity.getLastname();
+    String companyId = identity.getAttribute("companyId");
+
+    log.info("EMAIL GENERATOR RULE AD || 10: Entering generateEmail method with firstName: " + firstName + ", lastName: " + lastName + ", companyId: " + companyId);
+
+    try {
+        String domain = getDomainByCompanyID(Integer.parseInt(companyId));
+        String generatedEmail = firstName + "." + lastName + "@" + domain;
+        String applicationName = application.getName();
+        String identityId = identity.getId();
+        String attributeName = "mail";
+        String[] sourceIdsArray = {"de15dbc4e37b4e4abdd0a56e54d1376c"}; 
+        List sourceIds = Arrays.asList(sourceIdsArray);
+        String[] valuesArray = {generatedEmail};
+        List values = Arrays.asList(valuesArray);
+        String operation = "Create";
+        String workdayAttributeName = "promotedEmailId";
+
+        log.info("EMAIL GENERATOR RULE AD || 11: Generated email is: " + generatedEmail);
+
+        if (Util.isNotNullOrEmpty(firstName) && Util.isNotNullOrEmpty(lastName) && Util.isNotNullOrEmpty(domain)) {
+            if (Util.isNotNullOrEmpty(applicationName) && Util.isNotNullOrEmpty(identityId) && Util.isNotNullOrEmpty(attributeName)) {
+                if (generatedEmail != null && !generatedEmail.isEmpty()) {
+                    if (isUnique(generatedEmail, identityId, applicationName, attributeName)) {
+                        String workdayAttributeValue = "";
+                        workdayAttributeValue = idn.attrSearchGetIdentityName(sourceIds, workdayAttributeName, operation, values);
+                        log.info("EMAIL GENERATOR RULE AD || 12: Exiting generateEmail method with result: " + generatedEmail.toLowerCase());
+                        return generatedEmail.toLowerCase();
+                    } else {
+                        log.warn("EMAIL GENERATOR RULE AD || 13: Generated email is not unique, proceeding to fallback logic.");
                     }
                 }
             }
-        } else {
-            username = fullName;
-            username = username.toLowerCase();
-            if (isUnique(username)) {
-                log.debug( "AD Create User Name | Unique username generated: " + username);
-                log.debug( "AD Create User Name | Exit from the  GenerateUsername Method" );
-                return username;
-            } else {
-                for(int lastNameLength = 0; lastNameLength < lastName.length(); lastNameLength++) {
-                    username = firstName + "." + lastName.charAt(lastNameLength);
-                    username = username.toLowerCase();
-                    if (isUnique(username)) {
-                        log.debug( "AD Create User Name | Unique username generated: " + username);
-                        log.debug( "AD Create User Name | Exit from the  GenerateUsername Method" );
-                        return username;
-                    }
+
+            // Fallback logic to add iteration number to email
+            int iteration = 1;
+            while (iteration < 100) {
+                String emailWithIteration = firstName + "." + lastName + iteration + "@" + domain;
+                String[] emailIdtArray = {emailWithIteration};
+                List emailIdvalue = Arrays.asList(emailIdtArray);
+                if (isUnique(emailWithIteration, identityId, applicationName, attributeName)) {
+                    String workdayAttributeValue = "";
+                    workdayAttributeValue = idn.attrSearchGetIdentityName(sourceIds, workdayAttributeName, operation, emailIdvalue);
+                    log.info("EMAIL GENERATOR RULE AD || 14: Exiting generateEmail method with result (generated with iteration): " + emailWithIteration.toLowerCase());
+                    return emailWithIteration.toLowerCase();
                 }
+                iteration++;
             }
         }
-
-
-
-        return null;
-    }
-
-    public boolean isUnique(String username) throws GeneralException {
-        return !idn.accountExistsByDisplayName(application.getName(), username);
+        throw new GeneralException("EMAIL GENERATOR RULE AD || 15: Cannot generate email after 100 attempts");
+    } catch (Exception e) {
+        log.error("EMAIL GENERATOR RULE AD || 16: Error in generateEmail method: " + e.getMessage());
+        throw new GeneralException("Error in generateEmail method", e);
     }
+}
 
-    return generateUsername(identity.getFirstname(), identity.getLastname());
-
-  ]]></Source>
-</Rule>
\ No newline at end of file
+log.info("EMAIL GENERATOR RULE AD || 17: Exiting EmailGenerator rule - Generated email: " + generateEmail());
+return generateEmail();
+]]></Source>
+</Rule>
diff --git a/src/main/resources/rules/Rule - AttributeGenerator - sAMAccountNameGenerator b/src/main/resources/rules/Rule - AttributeGenerator - sAMAccountNameGenerator
new file mode 100644
index 0000000..b2e4a96
--- /dev/null
+++ b/src/main/resources/rules/Rule - AttributeGenerator - sAMAccountNameGenerator	
@@ -0,0 +1,185 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!DOCTYPE Rule PUBLIC "sailpoint.dtd" "sailpoint.dtd">
+<Rule name="EmailGenerator" type="AttributeGenerator">
+    <Description>Generate a unique email address for Active Directory.</Description>
+    <Source><![CDATA[
+
+import sailpoint.tools.GeneralException;
+import sailpoint.object.Identity;
+import sailpoint.object.Application;
+import sailpoint.object.ProvisioningPlan.AccountRequest;
+import sailpoint.object.ProvisioningPlan.AccountRequest.Operation;
+import sailpoint.object.ProvisioningPlan.AttributeRequest;
+import sailpoint.object.ProvisioningPlan;
+import sailpoint.object.ProvisioningPlan.Operation;
+import java.util.Random;
+import org.apache.commons.lang.StringUtils;
+import java.util.List;
+import java.util.ArrayList;
+import sailpoint.tools.Util;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+log.info("EMAIL GENERATOR RULE AD || 1: Entering the RULE - EmailGenerator");
+
+String companyID = identity.getAttribute("companyId");
+log.info("EMAIL GENERATOR RULE AD || 3: Retrieved COMPANY_ID is: " + companyID);
+
+/**
+ * Method to retrieve the email domain based on the company ID.
+ * It maps a given company ID to a corresponding domain. If no match is found, 
+ * a default message is returned.
+ * 
+ * @param companyID The company ID for which the domain needs to be retrieved.
+ * @return The corresponding domain for the company ID.
+ */
+public static String getDomainByCompanyID(String companyID) {
+    log.info("EMAIL GENERATOR RULE AD || 4: Entering getDomainByCompanyID method with companyID: " + companyID);
+
+    // Initialize the map with CompanyID and Email Domain pairs
+    Map companyDomains = new HashMap();
+    companyDomains.put("98", "jmfamily.com");
+    companyDomains.put("10", "jmfamily.com");
+    companyDomains.put("100", "jmfamily.com");
+    companyDomains.put("101", "jmfamily.com");
+    companyDomains.put("160", "jmfamilyholdings.com");
+    companyDomains.put("200", "setoyota.com");
+    companyDomains.put("250", "setoyota.com");
+    companyDomains.put("290", "setoyota.com");
+    companyDomains.put("300", "jmagroup.com");
+    companyDomains.put("301", "jmagroup.com");
+    companyDomains.put("303", "jmagroup.com");
+    companyDomains.put("305", "jmagroup.com");
+    companyDomains.put("307", "jmagroup.com");
+    companyDomains.put("400", "setf.com");
+    companyDomains.put("40011", "wofco.com");
+    companyDomains.put("40013", "ctrone.com");
+    companyDomains.put("40014", "yatc.org");
+    companyDomains.put("40015", "centurywarranty.com");
+    companyDomains.put("40016", "fiasolutions.com");
+    companyDomains.put("40017", "dsfs.ca");
+    companyDomains.put("40018", "mmsa.com");
+    companyDomains.put("40019", "jmcustomcreations.com");
+    companyDomains.put("40020", "dsfs.com");
+    companyDomains.put("421", "onedatascan.com");
+    companyDomains.put("422", "onedatascan.com");
+    companyDomains.put("424", "onedatascan.ca");
+    companyDomains.put("464", "onedatascan.com");
+    companyDomains.put("470", "onedatascan.com");
+    companyDomains.put("495", "onedatascan.ca");
+    companyDomains.put("700", "jmlexus.com");
+    companyDomains.put("997", "bellsouth.net");
+
+    // Return the domain for the given CompanyID, or a message if not found
+    String domain = companyDomains.getOrDefault(companyID, "CompanyID not found!");
+    log.info("EMAIL GENERATOR RULE AD || 5: Exiting getDomainByCompanyID method with domain: " + domain);
+    return domain;
+}
+
+log.info("EMAIL GENERATOR RULE AD || 6: COMPANY ID IS: " + getDomainByCompanyID(companyID));
+
+/**
+ * Method to check if the generated email is unique.
+ * It validates if the generated email already exists in LDAP for the given identity and application.
+ * 
+ * @param email The generated email to check for uniqueness.
+ * @param identityId The identity ID of the user.
+ * @param applicationName The name of the application.
+ * @param attributeName The LDAP attribute name to check.
+ * @return true if the email is unique, false otherwise.
+ * @throws GeneralException If there is an error during the check.
+ */
+public boolean isUnique(String email, String identityId, String applicationName, String attributeName) throws GeneralException {
+    log.info("EMAIL GENERATOR RULE AD || 7: Entering isUnique method with email: " + email);
+
+    try {
+        boolean isUnique = idn.isUniqueLDAPValue(identityId, applicationName, attributeName, email);
+        log.info("EMAIL GENERATOR RULE AD || 8: Exiting isUnique method with result: " + isUnique);
+        return isUnique;
+    } catch (Exception e) {
+        log.error("EMAIL GENERATOR RULE AD || 9: Error in isUnique method: " + e.getMessage());
+        throw new GeneralException("Error in isUnique method", e);
+    }
+}
+
+/**
+ * Method to generate a valid and unique email address for the user based on their first name, 
+ * last name, and company ID.
+ * It first tries to generate a basic email and check its uniqueness. If the email is not unique, 
+ * it appends a number to create a unique version.
+ * 
+ * @param firstName The first name of the user.
+ * @param lastName The last name of the user.
+ * @param companyId The company ID of the user to generate domain.
+ * @return The generated unique email address.
+ * @throws GeneralException If the email cannot be generated after 100 attempts.
+ */
+public String generateEmail() throws GeneralException {
+    
+    String firstName = identity.getFirstname();
+    String lastName = identity.getLastname();
+    String companyId = identity.getAttribute("companyId");
+
+    log.info("EMAIL GENERATOR RULE AD || 10: Entering generateEmail method with firstName: " + firstName + ", lastName: " + lastName + ", companyId: " + companyId);
+
+    try {
+        String domain = getDomainByCompanyID(companyId);
+        String generatedEmail = firstName + "." + lastName + "@" + domain;
+        String applicationName = application.getName();
+        String identityId = identity.getId();
+        String attributeName = "mail";
+        String[] sourceIdsArray = {"de15dbc4e37b4e4abdd0a56e54d1376c"}; 
+        List sourceIds = Arrays.asList(sourceIdsArray);
+        String[] valuesArray = {generatedEmail};
+        List values = Arrays.asList(valuesArray);
+        String operation = "Create";
+        String workdayAttributeName = "promotedEmailId";
+
+        log.info("EMAIL GENERATOR RULE AD || 11: Generated email is: " + generatedEmail);
+
+        if (Util.isNotNullOrEmpty(firstName) && Util.isNotNullOrEmpty(lastName) && Util.isNotNullOrEmpty(domain)) {
+            if (Util.isNotNullOrEmpty(applicationName) && Util.isNotNullOrEmpty(identityId) && Util.isNotNullOrEmpty(attributeName)) {
+                if (generatedEmail != null && !generatedEmail.isEmpty()) {
+                    // Check if the generated email is unique
+                    if (isUnique(generatedEmail, identityId, applicationName, attributeName)) {
+                        String workdayAttributeValue = idn.attrSearchGetIdentityName(sourceIds, workdayAttributeName, operation, values);
+                        log.info("EMAIL GENERATOR RULE AD || 12: Exiting generateEmail method with result: " + generatedEmail.toLowerCase());
+                        if (Util.isNullOrEmpty(workdayAttributeValue)){
+                            return generatedEmail.toLowerCase();
+                        }
+                    } else {
+                        log.warn("EMAIL GENERATOR RULE AD || 13: Generated email is not unique, proceeding to fallback logic.");
+                    }
+                }
+            }
+
+            // Fallback logic to add iteration number to email
+            int iteration = 1;
+            while (iteration < 100) {
+                String emailWithIteration = firstName + "." + lastName + iteration + "@" + domain;
+                String[] emailIdtArray = {emailWithIteration};
+                List emailIdvalue = Arrays.asList(emailIdtArray);
+
+                // Check if the email with iteration is unique
+                if (isUnique(emailWithIteration, identityId, applicationName, attributeName)) {
+                    String workdayAttributeValue = idn.attrSearchGetIdentityName(sourceIds, workdayAttributeName, operation, emailIdvalue);
+                    log.info("EMAIL GENERATOR RULE AD || 14: Exiting generateEmail method with result (generated with iteration): " + emailWithIteration.toLowerCase());
+                    if (Util.isNullOrEmpty(workdayAttributeValue)){
+                        return emailWithIteration.toLowerCase(); // Return as soon as we find a unique email
+                    }
+                }
+                iteration++; // Continue to next iteration only if not unique
+            }
+        }
+        throw new GeneralException("EMAIL GENERATOR RULE AD || 15: Cannot generate email after 100 attempts");
+    } catch (Exception e) {
+        log.error("EMAIL GENERATOR RULE AD || 16: Error in generateEmail method: " + e.getMessage());
+        throw new GeneralException("Error in generateEmail method", e);
+    }
+}
+
+log.info("EMAIL GENERATOR RULE AD || 17: Exiting EmailGenerator rule - Generated email: " + generateEmail());
+return generateEmail();
+]]></Source>
+</Rule>
diff --git a/src/main/resources/rules/Rule - BeforeProvisioning - SAP_Before_provisioning_Rule.xml b/src/main/resources/rules/Rule - BeforeProvisioning - SAP_Before_provisioning_Rule.xml
new file mode 100644
index 0000000..58d2e12
--- /dev/null
+++ b/src/main/resources/rules/Rule - BeforeProvisioning - SAP_Before_provisioning_Rule.xml	
@@ -0,0 +1,48 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!DOCTYPE Rule PUBLIC "sailpoint.dtd" "sailpoint.dtd">
+<Rule name="SAP_Before_provisioning_Rule" type="BeforeProvisioning">
+    <Description>SAP GRC BeforeProvisioning Rule To Remove Entitltments once user Disabled</Description>
+    <Source>
+	<![CDATA[
+import sailpoint.object.ProvisioningPlan;
+import sailpoint.object.ProvisioningPlan.AccountRequest;
+import sailpoint.object.ProvisioningPlan.AttributeRequest;
+import sailpoint.object.Application;
+import sailpoint.object.Identity;
+import sailpoint.object.Link;
+
+import sailpoint.api.IdentityService;
+
+import java.util.List;
+import java.util.Date;
+
+import java.text.SimpleDateFormat;
+
+IdentityService service = new IdentityService(context);
+Identity identity = plan.getIdentity();
+SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
+
+List acctReqs = plan.getAccountRequests();
+
+for(AccountRequest acct : acctReqs) {
+	log.info("SAP_Before provisioning_Rule - log 1 " +acct);
+	if(acct.getOperation().equals(AccountRequest.Operation.Disable)) {
+		log.info("SAP_Before provisioning_Rule - log 2 " + acct.getOperation());
+		
+		acct.add(new AttributeRequest("Valid To",ProvisioningPlan.Operation.Set,sdf.format(new Date())));
+		
+		List links = service.getLinks(identity,application);
+		log.info("SAP_Before provisioning_Rule - log 3 " + links);
+		if(!links.isEmpty()) {
+			List entitlements = links.get(0).getAttribute("Roles");
+			if(entitlements != null && !entitlements.isEmpty()) {
+				for(String value : entitlements) {
+					acct.add(new AttributeRequest("Roles",ProvisioningPlan.Operation.Remove,value));
+				}
+			}
+		}
+	}
+}
+]]>
+</Source>
+		</Rule>
\ No newline at end of file
diff --git a/src/main/resources/rules/Rule - BeforeProvisioning - SAP_Remove_Entitlements_After_Termination.xml b/src/main/resources/rules/Rule - BeforeProvisioning - SAP_Remove_Entitlements_After_Termination.xml
new file mode 100644
index 0000000..ae3bff6
--- /dev/null
+++ b/src/main/resources/rules/Rule - BeforeProvisioning - SAP_Remove_Entitlements_After_Termination.xml	
@@ -0,0 +1,132 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!DOCTYPE Rule PUBLIC "sailpoint.dtd" "sailpoint.dtd">
+<Rule name="SAP_Remove_Entitlements_After_Termination_Test" type="BeforeProvisioning">
+    <Description>SAP GRC BeforeProvisioning Rule To Remove Entitltments once user Disabled</Description>
+    <Source>
+	<![CDATA[
+
+import sailpoint.object.*;
+import sailpoint.object.ProvisioningPlan.Operation;
+import sailpoint.object.ProvisioningPlan.AccountRequest;
+import sailpoint.object.ProvisioningPlan.AttributeRequest;
+import sailpoint.rule.Account;
+import sailpoint.server.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import sailpoint.object.Identity;
+import sailpoint.object.ProvisioningPlan;
+import sailpoint.api.*;
+import org.apache.commons.lang.StringUtils;
+import sailpoint.object.Application;
+import sailpoint.object.Attributes;
+import sailpoint.object.Filter;
+import sailpoint.object.Link;
+import sailpoint.object.LinkExternalAttribute;
+import sailpoint.object.ManagedAttribute;
+import sailpoint.object.QueryOptions;
+import sailpoint.rule.RuleObjectFactory;
+import sailpoint.tools.GeneralException;
+import sailpoint.tools.Util;
+import sailpoint.rule.*;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+
+/** 
+	*SAP GRC BeforeProvisioning Rule to remove the roles assigned to user in SAP GRC source once the user becomes Terminates or Disabled 
+*/
+
+
+
+ /** 
+	*This method is used to fetch all the entitlement that user has
+	*@param accountExists  - Boolean check to confirm if account exist by native identity.
+	*@param value - user entitlements from getRawAccountAttribute(); method it may return String or ArrayList.
+	*@return attributeValueList - User entitlement list.
+	*@exception General exception, connectorExceptions.
+*/
+
+
+public List getAccountAttributeList(String applicationName, String nativeIdentity, String attributeName) {
+	log.info("SAP_Remove_Entitlements_After_Termination_Test || Log 9 - Entered getAccountAttributeList function");
+	List attributeValueList = new ArrayList();
+	try{
+		
+		boolean accountExists = idn.accountExistsByNativeIdentity(applicationName, nativeIdentity);
+		log.info("SAP_Remove_Entitlements_After_Termination_Test || Log 10 - Account Exists : "+accountExists);
+		if (accountExists) {
+
+			Object value = idn.getRawAccountAttribute(applicationName, nativeIdentity, attributeName);
+			log.info("SAP_Remove_Entitlements_After_Termination_Test || Log 11 - RAW Account Attributes: "+value);
+			if (value != null) {
+				if (value instanceof List) {
+					attributeValueList.addAll(value);
+				} else if (value instanceof String) {
+					attributeValueList.add(value);
+				}
+			
+			}
+		}
+	}
+	catch(Exception e)
+	{
+		log.error("SAP_Remove_Entitlements_After_Termination_test || ERROR - 1 Exception occurec in getAccountAttributeList function : "+e);
+	}
+	log.info("SAP_Remove_Entitlements_After_Termination_Test || Log 12 - attribut Value list is : "+attributeValueList);
+	log.info("SAP_Remove_Entitlements_After_Termination_Test || Log 13 - Exiting getAccountAttributeList function");
+    return attributeValueList;
+}
+
+/** 
+	*Below block of code is used to fetch the operation that is performed on the user account. 
+	*If the operation performed is Disable then code uses getAccountAttributeList(); to fetch all the entitlements that user has 
+	*Once the entitlements are fetched remove remove operation will be performed.
+*/
+
+if (plan != null) {
+    Identity identity = plan.getIdentity();
+	List accreqs = new LinkedList();
+	log.info("SAP_Remove_Entitlements_After_Termination_Test || Log 1 - Identity is : "+identity);
+    if (identity != null) {
+		log.info("SAP_Remove_Entitlements_After_Termination_Test || Log 2 - Plan is : "+plan);
+		String entName="Roles";
+		List accountRequests = plan.getAccountRequests();
+		log.info("SAP_Remove_Entitlements_After_Termination_Test || Log 3 - accountRequests plan.getAccountRequests as List is : "+accountRequests);
+        if (accountRequests != null && accountRequests.size() > 0) {
+            for (AccountRequest accRequest: accountRequests) {
+                if (accRequest != null) {
+                    if (accRequest.getNativeIdentity() == null) {
+						log.info("SAP_Remove_Entitlements_After_Termination_Test || Log 5 - accRequest from list : "+accRequest);
+						log.info("SAP_Remove_Entitlements_After_Termination_Test || Log 6 - Native identity inside IF) : "+accRequest.getNativeIdentity());
+                        plan.remove(accRequest);
+                    } else {
+
+                        AccountRequest.Operation op = accRequest.getOperation();
+						log.info("SAP_Remove_Entitlements_After_Termination_Test || Log - 7 Operation before entering to if condition : "+op);
+                        if (op != null) {
+                            if (op.equals(AccountRequest.Operation.Disable)) {
+								log.info("SAP_Remove_Entitlements_After_Termination_Test || Log 8 - Entering getAccountAttributeList Function");
+                                List entList = getAccountAttributeList(accRequest.getApplication(), accRequest.getNativeIdentity(), entName);
+								log.info("SAP_Remove_Entitlements_After_Termination_Test || Log 14 - Operation after entering to if condition : "+op);
+								log.info("SAP_Remove_Entitlements_After_Termination_Test || Log 15  - Entitlement List is before remove : "+entList);
+                                for (String ent: entList) {
+                                    AttributeRequest attrRequest = new AttributeRequest(entName, ProvisioningPlan.Operation.Remove, ent);
+									List entListAfterRemoveOp = getAccountAttributeList(accRequest.getApplication(), accRequest.getNativeIdentity(), entName);
+									log.info("SAP_Remove_Entitlements_After_Termination_Test || Log 16  - Entitlement List is after remove : "+entListAfterRemoveOp);
+                                }
+                            }
+                        }
+                    }
+                }
+				accreqs.add(accRequest);
+            }
+        }
+    }
+	plan.setAccountRequests(accreqs);
+
+}
+]]>
+</Source>
+		</Rule>
\ No newline at end of file
diff --git a/src/main/resources/rules/Rule - BeforeProvisioningRule - AddAccessRequesterDetails.xml b/src/main/resources/rules/Rule - BeforeProvisioningRule - AddAccessRequesterDetails.xml
new file mode 100644
index 0000000..3876730
--- /dev/null
+++ b/src/main/resources/rules/Rule - BeforeProvisioningRule - AddAccessRequesterDetails.xml	
@@ -0,0 +1,46 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!DOCTYPE Rule PUBLIC "sailpoint.dtd" "sailpoint.dtd">
+<Rule name="AddAccessRequesterDetails" type="BeforeProvisioning">
+    <Description>Before Provisioning Rule which changes disables and enables to a modify.</Description>
+    <Source><![CDATA[
+import sailpoint.object.*;
+import sailpoint.object.ProvisioningPlan.AccountRequest;
+import sailpoint.object.ProvisioningPlan.AccountRequest.Operation;
+import sailpoint.object.ProvisioningPlan.AttributeRequest;
+import sailpoint.object.ProvisioningPlan;
+import sailpoint.object.ProvisioningPlan.Operation;
+import sailpoint.object.Identity;
+import java.util.List;
+ 
+if(plan != null)
+{
+	log.debug(\"AD Before Provisioning Rule : Entering Rule\");
+	List accountRequests = plan.getAccountRequests();
+	if(accountRequests != null)
+	{
+		for(AccountRequest accountRequest : accountRequests) 
+		{
+			AccountRequest.Operation op = accountRequest.getOperation();
+			if(op != null && op == AccountRequest.Operation.Create)
+			{
+				// Get Requester info
+				List requesterList = plan.getRequesters();
+				Identity requester = null;
+				if (requesterList != null && requesterList.size() > 0)
+				{
+					requester = requesterList.get(0);				
+					if(requester != null)
+					{
+						String requesterNetID = (String)requester.getAttribute(\"netid\");
+						accountRequest.add(new AttributeRequest(\"extensionAttribute1\", ProvisioningPlan.Operation.Set, requesterNetID));
+						log.debug(\"UIH AD Before Provisioning Rule : Added Requester Information \");
+					}
+				}
+			}
+		}
+	}
+	log.debug(\"UIH AD Before Provisioning Rule : Exiting Rule\");
+}
+
+  ]]></Source>
+</Rule>
\ No newline at end of file
diff --git a/src/main/resources/rules/Rule - BeforeProvisioningRule - OUMovement.xml b/src/main/resources/rules/Rule - BeforeProvisioningRule - OUMovement.xml
new file mode 100644
index 0000000..7be1e08
--- /dev/null
+++ b/src/main/resources/rules/Rule - BeforeProvisioningRule - OUMovement.xml	
@@ -0,0 +1,94 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!DOCTYPE Rule PUBLIC "sailpoint.dtd" "sailpoint.dtd">
+<Rule name="AcOUMovement" type="BeforeProvisioning">
+    <Description>Before Provisioning Rule which changes disables and enables to a modify</Description>
+    <Source>
+	<![CDATA[
+  
+    import sailpoint.object.ProvisioningPlan.AccountRequest;
+	import sailpoint.object.ProvisioningPlan.AccountRequest.Operation;
+	import sailpoint.object.ProvisioningPlan.AttributeRequest;
+	import sailpoint.object.ProvisioningPlan;
+	import sailpoint.object.ProvisioningPlan.Operation;
+	import sailpoint.object.Identity;
+
+  if (plan != null) {
+     Identity identity = plan.getIdentity();
+	 String applicationName = application.getName();
+	 
+
+	for (AccountRequest accountRequest : plan.getAccountRequests()) {
+	  if (accountRequest.getOp().equals(ProvisioningPlan.ObjectOperation.Disable)) {
+        accountRequest.add(new AttributeRequest("AC_NewParent", ProvisioningPlan.Operation.Set, "OU=RetiredUsers,OU=RetiredObjects,OU=RAI,DC=devad,DC=rai,DC=com"));
+        accountRequest.add(new AttributeRequest("memberOf", ProvisioningPlan.Operation.Add, "CN=T2_EMP_DisabledAccounts,OU=T2-Groups,OU=Tier2,OU=Production,OU=RAI,DC=devad,DC=rai,DC=com"));
+        accountRequest.add(new AttributeRequest("primaryGroupDN", ProvisioningPlan.Operation.Set, "CN=T2_EMP_DisabledAccounts,OU=T2-Groups,OU=Tier2,OU=Production,OU=RAI,DC=devad,DC=rai,DC=com"));
+        accountRequest.add(new AttributeRequest("memberOf", ProvisioningPlan.Operation.Remove, "CN=Domain Users,CN=Users,DC=devad,DC=rai,DC=com"));
+
+	 }
+	  if (accountRequest.getOp().equals(ProvisioningPlan.ObjectOperation.Enable)) {
+        accountRequest.add(new AttributeRequest("AC_NewParent", ProvisioningPlan.Operation.Set, "OU=T2-Users,OU=Tier2,OU=Production,OU=RAI,DC=devad,DC=rai,DC=com"));
+        accountRequest.add(new AttributeRequest("memberOf", ProvisioningPlan.Operation.Add, "CN=Domain Users,CN=Users,DC=devad,DC=rai,DC=com"));
+        accountRequest.add(new AttributeRequest("primaryGroupDN", ProvisioningPlan.Operation.Set, "CN=Domain Users,CN=Users,DC=devad,DC=rai,DC=com"));
+		accountRequest.add(new AttributeRequest("memberOf", ProvisioningPlan.Operation.Remove, "CN=T2_EMP_DisabledAccounts,OU=T2-Groups,OU=Tier2,OU=Production,OU=RAI,DC=devad,DC=rai,DC=com"));
+        accountRequest.add(new AttributeRequest("memberOf", ProvisioningPlan.Operation.Remove, "CN=T2_Sec_InboundEmailBlock,OU=T2-Groups,OU=Tier2,OU=Production,OU=RAI,DC=devad,DC=rai,DC=com"));
+      }
+	  
+	  if (accountRequest.getOp().equals(ProvisioningPlan.ObjectOperation.Create)) {
+	  
+	  String nativeIdentity = accountRequest.getNativeIdentity();
+	  
+	  
+	  String UserOU = "OU=T2-Users,OU=Tier2,OU=Production,OU=RAI,DC=devad,DC=rai,DC=com";
+      String RetiredOU = "OU=RetiredUsers,OU=RetiredObjects,OU=RAI,DC=devad,DC=rai,DC=com";
+	   
+	  
+	  public String generateCN(String applicationName, String displayName, String UserOU, String RetiredOU, String nativeIdentity) {
+               String newDN = "CN=" + displayName + "," + UserOU;
+			   String newRetDN = "CN=" + displayName + "," + RetiredOU;
+			   
+			    boolean accountExistsInDN;
+                boolean accountExistsInRetDN;
+				
+				
+                accountExistsInDN = idn.accountExistsByNativeIdentity(applicationName, newDN);
+				accountExistsInRetDN = idn.accountExistsByNativeIdentity(applicationName, newRetDN);
+                if (!accountExistsInDN && !accountExistsInRetDN) {
+                    return displayName;
+                }
+
+                for (int i=1; i<100; i++) {
+                    String displayName = displayName + i;
+                    newDN = "CN=" + displayName + "," + UserOU;
+					newRetDN = "CN=" + displayName + "," + RetiredOU;
+                    accountExistsInDN = idn.accountExistsByNativeIdentity(applicationName, newDN);
+					accountExistsInRetDN = idn.accountExistsByNativeIdentity(applicationName, newRetDN);
+                    if(!accountExistsInDN && !accountExistsInRetDN) {
+                        return displayName;
+                    }
+                }
+                return null;
+            } 
+	  
+	  String displayName = (String) identity.getAttribute(\"displayName\");
+	  
+	 if (displayName != null && displayName.contains("[C]")) {
+    displayName = displayName.replace("[C]", "");
+}
+displayName = displayName.trim();
+
+String newCN = generateCN(applicationName, displayName, UserOU, RetiredOU, nativeIdentity);
+if (null != newCN){
+accountRequest.add(new AttributeRequest("AC_NewName", ProvisioningPlan.Operation.Set, "CN=" + newCN));
+accountRequest.add(new AttributeRequest("AC_NewParent", ProvisioningPlan.Operation.Set, UserOU));
+	  }
+        }
+		if ((accountRequest.getOp().equals(ProvisioningPlan.ObjectOperation.Create)) && (activeDirectoryDn != null)){
+		 	   log.debug("Inside Create Block to modify the provisioning plan");
+			   plan.remove(accountRequest);
+
+		 }
+	 }  
+	}
+]]>
+</Source>
+		</Rule>
\ No newline at end of file
diff --git a/src/main/resources/rules/Rule - BuildMap - JoinAttributes.xml b/src/main/resources/rules/Rule - BuildMap - JoinAttributes.xml
index f004b46..c3467ef 100644
--- a/src/main/resources/rules/Rule - BuildMap - JoinAttributes.xml	
+++ b/src/main/resources/rules/Rule - BuildMap - JoinAttributes.xml	
@@ -17,20 +17,40 @@
     </Inputs>
     </Signature>
     <Source><![CDATA[
-     import sailpoint.connector.DelimitedFileConnector;
+    import sailpoint.connector.DelimitedFileConnector;
+    import sailpoint.tools.Util;
 
-     Map map = DelimitedFileConnector.defaultBuildMap( cols, record );
-     String access = (String) map.get( "access" );
-     String permission = (String) map.get( "permission" );
+    Map map = DelimitedFileConnector.defaultBuildMap(cols, record);
+    log.info(map.get("Display_Name"));
+    // Log the initial map to see what data is received
+    log.info("DELIMITED FILE BUILD MAP RULE LOG 1: Initial map: " + map);
+
+    // Get the "User_Status" value from the map
+    String status = (String) map.get("User_Status");
+    log.info("DELIMITED FILE BUILD MAP RULE LOG 2: User_Status value: " + status);
+
+    boolean accountDisabledFlag = false;
+
+    // Check the User_Status and set the accountDisabledFlag accordingly
+    if (status.equalsIgnoreCase("A")) {
+        accountDisabledFlag = false;
+        log.info("DELIMITED FILE BUILD MAP RULE LOG 3: Account is active. accountDisabledFlag set to false.");
+    } else if (status.equalsIgnoreCase("I")) {
+        accountDisabledFlag = true;
+        log.info("DELIMITED FILE BUILD MAP RULE LOG 4: Account is disabled. accountDisabledFlag set to true.");
+    } else {
+        log.info("DELIMITED FILE BUILD MAP RULE LOG 5: Unrecognized status value. No changes to accountDisabledFlag.");
+    }
+
+    // Put the result into the map
+    map.put("IIQDisabled", accountDisabledFlag);
+
+    // Log the final map to verify the result
+    log.info("DELIMITED FILE BUILD MAP RULE LOG 6: Final map is: " + map);
+
+    return map;
 
-    log.debug("Map log: " + map);
 
-     if ( access != null && permission != null ) {
-          map.remove("access");
-          map.remove("permission");
-          map.put("access", access + " - " + permission);
-     }
-     return map;
 
   ]]></Source>
 </Rule>
\ No newline at end of file
diff --git a/src/main/resources/rules/Rule - BuildMap - Morrissey.xml b/src/main/resources/rules/Rule - BuildMap - Morrissey.xml
new file mode 100644
index 0000000..16fd0b4
--- /dev/null
+++ b/src/main/resources/rules/Rule - BuildMap - Morrissey.xml	
@@ -0,0 +1,39 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!DOCTYPE Rule PUBLIC "sailpoint.dtd" "sailpoint.dtd">
+<Rule name="MorriseyBuildMap" type="BuildMap">
+    <Description>This rule sets the IIQDisabled flag based on the User_Status field and adds a default "account" attribute with the value "access."</Description>
+    <Signature returnType='Object'>
+    <Inputs>
+    <Argument name='cols' type='java.util.List'>
+        <Description>
+            The columns of the delimited file.
+        </Description>
+    </Argument>
+        <Argument name='record' type='java.util.List'>
+            <Description>
+                A single record of the delimited file.
+            </Description>
+        </Argument>
+    </Inputs>
+    </Signature>
+    <Source><![CDATA[
+	
+    import sailpoint.connector.DelimitedFileConnector;
+ 
+    Map map = DelimitedFileConnector.defaultBuildMap(cols, record);
+    String status = (String) map.get("User_Status");
+    boolean accountDisabledFlag = false;
+    if (status != null && status.equalsIgnoreCase("A")) {
+        accountDisabledFlag = false;
+    } else {
+        accountDisabledFlag = true;  
+    }
+ 
+    map.put("IIQDisabled", accountDisabledFlag);
+	map.put("account", "access");
+ 
+    return map;
+ 
+ 
+  ]]></Source>
+</Rule>
\ No newline at end of file
diff --git a/src/test/java/sailpoint/EmailGeneratorTest.java b/src/test/java/sailpoint/EmailGeneratorTest.java
new file mode 100644
index 0000000..83ef0a9
--- /dev/null
+++ b/src/test/java/sailpoint/EmailGeneratorTest.java
@@ -0,0 +1,342 @@
+package sailpoint;
+
+import bsh.EvalError;
+import bsh.Interpreter;
+import org.apache.log4j.LogManager;
+import org.apache.log4j.Logger;
+import org.junit.jupiter.api.Test;
+import sailpoint.object.Application;
+import sailpoint.object.Identity;
+import sailpoint.rdk.utils.RuleXmlUtils;
+import sailpoint.server.IdnRuleUtil;
+import sailpoint.tools.GeneralException;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class EmailGeneratorTest {
+    Logger log = LogManager.getLogger(EmailGeneratorTest.class);
+
+    String result1 = "";
+    private static final String RULE_FILENAME = "src/main/resources/rules/Rule - AttributeGenerator - EmailGenerator.xml";
+
+    // Test case for "N" (Contractor)
+    @Test
+    public void testUsernameGeneratorWhereFirstAndLastNameValidContractor() throws GeneralException, EvalError {
+        Interpreter i = new Interpreter();
+
+        IdnRuleUtil idn = mock(IdnRuleUtil.class);
+        when(idn.accountExistsByDisplayName(any(), any())).thenReturn(false);
+        when(idn.attrSearchGetIdentityName(any(), any(), any(), any())).thenReturn(null);
+        when(idn.isUniqueLDAPValue(any(), any(), any(), any()))
+            .thenReturn(false) // First attempt: email is not unique
+            .thenReturn(true);  // Second attempt: email becomes unique after the first iteration
+
+        Application application = mock(Application.class);
+        when(application.getName()).thenReturn("Active Directory [source]");
+
+        Identity identity = mock(Identity.class);
+        when(identity.getFirstname()).thenReturn("tyler");
+        when(identity.getLastname()).thenReturn("Smith");
+        when(identity.getAttribute("companyId")).thenReturn("100");
+        when(identity.getAttribute("isAssociate")).thenReturn("N"); // Contractor
+        when(identity.getId()).thenReturn("g12h3b1g2y3v12");
+
+        i.set("log", log);
+        i.set("idn", idn);
+        i.set("application", application);
+        i.set("identity", identity);
+
+        String source = RuleXmlUtils.readRuleSourceFromFilePath(RULE_FILENAME);
+        result1 = (String) i.eval(source);
+
+        assertNotNull(result1);
+        assertEquals(result1, "tyler.smith1_contractor@jmfamily.com");
+
+        log.info("Beanshell script returned: " + result1);
+    }
+
+    // Test case for "Y" (Non-Contractor)
+    @Test
+    public void testUsernameGeneratorWhereFirstAndLastNameValidEmployee() throws GeneralException, EvalError {
+        Interpreter i = new Interpreter();
+
+        IdnRuleUtil idn = mock(IdnRuleUtil.class);
+        when(idn.accountExistsByDisplayName(any(), any())).thenReturn(false);
+        when(idn.attrSearchGetIdentityName(any(), any(), any(), any())).thenReturn(null);
+        when(idn.isUniqueLDAPValue(any(), any(), any(), any()))
+            .thenReturn(false) // First attempt: email is not unique
+            .thenReturn(true);  // Second attempt: email becomes unique after the first iteration
+
+        Application application = mock(Application.class);
+        when(application.getName()).thenReturn("Active Directory [source]");
+
+        Identity identity = mock(Identity.class);
+        when(identity.getFirstname()).thenReturn("tyler");
+        when(identity.getLastname()).thenReturn("Smith");
+        when(identity.getAttribute("companyId")).thenReturn("100");
+        when(identity.getAttribute("isAssociate")).thenReturn("Y"); // Non-Contractor
+        when(identity.getId()).thenReturn("g12h3b1g2y3v12");
+
+        i.set("log", log);
+        i.set("idn", idn);
+        i.set("application", application);
+        i.set("identity", identity);
+
+        String source = RuleXmlUtils.readRuleSourceFromFilePath(RULE_FILENAME);
+        result1 = (String) i.eval(source);
+
+        assertNotNull(result1);
+        assertEquals(result1, "tyler.smith1@jmfamily.com");
+
+        log.info("Beanshell script returned: " + result1);
+    }
+
+    // Test case for "N" (Contractor) with a different Company ID
+    @Test
+    public void testUsernameGeneratorWithDifferentCompanyIDContractor() throws GeneralException, EvalError {
+        Interpreter i = new Interpreter();
+
+        IdnRuleUtil idn = mock(IdnRuleUtil.class);
+        when(idn.accountExistsByDisplayName(any(), any())).thenReturn(false);
+        when(idn.attrSearchGetIdentityName(any(), any(), any(), any())).thenReturn(null);
+        when(idn.isUniqueLDAPValue(any(), any(), any(), any()))
+            .thenReturn(false) // First attempt: email is not unique
+            .thenReturn(true);  // Second attempt: email becomes unique after the first iteration
+
+        Application application = mock(Application.class);
+        when(application.getName()).thenReturn("Active Directory [source]");
+
+        Identity identity = mock(Identity.class);
+        when(identity.getFirstname()).thenReturn("alice");
+        when(identity.getLastname()).thenReturn("johnson");
+        when(identity.getAttribute("companyId")).thenReturn("300"); // Different Company ID
+        when(identity.getAttribute("isAssociate")).thenReturn("N"); // Contractor
+        when(identity.getId()).thenReturn("a1b2c3d4");
+
+        String result = "";
+
+        i.set("log", log);
+        i.set("idn", idn);
+        i.set("application", application);
+        i.set("identity", identity);
+
+        String source = RuleXmlUtils.readRuleSourceFromFilePath(RULE_FILENAME);
+        result = (String) i.eval(source);
+
+        // The domain should be "jmagroup.com" based on company ID "300"
+        assertNotNull(result);
+        assertEquals(result, "alice.johnson1_contractor@jmagroup.com");
+
+        log.info("Beanshell script returned: " + result);
+    }
+
+    // Test case for "Y" (Non-Contractor) with a different Company ID
+    @Test
+    public void testUsernameGeneratorWithDifferentCompanyIDEmployee() throws GeneralException, EvalError {
+        Interpreter i = new Interpreter();
+
+        IdnRuleUtil idn = mock(IdnRuleUtil.class);
+        when(idn.accountExistsByDisplayName(any(), any())).thenReturn(false);
+        when(idn.attrSearchGetIdentityName(any(), any(), any(), any())).thenReturn(null);
+        when(idn.isUniqueLDAPValue(any(), any(), any(), any())).thenReturn(true);
+
+        Application application = mock(Application.class);
+        when(application.getName()).thenReturn("Active Directory [source]");
+
+        Identity identity = mock(Identity.class);
+        when(identity.getFirstname()).thenReturn("alice");
+        when(identity.getLastname()).thenReturn("johnson");
+        when(identity.getAttribute("companyId")).thenReturn("300"); // Different Company ID
+        when(identity.getAttribute("isAssociate")).thenReturn("Y"); // Non-Contractor
+        when(identity.getId()).thenReturn("a1b2c3d4");
+
+        String result = "";
+
+        i.set("log", log);
+        i.set("idn", idn);
+        i.set("application", application);
+        i.set("identity", identity);
+
+        String source = RuleXmlUtils.readRuleSourceFromFilePath(RULE_FILENAME);
+        result = (String) i.eval(source);
+
+        // The domain should be "jmagroup.com" based on company ID "300"
+        assertNotNull(result);
+        assertEquals(result, "alice.johnson@jmagroup.com");
+
+        log.info("Beanshell script returned: " + result);
+    }
+
+    // Test case for "N" (Contractor) with a non-unique email initially
+    @Test
+    public void testUsernameGeneratorWithNonUniqueEmailInitiallyContractor() throws GeneralException, EvalError {
+        Interpreter i = new Interpreter();
+
+        IdnRuleUtil idn = mock(IdnRuleUtil.class);
+
+        // Simulate that the email is initially not unique
+        when(idn.isUniqueLDAPValue(any(), any(), any(), any()))
+            .thenReturn(false) // First attempt: email is not unique
+            .thenReturn(true);  // Second attempt: email becomes unique after the first iteration
+
+        when(idn.accountExistsByDisplayName(any(), any())).thenReturn(false);
+        when(idn.attrSearchGetIdentityName(any(), any(), any(), any())).thenReturn(null);
+
+        Application application = mock(Application.class);
+        when(application.getName()).thenReturn("Active Directory [source]");
+
+        Identity identity = mock(Identity.class);
+        when(identity.getFirstname()).thenReturn("john");
+        when(identity.getLastname()).thenReturn("doe");
+        when(identity.getAttribute("companyId")).thenReturn("100");
+        when(identity.getId()).thenReturn("g12h3b1g2y3v12");
+        when(identity.getAttribute("isAssociate")).thenReturn("N");
+
+        String result = "";
+
+        i.set("log", log);
+        i.set("idn", idn);
+        i.set("application", application);
+        i.set("identity", identity);
+
+        String source = RuleXmlUtils.readRuleSourceFromFilePath(RULE_FILENAME);
+        result = (String) i.eval(source);
+
+        // Since the first email attempt should not be unique, we expect the iteration to happen
+        assertNotNull(result);
+        assertEquals(result, "john.doe1_contractor@jmfamily.com"); // After iteration 1, the email should be unique
+
+        log.info("Beanshell script returned: " + result);
+    }
+
+    // Test case for "Y" (Non-Contractor) with a non-unique email initially
+    @Test
+    public void testUsernameGeneratorWithNonUniqueEmailInitiallyEmployee() throws GeneralException, EvalError {
+        Interpreter i = new Interpreter();
+
+        IdnRuleUtil idn = mock(IdnRuleUtil.class);
+
+        // Simulate that the email is initially not unique
+        when(idn.isUniqueLDAPValue(any(), any(), any(), any()))
+            .thenReturn(false) // First attempt: email is not unique
+            .thenReturn(true);  // Second attempt: email becomes unique after the first iteration
+
+        when(idn.accountExistsByDisplayName(any(), any())).thenReturn(false);
+        when(idn.attrSearchGetIdentityName(any(), any(), any(), any())).thenReturn(null);
+
+        Application application = mock(Application.class);
+        when(application.getName()).thenReturn("Active Directory [source]");
+
+        Identity identity = mock(Identity.class);
+        when(identity.getFirstname()).thenReturn("john");
+        when(identity.getLastname()).thenReturn("doe");
+        when(identity.getAttribute("companyId")).thenReturn("100");
+        when(identity.getId()).thenReturn("g12h3b1g2y3v12");
+
+        String result = "";
+
+        i.set("log", log);
+        i.set("idn", idn);
+        i.set("application", application);
+        i.set("identity", identity);
+
+        String source = RuleXmlUtils.readRuleSourceFromFilePath(RULE_FILENAME);
+        result = (String) i.eval(source);
+
+        // Since the first email attempt should not be unique, we expect the iteration to happen
+        assertNotNull(result);
+        assertEquals(result, "john.doe1@jmfamily.com"); // After iteration 1, the email should be unique
+
+        log.info("Beanshell script returned: " + result);
+    }
+    @Test
+    public void testUsernameGeneratorWithMultipleNonUniqueEmailAttemptsContractor() throws GeneralException, EvalError {
+        Interpreter i = new Interpreter();
+
+        IdnRuleUtil idn = mock(IdnRuleUtil.class);
+
+        // Simulate that the email is not unique for several attempts
+        when(idn.isUniqueLDAPValue(any(), any(), any(), any()))
+            .thenReturn(false) // Email is not unique on first attempt
+            .thenReturn(false) // Email still not unique on second attempt
+            .thenReturn(true);  // Becomes unique after the third attempt
+
+        when(idn.accountExistsByDisplayName(any(), any())).thenReturn(false);
+        when(idn.attrSearchGetIdentityName(any(), any(), any(), any())).thenReturn(null);
+
+        Application application = mock(Application.class);
+        when(application.getName()).thenReturn("Active Directory [source]");
+
+        Identity identity = mock(Identity.class);
+        when(identity.getFirstname()).thenReturn("john");
+        when(identity.getLastname()).thenReturn("doe");
+        when(identity.getAttribute("companyId")).thenReturn("100");
+        when(identity.getAttribute("isAssociate")).thenReturn("N"); // Contractor
+        when(identity.getId()).thenReturn("g12h3b1g2y3v12");
+
+        String result = "";
+
+        i.set("log", log);
+        i.set("idn", idn);
+        i.set("application", application);
+        i.set("identity", identity);
+
+        String source = RuleXmlUtils.readRuleSourceFromFilePath(RULE_FILENAME);
+        result = (String) i.eval(source);
+
+        // After several attempts, email should finally be unique
+        assertNotNull(result);
+        assertEquals(result, "john.doe2_contractor@jmfamily.com"); // After 2 failed attempts, we expect the third attempt to work
+
+        log.info("Beanshell script returned: " + result);
+    }
+
+
+    @Test
+    public void testUsernameGeneratorWithMultipleNonUniqueEmailAttemptsEmployee() throws GeneralException, EvalError {
+        Interpreter i = new Interpreter();
+
+        IdnRuleUtil idn = mock(IdnRuleUtil.class);
+
+        // Simulate that the email is not unique for several attempts
+        when(idn.isUniqueLDAPValue(any(), any(), any(), any()))
+            .thenReturn(false) // Email is not unique on first attempt
+            .thenReturn(false) // Email still not unique on second attempt
+            .thenReturn(true);  // Becomes unique after the third attempt
+
+        when(idn.accountExistsByDisplayName(any(), any())).thenReturn(false);
+        when(idn.attrSearchGetIdentityName(any(), any(), any(), any())).thenReturn(null);
+
+        Application application = mock(Application.class);
+        when(application.getName()).thenReturn("Active Directory [source]");
+
+        Identity identity = mock(Identity.class);
+        when(identity.getFirstname()).thenReturn("john");
+        when(identity.getLastname()).thenReturn("doe");
+        when(identity.getAttribute("companyId")).thenReturn("100");
+        when(identity.getAttribute("isAssociate")).thenReturn("Y"); // Non-Contractor
+        when(identity.getId()).thenReturn("g12h3b1g2y3v12");
+
+        String result = "";
+
+        i.set("log", log);
+        i.set("idn", idn);
+        i.set("application", application);
+        i.set("identity", identity);
+
+        String source = RuleXmlUtils.readRuleSourceFromFilePath(RULE_FILENAME);
+        result = (String) i.eval(source);
+
+        // After several attempts, email should finally be unique
+        assertNotNull(result);
+        assertEquals(result, "john.doe2@jmfamily.com"); // After 2 failed attempts, we expect the third attempt to work
+
+        log.info("Beanshell script returned: " + result);
+    }
+
+
+}
diff --git a/src/test/java/sailpoint/JoinAttributesTest.java b/src/test/java/sailpoint/JoinAttributesTest.java
index b8b5286..347f49b 100644
--- a/src/test/java/sailpoint/JoinAttributesTest.java
+++ b/src/test/java/sailpoint/JoinAttributesTest.java
@@ -18,17 +18,42 @@
 import sailpoint.rdk.utils.RuleXmlUtils;
 import sailpoint.tools.GeneralException;
 
+
+@SuppressWarnings("unused")
 public class JoinAttributesTest {
-    Logger log = LogManager.getLogger(ManagerCorrelationTest.class);
+    Logger log = LogManager.getLogger(JoinAttributesTest.class);
 
     private static final String RULE_FILENAME = "src/main/resources/rules/Rule - BuildMap - JoinAttributes.xml";
 
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testEnableUSer () throws GeneralException, EvalError {
+        Interpreter i = new Interpreter();
+
+        List<String> columns = Arrays.asList("User_Status");
+        List<String> rows = Arrays.asList("A");
+
+
+        i.set("log", log);
+        i.set("cols", columns);
+        i.set("record", rows);
+
+        String source = RuleXmlUtils.readRuleSourceFromFilePath(RULE_FILENAME);
+
+        //@SuppressWarnings("unchecked")
+        Map<String, String> result = (Map<String, String>) i.eval(source);
+
+        log.info("FINAL RESULT"+ result);
+
+
+    }
+    @SuppressWarnings("unchecked")
     @Test
-    public void testThatNewColumnIsAdded () throws GeneralException, EvalError {
+    public void testDisableUser () throws GeneralException, EvalError {
         Interpreter i = new Interpreter();
 
-        List<String> columns = Arrays.asList("access", "permission", "email");
-        List<String> rows = Arrays.asList("admin","write","john.doe@sailpoint.com");
+        List<String> columns = Arrays.asList("User_Status");
+        List<String> rows = Arrays.asList("I");
 
 
         i.set("log", log);
@@ -37,7 +62,7 @@ public void testThatNewColumnIsAdded () throws GeneralException, EvalError {
 
         String source = RuleXmlUtils.readRuleSourceFromFilePath(RULE_FILENAME);
 
-        @SuppressWarnings("unchecked")
+        //@SuppressWarnings("unchecked")
         Map<String, String> result = (Map<String, String>) i.eval(source);
 
         log.info(result);
diff --git a/src/test/java/sailpoint/ProvisioningTest.java b/src/test/java/sailpoint/ProvisioningTest.java
index 95e261e..cbafb8b 100644
--- a/src/test/java/sailpoint/ProvisioningTest.java
+++ b/src/test/java/sailpoint/ProvisioningTest.java
@@ -19,6 +19,7 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
+@SuppressWarnings("unused")
 public class ProvisioningTest {
     Logger log = LogManager.getLogger(ProvisioningTest.class);