示例#1
0
        [ProducesResponseType(409)] // Conflict
        public async Task <IActionResult> CopieDems([FromQuery] KeyUidRno keySite)
        {
            CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);

            if (carte == null)
            {
                return(Forbid());
            }

            bool estFournisseur = await carte.EstActifEtAMêmeUidRno(keySite.KeyParam);

            if (!estFournisseur)
            {
                return(Forbid());
            }

            Site site = await _utile.SiteDeKey(keySite);

            if (site == null)
            {
                return(NotFound());
            }

            RetourDeService retour = await _service.CopieDemandes(site);

            if (retour == null)
            {
                return(RésultatBadRequest("RienACopier"));
            }

            return(SaveChangesActionResult(retour));
        }
        public async Task <RetourDeService <DemandeSite> > Ajoute(FournisseurAAjouter ajout)
        {
            Fournisseur fournisseur = new Fournisseur();

            Fournisseur.CopieData(ajout, fournisseur);
            fournisseur.Site = new Site();
            Site.CopieData(ajout.Site, fournisseur.Site);
            DateTime date = DateTime.Now;
            RetourDeService <Fournisseur> retourFournisseur = await base.Ajoute(fournisseur, date);

            RetourDeService <DemandeSite> retour;

            if (!retourFournisseur.Ok)
            {
                return(new RetourDeService <DemandeSite>(retourFournisseur));
            }
            fournisseur = retourFournisseur.Entité;
            DemandeSite demande = new DemandeSite
            {
                Email = ajout.Email,
                Id    = fournisseur.Id,
                Date  = date
            };

            _context.DemandeSite.Add(demande);
            retour = await SaveChangesAsync <DemandeSite>(demande);

            if (retour.Ok)
            {
                retour.Entité.Fournisseur = fournisseur;
            }
            return(retour);
        }
        [ProducesResponseType(409)] // Conflict
        public async Task <IActionResult> Edite([FromQuery] ParamsVide paramsLigne, CLFLigne ligne)
        {
            vérificateur.Initialise(ligne, paramsLigne);
            try
            {
                await ClientDeLAction();
                await UtilisateurEstClientActifOuNouveauOuFournisseur();

                ContexteCatalogue();
                await LigneExiste();

                DocModifiable();
                await PeutCommanderProduit();

                ChampsInterditsAbsents();
                ChampsPrésentsValides();
            }
            catch (VérificationException)
            {
                return(vérificateur.Erreur);
            }

            RetourDeService retour = await _service.EditeLigne(vérificateur.LigneCLF, ligne);

            return(SaveChangesActionResult(retour));
        }
示例#4
0
        [ProducesResponseType(409)] // Conflict
        public async Task <IActionResult> CopieBon([FromQuery] ParamsCréeCommande paramsCrée)
        {
            Vérificateur vérificateur = new Vérificateur(paramsCrée);
            await vérificateur.Vérifie(
                ClientDeLAction,
                UtilisateurEstClientOuFournisseur,
                EtatSiteChangé,
                DerniereCommandePrésenteEtEnvoyée
                );

            if (vérificateur.Erreur != null)
            {
                return(vérificateur.Erreur);
            }


            long noCommande = vérificateur.DernièreCommande == null ? 1 : vérificateur.DernièreCommande.No + 1;
            RetourDeService <Commande> retour = await _service.AjouteCommande(vérificateur.KeyClient, noCommande, vérificateur.Site, vérificateur.EstFournisseur);

            if (retour.Ok)
            {
                await _détailCommandeService.AjouteCopiesDétails(vérificateur.DernièreCommande);
            }

            return(SaveChangesActionResult(retour));
        }
