internal static TransactionBookData ToTransactionBookData(XmlNode tranNode)
{
string tranCode = string.Empty;
Guid? orderBatchInstructionId;
TransactionBookData tranData = TransactionParser.ParseTransactionBookData(tranNode, out orderBatchInstructionId);
tranData.Id = Guid.Parse(tranNode.Attributes["ID"].Value);
tranData.Orders = new List <OrderBookData>();
var instrument = InstrumentManager.Default.Get(tranData.InstrumentId);
InstrumentCategory instrumentCategory = instrument.Category;
foreach (XmlNode orderNode in tranNode.ChildNodes)
{
if (orderNode.Name == "Order")
{
OrderBookData orderData = null;
if (instrumentCategory == InstrumentCategory.Forex)
{
orderData = OrderDataHelper.InitializeBookData(orderNode);
}
else
{
orderData = OrderDataHelper.InitalizePhysicalBookData(orderNode);
}
orderData.OrderBatchInstructionID = orderBatchInstructionId;
tranData.Orders.Add(orderData);
}
}
tranData.PlaceByRiskMonitor = true;
return(tranData);
}
private static bool CanBeAmendedBy(this Transaction sourceTran, TransactionBookData tranData)
{
TransactionSubType tranSubType = tranData.SubType;
if (tranSubType == TransactionSubType.Amend)
{
Order order = sourceTran.FirstOrder;
return(sourceTran.OrderCount == 1 &&
order.IsOpen &&
tranData.SourceOrderId != null &&
order.Id == tranData.SourceOrderId &&
sourceTran.AccountId == tranData.AccountId &&
sourceTran.InstrumentId == tranData.InstrumentId &&
sourceTran.Type == tranData.Type &&
sourceTran.OrderType == tranData.OrderType &&
sourceTran.ContractSize(null) == tranData.ContractSize &&
sourceTran.BeginTime == tranData.BeginTime &&
sourceTran.EndTime == tranData.EndTime &&
sourceTran.SubmitTime == tranData.SubmitTime &&
sourceTran.ExecuteTime == tranData.ExecuteTime &&
sourceTran.SubmitorId == tranData.SubmitorId &&
sourceTran.ApproverId == tranData.ApproverId);
}
else
{
return(false);
}
}
private static TransactionCommonData ParseTransactionData(XmlNode tranNode, bool isBook, List <AttrInfo> infos)
{
TransactionCommonData tranData;
if (isBook)
{
tranData = new TransactionBookData();
}
else
{
tranData = new TransactionData();
}
AttrsParser.Parse(tranData, infos, tranNode);
return(tranData);
}
public TransactionError Book(Token token, TransactionBookData tranData, bool preserveCalculation)
{
return(this.CallByRead(() =>
{
var account = GetAccount(tranData.AccountId);
if (preserveCalculation)
{
Logger.Error("Book, preserveCalculation = true");
return TransactionError.RuntimeError;
}
else
{
return account.Book(token, tranData);
}
}, () => TransactionError.RuntimeError));
}
private static void VerifyAmentedOrder(this Account account, TransactionBookData tranData)
{
Transaction tran = account.GetTran(tranData.Id);
if (tran == null)
{
return;
}
if (tran.CanBeAmendedBy(tranData))
{
CancelExecute(tran);
account.RemoveTransaction(tran);
}
else
{
throw new TransactionServerException(TransactionError.TransactionAlreadyExists);
}
}
internal static TransactionBookData ParseTransactionBookData(XmlNode tranNode, out Guid?orderBatchInstructionId)
{
orderBatchInstructionId = null;
var attrInfos = new List <AttrInfo>(_attrInfos)
{
new AttrInfo("ExecuteTime", typeof(DateTime)),
new AttrInfo("CheckMargin", typeof(bool))
{
DefaultValue = false
},
new AttrInfo("ApproverID", typeof(Guid))
{
FieldName = "ApproverId"
}
};
TransactionBookData bookData = (TransactionBookData)ParseTransactionData(tranNode, true, attrInfos);
if (tranNode.HasAttribute("OrderBatchInstructionID"))
{
orderBatchInstructionId = XmlConvert.ToGuid(tranNode.GetAttrValue("OrderBatchInstructionID"));
}
return(bookData);
}
TransactionError ISystemController.Book(Token token, TransactionBookData tranData, bool preserveCalculation)
{
return(this.Server.Book(token, tranData, preserveCalculation));
}
public iExchange.Common.TransactionError Book(iExchange.Common.Token token, TransactionBookData tranData, bool preserveCalculation)
{
Logger.InfoFormat("Book order tranId = {0}", tranData.Id);
return(this.Call <TransactionError>(() => this.Service.Book(token, tranData, preserveCalculation)));
}
