Migrating Decisions from TargetX to WebAdMIT

Overview

If you want to transfer decisions from TargetX to WebAdMIT, you can utilize the TargetX to WebAdMIT data migration process. This process uses a Python script along with Informatica to move decisions data from TargetX to update decisions in WebAdMIT.

Here’s how it works:

• TargetX exports a CSV file via Informatica to a folder on the Informatica server.
• The Python script, running on the Informatica server, picks up the CSV file and loads the data updates the decisions in WebAdMIT.
• The script then archives the file for data retention and auditing.

Prerequisites

Before setting this up, make sure you have the following:

• A Windows-based Informatica server to host the Python script. To get this ready, you’ll need:
  
  • An account with admin rights on the server.
  • Python installed on the server to edit and run the script.
  • Notepad++ or another text editor installed on the server.
• An existing CAS (WebAdMIT) to TargetX data integration.
• The field Program ID (For WebAdMIT API) should be included in your existing data integration from WebAdMIT > TargetX. If it’s not, you’ll need to adjust your current WebAdMIT > TargetX integration or create a new field in TargetX for this.

Setting up Decisions TargetX

Decisions in TargetX primarily occur within the Application Review Tool (ART). This tool is not standardized across institutions but instead configured to match each client’s unique business rules and review practices. For example, some clients begin the review process immediately after an application is submitted, while others wait until certain checklist items, transcripts, or other requirements are complete before starting review.
 
The review process itself is managed through Salesforce Flows, which create the necessary Application Review records. Depending on how the institution structures its process, there may be multiple review stages—such as an initial review, a committee review, and then a final review and decision. These Flows are tailored to each client and determine how and when Application Review records are created, updated, and advanced through the process.
 
Once the final review stage is reached, Salesforce Flows push the outcomes back to the Application object. At this point, several fields are typically updated, including the Application Decision, Show Reply to Offer, Enrollment Deposit, Decision Date, and Publish Decision Date/Time. In many implementations, additional updates also occur on the Contact record, such as moving the Student Stage forward to reflect the applicant’s new status.
 
Publishing the decision to the applicant depends on the Publish Decision Date/Time field. If this field contains a current date, the applicant’s Decision Letter (a Visualforce page) will display conditional content within their Applicant Portal or Dashboard. If a client has not configured App Configuration and Application Type values, however, applicants will not have a portal or Dashboard to view their decision information.

WebAdMIT User Identities

To use the WebAdMIT API, you’ll need a WebAdMIT user account that can access data for all departments and programs. This is usually an Institution Manager account in both prelaunch and production environments.

Here’s what to do:

1. Log in to WebAdMIT with your Institution Manager account.
2. Click Account at the top right to open Account Details.
3. Click Edit My Account.
4. Verify your account has the right organization and program assignments.
5. In the API section, click Generate New Key to create a unique API key.
6. Click Show Key and copy your API key—it will be needed for the script and to get your identity ID.

Retrieving Your User Identity ID

$ curl -n https://api.webadmit.org/api/v1/user_identities \
  -H "x-api-key: <ENTER YOUR API KEY>"

$ curl -n https://prelaunch.webadmit.org/api/v1/user_identities \
-H "x-api-key: <ENTER YOUR API KEY>"

{
"href": "/api/v1/user_identities",
"user_identities": [
{
"id": 42,
"type": "Admissions User",
"association": "SOPHAS",
"institution": "Demo University",
"organization": "Demo University School of Public Health",
"cycle": "2014 - 2015"
}
]
}

Retrieving the Decision IDs in WebAdMIT

$ curl -n https://api.webadmit.org/api/v1/user_identities/:<ENTER USER_IDENTITY_ID>/decisions/
 -H "x-api-key: <ENTER YOUR API KEY

{
  "href": "/api/v1/user_identities/1/decisions",
  "decisions": [
    {
      "id": 42,
      "name": "Offer Accepted"
    }
  ]
}

Data Mapping Document

We recommend creating a data mapping document that lists the TargetX Decisions and the corresponding decision Ids for Prelaunch and Production WebAdMIT. Create one for each admission cycle.

Configuring the TargetX Export

To get data from TargetX to WebAdMIT via Informatica, you need to set up Informatica export tasks.

Here’s a quick walkthrough:

1. Import the attached zip [Decisions_Informatica_Stencils.zip] file into your Informatica.
2. During import, make sure to choose your runtime environment.
3. Set up connections for your flat file dropbox folder and TargetX Salesforce (sandbox or production). 

4. Test the import and then click Import.
5. You’ll see 6 jobs created (3 mappings and 3 mapping tasks). 
   
   
   
   
6. Edit the ContactExport mapping:
   
   • Set the source connection to your TargetX sandbox or production. 
     
   • Make sure you bring in only the fields Id and TargetX_Base__CAS_Applicant_ID__c. 
     
   • Add a filter to exclude rows where TargetX_Base__CAS_Applicant_ID__c is null.  
     
   • Ensure the target connection points to your Informatica dropbox folder. 
     
