UIPath RPA Certification

IndexOutOfRangeException

(Exception) Occurs when the index of an object is out of the limits of the collection

Simulate (input method)

(Input method) How: Uses technology of target app to send instructions. Clicking and typing occur instantly Strengths: Works in background. Much faster. Can automatically erase previous written text. Can work on other activities during executions Limitations: Does not support hotkeys. Lower compatibility

Flow switch

Activity selects the next node depending on the value of an expression; Flow Switch can be seen as the equivalent of the procedural Switch activity in flowcharts. It can match more than 12 cases by starting more connections from the same switch node

Clear collection (lists)

Clears a specified collection of all items

Join data tables

Combines rows from two tables by using values common to each other, according to a Join rule, which is specified in the JoinType property

UI frameworks

-Default (Proprietary method that works with all interfaces) -Active accesibility (recommended when using legacy software, if the default framework does not work as expected) -UI automation (recommended when using newer applications in case the default framework does not work as expected)

Six stages of RPA implementations

1) Prepare RPA 2) Solution design 3) Build RPA 4) Test RPA 5) Stabilize RPA 6) Constant improvement

Arguments of global exception handler

1) errorInfo with In direction (Stores information about the error that was thrown and the workflow that has failed. The level of the error to be logged can be set in the Log Message activity.) 2) result with out direction (used for determining the next behavior of the process when it encounters an error)

Output panel

Displays valuable information about the execution of the automated process: messages logged, errors, and warnings

Principles an implementation should follow

-Reliable -Extensible -Maintainable -Efficient

Correct sequences of statuses in Transaction execution of Queue item

1) In Progress 2) Failed 3) Retried 4) Successful

On element vanish (UI element)

A container that enables you to perform one or multiple actions after a specified UI element vanishes

Process (orchestrator)

A package that has been allocated to a certain environment

Schedule (orchestrator)

A process that is configured for an execution that is not immediate, but according to a schedule. Multiple configurations are possible when it comes to schedules

Set transaction status (queue)

(queue) Changes the status of the transaction item to Failed (with an Application or Business Exception) or Successful. As a general approach, a transaction failed due to Application Exceptions will be retried, and a transactions failed due to Business Exceptions will not be retried.

Set transaction progress (queue)

(queue) Enables the creation of custom progress statuses for In Progress transactions. This can be useful for transactions that have a longer processing duration, and breaking down the workload will give valuable information

Get transaction item (queue)

(queue) Gets an item from the queue to process it, setting the status to 'In progress'.

Statuses of queue item (queue)

(queue) Queue item can have one of the following statuses: -New -In progress -Failed -Successful -Abandoned -Retired -Deleted

Add transaction item (queue)

(queue) The robot adds an item in the queue and starts the transaction with the status 'In progress'. The queue item cannot be sent for processing until the robot finalizes this activity and updates the status.

Add queue item (queue)

(queue) When encountering this activity in a workflow, the robot will send an item to the designated Queue and will configure the time frame and the other parameters

RetryInterval (retry scope)

(retry scope) Specifies the amount of time between each retry

NumberOfRetries (retry scope)

(retry scope) The number of times that the sequence is to be retried

Visual tree hierarchy (selector)

(selector) Displays a tree of the UI hierarchy and enables you to navigate through it, by clicking the arrows in front of each node. By default, the first time when you open UI Explorer, this panel displays all opened applications, in alphabetical order.

Anchor Base (selector)

(selector) Has two parts, one to locate the anchor UI element (Find image/Element), and the second to perform the desired activity. Very useful in cases in which the attribute values are unreliable/unstable, but there is a UI element that is stable and is linked to the target UI element

Find children (selector)

(selector) This activity can identify all the children of an element that is more stable. Since its output is the collection of children, you will need to come up with a mechanism to identify only the target UI element (using one of its attributes, that makes is unique between the children, but wouldn't be enough to identify it universally)

Relative selector

(selector) This activity will basically incorporate the information about the anchor's selector in the selector of the target UI element. (However, the new selector will probably need additional editing, as some nodes of the first selector will still be in the new one. The solution is to have that part (like a dynamic ID) removed, and the selector will stabilize using the anchor's selector)

Test activity

Used for running a test on the currently selected activity. When clicked, the Locals panel opens displaying the variables and arguments in scope. Execution logs generated by the Test Activity action are visible in the Output panel. Exceptions in Studio can be bubbled up, which means that the exception may be passed to parent containers in case it may be handled by them.

Step into (debugging)

Used to debug activities one at a time. When this action is triggered, the debugger opens and highlights the activity before it is executed

Breakpoints

Used to purposely pause the debugging process on an activity which may trigger execution issues. Setting a condition and/or hit count turns the simple breakpoint to a conditional one. Does not effect process execution

Image (Recording)

Used to record virtualized environments (such as VNC, virtual machines, Citrix, and more) or SAP. It permits only image, text and keyboard automation, and requires explicit positioning.

Split types (string manipulation)

(split types) -Split (Splits on character and creates new array of strings) -Double split (Performs a split to left and right of designated area) -Trim (Deletes leading or trailing spaces) -Substring (Splits on index and takes number of characters designated) -Replace (Changes specified character type to another) -Remove (Removes text indicated) -Left/right (Retrieves text from the index left/right) -Left/right+substring (Gets the text from the index counting from the left/right of what remains after substring trim)

Selector wildcard characters

* (Replaces zero or more characters) ? (Replaces a single character)

Values that can be assigned to the result argument (global exception handler)

-Continue (Exception is re-thrown) -Ignore (Exception is ignored, and the execution continues from the next activity) -Retry (The activity which threw the exception is retried. Use the RetryCount method for errorInfo to count the number of times the activity is retried) -Abort(The execution stops and throws the exception after running the current Global Exception Handler)

Three ways to create an argument

-From the body of an activity (Right-click a field and select Create In Argument or Create Out Argument from the context menu. Alternatively, press Ctrl+M or Ctrl+Shift+M. The Set Arg field is displayed.) -From expression editor (Select a part of the expression and press Ctrl+M or Ctrl+Shift+M. The Set Arg field is displayed) -From the properties panel (In the Designer panel, click Arguments. The Arguments panel is displayed)

Sheet activities (excel app integration)

-Get Workbook Sheet: (reads the name of a sheet by its index) -Get Workbook Sheets: (extracts the sheet names and stores them ordered by index) -Copy Sheet: (copies a sheet in an Excel file and pastes either in the same Excel file or in a different one specified)

Cell color activities

-Get cell color (reads the background color or a given cell in an Excel file and stores it as color variable output) -Set range color (changes the background color of all the cells in a given range. The input is a color variable)

Auto anchor position

-If selected, the Bottom case is not considered. -Searches for the UI element to the left, right or bottom of the container. -The closest one is selected - If multiple elements are found at equal distance from the anchor, the target is selected in this order: Right, Left, Bottom.

Fuzzy search

used to identify nearly any type of attribute in the top-level tags of selectors. Selector's fuzzy search capabilities enable you locate strings based on a pattern, rather than on an exact match to your input. This results in a more flexible method of identifying elements and validates selectors according to multiple attributes, even if some are prone to change during the automation process.

Process types

