public void AjouterUtilisateurRole(UtilisateurRole utilisateurRole)
{
using (UtilisateurDAL dal = new UtilisateurDAL())
{
dal.AjouterUtilisateurRole(utilisateurRole);
}
}
public static Utilisateur GetUtilisateurById(string id, bool initializer = true)
{
if (UtilisateurAlreadyInDictionary(id))
{
return(UtilisateurDictionary[id]);
}
var udao = UtilisateurDAL.SelectUtilisateurById(id);
var pdao = PersonneDAL.SelectPersonneById(udao.PersonneId);
var listeAdresse = new List <Adresse>();
if (initializer)
{
foreach (var adresseInDAO in pdao.Adresses)
{
var adresse = AdresseORM.GetAdresseById(adresseInDAO, false);
listeAdresse.Add(adresse);
}
}
var user = new Utilisateur(udao.IdUtilisateur, udao.VerifSolvable, udao.VerifRessortissant,
udao.VerifIdentite, udao.ListeMotClef, pdao.IdPersonne, pdao.Nom, pdao.Prenom, pdao.Age, pdao.Email,
pdao.Password, pdao.TelephoneMobile, pdao.TelephoneFixe, listeAdresse);
if (initializer)
{
UtilisateurDictionary[user.IdUtilisateur] = user;
AdresseORM.Populate(user.Adresses);
}
return(user);
}
public static Paiement GetPaiementById(string id, bool initializer = true)
{
var pdao = PaiementDAL.SelectPaiementById(id);
var utilisateurPaiement = new Utilisateur();
var lotPaiement = new Lot();
if (initializer)
{
lotPaiement = LotORM.GetLotById(LotDAL.SelectLotById(pdao.LotId).IdLot, false);
utilisateurPaiement =
UtilisateurORM.GetUtilisateurById(
UtilisateurDAL.SelectUtilisateurById(pdao.UtilisateurId).IdUtilisateur, false);
}
var paiement = new Paiement(pdao.IdPaiement, utilisateurPaiement, pdao.TypePaiement,
pdao.ValidationPaiement, lotPaiement);
if (initializer)
{
_paiementsDictionary[paiement.IdPaiement] = paiement;
LotORM.Populate(paiement.LotPaiement);
UtilisateurORM.Populate(new List <Utilisateur>(new[]
{
paiement.UtilisateurPaiement
}));
}
return(paiement);
}
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, "", "");
}
/// <summary>
/// Méthode temporaire à supprimer
/// </summary>
/// <param name="cliente"></param>
public void AjouterCliente(Cliente cliente)
{
using (UtilisateurDAL dal = new UtilisateurDAL())
{
dal.AjouterCliente(cliente);
}
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
UtilisateurDAL.getInstance().Dispose();
}
base.Dispose(disposing);
}
public ActionResult Create([Bind(Include = "id,mail,mdp,role")] Utilisateur utilisateur)
{
if (ModelState.IsValid)
{
Utilisateur u = UtilisateurDAL.getInstance().create(utilisateur);
return(RedirectToAction("Index"));
}
return(View(utilisateur));
}
public ActionResult Edit(VMUtilisateurPassword VMUser)
{
if (ModelState.IsValid)
{
VMUser.utilisateur.mdp = VMUser.Password;
Utilisateur u = UtilisateurDAL.getInstance().update(VMUser.utilisateur);
return(RedirectToAction("Index"));
}
return(View(VMUser));
}
public List <Role> ObtenirRolesUtilisateur(int utilisateurId)
{
List <Role> roleUtilisateur;
using (UtilisateurDAL dal = new UtilisateurDAL())
{
roleUtilisateur = dal.ObtenirRolesUtilisateur(utilisateurId);
}
return(roleUtilisateur);
}
private void OnPropertyChanged(string info)
{
PropertyChangedEventHandler handler = PropertyChanged;
if (handler != null)
{
handler(this, new PropertyChangedEventArgs(info));
UtilisateurDAL.UpdateUtilisateur(this);
}
}
// GET: Utilisateurs/Details/mail
public ActionResult Mine()
{
String mail = User.Identity.Name;
Utilisateur utilisateur = UtilisateurDAL.getInstance().getByMail(mail);
if (utilisateur == null)
{
return(HttpNotFound());
}
return(View("details", utilisateur));
}
public static void AddUtilisateur(Utilisateur user)
{
var test = PersonneDAL.SelectPersonneById(user.IdPersonne);
if (test.IdPersonne == null)
{
PersonneDAL.InsertNewPersonne(UtilisateurToPersonneDao(user));
}
UtilisateurDAL.InsertNewUtilisateur(UtilisateurToDao(user));
}
/// <summary>
/// Obtention d'un utilisateur à partir de son Id
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public Utilisateur ObtenirUtilisateur(int id)
{
Utilisateur utilisateur;
using (UtilisateurDAL dal = new UtilisateurDAL())
{
utilisateur = dal.ObtenirUtilisateur(id);
}
return(utilisateur);
}
/// <summary>
/// Identification d'un utilisateur à partir de son login et de son mot de passe non crypté
/// </summary>
/// <param name="login"></param>
/// <param name="motDePasse"></param>
/// <returns></returns>
public Utilisateur IdentifierUtilisateur(string login, string motDePasse)
{
Utilisateur utilisateur;
string motDePasseCrypte = UtilisateurRules.EncodeMD5(motDePasse);
using (UtilisateurDAL dal = new UtilisateurDAL())
{
utilisateur = dal.IdentifierUtilisateur(login, motDePasseCrypte);
}
return(utilisateur);
}
/// <summary>
/// Ajout d'une masseuse : Réservé à l'admin
/// </summary>
/// <param name="masseuse"></param>
/// <returns></returns>
public int AjouterMasseuse(Masseuse masseuse)
{
int id;
// Encription du mdp :
masseuse.MdpCripte = UtilisateurRules.EncodeMD5(masseuse.MdpCripte);
using (UtilisateurDAL dal = new UtilisateurDAL())
{
id = dal.AjouterMasseuse(masseuse);
}
return(id);
}
/// <summary>
/// Ajout d'une cliente à partir de son login et de son mot de passe non crypté
/// </summary>
/// <param name="login"></param>
/// <param name="motDePasse"></param>
/// <returns></returns>
public int AjouterCliente(string login, string motDePasse)
{
int idUtilisateur = -1;
string motDePasseCrypte = UtilisateurRules.EncodeMD5(motDePasse);
using (UtilisateurDAL dal = new UtilisateurDAL())
{
idUtilisateur = dal.AjouterCliente(login, motDePasseCrypte);
}
return(idUtilisateur);
}
public static List <Utilisateur> GetAllUtilisateur()
{
var ludao = UtilisateurDAL.SelectAllUtilisateur();
var users = new List <Utilisateur>();
foreach (var udao in ludao)
{
users.Add(GetUtilisateurById(udao.IdUtilisateur));
}
return(users);
}
// GET: Utilisateurs/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Utilisateur utilisateur = UtilisateurDAL.getInstance().getById((int)id);
if (utilisateur == null)
{
return(HttpNotFound());
}
return(View(utilisateur));
}
//Ce qui est exécuté selon si la condition est vraie ou fausse.
private void DeleteExecute(object parameter)
{
MessageBoxResult dialogResult = MessageBox.Show("Voulez-vous vraiment supprimer l'utilisateur " + this.UtilisateurSelectionne.IdProperty + " ?", "Confirmation de suppression", MessageBoxButton.YesNo);
if (dialogResult == MessageBoxResult.Yes)
{
//Suppression de l'utilisateur
UtilisateurDAL.DeleteUtilisateur(UtilisateurSelectionne.IdProperty);
MessageBox.Show("L'utilisateur a bien été supprimé.");
}
else if (dialogResult == MessageBoxResult.No)
{
}
}
public ActionResult Create(VMAvisDeRecherche VMadr)
{
if (ModelState.IsValid)
{
Utilisateur userConnected = UtilisateurDAL.getInstance().getByMail(User.Identity.Name);
VMadr.avisDeRecherche.membre = userConnected;
db.AvisDeRecherches.Add(VMadr.avisDeRecherche);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(VMadr));
}
public ActionResult LoginPost(ObjLogin model)
{
try
{
model.messageKO = "Erreur lors de la tentative de connection : ";
if (ModelState.IsValid)
{
// Chargement en base
using (UtilisateurDAL db = new UtilisateurDAL())
{
// On teste d'abord si l'utilisateur existe en bdd
bool isLoginExistant = db.isUtilisateurExistant(model.Login);
if (isLoginExistant)
{
// Si l'utilisateur existe, on regarde si le mot de passe est OK
bool isConnexionOK = db.isConnexionOK(model.Login, model.Password);
if (isConnexionOK)
{
model.messageKO = null;
model.isConnectionOK = true;
// maj de la variable de session concernant l'utilisateur connecté. P
// L'utilisateur connecté sera admin du site
Utilisateur UserConnecte = new Utilisateur(true);
UserConnecte.Login = model.Login;
System.Web.HttpContext.Current.Session[Commons.Const.sessionName_UserConnecte] = UserConnecte;
}
else
{
model.messageKO = model.messageKO + "Le mot de passe est erronné.";
}
}
else
{
model.messageKO = model.messageKO + "Le login renseigné n'existe pas.";
}
}
}
}
catch (Exception e)
{
model.messageKO = model.messageKO + e.Message;
Commons.Logger.genererErreur(typeof(HomeController), e.ToString());
// return RedirectToAction("AfficherErreur", "Error", new { message = e.Message });
}
return(PartialView("~/Views/Login/Login.cshtml", model));
}
public ActionResult Create([Bind(Include = "id,dateSignalement,commentaire,adresse,ville,avisDeRecherche_id")] Signalement signalement)
{
if (ModelState.IsValid)
{
if (User.Identity.IsAuthenticated)
{
signalement.utilisateur = UtilisateurDAL.getInstance().getByMail(User.Identity.Name);
}
db.Signalements.Add(signalement);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(signalement));
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Utilisateur utilisateur = UtilisateurDAL.getInstance().getById((int)id);
if (utilisateur == null)
{
return(HttpNotFound());
}
var VMUser = new VMUtilisateurPassword(utilisateur);
return(View(VMUser));
}
public ActionResult Index(Utilisateur utilisateur)
{
//On crée une variable "isValid" qui permet de savoir si un utilisateur possède une adresse mail valide sur notre site
var isValid = db.Utilisateurs.Where(am => am.AdresseMail == utilisateur.AdresseMail).FirstOrDefault();
//Si on a bien une adresse mail
if (isValid != null)
{
//On compare le mot de passe hashé entré par l'utilisateur et le mot de passe avec lequel il s'est inscrit
if (string.Compare(HashingPass.Hash(utilisateur.MotDePasse), isValid.MotDePasse) == 0)
{
/*Méthode qui va générer un ticket d'authentification pour l'utilisateur
* que l'on stocke par la suite dans un cookie pour le rediriger vers la page du site*/
var ticket = new FormsAuthenticationTicket("connexionCookie", false, 525600);
string encrypt = FormsAuthentication.Encrypt(ticket);
var connexionCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encrypt)
{
Expires = DateTime.Now.AddMinutes(5000)
};
connexionCookie.HttpOnly = true;
Response.Cookies.Add(connexionCookie);
HttpCookie idUserCookie = new HttpCookie("idUtilisateurCookie");
string strIdUtilisateur = UtilisateurDAL.getIdUtilisateurFromEmail(utilisateur.AdresseMail).ToString();
idUserCookie.Values.Set("idUtilisateur", strIdUtilisateur);
idUserCookie.Expires = DateTime.Now.AddMinutes(5000);
idUserCookie.HttpOnly = true;
Response.Cookies.Add(idUserCookie);
return(RedirectToAction("Index", "BilletRetards"));
//TEST
}
else
{
ModelState.AddModelError("MotDePasse", "Votre mot de passe est incorrect");
}
}
else
{
ModelState.AddModelError("AdresseMail", "L'adresse que vous avez renseignée n'existe pas");
}
return(View());
}
private void ajouterUtilisateur_Click(object sender, EventArgs e)
{
myDataObject.nomUtilisateurProperty = Nom.Text;
myDataObject.loginUtilisateurProperty = login.Text;
myDataObject.passwordUtilisateurProperty = password.Text;
string decimalValueToParse = isAdmin.Text;
Byte result;
Byte defaultValue = 0; //Par défaut l'utilisateur n'est pas admin
myDataObject.roleUtilisateurProperty = Byte.TryParse(decimalValueToParse, out result) ? result : defaultValue;
myDataObject.prenomUtilisateurProperty = Prenom.Text;
UtilisateurViewModel nouveau = new UtilisateurViewModel(UtilisateurDAL.getMaxIdUtilisateur() + 1, myDataObject.nomUtilisateurProperty, myDataObject.prenomUtilisateurProperty, myDataObject.roleUtilisateurProperty, myDataObject.passwordUtilisateurProperty, myDataObject.loginUtilisateurProperty);
lu.Add(nouveau);
UtilisateurORM.insertUtilisateur(nouveau);
listeUtilisateurs.Items.Refresh();
}
private void connexion_Click(object sender, EventArgs e)
{
Window window = Window.GetWindow(this);
myDataObject = UtilisateurORM.getUtilisateur(login.Text);
if (login.Text == myDataObject.loginUtilisateurProperty && UtilisateurDAL.hash(password.Password) == myDataObject.passwordUtilisateurProperty && myDataObject.roleUtilisateurProperty == 1) //Log des admins
{
window.Content = new AfficherInterfaceAdministrateur();
}
else if (login.Text == myDataObject.loginUtilisateurProperty && UtilisateurDAL.hash(password.Password) == myDataObject.passwordUtilisateurProperty && myDataObject.roleUtilisateurProperty == 0) //Log des utilisateurs
{
window.Content = new AfficherInterfaceUtilisateur();
}
else
{
window.Content = new AfficherPageMauvaisLogin();
}
}
public ActionResult Create([Bind(Include = "Motif,Justificatif")] BilletRetard billetRetard)
{
if (billetRetard.Motif != null)
{
if (billetRetard.Justificatif == null)
{
billetRetard.Justificatif = "Aucun";
}
billetRetard.DateHeure = DateTime.Now;
billetRetard.Score = 0;
int idUtilisateur = Int32.Parse(Request.Cookies["idUtilisateurCookie"]["idUtilisateur"]);
billetRetard.Utilisateur = UtilisateurDAL.getUtilisateurFromId(idUtilisateur);
db.BilletsRetards.Add(billetRetard);
db.SaveChanges();
return(RedirectToAction("Index", "BilletRetards"));
}
return(View(billetRetard));
}
public void connexionButton(object sender, RoutedEventArgs e)
{
Window pageConnexion = Window.GetWindow(this);
myDataObject = UtilisateurORM.getUtilisateur(loginTextBox.Text);
if (loginTextBox.Text == myDataObject.loginUtilisateurProperty && UtilisateurDAL.hash(passwordTextBox.Text) == myDataObject.passwordUtilisateurProperty)
{
if (myDataObject.isAdminUtilisateurProperty == 1)
{
pageConnexion.Content = new MenuDeSelectionAdmin();
}
else if (myDataObject.isAdminUtilisateurProperty == 0)
{
pageConnexion.Content = new AfficerChoixEquipe();
}
}
else
{
pageConnexion.Content = new PageErreurConnexion();
}
}
public UtilisateurViewModel()
{
//On tente une connexion à la base de données, sinon on retourne un message d'erreur.
try
{
int lastId = lastId = UtilisateurDAL.GetLastId();
}
catch
{
MessageBox.Show("Une erreur est survenue\nERREUR: Impossible de récupérer le dernier ID dans la base de données.");
}
try
{
ListeUtilisateurs = new ObservableCollection <Utilisateur>();
UtilisateurDAL.SelectUtilisateur(ListeUtilisateurs);
}
catch
{
MessageBox.Show("Une erreur est survenue\nERREUR: Impossible de récupérer la table [Utilisateur] \nVérifiez la connexion à la base de données.");
}
}
public ActionResult Login(String mail, String mdp, String returnUrl)
{
Utilisateur AuthenticatedUser = UtilisateurDAL.getInstance().authenticate(mail, mdp);
if (AuthenticatedUser != null)
{
int id = AuthenticatedUser.id;
FormsAuthentication.SetAuthCookie(AuthenticatedUser.mail.ToString(), false);
var authCookie = HttpContext.Request.Cookies[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
string encTicket = authCookie.Value;
if (!String.IsNullOrEmpty(encTicket))
{
var ticket = FormsAuthentication.Decrypt(encTicket);
var user = new UserIdentity(ticket);
var role = Roles.GetRolesForUser(user.Name);
var prin = new GenericPrincipal(user, role);
HttpContext.User = prin;
}
}
if (String.IsNullOrEmpty(returnUrl))
{
return(RedirectToAction("Index", "AvisDeRecherches"));
}
else
{
return(Redirect(returnUrl));
}
}
else
{
return(RedirectToAction("Login"));
}
}
