Gestion des droits d'utilisateur

Signaler
Messages postés
15
Date d'inscription
samedi 22 janvier 2011
Statut
Membre
Dernière intervention
7 octobre 2013
-
Messages postés
6414
Date d'inscription
mardi 8 mars 2005
Statut
Modérateur
Dernière intervention
29 juillet 2020
-
Bonjour,
s'ils vous plait vous avez un code de gestion des droits des utilisateurs avec les servlet et les jsp

5 réponses

Messages postés
29268
Date d'inscription
mercredi 22 octobre 2003
Statut
Modérateur
Dernière intervention
15 août 2020
335
Bonjour,

Je ne suis pas sûr que vous obtiendrez beaucoup de réponse pour ce genre de questions.
En règle générale (comme indiqué dans le règlement du site : CHARTE DU SITE ) nous ne fournissons pas de code tout prêt (sauf dans la section codes_sources.





Messages postés
6414
Date d'inscription
mardi 8 mars 2005
Statut
Modérateur
Dernière intervention
29 juillet 2020
296
Salut,

Je suis d'accord avec jordane45, mais si tu nous explique comment tu veux gérer les droits de tes utilisateurs, et ce que tu cherches à faire précisément, nous pourrons t'aiguiller.

En revanche, le code, tu t'en chargeras.
Messages postés
15
Date d'inscription
samedi 22 janvier 2011
Statut
Membre
Dernière intervention
7 octobre 2013

merci pour vos réponses,

beh voilà moi j'ai voulu faire la gestion des utilisateur en utilisant des filtres et en suivant le model MVC1 je vous envoie aussi le code mais je ne sais pas si c'est correcte dans tous les cas ça marche pas pour moi
package com.cdg.beans;

import java.io.Serializable;
import java.sql.Timestamp;

public class Utilisateur implements Serializable {
 
    private Long      idUtilisateur;
    private String    nomUtilisateur;
    private String    prenomUtilisateur;
    private String    email;
    private String    telephone;
    private String    login;
    private String    motDePasse;
    private String    profil;
    private Timestamp dateInscription;
    
    
 public Long getIdUtilisateur() {
  return idUtilisateur;
 }
 public void setIdUtilisateur(Long idUtilisateur) {
  this.idUtilisateur = idUtilisateur;
 }
 public String getNomUtilisateur() {
  return nomUtilisateur;
 }
 public void setNomUtilisateur(String nomUtilisateur) {
  this.nomUtilisateur = nomUtilisateur;
 }
 public String getPrenomUtilisateur() {
  return prenomUtilisateur;
 }
 public void setPrenomUtilisateur(String prenomUtilisateur) {
  this.prenomUtilisateur = prenomUtilisateur;
 }
 public String getEmail() {
  return email;
 }
 public void setEmail(String email) {
  this.email = email;
 }
 public String getTelephone() {
  return telephone;
 }
 public void setTelephone(String telephone) {
  this.telephone = telephone;
 }
 public String getLogin() {
  return login;
 }
 public void setLogin(String login) {
  this.login = login;
 }
 public String getMotDePasse() {
  return motDePasse;
 }
 public void setMotDePasse(String motDePasse) {
  this.motDePasse = motDePasse;
 }
 public String getProfil() {
  return profil;
 }
 public void setProfil(String profil) {
  this.profil = profil;
 }
 public Timestamp getDateInscription() {
  return dateInscription;
 }
 public void setDateInscription(Timestamp dateInscription) {
  this.dateInscription = dateInscription;
 }
 
}

ce code c'est le bean
et le code suivant c'est le dao
package com.cdg.dao;

import static com.cdg.dao.DAOUtilitaire.fermeturesSilencieuses;
import static com.cdg.dao.DAOUtilitaire.initialisationRequetePreparee;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.cdg.beans.Utilisateur;

public class UtilisateurDaoImpl implements UtilisateurDao {

    private static final String SQL_SELECT_PAR_EMAIL_MDP = "SELECT idUtilisateur,nomUtilisateur,prenomUtilisateur,email,telephone,login,motDePasse,profil,dateInscription FROM Utilisateur WHERE email = ? AND motDePasse=? ";
    private static final String SQL_SELECT_PAR_EMAIL = "SELECT idUtilisateur,nomUtilisateur,prenomUtilisateur,email,telephone,login,motDePasse,profil,dateInscription FROM Utilisateur WHERE email = ? ";
    private static final String SQL_INSERT           = "INSERT INTO Utilisateur (nomUtilisateur,prenomUtilisateur,email,telephone,login,motDePasse,profil,dateInscription) VALUES (?, ?, ?, ?, ?, ?, ?, NOW())";
    
    private static final String SQL_SELECT        = "SELECT idUtilisateur,nomUtilisateur,prenomUtilisateur,email,telephone,login,motDePasse,profil,dateInscription FROM Utilisateur ORDER BY idUtilisateur";
    private static final String SQL_SELECT_PAR_ID = "SELECT idUtilisateur,nomUtilisateur,prenomUtilisateur,email,telephone,login,motDePasse,profil,dateInscription   FROM Utilisateur WHERE idUtilisateur = ?";
    private static final String SQL_DELETE_PAR_ID = "DELETE FROM Utilisateur WHERE idUtilisateur = ?";
    
    private static final String SQL_SELECT_PAR_PROFIL = "SELECT profil FROM utilisateur where email like ?";


    private DAOFactory          daoFactory;

    UtilisateurDaoImpl( DAOFactory daoFactory ) {
        this.daoFactory = daoFactory;
    }
    
    /* Implémentation de la méthode définie dans l'interface UtilisateurDao */
    @Override
    public String trouver_profil( String email) throws DAOException {
     Connection connexion = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String profil=null;
     
        try {
            /* Récupération d'une connexion depuis la Factory */
            connexion = daoFactory.getConnection();
            preparedStatement = initialisationRequetePreparee( connexion, SQL_SELECT_PAR_PROFIL, false, email);
            resultSet = preparedStatement.executeQuery();
            while(resultSet.next()){
            profil=resultSet.getString("profil");
            }
            /* Parcours de la ligne de données de l'éventuel ResulSet retourné */
           
        } catch ( SQLException e ) {
            throw new DAOException( e );
        } finally {
            fermeturesSilencieuses( resultSet, preparedStatement, connexion );
        }
     return profil;     
     //   return utilisateur;
    }

    /* Implémentation de la méthode définie dans l'interface UtilisateurDao */
    @Override
    public Utilisateur trouver( String email ,String motDePasse) throws DAOException {
     Connection connexion = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        Utilisateur utilisateur = null;
     
        try {
            /* Récupération d'une connexion depuis la Factory */
            connexion = daoFactory.getConnection();
            preparedStatement = initialisationRequetePreparee( connexion, SQL_SELECT_PAR_EMAIL_MDP, false, email, motDePasse );
            resultSet = preparedStatement.executeQuery();
            /* Parcours de la ligne de données de l'éventuel ResulSet retourné */
            if ( resultSet.next() ) {
                utilisateur = map( resultSet );
            }
        } catch ( SQLException e ) {
            throw new DAOException( e );
        } finally {
            fermeturesSilencieuses( resultSet, preparedStatement, connexion );
        }
     
        return utilisateur;
    }//hadi ça marche mais string email
    
    
    @Override
 public Utilisateur trouver(String email) throws DAOException {
     Connection connexion = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        Utilisateur utilisateur = null;
     
        try {
            /* Récupération d'une connexion depuis la Factory */
            connexion = daoFactory.getConnection();
            preparedStatement = initialisationRequetePreparee( connexion, SQL_SELECT_PAR_EMAIL, false, email );
            resultSet = preparedStatement.executeQuery();
            /* Parcours de la ligne de données de l'éventuel ResulSet retourné */
            if ( resultSet.next() ) {
                utilisateur = map( resultSet );
            }
        } catch ( SQLException e ) {
            throw new DAOException( e );
        } finally {
            fermeturesSilencieuses( resultSet, preparedStatement, connexion );
        }
     
        return utilisateur;
    }//hadi ça marche mais string email
    
    /* Implémentation de la méthode définie dans l'interface UtilisateurDao */
    @Override
    public void creer( Utilisateur utilisateur ) throws DAOException {
        Connection connexion = null;
        PreparedStatement preparedStatement = null;
        ResultSet valeursAutoGenerees = null;

        try {
            connexion = daoFactory.getConnection();
            preparedStatement = initialisationRequetePreparee( connexion, SQL_INSERT, true,utilisateur.getNomUtilisateur(),utilisateur.getPrenomUtilisateur(), utilisateur.getEmail(),utilisateur.getTelephone(),utilisateur.getLogin(), utilisateur.getMotDePasse(), utilisateur.getProfil() );
            int statut = preparedStatement.executeUpdate();
            if ( statut == 0 ) {
                throw new DAOException( "échec de la création de l'utilisateur, aucune ligne ajoutée dans la table." );
            }
            valeursAutoGenerees = preparedStatement.getGeneratedKeys();
            if ( valeursAutoGenerees.next() ) {
                utilisateur.setIdUtilisateur( valeursAutoGenerees.getLong( 1 ) );
            } else {
                throw new DAOException( "échec de la création de l'utilisateur en base, aucun ID auto-généré retourné." );
            }
        } catch ( SQLException e ) {
            throw new DAOException( e );
        } finally {
            fermeturesSilencieuses( valeursAutoGenerees, preparedStatement, connexion );
        }
    }

    /*
     * Méthode générique utilisée pour retourner un utilisateur depuis la base
     * de données, correspondant à la requête SQL donnée prenant en paramètres
     * les objets passés en argument.
     */
    private Utilisateur trouver( String sql, Object... objets ) throws DAOException {
        Connection connexion = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        Utilisateur utilisateur = null;

        try {
            /* Récupération d'une connexion depuis la Factory */
            connexion = daoFactory.getConnection();
            /*
             * Préparation de la requête avec les objets passés en arguments
             * (ici, uniquement une adresse email) et exécution.
             */
            preparedStatement = initialisationRequetePreparee( connexion, sql, false, objets );
            resultSet = preparedStatement.executeQuery();
            /* Parcours de la ligne de données retournée dans le ResultSet */
            if ( resultSet.next() ) {
                utilisateur = map( resultSet );
            }
        } catch ( SQLException e ) {
            throw new DAOException( e );
        } finally {
            fermeturesSilencieuses( resultSet, preparedStatement, connexion );
        }

        return utilisateur;
    }

    /*
     * Simple méthode utilitaire permettant de faire la correspondance (le
     * mapping) entre une ligne issue de la table des utilisateurs (un
     * ResultSet) et un bean Utilisateur.
     */
    private static Utilisateur map( ResultSet resultSet ) throws SQLException {
        Utilisateur utilisateur = new Utilisateur();
        utilisateur.setIdUtilisateur( resultSet.getLong( "idUtilisateur" ) );
        utilisateur.setNomUtilisateur( resultSet.getString( "nomUtilisateur" ) );
        utilisateur.setPrenomUtilisateur( resultSet.getString( "prenomUtilisateur" ) );
        utilisateur.setEmail( resultSet.getString( "email" ) );
        utilisateur.setTelephone( resultSet.getString( "telephone" ) );
        utilisateur.setLogin( resultSet.getString( "login" ) );
        utilisateur.setMotDePasse( resultSet.getString( "motDePasse" ) );
        utilisateur.setProfil( resultSet.getString( "profil" ) );
        utilisateur.setDateInscription( resultSet.getTimestamp( "dateInscription" ) );
        return utilisateur;
    }

 @Override
 public Utilisateur trouver(long id) throws DAOException {
  return trouver( SQL_SELECT_PAR_ID, id );
 }

 @Override
 public List<Utilisateur> lister() throws DAOException {
  Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        List<Utilisateur> clients = new ArrayList<Utilisateur>();
 
        try {
            connection = daoFactory.getConnection();
            preparedStatement = connection.prepareStatement( SQL_SELECT );
            resultSet = preparedStatement.executeQuery();
            while ( resultSet.next() ) {
                clients.add( map( resultSet ) );
            }
        } catch ( SQLException e ) {
            throw new DAOException( e );
        } finally {
            fermeturesSilencieuses( resultSet, preparedStatement, connection );
        }
 
        return clients;
 }

 @Override
 public void supprimer(Utilisateur utilisateur) throws DAOException {
  Connection connexion = null;
        PreparedStatement preparedStatement = null;
 
        try {
            connexion = daoFactory.getConnection();
            preparedStatement = initialisationRequetePreparee( connexion, SQL_DELETE_PAR_ID, true, utilisateur.getIdUtilisateur() );
            int statut = preparedStatement.executeUpdate();
            if ( statut == 0 ) {
                throw new DAOException( "Échec de la suppression de l'utilisateur, aucune ligne supprimée de la table." );
            } else {
             utilisateur.setIdUtilisateur( null );
            }
        } catch ( SQLException e ) {
            throw new DAOException( e );
        } finally {
            fermeturesSilencieuses( preparedStatement, connexion );
        }
  
 }


}

et les code suivant c'est les filtres et connexionForm et la servlet connexion
package com.cdg.filters;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import com.cdg.beans.Utilisateur;
import com.cdg.dao.UtilisateurDao;
import com.cdg.forms.ConnexionForm;
 
public class RestrictionFilter implements Filter {
    public static final String ACCES_CONNEXION  ="/connexion";
    //public static final String ACCES_CONNEXION_ADMIN  = "/espaceAdmin/Bienvenue.jsp";
    public static final String ATT_SESSION_USER = "sessionUtilisateur";
    //private static final String SQL_SELECT_PAR_PROFIL = "SELECT profil FROM Utilisateur where email like 'lola@cdg.ma'";

 
    public void init( FilterConfig config ) throws ServletException {
    }
 
    public void doFilter( ServletRequest req, ServletResponse res, FilterChain chain) throws IOException,
            ServletException {
        /* Cast des objets request et response */
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;
     
  
 
        /* Non-filtrage des ressources statiques */
        String chemin = request.getRequestURI().substring( request.getContextPath().length() );
        if ( chemin.startsWith( "/inc" ) ) {
            chain.doFilter( request, response );
            return;
        }
 
        /* R?cup?ration de la session depuis la requ?te */
        HttpSession session = request.getSession();
 
        /**
         * Si l'objet utilisateur n'existe pas dans la session en cours, alors
         * l'utilisateur n'est pas connect?.
         */
        if ( session.getAttribute( ATT_SESSION_USER ) == null ) {
            /* Redirection vers la page publique */
            request.getRequestDispatcher( ACCES_CONNEXION ).forward( request, response );
        } else {
            /* Affichage de la page restreinte */
            chain.doFilter( request, response );
        }
        
    }
<code>package com.cdg.servlets;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.joda.time.*;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;
import org.joda.time.format.PeriodFormatter;
import org.joda.time.format.PeriodFormatterBuilder;

import com.cdg.beans.Utilisateur;
import com.cdg.dao.DAOFactory;
import com.cdg.dao.UtilisateurDao;
import com.cdg.forms.ConnexionForm;

public class Connexion extends HttpServlet {
 public static final String CONF_DAO_FACTORY = "daofactory";
 public static final String ATT_USER = "utilisateur";
 public static final String ATT_FORM = "form";
 public static final String ATT_INTERVALLE_CONNEXIONS = "intervalleConnexions";
 public static final String ATT_SESSION_USER = "sessionUtilisateur";
 public static final String COOKIE_DERNIERE_CONNEXION = "derniereConnexion";
 public static final String FORMAT_DATE = "dd/MM/yyyy HH:mm:ss";
 public static final String VUE = "/WEB-INF/connexion.jsp";
 //public static final String VUE_SUCCES= "/espaceAdmin/Bienvenue.jsp";
 public static final String VUE_SUCCES_ADMIN = "/espaceAdmin/Bienvenue.jsp";
 public static final String VUE_SUCCES_USER = "/espaceGestion/toto.jsp";

 public static final String CHAMP_MEMOIRE = "memoire";
 public static final int COOKIE_MAX_AGE = 60 * 60 * 24 * 365; // 1 an
 String choix="administrateur";
 String choix2="user";

 private UtilisateurDao utilisateurDao;

 public void init() throws ServletException {
  /* Récupération d'une instance de notre DAO Utilisateur */
  this.utilisateurDao = ((DAOFactory) getServletContext().getAttribute(
    CONF_DAO_FACTORY)).getUtilisateurDao();
 }

 public void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  /* Tentative de récupération du cookie depuis la requête */
  String derniereConnexion = getCookieValue(request,
    COOKIE_DERNIERE_CONNEXION);
  /* Si le cookie existe, alors calcul de la durée */
  if (derniereConnexion != null) {
   /* Récupération de la date courante */
   DateTime dtCourante = new DateTime();
   /* Récupération de la date présente dans le cookie */
   DateTimeFormatter formatter = DateTimeFormat
     .forPattern(FORMAT_DATE);
   DateTime dtDerniereConnexion = formatter
     .parseDateTime(derniereConnexion);
   /* Calcul de la durée de l'intervalle */
   Period periode = new Period(dtDerniereConnexion, dtCourante);
   /* Formatage de la durée de l'intervalle */
   PeriodFormatter periodFormatter = new PeriodFormatterBuilder()
     .appendYears().appendSuffix(" an ", " ans ").appendMonths()
     .appendSuffix(" mois ").appendDays()
     .appendSuffix(" jour ", " jours ").appendHours()
     .appendSuffix(" heure ", " heures ").appendMinutes()
     .appendSuffix(" minute ", " minutes ")
     .appendSeparator("et ").appendSeconds()
     .appendSuffix(" seconde", " secondes").toFormatter();
   String intervalleConnexions = periodFormatter.print(periode);
   /* Ajout de l'intervalle en tant qu'attribut de la requête */
   request.setAttribute(ATT_INTERVALLE_CONNEXIONS,
     intervalleConnexions);
  }
  /* Affichage de la page de connexion */
  this.getServletContext().getRequestDispatcher(VUE)
    .forward(request, response);
 }

 public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  /* Préparation de l'objet formulaire */
  ConnexionForm form = new ConnexionForm(utilisateurDao);
  /* Traitement de la requête et récupération du bean en résultant */
  Utilisateur utilisateur = form.connecterUtilisateur(request);

  /* Récupération de la session depuis la requête */
  HttpSession session = request.getSession();

  /*
   * Si aucune erreur de validation n'a eu lieu, alors ajout du bean
   * Utilisateur à la session, sinon suppression du bean de la session.
   */
  if ((utilisateur != null) && form.getErreurs().isEmpty()) {
   
   if (utilisateur.getProfil().equals(choix)) {
   session.setAttribute(ATT_SESSION_USER, utilisateur);
   /* Affichage de la fiche récapitulative */
     this.getServletContext().getRequestDispatcher(VUE_SUCCES_ADMIN)
     .forward(request, response);
   }
   else if (utilisateur.getProfil().equals(choix2)){
    
    this.getServletContext().getRequestDispatcher(VUE_SUCCES_USER)
    .forward(request, response);
    
   }
  } 
   else {
   session.setAttribute(ATT_SESSION_USER, null);
   /* Sinon, ré-affichage du formulaire de création avec les erreurs */
   this.getServletContext().getRequestDispatcher(VUE)
     .forward(request, response);
  }

  
  /*if (request.getParameter("jsp").equals("ajref")) 
   request.getRequestDispatcher("ajref.jsp").forward(request, response); 

   else if(request.getParameter("jsp").equals("ajproj")) 
   request.getRequestDispatcher("ajproj.jsp").forward(request, response);*/  

  /* Si et seulement si la case du formulaire est cochée */
  if (request.getParameter(CHAMP_MEMOIRE) != null) {
   /* Récupération de la date courante */
   DateTime dt = new DateTime();
   /* Formatage de la date et conversion en texte */
   DateTimeFormatter formatter = DateTimeFormat
     .forPattern(FORMAT_DATE);
   String dateDerniereConnexion = dt.toString(formatter);
   /* Création du cookie, et ajout à la réponse HTTP */
   setCookie(response, COOKIE_DERNIERE_CONNEXION,
     dateDerniereConnexion, COOKIE_MAX_AGE);
  } else {
   /* Demande de suppression du cookie du navigateur */
   setCookie(response, COOKIE_DERNIERE_CONNEXION, "", 0);
  }

  /* Stockage du formulaire et du bean dans l'objet request */
  request.setAttribute(ATT_FORM, form);
  request.setAttribute(ATT_USER, utilisateur);

  // this.getServletContext().getRequestDispatcher(VUE)
  // .forward(request, response);
 }

 /*
  * Méthode utilitaire gérant la création d'un cookie et son ajout à la
  * réponse HTTP.
  */
 private static void setCookie(HttpServletResponse response, String nom,
   String valeur, int maxAge) {
  Cookie cookie = new Cookie(nom, valeur);
  cookie.setMaxAge(maxAge);
  response.addCookie(cookie);
 }

 /**
  * Méthode utilitaire gérant la récupération de la valeur d'un cookie donné
  * depuis la requête HTTP.
  */
 private static String getCookieValue(HttpServletRequest request, String nom) {
  Cookie[] cookies = request.getCookies();
  if (cookies != null) {
   for (Cookie cookie : cookies) {
    if (cookie != null && nom.equals(cookie.getName())) {
     return cookie.getValue();
    }
   }
  }
  return null;
 }
}