-Manual and repetitive (Process performed by users and most of the process steps are the same for all cases or transactions) -Semi-manual and repetitive (Process which is performed by users and also involves an automation mechanism like Macro, Outlook plug-ins, etc.) -Automated (Process which is already automated) -Manual but Not Repetitive (Process which is performed by users. The process steps for each case will be different)

InvokeMethod Properties

-MethodName: Assign the method name to this property -TargetObject: When we want to invoke non-static methods, we need first to create an object that contains the method to execute -TargetType: When we want to invoke static methods, we specify the type that contains the static method to execute -GenericTypeArguments: When we want to invoke a generic method, we specify generic types in this collection -Parameters: The parameter collection of the method to be invoked -Result: The return value of the method execution

4 categories of processes

-No RPA -Semi-automation -High-cost RPA -Zero-touch animation

Selector tags

-Nodes in the selector XML fragment -Correspond to a visual element on the screen -First node is the app window -Last node is the element itself -Stored in properties panel of activities (input>target>selector

Automation complexity

-Number of screens -Types of applications -Variations / scenarios -Types and number of inputs Low: Easily created and requires small customizations. Desktop and web apps, scraping. 1-2 weeks Medium: Possibly requires the transfer of data between apps. 3-4 weeks High: Requires programming skills (string manipulations, working with arrays, data tables, collections, data formatting, exception handling, terminal emulators). 4-6 weeks.

Data types

-Numeric (used to store numbers) -Boolean (true or false) -Date and Time -String (Used to store text) -Collection (array, list, dictionary) -GenericValue (Int, String, Boolean, DateTime)

Email best practices

-Outlook and Exchange activities are easier to use since they don't require connection parameters. -If Outlook is configured, it's usually your best choice since it requires the least amount of setting up while offering extra features and being compatible with any email protocol -System.Net.Mail.MailMessage

Capabilities of Orchestrator

-Provisioning (creates and maintains connection with robots) -Deployment (ensures the delivery of the workflows for execution, either immediately or using schedules) -Configuration (enables the creation, configuration and maintenance of groups of robots and the execution of tasks) -Queues (the data that needs to be processed is broken down to indivisible operations called transactions. Queues can store any number of transactions and they facilitate their distribution, execution and monitoring) -Monitoring (keeps track of robot identification data and maintains user permissions) -Logging (stores and indexes the logs to an SQL database and/or ElasticSearch) -Inter-connectivity (acts as the centralized point of communication for 3rd party solutions or applications, and can be used for storing activity packages, libraries and other assets)

Methods of extracting PDF text

-Read PDF Text: (Reads all characters from a specified PDF file and stores them in a string variable) -Read PDF with OCR (Reads all characters from a specified PDF file and stores it in a string variable by using OCR technology)

Pivot table activities (excel app integration)

-Refresh Pivot Table: (refreshes a pivot table in an Excel file. This is useful when pivot table source data changes, as the refresh is not automatic) -Create Pivot Table: (creates a pivot table using a specified sheet and given parameters)

Retrieving (dictionary)

-Returns the dictionary item by its key [VarName.Item(key)] -Returns an Int32 value of the number of dictionary items [varName.Count] -Checks if the item with the given key exists in the Dictionary and returns a Boolean result [VarName.ContainsKey(Key)] -Checks if an item with a given key exists in the dictionary and returns a Boolean result and the value if found [VarName.TryGetValue(Key, Value)]

Process fitness

-Rule-based -Automatable and/or repetitive process -Standard input -Stable

What a procedure explains

-Who is responsible for each part of the process -When each part of the process needs to occur -How to handle exceptions -The specifications applicable to each part of the process

Full text (output method)

(Output method) How: Get Full Text Activity Implication: This output method is the default method and good enough in most cases. This method offers the option to ignore the hidden message and capture only the visible text. Strengths: It is the fastest, it has 100% accuracy and can work in the background. Moreover, it can extract hidden text (for example, the options in a drop-down list). Limitations: On the other hand, it doesn't support virtual environments and it doesn't capture text position and formatting.

Steps of deploying a process

1) Click add (Deploy window is displayed) 2) Select package 3) Select package version 4) Select environment 5) Click create

Steps to create a new library

1) Click start 2) Click new library 3) Enter the name, location, description, and program language 4) Create workflow 5) Publish the library to orchestrator or a custom field

How to create a project based on a template

1) Click the template. A window with details about the template opens 2) Select the version to use from the lower-left corner of the window (by default, the latest version), and then click Use Template.

Add queue item

1) Create queue 2) Create automation project 3) Drag an add queue item to designer panel 4) In queue name field, add queue name 5) Select priority 6) ItemInformation enables adding data to queue item 7) create argument and change its name, type, and value

Automation lifecycle

1) Developers build the process, test & debug pieces of it locally (Studio) 2) The process is published to the Development Orchestrator and tested again end-to-end 3) The project folder is committed (not packaged) to a Master Library folder (on VCS) 4) The IT/ RPA Operations team creates the project package for QA. This step is intended to be an additional safety measure: the automation source code is inspected (by a different entity) before being packaged and run by robots 5) If any issue is revealed during the tests, the steps above are repeated 6) Once all QA tests are passed, the package is pushed to a Production environment - Process Pckgs (Prod) 7) When the Process goes live, the process package is deployed to the production Robots and executed

Create a queue

1) In queues page, click add 2) Enter name 3) Decide unique reference 5) Decide auto retry 6) Click add

Command line interface

A console application which can request to start jobs, and waits for their output. It is a direct client of the Robot service, and communication is done through a WCF channel

On element appear (UI element)

A container that waits for a UI element to appear and enables you to perform multiple actions within it

GIT

A distributed, open source version control system. It has good support for branching, merging, and rewriting repository history. The pull request is one popular feature that allows teams to collaborate on Git branches and efficiently review each other's code. It is the most widely used version control system in the world and is considered the modern standard for software development

Selector

A feature that enables the identification of the User Interface elements through its address and attributes stored as XML fragments. The element identification is done to perform specific activities in an automation project. Selectors are generated automatically every time we use an activity that interacts with graphical user interface elements

Environment (orchestrator)

A group of robots configured in Orchestrator. Processes can be allocated to individual robots, but it's more effective to allocate them to environments. A robot can be part of more than one environment, provided they are in the same service

Faulted (Job state)

A job is in this state if it failed to start or the process threw an unhandled error during execution.

Successful (Job state)

A job is in this state if it has been executed correctly by the Robot and it has finished running, or has been stopped using the Stop button.

Running (Job state)

A job is in this state if it has established a connection to the Robot and it started executing the assigned process.

Pending (Job state)

A job is in this state if it is queued for the same Robot or it is trying to establish a connection with the Robot (only different jobs on the same Robot can be queued).

Stopped (Job state)

A job is in this state if it stopped (by using the Kill button, or by canceling it from the system tray) before it finished executing without throwing any errors.

Asset (orchestrator)

A piece of data stored in Orchestrator for the use of robots. Single value can be accessed and used by all robots. Value per robot can only be used by the indicated robot: -Text (Strings) -Bool (true or false values) -Integer (whole numbers) -Credential (usernames and passwords that the Robot requires to execute particular processes. Encrypted with the AES 256 algorithm)

Job (orchestrator)

A process that has been sent for execution to some or all of the robots in the environment. (To start a job, simply navigate to Jobs from the menu on the left, choose a process and either select the robots you want to execute the job from the environment, or allocate the job dynamically)

Package (Orchestrator)

