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