public CListeObjetsDonnees GetElementsLiesFor(Object obj)
{
if (obj == null)
{
return(null);
}
if (obj.GetType() != TypeElementsSourceRecherche)
{
return(null);
}
//Calcule le filtre
try
{
CFiltreDynamique filtreDyn = FiltreDynamique;
IElementAVariablesDynamiquesAvecContexteDonnee eltAVariables = GetElementAVariableSource(obj);
filtreDyn.ElementAVariablesExterne = eltAVariables;
if (filtreDyn != null)
{
CResultAErreur result = filtreDyn.GetFiltreData();
if (result && result.Data is CFiltreData)
{
CListeObjetsDonnees liste = new CListeObjetsDonnees(ContexteDonnee, TypeElements, (CFiltreData)result.Data);
return(liste);
}
}
}
catch { }
return(null);
}
/// /////////////////////////////////////////
public CResultAErreur GetDonnees(
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariables,
CListeObjetsDonnees listeDonnees,
IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
CListeObjetsDonnees liste = listeDonnees;
if ((liste == null || liste.TypeObjets != Structure.TypeSource) && Structure.TypeSource != null)
{
liste = new CListeObjetsDonnees(elementAVariables.ContexteDonnee, m_structure.TypeSource);
if (m_filtre != null)
{
m_filtre.ElementAVariablesExterne = elementAVariables;
result = m_filtre.GetFiltreData();
if (!result)
{
return(result);
}
liste.Filtre = (CFiltreData)result.Data;
}
}
if (Structure.TypeSource == null)
{
liste = null;
}
DataSet ds = new DataSet();
int nIdSession = -1;
if (elementAVariables != null && elementAVariables.ContexteDonnee != null)
{
nIdSession = elementAVariables.ContexteDonnee.IdSession;
}
else
{
nIdSession = CSessionClient.GetSessionUnique().IdSession;
}
result = m_structure.Export(nIdSession, liste, ref ds, elementAVariables, indicateur);
if (!result)
{
return(result);
}
result.Data = ds;
return(result);
}
/// ///////////////////////////////////////////
public object GetValeur(IElementAVariablesDynamiquesAvecContexteDonnee elementInterroge)
{
if (m_filtreDynamique == null)
{
return(null);
}
m_filtreDynamique.ElementAVariablesExterne = elementInterroge;
CResultAErreur result = m_filtreDynamique.GetFiltreData();
if (!result)
{
return(null);
}
CListeObjetsDonnees liste = new CListeObjetsDonnees(elementInterroge.ContexteDonnee, m_filtreDynamique.TypeElements);
liste.Filtre = (CFiltreData)result.Data;
return(liste.ToArray(m_filtreDynamique.TypeElements));
}
/// /////////////////////////////////////////////////////////////
public CFiltreData GetFiltrePourListe()
{
CFiltreData filtre = new CFiltreData();
if (IsDynamique)
{
CFiltreDynamique filtreDyn = FiltreDynamique;
CResultAErreur result = filtreDyn.GetFiltreData();
if (result.Data is CFiltreData)
{
filtre = (CFiltreData)result.Data;
}
}
else
{
string strChampId = "";
StringBuilder bl = new StringBuilder();
CStructureTable structure = CStructureTable.GetStructure(TypeElements);
strChampId = structure.ChampsId[0].NomChamp;
foreach (CRelationListeEntites_Entite rel in RelationsEntites)
{
bl.Append(rel.IdElement);
bl.Append(',');
}
if (bl.Length > 0)
{
bl.Remove(bl.Length - 1, 1);
}
if (bl.Length > 0)
{
filtre = new CFiltreData(strChampId + " in (" + bl.ToString() + ")");
}
else
{
filtre = new CFiltreDataImpossible();
}
}
return(filtre);
}
/// <summary>
/// retourne l'objet donné sélectionné à partir de la valeur retournée
/// </summary>
/// <remarks>
/// Ne fonctionne pas toujours, ça ne fonctionne que si la valeur retournée
/// est un champ DOTNET de l'entité sélectionnée
/// </remarks>
/// <param name="valeurRetournee"></param>
/// <param name="contexte"></param>
/// <returns></returns>
public CReferenceObjetDonnee GetObjetFromValeurRetournee(object valeurRetournee)
{
if (valeurRetournee == null)
{
return(null);
}
C2iExpressionChamp exp = ExpressionRetournee as C2iExpressionChamp;
if (exp != null)
{
CDefinitionProprieteDynamique propDyn = exp.DefinitionPropriete;
CDefinitionProprieteDynamiqueDotNet defDotNet = propDyn as CDefinitionProprieteDynamiqueDotNet;
if (defDotNet != null)
{
CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(m_filtreSelection.TypeElements, new object[] { CContexteDonneeSysteme.GetInstance() });
CStructureTable structure = CStructureTable.GetStructure(m_filtreSelection.TypeElements);
CInfoChampTable info = structure.GetChampFromPropriete(defDotNet.NomProprieteSansCleTypeChamp);
if (info != null)
{
CResultAErreur result = m_filtreSelection.GetFiltreData();
CFiltreData filtre = null;
if (result && result.Data is CFiltreData)
{
filtre = result.Data as CFiltreData;
}
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreData(info.NomChamp + "=@1",
valeurRetournee));
if (objet.ReadIfExists(filtre))
{
return(new CReferenceObjetDonnee(objet));
}
}
}
}
return(null);
}
////////////////////////////////////////////////////////////////////////
/// <summary>
/// Retourne les filtres finaux pour toutes les tables
//Le data du result contient les filtresdata finaux
/// </summary>
/// <param name="nIdSession"></param>
/// <param name="nIdUtilisateur">Id de l'utilisateur</param>
/// <param name="listeUsersGroupe">Id des utilisateurs associés à celui ci</param>
/// <returns></returns>
public CResultAErreur GetFiltresFinaux(int nIdSession, CGroupeUtilisateursSynchronisation groupe)
{
CResultAErreur result = CResultAErreur.True;
try
{
using (CContexteDonnee contexte = new CContexteDonnee(nIdSession, true, false))
{
CFiltresDynamiquesForTables filtresForTables = CalculeFiltresForTables();
CFiltresSynchronisation filtres = new CFiltresSynchronisation();
foreach (string strNomTable in CContexteDonnee.MappeurTableToClass.GetListeTables())
{
bool bShouldImporte = false;
CFiltreDynamique filtreDynamique = filtresForTables.GetFiltreDynamiqueForTable(strNomTable, ref bShouldImporte);
if (!bShouldImporte)
{
filtres.AddFiltreForTable(strNomTable, new CFiltreDataImpossible(), true);
}
else
{
if (filtreDynamique == null)
{
filtres.AddFiltreForTable(strNomTable, null, true);
}
else
{
//Trouve la variable contenant le groupe
CVariableDynamique variable = null;
foreach (CVariableDynamique v in filtreDynamique.ListeVariables)
{
if (v.Nom == CFiltreSynchronisation.c_nomVariableListeUtilisateurs)
{
variable = v;
}
}
filtreDynamique.SetValeurChamp(variable, groupe.ListeIdsUtilisateurs);
filtreDynamique.ContexteDonnee = contexte;
CResultAErreur resultTmp = filtreDynamique.GetFiltreData();
CFiltreData filtreData = null;
if (!result)
{
result.Erreur.EmpileErreurs(resultTmp.Erreur);
result.EmpileErreur(I.T("Error in table @1|189", strNomTable));
}
else
{
filtreData = (CFiltreData)resultTmp.Data;
filtres.AddFiltreForTable(strNomTable, filtreData, true);
}
}
}
}
result.Data = filtres;
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
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);
}
//-----------------------------------------------------------------
/// <summary>
/// Le data du result contient le datatable correspondant à ce paramètre de visu
/// </summary>
/// <returns></returns>
public CResultAErreur GetDataTable(CContexteDonnee contexteDonnee)
{
CResultAErreur result = CResultAErreur.True;
CTypeDonneeCumulee typeDonnee = GetTypeDonneeCumulee(contexteDonnee);
if (typeDonnee == null)
{
result.EmpileErreur(I.T("Unable to load Precalculated data type|20041"));
return(result);
}
CListeObjetsDonnees lstDatas = new CListeObjetsDonnees(
contexteDonnee,
typeof(CDonneeCumulee),
new CFiltreData(CTypeDonneeCumulee.c_champId + "=@1", m_nIdTypeDonneeCumulee));
CParametreDonneeCumulee parametre = typeDonnee.Parametre;
#region Filtrage des données
CFiltreData filtreDonnees = null;
int nCle = 0;
foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
{
if (cle.Champ != null && cle.Champ != "")
{
CFiltreDonneePrecalculee filtreBase = m_listeFiltresDeBase.FirstOrDefault(f => f.ChampAssocie == cle.Champ);
CFiltreDonneePrecalculee filtreUser = m_listeFiltresUser.FirstOrDefault(f => f.ChampAssocie == cle.Champ);
CFiltreDynamique filtreDynBase = filtreBase != null ? filtreBase.Filtre : null;
CFiltreDynamique filtreDynUser = filtreUser != null ? filtreUser.Filtre : null;
CFiltreData filtre = null;
if (filtreDynUser != null && filtreDynUser.ComposantPrincipal != null)
{
result = filtreDynUser.GetFiltreData();
if (result)
{
filtre = result.Data as CFiltreData;
}
}
if (filtreDynBase != null && filtreDynBase.ComposantPrincipal != null)
{
result = filtreDynBase.GetFiltreData();
if (result)
{
filtre = CFiltreData.GetAndFiltre(filtre, result.Data as CFiltreData);
}
}
if (filtre != null && filtre.HasFiltre)
{
//Crée une liste d'objets correspondant au filtre
CListeObjetsDonnees lst = new CListeObjetsDonnees(contexteDonnee, cle.TypeLie);
lst.Filtre = filtre;
StringBuilder bl = new StringBuilder();
foreach (CObjetDonneeAIdNumerique obj in lst)
{
bl.Append(obj.Id);
bl.Append(',');
}
filtre = null;
if (bl.Length == 0)
{
filtre = new CFiltreDataImpossible();
filtreDonnees = new CFiltreDataImpossible();
}
else
{
bl.Remove(bl.Length - 1, 1);
filtre = new CFiltreData(CDonneeCumulee.GetNomChampCle(nCle) + " in (" + bl.ToString() + ")");
filtreDonnees = CFiltreData.GetAndFiltre(filtreDonnees, filtre);
}
}
}
nCle++;
}
#endregion
if (filtreDonnees != null)
{
lstDatas.Filtre = filtreDonnees;
}
//Crée le datatable de base
DataTable table = new DataTable();
Dictionary <string, string> dicChampsACopier = new Dictionary <string, string>();
nCle = 0;
foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
{
if (cle.Champ != "")
{
DataColumn col = new DataColumn(cle.Champ, typeof(string));
table.Columns.Add(col);
dicChampsACopier[CDonneeCumulee.GetNomChampCle(nCle)] = col.ColumnName;
}
nCle++;
}
foreach (CParametreDonneeCumulee.CNomChampCumule nom in parametre.NomChampsDecimaux)
{
if (nom.NomChamp != "")
{
DataColumn col = new DataColumn(nom.NomChamp, typeof(double));
table.Columns.Add(col);
dicChampsACopier[CDonneeCumulee.GetNomChampValeur(nom.NumeroChamp)] = nom.NomChamp;
}
}
foreach (CParametreDonneeCumulee.CNomChampCumule nom in parametre.NomChampsDates)
{
if (nom.NomChamp != "")
{
DataColumn col = new DataColumn(nom.NomChamp, typeof(DateTime));
table.Columns.Add(col);
dicChampsACopier[CDonneeCumulee.GetNomChampDate(nom.NumeroChamp)] = nom.NomChamp;
}
}
foreach (CParametreDonneeCumulee.CNomChampCumule nom in parametre.NomChampsTextes)
{
if (nom.NomChamp != "")
{
DataColumn col = new DataColumn(nom.NomChamp, typeof(string));
table.Columns.Add(col);
dicChampsACopier[CDonneeCumulee.GetNomChampTexte(nom.NumeroChamp)] = nom.NomChamp;
}
}
foreach (CDonneeCumulee donnee in lstDatas)
{
DataRow rowSource = donnee.Row.Row;
DataRow rowDest = table.NewRow();
foreach (KeyValuePair <string, string> kv in dicChampsACopier)
{
rowDest[kv.Value] = rowSource[kv.Key];
}
table.Rows.Add(rowDest);
}
result = m_tableauCroise.CreateTableCroisee(table);
if (OperationCumul != OperationsAgregation.None)
{
DataTable tableFinale = result.Data as DataTable;
DataRow row = tableFinale.NewRow();
bool bHeaderFait = false;
foreach (DataColumn col in tableFinale.Columns)
{
CChampFinalDeTableauCroiseDonnee champDonnee = col.ExtendedProperties[CTableauCroise.c_ExtendedPropertyToColumnKey] as CChampFinalDeTableauCroiseDonnee;
if (champDonnee != null)
{
CDonneeAgregation donnee = CDonneeAgregation.GetNewDonneeForOperation(OperationCumul);
donnee.PrepareCalcul();
foreach (DataRow rowTmp in tableFinale.Rows)
{
donnee.IntegreDonnee(rowTmp[col]);
}
row[col] = donnee.GetValeurFinale();
}
else if (!bHeaderFait)
{
row[col] = m_strLibelleTotal;
bHeaderFait = true;
}
}
tableFinale.Rows.Add(row);
}
return(result);
}
