public virtual void TemplatePageDelete(TemplatePage entity)
 {
     TraceCallEnterEvent.Raise();
       try
       {
     m_DataContext.BeginNestedTran();
     try
     {
       m_DataContext.ndihdTemplatePageDelete(entity.TemplateRef,
                                         entity.PageIndex);
       m_DataContext.CommitNested();
     }
     catch
     {
       m_DataContext.RollbackNested();
       throw;
     }
     TraceCallReturnEvent.Raise();
     return;
       }
       catch (Exception ex)
       {
     ExceptionManager.Publish(ex);
     TraceCallReturnEvent.Raise(false);
     throw;
       }
 }
Пример #2
0
        private void IncreasePageIndex(int pageIndex)
        {
            ITemplatePageService srv = ServiceFactory.GetTemplatePageService();
              int topIndex = 0;

              for (topIndex = m_Template.Pages.CurrentCount; topIndex >= pageIndex; topIndex--)
              {
            //töröljük és létrehozunk egyel nagyobb indexet
            string hash = m_CurrentTemplateID.ToString() + "<#>" + topIndex.ToString();

            TemplatePage prev = (TemplatePage) m_Template.Pages[hash];

            //ha nincs a töröltek közt akkor beszúrjuk
            TemplatePage act = new TemplatePage(m_CurrentTemplateID, topIndex + 1);
            act.Name = prev.Name;

            //töröljük a régit
            m_Template.Pages.Delete(prev);

            //beszúrjuk az aktuálisat
            if (IsInDeletedTemplatePage(act) == false)
            {
              m_Template.Pages.Add(act, DocumentState.Inserted);
            }

            //megnézzük hogy nem volt e a régihez hozzárendelve kérdés mert ha igen akkor azoknak is növelni kell a sorszámát
            foreach (TemplateDetail item in  m_Template.Details.All)
            {
              if (item.PageIndex == act.PageIndex - 1)
              {
            item.PageIndex++;
              }
            }

            FillDetailsGrid(DBString.Null);
              }
        }
Пример #3
0
        private void btnPageNew_Click(object sender, EventArgs e)
        {
            frmTemplatePageEdit frmNew = null;
              try
              {
            frmNew = new frmTemplatePageEdit(m_CurrentTemplateID, m_Template.Pages);
            DialogResult result = frmNew.ShowDialog();
            if (result == DialogResult.OK)
            {
              //megnézzük hogy a p.PageIndex ki van e töltve (nagyobb mint 0)
              if (frmNew.CurrentPage.PageIndex == 0)
              {
            //ha 0 akkor nem adott meg indexet tehát a lista végéhez adjuk
            TemplatePage act = new TemplatePage(m_CurrentTemplateID, m_Template.Pages.CurrentCount + 1);
            act.Name = frmNew.CurrentPage.Name;

            //ha nincs a töröltek közt akkor beszúrjuk
            if (IsInDeletedTemplatePage(act) == false)
            {
              m_Template.Pages.Add(act, DocumentState.Inserted);
            }
              }
              else
              {
            //meg kell nézni hogy nincs e már ilyen index
            foreach (TemplatePage p in m_Template.Pages.All)
            {
              if (p.PageIndex == frmNew.CurrentPage.PageIndex)
              {
                IncreasePageIndex(frmNew.CurrentPage.PageIndex);
                break;
              }
            }

            //ha nincs a töröltek közt akkor beszúrjuk
            if (IsInDeletedTemplatePage(frmNew.CurrentPage) == false)
            {
              m_Template.Pages.Add(frmNew.CurrentPage, DocumentState.Inserted);
            }
              }

              FillPagesGrid(frmNew.CurrentPage.PageIndex);
            }
              }
              catch (Exception ex)
              {
            //	---	Log exception
            ExceptionManager.Publish(ex);
            //	---	Display Exception
            ErrorHandler.DisplayError("Nem várt hiba történt az új lap felvétele során.", ex);
              }
              finally
              {
            if (frmNew != null) frmNew.Dispose();
              }
        }