A project developed in UiPath Studio that is published to Orchestrator. Multiple versions of the same project can be stored and used. Any version of it can be downloaded from Orchestrator, in the .nupkg format -active: deployed to at least an environment; -inactive: not deployed (this type can be deleted)

ContinueOnError property

A property that specifies if the execution should continue even when the activity throws an error -While using data scraping - so the activity doesn't throw an error on the last page (when the selector of the 'Next' button is no longer found) -When we are not interested in capturing the error, but simply in the execution of the activity

Lookup data table

Activity enables you to search for a provided value in a specified DataTable and returns the RowIndex at which it was found. This activity can also help you return the value found in the cell that has the row coordinates specified in the RowIndex property and the column coordinates specified in the Target Column property category.

Assign activity

Activity that enables you to assign a value to a variable. You can use this activity to increment the value of a variable in a loop, sum up the value of two or more variables and assign the result to another variable, assign values to an array, and so on.

Break activity

Activity that enables you to stop the loop at a chose point, and then continues with the next activity

Retry scope

Activity that retries the contained activities as long as the condition is not met or an error is thrown. Is used for catching and handling an error, and simply retryies the execution instead of providing a more complex handling mechanism. It can be used without a termination condition, in which case it will retry the activities until no exception occurs (or the provided number of attempts is exceeded)

Add log fields

Adds custom log fields to the Robot Execution Logs. The new log fields created via this activity are added for every Log Message execution throughout the entire workflow, unless a Remove Log FIelds activity is used

Properties panel

Allows viewing and changing the properties of a selected activity. The information shown is contextual, as different activities can have different properties

Imports panel

Allows viewing the imported namespaces, and also adding new ones

State machine

An abstract machine consisting of a finite number of pre-defined states and transitions between these states. At any point, based on the external inputs and conditions verified, it can be in only one of the states. It can be used with a finite number of clear and stable states to go through.

Queue (orchestrator)

Containers that can hold an unlimited number of items. In Orchestrator they will store items and allow their distribution individually to robots for processing, and monitoring the status of the items based on the process outcomes. When creating a queue, you set the maximum number of retries (the number of times you want a queue item to be retried) and the Unique Reference field (select Yes if you want the transaction references to be unique). Once a queue was created, these settings can not be modified.

If activity

Contains a statement and two conditions. The first condition (the activity in the Then section) is executed if the statement is true, while the second one (the activity in the Else section) is executed if the statement is false.

Break (debugging)

Debugging action that allows you to pause the debugging process at any given moment. The activity which is being debugged remains highlighted when paused. Once this happens, you can choose to Continue, Step Into, Step Over, or Stop the debugging process

Ignore (debugging)

Debugging action that can be used to ignore an encountered exception and continue the execution from the next activity so that the rest of the workflow can be debugged. This action is useful when jumping over the activity that threw the exception and continuing debugging the remaining part of the project.

Restart (debugging)

Debugging action that is used for restarting the debugging process from the first activity of the project. It is available after an exception was thrown and the debug process is paused.

Focus (debugging)

Debugging button that helps you return to the current breakpoint or the activity that caused an error during debugging. The button is used after navigating through the process or after the process is paused, as an easy way to return to the activity that caused the error and resume the debugging process

Test bench

Debugging option that allows for the creation of automation building blocks, which can then be tested and added to the final workflow. It is used for testing activities, working with variables and debugging the process. All this is done in workflow, a temporary sequence that's not part of the current project and that is discarded when closed.

Slow step (debugging)

Debugging option that enables you to take a closer look at any activity during debugging. While this action is enabled, activities are highlighted in the debugging process. Moreover, containers such as flowcharts, sequences, or Invoke Workflow File activities are opened. This is similar to using Step Into, but without having to pause the debugging process

Locals Panel

Debugging panel displays properties or activities and user-defined variables and arguments. The panel is only visible while debugging. Right-click an argument, variable or property of the currently executing activity to add it to the Watch panel and monitor its execution throughout the debugging process.

Call Stack Panel

Debugging panel that displays the next activity to be executed and its parent containers when the project is paused in debugging. The panel is displayed during execution in debug mode and it gets populated after using Step Into, Break, Slow Step, or after the execution was paused because an error or a breakpoint was encountered.

Watch panel

Debugging panel that is only visible during debugging. It can be set to display the values of variables or arguments, and values of user-defined expressions that are in scope. These values are updated after each activity execution while debugging. Variables or arguments can be added to the Watch panel in the following ways: ---In the Watch panel, click the Add Watch field and type the name of the variable or argument; ---In the Locals panel, right-click a variable or argument and select Add to Watch; ---In the Variables or Arguments panel, right-click a variable or argument and select Add Watch.

Retry (debugging)

Debugging process that re-executes the previous activity, and throws the exception if it's encountered again.

Execution trail (debugging)

Debugging ribbon button, that, when enabled, it shows the exact execution path at debugging. As the process is executed, each activity is highlighted and marked in the Designer panel, showing you the execution as it happens -executed activities are marked and highlighted in green -activities that were not executed are not marked in any way -activities that threw an exception are marked and highlighted in red

Flow decision

Flowchart layouts are good for showcasing important business logic and related conditions like nested If statements or If... Else If constructs. There are situations where a Flowchart may look good even inside a Sequence.

Invoke process

Executes a UiPath process that is available for the local machine. Can be used to run local packages, as well as processes in Orchestrator, if a connection is available. It runs in Synchronous mode, meaning that the parent process waits for the child process to complete before resuming. Logs generated by the child processes only contain the outcome of the execution and errors, and are written in the same place as the ones from the parent and can be differentiated by the ProcessName field in local logs and Process column in Orchestrator

Run parallel process

Executes a UiPath process that is available for the local machine. a separate job is created for each process. It runs in Asynchronous mode, meaning that the parent process is only responsible for starting the child ones. After that happens, both processes run independently from each other.

Substring

Extracts a substring from a string using the starting index and the length [VarName1.Substring(StartIndex, length)]

Solution Architect

Is in charge of defining the Architecture of the RPA solution. Translates the requirements captured by the functional analysts, creating the architecture and design artifacts. They lead, advises, and are responsible for the developers' team delivery.

Inputs

The data that goes in the process

Native Citrix (recording)

Is the equivalent of the Desktop recorder, but for Citrix environments. Only use this in your Native Citrix automation projects

Context menu

Menu that enables you to perform several operations on your workflow, be it a sequence or a flowchart. You can display it by right-clicking an activity inside your workflow

Full join

Merge of data tables where all rows are kept from DataTable1 and DataTable2, regardloss of whether the join condition is met. Null values are added into the rows from both tables that don't have a match

Left join

Merge of data tables where all rows from DataTable1 and only the values from DataTable2 which meet the Join rule are kept. Null values are inserted into the column for the rows from DataTable1 that don't have a match in the DataTable2 rows

Merge data table

Merges the Destination with the Source, indicating whether to preserve changes and how to handle missing schema in the Source Input: -Destination: DataTable object to which the source DataTable is merged -MissingSchemaAction: Specifies the action to take if there are schema issues when merging the two DataTables -Source: The DataTable object to be added to the destination DataTable

Fine-tuning of selectors

The process of refining selectors in order to have the workflow correctly executed in situations in which the generated selector is unreliable, too specific or too sensitive with regards to system changes. It mainly consists of small simple changes that have a larger impact on the overall process, such as adding wildcards, using the repair function or using variables in selectors.

