public void scannerData(int reqId, int rank, ContractDetails contractDetails, string distance, string benchmark,
string projection, string legsStr)
{
// TODO: Write out contract details
WriteMessageToConsole(
$"ScannerData. ReqId: {reqId}, Rank: {rank}, Distance: {distance}, Benchmark: {benchmark}, Projection: {projection}, LegsStr: {legsStr}");
}
//! [openorderend]
//! [contractdetails]
public virtual void contractDetails(int reqId, ContractDetails contractDetails)
{
logger.LogInformation("ContractDetails begin. ReqId: " + reqId);
printContractMsg(contractDetails.Contract);
printContractDetailsMsg(contractDetails);
logger.LogInformation("ContractDetails end. ReqId: " + reqId);
}
public void printContractDetailsMsg(ContractDetails contractDetails)
{
logger.LogInformation("\tMarketName: " + contractDetails.MarketName);
logger.LogInformation("\tMinTick: " + contractDetails.MinTick);
logger.LogInformation("\tPriceMagnifier: " + contractDetails.PriceMagnifier);
logger.LogInformation("\tOrderTypes: " + contractDetails.OrderTypes);
logger.LogInformation("\tValidExchanges: " + contractDetails.ValidExchanges);
logger.LogInformation("\tUnderConId: " + contractDetails.UnderConId);
logger.LogInformation("\tLongName: " + contractDetails.LongName);
logger.LogInformation("\tContractMonth: " + contractDetails.ContractMonth);
logger.LogInformation("\tIndystry: " + contractDetails.Industry);
logger.LogInformation("\tCategory: " + contractDetails.Category);
logger.LogInformation("\tSubCategory: " + contractDetails.Subcategory);
logger.LogInformation("\tTimeZoneId: " + contractDetails.TimeZoneId);
logger.LogInformation("\tTradingHours: " + contractDetails.TradingHours);
logger.LogInformation("\tLiquidHours: " + contractDetails.LiquidHours);
logger.LogInformation("\tEvRule: " + contractDetails.EvRule);
logger.LogInformation("\tEvMultiplier: " + contractDetails.EvMultiplier);
logger.LogInformation("\tMdSizeMultiplier: " + contractDetails.MdSizeMultiplier);
logger.LogInformation("\tAggGroup: " + contractDetails.AggGroup);
logger.LogInformation("\tUnderSymbol: " + contractDetails.UnderSymbol);
logger.LogInformation("\tUnderSecType: " + contractDetails.UnderSecType);
logger.LogInformation("\tMarketRuleIds: " + contractDetails.MarketRuleIds);
logger.LogInformation("\tRealExpirationDate: " + contractDetails.RealExpirationDate);
logger.LogInformation("\tLastTradeTime: " + contractDetails.LastTradeTime);
logger.LogInformation("\tStock Type: " + contractDetails.StockType);
printContractDetailsSecIdList(contractDetails.SecIdList);
}
// This function receives the requested market scanner data results.
public virtual void scannerData(int reqId, int rank, ContractDetails contractDetails, string distance, string benchmark, string projection, string legsStr)
{
String str;
str = "scanner data @ " + DateTime.Now.ToShortTimeString();
AddTextToResponseListWindow(str);
}
//! [openorderend]
//! [contractdetails]
public virtual void contractDetails(int reqId, ContractDetails contractDetails)
{
Console.WriteLine("ContractDetails begin. ReqId: " + reqId);
IB.Program.contractDetailHandler(reqId, contractDetails);
//printContractMsg(contractDetails.Contract);
//printContractDetailsMsg(contractDetails);
Console.WriteLine("ContractDetails end. ReqId: " + reqId);
}
public void contractDetails(int reqId, ContractDetails contractDetails)
{
Console.WriteLine("/*******Incoming Contract Details - RequestId " + reqId + "************/");
Console.WriteLine(contractDetails.Summary.Symbol + " " + contractDetails.Summary.SecType + " @ " + contractDetails.Summary.Exchange);
Console.WriteLine("Expiry: " + contractDetails.Summary.Expiry + ", Right: " + contractDetails.Summary.Right);
Console.WriteLine("Strike: " + contractDetails.Summary.Strike + ", Multiplier: " + contractDetails.Summary.Multiplier);
Console.WriteLine("/******* End *************/\n");
}
override public void contractDetails(int reqId, ContractDetails contractDetails)
{
lock (_asyncObject)
{
HashSet <InstrumentInfo> instrInfo = (HashSet <InstrumentInfo>)_asyncObject[reqId];
instrInfo.Add(new InstrumentInfo(this, contractDetails));
}
}
public override void contractDetails(int reqId, ContractDetails contractDetails)
{
Console.WriteLine("/*******Incoming Contract Details - RequestId " + reqId + "************/");
Console.WriteLine(contractDetails.Summary.Symbol + " " + contractDetails.Summary.SecType + " @ " + contractDetails.Summary.Exchange);
Console.WriteLine("lastTradeDate: " + contractDetails.Summary.LastTradeDateOrContractMonth + ", Right: " + contractDetails.Summary.Right);
Console.WriteLine("Strike: " + contractDetails.Summary.Strike + ", Multiplier: " + contractDetails.Summary.Multiplier);
Console.WriteLine("/******* End *************/\n");
}
public virtual void scannerData(int reqId, int rank, ContractDetails contractDetails, string distance,
string benchmark, string projection, string legsStr)
{
logger.Info("ScannerData. " + reqId + " - Rank: " + rank + ", Symbol: " +
contractDetails.Summary.Symbol + ", SecType: " + contractDetails.Summary.SecType +
", Currency: " + contractDetails.Summary.Currency
+ ", Distance: " + distance + ", Benchmark: " + benchmark + ", Projection: " + projection +
", Legs String: " + legsStr + "\n");
}
public Scanner(int rank, ContractDetails contractDetails, string distance, string benchmark, string projection, string legsStr)
{
Rank = rank;
ContractDetails = contractDetails;
Distance = distance;
Benchmark = benchmark;
Projection = projection;
LegsStr = legsStr;
}
public virtual void bondContractDetails(int ReqId, ContractDetails contractDetails)
{
if (verbose)
{
string m = "Bond Contract Details. Req Id: " + ReqId + ", Contract Details: " + contractDetails.ToString();
msg.logMessage(clientSocket.getCurrentLocalTime(), 1, "Information", "Contract", contractDetails.UnderConId, 0, m);
Console.WriteLine(m);
}
}
void EWrapper.bondContractDetails(int requestId, ContractDetails contractDetails)
{
var tmp = BondContractDetails;
if (tmp != null)
{
tmp(requestId, contractDetails);
}
}
public virtual void scannerData(int reqId, int rank, ContractDetails contractDetails, string distance, string benchmark, string projection, string legsStr)
{
if (verbose)
{
string m = "Scanner Data. Req Id: " + reqId + ", Rank: " + rank + ", Contract Details: " + contractDetails.ToString() + ", Distance: " + distance + ", Benchmark: " + benchmark + ", Projection: " + projection + ", Legs Str: " + legsStr;
msg.logMessage(clientSocket.getCurrentLocalTime(), 1, "Information", "Market Data", contractDetails.UnderConId, 0, m);
Console.WriteLine(m);
}
}
internal ScannerDataItem(ResponseReader r)
{
Rank = r.ReadInt();
ContractDetails = new ContractDetails(r, ContractDetailsType.ScannerContractType);
Distance = r.ReadString();
Benchmark = r.ReadString();
Projection = r.ReadString();
ComboLegs = r.ReadString();
}
private void RequestMarketData(ContractDetails contractDetails)
{
int reqId = GenerateRequestId();
var baseContract = _handler.RegisterContract(reqId, contractDetails.Summary.ToContract(), contractDetails);
_consumer.Enqueue(baseContract);
_clientSocket.reqMktData(reqId, contractDetails.Summary, "100,225,233",
false, new List <TagValue>());
}
void EWrapper.bondContractDetails(int requestId, ContractDetails contractDetails)
{
var tmp = BondContractDetails;
if (tmp != null)
{
FireEvent(t => tmp(new BondContractDetailsMessage(requestId, contractDetails)), null);
}
}
void EWrapper.scannerData(int reqId, int rank, ContractDetails contractDetails, string distance, string benchmark, string projection, string legsStr)
{
var tmp = ScannerData;
if (tmp != null)
{
FireEvent(t => tmp(new ScannerMessage(reqId, rank, contractDetails, distance, benchmark, projection, legsStr)), null);
}
}
void EWrapper.contractDetails(int reqId, ContractDetails contractDetails)
{
var tmp = ContractDetails;
if (tmp != null)
{
sc.Post((t) => tmp(new ContractDetailsMessage(reqId, contractDetails)), null);
}
}
public void setConstractDetails(int reqId, ContractDetails details)
{
lock (_lock)
{
int conId = _reqContractMap[reqId];
_contractDetailMap[conId] = details;
_reqContractMap.Remove(reqId);
}
}
void EWrapper.contractDetails(int reqId, ContractDetails contractDetails)
{
var tmp = ContractDetails;
if (tmp != null)
{
FireEvent(t => tmp(new ContractDetailsMessage(reqId, contractDetails)), null);
}
}
void EWrapper.bondContractDetails(int requestId, ContractDetails contractDetails)
{
var tmp = BondContractDetails;
if (tmp != null)
{
sc.Post((t) => tmp(new BondContractDetailsMessage(requestId, contractDetails)), null);
}
}
//! [scannerparameters]
//! [scannerdata]
public virtual void scannerData(int reqId, int rank, ContractDetails contractDetails, string distance,
string benchmark, string projection, string legsStr)
{
Console.WriteLine("ScannerData. " + reqId + " - Rank: " + rank + ", Symbol: " +
contractDetails.Contract.Symbol + ", SecType: " + contractDetails.Contract.SecType +
", Currency: " + contractDetails.Contract.Currency
+ ", Distance: " + distance + ", Benchmark: " + benchmark + ", Projection: " +
projection + ", Legs String: " + legsStr);
}
void EWrapper.contractDetails(int reqId, ContractDetails contractDetails)
{
var tmp = ContractDetails;
if (tmp != null)
{
tmp(reqId, contractDetails);
}
}
void EWrapper.scannerData(int reqId, int rank, ContractDetails contractDetails, string distance, string benchmark, string projection, string legsStr)
{
var tmp = ScannerData;
if (tmp != null)
{
tmp(reqId, rank, contractDetails, distance, benchmark, projection, legsStr);
}
}
public ScannerMessage(int reqId, int rank, ContractDetails contractDetails, string distance, string benchmark, string projection, string legsStr)
{
RequestId = reqId;
Rank = rank;
ContractDetails = contractDetails;
Distance = distance;
Benchmark = benchmark;
Projection = projection;
LegsStr = legsStr;
}
public bool TryGetContractDetails(int tickerId, out ContractDetails contractDetails)
{
using (syncRoot.Lock())
{
ContractDetailsAcumulator acumulator;
contractDetailsByTicker.TryGetValue(tickerId, out acumulator);
contractDetails = acumulator?.BestDetails;
return(contractDetails != null);
}
}
private void startMarketDepth(ContractDetails contractData)
{
var id = mNextDOMTickerId++;
logMessage($"Starting market depth: id={id}; {contractToString(contractData.Contract)}");
mApi.reqMarketDepth(id, contractData.Contract, 20, false, null);
Ticker ticker = new Ticker(contractData);
mDOMTickers.Add(ticker);
}
private void startMarketDepth(ContractDetails contractDetails)
{
logMessage($"Starting market depth: {contractToString(contractDetails.Contract)}");
var id = mNextDOMTickerId++;
mApi.reqMarketDepth(id, contractDetails.Contract, 20, null);
Ticker ticker = new Ticker(contractDetails);
mDOMTickers.Add(ticker);
}
public virtual void scannerData(
int reqId,
int rank,
ContractDetails contractDetails,
string distance,
string benchmark,
string projection,
string legsStr)
{
}
public async Task GetPositionForSymbolGetsCompanyName()
{
// Arrange
const string CompanyName = "Microsoft";
var item = new PositionItem
{
Quantity = 1000,
Symbol = new Symbol {
Code = Symbol
},
Contract = new Contract {
Symbol = Symbol
}
};
var marketDataManager = Substitute.For <IMarketDataManager>();
var positionManager = Substitute.For <IPositionManager>();
var contractManager = Substitute.For <IContractManager>();
var order = new Order
{
OrderType = BrokerConstants.OrderTypes.Stop
};
var contract = new Contract {
Symbol = Symbol
};
var contractDetails = new ContractDetails()
{
LongName = CompanyName,
Contract = contract,
};
contractManager.RequestDetailsAsync(Arg.Is <Contract>(x => x.Symbol == Symbol)).Returns(new List <ContractDetails>
{
contractDetails
});
var orders = new List <OpenOrderEventArgs>
{
new OpenOrderEventArgs(1, contract, order, new OrderState())
};
positionManager.RequestOpenOrdersAsync().Returns(orders);
var vm = GetPositionForSymbolTest(item, marketDataManager, positionManager, contractManager);
// Act
await vm.GetPositionForSymbolAsync(Symbol);
// Assert
Assert.Equal(CompanyName, vm.Positions[0].Symbol.Name);
Assert.Equal(contractDetails, vm.Positions[0].ContractDetails);
}
/// <summary>
/// Full Constructor
/// </summary>
/// <param name="requestId">The ticker ID of the request to which this row is responding.</param>
/// <param name="rank">The ranking within the response of this bar.</param>
/// <param name="contractDetails">This structure contains a full description of the contract that was executed.</param>
/// <param name="distance">Meaning varies based on query.</param>
/// <param name="benchmark">Meaning varies based on query.</param>
/// <param name="projection">Meaning varies based on query.</param>
/// <param name="legsStr">Describes combo legs when scan is returning EFP.</param>
public ScannerDataEventArgs(int requestId, int rank, ContractDetails contractDetails, string distance,
string benchmark, string projection, string legsStr)
{
this.requestId = requestId;
this.legsStr = legsStr;
this.projection = projection;
this.benchmark = benchmark;
this.distance = distance;
this.contractDetails = contractDetails;
this.rank = rank;
}
public static void SetContractToDisabled(string contract, ContractGroup group)
{
Type contractType = contractTypes.Where(t => t.Name == contract).FirstOrDefault();
if (contractType == null)
{
LoggingUtil.LogWarning(typeof(ContractDisabler), "Couldn't find ContractType '" + contract + "' to disable.");
}
if (!contractDetails.ContainsKey(contractType))
{
contractDetails[contractType] = new ContractDetails(contractType);
}
ContractDetails details = contractDetails[contractType];
details.disablingGroups.AddUnique(group);
SetContractState(contractType, false);
}
/// <summary>
/// Full Constructor
/// </summary>
/// <param name="requestId">Request Id</param>
/// <param name="contractDetails">This structure contains a full description of the bond contract being looked up.</param>
public BondContractDetailsEventArgs(int requestId, ContractDetails contractDetails)
{
this.RequestId = requestId;
this.ContractDetails = contractDetails;
}
void Update()
{
// Check if we need to make a new enumerator
if (currentEnumerator == null)
{
// Prepare a list of possible selections
IEnumerable<ContractDetails> selections = contractDetails.Values.Where(cd =>
UnityEngine.Time.realtimeSinceStartup - cd.lastGenerationFailure > FAILURE_WAIT_TIME &&
cd.contracts.Count < MAX_CONTRACTS);
// Nothing is ready
if (!selections.Any())
{
return;
}
// Get a selection
int r = rand.Next(selections.Count());
currentDetails = selections.ElementAt(r);
currentEnumerator = ContractGenerator(currentDetails.prestige).GetEnumerator();
LoggingUtil.LogVerbose(this, "Got an enumerator, last failure time was " +
(UnityEngine.Time.realtimeSinceStartup - currentDetails.lastGenerationFailure) + " seconds ago");
}
// Loop through the enumerator until we run out of time, hit the end or generate a contract
float start = UnityEngine.Time.realtimeSinceStartup;
int count = 0;
while (UnityEngine.Time.realtimeSinceStartup - start < MAX_TIME)
{
count++;
if (!currentEnumerator.MoveNext())
{
// We ran through the entire enumerator, mark the failure
LoggingUtil.LogVerbose(this, "Contract generation failure");
currentDetails.lastGenerationFailure = UnityEngine.Time.realtimeSinceStartup;
currentEnumerator = null;
break;
}
KeyValuePair<ConfiguredContract, bool>? pair = currentEnumerator.Current;
if (pair != null && pair.Value.Value)
{
currentDetails.contracts.Enqueue(pair.Value.Key);
currentEnumerator = null;
break;
}
}
if (UnityEngine.Time.realtimeSinceStartup - start > 0.1)
{
LoggingUtil.LogDebug(this, "Contract attribute took too long (" + (UnityEngine.Time.realtimeSinceStartup - start) +
" seconds) to generate: " + lastKey);
}
}
/// <summary>
/// Full Constructor
/// </summary>
/// <param name="requestId">Request Id</param>
/// <param name="contractDetails">This structure contains a full description of the contract being looked up.</param>
public ContractDetailsEventArgs(int requestId, ContractDetails contractDetails)
{
this.requestId = requestId;
this.contractDetails = contractDetails;
}
void Update()
{
// Check if we need to make a new enumerator
if (currentEnumerator == null)
{
// Prepare a list of possible selections
IEnumerable<ContractDetails> selections = contractDetails.Values.Where(cd =>
UnityEngine.Time.realtimeSinceStartup - cd.lastGenerationFailure > FAILURE_WAIT_TIME &&
(cd.contracts.Count() < MAX_CONTRACTS || ContractType.AllValidContractTypes.Any(ct => ct.autoAccept && ct.prestige.Contains(cd.prestige))));
// Nothing is ready
if (!selections.Any())
{
return;
}
// Get a selection
int r = rand.Next(selections.Count());
currentDetails = selections.ElementAt(r);
currentEnumerator = ContractGenerator(currentDetails.prestige).GetEnumerator();
LoggingUtil.LogVerbose(this, "Got an enumerator, last failure time was " +
(UnityEngine.Time.realtimeSinceStartup - currentDetails.lastGenerationFailure) + " seconds ago");
}
// Loop through the enumerator until we run out of time, hit the end or generate a contract
float start = UnityEngine.Time.realtimeSinceStartup;
int count = 0;
while (UnityEngine.Time.realtimeSinceStartup - start < MAX_TIME)
{
count++;
if (!currentEnumerator.MoveNext())
{
// We ran through the entire enumerator, mark the failure
LoggingUtil.LogVerbose(this, "Contract generation failure");
currentDetails.lastGenerationFailure = UnityEngine.Time.realtimeSinceStartup;
currentEnumerator = null;
break;
}
ConfiguredContract contract = currentEnumerator.Current;
if (contract != null)
{
(contract.contractType.autoAccept ? priorityContracts : currentDetails.contracts).Enqueue(contract);
// We generated a high priority contract... force the system to do a generation pass
if (contract.contractType.autoAccept)
{
generateContractMethod.Invoke(ContractSystem.Instance, new object[] { rand.Next(int.MaxValue), contract.Prestige, 1 });
}
currentEnumerator = null;
break;
}
}
if (UnityEngine.Time.realtimeSinceStartup - start > 0.1)
{
LoggingUtil.LogDebug(this, "Contract attribute took too long (" + (UnityEngine.Time.realtimeSinceStartup - start) +
" seconds) to generate: " + lastKey);
}
}
