//------------------------------------------
protected override void MyGetXmlText(CEasyQuery query, StringBuilder bl, int nIndent)
{
if (BaliseOperateur.Length > 0 && m_champ != null)
{
AddIndent(bl, nIndent);
bl.Append("<");
bl.Append(BaliseOperateur);
bl.Append(">");
bl.Append(Environment.NewLine);
m_champ.GetXmlText(query, bl, nIndent + 1);
bl.Append(Environment.NewLine);
bl.Append("<Value Type='Text'>");
if (m_valeur != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(query);
CResultAErreur result = m_valeur.Eval(ctx);
if (result && result.Data != null)
{
bl.Append(result.Data.ToString());
}
}
bl.Append("</Value>");
bl.Append(Environment.NewLine);
bl.Append("</");
bl.Append(BaliseOperateur);
bl.Append(">");
bl.Append(Environment.NewLine);
}
}
//------------------------------------------------------------------------------------
protected override TextFormatting GetFormatting(Node node, TreeListColumn column)
{
CResultAErreur result = CResultAErreur.True;
TextFormatting format = new TextFormatting(base.GetFormatting(node, column));
CLocalAlarmeAffichee alarme = node.Tag as CLocalAlarmeAffichee;
if (alarme != null)
{
try
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(alarme);
C2iExpression exp = m_parametreAffichage.FormuleItemBackColor;
if (exp != null)
{
result = exp.Eval(ctx);
if (result)
{
Color couleurFond = (Color)result.Data;
if (couleurFond != null)
{
format.BackColor = couleurFond;
}
}
}
exp = m_parametreAffichage.FormuleItemForeColor;
if (exp != null)
{
result = exp.Eval(ctx);
if (result)
{
Color couleurTexte = (Color)result.Data;
if (couleurTexte != null)
{
format.ForeColor = couleurTexte;
}
}
}
CActionSur2iLink action = null;
if (m_dicIndexColonneAction.TryGetValue(column.Index, out action))
{
Font font = new Font(format.Font, FontStyle.Underline);
format.Font = font;
}
}
catch
{
}
}
return(format);
}
protected CResultAErreur TraiterEditionPanel(CObjetDonnee objet)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression ctxEval = CUtilControlesWnd.GetContexteEval(this, objet);
C2iWndListeSpeedStandard listeStd = this.WndAssociee as C2iWndListeSpeedStandard;
if (listeStd != null)
{
C2iExpression formule = listeStd.AlternativeEditedElement;
result = formule.Eval(ctxEval);
if (!result)
{
return(result);
}
CObjetDonneeAIdNumeriqueAuto objetToEdit = result.Data as CObjetDonneeAIdNumeriqueAuto;
if (objetToEdit != null)
{
CReferenceTypeForm refTypeForm = CFormFinder.GetRefFormToEdit(objetToEdit.GetType());
IFormNavigable frmToShow = refTypeForm.GetForm(objetToEdit) as IFormNavigable;
IFormNavigable frm = m_panelListeSpeedStd.FindForm() as IFormNavigable;
if (frm != null)
{
frm.Navigateur.AffichePage(frmToShow);
}
else
{
CFormNavigateurPopup.Show(frmToShow);
}
}
return(result);
}
return(result);
}
//----------------------------------------------------
public CIconeGantt GetIcone(IElementDeGantt element)
{
if (m_formuleCondition != null && Image != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(element);
CResultAErreur result = m_formuleCondition.Eval(ctx);
if (result)
{
if (result.Data is bool && (bool)result.Data)
{
string strTooltip = "";
if (Tooltip != null)
{
result = Tooltip.Eval(ctx);
if (result)
{
strTooltip = result.Data.ToString();
}
}
return(new CIconeGantt(Image, strTooltip));
}
}
}
return(null);
}
/// //////////////////////////////////////////////////////
private void m_btnTester_Click(object sender, System.EventArgs e)
{
C2iExpression expression = GetExpression();
if (expression == null)
{
return;
}
if (m_cmbType.SelectedItem == null || !(m_cmbType.SelectedItem is C2iTypeDonnee))
{
CFormAlerte.Afficher(I.T("Select a data type|30026"), EFormAlerteType.Exclamation);
return;
}
TypeDonnee tp = ((C2iTypeDonnee)m_cmbType.SelectedItem).TypeDonnee;
object obj = CObjetForTestValeurChampCustom.GetNewForTypeDonnee(tp,
null, m_txtTest.Text);
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(obj);
CResultAErreur result = expression.Eval(ctx);
if (!result)
{
result.EmpileErreur(I.T("Error during validation formula evaluation|30027"));
CFormAlerte.Afficher(result);
return;
}
if ((result.Data is bool && (bool)result.Data) || result.Data.ToString() == "1")
{
CFormAlerte.Afficher(I.T("Accepted value|30028"));
}
else
{
CFormAlerte.Afficher(I.T("Rejected value|30029"), EFormAlerteType.Erreur);
}
}
/// ////////////////////////////////////////////////////////////////////////////
private void m_btnEvaluer_Click(object sender, System.EventArgs e)
{
CContexteAnalyse2iExpression ctx = new CContexteAnalyse2iExpression(m_fournisseurProprietes, m_objetTest.GetType());
CAnalyseurSyntaxiqueExpression analyseur = new CAnalyseurSyntaxiqueExpression(ctx);
CResultAErreur result = analyseur.AnalyseChaine(m_txtFormule.Text);
m_arbreAnalyse.Nodes.Clear();
if (!result)
{
m_txtResult.Text = result.Erreur.ToString();
return;
}
C2iExpression expression = (C2iExpression)result.Data;
if (expression == null)
{
m_txtResult.Text = "Analyzed expression is null|30001";
return;
}
m_txtResult.Text = "Expression :" + Environment.NewLine + expression.GetString() + Environment.NewLine + "**********************";
FillNodes(m_arbreAnalyse.Nodes, expression);
m_txtResult.Text += "Evaluation :" + Environment.NewLine;
result = expression.Eval(new CContexteEvaluationExpression(m_objetTest));
if (!result)
{
m_txtResult.Text += result.Erreur.ToString();
}
else
{
m_txtResult.Text = result.Data.ToString();
}
}
public string GetNextValue(object source)
{
C2iExpression formule = FormuleCle;
string strCle = "";
if (formule != null)
{
Type typeSource = TypeSource;
CContexteEvaluationExpression ctx = null;
if (typeSource != null)
{
//Vérifie que la source est du bon type
if (source == null || !typeSource.IsAssignableFrom(source.GetType()))
{
throw new Exception(I.T("Source type is invalide for sequence @1 (@2)",
Libelle,
source == null?"Null":source.GetType().ToString()));
}
ctx = new CContexteEvaluationExpression(source);
}
else
{
ctx = new CContexteEvaluationExpression(null);
}
CResultAErreur result = formule.Eval(ctx);
if (!result)
{
throw new Exception(I.T("Error while evaluating key formula for sequence @1|20131",
Libelle));
}
if (result.Data != null)
{
strCle = result.Data.ToString();
}
else
{
strCle = "";
}
}
//Cherche la dernière valeur pour cette clé
CValeurSequenceNumerotation valeur = new CValeurSequenceNumerotation(ContexteDonnee);
if (!valeur.ReadIfExists(new CFiltreData(CValeurSequenceNumerotation.c_champCle + "=@1 and " +
CSequenceNumerotation.c_champId + "=@2",
strCle,
Id)))
{
valeur.CreateNewInCurrentContexte();
valeur.SequenceNumerotation = this;
valeur.DerniereValeur = ValeurDepart;
valeur.Cle = strCle;
}
else
{
valeur.DerniereValeur++;
}
string strValeur = strCle + FormatNumerotation.GetReference(valeur.DerniereValeur).Data.ToString();
return(strValeur);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
if (m_expressionElementADissocier == null)
{
result.EmpileErreur(I.T("No element to be dissociated|169"));
return(result);
}
result = m_expressionElementADissocier.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error in the elements to be dissociated formula|170"));
return(result);
}
if (result.Data != null)
{
if (!(result.Data is CObjetDonneeAIdNumerique))
{
result.EmpileErreur(I.T("The element to be dissociated formula must be return a work entity|167"));
return(result);
}
CComportementGenerique comportement = new CComportementGenerique(contexte.ContexteDonnee);
if (!comportement.ReadIfExists(m_dbKeyComportement))
{
return(result);
}
comportement.RemoveComportementFromObjet((CObjetDonneeAIdNumerique)result.Data);
}
return(result);
}
///Applique le paramètre à un élément
public void ApplyOnElement(C2iSymbole element, CContexteEvaluationExpression ctxEval)
{
foreach (KeyValuePair <string, C2iExpression> kv in m_dicFormulesParPropriete)
{
string strPropriete = kv.Key;
C2iExpression formule = kv.Value;
if (formule != null)
{
//Trouve la propriete
PropertyInfo info = element.GetType().GetProperty(strPropriete);
if (info != null && info.GetSetMethod() != null)
{
MethodInfo methode = info.GetSetMethod();
CResultAErreur result = formule.Eval(ctxEval);
if (result)
{
try
{
methode.Invoke(element, new object[] { result.Data });
}
catch
{
}
}
}
}
}
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
if (m_expressionElementAAssocier == null)
{
result.EmpileErreur(I.T("Not element to be associated|110"));
return(result);
}
result = m_expressionElementAAssocier.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error in element to be associated formula|111"));
return(result);
}
if (result.Data != null)
{
if (!(result.Data is CObjetDonneeAIdNumerique))
{
result.EmpileErreur(I.T("The element to be associated formula doesn't return a work entity|112"));
return(result);
}
CComportementGenerique comportement = new CComportementGenerique(contexte.ContexteDonnee);
if (!comportement.ReadIfExists(m_dbKeyComportement))
{
result.EmpileErreur(I.T("The @1 behavior doesn't exist|113", m_dbKeyComportement.ToString()));
return(result);
}
comportement.AddComportementToObjet((CObjetDonneeAIdNumerique)result.Data);
}
return(result);
}
/// //////////////////////////////////////////
private void UpdateUtilisateurEnDur()
{
CResultAErreur result = GetExpressionUtilisateur();
if (!result)
{
m_lblUtilisateurEnDur.Visible = false;
}
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(null);
C2iExpression exp = (C2iExpression)result.Data;
if (exp != null)
{
result = exp.Eval(ctx);
if (result)
{
try
{
int nId = Convert.ToInt32(result.Data);
using (CContexteDonnee contexte = new CContexteDonnee(CTimosApp.SessionClient.IdSession, true, false))
{
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(contexte);
if (user.ReadIfExists(nId))
{
m_lblUtilisateurEnDur.Text = user.Acteur.Nom;
m_lblUtilisateurEnDur.Visible = true;
return;
}
}
}
catch {}
}
}
m_lblUtilisateurEnDur.Visible = false;
}
public object GetValue(object objet)
{
if (m_formule == null)
{
return(null);
}
if (m_contexteEval == null)
{
m_contexteEval = new CContexteEvaluationExpression(objet);
m_contexteEval.UseOptimiseurs = true;
}
else
{
m_contexteEval.ChangeSource(objet);
}
if (objet is CObjetDonnee)
{
m_contexteEval.AttacheObjet(typeof(CContexteDonnee), ((CObjetDonnee)objet).ContexteDonnee);
}
CResultAErreur result = m_formule.Eval(m_contexteEval);
if (result)
{
return(result.Data);
}
return(null);
}
//------------------------------------------------------------
public CResultAErreur GetValue(object objet, string strPropriete)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression contexte = new CContexteEvaluationExpression(objet);
if (objet is CObjetDonnee)
{
contexte.AttacheObjet(typeof(CContexteDonnee), ((CObjetDonnee)objet).ContexteDonnee);
}
Type tpAnalyse = null;
if (objet != null)
{
tpAnalyse = objet.GetType();
}
CContexteAnalyse2iExpression ctx = new CContexteAnalyse2iExpression(new CFournisseurPropDynStd(), tpAnalyse);
CAnalyseurSyntaxiqueExpression analyseur = new CAnalyseurSyntaxiqueExpression(ctx);
result = analyseur.AnalyseChaine(strPropriete);
if (!result)
{
return(result);
}
C2iExpression formule = (C2iExpression)result.Data;
result = formule.Eval(contexte);
if (result)
{
return(result);
}
return(result);
}
/// ////////////////////////////////////////////////////////////
public void FillNode(TreeNode node, CObjetDonneeAIdNumeriqueAuto objet)
{
if (objet != null)
{
string strText = "";
if (m_formuleLibelle != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(objet);
CResultAErreur result = m_formuleLibelle.Eval(ctx);
if (result && result.Data != null)
{
strText = result.Data.ToString();
}
}
if (strText.Length == 0)
{
strText = CInterpreteurTextePropriete.GetStringValue(objet, m_strProprieteAffichee, "Non def");
}
node.Text = strText;
}
CInfoNode info;
if (node.Tag is CInfoNode)
{
info = (CInfoNode)node.Tag;
}
else
{
info = new CInfoNode();
}
info.Objet = objet;
node.Tag = info;
}
/// //////////////////////////////////////////////////////////////
protected override sc2i.common.CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
IDeclencheurActionSurServeur declencheur = (IDeclencheurActionSurServeur)C2iFactory.GetNewObjetForSession("CDeclencheurActionSurServeur", typeof(IDeclencheurActionSurServeur), contexte.IdSession);
if (declencheur == null)
{
result.EmpileErreur(I.T("Release action allocation server fail|187"));
return(result);
}
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
Hashtable valeursParametres = new Hashtable();
foreach (DictionaryEntry entry in m_tableValeursParametres)
{
string strProp = (string)entry.Key;
C2iExpression expression = (C2iExpression)entry.Value;
//Cherche la propriété
result = expression.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during @1 value evaluation|188", entry.Key.ToString()));
return(result);
}
valeursParametres[entry.Key] = result.Data;
}
return(declencheur.ExecuteAction(m_strCodeActionServeur, valeursParametres));
}
//---------------------------------------
public void SetElementToEvalFormules(object element)
{
if (m_dicFormulesParPropriete.Count > 0)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(element);
foreach (KeyValuePair <string, C2iExpression> propFormule in m_dicFormulesParPropriete)
{
string strProp = propFormule.Key;
C2iExpression exp = propFormule.Value;
CResultAErreur result = exp.Eval(ctx);
if (result)
{
try
{
PropertyInfo info = GetType().GetProperty(strProp);
if (info != null && info.GetSetMethod() != null)
{
info.GetSetMethod().Invoke(this, new object[] { result.Data });
}
}
catch
{
}
}
}
}
foreach (C2iComposant3D composant in Childs)
{
composant.SetElementToEvalFormules(element);
}
}
//---------------------------------------------------------------------------------------------------------
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);
}
//---------------------------------------------------------------------------------------------------------
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);
}
private void m_btnEval_Click(object sender, EventArgs e)
{
C2iExpression formule = m_txtFormule.Formule;
CResultAErreur res = CResultAErreur.True;
if (formule == null)
{
res = m_txtFormule.ResultAnalyse;
}
else
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression("");
res = formule.Eval(ctx);
}
if (!res)
{
m_txtResult.Text = res.Erreur.ToString();
}
else
{
if (res.Data == null)
{
m_txtResult.Text = "null";
}
else
{
m_txtResult.Text = res.Data.ToString();
}
}
}
/// /////////////////////////////////////////////////////////////////////////////////////
private static CResultAErreur ExecuteActionFormulairePopup(CActionSur2iLinkFormulairePopup actionPopup, object sender, object objetCible)
{
CResultAErreur result = CResultAErreur.True;
C2iExpression formuleElement = actionPopup.FormuleElementEdite;
IObjetDonnee elementEdite = null;
if (formuleElement != null)
{
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(objetCible);
ctxEval.AttacheObjet(typeof(CContexteDonnee), CSc2iWin32DataClient.ContexteCourant);
result = formuleElement.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Element evaluation error|30084"));
return(result);
}
if (result.Data == null)
{
result.EmpileErreur(I.T("Not avaliable|30082"));
return(result);
}
elementEdite = result.Data as IObjetDonnee;
}
else
{
elementEdite = objetCible as IObjetDonnee;
}
if (elementEdite != null)
{
Point pt = Cursor.Position;
bool bModeEdition = false;
if (sender != null)
{
pt = ((Control)sender).Location;
Form frm = ((Control)sender).FindForm();
if (frm != null && frm is CFormEditionStandard)
{
bModeEdition = ((CFormEditionStandard)frm).ModeEdition;
}
}
CFormExecuteActionFormulairePopup.Popup(
pt,
actionPopup,
elementEdite,
bModeEdition);
}
else
{
result.EmpileErreur(I.T("Popup form element is not a valid object|20882"));
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MyExecute(CContexteExecutionAction contexte)
{
CResultAErreur result = CResultAErreur.True;
CObjetDonneeAIdNumeriqueAuto objet = (CObjetDonneeAIdNumeriqueAuto)Activator.CreateInstance(m_typeEntiteACreer, new object[] { contexte.ContexteDonnee });
objet.CreateNewInCurrentContexte();
CContexteEvaluationExpression contexteEval = new CContexteEvaluationExpression(Process);
contexteEval.AttacheObjet(typeof(CContexteDonnee), contexte.ContexteDonnee);
foreach (DictionaryEntry entry in m_tableValeursProprietes)
{
string strProp = (string)entry.Key;
C2iExpression expression = (C2iExpression)entry.Value;
//Cherche la propriété
PropertyInfo info = m_typeEntiteACreer.GetProperty(strProp);
string strNomConvivial = strProp;
object[] attr = info.GetCustomAttributes(typeof(DynamicFieldAttribute), true);
if (attr.Length > 0)
{
strNomConvivial = ((DynamicFieldAttribute)attr[0]).NomConvivial;
}
MethodInfo methode = info.GetSetMethod();
if (methode != null)
{
//Evalue la valeur
result = expression.Eval(contexteEval);
if (!result)
{
result.EmpileErreur(I.T("Error during the @1 value evaluation|140", strNomConvivial));
return(result);
}
try
{
methode.Invoke(objet, new object[] { result.Data });
}
catch (Exception e)
{
result.EmpileErreur(I.T("Error during the assignment of @1 property|141", strNomConvivial));
result.EmpileErreur(e.Message);
return(result);
}
}
}
if (VariableResultat != null)
{
Process.SetValeurChamp(VariableResultat, objet);
}
CLienAction[] liens = GetLiensSortantHorsErreur();
if (liens.Length > 0)
{
result.Data = liens[0];
}
return(result);
}
/// //////////////////////////////////////////////////////////////
public override object GetValeur(object obj, CCacheValeursProprietes cacheValeurs, CRestrictionUtilisateurSurType restriction)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(obj, cacheValeurs);
CResultAErreur result = Expression.Eval(ctx);
if (!result)
{
return(null);
}
return(result.Data);
}
//----------------------------------------------------------------------------------
public DateTime?GetDateFromExpression(IElementDeGantt element, C2iExpression formule)
{
if (formule != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(element);
CResultAErreur result = formule.Eval(ctx);
if (result && result.Data is DateTime)
{
return((DateTime)result.Data);
}
}
return(null);
}
//--------------------------------------
public Color GetBackColor(CElementAVariablesDynamiques elt)
{
if (FormuleBackColor != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(elt);
CResultAErreur result = FormuleBackColor.Eval(ctx);
if (result && result.Data is Color)
{
return((Color)result.Data);
}
}
return(BackColor);
}
/// ///////////////////////////////////////////
public object GetValeurParDefaut()
{
if (m_expressionValeurParDefaut != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(null);
CResultAErreur result = m_expressionValeurParDefaut.Eval(ctx);
if (result)
{
return(result.Data);
}
}
return(null);
}
public object GetObjectValueForGrid(object element)
{
if (m_expression != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(element);
CResultAErreur result = m_expression.Eval(ctx);
if (result && result.Data != null)
{
return(result.Data);
}
}
return("");
}
//---------------------------------------------------
public override CResultAErreur RunAndSaveIfOk(CEtapeWorkflow etape)
{
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(etape);
CResultAErreur result = CResultAErreur.True;
if (m_formuleElementDeclencheur == null)
{
result.EmpileErreur(I.T("Invalid wait paramter on step @1|20091", TypeEtape.Libelle));
return(result);
}
result = m_formuleElementDeclencheur.Eval(ctxEval);
if (!result)
{
result.EmpileErreur(I.T("Invalid wait parameter on step @1|20091", TypeEtape.Libelle));
return(result);
}
if (result.Data == null)//Pas de cible, ok, on dégage
{
return(EndAndSaveIfOk(etape));
}
CObjetDonneeAIdNumerique objetCible = result.Data as CObjetDonneeAIdNumerique;
if (objetCible == null)
{
result.EmpileErreur(I.T("Can not run wait step @1 on type @2|20092",
TypeEtape.Libelle, DynamicClassAttribute.GetNomConvivial(result.Data.GetType())));
return(result);
}
CResultAErreurType <CHandlerEvenement> resH = CHandlerEvenement.CreateHandlerOnObject(
etape.ContexteDonnee,
objetCible,
ParametreDeclencheur,
"Workflow step " + TypeEtape.Id + "/" + etape.UniversalId,
etape.UniversalId);
if (!resH)
{
result.EmpileErreur(resH.Erreur);
return(result);
}
if (resH)
{
resH.DataType.EtapeWorkflowATerminer = etape;
}
return(etape.ContexteDonnee.SaveAll(true));
}
//-------------------------------------------------------------------
public object[] GetValues(CChartSetup chart)
{
List <object> lstRetour = new List <object>();
CParametreSourceChart p = chart.ParametresDonnees.GetSourceFV(m_strIdSource);
if (p != null && m_formule != null)
{
object valeur = p.GetSource(chart);
IEnumerable valEnum = valeur as IEnumerable;
if (valEnum is IEnumerable && EvaluateOnEachSourceElement)
{
foreach (object o in valEnum)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(o);
CResultAErreur result = m_formule.Eval(ctx);
if (result)
{
lstRetour.Add(result.Data);
}
}
}
else
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(valeur);
CResultAErreur result = m_formule.Eval(ctx);
IEnumerable retour = result.Data as IEnumerable;
if (retour != null)
{
foreach (object obj in retour)
{
lstRetour.Add(obj);
}
}
}
}
return(lstRetour.ToArray());
}
//-------------------------------------------------------------
private CResultAErreur AppliqueFormule()
{
CResultAErreur result = CResultAErreur.True;
C2iExpression formule = m_txtFormule.Formule;
if (formule == null)
{
result = m_txtFormule.ResultAnalyse;
return(result);
}
CContexteDonnee ctxOriginal = m_listeObjetsAAppliquer[0].ContexteDonnee;
try
{
if (m_contexteModification != null)
{
m_contexteModification.Dispose();
m_contexteModification = null;
}
m_contexteModification = ctxOriginal.GetContexteEdition();
foreach (CObjetDonnee objet in m_listeObjetsAAppliquer)
{
if (objet != null)
{
CObjetDonnee objetModif = objet.GetObjetInContexte(m_contexteModification);
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(objetModif);
result = formule.Eval(ctx);
if (!result)
{
result.EmpileErreur(I.T("Error while applying formula on @1|20093", objetModif.DescriptionElement));
return(result);
}
else
{
m_txtResult.Text += "-----------------------------------";
m_txtResult.Text += Environment.NewLine;
m_txtResult.Text += objetModif.DescriptionElement + "->";
m_txtResult.Text += result.Data != null?result.Data.ToString() : "NULL";
m_txtResult.Text += Environment.NewLine;
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//------------------------------------------
public void RecalcLibelle()
{
C2iExpression formule = TypeEntiteSnmp.FormuleCalculLibelle;
if (formule != null)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(this);
CResultAErreur result = formule.Eval(ctx);
if (result && result.Data != null)
{
Libelle = result.Data.ToString();
}
}
}
