//---------------------------------------------------
public override CResultAErreur GetErreursManualEndEtape(CEtapeWorkflow etape)
{
CResultAErreur result = base.GetErreursManualEndEtape(etape);
if (result)
{
result = CResultAErreur.True;
//Vérifie toutes les conditions de fin
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(etape);
foreach (CFormuleNommee fn in FormulesConditionFin)
{
if (fn != null && fn.Formule != null)
{
CResultAErreur resTmp = fn.Formule.Eval(ctx);
if (!resTmp)
{
result.EmpileErreur(I.T("Error in formula '@1' for step @2|20082",
fn.Libelle, etape.LastError));
return(result);
}
bool bOk = resTmp.Data != null;
if (bOk)
{
bool?bConv = CUtilBool.BoolFromString(resTmp.Data.ToString());
bOk = bConv == true;
}
if (!bOk)
{
result.EmpileErreur(fn.Libelle);
}
}
}
}
return(result);
}
private void m_lnkTest_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
//Cherche le workflow de test
CWorkflow wkf = new CWorkflow(TypeWorkflow.ContexteDonnee);
if (!wkf.ReadIfExists(new CFiltreData(
CTypeWorkflow.c_champId + "=@1",
TypeWorkflow.Id)))
{
wkf.CreateNew();
wkf.TypeWorkflow = TypeWorkflow;
foreach (CTypeEtapeWorkflow typeEtape in TypeWorkflow.Etapes)
{
CEtapeWorkflow etape = new CEtapeWorkflow(wkf.ContexteDonnee);
etape.CreateNewInCurrentContexte();
etape.Workflow = wkf;
etape.TypeEtape = typeEtape;
}
CResultAErreur result = wkf.CommitEdit();
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
}
foreach (CEtapeWorkflow etape in wkf.Etapes)
{
if (etape.TypeEtape.Bloc is CBlocWorkflowFormulaire)
{
CGestionnaireWorkflowsEnCours.Instance.AfficheEtape(etape);
}
}
}
/// ///////////////////////////////////////////
public override object Invoke(object objetAppelle, params object[] parametres)
{
CWorkflow workflow = objetAppelle as CWorkflow;
if (workflow == null || parametres.Length == 0 || parametres[0] == null)
{
return(null);
}
string strIdType = parametres[0].ToString();
CTypeWorkflow typeWorkfow = workflow.TypeWorkflow;
if (typeWorkfow == null)
{
return(null);
}
CListeObjetsDonnees etapes = typeWorkfow.Etapes;
etapes.Filtre = new CFiltreData(CObjetDonnee.c_champIdUniversel + "=@1",
strIdType);
if (etapes.Count == 0)
{
return(null);
}
CTypeEtapeWorkflow typeEtape = etapes[0] as CTypeEtapeWorkflow;
CEtapeWorkflow etape = workflow.GetEtapeForType(typeEtape);
if (etape != null)
{
return(CGestionnaireProjetsDeWorkflow.GetProjetDirectementAssocie(etape));
}
return(null);
}
//---------------------------------------------------------------------------------------------------------
private CResultAErreur GetElementEditeSecondaire(CEtapeWorkflow etapeEnCours)
{
CResultAErreur result = CResultAErreur.True;
if (etapeEnCours != null)
{
CBlocWorkflowFormulaire blocFormulaire = etapeEnCours.TypeEtape != null ? etapeEnCours.TypeEtape.Bloc as CBlocWorkflowFormulaire : null;
if (blocFormulaire == null)
{
result.EmpileErreur("Ce To do ne peut pas être traité dans l'application web Timos");
return(result);
}
if (blocFormulaire.FormuleElementEditeSecondaire != null)
{
C2iExpression expElementEditePrincipal = blocFormulaire.FormuleElementEditeSecondaire;
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(etapeEnCours);
result = expElementEditePrincipal.Eval(ctxEval);
if (!result)
{
result.EmpileErreur("Erreur dans l'évaluation de l'élément édité principal du to do " + etapeEnCours.Id);
}
}
}
return(result);
}
//---------------------------------------------------
public override void OnCancelStep(CEtapeWorkflow etape)
{
if (etape.WorkflowLancé != null)
{
etape.WorkflowLancé.StopWorkflow();
}
}
//-----------------------------------------------------------------------------------------------------
private void m_menuCreateStep_Click(object sender, EventArgs e)
{
CEtapeWorkflow etape = EtapeSelectionnee;
if (etape == null)
{
using (CContexteDonnee ctx = new CContexteDonnee(m_workflowRacine.ContexteDonnee.IdSession, true, false))
{
CWorkflow wkf = m_stackWorkflows.Peek();
if (wkf != null)
{
wkf = wkf.GetObjetInContexte(ctx) as CWorkflow;
CResultAErreurType <CEtapeWorkflow> res = wkf.CreateOrGetEtapeInCurrentContexte(TypeEtapeSelectionnee);
if (!res)
{
CFormAlerte.Afficher(res.Erreur);
return;
}
CResultAErreur result = ctx.SaveAll(true);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
}
}
}
}
//-----------------------------------------------------------------------------------------------------
private void m_menuStartStep_Click(object sender, EventArgs e)
{
CEtapeWorkflow etape = EtapeSelectionnee;
CWorkflow wkf = m_stackWorkflows.Peek();
using (CContexteDonnee ctx = new CContexteDonnee(wkf.ContexteDonnee.IdSession, true, false))
{
wkf = wkf.GetObjetInContexte(ctx) as CWorkflow;
CTypeEtapeWorkflow typeEtape = TypeEtapeSelectionnee;
if (etape != null)
{
typeEtape = etape.TypeEtape;
}
CResultAErreurType <CEtapeWorkflow> resEtape = wkf.CreateOrGetEtapeInCurrentContexte(typeEtape);
if (!resEtape)
{
CFormAlerte.Afficher(resEtape.Erreur);
return;
}
etape = resEtape.DataType;
etape = etape.GetObjetInContexte(ctx) as CEtapeWorkflow;
etape.InternalSetInfosDemarrageInCurrentContext();
CResultAErreur result = ctx.SaveAll(true);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
Refresh();
}
}
//---------------------------------------------------------------------------------------------------------
private string GetInstructionsForTodo(CEtapeWorkflow etapeEnCours)
{
string strResult = "Pas d'instructions";
if (etapeEnCours != null)
{
CBlocWorkflowFormulaire blocFormulaire = etapeEnCours.TypeEtape != null ? etapeEnCours.TypeEtape.Bloc as CBlocWorkflowFormulaire : null;
if (blocFormulaire == null)
{
strResult = "Ce To do ne peut pas être traité dans l'application web Timos";
return(strResult);
}
if (blocFormulaire.FormuleInstructions != null)
{
C2iExpression expInstructions = blocFormulaire.FormuleInstructions;
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(etapeEnCours);
CResultAErreur resEval = expInstructions.Eval(ctxEval);
if (resEval && resEval.Data != null)
{
strResult = resEval.Data.ToString();
}
else
{
strResult = etapeEnCours.Libelle + Environment.NewLine + resEval.Erreur.ToString();
}
}
}
return(strResult);
}
//---------------------------------------------------
public override CResultAErreur RunAndSaveIfOk(CEtapeWorkflow etape)
{
CResultAErreur result = CResultAErreur.True;
if (DbKeyTypeWorkflow == null)
{
return(EndAndSaveIfOk(etape));
}
CTypeEtapeWorkflow typeEtapeDémarrage = null;
if (m_dbKeyTypeEtapeDemarrage != null)
{
typeEtapeDémarrage = new CTypeEtapeWorkflow(etape.ContexteDonnee);
if (!typeEtapeDémarrage.ReadIfExists(m_dbKeyTypeEtapeDemarrage))
{
typeEtapeDémarrage = null;
}
}
CWorkflow workflow = GetOrCreateWorkflowInCurrentContexte(etape);
if (workflow != null && !workflow.IsRunning)
{
result = PrepareToStartWorkflow(etape);
if (workflow.TypeWorkflow.Etapes.Count == 0)
{
return(EndAndSaveIfOk(etape));
}
result = workflow.DémarreWorkflow(typeEtapeDémarrage, false);
}
return(etape.ContexteDonnee.SaveAll(true));
}
//-----------------------------------------------------------------------------------------------------
private void m_menuEtapeDessin_Opening(object sender, CancelEventArgs e)
{
CEtapeWorkflow etape = EtapeSelectionnee;
m_menuAfficheDetailEtape.Visible = etape != null;
m_menuAfficheDetailWorkflow.Visible = etape != null && etape.WorkflowLancé != null;
m_menuStartStep.Visible = m_bCanManage && etape == null || etape.EtatCode != (int)EEtatEtapeWorkflow.Démarrée;
m_menuSendNotifications.Visible = m_bCanManage && etape != null && etape.EtatCode == (int)EEtatEtapeWorkflow.Démarrée && etape.Affectations.GetAffectables().Count() > 0;
m_menuAnnulerEtape.Visible = m_bCanManage && etape != null && etape.EtatCode == (int)EEtatEtapeWorkflow.Démarrée;
m_menuEndStep.Visible = m_bCanManage && etape != null && etape.EtatCode == (int)EEtatEtapeWorkflow.Démarrée;
m_menuEditAffectations.Visible = m_bCanManage && etape != null;
if (etape != null)
{
CUtilMenuActionSurElement.InitMenuActions(
etape,
m_menuActionEtape.DropDownItems,
new MenuActionEventHandler(onClickMenuActionEventHandler));
m_menuActionEtape.Visible = m_menuActionEtape.DropDownItems.Count > 0;
}
else
{
m_menuActionEtape.Visible = false;
}
m_menuCreateStep.Visible = etape == null;
}
//---------------------------------------------------
public CWorkflow GetOrCreateWorkflowInCurrentContexte(CEtapeWorkflow etape)
{
CResultAErreur result = CResultAErreur.True;
if (DbKeyTypeWorkflow == null)
{
return(null);
}
//Lance le démarrage du workflow
if (etape.WorkflowLancé != null)
{
if (etape.WorkflowLancé.IdEtapeAppelante != etape.Id)
{
etape.WorkflowLancé.EtapeAppelante = etape;//Pour pallier aux soucis d'id négatifs stockés parfois
}
return(etape.WorkflowLancé);
}
else
{
CTypeWorkflow typeWorkflow = new CTypeWorkflow(etape.ContexteDonnee);
if (typeWorkflow.ReadIfExists(DbKeyTypeWorkflow))
{
CWorkflow workflow = new CWorkflow(etape.ContexteDonnee);
workflow.CreateNewInCurrentContexte();
workflow.TypeWorkflow = typeWorkflow;
workflow.Libelle = etape.Libelle;
workflow.EtapeAppelante = etape;
etape.WorkflowLancé = workflow;
return(workflow);
}
}
return(null);
}
//-------------------------------------------------------------
private void EndEtape()
{
if (m_formulaire != null && m_formulaire.ModeEdition)
{
CFormAlerte.Afficher(I.T("Validate your modification before|20572"));
return;
}
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee ctx = new CContexteDonnee(m_etapeEnCours.ContexteDonnee.IdSession, true, false))
{
if (m_objetSecondaireEnCoursEdition != null)
{
CObjetDonnee objetSecondaire = m_objetSecondaireEnCoursEdition.GetObjetInContexte(ctx);
result = m_panelFormulalire.AffecteValeursToElement(objetSecondaire);
}
if (result)
{
m_etapeEnCours = m_etapeEnCours.GetObjetInContexte(ctx) as CEtapeWorkflow;
if (m_etapeEnCours.EtatCode == (int)EEtatEtapeWorkflow.Démarrée)
{
result = m_etapeEnCours.EndEtapeAndSaveIfOk();
}
}
}
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
else
{
Init();
}
}
/// ///////////////////////////////////////
private void m_timerClignotant_Tick(object sender, System.EventArgs e)
{
if (m_imageInterventionProcess.Image == null)
{
m_imageInterventionProcess.Image = m_icones.Images[c_nImageIntervention];
}
else
{
m_imageInterventionProcess.Image = null;
}
if (m_nNbClignotementsWorkflowsRestant > 0)
{
if (m_nIdEtapeToLaunch != null)
{
int nId = m_nIdEtapeToLaunch.Value;
m_nIdEtapeToLaunch = null;
CEtapeWorkflow etape = new CEtapeWorkflow(CSc2iWin32DataClient.ContexteCourant);
if (etape.ReadIfExists(nId))
{
CGestionnaireWorkflowsEnCours.Instance.AfficheEtape(etape);
}
}
m_pictureWorkflow.Visible = !m_pictureWorkflow.Visible;
m_lblNbToDo.Visible = m_nNbEtapesEnCours > 0 && m_pictureWorkflow.Visible;
m_nNbClignotementsWorkflowsRestant--;
}
if (m_nNbClignotementsWorkflowsRestant <= 0)
{
m_pictureWorkflow.Visible = true;
m_lblNbToDo.Visible = m_nNbEtapesEnCours > 0;
m_pictureWorkflow.Invalidate();
}
}
//--------------------------------------------------------------------------
public override CResultAErreur RunAndSaveIfOk(CEtapeWorkflow etape)
{
CResultAErreur result = CResultAErreur.True;
System.Console.WriteLine("Démarrage étape " + etape.Libelle);
return(base.RunAndSaveIfOk(etape));
}
//--------------------------------------------------------------------------
public static IEnumerable <CProjet> FindSuccesseurs(CEtapeWorkflow etape)
{
if (etape == null)
{
return(new List <CProjet>());
}
return(FindSuccesseurs(etape.TypeEtape, etape.Workflow));
}
//-----------------------------------------------------------------------------------------------------
private void m_menuEditAffectations_Click(object sender, EventArgs e)
{
CEtapeWorkflow etape = EtapeSelectionnee;
if (etape != null)
{
CFormEditeAffectationsEtape.EditeAffectations(etape);
}
}
//--------------------------------------------------------------------------
private CResultAErreur StartOrRestartProjet(CEtapeWorkflow etape)
{
CResultAErreur result = CResultAErreur.True;
CResultAErreurType <CProjet> resProjet = CGestionnaireProjetsDeWorkflow.AssureProjetRunnable(etape, this);
if (!resProjet)
{
result.EmpileErreur(resProjet.Erreur);
return(result);
}
CProjet projet = resProjet.DataType;
if (projet == null)
{
return(result);
}
if (etape.DateDebut == null)
{
etape.DateDebut = DateTime.Now;
}
if (projet.ProjetsFils.Count == 0)
{
if (projet.DateDebutReel == null || GererIteration)
{
projet.DateDebutReel = etape.DateDebut.Value;
projet.DateFinRelle = null;
}
else if (!projet.HasOptionLienEtape(EOptionLienProjetEtape.StepKeepDates))
{
projet.DateDebutReel = etape.DateDebut.Value;
projet.DateFinRelle = null;
}
}
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(etape);
foreach (CAffectationsProprietes affectation in AffectationsCreationEtDemarrage)
{
bool bAppliquer = affectation.FormuleCondition == null || affectation.FormuleCondition is C2iExpressionVrai;
if (affectation.FormuleCondition != null)
{
CResultAErreur res = affectation.FormuleCondition.Eval(ctxEval);
if (res && res.Data != null && CUtilBool.BoolFromString(res.Data.ToString()) == true)
{
bAppliquer = true;
}
}
if (bAppliquer)
{
affectation.AffecteProprietes(projet, etape, new CFournisseurPropDynStd());
}
}
System.Console.WriteLine("Démarrage projet " + projet.Libelle);
return(result);
}
//---------------------------------------------------
public override CResultAErreur OnBlocRedemarréParUneEtapeDuSousWorkflow(CEtapeWorkflow etape)
{
CResultAErreur result = base.OnBlocRedemarréParUneEtapeDuSousWorkflow(etape);
if (result)
{
result = StartOrRestartProjet(etape);
}
return(result);
}
//---------------------------------------------------------------------
public static bool EditeAffectations(CEtapeWorkflow etape)
{
CFormEditeAffectationsEtape form = new CFormEditeAffectationsEtape();
form.m_etape = etape;
bool bOk = form.ShowDialog() == DialogResult.OK;
form.Dispose();
return(bOk);
}
/// //////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(sc2i.data.CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
CEtapeWorkflow etapeWorkflow = objet as CEtapeWorkflow;
if (etapeWorkflow != null)
{
}
return(result);
}
//---------------------------------------------------
public override CResultAErreur EndEtapeNoSave(CEtapeWorkflow etape)
{
CResultAErreur result = GetErreursManualEndEtape(etape);
if (result)
{
result = base.EndEtapeNoSave(etape);
}
return(result);
}
public static object GetProjetGenereParEtape(object source)
{
CEtapeWorkflow etape = source as CEtapeWorkflow;
if (etape == null)
{
return(null);
}
return(CGestionnaireProjetsDeWorkflow.GetProjetDirectementAssocie(etape));
}
//------------------------------------------------------------------------
private void NoteErreurSurEtape(CEtapeWorkflow etape, string strMessage)
{
using (CContexteDonnee ctx = new CContexteDonnee(etape.ContexteDonnee.IdSession, true, false))
{
etape = etape.GetObjetInContexte(ctx) as CEtapeWorkflow;
etape.EtatCode = (int)EEtatEtapeWorkflow.Erreur;
etape.LastError = strMessage;
etape.DateFin = null;
ctx.SaveAll(false);
}
}
//---------------------------------------------------
public CResultAErreur EndAndSaveIfOk(CEtapeWorkflow etape)
{
//Termine simplement l'étape
CResultAErreur result = EndEtapeNoSave(etape);
if (result)
{
result = etape.ContexteDonnee.SaveAll(true);
}
return(result);
}
/// ///////////////////////////////////////////
public override object Invoke(object objetAppelle, params object[] parametres)
{
CEtapeWorkflow etape = objetAppelle as CEtapeWorkflow;
if (etape == null || parametres.Length > 0)
{
return(null);
}
List <CActeur> listeActeurs = new List <CActeur>();
List <IAffectableAEtape> listeAffectables = new List <IAffectableAEtape>(etape.Assignments);
foreach (IAffectableAEtape affectable in listeAffectables)
{
CActeur acteur = affectable as CActeur;
if (acteur != null)
{
listeActeurs.Add(acteur);
}
else
{
CGroupeActeur groupe = affectable as CGroupeActeur;
if (groupe != null)
{
foreach (CRelationActeur_GroupeActeur relation in groupe.RelationsActeur)
{
listeActeurs.Add(relation.Acteur);
}
}
else
{
CProfilUtilisateur profil = affectable as CProfilUtilisateur;
if (profil != null)
{
CListeObjetDonneeGenerique <CActeur> lstActeursDansProfil =
new CListeObjetDonneeGenerique <CActeur>(etape.ContexteDonnee);
lstActeursDansProfil.Filtre = new CFiltreDataAvance(
CActeur.c_nomTable,
CDonneesActeurUtilisateur.c_nomTable + "." +
CRelationUtilisateur_Profil.c_nomTable + "." +
CProfilUtilisateur.c_nomTable + "." +
CProfilUtilisateur.c_champId + " = @1",
profil.Id);
foreach (CActeur acteurProfil in lstActeursDansProfil)
{
listeActeurs.Add(acteurProfil);
}
}
}
}
}
return(listeActeurs.ToArray());
}
//----------------------------------------------------
public void SetEtapeEnCours(CEtapeWorkflow etape, CFormEditionStandard formulaire)
{
m_etapeEnCours = etape;
m_formulaire = formulaire;
if (m_formulaire != null)
{
m_formulaire.AfterValideModification -= m_eventAfterValideModifications;
m_formulaire.AfterValideModification += m_eventAfterValideModifications;
}
Init();
}
//---------------------------------------------------------------------------
private void CControleDessinWorkflowEnCours_DoubleClicSurElement(object sender, EventArgs e)
{
if (Selection.Count == 1)
{
CEtapeWorkflow etape = EtapeSelectionnee;
if (etape != null && etape.WorkflowLancé != null)
{
AfficheWorkflow(etape.WorkflowLancé);
}
}
}
//----------------------------------------------------------------------------------
public static CProjet GetProjetDirectementAssocie(CEtapeWorkflow etape)
{
if (etape != null && etape.TypeEtape != null)
{
CBlocWorkflowProjet blocProjet = etape.TypeEtape.Bloc as CBlocWorkflowProjet;
if (blocProjet != null && blocProjet.IdChampProjet != null && etape.WorkflowLancé != null)
{
return(etape.WorkflowLancé.GetValeurChamp(blocProjet.IdChampProjet.Value) as CProjet);
}
}
return(null);
}
/// <summary>
/// Trouve le projet parent d'une étape , c'est à dire qu'on demande à l'étape parente de trouver le projet associé
/// </summary>
/// <param name="etape"></param>
/// <returns></returns>
public static CProjet FindProjetParent(CEtapeWorkflow etape)
{
if (etape != null)
{
CWorkflow workflowParent = etape.Workflow;
if (workflowParent.EtapeAppelante != null)
{
return(FindProjetAssocie(workflowParent.EtapeAppelante));
}
}
return(null);
}
//---------------------------------------------------
public override CResultAErreur RunAndSaveIfOk(CEtapeWorkflow etape)
{
if (DemarrageManuel)
{
return(etape.ContexteDonnee.SaveAll(true));
}
else
{
return(StartProcess(etape));
}
return(CResultAErreur.True);
}