Robot liscencing statuses

Only available for attended robots, displayed in front of the license type in the Type column -Green icon (Liscenced. Hovering over the icon displays the exact time and date the liscence was acquired) -Red icon (unliscenced)

Desktop (recording)

Recording suitable for all types of desktop apps and multiple actions. It is faster than the Basic recorder, and generates a container (with the selector of the top-level window) in which activities are enclosed, and partial selectors for each activity

Basic (recording)

Recording that generates a full selector for each activity and no container. The resulted automation is slower than one that uses containers and is suitable for single activities.

IsMatch (RegEx)

RegEx method that indicates whether the specified regular expression finds a match in the specified input string

Replace (RegEx)

RegEx method that match a regular expression pattern with a specified replacement string

Loops

Repititions of a set of operations based on a given condition

Transaction

Represents the minimum (atomic) amount of data and the necessary steps required to process the data, as to fulfill a section of a business process. We call the data atomic because once it is processed, the assumption is that we no longer need it going forward with the business process

Universal search

Search bar that enables you to find snippets, activities, variables, arguments, imports, project dependencies, and files in your current project. Searches return results from all workflow files, including files that are closed

Contains (String)

Type of string that checks whether a specific substring occurs within a string. Returns true or false [VarName.Contains("text")]

Join (string)

Type of string that concentrates the elements in a collection and displays them as a string [String.Join("|",CollVarName1)]

dynamic selector

Selector that uses a variable or an argument as a property for the attribute of your target tag. This allows the selector to easily identify a target element based on the value of the variable or argument, and not an exact string, which might change, depending on interactions inside your automation project. the variable or argument can be changed to interact with a different element, without changing the selector itself.

Concat (String)

Type of string that concentrates the representation of two specified objects [String.Concat(VarName1,VarName2)]

Format (string)

Type of string that converts the value of objects to strings and inserts them into another text [String.Format("{0} is {1}". VarName1, VarName2]

IndexOf (string)

Type of string that returns the zero-based index of the first occurence of a character in a string [VarName1.IndexOf("a")]

Robot

UiPath's execution agent that enables you to run workflows built in Studio

Adding (dictionary)

Step of creating an item to an existing dictionary. Need to use invoke code activity [VarName.Add(key,value)]

Removing (dictionary)

Step of subtracting an item from a dictionary. Can be used in an 'Assign; activity [VarName.Remove(Key)]

Argument

Store data dynamically, they have the same data types and they support the same methods. They pass data between workflows, and they have an additional property for this - the direction from/to which the data is passed. The direction can be In, Out and In/Out.

Invoke code

Synchronously invokes VB.NET or C# code, optionally passing it a list of input arguments. This activity can also return out arguments to the caller workflow

4 main states of REFramework

(REFramework) 1) Initial state 2) Get transaction data state 3) Process transaction state 4) End process state

Full selector

(Selector type) -Contain all the tags and attributes needed to identify a UI element, including the top-level window -Generated by the Basic Recorder -Recommended when switching between multiple windows

Partial selector

(Selector type) -Don't contain the tags and attributes of the top-level window, thus the activities must be enclosed in containers -Generated by the Desktop Recorder -Recommended when performing multiple actions in the same window

Retried (queue status)

(queue status) the item failed with an application exception and was retried. After the Robot finishes retrying the item, the status changes to Failed or Successful, according to your workflow

Deleted (queue status)

(queue status) the item has been manually selected from the Transactions page and marked as deleted; an item with this status can no longer be processed

Successful (queue status)

(queue status) the item was processed and sent to a Set Transaction Status activity, which changed its status to Successful

Failed (queue status)

(queue status) the item did not meet a business or application requirement within the project and was therefore sent to a Set Transaction Status activity, which changed its status to Failed

In progress (queue status)

(queue status) the item was processed with the Get Transaction Item or the Add Transaction Item activity; when an item has this status, your custom progress status is also displayed, in the Progress column

Modify text

Updates a text value using modifications including find and replace, trim, and combining (concatenating) with another text value -Find and replace -Combine text -Trim -Text to upper/lowercase

New (queue status)

(queue status) the item has just been added to the queue with the Add Queue Item activity, or the item was postponed, or a deadline was added to it, or the item was added after an attempt and failure of a previous queue item with auto-retry enabled

Abandoned (queue status)

(queue status) the item remained in the In Progress status for a long period of time (approx. 24 hours) without being processed

Postpone transaction item (queue)

(queue) Adds time parameters between which a transaction must be processed

Triggers (Orchestrator)

Enable you to execute jobs in a preplanned manner, at regular intervals (time triggers) or whenever new items are added to your queues (queue triggers). Can also configure triggers to not run on non-working days

Default package sources

Enabled by default: -Orchestrator -Local Disabled by default -Official -Go!

Bulk upload items (orchestrator)

Enables you to bulk upload queue items into a specific queue, directly from a .csv file. To do that, first upload your file into your Orchestrator instance for a specific queue. After the file is successfully processed, the contained items are uploaded into the queue according to the selected strategy. Please note that the file must be populated beforehand using predefined formats so that the upload operation is successful.

Processes page (orchestrator)

Enables you to deploy an uploaded package as a new process, manage previously created processes, and keep all your processes up to date with the most recent package versions. This helps you distribute packages across all users and robots in your organization and execute processes faster from the Jobs page.

Tenant (orchestrator)

Enables you to isolate data, with only one instance of Orchestrator. This feature facilitates automating different departments from your company and ensures the desired authorization of Orchestrator data per department.

Application exception

An error rooted in a technical issue

ApplicationException

(Exception) Describes an error rooted in a technical issue, such as an application that is not responding

NullReferenceException

(Exception) Error that usually occurs when using a variable with no set value

ArgumentException

(Exception) Is thrown when a method is invoked and at least one of the passed arguments does not meet the parameter specification of the called method

SelectorNotFoundException

(Exception) Is thrown when the robot is unable to find the designated selector for an activity in the target app within the TimeOut period

ImageOperationException

(Exception) Occurs when an image is not found within the TimeOut period

TextNotFoundException

(Exception) Occurs when the indicated text is not found within the TimeOut period

Benefits of orchestrator

-Accessibility and version control -Transactional processing -Efficient planning and execution -Securely storing assets -Monitoring

CSV Activities (excel app integration)