package com.cdg.filters;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import com.cdg.beans.Utilisateur;
import com.cdg.dao.UtilisateurDao;
import com.cdg.forms.ConnexionForm;
 
public class RestrictionFilter1 implements Filter {
    public static final String ACCES_CONNEXION  ="/connexion";
    //public static final String ACCES_CONNEXION_ADMIN  = "/espaceAdmin/Bienvenue.jsp";
    public static final String ATT_SESSION_USER = "sessionUtilisateur";
    //private static final String SQL_SELECT_PAR_PROFIL = "SELECT profil FROM Utilisateur where email like 'lola@cdg.ma'";

 
    public void init( FilterConfig config ) throws ServletException {
    }
 
    public void doFilter( ServletRequest req, ServletResponse res, FilterChain chain) throws IOException,
            ServletException {
        /* Cast des objets request et response */
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;
     
  
 
        /* Non-filtrage des ressources statiques */
        String chemin = request.getRequestURI().substring( request.getContextPath().length() );
        if ( chemin.startsWith( "/inc" ) ) {
            chain.doFilter( request, response );
            return;
        }
 
        /* R?cup?ration de la session depuis la requ?te */
        HttpSession session = request.getSession();
 
        /**
         * Si l'objet utilisateur n'existe pas dans la session en cours, alors
         * l'utilisateur n'est pas connect?.
         */
        if ( session.getAttribute( ATT_SESSION_USER ) == null ) {
            /* Redirection vers la page publique */
            request.getRequestDispatcher( ACCES_CONNEXION ).forward( request, response );
        } else {
            /* Affichage de la page restreinte */
            chain.doFilter( request, response );
        }
        
    }
    
    
 
