namespace Pixco.Framework.Navigation.Data
      {
      using System;
      
    using System.Data;
    using System.Collections;
    using System.Collections.Generic;
    using Weborb.Data.Management;
  
    
      using System.Data.SqlClient;
    
    public partial class AMF_devDb:TDatabase<SqlConnection,SqlTransaction,SqlCommand>
    {
      public AMF_devDb()
      {
        InitConnectionString("AMF_dev");
      }

    

        public NavigationGrouping create(NavigationGrouping navigationGrouping)
        {
          NavigationGroupingDataMapper dataMapper = new NavigationGroupingDataMapper(this);
          
          return dataMapper.create(navigationGrouping);
        }

        public NavigationGrouping update(NavigationGrouping navigationGrouping)
        {
          NavigationGroupingDataMapper dataMapper = new NavigationGroupingDataMapper(this);

          return dataMapper.update(navigationGrouping);
        }

        public NavigationGrouping remove(NavigationGrouping navigationGrouping)
        {
          NavigationGroupingDataMapper dataMapper = new NavigationGroupingDataMapper(this);

          return dataMapper.remove(navigationGrouping);
        }
      

        public NavigationItem create(NavigationItem navigationItem)
        {
          NavigationItemDataMapper dataMapper = new NavigationItemDataMapper(this);
          
          return dataMapper.create(navigationItem);
        }

        public NavigationItem update(NavigationItem navigationItem)
        {
          NavigationItemDataMapper dataMapper = new NavigationItemDataMapper(this);

          return dataMapper.update(navigationItem);
        }

        public NavigationItem remove(NavigationItem navigationItem)
        {
          NavigationItemDataMapper dataMapper = new NavigationItemDataMapper(this);

          return dataMapper.remove(navigationItem);
        }
      

        public NavigationQueryExpression create(NavigationQueryExpression navigationQueryExpression)
        {
          NavigationQueryExpressionDataMapper dataMapper = new NavigationQueryExpressionDataMapper(this);
          
          return dataMapper.create(navigationQueryExpression);
        }

        public NavigationQueryExpression update(NavigationQueryExpression navigationQueryExpression)
        {
          NavigationQueryExpressionDataMapper dataMapper = new NavigationQueryExpressionDataMapper(this);

          return dataMapper.update(navigationQueryExpression);
        }

        public NavigationQueryExpression remove(NavigationQueryExpression navigationQueryExpression)
        {
          NavigationQueryExpressionDataMapper dataMapper = new NavigationQueryExpressionDataMapper(this);

          return dataMapper.remove(navigationQueryExpression);
        }
      
        public DataSet Sp_alterdiagram(
        String 
            diagramname,int 
            owner_id,int 
            version,byte[] 
            definition)
        {
            DataSet dataSet = new DataSet();

            using (DatabaseConnectionMonitor databaseConnectionMonitor = new DatabaseConnectionMonitor(this))
            {
                using (SqlCommand sqlCommand = new SqlCommand("sp_alterdiagram", Connection))
                {
                    sqlCommand.CommandType = CommandType.StoredProcedure;
                    
                    
                      sqlCommand.Parameters.AddWithValue("@diagramname", 
                        diagramname);
                    
                      sqlCommand.Parameters.AddWithValue("@owner_id", 
                        owner_id);
                    
                      sqlCommand.Parameters.AddWithValue("@version", 
                        version);
                    
                      sqlCommand.Parameters.AddWithValue("@definition", 
                        definition);
                    
        
                    SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
                    
                    sqlDataAdapter.Fill(dataSet);
                }
            }

            return dataSet;
        }
      
        public DataSet Sp_creatediagram(
        String 
            diagramname,int 
            owner_id,int 
            version,byte[] 
            definition)
        {
            DataSet dataSet = new DataSet();

            using (DatabaseConnectionMonitor databaseConnectionMonitor = new DatabaseConnectionMonitor(this))
            {
                using (SqlCommand sqlCommand = new SqlCommand("sp_creatediagram", Connection))
                {
                    sqlCommand.CommandType = CommandType.StoredProcedure;
                    
                    
                      sqlCommand.Parameters.AddWithValue("@diagramname", 
                        diagramname);
                    
                      sqlCommand.Parameters.AddWithValue("@owner_id", 
                        owner_id);
                    
                      sqlCommand.Parameters.AddWithValue("@version", 
                        version);
                    
                      sqlCommand.Parameters.AddWithValue("@definition", 
                        definition);
                    
        
                    SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
                    
                    sqlDataAdapter.Fill(dataSet);
                }
            }

            return dataSet;
        }
      
        public DataSet Sp_dropdiagram(
        String 
            diagramname,int 
            owner_id)
        {
            DataSet dataSet = new DataSet();

            using (DatabaseConnectionMonitor databaseConnectionMonitor = new DatabaseConnectionMonitor(this))
            {
                using (SqlCommand sqlCommand = new SqlCommand("sp_dropdiagram", Connection))
                {
                    sqlCommand.CommandType = CommandType.StoredProcedure;
                    
                    
                      sqlCommand.Parameters.AddWithValue("@diagramname", 
                        diagramname);
                    
                      sqlCommand.Parameters.AddWithValue("@owner_id", 
                        owner_id);
                    
        
                    SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
                    
                    sqlDataAdapter.Fill(dataSet);
                }
            }

            return dataSet;
        }
      
        public DataSet Sp_helpdiagramdefinition(
        String 
            diagramname,int 
            owner_id)
        {
            DataSet dataSet = new DataSet();

            using (DatabaseConnectionMonitor databaseConnectionMonitor = new DatabaseConnectionMonitor(this))
            {
                using (SqlCommand sqlCommand = new SqlCommand("sp_helpdiagramdefinition", Connection))
                {
                    sqlCommand.CommandType = CommandType.StoredProcedure;
                    
                    
                      sqlCommand.Parameters.AddWithValue("@diagramname", 
                        diagramname);
                    
                      sqlCommand.Parameters.AddWithValue("@owner_id", 
                        owner_id);
                    
        
                    SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
                    
                    sqlDataAdapter.Fill(dataSet);
                }
            }

            return dataSet;
        }
      
        public DataSet Sp_helpdiagrams(
        String 
            diagramname,int 
            owner_id)
        {
            DataSet dataSet = new DataSet();

            using (DatabaseConnectionMonitor databaseConnectionMonitor = new DatabaseConnectionMonitor(this))
            {
                using (SqlCommand sqlCommand = new SqlCommand("sp_helpdiagrams", Connection))
                {
                    sqlCommand.CommandType = CommandType.StoredProcedure;
                    
                    
                      sqlCommand.Parameters.AddWithValue("@diagramname", 
                        diagramname);
                    
                      sqlCommand.Parameters.AddWithValue("@owner_id", 
                        owner_id);
                    
        
                    SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
                    
                    sqlDataAdapter.Fill(dataSet);
                }
            }

            return dataSet;
        }
      
        public DataSet Sp_renamediagram(
        String 
            diagramname,int 
            owner_id,String 
            new_diagramname)
        {
            DataSet dataSet = new DataSet();

            using (DatabaseConnectionMonitor databaseConnectionMonitor = new DatabaseConnectionMonitor(this))
            {
                using (SqlCommand sqlCommand = new SqlCommand("sp_renamediagram", Connection))
                {
                    sqlCommand.CommandType = CommandType.StoredProcedure;
                    
                    
                      sqlCommand.Parameters.AddWithValue("@diagramname", 
                        diagramname);
                    
                      sqlCommand.Parameters.AddWithValue("@owner_id", 
                        owner_id);
                    
                      sqlCommand.Parameters.AddWithValue("@new_diagramname", 
                        new_diagramname);
                    
        
                    SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
                    
                    sqlDataAdapter.Fill(dataSet);
                }
            }

            return dataSet;
        }
      
        public DataSet Sp_upgraddiagrams(
        )
        {
            DataSet dataSet = new DataSet();

            using (DatabaseConnectionMonitor databaseConnectionMonitor = new DatabaseConnectionMonitor(this))
            {
                using (SqlCommand sqlCommand = new SqlCommand("sp_upgraddiagrams", Connection))
                {
                    sqlCommand.CommandType = CommandType.StoredProcedure;
                    
                    
        
                    SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
                    
                    sqlDataAdapter.Fill(dataSet);
                }
            }

            return dataSet;
        }
      
    }
  
    
    public partial class NavigationGrouping: DomainObject
    {
    
      protected int _iD;
    
      protected int _metadataElementDefinitionID;
    
      protected int _sequence;
    
      protected int _createBy;
    
      protected DateTime _createDate;
    
      protected int _modifyBy;
    
      protected DateTime _modifyDate;
    

      // parent tables
      protected NavigationItem _relatedNavigationItem
        = new NavigationItem()
      ;
    

    public NavigationGrouping(){}

    public NavigationGrouping(
    int 
            iD,int 
            navigationItemID,int 
            metadataElementDefinitionID,int 
            sequence,int 
            createBy,DateTime 
            createDate,int 
            modifyBy,DateTime 
            modifyDate
    )
    {
    
      this.ID = iD;
    
      this.NavigationItemID = navigationItemID;
    
      this.MetadataElementDefinitionID = metadataElementDefinitionID;
    
      this.Sequence = sequence;
    
      this.CreateBy = createBy;
    
      this.CreateDate = createDate;
    
      this.ModifyBy = modifyBy;
    
      this.ModifyDate = modifyDate;
    
    }

    public override String  getUri()
    {

    String uri = "AMF_dev.NavigationGrouping."
    
      + ID.ToString()
    ;
    
    return uri;
    }

    

      public int ID
      {
        
            get { return _iD;}
            set 
            { 
                _iD = value;
            }
          
      }
    

      public int NavigationItemID
      {
        
            get
            {
            
                  if(_relatedNavigationItem != null)
                    return _relatedNavigationItem.ID;

                throw new NullReferenceException("Parent instance not initialized ");
            }
            set
            {
            
                      if(_relatedNavigationItem == null)
                        _relatedNavigationItem = new NavigationItem();

                      _relatedNavigationItem.ID = value;
                    
            }
          
      }
    

      public int MetadataElementDefinitionID
      {
        
            get { return _metadataElementDefinitionID;}
            set 
            { 
                _metadataElementDefinitionID = value;
            }
          
      }
    

      public int Sequence
      {
        
            get { return _sequence;}
            set 
            { 
                _sequence = value;
            }
          
      }
    

      public int CreateBy
      {
        
            get { return _createBy;}
            set 
            { 
                _createBy = value;
            }
          
      }
    

      public DateTime CreateDate
      {
        
            get { return _createDate;}
            set 
            { 
                _createDate = value;
            }
          
      }
    

      public int ModifyBy
      {
        
            get { return _modifyBy;}
            set 
            { 
                _modifyBy = value;
            }
          
      }
    

      public DateTime ModifyDate
      {
        
            get { return _modifyDate;}
            set 
            { 
                _modifyDate = value;
            }
          
      }
    

      public NavigationItem RelatedNavigationItem
      {
      get { return _relatedNavigationItem;}
      set { _relatedNavigationItem = value; }
      }
      
    


    public override DomainObject extractSingleObject()
    {
      NavigationGrouping navigationGrouping = new NavigationGrouping();
      
      navigationGrouping.ID = this.ID;
      navigationGrouping.NavigationItemID = this.NavigationItemID;
      navigationGrouping.MetadataElementDefinitionID = this.MetadataElementDefinitionID;
      navigationGrouping.Sequence = this.Sequence;
      navigationGrouping.CreateBy = this.CreateBy;
      navigationGrouping.CreateDate = this.CreateDate;
      navigationGrouping.ModifyBy = this.ModifyBy;
      navigationGrouping.ModifyDate = this.ModifyDate;
      navigationGrouping.ActiveRecordId = this.ActiveRecordId; 
      return navigationGrouping;
    }

    
    }
  

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

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

        
    
    private const String SqlCreate = @"Insert Into [Navigation].[NavigationGrouping] (
    
      [NavigationItemID]
      ,
      [MetadataElementDefinitionID]
      ,
      [Sequence]
      ,
      [CreateBy]
      ,
      [CreateDate]
      ,
      [ModifyBy]
      ,
      [ModifyDate]
      ) Values (
    
      @navigationItemID,
      @metadataElementDefinitionID,
      @sequence,
      @createBy,
      @createDate,
      @modifyBy,
      @modifyDate);

    
      select scope_identity();
    ";
    
    
    [Synchronized]
    public override NavigationGrouping create( NavigationGrouping navigationGrouping )
    {
      using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
      {
        using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
        {
        
                  sqlCommand.Parameters.AddWithValue("@navigationItemID", navigationGrouping.NavigationItemID);
              
                  sqlCommand.Parameters.AddWithValue("@metadataElementDefinitionID", navigationGrouping.MetadataElementDefinitionID);
              
                  sqlCommand.Parameters.AddWithValue("@sequence", navigationGrouping.Sequence);
              
                  sqlCommand.Parameters.AddWithValue("@createBy", navigationGrouping.CreateBy);
              
                  sqlCommand.Parameters.AddWithValue("@createDate", navigationGrouping.CreateDate);
              
                  sqlCommand.Parameters.AddWithValue("@modifyBy", navigationGrouping.ModifyBy);
              
                  sqlCommand.Parameters.AddWithValue("@modifyDate", navigationGrouping.ModifyDate);
              navigationGrouping.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
            
        }
      }
      
    
      
      raiseAffected(navigationGrouping,DataMapperOperation.create);

      return registerRecord(navigationGrouping);
    }

  

    private const String SqlSelectByPk = @"Select
    
      [ID] ,
      [NavigationItemID] ,
      [MetadataElementDefinitionID] ,
      [Sequence] ,
      [CreateBy] ,
      [CreateDate] ,
      [ModifyBy] ,
      [ModifyDate] 
     From [Navigation].[NavigationGrouping]
    
       Where 
      
         [ID] = @iD
    ";

    public NavigationGrouping 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("NavigationGrouping not found, search by primary key");
 

    }


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

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

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

    protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
    {
      NavigationGrouping _NavigationGrouping = (NavigationGrouping)domainObject;

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

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

      return sqlCommand;
    }

  

    protected override NavigationGrouping doLoad(IDataReader dataReader)
    {
    NavigationGrouping navigationGrouping = new NavigationGrouping();

    navigationGrouping.ID = (int) dataReader.GetValue(0);
            navigationGrouping.NavigationItemID = (int) dataReader.GetValue(1);
            navigationGrouping.MetadataElementDefinitionID = (int) dataReader.GetValue(2);
            navigationGrouping.Sequence = (int) dataReader.GetValue(3);
            navigationGrouping.CreateBy = (int) dataReader.GetValue(4);
            navigationGrouping.CreateDate = (DateTime) dataReader.GetValue(5);
            navigationGrouping.ModifyBy = (int) dataReader.GetValue(6);
            navigationGrouping.ModifyDate = (DateTime) dataReader.GetValue(7);
            

    
    
    return registerRecord(navigationGrouping);
    }


    protected override NavigationGrouping doLoad(Hashtable hashtable)
    {
      NavigationGrouping navigationGrouping = new NavigationGrouping();

      
        
        if(hashtable.ContainsKey("ID"))
        navigationGrouping.ID = ( int)hashtable["ID"];
          
        
        if(hashtable.ContainsKey("NavigationItemID"))
        navigationGrouping.NavigationItemID = ( int)hashtable["NavigationItemID"];
          
        
        if(hashtable.ContainsKey("MetadataElementDefinitionID"))
        navigationGrouping.MetadataElementDefinitionID = ( int)hashtable["MetadataElementDefinitionID"];
          
        
        if(hashtable.ContainsKey("Sequence"))
        navigationGrouping.Sequence = ( int)hashtable["Sequence"];
          
        
        if(hashtable.ContainsKey("CreateBy"))
        navigationGrouping.CreateBy = ( int)hashtable["CreateBy"];
          
        
        if(hashtable.ContainsKey("CreateDate"))
        navigationGrouping.CreateDate = ( DateTime)hashtable["CreateDate"];
          
        
        if(hashtable.ContainsKey("ModifyBy"))
        navigationGrouping.ModifyBy = ( int)hashtable["ModifyBy"];
          
        
        if(hashtable.ContainsKey("ModifyDate"))
        navigationGrouping.ModifyDate = ( DateTime)hashtable["ModifyDate"];
          

      return navigationGrouping;
    }


    protected override List<NavigationGrouping> fill(SqlCommand sqlCommand, int offset, int limit)
    {
        List<NavigationGrouping> resultList = new List<NavigationGrouping>();
    
         using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
         {
            DataTable dataTable = new DataTable();
            
            sqlDataAdapter.Fill(offset,limit,dataTable);
            
            foreach(DataRow dataRow in dataTable.Rows)
            {
              NavigationGrouping item = new NavigationGrouping();
              
              
                    item.ID = ( int)dataRow["ID"] ;
                  
                    item.NavigationItemID = ( int)dataRow["NavigationItemID"] ;
                  
                    item.MetadataElementDefinitionID = ( int)dataRow["MetadataElementDefinitionID"] ;
                  
                    item.Sequence = ( int)dataRow["Sequence"] ;
                  
                    item.CreateBy = ( int)dataRow["CreateBy"] ;
                  
                    item.CreateDate = ( DateTime)dataRow["CreateDate"] ;
                  
                    item.ModifyBy = ( int)dataRow["ModifyBy"] ;
                  
                    item.ModifyDate = ( DateTime)dataRow["ModifyDate"] ;
                  
               registerRecord(item);
               
               resultList.Add(item);
            }
         }
         
         return resultList;
    }
    
    
  

    #region Delete
    private const String SqlDelete = @"Delete From [Navigation].[NavigationGrouping]
    
      Where
      
        [ID] = @iD";
    [Synchronized]
    public override NavigationGrouping remove(NavigationGrouping navigationGrouping)
    {
      using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
      {
          using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
          {
          
            
            sqlCommand.Parameters.AddWithValue("@iD", navigationGrouping.ID);
          
            sqlCommand.ExecuteNonQuery();
          }
       }
      raiseAffected(navigationGrouping,DataMapperOperation.delete);

      return registerRecord(navigationGrouping);
    }

    #endregion
  
    [Synchronized]
    [TransactionRequired]
    public override NavigationGrouping save( NavigationGrouping navigationGrouping )
    {
      if(exists(navigationGrouping))
        return update(navigationGrouping);
        return create(navigationGrouping);
    }

  
      const String SqlUpdate = @"Update [Navigation].[NavigationGrouping] Set
      
        [NavigationItemID] = @navigationItemID,
        [MetadataElementDefinitionID] = @metadataElementDefinitionID,
        [Sequence] = @sequence,
        [CreateBy] = @createBy,
        [CreateDate] = @createDate,
        [ModifyBy] = @modifyBy,
        [ModifyDate] = @modifyDate
        Where
        
          [ID] = @iD";
    
    [Synchronized]
    public override NavigationGrouping update(NavigationGrouping navigationGrouping)
    {
      


        using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
        {
        using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
        {
        
              sqlCommand.Parameters.AddWithValue("@iD", navigationGrouping.ID);
            
              sqlCommand.Parameters.AddWithValue("@navigationItemID", navigationGrouping.NavigationItemID);
            
              sqlCommand.Parameters.AddWithValue("@metadataElementDefinitionID", navigationGrouping.MetadataElementDefinitionID);
            
              sqlCommand.Parameters.AddWithValue("@sequence", navigationGrouping.Sequence);
            
              sqlCommand.Parameters.AddWithValue("@createBy", navigationGrouping.CreateBy);
            
              sqlCommand.Parameters.AddWithValue("@createDate", navigationGrouping.CreateDate);
            
              sqlCommand.Parameters.AddWithValue("@modifyBy", navigationGrouping.ModifyBy);
            
              sqlCommand.Parameters.AddWithValue("@modifyDate", navigationGrouping.ModifyDate);
            


        sqlCommand.ExecuteNonQuery();
        }
        }

        

        raiseAffected(navigationGrouping,DataMapperOperation.update);
        
    
        return registerRecord(navigationGrouping);

    }

  
    }
    
  
    
    public partial class NavigationItem: DomainObject
    {
    
      protected int _iD;
    
      protected String _code;
    
      protected String _captionResourceCode;
    
      protected int _navigationType;
    
      protected int _createBy;
    
      protected DateTime _createDate;
    
      protected int _modifyBy;
    
      protected DateTime _modifyDate;
    

      // parent tables
      protected NavigationItem _relatedNavigationItem;
    

    public NavigationItem(){}

    public NavigationItem(
    int 
            iD,String 
            code,String 
            captionResourceCode,int 
            navigationType,int 
            parentNavigationItemID,int 
            createBy,DateTime 
            createDate,int 
            modifyBy,DateTime 
            modifyDate
    )
    {
    
      this.ID = iD;
    
      this.Code = code;
    
      this.CaptionResourceCode = captionResourceCode;
    
      this.NavigationType = navigationType;
    
      this.ParentNavigationItemID = parentNavigationItemID;
    
      this.CreateBy = createBy;
    
      this.CreateDate = createDate;
    
      this.ModifyBy = modifyBy;
    
      this.ModifyDate = modifyDate;
    
    }

    public override String  getUri()
    {

    String uri = "AMF_dev.NavigationItem."
    
      + ID.ToString()
    ;
    
    return uri;
    }

    

      public int ID
      {
        
            get { return _iD;}
            set 
            { 
                _iD = value;
            }
          
      }
    

      public String Code
      {
        
            get { return _code;}
            set 
            { 
                _code = value;
            }
          
      }
    

      public String CaptionResourceCode
      {
        
            get { return _captionResourceCode;}
            set 
            { 
                _captionResourceCode = value;
            }
          
      }
    

      public int NavigationType
      {
        
            get { return _navigationType;}
            set 
            { 
                _navigationType = value;
            }
          
      }
    

      public int? ParentNavigationItemID
      {
        
            get
            {
            
                  if(_relatedNavigationItem != null)
                    return _relatedNavigationItem.ID;

                return null;
            }
            set
            {
            
                      if(!value.HasValue)
                        _relatedNavigationItem = null;
                      else
                      {
                      if(_relatedNavigationItem == null)
                        _relatedNavigationItem = new NavigationItem();

                        _relatedNavigationItem.ID = value.Value;
                      }
                    
            }
          
      }
    

      public int CreateBy
      {
        
            get { return _createBy;}
            set 
            { 
                _createBy = value;
            }
          
      }
    

      public DateTime CreateDate
      {
        
            get { return _createDate;}
            set 
            { 
                _createDate = value;
            }
          
      }
    

      public int ModifyBy
      {
        
            get { return _modifyBy;}
            set 
            { 
                _modifyBy = value;
            }
          
      }
    

      public DateTime ModifyDate
      {
        
            get { return _modifyDate;}
            set 
            { 
                _modifyDate = value;
            }
          
      }
    

      public NavigationItem RelatedNavigationItem
      {
      get { return _relatedNavigationItem;}
      set { _relatedNavigationItem = value; }
      }
      
    


    public override DomainObject extractSingleObject()
    {
      NavigationItem navigationItem = new NavigationItem();
      
      navigationItem.ID = this.ID;
      navigationItem.Code = this.Code;
      navigationItem.CaptionResourceCode = this.CaptionResourceCode;
      navigationItem.NavigationType = this.NavigationType;
      navigationItem.ParentNavigationItemID = this.ParentNavigationItemID;
      navigationItem.CreateBy = this.CreateBy;
      navigationItem.CreateDate = this.CreateDate;
      navigationItem.ModifyBy = this.ModifyBy;
      navigationItem.ModifyDate = this.ModifyDate;
      navigationItem.ActiveRecordId = this.ActiveRecordId; 
      return navigationItem;
    }

    
          // one to many relation
          private List<NavigationGrouping> _relatedNavigationGrouping;

          public List<NavigationGrouping> relatedNavigationGrouping
          {
          get { return _relatedNavigationGrouping;}
          set { _relatedNavigationGrouping = value; }
          }
          
          
          public NavigationGrouping addRelatedNavigationGroupingItem(
          NavigationGrouping navigationGrouping)
          {
            navigationGrouping.RelatedNavigationItem = this;
            
            _relatedNavigationGrouping.Add(navigationGrouping);
            
            return navigationGrouping;
          }
            
        
          // one to many relation
          private List<NavigationItem> _relatedNavigationItemChild;

          public List<NavigationItem> relatedNavigationItemChild
          {
          get { return _relatedNavigationItemChild;}
          set { _relatedNavigationItemChild = value; }
          }
          
          
          public NavigationItem addRelatedNavigationItemChildItem(
          NavigationItem navigationItem)
          {
            navigationItem.RelatedNavigationItem = this;
            
            _relatedNavigationItemChild.Add(navigationItem);
            
            return navigationItem;
          }
            
        
          // one to many relation
          private List<NavigationQueryExpression> _relatedNavigationQueryExpression;

          public List<NavigationQueryExpression> relatedNavigationQueryExpression
          {
          get { return _relatedNavigationQueryExpression;}
          set { _relatedNavigationQueryExpression = value; }
          }
          
          
          public NavigationQueryExpression addRelatedNavigationQueryExpressionItem(
          NavigationQueryExpression navigationQueryExpression)
          {
            navigationQueryExpression.RelatedNavigationItem = this;
            
            _relatedNavigationQueryExpression.Add(navigationQueryExpression);
            
            return navigationQueryExpression;
          }
            
        
    }
  

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

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

        
    
    private const String SqlCreate = @"Insert Into [Navigation].[NavigationItem] (
    
      [Code]
      ,
      [CaptionResourceCode]
      ,
      [navigationType]
      ,
      [ParentNavigationItemID]
      ,
      [CreateBy]
      ,
      [CreateDate]
      ,
      [ModifyBy]
      ,
      [ModifyDate]
      ) Values (
    
      @code,
      @captionResourceCode,
      @navigationType,
      @parentNavigationItemID,
      @createBy,
      @createDate,
      @modifyBy,
      @modifyDate);

    
      select scope_identity();
    ";
    
    [TransactionRequired]
    [Synchronized]
    public override NavigationItem create( NavigationItem navigationItem )
    {
      using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
      {
        using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
        {
        
                  sqlCommand.Parameters.AddWithValue("@code", navigationItem.Code);
              
                  sqlCommand.Parameters.AddWithValue("@captionResourceCode", navigationItem.CaptionResourceCode);
              
                  sqlCommand.Parameters.AddWithValue("@navigationType", navigationItem.NavigationType);
              
                    if(navigationItem.ParentNavigationItemID.HasValue)
                  
                  sqlCommand.Parameters.AddWithValue("@parentNavigationItemID", navigationItem.ParentNavigationItemID);
                else
                  sqlCommand.Parameters.AddWithValue("@parentNavigationItemID", DBNull.Value);
              
                  sqlCommand.Parameters.AddWithValue("@createBy", navigationItem.CreateBy);
              
                  sqlCommand.Parameters.AddWithValue("@createDate", navigationItem.CreateDate);
              
                  sqlCommand.Parameters.AddWithValue("@modifyBy", navigationItem.ModifyBy);
              
                  sqlCommand.Parameters.AddWithValue("@modifyDate", navigationItem.ModifyDate);
              navigationItem.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
            
        }
      }
      
    
          
          if(navigationItem.relatedNavigationGrouping != null 
            && navigationItem.relatedNavigationGrouping.Count > 0)
          {
            NavigationGroupingDataMapper dataMapper = new NavigationGroupingDataMapper(Database);
            
            foreach(NavigationGrouping item in navigationItem.relatedNavigationGrouping)
              dataMapper.create(item);
          }
        
          
          if(navigationItem.relatedNavigationItemChild != null 
            && navigationItem.relatedNavigationItemChild.Count > 0)
          {
            NavigationItemDataMapper dataMapper = new NavigationItemDataMapper(Database);
            
            foreach(NavigationItem item in navigationItem.relatedNavigationItemChild)
              dataMapper.create(item);
          }
        
          
          if(navigationItem.relatedNavigationQueryExpression != null 
            && navigationItem.relatedNavigationQueryExpression.Count > 0)
          {
            NavigationQueryExpressionDataMapper dataMapper = new NavigationQueryExpressionDataMapper(Database);
            
            foreach(NavigationQueryExpression item in navigationItem.relatedNavigationQueryExpression)
              dataMapper.create(item);
          }
        
      
      raiseAffected(navigationItem,DataMapperOperation.create);

      return registerRecord(navigationItem);
    }

  

    private const String SqlSelectByPk = @"Select
    
      [ID] ,
      [Code] ,
      [CaptionResourceCode] ,
      [navigationType] ,
      [ParentNavigationItemID] ,
      [CreateBy] ,
      [CreateDate] ,
      [ModifyBy] ,
      [ModifyDate] 
     From [Navigation].[NavigationItem]
    
       Where 
      
         [ID] = @iD
    ";

    public NavigationItem 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("NavigationItem not found, search by primary key");
 

    }


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

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

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

    protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
    {
      NavigationItem _NavigationItem = (NavigationItem)domainObject;

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

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

      return sqlCommand;
    }

  

    protected override NavigationItem doLoad(IDataReader dataReader)
    {
    NavigationItem navigationItem = new NavigationItem();

    navigationItem.ID = (int) dataReader.GetValue(0);
            navigationItem.Code = (String) dataReader.GetValue(1);
            navigationItem.CaptionResourceCode = (String) dataReader.GetValue(2);
            navigationItem.NavigationType = (int) dataReader.GetValue(3);
            
          if(!dataReader.IsDBNull(4))        
          navigationItem.ParentNavigationItemID = (int) dataReader.GetValue(4);
            navigationItem.CreateBy = (int) dataReader.GetValue(5);
            navigationItem.CreateDate = (DateTime) dataReader.GetValue(6);
            navigationItem.ModifyBy = (int) dataReader.GetValue(7);
            navigationItem.ModifyDate = (DateTime) dataReader.GetValue(8);
            

    
    
    return registerRecord(navigationItem);
    }


    protected override NavigationItem doLoad(Hashtable hashtable)
    {
      NavigationItem navigationItem = new NavigationItem();

      
        
        if(hashtable.ContainsKey("ID"))
        navigationItem.ID = ( int)hashtable["ID"];
          
        
        if(hashtable.ContainsKey("Code"))
        navigationItem.Code = ( String)hashtable["Code"];
          
        
        if(hashtable.ContainsKey("CaptionResourceCode"))
        navigationItem.CaptionResourceCode = ( String)hashtable["CaptionResourceCode"];
          
        
        if(hashtable.ContainsKey("navigationType"))
        navigationItem.NavigationType = ( int)hashtable["NavigationType"];
          
        
        if(hashtable.ContainsKey("ParentNavigationItemID"))
        navigationItem.ParentNavigationItemID = ( int)hashtable["ParentNavigationItemID"];
          
        
        if(hashtable.ContainsKey("CreateBy"))
        navigationItem.CreateBy = ( int)hashtable["CreateBy"];
          
        
        if(hashtable.ContainsKey("CreateDate"))
        navigationItem.CreateDate = ( DateTime)hashtable["CreateDate"];
          
        
        if(hashtable.ContainsKey("ModifyBy"))
        navigationItem.ModifyBy = ( int)hashtable["ModifyBy"];
          
        
        if(hashtable.ContainsKey("ModifyDate"))
        navigationItem.ModifyDate = ( DateTime)hashtable["ModifyDate"];
          

      return navigationItem;
    }


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

    #region Delete
    private const String SqlDelete = @"Delete From [Navigation].[NavigationItem]
    
      Where
      
        [ID] = @iD";
    [Synchronized]
    public override NavigationItem remove(NavigationItem navigationItem)
    {
      using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
      {
          using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
          {
          
            
            sqlCommand.Parameters.AddWithValue("@iD", navigationItem.ID);
          
            sqlCommand.ExecuteNonQuery();
          }
       }
      raiseAffected(navigationItem,DataMapperOperation.delete);

      return registerRecord(navigationItem);
    }

    #endregion
  
    [Synchronized]
    [TransactionRequired]
    public override NavigationItem save( NavigationItem navigationItem )
    {
      if(exists(navigationItem))
        return update(navigationItem);
        return create(navigationItem);
    }

  
      const String SqlUpdate = @"Update [Navigation].[NavigationItem] Set
      
        [Code] = @code,
        [CaptionResourceCode] = @captionResourceCode,
        [navigationType] = @navigationType,
        [ParentNavigationItemID] = @parentNavigationItemID,
        [CreateBy] = @createBy,
        [CreateDate] = @createDate,
        [ModifyBy] = @modifyBy,
        [ModifyDate] = @modifyDate
        Where
        
          [ID] = @iD";
    [TransactionRequired]
    [Synchronized]
    public override NavigationItem update(NavigationItem navigationItem)
    {
      


        using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
        {
        using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
        {
        
              sqlCommand.Parameters.AddWithValue("@iD", navigationItem.ID);
            
              sqlCommand.Parameters.AddWithValue("@code", navigationItem.Code);
            
              sqlCommand.Parameters.AddWithValue("@captionResourceCode", navigationItem.CaptionResourceCode);
            
              sqlCommand.Parameters.AddWithValue("@navigationType", navigationItem.NavigationType);
            
                  if(navigationItem.ParentNavigationItemID.HasValue)
                
              sqlCommand.Parameters.AddWithValue("@parentNavigationItemID", navigationItem.ParentNavigationItemID);
              else
              sqlCommand.Parameters.AddWithValue("@parentNavigationItemID", DBNull.Value);
            
              sqlCommand.Parameters.AddWithValue("@createBy", navigationItem.CreateBy);
            
              sqlCommand.Parameters.AddWithValue("@createDate", navigationItem.CreateDate);
            
              sqlCommand.Parameters.AddWithValue("@modifyBy", navigationItem.ModifyBy);
            
              sqlCommand.Parameters.AddWithValue("@modifyDate", navigationItem.ModifyDate);
            


        sqlCommand.ExecuteNonQuery();
        }
        }

        
              if(navigationItem.relatedNavigationGrouping != null
              && navigationItem.relatedNavigationGrouping.Count > 0)
              {
              NavigationGroupingDataMapper dataMapper = new NavigationGroupingDataMapper(Database);

              foreach(NavigationGrouping item in navigationItem.relatedNavigationGrouping)
              dataMapper.save(item);
              }
            
              if(navigationItem.relatedNavigationItemChild != null
              && navigationItem.relatedNavigationItemChild.Count > 0)
              {
              NavigationItemDataMapper dataMapper = new NavigationItemDataMapper(Database);

              foreach(NavigationItem item in navigationItem.relatedNavigationItemChild)
              dataMapper.save(item);
              }
            
              if(navigationItem.relatedNavigationQueryExpression != null
              && navigationItem.relatedNavigationQueryExpression.Count > 0)
              {
              NavigationQueryExpressionDataMapper dataMapper = new NavigationQueryExpressionDataMapper(Database);

              foreach(NavigationQueryExpression item in navigationItem.relatedNavigationQueryExpression)
              dataMapper.save(item);
              }
            

        raiseAffected(navigationItem,DataMapperOperation.update);
        
    
        return registerRecord(navigationItem);

    }

  
    }
    
  
    
    public partial class NavigationQueryExpression: DomainObject
    {
    
      protected int _iD;
    
      protected int? _metadataElementDefinitionID;
    
      protected String _value;
    
      protected int _navigationOperator;
    
      protected int? _createBy;
    
      protected DateTime? _createDate;
    
      protected int? _modifyBy;
    
      protected DateTime? _modifyDate;
    

      // parent tables
      protected NavigationItem _relatedNavigationItem
        = new NavigationItem()
      ;
    

      // parent tables
      protected NavigationQueryExpression _relatedNavigationQueryExpressionParent;
    

    public NavigationQueryExpression(){}

    public NavigationQueryExpression(
    int 
            iD,int 
            navigationItemID,int 
            metadataElementDefinitionID,String 
            value,int 
            navigationOperator,int 
            navigationParentID,int 
            createBy,DateTime 
            createDate,int 
            modifyBy,DateTime 
            modifyDate
    )
    {
    
      this.ID = iD;
    
      this.NavigationItemID = navigationItemID;
    
      this.MetadataElementDefinitionID = metadataElementDefinitionID;
    
      this.Value = value;
    
      this.NavigationOperator = navigationOperator;
    
      this.NavigationParentID = navigationParentID;
    
      this.CreateBy = createBy;
    
      this.CreateDate = createDate;
    
      this.ModifyBy = modifyBy;
    
      this.ModifyDate = modifyDate;
    
    }

    public override String  getUri()
    {

    String uri = "AMF_dev.NavigationQueryExpression."
    
      + ID.ToString()
    ;
    
    return uri;
    }

    

      public int ID
      {
        
            get { return _iD;}
            set 
            { 
                _iD = value;
            }
          
      }
    

      public int NavigationItemID
      {
        
            get
            {
            
                  if(_relatedNavigationItem != null)
                    return _relatedNavigationItem.ID;

                throw new NullReferenceException("Parent instance not initialized ");
            }
            set
            {
            
                      if(_relatedNavigationItem == null)
                        _relatedNavigationItem = new NavigationItem();

                      _relatedNavigationItem.ID = value;
                    
            }
          
      }
    

      public int? MetadataElementDefinitionID
      {
        
            get { return _metadataElementDefinitionID;}
            set 
            { 
                _metadataElementDefinitionID = value;
            }
          
      }
    

      public String Value
      {
        
            get { return _value;}
            set 
            { 
                _value = value;
            }
          
      }
    

      public int NavigationOperator
      {
        
            get { return _navigationOperator;}
            set 
            { 
                _navigationOperator = value;
            }
          
      }
    

      public int? NavigationParentID
      {
        
            get
            {
            
                  if(_relatedNavigationQueryExpressionParent != null)
                    return _relatedNavigationQueryExpressionParent.ID;

                return null;
            }
            set
            {
            
                      if(!value.HasValue)
                        _relatedNavigationQueryExpressionParent = null;
                      else
                      {
                      if(_relatedNavigationQueryExpressionParent == null)
                        _relatedNavigationQueryExpressionParent = new NavigationQueryExpression();

                        _relatedNavigationQueryExpressionParent.ID = value.Value;
                      }
                    
            }
          
      }
    

      public int? CreateBy
      {
        
            get { return _createBy;}
            set 
            { 
                _createBy = value;
            }
          
      }
    

      public DateTime? CreateDate
      {
        
            get { return _createDate;}
            set 
            { 
                _createDate = value;
            }
          
      }
    

      public int? ModifyBy
      {
        
            get { return _modifyBy;}
            set 
            { 
                _modifyBy = value;
            }
          
      }
    

      public DateTime? ModifyDate
      {
        
            get { return _modifyDate;}
            set 
            { 
                _modifyDate = value;
            }
          
      }
    

      public NavigationItem RelatedNavigationItem
      {
      get { return _relatedNavigationItem;}
      set { _relatedNavigationItem = value; }
      }
      
    

      public NavigationQueryExpression RelatedNavigationQueryExpressionParent
      {
      get { return _relatedNavigationQueryExpressionParent;}
      set { _relatedNavigationQueryExpressionParent = value; }
      }
      
    


    public override DomainObject extractSingleObject()
    {
      NavigationQueryExpression navigationQueryExpression = new NavigationQueryExpression();
      
      navigationQueryExpression.ID = this.ID;
      navigationQueryExpression.NavigationItemID = this.NavigationItemID;
      navigationQueryExpression.MetadataElementDefinitionID = this.MetadataElementDefinitionID;
      navigationQueryExpression.Value = this.Value;
      navigationQueryExpression.NavigationOperator = this.NavigationOperator;
      navigationQueryExpression.NavigationParentID = this.NavigationParentID;
      navigationQueryExpression.CreateBy = this.CreateBy;
      navigationQueryExpression.CreateDate = this.CreateDate;
      navigationQueryExpression.ModifyBy = this.ModifyBy;
      navigationQueryExpression.ModifyDate = this.ModifyDate;
      navigationQueryExpression.ActiveRecordId = this.ActiveRecordId; 
      return navigationQueryExpression;
    }

    
          // one to many relation
          private List<NavigationQueryExpression> _relatedNavigationQueryExpressionChild;

          public List<NavigationQueryExpression> relatedNavigationQueryExpressionChild
          {
          get { return _relatedNavigationQueryExpressionChild;}
          set { _relatedNavigationQueryExpressionChild = value; }
          }
          
          
          public NavigationQueryExpression addRelatedNavigationQueryExpressionChildItem(
          NavigationQueryExpression navigationQueryExpression)
          {
            navigationQueryExpression.RelatedNavigationQueryExpressionParent = this;
            
            _relatedNavigationQueryExpressionChild.Add(navigationQueryExpression);
            
            return navigationQueryExpression;
          }
            
        
    }
  

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

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

        
    
    private const String SqlCreate = @"Insert Into [Navigation].[NavigationQueryExpression] (
    
      [NavigationItemID]
      ,
      [MetadataElementDefinitionID]
      ,
      [Value]
      ,
      [NavigationOperator]
      ,
      [NavigationParentID]
      ,
      [CreateBy]
      ,
      [CreateDate]
      ,
      [ModifyBy]
      ,
      [ModifyDate]
      ) Values (
    
      @navigationItemID,
      @metadataElementDefinitionID,
      @value,
      @navigationOperator,
      @navigationParentID,
      @createBy,
      @createDate,
      @modifyBy,
      @modifyDate);

    
      select scope_identity();
    ";
    
    [TransactionRequired]
    [Synchronized]
    public override NavigationQueryExpression create( NavigationQueryExpression navigationQueryExpression )
    {
      using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
      {
        using(SqlCommand sqlCommand = Database.CreateCommand( SqlCreate ))
        {
        
                  sqlCommand.Parameters.AddWithValue("@navigationItemID", navigationQueryExpression.NavigationItemID);
              
                    if(navigationQueryExpression.MetadataElementDefinitionID.HasValue)
                  
                  sqlCommand.Parameters.AddWithValue("@metadataElementDefinitionID", navigationQueryExpression.MetadataElementDefinitionID);
                else
                  sqlCommand.Parameters.AddWithValue("@metadataElementDefinitionID", DBNull.Value);
              
                    if(navigationQueryExpression.Value != null)
                  
                  sqlCommand.Parameters.AddWithValue("@value", navigationQueryExpression.Value);
                else
                  sqlCommand.Parameters.AddWithValue("@value", DBNull.Value);
              
                  sqlCommand.Parameters.AddWithValue("@navigationOperator", navigationQueryExpression.NavigationOperator);
              
                    if(navigationQueryExpression.NavigationParentID.HasValue)
                  
                  sqlCommand.Parameters.AddWithValue("@navigationParentID", navigationQueryExpression.NavigationParentID);
                else
                  sqlCommand.Parameters.AddWithValue("@navigationParentID", DBNull.Value);
              
                    if(navigationQueryExpression.CreateBy.HasValue)
                  
                  sqlCommand.Parameters.AddWithValue("@createBy", navigationQueryExpression.CreateBy);
                else
                  sqlCommand.Parameters.AddWithValue("@createBy", DBNull.Value);
              
                    if(navigationQueryExpression.CreateDate.HasValue)
                  
                  sqlCommand.Parameters.AddWithValue("@createDate", navigationQueryExpression.CreateDate);
                else
                  sqlCommand.Parameters.AddWithValue("@createDate", DBNull.Value);
              
                    if(navigationQueryExpression.ModifyBy.HasValue)
                  
                  sqlCommand.Parameters.AddWithValue("@modifyBy", navigationQueryExpression.ModifyBy);
                else
                  sqlCommand.Parameters.AddWithValue("@modifyBy", DBNull.Value);
              
                    if(navigationQueryExpression.ModifyDate.HasValue)
                  
                  sqlCommand.Parameters.AddWithValue("@modifyDate", navigationQueryExpression.ModifyDate);
                else
                  sqlCommand.Parameters.AddWithValue("@modifyDate", DBNull.Value);
              navigationQueryExpression.ID = int.Parse( sqlCommand.ExecuteScalar().ToString()) ;
            
        }
      }
      
    
          
          if(navigationQueryExpression.relatedNavigationQueryExpressionChild != null 
            && navigationQueryExpression.relatedNavigationQueryExpressionChild.Count > 0)
          {
            NavigationQueryExpressionDataMapper dataMapper = new NavigationQueryExpressionDataMapper(Database);
            
            foreach(NavigationQueryExpression item in navigationQueryExpression.relatedNavigationQueryExpressionChild)
              dataMapper.create(item);
          }
        
      
      raiseAffected(navigationQueryExpression,DataMapperOperation.create);

      return registerRecord(navigationQueryExpression);
    }

  

    private const String SqlSelectByPk = @"Select
    
      [ID] ,
      [NavigationItemID] ,
      [MetadataElementDefinitionID] ,
      [Value] ,
      [NavigationOperator] ,
      [NavigationParentID] ,
      [CreateBy] ,
      [CreateDate] ,
      [ModifyBy] ,
      [ModifyDate] 
     From [Navigation].[NavigationQueryExpression]
    
       Where 
      
         [ID] = @iD
    ";

    public NavigationQueryExpression 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("NavigationQueryExpression not found, search by primary key");
 

    }


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

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

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

    protected override IDbCommand PrepareCheckInCommand(DomainObject domainObject, string sqlQuery)
    {
      NavigationQueryExpression _NavigationQueryExpression = (NavigationQueryExpression)domainObject;

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

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

      return sqlCommand;
    }

  

    protected override NavigationQueryExpression doLoad(IDataReader dataReader)
    {
    NavigationQueryExpression navigationQueryExpression = new NavigationQueryExpression();

    navigationQueryExpression.ID = (int) dataReader.GetValue(0);
            navigationQueryExpression.NavigationItemID = (int) dataReader.GetValue(1);
            
          if(!dataReader.IsDBNull(2))        
          navigationQueryExpression.MetadataElementDefinitionID = (int) dataReader.GetValue(2);
            
          if(!dataReader.IsDBNull(3))        
          navigationQueryExpression.Value = (String) dataReader.GetValue(3);
            navigationQueryExpression.NavigationOperator = (int) dataReader.GetValue(4);
            
          if(!dataReader.IsDBNull(5))        
          navigationQueryExpression.NavigationParentID = (int) dataReader.GetValue(5);
            
          if(!dataReader.IsDBNull(6))        
          navigationQueryExpression.CreateBy = (int) dataReader.GetValue(6);
            
          if(!dataReader.IsDBNull(7))        
          navigationQueryExpression.CreateDate = (DateTime) dataReader.GetValue(7);
            
          if(!dataReader.IsDBNull(8))        
          navigationQueryExpression.ModifyBy = (int) dataReader.GetValue(8);
            
          if(!dataReader.IsDBNull(9))        
          navigationQueryExpression.ModifyDate = (DateTime) dataReader.GetValue(9);
            

    
    
    return registerRecord(navigationQueryExpression);
    }


    protected override NavigationQueryExpression doLoad(Hashtable hashtable)
    {
      NavigationQueryExpression navigationQueryExpression = new NavigationQueryExpression();

      
        
        if(hashtable.ContainsKey("ID"))
        navigationQueryExpression.ID = ( int)hashtable["ID"];
          
        
        if(hashtable.ContainsKey("NavigationItemID"))
        navigationQueryExpression.NavigationItemID = ( int)hashtable["NavigationItemID"];
          
        
        if(hashtable.ContainsKey("MetadataElementDefinitionID"))
        navigationQueryExpression.MetadataElementDefinitionID = ( int)hashtable["MetadataElementDefinitionID"];
          
        
        if(hashtable.ContainsKey("Value"))
        navigationQueryExpression.Value = ( String)hashtable["Value"];
          
        
        if(hashtable.ContainsKey("NavigationOperator"))
        navigationQueryExpression.NavigationOperator = ( int)hashtable["NavigationOperator"];
          
        
        if(hashtable.ContainsKey("NavigationParentID"))
        navigationQueryExpression.NavigationParentID = ( int)hashtable["NavigationParentID"];
          
        
        if(hashtable.ContainsKey("CreateBy"))
        navigationQueryExpression.CreateBy = ( int)hashtable["CreateBy"];
          
        
        if(hashtable.ContainsKey("CreateDate"))
        navigationQueryExpression.CreateDate = ( DateTime)hashtable["CreateDate"];
          
        
        if(hashtable.ContainsKey("ModifyBy"))
        navigationQueryExpression.ModifyBy = ( int)hashtable["ModifyBy"];
          
        
        if(hashtable.ContainsKey("ModifyDate"))
        navigationQueryExpression.ModifyDate = ( DateTime)hashtable["ModifyDate"];
          

      return navigationQueryExpression;
    }


    protected override List<NavigationQueryExpression> fill(SqlCommand sqlCommand, int offset, int limit)
    {
        List<NavigationQueryExpression> resultList = new List<NavigationQueryExpression>();
    
         using(SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand))
         {
            DataTable dataTable = new DataTable();
            
            sqlDataAdapter.Fill(offset,limit,dataTable);
            
            foreach(DataRow dataRow in dataTable.Rows)
            {
              NavigationQueryExpression item = new NavigationQueryExpression();
              
              
                    item.ID = ( int)dataRow["ID"] ;
                  
                    item.NavigationItemID = ( int)dataRow["NavigationItemID"] ;
                  
                  if(!dataRow.IsNull("MetadataElementDefinitionID"))
                
                    item.MetadataElementDefinitionID = ( int)dataRow["MetadataElementDefinitionID"] ;
                  
                  if(!dataRow.IsNull("Value"))
                
                    item.Value = ( String)dataRow["Value"] ;
                  
                    item.NavigationOperator = ( int)dataRow["NavigationOperator"] ;
                  
                  if(!dataRow.IsNull("NavigationParentID"))
                
                    item.NavigationParentID = ( int)dataRow["NavigationParentID"] ;
                  
                  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;
    }
    
    
  

    #region Delete
    private const String SqlDelete = @"Delete From [Navigation].[NavigationQueryExpression]
    
      Where
      
        [ID] = @iD";
    [Synchronized]
    public override NavigationQueryExpression remove(NavigationQueryExpression navigationQueryExpression)
    {
      using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
      {
          using(SqlCommand sqlCommand = Database.CreateCommand(SqlDelete))
          {
          
            
            sqlCommand.Parameters.AddWithValue("@iD", navigationQueryExpression.ID);
          
            sqlCommand.ExecuteNonQuery();
          }
       }
      raiseAffected(navigationQueryExpression,DataMapperOperation.delete);

      return registerRecord(navigationQueryExpression);
    }

    #endregion
  
    [Synchronized]
    [TransactionRequired]
    public override NavigationQueryExpression save( NavigationQueryExpression navigationQueryExpression )
    {
      if(exists(navigationQueryExpression))
        return update(navigationQueryExpression);
        return create(navigationQueryExpression);
    }

  
      const String SqlUpdate = @"Update [Navigation].[NavigationQueryExpression] Set
      
        [NavigationItemID] = @navigationItemID,
        [MetadataElementDefinitionID] = @metadataElementDefinitionID,
        [Value] = @value,
        [NavigationOperator] = @navigationOperator,
        [NavigationParentID] = @navigationParentID,
        [CreateBy] = @createBy,
        [CreateDate] = @createDate,
        [ModifyBy] = @modifyBy,
        [ModifyDate] = @modifyDate
        Where
        
          [ID] = @iD";
    [TransactionRequired]
    [Synchronized]
    public override NavigationQueryExpression update(NavigationQueryExpression navigationQueryExpression)
    {
      


        using (DatabaseConnectionMonitor monitor = new DatabaseConnectionMonitor(Database))
        {
        using(SqlCommand sqlCommand = Database.CreateCommand(SqlUpdate))
        {
        
              sqlCommand.Parameters.AddWithValue("@iD", navigationQueryExpression.ID);
            
              sqlCommand.Parameters.AddWithValue("@navigationItemID", navigationQueryExpression.NavigationItemID);
            
                  if(navigationQueryExpression.MetadataElementDefinitionID.HasValue)
                
              sqlCommand.Parameters.AddWithValue("@metadataElementDefinitionID", navigationQueryExpression.MetadataElementDefinitionID);
              else
              sqlCommand.Parameters.AddWithValue("@metadataElementDefinitionID", DBNull.Value);
            
                  if(navigationQueryExpression.Value != null)
                
              sqlCommand.Parameters.AddWithValue("@value", navigationQueryExpression.Value);
              else
              sqlCommand.Parameters.AddWithValue("@value", DBNull.Value);
            
              sqlCommand.Parameters.AddWithValue("@navigationOperator", navigationQueryExpression.NavigationOperator);
            
                  if(navigationQueryExpression.NavigationParentID.HasValue)
                
              sqlCommand.Parameters.AddWithValue("@navigationParentID", navigationQueryExpression.NavigationParentID);
              else
              sqlCommand.Parameters.AddWithValue("@navigationParentID", DBNull.Value);
            
                  if(navigationQueryExpression.CreateBy.HasValue)
                
              sqlCommand.Parameters.AddWithValue("@createBy", navigationQueryExpression.CreateBy);
              else
              sqlCommand.Parameters.AddWithValue("@createBy", DBNull.Value);
            
                  if(navigationQueryExpression.CreateDate.HasValue)
                
              sqlCommand.Parameters.AddWithValue("@createDate", navigationQueryExpression.CreateDate);
              else
              sqlCommand.Parameters.AddWithValue("@createDate", DBNull.Value);
            
                  if(navigationQueryExpression.ModifyBy.HasValue)
                
              sqlCommand.Parameters.AddWithValue("@modifyBy", navigationQueryExpression.ModifyBy);
              else
              sqlCommand.Parameters.AddWithValue("@modifyBy", DBNull.Value);
            
                  if(navigationQueryExpression.ModifyDate.HasValue)
                
              sqlCommand.Parameters.AddWithValue("@modifyDate", navigationQueryExpression.ModifyDate);
              else
              sqlCommand.Parameters.AddWithValue("@modifyDate", DBNull.Value);
            


        sqlCommand.ExecuteNonQuery();
        }
        }

        
              if(navigationQueryExpression.relatedNavigationQueryExpressionChild != null
              && navigationQueryExpression.relatedNavigationQueryExpressionChild.Count > 0)
              {
              NavigationQueryExpressionDataMapper dataMapper = new NavigationQueryExpressionDataMapper(Database);

              foreach(NavigationQueryExpression item in navigationQueryExpression.relatedNavigationQueryExpressionChild)
              dataMapper.save(item);
              }
            

        raiseAffected(navigationQueryExpression,DataMapperOperation.update);
        
    
        return registerRecord(navigationQueryExpression);

    }

  
    }
    
  
      }