Beispiel #1
0
        /// <summary>
        /// Le data du result contient un CDonneeSession
        /// </summary>
        /// <returns></returns>
        private static CResultAErreur GetSession()
        {
            CResultAErreur result = CResultAErreur.True;

            lock (typeof(CLanceurProcessCommandLine))
            {
                foreach (CDonneeSessionProcess donneeSession in m_poolSessions)
                {
                    if (!donneeSession.IsUsed)
                    {
                        donneeSession.StartUsing();
                        result.Data = donneeSession;
                        return(result);
                    }
                }
                CSessionProcessServeurSuivi session = new CSessionProcessServeurSuivi();
                result = session.OpenSession(new CAuthentificationSessionProcess(), "TimosProcess", ETypeApplicationCliente.Service);
                if (!result)
                {
                    result.Data = (int)EErreurs.ErrorWhileOpeningSession;
                    return(result);
                }
                CDonneeSessionProcess newDonneeSession = new CDonneeSessionProcess(session);
                newDonneeSession.StartUsing();
                m_poolSessions.Add(newDonneeSession);
                result.Data = newDonneeSession;
                return(result);
            }
        }
Beispiel #2
0
        /// ////////////////////////////////////////////////////////
        protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
        {
            CResultAErreur result = CResultAErreur.True;

            if (contexte.Branche.IsModeAsynchrone)              //On est déjà en asynchrone
            {
                return(result);
            }
            //Ouvre une nouvelle session
            CSessionProcessServeurSuivi session = new CSessionProcessServeurSuivi();

            result = session.OpenSession(new CAuthentificationSessionProcess(),
                                         I.T("Process @1|198", contexte.ProcessEnExecution.Libelle),
                                         CSessionClient.GetSessionForIdSession(contexte.ContexteDonnee.IdSession));
            if (!result)
            {
                result.EmpileErreur(I.T("Switch asynchronous mode failure|210"));
                return(result);
            }

            //Change l'id de session du contexte de travail
            contexte.ChangeIdSession(session.IdSession);

            if (GetLiensSortantHorsErreur().Length == 1)
            {
                result.Data = GetLiensSortantHorsErreur()[0];
            }
            return(result);
        }
Beispiel #3
0
        private static void OnTachePlanifiee(object state)
        {
            //14/12/2010 : si un traitement est en cours depuis plus de 24H, lance d'autres traitements
            TimeSpan sp = DateTime.Now - m_lastDateDebutTraitement;

            if (m_bTraitementEnCours && sp.TotalHours < 24)
            {
                return;
            }
            m_bTraitementEnCours      = true;
            m_lastDateDebutTraitement = DateTime.Now;
            try
            {
                System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Lowest;
                CResultAErreur result;
                if (m_sessionRecherche == null || !m_sessionRecherche.IsConnected)
                {
                    m_sessionRecherche = CSessionClient.CreateInstance();
                    result             = m_sessionRecherche.OpenSession(new CAuthentificationSessionServer(),
                                                                        I.T("Search of planned tasks|332"),
                                                                        ETypeApplicationCliente.Service);
                    if (!result)
                    {
                        C2iEventLog.WriteErreur(I.T("Session Opening error for planned tasks|333"));
                        return;
                    }
                }
                try
                {
                    CFiltreData filtre = new CFiltreData(CTachePlanifiee.c_champProchaineExecution + " < @1 and " +
                                                         CTachePlanifiee.c_champBloquer + "=@2",
                                                         DateTime.Now,
                                                         false
                                                         );
                    if (new CTachePlanifieeServeur(m_sessionRecherche.IdSession).CountRecords(
                            CTachePlanifiee.c_nomTable, filtre) > 0)
                    {
                        CSessionClient sessionTravail = new CSessionProcessServeurSuivi();
                        result = sessionTravail.OpenSession(new CAuthentificationSessionProcess(),
                                                            I.T("Planned Tasks execution|334"),
                                                            ETypeApplicationCliente.Service);
                        if (!result)
                        {
                            C2iEventLog.WriteErreur(I.T("Working session openning error for Planned Tasks|335"));
                            return;
                        }
                        try
                        {
                            using (CContexteDonnee contexteTravail = new CContexteDonnee(sessionTravail.IdSession, true, false))
                            {
                                CTachePlanifieeServeur serveur = new CTachePlanifieeServeur(sessionTravail.IdSession);
                                CListeObjetsDonnees    liste   = new CListeObjetsDonnees(contexteTravail, typeof(CTachePlanifiee));
                                liste.Filtre = filtre;

                                foreach (CTachePlanifiee tache in liste)
                                {
                                    CInfoDeclencheurProcess infoDeclencheur = new CInfoDeclencheurProcess(TypeEvenement.Date);
                                    try
                                    {
                                        serveur.ExecuteTache(tache.Id, null);
                                    }
                                    catch (Exception e)
                                    {
                                        string strLibelle = I.T("Error planned task @1|336", tache.Libelle) + Environment.NewLine;
                                        strLibelle += e.ToString();
                                        C2iEventLog.WriteErreur(strLibelle);
                                    }
                                    tache.BeginEdit();
                                    CDateTimeEx dt = tache.ParametrePlanification.GetNextOccurence(tache.DateProchaineExecution, false);
                                    while (dt != null && (DateTime)dt < DateTime.Now)
                                    {
                                        dt = tache.ParametrePlanification.GetNextOccurence(dt, false);
                                    }
                                    tache.DateProchaineExecution = dt;
                                    tache.CommitEdit();
                                    //Ouvre une session pour chaque tâche. Comme ça s'il y a une erreur sur une tâche,
                                    //les autres ne peuvent pas être impactées
                                    sessionTravail.CloseSession();
                                    result = sessionTravail.OpenSession(new CAuthentificationSessionProcess(),
                                                                        I.T("Planned Tasks execution|334"),
                                                                        ETypeApplicationCliente.Service);
                                    if (!result)
                                    {
                                        throw new CExceptionErreur(result.Erreur);
                                    }
                                }
                            }
                        }
                        catch (Exception e)
                        {
                            C2iEventLog.WriteErreur(I.T("Error in planned tasks : @1|337", e.ToString()));
                        }
                        finally
                        {
                            try
                            {
                                sessionTravail.CloseSession();
                            }
                            catch { }
                        }
                    }
                }
                catch (Exception e)
                {
                    C2iEventLog.WriteErreur(I.T("Error in planned tasks : @1|337", e.ToString()));
                }
            }
            catch (Exception e)
            {
                {
                    C2iEventLog.WriteErreur(I.T("Error in planned tasks : @1|337", e.ToString()));
                }
            }
            finally
            {
                m_bTraitementEnCours = false;
            }
        }
Beispiel #4
0
        /// <summary>
        /// Stocke le résultat d'une requête pour un type de données
        /// </summary>
        /// <param name="nIdTypeDonnee"></param>
        /// <param name="requete"></param>
        /// <returns></returns>
        public CResultAErreur StockeResultat(int nIdTypeDonnee, IIndicateurProgression indicateur)
        {
            using (C2iSponsor sponsor = new C2iSponsor())
            {
                sponsor.Register(indicateur);
                CResultAErreur result = CResultAErreur.True;
                if (m_tableCalculsEnCours[nIdTypeDonnee] != null)
                {
                    result.EmpileErreur(I.T("The recalculation for this cumulated data type is already in progress|143"));
                    return(result);
                }
                m_tableCalculsEnCours[nIdTypeDonnee] = true;
                CSessionProcessServeurSuivi sessionSuivi = null;
                try
                {
                    //Crée une session pour le calcul
                    CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
                    if (session == null)
                    {
                        result.EmpileErreur(I.T("Session error|144"));
                        return(result);
                    }

                    System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.BelowNormal;
                    sessionSuivi = new CSessionProcessServeurSuivi();
                    result       = sessionSuivi.OpenSession(new CAuthentificationSessionServer(),
                                                            I.T("Recalculation of datas @1|145", nIdTypeDonnee.ToString()),
                                                            session);
                    if (!result)
                    {
                        result.EmpileErreur(I.T("Opening session error|146"));
                        return(result);
                    }
                    IdSession = sessionSuivi.IdSession;
                    System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Lowest;
                    using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
                    {
                        //Récupère le type de donnée
                        CTypeDonneeCumulee typeDonnee = new CTypeDonneeCumulee(contexte);
                        if (!typeDonnee.ReadIfExists(nIdTypeDonnee))
                        {
                            result.EmpileErreur(I.T("The cumulated data type @1 doesn't exist|147", nIdTypeDonnee.ToString()));
                            return(result);
                        }

                        if (indicateur != null)
                        {
                            indicateur.SetInfo(I.T("Existing datas recovery|148"));
                            indicateur.SetValue(0);
                        }

                        CParametreDonneeCumulee parametre = typeDonnee.Parametre;

                        //Lit les données pour ce type de donnée cumulée
                        CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, typeof(CDonneeCumulee));
                        liste.Filtre = new CFiltreData(CTypeDonneeCumulee.c_champId + "=@1",
                                                       nIdTypeDonnee);
                        liste.AssureLectureFaite();
                        if (parametre.ViderAvantChaqueCalcul)
                        {
                            result = VideTable(nIdTypeDonnee, contexte.Tables[CDonneeCumulee.c_nomTable]);
                            if (!result)
                            {
                                return(result);
                            }
                        }


                        //Liste des champs clé à lire
                        ArrayList lstClesALire = new ArrayList();
                        //Liste des champs destination des clés
                        ArrayList lstDestClesALire = new ArrayList();

                        //Liste des valeurs décimales à lire
                        ArrayList lstValeursDecimalesALire = new ArrayList();
                        //Liste des champs destinatation des valeurs décimales
                        ArrayList lstDestValeursDecimalesALire = new ArrayList();

                        //Liste des valeurs dates à lire
                        ArrayList lstValeursDatesALire = new ArrayList();
                        //Liste des champs destinatation des valeurs dates
                        ArrayList lstDestValeursDatesALire = new ArrayList();

                        //Liste des valeurs texte à lire
                        ArrayList lstValeursTextesALire = new ArrayList();
                        //Liste des champs destinatation des valeurs texte
                        ArrayList lstDestValeursTextesALire = new ArrayList();

                        //Change les clés de la table de données pour qu'elles
                        //correspondent aux clés déclarées
                        //Pour des recherches ultérieures plus rapides
                        DataTable    tableDonnees = contexte.Tables[CDonneeCumulee.c_nomTable];
                        DataColumn[] oldKey       = tableDonnees.PrimaryKey;
                        ArrayList    lstCles      = new ArrayList();

                        for (int nCle = 0; nCle < CParametreDonneeCumulee.c_nbChampsCle; nCle++)
                        {
                            if (parametre.GetChampCle(nCle) != null &&
                                parametre.GetChampCle(nCle).Champ != "")
                            {
                                lstClesALire.Add(parametre.GetChampCle(nCle).Champ);
                                string strChampDest = CDonneeCumulee.c_baseChampCle + nCle.ToString();
                                lstDestClesALire.Add(strChampDest);
                                lstCles.Add(tableDonnees.Columns[strChampDest]);
                            }
                        }
                        try
                        {
                            tableDonnees.PrimaryKey = (DataColumn[])lstCles.ToArray(typeof(DataColumn));
                        }
                        catch
                        {
                            //On n'y arrive pas, on a probablement changé la requete ->On vide tout !
                            result = VideTable(nIdTypeDonnee, tableDonnees);
                            if (!result)
                            {
                                return(result);
                            }
                            tableDonnees.PrimaryKey = (DataColumn[])lstCles.ToArray(typeof(DataColumn));
                        }

                        //Repère les données à lire
                        for (int nChamp = 0; nChamp < CParametreDonneeCumulee.c_nbChampsValeur; nChamp++)
                        {
                            string strChamp = parametre.GetValueField(nChamp);
                            if (strChamp != null && strChamp != "")
                            {
                                lstValeursDecimalesALire.Add(strChamp);
                                lstDestValeursDecimalesALire.Add(CDonneeCumulee.c_baseChampValeur + nChamp.ToString());
                            }
                        }

                        for (int nChamp = 0; nChamp < CParametreDonneeCumulee.c_nbChampsDate; nChamp++)
                        {
                            string strChamp = parametre.GetDateField(nChamp);
                            if (strChamp != null && strChamp != "")
                            {
                                lstValeursDatesALire.Add(strChamp);
                                lstDestValeursDatesALire.Add(CDonneeCumulee.c_baseChampDate + nChamp.ToString());
                            }
                        }

                        for (int nChamp = 0; nChamp < CParametreDonneeCumulee.c_nbChampsTexte; nChamp++)
                        {
                            string strChamp = parametre.GetTextField(nChamp);
                            if (strChamp != null && strChamp != "")
                            {
                                lstValeursTextesALire.Add(strChamp);
                                lstDestValeursTextesALire.Add(CDonneeCumulee.c_baseChampTexte + nChamp.ToString());
                            }
                        }

                        if (indicateur != null)
                        {
                            indicateur.SetInfo(I.T("Request execution|149"));
                            indicateur.SetValue(10);
                        }

                        IDefinitionJeuDonnees defJeu = typeDonnee.Parametre.DefinitionDeDonnees;
                        IElementAVariablesDynamiquesAvecContexteDonnee eltAVariables = null;
                        if (defJeu is C2iRequete)
                        {
                            eltAVariables = (IElementAVariablesDynamiquesAvecContexteDonnee)defJeu;
                        }
                        else if (defJeu is CStructureExportAvecFiltre)
                        {
                            eltAVariables = ((CStructureExportAvecFiltre)defJeu).Filtre;
                            if (eltAVariables == null)
                            {
                                CFiltreDynamique filtre = new CFiltreDynamique(contexte);
                                filtre.TypeElements = defJeu.TypeDonneesEntree;
                                eltAVariables       = filtre;
                            }
                            ((CFiltreDynamique)eltAVariables).ContexteDonnee = contexte;
                        }

                        result = CParametreDonneeCumulee.GetTableSource(eltAVariables, defJeu, indicateur);
                        //Calcule le résultat de la requête demandée
                        if (!result)
                        {
                            result.EmpileErreur(I.T("Error in request|150"));
                            return(result);
                        }

                        //Liste des lignes trouvées dans la requête
                        Hashtable tableExistantes = new Hashtable();

                        DataTable tableSource = (DataTable)result.Data;

                        if (indicateur != null)
                        {
                            indicateur.SetInfo(I.T("Result Storage|151"));
                            indicateur.SetValue(20);
                            indicateur.PushSegment(20, 80);
                            indicateur.SetBornesSegment(0, tableSource.Rows.Count);
                        }

                        int nIndex = 0;

                        foreach (DataRow row in tableSource.Rows)
                        {
                            nIndex++;
                            if (indicateur != null && nIndex % 50 == 0)
                            {
                                indicateur.SetValue(nIndex);
                            }
                            lstCles.Clear();
                            for (int nCle = 0; nCle < lstClesALire.Count; nCle++)
                            {
                                lstCles.Add(row[(string)lstClesALire[nCle]]);
                            }
                            DataRow rowDest = tableDonnees.Rows.Find((object[])lstCles.ToArray(typeof(object)));
                            if (rowDest == null)
                            {
                                rowDest = tableDonnees.NewRow();
                                rowDest[CObjetDonnee.c_champIdUniversel] = CUniqueIdentifier.GetNew();
                                for (int nCle = 0; nCle < lstCles.Count; nCle++)
                                {
                                    rowDest[(string)lstDestClesALire[nCle]] = lstCles[nCle];
                                }
                                rowDest[CTypeDonneeCumulee.c_champId] = nIdTypeDonnee;
                                tableDonnees.Rows.Add(rowDest);
                            }
                            // Rempli les valeurs décimales de destination
                            for (int nChampVal = 0; nChampVal < lstValeursDecimalesALire.Count; nChampVal++)
                            {
                                try
                                {
                                    rowDest[(string)lstDestValeursDecimalesALire[nChampVal]] = Convert.ToDouble(row[(string)lstValeursDecimalesALire[nChampVal]]);
                                }
                                catch
                                {
                                    rowDest[CDonneeCumulee.c_baseChampValeur + nChampVal.ToString()] = 0;
                                }
                            }
                            // Rempli les valeurs Dates de destination
                            for (int nChampVal = 0; nChampVal < lstValeursDatesALire.Count; nChampVal++)
                            {
                                try
                                {
                                    rowDest[(string)lstDestValeursDatesALire[nChampVal]] = Convert.ToDateTime(row[(string)lstValeursDatesALire[nChampVal]]);
                                }
                                catch
                                {
                                    rowDest[CDonneeCumulee.c_baseChampDate + nChampVal.ToString()] = DBNull.Value;
                                }
                            }
                            // Rempli les valeurs Texte de destination
                            for (int nChampVal = 0; nChampVal < lstValeursTextesALire.Count; nChampVal++)
                            {
                                try
                                {
                                    rowDest[(string)lstDestValeursTextesALire[nChampVal]] = (row[(string)lstValeursTextesALire[nChampVal]]).ToString();
                                }
                                catch
                                {
                                    rowDest[CDonneeCumulee.c_baseChampTexte + nChampVal.ToString()] = "";
                                }
                            }

                            tableExistantes[rowDest] = true;
                        }
                        //Remet la clé à la valeur initiale
                        tableDonnees.PrimaryKey = oldKey;

                        if (indicateur != null)
                        {
                            indicateur.PopSegment();
                            indicateur.PushSegment(80, 90);
                            indicateur.SetBornesSegment(0, tableDonnees.Rows.Count);
                            indicateur.SetInfo(I.T("Deleting of old values|152"));
                        }

                        if (!parametre.PasDeSuppression)
                        {
                            //Supprime les lignes à supprimer
                            ArrayList lstRows = new ArrayList(tableDonnees.Rows);
                            nIndex = 0;
                            foreach (DataRow row in lstRows)
                            {
                                if (!tableExistantes.Contains(row))
                                {
                                    row.Delete();
                                }
                                nIndex++;
                                if (indicateur != null && nIndex % 50 == 0)
                                {
                                    indicateur.SetValue(nIndex);
                                }
                            }
                        }
                        if (indicateur != null)
                        {
                            indicateur.PopSegment();
                            indicateur.SetInfo(I.T("Datas saving|153"));
                        }
                        contexte.EnableTraitementsAvantSauvegarde = false;
                        result = contexte.SaveAll(true);
                        if (indicateur != null)
                        {
                            indicateur.SetInfo(I.T("Finished calculation|154"));
                        }
                    }
                }
                catch (Exception e)
                {
                    result.EmpileErreur(new CErreurException(e));
                    return(result);
                }
                finally
                {
                    if (sessionSuivi != null)
                    {
                        sessionSuivi.CloseSession();
                    }
                    m_tableCalculsEnCours.Remove(nIdTypeDonnee);
                }
                return(result);
            }
        }
        //Le data du result contient la valeur de retour du process
        protected CResultAErreur ExecuteProcess(
            CSessionClient session,
            object objetCible,
            CProcess leProcessAExecuter,
            CContexteDonnee contexte,
            bool bSauvegardeDuContexteExecutionExterne,
            IIndicateurProgression indicateur)
        {
            using (C2iSponsor sponsor = new C2iSponsor())
            {
                sponsor.Register(indicateur);
                /// Stef, le 2/4/08 : pb rencontré : leProcessAExecuter peut être
                /// lié à un autre CContexteDonnee que celui dans lequel on execute l'action
                /// en effet, il est alloué dans un CContexteDonnee, mais un autre CContexteDonnee
                /// peut être recréé pour que l'execution.
                /// OR, dans ce cas, les variables calculées évaluées par le CProcess se trouvent dans
                /// le contexte du process, donc, pas dans le contexte d'execution et les modifs
                /// sur ces variables ne sont donc pas sauvegardées !
                /// d'où la ligne suivante : leProcessAExecuter.ContexteDonnee = contexte
                leProcessAExecuter.ContexteDonnee = contexte;
                //Fin Stef 2/4/08
                CResultAErreur          result        = CResultAErreur.True;
                CProcessEnExecutionInDb processEnExec = new CProcessEnExecutionInDb(contexte);
                processEnExec.CreateNewInCurrentContexte();
                if (objetCible is CObjetDonneeAIdNumerique)
                {
                    processEnExec.ElementLie = (CObjetDonneeAIdNumerique)objetCible;
                }
                else
                {
                    processEnExec.ElementLie = null;
                }
                processEnExec.Libelle = leProcessAExecuter.Libelle;
                processEnExec.DbKeyEvennementDeclencheur = leProcessAExecuter.InfoDeclencheur.DbKeyEvenementDeclencheur;
                processEnExec.IdVersionExecution         = contexte.IdVersionDeTravail;

                CBrancheProcess branche = new CBrancheProcess(leProcessAExecuter);
                branche.IsModeAsynchrone = leProcessAExecuter.ModeAsynchrone;
                CSessionClient sessionSource = CSessionClient.GetSessionForIdSession(IdSession);

                //TESTDBKEYTODO
                branche.KeyUtilisateur          = sessionSource.GetInfoUtilisateur().KeyUtilisateur;
                branche.ConfigurationImpression = sessionSource.ConfigurationsImpression;

                CContexteExecutionAction contexteExecution = new CContexteExecutionAction(
                    processEnExec,
                    branche,
                    objetCible,
                    contexte,
                    leProcessAExecuter.ModeAsynchrone ? null : indicateur);
                contexteExecution.SauvegardeContexteExterne = bSauvegardeDuContexteExecutionExterne;
                //Mode synchrone
                if (!leProcessAExecuter.ModeAsynchrone)
                {
                    bool bTrans = false;
                    if (!bSauvegardeDuContexteExecutionExterne && leProcessAExecuter.ModeTransactionnel)
                    {
                        contexte.SaveAll(true);//Sauve le contexte en execution avant démarrage
                        session.BeginTrans();
                        bTrans = true;
                    }
                    try
                    {
                        result = branche.ExecuteAction(leProcessAExecuter.GetActionDebut(), contexteExecution, true);
                    }
                    catch (Exception e)
                    {
                        result.EmpileErreur(new CErreurException(e));
                    }
                    finally
                    {
                        if (bTrans)
                        {
                            if (result)
                            {
                                result = session.CommitTrans();
                                if (result)
                                {
                                    contexteExecution.OnEndProcess();
                                }
                            }
                            else
                            {
                                session.RollbackTrans();
                            }
                        }
                    }


                    if (!result)
                    {
                        result.EmpileErreur(I.T("Erreur in @1 process|20001", leProcessAExecuter.Libelle));
                    }
                    if (leProcessAExecuter.VariableDeRetour != null)
                    {
                        result.Data = leProcessAExecuter.GetValeurChamp(leProcessAExecuter.VariableDeRetour.IdVariable);
                    }
                    return(result);
                }
                else
                {
                    //Ouvre une nouvelle session pour éxecuter le process
                    if (leProcessAExecuter.ModeAsynchrone)
                    {
                        CSessionProcessServeurSuivi sessionAsync = new CSessionProcessServeurSuivi();
                        result = sessionAsync.OpenSession(new CAuthentificationSessionProcess(),
                                                          "Process " + leProcessAExecuter.Libelle,
                                                          session);
                        if (!result)
                        {
                            return(result);
                        }
                        session = sessionAsync;
                    }
                    contexteExecution.ChangeIdSession(session.IdSession);
                    contexteExecution.HasSessionPropre = true;
                    m_brancheToExecute         = branche;
                    m_actionToExecute          = leProcessAExecuter.GetActionDebut();
                    m_contexteExecutionProcess = contexteExecution;
                    Thread th = new Thread(new ThreadStart(DemarreProcess));
                    th.Start();
                    return(result);
                }
            }
        }
        private static void OnRetrieveMails(object state)
        {
            if (m_bTraitementEnCours)
                return;
            m_bTraitementEnCours = true;

            try
            {
                System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Lowest;
                CResultAErreur result;
                if (m_sessionRecherche == null || !m_sessionRecherche.IsConnected)
                {
                    m_sessionRecherche = CSessionClient.CreateInstance();
                    result = m_sessionRecherche.OpenSession(new CAuthentificationSessionServer(),
                        I.T("MAIL ACCOUNT SERVICE|10001"),
                        ETypeApplicationCliente.Service);
                    if (!result)
                    {
                        C2iEventLog.WriteErreur(I.T("Session Opening error for Mail Account Management Service|10003"));
                        return;
                    }
                }
                try
                {
                    CFiltreData filtre = new CFiltreData(
                        CCompteMail.c_champIsActive + " = @1",
                        true);
                    if (new CCompteMailServeur(m_sessionRecherche.IdSession).CountRecords(
                        CCompteMail.c_nomTable, filtre) > 0)
                    {
                        CSessionClient sessionTravail = new CSessionProcessServeurSuivi();
                        result = sessionTravail.OpenSession(new CAuthentificationSessionServer(),
                            I.T("RECEIVE MAILS SERVICE|10004"),
                            ETypeApplicationCliente.Service);
                        if (!result)
                        {
                            C2iEventLog.WriteErreur(I.T("Working session openning error for Receive Mails Service|10005"));
                            return;
                        }
                        try
                        {
                            using (CContexteDonnee contexteTravail = new CContexteDonnee(sessionTravail.IdSession, true, false))
                            {
                                //CCompteMailServeur compteServeur = new CCompteMailServeur(sessionTravail.IdSession);
                                CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteTravail, typeof(CCompteMail));
                                liste.Filtre = filtre;
                                ArrayList lstLock = liste.ToArrayList();

                                foreach (CCompteMail compteMail in lstLock)
                                {
                                    if (compteMail.DateDernierReleve == null ||
                                        compteMail.DateDernierReleve.Value.AddMinutes(compteMail.PeriodeReleve) < DateTime.Now)
                                    {
                                        result += compteMail.RetrieveMails();
                                    }
                                }
                            }
                        }
                        catch (Exception e)
                        {
                            C2iEventLog.WriteErreur(I.T("Error while receiving Mail : @1|10006", e.ToString()));
                        }
                        finally
                        {
                            try
                            {
                                sessionTravail.CloseSession();
                            }
                            catch { }
                        }
                    }
                }
                catch (Exception e)
                {
                    C2iEventLog.WriteErreur(I.T("Error while receiving Mail : @1|10006", e.ToString()));
                }
            }
            catch (Exception e)
            {
                {
                    C2iEventLog.WriteErreur(I.T("Error while receiving Mail : @1|10006", e.ToString()));
                }
            }
            finally
            {
                m_bTraitementEnCours = false;
            }
        }
Beispiel #7
0
        private static void OnSendSMS(object state)
        {
            if (m_bTraitementEnCours)
            {
                return;
            }
            m_bTraitementEnCours = true;

            try
            {
                System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Lowest;
                CResultAErreur result;
                if (m_sessionRecherche == null || !m_sessionRecherche.IsConnected)
                {
                    m_sessionRecherche = CSessionClient.CreateInstance();
                    result             = m_sessionRecherche.OpenSession(new CAuthentificationSessionServer(),
                                                                        I.T("SMS SERVICE|20159"),
                                                                        ETypeApplicationCliente.Service);
                    if (!result)
                    {
                        C2iEventLog.WriteErreur(I.T("Session Opening error for SMS Service|20160"));
                        return;
                    }
                }
                try
                {
                    CFiltreData filtre = new CFiltreData(CMessageSMS.c_champNextSendDate + " < @1 and " +
                                                         CMessageSMS.c_champDateEnvoi + " is null and " +
                                                         CMessageSMS.c_champNbEssais + " < 10",
                                                         DateTime.Now
                                                         );
                    if (new CMessageSMSServeur(m_sessionRecherche.IdSession).CountRecords(
                            CMessageSMS.c_nomTable, filtre) > 0)
                    {
                        CSessionClient sessionTravail = new CSessionProcessServeurSuivi();
                        result = sessionTravail.OpenSession(new CAuthentificationSessionProcess(),
                                                            I.T("Send SMS|20161"),
                                                            ETypeApplicationCliente.Service);
                        if (!result)
                        {
                            C2iEventLog.WriteErreur(I.T("Working session openning error for SMS send|20162"));
                            return;
                        }
                        try
                        {
                            using (CContexteDonnee contexteTravail = new CContexteDonnee(sessionTravail.IdSession, true, false))
                            {
                                CMessageSMSServeur  serveur = new CMessageSMSServeur(sessionTravail.IdSession);
                                CListeObjetsDonnees liste   = new CListeObjetsDonnees(contexteTravail, typeof(CMessageSMS));
                                liste.Filtre = filtre;
                                ArrayList lstLock = liste.ToArrayList();

                                foreach (CMessageSMS message in lstLock)
                                {
                                    CMessageSMSPourEnvoi toSend = new CMessageSMSPourEnvoi(message.Destinataires, message.Texte);
                                    result = toSend.Send(sessionTravail.IdSession);
                                    message.BeginEdit();
                                    if (!result)
                                    {
                                        message.NextSendDate = DateTime.Now.AddMinutes(3);
                                        message.NbEssais++;
                                        message.LastErreur = result.Erreur.ToString();
                                    }
                                    else
                                    {
                                        message.DateEnvoi  = DateTime.Now;
                                        message.LastErreur = "";
                                    }
                                    message.CommitEdit();

                                    result.SetTrue();
                                }
                            }
                        }
                        catch (Exception e)
                        {
                            C2iEventLog.WriteErreur(I.T("Error while sendind SMS : @1|20163", e.ToString()));
                        }
                        finally
                        {
                            try
                            {
                                sessionTravail.CloseSession();
                            }
                            catch { }
                        }
                    }
                }
                catch (Exception e)
                {
                    C2iEventLog.WriteErreur(I.T("Error while sendind SMS : @1|20163", e.ToString()));
                }
            }
            catch (Exception e)
            {
                {
                    C2iEventLog.WriteErreur(I.T("Error while sendind SMS : @1|20163", e.ToString()));
                }
            }
            finally
            {
                m_bTraitementEnCours = false;
            }
        }
Beispiel #8
0
        /// ////////////////////////////////////////////////////////
        protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
        {
            CResultAErreur result      = CResultAErreur.False;
            CProcessInDb   processInDB = new CProcessInDb(contexte.ContexteDonnee);

            if (!processInDB.ReadIfExists(m_dbKeyProcess))
            {
                result.EmpileErreur(I.T("The @1 action doesn't exist|194", m_dbKeyProcess.ToString()));
                result.EmpileErreur(I.T("Error in an action execution from an action|195"));
                return(result);
            }

            string strOldContextuel = contexte.ContexteDonnee.IdModificationContextuelle;

            CContexteDonnee contexteDonneeSousAction = contexte.ContexteDonnee;

            if (ModeAsynchrone || LancerDansUnProcessSepare)
            {
                contexteDonneeSousAction = new CContexteDonnee(contexte.IdSession, true, true);
            }

            //Si synchrone, s'execute dans le même contexte de données
            if (!ModeAsynchrone)
            {
                CProcessEnExecutionInDb processEnExec = new CProcessEnExecutionInDb(contexteDonneeSousAction);

                processEnExec.CreateNewInCurrentContexte();

                CProcess process = processInDB.Process;
                process.ContexteDonnee = contexteDonneeSousAction;

                object elementCible = contexte.ObjetCible;

                //Remplit les variables du process
                foreach (string strIdVariable in m_mapVariablesProcessToFormule.Keys)
                {
                    IVariableDynamique variable = process.GetVariable(strIdVariable);
                    //Evalue la formule
                    C2iExpression expression = (C2iExpression)m_mapVariablesProcessToFormule[strIdVariable];
                    CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
                    contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
                    result = expression.Eval(contexteEval);
                    if (!result)
                    {
                        result.EmpileErreur(I.T("Error during the variables assignment in sub action|197"));
                        result.EmpileErreur(I.T("@1 variable error|196", variable.Nom));
                        return(result);
                    }
                    CObjetDonnee objDonnee = result.Data as CObjetDonnee;
                    if (objDonnee != null)
                    {
                        result.Data = objDonnee.GetObjetInContexte(contexteDonneeSousAction);
                    }
                    process.SetValeurChamp(variable.IdVariable, result.Data);
                    if (variable.IdVariable == CProcess.c_strIdVariableElement && result.Data is CObjetDonneeAIdNumerique)
                    {
                        elementCible = result.Data;
                    }
                }

                if (elementCible is CObjetDonneeAIdNumerique)
                {
                    processEnExec.ElementLie = (CObjetDonneeAIdNumerique)elementCible;
                }
                else
                {
                    processEnExec.ElementLie = null;
                }
                processEnExec.Libelle = process.Libelle;

                CBrancheProcess branche = new CBrancheProcess(process);
                branche.IsModeAsynchrone = ModeAsynchrone;
                //TESTDBKEYOK
                branche.KeyUtilisateur          = contexte.Branche.KeyUtilisateur;
                branche.ConfigurationImpression = contexte.Branche.ConfigurationImpression;

                CContexteExecutionAction contexteExecution = new CContexteExecutionAction(
                    processEnExec,
                    branche,
                    elementCible,
                    ModeAsynchrone ? null : contexteDonneeSousAction, contexte.IndicateurProgression);

                CAction pointEntree = null;
                if (IdPointEntree >= 0)
                {
                    pointEntree = process.GetActionFromId(IdPointEntree);
                    if (pointEntree == null)
                    {
                        result.EmpileErreur(I.T("Can not find entry point|20018"));
                        return(result);
                    }
                }
                else
                {
                    pointEntree = process.GetActionDebut();
                }

                if (!ModeAsynchrone)
                {
                    contexteExecution.SauvegardeContexteExterne = !m_bLancerDansContexteSepare;

                    result = branche.ExecuteAction(pointEntree, contexteExecution, elementCible, true);
                    foreach (CContexteExecutionAction.CParametreServiceALancerALaFin s in contexteExecution.ServicesALancerALaFin)
                    {
                        contexte.AddServiceALancerALaFin(s);
                    }
                    contexteExecution.ClearServicesALancerALaFin();
                    if (m_bSansTrace)
                    {
                        processEnExec.Table.Rows.Remove(processEnExec.Row.Row);
                    }
                    if (VariableResultat != null && process.VariableDeRetour != null)
                    {
                        object valeur = process.GetValeurChamp(process.VariableDeRetour);
                        if (valeur != null)
                        {
                            valeur = valeur.ToString();
                        }
                        Process.SetValeurChamp(VariableResultat.IdVariable, valeur.ToString());
                    }
                }
                else
                {
                    //Ouvre une nouvelle session pour éxecuter le process
                    CSessionProcessServeurSuivi sessionAsync = new CSessionProcessServeurSuivi();
                    result = sessionAsync.OpenSession(new CAuthentificationSessionProcess(),
                                                      I.T("Process @1|198", processInDB.Libelle),
                                                      CSessionClient.GetSessionForIdSession(contexte.IdSession));
                    if (!result)
                    {
                        return(result);
                    }
                    contexteExecution.ChangeIdSession(sessionAsync.IdSession);
                    contexteExecution.HasSessionPropre = true;
                    m_brancheToExecute         = branche;
                    m_actionToExecute          = pointEntree;
                    m_elementCible             = elementCible;
                    m_contexteExecutionProcess = contexteExecution;
                    Thread th = new Thread(new ThreadStart(DemarreProcess));
                    th.Start();
                    return(result);
                }
            }
            contexte.ContexteDonnee.IdModificationContextuelle = strOldContextuel;
            return(result);
        }