public void Visit(KillOrderTransaction transaction)
{
var symbol = adapter.ResolveSymbolAsync(transaction.Instrument).Result;
if (symbol == null)
{
Logger.Error().Print($"Unable to resolve symbol for {transaction.Instrument}");
return;
}
var newTransactionId = IncTransId();
var qlTrans = new QLTransaction
{
ACTION = ACTION.KILL_ORDER,
ACCOUNT = transaction.Account,
CLIENT_CODE = transaction.Account,
SECCODE = symbol,
CLASSCODE = symbol.Length >= 5 ? "SPBOPT" : "SPBFUT",
EXECUTION_CONDITION = EXECUTION_CONDITION.PUT_IN_QUEUE,
TRANS_ID = newTransactionId.ToString(),
ORDER_KEY = transaction.OrderExchangeId
};
Logger.Debug().PrintFormat("Visit: {0}", qlTrans);
adapter.SendMessage(qlTrans);
container.PutTransaction(newTransactionId, transaction);
}
public async void Visit(KillOrderTransaction transaction)
{
try
{
var reply = await transClient.CancelOrder(new CancelOrder { order_id = transaction.OrderExchangeId });
OnMessageReceived(TransactionReply.Accepted(transaction, reply.code));
var oscm = new OrderStateChangeMessage
{
TransactionId = transaction.TransactionId,
OrderExchangeId = reply.code,
Quantity = reply.qty,
ActiveQuantity = reply.qtyLeft,
FilledQuantity = reply.qty_executed,
ChangeTime = DateTime.Now,
State = OrderState.Cancelled
};
OnMessageReceived(oscm);
}
catch (FTEException e)
{
OnMessageReceived(TransactionReply.Rejected(transaction, e.Message));
}
}
KillOrderTransaction GetKillOrderTransactionByTransId(long transId)
{
using (locker.ReadLock())
{
KillOrderTransaction rValue = null;
mapQuikTransIdOnKillOrderTransaction.TryGetValue(transId, out rValue);
return(rValue);
}
}
/// <summary>
/// Получить транзакцию на снятие заявки по идентификатору заявки
/// </summary>
/// <param name="orderId"></param>
/// <returns></returns>
public KillOrderTransaction GetKillOrderTransactionByOrderId(long orderId)
{
KillOrderTransaction rValue = null;
using (locker.ReadLock())
{
mapOrderIdIdOnKillOrderTransaction.TryGetValue(orderId, out rValue);
}
return(rValue);
}
/// <summary>
/// Обработать транзакцию <see cref="KillOrderTransaction"/>
/// </summary>
/// <param name="transaction">
/// Транзакция для обработки
/// </param>
void ITransactionVisitor.Visit(KillOrderTransaction transaction)
{
// Разбираем permId из OrderExchangeId
int permId;
if (!int.TryParse(transaction.OrderExchangeId, out permId))
{
Reject(transaction, "Invalid order exchange ID: \"{0}\".", transaction.OrderExchangeId);
return;
}
connector.Adapter.KillOrder(permId, transaction);
}
/// <summary>
/// Снять заявку
/// </summary>
/// <param name="permId">
/// Номер заявки
/// </param>
/// <param name="transaction">
/// Транзакция на снятие заявки
/// </param>
public void KillOrder(int permId, KillOrderTransaction transaction)
{
using (orderInfoContainerLock.Lock())
{
OrderInfo orderInfo;
if (!orderInfoContainer.TryGetByPermId(permId, out orderInfo))
{
throw new InvalidOperationException($"Unable to find order #{permId}");
}
orderInfo.KillOrderTransactionId = transaction.TransactionId;
var orderId = orderInfo.OrderId;
Socket.cancelOrder(orderId);
}
}
/// <summary>
/// Сохранить транзакцию на снятие заявки по её идентификатору
/// </summary>
/// <param name="id"></param>
/// <param name="killOrderTransaction"></param>
public void PutTransaction(long id, KillOrderTransaction killOrderTransaction)
{
using (locker.WriteLock())
{
long orderExchangeId = long.MinValue;
if (long.TryParse(killOrderTransaction.OrderExchangeId, out orderExchangeId))
{
currentSeccionTransactionIds.Add(id);
mapQuikTransIdOnKillOrderTransaction[id] = killOrderTransaction;
mapOrderIdIdOnKillOrderTransaction[orderExchangeId] = killOrderTransaction;
mapQuikTransIdOnOrderExchangeId[id] = orderExchangeId;
}
else
{
log.Error().Print(
$"Can't save kill transaction. Unable to parse {LogFieldNames.ExchangeOrderId} from {killOrderTransaction.OrderExchangeId}"
);
}
}
}
/// <summary>
/// Обработать транзакцию <see cref="KillOrderTransaction"/>
/// </summary>
/// <param name="transaction">
/// Транзакция для обработки
/// </param>
void ITransactionVisitor.Visit(KillOrderTransaction transaction)
{
if (!_orders.GetOrderParams(transaction.OrderExchangeId, out var _, out var symbol, out var qty, out var side))
{
SendMessage(TransactionReply.Rejected(transaction, $"Unknown order: {transaction.OrderExchangeId}"));
return;
}
var msg = new OrderCancelRequest();
var clOrderId = _killOrderTransactions.Add(transaction);
msg.ClOrdID = new ClOrdID(clOrderId);
msg.OrderID = new OrderID(transaction.OrderExchangeId);
msg.Symbol = new Symbol(symbol);
msg.Side = new Side(side);
msg.OrderQty = new OrderQty(qty);
msg.TransactTime = new TransactTime(DateTime.UtcNow);
SendFixMessage(msg);
}
/// <summary>
/// Снятие заявки
/// </summary>
private void SendTransactionInternal(KillOrderTransaction transaction)
{
// Получаем счет для транзакции
int accountId;
var hasAccountId = true;
using (accountsLock.ReadLock())
{
if (!accountIdsByCode.TryGetValue(transaction.Account, out accountId))
{
hasAccountId = false;
}
}
if (!hasAccountId)
{
OnMessageReceived(TransactionReply.Rejected(
transaction,
$"Account \"{transaction.Account}\" is unknown"));
return;
}
// Поиск заявки
OrderStatus orderStatus;
using (ordersLock.Lock())
{
orderStatusByChainOrderId.TryGetValue(transaction.OrderExchangeId, out orderStatus);
}
if (orderStatus == null)
{
OnMessageReceived(TransactionReply.Rejected(
transaction,
$"Order \"{transaction.OrderExchangeId}\" is not found"));
return;
}
// Формируем запрос
var msg = new OrderRequest
{
cancel_order = new CancelOrder
{
cl_order_id = transaction.TransactionId.ToString("N"),
account_id = accountId,
order_id = orderStatus.order_id,
orig_cl_order_id = orderStatus.order.cl_order_id,
when_utc_time = adapter.ResolveDateTime(DateTime.UtcNow)
},
request_id = adapter.GetNextRequestId()
};
// Запоминаем транзакцию
StoreTransaction(msg.request_id, transaction);
// Отправляем заявку
try
{
Logger.Debug().PrintFormat("Sending {0}", transaction);
adapter.SendMessage(msg);
}
catch (Exception)
{
OnMessageReceived(TransactionReply.Rejected(transaction, "Unable to send order"));
}
}
void ITransactionVisitor.Visit(KillOrderTransaction transaction)
{
router.SendTransactionInternal(transaction);
}
