In 2025, USCIS started using Cloudflares “Verify you are human” mechanism. Due to that, the following bot will not work because it cannot by pass Cloudflare’s verification.

To get the latest case status(H1B, H4 etc.), one has to visit USCIS and check status by providing case ID. Straight and easy…

What if someone is so lazy(or so busy) to visit the site daily and check the status? Or what if there are more than one Case ID to check everyday?

Having a script that checks daily and notifies us would be so helpful 😀. USCIS does have API features but there is a process and policies on who can get access and use. Maybe it's not worth going through all that process if it's just for one case ID. As a workaround, a simple NodeJS script can be deployed to run daily and lookup the status on our behalf.

Idea:

1. Take the case ID as input and get the status of the case.

2. Notify with the latest status

3. Repeat the process (until stopped)

Have NodeJS and NPM installed already

#1 Script to run the process

Puppeteer’s NPM package will be used to automate running a headless version of browser and get details from USCIS website.

npm i puppeteer

// Checkout the documentation to use other browser than the default.
// Also, optional parameters may require in actual code depending on
// OS and version

Next, the snippet to take the case ID and give the status back.

// index.js
import puppeteer from 'puppeteer';
// Set the case ID
const id = 'YourCaseID';
const mainUrl = 'https://egov.uscis.gov';

const browser = await puppeteer.launch({
    headless: true,
    args: ['--no-sandbox']
});
const page = await browser.newPage();
// Setting user agent is required in headless mode
await page.setUserAgent('Mozilla/5.0 (Windows NT 5.1; rv:5.0) Gecko/20100101 Firefox/133.0');

await page.goto(mainUrl);

// Type into search box
await page.locator('#receipt_number').fill(id);

// Wait and click on first result

await page.locator('[name=initCaseSearch]').click();

const reqUrl = `${mainUrl}/csol-api/case-statuses/${id}`;

// Wait for API request
await page.waitForResponse(reqUrl);

// Capture the value from the element that shows the status

const textSelector = await page
    .locator('#landing-page-header')
    .waitHandle();
const fullTitle = await textSelector?.evaluate(el => el.textContent);

// Print the full title.
console.log(id, fullTitle);

await browser.close();

#2 Notifications:

This is a personal preference on how and when to get notified. Personally I have set up a text message service to get notified via text everyday with the latest status.

But there are other ways to setup and get notified via email(nodemailer) or Webhooks or text messages.

#3 Repeat the process

I have used a Linux VM to run this script. And so, a CRON job has been set up and scheduled to run on a daily basis at a specific time. This job runs the node script and sends out a text message with the latest status of my Case.

This CRON job can also be set up on any local Raspberry PI computer or any old computer. ** On windows a task scheduler does the similar trick.

When this is all put together, it works seamlessly and makes it convenient to track the status automatically.

Based on the operating system and version, puppeteer might run into issues while initializing a headless browser. Use the debug options available to get around the issue.

Note: USCIS uses cloudflare bot prevention mechanism. This may cause the script to fail as it does not by pass the cloudflare verification page.

Cheers ✌

Primary focus of this article is on how the headers are constructed and message is sent using Connect-Rest method. The construction of headers logic is same and can be used to other operations not only on Service Bus integration but also with other Azure services (with slight modifications)

Things needed for this integration:

• A Pega application (with outbound internet connection)

• An Azure Service Bus with at least one queue

• Necessary permissions and roles to post message to queue

Steps involved:

1. Gather and prepare required properties

2. Construct Authorization header

3. Call the rest connector to post message

Gather and prepare required properties

In this step, collect all the required properties of service bus queue after all the required permissions are granted.

A http queue url, SharedAccessKey are required to proceed further.

The http queue url can be grabbed from the Queue properties in the Azure portal. It will be in this format.

// Replace __SERVICEBUSNAMESPACE__ and __QUEUE__ with your values.
https://__SERVICEBUSNAMESPACE__.servicebus.windows.net/__QUEUE__

Collect the SharedAccessKey from the Azure portal Service Bus Queue properties. If required, coordinate with your Azure administrator to generate one.

Construct Authorization header

This is the crucial part of the implementation. Azure Rest API services require the authorization header to be constructed and passed in a certain format. This is something common across most of the Azure services.

Go through this documentation on the requirement for constructing the authorization header for Azure services. We will be generating a SAS token for this use case.

"Java step"

In order to generate a SAS token, we will be needing crypto and hashing functions. So to use them, we will need to write some java code.

