////////////////////////////////////////////////////////
public string GetStringAvance(CFiltreDataAvance filtre)
{
CComposantFiltre composant = filtre.ComposantPrincipal;
if (composant == null)
{
return("");
}
//remplace chaque champ par sa valeur
for (int nParametre = filtre.Parametres.Count; nParametre > 0; nParametre--)
{
if (filtre.Parametres[nParametre - 1] is IList)
{
composant.RemplaceVariableParConstante("@" + nParametre, filtre.Parametres[nParametre - 1]);
filtre.Parametres[nParametre - 1] = "";
//Renomme les variables suivantes (qui sont déjà renommées en @PARAM)
for (int nSuivant = nParametre + 1; nSuivant <= filtre.Parametres.Count; nSuivant++)
{
composant.RenommeVariable("@PARAM" + (nSuivant), "@PARAM" + (nSuivant - 1));
}
filtre.Parametres.RemoveAt(nParametre - 1);
}
else
{
composant.RenommeVariable("@" + nParametre, "@PARAM" + (nParametre));
}
}
return(GetStringExpression(composant, filtre));
}
public override CComposantFiltre GetComposantFiltreFinal(CFiltreData filtre)
{
if (Parametres.Count == 2)
{
string strValeurCherchee = "";
if (Parametres[1] is CComposantFiltreVariable)
{
if (m_nIndexVariableParametre != -1)
{
strValeurCherchee = filtre.Parametres[m_nIndexVariableParametre - 1].ToString();
}
}
else if (Parametres[1] is CComposantFiltreConstante)
{
strValeurCherchee = ((CComposantFiltreConstante)Parametres[1]).Valeur.ToString();
}
else
{
strValeurCherchee = I.T("ERROR IN HASWORDS VALUE|102");
}
if (Parametres[0] is CComposantFiltreChamp)
{
CResultAErreur result = new CAnalyseurRequeteIntuitive().AnalyseChaine(strValeurCherchee);
if (result.Data is CElementRechercheIntuitive)
{
CComposantFiltre cp = ((CElementRechercheIntuitive)result.Data).GetComposantFiltre((CComposantFiltreChamp)Parametres[0]);
return(cp);
}
}
}
return(null);
}
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);
}
//////////////////////////////////////////////////
protected void CopyTo(CFiltreDataAvance filtre)
{
base.CopyTo(filtre);
filtre.m_strTablePrincipale = m_strTablePrincipale;
if (m_composantPrincipal != null)
{
m_composantPrincipal = (CComposantFiltre)CCloner2iSerializable.Clone(m_composantPrincipal);
}
}
/// ///////////////////////////////////////////////////
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);
}
}
/// ////////////////////////////////////////////////////////////////
protected CResultAErreur CalculeComposantPrincipal()
{
m_composantPrincipal = null;
CResultAErreur result = CAnalyseurSyntaxiqueFiltre.AnalyseFormule(Filtre, m_strTablePrincipale);
if (!result)
{
return(result);
}
m_composantPrincipal = (CComposantFiltre)result.Data;
return(result);
}
/// ////////////////////////////////////////////////////////////////
public void ChangeTableDeBase(string strTable, string strRelationPourAllerSurLaNouvelleTable)
{
CComposantFiltre composantPrincipal = ComposantPrincipal;
m_strTablePrincipale = strTable;
foreach (CComposantFiltreChamp champ in composantPrincipal.ExtractExpressionsType(typeof(CComposantFiltreChamp)))
{
champ.EmpileRelation(strTable, strRelationPourAllerSurLaNouvelleTable);
}
base.Filtre = ComposantPrincipal.GetString();
CalculeComposantPrincipal();
}
/// /////////////////////////////////////////////////
public static CResultAErreur AnalyseFormule(string strChaine, string strTableDeBase)
{
CResultAErreur result = CResultAErreur.True;
string strKey = strTableDeBase + "/" + strChaine;
CComposantFiltre composant = (CComposantFiltre)m_tableCache[strKey];
if (composant != null)
{
composant = (CComposantFiltre)CCloner2iSerializable.Clone(composant);
result.Data = composant;
return(result);
}
CAnalyseurSyntaxiqueFiltre analyseur = new CAnalyseurSyntaxiqueFiltre(strTableDeBase);
analyseur.SyntaxeSqlStandard = false;
string strCopie = strChaine;
//Permet de convertir un filtre data en filter data avancé
Regex exNotLike = new Regex("not like", RegexOptions.IgnoreCase);
Regex exNotIn = new Regex("not in", RegexOptions.IgnoreCase);
strCopie = exNotIn.Replace(strCopie, "NotIn");
strCopie = exNotLike.Replace(strCopie, "NotLike");
result = analyseur.AnalyseChaine(strCopie);
if (!result)
{
result.EmpileErreur(I.T("-------------SC2I Syntax-----------------|110"));
analyseur.SyntaxeSqlStandard = true;
CResultAErreur resultStd = analyseur.AnalyseChaine(strChaine);
if (!resultStd)
{
resultStd.EmpileErreur(I.T("-------------SQL Syntax--------------|111"));
result.Erreur += resultStd.Erreur;
}
else
{
result = resultStd;
}
}
if (result.Data is CComposantFiltre)
{
composant = (CComposantFiltre)result.Data;
composant = (CComposantFiltre)CCloner2iSerializable.Clone(composant);
m_tableCache.AddElement(strKey, composant);
}
return(result);
}
public override CComposantFiltre GetComposantFiltre(CComposantFiltreChamp champ)
{
CComposantFiltre droite = null;
if (Parametres.Length > 0 && Parametres[0] != null)
{
droite = Parametres[0].GetComposantFiltre(champ);
}
if (droite != null)
{
CComposantFiltreOperateur op = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurNot);
op.Parametres.Add(droite);
return(op);
}
return(null);
}
////////////////////////////////////////////////////////
public string GetStringAvance(CFiltreDataAvance filtre)
{
CComposantFiltre composant = filtre.ComposantPrincipal;
if (composant == null)
{
return("");
}
//remplace chaque champ par sa valeur
for (int nParametre = 1; nParametre <= filtre.Parametres.Count; nParametre++)
{
(composant).RemplaceVariableParConstante("@" + nParametre, filtre.Parametres[nParametre - 1]);
}
return(GetStringExpression(composant, filtre));
}
////////////////////////////////////////////////////////
public string GetStringAvance(CFiltreDataAvance filtre)
{
CComposantFiltre composant = filtre.ComposantPrincipal;
if (composant == null)
{
return("");
}
//remplace chaque champ par sa valeur
for (int nParametre = filtre.Parametres.Count; nParametre > 0; nParametre--)
{
if (filtre.Parametres[nParametre - 1] is IList)
{
composant.RemplaceVariableParConstante("@" + nParametre, filtre.Parametres[nParametre - 1]);
filtre.Parametres[nParametre - 1] = "";
}
composant.RenommeVariable("@" + nParametre, "@PARAM" + nParametre);
}
return(GetStringExpression(composant, filtre));
}
/// ////////////////////////////////////////////////////////////////
public override CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.Serialize(serializer);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strTablePrincipale);
I2iSerializable obj = m_composantPrincipal;
result = serializer.TraiteObject(ref obj);
m_composantPrincipal = (CComposantFiltre)obj;
return(result);
}
//// ////////////////////////////////////////////////////////////////
private CResultAErreur GetRelations(CComposantFiltre composant, CArbreTable arbre, bool bFillesLeftOuter)
{
CResultAErreur result = CResultAErreur.True;
bool bIsComposantLocalLeftOuter = false;
//Le ou entraine des left outers
if (composant is CComposantFiltreOperateur)
{
CComposantFiltreOperateur op = (CComposantFiltreOperateur)composant;
if (op.Operateur.Id == CComposantFiltreOperateur.c_IdOperateurOu)
{
bIsComposantLocalLeftOuter = true;
}
}
if (composant is CComposantFiltreHasNo)
{
bIsComposantLocalLeftOuter = true;
}
if (composant is CComposantFiltreChamp)
{
CComposantFiltreChamp champ = (CComposantFiltreChamp)composant;
result = IntegreRelationsChamps(arbre, champ, bIsComposantLocalLeftOuter || bFillesLeftOuter);
if (!result)
{
return(result);
}
}
foreach (CComposantFiltre composantFils in composant.Parametres)
{
result = GetRelations(composantFils, arbre, bIsComposantLocalLeftOuter || bFillesLeftOuter);
if (!result)
{
return(result);
}
}
return(result);
}
/// //////////////////////////////////////////////////
public override CResultAErreur GetComposantFiltreData(CFiltreDynamique filtre, CFiltreData filtreData)
{
CResultAErreur result = CResultAErreur.True;
//Vérifie que l'expression condition est OK
CContexteEvaluationExpression contexteEvaluation = new CContexteEvaluationExpression(filtre);
result = ConditionApplication.Eval(contexteEvaluation);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluation of @1|143", ConditionApplication.GetString()));
return(result);
}
if (result.Data == null || !((result.Data is bool && (bool)result.Data) || result.Data.ToString() == "1"))
{
result.Data = null;
return(result);
}
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 override void CreateJoinPourLiens(
CFiltreData filtre,
CArbreTable arbreTables,
CComposantFiltre composantFiltre,
ref bool bDistinct,
ref string strFrom,
ref string strWhere)
{
strFrom = "";
strWhere = "";
foreach (CArbreTableFille arbreFils in arbreTables.TablesLiees)
{
if (arbreFils.Relation.IsRelationFille)
{
bDistinct = true;
}
string strNomTableFils = CContexteDonnee.GetNomTableInDbForNomTable(arbreFils.NomTable);
strNomTableFils = GetPrefixeForTable(arbreFils.NomTable) + strNomTableFils;
strFrom += "," + strNomTableFils + GetSqlForAliasDecl(arbreFils.Alias);
string strSuiteFrom = "";
string strSuiteWhere = "";
CreateJoinPourLiens(filtre, arbreFils, composantFiltre, ref bDistinct, ref strSuiteFrom, ref strSuiteWhere);
if (strSuiteFrom != "")
{
strFrom += strSuiteFrom;
}
if (strWhere.Trim() != "" && strSuiteWhere.Trim() != "")
{
strWhere += " and (" + strSuiteWhere + ")";
}
if (strWhere.Trim() == "" && strSuiteWhere.Trim() != "")
{
strWhere = strSuiteWhere;
}
//Equivalence WHERE ( MACOL = MACOL (+))
CInfoRelationComposantFiltre relation = arbreFils.Relation;
string strAliasParent, strAliasFille;
string strSuffixeParent = "";
string strSuffixeFils = "";
string strTableDependante = "";
if (relation.IsRelationFille)
{
strAliasParent = arbreTables.Alias;
strAliasFille = arbreFils.Alias;
strTableDependante = arbreFils.NomTable;
if (arbreFils.IsLeftOuter)
{
strSuffixeFils = "(+)";
}
}
else
{
strAliasParent = arbreFils.Alias;
strAliasFille = arbreTables.Alias;
strTableDependante = arbreTables.Alias;
if (arbreFils.IsLeftOuter)
{
strSuffixeParent = "(+)";
}
}
string strTmp = relation.GetJoinClause(strAliasParent, strSuffixeParent, strAliasFille, strSuffixeFils);
string strComplementVersion = "";
if (EstCeQueLaTableGereLesVersions(strTableDependante) && !filtre.IntegrerLesElementsSupprimes)
{
strComplementVersion = "(" + strAliasFille + "." + CSc2iDataConst.c_champIsDeleted + "=0 or " +
strAliasFille + "." + CSc2iDataConst.c_champIsDeleted + " is null)";
}
string strIdsVersionsALire = filtre.GetStringListeIdsVersionsALire(',');
if (EstCeQueLaTableGereLesVersions(strTableDependante))
{
if (strComplementVersion != "")
{
strComplementVersion += " and ";
}
if (strIdsVersionsALire == null)
{
strComplementVersion += strAliasFille + "." + CSc2iDataConst.c_champIdVersion + " is null";
}
else
{
strComplementVersion += "(" + strAliasFille + "." + CSc2iDataConst.c_champIdVersion + " in (" + strIdsVersionsALire + ") or " +
strAliasFille + "." + CSc2iDataConst.c_champIdVersion + " is null)";
}
}
if (strComplementVersion != "")
{
if (strTmp != "")
{
strTmp = "((" + strTmp + ") and ";
}
else
{
strAliasFille += "(";
}
strTmp += strComplementVersion + ")";
}
if (strWhere.Trim() != "")
{
strWhere = "(" + strTmp + ") and (" + strWhere + ")";
}
else
{
strWhere = strTmp;
}
if (composantFiltre != null)
{
composantFiltre.DefinitAlias(arbreFils.CheminRelations, arbreFils.Alias);
}
}
}
//--------------------------------------------------
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 CFiltreDataAvance(string strTablePrincipale, CComposantFiltre composantPrincipal, params object[] parametres)
: base(composantPrincipal != null ? composantPrincipal.GetString() : "", parametres)
{
m_composantPrincipal = composantPrincipal;
m_strTablePrincipale = strTablePrincipale;
}
/////////////////////////////////////////////////////////////////////////////////////
public override void CreateJoinPourLiens(
CFiltreData filtre,
CArbreTable arbreTables,
CComposantFiltre composantFiltre,
ref bool bDistinct,
ref string strJoin,
ref string strWhere,
ref string strPrefixeFrom)
{
strJoin = "";
arbreTables.SortTablesLiees();
foreach (CArbreTableFille arbreFils in arbreTables.TablesLiees)
{
strPrefixeFrom += "(";
if (arbreFils.IsLeftOuter)
{
strJoin += " LEFT OUTER JOIN ";
}
else
{
strJoin += " INNER JOIN ";
}
if (arbreFils.Relation.IsRelationFille)
{
bDistinct = true;
}
string strTable;
strTable = CContexteDonnee.GetNomTableInDbForNomTable(arbreFils.NomTable) +
GetSqlForAliasDecl(arbreFils.Alias);
string strSuiteFrom = "";
string strSuiteWhere = "";
string strPrefixe = "";
CreateJoinPourLiens(filtre, arbreFils, composantFiltre, ref bDistinct, ref strSuiteFrom, ref strSuiteWhere, ref strPrefixe);
strJoin += strPrefixe;
if (strSuiteFrom.Trim() != "")
{
strTable = "(" + strTable;
}
strTable += strSuiteFrom;
if (strSuiteFrom.Trim() != "")
{
strTable += ")";
}
strJoin += strTable;
strJoin += " ON (";
CInfoRelationComposantFiltre relation = arbreFils.Relation;
string strAliasParent, strAliasFille;
string strTableDependante = "";
if (relation.IsRelationFille)
{
strAliasParent = arbreTables.Alias;
strAliasFille = arbreFils.Alias;
strTableDependante = arbreFils.NomTable;
}
else
{
strAliasParent = arbreFils.Alias;
strAliasFille = arbreTables.Alias;
strTableDependante = arbreTables.NomTable;
}
string strJointure = relation.GetJoinClause(strAliasParent, "", strAliasFille, "");
string strComplementVersion = "";
if (EstCeQueLaTableGereLesVersions(strTableDependante) && !filtre.IntegrerLesElementsSupprimes)
{
strComplementVersion = "(" + strAliasFille + "." + CSc2iDataConst.c_champIsDeleted + "=0 or " +
strAliasFille + "." + CSc2iDataConst.c_champIsDeleted + " is null)";
}
string strIdsVersionsALire = filtre.GetStringListeIdsVersionsALire(',');
if (EstCeQueLaTableGereLesVersions(strTableDependante))
{
if (strComplementVersion != "")
{
strComplementVersion += " and ";
}
if (strIdsVersionsALire == null)
{
strComplementVersion += strAliasFille + "." + CSc2iDataConst.c_champIdVersion + " is null";
}
else
{
strComplementVersion += "(" + strAliasFille + "." + CSc2iDataConst.c_champIdVersion + " in (" + strIdsVersionsALire + ") or " +
strAliasFille + "." + CSc2iDataConst.c_champIdVersion + " is null)";
}
}
if (strComplementVersion != "")
{
if (strWhere != "")
{
strWhere += " and (" + strComplementVersion + ") and (";
}
else
{
strWhere += "(";
}
strWhere += strComplementVersion + ")";
}
strJoin += strJointure + "))";
if (composantFiltre != null)
{
composantFiltre.DefinitAlias(arbreFils.CheminRelations, arbreFils.Alias);
}
if (filtre is CFiltreDataAvance)
{
foreach (CComposantFiltreChamp champ in ((CFiltreDataAvance)filtre).ChampsAAjouterAArbreTable)
{
champ.DefinitAlias(arbreFils.CheminRelations, arbreFils.Alias);
}
}
}
}
/// //////////////////////////////////////////////////
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);
}
/*///////////////////////////////////////////////////
* 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);
}
/// /////////////////////////////////////////////
///Le data du result contient le filtre
public CResultAErreur GetFiltreData( )
{
CResultAErreur result = CResultAErreur.True;
if (ComposantPrincipal == null)
{
result.Data = null;
return(result);
}
if (m_typeElementsFiltres == null)
{
result.EmpileErreur(I.T("The type of filter elements isn't valid|174"));
return(result);
}
string strTable = CContexteDonnee.GetNomTableForType(m_typeElementsFiltres);
if (strTable == "")
{
result.EmpileErreur(I.T("No table is associated with @1|175", DynamicClassAttribute.GetNomConvivial(m_typeElementsFiltres)));
return(result);
}
CContexteEvaluationExpression ctxEval = new CContexteEvaluationExpression(this);
CFiltreDataAvance filtre = new CFiltreDataAvance(strTable, "");
if (FormuleIntegrerParentsHierarchiques != null)
{
result = FormuleIntegrerParentsHierarchiques.Eval(ctxEval);
if (result && result.Data is bool && (bool)result.Data)
{
filtre.IntergerParentsHierarchiques = true;
}
else
{
filtre.IntergerParentsHierarchiques = false;
}
}
if (FormuleIntegrerFilsHierarchiques != null)
{
result = FormuleIntegrerFilsHierarchiques.Eval(ctxEval);
if (result && result.Data is bool && (bool)result.Data)
{
filtre.IntegrerFilsHierarchiques = true;
}
else
{
filtre.IntegrerFilsHierarchiques = false;
}
}
if (FormuleNeConserverQueLesRacines != null)
{
result = FormuleNeConserverQueLesRacines.Eval(ctxEval);
if (result && result.Data is bool && (bool)result.Data)
{
filtre.NeConserverQueLesRacines = true;
}
else
{
filtre.NeConserverQueLesRacines = false;
}
}
result = CResultAErreur.True;
result = m_composantFiltre.GetComposantFiltreData(this, filtre);
if (!result)
{
result.Data = null;
result.EmpileErreur(I.T("Error in filter|176"));
return(result);
}
CComposantFiltre composant = (CComposantFiltre)result.Data;
if (composant == null)
{
filtre.Filtre = "1=1";
}
else
{
filtre.ComposantPrincipal = composant;
}
result.Data = filtre;
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 override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] listeParametres)
{
CResultAErreur result = CResultAErreur.True;
try
{
string strVal = listeParametres[0].ToString();
Type tp = listeParametres[0] as Type;
if (tp == null)
{
tp = CActivatorSurChaine.GetType(strVal, true);
}
if (tp == null)
{
tp = CActivatorSurChaine.GetType(strVal, false);
}
if (tp == null)
{
result.EmpileErreur(I.T("The @1 type does not exist|221", strVal));
return(result);
}
string strTable = CContexteDonnee.GetNomTableForType(tp);
if (strTable == null)
{
result.EmpileErreur(I.T("The @1 type is not associated with a table|225", strVal));
return(result);
}
CFiltreDataAvance filtreAvance = new CFiltreDataAvance(strTable, listeParametres[1].ToString());
for (int n = 2; n < listeParametres.Length; n++)
{
filtreAvance.Parametres.Add(listeParametres[n]);
}
CComposantFiltre c = filtreAvance.ComposantPrincipal;
CContexteDonnee contexteDonnee = null;
if (ctx.ObjetSource is IObjetAContexteDonnee)
{
contexteDonnee = ((IObjetAContexteDonnee)ctx.ObjetSource).ContexteDonnee;
}
if (contexteDonnee == null)
{
contexteDonnee = (CContexteDonnee)ctx.GetObjetAttache(typeof(CContexteDonnee));
}
if (contexteDonnee == null)
{
contexteDonnee = new CContexteDonnee(CSessionClient.GetSessionUnique().IdSession, true, false);
ctx.AttacheObjet(typeof(CContexteDonnee), contexteDonnee);
}
CFiltreData filtre = null;
if (filtreAvance.HasFiltre)
{
filtre = filtreAvance;
}
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteDonnee, tp, filtre);
result.Data = liste;
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
