/////////////////////***********////////React***************////////////////////

- Les composants de connexion et d'enregistrement ont un formulaire pour

la soumission de données (avec prise en charge de la bibliothèque de validation de
réaction).
Ils appellent les méthodes de auth.service pour effectuer une demande de
connexion/enregistrement.

– Les méthodes auth.service utilisent axios pour effectuer des requêtes HTTP.
Il stocke ou récupère également JWT à partir du stockage local du navigateur dans
ces méthodes.

– Le composant d'accueil est public pour tous les visiteurs.

– Le composant de profil affiche les informations de l'utilisateur une fois

l'action de connexion réussie.

– Les composants BoardUser, BoardModerator, BoardAdmin seront affichés par état

user.roles.
Dans ces composants, nous utilisons user.service pour accéder aux ressources
protégées à partir de l'API Web.

– user.service utilise la fonction d'assistance auth-header() pour ajouter JWT à

l'en-tête HTTP.
auth-header() renvoie un objet contenant le JWT de l'utilisateur actuellement
connecté à partir du stockage local.
/////////////////********************************///////////
spring********************///////////
Le référentiel contient UserRepository & RoleRepository pour travailler avec la
base de données,
et il sera importé dans Controller.
Le contrôleur reçoit et traite la demande après qu'elle a été filtrée par
OncePerRequestFilter.
- AuthController gère les demandes d'abonnement/de connexion

- TestController a accès à des méthodes de ressources protégées à l'aide de

validations de rôle.

-AuthenticationEntryPoint détectera une erreur non autorisée et renverra un 401