-Append to CSV (add the info from a DataTable to a CSV file, creating it if it doesn't exist. The activity does not overwrite existing data) -Read CSV (reads all entries from a CSV file and store them in a DataTable) -Write CSV (overwrites a CSV with the information from a DataTable)

Robot connection statuses

-Available (UiPath Robot is not running a process and is free to be used) -Busy (UiPath Robot is running a process. You cannot edit the username, machine, and license type of a busy robot) -Unresponsive (UiPath Robot and Orchestrator have not communicated in the last two minutes. This value can be configured using the Scalability.Heartbeat.FailureThreshold parameter) -Disconnected (The UiPath Robot service is not running)

Automatically generated activities (auto recording)

-Click (Generated when click a button: enables you to add a time delay before or after the action, change the click type and add key modifiers) -Type into (Generated when typing into a text field or any editable UI element: enables you to add a time delay before or after the action or between key strokes, change the text at any point, and empty field) -Select item (Generated when you select an item from a drop-down list or combo box: Enable you to add a time delay before or after the action, and change the selected item) -Check (Generated when a radio button or check box is clicked: Enable you to add a time delay before or after the action, and select or unselect the check box)

GIT Commands

-Commit (Commits changes to head) -Push (Sends changes to master brance of remote repository) -Pull (Fetches and merges changes from remote server to working directory) -Merge -Branches

Range activities (excel app integration)

-Delete Column (removes a column from an Excel file based on the name) -Insert Column (inserts a blank column in an Excel file, at a certain position) -Insert/Delete Columns: (either adds blank columns or removes existing columns, based on the specified change type) -Insert/Delete Rows: (either adds blank rows or removes existing rows, based on the specified change type) -Select Range: (selects a specific range in an Excel file. In general, it is paired with another activity that performs a certain manipulation over the selected data) -Get Selected Range: (outputs a given range as String) -Delete Range: (removes a specified range from an Excel file) -Auto Fill Range: (applies a given formula over a given range in an Excel file) -Copy Paste Range: (copies and pastes an entire range (values, formulas and formatting) from a source sheet to a destination sheet) -Lookup Range: (searches for a value in all the cells in a given range) -Remove Duplicate Range: (deletes all duplicate rows from a given range)

Stages of the RPA journey

-Discovery -Build -Manage -Run -Engage -Measure

Selector editor panel

-Displays the selector for the specified UI object and enables you to customize it. -The bottom part of the panel displays the actual XML fragment that you have to use in a project. -The top part of this panel enables you to view all the nodes in a selector and eliminate the ones that are not necessary by clearing the check box in front of them. -Selecting a node here displays its attributes in the Selector Attributes and Property Explorer panels.

When fine-tuning of selectors is required

-Dynamically generated selectors (value of attribute change with each visit) -Selectors being too specific -System changes (version of app or another element changes when app is updated) -Selectors using IDX (Multiple similar elements)

REFramework features

-Settings (keeps track of such data by reading them from a configuration file (Config.xlsx) and storing them in a Dictionary object (Config) that is shared among the different states. This offers an easy way to maintain projects by changing values in the configuration file, instead of modifying workflows directly) -Logging (use Log Message activities that output details of what is happening in each step of the execution) -Business exception and application exception (If the cause of the problem can be fixed by restarting applications, then the framework automatically does that and tries again to process the same transaction. These exceptions are called Application Exceptions. If the problem is related to the data itself or an underlying business requirement then that transaction is skipped and the framework proceeds to the next transaction. These exceptions are called Business Rule Exceptions

Variable/Argument naming conventions

-Snake case (First1_Name2, first_name2) -Camel case (FirstName, lastName) -Pascal case (First1Name2, First1Name) -Kebab case (First-Name, First-Name1)

Execution target options (orchestrator job)

-Specific robots: option enables you to execute a job on a certain robot only -Allocate dynamically: enables you to execute the same process multiple times on whatever robot becomes available first. Jobs are placed in a pending state in the environment workload based on their creation time. As soon as a robot becomes available, it executes the next job in line.

Dynamic selector form

-Tag (target tag) -Attribute (target attribute) -{{Value}} (the name of the variable or argument which holds the property of the element you want to interact with)

Join Data Tables Wizard

-This wizard helps you configure the properties of the Join Data Tables activity. It can be opened by using the Join Wizard button in the body of the activity in the Designer panel. -From the upper section of the wizard, you can select both of the DataTable variables you wish to use in the operation, the Join type, and the output variable

Uploading items into a Queue

1) In the Queues page, click the corresponding More Actions button of your desired queue, and then Upload Items. The Upload Items window is displayed 2)Click Browse and select the desired .csv file 3)Click Upload. If your file is compliant with the supported formatting rules, the upload operation is successful. 4)Select the upload strategy. Click Upload. The items are added into your queue according to the previously selected strategy. 5)If you used the Process All Independently option and there are unprocessed items, the Upload button becomes Download and enables you to download a .csv file containing the unprocessed items.

How to browse for .Net variable types

1) In the Variables panel, from the Variable Type drop-down list, select Browse for Types. The Browse and Select a .Net Type window is displayed 2) In the Type Name field, type a keyword for the variable you are looking for 3) Select one and click OK. A new variable is created with the selected type and is displayed in the Variables panel

Debugging steps

1) Run the workflow and find the execution errors 2) Select "Validate" from Execute tab and remove any validation errors 3) Add breakpoints at the activities throwing the exceptions and at the invoked workflows that contain the errors 4) Run in debug mode

Steps of installing new packages

1) Select manage pacakges 2) Select All Packages category 3) Locate and find desired package 4) Install package 5) Accept liscence and save

Steps to create a template

1) Under New Project, click Template 2) Enter the name and description, and the location where to create the template 3) Click Create and your template opens in Studio

sequence of how robots select queue items

1)If items have a deadline: Priority->deadline with same priority 2)If items don't have a deadline: Priority-> first in, first out for items of same priority

Process

A set of interrelated or interacting activites that transform inputs into outputs.

Regulation Expression Builder (RegEx)

A specific search pattern that can be used to easily match, locate and manage text. -Enables you to identify multiple target elements with a single search execution.

Library

A system of activities with a well-contoured business function, which makes them suitable for sharing and reusability. In Orchestrator, this functionality implies a centralized location where all libraries are stored, namely the Libraries page, accessed by selecting its tab from the Packages page. From here libraries are shared across teams and tenants and can be used by any user with access.

REFramework

A template that helps you design (automation) processes. At a barebones minimum, a framework should offer a way to store, read, and easily modify project configuration data, a robust exception handling scheme, event logging for all exceptions and relevant transaction information. It is implemented as a state machine, which is a type of workflow that has two very useful features: -States that define actions to be taken according to the specified input -Transitions that move the execution between states depending on the outcomes of the states themselves

Global exception handler

A type of workflow designed to determine the behavior when encountering an execution error at the project level. Only one for the entire project can be used. Only uncaught exceptions will reach the Exception Handler.

Invoke method activity

A way to implement a code that is outside of the standard built-in activities. You can use this activity to invoke a method of a class. The class does not need to be part of the workflow or use any of the workflow base classes. The Invoke Method calls a public method of a specified object or type

Delay activity

Activity enables you to pause the automation for a custom period of time (in the hh:mm:ss format). (This activity proves itself quite useful in projects that require good timing, such as waiting for a specific application to start or waiting for some information to be processed so that you can use it in another activity)

Expression editor

Accessible with the Ctrl + Shift + E keyboard shortcut when used inside activity input fields. It is also available from the Properties panel, from fields that require inputting text, and from the body of an activity, by adding text directly in the required fields. Expressions can be written on multiples lines. Keyboard shortcuts for creating variables and arguments directly in expressions are available.

Organization unit (orchestrator)

An entity in Orchestrator that corresponds to a business unit. The same Orchestrator instance can have multiple organization units configured, each of them having separate robots, environments, queues, assets and so on

Business exception

An error rooted in the fact that certain data which the automation project depends on is incomplete, missing, outside of set boundaries (like trying to extract more from the ATM than the daily limit) or does not pass other data validation criteria (like an invoice amount containing letters). The mechanism of handling this exception has to be separately defined by the developer (based on the rules set by the process owner), or it can be reduced to stopping the execution of the process.

