/// <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);
}
/// <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>
/// <param name="model"></param>
public void ModifyHKStockOrderRpt(HKModifyBackEntity model)
{
if (string.IsNullOrEmpty(model.Id))
{
model.Id = Guid.NewGuid().ToString();
}
string format = "M<---港股改单回报接收(类型2改单)DoCallbackProcess.ModifyHKStockOrderRpt[ID={0},IsSuccess={1},OrderNo={2}]";
string desc = string.Format(format, model.Id, model.IsSuccess, model.OrderNo);
LogHelper.WriteDebug(desc);
//回推改单结果到前台
HKModifyOrderPushBack pushBack = new HKModifyOrderPushBack();
pushBack.IsSuccess = model.IsSuccess;
pushBack.Message = model.Message;
//这是撮合队列的委托ID
//pushBack.OriginalRequestNumber = model.OrderNo;
//这里撮合回推回来的回推通道ID不是前台的ID
//pushBack.CallbackChannlId = model.ChannelNo;
string entrustNumber = "";
string channelID = HKDataAccess.GetModifyOrderChannelIDByMacID(model.OrderNo, out entrustNumber);
pushBack.OriginalRequestNumber = entrustNumber;
pushBack.NewRequestNumber = entrustNumber;
pushBack.CallbackChannlId = channelID;
//pushBack.TradeID = model.
CounterOrderService.Instance.AcceptHKModifyOrder(pushBack);
string message = "";
//如果改单成功的话，那么发送内部的撤单回报
if (model.IsSuccess)
{
var cancelEntity = model.CanleOrderEntity;
message = "类型2改单成功-" + cancelEntity.Message;
cancelEntity.Message = "";
CancelHKStockOrderRpt(cancelEntity);
}
else
{
message = "类型2改单失败-" + model.Message;
}
// var tet = HKDataAccess.GetTodayEntrustTable(model.OrderNo);
//更新委托信息
//if (tet != null)
//{
// tet.OrderMessage = message;
// HKDataAccess.UpdateEntrustTable(tet);
//}
HKDataAccess.UpdateEntrustOrderMessage(entrustNumber, message);
}
private void DeleteEntrust(string entrustNumber)
{
if (string.IsNullOrEmpty(entrustNumber))
{
return;
}
//删除前面创建的柜台委托单实例
bool isSuccess = HKDataAccess.DeleteTodayEntrust(entrustNumber);
if (!isSuccess)
{
RescueManager.Instance.Record_HK_DeleteTodayEntrust(entrustNumber);
}
}
/// <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>
/// 处理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>
/// <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);
}
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);
}
/// <summary>
/// 执行删除港股当日委托动作
/// </summary>
/// <param name="entrustNumber">委托单号</param>
/// <returns>是否成功</returns>
private bool Rescue_HK_DeleteTodayEntrust(string entrustNumber)
{
return(HKDataAccess.DeleteTodayEntrust(entrustNumber));
}
/// <summary>
/// 内部撤单
/// </summary>
/// <param name="tet">委托实体</param>
/// <param name="strMcErrorMessage">错误信息</param>
/// <returns>是否成功</returns>
public override bool InternalCancelOrder(HK_TodayEntrustInfo tet, string strMcErrorMessage)
{
#region 初始化参数
//柜台委托单号
EntrustNumber = tet.EntrustNumber;
string errInfo = "[委托单号=" + EntrustNumber + ",Message=" + strMcErrorMessage + "]";
LogHelper.WriteDebug(
"------xxxxxx------开始进行港股内部撤单(撤单时委托状态为未报或者买卖报盘返回的委托单号无效)XHAcceptLogic.InternalCancelOrder" + errInfo);
Code = tet.Code;
CapitalAccount = tet.CapitalAccount; //资金帐户
HoldingAccount = tet.HoldAccount; //持仓帐户
var user = AccountManager.Instance.GetUserByAccount(tet.CapitalAccount);
if (user != null)
{
TradeID = user.UserID;
}
//else
//{
// TradeID = counterCacher.GetTraderIdByFundAccount(tet.CapitalAccount);
//}
//因为1.1结构修改，内部撤单和外部撤单逻辑已经一致，所以统一使用代码
//内部撤单也作为一个“特殊”的外部撤单来处理，即柜台自己造一个“撤单回报”
//发送给ReckonUnit来处理
//假的撮合委托单号
string orderNo = Guid.NewGuid().ToString();
tet.McOrderID = orderNo;
//假的撮合委托单号也要写入委托信息中，以便后面好删除缓存
//=====update 2009-11-09 李健华====
//HKDataAccess.UpdateEntrustTable(tet);
//这里只是更新撮合ID编号，以免更新了别的字段
HKDataAccess.UpdateEntrustMcOrderID(EntrustNumber, orderNo);
//=============
LogHelper.WriteDebug("HKAcceptLogic.InternalCancelOrder添加委托单号映射到ConterCache,OrderNo=" + orderNo);
//柜台缓存委托相关信息
var item = new OrderCacheItem(tet.CapitalAccount, tet.HoldAccount, tet.EntrustNumber,
(Types.TransactionDirection)Enum.Parse(typeof(Types.TransactionDirection),
tet.BuySellTypeID.ToString()));
item.EntrustAmount = tet.EntrustAmount;
item.Code = tet.Code;
item.TraderId = TradeID;
counterCacher.AddOrderMappingInfo(orderNo,
item);
CancelOrderEntityEx coe = new CancelOrderEntityEx();
coe.IsInternalCancelOrder = true;
coe.OrderNo = orderNo;
coe.IsSuccess = true;
coe.OrderVolume = tet.EntrustAmount - tet.TradeAmount - tet.CancelAmount;
coe.Id = Guid.NewGuid().ToString();
coe.Message = strMcErrorMessage;
ReckonCenter.Instace.AcceptCancelHKOrderRpt(coe);
#endregion
//内部撤单流程
//1.资金冻结处理，把资金冻结记录里的金额和费用全部还给资金表，删除冻结记录(实际上清零，不删除，盘后统一删）
//2.资金处理，把从资金冻结记录还回来的金额和费用加到可用资金，并减去总冻结资金
//3.持仓冻结处理(买入不处理）,把持仓冻结记录中的冻结量还给持仓表，删除冻结记录(实际上清零，不删除，盘后统一删）
//4.持仓处理（买入不处理），把从持仓冻结记录还回来的持仓量加到可用持仓，并减去总冻结持仓
//5.委托处理，更新委托状态，成交量，撤单量以及委托消息(OrderMessage)
return(true);
}
