/// ///////////////////////////////////////////////////
public override CResultAErreur GetComposantExpression(CFiltreDynamique filtre)
{
CResultAErreur result = CResultAErreur.True;
C2iExpression expressionPrec = null;
foreach (CComposantFiltreDynamique cp in ComposantsFils)
{
result = cp.GetComposantExpression(filtre);
if (result)
{
C2iExpression exp = result.Data as C2iExpression;
if (exp != null)
{
if (expressionPrec != null)
{
C2iExpression expLogique = GetExpressionOperateurLogique();
expLogique.Parametres.Add(expressionPrec);
expLogique.Parametres.Add(exp);
expressionPrec = expLogique;
}
else
{
expressionPrec = exp;
}
}
}
else
{
return(result);
}
}
result.Data = expressionPrec;
return(result);
}
//-----------------------------------------------------------------
protected override CResultAErreur MyMajChamps()
{
CResultAErreur result = base.MyMajChamps();
if (result)
{
CParametreDroitEditionType.CCoupleFormuleToGroupeRestrictions couple = CoupleEdite;
if (couple != null)
{
C2iExpression formule = m_txtFormule.Formule;
if (!m_txtFormule.ResultAnalyse)
{
result.EmpileErreur(result.Erreur);
}
else
{
couple.Formule = formule;
}
m_lblFormule.Text = formule != null?formule.GetString() : "";
couple.SetGroupeRestrictions(m_txtGroupe.ElementSelectionne as CGroupeRestrictionSurType);
if (result)
{
result = couple.VerifieDonnees();
}
}
}
return(result);
}
/// //////////////////////////////////////////
protected override sc2i.common.CResultAErreur MAJ_Champs()
{
CResultAErreur result = base.MAJ_Champs();
if (!(m_cmbAction.SelectedValue is string))
{
result.EmpileErreur(I.T("Select an action|30014"));
return(result);
}
ActionLancer.CodeAction = (string)m_cmbAction.SelectedValue;
ActionLancer.ResetFormules();
foreach (CFormuleForParametre formule in m_listeExpressions)
{
result = formule.UpdateFromEditeur();
if (result)
{
C2iExpression expression = formule.Formule;
if (expression != null)
{
ActionLancer.SetFormuleForParametre(formule.NomParametre, formule.Formule);
}
}
else
{
result.EmpileErreur(I.T("Error in the formula @1|30013", formule.NomConvivial));
return(result);
}
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.MySerialize(serializer);
if (!result)
{
return(result);
}
I2iSerializable objet = (I2iSerializable)m_formuleImprimanteClient;
result = serializer.TraiteObject(ref objet);
m_formuleImprimanteClient = (C2iExpression)objet;
objet = (I2iSerializable)m_formuleImprimanteServeur;
result = serializer.TraiteObject(ref objet);
m_formuleImprimanteServeur = (C2iExpression)objet;
return(result);
}
private void m_textBox_KeyPress(object sender, System.Windows.Forms.KeyPressEventArgs e)
{
m_formule = null;
if (m_bCancelNextKeyPress)
{
e.Handled = true;
}
else
{
if (ListBox.Visible)
{
if ((m_strSeparateurs + ".").IndexOf(e.KeyChar) >= 0)
{
//Le texte sélectionné ne doit pas contenir le caractère
if (ListBox.SelectedIndex >= 0 &&
ListBox.SelectedItem.ToString().IndexOf(e.KeyChar) < 0)
{
InsereFromListBox();
}
}
}
}
m_bCancelNextKeyPress = false;
//if (")}]".IndexOf(e.KeyChar) >= 0)
// ShowCouple(m_textBox.SelectionStart, e.KeyChar);
/*if ( e.KeyChar == '.' && !ListBox.Visible )
* ShowListBox ( m_textBox.SelectionStart );*/
}
/// //////////////////////////////////////////
protected override sc2i.common.CResultAErreur MAJ_Champs()
{
CResultAErreur result = base.MAJ_Champs();
ActionCreerEntite.TypeEntiteACreer = (Type)m_cmbTypeEntite.SelectedValue;
if (ActionCreerEntite.TypeEntiteACreer == typeof(DBNull))
{
ActionCreerEntite.TypeEntiteACreer = null;
}
ActionCreerEntite.ResetFormules();
foreach (CFormuleForPropriete formule in m_listeExpressions)
{
result = formule.UpdateFromEditeur();
if (result)
{
C2iExpression expression = formule.Formule;
if (expression != null)
{
ActionCreerEntite.SetFormuleForPropriete(formule.NomPropriete, formule.Formule);
}
}
else
{
result.EmpileErreur(I.T("Error in the formula of @1|30041", formule.NomConvivial));
return(result);
}
}
return(result);
}
//------------------------------------------------------------
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 static void SetFormule(int nIdSession, string strKey, C2iExpression formule)
{
AssureRecepteurNotifications(nIdSession);
CDataBaseRegistrePourClient reg = new CDataBaseRegistrePourClient(nIdSession);
if (formule == null)
{
reg.SetValeurBlob("GLOBFOR_" + strKey, null);
}
else
{
MemoryStream stream = new MemoryStream();
BinaryWriter writer = new BinaryWriter(stream);
CSerializerSaveBinaire ser = new CSerializerSaveBinaire(writer);
CResultAErreur res = ser.TraiteObject <C2iExpression>(ref formule);
if (res)
{
reg.SetValeurBlob("GLOBFOR_" + strKey, stream.GetBuffer());
CDonneeNotificationResetCacheDatabaseRegistre notif = new CDonneeNotificationResetCacheDatabaseRegistre(nIdSession);
CEnvoyeurNotification.EnvoieNotifications(new IDonneeNotification[] { notif });
}
writer.Close();
stream.Close();
stream.Dispose();
}
}
///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 MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
if (result)
{
result = base.MySerialize(serializer);
}
serializer.TraiteString(ref m_strFormatAffichage);
I2iSerializable objet = m_expression;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_expression = (C2iExpression)objet;
// Ajout des propriétés pour le web
if (nVersion >= 1)
{
serializer.TraiteString(ref m_strLibelleWeb);
serializer.TraiteInt(ref m_nNumOrdreWeb);
}
return(result);
}
//--------------------------------------------------------------------------
public static C2iExpression GetFormule(int nIdSession, string strKey)
{
AssureRecepteurNotifications(nIdSession);
C2iExpression formule = null;
if (m_cacheFormule.TryGetValue(strKey, out formule))
{
return(formule);
}
CDataBaseRegistrePourClient reg = new CDataBaseRegistrePourClient(nIdSession);
byte[] bts = reg.GetValeurBlob("GLOBFOR_" + strKey);
if (bts != null)
{
MemoryStream stream = new MemoryStream(bts);
BinaryReader reader = new BinaryReader(stream);
CSerializerReadBinaire ser = new CSerializerReadBinaire(reader);
CResultAErreur result = ser.TraiteObject <C2iExpression>(ref formule);
if (result)
{
m_cacheFormule[strKey] = formule;
}
reader.Close();
stream.Close();
stream.Dispose();
}
return(formule);
}
private CResultAErreur MajChamps()
{
CResultAErreur result = CResultAErreur.True;
if (m_parametre == null)
{
m_parametre = new CParametreRemplissageActiviteParIntervention();
}
m_parametre.ListeRemplissage.Clear();
foreach (CFormuleForParametre formule in m_listeExpressions)
{
result = formule.UpdateFromEditeur();
if (result)
{
C2iExpression expression = formule.Formule;
if (expression != null)
{
CRemplisssageChampActiviteActeur remplissage = new CRemplisssageChampActiviteActeur();
remplissage.IdChampCustom = formule.ChampCustom.Id;
remplissage.Formule = formule.Formule;
m_parametre.ListeRemplissage.Add(remplissage);
}
}
else
{
result.EmpileErreur(I.T("Error in the formula of @1|30192", formule.ChampCustom.Nom));
return(result);
}
}
return(result);
}
/// //////////////////////////////////////////////////////////////
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 C2iExpression GetFormuleFor(CDefinitionProprieteDynamique definition)
{
C2iExpression formule = null;
m_dicAffectations.TryGetValue(definition, out formule);
return(formule);
}
public void AddProprietesAccedees(
CArbreDefinitionsDynamiques arbre,
Type typeSource,
string strPropriete)
{
//TESTDBKEYOK
CDbKey key = CDbKey.CreateFromStringValue(strPropriete);
/*int nIdChamp = -1;
* try
* {
* nIdChamp = Int32.Parse ( strPropriete );
* }
* catch
* {
* }*/
CChampCalcule champCalcule = new CChampCalcule(CContexteDonneeSysteme.GetInstance());
C2iExpression formule = null;
if (champCalcule.ReadIfExists(key))
{
formule = champCalcule.Formule;
formule.GetArbreProprietesAccedees(arbre);
CDefinitionProprieteDynamiqueChampCalcule.DetailleSousArbres(arbre, CContexteDonneeSysteme.GetInstance());
}
}
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
if (result)
{
result = base.MySerialize(serializer);
}
serializer.TraiteString(ref m_strFormatAffichage);
I2iSerializable objet = m_expression;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_expression = (C2iExpression)objet;
return(result);
}
/// ////////////////////////////////////////////////////////////////////////////
private void m_btnOk_Click(object sender, System.EventArgs e)
{
if (m_champ == null)
{
CFormAlerte.Afficher(I.T("Select a field to test|30014"), EFormAlerteType.Exclamation);
return;
}
CContexteAnalyse2iExpression ctx = new CContexteAnalyse2iExpression(m_filtre, typeof(CFiltreDynamique));
CAnalyseurSyntaxiqueExpression analyseur = new CAnalyseurSyntaxiqueExpression(ctx);
CResultAErreur result = analyseur.AnalyseChaine(m_txtCondition.Text);
if (!result)
{
result.EmpileErreur(I.T("Error in condition formula|30016"));
CFormAlerte.Afficher(result);
return;
}
C2iExpression expressionCondition = (C2iExpression)result.Data;
m_composant.Champ = m_champ;
m_composant.ConditionApplication = expressionCondition;
m_composant.TestNull = m_btnEstNull.Checked;
DialogResult = DialogResult.OK;
Close();
}
public static C2iExpression EditeFormule(string strFormule,
IFournisseurProprietesDynamiques fournisseur,
CObjetPourSousProprietes objetAnalyse)
{
CFormStdEditeFormule form = new CFormStdEditeFormule();
form.m_strFormule = strFormule;
form.m_objetAnalyse = objetAnalyse;
form.m_fournisseur = fournisseur;
C2iExpression formule = null;
if (form.ShowDialog() == DialogResult.OK)
{
formule = form.m_txtFormule.Formule;
}
else
{
CContexteAnalyse2iExpression ctx = new CContexteAnalyse2iExpression(fournisseur, objetAnalyse);
CResultAErreur result = new CAnalyseurSyntaxiqueExpression(ctx).AnalyseChaine(strFormule);
if (result)
{
formule = result.Data as C2iExpression;
}
}
form.Dispose();
return(formule);
}
////////////////////////////////////////////
private void OnChangeExpression(string strTexte, ref C2iExpression expToSet, CComboboxAutoFilled combo)
{
CContexteAnalyse2iExpression ctx = new CContexteAnalyse2iExpression(ActionSynchronisme.Process, typeof(CProcess));
CResultAErreur result = new CAnalyseurSyntaxiqueExpression(ctx).AnalyseChaine(strTexte);
if (result)
{
ArrayList lstChamps = new ArrayList();
expToSet = (C2iExpression)result.Data;
Type tp = expToSet.TypeDonnee.TypeDotNetNatif;
CStructureTable structure = null;
try
{
structure = CStructureTable.GetStructure(tp);
ArrayList lst = new ArrayList();
foreach (CInfoChampTable champ in structure.Champs)
{
if (champ.TypeDonnee == typeof(DateTime) || champ.TypeDonnee == typeof(DateTime?))
{
lst.Add(champ);
}
}
//Cherche les champs custom
if (typeof(CElementAChamp).IsAssignableFrom(tp))
{
//Crée les infos champ custom pour le type
using (CContexteDonnee contexte = new CContexteDonnee(
CSessionClient.GetSessionUnique().IdSession,
true, false))
{
string strCodeRole = CRoleChampCustom.GetRoleForType(tp).CodeRole;
CListeObjetsDonnees listeChamps = CChampCustom.GetListeChampsForRole(
contexte, strCodeRole);
new CListeObjetsDonnees(contexte, typeof(CChampCustom));
listeChamps.Filtre = new CFiltreData(
CChampCustom.c_champType + "=@1",
(int)TypeDonnee.tDate);
foreach (CChampCustom champ in listeChamps)
{
CInfoChampTable info = new CInfoChampTable(
CSynchronismeDonnees.c_idChampCustom + champ.Id.ToString(),
typeof(DateTime),
0,
false,
false,
true,
false,
true);
info.NomConvivial = champ.Nom;
lst.Add(info);
}
}
}
combo.ListDonnees = lst;
}
catch
{
}
}
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.MySerialize(serializer);
if (result)
{
I2iSerializable tmp = m_formuleTableAImporter;
result = serializer.TraiteObject(ref tmp);
m_formuleTableAImporter = (C2iExpression)tmp;
}
if (result)
{
I2iSerializable tmp = m_formuleFichierSource;
result = serializer.TraiteObject(ref tmp);
m_formuleFichierSource = (C2iExpression)tmp;
}
int nTmp = (int)m_modeImport;
serializer.TraiteInt(ref nTmp);
m_modeImport = (EImportTableParametrableMode)nTmp;
return(result);
}
/// /////////////////////////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
CResultAErreur result = CResultAErreur.True;
int nVersion = GetNumVersion();
result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.MySerialize(serializer);
if (!result)
{
return(result);
}
I2iSerializable objet = m_formuleMessage;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_formuleMessage = (C2iExpression)objet;
result = serializer.TraiteArrayListOf2iSerializable(m_listeFormulesDestinataires);
if (!result)
{
return(result);
}
return(result);
}
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);
}
/// //////////////////////////////////////////
private void OnChangeVariable()
{
CResultAErreur result = CResultAErreur.True;
if (m_variableEnCoursEdition != null)
{
if (m_txtFormuleVariable.Text.Trim() != "")
{
result = GetFormule(m_txtFormuleVariable);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
m_tableIdVariableToFormule[m_variableEnCoursEdition.IdVariable] = result.Data;
}
else
{
m_tableIdVariableToFormule[m_variableEnCoursEdition.IdVariable] = null;
}
}
if (m_wndListeVariables.SelectedItems.Count != 1)
{
m_variableEnCoursEdition = null;
m_txtFormuleVariable.Visible = true;
return;
}
m_variableEnCoursEdition = (IVariableDynamique)m_wndListeVariables.SelectedItems[0].Tag;
m_lblNomVariable.Text = m_variableEnCoursEdition.Nom;
C2iExpression expression = (C2iExpression)m_tableIdVariableToFormule[m_variableEnCoursEdition.IdVariable];
m_txtFormuleVariable.Text = expression == null?"":expression.GetString();
}
/// //////////////////////////////////////////////////////
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);
}
}
public CResultAErreur Init(
Type typeObjets,
string strProprieteListeFils,
string strChampParent,
string strProprieteAffichee,
CFiltreData filtre,
CFiltreData filtreRacine)
{
m_typeObjets = typeObjets;
m_strProprieteListeFils = strProprieteListeFils;
m_strChampParent = strChampParent;
m_strDefProprieteAffichee = strProprieteAffichee;
string[] strProp = strProprieteAffichee.Split('|');
m_strProprieteAffichee = strProp[0];
if (strProp.Length > 1 && CFormulesGlobaleParametrage.GetDefinition(strProp[1]) != null)
{
m_formuleLibelle = CFormulesGlobaleParametrage.GetFormule(CSc2iWin32DataClient.ContexteCourant.IdSession, strProp[1]);
}
m_filtre = filtre;
m_filtreRacine = filtreRacine;
//Force la réinitialisation des controles
LockEdition = m_bIsLock;
return(CResultAErreur.True);
}
public CResultAErreurType <CParametresInitialisationEtape> MajChamps()
{
CParametresInitialisationEtape parametre = new CParametresInitialisationEtape();
CResultAErreurType <CParametresInitialisationEtape> result = new CResultAErreurType <CParametresInitialisationEtape>();
foreach (CFormuleNommee formuleNommée in m_panelFormules.GetFormules())
{
if (formuleNommée.Formule == null) //|| !typeof(IAffectableAEtape).IsAssignableFrom(formuleNommée.Formule.TypeDonnee.TypeDotNetNatif))
{
result.EmpileErreur(I.T("Formula @1 is invalid (should return an object that can be assigned to a step)|20066",
formuleNommée.Libelle));
}
}
C2iExpression formule = m_txtFormuleInitialisation.Formule;
if (formule == null && !m_txtFormuleInitialisation.ResultAnalyse)
{
result.EmpileErreur(m_txtFormuleInitialisation.ResultAnalyse.Erreur);
}
if (formule != null)
{
parametre.FormuleInitialisation = formule;
}
if (result)
{
parametre.Affectations.Formules = m_panelFormules.GetFormules();
result.DataType = parametre;
}
parametre.RecalculerAffectationsSurRedemarrage = m_chkRecalculerAffectations.Checked;
parametre.ReevaluerInitialisationSurRedemarrage = m_chkReevaluerFormuleSurRedemarrage.Checked;
return(result);
}
/// //////////////////////////////////////////////////
public override CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
I2iSerializable obj = m_champ;
serializer.TraiteObject(ref obj);
m_champ = (CDefinitionProprieteDynamique)obj;
obj = m_expressionValeur;
result = serializer.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_expressionValeur = (C2iExpression)obj;
obj = m_expressionConditionApplication;
result = serializer.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_expressionConditionApplication = (C2iExpression )obj;
return(result);
}
/// //////////////////////////////////////////
protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
{
CResultAErreur result = CResultAErreur.True;
try
{
C2iExpression[] parametresFiltre = new C2iExpression[Parametres.Count - 2];
for (int nIndex = 2; nIndex < Parametres.Count; nIndex++)
{
parametresFiltre[nIndex - 2] = Parametres2i[nIndex];
}
result = GetFiltre(ctx, Parametres2i[0], Parametres2i[1], parametresFiltre);
if (!result)
{
return(result);
}
if (!(ctx.ObjetSource is CObjetDonnee))
{
result.EmpileErreur(I.T("SelectSql cannot be applied here|229"));
return(result);
}
CFiltreDataAvance filtre = (CFiltreDataAvance)result.Data;
CListeObjetsDonnees liste = new CListeObjetsDonnees(((CObjetDonnee)ctx.ObjetSource).ContexteDonnee,
CContexteDonnee.GetTypeForTable(filtre.TablePrincipale));
liste.Filtre = filtre;
result.Data = liste;
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error in SelectSql|228"));
}
return(result);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MySerialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.MySerialize(serializer);
if (!result)
{
return(result);
}
I2iSerializable objet = m_expressionCondition;
result = serializer.TraiteObject(ref objet);
if (!result)
{
result.EmpileErreur(I.T("Serialisation error in the condition formula|132"));
return(result);
}
m_expressionCondition = (C2iExpression)objet;
return(result);
}
//----------------------------------
private C2iExpression GetFormuleValeur(object valeur)
{
C2iExpression formule = null;
if (valeur is CObjetDonneeAIdNumerique)
{
formule = new C2iExpressionGetEntite();
formule.Parametres.Add(new C2iExpressionConstante(valeur.GetType().ToString()));
formule.Parametres.Add(new C2iExpressionConstante(((CObjetDonneeAIdNumerique)valeur).Id));
}
else if (valeur == null)
{
formule = new C2iExpressionNull();
}
else
{
if (valeur is CDateTimeEx)
{
valeur = ((CDateTimeEx)valeur).DateTimeValue;
}
if (C2iExpressionConstante.CanManage(valeur))
{
formule = new C2iExpressionConstante(valeur);
}
}
return(formule);
}
