public void Dispose()
{
if (m_session != null)
{
m_session.CloseSession();
m_session.Dispose();
}
}
//-----------------------------------------------------------------------------------------------------
public void CloseSession(int nIdSession)
{
CInfoSessionAspectize.OnCloseSession(nIdSession);
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
if (session != null)
{
session.CloseSession();
}
}
private void m_lnkFermer_LinkClicked(object sender, System.Windows.Forms.LinkLabelLinkClickedEventArgs e)
{
CResultAErreur result = CResultAErreur.True;
if (MessageBox.Show("Fermer toutes les sessions sélectionnées ?", "Confirmation",
MessageBoxButtons.YesNo,
MessageBoxIcon.Question) == DialogResult.No)
{
return;
}
ArrayList lstThreads = new ArrayList();
m_listeServicesToLaunch.Clear();
m_listeThreadsEnAttente.Clear();
ThreadStart funcStart = new ThreadStart(AskForClose);
foreach (ListViewItem item in m_listView.CheckedItems)
{
int nIdSession = (int)item.Tag;
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
try
{
CServiceSurClientFermerApplication service = (CServiceSurClientFermerApplication)session.GetServiceSurClient(CServiceSurClientFermerApplication.c_idService);
if (service != null)
{
lock (m_listeServicesToLaunch)
{
m_listeServicesToLaunch.Add(service);
}
Thread th = new Thread(funcStart);
th.Start();
}
}
catch (Exception ex1)
{
result.EmpileErreur(ex1.Message);
try
{
if (session != null)
{
session.CloseSession();
}
}
catch (Exception ex2)
{
result.EmpileErreur(ex2.Message);
}
}
}
if (!result)
{
MessageBox.Show(result.MessageErreur);
}
}
/// <summary>
/// Exemple ligne de commande
/// TimosAuthDataBase.exe 127.0.0.1 TIMOS_USERS_PREPROD "Data Source=DESKTOP-VMDEVYK\SQLEXPRESS;Initial Catalog=TIMOS_USERS_DB;Integrated Security=True;Pooling=False"
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
CResultAErreur result = CResultAErreur.True;
string strURL = "tcp://127.0.0.1:8160";
string strNomTable = "TIMOS_USERS_PREPROD";
string strChaineDeConnexion = @"Data Source=DESKTOP-VMDEVYK\SQLEXPRESS;Initial Catalog=TIMOS_USERS_DB;Integrated Security=True;Pooling=False";
if (args.Length > 0)
{
strURL = "tcp://" + args[0] + ":8160";
if (args.Length > 1)
{
strNomTable = args[1];
}
if (args.Length > 2)
{
strChaineDeConnexion = args[2];
}
}
try
{
result = CInitialiseurClientTimos.InitClientTimos(strURL, 0, "", null);
}
catch { }
if (result)
{
CSessionClient session = CSessionClient.CreateInstance();
result = session.OpenSession(new CAuthentificationSessionProcess(), "Timos Auth Database", ETypeApplicationCliente.Process);
if (!result)
{
result.EmpileErreur("Erreur lors de l'authentification");
}
if (result)
{
Console.WriteLine("Argument 1 = " + strURL);
Console.WriteLine("Argument 2 = " + strNomTable);
result = GetTimosUsers(session.IdSession, strNomTable);
if (result && result.Data != null)
{
DataSet dataSource = result.Data as DataSet;
result = UpdateDatabase(strChaineDeConnexion, strNomTable, dataSource);
}
session.CloseSession();
}
}
if (!result)
{
Console.WriteLine(result.MessageErreur);
}
//Console.ReadKey();
}
//----------------------------------------------------------------------
public CResultAErreur UpdateValeurs(CContexteDonnee contexteDeBasePasEnEdition, IIndicateurProgression indicateurProgression)
{
if (Count == 0)
{
return(CResultAErreur.True);
}
CConteneurIndicateurProgression progress = CConteneurIndicateurProgression.GetConteneur(indicateurProgression);
CResultAErreur result = CResultAErreur.True;
//Lecture entite par entité pour optimiser la lecture
Dictionary <CEntiteSnmp, HashSet <CChampCustom> > lstChamps = new Dictionary <CEntiteSnmp, HashSet <CChampCustom> >();
progress.SetBornesSegment(0, Count);
foreach (CCoupleEntiteSnmp_Champ couple in this)
{
HashSet <CChampCustom> set = null;
if (!lstChamps.TryGetValue(couple.Entite, out set))
{
set = new HashSet <CChampCustom>();
lstChamps[couple.Entite] = set;
}
set.Add(couple.ChampCustom);
}
CSessionClient session = CSousSessionClient.GetNewSousSession(this[0].Entite.ContexteDonnee.IdSession);
session.OpenSession(new CAuthentificationSessionSousSession(this[0].Entite.ContexteDonnee.IdSession),
"SNMP", ETypeApplicationCliente.Service);
using (CContexteDonnee ctxModif = new CContexteDonnee(session.IdSession, true, false))
{
int nIndex = 1;
foreach (KeyValuePair <CEntiteSnmp, HashSet <CChampCustom> > kv in lstChamps)
{
CEntiteSnmp entite = kv.Key.GetObjetInContexte(ctxModif) as CEntiteSnmp;
CInterrogateurSnmp dynamicAgent = new CInterrogateurSnmp();
dynamicAgent.Connexion = entite.AgentSnmp.GetNewSnmpConnexion();
CEntiteSnmpPourSupervision ettSup = null;
foreach (CChampCustom champ in kv.Value)
{
int nIdChamp = champ.Id;
if (entite.ReadChampSnmp(nIdChamp, dynamicAgent, ref ettSup))
{
entite.CopieValeurSnmpDansValeurChamp(nIdChamp);
}
progress.SetValue(nIndex++);
}
}
progress.SetValue(Count);
ctxModif.SaveAll(true);
System.Threading.Thread.Sleep(2000);
session.CloseSession();
}
return(result);
}
/// /////////////////////////////////////////////////////////
public CResultAErreur Close()
{
CResultAErreur result = CResultAErreur.True;
result = MyClose();
try
{
m_session.CloseSession();
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public void OnEndProcess()
{
DoTraitementApresExecution();
if (m_bHasSessionPropre)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
if (session != null)
{
try
{
session.CloseSession();
}
catch { }
}
}
}
//---------------------------------------------------------------------------
public void CloseSession(int nIdSession)
{
CInfoSessionTiag.OnCloseSession(nIdSession);
CResultDataSet result = new CResultDataSet();
CUtilTimosTiag util = CUtilTimosTiag.GetUtilTiagForSession(nIdSession);
if (util != null)
{
util.OnCloseSession();
}
CSessionClient session = GetSession(nIdSession, result);
if (session != null)
{
session.CloseSession();
}
}
private static void OnTimerCloseSession(object state)
{
lock (typeof(CLockerSession))
{
if (DateTime.Now > m_datePeremptionSession)
{
try
{
if (m_session != null)
{
m_session.CloseSession();
}
}
catch
{
}
m_session = null;
}
}
}
//------------------------------------------------------------------------
private void AssureSession()
{
//S'assure de la validité de la session
if (m_session != null && !m_session.IsConnected)
{
m_session.CloseSession();
m_session.Dispose();
m_session = null;
}
if (m_session == null)
{
m_session = CSessionClient.CreateInstance();
CResultAErreur result = m_session.OpenSession(new CAuthentificationSessionProcess(), "Steps looper",
ETypeApplicationCliente.Service);
if (!result)
{
//C2iEventLog.WriteErreur("DEBUG_TODO - AssureSession() - Failed to create Step session looper" + Environment.NewLine + result.MessageErreur);
m_session = null;
}
}
}
//----------------------------------------------------------------------------------
/// <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 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;
}
}
/// //////////////////////////////////////////////////
///Démarre une étape.
///Attention, un étape ne peut démarrer que si elle n'est pas déjà démarrée
public void RunEtape(int nIdSessionMain, int nIdEtape)
{
CResultAErreur result = CResultAErreur.True;
CDbKey keyUser = null;
//Attend la fin des transactions en cours pour la session principale
IDatabaseConnexion cnx = null;
do
{
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
if (session != null && session.IsConnected)
{
IInfoUtilisateur info = session.GetInfoUtilisateur();
//TESTDBKEYTODO
if (info != null)
{
keyUser = info.KeyUtilisateur;
}
try
{
cnx = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, typeof(CEtapeWorkflow));
}
catch //En cas d'erreur, c'est probablement que la session a été fermée, du coup, on peut y aller !
{
cnx = null;
}
System.Threading.Thread.Sleep(50);
}
else
{
cnx = null;
}
}while (cnx != null && cnx.IsInTrans());
lock (typeof(CLockerStartEtape))//S'assure que deux étapes ne démarrent pas en même temps !
{
List <CDonneeNotificationWorkflow> lstNotifications = new List <CDonneeNotificationWorkflow>();
CAuthentificationSessionProcess auth = new CAuthentificationSessionProcess();
using (CSessionClient sousSession = CSessionClient.CreateInstance())
{
try
{
Console.WriteLine("Thread : " + System.Diagnostics.Process.GetCurrentProcess().Threads.Count);
sousSession.OpenSession(auth, "Workflow step " + nIdEtape, ETypeApplicationCliente.Process);
//TESTDBKEYTODO
if (keyUser != null)
{
sousSession.ChangeUtilisateur(keyUser);
}
using (CContexteDonnee ctx = new CContexteDonnee(sousSession.IdSession, true, true))
{
CEtapeWorkflow etape = new CEtapeWorkflow(ctx);
int nWaiter = 10;
while (!etape.ReadIfExists(nIdEtape) && nWaiter > 0)
{
//On ne trouve pas l'étape, c'est peut être que l'écriture en base n'est pas completement terminée
//On va retenter toutes les 2 secondes pendant 20 secondes, si elle n'existe jamais,
//c'est qu'il y a eu suppression (ou au moins non commit).
nWaiter--;
Thread.Sleep(2000);
}
if (etape.ReadIfExists(nIdEtape))
{
result = etape.InternalSetInfosDemarrageInCurrentContext();
etape.EtatCode = (int)EEtatEtapeWorkflow.Démarrée;
result = ctx.SaveAll(true);
if (result)
{
result = etape.InternalRunAndSaveifOk();
}
if (result && etape.CodeAffectations.Length > 0 && etape.DateFin == null)
{
CDonneeNotificationWorkflow donneeWorkflow = new CDonneeNotificationWorkflow(
nIdSessionMain,
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);
}
if (!result)
{
NoteErreurSurEtape(etape, result.Erreur.ToString());
return;
}
}
}
}
catch (Exception e)
{
}
finally
{
sousSession.CloseSession();
}
}
if (lstNotifications != null)
{
CEnvoyeurNotification.EnvoieNotifications(lstNotifications.ToArray());
}
}
}
/// <summary>
/// Execute une action
/// </summary>
/// <param name="action"></param>
/// <param name="contexte"></param>
/// <param name="bIsActionPrincipaleProcess">Si vrai, considère que le process en execution est fermé en sortie,
/// si non, il s'agit d'une action appelée dans une boucle par exemple</param>
/// <returns></returns>
public CResultAErreur ExecuteAction(
CAction action,
CContexteExecutionAction contexte,
object objetCible,
bool bIsActionPrincipaleProcess)
{
CResultAErreur result = CResultAErreur.True;
m_pile.Add(new CInfoPileExecution(null, action));
m_nIdActionEnCours = action.IdObjetProcess;
action.Process.SetValeurChamp(CProcess.c_strIdVariableElement, objetCible);
bool bFermerLaSessionEnSortant = IsModeAsynchrone && bIsActionPrincipaleProcess;
CSessionClient sessionClient = CSessionClient.GetSessionForIdSession(contexte.IdSession);
CConfigurationsImpression oldConf = null;
contexte.SetInfoProgression(action.Libelle);
try
{
if (contexte.IndicateurProgression != null && contexte.IndicateurProgression.CancelRequest)
{
result.EmpileErreur(I.T("User cancellation|182"));
result.Data = null;
return(result);
}
}
catch { }
if (sessionClient != null)
{
oldConf = sessionClient.ConfigurationsImpression;
}
try
{
if (sessionClient != null)
{
sessionClient.ConfigurationsImpression = ConfigurationImpression;
}
action.Process.ContexteExecution = contexte;
result = action.Execute(contexte);
while (result.Data != null && result)
{
//retourne un lien : on continue
if (result.Data is CLienAction)
{
m_nIdActionEnCours = action.IdObjetProcess;
CLienAction lien = (CLienAction)result.Data;
m_pile.Add(new CInfoPileExecution(lien, lien.ActionArrivee));
contexte.ProcessEnExecution.LibelleActionEnCours = lien.ActionArrivee.Libelle;
if (lien is CLienAsynchrone && !IsModeAsynchrone)
{
IsModeAsynchrone = true;
//Execution de l'action en mode asynchrone et fin
m_actionAsynchroneAExecuter = lien.ActionArrivee;
m_contexteAsynchrone = contexte;
Thread th = new Thread(new ThreadStart(ExecuteActionAsynchrone));
th.Start();
bFermerLaSessionEnSortant = false;
result.Data = null;
return(result);
}
else
{
action = ((CLienAction)result.Data).ActionArrivee;
action.Process.ContexteExecution = contexte;
contexte.SetInfoProgression(action.Libelle);
try
{
if (contexte.IndicateurProgression != null && contexte.IndicateurProgression.CancelRequest)
{
result.EmpileErreur(I.T("User cancellation|182"));
result.Data = null;
return(result);
}
}
catch { }
result = action.Execute(contexte);
}
}
else if (result.Data is CMetteurDeProcessEnPause)
{
//Mise en pause du process
result = contexte.ProcessEnExecution.PauseProcess(contexte);
result.Data = null;
return(result);
}
else
{
result.Data = null;
}
}
if (bIsActionPrincipaleProcess && result)
{
CResultAErreur resultTmp = contexte.ProcessEnExecution.EnProcess(contexte);
if (!resultTmp)
{
result.Erreur += resultTmp.Erreur;
result.Result = false;
}
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
}
finally
{
if (sessionClient != null)
{
sessionClient.ConfigurationsImpression = oldConf;
}
if (!result && bIsActionPrincipaleProcess)
{
//Pour ne modifier que le process et ne surtout pas faire les sauvegardes autres
contexte.ProcessEnExecution.BeginEdit();
contexte.ProcessEnExecution.Etat = EtatProcess.Erreur;
contexte.ProcessEnExecution.BrancheEnCours = this;
contexte.ProcessEnExecution.InfoEtat = result.Erreur.ToString();
if (IsModeAsynchrone)
{
//Notifie l'utilisateur qu'un erreur est survenue
CBesoinInterventionProcess intervention = new CBesoinInterventionProcess(contexte.ProcessEnExecution.ContexteDonnee);
intervention.CreateNewInCurrentContexte();
intervention.Libelle = I.T("@1 action error|259", contexte.ProcessEnExecution.Libelle);
intervention.DateDemande = DateTime.Now;
//Crée une boite de message pour afficher l'erreur
CProcess process = contexte.Branche.Process;
CActionMessageBox actionNotif = new CActionMessageBox(process);
actionNotif.FormuleMessage = new sc2i.expression.C2iExpressionConstante(intervention.Libelle + "\r\n" + result.Erreur.ToString());
actionNotif.Libelle = I.T("Error notification|260");
process.AddAction(actionNotif);
intervention.IdAction = actionNotif.IdObjetProcess;
//TESTDBKEYOK
intervention.KeyUtilisateur = KeyUtilisateur;
intervention.ProcessEnExecution = contexte.ProcessEnExecution;
contexte.ProcessEnExecution.BrancheEnCours = contexte.Branche;
}
contexte.ProcessEnExecution.CommitEdit();
}
if (IsModeAsynchrone && bFermerLaSessionEnSortant)
{
//Ferme la session
try
{
CSessionClient session = CSessionClient.GetSessionForIdSession(contexte.IdSession);
session.CloseSession();
}
catch {}
}
}
result.Data = null;
return(result);
}
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;
}
}
/// //////////////////////////////////////////////////
///Lance le calcul
public static void DoCalc(CElementsProjetARecalculer lstElements)
{
CResultAErreur result = CResultAErreur.True;
CDbKey keyUser = null;
//Attend la fin des transactions en cours pour la session principale
IDatabaseConnexion cnx = null;
do
{
CSessionClient session = CSessionClient.GetSessionForIdSession(lstElements.IdSession);
if (session != null && session.IsConnected)
{
IInfoUtilisateur info = session.GetInfoUtilisateur();
//TESTDBKEYOK
if (info != null)
{
keyUser = info.KeyUtilisateur;
}
try
{
cnx = CSc2iDataServer.GetInstance().GetDatabaseConnexion(lstElements.IdSession, typeof(CProjet));
}
catch //En cas d'erreur, c'est probablement que la session a été fermée, du coup, on peut y aller !
{
cnx = null;
}
System.Threading.Thread.Sleep(50);
}
else
{
cnx = null;
}
}while (cnx != null && cnx.IsInTrans());
lock (typeof(CLockerStartEtape))//S'assure que deux étapes ne démarrent pas en même temps !
{
CAuthentificationSessionProcess auth = new CAuthentificationSessionProcess();
using (CSessionClient sousSession = CSessionClient.CreateInstance())
{
try
{
sousSession.OpenSession(auth, "Projet asynchronous calc ", ETypeApplicationCliente.Process);
if (keyUser != null)
{
sousSession.ChangeUtilisateur(keyUser);
}
using (CContexteDonnee ctx = new CContexteDonnee(sousSession.IdSession, true, true))
{
SetModeCalculProjet(ctx);
foreach (int nIdProjet in lstElements.IdsProjets)
{
CProjet projet = new CProjet(ctx);
if (projet.ReadIfExists(nIdProjet))
{
projet.RecalculateDates(false);
}
}
foreach (int nIdMetaProjet in lstElements.IdsMetaProjets)
{
CMetaProjet meta = new CMetaProjet(ctx);
if (meta.ReadIfExists(nIdMetaProjet))
{
meta.UpdateDateDebutPlanifieeFromChilds(false);
meta.UpdateDateFinPlanifieeFromChilds(false);
meta.UpdateDateDebutReelleFromChilds(false);
meta.UpdateDateFinReelleFromChilds(false);
meta.CalcProgress(false);
}
}
result = ctx.SaveAll(false);
}
}
catch (Exception e)
{
}
finally
{
sousSession.CloseSession();
}
}
}
}