public object[] GetPriceByCode(string stockCode)
{
data.baseDS.priceDataRow priceRow = DbAccess.GetLastPriceData(stockCode);
if (priceRow == null)
{
return(null);
}
return(priceRow.ItemArray);
}
public static void InitData(data.baseDS.priceDataRow row)
{
row.stockCode = "";
row.onDate = DateTime.Today;
row.openPrice = 0;
row.highPrice = 0;
row.lowPrice = 0;
row.closePrice = 0;
row.volume = 0;
}
private static data.importDS.importPriceDataTable GetPrice(DateTime updateTime, string url, string marketCode)
{
data.importDS.importPriceDataTable importPriceTbl = new data.importDS.importPriceDataTable();
ForexData[] frData = ImportForex(url);
ForexData goldData = frData[3]; //Gold at price 4
if (lastForexData != null)
{
if (lastForexData.last == goldData.last &&
lastForexData.high == goldData.high &&
lastForexData.low == goldData.low)
{
return(importPriceTbl);
}
}
else
{
lastForexData = new ForexData();
}
lastForexData.last = goldData.last;
lastForexData.high = goldData.high;
lastForexData.low = goldData.low;
data.importDS.importPriceRow importRow;
importRow = importPriceTbl.NewimportPriceRow();
application.DbAccess.InitData(importRow);
importRow.onDate = updateTime;
importRow.stockExchange = marketCode;
importRow.stockCode = goldData.code;
importRow.closePrice = goldData.last;
importRow.highPrice = goldData.high;
importRow.lowPrice = goldData.low;
if (goldOpenPriceDate != updateTime.Date || goldOpenPrice == decimal.MinValue)
{
data.baseDS.priceDataRow row = application.DbAccess.GetLastPriceData(importRow.stockCode);
if (row != null)
{
goldOpenPrice = row.closePrice;
}
else
{
goldOpenPrice = importRow.closePrice;
}
goldOpenPriceDate = updateTime.Date;
}
importRow.openPrice = goldOpenPrice;
importPriceTbl.AddimportPriceRow(importRow);
return(importPriceTbl);
}
public bool GetTransactionInfo(ref TransactionInfo transInfo)
{
data.baseDS.priceDataRow priceRow = DbAccess.GetLastPriceData(transInfo.stockCode);
data.baseDS.portfolioRow portfolioRow = DbAccess.GetPortfolio(transInfo.portfolio);
data.baseDS.stockExchangeRow marketRow = application.AppLibs.GetStockExchange(transInfo.stockCode);
if (priceRow == null || portfolioRow == null || marketRow == null)
{
return(false);
}
transInfo.price = priceRow.closePrice;
transInfo.priceDate = priceRow.onDate;
transInfo.availableCash = portfolioRow.startCapAmt - portfolioRow.usedCapAmt;
transInfo.transFeePerc = marketRow.tranFeePerc;
transInfo.priceRatio = marketRow.priceRatio;
return(true);
}
private void OnUpdateData(data.baseDS.priceDataRow row, libs.importStat stat)
{
if (fCanceled)
{
stat.cancel = true;
}
this.ShowMessage(stat.updateCount.ToString("###,###,##0") + "/" +
stat.errorCount.ToString("###,###,##0") + "/" +
stat.dataCount.ToString("###,###,##0"), "Import");
//Do Aggregate and reset import to clear system resource
if (myDataSet.priceData.Count > constNumberOfImportInBatch)
{
application.DbAccess.UpdateData(myDataSet.priceData);
DoAggregate(myDataSet.priceData);
myDataSet.priceData.Clear();
}
}
//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;
}
public static void GenPriceData(string stockCode)
{
DateTime dt = DateTime.Now;
decimal lastHighPrice = 0, lastLowPrice = 0, lastClosePrice = 0, lastOpenPrice = 0, lastVolume = 0;
data.baseDS.priceDataSumRow dayPriceRow = myDailyPrice.GetData(stockCode, dt);
if (dayPriceRow == null)
{
data.baseDS.priceDataRow priceRow = application.DbAccess.GetLastPriceData(stockCode);
lastHighPrice = priceRow.highPrice;
lastLowPrice = priceRow.lowPrice;
lastClosePrice = priceRow.closePrice;
lastOpenPrice = priceRow.openPrice;
lastVolume = 0;
}
else
{
lastHighPrice = dayPriceRow.highPrice;
lastLowPrice = dayPriceRow.lowPrice;
lastClosePrice = dayPriceRow.closePrice;
lastOpenPrice = dayPriceRow.openPrice;
lastVolume = dayPriceRow.volume;
}
priceDataTbl.Clear();
importPriceTbl.Clear();
data.importDS.importPriceRow importRow = importPriceTbl.NewimportPriceRow();
application.DbAccess.InitData(importRow);
decimal highPrice = lastHighPrice + lastHighPrice * (decimal)common.system.Random(-4, 5) / 100;
decimal lowPrice = lastLowPrice + lastLowPrice * (decimal)common.system.Random(-4, 5) / 100;
decimal closePrice = lastClosePrice + lastClosePrice * (decimal)common.system.Random(-5, 5) / 100;
importRow.openPrice = lastOpenPrice;
importRow.highPrice = Math.Max(lastHighPrice, highPrice);
if (lowPrice < importRow.highPrice)
{
importRow.lowPrice = lowPrice;
}
else
{
importRow.lowPrice = importRow.highPrice;
}
if (closePrice >= importRow.lowPrice && closePrice <= importRow.highPrice)
{
importRow.closePrice = closePrice;
}
else
{
importRow.closePrice = (importRow.lowPrice + importRow.highPrice) / 2;
}
importRow.volume = lastVolume + common.system.Random(0, 100);
importRow.onDate = dt;
importRow.stockCode = stockCode;
importPriceTbl.AddimportPriceRow(importRow);
imports.libs.AddImportPrice(importPriceTbl, priceDataTbl);
application.DbAccess.UpdateData(priceDataTbl);
// In VN culture : start of week is Monday (not Sunday)
imports.libs.AggregatePriceData(priceDataTbl, vnCulture, null);
myDailyPrice.UpdateData(importRow);
}
public static void UpdateData(data.baseDS.priceDataRow row)
{
priceDataTA.Update(row);
row.AcceptChanges();
}