    public void destroy() {
    }
}



package com.cdg.forms;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import com.cdg.beans.Utilisateur;
import com.cdg.dao.DAOException;
import com.cdg.dao.UtilisateurDao;
import com.cdg.filters.RestrictionFilter;
import com.cdg.filters.RestrictionFilter1;

public final class ConnexionForm {
 private static final String CHAMP_EMAIL = "email";
 private static final String CHAMP_PASS = "motdepasse";
 private static final String CHAMP_PROFIL = "profil";

 private String resultat;
 private Map<String, String> erreurs = new HashMap<String, String>();
 private UtilisateurDao utilisateurDao;
 
 Utilisateur utilisateur;

 public ConnexionForm(UtilisateurDao utilisateurDao) {
  this.utilisateurDao = utilisateurDao;
 }

 public String getResultat() {
  return resultat;
 }

 public Map<String, String> getErreurs() {
  return erreurs;
 }

 public Utilisateur connecterUtilisateur(HttpServletRequest request) {
  /* Récupération des champs du formulaire */
  String email = getValeurChamp(request, CHAMP_EMAIL);
  String motDePasse = getValeurChamp(request, CHAMP_PASS);
  String profil = getValeurChamp(request, CHAMP_PROFIL);
  
  utilisateur.setProfil( profil);
        //System.out.println(email);
  Utilisateur utilisateur = new Utilisateur();
  try {
   traiterEmail(email, utilisateur);
   traiterMotDePasse(motDePasse, utilisateur);
   traiterProfil(profil, utilisateur);

   /* Initialisation du résultat global de la validation. */
   if (erreurs.isEmpty() && utilisateurDao.trouver(email, motDePasse) != null) {
    /*profil=*/utilisateurDao.trouver_profil( email );
    System.out.println(profil);
    String choix="administrateur";
    String choix2="user";
    if(choix.equals(profil)){
     RestrictionFilter rf=new RestrictionFilter();
     
    }
    
    else if(choix2.equals(profil)){
     RestrictionFilter1 rf1=new RestrictionFilter1();
    }
    resultat = "Succés de la connexion.";
   } else {
    resultat = "échec de la connexion.";
    utilisateur=null;
   }
  } catch (DAOException e) {
   resultat = "echec de la connexion : une erreur imprevue est survenue, merci de réessayer dans quelques instants.";
   e.printStackTrace();
  }

  return utilisateur;
 }

