/// <summary>
/// 验证是否在撮合中心接受委托时间内
/// </summary>
/// <param name="type">商品所属类别用来为了区分查询港股代码</param>
/// <param name="code">具体的交易代码</param>
/// <returns>是否在接受委托时间内</returns>
public static bool IsMatchTradingTime(Types.BreedClassTypeEnum type, string code)
{
CM_BourseType bourseType = MCService.CommonPara.GetBourseTypeByCommodityCode(code, type);
if (bourseType == null)
{
return(false);
}
// 撮合接收委托开始时间
DateTime matchBeginTime = bourseType.ReceivingConsignStartTime.Value;
matchBeginTime = SetNowDate(matchBeginTime);
// 撮合接收委托结束时间
DateTime matchEndTime = bourseType.ReceivingConsignEndTime.Value;
matchEndTime = SetNowDate(matchEndTime);
DateTime now = DateTime.Now;
if (Utils.CompareTime(matchBeginTime, now) <= 0 && Utils.CompareTime(matchEndTime, now) >= 0)
{
return(true);
}
return(false);
}
/// <summary>
/// 创建一个今日成交记录
/// </summary>
/// <param name="registerTable">登记表实体</param>
/// <param name="intNum">分红过户量</param>里
/// <returns>今日成交实体</returns>
private static XH_TodayTradeTableInfo GetTodayTradeTable(XH_MelonCutRegisterTableInfo registerTable, int intNum)
{
XH_TodayTradeTableInfo todayTradeTable = new XH_TodayTradeTableInfo();
todayTradeTable.TradeNumber = Guid.NewGuid().ToString();
todayTradeTable.BuySellTypeId = (int)GTA.VTS.Common.CommonObject.Types.TransactionDirection.Buying;
todayTradeTable.StockAccount = registerTable.UserAccountDistributeLogo;
todayTradeTable.TradeTypeId = (int)Types.DealRptType.DRTTransfer;
todayTradeTable.CurrencyTypeId = registerTable.TradeCurrencyType;
todayTradeTable.TradeUnitId = MCService.GetPriceUnit(registerTable.Code);
todayTradeTable.TradeAmount = intNum;
todayTradeTable.TradeTime = DateTime.Now;
CM_BourseType bourseType = MCService.CommonPara.GetBourseTypeByCommodityCode(registerTable.Code);
if (bourseType != null)
{
}
CM_Commodity commodity = MCService.CommonPara.GetCommodityByCommodityCode(registerTable.Code);
todayTradeTable.SpotCode = registerTable.Code;
if (commodity != null)
{
}
CM_BreedClass breedClass = MCService.CommonPara.GetBreedClassByCommodityCode(registerTable.Code);
if (breedClass != null)
{
}
return(todayTradeTable);
}
//================================ 事件 ================================
#region 交易时间管理窗体 TradeTimeManagerUI_Load
/// <summary>
/// 交易时间管理窗体 TradeTimeManagerUI_Load
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TradeTimeManagerUI_Load(object sender, EventArgs e)
{
try
{
if (EditType == (int)UITypes.EditTypeEnum.AddUI)
{
m_CM_BourseType = new CM_BourseType();
m_CM_TradeTime = new CM_TradeTime();
_dtTradeTime.Columns.Add(gdvTradeTimeSelect.Columns[0].FieldName, Type.GetType("System.String"));
//添加时在自定义的交易时间DataTabel中新增2列
_dtTradeTime.Columns.Add(gdvTradeTimeSelect.Columns[1].FieldName, Type.GetType("System.String"));
_dtTradeTime.Columns.Add(gdvTradeTimeSelect.Columns[2].FieldName, Type.GetType("System.String"));
this.btnUpdateTradeTime.Enabled = false;
this.btnOk.Text = "确定";
}
if (EditType == (int)UITypes.EditTypeEnum.UpdateUI)
{
UpdateInitData();
QueryCMTradeTime();
this.btnOk.Text = "修改交易所类型";
}
}
catch (Exception ex)
{
string errCode = "GL-4440";
string errMsg = "交易时间管理窗体加载失败!";
var exception = new VTException(errCode, errMsg, ex);
LogHelper.WriteError(exception.ToString(), exception.InnerException);
return;
}
}
/// <summary>
/// 获取当前月份最后交易日
/// </summary>
/// <param name="LastTradingDayEntity"></param>
/// <param name="code"></param>
/// <returns></returns>
private static int GetLastTradingDay(QH_LastTradingDay LastTradingDayEntity, string code)
{
//交易所代码
CM_BourseType _CMBourseType = GetCM_BourseTypeByCommodityCode(code);
int bourseTypeID = _CMBourseType.BourseTypeID;
switch ((int)LastTradingDayEntity.LastTradingDayTypeID)
{
//第几天
case (int)Types.QHLastTradingDayType.DeliMonthAndDay:
return(DeliMonthOfDay(LastTradingDayEntity, code));
// return int.MaxValue;
//倒数或者顺数第几个交易日
case (int)Types.QHLastTradingDayType.DeliMonthAndDownOrShunAndWeek:
return(DeliMonthOfTurnOrBackTrandingDay(LastTradingDayEntity, bourseTypeID));
// return int.MaxValue;
//交割月份的前一个月份的倒数或者顺数第几个交易日
case (int)Types.QHLastTradingDayType.DeliMonthAgoMonthLastTradeDay:
return(DeliMonthOfAgoMonthTradeDay(LastTradingDayEntity, bourseTypeID));
// return int.MaxValue;
//第几周的星期几
case (int)Types.QHLastTradingDayType.DeliMonthAndWeek:
return(DeliMonthOfWeekDay(LastTradingDayEntity, bourseTypeID));
// return int.MaxValue;
}
return(0);
}
private static void SetBeginTime(DateTime time, CM_BourseType type, Types.TradingTimeType timeType)
{
string sTime = GetKeyTime(time);
if (!matchTimes.Contains(sTime))
{
matchTimes.Add(sTime);
}
if (FirstBeginTime.Year == 2000)
{
FirstBeginTime = time;
return;
}
if (FirstBeginTime.Hour > time.Hour)
{
FirstBeginTime = time;
return;
}
if (FirstBeginTime.Hour == time.Hour)
{
if (FirstBeginTime.Minute > time.Minute)
{
FirstBeginTime = time;
}
}
}
/// <summary>
/// 获取需要更新的交易所类型数据 UpdateCMBourseType
/// </summary>
/// <param name="handle"></param>
private void UpdateCMBourseType(int handle)
{
try
{
if (handle < 0)
{
return;
}
//// 显示添加交易所类型UI
//AddBourseUI addBourseUI = new AddBourseUI();
//addBourseUI.EditType = (int) UITypes.EditTypeEnum.UpdateUI;
//显示添加交易时间窗体
TradeTimeManagerUI tradeTimeManagerUI = new TradeTimeManagerUI();
tradeTimeManagerUI.EditType = (int)UITypes.EditTypeEnum.UpdateUI;
DataRow _dr = this.gdvBourseTypeSelect.GetDataRow(handle);
int bourseTypeID = Convert.ToInt32(_dr["BourseTypeID"]);
CM_BourseType cM_BourseType = CommonParameterSetCommon.GetCMBourseTypeModel(bourseTypeID);
tradeTimeManagerUI.CMBourseType = cM_BourseType;
if (tradeTimeManagerUI.ShowDialog(this) == DialogResult.OK)
{
this.QueryCMBourseType();
this.gdvBourseTypeSelect.FocusedRowHandle = handle;
}
}
catch (Exception ex)
{
string errCode = "GL-4402";
string errMsg = "获取需要更新的现货交易费用数据失败!";
VTException exception = new VTException(errCode, errMsg, ex);
LogHelper.WriteError(exception.ToString(), exception.InnerException);
return;
}
}
/// <summary>
/// 判断当前时间是否清空当前撮合机中的委托
/// </summary>
/// <returns></returns>
public bool IsEndTime(int bourseTypeID)
{
CM_BourseType cm_bourseType = CommonDataCacheProxy.Instanse.GetCacheCM_BourseTypeByKey(bourseTypeID);
if (cm_bourseType == null || cm_bourseType.ReceivingConsignEndTime == null)
{
return(false);
}
DateTime endTime = ((DateTime)cm_bourseType.ReceivingConsignEndTime);
DateTime tmpTime = endTime.AddHours(AppConfig.GetConfigClearTime());
//当收市时间超过当天时，取当天最后时间
if ((tmpTime.Date - endTime.Date).Days > 0)
{
tmpTime = Utils.ConvertToDateTime(DateTime.Now.ToShortDateString(), "23:59:59");
return((DateTime.Now >= tmpTime) ? true : false);
}
if (DateTime.Now >= Utils.ConvertToNowDateTime(tmpTime))
{
return(true);
}
return(false);
}
/// <summary>
/// 指定时间是否在交易日内
/// </summary>
/// <param name="code">商品代码</param>
/// <param name="aDate">指定时间</param>
/// <returns>是否在交易日内</returns>
public static bool IsTradeDate(string code, DateTime aDate)
{
bool result = false;
CM_BourseType bourseType = GetCM_BourseTypeByCommodityCode(code);
if (bourseType != null)
{
result = IsTradeDate(bourseType.BourseTypeID, aDate);
}
return(result);
}
/// <summary>
/// 验证是否在柜台接受委托时间内
/// </summary>
/// <param name="type">商品所属类别用来为了区分查询港股代码</param>
/// <param name="code">具体的交易代码</param>
/// <param name="errMsg">错误信息</param>
/// <returns>是否在接受委托时间内</returns>
public static bool IsCountTradingTime(Types.BreedClassTypeEnum type, string code, ref string errMsg)
{
CM_BourseType bourseType = MCService.CommonPara.GetBourseTypeByCommodityCode(code, type);
if (bourseType == null)
{
errMsg = "无法获取相关交易所信息。";
return(false);
}
if (!bourseType.CounterFromSubmitStartTime.HasValue || !bourseType.CounterFromSubmitEndTime.HasValue)
{
errMsg = "无法获取交易所开收市时间。";
return(false);
}
// 柜台接收委托开始时间
DateTime countBeginTime = bourseType.CounterFromSubmitStartTime.Value;
// 柜台接收委托结束时间
DateTime countEndTime = bourseType.CounterFromSubmitEndTime.Value;
DateTime now = DateTime.Now;
errMsg = "";
//是否正在清算，在清算时不能接受委托
bool isReckoning = ScheduleManagement.ScheduleManager.IsStockReckoning ||
ScheduleManagement.ScheduleManager.IsFutureReckoning ||
ScheduleManagement.ScheduleManager.IsHKReckoning;
if (isReckoning)
{
errMsg = "当前柜台正在执行清算";
return(false);
}
if (ScheduleManagement.ScheduleManager.IsFutureReckoningErrorStopTrade)
{
errMsg = "当前柜台上一日清算异常，暂停交易";
return(false);
}
//然后判断是否在柜台的接受委托时间内
if (Utils.CompareTime(countBeginTime, now) < 0 && Utils.CompareTime(countEndTime, now) > 0)
{
return(true);
}
return(false);
}
/// <summary>
/// 根据商品代码返回所属交易所
/// </summary>
/// <param name="code">代码</param>
/// <returns></returns>
public AcceptTradeTime GetAcceptTradeTimeByCommodityCode(string code)
{
AcceptTradeTime accetpTime = new AcceptTradeTime();
CM_BourseType cm_bourseType = CommonDataManagerOperate.GetCM_BourseTypeByCommodityCode(code);
if (cm_bourseType == null || !cm_bourseType.ReceivingConsignStartTime.HasValue || !cm_bourseType.ReceivingConsignEndTime.HasValue)
{
return(null);
}
accetpTime.AcceptStartTime = cm_bourseType.ReceivingConsignStartTime.Value;
accetpTime.AcceptEndTime = cm_bourseType.ReceivingConsignEndTime.Value;
return(accetpTime);
}
/// <summary>
/// 添加交易所类型
/// </summary>
/// <param name="model">交易所类型实体</param>
/// <returns></returns>
public int AddCMBourseType(CM_BourseType model)
{
try
{
return(cM_BourseTypeDAL.Add(model));
}
catch (Exception ex)
{
string errCode = "GL-4700";
string errMsg = "添加交易所类型失败!";
var exception = new VTException(errCode, errMsg, ex);
LogHelper.WriteError(exception.ToString(), exception.InnerException);
return(AppGlobalVariable.INIT_INT);
}
}
/// <summary>
/// 更新交易所类型
/// </summary>
/// <param name="model">交易所类型实体</param>
/// <returns></returns>
public bool UpdateCMBourseType(CM_BourseType model)
{
try
{
return(cM_BourseTypeDAL.Update(model));
}
catch (Exception ex)
{
string errCode = "GL-4702";
string errMsg = "更新交易所类型失败!";
var exception = new VTException(errCode, errMsg, ex);
LogHelper.WriteError(exception.ToString(), exception.InnerException);
return(false);
}
}
private static void SetEndTime(DateTime time, CM_BourseType type, Types.TradingTimeType timeType)
{
if (LastEndTime.Year == 2000)
{
LastEndTime = time;
return;
}
if (LastEndTime.Hour < time.Hour)
{
LastEndTime = time;
return;
}
if (LastEndTime.Hour == time.Hour)
{
if (LastEndTime.Minute < time.Minute)
{
LastEndTime = time;
}
}
}
/// <summary>
/// 初始化撮合机
/// </summary>
private void InitDevice()
{
string showmsg = "正在初始化行撮合机";
LogHelper.WriteDebug(showmsg + DateTime.Now);
ShowMessage.Instanse.ShowFormTitleMessage(showmsg);
RC_MatchCenter center = CommonDataCacheProxy.Instanse.GetCacheMatchCenterByConfig();
if (center != null)
{
AppConfig.MatchCenterName = "【" + center.MatchCenterName + "】";
}
List <RC_MatchMachine> matchMachines = CommonDataCacheProxy.Instanse.GetCacheRC_MatchMachine();
string matchTypeID = AppConfig.GetConfigMatchBreedClassType();
//撮合中心撮合机不能为空
if (Utils.IsNullOrEmpty(matchMachines))
{
LogHelper.WriteInfo("撮合中心初始化撮合机分配代码时没有找到撮合机--撮合中心初始化不成功！" + DateTime.Now);
return;
}
int k = 0;
showmsg += "[" + matchMachines.Count + "]==";
#region 先清空所有撮合管理器中内容
//先清空所有撮合管理器中内容
//MatchCenterManager.Instance.matchDevices.Clear();
foreach (var item in MatchCenterManager.Instance.matchDevices)
{
MatchDevice dev = item.Value;
if (dev != null)
{
dev.ClearAllTimerEvent();
}
}
MatchCenterManager.Instance.matchDevices.Clear();
#endregion
#region 清除所有下单过滤行情数据列表
MatchCodeDictionary.hk_ActivityOrderDic.Clear();
MatchCodeDictionary.xh_ActivityOrderDic.Clear();
MatchCodeDictionary.qh_ActivityOrderDic.Clear();
//add by 董鹏 2010-01-25
MatchCodeDictionary.spqh_ActivityOrderDic.Clear();
#endregion
foreach (RC_MatchMachine machine in matchMachines)
{
#region 初始货所有撮合机器
k += 1;
ShowMessage.Instanse.ShowFormTitleMessage(showmsg + k + "号撮合机");
CM_BourseType bourseType = CommonDataCacheProxy.Instanse.GetCacheCM_BourseTypeByKey((int)machine.BourseTypeID);
MatchDevice device = new MatchDevice();
//TradeTimeManager.Instanse.AcceptStartTime = (DateTime)bourseType.ReceivingConsignStartTime;
//TradeTimeManager.Instanse.AcceptEndTime = (DateTime)bourseType.ReceivingConsignEndTime;
//List<CM_TradeTime> tradeTimes = CommonDataCacheProxy.Instanse.GetCacheCM_TradeTimeByBourseID(bourseType.BourseTypeID);
List <RC_TradeCommodityAssign> assigns = CommonDataManagerOperate.GetTradeCommodityAssignByMatchineID(machine.MatchMachineID);
if (Utils.IsNullOrEmpty(assigns))
{
continue;
}
//撮合中心遍历撮合单元
foreach (RC_TradeCommodityAssign assign in assigns)
{
string iniCode = assign.CommodityCode;
#region 根据配置初始化要撮合的商品代码
CM_BreedClass breedClass = CommonDataManagerOperate.GetBreedClassByCommodityCode(iniCode, assign.CodeFormSource);
if (breedClass != null && breedClass.BreedClassTypeID.HasValue)
{
//根据配置初始化要撮合的商品代码
switch ((Types.BreedClassTypeEnum)breedClass.BreedClassTypeID)
{
case Types.BreedClassTypeEnum.Stock:
//根据配置是否初始化本商品撮合代码
if (matchTypeID.Substring(3, 1) == "0")
{
continue;
}
#region 初始化现货撮合机
//ShowMessage.Instanse.ShowFormTitleMessage(showmsg + "正在初始现货代码[" + assign.CommodityCode + "]撮合机");
//if ((Types.BreedClassTypeEnum)breedClass.BreedClassTypeID == Types.BreedClassTypeEnum.Stock)
//{
var stockMatcher = new StockMatcher(iniCode);
stockMatcher.bourseTypeID = bourseType.BourseTypeID;
device.bourseTypeID = bourseType.BourseTypeID;
device.IniMatchDevice((Types.BreedClassTypeEnum)breedClass.BreedClassTypeID.Value);
//====获取相关代码中数据库的所有已下的委托 并添加到委托队列中
List <StockDataOrderEntity> xhEntity = StockDataOrderDataAccess.GetStockEntityList(iniCode);
if (!Utils.IsNullOrEmpty(xhEntity))
{
foreach (var entity in xhEntity)
{
//市场存量故障恢复
if (entity.MarketVolumeNo == entity.OrderNo && entity.MarkLeft > 0 &&
entity.MatchState != Types.MatchCenterState.First &&
entity.IsMarketPrice == (int)Types.MarketPriceType.otherPrice)
{
string stockKey = entity.SholderCode + "@" + entity.OrderPrice + "@" + entity.MarketVolumeNo;
if ((Types.TransactionDirection)entity.TransactionDirection == Types.TransactionDirection.Buying)
{
stockMatcher.buyMarketVolume.AddMarketVolume(stockKey, entity.MarkLeft);
}
else if ((Types.TransactionDirection)entity.TransactionDirection == Types.TransactionDirection.Selling)
{
stockMatcher.sellMarketVolume.AddMarketVolume(stockKey, entity.MarkLeft);
}
}
//添加过滤行情列表数据
MatchCodeDictionary.AddXH_ActivityOrderDic(entity.StockCode);
stockMatcher.EntityBuffer.InsertQueueItem(entity);
}
}
//==============================
if (device.StockMarkers.ContainsKey(iniCode))
{
device.StockMarkers.Remove(iniCode);
}
device.StockMarkers.Add(iniCode, stockMatcher);
//}
#endregion
break;
case Types.BreedClassTypeEnum.CommodityFuture:
#region 初始化商品期货撮合机 add by 董鹏 2010-01-22
//根据配置是否初始化本商品撮合代码
if (matchTypeID.Substring(0, 1) == "0")
{
continue;
}
var cfMatcher = new SPQHMatcher(iniCode);
cfMatcher.bourseTypeID = bourseType.BourseTypeID;
device.bourseTypeID = bourseType.BourseTypeID;
device.IniMatchDevice((Types.BreedClassTypeEnum)breedClass.BreedClassTypeID.Value);
//====获取相关代码中数据库的所有已下的委托 并添加到委托队列中
List <CommoditiesDataOrderEntity> cfModel = CommoditiesDataOrderAccess.GetFutureEntityList(iniCode);
if (!Utils.IsNullOrEmpty(cfModel))
{
foreach (var entity in cfModel)
{
//市场存量故障恢复
if (entity.MarketVolumeNo == entity.OrderNo && entity.MarkLeft > 0 &&
entity.MatchState != Types.MatchCenterState.First &&
entity.IsMarketPrice == (int)Types.MarketPriceType.otherPrice)
{
string futKey = entity.SholderCode + "@" + entity.OrderPrice + "@" + entity.MarketVolumeNo;
if ((Types.TransactionDirection)entity.TransactionDirection == Types.TransactionDirection.Buying)
{
cfMatcher.buyMarketVolume.AddMarketVolume(futKey, entity.MarkLeft);
}
else if ((Types.TransactionDirection)entity.TransactionDirection == Types.TransactionDirection.Selling)
{
cfMatcher.sellMarketVolume.AddMarketVolume(futKey, entity.MarkLeft);
}
}
//添加过滤行情列表数据
MatchCodeDictionary.AddSPQH_ActivityOrderDic(entity.StockCode);
cfMatcher.EntityBuffer.InsertQueueItem(entity);
}
}
//========================================//
if (device.CommoditiesMarkers.ContainsKey(iniCode))
{
device.CommoditiesMarkers.Remove(iniCode);
}
device.CommoditiesMarkers.Add(iniCode, cfMatcher);
#endregion
break;
case Types.BreedClassTypeEnum.StockIndexFuture:
#region 初始化股指期货撮合机
//ShowMessage.Instanse.ShowFormTitleMessage(showmsg + "正在初始期货代码[" + assign.CommodityCode + "]撮合机");
//根据配置是否初始化本商品撮合代码
if (matchTypeID.Substring(2, 1) == "0")
{
continue;
}
//if ((Types.BreedClassTypeEnum)breedClass.BreedClassTypeID == Types.BreedClassTypeEnum.StockIndexFuture)
//{
var futureMatcher = new FutureMatcher(iniCode);
futureMatcher.bourseTypeID = bourseType.BourseTypeID;
device.bourseTypeID = bourseType.BourseTypeID;
device.IniMatchDevice((Types.BreedClassTypeEnum)breedClass.BreedClassTypeID.Value);
//====获取相关代码中数据库的所有已下的委托 并添加到委托队列中
List <FutureDataOrderEntity> qhModel = FutureDataOrderDataAccess.GetFutureEntityList(iniCode);
if (!Utils.IsNullOrEmpty(qhModel))
{
foreach (var entity in qhModel)
{
//市场存量故障恢复
if (entity.MarketVolumeNo == entity.OrderNo && entity.MarkLeft > 0 &&
entity.MatchState != Types.MatchCenterState.First &&
entity.IsMarketPrice == (int)Types.MarketPriceType.otherPrice)
{
string futKey = entity.SholderCode + "@" + entity.OrderPrice + "@" + entity.MarketVolumeNo;
if ((Types.TransactionDirection)entity.TransactionDirection == Types.TransactionDirection.Buying)
{
futureMatcher.buyMarketVolume.AddMarketVolume(futKey, entity.MarkLeft);
}
else if ((Types.TransactionDirection)entity.TransactionDirection == Types.TransactionDirection.Selling)
{
futureMatcher.sellMarketVolume.AddMarketVolume(futKey, entity.MarkLeft);
}
}
//添加过滤行情列表数据
MatchCodeDictionary.AddQH_ActivityOrderDic(entity.StockCode);
futureMatcher.EntityBuffer.InsertQueueItem(entity);
}
}
//========================================//
if (device.FutureMarkers.ContainsKey(iniCode))
{
device.FutureMarkers.Remove(iniCode);
}
device.FutureMarkers.Add(iniCode, futureMatcher);
//}
#endregion
break;
case Types.BreedClassTypeEnum.HKStock:
#region 初始化港股撮合机
//根据配置是否初始化本商品撮合代码
if (matchTypeID.Substring(1, 1) == "0")
{
continue;
}
//ShowMessage.Instanse.ShowFormTitleMessage(showmsg + "正在初始港股代码[" + iniCode + "]撮合机");
//if ((Types.BreedClassTypeEnum)breedClass.BreedClassTypeID == Types.BreedClassTypeEnum.HKStock)
//{
// LogHelper.WriteInfo("正在初始化港股撮合机" + DateTime.Now);
var hkMatcher = new HKStockMatcher(iniCode);
hkMatcher.bourseTypeID = bourseType.BourseTypeID;
device.bourseTypeID = bourseType.BourseTypeID;
device.IniMatchDevice((Types.BreedClassTypeEnum)breedClass.BreedClassTypeID.Value);
//====获取相关代码中数据库的所有已下的委托 并添加到委托队列中
List <HKEntrustOrderInfo> hkOrders = HKEntrustOrderDal.GetHKEntrustOrderList(iniCode);
if (!Utils.IsNullOrEmpty(hkOrders))
{
foreach (var entity in hkOrders)
{
LogHelper.WriteDebug("程序启动==【港股】初始化重新添加委托到队列中" + entity.OrderNo + "当前委托量" + entity.OrderVolume + "原委托量:" + entity.OldVolume
+ "代码:" + entity.HKSecuritiesCode);
//市场存量故障恢复
if (entity.MarketVolumeNo == entity.OrderNo && entity.MarkLeft > 0 && entity.MatchState != Types.MatchCenterState.First &&
entity.OrderType != (int)Types.HKPriceType.SLO)
{
string hkKey = entity.SholderCode + "@" + entity.OrderPrice + "@" + entity.MarketVolumeNo;
if ((Types.TransactionDirection)entity.TradeType == Types.TransactionDirection.Buying)
{
hkMatcher.buyMarketVolume.AddMarketVolume(hkKey, entity.MarkLeft);
}
else if ((Types.TransactionDirection)entity.TradeType == Types.TransactionDirection.Selling)
{
hkMatcher.sellMarketVolume.AddMarketVolume(hkKey, entity.MarkLeft);
}
}
//添加过滤行情列表数据
MatchCodeDictionary.AddHK_ActivityOrderDic(entity.HKSecuritiesCode);
hkMatcher.orderCache.InsertQueueItem(entity);
}
}
//=============================//
if (device.HKStockMarkers.ContainsKey(iniCode))
{
device.HKStockMarkers.Remove(iniCode);
}
device.HKStockMarkers.Add(iniCode, hkMatcher);
//}
#endregion
break;
default:
break;
}
//以上加载并验证通过后再删除和加入
if (MatchCenterManager.Instance.matchDevices.ContainsKey(iniCode))
{
MatchCenterManager.Instance.matchDevices[iniCode] = null;
MatchCenterManager.Instance.matchDevices.Remove(iniCode);
}
MatchCenterManager.Instance.matchDevices.Add(iniCode, device);
// ShowMessage.Instanse.ShowFormTitleMessage(showmsg + "初始化代码[" + iniCode + "]撮合机(完)");
}
#endregion
}
#endregion
}
//删除完所有撤单数据,因为已经把数据都放入列表，已经不删除当再重启时又会重写一次到数据库
//这样就会重复
CancelOrderRecoveryDal.DeleteAll();
//清除初始化管理中心的数据中没有再使用到的数据
CommonDataCacheProxy.Instanse.ClearOther();
LogHelper.WriteInfo("撮合中心初始化成功！" + DateTime.Now);
}
/// <summary>
/// 保存交易的类型和交易时间到数据库
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnOk_Click(object sender, EventArgs e)
{
try
{
if (EditType == (int)UITypes.EditTypeEnum.AddUI)
{
if (!string.IsNullOrEmpty(this.txtBourseTypeName.Text))
{
if (!CommonParameterSetCommon.IsExistBourseTypeName(this.txtBourseTypeName.Text))
{
ShowMessageBox.ShowInformation("交易所名称已经存在!");
return;
}
}
else
{
ShowMessageBox.ShowInformation("交易所名称不能为空!");
return;
}
}
//交易所类型
CM_BourseType cM_BourseType = new CM_BourseType();
if (CMBourseType != null)
{
ManagementCenter.Model.CommonClass.UtilityClass.CopyEntityToEntity(CMBourseType, cM_BourseType);
cM_BourseType.BourseTypeName = this.txtBourseTypeName.Text;
if ((DateTime)tmCounFromSubmitStartTime.EditValue < (DateTime)tmCounFromSubmitEndTime.EditValue)
{
cM_BourseType.CounterFromSubmitStartTime =
Convert.ToDateTime(this.tmCounFromSubmitStartTime.Text);
cM_BourseType.CounterFromSubmitEndTime = Convert.ToDateTime(this.tmCounFromSubmitEndTime.Text);
}
else
{
ShowMessageBox.ShowInformation("开始时间需小于结束时间!");
return;
}
cM_BourseType.ISSysDefaultBourseType = (int)GTA.VTS.Common.CommonObject.Types.IsYesOrNo.No;//用户添加的交易所不是系统默认交易所
}
if (EditType == (int)UITypes.EditTypeEnum.AddUI)
{
List <CM_TradeTime> cmTradeTimeList = new List <CM_TradeTime>();
if (_dtTradeTime != null && _dtTradeTime.Rows.Count > 0)
{
foreach (DataRow _dr in _dtTradeTime.Rows)
{ //交易时间
CM_TradeTime cM_TradeTime = new CM_TradeTime();
//cM_TradeTime.BourseTypeID =;
cM_TradeTime.StartTime = Convert.ToDateTime(_dr[this.gdvTradeTimeSelect.Columns[1].FieldName]);
cM_TradeTime.EndTime = Convert.ToDateTime(_dr[this.gdvTradeTimeSelect.Columns[2].FieldName]);
cmTradeTimeList.Add(cM_TradeTime);
}
}
else
{
ShowMessageBox.ShowInformation("请填写交易时间!");
return;
}
int _BourseTypeMaxID = CommonParameterSetCommon.GetCMBourseTypeMaxId();
if (_BourseTypeMaxID != AppGlobalVariable.INIT_INT)
{
if (_BourseTypeMaxID > 100) //交易所类型表中的最大ID大于系统默认的ID，100时
{
cM_BourseType.BourseTypeID = _BourseTypeMaxID; //因为在DAL层返回的最大ID已经加1
}
else
{
cM_BourseType.BourseTypeID = 100 + 1;
}
}
int result = CommonParameterSetCommon.AddCMBourseTypeAndTradeTime(cM_BourseType, cmTradeTimeList);
if (result != AppGlobalVariable.INIT_INT)
{
ShowMessageBox.ShowInformation("添加成功!");
this.ClearAll();
this.DialogResult = DialogResult.OK;
this.Close();
}
else
{
ShowMessageBox.ShowInformation("添加失败!");
}
}
else if (EditType == (int)UITypes.EditTypeEnum.UpdateUI) //此处只修改交易所类型
{
bool _Result = CommonParameterSetCommon.UpdateCMBourseType(cM_BourseType); //, ref msg);
if (_Result)
{
ShowMessageBox.ShowInformation("交易所类型修改成功!");
this.DialogResult = DialogResult.OK;
this.Close();
}
else
{
ShowMessageBox.ShowInformation("交易所类型修改失败!");
}
}
}
catch (Exception ex)
{
string errCode = "GL-4447";
string errMsg = "保存交易的类型和交易时间到数据库失败!";
var exception = new VTException(errCode, errMsg, ex);
LogHelper.WriteError(exception.ToString(), exception.InnerException);
return;
}
}
/// <summary>
/// 添加交易所类型和交易时间
/// </summary>
/// <param name="cmBourseType">交易所类型实体</param>
/// <param name="cmTradeTimeList">交易时间实体集合</param>
/// <returns></returns>
public int AddCMBourseTypeAndTradeTime(CM_BourseType cmBourseType, List <CM_TradeTime> cmTradeTimeList)
{
var cmBourseTypeDal = new CM_BourseTypeDAL();
var cmTradeTimeDal = new CM_TradeTimeDAL();
DbConnection Conn = null;
Database db = DatabaseFactory.CreateDatabase();
Conn = db.CreateConnection();
if (Conn.State != ConnectionState.Open)
{
Conn.Open();
}
DbTransaction tran = Conn.BeginTransaction();
//交易所类型ID
int BourseTypeID = AppGlobalVariable.INIT_INT;
//交易时间ID
int TradeTimeID = AppGlobalVariable.INIT_INT;
try
{
if (cmBourseType != null && cmTradeTimeList.Count > 0)
{
BourseTypeID = cmBourseTypeDal.Add(cmBourseType, tran, db);
if (BourseTypeID == AppGlobalVariable.INIT_INT)
{
tran.Rollback();
}
foreach (CM_TradeTime _cmTradeTime in cmTradeTimeList)
{
_cmTradeTime.BourseTypeID = BourseTypeID;
TradeTimeID = cmTradeTimeDal.Add(_cmTradeTime, tran, db);
if (TradeTimeID == AppGlobalVariable.INIT_INT)
{
tran.Rollback();
break;
}
}
}
//根据交易所类型ID获取并查找最早的交易开始时间和最晚的交易结束时间
List <CM_TradeTime> cmTTimeList =
cmTradeTimeDal.GetListArray(string.Format("BourseTypeID={0}", BourseTypeID), tran, db);
if (cmTTimeList.Count > 0)
{
DateTime _tempStartTime = AppGlobalVariable.INIT_DATETIME;
DateTime _tempEndTime = AppGlobalVariable.INIT_DATETIME;
bool isStartTime = true; //标志开始值是否改变
bool isEndTime = true; //标志结束值是否改变
for (int i = 0; i < cmTTimeList.Count; i++)
{
if (isStartTime)
{
_tempStartTime = (DateTime)cmTTimeList[0].StartTime;
}
if (isEndTime)
{
_tempEndTime = (DateTime)cmTTimeList[0].EndTime;
}
if (_tempStartTime > (DateTime)cmTTimeList[i].StartTime)
{
_tempStartTime = (DateTime)cmTTimeList[i].StartTime;
isStartTime = false;
}
if (_tempEndTime < (DateTime)cmTTimeList[i].EndTime)
{
_tempEndTime = (DateTime)cmTTimeList[i].EndTime;
isEndTime = false;
}
}
bool result = cmBourseTypeDal.Update(BourseTypeID, _tempStartTime, _tempEndTime, tran, db);
if (!result)
{
tran.Rollback();
}
tran.Commit();
}
return(BourseTypeID);
}
catch (Exception ex)
{
tran.Rollback();
string errCode = "GL-4708";
string errMsg = "添加交易所类型和交易时间失败!";
var exception = new VTException(errCode, errMsg, ex);
LogHelper.WriteError(exception.ToString(), exception.InnerException);
return(AppGlobalVariable.INIT_INT);
}
finally
{
if (Conn.State == ConnectionState.Open)
{
Conn.Close();
}
}
}
/// <summary>
/// 添加交易所类型和交易时间
/// </summary>
/// <param name="cmBourseType">交易所类型实体</param>
/// <param name="cmTradeTimeList">交易时间实体集合</param>
/// <returns></returns>
public static int AddCMBourseTypeAndTradeTime(CM_BourseType cmBourseType, List <CM_TradeTime> cmTradeTimeList)
{
CM_BourseTypeBLL cM_BourseTypeBLL = new CM_BourseTypeBLL();
return(cM_BourseTypeBLL.AddCMBourseTypeAndTradeTime(cmBourseType, cmTradeTimeList));
}
