public static BacktestOrderModel ToOrderModel(this BacktestOrder order)
{
if (order == null)
{
return(null);
}
return(new BacktestOrderModel()
{
Cross = order.Cross,
FillPrice = FormatRate(order.Cross, order.FillPrice),
LastAsk = FormatRate(order.Cross, order.LastAsk),
LastBid = FormatRate(order.Cross, order.LastBid),
LastMid = FormatRate(order.Cross, order.LastMid),
LastUpdateTime = order.LastUpdateTime,
LimitPrice = FormatRate(order.Cross, order.LimitPrice),
OrderId = order.OrderId,
Origin = order.Origin,
PlacedTime = order.PlacedTime,
Quantity = order.Quantity / 1000,
Side = order.Side,
Status = order.Status,
StopPrice = FormatRate(order.Cross, order.StopPrice),
Type = order.Type,
History = order.History.ToOrderHistoryPointModels(),
TrailingAmount = FormatRate(order.Cross, order.TrailingAmount),
UsdQuantity = order.UsdQuantity
});
}
public async Task TestPostOrder()
{
string controllerEndpoint = "https://localhost:44379/";
OrdersConnector connector = OrdersConnector.GetConnector(controllerEndpoint);
BacktestOrder order = new BacktestOrder()
{
Cross = Cross.EURUSD,
LastUpdateTime = DateTime.Now,
LimitPrice = 1.11,
OrderId = 2,
PlacedTime = DateTime.Now.AddMinutes(-5),
Quantity = 20000,
Side = OrderSide.BUY,
Status = OrderStatusCode.PreSubmitted,
StopPrice = 1.12,
Type = OrderType.LIMIT,
UsdQuantity = 1500,
FillPrice = 1.2,
History = new List <OrderHistoryPoint>()
{
new OrderHistoryPoint()
{
Status = OrderStatusCode.PreSubmitted, Timestamp = DateTimeOffset.Now
}
},
TrailingAmount = 0.005
};
var result = await connector.PostOrder("RegTestJob", order);
Assert.IsNotNull(result);
}
internal GenericActionResult HandleOrderUpdate(string backtestJobName, BacktestOrder order)
{
if (order == null)
{
return(new GenericActionResult(false, "Invalid order object: null"));
}
logger.Debug($"Processing order update {order.OrderId}");
return(jobsControllerUtils.AddOrder(backtestJobName, order));
}
public async Task <GenericActionResult> PostOrder(string backtestJobName, BacktestOrder order, CancellationToken ct = default(CancellationToken))
{
try
{
ct.ThrowIfCancellationRequested();
if (string.IsNullOrEmpty(backtestJobName))
{
throw new ArgumentNullException(nameof(backtestJobName));
}
if (order == null)
{
throw new ArgumentNullException(nameof(order));
}
logger.Info($"About to send POST request to {controllerEndpoint}/api/orders/{backtestJobName}");
return(await controllerEndpoint.AppendPathSegment($"/api/orders/{backtestJobName}").PostJsonAsync(order, ct).ReceiveJson <GenericActionResult>());
}
catch (OperationCanceledException)
{
string err = "Not posting order update: operation cancelled";
logger.Error(err);
return(new GenericActionResult(false, err));
}
catch (ArgumentNullException ex)
{
string err = $"Not posting order update: missing or invalid parameter {ex.ParamName}";
logger.Error(err);
return(new GenericActionResult(false, err));
}
catch (Exception ex)
{
string err = "Failed to post order update";
logger.Error(err, ex);
return(new GenericActionResult(false, $"{err}: {ex.Message}"));
}
}
internal GenericActionResult AddOrder(string jobName, BacktestOrder order)
{
//BacktestJob job;
//if (activeJobs.TryGetValue(jobName, out job))
//{
// if (!job.Output.Orders.ContainsKey(order.OrderId))
// job.Output.Orders.Add(order.OrderId, order);
// else
// job.Output.Orders[order.OrderId] = order;
// activeJobs.AddOrUpdate(jobName, job, (key, oldValue) => job);
// return new GenericActionResult(true, $"Added order {order.OrderId} to job {jobName}");
//}
//else
//{
// string err = $"Not adding order to unknown job {jobName}";
// logger.Error(err);
// return new GenericActionResult(false, err);
//}
return(new GenericActionResult(false, "Disabled"));
}
public GenericActionResult Post(string backtestJobName, [FromBody] BacktestOrder order)
{
return(utils.HandleOrderUpdate(backtestJobName, order));
}
