public partial class SecurityRuleDataMapper:TDataMapper<SecurityRule,SqlConnection,AMF_devDb, Weborb.Data.Management.MSSql.CommandBuilder, SqlTransaction, SqlCommand>
    {
      public SecurityRuleDataMapper(){}
      public SecurityRuleDataMapper(AMF_devDb database):
      base(database){}
        public override String TableName
        {
          get
          {
            return "[Security].[SecurityRule]";
          }
        }

        public override Hashtable getRelation(string tableName)
        {
          throw new Exception("Not yet implemented");
        }

        
    
    private const String SqlCreate = @"Insert Into [Security].[SecurityRule] (
    NameResourceCode,ObjectType,ObjectID,Permission,CreateBy,CreateDate,ModifyBy,ModifyDate) Values (
    
      @NameResourceCode,
      @ObjectType,
      @ObjectID,
      @Permission,
      @CreateBy,
      @CreateDate,
      @ModifyBy,
      @ModifyDate);

    
      select scope_identity();
    ";
    
    [TransactionRequired]
    [Synchronized]
    public override SecurityRule create( SecurityRule securityRule )
    {
      using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
      {
        using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
        {
        
                  sqlCommand.Parameters.AddWithValue("@NameResourceCode", securityRule.NameResourceCode);
              
                  sqlCommand.Parameters.AddWithValue("@ObjectType", securityRule.ObjectType);
              
                  sqlCommand.Parameters.AddWithValue("@ObjectID", securityRule.ObjectID);
              
                  sqlCommand.Parameters.AddWithValue("@Permission", securityRule.Permission);
              
                    if(securityRule.CreateBy.HasValue)
                  
                  sqlCommand.Parameters.AddWithValue("@CreateBy", securityRule.CreateBy);
                else
                  sqlCommand.Parameters.AddWithValue("@CreateBy", DBNull.Value);
              
                    if(securityRule.CreateDate.HasValue)
                  
                  sqlCommand.Parameters.AddWithValue("@CreateDate", securityRule.CreateDate);
                else
                  sqlCommand.Parameters.AddWithValue("@CreateDate", DBNull.Value);
              
                    if(securityRule.ModifyBy.HasValue)
                  
                  sqlCommand.Parameters.AddWithValue("@ModifyBy", securityRule.ModifyBy);
                else
                  sqlCommand.Parameters.AddWithValue("@ModifyBy", DBNull.Value);
              
                    if(securityRule.ModifyDate.HasValue)
                  
                  sqlCommand.Parameters.AddWithValue("@ModifyDate", securityRule.ModifyDate);
                else
                  sqlCommand.Parameters.AddWithValue("@ModifyDate", DBNull.Value);
              securityRule.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
            
        }
      }
      
    
          
          if(securityRule.relatedSecurityExpression != null 
            && securityRule.relatedSecurityExpression.Count > 0)
          {
            SecurityExpressionDataMapper dataMapper = new SecurityExpressionDataMapper(Database);
            
            foreach(SecurityExpression item in securityRule.relatedSecurityExpression)
              dataMapper.create(item);
          }
        
          
          if(securityRule.relatedSecurityRuleSecurityRight != null 
            && securityRule.relatedSecurityRuleSecurityRight.Count > 0)
          {
            SecurityRuleSecurityRightDataMapper dataMapper = new SecurityRuleSecurityRightDataMapper(Database);
            
            foreach(SecurityRuleSecurityRight item in securityRule.relatedSecurityRuleSecurityRight)
              dataMapper.create(item);
          }
        
          
          if(securityRule.relatedSecurityRuleSecurityRole != null 
            && securityRule.relatedSecurityRuleSecurityRole.Count > 0)
          {
            SecurityRuleSecurityRoleDataMapper dataMapper = new SecurityRuleSecurityRoleDataMapper(Database);
            
            foreach(SecurityRuleSecurityRole item in securityRule.relatedSecurityRuleSecurityRole)
              dataMapper.create(item);
          }
        
      
      raiseAffected(securityRule,DataMapperOperation.create);

      return registerRecord(securityRule);
    }

  

    private const String SqlSelectByPk = @"Select
    ID,NameResourceCode,ObjectType,ObjectID,Permission,CreateBy,CreateDate,ModifyBy,ModifyDate
     From [Security].[SecurityRule]
    
       Where 
      ID = @ID
    ";

    public SecurityRule findByPrimaryKey(
    int iD
    )
    {
    using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
    {
    using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
    {
        
          sqlCommand.Parameters.AddWithValue("@ID", iD);
        

        using(IDataReader dataReader = sqlCommand.ExecuteReader())
        {
          if(dataReader.Read())
            return doLoad(dataReader);
        }
      }
     }      
      throw new DataNotFoundException("SecurityRule not found, search by primary key");
 

    }


    public bool exists(SecurityRule securityRule)
    {
      using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
      {
          using(SqlCommand sqlCommand = Database.CreateCommand(SqlSelectByPk))
          {
              
                sqlCommand.Parameters.AddWithValue("@ID", securityRule.ID);
              

              using(IDataReader dataReader = sqlCommand.ExecuteReader())
              {
              return dataReader.Read();
              }
          }
      }
    }

    private const string CheckInSql = @"
    
      [SecurityRule].[ID] = @CheckInID";

    protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
    {
      SecurityRule _SecurityRule = (SecurityRule)domainObject;

       SqlCommand sqlCommand = Database.CreateCommand(ModifyQueryForCheckIn(sqlQuery,CheckInSql));

      
        sqlCommand.Parameters.AddWithValue("@CheckInID", _SecurityRule.ID);
      

      return sqlCommand;
    }

  

    protected override SecurityRule doLoad(IDataReader dataReader)
    {
    SecurityRule securityRule = new SecurityRule();

    securityRule.ID = (int) dataReader.GetValue(0);
            securityRule.NameResourceCode = (String) dataReader.GetValue(1);
            securityRule.ObjectType = (int) dataReader.GetValue(2);
            securityRule.ObjectID = (int) dataReader.GetValue(3);
            securityRule.Permission = (int) dataReader.GetValue(4);
            
          if(!dataReader.IsDBNull(5))        
          securityRule.CreateBy = (int) dataReader.GetValue(5);
            
          if(!dataReader.IsDBNull(6))        
          securityRule.CreateDate = (DateTime) dataReader.GetValue(6);
            
          if(!dataReader.IsDBNull(7))        
          securityRule.ModifyBy = (int) dataReader.GetValue(7);
            
          if(!dataReader.IsDBNull(8))        
          securityRule.ModifyDate = (DateTime) dataReader.GetValue(8);
            

    
    
    return registerRecord(securityRule);
    }


    protected override SecurityRule doLoad(Hashtable hashtable)
    {
      SecurityRule securityRule = new SecurityRule();

      
        
        if(hashtable.ContainsKey("ID"))
        securityRule.ID = ( int)hashtable["ID"];
          
        
        if(hashtable.ContainsKey("NameResourceCode"))
        securityRule.NameResourceCode = ( String)hashtable["NameResourceCode"];
          
        
        if(hashtable.ContainsKey("ObjectType"))
        securityRule.ObjectType = ( int)hashtable["ObjectType"];
          
        
        if(hashtable.ContainsKey("ObjectID"))
        securityRule.ObjectID = ( int)hashtable["ObjectID"];
          
        
        if(hashtable.ContainsKey("Permission"))
        securityRule.Permission = ( int)hashtable["Permission"];
          
        
        if(hashtable.ContainsKey("CreateBy"))
        securityRule.CreateBy = ( int)hashtable["CreateBy"];
          
        
        if(hashtable.ContainsKey("CreateDate"))
        securityRule.CreateDate = ( DateTime)hashtable["CreateDate"];
          
        
        if(hashtable.ContainsKey("ModifyBy"))
        securityRule.ModifyBy = ( int)hashtable["ModifyBy"];
          
        
        if(hashtable.ContainsKey("ModifyDate"))
        securityRule.ModifyDate = ( DateTime)hashtable["ModifyDate"];
          

      return securityRule;
    }


    protected override List<SecurityRule> fill(SqlCommand sqlCommand, int offset, int limit)
    {
        List<SecurityRule> resultList = new List<SecurityRule>();
    
         using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
         {
            DataTable dataTable = new DataTable();
            
            sqlDataAdapter.Fill(offset,limit,dataTable);
            
            foreach(DataRow dataRow in dataTable.Rows)
            {
              SecurityRule item = new SecurityRule();
              
              
                    item.ID = ( int)dataRow["ID"] ;
                  
                    item.NameResourceCode = ( String)dataRow["NameResourceCode"] ;
                  
                    item.ObjectType = ( int)dataRow["ObjectType"] ;
                  
                    item.ObjectID = ( int)dataRow["ObjectID"] ;
                  
                    item.Permission = ( int)dataRow["Permission"] ;
                  
                  if(!dataRow.IsNull("CreateBy"))
                
                    item.CreateBy = ( int)dataRow["CreateBy"] ;
                  
                  if(!dataRow.IsNull("CreateDate"))
                
                    item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
                  
                  if(!dataRow.IsNull("ModifyBy"))
                
                    item.ModifyBy = ( int)dataRow["ModifyBy"] ;
                  
                  if(!dataRow.IsNull("ModifyDate"))
                
                    item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
                  
               registerRecord(item);
               
               resultList.Add(item);
            }
         }
         
         return resultList;
    }