/// <summary>Called when new data is received</summary>
public override void Step()
{
base.Step();
if (Instrument.NewCandle)
{
Debugging.LogInstrument();
Debugging.BreakOnPointOfInterest();
}
// Run the position manager
if (PosMgr != null)
{
PosMgr.Step();
}
// If there is a pending order, wait for it to trigger or expire
var pending = PendingOrders.FirstOrDefault();
if (pending != null)
{
// If the price is more than the SL/TP distance from the EP then give up on the order
var dist = Math.Abs(Instrument.LatestPrice.Mid - pending.TargetPrice);
if (dist > Math.Abs(pending.TakeProfitRel()) ||
dist > Math.Abs(pending.StopLossRel()))
{
Broker.CancelPendingOrder(pending);
}
else
{
return;
}
}
// Look for an existing trade for this strategy.
var position = Positions.FirstOrDefault();
if (position == null)
{
// Look for indicators to say "enter" and which direction.
QuoteCurrency?ep, tp;
var tt = Instrument.FindTradeEntry(out ep, out tp);
if (tt == null)
{
return;
}
// Create a trade in the suggested direction
var trade = new Trade(Instrument, tt.Value, Label, ep: ep, tp: tp);
trade.Expiration = (Bot.UtcNow + Instrument.TimeFrame.ToTimeSpan(10)).DateTime;
if (trade.RtR < 0.2)
{
return;
}
// Create a pending order
Broker.CreatePendingOrder(trade);
//Broker.CreateOrder(trade);
}
}
private void CancelPendingCallback(TradeResult tr)
{
if (tr.IsSuccessful)
{
cancelPedingList.Remove(tr.PendingOrder.Label);
}
else
{
var tr2 = CancelPendingOrder(tr.PendingOrder);
if (tr2.IsSuccessful)
{
cancelPedingList.Remove(tr.PendingOrder.Label);
}
else
{
if (PendingOrders.Where(x => x.SymbolCode == Symbol.Code && x.Label == tr.PendingOrder.Label).Count() > 0)
{
Print("ERROR!!! ไม่สามารถยกเลิก pending >>>" + tr.PendingOrder.Label);
cancelPedingList.Remove(tr.PendingOrder.Label);
}
else
{
cancelPedingList.Remove(tr.PendingOrder.Label);
}
}
}
}
protected override void OnBar()
{
if (_currentPosition != null)
{
BarsSinceEntry++;
//Print("Bars since entry: {0}", BarsSinceEntry);
ModifyOppositeColourBarTrailingStop();
}
if (!_canOpenPosition || PendingOrders.Any())
{
return;
}
if (ShouldWaitBeforeLookingForNewSetup())
{
return;
}
if (_takeLongsParameter && HasBullishSignal())
{
EnterLongPosition();
}
else if (_takeShortsParameter && HasBearishSignal())
{
EnterShortPosition();
}
}
public async Task <IHttpActionResult> PutPendingOrders(int id, PendingOrders pendingOrders)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != pendingOrders.Key1)
{
return(BadRequest());
}
db.Entry(pendingOrders).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PendingOrdersExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
/// <summary>
/// Called when a quant fund is terminated.
/// </summary>
public void OnTermination()
{
//Process each on termination event handler
bool isliquidate = true;
Modules.ForEach(x =>
{
x.OnTermination(out bool liquidate);
if (!liquidate)
{
isliquidate = false;
}
});
//Check if we need to liquidate
if (isliquidate)
{
//Cancel all pending orders
var po = PendingOrders.Cancel();
po.ForEach(o => _log.Info($"Cancelled the following pending order on terminate: {o.OrderId} for fund with id {o.FundId}"));
//Liquidate current quant fund
Liquidate();
}
}
protected override void OnTimer()
{
var remainingTime = _triggerTimeInServerTimeZone - Server.Time;
DrawRemainingTime(remainingTime);
if (!_ordersCreated)
{
var sellOrderTargetPrice = Symbol.Bid - PipsAway * Symbol.PipSize;
ChartObjects.DrawHorizontalLine("sell target", sellOrderTargetPrice, Colors.Red, 1, LineStyle.DotsVeryRare);
var buyOrderTargetPrice = Symbol.Ask + PipsAway * Symbol.PipSize;
ChartObjects.DrawHorizontalLine("buy target", buyOrderTargetPrice, Colors.Blue, 1, LineStyle.DotsVeryRare);
if (Server.Time <= _triggerTimeInServerTimeZone && (_triggerTimeInServerTimeZone - Server.Time).TotalSeconds <= SecondsBefore)
{
_ordersCreated = true;
var expirationTime = _triggerTimeInServerTimeZone.AddSeconds(SecondsTimeout);
PlaceStopOrder(TradeType.Sell, Symbol, Volume, sellOrderTargetPrice, Label, StopLoss, TakeProfit, expirationTime);
PlaceStopOrder(TradeType.Buy, Symbol, Volume, buyOrderTargetPrice, Label, StopLoss, TakeProfit, expirationTime);
ChartObjects.RemoveObject("sell target");
ChartObjects.RemoveObject("buy target");
}
}
if (_ordersCreated && !PendingOrders.Any(o => o.Label == Label))
{
Print("Orders expired");
Stop();
}
}
private User(Guid id) : base(id)
{
Apply <UserCreated>(e =>
{
Login = e.Login;
Id = e.SourceId;
Account = e.Account;
});
Apply <SkuPurchaseOrdered>(
e => { PendingOrders[e.OrderId] = new PendingOrder(e.OrderId, e.SkuId, e.Quantity, e.StockId); });
Apply <PendingOrderCanceled>(e =>
{
if (!PendingOrders.Remove(e.OrderId))
{
_logger.Warning("Could not find pending order {order} to cancel", e.OrderId);
}
});
Apply <PendingOrderCompleted>(e =>
{
if (!PendingOrders.Remove(e.OrderId))
{
_logger.Warning("Could not find pending order {order} to complete",
e.OrderId);
}
});
}
public static bool ParsePendingOrders(PendingOrders pendingOrders, out Orders orders)
{
try
{
int index = 0;
orders = new Orders();
foreach (PendingOrder p in pendingOrders)
{
Order order = new Order()
{
Id = p.Id,
Label = p.Label,
TargetEntryPrice = p.TargetPrice,
StopLossPips = (double)p.StopLossPips,
StopLossPrice = (double)p.StopLoss,
TakeProfitPips = (double)p.TakeProfitPips,
TakeProfitPrice = (double)p.TakeProfit,
Volume = p.Volume,
TradeType = ParseOrderTradeType(p.TradeType),
OrderType = ParseOrderType(p.OrderType)
};
orders.Order[index] = order;
index++;
}
orders.Count = index;
}
catch (Exception e)
{
Console.WriteLine("FAILED to parse Orders: " + e.ToString());
orders = null;
return(false);
}
return(true);
}
private void UpdateOrderInformation(Order order)
{
PendingOrders = new ObservableCollection <Order>(PendingOrders.Where(x => !x.Id.Equals(order.Id) && x.Status != OrderStatus.DONE));
if (order.Status != OrderStatus.DONE)
{
PendingOrders.Add(order);
}
}
private void UpdateWork(object sender, DoWorkEventArgs e)
{
var obj = new WorkOrder(cfg);
obj.OnLog += WO_OnLog;
obj.ChangeDateScheduled(PendingOrders.Where(k => k.Update).Select(x => x.h.OrderNum).ToList(), toChange);
RaisePropertyChanged("PendingOrders");
}
protected override void OnBar()
{
if (AdjustPendingOrder && PendingOrders.Any())
{
CheckToAdjustPendingOrder();
}
base.OnBar();
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
PendingOrders pendingOrders = await db.PendingOrders.FindAsync(id);
db.PendingOrders.Remove(pendingOrders);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
protected void CloseAllOrders()
{
if (PendingOrders.Count > 0)
{
foreach (var tp in PendingOrders.OrderByDescending(x => x.Id))
{
CancelPendingOrder(tp);
}
}
}
bool _OrderStatus(double magicIndex, string symbolCode, int test)
{
Symbol symbol = (Symbol.Code == symbolCode) ? Symbol : MarketData.GetSymbol(symbolCode);
var pos = Positions.Find("FxProQuant_" + magicIndex.ToString("F0"), symbol);
if (pos != null)
{
if (test == 0)
{
return(true);
}
if (test == 1)
{
return(true);
}
if (test == 3)
{
return(pos.TradeType == TradeType.Buy);
}
if (test == 4)
{
return(pos.TradeType == TradeType.Sell);
}
}
var po = PendingOrders.__Find("FxProQuant_" + magicIndex.ToString("F0"), symbol);
if (po != null)
{
if (test == 0)
{
return(true);
}
if (test == 2)
{
return(true);
}
if (test == 3)
{
return(po.TradeType == TradeType.Buy);
}
if (test == 4)
{
return(po.TradeType == TradeType.Sell);
}
if (test == 5)
{
return(po.OrderType == PendingOrderType.Limit);
}
if (test == 6)
{
return(po.OrderType == PendingOrderType.Stop);
}
}
return(false);
}
public async Task <ActionResult> Edit([Bind(Include = "Key1,Custo,TotCusto,TType,DateOrder,DeliveryDate,RefNum,Supplier,Item,Qty,ReceivedQty,UnitPrice,Amount")] PendingOrders pendingOrders)
{
if (ModelState.IsValid)
{
db.Entry(pendingOrders).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(pendingOrders));
}
public async Task <IHttpActionResult> GetPendingOrders(int id)
{
PendingOrders pendingOrders = await db.PendingOrders.FindAsync(id);
if (pendingOrders == null)
{
return(NotFound());
}
return(Ok(pendingOrders));
}
public static PendingOrder Find(this PendingOrders pendingOrders, string label, Symbol symbol)
{
foreach (PendingOrder po in pendingOrders)
{
if (po.SymbolCode == symbol.Code && po.Label == label)
{
return(po);
}
}
return(null);
}
public async Task <IHttpActionResult> PostPendingOrders(PendingOrders pendingOrders)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.PendingOrders.Add(pendingOrders);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = pendingOrders.Key1 }, pendingOrders));
}
private void HandleCompleteOrder(object parameter)
{
var order = (Order)parameter;
//TODO: if the order is fully paid, we can close it, otherwise we should just mark it 'completed'
order.OrderStateId = order.PaymentStateId == PaymentStates.Paid ? OrderStates.Closed : OrderStates.Completed;
DataService.UpdateObject(order);
DataService.SaveChanges();
PendingOrders.Remove(order);
}
public void Handle(OrderCommited t)
{
var pendingOrder = PendingOrders.FirstOrDefault(o => o.OrderId == t.Order.OrderId);
if (pendingOrder == null)
{
return;
}
PendingOrders.Remove(pendingOrder);
Console.WriteLine($"Order Complete: {pendingOrder.OrderId}");
}
private bool FindPendingOrder(PendingOrders pendingOrders, string label, out PendingOrder order)
{
foreach (PendingOrder p in pendingOrders)
{
if (p.Label == label)
{
order = p;
return(true);
}
}
order = null;
return(false);
}
/// <summary>Called when new data is received</summary>
public override void Step()
{
base.Step();
Dump();
EMA0.Add(Instrument.LatestPrice.Mid);
var position = Positions.FirstOrDefault();
var buy = PendingOrders.FirstOrDefault(x => x.TradeType == TradeType.Buy);
var sel = PendingOrders.FirstOrDefault(x => x.TradeType == TradeType.Sell);
// If a pending order is triggered cancel the other one
if (position != null)
{
if (buy != null)
{
Broker.CancelPendingOrder(buy);
}
if (sel != null)
{
Broker.CancelPendingOrder(sel);
}
buy = null;
sel = null;
if (position.NetProfit > Broker.Balance * 0.001)
{
Broker.ModifyOrder(Instrument, position, sl: position.EntryPrice + position.Sign() * 2.0 * Instrument.Spread);
}
}
// Update the pending orders with each tick
else if (buy != null && sel != null)
{
var buy_ = new Trade(Instrument, buy);
var sel_ = new Trade(Instrument, sel);
MakeSpanningTrades(buy_, sel_);
Broker.ModifyPendingOrder(buy, buy_);
Broker.ModifyPendingOrder(sel, sel_);
}
// If there are no positions or pending orders, create them
else if (position == null && buy == null && sel == null)
{
var buy_ = new Trade(Instrument, TradeType.Buy, Label, 0, null, null, 0);
var sel_ = new Trade(Instrument, TradeType.Sell, Label, 0, null, null, 0);
MakeSpanningTrades(buy_, sel_);
Broker.CreatePendingOrder(buy_);
Broker.CreatePendingOrder(sel_);
}
}
// GET: PendingOrders/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
PendingOrders pendingOrders = await db.PendingOrders.FindAsync(id);
if (pendingOrders == null)
{
return(HttpNotFound());
}
return(View(pendingOrders));
}
private void CheckToAdjustPendingOrder()
{
var pendingOrder = PendingOrders.SingleOrDefault();
if (pendingOrder == null)
{
return;
}
if (pendingOrder.TradeType == TradeType.Buy)
{
CheckToAdjustLongPendingOrder(pendingOrder);
}
}
public async Task <IHttpActionResult> DeletePendingOrders(int id)
{
PendingOrders pendingOrders = await db.PendingOrders.FindAsync(id);
if (pendingOrders == null)
{
return(NotFound());
}
db.PendingOrders.Remove(pendingOrders);
await db.SaveChangesAsync();
return(Ok(pendingOrders));
}
public void TakeOrder(int ticketCount, decimal ticketPrice, string creditCardNumber)
{
var order = new Order
{
CreditCardNumber = creditCardNumber,
TicketCount = ticketCount,
Subtotal = ticketCount * ticketPrice
};
PendingOrders.Add(order);
Publisher.Publish(new OrderPlaced {
Order = order
});
}
/// <summary>Update the risk level from pending orders positions</summary>
private void Update(PendingOrders orders)
{
// Add up all potential losses from pending orders
var risk = (AcctCurrency)0.0;
foreach (var order in orders.Select(x => new Order(x)))
{
// The stop loss will be negative if it is on the 'win' side
// of the entry price, regardless of trade type.
var sym = Bot.GetSymbol(order.SymbolCode);
risk += sym.QuoteToAcct(order.StopLossRel) * order.Volume;
}
PendingRisk = risk;
}
TriState _DeletePending(double magicIndex, string symbolCode)
{
Symbol symbol = (Symbol.Code == symbolCode) ? Symbol : MarketData.GetSymbol(symbolCode);
var po = PendingOrders.__Find("FxProQuant_" + magicIndex.ToString("F0"), symbol);
if (po == null)
{
return(new TriState());
}
if (!CancelPendingOrder(po).IsSuccessful)
{
Thread.Sleep(400);
return(false);
}
return(true);
}
private void ReQueryOrders(object sender, EventArgs e)
{
var oldMergeOption = DataService.MergeOption;
DataService.MergeOption = MergeOption.OverwriteChanges;
var orders = DataService.Orders.Expand("OrderItems").Where(x => x.OrderStateId == OrderStates.Cooking).ToList();
foreach (var order in orders.Where(order => !PendingOrders.Contains(order)))
{
PendingOrders.Add(order);
}
foreach (var pendingOrder in PendingOrders.Where(pendingOrder => !orders.Contains(pendingOrder)))
{
PendingOrders.Remove(pendingOrder);
}
DataService.MergeOption = oldMergeOption;
}
/// <summary>Called when new data is received</summary>
public override void Step()
{
base.Step();
Debugging.BreakOnPointOfInterest();
if (Instrument.NewCandle)
{
Debugging.LogInstrument();
}
if (PendingOrders.Any())
{
return;
}
// Look for an existing trade for this strategy.
var position = Positions.FirstOrDefault();
if (position == null)
{
// 'ep' must be lower than 'tp'
var ep = 0.2;
var tp = 0.6;
var sl = 0.8;
var exp = 1;
var step = Instrument.MCS; //MedianCandleSize(-5,1);
var sym = Instrument.LatestPrice;
var trade0 = new Trade(Instrument, TradeType.Buy, Label, ep: sym.Ask + ep * step, sl: sym.Ask - sl * step, tp: sym.Ask + tp * step, risk: 0.5f)
{
Expiration = (Bot.UtcNow + Instrument.TimeFrame.ToTimeSpan(exp)).DateTime
};
var trade1 = new Trade(Instrument, TradeType.Sell, Label, ep: sym.Bid - ep * step, sl: sym.Bid + sl * step, tp: sym.Bid - tp * step, risk: 0.5f)
{
Expiration = (Bot.UtcNow + Instrument.TimeFrame.ToTimeSpan(exp)).DateTime
};
Broker.CreatePendingOrder(trade0);
Broker.CreatePendingOrder(trade1);
}
else
{
}
}
public OrderController()
{
this.pendingOrders = new PendingOrders();
}
