Exemple #1
0
        public override CResultAErreur TraitementAvantSauvegarde(sc2i.data.CContexteDonnee contexte)
        {
            CResultAErreur result = base.TraitementAvantSauvegarde(contexte);

            if (!result)
            {
                return(result);
            }
            DataTable table = contexte.Tables[GetNomTable()];

            if (table == null)
            {
                return(result);
            }
            ArrayList lst = new ArrayList(table.Rows);

            foreach (DataRow row in new ArrayList(table.Rows))
            {
                if (row.RowState == DataRowState.Added)
                {
                    C2iMail          mail      = new C2iMail(row);
                    CTracabiliteMail traceMail = new CTracabiliteMail(contexte);
                    if (!traceMail.ReadIfExists(new CFiltreData(
                                                    CTracabiliteMail.c_champMessageUid + " = @1", mail.MessageId)))
                    {
                        traceMail.CreateNewInCurrentContexte();
                        traceMail.MessageUid    = mail.MessageId;
                        traceMail.DateReception = mail.DateReception;
                        traceMail.CompteMail    = mail.CompteMail;
                    }
                }
            }

            return(result);
        }
        //---------------------------------------------
        public override object[] GetObjets(CNodeConsultationHierarchique nodeParent, sc2i.data.CContexteDonnee contexteDonnee)
        {
            List <CSchemaReseau> lstCablages = new List <CSchemaReseau>();

            CSite site = m_schemaCablage.SiteApparenance;

            if (site != null)
            {
                CSchemaReseau schemaParent = m_schemaCablage.SchemaParent;
                if (schemaParent != null)
                {
                    IEnumerable <CLienReseau> lstLiens =
                        from elt in schemaParent.GetElementsForType <CLienReseau>()
                        where elt.LienReseau.Site1 == site || elt.LienReseau.Site2 == site
                        select elt.LienReseau;

                    foreach (CLienReseau lien in lstLiens)
                    {
                        CSchemaReseau schema = lien.SchemaReseau;
                        if (schema != null)
                        {
                            foreach (CSchemaReseau sche in schema.SchemaFils)
                            {
                                if (sche.SiteApparenance == site)
                                {
                                    lstCablages.Add(sche);
                                }
                            }
                        }
                    }
                }
            }

            return(lstCablages.ToArray());
        }
Exemple #3
0
        /// //////////////////////////////////////////////////
        public override CResultAErreur TraitementApresSauvegarde(sc2i.data.CContexteDonnee contexte, bool bOperationReussie)
        {
            CResultAErreur result = CResultAErreur.True;

            result = base.TraitementApresSauvegarde(contexte, bOperationReussie);
            if (!result)
            {
                return(result);
            }
            DataTable      table = contexte.Tables[GetNomTable()];
            List <DataRow> lstRowsEtapesADemarrer = table == null ? null : table.ExtendedProperties[c_constEtapesADemarre] as List <DataRow>;

            if (lstRowsEtapesADemarrer != null && lstRowsEtapesADemarrer.Count > 0)
            {
                int?           nIdSessionMain = IdSession;
                CDbKey         keyUtilisateur = null;
                CSessionClient session        = CSessionClient.GetSessionForIdSession(IdSession);
                if (session != null)
                {
                    IInfoUtilisateur info = session.GetInfoUtilisateur();
                    //TESTDBKEYOK
                    if (info != null)
                    {
                        keyUtilisateur = info.KeyUtilisateur;
                    }
                    CSousSessionClient sousSession = session as CSousSessionClient;
                    if (sousSession != null)
                    {
                        nIdSessionMain = sousSession.RootSession.IdSession;
                    }
                }
                List <CParametresStartEtapeInPile> lstToStart = new List <CParametresStartEtapeInPile>();
                foreach (DataRow row in lstRowsEtapesADemarrer)
                {
                    //Ancien mode, avant 13/9/2013
                    //RunEtapeInThread ( (int)row[CEtapeWorkflow.c_champId]);
                    //TESTDBKEYOK
                    lstToStart.Add(new CParametresStartEtapeInPile(
                                       nIdSessionMain, (int)row[CEtapeWorkflow.c_champId], keyUtilisateur));
                }
                CPileExecutionEtapes.AddEtapesADemarrer(lstToStart.ToArray());
            }
            return(result);
        }
