/// <summary>
/// Démarre une action
/// </summary>
/// <param name="process"></param>
/// <param name="nIdSession"></param>
/// <returns></returns>
public static CResultAErreur RunEvent(IDeclencheurAction declencheur, CObjetDonneeAIdNumerique objetCible, bool bHideProgress)
{
CFormExecuteProcess form = new CFormExecuteProcess();
form.Top = 0;
form.Left = Screen.PrimaryScreen.WorkingArea.Width / 2 - form.Width / 2;
if (declencheur is IDeclencheurActionManuelle)
{
bHideProgress |= ((IDeclencheurActionManuelle)declencheur).HideProgress;
}
if (bHideProgress)
{
CInfoDeclencheurProcess infoDeclencheur = new CInfoDeclencheurProcess(TypeEvenement.Manuel);
CAppelleurFonctionAsynchrone appeleur = new CAppelleurFonctionAsynchrone();
CResultAErreur resultDefault = CResultAErreur.True;
resultDefault.EmpileErreur(I.T("Asynchronous call error @1|20149", "RunEvent"));
return(appeleur.StartFonctionAndWaitAvecCallback(declencheur.GetType(), declencheur,
"RunEvent", "", resultDefault, objetCible, infoDeclencheur, null) as CResultAErreur);
//return declencheur.RunEvent(objetCible, infoDeclencheur, null);
}
else
{
IAsyncResult res = form.m_runEvent.BeginInvoke(declencheur, objetCible,
new AsyncCallback(form.OnEndProcess), null);
form.ShowDialog(); //Bloque le code ici !
CResultAErreur result = form.m_runEvent.EndInvoke(res);
return(result);
}
}
//-------------------------------------------------------------------
public CResultAErreur ExecuteTache(int nIdIntervention, IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
CTachePlanifiee tache = new CTachePlanifiee(contexte);
if (!tache.ReadIfExists(nIdIntervention))
{
result.EmpileErreur(I.T("The Planned Task '@1' does not exist|338", nIdIntervention.ToString()));
return(result);
}
int nNbErreurs = 0;
C2iEventLog.WriteInfo(I.T("Starting planned task @1|339", tache.Libelle), NiveauBavardage.PetiteCausette);
int nNbFait = 0;
string strErreur = "";
foreach (CRelationTachePlanifieeProcess rel in tache.RelationsProcess)
{
if (indicateur != null)
{
indicateur.SetInfo(I.T("Action @1|340", rel.Process.Libelle));
}
CInfoDeclencheurProcess infoDeclencheur = new CInfoDeclencheurProcess(TypeEvenement.Date);
result = CProcessEnExecutionInDb.StartProcess(rel.Process.Process, infoDeclencheur, IdSession, null, null);
if (!result)
{
result.EmpileErreur(I.T("Action @1|341", rel.Process.Libelle));
strErreur += Environment.NewLine;
strErreur += result.Erreur.ToString() + Environment.NewLine + "-------------------------------------" + Environment.NewLine;
nNbErreurs++;
result = CResultAErreur.True;
}
nNbFait++;
if (indicateur != null)
{
indicateur.SetValue(nNbFait);
}
}
foreach (CRelationTachePlanifieeTypeDonneeCumulee relData in tache.RelationsTypesDonneesCumulees)
{
result = relData.TypeDonneeCumulee.StockResultat(indicateur);
if (!result)
{
result.EmpileErreur(I.T("Cumulated data @1|342", relData.TypeDonneeCumulee.Libelle));
strErreur += result.Erreur.ToString() + "\r\n-------------------------------------\r\n";
nNbErreurs++;
result = CResultAErreur.True;
}
}
C2iEventLog.WriteInfo(I.T("End of planned task @1, @2 error(s)|343", tache.Libelle, nNbErreurs.ToString()), NiveauBavardage.PetiteCausette);
return(result);
}
}
/// //////////////////////////////////////////////////////////////////////////
public CResultAErreur DeclencheEvenementStatiques(Type typeObjet, CDbKey dbKeyObjet)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)Activator.CreateInstance(typeObjet, new object[] { contexte });
if (!objet.ReadIfExists(dbKeyObjet))
{
result.EmpileErreur(I.T("The @1 object with id @2 doesn't exist|106", DynamicClassAttribute.GetNomConvivial(typeObjet), dbKeyObjet.StringValue));
return(result);
}
IDeclencheurAction[] declencheurs = CRecuperateurDeclencheursActions.GetDeclencheursAssocies(objet);
foreach (IDeclencheurAction declencheur in declencheurs)
{
if (declencheur is CEvenement)
{
CEvenement evt = (CEvenement)declencheur;
CInfoDeclencheurProcess infoDeclencheur = new CInfoDeclencheurProcess();
bool bShouldDeclenche = false;
if (!evt.DejaDeclenchePourEntite(objet))
{
bShouldDeclenche = evt.ParametreDeclencheur.ShouldDeclenche(
objet,
false,
true,
ref infoDeclencheur);
}
if (bShouldDeclenche)
{
evt.EnregistreDeclenchementEvenement(objet, infoDeclencheur);
}
if (!result)
{
return(result);
}
}
}
}
return(result);
}
//-------------------------------------------------------------------------
private void m_lnkTester_LinkClicked(object sender, System.Windows.Forms.LinkLabelLinkClickedEventArgs e)
{
CResultAErreur result = CResultAErreur.True;
//Débute une transaction pour tester dans le vide !!!
CSessionClient session = CTimosApp.SessionClient;
result = session.BeginTrans();
if (result)
{
try
{
CInfoDeclencheurProcess info = new CInfoDeclencheurProcess(TypeEvenement.Manuel);
result = CProcessEnExecutionInDb.StartProcess(
Process.Process,
info,
CTimosApp.SessionClient.IdSession,
Process.ContexteDonnee.IdVersionDeTravail,
null);
}
catch (Exception ep)
{
result.EmpileErreur(new CErreurException(ep));
}
finally
{
session.RollbackTrans();
}
}
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
else
{
CFormAlerte.Afficher(I.T("Execution successful|30226"));
}
}
/// <summary>
/// Démarre une action
/// </summary>
/// <param name="process"></param>
/// <param name="nIdSession"></param>
/// <returns></returns>
public static CResultAErreur RunEventMultiple(IDeclencheurAction declencheur, CObjetDonneeAIdNumerique[] objetsCibles, bool bHideProgress)
{
CFormExecuteProcess form = new CFormExecuteProcess();
form.Top = 0;
form.Left = Screen.PrimaryScreen.WorkingArea.Width / 2 - form.Width / 2;
if (declencheur is IDeclencheurActionManuelle)
{
bHideProgress |= ((IDeclencheurActionManuelle)declencheur).HideProgress;
}
if (bHideProgress)
{
CInfoDeclencheurProcess infoDeclencheur = new CInfoDeclencheurProcess(TypeEvenement.Manuel);
return(declencheur.RunEventMultiple(objetsCibles, infoDeclencheur, null));
}
else
{
IAsyncResult res = form.m_runEventMultiples.BeginInvoke(declencheur, objetsCibles,
new AsyncCallback(form.OnEndProcess), null);
form.ShowDialog(); //Bloque le code ici !
CResultAErreur result = form.m_runEventMultiples.EndInvoke(res);
return(result);
}
}
/// /////////////////////////////////////////////////////////////////////////
private CResultAErreur RunEventMultiplesPrivate(IDeclencheurAction declencheur, CObjetDonneeAIdNumerique[] objetsCibles)
{
CInfoDeclencheurProcess infoDeclencheur = new CInfoDeclencheurProcess(TypeEvenement.Manuel);
return(declencheur.RunEventMultiple(objetsCibles, infoDeclencheur, this));
}
/// /////////////////////////////////////////////////////////////////////////
private CResultAErreur StartProcessMultiplesPrivate(CProcess process, CReferenceObjetDonnee[] refsCible, int nIdSession, int?nIdVersion)
{
CInfoDeclencheurProcess infoDeclencheur = new CInfoDeclencheurProcess(TypeEvenement.Manuel);
return(CProcessEnExecutionInDb.StartProcessMultiples(process, infoDeclencheur, refsCible, nIdSession, nIdVersion, this));
}
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;
}
}
/// //////////////////////////////////////////////////////////////////
protected static CResultAErreur ExecuteActionProcess(CActionSur2iLinkExecuterProcess action, object objetCible)
{
CResultAErreur result = CResultAErreur.True;
CProcessInDb process = new CProcessInDb(CSc2iWin32DataClient.ContexteCourant);
if (process.ReadIfExists(action.IdProcessInDb))
{
CProcess processToExecute = process.Process;
result = AffecteVariablesToProcess(action, processToExecute, objetCible);
if (!result)
{
return(result);
}
CInfoDeclencheurProcess infoDecl = new CInfoDeclencheurProcess(TypeEvenement.Manuel);
CReferenceObjetDonnee refObj = null;
object cibleProcess = objetCible;
if (cibleProcess is CDefinitionMultiSourceForExpression)
{
cibleProcess = ((CDefinitionMultiSourceForExpression)cibleProcess).ObjetPrincipal;
}
if (cibleProcess != null && process.TypeCible != null)
{
if (cibleProcess.GetType().IsArray)
{
ArrayList lstRefs = new ArrayList();
foreach (object cible in (Array)cibleProcess)
{
if (process.TypeCible.IsAssignableFrom(cible.GetType()) && cible is CObjetDonnee)
{
lstRefs.Add(new CReferenceObjetDonnee((CObjetDonnee)cible));
}
}
if (lstRefs.Count == 0)
{
result.EmpileErreur(I.T("No element selected for requested action|30085"));
}
else
{
result = CFormExecuteProcess.StartProcessMultiples(processToExecute,
(CReferenceObjetDonnee[])lstRefs.ToArray(typeof(CReferenceObjetDonnee)),
CTimosApp.SessionClient.IdSession,
CSc2iWin32DataClient.ContexteCourant.IdVersionDeTravail,
action.MasquerProgressProcess);
return(result);
}
}
else
{
if (process.TypeCible.IsAssignableFrom(cibleProcess.GetType()) && cibleProcess is CObjetDonnee)
{
refObj = new CReferenceObjetDonnee((CObjetDonnee)cibleProcess);
}
}
}
result = CFormExecuteProcess.StartProcess(processToExecute,
refObj,
CTimosApp.SessionClient.IdSession,
CSc2iWin32DataClient.ContexteCourant.IdVersionDeTravail,
action.MasquerProgressProcess);
}
else
{
CEvenement evt = new CEvenement(CSc2iWin32DataClient.ContexteCourant);
CInfoDeclencheurProcess infoDecl = new CInfoDeclencheurProcess(TypeEvenement.Manuel);
object cibleProcess = objetCible;
if (cibleProcess is CDefinitionMultiSourceForExpression)
{
cibleProcess = ((CDefinitionMultiSourceForExpression)cibleProcess).ObjetPrincipal;
}
if (evt.ReadIfExists(action.IdEvenement))
{
if (cibleProcess == null)
{
result.EmpileErreur(I.T("Impossible to execute the requested event|30086"));
return(result);
}
if (cibleProcess.GetType().IsArray)
{
ArrayList lstRefs = new ArrayList();
foreach (object cible in (Array)cibleProcess)
{
if (!(cible is CObjetDonneeAIdNumerique) || !evt.ShouldDeclenche((CObjetDonneeAIdNumerique)cible, ref infoDecl))
{
result.EmpileErreur(I.T("The requested action cannot be executed on at least one of the requested elements|30087"));
return(result);
}
lstRefs.Add(cible);
}
if (lstRefs.Count == 0)
{
result.EmpileErreur(I.T("No element selected for execution|30088"));
return(result);
}
result = CFormExecuteProcess.RunEventMultiple(
evt,
(CObjetDonneeAIdNumeriqueAuto[] )lstRefs.ToArray(typeof(CObjetDonneeAIdNumeriqueAuto)),
action.MasquerProgressProcess);
}
else
{
if (!evt.ShouldDeclenche((CObjetDonneeAIdNumerique)cibleProcess, ref infoDecl))
{
result.EmpileErreur(I.T("Impossible to trigger the requested event on this object|30089"));
return(result);
}
result = CFormExecuteProcess.RunEvent(evt, (CObjetDonneeAIdNumerique)cibleProcess, action.MasquerProgressProcess);
}
}
else
{
result.EmpileErreur(I.T("The requested action does not exist|30090"));
}
}
return(result);
}
public CCoupleEvenementObjet(CEvenement evt, CObjetDonneeAIdNumerique obj, CInfoDeclencheurProcess infoDeclencheur)
: base(obj, infoDeclencheur)
{
Evenement = evt;
}
/// <summary>
///
/// </summary>
/// <param name="objet"></param>
public CCoupleDeclencheurObjet(CObjetDonneeAIdNumerique objet, CInfoDeclencheurProcess infoDeclencheur)
{
Objet = objet;
InfoDeclencheur = infoDeclencheur;
}
/// <summary>
/// /////////////////////////////////////////////////////////////////////////////////
/// </summary>
/// <param name="table"></param>
/// <param name="result"></param>
///
private static CResultAErreur TraitementAvantSauvegardeExterne(CContexteDonnee contexte, Hashtable tableData)
{
CResultAErreur result = CResultAErreur.True;
///Stef 22/07/08 : l'appel à shouldDeclenche peut
///nécessiter GetValeurChamp (si conditions sur des champs). Or, si un élément n'a pas
///de valeur pour un champ, l'appli va aller chercher la valeur par défaut de ce
///champ, si le champ n'est pas chargé, l'appli va le lire. Comme on est souvent
///dans un contexte sans gestion par tables complètes, on est mal, parce que
///ça va génerer une requête par champ.
///Donc, on lit tous les champs custom avant de commencer
CListeObjetsDonnees listeChamps = new CListeObjetsDonnees(contexte, typeof(CChampCustom));
listeChamps.PreserveChanges = true; //Pour ne pas modifier les champs modifiés
listeChamps.AssureLectureFaite();
DateTime dt = DateTime.Now;
CTraitementApresSauvegarde traitement = new CTraitementApresSauvegarde( );
ArrayList lstTables = CContexteDonnee.GetTablesOrderInsert(contexte);
//Pour empêcher de regarder deux fois les évenements d'un même objet
//Type->Dictionnaire des ids vus
Dictionary <Type, Dictionary <int, bool> > elementsVus = new Dictionary <Type, Dictionary <int, bool> >();
DataRowChangeEventHandler handlerRedo = new DataRowChangeEventHandler(table_RowChanged);
Dictionary <string, Dictionary <int, bool> > listeElementsARepasser = null;
if (!m_listeElementsARepasser.TryGetValue(contexte, out listeElementsARepasser))
{
listeElementsARepasser = new Dictionary <string, Dictionary <int, bool> >();
m_listeElementsARepasser[contexte] = listeElementsARepasser;
}
bool bFirstPasse = true;
int nLimiteurPasses = 0;
while ((bFirstPasse | listeElementsARepasser.Count > 0) && nLimiteurPasses < 5)
{
nLimiteurPasses++;
foreach (DataTable table in lstTables)
{
if (table.Rows.Count > 0 && table.PrimaryKey.Length == 1)
{
string strChampCle = table.PrimaryKey[0].ColumnName;
Type tpObjets = CContexteDonnee.GetTypeForTable(table.TableName);
if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpObjets))
{
continue;
}
Type typeOriginal = tpObjets;
//Lors de la modif de champs custom, l'élement parent n'est pas forcement modifié
//Mais le champ peut l'être
if (tpObjets.IsSubclassOf(typeof(CRelationElementAChamp_ChampCustom)))
{
int nLigne = 0;
bool bGoOut = false;
while (table.Rows.Count > nLigne && !bGoOut)
{
if (table.Rows[nLigne].RowState != DataRowState.Deleted)
{
CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)contexte.GetNewObjetForRow(table.Rows[nLigne]);
tpObjets = rel.ElementAChamps.GetType();
strChampCle = ((CObjetDonnee)rel.ElementAChamps).GetChampsId()[0];
bGoOut = true;
}
nLigne++;
}
}
//Les objets qui n'ont pas de relationTypeId ne peuvent pas avoir d'évenements
if (tpObjets.GetCustomAttributes(typeof(NoRelationTypeIdAttribute), true).Length > 0)
{
continue;
}
ArrayList lstEvenements = GetListeEvenementsAutoSur(tpObjets, contexte.IdVersionDeTravail);
//Id des éléments modifiés
List <int> listeIdsElementsAVerifierHandlers = new List <int>();
string strPrimaryKey = "";
if (table.PrimaryKey.Length == 1 &&
table.PrimaryKey[0].DataType == typeof(int))
{
strPrimaryKey = table.PrimaryKey[0].ColumnName;
}
Dictionary <int, bool> tableIdsVues = null;
if (!elementsVus.TryGetValue(tpObjets, out tableIdsVues))
{
tableIdsVues = new Dictionary <int, bool>();
elementsVus[tpObjets] = tableIdsVues;
}
Dictionary <int, bool> listeARepasserPourTable = null;
if (!listeElementsARepasser.TryGetValue(table.TableName, out listeARepasserPourTable))
{
listeARepasserPourTable = null;
}
List <CObjetDonnee> lstObjetsAvecEvenementsSpecifiques = new List <CObjetDonnee>();
//Stef 16/11/2012 :
//Si c'est un élément à champs, il est consideré comme modifié
//si un de ses champs custom est modifiés
//Ca a été fait parce que les handlers d'évenement n'étaient
//Pas pris en compte sur modif de champ custom
//On n'enlève pas pour autant l'ancienne méthode qui consiste
//à considérer l'élément modifié losrqu'on passe sur la table des
//valeurs de champs custom
if (typeof(IObjetDonneeAChamps).IsAssignableFrom(typeOriginal) && table.Rows.Count > 0)
{
//Regarde s'il y a des relations
IObjetDonneeAChamps objAChamp = contexte.GetNewObjetForRow(table.Rows[0]) as IObjetDonneeAChamps;
string strTableChamps = objAChamp.GetNomTableRelationToChamps();
//Trouve la relation à la table
DataTable tableChamps = contexte.Tables[strTableChamps];
if (tableChamps != null)//Si la table champs n'est pas là, c'est
//qu'elle n'a pas été modifiée !! c'est logique çà
{
DataRelation rel = null;
foreach (DataRelation relTest in tableChamps.ParentRelations)
{
if (relTest.ParentTable.TableName == table.TableName)
{
rel = relTest;
break;
}
}
if (rel != null)//On peut vérifier !
{
foreach (DataRow row in new ArrayList(table.Rows))
{
if (row.RowState == DataRowState.Unchanged)//sinon, ce n'est pas la peine
{
DataRow[] rowsChamps = row.GetChildRows(rel);
foreach (DataRow rowChamp in rowsChamps)
{
if (rowChamp.RowState != DataRowState.Unchanged)
{
//Aloue l'objet pour s'assurer que la ligne est bien pleine
CObjetDonnee objTmp = contexte.GetNewObjetForRow(row);
objTmp.AssureData();
row.SetModified();
string strOldContexte = (string)row[CObjetDonnee.c_champContexteModification];
if (strOldContexte.Length == 0)
{
row[CObjetDonnee.c_champContexteModification] = rowChamp[CObjetDonnee.c_champContexteModification,
rowChamp.RowState == DataRowState.Deleted ? DataRowVersion.Original : DataRowVersion.Current] as string;
}
break;
}
}
}
}
}
}
}
foreach (DataRow row in new ArrayList(table.Rows))
{
CObjetDonneeAIdNumerique objet = null;
if (lstEvenements.Count > 0)
{
if (row.RowState == DataRowState.Added ||
row.RowState == DataRowState.Modified ||
row.RowState == DataRowState.Deleted)
{
objet = (CObjetDonneeAIdNumerique)((CContexteDonnee)table.DataSet).GetNewObjetForRow(row);
if (objet.Row.RowState == DataRowState.Deleted)
{
objet.VersionToReturn = DataRowVersion.Original;
}
if (objet.Row.RowState != DataRowState.Deleted && EvenementAttribute.HasEventsSpecifiques(objet))
{
lstObjetsAvecEvenementsSpecifiques.Add(objet);
}
if (typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(typeOriginal))
{
CRelationElementAChamp_ChampCustom rel = objet as CRelationElementAChamp_ChampCustom;
objet = (CObjetDonneeAIdNumerique)((CRelationElementAChamp_ChampCustom)objet).ElementAChamps;
if (objet.Row.RowState == DataRowState.Unchanged)
{
objet.Row.Row.SetModified();
}
if (objet.Row.RowState == DataRowState.Deleted)
{
objet.VersionToReturn = DataRowVersion.Original;
}
if (rel.ContexteDeModification.Length != 0 &&
objet.ContexteDeModification.Length == 0)
{
objet.ContexteDeModification = rel.ContexteDeModification;
}
}
if (!tableIdsVues.ContainsKey(objet.Id) || (
listeARepasserPourTable != null && listeARepasserPourTable.ContainsKey(objet.Id)))
{
tableIdsVues[objet.Id] = true;
foreach (CEvenement evt in lstEvenements)
{
if (!traitement.ContainsCouple(evt, (CObjetDonneeAIdNumerique)objet))
{
//Attention, si c'est une valeur de champ custom, envoie la valeur,
//c'est elle qui sera testée.
CInfoDeclencheurProcess infoDeclencheur = null;
if (evt.ShouldDeclenche((CObjetDonneeAIdNumerique)objet, ref infoDeclencheur))
{
infoDeclencheur.DbKeyEvenementDeclencheur = evt.DbKey;
infoDeclencheur.Info = evt.Libelle;
traitement.AddCoupleEvenementObjet(evt, (CObjetDonneeAIdNumerique)objet, infoDeclencheur);
}
}
}
}
}
}
//Regarde les handle d'évenement sur l'objet
if (strPrimaryKey != "" && (row.RowState == DataRowState.Modified))
{
listeIdsElementsAVerifierHandlers.Add((int)row[strPrimaryKey]);
}
}
if (listeARepasserPourTable != null)
{
listeARepasserPourTable.Clear();
}
if (listeIdsElementsAVerifierHandlers.Count > 0 && bFirstPasse)
{
//traitement par paquet de 500
for (int nIndexLot = 0; nIndexLot < listeIdsElementsAVerifierHandlers.Count; nIndexLot += 500)
{
int nMin = Math.Min(nIndexLot + 500, listeIdsElementsAVerifierHandlers.Count);
StringBuilder bl = new StringBuilder();
for (int nIndex = nIndexLot; nIndex < nMin; nIndex++)
{
bl.Append(listeIdsElementsAVerifierHandlers[nIndex].ToString());
bl.Append(",");
}
string strIdsElementsAVerifierHandlers = bl.ToString().Substring(0, bl.ToString().Length - 1);
//Recherche tous les handlers d'évenement pour les objets concernés
CListeObjetsDonnees listeHandler = new CListeObjetsDonnees(contexte, typeof(CHandlerEvenement));
listeHandler.Filtre = new CFiltreData(
CHandlerEvenement.c_champIdCible + " in (" + strIdsElementsAVerifierHandlers + ") and " +
CHandlerEvenement.c_champTypeCible + "=@1 and " +
CHandlerEvenement.c_champTypeEvenement + "=@2",
tpObjets.ToString(),
(int)TypeEvenement.Modification);
listeHandler.PreserveChanges = true;
foreach (CHandlerEvenement handler in listeHandler)
{
if (handler.Row.RowState != DataRowState.Deleted)
{
CObjetDonneeAIdNumerique objetTmp = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tpObjets, new object[] { contexte });
if (objetTmp.ReadIfExists(handler.IdElementCible))
{
CInfoDeclencheurProcess infoDeclencheur = null;
if (handler.ShoulDeclenche(objetTmp, ref infoDeclencheur))
{
if (infoDeclencheur != null && handler.EvenementLie != null)
{
infoDeclencheur.Info = handler.EvenementLie.Libelle;
}
traitement.AddCoupleHandlerObjet(handler, (CObjetDonneeAIdNumerique)objetTmp, infoDeclencheur);
}
}
}
}
}
}
//Annule les évenements spécifiques, ils ont été traités !
foreach (CObjetDonnee objet in lstObjetsAvecEvenementsSpecifiques)
{
EvenementAttribute.ClearEvenements(objet);
}
}
}
//Execute ce qui peut être executé tout de suite
foreach (DataTable table in contexte.Tables)
{
table.RowChanged += handlerRedo;
}
listeElementsARepasser.Clear();
foreach (CTraitementApresSauvegarde.CCoupleDeclencheurObjet couple in traitement.CouplesEvenementOuHandlerObjet)
{
if (couple.Objet is CObjetDonneeAIdNumerique &&
couple.PeutEtreExecuteSurLePosteClient)
{
result = couple.OnDeclencheSurClient();
if (!result)
{
return(result);
}
}
}
foreach (DataTable table in contexte.Tables)
{
table.RowChanged -= handlerRedo;
}
bFirstPasse = false;
}
if (traitement.CouplesEvenementOuHandlerObjet.Count != 0)
{
tableData[c_cleDonneeListeTraitements] = traitement;
}
m_listeElementsARepasser.Remove(contexte);
return(result);
}
/// ///////////////////////////////////////////////
public void AddCoupleHandlerObjet(CHandlerEvenement handler, CObjetDonneeAIdNumerique obj, CInfoDeclencheurProcess infoDeclencheur)
{
m_listeCoupesEvtObj.Add(new CCoupleHandlerObjet(handler, obj, infoDeclencheur));
}
/// ///////////////////////////////////////////////
public void AddCoupleEvenementObjet(CEvenement evt, CObjetDonneeAIdNumerique obj, CInfoDeclencheurProcess infoDeclencheur)
{
m_listeCoupesEvtObj.Add(new CCoupleEvenementObjet(evt, obj, infoDeclencheur));
}
public CCoupleHandlerObjet(CHandlerEvenement handler, CObjetDonneeAIdNumerique obj, CInfoDeclencheurProcess infoDeclencheur)
: base(obj, infoDeclencheur)
{
Handler = handler;
}
private static void OnTachePlanifiee(object state)
{
if (m_bTraitementEnCours || m_bIsSuspended)
{
return;
}
m_bTraitementEnCours = true;
try
{
//La session dévolue aux tâches planifiées est fermée régulierement pour
//Eviter des problèmes de déconnexion (qui ne sont jamais arrivés, mais
//on ne sait jamais ).
if (m_sessionClient == null || !m_sessionClient.IsConnected || m_sessionClient.DateHeureConnexion.AddDays(1) < DateTime.Now)
{
if (m_sessionClient != null)
{
try
{
m_sessionClient.CloseSession();
}
catch
{
}
}
//Ouvre une session pour executer l'action
m_sessionClient = CSessionClient.CreateInstance();
CResultAErreur result = m_sessionClient.OpenSession(new CAuthentificationSessionServer(),
"Evenements sur date",
ETypeApplicationCliente.Service);
if (!result)
{
C2iEventLog.WriteErreur("Erreur ouverture de session pour Evenements sur date");
return;
}
}
try
{
using (CContexteDonnee contexte = new CContexteDonnee(m_sessionClient.IdSession, true, false))
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, typeof(CHandlerEvenement));
liste.Filtre = new CFiltreData(CHandlerEvenement.c_champDateHeureDeclenchement + " < @1 and " +
CHandlerEvenement.c_champEtatExecution + "=@2",
DateTime.Now,
(int)EtatHandlerAction.AExecuter
);
foreach (CHandlerEvenement handler in liste)
{
CResultAErreur result = CResultAErreur.True;
C2iExpression formuleCondition = handler.FormuleCondition;
bool bShouldDeclenche = false;
CContexteEvaluationExpression ctxEval;
ctxEval = new CContexteEvaluationExpression(handler.ElementSurveille);
if (formuleCondition != null)
{
result = formuleCondition.Eval(ctxEval);
if (!result)
{
bShouldDeclenche = false;
C2iEventLog.WriteErreur("Erreur déclenchement handler " + handler.Id + " : erreur lors de l'évaluation de la condition");
}
else
{
if (result.Data is bool)
{
bShouldDeclenche = (bool)result.Data;
}
else
{
bShouldDeclenche = result.Data != null && result.Data.ToString() != "" && result.Data.ToString() != "0";
}
}
}
if (bShouldDeclenche)
{
if (handler.EvenementLie != null)
{
CInfoDeclencheurProcess infoDeclencheur = new CInfoDeclencheurProcess();
infoDeclencheur.TypeDeclencheur = TypeEvenement.Date;
infoDeclencheur.Info = handler.EvenementLie.Libelle;
result = handler.EvenementLie.RunEvent(handler.ElementSurveille, infoDeclencheur, null);
}
else if (handler.ProcessSource != null)
{
result = handler.RunEvent(
false,
handler.ElementSurveille,
new CInfoDeclencheurProcess(TypeEvenement.Date),
null);
}
else if (handler.EtapeWorkflowATerminer != null)
{
result = handler.RunEvent(
false,
handler.ElementSurveille,
new CInfoDeclencheurProcess(TypeEvenement.Date),
null);
}
}
handler.EndHandler(result);
}
}
}
catch (Exception e)
{
C2iEventLog.WriteErreur("Erreur Taches planifiées " + e.ToString());
}
finally
{
}
}
finally
{
m_bTraitementEnCours = false;
}
}
