Menu
CoddyTech

Noter les recettes

Fait partie de la section Minimal APIs du Journey ASP.NET Core de Coddy. Leçon 19 sur 20.

Ensuite, les apprenants attribuent aux recettes une note de 1 à 5 étoiles. Une note appartient à une seule recette : son adresse se trouve donc sous celle de la recette. Le préfixe d’un groupe peut contenir un paramètre de route ; tous les points de terminaison du groupe le reçoivent, et chaque lambda peut le demander par son nom :

var reviews = app.MapGroup("/api/books/{bookId:int}/reviews");
reviews.MapPost("/", (int bookId, NewReview input) => ...);
reviews.MapGet("/", (int bookId) => ...);

POST /api/books/7/reviews atteint le premier point de terminaison avec bookId défini sur 7, et le corps lu dans input.

challenge icon

Défi

Facile

POST /api/recipes/2/ratings avec {"stars":4} attribue une note à la recette 2. Garde tout ce que tu as écrit dans les leçons précédentes.

  1. Dans Recipe.cs, ajoute record NewRating(int Stars); et record Rating(int RecipeId, int Stars);.
  2. Dans Program.cs, sous favoriteIds, ajoute var ratings = new List<Rating>();.
  3. Au-dessus de app.Run(), crée le groupe app.MapGroup("/api/recipes/{id:int}/ratings") et associe-lui POST "/", en prenant int id et NewRating input.
  4. Lorsqu’aucune recette n’a cet identifiant, renvoie Results.NotFound(new { error = $"Recipe {id} not found" }).
  5. Ensuite, lorsque input.Stars est inférieur à 1 ou supérieur à 5, renvoie Results.BadRequest(new { error = "Stars must be from 1 to 5" }).
  6. Sinon, ajoute new Rating(id, input.Stars) à ratings et renvoie Results.Created($"/api/recipes/{id}/ratings", rating).

Essaie : appuie sur Exécuter, puis envoie POST {"stars":4} à /api/recipes/2/ratings : statut 201, {"recipeId":2,"stars":4} et Location: /api/recipes/2/ratings. Envoie POST {"stars":6} : 400. Envoie POST à /api/recipes/99/ratings : 404 {"error":"Recipe 99 not found"}.

Essayez vous-même

using Microsoft.AspNetCore.Http.HttpResults;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.Use(async (context, next) =>
{
    await next();
    app.Logger.LogInformation("{Method} {Path} -> {Status}",
        context.Request.Method, context.Request.Path, context.Response.StatusCode);
});

app.Use(async (context, next) =>
{
    context.Response.Headers["X-Api-Version"] = "1";
    await next();
});

app.Use(async (context, next) =>
{
    if (context.Request.Path.StartsWithSegments("/recipes"))
    {
        context.Response.Redirect("/api" + context.Request.Path + context.Request.QueryString, permanent: true);
        return;
    }
    await next();
});

app.UseStaticFiles();

var recipes = new List<Recipe>
{
    new(1, "Tomato Soup", "soup", 25),
    new(2, "Pancakes", "breakfast", 15),
    new(3, "Lentil Soup", "soup", 40),
};
var nextId = 4;
var favoriteIds = new List<int>();

app.MapGet("/", () => "Recipe API is running");
app.MapGet("/api/recipes", (string? category) =>
    recipes.Where(r => category is null || r.Category == category));
app.MapGet("/api/recipes/search", (string? q) =>
{
    if (string.IsNullOrWhiteSpace(q))
        return Results.BadRequest(new { error = "Add ?q= to search" });
    return Results.Ok(recipes.Where(r => r.Name.Contains(q, StringComparison.OrdinalIgnoreCase)));
});
app.MapGet("/api/recipes/{id:int}", (int id, ILogger<Program> logger) =>
{
    var recipe = recipes.FirstOrDefault(r => r.Id == id);
    if (recipe is null)
    {
        logger.LogWarning("Recipe {Id} was not found", id);
        return Results.NotFound(new { error = $"Recipe {id} not found" });
    }
    return Results.Ok(recipe);
});

app.MapPost("/api/recipes", (NewRecipe input, ILogger<Program> logger) =>
{
    if (string.IsNullOrWhiteSpace(input.Name))
        return Results.BadRequest(new { error = "Name is required" });
    if (input.Minutes <= 0)
        return Results.BadRequest(new { error = "Minutes must be more than 0" });
    var recipe = new Recipe(nextId++, input.Name, input.Category, input.Minutes);
    recipes.Add(recipe);
    logger.LogInformation("Added recipe {Id}: {Name}", recipe.Id, recipe.Name);
    return Results.Created($"/api/recipes/{recipe.Id}", recipe);
});

app.MapPut("/api/recipes/{id:int}", (int id, NewRecipe input) =>
{
    var index = recipes.FindIndex(r => r.Id == id);
    if (index == -1)
        return Results.NotFound(new { error = $"Recipe {id} not found" });
    var recipe = new Recipe(id, input.Name, input.Category, input.Minutes);
    recipes[index] = recipe;
    return Results.Ok(recipe);
});

app.MapDelete("/api/recipes/{id:int}", Results<NoContent, NotFound> (int id) =>
{
    var removed = recipes.RemoveAll(r => r.Id == id);
    return removed > 0 ? TypedResults.NoContent() : TypedResults.NotFound();
});

var favorites = app.MapGroup("/api/favorites");
favorites.MapGet("/", () => recipes.Where(r => favoriteIds.Contains(r.Id)));
favorites.MapPost("/{id:int}", (int id) =>
{
    if (!recipes.Any(r => r.Id == id))
        return Results.NotFound(new { error = $"Recipe {id} not found" });
    if (!favoriteIds.Contains(id))
        favoriteIds.Add(id);
    return Results.NoContent();
});
favorites.MapDelete("/{id:int}", (int id) =>
{
    favoriteIds.Remove(id);
    return Results.NoContent();
});

app.Run();

Toutes les leçons de Minimal APIs