Esempio n. 1
0
        /// <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)));
        }
Esempio n. 2
0
 public async Task FixeSynthèse(DocCLF docCLF, DbSet <DocCLF> docs)
 {
     if (docCLF.NoGroupe != null)
     {
         NoGroupe   = docCLF.NoGroupe;
         DateGroupe = await docs
                      .Where(d => d.Id == docCLF.Id && d.No == docCLF.NoGroupe && d.Type == DocCLF.TypeSynthèse(docCLF.Type))
                      .Select(d => d.Date)
                      .FirstOrDefaultAsync();
     }
 }