DaUserRole.auto.cs | searchcode

/EQT_V1/EQT.DAL/DaUserRole.auto.cs

http://sgsoft-las.googlecode.com/ · C# · 989 lines · 786 code · 86 blank · 117 comment · 22 complexity · 1ee7771efa4edec2ebbf5a8643b45dcc MD5 · raw file

#region DaUserRole

/*----------------------------------------------------------------

// ????DaUserRole.cs

// ??????UserRole??????

//

// 

// ?????2009-02-27

//

// ????? 

// ????? 

//----------------------------------------------------------------*/

using System;

using System.Collections;

using System.Collections.Generic;

using System.Data;

using System.Globalization;

using System.Text;

using System.Xml;

using System.Data.Common;

using Microsoft.Practices.EnterpriseLibrary.Data;

using Microsoft.Practices.EnterpriseLibrary.Data.Sql;

//using Microsoft.Practices.EnterpriseLibrary.Logging;

using EQT.Model; 

//using IDataLayer;



namespace EQT.Dal

{

    public	partial  class DaUserRole   //?????????,IUserRole 

    {   

	

		//???????????????????

		//???????????????SQL Server??????????????????ID??????entiry?

		//??????????????????

		#region SQL const

		private const  string SQL_INSERT="INSERT INTO User_Role (UID ,Role_ID ) VALUES "

			+"(@Uid,@Role_Id)";

		private const string SQL_UPDATE="UPDATE User_Role SET WHERE UID=@UID AND  Role_ID=@Role_ID";

		private const string SQL_DELETE="DELETE FROM User_Role WHERE UID=@UID AND  Role_ID=@Role_ID";

		private const string SQL_SELECT="SELECT UID ,Role_ID  from User_Role  ";

		private const string SQL_SELECT_ONE="SELECT UID ,Role_ID  from User_Role  WHERE UID=@UID AND  Role_ID=@Role_ID";                              

		#endregion

		

        private Database db;

		

		#region Constructor

	 

		/// <summary>

        /// ???????????????????????

        /// </summary>

		public DaUserRole ()

		{ 

			db=DatabaseFactory.CreateDatabase();

		}

		/// <summary>

        /// ?????databaseName??????

        /// </summary>

        /// <param name="databaseName">??????????????</param>

		public DaUserRole (string databaseName)

		{ 

            this.db = DatabaseFactory.CreateDatabase(databaseName);

		} 

		

		public DaUserRole (Database db)

		{ 

            this.db = db;

		} 

		

		#endregion

		

		//???CRUD??????????????????



	    #region Add

		

		///build the command object.It never throw exception.

		private DbCommand ConstructAddCommand()

		{

			DbCommand dbCommand = db.GetSqlStringCommand(SQL_INSERT);

			 

			//????:Uid	

			db.AddInParameter(dbCommand,"Uid",DbType.AnsiString);

			//????:Role_Id	

			db.AddInParameter(dbCommand,"Role_Id",DbType.AnsiString);

			return dbCommand;

		}		

		private DbCommand ConstructAddCommand(MoUserRole entity)

		{

			DbCommand dbCommand=db.GetSqlStringCommand(SQL_INSERT);

			 

			//????:Uid	

			db.AddInParameter(dbCommand,"Uid",DbType.AnsiString,entity.Uid);

			//????:Role_Id	

			db.AddInParameter(dbCommand,"Role_Id",DbType.AnsiString,entity.Role_Id);

			 

			return dbCommand;

		}

	

	    /// <summary>

		///????????????????commit

		/// </summary>

	    public int Add(MoUserRole entity,DbTransaction trans)

	    {	try

            {

				DbCommand dbCommand=ConstructAddCommand(entity);			

				return db.ExecuteNonQuery(dbCommand,trans);

			}

			catch(DbException ex)

			{				

				HandleDbException(ex,entity);				

			}

			return 0;

			

	    }		

	    public int Add(MoUserRole entity) 

        {	

			try

            {

				DbCommand dbCommand=ConstructAddCommand(entity);			

				return db.ExecuteNonQuery(dbCommand);

			}

			catch(DbException ex)

			{				

				HandleDbException(ex,entity);		

			}

			return 0;

	    }

		

		public int Add(List<MoUserRole> entity,DbTransaction trans)

		{

			int rc=0;		

            DbCommand dbCommand=ConstructAddCommand();

			int j=0;

			try

			{

			   for(j=0;j<entity.Count;j++)

			   {	

				//????:Uid	

				db.SetParameterValue(dbCommand,"Uid",entity[j].Uid);

				//????:Role_Id	

				db.SetParameterValue(dbCommand,"Role_Id",entity[j].Role_Id);

				rc+=db.ExecuteNonQuery(dbCommand,trans);

			   }

			}

			catch(DbException ex)

			{

				HandleDbException(ex,entity[j]);				

			}			 

            return rc;

		}		

		public int Add(List<MoUserRole> entity)

		{

			int rc = 0;			

			using (DbConnection cnn = db.CreateConnection())

            {    

				DbTransaction trans=null;

				try

				{

					cnn.Open();

					using(trans = cnn.BeginTransaction())

					{

						rc=Add(entity,trans);//This function throw customer exception.

						trans.Commit();

					}

					cnn.Close();

				}

				catch(DbException ex)

				{

					if(trans!=null)trans.Rollback();		

					HandleDbException(ex);	

				}

				///TODO:catch customer exception.

				//catch

				//{

				//	

				//}

			}

			return rc;

		}

		

        public int Add(DataTable dt, DbTransaction trans)

		{

			int rc=0;		 

            DbCommand dbCommand =ConstructAddCommand();	

			int j=0;

			try

			{

			   for(j=0;j<dt.Rows.Count;j++)

			   {	

					//????:Uid	

					db.SetParameterValue(dbCommand,"Uid",dt.Rows[j]["Uid"]);

					//????:Role_Id	

					db.SetParameterValue(dbCommand,"Role_Id",dt.Rows[j]["Role_Id"]);

					rc+=db.ExecuteNonQuery(dbCommand,trans);

			   }

			}

			catch(DbException ex)

			{				

				HandleDbException(ex,dt.Rows[j]);				

			}	

			 

            return rc;

		}		

		public int Add(DataTable dt)

        {

			int rc=0;

            using (DbConnection cnn = db.CreateConnection())

            { 

				DbTransaction trans=null;

				try

                {

					cnn.Open();

					using(trans = cnn.BeginTransaction())

					{

						rc = Add(dt, trans);

						trans.Commit();

						cnn.Close();

					}

				}

				catch(DbException ex)

				{	

					if(trans!=null)trans.Rollback();

					HandleDbException(ex);	

				}	

				///TODO:catch customer exception.

				//catch

				//{

				//	

				//}

            }

            return rc;

        }

		#endregion

		

		#region Update

		private DbCommand ConstructUpdateCommand()

		{

			DbCommand dbCommand=db.GetSqlStringCommand(SQL_UPDATE);

		    

		 

			db.AddInParameter(dbCommand,"Uid",DbType.AnsiString);

			db.AddInParameter(dbCommand,"Role_Id",DbType.AnsiString);

			 

			return dbCommand;

		}

		private DbCommand ConstructUpdateCommand(MoUserRole entity)

		{

			DbCommand dbCommand=db.GetSqlStringCommand(SQL_UPDATE);

		    

		 

			db.AddInParameter(dbCommand,"Uid",DbType.AnsiString,entity.Uid);

			db.AddInParameter(dbCommand,"Role_Id",DbType.AnsiString,entity.Role_Id);

			 

			return dbCommand;

		}

		/// <summary>

		/// ???????????:??????????

		/// </summary>	

	    public int Update(MoUserRole entity,DbTransaction trans)

	    {	    			

		    try

            {			

				DbCommand dbCommand=ConstructUpdateCommand(entity);

				return db.ExecuteNonQuery(dbCommand,trans);

			}

			catch(DbException ex)

			{				

				HandleDbException(ex,entity);		

			}

			return 0;

		}		

		public int Update(MoUserRole entity)

		{

			try

            {			

				DbCommand dbCommand=ConstructUpdateCommand(entity);

				return db.ExecuteNonQuery(dbCommand);

			}

			catch(DbException ex)

			{				

				HandleDbException(ex,entity);		

			}

			return 0;			

		}		

		public int Update(List<MoUserRole> entity,DbTransaction trans)

		{

			int rc=0;			 

            DbCommand dbCommand=ConstructUpdateCommand();

			int j=0;

			try

			{

			    for(j=0;j<entity.Count;j++)

				{	

					db.SetParameterValue(dbCommand,"Uid",entity[j].Uid);

					db.SetParameterValue(dbCommand,"Role_Id",entity[j].Role_Id);

					rc+=db.ExecuteNonQuery(dbCommand,trans);

				}

			}

			catch(DbException ex)

			{				

				HandleDbException(ex,entity[j]);		

			}			 

			return rc;			

		}		

		public int Update(List<MoUserRole> entity)

		{

			int rc = 0;	

			using (DbConnection cnn = db.CreateConnection())

            {   

				DbTransaction trans=null;

				try

				{          

					cnn.Open();

					using(trans = cnn.BeginTransaction())

					{

					rc=Update(entity,trans);

					trans.Commit();		

					}

					cnn.Close();

				}

				catch(DbException ex)

				{

					if(trans!=null)trans.Rollback();	

					HandleDbException(ex);	

				}				

			}

			return rc;

		}		

		public int Update(DataTable dt, DbTransaction trans)

		{

			int rc=0;			 

            DbCommand dbCommand=ConstructUpdateCommand();		

			int j=0;

		    try

		    {

			    for(j=0;j<dt.Rows.Count;j++)

				{	

					db.SetParameterValue(dbCommand,"Uid",dt.Rows[j]["Uid"]);

					db.SetParameterValue(dbCommand,"Role_Id",dt.Rows[j]["Role_Id"]);

					rc+=db.ExecuteNonQuery(dbCommand,trans);

				}

			}

			catch(DbException ex)

			{				

				HandleDbException(ex,dt.Rows[j]);		

			}		

            return rc;

			

		}		

		public int Update(DataTable dt)

        {

			if(dt==null ||dt.Rows.Count==0) return 0;

            int rc=0;       

            using (DbConnection cnn = db.CreateConnection())

            {

				DbTransaction trans=null;

				try

                {

					cnn.Open();

					using(trans = cnn.BeginTransaction())

					{

						rc = Add(dt, trans);

						trans.Commit();						

					}   

					cnn.Close();                  

                }

                catch(DbException ex)

				{

					if(trans!=null)trans.Rollback();	

					HandleDbException(ex);	

				}		

                

            }

            return rc;

        }

		#endregion

		

		#region Update By DataSet

		private void PrepareDataAdapterCommand(out DbCommand dbInsertCommand,

		                     out DbCommand dbUpdateCommand,out DbCommand dbDeleteCommand)

		{

			dbInsertCommand = db.GetSqlStringCommand(SQL_INSERT);

			#region set insert cmd parameters

			db.AddInParameter(dbInsertCommand, "Uid",DbType.AnsiString, "Uid", DataRowVersion.Current);

			db.AddInParameter(dbInsertCommand, "Role_Id",DbType.AnsiString, "Role_Id", DataRowVersion.Current);

			#endregion

			dbUpdateCommand = db.GetSqlStringCommand(SQL_UPDATE);

			#region Set update cmd value parameters

			#endregion

			#region set update cmd pk where parameters

			db.AddInParameter(dbUpdateCommand, "Uid", DbType.AnsiString, "Uid", DataRowVersion.Current);

			db.AddInParameter(dbUpdateCommand, "Role_Id", DbType.AnsiString, "Role_Id", DataRowVersion.Current);

			#endregion			

			dbDeleteCommand = db.GetSqlStringCommand(SQL_DELETE);

			#region set delete cmd pk where parameters

			db.AddInParameter(dbDeleteCommand, "Uid", DbType.AnsiString, "Uid", DataRowVersion.Current);

			db.AddInParameter(dbDeleteCommand, "Role_Id", DbType.AnsiString, "Role_Id", DataRowVersion.Current);

			#endregion

		}

		

		

		

		/// <summary>

		/// ??DataSet??????????

		/// </summary>

		public int UpdateByDataSet(DataSet dst, string strTableName, DbTransaction trans)

		{

			DbCommand dbInsertCommand = null;			

			DbCommand dbUpdateCommand = null;

			DbCommand dbDeleteCommand = null;

			PrepareDataAdapterCommand(out dbInsertCommand,out dbUpdateCommand,out dbDeleteCommand);

			try

            {

			    return db.UpdateDataSet(dst, strTableName, dbInsertCommand, dbUpdateCommand, dbDeleteCommand, trans);

			}

			catch(DbException ex)

			{			

				trans.Rollback();

				HandleDbException(ex);				

			}

			return 0;//TODO:Should return Application Specific Error Code.

		}

		

