public void FTPExchange()
{
//Mock exchange
ExchangeRequest request = new ExchangeRequest()
{
ExchangeID = 9999,
RequestID = Guid.NewGuid().ToString(),
ExchangeName = "FTP Download",
//InputUri = "https://showcase.equivant.com/eps/exchangePointservice.svc/...",
ProcessingMode = ProcessingMode.NonRealTime // required for test
};
//Load workflow to be tested
var wfMgr = new WorkflowManager();
wfMgr.LoadFromPath(_workflowRootDir + @"\DES\FTPExampleWorkflow.xaml");
var ep = new Exchange.ServerLib.ExchangePoint(true, wfMgr);
var response = ep.PerformAsyncDataExchange(request);
Assert.IsNotNull(response);
Console.WriteLine($"RequestID: {response.RequestID}");
Assert.IsNotNull(response.Result);
Console.WriteLine($"Response: { response.Result.SelectSingleNode("ftpdata")?.InnerText}");
}
public async Task <IActionResult> Exchange([FromBody] ExchangeRequest request)
{
_logger.LogInformation(
$"Omregn beløbet {request.Amount} med fra valuta \"{request.FromCurrencyCode}\" til valuta \"{request.ToCurrencyCode}\"");
if (!ModelState.IsValid)
{
return(BadRequest());
}
var result =
await _exchangeService.Exchange(request.Amount, request.FromCurrencyCode, request.ToCurrencyCode);
var responseConfig = new HALModelConfig
{
LinkBase = $"{Request.Scheme}://{Request.Host.ToString()}",
ForceHAL = Request.ContentType == "application/hal+json"
};
var response = new HALResponse(responseConfig);
response.AddEmbeddedResource("result", result);
response.AddLinks(
new Link("self", "/api/Exchange", null, "POST"),
new Link("fromCurrency", $"/api/CurrencyRates/{request.FromCurrencyCode}"),
new Link("toCurrency", $"/api/CurrencyRates/{request.ToCurrencyCode}")
);
return(this.HAL(response));
}
public async Task <JsonResult> ExchangeCurrency([FromBody] ExchangeRequest request)
{
ExchangeManager manager;
ExchangeInfo info;
string strInfo = HttpContext.Session.GetString("currencyInfo");
string url = @"http://data.fixer.io/api/latest?access_key=d0def2e2f997f931537d524b82434b2d&symbols=EUR,USD";
if (!string.IsNullOrEmpty(strInfo))
{
info = JsonConvert.DeserializeObject <ExchangeInfo>(strInfo);
if (DateTime.UtcNow.Date.Subtract(new DateTime(1970, 1, 1, 0, 0, 0).AddSeconds(Convert.ToDouble(info.Timestamp))).TotalMinutes < 10)
{
manager = new ExchangeManager(url, info);
}
else
{
manager = new ExchangeManager(url);
}
}
else
{
manager = new ExchangeManager(url);
}
decimal result = await manager.ExchangeCurrencies(request.value, request.fromCurrency, request.targetCurrency);
if (manager.exchangeInfo != null)
{
HttpContext.Session.SetString("currencyInfo", JsonConvert.SerializeObject(manager.exchangeInfo));
}
return(Json(result));
}
public ResponseEntity <QueryResult> Exchange(ExchangeRequest request)
{
var query = currencyRepository.Exchange(request);
QueryResult queryResult = mapper.Map <QueryResult>(query);
return(ResponseEntity <QueryResult> .Create(queryResult));
}
public async Task<ExchangeResponse> ExchangeMoney(ExchangeRequest exchangeReq)
{
var rate = await _ratesService.
GetExchangeRateAsync(exchangeReq.FromCurrency, exchangeReq.ToCurrency);
var exchanged = CalculateExchangeAmount(exchangeReq, rate);
var exchange = new Exchange()
{
Id = Guid.NewGuid(),
FromCurrency = exchanged.FromCurrency,
ToCurrency = exchanged.ToCurrency,
FromAmount = exchanged.FromAmount,
ToAmount = exchanged.ToAmount,
Date = DateTime.Now
};
Save(exchange);
var resp = new ExchangeResponse()
{
FromCurrency = exchanged.FromCurrency,
ToCurrency = exchanged.ToCurrency,
FromAmount = exchanged.FromAmount,
ToAmount = exchanged.ToAmount,
ToCurrencyRate = exchanged.ToCurrencyRate
};
return resp;
}
public async Task Verify_can_create_exchange1()
{
var services = GetContainerBuilder().BuildServiceProvider();
var result = await services.GetService <IBrokerObjectFactory>()
.Object <Exchange>()
.Create("fake_exchange", "HareDu", x =>
{
x.IsDurable();
x.IsForInternalUse();
x.HasRoutingType(ExchangeRoutingType.Direct);
x.HasArguments(arg =>
{
arg.Add("fake_arg", "8238b");
});
});
Console.WriteLine(result.ToJsonString());
Assert.Multiple(() =>
{
Assert.IsFalse(result.HasFaulted);
Assert.IsNotNull(result.DebugInfo);
ExchangeRequest request = result.DebugInfo.Request.ToObject <ExchangeRequest>();
Assert.IsTrue(request.Durable);
Assert.IsTrue(request.Internal);
Assert.AreEqual(1, request.Arguments.Count);
Assert.IsFalse(request.AutoDelete);
Assert.AreEqual("api/exchanges/HareDu/fake_exchange", result.DebugInfo.URL);
Assert.AreEqual(ExchangeRoutingType.Direct, request.RoutingType);
Assert.AreEqual("8238b", request.Arguments["fake_arg"].ToString());
});
}
public async Task can_refresh_cache(byte cacheRefreshRate)
{
var exchangeRequest = new ExchangeRequest(23.32m, Currency.EUR, Currency.GBP);
await LoadCache(exchangeRequest);
var freshTime = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
var freshExchangeRate = new ExchangeRate(
new Dictionary <Currency, decimal>
{
{ Currency.EUR, 1m },
{ Currency.GBP, 3.14m },
{ Currency.USD, 2.78m }
},
freshTime);
_configuration
.Setup(config => config.CacheRefreshRate)
.Returns(cacheRefreshRate);
_exchangeRatesRetriever
.Setup(retriever =>
retriever.Get(exchangeRequest.SourceCurrency))
.ReturnsAsync(freshExchangeRate);
var eurRates = await _cache.Get(exchangeRequest);
Assert.Equal(3, eurRates.Count);
Assert.Equal(freshExchangeRate.Rates[Currency.EUR], eurRates[Currency.EUR]);
Assert.Equal(freshExchangeRate.Rates[Currency.GBP], eurRates[Currency.GBP]);
Assert.Equal(freshExchangeRate.Rates[Currency.USD], eurRates[Currency.USD]);
}
public async Task <Result> Create(string exchange, string vhost, Action <ExchangeConfigurator> configurator = null, CancellationToken cancellationToken = default)
{
cancellationToken.RequestCanceled();
var impl = new ExchangeConfiguratorImpl();
configurator?.Invoke(impl);
ExchangeRequest request = impl.Request.Value;
Debug.Assert(request != null);
var errors = new List <Error>();
errors.AddRange(impl.Errors.Value);
if (string.IsNullOrWhiteSpace(exchange))
{
errors.Add(new ErrorImpl("The name of the exchange is missing."));
}
if (string.IsNullOrWhiteSpace(vhost))
{
errors.Add(new ErrorImpl("The name of the virtual host is missing."));
}
string url = $"api/exchanges/{vhost.ToSanitizedName()}/{exchange}";
if (errors.Any())
{
return(new FaultedResult(new DebugInfoImpl(url, request.ToJsonString(Deserializer.Options), errors)));
}
return(await PutRequest(url, request, cancellationToken).ConfigureAwait(false));
}
public ExchangeRequest Delete(ExchangeRequest ExchangeRequest)
{
var result = _context.Remove(ExchangeRequest);
_context.SaveChanges();
return(result.Entity);
}
public ExchangeRequest Create(ExchangeRequest ExchangeRequest)
{
var result = _context.Add <ExchangeRequest>(ExchangeRequest);
_context.SaveChanges();
return(result.Entity);
}
public void AddHistory(string firstCurrency, double sum, string secondCurrency, double convertedSum)
{
int id = ExchangeHistory.Count;
string date = DateTime.Today.ToShortDateString();
ExchangeRequest request = new ExchangeRequest(id, firstCurrency, sum, secondCurrency, convertedSum, date);
ExchangeHistory.Add(request);
}
public async Task <IReadOnlyDictionary <Currency, decimal> > Get(ExchangeRequest exchangeRequest)
{
await RefreshCache(exchangeRequest.SourceCurrency);
return(_cache.ContainsKey(exchangeRequest.SourceCurrency)
? _cache[exchangeRequest.SourceCurrency].Rates
: new Dictionary <Currency, decimal>());
}
public void AddHistory(string firstCurrency, double sum, string secondCurrency, double convertedSum)
{
string date = DateTime.Today.ToShortDateString();
ExchangeRequest exchangeRequest = new ExchangeRequest(0, firstCurrency, sum, secondCurrency, convertedSum, date);
Context.Add <ExchangeRequest>(exchangeRequest);
Context.SaveChanges();
}
/// <summary>
/// 创建实例
/// </summary>
public static ExchangeRequest create(int id, int num)
{
ExchangeRequest re = (ExchangeRequest)BytesControl.createRequest(dataID);
re.id = id;
re.num = num;
return(re);
}
/// <summary>
/// Перебор всех возможных вариантов обмена с получение лучших вариантов
/// </summary>
/// <param name="exchangeRequest">Запрос на обмен валюты</param>
/// <returns>Отсортированный список всех возможных вариантов обменов</returns>
internal List <Exchange> FindBestExchanges(ExchangeRequest exchangeRequest)
{
var exchangeDbContext = dataBaseService.GetExchangeRates();
var task = new FindAllExchangesTask(exchangeRequest, exchangeDbContext);
task.Exucute();
var allExchange = task.Result;
return(allExchange);
}
public async Task incomplete_cache_returns_empty_for_the_missing_currency()
{
var loadingExchangeRequest = new ExchangeRequest(23.32m, Currency.EUR, Currency.GBP);
var notFoundExchangeRequest = new ExchangeRequest(23.32m, Currency.GBP, Currency.USD);
await LoadCache(loadingExchangeRequest);
var cache = await _cache.Get(notFoundExchangeRequest);
Assert.Empty(cache);
}
public async Task <IActionResult> ExchangeMoney([FromQuery] ExchangeRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var resp = await _exchanges.ExchangeMoney(model);
return(Ok(resp));
}
public Exchange GetExchangeRate(ExchangeRequest request)
{
try {
var query = (from exchange in dbContext.Exchange
where exchange.SourceCurrency == request.CurrencyCode
orderby exchange.CreatedDate descending
select exchange).FirstOrDefault();
return(query);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public IHttpActionResult Exchange(string from, string to, double?amount)
{
if (String.IsNullOrWhiteSpace(from) || String.IsNullOrWhiteSpace(to) || !amount.HasValue)
{
return(BadRequest("Invalid parameters."));
}
if (amount < 0)
{
return(BadRequest("Amount must be a positive number."));
}
var exchange = new ExchangeRequest()
{
From = from,
To = to,
Amount = amount.Value
};
var FromCurrency = _currencies
.Where(curr => curr.Code.Equals(exchange.From))
.SingleOrDefault();
if (FromCurrency == null)
{
return(BadRequest($"Unknown currency: {exchange.From}"));
}
var ToCurrency = _currencies
.Where(curr => curr.Code.Equals(exchange.To))
.SingleOrDefault();
if (ToCurrency == null)
{
return(BadRequest($"Unknown currency: {exchange.To}"));
}
var exchangeResponse = new ExchangeResponse()
{
Request = exchange
};
exchangeResponse.Ratio = FromCurrency.Rate / ToCurrency.Rate;
exchangeResponse.Result = exchangeResponse.Ratio * exchange.Amount;
return(Ok(exchangeResponse));
}
private ExchangeResponse CalculateExchangeAmount(ExchangeRequest req, decimal rate)
{
var resAmount = Math.Round(req.FromAmount * rate, 5);
var resp = new ExchangeResponse()
{
FromAmount = req.FromAmount,
FromCurrency = req.FromCurrency,
ToCurrency = req.ToCurrency,
ToCurrencyRate = Math.Round(rate, 5),
ToAmount = resAmount
};
return resp;
}
public ExchangeRequest Post(ExchangeRequestDTO value)
{
ExchangeRequest model = new ExchangeRequest()
{
requesterId = value.requesterId,
responderId = value.responderId,
requesterApartmentId = value.requesterApartmentId,
responderApartmentId = value.responderApartmentId,
checkIn = value.checkIn.ToLocalTime(),
checkOut = value.checkOut.ToLocalTime(),
numberOfPersons = value.numberOfPersons,
status = "Pending"
};
return(IExchangeRequestRepository.Create(model));
}
/// <summary>
/// 兑换
/// </summary>
public void exchange(int id, int num)
{
ExchangeConfig config = ExchangeConfig.get(id);
if (config == null)
{
me.warnLog("兑换时,找不到兑换配置");
return;
}
ExchangeGroupConfig gConfig = ExchangeGroupConfig.get(config.groupID);
if (!gConfig.canClientUse)
{
me.warnLog("兑换时,该兑换不可客户端发起");
return;
}
if (!me.role.checkRoleConditions(gConfig.conditions, true))
{
me.warnLog("兑换时,条件不满足");
return;
}
if (!checkExchangeConditionEx(id, num))
{
me.warnLog("兑换时,附加条件不满足");
return;
}
if (!hasCost(config.costID, num))
{
me.warnLog("兑换时,材料不足");
return;
}
// if(CommonSetting.isClientDriveLogic)
// {
// doCost(config.costID,num,CallWayType.Exchange);
// addReward(config.rewarID,num,CallWayType.Exchange);
// }
// else
// {
me.send(ExchangeRequest.create(id, num));
// }
}
public async Task can_exchange_eur(decimal exchange, Currency exchangeIn, decimal exchangeRate)
{
var exchangeRequest = new ExchangeRequest(
23.32m,
Currency.EUR,
exchangeIn);
_ratesCache
.Setup(cache => cache.Get(exchangeRequest))
.ReturnsAsync(_exchangeRates[Currency.EUR]);
var result = await _calculator.Exchange(exchangeRequest);
Assert.Equal(exchange, result.Exchange);
Assert.Equal(exchangeIn.ToString(), result.ExchangeIn);
Assert.Equal(exchangeRate, result.ExchangeRate);
}
public async Task returns_empty_when_currency_not_found_while_refreshing()
{
var exchangeRequest = new ExchangeRequest(23.32m, Currency.EUR, Currency.GBP);
await LoadCache(exchangeRequest);
_configuration
.Setup(config => config.CacheRefreshRate)
.Returns(1);
_exchangeRatesRetriever
.Setup(retriever =>
retriever.Get(exchangeRequest.SourceCurrency))
.ReturnsAsync(new EmptyExchangeRate());
var exchangeResult = await _cache.Get(exchangeRequest);
Assert.Empty(exchangeResult);
}
public async Task should_throw_when_retriever_fails_to_refresh()
{
var exchangeRequest = new ExchangeRequest(23.32m, Currency.EUR, Currency.GBP);
await LoadCache(exchangeRequest);
_configuration
.Setup(config => config.CacheRefreshRate)
.Returns(1);
_exchangeRatesRetriever
.Setup(retriever =>
retriever.Get(exchangeRequest.SourceCurrency))
.ThrowsAsync(new OutOfMemoryException());
// I'm not really interested in what is the exception,
// just want to be sure it gets bubbled up
await Assert.ThrowsAsync <OutOfMemoryException>(() => _cache.Get(exchangeRequest));
}
public async Task <IActionResult> ExchangesAsync([Bind("CurrencyFrom,CountFrom,CurrencyTo")] ExchangeRequest exchangeRequest)
{
if (exchangeRequest.CurrencyFrom == exchangeRequest.CurrencyTo)
{
return(View("Index"));
}
try
{
ViewBag.DataRelevance = await exchangeService.CheckDataRelevanceAsync();
var bestExchanges = exchangeService.FindBestExchanges(exchangeRequest);
return(View(bestExchanges));
}
catch (Exception ex)
{
return(RedirectToAction(nameof(ErrorPage), ex.Message));
}
}
private async Task LoadCache(ExchangeRequest exchangeRequest, long cacheUpdateAt = 0)
{
var cacheToLoad =
cacheUpdateAt == 0
? new Dictionary <Currency, IAmExchangeRate>
{
{ Currency.EUR, _eurExchangeRate }
}
: new Dictionary <Currency, IAmExchangeRate>
{
{ Currency.EUR, new ExchangeRate(_eurExchangeRate.Rates, cacheUpdateAt) }
};
_exchangeRatesRetriever
.Setup(retriever =>
retriever.GetAll())
.ReturnsAsync(cacheToLoad);
await _cache.Get(exchangeRequest);
}
public async Task can_load_cache()
{
var exchangeRequest = new ExchangeRequest(23.32m, Currency.EUR, Currency.GBP);
var cacheToLoad = new Dictionary <Currency, IAmExchangeRate>
{
{ Currency.EUR, _eurExchangeRate }
};
_exchangeRatesRetriever
.Setup(retriever =>
retriever.GetAll())
.ReturnsAsync(cacheToLoad);
var eurRates = await _cache.Get(exchangeRequest);
Assert.Equal(3, eurRates.Count);
Assert.Equal(cacheToLoad[Currency.EUR].Rates[Currency.EUR], eurRates[Currency.EUR]);
Assert.Equal(cacheToLoad[Currency.EUR].Rates[Currency.GBP], eurRates[Currency.GBP]);
Assert.Equal(cacheToLoad[Currency.EUR].Rates[Currency.USD], eurRates[Currency.USD]);
}
public HttpResponseMessage Post(ExchangeRequest request)
{
if (ModelState.IsValid)
{
if (request == null)
{
request = new ExchangeRequest();
request.CurrencyCode = "USD";
request.Amount = 1.0;
}
Exchange objExchange = this.objExchangeRepository.GetExchangeRate(request);
ExchangeResponse objExchangeResponse = new ExchangeResponse();
try
{
if (objExchange != null)
{
objExchangeResponse.SourceCurrency = objExchange.SourceCurrency;
objExchangeResponse.ConversionRate = Math.Round(objExchange.ConversionRate, 2);
objExchangeResponse.Amount = request.Amount;
objExchangeResponse.Total = Math.Round(objExchange.ConversionRate, 2) * request.Amount;
objExchangeResponse.TimeStamp = objExchange.TimeStamp;
objExchangeResponse.ReturnCode = "1";
objExchangeResponse.Error = "Success";
return(Request.CreateResponse(System.Net.HttpStatusCode.OK, objExchangeResponse));;
}
else
{
return(Request.CreateResponse(HttpStatusCode.NotFound, "Requested currency code does not found"));
}
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK, ex.Message));
}
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public async Task <IAmExchangeResponse> Exchange(ExchangeRequest exchangeRequest)
{
var rates = await _ratesCache.Get(exchangeRequest);
if (rates.Count == 0)
{
return(new EmptyExchangeResponse());
}
var valueToExchange = exchangeRequest.Price;
var targetRate = rates[exchangeRequest.TargetCurrency];
var referenceRate = rates[exchangeRequest.SourceCurrency];
// As an MVP do not expect to operate over large values
// As such, not performing the calculation under a checked context
// please review the comment in https://github.com/gacastro/rates-r-us#future-improvements
var exchange = valueToExchange * targetRate / referenceRate;
var roundedExchange = Math.Round(exchange, 2);
return(new ExchangeResponse(roundedExchange, exchangeRequest.TargetCurrency, targetRate));
}
public ListingProductDetails ExchangeSearchRequest(ExchangeRequest ExchangeSearchRequest)
{
object[] results = this.Invoke("ExchangeSearchRequest", new object[] {
ExchangeSearchRequest});
return ((ListingProductDetails)(results[0]));
}
public System.IAsyncResult BeginExchangeSearchRequest(ExchangeRequest ExchangeSearchRequest, System.AsyncCallback callback, object asyncState)
{
return this.BeginInvoke("ExchangeSearchRequest", new object[] {
ExchangeSearchRequest}, callback, asyncState);
}
