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 * CTest ExchangeProvider. reated by Anatole on 26.04.2014. 031 */ 032public class TestRateProvider1 implements ExchangeRateProvider { 033 034 public static final int FACTOR = 1; 035 private static final ProviderContext PC = ProviderContextBuilder.of("TestRateProvider1", 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.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.getBaseCurrency()); 083 Objects.requireNonNull(conversionQuery.getCurrency()); 084 return "CHF".equals(conversionQuery.getBaseCurrency().getCurrencyCode()); 085 } 086 087 @Override 088 public ExchangeRate getExchangeRate(ConversionQuery conversionQuery) { 089 Objects.requireNonNull(conversionQuery); 090 Objects.requireNonNull(conversionQuery.getBaseCurrency()); 091 Objects.requireNonNull(conversionQuery.getCurrency()); 092 if (isAvailable(conversionQuery)) { 093 return new TestExchangeRate.Builder(getClass().getSimpleName(), RateType.OTHER) 094 .setFactor(new TestNumberValue(FACTOR)).setBase(conversionQuery.getBaseCurrency()) 095 .setTerm(conversionQuery.getCurrency()).build(); 096 } 097 return null; 098 } 099 100 @Override 101 public CurrencyConversion getCurrencyConversion(ConversionQuery query) { 102 Objects.requireNonNull(query); 103 Objects.requireNonNull(query.getCurrency()); 104 return new Conversion(query.getCurrency()); 105 } 106 107 @Override 108 public ExchangeRate getExchangeRate(CurrencyUnit base, CurrencyUnit term) { 109 return getExchangeRate(ConversionQueryBuilder.of().setBaseCurrency(base).setTermCurrency(term).build()); 110 } 111 112 @Override 113 public CurrencyConversion getCurrencyConversion(CurrencyUnit term) { 114 return new Conversion(term); 115 } 116 117 @Override 118 public boolean isAvailable(CurrencyUnit base, CurrencyUnit term) { 119 return isAvailable(ConversionQueryBuilder.of().setBaseCurrency(base).setTermCurrency(term).build()); 120 } 121 122 @Override 123 public boolean isAvailable(String baseCode, String termCode) { 124 return isAvailable(ConversionQueryBuilder.of().setBaseCurrency(Monetary.getCurrency(baseCode)) 125 .setTermCurrency(Monetary.getCurrency(termCode)).build()); 126 } 127 128 @Override 129 public ExchangeRate getExchangeRate(String baseCode, String termCode) { 130 return getExchangeRate(ConversionQueryBuilder.of().setBaseCurrency(Monetary.getCurrency(baseCode)) 131 .setTermCurrency(Monetary.getCurrency(termCode)).build()); 132 } 133 134 @Override 135 public ExchangeRate getReversed(ExchangeRate rate) { 136 ConversionQuery reverseQuery = rate.getContext().toQueryBuilder().setBaseCurrency(rate.getCurrency()) 137 .setTermCurrency(rate.getBaseCurrency()).build(); 138 if(isAvailable(reverseQuery)){ 139 return getExchangeRate(reverseQuery); 140 } 141 return null; 142 } 143 144 @Override 145 public CurrencyConversion getCurrencyConversion(String termCode) { 146 return new Conversion(Monetary.getCurrency(termCode)); 147 } 148 149 150}