Microsoft Dynamics AX In Practice: Creating Exchange Rate Providers in Microsoft Dynamics AX 2012 for Xignite

Microsoft Dynamics AX 2012 has the frame work for integrating currency exchange rates from exchange rate providers. Please reference Creating Exchange Rate Providers for Microsoft Dynamics AX 2012. The referenced document from Microsoft shows how to customize the frame work to work with Oanda Exchange Rates .

There are other providers, some which offer a fee based API and others which offer a free API. Doing research on these providers led me to Xignite. They offer a fee based API, which is fairly competitive with other providers.

This blog entry uses the referenced document from Microsoft as a guide to create a provider class in Dynamics AX specifically for use with Xignite API.

The provider class we will create will be the fee based provider. The fee based provider allows for selection of base currency, and specific currency pairs.

Create the class as ExchangeRateProviderXigniteRates and have it extend the ExchangeRateProvider as shown in the class declaration below.

Note: The ExchangeRateProviderIdAttribute is a unique ID that you will need to supply. You can obtain a unique ID from http://createguid.com

	[ExchangeRateProviderAttribute,
	ExchangeRateProviderIdAttribute('70441D3B-E1BC-430E-9192-2FB435BAB82A')]
	class ExchangeRateProviderXignite extends ExchangeRateProvider
	{

	str serviceUrl;
	str serviceUrlForDateRange;
	str serviceClient;
	int serviceTimeout;

	List rates;
	List dates;

	//Token for account identification when sending requests to Xignite
	//get your own token at Xignite
	#define.Token("get your own token")

	#define.HttpWebRequestMethod("GET")
	#define.HttpWebRequestContentType("application/xml")
	#define.HttpHeaderAuthorization("Authorization")

	#define.NameSpaceAlias("ns1")
	#define.NameSpaceURL("http://www.xignite.com/services/")

	#define.QuoteXPath("//HistoricalRate")
	#define.BidXPath("//ns1:Average")
	#define.DateXPath("//ns1:EndDate")

	#define.ServiceTimeout("serviceTimeout")
	#define.ServiceURL("ServiceUrl")
	#define.XIGNITEDateFormat("MM/dd/yyyy")



	}

view raw gistfile1.cs hosted with ❤ by GitHub

