/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CDonneeActionForEach donnee = (CDonneeActionForEach)contexte.Branche.GetDataAction(IdObjetProcess);
if (donnee == null)
{
donnee = new CDonneeActionForEach();
donnee.Position = 0;
}
contexte.Branche.StockeDataAction(IdObjetProcess, donnee);
IList liste = (IList)Process.GetValeurChamp(VariableListe.IdVariable);
CLienAction lienBoucle = null;
CLienAction lienFinal = null;
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienBoucle)
{
lienBoucle = lien;
}
else
{
lienFinal = lien;
}
}
ArrayList lstCopie = new ArrayList(liste);
liste = lstCopie;
for (int nPosition = 0; nPosition < liste.Count && lienBoucle != null; nPosition++)
{
try
{
if (contexte.IndicateurProgression != null && contexte.IndicateurProgression.CancelRequest)
{
result.EmpileErreur(I.T("User cancellation|182"));
return(result);
}
}
catch { }
Process.SetValeurChamp(VariableElementEnCours, liste[nPosition]);
contexte.PushElementInfoProgress(liste[nPosition]);
contexte.SetInfoProgression(nPosition.ToString() + "/" + liste.Count.ToString());
donnee.Position = nPosition;
if (lienBoucle != null)
{
result = contexte.Branche.ExecuteAction(lienBoucle.ActionArrivee, contexte, false);
}
contexte.PopElementInfoProgress();
if (!result)
{
return(result);
}
}
result.Data = lienFinal;
return(result);
}
/// ////////////////////////////////////////////////////////
public void RemoveLien(CLienAction lien)
{
ListeLiens.Remove(lien);
if (m_ordreZ.Contains(lien))
{
m_ordreZ.Remove(lien);
}
}
////////////////////////////////////////////////////////////////////////////////
public CInfoPileExecution(CLienAction lienSource, CAction actionExecutee)
{
m_nIdAction = actionExecutee.IdObjetProcess;
if (lienSource != null)
{
m_nIdLienArrivant = lienSource.IdActionArrivee;
}
}
/// ////////////////////////////////////////////////////////
public void AddLien(CLienAction lien)
{
ListeLiens.Add(lien);
m_ordreZ.Insert(0, lien);
}
/// <summary>
/// Execute une action
/// </summary>
/// <param name="action"></param>
/// <param name="contexte"></param>
/// <param name="bIsActionPrincipaleProcess">Si vrai, considère que le process en execution est fermé en sortie,
/// si non, il s'agit d'une action appelée dans une boucle par exemple</param>
/// <returns></returns>
public CResultAErreur ExecuteAction(
CAction action,
CContexteExecutionAction contexte,
object objetCible,
bool bIsActionPrincipaleProcess)
{
CResultAErreur result = CResultAErreur.True;
m_pile.Add(new CInfoPileExecution(null, action));
m_nIdActionEnCours = action.IdObjetProcess;
action.Process.SetValeurChamp(CProcess.c_strIdVariableElement, objetCible);
bool bFermerLaSessionEnSortant = IsModeAsynchrone && bIsActionPrincipaleProcess;
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
CConfigurationsImpression oldConf = null;
contexte.SetInfoProgression(action.Libelle);
try
{
if (contexte.IndicateurProgression != null && contexte.IndicateurProgression.CancelRequest)
{
result.EmpileErreur(I.T("User cancellation|182"));
result.Data = null;
return(result);
}
}
catch { }
if (sessionClient != null)
{
oldConf = sessionClient.ConfigurationsImpression;
}
try
{
if (sessionClient != null)
{
sessionClient.ConfigurationsImpression = ConfigurationImpression;
}
action.Process.ContexteExecution = contexte;
result = action.Execute(contexte);
while (result.Data != null && result)
{
//retourne un lien : on continue
if (result.Data is CLienAction)
{
m_nIdActionEnCours = action.IdObjetProcess;
CLienAction lien = (CLienAction)result.Data;
m_pile.Add(new CInfoPileExecution(lien, lien.ActionArrivee));
contexte.ProcessEnExecution.LibelleActionEnCours = lien.ActionArrivee.Libelle;
if (lien is CLienAsynchrone && !IsModeAsynchrone)
{
IsModeAsynchrone = true;
//Execution de l'action en mode asynchrone et fin
m_actionAsynchroneAExecuter = lien.ActionArrivee;
m_contexteAsynchrone = contexte;
Thread th = new Thread(new ThreadStart(ExecuteActionAsynchrone));
th.Start();
bFermerLaSessionEnSortant = false;
result.Data = null;
return(result);
}
else
{
action = ((CLienAction)result.Data).ActionArrivee;
action.Process.ContexteExecution = contexte;
contexte.SetInfoProgression(action.Libelle);
try
{
if (contexte.IndicateurProgression != null && contexte.IndicateurProgression.CancelRequest)
{
result.EmpileErreur(I.T("User cancellation|182"));
result.Data = null;
return(result);
}
}
catch { }
result = action.Execute(contexte);
}
}
else if (result.Data is CMetteurDeProcessEnPause)
{
//Mise en pause du process
result = contexte.ProcessEnExecution.PauseProcess(contexte);
result.Data = null;
return(result);
}
else
{
result.Data = null;
}
}
if (bIsActionPrincipaleProcess && result)
{
CResultAErreur resultTmp = contexte.ProcessEnExecution.EnProcess(contexte);
if (!resultTmp)
{
result.Erreur += resultTmp.Erreur;
result.Result = false;
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
if (sessionClient != null)
{
sessionClient.ConfigurationsImpression = oldConf;
}
if (!result && bIsActionPrincipaleProcess)
{
//Pour ne modifier que le process et ne surtout pas faire les sauvegardes autres
contexte.ProcessEnExecution.BeginEdit();
contexte.ProcessEnExecution.Etat = EtatProcess.Erreur;
contexte.ProcessEnExecution.BrancheEnCours = this;
contexte.ProcessEnExecution.InfoEtat = result.Erreur.ToString();
if (IsModeAsynchrone)
{
//Notifie l'utilisateur qu'un erreur est survenue
CBesoinInterventionProcess intervention = new CBesoinInterventionProcess(contexte.ProcessEnExecution.ContexteDonnee);
intervention.CreateNewInCurrentContexte();
intervention.Libelle = I.T("@1 action error|259", contexte.ProcessEnExecution.Libelle);
intervention.DateDemande = DateTime.Now;
//Crée une boite de message pour afficher l'erreur
CProcess process = contexte.Branche.Process;
CActionMessageBox actionNotif = new CActionMessageBox(process);
actionNotif.FormuleMessage = new sc2i.expression.C2iExpressionConstante(intervention.Libelle + "\r\n" + result.Erreur.ToString());
actionNotif.Libelle = I.T("Error notification|260");
process.AddAction(actionNotif);
intervention.IdAction = actionNotif.IdObjetProcess;
//TESTDBKEYOK
intervention.KeyUtilisateur = KeyUtilisateur;
intervention.ProcessEnExecution = contexte.ProcessEnExecution;
contexte.ProcessEnExecution.BrancheEnCours = contexte.Branche;
}
contexte.ProcessEnExecution.CommitEdit();
}
if (IsModeAsynchrone && bFermerLaSessionEnSortant)
{
//Ferme la session
try
{
CSessionClient session = CSessionClient.GetSessionForIdSession(contexte.IdSession);
session.CloseSession();
}
catch {}
}
}
result.Data = null;
return(result);
}
/// ////////////////////////////////////////////////////////
public CResultAErreur ExecuteLien(CContexteExecutionAction contexte, CLienAction lien)
{
return(lien.ActionArrivee.Execute(contexte));
}
/// <summary>
/// Crée un process fils à partir des actions d'un process.
/// Les actions listées sont mises dans le process fils
/// </summary>
/// <param name="process"></param>
/// <param name="actions"></param>
/// <returns>Le data du result contient le process fils créé</returns>
public static CResultAErreur CreateForSelection(CAction[] actions)
{
CResultAErreur result = CResultAErreur.True;
if (actions.Length == 0)
{
result.EmpileErreur(I.T("Can not create action group from empty selection|20035"));
return(result);
}
CProcess process = actions[0].Process;
//Vérifie qu'il n'y a qu'un seul lien sortant et un seul lien entrant
HashSet <CAction> dicActionsInSel = new HashSet <CAction>();
foreach (CAction action in actions)
{
dicActionsInSel.Add(action);
}
CLienAction lienEntrant = null;
Rectangle rctEnglobant = actions[0].RectangleAbsolu;
List <CLienAction> liensSortants = new List <CLienAction>();
foreach (CAction action in actions)
{
foreach (CLienAction lien in action.GetLiensArrivant())
{
if (!dicActionsInSel.Contains(lien.ActionDepart))
{
if (lienEntrant == null)
{
lienEntrant = lien;
break;
}
else
{
result.EmpileErreur(I.T("Selection should contains only one ingoing link|20036"));
return(result);
}
}
if (!dicActionsInSel.Contains(lien.ActionArrivee))
{
if (lien.GetType() != typeof(CLienAction))
{
result.EmpileErreur(I.T("Can not group actions with complex outgoing link|20037"));
}
}
}
foreach (CLienAction lien in action.GetLiensSortant())
{
if (!dicActionsInSel.Contains(lien.ActionArrivee))
{
liensSortants.Add(lien);
}
}
CActionProcessFils pf = action as CActionProcessFils;
if (pf != null)
{
foreach (IVariableDynamique variable in pf.ProcessFils.ListeVariables)
{
if (!pf.ProcessFils.IsVariableDeProcessParent(variable))
{
result.EmpileErreur(I.T("Can not group a group with variables|20039"));
return(result);
}
}
}
Rectangle rctAction = action.RectangleAbsolu;
rctEnglobant.Location = new Point(
Math.Min(rctEnglobant.Left, rctAction.Left),
Math.Min(rctEnglobant.Top, rctAction.Top));
rctEnglobant.Size = new Size(
Math.Max(rctEnglobant.Width, rctAction.Right - rctEnglobant.Left),
Math.Max(rctEnglobant.Height, rctAction.Bottom - rctEnglobant.Top));
}
//Crée le process fils
CActionProcessFils actionFils = new CActionProcessFils(process);
actionFils.Position = new Point(rctEnglobant.Left + (rctEnglobant.Width - actionFils.Size.Width) / 2,
rctEnglobant.Top + (rctEnglobant.Height - actionFils.Size.Height) / 2);
CProcess processFils = actionFils.ProcessFils;
Dictionary <CAction, CAction> dicCorrespondanceActions = new Dictionary <CAction, CAction>();
int nOffsetX = processFils.GetActionDebut().Position.X - rctEnglobant.Left;
int nOffsetY = processFils.GetActionDebut().Position.Y + 40 - rctEnglobant.Top;
foreach (CAction action in actions)
{
CAction newAction = Activator.CreateInstance(action.GetType(), new object[] { processFils }) as CAction;
CCloner2iSerializable.CopieTo(action, newAction);
newAction.Position = new Point(newAction.Position.X + nOffsetX,
newAction.Position.Y + nOffsetY);
dicCorrespondanceActions[action] = newAction;
processFils.AddAction(newAction);
}
//copie des liens
HashSet <CLienAction> hashLiens = new HashSet <CLienAction>();
//Crée la liste de tous les liens
foreach (CAction action in actions)
{
foreach (CLienAction lien in action.GetLiensSortant())
{
if (!liensSortants.Contains(lien) && !hashLiens.Contains(lien))
{
hashLiens.Add(lien);
}
}
foreach (CLienAction lien in action.GetLiensArrivant())
{
if (lien != lienEntrant && !hashLiens.Contains(lien))
{
hashLiens.Add(lien);
}
}
}
foreach (CLienAction lien in hashLiens)
{
CAction actionDepart = null;
CAction actionArrivee = null;
if (!dicCorrespondanceActions.TryGetValue(lien.ActionDepart, out actionDepart))
{
result.EmpileErreur(I.T("An error occured during grouping process|20038"));
return(result);
}
if (!dicCorrespondanceActions.TryGetValue(lien.ActionArrivee, out actionArrivee))
{
result.EmpileErreur(I.T("An error occured during grouping process|20038"));
return(result);
}
CLienAction newLien = Activator.CreateInstance(lien.GetType(), new object[] { processFils }) as CLienAction;
CCloner2iSerializable.CopieTo(lien, newLien);
newLien.ActionArrivee = actionArrivee;
newLien.ActionDepart = actionDepart;
processFils.AddLien(newLien);
}
//Crée le lien de départ
if (lienEntrant != null)
{
CLienAction newLienDepart = new CLienAction(processFils);
newLienDepart.ActionDepart = processFils.GetActionDebut();
newLienDepart.ActionArrivee = dicCorrespondanceActions[lienEntrant.ActionArrivee];
processFils.AddLien(newLienDepart);
CAction action1 = newLienDepart.ActionArrivee;
CAction actionStart = newLienDepart.ActionDepart;
actionStart.Position = new Point(
action1.Position.X + (action1.Size.Width - actionStart.Size.Width) / 2,
actionStart.Position.Y);
}
process.AddAction(actionFils);
//Modifie le lien de départ
if (lienEntrant != null)
{
lienEntrant.ActionArrivee = actionFils;
}
foreach (CLienAction lien in liensSortants)
{
lien.ActionDepart = actionFils;
}
foreach (CAction action in actions)
{
process.RemoveAction(action);
}
result.Data = actionFils;
return(result);
}
/// ////////////////////////////////////////////////////////
///Le data du result contient la liste des actions dégroupées
public CResultAErreur Degrouper()
{
CResultAErreur result = CResultAErreur.True;
foreach (IVariableDynamique variable in m_processFils.ListeVariables)
{
if (!m_processFils.IsVariableDeProcessParent(variable))
{
result.EmpileErreur(I.T("Can not ungroup a group with variables|20040"));
return(result);
}
}
Dictionary <CAction, CAction> dicCorrespondanceActions = new Dictionary <CAction, CAction>();
foreach (CAction action in m_processFils.Actions)
{
if (action.GetType() != typeof(CActionDebut))
{
CAction newAction = Activator.CreateInstance(action.GetType(), new object[] { Process }) as CAction;
CCloner2iSerializable.CopieTo(action, newAction);
newAction.Position = new Point(newAction.Position.X + Position.X,
newAction.Position.Y + Position.Y);
dicCorrespondanceActions[action] = newAction;
Process.AddAction(newAction);
}
}
//Crée les liens
CLienAction lienDebut = null;
CAction startAction = m_processFils.GetActionDebut();
List <CLienAction> lstLiens = new List <CLienAction>();
foreach (CLienAction lien in m_processFils.Liens)
{
CAction actionDepart = null;
CAction actionArrivee = null;
if (lien.ActionDepart == startAction)
{
lienDebut = lien;
}
else
{
if (!dicCorrespondanceActions.TryGetValue(lien.ActionDepart, out actionDepart))
{
result.EmpileErreur(I.T("An error occured during grouping process|20038"));
return(result);
}
if (!dicCorrespondanceActions.TryGetValue(lien.ActionArrivee, out actionArrivee))
{
result.EmpileErreur(I.T("An error occured during grouping process|20038"));
return(result);
}
CLienAction newLien = Activator.CreateInstance(lien.GetType(), new object[] { Process }) as CLienAction;
CCloner2iSerializable.CopieTo(lien, newLien);
newLien.ActionArrivee = actionArrivee;
newLien.ActionDepart = actionDepart;
Process.AddLien(newLien);
}
}
//Modifie les liens entrants
foreach (CLienAction lien in GetLiensArrivant())
{
if (lienDebut == null)
{
Process.RemoveLien(lien);
}
else
{
//Modifie l'action arrivée du lien
lien.ActionArrivee = dicCorrespondanceActions[lienDebut.ActionArrivee];
}
}
CLienAction lienSortant = null;
foreach (CLienAction lien in GetLiensSortant())
{
if (lien.GetType() == typeof(CLienAction))//Lien simple
{
lienSortant = lien;
}
}
List <CAction> lstRetour = new List <CAction>(dicCorrespondanceActions.Values);
if (lienSortant != null)
{
foreach (CAction action in lstRetour)
{
foreach (CLienAction lien in action.GetLiensSortantsPossibles())
{
if (!(lien is CLienErreur))
{
lien.ActionDepart = action;
lien.ActionArrivee = lienSortant.ActionArrivee;
Process.AddLien(lien);
}
}
}
}
Process.RemoveAction(this);
result.Data = lstRetour.AsReadOnly();
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur ExecuteAction(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CLienAction lienEvenement = null, lienStd = null;
//Trouve le lien sortant evenement
foreach (CLienAction lien in GetLiensSortantHorsErreur())
{
if (lien is CLienEvenement)
{
lienEvenement = lien;
}
else
{
lienStd = lien;
}
}
if (lienEvenement != null)
{
//Evalue l'élément cible
object obj = null;
obj = Process.GetValeurChamp(IdVariableElement);
if (obj != null && obj.Equals(Process))
{
obj = contexte.ProcessEnExecution;
}
if (obj != null)
{
if (!(obj is CObjetDonneeAIdNumerique))
{
result.EmpileErreur(I.T("The supervised element by the event @1 isn't correct|147", Libelle));
return(result);
}
CHandlerEvenement handler = new CHandlerEvenement(contexte.ContexteDonnee);
bool bShouldCreate = true;
if (TypeDeGestionDuCodeEvenement != TypeGestionCode.PasDeGestionCode)
{
//Vérifie que le handler n'existe pas déjà
CHandlerEvenement handlerExistant = new CHandlerEvenement(contexte.ContexteDonnee);
if (handlerExistant.ReadIfExists(
new CFiltreData(
CHandlerEvenement.c_champTypeCible + "=@1 and " +
CHandlerEvenement.c_champIdCible + "=@2 and " +
CHandlerEvenement.c_champCode + "=@3",
obj.GetType().ToString(),
((CObjetDonneeAIdNumerique)obj).Id,
ParametreDeclencheur.Code)))
{
switch (TypeDeGestionDuCodeEvenement)
{
case TypeGestionCode.NePasCreerSiExiste:
bShouldCreate = false;
break;
case TypeGestionCode.RemplacerSiExiste:
handler = handlerExistant;
bShouldCreate = true;
break;
}
}
}
if (bShouldCreate)
{
int nIdActionArrivee = lienEvenement.IdActionArrivee;
//Programme le handler
if (handler == null)
{
handler = new CHandlerEvenement(contexte.ContexteDonnee);
handler.CreateNewInCurrentContexte();
}
handler.Libelle = LibelleEvenement;
handler.Code = ParametreDeclencheur.Code;
handler.TypeEvenement = ParametreDeclencheur.TypeEvenement;
handler.FormuleCondition = ParametreDeclencheur.FormuleConditionDeclenchement;
handler.ProprieteSurveillee = ParametreDeclencheur.ProprieteASurveiller;
handler.FormuleValeurAvant = ParametreDeclencheur.FormuleValeurAvant;
handler.FormuleValeurApres = ParametreDeclencheur.FormuleValeurApres;
handler.ElementSurveille = (CObjetDonneeAIdNumerique)obj;
handler.DateHeure = null;
handler.ContextesException = ParametreDeclencheur.ContextesException;
handler.HideProgress = ParametreDeclencheur.HideProgress;
//Si date, évalue la formule de date
if (ParametreDeclencheur.TypeEvenement == TypeEvenement.Date)
{
object valeur = null;
if (ParametreDeclencheur.ProprieteASurveiller != null)
{
valeur = CParametreDeclencheurEvenement.GetValeur((CObjetDonnee)obj, ParametreDeclencheur.ProprieteASurveiller, DataRowVersion.Current);
}
if (valeur is CDateTimeEx)
{
valeur = ((CDateTimeEx)valeur).DateTimeValue;
}
if (valeur is DateTime? && valeur != null)
{
valeur = ((DateTime?)valeur).Value;
}
if (valeur is DateTime)
{
CObjetForTestValeurChampCustomDateTime objetEval = new CObjetForTestValeurChampCustomDateTime((DateTime)valeur);
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(objetEval);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
if (ParametreDeclencheur.FormuleDateProgramme == null)
{
result.EmpileErreur(I.T("Impossible to evaluate the date formula for the event release @1|149", Libelle));
return(result);
}
result = ParametreDeclencheur.FormuleDateProgramme.Eval(contexteEval);
}
else
{
result.EmpileErreur(I.T("The date value is incorrect|148"));
return(result);
}
if (!result || !(result.Data is DateTime))
{
result.EmpileErreur(I.T("Date formula is incorrect in the @1 release|150", Libelle));
return(result);
}
handler.DateHeure = new CDateTimeEx((DateTime)result.Data);
}
handler.ProcessSource = contexte.ProcessEnExecution;
handler.IdActionDeProcessToExecute = nIdActionArrivee;
}
}
}
result.Data = lienStd;
return(result);
}