Exemplo n.º 1
0
        /// <summary>
        /// 更新用户仓位信息包含股票和期货
        /// 该函数按照WorkThread的周期执行
        /// </summary>
        /// <param name="info">输入用户信息</param>
        /// <returns>用户仓位信息</returns>
        public static AccountInfo UpdateAccountList(UserInfo info)
        {
            string alias = info.alias.Trim();

            //获取全部持仓,该值会拆分成CC_Stock_records 和 CC_Future_records
            List <CC_TAOLI_TABLE> CC_records = new List <CC_TAOLI_TABLE>();

            if (CCDictionary.Keys.Contains(alias))
            {
                CC_records = CCDictionary[alias];
            }

            //获取股票持仓
            List <CC_TAOLI_TABLE> CC_Stock_records = (from item in CC_records where item.CC_TYPE == "49" && item.CC_USER == alias select item).ToList();

            //获取期货持仓
            List <CC_TAOLI_TABLE> CC_Future_records = (from item in CC_records where item.CC_TYPE == "1" && item.CC_USER == alias select item).ToList();

            //获取风控预冻结资金
            List <RiskFrozenInfo> Risk_Frozen_records = new List <RiskFrozenInfo>();

            if (RiskFrozenDictionary.Keys.Contains(alias))
            {
                Risk_Frozen_records = RiskFrozenDictionary[alias];
            }

            //获取股票委托冻结资金
            double         Entrust_frozen = 0;
            List <ERecord> Erecords       = new List <ERecord>();

            //获取委托持仓
            EntrustRecord.GetUserAccountInfo(alias, out Entrust_frozen, out Erecords);

            //内存股票账户,记录其中的可用资金,股票成本,冻结资金不随行情改变,直接使用
            StockAccountTable stockAccount = StockAccountDictionary[alias];

            //股票可用资金
            //1. 经过风控股票买入时改变,从减少可用资金,增加风控冻结资金;
            //2. 经过持仓股票卖出时改变,减少股票成本,增加股票可用资金
            // 股票可用资金,不会因行情改变而改变
            double stock_balance = Convert.ToDouble(stockAccount.Balance.Trim());

            //股票成本
            double stock_cost = Convert.ToDouble(stockAccount.StockValue.Trim());

            //冻结资金 (委托冻结资金 + 风控冻结资金)
            double stock_frozen_value = 0;

            foreach (ERecord record in Erecords)
            {
                stock_frozen_value += record.Amount * record.OrderPrice;
            }

            foreach (RiskFrozenInfo record in Risk_Frozen_records)
            {
                if (record.Type == "S" || record.Type == "s")
                {
                    stock_frozen_value += Convert.ToDouble(record.FrozenCost);
                }
            }

            //计算股票市值
            double market_value = 0;

            //股票盈亏
            double stock_earning = 0;

            foreach (CC_TAOLI_TABLE item in CC_Stock_records)
            {
                double price = 0;
                if (MarketPrice.market.Keys.Contains(item.CC_CODE.Trim()))
                {
                    price = MarketPrice.market[item.CC_CODE.Trim()] / 10000;
                }
                else
                {
                    price = Convert.ToDouble(item.CC_BUY_PRICE);
                }

                if (price != 0)
                {
                    //存在最新市值,采用最新市值计算
                    market_value += (Convert.ToInt32(item.CC_AMOUNT) * price);

                    //知道最新市值才能求盈亏
                    stock_earning += (price - Convert.ToDouble(item.CC_BUY_PRICE)) * Convert.ToInt32(item.CC_AMOUNT);
                }
                else
                {
                    //未找到最新市值,用成交价计算
                    market_value += (Convert.ToInt32(item.CC_AMOUNT) * Convert.ToDouble(item.CC_BUY_PRICE));
                }
            }

            //股票权益 (可用资金 + 股票市值 + 冻结资金量)
            double stock_total = stock_balance + market_value + stock_frozen_value;

            //内存期货账户,记录其中的平仓盈亏,静态权益,保证金,期货冻结资金不随行情改变,直接使用
            FutureAccountTable futureAccount = FutureAccountDictionary[alias];

            //静态权益
            double static_intrests = Convert.ToDouble(futureAccount.StatisInterests.Trim());

            //平仓盈亏
            double offset_gain = Convert.ToDouble(futureAccount.OffsetGain.Trim());

            //保证金
            double cash_deposit = Convert.ToDouble(futureAccount.CashDeposit.Trim());

            //期货冻结保证金
            double frozen_cash_deposit = 0;

            foreach (RiskFrozenInfo record in Risk_Frozen_records)
            {
                if (record.Type == "F" || record.Type == "F")
                {
                    frozen_cash_deposit += Convert.ToDouble(record.FrozenCost) * AccountPARA.Factor(record.Code) * AccountPARA.MarginValue;
                }
            }



            //期货对应股票市值
            double future_stock_marketvalue = 0;

            //持仓盈亏
            double opsition_gain = 0;

            foreach (CC_TAOLI_TABLE item in CC_Future_records)
            {
                double fprice = 0;

                if (MarketPrice.market.Keys.Contains(item.CC_CODE.Trim()))
                {
                    fprice = MarketPrice.market[item.CC_CODE.Trim()] / 10000;
                }
                else
                {
                    fprice = Convert.ToDouble(item.CC_BUY_PRICE);
                }

                if (item.CC_DIRECTION == TradeOrientationAndFlag.FutureTradeDirectionBuy)
                {
                    if (fprice != 0)
                    {
                        //期货买入仓位
                        //没有实时行情信息,无需再运行持仓盈亏
                        opsition_gain += (fprice - Convert.ToDouble(item.CC_BUY_PRICE)) * Convert.ToInt32(item.CC_AMOUNT) * AccountPARA.Factor(item.CC_CODE);

                        //存在实时行情,用期货行情计算期货对应股票市值
                        future_stock_marketvalue += (AccountPARA.Factor(item.CC_CODE) * Convert.ToInt32(item.CC_AMOUNT) * fprice);
                    }
                    else
                    {
                        //不存在实时行情,用成交价格计算期货对应股票市值
                        future_stock_marketvalue += (AccountPARA.Factor(item.CC_CODE) * Convert.ToInt32(item.CC_AMOUNT) * Convert.ToDouble(item.CC_BUY_PRICE));
                    }
                }
                else if (item.CC_DIRECTION == TradeOrientationAndFlag.FutureTradeDirectionSell)
                {
                    if (fprice != 0)
                    {
                        //期货买入仓位
                        //没有实时行情信息,无需再运行持仓盈亏
                        opsition_gain += (Convert.ToDouble(item.CC_BUY_PRICE) - fprice) * Convert.ToInt32(item.CC_AMOUNT) * AccountPARA.Factor(item.CC_CODE);

                        //存在实时行情,用期货行情计算期货对应股票市值
                        future_stock_marketvalue -= (AccountPARA.Factor(item.CC_CODE) * Convert.ToInt32(item.CC_AMOUNT) * fprice);
                    }
                    else
                    {
                        //不存在实时行情,用成交价格计算期货对应股票市值
                        future_stock_marketvalue -= (AccountPARA.Factor(item.CC_CODE) * Convert.ToInt32(item.CC_AMOUNT) * Convert.ToDouble(item.CC_BUY_PRICE));
                    }
                }
            }

            //动态权益 (静态权益 + 平仓盈亏 + 持仓盈亏)
            double dynamic_interests = static_intrests + offset_gain + opsition_gain;

            //可用资金 (动态权益 - 保证金)
            double expendableFund = dynamic_interests - cash_deposit;

            //期货风险度 (占用保证金 / 动态权益)
            double future_risk = cash_deposit / dynamic_interests;

            //更新股票资金Dictionary
            lock (StockAccountDictionary)
            {
                StockAccountDictionary[alias].Balance          = stock_balance.ToString();
                StockAccountDictionary[alias].Earning          = stock_earning.ToString();
                StockAccountDictionary[alias].MarketValue      = market_value.ToString();
                StockAccountDictionary[alias].StockFrozenValue = stock_frozen_value.ToString();
                StockAccountDictionary[alias].StockValue       = stock_cost.ToString();
                StockAccountDictionary[alias].Total            = stock_total.ToString();
                StockAccountDictionary[alias].UpdateTime       = DateTime.Now;
            }

            //更新期货资金Dictionary
            lock (FutureAccountDictionary)
            {
                FutureAccountDictionary[alias].CashDeposit      = cash_deposit.ToString();
                FutureAccountDictionary[alias].DynamicInterests = dynamic_interests.ToString();
                FutureAccountDictionary[alias].ExpendableFund   = expendableFund.ToString();
                FutureAccountDictionary[alias].FrozenValue      = frozen_cash_deposit.ToString();
                FutureAccountDictionary[alias].OffsetGain       = offset_gain.ToString();
                FutureAccountDictionary[alias].OpsitionGain     = opsition_gain.ToString();
                FutureAccountDictionary[alias].StatisInterests  = static_intrests.ToString();
                FutureAccountDictionary[alias].UpdateTime       = DateTime.Now;
            }

            //返回账户信息
            AccountInfo accinfo = new AccountInfo();

            accinfo.positions      = new List <AccountPosition>();
            accinfo.entrusts       = new List <AccountEntrust>();
            accinfo.riskFrozenInfo = new List <RiskFrozenInfo>();

            accinfo.account = stock_balance.ToString();
            accinfo.alias   = alias;
            accinfo.balance = stock_balance.ToString();
            accinfo.cost    = stock_cost.ToString();
            accinfo.earning = stock_earning.ToString();

            foreach (ERecord item in Erecords)
            {
                accinfo.entrusts.Add(new AccountEntrust()
                {
                    code          = item.Code,
                    dealAmount    = item.DealAmount.ToString(),
                    dealMoney     = item.DealFrezonMoney.ToString(),
                    exchange      = item.ExchangeId,
                    requestAmount = item.Amount.ToString(),
                    requestPrice  = item.OrderPrice.ToString(),
                    direction     = item.Direction.ToString(),
                    orderRef      = item.OrderRef.ToString(),
                    orderSysRef   = item.SysOrderRef.ToString()
                });
            }

            accinfo.faccount    = expendableFund.ToString();
            accinfo.fbond       = cash_deposit.ToString();
            accinfo.fincome     = (opsition_gain + offset_gain).ToString();
            accinfo.frisk       = (future_risk * 100).ToString() + "%";
            accinfo.frozen      = frozen_cash_deposit.ToString();
            accinfo.fstockvalue = future_stock_marketvalue.ToString();
            accinfo.fvalue      = dynamic_interests.ToString();
            accinfo.name        = info.name;

            foreach (CC_TAOLI_TABLE item in CC_Stock_records)
            {
                accinfo.positions.Add(new AccountPosition()
                {
                    amount    = item.CC_AMOUNT.ToString(),
                    code      = item.CC_CODE,
                    direction = item.CC_DIRECTION,
                    name      = item.CC_USER,
                    price     = item.CC_BUY_PRICE.ToString(),
                    type      = item.CC_TYPE
                });
            }

            foreach (CC_TAOLI_TABLE item in CC_Future_records)
            {
                accinfo.positions.Add(new AccountPosition()
                {
                    amount    = item.CC_AMOUNT.ToString(),
                    code      = item.CC_CODE,
                    direction = item.CC_DIRECTION,
                    name      = item.CC_USER,
                    price     = item.CC_BUY_PRICE.ToString(),
                    type      = item.CC_TYPE
                });
            }

            accinfo.risk_exposure  = "0";
            accinfo.riskFrozenInfo = new List <RiskFrozenInfo>();

            foreach (RiskFrozenInfo record in Risk_Frozen_records)
            {
                accinfo.riskFrozenInfo.Add(record);
            }

            accinfo.value = market_value.ToString();

            return(accinfo);
        }
