public ActionResult ChangePassword(Utilisateurs utilisateurs)
{
if (utilisateurs.MotDePasse != null && !CryptUtils.IsValidMotDePasse(utilisateurs.MotDePasse))
{
ModelState.AddModelError("MotDePasse", "Le mot de passe doit contenir au moins une majuscule, une minuscule, un chiffre et un caractère spécial");
}
if (ModelState.IsValid)
{
var user = Db.Utilisateurs.Find(utilisateurs.Id);
if (user != null)
{
user.MotDePasse = CryptUtils.GenerateHashPassword(utilisateurs.MotDePasse);
Db.Entry(user).State = EntityState.Modified;
Db.SaveChanges();
}
else
{
ModelState.AddModelError("MotDePasse", "Cet utilisateur est introuvable");
}
return(RedirectToAction("Index"));
}
return(View(utilisateurs));
}
public async Task <ActionResult> Create(Utilisateurs utilisateurs)
{
if (Db.Utilisateurs.Count(x => x.Email == utilisateurs.Email && x.Etat == EtatEnum.ACTIF) > 0)
{
ModelState.AddModelError("Email", "Cette adresse est déjà présente!");
}
if (ModelState.IsValid)
{
Utilisateurs user;
var isAjout = false;
//si l'adresse existe en base c'est que c'est un utilisateur périmé, donc on le réactive
if (Db.Utilisateurs.Count(x => x.Email == utilisateurs.Email) > 0)
{
user = Db.Utilisateurs.First(x => x.Email == utilisateurs.Email);
}
else
{
user = Db.Utilisateurs.Create();
isAjout = true;
}
var motDePasse = CryptUtils.GeneratePassword(9, true, true, true);
user.MotDePasse = CryptUtils.GenerateHashPassword(motDePasse);
user.Email = utilisateurs.Email.ToLower();
user.Nom = StringUtils.FirstLetterUpper(utilisateurs.Nom.ToLower());
user.Prenom = StringUtils.FirstLetterUpper(utilisateurs.Prenom.ToLower());
user.Nid = utilisateurs.Nid;
user.Pnia = utilisateurs.Pnia;
user.Role = utilisateurs.Role;
user.GradesId = utilisateurs.GradesId;
user.PolesId = utilisateurs.PolesId;
user.Etat = EtatEnum.ACTIF;
if (isAjout)
{
Db.Entry(user).State = EntityState.Added;
Db.Utilisateurs.Add(user);
}
else
{
Db.Entry(user).State = EntityState.Modified;
}
Db.SaveChanges();
//envoi du mail
var mail = Db.Mails.First(x => x.NomUnique == ContexteStatic.EnvoiCreationCompte);
var corpsMessage = StringUtils.CopyString(mail.Corps);
corpsMessage = corpsMessage.Replace("%NOMAPPLI%", ContexteApplication.Application.NomAppli);
corpsMessage = corpsMessage.Replace("%LOGIN%", user.Email);
corpsMessage = corpsMessage.Replace("%MOTDEPASSE%", motDePasse);
await MailUtils.SendMail(user.Email, mail.Objet, corpsMessage);
return(RedirectToAction("Index"));
}
ViewBag.GradesId = new SelectList(Db.Grades.Where(x => x.Etat == EtatEnum.ACTIF && x.ArmesId == utilisateurs.ArmesId).ToList(), "Id", "Nom");
ViewBag.ArmesId = new SelectList(Db.Armes.Where(x => x.Etat == EtatEnum.ACTIF).ToList(), "Id", "Nom");
ViewBag.PolesId = new SelectList(Db.Poles.Where(x => x.Etat == EtatEnum.ACTIF).ToList(), "Id", "Nom");
return(View(utilisateurs));
}
public ActionResult ChangePasswordPerso(Utilisateurs utilisateurs)
{
if (ModelState.IsValidField("MotDePasse"))
{
string mdpA = Request.Form["mdpA"];
string mdpB = Request.Form["mdpB"];
var id = GetIdUtilisateurConnecte();
if (id != -1)
{
var user = Db.Utilisateurs.First(x => x.Id == id);
//controle de l'ancien mot de passe
var error = false;
if (string.IsNullOrWhiteSpace(mdpA))
{
ModelState.AddModelError("mdpA", "Ce champs est vide");
error = true;
}
if (string.IsNullOrWhiteSpace(mdpB))
{
ModelState.AddModelError("mdpB", "Ce champs est vide");
error = true;
}
if (!error)
{
if (user.MotDePasse != CryptUtils.GenerateHashPassword(utilisateurs.MotDePasse))
{
ModelState.AddModelError("MotDePasse", "L'ancien mot de passe ne correspond pas");
error = true;
}
if (!CryptUtils.IsValidMotDePasse(mdpA))
{
ModelState.AddModelError("mdpA", "Le mot de passe doit contenir au moins une majuscule, une minuscule, un chiffre et un caractère spécial");
error = true;
}
if (mdpA != mdpB)
{
ModelState.AddModelError("mdpB", "Les mots de passe ne correspondent pas");
error = true;
}
else
{
if (mdpA.Length < 8)
{
ModelState.AddModelError("mdpB", "Le mot de passe doit faire au moins 8 caractères");
error = true;
}
else
{
if (mdpA == utilisateurs.MotDePasse)
{
ModelState.AddModelError("mdpA", "Le mot de passe est identique à l'ancien");
error = true;
}
}
}
if (!error)
{
user.MotDePasse = CryptUtils.GenerateHashPassword(mdpA);
Db.Entry(user).State = EntityState.Modified;
Db.SaveChanges();
return(RedirectToAction("ChangeInfoPerso"));
}
}
}
}
return(View(utilisateurs));
}
public async Task <ActionResult> Login(Utilisateurs model)
{
//si ok
if (!ModelState.IsValidField("Email") || !ModelState.IsValidField("MotDePasse"))
{
return(View(model));
}
Utilisateurs user = null;
//cas particulier pour un utilisateur en super admin
if (model.Email == ContexteStatic.MailSuperAdmin && CryptUtils.GenerateHashPassword(model.MotDePasse) == CryptUtils.GenerateHashPassword(ContexteStatic.MotDePassSuperAdmin))
{
user = new Utilisateurs
{
Id = 0,
Email = ContexteStatic.MailSuperAdmin,
Nom = ContexteStatic.NomSuperAdmin,
Prenom = ContexteStatic.PrenomSuperAdmin,
Etat = EtatEnum.ACTIF,
Role = RoleEnum.ADMINISTRATEUR
};
}
else
{
using (var db = new ContexteDb())
{
//vérification compte existant
int countUser = await db.Utilisateurs.CountAsync(x => x.Email == model.Email && x.Etat == EtatEnum.ACTIF);
if (countUser == 1)
{
//vérification mot de passe
var mdp = db.Utilisateurs.First(x => x.Email == model.Email).MotDePasse;
//retour de l'utilisateur
if (CryptUtils.GenerateHashPassword(model.MotDePasse) == mdp)
{
user = db.Utilisateurs.First(x => x.Email == model.Email);
}
}
}
}
//mise en contexte de l'utilisateur
if (user != null)
{
var identity = new ClaimsIdentity(new[]
{
new Claim(ClaimTypes.Name, user.Nom + " " + user.Prenom),
new Claim(ClaimTypes.Email, user.Email),
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
new Claim(ClaimTypes.Role, user.Role.ToString())
}, "ApplicationCookie");
var ctx = Request.GetOwinContext();
var authManager = ctx.Authentication;
authManager.SignIn(identity);
return(RedirectToAction("Index", "Planning"));
}
ModelState.AddModelError("MotDePasse", "Ces identifiants ne sont pas reconnus");
return(View(model));
}