/// <summary>
/// Constructors to create a market indicator's data for specific stock list
/// </summary>
/// <param name="timeRange"></param>
/// <param name="timeScale"></param>
/// <param name="stockCodes"></param>
public MarketData(AppTypes.TimeRanges timeRange, AppTypes.TimeScale timeScale, StringCollection stockCodes)
{
DateTime startDate = DateTime.Today, endDate = DateTime.Today;
AppTypes.GetDate(timeRange, out startDate, out endDate);
this.Init(startDate, endDate, timeScale, stockCodes);
}
/// <summary>
/// Constructors to create a market indicator's data for all enable stock
/// </summary>
/// <param name="timeRange"></param>
/// <param name="timeScale"></param>
public MarketData(AppTypes.TimeRanges timeRange, AppTypes.TimeScale timeScale)
{
DateTime startDate = DateTime.Today, endDate = DateTime.Today;
AppTypes.GetDate(timeRange, out startDate, out endDate);
this.Init(startDate, endDate, timeScale, null);
}
public static baseDS.priceDataStatDataTable GetPriceDataStat(AppTypes.TimeScale timeScale, string code)
{
if (timeScale == AppTypes.MainDataTimeScale)
{
return(priceDataStatTA.GetStatByCode(code));
}
return(priceDataStatTA.GetStatByTypeAndCode(timeScale.Code, code));
}
protected void ShowStock(string stockCode, AppTypes.TimeRanges timeRange, AppTypes.TimeScale timeScale)
{
if (myShowStock == null)
{
return;
}
myShowStock(stockCode, timeRange, timeScale);
}
private void Init(DateTime startDateTime, DateTime endDateTime, AppTypes.TimeScale timeScale, StringCollection stockCodes)
{
this.Cache.Clear();
this.StartDateTime = startDateTime;
this.EndDateTime = endDateTime;
if (stockCodes != null && stockCodes.Count != 0)
this.StockCodeList = common.system.MakeConditionStr(stockCodes, "'", "'", ",");
else this.StockCodeList = null;
this.TimeScale = timeScale;
}
public static int GetTotalPriceRow(AppTypes.TimeScale timeScale, DateTime frDate, DateTime toDate, string stockCode)
{
switch (timeScale.Type)
{
case AppTypes.TimeScaleTypes.RealTime:
return((int)priceDataTA.GetTotalRow(frDate, toDate, stockCode));
default:
return((int)priceDataTA.GetTotalSumRow(timeScale.Code, frDate, toDate, stockCode));
}
}
public TradeAlertItem(string stockCode, string strategy, AppTypes.TimeScale timeScale, DateTime onDateTime,
double price, double volume, TradePointInfo tradePoint)
{
this.StockCode = stockCode;
this.TimeScale = timeScale;
this.Strategy = strategy;
this.OnDateTime = onDateTime;
this.Price = price;
this.Volume = volume;
this.TradePoint = tradePoint;
}
public TradeAlertItem(string stockCode, string strategy, AppTypes.TimeScale timeScale, DateTime onDateTime,
double price, double volume, TradePointInfo tradePoint)
{
this.StockCode = stockCode;
this.TimeScale = timeScale;
this.Strategy = strategy;
this.OnDateTime = onDateTime;
this.Price = price;
this.Volume = volume;
this.TradePoint = tradePoint;
}
private void ShowEstimationForm(data.baseDS.stockCodeRow stockCodeRow, data.baseDS.strategyRow strategyRow,
AppTypes.TimeScale timeScale, DateTime frDate, DateTime toDate)
{
Data data = new Data(frDate, toDate, timeScale, stockCodeRow.code);
Analysis.AnalysisResult advices = appHub.strategy.TradeAnalysis(data, strategyRow.code);
if (advices != null)
{
myAdviceEstimateForm.Init(data, advices);
myAdviceEstimateForm.ShowForm();
}
}
public void ShowForm(string stockCode, StringCollection strategyCodes, AppTypes.TimeScale timeScale)
{
watchListLb.LoadData(commonClass.SysLibs.sysLoginCode, false);
this.myStrategyCodes = strategyCodes;
this.codeEd.Text = stockCode;
this.timeScaleCb.myValue = timeScale;
strategyLb.Items.Clear();
for (int idx = 0; idx < strategyCodes.Count; idx++)
{
strategyLb.Items.Add(application.Strategy.StrategyLibs.GetMetaName(strategyCodes[idx]));
}
this.timeScaleCb.myValue = timeScale;
this.ShowDialog();
}
private void Init(DateTime startDateTime, DateTime endDateTime, AppTypes.TimeScale timeScale, StringCollection stockCodes)
{
this.Cache.Clear();
this.StartDateTime = startDateTime;
this.EndDateTime = endDateTime;
if (stockCodes != null && stockCodes.Count != 0)
{
this.StockCodeList = common.system.MakeConditionStr(stockCodes, "'", "'", ",");
}
else
{
this.StockCodeList = null;
}
this.TimeScale = timeScale;
}
private static void CreateTradeAlert(databases.baseDS.tradeAlertDataTable tradeAlertTbl, string portfolioCode,
string stockCode, string strategy, AppTypes.TimeScale timeScale, TradePointInfo info, DateTime onTime, string msg)
{
databases.baseDS.tradeAlertRow row = tradeAlertTbl.NewtradeAlertRow();
databases.AppLibs.InitData(row);
row.onTime = onTime;
row.portfolio = portfolioCode;
row.stockCode = stockCode;
row.timeScale = timeScale.Code;
row.strategy = strategy;
row.status = (byte)AppTypes.CommonStatus.New;
row.tradeAction = (byte)info.TradeAction;
row.subject = info.TradeAction.ToString();
row.msg = msg;
tradeAlertTbl.AddtradeAlertRow(row);
}
/// <summary>
/// Get aggregation date/time from a date/time
/// </summary>
/// <param name="type"></param>
/// <param name="onDateTime"></param>
/// <param name="ci"></param>
/// <returns></returns>
public static DateTime AggregateDateTime(AppTypes.TimeScale timeScale, DateTime onDateTime, CultureInfo ci)
{
if (timeScale.Type == AppTypes.TimeScaleTypes.RealTime)
{
return(onDateTime);
}
switch (timeScale.Type)
{
case AppTypes.TimeScaleTypes.Minnute:
int newMin = ((int)(onDateTime.Minute / timeScale.AggregationValue)) * timeScale.AggregationValue;
return(onDateTime.Date.AddHours(newMin));
case AppTypes.TimeScaleTypes.Hour:
int newHour = ((int)(onDateTime.Hour / timeScale.AggregationValue)) * timeScale.AggregationValue;
return(onDateTime.Date.AddHours(newHour));
case AppTypes.TimeScaleTypes.Day:
int newDay = ((int)((onDateTime.Day - 1) / timeScale.AggregationValue)) * timeScale.AggregationValue + 1;
return(common.dateTimeLibs.MakeDate(newDay, onDateTime.Month, onDateTime.Year));
case AppTypes.TimeScaleTypes.Week:
int weekNo = onDateTime.DayOfYear / 7;
int newWeek = ((int)(weekNo / timeScale.AggregationValue)) * timeScale.AggregationValue;
DateTime newDate = common.dateTimeLibs.MakeDate(1, 1, onDateTime.Year).AddDays(newWeek * 7);
return(common.dateTimeLibs.StartOfWeek(newDate, ci));
case AppTypes.TimeScaleTypes.Month:
int newMonth = ((int)((onDateTime.Month - 1) / timeScale.AggregationValue)) * timeScale.AggregationValue + 1;
return(common.dateTimeLibs.MakeDate(1, newMonth, onDateTime.Year));
case AppTypes.TimeScaleTypes.Year:
int newYear = ((int)((onDateTime.Year - 1) / timeScale.AggregationValue)) * timeScale.AggregationValue + 1;
return(common.dateTimeLibs.MakeDate(1, 1, newYear));
default:
common.system.ThrowException("Invalid argument in AggregateDateTime()");
break;
}
return(onDateTime);
}
protected void ShowTradeTransactions(data.tmpDS.stockCodeRow stockCodeRow, string strategyCode,
AppTypes.TimeRanges timeRange, AppTypes.TimeScale timeScale)
{
string formName = stockCodeRow.code.Trim() + "," + timeRange.ToString() + "," + application.Strategy.Libs.GetMetaName(strategyCode) + "," + timeScale.Code;
profitEstimate myForm = profitEstimate.GetForm(formName);
myForm.myTimeRange = timeRange;
myForm.myTimeScale = timeScale;
myForm.myStockCode = stockCodeRow.code;
myForm.myOptions = new EstimateOptions();
myForm.myStrategyCode = strategyCode;
myForm.ReLoad();
myForm.Text = "(" + formName + ")";
if (this.myDockedPane != null)
{
myForm.Show(this.myDockedPane);
}
else
{
myForm.ShowDialog();
}
}
//public static int CreateTradeAlert()
//{
// CreateTradeAlert(null, null, null);
//}
public static int CreateTradeAlert(onProcessStart onStartFunc, onProcessItem onProcessItemFunc, onProcessEnd onEndFunc)
{
DateTime frDate = common.Consts.constNullDate;
DateTime toDate = DateTime.Now;
//Run all strategy analysis for all stocks.
databases.tmpDS.stockCodeDataTable stockCodeTbl = new databases.tmpDS.stockCodeDataTable();
databases.DbAccess.LoadData(stockCodeTbl, AppTypes.CommonStatus.Enable);
application.AnalysisData data = new application.AnalysisData();
data.DataTimeRange = AppTypes.TimeRanges.None;
data.DataMaxCount = Settings.sysGlobal.AlertDataCount;
TradeAlertItem[] tradeAlertList = new TradeAlertItem[0];
StringCollection strategyList = new StringCollection();
for (int idx = 0; idx < StrategyData.MetaList.Values.Length; idx++)
{
application.Strategy.StrategyMeta meta = (application.Strategy.StrategyMeta)StrategyData.MetaList.Values[idx];
if (meta.Type != AppTypes.StrategyTypes.Strategy)
{
continue;
}
strategyList.Add(((application.Strategy.StrategyMeta)StrategyData.MetaList.Values[idx]).Code);
}
if (onStartFunc != null)
{
onStartFunc(stockCodeTbl.Count);
}
DateTime alertDate;
DateTime alertFrDate = toDate.Date;
DateTime alertToDate = toDate;
for (int stockCodeIdx = 0; stockCodeIdx < stockCodeTbl.Count; stockCodeIdx++)
{
if (onProcessItemFunc != null)
{
if (!onProcessItemFunc(stockCodeTbl[stockCodeIdx].code))
{
break;
}
}
//foreach (AppTypes.TimeScale timeScale in AppTypes.myTimeScales) //???
AppTypes.TimeScale timeScale = AppTypes.TimeScaleFromType(AppTypes.TimeScaleTypes.Day);
{
data.DataStockCode = stockCodeTbl[stockCodeIdx].code;
data.DataTimeScale = timeScale;
data.LoadData();
for (int strategyIdx = 0; strategyIdx < strategyList.Count; strategyIdx++)
{
StrategyData.ClearCache();
TradePoints advices = application.Strategy.StrategyLibs.AnalysisStrategy(data, strategyList[strategyIdx].Trim());
if ((advices == null) || (advices.Count == 0))
{
continue;
}
//Only check the last advices for alert
TradePointInfo tradeInfo = (TradePointInfo)advices[advices.Count - 1];
alertDate = DateTime.FromOADate(data.DateTime[tradeInfo.DataIdx]);
//Ignore alerts that out of date range.
if (alertDate < alertFrDate || alertDate > alertToDate)
{
continue;
}
Array.Resize(ref tradeAlertList, tradeAlertList.Length + 1);
tradeAlertList[tradeAlertList.Length - 1] = new TradeAlertItem(stockCodeTbl[stockCodeIdx].code.Trim(), strategyList[strategyIdx].Trim(),
timeScale, alertDate,
data.Close[tradeInfo.DataIdx],
data.Volume[tradeInfo.DataIdx], tradeInfo);
}
}
}
//Create alerts in the day
int noAlertCreated = CreateTradeAlert(tradeAlertList);
//Save last lun date
//SaveLastRunTime(toDate);
if (onEndFunc != null)
{
onEndFunc();
}
stockCodeTbl.Dispose();
return(noAlertCreated);
}
public static List <decimal[]> Estimate_Matrix_Profit(AppTypes.TimeRanges timeRange, AppTypes.TimeScale timeScale,
StringCollection stockCodeList, StringCollection strategyList, EstimateOptions option)
{
List <decimal[]> retList = new List <decimal[]>();
for (int rowId = 0; rowId < stockCodeList.Count; rowId++)
{
Data.ClearCache();
AnalysisData analysisData = new AnalysisData(timeRange, timeScale, stockCodeList[rowId], DataAccessMode.Local);
decimal[] rowRetList = new decimal[strategyList.Count];
for (int colId = 0; colId < strategyList.Count; colId++)
{
Data.TradePoints advices = Analysis(analysisData, strategyList[colId]);
if (advices != null)
{
rowRetList[colId] = EstimateTrading_Profit(analysisData, ToTradePointInfo(advices), option);
}
else
{
rowRetList[colId] = 0;
}
}
retList.Add(rowRetList);
}
return(retList);
}
public static tradeAnalysis GetForm(string stockCode, AppTypes.TimeRanges timeRange, AppTypes.TimeScale timeScale)
{
string cacheKey = typeof(tradeAnalysis).ToString();
tradeAnalysis form = (tradeAnalysis)common.Data.dataCache.Find(cacheKey);
if (form == null || form.IsDisposed)
{
form = new Forms.tradeAnalysis();
common.Data.dataCache.Add(cacheKey, form);
}
form.ChartTimeRange = timeRange;
form.ChartTimeScale = timeScale;
form.ChartPriceType = AppTypes.ChartTypes.Line;
form.UseStock(DataAccess.Libs.myStockCodeTbl.FindBycode(stockCode));
form.Visible = true;
return(form);
}
public static tmpDS.marketDataDataTable GetMarketData(DateTime frDate, DateTime toDate, string codeList, AppTypes.TimeScale timeScale, AppTypes.MarketDataTypes type)
{
string sqlCond = "";
if (timeScale != AppTypes.MainDataTimeScale)
{
sqlCond += (sqlCond == "" ? "" : " AND ") + " type='" + timeScale.Code + "'";
}
sqlCond += (sqlCond == "" ? "" : " AND ") +
"onDate BETWEEN '" + common.system.ConvertToSQLDateString(frDate) + "'" +
" AND '" + common.system.ConvertToSQLDateString(toDate) + "'";
sqlCond += (sqlCond == "" ? "" : " AND ");
switch (type)
{
case AppTypes.MarketDataTypes.Advancing: sqlCond += "closePrice>openPrice"; break;
case AppTypes.MarketDataTypes.Declining: sqlCond += "closePrice<openPrice"; break;
default: sqlCond += "closePrice=openPrice"; break;
}
if (codeList != null && codeList != "")
{
sqlCond += (sqlCond == "" ? "" : " AND ") + " stockCode IN (" + codeList + ")";
}
else
{
sqlCond += (sqlCond == "" ? "" : " AND ") +
" stockCode IN (SELECT code FROM stockCode WHERE status & " + ((byte)AppTypes.CommonStatus.Enable).ToString() + ">0)";
}
string sqlCmd =
"SELECT onDate,COUNT(*) AS val0,SUM(volume) AS val1" +
" FROM " + (timeScale == AppTypes.MainDataTimeScale ? "priceData" : "priceDataSum") +
" WHERE " + sqlCond +
" GROUP BY onDate ORDER BY onDate";
tmpDS.marketDataDataTable tbl = new tmpDS.marketDataDataTable();
DbAccess.LoadFromSQL(tbl, sqlCmd);
return(tbl);
}
public static List <double[]> Estimate_Matrix_LastBizWeight(AppTypes.TimeRanges timeRange, AppTypes.TimeScale timeScale,
StringCollection stockCodeList, StringCollection strategyList)
{
List <double[]> retList = new List <double[]>();
for (int rowId = 0; rowId < stockCodeList.Count; rowId++)
{
Data.ClearCache();
AnalysisData analysisData = new AnalysisData(timeRange, timeScale, stockCodeList[rowId], DataAccessMode.Local);
double[] rowRetList = new double[strategyList.Count];
for (int colId = 0; colId < strategyList.Count; colId++)
{
Data.TradePoints tradePoints = Analysis(analysisData, strategyList[colId]);
if (tradePoints != null && tradePoints.Count > 0)
{
rowRetList[colId] = (tradePoints[tradePoints.Count - 1] as TradePointInfo).BusinessInfo.Weight;
}
else
{
rowRetList[colId] = double.NaN;
}
}
retList.Add(rowRetList);
}
return(retList);
}
/// <summary>
/// Agrregate a data row to hourly,daily data...
/// </summary>
/// <param name="priceRow"> source data arregated to [toSumTbl] </param>
/// <param name="changeVolume"> volume qty changed and is cumulated to total volume </param>
/// <param name="timeScale"> aggregate to hour,day,week... data </param>
/// <param name="cultureInfo"> culture info that need to caculate the start of the week param>
/// <param name="toSumTbl"> destination table</param>
public static void AggregatePriceData(databases.baseDS.priceDataRow priceRow, decimal changeVolume, AppTypes.TimeScale timeScale,
CultureInfo cultureInfo, databases.baseDS.priceDataSumDataTable toSumTbl)
{
DateTime dataDate = AggregateDateTime(timeScale, priceRow.onDate, cultureInfo);
databases.baseDS.priceDataSumRow priceDataSumRow;
priceDataSumRow = AppLibs.FindAndCache(toSumTbl, priceRow.stockCode, timeScale.Code, dataDate);
if (priceDataSumRow == null)
{
priceDataSumRow = toSumTbl.NewpriceDataSumRow();
databases.AppLibs.InitData(priceDataSumRow);
priceDataSumRow.type = timeScale.Code;
priceDataSumRow.stockCode = priceRow.stockCode;
priceDataSumRow.onDate = dataDate;
priceDataSumRow.openPrice = priceRow.openPrice;
priceDataSumRow.closePrice = priceRow.closePrice;
object lastPriceObj = lastClosePrices.Find(timeScale.Code + priceRow.stockCode);
if (lastPriceObj != null)
{
priceDataSumRow.openPrice = (decimal)lastPriceObj;
}
else
{
priceDataSumRow.openPrice = priceDataSumRow.closePrice;
}
toSumTbl.AddpriceDataSumRow(priceDataSumRow);
}
priceDataSumRow.closePrice = priceRow.closePrice;
lastClosePrices.Add(timeScale.Code + priceRow.stockCode, priceRow.closePrice);
if (priceDataSumRow.highPrice < priceRow.highPrice)
{
priceDataSumRow.highPrice = priceRow.highPrice;
}
if (priceDataSumRow.lowPrice > priceRow.lowPrice)
{
priceDataSumRow.lowPrice = priceRow.lowPrice;
}
priceDataSumRow.volume += changeVolume;
}
//Constructors
private MarketData(DateTime startDateTime, DateTime endDateTime, AppTypes.TimeScale timeScale, StringCollection stockCodes)
{
this.Init(startDateTime, endDateTime, timeScale, stockCodes);
}
//Swicth language. Note that the order of items must be preserved
public static void SetLanguage(ComboBox.ObjectCollection items, Type type)
{
StringCollection saveKeys = new StringCollection();
for (int idx = 0; idx < items.Count; idx++)
{
common.myComboBoxItem item = (common.myComboBoxItem)items[idx];
saveKeys.Add(item.Value);
}
if (type == typeof(AppTypes.TimeScale))
{
items.Clear();
for (int idx = 0; idx < saveKeys.Count; idx++)
{
object obj = FindTimeScaleByCode(saveKeys[idx]);
if (obj == null)
{
continue;
}
AppTypes.TimeScale item = (AppTypes.TimeScale)obj;
items.Add(new common.myComboBoxItem(item.Description, item.Code));
}
return;
}
if (type == typeof(AppTypes.TradeActions))
{
items.Clear();
for (int idx = 0; idx < saveKeys.Count; idx++)
{
object obj = FindCodeInEnum(saveKeys[idx], typeof(AppTypes.TradeActions));
if (obj == null)
{
continue;
}
AppTypes.TradeActions item = (AppTypes.TradeActions)obj;
items.Add(new common.myComboBoxItem(AppTypes.Type2Text(item), item.ToString()));
}
return;
}
if (type == typeof(AppTypes.TimeRanges))
{
items.Clear();
for (int idx = 0; idx < saveKeys.Count; idx++)
{
object obj = FindCodeInEnum(saveKeys[idx], typeof(AppTypes.TimeRanges));
if (obj == null)
{
continue;
}
AppTypes.TimeRanges item = (AppTypes.TimeRanges)obj;
items.Add(new common.myComboBoxItem(AppTypes.Type2Text(item), item.ToString()));
}
return;
}
if (type == typeof(AppTypes.StrategyTypes))
{
items.Clear();
for (int idx = 0; idx < saveKeys.Count; idx++)
{
object obj = FindCodeInEnum(saveKeys[idx], typeof(AppTypes.StrategyTypes));
if (obj == null)
{
continue;
}
AppTypes.StrategyTypes item = (AppTypes.StrategyTypes)obj;
items.Add(new common.myComboBoxItem(AppTypes.Type2Text(item), item.ToString()));
}
return;
}
if (type == typeof(AppTypes.Sex))
{
items.Clear();
for (int idx = 0; idx < saveKeys.Count; idx++)
{
object obj = FindCodeInEnum(saveKeys[idx], typeof(AppTypes.Sex));
if (obj == null)
{
continue;
}
AppTypes.Sex item = (AppTypes.Sex)obj;
items.Add(new common.myComboBoxItem(AppTypes.Type2Text(item), item.ToString()));
}
return;
}
if (type == typeof(AppTypes.CommonStatus))
{
items.Clear();
for (int idx = 0; idx < saveKeys.Count; idx++)
{
object obj = FindCodeInEnum(saveKeys[idx], typeof(AppTypes.CommonStatus));
if (obj == null)
{
continue;
}
AppTypes.CommonStatus item = (AppTypes.CommonStatus)obj;
items.Add(new common.myComboBoxItem(AppTypes.Type2Text(item), item.ToString()));
}
return;
}
if (type == typeof(AppTypes.ChartTypes))
{
items.Clear();
for (int idx = 0; idx < saveKeys.Count; idx++)
{
object obj = FindCodeInEnum(saveKeys[idx], typeof(AppTypes.ChartTypes));
if (obj == null)
{
continue;
}
AppTypes.ChartTypes item = (AppTypes.ChartTypes)obj;
items.Add(new common.myComboBoxItem(AppTypes.Type2Text(item), item.ToString()));
}
return;
}
if (type == typeof(AppTypes.BizSectorTypes))
{
items.Clear();
for (int idx = 0; idx < saveKeys.Count; idx++)
{
object obj = FindCodeInEnum(saveKeys[idx], typeof(AppTypes.BizSectorTypes));
if (obj == null)
{
continue;
}
AppTypes.BizSectorTypes item = (AppTypes.BizSectorTypes)obj;
items.Add(new common.myComboBoxItem(AppTypes.Type2Text(item), item.ToString()));
}
return;
}
}
//Agrregate date time for hourly,daily data...
//public static DateTime AggregateDateTime(AppTypes.timeScales type, DateTime onDateTime, CultureInfo ci)
//{
// switch (type)
// {
// case AppTypes.timeScales.Hour1:
// return onDateTime.Date.AddHours(onDateTime.Hour);
// case AppTypes.timeScales.Hour2:
// return onDateTime.Date.AddHours(onDateTime.Hour / 2);
// case AppTypes.timeScales.Hour4:
// return onDateTime.Date.AddHours(onDateTime.Hour / 4);
// case AppTypes.timeScales.Daily:
// return onDateTime.Date;
// case AppTypes.timeScales.Weekly:
// return common.dateTimeLibs.StartOfWeek(onDateTime, ci);
// case AppTypes.timeScales.Monthly:
// return common.dateTimeLibs.MakeDate(1, onDateTime.Month, onDateTime.Year);
// case AppTypes.timeScales.Yearly:
// return common.dateTimeLibs.MakeDate(1, 1, onDateTime.Year);
// default:
// common.system.ThrowException("Invalid argument in AggregateDateTime()");
// break;
// }
// return onDateTime;
//}
/// <summary>
/// Agrregate a data row to hourly,daily data...
/// </summary>
/// <param name="priceRow"> source data arregated to [toSumTbl] </param>
/// <param name="changeVolume"> volume qty changed and is cumulated to total volume </param>
/// <param name="timeScale"> aggregate to hour,day,week... data </param>
/// <param name="cultureInfo"> culture info that need to caculate the start of the week param>
/// <param name="toSumTbl"> destination table</param>
public static void AggregatePriceData(data.baseDS.priceDataRow priceRow, decimal changeVolume, AppTypes.TimeScale timeScale,
CultureInfo cultureInfo, data.baseDS.priceDataSumDataTable toSumTbl)
{
DateTime dataDate = AggregateDateTime(timeScale, priceRow.onDate, cultureInfo);
int dataTimeOffset = common.dateTimeLibs.DateDiffInMilliseconds(dataDate, priceRow.onDate);
data.baseDS.priceDataSumRow priceDataSumRow;
priceDataSumRow = libs.FindAndCache(toSumTbl, priceRow.stockCode, timeScale.Code, dataDate);
if (priceDataSumRow == null)
{
priceDataSumRow = toSumTbl.NewpriceDataSumRow();
commonClass.AppLibs.InitData(priceDataSumRow);
priceDataSumRow.type = timeScale.Code;
priceDataSumRow.stockCode = priceRow.stockCode;
priceDataSumRow.onDate = dataDate;
priceDataSumRow.openPrice = priceRow.openPrice;
priceDataSumRow.closePrice = priceRow.closePrice;
toSumTbl.AddpriceDataSumRow(priceDataSumRow);
}
if (priceDataSumRow.openTimeOffset > dataTimeOffset)
{
priceDataSumRow.openPrice = priceRow.openPrice;
priceDataSumRow.openTimeOffset = dataTimeOffset;
}
if (priceDataSumRow.closeTimeOffset <= dataTimeOffset)
{
priceDataSumRow.closePrice = priceRow.closePrice;
priceDataSumRow.closeTimeOffset = dataTimeOffset;
}
if (priceDataSumRow.highPrice < priceRow.highPrice)
{
priceDataSumRow.highPrice = priceRow.highPrice;
}
if (priceDataSumRow.lowPrice > priceRow.lowPrice)
{
priceDataSumRow.lowPrice = priceRow.lowPrice;
}
priceDataSumRow.volume += changeVolume;
}
private MarketData(DateTime startDateTime, DateTime endDateTime, AppTypes.TimeScale timeScale)
{
this.Init(startDateTime, endDateTime, timeScale, null);
}
private void AddStockToWatchList(string stockCode, StringCollection strategyCodes, AppTypes.TimeScale timeScale)
{
baseClass.Forms.addToWatchList_StockAndStrategy myForm = baseClass.Forms.addToWatchList_StockAndStrategy.GetForm("");
myForm.ShowForm(stockCode, strategyCodes, timeScale);
}