7. Save the Contact Export mapping and check the task’s connections.
8. Edit the Application Export mapping:
   
   • Ensure the source connection to TargetX (Sandbox or Production). 
     
   • Filter to only include application data for the CAS, cycle you want and only submitted applications.
   • Limit fields to relevant IDs and filters.

8. • Ensure the unconnected lookup points to the SFContactExport.csv in your dropbox. 
     
   • Ensure the target points to your flat file dropbox. 
     
9. Save and check the Application Export task.
10. Edit the TargetX-WebAdMIT mapping:
    
    • Point the source to TargetX.
    • Filter application data by CAS and cycle. 
      
    • Include fields for Contact ID, Program ID, TargetX Decision field, and any filters.
    • Ensure the unconnected lookup to your dropbox flat file. 

• • Edit the DECODE statement associated with the field TXDecision to transform the incoming TargetX decisions with WebAdMIT decision Ids. Also, change the cycle value to match the CAS cycle you are working with. Make sure to add a space between the “-” when entering the cycle years. For example, “2025 – 2026”. 
    
  • Make sure the target fields are in the order: CASID, Program Unique Identifier, then the transformed decision field. 

8. Save the mapping.
9. Edit the TargetX-WebAdMIT mapping task:
   • Go to Run Time Options > Advanced Options.
   • Add this post-processing command (replace paths accordingly):

del PathToDropbox\SFContact* && del PathToDropbox\SfApplication* && move /Y " PathToDropbox\YourFinalFile.csv" "PathToPythonScript\"

13. Save your changes.
14. Add the mapping tasks to your existing linear flow in this order:

• • Contact Export
  • Application Export
  • TargetX-WebAdMIT Export

Python Installation

You'll need to install Python on the server that will be hosting the script. To do so:

1. Download the software from https://www.python.org/downloads/.
2. Download the latest release for Windows (based on whether the server is a32 bit or 64 bit).
3. Once downloaded, run the Python install file as an administrator.
4. This opens an installation window:

6. Click Customize Installation to display  Optional Features:

7. Ensure that pip is selected.
8. The next page displays advanced installation options:

9.  Select the path to install Python and click Install.
10. Once Python is successfully installed, restart the server.
11. Once restarted, navigate to your system environment variables to ensure Python is appended to the end of the PATH variable. If it is not, you will need to add it. The path should be the path to the Python executable, such as C:\Users\username\AppData\Local\Programs\Python\Python310

12. To test that your Python installation was successful and added successfully to your PATH variables, run Command Prompt as an administrator, type python, and hit enter:

• If the response is similar to “Python is not recognized as an internal or external command”, then it could mean that the PATH variable is not correctly set up or your Python was not correctly installed.

Editing the Python script

1. Download the Python script and config.json file from Integration Help Center and place it on the Informatica server.
2. On the server, create a folder called TargetXToWebAdMIT.
3.  Create a sub-folder called Archive.
4. Place the Python script and the config.json file in the TargetXToWebAdMIT folder.
5. The CSV file from Outcomes must also be dropped in the TargetXToWebAdMIT folder.
6. Edit the config.json file in the TargetXToWebAdMIT folder using Notepad++ or Notepad and make the following changes:
   • Change the Api_key value to your API key for prelaunch or production.
   • Change the url_link value to prelaunch or production url.
   • Change Working_dir to the full directory path of your TargetXToWebAdMIT folder. Note that the directory separations use  "/".
   • Set File_name to the name of the incoming CSV file from Outcomes.

Creating a Python executable

Next, you'll need to create a Python executable that will run the script. To do so:

1. Open Command Prompt as an administrator.
2. Run the following command: pip install pyinstaller
   • If you get an error message that pip is not recognized as an internal or external command, this means your Python installation did not include the pip package.
   • The article How to Install PIP on Windows provides guidance on installing pip.
   • Once installed, type pip –version in Command Prompt to verify if the installation was successful.

   • If pip installation was successful, rerun the pyinstaller command: pip install pyinstaller

3. Run the following command to ensure the requests module gets installed correctly: pip install requests
4. If pyinstaller and requests installation was successful, in Command Prompt, navigate to the TargetXToWebAdMIT directory.
5. Type the following command: pyinstaller --onefile decisions.py and press enter.
6. This command converts the script into an executable.
7. The executable is found in the \TargetXToWebAdMIT\dist\ folder.
8. Copy the config.json file from the TargetXToWebAdMIT folder to \TargetXToWebAdMIT\dist\ folder.

Testing the executable

The following should be completed for prelaunch Outcomes to prelaunch WebAdMIT:

1. Navigate to the \TargetXToWebAdMIT\dist\ folder in Windows Explorer and double-click decisions.exe to open a running Command Prompt window.
2. If the Command Prompt window closes immediately after opening, then there is an issue with your Python code or the config.json file. In that case, navigate to the TargetXToWebAdMIT\dist folder and check the decisions.log file. If this file shows HTTP connection errors, this could mean that your API key, URL, or Cycle is incorrect.
3. Edit the config.json file to make sure the file name, directory paths, API keys, base URL, and cycle are correct.
4. Once verified, run the executable again.
5. If the executable continues to run, this means the JSON file is correct.
6. Run the Informatica tasks configured for this process to drop a csv file into the TargetXToWebAdMIT folder. The executable will pick up, process, and archive the file.
7. Navigate to the Archive folder under TargetXToWebAdMIT\Archive folder. You will see a timestamped_yourfilename.csv file.
8. Open the file, and you will see HTTP status codes printed in each row.
9. Successful loads would have a status code of 200, while unsuccessful loads would have a status code of 404 or 422.
10. The 404 status code could indicate several issues, including the Decision ID not existing in WebAdMIT, incorrect authentication methods (api_key), or CASID not found in WebAdMIT.
11. If error 422 is thrown, the applicant has already had a local status associated with their record.
12. Note that Decision Codes in WebAdMIT can only be updated via API for applicants that do not already have a Local Status associated with them.
13. If all rows show a 200 for each field, then the next step is to check prelaunch WebAdMIT to ensure the decision data was correctly applied in WebAdMIT.If all looks good, then close the running executable command prompt window and delete the archived file.

Setting the Python Executable as a Windows Service

To keep the script running indefinitely, the following steps are required to set up the Python executable as a windows service. For this purpose, you'll need to install a tool called NSSM (Non-Sucking Service Manager).

1. On your web browser on the Windows server meant to host the script, navigate to https://nssm.cc/download
2. Download the latest release of NSSM which is nssm 2.24.
3. This should download a zip file called nssm-2.24.zip.
4. Extract the zip file in the TargetXToWebAdMIT folder.
5. Open Command Prompt as an administrator, and within Command Prompt, navigate to TargetXToWebAdMIT\nssm-2.24\win64  (or win32, depending on your windows server).
6. Run the following command by replacing the paths to your Python executable and python (.py) file:
   • nssm install " TargetXToWebAdMIT" "PathTo\ TargetXToWebAdMIT\dist\decisions.exe" "PathTo\ TargetXToWebAdMIT\decisions.py"
7. If the service is successfully installed, it displays the following message in command prompt Service " TargetXToWebAdMIT" installed successfully!
8. Open services.msc in Windows as an admin and locate the TargetXToWebAdMIT service.
9. Start the TargetXToWebAdMIT service.

Testing the TargetXToWebAdMIT Service

1. To test the service, navigate to Testing the executable and perform steps 6 to 14.
   
2. If the test is successful, stop the TargetXToWebAdMIT service in services.msc and delete the archived file.
   
3. After all testing is completed and preparations are being made to move to production, perform the following steps to remove the service:
   
   • Open Command Prompt as an administrator, and within Command Prompt navigate to TargetXToWebAdMIT\nssm-2.24\win64 (or win32, depending on your Windows server).
     
   • Run the following in Command Prompt: nssm remove “TargetXToWebAdMIT”
     
   • A dialog will open to ask if you want to remove the service, click Yes, and it should say the service was successfully removed.
     
   • Open services.msc as an admin and refresh the services to ensure the TargetXToWebAdMIT service is not in the list of services.
     

Moving to Production

• After successful testing in prelaunch:
  
  • Delete the Build, Dist folders and main.spec file.
  • Update config.json with production API keys, URL, and cycle.
  • Rebuild the executable and set up the service.
  • Update the expression in the TargetX to WebAdMIT mapping to change the decision IDs to be production Decision IDs from WebAdMIT.
  • Update Informatica mappings to point to production TargetX.
  • Run the service and verify.

Cycle Over Cycle Changes

1. Cycle over cycle, the decision IDs change in WebAdMIT, hence the expression in the TargetX to WebAdMIT mapping will need to be updated with the new Decision IDs. Follow steps in the section “Retrieving the Decision IDs in WebAdMIT” to get the new decision IDs.
2. Change the cycle year in the expression for TargetX to WebAdMIT mapping to be the new cycle. Ensure the format is similar to “2025 - 2026” with spaces around the “-”
3. Edit the filter conditions for the Application mapping as well as the TargetX-WebAdMIT mapping to match filters required for the new cycle. These would be stored in the query options section for each of the sources for the mentioned mappings.
4. Stop the TargetXToWebAdMIT service.
5. Edit the config.json file in your TargetXToWebAdMIT and \ TargetXToWebAdMIT \dist folders.
6. Update the filename if you plan to use a new filename for the new cycle in the config.json file.
7. Update the cycle to correspond with the new cycle in the config.json file.
8. If you plan to use a completely new WebAdMIT user for the new cycle, change the API Key and cycle in the config.json file.
9. Save the config.json file in the TargetXToWebAdMIT and \ TargetXToWebAdMIT\dist folders with the changes.
10. Start the TargetXToWebAdMIT service.

Special Considerations

1. If you have multiple CASs that require decisions updated in WebAdMIT, then you will need one version of the script, config.json file and Informatica mapping set per CAS.
2. If your CAS cycles overlap, you will need two versions of the Informatica (Decision Ids will defer per CAS cycle) mappings per cycle. However, the script will remain the same. Ensure the filename output from the TargetX to WebAdMIT mapping task is the same between all cycles. Once the previous cycle ends, make sure to stop the linear flow containing the old mapping tasks.