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); } }