Example #1
0
 private async Task ValideAjoute(Client donnée, ModelStateDictionary modelState)
 {
     if (await NomPris(donnée.Nom))
     {
         ErreurDeModel.AjouteAModelState(modelState, "nom", "nomPris");
     }
 }
Example #2
0
 private async Task ValideEdite(Catégorie donnée, ModelStateDictionary modelState)
 {
     if (await NomPrisParAutre(donnée.Id, donnée.Nom))
     {
         ErreurDeModel.AjouteAModelState(modelState, "nom", "nomPris");
     }
 }
 private void VérifieEtatSiteCommence(Site site)
 {
     if (site.Etat != TypeEtatSite.Ouvert)
     {
         ErreurDeModel.AjouteAModelState(ModelState, "EtatSiteIncorrect");
     }
 }
 private void VérifieEtatSiteTermine(Site site)
 {
     if (site.Etat != TypeEtatSite.Livraison)
     {
         ErreurDeModel.AjouteAModelState(ModelState, "EtatSiteIncorrect");
     }
 }
 private async Task ValideAjoute(Fournisseur donnée, ModelStateDictionary modelState)
 {
     if (await NomPris(donnée.Nom))
     {
         ErreurDeModel.AjouteAModelState(modelState, "nom", "nomPris");
     }
     await _siteService.DValideAjoute()(donnée.Site, modelState);
 }
 private bool VérifiePrix(Produit donnée, ModelStateDictionary modelState)
 {
     string erreur = PrixProduitDef.Vérifie(donnée.Prix);
     if (erreur == null)
     {
         return true;
     }
     ErreurDeModel.AjouteAModelState(modelState, "prix", erreur);
     return false;
 }
 private async Task ValideSupprime(Produit donnée, ModelStateDictionary modelState)
 {
     bool avecCommandes = await _context.Lignes
         .Where(l => l.ProduitId == donnée.Id)
         .AnyAsync();
     if (avecCommandes)
     {
         ErreurDeModel.AjouteAModelState(modelState, "supprime");
     }
 }
        private async Task <Livraison> LivraisonDeCommence(Site site)
        {
            Livraison livraison = await _utile.DernièreLivraison(site);

            if (livraison != null && !livraison.Date.HasValue)
            {
                ErreurDeModel.AjouteAModelState(ModelState, "DernièreLivraisonPasTerminée");
            }
            return(livraison);
        }
 private bool VérifieTypeUnités(Produit donnée, ModelStateDictionary modelState)
 {
     bool valide = donnée.TypeCommande == TypeCommande.Unité ? donnée.TypeMesure == TypeMesure.Aucune : donnée.TypeMesure != TypeMesure.Aucune;
     if (valide)
     {
         return true;
     }
     ErreurDeModel.AjouteAModelState(modelState, "typesMesureEtCommande");
     return false;
 }
Example #10
0
        private async Task ValideSupprime(Catégorie donnée, ModelStateDictionary modelState)
        {
            bool avecProduits = await _context.Produit
                                .Where(p => donnée.Id == p.CategorieId)
                                .AnyAsync();

            if (avecProduits)
            {
                ErreurDeModel.AjouteAModelState(modelState, "nonVide");
            }
        }
Example #11
0
        private async Task ValideSupprime(Client donnée, ModelStateDictionary modelState)
        {
            bool avecDocs = await _context.Docs
                            .Where(doc => donnée.Id == doc.Id)
                            .AnyAsync();

            if (avecDocs)
            {
                ErreurDeModel.AjouteAModelState(modelState, "nonVide");
            }
        }
        private async Task <Livraison> LivraisonDeAnnule(Site site)
        {
            Livraison livraison = await _utile.DernièreLivraison(site);

            if (livraison == null || livraison.Date.HasValue)
            {
                ErreurDeModel.AjouteAModelState(ModelState, "PasDeDernièreLivraisonOuTerminée");
                return(null);
            }
            return(livraison);
        }
