public LimitOrder(Symbol s, Position.PositionSide side, double price, bool trailing = false, double trailsize = 0)
{
Symbol = s;
TriggerPrice = price;
Side = side;
Trailing = trailing;
TrailSize = trailsize;
}
public void ClosePosition(Symbol s)
{
OrderPlacementEngine.OrderObject orderObject = _opEngine.prepareParamsFromLoginRules(s.SymbolString);
/*
_opEngine.CreateTrueMarketCloseOrder(orderObject.AccountID, orderObject.OfferID, size,
(side.Equals(Position.PositionSide.Long)) ? "Buy" : "Sell");
*/
}
public Position(Symbol symbol, double openPrice, double size, PositionSide side, DateTime openDate)
{
Symbol = symbol;
PositionPrice = openPrice;
Side = side;
Size = size;
OpenDate = openDate;
}
public StopOrder GetStopOrder(Symbol s)
{
if (_outStandingStopOrders.ContainsKey(s))
{
return _outStandingStopOrders[s];
}
return null;
}
public bool TakePosition(Symbol s, double price, Position.PositionSide side, double size, DateTime date)
{
//Check if we can take the position, based on margin requirement
//If there's a position open for s, adjust position accordingly
_positions.Add(s, new Position(s, price, size, side, date));
return true;
}
public void GetLongHistoricPrices(string symbol, string timeframe, int ticks)
{
_mktData = new Quantum();
Symbol = new Symbol(symbol);
session.AttachHandler(mHandler);
DateTime dateNow = DateTime.Now;
TimeSpan time = Timeframe.StringToTimeSpan(timeframe);
DateTime startDate = dateNow.AddMinutes(-ticks * Timeframe.TimeframeToMinutes(timeframe));
O2GRequestFactory factory = session.Session.getRequestFactory();
O2GTimeframeCollection timeframes = factory.Timeframes;
O2GTimeframe tfo = timeframes[timeframe];
int counter = ticks;
lock (locker)
{
while (counter > 0)
{
_completeCounter++;
int subticks = (counter >= QSConstants.MAX_FXCM_API_TICKS)
? QSConstants.MAX_FXCM_API_TICKS
: counter;
O2GRequest request = factory.createMarketDataSnapshotRequestInstrument(symbol, tfo, subticks);
factory.fillMarketDataSnapshotRequestTime(request, startDate,
startDate.AddMinutes(2*subticks*Timeframe.TimeframeToMinutes(timeframe)));
session.Session.sendRequest(request);
startDate = startDate.AddMinutes(subticks*Timeframe.TimeframeToMinutes(timeframe));
counter -= (counter >= QSConstants.MAX_FXCM_API_TICKS) ? QSConstants.MAX_FXCM_API_TICKS : counter;
}
}
int timeCounter = 0;
while (!Complete || timeCounter++ < 3000) //max timeout 30 seconds
{
Thread.Sleep(100);
}
}
public void PlaceMarketOrder(Symbol sym, int size, Position.PositionSide side, double stopPips = double.NaN, double LimitPips = double.NaN)
{
if (!currentOffers.ContainsKey(sym)) return;
double orderPrice = side.Equals(Position.PositionSide.Long)
? currentOffers[sym].AskClose
: currentOffers[sym].BidClose;
//------------------------------------
// Take the position.
//------------------------------------
_portfolio.TakePosition(sym, orderPrice, side, size, currentOffers[sym].Time);
//------------------------------------
// Place Stop/Limits if defined
//------------------------------------
if (!stopPips.Equals(double.NaN))
{
StopOrder stopOrder = new StopOrder(sym, side, ((side.Equals(Position.PositionSide.Long)) ? orderPrice - stopPips : orderPrice + stopPips));
PlaceStopOrder(stopOrder);
}
if (!LimitPips.Equals(double.NaN))
{
LimitOrder limitOrder = new LimitOrder(sym, side, ((side.Equals(Position.PositionSide.Long)) ? orderPrice + LimitPips : orderPrice - LimitPips));
PlaceLimitOrder(limitOrder);
}
//------------------------------------
// Flags for visualization purposes
//------------------------------------
_flags.Add(new HighstockFlag(
(side == Position.PositionSide.Long) ? "B" : "S",
((side == Position.PositionSide.Long) ? "Bought " : "Sold ") + size + " on " + side + " at " + orderPrice + " on " + currentOffers[sym].Time.ToString(),
currentOffers[sym].Time
));
//Console.WriteLine(order.OrderDate.ToString() + "ORDER--------");
}
public bool ExistsShortPositionForSymbol(Symbol s)
{
return _portfolio.ExistsPositionForSymbol(s) && _portfolio[s].Side.Equals(Position.PositionSide.Short);
}
public bool ExistsPositionForSymbol(Symbol s)
{
return _portfolio.ExistsPositionForSymbol(s);
}
public void ClosePosition(Symbol s)
{
if (!currentOffers.ContainsKey(s)) return;
Tick t = currentOffers[s];
_tradeProfits.Add(_portfolio.ClosePosition(t,
(_portfolio.Positions[t.Symbol].isLong?t.BidClose:t.AskClose)));
//Remove Stops and Limits for position
if (_outStandingStopOrders.ContainsKey(t.Symbol))
_outStandingStopOrders.Remove(t.Symbol);
if (_outStandingLimitOrders.ContainsKey(t.Symbol))
_outStandingLimitOrders.Remove(t.Symbol);
//Flags for visualization purposes
_flags.Add(new HighstockFlag(
"C",
"Closed Order",
t.Time
));
}
public void ReducePosition(Symbol t, double size)
{
if (!currentOffers.ContainsKey(t)) return;
_portfolio.ReducePosition(currentOffers[t], size);
}
public LimitOrder GetLimitOrder(Symbol s)
{
if (_outStandingLimitOrders.ContainsKey(s))
{
return _outStandingLimitOrders[s];
}
return null;
}
public bool ExistsPositionForSymbol(Symbol s)
{
return _positions.ContainsKey(s);
}
public Position this[Symbol symbol]
{
get { return _positions[symbol]; }
}
public bool ExistsPositionForSymbol(Symbol s)
{
throw new NotImplementedException();
}
public void PlaceMarketOrder(Symbol sym, int size, Position.PositionSide side, double stopPips, double LimitPips)
{
OrderPlacementEngine.OrderObject orderObject = _opEngine.prepareParamsFromLoginRules(sym.SymbolString);
_opEngine.CreateTrueMarketOrder(orderObject.AccountID, orderObject.OfferID, size,
(side.Equals(Position.PositionSide.Long)) ? "Buy" : "Sell");
}
