public Amount CreateAmount(OrderRecord order)
{
var currency = (order.CurrencyRecord == null) ? "MYR" : order.CurrencyRecord.Code;
currency = order.selectedCurrency == null ? currency : order.selectedCurrency;
var subtotal = _priceConverationService.ConvertPrice((order.TotalPriceWithPromo > 0 ? order.TotalPriceWithPromo : order.TotalPrice), order.Campaign.CurrencyRecord, currency).Value.ToString("0.00").Replace(",", ".");
var shipping = _priceConverationService.ConvertPrice(order.Delivery, order.Campaign.CurrencyRecord, currency).Value.ToString("0.00").Replace(",", ".");
var total = float.Parse(subtotal) + float.Parse(shipping); //_priceConverationService.ConvertPrice(((order.TotalPriceWithPromo > 0 ? order.TotalPriceWithPromo : order.TotalPrice) + order.Delivery), order.Campaign.CurrencyRecord, currency).Value;
var details = new Details
{
//(order.TotalPriceWithPromo > 0 ? order.TotalPriceWithPromo : order.TotalPrice)
subtotal = subtotal,
shipping = shipping,
tax = "0.00".Replace(",", "."),
fee = total.ToString("0.00").Replace(",", ".") //total.ToString("0.00").Replace(",", ".")
};
//var total = order.TotalPrice;
var amount = new Amount
{
currency = currency,
details = details,
total = total.ToString("0.00").Replace(",", ".")
};
return(amount);
}
private void SendOrder(Side side)
{
try
{
Trace.WriteLine(String.Format("Send New Order: Type={0} Side={1} Symbol=[{2}] Qty=[{3}] LimitPrice=[{4}] TIF={5}",
this.OrderType.ToString(), side.ToString(), this.Symbol,
this.OrderQtyString, this.LimitPriceString, this.TimeInForce.ToString()));
Dictionary <int, string> customFieldsDict = new Dictionary <int, string>();
foreach (CustomFieldRecord cfr in this.CustomFields)
{
customFieldsDict[cfr.Tag] = cfr.Value;
}
int orderQty = int.Parse(this.OrderQtyString);
decimal limitPrice = decimal.Parse(this.LimitPriceString);
QuickFix.FIX42.NewOrderSingle nos = MessageCreator42.NewOrderSingle(
customFieldsDict,
this.OrderType, side, this.Symbol, orderQty, this.TimeInForce, limitPrice);
OrderRecord r = new OrderRecord(nos);
lock (_ordersLock)
{
Orders.Add(r);
}
_qfapp.Send(nos);
}
catch (Exception e)
{
Trace.WriteLine("Failed to send order\n" + e.ToString());
}
}
public EditViewModel GetView(OrderRecord model, List <OrderDetailRecord> childs)
{
var view = new EditViewModel
{
Id = model.Id,
OrderNo = model.OrderNo,
Supplier = model.Supplier,
LinkPerson = model.LinkPerson,
Phone = model.Phone,
Tel = model.Tel,
Fax = model.Fax,
OrderDate = model.OrderDate.ToString("yyyy-MM-dd"),
DeliveryDate = model.DeliveryDate.ToString("yyyy-MM-dd"),
CreateTime = model.CreateTime.ToString("yyyy-MM-dd"),
Remark = model.Remark,
Contract = model.Contract,
Details = childs.Select(s => new OrderDetail.EditViewModel
{
Id = s.Id,
SortIndex = s.SortIndex,
Name = s.Name,
Size = s.Size,
Unit = s.Unit,
Total = s.Total,
Output = s.Output,
Remark = s.Remark
}).ToList()
};
return(view);
}
public void MarketSell()
{
UnitTestContext context = new UnitTestContext();
context.Login();
OrderViewModel vm = new OrderViewModel(context.App, new FIXApplication.NullFixStrategy());
vm.Symbol = "pants";
vm.OrderQtyString = "999";
vm.SendSellCommand.Execute(null);
// messaging of sent order
Assert.AreEqual(1, context.Session.MsgLookup[QuickFix.FIX42.NewOrderSingle.MsgType].Count);
QuickFix.FIX42.NewOrderSingle msg = context.Session.MsgLookup[QuickFix.FIX42.NewOrderSingle.MsgType][0] as QuickFix.FIX42.NewOrderSingle;
Assert.AreEqual("pants", msg.Symbol.Obj);
Assert.AreEqual(999, msg.OrderQty.Obj);
Assert.AreEqual(QuickFix.Fields.Side.SELL, msg.Side.Obj);
// what's in the grid
Assert.AreEqual(1, vm.Orders.Count);
OrderRecord o = vm.Orders.First();
Assert.AreEqual("pants", o.Symbol);
Assert.AreEqual(-1, o.Price);
Assert.AreEqual("Market", o.OrdType);
Assert.AreEqual("Sell", o.Side);
}
public void DefaultBuyOrder()
{
UnitTestContext context = new UnitTestContext();
context.Login();
OrderViewModel vm = new OrderViewModel(context.App, new FIXApplication.NullFixStrategy());
vm.SendBuyCommand.Execute(null);
// messaging of sent order
Assert.AreEqual(1, context.Session.MsgLookup[QuickFix.FIX42.NewOrderSingle.MsgType].Count);
QuickFix.FIX42.NewOrderSingle msg = context.Session.MsgLookup[QuickFix.FIX42.NewOrderSingle.MsgType][0] as QuickFix.FIX42.NewOrderSingle;
Assert.AreEqual("IBM", msg.Symbol.Obj);
Assert.AreEqual(5, msg.OrderQty.Obj);
Assert.AreEqual(QuickFix.Fields.OrdType.MARKET, msg.OrdType.Obj);
Assert.AreEqual(QuickFix.Fields.Side.BUY, msg.Side.Obj);
// what's in the grid
Assert.AreEqual(1, vm.Orders.Count);
OrderRecord o = vm.Orders.First();
Assert.AreEqual("IBM", o.Symbol);
Assert.AreEqual(-1, o.Price);
Assert.AreEqual("Market", o.OrdType);
Assert.AreEqual("Buy", o.Side);
}
public void LimitBuy()
{
UnitTestContext context = new UnitTestContext();
context.Login();
OrderViewModel vm = new OrderViewModel(context.App, new FIXApplication.NullFixStrategy());
vm.OrderType = FIXApplication.Enums.OrderType.Limit;
vm.Symbol = "LIM";
vm.OrderQtyString = "9";
vm.LimitPriceString = "3.45";
vm.SendBuyCommand.Execute(null);
// messaging of sent order
Assert.AreEqual(1, context.Session.MsgLookup[QuickFix.FIX42.NewOrderSingle.MsgType].Count);
QuickFix.FIX42.NewOrderSingle msg = context.Session.MsgLookup[QuickFix.FIX42.NewOrderSingle.MsgType][0] as QuickFix.FIX42.NewOrderSingle;
Assert.AreEqual("LIM", msg.Symbol.Obj);
Assert.AreEqual(9, msg.OrderQty.Obj);
Assert.AreEqual(3.45m, msg.Price.Obj);
Assert.AreEqual(QuickFix.Fields.OrdType.LIMIT, msg.OrdType.Obj);
Assert.AreEqual(QuickFix.Fields.Side.BUY, msg.Side.Obj);
// what's in the grid
Assert.AreEqual(1, vm.Orders.Count);
OrderRecord o = vm.Orders.First();
Assert.AreEqual("LIM", o.Symbol);
Assert.AreEqual(3.45m, o.Price);
Assert.AreEqual("Limit", o.OrdType);
Assert.AreEqual("Buy", o.Side);
}
private void HandleOrderExecutionEvent(OrderStatus status, OrderRecord order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
// TODO We need to handle suspended -> active
switch (status)
{
case OrderStatus.Canceled:
case OrderStatus.Filled:
case OrderStatus.Traded:
RemoveOrder(order);
break;
case OrderStatus.PartiallyFilled:
OnPartialFill(order);
break;
case OrderStatus.Suspended:
UpdateOrder(order);
break;
case OrderStatus.New:
AddOrUpdateOrder(order);
break;
case OrderStatus.Rejected:
OrderRejected(order);
break;
}
}
public ExecutionReport CreateReport(
OrderRecord record,
SQ.ExecType? execType,
SQ.OrderStatus? orderStatus)
{
ExecutionReport report = new ExecutionReport();
report.DateTime = framework.Clock.DateTime;
report.Order = record.Order;
report.Instrument = record.Order.Instrument;
report.Side = record.Order.Side;
report.OrdType = record.Order.Type;
report.TimeInForce = record.Order.TimeInForce;
report.OrdQty = record.Order.Qty;
report.Price = record.Order.Price;
report.StopPx = record.Order.StopPx;
report.AvgPx = record.AvgPx;
report.CumQty = record.CumQty;
report.LeavesQty = record.LeavesQty;
if (execType != null)
report.ExecType = execType.Value;
if (orderStatus != null)
report.OrdStatus = orderStatus.Value;
return report;
}
public bool UpdateOrder(OrderRecord oldOrderDetails, OrderRecord newOrderDetails)
{
// TODO This should use an ordercancelreplace
var fakeCancelClOrdID = oldOrderDetails.ClOrdID + "_Cancel";
var cancel = _fixMessageGenerator.CreateOrderCancelMessage(oldOrderDetails.Symbol,
oldOrderDetails.ClOrdID,
fakeCancelClOrdID,
oldOrderDetails.Side,
oldOrderDetails.OrderID);
if (!_app.Send(cancel))
{
return(false);
}
var add = _fixMessageGenerator.CreateNewOrderSingleMessage(newOrderDetails.Symbol,
newOrderDetails.Side,
newOrderDetails.ClOrdID,
TradingAccount.None,
newOrderDetails.Price,
newOrderDetails.Quantity,
OrderType.Limit,
_execIDGenerator.CreateExecID());
return(_app.Send(add));
}
private void Trade(OrderStackRow osr, MarketSide side)
{
if (osr == null)
{
throw new ArgumentNullException("osr");
}
// The server currently does not support click trading, so we fake
// it here by adding a matching order to the other side of the market.
// If the server supported ImmediateOrCancel then we'd use that.
var isBid = side == MarketSide.Bid;
var matchingOrderDetails = new OrderRecord
{
ClOrdID = _clOrdIDGenerator.CreateClOrdID(),
LastUpdateTime = DateTime.UtcNow,
OrderID = string.Empty, // Set by server
OrdType = OrderType.Limit,
Price = decimal.Parse(isBid ? osr.BidPrice : osr.AskPrice),
Quantity = decimal.Parse(isBid ? osr.BidQty : osr.AskQty),
Side = isBid ? MarketSide.Ask : MarketSide.Bid,
Symbol = osr.Symbol,
Status = OrderStatus.New
};
_serverFacade.CreateOrder(matchingOrderDetails);
}
public IEnumerable <OrderRecord> GetAllOrderRecords()
{
using (SqlConnection Connection = new SqlConnection(connectionString))
{
ICollection <OrderRecord> orderRecords = new Collection <OrderRecord>();
SqlCommand Command = new SqlCommand();
Command.Connection = Connection;
Command.CommandText = "SELECT * FROM VW_OrderRecords";
Connection.Open();
SqlDataReader reader = Command.ExecuteReader();
while (reader.Read())
{
OrderRecord record = new OrderRecord();
record.OrderId = Convert.ToInt32(reader["OrderId"]);
record.Address = reader["Address"].ToString();
record.DateTime = reader["Date"].ToString();
record.UserName = reader["UserName"].ToString();
record.TotalPrice = Convert.ToInt64(reader["TotalOrderPrice"]);
orderRecords.Add(record);
}
reader.Close();
Connection.Close();
return(orderRecords);
}
}
public void OnNotifyOrderResponseUpdated(object sender, OrderResponseEventArgs e)
{
try
{
MethodInvoker invoker = delegate()
{
System.Console.WriteLine("[InquiryHistoryForm] OnNotifyOrderResponseUpdated ( 응답 수신 )");
FileLogManager.GetInstance().WriteLog("[InquiryHistoryForm] OnNotifyOrderResponseUpdated( 응답 수신 )");
if (this.orderDetailForm == null || this.orderDetailForm.IsDisposed)
{
System.Console.WriteLine("[InquiryHistoryForm] OnNotifyOrderResponseUpdated ( 상세 표시 중이 아님. )");
FileLogManager.GetInstance().WriteLog("[InquiryHistoryForm] OnNotifyOrderResponseUpdated( 상세 표시 중이 아님. )");
return;
}
if (this.lvOrderHistory.SelectedItems == null || this.lvOrderHistory.SelectedItems.Count < 1)
{
System.Console.WriteLine("[InquiryHistoryForm] OnNotifyOrderResponseUpdated ( 선택된 아이템이 없음 )");
FileLogManager.GetInstance().WriteLog("[InquiryHistoryForm] OnNotifyOrderResponseUpdated( 선택된 아이템이 없음 )");
return;
}
OrderRecord selectedRecord = this.lvOrderHistory.SelectedItems[0].Tag as OrderRecord;
if (selectedRecord == null)
{
System.Console.WriteLine("[InquiryHistoryForm] OnNotifyOrderResponseUpdated ( 선택된 아이템의 데이터 변환 오류 )");
FileLogManager.GetInstance().WriteLog("[InquiryHistoryForm] OnNotifyOrderResponseUpdated( 선택된 아이템의 데이터 변환 오류 )");
return;
}
if (e.ResponseInfo == null || e.ResponseInfo.Count < 1 || selectedRecord.CAPID != e.OrderRecordID)
{
System.Console.WriteLine("[InquiryHistoryForm] OnNotifyOrderResponseUpdated ( 상세 표시 중인 레코드와 응답 레코드가 다름 )");
FileLogManager.GetInstance().WriteLog("[InquiryHistoryForm] OnNotifyOrderResponseUpdated( 상세 표시 중인 레코드와 응답 레코드가 다름 )");
return;
}
this.orderDetailForm.UpdateOrderResponseInfo(e.ResponseInfo);
};
if (this.InvokeRequired)
{
Invoke(invoker);
}
else
{
invoker();
}
}
catch (Exception ex)
{
System.Console.WriteLine("[RecentlyOrderHistoryForm] OnNotifyOrderResponseUpdated ( Exception Occured!!!" + ex.ToString() + ")");
FileLogManager.GetInstance().WriteLog("[InquiryHistoryForm] OnNotifyOrderResponseUpdated( " + ex.ToString() + " )");
}
}
private Order GetOrder(OrderRecord record)
{
var id = new OrderIdentity(record.Id);
var customerId = new CustomerIdentity(record.CustomerId);
var status = record.OrderStatusId;
var orderDetails = record.OrderItems.Select(GetOrderItem).ToList().AsReadOnly();
return(new Order(id, customerId, DateTime.Now, status, orderDetails));
}
void OnAddOrderRecordRequest(IMessage msg, SessionEventArgs e)
{
var state = OrderRecordOptState.Failed;
OrderRecord orderRecord = msg.Obj as OrderRecord;
if (e.Session.SessionId != null)
{
try
{
orderRecord.UserId = (e.Session.SessionId as UserSessionIdMetaData).Id;
if (orderRecord.OrderStateId == 999999)
{
state = OrderRecordOptState.ReturnGold;
}
else
{
if (!_orderRecordBll.HasNotCompletedOrder(orderRecord.UserId,
orderRecord.ClientUserId, orderRecord.ClientUserSubAccountId))
{
if (_userBll.UpdateGold(orderRecord.UserId, -100))
{
state = OrderRecordOptState.DeductionGold;
}
}
if (orderRecord.OrderStateId >= 10 && orderRecord.OrderStateId <= 40)
{
_subAccountOrderTypeInfoBll.UpdateOrderTypeCount(
orderRecord.ClientUserSubAccountId, orderRecord.OrderTypeId.Value);
if (orderRecord.OrderStateId >= 20)
{
_subAccountUsageInfoBll.UpdateOrderCount(orderRecord.ClientUserSubAccountId);
}
}
}
if (!_orderRecordBll.Add(orderRecord))
{
state = OrderRecordOptState.Failed;
}
}
catch (Exception ex)
{
state = OrderRecordOptState.Failed;
ErrorLog(msg.Header.Type, ex);
}
}
else
{
state = OrderRecordOptState.InvalidOpt;
}
e.Session.Send(state, MessageType.AddOrderRecordResponse);
}
private OrderStack GetOrCreateStack(OrderRecord order)
{
var symbol = order.Symbol;
lock (_marketLock)
{
return(_market.GetOrCreate(symbol));
}
}
private static OrderRecord RemoveOrderImpl(List <OrderRecord> orders, OrderRecord order)
{
var existing = orders.FirstOrDefault(o => o.ClOrdID == order.ClOrdID);
if (existing != null)
{
orders.Remove(existing);
}
return(existing);
}
private ListOrdersRecordQueryResponse GetResponse(OrderRecord record)
{
var name = record.Id.ToString();
return(new ListOrdersRecordQueryResponse
{
Id = record.Id,
Name = name,
});
}
private OrderHeaderReadModel GetOrderHeaderReadModel(OrderRecord record)
{
var orderId = new OrderIdentity(record.Id);
var customerId = new CustomerIdentity(record.CustomerId);
var orderDate = record.OrderDate;
var status = (OrderStatus)record.OrderStatusId;
var totalPrice = record.OrderItems.Sum(e => e.UnitPrice * e.Quantity);
return(new OrderHeaderReadModel(orderId, customerId, orderDate, status, totalPrice));
}
public void Add(ViewModel.Order.AddForm form)
{
var orderDate = DateTime.Now;
var deliveryDate = DateTime.Now;
var details = new List <OrderDetailRecord>();
DateTime.TryParse(form.OrderDate, out orderDate);
DateTime.TryParse(form.DeliveryDate, out deliveryDate);
var model = new OrderRecord
{
OrderNo = form.OrderNo,
Supplier = form.Supplier,
LinkPerson = form.LinkPerson,
Phone = form.Phone,
Tel = form.Tel,
Fax = form.Fax,
OrderDate = orderDate,
DeliveryDate = deliveryDate,
Finished = 0,
CreateTime = DateTime.Now,
ModifyTime = DateTime.Now,
Address = form.Address,
Remark = form.Remark,
Contract = form.Contract
};
foreach (var det in form.Details)
{
details.Add(new OrderDetailRecord
{
SortIndex = det.SortIndex,
Name = det.Name,
Size = det.Size,
Unit = det.Unit,
Total = det.Total,
Output = det.Output,
Remark = det.Remark
});
}
try
{
int id = _thisDAL.Add(model);
foreach (var det in details)
{
det.Order_Id = id;
_orderDetailDal.Add(det);
}
}
catch (Exception e)
{
_thisDAL.AbortTransaction();
throw e;
}
}
public void RemoveShouldRemoveItemSuccefully()
{
var item3 = new OrderRecord()
{
Id = 3,
Status = "Received"
};
repository.Remove(item3);
Assert.That(!repository.listAll().Contains(item3));
}
public static void RemoveUserOrder(OrderRecord order)
{
if (order.m_type == 1)
{
MarketDatabase.CancelSellOrder(order.m_uniqueID, order.m_itemType, order.m_market);
}
else
{
MarketDatabase.CancelBuyOrder(order.m_uniqueID, order.m_itemType, order.m_market);
}
}
public OrderProcessor(OrderAgent agent, Order order, Logger logger)
{
_agent = agent;
_order = order;
_position = agent.GetPosition(order);
_record = new OrderRecord(order);
_info = OrderExtensions.GetOrderInfo(order);
_logger = logger;
listNode = agent.AddProcessor(this);
InitRules();
}
public async Task RecordEventAsync(int orderId, string userId, string other)
{
OrderRecord record = new OrderRecord {
OrderId = orderId,
UserId = userId,
Other = other,
};
context.OrderRecords.Add(record);
await context.SaveChangesAsync();
}
public async Task RecordEventAsync(int orderId, string userId, OrderStatusEnum toStatus)
{
OrderRecord record = new OrderRecord {
OrderId = orderId,
UserId = userId,
ToStatus = toStatus
};
context.OrderRecords.Add(record);
await context.SaveChangesAsync();
}
public void AddShouldAddItemToRecordsList()
{
var item4 = new OrderRecord()
{
Id = 4,
Status = "Received"
};
repository.Add(item4);
Assert.That(repository.listAll().Contains(item4));
}
public OrderDeTailForm(OrderRecord orderRecord, List <OrderResponseProfile> responseInfoList)
{
InitializeComponent();
this.currentOrderRecord = orderRecord;
this.currentResponseList = responseInfoList;
InitializeSelectedOrderList();
InitializeOrderDetailList();
InitializeOrderResponseList();
}
public void Update(OrderRecord record, Action <OrderRecordOptState> updateResponse)
{
_updateResponse = updateResponse;
var future = Global.SendToServer(record, MessageType.UpdateOrderRecordRequest);
if (future == null)
{
UpdateResponse(OrderRecordOptState.CannotConnectServer);
}
}
public async Task AddAsync(OrderRecord orderRecord, CancellationToken cancellationToken = default)
{
if (orderRecord == null)
{
throw new ArgumentNullException(nameof(orderRecord));
}
await toolShedContext.AddAsync(orderRecord, cancellationToken);
await toolShedContext.SaveChangesAsync(cancellationToken);
}
public void Add(OrderRecord record, Action <OrderRecordOptState> addResponse)
{
_addResponse = addResponse;
var future = Global.SendToServer(record, MessageType.AddOrderRecordRequest);
if (future == null)
{
AddResponse(OrderRecordOptState.CannotConnectServer);
}
}
public OrderProcessor(OrderAgent agent, Order order, Logger logger)
{
Agent = agent;
Order = order;
Manager = agent.GetPositionManager(order.strategyId);
ListNode = agent.AddProcessor(this);
_record = new OrderRecord(order);
_info = OrderExtensions.GetOrderInfo(order);
_logger = logger;
InitRules();
}
private Order GetOrder(OrderRecord record)
{
var id = new OrderIdentity(record.Id);
var customerId = new CustomerIdentity(record.CustomerId);
OrderStatus status = (OrderStatus)record.OrderStatusId; // TODO: VC
var orderDetails = record.OrderItems.Select(GetOrderItem).ToList().AsReadOnly();
// TODO: VC: OrderDetails is empty list, need to Include it in EF so that it loads...
return(new Order(id, customerId, DateTime.Now, status, orderDetails));
}
public void cancelOrder()
{
if (ord == null) {
if (cache != null) cache.Dispose();
return;
}
DisplayOrder(ord);
if (ord.CurrentStatus == "LIVE") {
WriteLine("ORDER LIVE -- SUBMITTING CANCEL");
state = State.CancelPending;
CancelBuilder cxl = new CancelBuilder(ord);
cache.SubmitCancel(cxl);
ord = null;
}
cache.Dispose();
}
/// <summary>
/// WCFコマンドを作成します。
/// </summary>
/// <param name="cmdType">コマンドを種別を表す文字列を指定します。</param>
public void Execute(string cmdType)
{
var proxy = this.FProxy;
switch (cmdType.ToLower())
{
case "startcallback":
proxy.StartCallback();
break;
case "stopcallback":
proxy.StopCallback();
break;
case "order":
var rec = new OrderRecord();
this.AddLog("GetNextOrderId");
rec.OrderId = proxy.GetNextOrderId();
this.AddLog("AddOrder");
proxy.AddOrder(rec);
break;
}
}
private void SetExternalOrder(Order order, ref OrderField field)
{
var orderRecord = new OrderRecord(order);
ExternalOrderRecord record = new ExternalOrderRecord();
record = externalOrders.GetOrAdd(order.Instrument.Symbol, record);
if (field.OpenClose == OpenCloseType.Open) {
if (field.Side == XAPI.OrderSide.Buy)
{
record.BuyOpen = orderRecord;
}
else {
record.SellOpen = orderRecord;
}
}
else {
if (field.Side == XAPI.OrderSide.Buy)
{
record.BuyClose = orderRecord;
}
else {
record.SellClose = orderRecord;
}
}
}
public void EmitExecutionReport(OrderRecord record, SQ.ExecType execType, SQ.OrderStatus orderStatus, string text)
{
ExecutionReport report = CreateReport(record, execType, orderStatus);
report.Text = text;
provider.EmitExecutionReport(report);
}
public void AddOrderRecord(OrderRecord orderRecord)
{
swRecord.EnterWriteLock();
orderRecords.Add(orderRecord);
swRecord.ExitWriteLock();
}
private void tradeApi_OnRtnOrder(object sender, OnRtnOrderArgs e)
{
OrderRecord orderRecord = GetOrderRecord(e.pOrder.RequestID);
swRecord.EnterWriteLock();
if (orderRecord == null)
{
orderRecord = new OrderRecord();
orderRecords.Add(orderRecord);
}
swRecord.ExitWriteLock();
ObjectUtils.CopyStruct(e.pOrder, orderRecord);
//OnRspQryOrderRecord(this, new OrderRecordEventArgs(orderRecords));
UpdateOrderRef(e.pOrder);
}
/// <summary>
/// Sets a records display order to to requested value, and also renumbers other records
/// in the group as required.</summary>
/// <param name="connection">
/// Connection (required).</param>
/// <param name="tableName">
/// Tablename (required).</param>
/// <param name="keyField">
/// ID field meta that will be used to locate the record (required).</param>
/// <param name="orderField">
/// Display order field meta.</param>
/// <param name="filter">
/// Filter that will determine the record group (can be null).</param>
/// <param name="recordID">
/// ID value of the record.</param>
/// <param name="newDisplayOrder">
/// New display order of the record.</param>
/// <param name="descendingKeyOrder">
/// Will records with same display order values be sorted in ascending or descending ID order?
/// For example, if records with ID's 1, 2, 3 has display order value of "0", their actual display
/// orders are 1, 2 and 3. If this parameter is set to true (descending), their display orders will
/// become 3, 2, 1. This parameter controls if records that are added recently and has no display
/// order value assigned (or 0) be shown at start or at the end.</param>
/// <returns>
/// If any of the display order values is changed true.</returns>
public static bool ReorderValues(IDbConnection connection, string tableName, Field keyField, Field orderField,
ICriteria filter = null, Int64? recordID = null, int newDisplayOrder = 1,
bool descendingKeyOrder = false, bool hasUniqueConstraint = false)
{
if (connection == null)
throw new ArgumentNullException("connection");
if (tableName == null || tableName.Length == 0)
throw new ArgumentNullException("tableName");
if (ReferenceEquals(null, keyField))
throw new ArgumentNullException("keyField");
if (ReferenceEquals(null, orderField))
throw new ArgumentNullException("orderField");
// last assigned display order value
int order = 0;
// a list that will contain an element for each record, and hold old and new display
// order values of records
List<OrderRecord> orderRecords = new List<OrderRecord>();
// link to the order entry for record whose display order value is asked to be changed
OrderRecord changing = null;
// query to fetch id and display order values of the records in the group
SqlQuery query = new SqlQuery()
.Select(
keyField,
orderField)
.From(
tableName, Alias.T0)
.Where(
filter)
.OrderBy(
orderField);
// determine display order for records with same display order values
// based on ID ordering set
query.OrderBy(keyField.Name, desc : descendingKeyOrder);
// read all existing records
using (IDataReader reader = SqlHelper.ExecuteReader(connection, query))
{
while (reader.Read())
{
// each records actual display order value is one more than previous one
order++;
// create an entry to hold current and new display order value of the record
OrderRecord r = new OrderRecord();
// record ID
r.recordID = Convert.ToInt64(reader.GetValue(0));
// old display order field value (not the actual display order!)
r.oldOrder = Convert.ToInt32(reader.GetValue(1));
// new display order value (actual one to be set)
r.newOrder = order;
orderRecords.Add(r);
// if this is the one that is requested to be changed, hold a link to its entry
if (recordID == r.recordID)
changing = r;
}
}
// ensure that the new display order is within limits
// if its lower than 1 or bigger than record count, fix it
if (newDisplayOrder <= 0)
newDisplayOrder = 1;
else if (newDisplayOrder > order)
newDisplayOrder = order;
// if the record whose display order is to be changed can be found, and its display order value is different
// than the one in database
if (changing != null && changing.newOrder != newDisplayOrder)
{
// let's say record had a display order value of 6and now it will become 10, the records with actual
// display orders of 7, 8, 9, 10 will become 6, 7, 8, 9 orders.
//
// WARNING: notice that array is 0 based, so record with actual display order of 7 is in the
// 6th index in the array)
for (int i = changing.newOrder; i < newDisplayOrder; i++)
orderRecords[i].newOrder = i;
// if the records display order is to be changed from 9 to 5, the records with actual orders of 5, 6, 7, 8
// is going to be 6, 7, 8, 9 ordered.
for (int i = newDisplayOrder - 1; i < changing.newOrder - 1; i++)
orderRecords[i].newOrder = i + 2;
// as the records that will be changing are assigned new orders, we may assign new display order
// directly.
changing.newOrder = newDisplayOrder;
}
return UpdateOrders(connection, orderRecords, tableName, keyField, orderField, hasUniqueConstraint);
}
protected void DisplayOrder(OrderRecord ord)
{
if (ord == null) return;
WriteLine(" --> got event {0}", ord.OrderId);
WriteLine(" ({0}: {1})", ord.Type, ord.CurrentStatus);
WriteLine(" ({0} {1} {2} at {3})", ord.Buyorsell, ord.Volume, ord.DispName,
(ord.Price == null || ord.Price.Value.Numerator == 0) ? "MKT" : ord.Price.Value.ToString());
if (!string.IsNullOrEmpty(ord.Reason))
WriteLine(" ({0})", ord.Reason);
}
private void EmitExecutionReport(OrderRecord record, OrdStatus ordStatus, double lastPx, int lastQty, string text)
{
ExecutionReport report = new ExecutionReport
{
TransactTime = Clock.Now,
ClOrdID = record.Order.ClOrdID,
OrigClOrdID = record.Order.ClOrdID,
OrderID = record.Order.OrderID,
Symbol = record.Order.Symbol,
SecurityType = record.Order.SecurityType,
SecurityExchange = record.Order.SecurityExchange,
Currency = record.Order.Currency,
Side = record.Order.Side,
OrdType = record.Order.OrdType,
TimeInForce = record.Order.TimeInForce,
OrderQty = record.Order.OrderQty,
Price = record.Order.Price,
StopPx = record.Order.StopPx,
LastPx = lastPx,
LastQty = lastQty
};
if (ordStatus == OrdStatus.Undefined)
{
record.AddFill(lastPx, lastQty);
if (record.LeavesQty > 0)
{
ordStatus = OrdStatus.PartiallyFilled;
}
else
{
ordStatus = OrdStatus.Filled;
}
}
report.AvgPx = record.AvgPx;
report.CumQty = record.CumQty;
report.LeavesQty = record.LeavesQty;
report.ExecType = XSpeedProvider.GetExecType(ordStatus);
report.OrdStatus = ordStatus;
report.Text = text;
EmitExecutionReport(report);
}
public void EmitExecutionReport(OrderRecord record, SQ.ExecType execType, SQ.OrderStatus orderStatus)
{
ExecutionReport report = CreateReport(record, execType, orderStatus);
provider.EmitExecutionReport(report);
}
public void DoOrderCancel(List<Order> ordersList)
{
OrderRecord[] recordList = new OrderRecord[ordersList.Count];
string[] OrderIds = new string[ordersList.Count];
for (int i = 0; i < ordersList.Count; ++i) {
// 如果需要下单的过程中撤单，这里有可能返回LocalID或ID
if (orderIDs.TryGetValue(ordersList[i].Id, out OrderIds[i])) {
if (this.workingOrders.TryGetValue(OrderIds[i], out recordList[i])) {
pendingCancels[OrderIds[i]] = recordList[i];
}
}
}
string outstr = provider._TdApi.CancelOrder(OrderIds);
string[] errs = outstr.Split(';');
{
int i = 0;
foreach (var e in errs)
{
if (!string.IsNullOrEmpty(e) && e != "0")
{
EmitExecutionReport(recordList[i], SQ.ExecType.ExecCancelReject, recordList[i].Order.Status, "ErrorCode:" + e);
}
++i;
}
}
}
public void ProcessNew(ref QuoteField quote, QuoteRecord record)
{
OrderRecord askRecord = new OrderRecord(record.AskOrder);
this.workingOrders.Add(quote.AskID, askRecord);
this.orderIDs.Add(askRecord.Order.Id, quote.AskID);
EmitExecutionReport(askRecord, (SQ.ExecType)quote.ExecType, (SQ.OrderStatus)quote.Status);
OrderRecord bidRecord = new OrderRecord(record.BidOrder);
this.workingOrders.Add(quote.BidID, bidRecord);
this.orderIDs.Add(bidRecord.Order.Id, quote.BidID);
EmitExecutionReport(bidRecord, (SQ.ExecType)quote.ExecType, (SQ.OrderStatus)quote.Status);
}
