/// <summary>
/// Ajoute au résultat qui contient un Utilisateur et un Role, un membre Entity qui est un Administrateur ou un Fournisseur ou un Client
/// suivant le type, créé à partir des données de la vue
/// </summary>
/// <param name="résultat"></param>
/// <param name="type">type de role</param>
/// <param name="vue"></param>
private void CréeEntité(RésultatEnregistrement résultat, string type, VueBase vue)
{
string uid = résultat.Role.Uid;
int rno = résultat.Role.Rno;
switch (type)
{
case TypeDeRole.Administrateur.Code:
résultat.Entité = (vue as AdministrateurVue).CréeAdministrateur();
résultat.Entité.Uid = uid;
résultat.Entité.Rno = rno;
break;
case TypeDeRole.Fournisseur.Code:
résultat.Entité = _fournisseurService.CréeFournisseur(résultat.Role, vue as EnregistrementFournisseurVue);
résultat.Site = _siteService.CréeSite(résultat.Role, vue as EnregistrementFournisseurVue);
break;
case TypeDeRole.Client.Code:
résultat.Entité = _clientService.CréeClient(résultat.Role, vue as EnregistrementClientVue);
break;
default:
break;
}
}
private async Task <RésultatEnregistrement> CréeUtilisateur(string type, VueBase vue)
{
RésultatEnregistrement résultat = new RésultatEnregistrement();
ApplicationUser existant = await _service.TrouveParEmail(vue.Email);
if (existant == null)
{
ApplicationUser applicationUser = new ApplicationUser
{
UserName = vue.Email,
Email = vue.Email,
};
RetourDeService <Utilisateur> retour = await _service.CréeUtilisateur(applicationUser, vue.Password);
if (retour.Ok)
{
résultat.ACréé = true;
résultat.user = applicationUser;
résultat.Utilisateur = retour.Entité;
}
else
{
résultat.ActionResult = SaveChangesActionResult(retour);
}
}
else
{
Utilisateur utilisateur = await _service.UtilisateurDeUser(existant.Id);
CarteUtilisateur carte = await _service.CréeCarteUtilisateur(HttpContext.User);
bool permis = carte != null && ((carte.EstUtilisateurActif && carte.Uid == utilisateur.Uid) || carte.EstAdministrateur);
if (permis)
{
résultat.ACréé = false;
résultat.user = existant;
résultat.Utilisateur = utilisateur;
permis = await PeutAjouterRole(utilisateur, type, vue);
if (!permis)
{
résultat.ActionResult = BadRequest();
}
}
else
{
résultat.ActionResult = Forbid();
}
}
return(résultat);
}
private async Task <IActionResult> Enregistre(string type, VueBase vue)
{
RésultatEnregistrement résultat = null;
try
{
résultat = await CréeUtilisateur(type, vue);
if (résultat.ActionResult != null)
{
return(résultat.ActionResult);
}
résultat.Role = await _roleService.CréeRole(résultat.Utilisateur);
CréeEntité(résultat, type, vue);
await ValideEntité(résultat, type);
if (!ModelState.IsValid)
{
if (résultat.ACréé)
{
await _service.Supprime(résultat.Utilisateur);
}
return(BadRequest(ModelState));
}
_roleService.AjouteSansSauver(résultat.Role);
AjouteEntitéSansSauver(résultat, type);
RetourDeService retour = await _service.SaveChangesAsync();
if (retour.Type != TypeRetourDeService.Ok && résultat.ACréé)
{
await _service.Supprime(résultat.Utilisateur);
return(SaveChangesActionResult(retour));
}
}
catch (Exception ex)
{
if (résultat != null && résultat.ACréé)
{
await _service.Supprime(résultat.Utilisateur);
}
throw ex;
}
return(await Connecte(résultat.applicationUser, true));
}
/// <summary>
/// Vérifie que l'utilisateur n'a pas déjà de role sur le site
/// </summary>
/// <param name="utilisateur"></param>
/// <param name="type"></param>
/// <param name="vue"></param>
/// <returns></returns>
private async Task <bool> PeutAjouterRole(Utilisateur utilisateur, string type, VueBase vue)
{
switch (type)
{
case TypeDeRole.Administrateur.Code:
return(true);
case TypeDeRole.Fournisseur.Code:
return(await _service.PeutAjouterRole(utilisateur, vue as EnregistrementFournisseurVue));
case TypeDeRole.Client.Code:
return(await _service.PeutAjouterRole(utilisateur, vue as EnregistrementClientVue));
default:
break;
}
return(false);
}