		/// <summary>

		/// ??DataSet???????????

		/// </summary>

		public int UpdateByDataSet(DataSet dst, string strTableName)

		{

			DbCommand dbInsertCommand = null;			

			DbCommand dbUpdateCommand = null;

			DbCommand dbDeleteCommand = null;

			PrepareDataAdapterCommand(out dbInsertCommand,out dbUpdateCommand,out dbDeleteCommand);

			try

            {

			    return db.UpdateDataSet(dst, strTableName, dbInsertCommand, dbUpdateCommand, dbDeleteCommand, UpdateBehavior.Transactional);			

			}

			catch(DbException ex)

			{	

				HandleDbException(ex);				

			}

			return 0;//TODO:Should return Application Specific Error Code.			

		}

		

		

		

		#endregion 

		

		#region Delete

		

		private DbCommand ConstructDeleteCommand()

		{

			DbCommand dbCommand=db.GetSqlStringCommand(SQL_DELETE);

			 

			db.AddInParameter(dbCommand,"Uid",DbType.AnsiString);

			db.AddInParameter(dbCommand,"Role_Id",DbType.AnsiString);

			 

			return dbCommand;

		}		

		private DbCommand ConstructDeleteCommand(MoUserRole entity)

		{

			DbCommand dbCommand=db.GetSqlStringCommand(SQL_DELETE);

			 

			db.AddInParameter(dbCommand,"Uid",DbType.AnsiString,entity.Uid);

			db.AddInParameter(dbCommand,"Role_Id",DbType.AnsiString,entity.Role_Id);

		 

			return dbCommand;

		}

		

		/// <summary>

		/// delete by pk(entity)

		/// </summary>	

		public int Delete(MoUserRole entity,DbTransaction trans)

		{	try

            {

				DbCommand dbCommand=ConstructDeleteCommand(entity);			

				return db.ExecuteNonQuery(dbCommand,trans);

			}

			catch(DbException ex)

			{			

				trans.Rollback();

				HandleDbException(ex,entity);				

			}

			return 0;

		}	

		public int Delete(MoUserRole entity)

		{

			try

            {

				DbCommand dbCommand=ConstructDeleteCommand(entity);			

				return db.ExecuteNonQuery(dbCommand);

			}

			catch(DbException ex)

			{				

				HandleDbException(ex,entity);				

			}

			return 0;

		}		

		/// <summary>

		/// mul-delete

		/// </summary>	

		public int Delete(List<MoUserRole> entities,DbTransaction trans)

		{

			int rc=0;	

			int j=0;

			DbCommand dbCommand=ConstructDeleteCommand();		

			try

			{

			    for(j=0;j<entities.Count;j++)

				{	

					db.SetParameterValue(dbCommand,"Uid",entities[j].Uid);

					db.SetParameterValue(dbCommand,"Role_Id",entities[j].Role_Id);

					rc+=db.ExecuteNonQuery(dbCommand,trans);

				}

			}

			catch(DbException ex)

			{	

				if(trans!=null)trans.Rollback();

				HandleDbException(ex,entities[j]);				

			}			 

			return rc;			

		}		

		public int Delete(List<MoUserRole> entities)

		{

			int rc = 0;			

			using (DbConnection cnn = db.CreateConnection())

            {      

				DbTransaction trans=null;

				try

				{

					cnn.Open();

					using(trans = cnn.BeginTransaction())

					{

						rc=Delete(entities,trans);

						trans.Commit();

					}               

					cnn.Close();

				}

				catch(DbException ex)

				{	

					if(trans!=null)trans.Rollback();

					HandleDbException(ex);				

				}	

			}

			return rc;

		}

		

		

		public int Delete(DataTable dt,DbTransaction trans)

		{

			int rc=0;			

			int j=0;

			DbCommand dbCommand=ConstructDeleteCommand();		

			try

			{

			    for(j=0;j<dt.Rows.Count;j++)

				{	

					db.SetParameterValue(dbCommand,"Uid",dt.Rows[j]["Uid"]);

					db.SetParameterValue(dbCommand,"Role_Id",dt.Rows[j]["Role_Id"]);

					rc+=db.ExecuteNonQuery(dbCommand,trans);

				}

			}

			catch(DbException ex)

			{	

				if(trans!=null)trans.Rollback();

				HandleDbException(ex,dt.Rows[j]);				

			}			 

			return rc;			

		 	

		}		