Пример #4
0
        /// -----------------------------------------------------------------		
        /// <summary>
        /// Beszúrás elõtt meg kell nézni hogy a töröltek között nincs e már 
        /// egy pont ilyen ...
        /// </summary>
        /// -----------------------------------------------------------------		
        private bool IsInDeletedTemplatePage(TemplatePage t)
        {
            bool isInDeleted = false;

              foreach (TemplatePage item in m_Template.Pages.Deleted)
              {
            if (item.PageIndex == t.PageIndex)
            {
              item.Name = t.Name;
              m_Template.Pages.Undelete(item);
              isInDeleted = true;
              break;
            }
              }

              return isInDeleted;
        }
Пример #5
0
 // -------------------------------------------------------------------------------------
 /// <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)
 {
 }
Пример #6
0
 // -------------------------------------------------------------------------------------
 /// <summary>
 /// Copy constructor.
 /// </summary>
 /// <param name="origInstance">Original document data to copy.</param>
 // -------------------------------------------------------------------------------------
 public TemplatePage(TemplatePage origInstance)
     : base(origInstance)
 {
 }
Пример #7
0
        private void btnOk_Click(object sender, EventArgs e)
        {
            //megnézzük elõször hogy ha adott meg indexet akkor az benne van az intervallumban
              if ((txtPageIndex.Text != "") && (m_ExistingPages != null))
              {
            int pageIndex = Convert.ToInt32(txtPageIndex.Text);
            if (pageIndex > m_ExistingPages.All.Count + 1)
            {
              MessageBox.Show("Az index nem megfelelõ!", "NDI HelpDesk Adminisztrátor", MessageBoxButtons.OK,
                          MessageBoxIcon.Warning);
              txtPageIndex.Focus();
              txtPageIndex.SelectAll();
              DialogResult = DialogResult.None;
              return;
            }
              }

              //	---	Check input data
              bool isValidated = CheckData();
              if (!isValidated)
              {
            DialogResult = DialogResult.None;
            return;
              }

              // save data
              if (m_CurrentPage == null)
              {
            if (txtPageIndex.Text == "") txtPageIndex.Text = "0";

            // check existing pages:
            int pageIndex = Convert.ToInt32(txtPageIndex.Text);

            //létrehozzuk a kért indexxel
            m_CurrentPage = new TemplatePage(m_TemplateID, pageIndex);
              }
              m_CurrentPage.Name = txtPageName.Text;
              m_CurrentPage.IsActive = cbxActivate.Checked;
        }
Пример #8
0
 /// <summary>
 /// Edit constructor
 /// </summary>
 public frmTemplatePageEdit(TemplatePage page)
 {
     // Required for Windows Form Designer support
       InitializeComponent();
       m_CurrentPage = page;
 }
 public virtual void TemplatePageUpdate(TemplatePage entity)
 {
     TraceCallEnterEvent.Raise();
       try
       {
     m_DataContext.BeginNestedTran();
     try
     {
       int count;
       m_DataContext.ndihdTemplatePageUpdate(entity.TemplateRef,
                                         entity.PageIndex,
                                         entity.Name,
                                         entity.IsActive, out count);
       if (count == 0) throw new ServiceUpdateException();
       m_DataContext.CommitNested();
     }
     catch
     {
       m_DataContext.RollbackNested();
       throw;
     }
     TraceCallReturnEvent.Raise();
     return;
       }
       catch (Exception ex)
       {
     ExceptionManager.Publish(ex);
     TraceCallReturnEvent.Raise(false);
     throw;
       }
 }
 public virtual TemplatePage TemplatePageSelect(DBGuid TemplateRefVal,
                                            DBInt PageIndexVal)
 {
     TraceCallEnterEvent.Raise();
       try
       {
     TemplatePage result = null;
     DataSet entitySet = m_DataContext.ndihdTemplatePageSelect(TemplateRefVal,
                                                           PageIndexVal);
     if (entitySet.Tables[0].Rows.Count != 0)
     {
       result = new TemplatePage(entitySet);
     }
     TraceCallReturnEvent.Raise();
     return result;
       }
       catch (Exception ex)
       {
     ExceptionManager.Publish(ex);
     TraceCallReturnEvent.Raise(false);
     throw;
       }
 }