IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Services Web Discussion :

Erreur 404 Not Found -Serveur API-requete PostAsync


Sujet :

Services Web

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre éprouvé
    Profil pro
    Inscrit en
    Mai 2002
    Messages
    986
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2002
    Messages : 986
    Par défaut Erreur 404 Not Found -Serveur API-requete PostAsync
    Bonjour,

    J'ai crée un service qui permet d'ajouter des auteurs et des livres en base de données.

    Le projet de départ est le service Web e-bibliotheque, qui fait appel aux méthodes de la classe ServiceAuteur d'une application Console ConsommerAPI.

    ConsommerAPI fait appel au service web ServeurAPI qui permet l'ajout en BDD d'un auteur.

    Dans la classe ServiceAuteur, j'ai crée cette constante avec cette adresse, qui est celle que je vois quand je vais dans la barre des tâches au niveau du serveur IISExpress(voir capt ecran)
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    private const string urlAPI = "http://localhost:41380/api/";
    J'ai également ajouté cela au niveau du Namespace
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
     
     [RoutePrefix("api/Auteur")]
    La méthode AjouterUnauteur de la classe ServiceAuteur est la suivante

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
     
     
     [HttpPost]
            [Route("auteur")]
            public async Task<Auteur> AjouterUnAuteur(Auteur auteur)
            {
                HttpResponseMessage objetReponse =null;
                try
                {
                    HttpClient client = new HttpClient();
     
                    //sérialization d'un auteur passé en paramètre au format JSON
                    //la classe de base JsonMediaTypeFormatter gère la sérialisation et la désérialisation des objets fortement typés à l'aide de l'ObjectContent. 
                    ObjectContent<Auteur> content = new ObjectContent<Auteur>(auteur, new JsonMediaTypeFormatter());
     
                    //la méthode PostAsync envoie une requête asynchrone POST vers le serveur d'API à une méthode Post
                    objetReponse = await client.PostAsync($"{urlAPI}Auteur/", content);
     
                    //si ce POST s'est bien effectué
                    if (objetReponse.IsSuccessStatusCode)
                    {
                        return auteur;
                    }//fin de if
                    else if (objetReponse.StatusCode == System.Net.HttpStatusCode.NotFound)
                    {
                        //l'instruction return null concerne une fonction  renvoyant un objet , l'instruction return concerne une fonction  ne renvoyant rien, c'est à dire avec le type de retour void
                        return null;
                    }//fin de else 
     
                }//fin de try
                catch(Exception ex)
                {
                    Console.WriteLine( $"Un problème avec API : status = {objetReponse.StatusCode}");
                    Console.WriteLine(ex.Message);
     
                }//fin de catch
                return null;
     
            }//fin de AjouterUnAuteur

    Chaque fois que je débogue, au niveau de la cette méthode , j'ai une erreur au niveau de cette instruction
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
     objetReponse = await client.PostAsync($"{urlAPI}Auteur/", content);
    {StatusCode: 404, ReasonPhrase: 'Not Found', Version: 1.1, Content: System.Net.Http.StreamContent, Headers:
    {
    X-SourceFiles: =?UTF-8?B?QzpcVXNlcnNcaGFyQDQzXERvY3VtZW50c1xlX2JpYmxpb3RoZXF1ZVxlLUJpYmxpb3RoZXF1ZVxhcGlcQXV0ZXVyXA==?=
    Cache-Control: private
    Date: Tue, 16 Jan 2024 14:40:08 GMT
    Server: Microsoft-IIS/10.0
    X-AspNet-Version: 4.0.30319
    X-Powered-By: ASP.NET
    Content-Length: 3300
    Content-Type: text/html; charset=utf-8
    }}

    J'ai tout essayé (si, si )pour tenter de résoudre ce problème, mais sans succès,et tourne en rond (notamment ajouter [HttpPost]
    [Route("auteur")] au niveau des methodes de ServiceAuteur, ) mais ne sais plus où me diriger pour resoudre ce pb.

    Je vous informe que j'ai ajouté la reference ConsommerApi au projet e-bibliotheque et que j'ai ajouté la reference ServeurAPI au projet ConsommerApi , qui , au niveau de ServiceAuteur doit pouvoir accéder au Serveur API.

    Merci beaucoup à vous de votre aide car je ne m'y retrouve plus malgré mes nombreuses tentatives de resoudre ce pb!


    Bien cordialement.

    new_wave
    Images attachées Images attachées     

  2. #2
    Expert confirmé
    Avatar de popo
    Homme Profil pro
    Analyste programmeur Delphi / C#
    Inscrit en
    Mars 2005
    Messages
    2 921
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Analyste programmeur Delphi / C#
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mars 2005
    Messages : 2 921
    Par défaut
    Tu as mis en quantité impressionnante d'informations.
    Ce qui est dommage; c'est qu'il n'y a pas grand chose d'utile dans tout ça et qu'il y a quelques incohérences qui font que tout se mélange.

    Déjà ajouter des attributs [HttpPost] et/ou [Route] dans une application console n'a aucun sens.

    Ensuite, tu nous montres un appel d'API en nous disant que ça déclenche un 404.
    Si une API renvoie 404 c'est que tu ne l'appelles pas correctement ou qu'elle n'est pas accessible.
    Et sans connaître le contrat de cette API, personne ne pourra t'aider.

    Enfin, je dirais qu'il est inutile voire carrément contre-productif d'écrire du code C# qui appelle une API sans avoir effectué cet appel avec un outil tel que Postman ou cURL.

    Donc pour faire fonctionner ton programme, il faut dans cet ordre.
    Obtenir le contrat de l'API que tu appelles (il y a certainement un swagger ou une page dédiée).
    Tester cette API avec un outil fait pour ça (je conseille fortement Postman qui possède une option pour générer du code).
    Une fois que l'API répond correctement dans l'outil, écrire le code correspondant.

  3. #3
    Membre éprouvé
    Profil pro
    Inscrit en
    Mai 2002
    Messages
    986
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2002
    Messages : 986
    Par défaut
    Bonjour,

    Merci beaucoup de ta réponse.

    En effet, je me suis un peu perdue.
    J'ai supprimé les attributs [HttpPost] et [Route] dans mon application console.

    J'ai réalisé ce projet en 2017.

    Son but était de faire fonctionner un service Web avec une API Rest.
    Le service Client Rest était utilisé pour la gestion des livres et auteurs

    Les ServiceClient et ServiceAuteur étaient utilisés via une application console (ConsommerAPI).

    Si je me souviens bien, et d'après mes commentaires de code de l'époque qui sont normalement fiables, on pouvait appeler les méthodes de AuteurController sur ServeurAPI soit via le client Rest ou via l'application console ConsommerAPI.

    Quand j'ai réalisé ce projet avec mon manager, cela fonctionnait bien mais peut être que depuis je me suis un peu emmêlée quant à son fonctionnement.


    Aujourd'hui, je souhaiterais commencer par reprendre l'accès au Serveur API via l'application console, si cela est faisable.

    Autre petit souci: tu peux constater le ServiceWeb e-bibilotheque : je me demande si ce service web était utilisé pour la gestion des Auteurs via l'application Console plutôt que ServeurAPI.En effet, le code de AuteurController diffère un peu de celui du ServeurAPI. Je ne sais plus très bien...
    Je te communique également le code Auteurcontroller dans e-bibiotheque

    Je pense sincèrement que tu pourrais m'aiguiller pour que je reprenne ce projet car tu sais quelles briques logicielles fonctionnent ensemble.

    Voici ci-dessous le code de la classe Auteurcontroller du ServeurAPI.

    J'ai ajouté les références du projet Entite et du projet Repository au niveau des references du ServeurAPI(ServiceWeb) car il en a besoin .

    Le projet Entité contient la classe Auteur(entre autres puisqu'il contient aussi la classe Livre)

    Je te fournis également le code des classes RepositoryAuteur et IRepositoryAuteur pour information.


    Souhaites tu que je te fournisse le code de certaines classes, pour t'aider à y voir davantage plus clair

    Merci infiniment de ton aide car j'ai vraiment besoin de reprendre ce projet, bien comprendre son fonctionnement et le faire fonctionner!

    Bien cordialement.

    new_wave

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
     
     
    using Entite;
    using Repository;
    using Repository.Interface;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Net;
    using System.Net.Http;
    using System.Web.Http;
     
     
     
    namespace ServeurAPI.Controllers
    {
        [RoutePrefix("api/Auteur")]
        public class AuteurController : ApiController
        {   //savoir:
            //1- si on ne nomme pas les méthodes ci-dessous explicitement (par un nom tel que Get, Post, Put, Delete) on doit écrire 
            //au dessus du nom de la méthode une metadonnée [Http+nom de la méthode à executer , ex [HttpGet] ou [HttpPost] car potentiellement toutes les méthodes  
            //sont éligibles à l'exécution si leur nom n'est pas explicite pour le routeur
            //toutes ces méthodes sont appelées soit via le client Rest , soit via l'application console ConsommerAPÏ
     
            //2-avec le client Rest,  les données saisies au niveau du body sont au format json. Avant d'être passées en paramètre de chaque méthode de la classe AuteurController, 
            // elles sont déserializées implicitement 
     
     
            /// <summary>
            /// méthode de récupération des données 
            ///  
            /// </summary>
            /// <returns>un HttpResponseMessage</returns>
            // GET: api/AuteurAPI
     
            [HttpGet]
            [Route("")]
            public IHttpActionResult Get()
            {
                try
                {//initialisation d'une instance de la classe RepositoryAuteur via l'interface  IRepositoryAuteur donc avec limitation à la méthode getByNameAndSurname
                    IRepositoryAuteur reposAuteur = new RepositoryAuteur();
     
                    IEnumerable<Auteur> liste = reposAuteur.GetAll();
     
                    return Ok(liste);
                }
                catch (Exception e)
                {
                    //logger l'erreur
     
                    return InternalServerError(e);
                }//fin de catch
            }//fin de Get
     
            // GET: api/AuteurAPI/5
            /// <summary>
            /// méthode de recupération d'un auteur avec saisie de son id au niveau de l'URL
            /// </summary>
            /// <param name="id"></param>
            /// <returns></returns>
            /// 
            [HttpGet]
            [Route("{id:int}")]
            public IHttpActionResult Get(int id)
            {
                IRepositoryAuteur reposAuteur = new RepositoryAuteur();
                try
                {
                    List<Auteur> auteur = reposAuteur.GetById(id);
                    if (auteur != null)
                        return Ok(auteur);
     
                    else { 
                        return NotFound();
     
                    }//fin de else
                }//fin de try
                catch (Exception e)
                {
                    return InternalServerError(e);
                }//fin de catch
     
            }//fin de Get
     
     
            /// <summary>
            /// méthode de POST d'un auteur saisi dans le body - 
            /// </summary>
            /// <param name="auteur"></param>
            /// <returns></returns>
            [HttpPost]
            [Route("")]
            public IHttpActionResult Post([FromBody]Auteur auteur)
            {
                try
                {
                    IRepositoryAuteur repoAuteur = new RepositoryAuteur();
                    repoAuteur.Add(auteur);
     
                    if (auteur != null)
                    {
                        //Creation d'un System.Web.Http.Results.OkResult(200 OK).
                        return Ok();
                    }//fin de if
                    else
                    {
                        return NotFound();
                    }//fin de else
                }//fin de try
                catch (Exception e)
                {
                    Console.WriteLine("IL y a une erreur " + e.StackTrace);
     
                    return InternalServerError(e);
                }//fin de catch
            }//fin de Post
     
     
            /// <summary>
            /// creation d'une fonction de suppression d'un auteur , qui pourra être appelée via l'interface client consommerAPI
            /// </summary>
            /// <param name="auteur"></param>
            /// <returns>un message de réussite de la suppression</returns>
            //public IHttpActionResult Delete(Auteur auteur)
            [HttpDelete]
            [Route("{auteur}")]
            public IHttpActionResult Delete(Auteur auteur)
            {
                IEnumerable<Auteur> auteur_a_chercher = null; 
                try
                {
     
     
                    if (auteur != null)
     
                        {
                        //creation d'une instance de la classe RepositoryAuteur qui permet la manipulation des données (fonction add, insert, delete, update...)
                        IRepositoryAuteur repoAuteur = new RepositoryAuteur();
     
                        //on verifie  si l'auteur passé en paramètre existe en bdd
                       auteur_a_chercher = repoAuteur.GetById(auteur.Id_auteur);
                       // auteur_a_chercher = repoAuteur.GetById(auteur);
     
                        //s'il existe bien on le supprime 
                        if (auteur_a_chercher != null)
                                {
                                    repoAuteur.Delete(auteur);
                                }//fin de if 
     
                        //on verifie à nouveau qu'il n' existe pas en bdd-
                        auteur_a_chercher = repoAuteur.GetById(auteur.Id_auteur);
     
                              //si l'auteur dont l'id est passé en paramètre de la méthode GetById n'existe pas , c'est qu'il a bien été supprimé
     
                                if (auteur_a_chercher == null)
                                {
                                    //retour d'un System.Web.Http.Results.OkResult(200 OK).
                                    return Ok();
     
                                }//fin de if 
     
                                //s'il existe encore en BDD, on retourne une erreur serveur
                                else
                                {
                                     return InternalServerError(new Exception());
     
                                }//fin de else
     
     
                    }//fin de if (auteur != null)
     
                    else //auteur est null ou n'existe pas en bdd
                    {
     
                        return NotFound();
     
                    }//fin de else
     
                }//fin de try
                catch (Exception e)
                {
                    //// Résumé*:
                    //     Creates an System.Web.Http.Results.ExceptionResult (500 Internal Server Error)
                    //     with the specified exception.
                    //
                    return InternalServerError(e);
     
                }//fin de catch
     
     
            }//fin de fonction Delete
     
     
     
     
            //// PUT: api/AuteurAPI/5
            /// <summary>
            /// methode de mise à jour 
            /// </summary>
            /// <param name="auteur"></param>
            /// <returns></returns>
            [HttpPut]
            [Route("{auteur}")]
            public IHttpActionResult Put([FromBody]Auteur auteur)
            {
     
     
             try { 
                 //création d'une instance de la classe RepositoryAuteur qui permet la manipulation des données (fonction add, insert, delete, update...)
                      IRepositoryAuteur repoAuteur = new RepositoryAuteur();
                        //appel de la méthode Update de cette instance  
                         repoAuteur.Update(auteur);
     
                         if (auteur != null)
                         {
                             //Creation d'un System.Web.Http.Results.OkResult(200 OK).
                             return Ok();
     
                            }//fin de if
     
                         else
                         {
                             return NotFound();
                         }//fin de else
                 }//fin de try
             catch (Exception e)
                 {
                     //// Résumé*:
                     //     Creates an System.Web.Http.Results.ExceptionResult (500 Internal Server Error)
                     //     with the specified exception.
                     //
                     return InternalServerError(e);
         }//fin de catch
     
      }//fin de méthode Put
     
     
     
        }//fin de classe
    }//fin de Namespace
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
     
     
    using ConsommerAPI;
    using e_Bibliotheque.Models;
    using Entite;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Threading.Tasks;
    using System.Web;
    using System.Web.Mvc;
    using Newtonsoft.Json;
     
    namespace e_Bibliotheque.Controllers
    {
        public class AuteurController : Controller
        {
            // GET: Auteur
            [HttpGet]
            public async Task<ActionResult> AfficherAuteurs()
            {
                VM_ListAuteurs model = new VM_ListAuteurs();
     
                try
                {
     
                    ServiceAuteur serviceAuteur = new ServiceAuteur();
     
                    model.ListAuteurs = await serviceAuteur.recupLesAuteursAsync();
     
                    return View(model);
     
                }
     
                catch(Exception ex)
                {
                    Console.WriteLine("une erreur s'est produite" + ex.Message);
     
                    return View(model);
                }
            }
     
            [HttpGet]
            [Route("{id:int}")]
            public async Task<ActionResult> DetailAuteur(int id)
            {
                VM_Auteur model = null;
                ServiceAuteur serviceAuteur = new ServiceAuteur();
                ViewBag.Id = id;
                Auteur auteur = await serviceAuteur.recupAuteurById(id);
     
                if (auteur != null)
                {
                    model = new VM_Auteur();
                    model.DateDeNaissance = auteur.DateOfBirthday;
                    model.Nom = auteur.Name;
                    model.Prenom = auteur.Surname;
     
                }
     
                return View(model);
            }
     
            [HttpGet]
            public ActionResult FormulaireAjoutAuteur()
            {
                VM_Auteur auteur = new VM_Auteur();
                return View(auteur);
            }
     
            [HttpPost]
     
            public async Task<ActionResult> FormulaireAjoutAuteur(VM_Auteur aut)
            {
     
                try
                {
                    ServiceAuteur servAuteur = new ServiceAuteur();
                    Auteur auteur = new Auteur() { Id = aut.Id_auteur, Surname = aut.Prenom, Name = aut.Nom, DateOfBirthday = aut.DateDeNaissance };
     
                    var ajoutResult = await servAuteur.AjouterUnAuteur(auteur);
     
                    if (ajoutResult != null)
                        return RedirectToAction("Accueil", "Accueil");
                    else
                        return View("FormulaireAjoutAuteur");
     
                }
     
                catch (Exception ex)
                {
                    Console.WriteLine("l'erreur suivante s'est produite" + ex.Message);
     
                    return View("FormulaireAjoutAuteur");  
     
                }
     
                }//fin de FormulaireAjoutauteur
     
     
     
            }//fin de classe
     
        }//fin de namepsace

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
     
     
    using Entite;
    using Repository.Interface;
    using System;
    using System.Collections.Generic;
    using System.Data.SqlClient;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using Dapper;
     
     
    namespace Repository
    {/// <summary>
    /// cette classe permet l'ajout, la suppression, la mise à jour et la sélection des auteurs 
    /// </summary>
        public class RepositoryAuteur: IRepositoryAuteur
        {
     
            /// <summary>
            /// Ce constructeur teste la chaîne de connexion
            /// </summary>
            public RepositoryAuteur()
            {
                try
                {
     
                    using (SqlConnection connection = Connexion.getInstance().SqlConnection)
     
                    {
                        connection.Open();
                    }
                }
                catch (Exception ex)
                {
                   Console.Write("Une erreur s'est produite pendant la connexion à la base de données " + ex.Message);
     
                }//fin de catch
     
            }//fin de méthode RepositoryAuteur()
     
            /// <summary>
            /// Cette Méthode prend en paramètre un auteur et l'ajoute en BDD
            /// </summary>
            /// <param name="o"></param>
            public void Add(Auteur o)
            {
                using (SqlConnection connection = Connexion.getInstance().SqlConnection)
                using (SqlCommand command = connection.CreateCommand())
                {
                    command.CommandText = "INSERT INTO AUTEUR(nom_auteur,prenom_auteur,date_naiss_auteur)VALUES (@nom_aut,@prenom_aut,@date_naiss_aut)";
                    command.Parameters.AddWithValue("@nom_aut", o.Name);
                    command.Parameters.AddWithValue("@prenom_aut", o.Surname);
                    command.Parameters.AddWithValue("@date_naiss_aut", o.DateOfBirthday);
                    connection.Open();
                    command.ExecuteNonQuery();
                }//fin de using
            }//fin de Add
           /// <summary>
           /// méthode de suppression d'un auteur passé en paramètre
           /// </summary>
           /// <param name="o"></param>
            public void Delete(Auteur o)
            {
                using (SqlConnection connection = Connexion.getInstance().SqlConnection)
                using (SqlCommand command = connection.CreateCommand())
                {
                    command.CommandText = "DELETE FROM AUTEUR WHERE prenom_auteur=@prenom_aut AND nom_auteur = @nom_aut AND date_naiss_auteur = @date_naiss_aut";
                    command.Parameters.AddWithValue("@prenom_aut", o.Surname);
                    command.Parameters.AddWithValue("@nom_aut", o.Name);
                    command.Parameters.AddWithValue("@date_naiss_aut", o.DateOfBirthday);
     
                    connection.Open();
                    command.ExecuteNonQuery();
                }
            }
            /// <summary>
            /// méthode de récupération de tous les auteurs 
            /// </summary>
            /// <returns>une liste d'auteurs</returns>
            public List<Auteur> GetAll()
            {
                List<Auteur> auteurs = new List<Auteur>();
                using (SqlConnection connection = Connexion.getInstance().SqlConnection)
                using (SqlCommand command = connection.CreateCommand())
                {
                    command.CommandText = "SELECT Id_auteur,nom_auteur,prenom_auteur,date_naiss_auteur FROM AUTEUR";
                    connection.Open();
                    var reader = command.ExecuteReader();
                    while (reader.Read())
                    {
                        Auteur auteur = new Auteur()
                        {
                            Id_auteur =(int)reader["Id_auteur"],
                            Name = reader["nom_auteur"] as string,
                            Surname = reader["prenom_auteur"] as string,
                            DateOfBirthday = (DateTime)reader["date_naiss_auteur"]
                        };
     
                        auteurs.Add(auteur);
                    }
                    return auteurs;
                }
            }
     
            /// <summary>
            /// recupération d'un auteur selon son Id
            /// </summary>
            /// <param name="id"></param>
            /// <returns></returns>
            public List<Auteur> GetById(int id)
            {
                using (SqlConnection connection = Connexion.getInstance().SqlConnection)
                using (SqlCommand command = connection.CreateCommand())
                {
                    command.CommandText = "SELECT Id_auteur,nom_auteur,prenom_auteur,date_naiss_auteur FROM AUTEUR WHERE Id_auteur=@Id";
                    command.Parameters.AddWithValue("@Id", id);
                    connection.Open();
                    var reader = command.ExecuteReader();
     
                    if (reader.Read())
                    {
     
                        Auteur auteur = new Auteur()
                        {
                            Id_auteur =(int) reader["Id_auteur"] ,
                            Name = reader["nom_auteur"] as string,
                            Surname = reader["prenom_auteur"] as string,
                            DateOfBirthday = (DateTime)reader["date_naiss_auteur"]
                        };//fin d'initialisation d'un auteur
     
                        List<Auteur> auteur_recupere = new List<Auteur>();
                        auteur_recupere.Add(auteur);
                        return auteur_recupere;
     
                    }//fin de if 
                    else
                    {
                        return null;
                    }//fin de else
                }//fin de using
            }//fin de GetById
     
            /// <summary>
            /// Sélectionne un auteur par son nom et prénom
            /// </summary>
            /// <param name="prenom"></param>
            /// <param name="nom"></param>
            /// <returns>un auteur</returns>
            public Auteur getByNameAndSurname(string prenom, string nom, DateTime? DateDeNaissance)
            {
                using (SqlConnection connection = Connexion.getInstance().SqlConnection)
                using (SqlCommand command = connection.CreateCommand())
                {
                    command.CommandText = "SELECT Id_auteur,nom_auteur,prenom_auteur,date_naiss_auteur FROM AUTEUR WHERE prenom_auteur=@Prenom_aut AND nom_auteur = @Nom_aut AND date_naiss_auteur = @DateNaiss_aut";
                    command.Parameters.AddWithValue("@Nom_aut", nom);
                    command.Parameters.AddWithValue("@Prenom_aut", prenom);
                    command.Parameters.AddWithValue("@DateNaiss_aut", DateDeNaissance);
     
                    connection.Open();
                    var reader = command.ExecuteReader();
     
                    reader.Read();
                    Auteur auteur = new Auteur()
                    {
                        Name = reader["nom_auteur"] as string,
                        Surname = reader["prenom_auteur"] as string,
                        DateOfBirthday = (DateTime)reader["date_naiss_auteur"]
     
                    };
     
                    return auteur;
                }
            }
            /// <summary>
            /// récupération de l' auteur d'un livre passé en paramètre 
            /// </summary>
            /// <param name="l"></param>
            /// <returns>un auteur</returns>
            public Auteur RecupParLivre(Livre l)
            {
                using (SqlConnection connection = Connexion.getInstance().SqlConnection)
                using (SqlCommand command = connection.CreateCommand())
                {
                    command.CommandText = "SELECT Id_auteur,nom_auteur,prenom_auteur,date_naiss_auteur FROM AUTEUR INNER JOIN LIVRE ON LIVRE.Auteur = AUTEUR.IdAuteur WHERE Id_livre = @IdLivre";
                    command.Parameters.AddWithValue("@IdLivre", l.Id_livre);
                    connection.Open();
                    var reader = command.ExecuteReader();
                    reader.Read();
     
                    Auteur auteur = new Auteur()
                    {
                        Id_auteur = (int)reader["Id_auteur"] ,
                        Name = reader["nom_auteur"] as string,
                        Surname = reader["prenom_auteur"] as string,
                        DateOfBirthday = (DateTime)reader["date_naiss_auteur"]
                    };
     
                    return auteur;
                }
            }
     
            public void Update(Auteur A)
            {
                using (SqlConnection connection = Connexion.getInstance().SqlConnection)
                using (SqlCommand command = connection.CreateCommand())
                {
                    command.CommandText = "UPDATE AUTEUR SET nom_auteur=@Nom_aut, prenom_auteur=@Prenom_aut,date_naiss_auteur=@DateNaiss_aut WHERE Id_auteur=@Id";
                    command.Parameters.AddWithValue("@Nom_aut", A.Name);
                    command.Parameters.AddWithValue("@Prenom_aut", A.Surname);
                    command.Parameters.AddWithValue("@DateNaiss_aut", A.DateOfBirthday);
                    command.Parameters.AddWithValue("@Id", A.Id_auteur);
     
                    connection.Open();
                    command.ExecuteNonQuery();
                }
            }
        }
    }
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
     
     
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
     
     
    namespace Entite
    {
        public class Auteur
        {
            public int Id_auteur { get; set; }
            public string Surname { get; set; }
            public string Name { get; set; }
            public DateTime DateOfBirthday { get; set; }
            public override string ToString()
            {
                return $" {Name} {Surname} {DateOfBirthday.ToShortDateString()}";
            }
     
     
     
        }//fin de classe
    }//fin de namespace
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
     
     
    using Entite;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using Dapper;
     
    namespace Repository.Interface
    {
        public interface IRepositoryAuteur:IRepository<Auteur>
        {
            Auteur getByNameAndSurname(string prenom, string nom, DateTime? dateDeNaissance);
        }
    }

  4. #4
    Expert confirmé
    Avatar de popo
    Homme Profil pro
    Analyste programmeur Delphi / C#
    Inscrit en
    Mars 2005
    Messages
    2 921
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Analyste programmeur Delphi / C#
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mars 2005
    Messages : 2 921
    Par défaut
    Là, on a quelque chose sur quoi s'appuyer

    Ton code montre un contrôleur Auteur dans une API ServeurAPI.
    Si c'est celle-là que tu souhaites appeler, il faut déjà commencer par utiliser le bon port.
    D'après ton écran 41380 est le port de e-biblothèque, pas de ServeurAPI qui lui s'ouvre sur le port 41782.

    Quand donne une requête cURL en POST sur http://localhost:41782/api/Auteur ?

  5. #5
    Membre éprouvé
    Profil pro
    Inscrit en
    Mai 2002
    Messages
    986
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2002
    Messages : 986
    Par défaut
    Bonjour,

    Merci de ta réponse.

    J'ai modifié , dans la classe ServiceAuteur(appli console consommerAPI) la valeur de l'adresse du serveur comme nécessaire.
    Maitenant, deux cas de figure

    1-Quand je demarre mon projet sur e-bibliotheque, j'ai l'affichage suivant (voir capt ecran)et dès que je veux créer un auteur, je bloque sur cette instruction , de la classe ServiceAuteur
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    //la méthode PostAsync envoie une requête asynchrone POST vers le serveur d'API à une méthode Post
                    objetReponse = await client.PostAsync($"{urlAPI}Auteur/", content);
    avec l'erreur

    {StatusCode: 500, ReasonPhrase: 'Internal Server Error', Version: 1.1, Content: System.Net.Http.StreamContent, Headers:
    {
    X-SourceFiles: =?UTF-8?B?QzpcVXNlcnNcaGFyQDQzXERvY3VtZW50c1xlX2JpYmxpb3RoZXF1ZV9vcmlnaW5lXFNlcnZldXJBUElcYXBpXEF1dGV1clw=?=
    Cache-Control: private
    Date: Thu, 18 Jan 2024 14:14:16 GMT
    Server: Microsoft-IIS/10.0
    X-AspNet-Version: 4.0.30319
    X-Powered-By: ASP.NET
    Content-Length: 11181
    Content-Type: text/html; charset=utf-8
    }}

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
     
    namespace ConsommerAPI
    {/// <summary>
     
     
        /// Cette classe, unique classe du projet ConsommeAPI, est une interface client vers le serveur ServeurAPI
        /// </summary>
        public class ServiceAuteur
        {
     
             private const string urlAPI = "http://localhost:41782/api/";
     
            /// <summary>
     
            /// <summary>
            /// fonction asynchrone d'ajout d'un auteur
            /// </summary>
            /// <param name="auteur"></param>
            /// <returns>l'auteur ajouté</returns>
     
            public async Task<Auteur> AjouterUnAuteur(Auteur auteur)
            {
                HttpResponseMessage objetReponse =null;
                try
                {
                    HttpClient client = new HttpClient();
     
                    //sérialization d'un auteur passé en paramètre au format JSON
                    //la classe de base JsonMediaTypeFormatter gère la sérialisation et la désérialisation des objets fortement typés à l'aide de l'ObjectContent. 
                    ObjectContent<Auteur> content = new ObjectContent<Auteur>(auteur, new JsonMediaTypeFormatter());
     
                    //la méthode PostAsync envoie une requête asynchrone POST vers le serveur d'API à une méthode Post
                    objetReponse = await client.PostAsync($"{urlAPI}Auteur/", content);
     
                    //si ce POST s'est bien effectué
                    if (objetReponse.IsSuccessStatusCode)
                    {
                        return auteur;
                    }//fin de if
                    else if (objetReponse.StatusCode == System.Net.HttpStatusCode.NotFound)
                    {
                        //l'instruction return null concerne une fonction  renvoyant un objet , l'instruction return concerne une fonction  ne renvoyant rien, c'est à dire avec le type de retour void
                        return null;
                    }//fin de else 
     
                }//fin de try
                catch(Exception ex)
                {
                    Console.WriteLine( $"Un problème avec API : status = {objetReponse.StatusCode}");
                    Console.WriteLine(ex.Message);
     
                }//fin de catch
                return null;
     
            }//fin de AjouterUnAuteur

    2-Si je demarre sur le service web ServeurApi ou si je saisis http://localhost:41782/api/Auteur dans la barre d'URL ,

    j'ai l'erreur suivante qui s'affiche (capture d'écran) avec le message suivant


    erreur {"The inline constraint resolver of type 'DefaultInlineConstraintResolver' was unable to resolve the following inline constraint: 'Auteur'."}

    Si je me souviens bien, je pense que le service web e-bibliotheque est lié à ConsommerAPI et que ServeurAPI est lié au client Rest.


    J'ai modifié mon message précédent pour te donner davantage d'infos à ce sujet.

    Merci en core beaucoup à toi de bien vouloir m'aider, car j'ai besoin de reprendre ce projet pour le maîtriser!

    Bien cordialement.

    new_wave
    Images attachées Images attachées    

  6. #6
    Expert confirmé
    Avatar de popo
    Homme Profil pro
    Analyste programmeur Delphi / C#
    Inscrit en
    Mars 2005
    Messages
    2 921
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Analyste programmeur Delphi / C#
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mars 2005
    Messages : 2 921
    Par défaut
    Je ne suis pas certain que le FromBody soit nécessaire.
    Ceci est l'exemple de Microsoft, et il ne l'ont pas mis.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    [RoutePrefix("api/books")]
    public class BooksController : ApiController
    {
        // GET api/books
        [Route("")]
        public IEnumerable<Book> Get() { ... }
     
        // GET api/books/5
        [Route("{id:int}")]
        public Book Get(int id) { ... }
     
        // POST api/books
        [Route("")]
        public HttpResponseMessage Post(Book book) { ... }
    }

  7. #7
    Expert confirmé
    Avatar de popo
    Homme Profil pro
    Analyste programmeur Delphi / C#
    Inscrit en
    Mars 2005
    Messages
    2 921
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Analyste programmeur Delphi / C#
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mars 2005
    Messages : 2 921
    Par défaut
    Si tu as un doute sur comment faire ton appel par code, Postman peut le générer pour toi. Cela s'effectue avec le bouton </> (chez moi il est sur la bande de droite).

  8. #8
    Membre éprouvé
    Profil pro
    Inscrit en
    Mai 2002
    Messages
    986
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2002
    Messages : 986
    Par défaut [resolu] envoi de requete post avec postman
    Bonjour et merci de ton retour.

    Je considère cette discussion comme résolue.

    L'envoi de requête via une application console "ConsommerAPI" fera l'objet d'une autre discussion

    Bien cordialement.

    new_wave


+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Erreur 404 Not Found Servlet
    Par ambe_fr dans le forum NetBeans
    Réponses: 1
    Dernier message: 27/07/2013, 12h37
  2. Erreur "404 not found"
    Par daydream123 dans le forum Spring
    Réponses: 2
    Dernier message: 03/02/2012, 15h58
  3. Erreur "faultString: (404)Not Found"
    Par notoriuous1 dans le forum Développement Web en Java
    Réponses: 0
    Dernier message: 28/12/2011, 13h15
  4. Apex et erreur 404 Not Found
    Par Kazevil dans le forum Administration
    Réponses: 1
    Dernier message: 25/03/2010, 14h47
  5. [phpBB][3] Erreur 404 not found lors de la demande de la page d'installation
    Par juninho dans le forum EDI, CMS, Outils, Scripts et API
    Réponses: 14
    Dernier message: 12/01/2008, 19h49

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo