//------------------------------------------------
public CResultAErreur ImportTable(
DataTable table,
CContexteImportDonnee contexteImport,
IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
Dictionary <DataRow, DataRow> m_dicSourceToDest = new Dictionary <DataRow, DataRow>();
contexteImport.TableSource = table;
int nNbDoTo = table.Rows.Count;
if (contexteImport.StartLine != null)
{
nNbDoTo -= contexteImport.StartLine.Value;
}
if (contexteImport.EndLine != null)
{
nNbDoTo -= (table.Rows.Count - contexteImport.EndLine.Value) - 1;
}
int nNbDone = 0;
if (indicateur != null)
{
indicateur.SetBornesSegment(0, nNbDoTo);
}
int nStart = contexteImport.StartLine == null ? 0 : contexteImport.StartLine.Value;
int nEnd = contexteImport.EndLine == null ? table.Rows.Count - 1 : Math.Min(contexteImport.EndLine.Value, table.Rows.Count - 1);
for (int nRowIndex = nStart; nRowIndex <= nEnd; nRowIndex++)
{
DataRow row = table.Rows[nRowIndex];
if (indicateur != null)
{
indicateur.SetInfo(I.T("Import line @1|20106", nRowIndex.ToString()));
}
contexteImport.StartImportRow(row, nRowIndex);
result = ImportRow(row, contexteImport, null, false);
nNbDone++;
if (indicateur != null)
{
indicateur.SetValue(nNbDone);
}
if (!result)
{
contexteImport.AddLog(new CLigneLogImport(
ETypeLigneLogImport.Error,
row,
null,
contexteImport,
I.T("Error on line import|20102")));
if (!contexteImport.BestEffort)
{
return(result);
}
result = CResultAErreur.True;
}
}
return(result);
}
private void SnmpUpdateThread(object sender, DoWorkEventArgs args)
{
if (m_bIsSnmpUpdating)
{
return;
}
IIndicateurProgression indicateur = sender as IIndicateurProgression;
m_bIsSnmpUpdating = true;
try
{
if (indicateur != null)
{
indicateur.SetBornesSegment(0, 100);
indicateur.SetValue(0);
indicateur.Masquer(false);
}
CSchemaReseau schema = m_stackCheminsReseau.Peek();
CListeCouplesEntiteChamp liste = schema.GetListeValeursSnmpAffichees();
liste.UpdateValeurs(schema.ContexteDonnee, indicateur);
if (indicateur != null)
{
indicateur.Masquer(true);
}
}
catch { }
finally
{
m_bIsSnmpUpdating = false;
}
}
//-------------------------------------------------------------------
public CResultAErreur ExecuteTache(int nIdIntervention, IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
CTachePlanifiee tache = new CTachePlanifiee(contexte);
if (!tache.ReadIfExists(nIdIntervention))
{
result.EmpileErreur(I.T("The Planned Task '@1' does not exist|338", nIdIntervention.ToString()));
return(result);
}
int nNbErreurs = 0;
C2iEventLog.WriteInfo(I.T("Starting planned task @1|339", tache.Libelle), NiveauBavardage.PetiteCausette);
int nNbFait = 0;
string strErreur = "";
foreach (CRelationTachePlanifieeProcess rel in tache.RelationsProcess)
{
if (indicateur != null)
{
indicateur.SetInfo(I.T("Action @1|340", rel.Process.Libelle));
}
CInfoDeclencheurProcess infoDeclencheur = new CInfoDeclencheurProcess(TypeEvenement.Date);
result = CProcessEnExecutionInDb.StartProcess(rel.Process.Process, infoDeclencheur, IdSession, null, null);
if (!result)
{
result.EmpileErreur(I.T("Action @1|341", rel.Process.Libelle));
strErreur += Environment.NewLine;
strErreur += result.Erreur.ToString() + Environment.NewLine + "-------------------------------------" + Environment.NewLine;
nNbErreurs++;
result = CResultAErreur.True;
}
nNbFait++;
if (indicateur != null)
{
indicateur.SetValue(nNbFait);
}
}
foreach (CRelationTachePlanifieeTypeDonneeCumulee relData in tache.RelationsTypesDonneesCumulees)
{
result = relData.TypeDonneeCumulee.StockResultat(indicateur);
if (!result)
{
result.EmpileErreur(I.T("Cumulated data @1|342", relData.TypeDonneeCumulee.Libelle));
strErreur += result.Erreur.ToString() + "\r\n-------------------------------------\r\n";
nNbErreurs++;
result = CResultAErreur.True;
}
}
C2iEventLog.WriteInfo(I.T("End of planned task @1, @2 error(s)|343", tache.Libelle, nNbErreurs.ToString()), NiveauBavardage.PetiteCausette);
return(result);
}
}
public void SetValue(int nValue)
{
try
{
if (m_indicateur != null)
{
m_indicateur.SetValue(nValue);
}
}
catch (Exception e)
{
}
}
//---------------------------------------------------------------------------
private CResultAErreur UpdateToVersion(int nVersion)
{
CResultAErreur result = CResultAErreur.True;
C2iDataBaseUpdateOperationList lstOps = m_structureDB.GetListeTypeOfVersion(nVersion);
int nCptOp = 0;
if (m_indicateurProgress != null)
{
m_indicateurProgress.SetBornesSegment(nCptOp, lstOps.Count);
}
bool bMAJVersion = true;
foreach (C2iDataBaseUpdateOperation op in lstOps)
{
if (m_indicateurProgress != null)
{
m_indicateurProgress.SetInfo(op.DescriptionOperation);
m_indicateurProgress.SetValue(nCptOp);
}
result = op.ExecuterOperation(Connection, m_indicateurProgress);
bMAJVersion = (op.GetType() != typeof(C2iDataBaseUpdateOperationNoSetVersionBase))? bMAJVersion:false;
nCptOp++;
if (!result)
{
break;
}
}
if (result && bMAJVersion && nVersion <= m_structureDB.GetLastVersion())
{
result = SetVersion(nVersion);
}
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 CFichier FindNext(bool bCanGoUp, CRepertoire repertoireStart, CFichier fichierStart, Regex regExRepertoire, Regex regExFichier, IIndicateurProgression indicateur)
{
bool bStartSearch = fichierStart == null;
if (repertoireStart != null && repertoireStart.RepertoireContenant == null)
{
repertoireStart = null;
}
if (regExRepertoire.IsMatch(Nom))
{
foreach (CFichier fichier in GetChilds <CFichier>())
{
if (fichier == fichierStart)
{
bStartSearch = true;
continue;
}
if (!bStartSearch)
{
continue;
}
if (regExFichier.IsMatch(fichier.Nom))
{
return(fichier);
}
}
}
if (RepertoireContenant == null && indicateur != null)
{
indicateur.SetBornesSegment(0, GetChilds <CRepertoire>().Count());
}
int nIndex = 0;
bStartSearch = repertoireStart == null;
foreach (CRepertoire rep in GetChilds <CRepertoire>())
{
if (RepertoireContenant == null)
{
indicateur.SetInfo(rep.Nom);
nIndex++;
indicateur.SetValue(nIndex);
}
if (rep == repertoireStart)
{
bStartSearch = true;
continue;
}
if (!bStartSearch)
{
continue;
}
CFichier trouve = rep.FindNext(false, null, null, regExRepertoire, regExFichier, indicateur);
if (trouve != null)
{
return(trouve);
}
if (indicateur.CancelRequest)
{
return(null);
}
}
if (RepertoireContenant != null && bCanGoUp)
{
return(RepertoireContenant.FindNext(true, this, null, regExRepertoire, regExFichier, indicateur));
}
return(null);
}
//---------------------------------------------------------------------------------
public CResultAErreurType <CSessionImport> DoSmartImport(
DataTable tableSource,
CConfigMappagesSmartImport config,
COptionExecutionSmartImport options,
IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
CSessionImport sessionImport = new CSessionImport();
sessionImport.TableSource = tableSource;
sessionImport.ConfigMappage = config;
CResultAErreurType <CSessionImport> resSession = new CResultAErreurType <CSessionImport>();
resSession.DataType = sessionImport;
int nTaillePaquet = options.TaillePaquets == null ? tableSource.Rows.Count : options.TaillePaquets.Value;
int nStartLigne = options.StartLine == null ? 0 : options.StartLine.Value;
int nEndLigne = options.EndLine == null ? tableSource.Rows.Count - 1 : Math.Min(options.EndLine.Value, tableSource.Rows.Count - 1);
int nNbToDo = nEndLigne - nStartLigne + 1;
int nNbDone = 0;
int?nIdVersionDonnees = null;
if (options.UtiliserVersionDonnee)
{
using (CContexteDonnee ctx = new CContexteDonnee(IdSession, true, false))
{
CVersionDonnees version = new CVersionDonnees(ctx);
version.CreateNew();
version.TypeVersion = new CTypeVersion(CTypeVersion.TypeVersion.Previsionnelle);
version.Libelle = I.T("Import data @1|20013", DateTime.Now.ToString("G"));
result = version.CommitEdit();
if (!result)
{
resSession.EmpileErreur(result.Erreur);
return(resSession);
}
nIdVersionDonnees = version.Id;
}
}
if (nStartLigne > 0)
{
sessionImport.AddLog(new CLigneLogImport(ETypeLigneLogImport.Info,
null,
"",
0,
nStartLigne - 1,
"Lines 0 to " + (nStartLigne - 1) + " are ignored"));
sessionImport.SetNonImportees(0, nStartLigne - 1);
}
if (nEndLigne < tableSource.Rows.Count - 1)
{
sessionImport.AddLog(new CLigneLogImport(ETypeLigneLogImport.Info,
null,
"",
nEndLigne + 1,
tableSource.Rows.Count - 1,
"Lines " + (nEndLigne + 1) + " to " + (tableSource.Rows.Count - 1) + " are ignored"));
sessionImport.SetNonImportees(nEndLigne + 1, tableSource.Rows.Count - 1);
}
//Ajoute dans la liste des lignes non importées, les lignes ignorées
using (C2iSponsor sponsor = new C2iSponsor())
{
if (indicateur != null)
{
sponsor.Register(indicateur);
indicateur.SetBornesSegment(0, nNbToDo);
}
try
{
while (nStartLigne <= nEndLigne)
{
using (CContexteDonnee ctxDonnees = new CContexteDonnee(IdSession, true, false))
{
if (m_nIdSession != null)
{
ctxDonnees.SetVersionDeTravail(nIdVersionDonnees, false);
}
CContexteImportDonnee ctxImport = new CContexteImportDonnee(ctxDonnees);
ctxImport.BestEffort = options.BestEffort;
ctxImport.StartLine = nStartLigne;
ctxImport.EndLine = Math.Min(nStartLigne + nTaillePaquet - 1, tableSource.Rows.Count - 1);
if (ctxImport.EndLine > nEndLigne)
{
ctxImport.EndLine = nEndLigne;
}
if (indicateur != null)
{
indicateur.PushSegment(nNbDone, nNbDone + ctxImport.EndLine.Value - ctxImport.StartLine.Value);
}
result = config.ImportTable(
tableSource,
ctxImport,
indicateur);
sessionImport.AddLogs(ctxImport.Logs);
if (indicateur != null)
{
indicateur.PopSegment();
}
if (result)
{
if (indicateur != null)
{
indicateur.SetInfo(I.T("Saving|20012"));
}
result = ctxDonnees.SaveAll(true);
if (!result)
{
sessionImport.SetNonImportees(ctxImport.StartLine.Value,
ctxImport.EndLine.Value);
sessionImport.AddLog(new CLigneLogImport(
ETypeLigneLogImport.Error,
null,
"",
ctxImport.StartLine.Value,
ctxImport.EndLine.Value,
"Error saving lines " + ctxImport.StartLine.Value + " to " + ctxImport.EndLine.Value + " " +
result.Erreur.ToString()));
}
if (!result && !ctxImport.BestEffort)
{
return(resSession);
}
if (result)
{
sessionImport.SetImportees(ctxImport.StartLine.Value,
ctxImport.EndLine.Value);
}
}
else
{
sessionImport.SetNonImportees(ctxImport.StartLine.Value,
ctxImport.EndLine.Value);
}
if (!result && !options.BestEffort)
{
return(resSession);
}
nStartLigne += nTaillePaquet;
nNbDone += nTaillePaquet;
if (indicateur != null)
{
indicateur.SetValue(nNbDone);
}
}
}
}
catch (Exception e)
{
resSession.EmpileErreur(new CErreurException(e));
}
finally
{
if (!result && !options.BestEffort)
{
resSession.EmpileErreur(result.Erreur);
}
}
return(resSession);
}
}
/// <summary>
/// Retourne le dataset correspondant à la multistructure. Le data du result contient le dataset
/// </summary>
/// <param name="bStructureOnly">Seulement la structure ( pas de données )</param>
/// <param name="listeDonnees">Liste de données à utiliser. Si non définit, chaque définition de données crée
/// sa propre liste, sinon, c'est cette liste qui sera utilisée par défaut</param>
/// <returns></returns>
public CResultAErreur GetDataSet(bool bStructureOnly, CListeObjetsDonnees listeDonnees, IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
//Le dataset complet
DataSet ds = new DataSet();
indicateur = CConteneurIndicateurProgression.GetConteneur(indicateur);
indicateur.SetBornesSegment(0, m_listeDefinitionsJeux.Count);
int NbFait = 0;
foreach (CElementMultiStructureExport element in m_listeDefinitionsJeux)
{
if (element.DefinitionJeu != null)
{
//result = element.DefinitionJeu.GetDonnees ( this, listeDonnees, CElementAVariablesDynamiques.GetNewFrom ( this ), indicateur );
result = element.DefinitionJeu.GetDonnees(this, listeDonnees, indicateur);
if (!result)
{
result.EmpileErreur(I.T("Error in the structure @1|183", element.Libelle));
return(result);
}
DataSet dsProv;
if (result.Data is DataTable)
{
if (((DataTable)result.Data).DataSet != null)
{
dsProv = ((DataTable)result.Data).DataSet;
}
else
{
dsProv = new DataSet();
dsProv.Tables.Add((DataTable)result.Data);
}
}
else
{
dsProv = (DataSet)result.Data;
}
if (ds.Tables.Count == 0)
{
ds = dsProv;
if (element.Prefixe.Trim() != "")
{
foreach (DataTable table in ds.Tables)
{
table.TableName = element.Prefixe.Trim() + "_" + table.TableName;
}
}
}
else
{
//Fusionne les dataset
//Nom de table dans dsProv->Nom de table dans ds
Hashtable tableRenommage = new Hashtable();
foreach (DataTable table in dsProv.Tables)
{
string strNomBase = (element.Prefixe.Trim() == ""?"":
element.Prefixe.Trim() + "_") + table.TableName;
string strNomTable = strNomBase;
int nIndex = 0;
while (ds.Tables[strNomTable] != null)
{
nIndex++;
strNomTable = strNomBase + "_" + nIndex.ToString();
}
table.TableName = strNomBase;
}
try
{
ds.Merge(dsProv, true);
}
catch (Exception exp)
{
result.EmpileErreur(I.T("Error while structures merging|184"));
result.EmpileErreur(new CErreurException(exp));
return(result);
}
}
}
NbFait++;
indicateur.SetValue(NbFait);
}
if (result)
{
result.Data = ds;
}
else
{
result.Data = null;
}
return(result);
}
//---------------------------------------------------------------------------
public CResultAErreur UpdateStructureBase(IIndicateurProgression indicateurProgress)
{
CResultAErreur result = CResultAErreur.True;
m_indicateurProgress = indicateurProgress;
int nVersionDB = (int)new CDatabaseRegistre(Connection).GetValeurLong(c_strCleVersionBDD, -1);
int nVersionFinale = m_structureDB.GetLastVersion();
int nOldVersion = nVersionDB;
if (nVersionDB < 0)
{
result = InitialisationBase();
}
if (m_bForceMAJ)
{
nVersionDB = nVersionDB > 0 ? nVersionDB - 1 : 0;
}
if (nVersionDB < 0)
{
nVersionDB = 0;
}
if (m_indicateurProgress != null)
{
m_indicateurProgress.PushLibelle(I.T("Database Update|30005"));
m_indicateurProgress.SetBornesSegment(nVersionDB, nVersionFinale);
//m_indicateurProgress.PushSegment(nVersionDB, nVersionFinale);
}
result = m_connexion.GetDataBaseCreator().UpdateStructureTableRegistre();
while (nVersionDB < nVersionFinale && result)
{
nVersionDB++;
result = m_connexion.BeginTrans();
if (!result)
{
return(result);
}
if (m_indicateurProgress != null)
{
m_indicateurProgress.SetInfo("Version " + nVersionDB.ToString());
m_indicateurProgress.SetValue(nVersionDB - 1);
m_indicateurProgress.PushLibelle("DataBase v" + nVersionDB.ToString());
m_indicateurProgress.PushSegment(nVersionDB - 1, nVersionDB);
}
result = UpdateToVersion(nVersionDB);
//Validation ou annulation des modifications si erreur
if (!result)
{
m_connexion.RollbackTrans();
result.EmpileErreur(I.T("Database Update Error|30006"));
throw new CExceptionErreur(result.Erreur);
}
else
{
result = m_connexion.CommitTrans();
}
if (m_indicateurProgress != null)
{
m_indicateurProgress.PopSegment();
m_indicateurProgress.PopLibelle();
}
}
/*if (m_indicateurProgress != null)
* m_indicateurProgress.PopSegment();*/
//rafraichit les caches de schéma
CObjetServeur.ClearCacheSchemas();
C2iOracleDataAdapter.ClearCacheSchemas();
CStructureTable.ClearCache();
return(result);
}