// Replace __SERVICEBUSNAMESPACE__ and __QUEUE__ with your values.
String strURL = "https://__SERVICEBUSNAMESPACE__.servicebus.windows.net/__QUEUE__";
String keyName = "Send"; // Shared key name. This is a constant required to post a message.
// Replace __SHAREDACCESSKEY__ with your value.
String key = "__SHAREDACCESSKEY__"; // Shared Access Key from Azure portal
long epoch = System.currentTimeMillis()/1000L;
int week = 60*60*24*7;
String ttl = Long.toString(epoch + week);
byte[] keyBytes = key.getBytes();
try {
  String encodedURL = java.net.URLEncoder.encode(strURL, "UTF-8");
  String strToSign = encodedURL + "\n" + ttl;
  javax.crypto.Mac sha256_HMAC = javax.crypto.Mac.getInstance("HmacSHA256");
  javax.crypto.spec.SecretKeySpec secret_key = new javax.crypto.spec.SecretKeySpec(keyBytes, "HmacSHA256");
  sha256_HMAC.init(secret_key);
  byte[] rawHmac = sha256_HMAC.doFinal(strToSign.getBytes("UTF-8"));
  String hash = org.apache.commons.codec.binary.Base64.encodeBase64String(rawHmac);
  String encodedHash = java.net.URLEncoder.encode(hash, "UTF-8");
  String sasToken = "SharedAccessSignature sr=" + encodedURL + "&sig=" + encodedHash + "&se=" + ttl + "&skn=" + keyName;
  tools.putParamValue("sasToken", sasToken); // Put the generated token onto a parameter
}
catch (java.security.NoSuchAlgorithmException e) {
  e.printStackTrace();
}
catch (Exception e){
  System.out.println("Error - " + e.getMessage());
}

The above code will generate a token and put onto "sasToken" parameter. This parameter will be later used in the REST connector to set it to Authorization header.

It is recommended to use Rule Utility Function instead of Java step in the Activity rule.

Call the rest connector to post message

Now, the final part is to call the REST service to post the message to queue. The documentation for the same can be found in this link.

"Connect-Rest rule"

Create a Connect-REST rule and provide the base url and resource path.

// Base url. Replace __SERVICEBUSNAMESPACE__ with your value.
http{s}://__SERVICEBUSNAMESPACE__.servicebus.windows.net

// Resource path. Replace __QUEUE__ with your values.
/__QUEUE__/messages

Next, supply the details in POST method. Authorization, BrokerProperties and Content-Type are minimum required headers. Check the documentation for more options. May have variations depending on setup and requirements.

BrokerProperties contain identifiers and some necessary values. Refer to this link for more details.

Finally, set the request body.

In the above screenshot, the BrokerProperties in the header(Param.BrokerProperties) and the Request message in the Message data(Param.RequestMessage) were referenced through parameters. The values for these parameters were set in the Activity prior to calling this Connect-REST rule.

Both the parameters were set with JSON strings.

The above screenshot is the activity that constructs required Parameters and call the Connect-REST rule.

First step sets the values to parameters in JSON strings format.

Second step is to construct the Authorization header value (Java snippet in the above section)

Third step is to call the Connect-REST rule with POST method.

If everything is setup correctly and the activity is run, the service will return 201 http status code which is a success.

Similarly, other operations on the Service Bus queues/topics can be performed with slight modifications.

Hope this helps!! Give it a try and feel free to reach out with any questions.

Cheers!!

Windows 11 virtual desktops are very useful for accessing from anywhere in the world. They can be connected through the browser, remote desktop app and even on mobile devices too.

Different entities created as part of virtual desktop creation are:

1. Azure subscription

2. Resource group

3. Workspace

4. Host pool

5. Application Group

6. Virtual desktop

To start with, an Azure account is required. If not done already, a new account needs to be registered at Azure Portal. Complete the registration process (registration information, payment process etc.)

A default subscription may be created during the initial registration, either it can be used or a new subscription can be created for the virtual desktop. Call it 'AVD-SUB' for this example.

An active subscription is required to create any resource in Azure

Next, create a resource group under the subscription selected/created in the above step. Call it 'AVD-SUB-RG' for this example. After that, create a new Azure virtual network(search for "virtual network" in the Azure portal) and call it 'AVD-VIRTUAL-NETWORK'.

Make sure to select the right subscription (AVD-SUB) and resource group (AVD-SUB-RG) for this new virtual network. Select the region closest or appropriate to your usage.

Next, search for Azure Virtual Desktop and open the section. Start with creating a host pool. Select the subscription, and resource group and give it the name 'AVD-HP' for this example.

Select the host pool type as 'Personal', this will create one machine per login. Select the region same as the virtual network created in the above step. In the next steps, skip creating the Virtual machine and Workspace by selecting the option 'No' and complete the Host pool creation.

Session Hosts

To create a session host(virtual desktop), go to the host pool and select 'Session hosts' and create one.

• Select the same subscription, resource group and location as before.

• Select the Image as 'Windows 11' (or of your choice) and the machine size according to your need.

• Give the number of VMs as 1.

