internal void OrderStatusHandle(OrderStatusData data)
{
Guid guid = data.OrigClientId;
_ordersLock.EnterUpgradeableReadLock();
try
{
if (!_orders.ContainsKey(guid))
{
if (data.Status != OrderStatus.Rejected && data.Status != OrderStatus.Canceled)
{
_ordersLock.EnterWriteLock();
try
{
_orders.Add(guid, data.OrderType == OrderType.Limit ?
(OrderBase) new OrderLimit(data, data.Symbol) :
new OrderMarket(data, data.Symbol));
_orders[guid].TimeStamp = data.OrderTimestamp;
}
finally
{ _ordersLock.ExitWriteLock(); }
}
}
else
{
if (data.Status == OrderStatus.Rejected || data.Status == OrderStatus.Canceled)
{
_orders[guid].TimeStamp = data.OrderTimestamp;
_orders[guid].Status = data.Status;
_orders[guid].OrderChanged();
_ordersLock.EnterWriteLock();
try
{
_orders[guid].Dispose();
_orders.Remove(guid);
}
finally
{ _ordersLock.ExitWriteLock(); }
}
else
{
_orders[guid].TimeStamp = data.OrderTimestamp;
_orders[guid].OpenTime = data.OpenTime;
_orders[guid].OrigClientId = data.OrigClientId;
_orders[guid].OrigQuantity = data.OrigQuantity;
_orders[guid].Status = data.Status;
_orders[guid].OrderChanged();
}
}
}
finally
{ _ordersLock.ExitUpgradeableReadLock(); }
}
private void OrderStatusHandler(OrderStatusData data)
{
TraderInfo traderInfo = TraderStatistic.Find(x => x.Symbol.Equals(data.Symbol));
if (traderInfo != null)
{
traderInfo.Update(data);
TraderInfoChanged?.Invoke(traderInfo);
}
_receiver.OrderStatusHandle(data);
}
public OrderStatus(OrderStatusData orderStatusData)
{
OrderStatusKey = orderStatusData.OrderStatusKey;
OrderStatusType = orderStatusData.OrderStatusType;
OrderStatusCode = orderStatusData.OrderStatusCode;
OrderStatusName = orderStatusData.OrderStatusName;
OrderStatusDesc = orderStatusData.OrderStatusDesc;
AddedUserID = orderStatusData.AuditAddUserId;
AddedDateTime = orderStatusData.AuditAddDatetime;
UpdateUserID = orderStatusData.AuditUpdateUserId;
UpdateDateTime = orderStatusData.AuditUpdateDatetime;
}
} // Map function closer
public List <SqlParameter> MapParamsForUpsert(OrderStatusData entity)
{
var sql_params = new List <SqlParameter>();
sql_params.Add(new SqlParameter("@order_status_key", entity.OrderStatusKey));
sql_params.Add(new SqlParameter("@order_status_code", entity.OrderStatusCode));
sql_params.Add(new SqlParameter("@order_status_name", entity.OrderStatusName));
sql_params.Add(new SqlParameter("@order_status_type", entity.OrderStatusType));
sql_params.Add(new SqlParameter("@order_status_desc", entity.OrderStatusDesc));
sql_params.Add(GetOutParam());
return(sql_params);
}
public static IList <OrderStatusData> GetOrderStatus()
{
List <T_SYS_DICTIONARY> listDict = GetDictionary("CHECKSTATE");
var result = listDict.CreateList(item =>
{
OrderStatusData cbbD = new OrderStatusData();
cbbD.Value = item.DICTIONARYVALUE;
cbbD.Text = item.DICTIONARYNAME;
return(cbbD);
});
return(result);
}
public OrderStatus Map(OrderStatusData order_status_data)
{
return(new OrderStatus()
{
OrderStatusKey = order_status_data.OrderStatusKey,
OrderStatusType = order_status_data.OrderStatusType,
OrderStatusCode = order_status_data.OrderStatusCode,
OrderStatusName = order_status_data.OrderStatusName,
OrderStatusDesc = order_status_data.OrderStatusDesc,
AddedUserID = order_status_data.AuditAddUserId,
AddedDateTime = order_status_data.AuditAddDatetime,
UpdateUserID = order_status_data.AuditUpdateUserId,
UpdateDateTime = order_status_data.AuditUpdateDatetime
});
}
public void orderStatus(int orderId, string status, int filled,
int remaining, double avgFillPrice, int permId, int parentId,
double lastFillPrice, int clientId, string whyHeld)
{
if (OrderStatusDic.ContainsKey(orderId))
{
OrderStatusData orderStatus = OrderStatusDic[orderId].Data;
orderStatus.OrderStatus = (OrderStatus)Enum.Parse(typeof(OrderStatus), status);
orderStatus.LastUpdateTime = DateTime.Now;
orderStatus.LastFillPrice = lastFillPrice;
Consumer.Enqueue(orderStatus);
}
else
{
Logger.Error($"Received order status on request not in OrderStatusDic, orderId is {orderId}");
}
}
protected void HandleOrderStatusData(OrderStatusData data)
{
SaveContractDetailsIfNeeded <OptionContract>(data.GetContract());
using (ITransaction transaction = _session.BeginTransaction())
{
_session.Evict(data);
_session.SaveOrMerge(data, data.Id);
try
{
transaction.Commit();
}
catch (Exception exception)
{
Logger.Error("Could not write to DB", exception);
}
}
}
protected OrderBase(OrderType type, OrderStatusData data, Symbol symbol)
{
Type = data.OrderType;
ClientId = data.ClientId;
Quantity = data.Quantity;
if (Quantity < 0)
{
return;
}
Side = data.Side;
Duration = data.Duration;
Leverage = data.Leverage;
Price = data.Price;
TargetSymbol = symbol;
PaidPrice = data.PaidPrice;
AccumQuantity = data.AccumQuantity;
OldContractId = data.OldContractId;
OpenTime = data.OpenTime;
OrderClientId = data.OrderClientId;
TimeStamp = data.OrderTimestamp;
OrigClientId = data.OrigClientId;
OrigQuantity = data.OrigQuantity;
Status = data.Status;
}
// aktualizacja danych z sieci - nowy status zlecenia
private void Update(OrderStatusData data)
{
StatusReport = new BosOrderStatusReport(data);
}
public OrderLimit(OrderStatusData data, Symbol symbol)
: base(OrderType.Limit, data, symbol)
{
}
public List <SqlParameter> MapParamsForDelete(OrderStatusData entity)
{
return(MapParamsForDelete(entity.OrderStatusKey));
}
private void OrderManagerOnOrderStatusDataUpdated(OrderStatusData orderStatusData)
{
OrderStatusDataUpdated?.Invoke(orderStatusData);
}
public OrderMarket(OrderStatusData data, Symbol symbol)
: base(OrderType.Market, data, symbol)
{
}
public IBOrderStatusWrapper(OrderStatusData data)
{
Data = data;
}
public void SetOrderStatusData(OrderStatusData orderStatusData)
{
OrderStatusData = orderStatusData;
}
internal void Update(OrderStatusData data)
{
Update(data as CommonFields);
TraderBalance2 = data.TraderBalance2;
}