示例#5
0
        [ProducesResponseType(409)] // Conflict
        public async Task <IActionResult> Ajoute([FromQuery] ParamsEditeDétail paramsDétail, DétailCommandeVue vue)
        {
            Vérificateur vérificateur = new Vérificateur(vue, paramsDétail);
            await vérificateur.Vérifie(
                ClientDeLAction,
                UtilisateurEstClientOuFournisseur,
                EtatSiteChangé,
                CommandeExiste,
                DétailNExistePas,
                CommandeModifiable,
                PeutCommanderProduit,
                ChampsInterditsAbsents,
                ChampsRequisPrésents,
                ChampsPrésentsValides
                );

            if (vérificateur.Erreur != null)
            {
                return(vérificateur.Erreur);
            }

            RetourDeService <DétailCommande> retour = await _détailCommandeService.Ajoute(vue);

            if (retour.Ok)
            {
                return(CreatedAtAction(nameof(LitDétail), vérificateur.KeyDétail, retour.Entité));
            }

            return(SaveChangesActionResult(retour));
        }
示例#6
0
        public async Task <IActionResult> Supprime([FromQuery] ParamsSupprimeLigne paramsSupprime)
        {
            vérificateur.Initialise(paramsSupprime);
            try
            {
                await ClientDeLAction();
                await UtilisateurEstClientActifOuNouveauOuFournisseur();

                ContexteCatalogue();
                await DocExiste();

                DocModifiable();
                // vérifie que la ligne commandant le produit dont le No est le No2 du paramétre existe et fixe vérificateur.LigneCLF
                LigneCLF ligne = vérificateur.DocCLF.Lignes.Where(l => l.ProduitId == paramsSupprime.ProduitId).FirstOrDefault();
                if (ligne == null)
                {
                    return(NotFound());
                }
                vérificateur.LigneCLF = ligne;
            }
            catch (VérificationException)
            {
                return(vérificateur.Erreur);
            }

            RetourDeService retour = await _service.SupprimeLigne(vérificateur.LigneCLF);

            return(SaveChangesActionResult(retour));
        }
        public async Task <IActionResult> ActionCommandes([FromQuery] KeyUidRno keyClient, Func <Site, KeyUidRno, List <Commande>, Task <RetourDeService> > action)
        {
            CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);

            if (carte == null)
            {
                // fausse carte
                return(Forbid());
            }

            Site site = await _utile.SiteDeClient(keyClient);

            if (site == null)
            {
                return(NotFound());
            }

            if (!await carte.EstActifEtAMêmeUidRno(site.KeyParam))
            {
                return(Forbid());
            }

            List <Commande> commandes = await _service.CommandesLivréesEtNonFacturées(site, keyClient);

            if (commandes.Count == 0)
            {
                Erreurs.ErreurDeModel.AjouteAModelState(ModelState, "PasDeCommandeLivréeEtNonFacturée");
                return(BadRequest());
            }

            RetourDeService retour = await action(site, keyClient, commandes);

            return(SaveChangesActionResult(retour));
        }
示例#8
0
        protected async Task <IActionResult> Fixe(ParamsFixeLigne paramsFixeLigne)
        {
            vérificateur.Initialise(paramsFixeLigne);
            try
            {
                await ClientDeLAction();
                await UtilisateurEstFournisseur();

                ContexteCatalogue();
                await LigneExiste();

                DocEstASynthétiser();
                string code = QuantitéDef.Vérifie(paramsFixeLigne.AFixer);
                if (code != null)
                {
                    vérificateur.Erreur = RésultatBadRequest("aFixer", code);
                    throw new VérificationException();
                }
            }
            catch (VérificationException)
            {
                return(vérificateur.Erreur);
            }

            RetourDeService retour = await _service.FixeLigne(vérificateur.LigneCLF, paramsFixeLigne.AFixer);

            return(SaveChangesActionResult(retour));
        }
