public void Initialize(string username, string[] servers, ILoggerFactory loggerFactory = null, string authToken = null)
{
_loggerFactory = loggerFactory ?? new DebugLoggerFactory();
_log = _loggerFactory.Create(typeof(ReactiveTrader));
_connectionProvider = new ConnectionProvider(username, servers, _loggerFactory);
var referenceDataServiceClient = new ReferenceDataServiceClient(_connectionProvider, _loggerFactory);
var executionServiceClient = new ExecutionServiceClient(_connectionProvider);
var blotterServiceClient = new BlotterServiceClient(_connectionProvider, _loggerFactory);
var pricingServiceClient = new PricingServiceClient(_connectionProvider, _loggerFactory);
if (authToken != null)
{
var controlServiceClient = new ControlServiceClient(new AuthTokenProvider(authToken), _connectionProvider, _loggerFactory);
_controlRepository = new ControlRepository(controlServiceClient);
}
PriceLatencyRecorder = new PriceLatencyRecorder();
var concurrencyService = new ConcurrencyService();
var tradeFactory = new TradeFactory();
var executionRepository = new ExecutionRepository(executionServiceClient, tradeFactory, concurrencyService);
var priceFactory = new PriceFactory(executionRepository, PriceLatencyRecorder);
var priceRepository = new PriceRepository(pricingServiceClient, priceFactory, _loggerFactory);
var currencyPairUpdateFactory = new CurrencyPairUpdateFactory(priceRepository);
TradeRepository = new TradeRepository(blotterServiceClient, tradeFactory);
ReferenceData = new ReferenceDataRepository(referenceDataServiceClient, currencyPairUpdateFactory);
}
public TradeJob(
TradeRepository tradeRepository,
IHubContext <btcusdtHub> hubcontext)
{
_tradeRepository = tradeRepository;
_hubcontext = hubcontext;
}
public UnitOfWork(FxContext context)
{
_context = context;
Price = new PriceRepository(_context);
Candle = new CandleRepository(_context);
Trade = new TradeRepository(_context);
}
public WhenStockServiceIsRequested()
{
IStockRepository stockRepository = new StockRepository();
ITradeRepository tradeRepository = new TradeRepository();
_stockService = new StockService(stockRepository, tradeRepository);
}
public void Initialize(string username, string[] servers, ILoggerFactory loggerFactory = null, string authToken = null)
{
_loggerFactory = loggerFactory ?? new DebugLoggerFactory();
_log = _loggerFactory.Create(typeof(ReactiveTrader));
var concurrencyService = new ConcurrencyService();
_serviceClientContainer = new WampServiceClientContainer(servers[0], username, concurrencyService, _loggerFactory);
// TODO: Make the Async Connection better
_serviceClientContainer.ConnectAsync().Wait();
var referenceDataServiceClient = new ReferenceDataServiceClient(_serviceClientContainer.Reference, _loggerFactory);
var executionServiceClient = new ExecutionServiceClient(_serviceClientContainer.Execution);
var blotterServiceClient = new BlotterServiceClient(_serviceClientContainer.Blotter, _loggerFactory);
var pricingServiceClient = new PricingServiceClient(_serviceClientContainer.Pricing, _loggerFactory);
PricingServiceClient = pricingServiceClient;
PriceLatencyRecorder = new PriceLatencyRecorder();
var tradeFactory = new TradeFactory();
var executionRepository = new ExecutionRepository(executionServiceClient, tradeFactory, concurrencyService);
var priceFactory = new PriceFactory(executionRepository, PriceLatencyRecorder);
var priceRepository = new PriceRepository(pricingServiceClient, priceFactory, _loggerFactory);
var currencyPairUpdateFactory = new CurrencyPairUpdateFactory(priceRepository);
TradeRepository = new TradeRepository(blotterServiceClient, tradeFactory);
ReferenceData = new ReferenceDataRepository(referenceDataServiceClient, currencyPairUpdateFactory);
}
// GET: TradeApi
public IHttpActionResult Index()
{
var repo = new TradeRepository();
var trades = repo.GetTrades();
return(Ok(trades));
}
public async Task LoadTradesTask()
{
var repo = new TradeRepository();
var result = await repo.LoadTrades("XBTUSD", new DateTime(2017, 11, 02, 11, 40, 00),
new DateTime(2017, 11, 03, 11, 40, 00));
Assert.That(result.Any(), Is.True);
}
public TradeAccountInfo(APIKeyRepository keyRepo, TradeConfigRepository configRepository, TradeRepository tradeRepository)
{
this.keyRepo = keyRepo;
this.configRepository = configRepository;
this.tradeRepository = tradeRepository;
logService = new LogService();
logService.CreateLogFile("TradeAccountInfo");
}
public TradeJob(
TradeRepository tradeRepository,
IHubContext <btcusdtHub> hubcontext,
PairsRepository pairsRepository)
{
_tradeRepository = tradeRepository;
_hubcontext = hubcontext;
_pairsRepository = pairsRepository;
}
public UnitOfWork(ArchimedesContext context)
{
_context = context;
Price = new PriceRepository(_context);
Candle = new CandleRepository(_context);
Trade = new TradeRepository(_context);
Market = new MarketRepository(_context);
PriceLevel = new PriceLevelRepository(_context);
Strategy = new StrategyRepository(_context);
}
public StatsController(TransactionsRepository transactionsRepository, TransferRepository transferRepository,
OutcomeTransactionRepository outcomeRepository, TradeRepository tradeRepository, UsersInfoRepository usersInfoRepository, UserRepository userRepository)
{
_transactionsRepository = transactionsRepository;
_transferRepository = transferRepository;
_outcomeRepository = outcomeRepository;
_tradeRepository = tradeRepository;
_usersInfoRepository = usersInfoRepository;
_userRepository = userRepository;
}
public async Task TradeRepository_GetAsyncTest()
{
var optionsbuilder = new DbContextOptionsBuilder <ExchangeContext>();
optionsbuilder.UseInMemoryDatabase(databaseName: "XOProjectDb");
var _dbContext = new ExchangeContext(optionsbuilder.Options);
ITradeRepository _tradeRepository = new TradeRepository(_dbContext);
var result = await _tradeRepository.GetAllTradings(1);
Assert.NotNull(result);
}
public IHttpActionResult Get()
{
var repo = new TradeRepository();
var trades = repo.GetTrades();
if (trades == null)
{
return(NotFound());
}
return(Ok(trades));
}
public void TestMethodTrades()
{
//Arrange
TradeRepository tradeRepo = new TradeRepository();
//Act
var trades = tradeRepo.GetTrades();
var tradeCount = trades.Count();
//Assert
Assert.AreEqual(tradeCount, 500);
}
public Trade Save(Trade trade)
{
TradeRepository repo = new TradeRepository();
if (repo.Iduplicate(trade))
{
return(new Trade());
}
else
{
return(repo.Save(trade));
}
}
public TradeController()
{
var databaseUri = UriFactory.CreateDatabaseUri(_databaseId);
_client = new DocumentClient(new Uri(_endpointUrl), _primaryKey);
_client.CreateDatabaseIfNotExistsAsync(new Database()
{
Id = _databaseId
});
_client.CreateDocumentCollectionIfNotExistsAsync(databaseUri, new DocumentCollection {
Id = _collectionId
}).Wait();
_repository = new TradeRepository(_client, _databaseId, _collectionId);
}
public void GetTradesTest()
{
// Check to see if the trade count is correct.
var tradeRepository = new TradeRepository();
var trades = tradeRepository.GetTrades();
int tradeCount = 0;
foreach (var trade in trades)
{
tradeCount++;
}
Assert.AreEqual(MaxCount, tradeCount);
}
public TradeController(
WalletsRepository walletsRepository,
TradeRepository tradeRepository,
BotsRepository botsRepository,
CandleStickRepository candleStickRepository,
PairsRepository pairsRepository,
IHubContext <btcusdtHub> hubcontext)
{
_walletsRepository = walletsRepository;
_tradeRepository = tradeRepository;
_botsRepository = botsRepository;
_candleStickRepository = candleStickRepository;
_pairsRepository = pairsRepository;
_hubcontext = hubcontext;
}
public void Dispose()
{
if (TradeRepository != null)
{
TradeRepository.Dispose();
TradeRepository = null;
}
if (SettlementManager != null)
{
SettlementManager.Dispose();
SettlementManager = null;
}
GC.Collect(0);
}
public async Task GetTradebyID_Database_test(int id)
{
using var connection = Database_init();
var options = new DbContextOptionsBuilder <mmpproject2Context>().UseSqlite(connection).Options;
using var context = new mmpproject2Context(options);
var repo = new TradeRepository(options);
var trade = await repo.GetAsync(id);
var tradeActual = context.Trades.Where(x => x.Id == id).Single();
Assert.Equal(trade.Id, tradeActual.Id);
Assert.Equal(trade.Price, tradeActual.Price);
Assert.Equal(trade.Quantity, tradeActual.Quantity);
}
private List <BuySellView> GetTrades(string simbol, double minPrice, double maxPrice)
{
var result = new List <BuySellView>();
var tradeRepository = new TradeRepository();
var trades = tradeRepository.Get(simbol, minPrice, maxPrice).ToList();
var resGroup = trades.GroupBy(x => new { x.Price, x.IsBuyer }).ToList();
foreach (var item in resGroup)
{
result.Add(new BuySellView()
{
Price = item.Key.Price,
IsBuy = item.Key.IsBuyer
});
}
return(result);
}
public async Task Get_Analysis_Valid_Maximum()
{
string symbol = "REL";
var builder = new DbContextOptionsBuilder <ExchangeContext>();
builder.UseInMemoryDatabase(databaseName: "TestTrade3");
var context = new ExchangeContext(builder.Options);
exchangeContextInit(context);
var repo = new TradeRepository(context);
var result = await repo.GetAnalysis(symbol) as List <TradeAnalysis>;;
Assert.AreEqual(100, result[0].Maximum);
}
public async Task Get_AllTrades_Valid_Count()
{
int portfolioID = 1;
var builder = new DbContextOptionsBuilder <ExchangeContext>();
builder.UseInMemoryDatabase(databaseName: "TestTrade1");
var context = new ExchangeContext(builder.Options);
exchangeContextInit(context);
var repo = new TradeRepository(context);
var result = await repo.GetAllTradings(portfolioID) as List <Trade>;;
var count = result.Count;
Assert.AreEqual(2, count);
}
public async Task Get_Trades_By_Symbol_Valid_Count()
{
string symbol = "REL";
var builder = new DbContextOptionsBuilder <ExchangeContext>();
builder.UseInMemoryDatabase(databaseName: "TestTrade2");
var context = new ExchangeContext(builder.Options);
exchangeContextInit(context);
var repo = new TradeRepository(context);
var result = await repo.GetBySymbol(symbol) as List <Trade>;;
var count = result.Count;
Assert.AreEqual(2, count);
}
public async Task GetTrades_Database_testAsync()
{
using var connection = Database_init();
var options = new DbContextOptionsBuilder <mmpproject2Context>().UseSqlite(connection).Options;
using var context = new mmpproject2Context(options);
var repo = new TradeRepository(options);
var trades = await repo.GetAllAsync();
var tradesActual = context.Trades.ToList();
foreach (var trade in trades)
{
Assert.Contains(trade.Id, tradesActual.Select(x => x.Id));
Assert.Contains(trade.Price, tradesActual.Select(x => x.Price));
Assert.Contains(trade.Quantity, tradesActual.Select(x => x.Quantity));
}
}
private async Task <decimal> SetupTradeService(string pair, DateTime start, DateTime end)
{
var real = new TradeRepository();
var config = _container.Resolve <Config>();
trades = (await real.LoadTrades(pair, start.AddHours(-config.Pairs[pair].LoadHours), end)).ToList();
var repo = _container.Resolve <ITradeRepository>();
repo.LoadTrades(Arg.Any <string>(), Arg.Any <DateTime>(), Arg.Any <DateTime>())
.Returns(args =>
{
var startDate = Convert.ToDateTime((object)args[1]).AddHours(-config.Pairs[pair].LoadHours);
var endDate = Convert.ToDateTime((object)args[2]);
return(trades.Where(x => x.DateTime > startDate && x.DateTime < endDate));
});
return(trades.Last().Price);
}
private async Task <List <TradeLine> > GetTrades(string simbol, double minPrice, double maxPrice)
{
var result = new List <TradeLine>();
await Task.Run(() =>
{
var tradeRepository = new TradeRepository();
var trades = tradeRepository.Get(simbol, minPrice, maxPrice).ToList();
var resGroup = trades.GroupBy(x => new { x.Price, x.IsBuyer }).ToList();
foreach (var item in resGroup)
{
result.Add(new TradeLine()
{
Price = item.Key.Price,
IsBuyer = item.Key.IsBuyer
});
}
});
return(result);
}
public void Query_ShouldReturnCorrectTradeCountTest()
{
// Arrange
var builder = new DbContextOptionsBuilder <ExchangeContext>();
builder.UseInMemoryDatabase(databaseName:
"TestPortfolio7");
var context = new ExchangeContext(builder.Options);
InitDbContext(context);
var repo = new TradeRepository(context);
// Act
var result = repo.Query();
var count = result.CountAsync();
// Assert
Assert.AreEqual(2, Convert.ToInt32(count.Result));
}
public void AddTrade_WithDetails_SuccessfullyAddsTradeToList()
{
// Arrange
var dateTimeProvider = new Mock <IDateTimeProvider>();
var localTimestamp = new DateTime(2017, 2, 17, 22, 14, 44);
dateTimeProvider.Setup(x => x.Now).Returns(localTimestamp);
var tradeRepository = new TradeRepository(dateTimeProvider.Object);
var teaStock = new CommonStock {
StockSymbol = "TEA"
};
// Act
var trade = tradeRepository.AddTrade(teaStock, 100, TransactionType.Buy, 1.23M);
// Assert
Assert.AreEqual(1, tradeRepository.TradeCount);
Assert.AreEqual(100, trade.Quantity);
Assert.AreEqual(TransactionType.Buy, trade.TransactionType);
Assert.AreEqual(1.23, trade.TradePrice);
Assert.AreEqual(localTimestamp, trade.LocalTimestamp);
Assert.AreEqual(teaStock, trade.Stock);
}
public void TradeAnalysis_Does_Not_Return_Null(string symbol)
{
//Arrange
var options = new DbContextOptionsBuilder <ExchangeContext>()
.UseInMemoryDatabase(databaseName: "GetTradeAnalysis")
.Options;
using (var context = new ExchangeContext(options))
{
context.Trades.Add(new Trade
{
Symbol = "REL",
Action = "BUY",
Id = 1,
NoOfShares = 200,
PortfolioId = 3,
Price = 343
});
context.Trades.Add(
new Trade
{
Symbol = "KEL",
Action = "SELL",
Id = 2,
NoOfShares = 100,
PortfolioId = 2,
Price = 232
}
);
context.SaveChanges();
//Act
ITradeRepository repo = new TradeRepository(context);
var result = repo.GetTradeAnalysis(symbol);
//Assert
Assert.NotNull(result);
}
}
