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