Robotic Process and Automation

1. Create a Sequence to obtain user inputs display them using a

message box

Aim:

To Create a Sequence to obtain user inputs display them using a

message box

Procedure:

 Go to the UiPath website and sign up for a free community edition

of UiPath Studio.
 Once signed up, download and install UiPath Studio following the
instructions provided.
 After installation, open UiPath Studio and sign in using your
UiPath account credentials to activate the community version.
 Open UiPath Studio.
 Click on New Project > Process.
 Name your project (e.g., "UserInputMessageBox") and click
Create.
 In UiPath Studio, drag the Sequence activity from the Activities
pane into the main workflow. A sequence is a collection of
activities that are executed in order.
 To collect user inputs, use the Input Dialog activity.

· In the Activities pane, search for Input Dialog. Drag the Input
Dialog activity into the Sequence

Title: "Enter Information"

Label: "Please enter your name:"

Result: Create a new variable to store the input, such as username

 After collecting the inputs, use the Message Box activity to display
the inputs to the user.

Steps to add Message Box:

 In the Activities pane, search for Message Box.

 Drag the Message Box activity after the input dialog.
 In the Text field, use string interpolation to combine the inputs and
display them

Example: "Name: " + userName + "\nAge: " + age + "\nCity: " + city

Here's what the final sequence might look like:

1. Input Dialog for userName

2. Input Dialog for age
3. Input Dialog for city
4. Message Box displaying the inputs

Visual Representation in UiPath Studio:

1. Sequence:
o Inside the Sequence, you add three Input Dialog activities,
one for each input (name, age, and city).
2. Message Box:
o After gathering all inputs, a Message Box will show the
formatted string containing the user's input.

Run the Workflow:

 Press Run in the top menu to execute the workflow.

 The input dialogs will appear one after the other asking for the user
to input their name, age, and city.
 After all the inputs are provided, a message box will display the
collected information.

Example Workflow Details:

 1. Input Dialog 1:
o Title: "Enter Information"
o Label: "Please enter your name:"
o Output: userName
2. Input Dialog 2:
o Title: "Enter Information"
o Label: "Please enter your age:"
o Output: age
3. Input Dialog 3:
o Title: "Enter Information"
o Label: "Please enter your city:"
o Output: city
4. Message Box:
o Text: "Name: " + userName + "\nAge: " + age + "\nCity: " +
city

Output:

Result

Once you're satisfied with the workflow, you can save it and even
publish it if you're working within an enterprise environment that
requires deploying robots.
2.Create a Flowchart to navigate to a desired page based on a
condition

Aim:

To Create a Flowchart to navigate to a desired page based on a condition

Procedure:

1. Start a New Project in UiPath Studio

o Open UiPath Studio.
o Create a new project by clicking New Project → Process.
o Name the project (e.g.,
"NavigateToPageBasedOnCondition").
o Click Create to start a new process.

Step 1: Add the Flowchart

1. In UiPath Studio, go to the Activities panel and search for

Flowchart.
2. Drag the Flowchart activity into the Designer panel.

This will create a blank flowchart where you will add your decision-
making logic and actions.

Step 2: Define a Condition

1. Define a Boolean Variable:

Before starting the flowchart, create a variable that will hold the
condition. In the Variables panel:
o Create a Boolean variable, say condition, and set its default
value to either True or False depending on your test scenario.
 2. Add an Assign Activity (Optional):
You can optionally initialize this variable at the start of the
flowchart:
o Assign condition = True (or False for testing other scenarios).

Step 3: Add the Decision Point (If Activity)

1. Drag the If Activity:

o In the Flowchart, drag an If activity to represent the condition
check.
2. Define the Condition:
In the Condition field of the If activity, use an expression to check
the condition variable:

condition = True

Step 4: Define Actions for True and False Branches

Now you need to specify what happens if the condition is True or False.

True Branch:

 If condition is True, you will navigate to Page 1 (or perform the

corresponding action).
 To simulate navigating to Page 1, drag a Message Box activity into
the Then branch of the If activity.
 In the Message Box, type "Navigating to Page 1".

False Branch:

 If condition is False, you will navigate to Page 2 (or perform the

corresponding action).
 Similarly, drag a Message Box activity into the Else branch of the
