public static UtilisateurViewModel getUtilisateur(int idUtilisateur)
{
UtilisateurDAO pDAO = UtilisateurDAO.getUtilisateurs(idUtilisateur);
UtilisateurViewModel p = new UtilisateurViewModel(pDAO.idUtilisateurDAO, pDAO.nomUtilisateurDAO, pDAO.prenomUtilisateurDAO, pDAO.roleUtilisateurDAO, pDAO.passwordUtilisateurDAO, pDAO.loginUtilisateurDAO);
return(p);
}
public ActionResult Create(UtilisateurViewModel utilisateurVM)
{
if (!ModelState.IsValid)
{
return(View());
}
// vérifie si l'e-mail existe déjà dans la BDD
if (_db.Utilisateurs.Any(utilisateur => utilisateur.Email == utilisateurVM.Email))
{
ModelState.AddModelError("Email", "Cet e-mail est déjà utilisé.");
return(View());
}
try
{
var utilisateur = new Utilisateur
{
Prenom = utilisateurVM.Prenom,
Nom = utilisateurVM.Nom,
Email = utilisateurVM.Email,
Telephone = utilisateurVM.Telephone,
// hashache du mot de passe
MotDePasse = BC.HashPassword(utilisateurVM.MotDePasse)
};
_db.Utilisateurs.Add(utilisateur);
_db.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
catch
{
return(View());
}
}
public AfficherUtilisateurs()
{
InitializeComponent();
lu = UtilisateurORM.listeUtilisateurs();
listeUtilisateurs.ItemsSource = lu;
myDataObject = new UtilisateurViewModel();
}
private void ajouterButton(object sender, RoutedEventArgs e)
{
myDataObjectUtilisateur.nomUtilisateurProperty = nomTextBox.Text;
myDataObjectUtilisateur.prenomUtilisateurProperty = prenomTextBox.Text;
myDataObjectUtilisateur.loginUtilisateurProperty = loginTextBox.Text;
myDataObjectUtilisateur.passwordUtilisateurProperty = passwordTextBox.Text;
if (adminCheckBox.IsChecked ?? false)
{
myDataObjectUtilisateur.isAdminUtilisateurProperty = 1;
}
else
{
myDataObjectUtilisateur.isAdminUtilisateurProperty = 0;
}
UtilisateurViewModel nouveauU = new UtilisateurViewModel(UtilisateurDAL.getMaxIdUtilisateur() + 1, myDataObjectUtilisateur.nomUtilisateurProperty, myDataObjectUtilisateur.prenomUtilisateurProperty, myDataObjectUtilisateur.isAdminUtilisateurProperty, myDataObjectUtilisateur.passwordUtilisateurProperty, myDataObjectUtilisateur.loginUtilisateurProperty);
lp.Add(nouveauU);
UtilisateurORM.insertUtilisateur(nouveauU);
listeUtilisateurs.Items.Refresh();
myDataObjectUtilisateur = new UtilisateurViewModel(UtilisateurDAL.getMaxIdUtilisateur() + 1, "", "", myDataObjectUtilisateur.isAdminUtilisateurProperty, "", "");
}
public ActionResult Index(UtilisateurViewModel viewModel, string returnUrl)
{
//Modèle fournit valide (info user correctement rempli - prénom + mdp bien renseignés ?)
if (ModelState.IsValid)
{
//Authentification de l'utilisateur
Utilisateur utilisateur = dal.Authentifier(viewModel.Utilisateur.Prenom, viewModel.Utilisateur.MotDePasse);
if (utilisateur != null)
{
//Si authentification OK : authentifier sur ASP.NET l’utilisateur en générant un cookie
//2ème param = false permet de faire en sorte que l’authentification n’ait qu’une durée de vie limitée à la session
FormsAuthentication.SetAuthCookie(utilisateur.Id.ToString(), false);
//Si URL page préalablement demandé existe, renvoie vers elle
//"IsLocalUrl" : Vérifie que le paramètre ReturnUrl contient bien un lien vers notre site (éviter toute tentative de redirection vers un site exterieur)
if (!string.IsNullOrWhiteSpace(returnUrl) && Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
//Sinon renvoie page accueil
return(Redirect("/"));
}
//Si authentification KO : ajouter erreur au ModelState afin d’informer la vue
//Champ en erreur = Utilisateur.Prenom car est chemin d’accès via le view-model
ModelState.AddModelError("Utilisateur.Prenom", "Prénom et/ou mot de passe incorrect(s)");
}
return(View(viewModel));
}
public async Task <IActionResult> ChangerPhoto(UtilisateurViewModel modelUser)
{
Utilisateur utilisateur = await UserService.GetUtilisateurByIdAsync(modelUser.Id);
// If a new photo is uploaded, the existing photo must be
// deleted. So check if there is an existing photo and delete
if (modelUser.ExistingPhotoPath != null)
{
string filePath = Path.Combine(hostingEnvironment.WebRootPath,
"images", modelUser.ExistingPhotoPath);
System.IO.File.Delete(filePath);
}
// Save the new photo in wwwroot/images folder and update
// PhotoPath property of the employee object which will be
// eventually saved in the database
utilisateur.ProfilePhoto = ProcessUploadedFile(modelUser);
utilisateur.Nom = modelUser.Nom;
// Call update method on the repository service passing it the
// employee object to update the data in the database table
await UserService.PutUtilisateurAsync(modelUser.Id, utilisateur);
return(View("Profil", utilisateur));
}
public static UtilisateurViewModel getUtilisateur(string loginUtilisateur)
{
UtilisateurDAO uDAO = UtilisateurDAO.getUtilisateurs(loginUtilisateur);
UtilisateurViewModel u = new UtilisateurViewModel(uDAO.idUtilisateurDAO, uDAO.nomUtilisateurDAO, uDAO.prenomUtilisateurDAO, uDAO.isAdminUtilisateurDAO, uDAO.passwordUtilisateurDAO, uDAO.loginUtilisateurDAO);
return(u);
}
public ActionResult Index(UtilisateurViewModel utilisateurVM, string returnUrl)
{
if (ModelState.IsValid)
{
Utilisateur utilisateur = UtilisateurServiceProxy.Instance().IdentifierUtilisateur(utilisateurVM.Utilisateur.Login, utilisateurVM.Utilisateur.MdpCripte);
if (utilisateur != null)
{
FormsAuthentication.SetAuthCookie(utilisateur.Id.ToString(), true);
//FormsAuthentication.
if (!String.IsNullOrEmpty(returnUrl) && Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(Redirect("/"));
}
}
else
{
ModelState.AddModelError("Utilisateur.Login", "Login et/ou mot de passe incorrect");
}
}
return(View(utilisateurVM));
}
public async Task <IActionResult> GetAllUsers(string id)
{
IEnumerable <Utilisateur> utilisateurs = userService.GetAllUtilisateurDetails();
List <UtilisateurViewModel> users = new List <UtilisateurViewModel>();
foreach (var user in utilisateurs)
{
var mod = new UtilisateurViewModel
{
Id = user.Id,
Nom = user.Nom,
Prenom = user.Prenom,
Email = user.Email,
};
if (await UserManager.IsInRoleAsync(user, "Administrateur"))
{
mod.role = "Administrateur";
}
else
{
if (await UserManager.IsInRoleAsync(user, "Utilisateur"))
{
mod.role = "Utilisateur";
}
else
{
mod.role = "Commercant";
}
}
users.Add(mod);
}
return(View(users));
}
public Inscription()
{
this.InitializeComponent();
//datacontext
inscription = new UtilisateurViewModel();
this.DataContext = inscription;
}
public EtudeViewModel(int id, string nom, DateTime date, UtilisateurViewModel proprio /*, MetierViewModel metier*/)
{
this.id = id;
this.nom = nom;
this.date = date;
this.proprio = proprio;
//metierPersonne = metier;
}
public UtilisateurView()
{
InitializeComponent();
Model = new UtilisateurViewModel();
this.DataContext = Model;
ListContent.Children.Add(Model.Content as Liste <T_S_UTILISATEUR_UTI>);
}
private void supprimerButton_Click(object sender, EventArgs e)
{
UtilisateurViewModel toRemove = (UtilisateurViewModel)listeUtilisateurs.SelectedItem;
lu.Remove(toRemove);
listeUtilisateurs.Items.Refresh();
UtilisateurORM.supprimerUtilisateur(selectedUtilisateurId);
}
public TrajetPage(TrajetViewModel trajet, UtilisateurViewModel user)
{
InitializeComponent();
trajet.CurrentUser = user;
this.BindingContext = MonTrajet = trajet;
this.Title = "Un trajet " + trajet.CurrentUser.Nom + " ?";
}
public async Task <IActionResult> RegisterUser(string returnUrl)
{
ViewData["countries"] = AvailableCountries;
UtilisateurViewModel model = new UtilisateurViewModel {
ReturnUrl = returnUrl, ExternalLogins = (await signInManager.GetExternalAuthenticationSchemesAsync()).ToList()
};
return(View(model));
}
public static UtilisateurViewModel getPersonne(int idPersonne)
{
UtilisateurDAO pDAO = UtilisateurDAO.getPersonne(idPersonne);
//int idMetier = pDAO.idMetierPersonneDAO;
//MetierViewModel m = MetierORM.getMetier(idMetier);
UtilisateurViewModel p = new UtilisateurViewModel(pDAO.idPersonneDAO, pDAO.nomPersonneDAO, pDAO.prenomPersonneDAO /*, m*/);
return(p);
}
public ConnexionPage(UtilisateurViewModel item)
{
InitializeComponent();
NavigationPage.SetHasNavigationBar(this, false);
this.BindingContext = item;
if(_email.Text!=null && _password.Text !=null)
{
_btnconnexion.IsEnabled = true;
}
}
public ActionResult CreerCompte(UtilisateurViewModel utilisateurViewModel)
{
if (ModelState.IsValid)
{
int id = dal.CreerUtilisateur(utilisateurViewModel.Utilisateur.Nom, utilisateurViewModel.Utilisateur.MotDePasse);
FormsAuthentication.SetAuthCookie(id.ToString(), false);
return(Redirect("/"));
}
return(View(utilisateurViewModel));
}
public ActionResult Index()
{
UtilisateurViewModel viewModel = new UtilisateurViewModel(HttpContext.User.Identity.IsAuthenticated);
if (HttpContext.User.Identity.IsAuthenticated)
{
viewModel.Utilisateur = dal.ObtenirUtilisateur(HttpContext.User.Identity.Name);
return(RedirectToAction("IndexSuperManager", "SuperManagerController"));
}
return(View(viewModel));
}
public ActionResult Index()
{
UtilisateurViewModel viewmodel = new UtilisateurViewModel();
if (HttpContext.User.Identity.Name != null)
{
viewmodel.Utilisateur = dal.ObtenirUtilisateur(HttpContext.User.Identity.Name);
viewmodel.Authentifie = true;
}
return(View(viewmodel));
}
public static ObservableCollection <UtilisateurViewModel> listeUtilisateurs()
{
ObservableCollection <UtilisateurDAO> lDAO = UtilisateurDAO.listeUtilisateurs();
ObservableCollection <UtilisateurViewModel> l = new ObservableCollection <UtilisateurViewModel>();
foreach (UtilisateurDAO element in lDAO)
{
UtilisateurViewModel u = new UtilisateurViewModel(element.idUtilisateurDAO, element.nomUtilisateurDAO, element.prenomUtilisateurDAO, element.isAdminUtilisateurDAO, element.passwordUtilisateurDAO, element.loginUtilisateurDAO);
l.Add(u);
}
return(l);
}
public ActionResult Index()
{
UtilisateurViewModel viewModel = new UtilisateurViewModel {
Authentifie = HttpContext.User.Identity.IsAuthenticated
};
if (HttpContext.User.Identity.IsAuthenticated)
{
viewModel.Utilisateur = dal.ObtenirUtilisateur(HttpContext.User.Identity.Name);
}
return(View(viewModel));
}
// GET: Login
/// <summary>
/// Action de base du controller Login : écran de login
/// Normalement l'user n'est pas authentifié, tout est vide
/// si il est utilisateur mais va là quand même, tout est préremplis
/// </summary>
/// <returns></returns>
public ActionResult Index()
{
UtilisateurViewModel utilisateurVM = new UtilisateurViewModel();
utilisateurVM.EstIdentifie = HttpContext.User.Identity.IsAuthenticated;
if (HttpContext.User.Identity.IsAuthenticated)
{
utilisateurVM.Utilisateur = UtilisateurServiceProxy.Instance().ObtenirUtilisateur(HttpContext.User.Identity.Name);
}
return(View(utilisateurVM));
}
public async Task <ViewResult> ChangerPhoto(string id)
{
Utilisateur utilisateur = await UserService.GetById(id);
UtilisateurViewModel modelUser = new UtilisateurViewModel
{
Id = utilisateur.Id,
Nom = utilisateur.Nom,
Prenom = utilisateur.Prenom,
ExistingPhotoPath = utilisateur.ProfilePhoto
};
return(View(modelUser));
}
public static UtilisateurHasEquipeViewModel getUtilisateurHasEquipe(int idUtilisateur, int idEquipe)
{
UtilisateurHasEquipeDAO uDAO = UtilisateurHasEquipeDAO.getUtilisateurHasEquipe(idUtilisateur, idEquipe);
int Utilisateur_idUtilisateur = uDAO.Utilisateur_idUtilisateurDAO;
UtilisateurViewModel u = UtilisateurORM.getUtilisateur(Utilisateur_idUtilisateur);
int Equipe_idEquipe = uDAO.Equipe_idEquipeDAO;
EquipeViewModel e = EquipeORM.getEquipe(Equipe_idEquipe);
UtilisateurHasEquipeViewModel ue = new UtilisateurHasEquipeViewModel(u, e);
return(ue);
}
public AfficherUtilisateurs()
{
InitializeComponent();
lp = UtilisateurORM.listeUtilisateurs();
lue = UtilisateurHasEquipeORM.listeUtilisateurHasEquipes();
le = EquipeORM.listeEquipes();
listeUtilisateurs.ItemsSource = lp;
listeUtilisateursHasEquipe.ItemsSource = lue;
EquipeComboBox.ItemsSource = le;
UtilisateurComboBox.ItemsSource = lp;
//EquipeComboBoxColumn.ItemsSource = le;
myDataObjectUtilisateur = new UtilisateurViewModel();
myDataObjectUtilisateurHasEquipe = new UtilisateurHasEquipeViewModel();
}
public async Task <ActionResult <UtilisateurViewModel> > GetUtilisateur(Guid id)
{
var utilisateur = new UtilisateurViewModel(await _context.Utilisateur
.Include(u => u.Role)
.Include(u => u.Site).ThenInclude(u => u.Entreprise)
.FirstOrDefaultAsync(u => u.Id == id));
if (utilisateur == null)
{
return(NotFound());
}
return(utilisateur);
}
public MainWindow()
{
InitializeComponent();
DALConnection.OpenConnection();
lu = ComptageORM.listeComptages();
// Initialisation de la liste des personnes via la BDD.
le = EtudeORM.listeEtudes();
lp = PlageORM.listePlages();
//lu = EtudeORM.getEtude(user.idPersonne);
MainWindow.user = user;
ListeEtude.ItemsSource = le;
ListePlage.ItemsSource = lp;
//listeComptages.ItemsSource = lu;
}
public static ObservableCollection <UtilisateurViewModel> listePersonnes()
{
ObservableCollection <UtilisateurDAO> lDAO = UtilisateurDAO.listePersonnes();
ObservableCollection <UtilisateurViewModel> l = new ObservableCollection <UtilisateurViewModel>();
foreach (UtilisateurDAO element in lDAO)
{
//int idMetier = element.idMetierPersonneDAO;
//MetierDAO m = MetierDAO.getMetier(idMetier);
//MetierViewModel metier = new MetierViewModel(m.idMetierDAO, m.libMetierDAO);
UtilisateurViewModel p = new UtilisateurViewModel(element.idPersonneDAO, element.nomPersonneDAO, element.prenomPersonneDAO /*, metier*/);
l.Add(p);
}
return(l);
}
public ActionResult Index()
{
UtilisateurViewModel viewModel = new UtilisateurViewModel {
Authentifie = HttpContext.User.Identity.IsAuthenticated
};
//Vérifie que l'utilisateur est authentifié
if (HttpContext.User.Identity.IsAuthenticated)
{
//Récupère utilisateur via la DAL à travers un viewmodel pour préparer les données à présenter dans la vue
//Identifiant de l’utilisateur dans la propriété Name car c'est L'id utilisé lors de l'appel (FormsAuthentication.SetAuthCookie(id.ToString(), false);)
viewModel.Utilisateur = dal.ObtenirUtilisateur(HttpContext.User.Identity.Name);
}
return(View(viewModel));
}