• Select the virtual network created in the above steps.

• Under Domain to join, select 'Azure Active Directory' and provide details for the Administrator account.

Leave all other settings as they are and create the virtual machine.

Now, under the host pool, select Application Groups and select the one that is created by the system. Then, go to Assignments from the menu and add a new assignment. Select the user(s) and submit.

The next step is to assign a role for these user(s) to access the virtual desktop. For that, go to the resource group (AVD-SUB-RG) and select Access Control (IWM) from the menu.

Go to Role assignments and add a new role assignment. Select 'Virtual Machine User Login' and add the user(s) under members. Review and complete the assignment process. Repeat the role assignment for 'Virtual Machine Administrator Login' to assign admin user(s).

Workspaces

Workspace is a section to host the remote desktop and any other apps. These will be accessed from the web session or through an app. To enable remote desktop for the virtual desktop created, it needs to be listed in the workspace.

Go to Azure Virtual Desktop and navigate to Workspaces from the menu.

Add a new workspace, select the right subscription, resource group and region and finish the creation process leaving other settings as is.

Now, go to the newly created workspace and navigate to Application Groups from the menu. Add a new Application group and select the one created by the system as part of Session host creation and finish the process.

RDP Properties

Go to the host pool and select RDP Properties from the menu. Here you can alter the settings for how the virtual desktop should work and perform. One important step is to make sure a specific setting is there in the Advanced section.

Check for the setting targetisaadjoined:i:1; under RDP properties under the Advanced section. If not already present add this to the beginning of the text present in the box.

Now all the steps are completed. Make sure the virtual desktop is created and running (host pool dashboard page)

Launch the virtual desktop

• Go to https://aka.ms/avdweb

• Login with virtual desktop credentials provided.

• The desktop will be displayed under Workspace.

• Click and it will start a remote session to the virtual desktop.

• If needed login with the user credentials created during setup.

Hope you got the setup right and can launch the desktop successfully. There are also some youtube tutorials on setting up the Azure Virtual Desktop. Check them too.

https://youtu.be/aPEibGMvxZw

https://www.youtube.com/watch?v=jMAanEp-ugI&t=60s

If you are Enterprise level systems administrator, you may want to check this book on how to manage Azure Virtual Desktop Environments. Link to Book

Feel free to leave a suggestion or comment. Thank you until next time.

When you start in the software industry or any industry for that matter, your primary focus should only be on learning. Learn as much as you can, gain knowledge and give your best at work.

Use all the resources available, talk to your mentors, peers or anyone and know a new thing every day. It is also important to share what you learned with others. Don’t keep it to yourself.

There are plenty of resources related to your field of work in form of books, videos, courses etc. Check out them, learn and gain proficiency in your area of interest.

Money is not a priority

When you start earning, you start to think about financial goals, commitments and spending on fantasies. This sometimes leads to a mindset where you feel like what you are earning is not enough.

Clear your mind about money and focus on your journey. Give your best in the initial years of your career and things will eventually turn out for you.

Once you flow through your career, several opportunities will come to you and slowly those convert into investments. Being diligent is the key.

As the time passes by and you accumulate some money, learn new things about investing and start with the money you earned so far.

Some of the recommended books on investing in stocks can be found in this link, check them out.

Do not compare with others

Never compare yourself to anyone in any aspect. Your only objective should be learning and giving your best. Gain as much knowledge as you can and share the same with others. This will help you grow and makes you a better engineer.

Get the right tools

Having the right tools for your job and learning purpose is very important and makes a lot of difference. It also motivates to push further. If you are in software industry, get you self a nice laptop, monitor, back pack. No need to go crazy and spend lot of money., just decent enough stuff should do the work.

And of course a nice water bottle to stay hydrated.

Do not change jobs

After a year or two, you may start feeling like you have done enough at your current workplace and it is time to change jobs. Unless you have a strong reason to change, do not think about a job change for at least 4-5 years. Because it is going to be an almost fresh start again at the new workplace.

Gain the knowledge and experience and when the time comes(have a good reason), make a move.

Go all in at work

When you start as a fresher, your primary objective should be learning and giving your best at work. It is not just an 8-hour job, stretch for long hours, spend more time at work and try to finish it with quality. Do not have a mindset like you have to work only regular hours.

It all pays off in future

All the hard work you did initially in your career is going to pay off in the future. The more knowledge and experience, the better future you will have.

Share your thoughts and tips with other new comers. Take care!!

There could be a scenario where we have to refer a parameterized Datapage in a HTML rule. But the syntax to access or refer a Datapage with parameters doesn't work.

D_PageName[param1: value1, param2: value2].PropertyName

However, there is a workaround to refer properties from parameterized Datapages.

Note: It is not recommended to use this method. Better way is to construct a new Datapage or a normal page with all values and use as reference in HTML rule.

