//----------------------------------------------------------------------------------
public void StartWithPath(string strPath)
{
InternalSetInfosDemarrageInCurrentContext();
CBlocWorkflowWorkflow bw = TypeEtape.Bloc as CBlocWorkflowWorkflow;
if (bw != null)
{
bw.StartWithPath(this, strPath);
}
}
//-------------------------------------------------------
public static bool EditeBloc(CBlocWorkflowWorkflow bloc)
{
if (bloc == null)
{
return(false);
}
CFormEditionBlocWorkflowWorkflow form = new CFormEditionBlocWorkflowWorkflow();
form.m_blocWorkflow = bloc;
bool bResult = form.ShowDialog() == DialogResult.OK;
form.Dispose();
return(bResult);
}
//---------------------------------------------------------
/// <summary>
/// A appeller lorsqu'un étape contenant un sous workflow
/// démarre ou redémarre car le sous workflow a redémarré.
/// </summary>
/// <returns></returns>
public CResultAErreur OnDemarrageDepuisSousWorkflow()
{
CResultAErreur result = CResultAErreur.True;
if (Etat.Code != EEtatEtapeWorkflow.ADemarrer && Etat.Code != EEtatEtapeWorkflow.Démarrée)
{
result = InternalSetInfosDemarrageInCurrentContext();
EtatCode = (int)EEtatEtapeWorkflow.Démarrée;
if (TypeEtape != null)
{
CBlocWorkflowWorkflow bloc = TypeEtape.Bloc as CBlocWorkflowWorkflow;
if (bloc != null)
{
result = bloc.OnBlocRedemarréParUneEtapeDuSousWorkflow(this);
}
}
}
return(result);
}
//------------------------------------------------------------------
private void m_panelWorkflow_DoubleClicSurElement(object sender, EventArgs e)
{
if (!LockEdition)
{
EditeCurrentEtape();
}
else
{
CWorkflowEtapeDessin etape = m_panelWorkflow.EtapeSelectionnee;
if (etape == null)
{
return;
}
CBlocWorkflow bloc = etape.TypeEtape != null ? etape.TypeEtape.Bloc : null;
CBlocWorkflowWorkflow blocWorkflow = bloc as CBlocWorkflowWorkflow;
if (blocWorkflow != null && blocWorkflow.DbKeyTypeWorkflow != null)
{
CTypeWorkflow typeWorkflow = new CTypeWorkflow(CSc2iWin32DataClient.ContexteCourant);
if (typeWorkflow.ReadIfExists(blocWorkflow.DbKeyTypeWorkflow))
{
CFormNavigateur navigateur = CFormNavigateur.FindNavigateur(this);
if (navigateur != null)
{
CReferenceTypeForm refFrm = CFormFinder.GetRefFormToEdit(typeof(CTypeWorkflow));
if (refFrm != null)
{
CFormEditionStandard frm = refFrm.GetForm(typeWorkflow) as CFormEditionStandard;
if (frm != null)
{
navigateur.AffichePage(frm);
}
}
}
}
}
}
}
//-------------------------------------------------------------------
private void m_menuEditWorkflow_Click(object sender, EventArgs e)
{
CWorkflowEtapeDessin etape = EtapeSelectionnee;
if (etape == null)
{
return;
}
CBlocWorkflowWorkflow blocwkf = etape != null && etape.TypeEtape != null ?
etape.TypeEtape.Bloc as CBlocWorkflowWorkflow : null;
if (blocwkf != null)
{
CReferenceTypeForm refFrm = CFormFinder.GetRefFormToEdit(typeof(CTypeWorkflow));
if (refFrm != null)
{
CTypeWorkflow typeWorkflow = null;
if (blocwkf.DbKeyTypeWorkflow == null)
{
if (!LockEdition)
{
typeWorkflow = new CTypeWorkflow(CSc2iWin32DataClient.ContexteCourant);
typeWorkflow.CreateNew();
typeWorkflow.Libelle = blocwkf.TypeEtape.Libelle;
}
}
else
{
typeWorkflow = new CTypeWorkflow(CSc2iWin32DataClient.ContexteCourant);
if (!typeWorkflow.ReadIfExists(blocwkf.DbKeyTypeWorkflow))
{
typeWorkflow = null;
}
}
if (typeWorkflow != null)
{
CFormNavigateur navigateur = null;
if (LockEdition)
{
Form frm = FindForm();
if (frm != null)
{
Control ctrl = frm.Parent;
while (ctrl != null && ctrl.Parent != null && !(ctrl is CFormNavigateur))
{
ctrl = ctrl.Parent;
}
if (typeof(CFormNavigateur).IsAssignableFrom(ctrl.GetType()))
{
navigateur = (CFormNavigateur)ctrl;
}
}
}
CFormEditionStandard frmEdition = refFrm.GetForm(typeWorkflow) as CFormEditionStandard;
if (navigateur == null && frmEdition != null)
{
CFormNavigateurPopup.Show(frmEdition);
if (!LockEdition && typeWorkflow.IsValide() && typeWorkflow.Id >= 0)
{
blocwkf.DbKeyTypeWorkflow = typeWorkflow.DbKey;
etape.TypeEtape.Bloc = blocwkf;
}
}
else
{
navigateur.AffichePage(frmEdition);
}
}
}
}
}
//--------------------------------------------------------------------------
/// <summary>
/// Resynchronise un workflow avec un projet
/// </summary>
/// <param name="wkf"></param>
/// <param name="projetRacine"></param>
public static CResultAErreur SynchroniseWorkflow(
CWorkflow wkf,
CProjet projetParent,
bool bShouldStartWorkflow,
bool bSynchroniserStarts)
{
CResultAErreur result = CResultAErreur.True;
//Identifie toutes les étapes BlocWorkflowWorkflow
List <CTypeEtapeWorkflow> lstTypeWkfWkf = new List <CTypeEtapeWorkflow>();
foreach (CTypeEtapeWorkflow typeEtape in wkf.TypeWorkflow.Etapes)
{
if (typeEtape.Bloc is CBlocWorkflowWorkflow)
{
lstTypeWkfWkf.Add(typeEtape);
}
}
foreach (CTypeEtapeWorkflow typeEtape in lstTypeWkfWkf)
{
CResultAErreurType <CEtapeWorkflow> resEtape = wkf.CreateOrGetEtapeInCurrentContexte(typeEtape);
if (!resEtape || resEtape.DataType == null)
{
result.EmpileErreur(I.T("Error while creating step '@1'", typeEtape.Libelle));
result.EmpileErreur(resEtape.Erreur);
return(result);
}
CBlocWorkflowWorkflow blocWkfWkf = typeEtape.Bloc as CBlocWorkflowWorkflow;
CEtapeWorkflow etape = resEtape.DataType;
CWorkflow sousWorkflow = blocWkfWkf.GetOrCreateWorkflowInCurrentContexte(etape);
//Trouve le projet associé à l'étape
CBlocWorkflowProjet blocProjet = blocWkfWkf as CBlocWorkflowProjet;
if (blocProjet != null)
{
CProjet projetEtape = FindProjetPourRattrapage(
projetParent, etape, blocProjet);
if (projetEtape != null)
{
if (blocProjet.IdChampProjet == null)
{
result.EmpileErreur(I.T("Workflow step @1 doesn't define a field to store associated project|20142", etape.Libelle));
return(result);
}
sousWorkflow.SetValeurChamp(blocProjet.IdChampProjet.Value, projetEtape);
bool bShouldStartSousWorkflow = projetEtape.DateDebutReel != null &&
projetEtape.DateFinRelle == null;
DateTime?oldDateDebut = projetEtape.DateDebutReel;
result = SynchroniseWorkflow(sousWorkflow, projetEtape, bShouldStartSousWorkflow, bSynchroniserStarts);
if (!result)
{
return(result);
}
if (bShouldStartSousWorkflow && oldDateDebut != null)//Remet les dates
{
etape.DateDebut = oldDateDebut;
projetEtape.DateDebutReel = oldDateDebut;
}
}
}
else
{
result = SynchroniseWorkflow(sousWorkflow, projetParent, false, bSynchroniserStarts);
}
}
if (bShouldStartWorkflow && !wkf.IsRunning && bSynchroniserStarts)
{
wkf.StartWorkflow(null);
}
return(result);
}
