Ejemplo n.º 1
0
        /// <summary>
        /// ajoute la donnée définie par la vue
        /// </summary>
        /// <param name="ajout">contient tous les champs pour créer une donnée</param>
        /// <returns></returns>
        protected async Task <IActionResult> Ajoute(TAjout ajout)
        {
            RetourDeService <T> retour = await __service.Ajoute(ajout, ModelState);

            if (retour.ModelError)
            {
                return(BadRequest(ModelState));
            }

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

            return(SaveChangesActionResult(retour));
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Modifie une donnée par les champs présents dans la vue
        /// </summary>
        /// <param name="donnée">donnée à modifier</param>
        /// <param name="vue">contient les champs à modifier dans la donnée</param>
        /// <returns></returns>
        protected async Task <IActionResult> Edite(T donnée, TEdite vue)
        {
            // vérifie que les valeurs à changer sont valides
            DAvecIdUintValideModel <T> dValide = __service.DValideEdite();

            if (dValide != null)
            {
                T àValider = __service.CréeDonnéeEditéeComplète(vue, donnée);
                await dValide(àValider, ModelState);

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

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

            return(SaveChangesActionResult(retour));
        }
Ejemplo n.º 3
0
        // ERREURS


        // LECTURES

        // ECRITURE

        public async Task <RetourDeService> SaveChangesAsync()
        {
            try
            {
                await _context.SaveChangesAsync();

                return(new RetourDeService(TypeRetourDeService.Ok));
            }
            catch (DbUpdateConcurrencyException)
            {
                return(new RetourDeService(TypeRetourDeService.ConcurrencyError));
            }
            catch (DbUpdateException ex)
            {
                RetourDeService retour = new RetourDeService(TypeRetourDeService.UpdateError)
                {
                    Message = ex.InnerException.Message
                };
                return(retour);
            }
        }
Ejemplo n.º 4
0
        public IActionResult SaveChangesActionResult(RetourDeService retour)
        {
            switch (retour.Type)
            {
            case TypeRetourDeService.Ok:
                return(NoContent());

            case TypeRetourDeService.IdentityError:
                return(StatusCode(500, "La création du compte utilisateur a échoué."));

            case TypeRetourDeService.ConcurrencyError:
                return(StatusCode(409));

            case TypeRetourDeService.Indéterminé:
                return(StatusCode(500, "Erreur interne inconnue."));

            default:
                break;
            }
            return(StatusCode(500, "Erreur interne inconnue."));
        }
Ejemplo n.º 5
0
        public async Task <RetourDeService <T> > SaveChangesAsync <T>(T objet) where T : class
        {
            try
            {
                await _context.SaveChangesAsync();

                return(new RetourDeService <T>(TypeRetourDeService.Ok)
                {
                    Objet = objet
                });
            }
            catch (DbUpdateConcurrencyException)
            {
                return(new RetourDeService <T>(TypeRetourDeService.ConcurrencyError));
            }
            catch (DbUpdateException ex)
            {
                RetourDeService <T> retour = new RetourDeService <T>(TypeRetourDeService.UpdateError)
                {
                    Message = ex.InnerException.Message
                };
                return(retour);
            }
        }
Ejemplo n.º 6
0
 public RetourDeService(RetourDeService retour)
 {
     Type    = retour.Type;
     Objet   = retour.Objet;
     Message = retour.Message;
 }