By setting the required parameters using java scriplet prior to using a reference tag, system will load the Datapage and the properties will be constructed in HTML rule.

<!-- Sample snippet to refer parameterized Datapages -->

<%
   // Set all parameters required for datapage
  tools.putParamValue("OperatorId", "administrator@pega.com");
 // Set all other params required for datapage
%>
    <div>
        <h1>Referencing Parameterized Data Page in HTML Rule</h1>
        <div>
            Name: <pega:reference name="D_pxOperatorDetails.pyUserName" />
        </div>
      <div>
            Email: <pega:reference name="D_pxOperatorDetails.pyAddresses(Email).pyEmailAddress" />
        </div>
      <div>
            TimeZone: <pega:reference name="D_pxOperatorDetails.pyDefaultTimeZone" />
        </div>
    </div>

And the result looks like this

Hope this helps and be very careful to refer properties from parameterized Datapage using this method. This is not supported and there is no official documentation.

If there any questions, feel free to reach me.

Cheers!

Let us see how we can implement this speech recognition API

We shall modify Pega pulse in such a way that it takes notes by listening to user.

We will be using Web speech API for this use case. To learn more about this API, please check this MDN Documentation

For this use case we need a javascript file. This file will contain functions and logic to invoke speech recognition API. These functions will convert speech into text and assign the text to textarea in Pulse section.

Steps to configure speech recognition API

1. Modify Pega pulse section and include two buttons 'Start' and 'Stop'. These buttons will activate and deactivate speech recognition. Add two empty labels in the same section.

2. Give Tour ID's to these two buttons and labels.

   • Start button - startSpeech
   • Stop button - stopSpeech
   • Label1 - speechInterim
   • Label2 - speechStatus

3. Provide a tour id of value 'pulseNote' to textarea field in Pega pulse section.

4. Create a javascript binary file in Pega and include this .js file in scripts and styles tab of container harness rule.

5. Get the code from this Gist and paste in the javascript file and save the rule.

6. Save all the rules and test the functionality. When the start button is clicked for the first time, browser will ask permission for microphone. Make sure this permission is granted.

At this point, browser will capture your speech and convert it to text and assign this text to textarea in Pega pulse section. To stop the speech recognition, just click on Stop button.

It is just a sample to get started with, this speech recognition can be applied to wide range of use cases in Pega workflows and in non pega applications as well.

I hope this gave a good idea to explore browser API's in Pega applications and would like to hear other interesting use cases you applied this API in.

Reach out to me if you encounter any issues or have any questions.

Thank you.

In the above use case, the information about user closing the pop up needs to be captured and stored. This is where the concept of cookies play well and is apt for this requirement.

Be cautious with cookies as they can have adverse effects

A custom cookie in a Pega application can be set in one line

tools.getRequestor().getRequestorPage().getPage("pyHTTPResponseHeaders")
.putString("set_cookie", "customCookie=someValue; Path=/prweb; Secure;");

Cookie has to be set on pyHttpResponseHeaders page property on pxRequestor page. Use set_cookie property to set cookie value.

But where does this line go?

This has to be placed in a Java step in an activity that is called from UI. It can be on click of a button or from XHR or fetch request.

Link to code

When this activity is invoked, the cookie will be sent in response. It can be verified in browser developer tools.

There should also be a logic in application to set or reset value of this cookie whenever user takes action. For example, in the above use case, when user closes the pop up, the value of cookie should be updated to indicate that pop up has been closed.

This way when the same user logs in to application again, pop up will not be displayed. The logic to check the cookie value and decide whether to show pop up or not should be implemented manually, most likely this code goes into Javascript file in portal harness. But it may differ based on application needs and design.

Lastly, there should be application logic to reset this cookie value, so that user will get the pop up again (Ex: when a new feature is introduced in next release).

Use custom cookies diligently and only when required. Pega doesn't recommend to use custom cookies as they may impact overall application

Feel free to leave a suggestion or comment. Thank you until next time.

This article only highlights the way to connect to Azure Redis server from NodeJS. For full list of commands and usage please refer to Redis and Microsoft documentation

At the time of this article is published, the version of Redis is 4.0.1

To connect to Azure Redis server using host name and primary key, Microsoft clearly described how to create a Redis client in their Javascript sample .

const client = redis.createClient(6380, hostName, 
{auth_pass: azureKey, tls: {servername: hostName}});

However, this works only until Redis version 3.0.0. In the later versions of Redis, the mechanism of passing parameters to createClient has changed. The parameters are now required to be passed in below format.

const client = redis.createClient({
    socket: {
        host: hostName,
        port: 6380,
        tls: true
    },
    password: azureKey,
});

It is also required to call connect method on the client object. Otherwise the connection will not be established

client.connect();