private async Task ValideAjoute(Client donnée, ModelStateDictionary modelState)
{
if (await NomPris(donnée.Nom))
{
ErreurDeModel.AjouteAModelState(modelState, "nom", "nomPris");
}
}
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;
}
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");
}
}
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);
}
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");
}
}
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);
}
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);
}
protected async Task <IActionResult> Connecte(ApplicationUser user, bool persistant)
{
CarteUtilisateur carteUtilisateur = await _service.CréeCarteUtilisateur(user);
if (!carteUtilisateur.EstUtilisateurActif)
{
ErreurDeModel erreur = new ErreurDeModel
{
Code = "etatUtilisateur",
Description = "Cet utilisateur n'est pas autorisé"
};
return(StatusCode(403, erreur));
}
JwtRéponse jwtRéponse = await _jwtFabrique.CréeReponse(carteUtilisateur);
Request.HttpContext.Response.Headers.Add(JwtFabrique.NomJwtRéponse, JsonConvert.SerializeObject(jwtRéponse));
await _service.Connecte(user, persistant);
return(new OkObjectResult(carteUtilisateur));
}
/// <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));
}
/// <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");
}
/// <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");
}