Exemplo n.º 2
0
        private static void WorkThread()
        {
            while (true)
            {
                Thread.Sleep(1000);


                if (DateTime.Now.Second % 2 == 0)
                {
                    //计划每5s刷新资金账户情况
                    List <UserInfo> users = DBAccessLayer.GetUser();

                    if (users == null)
                    {
                        return;
                    }

                    foreach (UserInfo info in users)
                    {
                        List <RISK_TABLE> risks = DBAccessLayer.GetRiskRecord(info.alias);

                        int count = 0;

                        if (risks.Count > 0)
                        {
                            List <TMRiskInfo> riskinfos = new List <TMRiskInfo>();

                            foreach (RISK_TABLE risk in risks)
                            {
                                count++;
                                if (count > 10)
                                {
                                    break;
                                }
                                riskinfos.Add(new TMRiskInfo()
                                {
                                    code = risk.code, hand = risk.amount.ToString(), price = risk.price.ToString(), orientation = risk.orientation, time = risk.time.ToString(), strategy = "00", user = risk.alias, errinfo = risk.err
                                });
                            }


                            TradeMonitor.Instance.updateRiskList(info.alias, JsonConvert.SerializeObject(riskinfos), JsonConvert.SerializeObject(riskmonitor.riskPara));
                        }



                        if (info.userRight == 3)
                        {
                            List <AccountInfo> accounts = new List <AccountInfo>();
                            foreach (KeyValuePair <string, AccountInfo> pair in AccountInfoDictionary)
                            {
                                accounts.Add(pair.Value);
                            }
                            TradeMonitor.Instance.updateAuditInfo(accounts);

                            //审计员没有风控和持仓信息
                            continue;
                        }

                        AccountInfo acc = UpdateAccountList(info);

                        if (AccountInfoDictionary.Keys.Contains(info.alias))
                        {
                            lock (AccountInfoDictionary)
                            {
                                AccountInfoDictionary[info.alias] = acc;
                            }
                        }
                        else
                        {
                            AccountInfoDictionary.Add(info.alias, acc);
                        }



                        if (info.userRight == 2)
                        {
                            //交易员显示个人账户信息
                            AccountCalculate.Instance.updateAccountInfo(info.alias, JsonConvert.SerializeObject(acc), false);

                            //更新用户交易列表视图
                            List <DL_TAOLI_TABLE> Deal_records = DBAccessLayer.GetUserDeals(info.alias);
                            if (Deal_records == null)
                            {
                                Deal_records = new List <DL_TAOLI_TABLE>();
                            }
                            TradeMonitor.Instance.updateTradeList(info.alias, JsonConvert.SerializeObject(Deal_records));

                            //更新持仓列表视图
                            TradeMonitor.Instance.updateOrderList(info.alias, null);
                            TradeMonitor.Instance.updateCCList(info.alias, acc.positions);
                        }
                        else if (info.userRight == 1)
                        {
                            //管理员显示所有用户账户信息
                            AccountCalculate.Instance.updateAccountInfo(info.alias, JsonConvert.SerializeObject(AccountInfoDictionary.Values), true);

                            //更新用户交易列表视图
                            List <DL_TAOLI_TABLE> Deal_records = DBAccessLayer.GetUserDeals(info.alias);
                            if (Deal_records == null)
                            {
                                Deal_records = new List <DL_TAOLI_TABLE>();
                            }
                            TradeMonitor.Instance.updateTradeList(info.alias, JsonConvert.SerializeObject(Deal_records));

                            //更新持仓列表视图
                            TradeMonitor.Instance.updateOrderList(info.alias, null);
                            TradeMonitor.Instance.updateCCList(info.alias, acc.positions);
                        }
                    }
                }
            }
        }