If activity.
  In the Message Box, type "Navigating to Page 2".

Step 5: Finalize the Flowchart

At this point, the flowchart should have the following structure:

1. Start: Begin the flowchart.

2. Condition (If Activity): Check the value of condition.
o If True: Display "Navigating to Page 1".
o If False: Display "Navigating to Page 2".
3. End: End the flowchart.

Example: Full UiPath Flowchart

Here's the high-level breakdown:

 Variables:
o condition (Boolean) → Initialized to True or False.
 Flowchart:

1. Assign: condition = True (or False for testing).

2. If Activity:
Condition: condition = True
Then: Add a Message Box with "Navigating to Page 1".
Else: Add a Message Box with "Navigating to Page 2".

Step 6: Run the Workflow

1. Test with True Condition:

o Set the condition variable to True and run the workflow. It
should display a message box saying "Navigating to Page 1".
2. Test with False Condition:
 o Set the condition variable to False and run the workflow. It
should display a message box saying "Navigating to Page 2".

Output

Visual Representation in UiPath Studio

+---------------------------+

| Start |

+---------------------------+

+---------------------------+

| Assign: condition = True | (or False for testing)

+---------------------------+

+---------------------------+

| If condition = True? |

+---------------------------+

/ \

True / \ False

/ \
+-------------------+ +-------------------+

| Message Box: | | Message Box: |

| "Navigating to | | "Navigating to |

| Page 1" | | Page 2" |

+-------------------+ +-------------------+

+---------------------------+

| End |

+---------------------------+

Lab 3: State Machine Workflow for Random Number Comparison

Aim

To automate a random number guessing task using a State Machine

workflow in UiPath, simulating user input and feedback with UI
Automation Activities.

Procedure

Procedure

1. Initialize: Create a variable to store a random number using New

Random().Next(1, 101).
2. Prompt User Input: Use an Input Dialog activity to capture user
input.
3. Compare Numbers: Use an If activity to check:
o If the input equals the random number, display a success
message and end the workflow.
o Otherwise, provide feedback using Message Box for "Too
high" or "Too low".
4. Repeat Process: Transition back to the input prompt for incorrect
guesses.
5. End Workflow: Exit after the correct number is guessed.

Code
Assign RandomNumber = New Random().Next(1, 101)

<Activity x:Class="UiPath.Core.Activities.InputDialog"
DisplayName="Input Dialog">

<x:Members>

<x:Property Name="Title" Type="InArgument(System.String)" />

<x:Property Name="Label" Type="InArgument(System.String)" />

<x:Property Name="Result" Type="OutArgument(System.String)" />

 </x:Members>

<sap:VirtualizedProperty Name="Result"
Type="OutArgument(System.String)" />

</Activity>

<Activity x:Class="UiPath.Core.Activities.If" DisplayName="Compare

Numbers">

<x:Members>

<x:Property Name="Condition"
Type="InArgument(System.Boolean)" />

<x:Property Name="Then" Type="Activity" />

<x:Property Name="Else" Type="Activity" />

</x:Members>

</Activity>

<Activity x:Class="UiPath.Core.Activities.MessageBox"
DisplayName="Feedback">

<x:Members>

<x:Property Name="Text" Type="InArgument(System.String)" />

</x:Members>

</Activity>

Output
Result

The RPA bot successfully automates a number guessing task, providing

feedback and saving time while demonstrating State Machine and UI
Automation capabilities.
Lab Experiment 4: Building a Process Using UI Automation
Activities

Aim: To automate a simple web-based task using UI Automation

activities.

Procedure:

1. Identify the Target Application: Choose a simple web

application with basic login and navigation functionalities.
2. Record the Process: Use the recording feature of your RPA tool
to capture the steps involved in performing the task.
3. Analyze the Recorded Steps: Review the recorded steps and
identify the UI elements that need to be interacted with.
4. Create the Automation Workflow: Design a workflow using the
following activities:
o Browser Activities: Open the browser, navigate to the target
URL, and close the browser.
o Input Activities: Simulate keyboard input to enter
credentials.
o Click Activities: Simulate mouse clicks to interact with
buttons and links.
o Wait Activities: Introduce delays to ensure synchronization
with the application.
5. Configure the Activities: Set the appropriate properties for each
activity, such as the target element, input values, and wait times.
6. Test and Debug: Execute the workflow and verify its correctness.
Debug any errors or issues that arise.
7. Optimize the Workflow: Refine the workflow to improve its
efficiency and reliability.

