/// //////////////////////////////////////////////////
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);
}
////////////////////////////////////////////////////////
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 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);
}