public CResultAErreur AppliqueTo(CEtapeWorkflow etape, bool bIsRedemarrage)
{
CResultAErreur result = CResultAErreur.True;
if (!bIsRedemarrage || RecalculerAffectationsSurRedemarrage)
{
CResultAErreurType <CAffectationsEtapeWorkflow> resAff = Affectations.CalculeAffectations(etape.Workflow);
if (!resAff)
{
result.EmpileErreur(resAff.Erreur);
return(result);
}
etape.Affectations = resAff.DataType;
}
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(etape);
if (FormuleInitialisation != null)
{
if (!bIsRedemarrage || ReevaluerInitialisationSurRedemarrage)
{
result = FormuleInitialisation.Eval(ctx);
}
}
return(result);
}
/// <summary>
/// Retourne l'étape de ce type pour le workflow
/// </summary>
/// <param name="workflow"></param>
/// <returns></returns>
public CResultAErreurType <CEtapeWorkflow> CreateOrGetEtapeInCurrentContexte(CTypeEtapeWorkflow typeEtape)
{
CResultAErreurType <CEtapeWorkflow> result = new CResultAErreurType <CEtapeWorkflow>();
//Vérifie que le workflow n'a pas déjà une étape de ce type
if (typeEtape == null)
{
result.EmpileErreur(I.T("Create step need a step type|20076"));
return(result);
}
//Vérifie que le workflow n'a pas déjà une étape de ce type
CEtapeWorkflow etape = GetEtapeForType(typeEtape);
bool bIsRedemarrage = true;
if (etape == null)
{
etape = new CEtapeWorkflow(ContexteDonnee);
etape.CreateNewInCurrentContexte();
etape.Workflow = this;
etape.TypeEtape = typeEtape;
bIsRedemarrage = false;
}
CResultAErreur resTmp = typeEtape.ParametresInitialisation.AppliqueTo(etape, bIsRedemarrage);
if (!resTmp)
{
result.EmpileErreur(resTmp.Erreur);
}
if (result)
{
result.DataType = etape;
}
return(result);
}
public CResultAErreur DémarreWorkflow(CTypeEtapeWorkflow typeEtapeDebut, bool bStartImmediate)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(ContexteDonnee.IdSession);
IInfoUtilisateur info = session != null?session.GetInfoUtilisateur() : null;
if (info != null)
{
//TESTDBKEYOK
KeyManager = info.KeyUtilisateur;
}
CResultAErreur result = CResultAErreur.True;
if (EtapesEnCours.Count != 0)
{
result.EmpileErreur(I.T("Workflow was already started|20073"));
return(result);
}
if (typeEtapeDebut == null ||
typeEtapeDebut.Workflow != TypeWorkflow//cas pourri : l'étape de début n'est pas valide pour ce workflow ça ne doit pas arriver
)
{
if (TypeWorkflow == null)
{
result.EmpileErreur(I.T("Workflow type should be set before it starts|20077"));
return(result);
}
typeEtapeDebut = TypeWorkflow.EtapeDemarrageDefaut;
if (typeEtapeDebut == null)
{
result.EmpileErreur(I.T("Workflow type @1 doesn't have any start point|20074",
TypeWorkflow != null?TypeWorkflow.Libelle:"???"));
return(result);
}
}
using (CContexteDonnee ctx = new CContexteDonnee(ContexteDonnee.IdSession, true, false))
{
///Si bStartImmediate, travaille dans un contexte spécifique qui est sauvé tout de suite
CContexteDonnee contexteDeTravail = bStartImmediate ? ctx : ContexteDonnee;
CWorkflow wkf = GetObjetInContexte(contexteDeTravail) as CWorkflow;
typeEtapeDebut = typeEtapeDebut.GetObjetInContexte(contexteDeTravail) as CTypeEtapeWorkflow;
CResultAErreurType <CEtapeWorkflow> resEtape = wkf.CreateOrGetEtapeInCurrentContexte(typeEtapeDebut);
if (resEtape)
{
CEtapeWorkflow etape = resEtape.DataType;
etape.DemandeDemarrageInCurrentContext(null);
}
else
{
result.EmpileErreur(resEtape.Erreur);
}
IsRunning = true;
RunGeneration++;
if (result && bStartImmediate)
{
result = ctx.SaveAll(true);
}
}
return(result);
}
//----------------------------------------------------------------------------------
//Prépare l'étape pour un démarrage
internal void DemandeDemarrageInCurrentContext(CEtapeWorkflow etapeAppelante)
{
InternalSetInfosDemarrageInCurrentContext();
EtapeAppelante = etapeAppelante;
}
//-------------------------------------------------------------------
/// <summary>
/// Démarre les étapes suivantes d'une étape
/// </summary>
/// <param name="etape"></param>
/// <returns></returns>
public CResultAErreur PrépareSuiteEtapeInCurrentContext(CEtapeWorkflow etape)
{
CResultAErreur result = CResultAErreur.True;
CTypeEtapeWorkflow typeEtape = etape.TypeEtape;
if (typeEtape.LiensSortants.Count == 0)
{
IsRunning = false;
if (EtapeAppelante != null)
{
//Fin de l'étape appelante
result = EtapeAppelante.EndEtapeNoSave();
if (!result)
{
return(result);
}
}
return(result);
}
foreach (CLienEtapesWorkflow lien in typeEtape.LiensSortants)
{
bool bStartLien = true;
C2iExpression formuleLien = lien.Formule;
if (lien.ActivationCode.Trim().Length > 0)
{
bStartLien = false;
foreach (string strCodeRetour in etape.CodesRetour)
{
if (strCodeRetour.ToUpper() == lien.ActivationCode.ToUpper())
{
bStartLien = true;
break;
}
}
}
if (formuleLien != null && bStartLien && !(formuleLien is C2iExpressionVrai))
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(etape);
result = formuleLien.Eval(ctx);
if (!result)
{
result.EmpileErreur(I.T("Error on condition formula on link @1 from step @2|20008",
lien.Libelle, etape.Libelle));
return(result);
}
bStartLien = result.Data != null && CUtilBool.BoolFromString(result.Data.ToString()) == true;
}
if (bStartLien)
{
CTypeEtapeWorkflow typeDestination = lien.EtapeDestination;
CResultAErreurType <CEtapeWorkflow> resEtape = etape.Workflow.CreateOrGetEtapeInCurrentContexte(typeDestination);
if (!resEtape)
{
result.EmpileErreur(resEtape.Erreur);
return(result);
}
else
{
resEtape.DataType.DemandeDemarrageInCurrentContext(etape);
}
}
}
return(result);
}
public bool StartWorkflowMultiSteps(ArrayList listEtapesToStart)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(ContexteDonnee.IdSession);
IInfoUtilisateur info = session != null?session.GetInfoUtilisateur() : null;
if (info != null)
{
KeyManager = info.KeyUtilisateur;
}
CResultAErreur result = CResultAErreur.True;
if (TypeWorkflow.Etapes.Count == 0)
{
if (EtapeAppelante != null)
{
EtapeAppelante.EndEtapeNoSave();
return(true);
}
}
foreach (object stepsPath in listEtapesToStart)
{
if (!(stepsPath is string))
{
throw new Exception(I.T("Invalid parameter for 'StartWorkflowMultiSteps'. Parameter must be an array of steps type path (separated by points).|20106"));
}
string strPath = (string)stepsPath;
int nPosPoint = strPath.IndexOf('.');
string strStepType = "";
string strSuitePath = "";
if (nPosPoint > 0)
{
strStepType = strPath.Substring(0, nPosPoint);
strSuitePath = strPath.Substring(nPosPoint + 1);
}
else
{
strStepType = strPath;
}
CTypeEtapeWorkflow typeEtape = null;
if (strStepType.Trim().Length == 0)
{
typeEtape = TypeWorkflow.EtapeDemarrageDefaut;
}
else
{
CListeObjetsDonnees lst = TypeWorkflow.Etapes;
lst.Filtre = new CFiltreData(CTypeEtapeWorkflow.c_champIdUniversel + "=@1", strStepType);
if (lst.Count > 0)
{
typeEtape = lst[0] as CTypeEtapeWorkflow;
}
if (typeEtape == null)
{
throw new Exception(I.T("Step type @1 can not be found|20107"));
}
}
CResultAErreurType <CEtapeWorkflow> resEtape = CreateOrGetEtapeInCurrentContexte(typeEtape);
if (resEtape)
{
CEtapeWorkflow etape = resEtape.DataType;
etape.StartWithPath(strSuitePath);
}
else
{
result.EmpileErreur(resEtape.Erreur);
}
IsRunning = true;
RunGeneration++;
}
return(result);
}