/// <summary>
/// Enlève tous les rôles avant d'ajouter les nouveaux rôles sélectionnés
/// </summary>
/// <param name="model"></param>
/// <param name="removeRoles"></param>
private void AddRoles(InformationUtilisateurViewModel model, bool removeRoles = true)
{
if (!_userManager.SupportsUserRole)
{
return;
}
ApplicationUser user = _userManager.FindByIdAsync(model.Id).Result;
IList <string> rls = _userManager.GetRolesAsync(user).Result;
_userManager.RemoveFromRolesAsync(user, rls).Wait();
rls = _userManager.GetRolesAsync(user).Result;
if (rls.Count > 1)
{
throw new Exception("Oups");
}
// S'il y a des groupes de sélectionnés...
if (model.Groupes != null)
{
IEnumerable <string> groupeIds = model.Groupes.Select(x => x.Id);
// Ajouter des groupes dans AspNetRoles à l'aide du UserManager (qui s'occupe de faire les liens entre les tables ASP
IdentityResult result =
_userManager.AddToRolesAsync(user, CommonMethods.GetRole(model.Groupes)).Result;
if (!result.Succeeded)
{
throw new Exception(Error.AjoutRoles);
}
}
}
/// <summary>
/// Met à jour les informations d'un utilisateur
/// </summary>
/// <param name="model"></param>
/// <param name="motDePasseModel"></param>
/// <param name="passwordHash"></param>
public static void UpdateUtilisateur(InformationUtilisateurViewModel model, string passwordHash, string UsagerMAJID, bool resetToken = false)
{
using (DBContext db = new DBContext())
{
ApplicationUser utilisateurExistant = db.Users.Single(u => u.Id == model.Id);
utilisateurExistant.UserName = model.UserName;
utilisateurExistant.NormalizedUserName = model.UserName.ToUpperInvariant();
utilisateurExistant.AccountDisabled = !model.Actif;
utilisateurExistant.Email = model.Email;
utilisateurExistant.NormalizedEmail = model.Email.ToUpperInvariant();
utilisateurExistant.DateHeureMAJ = DateTime.Now;
utilisateurExistant.FirstName = model.FirstName;
utilisateurExistant.LastName = model.LastName;
if (resetToken)
{
utilisateurExistant.SecurityStamp = string.Empty;
}
if (!string.IsNullOrWhiteSpace(passwordHash))
{
utilisateurExistant.PasswordHash = passwordHash;
}
db.SaveChanges();
}
}
public async Task <IActionResult> Create([DataSourceRequest] DataSourceRequest request,
InformationUtilisateurViewModel model)
{
//if (ModelState.ContainsKey("UserName"))
//{
// ModelState["UserName"].Errors.Clear();
// ModelState["UserName"].ValidationState = Microsoft.AspNetCore.Mvc.ModelBinding.ModelValidationState.Valid;
//}
if (ModelState.IsValid)
{
ApplicationUser user = new ApplicationUser
{
UserName = model.UserName,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
Langue = "FR",
DateHeureMAJ = DateTime.Now,
AccountDisabled = !model.Actif
};
if (string.IsNullOrWhiteSpace(model.MotDePasse))
{
model.MotDePasse = Guid.NewGuid().ToString().Replace("-", string.Empty).Remove(12) + "A!";
}
IdentityResult result = await _userManager.CreateAsync(user, model.MotDePasse);
model.ConfirmationMotDePasse = "**********";
model.MotDePasse = "**********";
_logger.LogWarning("création de User." + JsonConvert.SerializeObject(model) + " par " + User.Identity.Name);
if (result.Succeeded)
{
model.Id = user.Id; // Affecter le Id nouvellement créé par le UserManager au model pour que l'ajout des rôles fonctionne
AddRoles(model, false);
return(Json(new[] { user }.ToDataSourceResult(request, ModelState)));
}
else
{
string error = "Erreur de création de l'usager. Vérifier si l'information respecte les règles de sécurité: " + string.Join(", ", result.Errors.Select(x => x.Description));
ModelState.AddModelError("UserName", error);
return(this.Json(new DataSourceResult
{
Errors = error,
Data = ModelState,
Total = 1
}));
}
}
return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
}
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
// Don't reveal that the user does not exist
_logger.LogWarning("ResetPassword: A code must be supplied for password reset.");
return(RedirectToAction(nameof(ResetPasswordConfirmation)));
}
//julien: bypass de aspnet car non fonctionnel sur linux ou autre
if (user.SecurityStamp != model.Code)
{
_logger.LogWarning("ResetPassword: SecurityStamp invalide.");
ModelState.AddModelError(string.Empty, "Token invalide. Valider la procédure...");
}
else
{
if (string.IsNullOrWhiteSpace(model.Password))
{
ModelState.AddModelError(string.Empty, "Mot de passe invalide. Valider la procédure...");
}
else
{
string passwordHash = _userManager.PasswordHasher.HashPassword(new ApplicationUser(), model.Password);
InformationUtilisateurViewModel iusr = new InformationUtilisateurViewModel().Map(user);
iusr.Actif = !user.AccountDisabled;
Utilisateurs.UpdateUtilisateur(iusr, passwordHash, user.Id, true);
_logger.LogWarning("ResetPassword: successful pour " + user.UserName);
return(RedirectToAction(nameof(ResetPasswordConfirmation)));
}
}
return(View());
}
public async Task <IActionResult> Delete([DataSourceRequest] DataSourceRequest request, InformationUtilisateurViewModel model)
{
if (model.Id == null)
{
return(this.Json(new
{
success = false,
message = "Erreur l'effacement de l'utilisateur! " + "Code invalide. Contacter le support et indiquer les étapes pour reproduire ce problème."
}));
}
var user = await _userManager.FindByIdAsync(model.Id);
IdentityResult rc = new IdentityResult();
rc = await _userManager.DeleteAsync(user);
if (!rc.Succeeded)
{
throw new Exception("Une erreur est survenue: " + rc.Errors.First().Description);
}
// transaction.commit();
//}
model.ConfirmationMotDePasse = "**********";
model.MotDePasse = "**********";
_logger.LogWarning("delete de User." + JsonConvert.SerializeObject(model) + " par " + User.Identity.Name);
return(Json(new[] { model }.ToDataSourceResult(request)));
}
public async Task <IActionResult> Update([DataSourceRequest] DataSourceRequest request, InformationUtilisateurViewModel model)
{
if (model.MotDePasse != model.ConfirmationMotDePasse)
{
throw new Exception("Mot de passe de confirmation différent.");
}
string passwordHash = string.Empty;
if (!string.IsNullOrWhiteSpace(model.MotDePasse))
{
passwordHash = _userManager.PasswordHasher.HashPassword(new ApplicationUser(), model.MotDePasse);
}
Utilisateurs.UpdateUtilisateur(model, passwordHash, _userId);
model.ConfirmationMotDePasse = "**********";
model.MotDePasse = "**********";
_logger.LogWarning("update de User." + JsonConvert.SerializeObject(model) + " par " + User.Identity.Name);
AddRoles(model);
return(Json(new[] { model }.ToDataSourceResult(request)));
}
