/// //////////////////////////////////////////////////////////////////////////
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);
}
