/// /////////////////////////////////////////////////////////
public DataTable GetDataTable(IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablesPourFiltre)
{
DataTable table = new DataTable(m_strNomTable);
Type tp = typeof(int);
if (m_expressionValeur != null)
{
tp = m_expressionValeur.TypeDonnee.TypeDotNetNatif;
}
DataColumn col = table.Columns.Add(c_champNumRec, tp);
table.PrimaryKey = new DataColumn[] { col };
CTypeForFormule dummy = new CTypeForFormule(elementAVariablesPourFiltre);
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(dummy);
int nNbRecords = 0;
if (m_expressionNbRecords != null)
{
CResultAErreur result = m_expressionNbRecords.Eval(ctx);
if (!result)
{
return(table);
}
try
{
nNbRecords = Convert.ToInt32(result.Data);
}
catch
{
nNbRecords = 0;
}
}
for (int n = 0; n < nNbRecords; n++)
{
DataRow row = table.NewRow();
if (m_expressionValeur != null)
{
dummy.Valeur = n;
ctx.CacheEnabled = false;
if (ctx.Cache != null)
{
ctx.Cache.ResetCache();
}
CResultAErreur result = m_expressionValeur.Eval(ctx);
if (result)
{
row[c_champNumRec] = result.Data;
}
}
else
{
row[c_champNumRec] = n;
}
table.Rows.Add(row);
}
return(table);
}
/*//----------------------------------------------------------------------------------
* public CResultAErreur Export (int nIdSession, IEnumerable list, ref DataSet ds)
* {
* return Export ( nIdSession, list, ref ds, null );
* }*/
//----------------------------------------------------------------------------------
public CResultAErreur Export(int nIdSession,
IEnumerable list,
ref DataSet ds,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablesPourFiltre)
{
return(Export(nIdSession, list, ref ds, elementAVariablesPourFiltre, null));
}
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);
}
/// ////////////////////////////////////////////////////
protected void Init(CVariableDynamiqueListeObjets variable, IElementAVariablesDynamiquesAvecContexteDonnee elementAVariables)
{
m_variable = variable;
m_variable.FiltreDynamique.ElementAVariablesExterne = elementAVariables;
m_panelFiltre.Init(m_variable.FiltreDynamique);
m_panelFiltre.MasquerFormulaire(true);
m_txtNomVariable.Text = m_variable.Nom;
}
/// //////////////////////////////////////////////////////
public static bool EditeVariable(CVariableDynamiqueListeObjets variable, IElementAVariablesDynamiquesAvecContexteDonnee element)
{
CFormEditVariableDynamiqueListeObjets form = new CFormEditVariableDynamiqueListeObjets();
form.Init(variable, element);
Boolean bOk = form.ShowDialog() == DialogResult.OK;
form.Dispose();
return(bOk);
}
//-------------------------------------------------
public static CElementAVariablesDynamiques GetNewFrom(IElementAVariablesDynamiquesAvecContexteDonnee elt)
{
if (elt == null)
{
return(null);
}
CElementAVariablesDynamiques newElt = new CElementAVariablesDynamiques();
newElt.CopieStatique(elt);
return(newElt);
}
/// <summary>
/// Le data du result contient un datatable avec la structure du résultat
/// </summary>
/// <param name="nIdSession"></param>
/// <returns></returns>
public CResultAErreur GetStructureResultat(int nIdSession)
{
I2iRequeteServeur objetServeur = (I2iRequeteServeur)C2iFactory.GetNewObjetForSession("C2iRequeteServeur", typeof(I2iRequeteServeur), nIdSession);
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariable = this;
if (m_elementAVariablesExterne != null)
{
elementAVariable = m_elementAVariablesExterne;
}
return(objetServeur.ExecuteRequete(this, elementAVariable, true));
}
//----------------------------------------------------------------------------------
public CResultAErreur InsertDataInDataSet(
IEnumerable list,
DataSet ds,
ITableExport tableParente,
int nValeurCle,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablePourFiltres,
CCacheValeursProprietes cacheValeurs,
ITableExport tableFilleANeParCharger,
bool bAvecOptimisation,
CConteneurIndicateurProgression indicateur)
{
return(InsertDataInDataSet(list, ds, tableParente, new int[] { nValeurCle }, null, elementAVariablePourFiltres, cacheValeurs, null, bAvecOptimisation, indicateur));
}
//---------------------------------
public override CResultAErreur InsertDataInDataSet(
IEnumerable list,
DataSet ds,
ITableExport tableParente,
int[] nValeursCle,
RelationAttribute relationToObjetParent,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablePourFiltres,
CCacheValeursProprietes cacheValeurs,
ITableExport tableFilleANePasCharger,
bool bAvecOptimisation,
CConteneurIndicateurProgression indicateur)
{
if (tableParente != null)
{
return(base.InsertDataInDataSet(
list,
ds,
tableParente,
nValeursCle,
relationToObjetParent,
elementAVariablePourFiltres,
cacheValeurs,
tableFilleANePasCharger,
bAvecOptimisation,
indicateur));
}
else
{
CResultAErreur result = CResultAErreur.True;
foreach (ITableExport tableFille in TablesFilles)
{
result = tableFille.InsertDataInDataSet(
list,
ds,
tableParente,
nValeursCle,
relationToObjetParent,
elementAVariablePourFiltres,
cacheValeurs,
tableFilleANePasCharger,
bAvecOptimisation,
indicateur);
if (!result)
{
return(result);
}
}
return(result);
}
}
//private CDefinitionProprieteDynamique m_propriete;
public CFiltreDynamique EditeFiltre(CFiltreDynamique filtreDynamique, IElementAVariablesDynamiquesAvecContexteDonnee eltAVariablesExternes)
{
if (filtreDynamique == null)
{
filtreDynamique = new CFiltreDynamique();
}
filtreDynamique.ElementAVariablesExterne = eltAVariablesExternes;
CFormEditFiltreDynamique.EditeFiltre(filtreDynamique,
false,
true,
null);
return(filtreDynamique);
}
//----------------------------------------------------------------------------------
public CResultAErreur InitChamps(
ITableExport table,
ITableExport tableParente,
C2iStructureExport structure,
IElementAVariablesDynamiquesAvecContexteDonnee eltAVariablesDynamiques)
{
CResultAErreur result = CResultAErreur.True;
m_tableCalculee = table as C2iTableExportCalculee;
if (m_tableCalculee == null)
{
return(CResultAErreur.False);
}
m_structureExport = structure;
m_txtNomTable.Text = m_tableCalculee.NomTable;
if (m_tableCalculee.FormuleValeur != null)
{
m_txtFormuleValeur.Text = m_tableCalculee.FormuleValeur.GetString();
}
else
{
m_txtFormuleValeur.Text = "";
}
if (m_tableCalculee.FormuleNbRecords != null)
{
m_txtFormuleNbRecords.Text = m_tableCalculee.FormuleNbRecords.GetString();
}
else
{
m_txtFormuleNbRecords.Text = "0";
}
ElementAVariablesDynamiques = eltAVariablesDynamiques;
C2iTableExportCalculee.CTypeForFormule leType = new C2iTableExportCalculee.CTypeForFormule(m_elementAVariablesDynamiques);
m_wndAideFormule.ObjetInterroge = typeof(C2iTableExportCalculee.CTypeForFormule);
m_wndAideFormule.FournisseurProprietes = leType;
m_txtFormuleValeur.Init(m_wndAideFormule.FournisseurProprietes, m_wndAideFormule.ObjetInterroge);
m_txtFormuleNbRecords.Init(m_wndAideFormule.FournisseurProprietes, m_wndAideFormule.ObjetInterroge);
return(result);
}
//----------------------------------------------------------------------------------
private void AddTablesCalculees(DataSet ds, IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablesPourFiltre)
{
//Crée les tables calculees
foreach (C2iTableExportCalculee tableCalculee in m_listeTablesAutonomes)
{
DataTable tableAuto = tableCalculee.GetDataTable(elementAVariablesPourFiltre);
int nId = 1;
string strSource = tableAuto.TableName;
while (ds.Tables[tableAuto.TableName] != null)
{
tableAuto.TableName = strSource + "_" + nId;
nId++;
}
ds.Tables.Add(tableAuto);
}
}
/// /////////////////////////////////////////
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 (Expression == null)
{
return(null);
}
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(elementInterroge);
ctx.AttacheObjet(typeof(CContexteDonnee), elementInterroge.ContexteDonnee);
CResultAErreur result = Expression.Eval(ctx);
if (!result)
{
return(null);
}
return(result.Data);
}
/// /////////////////////////////////////////////////////////
public CResultAErreur InsertDataInDataSet(
IEnumerable list,
DataSet ds,
ITableExport tableParente,
int[] nValeursCle,
RelationAttribute relationToObjetParent,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablePourFiltres,
CCacheValeursProprietes cacheValeurs,
ITableExport tableFilleANeParCharger,
bool bAvecOptimisation,
CConteneurIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
result.EmpileErreur(I.T("Not supported function calling : C2iTableExportCalculée.InsertDataInDataset|124"));
return(result);
}
/// /////////////////////////////////////////////
///<summary>
///retourne la requête formattée pour SQL.
///</summary>
private string GetTexteRequeteFinaleSql(C2iRequete requete, IElementAVariablesDynamiquesAvecContexteDonnee elementAVariables, ref object[] valeursParametres, IDatabaseConnexion database)
{
ArrayList lstValeursParametres = new ArrayList();
string strTexte = requete.TexteRequete;
int nPos = strTexte.IndexOf("[@");
int nLastPos = nPos;
while (nPos > 0)
{
//Cherche le nom de la variable
string strNomVar = "";
nPos += 2;
while (nPos < strTexte.Length && strTexte[nPos] != ']')
{
strNomVar += strTexte[nPos];
nPos++;
}
string strIdVar = "";
foreach (CVariableDynamique variable in elementAVariables.ListeVariables)
{
if (strNomVar.ToUpper() == variable.Nom.ToUpper())
{
strIdVar = variable.IdVariable;
break;
}
}
if (strIdVar != "")
{
object val = elementAVariables.GetValeurChamp(strIdVar);
lstValeursParametres.Add(val);
strTexte = strTexte.Replace("[@" + strNomVar + "]", database.GetNomParametre(lstValeursParametres.Count.ToString()));
}
if (nLastPos + 1 < strTexte.Length)
{
nPos = strTexte.IndexOf("[@", nLastPos + 1);
nLastPos = nPos;
}
else
{
nPos = -1;
}
}
valeursParametres = (object[])lstValeursParametres.ToArray(typeof(object));
return(strTexte);
}
/// ///////////////////////////////////////////
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 virtual void CopieStatique(IElementAVariablesDynamiquesAvecContexteDonnee elt)
{
if (elt != null)
{
ContexteDonnee = elt.ContexteDonnee;
foreach (IVariableDynamique variable in elt.ListeVariables)
{
CVariableDynamiqueStatique newVariable = new CVariableDynamiqueStatique(this);
newVariable.IdVariable = variable.IdVariable;
newVariable.Nom = variable.Nom;
newVariable.Description = variable.Description;
newVariable.SetTypeDonnee(variable.TypeDonnee);
AddVariable(newVariable);
SetValeurChamp(newVariable, elt.GetValeurChamp(variable));
}
m_nIdSession = elt.IdSession;
m_contexteDonnee = elt.ContexteDonnee;
}
}
//----------------------------------------------------------------------------------
public CResultAErreur Export(int nIdSession,
IEnumerable list,
ref DataSet ds,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablesPourFiltre,
IIndicateurProgression indicateur)
{
if (list is CListeObjetsDonnees && m_bTraitementSurServeur)
{
CResultAErreur result = CResultAErreur.True;
CStringSerializer serializer = new CStringSerializer(ModeSerialisation.Ecriture);
I2iSerializable listeToSerialize = (I2iSerializable)list;
result = serializer.TraiteObject(ref listeToSerialize);
if (!result)
{
return(result);
}
I2iExporteurSurServeur exporteur = ( I2iExporteurSurServeur )C2iFactory.GetNewObjetForSession("C2iExporteurSurServeur", typeof(I2iExporteurSurServeur), nIdSession);
try
{
result = exporteur.ExportData(serializer.String, this, elementAVariablesPourFiltre, indicateur);
if (result)
{
ds = (DataSet)result.Data;
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error during the export on the server|101"));
}
return(result);
}
if (IsStructureComplexe)
{
return(ExportComplexe(nIdSession, list, ref ds, elementAVariablesPourFiltre, indicateur));
}
else
{
return(ExportSimple(nIdSession, list, ref ds, indicateur));
}
}
//------------------------------------------
public CResultAErreur InitChamps(
ITableExport table,
ITableExport tableParente,
C2iStructureExport structure,
IElementAVariablesDynamiquesAvecContexteDonnee eltAVariablesPourFiltre)
{
CResultAErreur result = CResultAErreur.True;
m_tableExport = table as C2iTableExport;
m_tableParente = tableParente;
m_structureExport = structure;
m_elementAVariablesPourFiltre = eltAVariablesPourFiltre;
if (m_tableExport == null)
{
result.EmpileErreur(I.T("Bad table format|20003"));
return(result);
}
InitChamps();
return(result);
}
/// //////////////////////////////////////////////////////////////
public CResultAErreur GetFiltreDataAAppliquer(IElementAVariablesDynamiquesAvecContexteDonnee elementAVariables)
{
CResultAErreur result = CResultAErreur.True;
if (FiltreAAppliquer == null)
{
return(result);
}
if (m_filtreDataAAppliquerCache == null)
{
FiltreAAppliquer.ElementAVariablesExterne = elementAVariables;
result = FiltreAAppliquer.GetFiltreData();
if (!result)
{
return(result);
}
m_filtreDataAAppliquerCache = (CFiltreData)result.Data;
}
result.Data = m_filtreDataAAppliquerCache;
return(result);
}
//------------------------------------------
public CResultAErreur InitChamps(
ITableExport table,
ITableExport tableParente,
C2iStructureExport structure,
IElementAVariablesDynamiquesAvecContexteDonnee eltAVariablesPourFiltre)
{
CResultAErreur result = CResultAErreur.True;
m_tableVue = table as C2iTableExportVue;
m_tableParente = tableParente;
m_structureExport = structure;
m_elementAVariablesPourFiltre = eltAVariablesPourFiltre;
if (m_tableVue == null)
{
result.EmpileErreur(I.T("Bad table format|20003"));
return(result);
}
InitChamps();
//Crée une table bidon avec tous les champs de la table fille de cette table
DataTable tableBidon = new DataTable();
if (m_tableVue.TablesFilles.Length != 0)
{
foreach (IChampDeTable champ in m_tableVue.TablesFilles[0].Champs)
{
Type tp = champ.TypeDonnee;
if (tp.IsGenericType && tp.GetGenericTypeDefinition() == typeof(Nullable <>))
{
tp = tp.GetGenericArguments()[0];
}
DataColumn col = new DataColumn(champ.NomChamp, tp);
tableBidon.Columns.Add(col);
}
}
m_fournisseur = new CFournisseurPropDynForDataTable(tableBidon);
return(result);
}
//----------------------------------------------------------------------------------
public CResultAErreur InitChamps(
ITableExport table,
ITableExport tableParente,
C2iStructureExport structure,
IElementAVariablesDynamiquesAvecContexteDonnee eltAVariablesDynamiques)
{
CResultAErreur result = CResultAErreur.True;
m_tableUnion = table as C2iTableExportUnion;
if (m_tableUnion == null)
{
return(CResultAErreur.False);
}
m_txtNomTable.Text = m_tableUnion.NomTable;
if (m_tableUnion.ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
m_lblType.Text = DynamicClassAttribute.GetNomConvivial(m_tableUnion.ChampOrigine.TypeDonnee.TypeDotNetNatif);
}
else if (m_tableUnion.ChampOrigine != null)
{
m_lblType.Text = m_tableUnion.ChampOrigine.Nom;
}
else
{
m_lblType.Text = "";
}
m_chkSupprimerTablesTravail.Checked = m_tableUnion.SupprimerTablesTravail;
m_tableUnion.RecalcStructure();
FillListeChamps();
return(result);
}
public static void SetElementAVariablesExternes(IElementAVariablesDynamiquesAvecContexteDonnee elt)
{
m_elementAVariablesExternes = elt;
}
//---------------------------------
public override CResultAErreur GetFiltreDataAAppliquer(IElementAVariablesDynamiquesAvecContexteDonnee elementAVariables)
{
CResultAErreur result = CResultAErreur.True;
return(result);
}
/// /////////////////////////////////////////////////////////
public CResultAErreur InsertDataInDataSet(
IEnumerable list,
DataSet ds,
ITableExport tableParente,
int[] nValeursCle,
RelationAttribute relationToObjetParent,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablePourFiltres,
CCacheValeursProprietes cacheValeurs,
ITableExport tableFilleANeParCharger,
bool bAvecOptimisation,
CConteneurIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
if (NePasCalculer)
{
return(result);
}
int nValeurIndicateur = 0;
indicateur.SetBornesSegment(0, m_tableauCroise == null?2:3);
if (list == null)
{
return(result);
}
if (!(list is CListeObjetsDonnees))
{
result.EmpileErreur(I.T("Attempt of cumulated table on something other that a data list|125"));
return(result);
}
CListeObjetsDonnees listeDonnees = (CListeObjetsDonnees)list;
if (relationToObjetParent == null)
{
//Principe de la lecture en une fois :
//Si la liste des une liste objets contenus, c'est que chaque élément
//est un composant d'un parent. On stock donc tous les parents
//Pour lesquels on veut les données,
//et elles seront lues dans le EndInsertTable.
//Par contre si la liste contenu a un filtre, on ne peut plus
//stocker juste ça, il faudrait en plus stocker le filtre et ça
//devient compliqué.
if (listeDonnees is CListeObjetsDonneesContenus &&
(listeDonnees.Filtre == null ||
!listeDonnees.Filtre.HasFiltre))
{
CListeObjetsDonneesContenus listeContenu = (CListeObjetsDonneesContenus)listeDonnees;
if (listeContenu.ObjetConteneur != null &&
typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(listeContenu.ObjetConteneur.GetType()))
{
if (m_mapIdBaseParentToReadToIdTable == null)
{
m_mapIdBaseParentToReadToIdTable = new Hashtable();
}
m_mapIdBaseParentToReadToIdTable[((CObjetDonneeAIdNumerique)listeContenu.ObjetConteneur).Id] = nValeursCle[0];
m_strChampIdParent = listeContenu.ChampsFille[0];
m_tableParente = tableParente;
listeContenu.GetFiltreForRead();
m_nIdSession = listeContenu.ContexteDonnee.IdSession;
m_elementAVariablePourFiltres = elementAVariablePourFiltres;
return(result);
}
}
}
DataTable table = ds.Tables[NomTable];
if (table == null)
{
result.EmpileErreur(I.T("Table @1 doesn't exist|116", NomTable));
return(result);
}
DataColumn colFille = null;
if (tableParente != null)
{
foreach (Constraint constraint in table.Constraints)
{
if (constraint is ForeignKeyConstraint)
{
ForeignKeyConstraint fkConst = (ForeignKeyConstraint)constraint;
colFille = fkConst.Columns[0];
}
}
}
CFiltreData filtreDeBase = listeDonnees.GetFiltreForRead();
result = GetFiltreDataAAppliquer(elementAVariablePourFiltres);
if (!result)
{
result.EmpileErreur(I.T("Error in cumulated table @1 filter|126", NomTable));
return(result);
}
CFiltreData leFiltreComplet = CFiltreData.GetAndFiltre(
filtreDeBase, (CFiltreData)result.Data);
C2iRequeteAvancee requete = m_requete;
CTableauCroise tableauCroise = m_tableauCroise;
string strChampParent = "";
if (relationToObjetParent != null)
{
requete = (C2iRequeteAvancee)CCloner2iSerializable.Clone(m_requete);
strChampParent = relationToObjetParent.ChampsParent[0] + "_CLE_DB";
Type typeChampParent = typeof(string);
IChampDeTable champParent = tableParente.Champs.FirstOrDefault(c => c.NomChamp == strChampParent);
if (champParent != null)
{
typeChampParent = champParent.TypeDonnee;
}
C2iChampDeRequete champ = new C2iChampDeRequete(
strChampParent,
new CSourceDeChampDeRequete(relationToObjetParent.ChampsFils[0]),
typeof(int),
OperationsAgregation.None,
true);
requete.ListeChamps.Add(champ);
string strListe = "";
foreach (int nId in nValeursCle)
{
strListe += nId.ToString() + ";";
}
strListe = strListe.Substring(0, strListe.Length - 1);
leFiltreComplet = CFiltreData.GetAndFiltre(leFiltreComplet, new CFiltreDataAvance(
requete.TableInterrogee,
relationToObjetParent.ChampsFils[0] + " in {" + strListe + "}"));
if (tableauCroise != null)
{
tableauCroise = (CTableauCroise)CCloner2iSerializable.Clone(m_tableauCroise);
tableauCroise.AddChampCle(new CCleTableauCroise(strChampParent, typeChampParent));
}
}
requete.FiltreAAppliquer = leFiltreComplet;
indicateur.SetInfo(I.T("Table @1 (request)|127", NomTable));
if (ChampOrigine == null)
{
requete.TableInterrogee = CContexteDonnee.GetNomTableForType(listeDonnees.TypeObjets);
}
result = requete.ExecuteRequete(listeDonnees.ContexteDonnee.IdSession);
indicateur.SetValue(nValeurIndicateur++);
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
if (!result)
{
return(result);
}
if (result.Data == null)
{
return(null);
}
DataTable tableDonnees = (DataTable)result.Data;
if (tableauCroise != null)
{
indicateur.SetInfo(I.T("Table @1 (cross table)|128", NomTable));
result = tableauCroise.CreateTableCroisee(tableDonnees);
indicateur.SetValue(nValeurIndicateur++);
if (!result)
{
result.EmpileErreur(I.T("Error in data crossing|130"));
return(result);
}
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
tableDonnees = (DataTable)result.Data;
foreach (DataColumn col in tableDonnees.Columns)
{
DataColumn laColonne = table.Columns[col.ColumnName];
if (laColonne == null)
{
table.Columns.Add(col.ColumnName, col.DataType);
}
//Stef le 5/5/2005 : Si la colonne n'est pas du bon type,
//son type est ajusté !
else if (laColonne.DataType != col.DataType)
{
laColonne.DataType = col.DataType;
}
}
}
else
{
//Ajuste le type des colonnes
foreach (DataColumn col in tableDonnees.Columns)
{
DataColumn laColonne = table.Columns[col.ColumnName];
if (laColonne != null && laColonne.DataType != col.DataType)
{
laColonne.DataType = col.DataType;
}
}
}
indicateur.SetInfo(I.T("Storage|129"));
indicateur.PushSegment(nValeurIndicateur, nValeurIndicateur + 1);
indicateur.SetBornesSegment(0, tableDonnees.Rows.Count);
int nFrequence = Math.Min(tableDonnees.Rows.Count / 20, 500) + 1;
//Intègre les données dans la table
ArrayList lstNewRows = new ArrayList();
int nCompteur = 0;
foreach (DataRow row in tableDonnees.Rows)
{
nCompteur++;
if (nCompteur % nFrequence == 0)
{
indicateur.SetValue(nCompteur);
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
}
DataRow newRow = table.NewRow();
foreach (DataColumn col in row.Table.Columns)
{
if (newRow.Table.Columns[col.ColumnName] != null)
{
newRow[col.ColumnName] = row[col];
}
}
if (colFille != null)
{
if (relationToObjetParent == null)
{
newRow[colFille] = nValeursCle[0];
}
else
{
newRow[colFille] = row[strChampParent];
}
}
table.Rows.Add(newRow);
}
indicateur.PopSegment();
return(result);
}
//----------------------------------------------------------------------------------
public CResultAErreur ExportComplexe(
int nIdSession,
IEnumerable list,
ref DataSet ds,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablesPourFiltres,
IIndicateurProgression indicateur)
{
if (m_cacheValeurs == null)
{
m_cacheValeurs = new CCacheValeursProprietes();
}
C2iSponsor sponsor = new C2iSponsor();
sponsor.Register(indicateur);
sponsor.Register(elementAVariablesPourFiltres);
CResultAErreur result = CResultAErreur.True;
try
{
indicateur = CConteneurIndicateurProgression.GetConteneur(indicateur);
DateTime dt = DateTime.Now;
//... Création des tables et des champs ...
bool bIsOptimisable = (list is CListeObjetsDonnees &&
typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(((CListeObjetsDonnees)list).TypeObjets)) ||
list == null;
result = CreateTableComplexeInDataset(bIsOptimisable, this.TypeSource, this.m_table, ds, null);
if (!result)
{
return(result);
}
AddTablesCalculees(ds, elementAVariablesPourFiltres);
if (list == null)
{
return(result);
}
m_cacheValeurs.CacheEnabled = true;
//ds.EnforceConstraints = false;
try
{
CInterpreteurProprieteDynamique.AssociationsSupplementaires.AssocieObjet(null, elementAVariablesPourFiltres);
CFournisseurGeneriqueProprietesDynamiques.AssocieObjetSupplementaire(null, new CObjetPourSousProprietes(elementAVariablesPourFiltres));
result = m_table.InsertDataInDataSet(list, ds, null, 0, elementAVariablesPourFiltres, m_cacheValeurs, null, true, CConteneurIndicateurProgression.GetConteneur(indicateur));
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
CInterpreteurProprieteDynamique.AssociationsSupplementaires.DissocieObjet(null, elementAVariablesPourFiltres);
CFournisseurGeneriqueProprietesDynamiques.DissocieObjetSupplementaire(null, new CObjetPourSousProprietes(elementAVariablesPourFiltres));
}
//ds.EnforceConstraints = true;
m_cacheValeurs.ResetCache();
m_cacheValeurs.CacheEnabled = false;
if (!result)
{
return(result);
}
result = m_table.EndInsertData(ds);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
sponsor.Unregister(indicateur);
sponsor.Unregister(elementAVariablesPourFiltres);
sponsor.Dispose();
}
return(result);
}
/// <summary>
/// Stocke le résultat d'une requête pour un type de données
/// </summary>
/// <param name="nIdTypeDonnee"></param>
/// <param name="requete"></param>
/// <returns></returns>
public CResultAErreur StockeResultat(int nIdTypeDonnee, IIndicateurProgression indicateur)
{
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(indicateur);
CResultAErreur result = CResultAErreur.True;
if (m_tableCalculsEnCours[nIdTypeDonnee] != null)
{
result.EmpileErreur(I.T("The recalculation for this cumulated data type is already in progress|143"));
return(result);
}
m_tableCalculsEnCours[nIdTypeDonnee] = true;
CSessionProcessServeurSuivi sessionSuivi = null;
try
{
//Crée une session pour le calcul
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
if (session == null)
{
result.EmpileErreur(I.T("Session error|144"));
return(result);
}
System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.BelowNormal;
sessionSuivi = new CSessionProcessServeurSuivi();
result = sessionSuivi.OpenSession(new CAuthentificationSessionServer(),
I.T("Recalculation of datas @1|145", nIdTypeDonnee.ToString()),
session);
if (!result)
{
result.EmpileErreur(I.T("Opening session error|146"));
return(result);
}
IdSession = sessionSuivi.IdSession;
System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Lowest;
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
//Récupère le type de donnée
CTypeDonneeCumulee typeDonnee = new CTypeDonneeCumulee(contexte);
if (!typeDonnee.ReadIfExists(nIdTypeDonnee))
{
result.EmpileErreur(I.T("The cumulated data type @1 doesn't exist|147", nIdTypeDonnee.ToString()));
return(result);
}
if (indicateur != null)
{
indicateur.SetInfo(I.T("Existing datas recovery|148"));
indicateur.SetValue(0);
}
CParametreDonneeCumulee parametre = typeDonnee.Parametre;
//Lit les données pour ce type de donnée cumulée
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, typeof(CDonneeCumulee));
liste.Filtre = new CFiltreData(CTypeDonneeCumulee.c_champId + "=@1",
nIdTypeDonnee);
liste.AssureLectureFaite();
if (parametre.ViderAvantChaqueCalcul)
{
result = VideTable(nIdTypeDonnee, contexte.Tables[CDonneeCumulee.c_nomTable]);
if (!result)
{
return(result);
}
}
//Liste des champs clé à lire
ArrayList lstClesALire = new ArrayList();
//Liste des champs destination des clés
ArrayList lstDestClesALire = new ArrayList();
//Liste des valeurs décimales à lire
ArrayList lstValeursDecimalesALire = new ArrayList();
//Liste des champs destinatation des valeurs décimales
ArrayList lstDestValeursDecimalesALire = new ArrayList();
//Liste des valeurs dates à lire
ArrayList lstValeursDatesALire = new ArrayList();
//Liste des champs destinatation des valeurs dates
ArrayList lstDestValeursDatesALire = new ArrayList();
//Liste des valeurs texte à lire
ArrayList lstValeursTextesALire = new ArrayList();
//Liste des champs destinatation des valeurs texte
ArrayList lstDestValeursTextesALire = new ArrayList();
//Change les clés de la table de données pour qu'elles
//correspondent aux clés déclarées
//Pour des recherches ultérieures plus rapides
DataTable tableDonnees = contexte.Tables[CDonneeCumulee.c_nomTable];
DataColumn[] oldKey = tableDonnees.PrimaryKey;
ArrayList lstCles = new ArrayList();
for (int nCle = 0; nCle < CParametreDonneeCumulee.c_nbChampsCle; nCle++)
{
if (parametre.GetChampCle(nCle) != null &&
parametre.GetChampCle(nCle).Champ != "")
{
lstClesALire.Add(parametre.GetChampCle(nCle).Champ);
string strChampDest = CDonneeCumulee.c_baseChampCle + nCle.ToString();
lstDestClesALire.Add(strChampDest);
lstCles.Add(tableDonnees.Columns[strChampDest]);
}
}
try
{
tableDonnees.PrimaryKey = (DataColumn[])lstCles.ToArray(typeof(DataColumn));
}
catch
{
//On n'y arrive pas, on a probablement changé la requete ->On vide tout !
result = VideTable(nIdTypeDonnee, tableDonnees);
if (!result)
{
return(result);
}
tableDonnees.PrimaryKey = (DataColumn[])lstCles.ToArray(typeof(DataColumn));
}
//Repère les données à lire
for (int nChamp = 0; nChamp < CParametreDonneeCumulee.c_nbChampsValeur; nChamp++)
{
string strChamp = parametre.GetValueField(nChamp);
if (strChamp != null && strChamp != "")
{
lstValeursDecimalesALire.Add(strChamp);
lstDestValeursDecimalesALire.Add(CDonneeCumulee.c_baseChampValeur + nChamp.ToString());
}
}
for (int nChamp = 0; nChamp < CParametreDonneeCumulee.c_nbChampsDate; nChamp++)
{
string strChamp = parametre.GetDateField(nChamp);
if (strChamp != null && strChamp != "")
{
lstValeursDatesALire.Add(strChamp);
lstDestValeursDatesALire.Add(CDonneeCumulee.c_baseChampDate + nChamp.ToString());
}
}
for (int nChamp = 0; nChamp < CParametreDonneeCumulee.c_nbChampsTexte; nChamp++)
{
string strChamp = parametre.GetTextField(nChamp);
if (strChamp != null && strChamp != "")
{
lstValeursTextesALire.Add(strChamp);
lstDestValeursTextesALire.Add(CDonneeCumulee.c_baseChampTexte + nChamp.ToString());
}
}
if (indicateur != null)
{
indicateur.SetInfo(I.T("Request execution|149"));
indicateur.SetValue(10);
}
IDefinitionJeuDonnees defJeu = typeDonnee.Parametre.DefinitionDeDonnees;
IElementAVariablesDynamiquesAvecContexteDonnee eltAVariables = null;
if (defJeu is C2iRequete)
{
eltAVariables = (IElementAVariablesDynamiquesAvecContexteDonnee)defJeu;
}
else if (defJeu is CStructureExportAvecFiltre)
{
eltAVariables = ((CStructureExportAvecFiltre)defJeu).Filtre;
if (eltAVariables == null)
{
CFiltreDynamique filtre = new CFiltreDynamique(contexte);
filtre.TypeElements = defJeu.TypeDonneesEntree;
eltAVariables = filtre;
}
((CFiltreDynamique)eltAVariables).ContexteDonnee = contexte;
}
result = CParametreDonneeCumulee.GetTableSource(eltAVariables, defJeu, indicateur);
//Calcule le résultat de la requête demandée
if (!result)
{
result.EmpileErreur(I.T("Error in request|150"));
return(result);
}
//Liste des lignes trouvées dans la requête
Hashtable tableExistantes = new Hashtable();
DataTable tableSource = (DataTable)result.Data;
if (indicateur != null)
{
indicateur.SetInfo(I.T("Result Storage|151"));
indicateur.SetValue(20);
indicateur.PushSegment(20, 80);
indicateur.SetBornesSegment(0, tableSource.Rows.Count);
}
int nIndex = 0;
foreach (DataRow row in tableSource.Rows)
{
nIndex++;
if (indicateur != null && nIndex % 50 == 0)
{
indicateur.SetValue(nIndex);
}
lstCles.Clear();
for (int nCle = 0; nCle < lstClesALire.Count; nCle++)
{
lstCles.Add(row[(string)lstClesALire[nCle]]);
}
DataRow rowDest = tableDonnees.Rows.Find((object[])lstCles.ToArray(typeof(object)));
if (rowDest == null)
{
rowDest = tableDonnees.NewRow();
rowDest[CObjetDonnee.c_champIdUniversel] = CUniqueIdentifier.GetNew();
for (int nCle = 0; nCle < lstCles.Count; nCle++)
{
rowDest[(string)lstDestClesALire[nCle]] = lstCles[nCle];
}
rowDest[CTypeDonneeCumulee.c_champId] = nIdTypeDonnee;
tableDonnees.Rows.Add(rowDest);
}
// Rempli les valeurs décimales de destination
for (int nChampVal = 0; nChampVal < lstValeursDecimalesALire.Count; nChampVal++)
{
try
{
rowDest[(string)lstDestValeursDecimalesALire[nChampVal]] = Convert.ToDouble(row[(string)lstValeursDecimalesALire[nChampVal]]);
}
catch
{
rowDest[CDonneeCumulee.c_baseChampValeur + nChampVal.ToString()] = 0;
}
}
// Rempli les valeurs Dates de destination
for (int nChampVal = 0; nChampVal < lstValeursDatesALire.Count; nChampVal++)
{
try
{
rowDest[(string)lstDestValeursDatesALire[nChampVal]] = Convert.ToDateTime(row[(string)lstValeursDatesALire[nChampVal]]);
}
catch
{
rowDest[CDonneeCumulee.c_baseChampDate + nChampVal.ToString()] = DBNull.Value;
}
}
// Rempli les valeurs Texte de destination
for (int nChampVal = 0; nChampVal < lstValeursTextesALire.Count; nChampVal++)
{
try
{
rowDest[(string)lstDestValeursTextesALire[nChampVal]] = (row[(string)lstValeursTextesALire[nChampVal]]).ToString();
}
catch
{
rowDest[CDonneeCumulee.c_baseChampTexte + nChampVal.ToString()] = "";
}
}
tableExistantes[rowDest] = true;
}
//Remet la clé à la valeur initiale
tableDonnees.PrimaryKey = oldKey;
if (indicateur != null)
{
indicateur.PopSegment();
indicateur.PushSegment(80, 90);
indicateur.SetBornesSegment(0, tableDonnees.Rows.Count);
indicateur.SetInfo(I.T("Deleting of old values|152"));
}
if (!parametre.PasDeSuppression)
{
//Supprime les lignes à supprimer
ArrayList lstRows = new ArrayList(tableDonnees.Rows);
nIndex = 0;
foreach (DataRow row in lstRows)
{
if (!tableExistantes.Contains(row))
{
row.Delete();
}
nIndex++;
if (indicateur != null && nIndex % 50 == 0)
{
indicateur.SetValue(nIndex);
}
}
}
if (indicateur != null)
{
indicateur.PopSegment();
indicateur.SetInfo(I.T("Datas saving|153"));
}
contexte.EnableTraitementsAvantSauvegarde = false;
result = contexte.SaveAll(true);
if (indicateur != null)
{
indicateur.SetInfo(I.T("Finished calculation|154"));
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
return(result);
}
finally
{
if (sessionSuivi != null)
{
sessionSuivi.CloseSession();
}
m_tableCalculsEnCours.Remove(nIdTypeDonnee);
}
return(result);
}
}
/// /////////////////////////////////////////////
public CFiltreDynamique(IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablesExternes,
CContexteDonnee contexteDonnee)
{
m_elementAVariablesExterne = elementAVariablesExternes;
m_contexteDonnee = contexteDonnee;
}
/// ////////////////////////////////
public CResultAErreur ExecuteRequete(C2iRequete requete, IElementAVariablesDynamiquesAvecContexteDonnee elementAVariables, bool bStructureOnly)
{
CResultAErreur result = CResultAErreur.True;
Type typeReference = requete.TypeReferencePourConnexion;
if (typeReference != null)
{
///TODO
///Problème VersionObjet
object objServeur = CContexteDonnee.GetTableLoader(CContexteDonnee.GetNomTableForType(typeReference), null, IdSession);
if (objServeur != null)
{
typeReference = objServeur.GetType();
}
else
{
typeReference = null;
}
}
IDatabaseConnexion con;
if (typeReference == null)
{
con = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, "");
}
else
{
con = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, typeReference);
}
object[] lstParams = null;
string strRequete = GetTexteRequeteFinaleSql(requete, elementAVariables, ref lstParams, con);
int nOldTimeOut = con.CommandTimeOut;
con.CommandTimeOut = 60 * 10;
IDataAdapter adapter = con.GetAdapterForRequete(strRequete, lstParams);
DataSet ds = new DataSet();
try
{
lock (con)
{
if (bStructureOnly)
{
adapter.FillSchema(ds, SchemaType.Source);
}
else
{
adapter.Fill(ds);
}
}
if (ds.Tables.Count > 0)
{
DataTable table = ds.Tables[0];
if (requete.TableauCroise != null)
{
result = requete.TableauCroise.CreateTableCroisee(table);
if (result)
{
table = (DataTable)result.Data;
}
}
table.TableName = "DONNEES_REQUETE";
result.Data = table;
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error in the request '@1'|102", strRequete));
}
finally
{
con.CommandTimeOut = nOldTimeOut;
CUtilDataAdapter.DisposeAdapter(adapter);
}
return(result);
}
