//----------------------------------------------------------------------
public CResultAErreur Eval(CContexteEvaluationExpression ctxEval, params object[] parametres)
{
if (Formule == null)
{
return(null);
}
int nParametre = 0;
CContexteEvaluationExpression ctxCopie = new CContexteEvaluationExpression(ctxEval.ObjetSource);
foreach (CParametreFonctionDynamique parametre in Parametres)
{
CDefinitionProprieteDynamiqueVariableFormule def = new CDefinitionProprieteDynamiqueVariableFormule(
parametre.Nom,
parametre.TypeResultatExpression,
true);
ctxCopie.AddVariable(def);
if (nParametre < parametres.Length)
{
ctxCopie.SetValeurVariable(def, parametres[nParametre]);
}
else
{
ctxCopie.SetValeurVariable(def, null);
}
nParametre++;
}
CResultAErreur result = Formule.Eval(ctxCopie);
if (!result)
{
result.EmpileErreur(I.T("Error while evaluating method @1|20127"));
}
return(result);
}
//-------------------------------------------------------------------
public object[] GetValues(CChartSetup chart)
{
List <object> lstValeurs = new List <object>();
CParametreSourceChart p = chart.ParametresDonnees.GetSourceFV(SourceId);
if (p != null)
{
CEasyQuery query = p.GetSource(chart) as CEasyQuery;
if (query != null)
{
//trouve la table
DataTable table = query.GetTable(TableName);
if (table != null)
{
DataColumn col = table.Columns[ColumnName];
if (col != null)
{
foreach (DataRow row in table.Rows)
{
object val = row[col];
if (val == DBNull.Value)
{
lstValeurs.Add(null);
}
else
{
lstValeurs.Add(val);
}
}
}
else if (Formule != null)
{
foreach (DataRow row in table.Rows)
{
CDynamicDataTableRow dr = new CDynamicDataTableRow(row);
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(dr);
CResultAErreur result = Formule.Eval(ctx);
if (result)
{
lstValeurs.Add(result.Data);
}
else
{
lstValeurs.Add(null);
}
}
}
}
}
}
return(lstValeurs.ToArray());
}
/// //////////////////////////////////////////////////
public object Calcule(object objetEvalue, CFournisseurPropDynStd fournisseur)
{
if (objetEvalue == null)
{
return(null);
}
if (fournisseur == null)
{
fournisseur = new CFournisseurPropDynStd();
}
CContexteEvaluationExpression contexte = new CContexteEvaluationExpression(objetEvalue);
contexte.AttacheObjet(typeof(CContexteDonnee), ContexteDonnee);
CResultAErreur result = Formule.Eval(contexte);
contexte.DetacheObjet(typeof(CContexteDonnee));
if (result)
{
return(result.Data);
}
return(null);
}
//---------------------------------------------------
protected override CResultAErreur GetDatasHorsCalculees(CListeQuerySource sources)
{
CResultAErreur result = CResultAErreur.True;
if (TableSource != null)
{
result = TableSource.GetDatas(sources);
if (!result)
{
return(result);
}
DataTable table = result.Data as DataTable;
if (table != null)
{
DataTable tableFiltre = null;
Dictionary <IColumnDeEasyQuery, DataColumn> mapColonnes = new Dictionary <IColumnDeEasyQuery, DataColumn>();
Dictionary <string, string> mapIdSourceToNomSource = new Dictionary <string, string>();
foreach (IColumnDeEasyQuery col in TableSource.Columns)
{
mapIdSourceToNomSource[col.Id] = col.ColumnName;
}
if (InclureToutesLesColonnesSource)
{
tableFiltre = table.Clone() as DataTable;
}
else
{
tableFiltre = new DataTable(NomFinal);
foreach (CColumnEQFromSource colFromSource in ColonnesFromSource)
{
Type tp = colFromSource.DataType;
if (tp.IsGenericType && tp.GetGenericTypeDefinition() == typeof(Nullable <>))
{
tp = tp.GetGenericArguments()[0];
}
DataColumn colToAdd = new DataColumn(colFromSource.ColumnName, tp);
tableFiltre.Columns.Add(colToAdd);
mapColonnes[colFromSource] = colToAdd;
}
}
foreach (CColonneEQCalculee colCalc in ColonnesCalculeesFromSource)
{
Type tp = colCalc.DataType;
if (tp.IsGenericType && tp.GetGenericTypeDefinition() == typeof(Nullable <>))
{
tp = tp.GetGenericArguments()[0];
}
DataColumn colToAdd = new DataColumn(colCalc.ColumnName, tp);
tableFiltre.Columns.Add(colToAdd);
mapColonnes[colCalc] = colToAdd;
}
HashSet <IColumnDeEasyQuery> colsSourceCopiables = new HashSet <IColumnDeEasyQuery>();
foreach (IColumnDeEasyQuery col in TableSource.Columns)
{
if (tableFiltre.Columns[col.ColumnName] != null)
{
colsSourceCopiables.Add(col);
}
}
DataRow previousRow = null;
foreach (DataRow row in table.Rows)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(new CDataRowForChampCalculeODEQ(row, previousRow, Query));
if (Formule is C2iExpressionVrai)
{
result.Data = true;
}
else
{
result = Formule.Eval(ctx);
}
previousRow = row;
if (result && result.Data is bool && (bool)result.Data)
{
DataRow rowDest = tableFiltre.NewRow();
if (InclureToutesLesColonnesSource)
{
foreach (IColumnDeEasyQuery col in colsSourceCopiables)
{
rowDest[col.ColumnName] = row[col.ColumnName];
}
}
else
{
foreach (CColumnEQFromSource colFromSource in ColonnesFromSource)
{
rowDest[mapColonnes[colFromSource]] = row[mapIdSourceToNomSource[colFromSource.IdColumnSource]];
}
}
//Ajout des données calculées
foreach (CColonneEQCalculee colCalc in ColonnesCalculeesFromSource)
{
if (colCalc != null && colCalc.Formule != null)
{
result = colCalc.Formule.Eval(ctx);
if (result)
{
try
{
if (result.Data == null)
{
rowDest[mapColonnes[colCalc]] = DBNull.Value;
}
else
{
rowDest[mapColonnes[colCalc]] = result.Data;
}
}
catch { }
}
}
}
tableFiltre.Rows.Add(rowDest);
}
}
result.Data = tableFiltre;
}
}
if (!(result.Data is DataTable))
{
result.EmpileErreur(I.T("Error in table @1|20002", NomFinal));
}
return(result);
}