		public int Delete(DataTable dt)

		{

			int rc=0;

		    using (DbConnection cnn = db.CreateConnection())

            {

				DbTransaction trans=null;

				try

				{

					cnn.Open();				

					using(trans = cnn.BeginTransaction())

					{

						rc = Delete(dt, trans);

						trans.Commit();

					}

					cnn.Close();

                }

                catch(DbException ex)

				{	

					if(trans!=null)trans.Rollback();

					HandleDbException(ex);				

				}

                

            }

            return rc;

		}		

		/// <summary>

		/// ??????????

		/// </summary>	

		public int Delete(string Uid,string Role_Id,DbTransaction trans)

		{			 

			try

			{

				DbCommand dbCommand=db.GetSqlStringCommand(SQL_DELETE);

				 

				db.AddInParameter(dbCommand,"Uid",DbType.AnsiString,Uid);

				db.AddInParameter(dbCommand,"Role_Id",DbType.AnsiString,Role_Id);

				 

				return db.ExecuteNonQuery(dbCommand,trans);

			}

			catch(DbException ex)

			{	

				if(trans!=null)trans.Rollback();

				HandleDbException(ex);				

			}	

			return 0;

		}	

		

		public int Delete(string Uid,string Role_Id)

		{

			try

			{

				DbCommand dbCommand=db.GetSqlStringCommand(SQL_DELETE);

				 

				db.AddInParameter(dbCommand,"Uid",DbType.AnsiString,Uid);

				db.AddInParameter(dbCommand,"Role_Id",DbType.AnsiString,Role_Id);

				 

				return db.ExecuteNonQuery(dbCommand);

			}

			catch(DbException ex)

			{			 

				HandleDbException(ex);				

			}	

			return -1;

		}

		#endregion

		

		#region Query All by condition

		/// <summary>

		/// ????WHERE????????,?condition????????

		/// </summary>		

		public DataSet Query(string condition)

		{			

			try

			{

				return db.ExecuteDataSet(CommandType.Text,String.IsNullOrEmpty(condition)?SQL_SELECT:SQL_SELECT+condition);	 

			}

			catch(DbException ex)

			{			 

				HandleDbException(ex);				

			}	

            return new DataSet();

		}		

	    public DataSet Query(string condition, DbTransaction trans)

        {   

            try

            {

                return db.ExecuteDataSet(trans, CommandType.Text, String.IsNullOrEmpty(condition) ? SQL_SELECT : SQL_SELECT + condition);

            }

            catch(DbException ex)

			{			 

				HandleDbException(ex);				

			}	

            return new DataSet();

        }

		#endregion

		

		#region GetEntity(s)

		/// <summary>

		///????????????

		/// </summary>

	    public MoUserRole GetEntity(string mUid ,string mRole_Id )

		{			 

			MoUserRole entity = new MoUserRole();

			entity.Uid=mUid;

			entity.Role_Id=mRole_Id;

			if(GetEntityEx(entity))

			{

				return entity;

			}

			else

			{

				return null;

			}

		}

		

		public MoUserRole GetEntity(string mUid ,string mRole_Id ,DbTransaction trans)

		{			 

			MoUserRole entity = new MoUserRole();

			entity.Uid=mUid;

			entity.Role_Id=mRole_Id;

			if(GetEntityEx(entity,trans))

			{

				return entity;

			}

			else

			{

				return null;

			}

		}

		

		private DbCommand ConstructSelectOneCommand(Database db,MoUserRole entity)

		{

			DbCommand dbCommand=db.GetSqlStringCommand(SQL_SELECT_ONE);

			 

			db.AddInParameter(dbCommand,"Uid",DbType.AnsiString,entity.Uid);

			db.AddInParameter(dbCommand,"Role_Id",DbType.AnsiString,entity.Role_Id);

			return dbCommand;

		}

		private DbCommand ConstructSelectOneCommand(Database db)

		{

			DbCommand dbCommand=db.GetSqlStringCommand(SQL_SELECT_ONE);

			 

			db.AddInParameter(dbCommand,"Uid",DbType.AnsiString);

			db.AddInParameter(dbCommand,"Role_Id",DbType.AnsiString);

			return dbCommand;

		}

		private void PopulateEntityByDataReader(IDataReader reader,ref MoUserRole entity)

