Welcome to the OPA Hub!


Category Archives: Oracle Policy Modeling

JSON Extension File

JSON Extension File

As many, but not all readers are probably aware, the Oracle Policy Automation JavaScript API is restricted in terms of what data it can manipulate in code. The default position is simple. If you plan on working with (accessing, updating or whatever is appropriate given the nature of the data and the type of attribute or entity instance) information from the Data tab of Oracle Policy Modeling then it must be present on the Screen that contains your Extension.

Here is a simple example to illustrate. Suppose you have a project that infers a list of Metro Stations. These stations are inferred in some way by Excel or Word rules. You wish to use a drop-down to allow the user to select one of those stations.

You decide to use the much-downloaded educational example called  Dynamic Options from Instances which you found in the OPA Hub Shop. So far so good. You look at the example Project and you see this:

JSON Extension File - Before

Cool. It’s a demonstration of a dynamic options list (at the bottom) driven by the entity instances (at the top). And the console shows some cool output to highlight the construction of the list. On the left, you can see that the interview is made up of two Screens. Excellent. Then you decide to split the interview into three Screens – separating the Instances from the Selection. Sounds really cool and a better layout. Now you see this in the Debugger:

JSON Extension FileWhich I think you will agree, is sub-optimal. Our extension just fails miserably. But now, it’s opm.extension.data.json to the rescue. We create this file in the resources folder and populate it according to our needs. In this case, we add – and this is required for any entity attributes – the relationship name (the technical name, not the textual name) and then we declare any attributes we want. So our file looks like this:

JSON Extension File Example

We re-debug and everything is back to normal. Re-cool. Obviously we should avoid putting too many elements in there – especially parent – child relationships which can result in masses of JSON being generated by Oracle Policy Automation and made available to your JavaScript, potentially creating performance bottlenecks. But for our little example, it’s perfect.

Table Headers Tabular Layout Trick 7

Table Headers : Tabular Layout Trick

Table Headers : Tabular Layout Trick

There is always much discussion when users first discover the Interview tab. Let’s be honest – not all of the comments are exactly positive. It all feels a bit, well, basic.

There are a number of things that catch you out at first (and indeed, later). So let’s take a moment to study tabular layouts and a common issue.

For this example I’m going to use the same project (Credit and Visa Cards) as the previous post, since that gives us two entities to work with.

Tabular Layout

Let’s consider that you want to display both entities using tabular layout. You create a Screen and set them both to tabular display. But let’s assume that you want to display the Visa Card with a couple of specifics. You want to include the provider of the credit card. So let’s set that up as a Value List and use an attribute on the Credit Card, and infer it on the Visa Card:

Table Headers Tabular Layout Trick 1So, with that now done, we want to display the Visa Card provider in the Entity Collect (as it is an inferred entity, we cannot use an Entity Collect). But we want to display it as a label as you can see in this screenshot (we added a name to the attribute as you saw in step one so we can reference it in our Screen:

Table Headers Tabular Layout Trick 2Notice how we added a label and used that to display the text of the provider? Using a label ensures three things

  1. It is read-only
  2. If the user is tabbing from input to input, the cursor will not get stuck in that field
  3. It doesn’t look like a read-only input, just a label (which is what we want).

But the downside is that the label does not have a table header in that column, since the Interview designer only adds those for Inputs:

Table Headers Tabular Layout Trick 4

I find it a shame that we cannot put table headers in this “tabular” column, since in HTML a table should have column headers. In fact if we take a moment to inspect this table in the browser, we note that annoying, there is a table header in the table:

Table Headers Tabular Layout Trick 5

So, we need to get that table header populated with our chosen text. But how shall we do it? We don’t want to create an Entity Container extension, since that would mean we have to do the whole thing from top to bottom. So we only want a little tiny change. We have a couple of choices.

  1. Create a Style Extension for the Entity Collect
  2. Create a Label Extension for stealth modification

Let’s try the first option, since it reveals some interesting facts about Styling Extensions. Firstly, get ready by doing the following; change the text associated with your entity in the Interview by double-clicking where the rectangle is, and entering whatever text you would like to display in the missing header.

Then add a compound Styling Extension to your Project. Tabular Containers allow for nested styling, like this:

OraclePolicyAutomation.AddExtension({
style: {
tabularContainer: function (control) {
if (control.getProperty("name") === "xContainer") {
style: {
headerRow:
YOUR STUFF GOES HERE
 
}
}
}
 
}
});

Notice the “headerRow” is a child of “tabularContainer”. And notice the line that says YOUR STUFF GOES HERE. Now for an interesting fact about Styling Extensions. They behave, to a reasonable degree, just like Control Extensions. They are really one and the same thing – the main difference of course is the handlers that are exposed in Control and Interview Extensions.

Drop jQuery into your resources folder, and then replace YOUR STUFF GOES HERE with the following line:

$("#opaCtl4th0").text(control.getCaption());

Of course, the jQuery selector may be different for you but it is easy to find the “header” I illustrated in the previous screenshots. Open your Project in a real Browser (Ctrl+F5) for debugging and take a look at the results:

Final Header Result

Our Styling Extension has added the text to the header, drawing it from the Interview Screen Entity Container definition, and we have it where we want it. Of course, you could style it as well.

But it goes to show that Styling Extensions are really not very different to Control Extensions!

Back to Basics : Extensions #2

Back to Basics : Extensions #2

Following on from the previous post, we delve more deeply into the JavaScript Extensions world.

Interview Execution in a Browser

So how does an Interview Extension work? Let’s begin with some basic information about how your Oracle Policy Automation Interview runs in your Browser. If you happened to be viewing an Interview right now, and you were to open the Console (F12 in Google Chrome, or Microsoft Edge. Check your Browser documentation for the equivalent key or menu option), you might be able to view something like the following screenshot. Check the steps under the image as you may need to refer to them in your own case.

Extensions

In this screenshot I have launched a Project using the Debugger. Remember that if you hold down F5 while clicking the Debug button, you will open the Interview in the Debugger and in your default Browser.

  1. Your web server may of course be a different address.
  2. The web-determinations folder will not have the same numeric suffix as in this screenshot, indeed will most likely not have a suffix at all. This is a feature of the Debugging session.
  3. The js file is most likely in the staticresource folder, however if you are in a more integrated environment it may be in a different subfolder, or a different folder altogether. But it will be present.
  4. The contents of the js file can be read more easily by selecting (in Google Chrome in this case) the option to pretty print the code.

Interviews.js

This file is the foundation of the Interview experience provided by Oracle Policy Automation. It contains all the code necessary to make the user experience function correctly. Inside this file, however, there is a built-in capacity to accept extensions that change the behaviour of the Interview.

In your Console, search in the file for the following text – “customLabel:” (without the quotation marks, but with the colon). You should find one instance of that text, as shown in the screenshot below.

Extensions

  1. Search for the text
  2. Find the text in the file.

Take a moment to perform a second search in the same file, for the text shown below. Use the screenshot as your guide.

  1. Ensure you are looking at interviews.js
  2. Search for this text
  3. View the style definition for textInputStyle.

Accepted Extension Types

Notice in the first example, that customLabel is only one of a series of items in the first list. These are the recognized types of Control extension that we, as Oracle Policy Automation Project workers, are permitted to develop.

In the second search you found that there was a style defined for controls called textInputs. Although not quite as obvious perhaps as the first example, an Oracle Policy Automation Project might want to override the Style(s) used in a Project, in order to comply with corporate guidelines for example: and this system will help us do just that. Style Extensions use keywords in the same way to indicate which elements you wish to style.

About Extensions

It is not important at this stage to understand how these extensions are created or used. It is, however fundamentally important to understand that you will be extending Oracle Policy Automation Interviews by adding one or more of these acceptable extensions, and that they will be run in the browser in the same way as the standard JavaScript is already. These interviews can then be better adapted to your IT environment. As an example, read how Styling Extensions enable integration visually with Oracle Content & Experience Cloud.

More on this subject, with some worked examples, shortly.

Back to Basics – What are Extensions?

Back to Basics – What are Extensions?

Styling Extensions

Introduced in Oracle Policy Automation November 2016 release, a styling extension allows a designer to create styling rules and logic using JavaScript and Cascading Style Sheets. These files are contained within the deployed Oracle Policy Automation project, and should be used only if you have exhausted all of the built in Styling possibilities offered as standard in the Interview tab, Styles dialog.

Control Extensions

A Control represents a single item placed on a Screen during the design of an Interview. Typically these controls might be used by the user to enter data (for example, a Control with a Calendar attached to enter the date of birth of the applicant) or to organize data on the Screen (for example, a Container that allows for a better layout of several other items). At run-time, each Control is translated into HTML and associated JavaScript code. Introduced initially at the same time as the styling extensions mentioned in the previous paragraph, although they have grown more numerous over time.

Control Extensions Example

They are generally referred to by a name such as customLabel or customContainer which identifies the type. In a later post you will learn the origin of these names.

Evolution

Interview behavior Extensions have gradually gained in functionality, and also in terms of which Control types are available for customization. There are different kinds of extension for different needs.

Scope

If Controls represent items grouped on a Screen (and therefore on a page, as far as most Interview users are concerned), with Extensions you can also customize the real estate around the pages – whether it be the navigation styling, of a custom footer or header, or even a completely new navigation system. So extensions can be for a single Control, or for a complete Navigation system.

Naming Convention

Technically speaking, all of the examples mentioned above are called Interview Extensions in the official documentation, and they are divided into styling extensions and control extensions as you will discover. You can find the reference material at the following URL at the time of writing .

Architecture

Before looking at the different types available to us, it pays to review the architecture of the Interview and gain understanding as to how they function within it. Coming next…

Fun with Aliases and Strings #2

Fun with Aliases and Strings #2

Returning to the ” Aliases and Strings”  theme of the previous post, where we looked into an example of String concatenation. Just a reminder, in the previous article you created the entity model and set up a couple of relationships, before using a rule to decide if the ticker tape instance is a member of a relationship called  the next ticker tapes.

So here is the continuation of the document you saw in the previous steps:

Aliases and Strings #2

The first part should look reasonably familiar, since it builds on the example with the next ticker tapes. But is uses the second relationship, called the closest ticker tape. Note the wording closest ticker tape not ticker tapes. We are aiming for the closest one, or if you prefer, the next one in line. So for ticker tape number 3, the closest would be number 4.

Dodgey Ticker

We again use an alias, but things get a bit sticky in the following parts. Where did the further ticker tape come from? Well, perhaps unsurprisingly, it’s another alias. You see, we already used the other ticker tape in the conclusion so we need to use another word : in this case further was my personal choice, but it could have been another word that meant something in this context. So by now we have the following, expressed in conversational style :

Compare ticker tape A (with other tapes, let’s say B, C and D). B,C or D will be called the closest ticker tape if the following is true.

  1. B,C or D have an ID that is higher than the ID for A
  2. Using the next ticker tapes as your starting point (so, B C and D)
  3. Compare them (so B compared to C, B compared to D etc) to this rule
  4. Is B’s ID is less than or equal to C (for example)?

So we end up with the ticker tape that is in the next ticker tapes AND has an ID that is less than or equal to the other next ticker tapes. So it is the closest one.

I’m reminded of this excellent conversation from Monty Python since it can get a bit confusing at first:

video

The final rule concerns whichever ticker tape has the longest string. And that string is what you are about to create, for each and every instance of your entity.

We’re coming with you!

You will generate a string of text for each of the entity instances (so, for each of the ticker tape instances). And this string will be the driver of a logical loop.

Firstly, let’s set your scene and remind of the context:

  1. “Text 1”
  2. “Text 2”
  3. “Text 3”

Each ticker tape has a text message, for example “Text 1” . This message should be concatenated with the other text messages to form a long “final” string. Each should have a comma inserted between them, into the final string, and of course a “.” at the end. Just to make a nice tidy “final” string. It might look like “Text 1, Text 2, Text 3.”.

Aliases and Strings #2

So each instance has a text string, and a “final text”. The “final text” will be the ticker tape text string concatenated with the closest ticker tape’s text string, plus a comma if required – for example if there are no “next ticker tapes” for a given tape, it’s because we have reached the end of the instances (number 4 , if there is no number 5).

The following attributes give us the numbers used in the table above:

Aliases and Strings #2

And the final (final) global attribute:

Final String Result

Aliases and Strings #2

In the next part of this series, there will be a chance to look back on the techniques, observe the warning message and generally investigate your logical loop.

Aliases and Strings part three will be with you in a few days, In the meantime of course you can read the online help here.

OPA Word Rules – Level Up!

OPA Word Rules  – Level Up!

As the summer lethargy begins to bite (at least if you are in the Northern Hemisphere) I find my colleagues are missing from their desk – vacations long planned are finally here! It is with this in mind that today I am sharing a lighthearted post about Word rule levels. But there is a nice payoff in the end of the post, which some of you will might already know but it might be useful for some, occasionally.

Let’s look at the following document snippet and ask ourselves a question (this screenshot comes from the RetailDiscounts example project).

OPA Word Rules - Level Up!

The picture above shows a fairly typical nested level structure, which improves clarity and helps both the rule author and the rule validator / subject matter expert because it makes the goal and conditions clear. And we can see in this case, there are 2 levels used (level one is yellow, level two is salmon pink).

How low can you go?

The question is, how many levels can you have? Note, that this question is not “how many levels should you have?” which is altogether more nuanced and more in the domain of best practices – and if you are in doubt about that, I strongly suggest you read Jasmine’s famous PDF here.

So, how many can you have? Well, let’s look a the Word Ribbon  – there is a drop-down to help us:

OPA Word Rules - Level Up!

So that’s the answer, right? Five levels, each with their own color.  Or is it?

It’s not Summer, it’s Easter! OPA Word Rules – Level Up!

Some might qualify this as an Easter Egg in computer geek-vocabulary. It’s an unexpected feature – but there are actually SIX levels. Not five.

Take a look at the following screenshot, notice the styles have been displayed for clarity.

OPA Word Rules - Level Up!

In the (albeit very infrequent) case of needing a sixth level, you can access it by pressing the Increase Indent button on the toolbar, while the cursor is on the fifth level (or you can press F12 on your keyboard).

Have a nice day!

Stunning Infographics with Oracle Policy Automation and Easelly #1

Stunning Infographics with Oracle Policy Automation and Easelly

Oracle Policy Automation and Easelly : Once in a while I come across something in the Oracle Policy Automation universe that just makes me go “Wow!!!”. And today’s post is like that. I was working on a demonstration the other day of a fairly familiar concept : a  retail audit or “store visit”.

Visits to retailers, whatever product you are selling, are pretty often rushed affairs, probably squeezed in a back room or just hunkering down on the corner of a work surface for a few minutes. It’s in the middle of the day, there are customers coming in and in spite of cordial relations, the retailer would really much rather be doing their job. And chances are, there are another 3 or 4 people coming in later to do the same thing as you.

Oracle Policy Automation is a real benefit in situations like this – you can perform what-ifs, demonstrate how the retailer is performing, simulate new scenarios to encourage and engage with them.

But when you’re fighting to get focus, and the room is airless and hot, you really need to be able to bring your A game. I’ve watched some amazing people doing this job, and they really impress how much they pack into the short time they are on the premises. But when they are gone, their message sometimes gets forgotten, mis-remembered or filed away. I started thinking how  Oracle Policy Automation could really leave a mark.

My first thoughts were to Oracle BI Publisher for a take-away or handout, and there are some excellent demonstrations out there, including in the Sample Projects (Healthy Eating). But I was still left wondering as to what might be a better solution. BI Publisher is in this case let down by it’s basic format and premise – Word. It is too linear, static and inflexible. You don’t use Word to create the most modern, web-friendly and engaging support materials. Then I had a bit of a brainwave.

Stunning Infographics with Oracle Policy Automation and Easelly

For a number of years I have been a user of Easelly – an online Infographics design platform. I’ve had great fun with it, using it to show results of surveys and I use their templates quite a lot when I need a framework for a new graphic. I’m not a designer, but I’m pleased with the easy learning curve and the results.

Recently Easelly have started offering a REST API to their “pro users”. And this allows for the generation of PDF or PNG content on the fly. For example, you have data in Oracle Policy Automation and you insert it on the fly into your best infographic. Send it by mail, print it before you visit – it doesn’t matter how you do it but you will definitely want to get this in front of your customer. Pro accoun

Oracle Policy Automation and Easelly

ts are not expensive – $24 US Dollar a year.

Here is an example, with an infographic designed by Easelly. You can see it on the right hand side of the page. I think you would agree that something like that could be done in BI Publisher, but not without a very robust skill set. With Easelly however, a tool built for infographics, it is considerably simpler. Please note : I’ve used the Easelly platform since it was launched, and I like to think I know BI Publisher quite well. So I can compare the two fairly objectively – and for modern infographics, the learning curve and capabilities of Easelly mean I would choose it every time.

Custom Control and REST API Integration

And here is the video that shows it being generated live in Oracle Policy Automation. That’s what I can a showstopper graphic. The great thing is, with the Oracle Policy Automation Custom Control concept , adding this to the Interview is a matter of minutes.

The data, the labels – all that is coming from Oracle Policy Automation much in the same way as for BI Publisher and Forms. Only way better looking!  In the next article in this series I’ll show you how to integrate Oracle Policy Automation with Easelly using, in this case, a PHP-based Custom Label Control.

Importing Data into an Interview : Excel Example

Importing Data into an Interview : Excel Example

Readers will remember a while ago I explained briefly how to use Microsoft Excel to act as a Connection Datasource – in this overview article, followed by this one in a little more detail. Now we look at another challenge : Importing Data into an Interview.

Well, here comes another example of the ubiquitous nature of Microsoft Excel. The customer requirement was as follows:

Using a simple mechanism, let the user upload an existing Excel spreadsheet into the Interview. Parse the spreadsheet, read the data in it, create corresponding rows in an Entity. Let the user review the data but do not require any new data entry. There may be up to 250 rows of data to import. So how do you go about about Importing Data into an Interview?

So how can we face up to a challenge like that? We need:

  • An upload that isn’t a standard File Upload Group
  • A parsing mechanism to read Excel and extract the data in a given tab, or wherever
  • A custom Entity Collect to handle the data import / create the rows in a Screen

The shopping list above isn’t that long.

The File Upload is essentially an HTML 5 component to let the user select a file on their computer. We cannot access an arbitrary local path from JavaScript, so we need the user to point to the file they want to upload.

There are a number of JavaScript-based Excel parsers, including the excellent SheetJS js-xlsx which we used. It is capable of converting to and from Excel, which is no easy task when you consider that an Excel file is basically a Zip file with a bunch of complicated stuff inside it. The library can convert to HTML, CSV and magically (for our requirement) JSON. Awesome!

Plus, in a previous post we’ve also looked at the (large amount of) work required to build a Custom Entity Collect Extension. In fact when I was writing that article I was thinking, for goodness sake Richard, when do you think you will actually need to go to the trouble of building that Entity Collect Extension? Well, I’ve finally found a use for it – Importing Data into an Interview!

We need an Entity Collect Extension since we need some way of getting the Excel data into the Entity Collect, which ultimately means we need to do some work behind the scenes between the import of the data and the display of the Entity Collect. We need to rewire the Entity Collect temporarily so that it sucks our Excel data up, before we show it to the user so they can examine the results.

For the purposes of a raw demo, I unplugged all the other functionality (delete buttons, add buttons, etc.) and just concentrated on getting the data into the Entity Collect. There are how ever a few caveats. Once you get into the larger imports, at least in the Debugger, you can expect to see “concurrent record editing” errors. I’m trying to find out what the limit is exactly. But up to a few hundred I think it’s OK.

So let’s look at the items in turn.

File Upload and Data Load

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
{
					//console.log("Starting customInput Mount");
					var div = document.createElement("input");
					div.id = "myFile";
					div.type = "File";
					//div.value = control.getValue();
					el.appendChild(div);
 
					function handleFile(e) {
						var files = e.target.files,
						f = files[0];
						var reader = new FileReader();
						reader.onload = function (e) {
							var data = new Uint8Array(e.target.result);
							//console.log("In Change");
							var workbook = XLSX.read(data, {
									type: 'array'
								});
 
							worksheet = workbook.Sheets["YOURWORKSHEET"];
							jsonoutput = XLSX.utils.sheet_to_json(worksheet, {
						raw: true, header : 1
							});
						//console.log("Read " + jsonoutput );
						};
 
						reader.readAsArrayBuffer(f);	
						var completepath = $(':file').val();
							//console.log(completepath);
						interview.setInputValue("rest_filenameandpath", completepath);
					}
 
 
				var filedialog = document.getElementById("myFile");
					filedialog.addEventListener('change', handleFile, false);
 
					var completepath = $(':file').val();
						control.setValue(completepath);
						//console.log("Hello " + completepath);
						//console.log("Ending customInput Mount");
				}

Assuming you have a custom Input framework as your starting point, the above code will be in the mount. This will build an HTML5 file upload control, and attach an event handler. The code regarding Excel depends upon xlsx.full.min.js being in the resources directory. But that’s it. You’ve loaded the Excel file into a JSON object.

Entity Collect

The next step is to include a Custom Entity Collect in your project, and use the jsonoutput object (which you just created from the imported file above) in the mount of the Entity Collect to load the JSON into the Entity Collect. The following is an extract from the mount code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var numEntities = Object.size(jsonoutput);
					//console.log(numEntities);
					// Remove header row if the file has one
					jsonoutput.shift();
					// load records into the Entity Collect
 
					if (control.getRows() == 0) {
						for (j = 0; j < numEntities - 1; j++) {
							control.addNewRow();
							var mycurrentrecords = control.getRows();
							mycurrentrecords[j][0].setValue(jsonoutput[j][0]);
							mycurrentrecords[j][1].setValue(jsonoutput[j][1]);
							mycurrentrecords[j][2].setValue(jsonoutput[j][2]);
							mycurrentrecords[j][3].setValue(jsonoutput[j][3])
drawrows();

The end result is something like this:

Importing Data into an Interview

The File is loaded into the Entity Collect, and the contents displayed to the user. In my case I unhooked all the code related to modification (the onchange stuff from the original idea) and removed the add / delete buttons, since it was designed to just allow the user to see the loaded result, not modify it.

Importing Data into an Interview

If you want to have a look at the project, just download the very basic example here.

Sneak Peek : Web Authoring – Modules

Sneak Peek : Web Authoring – Modules

Having recently installed an Oracle Policy Modeling 19A platform, in an On Premise / Private Cloud scenario, I proceeded, as per usual, to dig around and see what was new behind the scenes. One item that caught my attention was a parameter, in the usual table (I’m not going to mention which table, since if you have an On Premise installation you will know which table I mean, and if you are in the Cloud, you won’t have access to it anyway) called feature_web_rules_enabled.  Web Rule Authoring has been on the radar for a while, and mentioned under safe harbor at a few events recently. So what’s behind this idea of Web Authoring?

Simply put, it’s the idea that some users might want to develop rules without Microsoft Word or Excel.

Having recently installed an Oracle Policy Modeling 19A platform, in an On Premise / Private Cloud scenario, I proceeded, as per usual, to dig around and see what was new behind the scenes. One item that caught my attention was a parameter, in the usual table (I’m not going to mention which table, since if you have an On Premise installation you will know which table I mean, and if you are in the Cloud, you won’t have access to it anyway) called feature_web_rules_enabled.  Web Rule Authoring has been on the radar for a while, and mentioned under safe harbor at a few events recently. So what’s behind this idea of Web Authoring?

Simply put, it’s the idea that some users might want to develop rules without Microsoft Word or Excel.

So, I couldn’t help but switch the parameter on. Now, obviously this is a work in progress, and the finished product will look very different, but it is always exciting to see what the Oracle Policy Automation team are working on. It is especially true in respect of authoring without Microsoft Word or Excel. Web Authoring – “Modules” have the potential to provide a new approach to rule creation. Perhaps targeting a more technically savvy audience, whilst Microsoft Word and Excel could continue to provide the well-known and well-loved platform for more busines-oriented users. Of course, that is just my subjective opinion : I’m sure Davin and the team have their own very exciting vision of the future.

So, I couldn’t help but switch the parameter on. Now, obviously this is a work in progress, and the finished product will look very different, but it is always exciting to see what the Oracle Policy Automation team are working on. It is especially true in respect of Rules Authoring without Microsoft Word or Excel. Web Authoring – Modules have the potential to provide a new approach to rule authoring, perhaps for a more technically savvy audience, whilst Microsoft Word and Excel would continue to provide the well-known and loved platform for business users. Of course, that is just my subjective opinion : I’m sure Davin and the team have their own very exciting vision of the future.

So here are the things I was able to look at, once I had enabled the parameter:

Web Rules Modules

A funky new icon, which is a combination of Repository and Deployment arranged to look like a set of epaulettes that an airline captain might wear. Good Choice!

At it’s heart, obviously, a new interface for entering rules, complete with auto-detection of attributes and operators (watch for the formatting and indenting in the video below), plus Rule Assistant-style pop-up suggestions as you type, complete with functions. And secondly, the ability to quickly deploy the Module and pick up the WSDL from this “one-shot” screen.

As I said at the start : the end product will I’m sure look completely different, but isn’t it exciting to see the development of a new feature already taking shape? What do you think of the potential of this?

Back to OPA Basics : Oracle Policy Modeling Features

Back to OPA Basics : Oracle Policy Modeling Features

Welcome to another in our periodic back to OPA basics series. At the moment I am watching a lot of new starters join a set of experienced developers. And funnily enough, both groups sometimes are stuck in their routine. For the new people, they fall back on what they know from other rules engines. For the more experienced people, that are familiar with Oracle Policy Modeling, they repeat what they learned long ago and do not necessarily see anything that has been added to the application in the intervening time since they first started using it.

So here are my top five cool time savers and useful things you can find in Oracle Policy Modeling today.

  • The Rule Assistant

I still find it strange that many people don’t use the Assistant in Word. If there was ever a tool to avoid having to remember the arcane spelling and phraseology of an Oracle Policy Automation attribute, this is it!

Back to OPA Basics - Rule Assistant

  • The Convert to Test Case Export

Watching people filling in every cell in their Test Case spreadsheet, when they probably have already saved many of the initial scenarios as debug sessions, I think they should remember the fact that they can move a unit test into a Test Case, and vice-versa.

Back to OPA Basics - Export as Test Case

  • The Find Unused Attribute Filter

I tend to use this one when the Rule Assistant has not been used very much, so we are looking for duplicate / mispelled attributes in our Project (see Rule Assistant, above).

Back to OPA Basics - Unused Attributes

  • The Inclusion Report

OK, so I’m probably cheating as far as this one is concerned, but it is a real time saver. In 19A, the introduction of the Inclusion Report has saved me time already. Great for beginning an impact assessment when some sort of surgery is required on Project structure. Find out more here.

Back to OPA Basics - Inclusion Report

  • The Export Entity Data Model Option

This is a tiny little option hidden away in the toolbar but I’m often asked by non-OPA people for the data model and I find this export really simple and quick to use.

Tiny Button - Export Data Model

Well, that’s our top five for now. What other tricks do you use to get the most out of Oracle Policy Modeling?

Let us know in the comments!