public MarketDataHandler(string period, bool isAdjustedValue, int priorityStart, int priorityEnd)
{
_period = ConvertStringToBarFrequency(period);
_isAdjustedValue = isAdjustedValue;
_priorityStart = priorityStart;
_priorityEnd = priorityEnd;
}
public string GetLatestStockHistoryPrices(string symbols, string frequency, string isadjustedvalue, string datasource)
{
try
{
string[] symbolList = symbols.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
BarFrequency freq = RestfulHelper.ConvertStringToBarFrequency(frequency);
bool isAdjusted = false;
if (!string.IsNullOrWhiteSpace(isadjustedvalue))
{
if (!bool.TryParse(isadjustedvalue, out isAdjusted))
{
return("Error:isAdjustedValue");
}
}
IDictionary <string, StockBar> result = new MarketDataService().GetLatestStockHistoryPrices(symbolList, freq, isAdjusted, datasource);
if (result != null && result.Count > 0)
{
result.Values.ToCSV();
}
return(string.Empty);
}
catch (Exception ex)
{
_Logger.Error(ex);
throw ex;
}
}
public TVCHistoryResponse GetHistoricalPrices(string symbol, BarFrequency frequency, DateTime from, DateTime to)
{
string freq = ConvertBarFrequencyToTVCResolution(frequency);
string result = TVCHttpGet(string.Format(TVC_URL_HISTORY, symbol, freq, from.ToUnixDateTime(), to.ToUnixDateTime()));
TVCHistoryResponse history = JsonConvert.DeserializeObject <TVCHistoryResponse>(result);
return(history);
}
public bool StoreHistoryPrices(long SID, BarFrequency period, bool isAdjustedValue, Bar[] bars)
{
BasicHttpBinding binding = Utility.BuildBasicHttpBinding();
EndpointAddress endpoint = BuildMarketDataSkywolfHttpEndpointAddress();
using (SkywolfClient <IMarketDataService> skywolf = new SkywolfClient <IMarketDataService>(binding, endpoint))
{
return(skywolf.Instance.VA_StorePrices(SID, period, isAdjustedValue, bars));
}
}
public TVCHistoryResponse TVC_GetHistoricalPrices(string symbol, BarFrequency frequency, DateTime from, DateTime to)
{
try
{
return((_dataGrabber[DATASOURCE_TVC] as TVCMarketDataGrabber).GetHistoricalPrices(symbol, frequency, from, to));
}
catch (Exception ex)
{
_Logger.Error(ex);
throw ex;
}
}
public bool VA_StorePrices(long SID, BarFrequency frequency, bool isAdjustedValue, Bar[] bars)
{
try
{
return(new MarketDataDatabase().VA_StorePrices(SID, frequency, isAdjustedValue, bars));
}
catch (Exception ex)
{
_Logger.Error(ex);
throw ex;
}
}
public static BarFrequency ConvertStringToBarFrequency(string freq)
{
BarFrequency result = BarFrequency.None;
switch (freq.Trim().ToUpper())
{
case "MN":
result = BarFrequency.Month1;
break;
case "W1":
result = BarFrequency.Week1;
break;
case "D1":
result = BarFrequency.Day1;
break;
case "H4":
result = BarFrequency.Hour4;
break;
case "H1":
result = BarFrequency.Hour1;
break;
case "M30":
result = BarFrequency.Minute30;
break;
case "M15":
result = BarFrequency.Minute15;
break;
case "M5":
result = BarFrequency.Minute5;
break;
case "M1":
result = BarFrequency.Minute1;
break;
case "T":
result = BarFrequency.Tick;
break;
}
return(result);
}
public static string ConvertBarFrequencyToString(BarFrequency freq)
{
string result = string.Empty;
switch (freq)
{
case BarFrequency.Month1:
result = "MN";
break;
case BarFrequency.Week1:
result = "W1";
break;
case BarFrequency.Day1:
result = "D1";
break;
case BarFrequency.Hour4:
result = "H4";
break;
case BarFrequency.Hour1:
result = "H1";
break;
case BarFrequency.Minute30:
result = "M30";
break;
case BarFrequency.Minute15:
result = "M15";
break;
case BarFrequency.Minute5:
result = "M5";
break;
case BarFrequency.Minute1:
result = "M1";
break;
case BarFrequency.Tick:
result = "T";
break;
}
return(result);
}
public TimeSeriesDataOutput RetrieveStockTimeSeriesPrices(string symbol, BarFrequency period, bool isAjustedValue, long outputCount)
{
BasicHttpBinding binding = Utility.BuildBasicHttpBinding();
EndpointAddress endpoint = BuildMarketDataSkywolfHttpEndpointAddress();
using (SkywolfClient <IMarketDataService> skywolf = new SkywolfClient <IMarketDataService>(binding, endpoint))
{
TimeSeriesDataInput input = new TimeSeriesDataInput();
input.Frequency = period;
input.IsAdjustedValue = isAjustedValue;
input.Symbol = symbol;
input.OutputCount = outputCount;
return(skywolf.Instance.GetTimeSeriesData(input, DATASOURCE));
}
}
public string ConvertBarFrequencyToTVCResolution(BarFrequency frequency)
{
string freq = "D";
switch (frequency)
{
case BarFrequency.Day1:
freq = "D";
break;
case BarFrequency.Hour1:
freq = "60";
break;
case BarFrequency.Hour4:
freq = "240";
break;
case BarFrequency.Minute1:
freq = "1";
break;
case BarFrequency.Minute15:
freq = "15";
break;
case BarFrequency.Minute30:
freq = "30";
break;
case BarFrequency.Minute5:
freq = "5";
break;
case BarFrequency.Month1:
freq = "M";
break;
case BarFrequency.Week1:
freq = "W";
break;
}
return(freq);
}
public string TVC_GetHistoricalPrices(string symbol, string frequency, string from, string to)
{
BarFrequency freq = RestfulHelper.ConvertStringToBarFrequency(frequency);
DateTime startDate = DateTime.MinValue;
if (!string.IsNullOrWhiteSpace(from))
{
try
{
startDate = Convert.ToDateTime(from);
}
catch (Exception)
{
return("Error:from");
}
}
DateTime endDate = DateTime.Today;
if (!string.IsNullOrWhiteSpace(to))
{
try
{
endDate = Convert.ToDateTime(to);
}
catch (Exception)
{
return("Error:to");
}
}
try
{
TVCHistoryResponse response = new MarketDataService().TVC_GetHistoricalPrices(symbol, freq, startDate, endDate);
return(JsonConvert.SerializeObject(response));
}
catch (Exception ex)
{
_Logger.Error(ex);
throw ex;
}
}
public string GetLatestCryptoHistoryPrices(string symbols, string market, string frequency, string datasource)
{
try
{
string[] symbolList = symbols.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
BarFrequency freq = RestfulHelper.ConvertStringToBarFrequency(frequency);
IDictionary <string, CryptoBar> result = new MarketDataService().GetLatestCryptoHistoryPrices(symbolList, market, freq, datasource);
if (result != null && result.Count > 0)
{
return(result.Values.ToCSV());
}
return(string.Empty);
}
catch (Exception ex)
{
_Logger.Error(ex);
throw ex;
}
}
public List <DateTime> GetDateTimes(string country, DateTime endDate, int count = 1, BarFrequency freq = BarFrequency.Day1, string type = "STK")
{
RefreshCache();
List <DateTime> dateRange = new List <DateTime>();
string key = country + "-" + type;
if (_calendarFinalDates.ContainsKey(key))
{
DateTime startTime = _calendarStartDates[key];
DateTime finalTime = _calendarFinalDates[key];
if (endDate >= startTime && endDate <= finalTime)
{
List <DateTime> allDateRange = null;
switch (freq)
{
case BarFrequency.Day1:
allDateRange = _marketOpenDayCache[key];
break;
case BarFrequency.Minute1:
allDateRange = _marketOpenMinCache[key];
break;
}
if (allDateRange != null)
{
DateTime endDateInRange = (from p in allDateRange
where p <= endDate
orderby p descending
select p).FirstOrDefault();
int endDateIdx = allDateRange.IndexOf(endDateInRange);
dateRange = allDateRange.GetRange(endDateIdx, count);
}
}
}
return(dateRange);
}
public IDictionary <string, CryptoBar> GetLatestCryptoHistoryPrices(string[] symbols, string market, BarFrequency period)
{
BasicHttpBinding binding = Utility.BuildBasicHttpBinding();
EndpointAddress endpoint = BuildMarketDataSkywolfHttpEndpointAddress();
using (SkywolfClient <IMarketDataService> skywolf = new SkywolfClient <IMarketDataService>(binding, endpoint))
{
return(skywolf.Instance.GetLatestCryptoHistoryPrices(symbols, market, period, DATASOURCE));
}
}
public IDictionary <string, StockBar> GetLatestStockHistoryPrices(string[] symbols, BarFrequency period, bool isAdjustedValue)
{
int iCount = 0;
while (iCount < 3)
{
try
{
BasicHttpBinding binding = Utility.BuildBasicHttpBinding();
EndpointAddress endpoint = BuildMarketDataSkywolfHttpEndpointAddress();
using (SkywolfClient <IMarketDataService> skywolf = new SkywolfClient <IMarketDataService>(binding, endpoint))
{
IDictionary <string, StockBar> stockBars = skywolf.Instance.GetLatestStockHistoryPrices(symbols, period, isAdjustedValue, DATASOURCE);
ConcurrentDictionary <string, StockBar> dictStockBars = new ConcurrentDictionary <string, StockBar>();
if (stockBars != null && stockBars.Count > 0)
{
foreach (var pair in stockBars)
{
dictStockBars[pair.Key] = pair.Value;
}
}
return(dictStockBars);
}
}
catch (Exception ex)
{
if (iCount == 2)
{
throw ex;
}
iCount++;
}
}
return(null);
}
public IDictionary <string, CryptoBar> GetLatestCryptoHistoryPrices(string[] symbols, string market, BarFrequency frequency, string datasource)
{
if (symbols == null || symbols.Length == 0 || string.IsNullOrEmpty(market))
{
return(null);
}
IDictionary <string, CryptoBar> output = null;
try
{
if (string.IsNullOrEmpty(datasource))
{
datasource = DATASOURCE_DEFAULT;
}
datasource = datasource.Trim().ToLower();
if (datasource == DATASOURCE_ALPHAVANTAGE)
{
output = new MarketDataDatabase().VA_GetLatestCryptoPrices(symbols, market, frequency);
}
}
catch (Exception ex)
{
_Logger.Error(ex);
throw ex;
}
return(output);
}
public DataTable GetHistory(string now, string country, IEnumerable <string> symbols, string field, BarFrequency freq, int count)
{
throw new NotImplementedException();
}
public string GetCryptoHistoryPrices(string symbols, string market, string frequency, string startdate, string enddate, string outputcount, string datasource)
{
try
{
string[] symbolList = symbols.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
BarFrequency freq = RestfulHelper.ConvertStringToBarFrequency(frequency);
DateTime? start = null;
if (!string.IsNullOrWhiteSpace(startdate))
{
try
{
start = Convert.ToDateTime(startdate);
}
catch (Exception)
{
return("Error:startDate");
}
}
DateTime?end = null;
if (!string.IsNullOrWhiteSpace(enddate))
{
try
{
end = Convert.ToDateTime(enddate);
}
catch (Exception)
{
return("Error:endDate");
}
}
int count = 0;
if (!string.IsNullOrWhiteSpace(outputcount))
{
if (!int.TryParse(outputcount, out count))
{
return("Error:outputCount");
}
}
IDictionary <string, CryptoBar[]> result = new MarketDataService().GetCryptoHistoryPrices(symbolList, market, freq, start, end, count, datasource);
StringBuilder resultBuilder = new StringBuilder();
if (result != null && result.Count > 0)
{
foreach (string s in symbolList)
{
resultBuilder.AppendLine("<symbol>");
resultBuilder.AppendLine(s);
resultBuilder.AppendLine("</symbol>");
CryptoBar[] cryptoBars = null;
resultBuilder.AppendLine("<data>");
if (result.TryGetValue(s, out cryptoBars) && cryptoBars != null)
{
resultBuilder.Append(cryptoBars.ToCSV());
}
resultBuilder.AppendLine("</data>");
}
}
return(resultBuilder.ToString());
}
catch (Exception ex)
{
_Logger.Error(ex);
throw ex;
}
}
public IDictionary <string, StockBar> GetLatestStockHistoryPrices(string[] symbols, BarFrequency frequency, bool isAdjustedValue, string datasource)
{
if (symbols == null || symbols.Length == 0)
{
return(null);
}
IDictionary <string, StockBar> output = null;
try
{
if (string.IsNullOrEmpty(datasource))
{
datasource = DATASOURCE_DEFAULT;
}
datasource = datasource.Trim().ToLower();
if (datasource == DATASOURCE_ALPHAVANTAGE)
{
output = new MarketDataDatabase().VA_GetLatestStockPrices(symbols, frequency, isAdjustedValue);
}
}
catch (Exception ex)
{
_Logger.Error(ex);
throw ex;
}
return(output);
}
