Esempio n. 1
0
        /// <summary>
        /// Crée un document à envoyer avec seulement le No.
        /// </summary>
        /// <param name="noBon">document dans la bdd</param>
        /// <returns></returns>
        public static CLFDoc DeNo(uint noBon)
        {
            CLFDoc clfDoc = new CLFDoc
            {
                No = noBon
            };

            return(clfDoc);
        }
Esempio n. 2
0
        /// <summary>
        /// Crée un document à envoyer avec seulement la Date.
        /// </summary>
        /// <param name="docCLF">document dans la bdd</param>
        /// <returns></returns>
        public static CLFDoc DeDate(DocCLF docCLF)
        {
            CLFDoc clfDoc = new CLFDoc
            {
                Date = docCLF.Date
            };

            return(clfDoc);
        }
Esempio n. 3
0
        /// <summary>
        /// Crée un document à envoyer avec seulement le No et le Type.
        /// </summary>
        /// <param name="docCLF">document dans la bdd</param>
        /// <returns></returns>
        public static CLFDoc DeNoType(DocCLF docCLF)
        {
            CLFDoc clfDoc = new CLFDoc
            {
                No   = docCLF.No,
                Type = docCLF.Type
            };

            return(clfDoc);
        }
Esempio n. 4
0
        /// <summary>
        /// Crée un document à envoyer avec seulement l'Id du client et le No du document.
        /// </summary>
        /// <param name="docCLF">document dans la bdd</param>
        /// <returns></returns>
        public static CLFDoc DeKey(DocCLF docCLF)
        {
            CLFDoc clfDoc = new CLFDoc
            {
                Id = docCLF.Id,
                No = docCLF.No
            };

            return(clfDoc);
        }
Esempio n. 5
0
        /// <summary>
        /// Crée un document à envoyer avec la key, la Date, les lignes avec ou sans AFixer suivant la fonction de création de ligne.
        /// </summary>
        /// <param name="docCLF">document dans la bdd</param>
        /// <param name="créeLigneData">transforme une ligne de la bdd en une ligne à envoyer</param>
        /// <returns></returns>
        public static CLFDoc AvecLignes(DocCLF docCLF, Func <LigneCLF, CLFLigneData> créeLigneData)
        {
            CLFDoc clfDoc = new CLFDoc
            {
                Id     = docCLF.Id,
                No     = docCLF.No,
                Date   = docCLF.Date,
                Lignes = docCLF.Lignes.Select(l => créeLigneData(l)).ToList()
            };

            return(clfDoc);
        }
Esempio n. 6
0
        public static CLFDoc APréparer(DocCLF docCLF)
        {
            CLFDoc clfDoc = new CLFDoc
            {
                Id        = docCLF.Id,
                No        = docCLF.No,
                Date      = docCLF.Date,
                NbLignes  = docCLF.Lignes.Count,
                Incomplet = !docCLF.Lignes.All(l => l.AFixer.HasValue)
            };

            return(clfDoc);
        }
Esempio n. 7
0
        /// <summary>
        /// Crée un document à envoyer avec la key, la Date, le Type, le NbLignes, le Total et le Incomplet.
        /// Si le document fait partie d'une synthèse, le CLFDoc contient aussi le NoGroupe, la DateGroupe.
        /// </summary>
        /// <param name="docCLF">document dans la bdd</param>
        /// <returns></returns>
        public static async Task <CLFDoc> Résumé(DocCLF docCLF, DbSet <DocCLF> docs)
        {
            CLFDoc clfDoc = new CLFDoc
            {
                Id        = docCLF.Id,
                No        = docCLF.No,
                Type      = docCLF.Type,
                Date      = docCLF.Date,
                NoGroupe  = docCLF.NoGroupe,
                NbLignes  = docCLF.NbLignes,
                Total     = docCLF.Total,
                Incomplet = docCLF.Incomplet
            };
            await clfDoc.FixeSynthèse(docCLF, docs);

            return(clfDoc);
        }
Esempio n. 8
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. 9
0
        /// <summary>
        /// Crée un document à envoyer avec la key, la Date, les lignes avec AFixer.
        /// </summary>
        /// <param name="docCLF">document dans la bdd</param>
        /// <returns></returns>
        public static CLFDoc AvecLignesAvecAFixer(DocCLF docCLF)
        {
            CLFDoc clfDoc = CLFDoc.AvecLignes(docCLF, CLFLigneData.LigneDataAvecAFixer);

            return(clfDoc);
        }