Esempio n. 1
0
        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));
        }
        [ProducesResponseType(409)] // Conflict
        public async Task <IActionResult> EnCours([FromQuery] ParamsKeyClient paramsKeyClient)
        {
            vérificateur.Initialise(paramsKeyClient);
            try
            {
                await ClientDeLAction();
                await UtilisateurEstClientActifOuNouveau();

                ContexteCatalogue();
            }
            catch (VérificationException)
            {
                return(vérificateur.Erreur);
            }

            if (paramsKeyClient.DateCatalogue.HasValue)
            {
                // la commande en cours a déjà été chargée par l'application client qui vérifie seulement le contexte catalogue
                // la vérification a réussi
                // retourne un CLFDocs vide
                return(Ok(new CLFDocs()));
            }

            CLFDocs docs = await _service.CommandeEnCours(paramsKeyClient.Id);

            return(Ok(docs));
        }
Esempio n. 3
0
        [ProducesResponseType(404)] // Not found
        public async Task <IActionResult> NouveauxDocs()
        {
            CarteUtilisateur carte = await CréeCarteUtilisateur();

            if (carte.Erreur != null)
            {
                return(carte.Erreur);
            }

            CLFDocs clfDocs = await _service.NouveauxDocs(carte.Utilisateur);

            return(Ok(clfDocs));
        }
Esempio n. 4
0
        [ProducesResponseType(404)] // Not found
        public async Task <IActionResult> ListeF([FromQuery] ParamsFiltreDoc paramsFiltre)
        {
            // la liste est demandée par le fournisseur, paramsFiltre a la clé du site
            CarteUtilisateur carte = await CréeCarteFournisseur(paramsFiltre.Id, EtatsRolePermis.PasFermé);

            if (carte.Erreur != null)
            {
                return(carte.Erreur);
            }

            CLFDocs clfDocs = await _service.Résumés(paramsFiltre, carte.Fournisseur.Site);

            return(Ok(clfDocs));
        }
Esempio n. 5
0
        [ProducesResponseType(404)] // Not found
        public async Task <IActionResult> ListeC([FromQuery] ParamsFiltreDoc paramsFiltre)
        {
            // la liste est demandée par le client, paramsFiltre a la clé du client
            vérificateur.Initialise(paramsFiltre.Id);
            try
            {
                await ClientDeLAction();
                await UtilisateurEstClientPasFerméOuFournisseur();
            }
            catch (VérificationException)
            {
                return(vérificateur.Erreur);
            }

            CLFDocs clfDocs = await _service.Résumés(paramsFiltre, vérificateur.Client);

            return(Ok(clfDocs));
        }
Esempio n. 6
0
        /// <summary>
        /// Retourne un CLFDocs dont le champ Documents contient les documents envoyés et sans synthèse du client avec les lignes
        /// </summary>
        /// <param name="idClient"></param>
        /// <returns></returns>
        protected async Task <IActionResult> Client(uint idClient)
        {
            vérificateur.Initialise(idClient);
            try
            {
                await ClientDeLAction();
                await UtilisateurEstFournisseur();

                ContexteCatalogue();
            }
            catch (VérificationException)
            {
                return(vérificateur.Erreur);
            }

            CLFDocs clfDocs = await _service.BonsDUnClient(vérificateur.Site, idClient, _type);

            return(Ok(clfDocs));
        }
Esempio n. 7
0
        /// <summary>
        /// Retourne un CLFDocs dont le Documents contient les états de préparation des bons envoyés et sans synthèse de tous les clients.
        /// </summary>
        /// <param name="idSite">Id du site</param>
        /// <returns></returns>
        protected async Task <IActionResult> Clients(uint idSite)
        {
            CarteUtilisateur carte = await CréeCarteFournisseur(idSite, EtatsRolePermis.Actif);

            if (carte.Erreur != null)
            {
                return(carte.Erreur);
            }

            vérificateur.Site = carte.Fournisseur.Site;
            try
            {
                ContexteCatalogue();
            }
            catch (VérificationException)
            {
                return(vérificateur.Erreur);
            }


            CLFDocs clfDocs = await _service.ClientsAvecBons(idSite, _type);

            return(Ok(clfDocs));
        }