Code Snippet (Example in UiPath):

XML
<Activity
x:Class="UiPath.Core.Activities.Browser.OpenBrow
ser" DisplayName="Open Browser"
sap:Virtualized="True" sap:Verifiable="True">
<x:Members>
<x:Property Name="BrowserType"
Type="InArgument(System.String)" />
<x:Property Name="Url"
Type="InArgument(System.String)" />
</x:Members>
<sap:VirtualizedProperty
Name="DisplaySettings"
Type="InArgument(UiPath.Core.Activities.Browser.
BrowserDisplaySettings)" />
<sap:VirtualizedProperty Name="NewSession"
Type="InArgument(System.Boolean)" />
</Activity>

Output:

Result: The RPA bot successfully automates the web-based task, saving
time and effort.

Lab Experiment 5: Creating an Automation Process Using System

Activities, Variables, and Arguments
Aim: To automate a system-level task, such as file operations or email
sending, using system activities, variables, and arguments.

Procedure:

1. Identify the Task: Determine the specific system-level task to be

automated, such as copying files, sending emails, or working with
Excel spreadsheets.
2. Design the Workflow: Create a workflow using the following
activities:
o Assign Activities: Assign values to variables to store input
data.
o System Activities: Use activities like "Copy File," "Send
Email," or "Excel Application Scope" to perform the task.
o Flow Control Activities: Control the flow of execution
using activities like "If," "For Each," and "While."
3. Configure the Activities: Set the appropriate properties for each
activity, such as file paths, email addresses, and Excel sheet names.
4. Test and Debug: Execute the workflow and verify its correctness.
Debug any errors or issues that arise.
5. Optimize the Workflow: Refine the workflow to improve its
efficiency and reliability.

Code Snippet (Example in UiPath):

XML
<Activity
x:Class="UiPath.Core.Activities.Assign"
DisplayName="Assign" sap:Virtualized="True"
sap:Verifiable="True">
<x:Members>
<x:Property Name="To"
Type="OutArgument(System.Object)" />
<x:Property Name="Value"
Type="InArgument(System.Object)" />
</x:Members>
</Activity>

Output:

Result: The RPA bot successfully automates the system-level task,

improving productivity.

Lab Experiment 6: Implementing Automation Using System Trigger

Aim: To automate a process based on a specific system event, such as a
file being created or modified.

Procedure:

1. Identify the Trigger Event:

o Determine the specific system event that will trigger the
automation. For example, a new file being added to a specific
folder.
2. Configure the System Trigger:
o Use the system trigger functionality of your RPA tool (e.g.,
UiPath, Automation Anywhere) to set up a rule that monitors
for the specified event.
o Configure the following parameters:
 File Path: The directory path to monitor.
 Event Type: The specific event to trigger on (e.g., File
Created, File Modified, File Deleted).
3. Design the Workflow:
o Create a workflow that will be executed when the trigger is
activated. This workflow can include various activities like:
 Opening the newly created file
 Processing the file content
 Sending an email notification
 Moving or copying the file
4. Connect the Trigger to the Workflow:
o Link the system trigger to the starting point of the workflow.

Example (UiPath):

XML Code:

XML
<Activity
x:Class="UiPath.Core.Activities.System.FileSyste
mTrigger" DisplayName="File System Trigger"
sap:Virtualized="True" sap:Verifiable="True">
 <x:Members>
<x:Property Name="FilePath"
Type="InArgument(System.String)" />
<x:Property Name="EventType"
Type="InArgument(UiPath.Core.Activities.System.F
ileSystemEventType)" />
<x:Property Name="TriggerType"
Type="InArgument(UiPath.Core.Activities.System.T
riggerType)" />
</x:Members>
</Activity>

Output:

Result:The automation successfully responds to the system event,

improving efficiency and productivity
Experiment 7: Automate Login to a Web Email Account

Aim: To automate the login process to a web-based email account using

an RPA tool.

Procedure:

1. Identify the Target Website: Determine the URL of the email

account's login page.
2. Record the Login Process: Use the recording feature of the RPA
tool to capture the steps involved in entering the username,
password, and clicking the login button.
3. Analyze the Recorded Steps: Review the recorded steps and
identify the UI elements that need to be interacted with (e.g., input
fields, buttons).
4. Create the Automation Workflow: Design a workflow using the
following activities:
o Browser Activities: Open the browser, navigate to the login
page, and close the browser.
o Input Activities: Simulate keyboard input to enter the
username and password.
o Click Activities: Simulate mouse clicks to click the login
button.
o Wait Activities: Introduce delays to ensure synchronization
with the website.
5. Configure the Activities: Set the appropriate properties for each
activity, such as the target element, input values, and wait times.
6. Test and Debug: Execute the workflow and verify that it
successfully logs into the email account. Debug any errors or
issues that arise.
7. Secure Sensitive Information: Implement secure storage
mechanisms for sensitive information like passwords.

Code Snippet (Example in UiPath):

XML
<Activity
x:Class="UiPath.Core.Activities.Browser.OpenBrow
ser" DisplayName="Open Browser"
sap:Virtualized="True" sap:Verifiable="True">
<x:Members>
<x:Property Name="BrowserType"
Type="InArgument(System.String)" />
<x:Property Name="Url"
Type="InArgument(System.String)" />
</x:Members>
<sap:VirtualizedProperty
Name="DisplaySettings"
Type="InArgument(UiPath.Core.Activities.Browser.
BrowserDisplaySettings)" />
<sap:VirtualizedProperty Name="NewSession"
Type="InArgument(System.Boolean)" />
</Activity>

Output:

Result:

 Automation of the login process saves time and effort

Experiment 8: Recording Mouse and Keyboard Actions

Aim: To record and replay user actions to automate tasks that involve
complex interactions with a user interface.

Procedure:

1. Start the Recording: Initiate the recording feature of the RPA

tool.
2. Perform the Actions: Manually perform the desired actions, such
as clicking buttons, typing text, and navigating through menus.
3. Stop the Recording: End the recording session.
4. Review the Recording: Review the recorded steps to ensure
accuracy.
5. Create the Automation Workflow: Use the recorded steps to
create a workflow with appropriate activities.
6. Test and Debug: Execute the workflow and verify that it performs
the actions correctly.

Output:

 The RPA bot replicates the recorded actions.

Result:

 Automation of complex tasks that require precise mouse and

keyboard input.

Experiment 9: Scraping Data from a Website and Writing to CSV

Aim: To extract data from a website and save it to a CSV file.

Procedure:

1. Identify the Target Website: Determine the URL of the website

containing the desired data.
2. Analyze the Website Structure: Inspect the HTML structure of
the website to identify the elements containing the data.
3. Create the Automation Workflow: Design a workflow using the
following activities:
o Browser Activities: Open the browser, navigate to the target
URL, and close the browser.
o Web Scraping Activities: Use activities like "Get Text,"
"Get Attribute," and "Data Scraping" to extract the required
data.
o File Activities: Create a CSV file and write the extracted
data to it.
4. Configure the Activities: Set the appropriate properties for each
activity, such as the target element, output file path, and CSV
delimiter.
5. Test and Debug: Execute the workflow and verify that the data is
extracted and saved correctly.

Code Snippet (Example in UiPath):

XML
<Activity
x:Class="UiPath.Core.Activities.Browser.OpenBrow
ser" DisplayName="Open Browser"
sap:Virtualized="True" sap:Verifiable="True">
</Activity>

<Activity
x:Class="UiPath.Core.Activities.Web.GetText"
DisplayName="Get Text" sap:Virtualized="True"
sap:Verifiable="True">
 <x:Members>
<x:Property Name="Selector"
Type="InArgument(UiPath.Core.Selector)" />
</x:Members>
</Activity>

<Activity
x:Class="UiPath.Core.Activities.File.Write CSV"
DisplayName="Write CSV" sap:Virtualized="True"
sap:Verifiable="True">
<x:Members>
<x:Property Name="FilePath"
Type="InArgument(System.String)" />
<x:Property Name="DataTable"
Type="InArgument(System.Data.DataTable)" />
</x:Members>
</Activity>

