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)); }