/// <summary>
/// 3.买一卖一百分比
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private bool CheckType3(StockOrderRequest request, HighLowRange highLowRange)
{
decimal highRange = highLowRange.HighRange;
decimal lowRange = highLowRange.LowRange;
IRealtimeMarketService service = RealTimeMarketUtil.GetRealMarketService(); //RealtimeMarketServiceFactory.GetService();
HqExData data = service.GetStockHqData(request.Code);
HqExData exData = data;
HqData hqData = exData.HqData;
float b1 = hqData.Buyprice1;
decimal buy1 = (decimal)b1;
float s1 = hqData.Sellprice1;
decimal sell1 = (decimal)s1;
decimal high = sell1 * highRange;
decimal low = buy1 * lowRange;
decimal orderPrice = (decimal)request.OrderPrice;
if (orderPrice >= low && orderPrice <= high)
{
return(true);
}
return(false);
}
/// <summary>
/// 1.昨日收盘价的上下百分比
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private bool CheckType1(StockOrderRequest request, HighLowRange highLowRange)
{
decimal highRange = highLowRange.HighRange;
decimal lowRange = highLowRange.LowRange;
IRealtimeMarketService service = RealTimeMarketUtil.GetRealMarketService(); //RealtimeMarketServiceFactory.GetService();
HqExData data = service.GetStockHqData(request.Code);
HqExData exData = data;
float yClose = exData.YClose;
decimal yestPrice = (decimal)yClose;
decimal high = yestPrice * (1 + highRange);
decimal low = yestPrice * (1 - lowRange);
decimal orderPrice = (decimal)request.OrderPrice;
if (orderPrice >= low && orderPrice <= high)
{
return(true);
}
return(false);
}
/// <summary>
/// 获取现货交易费用
/// </summary>
/// <param name="request">现货委托</param>
/// <returns>现货交易费用结果</returns>
public static XHCostResult ComputeXHCost(StockOrderRequest request)
{
int?bc = MCService.CommonPara.GetBreedClassIdByCommodityCode(request.Code);
XHCostResult result = null;
if (!bc.HasValue)
{
return(null);
}
int breedClassID = bc.Value;
XH_SpotCosts cost = MCService.SpotTradeRules.GetSpotCostsByBreedClassID(breedClassID);
if (cost == null)
{
return(null);
}
try
{
result = InternalComputeXHCost(request, cost);
}
catch (Exception ex)
{
string errCode = "GT-1701";
string errMsg = "无法获取现货交易费用。";
VTException exception = new VTException(errCode, errMsg, ex);
LogHelper.WriteError(exception.ToString(), exception);
throw exception;
}
return(result);
}
StockOrderRequest BuildStockOrderRequest()
{
var result = new StockOrderRequest();
//通道回送通道ID
result.ChannelID = "A";
//买卖类型
result.BuySell = GTA.VTS.Common.CommonObject.Types.TransactionDirection.Buying;
//代码
result.Code = "000001";
//资金帐户
result.FundAccountId = "XH0001";
//交易员密码
result.TraderPassword = "******";
//委托量
result.OrderAmount = 100;
//委托价
result.OrderPrice = 44.58F;
//交易单位股
result.OrderUnitType = Types.UnitType.Thigh;
//限价委托/市价委托
result.OrderWay = ReckoningCounter.Entity.Contants.Types.OrderPriceType.OPTLimited;
//投组关系
result.PortfoliosId = "1";
return(result);
}
/// <summary>
/// 多个帐户下单调用的方法(10,100个帐户)
/// </summary>
/// <param name="stockOrderRequest"></param>
private void XhOrderTest(StockOrderRequest stockOrderRequest)
{
//DoOrderClient doOrderClient = new DoOrderClient();
string xhOrderID = string.Empty;
//下单
if (stockOrderRequestList.Count != 0)
{
DoOrderClient doOrderClient = new DoOrderClient();
DateTime startTime = DateTime.Now;
xhOrderID = doOrderClient.DoStockOrder(stockOrderRequest).OrderId;
DateTime endTime = DateTime.Now;
TimeSpan timeSpan = endTime - startTime;
int span = timeSpan.Milliseconds;
//allTimeSeconds += span;
//把每笔单的时间添加到list中
addTimeList.Add(span);
if (!string.IsNullOrEmpty(xhOrderID))
{
UpdateVaule(xhOrderID); //调用委托方法
}
}
}
public OrderResponse DoStockOrder(StockOrderRequest order)
{
if (!IsServiceOk)
{
return new OrderResponse {
OrderMessage = ServiceErrorMsg
}
}
;
order.ChannelID = Channelid;
OrderResponse response = null;
try
{
response = doOrderClient.DoStockOrder(order);
}
catch (Exception ex)
{
LogHelper.WriteError(ex.Message, ex);
response = new OrderResponse();
response.IsSuccess = false;
response.OrderMessage = ServiceErrorMsg;
IsServiceOk = false;
}
return(response);
}
public void DoStockOrderTest()
{
InitRealtimeMarketComponent();
OrderAccepter target = new OrderAccepter(); // TODO: Initialize to an appropriate value
StockOrderRequest stockorder = BuildStockOrderRequest(); // TODO: Initialize to an appropriate value
OrderResponse expected = null; // TODO: Initialize to an appropriate value
OrderResponse actual;
actual = target.DoStockOrder(stockorder);
Assert.IsNotNull(actual.OrderId);
}
/// <summary>
/// 获取现货交易费用
/// </summary>
/// <param name="code">商品代码</param>
/// <param name="price">委托价格</param>
/// <param name="amount">委托数量</param>
/// <param name="unitType">委托单位类型</param>
/// <param name="buySell">买卖方向</param>
/// <returns>现货交易费用结果</returns>
public static XHCostResult ComputeXHCost(string code, float price, int amount, Types.UnitType unitType,
Types.TransactionDirection buySell)
{
StockOrderRequest request = new StockOrderRequest();
request.Code = code;
request.OrderPrice = price;
request.OrderAmount = amount;
request.OrderUnitType = unitType;
request.BuySell = buySell;
return(ComputeXHCost(request));
}
/// <summary>
/// 4.权证涨跌幅
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private bool CheckType4(StockOrderRequest request, HighLowRange highLowRange)
{
decimal highRange = highLowRange.HighRange;
decimal lowRange = highLowRange.LowRange;
decimal orderPrice = (decimal)request.OrderPrice;
if (orderPrice >= lowRange && orderPrice <= highRange)
{
return(true);
}
return(false);
}
/// <summary>
/// 5.港股买卖价位
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private bool CheckType5(StockOrderRequest request, HighLowRange highLowRange)
{
HKRange hkRange = highLowRange.HongKongRange;
decimal buyHighRange = hkRange.BuyHighRange;
decimal buyLowRange = hkRange.BuyLowRange;
decimal sellHighRange = hkRange.SellHighRange;
decimal sellLowRange = hkRange.SellLowRange;
IRealtimeMarketService service = RealTimeMarketUtil.GetRealMarketService(); //RealtimeMarketServiceFactory.GetService();
HqExData data = service.GetStockHqData(request.Code);
HqExData exData = data;
HqData hqData = exData.HqData;
float b1 = hqData.Buyprice1;
decimal buy1 = (decimal)b1;
float s1 = hqData.Sellprice1;
decimal sell1 = (decimal)s1;
decimal buyH = sell1;
decimal buyL = MCService.HLRangeProcessor.GetHKRangeValue(request.Code, (decimal)request.OrderPrice, buy1,
-buyLowRange);
decimal sellH = MCService.HLRangeProcessor.GetHKRangeValue(request.Code, (decimal)request.OrderPrice, sell1,
sellHighRange);
decimal sellL = buy1;
decimal high = 0;
decimal low = 0;
if (request.BuySell == Types.TransactionDirection.Buying)
{
low = buyL;
high = buyH;
}
else
{
low = sellL;
high = sellH;
}
decimal orderPrice = (decimal)request.OrderPrice;
if (orderPrice >= low && orderPrice <= high)
{
return(true);
}
throw new NotImplementedException();
}
public override bool Validate(StockOrderRequest request, ref string strMessage)
{
string errMsg = "交易员没有此品种的交易权限！";
string errCode = "GT-1254";
string tradeID = request.TraderId;
if (string.IsNullOrEmpty(tradeID))
{
strMessage = errCode + ":" + errMsg;
return(false);
}
int userid = 0;
try
{
userid = int.Parse(tradeID.Trim());
}
catch (Exception ex)
{
LogHelper.WriteError(ex.Message, ex);
strMessage = errCode + ":" + errMsg;
return(false);
}
var rightList = MCService.CommonPara.GetTransactionRightTable(userid);
if (Utils.IsNullOrEmpty(rightList))
{
strMessage = errCode + ":" + errMsg;
return(false);
}
foreach (UM_DealerTradeBreedClass tradeBreedClass in rightList)
{
if (!tradeBreedClass.BreedClassID.HasValue)
{
continue;
}
if (this.BreedClassID == tradeBreedClass.BreedClassID.Value)
{
return(true);
}
}
strMessage = errCode + ":" + errMsg;
return(false);
}
public override bool Validate(StockOrderRequest request, ref string strMessage)
{
string errMsg = "现货委托数量必须大于零！";
string errCode = "GT-1255";
strMessage = errCode + ":" + errMsg;
if (request.OrderAmount <= 0)
{
return(false);
}
strMessage = "";
return(true);
}
/// <summary>
/// 获取交易品种并检验
/// </summary>
/// <param name="request">股票委托请求</param>
/// <param name="strMessage">现货检验错误信息</param>
/// <param name="iBreed">品种标识</param>
public bool Validate(StockOrderRequest request, ref string strMessage, int iBreed)
{
bool bresult = false;
StockRuleContainer src = GetContainer(iBreed);
if (src == null)
{
src = new StockRuleContainer(iBreed);
SetContainer(iBreed, src);
}
bresult = src.ValidateAllRules(request, ref strMessage); //调用现货检验总方法
return(bresult);
}
StockOrderRequest BuildOrder(int selectIndex)
{
var result = new StockOrderRequest();
result.Code = this.tbCode.Text;
result.ChannelID = ClientID;
result.OrderAmount = int.Parse(tbAmount.Text);
result.BuySell = selectIndex == 0
? TypesTransactionDirection.Buying
: TypesTransactionDirection.Selling;
result.OrderUnitType = TypesUnitType.Hand;
result.OrderPrice = double.Parse(this.tbPrice.Text);
result.OrderWay = TypesOrderPriceType.OPTLimited;
return(result);
}
/// <summary>
/// 初始化现货下单数据(多个帐户下单调用的方法 (10,100个帐户))
/// </summary>
private void InitXhOrder(string xAccount)
{
StockOrderRequest stockOrderRequest = new StockOrderRequest();
stockOrderRequest.BuySell = DoOrderS8090.TypesTransactionDirection.Buying;
stockOrderRequest.Code = "000005"; // "000001";// "031005";
stockOrderRequest.ChannelID = "0";
stockOrderRequest.FundAccountId = xAccount; //"010000004402";// "010000002402";
//stockOrderRequest.ExtensionData = // stockIndexFuturesOrderRequest.OpenCloseType("Buying");
stockOrderRequest.OrderAmount = 100;
stockOrderRequest.OrderPrice = 3.5f;
stockOrderRequest.OrderUnitType = DoOrderS8090.TypesUnitType.Thigh;
stockOrderRequest.OrderWay = DoOrderS8090.TypesOrderPriceType.OPTLimited;
//stockOrderRequest.TraderId = "44";// "24";
stockOrderRequest.TraderPassword = "******";
stockOrderRequest.PortfoliosId = "0";
stockOrderRequestList.Add(stockOrderRequest);
}
public override bool Validate(StockOrderRequest request, ref string strMessage)
{
bool result = false;
string errMsg = "超过当前现货单笔最大委托量！";
string errCode = "GT-1251";
strMessage = errCode + ":" + errMsg;
int maxUnit = TradeRules.MaxLeaveQuantityUnit;
Types.UnitType maxUnitType;
try
{
maxUnitType = (Types.UnitType)maxUnit;
}
catch
{
return(false);
}
decimal scale = MCService.GetTradeUnitScale(request.Code, request.OrderUnitType);
decimal scale2 = MCService.GetTradeUnitScale(request.Code, maxUnitType);
var orderAmount = (decimal)request.OrderAmount * scale;
int?maxSingle = TradeRules.MaxLeaveQuantity;
if (maxSingle.HasValue)
{
decimal maxAmount = maxSingle.Value * scale2;
if (orderAmount <= maxAmount)
{
result = true;
strMessage = "";
}
}
return(result);
}
/// <summary>
/// 股票（现货）委托规则检验
/// </summary>
/// <param name="request">股票委托对象</param>
/// <param name="errMsg">返回错误检验信息</param>
/// <returns>是否成功</returns>
public bool ValidateStockTradeRule(StockOrderRequest request, ref string errMsg)
{
CM_BreedClass breedClass = MCService.CommonPara.GetBreedClassByCommodityCode(request.Code);
bool result = false;
if (breedClass != null)
{
int breedClassTypeID = breedClass.BreedClassTypeID.Value;
int breedClassID = breedClass.BreedClassID;
if (breedClassTypeID != (int)Types.BreedClassTypeEnum.Stock)
{
return(false);
}
result = StockTradingRuleValidater.Validate(request, ref errMsg,
Convert.ToInt32(breedClassID));
}
return(result);
}
/// <summary>
/// 股票校验
/// </summary>
/// <param name="request">股票委托</param>
/// <param name="errMsg">错误信息</param>
/// <returns>校验成功失败结果</returns>
public static bool Validate(StockOrderRequest request, ref string errMsg)
{
try
{
//内部校验
LocalStockValidater local = new LocalStockValidater(request);
bool result = local.Check(out errMsg);
//外部校验
if (result)
{
result = McValidater.GetInstance().ValidateStockTradeRule(request, ref errMsg);
}
return(result);
}
catch (Exception ex)
{
LogHelper.WriteError(ex.ToString(), ex);
return(false);
}
}
//TODO:最小交易单位校验
/// <summary>
/// 最小交易单位校验，原来在外部校验中，但是为了避免与调用方重复调用数据库读取持仓，现在抽离出来
/// 供调用者直接调用
/// </summary>
/// <param name="request">委托</param>
/// <param name="position">当前委托对应的商品的持仓量</param>
/// <param name="errMsg">错误信息</param>
/// <returns>是否校验成功</returns>
public static bool ValidateStockMinVolumeOfBusiness(StockOrderRequest request, int position, ref string errMsg)
{
CM_BreedClass breedClass = MCService.CommonPara.GetBreedClassByCommodityCode(request.Code);
bool result = false;
if (breedClass != null)
{
int breedClassTypeID = breedClass.BreedClassTypeID.Value;
int breedClassID = breedClass.BreedClassID;
if (breedClassTypeID != (int)Types.BreedClassTypeEnum.Stock)
{
return(false);
}
StockMinVolumeOfBusinessCommand command = new StockMinVolumeOfBusinessCommand(breedClassID, position);
result = command.Validate(request, ref errMsg);
}
return(result);
}
/// <summary>
/// 下单消息处理
/// </summary>
/// <param name="response">下单返回信息</param>
/// <param name="request">下单请求</param>
public void ProcessDoOrder(OrderResponse response, StockOrderRequest request)
{
XHMessage message = new XHMessage();
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 = "";
listLock.EnterWriteLock();
try
{
xhMessageList.Add(message);
}
finally
{
listLock.ExitWriteLock();
}
if (!response.IsSuccess)
{
message.EntrustNumber = System.Guid.NewGuid().ToString();
message.OrderStatus = "废单06";
}
xhMessageCache.Add(message.EntrustNumber, message);
HasChanged = true;
}
/// <summary>
/// 6.最近成交价上下各多少元
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private bool CheckType6(StockOrderRequest request, HighLowRange highLowRange)
{
decimal highRange = highLowRange.HighRange;
decimal lowRange = highLowRange.LowRange;
IRealtimeMarketService service = RealTimeMarketUtil.GetRealMarketService(); //RealtimeMarketServiceFactory.GetService();
HqExData data = service.GetStockHqData(request.Code);
HqExData exData = data;
float rPrice = exData.LastVolume;
decimal recentPrice = (decimal)rPrice;
decimal high = recentPrice + highRange;
decimal low = recentPrice - lowRange;
decimal orderPrice = (decimal)request.OrderPrice;
if (orderPrice >= low && orderPrice <= high)
{
return(true);
}
return(false);
}
public LocalStockValidater(StockOrderRequest request)
{
this.request = request;
}
/// <summary>
/// 构建现货委托单
/// </summary>
/// <param name="order"></param>
/// <param name="originalOrder"></param>
/// <param name="strHoldingAccount"></param>
/// <param name="strCapitalAccount"></param>
/// <param name="iCurType"></param>
/// <param name="strMessage"></param>
/// <returns></returns>
public static string BuildXhOrder(ref XH_TodayEntrustTableInfo order, StockOrderRequest originalOrder,
string strHoldingAccount, string strCapitalAccount, int iCurType,
ref string strMessage)
{
if (order == null)
{
order = new XH_TodayEntrustTableInfo();
}
order.EntrustNumber = BuildXHOrderNo();
order.CurrencyTypeId = iCurType;
order.TradeUnitId = (int)originalOrder.OrderUnitType;
order.EntrustAmount = (int)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.StockAccount = strHoldingAccount.Trim();
if (strCapitalAccount == null)
{
strCapitalAccount = "";
}
order.CapitalAccount = strCapitalAccount.Trim();
if (originalOrder.PortfoliosId == null)
{
originalOrder.PortfoliosId = "";
}
order.PortfolioLogo = originalOrder.PortfoliosId.Trim();
if (originalOrder.Code == null)
{
originalOrder.Code = "";
}
order.SpotCode = originalOrder.Code.Trim();
order.TradeAmount = 0;
order.TradeAveragePrice = 0;
order.CancelAmount = 0;
order.CancelLogo = true;
if (originalOrder.ChannelID == null)
{
originalOrder.ChannelID = "";
}
order.CallbackChannlId = originalOrder.ChannelID.Trim();
order.IsMarketValue = originalOrder.OrderWay == Types.OrderPriceType.OPTMarketPrice
? true
: false;
order.OrderMessage = "";
order.McOrderId = "";
CheckEntrustLength(order);
#if (DEBUG)
LogHelper.WriteDebug("XHCommonLogic.BuildXhOrder:" + order);
#endif
XH_TodayEntrustTableDal dal = new XH_TodayEntrustTableDal();
dal.Add(order);
return(order.EntrustNumber);
}
/// <summary>
/// 现货下单测试
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnXHOrderService_Click(object sender, EventArgs e)
{
//下单请求时间
labXhXDTime.Text = DateTime.Now.ToString();
#region 一秒一个帐户下1000笔单的测试
////同一秒一个帐户下1000笔单的测试
//this.InitXhOrder();
//int count = 1000;
//Action action = new Action(XhOrderTest);
//for (int i = 0; i < count; i++)
//{
// action.BeginInvoke(null, null);
//}
#endregion
#region 一秒10帐户下1000笔单的测试
////同一秒一个10帐户下1000笔单的测试
//10个现货帐户
//string[] xAccountList = {
// "010000004402", "010000004502", "010000004602", "010000004702", "010000004802", "010000004902"
// ,"010000005002","010000005102","010000005202","010000005302"
// };
#endregion
#region 一秒100帐户下1000笔单的测试 //100个现货帐户
string[] xAccountList =
{
"010000004402", "010000004502", "010000004602", "010000004702", "010000004802", "010000004902"
, "010000005002", "010000005102", "010000005202", "010000005302", "010000005402", "010000005502", "010000005602",
"010000005702", "010000005802", "010000005902", "010000006002", "010000006102", "010000006202", "010000006302",
"010000006402", "010000006502", "010000006602", "010000006702", "010000006802", "010000006902", "010000007002",
"010000007102", "010000007202", "010000007302", "010000007402", "010000007502", "010000007602", "010000007702",
"010000007802", "010000007902", "010000008102", "010000008202", "010000008302", "010000008502", "010000008602",
"010000008702", "010000008802", "010000008902", "010000009002", "010000009102", "010000009202", "010000009302",
"010000009402", "010000009502", "010000009602", "010000009702", "010000009802", "010000009902", "010000010002",
"010000010102", "010000010202", "010000010302", "010000010402", "010000010502", "010000010602", "010000010702",
"010000010802", "010000010902", "010000011002", "010000011102", "010000011202", "010000011302", "010000011402",
"010000011502", "010000011602", "010000011702", "010000011802", "010000011902", "010000012002", "010000012102",
"010000012202", "010000012302", "010000012402", "010000012502", "010000012602", "010000012702", "010000012802",
"010000012902", "010000013002", "010000013102", "010000013202", "010000013302", "010000013402", "010000013502",
"010000013602", "010000013702", "010000013802", "010000013902", "010000014002", "010000014102", "010000014202",
"010000014302", "010000014402", "010000014502"
};
#endregion
//初始化现货下单数据
string _xAccount = string.Empty;
for (int i = 0; i < xAccountList.Length; i++)
{
_xAccount = xAccountList[i];
this.InitXhOrder(_xAccount);
}
allTimeSeconds = 0;
//循环多上帐户并执行现货下单
for (int i = 0; i < stockOrderRequestList.Count; i++)
{
int count = 10;// 100;//1000;
StockOrderRequest stockOrderRequest = stockOrderRequestList[i];
StockXdOrder stockXdOrder = new StockXdOrder(XhOrderTest);
for (int j = 0; j < count; j++)
{
stockXdOrder.BeginInvoke(stockOrderRequest, null, null);
}
}
}
private static XHCostResult InternalComputeXHCost(StockOrderRequest request, XH_SpotCosts cost)
{
CM_BreedClass breedClass = MCService.CommonPara.GetBreedClassByCommodityCode(request.Code);
XHCostResult result = new XHCostResult();
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;
/// 1.印花税
decimal stamp = cost.StampDuty / 100;
decimal stampStart = cost.StampDutyStartingpoint;
if (cost.StampDutyTypeID.HasValue)
{
int stampType = cost.StampDutyTypeID.Value;
#region old code
//if (stampType == (int)Types.GetValueTypeEnum.SingleSell &&
// request.BuySell == Types.TransactionDirection.Selling)
//{
// decimal stampVal = stamp * dealAmount;
// if (stampVal < stampStart)
// stampVal = stampStart;
// stampVal = Utils.Round(stampVal);
// result.StampDuty = stampVal;
//}
#endregion
decimal stampVal = stamp * dealAmount;
if (stampVal < stampStart)
{
stampVal = stampStart;
}
stampVal = Utils.Round(stampVal);
switch ((Types.GetValueTypeEnum)stampType)
{
case Types.GetValueTypeEnum.Single:
break;
case Types.GetValueTypeEnum.Scope:
break;
case Types.GetValueTypeEnum.Turnover:
break;
case Types.GetValueTypeEnum.Thigh:
break;
case Types.GetValueTypeEnum.SingleBuy:
if (request.BuySell == Types.TransactionDirection.Buying)
{
result.StampDuty = stampVal;
}
break;
case Types.GetValueTypeEnum.SingleSell:
if (request.BuySell == Types.TransactionDirection.Selling)
{
result.StampDuty = stampVal;
}
break;
case Types.GetValueTypeEnum.TwoEdge:
result.StampDuty = stampVal;
break;
case Types.GetValueTypeEnum.No:
break;
default:
break;
}
}
/// 2.佣金
//public decimal Commision { get; set; }
if (cost.Commision.HasValue)
{
decimal comm = cost.Commision.Value / 100;
decimal commVal = comm * dealAmount;
decimal commStart = cost.CommisionStartingpoint;
if (commVal < commStart)
{
commVal = commStart;
}
commVal = Utils.Round(commVal);
result.Commision = commVal;
}
/// 3.过户费
//public decimal TransferToll { get; set; }
decimal trans = cost.TransferToll / 100;
int transType = cost.TransferTollTypeID;
decimal transVal = 0;
//过户费类型 [按股] [按成交额]
switch (transType)
{
case (int)Types.GetValueTypeEnum.Thigh:
transVal = trans * orderAmount;
break;
case (int)Types.GetValueTypeEnum.Turnover:
transVal = trans * dealAmount;
break;
}
transVal = Utils.Round(transVal);
if (cost.TransferTollStartingpoint.HasValue)
{
decimal transStart = cost.TransferTollStartingpoint.Value;
if (transVal < transStart)
{
transVal = transStart;
}
}
transVal = Utils.Round(transVal);
result.TransferToll = transVal;
/// 4.交易手续费
//public decimal PoundageSingleValue { get; set; }
if (cost.GetValueTypeID.HasValue)
{
int poundType = cost.GetValueTypeID.Value;
//交易手续费单值 single double
switch (poundType)
{
case (int)Types.GetValueTypeEnum.Single:
decimal pound = cost.PoundageSingleValue.Value / 100;
decimal poundValue = pound * dealAmount;
poundValue = Utils.Round(poundValue);
result.PoundageSingleValue = poundValue;
break;
case (int)Types.GetValueTypeEnum.Scope:
//IList<XH_SpotRangeCost> costs =
// MCService.SpotTradeRules.GetSpotRangeCostByBreedClassID(breedClass.BreedClassID);
//foreach (XH_SpotRangeCost spotRangeCost in costs)
//{
// //int fieldRangeID = spotRangeCost.FieldRangeID;
// decimal pound2 = spotRangeCost.Value.Value;
// pound2 = Utils.Round(pound2);
// CM_FieldRange fieldRange = MCService.GetFieldRange(fieldRangeID);
// //是否在当前字段范围内
// bool isExist = MCService.CheckFieldRange(dealAmount, fieldRange);
// if (isExist)
// {
// result.PoundageSingleValue = pound2;
// break;
// }
//}
break;
}
}
/// 5.监管费
//public decimal MonitoringFee { get; set; }
if (cost.MonitoringFee.HasValue)
{
decimal monitor = cost.MonitoringFee.Value / 100;
decimal monitorVal = monitor * dealAmount;
monitorVal = Utils.Round(monitorVal);
result.MonitoringFee = monitorVal;
}
/// 6.结算费
if (cost.ClearingFees.HasValue)
{
decimal clear = cost.ClearingFees.Value / 100;
decimal clearval = clear * dealAmount;
clearval = Utils.Round(clearval);
result.ClearingFees = clearval;
}
/// 7.交易系统使用费（港股）
if (cost.SystemToll.HasValue)
{
result.TradeSystemFees = cost.SystemToll.Value;
}
string format = "现货费用计算[代码={0},价格={1},数量={2},单位={3},方向={4}]";
string desc = string.Format(format, request.Code, request.OrderPrice, request.OrderAmount,
request.OrderUnitType, request.BuySell);
LogHelper.WriteDebug(desc + result);
return(result);
}
/// <summary>
/// 构造函数
/// </summary>
public XhTodayEntrustTableEx(StockOrderRequest request)
{
OriginalRequest = request;
}
public override bool Validate(StockOrderRequest request, ref string strMessage)
{
//根据要求，柜台不再做涨跌幅判断，由撮合处理
return(true);
#region 根据要求，柜台不再做涨跌幅判断，由撮合处理 所以以下注释
//string errMsg = "现货涨跌幅检验失败！";
//string errCode = "GT-1253";
////如果是市价单，那么委托价格是0，不再校验
//if (request.OrderWay == Entity.Contants.Types.OrderPriceType.OPTMarketPrice)
//{
// return true;
//}
//decimal orderPrice = (decimal) request.OrderPrice;
//decimal orderPriceD = (decimal) request.OrderPrice;
//HighLowRangeValue value = MCService.HLRangeProcessor.GetHighLowRangeValueByCommodityCode(request.Code,
// orderPriceD);
//if (value == null)
//{
// return true;
//}
//if (value.RangeType != Types.HighLowRangeType.HongKongPrice)
//{
// decimal high = value.HighRangeValue;
// decimal low = value.LowRangeValue;
// if (orderPrice >= low && orderPrice <= high)
// {
// return true;
// }
// strMessage = errCode + ":" + errMsg;
// return false;
//}
//else
//{
// HKRangeValue hkRangeValue = value.HongKongRangeValue;
// decimal buyH = hkRangeValue.BuyHighRangeValue;
// decimal buyL = hkRangeValue.BuyLowRangeValue;
// decimal sellH = hkRangeValue.SellHighRangeValue;
// decimal sellL = hkRangeValue.SellLowRangeValue;
// decimal high = 0;
// decimal low = 0;
// if (request.BuySell == Types.TransactionDirection.Buying)
// {
// low = buyL;
// high = buyH;
// }
// else
// {
// low = sellL;
// high = sellH;
// }
// if (orderPrice >= low && orderPrice <= high)
// {
// return true;
// }
// strMessage = errCode + ":" + errMsg;
// return false;
//}
////HighLowRange highLowRange = MCService.HLRangeProcessor.GetStockHighLowRangeByCommodityCode(request.Code);
////switch (highLowRange.RangeType)
////{
//// case Types.HighLowRangeType.YesterdayCloseScale:
//// return CheckType1(request, highLowRange);
//// case Types.HighLowRangeType.RecentDealScale:
//// return CheckType2(request, highLowRange);
//// case Types.HighLowRangeType.Buy1Sell1Scale:
//// return CheckType3(request, highLowRange);
//// case Types.HighLowRangeType.RightPermitHighLow:
//// return CheckType4(request, highLowRange);
//// case Types.HighLowRangeType.HongKongPrice:
//// return CheckType5(request, highLowRange);
//// case Types.HighLowRangeType.RecentDealNumber:
//// return CheckType6(request, highLowRange);
////}
#endregion
}
public override bool Validate(StockOrderRequest request, ref string strMessage)
{
bool result = false;
string errMsg = "现货最小变动价位检验失败！";
string errCode = "GT-1252";
strMessage = errCode + ":" + errMsg;
int?min = TradeRules.ValueTypeMinChangePrice;
if (!min.HasValue)
{
return(false);
}
int minValueType = min.Value;
decimal orderPrice = (decimal)request.OrderPrice;
switch (minValueType)
{
case (int)Types.GetValueTypeEnum.Single:
decimal?minSingle = TradeRules.MinChangePrice;
if (minSingle.HasValue)
{
decimal minSingleValue = minSingle.Value;
//是否满足最小变动价位
if (orderPrice % minSingleValue == 0)
{
result = true;
strMessage = "";
}
}
break;
case (int)Types.GetValueTypeEnum.Scope:
//foreach (XH_MinChangePriceValue changePriceValue in MinChangePriceValue)
//{
// if (changePriceValue.Value.HasValue)
// {
// decimal fValue = changePriceValue.Value.Value;
// CM_FieldRange fieldRange = MCService.GetFieldRange(changePriceValue.FieldRangeID);
// //是否在当前字段范围内
// result = MCService.CheckFieldRange(orderPrice, fieldRange);
// if (result)
// {
// //是否满足最小变动价位
// if (orderPrice%fValue == 0)
// {
// strMessage = "";
// return true;
// }
// }
// }
//}
break;
}
return(result);
}
public override bool Validate(StockOrderRequest request, ref string strMessage)
{
string errMsg = "现货最小单位检验失败！";
string errCode = "GT-1250";
int unitID = (int)request.OrderUnitType;
int tradeWayID = (int)request.BuySell;
if (MinVolumeOfBusinessList == null)
{
strMessage = errCode + ":" + errMsg;
return(false);
}
var minVolumes = from minVolume in MinVolumeOfBusinessList
where minVolume.UnitID.Value == unitID && minVolume.TradeWayID.Value == tradeWayID
select minVolume;
;
//当此品种没有此交易单位时检验不通过。如权证 下单80股则检验失败(单位只有手和份)
if (minVolumes.Count() == 0)
{
strMessage = errCode + ":" + errMsg;
return(false);
}
if (request.BuySell == Types.TransactionDirection.Buying)
{
foreach (XH_MinVolumeOfBusiness volume in minVolumes)
{
if ((int)request.OrderUnitType == volume.UnitID)
{
if (request.OrderAmount < volume.VolumeOfBusiness.Value ||
(request.OrderAmount % volume.VolumeOfBusiness.Value != 0))
{
strMessage = errCode + ":" + errMsg;
return(false);
}
}
}
}
//卖的话需要进行零股处理
else
{
//委托单位转换为计价单位
decimal scale = MCService.GetTradeUnitScale(request.Code, request.OrderUnitType);
var amount = (decimal)request.OrderAmount * scale;
//持仓单位(默认为撮合单位)转为计价单位
decimal scale2 = MCService.GetMatchUnitScale(request.Code);
var position = m_Position * scale2;
if (amount > position)
{
strMessage = errCode + ":" + "超过可用持仓";
return(false);
}
//现货最小单位零股检验
foreach (XH_MinVolumeOfBusiness volume in minVolumes)
{
if ((int)request.OrderUnitType == volume.UnitID)
{
if (request.OrderAmount < volume.VolumeOfBusiness.Value ||
(request.OrderAmount % volume.VolumeOfBusiness.Value != 0))
{
if (amount != position)
{
strMessage = errCode + ":" + errMsg;
return(false);
}
}
}
}
//现货最小单位零股检验
//int zeroScale = TradeRules.MinVolumeMultiples;
//if (amount%zeroScale != 0)
//{
// if (amount != position)
// {
// strMessage = errCode + ":" + errMsg;
// return false;
// }
//}
}
return(true);
}
