935 lines
40 KiB
C#
Executable File
935 lines
40 KiB
C#
Executable File
using MarketData.MarketDataModel;
|
|
using MarketData.DataAccess;
|
|
using MarketData.Utils;
|
|
|
|
namespace MarketData.Helper
|
|
{
|
|
public class PricingThreadHelper : ThreadHelper
|
|
{
|
|
private DateTime pricingDate=DateTime.Parse("12-31-9999");
|
|
private DateTime? startDate;
|
|
|
|
public PricingThreadHelper(String symbol,ManualResetEvent resetEvent)
|
|
{
|
|
Symbol=symbol;
|
|
ResetEvent=resetEvent;
|
|
}
|
|
public PricingThreadHelper(String symbol, DateTime pricingDate,ManualResetEvent resetEvent)
|
|
{
|
|
Symbol = symbol;
|
|
this.pricingDate=pricingDate;
|
|
ResetEvent = resetEvent;
|
|
}
|
|
public PricingThreadHelper(String symbol, ManualResetEvent resetEvent,DateTime? startDate=null)
|
|
{
|
|
Symbol = symbol;
|
|
this.pricingDate=DateTime.Now;
|
|
this.startDate=startDate;
|
|
ResetEvent = resetEvent;
|
|
}
|
|
public DateTime PricingDate
|
|
{
|
|
get{return pricingDate;}
|
|
}
|
|
public DateTime? StartDate
|
|
{
|
|
get{return startDate;}
|
|
}
|
|
}
|
|
public class PricingMarketDataHelper
|
|
{
|
|
private static int MaxThreads = (int)ThreadHelperEnum.MaxThreads;
|
|
private static int WaitBetweenRequests=125;
|
|
private List<String> symbols;
|
|
private int currentIndex = 0;
|
|
|
|
public PricingMarketDataHelper()
|
|
{
|
|
}
|
|
public static Price RollPriceForward(String symbol)
|
|
{
|
|
try
|
|
{
|
|
DateGenerator dateGenerator=new DateGenerator();
|
|
DateTime latestDate=PremarketDA.GetLatestMarketDate();
|
|
if(Utility.IsEpoch(latestDate))return null;
|
|
Price latestPrice=PricingDA.GetPrice(symbol);
|
|
if(null==latestPrice)return null;
|
|
DateTime latestPriceDateSymbol=latestPrice.Date;
|
|
latestPrice.Date=latestDate;
|
|
PricingDA.InsertPrice(latestPrice);
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("{0} price rolled forward from {1} to {2}",symbol,latestPriceDateSymbol.ToShortDateString(),latestDate.ToShortDateString()));
|
|
return latestPrice;
|
|
}
|
|
catch(Exception exception)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Exception rolling price forward for {0}. Exception was {1}",symbol,exception.ToString()));
|
|
return null;
|
|
}
|
|
}
|
|
public bool UpdateLatestPriceAll()
|
|
{
|
|
Profiler profiler=new Profiler();
|
|
try
|
|
{
|
|
symbols = PricingDA.GetSymbols();
|
|
currentIndex=0;
|
|
while (true)
|
|
{
|
|
List<String> queueSymbols = GetQueueSymbols();
|
|
if (null == queueSymbols || 0 == queueSymbols.Count) break;
|
|
ManualResetEvent[] resetEvents = new ManualResetEvent[queueSymbols.Count];
|
|
for (int eventIndex = 0; eventIndex < resetEvents.Length; eventIndex++)
|
|
{
|
|
resetEvents[eventIndex] = new ManualResetEvent(false);
|
|
}
|
|
for (int index = 0; index < queueSymbols.Count; index++)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper = new PricingThreadHelper(queueSymbols[index],resetEvents[index]);
|
|
ThreadPool.QueueUserWorkItem(ThreadPoolCallbackUpdateLatestPriceAll, pricingThreadHelper);
|
|
try{Thread.Sleep(WaitBetweenRequests);}catch(Exception){;}
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"UpdateLatestPriceAll, waiting for queued items to complete.");
|
|
WaitHandle.WaitAll(resetEvents);
|
|
}
|
|
return true;
|
|
}
|
|
finally
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("[UpdateLatestPriceAll]End, total took {0}(ms)",profiler.End()));
|
|
}
|
|
}
|
|
public bool UpdatePricesBigCharts(DateTime? startDate=null) // get prices from BigCharts
|
|
{
|
|
Profiler profiler=new Profiler();
|
|
try
|
|
{
|
|
symbols = PricingDA.GetSymbols();
|
|
currentIndex=0;
|
|
if(null==startDate)startDate=DateTime.Now;
|
|
while (true)
|
|
{
|
|
List<String> queueSymbols = GetQueueSymbols();
|
|
if (null == queueSymbols || 0 == queueSymbols.Count) break;
|
|
ManualResetEvent[] resetEvents = new ManualResetEvent[queueSymbols.Count];
|
|
for (int eventIndex = 0; eventIndex < resetEvents.Length; eventIndex++)
|
|
{
|
|
resetEvents[eventIndex] = new ManualResetEvent(false);
|
|
}
|
|
for (int index = 0; index < queueSymbols.Count; index++)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper = new PricingThreadHelper(queueSymbols[index],startDate.Value,resetEvents[index]);
|
|
ThreadPool.QueueUserWorkItem(ThreadPoolCallbackUpdatePricesBigCharts, pricingThreadHelper);
|
|
try{Thread.Sleep(WaitBetweenRequests);}catch(Exception){;}
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"UpdatePricesBigCharts, waiting for queued items to complete.");
|
|
WaitHandle.WaitAll(resetEvents);
|
|
}
|
|
return true;
|
|
}
|
|
finally
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("[UpdatePricesBigCharts]End, total took {0}(ms)",profiler.End()));
|
|
}
|
|
}
|
|
public bool UpdatePricesYahoo(DateTime? startDate=null) // get prices from Yahoo
|
|
{
|
|
Profiler profiler=new Profiler();
|
|
try
|
|
{
|
|
symbols=PricingDA.GetSymbols();
|
|
currentIndex=0;
|
|
if(null==startDate) startDate=DateTime.Now;
|
|
while(true)
|
|
{
|
|
List<String> queueSymbols=GetQueueSymbols();
|
|
if(null==queueSymbols||0==queueSymbols.Count) break;
|
|
ManualResetEvent[] resetEvents=new ManualResetEvent[queueSymbols.Count];
|
|
for(int eventIndex=0;eventIndex<resetEvents.Length;eventIndex++)
|
|
{
|
|
resetEvents[eventIndex]=new ManualResetEvent(false);
|
|
}
|
|
for(int index=0;index<queueSymbols.Count;index++)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper=new PricingThreadHelper(queueSymbols[index],startDate.Value,resetEvents[index]);
|
|
ThreadPool.QueueUserWorkItem(ThreadPoolCallbackUpdatePricesYahoo,pricingThreadHelper);
|
|
try{Thread.Sleep(WaitBetweenRequests);}catch(Exception){;}
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"UpdatePricesYahoo, waiting for queued items to complete.");
|
|
WaitHandle.WaitAll(resetEvents);
|
|
}
|
|
return true;
|
|
}
|
|
finally
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("[UpdatePricesBigCharts]End, total took {0}(ms)",profiler.End()));
|
|
}
|
|
}
|
|
|
|
public bool UpdatePricesYahooSweep(DateTime? startDate = null) // get prices from Yahoo
|
|
{
|
|
Profiler profiler = new Profiler();
|
|
try
|
|
{
|
|
symbols = PricingDA.GetSymbols();
|
|
currentIndex = 0;
|
|
if (null == startDate) startDate = DateTime.Now;
|
|
while (true)
|
|
{
|
|
List<String> queueSymbols = GetQueueSymbols();
|
|
if (null == queueSymbols || 0 == queueSymbols.Count) break;
|
|
ManualResetEvent[] resetEvents = new ManualResetEvent[queueSymbols.Count];
|
|
for (int eventIndex = 0; eventIndex < resetEvents.Length; eventIndex++)
|
|
{
|
|
resetEvents[eventIndex] = new ManualResetEvent(false);
|
|
}
|
|
for (int index = 0; index < queueSymbols.Count; index++)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper = new PricingThreadHelper(queueSymbols[index], startDate.Value, resetEvents[index]);
|
|
ThreadPool.QueueUserWorkItem(ThreadPoolCallbackUpdatePricesYahooSweep, pricingThreadHelper);
|
|
try { Thread.Sleep(WaitBetweenRequests); } catch (Exception) {; }
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG, "UpdatePricesYahooSweep, waiting for queued items to complete.");
|
|
WaitHandle.WaitAll(resetEvents);
|
|
}
|
|
return true;
|
|
}
|
|
finally
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG, String.Format("[UpdatePricesYahooSweep]End, total took {0}(ms)", profiler.End()));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// UpdatePricesBarChartSweep - This feed is intended to supplement BigCharts nightly price feed in UPDATEDAILY2 by filling any gaps that may occur
|
|
/// in that feed. This feed will only pull a price for which we had a price yesterday (findprevbusinessday) and for which do not have
|
|
/// a price tonight. If BigCharts was successful then we can expect this method to retrieve nothing. If BigCharts fails to give us a price
|
|
/// tonight BUT did in fact give us a price yesterday then this method will attempt to rerieve that symbol from BarChart and insert that
|
|
/// price into the database with the appropriate date (tonight) and with the appropriate Source (BarChart).
|
|
/// </summary>
|
|
/// <param name="startDate"></param>
|
|
/// <returns></returns>
|
|
public bool UpdatePricesBarChartSweep(DateTime? startDate = null)
|
|
{
|
|
Profiler profiler = new Profiler();
|
|
try
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG, "[UpdatePricesBarChartSweep]Enter");
|
|
DateGenerator dateGenerator = new DateGenerator();
|
|
if (null == startDate) startDate = DateTime.Now;
|
|
startDate = dateGenerator.GetPrevBusinessDay(startDate.Value); // make sure we are given a valid business date
|
|
DateTime requiredDate = dateGenerator.FindPrevBusinessDay(startDate.Value); // now go and fetch yesterday (prev business day)
|
|
MDTrace.WriteLine(LogLevel.DEBUG, $"[UpdatePricesBarChartSweep] Determining what prices we need on {startDate.Value.ToShortDateString()} by examing what prices we had on {requiredDate.ToShortDateString()}");
|
|
MDTrace.WriteLine(LogLevel.DEBUG, $"[UpdatePricesBarChartSweep] Retrieve universe of symbols...");
|
|
symbols = PricingDA.GetSymbols(); // get the list of symbols in the universe
|
|
MDTrace.WriteLine(LogLevel.DEBUG, $"[UpdatePricesBarChartSweep] Retrieve latest dates...");
|
|
Dictionary<String, DateTime> latestDates = PricingDA.GetLatestDates(symbols); // get the latest pricing date for these symbols
|
|
List<String> symbolsToFetch = new List<String>();
|
|
List<String> keys = latestDates.Keys.ToList();
|
|
MDTrace.WriteLine(LogLevel.DEBUG, $"[UpdatePricesBarChartSweep] Filtering...");
|
|
foreach (String key in keys) // go through the latest dates and select those for which
|
|
{ // we have a price on previous business date
|
|
if (latestDates[key].Date.Date.Equals(requiredDate.Date))
|
|
{
|
|
symbolsToFetch.Add(key);
|
|
}
|
|
}
|
|
symbols = symbolsToFetch; // These are the symbols that we know we need to fetch
|
|
if (0 == symbolsToFetch.Count)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG, $"[UpdatePricesBarChartSweep] Does not need to supplement any pricing data for {startDate.Value.ToShortDateString()} .");
|
|
}
|
|
currentIndex = 0;
|
|
while (true)
|
|
{
|
|
List<String> queueSymbols = GetQueueSymbols();
|
|
if (null == queueSymbols || 0 == queueSymbols.Count) break;
|
|
ManualResetEvent[] resetEvents = new ManualResetEvent[queueSymbols.Count];
|
|
for (int eventIndex = 0; eventIndex < resetEvents.Length; eventIndex++)
|
|
{
|
|
resetEvents[eventIndex] = new ManualResetEvent(false);
|
|
}
|
|
for (int index = 0; index < queueSymbols.Count; index++)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper = new PricingThreadHelper(queueSymbols[index], startDate.Value, resetEvents[index]);
|
|
ThreadPool.QueueUserWorkItem(ThreadPoolCallbackUpdatePricesBarChartSweep, pricingThreadHelper);
|
|
try { Thread.Sleep(WaitBetweenRequests); } catch (Exception) {; }
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG, "UpdatePricesBarChartSweep, waiting for queued items to complete.");
|
|
WaitHandle.WaitAll(resetEvents);
|
|
}
|
|
return true;
|
|
}
|
|
finally
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG, String.Format("[UpdatePricesBarChartSweep]End, total took {0}(ms)", profiler.End()));
|
|
}
|
|
}
|
|
|
|
public bool UpdatePricesAsOfSymbol(String symbol, DateTime asOf) // get prices from BigCharts
|
|
{
|
|
Profiler profiler = new Profiler();
|
|
try
|
|
{
|
|
symbols = new List<String>();
|
|
symbols.Add(symbol);
|
|
currentIndex = 0;
|
|
while (true)
|
|
{
|
|
List<String> queueSymbols = GetQueueSymbols();
|
|
if (null == queueSymbols || 0 == queueSymbols.Count) break;
|
|
ManualResetEvent[] resetEvents = new ManualResetEvent[queueSymbols.Count];
|
|
for (int eventIndex = 0; eventIndex < resetEvents.Length; eventIndex++)
|
|
{
|
|
resetEvents[eventIndex] = new ManualResetEvent(false);
|
|
}
|
|
for (int index = 0; index < queueSymbols.Count; index++)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper = new PricingThreadHelper(queueSymbols[index], resetEvents[index], asOf);
|
|
ThreadPool.QueueUserWorkItem(ThreadPoolCallbackUpdatePricesAsOf, pricingThreadHelper);
|
|
try { Thread.Sleep(WaitBetweenRequests); } catch (Exception) {; }
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG, "UpdatePricesAsOfSymbol, waiting for queued items to complete.");
|
|
WaitHandle.WaitAll(resetEvents);
|
|
}
|
|
return true;
|
|
}
|
|
finally
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG, String.Format("[UpdatePricesAsOfSymbol]End, total took {0}(ms)", profiler.End()));
|
|
}
|
|
}
|
|
public bool UpdatePriceAsOfSymbolYahoo(String symbol,DateTime asOf) // get prices from Yahoo
|
|
{
|
|
Profiler profiler=new Profiler();
|
|
try
|
|
{
|
|
symbols=new List<String>();
|
|
symbols.Add(symbol);
|
|
currentIndex=0;
|
|
while(true)
|
|
{
|
|
List<String> queueSymbols=GetQueueSymbols();
|
|
if(null==queueSymbols||0==queueSymbols.Count) break;
|
|
ManualResetEvent[] resetEvents=new ManualResetEvent[queueSymbols.Count];
|
|
for(int eventIndex=0;eventIndex<resetEvents.Length;eventIndex++)
|
|
{
|
|
resetEvents[eventIndex]=new ManualResetEvent(false);
|
|
}
|
|
for(int index=0;index<queueSymbols.Count;index++)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper=new PricingThreadHelper(queueSymbols[index],asOf,resetEvents[index]);
|
|
ThreadPool.QueueUserWorkItem(ThreadPoolCallbackUpdatePricesYahoo,pricingThreadHelper);
|
|
try{Thread.Sleep(WaitBetweenRequests);}catch(Exception){;}
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"UpdatePricesAsOfSymbol, waiting for queued items to complete.");
|
|
WaitHandle.WaitAll(resetEvents);
|
|
}
|
|
return true;
|
|
}
|
|
finally
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("[UpdatePricesAsOfSymbol]End, total took {0}(ms)",profiler.End()));
|
|
}
|
|
}
|
|
public bool UpdatePricesAsOf(DateTime asOf)
|
|
{
|
|
Profiler profiler=new Profiler();
|
|
try
|
|
{
|
|
symbols=PricingDA.GetSymbols();
|
|
currentIndex=0;
|
|
while (true)
|
|
{
|
|
List<String> queueSymbols = GetQueueSymbols();
|
|
if (null == queueSymbols || 0 == queueSymbols.Count) break;
|
|
ManualResetEvent[] resetEvents = new ManualResetEvent[queueSymbols.Count];
|
|
for (int eventIndex = 0; eventIndex < resetEvents.Length; eventIndex++)
|
|
{
|
|
resetEvents[eventIndex] = new ManualResetEvent(false);
|
|
}
|
|
for (int index = 0; index < queueSymbols.Count; index++)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper = new PricingThreadHelper(queueSymbols[index], resetEvents[index],asOf);
|
|
ThreadPool.QueueUserWorkItem(ThreadPoolCallbackUpdatePricesAsOf, pricingThreadHelper);
|
|
try{Thread.Sleep(WaitBetweenRequests);}catch(Exception){;}
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"UpdatePricesAsOf, waiting for queued items to complete.");
|
|
WaitHandle.WaitAll(resetEvents);
|
|
}
|
|
return true;
|
|
}
|
|
finally
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("[UpdatePricesAsOf]End, total took {0}(ms)",profiler.End()));
|
|
}
|
|
}
|
|
public bool GetMissingPricesSymbol(String symbol,DateTime? startDate=null)
|
|
{
|
|
Profiler profiler=new Profiler();
|
|
try
|
|
{
|
|
List<String> symbols=new List<String>();
|
|
symbols.Add(symbol);
|
|
this.symbols=symbols;
|
|
currentIndex = 0;
|
|
while (true)
|
|
{
|
|
List<String> queueSymbols = GetQueueSymbols();
|
|
if (null == queueSymbols || 0 == queueSymbols.Count) break;
|
|
ManualResetEvent[] resetEvents = new ManualResetEvent[queueSymbols.Count];
|
|
for (int eventIndex = 0; eventIndex < resetEvents.Length; eventIndex++)
|
|
{
|
|
resetEvents[eventIndex] = new ManualResetEvent(false);
|
|
}
|
|
for (int index = 0; index < queueSymbols.Count; index++)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper = new PricingThreadHelper(queueSymbols[index], resetEvents[index],startDate);
|
|
ThreadPool.QueueUserWorkItem(ThreadPoolCallbackGetMissingPrice, pricingThreadHelper);
|
|
try{Thread.Sleep(WaitBetweenRequests);}catch(Exception){;}
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"Get missing prices, waiting for queued items to complete.");
|
|
WaitHandle.WaitAll(resetEvents);
|
|
}
|
|
return true;
|
|
}
|
|
finally
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("[GetMissingPrices]End, total took {0}(ms)",profiler.End()));
|
|
}
|
|
}
|
|
public bool GetMissingPrices(DateTime? startDate=null)
|
|
{
|
|
Profiler profiler=new Profiler();
|
|
try
|
|
{
|
|
this.symbols=PricingDA.GetSymbols();
|
|
currentIndex = 0;
|
|
while (true)
|
|
{
|
|
List<String> queueSymbols = GetQueueSymbols();
|
|
if (null == queueSymbols || 0 == queueSymbols.Count) break;
|
|
ManualResetEvent[] resetEvents = new ManualResetEvent[queueSymbols.Count];
|
|
for (int eventIndex = 0; eventIndex < resetEvents.Length; eventIndex++)
|
|
{
|
|
resetEvents[eventIndex] = new ManualResetEvent(false);
|
|
}
|
|
for (int index = 0; index < queueSymbols.Count; index++)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper = new PricingThreadHelper(queueSymbols[index], resetEvents[index],startDate);
|
|
ThreadPool.QueueUserWorkItem(ThreadPoolCallbackGetMissingPrice, pricingThreadHelper);
|
|
try{Thread.Sleep(WaitBetweenRequests);}catch(Exception){;}
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"Get missing prices, waiting for queued items to complete.");
|
|
WaitHandle.WaitAll(resetEvents);
|
|
}
|
|
return true;
|
|
}
|
|
finally
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("[GetMissingPrices]End, total took {0}(ms)",profiler.End()));
|
|
}
|
|
}
|
|
|
|
public bool UpdateLatestPriceSymbol(String symbol)
|
|
{
|
|
List<String> symbols = new List<String>();
|
|
symbols.Add(symbol);
|
|
return UpdateLatestPrices(symbols);
|
|
}
|
|
|
|
public bool UpdateLatestPrices(List<String> symbols)
|
|
{
|
|
Profiler profiler = new Profiler();
|
|
try
|
|
{
|
|
DateTime pricingDate = DateTime.Now;
|
|
this.symbols = symbols;
|
|
currentIndex = 0;
|
|
while (true)
|
|
{
|
|
List<String> queueSymbols = GetQueueSymbols();
|
|
if (null == queueSymbols || 0 == queueSymbols.Count) break;
|
|
ManualResetEvent[] resetEvents = new ManualResetEvent[queueSymbols.Count];
|
|
for (int eventIndex = 0; eventIndex < resetEvents.Length; eventIndex++)
|
|
{
|
|
resetEvents[eventIndex] = new ManualResetEvent(false);
|
|
}
|
|
for (int index = 0; index < queueSymbols.Count; index++)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper = new PricingThreadHelper(queueSymbols[index], pricingDate, resetEvents[index]);
|
|
ThreadPool.QueueUserWorkItem(ThreadPoolCallbackUpdateLatestPrice, pricingThreadHelper);
|
|
try { Thread.Sleep(WaitBetweenRequests); } catch (Exception) {; }
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG, "Load prices, waiting for queued items to complete.");
|
|
WaitHandle.WaitAll(resetEvents);
|
|
}
|
|
return true;
|
|
}
|
|
finally
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG, String.Format("[UpdateLatestPrices]End, total took {0}(ms)", profiler.End()));
|
|
}
|
|
}
|
|
public bool LoadPrices(List<String> symbols)
|
|
{
|
|
Profiler profiler=new Profiler();
|
|
try
|
|
{
|
|
DateTime pricingDate=DateTime.Now;
|
|
this.symbols = symbols;
|
|
currentIndex = 0;
|
|
while (true)
|
|
{
|
|
List<String> queueSymbols = GetQueueSymbols();
|
|
if (null == queueSymbols || 0 == queueSymbols.Count) break;
|
|
ManualResetEvent[] resetEvents = new ManualResetEvent[queueSymbols.Count];
|
|
for (int eventIndex = 0; eventIndex < resetEvents.Length; eventIndex++)
|
|
{
|
|
resetEvents[eventIndex] = new ManualResetEvent(false);
|
|
}
|
|
for (int index = 0; index < queueSymbols.Count; index++)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper = new PricingThreadHelper(queueSymbols[index], pricingDate,resetEvents[index]);
|
|
ThreadPool.QueueUserWorkItem(ThreadPoolCallbackLoadPrices, pricingThreadHelper);
|
|
try{Thread.Sleep(WaitBetweenRequests);}catch(Exception){;}
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"Load prices, waiting for queued items to complete.");
|
|
WaitHandle.WaitAll(resetEvents);
|
|
}
|
|
return true;
|
|
}
|
|
finally
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("[LoadPrices]End, total took {0}(ms)",profiler.End()));
|
|
}
|
|
}
|
|
// ************************************************************************************************************************************
|
|
// *************************************************** T H R E A D P O O L C A L L B A C K ******************************************
|
|
// ************************************************************************************************************************************
|
|
public void ThreadPoolCallbackUpdateLatestPriceAll(Object pricingThreadHelperContext)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper = (PricingThreadHelper)pricingThreadHelperContext;
|
|
try
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("UpdateLatestPriceAll, Thread {0} started for {1}...", Thread.CurrentThread.ManagedThreadId, pricingThreadHelper.Symbol));
|
|
UpdateLatestPriceAllEx(pricingThreadHelper.Symbol);
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("UpdateLatestPriceAll, Thread {0} ended for {1}", Thread.CurrentThread.ManagedThreadId, pricingThreadHelper.Symbol));
|
|
}
|
|
finally
|
|
{
|
|
pricingThreadHelper.ResetEvent.Set();
|
|
}
|
|
}
|
|
public void ThreadPoolCallbackUpdatePricesBigCharts(Object pricingThreadHelperContext)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper = (PricingThreadHelper)pricingThreadHelperContext;
|
|
try
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Load price (BigCharts), Thread {0} started for {1}...", Thread.CurrentThread.ManagedThreadId, pricingThreadHelper.Symbol));
|
|
UpdatePriceBigChartsEx(pricingThreadHelper.Symbol,pricingThreadHelper.PricingDate);
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Load price (BigCharts), Thread {0} ended for {1}", Thread.CurrentThread.ManagedThreadId, pricingThreadHelper.Symbol));
|
|
}
|
|
finally
|
|
{
|
|
pricingThreadHelper.ResetEvent.Set();
|
|
}
|
|
}
|
|
public void ThreadPoolCallbackUpdatePricesYahoo(Object pricingThreadHelperContext)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper=(PricingThreadHelper)pricingThreadHelperContext;
|
|
try
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Load price (Yahoo), Thread {0} started for {1}...",Thread.CurrentThread.ManagedThreadId,pricingThreadHelper.Symbol));
|
|
UpdatePriceYahoo(pricingThreadHelper.Symbol,pricingThreadHelper.PricingDate);
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Load price (Yahoo), Thread {0} ended for {1}",Thread.CurrentThread.ManagedThreadId,pricingThreadHelper.Symbol));
|
|
}
|
|
finally
|
|
{
|
|
pricingThreadHelper.ResetEvent.Set();
|
|
}
|
|
}
|
|
public void ThreadPoolCallbackUpdatePricesYahooSweep(Object pricingThreadHelperContext)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper=(PricingThreadHelper)pricingThreadHelperContext;
|
|
try
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Load price (Yahoo), Thread {0} started for {1}...",Thread.CurrentThread.ManagedThreadId,pricingThreadHelper.Symbol));
|
|
UpdatePriceYahooSweep(pricingThreadHelper.Symbol,pricingThreadHelper.PricingDate);
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Load price (Yahoo), Thread {0} ended for {1}",Thread.CurrentThread.ManagedThreadId,pricingThreadHelper.Symbol));
|
|
}
|
|
finally
|
|
{
|
|
pricingThreadHelper.ResetEvent.Set();
|
|
}
|
|
}
|
|
public void ThreadPoolCallbackUpdatePricesBarChartSweep(Object pricingThreadHelperContext)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper=(PricingThreadHelper)pricingThreadHelperContext;
|
|
try
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Load price (BarChart), Thread {0} started for {1}...",Thread.CurrentThread.ManagedThreadId,pricingThreadHelper.Symbol));
|
|
UpdatePriceBarChartSweep(pricingThreadHelper.Symbol,pricingThreadHelper.PricingDate);
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Load price (BarChart), Thread {0} ended for {1}",Thread.CurrentThread.ManagedThreadId,pricingThreadHelper.Symbol));
|
|
}
|
|
finally
|
|
{
|
|
pricingThreadHelper.ResetEvent.Set();
|
|
}
|
|
}
|
|
public void ThreadPoolCallbackUpdatePricesAsOf(Object pricingThreadHelperContext)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper = (PricingThreadHelper)pricingThreadHelperContext;
|
|
try
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG, String.Format("Load price, Thread {0} started for {1}...", Thread.CurrentThread.ManagedThreadId, pricingThreadHelper.Symbol));
|
|
UpdatePriceAsOfEx(pricingThreadHelper.Symbol, pricingThreadHelper.StartDate.Value);
|
|
MDTrace.WriteLine(LogLevel.DEBUG, String.Format("Load price, Thread {0} ended for {1}", Thread.CurrentThread.ManagedThreadId, pricingThreadHelper.Symbol));
|
|
}
|
|
finally
|
|
{
|
|
pricingThreadHelper.ResetEvent.Set();
|
|
}
|
|
}
|
|
public void ThreadPoolCallbackGetMissingPrice(Object pricingThreadHelperContext)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper = (PricingThreadHelper)pricingThreadHelperContext;
|
|
try
|
|
{
|
|
GetMissingPricesEx(pricingThreadHelper.Symbol,pricingThreadHelper.StartDate==null?new DateTime():pricingThreadHelper.StartDate.Value);
|
|
}
|
|
finally
|
|
{
|
|
pricingThreadHelper.ResetEvent.Set();
|
|
}
|
|
}
|
|
public void ThreadPoolCallbackUpdateLatestPrice(Object pricingThreadHelperContext)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper = (PricingThreadHelper)pricingThreadHelperContext;
|
|
try
|
|
{
|
|
Price latestPrice = MarketDataHelper.GetLatestPrice(pricingThreadHelper.Symbol);
|
|
if (null == latestPrice)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("***** Error retrieving latest price for {0} *****",pricingThreadHelper.Symbol));
|
|
return;
|
|
}
|
|
|
|
MDTrace.WriteLine(LogLevel.DEBUG,Price.Header);
|
|
MDTrace.WriteLine(LogLevel.DEBUG,latestPrice.ToString());
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"Removing price for '"+pricingThreadHelper.Symbol+"' on "+Utility.DateTimeToStringMMSDDSYYYY(latestPrice.Date));
|
|
PricingDA.DeletePrice(pricingThreadHelper.Symbol,latestPrice.Date);
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"Adding price for '" + pricingThreadHelper.Symbol + "' on " + Utility.DateTimeToStringMMSDDSYYYY(latestPrice.Date));
|
|
PricingDA.InsertPrice(latestPrice);
|
|
}
|
|
finally
|
|
{
|
|
pricingThreadHelper.ResetEvent.Set();
|
|
}
|
|
}
|
|
public void ThreadPoolCallbackLoadPrices(Object pricingThreadHelperContext)
|
|
{
|
|
PricingThreadHelper pricingThreadHelper = (PricingThreadHelper)pricingThreadHelperContext;
|
|
try
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Load price, Thread {0} started for {1}...", Thread.CurrentThread.ManagedThreadId, pricingThreadHelper.Symbol));
|
|
LoadPricesSymbolEx(pricingThreadHelper.Symbol,pricingThreadHelper.PricingDate);
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Load price, Thread {0} ended for {1}", Thread.CurrentThread.ManagedThreadId, pricingThreadHelper.Symbol));
|
|
}
|
|
finally
|
|
{
|
|
pricingThreadHelper.ResetEvent.Set();
|
|
}
|
|
}
|
|
// ****************************************************************************************************************************************
|
|
// ****************************************************************************************************************************************
|
|
// ****************************************************************************************************************************************
|
|
private List<String> GetQueueSymbols()
|
|
{
|
|
List<String> queueSymbols = new List<String>();
|
|
int index = currentIndex;
|
|
for (; index < currentIndex + MaxThreads && index < symbols.Count; index++)
|
|
{
|
|
queueSymbols.Add(symbols[index]);
|
|
}
|
|
currentIndex = index;
|
|
return queueSymbols;
|
|
}
|
|
// ********************************************************************************************************************************************
|
|
// ************************************************************ W O R K E R S *****************************************************************
|
|
// ********************************************************************************************************************************************
|
|
public static void GetMissingPricesEx(String symbol,DateTime startDate)
|
|
{
|
|
try
|
|
{
|
|
DateGenerator dateGenerator=new DateGenerator();
|
|
TimeSpan oneDay=new TimeSpan(1,0,0,0);
|
|
DateTime? historicalDate = null;
|
|
DateTime minDate=Constants.MIN_PRICING_DATE;
|
|
|
|
List<DateTime> pricingDatesList = PricingDA.GetPricingDatesForSymbol(symbol);
|
|
if (null == pricingDatesList || 0 == pricingDatesList.Count) return;
|
|
pricingDatesList=pricingDatesList.Where(x => x.Date>=minDate.Date).ToList();
|
|
if(null==pricingDatesList||0==pricingDatesList.Count) return;
|
|
DateTime beginDate = pricingDatesList[0];
|
|
DateTime endDate = pricingDatesList[pricingDatesList.Count - 1];
|
|
Dictionary<DateTime, DateTime> pricingDates = new Dictionary<DateTime, DateTime>();
|
|
for (int listIndex = 0; listIndex < pricingDatesList.Count; listIndex++)
|
|
{
|
|
DateTime pricingDate=pricingDatesList[listIndex];
|
|
pricingDates.Add(pricingDate.Date, pricingDate.Date);
|
|
}
|
|
Dictionary<DateTime, Price> marketPrices = new Dictionary<DateTime, Price>();
|
|
if (Utility.IsEpoch(startDate)) historicalDate = beginDate;
|
|
else historicalDate = startDate;
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"Working on '" + symbol + "' from "+Utility.DateTimeToStringMMHDDHYYYY(historicalDate.Value)+" to "+Utility.DateTimeToStringMMHDDHYYYY(endDate));
|
|
Prices prices = MarketDataHelper.GetDailyPrices(symbol, historicalDate.Value, endDate); // yahoo finance
|
|
if(null==prices||0==prices.Count)prices=MarketDataHelper.GetPricesAsOf(symbol,historicalDate.Value,endDate); // try big charts
|
|
if (null == prices||0==prices.Count)return;
|
|
for (int listIndex = 0; listIndex < prices.Count; listIndex++)
|
|
{
|
|
Price price = prices[listIndex];
|
|
if(!marketPrices.ContainsKey(price.Date.Date))marketPrices.Add(price.Date,price);
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Retrieved {0} prices from feed for {1}",prices.Count,symbol));
|
|
bool added=false;
|
|
for (DateTime date = historicalDate.Value.Date; date < endDate.Date; date += oneDay)
|
|
{
|
|
if (pricingDates.ContainsKey(date.Date)) continue;
|
|
if (dateGenerator.IsWeekend(date)) continue;
|
|
Price price = null;
|
|
if (!marketPrices.ContainsKey(date.Date))continue;
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Inserting price {0}...",price.ToString()));
|
|
price = marketPrices[date.Date];
|
|
MDTrace.WriteLine(LogLevel.DEBUG,price.ToString());
|
|
PricingDA.InsertPrice(price);
|
|
added=true;
|
|
}
|
|
if(!added)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"There were no new prices to add for '" + symbol);
|
|
}
|
|
}
|
|
catch(Exception exception)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Exception {0}",exception.ToString()));
|
|
}
|
|
}
|
|
public static void UpdateLatestPriceAllEx(String symbol)
|
|
{
|
|
try
|
|
{
|
|
symbol = symbol.ToUpper();
|
|
Price latestPrice = MarketDataHelper.GetLatestPrice(symbol);
|
|
if (null == latestPrice)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"Error retrieving latest price.");
|
|
return;
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG,Price.Header);
|
|
MDTrace.WriteLine(LogLevel.DEBUG,latestPrice.ToString());
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"Removing price for '" + symbol + "' on " + Utility.DateTimeToStringMMSDDSYYYY(latestPrice.Date));
|
|
PricingDA.DeletePrice(symbol, latestPrice.Date);
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Inserting price {0}...",latestPrice.ToString()));
|
|
PricingDA.InsertPrice(latestPrice);
|
|
}
|
|
catch(Exception exception)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,exception.ToString());
|
|
}
|
|
}
|
|
public static void UpdatePriceBigChartsEx(String symbol,DateTime pricingDate)
|
|
{
|
|
try
|
|
{
|
|
Price price=PricingDA.GetPrice(symbol,pricingDate);
|
|
if(null!=price)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"Already have latest price for '" + symbol + "'");
|
|
return;
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Requesting price for {0} for start date:{1} end date:{2}",symbol,pricingDate,pricingDate));
|
|
Prices prices = MarketDataHelper.GetPricesAsOf(symbol, pricingDate,pricingDate);
|
|
if (null == prices||0==prices.Count)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"No prices (GetPricesAsOf) for '" + symbol+ "'");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
for (int secIndex = 0; secIndex < prices.Count; secIndex++)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,prices[secIndex].ToString());
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"Inserting....");
|
|
PricingDA.InsertPrices(prices);
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"Done.");
|
|
}
|
|
}
|
|
catch(Exception exception)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Exception {0}",exception.ToString()));
|
|
}
|
|
}
|
|
public static void UpdatePriceYahoo(String symbol,DateTime pricingDate)
|
|
{
|
|
try
|
|
{
|
|
Price price=PricingDA.GetPrice(symbol,pricingDate);
|
|
if(null!=price)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"Already have latest price for '"+symbol+"'");
|
|
return;
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Requesting price for {0} for start date:{1} end date:{2}",symbol,pricingDate,pricingDate));
|
|
price=MarketDataHelper.GetDailyPrice(symbol,pricingDate);
|
|
if(null==price)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"No price (UpdatePriceYahoo) for '"+symbol+"'");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Inserting price {0}...",price.ToString()));
|
|
PricingDA.InsertPrice(price);
|
|
}
|
|
}
|
|
catch(Exception exception)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Exception {0}",exception.ToString()));
|
|
}
|
|
}
|
|
public static void UpdatePriceYahooSweep(String symbol,DateTime pricingDate)
|
|
{
|
|
try
|
|
{
|
|
CompanyProfile companyProfile=CompanyProfileDA.GetCompanyProfile(symbol);
|
|
Price price=PricingDA.GetPrice(symbol,pricingDate);
|
|
if(null!=price)
|
|
{
|
|
if(companyProfile==null || !companyProfile.PricingSourceEnum.Equals(CompanyProfile.EnumPricingSource.YAHOO))
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"Already have latest price for '"+symbol+"'");
|
|
return;
|
|
}
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("UpdatePriceYahooSweep: Requesting price for {0} for start date:{1} end date:{2}",symbol,pricingDate,pricingDate));
|
|
price=MarketDataHelper.GetDailyPrice(symbol,pricingDate);
|
|
if(null==price)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"No price (UpdatePriceYahooSweep) for '"+symbol+"'");
|
|
return;
|
|
}
|
|
else if(!price.IsValid)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"Invalid price (UpdatePriceYahooSweep) for '"+symbol+"'");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Inserting price {0}...",price.ToString()));
|
|
PricingDA.InsertPrice(price);
|
|
}
|
|
}
|
|
catch(Exception exception)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Exception {0}",exception.ToString()));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// This feed is intended to supplement BigCharts and Yahoo feed.
|
|
/// It should run in the UPDATEDAILY2 chain after Yahoo during the nightly price capture.
|
|
/// It will only retrieve price for the current date AND it expects us to have a price for the previous business date.
|
|
/// In other words it will not fill pricing gaps, it will only add "tonights" price to an already established pricing history
|
|
/// and only if we are missing a price. See the method UpdatePricesBarChartSweep to understand the context.
|
|
/// </summary>
|
|
/// <param name="symbol"></param>
|
|
/// <param name="pricingDate"></param>
|
|
public static void UpdatePriceBarChartSweep(String symbol, DateTime pricingDate)
|
|
{
|
|
try
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG, String.Format("UpdatePriceBarChartSweep: Requesting latest price for {0} ", symbol));
|
|
Price price = MarketDataHelper.GetLatestPriceBarChart(symbol);
|
|
if (null == price)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG, "(UpdatePriceBarChartSweep) No price for '" + symbol + "'");
|
|
return;
|
|
}
|
|
else if (!price.IsValid)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG, "(UpdatePriceBarChartSweep) Invalid price for '" + symbol + "'");
|
|
return;
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG, String.Format("(UpdatePriceBarChartSweep) Inserting price {0}...", price.ToString()));
|
|
PricingDA.InsertPrice(price);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG, String.Format("(UpdatePriceBarChartSweep) Exception {0}", exception.ToString()));
|
|
}
|
|
}
|
|
|
|
public static void UpdatePriceAsOfEx(String symbol, DateTime asOf)
|
|
{
|
|
try
|
|
{
|
|
DateTime latestDate = PricingDA.GetLatestDate(symbol);
|
|
MDTrace.WriteLine(LogLevel.DEBUG, String.Format("Latest pricing date for {0} is {1}", symbol, latestDate.ToShortDateString()));
|
|
if (latestDate.Equals(asOf))
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG, "Already have price for '" + symbol + "' on " + Utility.DateTimeToStringMMHDDHYYYY(asOf));
|
|
return;
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG, String.Format("Retrieving price for {0} on {1} from BigCharts", symbol, asOf.ToShortDateString()));
|
|
Price price = MarketDataHelper.GetPriceAsOf(symbol, asOf);
|
|
if (null == price)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG, String.Format("Error retrieving price for {0} on {1}", symbol, asOf.ToShortDateString()));
|
|
return;
|
|
}
|
|
MDTrace.WriteLine(LogLevel.DEBUG, Price.Header);
|
|
MDTrace.WriteLine(LogLevel.DEBUG, price.ToString());
|
|
MDTrace.WriteLine(LogLevel.DEBUG, String.Format("Inserting price {0}...", price.ToString()));
|
|
PricingDA.InsertPrice(price);
|
|
MDTrace.WriteLine(LogLevel.DEBUG, "");
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG, exception.ToString());
|
|
}
|
|
}
|
|
|
|
public static void LoadPricesSymbolEx(String symbol,DateTime pricingDate)
|
|
{
|
|
DateGenerator dateGenerator = new DateGenerator();
|
|
DateTime startDate = pricingDate; // the least recent date
|
|
DateTime endDate = pricingDate; // the most recent date
|
|
endDate = dateGenerator.GetPrevBusinessDay(endDate);
|
|
startDate = PricingDA.GetLatestDate(symbol);
|
|
startDate = dateGenerator.FindNextBusinessDay(startDate);
|
|
if (startDate.Date > endDate.Date)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"Already have latest price for '" + symbol + "'");
|
|
return;
|
|
}
|
|
Prices prices=MarketDataHelper.GetPricesAsOf(symbol,startDate,endDate);
|
|
if (null == prices||0==prices.Count)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"No prices (GetDailyPrices) for '" + symbol + "'");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
for (int secIndex = 0; secIndex < prices.Count; secIndex++)
|
|
{
|
|
MDTrace.WriteLine(LogLevel.DEBUG,prices[secIndex].ToString());
|
|
}
|
|
PricingDA.InsertPrices(prices);
|
|
MDTrace.WriteLine(LogLevel.DEBUG,"Done.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|