OpenSpan Introduction

 100% Free Openspan Course, Enroll Now

OpenSpan is a desktop automation and analytic tool platform that helps us improve the productivity of front and back-office operators.

It makes the system to include the reference data and examples for OpenSpan Studio and OpenSpan Runtime where it is a part of PEGA.

The following will provide a quick way to view information on the core functional areas of the OpenSpan product site.

OpenSpan Studio Development Environment:

OpenSpan Studio works within the Visual Studio design environment. Whereas the environment is formed of: Menu toolbar, Standard toolbar, various Tool Windows (docked or auto-hidden) on the left, bottom and right sides, as well as the Designer space.

OpenSpan Integrated Development Environment for creating, building, and testing OpenSpan Runtime projects.

OpenSpan Solutions and Project Items:

OpenSpan provides a set of system project items designed specifically for the application combination, workflow industrialization, and event monitoring. To add a project to a solution, select File | New | Project.

On the New Project dialogue select an OpenSpan template for the Project and define the Project name.

Integrating Applications:

OpenSpan Adapter Project items provide integration with enterprise applications for creating automated workflows and event monitoring.

Overview

OpenSpan Studio lets you interrogate applications, in order to expose the underlying objects and uniquely identify each object. You can then use these objects to build automation and monitor application events. To interrogate an application, you use OpenSpan Adapters. Interrogation results in the creation of controls corresponding to the interrogated application targets. OpenSpan uses translators and factories to enable communication between application targets and their platforms. Definitions of the key OpenSpan integration concepts and terms are stated below:

Adapters

The OpenSpan platform lets developers integrate applications at the desktop through their user interfaces. In order to integrate an application, OpenSpan uses adapters to inject code with-in the targeted application which directly interact with the application’s objects.

OpenSpan does not require the target application to be recompiled or modified in any way. OpenSpan supports a large number of platforms and application control types including Windows Common Controls, Internet Explorer HTML Controls, Java and .NET.

An adapter is a component that lets users integrate with an application to build upon a specific platform (Windows, Web and so on.) by interrogating the application to produce metadata describing applications where adapters have accessible properties, methods and events.,

Controls

When an application object is interrogated in OpenSpan Studio, a representation of that Object is created and that representation is known as a Control. OpenSpan organizes Control in a hierarchy. For example, integration of Calculator application and interrogation of Clear button, Equals button and results from text box:

This order is also there in the class associated with the control. For example, a text box interrogated in a Windows application would be in the OpenSpan. Adapters.Controls.Textbox.Class. The OpenSpan Textbox Control has all the properties, methods and events associated with the OpenSpan.Adapters.Controls.Control (base control) with those specific functions of the text box.

 A Control performs the following functions:

1. Saves the rules that are necessary to correct, identify the objects for the next time when the application has to run.

2. Acts as a proxy for the objects, so it can be used for automation even when the User Object has not been created within the targeted application.

3. Provides a consistent interface for the Object, regardless of the underlying application technology.

Controls are displayed within the OpenSpan Studio Object Explorer. A Control is considered and created when it has been matched and destroyed, when it has been unmatched.

The properties, methods and events, Controls inherit from the OpenSpan. Adapter

Targets

A Target is an OpenSpan object that corresponds directly to an Application Object. Whereas it controls and represents the virtual application object that does not change between runs of the application. Target represents the actual Application Object that exists within the application at any given moment.

Targets are created and destroyed when Application Objects are created and destroyed. A Target is platform specific and encapsulates the necessary logic for robotic and monitor application objects.

Thus, the text box Control can interact with any Target that implements the text box interface, such as, a Windows text box target, a Java text box target or an HTML text box Target.

Translators

A Translator is a unit that injects code and enables OpenSpan to automate and receive events from an Application Object. Targets communicate directly with Translators by using the OpenSpan IPC layer.

Most of the time Translators are Objects, although in some of the cases translators can just be a single module or static class that communicates with all the supported objects. Translators do not require any modifications or recompilation of the Target Application.

OpenSpan automatically injects Translators into a target application and are attaches them to the appropriate Application Object. Translators are typically written in the same language as the objects they are interacting with.

Thus, for example, Translators for .NET controls are written in C# and Translators for Java controls are written in Java. The most notable exception to this is ActiveX or COM controls, due to it’s binary interface, that can be written in C++ regardless of whether they were originally written in Visual Basic or another language. Their assemblies are included in Deployment packages.

The diagram below illustrates the relationship amongst Controls, Targets, Translators and Application Objects.

Factories

