//---------------------------------------------------------------------------
public bool GenereItem(
object obj,
double fLat,
double fLong, CMapLayer layer)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(this.m_mapItemGenerator);
if (FormuleCondition != null && !(FormuleCondition is C2iExpressionVrai))
{
result = FormuleCondition.Eval(ctx);
if (!result || result.Data == null)
{
return(false);
}
bool?bResult = CUtilBool.BoolFromString(result.Data.ToString());
if (bResult == null || !bResult.Value)
{
return(false);
}
}
string strLibelle = "";
if (FormuleToolTip != null)
{
result = FormuleToolTip.Eval(ctx);
if (result && result.Data != null)
{
strLibelle = result.Data.ToString();
}
}
IMapItem item = null;
if (MarkerType != EMapMarkerType.none)
{
item = new CMapItemSimple(layer, fLat, fLong, MarkerType);
}
else if (Image != null)
{
if (layer.Database.GetImage(m_strImageId) == null)
{
layer.Database.AddImage(m_strImageId, Image);
}
item = new CMapItemImage(layer, fLat, fLong, m_strImageId);
}
else
{
item = new CMapItemSimple(layer, fLat, fLong, EMapMarkerType.green);
}
item.Tag = obj;
item.ToolTip = strLibelle;
item.PermanentToolTip = PermanentToolTip;
if (ItemGenerator.ActionSurClick != null)
{
item.MouseClicked += new MapItemClickEventHandler(OnMouseClick);
}
return(true);
}
//---------------------------------------------------
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);
}
//-----------------------------------------------------------------------------------------
public override CReferenceTypeForm GetFinalRefTypeForm(CObjetDonneeAIdNumeriqueAuto objetDonnee)
{
CResultAErreur result = CResultAErreur.True;
if (objetDonnee == null)
{
foreach (CParametreTypeForm parametre in m_listeParametres)
{
if (parametre.Formule == null || parametre.Formule is C2iExpressionVrai)
{
return(parametre.ReferenceTypeForm);
}
}
return(m_defaultTypeForm);
}
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(objetDonnee);
foreach (CParametreTypeForm parametre in m_listeParametres)
{
result.Data = true;
if (parametre.Formule != null)
{
result = parametre.Formule.Eval(ctxEval);
}
if (result && CUtilBool.BoolFromObject(result.Data))
{
return(parametre.ReferenceTypeForm);
}
}
if (m_defaultTypeForm != null)
{
return(m_defaultTypeForm);
}
return(null);
}
//--------------------------------------------------------
public virtual bool ShouldImport(DataRow row, CContexteImportDonnee contexte)
{
switch (m_optionImport)
{
case EOptionImport.OnCreate:
if (row.RowState != DataRowState.Added)
{
return(false);
}
break;
case EOptionImport.Never:
return(false);
}
if (Condition != null && !(Condition is C2iExpressionVrai))
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(row);
CResultAErreur result = Condition.Eval(ctx);
if (!result)
{
result.EmpileErreur(I.T("Error on condition formula '@1'|20103",
Condition.GetString()));
contexte.AddLog(new CLigneLogImport(ETypeLigneLogImport.Error,
row,
"",
contexte,
result.Erreur.ToString()));
return(false);
}
return(CUtilBool.BoolFromObject(result.Data));
}
return(true);
}
//---------------------------------------------------------------------------
public bool GenereItem(
object obj,
double fLat1,
double fLong1,
double fLat2,
double fLong2,
CMapLayer layer)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(this.m_mapLineGenerator);
if (FormuleCondition != null && !(FormuleCondition is C2iExpressionVrai))
{
result = FormuleCondition.Eval(ctx);
if (!result || result.Data == null)
{
return(false);
}
bool?bResult = CUtilBool.BoolFromString(result.Data.ToString());
if (bResult == null || !bResult.Value)
{
return(false);
}
}
string strLibelle = "";
if (FormuleToolTip != null)
{
result = FormuleToolTip.Eval(ctx);
if (result && result.Data != null)
{
strLibelle = result.Data.ToString();
}
}
CMapItemPath line = new CMapItemPath(layer);
line.LineColor = LineColor;
line.LineWidth = LineWidth;
line.ToolTip = strLibelle;
line.PermanentToolTip = m_bPermanentToolTip;
line.Tag = obj;
List <SLatLong> lstPts = new List <SLatLong>();
lstPts.Add(new SLatLong(fLat1, fLong1));
//lstPts.Add(new SLatLong((fLat1 + fLat2) / 2, (fLong1 + fLong2) / 2));
lstPts.Add(new SLatLong(fLat2, fLong2));
line.Points = lstPts;
if (LineGenerator.ActionSurClick != null)
{
line.MouseClicked += new MapItemClickEventHandler(OnMouseClick);
}
return(true);
}
//--------------------------------------------------------------------------
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 ITestDataHotel GetTestFinal(object objetPourSousProprietes)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(objetPourSousProprietes);
if (FormuleApplication != null)
{
result = FormuleApplication.Eval(ctx);
if (!result || result.Data == null)
{
return(null);
}
if (!CUtilBool.BoolFromObject(result.Data))
{
return(null);
}
}
double?valRef = null;
if (FormuleValeur != null)
{
result = FormuleValeur.Eval(ctx);
if (!result)
{
return(null);
}
if (result.Data is double)
{
valRef = (double)result.Data;
}
else
{
try
{
valRef = Convert.ToDouble(result.Data);
}
catch { }
}
}
if (valRef == null)
{
return(null);
}
CTestDataHotelValue test = new CTestDataHotelValue();
test.IdChamp = m_strHotelColonneId;
test.Operateur = Operateur;
test.ValeurReference = valRef.Value;
return(test);
}
//---------------------------------------------------------------------------
public CResultAErreur ExecuteAction(CActionSur2iLinkMenuDeroulant actionMenu, object sender, object objetCible)
{
CResultAErreur result = CResultAErreur.True;
List <ToolStripItem> listeItems = new List <ToolStripItem>();
foreach (IMenuItem item in actionMenu.ListeMenuItems)
{
bool bAdd = true;
if (item.FormuleCondition != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(objetCible);
result = item.FormuleCondition.Eval(ctx);
if (result && !CUtilBool.BoolFromObject(result.Data))
{
bAdd = false;
}
}
if (bAdd)
{
IExecuteurSpecifiqueActionMenuItem executeurSpecifique = null;
if (m_dicTypeActionExecuteur.TryGetValue(item.GetType(), out executeurSpecifique))
{
listeItems.AddRange(executeurSpecifique.GetItemsForContextMenuStrip(item, sender, objetCible));
}
}
}
ContextMenuStrip menuDeroulant = new ContextMenuStrip();
menuDeroulant.Items.Clear();
menuDeroulant.Items.AddRange(listeItems.ToArray());
if (menuDeroulant.Items.Count > 0)
{
/*if (sender != null)
* menuDeroulant.Show((Control)sender, new Point(0, ((Control)sender).Height));
* else*/
menuDeroulant.Show(Cursor.Position);
}
result.Data = listeItems.ToArray();
return(result);
}
//--------------------------------------------------
public ITestDataHotel GetTestFinal(object objetPourSousProprietes)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(objetPourSousProprietes);
if (FormuleApplication != null)
{
result = FormuleApplication.Eval(ctx);
if (!result || result.Data == null)
{
return(null);
}
if (!CUtilBool.BoolFromObject(result.Data))
{
return(null);
}
}
DateTime?dateRef = null;
if (FormuleDate != null)
{
result = FormuleDate.Eval(ctx);
if (!result)
{
return(null);
}
if (result.Data is DateTime || result.Data is CDateTimeEx)
{
dateRef = (DateTime)result.Data;
}
}
if (dateRef == null)
{
return(null);
}
CTestDataHotelDate test = new CTestDataHotelDate();
test.Operateur = Operateur;
test.DateTest = dateRef.Value;
return(test);
}
//---------------------------------------------------
public override CResultAErreur EndEtapeNoSave(CEtapeWorkflow etape)
{
HashSet <string> lstCodes = new HashSet <string>();
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(etape);
foreach (CFormuleNommee formule in FormulesCodesRetour)
{
CResultAErreur result = formule.Formule.Eval(ctx);
bool? bOk = result && result.Data != null?CUtilBool.BoolFromString(result.Data.ToString()) : null;
if (bOk != null && bOk.Value)
{
lstCodes.Add(formule.Libelle);
}
}
if (lstCodes.Count == 0)
{
lstCodes.Add(c_codeRetourAutres);
}
etape.CodesRetour = lstCodes.ToArray();
return(base.EndEtapeNoSave(etape));
}
//--------------------------------------------
protected virtual bool ShouldApply(CEasyQuery query)
{
if (m_condition == null)
{
return(true);
}
if (m_condition is C2iExpressionVrai)
{
return(true);
}
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(query);
CResultAErreur result = m_condition.Eval(ctx);
if (!result)
{
return(true);
}
if (CUtilBool.BoolFromObject(result.Data))
{
return(true);
}
return(false);
}
public void Init(
CWndFor2iDataGrid wndFor2iDataGrid,
C2iWndDataGrid wndGrid,
object elementEdite,
List <object> lstObjets,
IFournisseurProprietesDynamiques fournisseur)
{
m_wndFor2iDataGrid = wndFor2iDataGrid;
m_listeObjetsOriginale = lstObjets;
m_fournisseur = fournisseur;
m_wndGrid = wndGrid;
m_elementEdite = elementEdite;
if (m_cache != null)
{
m_cache.Dispose();
}
m_cache = new CGridDataCache(this);
List <object> listeObjets = new List <object>(lstObjets);
foreach (object newElt in m_listeElementsAdd)
{
if (!lstObjets.Contains(newElt))
{
lstObjets.Add(newElt);
}
}
m_panelTop.Visible = m_wndGrid.HasAddButton || m_wndGrid.HasDeleteButton;
m_lnkAdd.Visible = m_wndGrid.HasAddButton;
m_lnkDelete.Visible = m_wndGrid.HasDeleteButton;
m_grid.AutoGenerateColumns = false;
Filtrer();
m_grid.SuspendDrawing();
//m_grid.DataSource = lstObjets;
m_grid.Columns.Clear();
int nMaxHeight = m_grid.ColumnHeadersHeight;
m_grid.EnableHeadersVisualStyles = false;
m_grid.RowHeadersVisible = m_wndGrid.RowHeaderWidth != 0;
m_grid.RowHeadersWidth = Math.Max(m_wndGrid.RowHeaderWidth, 10);
m_grid.RowHeadersDefaultCellStyle.BackColor = m_wndGrid.RowHeaderColor;
m_grid.BackgroundColor = m_wndGrid.BackColor;
m_grid.DefaultCellStyle.SelectionBackColor = m_wndGrid.SelectedCellBackColor;
m_grid.DefaultCellStyle.SelectionForeColor = m_wndGrid.SelectedCellForeColor;
m_grid.EditMode = DataGridViewEditMode.EditOnEnter;
if (m_wndGrid.DefaultRowHeight > 0)
{
m_grid.RowTemplate.Height = m_wndGrid.DefaultRowHeight;
}
int nCol = 0;
foreach (I2iObjetGraphique obj in m_wndGrid.Childs)
{
C2iWndDataGridColumn col = obj as C2iWndDataGridColumn;
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(m_elementEdite);
//Evalue la formule de visibilité
if (col.Visiblity != null)
{
CResultAErreur res = col.Visiblity.Eval(ctxEval);
if (res && !CUtilBool.BoolFromObject(res.Data))
{
col = null;
}
}
if (col != null)
{
IWndIncluableDansDataGrid wndForGrid = col.Control as IWndIncluableDansDataGrid;
m_cache.RegisterControle(nCol, wndForGrid);
nCol++;
if (wndForGrid != null)
{
DataGridViewColumn gridCol = new DataGridViewColumn(
new CDataGridViewCustomCellFor2iWnd(m_cache, col, nCol - 1, wndForGrid, m_fournisseur)
);
if (col.Enabled != null)
{
CResultAErreur result = col.Enabled.Eval(ctxEval);
if (result && !CUtilBool.BoolFromObject(result.Data))
{
gridCol.ReadOnly = true;
}
}
gridCol.HeaderText = col.Text;
gridCol.Width = col.ColumnWidth;
DataGridViewCellStyle style = new DataGridViewCellStyle();
style.BackColor = col.BackColor;
style.ForeColor = col.ForeColor;
style.Font = col.Font;
gridCol.HeaderCell.Style = style;
if (col.Control != null)
{
DataGridViewCellStyle styleCell = new DataGridViewCellStyle();
styleCell.Font = col.Control.Font;
styleCell.BackColor = col.Control.BackColor;
styleCell.ForeColor = col.Control.ForeColor;
styleCell.WrapMode = DataGridViewTriState.True;
gridCol.CellTemplate.Style = styleCell;
}
m_grid.Columns.Add(gridCol);
nMaxHeight = Math.Max(col.Size.Height, nMaxHeight);
}
}
}
m_grid.ResumeDrawing();
m_grid.ColumnHeadersHeight = nMaxHeight;
InitRestrictions(m_listeRestrictions);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(Process);
object elementCible = null;
if (FormuleElementCible != null)
{
result = FormuleElementCible.Eval(ctxEval);
if (result)
{
elementCible = result.Data;
}
}
if (elementCible == null)
{
result.EmpileErreur(I.T("Error in target element formula|20236"));
return(result);
}
else if (elementCible is CObjetDonnee)
{
elementCible = ((CObjetDonnee)elementCible).GetObjetInContexte(contexte.ContexteDonnee);
}
CLigneTableParametrable ligne = null;
if (FormuleRow != null)
{
result = FormuleRow.Eval(ctxEval);
if (result)
{
ligne = result.Data as CLigneTableParametrable;
}
}
if (ligne == null)
{
result.EmpileErreur(I.T("Error in table row formula|20238"));
return(result);
}
//Identifie les colonnes à importer
Dictionary <string, CDefinitionProprieteDynamique> dicMap = new Dictionary <string, CDefinitionProprieteDynamique>();
foreach (CMappageColonne mappage in Mappages)
{
if (mappage.ProprieteCible != null)
{
bool bPrendre = true;
CColonneTableParametrable col = new CColonneTableParametrable(contexte.ContexteDonnee);
if (col.ReadIfExists(mappage.IdColonne))
{
if (mappage.FormuleCondition != null)
{
result = mappage.FormuleCondition.Eval(ctxEval);
if (!result || result.Data == null)
{
bPrendre = false;
}
else
{
bool?bTmp = CUtilBool.BoolFromString(result.Data.ToString());
if (bTmp != null)
{
bPrendre = bTmp.Value;
}
else
{
bPrendre = false;
}
}
}
if (bPrendre)
{
object val = ligne.GetValue(col.Libelle);
if (val != null || !m_bIgnorerLesValeursVides)
{
try
{
CInterpreteurProprieteDynamique.SetValue(elementCible, mappage.ProprieteCible, ligne.GetValue(col.Libelle));
}
catch
{
}
}
}
}
}
}
return(result);
}
//---------------------------------------------------
//S'assure que le projet est bien créé
internal CResultAErreurType <CProjet> GetOrCreateProjetInCurrentContexte(CEtapeWorkflow etape, CProjet projetParent, IEnumerable <CProjet> predecesseurs)
{
CResultAErreurType <CProjet> resProjet = new CResultAErreurType <CProjet>();
CWorkflow workflow = GetOrCreateWorkflowInCurrentContexte(etape);
if (workflow == null)
{
resProjet.EmpileErreur(I.T("Can not create workflow for step @1|20143", etape.Libelle));
return(resProjet);
}
if (m_nIdChampProjet == null)
{
resProjet.EmpileErreur(I.T("Workflow step @1 doesn't define a field to store associated project|20142", etape.Libelle));
return(resProjet);
}
CProjet projet = workflow.GetValeurChamp(m_nIdChampProjet.Value) as CProjet;
//SC 8/5/2013 : s'assure que le projet a le bon parent !
if (projetParent != null && projet != null &&
projetParent != projet.Projet)
{
projet = null;
}
string strGanttId = GetGanttId(etape);
if (projet == null)
{
//Création du projet
projet = new CProjet(etape.ContexteDonnee);
CTypeProjet typeProjet = null;
if (m_dbKeyTypeProjet != null) //s'il est null, pas d'erreur ça peut être les formules d'initialisation qui le remplissent
{
typeProjet = new CTypeProjet(etape.ContexteDonnee);
if (!typeProjet.ReadIfExists(m_dbKeyTypeProjet))
{
resProjet.EmpileErreur(I.T("Project type @1 for step @2 doesn't exists|20144", m_dbKeyTypeProjet.StringValue, etape.Libelle));
return(resProjet);
}
}
projet.CreateNewInCurrentContexte();
projet.TypeProjet = typeProjet;
projet.GanttId = strGanttId;
DateTime?dateDebut = null;
foreach (CProjet pred in predecesseurs)
{
if (dateDebut == null || pred.DateFinGantt > dateDebut.Value)
{
dateDebut = pred.DateFinGantt;
}
}
if (dateDebut == null)
{
dateDebut = DateTime.Now;
}
projet.DateDebutPlanifiee = dateDebut;
if (typeProjet != null)
{
projet.DateFinPlanifiee = projet.DateDebutPlanifiee.Value.AddHours(typeProjet.DureeDefautHeures);
}
projet.Projet = projetParent;
projet.Libelle = etape.Libelle;
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());
}
}
foreach (CProjet predecesseur in predecesseurs)
{
projet.AddPredecessor(predecesseur);
}
CResultAErreur result = workflow.SetValeurChamp(m_nIdChampProjet.Value, projet);
if (!result)
{
resProjet.EmpileErreur(result.MessageErreur);
return(resProjet);
}
}
resProjet.DataType = projet;
return(resProjet);
}
//--------------------------------------------------------------------------
/// <summary>
/// Retourne un projet pouvant être executé pour l'étape demandée<BR>
/// </BR>
/// Cette fonction se charge de la mise à jour de toutes la structure du projet
/// </summary>
/// <param name="etape"></param>
/// <returns></returns>
public static CResultAErreurType <CProjet> AssureProjetRunnable(CEtapeWorkflow etape, CBlocWorkflowProjet blocProjet)
{
CResultAErreurType <CProjet> resProjet = new CResultAErreurType <CProjet>();
CProjet projet = GetProjetDirectementAssocie(etape);
int nNumLastIteration = 0;
if (projet != null)
{
nNumLastIteration = projet.NumeroIteration;
if (projet.GanttId == "")
{
projet.GanttId = blocProjet.GetGanttId(etape);
}
}
CProjet projetParent = FindProjetParent(etape);
if (projetParent != null && projet != null &&
projetParent != projet.Projet)
{
projet = null;
}
if (projet == null)
{
resProjet = blocProjet.GetOrCreateProjetInCurrentContexte(etape,
FindProjetParent(etape),
FindPredecesseurs(etape));
return(resProjet);
}
if (
projet.DateFinRelle == null ||
!blocProjet.GererIteration ||
projet.HasOptionLienEtape(EOptionLienProjetEtape.NoIteration))
{
if ((!blocProjet.GererIteration || projet.HasOptionLienEtape(EOptionLienProjetEtape.NoIteration)) &&
!projet.HasOptionLienEtape(EOptionLienProjetEtape.StepKeepDates))
{
projet.DateFinRelle = null;
}
resProjet.DataType = projet;
return(resProjet);
}
//Il faut créer une ittération pour ce projet
IEnumerable <CProjet> predecesseurs = FindPredecesseurs(etape);
CProjet newProjet = projet.Clone(false) as CProjet;
//Remet les dates à null
newProjet.DateDebutReel = null;
newProjet.DateFinRelle = null;
//Met les deux projets sur la même barre de gantt
if (projet.GanttId.Length == 0)
{
projet.GanttId = blocProjet.GetGanttId(etape);
}
newProjet.GanttId = projet.GanttId;
DateTime?dateDebut = null;
foreach (CProjet pred in predecesseurs)
{
if (dateDebut == null || pred.DateFinGantt > dateDebut.Value)
{
dateDebut = pred.DateFinGantt;
}
}
if (dateDebut == null)
{
dateDebut = DateTime.Now;
}
if (dateDebut != null)
{
newProjet.DateDebutPlanifiee = dateDebut.Value;
newProjet.DateFinPlanifiee = dateDebut.Value.AddHours(projet.DureeEnHeure.Value);
}
newProjet.DateDebutAuto = true;
newProjet.NumeroIteration = nNumLastIteration + 1;
//Supprime toutes les dépendances du nouveau projet
CObjetDonneeAIdNumerique.Delete(newProjet.LiensDeProjetAttaches, true);
//Change le workflow lancé
etape.WorkflowLancé.SetValeurChamp(blocProjet.IdChampProjet.Value, newProjet);
//Crée les liens vers les prédécesseurs
foreach (CProjet pred in predecesseurs)
{
newProjet.AddPredecessor(pred);
}
//Met à jour les successeurs
foreach (CTypeEtapeWorkflow typeSucc in FindTypesSuccesseurs(etape.TypeEtape))
{
CEtapeWorkflow succ = etape.Workflow.GetEtapeForType(typeSucc);
if (succ != null)
{
resProjet = AssureProjetRunnable(succ, succ.TypeEtape.Bloc as CBlocWorkflowProjet);
CProjet prjSucc = resProjet.DataType;
if (prjSucc != null)
{
//Si le projet est lié à l'ancien, on déplace le lien
CLienDeProjet lien = prjSucc.GetLienToPredecesseur(projet);
if (lien != null)
{
lien.ProjetA = newProjet;
}
}
}
}
newProjet.AutoMoveDependancies();
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(etape);
foreach (CAffectationsProprietes affectation in blocProjet.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(newProjet, etape, new CFournisseurPropDynStd());
}
}
resProjet.DataType = newProjet;
return(resProjet);
}
//-------------------------------------------------------------------
/// <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);
}