Resumed (Job state)

An intermediary state that is triggered if the conditions (user intervention, intermediary process completion) of a fragmented workflow have been met. It is triggered by the corresponding activities in Studio.

Terminating (Job state)

An intermediary state that is triggered if you clicked the Kill button in Orchestrator. By default, a cleanup background job runs once every three hours and transitions to Failed the jobs that have been in a Terminating state for at least one day.

Stopping (Job state)

An intermediary state that is triggered if you clicked the Stop button in Orchestrator.

Suspended (Job state)

An intermediary state that is triggered with the purpose of allowing user intervention or completion of an intermediary process. It is triggered by the corresponding activities in Studio.

Go to file

Bar searches and opens files part of the current project folder. .xaml files are opened in the Designer panel in Studio, while other files, such as screenshots or Excel files, are opened with their respective default application on your machine. Double-click or press Enter to open a file.

Tracepoint

Breakpoints with set logged messages. When the tracepoint is reached during debugging, the message is logged at trace level. Conditional tracepoints have a set condition or hit count, and a logged message. The message is logged when the condition is met the number of times stated in the hit count field

Check true/false

Checks if a given Boolean expression is true/false and throws an exception with a custom message at runtime when the expression is false/true. This activity can be used in the Retry Scope activity.

Text exists

Checks if a text is found in a given UI element. This is useful when UI elements are not accessible otherwise than as images

Namespace

Classes of activities or variables that can be used in a project

Web (recording)

Designed for recording in web apps and browsers, generates containers and uses the Simulate Type/Click input method by default

Project Panel

Displays the contents of the automation project, enabling the project organization through creation of subfolders and management of dependencies. Also allows importing workflows and opening file locations

Outline panel

Displays the project hierarchy, all available variables and nodes. You can go to a specific activity by selecting it

Property explorer

Functionality of the UI Explorer that displays all the attributes of a certain UI element, including those that are not displayed in the selector, like position, visibility, innertext, and so on

UIPath Studio

Helps you design automation workflows visually, quickly and with only basic programming knowledge. Where the automated processes are built in a visual way, using the built-in recorder, drag & drop activities and best practice templates.

Log activities (debugging)

If enabled, debugged activities are displayed as Trace logs in the Output panel. Logs are automatically sent to Orchestrator if connected, but you can have them stored locally by disabling the Allow Development Logging option from the Settings tab in the Add or Edit Robot window. By default, the debugger logs activities so that each step appears in the Output panel. If you decide to disable the Log Activities option for debugging, Trace logs are not displayed in the Output panel. In the case of a normal execution with no errors, you only get to see the debug execution start and end times. However, adding a Log Message can help you determine where issues might occur.

Exists in collection (lists)

Indicates whether a given item is present in a given collection by outputting a Boolean as the result

Flowchart

Individual activities are a bit more difficult to read and edit, but the flows between them are much clearer. Used when decision points and branching are needed in order to accommodate complex scenarios, workarounds and decision mechanisms.

RPA Developers

On complex projects, several will collaborate to automate all processes

Command Palette

Opened by using the Ctrl + Shift + P, F3 keyboard shortcuts, or by clicking the search button. It incorporates the Add activity, the Universal search, the Go to file, and Jump to activity search bars

Add activity search bar

Opened using the Ctrl + Shift + T keyboard shortcut. You can search for activities in installed packages, and add them after the selected activity in the file. The bar automatically assigns keyboard shortcuts to the first five results, and remembers your previous findings

Excel application scope

Opens an Excel workbook and provides a scope for Excel activities. When the execution ends, the specified workbook and the Excel application are closed. Excel can be open when this is ran. Can be configured to write the output of the activities in the container in a different file. If the same workflow deals with information from two or more Excel files, an Excel Application Scope has to be used for each file.

Project dependencies

Packages linked into a specific project, containing activities, either default or custom. Dependencies are contextual and take into consideration each project's definition, including the activities that it uses, variables, input/output arguments. Therefore, a dependency is set only if it has at least one reference in the project's definition

Find references panel

Panel displays results for references you search for in your project. To find every place in the project where an element is referenced, right-click it and select Find References.

Designer panel

Panel displays your current automation project, enables you to make changes to it, and provides quick access to variables, arguments and imports.

Snippets panel

Panel enables you to easily reuse automations. It includes, by default, multiple samples and snippets.

Resources panel

Panel in Studio can load assets, queues, processes, and entities, provided that the Robot is connected to Orchestrator. (If the Robot connected to Orchestrator is of type Standard, then the Resources panel can display only the Classic folder which has this Robot provisioned. If the Robot connected to Orchestrator is of type Standard, then the Resources panel can display only the Classic folder which has this Robot provisioned).

Activities panel

Panel shows available activities that can be added to the current workflow. You can search for activities by name and description using the search box at the top of the panel, navigate through them using navigation keys, and press Enter to add the selected activity to the currently opened file.

Immediate panel

Panel that is only visible during debugging, and it can be used for inspecting data available at a certain point during debugging. It can evaluate variables, arguments, or statements.

Multiple assign

Performs multiple assign actions, enabling you to assign values to multiple variables without the need to use multiple Assign activities. A common use case for this activity is initialization before large processes, sparing the user of the need to configure multiple Assign activities.

Sequence

Process flows in a clear succession. Decision trees are rarely used. Activities are easier to read and maintain, thus, they are highly recommended for simple, linear workflows

Dispatcher and Performer model

Process involving queues is separated: -Dispatcher is the stage in which data is taken and fed into a queue in Orchestrator, from where it can be taken and processed by the robots -Performer is the stage in which the data is processed

Data manipulation

Process of modifying, structuring, formatting, or sorting through data in order to facilitate its usage and increase its management capabilities

Background process

Process that doesn't need to interact with UI elements on the screen but rather relies on background processes to pass along information. UIAutomation activities should not be used in these project types. Multiple such processes can simultaneously run on a machine, even if a foreground process is already running.

Foreground process

Process used when your automation project needs to interact with UI elements. These processes heavily rely on UIAutomation activities. You can only execute one foreground process at a time.

Version control systems

Provides a developer an effective way to develop larger projects that require collaboration between multiple users

Picture in picture (debugging)

Ribbon option in the Debug tab is available for both executing and debugging processes or libraries in a separate session on your machine. If enabled, the process starts in a separate session whenever you select Run or Run File, Debug or Debug File. Having the option to run a process in Picture in Picture (PiP) can be very useful in attended automation.

Development robot

Robot that has the features of an unattended robot, but it should be used only to connect Studio to Orchestrator, for development purposes

Non-production robot

Robot that is similar to unattended robots, but they should be used only for development and testing purposes

Standard robot

Robot that works on a single Standard Machine only. It is a good choice when the machine on which the robot runs is known and will never change

Floating robot

Robot that works only on any machine defined in orchestrator. It is a good choice when human users work in shifts on the same machine or on different machines, and when virtual machines are being regenerated often. Only attended and development robots can be floating robots

Unattended robot

Run unattended in virtual environments and can automate any number of processes

Jump to activity

The Jump to activity search bar part of Command Palette helps find and focus specific activities in large workflows. When opened, the Jump to activity bar displays the list of all activities in the .xaml file currently focused in the Designer panel. Activities in the Jump to activity bar are arranged in the following order: container, parent, and child activities.

