//----------------------------------------------------------------------
public CResultAErreur UpdateValeurs(CContexteDonnee contexteDeBasePasEnEdition, IIndicateurProgression indicateurProgression)
{
if (Count == 0)
{
return(CResultAErreur.True);
}
CConteneurIndicateurProgression progress = CConteneurIndicateurProgression.GetConteneur(indicateurProgression);
CResultAErreur result = CResultAErreur.True;
//Lecture entite par entité pour optimiser la lecture
Dictionary <CEntiteSnmp, HashSet <CChampCustom> > lstChamps = new Dictionary <CEntiteSnmp, HashSet <CChampCustom> >();
progress.SetBornesSegment(0, Count);
foreach (CCoupleEntiteSnmp_Champ couple in this)
{
HashSet <CChampCustom> set = null;
if (!lstChamps.TryGetValue(couple.Entite, out set))
{
set = new HashSet <CChampCustom>();
lstChamps[couple.Entite] = set;
}
set.Add(couple.ChampCustom);
}
CSessionClient session = CSousSessionClient.GetNewSousSession(this[0].Entite.ContexteDonnee.IdSession);
session.OpenSession(new CAuthentificationSessionSousSession(this[0].Entite.ContexteDonnee.IdSession),
"SNMP", ETypeApplicationCliente.Service);
using (CContexteDonnee ctxModif = new CContexteDonnee(session.IdSession, true, false))
{
int nIndex = 1;
foreach (KeyValuePair <CEntiteSnmp, HashSet <CChampCustom> > kv in lstChamps)
{
CEntiteSnmp entite = kv.Key.GetObjetInContexte(ctxModif) as CEntiteSnmp;
CInterrogateurSnmp dynamicAgent = new CInterrogateurSnmp();
dynamicAgent.Connexion = entite.AgentSnmp.GetNewSnmpConnexion();
CEntiteSnmpPourSupervision ettSup = null;
foreach (CChampCustom champ in kv.Value)
{
int nIdChamp = champ.Id;
if (entite.ReadChampSnmp(nIdChamp, dynamicAgent, ref ettSup))
{
entite.CopieValeurSnmpDansValeurChamp(nIdChamp);
}
progress.SetValue(nIndex++);
}
}
progress.SetValue(Count);
ctxModif.SaveAll(true);
System.Threading.Thread.Sleep(2000);
session.CloseSession();
}
return(result);
}
public CBackgroundWorkerAvecProgress(IIndicateurProgression indicateur)
{
m_indicateur = CConteneurIndicateurProgression.GetConteneur(indicateur);
}
//----------------------------------------------------------------------------------
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>
/// 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 static CResultAErreur Init(
string strEventJournalName,
string strEventJournalTexte,
IIndicateurProgression indicateurProgress)
{
CResultAErreur result = CResultAErreur.True;
try
{
int nValeurIndicateur = 0;
C2iEventLog.Init(strEventJournalName, strEventJournalTexte, NiveauBavardage.VraiPiplette);
CConteneurIndicateurProgression indicateur = CConteneurIndicateurProgression.GetConteneur(indicateurProgress);
if (indicateur != null)
{
indicateur.PushSegment(0, 13);
}
CTraducteur.ReadFichier("");
#region Configuration du remoting
indicateur.SetValue(nValeurIndicateur++);
AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);
C2iSponsor.EnableSecurite();
#endregion
#region Configuration de l'allocateur d'objets
Dictionary <string, MarshalByRefObject> dicLocalSingleton = new Dictionary <string, MarshalByRefObject>();
dicLocalSingleton["sc2i.multitiers.client.IGestionnaireSessions"] = new CGestionnaireSessionSagexProSolo();
C2iFactory.InitEnLocal(new C2iObjetServeurFactory(), dicLocalSingleton);
indicateur.SetValue(nValeurIndicateur++);
CSessionClient session = CSessionClient.CreateInstance();
result = session.OpenSession(new CAuthentificationSessionServer(), "SagexProSolo", ETypeApplicationCliente.Service);
if (!result)
{
result.EmpileErreur(I.T("Opening session error|30010"));
return(result);
}
CSc2iDataServer.AddDefinitionConnexion(
new CDefinitionConnexionDataSource(
c_droitsDataSource,
typeof(CGestionnaireDroitsUtilisateurs),
""));
CSc2iDataServer.SetIdConnexionForClasse(typeof(CDroitUtilisateurServeur), c_droitsDataSource);
#endregion
#region Configuration de la base de données
indicateur.SetValue(nValeurIndicateur++);
Type typeConnexion = typeof(CAccess97DatabaseConnexion);
//Récuperation du type de connection
CSc2iDataServer.Init(
new CDefinitionConnexionDataSource(
c_mainDataSource,
typeConnexion,
"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=\"C:\\Documents and Settings\\GENERIC\\Mes documents\\BASEVIDE2000.MDB\"",
""));
#endregion
#region Ajout des références DLL
indicateur.SetValue(nValeurIndicateur++);
AppDomain.CurrentDomain.Load("sc2i.data.client");
AppDomain.CurrentDomain.Load("sc2i.data.serveur");
AppDomain.CurrentDomain.Load("sc2i.data.dynamic");
AppDomain.CurrentDomain.Load("sc2i.data.dynamic.loader");
AppDomain.CurrentDomain.Load("sc2i.process");
AppDomain.CurrentDomain.Load("sc2i.process.serveur");
AppDomain.CurrentDomain.Load("sc2i.expression");
AppDomain.CurrentDomain.Load("sc2i.Formulaire");
AppDomain.CurrentDomain.Load("futurocom.vectordb.data");
AppDomain.CurrentDomain.Load("futurocom.vectordb.data.server");
AppDomain.CurrentDomain.Load("futurocomapp.data");
AppDomain.CurrentDomain.Load("futurocomapp.data.server");
AppDomain.CurrentDomain.Load("sagexpro.data");
AppDomain.CurrentDomain.Load("sagexpro.data.serveur");
foreach (Assembly ass in AppDomain.CurrentDomain.GetAssemblies())
{
CContexteDonnee.AddAssembly(ass);
}
#endregion
#region Teste la connexion
indicateur.SetValue(nValeurIndicateur++);
IDatabaseConnexion cnx = CSc2iDataServer.GetInstance().GetDatabaseConnexion(session.IdSession, c_mainDataSource);
//Attend la connexion pendant au max 5 minutes pour que ça démarre
DateTime dtStartAttente = DateTime.Now;
TimeSpan delaiAttente = DateTime.Now - dtStartAttente;
result = cnx.IsConnexionValide();
while (!result && delaiAttente.TotalSeconds < 5 * 60)
{
C2iEventLog.WriteErreur(result.MessageErreur);
delaiAttente = DateTime.Now - dtStartAttente;
C2iEventLog.WriteErreur(I.T("Connection not availiable(@1)|30014", delaiAttente.TotalSeconds.ToString() + " s)") +
Environment.NewLine);
string messageErreur = I.T("The connection with the database could not have been established. Verify the connection string and check if the database has been started|30015");
C2iEventLog.WriteErreur(messageErreur);
result.EmpileErreur(messageErreur);
return(result);
}
if (typeof(CSqlDatabaseConnexion).IsAssignableFrom(typeConnexion))
{
cnx.RunStatement("SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED");
}
#endregion
//Initialisation des classes autoexecutables
CAutoexecuteurClasses.RunAutoexecs();
//Initialisation du serveur de documents GED
//Initialise les restrictions standards
#region Vérifie que les champs des tables font bien moins de 25 cars
indicateur.SetValue(nValeurIndicateur++);
DateTime dt = DateTime.Now;
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
CStructureTable structure = CStructureTable.GetStructure(tp);
if (structure.NomTable.Length > 25)
{
result.EmpileErreur("Table " + structure.NomTable + " (" + tp.ToString() + ")=" + structure.NomTable.Length + "cars");
}
if (structure.NomTable.ToUpper() != structure.NomTable)
{
result.EmpileErreur(I.T("Table name @1 must be uppercase|30018", structure.NomTable));
}
foreach (CInfoChampTable champ in structure.Champs)
{
if (champ.NomChamp.Length > 25)
{
result.EmpileErreur("Table " + structure.NomTable + " (" + tp.ToString() + ")\t champ " + champ.NomChamp + "=" + champ.NomChamp.Length + "cars");
}
if (champ.NomChamp.ToUpper() != champ.NomChamp)
{
result.EmpileErreur(I.T("The name of the field '@1' of the field '@2' must be uppercase|30019", champ.NomChamp, structure.NomTable));
}
}
}
TimeSpan sp = DateTime.Now - dt;
Console.WriteLine(I.T("Table name verification |30020") + sp.TotalMilliseconds);
if (!result)
{
return(result);
}
#endregion
#region Mise à jour de la structure de la base
indicateur.SetValue(nValeurIndicateur++);
CUpdaterDataBase updaterDataBase = CUpdaterDataBase.GetInstance(cnx, new CSagexproStructureBase());
//S'assure que la gestion des éléments est initialisé dans les licences
//CLicenceCheckElementNb.GetInstance();
result = updaterDataBase.UpdateStructureBase(indicateur);
if (!result)
{
return(result);
}
#endregion
//Restrictions sur applications
//Initialisation du serveur de documents GED
//Initialisation de la base d'utilisateurs AD
//CAdBase.Init(CfuturocomappServeurRegistre.RacineAd,"","");
//Initialise les fournisseurs de services
//CSessionClientSurServeur.RegisterFournisseur( new CFournisseurFiltresForSynchronisation() );
CGestionnaireEvenements.Init();
if (!result)
{
return(result);
}
//CGestionnaireObjetsAttachesASession.OnAttacheObjet += new LinkObjectEventHandler(CGestionnaireObjetsAttachesASession_OnAttacheObjet);
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//------------------------------------------------------------------------------------------------------------------------------
public static CResultAErreur RecalculeCoutsDescendants(IEnumerable <IElementACout> elements, bool bCoutReel, bool bRecursif, IIndicateurProgression indicateurDeProgression)
{
CConteneurIndicateurProgression indicateur = CConteneurIndicateurProgression.GetConteneur(indicateurDeProgression);
indicateur.CanCancel = true;
CResultAErreur result = CResultAErreur.True;
Dictionary <IElementACout, IElementACout[]> elementsToSources = new Dictionary <IElementACout, IElementACout[]>();
Dictionary <IElementACout, CImputationsCouts> dicImputations = new Dictionary <IElementACout, CImputationsCouts>();
foreach (IElementACout elt in elements)
{
FillDicSources(bCoutReel, elt, bRecursif, elementsToSources);
}
HashSet <IElementACout> setRecalcules = new HashSet <IElementACout>();
List <IElementACout> elementsACalculer = new List <IElementACout>();
if (bRecursif)
{
foreach (IElementACout elt in elementsToSources.Keys)
{
elementsACalculer.Add(elt);
}
}
else
{
elementsACalculer.AddRange(elements);
}
indicateur.SetBornesSegment(0, elementsACalculer.Count());
int nNbFaits = 0;
try
{
while (elementsACalculer.Count > 0)
{
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Operation cancelled|20184"));
return(result);
}
List <IElementACout> prochaineGeneration = new List <IElementACout>();
foreach (IElementACout elt in elementsACalculer)
{
//Vérifie qu'il est possible de calculer cet élément
IElementACout[] sources = elementsToSources[elt];
bool bCanCalcul = !elt.IsCoutFromSources(bCoutReel);
if (!bCanCalcul)
{
bCanCalcul = true;
foreach (IElementACout source in sources)
{
if (!setRecalcules.Contains(source) && elementsToSources.ContainsKey(source))
{
bCanCalcul = false;
break;
}
}
}
if (bCanCalcul)
{
nNbFaits++;
indicateur.SetValue(nNbFaits);
indicateur.SetInfo(elt.Libelle);
setRecalcules.Add(elt);
double fCout = 0;
if (elt.ShouldAjouterCoutPropreAuCoutDesSource(bCoutReel) && elt.IsCoutFromSources(bCoutReel))
{
AffecteValeurCalcSansSourcesToElement(elt, bCoutReel);
fCout = bCoutReel ? elt.CoutReel : elt.CoutPrevisionnel;
}
CValeursImputées valeursDeSources = GetValeursImputéesDeSources(elt);
valeursDeSources.Reset(bCoutReel);
if (elt.IsCoutFromSources(bCoutReel))
{
foreach (IElementACout source in sources)
{
CImputationsCouts imputations = null;
if (!dicImputations.TryGetValue(source, out imputations))
{
imputations = source.GetImputationsAFaireSurUtilisateursDeCout();
dicImputations[source] = imputations;
}
if (imputations != null)
{
double fImput = imputations.GetCoutImputéeA(elt, bCoutReel);
fCout += fImput;
SetValeurImputéeSurUtilisateur(source, elt, fImput, bCoutReel);
valeursDeSources.SetImputation(source, fImput, bCoutReel);
}
}
elt.SetCoutSansCalculDesParents(fCout, bCoutReel);
OnChangeCoutSansCalculCoutDescendant(elt, bCoutReel, false);
SetValeursImputéesDeSources(elt, valeursDeSources);
}
else
{
AffecteValeurCalcSansSourcesToElement(elt, bCoutReel);
}
}
else
{
prochaineGeneration.Add(elt);
}
}
if (prochaineGeneration.Count == elementsACalculer.Count)//On n'a rien fait, c'est la cata
{
result.EmpileErreur(I.T("Can not calculate cost. Cyclic redundancy error|20182"));
return(result);
}
elementsACalculer = prochaineGeneration;
if (!bRecursif)
{
break;
}
}
}
finally
{
}
return(result);
}