//----------------------------------------------------
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);
}
/// //////////////////////////////////////////////////////////////////////////
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()));
}
}
}
}
//-----------------------------------------------------------------------------------------
/// <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);
}
/////////////////////////////////////////////////////////////////////////////////
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);
}
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;
}
}
// 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);
}
//----------------------------------------------------
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);
}
//-------------------------------------------------------------------
/// <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 static void OnRetrieveMails(object state)
{
if (m_bTraitementEnCours)
return;
m_bTraitementEnCours = true;
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("MAIL ACCOUNT SERVICE|10001"),
ETypeApplicationCliente.Service);
if (!result)
{
C2iEventLog.WriteErreur(I.T("Session Opening error for Mail Account Management Service|10003"));
return;
}
}
try
{
CFiltreData filtre = new CFiltreData(
CCompteMail.c_champIsActive + " = @1",
true);
if (new CCompteMailServeur(m_sessionRecherche.IdSession).CountRecords(
CCompteMail.c_nomTable, filtre) > 0)
{
CSessionClient sessionTravail = new CSessionProcessServeurSuivi();
result = sessionTravail.OpenSession(new CAuthentificationSessionServer(),
I.T("RECEIVE MAILS SERVICE|10004"),
ETypeApplicationCliente.Service);
if (!result)
{
C2iEventLog.WriteErreur(I.T("Working session openning error for Receive Mails Service|10005"));
return;
}
try
{
using (CContexteDonnee contexteTravail = new CContexteDonnee(sessionTravail.IdSession, true, false))
{
//CCompteMailServeur compteServeur = new CCompteMailServeur(sessionTravail.IdSession);
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteTravail, typeof(CCompteMail));
liste.Filtre = filtre;
ArrayList lstLock = liste.ToArrayList();
foreach (CCompteMail compteMail in lstLock)
{
if (compteMail.DateDernierReleve == null ||
compteMail.DateDernierReleve.Value.AddMinutes(compteMail.PeriodeReleve) < DateTime.Now)
{
result += compteMail.RetrieveMails();
}
}
}
}
catch (Exception e)
{
C2iEventLog.WriteErreur(I.T("Error while receiving Mail : @1|10006", e.ToString()));
}
finally
{
try
{
sessionTravail.CloseSession();
}
catch { }
}
}
}
catch (Exception e)
{
C2iEventLog.WriteErreur(I.T("Error while receiving Mail : @1|10006", e.ToString()));
}
}
catch (Exception e)
{
{
C2iEventLog.WriteErreur(I.T("Error while receiving Mail : @1|10006", e.ToString()));
}
}
finally
{
m_bTraitementEnCours = false;
}
}
public CResultAErreurType <CMappageIdsAlarmes> Traite(CMemoryDb dbContenantLesAlarmesATraiter)
{
CResultAErreurType <CMappageIdsAlarmes> result = new CResultAErreurType <CMappageIdsAlarmes>();
result.SetTrue();
CResultAErreur resErreur = CResultAErreur.True;
try
{
lock (typeof(CLockerTraitementAlarme))
{
resErreur = AssureSessionEtContexte();
if (!resErreur)
{
result.EmpileErreur(resErreur.Erreur);
return(result);
}
CListeEntitesDeMemoryDb <CLocalAlarme> lstAlarmes = new CListeEntitesDeMemoryDb <CLocalAlarme>(dbContenantLesAlarmesATraiter);
lstAlarmes.Filtre = new CFiltreMemoryDb(CMemoryDb.c_champIsToRead + "=@1", false);
lstAlarmes.Sort = CLocalAlarme.c_champDateDebut;
//Mappage des ids pour les alarmes qui changent d'ID
m_nNbAlarmesTraitees += lstAlarmes.Count();
CMappageIdsAlarmes dicMapIds = new CMappageIdsAlarmes();
HashSet <string> alarmesTraitees = new HashSet <string>();
using (CContexteDonnee ctxEdit = m_contexteDonnee.GetContexteEdition())
{
ctxEdit.EnableTraitementsExternes = false;
ctxEdit.DisableHistorisation = true;
try
{
foreach (CLocalAlarme alrm in lstAlarmes)
{
if (!alarmesTraitees.Contains(alrm.Id))
{
CLocalAlarme root = alrm;
while (root.Parent != null && !root.Parent.IsToRead())
{
root = root.Parent;
}
GereHierarchie(ctxEdit, root, dicMapIds, alarmesTraitees, null);
}
}
result.DataType = dicMapIds;
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
if (result)
{
resErreur = SauvegardeOptimisee(ctxEdit);
if (!resErreur)
{
result.EmpileErreur(resErreur.Erreur);
}
}
else
{
ctxEdit.CancelEdit();
}
}
}
}
}
catch (Exception e)
{
{
C2iEventLog.WriteErreur(I.T("Error in Alarms @1|20156", e.ToString()));
}
}
finally
{
}
Console.WriteLine("Alarmes traitées : " + m_nNbAlarmesTraitees + " à " + DateTime.Now.ToString("HH:mm:ss"));
return(result);
}
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 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);
}
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 CResultAErreur TraiteDataRowFromCsv(string strCsvDataRow)
{
CResultAErreur result = CResultAErreur.True;
// Traite la data row de données CSV
string[] listeDatas = strCsvDataRow.Split(';');
string strHostId = listeDatas[0];
if (strHostId == "")
{
string strErreur = "No host Id for CSV data row : " + strCsvDataRow;
C2iEventLog.WriteErreur(strErreur);
result.EmpileErreur(strErreur);
return(result);
}
HostId = strHostId;
try{
DateTime dt = ParseDateFromString(listeDatas[1]);
if (dt != null)
{
//Vérifie l'existence de cet élément
CListeObjetDonneeGenerique <CCamusatQowisioData> lstToCount = new CListeObjetDonneeGenerique <CCamusatQowisioData>(ContexteDonnee);
lstToCount.Filtre = new CFiltreData(
c_champQwHost_Id + "=@1 and " +
c_champQwDateTime + "=@2",
strHostId,
dt);
if (lstToCount.Count > 0)
{
if (IsNew())
{
CancelCreate();
}
PointeSurLigne(lstToCount[0].Id);
}
}
}
catch (Exception e)
{
}
int?nIdSite = TrouveAssociationIdHost_IdSite(strHostId, ContexteDonnee);
if (nIdSite == null)
{
string strErreur = "Error in TraiteDataRowFromCsv: No associatied Site found for Host Id : " + strHostId;
C2iEventLog.WriteErreur(strErreur);
result.EmpileErreur(strErreur);
return(result);
}
int nIdTypSite = -1;
lock (typeof(CLockerCacheDatasQowisio))
{
if (!s_dicCacheSiteId_TypeSiteId.TryGetValue(nIdSite.Value, out nIdTypSite))
{
CSite site = new CSite(ContexteDonnee);
if (site.ReadIfExists(nIdSite))
{
nIdTypSite = site.TypeSite.Id;
s_dicCacheSiteId_TypeSiteId[nIdSite.Value] = nIdTypSite;
}
}
}
if (nIdTypSite == c_nIdTypeSiteTelecom)
{
SiteId = nIdSite;
}
else if (nIdTypSite == c_nIdTypeSitePickup)
{
PickupId = nIdSite;
}
else
{
string strErreur = "Error in Site Type for site Id = " + nIdSite.Value;
C2iEventLog.WriteErreur(strErreur);
result.EmpileErreur(strErreur);
return(result);
}
int nNbColonnes = listeDatas.Length;
for (int i = 1; i < nNbColonnes; i++)
{
string strDataSource = listeDatas[i];
KeyValuePair <string, Type> defChampData;
if (s_dicMappageColonneCsv_ChampData.TryGetValue(i, out defChampData))
{
string strNomChamp = defChampData.Key;
Type typeDonnee = defChampData.Value;
if (typeDonnee == typeof(DateTime))
{
try
{
DateTime date = ParseDateFromString(strDataSource);
Row[strNomChamp] = date;
continue;
}
catch { }
}
if (typeDonnee == typeof(int?))
{
if (strDataSource.Trim() == "")
{
Row[strNomChamp] = DBNull.Value;
}
else
{
try
{
int nVal = Int32.Parse(strDataSource);
Row[strNomChamp] = nVal;
}
catch
{
Row[strNomChamp] = DBNull.Value;
}
}
}
if (typeDonnee == typeof(double))
{
try
{
double valeur = CUtilDouble.DoubleFromString(strDataSource);
Row[strNomChamp] = valeur;
continue;
}
catch { }
}
if (typeDonnee == typeof(string))
{
Row[strNomChamp] = strDataSource;
continue;
}
}
else
{
return(result);
}
}
result += TraiteAssociationsFuelProbeTank();
return(result);
}
public static void MonitorAlarmes()
{
int nCptWatchDogAlSyst = 0;
Thread.Sleep(50000);
CSessionClient session = CSessionClient.CreateInstance();
session.OpenSession(new CAuthentificationSessionServer());
while (true)
{
//Thread.Sleep(200); // inhibition pour faciliter debug des autres objets
//continue;
nCptWatchDogAlSyst++;
using (CContexteDonnee ctx = new CContexteDonnee(session.IdSession, true, true))
{
CListeObjetsDonnees lst = new CListeObjetsDonnees(ctx, typeof(CSpvMessalrm));
if (lst.Count > 0)
{
List <CEvenementAlarm> lstAlarm = new List <CEvenementAlarm>();
StringBuilder bl = new StringBuilder();
foreach (CSpvMessalrm message in lst)
{
try
{
CEvenementAlarm eventAlarm = message.GetNewEvenementAlarm();
if (eventAlarm != null)
{
lstAlarm.Add(eventAlarm);
}
}
catch (Exception e)
{
C2iEventLog.WriteErreur(e.Message);
}
bl.Append(message.Id);
bl.Append(',');
}
bl.Remove(bl.Length - 1, 1);
if (lstAlarm.Count > 0)
{
CDonneeNotificationAlarmes notif = new CDonneeNotificationAlarmes(session.IdSession, lstAlarm);
CEnvoyeurNotification.EnvoieNotifications(new IDonneeNotification[] { notif });
}
SendMailsDelegate sndMail = new SendMailsDelegate(SendMails);
sndMail.BeginInvoke(lstAlarm, ctx, null, null);
IDatabaseConnexion connexion = CSc2iDataServer.GetInstance().GetDatabaseConnexion(session.IdSession, CSpvServeur.c_spvConnection);
connexion.RunStatement("Delete from " + CSpvMessalrm.c_nomTableInDb + " where " +
CSpvMessalrm.c_champMESSALRM_ID + " in (" + bl.ToString() + ")");
/* TimeSpan sp = DateTime.Now - dt;
* double fTime = sp.TotalMilliseconds;*/
}//if (lst.Count > 0)
if (nCptWatchDogAlSyst >= 200) // vérification toutes les 20 secondes
{
nCptWatchDogAlSyst = 0;
IDatabaseConnexion cnx = CSc2iDataServer.GetInstance().GetDatabaseConnexion(session.IdSession, CSpvServeur.c_spvConnection);
cnx.RunStatement("begin WatchDog; end;");
}
}
if (C2iStopApp.AppStopper.WaitOne(100, false))
{
break;
}
}
}
private static void OnSendSMS(object state)
{
if (m_bTraitementEnCours)
{
return;
}
m_bTraitementEnCours = true;
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("SMS SERVICE|20159"),
ETypeApplicationCliente.Service);
if (!result)
{
C2iEventLog.WriteErreur(I.T("Session Opening error for SMS Service|20160"));
return;
}
}
try
{
CFiltreData filtre = new CFiltreData(CMessageSMS.c_champNextSendDate + " < @1 and " +
CMessageSMS.c_champDateEnvoi + " is null and " +
CMessageSMS.c_champNbEssais + " < 10",
DateTime.Now
);
if (new CMessageSMSServeur(m_sessionRecherche.IdSession).CountRecords(
CMessageSMS.c_nomTable, filtre) > 0)
{
CSessionClient sessionTravail = new CSessionProcessServeurSuivi();
result = sessionTravail.OpenSession(new CAuthentificationSessionProcess(),
I.T("Send SMS|20161"),
ETypeApplicationCliente.Service);
if (!result)
{
C2iEventLog.WriteErreur(I.T("Working session openning error for SMS send|20162"));
return;
}
try
{
using (CContexteDonnee contexteTravail = new CContexteDonnee(sessionTravail.IdSession, true, false))
{
CMessageSMSServeur serveur = new CMessageSMSServeur(sessionTravail.IdSession);
CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteTravail, typeof(CMessageSMS));
liste.Filtre = filtre;
ArrayList lstLock = liste.ToArrayList();
foreach (CMessageSMS message in lstLock)
{
CMessageSMSPourEnvoi toSend = new CMessageSMSPourEnvoi(message.Destinataires, message.Texte);
result = toSend.Send(sessionTravail.IdSession);
message.BeginEdit();
if (!result)
{
message.NextSendDate = DateTime.Now.AddMinutes(3);
message.NbEssais++;
message.LastErreur = result.Erreur.ToString();
}
else
{
message.DateEnvoi = DateTime.Now;
message.LastErreur = "";
}
message.CommitEdit();
result.SetTrue();
}
}
}
catch (Exception e)
{
C2iEventLog.WriteErreur(I.T("Error while sendind SMS : @1|20163", e.ToString()));
}
finally
{
try
{
sessionTravail.CloseSession();
}
catch { }
}
}
}
catch (Exception e)
{
C2iEventLog.WriteErreur(I.T("Error while sendind SMS : @1|20163", e.ToString()));
}
}
catch (Exception e)
{
{
C2iEventLog.WriteErreur(I.T("Error while sendind SMS : @1|20163", e.ToString()));
}
}
finally
{
m_bTraitementEnCours = false;
}
}
public static void Demasque()
{
int c_nAttente = 500; // 500 ms d'attente dans la boucle
int nNbToursBoucle = 1800000 / c_nAttente; // Nb de tours de boucle pour 1/2h d'attente
Thread.Sleep(50000);
CSessionClient session = CSessionClient.CreateInstance();
session.OpenSession(new CAuthentificationSessionServer(), "Unmask alarms", ETypeApplicationCliente.Service);
IDatabaseConnexion connexion = CSc2iDataServer.GetInstance().GetDatabaseConnexion(session.IdSession, CSpvServeur.c_spvConnection);
string stSQL = "Begin MaskModified; end;";
CResultAErreur result;
int nErreur1 = 0, nErreur2 = 0;
while (true)
{
// Démasquage
result = CResultAErreur.True;
try
{
// Démasquage
result += connexion.BeginTrans();
if (result)
{
result += connexion.ExecuteScalar(stSQL);
}
if (result)
{
result += connexion.CommitTrans();
}
else
{
connexion.RollbackTrans();
}
}
catch (Exception e)
{
result.EmpileErreur(e.Message);
}
if (!result)
{
if (nErreur1 == 0)
{
C2iEventLog.WriteErreur(I.T("Problem with unmasking alarms automatically|50000"));
nErreur1++;
}
}
// Pour ne pas trop encombrer les événements windows
if (nErreur1 > 0)
{
nErreur1++;
}
else if (nErreur1 > nNbToursBoucle) // Equipvaut à 1/2 heure
{
nErreur1 = 0;
}
// Démasquage alarmes filles (traitement déconnecté du précédent)
try
{
result = connexion.BeginTrans();
if (result)
{
result += connexion.ExecuteScalar("DELETE " + CSpvFinalarm.c_nomTableInDb);
}
if (result)
{
result += connexion.CommitTrans();
}
else
{
connexion.RollbackTrans();
}
}
catch (Exception e)
{
result.EmpileErreur(e.Message);
}
if (!result)
{
if (nErreur2 == 0)
{
C2iEventLog.WriteErreur(I.T("Problem with unmasking child alarms automatically|50001"));
nErreur2++;
}
}
// Pour ne pas trop encombrer les événements windows
if (nErreur2 > 0)
{
nErreur2++;
}
else if (nErreur2 > nNbToursBoucle) // Equipvaut à 1/2 heure
{
nErreur2 = 0;
}
if (C2iStopApp.AppStopper.WaitOne(c_nAttente, false))
{
break;
}
}
}
//------------------------------------------------------------------------
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());
}
}
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;
}
}
//----------------------------------------------------------------------------------
/// <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;
}
}
//------------------------------------------------------------------------------------
/// <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);
}
//-------------------------------------------------------------------
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);
}
}