private async Task <IActionResult> Document(KeyDocSansType keyDocSansType, TypeCLF type)
{
if (keyDocSansType is null)
{
throw new System.ArgumentNullException(nameof(keyDocSansType));
}
vérificateur.Initialise(keyDocSansType);
try
{
await ClientDeLAction();
await UtilisateurEstClientPasFerméOuFournisseur();
}
catch (VérificationException)
{
return(vérificateur.Erreur);
}
CLFDocs document = await _service.Document(vérificateur.Site, keyDocSansType, type);
if (document == null)
{
return(NotFound());
}
return(Ok(document));
}
/// <summary>
/// Exécute une action sur chaque ligne du document défini par la clé. Retourne une erreur s'il n'y a pas de ligne où l'action est possible.
/// </summary>
/// <param name="keyDocSansType"></param>
/// <param name="action">retourne null si l'action est impossible</param>
/// <returns></returns>
protected async Task <IActionResult> Action(KeyDocSansType keyDocSansType, Func <DocCLF, Task <RetourDeService> > action)
{
vérificateur.Initialise(keyDocSansType);
try
{
await ClientDeLAction();
await UtilisateurEstFournisseur();
ContexteCatalogue();
await DocExiste();
DocEstASynthétiser();
}
catch (VérificationException)
{
return(vérificateur.Erreur);
}
RetourDeService retour = await action(vérificateur.DocCLF);
return(SaveChangesActionResult(retour));
}
/// <summary>
///
/// </summary>
/// <param name="paramsClient"></param>
/// <param name="copieLignes"></param>
/// <returns></returns>
protected async Task <IActionResult> CréeBon(ParamsKeyClient paramsClient, bool copieLignes)
{
vérificateur.Initialise(paramsClient);
try
{
await ClientDeLAction();
await UtilisateurEstClientActifOuNouveauOuFournisseur();
ContexteCatalogue();
}
catch (VérificationException)
{
return(vérificateur.Erreur);
}
uint noBon;
DocCLF docACopier = null;
if (vérificateur.EstClient)
{
if (_type != TypeCLF.Commande)
{
return(RésultatInterdit("Un client ne peut créer que des bons de commande."));
}
DocCLF dernièreCommande = await _service.DernierDoc(vérificateur.IdClient, TypeCLF.Commande);
if (copieLignes)
{
// la dernière commande doit exister et être envoyée
if (dernièreCommande == null || !dernièreCommande.Date.HasValue)
{
return(RésultatBadRequest("DerniereCommandeAbsenteOuPasEnvoyée"));
}
docACopier = dernièreCommande;
}
else
{
// la dernière commande doit ne pas exister ou être envoyée.
if (!(dernièreCommande == null || dernièreCommande.Date.HasValue))
{
return(RésultatBadRequest("DerniereCommandePrésenteEtPasEnvoyée"));
}
}
noBon = dernièreCommande == null ? 1 : dernièreCommande.No + 1;
}
else
{
// key du bon virtuel du client
KeyDocSansType key = new KeyDocSansType
{
Id = vérificateur.IdClient,
No = 0
};
DocCLF bonVirtuel = await _service.DocCLFDeKey(key, _type);
if (bonVirtuel != null)
{
// il ne peut y avoir qu'un seul bon virtuel d'un type donné
return(RésultatBadRequest("BonVirtuelPrésent"));
}
if (copieLignes)
{
// on ne peut copier les lignes que si la synthèse précédente a été réalisée à partir du seul bon virtuel
// c'est le cas s'il n'y a pas de bon ayant pour NoGroupe le No de cette synthèse
docACopier = await _service.DernierDoc(vérificateur.IdClient, DocCLF.TypeSynthèse(_type));
if (docACopier == null)
{
return(RésultatBadRequest("PasDeDernièreSynthèse"));
}
if (!(await _service.EstSynthèseSansBons(docACopier)))
{
return(RésultatBadRequest("DernièreSynthèseAvecBons"));
}
}
noBon = 0;
}
RetourDeService <DocCLF> retour = await _service.AjouteBon(vérificateur.IdClient, vérificateur.Site, _type, noBon);
if (!retour.Ok)
{
return(SaveChangesActionResult(retour));
}
if (docACopier != null)
{
RetourDeService retour1 = await _service.CopieLignes(retour.Entité, docACopier, vérificateur.Site.DateCatalogue.Value);
if (!retour1.Ok)
{
return(SaveChangesActionResult(retour1));
}
}
return(RésultatCréé(CLFDoc.DeNo(noBon)));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> Facture([FromQuery] KeyDocSansType keyDocument)
{
return(await Document(keyDocument, TypeCLF.Facture));
}
[ProducesResponseType(404)] // Not found
public async Task <IActionResult> Livraison([FromQuery] KeyDocSansType keyDocument)
{
return(await Document(keyDocument, TypeCLF.Livraison));
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> AnnuleD([FromQuery] KeyDocSansType keyDoc)
{
Task <RetourDeService> action(DocCLF docCLF) => _service.Annule(docCLF, TypeCLF.Livraison);
return(await Action(keyDoc, action));
}
[ProducesResponseType(409)] // Conflict
public async Task <IActionResult> CopieD([FromQuery] KeyDocSansType keyDoc)
{
Task <RetourDeService> action(DocCLF docCLF) => _service.CopieQuantité(docCLF, TypeCLF.Commande);
return(await Action(keyDoc, action));
}
/// <summary>
/// Fixe KeyClient et KeyDoc.
/// </summary>
/// <param name="keyDocSansType">objet ayant la même KeyUidRnoNo que le document</param>
public void Initialise(KeyDocSansType keyDocSansType)
{
IdClient = keyDocSansType.Id;
KeyDoc = keyDocSansType;
}
