public DeleteArgs(long rowVersion, int orderId, ClientMarketData.OrderRow SetPrice) { // Initialize Members this.rowVersion = rowVersion; this.orderId = orderId; this.SetPrice = SetPrice; }
public void Initialize(ClientMarketData.OrderRow orderRow) { this.orderId = orderRow.OrderId; this.transactionType = (TransactionType)orderRow.TransactionTypeCode; this.tif = (TIF)orderRow.TimeInForceCode; this.pricedAt = (PricedAt)orderRow.OrderTypeCode; this.quantity = orderRow.Quantity; this.price1 = orderRow.IsPrice1Null() ? (object)null : orderRow.Price1; this.price2 = orderRow.IsPrice2Null() ? (object)null : orderRow.Price2; }
public OrdersElement(BlockOrderDocument blockOrderDocument, ClientMarketData.OrderRow orderRow) : base("Order", blockOrderDocument) { this.orderRow = orderRow; AddAttribute("OrderId", this.orderRow.OrderId); AddAttribute("AccountId", this.orderRow.AccountId); AddAttribute("SecurityId", this.orderRow.SecurityId); AddAttribute("SecurityName", this.orderRow.SecurityRowByFKSecurityOrderSecurityId.ObjectRow.Name); AddAttribute("SecuritySymbol", this.orderRow.SecurityRowByFKSecurityOrderSecurityId.Symbol); AddAttribute("SettlementName", this.orderRow.SecurityRowByFKSecurityOrderSettlementId.ObjectRow.Name); AddAttribute("SettlementSymbol", this.orderRow.SecurityRowByFKSecurityOrderSettlementId.Symbol); AddAttribute("PositionTypeCode", this.orderRow.PositionTypeCode); AddAttribute("TransactionTypeCode", this.orderRow.TransactionTypeCode); AddAttribute("TransactionTypeName", this.orderRow.TransactionTypeRow.Mnemonic); AddAttribute("Quantity", this.orderRow.Quantity); AddAttribute("TimeInForceCode", this.orderRow.TimeInForceCode); AddAttribute("TimeInForceName", this.orderRow.TimeInForceRow.Mnemonic); AddAttribute("OrderTypeCode", this.orderRow.OrderTypeCode); AddAttribute("OrderTypeName", this.orderRow.OrderTypeRow.Mnemonic); ClientMarketData.PriceRow priceRow = ClientMarketData.Price.FindBySecurityIdCurrencyId( this.orderRow.SecurityId, this.orderRow.SettlementId); if (priceRow != null) { AddAttribute("LastPrice", priceRow.LastPrice); AddAttribute("BidPrice", priceRow.BidPrice); AddAttribute("BidSize", priceRow.BidSize); AddAttribute("AskPrice", priceRow.AskPrice); AddAttribute("AskSize", priceRow.AskSize); } if (!this.orderRow.IsPrice1Null()) { AddAttribute("Price1", this.orderRow.Price1); } if (!this.orderRow.IsPrice2Null()) { AddAttribute("Price2", this.orderRow.Price2); } if (!this.orderRow.IsConditionCodeNull()) { AddAttribute("ConditionCode", this.orderRow.ConditionCode); } if (!this.orderRow.IsNoteNull()) { AddAttribute("Note", this.orderRow.Note); } }
/// <summary> /// Creates a denormalized order record from a global record. /// </summary> /// <param name="globalOrder"></param> /// <returns></returns> public static OrderSet.OrderRow Create(ClientMarketData.OrderRow globalOrder) { // Create a new order record from the record factory. OrderSet.OrderRow orderRow = orderSet.Order.NewOrderRow(); // These records are global and use the global system of identifiers. orderRow.IsLocal = false; // Copy each field that has an analog in the local record set into the new record. foreach (DataColumn dataColumn in globalOrder.Table.Columns) { orderRow[dataColumn.ColumnName] = globalOrder[dataColumn]; } // AccountId cross-referenced data is filled in here. orderRow.AccountMnemonic = globalOrder.AccountRow.Mnemonic; orderRow.AccountName = globalOrder.AccountRow.ObjectRow.Name; // SecurityId cross-referenced data is filled in here. orderRow.SecuritySymbol = globalOrder.SecurityRowByFKSecurityOrderSecurityId.Symbol; orderRow.SecurityName = globalOrder.SecurityRowByFKSecurityOrderSecurityId.ObjectRow.Name; // CurrencyId cross-referenced data is filled in here. orderRow.SettlementSymbol = globalOrder.SecurityRowByFKSecurityOrderSettlementId.Symbol; orderRow.SettlementName = globalOrder.SecurityRowByFKSecurityOrderSettlementId.ObjectRow.Name; // BrokerId cross-referenced data is filled in here. if (!globalOrder.IsBrokerIdNull()) { ClientMarketData.BrokerRow brokerRow = ClientMarketData.Broker.FindByBrokerId(globalOrder.BrokerId); if (brokerRow != null) { orderRow.BrokerSymbol = brokerRow.Symbol; orderRow.BrokerName = brokerRow.ObjectRow.Name; } } // TimeInForce cross-referenced data is filled in here. orderRow.TimeInForceMnemonic = globalOrder.TimeInForceRow.Mnemonic; // TimeInForce cross-referenced data is filled in here. orderRow.OrderTypeMnemonic = globalOrder.OrderTypeRow.Mnemonic; // This is a complete record of the order, including the referenced data. return(orderRow); }
/// <summary> /// Creates a proposed order record. /// </summary> /// <param name="orderRow">A proposed order record from the primary ADO database.</param> /// <returns>A Order record based on the ADO record.</returns> internal static Order Make(ClientMarketData.OrderRow orderRow) { // Initialize the object DataRowVersion dataRowVersion = orderRow.RowState == DataRowState.Deleted ? DataRowVersion.Original : DataRowVersion.Current; // Extract the data from the ADO record. int orderId = (int)orderRow[ClientMarketData.Order.OrderIdColumn, dataRowVersion]; TransactionType transactionType = (TransactionType)orderRow[ClientMarketData.Order.TransactionTypeCodeColumn, dataRowVersion]; int accountId = (int)orderRow[ClientMarketData.Order.AccountIdColumn, dataRowVersion]; int securityId = (int)orderRow[ClientMarketData.Order.SecurityIdColumn, dataRowVersion]; int positionTypeCode = Common.TransactionType.GetPosition((int)transactionType); Position position = Position.Make(accountId, securityId, positionTypeCode); TIF tif = (TIF)orderRow[ClientMarketData.Order.TimeInForceCodeColumn, dataRowVersion]; PricedAt pricedAt = (PricedAt)orderRow[ClientMarketData.Order.OrderTypeCodeColumn, dataRowVersion]; decimal quantity = (decimal)orderRow[ClientMarketData.Order.QuantityColumn, dataRowVersion]; object price1 = orderRow[ClientMarketData.Order.Price1Column, dataRowVersion]; object price2 = orderRow[ClientMarketData.Order.Price2Column, dataRowVersion]; // Create a new record based on the data extracted from the ADO database. return(new Order(orderId, position, tif, pricedAt, quantity, price1, price2)); }
/// <summary> /// Handles the primary Market Data events and passes the events along to the Langauge Primitives. /// </summary> /// <param name="sender">The object that originated the event.</param> /// <param name="orderRowChangeEvent">The record change event argument.</param> public static void OrderHandler(object sender, ClientMarketData.OrderRowChangeEvent orderRowChangeEvent) { // Extract the record from the event argument. ClientMarketData.OrderRow orderRow = orderRowChangeEvent.Row; // Translate the ADO.NET row states into a record state used by the Rules Engine. Action action = Action.Nothing; switch (orderRowChangeEvent.Action) { case DataRowAction.Add: action = Action.Add; break; case DataRowAction.Delete: action = Action.Delete; break; case DataRowAction.Change: action = Action.Change; break; case DataRowAction.Commit: return; } // Place the event into a list that will be processed when the tables are no longer locked. Order.orderEventArgList.Add(new OrderEventArgs(action, Order.Make(orderRow))); }
/// <summary> /// Creates an element in the Appraisal Document that represents a fund's or account's position. /// </summary> /// <param name="appraisalDocument">The parent document.</param> /// <param name="driverAccount">Identifies the individual position at the account/security/position level.</param> public AccountElement(AppraisalDocument appraisalDocument, AppraisalSet.AccountRow driverAccount) : base("Account", appraisalDocument) { // Get the account record from the account id. This record drives most of the data that appears in this element. ClientMarketData.AccountRow accountRow = ClientMarketData.Account.FindByAccountId(driverAccount.AccountId); // Count up the compliance violations int violationCount = 0; foreach (DataRowView dataRowView in ClientMarketData.Violation.UKViolationAccountIdSecurityIdPositionTypeCode.FindRows( new object[] { driverAccount.AccountId, driverAccount.SecurityId, driverAccount.PositionTypeCode })) { ClientMarketData.ViolationRow violationRow = (ClientMarketData.ViolationRow)dataRowView.Row; if (violationRow.RestrictionRow.Severity > 0) { violationCount++; } } AddAttribute("Violation", violationCount); // Add the essential attributes to the element. AddAttribute("AccountId", accountRow.AccountId.ToString()); // Aggregate the tax lot positions and cost. decimal taxLotQuantity = 0.0M; decimal taxLotCost = 0.0M; foreach (ClientMarketData.TaxLotRow taxLotRow in accountRow.GetTaxLotRows()) { if (taxLotRow.SecurityId == driverAccount.SecurityId && taxLotRow.PositionTypeCode == driverAccount.PositionTypeCode) { taxLotQuantity += taxLotRow.Quantity; taxLotCost += taxLotRow.Cost * taxLotRow.Quantity; } } AddAttribute("TaxLotQuantity", taxLotQuantity.ToString()); AddAttribute("TaxLotCost", taxLotCost.ToString()); // Aggregate the proposed orders positions. decimal proposedOrderQuantity = 0.0M; foreach (DataRowView dataRowView in appraisalDocument.proposedOrderView.FindRows(new object[] { driverAccount.AccountId, driverAccount.SecurityId, driverAccount.PositionTypeCode })) { ClientMarketData.ProposedOrderRow proposedOrderRow = (ClientMarketData.ProposedOrderRow)dataRowView.Row; proposedOrderQuantity += proposedOrderRow.Quantity * proposedOrderRow.TransactionTypeRow.QuantitySign; } AddAttribute("ProposedOrderQuantity", proposedOrderQuantity.ToString()); // Aggregate the orders. decimal orderQuantity = 0.0M; foreach (DataRowView dataRowView in appraisalDocument.orderView.FindRows(new object[] { driverAccount.AccountId, driverAccount.SecurityId, driverAccount.PositionTypeCode })) { ClientMarketData.OrderRow orderRow = (ClientMarketData.OrderRow)dataRowView.Row; orderQuantity += orderRow.Quantity * orderRow.TransactionTypeRow.QuantitySign; } AddAttribute("OrderQuantity", orderQuantity.ToString()); // Aggregate the allocations. decimal allocationQuantity = 0.0M; foreach (DataRowView dataRowView in appraisalDocument.allocationView.FindRows(new object[] { driverAccount.AccountId, driverAccount.SecurityId, driverAccount.PositionTypeCode })) { ClientMarketData.AllocationRow allocationRow = (ClientMarketData.AllocationRow)dataRowView.Row; allocationQuantity += allocationRow.Quantity * allocationRow.TransactionTypeRow.QuantitySign; } AddAttribute("AllocationQuantity", allocationQuantity.ToString()); }
public OrdersElement CreateOrdersElement(ClientMarketData.OrderRow orderRow) { return(new OrdersElement(this, orderRow)); }
public void Initialize(Account account, Security security, TransactionType transactionType, TIF tif, PricedAt pricedAt, decimal quantity, object price1, object price2) { // Create a block order on the server. RemoteBatch remoteBatch = new RemoteBatch(); RemoteAssembly remoteAssembly = remoteBatch.Assemblies.Add("Service.Trading"); RemoteType remoteType = remoteAssembly.Types.Add("Shadows.WebService.Trading.Order"); RemoteMethod remoteMethod = remoteType.Methods.Add("Insert"); remoteMethod.Parameters.Add("orderId", DataType.Int, Direction.ReturnValue); remoteMethod.Parameters.Add("accountId", account.AccountId); remoteMethod.Parameters.Add("securityId", security.SecurityId); remoteMethod.Parameters.Add("settlementId", security.SettlementId); remoteMethod.Parameters.Add("transactionTypeCode", (int)transactionType); remoteMethod.Parameters.Add("timeInForceCode", (int)tif); remoteMethod.Parameters.Add("orderTypeCode", (int)pricedAt); remoteMethod.Parameters.Add("quantity", quantity); remoteMethod.Parameters.Add("price1", price1 == null ? (object)DBNull.Value : price1); remoteMethod.Parameters.Add("price2", price2 == null ? (object)DBNull.Value : price2); ClientMarketData.Execute(remoteBatch); // Now that the block order is created, construct the in-memory version of the record. int orderId = (int)remoteMethod.Parameters["orderId"].Value; try { // Lock the tables. Debug.Assert(!ClientMarketData.AreLocksHeld); ClientMarketData.AccountLock.AcquireReaderLock(CommonTimeout.LockWait); ClientMarketData.OrderLock.AcquireReaderLock(CommonTimeout.LockWait); ClientMarketData.ObjectLock.AcquireReaderLock(CommonTimeout.LockWait); ClientMarketData.SecurityLock.AcquireReaderLock(CommonTimeout.LockWait); ClientMarketData.OrderRow orderRow = ClientMarketData.Order.FindByOrderId(orderId); if (orderRow == null) { throw new Exception(String.Format("Order {0} doesn't exist", orderId)); } Initialize(orderRow); } finally { // Release the table locks. if (ClientMarketData.AccountLock.IsReaderLockHeld) { ClientMarketData.AccountLock.ReleaseReaderLock(); } if (ClientMarketData.OrderLock.IsReaderLockHeld) { ClientMarketData.OrderLock.ReleaseReaderLock(); } if (ClientMarketData.ObjectLock.IsReaderLockHeld) { ClientMarketData.ObjectLock.ReleaseReaderLock(); } if (ClientMarketData.SecurityLock.IsReaderLockHeld) { ClientMarketData.SecurityLock.ReleaseReaderLock(); } Debug.Assert(!ClientMarketData.AreLocksHeld); } }