public void SendOrderStatus(OrderStatusRequest request)
{
GlobalHost.ConnectionManager.GetHubContext <OrderStatusHub>()
.Clients
.Group(request.ClientIdentifier.ToString())
.statusUpdated(request.Status);
}
public OrderStatusResponse GetOrderStatus(int order_id)
{
OrderStatusRequest req = new OrderStatusRequest(Nonce, order_id);
string response = SendRequest(req, "POST");
return(OrderStatusResponse.FromJSON(response));
}
public void RequiresMerchantReferenceIsNotBlank()
{
var request = new OrderStatusRequest()
{
MerchantReference = null
};
//Throws when merchant reference is null
Assert.ThrowsException <ArgumentNullException>
(
() =>
{
request.Validate();
}
);
//Throws when order id is empty string
request.MerchantReference = String.Empty;
Assert.ThrowsException <ArgumentException>
(
() =>
{
request.Validate();
}
);
//Does not throw when merchante reference is nto blank.
request.MerchantReference = "12355";
request.Validate();
}
public static void ValidateOrderStatusRequest(OrderStatusRequest request)
{
List <string> fields = new List <string>();
if (request.OperatorID == null || !Regex.IsMatch(request.OperatorID, PARAMETERS.OPERATORID.PATTERN))
{
fields.Add(PARAMETERS.OPERATORID.NAME);
}
if (request.OrderId == null || !Regex.IsMatch(request.OrderId, PARAMETERS.ORDERID.PATTERN))
{
fields.Add(PARAMETERS.ORDERID.NAME);
}
if (request.ProductRef != null && !Regex.IsMatch(request.ProductRef, PARAMETERS.PRODUCTREF.PATTERN))
{
fields.Add(PARAMETERS.PRODUCTREF.NAME);
}
if (request.Options != null && !Regex.IsMatch(request.Options, PARAMETERS.OPTIONS.PATTERN))
{
fields.Add(PARAMETERS.OPTIONS.NAME);
}
if (fields.Count > 0)
{
string message = "";
foreach (string field in fields)
{
message = message + " " + field;
}
throw new VPOSClientException("Invalid Request! The following field/s are not valid or missing:" + message);
}
}
public static OrderStatusResult RequestOrderStatus(OrderStatusRequest statusRequest)
{
var channel = new ChannelFactory <IOrderProcessing>("*").CreateChannel();
var result = channel.OrderStatusRequest(statusRequest);
return(result);
}
public object Get(OrderStatusRequest request)
{
AuthService.CurrentSessionFactory();
var status = _orderStatusHelper.GetOrderStatus(request.OrderId, SessionAs <IAuthSession>());
_logger.LogMessage("OrderStatusService: Vehicle {0} OrderId: {1}: ({2}, {3}).", status.VehicleNumber, status.OrderId, status.VehicleLatitude, status.VehicleLongitude);
return(Mapper.Map <OrderStatusRequestResponse>(status));
}
private void buttonRequestOrderStatus_Click(object sender, EventArgs e)
{
var statusRequest = new OrderStatusRequest {
OrderNumber = textRequestStatusOrderNumber.Text
};
var result = ServiceCommuincation.RequestOrderStatus(statusRequest);
DisplayRequestOrderStatusResults(result);
}
static void TestOrderStatus()
{
var vposClient = new VPOSClient(URL_WEB_API,
API_RESULT_KEY, START_KEY_VPOS, SHOP_ID, URL_REDIRECT);
var requestData = new OrderStatusRequest(SHOP_ID, OPERATOR_ID, "516774135");
var response = vposClient.GetOrderStatus(requestData);
Console.WriteLine(response);
}
public static BPWXmlRequest <OrderStatusRequestXML> MapOrderStatusRequest(OrderStatusRequest statusRequest, string shopId)
{
var requestData = new OrderStatusRequestXML();
requestData.OrderID = statusRequest.OrderId;
requestData.ProductRef = statusRequest.ProductRef;
var requestXML = new BPWXmlRequest <OrderStatusRequestXML>(requestData);
requestXML.SetHeaderInfo(shopId, statusRequest.OperatorID);
return(requestXML);
}
/// <inheritdoc />
public async Task GetOrdersAndFillsAsync(ulong accountId, string requestId = null)
{
var request = new OrderStatusRequest
{
MsgType = MsgTypes.OrderMassStatusRequest,
Account = accountId,
OrdStatusReqId = requestId.Proto(),
};
await SendCommandAsync(request).ConfigureAwait(false);
}
/// <inheritdoc />
public async Task GetOrderAsync(ulong account, string orderId = "", string clOrdId = "", string requestId = null)
{
var request = new OrderStatusRequest
{
MsgType = MsgTypes.OrderStatusRequest,
Account = account,
OrdStatusReqId = requestId.Proto(),
OrderId = orderId.Proto(),
ClOrdId = clOrdId.Proto(),
};
await SendCommandAsync(request).ConfigureAwait(false);
}
public static OrderStatusResult RequestOrderStatus(OrderStatusRequest statusRequest)
{
//var binding = new WSHttpBinding();
//var address = new EndpointAddress(@"http://*****:*****@"net.tcp://localhost:8080/OrderProcessingService");
var factory = new ChannelFactory <IOrderProcessing>(binding, address);
var channel = factory.CreateChannel();
var result = channel.OrderStatusRequest(statusRequest);
return(result);
}
public void Validate_EnrolRequest_RequiresOrderId()
{
var request = new OrderStatusRequest()
{
OrderId = null
};
Assert.ThrowsException <ArgumentNullException>(() => request.Validate());
request.OrderId = String.Empty;
Assert.ThrowsException <ArgumentException>(() => request.Validate());
request.OrderId = " ";
Assert.ThrowsException <ArgumentException>(() => request.Validate());
}
private void GetIdAndOrderDate(OrderStatusRequest request, OrderStatusResult result)
{
using (var cmd = new SqlCommand("usp_GetOrderDateAndID", cn))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add(new SqlParameter("@OrderNumber", SqlDbType.NVarChar, 255) {Value = request.OrderNumber});
var reader = cmd.ExecuteReader();
if (reader.HasRows)
{
reader.Read();
id = reader.GetInt32(OrderIdOrdinal);
result.OrderDate = reader.GetDateTime(OrderedDateOrdinal);
}
reader.Close();
}
}
private void GetIdAndOrderDate(OrderStatusRequest request, OrderStatusResult result)
{
using (var cmd = new SqlCommand("usp_GetOrderDateAndID", cn))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add(new SqlParameter("@OrderNumber", SqlDbType.NVarChar, 255)
{
Value = request.OrderNumber
});
var reader = cmd.ExecuteReader();
if (reader.HasRows)
{
reader.Read();
id = reader.GetInt32(OrderIdOrdinal);
result.OrderDate = reader.GetDateTime(OrderedDateOrdinal);
}
reader.Close();
}
}
static async Task OrderStatusSample(long orderId)
{
var api = new BitfinexApiV1(Configuration["BitfinexApi_key"], Configuration["BitfinexApi_secret"]);
var request = new OrderStatusRequest
{
OrderId = orderId
};
LogRequest(request);
var response = await api.OrderStatusAsync(request);
LogResponse(response);
if (response.IsLive)
{
throw new ApplicationException("Order is still being executed. Waiting for completion.");
}
}
public static async Task <OrderStatusResponse> SetOrderStatus(string orderId, OrderStatus status)
{
var post = new OrderStatusRequest();
post.OrderId = orderId;
post.Status = status;
try
{
var json = JsonConvert.SerializeObject(post);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
return(await MakeRequest <OrderStatusResponse>(ProjectConfig.SetOrderStatusUrl, httpContent));
}
catch (WebException ex)
{
Console.WriteLine(ex.Message);
}
return(null);
}
public OrderStatusResult GetOrderStatus(OrderStatusRequest request)
{
var result = new OrderStatusResult();
try
{
GetIdAndOrderDate(request, result);
result.ItemStatuses = GetLineItemStatuses(id);
}
catch (SqlException ex)
{
result.HasException = true;
result.Exception = ExceptionFactory.BuildSqlException(ex);
}
catch (Exception ex)
{
result.HasException = true;
result.Exception = ExceptionFactory.BuildSystemException(ex);
}
return result;
}
public OrderStatusResult GetOrderStatus(OrderStatusRequest request)
{
var result = new OrderStatusResult();
try
{
GetIdAndOrderDate(request, result);
result.ItemStatuses = GetLineItemStatuses(id);
}
catch (SqlException ex)
{
result.HasException = true;
result.Exception = ExceptionFactory.BuildSqlException(ex);
}
catch (Exception ex)
{
result.HasException = true;
result.Exception = ExceptionFactory.BuildSystemException(ex);
}
return(result);
}
public OrderStatusResponse GetOrderStatus(OrderStatusRequest orderStatusRequest)
{
// Validate Request
RequestValidator.ValidateOrderStatusRequest(orderStatusRequest);
// Build Request object
var request = RequestMapper.MapOrderStatusRequest(orderStatusRequest, _shopId);
request.Request.MAC = _encoder.GetMac(RequestHandler.GetMacDictionary(request), _apiResultKey);
var xmlBody = XmlTool.Serialize(request);
// Do call to VPOS
var xmlResponse = _restClient.CallApi(_urlAPI, xmlBody);
// Map response
var objectResponse = XmlTool.Deserialize <BPWXmlResponse <DataOrderStatus> >(xmlResponse);
// Verify Mac Response
VerifyMacResponse(objectResponse);
VerifyPanAliasData(objectResponse.Data.PanAliasData);
foreach (var authorization in objectResponse.Data.Authorizations)
{
VerifyAuthorization(authorization);
}
return(ResponseMapper.MapOrderStatusResponse(objectResponse));
}
public virtual void SendOrderStatusRequest(OrderStatusRequest request)
{
}
private void SendSelectedRequest()
{
switch (DataContainer.Data[_listBoxSelectedIndexNo].MsgType)
{
case "U1000":
MsgAIR requestData = (MsgAIR)DataContainer.Data[_listBoxSelectedIndexNo];
AccountInfoRequest request = new AccountInfoRequest();
request.Set(new Account(Properties.Settings.Default.Account));
request.Set(new AccReqID(requestData.AccReqID));
//testforJack
//request.Set(new SubscriptionRequestType('1'));
if (!initiator.IsStopped)
{
bool ret = Session.SendToTarget(request, conn.m_sessionID);
}
else
{
MessageBox.Show(@"Connection is not established!!", @"Warning", MessageBoxButtons.OK);
}
break;
case "D":
MsgNOSR requestData1 = (MsgNOSR)DataContainer.Data[_listBoxSelectedIndexNo];
NewOrderSingle request1 = new NewOrderSingle();
request1.Set(new Account(Properties.Settings.Default.Account));
request1.Set(new ClOrdID(requestData1.ClOrdID));
request1.Set(new OrderQty(decimal.Parse(requestData1.OrderQty)));
request1.Set(new OrdType(char.Parse(requestData1.OrdType)));
request1.Set(new Side(char.Parse(requestData1.Side)));
request1.Set(new Symbol(requestData1.Symbol));
request1.Set(new TransactTime(DateTime.Now));
if (!initiator.IsStopped)
{
bool ret = Session.SendToTarget(request1, conn.m_sessionID);
}
else
{
MessageBox.Show(@"Connection is not established!!", @"Warning", MessageBoxButtons.OK);
}
break;
case "H":
MsgOSR requestData2 = (MsgOSR)DataContainer.Data[_listBoxSelectedIndexNo];
OrderStatusRequest request2 = new OrderStatusRequest();
request2.Set(new Account(Properties.Settings.Default.Account));
request2.Set(new ClOrdID(requestData2.ClOrdID));
request2.Set(new Side(char.Parse(requestData2.Side)));
request2.Set(new Symbol(requestData2.Symbol));
request2.Set(new OrderID(requestData2.OrderID));
if (!initiator.IsStopped)
{
bool ret = Session.SendToTarget(request2, conn.m_sessionID);
}
else
{
MessageBox.Show(@"Connection is not established!!", @"Warning", MessageBoxButtons.OK);
}
break;
case "AF2":
MsgBOIR requestData3 = (MsgBOIR)DataContainer.Data[_listBoxSelectedIndexNo];
OrderMassStatusRequest request3 = new OrderMassStatusRequest();
request3.Set(new Account(Properties.Settings.Default.Account));
request3.Set(new Symbol(requestData3.Symbol));
request3.Set(new MassStatusReqID(requestData3.MassStatusReqID));
//request3.Set(new NoStatuses(int.Parse(requestData3.GroupNums)));
if (!initiator.IsStopped)
{
bool ret = Session.SendToTarget(request3, conn.m_sessionID);
}
else
{
MessageBox.Show(@"Connection is not established!!", @"Warning", MessageBoxButtons.OK);
}
break;
case "G":
MsgOCRR requestData4 = (MsgOCRR)DataContainer.Data[_listBoxSelectedIndexNo];
OrderCancelReplaceRequest request4 = new OrderCancelReplaceRequest();
request4.Set(new Account(Properties.Settings.Default.Account));
request4.Set(new ClOrdID(requestData4.ClOrdID));
request4.Set(new OrderQty(decimal.Parse(requestData4.OrderQty)));
request4.Set(new OrderID(requestData4.OrderID));
if (!initiator.IsStopped)
{
bool ret = Session.SendToTarget(request4, conn.m_sessionID);
}
else
{
MessageBox.Show(@"Connection is not established!!", @"Warning", MessageBoxButtons.OK);
}
break;
case "F":
MsgOCR requestData5 = (MsgOCR)DataContainer.Data[_listBoxSelectedIndexNo];
OrderCancelRequest request5 = new OrderCancelRequest();
request5.Set(new Account(Properties.Settings.Default.Account));
request5.Set(new ClOrdID(requestData5.ClOrdID));
request5.Set(new OrderID(requestData5.OrderID));
request5.Set(new Symbol(requestData5.Symbol));
request5.Set(new TransactTime(DateTime.Now));
if (!initiator.IsStopped)
{
bool ret = Session.SendToTarget(request5, conn.m_sessionID);
}
else
{
MessageBox.Show(@"Connection is not established!!", @"Warning", MessageBoxButtons.OK);
}
break;
default:
break;
}
}
public void SendOrderStatusRequest(OrderStatusRequest request)
{
throw new NotImplementedException();
}
private static async Task TestLaybyOrderLifecycle(ILaybuyClient client, CreateOrderRequest createRequest)
{
System.Diagnostics.Trace.WriteLine("Merchant Ref: " + createRequest.MerchantReference);
var createOrderResponse = await client.Create(createRequest).ConfigureAwait(false);
Assert.IsNotNull(createOrderResponse);
Assert.AreEqual(createOrderResponse.Result, LaybuyStatus.Success);
Assert.IsFalse(String.IsNullOrWhiteSpace(createOrderResponse.Token));
Assert.IsTrue(String.IsNullOrWhiteSpace(createOrderResponse.Error));
Assert.IsNotNull(createOrderResponse.PaymentUrl);
//Poll until 'order' reaches a final status
var done = false;
var started = DateTime.Now;
var statusRequest = new OrderStatusRequest()
{
MerchantReference = createRequest.MerchantReference
};
OrderStatusResponse statusResponse;
while (!done)
{
await Task.Delay(5000); //Laybuy say poll every 5-10 seconds
statusResponse = await client.GetOrderStatus(statusRequest).ConfigureAwait(false);
done = !LaybuyOrderStatus.IsPendingStatus(statusResponse.Status);
if (DateTime.Now.Subtract(started).TotalMinutes > 5)
{
throw new TimeoutException("Order not accepted after 5 minutes.");
}
if (LaybuyOrderStatus.IsFailed(statusResponse.Status))
{
throw new LaybuyApiException(statusResponse.Status + " - " + statusResponse.Error);
}
}
var orderResponse = await client.GetOrder(new OrderRequest()
{
MerchantReference = statusRequest.MerchantReference
}).ConfigureAwait(false);
Assert.AreEqual(orderResponse.Result, LaybuyStatus.Success);
System.Diagnostics.Trace.WriteLine("Order Id: " + orderResponse.OrderId);
System.Diagnostics.Trace.WriteLine("Payment token: " + orderResponse.Token);
Assert.IsNotNull(orderResponse.Refunds);
Assert.IsFalse(String.IsNullOrEmpty(orderResponse.Currency));
Assert.IsNotNull(orderResponse.Processed);
Assert.IsTrue(orderResponse.OrderId > 0);
Assert.AreEqual(orderResponse.MerchantReference, createRequest.MerchantReference);
//TODO: Laybuy doesn't actually return this here?
//Assert.AreEqual(orderResponse.Token, createOrderResponse.Token);
//Refund the order
var refundRequest = new RefundRequest()
{
RefundMerchantReference = System.Guid.NewGuid().ToString(), OrderId = orderResponse.OrderId, Amount = orderResponse.Amount, Note = "Test refund"
};
System.Diagnostics.Trace.WriteLine("Refund Ref: " + refundRequest.RefundMerchantReference);
var refundResponse = await client.Refund(refundRequest).ConfigureAwait(false);
Assert.IsNotNull(refundResponse);
Assert.AreEqual(refundResponse.Result, LaybuyStatus.Success);
Assert.IsTrue(refundResponse.RefundId > 0);
Assert.AreEqual(createRequest.MerchantReference, refundResponse.MerchantReference);
//Can get the order by order id
var orderRequest = new OrderRequest()
{
OrderId = orderResponse.OrderId
};
orderResponse = await client.GetOrder(orderRequest).ConfigureAwait(false);
Assert.AreEqual(orderResponse.Result, LaybuyStatus.Success);
Assert.AreEqual(1, orderResponse.Refunds.Count());
}
public GetExternalOrderStatusRequest()
{
_MyOrderStatusRequest = new OrderStatusRequest();
}
public void SendOrderStatusRequest(OrderStatusRequest request)
{
throw new Exception("The method or operation is not implemented.");
}
public OrderStatusResult OrderStatusRequest(OrderStatusRequest request)
{
var requestor = new GetOrderStatusHandler(connectString);
return(requestor.GetOrderStatus(request));
}
public void SendOrderStatusRequest(OrderStatusRequest request)
{
SendOrderStatusRequest(request as FIXOrderStatusRequest);
}
public void SendOrderStatusRequest(OrderStatusRequest request)
{
throw new Exception("The method or operation is not implemented.");
}
public virtual void SendOrderStatusRequest(OrderStatusRequest request)
{
}
public bool Handle(IRequestMessage msg)
{
Type msgType = msg.GetType();
if (typeof(IRequestMessage).IsAssignableFrom(msgType))
{
if (typeof(OrderStatusRequest) == msgType)
{
OrderStatusRequest statusReq = (OrderStatusRequest)msg;
SingleOrder order = OrdersManager.GetOrder(statusReq.RequesterOrderID);
if (order != null)
{
lock (order)
{
try
{
Fix_OrderStatusResponse status = new Fix_OrderStatusResponse();
{
status.ClientKey = statusReq.ClientKey;
status.ReqOrdID = statusReq.RequesterOrderID;
status.OrdStatus = order[SingleOrderProperties.OrderStatus].ToString();
status.IsExisted = true;
status.AvgPrc = Convert.ToDouble(order[SingleOrderProperties.AvgPrice]);
status.CurrPrc = Convert.ToDouble(order[SingleOrderProperties.CurrentPrice]);
status.ExecPrc = Convert.ToDouble(order[SingleOrderProperties.LastExecPrice]);
status.CurrQty = (int)order[SingleOrderProperties.CurrentQuantity];
status.LastExecQty = (int)order[SingleOrderProperties.LastExecQuantity];
status.RemQty = (int)order[SingleOrderProperties.RemainingQuantity];
status.TotExecQty = (int)order[SingleOrderProperties.ExecutedQuantity];
status.IsActive = Convert.ToBoolean(order[SingleOrderProperties.IsActive]);
status.IsPending = Convert.ToBoolean(order[SingleOrderProperties.IsPending]);
status.IsCompleted = Convert.ToBoolean(order[SingleOrderProperties.IsCompleted]);
status.IsExecuted = Convert.ToBoolean(order[SingleOrderProperties.IsExecuted]);
status.LastUpdate = (DateTime)order[SingleOrderProperties.ModifiedDateTime];
status.PlacementTime = (DateTime)order[SingleOrderProperties.PlacementDateTime];
status.OrdTyp = order[SingleOrderProperties.OrderType].ToString();
status.TIF = order[SingleOrderProperties.TimeInForce].ToString();
status.Note = order[SingleOrderProperties.Note].ToString();
}
Dictionary <string, object> data = new Dictionary <string, object>();
bool aon = (bool)order[SingleOrderProperties.AON];
if (aon)
{
data.Add("AON", aon);
data.Add("MinQty", (int)order[SingleOrderProperties.MinQty]);
}
if (HasValue(order[SingleOrderProperties.ExpirationDate]))
{
data.Add("ExpirationDate", (DateTime)order[SingleOrderProperties.ExpirationDate]);
}
if (HasValue(order[SingleOrderProperties.ExpirationDateTime]))
{
data.Add("ExpirationDateTime", (DateTime)order[SingleOrderProperties.ExpirationDateTime]);
}
Sessions.Push(Sessions.GetUsername(status.ClientKey), new IResponseMessage[] { status });
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error sending order status to the client, ClientKey {0}, Error: {1}", statusReq, ex.Message), ConsoleColor.Red, ConsoleColor.White, true);
}
}
}
else
{
try
{
Sessions.Push(Sessions.GetUsername(statusReq.ClientKey), new IResponseMessage[] { new Fix_OrderStatusResponse()
{
ClientKey = statusReq.ClientKey, ReqOrdID = statusReq.RequesterOrderID, IsExisted = false
} });
}
catch (Exception ex)
{
Counters.IncrementCounter(CountersConstants.ExceptionMessages);
SystemLogger.WriteOnConsoleAsync(true, string.Format("Error sending order status to the client, ClientKey {0}, Error: {1}", statusReq, ex.Message), ConsoleColor.Red, ConsoleColor.White, true);
}
}
return(true);
}
}
return(false);
}
public virtual void onMessage(OrderStatusRequest message, QuickFix.SessionID session)
{
throw new QuickFix.UnsupportedMessageType();
}
static void Main(string[] args)
{
TestFixApp testFixApp = new TestFixApp(args.FirstOrDefault());
testFixApp.Start();
Account account = new Account("54b97c9e-202b-11b2-be90-529049f1f1bb");
ClOrdID clOrdId = new ClOrdID(Guid.NewGuid().ToString());
Symbol symbol = new Symbol("BTC/USD");
Side side = new Side(Side.BUY);
#region SecurityListRequest
SecurityListRequest securityListRequest = new SecurityListRequest(
new SecurityReqID(Guid.NewGuid().ToString()),
new SecurityListRequestType(SecurityListRequestType.SYMBOL)
)
{
Symbol = symbol
};
Console.WriteLine("Press enter to next comand");
Console.ReadLine();
testFixApp.Send(securityListRequest);
testFixApp.WaitResponces(1);
#endregion SecurityListRequest
#region MarketDataRequest
MarketDataRequest marketDataRequest = new MarketDataRequest(
new MDReqID(Guid.NewGuid().ToString()),
new SubscriptionRequestType(SubscriptionRequestType.SNAPSHOT),
new MarketDepth(5))
{
MDUpdateType = new MDUpdateType(MDUpdateType.FULL_REFRESH),
};
var bid = new MarketDataRequest.NoMDEntryTypesGroup()
{
MDEntryType = new MDEntryType(MDEntryType.BID)
};
var ask = new MarketDataRequest.NoMDEntryTypesGroup()
{
MDEntryType = new MDEntryType(MDEntryType.OFFER)
};
var symGroup = new MarketDataRequest.NoRelatedSymGroup
{
Symbol = symbol
};
marketDataRequest.AddGroup(bid);
marketDataRequest.AddGroup(ask);
marketDataRequest.AddGroup(symGroup);
Console.WriteLine("Press enter to next comand");
Console.ReadLine();
testFixApp.Send(marketDataRequest);
testFixApp.WaitResponces(1);
#endregion MarketDataRequest
#region NewOrderSingle
NewOrderSingle newOrderSingle = new NewOrderSingle(
clOrdId,
symbol,
side,
new TransactTime(DateTime.Now),
new OrdType(OrdType.LIMIT))
{
OrderQty = new OrderQty(0.1m),
Price = new Price(1m),
Account = account,
AcctIDSource = new AcctIDSource(AcctIDSource.OTHER)
};
Console.WriteLine("Press enter to next comand");
Console.ReadLine();
testFixApp.Send(newOrderSingle);
testFixApp.WaitResponces(2);
#endregion NewOrderSingle
#region OrderCancelReplaceRequest
OrderCancelReplaceRequest orderCancelReplaceRequest = new OrderCancelReplaceRequest(
new OrigClOrdID(clOrdId.ToString()),
clOrdId = new ClOrdID(Guid.NewGuid().ToString()),
symbol,
side,
new TransactTime(DateTime.Now),
new OrdType(OrdType.LIMIT))
{
Price = new Price(2m),
OrderQty = new OrderQty(0.2m)
};
Console.WriteLine("Press enter to next comand");
Console.ReadLine();
testFixApp.Send(orderCancelReplaceRequest);
testFixApp.WaitResponces(2);
#endregion OrderCancelReplaceRequest
#region OrderStatusRequest
OrderStatusRequest orderStatusRequest = new OrderStatusRequest(
clOrdId,
symbol,
side
);
Console.WriteLine("Press enter to next comand");
Console.ReadLine();
testFixApp.Send(orderStatusRequest);
testFixApp.WaitResponces(1);
#endregion OrderStatusRequest
#region OrderCancelRequest
OrderCancelRequest orderCancelRequest = new OrderCancelRequest(
new OrigClOrdID(clOrdId.ToString()),
new ClOrdID(Guid.NewGuid().ToString()),
symbol,
side,
new TransactTime(DateTime.Now)
)
{
OrderQty = new OrderQty(0.1m)
};
Console.WriteLine("Press enter to next comand");
Console.ReadLine();
testFixApp.Send(orderCancelRequest);
testFixApp.WaitResponces(3);
#endregion region OrderCancelRequest
#region OrderMassStatusRequest
OrderMassStatusRequest orderMassStatusRequest = new OrderMassStatusRequest(
new MassStatusReqID(Guid.NewGuid().ToString()),
new MassStatusReqType(MassStatusReqType.STATUS_FOR_ALL_ORDERS))
{
Side = side,
Symbol = symbol
};
Console.WriteLine("Press enter to next comand");
Console.ReadLine();
testFixApp.Send(orderMassStatusRequest);
#endregion OrderMassStatusRequest
Console.WriteLine("Press enter to exit");
Console.ReadLine();
testFixApp.Stop();
}
public void SendOrderStatusRequest(OrderStatusRequest request)
{
SendOrderStatusRequest(request as FIXOrderStatusRequest);
}
public void SendOrderStatusRequest(OrderStatusRequest request)
{
throw new NotImplementedException();
}
