//----------------------------------------------------------------------------------------------------
public CResultAErreur SendDonneesPooled(List <CDonneeCumuleeTransportable> lstDonnees)
{
CResultAErreur result = AssureSessionPolling();
if (!result)
{
return(result);
}
using (CContexteDonnee ctx = new CContexteDonnee(m_sessionPolling.IdSession, true, false))
{
foreach (CDonneeCumuleeTransportable donnee in lstDonnees)
{
CDonneeCumulee data = new CDonneeCumulee(ctx);
data.CreateNewInCurrentContexte();
if (!data.FillFromDonneeTransportable(donnee))
{
data.Delete(true);
}
}
ctx.EnableTraitementsAvantSauvegarde = false;
ctx.EnableTraitementsExternes = false;
result = ctx.SaveAll(false);
}
result.Data = null;
return(result);
}
/// /////////////////////////////////////////////////////////////
/// <summary>
/// Crée un attribut relation décrivant la relation qui lie la donnée cumulée au type demandé
/// </summary>
/// <param name="tp"></param>
/// <returns></returns>
public RelationAttribute GetRelationAttributeToType(Type tp)
{
int nCle = 0;
foreach (CCleDonneeCumulee cle in Parametre.ChampsCle)
{
if (cle.TypeLie != null && cle.TypeLie == tp)
{
CObjetDonneeAIdNumerique obj = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, new object[] { ContexteDonnee });
RelationAttribute attr = new RelationAttribute(
obj.GetNomTable(),
obj.GetChampId(),
CDonneeCumulee.GetNomChampCle(nCle),
false,
true,
false);
return(attr);
}
nCle++;
}
return(null);
}
/// /////////////////////////////////////////////////////////////
public CListeObjetsDonnees GetDonneesCumuleesForObjet(CObjetDonneeAIdNumerique objet)
{
//Trouve le champ du paramètre qui est lié au type de l'objet lié
CParametreDonneeCumulee parametre = Parametre;
int nCle = 0;
string strChampCle = "";
foreach (CCleDonneeCumulee cle in parametre.ChampsCle)
{
if (cle.TypeLie != null && cle.TypeLie == objet.GetType())
{
strChampCle = CDonneeCumulee.GetNomChampCle(nCle);
break;
}
else
{
nCle++;
}
}
CListeObjetsDonnees listeVide = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CDonneeCumulee));
listeVide.Filtre = new CFiltreDataImpossible();
if (strChampCle == "")
{
return(listeVide);
}
CFiltreData filtre = new CFiltreData(
CTypeDonneeCumulee.c_champId + "=@1 and " +
strChampCle + "=@2",
this.Id,
objet.Id.ToString());
CListeObjetsDonnees liste = new CListeObjetsDonnees(objet.ContexteDonnee, typeof(CDonneeCumulee));
liste.Filtre = filtre;
return(liste);
}
/// //////////////////////////////////////////
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>
/// 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);
}
