/// <summary>
/// 获取股指期货交易费用
/// </summary>
/// <param name="request">股指期货委托</param>
/// <returns>股指期货交易费用结果</returns>
public static QHCostResult ComputeGZQHCost(StockIndexFuturesOrderRequest request)
{
int?bc = MCService.CommonPara.GetBreedClassIdByCommodityCode(request.Code);
QHCostResult result = null;
if (!bc.HasValue)
{
return(result);
}
int breedClassID = bc.Value;
QH_FutureCosts cost = MCService.FuturesTradeRules.GetFutureCostsByBreedClassID(breedClassID);
if (cost == null)
{
return(null);
}
try
{
result = InternalComputeGZQHCost(request, cost);
}
catch (Exception ex)
{
string errCode = "GT-1703";
string errMsg = "无法获取股指期货货交易费用。";
VTException exception = new VTException(errCode, errMsg, ex);
LogHelper.WriteError(exception.ToString(), exception);
throw exception;
}
return(result);
}
public void ProcessDoOrder(OrderResponse response, StockIndexFuturesOrderRequest request)
{
QHMessage message = new QHMessage();
message.BuySell = request.BuySell == GTA.VTS.Common.CommonObject.Types.TransactionDirection.Buying ? "买" : "卖";
message.CapitalAccount = request.FundAccountId;
message.Code = request.Code;
message.EntrustAmount = request.OrderAmount.ToString();
message.EntrustNumber = response.OrderId;
message.EntrustPrice = request.OrderPrice.ToString();
message.EntrustType = request.OrderWay == TypesOrderPriceType.OPTLimited ? "限价" : "市价";
message.OrderMessage = response.OrderMessage;
message.OrderStatus = "未报02";
message.TradeAmount = "0";
message.TradeTime = "";
message.OpenClose = Utils.GetFutureOpenCloseType(request.OpenCloseType);
qhMessageList.Add(message);
if (!response.IsSuccess)
{
message.EntrustNumber = Guid.NewGuid().ToString();
message.OrderStatus = "废单06";
}
qhMessageCache.Add(message.EntrustNumber, message);
HasChanged = true;
}
public OrderResponse DoGZQHOrder(StockIndexFuturesOrderRequest order)
{
if (!IsServiceOk)
{
return new OrderResponse {
OrderMessage = ServiceErrorMsg
}
}
;
order.ChannelID = Channelid;
OrderResponse response = null;
try
{
response = doOrderClient.DoStockIndexFuturesOrder(order);
}
catch (Exception ex)
{
LogHelper.WriteError(ex.Message, ex);
response = new OrderResponse();
response.IsSuccess = false;
response.OrderMessage = ServiceErrorMsg;
IsServiceOk = false;
}
return(response);
}
public void DoStockIndexFuturesOrderTest1()
{
OrderAccepter target = new OrderAccepter(); // TODO: 初始化为适当的值
StockIndexFuturesOrderRequest futuresorder = null; // TODO: 初始化为适当的值
futuresorder = new StockIndexFuturesOrderRequest();
//赋值
futuresorder.BuySell = Types.TransactionDirection.Buying;
futuresorder.Code = "IF0904";
futuresorder.ChannelID = "0";
futuresorder.FundAccountId = "010000002406";
futuresorder.OpenCloseType = ReckoningCounter.Entity.Contants.Types.FutureOpenCloseType.OpenPosition;
futuresorder.OrderAmount = 1;
futuresorder.OrderPrice = 2505;
futuresorder.OrderUnitType = GTA.VTS.Common.CommonObject.Types.UnitType.Hand;
futuresorder.OrderWay = ReckoningCounter.Entity.Contants.Types.OrderPriceType.OPTLimited;
futuresorder.TraderId = "24";
futuresorder.TraderPassword = "******";
futuresorder.PortfoliosId = "0";
OrderResponse expected = new OrderResponse(); //null; // TODO: 初始化为适当的值
expected.OrderId = "123456789"; //仅测试
OrderResponse actual;
actual = target.DoStockIndexFuturesOrder(futuresorder);
Assert.AreNotEqual(expected, actual);
// Assert.Inconclusive("验证此测试方法的正确性。");
}
/// <summary>
/// 股指期货委托规则检验
/// </summary>
/// <param name="request">股指期货委托对象</param>
/// <param name="errMsg">返回错误检验信息</param>
/// <returns>是否成功</returns>
public bool ValidateStockIndexFutureTradeRule(StockIndexFuturesOrderRequest request, ref string errMsg)
{
//目前股指期货的校验使用期货的校验
MercantileFuturesOrderRequest futuresOrderRequest = MCService.GetFuturesOrderRequest(request);
return(ValidateFutureTradeRule(futuresOrderRequest, ref errMsg));
}
public LocalFutureOpenValidater(StockIndexFuturesOrderRequest request)
{
//this.request = request;
this.traderId = request.TraderId;
this.code = request.Code;
this.buysell = request.BuySell;
}
public void DoStockIndexFuturesOrderTest()
{
OrderAccepter target = new OrderAccepter(); // TODO: Initialize to an appropriate value
StockIndexFuturesOrderRequest futuresorder = null; // TODO: Initialize to an appropriate value
OrderResponse expected = null; // TODO: Initialize to an appropriate value
OrderResponse actual;
actual = target.DoStockIndexFuturesOrder(futuresorder);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
/// <summary>
/// 获取股指期货交易费用
/// </summary>
/// <param name="code">商品代码</param>
/// <param name="price">委托价格</param>
/// <param name="amount">委托数量</param>
/// <param name="unitType">委托单位类型</param>
/// <param name="openCloseType">开平仓方向</param>
/// <returns>股指期货交易费用结果</returns>
public static QHCostResult ComputeGZQHCost(string code, float price, int amount, Types.UnitType unitType,
Entity.Contants.Types.FutureOpenCloseType openCloseType)
{
StockIndexFuturesOrderRequest request = new StockIndexFuturesOrderRequest();
request.Code = code;
request.OrderPrice = price;
request.OrderAmount = amount;
request.OrderUnitType = unitType;
request.OpenCloseType = openCloseType;
return(ComputeGZQHCost(request));
}
/// <summary>
/// 商品期货实体转换为股指期货实体
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static StockIndexFuturesOrderRequest SPQHEntryConversionGZQHEntry(MercantileFuturesOrderRequest model)
{
StockIndexFuturesOrderRequest futRequest = new StockIndexFuturesOrderRequest();
futRequest.BuySell = model.BuySell;
futRequest.ChannelID = model.ChannelID;
futRequest.Code = model.Code;
futRequest.FundAccountId = model.FundAccountId;
futRequest.OpenCloseType = model.OpenCloseType;
futRequest.OrderAmount = model.OrderAmount;
futRequest.OrderPrice = model.OrderPrice;
futRequest.OrderUnitType = model.OrderUnitType;
futRequest.OrderWay = model.OrderWay;
futRequest.PortfoliosId = model.PortfoliosId;
futRequest.TraderId = model.TraderId;
futRequest.TraderPassword = model.TraderPassword;
return(futRequest);
}
/// <summary>
/// 股指期货校验
/// </summary>
/// <param name="request">股指期货合约</param>
/// <param name="errMsg">错误信息</param>
/// <returns>校验成功失败结果</returns>
public static bool Validate(StockIndexFuturesOrderRequest request, ref string errMsg)
{
try
{
//内部校验
LocalFutureOpenValidater localFutureOpenValidater = new LocalFutureOpenValidater(request);
bool result = localFutureOpenValidater.Check(out errMsg, Types.BreedClassTypeEnum.StockIndexFuture);
//外部校验
if (result)
{
result = McValidater.GetInstance().ValidateStockIndexFutureTradeRule(request, ref errMsg);
}
return(result);
}
catch (Exception ex)
{
LogHelper.WriteError(ex.ToString(), ex);
return(false);
}
}
/// <summary>
/// 获取股指期货交易费用的实际方法，目前使用商品期货的计算方法
/// </summary>
/// <param name="request">股指期货委托</param>
/// <param name="cost">费用实体</param>
/// <returns>股指期货交易费用结果</returns>
private static QHCostResult InternalComputeGZQHCost(StockIndexFuturesOrderRequest request, QH_FutureCosts cost)
{
QHCostResult result = new QHCostResult();
//result.Code = result.Code;
result.Code = request.Code;
decimal orderPrice = (decimal)request.OrderPrice;
//期货合约乘数300
decimal scale = MCService.GetTradeUnitScale(request.Code, request.OrderUnitType);
//以计价单位计算的委托量
var orderAmount = (decimal)request.OrderAmount * scale;
//成交额
var dealAmount = orderPrice * orderAmount;
decimal cosing = 0;
//按类型计算比例
switch ((Types.FutrueCostType)Enum.Parse(typeof(Types.FutrueCostType), cost.CostType.ToString()))
{
case Types.FutrueCostType.TradeUnitCharge:
//与量有关的都是撮合单位，所以这里不用再把委托量*转换比例
//为了不改上面的代码这里直接再把原来转了的值再除
orderAmount = (decimal)orderAmount / scale;
cosing = orderAmount * cost.TurnoverRateOfServiceCharge;
break;
case Types.FutrueCostType.TurnoverRateOfSerCha:
//比例
decimal cosingScale = cost.TurnoverRateOfServiceCharge / 100;
cosing = dealAmount * cosingScale;
break;
}
cosing = Utils.Round(cosing);
#region old code
//decimal tradeVal = 0;
////成交单位比率
//if (cost.TradeUnitCharge.HasValue)
//{
// decimal trade = cost.TradeUnitCharge.Value / 100;
// tradeVal = orderAmount * trade;
// tradeVal = Utils.Round(tradeVal);
//}
//decimal turnVal = 0;
////成交金额比率
//if (cost.TurnoverRateOfServiceCharge.HasValue)
//{
// decimal turn = cost.TurnoverRateOfServiceCharge.Value / 100;
// turnVal = turn * dealAmount;
// turnVal = Utils.Round(turnVal);
//}
//result.Cosing = tradeVal + turnVal;
#endregion
result.Cosing = cosing;
string format = "股指期货费用计算[代码={0},价格={1},数量={2},单位={3},方向={4},合约乘数={5},股指期货交易费用类型={6},费用比率={7}]";
string desc = string.Format(format, request.Code, request.OrderPrice, request.OrderAmount,
request.OrderUnitType, request.BuySell, scale
, cost.CostType + "--" + (cost.CostType == (int)Types.FutrueCostType.TradeUnitCharge ? "按成交量" : "按成交额")
, cost.TurnoverRateOfServiceCharge);
LogHelper.WriteDebug(desc + result);
return(result);
}
/// <summary>
/// 构造股指期货委托单
/// </summary>
public static string BuildGZQHOrder(ref QH_TodayEntrustTableInfo order,
StockIndexFuturesOrderRequest originalOrder,
string strHoldingAccount, string strCapitalAccount,
int iCurType, ref string strMessage)
{
//bool result = false;
order = new QH_TodayEntrustTableInfo();
order.EntrustNumber = BuildQHOrderNo();
order.EntrustAmount = Convert.ToInt32(originalOrder.OrderAmount);
order.EntrustPrice = Convert.ToDecimal(originalOrder.OrderPrice);
order.EntrustTime = DateTime.Now;
order.OfferTime = DateTime.Now;
order.IsMarketValue = originalOrder.OrderWay == Types.OrderPriceType.OPTMarketPrice
? true
: false;
order.BuySellTypeId = (int)originalOrder.BuySell;
order.OrderStatusId = (int)Types.OrderStateType.DOSUnRequired;
if (strHoldingAccount == null)
{
strHoldingAccount = "";
}
order.TradeAccount = strHoldingAccount;
if (strCapitalAccount == null)
{
strCapitalAccount = "";
}
order.CapitalAccount = strCapitalAccount;
if (originalOrder.PortfoliosId == null)
{
originalOrder.PortfoliosId = "";
}
order.PortfolioLogo = originalOrder.PortfoliosId;
if (originalOrder.Code == null)
{
originalOrder.Code = "";
}
order.ContractCode = originalOrder.Code;
order.TradeAmount = 0;
order.TradeAveragePrice = 0;
order.CancelAmount = 0;
order.CancelLogo = true;
if (originalOrder.ChannelID == null)
{
originalOrder.ChannelID = "";
}
order.CallbackChannelId = originalOrder.ChannelID;
order.IsMarketValue = originalOrder.OrderWay == Types.OrderPriceType.OPTMarketPrice
? true
: false;
order.OpenCloseTypeId = (int)originalOrder.OpenCloseType;
order.TradeUnitId = (int)originalOrder.OrderUnitType;
order.CurrencyTypeId = iCurType;
order.OrderMessage = "";
order.McOrderId = "";
CheckEntrustLength(order);
QH_TodayEntrustTableDal dal = new QH_TodayEntrustTableDal();
dal.Add(order);
return(order.EntrustNumber);
}
/// <summary>
/// 平仓股指期货合约
/// </summary>
/// <param name="orderAccepter"></param>
/// <param name="holdTable">持仓合约</param>
/// <param name="price">价格</param>
/// <param name="isExpiredContract">是否是过期的合约需要平仓</param>
private void CloseStockIndexContract(OrderAccepter orderAccepter, QH_HoldAccountTableInfo holdTable, float price, bool isExpiredContract)
{
if (holdTable == null)
{
return;
}
//if (holdTable.HistoryHoldAmount<0.00m)
// return;
if (holdTable.HistoryHoldAmount == 0)
{
return;
}
StockIndexFuturesOrderRequest request = null;
if (isExpiredContract)
{
request = new StockIndexFuturesOrderRequest2 {
IsForcedCloseOrder = true, QHForcedCloseType = Types.QHForcedCloseType.Expired
};
}
else
{
request = new StockIndexFuturesOrderRequest2 {
IsForcedCloseOrder = true, QHForcedCloseType = Types.QHForcedCloseType.CapitalCheck
};
}
var buySellType = holdTable.BuySellTypeId == (int)Types.TransactionDirection.Buying
? Types.TransactionDirection.Selling
: Types.TransactionDirection.Buying;
request.BuySell = buySellType;
request.Code = holdTable.Contract;
request.FundAccountId = capitalAccount.UserAccountDistributeLogo;
request.OpenCloseType = Entity.Contants.Types.FutureOpenCloseType.ClosePosition;
request.OrderAmount = (float)holdTable.HistoryHoldAmount;
request.OrderPrice = price;
request.OrderUnitType = Types.UnitType.Hand;
request.OrderWay = price == 0
? Entity.Contants.Types.OrderPriceType.OPTMarketPrice
: Entity.Contants.Types.OrderPriceType.OPTLimited;
string type = isExpiredContract ? "持仓检查平仓" : "资金检查平仓";
string format =
"FutureDayChecker开盘持仓检查强制平仓[UserAccountDistributeLogo={0},AccountHoldLogoId={1}，Code={2}, Price={3}, 平仓类型={4}]-委托信息：" +
request;
string msg = string.Format(format, holdTable.UserAccountDistributeLogo, holdTable.AccountHoldLogoId,
holdTable.Contract, price, type);
LogHelper.WriteDebug(msg + holdTable);
UA_UserAccountAllocationTableDal ua_UserAccountAllocationTableDal = new UA_UserAccountAllocationTableDal();
//设置为其所属的交易员
var userAccountAllocationTable =
ua_UserAccountAllocationTableDal.GetModel(
capitalAccount.UserAccountDistributeLogo);
if (userAccountAllocationTable == null)
{
string msg2 = "开盘检查强行平仓失败！无法获取资金账户信息，ID=" + capitalAccount.UserAccountDistributeLogo;
LogHelper.WriteInfo(msg2);
return;
}
UA_UserBasicInformationTableDal ua_UserBasicInformationTableDal = new UA_UserBasicInformationTableDal();
var user =
ua_UserBasicInformationTableDal.GetModel(userAccountAllocationTable.UserID);
if (user == null)
{
string msg3 = "开盘检查强行平仓失败！无法获取交易员信息，UserID=" + userAccountAllocationTable.UserID;
LogHelper.WriteInfo(msg3);
return;
}
request.TraderId = user.UserID;
request.TraderPassword = user.Password;
orderAccepter.DoStockIndexFuturesOrder(request);
}
