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