Why Groovy is Game Changing

ODTUG • KScope18 Slide 1
Why Groovy is Game Changing
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)

WHY IS GROOVY AND
PBCS
SO
GAME CHANGING
ODTUG • KScope18 2
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)

• Starbucks on us
• Questions and Answers
» We will answer questions throughout the
presentation
» Bring questions with your name/email/phone
number up to the front at the end of the
presentation and I will make sure they get
answered
HOUSEKEEPING
WELCOME

KYLE GOODFRIENDHuron Consulting / Oracle EPBCS Implementation Specialist
Professional and Personal
• BBA, concentration in Finance
• College professor for 5 years
• Started consulting in 2008
• 100% self taught (technology)
• Worked with Huron since 2013
(via ADI Strategies)
• Created In2Hyperion and the
Essbase Excel Ribbon
• Started the Columbus Hyperion
Customer Community
(CHCC.In2Hyperion.com)
• Love playing ice hockey, scuba
diving, and rescue dogs
• Have a beautiful wife that I drive
nuts
• Raising a son that is a walking
medical deductible
Planning and Essbase
• Worked with Hyperion since
1997
• Started learning Groovy in
August of 2017
• Worked with the cloud since
2015
• Hold certification in Hyperion
Planning, PBCS, and EPBCS
• Hold specialization in Pre-
Sales, Sales, and Support for
both Planning and Essbase
• Also a Microsoft Certified
Professional
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)

HOW TO CONTACT KYLE
kyle@in2hyperion.com
www.in2hyperion.com
kgoodfriend@huronconsultinggroup.com
ODTUG • KScope18
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM) 5

Sign up at
www.in2hyperion.com
to receive blog
updates through email
STAYING CONNECTED
IN2HYPERION
Join the LinkedIn
In2Hyperion Group
www.linkedin.com/
groups/4010770
LINKEDIN GROUP
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)

PRESENTATION PROGRESSION
01
GROOVY INTRODUCTION
What is Groovy
02
GROOVY AND PBCS
How does groovy benefit an
implementation
03
LEARNING CURVE
What to expect if you are not a
Groovy or Java programmer
04
FEATURE DEEP DIVE
Benefits, demos, and code reviews
05
07
LEARNING AS YOU GO
Don’t make the same mistakes I
made
06
GROWING PAINS
A new product, new integration,
watchout for these gotchas
08 RESOURCES
Where to go to get help
09 WRAPPING UP
Where to go from here
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)
THERE IS MORE
The opportunities are endless

GROOVY INTRODUCTION
Groovy has a lot to offer and the journey starts here
ODTUG • KScope18
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM) Slide 8

FLAVORS OF GROOVY
RELATED TO PBCS
Groovy can be used to access the API to
do all kinds of things, including
automation, system backups, and user
communication. This discussion will focus
on the ability to access Groovy INSIDE the
calculation manager only.
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)

Seamlessly and
transparently
integrates and
interoperates with Java
and any third-party
libraries
BENEFITS OF GROOVY
SMOOTH JAVA
INTEGRATION
Closures, builders,
runtime &compile-time
meta-programming,
functional
programming, type
inference, and static
compilation
POWERFUL
FEATURES
Concise, readable and
expressive syntax, easy
to learn for Java
developers
FLAT LEARNING
CURVE
Web development,
reactive applications,
concurrency /
asynchronous / parallelism
library, test frameworks,
build tools, code analysis,
GUI building
VIBRANT AND RICH
ECOSYSTEM
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)

Great for writing
concise and
maintainable tests,
and for all your build
and automation tasks
BENEFITS OF GROOVY
SCRIPTING AND
TESTING GLUE Apache Groovy is a powerful, optionally typed
and dynamic language, with static-typing and
static compilation capabilities, for the Java
platform aimed at improving developer
productivity thanks to a concise, familiar and
easy to learn syntax. It integrates smoothly with
any Java program, and immediately delivers
powerful features to your application, including
scripting capabilities, Domain-Specific Language,
authoring, runtime and compile-time meta-
programming and functional programming.
WHAT IS GROOVY
Flexible & malleable
syntax, advanced
integration &
customization
mechanisms, to integrate
readable business rules in
your applications
DOMAIN-SPECIFIC
LANGUAGES
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)

IMPACT TO
PBCS
DESIGN
AND
OPTIONS
AVAILABLE
• Java development is fast-tracked and
maintenance is simplified
• Developers get much of the functionality of
the Java API
• The knowledge required to construct complex
functionality is far less with Groovy
• PBCS is built with Groovy so it’s going to be a
part of the product roadmap
• Within PBCS
» Access to use groovy to interact with the user
» Customize commands sent to the Essbase

IMPACT TO THE
IMPLEMENTATION
How does addition of Groovy impact an
implementation
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)

