public SecurityMap SaveSecurityMap(Security security, string cusip)
{
SecurityMap securityMap;
try
{
securityMap = new SecurityMap
{
Cusip = cusip,
Name = security.Name,
SecurityId = security.SecurityId
};
_db.SecurityMaps.Add(securityMap);
_db.SaveChanges();
}
catch
{
securityMap = _db.SecurityMaps.FirstOrDefault(s => s.Cusip == cusip);
if (securityMap == null)
{
throw;
}
}
return(securityMap);
}
public Security CusipLookup(string cusip)
{
Security security = null;
SecurityMap securityMap = _db.SecurityMaps.FirstOrDefault(s => s.Cusip == cusip);
if (securityMap != null)
{
security = _db.Securities.FirstOrDefault(s => s.SecurityId == securityMap.SecurityId);
}
else
{
UnknownShare unknownShare = _db.UnknownShares.FirstOrDefault(s => s.Cusip == cusip);
if (unknownShare == null)
{
security = StockFinder.CusipLookup(cusip);
}
}
return(security);
}
public Security NameLookup(string name)
{
name = NormaliseSecurityName(name);
SecurityMap securityMap = _db.SecurityMaps.FirstOrDefault(s => s.Name == name);
Security security = null;
if (securityMap != null)
{
security = _db.Securities.FirstOrDefault(s => s.SecurityId == securityMap.SecurityId);
}
else
{
UnknownShare unknownShare = _db.UnknownShares.FirstOrDefault(s => s.NameOfIssuer == name);
if (unknownShare == null)
{
security = StockFinder.NameLookup(name);
}
}
return(security);
}
/// <summary>
/// Creates an address map from an XML document.
/// </summary>
/// <param name="xmlDocument">The document to be parsed for addresses</param>
/// <param name="documentVersion">Identifies a particular version of the document</param>
public AddressMap(XmlDocument xmlDocument, int documentVersion) : base()
{
// This table is used to quickly map an element name to a token.
ElementNameTable elementNameTable = new ElementNameTable();
// These variables are used to track the states when parsing the XML Spreadsheet.
int rowType = 0;
int rowIndex = 0;
int columnIndex = 0;
int columnType = 0;
int securityId = 0;
ParsingState parsingState = ParsingState.None;
// IMPORTANT CONCEPT: Create a fast, forward only reader on the XML Document. This saves a lot of time over
// trying to use XPath commands on the version used for the document. The main idea is that we are going to
// rip through the spreadsheet XML looking only for specific element nodes. Certain elements will cause the
// state of the parsing to change (e.g. finding a 'ss:Row' element will increment the row counter. Other
// nodes contain data that helps to map the spreadsheet document into a data structure that can be used to
// address individual cells in the spreadsheet, which is the end product of this method.
XmlNodeReader xmlNodeReader = new XmlNodeReader(xmlDocument);
// Rip through the XML file looking for specific node types and names.
while (xmlNodeReader.Read())
{
// The outer switch statement divides the nodes up into their types. The inner switch statement will
// examine their names. We will switch from one state to another based on this combination of node type
// and name. The state ultimately tells us how to interpret the data when we run across it.
switch (xmlNodeReader.NodeType)
{
case XmlNodeType.Element:
// Turn the element name into a token so we can quickly jump to the code to handle it.
switch (elementNameTable[xmlNodeReader.Name])
{
case ElementName.NamedRange:
// Create a mapping of column names to column types and vica-versa.
columnIndex = SpreadsheetColumn.Parse(xmlNodeReader["ss:RefersTo"]);
columnType = ColumnType.Tokenize(xmlNodeReader["ss:Name"]);
if (columnIndex != SpreadsheetColumn.DoesNotExist && columnType != ColumnType.None)
{
// Make sure that errors in the column names don't kill the whole parsing session.
try
{
this.ColumnIndexMap.AddColumnIndexMapRow(columnType, columnIndex);
this.ColumnIdMap.AddColumnIdMapRow(columnIndex, columnType);
}
catch (Exception exception)
{
// Write the error and stack trace out to the debug listener
Debug.WriteLine(String.Format("{0}, {1}", exception.Message, exception.StackTrace));
}
}
break;
case ElementName.Row:
// Increase the row index monotonically if no explicit index is given.
string rowIndexText = xmlNodeReader["ss:Index"];
rowIndex = (rowIndexText == null) ? rowIndex + 1 : Convert.ToInt32(rowIndexText);
// Reset the state of the row when we recognize a new row.
rowType = RowType.Unused;
columnIndex = 0;
break;
case ElementName.Cell:
// Increase the column index monotonically if no explicit index is given.
string columnIndexText = xmlNodeReader["ss:Index"];
columnIndex = (columnIndexText == null) ? columnIndex + 1 : Convert.ToInt32(columnIndexText);
break;
case ElementName.Data:
// If we're on the row type column (typically, the first column of every row in the
// spreadsheet), then the next Text node will contain the row type.
if (columnIndex == GetColumnIndex(ColumnType.RowType))
{
parsingState = ParsingState.RowType;
break;
}
// If the current column is a position type code on a position row, then look for the position
// type code the next time a Text node is found.
if (rowType == RowType.BlockOrder && columnIndex == GetColumnIndex(ColumnType.BlockOrderId))
{
parsingState = ParsingState.BlockOrderId;
break;
}
// If the current column is the security id column on a position row, then look for the
// security id the next time a Text node is found.
if (rowType == RowType.BlockOrder && columnIndex == GetColumnIndex(ColumnType.SecurityId))
{
parsingState = ParsingState.SecurityId;
break;
}
break;
default:
// The parsing state is only good for the scope of the 'Data' element. If we didnt'
// recognize a parsing state above, then reset the state value so we don't get confused the
// next time we read a 'Data' node.
parsingState = ParsingState.None;
break;
}
break;
case XmlNodeType.Text:
// The state variable tells us how to interpret the text nodes.
switch (parsingState)
{
case ParsingState.RowType:
// This node tells us what kind of row we are reading.
rowType = Convert.ToInt32(xmlNodeReader.Value);
break;
case ParsingState.SecurityId:
// The security identifier is found in this cell.
securityId = Convert.ToInt32(xmlNodeReader.Value);
// Construct a map of security locations for the incoming prices. Remember that a single
// security could be on the report twice: once for long and once for short positions. Create
// the security level row first if it doesn't already exist.
AddressMapSet.SecurityMapRow securityMapRow = SecurityMap.FindBySecurityId(securityId);
if (securityMapRow == null)
{
securityMapRow = SecurityMap.AddSecurityMapRow(securityId);
}
// Last Price Mapping
int lastPriceColumnIndex = GetColumnIndex(ColumnType.LastPrice);
if (lastPriceColumnIndex != SpreadsheetColumn.DoesNotExist)
{
LastPriceAddress.AddLastPriceAddressRow(securityMapRow,
documentVersion, rowIndex, lastPriceColumnIndex);
}
// Bid Price Mapping
int bidPriceColumnIndex = GetColumnIndex(ColumnType.BidPrice);
if (bidPriceColumnIndex != SpreadsheetColumn.DoesNotExist)
{
BidPriceAddress.AddBidPriceAddressRow(securityMapRow,
documentVersion, rowIndex, bidPriceColumnIndex);
}
// Ask Price Mapping
int askPriceColumnIndex = GetColumnIndex(ColumnType.AskPrice);
if (askPriceColumnIndex != SpreadsheetColumn.DoesNotExist)
{
AskPriceAddress.AddAskPriceAddressRow(securityMapRow,
documentVersion, rowIndex, askPriceColumnIndex);
}
break;
case ParsingState.BlockOrderId:
// The position type code is found in this cell.
int blockOrderId = Convert.ToInt32(xmlNodeReader.Value);
// Construct a map entry for cell that is addressed by a security, position type code
// combination. Note how the columns are mapped dynamically based on the names given to the
// columns in the spreadsheet. See the section above that extracts the column names for how
// the column index is constructed.
BlockOrderMap.AddBlockOrderMapRow(blockOrderId, ColumnType.StatusCode, documentVersion, rowIndex, GetColumnIndex(ColumnType.StatusCode));
BlockOrderMap.AddBlockOrderMapRow(blockOrderId, ColumnType.QuantityOrdered, documentVersion, rowIndex, GetColumnIndex(ColumnType.QuantityOrdered));
BlockOrderMap.AddBlockOrderMapRow(blockOrderId, ColumnType.QuantityPlaced, documentVersion, rowIndex, GetColumnIndex(ColumnType.QuantityPlaced));
BlockOrderMap.AddBlockOrderMapRow(blockOrderId, ColumnType.QuantityExecuted, documentVersion, rowIndex, GetColumnIndex(ColumnType.QuantityExecuted));
break;
}
// Reset the parsing state after each text node is read and interpreted.
parsingState = ParsingState.None;
break;
}
}
// Commit all the changes made to the data set.
this.AcceptChanges();
}