public void AggregateFields(ClientMarketData.WorkingOrderRow workingOrderRow)
{
this.totalSourceOrderedQuantity = 0.0M;
this.totalDestinationOrderedQuantity = 0.0M;
this.totalWorkingQuantity = 0.0M;
this.totalExecutedQuantity = 0.0M;
this.totalAllocatedQuantity = 0.0M;
this.totalLeavesQuantity = 0.0M;
this.averagePriceExecuted = 0.0M;
this.totalCommission = 0.0M;
this.totalMarketValue = 0.0M;
// this.averageCommissionRate = 0.0M;
foreach (ClientMarketData.SourceOrderRow customerOrderRow in workingOrderRow.GetSourceOrderRows())
{
this.totalSourceOrderedQuantity += customerOrderRow.OrderedQuantity;
}
foreach (ClientMarketData.DestinationOrderRow destinationOrderRow in workingOrderRow.GetDestinationOrderRows())
{
this.totalDestinationOrderedQuantity += destinationOrderRow.OrderedQuantity - destinationOrderRow.CanceledQuantity;
foreach (ClientMarketData.ExecutionRow executionRow in destinationOrderRow.GetExecutionRows())
{
this.totalExecutedQuantity += executionRow.ExecutionQuantity;
this.totalMarketValue += executionRow.ExecutionQuantity * executionRow.ExecutionPrice;
}
}
this.totalWorkingQuantity = this.totalSourceOrderedQuantity - this.totalExecutedQuantity;
this.totalLeavesQuantity = this.totalSourceOrderedQuantity - this.totalDestinationOrderedQuantity;
this.averagePriceExecuted = this.totalExecutedQuantity == 0.0M ? 0.0M :
this.totalMarketValue / this.totalExecutedQuantity;
foreach (ClientMarketData.AllocationRow allocationRow in workingOrderRow.GetAllocationRows())
{
this.totalAllocatedQuantity += allocationRow.Quantity;
this.totalCommission += allocationRow.Commission;
}
}
/// <summary>
/// Initialize the data used in this application.
/// </summary>
private void InitializeData(object parameter)
{
string title = string.Empty;
string symbol = string.Empty;
string name = string.Empty;
Bitmap logo = null;
decimal leavesQuantity = 0.0m;
decimal minimumQuantity = 0.0m;
NegotiationState negotiationState = NegotiationState.None;
try
{
// Lock the tables.
System.Diagnostics.Debug.Assert(!ClientMarketData.IsLocked);
ClientMarketData.MatchLock.AcquireReaderLock(ClientTimeout.LockWait);
ClientMarketData.NegotiationLock.AcquireReaderLock(ClientTimeout.LockWait);
ClientMarketData.ObjectLock.AcquireReaderLock(ClientTimeout.LockWait);
ClientMarketData.OrderTypeLock.AcquireReaderLock(ClientTimeout.LockWait);
ClientMarketData.SecurityLock.AcquireReaderLock(ClientTimeout.LockWait);
ClientMarketData.WorkingOrderLock.AcquireReaderLock(ClientTimeout.LockWait);
// Find the Match record.
ClientMarketData.MatchRow matchRow = ClientMarketData.Match.FindByMatchId(this.matchId);
ClientMarketData.WorkingOrderRow workingOrderRow = matchRow.WorkingOrderRow;
ClientMarketData.OrderTypeRow orderTypeRow = workingOrderRow.OrderTypeRow;
ClientMarketData.SecurityRow securityRow = workingOrderRow.SecurityRowBySecurityWorkingOrderSecurityId;
symbol = securityRow.Symbol;
name = securityRow.ObjectRow.Name;
minimumQuantity = securityRow.MinimumQuantity;
if (!securityRow.IsLogoNull())
{
MemoryStream memoryStream = new MemoryStream(Convert.FromBase64String(securityRow.Logo));
logo = new Bitmap(memoryStream);
}
title = string.Format("{0} of {1}", orderTypeRow.Description, symbol);
leavesQuantity = workingOrderRow.SubmittedQuantity;
foreach (ClientMarketData.DestinationOrderRow destinationOrderRow in workingOrderRow.GetDestinationOrderRows())
{
foreach (ClientMarketData.ExecutionRow executionRow in destinationOrderRow.GetExecutionRows())
{
leavesQuantity -= executionRow.ExecutionQuantity;
}
}
}
finally
{
// Release the locks.
if (ClientMarketData.MatchLock.IsReaderLockHeld)
{
ClientMarketData.MatchLock.ReleaseReaderLock();
}
if (ClientMarketData.NegotiationLock.IsReaderLockHeld)
{
ClientMarketData.NegotiationLock.ReleaseReaderLock();
}
if (ClientMarketData.ObjectLock.IsReaderLockHeld)
{
ClientMarketData.ObjectLock.ReleaseReaderLock();
}
if (ClientMarketData.OrderTypeLock.IsReaderLockHeld)
{
ClientMarketData.OrderTypeLock.ReleaseReaderLock();
}
if (ClientMarketData.SecurityLock.IsReaderLockHeld)
{
ClientMarketData.SecurityLock.ReleaseReaderLock();
}
if (ClientMarketData.WorkingOrderLock.IsReaderLockHeld)
{
ClientMarketData.WorkingOrderLock.ReleaseReaderLock();
}
System.Diagnostics.Debug.Assert(!ClientMarketData.IsLocked);
}
Invoke(new SetDialogAttributesDelegate(SetDialogAttributes), new object[] { title, symbol, name, logo, leavesQuantity, negotiationState });
}
/// <summary>
/// Creates a well formed working order document object model.
/// </summary>
/// <param name="blotterId">The blotter identifies what blocks are to be included in this document.</param>
public SourceOrderDocument(Blotter blotter, WorkingOrder[] workingOrders)
{
try
{
// Lock the tables
System.Diagnostics.Debug.Assert(!ClientMarketData.IsLocked);
ClientMarketData.BlotterLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.DestinationLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.ObjectLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.ObjectTreeLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.OrderTypeLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.PriceTypeLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.SecurityLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.SourceOrderLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.StatusLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.StylesheetLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.TimeInForceLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.UserLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.WorkingOrderLock.AcquireReaderLock(CommonTimeout.LockWait);
// Create the root element for the document.
XmlNode documentNode = this.AppendChild(this.CreateElement("Document"));
if (workingOrders == null)
{
// Find the top level blotter record and recursively construct the report by merging all the children.
ClientMarketData.ObjectRow objectRow = ClientMarketData.Object.FindByObjectId(blotter.BlotterId);
if (objectRow != null)
{
RecurseBlotter(documentNode, objectRow);
}
}
else
{
foreach (WorkingOrder workingOrder in workingOrders)
{
ClientMarketData.WorkingOrderRow workingOrderRow = ClientMarketData.WorkingOrder.FindByWorkingOrderId(workingOrder.WorkingOrderId);
if (workingOrderRow != null)
{
foreach (ClientMarketData.SourceOrderRow sourceOrderRow in workingOrderRow.GetSourceOrderRows())
{
documentNode.AppendChild(new SourceOrderElement(this, sourceOrderRow, FieldArray.Set));
}
}
}
}
}
catch (Exception exception)
{
// Write the error and stack trace out to the debug listener
EventLog.Error("{0}, {1}", exception.Message, exception.StackTrace);
}
finally
{
// Release the table locks.
if (ClientMarketData.BlotterLock.IsReaderLockHeld)
{
ClientMarketData.BlotterLock.ReleaseReaderLock();
}
if (ClientMarketData.DestinationLock.IsReaderLockHeld)
{
ClientMarketData.DestinationLock.ReleaseReaderLock();
}
if (ClientMarketData.ObjectLock.IsReaderLockHeld)
{
ClientMarketData.ObjectLock.ReleaseReaderLock();
}
if (ClientMarketData.ObjectTreeLock.IsReaderLockHeld)
{
ClientMarketData.ObjectTreeLock.ReleaseReaderLock();
}
if (ClientMarketData.OrderTypeLock.IsReaderLockHeld)
{
ClientMarketData.OrderTypeLock.ReleaseReaderLock();
}
if (ClientMarketData.PriceTypeLock.IsReaderLockHeld)
{
ClientMarketData.PriceTypeLock.ReleaseReaderLock();
}
if (ClientMarketData.SecurityLock.IsReaderLockHeld)
{
ClientMarketData.SecurityLock.ReleaseReaderLock();
}
if (ClientMarketData.SourceOrderLock.IsReaderLockHeld)
{
ClientMarketData.SourceOrderLock.ReleaseReaderLock();
}
if (ClientMarketData.StatusLock.IsReaderLockHeld)
{
ClientMarketData.StatusLock.ReleaseReaderLock();
}
if (ClientMarketData.StylesheetLock.IsReaderLockHeld)
{
ClientMarketData.StylesheetLock.ReleaseReaderLock();
}
if (ClientMarketData.TimeInForceLock.IsReaderLockHeld)
{
ClientMarketData.TimeInForceLock.ReleaseReaderLock();
}
if (ClientMarketData.UserLock.IsReaderLockHeld)
{
ClientMarketData.UserLock.ReleaseReaderLock();
}
if (ClientMarketData.WorkingOrderLock.IsReaderLockHeld)
{
ClientMarketData.WorkingOrderLock.ReleaseReaderLock();
}
System.Diagnostics.Debug.Assert(!ClientMarketData.IsLocked);
}
}
/// <summary>
/// Creates an XML Element representing a workingOrder in a execution document.
/// </summary>
/// <param name="xmlDocument">The destination XML document.</param>
/// <param name="workingOrderRow">A workingOrder record.</param>
public WorkingOrderElement(XmlDocument xmlDocument, ClientMarketData.WorkingOrderRow workingOrderRow) : base("WorkingOrder", xmlDocument)
{
}
/// <summary>
/// Creates a workingOrder element for the AdvertisementDocument
/// </summary>
/// <param name="workingOrderRow">A WorkingOrder record</param>
/// <returns>An element that represents a workingOrder.</returns>
public WorkingOrderElement CreateWorkingOrderElement(ClientMarketData.WorkingOrderRow workingOrderRow)
{
return(new WorkingOrderElement(this, workingOrderRow));
}
/// <summary>
/// Method called to retrieve the securityId for the security selected in the match viewere.
/// </summary>
/// <param name="parameter"></param>
private void InitializeData(object parameter)
{
int id = Int32.MinValue;
try
{
// Lock the tables.
System.Diagnostics.Debug.Assert(!ClientMarketData.IsLocked);
ClientMarketData.MatchLock.AcquireReaderLock(ClientTimeout.LockWait);
ClientMarketData.NegotiationLock.AcquireReaderLock(ClientTimeout.LockWait);
ClientMarketData.OrderTypeLock.AcquireReaderLock(ClientTimeout.LockWait);
ClientMarketData.SecurityLock.AcquireReaderLock(ClientTimeout.LockWait);
ClientMarketData.WorkingOrderLock.AcquireReaderLock(ClientTimeout.LockWait);
// Find the Match record.
ClientMarketData.MatchRow matchRow = ClientMarketData.Match.FindByMatchId(this.matchId);
ClientMarketData.WorkingOrderRow workingOrderRow = matchRow.WorkingOrderRow;
ClientMarketData.OrderTypeRow orderTypeRow = workingOrderRow.OrderTypeRow;
ClientMarketData.SecurityRow securityRow = workingOrderRow.SecurityRowBySecurityWorkingOrderSecurityId;
if (securityRow != null)
{
id = securityRow.SecurityId;
}
}
catch (Exception e)
{
// Write the error and stack trace out to the debug listener
EventLog.Error("{0}, {1}", e.Message, e.StackTrace);
}
finally
{
// Release the locks.
if (ClientMarketData.MatchLock.IsReaderLockHeld)
{
ClientMarketData.MatchLock.ReleaseReaderLock();
}
if (ClientMarketData.NegotiationLock.IsReaderLockHeld)
{
ClientMarketData.NegotiationLock.ReleaseReaderLock();
}
if (ClientMarketData.OrderTypeLock.IsReaderLockHeld)
{
ClientMarketData.OrderTypeLock.ReleaseReaderLock();
}
if (ClientMarketData.SecurityLock.IsReaderLockHeld)
{
ClientMarketData.SecurityLock.ReleaseReaderLock();
}
if (ClientMarketData.WorkingOrderLock.IsReaderLockHeld)
{
ClientMarketData.WorkingOrderLock.ReleaseReaderLock();
}
System.Diagnostics.Debug.Assert(!ClientMarketData.IsLocked);
}
if (id != Int32.MinValue)
{
this.Open(id);
}
}
/// <summary>
/// Notifies the user that a match opportunity exists.
/// </summary>
/// <param name="parameter">The thread initialization parameters.</param>
private void NotifyUser(object parameter)
{
// Extract the thread parameters.
int matchId = (int)parameter;
// The symbol, title and the bitmap for the corporate logo will be retrieved from the data model in the code below.
// They will be used to initialize the pop-up dialog after the locks on the data model have been released.
string symbol = string.Empty;
string title = string.Empty;
Bitmap logo = null;
try
{
// Lock the tables.
System.Diagnostics.Debug.Assert(!ClientMarketData.IsLocked);
ClientMarketData.MatchLock.AcquireReaderLock(ClientTimeout.LockWait);
ClientMarketData.NegotiationLock.AcquireReaderLock(ClientTimeout.LockWait);
ClientMarketData.OrderTypeLock.AcquireReaderLock(ClientTimeout.LockWait);
ClientMarketData.SecurityLock.AcquireReaderLock(ClientTimeout.LockWait);
ClientMarketData.WorkingOrderLock.AcquireReaderLock(ClientTimeout.LockWait);
// The match record, working order, order type and security records are used to construct the title, symbol and
// logo used by the notification window.
ClientMarketData.MatchRow matchRow = ClientMarketData.Match.FindByMatchId(matchId);
ClientMarketData.WorkingOrderRow workingOrderRow = matchRow.WorkingOrderRow;
ClientMarketData.OrderTypeRow orderTypeRow = workingOrderRow.OrderTypeRow;
ClientMarketData.SecurityRow securityRow = workingOrderRow.SecurityRowBySecurityWorkingOrderSecurityId;
// Get the security symbol.
symbol = securityRow.Symbol;
// Create a logo bitmap.
if (!securityRow.IsLogoNull())
{
MemoryStream memoryStream = new MemoryStream(Convert.FromBase64String(securityRow.Logo));
logo = new Bitmap(memoryStream);
}
// Construct the title for the notification window.
title = string.Format("{0} of {1}", orderTypeRow.Description, symbol);
}
finally
{
// Release the locks.
if (ClientMarketData.MatchLock.IsReaderLockHeld)
{
ClientMarketData.MatchLock.ReleaseReaderLock();
}
if (ClientMarketData.NegotiationLock.IsReaderLockHeld)
{
ClientMarketData.NegotiationLock.ReleaseReaderLock();
}
if (ClientMarketData.OrderTypeLock.IsReaderLockHeld)
{
ClientMarketData.OrderTypeLock.ReleaseReaderLock();
}
if (ClientMarketData.SecurityLock.IsReaderLockHeld)
{
ClientMarketData.SecurityLock.ReleaseReaderLock();
}
if (ClientMarketData.WorkingOrderLock.IsReaderLockHeld)
{
ClientMarketData.WorkingOrderLock.ReleaseReaderLock();
}
System.Diagnostics.Debug.Assert(!ClientMarketData.IsLocked);
}
// The notification window looks and acts like the Microsoft Instant Messaging window. It will pop up in the lower
// right hand corner of the screen with a title, the corporate logo and a chance to either accept or decline the
// opportunity for a match.
NotificationWindow notificationWindow = new NotificationWindow();
notificationWindow.MatchId = matchId;
notificationWindow.Symbol = symbol;
notificationWindow.Message = title;
notificationWindow.CompanyLogo = logo;
notificationWindow.Accept += new MatchEventHandler(AcceptNegotiation);
notificationWindow.Decline += new MatchEventHandler(DeclineNegotiation);
notificationWindow.ChangeOptions += new EventHandler(ChangeOptions);
notificationWindow.Show();
}
public WorkingOrderElement(WorkingOrderDocument workingOrderDocument, ClientMarketData.WorkingOrderRow workingOrderRow, FieldArray fields) :
base("WorkingOrder", workingOrderDocument)
{
// Aggregate all the data related to this staged order. This will work out the aggregates and distinct column
// operations.
if (fields[Field.SourceOrder] || fields[Field.DestinationOrder] || fields[Field.Execution] || fields[Field.Allocation])
{
AggregateFields(workingOrderRow);
}
// WorkingOrderId - Primary Key for this report.
AddAttribute("WorkingOrderId", workingOrderRow.WorkingOrderId);
// Status - Note that the status code is always provided to the DOM for color coding of the fields.
AddAttribute("StatusCode", workingOrderRow.StatusCode);
if (fields[Field.Status])
{
AddAttribute("StatusName", workingOrderRow.StatusRow.Mnemonic);
}
// Select a green flag for submitted records, a red flag for unsubmitted.
int imageIndex = -1;
switch (workingOrderRow.StatusCode)
{
case Status.Error:
imageIndex = ClientMarketData.Image.KeyImageExternalId0.Find("Error Small");
break;
case Status.Submitted:
imageIndex = ClientMarketData.Image.KeyImageExternalId0.Find("Flag Green Small");
break;
default:
imageIndex = ClientMarketData.Image.KeyImageExternalId0.Find("Flag Red Small");
break;
}
if (imageIndex != -1)
{
ClientMarketData.ImageRow imageRow =
(ClientMarketData.ImageRow)ClientMarketData.Image.KeyImageExternalId0[imageIndex].Row;
AddAttribute("StatusImage", imageRow.Image);
}
// Blotter
if (fields[Field.Blotter])
{
AddAttribute("Blotter", workingOrderRow.BlotterId);
AddAttribute("BlotterName", workingOrderRow.BlotterRow.ObjectRow.Name);
}
// SubmissionTypeCode
if (fields[Field.SubmissionTypeCode])
{
AddAttribute("SubmissionTypeCode", workingOrderRow.SubmissionTypeCode);
}
// IsBrokerMatch
if (fields[Field.IsBrokerMatch])
{
AddAttribute("IsBrokerMatch", workingOrderRow.IsBrokerMatch);
}
// IsInstitutionMatch
if (fields[Field.IsInstitutionMatch])
{
AddAttribute("IsInstitutionMatch", workingOrderRow.IsInstitutionMatch);
}
// IsHedgeMatch
if (fields[Field.IsHedgeMatch])
{
AddAttribute("IsHedgeMatch", workingOrderRow.IsHedgeMatch);
}
// Auto-Execute - we always send the isAutomatic flag and the quantity
if (fields[Field.AutoExecute])
{
AddAttribute("IsAutomatic", workingOrderRow.IsAutomatic);
if (!workingOrderRow.IsAutomaticQuantityNull())
{
AddAttribute("AutomaticQuantity", workingOrderRow.AutomaticQuantity);
}
else
{
AddAttribute("AutomaticQuantity", 0);
}
}
// LimitPrice
if (fields[Field.LimitPrice])
{
if (!workingOrderRow.IsLimitPriceNull())
{
AddAttribute("LimitPrice", workingOrderRow.LimitPrice);
}
else
{
AddAttribute("LimitPrice", 0);
}
}
// OrderType
if (fields[Field.OrderType])
{
AddAttribute("OrderTypeCode", workingOrderRow.OrderTypeCode);
AddAttribute("OrderTypeDescription", workingOrderRow.OrderTypeRow.Description);
AddAttribute("OrderTypeMnemonic", workingOrderRow.OrderTypeRow.Mnemonic);
AddAttribute("CashSign", workingOrderRow.OrderTypeRow.CashSign);
AddAttribute("QuantitySign", workingOrderRow.OrderTypeRow.QuantitySign);
// Select a green flag for submitted records, a red flag for unsubmitted.
int orderTypeImageIndex = -1;
switch (workingOrderRow.OrderTypeCode)
{
case OrderType.Buy:
orderTypeImageIndex = ClientMarketData.Image.KeyImageExternalId0.Find("Navigate Plain Green Small");
break;
case OrderType.Sell:
orderTypeImageIndex = ClientMarketData.Image.KeyImageExternalId0.Find("Navigate Plain Red Small");
break;
}
if (orderTypeImageIndex != -1)
{
ClientMarketData.ImageRow imageRow =
(ClientMarketData.ImageRow)ClientMarketData.Image.KeyImageExternalId0[orderTypeImageIndex].Row;
AddAttribute("OrderTypeImage", imageRow.Image);
}
}
// TimeInForce
if (fields[Field.TimeInForce])
{
AddAttribute("TimeInForceCode", workingOrderRow.TimeInForceRow.TimeInForceCode);
AddAttribute("TimeInForceName", workingOrderRow.TimeInForceRow.Mnemonic);
}
// Security
if (fields[Field.Security])
{
AddAttribute("SecurityId", workingOrderRow.SecurityRowBySecurityWorkingOrderSecurityId.SecurityId);
AddAttribute("SecuritySymbol", workingOrderRow.SecurityRowBySecurityWorkingOrderSecurityId.Symbol);
AddAttribute("SecurityName", workingOrderRow.SecurityRowBySecurityWorkingOrderSecurityId.ObjectRow.Name);
if (!workingOrderRow.SecurityRowBySecurityWorkingOrderSecurityId.IsMarketCapitalizationNull())
{
AddAttribute("MarketCapitalization", workingOrderRow.SecurityRowBySecurityWorkingOrderSecurityId.MarketCapitalization / 1000000.0m);
}
if (!workingOrderRow.SecurityRowBySecurityWorkingOrderSecurityId.IsAverageDailyVolumeNull())
{
AddAttribute("AverageDailyVolume", workingOrderRow.SecurityRowBySecurityWorkingOrderSecurityId.AverageDailyVolume / 1000.0m);
}
AddAttribute("VolumeCategoryMnemonic", workingOrderRow.SecurityRowBySecurityWorkingOrderSecurityId.VolumeCategoryRow.Mnemonic);
}
// Source Order Total Quantity
if (fields[Field.SourceOrder])
{
AddAttribute("SourceOrderQuantity", this.totalSourceOrderedQuantity);
}
// Destination Order Total Quantity
if (fields[Field.DestinationOrder])
{
AddAttribute("DestinationOrderQuantity", this.totalDestinationOrderedQuantity);
}
// Total Executed Quantity and Average Price
if (fields[Field.SubmittedQuantity])
{
AddAttribute("SubmittedQuantity", workingOrderRow.SubmittedQuantity);
}
// Total Executed Quantity and Average Price
if (fields[Field.Execution])
{
AddAttribute("ExecutedQuantity", this.totalExecutedQuantity);
AddAttribute("AveragePrice", this.averagePriceExecuted);
}
// Total Quantity Allocated
if (fields[Field.Allocation])
{
AddAttribute("AllocatedQuantity", this.totalAllocatedQuantity);
}
// Working Order Leaves (Total Source Quantity - Total Destination Quantity)
if (fields[Field.SourceOrder] || fields[Field.DestinationOrder])
{
AddAttribute("LeavesQuantity", this.totalLeavesQuantity);
}
// Working Order Working Quantity (Total Source Quantity - Total Executed Quantity)
if (fields[Field.SourceOrder] || fields[Field.Execution])
{
AddAttribute("WorkingQuantity", this.totalWorkingQuantity);
}
// Start Time
if (fields[Field.StartTime] && !workingOrderRow.IsStartTimeNull())
{
AddAttribute("StartTime", workingOrderRow.StartTime.ToString("s"));
}
// Stop Time
if (fields[Field.StopTime] && !workingOrderRow.IsStopTimeNull())
{
AddAttribute("StopTime", workingOrderRow.StopTime.ToString("s"));
}
// Maxmimum Volatility
if (fields[Field.MaximumVolatility] && !workingOrderRow.IsMaximumVolatilityNull())
{
AddAttribute("MaximumVolatility", workingOrderRow.MaximumVolatility);
}
// News Free Time
if (fields[Field.NewsFreeTime] && !workingOrderRow.IsNewsFreeTimeNull())
{
AddAttribute("NewsFreeTime", workingOrderRow.NewsFreeTime);
}
// Timer Field
if (fields[Field.Timer])
{
TimeSpan timeLeft = workingOrderRow.TimerRow.StopTime.Subtract(workingOrderRow.TimerRow.CurrentTime);
AddAttribute("TimeLeft", string.Format("{0:0}:{1:00}", timeLeft.Minutes, timeLeft.Seconds));
}
// The Working Order Fields
if (fields[Field.WorkingOrder])
{
// Created
AddAttribute("CreatedName", workingOrderRow.UserRowByUserWorkingOrderCreatedUserId.ObjectRow.Name);
AddAttribute("CreatedTime", workingOrderRow.CreatedTime.ToString("s"));
// Destination
if (!workingOrderRow.IsDestinationIdNull())
{
AddAttribute("DestinationId", workingOrderRow.DestinationRow.DestinationId);
AddAttribute("DestinationName", workingOrderRow.DestinationRow.Name);
AddAttribute("DestinationShortName", workingOrderRow.DestinationRow.ShortName);
}
// The Direction of this order (buy, sell, buy cover, etc.)
AddAttribute("PriceTypeCode", workingOrderRow.PriceTypeRow.PriceTypeCode);
AddAttribute("PriceTypeMnemonic", workingOrderRow.PriceTypeRow.Mnemonic);
// Commission
AddAttribute("Commission", this.totalCommission);
// FilledNet
AddAttribute("NetMarketValue", this.totalMarketValue - workingOrderRow.OrderTypeRow.CashSign * this.totalCommission);
// Market
// AddAttribute("MarketId", workingOrderRow.SecurityRowByFKSecurityWorkingOrderSecurityId.MarketRow.MarketId);
// AddAttribute("MarketName", workingOrderRow.SecurityRowByFKSecurityWorkingOrderSecurityId.MarketRow.Name);
// AddAttribute("MarketShortName", workingOrderRow.SecurityRowByFKSecurityWorkingOrderSecurityId.MarketRow.ShortName);
// LimitPrice
// NOTE: LimitPrice is not sent when the WorkingOrder flag is set.
// LimitPrice has a separate bit set in the field arary
// Stop Price
if (!workingOrderRow.IsStopPriceNull())
{
AddAttribute("StopPrice", (decimal)workingOrderRow.StopPrice);
}
// TradeDate
AddAttribute("TradeDate", workingOrderRow.CreatedTime.ToString("s"));
// UploadTime
if (!workingOrderRow.IsUploadedTimeNull())
{
AddAttribute("UploadTime", workingOrderRow.CreatedTime.ToString("s"));
}
// CommissionType
// if (workingOrderRow != null)
// {
// ClientMarketData.CommissionRateTypeRow commissionRateTypeRow =
// ClientMarketData.CommissionRateType.FindByCommissionRateTypeCode((int)this.commissionRateTypeCode);
// AddAttribute("CommissionRateTypeCode", commissionRateTypeRow.CommissionRateTypeCode);
// AddAttribute("CommissionRateTypeName", commissionRateTypeRow.Name);
// AddAttribute("CommissionRate", this.averageCommissionRate);
// }
// Filled Gross
AddAttribute("MarketValue", this.totalMarketValue);
// Unfilled
AddAttribute("Unfilled", this.totalSourceOrderedQuantity - this.totalExecutedQuantity);
}
// Find the pricing record.
if (!workingOrderRow.IsSettlementIdNull())
{
ClientMarketData.PriceRow priceRow = ClientMarketData.Price.FindBySecurityId(workingOrderRow.SecurityId);
if (priceRow != null)
{
if (fields[Field.LastPrice])
{
AddAttribute("LastPrice", priceRow.LastPrice);
}
if (fields[Field.BidPrice])
{
AddAttribute("BidPrice", priceRow.BidPrice);
}
if (fields[Field.AskPrice])
{
AddAttribute("AskPrice", priceRow.AskPrice);
}
if (fields[Field.LastSize])
{
AddAttribute("LastSize", priceRow.LastSize);
}
if (fields[Field.BidSize])
{
AddAttribute("BidSize", priceRow.BidSize);
}
if (fields[Field.AskPrice])
{
AddAttribute("AskSize", priceRow.AskSize);
}
if (fields[Field.Volume])
{
AddAttribute("Volume", priceRow.Volume);
}
if (fields[Field.InterpolatedVolume])
{
AddAttribute("InterpolatedVolume", VolumeHelper.CurrentVolumePercentage(DateTime.Now,
workingOrderRow.SecurityRowBySecurityWorkingOrderSecurityId.AverageDailyVolume,
priceRow.Volume));
}
if (fields[Field.VolumeWeightedAveragePrice])
{
AddAttribute("VolumeWeightedAveragePrice", priceRow.VolumeWeightedAveragePrice);
}
}
}
}
/// <summary>
/// Creates a well formed working order document object model from fragments of data.
/// </summary>
/// <param name="fragmentList">A collection of fragments to be added/removed from the document in the viewer.</param>
public WorkingOrderDocument(FragmentList fragmentList)
{
try
{
// Lock the tables
System.Diagnostics.Debug.Assert(!ClientMarketData.IsLocked);
ClientMarketData.BlotterLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.SourceOrderLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.DestinationLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.DestinationOrderLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.ExecutionLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.ImageLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.ObjectLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.ObjectTreeLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.OrderTypeLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.PriceTypeLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.PriceLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.SecurityLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.StatusLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.StylesheetLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.TimeInForceLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.TimerLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.UserLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.WorkingOrderLock.AcquireReaderLock(CommonTimeout.LockWait);
ClientMarketData.VolumeCategoryLock.AcquireReaderLock(CommonTimeout.LockWait);
// The root of the fragment document.
XmlNode fragmentNode = this.AppendChild(this.CreateElement("Fragment"));
// The insert, update and delete elements are only included only when there is data in those sections.
XmlNode insertNode = null;
XmlNode updateNode = null;
XmlNode deleteNode = null;
foreach (Fragment fragment in fragmentList)
{
// The generic record in the fragment is cast here to a WorkingOrderRow. By design, this is the only type of
// record that will be placed into the FragmentList.
ClientMarketData.WorkingOrderRow workingOrderRow = (ClientMarketData.WorkingOrderRow)fragment.Row;
// Insert, Update or Delete the fragment.
switch (fragment.DataAction)
{
case DataAction.Insert:
// The 'insert' element is optional until there is something to insert.
if (insertNode == null)
{
insertNode = fragmentNode.AppendChild(this.CreateElement("Insert"));
}
// Insert the record.
insertNode.AppendChild(new WorkingOrderElement(this, workingOrderRow, FieldArray.Set));
break;
case DataAction.Update:
// The 'update' element is optional until there is something to update.
if (updateNode == null)
{
updateNode = fragmentNode.AppendChild(this.CreateElement("Update"));
}
// Update individual properties of the record.
updateNode.AppendChild(new WorkingOrderElement(this, workingOrderRow, fragment.Fields));
break;
case DataAction.Delete:
// The 'delete' element is optional until there is something to delete.
if (deleteNode == null)
{
deleteNode = fragmentNode.AppendChild(this.CreateElement("Delete"));
}
// The original record can't be used (because it has been deleted, duh). A key is constructed from the data
// stored in the fragment list.
CommonElement commonElement = new CommonElement("WorkingOrder", this);
commonElement.AddAttribute("WorkingOrderId", (int)fragment.Key[0]);
deleteNode.AppendChild(commonElement);
break;
}
}
}
catch (Exception exception)
{
// Write the error and stack trace out to the event log.
EventLog.Error("{0}, {1}", exception.Message, exception.StackTrace);
}
finally
{
// Release the table locks.
if (ClientMarketData.BlotterLock.IsReaderLockHeld)
{
ClientMarketData.BlotterLock.ReleaseReaderLock();
}
if (ClientMarketData.SourceOrderLock.IsReaderLockHeld)
{
ClientMarketData.SourceOrderLock.ReleaseReaderLock();
}
if (ClientMarketData.DestinationLock.IsReaderLockHeld)
{
ClientMarketData.DestinationLock.ReleaseReaderLock();
}
if (ClientMarketData.DestinationOrderLock.IsReaderLockHeld)
{
ClientMarketData.DestinationOrderLock.ReleaseReaderLock();
}
if (ClientMarketData.ExecutionLock.IsReaderLockHeld)
{
ClientMarketData.ExecutionLock.ReleaseReaderLock();
}
if (ClientMarketData.ImageLock.IsReaderLockHeld)
{
ClientMarketData.ImageLock.ReleaseReaderLock();
}
if (ClientMarketData.ObjectLock.IsReaderLockHeld)
{
ClientMarketData.ObjectLock.ReleaseReaderLock();
}
if (ClientMarketData.ObjectTreeLock.IsReaderLockHeld)
{
ClientMarketData.ObjectTreeLock.ReleaseReaderLock();
}
if (ClientMarketData.OrderTypeLock.IsReaderLockHeld)
{
ClientMarketData.OrderTypeLock.ReleaseReaderLock();
}
if (ClientMarketData.PriceTypeLock.IsReaderLockHeld)
{
ClientMarketData.PriceTypeLock.ReleaseReaderLock();
}
if (ClientMarketData.PriceLock.IsReaderLockHeld)
{
ClientMarketData.PriceLock.ReleaseReaderLock();
}
if (ClientMarketData.SecurityLock.IsReaderLockHeld)
{
ClientMarketData.SecurityLock.ReleaseReaderLock();
}
if (ClientMarketData.StatusLock.IsReaderLockHeld)
{
ClientMarketData.StatusLock.ReleaseReaderLock();
}
if (ClientMarketData.StylesheetLock.IsReaderLockHeld)
{
ClientMarketData.StylesheetLock.ReleaseReaderLock();
}
if (ClientMarketData.TimeInForceLock.IsReaderLockHeld)
{
ClientMarketData.TimeInForceLock.ReleaseReaderLock();
}
if (ClientMarketData.TimerLock.IsReaderLockHeld)
{
ClientMarketData.TimerLock.ReleaseReaderLock();
}
if (ClientMarketData.UserLock.IsReaderLockHeld)
{
ClientMarketData.UserLock.ReleaseReaderLock();
}
if (ClientMarketData.WorkingOrderLock.IsReaderLockHeld)
{
ClientMarketData.WorkingOrderLock.ReleaseReaderLock();
}
if (ClientMarketData.VolumeCategoryLock.IsReaderLockHeld)
{
ClientMarketData.VolumeCategoryLock.ReleaseReaderLock();
}
System.Diagnostics.Debug.Assert(!ClientMarketData.IsLocked);
}
}
