Currency Input Field Rounding Issues with Decimal Values Above 10,000 (Ex.: 200,300.57) - Need Plugin Recommendation

Question

I'm working on a custom currency input field component and facing a challenging issue with decimal value conversion and rounding when values exceed 10,000 (5+ digits).
Here's my current implementation:

a!localVariables(
  a!textField(
    label: ri!label,
    labelPosition: a!defaultValue(ri!labelPosition, "ABOVE"),
    value: a!currency(
      isoCode: a!defaultValue(ri!isoCode, "BRL"),
      value: rule!process_BRLInputSanitizer(
        value: ri!value,
        toDecimal: true,
        showSeparators: false
      ),
      decimalPlaces: 2,
      showSeparators: true
    ),
    placeholder: ri!placeholder,
    saveInto: a!localVariables(
      {
        a!save(
          ri!value,
          a!currency(
            isoCode: a!defaultValue(ri!isoCode, "BRL"),
            value: rule!process_BRLInputSanitizer(
              value: save!value,
              toDecimal: true,
              showSeparators: false
            ),
            decimalPlaces: 2,
            showSeparators: true
          ),
          
        ),
        ri!saveInto
      }
    ),
    disabled: a!defaultValue(ri!disabled, false),
    readOnly: a!defaultValue(ri!readOnly, false),
    refreshAfter: "KEYPRESS",
    validations: { ri!validations },
    showWhen: a!defaultValue(ri!showWhen, true),
    instructions: ri!instructions,
    helpTooltip: ri!helpTooltip
  )
)
Supporting Rule (process_BRLInputSanitizer):

a!localVariables(
  local!toDecimal: a!defaultValue(ri!toDecimal, false),
  local!value: tostring(ri!value),
  local!left: substitute(local!value, ",", "."),
  local!right: substitute(local!value, ".", ","),
  local!result: if(
    local!toDecimal,
    concat(
      left(local!right, len(local!right) - 3),
      right(local!left, 3)
    ),
    concat(
      left(local!left, len(local!left) - 3),
      right(local!right, 3)
    )
  ),
  if(
    a!defaultValue(ri!showSeparators, true),
    local!result,
    if(
      local!toDecimal,
      substitute(local!result, ",", ""),
      substitute(local!result, ".", "")
    )
  )
)

The Problem: When the system casts the value back to a Decimal type, it rounds the value incorrectly when it exceeds 10,000 (5+ digits). I need the value to remain as a precise Decimal because my Record Type field that integrates with the backend requires decimal format.

Questions:

Why does this rounding occur specifically when values exceed 5 digits?
Is there an existing plugin or component that handles dynamic currency formatting (showing decimal separators while the user types) that maintains decimal precision?
If such a plugin exists, it would save me from building this from scratch.

I'm essentially trying to create a currency input that displays proper formatting (R$323,845.27) while maintaining the underlying decimal value for record Type integration.
Any recommendations for existing solutions or insights into the rounding behavior would be greatly appreciated!
Thank you all for your time and assistance.

mikes0011 · Accepted Answer

What if, my record type value is a Decimal? How am I going to handle it if the value is always being casted

You're overcomplicating this. Store the decimal value only, and only worry about formatting it anytime it's output to a user-facing display. That should be it.

Appian will always displays the imprecise value. There is no other way without using a string.

The correct decimal value is stored correctly in a decimal type variable, whether that's a record field or CDT field. Remember that what's "displayed" is liable to be different from what's there in the underlying data, when just looking at the default output. Casting the output to text and using the formatting string merely forces the displayed value to look like what you're expecting (but of course this is still a representation of the underlying data).

mikes0011 · Answer

Appian's default way of displaying decimal numbers takes some sometimes unintuitive liberties with the number of significant figures shown - in ways that are a little unintuitive and opaque to not only the end user but also the designer (frustratingly). I'm not exactly sure I'm comprehending the manual conversions you're with your utuility rule, but I was under the impression that a!currency() was supposed to handle things like "dots instead of commas and commas instead of dots" automatically for currencies that use opposing systems (though i haven't tested this). BTW, are users not using locales that support the proper number entry system inherently? I thought it worked without manual conversion when the locale was set right (also haven't personally tested though).

My general advice at this point would be to go back to basics and make sure you're doing any manual conversion on a displayed number (versus the underlying decimal value) only at the very end, to avoid it becoming confused.

Sign up

Login with SSO

Login to the community

Login with SSO