Managing substitution variables using EPM Automate and REST

I was recently asked if it is possible to use the REST API in EPM cloud to manage substitution variables, at the time there was no documentation advising that it was possible but the clue was that it is available using the EPM Automate utility.

The rule I usually apply is if it is available in the EPM Automate utility, then there should be an equivalent REST resource as the utility is built on top of REST APIs.

In the next release (16.12) there is a documented new feature -
“You can now use REST APIs to get and set substitution variables”

I am assuming this just means the REST API documentation is going to be updated as the resources are already there. (update: this is exactly what has happened)

In this post I am going to explore the options that are currently available with the EPM Automate utility and REST API to manage substitution variables, at the same time I am going to apply this to one of the many scenarios where this might be beneficial.

If you are not already aware there is functionality in both cloud and on-premise to create a rolling forecast in the form designer, there is a possibility you have not seen this before so I will quickly go through setting it up.

Once you drop Year and Period dimension into a column the right click option of “Rolling Forecast Setup” appears.

This will open the forecast setup window where you can define the prefix, start period/year and number of periods.

In my example I am going to create the forecast starting from Jan 2017 for 12 periods with a prefix of Roll

After generating Essbase substitution variables will be created and the form design will be populated with them.

So in my example 12 period and year substitution variables have been created using the defined prefix.

Using the inbuilt functionality, the sub vars are always created at application level.

Opening the form displays twelve periods starting from Jan 2017.

To update the sub vars to say shift a month forward you can right click the period or year in the form and select “Set Rolling Forecast Variables”

This will open a window with the forecast variables and the current values.

If I shift the values by one the variables values will be updated in the window.

Applying this will then update the Essbase sub vars and the form will now reflect this.

This all well and good if you like going into the form and shifting the sub var values or manually updating them through the variables section in the user interface, I prefer to use automation than live in a world of manual repetitiveness so this is where using either the EPM Automate utility or the REST API can help.

Let us start with the EPM Automate utility.

There are two commands currently available for managing sub vars through the utility:

setsubstvars - creates or updates one or more substitution variables at the Planning application or at cube level (added 16.04)

getsubstvar - enables you to view the current value of a substitution variable or the value of all variables at the cube or application level (added 16.11)

The syntax for setsubstvars is:

epmautomate setsubstvars CUBE_NAME|ALL SUBSTVAR=VALUE [SUBSTVAR=VALUE]

CUBE_NAME can be set as an individual cube name or by using ALL to set at application level, a single or multiple sub vars can be created/updated in in one command.

For example:

epmautomate setsubstvars ALL CurYear=FY16 CurPeriod=Dec

or at cube level

epmautomate setsubstvars Plan2 CurForecast=FY17

If I take an example using the rolling forecast variables that were created earlier.

The variables "RollPer1" and "RollPer2" could be shifted forward a month by using the utility to set them to "Mar" and "Apr"

epmautomate setsubstvars ALL RollPer1=Mar RollPer2=Apr

To check the variables have been set then the getsubstvar command can be used.

The syntax for the command is

epmautomate getsubstvar CUBE_NAME|ALL [name=VARIABLE_NAME]

Once again variables can be retrieve either at application level using ALL or by specifying the cube, there is also the option to specify the variable name to return the value for.

To return the value of the "RollPer1" variable which was just updated then you can simply use

epmautomate getsubstvar ALL name=RollPer1

To return all the variables at application level the following syntax can be used.

If you wanted to return variables that have been assigned at cube level, then you would just change ALL to the cube name.

Unlike with the set command it doesn’t look like you can define multiple variables as it returns all variables.

For the majority of situations, the EPM automate utility is perfectly acceptable for managing variables but if you want more flexibility over them or build into a current process then this is where the REST API can help.

The REST resources are available through the following URLs

For application level:

https://epm_cloud_instance/HyperionPlanning/rest/{api_version}/applications/{app_name}/substitutionvariables

For cube level

https://epm_cloud_instance/HyperionPlanning/rest/{api_version}/applications/{app_name}/plantypes/{cube_name}/substitutionvariables 

You can see the URL contains “plantypes” which is the way Essbase databases have been known in the planning world for a long time, there is now a transition to these being called cubes instead of plan types, in reality they the same thing but there will be a crossover period where there be reference to both naming conventions.

If you are retrieving variables, then you would use the GET method and if you are creating/updating then you would use the POST method.

When creating/updating variables the body of the POST requires the sub var details provided in JSON format.

The format for the JSON should be:

{  
   "items":[  
      {  
         "planType":"ALL|CUBE_NAME",
         "name":"SUB_VAR_NAME",
         "value":"SUB_VAR_VALUE"
      }
   ]
}

Basically there is an array called “items” which contains objects holding the name/value pairs for the sub var definition.

Using the REST resource, the value of the sub var “RollPer1” can be updated to “Apr” which I will demonstrate with a REST client.

If after a posting a success response is returned then this indicates there were no problems with the create/update of the variable.