Switch

The Switch activity enables you to select one choice out of multiple, based on the value of a specified expression. By default, the activity uses the integer argument, but you can change it from the Properties panel, from the TypeArgument list.

Step over (debugging)

The action debugs the next activity, highlighting containers (such as flowcharts, sequences, or Invoke Workflow File activities) without opening them. This action comes in handy for skipping analysis of large containers which are unlikely to trigger any issues during execution.

Robot Agent (Tray)

The actual user interface of the Robot. It is a WPF application which displays the available jobs in a system tray window. As a client of the Robot service, it can request to start or stop jobs, and change settings through a WCF channel, based on user input. It enables you to view all the available automation processes, start and stop a process, view and manage running foreground and background processes, view and download processes, view the status of connection to orchestrator, search for available processes, and open logs

Debugging

The process of identifying and removing errors that prevent the project from functioning correctly. It is recommended to perform during the design stage of the automation project, at activity, file and project level

UI explorer

The functionality in UiPath Studio that allows analyzing and editing selectors. It contains a status button showing users the state of the selector, a Visual Tree Panel that displays a navigable UI of each application running at that moment, as well as the selected UI element. It displays all the available tags and attributes and gives the option to check them in or out

Control flow

The order in which individual statements, instructions, or function calls are executed or evaluated in a software project

Iterative process

The steps of the process are performed multiple times, but each time different data items are used. This kind of process can be implemented with a simple loop, but it has the disadvantage that, if a problem happens when processing one item, the whole process is interrupted and the other items remain unprocessed

Linear process

The steps of the process are performed only once and, if there is the need to process different data, the automation needs to be executed again. They are usually simple and easy to implement, but not very suitable to situations that require repetitions of steps using different data

Transactional process

The steps of this processes repeat multiple times over different data items. However, the automation is designed so that each repeatable part is processed independently. These repeatable parts are then called transactions. Transactions are independent from each other, because they do not share any data or have any particular order to be processed

RPA

The technology that allows computer software to mimic actions typically performed by humans interacting with digital systems to execute business processes. It is non-invasive, easy to scale, and and is future proof. -Emulates human actions -Operates any application with a user interface -Processes data in structured formats -Works continuously -Has high accuracy

Macro activities (excel app integration)

These activities can execute macros that where already defined in the Excel file, or can invoke macros from other files. Please note that these activities work with .xslm files. -Execute Macro -Invoke VBA: macro from another file

Revision statuses (queue status)

These statuses let you perform version control but only of queue items that have been abandoned or have failed with an application or business exception. These statuses have to be manually set per item, by an assigned reviewer -None (default) -In review -Verified -Retried

Try Catch

This activity catches a specified exception type in a sequence or activity, and either displays an error notification or dismisses it and continues the execution Try: The activities performed which have a chance of throwing an error Catch: The activity or set of activities to be performed when an error occurs. Please note that multiple errors and corresponding activities can be added in this block Finally: The activity or set of activities to be performed after the Try Catch block. This section is executed only when no exceptions are thrown or when an error occurs and is caught in the Catch section

Step out (debugging)

This debugging action is used for stepping out and pausing the execution at the level of the current container. Completes the execution of activities in the current container, before pausing the debugging. This option works well with nested sequences.

Continue on exception (debugging)

This debugging feature is disabled by default. When disabled in the ribbon, it throws the execution error and stops the debugging, highlights the activity which threw the exception, and logs the exception in the Output panel. If a Global Exception Handler was previously set in the project, the exception is passed on to the handler. When enabled, the exception is logged in the Output panel, the execution continues.

Recording

This functionality enables you to easily capture a user's actions on the screen and translates them into sequences. These projects can be modified and parameterized so that you can easily replay and reuse them in as many other processes as you need. All user interface elements are highlighted while you record, as you can see in the following screenshot, so that you can be sure the correct buttons, fields or menus are selected. -Automatically saved as .png files

UiPath Assistant

Tool where individuals can easily access, manage and run automations with just a couple of clicks. Can send commands to start or stop jobs and change settings, based on user input.

Attended robot

Triggered by user events, and operates alongside a human, on the same workstation. Started from robot tray or command prompt

Invoke workflow file activity

Triggers another workflow from within the current activity

QueueItem variables

Variable that stores an item which has been extracted from a container of items, a queue. This extraction is generally made with the purpose of further using the queue items in various scenarios. Each entry read by the QueueItem variable is stored in a queue item and added to the designated queue in Orchestrator.

Find element (UI element)

Waits for the specified UI element to appear on the screen (to be in the foreground) and returns it as a UiElement variable

Wait element vanish (UI element)

Waits for the specified UI element to disappear from the screen. It's an alternative to Find Element, for example when the disappearance of an element (a loading sign) is more reliable then the appearance of another element

SVN

With a centralized system, this version control system stores all files and historical data on a central server. The developers commit their changes to this central server repository. -Trunk: The trunk is the hub of your current, stable code and product. It only includes tested, unbroken code. -Branches: Here you add the new codes and features. Using a copy of the trunk code, team members conduct research and development in the branch. This allows each team member to work on the enhanced features without disrupting each other's progress. -Tags: Tags are a duplicate of a branch at a given point in time. Tags are not used during development but are used during deployment after the branch's code is completed. Marking code with tags make it easy to review and, if necessary, revert your code.

Default (input method)

(Input method) How: Click and typing Implications: Supports hotkeys. Attended user cannot touch mouse or keyboard, lower speed and load times Limitations: Does not automatically erase previous text. Does not work in background

Send window message (input method)

(Input method) How: Replays window messages that target app receives when mouse/keyboard are used. Click and type occur instantly Strengths: Works in background. Low speed and load times. Supports hotkeys. Can work on other activities during execution Limitations: Does not automatically erase previous text. Works only with apps that respond to Window Messages

Data scraping wizard (output method)

(Output method) A functionality of UiPath Studio that allows the extraction of structured information from an application, browser or document to a DataTable variable. The functionality can be accessed directly from the Design ribbon of UiPath Studio. (The first element chosen is used to populate the first column, and the option to extract the URL (where these exist) is also presented. The user may change the order of the columns and specify the maximum number of entries to be extracted (the default is 100 and leaving 0 means extracting all the results). In the Preview stage, the 'Extract Correlated Data' option can be used to extract other fields of data, by indicating the first and the second entry, just like for the main field)

Native (output method)

(Output method) How: Get Visible Text Activity Implication: This ouput method is compatible with applications that use Graphics Design Interface (GDI), the Microsoft API used for representing graphical objects. It can process all known characters as separators (comma, space, and so on), but when only certain separators are specified, it can ignore all the others. Strength: It can extract the text position and formatting (including text color) and has 100% accuracy on the applications that support GDI. Weakness: Its speed is somewhat lower than FullText, it doesn't extract hidden text and it cannot work in the background; and just like FullText, it doesn't support virtual environments.

OCR (output method)

(output method) How: Get OCR Text Activity Implications: Its technology relies on recognizing each character and its position. The OCR method has two default engines that can be used alternatively - Google Tesseract and Microsoft MODI. Strength: The only output method that works with virtual environments and with "reading" text from images. Weakness: It cannot work in the background, it cannot extract hidden text, and its speed is by far the lowest. Its accuracy varies from one text to another and changing settings can also improve the results. Just like the Native method, it also captures the text position

