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 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 virtual CComposantFiltre GetComposantFiltre()
{
CComposantFiltre filtrebase;
string idOperateur = "";
switch (FilsOperateur)
{
case EOperateurElementAComposantFiltre.Et:
idOperateur = CComposantFiltreOperateur.c_IdOperateurEt;
break;
case EOperateurElementAComposantFiltre.Ou:
idOperateur = CComposantFiltreOperateur.c_IdOperateurOu;
break;
default:
return(null);
}
int nbEle = m_lstFils.Count;
if (nbEle > 1)
{
filtrebase = new CComposantFiltreOperateur(idOperateur);
CComposantFiltreOperateur filtrelast = (CComposantFiltreOperateur)filtrebase;
for (int i = 0; i < nbEle; i++)
{
CDataGridViewColonneFilterComponent fils = m_lstFils[i];
if (i == m_lstFils.Count - 2)
{
filtrelast.Parametres.Add(fils.GetComposantFiltre());
filtrelast.Parametres.Add(m_lstFils[i + 1].GetComposantFiltre());
break;
}
else
{
filtrelast.Parametres.Add(fils.GetComposantFiltre());
CComposantFiltreOperateur filtresuivant = new CComposantFiltreOperateur(idOperateur);
filtrelast.Parametres.Add(filtresuivant);
filtrelast = filtresuivant;
}
}
}
else if (nbEle == 1)
{
filtrebase = m_lstFils[0].GetComposantFiltre();
}
else
{
return(null);
}
return(filtrebase);
}
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 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);
}
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 void AddAndFiltre ( CFiltreData filtre )
* {
* if ( filtre == null || !filtre.HasFiltre )
* return;
* if ( m_strFiltre.Trim() != "" )
* m_strFiltre = "("+m_strFiltre+") and ";
* string strNewFiltre = filtre.Filtre+" ";
* int nNumNewParam = Parametres.Count +1;
* for ( int nParam = 0; nParam < filtre.Parametres.Count; nParam++ )
* {
* strNewFiltre = strNewFiltre.Replace("@"+(nParam+1).ToString()+" ", "@"+nNumNewParam.ToString()+" ");
* Parametres.Add ( filtre.Parametres[nParam] );
* nNumNewParam++;
* }
* m_strFiltre += strNewFiltre;
* }*/
///////////////////////////////////////////////////
protected static CFiltreData CombineFiltres(CFiltreData filtre1, CFiltreData filtre2, string strOperateur)
{
if ((filtre1 == null || !filtre1.HasFiltre) && (filtre2 == null || !filtre2.HasFiltre))
{
return(null);
}
if (filtre1 == null || !filtre1.HasFiltre)
{
return(filtre2.GetClone());
}
if (filtre2 == null || !filtre2.HasFiltre)
{
return(filtre1.GetClone());
}
if (filtre1 is CFiltreDataImpossible || filtre2 is CFiltreDataImpossible)
{
return(new CFiltreDataImpossible());
}
CFiltreData filtreResult = null;
if (filtre1 is CFiltreDataAvance || filtre2 is CFiltreDataAvance)
{
string strTable;
if (filtre1 is CFiltreDataAvance)
{
strTable = ((CFiltreDataAvance)filtre1).TablePrincipale;
if (filtre2 is CFiltreDataAvance &&
((CFiltreDataAvance)filtre2).TablePrincipale != strTable)
{
throw new Exception(I.T("Cannot combine @1 filter on different tables|133", strOperateur));
}
}
else
{
strTable = ((CFiltreDataAvance)filtre2).TablePrincipale;
}
filtreResult = new CFiltreDataAvance(strTable, "");
if (!(filtre1 is CFiltreDataAvance))
{
filtre1 = CFiltreDataAvance.ConvertFiltreToFiltreAvance(strTable, filtre1);
}
if (!(filtre2 is CFiltreDataAvance))
{
filtre2 = CFiltreDataAvance.ConvertFiltreToFiltreAvance(strTable, filtre2);
}
CResultAErreur result = CResultAErreur.True;
CFiltreDataAvance filtre1Avance = filtre1 as CFiltreDataAvance;
CComposantFiltre composant1 = filtre1Avance.ComposantPrincipal;
if (composant1 == null)
{
result = CAnalyseurSyntaxiqueFiltre.AnalyseFormule(filtre1.Filtre, strTable);
if (!result)
{
result.EmpileErreur(I.T("Error while analyzing filter @1|134", filtre1.Filtre));
throw new CExceptionErreur(result.Erreur);
}
composant1 = result.Data as CComposantFiltre;
}
CFiltreDataAvance copie = filtre2.GetClone() as CFiltreDataAvance;
copie.RenumerotteParameters(filtre1.Parametres.Count + 1);
CComposantFiltre composant2 = copie.ComposantPrincipal;
if (composant2 == null)
{
result = CAnalyseurSyntaxiqueFiltre.AnalyseFormule(copie.Filtre, strTable);
if (!result)
{
result.EmpileErreur(I.T("Error while analyzing filter @1|134", copie.Filtre));
throw new CExceptionErreur(result.Erreur);
}
composant2 = result.Data as CComposantFiltre;
}
CComposantFiltre composantPrincipal = null;
if (strOperateur.ToUpper() == "OR")
{
composantPrincipal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurOu);
}
if (strOperateur.ToUpper() == "AND")
{
composantPrincipal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
}
if (composantPrincipal != null)
{
composantPrincipal.Parametres.Add(composant1);
composantPrincipal.Parametres.Add(composant2);
filtreResult = new CFiltreDataAvance(strTable, composantPrincipal);
}
else
{
filtreResult.Filtre = "(" + composant1.GetString() + ") " + strOperateur + " (" +
composant2.GetString() + ")";
}
}
else
{
filtreResult = new CFiltreData();
filtreResult.Filtre = "(" + filtre1.Filtre + ")";
CFiltreData copie = filtre2.GetClone();
copie.RenumerotteParameters(filtre1.Parametres.Count + 1);
filtreResult.Filtre += " " + strOperateur + " (" + copie.Filtre + ")";
}
foreach (object parametre in filtre1.Parametres)
{
filtreResult.Parametres.Add(parametre);
}
foreach (object parametre in filtre2.Parametres)
{
filtreResult.Parametres.Add(parametre);
}
if (filtre1 != null && filtre1.SortOrder != "")
{
filtreResult.SortOrder = filtre1.SortOrder;
}
if (filtre2 != null && filtre2.SortOrder != "")
{
if (filtreResult.SortOrder != "")
{
filtreResult.SortOrder += ",";
}
filtreResult.SortOrder += filtre2.SortOrder;
}
if (filtre1 != null)
{
filtreResult.IntegrerLesElementsSupprimes |= filtre1.IntegrerLesElementsSupprimes;
filtreResult.IgnorerVersionDeContexte |= filtre1.IgnorerVersionDeContexte;
filtreResult.IdsDeVersionsALire = filtre1.IdsDeVersionsALire;
filtreResult.IntergerParentsHierarchiques |= filtre1.IntergerParentsHierarchiques;
filtreResult.IntegrerFilsHierarchiques |= filtre1.IntegrerFilsHierarchiques;
filtreResult.NeConserverQueLesRacines |= filtre1.NeConserverQueLesRacines;
}
if (filtre2 != null)
{
filtreResult.IntegrerLesElementsSupprimes |= filtre2.IntegrerLesElementsSupprimes;
filtreResult.IgnorerVersionDeContexte |= filtre2.IgnorerVersionDeContexte;
filtreResult.IntergerParentsHierarchiques |= filtre2.IntergerParentsHierarchiques;
filtreResult.IntegrerFilsHierarchiques |= filtre2.IntegrerFilsHierarchiques;
filtreResult.NeConserverQueLesRacines |= filtre2.NeConserverQueLesRacines;
if (filtre2.IdsDeVersionsALire != null)
{
if (filtreResult.IdsDeVersionsALire != null)
{
Hashtable tblIds = new Hashtable();
foreach (int nId in filtreResult.IdsDeVersionsALire)
{
tblIds[nId] = true;
}
foreach (int nId in filtre2.IdsDeVersionsALire)
{
tblIds[nId] = true;
}
ArrayList lst = new ArrayList();
foreach (int nId in tblIds.Keys)
{
lst.Add(nId);
}
filtreResult.IdsDeVersionsALire = (int[])lst.ToArray(typeof(int));
}
else
{
filtreResult.IdsDeVersionsALire = filtre2.IdsDeVersionsALire;
}
}
}
return(filtreResult);
}
/// //////////////////////////////////////////////////
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 override CComposantFiltre GetComposantFiltre()
{
string idOperateur = "";
object val = m_valeur;
switch (m_operateur.Code)
{
case EOperateurTestFiltre.Egal:
idOperateur = CComposantFiltreOperateur.c_IdOperateurEgal;
break;
case EOperateurTestFiltre.Different:
idOperateur = CComposantFiltreOperateur.c_IdOperateurDifferent;
break;
case EOperateurTestFiltre.PlusPetit:
idOperateur = CComposantFiltreOperateur.c_IdOperateurInf;
break;
case EOperateurTestFiltre.PlusGrand:
idOperateur = CComposantFiltreOperateur.c_IdOperateurSup;
break;
case EOperateurTestFiltre.PlusPetitOuEgal:
idOperateur = CComposantFiltreOperateur.c_IdOperateurInfEgal;
break;
case EOperateurTestFiltre.PlusGrandOuEgal:
idOperateur = CComposantFiltreOperateur.c_IdOperateurSuperieurOuEgal;
break;
case EOperateurTestFiltre.Contient:
idOperateur = CComposantFiltreOperateur.c_IdOperateurLike;
val = "%" + val.ToString() + "%";
break;
case EOperateurTestFiltre.NeContientPas:
idOperateur = CComposantFiltreOperateur.c_IdOperateurNotLike;
val = "%" + val.ToString() + "%";
break;
case EOperateurTestFiltre.CommencePar:
idOperateur = CComposantFiltreOperateur.c_IdOperateurLike;
val = val.ToString() + "%";
break;
case EOperateurTestFiltre.NeCommencePasPar:
idOperateur = CComposantFiltreOperateur.c_IdOperateurNotLike;
val = val.ToString() + "%";
break;
case EOperateurTestFiltre.TerminePar:
idOperateur = CComposantFiltreOperateur.c_IdOperateurLike;
val = "%" + val.ToString();
break;
case EOperateurTestFiltre.NeTerminePasPar:
idOperateur = CComposantFiltreOperateur.c_IdOperateurDifferent;
val = "%" + val.ToString();
break;
case EOperateurTestFiltre.Null:
idOperateur = CComposantFiltreOperateur.c_IdOperateurNull;
break;
case EOperateurTestFiltre.NonNull:
idOperateur = CComposantFiltreOperateur.c_IdOperateurIsNotNull;
break;
default:
break;
}
CComposantFiltre filtre;
if (idOperateur == CComposantFiltreOperateur.c_IdOperateurIsNotNull)
{
CComposantFiltreHas has = new CComposantFiltreHas();
has.Parametres.Add(new CComposantFiltreChamp(m_col.DataPropertyName, ""));
filtre = has;
}
else if (idOperateur == CComposantFiltreOperateur.c_IdOperateurNull)
{
CComposantFiltreHasNo hasnot = new CComposantFiltreHasNo();
hasnot.Parametres.Add(new CComposantFiltreChamp(m_col.DataPropertyName, ""));
filtre = hasnot;
}
else
{
CComposantFiltreOperateur compar = new CComposantFiltreOperateur(idOperateur);
compar.Parametres.Add(new CComposantFiltreChamp(m_col.DataPropertyName, ""));
compar.Parametres.Add(new CComposantFiltreConstante(val));
filtre = compar;
}
return(filtre);
}
//--------------------------------------------------
protected override CResultAErreur GetDatasHorsCalculees(CListeQuerySource sources)
{
CResultAErreur result = CResultAErreur.True;
CResultAErreurType <CColumnDeEasyQueryChampDeRequete> resCol = GetColonneIdSource();
m_dicRowsParentes = null;
if (!resCol)
{
result.EmpileErreur(resCol.Erreur);
return(result);
}
IODEQTableFromFramework tableSource = this.ElementsSource[0] as IODEQTableFromFramework;
if (tableSource != null)
{
result = tableSource.GetDatas(sources);
if (!result)
{
return(result);
}
DataTable tableParente = result.Data as DataTable;
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = CContexteDonnee.GetNomTableForType(TypeElements);
foreach (IColumnDeEasyQuery col in m_listeColonnes)
{
CColumnDeEasyQueryChampDeRequete colR = col as CColumnDeEasyQueryChampDeRequete;
requete.ListeChamps.Add(colR);
}
if (requete.ListeChamps.Count == 0)
{
result.Data = new DataTable();
return(result);
}
bool bRelTrouve = false;
CComposantFiltreOperateur cpOperateur = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurIn);
CComposantFiltre cpFinal = cpOperateur;
result = FiltreDynamique.GetFiltreData();
if (!result)
{
return(result);
}
CFiltreDataAvance filtre = result.Data as CFiltreDataAvance;
if (filtre == null)
{
filtre = new CFiltreDataAvance(requete.TableInterrogee, "");
}
CDefinitionProprieteDynamiqueRelation rel = m_definitionSource as CDefinitionProprieteDynamiqueRelation;
string strNomChampParent = null;
//// Relation standard
if (rel != null)
{
//m_definitionSource.GetDefinitionInverse(TypeElements);
if (rel.Relation.TableParente == requete.TableInterrogee)
{
cpOperateur.Parametres.Add(new CComposantFiltreChamp(rel.Relation.ChampsParent[0], requete.TableInterrogee));
strNomChampParent = rel.Relation.ChampsParent[0];
}
else
{
cpOperateur.Parametres.Add(new CComposantFiltreChamp(rel.Relation.ChampsFille[0], requete.TableInterrogee));
strNomChampParent = rel.Relation.ChampsFille[0];
}
bRelTrouve = true;
}
else
{
///Relation Type id
CDefinitionProprieteDynamiqueRelationTypeId relTypeId = m_definitionSource as CDefinitionProprieteDynamiqueRelationTypeId;
if (relTypeId != null)
{
cpOperateur.Parametres.Add(new CComposantFiltreChamp(relTypeId.Relation.ChampId, requete.TableInterrogee));
strNomChampParent = relTypeId.Relation.ChampId;
cpFinal = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
cpFinal.Parametres.Add(cpOperateur);
CComposantFiltre cpType = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEgal);
cpType.Parametres.Add(new CComposantFiltreChamp(relTypeId.Relation.ChampType, requete.TableInterrogee));
cpType.Parametres.Add(new CComposantFiltreVariable("@" + (filtre.Parametres.Count + 1).ToString("0")));
filtre.Parametres.Add(tableSource.TypeElements.ToString());
cpFinal.Parametres.Add(cpType);
bRelTrouve = true;
}
}
if (strNomChampParent != null)
{
requete.ListeChamps.Add(new C2iChampDeRequete(c_nomChampParentId, new CSourceDeChampDeRequete(strNomChampParent), typeof(int), OperationsAgregation.None, false));
}
if (!bRelTrouve)
{
result.EmpileErreur(I.T("Can not find link for table @1|20076", NomFinal));
return(result);
}
int nParametre = filtre.Parametres.Count;
cpOperateur.Parametres.Add(new CComposantFiltreVariable("@" + (filtre.Parametres.Count + 1).ToString("0")));
filtre.Parametres.Add(new int[0]);
if (filtre.ComposantPrincipal == null)
{
filtre.ComposantPrincipal = cpFinal;
}
else
{
CComposantFiltreOperateur opEt = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt);
opEt.Parametres.Add(cpFinal);
opEt.Parametres.Add(filtre.ComposantPrincipal);
filtre.ComposantPrincipal = opEt;
}
m_dicRowsParentes = new Dictionary <object, DataRow>();
DataTable maTable = null;
int nLectureParLot = 500;
for (int nRow = 0; nRow < tableParente.Rows.Count; nRow += nLectureParLot)
{
int nMax = Math.Min(nRow + nLectureParLot, tableParente.Rows.Count);
List <int> lstIds = new List <int>();
for (int n = nRow; n < nMax; n++)
{
DataRow row = tableParente.Rows[n];
int nVal = (int)row[resCol.DataType.ColumnName];
lstIds.Add(nVal);
m_dicRowsParentes[nVal] = row;
}
filtre.Parametres[nParametre] = lstIds.ToArray();
DataTable tableTmp = null;
requete.FiltreAAppliquer = filtre;
result = requete.ExecuteRequete(CContexteDonneeSysteme.GetInstance().IdSession);
if (!result || !(result.Data is DataTable))
{
result.EmpileErreur(I.T("Error on table @1|20070", NomFinal));
return(result);
}
tableTmp = result.Data as DataTable;
if (maTable == null)
{
maTable = tableTmp;
}
else
{
maTable.Merge(tableTmp);
}
}
if (maTable == null)
{
maTable = new DataTable(NomFinal);
foreach (IColumnDeEasyQuery colEQ in ColonnesOrCalculees)
{
DataColumn col = new DataColumn(colEQ.ColumnName, colEQ.DataType);
try
{
maTable.Columns.Add(col);
}
catch { }
}
DataColumn colParent = new DataColumn(c_nomChampParentId, typeof(int));
try
{
maTable.Columns.Add(colParent);
}
catch { }
}
else
{
//Ajoute les colonnes from parent
Dictionary <CColumnEQFromSource, string> dicColFromSourceToNom = new Dictionary <CColumnEQFromSource, string>();
foreach (CColumnEQFromSource colFromSource in m_listeColonnesFromParent)
{
if (!maTable.Columns.Contains(colFromSource.ColumnName))
{
maTable.Columns.Add(colFromSource.ColumnName, colFromSource.DataType);
}
IColumnDeEasyQuery colSource = tableSource.Columns.FirstOrDefault(c => c.Id == colFromSource.IdColumnSource);
if (colSource != null && tableParente.Columns.Contains(colSource.ColumnName))
{
dicColFromSourceToNom[colFromSource] = colSource.ColumnName;
}
}
if (maTable.Columns.Contains(c_nomChampParentId))
{
foreach (DataRow row in maTable.Rows)
{
if (row[c_nomChampParentId] is int)
{
DataRow rowParente = null;
if (m_dicRowsParentes.TryGetValue((int)row[c_nomChampParentId], out rowParente))
{
if (rowParente != null)
{
foreach (KeyValuePair <CColumnEQFromSource, string> kv in dicColFromSourceToNom)
{
row[kv.Key.ColumnName] = rowParente[kv.Value];
}
}
}
}
}
maTable.Columns.Remove(c_nomChampParentId);
}
}
result.Data = maTable;
}
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,
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 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 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);
}
