/// <summary>
/// Démarre une action
/// </summary>
/// <param name="process"></param>
/// <param name="nIdSession"></param>
/// <returns></returns>
public static CResultAErreur StartProcess(CProcess process, CReferenceObjetDonnee refCible, int nIdSession, int?nIdVersion, bool bHideProgress)
{
CFormExecuteProcess form = new CFormExecuteProcess();
form.Top = 0;
form.Left = Screen.PrimaryScreen.WorkingArea.Width / 2 - form.Width / 2;
if (bHideProgress)
{
return(CProcessEnExecutionInDb.StartProcess(
process,
new CInfoDeclencheurProcess(TypeEvenement.Manuel),
refCible,
nIdSession,
nIdVersion,
null));
}
else
{
IAsyncResult res = form.m_startProcess.BeginInvoke(process, refCible, nIdSession, nIdVersion,
new AsyncCallback(form.OnEndProcess), null);
form.ShowDialog(); //Bloque le code ici !
CResultAErreur result = form.m_startProcess.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 override CResultAErreur VerifieDonnees(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
try
{
CProcessEnExecutionInDb ProcessEnExecution = (CProcessEnExecutionInDb)objet;
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
/// /////////////////////////////////////////////////////////////////////////
/// <summary>
/// Relance une action
/// </summary>
/// <param name="processEnExec"></param>
/// <param name="nIdAction"></param>
/// <returns></returns>
public static CResultAErreur RepriseAction(CProcessEnExecutionInDb processEnExec, int nIdAction)
{
CFormExecuteProcess form = new CFormExecuteProcess();
form.Top = 0;
form.Left = Screen.PrimaryScreen.WorkingArea.Width / 2 - form.Width / 2;
IAsyncResult res = form.m_repriseAction.BeginInvoke(processEnExec, nIdAction,
new AsyncCallback(form.OnEndProcess), null);
form.ShowDialog(); //Bloque le code ici !
CResultAErreur result = form.m_repriseAction.EndInvoke(res);
return(result);
}
//-------------------------------------------------------------
public CResultAErreur StartProcess(CEtapeWorkflow etape)
{
CResultAErreur result = CResultAErreur.True;
CProcess process = m_process;
if (process == null)
{
if (m_dbKeyProcess != null)
{
CProcessInDb processInDb = new CProcessInDb(etape.ContexteDonnee);
if (processInDb.ReadIfExists(m_dbKeyProcess))
{
process = processInDb.Process;
}
}
}
if (process != null)
{
if (process.Libelle.Trim().Length == 0 && etape != null)
{
process.Libelle = I.T("Step @1|20109", etape.Libelle);
}
result = CProcessEnExecutionInDb.StartProcess(process, new CInfoDeclencheurProcess(TypeEvenement.Specifique),
new CReferenceObjetDonnee(etape),
etape.ContexteDonnee.IdSession,
null,
null);
if (result)
{
etape.Refresh();//Relit l'étape car elle a pu être modifiée par le process
if (m_bUtiliserSortieDeProcessCommeCodeRetour && (result.Data is string || result.Data is string[]))
{
if (result.Data is string)
{
etape.CodesRetour = new string[] { (string)result.Data }
}
;
if (result.Data is string[])
{
etape.CodesRetour = (string[])result.Data;
}
}
result = EndAndSaveIfOk(etape);
}
}
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"));
}
}
/// /////////////////////////////////////////////////////////////////////////
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 CResultAErreur RepriseActionPrivate(CProcessEnExecutionInDb processEnExec, int nIdAction)
{
return(processEnExec.RepriseProcess(nIdAction, this));
}
/* les parametres sont passés dans le table de paramètres :
* Id de la variable, suivi de sa valeur( en texte ),...
*
*/
public string StartAction(int nIdAction, string[] strParametres)
{
DataSet ds = new DataSet();
if (!AssureSession())
{
return("ERROR : " + I.T("Session error|30002"));
}
if ((strParametres.Length % 2) != 0)
{
return("ERROR : " + I.T("The parameters are not passed correctly|30003"));
}
using (CContexteDonnee contexte = new CContexteDonnee(m_session.IdSession, true, false))
{
CProcessInDb processInDb = new CProcessInDb(contexte);
if (!processInDb.ReadIfExists(nIdAction))
{
return("ERROR : " + I.T("The action @1 does not exist|30004", nIdAction.ToString()));
}
CProcess process = processInDb.Process;
#region Affectation des variables du process
for (int nVariable = 0; nVariable < strParametres.Length; nVariable += 2)
{
string strVariable = strParametres[nVariable];
IVariableDynamique variable = null;
try
{
variable = process.GetVariable(strVariable);
}
catch
{
foreach (CVariableDynamique varTest in process.ListeVariables)
{
if (varTest.Nom.ToUpper() == strVariable.ToUpper())
{
variable = varTest;
break;
}
}
if (variable == null)
{
return("ERROR : " + I.T("@1 is not a valid variable id|30005", strVariable));
}
}
if (!(variable is CVariableDynamiqueSaisie))
{
return("ERROR : " + I.T("The variable @1 is not valid or does not exist|30006", strVariable));
}
try
{
object valeur = ((CVariableDynamiqueSaisie)variable).TypeDonnee2i.StringToType(strParametres[nVariable + 1], null);
process.SetValeurChamp(variable, valeur);
}
catch
{
return("ERROR : " + I.T("Error in affectation of variable @1|30007", variable.Nom));
}
}
#endregion
//Note : le service web ne sait pas lancer un process dans une version
CResultAErreur result = CProcessEnExecutionInDb.StartProcess(process, new CInfoDeclencheurProcess(TypeEvenement.Manuel), m_session.IdSession, null, null);
if (!result)
{
return("ERROR : " + result.Erreur.ToString());
}
if (result.Data != null)
{
return(result.Data.ToString());
}
return(null);
}
}
/// //////////////////////////////////////////////////
public CResultAErreur RepriseProcess(int nIdProcessEnExecution,
int nIdAction,
IIndicateurProgression indicateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(indicateur);
CResultAErreur result = CResultAErreur.True;
///Stef, 290808 : ouvre une session spécifique pour le process
///Pour pouvoir gérer le changement d'utilisateur proprement
CSousSessionClient session = CSousSessionClient.GetNewSousSession(IdSession);
session.OpenSession(new CAuthentificationSessionSousSession(IdSession), "Continue process " + nIdProcessEnExecution, ETypeApplicationCliente.Process);
CSessionClient sessionOriginale = CSessionClient.GetSessionForIdSession(IdSession);
//TESTDBKEYTODO
if (sessionOriginale.GetInfoUtilisateur() != null)
{
session.ChangeUtilisateur(sessionOriginale.GetInfoUtilisateur().KeyUtilisateur);
}
try
{
//Stef 08/12/2007 : le contexte ne reçoit plus les notifications
using (CContexteDonnee contexteDonnee = new CContexteDonnee(session.IdSession, true, false))
{
CProcessEnExecutionInDb processEnExecution = new CProcessEnExecutionInDb(contexteDonnee);
if (!processEnExecution.ReadIfExists(nIdProcessEnExecution))
{
result.EmpileErreur(I.T("Current action @1 doesn't exist|30012", nIdProcessEnExecution.ToString()));
return(result);
}
result = contexteDonnee.SetVersionDeTravail(processEnExecution.IdVersionExecution, true);
if (!result)
{
return(result);
}
CBrancheProcess branche = processEnExecution.BrancheEnCours;
CContexteExecutionAction contexteExecution = new CContexteExecutionAction(
processEnExecution, branche, branche.Process.GetValeurChamp(CProcess.c_strIdVariableElement), contexteDonnee, indicateur);
CAction action = branche.Process.GetActionFromId(nIdAction);
if (action == null)
{
result.EmpileErreur(I.T("Impossible to resume the processing : the action @1 doesn't exist|30013", nIdAction.ToString()));
return(result);
}
bool bTrans = false;
if (branche.Process.ModeTransactionnel)
{
session.BeginTrans();
bTrans = true;
}
try
{
result = branche.ExecuteAction(action, 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();
}
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
try
{
session.CloseSession();
}
catch { }
}
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);
}
}
}
//-------------------------------------------------------------------------
public CFormEditionProcessEnExecution(CProcessEnExecutionInDb processEnExec, CListeObjetsDonnees liste)
: base(processEnExec, liste)
{
// Cet appel est requis par le Concepteur Windows Form.
InitializeComponent();
}
//-------------------------------------------------------------------------
public CFormEditionProcessEnExecution(CProcessEnExecutionInDb processEnExec)
: base(processEnExec)
{
// Cet appel est requis par le Concepteur Windows Form.
InitializeComponent();
}
//-----------------------------------------------------------
public static CResultAErreur RunProcess(int nIdProcess, Dictionary <string, string> valeursParametres)
{
AssureTimerNettoyage();
CResultAErreur result = GetSession();
if (!result)
{
return(result);
}
CDonneeSessionProcess donneeSession = result.Data as CDonneeSessionProcess;
result = CResultAErreur.True;
try
{
CSessionClient session = donneeSession.SessionClient;
using (CContexteDonnee contexte = new CContexteDonnee(session.IdSession, true, false))
{
CProcessInDb processInDb = new CProcessInDb(contexte);
if (!processInDb.ReadIfExists(nIdProcess))
{
result.EmpileErreur(I.T("The process @1 doesn't exist|30008", nIdProcess.ToString()));
result.Data = (int)EErreurs.ProcessDoesntExists;
return(result);
}
CProcess process = processInDb.Process;
foreach (KeyValuePair <string, string> parametre in valeursParametres)
{
string strParametre = parametre.Key;
string strValeur = parametre.Value;
bool bTrouvee = false;
foreach (IVariableDynamique variable in process.ListeVariables)
{
if (strParametre.ToUpper() == variable.Nom.ToUpper())
{
if (!variable.TypeDonnee.TypeDotNetNatif.IsValueType && variable.TypeDonnee.TypeDotNetNatif != typeof(string))
{
result.EmpileErreur(I.T("Variable @1 cannot be set by TimosProcess. Only simple values can be used|30009", variable.Nom));
result.Data = (int)EErreurs.InvalidVariableValueOnlySimpleValuesAreAccepted;
return(result);
}
try
{
object valeur = CUtilTexte.FromUniversalString(strValeur, variable.TypeDonnee.TypeDotNetNatif);
}
catch
{
}
process.SetValeurChamp(variable.IdVariable, strValeur);
bTrouvee = true;
break;
}
}
if (!bTrouvee)
{
result = ShowHelp(process);
result.EmpileErreur(I.T("Unknown variable @1|30010", strParametre));
result.Data = (int)EErreurs.UnknownVariable;
return(result);
}
}
result = CProcessEnExecutionInDb.StartProcess(process, new CInfoDeclencheurProcess(TypeEvenement.Manuel), session.IdSession, null, null);
if (!result)
{
result.Data = (int)EErreurs.ErrorWhileRunningProcess;
return(result);
}
if (result.Data != null)
{
try
{
result.Data = Convert.ToInt32(result.Data);
}
catch
{
}
return(result);
}
else
{
result.Data = 0;
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.Data = (int)EErreurs.ErrorWhileRunningProcess;
return(result);
}
finally
{
lock (typeof(CLanceurProcessCommandLine))
{
donneeSession.EndUsing();
}
}
return(result);
}