Exemple #4
0
        //---------------------------------------------
        public override object[] GetObjets(CNodeConsultationHierarchique nodeParent, sc2i.data.CContexteDonnee contexteDonnee)
        {
            if (m_formuleObjets == null)
            {
                return(new object[0]);
            }
            CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(nodeParent);
            CResultAErreur result             = m_formuleObjets.Eval(ctx);
            IEnumerable    en        = result.Data as IEnumerable;
            ArrayList      lstObjets = new ArrayList();

            if (en != null)
            {
                foreach (object obj in en)
                {
                    lstObjets.Add(obj);
                }
            }
            else if (result.Data != null)
            {
                lstObjets.Add(result.Data);
            }
            return(lstObjets.ToArray());
        }
Exemple #5
0
        /// //////////////////////////////////////////////////
        public override CResultAErreur TraitementAvantSauvegarde(sc2i.data.CContexteDonnee contexte)
        {
            CResultAErreur result = base.TraitementAvantSauvegarde(contexte);

            if (!result)
            {
                return(result);
            }



            DataTable table = contexte.Tables[GetNomTable()];

            if (table == null)
            {
                return(result);
            }

            //Stocke la liste des étapes pour lesquelles le traitement a déjà été fait dans cette sauvegarde
            //Pour éviter que plusieurs appels à TraitementAvantSauvegarde ne déclenche plusieurs fois la même étape !
            HashSet <int> lstEtapesTraitees = table.ExtendedProperties[c_constEtapesTraitees] as HashSet <int>;

            if (lstEtapesTraitees == null)
            {
                lstEtapesTraitees = new HashSet <int>();
                table.ExtendedProperties[c_constEtapesTraitees] = lstEtapesTraitees;
            }

            CEtapeWorkflow etape = null;

            bool bHasLancéDesEtapes = true;

            ArrayList lst;

            do
            {
                bHasLancéDesEtapes = false;
                lst = new ArrayList(table.Rows);
                //Identifie les étapes terminées et lance la suite
                foreach (DataRow rowTerminee in lst)
                {
                    if (rowTerminee.RowState == DataRowState.Modified)
                    {
                        etape = new CEtapeWorkflow(rowTerminee);
                        if (!lstEtapesTraitees.Contains(etape.Id))
                        {
                            etape.VersionToReturn = DataRowVersion.Original;
                            EEtatEtapeWorkflow oldEtat = (EEtatEtapeWorkflow)etape.EtatCode;
                            etape.VersionToReturn = DataRowVersion.Current;
                            EEtatEtapeWorkflow etat = (EEtatEtapeWorkflow)etape.EtatCode;
                            if (etat == EEtatEtapeWorkflow.Terminée && oldEtat != EEtatEtapeWorkflow.Terminée)
                            {
                                lstEtapesTraitees.Add(etape.Id);
                                //Il faut lancer la suite de cette étape
                                result             = etape.Workflow.PrépareSuiteEtapeInCurrentContext(etape);
                                bHasLancéDesEtapes = true;
                            }
                        }
                    }
                }
            }while (bHasLancéDesEtapes);

            lst = new ArrayList(table.Rows);
            List <DataRow> lstEtapesADemarrer = table.ExtendedProperties[c_constEtapesADemarre] as List <DataRow>;

            if (lstEtapesADemarrer == null)
            {
                lstEtapesADemarrer = new List <DataRow>();
            }
            foreach (DataRow row in lst)
            {
                if (row.RowState == DataRowState.Added || row.RowState == DataRowState.Modified)
                {
                    etape = new CEtapeWorkflow(row);

                    if (etape.DateDebut != null && etape.DateFin == null &&
                        etape.EtatCode == (int)EEtatEtapeWorkflow.ADemarrer)
                    {
                        if (!lstEtapesTraitees.Contains(etape.Id))
                        {
                            lstEtapesTraitees.Add(etape.Id);
                            //etape.EtatCode = (int)EEtatEtapeWorkflow.Démarrée;
                            lstEtapesADemarrer.Add(row);
                        }
                    }
                }
            }
            if (lstEtapesADemarrer.Count > 0)
            {
                table.ExtendedProperties[c_constEtapesADemarre] = lstEtapesADemarrer;
            }

            return(result);
        }
Exemple #6
0
 //---------------------------------------------
 public override object[] GetObjets(CNodeConsultationHierarchique nodeParent, sc2i.data.CContexteDonnee contexteDonnee)
 {
     return(new object[] { m_objetRacine });
 }