private void EditeElement()
        {
            CObjetDonneeAIdNumeriqueAuto objet = null;

            bool            bIsNewContexte = false;
            CContexteDonnee contexteDonnee = CSc2iWin32DataClient.ContexteCourant;

            if (m_parametreEdition.IdVersionAForcer != contexteDonnee.IdVersionDeTravail)
            {
                contexteDonnee = (CContexteDonnee)CSc2iWin32DataClient.ContexteCourant.Clone();// GetNewContexteDonneeInSameThread(m_parametreEdition.IdSession, true);
                contexteDonnee.SetEnableAutoStructure(true);
                contexteDonnee.SetVersionDeTravail(m_parametreEdition.IdVersionAForcer, false);
                bIsNewContexte = true;
            }
            objet = m_parametreEdition.ReferenceObjet.GetObjet(contexteDonnee) as CObjetDonneeAIdNumeriqueAuto;
            if (objet == null)
            {
                m_resultEdit.EmpileErreur(I.T("The object to edit doesn't exist|1078"));
                return;
            }

            CReferenceTypeForm refTypeForm = null;

            if (m_strCodeFormulaire != string.Empty)
            {
                refTypeForm = CFormFinder.GetRefFormToEdit(objet.GetType(), m_strCodeFormulaire);
            }
            else
            {
                refTypeForm = CFormFinder.GetRefFormToEdit(objet.GetType());
            }

            if (refTypeForm == null)
            {
                m_resultEdit.EmpileErreur(I.T("The system is not able to edit elements from type @1|1076", m_parametreEdition.GetType().ToString()));
                return;
            }

            try
            {
                CFormEditionStandard form = refTypeForm.GetForm(objet) as CFormEditionStandard;
                if (form != null)
                {
                    CFormNavigateurPopup.Show(form);//, CTimosApp.Navigateur);
                }
            }
            catch (Exception e)
            {
                m_resultEdit.EmpileErreur(new CErreurException(e));
            }
            finally
            {
                if (bIsNewContexte)
                {
                    contexteDonnee.Dispose();
                    contexteDonnee = null;
                }
            }
        }
Example #2
0
        //-------------------------------------------------------
        private bool ValideModifs()
        {
            if (!m_gestionnaireModeEdition.ModeEdition || m_contexteEnEdition == null)
            {
                return(false);
            }
            CResultAErreur result = m_contexteEnEdition.SaveAll(true);

            if (!result)
            {
                CFormAlerte.Afficher(result.Erreur);
                return(false);
            }
            m_contexteEnEdition.Dispose();
            m_contexteEnEdition = null;
            m_panelTop.SetContexteDonnee(m_contexteDonnee);
            return(true);
        }
Example #3
0
        /// //////////////////////////////////////////
        public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] valeursParametres)
        {
            CResultAErreur result = CResultAErreur.True;

            try
            {
                //TESTDBKEYOK
                CContexteDonnee contexte = (CContexteDonnee)ctx.GetObjetAttache(typeof(CContexteDonnee));
                CDbKey          key      = null;
                if (contexte != null)
                {
                    key = CSessionClient.GetSessionForIdSession(contexte.IdSession).GetInfoUtilisateur().KeyUtilisateur;
                }
                else
                {
                    key = CSessionClient.GetSessionUnique().GetInfoUtilisateur().KeyUtilisateur;
                }
                if (key != null)
                {
                    bool bNewContexte = false;
                    if (contexte == null)
                    {
                        if (ctx.ObjetSource is CObjetDonnee)
                        {
                            contexte = ((CObjetDonnee)ctx.ObjetSource).ContexteDonnee;
                        }
                        else
                        {
                            contexte     = CContexteDonneeSysteme.GetInstance();
                            bNewContexte = false;
                        }
                    }
                    CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(contexte);
                    if (user.ReadIfExists(key))
                    {
                        result.Data = user.Acteur;
                    }
                    else
                    {
                        result.Data = null;
                    }
                    if (bNewContexte)
                    {
                        contexte.Dispose();
                    }
                }
            }
            catch
            {
                result.Data = -1;
            }
            return(result);
        }
Example #4
0
        //-------------------------------------------------------------
        private CResultAErreur AppliqueFormule()
        {
            CResultAErreur result  = CResultAErreur.True;
            C2iExpression  formule = m_txtFormule.Formule;

            if (formule == null)
            {
                result = m_txtFormule.ResultAnalyse;
                return(result);
            }
            CContexteDonnee ctxOriginal = m_listeObjetsAAppliquer[0].ContexteDonnee;

            try
            {
                if (m_contexteModification != null)
                {
                    m_contexteModification.Dispose();
                    m_contexteModification = null;
                }
                m_contexteModification = ctxOriginal.GetContexteEdition();
                foreach (CObjetDonnee objet in m_listeObjetsAAppliquer)
                {
                    if (objet != null)
                    {
                        CObjetDonnee objetModif           = objet.GetObjetInContexte(m_contexteModification);
                        CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(objetModif);
                        result = formule.Eval(ctx);
                        if (!result)
                        {
                            result.EmpileErreur(I.T("Error while applying formula on @1|20093", objetModif.DescriptionElement));
                            return(result);
                        }
                        else
                        {
                            m_txtResult.Text += "-----------------------------------";
                            m_txtResult.Text += Environment.NewLine;
                            m_txtResult.Text += objetModif.DescriptionElement + "->";
                            m_txtResult.Text += result.Data != null?result.Data.ToString() : "NULL";

                            m_txtResult.Text += Environment.NewLine;
                        }
                    }
                }
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
            }
            return(result);
        }