 /*
  * Appel à la validation de l'adresse email reçue et initialisation de la
  * propriété email du bean
  */
 private void traiterEmail(String email, Utilisateur utilisateur) {
  try {
   validationEmail(email);
  } catch (FormValidationException e) {
   setErreur(CHAMP_EMAIL, e.getMessage());
  }
  utilisateur.setEmail(email);
 }

 /*
  * Appel à la validation de mot de passe reçue et initialisation de la
  * proprieté email du bean
  */
 private void traiterMotDePasse(String motDePasse, Utilisateur utilisateur) {
  try {
   validationMotDePasse(motDePasse);
  } catch (FormValidationException e) {
   setErreur(CHAMP_PASS, e.getMessage());
  }
  utilisateur.setMotDePasse(motDePasse);
 }
 
 /*
  * Appel à la validation de l'adresse email reçue et initialisation de la
  * propriété email du bean
  */
 private void traiterProfil(String profil, Utilisateur utilisateur) {
  try {
   validationProfil(profil);
  } catch (FormValidationException e) {
   setErreur(CHAMP_PROFIL, e.getMessage());
  }
  utilisateur.setProfil(profil);
 }

 /* Validation de l'adresse email */
 private void validationEmail(String email) throws FormValidationException {
  if (email != null
    && !email.matches("([^.@]+)(\.[^.@]+)*@([^.@]+\.)+([^.@]+)")) {
   throw new FormValidationException(
     "Merci de saisir une adresse mail valide.");
  }
 }

