public async Task Connecte(CarteUtilisateur carteUtilisateur)
{
Utilisateur utilisateur = carteUtilisateur.Utilisateur;
// persistant est false car l'utilisateur doit s'authentifier à chaque accès
await _signInManager.SignInAsync(utilisateur, false);
// lit et augmente le sessionId de l'utilisateur
int sessionId = utilisateur.SessionId;
if (sessionId < 0)
{
// l'utilisateur s'est déconnecté lors de sa dernière session
// et son SessionId a été changé en son opposé
sessionId = -sessionId;
}
sessionId = sessionId + 1;
// fixe le sessionId de l'utilisateur et de la carte
utilisateur.SessionId = sessionId;
_context.Utilisateur.Update(utilisateur);
ArchiveUtilisateur archive = new ArchiveUtilisateur
{
Id = utilisateur.Id,
Date = DateTime.Now,
SessionId = sessionId
};
_context.ArchiveUtilisateur.Add(archive);
await _context.SaveChangesAsync();
carteUtilisateur.SessionId = sessionId;
}
/// <summary>
/// Vérifie que l'utilisateur est le client de la commande ou le fournisseur du site
/// </summary>
/// <param name="paramClient"></param>
/// <returns></returns>
private async Task UtilisateurEstClientOuFournisseur(Vérificateur vérificateur)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
vérificateur.Erreur = Forbid();
return;
}
vérificateur.EstClient = await carte.EstActifEtAMêmeUidRno(vérificateur.KeyClient.KeyParam);
if (!vérificateur.EstClient)
{
vérificateur.EstFournisseur = await carte.EstActifEtAMêmeUidRno(vérificateur.Site.KeyParam);
if (!vérificateur.EstFournisseur)
{
vérificateur.Erreur = Forbid();
return;
}
}
else
{
vérificateur.EstFournisseur = false;
}
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> CopieDems([FromQuery] KeyUidRno keySite)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
return(Forbid());
}
bool estFournisseur = await carte.EstActifEtAMêmeUidRno(keySite.KeyParam);
if (!estFournisseur)
{
return(Forbid());
}
Site site = await _utile.SiteDeKey(keySite);
if (site == null)
{
return(NotFound());
}
RetourDeService retour = await _service.CopieDemandes(site);
if (retour == null)
{
return(RésultatBadRequest("RienACopier"));
}
return(SaveChangesActionResult(retour));
}
/// <summary>
/// Supprime une donnée.
/// </summary>
/// <param name="carte">Carte utilisateur comportant une erreur si l'édition n'est pas autorisée</param>
/// <param name="donnée">donnée à supprimer si elle existe</param>
/// <returns></returns>
protected async Task <IActionResult> Supprime(CarteUtilisateur carte, T donnée)
{
if (carte.Erreur != null)
{
return(carte.Erreur);
}
if (donnée == null)
{
return(NotFound());
}
DAvecIdUintValideModel <T> dValideSupprime = __service.DValideSupprime();
if (dValideSupprime != null)
{
await dValideSupprime(donnée, ModelState);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
}
var retour = await __service.Supprime(donnée);
return(SaveChangesActionResult(retour));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> Lit([FromQuery] KeyUidRnoNo2 keyDétail)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
bool estLeClient = await carte.EstActifEtAMêmeUidRno(AKeyUidRnoNo2.KeyUidRno_1(keyDétail).KeyParam);
if (!estLeClient)
{
bool estFournisseur = await carte.EstActifEtAMêmeUidRno(AKeyUidRnoNo2.KeyUidRno_2(keyDétail).KeyParam);
if (!estFournisseur)
{
return(Forbid());
}
}
DétailCommande détail = await _détailCommandeService.Lit(keyDétail.KeyParam);
if (détail == null)
{
return(NotFound());
}
DétailCommandeVue vue = _détailCommandeService.CréeVue(détail);
return(Ok(vue));
}
/// <summary>
/// Crée une CarteUtilisateur à partir d'un Utilisateur.
/// Fixe l'Utilisateur de la carte avec son Archives, avec ses Clients incluant leurs Archives et leur Site incluant son Fournisseur
/// et avec ses Fournisseurs incluant leurs Archives et leur Site.
/// </summary>
/// <param name="utilisateur"></param>
/// <returns>la CarteUtilisateur créée</returns>
public async Task <CarteUtilisateur> CréeCarteUtilisateur(Utilisateur utilisateur)
{
CarteUtilisateur carte = new CarteUtilisateur(_context);
await carte.FixeUtilisateur(utilisateur);
return(carte);
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> Commandes([FromQuery] KeyUidRno keyClient)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
Site site = await _utile.SiteDeClient(keyClient);
if (site == null)
{
return(NotFound());
}
if (!await carte.EstActifEtAMêmeUidRno(site.KeyParam))
{
return(Forbid());
}
List <CommandeAFacturer> commandes = await _service.CommandesAFacturer(site, keyClient);
return(Ok(commandes));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> ListeC([FromQuery] KeyUidRno keyClient)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
Site site = await _utile.SiteDeClient(keyClient);
if (site == null)
{
return(NotFound());
}
if (!carte.EstClient(site))
{
return(Forbid());
}
Documents documents = await _service.ListeC(site, keyClient);
return(Ok(documents));
}
public async Task <CarteUtilisateur> CréeCarteUtilisateur(ClaimsPrincipal user)
{
CarteUtilisateur carte = new CarteUtilisateur();
IEnumerable <Claim> claims = user.Identities.FirstOrDefault()?.Claims;
if (claims != null && claims.Count() > 0)
{
carte.UserId = (claims.Where(c => c.Type == JwtClaims.UserId).First())?.Value;
carte.UserName = (claims.Where(c => c.Type == JwtClaims.UserName).First())?.Value;
carte.Uid = (claims.Where(c => c.Type == JwtClaims.UtilisateurId).First())?.Value;
}
Utilisateur utilisateur = await _context.Utilisateur.Where(u => u.UserId == carte.UserId).FirstOrDefaultAsync();
if (utilisateur != null)
{
ApplicationUser applicationUser = utilisateur.ApplicationUser;
if (carte.UserName != applicationUser.UserName || carte.Uid != utilisateur.Uid)
{
// fausse carte
return(null);
}
await ComplèteCarteUtilisateur(carte, utilisateur);
}
return(carte);
}
/// <summary>
/// Crée une CarteUtilisateur à partir des Claims envoyées avec une requête Http.
/// Fixe l'Utilisateur de la carte avec son Archives, avec ses Clients incluant leurs Archives et leur Site incluant son Fournisseur
/// et avec ses Fournisseurs incluant leurs Archives et leur Site.
/// </summary>
/// <param name="httpContext">le HttpContext de la requête</param>
/// <returns>la CarteUtilisateur créée, ou null si les Claims ne sont pas valide</returns>
public async Task <CarteUtilisateur> CréeCarteUtilisateur(HttpContext httpContext)
{
CarteUtilisateur carte = new CarteUtilisateur(_context);
ClaimsPrincipal user = httpContext.User;
IEnumerable <Claim> claims = user.Identities.FirstOrDefault()?.Claims;
if (claims == null || claims.Count() == 0)
{
return(carte);
}
string userId = claims.Where(c => c.Type == JwtClaims.UserId).First()?.Value;
string userName = claims.Where(c => c.Type == JwtClaims.UserName).First()?.Value;
string uid = claims.Where(c => c.Type == JwtClaims.UtilisateurId).First()?.Value;
int sessionId = int.Parse(claims.Where(c => c.Type == JwtClaims.SessionId).First()?.Value);
Utilisateur utilisateur = await _context.Utilisateur
.Where(u => u.Id == userId)
.FirstOrDefaultAsync();
if (utilisateur == null)
{
return(carte);
}
if (userName != utilisateur.UserName)
{
// fausse carte
return(carte);
}
await carte.FixeUtilisateur(utilisateur);
carte.SessionId = sessionId;
return(carte);
}
/// <summary>
/// Crée la carte utilisateur définie par le HttpContext.
/// Vérifie que l'utilisateur existe et n'est pas banni et que la session est la même qu'à la connection.
/// Cherche parmi les roles de la carte un role de client ayant la key du client ou à défaut le role du fournisseur du site du client.
/// Vérifie que le role trouvé n'est pas fermé.
/// Fixe le Role de la carte.
/// Met éventuellement à jour le NoDernierRole archivé de l'utilisateur.
/// </summary>
/// <param name="idClient">objet ayant les Uid et Rno du client</param>
/// <returns></returns>
protected async Task <CarteUtilisateur> CréeCarteClientOuFournisseurDeClient(uint idClient, EtatRole[] étatsSitePermis, EtatRole[] étatsClientPermis)
{
CarteUtilisateur carteUtilisateur = await CréeCarteUtilisateur();
if (carteUtilisateur.Erreur != null)
{
return(carteUtilisateur);
}
Client client = carteUtilisateur.Utilisateur.Clients
.Where(c => c.Id == idClient)
.FirstOrDefault();
if (client != null)
{
await FixeClient(carteUtilisateur, client, étatsSitePermis, étatsClientPermis);
return(carteUtilisateur);
}
Fournisseur fournisseur = await carteUtilisateur.FournisseurDeClient(idClient);
if (fournisseur == null)
{
carteUtilisateur.Erreur = NotFound();
return(carteUtilisateur);
}
await FixeFournisseur(carteUtilisateur, fournisseur, étatsSitePermis);
return(carteUtilisateur);
}
/// <summary>
/// Crée la carte utilisateur définie par le HttpContext.
/// Vérifie que l'utilisateur existe et n'est pas banni et que la session est la même qu'à la connection.
/// Cherche parmi les roles de la carte un role de client ayant la key du client ou à défaut un role de fournisseur ayant la key du site
/// Vérifie que le role trouvé n'est pas fermé.
/// Fixe le Role de la carte.
/// Met éventuellement à jour le NoDernierRole archivé de l'utilisateur.
/// </summary>
/// <param name="idClient">Id du client</param>
/// <param name="idSite">Id du site</param>
/// <returns></returns>
protected async Task <CarteUtilisateur> CréeCarteClientDeClientOuFournisseurDeSite(uint idClient, uint idSite, EtatRole[] étatsSitePermis, EtatRole[] étatsClientPermis)
{
CarteUtilisateur carteUtilisateur = await CréeCarteUtilisateur();
if (carteUtilisateur.Erreur != null)
{
return(carteUtilisateur);
}
Client client = carteUtilisateur.Utilisateur.Clients
.Where(c => c.Id == idClient)
.FirstOrDefault();
if (client != null)
{
await FixeClient(carteUtilisateur, client, étatsSitePermis, étatsClientPermis);
return(carteUtilisateur);
}
Fournisseur fournisseur = carteUtilisateur.Utilisateur.Fournisseurs
.Where(f => f.Id == idSite)
.FirstOrDefault();
if (fournisseur == null)
{
carteUtilisateur.Erreur = RésultatInterdit("Ni client ni fournisseur");
return(carteUtilisateur);
}
await FixeFournisseur(carteUtilisateur, fournisseur, étatsSitePermis);
return(carteUtilisateur);
}
public async Task <IActionResult> ActionCommandes([FromQuery] KeyUidRno keyClient, Func <Site, KeyUidRno, List <Commande>, Task <RetourDeService> > action)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
Site site = await _utile.SiteDeClient(keyClient);
if (site == null)
{
return(NotFound());
}
if (!await carte.EstActifEtAMêmeUidRno(site.KeyParam))
{
return(Forbid());
}
List <Commande> commandes = await _service.CommandesLivréesEtNonFacturées(site, keyClient);
if (commandes.Count == 0)
{
Erreurs.ErreurDeModel.AjouteAModelState(ModelState, "PasDeCommandeLivréeEtNonFacturée");
return(BadRequest());
}
RetourDeService retour = await action(site, keyClient, commandes);
return(SaveChangesActionResult(retour));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> Clients([FromQuery] KeyUidRno keySite)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
if (!await carte.EstActifEtAMêmeUidRno(keySite.KeyParam))
{
return(Forbid());
}
Site site = await _utile.SiteDeKey(keySite);
if (site == null)
{
return(NotFound());
}
AFacturer àFacturer = await _service.AFacturer(site);
return(Ok(àFacturer));
}
/// <summary>
/// Ajoute un header contenant le jeton identifiant de la carte à la response d'une requête de connection
/// </summary>
/// <param name="httpResponse"></param>
/// <param name="carte"></param>
/// <returns></returns>
public async Task AjouteCarteAResponse(HttpResponse httpResponse, CarteUtilisateur carte)
{
JwtRéponse jwtRéponse = await _jwtFabrique.CréeReponse(carte);
string header = JsonSerializer.Serialize(jwtRéponse);
httpResponse.Headers.Add(JwtFabrique.NomJwtRéponse, header);
}
private async Task FixeFournisseur(CarteUtilisateur carte, Fournisseur fournisseur, EtatRole[] étatsSitePermis)
{
if (!étatsSitePermis.Contains(fournisseur.Etat))
{
carte.Erreur = RésultatInterdit("EtatSite interdit");
return;
}
carte.Fournisseur = fournisseur;
await carte.ArchiveDernierSite(fournisseur.Id);
}
/// <summary>
/// Vérifie que l'utilisateur est le fournisseur du site
/// </summary>
protected async Task UtilisateurEstFournisseur()
{
CarteUtilisateur carte = await CréeCarteFournisseur(vérificateur.Site.Id, EtatsRolePermis.Actif);
if (carte.Erreur != null)
{
vérificateur.Erreur = carte.Erreur;
throw new VérificationException();
}
}
/// <summary>
/// Vérifie que l'utilisateur est le client du document et que son role est actif ou nouveau
/// </summary>
protected async Task UtilisateurEstClientActifOuNouveau()
{
CarteUtilisateur carte = await CréeCarteClientDeClient(vérificateur.IdClient, EtatsRolePermis.Actif, EtatsRolePermis.PasInactif);
if (carte.Erreur != null)
{
vérificateur.Erreur = carte.Erreur;
throw new VérificationException();
}
}
[ProducesResponseType(403)] // Forbid
public async Task <IActionResult> Session()
{
CarteUtilisateur carte = await CréeCarteUtilisateur();
if (carte.Erreur != null)
{
return(carte.Erreur);
}
return(Ok());
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> Liste()
{
CarteUtilisateur carte = await CréeCarteAdministrateur();
if (carte.Erreur != null)
{
return(carte.Erreur);
}
return(Ok(await UtilisateurService.Lit()));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> Etat([FromQuery] uint idSite)
{
CarteUtilisateur carte = await CréeCarteUsager(idSite, EtatsRolePermis.PasFermé, EtatsRolePermis.PasFermé);
if (carte.Erreur != null)
{
return(carte.Erreur);
}
return(Ok(new ContexteCatalogue(carte.Site)));
}
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);
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> Complet([FromQuery] uint idSite)
{
CarteUtilisateur carteUtilisateur = await CréeCarteFournisseur(idSite, EtatsRolePermis.PasFermé);
if (carteUtilisateur.Erreur != null)
{
return(carteUtilisateur.Erreur);
}
Catalogue catalogue = await _service.Complet(idSite);
return(Ok(catalogue));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> NouveauxDocs()
{
CarteUtilisateur carte = await CréeCarteUtilisateur();
if (carte.Erreur != null)
{
return(carte.Erreur);
}
CLFDocs clfDocs = await _service.NouveauxDocs(carte.Utilisateur);
return(Ok(clfDocs));
}
public async Task <IActionResult> Deconnecte()
{
CarteUtilisateur carte = await CréeCarteUtilisateur();
if (carte.Erreur == null)
{
// ne déconnecte que si l'utilisateur est connecté à sa session en cours
await UtilisateurService.Déconnecte(carte);
}
// dans tous les cas
return(Ok());
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> Disponible([FromQuery] uint idSite)
{
CarteUtilisateur carte = await CréeCarteUsager(idSite, EtatsRolePermis.PasFermé, EtatsRolePermis.PasFermé);
if (carte.Erreur != null)
{
return(carte.Erreur);
}
Catalogue catalogue = await _service.Disponibles(idSite);
return(Ok(catalogue));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> Fournisseurs()
{
CarteUtilisateur carteUtilisateur = await CréeCarteAdministrateur();
if (carteUtilisateur.Erreur != null)
{
return(carteUtilisateur.Erreur);
}
List <FournisseurVue> fournisseurs = await _service.Fournisseurs();
return(Ok(fournisseurs));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> Bilans([FromQuery] uint idSite)
{
// la liste est demandée par le fournisseur
CarteUtilisateur carte = await CréeCarteFournisseur(idSite, EtatsRolePermis.PasFermé);
if (carte.Erreur != null)
{
return(carte.Erreur);
}
List <CLFClientBilanDocs> bilans = await _service.ClientsAvecBilanDocuments(carte.Fournisseur.Site);
return(Ok(bilans));
}
/// <summary>
/// Vérifie que l'utilisateur est le client du document et que son role est actif ou nouveau ou qu'il est le fournisseur du site
/// </summary>
protected async Task UtilisateurEstClientPasFerméOuFournisseur()
{
CarteUtilisateur carte = await CréeCarteClientDeClientOuFournisseurDeSite(vérificateur.IdClient, vérificateur.Site.Id,
EtatsRolePermis.Actif, EtatsRolePermis.PasFermé);
if (carte.Erreur != null)
{
vérificateur.Erreur = carte.Erreur;
throw new VérificationException();
}
vérificateur.EstFournisseur = carte.Fournisseur != null;
vérificateur.EstClient = !vérificateur.EstFournisseur;
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> ListeF([FromQuery] ParamsFiltreDoc paramsFiltre)
{
// la liste est demandée par le fournisseur, paramsFiltre a la clé du site
CarteUtilisateur carte = await CréeCarteFournisseur(paramsFiltre.Id, EtatsRolePermis.PasFermé);
if (carte.Erreur != null)
{
return(carte.Erreur);
}
CLFDocs clfDocs = await _service.Résumés(paramsFiltre, carte.Fournisseur.Site);
return(Ok(clfDocs));
}
