/// <summary>
/// 增加一条数据
/// 注：本方法没有插入创建时间，创建时间由数据创建
/// </summary>
public void Add(HKModifyOrderRequest model)
{
StringBuilder strSql = new StringBuilder();
strSql.Append("insert into HK_ModifyOrderRequest(");
strSql.Append("ID,ChannelID,TraderId,FundAccountId,TraderPassword,Code,EntrustNubmer,OrderPrice,OrderAmount,Message)");
strSql.Append(" values (");
strSql.Append("@ID,@ChannelID,@TraderId,@FundAccountId,@TraderPassword,@Code,@EntrustNubmer,@OrderPrice,@OrderAmount,@Message)");
Database db = DatabaseFactory.CreateDatabase();
DbCommand dbCommand = db.GetSqlStringCommand(strSql.ToString());
db.AddInParameter(dbCommand, "ID", DbType.AnsiString, model.ID);
db.AddInParameter(dbCommand, "ChannelID", DbType.AnsiString, model.ChannelID);
db.AddInParameter(dbCommand, "TraderId", DbType.AnsiString, model.TraderId);
db.AddInParameter(dbCommand, "FundAccountId", DbType.AnsiString, model.FundAccountId);
db.AddInParameter(dbCommand, "TraderPassword", DbType.AnsiString, model.TraderPassword);
db.AddInParameter(dbCommand, "Code", DbType.AnsiString, model.Code);
db.AddInParameter(dbCommand, "EntrustNubmer", DbType.AnsiString, model.EntrustNubmer);
db.AddInParameter(dbCommand, "OrderPrice", DbType.Decimal, model.OrderPrice);
db.AddInParameter(dbCommand, "OrderAmount", DbType.Int32, model.OrderAmount);
db.AddInParameter(dbCommand, "Message", DbType.AnsiString, model.Message);
// db.AddInParameter(dbCommand, "ModifyOrderDateTime", DbType.DateTime, model.ModifyOrderDateTime);
db.ExecuteNonQuery(dbCommand);
}
/// <summary>
/// 更新类型2改单的各种状态变化
/// </summary>
/// <param name="entrustNumber"></param>
public void ProcessType2ModifyOrder(string entrustNumber)
{
string desc = "M<---——ModifyOrderProcessor.ProcessType2ModifyOrder类型2改单——原始委托清算完毕,更新状态";
LogHelper.WriteDebug(desc);
//===update 2009-11-08 李健华
//HK_TodayEntrustInfo tet = HKDataAccess.GetTodayEntrustTable(entrustNumber);
//如果新单号与原始单号相同，那么代表是一个类型2的改单
//tet.ModifyOrderNumber = entrustNumber;
//tet.IsModifyOrder = true;
//HKDataAccess.UpdateEntrustTable(tet);
//为了不更新区他字段 和不用再查询一次再更新
HKDataAccess.UpdateEntrustModifyOrderNumber(entrustNumber, entrustNumber);
//记录成功改单委托记录明细，方便查询和关联查询
HKDataAccess.AddModifyOrderSuccessDatils(entrustNumber, entrustNumber, 2);
//=======================
HK_ModifyOrderRequestDal dal = new HK_ModifyOrderRequestDal();
HKModifyOrderRequest request = dal.GetModel(entrustNumber);
if (request != null)
{
request.ModifyOrderDateTime = DateTime.Now;
HKDataAccess.UpdateModifyOrderRequest(request);
}
DeleteType2Reqeust(entrustNumber);
}
/// <summary>
/// 对象实体绑定数据
/// </summary>
public HKModifyOrderRequest ReaderBind(IDataReader dataReader)
{
HKModifyOrderRequest model = new HKModifyOrderRequest();
object ojb;
model.ID = dataReader["ID"].ToString();
model.ChannelID = dataReader["ChannelID"].ToString();
model.TraderId = dataReader["TraderId"].ToString();
model.FundAccountId = dataReader["FundAccountId"].ToString();
model.TraderPassword = dataReader["TraderPassword"].ToString();
model.Code = dataReader["Code"].ToString();
model.EntrustNubmer = dataReader["EntrustNubmer"].ToString();
ojb = dataReader["OrderPrice"];
if (ojb != null && ojb != DBNull.Value)
{
model.OrderPrice = float.Parse(ojb.ToString());
}
ojb = dataReader["OrderAmount"];
if (ojb != null && ojb != DBNull.Value)
{
model.OrderAmount = float.Parse(ojb.ToString());
}
model.Message = dataReader["Message"].ToString();
ojb = dataReader["ModifyOrderDateTime"];
if (ojb != null && ojb != DBNull.Value)
{
model.ModifyOrderDateTime = (DateTime)ojb;
}
return(model);
}
/// <summary>
/// 类型1改单——生成新委托，下单，并回推改单结果到前台
/// </summary>
/// <param name="request"></param>
internal void ProcessType1_NewOrder(HKModifyOrderRequest request)
{
LogHelper.WriteDebug("M——————>ModifyOrderProcessor.ProcessType1_NewOrder生成新委托，下单，并回推改单结果到前台" + request);
HKOrderRequest newRequest = CreateNewType1Request(request);
HKModifyOrderPushBack pushBack = new HKModifyOrderPushBack();
pushBack.OriginalRequestNumber = request.EntrustNubmer;
pushBack.TradeID = request.TraderId;
pushBack.CallbackChannlId = request.ChannelID;
var res = OrderAccepterService.Service.DoHKOrder(newRequest);
pushBack.IsSuccess = res.IsSuccess;
pushBack.Message = res.OrderMessage;
if (res.IsSuccess)
{
HKDataAccess.UpdateEntrustModifyOrderNumber(res.OrderId, request.EntrustNubmer);
//记录成功改单委托记录明细，方便查询和关联查询
HKDataAccess.AddModifyOrderSuccessDatils(res.OrderId, request.EntrustNubmer, 1);
pushBack.NewRequestNumber = res.OrderId;
}
else
{
request.Message = res.OrderMessage;
HKDataAccess.UpdateModifyOrderRequest(request);
}
//将改单结果推给前台
CounterOrderService.Instance.AcceptHKModifyOrder(pushBack);
}
public OrderResponse ModifyHKOrder(HKModifyOrderRequest order)
{
if (!IsServiceOk)
{
return new OrderResponse {
OrderMessage = ServiceErrorMsg
}
}
;
order.ChannelID = Channelid;
OrderResponse response = null;
try
{
response = doOrderClient.DoHKModifyOrder(order);
}
catch (Exception ex)
{
LogHelper.WriteError(ex.Message, ex);
response = new OrderResponse();
response.IsSuccess = false;
response.OrderMessage = ServiceErrorMsg;
IsServiceOk = false;
}
return(response);
}
/// <summary>
/// 更新港股改单委托
/// </summary>
/// <param name="model"></param>
public static void UpdateModifyOrderRequest(HKModifyOrderRequest model)
{
try
{
HK_ModifyOrderRequestDal dal = new HK_ModifyOrderRequestDal();
dal.Update(model);
}
catch (Exception ex)
{
LogHelper.WriteError(ex.Message, ex);
}
}
/// <summary>
/// 类型3改单委托缓存是否存在对应的委托
/// </summary>
/// <param name="entrustNumber"></param>
/// <param name="request"></param>
/// <returns></returns>
public bool IsExistType3Request(string entrustNumber, out HKModifyOrderRequest request)
{
request = null;
if (type3Cache.Contains(entrustNumber))
{
request = type3Cache.Get(entrustNumber);
return(true);
}
return(false);
}
/// <summary>
/// 港股改单校验
/// </summary>
/// <param name="request">改单请求对象</param>
/// <param name="entrusInfo">原委托单对象</param>
/// <param name="errMsg">异常信息</param>
/// <returns>返回检验是否成功</returns>
public static bool Validate(HKModifyOrderRequest request, ReckoningCounter.Entity.Model.HK.HK_TodayEntrustInfo entrusInfo, ref string errMsg)
{
try
{
bool result = McValidater.GetInstance().ValidateHKModifyOrderRule(request, entrusInfo, ref errMsg);
return(result);
}
catch (Exception ex)
{
LogHelper.WriteError(ex.ToString(), ex);
return(false);
}
}
/// <summary>
/// 记录港股改单操作
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static bool AddHKModifyOrderRequest(HKModifyOrderRequest model)
{
try
{
HK_ModifyOrderRequestDal dal = new HK_ModifyOrderRequestDal();
dal.Add(model);
return(true);
}
catch (Exception ex)
{
LogHelper.WriteError(ex.Message, ex);
return(false);
}
}
/// <summary>
/// 港股改单委托规则检验
/// </summary>
/// <param name="request">改单请求实体</param>
/// <param name="entrusInfo">原委托实体对象</param>
/// <param name="errMsg">返回错误检验信息</param>
/// <returns>是否成功</returns>
public bool ValidateHKModifyOrderRule(HKModifyOrderRequest request, ReckoningCounter.Entity.Model.HK.HK_TodayEntrustInfo entrusInfo, ref string errMsg)
{
CM_BreedClass breedClass = MCService.CommonPara.GetBreedClassByCommodityCode(request.Code, Types.BreedClassTypeEnum.HKStock);
bool result = false;
if (breedClass != null)
{
if (!breedClass.BreedClassTypeID.HasValue || breedClass.BreedClassTypeID.Value != (int)Types.BreedClassTypeEnum.HKStock)
{
errMsg = "当前代码不为港股类别--" + breedClass.BreedClassTypeID.Value;
return(false);
}
result = HKModifyOrderRuleContainer.Validate(request, entrusInfo, breedClass.BreedClassID, ref errMsg);
}
return(result);
}
private HKOrderRequest CreateNewType3Request(HKModifyOrderRequest request, HK_TodayEntrustInfo tet, float amount)
{
HKOrderRequest newRequest = new HKOrderRequest();
newRequest.BuySell = (Types.TransactionDirection)tet.BuySellTypeID;
newRequest.ChannelID = tet.CallbackChannlID;
newRequest.Code = request.Code;
newRequest.FundAccountId = request.FundAccountId;
newRequest.OrderAmount = amount;
newRequest.OrderPrice = request.OrderPrice;
newRequest.OrderUnitType = (Types.UnitType)tet.TradeUnitID;
newRequest.OrderWay = Types.HKPriceType.LO;
newRequest.PortfoliosId = tet.PortfolioLogo;
newRequest.TraderId = request.TraderId;
newRequest.TraderPassword = request.TraderPassword;
return(newRequest);
}
/// <summary>
/// 根据港股改单委托创建新的委托
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private HKOrderRequest CreateNewType1Request(HKModifyOrderRequest request)
{
var tet = HKDataAccess.GetTodayEntrustTable(request.EntrustNubmer);
HKOrderRequest newRequest = new HKOrderRequest();
newRequest.BuySell = (Types.TransactionDirection)tet.BuySellTypeID;
newRequest.ChannelID = tet.CallbackChannlID;
newRequest.Code = request.Code;
newRequest.FundAccountId = request.FundAccountId;
newRequest.OrderAmount = request.OrderAmount;
newRequest.OrderPrice = request.OrderPrice;
newRequest.OrderUnitType = (Types.UnitType)tet.TradeUnitID;
newRequest.OrderWay = Types.HKPriceType.LO;
newRequest.PortfoliosId = tet.PortfolioLogo;
newRequest.TraderId = request.TraderId;
newRequest.TraderPassword = request.TraderPassword;
return(newRequest);
}
/// <summary>
/// 得到一个对象实体
/// </summary>
public HKModifyOrderRequest GetModel(string ID)
{
StringBuilder strSql = new StringBuilder();
strSql.Append("select ID,ChannelID,TraderId,FundAccountId,TraderPassword,Code,EntrustNubmer,OrderPrice,OrderAmount,Message,ModifyOrderDateTime from HK_ModifyOrderRequest ");
strSql.Append(" where ID=@ID ");
Database db = DatabaseFactory.CreateDatabase();
DbCommand dbCommand = db.GetSqlStringCommand(strSql.ToString());
db.AddInParameter(dbCommand, "ID", DbType.AnsiString, ID);
HKModifyOrderRequest model = null;
using (IDataReader dataReader = db.ExecuteReader(dbCommand))
{
if (dataReader.Read())
{
model = ReaderBind(dataReader);
}
}
return(model);
}
/// <summary>
/// 处理Type1类型改单-未报
/// </summary>
/// <param name="request">改单委托</param>
private void ProcessType1(HKModifyOrderRequest request)
{
LogHelper.WriteDebug("M————>ModifyOrderProcessor.ProcessType1接收类型1改单请求" + request);
//如果不在交易时间内，那么直接到缓存中删除原来的委托，生成新委托
if (!ValidateCenter.IsMatchTradingTime(Types.BreedClassTypeEnum.HKStock, request.Code))
{
LogHelper.WriteDebug("类型1改单请求" + request + "不在交易时间时间内，直接到缓存中删除原来的委托，生成新委托");
//1.删除缓存中的委托信息
OrderOfferCenter.Instance._orderCache.DeleteHKOrder(request.Code, request.EntrustNubmer);
//2.进行内存撤单
var tet = HKDataAccess.GetTodayEntrustTable(request.EntrustNubmer);
OrderOfferCenter.Instance.IntelnalCancelHKOrder(tet, "预委托被改单，作废");
//tet.OrderStatusID = (int)Entity.Contants.Types.OrderStateType.DOSCanceled;
//tet.OrderMessage = "未报的委托被改单，作废";
//HKDataAccess.UpdateEntrustTable(tet);
//3.回推原始委托变化到前台
ReckonEndObject <HK_TodayEntrustInfo, HK_TodayTradeInfo> reckonEndObject =
new ReckonEndObject <HK_TodayEntrustInfo, HK_TodayTradeInfo>();
reckonEndObject.IsSuccess = true;
reckonEndObject.EntrustTable = tet;
reckonEndObject.TradeTableList = new List <HK_TodayTradeInfo>();
reckonEndObject.TradeID = request.TraderId;
reckonEndObject.Message = "";
CounterOrderService.Instance.AcceptHKDealOrder(reckonEndObject);
ProcessType1_NewOrder(request);
}
else
{
//否则的话，放入类型1改单缓存，等原始委托报盘时再处理
LogHelper.WriteDebug("M————>ModifyOrderProcessor.ProcessType1类型1改单请求在交易时间内，放入缓存等待报盘时查找核对" + request);
AddType1Reqest(request);
}
}
/// <summary>
/// 处理Type3类型改单-价变量变
/// </summary>
/// <param name="request">改单委托</param>
private void ProcessType3(HKModifyOrderRequest request)
{
LogHelper.WriteDebug("M————>ModifyOrderProcessor.ProcessType3接收类型3改单请求" + request);
string strMessage = "";
Entity.Contants.Types.OrderStateType ost;
int errType;
//先进行主动撤单
bool result = OrderAccepterService.Service.CancelHKOrder(request.EntrustNubmer, ref strMessage, out ost,
out errType);
//如果发送撤单委托都进行不成功，那么整个改单委托直接作废
if (!result)
{
HKModifyOrderPushBack pushBack = new HKModifyOrderPushBack();
pushBack.IsSuccess = false;
pushBack.Message = strMessage;
pushBack.OriginalRequestNumber = request.EntrustNubmer;
pushBack.TradeID = request.TraderId;
pushBack.CallbackChannlId = request.ChannelID;
request.Message = strMessage;
HKDataAccess.UpdateModifyOrderRequest(request);
LogHelper.WriteDebug("M————>ModifyOrderProcessor.ProcessType3发送撤单委托不成功，整个改单委托直接作废" + request +
"Message=" + strMessage);
//将类型3改单失败结果推给前台
CounterOrderService.Instance.AcceptHKModifyOrder(pushBack);
return;
}
//成功的话，放入类型3改单缓存，等撤单成交回报清算完毕时再处理
AddType3Reqest(request);
}
/// <summary>
/// 更新一条数据
/// </summary>
public void Update(HKModifyOrderRequest model)
{
if (model.ModifyOrderDateTime == DateTime.MaxValue || model.ModifyOrderDateTime == DateTime.MinValue)
{
model.ModifyOrderDateTime = DateTime.Now;
}
StringBuilder strSql = new StringBuilder();
strSql.Append("update HK_ModifyOrderRequest set ");
strSql.Append("ChannelID=@ChannelID,");
strSql.Append("TraderId=@TraderId,");
strSql.Append("FundAccountId=@FundAccountId,");
strSql.Append("TraderPassword=@TraderPassword,");
strSql.Append("Code=@Code,");
strSql.Append("EntrustNubmer=@EntrustNubmer,");
strSql.Append("OrderPrice=@OrderPrice,");
strSql.Append("OrderAmount=@OrderAmount,");
strSql.Append("Message=@Message,");
strSql.Append("ModifyOrderDateTime=@ModifyOrderDateTime");
strSql.Append(" where ID=@ID ");
Database db = DatabaseFactory.CreateDatabase();
DbCommand dbCommand = db.GetSqlStringCommand(strSql.ToString());
db.AddInParameter(dbCommand, "ID", DbType.AnsiString, model.ID);
db.AddInParameter(dbCommand, "ChannelID", DbType.AnsiString, model.ChannelID);
db.AddInParameter(dbCommand, "TraderId", DbType.AnsiString, model.TraderId);
db.AddInParameter(dbCommand, "FundAccountId", DbType.AnsiString, model.FundAccountId);
db.AddInParameter(dbCommand, "TraderPassword", DbType.AnsiString, model.TraderPassword);
db.AddInParameter(dbCommand, "Code", DbType.AnsiString, model.Code);
db.AddInParameter(dbCommand, "EntrustNubmer", DbType.AnsiString, model.EntrustNubmer);
db.AddInParameter(dbCommand, "OrderPrice", DbType.Decimal, model.OrderPrice);
db.AddInParameter(dbCommand, "OrderAmount", DbType.Int32, model.OrderAmount);
db.AddInParameter(dbCommand, "Message", DbType.AnsiString, model.Message);
db.AddInParameter(dbCommand, "ModifyOrderDateTime", DbType.DateTime, model.ModifyOrderDateTime);
db.ExecuteNonQuery(dbCommand);
}
/// <summary>
/// 处理Type2类型改单-价不变量减
/// </summary>
/// <param name="request">改单委托</param>
private void ProcessType2(HKModifyOrderRequest request)
{
LogHelper.WriteDebug("M————>ModifyOrderProcessor.ProcessType2接收类型2改单请求" + request);
OrderOfferCenter.Instance.OfferHKModifyOrder(request);
}
/// <summary>
/// 当原始委托撤单清算完毕后，由此方法进行后继处理
/// 生成新的委托进行下单，并修改原始委托相关信息
/// </summary>
/// <param name="request"></param>
public void ProcessType3NewOrder(HKModifyOrderRequest request)
{
string desc = "M<---——ModifyOrderProcessor.ProcessType3NewOrder类型3改单——原始委托撤单清算完毕,生成新的委托下单，改单对象" + request;
LogHelper.WriteDebug(desc);
HK_TodayEntrustInfo tet = HKDataAccess.GetTodayEntrustTable(request.EntrustNubmer);
string strMessage = "";
OrderResponse res = null;
HKModifyOrderPushBack pushBack = new HKModifyOrderPushBack();
pushBack.OriginalRequestNumber = request.EntrustNubmer;
pushBack.TradeID = request.TraderId;
pushBack.CallbackChannlId = request.ChannelID;
//计算出需要下的量
float amount = request.OrderAmount - tet.TradeAmount;
//如果成交量已经大于等于当前改单量，那么无法再进行改单操作，改单失败
if (amount <= 0)
{
string format = "GT-2456:[港股改单委托]当前委托已成交数量{0}大于等于改单量{1}";
strMessage = string.Format(format, tet.TradeAmount, request.OrderAmount);
LogHelper.WriteDebug("M<---——ModifyOrderProcessor.ProcessType3NewOrder类型3改单失败" + request + "Message=" +
strMessage);
pushBack.Message = strMessage;
pushBack.IsSuccess = false;
//将改单结果推给前台
CounterOrderService.Instance.AcceptHKModifyOrder(pushBack);
//更新改单委托记录表的信息
request.Message = strMessage;
HKDataAccess.UpdateModifyOrderRequest(request);
}
else
{
HKOrderRequest newRequest = CreateNewType3Request(request, tet, amount);
res = OrderAccepterService.Service.DoHKOrder(newRequest);
pushBack.NewRequestNumber = res.OrderId;
pushBack.Message = res.OrderMessage;
string txtMsg = "";
if (res.IsSuccess)
{
txtMsg = "类型3改单成功";
//更新改单后成功下单的委托单，--更新是一笔改单下单委托，和原来被改单的委托单号
HKDataAccess.UpdateEntrustModifyOrderNumber(res.OrderId, tet.EntrustNumber);
//记录成功改单委托记录明细，方便查询和关联查询
HKDataAccess.AddModifyOrderSuccessDatils(res.OrderId, tet.EntrustNumber, 3);
}
else
{
string desc2 = "M<---——ModifyOrderProcessor.ProcessType3NewOrder类型3改单——生成新的委托下单失败，改单对象" + request +
"Message=" + res.OrderMessage;
LogHelper.WriteDebug(desc2);
txtMsg = "GT-2457:类型3改单生成新的委托下单失败" + res.OrderMessage;
//更新改单委托记录表的信息
request.Message = txtMsg;
HKDataAccess.UpdateModifyOrderRequest(request);
}
//将改单结果推给前台
CounterOrderService.Instance.AcceptHKModifyOrder(pushBack);
////修改原始委托信息
//tet.ModifyOrderNumber = request.EntrustNubmer;
//tet.IsModifyOrder = true;
//HKDataAccess.UpdateEntrustTable(tet);
//request.ModifyOrderDateTime = DateTime.Now;
//=====add 李健华 2009-11-07=========
//则更新原始委托单信息
HKDataAccess.UpdateEntrustOrderMessage(tet.EntrustNumber, txtMsg);
//===========
}
DeleteType3Reqeust(request.EntrustNubmer);
}
/// <summary>
/// 添加类型3改单委托到缓存中
/// </summary>
/// <param name="request"></param>
private void AddType3Reqest(HKModifyOrderRequest request)
{
type3Cache.Add(request.EntrustNubmer, request);
}
/// <summary>
/// 添加类型2改单委托到缓存中
/// </summary>
/// <param name="request"></param>
public void AddType2Reqest(HKModifyOrderRequest request)
{
type2Cache.Add(request.EntrustNubmer, request);
}
/// <summary>
/// 根据改单请求和改单类型，改单委托的买卖方向，检验相关验证方法
/// </summary>
/// <param name="hkModifyOrder"></param>
/// <param name="modifyType"></param>
/// <param name="entrusInfo"></param>
/// <param name="strMessage"></param>
/// <returns></returns>
public bool Validate(HKModifyOrderRequest hkModifyOrder, HK_TodayEntrustInfo entrusInfo, int breedClassID,
ref string strMessage)
{
BreedClassID = breedClassID;
bool reust = false;
int modifyType = 0; //改单类型
#region 判断改单类型
//未注报
if (entrusInfo.OrderStatusID == (int)Types.OrderStateType.DOSUnRequired)
{
modifyType = 1;
}
//已报、部成
if (entrusInfo.OrderStatusID == (int)Types.OrderStateType.DOSIsRequired ||
entrusInfo.OrderStatusID == (int)Types.OrderStateType.DOSPartDealed)
{
if ((decimal)hkModifyOrder.OrderPrice == entrusInfo.EntrustPrice &&
hkModifyOrder.OrderAmount < entrusInfo.EntrustAmount)
{
modifyType = 2;
}
else
{
modifyType = 3;
}
}
#endregion
if (modifyType == 0)
{
strMessage = "GT-2250:[港股改单委托验证]当前委托无法改单";
return(false);
}
#region 为适用之前的方法组装下单请求实体
HKOrderRequest request = new HKOrderRequest();
request.Code = hkModifyOrder.Code;
request.ChannelID = hkModifyOrder.ChannelID;
request.BuySell = (CommonObject.Types.TransactionDirection)entrusInfo.BuySellTypeID;
request.OrderAmount = hkModifyOrder.OrderAmount;
request.OrderPrice = hkModifyOrder.OrderPrice;
request.FundAccountId = entrusInfo.CapitalAccount;
request.OrderUnitType = (GTA.VTS.Common.CommonObject.Types.UnitType)entrusInfo.TradeUnitID;
request.OrderWay = (GTA.VTS.Common.CommonObject.Types.HKPriceType)entrusInfo.OrderPriceType;
#endregion
#region 1.零股检验
//零股检验
HKStockZeroVolumeOfBusinessCommand zerovolume = new HKStockZeroVolumeOfBusinessCommand(BreedClassID);
reust = zerovolume.Validate(request, ref strMessage);
if (!reust)
{
return(false);
}
#endregion
#region 2.单笔最大委托量检验命令
//单笔最大委托量检验命令
HKStockMaxLeaveQuantityRangeValueCommand maxLeave =
new HKStockMaxLeaveQuantityRangeValueCommand(BreedClassID);
reust = maxLeave.Validate(request, ref strMessage);
if (!reust)
{
return(false);
}
#endregion
#region 3.不是第二种类型量减的并且价格有改动的验证最小变动价格
//不是第二种类型量减的并且价格有改动的验证最小变动价格
if (modifyType != 2 && (decimal)hkModifyOrder.OrderPrice != entrusInfo.EntrustPrice)
{
HKStockMinChangePriceValueCommand minChange = new HKStockMinChangePriceValueCommand(BreedClassID);
reust = minChange.Validate(request, ref strMessage);
if (!reust)
{
return(false);
}
}
#endregion
#region 委托量有所改变则验证相关持仓(宋涛1116：此处不需要进行校验，等待原委托撤单成功后，由新单校验处检验)
////if (modifyType != 2)
//{
//if (hkModifyOrder.OrderAmount != entrusInfo.EntrustAmount)
//{
// if (entrusInfo.BuySellTypeID == (int)Types.TransactionDirection.Buying)
// {
// reust = PO_HoldValidate_Buy(ref strMessage, entrusInfo, request);
// }
// else
// {
// reust = PO_HoldValidate_Sell(ref strMessage, entrusInfo, request);
// }
// if (!reust)
// {
// return false;
// }
//}
////}
//不考虑持仓量，只考虑委托最小单位的验证
HKModifyStockMinVolumeOfBusinessCommand minVolume = new HKModifyStockMinVolumeOfBusinessCommand(BreedClassID);
reust = minVolume.Validate(request, ref strMessage);
if (!reust)
{
return(false);
}
#endregion
return(true);
}
public OrderResponse Process(HKModifyOrderRequest hkOrder)
{
LogHelper.WriteDebug("M——>ModifyOrderProcessor.Process接收改单入口" + hkOrder);
bool canModifyOrder = false;
OrderResponse orResult = new OrderResponse();
string strErrorMessage = "";
//hkOrder.ID = HKCommonLogic.BuildHKOrderNo();
hkOrder.ID = Guid.NewGuid().ToString();
#region 原始单位及成交量转换
var code = hkOrder.Code;
var oriUnitType = hkOrder.OrderUnitType;
decimal scale;
Types.UnitType matchUnitType;
bool canConvert = OrderAccepter.ConvertUnitType(Types.BreedClassTypeEnum.HKStock, code, oriUnitType, out scale, out matchUnitType);
if (!canConvert)
{
strErrorMessage = @"GT-2450:[港股委托]无法进行行情单位转换.";
goto EndProcess;
}
LogHelper.WriteDebug("委托单：" + hkOrder.EntrustNubmer + "当前改单获取到的转换倍数为: " + scale);
hkOrder.OrderUnitType = matchUnitType;
hkOrder.OrderAmount = hkOrder.OrderAmount * (float)scale;
#endregion
//记录改单操作记录数据
bool canSave = HKDataAccess.AddHKModifyOrderRequest(hkOrder);
if (!canSave)
{
strErrorMessage = @"GT-2451:[港股改单委托]无法保持改单委托，请查看错误日志.";
LogHelper.WriteInfo(strErrorMessage + "," + hkOrder);
goto EndProcess;
}
#region 校验
if ((string.IsNullOrEmpty(hkOrder.TraderId) && string.IsNullOrEmpty(hkOrder.FundAccountId)))
{
strErrorMessage = @"GT-2452:[港股改单委托]交易员ID或资金帐户无效.";
LogHelper.WriteInfo(strErrorMessage + "," + hkOrder);
goto EndProcess;
}
//柜台委托时间判断
if (!ValidateCenter.IsCountTradingTime(Types.BreedClassTypeEnum.HKStock, hkOrder.Code, ref strErrorMessage))
{
LogHelper.WriteInfo("ModifyOrderProcessor.Process" + strErrorMessage);
string oriMsg = "当前时间不接受委托";
if (strErrorMessage.Length > 0)
{
oriMsg = strErrorMessage;
}
strErrorMessage = @"GT-2453:[港股改单委托]" + oriMsg;
LogHelper.WriteInfo(strErrorMessage + "," + hkOrder);
goto EndProcess;
}
HK_TodayEntrustInfo tet = HKDataAccess.GetTodayEntrustTable(hkOrder.EntrustNubmer);
if (tet == null)
{
strErrorMessage = "GT-2454:[港股改单委托]无委托对象信息";
LogHelper.WriteInfo(strErrorMessage + "," + hkOrder);
goto EndProcess;
}
if ((float)tet.EntrustPrice == hkOrder.OrderPrice && tet.EntrustAmount == (int)hkOrder.OrderAmount)
{
strErrorMessage = "GT-2455:[港股改单委托]无效改单，改单量、改单价与原始委托相同";
LogHelper.WriteInfo(strErrorMessage + "," + hkOrder);
goto EndProcess;
}
//港股改单规则检验，这里有些与真实下单有些重复，但这样可以提高改单的成功率
if (!McValidater.GetInstance().ValidateHKModifyOrderRule(hkOrder, tet, ref strErrorMessage))
{
LogHelper.WriteInfo(strErrorMessage + "," + hkOrder);
goto EndProcess;
}
#endregion
//未报
if (tet.OrderStatusID == (int)Entity.Contants.Types.OrderStateType.DOSUnRequired)
{
ProcessType1(hkOrder);
canModifyOrder = true;
goto EndProcess;
}
#region 已报、部成
if (tet.OrderStatusID == (int)Entity.Contants.Types.OrderStateType.DOSIsRequired ||
tet.OrderStatusID == (int)Entity.Contants.Types.OrderStateType.DOSPartDealed)
{
//如果不在交易时间内，那么直接到缓存中删除原来的委托，生成新委托
if (!ValidateCenter.IsMatchTradingTime(Types.BreedClassTypeEnum.HKStock, hkOrder.Code))
{
strErrorMessage = "GT-2456:[港股改单委托]不在交易时间内";
LogHelper.WriteInfo(strErrorMessage + "," + hkOrder);
goto EndProcess;
}
if ((decimal)hkOrder.OrderPrice == tet.EntrustPrice && hkOrder.OrderAmount < tet.EntrustAmount)
{
ProcessType2(hkOrder);
canModifyOrder = true;
}
else
{
ProcessType3(hkOrder);
canModifyOrder = true;
goto EndProcess;
}
}
#endregion
EndProcess:
//结束
if (canModifyOrder)
{
hkOrder.ModifyOrderDateTime = DateTime.Now;
orResult.OrderDatetime = DateTime.Now;
}
else
{
int type = 0;
bool canGetErrorCode = Utils.GetErrorCode(strErrorMessage, out type);
if (canGetErrorCode)
{
orResult.ErrorType = type;
}
hkOrder.Message = strErrorMessage;
orResult.OrderMessage = strErrorMessage;
}
//更新改单委托
HKDataAccess.UpdateModifyOrderRequest(hkOrder);
orResult.IsSuccess = canModifyOrder;
orResult.OrderId = hkOrder.ID;
return(orResult);
}