Example #5
0
 /// ///////////////////////////////////////////////////////////
 public static void session_OnCloseSession(object sender, EventArgs e)
 {
     if (sender is CSessionClient)
     {
         CSessionClient session = (CSessionClient)sender;
         try
         {
             CContexteDonnee contexte = (CContexteDonnee)m_tableContextesDonneesParSessions[session.IdSession];
             contexte.Dispose();
         }
         catch {}
         m_tableContextesDonneesParSessions[session.IdSession] = null;
     }
 }
        //------------------------------------------------------
        public void InitForObjet(CObjetDonneeAIdNumerique objet, CVersionDonnees version)
        {
            CSessionClient   session = CSessionClient.GetSessionForIdSession(objet.ContexteDonnee.IdSession);
            IInfoUtilisateur info    = session.GetInfoUtilisateur();

            if (info != null)
            {
                m_bCanRestore = info.GetDonneeDroit(CDroitDeBaseSC2I.c_droitAdministration) != null;
            }
            m_bCanRestore         &= version != null && version.TypeVersion.Code == CTypeVersion.TypeVersion.Archive;
            m_panelRestore.Visible = m_bCanRestore;

            if (m_contexteDonnees != null)
            {
                m_contexteDonnees.Dispose();
            }
            m_tableValeurs.Clear();
            m_objetDepart = null;
            m_version     = null;
            m_arbreObjet.Nodes.Clear();
            if (objet == null || version == null)
            {
                return;
            }
            m_contexteDonnees = new CContexteDonnee(objet.ContexteDonnee.IdSession, true, false);
            m_contexteDonnees.SetVersionDeTravail(-1, false);            //Travaille sur toutes les versions
            m_objetDepart = (CObjetDonneeAIdNumerique)m_contexteDonnees.GetObjetInThisContexte(objet);
            m_version     = (CVersionDonnees)m_contexteDonnees.GetObjetInThisContexte(version);

            List <int> lstIds = new List <int>();

            if (m_version.TypeVersion.Code == CTypeVersion.TypeVersion.Previsionnelle)
            {
                CVersionDonnees verTmp = m_version.VersionParente;
                while (verTmp != null)
                {
                    lstIds.Add(verTmp.Id);
                    verTmp = verTmp.VersionParente;
                }
            }
            m_nIdsVersionsSuccessives = lstIds.ToArray();

            CreateNodeObjet(m_arbreObjet.Nodes, m_objetDepart);
        }
 /// ///////////////////////////////////////////////////////////
 public static void session_OnCloseSession(object sender, EventArgs e)
 {
     if (sender is CSessionClient)
     {
         CSessionClient session = (CSessionClient)sender;
         try
         {
             CContexteDonnee contexte = null;
             if (m_tableContextesDonneesParSessions.TryGetValue(session.IdSession, out contexte))
             {
                 contexte.Dispose();
             }
         }
         catch { }
         if (m_tableContextesDonneesParSessions.ContainsKey(session.IdSession))
         {
             m_tableContextesDonneesParSessions.Remove(session.IdSession);
         }
     }
 }
Example #8
0
 //------------------------------------------
 private void m_picBox_DragDrop(object sender, DragEventArgs e)
 {
     CReferenceObjetDonnee[] refs = e.Data.GetData(typeof(CReferenceObjetDonnee[])) as CReferenceObjetDonnee[];
     if (refs == null)
     {
         CReferenceObjetDonnee refe = e.Data.GetData(typeof(CReferenceObjetDonnee)) as CReferenceObjetDonnee;
         if (refe != null)
         {
             refs = new CReferenceObjetDonnee[] { refe };
         }
     }
     if (refs != null)
     {
         List <CBesoin> lstBesoins = new List <CBesoin>();
         StringBuilder  blListe    = new StringBuilder();
         foreach (CReferenceObjetDonnee refO in refs)
         {
             if (typeof(CBesoin).IsAssignableFrom(refO.TypeObjet))
             {
                 CBesoin besoin = refO.GetObjet(m_satisfaction.ContexteDonnee) as CBesoin;
                 if (besoin != null)
                 {
                     if (m_satisfaction.CanSatisfaire(besoin))
                     {
                         lstBesoins.Add(besoin);
                         blListe.Append(besoin.Libelle);
                         blListe.Append(" ,");
                     }
                 }
             }
         }
         if (lstBesoins.Count > 0)
         {
             blListe.Remove(blListe.Length - 2, 2);
             if (MessageBox.Show(I.T("@1 will be considered as a solution of @2. Continue ?|20631",
                                     m_satisfaction.Libelle, blListe.ToString()), "",
                                 MessageBoxButtons.YesNo,
                                 MessageBoxIcon.Question) == DialogResult.Yes)
             {
                 CContexteDonnee ctx = m_satisfaction.ContexteDonnee;
                 if (!m_bIsEnEdition)
                 {
                     ctx = ctx.GetContexteEdition();
                 }
                 foreach (CBesoin besoin in lstBesoins)
                 {
                     CBesoin besoinEdit = besoin.GetObjetInContexte(ctx) as CBesoin;
                     besoinEdit.AddSatisfaction(m_satisfaction, null);
                 }
                 if (!m_bIsEnEdition)
                 {
                     CResultAErreur result = ctx.CommitEdit();
                     if (!result)
                     {
                         CFormAlerte.Afficher(result.Erreur);
                         ctx.CancelEdit();
                     }
                     ctx.Dispose();
                 }
             }
         }
     }
 }