lorsque les clients
accèdent à des ressources protégées sans authentification.
-OncePerRequestFilter effectue une seule exécution pour chaque requête adressée à
notre API.
Il fournit une méthode doFilterInternal() que nous allons implémenter pour
analyser et valider JWT,
charger les détails de l'utilisateur (à l'aide de UserDetailsService),
vérifier l'autorisation (à l'aide de UsernamePasswordAuthenticationToken).
--AuthenticationManager a un DaoAuthenticationProvider
(avec l'aide de UserDetailsService & PasswordEncoder) pour valider l'objet
UsernamePasswordAuthenticationToken.
En cas de succès, AuthenticationManager renvoie un objet
Authentication entièrement rempli (y compris les autorités accordées).
***WebSecurityConfigurerAdapter :

***UserDetailsService:
L'interface a une méthode pour charger l'utilisateur par nom d'utilisateur
et renvoie un objet UserDetails que Spring Security peut utiliser pour
l'authentification et la validation.

***UserDetails:ontient les informations nécessaires

 (telles que : nom d'utilisateur, mot de passe, autorités)
pour créer un objet d'authentification.

* UsernamePasswordAuthenticationToken:obtient {nom d'utilisateur, mot de passe}

à partir de la demande de connexion, AuthenticationManager
l'utilisera pour authentifier un compte de connexion.

////////////////
*********************************************//////////////////////////////////////
/////////////

import React, { Component } from 'react';

import './App.css';
import { Switch, Route, Link } from "react-router-dom";
import ListPersonneComponents from './components/ListPersonneComponents';
import CreatePersonne from './components/CreatePersonne';
import UpdatePersonne from './components/UpdatePersonne';
import viewPersonneComponent from './components/viewPersonneComponent';
import FooterComponents from './components/FooterComponents';
import HomeComponents from './components/HomeComponents';
import Register from './components/Register';
import RegisterService from './Services/RegisterService';

class App extends Component {

constructor(props) {
super(props);
this.logOut = this.logOut.bind(this);
this.state = {
showModeratorBoard: false,
showAdminBoard: false,
currentUser: undefined,
};

}
componentDidMount() {
const user = RegisterService.getCurrentUser();
if (user) {
this.setState({
currentUser: RegisterService.getCurrentUser(),
showModeratorBoard: user.roles.includes("ROLE_MODERATOR"),
showAdminBoard: user.roles.includes("ROLE_ADMIN")
});
}
}
logOut() {
RegisterService.logout();
this.setState({
showModeratorBoard: false,
showAdminBoard: false,
currentUser: undefined,
});
}
render() {
const { currentUser, showModeratorBoard, showAdminBoard } = this.state;
return (
<Router>
<div>
<nav className='navbar navbar-expand navbar-dark bg-dark'>
<link to={"/"} className="navbar-brand">
EspaceRecrutement </link>

<div className='navbar navbar-expand navbar-dark bg-dark'>

<li className='nav-item'>
<link to={"/home"} className="nav-link">
home </link>
</li>
{showModeratorBoard && (
<li className='nav-item'>
<link to={"/mod"} className="nav-link">
moderator </link>
</li>)}

{showAdminBoard && (
<li className='nav-item'>
<link to={"/admin"} className="nav-link">
admin </link>
</li>)}
{currentUser && (

<li className='nav-item'>
<link to={"/user"} className="nav-link">
User </link>
</li>
)}
</div>
{currentUser ? (
<div className='navbar-nav ml-auto'>
<li className='nav-item'>
<link to={"/profile"} className="nav-link">
{currentUser.login
} </link>
</li>
<li className='nav-item'>
<link to={"/login"} className="nav-link" onClick={this.logOut}>
logOut </link>
</li>
</div>
) : (
<div className='navbar-nav ml-auto'>
<li className='nav-item'>
<link to={"/login"} className="nav-link">

</link>
</li>
<li className='nav-item'>
<link to={"/register"} className="nav-link">

Sign Up </link>
</li>
</div>
)}
</nav>
</div>
 <div>

<div>

<div className="container">
<Switch>
<Route path={["/", "/home"]} exact component={HomeComponents}>
</Route>
<Route path="/v1" component={HomeComponents}> </Route>
<Route path="/personnes"
component={ListPersonneComponents}></Route>
<Route path="/Register" component={Register}></Route>
<Route path="/addPersonnes" component={CreatePersonne}></Route>
<Route path="/updatePersonee/:id"
component={UpdatePersonne}></Route>
<Route path="/ViewPersonnes/:id"
component={viewPersonneComponent}></Route>

</Switch>
</div>

</div >
<FooterComponents />
</div>
</Router>
);
}
}
///////////////////////
*****************************//////////////////////////////////

/////////////////////*****************************/////////////////////////////////

export default App;

/////////////////
*******************************************////////////////////////////////////////
/
To refresh a page, we need to use the window. location. reload() method in React.
By default this method reloads the page from a cache,
if we pass true as an argument it reloads the entire page from a server instead of
cache.
///////////////
****************************************///////////////////////////////////////////
/
////////////////////////////////////////////////////
**********************************************////////////////
@PostMapping("/signupCandidat")
public ResponseEntity<?> SignUp(@Valid @RequestBody SignUpUser
signUpRequest) {
/*if (personneDAO.existsByLogin(signUpRequest.getLogin())) {
return ResponseEntity
.badRequest()
.body(new Message("Error: Username is already taken!"));
}
 if (personneDAO.existsByEmail(signUpRequest.getEmail())) {
return ResponseEntity
.badRequest()
.body(new Message("Error: Email is already in use!"));
}*/

// Create new user's account

/* Personne personne = new
Personne(signUpRequest.getCin() ,signUpRequest.getNom(),signUpRequest.getPrenom(),

signUpRequest.getEmail(),signUpRequest.getNumeroTelephone(),signUpRequest.getEtatCi
vil(),signUpRequest.getLogin(),
encoder.encode(signUpRequest.getPassword()));
Candidat candidat= new Candidat(signUpRequest.getDate_Naissance(),

signUpRequest.getAdresse(),signUpRequest.getImage(),signUpRequest.getCv(),personne)
;*/
Utilisateur user =new
Utilisateur(signUpRequest.getCin() ,signUpRequest.getNom(),signUpRequest.getPrenom(
),

signUpRequest.getEmail(),signUpRequest.getNumeroTelephone(),signUpRequest.getEtatCi
vil(),signUpRequest.getDate_Naissance(),

signUpRequest.getAdresse(),signUpRequest.getImage(),signUpRequest.getLogin(),
encoder.encode(signUpRequest.getPassword()));
Set<String> strRoles = signUpRequest.getRole();
Set<Role> roles = new HashSet<>();

Role userRole = roleDAO.findByName("ROLE_CANDIDAT")

.orElseThrow(() -> new RuntimeException("Error: Role is not
found."));
roles.add(userRole);

user.setRoles(roles);
userDAO.save(user);

return ResponseEntity.ok(new Message("User registered successfully!"));

}

//////////////////////////////////************************/////////////////////////
////

@PostMapping("/signupClient")
public ResponseEntity<?> registerClt(@Valid @RequestBody SignUpUser
signUpRequest) {

// Create new user's account

Utilisateur user =new
Utilisateur(signUpRequest.getNom(),signUpRequest.getPrenom(),
signUpRequest.getEmail(),signUpRequest.getNumeroTelephone(),

signUpRequest.getAdresse(),signUpRequest.getMatriculeFiscale(),signUpRequest.getNom
Societe(),

signUpRequest.getRaisonSociale(),signUpRequest.getLogo(),signUpRequest.getLogin(),
encoder.encode(signUpRequest.getPassword()));
Set<String> strRoles = signUpRequest.getRole();
Set<Role> roles = new HashSet<>();

Role userRole = roleDAO.findByName("ROLE_CLIENT")

.orElseThrow(() -> new RuntimeException("Error: Role is not
found."));
roles.add(userRole);

user.setRoles(roles);
userDAO.save(user);

return ResponseEntity.ok(new Message("User registered successfully!"));

}