public IHttpActionResult GetSymbol([FromUri] string symbol = null)
{
using (var symbolRepository = new SymbolRepository())
{
var symbolModel = symbolRepository.FindByName(symbol).FirstOrDefault();
if (symbolModel == null)
{
return(NotFound());
}
return(Ok(JsonConvert.SerializeObject(new
{
description = symbolModel.Name,
name = symbolModel.Name,
minmov = 1,
minmov2 = 0,
has_intraday = false,
has_no_volume = false,
pointvalue = 1,
pricescale = 100,
supported_pesolutions = new[] { "D" },
ticker = symbolModel.Name
})));
}
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var symbolRepository = new SymbolRepository();
var signRepository = new SignRepository();
Application.Run(new Form1(symbolRepository, signRepository));
}
public async Task InitializeAsync()
{
var cleanFixture = new CleanDBFixture();
var exchangeSyncSetupFixture = new ExchangeSyncSetupFixture();
await cleanFixture.InitializeAsync();
await exchangeSyncSetupFixture.InitializeAsync();
_sync = exchangeSyncSetupFixture.ExchangeSync;
_syncRepo = exchangeSyncSetupFixture.ExchangeSyncRepo;
_symbolRepo = exchangeSyncSetupFixture.SymbolRepo;
}
public string Get(string symbol)
{
int index = symbol.IndexOf(":", StringComparison.Ordinal);
if (index > 0)
{
symbol = symbol.Substring(0, index);
}
var symbolModel = Map <Symbol, SymbolInfo>(SymbolRepository.Get(x => x.Name.ToUpper() == symbol));
//Change price resolution
if (CustomDatas.GetIntegerSymbolsName().Contains(symbolModel.Name.ToUpper()))
{
symbolModel.MinMov = 1;
symbolModel.PriceScale = 1;
}
return(JsonConvert.SerializeObject(symbolModel));
}
public IHttpActionResult FindSymbols(
[FromUri] string query = null, [FromUri] string type = null,
[FromUri] string exchange = null, [FromUri] int?limit = null)
{
using (var symbolRepository = new SymbolRepository())
{
var foundSymbols = symbolRepository
.FindByName(query)
.Take(limit ?? 30)
.ToList();
if (foundSymbols.Count == 0)
{
return(NotFound());
}
return(Ok(foundSymbols.Select(s => new { symbol = s.Name, full_name = s.Name })));
}
}
public MembersRepository(
IHttpContextAccessor httpContextAccessor,
IDatabaseManager databaseManager,
CachedSettings cachedSettings,
GamePayoutEngine gamePayoutEngine,
PaylineRepository paylineRepository,
SymbolRepository symbolRepository,
HistoryDecoderFactory historyDecoderFactory,
GameInfoRepository gameInfoRepository)
{
this.httpContextAccessor = httpContextAccessor;
this.databaseManager = databaseManager;
this.cachedSettings = cachedSettings;
this.gamePayoutEngine = gamePayoutEngine;
this.paylineRepository = paylineRepository;
this.symbolRepository = symbolRepository;
this.gameInfoRepository = gameInfoRepository;
this.historyDecoderFactory = historyDecoderFactory;
}
public static void SetupSymbols(TickTraderWebClient client)
{
var symbols = client.GetQuoteHistorySymbols();
foreach (var symbol in symbols)
{
using (var repo = new SymbolRepository())
{
try
{
repo.AddSymbol(new Symbol {
Name = symbol
}).GetAwaiter().GetResult();
}
catch (SqlException e)
{
Console.WriteLine(e);
}
}
}
}
public static void SetupQuotes(TickTraderWebClient client)
{
using (var symbolRepository = new SymbolRepository())
using (var quoteRepository = new QuoteRepository())
{
var symbols = symbolRepository.GetAll().ToList();
foreach (var symbol in symbols)
{
try
{
var periodicities = client.GetQuoteSymbolPeriodicities(symbol.Name);
var barInfo = client.GetBarsInfo(symbol.Name, periodicities[0]);
var bars = client.GetBars(symbol.Name, periodicities[0], barInfo.AvailableTo, BatchSize);
foreach (var bar in bars.Bars)
{
quoteRepository.AddQuote(new Quote
{
SymbolId = symbol.Id,
Timestamp = bar.Timestamp,
Close = bar.Close,
High = bar.High,
Low = bar.Low,
Open = bar.Open,
Volume = bar.Open
});
}
}
catch (HttpRequestException e)
{
Console.WriteLine(e.Message);
}
catch (SqlException e)
{
Console.WriteLine(e.Message);
}
}
}
}
public async Task InitializeAsync()
{
var mockDbOptions = new Mock <IOptionsMonitor <DbOptions> >();
mockDbOptions.Setup(x => x.CurrentValue).Returns(new DbOptions
{
ConnectionString = AppTestSettings.Instance.TestDBConnectionString,
DefaultBulkCopyBatchSize = AppTestSettings.Instance.DefaultBulkCopyBatchSize
});
var nasdaqLogger = new Mock <ILogger <NasdaqParser> >();
var exchangeClientLogger = new Mock <ILogger <ExchangeClient> >();
// Setup dependencies
ExchangeSyncRepo = new ExchangeSyncRepository(mockDbOptions.Object);
string nasdaqDownloadUrl = (await ExchangeSyncRepo.GetSyncSettings()).Url;
// Stub FTP so we use downloaded file from disk instead of every test run
var stubFTPClient = new CachedNasdaqClient(nasdaqDownloadUrl);
var exchangeClient = new ExchangeClient(
ftpClient: stubFTPClient,
parser: new NasdaqParser(nasdaqLogger.Object),
logger: exchangeClientLogger.Object);
var changesetFactory = new ExchangeSyncChangesetsFactory();
ExchangeSync = new ExchangeSync(exchangeClient, ExchangeSyncRepo, changesetFactory, new Mock <ILogger <ExchangeSync> >().Object);
SymbolRepo = new SymbolRepository(mockDbOptions.Object);
await ToggleSyncThreshold(false);
await ExchangeSync.Sync();
await ToggleSyncThreshold(true);
}
public async Task <bool> Run(ILogger logger)
{
logger.LogInformation("Running repository bootstrapper");
try
{
foreach (var currency in CurrencyFactory.List())
{
await CurrencyRepository.Add(currency);
}
foreach (var symbol in SymbolFactory.List())
{
await SymbolRepository.Add(symbol);
}
foreach (var group in IntervalFactory.ListGroups())
{
foreach (var ik in IntervalFactory.ListIntervalKeys(group.IntervalGroup))
{
await IntervalRepository.Add(ik);
}
}
foreach (var exchange in ExchangeFactory.List())
{
await ExchangeRepository.Add(exchange);
var httpClient = exchange.GetHttpClient();
foreach (var symbolCode in exchange.Symbol)
{
var symbol = SymbolFactory.Get(symbolCode);
await SymbolRepository.Add(symbol);
await ExchangeRepository.AddSymbol(exchange.Name, symbolCode);
var tradeFilter = await HistorianRepository.GetTradeFilter(exchange.Name, symbolCode);
if (tradeFilter == null)
{
using (var transaction = await StorageTransactionFactory.Begin())
{
await HistorianRepository.SetTradeFilter(transaction, exchange.Name, symbolCode, httpClient.InitialTradeFilter);
await transaction.Commit();
}
}
}
}
foreach (var orderSide in OrderSideFactory.List())
{
await OrderSideRepository.Add(orderSide);
}
return(true);
}
catch (Exception ex)
{
logger.LogCritical(ex, "Unable to run repository bootstrapper");
return(false);
}
}
public string Get(string query, string type, string exchange, int limit)
{
var data = SymbolRepository.GetList(x => x.Name.ToUpper().Contains(query));
return(JsonConvert.SerializeObject(data != null ? Map <ICollection <Symbol>, ICollection <SymbolSearchResponse> >(data) : new List <SymbolSearchResponse>()));
}
