/// ////////////////////////////////////////////////////////////////////////// protected void EnvoieNotificationsThread(IDonneeNotification[] donnees, TypeGestionSessionEnvoyeur typeGestion) { foreach (CSessionClientSurServeur session in CGestionnaireSessions.ListeSessionsServeur) { try { EnvoieNotificationsToSessionCallBack sender = new EnvoieNotificationsToSessionCallBack(EnvoieNotificationToSessionThread); sender.BeginInvoke(session.SessionClient, donnees, null, null); } catch { C2iEventLog.WriteErreur(I.T("Sending notifiations to session @1 error|104", session.IdSession.ToString())); } } //Transfert de la notification aux serveurs annexes foreach (string strURI in m_tableServeursAnnexes.Keys) { if (strURI != "") { try { IGestionnaireNotification gestionnaireAnnexe = (IGestionnaireNotification)Activator.GetObject(typeof(IGestionnaireNotification), strURI + "/IGestionnaireNotification"); gestionnaireAnnexe.RelaieNotifications(donnees); } catch (Exception e) { C2iEventLog.WriteErreur(I.T("Secondary server error @1\r\n@2|103", strURI, e.ToString())); } } } }
public static void AutoexecInit() { lock (typeof(CGestionnaireDonneesQowisio)) { if (m_bAutoexecDone) { return; } m_bAutoexecDone = true; } m_bTraitementEnCours = true; CTimosServeur.OnMajStructureBaseEvent += new EventHandler(CTimosServeur_OnMajStructureBaseEvent); string strAppData = AppDataPath; if (!Directory.Exists(strAppData)) { Directory.CreateDirectory(strAppData); } C2iEventLog.WriteInfo(strAppData); // Récupère le nom du dernier fichier traité CDataBaseRegistrePourClient registreClient = new CDataBaseRegistrePourClient(0); CContexteDonneeServeur.AddTraitementAvantSauvegarde(new TraitementSauvegardeExterne(TraitementAvantSauvegardeExterne)); }
//----------------------------------------------------------------------------------------- /// <summary> /// /// </summary> /// <param name="strQowisioId"></param> /// <param name="contexte"></param> /// <returns></returns> public static CResultAErreur GetEquipementLogiqueFromQowisioId(string strQowisioId, CContexteDonnee contexte) { CResultAErreur result = CResultAErreur.True; CFiltreData filtre = new CFiltreDataAvance( CEquipementLogique.c_nomTable, CRelationEquipementLogique_ChampCustom.c_nomTable + "." + CChampCustom.c_nomTable + "." + CChampCustom.c_champId + " = @1 AND " + CRelationEquipementLogique_ChampCustom.c_nomTable + "." + CRelationEquipementLogique_ChampCustom.c_champValeurString + " = @2", c_nIdChampTimosQowisioId, strQowisioId); try { CEquipementLogique equipementLogiqueQowisio = new CEquipementLogique(contexte); if (equipementLogiqueQowisio.ReadIfExists(filtre)) { result.Data = equipementLogiqueQowisio; return(result); } } catch (Exception e) { C2iEventLog.WriteErreur("Error in GetEquipementLogiqueFromQowisioId : " + e.Message); result.EmpileErreur(e.Message); return(result); } return(result); }
//---------------------------------------------------- private CResultAErreur AssureSessionEtContexte() { CResultAErreur resErreur = CResultAErreur.True; System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Lowest; if (m_sessionClient == null || !m_sessionClient.IsConnected) { m_sessionClient = CSessionClient.CreateInstance(); resErreur = m_sessionClient.OpenSession(new CAuthentificationSessionServer(), I.T("Alarm management|20154"), ETypeApplicationCliente.Service); if (!resErreur) { resErreur.EmpileErreur(resErreur.Erreur); C2iEventLog.WriteErreur(I.T("Error while open alarm management session|20155")); resErreur.EmpileErreur(I.T("Error while open alarm management session|20155")); return(resErreur); } } if (m_contexteDonnee == null) { m_contexteDonnee = new CContexteDonnee(m_sessionClient.IdSession, true, true); CListeObjetsDonnees lst = new CListeObjetsDonnees(m_contexteDonnee, typeof(CTypeAlarme)); lst.AssureLectureFaite(); lst.ReadDependances("RelationsChampsCustomListe"); lst = new CListeObjetsDonnees(m_contexteDonnee, typeof(CSeveriteAlarme)); lst.AssureLectureFaite(); } return(resErreur); }
//------------------------------------------------------------------- public static void Autoexec() { if (C2iAppliServeur.GetValeur(c_cleDesactivation) == null) { m_timer = new Timer(new TimerCallback(OnTachePlanifiee), null, 4 * 60000, 60000); C2iEventLog.WriteInfo("Gestionnaire d'évenements sur date démarré"); } }
///////////////////////////////////////////////////////////////////////////////// public override CResultAErreur Delete(bool bDansContexteCourant) { CResultAErreur result = CResultAErreur.True; result.EmpileErreur(I.T("Cannot delete an application right|129")); C2iEventLog.WriteErreur(I.T("Attempt to delete a right from the database|130")); return(result); }
//------------------------------------------------------------------- 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); } }
protected override void OnStart(string[] args) { CTimosServeur.ArretServeur += new EventHandler(CTimosServeur_ArretServeur); CResultAErreur result = CTimosServeur.GetInstance().InitServeur(AppDomain.CurrentDomain.BaseDirectory + "\\timos.remoting.config", null); if (!result) { C2iEventLog.WriteErreur(result.Erreur.ToString()); throw new Exception("Erreur while starting the service " + result.Erreur.ToString()); } }
//-------------------------------------------------------------- private void DeleteListenersEnErreur() { lock (typeof(CLockerListeListeners)) { C2iEventLog.WriteErreur("Error on trace system. Cleaning up"); DeleteListenersEnErreur(m_listeListeners); foreach (KeyValuePair <string, List <IFuturocomTraceListener> > kv in m_dicCategorieToListener) { DeleteListenersEnErreur(kv.Value); } } }
//------------------------------------------------------------------------ private void LoopEtapes() { //C2iEventLog.WriteInfo("DEBUG_TODO - LoopEtapes() - m_bLoopEtapesEnCours = " + m_bLoopEtapesEnCours); if (m_bLoopEtapesEnCours) { return; } int nNbEtapes = 0; LoadEtapesDepuisBase(); lock (typeof(CLockerEtapes)) { m_bLoopEtapesEnCours = true; m_timerLooper.Stop(); //C2iEventLog.WriteInfo("DEBUG_TODO - LoopEtapes() - m_timerLooper.Stop()"); nNbEtapes = m_listeEtapes.Count; } try { while (nNbEtapes > 0) { AssureSession(); if (m_session != null) { StartNextEtape(); } lock (typeof(CLockerEtapes)) { nNbEtapes = m_listeEtapes.Count; } System.Threading.Thread.Sleep(500); } } catch (Exception e) { C2iEventLog.WriteErreur("DEBUG_TODO - LoopEtapes() - Step loop failed : " + e.Message); } lock (typeof(CLockerEtapes)) { m_bLoopEtapesEnCours = false; m_timerLooper.Interval = c_nDelaiTimerLooper; m_timerLooper.Start(); //C2iEventLog.WriteInfo("DEBUG_TODO - LoopEtapes() - m_timerLooper.Start()"); } }
//////////////////////////////////////////////////////////////////////// public CResultAErreur CommitTrans() { CResultAErreur result = CResultAErreur.True; foreach (IDatabaseConnexion connexion in m_connexions.Values) { result = connexion.CommitTrans(); if (!result) { C2iEventLog.WriteErreur(I.T("ERROR WHILE TRANSATION CLOSING :\r\nConnection: @1\r\nSession: @2\r\nConnection number for this session: @3|199", connexion.ConnexionString, IdSession.ToString(), m_connexions.Count.ToString())); return(result); } } m_nNbTransactionsOuvertes--; return(result); }
protected override void OnStart(string[] args) { try { C2iEventLog.Init("Timos", NiveauBavardage.VraiPiplette); RemotingConfiguration.Configure(AppDomain.CurrentDomain.BaseDirectory + "\\serviceMediation.remoting.config", false); RemotingConfiguration.CustomErrorsMode = CustomErrorsModes.On; CAutoexecuteurClasses.RunAllAutoexecs(); CSnmpProxyConfiguration.GetInstance().MiseAJour(true); CServiceMediation.GetDefaultInstance().Configuration.MettreAJour(true, true); } catch (Exception e) { C2iEventLog.WriteErreur(e.Message); throw e; } }
/////////////////////////////////////////////// public void CloseSession() { string strMessage = I.T("Closing session @1|110", IdSession.ToString()); try { strMessage += " " + GetInfoUtilisateur().NomUtilisateur; } catch { } CAuthentificationSessionSousSession authSousSession = m_authentification as CAuthentificationSessionSousSession; if (authSousSession != null) { ISessionClientSurServeur sessionPrinc = CGestionnaireSessions.GetSessionClientSurServeurStatic(authSousSession.IdSessionPrincipale); if (sessionPrinc != null) { sessionPrinc.RemoveSousSession(this); } } C2iEventLog.WriteInfo(strMessage, NiveauBavardage.VraiPiplette); int nIdSession = IdSession; DateTime dt = DateTime.Now; MyCloseSession(); TimeSpan sp = DateTime.Now - dt; Console.WriteLine("SessionServeur closing " + nIdSession + " / 1 : " + sp.TotalMilliseconds); CGestionnaireObjetsAttachesASession.OnCloseSession(IdSession); sp = DateTime.Now - dt; Console.WriteLine("SessionServeur closing " + nIdSession + " / 2 : " + sp.TotalMilliseconds); CGestionnaireSessions.CloseSession(this); sp = DateTime.Now - dt; Console.WriteLine("SessionServeur closing " + nIdSession + " / 3 : " + sp.TotalMilliseconds); CGestionnaireObjetsAttachesASession.OnCloseSession(IdSession); //Si jamais le close sessino a réaloué des éléments sp = DateTime.Now - dt; Console.WriteLine("SessionServeur closing " + nIdSession + " / 4 : " + sp.TotalMilliseconds); m_sponsor.Unregister(m_sessionSurClient); sp = DateTime.Now - dt; Console.WriteLine("SessionServeur closing " + nIdSession + " / 5 : " + sp.TotalMilliseconds); m_sessionSurClient = null; }
/// /////////////////////////////////////////////////// public CResultAErreur ReconnecteSession(CSessionClient sessionSurClient) { CResultAErreur result = CResultAErreur.True; ISessionClientSurServeur sessionSurServeur = GetSessionClientSurServeur(sessionSurClient.IdSession); if (sessionSurServeur != null) { sessionSurClient.SessionSurServeur = sessionSurServeur; return(result); } result = CanOpenSession(sessionSurClient); if (result) { sessionSurServeur = GetNewSessionSurServeur(sessionSurClient, result.Data); result.Data = null; if (sessionSurServeur == null) { result.EmpileErreur(I.T("Server session allocation impossible|105")); } else { sessionSurClient.SessionSurServeur = sessionSurServeur; lock (typeof(CLockerListeSessions)) { m_listeSessions[sessionSurClient.IdSession] = sessionSurServeur; } string strMessage = I.T("Session Reconnection n°|111") + sessionSurClient.IdSession + "\r\n" + I.T("Type|107") + sessionSurClient.TypeApplicationCliente.ToString(); strMessage += I.T("\r\n|108") + sessionSurServeur.DescriptionApplicationCliente; try { strMessage += I.T("\r\n|108") + sessionSurClient.GetInfoUtilisateur().NomUtilisateur; } catch { } C2iEventLog.WriteInfo(strMessage, NiveauBavardage.VraiPiplette); CDonneeNotificationConnection donnee = new CDonneeNotificationConnection(sessionSurClient.IdSession, true); CEnvoyeurNotification.EnvoieNotifications(new IDonneeNotification[] { donnee }); } } return(result); }
// Notify a handler that an object has been disconnected. public void DisconnectedObject(Object obj) { if (obj is CSessionClientSurServeur) { bool bConnected = false; CSessionClientSurServeur session = (CSessionClientSurServeur)obj; try { CSessionClientSurServeur sc = CGestionnaireSessions.GetSessionClientSurServeurStatic(session.IdSession) as CSessionClientSurServeur; if (CGestionnaireSessions.IsSessionOpenStatic(session.IdSession)) { // try { //Tente de contacter la session cliente bConnected = sc == null || sc.SessionClient.IsConnected; } catch { } if (!bConnected) { string strMessage = I.T("Auto disconnection session number @1|109", session.IdSession.ToString()) + I.T("\r\n|108") + I.T("Type|107") + session.TypeApplicationCliente.ToString(); strMessage += I.T("\r\n|108") + session.DescriptionApplicationCliente; try { strMessage += I.T("\r\n|108") + session.GetInfoUtilisateur().NomUtilisateur; } catch { } C2iEventLog.WriteErreur(strMessage); } } } catch {} if (!bConnected) { session.CloseSession(); } } }
/// ////////////////////////////////////////////////////////////////////////// protected void EnvoieNotificationToSessionThread(CSessionClient session, IDonneeNotification[] donnees) { try { session.OnNotification(donnees); } catch (Exception e) { try { m_nNbErreursNotif++; if (m_nNbErreursNotif > 20) { C2iEventLog.WriteErreur("Error sending notification \r\n" + e.ToString()); m_nNbErreursNotif = 0; } } catch { } } }
//----------------------------------------------------------------------------------------- public static DateTime ParseDateFromString(string strDate) { try { int nAnnee = Int32.Parse(strDate.Substring(0, 4)); int nMois = Int32.Parse(strDate.Substring(4, 2)); int nJour = Int32.Parse(strDate.Substring(6, 2)); int nHeure = Int32.Parse(strDate.Substring(8, 2)); int nMinute = Int32.Parse(strDate.Substring(10, 2)); int nSeconde = Int32.Parse(strDate.Substring(12, 2)); DateTime date = new DateTime(nAnnee, nMois, nJour, nHeure, nMinute, nSeconde, DateTimeKind.Utc); return(date); } catch (Exception e) { C2iEventLog.WriteErreur("Error in ParseDateFromString : " + e.Message); } return(DateTime.MinValue); }
//------------------------------------------------------------------- /// <summary> /// Fait un traitement global avant sauvegarde pour s'assurer que tous les éléments /// qui imposent une mise à jour de l'agent SNMP ont bien préparé la liste des agents /// à mettre à jour. /// </summary> /// <param name="contexte"></param> /// <param name="tableData"></param> /// <param name="result"></param> public static CResultAErreur CContexteDonneeServeur_DoTraitementExterneAvantSauvegarde(CContexteDonnee contexte, Hashtable tableData) { CResultAErreur result = CResultAErreur.True; HashSet <DataRow> rows = GetTableAgentsAMettreAJourToSnmp(contexte, false); if (rows != null) { foreach (DataRow row in rows) { CAgentSnmp agent = new CAgentSnmp(row); try { if (agent.AutoUpdate) { result = agent.UpdateToSnmpInCurrentContext(true); } } catch (Exception e) { result.EmpileErreur(new CErreurException(e)); } if (!result) { string strTexte = I.T("Error while update SNMP agent @1|20157", agent.SnmpIp); strTexte += "\r\n"; strTexte += result.Erreur.ToString(); C2iEventLog.WriteErreur(strTexte); } result = CResultAErreur.True; } } DataTable table = contexte.Tables[CAgentSnmp.c_nomTable]; if (table != null) { table.ExtendedProperties.Remove(c_cleDataAgentsAMettreAjour); } return(result); }
//---------------------------------------------------- private CResultAErreur AssureSessionPolling() { CResultAErreur resErreur = CResultAErreur.True; System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Lowest; if (m_sessionPolling == null || !m_sessionPolling.IsConnected) { m_sessionPolling = CSessionClient.CreateInstance(); resErreur = m_sessionPolling.OpenSession(new CAuthentificationSessionServer(), "Snmp polling manager", ETypeApplicationCliente.Service); if (!resErreur) { resErreur.EmpileErreur(resErreur.Erreur); C2iEventLog.WriteErreur("Error while open snmp polling management"); resErreur.EmpileErreur("Error while open snmp polling management"); return(resErreur); } } return(resErreur); }
public int Compare(object x, object y) { try { object val1, val2; if (((DataRow)x).RowState == DataRowState.Deleted || ((DataRow)y).RowState == DataRowState.Deleted) { return(0); } val1 = ((DataRow)x)[m_strColonne]; val2 = ((DataRow)y)[m_strColonne]; if (val1 is IComparable && val2 is IComparable) { return(((IComparable)val1).CompareTo((IComparable)val2)); } if (val1.Equals(val2)) { return(0); } return(-1); } catch (Exception ex) { object val1, val2; val1 = ((DataRow)x)[m_strColonne]; val2 = ((DataRow)y)[m_strColonne]; string strInfosDebug = "DEBUG_OOREDOO" + Environment.NewLine; strInfosDebug += "Error in Compare function" + Environment.NewLine; strInfosDebug += "Val1 = " + val1.ToString() + Environment.NewLine; strInfosDebug += "Val2 = " + val2.ToString() + Environment.NewLine; C2iEventLog.WriteInfo(strInfosDebug); } return(0); }
//------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// <param name="strXmlFile"></param> /// <param name="contexte"></param> private static CResultAErreur TraiteFichierQowisio(string strXmlFile, CContexteDonnee contexte, EModeTraitment modeTraitement) { CResultAErreur result = CResultAErreur.True; try { XmlDocument fichierXmlQowisio = new XmlDocument(); fichierXmlQowisio.Load(strXmlFile); XmlNode nodeExport = fichierXmlQowisio.SelectSingleNode("export"); if (nodeExport == null) { result.EmpileErreur("<export> node not found in file : " + strXmlFile); return(result); } if ((modeTraitement & EModeTraitment.MEDIUM) == EModeTraitment.MEDIUM) { XmlNode nodeInventory = nodeExport.SelectSingleNode("inventory"); if (nodeInventory != null) { result += TraiteInventaireQowisio(nodeInventory, contexte); if (!result) { C2iEventLog.WriteErreur("CCamusatQowisioDataServeur error in TraiteInventaireQowisio : " + result.MessageErreur); return(result); } } } if ((modeTraitement & EModeTraitment.SHORT) == EModeTraitment.SHORT) { XmlNode nodeData = nodeExport.SelectSingleNode("data"); if (nodeData != null) { result = TraiteDataQowisio(nodeData, contexte); if (!result) { C2iEventLog.WriteErreur("CCamusatQowisioDataServeur error in TraiteDataQowisio : " + result.MessageErreur); } } XmlNode nodeAlarms = nodeExport.SelectSingleNode("alarms"); if (nodeAlarms != null) { result = TraiteAlarmesQowisio(nodeAlarms, contexte); if (!result) { C2iEventLog.WriteErreur("CCamusatQowisioDataServeur error in TraiteAlarmesQowisio : " + result.MessageErreur); } } } result = contexte.SaveAll(true); if (!result) { C2iEventLog.WriteErreur(result.MessageErreur); } } catch (Exception e) { string strErreur = "CCamusatQowisioDataServeur error in TraiteFichierQowisio : " + e.Message; C2iEventLog.WriteErreur(strErreur); result.EmpileErreur(strErreur); Console.WriteLine(strErreur); return(result); } finally { } return(result); }
//---------------------------------------------------------------------------------- /// <summary> /// /// </summary> /// <param name="target"></param> public static void OnTimerTraitement(object target) { CResultAErreur result = CResultAErreur.True; TimeSpan ts = DateTime.Now - m_lastDateDebutTraitementShort; if (m_bTraitementEnCours) { if (ts.TotalMinutes < 5) { return; } else { C2iEventLog.WriteErreur("CCamusatQowisioDataServeur : data processing >= 5 minutes"); return; } } m_bTraitementEnCours = true; m_lastDateDebutTraitementShort = DateTime.Now; // Determine le mode du traitement SHORT/MEDIUM/FULL EModeTraitment modeTraitement = EModeTraitment.SHORT; ts = DateTime.Now - m_lastDateDebutTraitementMedium; if (ts.TotalMilliseconds >= c_nDelaiTraitementMedium) { modeTraitement = modeTraitement | EModeTraitment.MEDIUM; m_lastDateDebutTraitementMedium = DateTime.Now; } ts = DateTime.Now - m_lastDateDebutTraitementMedium; if (ts.TotalMilliseconds >= c_nDelaiTraitementFull) { modeTraitement = modeTraitement | EModeTraitment.FULL; m_lastDateDebutTraitementFull = DateTime.Now; } try { System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Lowest; try { m_sessionClient = CSessionClient.CreateInstance(); result = m_sessionClient.OpenSession(new CAuthentificationSessionServer(), "Qowisio XML data processing", ETypeApplicationCliente.Service); if (!result) { C2iEventLog.WriteErreur("Working session openning error for CCamusatQowisioDataServeur"); return; } try { //Récupère les fichiers FTP string strFTPserver = CCamusatQowisioServeurRegistre.FTPServer; string strFTPuser = CCamusatQowisioServeurRegistre.FTPUser; string strFTPpassword = CCamusatQowisioServeurRegistre.FTPPassword; int nFTPport = CCamusatQowisioServeurRegistre.FTPPort; string strIncomingDirectory = CCamusatQowisioServeurRegistre.FTPIncomingDirectory; List <string> listeFichiersATraiter = new List <string>(); ArrayList listFiles = null; string strLastFile = new CDataBaseRegistrePourClient(m_sessionClient.IdSession).GetValeurString(c_strCleDernierFichierTraité, ""); Sftp ftp = new Sftp(strFTPserver, strFTPuser, strFTPpassword); try { ftp.Connect(); /* Open the FTP connection */ listFiles = ftp.GetFileList(strIncomingDirectory); listFiles.Sort(); listFiles.Reverse(); /* * // constitue la liste des fichiers à traiter * listFiles.AddRange(ftp.GetFiles()); * listFiles.Sort(new CFtpFileInfoComparer()); * listFiles.Reverse();*/ foreach (string strFtpFile in listFiles) { if (strFtpFile.CompareTo(strLastFile) <= 0) { break; } string strWorkFile = WorkDir + "\\" + strFtpFile; if (strFtpFile.ToUpper().EndsWith("XML")) { if (!File.Exists(strWorkFile)) { ftp.Get(strIncomingDirectory + "/" + strFtpFile, strWorkFile); //ftp.GetFile(fileInfo.Name, strWorkFile, false); /* download /incoming/file.txt as file.txt to current executing directory, overwrite if it exists */ //ftp.RemoveFile(fileInfo.Name); } listeFichiersATraiter.Insert(0, strFtpFile); } } if (listeFichiersATraiter.Count > 0) { new CDataBaseRegistrePourClient(m_sessionClient.IdSession).SetValeur(c_strCleDernierFichierTraité, listeFichiersATraiter[listeFichiersATraiter.Count - 1]); } ftp.Close(); } catch (Exception ex) { C2iEventLog.WriteErreur("CCamusatQowisioDataServeur error openning FTP connection: " + ex.Message); } finally { ftp.Close(); } // Traite la liste des fichiers à traiter using (CContexteDonnee contexte = new CContexteDonnee(m_sessionClient.IdSession, true, false)) { List <string> lstFichiersWork = new List <string>(Directory.GetFiles(WorkDir, "*.xml")); lstFichiersWork.Sort(); //CCamusatQowisioDataServeur serveur = new CCamusatQowisioDataServeur(m_sessionClient.IdSession); foreach (string strWorkFile in lstFichiersWork) { try { string strNomFichier = Path.GetFileName(strWorkFile); // Traitement d'un fichier XML result = TraiteFichierQowisio(strWorkFile, contexte, modeTraitement); string strArchive = DoneDir + "\\" + strNomFichier; if (result) { MoveSafely(strWorkFile, ref strArchive); } else { strArchive = ErrorDir + "\\" + strNomFichier; MoveSafely(strWorkFile, ref strArchive); FileStream stream = new FileStream(strArchive + ".Err", FileMode.CreateNew, FileAccess.Write); StreamWriter writer = new StreamWriter(stream); writer.Write(result.MessageErreur); writer.Close(); stream.Close(); } } catch (Exception e) { C2iEventLog.WriteErreur("CCamusatQowisioDataServeur error while processing file : " + strWorkFile + " - " + e.Message); } } } } catch (Exception ex) { C2iEventLog.WriteErreur("CCamusatQowisioDataServeur error processing files : " + ex.Message); } finally { try { m_sessionClient.CloseSession(); } catch { } } } catch (Exception e) { C2iEventLog.WriteErreur("CCamusatQowisioDataServeur error in OnTimerTraitement : " + e.Message); } } catch (Exception ex) { C2iEventLog.WriteErreur("CCamusatQowisioDataServeur error in OnTimerTraitement : " + ex.Message); } finally { m_bTraitementEnCours = false; } }
/// /////////////////////////////////////////////////// public static void NettoieSessions(object state) { try { StringBuilder blInfo = new StringBuilder(); blInfo.Append("Sessions cleaning : " + DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss") + "\r\n"); foreach (DictionaryEntry entry in new ArrayList(m_listeSessions)) { try { int nIdSession = (int)entry.Key; blInfo.Append("Session "); blInfo.Append(nIdSession); CSessionClientSurServeur sessionServeur = (CSessionClientSurServeur)entry.Value; CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession); bool bIsConnected = false; try { bIsConnected = session.IsConnected; if (bIsConnected) { sessionServeur.DateHeureLastTestSessionClientSuccess = DateTime.Now; } } catch { blInfo.Append("/Disconnected from client/"); } if (session == null || !bIsConnected) { TimeSpan sp = DateTime.Now - sessionServeur.DateHeureLastTestSessionClientSuccess; if (sp.TotalMinutes > LifetimeServices.SponsorshipTimeout.Minutes) { blInfo.Append("/Closing/"); C2iEventLog.WriteInfo("Loose " + nIdSession + " Automatic disconnect", NiveauBavardage.PetiteCausette); try { sessionServeur.CloseSession(); } catch { CloseSession(sessionServeur); } blInfo.Append("/Closed/"); } } else { blInfo.Append("/active/"); } blInfo.Append(Environment.NewLine); } catch { blInfo.Append("ERROR \r\n"); } } C2iEventLog.WriteInfo(blInfo.ToString(), NiveauBavardage.VraiPiplette); } catch {} }
public static void OnTimerGestionAuto(object state) { if (m_bGestionAutoEnCours) { return; } try { m_bGestionAutoEnCours = true; CSessionClient session = CSessionClient.CreateInstance(); CResultAErreur result = session.OpenSession(new CAuthentificationSessionServer(), I.T("Automatic management of the diary states|314"), ETypeApplicationCliente.Service); if (!result) { result.EmpileErreur(I.T("Error in the automatic management of expiration dates: Impossible to open a session|315")); C2iEventLog.WriteErreur(result.Erreur.ToString()); return; } try { using (CContexteDonnee contexte = new CContexteDonnee(session.IdSession, true, false)) { DateTime dt = DateTime.Now; CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, typeof(CEntreeAgenda)); liste.Filtre = new CFiltreData( CEntreeAgenda.c_champEtatAutomatique + "=@1 and " + CEntreeAgenda.c_champEtat + "<>@2 and " + CEntreeAgenda.c_champEtat + "<>@3 and (" + "(" + CEntreeAgenda.c_champDateDebut + "< @4 and " + CEntreeAgenda.c_champDateFin + ">@4 and " + CEntreeAgenda.c_champEtat + "<>@5) or (" + CEntreeAgenda.c_champDateFin + "<@4 and " + CEntreeAgenda.c_champEtat + "<@6) )", true, (int)EtatEntreeAgenda.Info, (int)EtatEntreeAgenda.Annulee, //dt.ToString("dd/MM/yyyy HH:mm:00"), dt, (int)EtatEntreeAgenda.EnCours, (int)EtatEntreeAgenda.Terminee); foreach (CEntreeAgenda entree in liste) { entree.EtatAuto = false; if (entree.DateDebut < dt && entree.DateFin > dt) { entree.CodeEtatInt = (int)EtatEntreeAgenda.EnCours; } if (entree.DateFin < dt) { entree.CodeEtatInt = (int)EtatEntreeAgenda.Terminee; } entree.EtatAuto = true; } result = contexte.SaveAll(true); if (!result) { result.EmpileErreur(I.T("AError in the automatic management of expiration dates:Error during backup operation|316")); C2iEventLog.WriteErreur(result.Erreur.ToString()); return; } } } finally { session.CloseSession(); } } finally { m_bGestionAutoEnCours = false; } }
//------------------------------------------------------------------- public static CResultAErreur TraitementAvantSauvegarde(CContexteDonnee contexte, string strNomTable) { lock (typeof(CObjetHierarchiqueServeur))//Empeche que plusieurs thread entrent en même temps { CResultAErreur result = CResultAErreur.True; if (!result) { return(result); } DataTable table = contexte.Tables[strNomTable]; ArrayList lstRows = new ArrayList(table.Rows); IObjetHierarchiqueACodeHierarchique objet = (IObjetHierarchiqueACodeHierarchique)Activator.CreateInstance(CContexteDonnee.GetTypeForTable(strNomTable), new object[] { contexte }); string strInfosDebug = ""; /*/*** START DEBUG : ajout d'une trace pour analyser le bug chez OOREDOO * strInfosDebug = "DEBUG_TIMOS" + Environment.NewLine; * strInfosDebug += "Nom de la table : " + strNomTable + Environment.NewLine; * strInfosDebug += "Contenu des rows : " + Environment.NewLine; * foreach (DataColumn col in table.Columns) * { * strInfosDebug += col.ColumnName + ";"; * } * strInfosDebug += Environment.NewLine; * * foreach (DataRow row in lstRows) * { * foreach (var item in row.ItemArray) * { * strInfosDebug += item.ToString() + ";"; * } * strInfosDebug += Environment.NewLine; * } * C2iEventLog.WriteInfo(strInfosDebug); * /*** END DEBUG ***/ try { //C2iEventLog.WriteInfo("DEBUG_TIMOS - TraitementAvantSauvegarde() objet hiérarchique - before Sort"); lstRows.Sort(new CRowSorterSurParent(objet.ChampIdParent)); //C2iEventLog.WriteInfo("DEBUG_TIMOS - TraitementAvantSauvegarde() objet hiérarchique - after Sort"); } catch (Exception ex) { //*** START DEBUG 02/11/2020 : ajout d'une trace pour analyser le bug chez OOREDOO // Cause problème de tri sur table objets hiérarchiques sur champ idParent strInfosDebug = "DEBUG_TIMOS" + Environment.NewLine; strInfosDebug += "ERROR MESSAGE : " + ex.Message + Environment.NewLine; C2iEventLog.WriteErreur(strInfosDebug); /*** END DEBUG ***/ } object lastParent = DBNull.Value; int nLastCode = 0; foreach (DataRow row in lstRows) { //Allocation du code famille objet = (IObjetHierarchiqueACodeHierarchique)Activator.CreateInstance(CContexteDonnee.GetTypeForTable(strNomTable), new object[] { row }); if (objet.Row.RowState != DataRowState.Deleted && (objet.CodeSystemePartiel == objet.CodePartielDefaut || HasChange(objet, objet.ChampIdParent))) { if (!objet.Row[objet.ChampIdParent].Equals(lastParent)) { nLastCode = 0; lastParent = objet.Row[objet.ChampIdParent]; } AlloueCode(objet, ref nLastCode); } } return(result); } }
private static void OnTachePlanifiee(object state) { //14/12/2010 : si un traitement est en cours depuis plus de 24H, lance d'autres traitements TimeSpan sp = DateTime.Now - m_lastDateDebutTraitement; if (m_bTraitementEnCours && sp.TotalHours < 24) { return; } m_bTraitementEnCours = true; m_lastDateDebutTraitement = DateTime.Now; try { System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.Lowest; CResultAErreur result; if (m_sessionRecherche == null || !m_sessionRecherche.IsConnected) { m_sessionRecherche = CSessionClient.CreateInstance(); result = m_sessionRecherche.OpenSession(new CAuthentificationSessionServer(), I.T("Search of planned tasks|332"), ETypeApplicationCliente.Service); if (!result) { C2iEventLog.WriteErreur(I.T("Session Opening error for planned tasks|333")); return; } } try { CFiltreData filtre = new CFiltreData(CTachePlanifiee.c_champProchaineExecution + " < @1 and " + CTachePlanifiee.c_champBloquer + "=@2", DateTime.Now, false ); if (new CTachePlanifieeServeur(m_sessionRecherche.IdSession).CountRecords( CTachePlanifiee.c_nomTable, filtre) > 0) { CSessionClient sessionTravail = new CSessionProcessServeurSuivi(); result = sessionTravail.OpenSession(new CAuthentificationSessionProcess(), I.T("Planned Tasks execution|334"), ETypeApplicationCliente.Service); if (!result) { C2iEventLog.WriteErreur(I.T("Working session openning error for Planned Tasks|335")); return; } try { using (CContexteDonnee contexteTravail = new CContexteDonnee(sessionTravail.IdSession, true, false)) { CTachePlanifieeServeur serveur = new CTachePlanifieeServeur(sessionTravail.IdSession); CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteTravail, typeof(CTachePlanifiee)); liste.Filtre = filtre; foreach (CTachePlanifiee tache in liste) { CInfoDeclencheurProcess infoDeclencheur = new CInfoDeclencheurProcess(TypeEvenement.Date); try { serveur.ExecuteTache(tache.Id, null); } catch (Exception e) { string strLibelle = I.T("Error planned task @1|336", tache.Libelle) + Environment.NewLine; strLibelle += e.ToString(); C2iEventLog.WriteErreur(strLibelle); } tache.BeginEdit(); CDateTimeEx dt = tache.ParametrePlanification.GetNextOccurence(tache.DateProchaineExecution, false); while (dt != null && (DateTime)dt < DateTime.Now) { dt = tache.ParametrePlanification.GetNextOccurence(dt, false); } tache.DateProchaineExecution = dt; tache.CommitEdit(); //Ouvre une session pour chaque tâche. Comme ça s'il y a une erreur sur une tâche, //les autres ne peuvent pas être impactées sessionTravail.CloseSession(); result = sessionTravail.OpenSession(new CAuthentificationSessionProcess(), I.T("Planned Tasks execution|334"), ETypeApplicationCliente.Service); if (!result) { throw new CExceptionErreur(result.Erreur); } } } } catch (Exception e) { C2iEventLog.WriteErreur(I.T("Error in planned tasks : @1|337", e.ToString())); } finally { try { sessionTravail.CloseSession(); } catch { } } } } catch (Exception e) { C2iEventLog.WriteErreur(I.T("Error in planned tasks : @1|337", e.ToString())); } } catch (Exception e) { { C2iEventLog.WriteErreur(I.T("Error in planned tasks : @1|337", e.ToString())); } } finally { m_bTraitementEnCours = false; } }
//------------------------------------------------------------------- public static void Autoexec() { m_timer = new Timer(new TimerCallback(OnTachePlanifiee), null, c_nDelaiTachePlanifiee, c_nDelaiTachePlanifiee); C2iEventLog.WriteInfo(I.T("Planned Task Manager started|331")); }
private static void OnTachePlanifiee(object state) { if (m_bTraitementEnCours || m_bIsSuspended) { return; } m_bTraitementEnCours = true; try { //La session dévolue aux tâches planifiées est fermée régulierement pour //Eviter des problèmes de déconnexion (qui ne sont jamais arrivés, mais //on ne sait jamais ). if (m_sessionClient == null || !m_sessionClient.IsConnected || m_sessionClient.DateHeureConnexion.AddDays(1) < DateTime.Now) { if (m_sessionClient != null) { try { m_sessionClient.CloseSession(); } catch { } } //Ouvre une session pour executer l'action m_sessionClient = CSessionClient.CreateInstance(); CResultAErreur result = m_sessionClient.OpenSession(new CAuthentificationSessionServer(), "Evenements sur date", ETypeApplicationCliente.Service); if (!result) { C2iEventLog.WriteErreur("Erreur ouverture de session pour Evenements sur date"); return; } } try { using (CContexteDonnee contexte = new CContexteDonnee(m_sessionClient.IdSession, true, false)) { CListeObjetsDonnees liste = new CListeObjetsDonnees(contexte, typeof(CHandlerEvenement)); liste.Filtre = new CFiltreData(CHandlerEvenement.c_champDateHeureDeclenchement + " < @1 and " + CHandlerEvenement.c_champEtatExecution + "=@2", DateTime.Now, (int)EtatHandlerAction.AExecuter ); foreach (CHandlerEvenement handler in liste) { CResultAErreur result = CResultAErreur.True; C2iExpression formuleCondition = handler.FormuleCondition; bool bShouldDeclenche = false; CContexteEvaluationExpression ctxEval; ctxEval = new CContexteEvaluationExpression(handler.ElementSurveille); if (formuleCondition != null) { result = formuleCondition.Eval(ctxEval); if (!result) { bShouldDeclenche = false; C2iEventLog.WriteErreur("Erreur déclenchement handler " + handler.Id + " : erreur lors de l'évaluation de la condition"); } else { if (result.Data is bool) { bShouldDeclenche = (bool)result.Data; } else { bShouldDeclenche = result.Data != null && result.Data.ToString() != "" && result.Data.ToString() != "0"; } } } if (bShouldDeclenche) { if (handler.EvenementLie != null) { CInfoDeclencheurProcess infoDeclencheur = new CInfoDeclencheurProcess(); infoDeclencheur.TypeDeclencheur = TypeEvenement.Date; infoDeclencheur.Info = handler.EvenementLie.Libelle; result = handler.EvenementLie.RunEvent(handler.ElementSurveille, infoDeclencheur, null); } else if (handler.ProcessSource != null) { result = handler.RunEvent( false, handler.ElementSurveille, new CInfoDeclencheurProcess(TypeEvenement.Date), null); } else if (handler.EtapeWorkflowATerminer != null) { result = handler.RunEvent( false, handler.ElementSurveille, new CInfoDeclencheurProcess(TypeEvenement.Date), null); } } handler.EndHandler(result); } } } catch (Exception e) { C2iEventLog.WriteErreur("Erreur Taches planifiées " + e.ToString()); } finally { } } finally { m_bTraitementEnCours = false; } }
//------------------------------------------------------------------------ private void ExecuteEtape(CParametresStartEtapeInPile parametreStart) { //C2iEventLog.WriteInfo("DEBUG_TODO - ExecuteEtape()"); List <CDonneeNotificationWorkflow> lstNotifications = new List <CDonneeNotificationWorkflow>(); //TESTDBKEYTODO if (parametreStart.KeyUtilisateur != null) { m_session.ChangeUtilisateur(parametreStart.KeyUtilisateur); } try { using (CContexteDonnee ctx = new CContexteDonnee(m_session.IdSession, true, false)) { CResultAErreur result = CResultAErreur.True; CEtapeWorkflow etape = new CEtapeWorkflow(ctx); //C2iEventLog.WriteInfo("DEBUG_TODO - ExecuteEtape() - etape.ReadIfExists(" + parametreStart.IdEtape + ")"); if (etape.ReadIfExists(parametreStart.IdEtape)) { //C2iEventLog.WriteInfo("DEBUG_TODO - ExecuteEtape() OK étape existe Id = " + parametreStart.IdEtape); result = etape.InternalSetInfosDemarrageInCurrentContext(); //C2iEventLog.WriteInfo("DEBUG_TODO - etape.InternalSetInfosDemarrageInCurrentContext() Id = " + parametreStart.IdEtape); etape.EtatCode = (int)EEtatEtapeWorkflow.Démarrée; result = ctx.SaveAll(true); //C2iEventLog.WriteInfo("DEBUG_TODO - ctx.SaveAll(true) Id = " + parametreStart.IdEtape + " - result = " + result.Result); if (result) { //C2iEventLog.WriteInfo("DEBUG_TODO - before InternalRunAndSaveifOk() Id = " + parametreStart.IdEtape); result = etape.InternalRunAndSaveifOk(); //C2iEventLog.WriteInfo("DEBUG_TODO - after InternalRunAndSaveifOk() Id = " + parametreStart.IdEtape); } else { C2iEventLog.WriteInfo("DEBUG_TODO - InternalRunAndSaveifOk() - Erreur : " + result.MessageErreur); } if (result && etape.CodeAffectations.Length > 0 && etape.DateFin == null) { CDonneeNotificationWorkflow donneeWorkflow = new CDonneeNotificationWorkflow( m_session.IdSession, etape.Id, etape.Libelle, etape.CodeAffectations, etape.TypeEtape.ExecutionAutomatique); lstNotifications.Add(donneeWorkflow); // Déclenche l'evenement spécifique au démarrage de l'étape result = etape.EnregistreEvenement(CEtapeWorkflow.c_codeEvenementOnRunStep, true); //C2iEventLog.WriteInfo("DEBUG_TODO - ExecuteEtape() - etape.EnregistreEvenement()"); } if (!result) { NoteErreurSurEtape(etape, result.MessageErreur); return; } //C2iEventLog.WriteInfo("DEBUG_TODO - ExecuteEtape() - Fin traitement étape Id = " + parametreStart.IdEtape); } } } catch (Exception e) { C2iEventLog.WriteErreur("DEBUG_TODO - ExecuteEtape() - Exception executing step Id = " + parametreStart.IdEtape + Environment.NewLine + e.Message); } if (lstNotifications != null) { CEnvoyeurNotification.EnvoieNotifications(lstNotifications.ToArray()); } }
protected virtual CResultAErreur UpdateTable(CStructureTable structure, ArrayList strChampsAutorisesANull) { CResultAErreur result = CResultAErreur.True; ArrayList champsCrees = new ArrayList(); DataTable dt = GetDataTableForUpdateTable(structure); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #region M.A.J des champs de la table string strNomTable = structure.NomTableInDb; foreach (CInfoChampTable champ in structure.Champs) { bool bExists = false; bool bModifiedType = false; bool bModifiedNotNull = false; bool bModifiedLength = false; bool bModifiedIndex = false; if (strChampsAutorisesANull.Contains(champ.NomChamp)) { champ.NullAuthorized = true; } // 1 - Verification d'existance de la colonne et des modifs à faire si elle existe foreach (DataColumn colonne in dt.Columns) { if (champ.NomChamp == colonne.ColumnName) { bModifiedType = Champ_ModifiedType(champ, colonne); bModifiedLength = Champ_ModifiedLength(champ, colonne); bModifiedNotNull = Champ_ModifiedNotNull(champ, colonne, strChampsAutorisesANull); bModifiedIndex = Champ_ModifiedIndex(strNomTable, champ); bExists = true; break; } } // 2 - Creation d'une colonne inexistante if (!bExists) { result = CreateChamp(structure.NomTableInDb, champ); if (result) { champsCrees.Add(champ.NomChamp); } } // 3 - Modification d'une colonne else if (bModifiedType || bModifiedNotNull || bModifiedLength) { result = UpdateChamp(strNomTable, champ, bModifiedNotNull, bModifiedLength, bModifiedType); } if (!result) { return(result); } if (bModifiedIndex) { if (champ.IsIndex) { result = CreateIndex(strNomTable, false, champ.NomChamp); } else { result = DeleteIndex(strNomTable, champ.NomChamp); } if (!result) { return(result); } } } // Suppression d'une colonne de la table foreach (DataColumn colonne in dt.Columns) { bool bExists = false; foreach (CInfoChampTable info in structure.Champs) { if (info.NomChamp == colonne.ColumnName) { bExists = true; break; } } if (!bExists) { //SC le 17082009 : Plus de suppression automatique de colonne //Par UpdateTable. Pour supprimer une colonne, il faut utiliser une opération //de suppression de colonne C2iEventLog.WriteInfo("Field " + colonne.ColumnName + " in table " + structure.NomTableInDb + " should be deleted"); //result = DeleteChamp(structure.NomTableInDb, colonne.ColumnName); if (!result) { return(result); } } } #endregion //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #region M.A.J des contraintes de la table List <CInfoRelation> relationsActuelles = new List <CInfoRelation>(); result = GetRelationsExistantes(strNomTable, ref relationsActuelles); if (!result) { return(result); } List <CInfoRelation> relationsVoulues = new List <CInfoRelation>(); foreach (CInfoRelation r in structure.RelationsParentes) { if (r.IsInDb) { relationsVoulues.Add(r); } } List <CInfoRelation> nouvellesRelations = GetRelationsInnexistantes(relationsActuelles, relationsVoulues); List <CInfoRelation> relationsObseletes = GetRelationsInnexistantes(relationsVoulues, relationsActuelles); foreach (CInfoRelation rel in nouvellesRelations) { foreach (string strChampFils in rel.ChampsFille) { if (strChampsAutorisesANull.Contains(strChampFils)) { rel.Obligatoire = false; } } string strRequeteRelation = GetRequeteCreateCleEtrangere(rel); result = Connection.RunStatement(strRequeteRelation); if (result) { AfterChangeContraintes(CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille)); } string strNomTableFilleInDb = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille); if (result && rel.Indexed) { result = CreateIndex(strNomTableFilleInDb, rel.IsClustered, rel.ChampsFille); if (result) { AfterChangeIndexs(CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille)); } } if (!result) { result.EmpileErreur(I.T("Error while creating foreign key of @1 table (@2)|127", structure.NomTableInDb, strRequeteRelation)); return(result); } } foreach (CInfoRelation rel in relationsObseletes) { string strNomTableFilleInDb = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille); result = DeleteIndex(strNomTableFilleInDb, rel.ChampsFille); string strRequeteRelation = GetRequeteDeleteClefEtrangere(rel); result = Connection.RunStatement(strRequeteRelation); if (result) { AfterChangeContraintes(strNomTableFilleInDb); } if (!result) { result.EmpileErreur(I.T("Error while deleting foreign key of @1 table (@2)|212", structure.NomTableInDb, strRequeteRelation)); return(result); } } //Vérification des indexs des relations foreach (CInfoRelation rel in relationsVoulues) { if (!nouvellesRelations.Contains(rel)) { string strNomTableFilleInDb = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille); if (rel.Indexed) { result = CreateIndex(strNomTableFilleInDb, rel.IsClustered, rel.ChampsFille); } else if (ShouldDeleteIndexRelation(strNomTableFilleInDb, rel)) { result = DeleteIndex(strNomTableFilleInDb, rel.ChampsFille); } if (!result) { return(result); } } } //Gestion des attributs Index sur la classe foreach (CInfoIndexTable info in structure.IndexSupplementaires) { result = CreateIndex(strNomTable, info.IsCluster, info.Champs); if (!result) { return(result); } } #endregion //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ return(result); }