gburri/recipes
1
0
Fork 0
Code Issues 6 Pull requests Projects Releases Packages Wiki Activity Actions

Simplify web API (put ids in url)

Browse source
This commit is contained in:
Greg Burri 2025-05-19 22:58:00 +02:00
parent 0c43935bef
commit 6e017e41a3
14 changed files with 403 additions and 588 deletions
Download patch file Download diff file Expand all files Collapse all files

14
backend/src/services/ron/mod.rs
View file

@ -1,6 +1,6 @@
use axum::{
debug_handler,
extract::{Extension, Query, State},
extract::{Extension, Path, Query, State},
http::{HeaderMap, StatusCode},
response::{IntoResponse, Result},
};
@ -25,14 +25,14 @@ pub async fn set_lang(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
headers: HeaderMap,
ExtractRon(ron): ExtractRon<common::ron_api::SetLang>,
ExtractRon(lang): ExtractRon<String>,
) -> Result<(CookieJar, StatusCode)> {
let mut jar = CookieJar::from_headers(&headers);
if let Some(user) = context.user {
connection.set_user_lang(user.id, &ron.lang).await?;
connection.set_user_lang(user.id, &lang).await?;
} else {
// Only set the cookie if the user is not connected.
let cookie = Cookie::build((consts::COOKIE_LANG_NAME, ron.lang))
let cookie = Cookie::build((consts::COOKIE_LANG_NAME, lang))
.same_site(SameSite::Lax)
.path("/");
jar = jar.add(cookie);
@ -43,11 +43,9 @@ pub async fn set_lang(
#[debug_handler]
pub async fn get_translation(
Extension(context): Extension<Context>,
translation_id: Query<ron_api::Id>,
Path(id): Path<i64>,
) -> Result<impl IntoResponse> {
Ok(ron_response_ok(ron_api::Value {
value: context.tr.t_from_id(translation_id.id),
}))
Ok(ron_response_ok(context.tr.t_from_id(id)))
}
/*** 404 ***/

281
backend/src/services/ron/recipe.rs
View file

@ -1,12 +1,12 @@
use axum::{
debug_handler,
extract::{Extension, State},
extract::{Extension, Path, State},
http::StatusCode,
response::{IntoResponse, Result},
};
use axum_extra::extract::Query;
use common::ron_api;
// use tracing::{event, Level};
use tracing::warn;
use crate::{
app::Context, data::db, data::model, ron_extractor::ExtractRon, ron_utils::ron_response_ok,
@ -19,23 +19,22 @@ use super::rights::*;
#[debug_handler]
pub async fn get_titles(
State(connection): State<db::Connection>,
recipe_ids: Query<ron_api::Ids>,
recipe_ids: Query<Vec<i64>>,
) -> Result<impl IntoResponse> {
Ok(ron_response_ok(ron_api::Strings {
strs: connection.get_recipe_titles(&recipe_ids.ids).await?,
}))
Ok(ron_response_ok(
connection.get_recipe_titles(&recipe_ids).await?,
))
}
#[debug_handler]
pub async fn set_title(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::SetRecipeTitle>,
Path(recipe_id): Path<i64>,
ExtractRon(title): ExtractRon<String>,
) -> Result<StatusCode> {
check_user_rights_recipe(&connection, &context.user, ron.recipe_id).await?;
connection
.set_recipe_title(ron.recipe_id, &ron.title)
.await?;
check_user_rights_recipe(&connection, &context.user, recipe_id).await?;
connection.set_recipe_title(recipe_id, &title).await?;
Ok(StatusCode::OK)
}
@ -43,11 +42,12 @@ pub async fn set_title(
pub async fn set_description(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::SetRecipeDescription>,
Path(recipe_id): Path<i64>,
ExtractRon(description): ExtractRon<String>,
) -> Result<StatusCode> {
check_user_rights_recipe(&connection, &context.user, ron.recipe_id).await?;
check_user_rights_recipe(&connection, &context.user, recipe_id).await?;
connection
.set_recipe_description(ron.recipe_id, &ron.description)
.set_recipe_description(recipe_id, &description)
.await?;
Ok(StatusCode::OK)
}
@ -56,12 +56,11 @@ pub async fn set_description(
pub async fn set_servings(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::SetRecipeServings>,
Path(recipe_id): Path<i64>,
ExtractRon(servings): ExtractRon<Option<u32>>,
) -> Result<StatusCode> {
check_user_rights_recipe(&connection, &context.user, ron.recipe_id).await?;
connection
.set_recipe_servings(ron.recipe_id, ron.servings)
.await?;
check_user_rights_recipe(&connection, &context.user, recipe_id).await?;
connection.set_recipe_servings(recipe_id, servings).await?;
Ok(StatusCode::OK)
}
@ -69,11 +68,12 @@ pub async fn set_servings(
pub async fn set_estimated_time(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::SetRecipeEstimatedTime>,
Path(recipe_id): Path<i64>,
ExtractRon(time): ExtractRon<Option<u32>>,
) -> Result<StatusCode> {
check_user_rights_recipe(&connection, &context.user, ron.recipe_id).await?;
check_user_rights_recipe(&connection, &context.user, recipe_id).await?;
connection
.set_recipe_estimated_time(ron.recipe_id, ron.estimated_time)
.set_recipe_estimated_time(recipe_id, time)
.await?;
Ok(StatusCode::OK)
}
@ -81,30 +81,22 @@ pub async fn set_estimated_time(
#[debug_handler]
pub async fn get_tags(
State(connection): State<db::Connection>,
recipe_id: Query<ron_api::Id>,
Path(recipe_id): Path<i64>,
) -> Result<impl IntoResponse> {
Ok(ron_response_ok(ron_api::Tags {
recipe_id: recipe_id.id,
tags: connection.get_recipes_tags(recipe_id.id).await?,
}))
Ok(ron_response_ok(
connection.get_recipes_tags(recipe_id).await?,
))
}
#[debug_handler]
pub async fn add_tags(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::Tags>,
Path(recipe_id): Path<i64>,
ExtractRon(tags): ExtractRon<Vec<String>>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe(&connection, &context.user, ron.recipe_id).await?;
connection
.add_recipe_tags(
ron.recipe_id,
&ron.tags
.into_iter()
.map(|tag| tag.to_lowercase())
.collect::<Vec<_>>(),
)
.await?;
check_user_rights_recipe(&connection, &context.user, recipe_id).await?;
connection.add_recipe_tags(recipe_id, &tags).await?;
Ok(StatusCode::OK)
}
@ -112,18 +104,11 @@ pub async fn add_tags(
pub async fn rm_tags(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::Tags>,
Path(recipe_id): Path<i64>,
ExtractRon(tags): ExtractRon<Vec<String>>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe(&connection, &context.user, ron.recipe_id).await?;
connection
.rm_recipe_tags(
ron.recipe_id,
&ron.tags
.into_iter()
.map(|tag| tag.to_lowercase())
.collect::<Vec<_>>(),
)
.await?;
check_user_rights_recipe(&connection, &context.user, recipe_id).await?;
connection.rm_recipe_tags(recipe_id, &tags).await?;
Ok(StatusCode::OK)
}
@ -131,11 +116,12 @@ pub async fn rm_tags(
pub async fn set_difficulty(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::SetRecipeDifficulty>,
Path(recipe_id): Path<i64>,
ExtractRon(difficulty): ExtractRon<ron_api::Difficulty>,
) -> Result<StatusCode> {
check_user_rights_recipe(&connection, &context.user, ron.recipe_id).await?;
check_user_rights_recipe(&connection, &context.user, recipe_id).await?;
connection
.set_recipe_difficulty(ron.recipe_id, ron.difficulty)
.set_recipe_difficulty(recipe_id, difficulty)
.await?;
Ok(StatusCode::OK)
}
@ -144,20 +130,19 @@ pub async fn set_difficulty(
pub async fn set_language(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::SetRecipeLanguage>,
Path(recipe_id): Path<i64>,
ExtractRon(lang): ExtractRon<String>,
) -> Result<StatusCode> {
if !crate::translation::available_codes()
.iter()
.any(|&l| l == ron.lang)
.any(|&l| l == lang)
{
// TODO: log?
warn!("Can't find language: {}", lang);
return Ok(StatusCode::BAD_REQUEST);
}
check_user_rights_recipe(&connection, &context.user, ron.recipe_id).await?;
connection
.set_recipe_language(ron.recipe_id, &ron.lang)
.await?;
check_user_rights_recipe(&connection, &context.user, recipe_id).await?;
connection.set_recipe_language(recipe_id, &lang).await?;
Ok(StatusCode::OK)
}
@ -165,11 +150,12 @@ pub async fn set_language(
pub async fn set_is_public(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::SetRecipeIsPublic>,
Path(recipe_id): Path<i64>,
ExtractRon(is_public): ExtractRon<bool>,
) -> Result<StatusCode> {
check_user_rights_recipe(&connection, &context.user, ron.recipe_id).await?;
check_user_rights_recipe(&connection, &context.user, recipe_id).await?;
connection
.set_recipe_is_public(ron.recipe_id, ron.is_public)
.set_recipe_is_public(recipe_id, is_public)
.await?;
Ok(StatusCode::OK)
}
@ -178,10 +164,10 @@ pub async fn set_is_public(
pub async fn rm(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::Id>,
Path(recipe_id): Path<i64>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe(&connection, &context.user, ron.id).await?;
connection.rm_recipe(ron.id).await?;
check_user_rights_recipe(&connection, &context.user, recipe_id).await?;
connection.rm_recipe(recipe_id).await?;
Ok(StatusCode::OK)
}
@ -225,12 +211,12 @@ impl From<model::Ingredient> for ron_api::Ingredient {
#[debug_handler]
pub async fn get_groups(
State(connection): State<db::Connection>,
recipe_id: Query<ron_api::Id>,
Path(recipe_id): Path<i64>,
) -> Result<impl IntoResponse> {
// Here we don't check user rights on purpose.
Ok(ron_response_ok(
connection
.get_groups(recipe_id.id)
.get_groups(recipe_id)
.await?
.into_iter()
.map(ron_api::Group::from)
@ -242,22 +228,32 @@ pub async fn get_groups(
pub async fn add_group(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::Id>,
Path(recipe_id): Path<i64>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe(&connection, &context.user, ron.id).await?;
let id = connection.add_recipe_group(ron.id).await?;
check_user_rights_recipe(&connection, &context.user, recipe_id).await?;
let id = connection.add_recipe_group(recipe_id).await?;
Ok(ron_response_ok(id))
}
Ok(ron_response_ok(ron_api::Id { id }))
#[debug_handler]
pub async fn set_groups_order(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ids): ExtractRon<Vec<i64>>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_groups(&connection, &context.user, &ids).await?;
connection.set_groups_order(&ids).await?;
Ok(StatusCode::OK)
}
#[debug_handler]
pub async fn rm_group(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::Id>,
Path(groupe_id): Path<i64>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_group(&connection, &context.user, ron.id).await?;
connection.rm_recipe_group(ron.id).await?;
check_user_rights_recipe_group(&connection, &context.user, groupe_id).await?;
connection.rm_recipe_group(groupe_id).await?;
Ok(StatusCode::OK)
}
@ -265,10 +261,11 @@ pub async fn rm_group(
pub async fn set_group_name(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::SetGroupName>,
Path(group_id): Path<i64>,
ExtractRon(name): ExtractRon<String>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_group(&connection, &context.user, ron.group_id).await?;
connection.set_group_name(ron.group_id, &ron.name).await?;
check_user_rights_recipe_group(&connection, &context.user, group_id).await?;
connection.set_group_name(group_id, &name).await?;
Ok(StatusCode::OK)
}
@ -276,23 +273,11 @@ pub async fn set_group_name(
pub async fn set_group_comment(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::SetGroupComment>,
Path(group_id): Path<i64>,
ExtractRon(comment): ExtractRon<String>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_group(&connection, &context.user, ron.group_id).await?;
connection
.set_group_comment(ron.group_id, &ron.comment)
.await?;
Ok(StatusCode::OK)
}
#[debug_handler]
pub async fn set_groups_order(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::Ids>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_groups(&connection, &context.user, &ron.ids).await?;
connection.set_groups_order(&ron.ids).await?;
check_user_rights_recipe_group(&connection, &context.user, group_id).await?;
connection.set_group_comment(group_id, &comment).await?;
Ok(StatusCode::OK)
}
@ -300,22 +285,32 @@ pub async fn set_groups_order(
pub async fn add_step(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::Id>,
Path(group_id): Path<i64>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_group(&connection, &context.user, ron.id).await?;
let id = connection.add_recipe_step(ron.id).await?;
check_user_rights_recipe_group(&connection, &context.user, group_id).await?;
let id = connection.add_recipe_step(group_id).await?;
Ok(ron_response_ok(id))
}
Ok(ron_response_ok(ron_api::Id { id }))
#[debug_handler]
pub async fn set_steps_order(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ids): ExtractRon<Vec<i64>>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_steps(&connection, &context.user, &ids).await?;
connection.set_steps_order(&ids).await?;
Ok(StatusCode::OK)
}
#[debug_handler]
pub async fn rm_step(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::Id>,
Path(step_id): Path<i64>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_step(&connection, &context.user, ron.id).await?;
connection.rm_recipe_step(ron.id).await?;
check_user_rights_recipe_step(&connection, &context.user, step_id).await?;
connection.rm_recipe_step(step_id).await?;
Ok(StatusCode::OK)
}
@ -323,21 +318,11 @@ pub async fn rm_step(
pub async fn set_step_action(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::SetStepAction>,
Path(step_id): Path<i64>,
ExtractRon(action): ExtractRon<String>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_step(&connection, &context.user, ron.step_id).await?;
connection.set_step_action(ron.step_id, &ron.action).await?;
Ok(StatusCode::OK)
}
#[debug_handler]
pub async fn set_steps_order(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::Ids>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_steps(&connection, &context.user, &ron.ids).await?;
connection.set_steps_order(&ron.ids).await?;
check_user_rights_recipe_step(&connection, &context.user, step_id).await?;
connection.set_step_action(step_id, &action).await?;
Ok(StatusCode::OK)
}
@ -345,21 +330,32 @@ pub async fn set_steps_order(
pub async fn add_ingredient(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::Id>,
Path(step_id): Path<i64>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_step(&connection, &context.user, ron.id).await?;
let id = connection.add_recipe_ingredient(ron.id).await?;
Ok(ron_response_ok(ron_api::Id { id }))
check_user_rights_recipe_step(&connection, &context.user, step_id).await?;
let id = connection.add_recipe_ingredient(step_id).await?;
Ok(ron_response_ok(id))
}
#[debug_handler]
pub async fn set_ingredients_order(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ids): ExtractRon<Vec<i64>>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_ingredients(&connection, &context.user, &ids).await?;
connection.set_ingredients_order(&ids).await?;
Ok(StatusCode::OK)
}
#[debug_handler]
pub async fn rm_ingredient(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::Id>,
Path(ingredient_id): Path<i64>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_ingredient(&connection, &context.user, ron.id).await?;
connection.rm_recipe_ingredient(ron.id).await?;
check_user_rights_recipe_ingredient(&connection, &context.user, ingredient_id).await?;
connection.rm_recipe_ingredient(ingredient_id).await?;
Ok(StatusCode::OK)
}
@ -367,12 +363,11 @@ pub async fn rm_ingredient(
pub async fn set_ingredient_name(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::SetIngredientName>,
Path(ingredient_id): Path<i64>,
ExtractRon(name): ExtractRon<String>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_ingredient(&connection, &context.user, ron.ingredient_id).await?;
connection
.set_ingredient_name(ron.ingredient_id, &ron.name)
.await?;
check_user_rights_recipe_ingredient(&connection, &context.user, ingredient_id).await?;
connection.set_ingredient_name(ingredient_id, &name).await?;
Ok(StatusCode::OK)
}
@ -380,11 +375,12 @@ pub async fn set_ingredient_name(
pub async fn set_ingredient_comment(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::SetIngredientComment>,
Path(ingredient_id): Path<i64>,
ExtractRon(comment): ExtractRon<String>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_ingredient(&connection, &context.user, ron.ingredient_id).await?;
check_user_rights_recipe_ingredient(&connection, &context.user, ingredient_id).await?;
connection
.set_ingredient_comment(ron.ingredient_id, &ron.comment)
.set_ingredient_comment(ingredient_id, &comment)
.await?;
Ok(StatusCode::OK)
}
@ -393,11 +389,12 @@ pub async fn set_ingredient_comment(
pub async fn set_ingredient_quantity(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::SetIngredientQuantity>,
Path(ingredient_id): Path<i64>,
ExtractRon(quantity): ExtractRon<Option<f64>>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_ingredient(&connection, &context.user, ron.ingredient_id).await?;
check_user_rights_recipe_ingredient(&connection, &context.user, ingredient_id).await?;
connection
.set_ingredient_quantity(ron.ingredient_id, ron.quantity)
.set_ingredient_quantity(ingredient_id, quantity)
.await?;
Ok(StatusCode::OK)
}
@ -406,22 +403,10 @@ pub async fn set_ingredient_quantity(
pub async fn set_ingredient_unit(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::SetIngredientUnit>,
Path(ingredient_id): Path<i64>,
ExtractRon(unit): ExtractRon<String>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_ingredient(&connection, &context.user, ron.ingredient_id).await?;
connection
.set_ingredient_unit(ron.ingredient_id, &ron.unit)
.await?;
Ok(StatusCode::OK)
}
#[debug_handler]
pub async fn set_ingredients_order(
State(connection): State<db::Connection>,
Extension(context): Extension<Context>,
ExtractRon(ron): ExtractRon<ron_api::Ids>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_ingredients(&connection, &context.user, &ron.ids).await?;
connection.set_ingredients_order(&ron.ids).await?;
check_user_rights_recipe_ingredient(&connection, &context.user, ingredient_id).await?;
connection.set_ingredient_unit(ingredient_id, &unit).await?;
Ok(StatusCode::OK)
}