Now create a method called getConfigurationDefaults. This method will provide the default URL used to make requests to the provider.

	public ExchangeRateProviderConfigDefaults getConfigurationDefaults()
	{
	ExchangeRateProviderConfigDefaults configurationDefaults = ExchangeRateProviderConfigDefaults::construct();
	configurationDefaults.addNameValueConfigurationPair(#ServiceTimeout, '5000');

	//Requires Enterprise account
	configurationDefaults.addNameValueConfigurationPair(#ServiceURL, 'http://globalcurrencies.xignite.com/xGlobalCurrencies.xml/GetHistoricalRate?Symbol=%1%2&AsOfDate=%3&FixingTime=01:00&PriceType=Mid&_token=%4');

	return configurationDefaults;
	}

view raw gistfile1.cs hosted with ❤ by GitHub

Next create the getExchangeRates method. This method is responsible for constructing the URL to request the currency information from the provider, and store the results in the currency exchange rate tables of Dynamics AX.

	public ExchangeRateResponse getExchangeRates(ExchangeRateRequest _exchangeRateRequest)
	{
	ExchangeRateResponse response = ExchangeRateResponse::construct();
	ExchangeRateResponseCurrencyPair currencyPairResponse;
	ExchangeRateResponseExchangeRate exchangeRateResponse;
	ExchangeRateRequestCurrencyPair currencyPairRequest;
	ExchangeRateProviderConfig config = ExchangeRateProviderConfig::construct();

	RetailCommonWebAPI webApi;
	RetailWebRequest webRequest;
	RetailWebResponse webResponse;

	str xIgniteRequestString;
	date currentDate;

	CurrencyExchangeRate exchangeRate;

	//System.Net.WebResponse webResponse;
	System.IO.StreamReader streamReader;
	System.IO.Stream stream;
	System.Net.HttpWebRequest httpWebRequest;

	ListEnumerator rateEnumerator, dateEnumerator;

	System.Net.WebHeaderCollection webCollection;
	System.DateTime fromDate, fromUTCDate;
	System.TimeZone localTimeZone;

	int compareResult;
	str XMLOut;
	str dateForRequest;
	rates = new List(Types::Real);
	dates = new List(Types::Date);

	localTimeZone = System.TimeZone::get_CurrentTimeZone();
	// Iterate over the requested currency pairs. This is only required for providers
	// that support specific currency pairs.
	_exchangeRateRequest.initializeCurrencyPairEnumerator();
	while(_exchangeRateRequest.moveNextCurrencyPair())
	{
	serviceTimeout = str2int(config.getPropertyValue(this.getProviderId(), #ServiceTimeout));
	serviceUrl = config.getPropertyValue(this.getProviderId(), #ServiceURL);
	// Process each date separately.
	fromDate = _exchangeRateRequest.parmFromDate();
	compareResult = fromDate.CompareTo(_exchangeRateRequest.parmToDate());
	while (compareResult <= 0)
	{
	currencyPairRequest = _exchangeRateRequest.getCurrentCurrencyPair();
	currencyPairResponse = ExchangeRateResponseCurrencyPair::construct();
	currencyPairResponse.parmFromCurrency(currencyPairRequest.parmFromCurrency());
	currencyPairResponse.parmToCurrency(currencyPairRequest.parmToCurrency());
	// All rates are requested with a display factor of 1 for this provider. If the
	// rates internally are represented using a different exchange rate display
	// factor, the framework will make the necessary adjustments when saving the
	// exchange rates.
	currencyPairResponse.parmExchangeRateDisplayFactor(ExchangeRateDisplayFactor::One);
	// convert to UTC
	fromUTCDate = localTimeZone.ToUniversalTime(fromDate);
	dateForRequest = fromUTCDate.ToString(#XIGNITEDateFormat);
	// Build the request URL.
	xIgniteRequestString = strFmt(serviceUrl,
	currencyPairRequest.parmFromCurrency(),
	currencyPairRequest.parmToCurrency(),
	dateForRequest,
	#Token);
	// Configure the request for XIGNITE.
	webApi = RetailCommonWebAPI::construct();
	webRequest = RetailWebRequest::newUrl(xIgniteRequestString);

	try
	{
	// Invoke the service
	webResponse = webApi.getResponse(webRequest);

	XMLOut = webResponse.parmData();

	// Parse the XML to retrieve the rate and date.
	this.readRate(XMLOut);
	rateEnumerator = rates.getEnumerator();
	rateEnumerator.moveNext();
	dateEnumerator = dates.getEnumerator();
	// Create the Exchange Rate Provider Response.
	dateEnumerator.moveNext();
	exchangeRate = rateEnumerator.current();
	currentDate = dateEnumerator.current();
	if (currentDate != dateNull() && exchangeRate)
	{
	exchangeRateResponse = ExchangeRateResponseExchangeRate::construct();
	exchangeRateResponse.parmValidFrom(currentDate);
	exchangeRateResponse.parmExchangeRate(exchangeRate);
	currencyPairResponse.addExchangeRate(exchangeRateResponse);
	currentDate = dateNull();
	exchangeRate = 0;
	}
	}
	catch (Exception::CLRError)
	{
	// The service call did not complete. Swallow the exception and try the next
	// currency pair. The framework will be able to determine which currency
	// pairs were successfully retrieved and will display the appropriate
	// warnings to the user.
	}
	response.addOrUpdateCurrencyPair(currencyPairResponse);
	rates = new List(Types::Real);
	dates = new List(Types::Date);
	fromDate = fromDate.AddDays(1);
	compareResult = fromDate.CompareTo(_exchangeRateRequest.parmToDate());
	}
	}
	return response;
	}

view raw gistfile1.cs hosted with ❤ by GitHub

Next create the getName method. This method is used by Dynamics AX to populate the list of providers that Dynamics AX has been modified to support.

	public ExchangeRateProviderName getName()
	{
	return "Xignite";
	}

view raw gistfile1.cs hosted with ❤ by GitHub

Once the getName method is created, create the getProviderId method. This method simply returns the unique GUID that was assigned in the class declaration.

	public ExchangeRateProviderId getProviderId()
	{
	return '70441D3B-E1BC-430E-9192-2FB435BAB82A';
	}

view raw gistfile1.cs hosted with ❤ by GitHub

Next create the getSupportedOptions method.

	public ExchangeRateProviderSupportedOptions getSupportedOptions()
	{
	ExchangeRateProviderSupportedOptions supportedOptions = ExchangeRateProviderSupportedOptions::construct();
	supportedOptions.parmDoesSupportSpecificCurrencyPairs(true);
	supportedOptions.parmDoesSupportSpecificDates(false);
	supportedOptions.parmFixedBaseIsoCurrency('');
	return supportedOptions;
	}

view raw gistfile1.cs hosted with ❤ by GitHub

The last method that needs created is the readRate method. It is responsible for parsing the XML response string from the provider, and storing the exchange rate and currency information in the Lists.

	private void readRate(str _xmlString)
	{
	XmlDocument xmlDom = new XmlDocument();
	XmlNode xmlRootNode, xmlBidNode, xmlDateNode;
	XmlNamespaceManager nmgr = new XmlNamespaceManager(new XmlNameTable());
	CurrencyExchangeRate exchangeRate;
	ValidFromDate exchangeDate;
	str value;

	xmlDom.LoadXml(_xmlString);

	nmgr.addNamespace(#NameSpaceAlias,#NameSpaceURL);

	xmlRootNode = xmlDom.documentElement();
	if (xmlRootNode)
	{
	// Find the exchange rate
	xmlBidNode = xmlRootNode.selectSingleNode(#BidXPath,nmgr);
	if (xmlBidNode)
	{
	value = xmlBidNode.InnerText();
	exchangeRate = str2num(value);
	if (exchangeRate)
	{
	rates.addEnd(exchangeRate);
	}
	}
	//Find the date of the exchange rate.
	xmlDateNode = xmlRootNode.selectSingleNode(#DateXPath,nmgr);
	if (xmlDateNode)
	{
	value = xmlDateNode.InnerText();
	// convert the date from UTC to local timezone.
	exchangeDate = str2Date(Value,213);
	if (exchangeRate)
	{
	dates.addEnd(exchangeDate);
	}
	}
	}
	}