		{

			if (!reader.IsDBNull(0)) entity.Uid = reader.GetString(0);

			if (!reader.IsDBNull(1)) entity.Role_Id = reader.GetString(1);

		}

		

		/// <summary>

		///????????????????????????????????.

		///??????????????????????ref????

		/// </summary>

		public bool GetEntityEx(MoUserRole entity)

		{

			DbCommand dbCommand=ConstructSelectOneCommand(db,entity);

			try

			{

				using(IDataReader reader=db.ExecuteReader(dbCommand))

				{   

					if(reader.Read()) 

					{

						PopulateEntityByDataReader(reader,ref entity);

						return true;

					}

				}

			}

			catch(DbException ex)

			{	 

				HandleDbException(ex,entity);				

			}	

			return false;

		}

		public bool GetEntityEx(MoUserRole entity,DbTransaction trans)

		{		

			DbCommand dbCommand=ConstructSelectOneCommand(db,entity);

			try

			{

				using(IDataReader reader=db.ExecuteReader(dbCommand,trans))

				{   

					if(reader.Read())

					{

						PopulateEntityByDataReader(reader,ref entity);	

						return true;

					}

				}

			} 

			catch(DbException ex)

			{			 

				trans.Rollback();

				HandleDbException(ex,entity);				

			}	

			return false;

			

		}

		

		public List<MoUserRole> GetEntities(string condition,DbTransaction trans)

		{

			List<MoUserRole> list=new List<MoUserRole>();			

			try

			{				

			    using(IDataReader reader= db.ExecuteReader(trans,CommandType.Text, String.IsNullOrEmpty(condition) ? SQL_SELECT : SQL_SELECT+ condition))

			    {

				    while(reader.Read())

					{			

						MoUserRole entity=new MoUserRole();

						PopulateEntityByDataReader(reader,ref entity);	

						list.Add(entity);

					}

			    }

			}

			catch(DbException ex)

			{			 

				trans.Rollback();

				HandleDbException(ex);				

			}	

			return list;

			

		}

		

		

		public List<MoUserRole> GetEntities(string condition)

		{

			List<MoUserRole> list=new List<MoUserRole>();	

			try

			{

				using(IDataReader reader= db.ExecuteReader(CommandType.Text, String.IsNullOrEmpty(condition) ? SQL_SELECT : SQL_SELECT+" " + condition))

				{   

					while(reader.Read())

					{	

						MoUserRole entity=new MoUserRole();

						PopulateEntityByDataReader(reader,ref entity);	

						list.Add(entity);

					}

				}

			}

			catch(DbException ex)

			{	 

				HandleDbException(ex);				

			}	

			return list;

		}

		#endregion

		

		#region Count

		/// <summary>

		/// ????????

		/// </summary>

		public int GetCount()

		{

			return Convert.ToInt32(db.ExecuteScalar(CommandType.Text,

			"SELECT COUNT(*) FROM User_Role "));

		}

		

		public int GetCount(DbTransaction trans)

		{

			try

			{

			    return Convert.ToInt32(db.ExecuteScalar(trans,CommandType.Text,

			    "SELECT COUNT(*) FROM User_Role "));

		    }

		    catch(DbException ex)

			{	 

				HandleDbException(ex);				

			}	

			return -1;

		}

		

		/// <summary>

		/// ????WHERE?????

		/// </summary>

		public int GetCount(string condition)

		{

			return Convert.ToInt32(db.ExecuteScalar(CommandType.Text,String.IsNullOrEmpty(condition)?

			"SELECT COUNT(*) FROM User_Role ":"SELECT COUNT(*) FROM User_Role "+condition ));

		}

		

		public int GetCount(string condition,DbTransaction trans)

		{

			try

			{

			   return Convert.ToInt32(db.ExecuteScalar(trans,CommandType.Text,String.IsNullOrEmpty(condition)?

			   "SELECT COUNT(*) FROM User_Role ":"SELECT COUNT(*) FROM User_Role "+condition ));

		    }

			catch(DbException ex)

			{	 

				HandleDbException(ex);				

			}	

			return -1;

		}

		#endregion

		

		#region Check isExist

		/// <summary>

		/// ????????????

		/// </summary>

        public bool IsExist(string mUid ,string mRole_Id )

