How to Reference One Rule into Another Using Namespace Identifiers in OneStream

When you’re dealing with various business rules in OneStream, things can get repetitive. Now, you might be thinking, “Can I just reuse some logic from one rule in another, instead of rewriting it from scratch?” The answer is a big YES. That’s where namespace identifiers come into play. It’s like giving your rules a clear address so they can talk to each other. Let’s dive into how you can make this happen.

Step 1: Understanding the Power of Namespace Identifiers

In simple terms, a namespace is like a folder or a container. It groups together related rules and methods, so when you reference it in another rule, you know exactly where to find what you need.

For example, imagine you’ve got a rule called “TaxCalculation”. Instead of copying and pasting that entire rule into every other rule that needs to calculate taxes, you can just call the specific method from that rule using its namespace.

Step 2: Create a Business Rule to Reference

Let’s say you’ve already got a rule that does some magic, like calculating a tax:

Namespace MyCompany.TaxRules
    Public Class TaxCalculation
        Public Shared Function CalculateTax(ByVal income As Decimal) As Decimal
            Return income * 0.15
        End Function
    End Class
End Namespace

Here, MyCompany.TaxRules is your namespace. You’re telling OneStream, “Hey, this is where all my tax rules live.”

Step 3: Referencing This Rule in Another Rule

Now you want to use this tax calculation in another business rule without rewriting the entire calculation logic. Here’s how you can do that:

1. Add a Reference to the Namespace in the new rule. So, when you write a new rule that needs the tax calculation, you just reference the namespace like this:

Namespace MyCompany.SalaryRules
    Public Class SalaryCalculation
        Public Shared Function GetNetSalary(ByVal grossSalary As Decimal) As Decimal
            Dim taxAmount As Decimal = MyCompany.TaxRules.TaxCalculation.CalculateTax(grossSalary)
            Return grossSalary - taxAmount
        End Function
    End Class
End Namespace

See what’s happening here? Instead of retyping all the tax logic, you just pull in the method from your TaxCalculation rule using the namespace MyCompany.TaxRules.

Step 4: Using the Shared Keyword

Notice that we used the “Shared” keyword. This is important because it allows other rules to access the method directly without creating an instance of the class. Think of it like making the method available to the whole OneStream application.

If you don’t make your function “Shared" you’d have to create a new instance of the class every time, which can be cumbersome and unnecessary. So, make sure you use “Shared” when you’re designing methods meant to be reused across multiple rules.

Step 5: Benefits of Using Namespace References

Here’s why you’d want to go through the effort of organizing your rules with namespaces:

• Reusability: Once a rule is written, you can call it in other rules without rewriting any logic.
• Maintainability: If the calculation changes, you only have to update it in one place, and it automatically reflects wherever the rule is referenced.
• Clarity: Your code stays clean. Instead of massive chunks of repeated logic, your rules are concise and easy to understand.

Step 6: Test and Debug

Of course, you’ll want to test everything out:

• Run a Script: Write a small script that references your namespace and calls the function to ensure everything works as expected.
• Check Logs: As usual, OneStream will let you know if there are any issues when calling namespaces or functions.

Wrapping Up

Using namespaces to reference one rule in another is a game-changer for simplifying your work in OneStream. It not only keeps things tidy but also saves time when changes are needed. By organizing your rules into namespaces, you can reuse code, maintain it easily, and focus on what really matters: getting things done efficiently.

So next time you’re working in OneStream, don’t just copy-paste your logic. Give your rules a proper namespace and reference them wherever needed!

Happy coding! 🎉