Output:

Result:

 Automation of data extraction and processing tasks

10. Implement Error Handling in RPA platform
Aim:
To implement error handling in a Robotics Process Automation (RPA)
process to ensure that the automation can gracefully handle
exceptions, log errors, and continue or stop the execution depending
on the scenario.
Procedure:

1.Setup the RPA Environment:

 Install an RPA tool such as UiPath, Automation Anywhere, or Blue

Prism.

 Create a new process or project in the RPA tool to implement error

handling.

2. Identify Error Scenarios:

 Think of potential errors that might occur in the process (e.g.,

webpage not found, element not found, database connection failure, or
network errors).
Consider errors such as:

 Missing files
 Incorrect data
 Timeout errors
 Application crashes

3.Use Try-Catch Blocks (or equivalent):

 In most RPA platforms, you can use Try-Catch or Try-Except

blocks to handle exceptions.
 Define a Try block for the activities that may fail and a Catch block to
handle the exceptions and log them.

4.Log Errors:

 Use activities like Log Message to log errors and Write to Log or
Write to File to record the exception details.

 You may also use custom logging or reporting activities

5. Handle Specific Errors:

 Catch specific exceptions (like network errors, element not found,

etc.) and take specific actions, such as retrying the operation, sending
notifications, or terminating the process.

 Use Throw to propagate exceptions when needed.

6.Define Fallback Actions:

 For example, in case of a timeout, you can retry the action a set
number of times before sending an email notification.

Or you can use Continue to skip a problematic step and proceed with
the rest of the automation.

7.Run and Test the Automation:

 Execute the automation and deliberately cause an error (e.g., by

disconnecting the network or using an invalid file path) to see if the error
handling works as expected.

 Check if the process recovers from the error or stops gracefully, and
the error is logged correctly.

Program:

<Sequence>
 <!-- Try block -->

<TryCatch>

<!-- Try block where the risky operation takes place -->

<TryBlock>

<ReadTextFile FilePath="C:\invalidfile.txt"
Output="fileContent" />

</TryBlock>

<!-- Catch block where errors are handled -->

<Catch Exception="System.IO.FileNotFoundException">

<LogMessage Message="File not found error occurred."

Level="Error" />

<WriteTextFile FilePath="C:\ErrorLogs.txt" Text="File not

found at: C:\invalidfile.txt" Append="True" />

<SendEmail To="admin@example.com" Subject="Error in RPA

Automation" Body="The file could not be found. Check logs for
details." />

</Catch>

<!-- Optional: Catch any other exception -->

<Catch Exception="System.Exception">

<LogMessage Message="An unexpected error occurred."

Level="Error" />
 <WriteTextFile FilePath="C:\ErrorLogs.txt" Text="Unexpected
error occurred." Append="True" />

</Catch>

</TryCatch>

</Sequence>

Output:

Result:

This experiment demonstrates how error handling in RPA ensures that

automations run smoothly and can recover from potential failures.

11. Web Scraping

Aim:
To perform a web scraping task using Robotics Process Automation
(RPA) to extract data from a website , automate the process, and store
the scraped data in a structured format.

Procedure:

1.Setup the RPA Environment:

• Install an RPA tool such as UiPath, Automation Anywhere, or

Blue Prism

• Set up the automation environment by creating a new process in

the RPA tool.

2.Choose a Website to Scrape:

• Select a website that has structured data such as a list of products,

news articles, or weather data. For example, a product list from an e-
commerce site like Amazon.

3.Identify the Elements:

• Use the built-in web scraping tool in the RPA software to capture
the data you want to scrape. This usually involves selecting elements on
the webpage such as titles, prices, and descriptions.

4.Create a Sequence or Flow:

• In the RPA tool, create a sequence or flow of activities that

include opening the browser, navigating to the URL, scraping the data,
and saving it.

5.Handle the Data:

• Use activities like Data Scraping, Get Text, or Extract Structured Data
in the RPA tool to retrieve the data
• Use activities like Write CSV or Write to Excel to save the scraped
data.

6.Run the Automation:

• Execute the process and observe the RPA tool scraping the
required data from the webpage.

7. Validate the Output:

• Check the stored data in the CSV or Excel file to ensure the data is
scraped correctly.

Program:

1. Open Browser Activity:

• • Use the Open Browser activity to launch the web page.

2.Data Scraping:

• Use the Data Scraping wizard in UiPath to capture tabular data

from the webpage. This will automatically create a data table variable.

3. Extract Data:

• • The wizard identifies the repeating pattern in the data (like rows
of product listings) and extracts each element such as the product name,
price, and description.

4. Write to Excel:

1.Use the Write Range activity to save the scraped data to an Excel
sheet.

<Sequence>
 <OpenBrowser Url="https://www.example.com/products"
BrowserType="Chrome"/>

<DataScraping Source="Open Browser" DataTable="scrapedData"/>

<WriteRange DataTable="scrapedData" FileName="C:\path\to\

output.xlsx" SheetName="Products"/>

</Sequence>

Output:

Result:

This experiment demonstrates how RPA can be used to automate the

process of web scraping, reducing manual effort and providing quick,
accurate results.

12. Email Query Processing

Aim:

To automate the process of reading and responding to email queries

using Robotics Process Automation (RPA) tools like UiPath, by
extracting key information from incoming emails and sending a tailored
response.

Procedure:

1.Set up the RPA Environment:

 Install an RPA tool like UiPath, Automation Anywhere, or Blue

Prism.

Create a new project or process to handle email query processing.

2.Configure Email Integration:

 Configure email integration by connecting the RPA tool to an email

server (e.g., Outlook, Gmail, or Office365) using IMAP/SMTP
protocols.

 In UiPath, use the Get IMAP Mail Messages or Get Outlook Mail
Messages activities to retrieve emails from a mailbox.

3.Extract Information from Emails:

 Once the emails are fetched, use string manipulation or regular

expressions to extract key information from the email body. For
example, extract customer name, query, and any required details (e.g.,
invoice number or issue description).

 Use If conditions or switch cases to decide how to respond to each

email based on its content (e.g., different responses based on keywords
like "invoice," "support," or "order").

4.Process the Query:

Based on the extracted information, the RPA bot can process the query.
For example:

 If the query contains the word "invoice," the bot can check for
invoice-related information.

o If it contains "support," the bot may reply with

troubleshooting steps or create a support ticket.

5.Send Automated Response:

 Use Send Outlook Mail Message or Send SMTP Mail Message

to send a response email to the user based on the query. Tailor the
response content based on the extracted data.

6.Error Handling:

 Implement error handling to manage issues such as email retrieval

failure or failed sending of emails.

 Log any errors for further troubleshooting.

7. Run and Test the Process:

 Execute the RPA process and test by sending different types of

emails to check if the automation correctly processes them and
responds appropriately.

Program:

<Sequence>

<!-- Get unread emails from Outlook -->

<GetOutlookMailMessages Folder="Inbox" ReadOnly="True"

Output="emails"/>
 <!-- Loop through the emails -->

<ForEach Item In="emails">

<!-- Extract query details from the email body -->

<Assign>

messageBody = Item.Body

</Assign>

<!-- Check if the email contains an invoice query -->

<If Condition="messageBody.Contains('invoice')">

<Then>

<!-- Send Invoice-related Response -->

<SendOutlookMailMessage To="sender@example.com"
Subject="Invoice Query Response" Body="Dear Customer, your invoice
details are being processed."/>

</Then>

</If>

<!-- Check if the email contains support query -->

<If Condition="messageBody.Contains('support')">

<Then>

<!-- Send Support-related Response -->

 <SendOutlookMailMessage To="sender@example.com"
Subject="Support Query Response" Body="Dear Customer, please
follow the troubleshooting steps: 1. Restart your system. 2. Try again."/>

</Then>

</If>

<!-- If no matching query is found -->

<If Condition="Not (messageBody.Contains('invoice') Or

messageBody.Contains('support'))">

<Then>

<SendOutlookMailMessage To="sender@example.com"
Subject="Query Received" Body="Dear Customer, we have received
your query and will get back to you shortly."/>

</Then>

</If>

</ForEach>

</Sequence>
Output:

This experiment demonstrates how RPA can be used to automate email

query processing, saving time and ensuring a faster response to customer
inquiries.