[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)); }
public async Task <RetourDeService <DemandeSite> > Ajoute(FournisseurAAjouter ajout) { Fournisseur fournisseur = new Fournisseur(); Fournisseur.CopieData(ajout, fournisseur); fournisseur.Site = new Site(); Site.CopieData(ajout.Site, fournisseur.Site); DateTime date = DateTime.Now; RetourDeService <Fournisseur> retourFournisseur = await base.Ajoute(fournisseur, date); RetourDeService <DemandeSite> retour; if (!retourFournisseur.Ok) { return(new RetourDeService <DemandeSite>(retourFournisseur)); } fournisseur = retourFournisseur.Entité; DemandeSite demande = new DemandeSite { Email = ajout.Email, Id = fournisseur.Id, Date = date }; _context.DemandeSite.Add(demande); retour = await SaveChangesAsync <DemandeSite>(demande); if (retour.Ok) { retour.Entité.Fournisseur = fournisseur; } return(retour); }
[ProducesResponseType(409)] // Conflict public async Task <IActionResult> Edite([FromQuery] ParamsVide paramsLigne, CLFLigne ligne) { vérificateur.Initialise(ligne, paramsLigne); try { await ClientDeLAction(); await UtilisateurEstClientActifOuNouveauOuFournisseur(); ContexteCatalogue(); await LigneExiste(); DocModifiable(); await PeutCommanderProduit(); ChampsInterditsAbsents(); ChampsPrésentsValides(); } catch (VérificationException) { return(vérificateur.Erreur); } RetourDeService retour = await _service.EditeLigne(vérificateur.LigneCLF, ligne); return(SaveChangesActionResult(retour)); }
[ProducesResponseType(409)] // Conflict public async Task <IActionResult> CopieBon([FromQuery] ParamsCréeCommande paramsCrée) { Vérificateur vérificateur = new Vérificateur(paramsCrée); await vérificateur.Vérifie( ClientDeLAction, UtilisateurEstClientOuFournisseur, EtatSiteChangé, DerniereCommandePrésenteEtEnvoyée ); if (vérificateur.Erreur != null) { return(vérificateur.Erreur); } long noCommande = vérificateur.DernièreCommande == null ? 1 : vérificateur.DernièreCommande.No + 1; RetourDeService <Commande> retour = await _service.AjouteCommande(vérificateur.KeyClient, noCommande, vérificateur.Site, vérificateur.EstFournisseur); if (retour.Ok) { await _détailCommandeService.AjouteCopiesDétails(vérificateur.DernièreCommande); } return(SaveChangesActionResult(retour)); }
[ProducesResponseType(409)] // Conflict public async Task <IActionResult> Ajoute([FromQuery] ParamsEditeDétail paramsDétail, DétailCommandeVue vue) { Vérificateur vérificateur = new Vérificateur(vue, paramsDétail); await vérificateur.Vérifie( ClientDeLAction, UtilisateurEstClientOuFournisseur, EtatSiteChangé, CommandeExiste, DétailNExistePas, CommandeModifiable, PeutCommanderProduit, ChampsInterditsAbsents, ChampsRequisPrésents, ChampsPrésentsValides ); if (vérificateur.Erreur != null) { return(vérificateur.Erreur); } RetourDeService <DétailCommande> retour = await _détailCommandeService.Ajoute(vue); if (retour.Ok) { return(CreatedAtAction(nameof(LitDétail), vérificateur.KeyDétail, retour.Entité)); } return(SaveChangesActionResult(retour)); }
public async Task <IActionResult> Supprime([FromQuery] ParamsSupprimeLigne paramsSupprime) { vérificateur.Initialise(paramsSupprime); try { await ClientDeLAction(); await UtilisateurEstClientActifOuNouveauOuFournisseur(); ContexteCatalogue(); await DocExiste(); DocModifiable(); // vérifie que la ligne commandant le produit dont le No est le No2 du paramétre existe et fixe vérificateur.LigneCLF LigneCLF ligne = vérificateur.DocCLF.Lignes.Where(l => l.ProduitId == paramsSupprime.ProduitId).FirstOrDefault(); if (ligne == null) { return(NotFound()); } vérificateur.LigneCLF = ligne; } catch (VérificationException) { return(vérificateur.Erreur); } RetourDeService retour = await _service.SupprimeLigne(vérificateur.LigneCLF); return(SaveChangesActionResult(retour)); }
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)); }
protected async Task <IActionResult> Fixe(ParamsFixeLigne paramsFixeLigne) { vérificateur.Initialise(paramsFixeLigne); try { await ClientDeLAction(); await UtilisateurEstFournisseur(); ContexteCatalogue(); await LigneExiste(); DocEstASynthétiser(); string code = QuantitéDef.Vérifie(paramsFixeLigne.AFixer); if (code != null) { vérificateur.Erreur = RésultatBadRequest("aFixer", code); throw new VérificationException(); } } catch (VérificationException) { return(vérificateur.Erreur); } RetourDeService retour = await _service.FixeLigne(vérificateur.LigneCLF, paramsFixeLigne.AFixer); return(SaveChangesActionResult(retour)); }
/// <summary> /// Exécute une action sur chaque ligne des documents d'un client dont le No est dans une liste. /// Retourne une erreur si l'un des documents n'est pas à synthétiser. /// </summary> /// <param name="paramsSynthèse">contient l'Id du client et la liste des No des documents à synthétiser</param> /// <param name="action">retourne null si l'action est impossible</param> /// <returns></returns> protected async Task <IActionResult> Action(ParamsSynthèse paramsSynthèse, Func <List <DocCLF>, Task <RetourDeService> > action) { vérificateur.Initialise(paramsSynthèse.Id); try { await ClientDeLAction(); await UtilisateurEstFournisseur(); ContexteCatalogue(); } catch (VérificationException) { return(vérificateur.Erreur); } // Lit la liste des documents synthétisables dont le No est dans la liste. List <DocCLF> docs = await _service.DocumentsEnvoyésSansSynthèse(paramsSynthèse, DocCLF.TypeBon(_type)); if (docs.Count != paramsSynthèse.NoDocs.Count) { // L'un des No de la liste ne correspond pas à un document synthétisable. return(RésultatBadRequest("DocumentsPasEnvoyésOuAvecSynthèse")); } RetourDeService retour = await action(docs); return(SaveChangesActionResult(retour)); }
/// <summary> /// retourne la Commande ouverte (sans date) d'un client /// crée une nouvelle Commande s'il n'y en a pas d'ouvertes /// </summary> /// <param name="keyClient"></param> /// <returns></returns> public async Task <Commande> Ouverte(AKeyUidRno keyClient) { Commande commande = await _context.Commande .Where(c => c.Uid == keyClient.Uid && c.Rno == keyClient.Rno) .LastOrDefaultAsync(); long no = 1; if (commande != null) { if (commande.Date != null) { no = commande.No + 1; } commande = null; } if (commande == null) { commande = new Commande { Uid = keyClient.Uid, Rno = keyClient.Rno, No = no, }; _context.Commande.Add(commande); RetourDeService retour = await SaveChangesAsync(commande); if (!retour.Ok) { return(null); } } return(commande); }
/// <summary> /// Crée un Client avec son Utilisateur. /// </summary> /// <param name="vue">PeupleClientVue définissant le Client à créer</param> /// <param name="peupleId">PeupleId contenant les Id des derniers objets créés</param> /// <returns></returns> private async Task <RetourDeService> AjouteClient(PeupleClientVue vue, PeupleId peupleId) { uint id = peupleId.Client + 1; RetourDeService <Utilisateur> retourUtilisateur = await _utilisateurService.CréeUtilisateur(vue); if (!retourUtilisateur.Ok) { return(retourUtilisateur); } Utilisateur utilisateur = retourUtilisateur.Entité; await _utilisateurService.ConfirmeEmailDirect(utilisateur); Client client = new Client { Id = id, UtilisateurId = utilisateur.Id, SiteId = peupleId.Fournisseur, Etat = EtatRole.Nouveau }; Role.CopieData(vue, client); RetourDeService retour = await _clientService.Ajoute(client); if (retour.Ok) { peupleId.Client = id; } return(retour); }
[ProducesResponseType(409)] // Conflict public async Task <IActionResult> Envoi([FromQuery] ParamsKeyClient paramsClient) { vérificateur.Initialise(paramsClient); try { await ClientDeLAction(); await UtilisateurEstClientActifOuNouveau(); ContexteCatalogue(); } catch (VérificationException) { return(vérificateur.Erreur); } DocCLF dernièreCommande = await _service.DernierDoc(paramsClient.Id, TypeCLF.Commande); // la dernière commande doit exister et ne pas être envoyée if (dernièreCommande == null || dernièreCommande.Date.HasValue) { return(RésultatBadRequest("DerniereCommandeAbsenteOuEnvoyée")); } RetourDeService <CLFDoc> retour = await _service.EnvoiCommande(vérificateur.Site, dernièreCommande); if (retour.Ok) { return(RésultatCréé(retour.Entité)); } return(SaveChangesActionResult(retour)); }
public async Task <RetourDeService> Ferme(KeyUidRno key, DateTime jusquA) { Site site = await LitSite(key); if (site.Etat != TypeEtatSite.Actif && site.Etat != TypeEtatSite.Inactif) { return(new RetourDeService <Site>(TypeRetourDeService.Ok)); } DateTime maintenant = DateTime.Now; string type; DateTime?date; if (jusquA < maintenant) { type = TypeEtatSite.Inactif; date = null; } else { type = TypeEtatSite.Actif; date = jusquA; } if (site.Etat != type || site.DateEtat != date) { site.Etat = type; site.DateEtat = date; _context.Site.Update(site); EtatSite etat = new EtatSite { Uid = key.Uid, Rno = key.Rno, Etat = type, DateEtat = date, Date = maintenant }; _context.EtatSite.Add(etat); } RetourDeService retour = await SaveChangesAsync(); if (retour.Ok) { List <Commande> commandes = await _context.Commande .Where(c => c.Date == null && c.LivraisonUid == key.Uid && c.LivraisonRno == key.Rno) .ToListAsync(); if (commandes.Count > 0) { commandes.ForEach(c => { c.Etat = TypeEtatCommande.Accepté; _context.Commande.Update(c); }); retour = await SaveChangesAsync(); } } return(retour); }
public async Task <IActionResult> Peuple() { if (await _peupleService.EstPeuplé()) { return(BadRequest()); } RetourDeService retour = await _peupleService.Peuple(); return(SaveChangesActionResult(retour)); }
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)); }
public async Task <RetourDeService> Peuple() { PeupleId peupleId = new PeupleId(); RetourDeService retour = await AjouteAdministrateur(); // Crée les fournisseurs: Utilisateur, Fournisseur, Site for (int i = 0; i < PeuplementUtilisateurs.Fournisseurs.Length && retour.Ok; i++) { PeupleFournisseurVue vue = PeuplementUtilisateurs.Fournisseurs[i]; retour = await AjouteFournisseur(vue, peupleId); } return(retour); }
/// <summary> /// Crée l'administrateur. /// </summary> /// <returns></returns> private async Task <RetourDeService> AjouteAdministrateur() { CréeCompteVue vue = new CréeCompteVue { Email = "*****@*****.**", Password = "******" }; RetourDeService <Utilisateur> retourUtilisateur = await _utilisateurService.CréeUtilisateur(vue); if (retourUtilisateur.Ok) { await _utilisateurService.ConfirmeEmailDirect(retourUtilisateur.Entité); } return(retourUtilisateur); }
[ProducesResponseType(409)] // Conflict public async Task <IActionResult> CopieDemC([FromQuery] KeyUidRno keyClient) { Vérificateur vérificateur = new Vérificateur { KeyClient = keyClient }; await vérificateur.Vérifie( ClientDeLAction, UtilisateurEstFournisseur, DétailExiste, ALivrerModifiable ); if (vérificateur.Erreur != null) { return(vérificateur.Erreur); } CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User); if (carte == null) { return(Forbid()); } Site site = await _utile.SiteDeClient(keyClient); if (site == null) { return(NotFound()); } bool estFournisseur = await carte.EstActifEtAMêmeUidRno(site.KeyParam); if (!estFournisseur) { return(Forbid()); } RetourDeService retour = await _service.CopieDemandes(site, keyClient); if (retour == null) { return(RésultatBadRequest("RienACopier")); } return(SaveChangesActionResult(retour)); }
[ProducesResponseType(409)] // Conflict public async Task <IActionResult> Commence([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)) { // pas le fournisseur return(Forbid()); } Site site = await _utile.SiteDeKey(keySite); if (site == null) { return(NotFound()); } if (site.Etat != TypeEtatSite.Ouvert) { ErreurDeModel.AjouteAModelState(ModelState, "EtatSiteIncorrect"); return(BadRequest(ModelState)); } Livraison livraison = await _utile.DernièreLivraison(site); if (livraison != null && !livraison.Date.HasValue) { ErreurDeModel.AjouteAModelState(ModelState, "DernièreLivraisonPasTerminée"); } await _service.CommenceLivraison(site); RetourDeService retour = await _siteService.ChangeEtat(site, TypeEtatSite.Livraison); if (retour.Ok) { return(Ok(await _service.VueDesCommandesOuvertesDesClientsAvecCompte(site))); } return(SaveChangesActionResult(retour)); }
public async Task <IActionResult> Edite(TVue vue) { CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User); if (carte == null) { // fausse carte return(Forbid()); } if (dEditeEstPermis == null || !(await dEditeEstPermis(carte, vue.KeyParam))) { return(Forbid()); } T nouveau = __service.CréeDonnée(vue); if (dEcritVerrouillé != null && await dEcritVerrouillé(carte, nouveau)) { return(Conflict()); } DValideEdite <T> dValideEdite = __service.DValideEdite(); if (dValideEdite != null) { await dValideEdite(nouveau, ModelState); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } } T donnée = await __service.Lit(vue.KeyParam as TParam); if (donnée == null) { return(NotFound()); } RetourDeService <T> retour = await __service.Edite(donnée, nouveau); return(SaveChangesActionResult(retour)); }
public async Task <IActionResult> Ajoute(TVue vue) { CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User); if (carte == null) { // fausse carte return(Forbid()); } if (dAjouteEstPermis == null || !(await dAjouteEstPermis(carte, vue.KeyParamParent))) { return(Forbid()); } await FixeKeyParamAjout(vue); T donnée = __service.CréeDonnée(vue); if (dEcritVerrouillé != null && await dEcritVerrouillé(carte, donnée)) { return(Conflict()); } DValideAjoute <T> dValideAjoute = __service.DValideAjoute(); if (dValideAjoute != null) { await dValideAjoute(donnée, ModelState); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } } RetourDeService <T> retour = await __service.Ajoute(donnée); if (retour.Ok) { return(CreatedAtAction(nameof(Lit), vue.TexteKey, vue)); } return(SaveChangesActionResult(retour)); }
public async Task <IActionResult> Ajoute([FromBody] CréeCompteVue vue) { RetourDeService <Utilisateur> retour = await CréeUtilisateur(vue); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (retour.Type != TypeRetourDeService.Ok) { return(SaveChangesActionResult(retour)); } // envoie un mail contenant le lien de confirmation await UtilisateurService.EnvoieEmailConfirmeCompte(retour.Entité); return(Ok()); }
[ProducesResponseType(409)] // Conflict public async Task <IActionResult> Detail(DétailCommandeVue vue) { CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User); if (carte == null) { // fausse carte return(Forbid()); } KeyUidRno keySite = new KeyUidRno { Uid = vue.Uid2, Rno = vue.Rno }; if (!await carte.EstActifEtAMêmeUidRno(keySite.KeyParam)) { return(Forbid()); } Commande commande = await _service.CommandeDeDétail(vue); if (commande == null) { return(NotFound()); } if (!(await _service.EstDansSynthèseEnvoyée(commande))) { Erreurs.ErreurDeModel.AjouteAModelState(ModelState, "CommandeLivréeEtNonFacturée"); return(BadRequest()); } DétailCommande détail = await _service.LitDétail(vue); if (détail == null) { return(NotFound()); } RetourDeService retour = await _service.EcritDétail(détail, vue); return(SaveChangesActionResult(retour)); }
[ProducesResponseType(409)] // Conflict public async Task <IActionResult> Nouveau([FromQuery] ParamsCréeCommande paramsCrée) { Vérificateur vérificateur = new Vérificateur(paramsCrée); await vérificateur.Vérifie( ClientDeLAction, UtilisateurEstClientOuFournisseur, EtatSiteChangé, DerniereCommandeAbsenteOuEnvoyée ); if (vérificateur.Erreur != null) { return(vérificateur.Erreur); } long noCommande = vérificateur.DernièreCommande == null ? 1 : vérificateur.DernièreCommande.No + 1; RetourDeService retour = await _service.AjouteCommande(vérificateur.KeyClient, noCommande, vérificateur.Site, vérificateur.EstFournisseur); return(SaveChangesActionResult(retour)); }
[ProducesResponseType(409)] // Conflict public async Task <IActionResult> Supprime([FromQuery] ParamsSupprimeDétail paramsDétail) { Vérificateur vérificateur = new Vérificateur(paramsDétail); await vérificateur.Vérifie( ClientDeLAction, UtilisateurEstClientOuFournisseur, EtatSiteChangé, DétailExiste, CommandeModifiable ); if (vérificateur.Erreur != null) { return(vérificateur.Erreur); } RetourDeService retour = await _détailCommandeService.Supprime(vérificateur.Détail); return(SaveChangesActionResult(retour)); }
[ProducesResponseType(409)] // Conflict public async Task <IActionResult> Edite(CLFLigne clfLigne) { vérificateur.Initialise(clfLigne); try { await ClientDeLAction(); await UtilisateurEstFournisseur(); await LigneExiste(); DocEstASynthétiser(); } catch (VérificationException) { return(vérificateur.Erreur); } RetourDeService retour = await _service.EditeLigne(vérificateur.LigneCLF, clfLigne); return(SaveChangesActionResult(retour)); }
/// <summary> /// Crée un Client sans Utilisateur. /// </summary> /// <param name="peupleId">PeupleId contenant les Id des derniers objets créés</param> /// <returns></returns> private async Task <RetourDeService> AjouteClient(PeupleId peupleId) { uint id = peupleId.Client + 1; Client client = new Client { Id = id, SiteId = peupleId.Fournisseur, Nom = "Client" + id, Adresse = "Adresse" + id, Ville = "Ville" + id, Etat = EtatRole.Actif }; RetourDeService retour = await _clientService.Ajoute(client); if (retour.Ok) { peupleId.Client = id; } return(retour); }
public async Task <IActionResult> ActionCommande([FromQuery] KeyUidRnoNo keyCommande, Func <Commande, Task <RetourDeService> > action) { CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User); if (carte == null) { // fausse carte return(Forbid()); } KeyUidRno keyClient = new KeyUidRno { Uid = keyCommande.Uid, Rno = keyCommande.Rno }; Site site = await _utile.SiteDeClient(keyClient); if (site == null) { return(NotFound()); } if (!await carte.EstActifEtAMêmeUidRno(site.KeyParam)) { return(Forbid()); } Commande commande = await _service.LitCommande(keyCommande); if (commande == null) { return(NotFound()); } if (!(await _service.EstDansSynthèseEnvoyée(commande))) { Erreurs.ErreurDeModel.AjouteAModelState(ModelState, "CommandeLivréeEtNonFacturée"); } RetourDeService retour = await action(commande); return(SaveChangesActionResult(retour)); }
/// <summary> /// modèle de vérification pour exécuter une action du fournisseur /// </summary> /// <param name="keyOuVueCommande"></param> /// <param name="action"></param> /// <returns></returns> private async Task <IActionResult> ActionFournisseur(AKeyUidRno keySite, DVérifieEtatSite vérifieEtatSite, DLivraisonDeLAction livraisonDeLAction, DActionLivraison actionLivraison) { CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User); if (carte == null) { // fausse carte return(Forbid()); } if (!await carte.EstActifEtAMêmeUidRno(keySite.KeyParam)) { // pas le fournisseur return(Forbid()); } Site site = await _utile.SiteDeKey(keySite); if (site == null) { return(NotFound()); } vérifieEtatSite(site); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } Livraison livraison = await livraisonDeLAction(site); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } RetourDeService retour = await actionLivraison(site, livraison); return(SaveChangesActionResult(retour)); }