public async Task <IHttpActionResult> Create(ExchangeRateDto exchangeRate)
{
_exchangeRateRepository.Add(exchangeRate.Map <ExchangeRate>());
await UnitOfWork.CompleteAsync();
return(Created(new Uri(Request.RequestUri + "/" + exchangeRate.Id), exchangeRate));
}
private decimal ValueOfOneUnitOfCurrencyToDDK(string currencyExchangeFrom)
{
decimal oneUnitValue = 0;
ExchangeRateDto currencyCurrencyValues = _exchangeRatesRepository.GetExchangeRateByISO(currencyExchangeFrom);
oneUnitValue = decimal.Divide(currencyCurrencyValues.RateOfCurrency, 100);
return(oneUnitValue);
}
private ExchangeRateDto CreateExchangeRate(string currencyName, string iSO, decimal amountOfDDK, decimal rateOfCurrency)
{
var exchangeRate = new ExchangeRateDto();
exchangeRate.CurrencyName = currencyName;
exchangeRate.ISO = iSO;
exchangeRate.AmountOfDDK = amountOfDDK;
exchangeRate.RateOfCurrency = rateOfCurrency;
return(exchangeRate);
}
public async Task <IHttpActionResult> UpdateAsync(int id, ExchangeRateDto exchangeRate)
{
var exchangeRateInDb = await _exchangeRateRepository.GetAsync(id);
if (exchangeRateInDb == null)
{
return(NotFound());
}
_exchangeRateRepository.Add(exchangeRate.Map <ExchangeRate>());
await UnitOfWork.CompleteAsync();
return(Ok());
}
/// <summary>
/// Gets the statements.
/// </summary>
/// <param name="sessionID">The session identifier.</param>
/// <param name="startDate">The start date.</param>
/// <param name="endDate">The end date.</param>
/// <param name="interestRate">The interest rate.</param>
/// <returns></returns>
public async Task <TaxesDto> GetTaxesAsync(string sessionID, DateTime startDate, DateTime endDate, double interestRate)
{
TaxesDto taxes = new TaxesDto()
{
StartDate = startDate,
EndDate = endDate,
};
List <PBStatementItemDto> statements = await this.privat24BusinessService.GetStatementsAsync(sessionID, startDate, endDate);
var inputStatements = statements
.Where(d => d.Info.ShortType == "C")
.Where(d => d.Amount.Amount >= 0 && d.Credit.Account.Number.StartsWith("2600") || d.Amount.Amount < 0 && d.Debet.Account.Number.StartsWith("2600"))
.OrderBy(d => d.Info.PostDate)
.ToList();
foreach (var inputStatement in inputStatements)
{
inputStatement.IsTaxed = !inputStatement.Purpose.StartsWith("Гривнi вiд вiльного продажу");
if (inputStatement.Amount.CCY.Equals("UAH"))
{
inputStatement.Course = 1;
}
else
{
ExchangeRateDto excangeRate = await this.privat24Service
.GetExchangeRate(inputStatement.Amount.CCY, inputStatement.Info.PostDate);
if (excangeRate != null)
{
inputStatement.Course = excangeRate.PurchaseRateNB;
}
}
inputStatement.AmountInUAH = inputStatement.Course * inputStatement.Amount.Amount;
if (inputStatement.IsTaxed)
{
taxes.FullAmount += inputStatement.AmountInUAH;
}
}
taxes.TaxesAmount = (interestRate / 100) * taxes.FullAmount;
taxes.InterestRate = interestRate;
taxes.Statements = inputStatements;
return(taxes);
}
public void Setup()
{
_stubExchangeRatesRepository = Substitute.For <IExchangeRatesRepository>();
ExchangeRateDto exchangeRateEUR = createExchangeRate("Euro", "EUR", 100, 500m);
_stubExchangeRatesRepository.GetExchangeRateByISO("EUR").Returns(exchangeRateEUR);
ExchangeRateDto exchangeRateUSD = createExchangeRate("Amerikanske dollar", "USD", 100, 600m);
_stubExchangeRatesRepository.GetExchangeRateByISO("USD").Returns(exchangeRateUSD);
ExchangeRateDto exchangeRateJPY = createExchangeRate("Japanske yen", "JPY", 100, 500m);
_stubExchangeRatesRepository.GetExchangeRateByISO("JPY").Returns(exchangeRateJPY);
}
// fixed is basically from
// variable is to
// so EUR/USD 1.3225 means 1 euro buys 1.3225 dollars
// with eur = fixed and usd = variable currencies
public async Task <ExchangeRateDto> GetRate(
Currency fixedCurrency,
Currency variableCurrency,
DateTime dayOfConversion,
ISystemProcessOperationRunRuleContext ruleCtx)
{
if (string.IsNullOrWhiteSpace(fixedCurrency.Code) || string.IsNullOrWhiteSpace(variableCurrency.Code))
{
this._logger.LogError(
$"was asked to convert two currencies. Once of which was null or empty {fixedCurrency} {variableCurrency}");
return(null);
}
if (string.Equals(fixedCurrency.Code, variableCurrency.Code, StringComparison.InvariantCultureIgnoreCase))
{
var noConversionRate = new ExchangeRateDto
{
DateTime = dayOfConversion,
FixedCurrency = fixedCurrency.Code,
VariableCurrency = variableCurrency.Code,
Rate = 1
};
this._logger.LogInformation(
$"was asked to convert two currencies but they were equal. Returning a rate of 1 for {fixedCurrency} and {variableCurrency}");
return(noConversionRate);
}
var rates = await this.GetExchangeRatesNearestToDate(dayOfConversion, ruleCtx);
if (rates == null || !rates.Any())
{
this._logger.LogError($"unable to find any rates on {dayOfConversion.ToShortDateString()}");
ruleCtx.EventException(
$"unable to change rates from {fixedCurrency.Code} to {variableCurrency.Code} on {dayOfConversion.ToShortDateString()}");
return(null);
}
var rate = this.Convert(rates, fixedCurrency, variableCurrency, dayOfConversion, ruleCtx);
this._logger.LogInformation(
$"was asked to convert two currencies {fixedCurrency} and {variableCurrency} on {dayOfConversion}. Returning {rate.Rate} as the exchange rate");
return(rate);
}
public WashTradeSteps(ScenarioContext scenarioContext, UniverseSelectionState universeSelectionState)
{
this._scenarioContext = scenarioContext;
this._universeSelectionState = universeSelectionState;
var exchangeRateApiRepository = A.Fake <IExchangeRateApiCachingDecorator>();
var exchangeRateDto = new ExchangeRateDto
{
DateTime = new DateTime(2018, 01, 01),
Name = "GBX/USD",
FixedCurrency = "GBX",
VariableCurrency = "USD",
Rate = 200d
};
A.CallTo(() => exchangeRateApiRepository.GetAsync(A <DateTime> .Ignored, A <DateTime> .Ignored)).Returns(
new Dictionary <DateTime, IReadOnlyCollection <ExchangeRateDto> >
{
{ new DateTime(2018, 01, 01), new[] { exchangeRateDto } }
});
var currencyLogger = new NullLogger <CurrencyConverterService>();
this._currencyConverterService = new CurrencyConverterService(exchangeRateApiRepository, currencyLogger);
this._washTradeClustering = new ClusteringService();
this._universeOrderFilterService = A.Fake <IUniverseEquityOrderFilterService>();
this._equityMarketCacheFactory = A.Fake <IUniverseEquityMarketCacheFactory>();
this._fixedIncomeMarketCacheFactory = A.Fake <IUniverseFixedIncomeMarketCacheFactory>();
this._logger = new NullLogger <WashTradeRule>();
this._tradingLogger = new NullLogger <TradingHistoryStack>();
this._equityRuleWashTradeFactory = new EquityRuleWashTradeFactory(
this._currencyConverterService,
this._washTradeClustering,
this._universeOrderFilterService,
this._equityMarketCacheFactory,
this._fixedIncomeMarketCacheFactory,
this._logger,
this._tradingLogger);
this._ruleCtx = A.Fake <ISystemProcessOperationRunRuleContext>();
this._alertStream = A.Fake <IUniverseAlertStream>();
}
public async Task <ExchangeRateDto?> CreateOrUpdateExchangeRate(string currency)
{
var exchangeRateFromCoinbase =
await _coinbaseConnector.GetExchangeRatesForCurrency(currency);
if (exchangeRateFromCoinbase == null)
{
_logger.LogError("Data from Coinbase for exchange rate {Currency} was null", currency);
return(null);
}
var nokRate = exchangeRateFromCoinbase.Rates[ExchangeRateConstants.NOK];
var usdRate = exchangeRateFromCoinbase.Rates[ExchangeRateConstants.USD];
var eurRate = exchangeRateFromCoinbase.Rates[ExchangeRateConstants.EUR];
var exchangeRates = await _exchangeRateProvider.GetExchangeRates(new ExchangeRateSearchParameters { Currencies = new [] { currency } });
var exchangeRate = exchangeRates.FirstOrDefault();
if (exchangeRate != null)
{
exchangeRate.NOKRate = nokRate;
exchangeRate.USDRate = usdRate;
exchangeRate.EURRate = eurRate;
_dbRepository.QueueUpdate <ExchangeRate, ExchangeRateDto>(exchangeRate);
}
else
{
exchangeRate = new ExchangeRateDto
{
Currency = currency,
NOKRate = nokRate,
USDRate = usdRate,
EURRate = eurRate
};
_dbRepository.QueueAdd <ExchangeRate, ExchangeRateDto>(exchangeRate);
}
await _dbRepository.ExecuteQueueAsync();
return(exchangeRate);
}
public async Task Convert_WithIndirectConversionRateSetOneRates_ReturnsExpectedResult(
decimal rate1,
decimal rate2,
decimal expected)
{
var converter = new CurrencyConverterService(this._apiRepository, this._logger);
var Moneys = new List <Money> {
new Money(100, "CNY")
};
var targetCurrency = new Currency("EUR");
var targetDate = new DateTime(2018, 01, 01);
var cnyRate = new ExchangeRateDto
{
DateTime = targetDate,
FixedCurrency = "CNY",
VariableCurrency = "USD",
Name = "Thaler",
Rate = (double)rate1
};
var eurRate = new ExchangeRateDto
{
DateTime = targetDate,
FixedCurrency = "EUR",
VariableCurrency = "USD",
Name = "Thaler",
Rate = (double)rate2
};
var rates = new Dictionary <DateTime, IReadOnlyCollection <ExchangeRateDto> >
{
{ targetDate, new[] { cnyRate, eurRate } }
};
A.CallTo(() => this._apiRepository.GetAsync(targetDate, targetDate)).Returns(rates);
var conversion = await converter.Convert(Moneys, targetCurrency, targetDate, this._ruleCtx);
Assert.IsNotNull(conversion);
Assert.AreEqual(conversion.Value.Value, expected);
Assert.AreEqual(conversion.Value.Currency.Code, "EUR");
A.CallTo(() => this._apiRepository.GetAsync(targetDate, targetDate)).MustHaveHappenedOnceExactly();
}
public async Task QueueUpdateExchangeRate(ExchangeRateDto exchangeRateInDb)
{
var exchangeRateFromCoinbase =
await _coinbaseConnector.GetExchangeRatesForCurrency(exchangeRateInDb.Currency);
if (exchangeRateFromCoinbase == null)
{
_logger.LogError("Data from Coinbase for exchange rate {Currency} was null", exchangeRateInDb.Currency);
return;
}
var nokRate = exchangeRateFromCoinbase.Rates[ExchangeRateConstants.NOK];
var usdRate = exchangeRateFromCoinbase.Rates[ExchangeRateConstants.USD];
var eurRate = exchangeRateFromCoinbase.Rates[ExchangeRateConstants.EUR];
exchangeRateInDb.NOKRate = nokRate;
exchangeRateInDb.USDRate = usdRate;
exchangeRateInDb.EURRate = eurRate;
_dbRepository.QueueUpdate <ExchangeRate, ExchangeRateDto>(exchangeRateInDb);
}
public async Task Convert_WithDirectConversionMultipleRates_ReturnsExpectedResult()
{
var converter = new CurrencyConverterService(this._apiRepository, this._logger);
var monies = new List <Money> {
new Money(100, "CNY"), new Money(20, "USD")
};
var targetCurrency = new Currency("GBP");
var targetDate = new DateTime(2018, 01, 01);
var cnyRate = new ExchangeRateDto
{
DateTime = targetDate,
FixedCurrency = "CNY",
VariableCurrency = "GBP",
Name = "Pound Sterling",
Rate = 0.1
};
var usdRate = new ExchangeRateDto
{
DateTime = targetDate,
FixedCurrency = "USD",
VariableCurrency = "GBP",
Name = "Pound Sterling",
Rate = 0.5
};
var rates = new Dictionary <DateTime, IReadOnlyCollection <ExchangeRateDto> >
{
{ targetDate, new[] { cnyRate, usdRate } }
};
A.CallTo(() => this._apiRepository.GetAsync(targetDate, targetDate)).Returns(rates);
var conversion = await converter.Convert(monies, targetCurrency, targetDate, this._ruleCtx);
Assert.IsNotNull(conversion);
Assert.AreEqual(conversion.Value.Value, 20);
Assert.AreEqual(conversion.Value.Currency.Code, "GBP");
A.CallTo(() => this._apiRepository.GetAsync(targetDate, targetDate)).MustHaveHappenedOnceExactly();
}
private static void Strategy(Dictionary <string, ExchangeRateDto> exchangeRates)
{
BalanceDto balance = apiHandler.getBalanceDTO(logger);
Dictionary <string, double> currencyBalances = new Dictionary <string, double>
{
{ "BTC", balance.btc },
{ "ETH", balance.eth },
{ "XRP", balance.xrp }
};
Random rnd = new Random();
foreach (var item in exchangeRates)
{
ExchangeRateDto dto = item.Value;
//random hogy előbb eladni, vagy venni próbál
//egy körben egyszerre csak eladni vagy venni tud
if (dto.LastRefreshed != lastTradeDate[dto.Symbol])
{
if (rnd.Next(2) == 0)
{
if (!SellStrategy(dto, currencyBalances, balance))
{
BuyStrategy(dto, currencyBalances, balance);
}
}
else
{
if (!BuyStrategy(dto, currencyBalances, balance))
{
SellStrategy(dto, currencyBalances, balance);
}
}
}
else
{
logger.Info("The datas were not refreshed.");
}
}
}
public void rateChanged(ExchangeRateDto rate)
{
Clients.AllExcept(new List <string> {
Context.ConnectionId
}).rateChanged(rate);
}
public HighVolumeSteps(ScenarioContext scenarioContext, UniverseSelectionState universeSelectionState)
{
_scenarioContext = scenarioContext;
_universeSelectionState = universeSelectionState;
var exchangeRateApiRepository = A.Fake <IExchangeRateApiCachingDecorator>();
var exchangeRateDto = new ExchangeRateDto
{
DateTime = new DateTime(2018, 01, 01), Name = "GBX/USD", FixedCurrency = "GBX", VariableCurrency = "USD", Rate = 0.02d
};
var exchangeRateDtoJpy = new ExchangeRateDto
{
DateTime = new DateTime(2018, 01, 01),
Name = "USD/JPY",
FixedCurrency = "USD",
VariableCurrency = "JPY",
Rate = 100
};
var exchangeRateDtoGbx = new ExchangeRateDto
{
DateTime = new DateTime(2018, 01, 01),
Name = "GBX/GBX",
FixedCurrency = "GBX",
VariableCurrency = "GBX",
Rate = 1
};
A.CallTo(() =>
exchangeRateApiRepository.GetAsync(A <DateTime> .Ignored, A <DateTime> .Ignored))
.Returns(new Dictionary <DateTime, IReadOnlyCollection <ExchangeRateDto> >
{
{ new DateTime(2018, 01, 01), new ExchangeRateDto[]
{
exchangeRateDto,
exchangeRateDtoJpy,
exchangeRateDtoGbx
} }
});
var repository = A.Fake <IMarketOpenCloseApiCachingDecorator>();
A
.CallTo(() => repository.GetAsync()).
Returns(new ExchangeDto[]
{
new ExchangeDto
{
Code = "XLON",
MarketOpenTime = TimeSpan.FromHours(8),
MarketCloseTime = TimeSpan.FromHours(16),
IsOpenOnMonday = true,
IsOpenOnTuesday = true,
IsOpenOnWednesday = true,
IsOpenOnThursday = true,
IsOpenOnFriday = true,
IsOpenOnSaturday = true,
IsOpenOnSunday = true,
},
new ExchangeDto
{
Code = "NASDAQ",
MarketOpenTime = TimeSpan.FromHours(15),
MarketCloseTime = TimeSpan.FromHours(23),
IsOpenOnMonday = true,
IsOpenOnTuesday = true,
IsOpenOnWednesday = true,
IsOpenOnThursday = true,
IsOpenOnFriday = true,
IsOpenOnSaturday = true,
IsOpenOnSunday = true,
}
});
_tradingHoursService = new MarketTradingHoursService(repository, new NullLogger <MarketTradingHoursService>());
_equityMarketCacheFactory = new UniverseEquityMarketCacheFactory(
new StubRuleRunDataRequestRepository(),
new StubRuleRunDataRequestRepository(),
new NullLogger <UniverseEquityMarketCacheFactory>());
_fixedIncomeMarketCacheFactory = new UniverseFixedIncomeMarketCacheFactory(
new StubRuleRunDataRequestRepository(),
new StubRuleRunDataRequestRepository(),
new NullLogger <UniverseFixedIncomeMarketCacheFactory>());
var currencyLogger = new NullLogger <CurrencyConverterService>();
currencyConverterService = new CurrencyConverterService(exchangeRateApiRepository, currencyLogger);
_universeOrderFilterService = A.Fake <IUniverseEquityOrderFilterService>();
_logger = new NullLogger <HighVolumeRule>();
_tradingLogger = new NullLogger <TradingHistoryStack>();
_ruleCtx = A.Fake <ISystemProcessOperationRunRuleContext>();
_alertStream = A.Fake <IUniverseAlertStream>();
_dataRequestSubscriber = A.Fake <IUniverseDataRequestsSubscriber>();
_equityRuleHighVolumeFactory = new EquityRuleHighVolumeFactory(
_universeOrderFilterService,
_equityMarketCacheFactory,
_fixedIncomeMarketCacheFactory,
_tradingHoursService,
this.currencyConverterService,
_logger,
_tradingLogger);
}
public HighVolumeVenueFilterSteps(
ScenarioContext scenarioContext,
UniverseSelectionState universeSelectionState)
{
this._scenarioContext = scenarioContext;
this._universeSelectionState = universeSelectionState;
this._observer = A.Fake <IObserver <IUniverseEvent> >();
this._universeDataRequestsSubscriber = A.Fake <IUniverseDataRequestsSubscriber>();
var exchangeRateApiRepository = A.Fake <IExchangeRateApiCachingDecorator>();
var exchangeRateDto = new ExchangeRateDto
{
DateTime = new DateTime(2018, 01, 01),
Name = "GBX/USD",
FixedCurrency = "GBX",
VariableCurrency = "USD",
Rate = 0.02d
};
A.CallTo(() => exchangeRateApiRepository.GetAsync(A <DateTime> .Ignored, A <DateTime> .Ignored)).Returns(
new Dictionary <DateTime, IReadOnlyCollection <ExchangeRateDto> >
{
{ new DateTime(2018, 01, 01), new[] { exchangeRateDto } }
});
var repository = A.Fake <IMarketOpenCloseApiCachingDecorator>();
A.CallTo(() => repository.GetAsync()).Returns(
new[]
{
new ExchangeDto
{
Code = "XLON",
MarketOpenTime = TimeSpan.FromHours(8),
MarketCloseTime = TimeSpan.FromHours(16),
IsOpenOnMonday = true,
IsOpenOnTuesday = true,
IsOpenOnWednesday = true,
IsOpenOnThursday = true,
IsOpenOnFriday = true,
IsOpenOnSaturday = true,
IsOpenOnSunday = true
},
new ExchangeDto
{
Code = "NASDAQ",
MarketOpenTime = TimeSpan.FromHours(15),
MarketCloseTime = TimeSpan.FromHours(23),
IsOpenOnMonday = true,
IsOpenOnTuesday = true,
IsOpenOnWednesday = true,
IsOpenOnThursday = true,
IsOpenOnFriday = true,
IsOpenOnSaturday = true,
IsOpenOnSunday = true
}
});
this._tradingHoursService = new MarketTradingHoursService(
repository,
new NullLogger <MarketTradingHoursService>());
this._interdayUniverseMarketCacheFactory = new UniverseEquityMarketCacheFactory(
new StubRuleRunDataRequestRepository(),
new StubRuleRunDataRequestRepository(),
new NullLogger <UniverseEquityMarketCacheFactory>());
this._universeOrderFilterService = A.Fake <IUniverseEquityOrderFilterService>();
this._logger = new NullLogger <HighVolumeRule>();
this._tradingLogger = new NullLogger <TradingHistoryStack>();
this._ruleCtx = A.Fake <ISystemProcessOperationRunRuleContext>();
}