示例#9
0
        /// <summary>
        /// Exécute une action sur chaque ligne des documents d'un client dont le No est dans une liste.
        /// Retourne une erreur si l'un des documents n'est pas à synthétiser.
        /// </summary>
        /// <param name="paramsSynthèse">contient l'Id du client et la liste des No des documents à synthétiser</param>
        /// <param name="action">retourne null si l'action est impossible</param>
        /// <returns></returns>
        protected async Task <IActionResult> Action(ParamsSynthèse paramsSynthèse, Func <List <DocCLF>, Task <RetourDeService> > action)
        {
            vérificateur.Initialise(paramsSynthèse.Id);
            try
            {
                await ClientDeLAction();
                await UtilisateurEstFournisseur();

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

            // Lit la liste des documents synthétisables dont le No est dans la liste.
            List <DocCLF> docs = await _service.DocumentsEnvoyésSansSynthèse(paramsSynthèse, DocCLF.TypeBon(_type));

            if (docs.Count != paramsSynthèse.NoDocs.Count)
            {
                // L'un des No de la liste ne correspond pas à un document synthétisable.
                return(RésultatBadRequest("DocumentsPasEnvoyésOuAvecSynthèse"));
            }

            RetourDeService retour = await action(docs);

            return(SaveChangesActionResult(retour));
        }
示例#10
0
        /// <summary>
        /// retourne la Commande ouverte (sans date) d'un client
        /// crée une nouvelle Commande s'il n'y en a pas d'ouvertes
        /// </summary>
        /// <param name="keyClient"></param>
        /// <returns></returns>
        public async Task <Commande> Ouverte(AKeyUidRno keyClient)
        {
            Commande commande = await _context.Commande
                                .Where(c => c.Uid == keyClient.Uid && c.Rno == keyClient.Rno)
                                .LastOrDefaultAsync();

            long no = 1;

            if (commande != null)
            {
                if (commande.Date != null)
                {
                    no = commande.No + 1;
                }
                commande = null;
            }
            if (commande == null)
            {
                commande = new Commande
                {
                    Uid = keyClient.Uid,
                    Rno = keyClient.Rno,
                    No  = no,
                };
                _context.Commande.Add(commande);
                RetourDeService retour = await SaveChangesAsync(commande);

                if (!retour.Ok)
                {
                    return(null);
                }
            }
            return(commande);
        }
示例#11
0
        /// <summary>
        /// Crée un Client avec son Utilisateur.
        /// </summary>
        /// <param name="vue">PeupleClientVue définissant le Client à créer</param>
        /// <param name="peupleId">PeupleId contenant les Id des derniers objets créés</param>
        /// <returns></returns>
        private async Task <RetourDeService> AjouteClient(PeupleClientVue vue, PeupleId peupleId)
        {
            uint id = peupleId.Client + 1;
            RetourDeService <Utilisateur> retourUtilisateur = await _utilisateurService.CréeUtilisateur(vue);

            if (!retourUtilisateur.Ok)
            {
                return(retourUtilisateur);
            }
            Utilisateur utilisateur = retourUtilisateur.Entité;
            await _utilisateurService.ConfirmeEmailDirect(utilisateur);

            Client client = new Client
            {
                Id            = id,
                UtilisateurId = utilisateur.Id,
                SiteId        = peupleId.Fournisseur,
                Etat          = EtatRole.Nouveau
            };

            Role.CopieData(vue, client);
            RetourDeService retour = await _clientService.Ajoute(client);

            if (retour.Ok)
            {
                peupleId.Client = id;
            }
            return(retour);
        }
        [ProducesResponseType(409)] // Conflict
        public async Task <IActionResult> Envoi([FromQuery] ParamsKeyClient paramsClient)
        {
            vérificateur.Initialise(paramsClient);
            try
            {
                await ClientDeLAction();
                await UtilisateurEstClientActifOuNouveau();

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

            DocCLF dernièreCommande = await _service.DernierDoc(paramsClient.Id, TypeCLF.Commande);

            // la dernière commande doit exister et ne pas être envoyée
            if (dernièreCommande == null || dernièreCommande.Date.HasValue)
            {
                return(RésultatBadRequest("DerniereCommandeAbsenteOuEnvoyée"));
            }

            RetourDeService <CLFDoc> retour = await _service.EnvoiCommande(vérificateur.Site, dernièreCommande);

            if (retour.Ok)
            {
                return(RésultatCréé(retour.Entité));
            }

            return(SaveChangesActionResult(retour));
        }
示例#13
0
        public async Task <RetourDeService> Ferme(KeyUidRno key, DateTime jusquA)
        {
            Site site = await LitSite(key);

            if (site.Etat != TypeEtatSite.Actif && site.Etat != TypeEtatSite.Inactif)
            {
                return(new RetourDeService <Site>(TypeRetourDeService.Ok));
            }
            DateTime maintenant = DateTime.Now;
            string   type;
            DateTime?date;

            if (jusquA < maintenant)
            {
                type = TypeEtatSite.Inactif;
                date = null;
            }
            else
            {
                type = TypeEtatSite.Actif;
                date = jusquA;
            }
            if (site.Etat != type || site.DateEtat != date)
            {
                site.Etat     = type;
                site.DateEtat = date;
                _context.Site.Update(site);
                EtatSite etat = new EtatSite
                {
                    Uid      = key.Uid,
                    Rno      = key.Rno,
                    Etat     = type,
                    DateEtat = date,
                    Date     = maintenant
                };
                _context.EtatSite.Add(etat);
            }
            RetourDeService retour = await SaveChangesAsync();

            if (retour.Ok)
            {
                List <Commande> commandes = await _context.Commande
                                            .Where(c => c.Date == null && c.LivraisonUid == key.Uid && c.LivraisonRno == key.Rno)
                                            .ToListAsync();

                if (commandes.Count > 0)
                {
                    commandes.ForEach(c =>
                    {
                        c.Etat = TypeEtatCommande.Accepté;
                        _context.Commande.Update(c);
                    });
                    retour = await SaveChangesAsync();
                }
            }
            return(retour);
        }
示例#14
0
        public async Task <IActionResult> Peuple()
        {
            if (await _peupleService.EstPeuplé())
            {
                return(BadRequest());
            }

            RetourDeService retour = await _peupleService.Peuple();

            return(SaveChangesActionResult(retour));
        }
        private async Task <RésultatEnregistrement> CréeUtilisateur(string type, VueBase vue)
        {
            RésultatEnregistrement résultat = new RésultatEnregistrement();
            ApplicationUser        existant = await _service.TrouveParEmail(vue.Email);

            if (existant == null)
            {
                ApplicationUser applicationUser = new ApplicationUser
                {
                    UserName = vue.Email,
                    Email    = vue.Email,
                };

                RetourDeService <Utilisateur> retour = await _service.CréeUtilisateur(applicationUser, vue.Password);

                if (retour.Ok)
                {
                    résultat.ACréé       = true;
                    résultat.user        = applicationUser;
                    résultat.Utilisateur = retour.Entité;
                }
                else
                {
                    résultat.ActionResult = SaveChangesActionResult(retour);
                }
            }
            else
            {
                Utilisateur utilisateur = await _service.UtilisateurDeUser(existant.Id);

                CarteUtilisateur carte = await _service.CréeCarteUtilisateur(HttpContext.User);

                bool permis = carte != null && ((carte.EstUtilisateurActif && carte.Uid == utilisateur.Uid) || carte.EstAdministrateur);
                if (permis)
                {
                    résultat.ACréé       = false;
                    résultat.user        = existant;
                    résultat.Utilisateur = utilisateur;
                    permis = await PeutAjouterRole(utilisateur, type, vue);

                    if (!permis)
                    {
                        résultat.ActionResult = BadRequest();
                    }
                }
                else
                {
                    résultat.ActionResult = Forbid();
                }
            }
            return(résultat);
        }
示例#16
0
        private async Task <IActionResult> Enregistre(string type, VueBase vue)
        {
            RésultatEnregistrement résultat = null;

            try
            {
                résultat = await CréeUtilisateur(type, vue);

                if (résultat.ActionResult != null)
                {
                    return(résultat.ActionResult);
                }

                résultat.Role = await _roleService.CréeRole(résultat.Utilisateur);

                CréeEntité(résultat, type, vue);

                await ValideEntité(résultat, type);

                if (!ModelState.IsValid)
                {
                    if (résultat.ACréé)
                    {
                        await _service.Supprime(résultat.Utilisateur);
                    }
                    return(BadRequest(ModelState));
                }

                _roleService.AjouteSansSauver(résultat.Role);
                AjouteEntitéSansSauver(résultat, type);

                RetourDeService retour = await _service.SaveChangesAsync();

                if (retour.Type != TypeRetourDeService.Ok && résultat.ACréé)
                {
                    await _service.Supprime(résultat.Utilisateur);

                    return(SaveChangesActionResult(retour));
                }
            }
            catch (Exception ex)
            {
                if (résultat != null && résultat.ACréé)
                {
                    await _service.Supprime(résultat.Utilisateur);
                }
                throw ex;
            }

            return(await Connecte(résultat.applicationUser, true));
        }
示例#17
0
        public async Task <RetourDeService> Peuple()
        {
            PeupleId        peupleId = new PeupleId();
            RetourDeService retour   = await AjouteAdministrateur();

            // Crée les fournisseurs: Utilisateur, Fournisseur, Site
            for (int i = 0; i < PeuplementUtilisateurs.Fournisseurs.Length && retour.Ok; i++)
            {
                PeupleFournisseurVue vue = PeuplementUtilisateurs.Fournisseurs[i];
                retour = await AjouteFournisseur(vue, peupleId);
            }

            return(retour);
        }
示例#18
0
        /// <summary>
        /// Crée l'administrateur.
        /// </summary>
        /// <returns></returns>
        private async Task <RetourDeService> AjouteAdministrateur()
        {
            CréeCompteVue vue = new CréeCompteVue
            {
                Email    = "*****@*****.**",
                Password = "******"
            };
            RetourDeService <Utilisateur> retourUtilisateur = await _utilisateurService.CréeUtilisateur(vue);

            if (retourUtilisateur.Ok)
            {
                await _utilisateurService.ConfirmeEmailDirect(retourUtilisateur.Entité);
            }
            return(retourUtilisateur);
        }
示例#19
0
        [ProducesResponseType(409)] // Conflict
        public async Task <IActionResult> CopieDemC([FromQuery] KeyUidRno keyClient)
        {
            Vérificateur vérificateur = new Vérificateur
            {
                KeyClient = keyClient
            };
            await vérificateur.Vérifie(
                ClientDeLAction,
                UtilisateurEstFournisseur,
                DétailExiste,
                ALivrerModifiable
                );

            if (vérificateur.Erreur != null)
            {
                return(vérificateur.Erreur);
            }
            CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);

            if (carte == null)
            {
                return(Forbid());
            }

            Site site = await _utile.SiteDeClient(keyClient);

            if (site == null)
            {
                return(NotFound());
            }

            bool estFournisseur = await carte.EstActifEtAMêmeUidRno(site.KeyParam);

            if (!estFournisseur)
            {
                return(Forbid());
            }

            RetourDeService retour = await _service.CopieDemandes(site, keyClient);

            if (retour == null)
            {
                return(RésultatBadRequest("RienACopier"));
            }

            return(SaveChangesActionResult(retour));
        }
        [ProducesResponseType(409)] // Conflict
        public async Task <IActionResult> Commence([FromQuery] KeyUidRno keySite)
        {
            CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);

            if (carte == null)
            {
                // fausse carte
                return(Forbid());
            }

            if (!await carte.EstActifEtAMêmeUidRno(keySite.KeyParam))
            {
                // pas le fournisseur
                return(Forbid());
            }

            Site site = await _utile.SiteDeKey(keySite);

            if (site == null)
            {
                return(NotFound());
            }
            if (site.Etat != TypeEtatSite.Ouvert)
            {
                ErreurDeModel.AjouteAModelState(ModelState, "EtatSiteIncorrect");
                return(BadRequest(ModelState));
            }

            Livraison livraison = await _utile.DernièreLivraison(site);

            if (livraison != null && !livraison.Date.HasValue)
            {
                ErreurDeModel.AjouteAModelState(ModelState, "DernièreLivraisonPasTerminée");
            }

            await _service.CommenceLivraison(site);

            RetourDeService retour = await _siteService.ChangeEtat(site, TypeEtatSite.Livraison);

            if (retour.Ok)
            {
                return(Ok(await _service.VueDesCommandesOuvertesDesClientsAvecCompte(site)));
            }

            return(SaveChangesActionResult(retour));
        }
        public async Task <IActionResult> Edite(TVue vue)
        {
            CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);

            if (carte == null)
            {
                // fausse carte
                return(Forbid());
            }

            if (dEditeEstPermis == null || !(await dEditeEstPermis(carte, vue.KeyParam)))
            {
                return(Forbid());
            }

            T nouveau = __service.CréeDonnée(vue);

            if (dEcritVerrouillé != null && await dEcritVerrouillé(carte, nouveau))
            {
                return(Conflict());
            }

            DValideEdite <T> dValideEdite = __service.DValideEdite();

            if (dValideEdite != null)
            {
                await dValideEdite(nouveau, ModelState);

                if (!ModelState.IsValid)
                {
                    return(BadRequest(ModelState));
                }
            }

            T donnée = await __service.Lit(vue.KeyParam as TParam);

            if (donnée == null)
            {
                return(NotFound());
            }

            RetourDeService <T> retour = await __service.Edite(donnée, nouveau);

            return(SaveChangesActionResult(retour));
        }
        public async Task <IActionResult> Ajoute(TVue vue)
        {
            CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);

            if (carte == null)
            {
                // fausse carte
                return(Forbid());
            }

            if (dAjouteEstPermis == null || !(await dAjouteEstPermis(carte, vue.KeyParamParent)))
            {
                return(Forbid());
            }

            await FixeKeyParamAjout(vue);

            T donnée = __service.CréeDonnée(vue);

            if (dEcritVerrouillé != null && await dEcritVerrouillé(carte, donnée))
            {
                return(Conflict());
            }

            DValideAjoute <T> dValideAjoute = __service.DValideAjoute();

            if (dValideAjoute != null)
            {
                await dValideAjoute(donnée, ModelState);

                if (!ModelState.IsValid)
                {
                    return(BadRequest(ModelState));
                }
            }

            RetourDeService <T> retour = await __service.Ajoute(donnée);

            if (retour.Ok)
            {
                return(CreatedAtAction(nameof(Lit), vue.TexteKey, vue));
            }

            return(SaveChangesActionResult(retour));
        }