Exemplo n.º 3
0
        /// <summary>
        /// 风控检测
        /// 仅针对股票买入和期货开仓进行判断
        /// 新交易影响持仓参数:
        ///     股票:
        ///         可用资金减少
        ///         股票成本增加
        ///         风控冻结资金量增加
        ///     期货:
        ///         期货冻结资金增加
        ///         可用资金减少
        /// </summary>
        /// <param name="alias">用户名</param>
        /// <param name="orderlist">交易列表</param>
        /// <param name="result">结果</param>
        /// <returns>是否通过风控</returns>
        public static bool RiskDetection(string alias, List <TradeOrderStruct> orderlist, out string result)
        {
            result = string.Empty;
            if (alias == null)
            {
                return(false);
            }
            //第一步: 计算新交易引入后对于股票,期货持仓参数的预见性影响
            alias = alias.Trim();

            //风控错误码
            int errCode = 0;

            //默认策略号
            String StrategyId = "000";

            if (orderlist != null && orderlist.Count > 0)
            {
                StrategyId = orderlist[0].belongStrategy;
            }


            //获取真实实时账户信息
            UserInfo user = DBAccessLayer.GetOneUser(alias);

            if (user == null)
            {
                result = "未查到用户:" + alias;
                RiskInfo info = new RiskInfo()
                {
                    alias       = alias,
                    price       = 0,
                    amount      = 0,
                    err         = result,
                    orientation = "0",
                    code        = "000",
                    strid       = StrategyId
                };
                ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                return(false);
            }

            //刷新内存中的资金信息
            AccountInfo current_account = accountMonitor.UpdateAccountList(user);

            StockAccountTable stock_account = accountMonitor.GetStockAccount(alias);

            if (stock_account == null)
            {
                result = "stockAccountDictionary中不存在用户:" + alias;
                RiskInfo info = new RiskInfo()
                {
                    alias       = alias,
                    price       = 0,
                    amount      = 0,
                    err         = result,
                    orientation = "0",
                    code        = "000",
                    strid       = StrategyId
                };
                ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                return(false);
            }

            FutureAccountTable future_account = accountMonitor.GetFutureAccount(alias);

            if (future_account == null)
            {
                result = "futureAccountDictionary中不存在用户: " + alias;
                RiskInfo info = new RiskInfo()
                {
                    alias       = alias,
                    price       = 0,
                    amount      = 0,
                    err         = result,
                    orientation = "0",
                    code        = "000",
                    strid       = StrategyId
                };
                ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                return(false);
            }

            //计划买入股票交易列表
            var Stock_to_buy_var = (from item
                                    in orderlist
                                    where item.cTradeDirection == TradeOrientationAndFlag.StockTradeDirectionBuy &&
                                    (item.cSecurityType == "S" || item.cSecurityType == "s")
                                    select item);


            List <TradeOrderStruct> Stock_to_buy = new List <TradeOrderStruct>();

            if (Stock_to_buy_var.Count() != 0)
            {
                Stock_to_buy = Stock_to_buy_var.ToList();
            }

            //计划卖出股票交易列表
            var Stock_to_sell_var = (from item
                                     in orderlist
                                     where item.cTradeDirection == TradeOrientationAndFlag.StockTradeDirectionSell &&
                                     (item.cSecurityType == "S" || item.cSecurityType == "s")
                                     select item);

            List <TradeOrderStruct> Stock_to_sell = new List <TradeOrderStruct>();

            if (Stock_to_sell_var.Count() != 0)
            {
                Stock_to_sell = Stock_to_sell_var.ToList();
            }

            //计划开仓期货交易列表
            var Future_to_open_var = (from item
                                      in orderlist
                                      where item.cOffsetFlag == TradeOrientationAndFlag.FutureTradeOffsetOpen &&
                                      (item.cSecurityType == "F" || item.cSecurityType == "f")
                                      select item);

            List <TradeOrderStruct> Future_to_open = new List <TradeOrderStruct>();

            if (Future_to_open_var.Count() != 0)
            {
                Future_to_open = Future_to_open_var.ToList();
            }

            //计划平仓期货交易列表
            var Future_to_close_var = (from item
                                       in orderlist
                                       where item.cOffsetFlag == TradeOrientationAndFlag.FutureTradeOffsetClose &&
                                       (item.cSecurityType == "F" || item.cSecurityType == "f")
                                       select item);

            List <TradeOrderStruct> Future_to_close = new List <TradeOrderStruct>();

            if (Future_to_close_var.Count() != 0)
            {
                Future_to_close = Future_to_close_var.ToList();
            }

            //计算预期购买股票成本
            double stock_etimate_add_cost = 0;

            foreach (TradeOrderStruct order in Stock_to_buy)
            {
                stock_etimate_add_cost += order.dOrderPrice * order.nSecurityAmount;
            }

            //计算预期期货追加保证金
            double future_estimate_add_deposit = 0;

            //计算预期期货对应股票市值变化值
            double future_estimate_market_value = 0;

            foreach (TradeOrderStruct order in Future_to_open)
            {
                future_estimate_add_deposit += (order.nSecurityAmount * order.dOrderPrice * AccountPARA.MarginValue * AccountPARA.Factor(order.cSecurityCode));
                if (order.cTradeDirection == TradeOrientationAndFlag.FutureTradeDirectionBuy)
                {
                    future_estimate_market_value += (order.nSecurityAmount * order.dOrderPrice * AccountPARA.Factor(order.cSecurityCode));
                }
                else if (order.cTradeDirection == TradeOrientationAndFlag.FutureTradeDirectionSell)
                {
                    future_estimate_market_value -= (order.nSecurityAmount * order.dOrderPrice * AccountPARA.Factor(order.cSecurityCode));
                }
            }



            //第二步: 计算修改的资金账户参数是否满足风控指标要求

            //判断卖出/平仓证券是否小于持仓

            #region 黑白名单判断及总股本限制

            //获得白名单
            List <BWNameTable> BWRecords = DBAccessLayer.GetWBNamwList();

            foreach (TradeOrderStruct tos in orderlist)
            {
                BWNameTable BW_record = BWRecords.Find(delegate(BWNameTable item) { return(item.Code.Trim() == tos.cSecurityCode.Trim()); });

                if (BW_record == null)
                {
                    errCode = 4;
                    result  = accountMonitor.GetErrorCode(errCode, tos.cSecurityCode);
                    RiskInfo info = new RiskInfo()
                    {
                        alias       = alias,
                        price       = tos.dOrderPrice,
                        amount      = Convert.ToInt32(tos.nSecurityAmount),
                        err         = result,
                        orientation = tos.cTradeDirection,
                        code        = tos.cSecurityCode.Trim(),
                        strid       = tos.belongStrategy
                    };
                    ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));

                    return(false);
                }

                if (tos.cSecurityType.ToUpper() == "S" && tos.cTradeDirection == TradeOrientationAndFlag.StockTradeDirectionBuy)
                {
                    //判断总股本数量和流通股数量限制
                    double buylimit  = Convert.ToDouble(BW_record.PercentageA) * Convert.ToDouble(BW_record.Amount);
                    double buylimit2 = Convert.ToDouble(BW_record.PercentageB) * Convert.ToDouble(BW_record.Value);

                    int entrust_amount = 0;

                    AccountEntrust entrust_record = current_account.entrusts.Find(
                        delegate(AccountEntrust item)
                    {
                        return(item.code == tos.cSecurityCode);
                    }
                        );

                    if (entrust_record != null)
                    {
                        entrust_amount = Convert.ToInt32(entrust_record.dealAmount);
                    }

                    int position_amount = 0;

                    AccountPosition position_record = current_account.positions.Find(
                        delegate(AccountPosition item)
                    {
                        return(item.code == tos.cSecurityCode);
                    }
                        );

                    if (position_record != null)
                    {
                        position_amount = Convert.ToInt32(position_record.amount);
                    }

                    //总股本限制
                    if (tos.nSecurityAmount + entrust_amount + position_amount > buylimit)
                    {
                        errCode = 5;
                        result  = accountMonitor.GetErrorCode(errCode, tos.cSecurityCode);
                        RiskInfo info = new RiskInfo()
                        {
                            alias       = alias,
                            price       = tos.dOrderPrice,
                            amount      = Convert.ToInt32(tos.nSecurityAmount),
                            err         = result,
                            orientation = tos.cTradeDirection,
                            code        = tos.cSecurityCode.Trim(),
                            strid       = tos.belongStrategy
                        };
                        ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                        return(false);
                    }

                    //流通股限制
                    if (tos.nSecurityAmount + entrust_amount + position_amount > buylimit2)
                    {
                        errCode = 5;
                        result  = accountMonitor.GetErrorCode(errCode, tos.cSecurityCode);
                        RiskInfo info = new RiskInfo()
                        {
                            alias       = alias,
                            price       = tos.dOrderPrice,
                            amount      = Convert.ToInt32(tos.nSecurityAmount),
                            err         = result,
                            orientation = tos.cTradeDirection,
                            code        = tos.cSecurityCode.Trim(),
                            strid       = tos.belongStrategy
                        };
                        ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                        return(false);
                    }
                }
            }

            #endregion

            #region 判断卖出/平仓证券是否小于持仓
            foreach (TradeOrderStruct order in orderlist)
            {
                if (order.cSecurityType == "F" || order.cSecurityType == "f")
                {
                    if (order.cOffsetFlag == TradeOrientationAndFlag.FutureTradeOffsetClose)
                    {
                        int position_amount = 0;

                        //期货平仓交易,需要判断对应开仓数量是否满足
                        if (order.cTradeDirection == TradeOrientationAndFlag.FutureTradeDirectionBuy)
                        {
                            //买入平仓,需要判断卖出开仓数量

                            AccountPosition position_record = current_account.positions.Find(
                                delegate(AccountPosition item)
                            {
                                return(item.direction == TradeOrientationAndFlag.FutureTradeDirectionSell && order.cSecurityCode == item.code);
                            }
                                );

                            if (position_record != null)
                            {
                                position_amount = Convert.ToInt32(position_record.amount);
                            }

                            if (order.nSecurityAmount > position_amount)
                            {
                                //买入平仓数量小于卖出仓位,交易被拒绝。
                                errCode = 12;
                                result  = accountMonitor.GetErrorCode(errCode, order.cSecurityCode + "|" + position_amount + "|" + order.cTradeDirection);
                                RiskInfo info = new RiskInfo()
                                {
                                    alias       = alias,
                                    price       = order.dOrderPrice,
                                    amount      = Convert.ToInt32(order.nSecurityAmount),
                                    err         = result,
                                    orientation = order.cTradeDirection,
                                    code        = order.cSecurityCode.Trim(),
                                    strid       = order.belongStrategy
                                };
                                ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                                return(false);
                            }
                        }
                        else if (order.cTradeDirection == TradeOrientationAndFlag.FutureTradeDirectionSell)
                        {
                            //卖出平仓,需要判断买入开仓的数量

                            AccountPosition position_record = current_account.positions.Find(
                                delegate(AccountPosition item)
                            {
                                return(item.direction == TradeOrientationAndFlag.FutureTradeDirectionBuy && order.cSecurityCode == item.code);
                            }
                                );

                            if (position_record != null)
                            {
                                position_amount = Convert.ToInt32(position_record.amount);
                            }

                            if (order.nSecurityAmount > position_amount)
                            {
                                //卖出平仓数量小于买入仓位,交易被拒绝。
                                errCode = 12;
                                result  = accountMonitor.GetErrorCode(errCode, order.cSecurityCode + "|" + position_amount + "|" + order.cTradeDirection);
                                RiskInfo info = new RiskInfo()
                                {
                                    alias       = alias,
                                    price       = order.dOrderPrice,
                                    amount      = Convert.ToInt32(order.nSecurityAmount),
                                    err         = result,
                                    orientation = order.cTradeDirection,
                                    code        = order.cSecurityCode.Trim(),
                                    strid       = order.belongStrategy
                                };
                                ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                                return(false);
                            }
                        }
                    }
                }
                else if (order.cSecurityType == "S" || order.cSecurityType == "s")
                {
                    if (order.cTradeDirection == TradeOrientationAndFlag.StockTradeDirectionSell)
                    {
                        //股票卖出交易,需要判断当前持仓数量是否满足
                        int entrust_amount = 0;

                        AccountEntrust entrust_record = current_account.entrusts.Find(
                            delegate(AccountEntrust item)
                        {
                            return(item.code == order.cSecurityCode && item.direction == TradeOrientationAndFlag.StockTradeDirectionSell);
                        }
                            );

                        if (entrust_record != null)
                        {
                            entrust_amount = Convert.ToInt32(entrust_record.dealAmount);
                        }

                        int position_amount = 0;

                        AccountPosition position_record = current_account.positions.Find(
                            delegate(AccountPosition item)
                        {
                            return(item.code == order.cSecurityCode);
                        }
                            );

                        if (position_record != null)
                        {
                            position_amount = Convert.ToInt32(position_record.amount);
                        }

                        //判断当前持仓和委托+下单卖出总和比较
                        if (order.nSecurityAmount + entrust_amount > position_amount)
                        {
                            errCode = 11;
                            result  = accountMonitor.GetErrorCode(errCode, order.cSecurityCode + "|" + (entrust_amount + position_amount).ToString());
                            RiskInfo info = new RiskInfo()
                            {
                                alias       = alias,
                                price       = order.dOrderPrice,
                                amount      = Convert.ToInt32(order.nSecurityAmount),
                                err         = result,
                                orientation = order.cTradeDirection,
                                code        = order.cSecurityCode.Trim(),
                                strid       = order.belongStrategy
                            };
                            ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                            return(false);
                        }
                    }
                }
            }
            #endregion

            #region 判断买入股票和期货需要资金是否高于当前可用资金

            //预期股票剩余资金
            double stock_balance = Convert.ToDouble(current_account.account) - stock_etimate_add_cost;

            if (stock_balance <= 0)
            {
                errCode = 1;
                result  = accountMonitor.GetErrorCode(errCode, string.Empty);
                RiskInfo info = new RiskInfo()
                {
                    alias       = alias,
                    price       = 0,
                    amount      = Convert.ToInt32(0),
                    err         = result,
                    orientation = "0",
                    code        = "000",
                    strid       = StrategyId
                };
                ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                return(false);
            }

            //预期期货可用资金
            double future_balance = Convert.ToDouble(current_account.faccount) - future_estimate_add_deposit;

            if (future_balance <= 0)
            {
                errCode = 2;
                result  = accountMonitor.GetErrorCode(errCode, string.Empty);
                RiskInfo info = new RiskInfo()
                {
                    alias       = alias,
                    price       = 0,
                    amount      = Convert.ToInt32(0),
                    err         = result,
                    orientation = "0",
                    code        = "000",
                    strid       = StrategyId
                };
                ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                return(false);
            }

            #endregion

            #region 单一股票占总资产不超过5%

            //总资产
            double totalAccount = Convert.ToDouble(current_account.account) + Convert.ToDouble(current_account.fstockvalue) + Convert.ToDouble(current_account.fvalue);

            foreach (TradeOrderStruct tos in orderlist)
            {
                if (tos.cSecurityType.ToUpper() == "S")
                {
                    if (CheckStockException(tos.cSecurityCode))
                    {
                        continue;
                    }

                    if (tos.cTradeDirection == TradeOrientationAndFlag.StockTradeDirectionBuy)
                    {
                        double entrust_value = 0;

                        AccountEntrust entrust_record = current_account.entrusts.Find(
                            delegate(AccountEntrust item)
                        {
                            return(item.code == tos.cSecurityCode);
                        }
                            );

                        if (entrust_record != null)
                        {
                            entrust_value = Convert.ToDouble(entrust_record.dealMoney) * Convert.ToDouble(entrust_record.dealAmount);
                        }

                        double position_value = 0;

                        AccountPosition position_record = current_account.positions.Find(
                            delegate(AccountPosition item)
                        {
                            return(item.code == tos.cSecurityCode);
                        }
                            );

                        if (position_record != null)
                        {
                            position_value = Convert.ToDouble(position_record.price) * Convert.ToDouble(position_record.amount);
                        }

                        if ((tos.nSecurityAmount * tos.dOrderPrice + entrust_value + position_value) / totalAccount > riskPara.PerStockCostPercentage)
                        {
                            errCode = 6;
                            result  = accountMonitor.GetErrorCode(errCode, tos.cSecurityCode);
                            RiskInfo info = new RiskInfo()
                            {
                                alias       = alias,
                                price       = 0,
                                amount      = Convert.ToInt32(0),
                                err         = result,
                                orientation = "0",
                                code        = "000",
                                strid       = StrategyId
                            };
                            ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                            return(false);
                        }
                    }
                }
            }

            #endregion

            #region 股票所占投资总额不超过80%
            //总市值,totalAccount
            //当前股票成本 , current_account.cost + 委托中的买入股票成本
            double estimate_stock_value = Convert.ToDouble(current_account.value);

            foreach (AccountEntrust record in current_account.entrusts)
            {
                if (record.direction == TradeOrientationAndFlag.StockTradeDirectionBuy)
                {
                    estimate_stock_value += Convert.ToDouble(record.dealMoney) * Convert.ToDouble(record.dealAmount);
                }
            }

            foreach (RiskFrozenInfo record in current_account.riskFrozenInfo)
            {
                if (record.Type.ToUpper() == "S" && record.TradeDirection == TradeOrientationAndFlag.StockTradeDirectionBuy)
                {
                    estimate_stock_value += Convert.ToDouble(record.FrozenCost);
                }
            }

            estimate_stock_value += stock_etimate_add_cost;

            if (estimate_stock_value / totalAccount > riskPara.stockRatio)
            {
                errCode = 13;
                result  = accountMonitor.GetErrorCode(errCode, (estimate_stock_value / totalAccount * 100).ToString());
                RiskInfo info = new RiskInfo()
                {
                    alias       = alias,
                    price       = 0,
                    amount      = Convert.ToInt32(0),
                    err         = result,
                    orientation = "0",
                    code        = "000",
                    strid       = StrategyId
                };
                ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                return(false);
            }
            #endregion

            #region 单日期货交易次数不超过10手

            if (FutureTradeTimes.Keys.Contains(alias))
            {
                if (DateTime.Now.Hour > 16)
                {
                    //下午四点后,默认计数清零
                    FutureTradeTimes[alias] = 0;
                }

                if (DateTime.Now.DayOfWeek == DayOfWeek.Saturday || DateTime.Now.DayOfWeek == DayOfWeek.Sunday)
                {
                    //周末直接清零
                    FutureTradeTimes[alias] = 0;
                }
            }
            else
            {
                FutureTradeTimes.Add(alias, 0);
            }


            int future_trade_hand_count = 0;

            foreach (TradeOrderStruct tos in orderlist)
            {
                if (tos.cSecurityType.ToUpper() == "F" && tos.cOffsetFlag == TradeOrientationAndFlag.FutureTradeOffsetOpen)
                {
                    //只有期货开仓才会计入数量限制,平仓不限
                    future_trade_hand_count += Convert.ToInt32(tos.nSecurityAmount);
                }
            }


            if (FutureTradeTimes[alias] + future_trade_hand_count > 10)
            {
                errCode = 10;
                result  = accountMonitor.GetErrorCode(errCode, string.Empty);
                RiskInfo info = new RiskInfo()
                {
                    alias       = alias,
                    price       = 0,
                    amount      = Convert.ToInt32(0),
                    err         = result,
                    orientation = "0",
                    code        = "000",
                    strid       = StrategyId
                };
                ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                return(false);
            }

            #endregion

            #region 期货风险度和敞口比例

            //期货风险度
            double risk_radio = (Convert.ToDouble(current_account.fbond) + future_estimate_add_deposit) / (Convert.ToDouble(current_account.fvalue));

            if (risk_radio >= riskPara.riskLevel)
            {
                errCode = 8;
                result  = accountMonitor.GetErrorCode(errCode, string.Empty);
                RiskInfo info = new RiskInfo()
                {
                    alias       = alias,
                    price       = 0,
                    amount      = Convert.ToInt32(0),
                    err         = result,
                    orientation = "0",
                    code        = "000",
                    strid       = StrategyId
                };
                ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                return(false);
            }


            #endregion

            #region 监控用户登录判断

            if (!userOper.CheckMonitorUser(CONFIG.GlobalMonitor))
            {
                errCode = 14;
                result  = accountMonitor.GetErrorCode(errCode, string.Empty);
                RiskInfo info = new RiskInfo()
                {
                    alias       = alias,
                    price       = 0,
                    amount      = Convert.ToInt32(0),
                    err         = result,
                    orientation = "0",
                    code        = "000",
                    strid       = StrategyId
                };
                ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                return(false);
            }

            #endregion


            //敞口
            foreach (TradeOrderStruct tos in orderlist)
            {
                //股票卖出和期货平仓交易不计算敞口
                if (tos.cSecurityType.ToUpper() == "S" && tos.cTradeDirection == TradeOrientationAndFlag.StockTradeDirectionSell)
                {
                    continue;
                }
                if (tos.cSecurityType.ToUpper() == "F" && tos.cOffsetFlag == TradeOrientationAndFlag.FutureTradeOffsetClose)
                {
                    continue;
                }

                //股票买入和期货开仓需要通过敞口验证
                double changkouRatio = 0;

                if (!((Convert.ToDouble(current_account.value) + stock_etimate_add_cost) == 0))
                {
                    changkouRatio = (Convert.ToDouble(current_account.fstockvalue) + future_estimate_market_value + Convert.ToDouble(current_account.value) + stock_etimate_add_cost) / (Convert.ToDouble(current_account.value) + stock_etimate_add_cost);
                    if (Math.Abs(changkouRatio) > riskPara.changkouRatio)
                    {
                        errCode = 9;
                        result  = accountMonitor.GetErrorCode(errCode, changkouRatio.ToString());
                        RiskInfo info = new RiskInfo()
                        {
                            alias       = alias,
                            price       = 0,
                            amount      = Convert.ToInt32(0),
                            err         = result,
                            orientation = "0",
                            code        = "000",
                            strid       = StrategyId
                        };
                        ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                        //return false;
                    }
                }
                else
                {
                    errCode = 9;
                    result  = accountMonitor.GetErrorCode(errCode, "无穷大");
                    RiskInfo info = new RiskInfo()
                    {
                        alias       = alias,
                        price       = 0,
                        amount      = Convert.ToInt32(0),
                        err         = result,
                        orientation = "0",
                        code        = "000",
                        strid       = StrategyId
                    };
                    ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(info));
                    //return false;
                }
            }

            //第三部: 实际减少股票资金

            foreach (TradeOrderStruct tos in orderlist)
            {
                if (tos.cSecurityType.ToUpper() == "S")
                {
                    if (tos.cTradeDirection == TradeOrientationAndFlag.StockTradeDirectionBuy)
                    {
                        //股票交易买入需要计入风控列表
                        accountMonitor.UpdateRiskFrozonAccount(user.alias, tos.cSecurityCode, Convert.ToInt32(tos.nSecurityAmount), tos.nSecurityAmount
                                                               * tos.dOrderPrice, "S", tos.cTradeDirection);
                    }
                }
                else if (tos.cSecurityType.ToUpper() == "F")
                {
                    if (tos.cOffsetFlag == TradeOrientationAndFlag.FutureTradeOffsetOpen)
                    {
                        //期货交易开仓需要计入风控列表
                        accountMonitor.UpdateRiskFrozonAccount(user.alias, tos.cSecurityCode, Convert.ToInt32(tos.nSecurityAmount), tos.nSecurityAmount * tos.dOrderPrice, "F", tos.cTradeDirection);
                    }
                }
            }

            errCode = 0;

            result = accountMonitor.GetErrorCode(errCode, string.Empty);

            RiskInfo infoSuccess = new RiskInfo()
            {
                alias       = alias,
                price       = 0,
                amount      = Convert.ToInt32(0),
                err         = result,
                orientation = "0",
                code        = "000",
                strid       = StrategyId
            };
            ThreadPool.QueueUserWorkItem(new WaitCallback(DBAccessLayer.AddRiskRecord), (object)(infoSuccess));

            return(true);
        }