001/* 002 * Copyright (c) 2012, 2013, Werner Keil, Credit Suisse (Anatole Tresch). Licensed under the Apache 003 * License, Version 2.0 (the "License"); you may not use this file except in compliance with the 004 * License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 005 * Unless required by applicable law or agreed to in writing, software distributed under the License 006 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express 007 * or implied. See the License for the specific language governing permissions and limitations under 008 * the License. Contributors: Anatole Tresch - initial version. 009 */ 010package org.javamoney.tck.tests.internal; 011 012import org.javamoney.tck.tests.conversion.TestExchangeRate; 013 014import javax.money.CurrencyUnit; 015import javax.money.MonetaryAmount; 016import javax.money.Monetary; 017import javax.money.convert.ConversionContext; 018import javax.money.convert.ConversionContextBuilder; 019import javax.money.convert.ConversionQuery; 020import javax.money.convert.ConversionQueryBuilder; 021import javax.money.convert.CurrencyConversion; 022import javax.money.convert.ExchangeRate; 023import javax.money.convert.ExchangeRateProvider; 024import javax.money.convert.ProviderContext; 025import javax.money.convert.ProviderContextBuilder; 026import javax.money.convert.RateType; 027import java.util.Objects; 028 029/** 030 * Test ExchangeProvider. Created by Anatole on 26.04.2014. 031 */ 032public class TestRateProvider02 implements ExchangeRateProvider { 033 034 public static final double FACTOR = 0.2; 035 private static final ProviderContext PC = ProviderContextBuilder.of("TestRateProvider02", RateType.OTHER).build(); 036 private static final ConversionContext CC = ConversionContextBuilder.create(PC, RateType.OTHER).build(); 037 038 private static final class Conversion implements CurrencyConversion { 039 040 private CurrencyUnit term; 041 042 private Conversion(CurrencyUnit term) { 043 Objects.requireNonNull(term); 044 this.term = term; 045 } 046 047 @Override 048 public CurrencyUnit getCurrency() { 049 return term; 050 } 051 052 @Override 053 public ConversionContext getContext() { 054 return CC; 055 } 056 057 @Override 058 public ExchangeRate getExchangeRate(MonetaryAmount sourceAmount) { 059 return new TestExchangeRate.Builder(CC).setFactor(new TestNumberValue(FACTOR)) 060 .setBase(sourceAmount.getCurrency()).setTerm(term).build(); 061 } 062 063 @Override 064 public MonetaryAmount apply(MonetaryAmount value) { 065 return value.multiply(FACTOR).getFactory().setCurrency(term).create(); 066 } 067 068 @Override 069 public ExchangeRateProvider getExchangeRateProvider() { 070 return null; 071 } 072 } 073 074 @Override 075 public ProviderContext getContext() { 076 return PC; 077 } 078 079 @Override 080 public boolean isAvailable(ConversionQuery conversionQuery) { 081 Objects.requireNonNull(conversionQuery); 082 Objects.requireNonNull(conversionQuery.getCurrency()); 083 return true; 084 } 085 086 @Override 087 public ExchangeRate getExchangeRate(ConversionQuery conversionQuery) { 088 Objects.requireNonNull(conversionQuery.getBaseCurrency()); 089 if (isAvailable(conversionQuery)) { 090 return new TestExchangeRate.Builder(getContext().getProviderName(), RateType.OTHER) 091 .setFactor(new TestNumberValue(FACTOR)).setBase(conversionQuery.getBaseCurrency()) 092 .setTerm(conversionQuery.getCurrency()).build(); 093 } 094 return null; 095 } 096 097 098 @Override 099 public CurrencyConversion getCurrencyConversion(CurrencyUnit term) { 100 return new Conversion(term); 101 } 102 103 @Override 104 public boolean isAvailable(CurrencyUnit base, CurrencyUnit term) { 105 return isAvailable(ConversionQueryBuilder.of().setBaseCurrency(base).setTermCurrency(term).build()); 106 } 107 108 @Override 109 public boolean isAvailable(String baseCode, String termCode) { 110 return isAvailable(ConversionQueryBuilder.of().setBaseCurrency(Monetary.getCurrency(baseCode)) 111 .setTermCurrency(Monetary.getCurrency(termCode)).build()); 112 } 113 114 @Override 115 public ExchangeRate getReversed(ExchangeRate rate) { 116 ConversionQuery reverseQuery = rate.getContext().toQueryBuilder().setBaseCurrency(rate.getCurrency()) 117 .setTermCurrency(rate.getBaseCurrency()).build(); 118 if(isAvailable(reverseQuery)){ 119 return getExchangeRate(reverseQuery); 120 } 121 return null; 122 } 123 124 @Override 125 public CurrencyConversion getCurrencyConversion(String termCode) { 126 return new Conversion(Monetary.getCurrency(termCode)); 127 } 128 129 @Override 130 public CurrencyConversion getCurrencyConversion(ConversionQuery conversionQuery) { 131 Objects.requireNonNull(conversionQuery); 132 Objects.requireNonNull(conversionQuery.getCurrency()); 133 return new Conversion(conversionQuery.getCurrency()); 134 } 135 136 @Override 137 public ExchangeRate getExchangeRate(CurrencyUnit base, CurrencyUnit term) { 138 return getExchangeRate(ConversionQueryBuilder.of().setBaseCurrency(base).setTermCurrency(term).build()); 139 } 140 141 @Override 142 public ExchangeRate getExchangeRate(String baseCode, String termCode) { 143 return getExchangeRate(ConversionQueryBuilder.of().setBaseCurrency(Monetary.getCurrency(baseCode)) 144 .setTermCurrency(Monetary.getCurrency(termCode)).build()); 145 } 146 147 148}