IMPACT TO
BUILD
• Performance will improve
• Input validation will improve data input
• Developers will have a learning curve
• Timeline will increase
» Growing knowledge
» Additional functionality
WHAT YOU NEED TO KNOW

DEMONSTRATION
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)

GROOVY AND PBCS
Who can use it and in what capacity can it be used
ODTUG • KScope18

• ePBCS and PBCS+1 have access to create
Groovy calculations
• Groovy calculations open up the Java API and
provide a user experience never before
available
• Have access to use groovy to interact with
the user and customize commands sent to
the PBCS
There is currently no expectation that Oracle will make
Groovy Calculations available in future on-premise releases
GROOVY
AVAILABILITY AND
LICENSING
ODTUG •
KScope18 17
Wed, Jun 13, 2018 (03:30 PM -
04:30 PM)

FUNCTIONAL OVERVIEW
Proactive User Input Validation
Users are promptedfor input frequently for
things like employee, project, capex, and
product properties. This data canbe validatedprior to any business logic to ensure consistent
andvaliddata input.
Proactive Data Validation
User input canbe validatedandcaninterrupt
the data formsave proactively. For example, if
anemployee is not fully allocated, the formwill
not save until it is 100%.
Selective Data Synchronization
Data between input and reporting applications can
be near real-time because synchronization is
isolated to only the edited or effected data. It can
now be executed on form save due to performance
improvements.
Selective Business Logic Execution
Users cannowsee significantly improved
performance ondata forminput because the
business logic canbe isolatedto only what has
beenchangedor effected.
Access to Java Functions
Logic that couldn't be completed, or wasn't
because of performance issues cannowbe
accessedandexecutedat lighteningspeed. Developers nowhave access to functions
fromthe Java API.
Real-Time Consolidated Reporting
Data betweenapplications, like workforce,
capital, anda consolidatedP&L canbe
synchronizedinreal-time without timely data
consolidations.

FUNCTIONAL OVERVIEW
Execute CalculationLogic onASO
Prior to the availability of Groovy, business logic
onASOwas not available. Now, all logic that
exists inBSOdatabases is available throughthe
Java API andcanbe executeddirectly inASO.
Advanced FormTraffic Lighting
Simple andextremely complex color coding can
be addedto forms onloadandonsave. The
possibilities are endless andare completely
customizable.
CustomLogging
Developers have complete control over what is
loggedfor review. User information, POV
selections, timing, anddata that has changed,
are just a sample of what canbe logged.
CustomUser Errors
Custommessages in an infinite number of
languages canbe displayedinprompts and
addedtocells tocommunicate changes, rule
violations, anderrors.
Interaction with Strategic Modeling
Data movement to and from Strategic
Modeling can be done in real-time on form
save.

PERFORMANCE
IMPROVEMENTS
The speed and agility that Groovy provides in
customizing calculations introduces consolidated real-
time reporting
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)

REAL WORLD USER EXAMPLE (SPEED &
FUNCTIONALITY)
99%IMPROVEMENT 98% 99%
Reporting includes all updates from
detailed modules (product, Capex,
workforce, and similar modules) and
is included in
real time as changes are made
Consolidated Reporting
workforce, and similar modules) at
scheduled intervals
users have to wait to see
consolidated information
Groovy eliminates the need to
consolidate the BSO cube and
copies data directly from the
ASO cube at a consolidated
level
.2 Seconds
Dimensions are consolidated
and copied to the P&L model
82.9 Seconds
Consolidated P&L
Product detailed dimensions
are consolidated and moved
to the P&L model
Groovy selects only the cells
that where edited and copies
only what changed to the
reporting model
1.0 Seconds
All data on the form is
synchronized
14.5 Seconds
Smart Push
Data synchronizes to the
reporting cube for analysis
01
0110
0001
01101
Groovy selects only edited
cells and executes the logic
on only products and periods
that changed
0.3 Seconds
All products on the form are
calculated
26.1 Seconds
Business Logic
Growth rates are entered at
total product breakouts and
allocated to the detailed level
With the inclusion of Groovy
and access to the Java API,
more customization can be
integrated to maximum
performance and achieve real
time consolidated reporting
Submit
Planner Input
User submits updates to the
Gross Proﬁt model at a
detailed product level that
exists at a more granular level
than in the P&L model
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)

workforce, and similar modules) and
is included in
real time as changes are made
Consolidated Reporting
workforce, and similar modules) at
scheduled intervals
users have to wait to see
consolidated information
REAL WORLD PROCESS EXAMPLE (SPEED &
FUNCTIONALITY)
Automated Process
Administrative processes are
executed to run all business
logic and model
synchronizations
The entire data set is
consolidated and moved to
the P&L model
12.0 Seconds
Dimensions are consolidated
and copied to the P&L model
663.6 Seconds
Global Consolidation
Global product consolidations are
often required to catch all changes
and completed during
maintenance windows
99% 99%
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)

