public override object GetField(Main.Common.Enums.Fields field)
{
MarketDataOrderBookEntryFields mdField = (MarketDataOrderBookEntryFields)field;
if (OrderBookEntry == null || action == null)
{
return(MarketDataOrderBookEntryFields.NULL);
}
if (mdField == MarketDataOrderBookEntryFields.MDUpdateAction)
{
return(GetMDUpdateAction());
}
else if (mdField == MarketDataOrderBookEntryFields.Symbol)
{
return(OrderBookEntry.symbol);
}
else if (mdField == MarketDataOrderBookEntryFields.MDEntrySize)
{
return(OrderBookEntry.size);
}
else if (mdField == MarketDataOrderBookEntryFields.MDEntryPx)
{
return(OrderBookEntry.price);
}
else if (mdField == MarketDataOrderBookEntryFields.MDEntryType)
{
return(IsBid ? MDEntryType.Bid : MDEntryType.Ask);
}
else
{
return(MarketDataOrderBookEntryFields.NULL);
}
}
public override object GetField(Main.Common.Enums.Fields field)
{
OrderCancelRejectField xrField = (OrderCancelRejectField)field;
if (xrField == OrderCancelRejectField.ClOrdID)
{
return(ClOrderId);
}
if (xrField == OrderCancelRejectField.CxlRejReason)
{
return(CxlRejReason);
}
else if (xrField == OrderCancelRejectField.CxlRejResponseTo)
{
return(CxlRejResponseTo.OrderCancelRequest);
}
else if (xrField == OrderCancelRejectField.OrderID)
{
return(OrderId);
}
else if (xrField == OrderCancelRejectField.OrdStatus)
{
return(OrdStatus);
}
else if (xrField == OrderCancelRejectField.Side)
{
return(Side);
}
else if (xrField == OrderCancelRejectField.Price)
{
return(Price);
}
else if (xrField == OrderCancelRejectField.LeftQty)
{
return(LeftQty);
}
else if (xrField == OrderCancelRejectField.OrdQty)
{
return(OrdQty);
}
else if (xrField == OrderCancelRejectField.OrigClOrdID)
{
return(OrigClOrderId);
}
else if (xrField == OrderCancelRejectField.Text)
{
return(Text);
}
else if (xrField == OrderCancelRejectField.Symbol)
{
return(Symbol);
}
else
{
return(ExecutionReportFields.NULL);
}
}
public override object GetField(Main.Common.Enums.Fields field)
{
ExecutionReportFields xrField = (ExecutionReportFields)field;
if (xrField == ExecutionReportFields.LastReport)
{
return(LastReport);
}
else
{
return(base.GetField(field));
}
}
public override object GetField(Main.Common.Enums.Fields field)
{
MarketDataRequestField mdrField = (MarketDataRequestField)field;
if (Security == null)
{
return(MarketDataRequestField.NULL);
}
if (mdrField == MarketDataRequestField.Symbol)
{
return(Security.Symbol);
}
if (mdrField == MarketDataRequestField.Exchange)
{
if (!string.IsNullOrEmpty(Security.Exchange))
{
return(Security.Exchange);
}
else if (Security.Symbol.Contains(_EXCHANGE_SEPARATOR_FIELD))
{
return(Security.Symbol.Split(new string[] { _EXCHANGE_SEPARATOR_FIELD }, StringSplitOptions.RemoveEmptyEntries)[1]);
}
else
{
return(null);
}
}
if (mdrField == MarketDataRequestField.SecurityType)
{
return(Security.SecType);
}
if (mdrField == MarketDataRequestField.Currency)
{
return(Security.Currency);
}
if (mdrField == MarketDataRequestField.MDReqId)
{
return(MdReqId);
}
if (mdrField == MarketDataRequestField.SubscriptionRequestType)
{
return(SubscriptionRequestType);
}
else
{
return(MarketDataRequestField.NULL);
}
}
public override object GetField(Main.Common.Enums.Fields field)
{
MarketDataFields mdField = (MarketDataFields)field;
if (mdField == MarketDataFields.Error)
{
return(Error);
}
else if (mdField == MarketDataFields.Symbol)
{
return(Symbol);
}
return(MarketDataFields.NULL);
}
public override object GetField(Main.Common.Enums.Fields field)
{
MarketDataFields mdField = (MarketDataFields)field;
if (Trade == null)
{
return(MarketDataFields.NULL);
}
if (mdField == MarketDataFields.Symbol)
{
return(Trade.symbol);
}
else if (mdField == MarketDataFields.Trade)
{
return(Trade.price);
}
else if (mdField == MarketDataFields.MDTradeSize)
{
return(Trade.size);
}
else if (mdField == MarketDataFields.Timestamp)
{
TimeSpan elapsed = Trade.timestamp - new DateTime(1970, 1, 1);
return(Convert.ToInt64(elapsed.TotalMilliseconds));
}
else if (mdField == MarketDataFields.TradeId)
{
return(Trade.trdMatchID);
}
else if (mdField == MarketDataFields.Side)
{
return(GetSide());
}
else if (mdField == MarketDataFields.MyTrade)
{
return(Trade.trdMatchID != "00000000-0000-0000-0000-000000000000");
}
else if (mdField == MarketDataFields.LastTrade)
{
return(LastTrade);
}
else
{
return(MarketDataOrderBookEntryFields.NULL);
}
}
public override object GetField(Main.Common.Enums.Fields field)
{
SecurityListRequestField slrField = (SecurityListRequestField)field;
if (slrField == SecurityListRequestField.Symbol)
{
return(Symbol);
}
else if (slrField == SecurityListRequestField.SecurityListRequestType)
{
return(SecurityListRequestType);
}
else
{
return(SecurityListRequestField.NULL);
}
}
public override object GetField(Main.Common.Enums.Fields field)
{
SecurityListFields slField = (SecurityListFields)field;
if (SecurityList == null)
{
return(SecurityListFields.NULL);
}
if (slField == SecurityListFields.SecurityRequestResult)
{
return(Main.Common.Enums.SecurityRequestResult.ValidRequest);
}
else if (slField == SecurityListFields.SecurityListRequestType)
{
return(Main.Common.Enums.SecurityListRequestType.AllSecurities);
}
else if (slField == SecurityListFields.MarketID)
{
return("BitMex");
}
else if (slField == SecurityListFields.MarketSegmentID)
{
return(SecurityListFields.NULL);
}
else if (slField == SecurityListFields.TotNoRelatedSym)
{
return(SecurityList.Count);
}
else if (slField == SecurityListFields.LastFragment)
{
return("yes");
}
else if (slField == SecurityListFields.Securities)
{
return(GetSecurities());
}
return(SecurityListFields.NULL);
}
public override object GetField(Main.Common.Enums.Fields field)
{
SecurityFields sField = (SecurityFields)field;
if (Security == null)
{
return(SecurityFields.NULL);
}
if (sField == SecurityFields.Symbol)
{
return(Security.Symbol);
}
else if (sField == SecurityFields.SecurityType)
{
return(Security.SecType);
}
else if (sField == SecurityFields.Currency)
{
return(Security.Currency);
}
else if (sField == SecurityFields.Exchange)
{
return(Security.Exchange);
}
else if (sField == SecurityFields.Halted)
{
return(Security.Halted);
}
else if (sField == SecurityFields.MarketData)
{
return(new MarketDataWrapper(Security, Config));
}
return(ExecutionReportFields.NULL);
}
public override object GetField(Main.Common.Enums.Fields field)
{
ExecutionReportFields xrField = (ExecutionReportFields)field;
if (ExecutionReport == null)
{
return(ExecutionReportFields.NULL);
}
if (xrField == ExecutionReportFields.ExecType)
{
return(GetExecTypeFromBitMexStatus(ExecutionReport.ExecType));
}
if (xrField == ExecutionReportFields.ExecID)
{
return(ExecutionReport.ExecID);
}
else if (xrField == ExecutionReportFields.OrdStatus)
{
return(GetOrdStatusFromBitMexStatus(ExecutionReport.OrdStatus));
}
else if (xrField == ExecutionReportFields.OrdRejReason)
{
return(GetOrdRejReasonFromBitMexStatus(ExecutionReport.OrdRejReason));
}
else if (xrField == ExecutionReportFields.LeavesQty)
{
return(ExecutionReport.LeavesQty);
}
else if (xrField == ExecutionReportFields.CumQty)
{
return(ExecutionReport.CumQty);
}
else if (xrField == ExecutionReportFields.AvgPx)
{
return(ExecutionReport.AvgPx);
}
else if (xrField == ExecutionReportFields.Commission)
{
return(ExecutionReport.Commission);
}
else if (xrField == ExecutionReportFields.Text)
{
return(ExecutionReport.Text);
}
else if (xrField == ExecutionReportFields.TransactTime)
{
return(ExecutionReport.TransactTime);
}
else if (xrField == ExecutionReportFields.LastQty)
{
return(ExecutionReport.LastQty);
}
else if (xrField == ExecutionReportFields.LastPx)
{
return(ExecutionReport.LastPx);
}
else if (xrField == ExecutionReportFields.LastMkt)
{
return(ExecutionReport.UnderlyingLastPx);
}
if (Order == null)
{
return(ExecutionReportFields.NULL);
}
if (xrField == ExecutionReportFields.OrderID)
{
return(Order.OrderId);
}
else if (xrField == ExecutionReportFields.ClOrdID)
{
return(Order.ClOrdId);
}
else if (xrField == ExecutionReportFields.Symbol)
{
return(Order.SymbolPair);
}
else if (xrField == ExecutionReportFields.OrderQty)
{
return(Order.OrderQty);
}
else if (xrField == ExecutionReportFields.CashOrderQty)
{
return(ExecutionReportFields.NULL);
}
else if (xrField == ExecutionReportFields.OrdType)
{
return(Order.OrdType);
}
else if (xrField == ExecutionReportFields.Price)
{
return(Order.Price);
}
else if (xrField == ExecutionReportFields.StopPx)
{
return(ExecutionReportFields.NULL);
}
else if (xrField == ExecutionReportFields.Currency)
{
return(Order.Currency);
}
else if (xrField == ExecutionReportFields.ExpireDate)
{
return(ExecutionReportFields.NULL);
}
else if (xrField == ExecutionReportFields.MinQty)
{
return(ExecutionReportFields.NULL);
}
else if (xrField == ExecutionReportFields.Side)
{
return(Order.Side);
}
else if (xrField == ExecutionReportFields.QuantityType)
{
return(QuantityType.CURRENCY);//In IB v1.0 we only work with SHARE orders
}
else if (xrField == ExecutionReportFields.PriceType)
{
return(PriceType.FixedAmount);//In IB v1.0 we only work with FIXED AMMOUNT orders
}
else if (xrField == ExecutionReportFields.Account)
{
return(Order.Account);//In IB v1.0 we only work with SHARE orders
}
return(ExecutionReportFields.NULL);
}
public override object GetField(Main.Common.Enums.Fields field)
{
OrderFields oField = (OrderFields)field;
if (Order == null)
{
return(OrderFields.NULL);
}
if (oField == OrderFields.ClOrdID)
{
return(Order.ClOrdId);
}
else if (oField == OrderFields.SettlType)
{
return(Order.SettlType);
}
else if (oField == OrderFields.SettlDate)
{
return(Order.SettlDate);
}
else if (oField == OrderFields.Symbol)
{
return(Order.Security.Symbol);
}
else if (oField == OrderFields.SecurityType)
{
return(Order.Security.SecType);
}
else if (oField == OrderFields.Currency)
{
return(Order.Currency);
}
else if (oField == OrderFields.Exchange)
{
return(Order.Exchange);
}
else if (oField == OrderFields.OrdType)
{
return(Order.OrdType);
}
else if (oField == OrderFields.PriceType)
{
return(Order.PriceType);
}
else if (oField == OrderFields.Price)
{
return(Order.Price);
}
else if (oField == OrderFields.StopPx)
{
return(Order.StopPx);
}
else if (oField == OrderFields.ExpireDate)
{
return(Order.ExpireTime.HasValue ? (DateTime?)new DateTime(
Order.ExpireTime.Value.Year,
Order.ExpireTime.Value.Month,
Order.ExpireTime.Value.Day) : null);
}
else if (oField == OrderFields.ExpireTime)
{
return(Order.ExpireTime.HasValue ? (DateTime?)new DateTime(
Order.ExpireTime.Value.Year,
Order.ExpireTime.Value.Month,
Order.ExpireTime.Value.Day,
Order.ExpireTime.Value.Hour,
Order.ExpireTime.Value.Minute,
Order.ExpireTime.Value.Second) : null);
}
else if (oField == OrderFields.Side)
{
return(Order.Side);
}
else if (oField == OrderFields.OrderQty)
{
return(Order.OrderQty);
}
else if (oField == OrderFields.CashOrderQty)
{
return(Order.CashOrderQty);
}
else if (oField == OrderFields.OrderPercent)
{
return(Order.OrderPercent);
}
else if (oField == OrderFields.TimeInForce)
{
return(Order.TimeInForce);
}
else if (oField == OrderFields.MinQty)
{
return(Order.MinQty);
}
return(OrderFields.NULL);
}
public override object GetField(Main.Common.Enums.Fields field)
{
SecurityFields sField = (SecurityFields)field;
if (Security == null)
{
return(SecurityFields.NULL);
}
if (sField == SecurityFields.Symbol)
{
return(Security.SecurityAltID);//Ex: XBTZ18
}
else if (sField == SecurityFields.SecurityDesc)
{
return(Security.SecurityAltID);
}
else if (sField == SecurityFields.SecurityType)
{
return(GetSecurityType());
}
else if (sField == SecurityFields.Factor)
{
return(SecurityFields.NULL);
}
else if (sField == SecurityFields.CFICode)
{
return(SecurityFields.NULL);
}
else if (sField == SecurityFields.ContractMultiplier)
{
return(Security.ContractMultiplier);
}
else if (sField == SecurityFields.Currency)
{
return(Security.QuoteSymbol);
}
else if (sField == SecurityFields.Exchange)
{
return("BitMex");
}
else if (sField == SecurityFields.StrikePrice)
{
return(Security.StrikePrice);
}
else if (sField == SecurityFields.MaturityDate)
{
return(Security.MaturityDate);
}
else if (sField == SecurityFields.MaturityMonthYear)
{
return(Security.MaturityMonthYear);
}
else if (sField == SecurityFields.SymbolSfx)
{
return(Security.Symbol);//Ex: XBT
}
else if (sField == SecurityFields.UnderlyingSymbol)
{
return(Security.Symbol);
}
else if (sField == SecurityFields.StrikeCurrency)
{
return(Security.QuoteSymbol);
}
else if (sField == SecurityFields.MinPriceIncrement)
{
return(Security.MinPriceIncrement);
}
else if (sField == SecurityFields.TickSize)
{
return(SecurityFields.NULL);
}
else if (sField == SecurityFields.InstrumentPricePrecision)
{
return(SecurityFields.NULL);
}
else if (sField == SecurityFields.InstrumentSizePrecision)
{
return(SecurityFields.NULL);
}
else if (sField == SecurityFields.ContractPositionNumber)
{
return(SecurityFields.NULL);
}
else if (sField == SecurityFields.MarginRatio)
{
return(Security.GetMargin());
}
else if (sField == SecurityFields.ContractSize)
{
return(Security.LotSize);
}
else if (sField == SecurityFields.MarketData)
{
return(null);
}
return(SecurityFields.NULL);
}
public override object GetField(Main.Common.Enums.Fields field)
{
MarketDataFields mdField = (MarketDataFields)field;
if (Security == null)
{
return(MarketDataFields.NULL);
}
if (mdField == MarketDataFields.Symbol)
{
return(Security.Symbol);
}
else if (mdField == MarketDataFields.SecurityType)
{
return(Security.SecType);
}
else if (mdField == MarketDataFields.Currency)
{
return(Security.Currency);
}
else if (mdField == MarketDataFields.MDMkt)
{
return(Security.Exchange);
}
if (Security == null || Security.MarketData == null)
{
return(MarketDataFields.NULL);
}
if (mdField == MarketDataFields.OpeningPrice)
{
return(Security.MarketData.OpeningPrice);
}
else if (mdField == MarketDataFields.ClosingPrice)
{
return(Security.MarketData.ClosingPrice);
}
else if (mdField == MarketDataFields.TradingSessionHighPrice)
{
return(Security.MarketData.TradingSessionHighPrice);
}
else if (mdField == MarketDataFields.TradingSessionLowPrice)
{
return(Security.MarketData.TradingSessionLowPrice);
}
else if (mdField == MarketDataFields.TradingSessionLowPrice)
{
return(Security.MarketData.TradingSessionLowPrice);
}
else if (mdField == MarketDataFields.TradeVolume)
{
return(Security.MarketData.TradeVolume);
}
else if (mdField == MarketDataFields.OpenInterest)
{
return(Security.MarketData.OpenInterest);
}
else if (mdField == MarketDataFields.SettlType)
{
return(Security.MarketData.SettlType);
}
else if (mdField == MarketDataFields.CompositeUnderlyingPrice)
{
return(Security.MarketData.CompositeUnderlyingPrice);
}
else if (mdField == MarketDataFields.MidPrice)
{
return(Security.MarketData.MidPrice);
}
else if (mdField == MarketDataFields.SessionHighBid)
{
return(Security.MarketData.SessionHighBid);
}
else if (mdField == MarketDataFields.SessionLowOffer)
{
return(Security.MarketData.SessionLowOffer);
}
else if (mdField == MarketDataFields.EarlyPrices)
{
return(Security.MarketData.EarlyPrices);
}
else if (mdField == MarketDataFields.Trade)
{
return(Security.MarketData.Trade);
}
else if (mdField == MarketDataFields.MDTradeSize)
{
return(Security.MarketData.MDTradeSize);
}
else if (mdField == MarketDataFields.BestBidPrice)
{
return(Security.MarketData.BestBidPrice);
}
else if (mdField == MarketDataFields.BestAskPrice)
{
return(Security.MarketData.BestAskPrice);
}
else if (mdField == MarketDataFields.BestBidSize)
{
return(Security.MarketData.BestBidSize);
}
else if (mdField == MarketDataFields.BestBidCashSize)
{
return(Security.MarketData.BestBidCashSize);
}
else if (mdField == MarketDataFields.BestAskSize)
{
return(Security.MarketData.BestAskSize);
}
else if (mdField == MarketDataFields.BestAskCashSize)
{
return(Security.MarketData.BestAskCashSize);
}
else if (mdField == MarketDataFields.BestBidExch)
{
return(Security.MarketData.BestBidExch);
}
else if (mdField == MarketDataFields.BestAskExch)
{
return(Security.MarketData.BestAskExch);
}
else if (mdField == MarketDataFields.MDEntryDate)
{
return(Security.MarketData.MDEntryDate);
}
else if (mdField == MarketDataFields.MDEntryTime)
{
return(Security.MarketData.MDLocalEntryDate);
}
else if (mdField == MarketDataFields.MDLocalEntryDate)
{
return(Security.MarketData.MDLocalEntryDate);
}
else if (mdField == MarketDataFields.ReverseMarketData)
{
return(Security.ReverseMarketData);
}
else if (mdField == MarketDataFields.LastTradeDateTime)
{
return(Security.MarketData.LastTradeDateTime);
}
else if (mdField == MarketDataFields.PercentageChange)
{
return(Security.MarketData.PercentageChange);
}
return(MarketDataFields.NULL);
}
public override object GetField(Main.Common.Enums.Fields field)
{
return(null);
}
public override object GetField(Main.Common.Enums.Fields field)
{
return(ExecutionReportFields.NULL);
}
public override object GetField(Main.Common.Enums.Fields field)
{
PositionFields pField = (PositionFields)field;
if (Position == null)
{
return(PositionFields.NULL);
}
if (pField == PositionFields.Symbol)
{
return(Position.Security.Symbol);
}
else if (pField == PositionFields.PosId)
{
return(Position.PosId);
}
else if (pField == PositionFields.Exchange)
{
return(Position.Exchange);
}
else if (pField == PositionFields.QuantityType)
{
return(Position.QuantityType);
}
else if (pField == PositionFields.PriceType)
{
return(Position.PriceType);
}
else if (pField == PositionFields.Qty)
{
return(Position.Qty);
}
else if (pField == PositionFields.CashQty)
{
return(Position.CashQty);
}
else if (pField == PositionFields.Percent)
{
return(Position.Percent);
}
else if (pField == PositionFields.ExecutionReports)
{
return(Position.ExecutionReports);
}
else if (pField == PositionFields.Orders)
{
return(Position.Orders);
}
else if (pField == PositionFields.Side)
{
return(Position.Side);
}
else if (pField == PositionFields.PosStatus)
{
return(Position.PosStatus);
}
else if (pField == PositionFields.Security)
{
return(new SecurityWrapper(Position.Security, Config));
}
else if (pField == PositionFields.Currency)
{
return(Position.Security.Currency);
}
else if (pField == PositionFields.SecurityType)
{
return(Position.Security.SecType);
}
else if (pField == PositionFields.Account)
{
return(Position.AccountId);
}
return(ExecutionReportFields.NULL);
}
