/// //////////////////////////////////////////////////////// protected override CResultAErreur MyExecute(CContexteExecutionAction contexte) { CBrancheProcess branche = new CBrancheProcess(m_processFils); branche.IsModeAsynchrone = false; //TESTDBKEYOK branche.KeyUtilisateur = contexte.Branche.KeyUtilisateur; branche.ConfigurationImpression = contexte.Branche.ConfigurationImpression; CContexteExecutionAction contexteExecution = new CContexteExecutionAction( contexte.ProcessEnExecution, branche, contexte.ObjetCible, contexte.ContexteDonnee, contexte.IndicateurProgression); contexteExecution.SauvegardeContexteExterne = true; CAction pointEntree = m_processFils.GetActionDebut(); CResultAErreur result = CResultAErreur.True; result = branche.ExecuteAction(pointEntree, contexteExecution, contexte.ObjetCible, false); foreach (CContexteExecutionAction.CParametreServiceALancerALaFin p in contexteExecution.ServicesALancerALaFin) { contexte.AddServiceALancerALaFin(p); } contexteExecution.ClearServicesALancerALaFin(); return(result); }
//////////////////////////////////////////////////////////////////////////////// public CInfoPileExecution(CLienAction lienSource, CAction actionExecutee) { m_nIdAction = actionExecutee.IdObjetProcess; if (lienSource != null) { m_nIdLienArrivant = lienSource.IdActionArrivee; } }
/// //////////////////////////////////////////////////////// public void AddAction(CAction action) { if (action is CActionDebut && GetActionDebut() != null) { return; } ListeActions.Add(action); m_ordreZ.Add(action); if (OnChangeListeActions != null) { OnChangeListeActions(this, new EventArgs()); } }
/// //////////////////////////////////////////////////////// public CLienAction[] GetLiensForAction(CAction action, bool bArrivant, bool bHorsErreur) { ArrayList lstLiens = new ArrayList(); foreach (CLienAction lien in ListeLiens) { if (!bHorsErreur || !(lien is CLienErreur)) { if (bArrivant && lien.IdActionArrivee == action.IdObjetProcess) { lstLiens.Add(lien); } if (!bArrivant && lien.IdActionDepart == action.IdObjetProcess) { lstLiens.Add(lien); } } } return((CLienAction[])lstLiens.ToArray(typeof(CLienAction))); }
/// //////////////////////////////////////////////////////// public void RemoveAction(CAction action) { if (action is CActionDebut) { return; } foreach (CLienAction lien in Liens) { if (lien.IdActionArrivee == action.IdObjetProcess || lien.IdActionDepart == action.IdObjetProcess) { RemoveLien(lien); } } ListeActions.Remove(action); if (m_ordreZ.Contains(action)) { m_ordreZ.Remove(action); } if (OnChangeListeActions != null) { OnChangeListeActions(this, new EventArgs()); } }
private void AssurePositionOk( ) { if (!m_bPositionInvalide)//Vérifie que le départ et l'arrivé n'ont pas bougé { if (ActionDepart != null && ActionDepart.RectangleAbsolu != m_lastRectangleDepart || ActionArrivee != null && ActionArrivee.RectangleAbsolu != m_lastRectangleArrivee) { m_bPositionInvalide = true; } } if (m_bPositionInvalide) { Point pt1; CAction actionDepart = ActionDepart; if (actionDepart == null) { pt1 = m_lastPointDepart; } else { m_lastRectangleDepart = actionDepart.RectangleAbsolu; pt1 = GetCentreRect(m_lastRectangleDepart); } Point pt2; CAction actionArrivee = ActionArrivee; if (actionArrivee == null) { pt2 = m_lastPointArrivee; } else { m_lastRectangleArrivee = actionArrivee.RectangleAbsolu; pt2 = GetCentreRect(m_lastRectangleArrivee); } m_lienTracable = CTraceurLienDroit.GetLien(pt1, pt2, ModeSortieDuLien); if (actionDepart != null) { Point[] pts1 = actionDepart.GetPolygoneDessin(); //Suppression des segments inutiles int nLastIntersect = 0; CSegmentDroite[] segments = m_lienTracable.Segments; for (nLastIntersect = segments.Count() - 1; nLastIntersect > 0; nLastIntersect--) { Point dummy = new Point(0, 0); if (segments[nLastIntersect].GetIntersectionPoint(pts1, ref dummy)) { break; } } for (int n = 0; n < nLastIntersect; n++) { m_lienTracable.RemovePoint(0); } if (m_lienTracable.Points.Count() > 1) { CSegmentDroite segment = new CSegmentDroite(m_lienTracable.Points.ElementAt(0), m_lienTracable.Points.ElementAt(1)); if (segment.GetIntersectionPoint(pts1, ref pt1)) { m_lienTracable.RemplacePoint(0, pt1); } } } if (actionArrivee != null) { Point[] pts2 = actionArrivee.GetPolygoneDessin(); //Suppression des segments inutiles CSegmentDroite[] segments = m_lienTracable.Segments; int nLastIntersect = segments.Count() - 1; for (nLastIntersect = 0; nLastIntersect < segments.Count() - 1; nLastIntersect++) { Point dummy = new Point(0, 0); if (segments[nLastIntersect].GetIntersectionPoint(pts2, ref dummy)) { break; } } for (int n = nLastIntersect + 1; n < segments.Count(); n++) { m_lienTracable.RemovePoint(m_lienTracable.Points.Count() - 1); } if (m_lienTracable.Points.Count() > 1) { CSegmentDroite segment = new CSegmentDroite( m_lienTracable.Points.ElementAt(m_lienTracable.Points.Count() - 2), m_lienTracable.Points.ElementAt(m_lienTracable.Points.Count() - 1)); if (segment.GetIntersectionPoint(pts2, ref pt2)) { m_lienTracable.RemplacePoint(m_lienTracable.Points.Count() - 1, pt2); } } } m_lastPointDepart = m_lienTracable.Points.ElementAt(0);; m_lastPointArrivee = m_lienTracable.Points.ElementAt(m_lienTracable.Points.Count() - 1); m_bPositionInvalide = false; } }
/// //////////////////////////////////////////////////////// public CLienAction[] GetLiensForAction(CAction action, bool bArrivant) { return(GetLiensForAction(action, bArrivant, false)); }
/// <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 ExecuteAction(CAction action, CContexteExecutionAction contexte, bool bIsActionPrincipaleProcess) { return(ExecuteAction(action, contexte, contexte.ObjetCible, bIsActionPrincipaleProcess)); }
/// <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 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); }