public override CComposantFiltre GetComposantFiltre(CComposantFiltreChamp champ)
{
CComposantFiltre gauche = null;
CComposantFiltre droite = null;
if (Parametres.Length > 0 && Parametres[0] != null)
{
gauche = Parametres[0].GetComposantFiltre(champ);
}
if (Parametres.Length > 1 && Parametres[1] != null)
{
droite = Parametres[1].GetComposantFiltre(champ);
}
if (gauche != null && droite != null)
{
CComposantFiltreOperateur op = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurOu);
op.Parametres.Add(gauche);
op.Parametres.Add(droite);
return(op);
}
if (gauche == null && droite != null)
{
return(droite);
}
if (gauche != null && droite == null)
{
return(gauche);
}
return(null);
}
////////////////////////////////////////////////////////////////////////////
public override CComposantFiltre GetComposantFiltre(CComposantFiltreChamp champ)
{
string strSeparateursMots = " ,;:!.?()-*+/\'";
string strTexte = MotUtilise;
//Remplace les caractères accentuables par leurs équivalents
strTexte = Regex.Replace(strTexte, "[éèêëe]", "[éèêëe]");
strTexte = Regex.Replace(strTexte, "[aàäâ]", "[aàäâ]");
strTexte = Regex.Replace(strTexte, "[iîï]", "[iîï]");
strTexte = Regex.Replace(strTexte, "[oôö]", "[oôö]");
strTexte = Regex.Replace(strTexte, "[uüûù]", "[uüûù]");
strTexte = Regex.Replace(strTexte, "[cç]", "[cç]");
CComposantFiltre ou = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurOu);
CComposantFiltre like = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurLike);
like.Parametres.Add(champ);
like.Parametres.Add(new CComposantFiltreConstante(strTexte + "%"));
ou.Parametres.Add(like);
like = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurLike);
like.Parametres.Add(champ);
like.Parametres.Add(new CComposantFiltreConstante("%[" + strSeparateursMots + "]" + strTexte + "%"));
ou.Parametres.Add(like);
return(ou);
}
//--------------------------------------------------------
public void InitComposant(CComposantFiltreChamp champTeste,
string strNomTableSousFiltre,
CComposantFiltreChamp champDeSousFiltre,
CFiltreDataAvance filtre)
{
m_champTeste = champTeste;
m_strTableSousFiltre = strNomTableSousFiltre;
m_champSousFiltre = champDeSousFiltre;
m_filtre = filtre;
m_bIsInterprete = true;
}
/// <summary>
/// Le data du result contient un CArbreTable
/// </summary>
/// <returns></returns>
public CResultAErreur CalculeArbre(CArbreTable arbre)
{
CResultAErreur result = CResultAErreur.True;
//Identifie les relations à mettre en jeu
ArrayList lstChamps = new ArrayList();
if (m_strTableInterrogee == "")
{
result.EmpileErreur(I.T("Request table is not defined|106"));
return(result);
}
if (arbre == null)
{
arbre = new CArbreTableParente(m_strTableInterrogee);
}
foreach (C2iChampDeRequete champ in ListeChamps)
{
try
{
foreach (CSourceDeChampDeRequete source in champ.Sources)
{
CComposantFiltreChamp composant = new CComposantFiltreChamp(source.Source, m_strTableInterrogee);
CArbreTable arbreEnCours = arbre;
foreach (CInfoRelationComposantFiltre relation in composant.Relations)
{
//Stef 08/08/2013 : toutes les relations sont integrées
//en leftouter : en effet, on doit prendre toutes les valeurs
//de la table source, même si elles n'ont pas de valeur liées dans la
//table fille
arbreEnCours = arbreEnCours.IntegreRelation(relation, true, composant.IdChampCustom);
if (arbreEnCours == null)
{
result.EmpileErreur(I.T("Itegration error of the relation @1|107", relation.RelationKey));
return(result);
}
}
source.ChampDeTable = composant.NomChamp;
source.Alias = arbreEnCours.Alias;
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error in field @1|108", champ.NomChamp));
return(result);
}
}
result.Data = arbre;
return(result);
}
public override CComposantFiltre GetComposantFiltre(CComposantFiltreChamp champ)
{
CComposantFiltre droite = null;
if (Parametres.Length > 0 && Parametres[0] != null)
{
droite = Parametres[0].GetComposantFiltre(champ);
}
if (droite != null)
{
CComposantFiltreOperateur op = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurNot);
op.Parametres.Add(droite);
return(op);
}
return(null);
}
/// ////////////////////////////////////////////////////////////////
private CResultAErreur IntegreRelationsChamps(CArbreTable arbre, CComposantFiltreChamp champ, bool bIsLeftOuter)
{
CResultAErreur result = CResultAErreur.True;
CArbreTable arbreEnCours = arbre;
foreach (CInfoRelationComposantFiltre relation in champ.Relations)
{
arbreEnCours = arbreEnCours.IntegreRelation(relation, bIsLeftOuter, champ.IdChampCustom);
if (arbreEnCours == null)
{
result.EmpileErreur(I.T("Error while integrating relation @1|107", relation.RelationKey));
return(result);
}
}
return(result);
}
//// ////////////////////////////////////////////////////////////////
private CResultAErreur GetRelations(CComposantFiltre composant, CArbreTable arbre, bool bFillesLeftOuter)
{
CResultAErreur result = CResultAErreur.True;
bool bIsComposantLocalLeftOuter = false;
//Le ou entraine des left outers
if (composant is CComposantFiltreOperateur)
{
CComposantFiltreOperateur op = (CComposantFiltreOperateur)composant;
if (op.Operateur.Id == CComposantFiltreOperateur.c_IdOperateurOu)
{
bIsComposantLocalLeftOuter = true;
}
}
if (composant is CComposantFiltreHasNo)
{
bIsComposantLocalLeftOuter = true;
}
if (composant is CComposantFiltreChamp)
{
CComposantFiltreChamp champ = (CComposantFiltreChamp)composant;
result = IntegreRelationsChamps(arbre, champ, bIsComposantLocalLeftOuter || bFillesLeftOuter);
if (!result)
{
return(result);
}
}
foreach (CComposantFiltre composantFils in composant.Parametres)
{
result = GetRelations(composantFils, arbre, bIsComposantLocalLeftOuter || bFillesLeftOuter);
if (!result)
{
return(result);
}
}
return(result);
}
/// //////////////////////////////////////////////////
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 string GetStringExpression(IExpression expression, CFiltreData filtre)
{
string strRetour = "";
if (expression is CComposantFiltre)
{
expression = ((CComposantFiltre)expression).GetComposantFiltreFinal(filtre);
}
if (expression is CComposantFiltreChamp)
{
CComposantFiltreChamp champ = (CComposantFiltreChamp)expression;
if (champ.Alias != "")
{
strRetour += champ.Alias + ".";
}
strRetour += champ.NomChamp;
}
else if (expression is CComposantFiltreVariable)
{
strRetour = ((CComposantFiltreVariable)expression).GetString();
}
else if (expression is CComposantFiltreConstante)
{
CComposantFiltreConstante constante = (CComposantFiltreConstante)expression;
strRetour = CConvertisseurObjetToSqlServeur.ConvertToSql(constante.Valeur);
}
else if (expression is CComposantFiltreHasNo)
{
strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre);
strRetour += " is null";
}
else if (expression is CComposantFiltreHas)
{
strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre);
strRetour += " is not null";
}
else if (expression is CComposantFiltreListe)
{
CComposantFiltreListe liste = (CComposantFiltreListe)expression;
strRetour = "";
foreach (IExpression expInListe in liste.Liste)
{
strRetour += GetStringExpression(expInListe, filtre) + ",";
}
if (strRetour.Length > 0)
{
strRetour = strRetour.Substring(0, strRetour.Length - 1);
}
strRetour = "(" + strRetour + ")";
}
else if (expression is CComposantFiltreSousFiltre && m_connexion != null)
{
CComposantFiltreSousFiltre compo = (CComposantFiltreSousFiltre)expression;
CResultAErreur result = compo.InterpreteParametres();
if (result)
{
string strWhere = "";
string strJoin = "";
string strPrefixFrom = "";
bool bDistinct = false;
compo.Filtre.Parametres.Clear();
compo.Filtre.AddChampAAjouterAArbreTable(compo.ChampSousFiltre);
foreach (object parametre in filtre.Parametres)
{
compo.Filtre.Parametres.Add(parametre);
}
CComposantFiltreOperateur compoEt = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
compoEt.Parametres.Add(compo.Filtre.ComposantPrincipal);
CComposantFiltreHas compoNotNull = new CComposantFiltreHas();
compoNotNull.Parametres.Add(compo.ChampSousFiltre);
compoEt.Parametres.Add(compoNotNull);
compo.Filtre.ComposantPrincipal = compoEt;
IEnumerable <C2iDbDatabaseConnexion.CParametreRequeteDatabase> parametres = null;
result = m_connexion.PrepareRequeteFromFiltre(
compo.Filtre,
ref strWhere,
ref strJoin,
ref bDistinct,
ref strPrefixFrom,
ref parametres);
if (result)
{
strRetour += " ";
if (compo.ChampTeste.Alias != "")
{
strRetour += compo.ChampTeste.Alias + ".";
}
strRetour += compo.ChampTeste.NomChamp;
if (compo is CComposantFiltreInSousFiltre)
{
strRetour += " in (";
}
else
{
strRetour += " not in (";
}
string strSelect = "select ";
if (compo.ChampSousFiltre.Alias != "")
{
strSelect += compo.ChampSousFiltre.Alias + ".";
}
strSelect += compo.ChampSousFiltre.NomChamp;
strSelect += " from " + CContexteDonnee.GetNomTableInDbForNomTable(compo.TableSousFiltre);
strRetour += m_connexion.GetSql(strSelect, strPrefixFrom, strJoin, strWhere);
strRetour += ")";
}
}
}
else if (expression is CComposantFiltreOperateur)
{
COperateurAnalysable operateur = ((CComposantFiltreOperateur)expression).Operateur;
string strTexteOperateur = operateur.Texte;
if (operateur.Texte.Length > 3 && operateur.Texte.Substring(0, 3).ToUpper() == "NOT")
{
strTexteOperateur = operateur.Texte.Substring(0, 3) + " " + operateur.Texte.Substring(3);
}
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains)
{
strTexteOperateur = "like";
}
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
{
strTexteOperateur = "not like";
}
if (operateur.Niveau > 0 && operateur.Niveau != 4)
{
string str1, str2, str3;
str1 = GetStringExpression((IExpression)expression.Parametres[0], filtre);
str2 = strTexteOperateur;
str3 = GetStringExpression((IExpression)expression.Parametres[1], filtre);
string[] valeurs = new string[] { str3 };
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains ||
operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
{
str3 = "'%'+" + str3 + "+'%'";
}
if (operateur.Niveau >= 4)
{
str1 = "(" + str1 + ")";
str3 = "(" + str3 + ")";
}
bool bChercheVide = false;
if (strTexteOperateur.ToUpper() == "LIKE")
{
bChercheVide = str3 == "%%";
if (!bChercheVide && str3.Contains("@"))
{
try
{
int nParam = Int32.Parse(str3.Substring("@PARAM".Length));
if (filtre.Parametres[nParam - 1].ToString() == "%%")
{
bChercheVide = true;
}
}
catch
{
}
}
}
if (bChercheVide)
{
strRetour += str3 + "=" + str3;
}
else
{
strRetour = str1 + " " + str2 + " " + str3;
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurLike ||
operateur.Id == CComposantFiltreOperateur.c_IdOperateurNotLike)
{
strRetour += " ESCAPE '\\'";
}
}
}
else
{
strRetour = strTexteOperateur + "(";
foreach (IExpression exp in expression.Parametres)
{
strRetour += GetStringExpression(exp, filtre) + ",";
}
if (expression.Parametres.Count > 0)
{
strRetour = strRetour.Substring(0, strRetour.Length - 1);
}
strRetour += ")";
}
}
return(strRetour);
}
////////////////////////////////////////////////////////
public string GetStringExpression(IExpression expression, CFiltreData filtre)
{
string strRetour = "";
if (expression is CComposantFiltre)
{
expression = ((CComposantFiltre)expression).GetComposantFiltreFinal(filtre);
}
if (expression is CComposantFiltreChamp)
{
CComposantFiltreChamp champ = (CComposantFiltreChamp)expression;
if (champ.Alias != "")
{
strRetour += champ.Alias + ".";
}
strRetour += champ.NomChamp;
/*if ( champ.Relations.Length > 0 )
* {
* if (champ.Relations[champ.Relations.Length-1].IsRelationFille)
* strRetour = champ.Relations[champ.Relations.Length-1].TableFille+".";
* else
* strRetour = champ.Relations[champ.Relations.Length-1].TableParente+".";
* }
* strRetour += champ.NomChamp;*/
}
else if (expression is CComposantFiltreVariable)
{
strRetour = ((CComposantFiltreVariable)expression).GetString();
}
else if (expression is CComposantFiltreConstante)
{
CComposantFiltreConstante constante = (CComposantFiltreConstante)expression;
strRetour = CConvertisseurObjetToSqlServeur.ConvertToSql(constante.Valeur);
}
else if (expression is CComposantFiltreHasNo)
{
strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre);
strRetour += " is null";
}
else if (expression is CComposantFiltreHas)
{
strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre);
strRetour += " is not null";
}
else if (expression is CComposantFiltreListe)
{
CComposantFiltreListe liste = (CComposantFiltreListe)expression;
strRetour = "";
foreach (IExpression expInListe in liste.Liste)
{
strRetour += GetStringExpression(expInListe, filtre) + ",";
}
if (strRetour.Length > 0)
{
strRetour = strRetour.Substring(0, strRetour.Length - 1);
}
strRetour = "(" + strRetour + ")";
}
else if (expression is CComposantFiltreOperateur)
{
COperateurAnalysable operateur = ((CComposantFiltreOperateur)expression).Operateur;
string strTexteOperateur = operateur.Texte;
if (operateur.Texte.Length > 3 && operateur.Texte.Substring(0, 3).ToUpper() == "NOT")
{
strTexteOperateur = operateur.Texte.Substring(0, 3) + " " + operateur.Texte.Substring(3);
}
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains)
{
strTexteOperateur = "like";
}
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
{
strTexteOperateur = "not like";
}
if (operateur.Niveau > 0 && operateur.Niveau != 4)
{
string str1, str2, str3;
str1 = GetStringExpression((IExpression)expression.Parametres[0], filtre);
str2 = strTexteOperateur;
str3 = GetStringExpression((IExpression)expression.Parametres[1], filtre);
string[] valeurs = new string[] { str3 };
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains ||
operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
{
str3 = "'%'+" + str3 + "+'%'";
}
if (operateur.Niveau >= 4)
{
str1 = "(" + str1 + ")";
str3 = "(" + str3 + ")";
}
bool bChercheVide = false;
if (strTexteOperateur.ToUpper() == "LIKE")
{
bChercheVide = str3 == "%%";
if (!bChercheVide && str3.Contains("@"))
{
try
{
int nParam = Int32.Parse(str3.Substring("@PARAM".Length));
if (filtre.Parametres[nParam - 1].ToString() == "%%")
{
bChercheVide = true;
}
}
catch
{
}
}
}
if (bChercheVide)
{
strRetour += str3 + "=" + str3;
}
else
{
strRetour = str1 + " " + str2 + " " + str3;
/*if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurLike ||
* operateur.Id == CComposantFiltreOperateur.c_IdOperateurNotLike)
* strRetour += " ESCAPE '\\'";*/
}
}
else
{
strRetour = strTexteOperateur + "(";
foreach (IExpression exp in expression.Parametres)
{
strRetour += GetStringExpression(exp, filtre) + ",";
}
if (expression.Parametres.Count > 0)
{
strRetour = strRetour.Substring(0, strRetour.Length - 1);
}
strRetour += ")";
}
}
return(strRetour);
}
public abstract CComposantFiltre GetComposantFiltre(CComposantFiltreChamp champ);
//--------------------------------------------------------
public CResultAErreur InterpreteParametres()
{
CResultAErreur result = CResultAErreur.True;
if (m_bIsInterprete)
{
return(result);
}
//Paramètre 1 : champ
//Paramètre 2 : sous type
//Parametre 3 : champ de sous type retourné
//Paramètre 4 : Filtre
if (Parametres.Count < 4)
{
result.EmpileErreur(GetOperateurSousFiltre() + " " +
I.T("Require 4 parameters : field, type, source field, sub filter|20008"));
return(result);
}
m_champTeste = Parametres[0] as CComposantFiltreChamp;
if (m_champTeste == null)
{
result.EmpileErreur(GetOperateurSousFiltre() + " : " + I.T("First parameter is invalid (field requiered|20070"));
}
Type tp = null;
m_strTableSousFiltre = null;
CComposantFiltreConstante compoCst = Parametres[1] as CComposantFiltreConstante;
if (compoCst != null && compoCst.Valeur != null)
{
tp = CActivatorSurChaine.GetType(compoCst.Valeur.ToString(), true);
if (tp != null)
{
m_strTableSousFiltre = CContexteDonnee.GetNomTableForType(tp);
}
if (m_strTableSousFiltre == null)
{
result.EmpileErreur(I.T("Invalid type reference (@1)|20009", compoCst.Valeur.ToString()));
}
}
else
{
result.EmpileErreur(GetOperateurSousFiltre() + " : " + I.T("Second parameter is invalid (type requiered)|20010"));
}
if (result)
{
CComposantFiltreConstante compoFiltre = Parametres[3] as CComposantFiltreConstante;
if (compoFiltre == null || compoFiltre.Valeur == null)
{
result.EmpileErreur(GetOperateurSousFiltre() + " : " + I.T("4th parameter is invalid (filtre requiered)|20012"));
return(result);
}
m_filtre = new CFiltreDataAvance(m_strTableSousFiltre, compoFiltre.Valeur.ToString());
if (m_filtre.ComposantPrincipal == null)
{
result.EmpileErreur(I.T("Sub filter is invalide|20014"));
return(result);
}
}
if (result)
{
CComposantFiltreConstante compoSousChamp = Parametres[2] as CComposantFiltreConstante;
if (compoSousChamp == null || compoSousChamp.Valeur == null)
{
result.EmpileErreur(GetOperateur() + " : " + I.T("3rd parameter is invalide (field requiered)|20013"));
return(result);
}
m_champSousFiltre = new CComposantFiltreChamp(compoSousChamp.Valeur.ToString(), m_strTableSousFiltre);
}
m_bIsInterprete = result.Result;
return(result);
}
/// //////////////////////////////////////////////////
public override CResultAErreur GetComposantFiltreData(CFiltreDynamique filtre, CFiltreData filtreData)
{
CResultAErreur result = CResultAErreur.True;
if (m_listeIdentifiantsSelectionnes.Count == 0)
{
return(result);
}
//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;
if (m_champ is CDefinitionProprieteDynamiqueThis)
{
strNomChamp = "";
}
else
{
strNomChamp = strNomChamp + ".";
}
bool bIdNumericId = m_listeIdentifiantsSelectionnes[0].IsNumericalId();
//TESTDBKEYTODO
if (bIdNumericId)
{
//Trouve le nom du champ identifiant
Type tp = m_champ.TypeDonnee.TypeDotNetNatif;
object[] attribs = tp.GetCustomAttributes(typeof(TableAttribute), true);
if (attribs.Length > 0)
{
TableAttribute tf = (TableAttribute)attribs[0];
if (tf.ChampsId.Length != 1)
{
result.EmpileErreur(I.T("Cannot apply selection on field @1|150", strNomChamp));
return(result);
}
strNomChamp += tf.ChampsId[0];
}
else
{
result.EmpileErreur(I.T("Cannot apply selection on field @1|150", strNomChamp));
return(result);
}
}
else
{
strNomChamp += CObjetDonnee.c_champIdUniversel;
}
CComposantFiltreChamp composantChamp = new CComposantFiltreChamp(strNomChamp, CContexteDonnee.GetNomTableForType(filtre.TypeElements));
CComposantFiltre composantOperateur;
if (m_bExclure)
{
composantOperateur = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurNotIn);
}
else
{
composantOperateur = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurIn);
}
composantOperateur.Parametres.Add(composantChamp);
ArrayList lst = new ArrayList();
foreach (CDbKey key in m_listeIdentifiantsSelectionnes)
{
lst.Add(new CComposantFiltreConstante(key.GetValeurInDb()));
}
composantOperateur.Parametres.Add(new CComposantFiltreListe((IExpression[])lst.ToArray(typeof(IExpression))));
if (m_bExclure)
{
//Si not in->Peut aussi être null !!!
CComposantFiltre compoOu = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurOu);
CComposantFiltreHasNo compoHasNo = new CComposantFiltreHasNo();
compoHasNo.Parametres.Add(new CComposantFiltreChamp(strNomChamp, CContexteDonnee.GetNomTableForType(filtre.TypeElements)));
compoOu.Parametres.Add(compoHasNo);
compoOu.Parametres.Add(composantOperateur);
composantOperateur = compoOu;
}
result.Data = composantOperateur;
return(result);
}
////////////////////////////////////////////////////////
protected string GetStringExpression(IExpression expression, Dictionary <string, object> valeursParametres)
{
string strRetour = "";
if (expression is CComposantFiltreChamp)
{
CComposantFiltreChamp champ = (CComposantFiltreChamp)expression;
if (champ.Alias != "")
{
strRetour += champ.Alias + ".";
}
strRetour += champ.NomChamp;
/*if ( champ.Relations.Length > 0 )
* {
* if (champ.Relations[champ.Relations.Length-1].IsRelationFille)
* strRetour = champ.Relations[champ.Relations.Length-1].TableFille+".";
* else
* strRetour = champ.Relations[champ.Relations.Length-1].TableParente+".";
* }
* strRetour += champ.NomChamp;*/
}
else if (expression is CComposantFiltreVariable)
{
strRetour = ((CComposantFiltreVariable)expression).GetString();
}
else if (expression is CComposantFiltreConstante)
{
CComposantFiltreConstante constante = (CComposantFiltreConstante)expression;
strRetour = CConvertisseurObjetToSqlServeur.ConvertToSql(constante.Valeur);
}
else if (expression is CComposantFiltreHasNo)
{
strRetour += GetStringExpression((IExpression)expression.Parametres[0], valeursParametres);
strRetour += " is null";
}
else if (expression is CComposantFiltreHas)
{
strRetour += GetStringExpression((IExpression)expression.Parametres[0], valeursParametres);
strRetour += " is not null";
}
else if (expression is CComposantFiltreListe)
{
CComposantFiltreListe liste = (CComposantFiltreListe)expression;
strRetour = "";
foreach (IExpression expInListe in liste.Liste)
{
strRetour += GetStringExpression(expInListe, valeursParametres) + ",";
}
if (strRetour.Length > 0)
{
strRetour = strRetour.Substring(0, strRetour.Length - 1);
}
strRetour = "(" + strRetour + ")";
}
else if (expression is CComposantFiltreOperateur)
{
COperateurAnalysable operateur = ((CComposantFiltreOperateur)expression).Operateur;
string strTexteOperateur = operateur.Texte;
//Remplacement du not par not espace operateur
bool bToUpper = false;
if (operateur.Texte.Length > 3 && operateur.Texte.Substring(0, 3).ToUpper() == "NOT")
{
strTexteOperateur = operateur.Texte.Substring(0, 3) + " " + operateur.Texte.Substring(3);
}
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains)
{
strTexteOperateur = "like";
}
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
{
strTexteOperateur = "not like";
}
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurLike ||
operateur.Id == CComposantFiltreOperateur.c_IdOperateurNotLike ||
operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains ||
operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
{
bToUpper = true;
}
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurEtBinaire)
{
string str1, str2;
str1 = GetStringExpression((IExpression)expression.Parametres[0], valeursParametres);
str2 = GetStringExpression((IExpression)expression.Parametres[1], valeursParametres);
strRetour = "BitAnd(" + str1 + "," + str2 + ")";
}
else if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurOuBinaire)
{
string str1, str2;
str1 = GetStringExpression((IExpression)expression.Parametres[0], valeursParametres);
str2 = GetStringExpression((IExpression)expression.Parametres[1], valeursParametres);
strRetour = "BitOr(" + str1 + "," + str2 + ")";
}
else if (operateur.Niveau > 0 && operateur.Niveau != 4)
{
string str1, str2, str3;
str1 = GetStringExpression((IExpression)expression.Parametres[0], valeursParametres);
if (bToUpper)
{
str1 = "Upper(" + str1 + ")";
}
str2 = strTexteOperateur;
str3 = GetStringExpression((IExpression)expression.Parametres[1], valeursParametres);
object val = null;
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurEgal &&
valeursParametres != null &&
valeursParametres.TryGetValue(str3, out val) &&
val == c_null)
{
//Obligé d'ajouter une référence au nom de la variable, sinon, MySql fait la gueule
//d'où or str3 is null qui ne sert à rien
strRetour = "(" + str1 + " is null or " + str3 + " is null)";
}
else if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurDifferent &&
valeursParametres != null &&
valeursParametres.TryGetValue(str3, out val) &&
val == c_null)
{
//Obligé d'ajouter une référence au nom de la variable, sinon, MySql fait la gueule
//d'où or str3 is null qui ne sert à rien
strRetour = "(" + str1 + " is not null or " + str3 + " is null)";
}
else
{
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains ||
operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
{
str3 = "Concat('%',concat(" + str3 + ",'%'))";
}
if (bToUpper)
{
str3 = "Upper(" + str3 + ")";
}
if (operateur.Niveau >= 4)
{
str1 = "(" + str1 + ")";
str3 = "(" + str3 + ")";
}
strRetour = str1 + " " + str2 + " " + str3;
}
}
else
{
strRetour = strTexteOperateur + "(";
foreach (IExpression exp in expression.Parametres)
{
strRetour += GetStringExpression(exp, valeursParametres) + ",";
}
if (expression.Parametres.Count > 0)
{
strRetour = strRetour.Substring(0, strRetour.Length - 1);
}
strRetour += ")";
}
}
return(strRetour);
}
////////////////////////////////////////////////////////
protected string GetStringExpression(
IExpression expression,
CFiltreData filtre,
Dictionary <string, object> valeursParametres)
{
string strRetour = "";
if (expression is CComposantFiltreChamp)
{
CComposantFiltreChamp champ = (CComposantFiltreChamp)expression;
if (champ.Alias != "")
{
strRetour += champ.Alias + ".";
}
strRetour += champ.NomChamp;
/*if ( champ.Relations.Length > 0 )
* {
* if (champ.Relations[champ.Relations.Length-1].IsRelationFille)
* strRetour = champ.Relations[champ.Relations.Length-1].TableFille+".";
* else
* strRetour = champ.Relations[champ.Relations.Length-1].TableParente+".";
* }
* strRetour += champ.NomChamp;*/
}
else if (expression is CComposantFiltreVariable)
{
strRetour = ((CComposantFiltreVariable)expression).GetString();
}
else if (expression is CComposantFiltreConstante)
{
CComposantFiltreConstante constante = (CComposantFiltreConstante)expression;
strRetour = CConvertisseurObjetToSqlServeur.ConvertToSql(constante.Valeur);
}
else if (expression is CComposantFiltreHasNo)
{
strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre, valeursParametres);
strRetour += " is null";
}
else if (expression is CComposantFiltreHas)
{
strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre, valeursParametres);
strRetour += " is not null";
}
else if (expression is CComposantFiltreListe)
{
CComposantFiltreListe liste = (CComposantFiltreListe)expression;
strRetour = "";
foreach (IExpression expInListe in liste.Liste)
{
strRetour += GetStringExpression(expInListe, filtre, valeursParametres) + ",";
}
if (strRetour.Length > 0)
{
strRetour = strRetour.Substring(0, strRetour.Length - 1);
}
strRetour = "(" + strRetour + ")";
}
else if (expression is CComposantFiltreSousFiltre && m_connexion != null)
{
CComposantFiltreSousFiltre compo = (CComposantFiltreSousFiltre)expression;
CResultAErreur result = compo.InterpreteParametres();
if (result)
{
string strWhere = "";
string strJoin = "";
string strPrefixFrom = "";
bool bDistinct = false;
compo.Filtre.Parametres.Clear();
compo.Filtre.AddChampAAjouterAArbreTable(compo.ChampSousFiltre);
foreach (object parametre in filtre.Parametres)
{
compo.Filtre.Parametres.Add(parametre);
}
CComposantFiltreOperateur compoEt = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
compoEt.Parametres.Add(compo.Filtre.ComposantPrincipal);
CComposantFiltreHas compoNotNull = new CComposantFiltreHas();
compoNotNull.Parametres.Add(compo.ChampSousFiltre);
compoEt.Parametres.Add(compoNotNull);
compo.Filtre.ComposantPrincipal = compoEt;
IEnumerable <C2iDbDatabaseConnexion.CParametreRequeteDatabase> parametres = null;
result = m_connexion.PrepareRequeteFromFiltre(
compo.Filtre,
ref strWhere,
ref strJoin,
ref bDistinct,
ref strPrefixFrom,
ref parametres);
if (result)
{
strRetour += " ";
if (compo.ChampTeste.Alias != "")
{
strRetour += compo.ChampTeste.Alias + ".";
}
strRetour += compo.ChampTeste.NomChamp;
if (compo is CComposantFiltreInSousFiltre)
{
strRetour += " in (";
}
else
{
strRetour += " not in (";
}
string strSelect = "select ";
if (compo.ChampSousFiltre.Alias != "")
{
strSelect += compo.ChampSousFiltre.Alias + ".";
}
strSelect += compo.ChampSousFiltre.NomChamp;
strSelect += " from " + CContexteDonnee.GetNomTableInDbForNomTable(compo.TableSousFiltre);
strRetour += m_connexion.GetSql(strSelect, strPrefixFrom, strJoin, strWhere);
strRetour += ")";
}
}
}
else if (expression is CComposantFiltreOperateur)
{
COperateurAnalysable operateur = ((CComposantFiltreOperateur)expression).Operateur;
string strTexteOperateur = operateur.Texte;
//Remplacement du not par not espace operateur
bool bToUpper = false;
if (operateur.Texte.Length > 3 && operateur.Texte.Substring(0, 3).ToUpper() == "NOT")
{
strTexteOperateur = operateur.Texte.Substring(0, 3) + " " + operateur.Texte.Substring(3);
}
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains)
{
strTexteOperateur = "like";
}
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
{
strTexteOperateur = "not like";
}
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurLike ||
operateur.Id == CComposantFiltreOperateur.c_IdOperateurNotLike ||
operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains ||
operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
{
bToUpper = true;
}
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurEtBinaire)
{
string str1, str2;
str1 = GetStringExpression((IExpression)expression.Parametres[0], filtre, valeursParametres);
str2 = GetStringExpression((IExpression)expression.Parametres[1], filtre, valeursParametres);
strRetour = "BitAnd(" + str1 + "," + str2 + ")";
}
else if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurOuBinaire)
{
string str1, str2;
str1 = GetStringExpression((IExpression)expression.Parametres[0], filtre, valeursParametres);
str2 = GetStringExpression((IExpression)expression.Parametres[1], filtre, valeursParametres);
strRetour = "BitOr(" + str1 + "," + str2 + ")";
}
else if (operateur.Niveau > 0 && operateur.Niveau != 4)
{
string str1, str2, str3;
str1 = GetStringExpression((IExpression)expression.Parametres[0], filtre, valeursParametres);
if (bToUpper)
{
str1 = "Upper(" + str1 + ")";
}
str2 = strTexteOperateur;
str3 = GetStringExpression((IExpression)expression.Parametres[1], filtre, valeursParametres);
object val = null;
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurEgal &&
valeursParametres != null &&
valeursParametres.TryGetValue(str3, out val) &&
val == c_null)
{
//Obligé d'ajouter une référence au nom de la variable, sinon, oracle fait la gueule
//d'où or str3 is null qui ne sert à rien
strRetour = "(" + str1 + " is null or " + str3 + " is null)";
}
else if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurDifferent &&
valeursParametres != null &&
valeursParametres.TryGetValue(str3, out val) &&
val == c_null)
{
//Obligé d'ajouter une référence au nom de la variable, sinon, oracle fait la gueule
//d'où or str3 is null qui ne sert à rien
strRetour = "(" + str1 + " is not null or " + str3 + " is null)";
}
else
{
if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains ||
operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout)
{
str3 = "Concat('%',concat(" + str3 + ",'%'))";
}
if (bToUpper)
{
str3 = "Upper(" + str3 + ")";
}
if (operateur.Niveau >= 4)
{
str1 = "(" + str1 + ")";
str3 = "(" + str3 + ")";
}
strRetour = str1 + " " + str2 + " " + str3;
}
}
else
{
strRetour = strTexteOperateur + "(";
foreach (IExpression exp in expression.Parametres)
{
strRetour += GetStringExpression(exp, filtre, valeursParametres) + ",";
}
if (expression.Parametres.Count > 0)
{
strRetour = strRetour.Substring(0, strRetour.Length - 1);
}
strRetour += ")";
}
}
return(strRetour);
}
/// //////////////////////////////////////////////////
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_champTeste.NomPropriete;
if (m_champTeste is CDefinitionProprieteDynamiqueChampCustom)
{
CDbKey dbKeyChamp = ((CDefinitionProprieteDynamiqueChampCustom)m_champTeste).DbKeyChamp;
strNomChamp = m_champTeste.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);
operateurIdChamp.Parametres.Add(new CComposantFiltreChamp(strAcces + CChampCustom.c_champId, CContexteDonnee.GetNomTableForType(filtre.TypeElements)));
operateurIdChamp.Parametres.Add(new CComposantFiltreConstante(dbKeyChamp));
opPrincipal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
opPrincipal.Parametres.Add(operateurIdChamp);
Type typeChamp = m_champTeste.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));
CComposantFiltreSousFiltre composantSousFiltre = IsNotInTest ?
new CComposantFiltreNotInSousFiltre() as CComposantFiltreSousFiltre :
new CComposantFiltreInSousFiltre() as CComposantFiltreSousFiltre;
m_sousFiltre.ElementAVariablesExterne = filtre;
result = m_sousFiltre.GetFiltreData();
CFiltreDataAvance filtreAvance = null;
if (result && result.Data is CFiltreDataAvance)
{
filtreAvance = result.Data as CFiltreDataAvance;
}
else
{
return(result);
}
filtreAvance.RenumerotteParameters(filtreData.Parametres.Count + 1);
foreach (object parametre in filtreAvance.Parametres)
{
filtreData.Parametres.Add(parametre);
}
CComposantFiltreChamp champDeSousFiltre = new CComposantFiltreChamp(m_champRetourneParSousFiltre.NomPropriete, filtreAvance.TablePrincipale);
composantSousFiltre.InitComposant(composantChamp, filtreAvance.TablePrincipale, champDeSousFiltre, filtreAvance);
composantSousFiltre.Parametres.Add(composantChamp);
composantSousFiltre.Parametres.Add(new CComposantFiltreConstante(CContexteDonnee.GetTypeForTable(filtreAvance.TablePrincipale).ToString()));
composantSousFiltre.Parametres.Add(new CComposantFiltreConstante(champDeSousFiltre.ChaineInitiale));
composantSousFiltre.Parametres.Add(new CComposantFiltreConstante(filtreAvance.ComposantPrincipal.GetString()));
CComposantFiltre composantRecherche = composantSousFiltre;
if (opPrincipal != null)
{
opPrincipal.Parametres.Add(composantRecherche);
composantRecherche = opPrincipal;
}
result.Data = composantRecherche;
return(result);
}
/// ////////////////////////////////////////////////////////////////
public void AddChampAAjouterAArbreTable(CComposantFiltreChamp champ)
{
m_listeChampsAAjouterAArbreTable.Add(champ);
}
////////////////////////////////////////////////////////
public string GetStringExpression(IExpression expression, CFiltreData filtre)
{
string strRetour = "";
if (expression is CComposantFiltre)
{
expression = ((CComposantFiltre)expression).GetComposantFiltreFinal(filtre);
}
if (expression is CComposantFiltreChamp)
{
CComposantFiltreChamp champ = (CComposantFiltreChamp)expression;
foreach (CInfoRelationComposantFiltre info in champ.Relations)
{
strRetour += "Parent(" + info.RelationKey + ").";
}
strRetour += champ.NomChamp;
}
else if (expression is CComposantFiltreConstante)
{
CComposantFiltreConstante constante = (CComposantFiltreConstante)expression;
if (constante.Valeur is String)
{
strRetour = "'" + constante.Valeur.ToString().Replace("'", "''") + "'";
}
else if (constante.Valeur is DateTime)
{
strRetour += ((DateTime)constante.Valeur).ToShortDateString();
}
else
{
strRetour += constante.Valeur.ToString();
}
}
else if (expression is CComposantFiltreListe)
{
CComposantFiltreListe liste = (CComposantFiltreListe)expression;
strRetour = "";
foreach (IExpression expDeListe in liste.Liste)
{
strRetour += GetStringExpression(expDeListe, filtre) + ",";
}
if (strRetour.Length > 0)
{
strRetour = strRetour.Substring(0, strRetour.Length - 1);
}
strRetour = "(" + strRetour + ")";
}
else if (expression is CComposantFiltreOperateur)
{
COperateurAnalysable operateur = ((CComposantFiltreOperateur)expression).Operateur;
string strTexteOperateur = operateur.Texte;
if (operateur.Niveau > 0 && operateur.Niveau != 4)
{
if (operateur.Texte.Length > 3 && operateur.Texte.Substring(0, 3).ToUpper() == "NOT")
{
strTexteOperateur = operateur.Texte.Substring(0, 3) + " " + operateur.Texte.Substring(3);
}
strRetour = GetStringExpression((IExpression)expression.Parametres[0], filtre) +
" " + strTexteOperateur +
" " + GetStringExpression((IExpression)expression.Parametres[1], filtre);
}
else
{
strRetour = strTexteOperateur + "(";
foreach (IExpression exp in expression.Parametres)
{
strRetour += GetStringExpression(exp, filtre) + ",";
}
if (expression.Parametres.Count > 0)
{
strRetour = strRetour.Substring(0, strRetour.Length - 1);
}
strRetour += ")";
}
}
return(strRetour);
}
/// //////////////////////////////////////////////////
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 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() == "0")
{
result.Data = null;
return(result);
}
if (m_champValeur is CDefinitionProprieteDynamiqueChampCustom)
{
if (m_champ is CDefinitionProprieteDynamiqueChampCustom)
{
result.EmpileErreur(I.T("Operation not supported: Field = Field|156"));
return(result);
}
else
{
CDefinitionProprieteDynamique defTmp = m_champ;
m_champ = m_champValeur;
m_champValeur = defTmp;
}
}
CComposantFiltreOperateur opPrincipal = null;
string strNomChamp = m_champ.NomPropriete;
CDbKey dbKeyChampCustom = null;
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.";
dbKeyChampCustom = ((CDefinitionProprieteDynamiqueChampCustom)m_champ).DbKeyChamp;
//Stef, 12/10/2009, le test de l'id du champ custom est
//Maintenant gerée par le CInfoRelationChampCustom et non
//Plus directement dans la clause where. Ca va beaucoup plus vite sous SqlServer
/*CComposantFiltreOperateur operateurIdChamp = new CComposantFiltreOperateur ( CComposantFiltreOperateur.c_IdOperateurEgal );
* CComposantFiltreChamp compo1 = new CComposantFiltreChamp ( strAcces+CChampCustom.c_champId, CContexteDonnee.GetNomTableForType (filtre.TypeElements));
* compo1.IdChampCustom = nIdChampCustom;
* operateurIdChamp.Parametres.Add ( compo1 );
* operateurIdChamp.Parametres.Add ( new CComposantFiltreConstante ( nIdChamp ) );
* 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;
opPrincipal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
CComposantFiltreChamp composantChampNull = new CComposantFiltreChamp(strAcces + CRelationElementAChamp_ChampCustom.c_champValeurNull, CContexteDonnee.GetNomTableForType(filtre.TypeElements));
composantChampNull.IdChampCustom = CChampCustom.GetIdFromDbKey(dbKeyChampCustom);
CComposantFiltreOperateur opEgal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEgal);
opEgal.Parametres.Add(composantChampNull);
opEgal.Parametres.Add(new CComposantFiltreConstante(0));
opPrincipal.Parametres.Add(opEgal);
}
CComposantFiltreChamp composantChamp = new CComposantFiltreChamp(strNomChamp, CContexteDonnee.GetNomTableForType(filtre.TypeElements));
composantChamp.IdChampCustom = CChampCustom.GetIdFromDbKey(dbKeyChampCustom);
CComposantFiltreOperateur composantOperateur = new CComposantFiltreOperateur(IdOperateur);
CComposantFiltre composantValeur = null;
if (ExpressionValeur == null)
{
if (m_champValeur != null)
{
composantValeur = new CComposantFiltreChamp(m_champValeur.NomPropriete, composantChamp.TableDeBase);
}
else
{
result.EmpileErreur(I.T("Value is not defined for element @1|157", Description));
result.Data = null;
return(result);
}
}
else
{
result = ExpressionValeur.Eval(contexteEvaluation);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluation of @1|143", ExpressionValeur.GetString()));
result.Data = null;
return(result);
}
CComposantFiltreVariable composantVariable = new CComposantFiltreVariable("@" + (filtreData.Parametres.Count + 1).ToString());
filtreData.Parametres.Add(result.Data);
composantValeur = composantVariable;
}
composantOperateur.Parametres.Add(composantChamp);
composantOperateur.Parametres.Add(composantValeur);
if (IdOperateur == CComposantFiltreOperateur.c_IdOperateurDifferent)
{
//Ajoute ou null
CComposantFiltreOperateur ou = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurOu);
ou.Parametres.Add(composantOperateur);
CComposantFiltreHasNo hasNo = new CComposantFiltreHasNo();
hasNo.Parametres.Add(new CComposantFiltreChamp(strNomChamp, composantChamp.TableDeBase));
ou.Parametres.Add(hasNo);
composantOperateur = ou;
}
if (opPrincipal != null)
{
opPrincipal.Parametres.Add(composantOperateur);
composantOperateur = opPrincipal;
}
result.Data = composantOperateur;
return(result);
}