示例#23
0
        public async Task <IActionResult> Ajoute([FromBody] CréeCompteVue vue)
        {
            RetourDeService <Utilisateur> retour = await CréeUtilisateur(vue);

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            if (retour.Type != TypeRetourDeService.Ok)
            {
                return(SaveChangesActionResult(retour));
            }

            // envoie un mail contenant le lien de confirmation
            await UtilisateurService.EnvoieEmailConfirmeCompte(retour.Entité);

            return(Ok());
        }
        [ProducesResponseType(409)] // Conflict
        public async Task <IActionResult> Detail(DétailCommandeVue vue)
        {
            CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);

            if (carte == null)
            {
                // fausse carte
                return(Forbid());
            }

            KeyUidRno keySite = new KeyUidRno {
                Uid = vue.Uid2, Rno = vue.Rno
            };

            if (!await carte.EstActifEtAMêmeUidRno(keySite.KeyParam))
            {
                return(Forbid());
            }

            Commande commande = await _service.CommandeDeDétail(vue);

            if (commande == null)
            {
                return(NotFound());
            }

            if (!(await _service.EstDansSynthèseEnvoyée(commande)))
            {
                Erreurs.ErreurDeModel.AjouteAModelState(ModelState, "CommandeLivréeEtNonFacturée");
                return(BadRequest());
            }

            DétailCommande détail = await _service.LitDétail(vue);

            if (détail == null)
            {
                return(NotFound());
            }

            RetourDeService retour = await _service.EcritDétail(détail, vue);

            return(SaveChangesActionResult(retour));
        }