Factories control and enable OpenSpan Studio to talk to the specific platforms.  These factories interact with brokers and are injected at the platform level (.NET, Java, Active X and so on).

Factories appear in Object Explorer and are automatically detected by OpenSpan Studio.

From a user, the most important thing to know about factories is that their appearance in Object Explorer indicates that OpenSpan Studio is interacting successfully with the platform.

Automating Application Workflow Tasks:

OpenSpan Automation Project provides visual design surface for creating automated application tasks and application event reporting.

Use Automation for creating logic in order to execute OpenSpan Studio integration, automation, and event projects.

In order to build the project functionality, you need to add the properties, methods, and events for controlling them from Object Explorer and OpenSpan components from Toolbox window.

As you place controls and components on automation, the objects are represented by the design blocks with data and event ports. Making connections between the data and event port establishes the automation logic.

Specialty Components and Controls:

OpenSpan provides a suite of specialty components for the use in the workflow automation and application event monitoring projects.

OpenSpan Studio consists of custom components as well as standard .NET controls use in solutions. This topic lists the OpenSpan components.

Building and Debugging Projects | OpenSpan Project Deployment | Project References:

Design environment contains functions for the configuration and building deployable OpenSpan Runtime Projects as well as OpenSpan Project assemblies to use with Non-OpenSpan .NET Projects.

Building and Debugging Projects

Once you have created an OpenSpan project, you can debug the project with-in OpenSpan Studio to test the functionality and integration.After debugging a project in OpenSpan Studio, it launches the OpenSpan Runtime application which runs the project.

To stop the project, click the Stop button on the Debug toolbar. Stopping the project, unloads the project, closing all project integrated applications, and shuts down OpenSpan Run time. This section describes the running project through the debugger along with debugging functions and options.

OpenSpan Project Deployment:

To create a deployment package for an OpenSpan project this OpenSpan Runtime application can be used by the OpenSpan deployment functions or MSBuild command line to build process.

A deployment package consists of an Openspan file and a .manifest file. The .openspan file contains compiled version of the project which contains all of the necessary assemblies and all Translator files required for the project.

When using the Start functions (either Start Debugging or Start without Debugging) within Studio, the Project is built and then the resulting files run using the OpenSpan Runtime application, installed in conjunction with OpenSpan Studio.

Project References:

OpenSpan Studio projects can reference other OpenSpan Studio projects and use the referenced project items. In addition, Non-OpenSpan projects, such as .NET C# applications, can refer OpenSpan projects to use interrogated controls in integrated applications.

For example, an OpenSpan project may have all of the necessary controls interrogated from a CRM windows application and use some or all of the controls from the CRM application in your project.

In this case, you create a Solution which contains your main project and the OpenSpan project which contains the interrogated CRM application controls.

Testing and Debugging Projects | OpenSpan Diagnostics | Unit Testing: 

OpenSpan Studio provides comprehensive set of testing and debugging functions and uses OpenSpan projects. In addition, you can configure both OpenSpan Studio and OpenSpan Runtime application to publish detailed diagnostic messages.

Testing and Debugging Projects:

Once when an OpenSpan project has been created, you can debug the project within OpenSpan Studio and test the functionality and integration. Debugging a project in OpenSpan Studio launches the OpenSpan Runtime application and runs the project.

To stop this project, click the Stop button on the Debug toolbar. Stopping the project unloads the project, closing all project integrated applications and shuts down OpenSpan Runtime.

OpenSpan Diagnostics:

Both OpenSpan Studio and OpenSpan Runtime provide diagnostic message, to configure how diagnostic messages are published for OpenSpan Studio, access the Studio Diagnostics settings from the Options dialog.

When you start a project in OpenSpan Studio (click the Start Debugging button on the main tool bar or select Debug | Start Debugging) the project has to run by the OpenSpan.Runtime.exe application installed along with OpenSpan Studio. To configure diagnostic messages, published from the runtime application, use the Runtime Diagnostics settings in the Options the dialog in OpenSpan Studio.

Unit Testing:

Use the Unit Testing feature of OpenSpan Studio to run project automation logic and return either “Passed” or “Failed” reports.

Application Event Monitoring:

The OpenSpan event feature set works with OpenSpan Runtime and collects the database on the system and application events, such as starting an application, clicking a button, navigating a web application, locking a workstation.

As Runtime events occur, the system/application data gets collected and stored in the OS_Events table. This type of data collected by events-enabled, OpenSpan Runtime projects depends on the configuration and project design. This set of features works only with OpenSpan Server.

To know more information and guidance regarding OpenSpan you can refer this blog.

Enroll for OpenSpan Training Course