How to use

getContext

method

in

javax.money.convert.ExchangeRate

@Override
public int compareTo(ExchangeRate o) {
  Objects.requireNonNull(o);
  int compare = this.getBaseCurrency().getCurrencyCode().compareTo(o.getBaseCurrency().getCurrencyCode());
  if (compare == 0) {
    compare = this.getCurrency().getCurrencyCode().compareTo(o.getCurrency().getCurrencyCode());
  }
  if (compare == 0) {
    compare = this.getContext().getProviderName().compareTo(o.getContext().getProviderName());
  }
  return compare;
}

@Override
public int compareTo(ExchangeRate o) {
  if (o == null) {
    return -1;
  }
  int compare = this.getBaseCurrency().getCurrencyCode().compareTo(o.getBaseCurrency().getCurrencyCode());
  if (compare == 0) {
    compare = this.getCurrency().getCurrencyCode().compareTo(o.getCurrency().getCurrencyCode());
  }
  if (compare == 0) {
    compare = this.getContext().getProviderName().compareTo(o.getContext().getProviderName());
  }
  return compare;
}

/**
 * Initialize the {@link ExchangeRateBuilder} with an {@link javax.money.convert.ExchangeRate}. This is
 * useful for creating a new rate, reusing some properties from an
 * existing one.
 *
 * @param rate the base rate
 * @return the Builder, for chaining.
 */
public ExchangeRateBuilder setRate(ExchangeRate rate) {
  this.base = rate.getBaseCurrency();
  this.term = rate.getCurrency();
  this.conversionContext = rate.getContext();
  this.factor = rate.getFactor();
  this.rateChain = rate.getExchangeRateChain();
  this.term = rate.getCurrency();
  return this;
}

  /**
   * Initialize the {@link Builder} with an {@link javax.money.convert.ExchangeRate}. This is
   * useful for creating a new rate, reusing some properties from an
   * existing one.
   *
   * @param rate the base rate
   * @return the Builder, for chaining.
   */
  public Builder setRate(ExchangeRate rate) {
    this.base = rate.getBaseCurrency();
    this.term = rate.getCurrency();
    this.conversionContext = rate.getContext();
    this.factor = rate.getFactor();
    this.rateChain = rate.getExchangeRateChain();
    this.term = rate.getCurrency();
    return this;
  }
}

@Override
public ExchangeRate getReversed(ExchangeRate rate) {
  ConversionQuery reverseQuery = rate.getContext().toQueryBuilder().setBaseCurrency(rate.getCurrency())
      .setTermCurrency(rate.getBaseCurrency()).build();
  if(isAvailable(reverseQuery)){
    return getExchangeRate(reverseQuery);
  }
  return null;
}

@Override
public ExchangeRate getReversed(ExchangeRate rate) {
  ConversionQuery reverseQuery = rate.getContext().toQueryBuilder().setBaseCurrency(rate.getCurrency())
      .setTermCurrency(rate.getBaseCurrency()).build();
  if(isAvailable(reverseQuery)){
    return getExchangeRate(reverseQuery);
  }
  return null;
}

@Override
public ExchangeRate getReversed(ExchangeRate rate) {
  ConversionQuery reverseQuery = rate.getContext().toQueryBuilder().setBaseCurrency(rate.getCurrency())
      .setTermCurrency(rate.getBaseCurrency()).build();
  if(isAvailable(reverseQuery)){
    return getExchangeRate(reverseQuery);
  }
  return null;
}

@Override
public ExchangeRate getReversed(ExchangeRate rate) {
  ConversionQuery reverseQuery = rate.getContext().toQueryBuilder().setBaseCurrency(rate.getCurrency())
      .setTermCurrency(rate.getBaseCurrency()).build();
  if(isAvailable(reverseQuery)){
    return getExchangeRate(reverseQuery);
  }
  return null;
}

/**
 * Ensure additional ConversionContext is passed correctly to SPIs.<p>
 * Hint: this assertion will require some custom SPIs to be registered and selected for chain inclusion!
 */
@Test(description = "4.3.3 Ensure additional ConversionQuery data is passed correctly to SPIs.")
@SpecAssertion(id = "433-A2", section = "4.3.3")
public void testPassingOverConversionContextToSPIs() {
  ExchangeRateProvider prov = MonetaryConversions.getExchangeRateProvider("TestRateProvider");
  ConversionQuery ctx = ConversionQueryBuilder.of().set(Locale.CANADA).set("Foo", "bar").setBaseCurrency(FOO_UNIT)
      .setTermCurrency(Monetary.getCurrency("XXX")).build();
  ExchangeRate rate = prov.getExchangeRate(ctx);
  AssertJUnit.assertNotNull("No test rate returned by getExchangeRate(ConversionQuery), " +
      "probably TestProvider is not correct registered.");
  AssertJUnit.assertEquals(
      "Text parameter Locale.class was not correctly passed to ExchangeRateProvider implementation.", "bar",
      rate.getContext().getText("Foo"));
  AssertJUnit.assertEquals(
      "Object parameter Locale.class was not correctly passed to ExchangeRateProvider implementation.",
      Locale.CANADA, rate.getContext().get(Locale.class));
}

