/// ///////////////////////////////////////////
public override CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.Serialize(serializer);
if (!result)
{
return(result);
}
I2iSerializable objet = (I2iSerializable)m_filtreDynamique;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_filtreDynamique = (CFiltreDynamique)objet;
return(result);
}
/// //////////////////////////////////////////////////
public override CResultAErreur GetComposantExpression(CFiltreDynamique filtreDynamique)
{
CResultAErreur result = CResultAErreur.True;
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(filtreDynamique);
if (ConditionApplication != null)
{
result = ConditionApplication.Eval(ctx);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluation of @1|143", ConditionApplication.GetString()));
return(result);
}
if (!((result.Data is bool && (bool)result.Data) || result.Data.ToString() == "1"))
{
result.Data = null;
return(result);
}
}
C2iExpressionChamp expChamp = new C2iExpressionChamp(m_champ);
C2iExpression expressionIsNull = new C2iExpressionEstNull();
expressionIsNull.Parametres.Add(expChamp);
result.Data = expressionIsNull;
if (!TestNull)
{
C2iExpression expNon = new C2iExpressionNon();
expNon.Parametres.Add(expressionIsNull);
result.Data = expNon;
}
return(result);
}
public CListeObjetsDonnees GetElementsLiesFor(Object obj)
{
if (obj == null)
{
return(null);
}
if (obj.GetType() != TypeElementsSourceRecherche)
{
return(null);
}
//Calcule le filtre
try
{
CFiltreDynamique filtreDyn = FiltreDynamique;
IElementAVariablesDynamiquesAvecContexteDonnee eltAVariables = GetElementAVariableSource(obj);
filtreDyn.ElementAVariablesExterne = eltAVariables;
if (filtreDyn != null)
{
CResultAErreur result = filtreDyn.GetFiltreData();
if (result && result.Data is CFiltreData)
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(ContexteDonnee, TypeElements, (CFiltreData)result.Data);
return(liste);
}
}
}
catch { }
return(null);
}
/// //////////////////////////////////////////////////
public override void OnChangeVariable(CFiltreDynamique filtre, CVariableDynamique variable)
{
foreach (CComposantFiltreDynamique composant in m_listeComposantsFils)
{
composant.OnChangeVariable(filtre, variable);
}
}
/// ///////////////////////////////////////////////////
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);
}
//---------------------------------------
private void InitFiltres()
{
CTypeDonneeCumulee typeDonnee = GetTypeDonneeCumulee(CContexteDonneeSysteme.GetInstance());
if (typeDonnee == null)
{
m_listeFiltresDeBase.Clear();
m_listeFiltresUser.Clear();
return;
}
CParametreDonneeCumulee parametre = typeDonnee.Parametre;
Dictionary <string, bool> dicToDelete = new Dictionary <string, bool>();
foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresDeBase)
{
dicToDelete[filtre.ChampAssocie] = true;
}
foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresUser)
{
dicToDelete[filtre.ChampAssocie] = true;
}
foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
{
if (cle.TypeLie != null)
{
CFiltreDonneePrecalculee filtre = m_listeFiltresDeBase.FirstOrDefault(f => f.ChampAssocie == cle.Champ);
if (filtre != null)
{
dicToDelete[filtre.ChampAssocie] = false;
}
if (m_listeFiltresDeBase.Count(f => f.ChampAssocie == cle.Champ) == 0)
{
CFiltreDynamique filtreTmp = new CFiltreDynamique();
filtreTmp.TypeElements = cle.TypeLie;
m_listeFiltresDeBase.Add(new CFiltreDonneePrecalculee(cle.Champ, cle.Champ, filtreTmp));
}
if (m_listeFiltresUser.Count(f => f.ChampAssocie == cle.Champ) == 0)
{
CFiltreDynamique filtreTmp = new CFiltreDynamique();
filtreTmp.TypeElements = cle.TypeLie;
m_listeFiltresUser.Add(new CFiltreDonneePrecalculee(cle.Champ, cle.Champ, filtreTmp));
}
}
}
foreach (KeyValuePair <string, bool> kv in dicToDelete)
{
if (kv.Value)
{
foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresUser.FindAll(f => f.ChampAssocie == kv.Key).ToArray())
{
m_listeFiltresUser.Remove(filtre);
}
foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresDeBase.FindAll(f => f.ChampAssocie == kv.Key).ToArray())
{
m_listeFiltresDeBase.Remove(filtre);
}
}
}
}
public CFiltreDonneePrecalculee(string strChampAssocie,
string strLibelle,
CFiltreDynamique filtre)
{
m_filtre = filtre;
m_strChampAssocie = strChampAssocie;
m_strLibelle = strLibelle;
}
/// ///////////////////////////////////////////////////
public override CResultAErreur GetComposantFiltreData(CFiltreDynamique filtre, CFiltreData filtreData)
{
CResultAErreur result = CResultAErreur.True;
try
{
if (m_listeComposantsFils.Count < 1)
{
return(result);
}
result = ((CComposantFiltreDynamique)m_listeComposantsFils[0]).GetComposantFiltreData(filtre, filtreData);
if (!result)
{
result.EmpileErreur(I.T("Error in element @1|136", ((CComposantFiltreDynamique)m_listeComposantsFils[0]).Description));
result.Data = null;
return(result);
}
CComposantFiltre composantAvant = (CComposantFiltre)result.Data;
for (int nComposant = 1; nComposant < m_listeComposantsFils.Count; nComposant++)
{
CComposantFiltreDynamique composantDynamique = (CComposantFiltreDynamique)m_listeComposantsFils[nComposant];
result = composantDynamique.GetComposantFiltreData(filtre, filtreData);
if (!result)
{
result.EmpileErreur(I.T("Error in element @1|136", ((CComposantFiltreDynamique)m_listeComposantsFils[nComposant]).Description));
result.Data = null;
return(result);
}
if (result.Data != null)
{
if (composantAvant != null)
{
CComposantFiltreOperateur parenthesesNew = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurParentheses);
CComposantFiltreOperateur parenthesesOld = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurParentheses);
parenthesesNew.Parametres.Add(result.Data);
parenthesesOld.Parametres.Add(composantAvant);
CComposantFiltreOperateur operateur = new CComposantFiltreOperateur(GetIdComposantFiltreOperateur());
operateur.Parametres.Add(parenthesesOld);
operateur.Parametres.Add(parenthesesNew);
composantAvant = operateur;
}
else
{
composantAvant = (CComposantFiltre)result.Data;
}
}
}
result.Data = composantAvant;
return(result);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
}
//----------------------------------------------------------------------------------
public CResultAErreur Serialize(C2iSerializer serialiser)
{
int nVersion = GetNumVersion();
CResultAErreur result = serialiser.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serialiser.TraiteString(ref m_strNomTable);
I2iSerializable obj = ChampOrigine;
result = serialiser.TraiteObject(ref obj);
if (!result)
{
return(result);
}
ChampOrigine = (CDefinitionProprieteDynamique)obj;
obj = m_requete;
result = serialiser.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_requete = (C2iRequeteAvancee)obj;
if (m_requete == null)
{
m_requete = new C2iRequeteAvancee(null);
}
obj = m_filtreAAppliquer;
result = serialiser.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_filtreAAppliquer = (CFiltreDynamique)obj;
if (nVersion >= 1)
{
obj = m_tableauCroise;
result = serialiser.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_tableauCroise = (CTableauCroise)obj;
}
if (nVersion >= 2)
{
serialiser.TraiteBool(ref m_bNePasCalculer);
}
return(result);
}
/// //////////////////////////////////////////////////
public override CResultAErreur VerifieIntegrite(CFiltreDynamique filtre)
{
CResultAErreur result = CResultAErreur.True;
if (m_champTeste == null)
{
result.EmpileErreur(I.T("Field not defined|144"));
}
return(result);
}
////////////////////////////////////////////////////////////////////////
public static CFiltreDynamique GetFiltreDynamiqueSynchro(Type type)
{
CFiltreDynamique filtre = new CFiltreDynamique();
filtre.TypeElements = type;
CVariableDynamiqueListeTypeSimple variable = new CVariableDynamiqueListeTypeSimple(filtre);
variable.TypeDonnee2i = new C2iTypeDonnee(TypeDonnee.tEntier);
variable.Nom = c_nomVariableListeUtilisateurs;
filtre.AddVariable(variable);
return(filtre);
}
////////////////////////////////////////////////////////////////////////
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strNomTable);
I2iSerializable objet = m_filtreDynamique;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_filtreDynamique = (CFiltreDynamique)objet;
objet = m_relationToParent;
result = serializer.TraiteObject(ref objet);
if (!result)
{
return(result);
}
m_relationToParent = (CInfoRelation)objet;
serializer.TraiteBool(ref m_bTouteLaTable);
result = serializer.TraiteArrayListOf2iSerializable(m_listeFils);
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
NettoieFiltresFils();
foreach (CFiltreSynchronisation filtre in m_listeFils)
{
filtre.DefinitParent(this, filtre.RelationToParent);
}
}
if (nVersion >= 1)
{
serializer.TraiteBool(ref m_bIsAutoAdd);
}
return(result);
}
////////////////////////////////////////////////////////////////////////
public CFiltreDynamique GetFiltreDynamiqueForTable(string strNomTable, ref bool bShouldSynchroniseTable)
{
ArrayList lst = (ArrayList)m_tableTableToFiltreSynchronisation[strNomTable];
Type tp = CContexteDonnee.GetTypeForTable(strNomTable);
if (tp != null && tp.GetCustomAttributes(typeof(FullTableSyncAttribute), true).Length > 0)
{
bShouldSynchroniseTable = true;
return(null);
}
if (lst == null || lst.Count == 0)
{
bShouldSynchroniseTable = false;
return(null);
}
bShouldSynchroniseTable = true;
CFiltreDynamique filtreDynamique = CFiltreSynchronisation.GetFiltreDynamiqueSynchro(CContexteDonnee.GetTypeForTable(strNomTable));
CComposantFiltreDynamiqueOu composantOu = new CComposantFiltreDynamiqueOu();
foreach (CFiltreSynchronisation filtreSynchro in lst)
{
if (filtreSynchro.TouteLaTable || filtreSynchro.FiltreDynamique == null)
{
return(null);
}
CFiltreDynamique filtreLocal = filtreSynchro.GetFiltreToElementPrincipal();
if (filtreLocal != null && filtreLocal.ComposantPrincipal != null)
{
composantOu.AddComposantFils(filtreLocal.ComposantPrincipal);
}
if (filtreLocal == null)
{
return(null);
}
}
if (composantOu.GetNbComposantsFils() == 0)
{
return(null);
}
if (composantOu.GetNbComposantsFils() == 1)
{
filtreDynamique.ComposantPrincipal = composantOu.ComposantsFils[0];
}
else
{
filtreDynamique.ComposantPrincipal = composantOu;
}
return(filtreDynamique);
}
//----------------------------------------------------------------------------------
public object Clone()
{
/*CStringSerializer serializer = new CStringSerializer(ModeSerialisation.Ecriture);
* Serialize ( serializer );
* string strData = serializer.String;
*
* serializer = new CStringSerializer ( strData, ModeSerialisation.Lecture );
* filtreCopie.Serialize ( serializer );
* return filtreCopie;*/
CFiltreDynamique filtreCopie = new CFiltreDynamique(m_elementAVariablesExterne, ContexteDonnee);
C2iSerializer.CloneTo(this, filtreCopie);
return(filtreCopie);
}
/// //////////////////////////////////////////////////
public override CResultAErreur VerifieIntegrite(CFiltreDynamique filtre)
{
CResultAErreur result = CResultAErreur.True;
if (m_champ == null)
{
result.EmpileErreur(I.T("Field not defined|144"));
}
if (m_strIdOperateur == null)
{
result.EmpileErreur(I.T("Operator not defined|158"));
}
if (m_champValeur is CDefinitionProprieteDynamiqueChampCustom &&
m_champ is CDefinitionProprieteDynamiqueChampCustom)
{
result.EmpileErreur(I.T("Test function not supported : Custom field = Custom field|159"));
return(result);
}
if (ExpressionValeur == null && m_champValeur == null)
{
result.EmpileErreur(I.T("Value formula is incorrect|145"));
}
else if (ExpressionValeur != null)
{
ArrayList lstChamps = ExpressionValeur.ExtractExpressionsType(typeof(C2iExpressionChamp));
foreach (C2iExpressionChamp expChamp in lstChamps)
{
CDefinitionProprieteDynamique def = expChamp.DefinitionPropriete;
if (def == null)
{
result.EmpileErreur(I.T("Null field in value formula|160"));
}
else
{
if (def is CDefinitionProprieteDynamiqueVariableDynamique)
{
CDefinitionProprieteDynamiqueVariableDynamique defVar = (CDefinitionProprieteDynamiqueVariableDynamique)def;
CVariableDynamique variable = filtre.GetVariable(defVar.IdChamp);
if (variable == null)
{
result.EmpileErreur(I.T("The variable @1 doesn't exist|147", defVar.Nom));
}
}
}
}
}
return(result);
}
/// //////////////////////////////////////////////////
public override CResultAErreur VerifieIntegrite(CFiltreDynamique filtre)
{
CResultAErreur result = CResultAErreur.True;
if (m_champ == null)
{
result.EmpileErreur(I.T("Field not defined|144"));
}
else if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(m_champ.TypeDonnee.TypeDotNetNatif))
{
result.EmpileErreur(I.T("Cannot apply static selection on field @1|151", m_champ.Nom));
}
return(result);
}
/// ///////////////////////////////////////////////
public override CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.Serialize(serializer);
I2iSerializable obj = m_expressionAffichee;
result = serializer.TraiteObject(ref obj);
m_expressionAffichee = (C2iExpression)obj;
obj = m_expressionRetournee;
result = serializer.TraiteObject(ref obj);
m_expressionRetournee = (C2iExpression)obj;
obj = m_filtreSelection;
result = serializer.TraiteObject(ref obj);
m_filtreSelection = (CFiltreDynamique)obj;
if (nVersion > 0)
{
serializer.TraiteBool(ref m_bCanBeNull);
serializer.TraiteString(ref m_strTextNull);
}
else
{
m_bCanBeNull = false;
m_strTextNull = "";
}
if (nVersion >= 2)
{
serializer.TraiteBool(ref m_bRechercheRapide);
}
else
{
m_bRechercheRapide = false;
}
return(result);
}
/// //////////////////////////////////////////////////
protected void OnChangeVariable(CFiltreDynamique filtre, C2iExpression expression, CVariableDynamique variable)
{
if (expression == null)
{
return;
}
foreach (C2iExpressionChamp exp in expression.ExtractExpressionsType(typeof(C2iExpressionChamp)))
{
if (exp.DefinitionPropriete is CDefinitionProprieteDynamiqueVariableDynamique)
{
CDefinitionProprieteDynamiqueVariableDynamique def = (CDefinitionProprieteDynamiqueVariableDynamique)exp.DefinitionPropriete;
if (def.IdChamp == variable.IdVariable)
{
def = new CDefinitionProprieteDynamiqueVariableDynamique(variable);
exp.DefinitionPropriete = def;
}
}
}
}
/// /////////////////////////////////////////////////////////////////////////
public override CResultAErreur VerifieIntegrite(CFiltreDynamique filtre)
{
CResultAErreur result = CResultAErreur.True;
if (m_listeComposantsFils.Count == 0)
{
result.EmpileErreur(I.T("The component @1 has no sub-component|138", Description));
return(result);
}
foreach (CComposantFiltreDynamique composant in m_listeComposantsFils)
{
CResultAErreur resultTmp = composant.VerifieIntegrite(filtre);
if (!resultTmp)
{
result.Erreur.EmpileErreurs(resultTmp.Erreur);
result.EmpileErreur(I.T("Error in component '@1'|137", composant.Description));
}
}
return(result);
}
/// /////////////////////////////////////////
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
I2iSerializable objet = m_structure;
result = serializer.TraiteObject(ref objet);
m_structure = (C2iStructureExport)objet;
objet = m_filtre;
result = serializer.TraiteObject(ref objet);
m_filtre = (CFiltreDynamique)objet;
return(result);
}
//----------------------------------------------------------------------------------
public override CResultAErreur Serialize(C2iSerializer serialiser)
{
int nVersion = GetNumVersion();
CResultAErreur result = serialiser.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
if (nVersion < 4)
{
return(SerializeAvantC2iTableExportATableFille(serialiser, nVersion));
}
result = base.Serialize(serialiser);
if (!result)
{
return(result);
}
I2iSerializable obj = ChampOrigine;
result = serialiser.TraiteObject(ref obj);
if (!result)
{
return(result);
}
ChampOrigine = (CDefinitionProprieteDynamique)obj;
result = serialiser.TraiteListe <C2iChampExport>(m_listeChamps);
if (!result)
{
return(result);
}
obj = m_filtreAAppliquer;
result = serialiser.TraiteObject(ref obj);
m_filtreAAppliquer = (CFiltreDynamique)obj;
return(result);
}
/// /////////////////////////////////////////////////////////////
public CFiltreData GetFiltrePourListe()
{
CFiltreData filtre = new CFiltreData();
if (IsDynamique)
{
CFiltreDynamique filtreDyn = FiltreDynamique;
CResultAErreur result = filtreDyn.GetFiltreData();
if (result.Data is CFiltreData)
{
filtre = (CFiltreData)result.Data;
}
}
else
{
string strChampId = "";
StringBuilder bl = new StringBuilder();
CStructureTable structure = CStructureTable.GetStructure(TypeElements);
strChampId = structure.ChampsId[0].NomChamp;
foreach (CRelationListeEntites_Entite rel in RelationsEntites)
{
bl.Append(rel.IdElement);
bl.Append(',');
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
}
if (bl.Length > 0)
{
filtre = new CFiltreData(strChampId + " in (" + bl.ToString() + ")");
}
else
{
filtre = new CFiltreDataImpossible();
}
}
return(filtre);
}
/// //////////////////////////////////////////////////
public override CResultAErreur GetComposantExpression(CFiltreDynamique filtre)
{
CResultAErreur result = CResultAErreur.False;
return(result);
}
/// //////////////////////////////////////////////////
public override void OnChangeVariable(CFiltreDynamique filtre, CVariableDynamique variable)
{
OnChangeVariable(filtre, m_expressionValeur, variable);
OnChangeVariable(filtre, m_expressionConditionApplication, variable);
}
/// //////////////////////////////////////////////////
public override CResultAErreur GetComposantFiltreData(CFiltreDynamique filtre, CFiltreData filtreData)
{
CResultAErreur result = CResultAErreur.True;
//Vérifie que l'expression condition est OK
CContexteEvaluationExpression contexteEvaluation = new CContexteEvaluationExpression(filtre);
result = ConditionApplication.Eval(contexteEvaluation);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluation of @1|143", ConditionApplication.GetString()));
return(result);
}
if (result.Data == null || !((result.Data is bool && (bool)result.Data) || result.Data.ToString() == "1"))
{
result.Data = null;
return(result);
}
CComposantFiltreOperateur opPrincipal = null;
string strNomChamp = m_champ.NomPropriete;
if (m_champ is CDefinitionProprieteDynamiqueChampCustom)
{
CDbKey keyChamp = ((CDefinitionProprieteDynamiqueChampCustom)m_champ).DbKeyChamp;
strNomChamp = m_champ.NomPropriete;
string strAcces = "";
//Trouve le nom du champ et le chemin d'accès
int nPos = strNomChamp.LastIndexOf(".");
if (nPos != -1)
{
strAcces = strNomChamp.Substring(0, nPos + 1);
strNomChamp = strNomChamp.Substring(nPos + 1);
}
strAcces += "RelationsChampsCustom.";
CComposantFiltreOperateur operateurIdChamp = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEgal);
// TESTDBKEYOK
if (keyChamp.IsNumericalId())
{
operateurIdChamp.Parametres.Add(new CComposantFiltreChamp(strAcces + CChampCustom.c_champId, CContexteDonnee.GetNomTableForType(filtre.TypeElements)));
}
else
{
operateurIdChamp.Parametres.Add(new CComposantFiltreChamp(strAcces + CObjetDonnee.c_champIdUniversel, CContexteDonnee.GetNomTableForType(filtre.TypeElements)));
}
operateurIdChamp.Parametres.Add(new CComposantFiltreConstante(keyChamp.GetValeurInDb()));
opPrincipal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
opPrincipal.Parametres.Add(operateurIdChamp);
Type typeChamp = m_champ.TypeDonnee.TypeDotNetNatif;
if (typeChamp == typeof(double))
{
strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurDouble;
}
else if (typeChamp == typeof(int))
{
strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurInt;
}
else if (typeChamp == typeof(DateTime) || typeChamp == typeof(CDateTimeEx))
{
strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurDate;
}
else if (typeChamp == typeof(bool))
{
strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurBool;
}
else
{
strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurString;
}
strNomChamp = strAcces + strNomChamp;
}
CComposantFiltreChamp composantChamp = new CComposantFiltreChamp(strNomChamp, CContexteDonnee.GetNomTableForType(filtre.TypeElements));
CComposantFiltre composantRecherche = new CComposantFiltreRechercheAvancee();
CComposantFiltre composantValeur = null;
result = ExpressionValeur.Eval(contexteEvaluation);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluation of @1|143", ExpressionValeur.GetString()));
result.Data = null;
return(result);
}
composantValeur = new CComposantFiltreConstante(result.Data.ToString());
composantRecherche.Parametres.Add(composantChamp);
composantRecherche.Parametres.Add(composantValeur);
if (opPrincipal != null)
{
opPrincipal.Parametres.Add(composantRecherche);
composantRecherche = opPrincipal;
}
result.Data = composantRecherche;
return(result);
}
/// //////////////////////////////////////////////////
public override void OnChangeVariable(CFiltreDynamique filtre, CVariableDynamique variable)
{
}
/// //////////////////////////////////////////////////
public override CResultAErreur GetComposantFiltreData(CFiltreDynamique filtre, CFiltreData filtreData)
{
CResultAErreur result = CResultAErreur.True;
//Vérifie que l'expression condition est OK
CContexteEvaluationExpression contexteEvaluation = new CContexteEvaluationExpression(filtre);
result = ConditionApplication.Eval(contexteEvaluation);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluation of @1|143", ConditionApplication.GetString()));
return(result);
}
if (result.Data == null || !((result.Data is bool && (bool)result.Data) || result.Data.ToString() == "1"))
{
result.Data = null;
return(result);
}
string strNomChamp = m_champ.NomPropriete;
CDbKey dbKeyChampCustom = null;
if (m_champ is CDefinitionProprieteDynamiqueChampCustom)
{
CComposantFiltreOperateur opPrincipal = null;
dbKeyChampCustom = ((CDefinitionProprieteDynamiqueChampCustom)m_champ).DbKeyChamp;
strNomChamp = m_champ.NomPropriete;
string strAcces = "";
//Trouve le nom du champ et le chemin d'accès
int nPos = strNomChamp.LastIndexOf(".");
if (nPos != -1)
{
strAcces = strNomChamp.Substring(0, nPos + 1);
strNomChamp = strNomChamp.Substring(nPos + 1);
}
strAcces += "RelationsChampsCustom.";
int nIdChamp = CChampCustom.GetIdFromDbKey(dbKeyChampCustom);
CComposantFiltreOperateur operateurIdChamp = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEgal);
CComposantFiltreChamp compo1 = new CComposantFiltreChamp(strAcces + CChampCustom.c_champId, CContexteDonnee.GetNomTableForType(filtre.TypeElements));
compo1.IdChampCustom = nIdChamp;
operateurIdChamp.Parametres.Add(compo1);
operateurIdChamp.Parametres.Add(new CComposantFiltreConstante(nIdChamp));
opPrincipal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
opPrincipal.Parametres.Add(operateurIdChamp);
//Stef, 28072008 : pour tester si un champ est null, on vérifie CRelationElementAChamp_ChampCustom.c_champValeurNull
//et non pas les valeurs suivant le type
/*if ( typeChamp == typeof(double))
* strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurDouble;
* else if ( typeChamp == typeof(int))
* strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurInt;
* else if ( typeChamp == typeof(DateTime) || typeChamp == typeof(CDateTimeEx) )
* strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurDate;
* else if ( typeChamp == typeof(bool))
* strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurBool;
* else
* strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurString;
*/
strNomChamp = CRelationElementAChamp_ChampCustom.c_champValeurNull;
strNomChamp = strAcces + strNomChamp;
CComposantFiltreChamp composantChamp = new CComposantFiltreChamp(strNomChamp, CContexteDonnee.GetNomTableForType(filtre.TypeElements));
composantChamp.IdChampCustom = nIdChamp;
CComposantFiltre composantOperateur = new CComposantFiltreOperateur(
m_bTestNull ? CComposantFiltreOperateur.c_IdOperateurDifferent : CComposantFiltreOperateur.c_IdOperateurEgal);
composantOperateur.Parametres.Add(composantChamp);
composantOperateur.Parametres.Add(new CComposantFiltreConstante(0));
opPrincipal.Parametres.Add(composantOperateur);
composantOperateur = opPrincipal;
result.Data = composantOperateur;
//Stef 28072008, fin modif
}
else
{
CComposantFiltreChamp composantChamp = new CComposantFiltreChamp(strNomChamp, CContexteDonnee.GetNomTableForType(filtre.TypeElements));
composantChamp.IdChampCustom = CChampCustom.GetIdFromDbKey(dbKeyChampCustom);
CComposantFiltre composantOperateur;
if (!m_bTestNull)
{
composantOperateur = new CComposantFiltreHas();
}
else
{
composantOperateur = new CComposantFiltreHasNo();
}
composantOperateur.Parametres.Add(composantChamp);
result.Data = composantOperateur;
}
return(result);
}
////////////////////////////////////////////////////////////////////////
public void InitFiltreDynamique()
{
m_filtreDynamique = GetFiltreDynamiqueSynchro(CContexteDonnee.GetTypeForTable(NomTable));
}
////////////////////////////////////////////////////////////////////////
/// <summary>
/// Retourne un filtre dynamique pour la table associée en
/// prenant en compte les filtres des parents
/// </summary>
/// <returns></returns>
public CFiltreDynamique GetFiltreToElementPrincipal()
{
if (TouteLaTable)
{
return(null);
}
CFiltreDynamique filtreDynamiqueParent = null;
if (FiltreParent != null)
{
filtreDynamiqueParent = FiltreParent.GetFiltreToElementPrincipal();
}
Type typeElements = CContexteDonnee.GetTypeForTable(NomTable);
CStructureTable structure = CStructureTable.GetStructure(typeElements);
CFiltreDynamique filtreFinal = (CFiltreDynamique)FiltreDynamique.Clone();
CDefinitionProprieteDynamique defToParent = null;
//Trouve la propriété qui amène sur le parent
if (RelationToParent != null)
{
if (RelationToParent.TableFille == NomTable)
{
if (filtreDynamiqueParent != null && filtreDynamiqueParent.ComposantPrincipal != null)
{
Type tp = CContexteDonnee.GetTypeForTable(RelationToParent.TableParente);
string strNomConvivial = DynamicClassAttribute.GetNomConvivial(tp);
//Nous somme dans une relation fille
foreach (CInfoRelation relationParente in structure.RelationsParentes)
{
if (relationParente.RelationKey == RelationToParent.RelationKey)
{
defToParent = new CDefinitionProprieteDynamiqueDotNet(
strNomConvivial,
relationParente.Propriete,
new CTypeResultatExpression(CContexteDonnee.GetTypeForTable(relationParente.TableParente), false),
true,
true,
"");
break;
}
}
if (defToParent == null)
{
defToParent = new CDefinitionProprieteDynamique(
strNomConvivial,
RelationToParent.RelationKey,
new CTypeResultatExpression(tp, false),
true,
true,
"");
}
}
}
else
{
//Nous sommes dans une relation parente
foreach (CInfoRelation relationFille in structure.RelationsFilles)
{
if (relationFille.RelationKey == RelationToParent.RelationKey)
{
defToParent = new CDefinitionProprieteDynamiqueDotNet(
relationFille.NomConvivial,
relationFille.Propriete,
new CTypeResultatExpression(CContexteDonnee.GetTypeForTable(relationFille.TableFille), true),
true,
true,
"");
break;
}
}
if (defToParent == null)
{
Type tp = CContexteDonnee.GetTypeForTable(RelationToParent.TableFille);
defToParent = new CDefinitionProprieteDynamique(
DynamicClassAttribute.GetNomConvivial(tp) + "(" + RelationToParent.NomConvivial + ")",
RelationToParent.RelationKey,
new CTypeResultatExpression(tp, false),
true, true);
}
if (filtreDynamiqueParent == null)
{
filtreDynamiqueParent = new CFiltreDynamiqueParentTablePleine(NomTable, RelationToParent);
}
}
}
if (filtreDynamiqueParent != null && filtreDynamiqueParent.ComposantPrincipal != null)
{
filtreDynamiqueParent.ComposantPrincipal.InsereDefinitionToObjetFinal(defToParent);
if (FiltreDynamique == null || FiltreDynamique.ComposantPrincipal == null)
{
return(filtreDynamiqueParent);
}
CComposantFiltreDynamique composantEt = null;
if (!(filtreDynamiqueParent.ComposantPrincipal is CComposantFiltreDynamiqueEt))
{
composantEt = new CComposantFiltreDynamiqueEt();
composantEt.AddComposantFils(filtreDynamiqueParent.ComposantPrincipal);
}
else
{
composantEt = (CComposantFiltreDynamiqueEt)filtreDynamiqueParent.ComposantPrincipal;
}
composantEt.AddComposantFils(filtreFinal.ComposantPrincipal);
filtreFinal.ComposantPrincipal = composantEt;
}
if (filtreFinal.ComposantPrincipal == null)
{
return(null);
}
return(filtreFinal);
}
//----------------------------------------------------------------------------------
#region SerializeAvantC2iTableExportATableFille
private CResultAErreur SerializeAvantC2iTableExportATableFille(C2iSerializer serialiser, int nOldVersion)
{
CResultAErreur result = CResultAErreur.True;
if (serialiser.Mode == ModeSerialisation.Ecriture)
{
//Pas la peine de traduire, ça n'arrive jamais
result.EmpileErreur("Cannot write the old version of C2iTableExport");
return(result);
}
string strTmp = NomTable;
serialiser.TraiteString(ref strTmp);
NomTable = strTmp;
I2iSerializable obj = ChampOrigine;
result = serialiser.TraiteObject(ref obj);
if (!result)
{
return(result);
}
ChampOrigine = (CDefinitionProprieteDynamique)obj;
serialiser.AttacheObjet(typeof(ITableExport), this);
ArrayList lstTables = new ArrayList();
result = serialiser.TraiteArrayListOf2iSerializable(lstTables);
serialiser.DetacheObjet(typeof(ITableExport), this);
if (!result)
{
return(result);
}
ClearTablesFilles();
foreach (ITableExport table in lstTables)
{
AddTableFille(table);
}
ArrayList lstChamps = new ArrayList();
result = serialiser.TraiteArrayListOf2iSerializable(lstChamps);
if (!result)
{
return(result);
}
m_listeChamps.Clear();
foreach (C2iChampExport champ in lstChamps)
{
AddChamp(champ);
}
if (nOldVersion >= 1)
{
obj = m_filtreAAppliquer;
result = serialiser.TraiteObject(ref obj);
m_filtreAAppliquer = (CFiltreDynamique)obj;
}
return(result);
}