protected CResultAErreur CanOpenSessionLogin(CSessionClient session)
{
CResultAErreur result = CResultAErreur.True;
if (session.Authentification is CAuthentificationSessionTimosLoginPwd)
{
CAuthentificationSessionTimosLoginPwd auth = (CAuthentificationSessionTimosLoginPwd)session.Authentification;
result = IsUserValide(auth.Login, auth.MotDePasse);
if (result)
{
return(InitialiserSessionCliente(session, (CDonneesActeurUtilisateur)result.Data));
}
}
else
{
result.EmpileErreur(I.T("Authentification type error|30004"));
}
return(result);
}
public static void AssureInit()
{
CResultAErreur result = CResultAErreur.True;
if (m_sessionClient == null)
{
result = CInitialiseurClientTimos.InitClientTimos(new CTimosTestMetierRegistre());
if (!result)
{
throw new Exception(result.Erreur.ToString());
}
m_sessionClient = CSessionClient.CreateInstance();
result = m_sessionClient.OpenSession(new CAuthentificationSessionServiceClient());
if (!result)
{
throw new Exception(result.Erreur.ToString());
}
}
}
protected CResultAErreur CanOpenSessionAD(CSessionClient session)
{
CResultAErreur result = CResultAErreur.True;
if (session.Authentification is CAuthentificationSessionTimosAD)
{
CAuthentificationSessionTimosAD auth = (CAuthentificationSessionTimosAD)session.Authentification;
result = IsUserAdValide(auth.UserId);
if (result)
{
return(InitialiserSessionCliente(session, (CDonneesActeurUtilisateur)result.Data));
}
}
else
{
result.EmpileErreur(I.T("Authentification type error|30004"));
}
return(result);
}
public static CActeur UtilisateurActuel(CContexteDonnee ctx)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(ctx.IdSession);
if (session != null)
{
IInfoUtilisateur infoUser = session.GetInfoUtilisateur();
if (infoUser != null)
{
CDonneesActeurUtilisateur data = new CDonneesActeurUtilisateur(ctx);
//TESTDBKEYOK
if (data.ReadIfExists(infoUser.KeyUtilisateur))
{
return(data.Acteur);
}
}
}
return(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);
}
public CSnmpProxyConfiguration GetConfigurationDeProxy(int nIdProxy)
{
using (CSessionClient session = CSessionClient.CreateInstance())
{
CResultAErreur result = session.OpenSession(new CAuthentificationSessionProcess());
if (!result)
{
return(null);
}
using (CContexteDonnee ctx = new CContexteDonnee(session.IdSession, true, false))
{
CSnmpProxyInDb proxy = new CSnmpProxyInDb(ctx);
if (proxy.ReadIfExists(nIdProxy))
{
return(proxy.GetConfiguration());
}
}
}
return(null);
}
/// //////////////////////////////////////////////////////////////////////////
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 void session_OnCloseSession(object sender, EventArgs e)
{
if (sender is CSessionClient)
{
CSessionClient session = (CSessionClient)sender;
try
{
CContexteDonnee contexte = null;
if (m_tableContextesDonneesParSessions.TryGetValue(session.IdSession, out contexte))
{
contexte.Dispose();
}
}
catch { }
if (m_tableContextesDonneesParSessions.ContainsKey(session.IdSession))
{
m_tableContextesDonneesParSessions.Remove(session.IdSession);
}
}
}
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;
}
}
}
///////////////////////////////////////////////
public CSessionClientSurServeur(CSessionClient sessionSurClient)
{
m_sessionSurClient = sessionSurClient;
IdSession = sessionSurClient.IdSession;
m_dateHeureConnexion = sessionSurClient.DateHeureConnexion;
m_dateHeureDerniereActivite = DateTime.Now;
m_sponsor.Register(m_sessionSurClient);
m_strDescription = sessionSurClient.DescriptionApplicationCliente;
m_typeApplication = sessionSurClient.TypeApplicationCliente;
m_authentification = sessionSurClient.Authentification;
CAuthentificationSessionSousSession autSousSession = m_authentification as CAuthentificationSessionSousSession;
if (autSousSession != null)
{
ISessionClientSurServeur sessionPrincipale = CGestionnaireSessions.GetSessionClientSurServeurStatic(autSousSession.IdSessionPrincipale);
if (sessionPrincipale != null)
{
sessionPrincipale.RegisterSousSession(this);
}
}
}
//-------------------------------------------------------------------
protected override void MyInitValeurDefaut()
{
DateFin = DateTime.Now.AddMonths(1);
try
{
CSessionClient session = CSessionClient.GetSessionForIdSession(ContexteDonnee.IdSession);
if (session != null)
{
//TESTDBKEYOK
CDbKey keyUser = session.GetInfoUtilisateur().KeyUtilisateur;
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(ContexteDonnee);
if (user.ReadIfExists(keyUser))
{
Auteur = user;
}
}
}
catch
{}
IsPublique = true;
}
private bool AssureSession()
{
lock (typeof(CLockerSession))
{
m_datePeremptionSession = DateTime.Now.AddMinutes(5);
if (m_session == null || !m_session.IsConnected)
{
CResultAErreur result = OpenSession();
if (!result)
{
m_session = null;
}
else
{
m_session = (CSessionClient)result.Data;
}
return(result.Result);
}
return(true);
}
}
public static IDonneeDroitUtilisateur GetDonneeDroitForSession(int nIdSession, string strCodeDroit)
{
try
{
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
if (session == null)
{
return(null);
}
IInfoUtilisateur info = session.GetInfoUtilisateur();
if (info == null)
{
return(null);
}
return(info.GetDonneeDroit(strCodeDroit));
}
catch
{
}
return(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;
}
}
}
public static CDonneesActeurUtilisateur GetUserForSession(CContexteDonnee contexte)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(contexte.IdSession);
if (session == null)
{
return(null);
}
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(contexte);
try
{
//TESTDBKEYOK
if (user.ReadIfExists(session.GetInfoUtilisateur().KeyUtilisateur))
{
return(user);
}
}
catch {}
return(null);
}
//---------------------------------------------------------
/// <summary>
/// Stocke les différentes informations pour le démarrage d'une étape
/// (date de début, date de fin à null, idDémarreur et IdTermineur à null)
/// <BR></BR>Cette méthode ne doit pas être utilisée en dehors d'un appel par l'objet serveur
/// </summary>
/// <returns></returns>
public CResultAErreur InternalSetInfosDemarrageInCurrentContext()
{
if (DateDebut != null && DateFin != null)
{
//Historise l'étape
CEtapeWorkflowHistorique h = new CEtapeWorkflowHistorique(ContexteDonnee);
h.CreateNewInCurrentContexte();
h.DateDebut = DateDebut.Value;
h.DateFin = DateFin.Value;
//TESTDBKEYOK
h.KeyDémarreur = KeyDémarreur;
h.KeyTermineur = KeyTermineur;
h.CodesRetourString = CodesRetourString;
h.EtatCode = EtatCode;
h.EtapeAppelante = EtapeAppelante;
h.Etape = this;
h.RunGeneration = RunGeneration;
}
DateDebut = DateTime.Now;
RunGeneration = Workflow.RunGeneration;
DateFin = null;
CodesRetour = new string[0];
CSessionClient session = CSessionClient.GetSessionForIdSession(ContexteDonnee.IdSession);
if (session is CSousSessionClient)
{
session = ((CSousSessionClient)session).RootSession;
}
IInfoUtilisateur info = session != null?session.GetInfoUtilisateur() : null;
KeyDémarreur = info != null ? info.KeyUtilisateur : null;
KeyTermineur = null;
EtatCode = (int)EEtatEtapeWorkflow.ADemarrer;
if (Workflow.EtapeAppelante != null && Workflow.EtapeAppelante.Etat.Code != EEtatEtapeWorkflow.Démarrée)
{
Workflow.EtapeAppelante.OnDemarrageDepuisSousWorkflow();
}
Workflow.IsRunning = true;
return(CResultAErreur.True);
}
//-------------------------------------------------------------------
protected override void MyInitValeurDefaut()
{
DateCreation = DateTime.Now;
NextSendDate = DateTime.Now;
try
{
CSessionClient session = CSessionClient.GetSessionForIdSession(ContexteDonnee.IdSession);
if (session != null)
{
//TESTDBKEYOK
CDbKey keyUser = session.GetInfoUtilisateur().KeyUtilisateur;
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(ContexteDonnee);
if (user.ReadIfExists(keyUser))
{
Auteur = user;
}
}
}
catch
{}
NbEssais = 0;
}
//-----------------------------------------------------------
private void CFormAffectationEntitesOrganisationnelles_Load(object sender, EventArgs e)
{
sc2i.win32.common.CWin32Traducteur.Translate(this);
m_lblEntite.Text = m_objet.DescriptionElement;
m_extModeEdition.ModeEdition = false;
m_btnOk.Visible = false;
CSessionClient session = CSessionClient.GetSessionForIdSession(CTimosApp.SessionClient.IdSession);
CRestrictionUtilisateurSurType rest = session.GetInfoUtilisateur().GetRestrictionsSurObjet(m_objet, m_objet.ContexteDonnee.IdVersionDeTravail);
if (rest.CanModifyType() && !m_objet.ContexteDonnee.IsEnEdition)
{
rest = session.GetInfoUtilisateur().GetRestrictionsSur(typeof(CRelationElement_EO), m_objet.ContexteDonnee.IdVersionDeTravail);
m_lnkAjouter.Visible = rest.CanCreateType();
m_lnkSupprimer.Visible = rest.CanDeleteType();
m_btnOk.Visible = m_lnkAjouter.Visible || m_lnkSupprimer.Visible;
m_extModeEdition.ModeEdition = m_btnOk.Visible;
m_objet.BeginEdit();
m_bStopEditionSurSortie = true;
}
m_wndListeEos.ListeSource = CRelationElement_EO.GetListeRelationsForElement(m_objet);
}
//------------------------------------------------------
private static void SetSetupForWindow(CSessionClient session, Form form, CSetupVisibiliteControles setup)
{
string strKey = c_racineCleRegistre + form.GetType().ToString();
CDataBaseRegistrePourClient reg = new CDataBaseRegistrePourClient(session.IdSession);
if (setup == null)
{
reg.SetValeurBlob(strKey, new byte[0]);
}
else
{
MemoryStream stream = new MemoryStream();
BinaryWriter writer = new BinaryWriter(stream);
CSerializerSaveBinaire ser = new CSerializerSaveBinaire(writer);
CResultAErreur result = setup.Serialize(ser);
stream.Flush();
reg.SetValeurBlob(strKey, stream.GetBuffer());
writer.Close();
stream.Close();
stream.Dispose();
}
}
//-------------------------------------------------------------------
private void GetListesPourValidation(
ref ArrayList listeFichiersToDelete,
ref ArrayList listeFichiersToValide,
ref ArrayList listeFichiersANePasSupprimer)
{
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
listeFichiersToDelete = null;
listeFichiersToValide = null;
listeFichiersANePasSupprimer = null;
if (session != null)
{
listeFichiersToDelete = session.GetPropriete(c_strListeFichiersToDelete) as ArrayList;
listeFichiersToValide = session.GetPropriete(c_strListeFichiersToValidate) as ArrayList;
listeFichiersANePasSupprimer = session.GetPropriete(c_strListeFichierSANePasSupprimer) as ArrayList;
}
else
{
listeFichiersToDelete = m_globaleListeANePasSupprimer;
listeFichiersToValide = m_globaleListeFichiersToValide;
listeFichiersANePasSupprimer = m_globaleListeANePasSupprimer;
return;
}
if (listeFichiersToDelete == null)
{
listeFichiersToDelete = new ArrayList();
session.SetPropriete(c_strListeFichiersToDelete, listeFichiersToDelete);
}
if (listeFichiersToValide == null)
{
listeFichiersToValide = new ArrayList();
session.SetPropriete(c_strListeFichiersToValidate, listeFichiersToValide);
}
if (listeFichiersANePasSupprimer == null)
{
listeFichiersANePasSupprimer = new ArrayList();
session.SetPropriete(c_strListeFichierSANePasSupprimer, listeFichiersANePasSupprimer);
}
}
//----------------------------------------------------
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);
}
//-------------------------------------------------------------------------------
//Annule les modifications réalisées sur l'objet
public CResultAErreur AnnuleModificationsPrevisionnelles(int nIdVersionObjet)
{
CResultAErreur result = CResultAErreur.True;
using (CContexteDonnee contexte = new CContexteDonnee(IdSession, true, false))
{
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
result = session.BeginTrans();
if (!result)
{
return(result);
}
CVersionDonneesObjet versionObjet = new CVersionDonneesObjet(contexte);
if (!versionObjet.ReadIfExists(nIdVersionObjet))
{
return(result); //Rien à annuler
}
CVersionDonnees versionPrev = versionObjet.VersionDonnees;
if (versionPrev.TypeVersion.Code != CTypeVersion.TypeVersion.Previsionnelle)
{
result.EmpileErreur(I.T("Cannot cancel archive operation|220"));
return(result);
}
result = AnnuleModificationPrevisionnelle(versionObjet);
if (result)
{
result = contexte.SaveAll(true);
if (result)
{
result = session.CommitTrans();
}
else
{
result = session.RollbackTrans();
}
}
}
return(result);
}
//---------------------------------------------------------
private void SendMessage()
{
//TESTDBKEYOK
if (m_txtToSend.Text.Trim() != "")
{
try
{
if (m_nIdUtilisateurAutre < 0)
{
CFormAlerte.Afficher(I.T("Select a User |30064"), EFormAlerteType.Erreur);
return;
}
CDbKey keyDest = CSc2iWin32DataClient.ContexteCourant.GetKeyFromId <CDonneesActeurUtilisateur>(m_nIdUtilisateurAutre);
if (!CSessionClient.IsUserConnected(keyDest))
{
CFormAlerte.Afficher(m_lblUser.Text + " is not connected|30065", EFormAlerteType.Erreur);
return;
}
string strMes = m_txtToSend.Text.Replace("\r", " ");
strMes = strMes.Replace("\n", " ");
int?nIdEnvoyeur = CSc2iWin32DataClient.ContexteCourant.GetIdFromKey <CDonneesActeurUtilisateur>(CTimosApp.SessionClient.GetInfoUtilisateur().KeyUtilisateur);
CDonneeNotificationMessageInstantane message = new CDonneeNotificationMessageInstantane(
CTimosApp.SessionClient.IdSession,
nIdEnvoyeur.Value,
keyDest,
strMes);
CEnvoyeurNotification.EnvoieNotifications(new IDonneeNotification[] { message });
AddMessage(strMes, false);
m_txtToSend.Text = "";
}
catch
{
CFormAlerte.Afficher("Sending error|30066", EFormAlerteType.Erreur);
}
}
}
protected CResultAErreur CanOpenSessionUserADMAC(CSessionClient session)
{
CResultAErreur result = CResultAErreur.True;
try
{
CAuthentificationSessionUserADMAC auth = (CAuthentificationSessionUserADMAC)session.Authentification;
string[] strNoms = auth.UserId.Split('/');
string strNom;
if (strNoms.Length < 1)
{
result.EmpileErreur(I.T("Unauthorised Windows user name|5"));
}
else
{
strNom = strNoms[strNoms.Length - 1];
using (CContexteDonnee contexte = new CContexteDonnee(m_session.IdSession, true, false))
{
CDonneesActeurUtilisateur donnees = new CDonneesActeurUtilisateur(contexte);
if (donnees.ReadIfExists(new CFiltreData(CDonneesActeurUtilisateur.c_champNomWindows + "=@1", strNom)))
{
return(InitialiserSessionCliente(session, donnees));
}
else
{
result.EmpileErreur(I.T("Invalid user name|6"));
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(I.T("Login error |4"));
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------
public static CDonneesActeurUtilisateur GetUserForSession(int nIdSession, CContexteDonnee contexte)
{
try
{
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
if (session == null)
{
return(null);
}
//TESTDBKEYOK
CDbKey keyUtilisateur = session.GetInfoUtilisateur().KeyUtilisateur;
CDonneesActeurUtilisateur user = new CDonneesActeurUtilisateur(contexte);
if (!user.ReadIfExists(keyUtilisateur))
{
return(null);
}
return(user);
}
catch
{
}
return(null);
}
//------------------------------------------------------------------------
private static bool IsTransactionTerminee(int nIdSession)
{
//S'assure que la transaction est terminée pour cette session
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
IDatabaseConnexion cnx = null;
if (session != null && session.IsConnected)
{
try
{
cnx = CSc2iDataServer.GetInstance().GetDatabaseConnexion(nIdSession, 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;
}
}
else
{
cnx = null;
}
return(cnx == null || !cnx.IsInTrans());
}
protected CResultAErreur CanOpenSessionSousSession(CSessionClient session)
{
CResultAErreur result = CResultAErreur.True;
try
{
CAuthentificationSessionSousSession auth = (CAuthentificationSessionSousSession)session.Authentification;
CSessionClient sessionMain = GetSessionClient(auth.IdSessionPrincipale);
if (sessionMain == null)
{
result.EmpileErreur(I.T("The master session doesn't exist|16"));
return(result);
}
//Effectue un appel pour provoquer une exception en cas d'erreursessionMain.IdSession;
int nDummy = sessionMain.IdSession;
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error while accessing the master session|17"));
}
return(result);
}
/// ///////////////////////////////////////////////////
private void CreateControles(Crownwood.Magic.Controls.TabPage page)
{
if (m_tableCreateurs[page] != null || ElementEdite == null)
{
return;
}
C2iWnd wnd = m_tablePageTo2iWnd[page];
Panel panel = new Panel();
panel.BackColor = wnd.BackColor;
panel.ForeColor = wnd.ForeColor;
panel.Font = wnd.Font;
panel.Location = new Point(0, 0);
panel.Size = wnd.Size;
panel.AutoScroll = true;
page.Controls.Add(panel);
panel.SuspendLayout();
CCreateur2iFormulaire createur;
IObjetDonneeAIdNumeriqueAuto objetDonnee = ElementEdite as IObjetDonneeAIdNumeriqueAuto;
if (objetDonnee != null)
{
createur = new CCreateur2iFormulaire(objetDonnee.ContexteDonnee.IdSession, ElementEdite, page);
}
else
{
createur = new CCreateur2iFormulaire(CSessionClient.GetSessionUnique().IdSession, ElementEdite, page);
}
createur.CreateChilds(panel, wnd, m_champTooltip);
panel.ResumeLayout();
panel.Size = page.ClientSize;
m_tableCreateurs[page] = createur;
page.ResumeLayout();
panel.Dock = DockStyle.Fill;
}
/// ///////////////////////////////////////////////////
#region OLD
protected CResultAErreur CanOpenSessionLoginPasswordMAC(CSessionClient session)
{
CResultAErreur result = CResultAErreur.True;
try
{
CAuthentificationSessionLoginPasswordMAC auth = (CAuthentificationSessionLoginPasswordMAC)session.Authentification;
if (auth.Login.Trim() == "" || auth.Password.Trim() == "")
{
result.EmpileErreur(I.T("Invalid user name or password |3"));
}
else
{
using (CContexteDonnee contexte = new CContexteDonnee(m_session.IdSession, true, false))
{
string strPassCrypte = C2iCrypto.Crypte(auth.Password);
CDonneesActeurUtilisateur donnees = new CDonneesActeurUtilisateur(contexte);
if (donnees.ReadIfExists(new CFiltreData(CDonneesActeurUtilisateur.c_champLogin + "=@1 and " +
CDonneesActeurUtilisateur.c_champPassword + "=@2",
auth.Login, strPassCrypte)) && donnees.VerifiePassword(auth.Password))
{
return(InitialiserSessionCliente(session, donnees));
}
else
{
result.EmpileErreur(I.T("Invalid user name or password |3"));
}
}
}
}
catch (Exception e)
{
result.EmpileErreur(I.T("Login error |4"));
result.EmpileErreur(new CErreurException(e));
}
return(result);
}
//-------------------------------------------------------------------------
private void m_lnkTester_LinkClicked(object sender, System.Windows.Forms.LinkLabelLinkClickedEventArgs e)
{
CResultAErreur result = CResultAErreur.True;
//Débute une transaction pour tester dans le vide !!!
CSessionClient session = CTimosApp.SessionClient;
result = session.BeginTrans();
if (result)
{
try
{
CInfoDeclencheurProcess info = new CInfoDeclencheurProcess(TypeEvenement.Manuel);
result = CProcessEnExecutionInDb.StartProcess(
Process.Process,
info,
CTimosApp.SessionClient.IdSession,
Process.ContexteDonnee.IdVersionDeTravail,
null);
}
catch (Exception ep)
{
result.EmpileErreur(new CErreurException(ep));
}
finally
{
session.RollbackTrans();
}
}
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
}
else
{
CFormAlerte.Afficher(I.T("Execution successful|30226"));
}
}