utils/currency.js 

  2. /*
  3.  * Your installation or use of this SugarCRM file is subject to the applicable
  4.  * terms available at
  5.  * http://support.sugarcrm.com/Resources/Master_Subscription_Agreements/.
  6.  * If you do not agree to all of the applicable terms or do not have the
  7.  * authority to bind the entity as an authorized representative, then do not
  8.  * install or use this SugarCRM file.
  9.  *
  10.  * Copyright (C) SugarCRM Inc. All rights reserved.
  11.  */
  13. const math = require('./math');
  14. const User = require('../core/user');
  15. const Utils = require('./utils');
  17. /**
  18.  * Currency module provides utility methods for working with currencies.
  19.  *
  20.  * @module Utils/Currency
  21.  */
  22.  module.exports = {
  23.     /**
  24.      * Gets the base currency id.
  25.      *
  26.      * @return {string} The base currency id.
  27.      */
  28.     getBaseCurrencyId: function() {
  29.         return SUGAR.App.metadata.getBaseCurrencyId();
  30.     },
  32.     /**
  33.      * Gets the system's base currency.
  34.      *
  35.      * @return {Object} The base currency data.
  36.      */
  37.     getBaseCurrency: function() {
  38.         var currId = SUGAR.App.metadata.getBaseCurrencyId(),
  39.             currencyObj = SUGAR.App.metadata.getCurrency(currId);
  41.         // add currency_id to returned data
  42.         currencyObj.currency_id = currId;
  44.         return currencyObj;
  45.     },
  47.     /**
  48.      * Returns a map of currency IDs to the result of applying the
  49.      * given Handlebars template to them.
  50.      *
  51.      * Example for the `template` param:
  52.      * ```
  53.      *   getCurrenciesSelector(Handlebars.compile('{{symbol}} ({{iso}})'));
  54.      * ```
  55.      *
  56.      * @param {Function} template How to format the values returned.
  57.      * @return {Object} Map from currency IDs to formatted currency data.
  58.      */
  59.     getCurrenciesSelector: function(template) {
  60.         var currencies = {};
  62.         _.each(SUGAR.App.metadata.getCurrencies(), function(currency, id) {
  63.             currencies[id] = template(currency);
  64.         });
  65.         return currencies;
  66.     },
  68.     /**
  69.      * Gets the symbol for the given currency ID.
  70.      *
  71.      * @param {string}  currencyId Currency identifier.
  72.      * @return {string} The currency display symbol (e.g. "$").
  73.      */
  74.     getCurrencySymbol: function (currencyId) {
  75.         var currency = SUGAR.App.metadata.getCurrency(currencyId);
  76.         return currency ? currency.symbol : '';
  77.     },
  79.     /**
  80.      * Formats a currency amount.
  81.      *
  82.      * @param {number} amount The amount to be formatted.
  83.      * @param {string} [currencyId] The currency id to be used. If not
  84.      *     specified, the system default will be used.
  85.      * @param {number} [decimalPrecision=2] The number of digits for
  86.      *     decimal precision.
  87.      * @param {string} [numberGroupingSeparator=','] The thousands separator.
  88.      * @param {string} [decimalSeparator='.'] The decimal separator (string
  89.      *     between number and decimal digits).
  90.      * @param {string} [symbolSeparator=''] The string between the symbol and
  91.      *     the amount.
  92.      * @return {string} The formatted currency amount.
  93.      */
  94.     formatAmount: function(
  95.         amount,
  96.         currencyId,
  97.         decimalPrecision,
  98.         numberGroupingSeparator,
  99.         decimalSeparator,
  100.         symbolSeparator
  101.     ) {
  102.         // we don't want to format non-numbers
  103.         if (!_.isFinite(amount)) {
  104.             return amount;
  105.         }
  106.         var currencySymbol;
  107.         var config = SUGAR.App.metadata.getConfig();
  108.         // default to base currency
  109.         currencyId = currencyId || this.getBaseCurrencyId();
  110.         symbolSeparator = symbolSeparator || '';
  111.         // use reasonable defaults if none exist
  112.         if (!_.isFinite(decimalPrecision)) {
  113.             if (_.isFinite(config.defaultCurrencySignificantDigits)) {
  114.                 decimalPrecision = config.defaultCurrencySignificantDigits;
  115.             }
  116.             else {
  117.                 decimalPrecision = 2;
  118.             }
  119.         }
  121.         decimalSeparator = decimalSeparator || config.defaultDecimalSeparator || '.';
  122.         // if the numberGroupingSeparator is truly undefined we need to get the defaults, if it's an empty string
  123.         // we need to use the empty string as it's a valid value.
  124.         numberGroupingSeparator = (!_.isUndefined(numberGroupingSeparator)) ?
  125.             numberGroupingSeparator : config.defaultNumberGroupingSeparator || ',';
  127.         currencySymbol = this.getCurrencySymbol(currencyId) || this.getCurrencySymbol(this.getBaseCurrencyId());
  128.         amount = Utils.formatNumber(
  129.             amount,
  130.             decimalPrecision,
  131.             decimalPrecision,
  132.             numberGroupingSeparator,
  133.             decimalSeparator
  134.         );
  135.         return currencySymbol + symbolSeparator + amount;
  136.     },
  138.     /**
  139.      * Formats a currency amount according to the current user's locale.
  140.      *
  141.      * @param {number} amount The amount to format.
  142.      * @param {string} [currencyId] The currency id to use. If not
  143.      *   specified, the system default will be used.
  144.      * @param {string} [decimalPrecision] The number of decimal digits to use.
  145.      *   If not specified, the user preference will be used.
  146.      * @return {string} formatted currency amount.
  147.      */
  148.     formatAmountLocale: function (amount, currencyId, decimalPrecision) {
  149.         // get user preferred formatting
  150.         var decimalSeparator = User.getPreference('decimal_separator');
  151.         var numberGroupingSeparator = User.getPreference('number_grouping_separator');
  152.         var userDecimalPrecision = User.getPreference('decimal_precision');
  153.         decimalPrecision = (_.isFinite(decimalPrecision)) ? decimalPrecision : userDecimalPrecision;
  154.         return this.formatAmount(
  155.             amount,
  156.             currencyId,
  157.             decimalPrecision,
  158.             numberGroupingSeparator,
  159.             decimalSeparator
  160.         );
  161.     },
  163.     /**
  164.      * Unformats a currency amount.
  165.      *
  166.      * @param {string} amount The amount to unformat.
  167.      * @param {string} numberGroupingSeparator Thousands separator.
  168.      * @param {string} decimalSeparator The string between number and decimals.
  169.      * @param {boolean} [toFloat=false] If `true`, convert string to float
  170.      *   value.
  171.      * @return {string} The unformatted currency amount.
  172.      */
  173.     unformatAmount:function (amount, numberGroupingSeparator, decimalSeparator, toFloat) {
  174.         toFloat = toFloat || false;
  175.         // strip off currency symbol, or anything prefixed that is not a digit or separator
  176.         amount = amount.toString().replace(/^[^\d\.\,-]+/, '');
  177.         return Utils.unformatNumberString(
  178.             amount,
  179.             numberGroupingSeparator,
  180.             decimalSeparator,
  181.             toFloat
  182.         );
  183.     },
  185.     /**
  186.      * Unformats the currency amount according to the current user's locale.
  187.      *
  188.      * @param {string} amount Amount to unformat.
  189.      * @param {boolean} toFloat If `true`, convert string to float value.
  190.      * @return {string} The unformatted currency amount.
  191.      */
  192.     unformatAmountLocale:function (amount, toFloat) {
  193.         var decimalSeparator,
  194.             numberGroupingSeparator,
  195.             config = SUGAR.App.metadata.getConfig();
  196.         // use user locale or reasonable defaults
  197.         decimalSeparator = User.getPreference('decimal_separator') || config.defaultDecimalSeparator || '.';
  198.         var userNumGroupingSeparator = User.getPreference('number_grouping_separator');
  199.         numberGroupingSeparator = userNumGroupingSeparator || config.defaultNumberGroupingSeparator || ',';
  200.         return this.unformatAmount(
  201.             amount,
  202.             numberGroupingSeparator,
  203.             decimalSeparator,
  204.             toFloat
  205.         );
  206.     },
  208.     /**
  209.      * Converts from one currency to another.
  210.      *
  211.      * @param {number|string} amount Base currency amount.
  212.      * @param {string} fromId Source currency id.
  213.      * @param {string} toId Target currency id.
  214.      * @return {string} The converted amount.
  215.      */
  216.     convertAmount: function(amount, fromId, toId) {
  217.         var currency1;
  218.         var currency2;
  219.         if (fromId == toId) {
  220.             return math.round(amount, undefined, true);
  221.         }
  222.         currency1 = SUGAR.App.metadata.getCurrency(fromId);
  223.         currency2 = SUGAR.App.metadata.getCurrency(toId);
  224.         return this.convertWithRate(amount, currency1.conversion_rate, currency2.conversion_rate);
  225.     },
  227.     /**
  228.      * Converts a currency to the base currency.
  229.      *
  230.      * @param {number|string} amount The amount in the source currency.
  231.      * @param {string} fromId Source currency id.
  232.      * @return {string} The converted amount.
  233.      */
  234.     convertToBase: function (amount, fromId) {
  235.         return this.convertAmount(amount, fromId, this.getBaseCurrencyId());
  236.     },
  238.     /**
  239.      * Converts from the base currency to another currency.
  240.      *
  241.      * @param {number|string} amount The amount in the base currency.
  242.      * @param {string} toId Target currency id.
  243.      * @return {string} The converted amount.
  244.      */
  245.     convertFromBase:function (amount, toId) {
  246.         return this.convertAmount(amount, this.getBaseCurrencyId(), toId);
  247.     },
  249.     /**
  250.      * Converts a currency with given conversion rates.
  251.      *
  252.      * @param {number|string} amount The amount in the origin currency.
  253.      * @param {number} fromRate The origin conversion rate relative to the base
  254.      *   currency.
  255.      * @param {number} toRate The target conversion rate relative to the base
  256.      *   currency.
  257.      * @return {string} The converted amount.
  258.      */
  259.     convertWithRate: function(amount, fromRate, toRate) {
  260.         fromRate = fromRate || 1.0;
  261.         toRate = toRate || 1.0;
  262.         return math.mul(math.div(amount, fromRate, undefined, true), toRate, undefined, true);
  263.     }
  264. };
  265. JAVASCRIPT
    Copied!