 /* Validation des mots de passe */
 private void validationMotDePasse(String motDePasse)
   throws FormValidationException {
  if (motDePasse != null) {
   if (motDePasse.length() < 3) {
    throw new FormValidationException(
      "Les mots de passe doivent contenir au moins 3 caractères.");
   }
  } else {
   throw new FormValidationException(
     "Merci de saisir et confirmer votre mot de passe.");
  }
 }
 
 /* Validation du nom d'utulisateur */
    private void validationProfil( String profil ) throws FormValidationException {
        if ( profil != null && profil.length() < 3 ) {
            throw new FormValidationException( "Le profil d'utilisateur doit contenir au moins 3 caractéres." );
        }
    }

 /*
  * Ajoute un message correspondant au champ sp?cifi? ? la map des erreurs.
  */
 private void setErreur(String champ, String message) {
  erreurs.put(champ, message);
 }

 /*
  * M?thode utilitaire qui retourne null si un champ est vide, et son contenu
  * sinon.
  */
 private static String getValeurChamp(HttpServletRequest request,
   String nomChamp) {
  String valeur = request.getParameter(nomChamp);
  if (valeur == null || valeur.trim().length() == 0) {
   return null;
  } else {
   return valeur;
  }
 }
}
Messages postés
15
Date d'inscription
samedi 22 janvier 2011
Statut
Membre
Dernière intervention
7 octobre 2013

c'est très long mais seulement pour vous pouvez savoir ce que j'ai mis exactement

--
Messages postés
6414
Date d'inscription
mardi 8 mars 2005
Statut
Modérateur
Dernière intervention
29 juillet 2020
296
On ne va pas lire ni exécuter ton code, si tu n'arrives pas à formuler de manière claire et précise ce qui te poses problème, tu n'obtiendras pas de réponse !