		{

			string sql="SELECT COUNT(*) FROM User_Role  WHERE UID=@Uid and  Role_ID=@Role_Id  ";

			

			DbCommand dbCommand=db.GetSqlStringCommand(sql);

			db.AddInParameter(dbCommand,"Uid",DbType.AnsiString,mUid);

			db.AddInParameter(dbCommand,"Role_Id",DbType.AnsiString,mRole_Id);

			return Convert.ToInt32(db.ExecuteScalar(dbCommand))>0;

		}

		

		public bool IsExist(string mUid ,string mRole_Id ,DbTransaction trans)

		{			 

			string sql="select count(*) from User_Role  where UID=@Uid and  Role_ID=@Role_Id  ";

			

			DbCommand dbCommand=db.GetSqlStringCommand(sql);

			db.AddInParameter(dbCommand,"Uid",DbType.AnsiString,mUid);

			db.AddInParameter(dbCommand,"Role_Id",DbType.AnsiString,mRole_Id);

			try

			{

			   return Convert.ToInt32(db.ExecuteScalar(dbCommand,trans))>0;

			}

			catch

			{

			    trans.Rollback();

				throw;

			}		 

		}

		

		public bool IsExist(MoUserRole entity,DbTransaction trans)

		{			

			string sql="select count(*) from User_Role  where UID=@Uid and  Role_ID=@Role_Id  ";

			

			DbCommand dbCommand=db.GetSqlStringCommand(sql);

			#region set pk where parameters

			db.AddInParameter(dbCommand,"Uid",DbType.AnsiString,entity.Uid);

			db.AddInParameter(dbCommand,"Role_Id",DbType.AnsiString,entity.Role_Id);

			#endregion

			try

			{

			   return Convert.ToInt32(db.ExecuteScalar(dbCommand,trans))>0;

			}

			catch

			{

			    trans.Rollback();

				throw;

			}		 

		}

		

		public bool IsExist(MoUserRole entity)

		{

			string sql="select count(*) from User_Role  where UID=@Uid and  Role_ID=@Role_Id  ";

			

			DbCommand dbCommand=db.GetSqlStringCommand(sql);

			#region set pk where parameters

			db.AddInParameter(dbCommand,"Uid",DbType.AnsiString,entity.Uid);

			db.AddInParameter(dbCommand,"Role_Id",DbType.AnsiString,entity.Role_Id);

			#endregion

			 

			return Convert.ToInt32(db.ExecuteScalar(dbCommand))>0;

			 	 

		}

		#endregion

		

		#region Handle Exception

		private void HandleDbException(DbException ex)

		{

			//TODO:handle db exception.

			//Please throw application custom exception.

			

			throw ex;

		}

		private void HandleDbException(DbException ex, MoUserRole entity)

		{			

			//NOTE:If you use SQL Server/Oracle/Db2... ,Please add the [internal static class ErrorCodes]

			//Use the ErrorCodes like below:

			//if (ex.Number == ErrorCodes.SqlUserRaisedError)

            //{

            //    switch (ex.State)

            //    {

            //    case ErrorCodes.ValidationError:

            //        string[] messageParts = ex.Errors[0].Message.Split(':');

            //        throw new RepositoryValidationException(

            //            mapper.MapDbParameterToBusinessEntityProperty(messageParts[0]),

            //            messageParts[1], ex);



            //    case ErrorCodes.ConcurrencyViolationError:

            //        throw new ConcurrencyViolationException(ex.Message, ex);



            //    }

            //}

			

            //TODO:Please contruct your customer Exception.

            //throw new RepositoryFailureException(ex);      

			throw ex;           

		}

		private void HandleDbException(DbException ex,DataRow entity)

		{

			//TODO:If you use SQL Server/Oracle/Db2... ,Please add the [internal static class ErrorCodes]

			//if (ex.Number == ErrorCodes.SqlUserRaisedError)

            //{

            //    switch (ex.State)

            //    {

            //    case ErrorCodes.ValidationError:

            //        string[] messageParts = ex.Errors[0].Message.Split(':');

            //        throw new RepositoryValidationException(

            //            mapper.MapDbParameterToBusinessEntityProperty(messageParts[0]),

            //            messageParts[1], ex);



            //    case ErrorCodes.ConcurrencyViolationError:

            //        throw new ConcurrencyViolationException(ex.Message, ex);



            //    }

            //}

			

            //TODO:Please contruct your customer Exception.

            //throw new RepositoryFailureException(ex);      

			throw ex;           

		}

		#endregion

	}

}	

#endregion