/**
 * Sets the exchange rate type
 *
 * @param rate the {@link javax.money.convert.ExchangeRate} to be applied
 */
public ExchangeRateBuilder(ExchangeRate rate) {
  setContext(rate.getContext());
  setFactor(rate.getFactor());
  setTerm(rate.getCurrency());
  setBase(rate.getBaseCurrency());
  setRateChain(rate.getExchangeRateChain());
}

/**
 * Sets the exchange rate type
 *
 * @param rate the {@link javax.money.convert.ExchangeRate} to be applied
 */
public Builder(ExchangeRate rate) {
  setContext(rate.getContext());
  setFactor(rate.getFactor());
  setTerm(rate.getCurrency());
  setBase(rate.getBaseCurrency());
  setRateChain(rate.getExchangeRateChain());
}

/**
 * The method reverses the {@link ExchangeRate} to a rate mapping from term
 * to base {@link CurrencyUnit}. Hereby the factor must <b>not</b> be
 * recalculated as {@code 1/oldFactor}, since typically reverse rates are
 * not symmetric in most cases.
 *
 * @return the matching reversed {@link ExchangeRate}, or {@code null}, if
 * the rate cannot be reversed.
 */
default ExchangeRate getReversed(ExchangeRate rate){
  ConversionQuery reverseQuery = rate.getContext().toQueryBuilder().setBaseCurrency(rate.getCurrency())
      .setTermCurrency(rate.getBaseCurrency()).build();
  if(isAvailable(reverseQuery)){
    return getExchangeRate(reverseQuery);
  }
  return null;
}

/**
 * Method that converts the source {@link MonetaryAmount} to an
 * {@link MonetaryAmount} based on the {@link ExchangeRate} of this
 * conversion.
 * @param amount The source amount
 * @return The converted amount, never null.
 * @throws CurrencyConversionException if conversion failed, or the required data is not available.
 * @see #getExchangeRate(MonetaryAmount)
 */
@Override
public MonetaryAmount apply(MonetaryAmount amount) {
  if (termCurrency.equals(Objects.requireNonNull(amount).getCurrency())) {
    return amount;
  }
  ExchangeRate rate = getExchangeRate(amount);
  if (Objects.isNull(rate) || !amount.getCurrency().equals(rate.getBaseCurrency())) {
    throw new CurrencyConversionException(amount.getCurrency(),
        this.termCurrency, null);
  }
  NumberValue factor = rate.getFactor();
  factor = roundFactor(amount, factor);
  Integer scale = rate.getContext().get(KEY_SCALE, Integer.class);
  if(Objects.isNull(scale) || scale < 0) {
    return amount.multiply(factor).getFactory().setCurrency(rate.getCurrency()).create();
  } else {
    return amount.multiply(factor).getFactory().setCurrency(rate.getCurrency()).create().with(MonetaryOperators.rounding(scale));
  }
}

/**
 * Compare conversions done with exchange rates provided for same currency pair.
 */
@Test(description = "4.3.2 Test correct ExchangeRate is returned for CHF -> FOO, using TestRateProvider.")
@SpecAssertion(id = "432-A2", section = "4.3.2")
public void testConversionComparedWithRate() {
  final CurrencyUnit FOO = new TestCurrencyUnit("FOO");
  ExchangeRate rate = MonetaryConversions.getExchangeRateProvider("TestRateProvider")
      .getExchangeRate(Monetary.getCurrency("CHF"), FOO);
  AssertJUnit.assertEquals(rate.getBaseCurrency(), Monetary.getCurrency("CHF"));
  AssertJUnit.assertEquals(rate.getCurrency().getCurrencyCode(), FOO.getCurrencyCode());
  AssertJUnit.assertEquals(rate.getFactor().intValueExact(), 2);
  AssertJUnit.assertEquals("TestRateProvider", rate.getContext().getProviderName());
}

private ExchangeRate createExchangeRate(ConversionQuery query,
                    ExchangeRateBuilder builder, ExchangeRate sourceRate,
                    ExchangeRate target) {
  if (areBothBaseCurrencies(query)) {
    builder.setFactor(DefaultNumberValue.ONE);
    return builder.build();
  } else if (BASE_CURRENCY_CODE.equals(query.getCurrency().getCurrencyCode())) {
    if (Objects.isNull(sourceRate)) {
      return null;
    }
    return reverse(sourceRate);
  } else if (BASE_CURRENCY_CODE.equals(query.getBaseCurrency()
      .getCurrencyCode())) {
    return target;
  } else {
    ExchangeRate rate1 = getExchangeRate(
        query.toBuilder().setTermCurrency(Monetary.getCurrency(BASE_CURRENCY_CODE)).build());
    ExchangeRate rate2 = getExchangeRate(
        query.toBuilder().setBaseCurrency(Monetary.getCurrency(BASE_CURRENCY_CODE))
            .setTermCurrency(query.getCurrency()).build());
    if (Objects.nonNull(rate1) && Objects.nonNull(rate2)) {
      builder.setFactor(multiply(rate1.getFactor(), rate2.getFactor()));
      builder.setRateChain(rate1, rate2);
      return builder.build();
    }
    throw new CurrencyConversionException(query.getBaseCurrency(),
        query.getCurrency(), sourceRate.getContext());
  }
}