REAL-TIME
CONSOLIDATED
REPORTING

Idenfity the candidates that will benefit using Groovy
Calculations
ODTUG •
KScope18
Wed, Jun 13, 2018 (03:30 PM -
04:30 PM)
24
SHOULD YOU CONSIDER
GROOVY?

SHOULD
YOU
CONSIDER
GROOVY AS
AN OPTION
NEW
IMPLEMENTATIONS
• On-premise implementations that want better
performance
• PBCS implementations that have performance
issues because of
» Large dimensions
» Complex calculations
» Detailed planning input
» Lack of real-time reporting
• Implementations that need more complex user
input validation
• Applications that want proactive data validation

SHOULD
YOU
CONSIDER
GROOVY AS
AN OPTION
EXISTING
IMPLEMENTATIONS
• Have complex models
• Have large dimensions
• Require data input validation
• Require real-time consolidated reporting

SO, WHO SHOULD CONSIDER GROOVY?
ODTUG • KScope18
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM) 27

THE LEARNING CURVE
For those who have Groovy or Java backgrounds, this
should be easy. For the rest of us, there is a learning
curve.
ODTUG • KScope18

EXPERTISE NEEDED
Intuitive Developers
Groovy may be built on Java, but Java developers are not
required to successfully implement Groovy into PBCS.
Experienced developers who have knowledge within PBCS
and understand that basic functionality with scripting will
be able to use Groovy training materials and global rules to
build an application with groovy that fits a clients
performance needs. It only takes a little groovy knowledge
to exponentially improve ePBCS performance.
Visionary Managers
Managers who can understand, interpret, and plan the
execution of requirements with Groovy will build
exceptional applications. Managers will communicate how
Groovy fills performance gaps that existed prior to its
release and help clients understand why Groovy is a
necessary element of any planning application.
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)

THREE
ASPECTS
TO LEARN
• PBCS API (methods and properties available to
interact with PBCS)
• Groovy (Open source development language)
• Middle ground (the overlap)
Growth of PBCS API Growth of Groovy
Productivity

FEATURE DEEP DIVE
Ready, set, go! Take it all in. This is where things get
really Groovy.
ODTUG • KScope18

CHANGING
NAMES TO
PROTECT
THE
INNOCENT
• The application is a replica of live application
• Size of the application is twice the size of BBG
• The volume of metadata is the same
• The metadata has been changed to protect the
innocent
• The data has been altered

ODTUG • KScope18
REAL-TIME CONSOLIDATED REPORTING

REAL-TIME
CONSOLIDATED
REPORTING
Detailed
App
Consolidated
P&L
Detailed
App
Consolidated
P&L
NON GROOVY
• All dimensions need to be
consolidated
• Movement from ASO is not possible
• Movement is batched and scheduled
WITH GROOVY
• NO BSO consolidation is required
• Data can be transferred from ASO
• Movement is executed on form
save

REAL-TIME
CONSOLIDATED
REPORTING
DATA FLOW
PART 1
• Intra-model (GP) data movement
User Enters
Data
Data Saved
to BSO
Business
Logic Runs
Smart Push
to ASO
Consolidated
Data
These objects are all physical artifacts in the Planning application
1. The user submits changes to the data in a data form
2. The data is stored in the BSO database
3. The appropriate business logic is executed on the respective POV
4. A Smart Push is executed to move the updated data to the ASO database
5. The data is available at consolidated levels
* In the sample application, this application includes breakouts that the P&L
cube does not have (Product, Order Method, and Delivery Channel)

REAL-TIME
CONSOLIDATED
REPORTING
DATA FLOW
PART 2
• Inter-model data movement
Virtual forms can be created to simulate a data retrieve and data submission
1. A virtual form is dynamically created on the POV to retrieve data from the
GP ASO database to pull consolidated data at the dimensions that don’t
exist in the P&L database.
2. Virtual forms is dynamically created on the POV to submit data to the P&L
ASO and BSO databases
3. Data from the form in step 1 is copied to the forms in step 2 and submitted
to both P&L cubes
* No consolidation calculations are required
P&L ASO
Database
Consolidated
GP Retrieve
P&L BSO
Database
P&L
Connection
Virtual Artifacts Physical Artifacts

DEMONSTRATION
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)
We will kickstart the feature deep-dive with a real world process that
encompasses many of the things we are going to discuss in detail,
including
• Data input validation
• Traffic lighting
• Custom Essbase calculations
• Customized data copies / smart pushes
• Eliminations of the need for consolidations via GridBuilder
processing

