}//HubEventHandler()
//
//
//
// *************************************************************************
// *** Process Request ****
// *************************************************************************
/// <summary>
/// These are request for fill hub resources. Some can not be completed yet, and these
/// will be stored in a Queue for retrying later.
/// </summary>
private void ProcessAuditTrailEvent(AuditTrailEventArgs eventArg)
{
if (eventArg == null)
{
return;
}
if (eventArg.auditTrailEventType == AuditTrailEventType.LoadAuditTrailFills)
{
if (m_Listener != null)
{
// It does not need the TT to start fill listening.
m_IsInitializingBooks = false;
Log.NewEntry(LogLevel.Minor, "Connected to audit trail file.");
m_Listener.Filled += new EventHandler(HubEventEnqueue);
AuditTrailPlayer auditTrailReader = (AuditTrailPlayer)eventArg.Data[0];
AuditTrailFillHub auditTrailFillHub = (AuditTrailFillHub)eventArg.Data[1];
DateTime auditTrailReadingStartDateTime = (DateTime)eventArg.Data[2];
DateTime auditTrailPlayingEndDateTime = (DateTime)eventArg.Data[3];
LogHub log = (LogHub)eventArg.Data[4];
m_Listener.Log = log;
// Get the variables from GUI thread to load audit trail fills and update initial state of fill hub.
if (auditTrailReader.TryReadAuditTrailFills(auditTrailReadingStartDateTime, auditTrailPlayingEndDateTime, auditTrailFillHub))
{
m_NeededCheckKeys.Clear();
m_NeededCheckKeys.AddRange(auditTrailReader.m_NeededBookInstrumentList);
Log.NewEntry(LogLevel.Minor, "Successfully load fills from audit trail file.");
}
else
{
Log.NewEntry(LogLevel.Major, "Failed to load fills from audit trail file.");
return;
}
}
}
else if (eventArg.auditTrailEventType == AuditTrailEventType.PlayAuditTrailFills)
{
AuditTrailPlayer auditTrailReader = (AuditTrailPlayer)eventArg.Data[0];
AuditTrailFillHub auditTrailFillHub = (AuditTrailFillHub)eventArg.Data[1];
DateTime auditTrailReadingStartDateTime = (DateTime)eventArg.Data[2];
DateTime auditTrailPlayingEndDateTime = (DateTime)eventArg.Data[3];
LogHub log = (LogHub)eventArg.Data[4];
// Get the variables from GUI thread to play the audit trail fills.
if (auditTrailReader.TryPlayAuditTrailFillsForFillHub(auditTrailFillHub, auditTrailReadingStartDateTime, auditTrailPlayingEndDateTime, out auditTrailFillHub))
{
Log.NewEntry(LogLevel.Minor, "Successful in playing the audit trail file.");
}
else
{
Log.NewEntry(LogLevel.Major, "Failed to play the audit trail file.");
return;
}
}
}// ProcessRequest()
}//buttonExit_Click()
/// <summary>
/// Form closing event.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void AmbreRecoveryViewer_Closing(object sender, FormClosingEventArgs e)
{
// Exit.
this.FormClosing -= new FormClosingEventHandler(AmbreRecoveryViewer_Closing);
// Delete the files we copied.
if (m_RepoFileList.Count > 0)
{
try
{
foreach (string filePath in m_RepoFileList)
{
System.IO.File.Delete(filePath);
}
}
catch (Exception ex)
{
Log.NewEntry(LogLevel.Major, "Failed to delete copied files and the error is {0}.", ex);
}
}
// Shut down the fill hub.
if (m_AuditTrailFillHub != null)
{
m_AuditTrailFillHub.RequestSubstractEventHandler();
m_AuditTrailFillHub.RequestStop();
m_AuditTrailFillHub = null;
}
// Shut down the services.
if (m_MarketTTAPIService != null)
{
m_MarketTTAPIService.RequestStop();
m_MarketTTAPIService = null;
}
if (m_TTAPIService != null)
{
m_TTAPIService.ServiceStateChanged -= new EventHandler(TTAPIService_ServiceStateChanged);
m_TTAPIService.RequestStop();
m_TTAPIService = null;
}
// Shut down the log.
if (Log != null)
{
Log.NewEntry(LogLevel.Minor, "The form is closing.");
Log.Flush();
Log.RequestStop();
Log = null;
}
}//Form_Closing()
// *****************************************************************
// **** Properties ****
// *****************************************************************
//
//
#endregion//Properties
#region Public Methods
// *****************************************************************
// **** Public Methods ****
// *****************************************************************
//
//
//
//
//
//
/// <summary>
/// This function reads all lines in the audit trail file, generating fill event args and store them.
/// In addition to that, it also collect the last most recent fill information and update the position for the next step.
/// </summary>
/// <param name="startDateTime"></param>
/// <param name="endDateTime"></param>
/// <returns></returns>
public bool TryReadAuditTrailFills(DateTime startDateTime, DateTime endDateTime, AuditTrailFillHub auditTrailFillHub)
{
// This method will load the audit trail fills from TT given start and end date time automatically.
// The results will be added to the audit trail fills dictionary.
// It will also construct the fill hub name by user dictionary.
// Get the target audit trail files to read. The file name format is AuditLog_yyyy-mm-dd_N.
DateTime startDate;
DateTime endDate;
startDate = startDateTime.Subtract(startDateTime.TimeOfDay);
while (startDate.DayOfWeek == DayOfWeek.Saturday || startDate.DayOfWeek == DayOfWeek.Sunday)
{
startDate = startDate.AddDays(-1);
}
endDate = endDateTime.Subtract(endDateTime.TimeOfDay).AddDays(1);
while (endDate.DayOfWeek == DayOfWeek.Saturday || endDate.DayOfWeek == DayOfWeek.Sunday)
{
endDate = endDate.AddDays(1);
}
if (!System.IO.Directory.Exists(m_AuditTrailPath))
{
System.IO.Directory.CreateDirectory(m_AuditTrailPath);
}
string pattern = "AuditLog*.mdb";
List <string> fileList = new List <string>();
List <string> targetFileList = new List <string>();
List <string> targetTableList = new List <string>();
List <DateTime> targetDateList = new List <DateTime>();
fileList.AddRange(System.IO.Directory.GetFiles(m_AuditTrailPath, pattern));
int dateDelimiterStart;
int dateDelimiterEnd;
DateTime fileDate = DateTime.MinValue;
string fileDateString;
// Loop through the file collection and choose the desired files.
foreach (string fileName in fileList)
{
dateDelimiterEnd = fileName.LastIndexOf("_");
dateDelimiterStart = fileName.LastIndexOf("_", dateDelimiterEnd - 1);
if (dateDelimiterStart < fileName.Length && dateDelimiterEnd < fileName.Length)
{
fileDateString = fileName.Substring(dateDelimiterStart + 1, dateDelimiterEnd - dateDelimiterStart - 1);
if (DateTime.TryParseExact(fileDateString, "yyyy-MM-dd", null, System.Globalization.DateTimeStyles.None, out fileDate))
{
if (startDate <= fileDate && fileDate <= endDate)
{
Log.NewEntry(LogLevel.Minor, "Include the file name:{0}.", fileName);
targetFileList.Add(fileName);
targetTableList.Add(fileDate.ToString("MMMdd"));
targetDateList.Add(fileDate);
}
else
{
Log.NewEntry(LogLevel.Major, "Exclude the file name:{0}.", fileName);
continue;
}
}
else
{
Log.NewEntry(LogLevel.Major, "There is problem in parsing file date string:{0}.", fileDateString);
continue;
}
}
else
{
Log.NewEntry(LogLevel.Major, "There is problem in parsing file name:{0}.", fileName);
continue;
}
}
// Build the connections and load data from the file collection.
m_FillEventArgsList.Clear();
bool isBadRow;
List <InstrumentKey> instrumentKeyList = new List <InstrumentKey>();
bool readAllFillAccounts = false;
if (auditTrailFillHub.HubName == string.Empty)
{
readAllFillAccounts = true;
}
for (int fileIndex = 0; fileIndex < targetFileList.Count; ++fileIndex)
{
// Read from the audit file.
List <List <object> > dataCollections = new List <List <object> >();
if (AccessReader.TryReadAccessFile(targetFileList[fileIndex], targetTableList[fileIndex], out dataCollections))
{
// Get the information from the output. All the values are in object type.
int rowNumber = dataCollections.Count;
for (int rowIndex = 0; rowIndex < rowNumber; ++rowIndex)
{
isBadRow = false;
// The valid data types are explored in detail by test program.
string localTimeStamp = (string)dataCollections[rowIndex][ObjectListSchema.LocalTimeStamp];
string exchangeName = (string)dataCollections[rowIndex][ObjectListSchema.ExchangeName];
string orderStatus = (string)dataCollections[rowIndex][ObjectListSchema.OrderStatus];
string orderAction = (string)dataCollections[rowIndex][ObjectListSchema.OrderAction];
string orderSide = (string)dataCollections[rowIndex][ObjectListSchema.OrderSide];
int orderQty = (int)dataCollections[rowIndex][ObjectListSchema.OrderQty];
string product = (string)dataCollections[rowIndex][ObjectListSchema.Product];
string contract = (string)dataCollections[rowIndex][ObjectListSchema.Contract];
string orderPrice = (string)dataCollections[rowIndex][ObjectListSchema.OrderPrice];
string accountName = (string)dataCollections[rowIndex][ObjectListSchema.AccountName];
string userName = (string)dataCollections[rowIndex][ObjectListSchema.UserName];
string exchangeTime = (string)dataCollections[rowIndex][ObjectListSchema.ExchangeTime];
string exchangeDate = (string)dataCollections[rowIndex][ObjectListSchema.ExchangeDate];
string tradeSource = (string)dataCollections[rowIndex][ObjectListSchema.TradeSource];
string ttOrderKey = (string)dataCollections[rowIndex][ObjectListSchema.TTOrderKey];
string ttSeriesKey = (string)dataCollections[rowIndex][ObjectListSchema.TTSeriesKey];
// Check whether the account is desired.
if (!readAllFillAccounts && !accountName.Equals(m_FillHubName))
{
continue;
}
// Check whether the exchange name includes AlgoSE sub string.
if (exchangeName.Contains(m_ExchangeName_AlgoSE))
{
continue;
}
// Check whether it is a fill event.
if (!orderAction.Equals(m_Action_Fill) && !orderAction.Equals(m_Action_PartialFill))
{
continue;
}
// Check whether it is a OK status.
if (!orderStatus.Equals(m_OrderStatus_OK))
{
continue;
}
// Check whether the product type is future.
if (product.Equals(m_Product_AutoSpreader))
{
continue;
}
// Check whether the contract string contains Calendar string to avoid duplicate fills.
foreach (string specialString in m_Contract_Special)
{
if (contract.Contains(specialString))
{
isBadRow = true;
if (exchangeName.Contains("TOCOM") && specialString.Equals("/") && isBadRow)
{
isBadRow = false;
}
break;
}
}
if (isBadRow)
{
continue;
}
// Try parse some necessary variables.
DateTime localDateTimeValid = DateTime.MinValue;
DateTime exchangeTimeValid = DateTime.MinValue;
DateTime exchangeDateValid = DateTime.MinValue;
double fillPrice = double.NaN;
if (!DateTime.TryParseExact(localTimeStamp, "HH:mm:ss.fff", null, System.Globalization.DateTimeStyles.None, out localDateTimeValid))
{
Log.NewEntry(LogLevel.Major, "Failed to parse the utc time of {0}.", localTimeStamp);
continue;
}
if (!DateTime.TryParseExact(exchangeTime, "HH:mm:ss.fff", null, System.Globalization.DateTimeStyles.None, out exchangeTimeValid))
{
Log.NewEntry(LogLevel.Major, "Failed to parse the exchange time of {0}.", exchangeTime);
continue;
}
if (!DateTime.TryParseExact(exchangeDate, "ddMMMyy", System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.None, out exchangeDateValid))
{
Log.NewEntry(LogLevel.Major, "Failed to parse the exchange time of {0}.", exchangeDate);
continue;
}
if (!double.TryParse(orderPrice, out fillPrice))
{
Log.NewEntry(LogLevel.Major, "Failed to parse the order price of {0}.", orderPrice);
continue;
}
localDateTimeValid = targetDateList[fileIndex].Add(localDateTimeValid.TimeOfDay);
exchangeTimeValid = exchangeDateValid.Add(exchangeTimeValid.TimeOfDay);
// Edit the market.
int validEndIndex = exchangeName.LastIndexOf("-");
if (validEndIndex >= 0)
{
exchangeName = exchangeName.Substring(0, validEndIndex);
}
// Create fill.
Fill fill = new Fill();
fill.ExchangeTime = exchangeTimeValid;
//TimeZoneInfo localTimeZone = TimeZoneInfo.FindSystemTimeZoneById(m_LocalTimeZoneString);
//DateTime localDateTime = TimeZoneInfo.ConvertTimeFromUtc(localDateTimeValid, localTimeZone);
fill.LocalTime = localDateTimeValid;
fill.Price = fillPrice;
fill.Qty = orderSide.Equals(m_OrderSide_Buy) ? orderQty : (orderSide.Equals(m_OrderSide_Sell) ? -orderQty : 0);
// Create fill event args.
InstrumentKey instrumentKey = new InstrumentKey(exchangeName, TradingTechnologies.TTAPI.ProductType.Future, product, ttSeriesKey);
FillEventArgs fillEventArgs = new FillEventArgs();
fillEventArgs.Fill = fill;
fillEventArgs.AccountID = accountName;
//fillEventArgs.FillKey = ttOrderKey;
fillEventArgs.Type = FillType.Historic;
fillEventArgs.TTInstrumentKey = instrumentKey;
// Add the instrument key to the list.
if (startDateTime.AddSeconds(-3) <= localDateTimeValid && localDateTimeValid <= endDateTime.AddSeconds(3))
{
if (!TTConvert.CheckExistenceOfInstrumentKey(instrumentKeyList, instrumentKey))
{
instrumentKeyList.Add(instrumentKey);
}
// Add the fill event args to the list.
string rowInfo = string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11},{12},{13},{14},{15}.", localTimeStamp, exchangeName, orderStatus, orderAction, orderSide, orderQty, product, contract, orderPrice, accountName, userName, exchangeTime, exchangeDate, tradeSource, ttOrderKey, ttSeriesKey);
Log.NewEntry(LogLevel.Minor, "Record:{0}", rowInfo);
m_FillEventArgsList.Add(fillEventArgs);
}
}
}
else
{
Log.NewEntry(LogLevel.Major, "Failed to read access file with name:{0}.", targetFileList[fileIndex]);
continue;
}
Log.NewEntry(LogLevel.Minor, "Complete reading access file with name:{0}.", targetFileList[fileIndex]);
}
// Get the last local time of fill for each instrument in initial fill hub.
m_NeededBookInstrumentList.Clear();
//foreach (InstrumentKey ttKeyInWaitList in auditTrailFillHub.InitialWaitDictionary.Keys)
//{
// // These fills that do not have books will be requested to create new books if possible. To ensure they have books, create them if necessary here.
// if (!auditTrailFillHub.TryCheckExistenceOfInstrumentKey(ttKeyInWaitList) && !TTConvert.CheckExistenceOfInstrumentKey(neededBookInstrumentList, ttKeyInWaitList))
// {
// neededBookInstrumentList.Add(ttKeyInWaitList);
// }
//}
// For the fills from the audit trail files, also get instruments that need books.
foreach (InstrumentKey instrumentKeyInAuditTrail in instrumentKeyList)
{
if (!auditTrailFillHub.TryCheckExistenceOfInstrumentKey(instrumentKeyInAuditTrail) && !TTConvert.CheckExistenceOfInstrumentKey(m_NeededBookInstrumentList, instrumentKeyInAuditTrail))
{
m_NeededBookInstrumentList.Add(instrumentKeyInAuditTrail);
}
}
// Clear all trades in the waiting list because they are all included in the audit trail files.
auditTrailFillHub.InitialWaitDictionary.Clear();
// Create books if necessary.
// The instrument that need book creation is those got from FillEventArgs from drop file and the new fills listened in the audit trail file.
// It is crucial to get all the books ready before updating positions.
foreach (InstrumentKey key in m_NeededBookInstrumentList)
{
OrderHubRequest creatFillBookRequest = new OrderHubRequest(OrderHubRequest.RequestType.RequestCreateFillBook);
creatFillBookRequest.Data = new object[1];
creatFillBookRequest.Data[0] = key;
auditTrailFillHub.HubEventEnqueue(creatFillBookRequest);
}
Log.NewEntry(LogLevel.Minor, "Complete loading audit trail fills.");
return(true);
}
/// <summary>
/// This function plays all the effective fill event args that are in specified date time range by getting initial fill hub and outputting final fill hub.
/// </summary>
/// <param name="initialFillHub"></param>
/// <param name="startDateTime"></param>
/// <param name="endDateTime"></param>
/// <param name="workingFillHub"></param>
/// <returns></returns>
public bool TryPlayAuditTrailFillsForFillHub(AuditTrailFillHub initialFillHub, DateTime startDateTime, DateTime endDateTime, out AuditTrailFillHub workingFillHub)
{
// This method will load fill hub and add audit trail fills to each instrument in it.
Dictionary <InstrumentKey, DateTime> instrumentLastExchangeDateTimeDictionary = new Dictionary <InstrumentKey, DateTime>();
DateTime minDateTime = new DateTime(2000, 1, 1);
workingFillHub = null;
DateTime thisFillLocalDateTime;
DateTime thisFillExchangeDateTime;
DateTime lastExchangeFillDateTime;
//foreach (InstrumentKey ttKeyInWaitList in initialFillHub.InitialWaitDictionary.Keys)
//{
// // The fill event args dictionary contains exchange date time as keys.
// SortedList<DateTime, FillEventArgs> fillEventArgsDictionary = initialFillHub.InitialWaitDictionary[ttKeyInWaitList];
// DateTime exchangeLastDateTime = new DateTime(2000, 1, 1);
// foreach (DateTime exchangeDateTime in fillEventArgsDictionary.Keys)
// {
// DateTime thisLocalDateTime = fillEventArgsDictionary[exchangeDateTime].Fill.LocalTime;
// DateTime thisExchangeDateTime = fillEventArgsDictionary[exchangeDateTime].Fill.ExchangeTime;
// if (thisLocalDateTime <= endDateTime)
// {
// initialFillHub.m_Listener.OnFilled(fillEventArgsDictionary[exchangeDateTime]);
// exchangeLastDateTime = thisExchangeDateTime;
// }
// }
// // Add entries to the local date time dictionary.
// if (exchangeLastDateTime > minDateTime)
// {
// if (!instrumentLastExchangeDateTimeDictionary.ContainsKey(ttKeyInWaitList))
// instrumentLastExchangeDateTimeDictionary.Add(ttKeyInWaitList, exchangeLastDateTime);
// }
// //// These fills that do not have books will be requested to create new books if possible. To ensure they have books, create them if necessary here.
// //if (!auditTrailFillHub.TryCheckExistenceOfInstrumentKey(ttKeyInWaitList) && !TTConvert.CheckExistenceOfInstrumentKey(m_NeededBookInstrumentList, ttKeyInWaitList))
// //{
// // m_NeededBookInstrumentList.Add(ttKeyInWaitList);
// //}
//}
// Loop through the books to get last fill local date time if there is no fill event in the waiting list.
List <InstrumentName> instrumentNameList = new List <InstrumentName>();
//List<InstrumentKey> instrumentListWithBooks = new List<InstrumentKey>();
initialFillHub.GetInstrumentNames(ref instrumentNameList);
foreach (InstrumentName instrumentName in instrumentNameList)
{
IFillBook book;
InstrumentKey ttInstrumentKey;
if (initialFillHub.TryEnterReadBook(instrumentName, out book) && book is BookLifo && initialFillHub.TryGetInstrumentKey(instrumentName, out ttInstrumentKey))
{
//if (!TTConvert.CheckExistenceOfInstrumentKey(instrumentListWithBooks, ttInstrumentKey))
// instrumentListWithBooks.Add(ttInstrumentKey);
if (!instrumentLastExchangeDateTimeDictionary.ContainsKey(ttInstrumentKey))
{
instrumentLastExchangeDateTimeDictionary.Add(ttInstrumentKey, ((BookLifo)book).ExchangeTimeLast);
}
//else
//{
// if (((BookLifo)book).ExchangeTimeLast > instrumentLastExchangeDateTimeDictionary[ttInstrumentKey])
// {
// Log.NewEntry(LogLevel.Major, "The recorded exchange time in book:{0} is later than recorded new fill exchange time:{1}.", ((BookLifo)book).ExchangeTimeLast, instrumentLastExchangeDateTimeDictionary[ttInstrumentKey]);
// instrumentLastExchangeDateTimeDictionary[ttInstrumentKey] = ((BookLifo)book).ExchangeTimeLast;
// }
//}
initialFillHub.ExitReadBook(instrumentName);
}
}
// Sort event args into dictionary by instruments.
Dictionary <InstrumentKey, SortedList <DateTime, FillEventArgs> > m_FillEventArgsByInstrumentKey = new Dictionary <InstrumentKey, SortedList <DateTime, FillEventArgs> >();
foreach (FillEventArgs e in m_FillEventArgsList)
{
if (!m_FillEventArgsByInstrumentKey.ContainsKey(e.TTInstrumentKey))
{
m_FillEventArgsByInstrumentKey.Add(e.TTInstrumentKey, new SortedList <DateTime, FillEventArgs>());
}
while (m_FillEventArgsByInstrumentKey[e.TTInstrumentKey].ContainsKey(e.Fill.ExchangeTime))
{
e.Fill.ExchangeTime = e.Fill.ExchangeTime.AddTicks(1L);
}
m_FillEventArgsByInstrumentKey[e.TTInstrumentKey].Add(e.Fill.ExchangeTime, e);
}
// Play the fill event args in the program.
foreach (InstrumentKey ttKey in m_FillEventArgsByInstrumentKey.Keys)
{
if (instrumentLastExchangeDateTimeDictionary.ContainsKey(ttKey))
{
lastExchangeFillDateTime = instrumentLastExchangeDateTimeDictionary[ttKey];
}
else
{
// Sometimes, there are other instruments that we do not the know the last local date time. This may due to that there are no books in the drop file.
// This is a new instrument and we should accept all the fills.
lastExchangeFillDateTime = startDateTime.AddMilliseconds(-1);
}
foreach (DateTime sortedDateTime in m_FillEventArgsByInstrumentKey[ttKey].Keys)
{
thisFillLocalDateTime = m_FillEventArgsByInstrumentKey[ttKey][sortedDateTime].Fill.LocalTime;
thisFillExchangeDateTime = sortedDateTime;
if (thisFillExchangeDateTime > lastExchangeFillDateTime && thisFillLocalDateTime <= endDateTime)
{
initialFillHub.m_Listener.OnFilled(m_FillEventArgsByInstrumentKey[ttKey][sortedDateTime]);
}
}
}
//// Play the fill event args in the program.
//foreach (FillEventArgs fillEventArg in m_FillEventArgsList)
//{
// thisFillLocalDateTime = fillEventArg.Fill.LocalTime;
// thisFillExchangeDateTime = fillEventArg.Fill.ExchangeTime;
// InstrumentKey ttKeyInAuditTrail = fillEventArg.TTInstrumentKey;
// if (instrumentLastExchangeDateTimeDictionary.ContainsKey(ttKeyInAuditTrail))
// {
// lastExchangeFillDateTime = instrumentLastExchangeDateTimeDictionary[ttKeyInAuditTrail];
// }
// else
// {
// // Sometimes, there are other instruments that we do not the know the last local date time. This may due to that there are no books in the drop file.
// // This is a new instrument and we should accept all the fills.
// lastExchangeFillDateTime = startDateTime.AddMilliseconds(-1);
// }
// if (thisFillExchangeDateTime > lastExchangeFillDateTime && thisFillLocalDateTime <= endDateTime)
// initialFillHub.m_Listener.OnFilled(fillEventArg);
//}
workingFillHub = initialFillHub;
return(true);
}
// *****************************************************************
// **** Public Methods ****
// *****************************************************************
//
//
//
/// <summary>
/// Get drop file specified by user using a Ambre position recovery start date time.
/// It loads the most recent drop file before this date time.
/// </summary>
/// <param name="userName"></param>
/// <param name="fillHubName"></param>
/// <param name="selectedDateTime"></param>
/// <param name="fillHub"></param>
/// <returns></returns>
public bool TryPlayDropFileForOneFillHub(string userName, string fillHubName, DateTime selectedDateTime, out AuditTrailFillHub fillHub)
{
fillHub = null;
// Find the fill book with the closest date time to the input date time.
string currentFilePath = null;
string pattern = string.Format("*FillBooks_{0}_{1}.txt", userName, fillHubName);
DateTime searchFileDateTime = DateTime.MinValue;
bool isBookFound = false;
// Get the directories with date format in the drop path.
List <string> dirPathList = new List <string>(System.IO.Directory.GetDirectories(m_DropPath, "20*"));
dirPathList.Sort();
int dirPtr = dirPathList.Count - 1;
string currentDirPath;
int indexDir;
// Create the file path list to store the searched files.
List <string> filePathList = new List <string>();
int indexPath;
int filePtr;
string fileName;
string fileTime;
string fileDate;
string fileDateTime;
// Start searching for the correct file. Loop through directory.
while (!isBookFound && dirPtr >= 0)
{
currentDirPath = dirPathList[dirPtr];
filePathList.Clear();
filePathList.AddRange(System.IO.Directory.GetFiles(currentDirPath, pattern));
if (filePathList.Count > 0)
{
filePathList.Sort();
filePtr = filePathList.Count - 1;
// Loop through files in that directory.
while (!isBookFound && filePtr >= 0)
{
currentFilePath = filePathList[filePtr];
indexDir = currentDirPath.LastIndexOf('\\');
indexPath = currentFilePath.LastIndexOf('\\');
fileName = currentFilePath.Substring(indexPath + 1, currentFilePath.Length - (indexPath + 1));
fileTime = fileName.Substring(0, fileName.IndexOf("_"));
fileDate = currentDirPath.Substring(indexDir + 1, currentDirPath.Length - (indexDir + 1));
fileDateTime = string.Format("{0}{1}", fileDate, fileTime);
// Parse the date time out.
if (!DateTime.TryParseExact(fileDateTime, "yyyyMMddHHmmss", null, System.Globalization.DateTimeStyles.None, out searchFileDateTime))
{
Log.NewEntry(LogLevel.Major, "Failed to parse the file date time of {0}.", fileDateTime);
}
else
{
Log.NewEntry(LogLevel.Minor, "Successfully get the file path of {0}.", searchFileDateTime);
System.IO.FileInfo info = new System.IO.FileInfo(filePathList[filePtr]);
m_SelectedDropFileDateTime = searchFileDateTime;
isBookFound = searchFileDateTime <= selectedDateTime && info.Length > 0;
}
// If no desired file is found in this directory, find in the next directory.
filePtr--;
if (!isBookFound && filePtr < 0)
{
dirPtr--;
break;
}
}
}
else
{
dirPtr--;
}
}
// Check finally whether we have found the file.
if (!isBookFound || string.IsNullOrEmpty(currentFilePath))
{
Log.NewEntry(LogLevel.Major, "Failed to locate the file before date time of {0}.", selectedDateTime);
return(false);
}
else
{
// Start to load every element from the file.
Log.NewEntry(LogLevel.Minor, "Start load elements from drop file.");
List <Node> nodeList;
try
{
using (StringifiableReader reader = new StringifiableReader(currentFilePath))
{
nodeList = reader.ReadNodesToEnd();
reader.Close();
}
}
catch (Exception e)
{
Log.NewEntry(LogLevel.Major, "TryPlayDropFileForOneFillHub: Strigifiable Reader Exception: {0}", e.Message);
return(false);
}
// Go through the node list backward, looking for the last fill hub node.
Node hubNode = null;
string fillHubTypeName = typeof(FillHub).FullName;
int ptr = nodeList.Count - 1;
while (ptr >= 0)
{
if (hubNode != null)
{
nodeList.RemoveAt(ptr);
}
else if (nodeList[ptr].Name == fillHubTypeName)
{
hubNode = nodeList[ptr];
nodeList.RemoveAt(ptr);
}
ptr--;
}
// Extract the information from the fill hub node.
fillHub = new AuditTrailFillHub(fillHubName, false);
List <IStringifiable> objectList = new List <IStringifiable>();
((IStringifiable)fillHub).SetAttributes(hubNode.Attributes);
foreach (IStringifiable subElement in hubNode.SubElements)
{
IStringifiable obj = Stringifiable.Create((Node)subElement);
objectList.Add(obj);
}
foreach (Node anode in nodeList)
{
IStringifiable obj = Stringifiable.Create(anode);
objectList.Add(obj);
}
// Load objects we found.
if (objectList != null && objectList.Count > 0)
{
foreach (IStringifiable obj in objectList)
{
if (obj is InstrumentMapEntry)
{
((IStringifiable)fillHub).AddSubElement(obj);
}
}
foreach (IStringifiable obj in objectList)
{
if (!(obj is InstrumentMapEntry))
{
((IStringifiable)fillHub).AddSubElement(obj);
}
}
return(true);
}
else
{
return(false);
}
}
}
