public void GetStatistics(out DBInt RegisterUserCount,
                       out DBInt RegisterOrganisationCount,
                       out DBInt PendingQuestionFormCount)
 {
     TraceCallEnterEvent.Raise();
       try
       {
     RegisterUserCount = new DBInt();
     RegisterOrganisationCount = new DBInt();
     PendingQuestionFormCount = new DBInt();
     DataSet entitySet = m_DataContext.ndihdGetStatistics();
     if (entitySet.Tables[0].Rows.Count == 1)
     {
       DataRow dr = entitySet.Tables[0].Rows[0];
       RegisterUserCount.Value = dr["nRegisterUserCount"];
       RegisterOrganisationCount.Value = dr["nRegisterOrganisationCount"];
       PendingQuestionFormCount.Value = dr["nPendingQuestionFormCount"];
     }
     TraceCallReturnEvent.Raise();
     //return result;
       }
       catch (Exception ex)
       {
     ExceptionManager.Publish(ex);
     TraceCallReturnEvent.Raise(false);
     throw;
       }
 }

 public virtual void DeleteChildrenByDistrictSearchCodeOfOrganisation(DBInt DistrictSearchCodeVal)
 {
     TraceCallEnterEvent.Raise();
       try
       {
     m_DataContext.BeginNestedTran();
     try
     {
       m_DataContext.ndihdDistrictSearchCodeOfOrganisationDeleteBy(DistrictSearchCodeVal);
       m_DataContext.CommitNested();
     }
     catch
     {
       m_DataContext.RollbackNested();
       throw;
     }
     TraceCallReturnEvent.Raise();
     return;
       }
       catch (Exception ex)
       {
     ExceptionManager.Publish(ex);
     TraceCallReturnEvent.Raise(false);
     throw;
       }
 }

 // -------------------------------------------------------------------------------------
 /// <summary>
 /// Primary key based constructor
 /// </summary>
 /// <param name="EventIDVal">Value of 'nEventID' field</param>
 /// <param name="NameVal">Value of 'cName' field</param>
 // -------------------------------------------------------------------------------------
 public EventPropertyBase(DBInt EventIDVal,
                      DBString NameVal)
 {
     ResetExceptions();
       m_EventID = EventIDVal;
       m_Name = NameVal;
 }

 public virtual void DeleteChildrenByEventProperty(DBInt IDVal)
 {
     TraceCallEnterEvent.Raise();
       try
       {
     m_DataContext.BeginNestedTran();
     try
     {
       m_DataContext.ndihdEventPropertyDeleteBy(IDVal);
       m_DataContext.CommitNested();
     }
     catch
     {
       m_DataContext.RollbackNested();
       throw;
     }
     TraceCallReturnEvent.Raise();
     return;
       }
       catch (Exception ex)
       {
     ExceptionManager.Publish(ex);
     TraceCallReturnEvent.Raise(false);
     throw;
       }
 }

        public frmSystemLogEdit(DBInt ID)
        {
            // Required for Windows Form Designer support
              InitializeComponent();

              CurrentID = ID;
        }

 // -------------------------------------------------------------------------------------
 /// <summary>
 /// Primary key based constructor
 /// </summary>
 /// <param name="TemplateRefVal">Value of 'uTemplateRef' field</param>
 /// <param name="PageIndexVal">Value of 'nPageIndex' field</param>
 // -------------------------------------------------------------------------------------
 public TemplatePageBase(DBGuid TemplateRefVal,
                     DBInt PageIndexVal)
 {
     ResetExceptions();
       m_TemplateRef = TemplateRefVal;
       m_PageIndex = PageIndexVal;
 }

        public KefWebDataContainer KefCategoryOfKefWebDataSelectByIsActive(string KefCategoryRef, DBInt IsActive)
        {
            TraceCallEnterEvent.Raise();
              try
              {
            KefWebDataContainer result;

            DataSet entitySet = m_DataContext.ndihdKefCategoryOfKefWebDataSelectByIsActive(KefCategoryRef, IsActive);
            result = new KefWebDataContainer(entitySet.Tables[0]);

            TraceCallReturnEvent.Raise();
            return result;
              }
              catch (Exception ex)
              {
            ExceptionManager.Publish(ex);
            TraceCallReturnEvent.Raise(false);
            throw;
              }
        }

 public void AddEventProperty(DBInt nEventID, DBString cName, DBString cValue, out int retVal)
 {
     SqlCommand command1 = base.PrepareSPCall("aeAddEventProperty");
       SqlParameter parameter1 = command1.Parameters.Add("@RETURNVALUE", SqlDbType.Int);
       parameter1.Direction = ParameterDirection.ReturnValue;
       SqlParameter parameter2 = command1.Parameters.Add("@nEventID", SqlDbType.Int);
       parameter2.Value = nEventID.Value;
       SqlParameter parameter3 = command1.Parameters.Add("@cName", SqlDbType.VarChar, 0x20);
       parameter3.Value = cName.Value;
       SqlParameter parameter4 = command1.Parameters.Add("@cValue", SqlDbType.VarChar, 0xfa0);
       parameter4.Value = cValue.Value;
       try
       {
     command1.ExecuteNonQuery();
       }
       finally
       {
     base.FinishSPCall();
       }
       retVal = (int) parameter1.Value;
 }

   public DataSet ndihdEDocumentSelectDispsetTop(DBGuid uCategoryRef,
 DBString cTypeRef,
 DBInt nShowMaxCount,
 out int retVal)
   {
       TraceCallEnterEvent.Raise();
         SqlCommand sqlComm = PrepareSPCall("[dbo].[ndihdEDocumentSelectDispsetTop]");
         SqlParameter returnValue = sqlComm.Parameters.Add("@RETURNVALUE", SqlDbType.Int);
         returnValue.Direction = ParameterDirection.ReturnValue;
         SqlParameter p1 = sqlComm.Parameters.Add("@uCategoryRef", SqlDbType.UniqueIdentifier);
         p1.Value = uCategoryRef.Value;
         SqlParameter p2 = sqlComm.Parameters.Add("@cTypeRef", SqlDbType.Char, 10);
         p2.Value = cTypeRef.Value;
         SqlParameter p3 = sqlComm.Parameters.Add("@nShowMaxCount", SqlDbType.Int);
         p3.Value = nShowMaxCount.Value;
         TraceDbCommandEvent.Raise(sqlComm);
         DataSet Result = new DataSet();
         try
         {
       SqlDataAdapter sqlAdapt = new SqlDataAdapter(sqlComm);
       sqlAdapt.Fill(Result);
       TraceCallReturnEvent.Raise();
         }
         catch (SqlException e)
         {
       TraceCallReturnEvent.Raise(false);
       SqlErrorHandler.Handle(e, uCategoryRef.ToString());
         }
         finally
         {
       FinishSPCall();
         }
         retVal = (int)returnValue.Value;
         TraceInfoEvent.Raise("RetVal: {0}", retVal);
         return Result;
   }

   public void ndihdQualificationUpdate(DBString cID,
 DBString cName,
 bool bIsActive,
 DBInt nOrder,
 out int retVal)
   {
       TraceCallEnterEvent.Raise();
         SqlCommand sqlComm = PrepareSPCall("[dbo].[ndihdQualificationUpdate]");
         SqlParameter returnValue = sqlComm.Parameters.Add("@RETURNVALUE", SqlDbType.Int);
         returnValue.Direction = ParameterDirection.ReturnValue;
         SqlParameter p1 = sqlComm.Parameters.Add("@cID", SqlDbType.Char, 10);
         p1.Value = cID.Value;
         SqlParameter p2 = sqlComm.Parameters.Add("@cName", SqlDbType.VarChar, 250);
         p2.Value = cName.Value;
         SqlParameter p3 = sqlComm.Parameters.Add("@bIsActive", SqlDbType.Bit);
         p3.Value = bIsActive;
         SqlParameter p4 = sqlComm.Parameters.Add("@nOrder", SqlDbType.Int);
         p4.Value = nOrder.Value;
         TraceDbCommandEvent.Raise(sqlComm);
         try
         {
       sqlComm.ExecuteNonQuery();
       TraceCallReturnEvent.Raise();
         }
         catch (SqlException e)
         {
       TraceCallReturnEvent.Raise(false);
       SqlErrorHandler.Handle(e, cID.ToString());
         }
         finally
         {
       FinishSPCall();
         }
         retVal = (int)returnValue.Value;
         TraceInfoEvent.Raise("RetVal: {0}", retVal);
   }

 // -------------------------------------------------------------------------------------
 /// <summary>
 /// XmlNode setup constructor
 /// </summary>
 /// <param name="node">XmlNode containing document data.</param>
 // -------------------------------------------------------------------------------------
 public TemplateDetailBase(XmlNode node)
 {
     m_ID = new DBString(node.Attributes["ID"]);
       m_TemplateRef = new DBGuid(node.Attributes["TemplateRef"]);
       m_Question = new DBString(node.SelectSingleNode("Question"));
       m_DataType = new DBString(node.SelectSingleNode("DataType"));
       m_Layout = new DBString(node.SelectSingleNode("Layout"));
       m_Constraint = new DBString(node.SelectSingleNode("Constraint"));
       m_ItemList = new DBString(node.SelectSingleNode("ItemList"));
       m_Description = new DBString(node.SelectSingleNode("Description"));
       m_Order = new DBInt(node.SelectSingleNode("Order"));
       m_PageIndex = new DBInt(node.SelectSingleNode("PageIndex"));
       m_IsActive = Convert.ToBoolean(node.SelectSingleNode("IsActive").InnerText);
       m_IsFilterCondition = Convert.ToBoolean(node.SelectSingleNode("IsFilterCondition").InnerText);
 }

 // -------------------------------------------------------------------------------------
 /// <summary>
 /// Copy constructor.
 /// </summary>
 /// <param name="TemplateRefVal">Value of 'uTemplateRef' field</param>
 /// <param name="PageIndexVal">Value of 'nPageIndex' field</param>
 /// <param name="origInstance">Original document data to copy.</param>
 // -------------------------------------------------------------------------------------
 public TemplatePage(DBGuid TemplateRefVal,
                 DBInt PageIndexVal,
                 TemplatePage origInstance)
     : base(TemplateRefVal, PageIndexVal, origInstance)
 {
 }

 // -------------------------------------------------------------------------------------
 /// <summary>
 /// Copy constructor.
 /// </summary>
 /// <param name="DistrictSearchCodeVal">Value of 'nDistrictSearchCode' field</param>
 /// <param name="origInstance">Original document data to copy.</param>
 // -------------------------------------------------------------------------------------
 public DistrictSearch(DBInt DistrictSearchCodeVal,
                   DistrictSearch origInstance)
     : base(DistrictSearchCodeVal, origInstance)
 {
 }

 // -------------------------------------------------------------------------------------
 /// <summary>
 /// XmlNode setup constructor
 /// </summary>
 /// <param name="node">XmlNode containing document data.</param>
 // -------------------------------------------------------------------------------------
 public JobOfferBase(XmlNode node)
 {
     m_ID = new DBGuid(node.Attributes["ID"]);
       m_RefId = new DBInt(node.SelectSingleNode("RefId"));
       m_Description = new DBString(node.SelectSingleNode("Description"));
       m_Message = new DBString(node.SelectSingleNode("Message"));
       m_Requirements = new DBString(node.SelectSingleNode("Requirements"));
       m_City = new DBString(node.SelectSingleNode("City"));
       m_RegionRef = new DBString(node.SelectSingleNode("RegionRef"));
       m_Status = new DBString(node.SelectSingleNode("Status"));
       m_QualificationMinRef = new DBString(node.SelectSingleNode("QualificationMinRef"));
       m_IdealEmployee = new DBString(node.SelectSingleNode("IdealEmployee"));
       m_ActivityPrevention = Convert.ToBoolean(node.SelectSingleNode("ActivityPrevention").InnerText);
       m_ActivityResearch = Convert.ToBoolean(node.SelectSingleNode("ActivityResearch").InnerText);
       m_ActivityRehabilitation = Convert.ToBoolean(node.SelectSingleNode("ActivityRehabilitation").InnerText);
       m_ActivityOther = Convert.ToBoolean(node.SelectSingleNode("ActivityOther").InnerText);
       m_EmployeeCount = new DBInt(node.SelectSingleNode("EmployeeCount"));
       m_FreeEmployeeCount = new DBInt(node.SelectSingleNode("FreeEmployeeCount"));
       m_HomePage = new DBString(node.SelectSingleNode("HomePage"));
       m_ContactName = new DBString(node.SelectSingleNode("ContactName"));
       m_ContactPhone = new DBString(node.SelectSingleNode("ContactPhone"));
       m_ContactEmail = new DBString(node.SelectSingleNode("ContactEmail"));
       m_Sender = new DBString(node.SelectSingleNode("Sender"));
       m_NotificationSend = Convert.ToBoolean(node.SelectSingleNode("NotificationSend").InnerText);
       m_NotificationDate = new DBDateTime(node.SelectSingleNode("NotificationDate"));
       m_Expiredate = new DBDateTime(node.SelectSingleNode("Expiredate"));
       m_LastModified = new DBDateTime(node.SelectSingleNode("LastModified"));
       m_Created = new DBDateTime(node.SelectSingleNode("Created"));
 }

 public EDocumentCategoryContainer EDocumentCategorySelectFiltered(DBString cName,
                                                               DBString cType, DBInt isActive)
 {
     TraceCallEnterEvent.Raise();
       try
       {
     if (isActive == null)
     {
       isActive = DBInt.Null;
     }
     EDocumentCategoryContainer result;
     DataSet entitySet = m_DataContext.ndihdEDocumentCategorySelectFiltered(cName, cType, isActive);
     result = new EDocumentCategoryContainer(entitySet.Tables[0]);
     TraceCallReturnEvent.Raise();
     return result;
       }
       catch (Exception ex)
       {
     ExceptionManager.Publish(ex);
     TraceCallReturnEvent.Raise(false);
     throw;
       }
 }

        public DataTable KefOrgOfOrgSelectFiltered(DBGuid OrganisationID, DBInt IsActive)
        {
            TraceCallEnterEvent.Raise();
              try
              {
            DataSet entitySet = m_DataContext.ndihdKefOrgOfOrgSelectFiltered(OrganisationID, IsActive);

            TraceCallReturnEvent.Raise();

            return entitySet.Tables[0];
              }
              catch (Exception ex)
              {
            ExceptionManager.Publish(ex);
            TraceCallReturnEvent.Raise(false);
            throw;
              }
        }

        // -------------------------------------------------------------------------------------
        /// <summary>
        /// Pages DataGrid
        /// </summary>
        // -------------------------------------------------------------------------------------
        private void FillPagesGrid(DBInt PageID)
        {
            try
              {
            string sortColumn = "PageIndex";
            int selectedRow = -1;

            // storing the previous sort order
            if (dtgPages.DataSource != null)
            {
              sortColumn = ((DataTable) dtgPages.DataSource).DefaultView.Sort;
            }

            // retrieving data
            DataTable dt = m_Template.Pages.CurrentAsDatatable;
            dt.DefaultView.Sort = sortColumn;
            dtgPages.DataSource = dt;

            // locates the row specified by ID param
            if (!PageID.IsNull)
            {
              BindingManagerBase bm = dtgDetails.BindingContext[dtgPages.DataSource, dtgPages.DataMember];
              DataRow dr;
              for (int i = 0; i < bm.Count; i++)
              {
            dr = ((DataRowView) bm.Current).Row;
            if (PageID.Equals(Convert.ToInt32(dr["PageIndex"])))
            {
              selectedRow = i;
              break;
            }
            bm.Position += 1;
              }
            }

            // makes the row selected
            if (selectedRow <= ((DataTable) dtgPages.DataSource).DefaultView.Count && selectedRow > -1)
            {
              dtgPages.Select(selectedRow);
              dtgPages.CurrentRowIndex = selectedRow;
            }
            else if (((DataTable) dtgPages.DataSource).DefaultView.Count != 0)
            {
              dtgPages.Select(0);
            }

            btnPageModify.Enabled = (((DataTable) dtgPages.DataSource).DefaultView.Count != 0);
            btnPageDelete.Enabled = (((DataTable) dtgPages.DataSource).DefaultView.Count != 0);
            btnNewDetail.Enabled = (((DataTable) dtgPages.DataSource).DefaultView.Count != 0);
              }
              catch (Exception ex)
              {
            //	---	Log exception
            ExceptionManager.Publish(ex);
            //	---	Display Exception
            ErrorHandler.DisplayError("Hiba az adatok lekérdezése során", ex);
              }
        }

 // -------------------------------------------------------------------------------------
 /// <summary>
 /// Copy constructor.
 /// </summary>
 /// <param name="IDVal">Value of 'uID' field</param>
 /// <param name="origInstance">Original document data to copy.</param>
 // -------------------------------------------------------------------------------------
 public JobFindBase(DBGuid IDVal,
                JobFindBase origInstance)
     : base()
 {
     m_ID = IDVal;
       m_RefId = origInstance.m_RefId;
       m_Description = origInstance.m_Description;
       m_City = origInstance.m_City;
       m_RegionRef = origInstance.m_RegionRef;
       m_Status = origInstance.m_Status;
       m_ActivityPrevention = origInstance.m_ActivityPrevention;
       m_ActivityResearch = origInstance.m_ActivityResearch;
       m_ActivityRehabilitation = origInstance.m_ActivityRehabilitation;
       m_ActivityOther = origInstance.m_ActivityOther;
       m_Sender = origInstance.m_Sender;
       m_NotificationSend = origInstance.m_NotificationSend;
       m_NotificationDate = origInstance.m_NotificationDate;
       m_Expiredate = origInstance.m_Expiredate;
       m_LastModified = origInstance.m_LastModified;
       m_Created = origInstance.m_Created;
 }

 // -------------------------------------------------------------------------------------
 /// <summary>
 /// Copy constructor.
 /// </summary>
 /// <param name="IDVal">Value of 'uID' field</param>
 /// <param name="origInstance">Original document data to copy.</param>
 // -------------------------------------------------------------------------------------
 public ProgramAttachmentBase(DBGuid IDVal,
                          ProgramAttachmentBase origInstance)
 {
     m_ID = IDVal;
       m_ProgramRef = origInstance.m_ProgramRef;
       m_Path = origInstance.m_Path;
       m_Name = origInstance.m_Name;
       m_Description = origInstance.m_Description;
       m_Author = origInstance.m_Author;
       m_Publisher = origInstance.m_Publisher;
       m_PublishedYear = origInstance.m_PublishedYear;
       m_Keywords = origInstance.m_Keywords;
       m_CreatedDate = origInstance.m_CreatedDate;
       m_FileSize = origInstance.m_FileSize;
       m_IsActive = origInstance.m_IsActive;
 }

   // -------------------------------------------------------------------------------------
   /// <summary>
   /// Copy constructor.
   /// </summary>
   /// <param name="IDVal">Value of 'uID' field</param>
   /// <param name="origInstance">Original document data to copy.</param>
   // -------------------------------------------------------------------------------------
   public DesignerDrogAttachmentBase(DBGuid IDVal,
 DesignerDrogAttachmentBase origInstance)
       : base()
   {
       this.m_ID = IDVal;
         this.m_ItemRef = origInstance.m_ItemRef;
         this.m_Path = origInstance.m_Path;
         this.m_Name = origInstance.m_Name;
         this.m_Description = origInstance.m_Description;
         this.m_CreatedDate = origInstance.m_CreatedDate;
         this.m_FileSize = origInstance.m_FileSize;
         this.m_IsActive = origInstance.m_IsActive;
   }