/// <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(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));
}
[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> 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));
}
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(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));
}
[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));
}
[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));
}
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));
}
private async Task <IActionResult> Document(KeyUidRnoNo keyDocument, Func <Site, KeyUidRnoNo, Task <AKeyUidRnoNo> > litDocument)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
KeyUidRno keyClient = new KeyUidRno
{
Uid = keyDocument.Uid,
Rno = keyDocument.Rno
};
Site site = await _utile.SiteDeClient(keyClient);
if (site == null)
{
return(NotFound());
}
if (!await carte.EstActifEtAMêmeUidRno(site.KeyParam))
{
// l'utilisateur n'est pas le fournisseur
if (!carte.EstClient(site))
{
return(Forbid());
}
}
AKeyUidRnoNo document = await litDocument(site, keyDocument);
if (document == null)
{
return(NotFound());
}
return(Ok(document));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> AvecCompte([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());
}
return(Ok(await _service.VueDesCommandesOuvertesDesClientsAvecCompte(site)));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> EnCours([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());
}
return(Ok(await _service.LivraisonVueEnCours(site)));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> EnCours([FromQuery] KeyUidRno keyClient)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
// fausse carte
return(Forbid());
}
if (!await carte.EstActifEtAMêmeUidRno(keyClient.KeyParam))
{
return(Forbid());
}
CommandeVue commandeVue = await _service.EnCours(keyClient);
if (commandeVue == null)
{
return(NotFound());
}
return(Ok(commandeVue));
}