To verify this, REST can be used again using a GET method to retrieve the variable details in JSON format, to return a single variable then the name of the variable can be added to the end of the URL.

To return all the variable at application level then you just wouldn’t include the variable name:

The same principal goes for cube level and the only difference is a slight change to the URL.

To create/update multiple variables the JSON just requires additional objects and sub var definitions adding to the “items” array.

To verify this a GET request can be made including the cube name in the URL.

Going back to where I started with this post and the rolling forecast functionality in the UI with the ability to shift periods, I thought I would put together a script to replicate this functionality and provide a fully automated solution.

This is just an example using PowerShell and no doubt it could be simplified further or written using different methods or scripting languages, the beauty is there are so many ways to achieve the same end result and it places the power in your own hands.

I have reset the sub vars back to the way they were so a start period of Jan and a start year of FY17, the example is based on a financial year starting in January.

The objective is to read in the current sub vars based on the prefix and then shift the periods/year depending on the value defined in a variable.

I am going to break the script into chunks and give an overview of what is happening, I am not including the authorisation header information as I have included that in previous posts and if you want to understand how it is done just revert back to them.

The above section defines the prefix of the sub vars which is “Roll” and they are set at application level, the number of periods to shift will be forward by one.

The sub vars REST resource is invoked using a GET method and the returned items are then stored.

The current value of all the rolling forecast variables are then displayed.

Next the number of months, start period and year are stored in variables.

I have displayed the variables to highlight they have been retrieved and stored correctly.

The next section loops through all the months in the forecast so in this example that will be twelve times.

During the first loop the start period and year are converted into date format and stored.

The date is then shifted by x number of months so in my case that will be one.

The date is then converted back in the correct format for the sub vars e.g. period=Feb and year=FY17

The converted dates are then stored and the loop continues until completed.

At this point if we take a look at what has been stored we can see the variable values have now been shifted forward by one.

The final section of the script creates an object with all the updated sub var information and converts that into JSON format.

A post is then made to the REST resource with the body containing the formatted JSON.

I have outputted the body of the post to show that the JSON is in the correct format.

Running another GET request to the REST resource verifies all the sub vars have been shifted forward by one month.

Opening the rolling forecast form also confirms that the all the variables have been correctly set.

Now I have an automated solution to manage the rolling forecast without the hassle.

So there we go, hopefully this post has provided a valuable insight into some of the options available to simplify the management of substitution variables.

Planning to FDMEE with a little help from Groovy

I was recently asked whether it would be possible to run FDMEE data load rules from within a planning task list, this was for an 11.1.2.4 on-premise environment.

Currently there is no default functionality to do this so if you want to be restricted to using what is available then the short answer would be no, if you are open to a little customisation then there are possible solutions and in this post I will cover one of the ideas I came up with.

Before thinking about planning it is worth understanding what options are available to run FDMEE rules outside of the user interface, if this was Oracle EPM Cloud then there are REST resources available which I blogged about here, at the time of writing this these have not yet made it down to on-premise but hopefully will soon.

For on-premise there is the option of calling SOAP based Web Services or posting to a java servlet which is the method the FDMEE batch scripts use, I wrote about both methods here.

Out of the options I decided on the servlet method as it is pretty simple to use and does not require additional configuration like the SOAP Web Services.

I am not going to cover all the details on the servlet as there is no point in duplicating what I have written in the past.

In summary the URL for the servlet is :

http(s)://<webserver>:<port>/aif/BatchExecutionServlet

The following parameters with assigned values should be posted to the servlet.

TYPE
RULE_NAME
IMPORT_FROM_SOURCE
EXPORT_TO_TARGET
EXEC_MODE
EXPORT_MODE 
EXC_RATE_FLAG
START_PERIOD_NAME
END_PERIOD_NAME
SYNC_MODE
USER_NAME
PASSWORD

An example of running an FDMEE data load rule would be:

A response would then be returned providing information on whether the rule was successfully started.

In my example I am setting the “SYNC_MODE” to false which means a response is returned once the rule has started or if there was a problem running the rule.

It is possible to set the value to true which will return a response once the rule has completed or failed, there are risks involved with this depending on the time the rule takes to run, you could end up holding on to sessions and generating stuck threads.

So now I have a method to run a rule but how can this be run from a planning task list.

For on-premise the list of available task types are:

Out of the list possibilities are either URL , Business rule or Form with Business Rule attached, the problem with URL is it will be using a GET method and there is not much room for it being dynamic.

Which leaves a business rule or a form containing a business rule, it is certainly possible to create a Java custom defined function to post to the servlet, the problem with CDFs is that they need to be compiled, copied to the correct location on the Essbase server, registered, if anything needs updating then we need to go through the process again which is not great.

Luckily there is another option, starting with Calculation Manager 11.1.2.4.006 there were two new CDFs introduced, @CalcMgrGroovyNumber and @CalcMgrGroovyString

