Leveraging Siebel Open UI: Introducing Plug-in Wrappers

Plug-in Wrappers are an exciting tool introduced with Siebel Open UI Innovation Pack 2014. This technical blog highlights the key UX benefits and walks through a real-world example of how they can be used.

Introduction #

The Boxfusion team have been working with Siebel Open UI for the last 4 years, producing a steady stream of innovations and new approaches to improving Siebel CX and usability.

Working to drive process efficiency and positively impact the responsiveness of the Siebel application, we are pleased to be able to share our insights into Plug-in Wrappers which are a relatively new feature available with the latest Siebel releases.

Plug-in Wrappers offer a means to apply generic functionality to selected types of controls across the whole application, and can therefore help to reduce development and maintenance effort in certain scenarios. This technical blog aims to describe how and why we are making effective use of this powerful new Open UI functionality, relating it to one of our recent customer requirements.

The requirement #

Our client had recently made the leap forward into the world of Open UI with an upgrade to IP2015, and an exploration of the potential User Experience enhancements to the application concluded that users would greatly benefit from highlighting critical information on the page.

For example, when a team member examines an account, it should be immediately obvious if the account should be emailed and never called, or if there are any special instructions associated with a customer. In this instance, it was decided that there needed to be a means to draw attention to these important customer preference fields.

It would also be important that this solution could be easily built upon, or extended to other fields in the future with minimal configuration, to allow the business to rapidly respond to evolving requirements.

Choosing a solution #

The flexibility offered by Siebel's core configuration and reinforced by the Siebel Open UI API enables the delivery of these requirements.

For example, a Physical Renderer can be attached to every applet where this functionality needs to exist; we could hard-code some of the conditions, or we could implement a dynamic solution which uses List of Values to check if a field needs to be highlighted. These solutions lack flexibility and the repetition of code is very likely, and as such, it is recommended that we avoid these, given that the requirements may change and we may need to handle more fields in the future. In this case, using Plug-in Wrappers gives us the power to write simple code which can be applied to any number of controls across the application, which eliminates the need for repetition and also offers a useful way of tailoring specific functionality to certain types of controls. We have so far discussed two distinctly different types; namely text-areas for Special Instructions, and check-boxes for Boolean controls like Never Call and Never Email.

The following screenshots illustrate what we aimed to achieve for some of the relevant controls:

Some simple CSS classes can be used to create these effects:

The Plug-in Wrappers can make use of these classes in order to apply the desired highlighting effects to the correct controls when the criteria are met.

Implementing the plug-in wrappers #

Our solution needed to deal with both text-area controls and check-box controls and as such we created two new Plug-in Wrapper files. We need to add these as manifest files as normal:

In Manifest Administration, Plug-in Wrappers are added as Application/Common UI Objects, with an expression relevant to the implementation. An additional Application/Common UI object must be created, as the vanilla ones cannot be edited.

The content of the Plug-in Wrappers are logically very similar. There are two main aspects to consider:

1. When should the Plug-in Wrapper be attached to a control?
2. How and when should the Plug-in Wrapper manipulate the control it is attached to?

Attaching the plug-in wrappers #

In order to improve the maintenance and extensibility of our solution, we made use of Control User Properties in order to determine whether the special functionality should run for a control. For every control where the relevant Plug-in Wrapper functionality should run, a Control User Property can be added as in the following screenshot:

"ClientPMUserProp" user property allows our user property to be accessible to Open UI. We can get control user properties with a function like the following:

This means that we can use the existence of the Control User Property to determine whether or not the Plug-in Wrapper should be attached to the control. The following code illustrates how we can achieve this for Text Area controls:

Similarly, in our Check-box Plug-in Wrapper, we can do something similar to detect whether the check-box should be highlighted:

The above examples show how we used two different control user properties to indicate the logic which should be applied by the Plug-in Wrappers. To extend this functionality to other forms in the application, all we need to do is add the control user properties to the relevant controls.

Manipulating the controls #

As with Physical Renderers, familiar methods including "Init", "ShowUI", "BindEvents" are available to provide the flexibility to execute custom functionality precisely when necessary. In this case, we have used ShowUI, as we need to make sure that the highlighting happens when the controls are first shown, but it doesn't need to happen more frequently.

Having chosen an appropriate method, the last step is to write the code which will determine whether the control should be highlighted, and apply the necessary styling.

For Check-boxes, the following screenshot shows how we applied the CSS class to highlight the control if the value was "Y":

For Text Area controls, if the length is greater than 0, we call an animate function to render a glowing effect:

Summary #

In summary, this example demonstrates how Plug-in Wrappers can be leveraged as a simple but powerful way to extend the functionality of an Open UI-enabled Siebel solution. A requirement to apply generic functionality across the application can be built with some relatively simple JavaScript and jQuery, supported with basic Manifest and Siebel Tools configuration.

This option can be implemented quickly and also provides a foundation upon which further requirements can be supported in the future.

In light of this, some of the key benefits of applying Plug-in Wrappers are:

• Reduced development time by reducing repetition
• Reduced complexity for control-specific development
• Easy to extend solutions

Plug-in Wrappers, therefore, add to the growing list of reasons to upgrade to the recent Siebel Innovation Packs and transform your users' experience.

Ask Our Experts #

If you would like to have a better understanding of how you are able to exploit the benefits of Open UI to the full including leveraging new and advanced Open UI techniques such as Plug-in Wrappers, get in touch with us today.

Call us now on +44 203 2834315 or email us at [email protected].