/// <summary>
/// 保存撤单回报
/// </summary>
/// <param name="entity">撤单回报</param>
private bool InsertCancelDealBackEntity(CancelOrderEntity entity, DealBackEntityType type)
{
if (HasAddId(entity.Id))
{
return(false);
}
BD_UnReckonedDealTableInfo table = new BD_UnReckonedDealTableInfo();
table.id = entity.Id;
table.OrderNo = entity.OrderNo;
table.Message = entity.Message;
//table.Price = entity.DealPrice;
table.Amount = (int)entity.OrderVolume;
table.IsSuccess = entity.IsSuccess;
table.EntityType = (int)type;
string desc = GetCancelDesc(entity);
LogHelper.WriteDebug("$-------$CrashManager.InsertCancelDealBackEntity" + desc);
SaveEntity(table);
//entity.Id = table.Id.ToString();
AddID(entity.Id);
return(true);
}
public string GetCancelDesc(CancelOrderEntity entity)
{
string format = "撤单回报[OrderNo={0},OrderVolume={1},Message={2},IsSuccess={3}, ID={4}, CounterID={5}]";
return(string.Format(format, entity.OrderNo, entity.OrderVolume, entity.Message, entity.IsSuccess, entity.Id,
CountID));
}
/// <summary>
/// 保存撮合中心商品期货撤单回报
/// </summary>
/// <param name="model">回报实体</param>
public void SaveCFCancelBack(CancelOrderEntity model)
{
#region 通道号或者成交实体不能为空
if (model == null || string.IsNullOrEmpty(model.ChannelNo))
{
return;
}
#endregion
#region 步撤单实体
lock (((ICollection)MatchCenterManager.Instance.CancelBackCFEntitys).SyncRoot)
{
if (MatchCenterManager.Instance.CancelBackCFEntitys.ContainsKey(model.ChannelNo))
{
Queue <CancelOrderEntity> queue = MatchCenterManager.Instance.CancelBackCFEntitys[model.ChannelNo];
queue.Enqueue(model);
}
else
{
var queue = new Queue <CancelOrderEntity>();
queue.Enqueue(model);
MatchCenterManager.Instance.CancelBackCFEntitys[model.ChannelNo] = queue;
}
}
#endregion
}
public static string DescInfo(this CancelOrderEntity entity)
{
string format = "CancelOrderEntity[OrderNo={0},OrderVolume={1},IsSuccess={2},Message={3},ID={4}]";
string desc = string.Format(format, entity.OrderNo, entity.OrderVolume, entity.IsSuccess, entity.Message,
entity.Id);
return(desc);
}
/// <summary>
/// 撤销委托单
/// </summary>
/// <param name="model">委托单</param>
public void CancelOrder(CancelEntity model)
{
if (model == null)
{
return;
}
//bool cancel = false;
var dataEntity = new CancelOrderEntity();
dataEntity.OrderNo = model.OldOrderNo;
string code = Guid.NewGuid().ToString();
//id
dataEntity.Id = code;
//撮合中心委托单号
if (string.IsNullOrEmpty(model.OldOrderNo))
{
return;
}
decimal cancount = 0.00m;
dataEntity.IsSuccess = false;
dataEntity.Message = "撤单失败，委托单不存在。";
OperationContext context = null;
if (model.ChannelNo != null)
{
if (MatchCenterManager.Instance.OperationContexts.ContainsKey(model.ChannelNo))
{
context = MatchCenterManager.Instance.OperationContexts[model.ChannelNo];
}
}
//撮合中心上下文不能为空
if (context == null)
{
return;
}
try
{
dataEntity.OrderVolume = 0.00m;
var callback = context.GetCallbackChannel <IDoOrderCallback>();
if (callback != null)
{
//var md = new CancelOrderDelegate(callback.CancelStockIndexFuturesOrderRpt);
//md.BeginInvoke(dataEntity, null, null);
callback.CancelStockIndexFuturesOrderRpt(dataEntity);
}
LogHelper.WriteDebug(" 撤单失败[" + "委托id=" + code + "委托代码=" + model.StockCode + ",撤单时间=" + DateTime.Now + ",委托单号码=" + model.OldOrderNo + ",撤单数量=" + cancount + "]");
}
catch (Exception ex)
{
LogHelper.WriteError("CH-0001:撤单失败wcf服务通道阻塞", ex);
return;
}
}
/// <summary>
/// 撤消委托单
/// </summary>
/// <param name="model">委托实体</param>
public void CancelOrder(CancelEntity model)
{
LogHelper.WriteDebug("[撮合单元运行撤销委托单方法]");
//委托实体为空
if (model == null)
{
return;
}
//bool cancel = false;
string code = Guid.NewGuid().ToString();
var dataEntity = new CancelOrderEntity();
//id
dataEntity.Id = code;
//委托单号码
dataEntity.OrderNo = model.OldOrderNo;
//通道号码
dataEntity.ChannelNo = model.ChannelNo;
decimal cancount = 0.00m;
dataEntity.IsSuccess = false;
dataEntity.Message = "撤单失败，委托单不存在。";
OperationContext context = null;
//通道号码不能为空
if (model.ChannelNo != null)
{
if (MatchCenterManager.Instance.OperationContexts.ContainsKey((model.ChannelNo)))
{
context = MatchCenterManager.Instance.OperationContexts[model.ChannelNo];
}
}
//上下文不能为空
if (context == null)
{
return;
}
try
{
var callback = context.GetCallbackChannel <IDoOrderCallback>();
if (callback != null)
{
callback.CancelStockOrderRpt(dataEntity);
}
LogHelper.WriteDebug(" 撤单失败[" + "委托id=" + code + "委托代码=" + model.StockCode + ",撤单时间=" + DateTime.Now + ",委托单号码=" + model.OldOrderNo + ",撤单数量=" + cancount + "]");
}
catch (Exception ex)
{
LogHelper.WriteError("CH-100:撤单wcf服务通道异常", ex);
TradePushBackImpl.Instanse.SaveXHCancelBack(dataEntity);
}
}
/// <summary>
/// 港股撤单回报
/// </summary>
/// <param name="model"></param>
public void CancelHKStockOrderRpt(CancelOrderEntity model)
{
string desc = CrashManager.GetInstance().GetCancelDesc(model);
LogHelper.WriteDebug("<---港股撤单异步回报DoCallbackProcess.CancelHKStockOrderRpt" + desc);
if (string.IsNullOrEmpty(model.Id))
{
model.Id = Guid.NewGuid().ToString();
}
if (CrashManager.GetInstance().InsertHkCancelDealBackEntity(model))
{
ReckonCenter.Instace.AcceptCancelHKOrderRpt(model);
}
}
// CancelOrder
public async Task <CancelOrder> CancelOrder(CancelType cancelType, string orderID, string currency, TradingPair tradingPair)
{
string market = String.Format("{0}_{1}", currency, tradingPair.ToString());
using (var client = new HttpClient())
{
// create the URL string.
string endpoint = "api/private/cancelorder";
// JSON POST parameters
JObject jObject = new JObject();
jObject["Type"] = cancelType.ToString();
jObject["OrderId"] = orderID;
jObject["Market"] = market;
string postParams = jObject.ToString(Formatting.None, null);
// Http Client params
SetHttpClientPropertiesPrivate(client, endpoint, postParams);
// make the request
var content = new StringContent(postParams, Encoding.UTF8, "application/json");
var response = await client.PostAsync(endpoint, content);
// parse the response and return the data.
var jsonResponseString = await response.Content.ReadAsStringAsync();
CancelOrderEntity cancelOrderEntity = new CancelOrderEntity();
try
{
cancelOrderEntity = JsonConvert.DeserializeObject <CancelOrderEntity>(jsonResponseString);
}
catch (Exception e)
{
throw new Exception(_ParseError, e);
}
// Check success message from server
if (cancelOrderEntity.Success == false)
{
throw new Exception(_SuccessError);
}
return(cancelOrderEntity.Result);
}
}
private void ProcessCancelTable(BD_UnReckonedDealTableInfo table, int type)
{
CancelOrderEntity entity = new CancelOrderEntity();
entity.Id = table.id;
entity.OrderNo = table.OrderNo;
entity.OrderVolume = table.Amount.Value;
entity.Message = table.Message;
entity.IsSuccess = table.IsSuccess;
switch (type)
{
case (int)DealBackEntityType.XHCancel:
LogHelper.WriteInfo("$-------$CrashManger.ProcessCancelTable重新发送现货CancelOrderEntity" +
GetCancelDesc(entity));
ReckonCenter.Instace.AcceptCancelXHOrderRpt(entity);
break;
case (int)DealBackEntityType.HKCancel:
LogHelper.WriteInfo("$-------$CrashManger.ProcessCancelTable重新发送现货CancelOrderEntity" +
GetCancelDesc(entity));
ReckonCenter.Instace.AcceptCancelHKOrderRpt(entity);
break;
case (int)DealBackEntityType.QHCancel:
LogHelper.WriteInfo("$-------$CrashManger.ProcessCancelTable重新发送期货CancelOrderEntity" +
GetCancelDesc(entity));
ReckonCenter.Instace.AcceptCancelSPQHOrderRpt(entity);
break;
case (int)DealBackEntityType.GZQHCancel:
LogHelper.WriteInfo("$-------$CrashManger.ProcessCancelTable重新发送股指期货CancelOrderEntity" +
GetCancelDesc(entity));
ReckonCenter.Instace.AcceptCancelGZQHOrderRpt(entity);
break;
}
}
/// <summary>
/// 构建港股撤单成交回报
/// </summary>
/// <param name="tet"></param>
/// <param name="rde"></param>
/// <param name="tm"></param>
/// <param name="trade"></param>
/// <param name="isInternalCancel"></param>
/// <returns></returns>
public static string BuildHKCancelRpt(HK_TodayEntrustInfo tet, CancelOrderEntity rde,
ReckoningTransaction tm, out HK_TodayTradeInfo trade,
bool isInternalCancel)
{
string result = string.Empty;
//当为价格错误的撤单时，直接作为废单，不记录到数据库中。
if (rde.OrderVolume == -1)
{
trade = null;
return(result);
}
//成交回报实体
var hkDealrpt = new HK_TodayTradeInfo();
//xhDealrpt.TradeNumber = this.BuildXHDealOrderNo();
hkDealrpt.TradeNumber = rde.Id; //不再自己构建id，使用撤单回报的id，一一对应
//成交时间
hkDealrpt.TradeTime = DateTime.Now;
//成交价
hkDealrpt.TradePrice = 0;
//成交单位
hkDealrpt.TradeUnitId = tet.TradeUnitID;
//成交量
hkDealrpt.TradeAmount = Convert.ToInt32(rde.OrderVolume);
//股东代码
hkDealrpt.HoldAccount = tet.HoldAccount;
//资金帐户
hkDealrpt.CapitalAccount = tet.CapitalAccount;
//成交回报类型
if (isInternalCancel)
{
hkDealrpt.TradeTypeId = (int)Types.DealRptType.DRTInternalCanceled;
}
else
{
hkDealrpt.TradeTypeId = (int)Types.DealRptType.DRTCanceled;
}
//现货名称
hkDealrpt.Code = tet.Code;
//印花税
hkDealrpt.StampTax = 0;
//佣金
hkDealrpt.Commission = 0;
//过户费
hkDealrpt.TransferAccountFee = 0;
//交易系统使用费
hkDealrpt.TradingSystemUseFee = 0;
//监管费
hkDealrpt.MonitoringFee = 0;
hkDealrpt.ClearingFee = 0;
//委托价格
hkDealrpt.EntrustPrice = tet.EntrustPrice;
//成交金额
hkDealrpt.TradeCapitalAmount = hkDealrpt.TradePrice * hkDealrpt.TradeAmount;
//投组标识
hkDealrpt.PortfolioLogo = tet.PortfolioLogo;
//货币类型
hkDealrpt.CurrencyTypeId = tet.CurrencyTypeID;
//买卖方向
hkDealrpt.BuySellTypeId = tet.BuySellTypeID;
hkDealrpt.EntrustNumber = tet.EntrustNumber;
HK_TodayTradeDal hkTodayTradeDal = new HK_TodayTradeDal();
hkTodayTradeDal.Add(hkDealrpt, tm);
result = hkDealrpt.TradeNumber;
trade = hkDealrpt;
return(result);
}
public bool InsertGZQHCancelDealBackEntity(CancelOrderEntity entity)
{
return(InsertCancelDealBackEntity(entity, DealBackEntityType.GZQHCancel));
}
/// <summary>
/// 构造器
/// </summary>
/// <param name="rptItem"></param>
/// <param name="breedClassType"></param>
public CancelOrderRptItem(CancelOrderEntity rptItem, Types.BreedClassTypeEnum breedClassType)
{
RptItem = rptItem;
BreedClassType = breedClassType;
}
/// <summary>
/// 构建现货撤单成交回报
/// </summary>
/// <param name="tet"></param>
/// <param name="rde"></param>
/// <param name="tm"></param>
/// <param name="trade"></param>
/// <param name="isInternalCancel"></param>
/// <returns></returns>
public static string BuildXHCancelRpt(XH_TodayEntrustTableInfo tet, CancelOrderEntity rde,
ReckoningTransaction tm, out XH_TodayTradeTableInfo trade,
bool isInternalCancel)
{
string result = string.Empty;
//当为价格错误的撤单时，直接作为废单，不记录到数据库中。
if (rde.OrderVolume == -1)
{
trade = null;
return(result);
}
//成交回报实体
var xhDealrpt = new XH_TodayTradeTableInfo();
//xhDealrpt.TradeNumber = this.BuildXHDealOrderNo();
xhDealrpt.TradeNumber = rde.Id; //不再自己构建id，使用撤单回报的id，一一对应
//成交时间
xhDealrpt.TradeTime = DateTime.Now;
//成交价
xhDealrpt.TradePrice = 0;
//成交单位
xhDealrpt.TradeUnitId = tet.TradeUnitId;
//成交量
xhDealrpt.TradeAmount = Convert.ToInt32(rde.OrderVolume);
//股东代码
xhDealrpt.StockAccount = tet.StockAccount;
//资金帐户
xhDealrpt.CapitalAccount = tet.CapitalAccount;
//成交回报类型
if (isInternalCancel)
{
xhDealrpt.TradeTypeId = (int)Types.DealRptType.DRTInternalCanceled;
}
else
{
xhDealrpt.TradeTypeId = (int)Types.DealRptType.DRTCanceled;
}
//现货名称
xhDealrpt.SpotCode = tet.SpotCode;
//印花税
xhDealrpt.StampTax = 0;
//佣金
xhDealrpt.Commission = 0;
//过户费
xhDealrpt.TransferAccountFee = 0;
//交易系统使用费
xhDealrpt.TradingSystemUseFee = 0;
//监管费
xhDealrpt.MonitoringFee = 0;
xhDealrpt.ClearingFee = 0;
//委托价格
xhDealrpt.EntrustPrice = tet.EntrustPrice;
//成交金额
xhDealrpt.TradeCapitalAmount = xhDealrpt.TradePrice * xhDealrpt.TradeAmount;
//投组标识
xhDealrpt.PortfolioLogo = tet.PortfolioLogo;
//货币类型
xhDealrpt.CurrencyTypeId = tet.CurrencyTypeId;
//买卖方向
xhDealrpt.BuySellTypeId = tet.BuySellTypeId;
xhDealrpt.EntrustNumber = tet.EntrustNumber;
XH_TodayTradeTableDal xhTodayTradeTableDal = new XH_TodayTradeTableDal();
xhTodayTradeTableDal.Add(xhDealrpt, tm);
result = xhDealrpt.TradeNumber;
trade = xhDealrpt;
return(result);
}
/// <summary>
/// 构建期货撤单回报
/// </summary>
/// <param name="tet"></param>
/// <param name="rde"></param>
/// <param name="tm"></param>
/// <param name="isInternalCancelOrder"></param>
/// <returns></returns>
public static QH_TodayTradeTableInfo BuildQHCancelRpt(QH_TodayEntrustTableInfo tet, CancelOrderEntity rde,
ReckoningTransaction tm, bool isInternalCancelOrder)
{
string result = string.Empty;
//当为价格错误的撤单时，直接作为废单，不记录到数据库中。
if (rde.OrderVolume == -1)
{
return(null);
}
//成交回报实体
var qhDealrpt = new QH_TodayTradeTableInfo();
qhDealrpt.TradeNumber = rde.Id; //不再自己构建id，使用撤单回报的id，一一对应
//成交时间
qhDealrpt.TradeTime = DateTime.Now;
//成交价
qhDealrpt.TradePrice = 0;
//成交量
qhDealrpt.TradeAmount = Convert.ToInt32(rde.OrderVolume);
//股东代码
qhDealrpt.TradeAccount = tet.TradeAccount;
//资金帐户
qhDealrpt.CapitalAccount = tet.CapitalAccount;
//成交回报类型
if (isInternalCancelOrder)
{
qhDealrpt.TradeTypeId = (int)Types.DealRptType.DRTInternalCanceled;
}
else
{
qhDealrpt.TradeTypeId = (int)Types.DealRptType.DRTCanceled;
}
//现货名称
qhDealrpt.ContractCode = tet.ContractCode;
//交易手续费
qhDealrpt.TradeProceduresFee = 0;
//保证金
qhDealrpt.Margin = 0;
//委托价格
qhDealrpt.EntrustPrice = tet.EntrustPrice;
//委托单号
qhDealrpt.EntrustNumber = tet.EntrustNumber;
//投组标识
qhDealrpt.PortfolioLogo = tet.PortfolioLogo;
//货币类型
qhDealrpt.CurrencyTypeId = tet.CurrencyTypeId;
//开平方向
qhDealrpt.OpenCloseTypeId = tet.OpenCloseTypeId;
//买卖方向
qhDealrpt.BuySellTypeId = tet.BuySellTypeId;
//成交单位
qhDealrpt.TradeUnitId = tet.TradeUnitId;
//2009-12-03 add 李健华
qhDealrpt.MarketProfitLoss = 0;
//==========
QH_TodayTradeTableDal qh_TodayTradeTableDal = new QH_TodayTradeTableDal();
// var provider = new SqlQhTodayTradeTableProvider(TransactionFactory.RC_ConnectionString, true, string.Empty);
//provider.Insert(tm, qhDealrpt);
qh_TodayTradeTableDal.Add(qhDealrpt, tm);
return(qhDealrpt);
}
//void IOrderDealRptCallback.CancelHKStockOrderRpt(CancelOrderEntity model)
//{
// throw new NotImplementedException();
//}
IAsyncResult IOrderDealRptCallback.BeginCancelHKStockOrderRpt(CancelOrderEntity model, AsyncCallback callback, object asyncState)
{
throw new NotImplementedException();
}
