public static ScannerConfig GetOptVolumeMostActiveScannerConfig()
{
double[] prices = { 0, 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 82, 103, 124, 194, 264 };
var scannerConfig = new ScannerConfig()
{
Id = 1,
Enable = true,
StartTime = Exchange.MarketOpenHour,
EndTime = Exchange.MarketCloseHour,
Frequency = 60
};
for (int i = 0; i < prices.Length; i++)
{
var parameter = new ScannerParameter()
{
ScanCode = MostActiveOption,
Instrument = "STK",
LocationCode = "STK.US",
NumberOfRows = 50,
AbovePrice = prices[i],
};
if (i != prices.Length - 1)
{
parameter.BelowPrice = prices[i + 1] + 0.01;
}
scannerConfig.Parameters.Add(parameter);
}
return(scannerConfig);
}
public static ScannerConfig GetConfiguredScannerConfig(int scannerConfigId, string scanCode, TimeSpan startTime, TimeSpan endTime)
{
double[] prices = { 0, 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 82, 103, 124, 194, 264 };
var scannerConfig = new ScannerConfig()
{
Id = scannerConfigId,
Enable = true,
StartTime = startTime,
EndTime = endTime,
Frequency = 60
};
for (int i = 0; i < prices.Length; i++)
{
var parameter = new ScannerParameter()
{
ScanCode = scanCode,
Instrument = "STK",
LocationCode = "STK.US",
NumberOfRows = 50,
AbovePrice = prices[i],
};
if (i != prices.Length - 1)
{
parameter.BelowPrice = prices[i + 1] + 0.01;
}
scannerConfig.Parameters.Add(parameter);
}
return(scannerConfig);
}
public static Scanner CreateScanner(GridModel grid, ScannerParameter kbScanParams)
{
if (!GetScannerActive(grid, kbScanParams))
{
logger.Debug("No scanner is created, because it's explicitly deactivated!");
return(null);
}
string type = GetScannerType(grid, kbScanParams);
try { return(createScanners[type](grid, kbScanParams)); }
catch (Exception e)
{
string msg;
if (e is KeyNotFoundException)
{
msg = String.Format("Scanner of type '{0}' isn't implemented!", type);
}
else
{
msg = "Unrecognized exception occurred while creating scanner!";
}
throw new Exception(msg);
}
}
private static Scanner BuildScanner(GridModel grid, ScannerParameter kbScanParams)
{
try { return(ScannerFactory.CreateScanner(grid, kbScanParams)); }
catch (Exception e)
{
logger.Error("Building scanner for grid '{0}' failed!\n{1}", grid.Id, e.Message);
return(null);
}
}
private static void GetScanTimes(GridModel grid, ScannerParameter kbScanParams,
out int initialScanDelay, out int postAcceptanceDelay, out int postInputAcceptanceTime, out int scanTime)
{
if (InitialScanDelayIsDefined(grid.ScanParams))
{
initialScanDelay = grid.ScanParams.InitialScanDelay.Value;
}
else if (InitialScanDelayIsDefined(kbScanParams))
{
initialScanDelay = kbScanParams.InitialScanDelay.Value;
}
else
{
initialScanDelay = Config.Scanner.InitialScanDelay;
}
if (PostAcceptanceDelayIsDefined(grid.ScanParams))
{
postAcceptanceDelay = grid.ScanParams.PostAcceptanceDelay.Value;
}
else if (PostAcceptanceDelayIsDefined(kbScanParams))
{
postAcceptanceDelay = kbScanParams.PostAcceptanceDelay.Value;
}
else
{
postAcceptanceDelay = Config.Scanner.PostAcceptanceDelay;
}
if (PostInputAcceptanceTimeIsDefined(grid.ScanParams))
{
postInputAcceptanceTime = grid.ScanParams.PostInputAcceptanceTime.Value;
}
else if (PostInputAcceptanceTimeIsDefined(kbScanParams))
{
postInputAcceptanceTime = kbScanParams.PostInputAcceptanceTime.Value;
}
else
{
postInputAcceptanceTime = Config.Scanner.PostInputAcceptanceTime;
}
if (ScanTimeIsDefined(grid.ScanParams))
{
scanTime = grid.ScanParams.ScanTime.Value;
}
else if (ScanTimeIsDefined(kbScanParams))
{
scanTime = kbScanParams.ScanTime.Value;
}
else
{
scanTime = Config.Scanner.ScanTime;
}
}
public static ScannerSubscription ToScannerSubscription(this ScannerParameter param)
{
var res = new ScannerSubscription();
if (param.NumberOfRows.HasValue)
{
res.NumberOfRows = (int)param.NumberOfRows;
}
if (param.AbovePrice.HasValue)
{
res.AbovePrice = (double)param.AbovePrice;
}
if (param.BelowPrice.HasValue)
{
res.BelowPrice = (double)param.BelowPrice;
}
if (param.AboveVolume.HasValue)
{
res.AboveVolume = (int)param.AboveVolume;
}
if (param.AverageOptionVolumeAbove.HasValue)
{
res.AverageOptionVolumeAbove = (int)param.AverageOptionVolumeAbove;
}
if (param.MarketCapAbove.HasValue)
{
res.MarketCapAbove = (double)param.MarketCapAbove;
}
if (param.MarketCapBelow.HasValue)
{
res.MarketCapBelow = (double)param.MarketCapBelow;
}
if (param.CouponRateAbove.HasValue)
{
res.CouponRateAbove = (double)param.CouponRateAbove;
}
if (param.CouponRateBelow.HasValue)
{
res.CouponRateBelow = (double)param.CouponRateBelow;
}
res.Instrument = param.Instrument;
res.LocationCode = param.LocationCode;
res.ScanCode = param.ScanCode;
res.MoodyRatingAbove = param.MoodyRatingAbove;
res.MoodyRatingBelow = param.MoodyRatingBelow;
res.SpRatingAbove = param.SpRatingAbove;
res.SpRatingBelow = param.SpRatingBelow;
res.MaturityDateAbove = param.MaturityDateAbove;
res.MaturityDateBelow = param.MaturityDateBelow;
res.ExcludeConvertible = param.ExcludeConvertible;
res.ScannerSettingPairs = param.ScannerSettingPairs;
res.StockTypeFilter = param.StockTypeFilter;
return(res);
}
public static Grid BuildGrid(GridModel model, ScannerParameter kbScanParams, GeneralStyle kbStyle)
{
InheritStyleTillButtons(model, kbStyle);
GridStatusImpl status = new GridStatusImpl(model);
Drawer drawer = BuildDrawer(model, status);
Scanner scanner = BuildScanner(model, kbScanParams);
return(new Grid(model, status, drawer, scanner));
}
private static Scanner CreateColumnRowScanner(GridModel grid, ScannerParameter kbScanParams)
{
logger.Debug("Creating ColumnRowScanner...");
int isd, pad, piat, st;
GetScanTimes(grid, kbScanParams, out isd, out pad, out piat, out st);
bool top = GetStartTop(grid, kbScanParams);
bool left = GetStartLeft(grid, kbScanParams);
int lcl = GetLocalCycleLimit(grid, kbScanParams);
return(new ColumnRowScanner(grid, isd, pad, piat, st, top, left, lcl));
}
public ScannerRequest(TimeSpan startTime, TimeSpan endTime, int frequency, ScannerParameter parameter, ITimeProvider timeProvider)
{
StartTime = startTime;
EndTime = endTime;
Frequency = TimeSpan.FromSeconds(frequency);
Parameter = parameter;
_timeProvider = timeProvider;
_cts = new CancellationTokenSource();
_semaphoreSlim = new SemaphoreSlim(0, 1);
// default
_previousScanner = new Scanner();
}
private static Scanner CreateTestScanner(GridModel grid, ScannerParameter kbScanParams)
{
logger.Debug("Creating TestScanner...");
int isd, pad, piat, st;
GetScanTimes(grid, kbScanParams, out isd, out pad, out piat, out st);
//isd = 0;
//pad = 0;
//piat = 0;
//st = 300;
return(new TestScanner(grid, isd, pad, piat, st));
}
public Task <Scanner> GetScannerAsync(ScannerParameter scannerParameter)
{
var ct = new CancellationTokenSource(DefaultTimeoutMs);
var res = new TaskCompletionSource <Scanner>();
ct.Token.Register(() => res.TrySetCanceled(), false);
var reqId = new Random(DateTime.Now.Millisecond).Next();
var ibScanner = new Scanner();
EventHandler <ScannerEventArgs> scanner = (sender, args) =>
{
if (args.RequestId != reqId)
{
return;
}
ibScanner.Rows.Add(new ScannerRow()
{
Rank = args.Rank, Symbol = args.ContractDetails.Summary.Symbol
});
};
EventHandler <ScannerEndEventArgs> scannerEnd = (sender, args) =>
{
if (args.RequestId != reqId)
{
return;
}
res.TrySetResult(ibScanner);
};
EventDispatcher.Scanner += scanner;
EventDispatcher.ScannerEnd += scannerEnd;
ClientSocket.reqScannerSubscription(reqId, scannerParameter.ToScannerSubscription(), new List <TagValue>());
res.Task.ContinueWith(x =>
{
ClientSocket.cancelScannerSubscription(reqId);
EventDispatcher.Scanner -= scanner;
EventDispatcher.ScannerEnd -= scannerEnd;
}, TaskContinuationOptions.None);
return(res.Task);
}
private static bool GetStartLeft(GridModel grid, ScannerParameter kbScanParams)
{
bool left;
if (StartLeftIsDefined(grid.ScanParams))
{
left = grid.ScanParams.StartLeft.Value;
}
else if (StartLeftIsDefined(kbScanParams))
{
left = kbScanParams.StartLeft.Value;
}
else
{
left = Config.Scanner.StartLeft;
}
return(left);
}
private static string GetScannerType(GridModel grid, ScannerParameter kbScanParams)
{
string type;
if (ScannerTypeIsDefined(grid.ScanParams))
{
type = grid.ScanParams.ScannerType;
}
else if (ScannerTypeIsDefined(kbScanParams))
{
type = kbScanParams.ScannerType;
}
else
{
type = Config.Scanner.ScannerType;
}
return(type);
}
private static bool GetScannerActive(GridModel grid, ScannerParameter kbScanParams)
{
bool active = false;
if (ScannerActiveIsDefined(grid.ScanParams))
{
active = grid.ScanParams.ScannerActive.Value;
}
else if (ScannerActiveIsDefined(kbScanParams))
{
active = kbScanParams.ScannerActive.Value;
}
else
{
active = Config.Scanner.ScannerActive;
}
return(active);
}
private static bool GetMoveHorizontal(GridModel grid, ScannerParameter kbScanParams)
{
bool hrz;
if (MoveHorizontalIsDefined(grid.ScanParams))
{
hrz = grid.ScanParams.MoveHorizontal.Value;
}
else if (MoveHorizontalIsDefined(kbScanParams))
{
hrz = kbScanParams.MoveHorizontal.Value;
}
else
{
hrz = Config.Scanner.MoveHorizontal;
}
return(hrz);
}
private static bool GetStartTop(GridModel grid, ScannerParameter kbScanParams)
{
bool top;
if (StartTopIsDefined(grid.ScanParams))
{
top = grid.ScanParams.StartTop.Value;
}
else if (StartTopIsDefined(kbScanParams))
{
top = kbScanParams.StartTop.Value;
}
else
{
top = Config.Scanner.StartTop;
}
return(top);
}
private static Scanner CreateLinearScanner(GridModel grid, ScannerParameter kbScanParams)
{
logger.Debug("Creating LinearScanner...");
int isd, pad, piat, st;
GetScanTimes(grid, kbScanParams, out isd, out pad, out piat, out st);
bool top = GetStartTop(grid, kbScanParams);
bool left = GetStartLeft(grid, kbScanParams);
bool hrz = GetMoveHorizontal(grid, kbScanParams);
//st = 300;
//top = false;
//left = false;
//hrz = false;
return(new LinearScanner(grid, isd, pad, piat, st, top, left, hrz));
}
private static int GetLocalCycleLimit(GridModel grid, ScannerParameter kbScanParams)
{
int limit;
if (LocalCycleLimitIsDefined(grid.ScanParams))
{
limit = grid.ScanParams.LocalCycleLimit.Value;
}
else if (LocalCycleLimitIsDefined(kbScanParams))
{
limit = kbScanParams.LocalCycleLimit.Value;
}
else
{
limit = Config.Scanner.LocalCycleLimit;
}
return(limit);
}
public void Whenever_Time_UntilExpiration_Should_Return_BusinessDay_Between_Start_And_End_Time(DateTime now)
{
// Arrange
var startTime = new TimeSpan(9, 30, 0);
var endTime = new TimeSpan(16, 0, 0);
var frequency = 60;
var scannerParameter = new ScannerParameter();
var timeProvider = new Mock <ITimeProvider>();
timeProvider.SetupGet(x => x.Now).Returns(now);
// Act
var scannerRequest = new ScannerRequest(startTime, endTime, frequency, scannerParameter, timeProvider.Object);
var next = now + scannerRequest.UntilExpiration;
// Assert
Assert.True(next.IsBusinessDay());
Assert.True(next.TimeOfDay >= startTime);
Assert.True(next.TimeOfDay <= endTime);
}
private static bool StartTopIsDefined(ScannerParameter scanParams)
{
return(scanParams != null && scanParams.StartTop.HasValue);
}
private static bool ScannerTypeIsDefined(ScannerParameter scanParams)
{
return(!(scanParams == null || String.IsNullOrEmpty(scanParams.ScannerType)));
}
private static bool InitialScanDelayIsDefined(ScannerParameter scanParams)
{
return(scanParams != null && scanParams.InitialScanDelay.HasValue);
}
private static bool PostAcceptanceDelayIsDefined(ScannerParameter scanParams)
{
return(scanParams != null && scanParams.PostAcceptanceDelay.HasValue);
}
private static bool PostInputAcceptanceTimeIsDefined(ScannerParameter scanParams)
{
return(scanParams != null && scanParams.PostInputAcceptanceTime.HasValue);
}
private static bool ScanTimeIsDefined(ScannerParameter scanParams)
{
return(scanParams != null && scanParams.ScanTime.HasValue);
}
private static bool LocalCycleLimitIsDefined(ScannerParameter scanParams)
{
return(scanParams != null && scanParams.LocalCycleLimit.HasValue);
}
private static bool MoveHorizontalIsDefined(ScannerParameter scanParams)
{
return(scanParams != null && scanParams.MoveHorizontal.HasValue);
}
