//---------------------------------------------------
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);
}
/// ///////////////////////////////////////////
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);
}
//--------------------------------------------------------------------------
public static CResultAErreur CreateSqueletteProjetsInCurrentContext(
CWorkflow workflow,
CTypeEtapeWorkflow typeEtapeDebut,
CProjet projetParent)
{
CResultAErreur result = CResultAErreur.True;
CTypeWorkflow typeWorkflow = workflow.TypeWorkflow;
//Récupére le type d'étape de base
CTypeEtapeWorkflow typeEtape = typeEtapeDebut;
if (typeEtape == null)
{
typeEtape = typeWorkflow.EtapeDemarrageDefaut;
}
if (typeEtape == null)
{
return(result);
}
//règle de création : on ne suit que les liens systèmatiques (sans CodeRetour et sans formule)
result = CreateProjets(workflow, typeEtape, projetParent);
return(result);
}
//-------------------------------------------------------
private void InitComboStartStep()
{
CTypeWorkflow typeWorkflow = m_txtSelectWorkflow.ElementSelectionne as CTypeWorkflow;
if (typeWorkflow != null)
{
m_cmbStartStep.Init(typeWorkflow.Etapes, "Libelle", true);
m_cmbStartStep.Enabled = true;
if (m_keyLastIdTypeEtapeSel != null)
{
CTypeEtapeWorkflow typeEtape = new CTypeEtapeWorkflow(CSc2iWin32DataClient.ContexteCourant);
if (typeEtape.ReadIfExists(m_keyLastIdTypeEtapeSel) && typeWorkflow.Equals(typeEtape.Workflow))
{
m_cmbStartStep.ElementSelectionne = typeEtape;
}
else
{
m_cmbStartStep.ElementSelectionne = null;
}
}
else
{
m_cmbStartStep.ElementSelectionne = null;
}
}
else
{
m_cmbStartStep.Enabled = false;
}
}
//-------------------------------------------------------------------------
private void m_linkTypeWorkflow_LinkClicked(object sender, EventArgs e)
{
CTypeWorkflow typeWorkflowParent = TypeEtape.Workflow;
if (typeWorkflowParent != null)
{
CTimosApp.Navigateur.AffichePage(new CFormEditionTypeWorkflow(typeWorkflowParent));
}
}
//-------------------------------------------------------------------
public void AppliquerFiltre()
{
CFiltreData filtre = null;
CActeur acteur = m_txtActeur.ElementSelectionne as CActeur;
if (acteur != null)
{
CFiltreData filtreAss = new CFiltreData();
string[] strCodes = acteur.GetListeCodesAffectationEtape();
foreach (string strCode in strCodes)
{
filtreAss.Filtre += CEtapeWorkflow.c_champAffectations + " like @" +
(filtreAss.Parametres.Count + 1) + " or ";
filtreAss.Parametres.Add("%~" + strCode + "~%");
}
if (filtreAss.Filtre.Length > 0)
{
filtreAss.Filtre = filtreAss.Filtre.Remove(filtreAss.Filtre.Length - 4, 4);
filtre = CFiltreData.GetAndFiltre(filtre, filtreAss);
}
}
CEtatEtapeWorkflow etat = m_cmbEtats.SelectedValue as CEtatEtapeWorkflow;
if (etat != null)
{
CFiltreData filtreTmp = new CFiltreData(CEtapeWorkflow.c_champEtat + "=@1",
etat.CodeInt);
filtre = CFiltreData.GetAndFiltre(filtreTmp, filtre);
}
CTypeWorkflow type = m_txtTypeWorkflow.ElementSelectionne as CTypeWorkflow;
if (type != null)
{
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreDataAvance(CEtapeWorkflow.c_nomTable,
CTypeEtapeWorkflow.c_nomTable + "." +
CTypeWorkflow.c_champId + "=@1", type.Id));
}
if (m_txtLabel.Text.Trim().Length > 0)
{
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreDataAvance(CEtapeWorkflow.c_nomTable,
"(" + CEtapeWorkflow.c_champLibelle + " like @1) or (" +
CEtapeWorkflow.c_champLibelle + "=@2 and " +
CTypeEtapeWorkflow.c_nomTable + "." +
CTypeEtapeWorkflow.c_champLibelle + " like @1)",
"%" + m_txtLabel.Text.Trim() + "%", ""));
}
Filtre = filtre;
OnAppliqueFiltre(new object(), null);
}
//-------------------------------------------------------
private void InitChamps()
{
if (m_blocWorkflow == null)
{
return;
}
m_txtSelectWorkflow.Init(typeof(CTypeWorkflow),
"Libelle",
false);
if (m_blocWorkflow.DbKeyTypeWorkflow != null)
{
CTypeWorkflow wkf = new CTypeWorkflow(CSc2iWin32DataClient.ContexteCourant);
if (wkf.ReadIfExists(m_blocWorkflow.DbKeyTypeWorkflow))
{
m_txtSelectWorkflow.ElementSelectionne = wkf;
}
}
m_txtSelectTypeProjet.Init(typeof(CTypeProjet),
"Libelle",
false);
if (m_blocWorkflow.DbKeyTypeProjet != null)
{
CTypeProjet typeProjet = new CTypeProjet(CSc2iWin32DataClient.ContexteCourant);
if (typeProjet.ReadIfExists(m_blocWorkflow.DbKeyTypeProjet))
{
m_txtSelectTypeProjet.ElementSelectionne = typeProjet;
}
}
m_cmbProjectField.Init(typeof(CChampCustom),
CFiltreData.GetAndFiltre(CChampCustom.GetFiltreChampsForRole(CWorkflow.c_roleChampCustom),
new CFiltreData(
CChampCustom.c_champTypeObjetDonnee + "=@1",
typeof(CProjet).ToString())),
"Nom",
false);
if (m_blocWorkflow.IdChampProjet != null)
{
CChampCustom champ = new CChampCustom(CSc2iWin32DataClient.ContexteCourant);
if (champ.ReadIfExists(m_blocWorkflow.IdChampProjet.Value))
{
m_cmbProjectField.ElementSelectionne = champ;
}
}
m_listeAffectations.Clear();
m_listeAffectations.AddRange(m_blocWorkflow.AffectationsCreationEtDemarrage);
m_txtFormuleGanttId.Init(new CFournisseurPropDynStd(),
typeof(CEtapeWorkflow));
m_txtFormuleGanttId.Formule = m_blocWorkflow.FormuleGanttId;
m_chkGererIterations.Checked = m_blocWorkflow.GererIteration;
}
//-------------------------------------------------------------------
public void FillContexte(CContexteFormNavigable ctx)
{
CActeur acteur = m_txtActeur.ElementSelectionne as CActeur;
ctx["FILTRE_ACTEUR"] = acteur != null ? (int?)acteur.Id : null;
CEtatEtapeWorkflow etat = m_cmbEtats.SelectedValue as CEtatEtapeWorkflow;
ctx["FILTRE_ETAT"] = etat;
CTypeWorkflow type = m_txtTypeWorkflow.ElementSelectionne as CTypeWorkflow;
ctx["FILTRE_TYPE_WKF"] = type != null ? (int?)type.Id : null;
ctx["FILTRE_LABEL"] = m_txtLabel.Text;
}
private void m_txtSelectTypeWorkflow_ElementSelectionneChanged(object sender, EventArgs e)
{
CTypeWorkflow tp = m_txtSelectTypeWorkflow.ElementSelectionne as CTypeWorkflow;
if (tp != null && m_gestionnaireModeEdition.ModeEdition)
{
Workflow.TypeWorkflow = tp;
RefreshChampsCustom();
InvalidePage(m_pageWorkflow);
if (m_tabControl.SelectedTab == m_pageWorkflow)
{
InitPage(m_pageWorkflow);
}
}
}
//-------------------------------------------------------
private void InitChamps()
{
m_txtSelectWorkflow.InitAvecFiltreDeBase(typeof(CTypeWorkflow),
"Libelle",
null, false);
if (m_blocWorkflow.DbKeyTypeWorkflow != null)
{
CTypeWorkflow wkf = new CTypeWorkflow(CSc2iWin32DataClient.ContexteCourant);
if (wkf.ReadIfExists(m_blocWorkflow.DbKeyTypeWorkflow))
{
m_txtSelectWorkflow.ElementSelectionne = wkf;
}
}
m_keyLastIdTypeEtapeSel = m_blocWorkflow.DbKeyTypeEtapeDémarrage;
m_txtWorkflowInit.Init(new CFournisseurGeneriqueProprietesDynamiques(), typeof(CEtapeWorkflow));
m_txtWorkflowInit.Formule = m_blocWorkflow.FormuleInitialisationWorkflowLance;
InitComboStartStep();
}
/// //////////////////////////////////////////////////
public override CResultAErreur VerifieDonnees(sc2i.data.CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
CTypeWorkflow typeWorkflow = objet as CTypeWorkflow;
if (typeWorkflow != null)
{
if (typeWorkflow.Libelle.Length == 0)
{
result.EmpileErreur(I.T("Workflow type label should be set|20003"));
}
if (typeWorkflow.Etapes.Count > 0 && typeWorkflow.EtapeDemarrageDefaut == null)
{
result.EmpileErreur(I.T("You have to select a start step for this workflow|20009"));
}
}
return(result);
}
//-------------------------------------------------------
private CResultAErreur MajChamps()
{
CResultAErreur result = CResultAErreur.True;
CTypeWorkflow wkf = m_txtSelectWorkflow.ElementSelectionne as CTypeWorkflow;
if (wkf != null)
{
m_blocWorkflow.DbKeyTypeWorkflow = wkf.DbKey;
}
else
{
m_blocWorkflow.DbKeyTypeWorkflow = null;
}
CTypeProjet typeProjet = m_txtSelectTypeProjet.ElementSelectionne as CTypeProjet;
if (typeProjet != null)
{
m_blocWorkflow.DbKeyTypeProjet = typeProjet.DbKey;
}
else
{
m_blocWorkflow.DbKeyTypeProjet = null;
}
CChampCustom champ = m_cmbProjectField.ElementSelectionne as CChampCustom;
if (champ != null)
{
m_blocWorkflow.IdChampProjet = champ.Id;
}
else
{
m_blocWorkflow.IdChampProjet = null;
}
m_blocWorkflow.AffectationsCreationEtDemarrage = m_listeAffectations;
m_blocWorkflow.FormuleGanttId = m_txtFormuleGanttId.Formule;
m_blocWorkflow.GererIteration = m_chkGererIterations.Checked;
return(result);
}
//-------------------------------------------------------------------
public void InitFromContexte(CContexteFormNavigable ctx)
{
int?nIdActeur = ctx["FILTRE_ACTEUR"] as int?;
if (nIdActeur != null)
{
CActeur acteur = new CActeur(CSc2iWin32DataClient.ContexteCourant);
if (acteur.ReadIfExists(nIdActeur.Value))
{
m_txtActeur.ElementSelectionne = acteur;
}
}
else
{
m_txtActeur.ElementSelectionne = null;
}
CEtatEtapeWorkflow etat = ctx["FILTRE_ETAT"] as CEtatEtapeWorkflow;
if (etat != null)
{
m_cmbEtats.SelectedValue = etat;
}
else
{
m_cmbEtats.SelectedValue = null;
}
int?nIdType = ctx["FILTRE_TYPE_WKF"] as int?;
if (nIdType != null)
{
CTypeWorkflow type = new CTypeWorkflow(CSc2iWin32DataClient.ContexteCourant);
if (type.ReadIfExists(nIdType.Value))
{
m_txtTypeWorkflow.ElementSelectionne = type;
}
}
else
{
m_txtTypeWorkflow.ElementSelectionne = null;
}
m_txtLabel.Text = ctx["FILTRE_LABEL"] as string;
}
//-------------------------------------------------------
private CResultAErreur MajChamps()
{
CResultAErreur result = CResultAErreur.True;
CTypeWorkflow wkfType = m_txtSelectWorkflow.ElementSelectionne as CTypeWorkflow;
if (wkfType != null)
{
m_blocWorkflow.DbKeyTypeWorkflow = wkfType.DbKey;
}
else
{
m_blocWorkflow.DbKeyTypeWorkflow = null;
}
CTypeEtapeWorkflow typeEtape = m_cmbStartStep.ElementSelectionne as CTypeEtapeWorkflow;
if (typeEtape != null)
{
m_blocWorkflow.DbKeyTypeEtapeDémarrage = typeEtape.DbKey;
}
else
{
m_blocWorkflow.DbKeyTypeEtapeDémarrage = null;
}
if (m_txtWorkflowInit.Formule == null)
{
if (!m_txtWorkflowInit.ResultAnalyse)
{
result.EmpileErreur(m_txtWorkflowInit.ResultAnalyse.Erreur);
}
}
else
{
m_blocWorkflow.FormuleInitialisationWorkflowLance = m_txtWorkflowInit.Formule;
}
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);
}
}
}
}
}
}
}
//----------------------------------------------------------
public CWorkflowDessin(CTypeWorkflow typeWorkflow)
: this()
{
m_typeWorkflow = typeWorkflow;
}
//-------------------------------------------------------------------------
public CFormEditionTypeWorkflow(CTypeWorkflow TypeWorkflow, CListeObjetsDonnees liste)
: base(TypeWorkflow, liste)
{
// Cet appel est requis par le Concepteur Windows Form.
InitializeComponent();
}
/// ////////////////////////////////////////////////////////////////////
public CResultAErreur SerializeFiltre(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
InitCombos();
}
CActeur acteur = m_txtActeur.ElementSelectionne as CActeur;
int? nIdActeur = acteur != null ? (int?)acteur.Id : null;
serializer.TraiteIntNullable(ref nIdActeur);
if (nIdActeur != null && serializer.Mode == ModeSerialisation.Lecture)
{
acteur = new CActeur(CSc2iWin32DataClient.ContexteCourant);
if (acteur.ReadIfExists(nIdActeur.Value))
{
m_txtActeur.ElementSelectionne = acteur;
}
}
CEtatEtapeWorkflow etat = m_cmbEtats.SelectedValue as CEtatEtapeWorkflow;
int?nEtat = etat != null?(int?)etat.CodeInt:null;
serializer.TraiteIntNullable(ref nEtat);
if (serializer.Mode == ModeSerialisation.Lecture && nEtat != null)
{
etat = new CEtatEtapeWorkflow((EEtatEtapeWorkflow)nEtat.Value);
m_cmbEtats.SelectedValue = etat;
}
CTypeWorkflow type = m_txtTypeWorkflow.ElementSelectionne as CTypeWorkflow;
int? nIdType = type != null ? (int?)type.Id : null;
serializer.TraiteIntNullable(ref nIdType);
if (nIdType != null && serializer.Mode == ModeSerialisation.Lecture)
{
type = new CTypeWorkflow(CSc2iWin32DataClient.ContexteCourant);
if (type.ReadIfExists(nIdType.Value))
{
m_txtTypeWorkflow.ElementSelectionne = type;
}
}
string strText = m_txtLabel.Text;
serializer.TraiteString(ref strText);
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_txtLabel.Text = strText;
}
return(result);
}
//-------------------------------------------------------------------------
public CFormEditionTypeWorkflow(CTypeWorkflow TypeWorkflow)
: base(TypeWorkflow)
{
// Cet appel est requis par le Concepteur Windows Form.
InitializeComponent();
}
//-------------------------------------------------------------------
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);
}
}
}
}
}