ODTUG • KScope18
TRAFFIC LIGHTING

TRAFFIC
LIGHTING
• Interact with users
• Draw attention to important data
• Indicate possible issues by thresholds
• Show required inputs
• Highlight variances and other critical metrics
BENEFITS

TRAFFIC
LIGHTING
• Set background colors
• Set cell tool tips
• Add validation without throwing errors – act
like warnings
• Add validation and stop form from saving
OPTIONS

TRAFFIC
LIGHTING
DataGrid curDataGrid = operation.grid
def iColor = 16746496
def sValidateTo = curDataGrid.getCellWithMembers('Input').data
/* can add destCell && to the if and it will ignore the null columns
*/
operation.grid.dataCellIterator('Avg_Price/Case','Input').each
{ DataCell destCell = it.crossDimCell('Initialize')
if(it.data.round(2) != destCell.data.round(2)) {
println it.data.round(2)
println destCell.data.round(2)
it.setBgColor(iColor)}
}
operation.grid.dataCellIterator('Regular_Cases','Input').each{
DataCell destCell = it.crossDimCell('Initialize')
println destCell.data.round(2)it.setBgColor(iColor)
}
}
operation.grid.dataCellIterator('Net_Sales','Input').each{
it.setBgColor(iColor)
}
}
operation.grid.dataCellIterator("GP_Level_2","Input").each
{
if(it.data.round(2) != destCell.data.round(2)) {println it.data.round(2)
}
}
CODE REVIEW
operation.grid.dataCellIterator("Case_Growth",'Input').each
{
DataCell destCell = it.crossDimCell('Initialize')if(it.data.round(2) != destCell.data.round(2)) {
}}
operation.grid.dataCellIterator('Sales_Growth','Input').each
{
DataCell destCell = it.crossDimCell('Initialize')if(it.data.round(2) != destCell.data.round(2)) {
}
operation.grid.dataCellIterator("GP_2_%_Diff",'Input').each
{ DataCell destCell = it.crossDimCell('Initialize')
}

ODTUG • KScope18
DYNAMIC ESSBASE CALCULATIONS

DYNAMIC
ESSBASE
CALCULATIONS
• Improve performance
• Improve user experience
BENEFITS

EXAMPLE
DYNAMIC
ESSBASE
CALCULATIONS
Legacy Business Rule
• Provides the ability to
pass the POV
(Page/Header) to a
business rule to isolate
what is calculated
• Executes on all rows and
columns regardless of the
state of the data
Groovy Calculation
• Can access the same
POV and can
dynamically change
business logic based on
selections
• Can identify the
changed cells and alter
the business logic based
on results

DYNAMIC
ESSBASE
CALCULATIONS
// Set variables and loop through edited cells
Set<String> periods = []
Set<String> products = []
operation.grid.dataCellIterator({DataCell cell -> cell.edited},
MemberNameType.ESSBASE_NAME).each { DataCell cell ->
periods << cell.periodName
products << cell.getMemberName("Product")
}
// Exit the script it no cells were edited
if(products.size() == 0) {
println("No edited cells found!")
return
}
// Construct the calculation script to be sent to Essbase
String calcScript = """
Fix("${povMemberNames.join('", "')}",
"${periods.join('", "')}",
"${products.join('", "')}")
"Revenue"(
"Revenue" = ”Avg_Price" * "Units";)
EndFix;"""
// Print the script to the log
println("The following calc script was executed by
$operation.user.fullName: n $calcScript")
// Return the calculation script to be executed
return calcScript.toString()
CODE REVIEW

ODTUG • KScope18
FILTERED DATA MAPS

FILTERED
DATA
MAPS
• Improve speed of data movements
• Miminize possible threasholds for clearing
target before loading
• Minimize possible threasholds in size of data
• Eliminate need to run in background
• Give user feedback on completion
BENEFITS

FILTERED
DATA
MAPS
// Get POV
String sCompany =
operation.grid.getCellWithMembers().getMemberName("Company")
String sMaterialGroup =
operation.grid.getCellWithMembers().getMemberName("Material_Group")
String sChannel =
operation.grid.getCellWithMembers().getMemberName("Channel")
String sAccount =
operation.grid.getCellWithMembers().getMemberName("Account")
// Get list of vendors that have been edited
def lstVendors = []
operation.grid.dataCellIterator({DataCell cell -> cell.edited}).each{
lstVendors.add(it.getMemberName("Vendor"))
}
// Convert collection to comma delimited string
String strVendors = """"${lstVendors.unique().join('","')}""""
// Execute a filtered data map based on the POV and edited vendors
if(lstVendors)
operation.application.getDataMap("GP Form Push").execute
(["Company":sCompany,"Channel":'ILvl0Descendants(Channel)’,
"Material_Group":'ILvl0Descendants(Material_Group)’,
"Vendor":strVendors,
"Scenario":"OEP_Plan",
"Version":"OEP_Working",
"Years":"&v_BudYear",
"Source":"Input",
"Currency":'"USD","Local"'],true)
CODE REVIEW

ODTUG • KScope18
GRID BUILDERS

GRID
BUILDERS
• Move data from ASO to BSO
• Include mappings when pushing data from BSO
to ASO
• security issues with Data Maps/Smart Pushes
also exist
• Perform calculations outside of Essbase
• Performance improvements over Data
Maps/Smart Pushes
• Write directly to ASO (bypass BSO and Essbase
calculations)
BENEFITS

CODE
REVIEW
GRID
BUILDERS
I will be doing a 20-30 minute deep dive on the
GridBuilder methods
Last Minute ODTUG Kscope18 Planning
Souvenirs You Will ACTUALLY Use!
June 14th
, 9:30 - 11:00 a.m.
Southern Hemisphere II, Fifth Level

ODTUG • KScope18
CUSTOMIZED LOGS

BENEFITS • Completely customizable
» User who executed it
» Execution times
» POV
» Dynamic calculation sent to Essbase
• Unlimited possibilities
CUSTOMIZED LOGS

EXAMPLE Log messages :
****************************************************
Time taken for allocation and consolidation = 0 secs
Total Time = 0.001 secs
****************************************************
data push running for
"v30000400030001","v30000400030002","v30000400060001","v30000401630001","v300004000
80004","v30000400080002","v30000400080001"
****************************************************
Time taken for data push = 2.051 secs
****************************************************
POV:
[FY17, OEP_Forecast, OEP_Working, BILB, Tot_Channel, Total_Material_Group,
Tot_Source, Tot_Vendor, MTD]
ROWS HEADER:
[[Regular_Cases], [Net_Sales], [Cost_of_Sales_without_Samples], [Gallonage_Tax],
[Depletion_Allowance_Manual_Chargeback], [Gain_Loss_Inv_Reval],
[Supplier_Commitments], [Supplier_Spend_Non_Committed], [Samples], [GP_NDF],
[GP_BDF], [GP_Contract_Amortization], [Sample_Adjustment]]
COLUMNS:
[Jan, Jan, Feb, Feb, Mar, Mar, Apr, Apr, May, May, Jun, Jun, Jul, Jul, Aug, Aug,
Sep, Sep, Oct, Oct, Nov, Nov, Dec, Dec]
[Local, USD, Local, USD, Local, USD, Local, USD, Local, USD, Local, USD, Local,
USD, Local, USD, Local, USD, Local, USD, Local, USD, Local, USD]
Total number of cells accepted: 312
Total number of cells rejected: 0
First 100 rejected cells: []
Total number of cells accepted: 312
Total number of cells rejected: 0
First 100 rejected cells: []
****************************************************
Time taken copy to fin = 0.48 secs
****************************************************
CUSTOMIZED LOGS

CODE
REVIEW
def startTime = currentTimeMillis()
def procTime = currentTimeMillis()
def elapsed=(currentTimeMillis()-startTime)/1000
Calendar calendar = Calendar.getInstance()
calendar.setTimeInMillis(currentTimeMillis())def now = calendar.getTime()
def dtstmp = now.format("MM/dd/yyyy")
elapsed=(currentTimeMillis()-procTime)/1000
procTime = currentTimeMillis()println "****************************************************"
println "Time taken for allocation and consolidation = $elapsed secs"println "Total Time = " + (currentTimeMillis()-startTime)/1000 + " secs"
println "****************************************************"
[Code Removed]String strVendors = """"${lstVendors.unique().join('","')}""""
println "data push running for " + strVendors[Code Removed]
procTime = currentTimeMillis()
println "****************************************************"
println "Time taken for data push = $elapsed secs"println "Total Time = " + (currentTimeMillis()-startTime)/1000 + " secs"
println "****************************************************"[Code Removed]
println "POV:"
println povmbrs*.essbaseMbrNameprintln ""
println"ROWS HEADER:"
println rowmbrs.headers*.essbaseMbrName
println ""
println"COLUMNS:"
println colmbrs[0]*.essbaseMbrName
println colmbrs[1]*.essbaseMbrNameprintln ""
println ""
[Code Removed]println("Total number of cells accepted: $status.numAcceptedCells")
println("Total number of cells rejected: $status.numRejectedCells")println("First 100 rejected cells: $status.cellsRejected")
finCube.saveGrid(grid)
println("Total number of cells accepted: $rstatus.numAcceptedCells")
println("Total number of cells rejected: $rstatus.numRejectedCells")println("First 100 rejected cells: $rstatus.cellsRejected")
rfinCube.saveGrid(rgrid)
procTime = currentTimeMillis()println "****************************************************"
println "Time taken copy to fin = $elapsed secs"
println "Total Time = " + (currentTimeMillis()-startTime)/1000 + " secs"
println "****************************************************"
CUSTOMIZED LOGS

ODTUG • KScope18
RUN TIME PROMPTS

RUN TIME
PROMPTS
• Conditional execution
» Confirm long process or processes that clear or
reset data
» Confirm what processes will be executed
• Validate input before RTP use
» Check for special characters
» Verify start and end dates
BENEFITS

DEMONSTRATION
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)
RTP Validation has huge impacts on system perceptions.
It can stop invalid data from being entered and confirm
expectations before long running processes
• WFP Data input (validate name, start and term dates)
• Execute global consolidations

RUN TIME
PROMPTS
/*RTPS: {RTP_Push},{RTP_Clear},{RTP_Name} */
if(rtps.RTP_Push.getEssbaseValue() == "1"){
operation.application.getDataMap("GP Form Push").execute(
["Company":"ILvl0Descendants(Company)",
"Channel":"ILvl0Descendants(Channel)",
"Material_Group":"ILvl0Descendants(Material_Group)",
"Vendor":"ILvl0Descendants(Vendor)",
"Scenario":"OEP_Plan",
"Version":"OEP_Working",
"Years":"&v_BudYear",
"Source":"ILvl0Descendants(Source)",
"Currency":'"USD","Local”’],
rtps.RTP_Push.getEssbaseValue().toBoolean()
)
def isValid = true
def specialCh = ['!','@',']','#','$','%','^','&','*']
for (int i=0; i<specialCh.size; i++) {
if(rtps.RTP_Name.getEnteredValue().contains(specialCh[i]))
isValid=false
}
if(isValid == true)
{
}
CODE REVIEW

RUN TIME
PROMPTS
/*RTPS: {RTP_Description} */
// Define Message Bundle
def mbUs = messageBundle([
"validation.SpecialChar":"Only alphanumeric characters are permitted"])
def mbl = messageBundleLoader(["en" : mbUs])
def isValid = true
// Define the list characters NOT allowed
def specialCh = ['!','@',']','#','$','%','^','&','*']
for (int i=0; i<specialCh.size(); i++) {
if(rtps.RTP_Description.toString().contains(specialCh[i]))
isValid = false
}
if(isValid == false)
{
throwVetoException(mbl, "validation.SpecialChar",
rtps.RTP_Description)
}
CODE REVIEW

ODTUG • KScope18
DATA FORM VALIDATION

DATA
FORM
VALIDATION
• Improve the reliability of the data entered
• Proactively fix errors before they become
problems
• Educate users on the fly
• Stop users from entering any data until it
validates
• Improve validity of budgets
BENEFITS

DEMONSTRATION
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)
Interractive data validation on forms can improve user
input and eliminate data issues before they exist
• WFP Data input (ensure correct data is entered to
correspond to the employee selections)
• Gross Profit Spreading (make sure adjustments to
monthly volumes aren’t adjusted outside
predetermined thresholds)
• New Products (improve consistency with data input)

EXAMPLE
DATA
FORM
VALIDATION
• Any validation that can be done using member
names, hierarchies or math is possible
• Example
» The GP Level 2 % has to be between -10% and 30%.
» The Regular Cases CANNOT have one month that is more than 50%
of the total cases.
» If Regular Cases is entered, a corresponding Average Price per Case
is required.
NEW PRODUCT EXAMPLE

DATA
FORM
VALIDATION
def BackErrColor = 16755370 //Red
def BackWarnColor = 16756480 //Orange
operation.grid.dataCellIterator('Regular_Cases','Jan','Feb','Mar','Apr'
,'May','Jun','Jul','Aug','Sep','Oct','Nov','Dec').each {
// Check cases
def CaseTotal = it.crossDimCell('Jan').data +
it.crossDimCell('Feb').data + it.crossDimCell('Mar').data +
it.crossDimCell('Apr').data + it.crossDimCell('May').data +
it.crossDimCell('Jun').data + it.crossDimCell('Jul').data +
it.crossDimCell('Aug').data + it.crossDimCell('Sep').data +
it.crossDimCell('Oct').data + it.crossDimCell('Nov').data +
it.crossDimCell('Dec').data
println "$it.MemberNames $it.data $CaseTotal"
if(it.data / CaseTotal > 0.5 ) {
println "warning"
it.addValidationError(BackErrColor, "Cases for a single month can't
be more than 50% of the total year cases.", false)
}
if(it.data != 0 && (it.crossDimCell("Avg_Price/Case_Inp").data == 0
|| it.crossDimCell("Avg_Price/Case_Inp").data == '#Missing'))
it.crossDimCell("Avg_Price/Case_Inp").addValidationError(BackErrColor,
"A price is required when cases are entered.", false)
}
operation.grid.dataCellIterator('GP_2_%_Inp','Jan','Feb','Mar','Apr','M
ay','Jun','Jul','Aug','Sep','Oct','Nov','Dec').each {
// Check cases
println "$it.MemberNames $it.data"
if(it.data > 0.3 || it.data < -0.1 ) {
println "invalid"
it.addValidationError(BackErrColor, "GP2 has to be between -10% and
30%.", false)
}
}
CODE REVIEW - NEW PRODUCT

EXAMPLE
DATA
FORM
VALIDATION
• Example Adjustments can be made to any
month
»The net change has to be 0
»No change can push the number to a
negative number
PHASING EXAMPLE

DATA
FORM
VALIDATION
def BackErrColor = 16755370 //Red
operation.grid.dataCellIterator({DataCell cell ->
cell.edited}).each {
// Check cases
def CaseTotal = it.crossDimCell('Jan').data +
it.crossDimCell('Feb').data + it.crossDimCell('Mar').data +
it.crossDimCell('Apr').data + it.crossDimCell('May').data +
it.crossDimCell('Jun').data + it.crossDimCell('Jul').data +
it.crossDimCell('Aug').data + it.crossDimCell('Sep').data +
it.crossDimCell('Oct').data + it.crossDimCell('Nov').data +
it.crossDimCell('Dec').data
if(it.data + it.crossDimCell('OEP_Working').data < 0.0)
{
def change = it.data + it.crossDimCell('OEP_Working').data
it.addValidationError(BackErrColor, "Your adjustment forces
the new cases to be a negative volume. Increase your
adjustment by $change", false)
}
else
{
if(CaseTotal != 0.0 && it.data != 0.0) {
println "net change is not 0 - $it.MemberNames"
it.addValidationError(BackErrColor, "Adjustments must not
have a full year impact. Currently, the data would change
by $CaseTotal.", false)
}
}
}
CODE REVIEW - PHASING

THERE IS MORE
We covered the biggest bang for your buck. The
opportunities to improve applications doesn’t stop
there. When you leave here, take a look at some of the
other things that make the inclusion of Groovy into
PBCS special.
ODTUG • KScope18

MORE
STUFF
THAN YOU
CAN SHAKE
A STICK AT
• Query metadata
• Localized messages
• Smartlist integration
• Modularized code
• Customized logging
• Clearing ASO data
OTHER POSSIBILITIES

THINKING OUTSIDE THE BOX
ODTUG • KScope18
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM) 71

With Groovy, business
logic can be written
and executed, with
results stored in ASO
BUSINESS LOGIC CAN BE EXECUTED IN ASO VIA
GROOVY
BUSINESS LOGIC
Allocation logic can be
processed in Groovy
with the results stored
in ASO
ALLOCATIONS
Data can be loaded to
ASO, but has minimal
calculation logic
ASO LIMITATIONS
Currency exchange
rates can be accessed
and used to calculate
and store USD
equivalents
FX RATES
Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)

ACCESS TO
JAVA
FUNCTIONS
• Java functions are available. These can
introduce opportunities to do things never
before available or improve on functions in
Essbase that introduce performance
degradation.
» Math
» Strings
» If/Then logic
» Mapping
» Comparisons

GROWING PAINS
Released in June, and just now being included in a
larger volume of implementations, there are still some
issues/bugs that are causing complications with going
live.
ODTUG • KScope18

GROWING
PAINS
• 9 months into use
• Just starting to be heavily used/globally tested
• Current Issues
» Groovy rules included in rulesets do not execute
from an action menu in Smart View
• Edited cells do not stay edited with Groovy
validation rules executed before save in Smart
View
• The data in hidden columns/rows is not
accessible in a Groovy rule in Smart View (will
return a null pointer error)

GROWING
PAINS
• Groovy documentation shows methods that
are not accessible
• Many documented methods are still private
and not available
» Substitution variable
» Get content of rule

HOW TO
GET WHAT
YOU WANT
• Open a ticket immediately
» Call 1-800-223-1711
» Press 1 and enter your SR number
» Press 2 to speak with a manager
do not press 1 to speak with Engineer, this will likely result in going
straight to Voicemail
» Tell the Support Hub the critical impact you are facing
» Request a Duty Manager callback ASAP
» Repeat request level 2, then level 3, to level n, until you get what you
want
• Some helpful tips:
» Speak with the support hub manager
» Describe the impact, include key project milestones at risk and
communicate what you need for progress
» If your issue is CRITICAL you should ALWAYS make a request for a duty
manager call back.
» If you ask for a duty manager call back, wait 30-60 minutes until you
receive the call and reiterate the problem
» Be strategic with your request
» Don't just say you need to escalate - describe the impact and
communicate what you need for progress
» Keep in mind, your SR will NOT appear in an "escalated" state unless
you negotiate this with a duty manager
WORKING WITH SUPPORT

LEARNING AS YOU GO
There is a lot to be excited about. There are times when
you forge ahead at lightening speeds. There are other
times when you may want to think before you run.
ODTUG • KScope18

WALK
BEFORE
YOU RUN
• Develop standards and be consistent
» Getting POV members
» Looping through edited rows
» Variable definition
• As soon as code is identified to be used in
multiple rules, modularize it
• When you get stuck, identify the issue as
something related to the PBCS API vs. Groovy
and research a solution appropriately
• Data can be moved with Data Maps and Grid
Builders and a strategic decision on which
should be used should be made before
implementation
SUGGESTIONS FROM EXPERIENCE

WALK
BEFORE
YOU RUN
• GridBuilder has a cell limit (pre-suppression) of
500,000
• You will see better performance with getting cell
content using CrossDimCell vs.
getCellWithMembers
• Use functions (e.g. IDecendants) to build your grids
when possible, as it is faster than adding all rows
and suppressing
• GridBuilder uses GridDefinitonBuilder, so it can be
slower in bigger grids. GridDefinitionBuilder is
faster because you specify the dimensions for each
member
• Favor the use of .withCloseable{} when building,
loading, saving, a grid. Better memory
management.
UNDOCUMENTED FINDS

RESOURCES
Everybody needs help. Here is where to start
ODTUG • KScope18

GETTING
HELP
There are a lot of great books, articles and videos about Groovy listed here:
http://groovy-lang.org/learn.html
In particular, I would like to highlight the following two books:
https://www.manning.com/books/groovy-in-action-second-edition
https://pragprog.com/book/vslg2/programming-groovy-2
The following course on Udemy is very affordable and can be a useful asset:
https://www.udemy.com/apache-groovy/learn/v4/overview
They can also start by going over the “Language Specification” section in the
following document is also useful:
http://groovy-lang.org/documentation.html
Oracle EPBCS Groovy documentation:
http://docs.oracle.com/cloud/latest/epm-common/GROOV/
http://www.in2hyperion.com

MORE
EXAMPLES
AT
• My Adventures inGroovy Calculations -
Part 1
• Part 2: Data Validation
• Part 3: Acting OnEditedCells
• Part 4: RunTime Prompts
• Part 5: Accessing RunTime Prompts
• Part 6: Converting a POV into a Fix
• Part 7: Validating RunTime Prompts
• Part 8: Customizing Data Maps andSmart
Pushes
• Part 9: Groovy andPBCS is Game
Changing inLouisville
• Part 10: Validating FormData
• Part 11: Accessing Metadata Properties
• Part 12: Learning andTesting Groovy
Outside of PBCS
• Part 13: Returning Errors (Data Forms)
• Part 14: Returning Errors (Data Form
Cells)
• Part 15: Returning Errors (RTP Edition)
addenhancement andother bug report
GROOVY SERIES
• Part 16: Ignore FormSave WhenNo Data
Has BeenEdited
• Part 17: Force Cell Comments
• Part 18: Real Time Data Movement
(Setting The Stage)
• Part 19: Real Time Reporting Webinar
withBreakthruBeverage Group
• Part 20: Groovy On-Premise vs. GroovyCloud
• Part 21: Real Time Data Movement
(Getting Groovy)
• Part 22: Looping ThroughMember
Descendants
• Part 23: Is the POV a level 0 member?
• Part 24: Getting Member Properties?
• Part 25: The DataGridBuilders
• Part 26: Interacting withSmart Lists
• Part 27: Using Maps inGroovy as lookup
Tables

WRAPPING UP
I hope you enjoyed the show, but we aren’t quite done
yet.
ODTUG • KScope18

WRAPPING
UP
• Write down a question and drop it off up front
and I will answer it at in2hyperion.com
• Please be gentle when you fill out a survey
LAST BUT NOT LEAST

APPENDICES
ODTUG • KScope18

CREATING
YOUR FIRST
GROOVY
SCRIPT
• Open Rules in PBCS and create a new rule
• Change the dropdown box from Designer to
Edit Script
• Change the Script type dropdown box from
Calc Script to Groovy Script

Wed, Jun 13, 2018 (03:30 PM - 04:30 PM)

Why Groovy is Game Changing

More Related Content

Similar to Why Groovy is Game Changing (20)

More from Kyle Goodfriend (13)

Recently uploaded (20)

Why Groovy is Game Changing