/** * Checks if an {@link ExchangeRate} between two {@link CurrencyUnit} is * available from this provider. This method should check, if a given rate * is <i>currently</i> defined. * * @param base the base {@link CurrencyUnit} * @param term the term {@link CurrencyUnit} * @return {@code true}, if such an {@link ExchangeRate} is currently * defined. */ default boolean isAvailable(CurrencyUnit base, CurrencyUnit term){ return isAvailable(ConversionQueryBuilder.of().setBaseCurrency(base).setTermCurrency(term).build()); }
/** * Set the providers to be considered. If not set explicitly the <i>default</i> ISO currencies as * returned by {@link java.util.Currency} is used. * * @param rateTypes the rate types to use, not null. * @return the query for chaining. */ public ConversionQueryBuilder setRateTypes(Set<RateType> rateTypes) { return set(ConversionQuery.KEY_RATE_TYPES, rateTypes); }
/** * Access an instance of {@link CurrencyConversion}. * * @param termCurrency the terminating/target currency unit, not null. * @param providers the {@link javax.money.convert.ConversionQuery} provider names defines a corresponding * provider chain that must be encapsulated by the resulting {@link javax * .money.convert.CurrencyConversion}. By default the default * provider chain as defined by #getDefaultCurrencyProviderChain will be used. * @return the corresponding conversion, not null. * @throws javax.money.MonetaryException if no matching conversion could be found. * @see #isConversionAvailable(javax.money.convert.ConversionQuery) */ default CurrencyConversion getConversion(CurrencyUnit termCurrency, String... providers) { return getConversion(ConversionQueryBuilder.of().setTermCurrency(termCurrency).setProviderNames(providers).build()); }
/** * Creates a query builder based on this onctex. * * @return a new instance of {@link ConversionQueryBuilder}, never null. */ public ConversionQueryBuilder toQueryBuilder() { return ConversionQueryBuilder.of().importContext(this); }
/** * Access a {@link CurrencyConversion} that can be applied as a * {@link MonetaryOperator} to an amount. * * @param term term {@link CurrencyUnit}, not {@code null} * @return a new instance of a corresponding {@link CurrencyConversion}, * never {@code null}. */ default CurrencyConversion getCurrencyConversion(CurrencyUnit term){ return getCurrencyConversion(ConversionQueryBuilder.of().setTermCurrency(term).build()); }
@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; }
/** * Get the exchange rate type that this provider instance is providing data * for. * * @return the exchange rate type if this instance. */ @Override public ExchangeRate getExchangeRate(MonetaryAmount amount) { return this.rateProvider.getExchangeRate(ConversionQueryBuilder .of(conversionQuery).setBaseCurrency(amount.getCurrency()) .build()); // return this.rateProvider.getExchangeRate(amount.getCurrency(), // getCurrency()); }
/** * Access a compound instance of an {@link ExchangeRateProvider} based on the given provider chain. * * @param providers the {@link javax.money.convert.ConversionQuery} provider names defines a corresponding * provider chain that must be * encapsulated by the resulting {@link javax.money.convert.ExchangeRateProvider}. By default * the default * provider changes as defined in #getDefaultCurrencyProviderChain will be used. * @return an {@link ExchangeRateProvider} built up with the given sub * providers, never {@code null}. * @throws MonetaryException if a provider listed could not be found. * @see #getProviderNames() * @see #isExchangeRateProviderAvailable(javax.money.convert.ConversionQuery) */ default ExchangeRateProvider getExchangeRateProvider(String... providers) { return getExchangeRateProvider(ConversionQueryBuilder.of().setProviderNames(providers).build()); }
/** * Test if all providers returns valid meta data. * * @see javax.money.convert.ProviderContext */ @Test(description = "4.3.1 Test if all CurrencyConversion instances returns valid ConversionContext, accessed by " + "ConversionQuery/CurrencyUnit.") @SpecAssertion(id = "431-A3", section = "4.3.1") public void testProviderMetadata3WithContext() { for (String providerName : MonetaryConversions.getConversionProviderNames()) { ConversionQuery query = ConversionQueryBuilder.of(). setTermCurrency(Monetary.getCurrency("XXX")).setProviderName(providerName).build(); if (MonetaryConversions.isConversionAvailable(query)) { CurrencyConversion conv = MonetaryConversions.getConversion(query); ConversionContext ctx = conv.getContext(); AssertJUnit.assertNotNull( "ExchangeProvider must return a valid ProviderContext, but returned null: " + providerName, ctx); AssertJUnit.assertEquals("ExchangeProvider's ProviderContext returns invalid name: " + providerName, providerName, ctx.getProviderName()); AssertJUnit.assertNotNull( "ExchangeProvider's ProviderContext declares invalid RateTypes to be returned (null): " + providerName, ctx.getRateType()); } } }
/** * Sets the base currency. * * @param currencyCode the currency code, resolvable through {@link javax.money * .MonetaryCurrencies#getCurrency(String, String...)}, not null. * @return the query for chaining. */ public ConversionQueryBuilder setBaseCurrency(String currencyCode) { return setBaseCurrency(Monetary.getCurrency(currencyCode)); }
/** * Creates a new Builder preinitialized with values from this instance. * * @return a new Builder, never null. */ public ConversionQueryBuilder toBuilder() { return ConversionQueryBuilder.of(this); }
/** * Sets the term currency. * * @param currencyCode the currency code, resolvable through {@link javax.money * .MonetaryCurrencies#getCurrency(String, String...)}, not null. * @return the query for chaining. */ public ConversionQueryBuilder setTermCurrency(String currencyCode) { return setTermCurrency(Monetary.getCurrency(currencyCode)); }
@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; }
/** * Access the default provider chain. Compare with entries from javamoney.properties. The chain must not be empty! */ @Test(description = "4.3.1 Access and test the default conversion provider chain, by accessing a default" + "CurrencyConversion for ConversionQuery.") @SpecAssertion(id = "431-A4", section = "4.3.1") public void testDefaultProviderChainIsDefinedDefaultWithContext() { ConversionQuery query = ConversionQueryBuilder.of().setTermCurrency(Monetary.getCurrency("CHF")).build(); CurrencyConversion conv = MonetaryConversions.getConversion(query); AssertJUnit.assertNotNull("No default CurrencyConversion returned.", conv); // we cannot test more here... }
/** * Access an instance of {@link CurrencyConversion} using the given * providers as a provider chain. Use {@link #getConversionProviderNames()}s * to check, which are available. * * @return the exchange rate provider. * @throws IllegalArgumentException if no such {@link ExchangeRateProvider} is available. */ public static ExchangeRateProvider getExchangeRateProvider(String... providers){ if(providers.length == 0){ List<String> defaultProviderChain = getDefaultConversionProviderChain(); return getMonetaryConversionsSpi().getExchangeRateProvider(ConversionQueryBuilder.of().setProviderNames( defaultProviderChain.toArray(new String[defaultProviderChain.size()])).build()); } ExchangeRateProvider provider = getMonetaryConversionsSpi() .getExchangeRateProvider(ConversionQueryBuilder.of().setProviderNames(providers).build()); return Optional.ofNullable(provider) .orElseThrow(() -> new MonetaryException("No such rate provider: " + Arrays.toString(providers))); }
@Override public boolean isAvailable(CurrencyUnit base, CurrencyUnit term) { return isAvailable(ConversionQueryBuilder.of().setBaseCurrency(base).setTermCurrency(term).build()); }
@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; }
/** * Allows to quickly check, if a {@link javax.money.convert.CurrencyConversion} is accessible for the given * {@link javax.money.convert.ConversionQuery}. * * @param termCurrency the terminating/target currency unit, not null. * @param providers the provider names defines a corresponding * provider chain that must be encapsulated by the resulting {@link javax * .money.convert.CurrencyConversion}. By default the provider * chain as defined by #getDefaultCurrencyProviderChain will be used. * @return {@code true}, if such a conversion is supported, meaning an according * {@link CurrencyConversion} can be * accessed. * @see #getConversion(javax.money.convert.ConversionQuery) * @see #getConversion(CurrencyUnit, String...)} */ default boolean isConversionAvailable(CurrencyUnit termCurrency, String... providers) { return isConversionAvailable( ConversionQueryBuilder.of().setTermCurrency(termCurrency).setProviderNames(providers).build()); }
/** * Access the conversion using the default conversion chain. */ @Test(description = "4.3.1 Access and test conversion using the default provider chain.") @SpecAssertion(id = "431-A5", section = "4.3.1") public void testDefaultConversion() { ConversionQuery query = ConversionQueryBuilder.of().setTermCurrency(Monetary.getCurrency("USD")).build(); CurrencyConversion conv = MonetaryConversions.getConversion(query); AssertJUnit.assertNotNull("No default CurrencyConversion returned for USD.", conv); query = ConversionQueryBuilder.of().setTermCurrency(Monetary.getCurrency("EUR")).build(); conv = MonetaryConversions.getConversion(query); AssertJUnit.assertNotNull("No default CurrencyConversion returned for EUR.", conv); }
/** * Sets the base currency. * * @param currency the base currency * @return the query for chaining. */ public ConversionQueryBuilder setBaseCurrency(CurrencyUnit currency) { return set(ConversionQuery.KEY_BASE_CURRENCY, currency); }