Example #13
0
 private async Task ValideEdite(Site site, ModelStateDictionary modelState)
 {
     if (await UrlPriseParAutre(site.Id, site.Url))
     {
         ErreurDeModel.AjouteAModelState(modelState, "Url", "nomPris");
     }
     if (await TitrePrisParAutre(site.Id, site.Titre))
     {
         ErreurDeModel.AjouteAModelState(modelState, "titre", "nomPris");
     }
 }
Example #14
0
 private async Task ValideAjoute(Produit donnée, ModelStateDictionary modelState)
 {
     if (VérifieTypeUnités(donnée, modelState))
     {
         if (VérifiePrix(donnée, modelState))
         {
             if (await NomPris(donnée.Id, donnée.Nom))
             {
                 ErreurDeModel.AjouteAModelState(modelState, "nom", "nomPris");
             }
         }
     }
 }
        [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> Connecte([FromBody] ConnectionVue connection)
        {
            ApplicationUser user = await _service.ApplicationUserVérifié(connection.UserName, connection.Password);

            if (user == null)
            {
                ErreurDeModel erreur = new ErreurDeModel
                {
                    Code        = "identifiants",
                    Description = "Nom ou mot de passe invalide"
                };
                erreur.AjouteAModelState(ModelState);
                return(BadRequest(ModelState));
            }

            return(await Connecte(user, connection.Persistant));
        }
        private async Task <Livraison> LivraisonDeTerminer(Site site)
        {
            Livraison livraison = await _utile.DernièreLivraison(site);

            if (livraison == null || livraison.Date.HasValue)
            {
                ErreurDeModel.AjouteAModelState(ModelState, "PasDeDernièreLivraisonOuTerminée");
                return(null);
            }
            bool estPrête = await _service.EstPrête(livraison);

            if (!estPrête)
            {
                ErreurDeModel.AjouteAModelState(ModelState, "LivraisonPasPrête");
                return(null);
            }
            return(livraison);
        }
Example #18
0
        protected async Task <RetourDeService <Utilisateur> > CréeUtilisateur(ICréeCompteVue vue)
        {
            RetourDeService <Utilisateur> retour = await UtilisateurService.CréeUtilisateur(vue);

            if (retour.Type == TypeRetourDeService.IdentityError)
            {
                IEnumerable <IdentityError> errors = (IEnumerable <IdentityError>)retour.Objet;
                foreach (IdentityError error in errors)
                {
                    if (error.Code == IdentityErrorCodes.DuplicateUserName)
                    {
                        ErreurDeModel.AjouteAModelState(ModelState, "email", "nomPris");
                    }
                    else
                    {
                        ErreurDeModel.AjouteAModelState(ModelState, error.Code);
                    }
                }
            }
            return(retour);
        }
Example #19
0
 /// <summary>
 /// modèle des erreurs BadRequest
 /// </summary>
 /// <param name="code">nom du validateur du formulaire</param>
 /// <returns></returns>
 protected IActionResult RésultatBadRequest(string code)
 {
     ErreurDeModel.AjouteAModelState(ModelState, code);
     return(BadRequest(ModelState));
 }
Example #20
0
 /// <summary>
 /// Marque dans le ModelState une ErreurDeModel Vide pour la propriété de type string.
 /// </summary>
 /// <param name="nomPropriété">nom de la propriété de type string qui a une valeur vide alors qu'il ne le faut pas.</param>
 private void QuandStringVide(string nomPropriété)
 {
     ErreurDeModel.AjouteAModelState(ModelState, nomPropriété, "Vide");
 }
Example #21
0
 /// <summary>
 /// Marque dans le ModelState une ErreurDeModel Null pour la propriété.
 /// </summary>
 /// <param name="nomPropriété">nom de la propriété qui a une valeur nulle alors qu'il ne le faut pas.</param>
 private void QuandNull(string nomPropriété)
 {
     ErreurDeModel.AjouteAModelState(ModelState, nomPropriété, "Null");
 }