示例#25
0
        [ProducesResponseType(409)] // Conflict
        public async Task <IActionResult> Nouveau([FromQuery] ParamsCréeCommande paramsCrée)
        {
            Vérificateur vérificateur = new Vérificateur(paramsCrée);
            await vérificateur.Vérifie(
                ClientDeLAction,
                UtilisateurEstClientOuFournisseur,
                EtatSiteChangé,
                DerniereCommandeAbsenteOuEnvoyée
                );

            if (vérificateur.Erreur != null)
            {
                return(vérificateur.Erreur);
            }

            long            noCommande = vérificateur.DernièreCommande == null ? 1 : vérificateur.DernièreCommande.No + 1;
            RetourDeService retour     = await _service.AjouteCommande(vérificateur.KeyClient, noCommande, vérificateur.Site, vérificateur.EstFournisseur);

            return(SaveChangesActionResult(retour));
        }
示例#26
0
        [ProducesResponseType(409)] // Conflict
        public async Task <IActionResult> Supprime([FromQuery] ParamsSupprimeDétail paramsDétail)
        {
            Vérificateur vérificateur = new Vérificateur(paramsDétail);
            await vérificateur.Vérifie(
                ClientDeLAction,
                UtilisateurEstClientOuFournisseur,
                EtatSiteChangé,
                DétailExiste,
                CommandeModifiable
                );

            if (vérificateur.Erreur != null)
            {
                return(vérificateur.Erreur);
            }

            RetourDeService retour = await _détailCommandeService.Supprime(vérificateur.Détail);

            return(SaveChangesActionResult(retour));
        }
        [ProducesResponseType(409)] // Conflict
        public async Task <IActionResult> Edite(CLFLigne clfLigne)
        {
            vérificateur.Initialise(clfLigne);
            try
            {
                await ClientDeLAction();
                await UtilisateurEstFournisseur();
                await LigneExiste();

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

            RetourDeService retour = await _service.EditeLigne(vérificateur.LigneCLF, clfLigne);

            return(SaveChangesActionResult(retour));
        }
示例#28
0
        /// <summary>
        /// Crée un Client sans Utilisateur.
        /// </summary>
        /// <param name="peupleId">PeupleId contenant les Id des derniers objets créés</param>
        /// <returns></returns>
        private async Task <RetourDeService> AjouteClient(PeupleId peupleId)
        {
            uint   id     = peupleId.Client + 1;
            Client client = new Client
            {
                Id      = id,
                SiteId  = peupleId.Fournisseur,
                Nom     = "Client" + id,
                Adresse = "Adresse" + id,
                Ville   = "Ville" + id,
                Etat    = EtatRole.Actif
            };
            RetourDeService retour = await _clientService.Ajoute(client);

            if (retour.Ok)
            {
                peupleId.Client = id;
            }
            return(retour);
        }
        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));
        }
        /// <summary>
        /// modèle de vérification pour exécuter une action du fournisseur
        /// </summary>
        /// <param name="keyOuVueCommande"></param>
        /// <param name="action"></param>
        /// <returns></returns>
        private async Task <IActionResult> ActionFournisseur(AKeyUidRno keySite,
                                                             DVérifieEtatSite vérifieEtatSite, DLivraisonDeLAction livraisonDeLAction, DActionLivraison actionLivraison)
        {
            CarteUtilisateur carte = await _utilisateurService.CréeCarteUtilisateur(HttpContext.User);

            if (carte == null)
            {
                // fausse carte
                return(Forbid());
            }

            if (!await carte.EstActifEtAMêmeUidRno(keySite.KeyParam))
            {
                // pas le fournisseur
                return(Forbid());
            }

            Site site = await _utile.SiteDeKey(keySite);

            if (site == null)
            {
                return(NotFound());
            }

            vérifieEtatSite(site);
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            Livraison livraison = await livraisonDeLAction(site);

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            RetourDeService retour = await actionLivraison(site, livraison);

            return(SaveChangesActionResult(retour));
        }