//------------------------------------------------------------
public CResultAErreur GetValue(object objet, string strPropriete)
{
CResultAErreur result = CResultAErreur.True;
CObjetDonneeAIdNumerique objetDonnee = objet as CObjetDonneeAIdNumerique;
if (objetDonnee == null)
{
return(result);
}
//traduit la propriété : Id du type | Numéro de clé
int nIdType = -1;
int nNumCle = -1;
try
{
string[] strProps = strPropriete.Split('|');
nIdType = Int32.Parse(strProps[0]);
nNumCle = Int32.Parse(strProps[1]);
}
catch
{
result.EmpileErreur(I.T("Bad cumulated data field @1|20026", strPropriete));
return(result);
}
CTypeDonneeCumulee type = new CTypeDonneeCumulee(objetDonnee.ContexteDonnee);
if (!type.ReadIfExists(nIdType))
{
result.EmpileErreur(I.T("Cumulated data type @1 doesn't exists|20027", nIdType.ToString()));
return(result);
}
result.Data = type.GetDonneesCumuleesForObjet(objetDonnee);
return(result);
}
//---------------------------------------
public DataTable GetDataTableModelePourParametrage(CContexteDonnee contexte)
{
if (m_nIdTypeDonneeCumulee == null)
{
return(null);
}
CTypeDonneeCumulee typeDonnee = GetTypeDonneeCumulee(contexte);
if (typeDonnee == null)
{
return(null);
}
DataTable table = new DataTable();
CParametreDonneeCumulee parametreDonnee = typeDonnee.Parametre;
if (parametreDonnee == null)
{
return(null);
}
foreach (CCleDonneeCumulee cle in parametreDonnee.ChampsCle)
{
if (cle.Champ != "")
{
DataColumn col = new DataColumn(cle.Champ, typeof(string));
col.AllowDBNull = true;
table.Columns.Add(col);
}
}
foreach (CParametreDonneeCumulee.CNomChampCumule champ in parametreDonnee.NomChampsDecimaux)
{
string strChamp = parametreDonnee.GetValueField(champ.NumeroChamp);
if (strChamp != null && strChamp != "")
{
DataColumn col = new DataColumn(champ.NomChamp, typeof(double));
col.AllowDBNull = true;
table.Columns.Add(col);
}
}
foreach (CParametreDonneeCumulee.CNomChampCumule champ in parametreDonnee.NomChampsDates)
{
string strChamp = parametreDonnee.GetDateField(champ.NumeroChamp);
if (strChamp != null && strChamp != "")
{
DataColumn col = new DataColumn(champ.NomChamp, typeof(DateTime));
col.AllowDBNull = true;
table.Columns.Add(col);
}
}
foreach (CParametreDonneeCumulee.CNomChampCumule champ in parametreDonnee.NomChampsTextes)
{
string strChamp = parametreDonnee.GetTextField(champ.NumeroChamp);
if (strChamp != null && strChamp != "")
{
DataColumn col = new DataColumn(champ.NomChamp, typeof(string));
col.AllowDBNull = true;
table.Columns.Add(col);
}
}
return(table);
}
//---------------------------------------
private void InitFiltres()
{
CTypeDonneeCumulee typeDonnee = GetTypeDonneeCumulee(CContexteDonneeSysteme.GetInstance());
if (typeDonnee == null)
{
m_listeFiltresDeBase.Clear();
m_listeFiltresUser.Clear();
return;
}
CParametreDonneeCumulee parametre = typeDonnee.Parametre;
Dictionary <string, bool> dicToDelete = new Dictionary <string, bool>();
foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresDeBase)
{
dicToDelete[filtre.ChampAssocie] = true;
}
foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresUser)
{
dicToDelete[filtre.ChampAssocie] = true;
}
foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
{
if (cle.TypeLie != null)
{
CFiltreDonneePrecalculee filtre = m_listeFiltresDeBase.FirstOrDefault(f => f.ChampAssocie == cle.Champ);
if (filtre != null)
{
dicToDelete[filtre.ChampAssocie] = false;
}
if (m_listeFiltresDeBase.Count(f => f.ChampAssocie == cle.Champ) == 0)
{
CFiltreDynamique filtreTmp = new CFiltreDynamique();
filtreTmp.TypeElements = cle.TypeLie;
m_listeFiltresDeBase.Add(new CFiltreDonneePrecalculee(cle.Champ, cle.Champ, filtreTmp));
}
if (m_listeFiltresUser.Count(f => f.ChampAssocie == cle.Champ) == 0)
{
CFiltreDynamique filtreTmp = new CFiltreDynamique();
filtreTmp.TypeElements = cle.TypeLie;
m_listeFiltresUser.Add(new CFiltreDonneePrecalculee(cle.Champ, cle.Champ, filtreTmp));
}
}
}
foreach (KeyValuePair <string, bool> kv in dicToDelete)
{
if (kv.Value)
{
foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresUser.FindAll(f => f.ChampAssocie == kv.Key).ToArray())
{
m_listeFiltresUser.Remove(filtre);
}
foreach (CFiltreDonneePrecalculee filtre in m_listeFiltresDeBase.FindAll(f => f.ChampAssocie == kv.Key).ToArray())
{
m_listeFiltresDeBase.Remove(filtre);
}
}
}
}
/// //////////////////////////////////////////////////////
public CDefinitionProprieteDynamiqueDonneeCumulee(CTypeDonneeCumulee td, int nNumeroCle)
: base(td.Libelle.Replace(" ", "_"),
td.Id + "|" + nNumeroCle,
new CTypeResultatExpression(typeof(CDonneeCumulee), true), true, true)
{
m_dbKeyTypeDonneeCumulee = td.DbKey;
Rubrique = I.T("Cumulated data|163");
}
public CTypeDonneeCumulee GetTypeDonneeCumulee(CContexteDonnee ctx)
{
if (m_nIdTypeDonneeCumulee == null)
{
return(null);
}
CTypeDonneeCumulee typeDonnee = new CTypeDonneeCumulee(ctx);
if (typeDonnee.ReadIfExists(m_nIdTypeDonneeCumulee.Value))
{
return(typeDonnee);
}
return(null);
}
public object GetValue(object objet)
{
CObjetDonneeAIdNumerique objetDonnee = objet as CObjetDonneeAIdNumerique;
if (objetDonnee == null)
{
return(null);
}
CTypeDonneeCumulee type = new CTypeDonneeCumulee(objetDonnee.ContexteDonnee);
if (type.ReadIfExists(m_nIdTypeDonnee))
{
return(type.GetDonneesCumuleesForObjet(objetDonnee));
}
return(null);
}
/// ////////////////////////////////////////
private void CreateTableConversionNoms()
{
m_tableConversionNoms = new Hashtable();
using (CContexteDonnee contexte = new CContexteDonnee(sc2i.multitiers.client.CSessionClient.GetSessionUnique().IdSession, true, false))
{
CTypeDonneeCumulee type = new CTypeDonneeCumulee(contexte);
if (type.ReadIfExists(m_dbKeyTypeDonneeCumulee))
{
CParametreDonneeCumulee parametre = type.Parametre;
foreach (CParametreDonneeCumulee.CNomChampCumule cle in parametre.Cles)
{
if (cle.NomChamp != "")
{
m_tableConversionNoms[I.T("Key|45") + cle.NumeroChamp.ToString()] = cle.NomChamp;
}
}
foreach (CParametreDonneeCumulee.CNomChampCumule valeur in parametre.NomChampsDecimaux)
{
if (valeur.NomChamp != "")
{
m_tableConversionNoms[I.T("Value|40") + valeur.NumeroChamp.ToString()] = valeur.NomChamp;
}
}
foreach (CParametreDonneeCumulee.CNomChampCumule valeur in parametre.NomChampsDates)
{
if (valeur.NomChamp != "")
{
m_tableConversionNoms[I.T("Date|245") + valeur.NumeroChamp.ToString()] = valeur.NomChamp;
}
}
foreach (CParametreDonneeCumulee.CNomChampCumule valeur in parametre.NomChampsTextes)
{
if (valeur.NomChamp != "")
{
m_tableConversionNoms[I.T("Text|246") + valeur.NumeroChamp.ToString()] = valeur.NomChamp;
}
}
}
}
}
/// <summary>
/// Prépare le paramètre de visu pour afficher les données demandées
/// fait les chargements à faire, et tout et tout
/// </summary>
/// <param name="table"></param>
public CResultAErreur PrepareAffichageDonnees(
DataTable table,
CContexteDonnee contexte)
{
CResultAErreur result = CResultAErreur.True;
CTypeDonneeCumulee typeDonnee = GetTypeDonneeCumulee(contexte);
if (typeDonnee == null)
{
result.EmpileErreur(I.T("Can not find Cumulated data type|20041"));
}
CParametreDonneeCumulee parametreDonnee = typeDonnee.Parametre;
foreach (CParametreVisuChampTableauCroise paramVisu in ParametresChamps)
{
result = paramVisu.PrepareAffichageDonnees(table, contexte, parametreDonnee, this);
if (!result)
{
return(result);
}
}
return(result);
}
/// //////////////////////////////////////////
public override CResultAErreur MyEval(CContexteEvaluationExpression ctx, object[] listeParametres)
{
CResultAErreur result = CResultAErreur.True;
try
{
CContexteDonnee contexteDonnee = (CContexteDonnee)ctx.GetObjetAttache(typeof(CContexteDonnee));
if (contexteDonnee == null)
{
if (ctx.ObjetSource != null && ctx.ObjetSource is IObjetAContexteDonnee)
{
contexteDonnee = ((IObjetAContexteDonnee)ctx.ObjetSource).ContexteDonnee;
}
else
{
contexteDonnee = new CContexteDonnee(CSessionClient.GetSessionUnique().IdSession, true, false);
}
ctx.AttacheObjet(typeof(CContexteDonnee), contexteDonnee);
}
/*//Cherche un objet donnée dans le contexte d'évaluation pour pouvoir
* //avoir un contexte de donnee;
* if ( !(ctx.ObjetSource is CObjetDonnee) )
* {
* result.EmpileErreur("Impossible de récupérer une donnée de production si la source de la formule n'est pas un objet donnee");
* return result;
* }
* CContexteDonnee contexte = ((CObjetDonnee)ctx.ObjetSource).ContexteDonnee;*/
bool bHasNoReadInDb = listeParametres[0] is bool;
bool bNePasLireEnBase = bHasNoReadInDb ? (bool)listeParametres[0] : false;
int nStartParam = bHasNoReadInDb ? 1 : 0;
CTypeDonneeCumulee typeDonnee = new CTypeDonneeCumulee(contexteDonnee);
if (!typeDonnee.ReadIfExists(new CFiltreData(CTypeDonneeCumulee.c_champCode + "=@1",
listeParametres[0 + nStartParam].ToString())))
{
result.EmpileErreur(I.T("The cumulated data type @1 does not exist|218", listeParametres[0 + nStartParam].ToString()));
return(result);
}
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteDonnee, typeof(CDonneeCumulee));
CFiltreData filtre = new CFiltreData(
CTypeDonneeCumulee.c_champId + "=@1", typeDonnee.Id);
//Indice de la clé
int nCle = 0;
CParametreDonneeCumulee parametre = typeDonnee.Parametre;
for (int nParam = nStartParam + 2; nParam < listeParametres.Length; nParam++)
{
if (listeParametres[nParam] != null)
{
CCleDonneeCumulee cle = parametre.GetChampCle(nCle);
while ((cle == null || cle.Champ == "") && nCle < CParametreDonneeCumulee.c_nbChampsCle)
{
nCle++;
cle = parametre.GetChampCle(nCle);
}
if (nCle > CParametreDonneeCumulee.c_nbChampsCle)
{
break;
}
else
{
if (cle.Champ != "")
{
filtre.Filtre += " and " + CDonneeCumulee.c_baseChampCle + nCle.ToString() + "=@" +
(filtre.Parametres.Count + 1).ToString();
filtre.Parametres.Add(listeParametres[nParam].ToString());
}
nCle++;
}
}
}
liste.Filtre = filtre;
liste.InterditLectureInDB = bNePasLireEnBase;
if (liste.Count > 0)
{
CDonneeCumulee donnee = (CDonneeCumulee)liste[0];
int nParam = Convert.ToInt32(listeParametres[nStartParam + 1]);
if (nParam < 0 || nParam > CParametreDonneeCumulee.c_nbChampsValeur)
{
result.EmpileErreur(I.T("The cumulated data has no value @1|219", nParam.ToString()));
return(result);
}
result.Data = (double)donnee.Row[CDonneeCumulee.c_baseChampValeur + nParam.ToString()];
}
else
{
result.Data = (double)0;
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
return(result);
}
/// <summary>
/// récupère un objet pour formule liée à la cellule
///
/// </summary>
/// <param name="paramVisu"></param>
/// <param name="row">Ligne contenant les données (peut être nul en design)</param>
/// <param name="nCol">Numéro de colonne où se trouve la donnée (peut être null en design)</param>
/// <returns></returns>
public CElementAVariablesDynamiques GetObjetPourFormuleCellule
(
CParametreVisuDonneePrecalculee paramVisu,
DataRow row,
int?nCol)
{
CElementAVariablesDynamiques eltAVariables = new CElementAVariablesDynamiques();
CTypeDonneeCumulee typeDonnee = paramVisu.GetTypeDonneeCumulee(CContexteDonneeSysteme.GetInstance());
if (typeDonnee == null)
{
return(null);
}
CParametreDonneeCumulee parametreDonnee = typeDonnee.Parametre;
//Ajoute les clés
CChampFinalDeTableauCroise[] champsFinaux = paramVisu.TableauCroise.ChampsFinaux;
int nIdVariable = 0;
foreach (CChampFinalDeTableauCroise champFinal in champsFinaux)
{
CChampFinalDeTableauCroiseCle champCle = champFinal as CChampFinalDeTableauCroiseCle;
if (champCle != null)
{
CCleDonneeCumulee cle = parametreDonnee.GetChampCle(champCle.NomChamp);
if (cle != null)
{
CVariableDynamiqueSysteme variable = new CVariableDynamiqueSysteme(eltAVariables);
variable.Nom = champCle.NomChamp;
variable.IdVariable = nIdVariable.ToString();
nIdVariable++;
if (cle.TypeLie != null)
{
variable.SetTypeDonnee(new CTypeResultatExpression(cle.TypeLie, false));
}
else
{
variable.SetTypeDonnee(new CTypeResultatExpression(typeof(int), false));
}
eltAVariables.AddVariable(variable);
if (row != null && row.Table.Columns.Contains(champCle.NomChamp))
{
object val = row[champCle.NomChamp];;
if (cle.TypeLie != null)
{
try
{
if (val != DBNull.Value)
{
val = paramVisu.GetFromCache(cle.TypeLie, Int32.Parse((val.ToString())));
}
}
catch { }
}
else
if (val != DBNull.Value)
{
val = val.ToString();
}
//TESTDBKEYOK (SC)
eltAVariables.SetValeurChamp(variable.IdVariable, val);
}
}
}
}
//Ajoute la valeur de colonne pivot (s'il y a lieu )
CChampFinalDeTableauCroiseDonnee champAvecPivot = ChampFinal as CChampFinalDeTableauCroiseDonnee;
if (champAvecPivot != null && champAvecPivot.Pivot != null)
{
CCleDonneeCumulee cle = parametreDonnee.GetChampCle(champAvecPivot.Pivot.NomChamp);
if (cle != null)
{
CVariableDynamiqueSysteme variable = new CVariableDynamiqueSysteme(eltAVariables);
variable.Nom = champAvecPivot.Pivot.NomChamp;
variable.IdVariable = nIdVariable.ToString();
nIdVariable++;
if (cle.TypeLie != null)
{
variable.SetTypeDonnee(new CTypeResultatExpression(cle.TypeLie, false));
}
else
{
variable.SetTypeDonnee(new CTypeResultatExpression(typeof(string), false));
}
eltAVariables.AddVariable(variable);
if (row != null && nCol != null)
{
DataColumn col = row.Table.Columns[nCol.Value];
CChampFinalDetableauCroiseDonneeAvecValeur cv = col.ExtendedProperties[CTableauCroise.c_ExtendedPropertyToColumnKey] as CChampFinalDetableauCroiseDonneeAvecValeur;
if (cv != null)
{
object val = cv.ValeurPivot;
if (cle.TypeLie != null)
{
try
{
if (val != null)
{
val = paramVisu.GetFromCache(cle.TypeLie, Int32.Parse(val.ToString()));
}
}
catch
{
}
}
else
if (val != null)
{
val = val.ToString();
}
eltAVariables.SetValeurChamp(variable.IdVariable, val);
}
}
}
}
//Ajoute la valeur de la colonne
CVariableDynamiqueSysteme variableValue = new CVariableDynamiqueSysteme(eltAVariables);
variableValue.Nom = c_nomVariableValue;
variableValue.IdVariable = nIdVariable.ToString();
nIdVariable++;
variableValue.SetTypeDonnee(new CTypeResultatExpression(typeof(double), false));
eltAVariables.AddVariable(variableValue);
try
{
eltAVariables.SetValeurChamp(variableValue.IdVariable, Convert.ToDouble(row[nCol.Value]));
}
catch
{
}
//Ajoute les variables de filtre
foreach (CFiltreDonneePrecalculee filtreDonnee in paramVisu.FiltresUtilisateur)
{
foreach (IVariableDynamique variable in filtreDonnee.Filtre.ListeVariables)
{
CVariableDeFiltreDeportee v = new CVariableDeFiltreDeportee(eltAVariables);
v.Nom = variable.Nom;
v.SetTypeDonnee(variable.TypeDonnee);
v.ChampAssocieAuFiltre = filtreDonnee.ChampAssocie;
eltAVariables.AddVariable(v);
eltAVariables.SetValeurChamp(v.IdVariable, filtreDonnee.Filtre.GetValeurChamp(variable.IdVariable));
}
}
return(eltAVariables);
}
//----------------------------------------------------------------------------------
public virtual CResultAErreur InsertDataInDataSet(
IEnumerable list,
DataSet ds,
ITableExport tableParente,
int[] nValeursCle,
RelationAttribute relationToObjetParent,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablePourFiltres,
CCacheValeursProprietes cacheValeurs,
ITableExport tableFilleANePasCharger,
bool bAvecOptimisation,
CConteneurIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
if (NePasCalculer)
{
return(result);
}
if (tableParente != null && nValeursCle.Length == 0)
{
return(result);
}
DataTable table = ds.Tables[NomTable];
if (table == null)
{
result.EmpileErreur(I.T("Table @1 doesn't exist|116", NomTable));
return(result);
}
indicateur.SetInfo(I.T("Table @1|115", NomTable));
if (nValeursCle.Length > 1 &&
relationToObjetParent == null)
{
result.EmpileErreur(I.T("Error: Multiple child table loading without knowing the relation indicating how the parental link is established|117"));
return(result);
}
DataColumn colFilleDeContrainte = null;
DataTable tableFilleDeContrainte = null;
if (tableParente != null)
{
if (ChampOrigine.TypeDonnee.IsArrayOfTypeNatif || !bAvecOptimisation ||
ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
//On est dans une relation fille
foreach (Constraint constraint in table.Constraints)
{
if (constraint is ForeignKeyConstraint)
{
ForeignKeyConstraint fkConst = (ForeignKeyConstraint)constraint;
if (fkConst.RelatedTable.TableName == tableParente.NomTable)
{
colFilleDeContrainte = fkConst.Columns[0];
break;
}
}
}
tableFilleDeContrainte = table;
}
else
{
//On est dans une relation parente
DataTable tblP = ds.Tables[tableParente.NomTable];
foreach (Constraint contraint in tblP.Constraints)
{
if (contraint is ForeignKeyConstraint)
{
ForeignKeyConstraint fk = (ForeignKeyConstraint)contraint;
if (fk.RelatedTable.TableName == table.TableName)
{
colFilleDeContrainte = fk.Columns[0];
tableFilleDeContrainte = tblP;
break;
}
}
}
}
}
if (list == null)
{
return(result);
}
//Désactive les ids auto sur les objetDonneeAIdNumerique.
//Car on utilise alors les valeurs de clé des éléments
bool bUtiliserIdObjets = false;
if (bAvecOptimisation && (ChampOrigine == null || ChampOrigine.NomPropriete.IndexOf('.') < 0 || !ChampOrigine.TypeDonnee.IsArrayOfTypeNatif))
{
if (list is CListeObjetsDonnees && (tableParente == null || colFilleDeContrainte == null))
{
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(((CListeObjetsDonnees)list).TypeObjets))
{
table.PrimaryKey[0].AutoIncrement = false;
bUtiliserIdObjets = true;
}
}
if (list is ArrayList)
{
ArrayList arrL = (ArrayList)list;
if (arrL.Count > 0 &&
typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(arrL[0].GetType()))
{
table.PrimaryKey[0].AutoIncrement = false;
bUtiliserIdObjets = true;
}
}
}
if (FiltreAAppliquer != null)
{
CListeObjetsDonnees listeObjetsDonnee = list as CListeObjetsDonnees;
if (listeObjetsDonnee == null)//Tente de convertir en liste d'objets
{
//Récupère le contexte de données
CContexteDonnee ctx = null;
foreach (object obj in list)
{
IObjetAContexteDonnee objACtx = obj as IObjetAContexteDonnee;
if (objACtx != null)
{
ctx = objACtx.ContexteDonnee;
break;
}
}
listeObjetsDonnee = CListeObjetsDonnees.CreateListFrom(ctx, list);
}
if (listeObjetsDonnee != null)
{
list = listeObjetsDonnee;
result = GetFiltreDataAAppliquer(elementAVariablePourFiltres);
if (!result)
{
result.EmpileErreur(I.T("Error in the filter of the table @1|119", NomTable));
return(result);
}
try
{
if (result.Data != null)
{
listeObjetsDonnee.Filtre = CFiltreData.GetAndFiltre(listeObjetsDonnee.Filtre, (CFiltreData)result.Data);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error during combination of table @1 filter|120", NomTable));
return(result);
}
}
}
//Table fille->
//si relation : Attribut relation (parente) représentant le lien entre la relation fille et cette tablle
//Si donnée cumulée : true
Hashtable tableTablesFillesToDependanceDirecte = new Hashtable();
//Table parente->Champ fille contenant l'id
Hashtable tableParentsCharges = new Hashtable();
#region Optimisations des CListeObjetsDonnees
if (bAvecOptimisation && list is CListeObjetsDonnees)
{
CListeObjetsDonnees listeObjets = (CListeObjetsDonnees)list;
if (bUtiliserIdObjets)
{
#region Identifie les tables filles qui peuvent être remplies en une seule requête.
//Identifie les sous tables qui peuvent être chargées en une seule fois :
//Il s'agit des sous tables liée directement à une propriété par
//des relations (attribut RelationFille ou Relation).
foreach (ITableExport tableFille in TablesFilles)
{
Type tpAnalyse = listeObjets.TypeObjets;
if (tableFille != tableFilleANePasCharger && (tableFille is C2iTableExportATableFille || tableFille is C2iTableExportCumulee))
{
if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueDonneeCumulee)
{
tableTablesFillesToDependanceDirecte[tableFille] = true;
}
else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueRelationTypeId)
{
tableTablesFillesToDependanceDirecte[tableFille] = true;
}
else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
tableTablesFillesToDependanceDirecte[tableFille] = true;
}
else if (tableFille.ChampOrigine != null)
{
string strPropOrigine = tableFille.ChampOrigine.NomProprieteSansCleTypeChamp;
if (strPropOrigine.IndexOf('.') < 0)
{
//Seules les propriétés directes sont optimisées (pour le moment et peut être que ça suffit)
PropertyInfo info = tpAnalyse.GetProperty(strPropOrigine);
if (info != null)
{
object[] attribs = info.GetCustomAttributes(typeof(RelationFilleAttribute), true);
if (attribs.Length > 0)
{
RelationFilleAttribute attrFille = (RelationFilleAttribute)attribs[0];
tpAnalyse = attrFille.TypeFille;
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpAnalyse))
{
info = tpAnalyse.GetProperty(attrFille.ProprieteFille);
if (info != null)
{
attribs = info.GetCustomAttributes(typeof(RelationAttribute), true);
if (attribs.Length > 0)
{
RelationAttribute attrParent = (RelationAttribute)attribs[0];
if (attrParent.ChampsFils.Length == 1)
{
tableTablesFillesToDependanceDirecte[tableFille] = attrParent;
}
}
}
}
}
}
}
}
}
}
#endregion
#region Charges les tables parentes qui peuvent être chargées
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(listeObjets.TypeObjets))
{
string strNomTableFille = listeObjets.NomTable;
foreach (ITableExport tableParenteAOptimiser in TablesFilles)
{
if (tableParenteAOptimiser != tableFilleANePasCharger && tableParenteAOptimiser.ChampOrigine != null && !tableParenteAOptimiser.ChampOrigine.TypeDonnee.IsArrayOfTypeNatif)
{
if (IsOptimisable(tableParenteAOptimiser, TypeSource))
{
CListeObjetsDonnees listeMere = listeObjets.GetDependances(tableParenteAOptimiser.ChampOrigine.NomProprieteSansCleTypeChamp);
if (listeMere != null)
{
result = tableParenteAOptimiser.InsertDataInDataSet(
listeMere,
ds,
null,
0,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
//Trouve le champ fille de lien
foreach (Constraint contrainte in table.Constraints)
{
if (contrainte is ForeignKeyConstraint)
{
ForeignKeyConstraint fk = (ForeignKeyConstraint)contrainte;
if (fk.RelatedTable.TableName == tableParenteAOptimiser.NomTable)
{
tableParentsCharges[tableParenteAOptimiser] = fk.Columns[0].ColumnName;
break;
}
}
}
}
}
}
}
}
#endregion
}
#region Identification des dépendances
if (m_strDependancesToOptim == null)
{
Hashtable tableDependances = new Hashtable();
AddProprietesOrigineDesChampsToTable(tableDependances, "", listeObjets.ContexteDonnee);
foreach (ITableExport tableFille in TablesFilles)
{
if (tableFille != tableFilleANePasCharger &&
!tableTablesFillesToDependanceDirecte.Contains(tableFille) &&
!tableParentsCharges.Contains(tableFille))
{
string strChemin = "";
if (ChampOrigine != null)
{
strChemin = ChampOrigine.NomPropriete;
}
if (tableFille.FiltreAAppliquer == null)
{
tableFille.AddProprietesOrigineDesChampsToTable(tableDependances, strChemin, listeObjets.ContexteDonnee);
}
}
}
m_strDependancesToOptim = new string[tableDependances.Count];
int nDep = 0;
foreach (string strOrigine in tableDependances.Keys)
{
m_strDependancesToOptim[nDep++] = strOrigine;
}
}
#endregion
}
#endregion
indicateur.SetInfo(I.T("Table @1|115", NomTable));
CFiltreData filtreDeBase = null;
if (list is CListeObjetsDonnees)
{
filtreDeBase = ((CListeObjetsDonnees)list).Filtre;
}
ArrayList listeIds = new ArrayList();
string strColonneCle = table.PrimaryKey[0].ColumnName;
indicateur.SetBornesSegment(0, nValeursCle.Length);
indicateur.SetValue(0);
//Lecture par paquets de 1000 clés
for (int n = 0; n < nValeursCle.Length; n += c_nNbLectureParLotFils)
{
if (bAvecOptimisation && (list is CListeObjetsDonnees) && relationToObjetParent != null)
{
CListeObjetsDonnees listeObjets = (CListeObjetsDonnees)list;
StringBuilder blCles = new StringBuilder();
char cSepIn = ',';
if (filtreDeBase is CFiltreDataAvance)
{
cSepIn = ';';
}
for (int nCle = n; nCle < Math.Min(n + c_nNbLectureParLotFils, nValeursCle.Length); nCle++)
{
blCles.Append(nValeursCle[nCle]);
blCles.Append(cSepIn);
}
if (blCles.Length > 0)
{
blCles.Remove(blCles.Length - 1, 1);
string strCles = blCles.ToString();
if (filtreDeBase is CFiltreDataAvance)
{
listeObjets.Filtre = CFiltreData.GetAndFiltre(
filtreDeBase, new CFiltreDataAvance(
listeObjets.NomTable,
relationToObjetParent.ChampsFils[0] + " in {" + strCles + "}"));
}
else
{
listeObjets.Filtre = CFiltreData.GetAndFiltre(
filtreDeBase,
new CFiltreData(
relationToObjetParent.ChampsFils[0] + " in (" + strCles.Replace(';', ',') + ")"));
}
}
}
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
if (list is CListeObjetsDonnees && m_strDependancesToOptim != null && m_strDependancesToOptim.Length > 0)
{
((CListeObjetsDonnees)list).ReadDependances(m_strDependancesToOptim);
}
int nCountTotal = 1;
if (list is IList)
{
nCountTotal = ((IList)list).Count;
}
else if (list is Array)
{
nCountTotal = ((Array)list).Length;
}
indicateur.PushSegment(n, Math.Min(n + c_nNbLectureParLotFils, nValeursCle.Length));
int nNbElements = 0;
indicateur.SetBornesSegment(0, nCountTotal);
int nFrequence = Math.Min(nCountTotal / 20, 500) + 1;
CSessionClient session = CSessionClient.GetSessionUnique();
IInfoUtilisateur infoUser = session != null?session.GetInfoUtilisateur() : null;
///AJOUT DES LIGNES DANS LA TABLE
foreach (object obj in list)
{
CRestrictionUtilisateurSurType restriction = null;
if (infoUser != null && obj != null)
{
restriction = infoUser.GetRestrictionsSur(obj.GetType(), obj is IObjetAContexteDonnee?((IObjetAContexteDonnee)obj).ContexteDonnee.IdVersionDeTravail:null);
}
nNbElements++;
if (nNbElements % nFrequence == 0)
{
indicateur.SetValue(nNbElements);
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
}
bool bShouldImporte = true;
DataRow row = null;
if (bUtiliserIdObjets)
{
row = table.Rows.Find(((CObjetDonneeAIdNumerique)obj).Id);
bShouldImporte = row == null;
}
if (bShouldImporte)
{
row = table.NewRow();
if (bUtiliserIdObjets)
{
int nId = ((CObjetDonneeAIdNumerique)obj).Id;
row[strColonneCle] = nId;
listeIds.Add(nId);
}
//Ajoute les valeurs de champs propres à cette table
result = InsereValeursChamps(obj, row, cacheValeurs, restriction);
if (!result)
{
return(result);
}
if (colFilleDeContrainte != null && nValeursCle.Length > 0)
{
DataRow rowFille = row;
if (tableFilleDeContrainte == table)
{
if (relationToObjetParent == null)
{
rowFille[colFilleDeContrainte] = nValeursCle[0];
}
else
{
rowFille[colFilleDeContrainte] = ((CObjetDonnee)obj).Row[relationToObjetParent.ChampsFils[0]];
}
}
}
table.Rows.Add(row);
}
//Dans tous les cas, met à jour la table dépendante si besoin est !
if (colFilleDeContrainte != null && nValeursCle.Length > 0)
{
DataRow rowFille = row;
if (tableFilleDeContrainte != table)
{
rowFille = tableFilleDeContrainte.Rows.Find(nValeursCle[0]);
rowFille[colFilleDeContrainte] = row[strColonneCle];
}
}
if (bShouldImporte)
{
//AJout des données des sous tables non optimisées
foreach (ITableExport tbl in TablesFilles)
{
if (tbl.ChampOrigine != null && !tableTablesFillesToDependanceDirecte.Contains(tbl) && tbl != tableFilleANePasCharger)
{
bool bChildIsOptimisable = IsOptimisable(tbl, TypeSource);
//Impossible de lire en direct
object objet = null;
if (tbl.ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
objet = obj;
}
else
{
objet = CInterpreteurProprieteDynamique.GetValue(obj, tbl.ChampOrigine, cacheValeurs).Data;
}
string strNomCol = (string)tableParentsCharges[tbl];
if (strNomCol != null)
{
if (objet != null)
{
row[strNomCol] = ((CObjetDonneeAIdNumerique)objet).Id;
}
else
{
row[strNomCol] = DBNull.Value;
}
}
else
{
indicateur.PushSegment(nNbElements, nNbElements + 1);
if (objet != null)
{
IEnumerable tempList;
if (objet is IEnumerable)
{
tempList = (IEnumerable)objet;
}
else
{
ArrayList listeObjetUnique = new ArrayList();
listeObjetUnique.Add(objet);
tempList = listeObjetUnique;
}
if (tempList != null)
{
result = tbl.InsertDataInDataSet(
tempList,
ds,
this,
(int)row[table.PrimaryKey[0]],
elementAVariablePourFiltres,
cacheValeurs,
this,
bChildIsOptimisable,
indicateur);
if (!result)
{
return(result);
}
}
}
indicateur.PopSegment();
}
}
}
//vide le cache après chaque objet de la table principale
if (tableParente == null)
{
cacheValeurs.ResetCache();
}
}
}
indicateur.PopSegment();
}
indicateur.SetValue(nValeursCle.Length);
///Chargement des relations optimisées
int nTable = 0;
foreach (DictionaryEntry entry in tableTablesFillesToDependanceDirecte)
{
nTable++;
ITableExport tableFille = (ITableExport)entry.Key;
if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueDonneeCumulee)
{
CDefinitionProprieteDynamiqueDonneeCumulee defCum = (CDefinitionProprieteDynamiqueDonneeCumulee)tableFille.ChampOrigine;
//Trouve les données cumulées correspondants aux éléments
CListeObjetsDonnees listeInit = (CListeObjetsDonnees)list;
CTypeDonneeCumulee typeCumule = new CTypeDonneeCumulee(listeInit.ContexteDonnee);
if (!typeCumule.ReadIfExists(
defCum.DbKeyTypeDonnee))
{
result.EmpileErreur(I.T("The cumulated data type @1 doesn't exist|122", defCum.DbKeyTypeDonnee.ToString()));
return(result);
}
RelationAttribute attr = typeCumule.GetRelationAttributeToType(listeInit.TypeObjets);
string strChampIdOuDbKey = "";
if (defCum.DbKeyTypeDonnee.IsNumericalId())
{
strChampIdOuDbKey = CTypeDonneeCumulee.c_champId;
}
else
{
strChampIdOuDbKey = CObjetDonnee.c_champIdUniversel;
}
CListeObjetsDonnees listeFils = new CListeObjetsDonnees(
listeInit.ContexteDonnee,
typeof(CDonneeCumulee),
new CFiltreData(strChampIdOuDbKey + " = @1 ", defCum.DbKeyTypeDonnee.GetValeurInDb()));
listeFils.ModeSansTri = true; //Optimisation pour ne pas utiliser de dataview
result = tableFille.InsertDataInDataSet(
listeFils,
ds,
this,
(int[])listeIds.ToArray(typeof(int)),
attr,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
}
else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueRelationTypeId)
{
CDefinitionProprieteDynamiqueRelationTypeId defTypeId = (CDefinitionProprieteDynamiqueRelationTypeId)tableFille.ChampOrigine;
RelationTypeIdAttribute relTpIdAttr = defTypeId.Relation;
//Trouve les données cumulées correspondants aux éléments
CListeObjetsDonnees listeInit = (CListeObjetsDonnees)list;
if (listeInit.Count != 0)
{
CListeObjetsDonnees listeFils = new CListeObjetsDonnees(
listeInit.ContexteDonnee,
CContexteDonnee.GetTypeForTable(relTpIdAttr.TableFille),
new CFiltreData(relTpIdAttr.ChampType + "=@1", listeInit.TypeObjets.ToString()));
listeFils.ModeSansTri = true; //Optimisation pour ne pas utiliser de dataview
RelationAttribute attrTmp = new RelationAttribute(
listeInit.NomTable,
((CObjetDonneeAIdNumerique)listeInit[0]).GetChampId(),
relTpIdAttr.ChampId, false, false);
result = tableFille.InsertDataInDataSet(
listeFils,
ds,
this,
(int[])listeIds.ToArray(typeof(int)),
attrTmp,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
}
}
else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
CListeObjetsDonnees listeInit = new CListeObjetsDonnees(
((CListeObjetsDonnees)list).ContexteDonnee,
tableFille.ChampOrigine.TypeDonnee.TypeDotNetNatif, true);
listeInit.ModeSansTri = true; //Optimisation pour ne pas utiliser de dataview
string strChampId = listeInit.ContexteDonnee.GetTableSafe(CContexteDonnee.GetNomTableForType(listeInit.TypeObjets)).PrimaryKey[0].ColumnName;
RelationAttribute attrTmp = new RelationAttribute(
listeInit.NomTable,
strChampId,
strChampId,
false, false);
//Copie les clés dans la clé et dans la valeur de champ externe
result = tableFille.InsertDataInDataSet(
listeInit,
ds,
this,
(int[])listeIds.ToArray(typeof(int)),
attrTmp,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
}
else if (tableFille.ChampOrigine != null)
{
RelationAttribute attr = (RelationAttribute)entry.Value;
CListeObjetsDonnees listeFils = new CListeObjetsDonnees(
((CListeObjetsDonnees)list).ContexteDonnee,
tableFille.ChampOrigine.TypeDonnee.TypeDotNetNatif, true);
listeFils.ModeSansTri = true; //Optimisation pour ne pas utiliser de dataview
result = tableFille.InsertDataInDataSet(
listeFils,
ds,
this,
(int[])listeIds.ToArray(typeof(int)),
attr,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
}
else
{
result = tableFille.InsertDataInDataSet(
null,
ds,
this,
(int[])listeIds.ToArray(typeof(int)),
null,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
}
}
return(result);
}
/// ///////////////////////////////////////////////////////////
public object GetValue(object objetInterroge, CDefinitionProprieteDynamique propriete)
{
//Récupère l'objet à interroger
string strProp = propriete.NomPropriete;
object valeur = m_cache.GetValeurCache(objetInterroge, strProp);
if (valeur != null)
{
return(valeur);
}
CContexteDonnee contexteForObjets = ContexteDonneeCache;
if (objetInterroge is IObjetAContexteDonnee)
{
contexteForObjets = ((IObjetAContexteDonnee)objetInterroge).ContexteDonnee;
}
if (contexteForObjets == null)
{
contexteForObjets = ContexteDonneeCache;
}
object objetFinal = objetInterroge;
int nPos = strProp.LastIndexOf('.');
if (nPos > 0 && !(propriete is CDefinitionProprieteDynamiqueDonneeCumulee) &&
!(propriete is CDefinitionProprieteDynamiqueChampCustom) &&
!(propriete is CDefinitionProprieteDynamiqueChampCustomFils) &&
!(propriete is CDefinitionProprieteDynamiqueFormule))
{
string strPropDebut;
strPropDebut = strProp.Substring(0, nPos);
strProp = strProp.Substring(nPos + 1);
objetFinal = m_cache.GetValeurCache(objetInterroge, strPropDebut);
if (objetFinal == null)
{
objetFinal = GetValue(objetInterroge, strPropDebut);
/*object objetAInterroger = null;
* MemberInfo membre = null;
* CInterpreteurTexteProptVariete.GetObjetFinalEtMemberInfo ( objetInterroge, strPropDebut, ref objetAInterroger, ref membre );
* if ( membre != null )
* {
* objetFinal = CInterpreteurTextePropriete.GetValue ( objetAInterroger, membre );
* }
* else
* {
* //On n'a pas trouvé le membre, il s'agit donc d'autre chose, il faut donc décomposer
* //Le champ
* }*/
//objetFinal = CInterpreteurTextePropriete.GetValue(objetInterroge, strPropDebut);
m_cache.StockeValeurEnCache(objetInterroge, strPropDebut, objetFinal);
}
if (objetFinal == null)
{
return(null);
}
valeur = m_cache.GetValeurCache(objetFinal, strProp);
if (valeur != null)
{
return(valeur);
}
}
if (propriete is CDefinitionProprieteDynamiqueChampCustom)
{
if (!(objetFinal is IElementAChamps))
{
valeur = null;
}
else
{
//TESTDBKEYTODO qui ne peut pas marche
valeur = ((IElementAChamps)objetFinal).GetValeurChamp(((CDefinitionProprieteDynamiqueChampCustom)propriete).DbKeyChamp.InternalIdNumeriqueANeJamaisUtiliserSaufDansCDbKeyAddOn.Value, System.Data.DataRowVersion.Default);
/*if (m_bValeurAfficheeDeChampsCustom)
* {
* CChampCustom champ = new CChampCustom(ContexteDonneeCache);
* if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCustom)propriete).IdChamp))
* {
* object valTmp = champ.DisplayFromValue(valeur);
* if (valTmp != null)
* valeur = valTmp;
* }
* }*/
}
}
else if (propriete is CDefinitionProprieteDynamiqueChampCustomFils && objetInterroge is CObjetDonneeAIdNumerique)
{
CChampCustom champ = new CChampCustom(ContexteDonneeCache);
if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCustomFils)propriete).KeyChamp))
{
Type tp = champ.Role.TypeAssocie;
try
{
IObjetDonneeAChamps elt = (IObjetDonneeAChamps)Activator.CreateInstance(tp, new object[] { contexteForObjets });
CRelationElementAChamp_ChampCustom rel = elt.GetNewRelationToChamp();
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteForObjets, tp);
liste.Filtre = new CFiltreDataAvance(
elt.GetNomTable(),
rel.GetNomTable() + "." +
CRelationElementAChamp_ChampCustom.c_champValeurString + "=@1 and " +
rel.GetNomTable() + "." +
CRelationElementAChamp_ChampCustom.c_champValeurInt + "=@2 and " +
rel.GetNomTable() + "." +
CChampCustom.c_champId + "=@3",
objetInterroge.GetType().ToString(),
((CObjetDonneeAIdNumerique)objetInterroge).Id,
champ.Id);
valeur = liste.ToArray(tp);
}
catch
{
valeur = null;
}
}
}
else if (propriete is CDefinitionProprieteDynamiqueListeEntites)
{
CListeEntites liste = new CListeEntites(contexteForObjets);
try
{
if (liste.ReadIfExists(((CDefinitionProprieteDynamiqueListeEntites)propriete).DbKeyListeEntite))
{
CListeObjetsDonnees resultListe = liste.GetElementsLiesFor(objetInterroge);
if (resultListe != null)
{
valeur = resultListe.ToArray(liste.TypeElements);
}
}
}
catch
{
valeur = null;
}
}
else if (propriete is CDefinitionProprieteDynamiqueRelationTypeId)
{
if (!(objetFinal is CObjetDonneeAIdNumerique))
{
valeur = null;
}
else
{
CDefinitionProprieteDynamiqueRelationTypeId defRel = (CDefinitionProprieteDynamiqueRelationTypeId)propriete;
return(((CObjetDonneeAIdNumerique)objetFinal).GetDependancesRelationTypeId(
defRel.Relation.TableFille,
defRel.Relation.ChampType,
defRel.Relation.ChampId,
false));
}
}
else if (propriete is CDefinitionProprieteDynamiqueDonneeCumulee)
{
if (!(objetFinal is CObjetDonneeAIdNumerique))
{
valeur = null;
}
else
{
CDefinitionProprieteDynamiqueDonneeCumulee defType = (CDefinitionProprieteDynamiqueDonneeCumulee)propriete;
CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)objetFinal;
CTypeDonneeCumulee type = new CTypeDonneeCumulee(contexteForObjets);
if (type.ReadIfExists(defType.DbKeyTypeDonnee))
{
valeur = type.GetDonneesCumuleesForObjet(objet);
}
else
{
valeur = null;
}
}
}
else if (propriete is CDefinitionProprieteDynamiqueChampCalcule)
{
CChampCalcule champ = new CChampCalcule(contexteForObjets);
if (champ.ReadIfExists(((CDefinitionProprieteDynamiqueChampCalcule)propriete).DbKeyChamp))
{
valeur = champ.Calcule(objetFinal, new CFournisseurPropDynStd(true));
}
else
{
valeur = null;
}
}
else if (propriete is CDefinitionProprieteDynamiqueFormule)
{
CContexteEvaluationExpression contexte = new CContexteEvaluationExpression(objetInterroge);
contexte.AttacheObjet(typeof(CContexteDonnee), contexteForObjets);
CResultAErreur result = ((CDefinitionProprieteDynamiqueFormule)propriete).Formule.Eval(contexte);
if (result)
{
return(result.Data);
}
}
else if (propriete is CDefinitionProprieteDynamiqueVariableDynamique && objetFinal is IElementAVariables)
{
valeur = ((IElementAVariables)objetFinal).GetValeurChamp(((CDefinitionProprieteDynamiqueVariableDynamique)propriete).IdChamp);
}
else
{
valeur = CInterpreteurTextePropriete.GetValue(objetFinal, strProp);
}
m_cache.StockeValeurEnCache(objetInterroge, propriete.Nom, valeur);
if (objetFinal != objetInterroge)
{
m_cache.StockeValeurEnCache(objetFinal, strProp, valeur);
}
return(valeur);
}
//-----------------------------------------------------------------
/// <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);
}