There is currently not much in terms of documentation from Oracle on these functions, personally I think Calculation Manager documentation is pretty poor, anyway this is where Celvin comes to the rescue, Celvin has wrote a great OTN article which provides the lowdown on these functions

I am not going to steal any of Celvin’s limelight so go and read the article to understand the functions in detail, you may get sore eyes from some of the small screenshots though :)

Basically if you are running Calculation Manager 11.1.2.4.006+ and Planning 11.1.2.4.002+ you will be able to take advantage of this functionality, with these CDFs you can run Groovy scripts which will compile at runtime so you don’t get the headache like with Java CDFs

The OTN article focused on Essbase so I was keen to see if not only would it work with Planning but could it deliver my requirements.

There are a few configuration steps that are required before you can start using the Groovy functionality.

Download the latest Apache Groovy jar file.

Copy the jar to <MIDDLEWARE_HOME>\EPMSystem11R1\products\Essbase\EssbaseServer\java\udf

Create a whitelist properties file in the same directory to define which Java/Groovy packages/classes will be allowed in your Groovy scripts.

I included the following to be whitelisted.

You will see that I included the Calc Manager CDF logger class which helps provide additional logging to the one included with the Groovy CDFs.

The way I wanted to work with the Groovy functionality was to have a planning web form which would hold some information on the FDMEE rule, there would a business rule attached to the form with additional run time prompts, when running the business rule, the values held in the variables would be passed into the rule, the rule would then pass these into a Groovy script, the Groovy script would then make the http post to run the FDMEE rule based on the values passed into the script, the result of running the FDMEE rule would then be stored in the planning form and if there was a problem running the FDMEE rule an error message would be generated in planning.

It is much easier to understand if I break it down, starting with the business rule in Calculation Manager.

The first two "RUNJAVA" lines set the logging level and the format of the log, I have gone for “FINE” as it records the right level of detail in the log that I am looking for.

The default location of the log is the same as the essbase.log, it is possible to change the location of the log, in the end solution I set the log in the FDMEE shared location so it was easier to access it.

The third "RUNJAVA" line defines that script will be compiled as it will be run from within a FIX, the script is file based and located in the FDMEE shared location, I kept it there for ease of maintenance and migrations, finally a list of variables which will be passed into the Groovy script.

The next section of the script an Essbase calc script variable is defined which will hold the value returned from calling the Groovy script.

A FIX is used to narrow down the intersection of data on the planning form.

Member “FDMEE_Run_Date” will store the current date.

“FDMEE_Rule_Status” will hold the value returned from the Groovy script, the value determines the status of running the FDMEE rule, in planning the member has a Smart List assigned to provide a friendly status name instead of a number.

In my example I am using the @CalcMgrGroovyNumber function, the name of the script is included, it is a bit of a shame that when you are using a file you have to use the script name twice, it would be nice if you could allocate a name for the script instead of the full path.

There is then a list of variables and the values which are passed into the Groovy script, these are mainly set by run time prompts which you will see shortly.

I could have used the @CalcMgrGroovyString function but I wanted to return a value so I could then generate an error message to inform the user that running the rule failed and why it failed.

As for the Groovy script well I am not going to include every line of code but first static variables are defined and then the parameters and values are built up for posting to the servlet, the values are the ones passed into the Groovy script.

A single user with an encrypted password is used to run the FDMEE rules

I use the Calc Manager CDF logger class which I added to the whitelist properties file to write the full posting string to the log.

A http connection is made to the FDMEE servlet and the parameters posted to the servlet.

The response from the FDMEE servlet is then parsed and depending on the return string a value is returned to the business rule.

So let’s see it all in action, a form was created and added to a task list, the form displays the user and the available FDMEE load rules in the POV, these are controlled by access permissions.

Two members hold the status and date which you will have seen as part of the business rule.

The business rule was attached to the form.

Running the rule displays the list of run time prompts with default values which can be overridden.

I used substitution variables for the start and end period of the FDMEE load rule, I did have an issue in Calc Manager where if a string variable value contains a hyphen it would treat it as a number when passing into the rule, to get around this I had to remove the hyphen and then add it back in again in the Groovy script, I have never got round to looking if there is another way round this or if it is a bug.

I know I could have moved some of the variables into the form but most of this is for demo purposes and the final solution was slightly different, the good thing is there are different ways of achieving the same end result.

If there are no problems running the FDMEE rule the standard business rule information message is displayed.

Then the form is populated with the status and run date.

So let us run the rule again and enter an invalid value into a run time variable.

Now an error message is returned to the user.

The form is updated to reflect this error.

The form and rule with prompts can also be run from Smart View.

I also created a review form which shows the current status of the FDMEE rules that have been run from planning.

The log is formatted in the way I set in the business rule and contains the additional lines that I added in the Groovy script, using the “FINE” log level it also includes the value returned to the business rule.

Well there you go that was my first journey into using Groovy with planning which I hope you found interesting.