[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> CopieDemP([FromQuery] KeyUidRnoNo keyProduit)
{
CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);
if (carte == null)
{
return(Forbid());
}
Site site = await _utile.SiteDeKeyProduitOuLivraison(keyProduit);
if (site == null)
{
return(NotFound());
}
bool estFournisseur = await carte.EstActifEtAMêmeUidRno(site.KeyParam);
if (!estFournisseur)
{
return(Forbid());
}
RetourDeService retour = await _service.CopieDemandes(site, keyProduit);
if (retour == null)
{
return(RésultatBadRequest("RienACopier"));
}
return(SaveChangesActionResult(retour));
}
/// <summary>
/// retourne la livraison définie par la clé
/// </summary>
/// <param name="keyLivraison"></param>
/// <returns>null si non trouvé</returns>
private async Task <Livraison> LivraisonDeKey(KeyUidRnoNo keyLivraison)
{
Livraison livraison = await _context.Livraison
.Where(l => l.Uid == keyLivraison.Uid && l.Rno == keyLivraison.Rno)
.FirstOrDefaultAsync();
return(livraison);
}
public async Task <AKeyUidRnoNo> Facture(AKeyUidRno keySite, KeyUidRnoNo keyDocument)
{
Func <Commande, bool> filtreCommandes = c => c.Uid == keyDocument.Uid && c.Rno == keyDocument.Rno;
Func <DétailCommande, bool> filtreDétails = d => d.AFacturer.HasValue && d.AFacturer.Value > 0;
List <Commande> commandes = await _utile.CommandesAvecDétailsLivraisonEtFacture(filtreCommandes, filtreDétails, null, null)
.Where(c => c.Livraison != null && c.Livraison.Facture != null && c.Livraison.Facture.No == keyDocument.No && c.Livraison.Facture.Date.HasValue)
.ToListAsync();
if (commandes.Count() == 0)
{
return(null);
}
List <DocumentCommande> documents = await DocumentCommandes(keySite, commandes, filtreDétails, avecDétails : true);
return(DocumentsFactureTarif(commandes, documents).First());
}
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));
}
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));
}
public async Task <AKeyUidRnoNo> Commande(AKeyUidRno keySite, KeyUidRnoNo keyDocument)
{
bool filtreCommandes(Commande c) => c.Uid == keyDocument.Uid && c.Rno == keyDocument.Rno && c.No == keyDocument.No;
bool filtreDétails(DétailCommande d) => d.Demande.HasValue;
List <Commande> commandes = await _utile.CommandesAvecDétailsLivraisonEtFacture(filtreCommandes, filtreDétails, null, null).ToListAsync();
if (commandes.Count() == 0)
{
return(null);
}
DocumentCommande commande = (await DocumentCommandes(keySite, commandes, filtreDétails, avecDétails: true)).First();
commande.Détails = commande.Détails.Select(d => new DétailCommandeData
{
No = d.No,
TypeCommande = d.TypeCommande,
Demande = d.Demande
}).ToList();
return(commande);
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> AnnuleCommande([FromQuery] KeyUidRnoNo keyCommande)
{
Task <RetourDeService> action(Commande commande) => _service.AnnuleCommande(commande);
return(await ActionCommande(keyCommande, action));
}
/// <summary>
/// Copie Demande dans AServir pour tous les DétailCommande demandant le produit dont la demande est copiable
/// </summary>
/// <param name="site"></param>
/// <param name="keyProduit"></param>
/// <returns>null s'il n'y a pas de détails copiables</returns>
public async Task <RetourDeService> CopieDemandes(Site site, KeyUidRnoNo keyProduit)
{
return(await CopieDemandes(site, filtreClient : null, filtreProduit : p => p.No == keyProduit.No, filtreDétail : null));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> Facture([FromQuery] KeyUidRnoNo keyDocument)
{
return(await Document(keyDocument, (Site site, KeyUidRnoNo key) => _service.Facture(site, key)));
}
