//------------------------------------------------
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);
}
/// /////////////////////////////////////////////////////////////
public static CResultAErreur StartProcessMultiples(CProcess process,
CInfoDeclencheurProcess infoDeclencheur,
CReferenceObjetDonnee[] refsCible,
int nIdSession,
int?nIdVersion,
IIndicateurProgression indicateur)
{
process.InfoDeclencheur = infoDeclencheur;
///TODO
///Problème VersionObjet
IProcessEnExecutionInDbServeur processServeur = (IProcessEnExecutionInDbServeur)CContexteDonnee.GetTableLoader(c_nomTable, null, nIdSession);
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(processServeur);
CAppelleurFonctionAsynchrone appelleur = new CAppelleurFonctionAsynchrone();
CResultAErreur defaultResult = CResultAErreur.True;
defaultResult.EmpileErreur(I.T("Asynchronous call error @1|20032", "StartProcessMultiples"));
return(appelleur.StartFonctionAndWaitAvecCallback(
typeof(IProcessEnExecutionInDbServeur),
processServeur,
"StartProcessMultiples",
"",
defaultResult,
new CValise2iSerializable(process),
refsCible,
nIdVersion,
indicateur) as CResultAErreur);
}
}
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 CResultAErreur EnregistreDeclenchementEvenementSurClient(
CObjetDonneeAIdNumerique objet,
CInfoDeclencheurProcess infoDeclencheur,
IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
result.EmpileErreur(I.T("Not available for event handlers|50000"));
return(result);
}
/// ///////////////////////////////////////////////
public static void EndIndicateur(IIndicateurProgression indicateur)
{
if (indicateur is System.Windows.Forms.Form)
{
((System.Windows.Forms.Form)indicateur).Invoke((MethodInvoker) delegate
{
((System.Windows.Forms.Form)indicateur).Hide();
});
}
}
//-------------------------------------------------------------------
public CResultAErreur RunEvent(
CObjetDonneeAIdNumerique obj,
CInfoDeclencheurProcess infoDeclencheur,
IIndicateurProgression indicateur)
{
return(RunEvent(true,
obj,
infoDeclencheur,
indicateur));
}
//-------------------------------------------------------------------------------------------
public CResultAErreurType <CSessionImport> DoImportSurServeur(
int nIdSession,
DataTable tableSource,
COptionExecutionSmartImport options,
IIndicateurProgression indicateur)
{
ISmartImporterAgent st = C2iFactory.GetNewObjetForSession("CSmartImporterAgent", typeof(ISmartImporterAgent), nIdSession) as ISmartImporterAgent;
CResultAErreurType <CSessionImport> result = st.DoSmartImport(tableSource, this, options, indicateur);
return(result);
}
/// /////////////////////////////////////////////////////////////
public CResultAErreur RepriseProcess(int nIdAction, IIndicateurProgression indicateur)
{
///TODO
///Problème VersionObjet
IProcessEnExecutionInDbServeur processServeur = (IProcessEnExecutionInDbServeur)CContexteDonnee.GetTableLoader(c_nomTable, null, ContexteDonnee.IdSession);
using (C2iSponsor sponsor = new C2iSponsor())
{
sponsor.Register(processServeur);
return(processServeur.RepriseProcess(Id, nIdAction, indicateur));
}
}
/// ///////////////////////////////////////////////////////////
public static CResultAErreur InitClientTimos(
C2iMultitiersClientRegistre registre,
bool bAvecSynchronisation,
IIndicateurProgression indicateurProgression)
{
return(InitClientTimos(
registre.GetFactoryURL(),
registre.GetRemotingTCPChannel(),
registre.GetBindTCPChannelBindTo(),
indicateurProgression));
}
public static CConteneurIndicateurProgression GetConteneur(IIndicateurProgression indicateur)
{
CConteneurIndicateurProgression conteneurIndic = (indicateur as CConteneurIndicateurProgression);
if (conteneurIndic != null)
{
return(conteneurIndic);
}
CConteneurIndicateurProgression conteneur = ( CConteneurIndicateurProgression )Activator.CreateInstance(m_typeConteneurParDefaut, true);
conteneur.Indicateur = indicateur;
return(conteneur);
}
private bool CreateJeuDeTest()
{
CServicePopupProgressionTimos serviceIndicateur = new CServicePopupProgressionTimos();
IIndicateurProgression indicateur = serviceIndicateur.GetNewIndicateurAndPopup();
DataSet ds = m_panelMultiStructure.GetJeuEssai(indicateur);
if (ds != null)
{
try
{
Rapport.CompleteDataSetDonnees(ds, m_panelMultiStructure.MultiStructure);
}
catch (Exception e)
{
serviceIndicateur.EndIndicateur(indicateur);
CFormAlerte.Afficher(e.ToString(), EFormAlerteType.Erreur);
return(false);
}
}
serviceIndicateur.EndIndicateur(indicateur);
if (ds == null)
{
return(false);
}
/*CMultiStructureExport structure = m_panelMultiStructure.MultiStructure;
* if ( structure.Formulaire != null && structure.Formulaire.Childs.Length > 0 )
* {
* if ( !CFormFormulairePopup.EditeElement ( structure.Formulaire, structure, "Données de l'état" ) )
* return false;
* }
* CServicePopupProgressionCafel serviceIndicateur = new CServicePopupProgressionCafel();
* IIndicateurProgression indicateur = serviceIndicateur.GetNewIndicateurAndPopup();
* CResultAErreur result = Rapport.GetDataFromMultiStructure( structure, null, false, indicateur );
* serviceIndicateur.EndIndicateur(indicateur);
* if ( !result )
* {
* CFormAlerte.Afficher( result.Erreur );
* return false;
* }*/
m_datasetTest = ds;
return(true);
}
/// //////////////////////////////////////////
public void AttacheIndicateur(IIndicateurProgression indicateur)
{
try
{
lock ( m_listeIndicateursProgression )
{
indicateur.SetBornesSegment(m_gestionnaireProgression.MinValue, m_gestionnaireProgression.MaxValue);
indicateur.SetInfo(m_strInfoProgression);
indicateur.CanCancel = m_bCanCancel;
m_listeIndicateursProgression.Add(indicateur);
}
}
catch
{
}
}
public CContexteExecutionAction(
CProcessEnExecutionInDb processEnExecution,
CBrancheProcess branche,
object objetCible,
CContexteDonnee contexteDonnee,
IIndicateurProgression indicateur)
{
m_processEnExecution = processEnExecution;
m_contexteDonnee = contexteDonnee;
m_branche = branche;
m_objetCible = objetCible;
PushElementInfoProgress(m_objetCible);
m_indicateurProgression = indicateur;
m_timerRefreshIndicateur.Elapsed += new ElapsedEventHandler(m_timerRefreshIndicateur_Elapsed);
m_timerRefreshIndicateur.Interval = c_nDelayRefreshIndicateur;
}
/// /////////////////////////////////////////
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 CResultAErreur RunEvent(
bool bAutoManagerHandlerTermine,
CObjetDonneeAIdNumerique obj,
CInfoDeclencheurProcess infoDeclencheur,
IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
CProcessEnExecutionInDb process = ProcessSource;
if (ProcessSource != null)
{
result = process.RepriseProcess(IdActionDeProcessToExecute, indicateur);
}
else if (EtapeWorkflowATerminer != null)
{
using (CContexteDonnee contexte = new CContexteDonnee(ContexteDonnee.IdSession, true, false))
{
CEtapeWorkflow etape = EtapeWorkflowATerminer.GetObjetInContexte(contexte) as CEtapeWorkflow;
if (etape != null)
{
result = etape.EndEtapeAndSaveIfOk();
}
if (!result)
{
//L'étape ne s'est pas terminée ? tant pis alors, c'est pas grave, elle se terminera par ailleurs
result = CResultAErreur.True;
return(result);
}
}
}
//gestion du handler faite ailleurs
if (!bAutoManagerHandlerTermine)
{
if (!result)
{
result.EmpileErreur(I.T("@1 handler error|271", Libelle));
}
return(result);
}
EndHandler(result);
return(result);
}
//----------------------------------------------------------------------------------
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));
}
}
//--------------------------------------------------------------
private void m_btnImporter_Click(object sender, EventArgs e)
{
CConfigMappagesSmartImport config = null;
DataTable table = null;
CResultAErreur result = PrepareImport(ref config, ref table);
if (!result || table == null)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
if (!CFormOptionsImport.EditeOptions(m_optionsExecution))
{
return;
}
IIndicateurProgression indicateur = null;
indicateur = CFormProgression.GetNewIndicateurAndPopup(I.T("Importing data|20245"));
CResultAErreurType <CSessionImport> resSession;
resSession = config.DoImportSurServeur(CSc2iWin32DataClient.ContexteCourant.IdSession,
table,
m_optionsExecution,
indicateur);
CFormProgression.EndIndicateur(indicateur);
if (m_optionsExecution.NomFichierSauvegarde != null &&
m_optionsExecution.NomFichierSauvegarde.Length > 0)
{
result = CSerializerObjetInFile.SaveToFile(resSession.DataType, "IMPORT_SESSION", m_optionsExecution.NomFichierSauvegarde);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
}
SetSessionEnCours(resSession.DataType);
CFormEditionSessionImport.EditeSession(m_sessionImport);
}
//--------------------------------------------------------------------------------------------------------------------
public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
IDataBaseCreator createur = connection.GetDataBaseCreator();
string strNomTableInContexte = CContexteDonnee.GetNomTableForType(m_type);
string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(strNomTableInContexte);
createur.CreationOuUpdateTableFromType(m_type);
string strChampIdObjet = m_strChampIdObjet;
if (m_strChampIdObjet.StartsWith("#SQL#"))
{
strChampIdObjet = m_strChampIdObjet.Substring("#SQL#".Length);
}
CObjetServeur.ClearCacheSchemas();
if (createur.ChampExists(strNomTableInDb, strChampIdObjet) &&
createur.ChampExists(strNomTableInDb, m_strChampDbKey))
{
using (CContexteDonnee ctx = new CContexteDonnee(connection.IdSession, true, false))
{
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.TableInterrogee = strNomTableInDb;
CStructureTable structure = CStructureTable.GetStructure(m_type);
/*
* requete.ListeChamps.Add ( new C2iChampDeRequete (
* "ID",
* new CSourceDeChampDeRequete(structure.ChampsId[0].NomChamp),
* typeof(int),
* OperationsAgregation.None,
* true ));*/
requete.ListeChamps.Add(new C2iChampDeRequete(
"IDOBJET",
new CSourceDeChampDeRequete(m_strChampIdObjet),
typeof(int),
OperationsAgregation.None,
true));
if (m_typeObjetFixe == null)
{
requete.ListeChamps.Add(new C2iChampDeRequete(
"TYPEOBJET",
new CSourceDeChampDeRequete(m_strChampTypeObjet),
typeof(string),
OperationsAgregation.None,
true));
}
result = requete.ExecuteRequete(connection.IdSession);
if (!result)
{
return(result);
}
DataTable table = result.Data as DataTable;
Dictionary <int, int?> dicIdToIdObjet = new Dictionary <int, int?>();
string strFieldIdObjetInTable = m_strChampIdObjet.Replace("#SQL#", "");
foreach (DataRow row in table.Rows)
{
object val = row["IDOBJET"];
int? nValId = val == DBNull.Value?null:(int?)val;
if (nValId != null && nValId >= 0)
{
CDbKey key = null;
Type tp = m_typeObjetFixe;
if (tp == null)//Type non fixe
{
string strType = (string)row["TYPEOBJET"];
tp = CActivatorSurChaine.GetType(strType);
}
if (tp != null)
{
CObjetDonneeAIdNumerique objPointe = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, ctx);
if (objPointe.ReadIfExists(nValId.Value))
{
key = objPointe.DbKey;
}
}
if (key != null)
{
string strRequete = "Update " + strNomTableInDb + " set " +
m_strChampDbKey + "=" + connection.GetStringForRequete(key.StringValue) + " where " +
strFieldIdObjetInTable + "=" + nValId.Value;
if (m_typeObjetFixe == null)
{
strRequete += " and " + m_strChampTypeObjet + "='" +
row["TYPEOBJET"].ToString() + "'";
}
connection.RunStatement(strRequete);
}
}
}
}
//Supprime le champ
createur.DeleteChamp(strNomTableInDb, strChampIdObjet);
}
return(result);
}
public abstract CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur);
//--------------------------------------------------------------------------------------------------------------------
public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
if (!typeof(IObjetDonneeAIdNumerique).IsAssignableFrom(m_type) || !CObjetDonnee.TypeManageIdUniversel(m_type))
{
result.EmpileErreur(m_type.ToString() + " can not have Universal Id");
}
string strNomTable = CContexteDonnee.GetNomTableForType(m_type);
CStructureTable structure = CStructureTable.GetStructure(m_type);
string strChampId = structure.ChampsId[0].NomChamp;
C2iRequeteAvancee requete = new C2iRequeteAvancee();
requete.FiltreAAppliquer = new CFiltreData(CObjetDonnee.c_champIdUniversel + "=@1", "");
requete.TableInterrogee = CContexteDonnee.GetNomTableForType(m_type);
requete.ListeChamps.Add(new C2iChampDeRequete(strChampId, new CSourceDeChampDeRequete(strChampId),
typeof(int),
OperationsAgregation.None, true));
Console.WriteLine("Update Universal id on " + strNomTable);
result = requete.ExecuteRequete(connection.IdSession);
if (!result)
{
return(result);
}
string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(strNomTable);
DataTable table = result.Data as DataTable;
int nNb = 0;
bool bWasInTrans = connection.IsInTrans();
if (bWasInTrans)
{
connection.CommitTrans();
}
DateTime dt = DateTime.Now;
if (table.Rows.Count > 0)
{
if (table.Rows.Count > 10000 && connection is COracleDatabaseConnexion)
{
string strQuery = "Update " + strNomTableInDb + " set " + CObjetDonnee.c_champIdUniversel +
"=CONCAT('" + strNomTableInDb + "'," + strChampId + ")";
result = connection.RunStatement(strQuery);
}
else
{
foreach (DataRow row in table.Rows)
{
string strQuery = "Update " + strNomTableInDb + " set " +
CObjetDonnee.c_champIdUniversel + "='" + CUniqueIdentifier.GetNew() + "' where " +
strChampId + "=" + row[0].ToString();
result = connection.ExecuteScalar(strQuery);
if (!result)
{
break;
}
nNb++;
if (nNb % 100 == 0)
{
TimeSpan sp = DateTime.Now - dt;
double fVal = (double)sp.TotalSeconds / (double)nNb * (double)(table.Rows.Count - nNb);
Console.WriteLine(strNomTableInDb + " " + nNb + "/" + table.Rows.Count + " reste " + fVal.ToString("0s"));
}
}
}
}
if (bWasInTrans)
{
connection.BeginTrans();
}
return(result);
/*
*
* //Trouve tous les éléments du type qui n'ont pas d'id universel
* using (CContexteDonnee ctx = new CContexteDonnee(connection.IdSession, true, false))
* {
* CListeObjetsDonnees lst = new CListeObjetsDonnees(ctx, m_type, false);
* lst.Filtre = new CFiltreData(CObjetDonnee.c_champIdUniversel + "=@1", "");
* lst.Filtre.IgnorerVersionDeContexte = true;
* lst.AppliquerFiltreAffichage = false;
*
* foreach (IObjetDonnee objet in lst.ToArrayList())
* {
* objet.Row[CObjetDonnee.c_champIdUniversel] = CUniqueIdentifier.GetNew();
* }
* string strNomTable = CContexteDonnee.GetNomTableForType(m_type);
* CObjetServeur objetServeur = CContexteDonnee.GetTableLoader(strNomTable, null, connection.IdSession) as CObjetServeur;
* int nCount = ctx.Tables[strNomTable].Rows.Count;
* DataTable tableSource = ctx.Tables[strNomTable];
*
* List<string> lstChampsExclus = new List<string>();
* HashSet<string> lstIDs = new HashSet<string>();
* CStructureTable structure = CStructureTable.GetStructure(m_type);
* foreach (CInfoChampTable info in structure.ChampsId)
* lstIDs.Add(info.NomChamp);
*
* foreach (CInfoChampTable champ in structure.Champs)
* if (champ.NomChamp != CObjetDonnee.c_champIdUniversel && !lstIDs.Contains(champ.NomChamp))
* lstChampsExclus.Add(champ.NomChamp);
*
* IDataAdapter adapter = objetServeur.GetDataAdapter(DataRowState.Modified, lstChampsExclus.ToArray());
*
* for (int nRow = 0; nRow < nCount; nRow += 5000)
* {
*
* using (DataSet dsCopie = new DataSet())
* {
* dsCopie.EnforceConstraints = false;
* DataTable tableCopie = ctx.Tables[strNomTable].Clone();
* tableCopie.BeginLoadData();
* dsCopie.Tables.Add(tableCopie);
* int nMax = Math.Min(nRow + 5000, nCount);
* DateTime dt = DateTime.Now;
* for (int n = nRow; n < nMax; n++)
* {
* tableCopie.ImportRow(tableSource.Rows[n]);
* }
* TimeSpan sp = DateTime.Now - dt;
* Console.WriteLine("Write 1" + strNomTable + " " + nRow + "/" + nCount+" "+sp.TotalSeconds.ToString());
* adapter.Update(dsCopie);
* sp = DateTime.Now - dt;
* Console.WriteLine("Write 2" + strNomTable + " " + nRow + "/" + nCount + " " + sp.TotalSeconds.ToString());
* }
* }
* }
* return result;*/
}
public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
IDataBaseCreator createur = connection.GetDataBaseCreator();
if (createur.TableExists(m_strNomTable))
{
result = createur.DeleteTable(m_strNomTable);
}
return(result);
}
public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
{
return(CResultAErreur.True);
}
public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
{
return(Delegue(connection.GetDataBaseCreator()));
}
public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
{
if (connection.GetDataBaseCreator().ChampExists(m_strNomTable, m_strNomChamp))
{
return(connection.GetDataBaseCreator().DeleteChamp(m_strNomTable, m_strNomChamp));
}
return(CResultAErreur.True);
}
public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
{
IDataBaseCreator creator = connection.GetDataBaseCreator();
string strNomTable = DynamicClassAttribute.GetNomConvivial(m_type);
if (!m_bSuppression)
{
#if PDA
return(COracleTableCreator.CreationOuUpdateTableFromType(tp, m_nIdSession));
#else
return(creator.CreationOuUpdateTableFromType(m_type, new ArrayList(m_strChampsAutorisesANull)));
#endif
}
else
{
#if PDA
return(CSQLCeTableCreator.SuppressionTable(strNomTable, m_nIdSession));
#else
return(creator.DeleteTable(CStructureTable.GetStructure(m_type).NomTableInDb));
#endif
}
}
/// <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 double RecalcActualCost(IIndicateurProgression indicateur)
{
CUtilElementACout.RecalculeCoutDescendant(this, true, true, indicateur);
return(CoutReel);
}
public CBackgroundWorkerAvecProgress(IIndicateurProgression indicateur)
{
m_indicateur = CConteneurIndicateurProgression.GetConteneur(indicateur);
}
private void m_btnTesterImport_Click(object sender, EventArgs e)
{
CConfigMappagesSmartImport config = null;
DataTable table = null;
CResultAErreur result = PrepareImport(ref config, ref table);
if (!result || table == null)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
DialogResult dr = MessageBox.Show(I.T("Would you like to save configuration first ?|20225"), "",
MessageBoxButtons.YesNoCancel,
MessageBoxIcon.Question);
if (dr == DialogResult.Cancel)
{
return;
}
if (dr == DialogResult.Yes)
{
if (!SaveConfig())
{
return;
}
}
if (!CFormOptionsSimulation.EditeOptions(m_optionsSimulation))
{
return;
}
using (CContexteDonnee ctx = new CContexteDonnee(CSc2iWin32DataClient.ContexteCourant.IdSession, true, false))
{
CContexteImportDonnee contexteImport = new CContexteImportDonnee(ctx);
contexteImport.StartLine = m_optionsSimulation.StartLine;
contexteImport.EndLine = m_optionsSimulation.EndLine;
contexteImport.BestEffort = true;
IIndicateurProgression indicateur = null;
indicateur = CFormProgression.GetNewIndicateurAndPopup(I.T("Testing import|20246"));
result = config.ImportTable(table, contexteImport, indicateur);
CFormProgression.EndIndicateur(indicateur);
indicateur = null;
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
if (m_optionsSimulation.TestDbWriting)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(ctx.IdSession);
session.BeginTrans();
result = ctx.SaveAll(false);
session.RollbackTrans();
if (!result)
{
if (CFormAlerte.Afficher(result.Erreur, EFormAlerteBoutons.ContinuerAnnuler, EFormAlerteType.Info) == System.Windows.Forms.DialogResult.Cancel)
{
return;
}
}
}
if (CFormResultatSmartImport.ShowImportResult(ctx, contexteImport, config, m_rootValues, table))
{
result = ctx.SaveAll(true);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
}
}
}
