/// <summary>Inserts a Order record.</summary>
/// <param name="transaction">Commits or rejects a set of commands as a unit</param>
/// <param name="blockOrderId">The value for the BlockOrderId column.</param>
/// <param name="accountId">The value for the AccountId column.</param>
/// <param name="securityId">The value for the SecurityId column.</param>
/// <param name="settlementId">The value for the SettlementId column.</param>
/// <param name="brokerId">The value for the BrokerId column.</param>
/// <param name="transactionTypeCode">The value for the TransactionTypeCode column.</param>
/// <param name="timeInForceCode">The value for the TimeInForceCode column.</param>
/// <param name="orderTypeCode">The value for the OrderTypeCode column.</param>
/// <param name="conditionCode">The value for the ConditionCode column.</param>
/// <param name="rowVersion">The value for the RowVersion column.</param>
/// <param name="isAgency">The value for the Agency column.</param>
/// <param name="quantity">The value for the Quantity column.</param>
/// <param name="price1">The value for the Price1 column.</param>
/// <param name="price2">The value for the Price2 column.</param>
/// <param name="note">The value for the Note column.</param>
/// <param name="createdTime">The value for the CreatedTime column.</param>
/// <param name="createdLoginId">The value for the CreatedLoginId column.</param>
/// <param name="modifiedTime">The value for the ModifiedTime column.</param>
/// <param name="modifiedLoginId">The value for the ModifiedLoginId column.</param>
public static int Insert(
Transaction transaction,
object blockOrderId,
object blotterId,
int accountId,
int securityId,
int settlementId,
object brokerId,
int transactionTypeCode,
int timeInForceCode,
int orderTypeCode,
object conditionCode,
ref long rowVersion,
object isAgency,
System.Decimal quantity,
object price1,
object price2,
object note)
{
// The rowVersion of the block order is declared here, but it is not passed back to the caller.
long rowVersionBlockOrder = long.MinValue;
// This will find a block order for the order, or create a block order if one is needed. The order must be associated
// with a block at all times.
if (blockOrderId == null)
{
// If the blotter wasn't provided, then find a blotter using the mapping of securities to blotters.
if (blotterId == null)
{
ServerMarketData.SecurityRow securityRow = ServerMarketData.Security.FindBySecurityId(securityId);
if (securityRow == null)
{
throw new Exception(string.Format("Security {0} does not exist", securityId));
}
blotterId = TradingSupport.AutoRoute(securityRow, quantity);
}
// If the order hasn't been associated with a block order yet, then find open one up. The 'Open' method will
// either return a block that matches the attributes of the order -- and can still be blocked -- or it will create
// a new block based on the attributes of this new order.
blockOrderId = Shadows.WebService.Trading.BlockOrder.Open(transaction, (int)blotterId, accountId, securityId,
settlementId, brokerId, transactionTypeCode, timeInForceCode, orderTypeCode, conditionCode,
ref rowVersionBlockOrder, isAgency, price1, price2);
}
// These values are provided by the server.
int positionTypeCode = Shadows.Quasar.Common.TransactionType.GetPosition(transactionTypeCode);
DateTime createdTime = DateTime.Now;
int createdLoginId = ServerMarketData.LoginId;
// Call the internal method to add the order.
return(Shadows.WebService.Core.Order.Insert(transaction, (int)blockOrderId, accountId, securityId, settlementId, brokerId,
positionTypeCode, transactionTypeCode, timeInForceCode, orderTypeCode, conditionCode, ref rowVersion, null, null,
quantity, price1, price2, note, createdTime, createdLoginId, createdTime, createdLoginId));
}
private static void Update(RemoteBatch remoteBatch, RemoteTransaction remoteTransaction,
ClientMarketData.ProposedOrderRow parentProposedOrder, decimal quantityInstruction)
{
// These define the assembly and the types within those assemblies that will be used to create the proposed orders on
// the middle tier.
RemoteAssembly remoteAssembly = remoteBatch.Assemblies.Add("Service.Core");
RemoteType proposedOrderType = remoteAssembly.Types.Add("Shadows.WebService.Core.ProposedOrder");
ClientMarketData.AccountRow accountRow = parentProposedOrder.AccountRow;
ClientMarketData.SecurityRow securityRow = parentProposedOrder.SecurityRowByFKSecurityProposedOrderSecurityId;
// This will turn the signed quantity into an absolute quantity and a transaction code (e.g. -1000 is turned into a
// SELL of 1000 shares).
decimal parentQuantity = Math.Abs(quantityInstruction);
int parentTransactionTypeCode = TransactionType.Calculate(securityRow.SecurityTypeCode,
parentProposedOrder.PositionTypeCode, quantityInstruction);
// The time in force first comes from the user preferences, next, account settings and finally defaults to a day
// orders.
int timeInForceCode = !ClientPreferences.IsTimeInForceCodeNull() ? ClientPreferences.TimeInForceCode :
!accountRow.IsTimeInForceCodeNull() ? accountRow.TimeInForceCode : TimeInForce.DAY;
// The destination blotter comes first from the user preferences, second from the account preferences, and finally uses
// the auto-routing logic.
int blotterId = !ClientPreferences.IsBlotterIdNull() ? ClientPreferences.BlotterId :
!accountRow.IsBlotterIdNull() ? accountRow.BlotterId :
TradingSupport.AutoRoute(securityRow, parentQuantity);
// Create a command to update the proposed order.
RemoteMethod updateParent = proposedOrderType.Methods.Add("Update");
updateParent.Transaction = remoteTransaction;
updateParent.Parameters.Add("rowVersion", parentProposedOrder.RowVersion);
updateParent.Parameters.Add("proposedOrderId", parentProposedOrder.ProposedOrderId);
updateParent.Parameters.Add("accountId", parentProposedOrder.AccountId);
updateParent.Parameters.Add("securityId", parentProposedOrder.SecurityId);
updateParent.Parameters.Add("settlementId", parentProposedOrder.SettlementId);
updateParent.Parameters.Add("blotterId", blotterId);
updateParent.Parameters.Add("positionTypeCode", parentProposedOrder.PositionTypeCode);
updateParent.Parameters.Add("transactionTypeCode", parentTransactionTypeCode);
updateParent.Parameters.Add("timeInForceCode", timeInForceCode);
updateParent.Parameters.Add("orderTypeCode", OrderType.Market);
updateParent.Parameters.Add("quantity", parentQuantity);
foreach (ClientMarketData.ProposedOrderTreeRow proposedOrderTree in
parentProposedOrder.GetProposedOrderTreeRowsByFKProposedOrderProposedOrderTreeParentId())
{
ClientMarketData.ProposedOrderRow childProposedOrder =
proposedOrderTree.ProposedOrderRowByFKProposedOrderProposedOrderTreeChildId;
// If this is the settlement part of the order, then adjust the quantity.
if (childProposedOrder.SecurityId == parentProposedOrder.SettlementId)
{
// The settlement security is needed for the calculation of the cash impact of this trade.
ClientMarketData.CurrencyRow currencyRow =
MarketData.Currency.FindByCurrencyId(childProposedOrder.SettlementId);
decimal marketValue = parentQuantity * securityRow.QuantityFactor *
Price.Security(currencyRow, securityRow) * securityRow.PriceFactor *
TransactionType.GetCashSign(parentTransactionTypeCode);
decimal childQuantity = Math.Abs(marketValue);
int childTransactionTypeCode = TransactionType.Calculate(securityRow.SecurityTypeCode,
parentProposedOrder.PositionTypeCode, marketValue);
// Create a command to update the proposed order.
RemoteMethod updateChild = proposedOrderType.Methods.Add("Update");
updateChild.Transaction = remoteTransaction;
updateChild.Parameters.Add("rowVersion", childProposedOrder.RowVersion);
updateChild.Parameters.Add("proposedOrderId", childProposedOrder.ProposedOrderId);
updateChild.Parameters.Add("accountId", childProposedOrder.AccountId);
updateChild.Parameters.Add("securityId", childProposedOrder.SecurityId);
updateChild.Parameters.Add("settlementId", childProposedOrder.SettlementId);
updateChild.Parameters.Add("blotterId", blotterId);
updateChild.Parameters.Add("positionTypeCode", parentProposedOrder.PositionTypeCode);
updateChild.Parameters.Add("transactionTypeCode", childTransactionTypeCode);
updateChild.Parameters.Add("timeInForceCode", timeInForceCode);
updateChild.Parameters.Add("orderTypeCode", OrderType.Market);
updateChild.Parameters.Add("quantity", childQuantity);
}
}
}
/// <summary>
/// Creates a command in a RemoteBatch structure to insert a proposed order.
/// </summary>
/// <param name="remoteBatch"></param>
/// <param name="remoteTransaction"></param>
/// <param name="accountRow"></param>
/// <param name="securityRow"></param>
/// <param name="positionTypeCode"></param>
/// <param name="quantityInstruction"></param>
private static void Insert(RemoteBatch remoteBatch, RemoteTransaction remoteTransaction,
ClientMarketData.AccountRow accountRow, ClientMarketData.SecurityRow securityRow, int positionTypeCode,
decimal quantityInstruction)
{
// These define the assembly and the types within those assemblies that will be used to create the proposed orders on
// the middle tier.
RemoteAssembly remoteAssembly = remoteBatch.Assemblies.Add("Service.Core");
RemoteType proposedOrderType = remoteAssembly.Types.Add("Shadows.WebService.Core.ProposedOrder");
RemoteType proposedOrderTreeType = remoteAssembly.Types.Add("Shadows.WebService.Core.ProposedOrderTree");
// Find the default settlement for this order.
int settlementId = Shadows.Quasar.Common.Security.GetDefaultSettlementId(securityRow);
// As a convention between the rebalancing section and the order generation, the parentQuantity passed into this method
// is a signed value where the negative values are treated as 'Sell' instructions and the positive values meaning
// 'Buy'. This will adjust the parentQuantity so the trading methods can deal with an unsigned value, which is more
// natural for trading.
decimal parentQuantity = Math.Abs(quantityInstruction);
// This will turn the signed parentQuantity into an absolute parentQuantity and a transaction code (e.g. -1000 is
// turned into a SELL of 1000 shares).
int parentTransactionTypeCode = TransactionType.Calculate(securityRow.SecurityTypeCode, positionTypeCode, quantityInstruction);
// The time in force first comes from the user preferences, next, account settings and finally defaults to a day
// orders.
int timeInForceCode = !ClientPreferences.IsTimeInForceCodeNull() ?
ClientPreferences.TimeInForceCode : !accountRow.IsTimeInForceCodeNull() ? accountRow.TimeInForceCode :
TimeInForce.DAY;
// The destination blotter comes first from the user preferences, second from the account preferences, and finally uses
// the auto-routing logic.
int parentBlotterId = ClientPreferences.IsBlotterIdNull() ? (accountRow.IsBlotterIdNull() ?
TradingSupport.AutoRoute(securityRow, parentQuantity) : accountRow.BlotterId) : ClientPreferences.BlotterId;
// Create a command to delete the relationship between the parent and child.
RemoteMethod insertParent = proposedOrderType.Methods.Add("Insert");
insertParent.Transaction = remoteTransaction;
insertParent.Parameters.Add("proposedOrderId", DataType.Int, Direction.ReturnValue);
insertParent.Parameters.Add("blotterId", parentBlotterId);
insertParent.Parameters.Add("accountId", accountRow.AccountId);
insertParent.Parameters.Add("securityId", securityRow.SecurityId);
insertParent.Parameters.Add("settlementId", settlementId);
insertParent.Parameters.Add("positionTypeCode", positionTypeCode);
insertParent.Parameters.Add("transactionTypeCode", parentTransactionTypeCode);
insertParent.Parameters.Add("timeInForceCode", timeInForceCode);
insertParent.Parameters.Add("orderTypeCode", OrderType.Market);
insertParent.Parameters.Add("quantity", parentQuantity);
// Now it's time to create an order for the settlement currency.
if (securityRow.SecurityTypeCode == SecurityType.Equity || securityRow.SecurityTypeCode == SecurityType.Debt)
{
// The underlying currency is needed for the market value calculations.
ClientMarketData.CurrencyRow currencyRow = MarketData.Currency.FindByCurrencyId(settlementId);
decimal marketValue = parentQuantity * securityRow.QuantityFactor * Price.Security(currencyRow, securityRow)
* securityRow.PriceFactor * TransactionType.GetCashSign(parentTransactionTypeCode);
// The stragegy for handling the settlement currency changes is to calculate the old market value, calculate the
// new market value, and add the difference to the running total for the settlement currency of this security. The
// new market value is the impact of the trade that was just entered.
int childTransactionTypeCode = TransactionType.Calculate(securityRow.SecurityTypeCode, positionTypeCode,
marketValue);
decimal childQuantity = Math.Abs(marketValue);
// The destination blotter comes first from the user preferences, second from the account preferences, and finally
// uses the auto-routing logic.
int childBlotterId = ClientPreferences.IsBlotterIdNull() ? (accountRow.IsBlotterIdNull() ?
TradingSupport.AutoRoute(currencyRow.SecurityRow, childQuantity) : accountRow.BlotterId) :
ClientPreferences.BlotterId;
// Fill in the rest of the fields and the defaulted fields for this order. Create a command to delete the
// relationship between the parent and child.
RemoteMethod insertChild = proposedOrderType.Methods.Add("Insert");
insertChild.Transaction = remoteTransaction;
insertChild.Parameters.Add("proposedOrderId", DataType.Int, Direction.ReturnValue);
insertChild.Parameters.Add("blotterId", childBlotterId);
insertChild.Parameters.Add("accountId", accountRow.AccountId);
insertChild.Parameters.Add("securityId", settlementId);
insertChild.Parameters.Add("settlementId", settlementId);
insertChild.Parameters.Add("transactionTypeCode", childTransactionTypeCode);
insertChild.Parameters.Add("positionTypeCode", positionTypeCode);
insertChild.Parameters.Add("timeInForceCode", timeInForceCode);
insertChild.Parameters.Add("orderTypeCode", OrderType.Market);
insertChild.Parameters.Add("quantity", childQuantity);
RemoteMethod insertRelation = proposedOrderTreeType.Methods.Add("Insert");
insertRelation.Transaction = remoteTransaction;
insertRelation.Parameters.Add("parentId", insertParent.Parameters["proposedOrderId"]);
insertRelation.Parameters.Add("childId", insertChild.Parameters["proposedOrderId"]);
}
}