automation first three-pronged approach

-A robot for every person -Open and free collaboration -Robots learn skills

Send hotkey (input) option

-Activate(Field is brought to foreground and activated before typing) -ClickBeforeTyping(UI element clicked on before typing) -DelayBetweenKeys (Delay between each key typed) -EmptyField (UI element emptied before typing)

Type into (input) options

-Activate(Field is brought to foreground and activated before typing) -ClickBeforeTyping(UI element clicked on before typing) -DelayBetweenKeys (Delay between each key typed) -EmptyField (UI element emptied before typing)

UiPath supported automotation types

-Attended -Hybrid -Unattended

How DataTables are created

-Build data table -Read range (Uses .xlsx files, does not need Excel) -Read CSV -Data scraping

Click (input) options

-Clicktype (Single or double) -MouseButton (Left, middle, or right button) -KeyModifiers (Press Alt, Ctrl, Shift and/or win key while performing action)

Selector attributes panel

-Displays all the available attributes of a selected node (from the Selector Editor panel). -You can add or eliminate some of the node attributes by selecting or clearing the check box in front of each attribute. -Additionally, you can change the value of each attribute yet this modification is retained only if the new selector points at the originally selected UI object.

Three important loop types

-Do while (Executes a specific sequence while a condition is met. Condition is evaluated after each execution of the statements. When the specified condition is no longer met, the project exits the loop) -While (Executes a specific sequence while a condition is met. Condition is evaluated before each execution of the statements) -For each (Performs an activity or a series of activities on each element of a collection)

State activity sections

-Entry (Enables you to add entry trigger for selected state) -Exit (Enables you to add xit trigger for selected state) -Transition (Displays transitions linked to selected state)

2 ways of accessing and manipulating workbooks

-File level access (Doesn't require Excel, works only for .xlsx files) -Excel app integration (Works for all files, requires Excel)

Three ways to create variables

-From the variables panel -From assign (Ctrl+k) -From the properties panel (in field where variable is needed & Ctrl+k)

Extract attributes activities (output method)

-Get ancestor (Retrives the ancestor of a UI element) -Get attribute (Allows one to indicate an attribute, and retrieves the value of that specific attribute) -Get position (Retrieves the actual position on the screen of a specific element)

Components of a process

-Inputs -Process Flows -Source applications -Outputs

Main properties of variables

-Name (Should be descriptive as possible) -Type (What kind of data can be stored in the variable) -Default value -Scope (Part of the workflow in which the variable can be used)

Factors driving automation potential

-Rule based (Decisions are made based on business rules and pre-defined logic) -Process type -Standard input (Content is positioned in the same place even if the input types are different) -Process expected to change (Are processes or applications used to process a case going to change within 3-6 months?) -Unknown exceptions % (Percentage of the total volume received which cannot be processed without an external factor)

Variable types

-Text (can store only strings) -Boolean (true or false) -Number (Int32) -Array (Store multiple values of same type) -Date and time -Data table (Store big pieces of information, and act as a database or a simple spreadsheet with rows and columns) -GenericValue (Store any kind of data, variables auto-converted to perform certain actions)

If statement

-The condition that is verified (with 2 potential outcomes - true or false) -The set of actions to be executed when the condition is true (the Then branch) -The set of actions to be executed when the condition is false (the Else branch)

Transitition sections (state activity)

-Trigger (Add a trigger for the next state) -Condtion (Add a condition under which an activity or sequence is to be executed -Action

Non-greedy search

-search makes it possible to identify the target element from a pool of similar applications, matching the attributes you specify. It needs to be included in the top-level tag of a selector. -Instructs it to search through all the active windows or browser instances which match the top-level tags of your selector, and not just the window instances in focus. Makes use of the idx() attribute

Variable

Containers that can hold multiple data entries (values) of the same data type. They pass data between activities inside workflows. They can change through external input, data manipulation or passing from one activity to another.

Solution design

Each process to be automated is documented ("as is" and "to be"), the architecture is created and reviewed, the test scenarios and environments are prepared and the solution design is created and documented for each process

Arguments panel

Enables creating variables and changing attributes of arguments that store data which are passed between projects

Variables panel

Enables creating variables and changing their attributes

Element exists (UI element)

Enables you to verify if a UI element exists, even if it is not visible. It returns a Boolean variable, which makes it very useful in 'If statement' activities

Initialization (dictionary)

First step of a dictionary. Can be done inside an Assign activity, and from the Variables Panel.

Implementation Manager/Project Manager

Forms and manages the RPA team, does resource planning and teams availability, in order to hit automation goals. Most of the times is the Single Point of Contact (SPOC) for questions, RPA initiatives, or parallel RPA product projects.

Business Analyst

Is responsible for mapping of the AS IS and proposed TO BE processes. Hold knowledge of the business process that gets automated, general business process theory and RPA capabilities. They are responsible with listing the process requirements for automation, clarifying the inputs and expected outputs, creating RPA documentation (Process Design Documents, Process maps.

Process owner

Is the key stakeholder and beneficiaries of the RPA solution. Usually Senior Management level, with some 10-15+ years of experience, possibly split across domains. Multiple people can have this role, based on department (Finance, IT, HR, etc).

UIPath Orchestrator

Lets you control, manage and monitor the robots. It is also the place where libraries, reusable components, assets and processes used by the robots are stored. A server application accessed via browser, through which the robotic workforce is controlled, managed and monitored

RPA Support

Manage the robots after the processes have been moved to production, with support from the original RPA devs who have performed the automation. May have multiple levels of support: L1- Client, L2- client/ partner, (L0 - Super users; L3 - UiPath)

Add to collection (lists)

Manipulation of lists that adds an item to a specified collection [list.Add()]

Remove from collection (lists)

Manipulation of lists that removes an item from a specified collection and can output a Boolean variable that confirms the success of the removal operation

Inner join

Merge of data tables where all rows are kept from both tables that meet the Join rule. Any rows that do not meet the rule are removed from the resulting table

Zero-touch automation

Processes that are digital and involve a highly static system and process environment, so that they can be easily broken into instructions and simple triggers can be defined

High-cost rpa

Processes that are rather digital and can be automated, but use some technologies that are complex (such as OCR) or require advanced programming skills

Semi-automation

Processes that can be broken down into steps that can be clearly automated, and steps that need to stay manual (such as validations or usage of physical security tokens)

No RPA

Processes where change is frequent, the system environment is volatile, and multiple manual (even non-digital) actions are required

Matches (RegEx)

RegEx method that searches for an input string for all occurrances and returns all the successful matches

Replace (string)

Replaces all the occurances of a substring in a string [VarName.Replace("original", "replaced)]

Split (String)

Splits a string into substrings using a given separator [VarName.Split("|"c)(index)]

Outputs

The result generated by the process

Process flows

The sequences of sub-processes or activities used to perform the sub-processes or activities of the process

Collection data type

Used for handling and processing complex data -Array (store multiple values of the same data type. Size is determined at creation) -List (store multiple values of the same data type. Unlike arrays, their size is dynamic) -Dictionary (Used to store objects in the form of [key, value] pairs, each of which can be of a separate data type)

Infrastructure and IT Security admin

With good technical and security skills, they are responsible for setting up and maintaining hardware & software resources for UiPath product installations. They set up accounts for all the devs, end users and robots