/// <summary>
        ///  根据品种有效申报标识删除有效申报取值和有效申报类型
        /// </summary>
        /// <param name="BreedClassValidID">品种有效申报标识</param>
        /// <param name="tran">事务</param>
        /// <param name="db">db</param>
        /// <param name="flag">状态标识</param>
        /// <returns></returns>
        public bool DeleteValidDeclareValue(int BreedClassValidID, DbTransaction tran, Database db, bool flag)
        {
            XH_ValidDeclareTypeDAL  xHValidDeclareTypeDAL  = new XH_ValidDeclareTypeDAL();
            XH_ValidDeclareValueDAL xHValidDeclareValueDAL = new XH_ValidDeclareValueDAL();
            DbConnection            Conn = null;

            try
            {
                //创建本地事务
                if (db == null && tran == null)
                {
                    db   = DatabaseFactory.CreateDatabase();
                    Conn = db.CreateConnection();
                    if (Conn.State != ConnectionState.Open)
                    {
                        Conn.Open();
                    }
                    tran = Conn.BeginTransaction();
                }

                xHValidDeclareValueDAL.DeleteVDeclareValue(BreedClassValidID, tran, db);
                xHValidDeclareTypeDAL.DeleteValidDeclareType(BreedClassValidID, tran, db);
                if (!flag)
                {
                    tran.Commit();
                }
                return(true);
            }
            catch (Exception ex)
            {
                if (!flag)
                {
                    tran.Rollback();
                }
                string      errCode   = "GL-5261";
                string      errMsg    = "根据品种有效申报标识删除有效申报取值和有效申报类型失败!";
                VTException exception = new VTException(errCode, errMsg, ex);
                LogHelper.WriteError(exception.ToString(), exception.InnerException);

                return(false);
            }
            finally
            {
                if (Conn != null && Conn.State == ConnectionState.Open)
                {
                    if (!flag)
                    {
                        Conn.Close();
                    }
                }
            }
        }
        /// <summary>
        ///根据品种标识,品种涨跌幅标识,品种有效申报标识,删除现货品种交易规则(规则相关表全部删除)
        /// </summary>
        /// <param name="BreedClassID">品种标识</param>
        ///// <param name="BreedClassHighLowID">品种涨跌幅标识</param>
        ///// <param name="BreedClassValidID">品种有效申报标识</param>
        /// <returns></returns>
        public bool DeleteSpotTradeRulesAboutAll(int BreedClassID)
        {
            XH_SpotTradeRulesDAL    xHSpotTradeRulesDAL    = new XH_SpotTradeRulesDAL();
            XH_SpotPositionDAL      xHSpotPositionDAL      = new XH_SpotPositionDAL();
            XH_SpotHighLowValueDAL  xHSpotHighLowValueDAL  = new XH_SpotHighLowValueDAL();
            XH_ValidDeclareValueDAL xHValidDeclareValueDAL = new XH_ValidDeclareValueDAL();
            //XH_MinChangePriceValueDAL xHMinChangePriceValueDAL = new XH_MinChangePriceValueDAL();
            CM_FieldRangeDAL          cMFieldRangeDAL          = new CM_FieldRangeDAL();
            XH_ValidDeclareTypeDAL    xHValidDeclareTypeDAL    = new XH_ValidDeclareTypeDAL();
            XH_MinVolumeOfBusinessDAL xHMinVolumeOfBusinessDAL = new XH_MinVolumeOfBusinessDAL();

            XH_SpotHighLowControlTypeDAL xHSpotHighLowControlTypeDAL = new XH_SpotHighLowControlTypeDAL();
            CM_UnitConversionDAL         cM_UnitConversionDAL        = new CM_UnitConversionDAL();


            DbConnection Conn = null;
            Database     db   = DatabaseFactory.CreateDatabase();

            Conn = db.CreateConnection();
            if (Conn.State != ConnectionState.Open)
            {
                Conn.Open();
            }
            DbTransaction Tran = Conn.BeginTransaction();

            try
            {
                int BreedClassHighLowID            = AppGlobalVariable.INIT_INT;
                int BreedClassValidID              = AppGlobalVariable.INIT_INT;
                XH_SpotTradeRules xHSpotTradeRules = new XH_SpotTradeRules();
                xHSpotTradeRules = xHSpotTradeRulesDAL.GetModel(BreedClassID);
                if (xHSpotTradeRules != null)
                {
                    if (!string.IsNullOrEmpty(xHSpotTradeRules.BreedClassHighLowID.ToString()))
                    {
                        BreedClassHighLowID = Convert.ToInt32(xHSpotTradeRules.BreedClassHighLowID);
                    }
                    if (!string.IsNullOrEmpty(xHSpotTradeRules.BreedClassValidID.ToString()))
                    {
                        BreedClassValidID = Convert.ToInt32(xHSpotTradeRules.BreedClassValidID);
                    }
                    if (BreedClassHighLowID != AppGlobalVariable.INIT_INT)
                    {
                        if (!xHSpotHighLowValueDAL.DeleteSpotHighLowValue(BreedClassHighLowID, Tran, db))
                        {
                            Tran.Rollback();
                            return(false);
                        }
                    }
                    if (BreedClassValidID != AppGlobalVariable.INIT_INT)
                    {
                        if (!xHValidDeclareValueDAL.DeleteVDeclareValue(BreedClassValidID, Tran, db))
                        {
                            Tran.Rollback();
                            return(false);
                        }
                    }
                    //if (!xHMinChangePriceValueDAL.Delete(BreedClassID, Tran, db))
                    //{
                    //    Tran.Rollback();
                    //    return false;
                    //}

                    //List<Model.XH_MinChangePriceValue> xhMinCHangePriceV =
                    //    xHMinChangePriceValueDAL.GetListArray(string.Format("BreedClassID={0}", BreedClassID), Tran, db);
                    //foreach (Model.XH_MinChangePriceValue FieldRangeID in xhMinCHangePriceV)
                    //{
                    //    if (!cMFieldRangeDAL.Delete(FieldRangeID.FieldRangeID))
                    //    {
                    //        Tran.Rollback();
                    //        return false;
                    //    }
                    //}
                    if (!xHMinVolumeOfBusinessDAL.DeleteXHMinVolumeOfBusByBreedClassID(BreedClassID, Tran, db))
                    {
                        Tran.Rollback();
                        return(false);
                    }
                    //添加删除现货单位换算
                    List <Model.CM_UnitConversion> cMUnitC =
                        cM_UnitConversionDAL.GetListArray(string.Format("BreedClassID={0}", BreedClassID));
                    foreach (Model.CM_UnitConversion unitConversion in cMUnitC)
                    {
                        if (!cM_UnitConversionDAL.DeleteUnitConversionByBreedClassID(Convert.ToInt32(unitConversion.BreedClassID), Tran, db))
                        {
                            Tran.Rollback();
                            return(false);
                        }
                    }

                    if (!xHSpotTradeRulesDAL.Delete(BreedClassID, Tran, db))
                    {
                        Tran.Rollback();
                        return(false);
                    }
                    if (!xHValidDeclareTypeDAL.DeleteValidDeclareType(BreedClassValidID, Tran, db))
                    {
                        Tran.Rollback();
                        return(false);
                    }
                    if (!xHSpotHighLowControlTypeDAL.Delete(BreedClassHighLowID, Tran, db))
                    {
                        Tran.Rollback();
                        return(false);
                    }
                }
                Tran.Commit();
                return(true);
            }
            catch (Exception ex)
            {
                Tran.Rollback();
                string      errCode   = "GL-5202";
                string      errMsg    = "根据品种标识,品种涨跌幅标识,品种有效申报标识,删除现货品种交易规则(规则相关表全部删除)失败!";
                VTException exception = new VTException(errCode, errMsg, ex);
                LogHelper.WriteError(exception.ToString(), exception.InnerException);

                return(false);
            }
            finally
            {
                if (Conn.State == ConnectionState.Open)
                {
                    Conn.Close();
                }
            }
        }