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

Factorize some ron api types

Browse source
This commit is contained in:
Greg Burri 2025-01-16 00:43:19 +01:00
parent ca2227037f
commit 67e13d9074
3 changed files with 62 additions and 211 deletions
Download patch file Download diff file Expand all files Collapse all files

77
backend/src/services/ron.rs
View file

@ -346,10 +346,10 @@ pub async fn set_is_published(
pub async fn rm( pub async fn rm(
State(connection): State<db::Connection>, State(connection): State<db::Connection>,
Extension(user): Extension<Option<model::User>>, Extension(user): Extension<Option<model::User>>,
ExtractRon(ron): ExtractRon<common::ron_api::Remove>, ExtractRon(ron): ExtractRon<common::ron_api::Id>,
) -> Result<impl IntoResponse> { ) -> Result<impl IntoResponse> {
check_user_rights_recipe(&connection, &user, ron.recipe_id).await?; check_user_rights_recipe(&connection, &user, ron.id).await?;
connection.rm_recipe(ron.recipe_id).await?; connection.rm_recipe(ron.id).await?;
Ok(StatusCode::OK) Ok(StatusCode::OK)
} }
@ -415,25 +415,22 @@ pub async fn get_groups(
pub async fn add_group( pub async fn add_group(
State(connection): State<db::Connection>, State(connection): State<db::Connection>,
Extension(user): Extension<Option<model::User>>, Extension(user): Extension<Option<model::User>>,
ExtractRon(ron): ExtractRon<common::ron_api::AddRecipeGroup>, ExtractRon(ron): ExtractRon<common::ron_api::Id>,
) -> Result<impl IntoResponse> { ) -> Result<impl IntoResponse> {
check_user_rights_recipe(&connection, &user, ron.recipe_id).await?; check_user_rights_recipe(&connection, &user, ron.id).await?;
let group_id = connection.add_recipe_group(ron.recipe_id).await?; let id = connection.add_recipe_group(ron.id).await?;
Ok(ron_response( Ok(ron_response(StatusCode::OK, common::ron_api::Id { id }))
StatusCode::OK,
common::ron_api::AddRecipeGroupResult { group_id },
))
} }
#[debug_handler] #[debug_handler]
pub async fn rm_group( pub async fn rm_group(
State(connection): State<db::Connection>, State(connection): State<db::Connection>,
Extension(user): Extension<Option<model::User>>, Extension(user): Extension<Option<model::User>>,
ExtractRon(ron): ExtractRon<common::ron_api::RemoveRecipeGroup>, ExtractRon(ron): ExtractRon<common::ron_api::Id>,
) -> Result<impl IntoResponse> { ) -> Result<impl IntoResponse> {
check_user_rights_recipe_group(&connection, &user, ron.group_id).await?; check_user_rights_recipe_group(&connection, &user, ron.id).await?;
connection.rm_recipe_group(ron.group_id).await?; connection.rm_recipe_group(ron.id).await?;
Ok(StatusCode::OK) Ok(StatusCode::OK)
} }
@ -465,10 +462,10 @@ pub async fn set_group_comment(
pub async fn set_groups_order( pub async fn set_groups_order(
State(connection): State<db::Connection>, State(connection): State<db::Connection>,
Extension(user): Extension<Option<model::User>>, Extension(user): Extension<Option<model::User>>,
ExtractRon(ron): ExtractRon<common::ron_api::SetGroupOrders>, ExtractRon(ron): ExtractRon<common::ron_api::Ids>,
) -> Result<impl IntoResponse> { ) -> Result<impl IntoResponse> {
check_user_rights_recipe_groups(&connection, &user, &ron.group_ids).await?; check_user_rights_recipe_groups(&connection, &user, &ron.ids).await?;
connection.set_groups_order(&ron.group_ids).await?; connection.set_groups_order(&ron.ids).await?;
Ok(StatusCode::OK) Ok(StatusCode::OK)
} }
@ -476,25 +473,22 @@ pub async fn set_groups_order(
pub async fn add_step( pub async fn add_step(
State(connection): State<db::Connection>, State(connection): State<db::Connection>,
Extension(user): Extension<Option<model::User>>, Extension(user): Extension<Option<model::User>>,
ExtractRon(ron): ExtractRon<common::ron_api::AddRecipeStep>, ExtractRon(ron): ExtractRon<common::ron_api::Id>,
) -> Result<impl IntoResponse> { ) -> Result<impl IntoResponse> {
check_user_rights_recipe_group(&connection, &user, ron.group_id).await?; check_user_rights_recipe_group(&connection, &user, ron.id).await?;
let step_id = connection.add_recipe_step(ron.group_id).await?; let id = connection.add_recipe_step(ron.id).await?;
Ok(ron_response( Ok(ron_response(StatusCode::OK, common::ron_api::Id { id }))
StatusCode::OK,
common::ron_api::AddRecipeStepResult { step_id },
))
} }
#[debug_handler] #[debug_handler]
pub async fn rm_step( pub async fn rm_step(
State(connection): State<db::Connection>, State(connection): State<db::Connection>,
Extension(user): Extension<Option<model::User>>, Extension(user): Extension<Option<model::User>>,
ExtractRon(ron): ExtractRon<common::ron_api::RemoveRecipeStep>, ExtractRon(ron): ExtractRon<common::ron_api::Id>,
) -> Result<impl IntoResponse> { ) -> Result<impl IntoResponse> {
check_user_rights_recipe_step(&connection, &user, ron.step_id).await?; check_user_rights_recipe_step(&connection, &user, ron.id).await?;
connection.rm_recipe_step(ron.step_id).await?; connection.rm_recipe_step(ron.id).await?;
Ok(StatusCode::OK) Ok(StatusCode::OK)
} }
@ -513,10 +507,10 @@ pub async fn set_step_action(
pub async fn set_steps_order( pub async fn set_steps_order(
State(connection): State<db::Connection>, State(connection): State<db::Connection>,
Extension(user): Extension<Option<model::User>>, Extension(user): Extension<Option<model::User>>,
ExtractRon(ron): ExtractRon<common::ron_api::SetStepOrders>, ExtractRon(ron): ExtractRon<common::ron_api::Ids>,
) -> Result<impl IntoResponse> { ) -> Result<impl IntoResponse> {
check_user_rights_recipe_steps(&connection, &user, &ron.step_ids).await?; check_user_rights_recipe_steps(&connection, &user, &ron.ids).await?;
connection.set_steps_order(&ron.step_ids).await?; connection.set_steps_order(&ron.ids).await?;
Ok(StatusCode::OK) Ok(StatusCode::OK)
} }
@ -524,25 +518,22 @@ pub async fn set_steps_order(
pub async fn add_ingredient( pub async fn add_ingredient(
State(connection): State<db::Connection>, State(connection): State<db::Connection>,
Extension(user): Extension<Option<model::User>>, Extension(user): Extension<Option<model::User>>,
ExtractRon(ron): ExtractRon<common::ron_api::AddRecipeIngredient>, ExtractRon(ron): ExtractRon<common::ron_api::Id>,
) -> Result<impl IntoResponse> { ) -> Result<impl IntoResponse> {
check_user_rights_recipe_step(&connection, &user, ron.step_id).await?; check_user_rights_recipe_step(&connection, &user, ron.id).await?;
let ingredient_id = connection.add_recipe_ingredient(ron.step_id).await?; let id = connection.add_recipe_ingredient(ron.id).await?;
Ok(ron_response( Ok(ron_response(StatusCode::OK, common::ron_api::Id { id }))
StatusCode::OK,
common::ron_api::AddRecipeIngredientResult { ingredient_id },
))
} }
#[debug_handler] #[debug_handler]
pub async fn rm_ingredient( pub async fn rm_ingredient(
State(connection): State<db::Connection>, State(connection): State<db::Connection>,
Extension(user): Extension<Option<model::User>>, Extension(user): Extension<Option<model::User>>,
ExtractRon(ron): ExtractRon<common::ron_api::RemoveRecipeIngredient>, ExtractRon(ron): ExtractRon<common::ron_api::Id>,
) -> Result<impl IntoResponse> { ) -> Result<impl IntoResponse> {
check_user_rights_recipe_ingredient(&connection, &user, ron.ingredient_id).await?; check_user_rights_recipe_ingredient(&connection, &user, ron.id).await?;
connection.rm_recipe_ingredient(ron.ingredient_id).await?; connection.rm_recipe_ingredient(ron.id).await?;
Ok(StatusCode::OK) Ok(StatusCode::OK)
} }
@ -602,12 +593,10 @@ pub async fn set_ingredient_unit(
pub async fn set_ingredients_order( pub async fn set_ingredients_order(
State(connection): State<db::Connection>, State(connection): State<db::Connection>,
Extension(user): Extension<Option<model::User>>, Extension(user): Extension<Option<model::User>>,
ExtractRon(ron): ExtractRon<common::ron_api::SetIngredientOrders>, ExtractRon(ron): ExtractRon<common::ron_api::Ids>,
) -> Result<impl IntoResponse> { ) -> Result<impl IntoResponse> {
check_user_rights_recipe_ingredients(&connection, &user, &ron.ingredient_ids).await?; check_user_rights_recipe_ingredients(&connection, &user, &ron.ids).await?;
connection connection.set_ingredients_order(&ron.ids).await?;
.set_ingredients_order(&ron.ingredient_ids)
.await?;
Ok(StatusCode::OK) Ok(StatusCode::OK)
} }

155
common/src/ron_api.rs
View file

@ -6,6 +6,16 @@ pub struct SetLang {
pub lang: String, pub lang: String,
} }
#[derive(Serialize, Deserialize, Clone)]
pub struct Ids {
pub ids: Vec<i64>,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct Id {
pub id: i64,
}
///// RECIPE ///// ///// RECIPE /////
#[derive(Serialize, Deserialize, Clone)] #[derive(Serialize, Deserialize, Clone)]
@ -76,26 +86,6 @@ pub struct SetIsPublished {
pub is_published: bool, pub is_published: bool,
} }
#[derive(Serialize, Deserialize, Clone)]
pub struct Remove {
pub recipe_id: i64,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct AddRecipeGroup {
pub recipe_id: i64,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct AddRecipeGroupResult {
pub group_id: i64,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct RemoveRecipeGroup {
pub group_id: i64,
}
#[derive(Serialize, Deserialize, Clone)] #[derive(Serialize, Deserialize, Clone)]
pub struct SetGroupName { pub struct SetGroupName {
pub group_id: i64, pub group_id: i64,
@ -108,52 +98,12 @@ pub struct SetGroupComment {
pub comment: String, pub comment: String,
} }
#[derive(Serialize, Deserialize, Clone)]
pub struct SetGroupOrders {
pub group_ids: Vec<i64>,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct AddRecipeStep {
pub group_id: i64,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct AddRecipeStepResult {
pub step_id: i64,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct RemoveRecipeStep {
pub step_id: i64,
}
#[derive(Serialize, Deserialize, Clone)] #[derive(Serialize, Deserialize, Clone)]
pub struct SetStepAction { pub struct SetStepAction {
pub step_id: i64, pub step_id: i64,
pub action: String, pub action: String,
} }
#[derive(Serialize, Deserialize, Clone)]
pub struct SetStepOrders {
pub step_ids: Vec<i64>,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct AddRecipeIngredient {
pub step_id: i64,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct AddRecipeIngredientResult {
pub ingredient_id: i64,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct RemoveRecipeIngredient {
pub ingredient_id: i64,
}
#[derive(Serialize, Deserialize, Clone)] #[derive(Serialize, Deserialize, Clone)]
pub struct SetIngredientName { pub struct SetIngredientName {
pub ingredient_id: i64, pub ingredient_id: i64,
@ -178,11 +128,6 @@ pub struct SetIngredientUnit {
pub unit: String, pub unit: String,
} }
#[derive(Serialize, Deserialize, Clone)]
pub struct SetIngredientOrders {
pub ingredient_ids: Vec<i64>,
}
#[derive(Serialize, Deserialize, Clone)] #[derive(Serialize, Deserialize, Clone)]
pub struct Tags { pub struct Tags {
pub recipe_id: i64, pub recipe_id: i64,
@ -213,86 +158,6 @@ pub struct Ingredient {
pub quantity_unit: String, pub quantity_unit: String,
} }
// #[derive(Serialize, Deserialize, Clone)]
// pub struct AddRecipeImage {
// pub recipe_id: i64,
// pub image: Vec<u8>,
// }
// #[derive(Serialize, Deserialize, Clone)]
// pub struct AddRecipeImageReply {
// pub image_id: i64,
// }
// #[derive(Serialize, Deserialize, Clone)]
// pub struct RemoveRecipeImage {
// pub image_id: i64,
// }
// #[derive(Serialize, Deserialize, Clone)]
// pub struct AddRecipeIngredient {
// pub group_id: i64,
// pub name: String,
// pub quantity_value: Option<f64>,
// pub quantity_unit: String,
// }
// #[derive(Serialize, Deserialize, Clone)]
// pub struct AddRecipeIngredientReply {
// pub ingredient_id: i64,
// }
// #[derive(Serialize, Deserialize, Clone)]
// pub struct RemoveRecipeIngredient {
// pub group_id: i64,
// }
// #[derive(Serialize, Deserialize, Clone)]
// pub struct SetRecipeIngredientsOrder {
// pub group_id: i64,
// pub ingredient_ids: Vec<i64>,
// }
// #[derive(Serialize, Deserialize, Clone)]
// pub struct AddRecipeGroup {
// pub recipe_id: i64,
// pub name: String,
// pub quantity_value: Option<f64>,
// pub quantity_unit: String,
// }
// #[derive(Serialize, Deserialize, Clone)]
// pub struct AddRecipeGroupReply {
// pub group_id: i64,
// }
// #[derive(Serialize, Deserialize, Clone)]
// pub struct RemoveRecipeGroupReply {
// pub group_id: i64,
// }
// #[derive(Serialize, Deserialize, Clone)]
// pub struct SetRecipeGroupsOrder {
// pub recipe_id: i64,
// pub group_ids: Vec<i64>,
// }
// #[derive(Serialize, Deserialize, Clone)]
// pub struct AddRecipeStep {
// pub group_id: i64,
// pub name: String,
// }
// #[derive(Serialize, Deserialize, Clone)]
// pub struct AddRecipeStepReply {
// pub step_id: i64,
// }
// #[derive(Serialize, Deserialize, Clone)]
// pub struct RemoveRecipeStep {
// pub step_id: i64,
// }
///// PROFILE ///// ///// PROFILE /////
#[derive(Serialize, Deserialize, Clone)] #[derive(Serialize, Deserialize, Clone)]

41
frontend/src/recipe_edit.rs
View file

@ -273,7 +273,7 @@ pub fn setup_page(recipe_id: i64) -> Result<(), JsValue> {
)) ))
.await .await
{ {
let body = ron_api::Remove { recipe_id }; let body = ron_api::Id { id: recipe_id };
let _ = request::delete::<(), _>("recipe/remove", body).await; let _ = request::delete::<(), _>("recipe/remove", body).await;
window().location().set_href("/").unwrap(); window().location().set_href("/").unwrap();
@ -316,12 +316,11 @@ pub fn setup_page(recipe_id: i64) -> Result<(), JsValue> {
{ {
let button_add_group: HtmlInputElement = by_id("input-add-group"); let button_add_group: HtmlInputElement = by_id("input-add-group");
let on_click_add_group = EventListener::new(&button_add_group, "click", move |_event| { let on_click_add_group = EventListener::new(&button_add_group, "click", move |_event| {
let body = ron_api::AddRecipeGroup { recipe_id }; let body = ron_api::Id { id: recipe_id };
spawn_local(async move { spawn_local(async move {
let response: ron_api::AddRecipeGroupResult = let response: ron_api::Id = request::post("recipe/add_group", body).await.unwrap();
request::post("recipe/add_group", body).await.unwrap();
create_group_element(&ron_api::Group { create_group_element(&ron_api::Group {
id: response.group_id, id: response.id,
name: "".to_string(), name: "".to_string(),
comment: "".to_string(), comment: "".to_string(),
steps: vec![], steps: vec![],
@ -344,13 +343,13 @@ fn create_group_element(group: &ron_api::Group) -> Element {
set_draggable(&group_element, "group", |_element| { set_draggable(&group_element, "group", |_element| {
spawn_local(async move { spawn_local(async move {
let group_ids = by_id::<Element>("groups-container") let ids = by_id::<Element>("groups-container")
.selector_all::<Element>(".group") .selector_all::<Element>(".group")
.into_iter() .into_iter()
.map(|e| e.id()[6..].parse::<i64>().unwrap()) .map(|e| e.id()[6..].parse::<i64>().unwrap())
.collect(); .collect();
let body = ron_api::SetGroupOrders { group_ids }; let body = ron_api::Ids { ids };
let _ = request::put::<(), _>("recipe/set_groups_order", body).await; let _ = request::put::<(), _>("recipe/set_groups_order", body).await;
}); });
}); });
@ -400,7 +399,7 @@ fn create_group_element(group: &ron_api::Group) -> Element {
.value(); .value();
spawn_local(async move { spawn_local(async move {
if modal_dialog::show(&format!("Are you sure to delete the group '{}'", name)).await { if modal_dialog::show(&format!("Are you sure to delete the group '{}'", name)).await {
let body = ron_api::RemoveRecipeGroup { group_id }; let body = ron_api::Id { id: group_id };
let _ = request::delete::<(), _>("recipe/remove_group", body).await; let _ = request::delete::<(), _>("recipe/remove_group", body).await;
let group_element = by_id::<Element>(&format!("group-{}", group_id)); let group_element = by_id::<Element>(&format!("group-{}", group_id));
group_element.next_element_sibling().unwrap().remove(); group_element.next_element_sibling().unwrap().remove();
@ -414,13 +413,12 @@ fn create_group_element(group: &ron_api::Group) -> Element {
let add_step_button: HtmlInputElement = group_element.selector(".input-add-step"); let add_step_button: HtmlInputElement = group_element.selector(".input-add-step");
EventListener::new(&add_step_button, "click", move |_event| { EventListener::new(&add_step_button, "click", move |_event| {
spawn_local(async move { spawn_local(async move {
let body = ron_api::AddRecipeStep { group_id }; let body = ron_api::Id { id: group_id };
let response: ron_api::AddRecipeStepResult = let response: ron_api::Id = request::post("recipe/add_step", body).await.unwrap();
request::post("recipe/add_step", body).await.unwrap();
create_step_element( create_step_element(
&selector::<Element>(&format!("#group-{} .steps", group_id)), &selector::<Element>(&format!("#group-{} .steps", group_id)),
&ron_api::Step { &ron_api::Step {
id: response.step_id, id: response.id,
action: "".to_string(), action: "".to_string(),
ingredients: vec![], ingredients: vec![],
}, },
@ -494,7 +492,7 @@ fn create_step_element(group_element: &Element, step: &ron_api::Step) -> Element
set_draggable(&step_element, "step", |element| { set_draggable(&step_element, "step", |element| {
let element = element.clone(); let element = element.clone();
spawn_local(async move { spawn_local(async move {
let step_ids = element let ids = element
.parent_element() .parent_element()
.unwrap() .unwrap()
.selector_all::<Element>(".step") .selector_all::<Element>(".step")
@ -502,7 +500,7 @@ fn create_step_element(group_element: &Element, step: &ron_api::Step) -> Element
.map(|e| e.id()[5..].parse::<i64>().unwrap()) .map(|e| e.id()[5..].parse::<i64>().unwrap())
.collect(); .collect();
let body = ron_api::SetStepOrders { step_ids }; let body = ron_api::Ids { ids };
let _ = request::put::<(), _>("recipe/set_steps_order", body).await; let _ = request::put::<(), _>("recipe/set_steps_order", body).await;
}); });
}); });
@ -534,7 +532,7 @@ fn create_step_element(group_element: &Element, step: &ron_api::Step) -> Element
.value(); .value();
spawn_local(async move { spawn_local(async move {
if modal_dialog::show(&format!("Are you sure to delete the step '{}'", action)).await { if modal_dialog::show(&format!("Are you sure to delete the step '{}'", action)).await {
let body = ron_api::RemoveRecipeStep { step_id }; let body = ron_api::Id { id: step_id };
let _ = request::delete::<(), _>("recipe/remove_step", body).await; let _ = request::delete::<(), _>("recipe/remove_step", body).await;
let step_element = by_id::<Element>(&format!("step-{}", step_id)); let step_element = by_id::<Element>(&format!("step-{}", step_id));
step_element.next_element_sibling().unwrap().remove(); step_element.next_element_sibling().unwrap().remove();
@ -548,13 +546,12 @@ fn create_step_element(group_element: &Element, step: &ron_api::Step) -> Element
let add_ingredient_button: HtmlInputElement = step_element.selector(".input-add-ingredient"); let add_ingredient_button: HtmlInputElement = step_element.selector(".input-add-ingredient");
EventListener::new(&add_ingredient_button, "click", move |_event| { EventListener::new(&add_ingredient_button, "click", move |_event| {
spawn_local(async move { spawn_local(async move {
let body = ron_api::AddRecipeIngredient { step_id }; let body = ron_api::Id { id: step_id };
let response: ron_api::AddRecipeIngredientResult = let response: ron_api::Id = request::post("recipe/add_ingredient", body).await.unwrap();
request::post("recipe/add_ingredient", body).await.unwrap();
create_ingredient_element( create_ingredient_element(
&selector::<Element>(&format!("#step-{} .ingredients", step_id)), &selector::<Element>(&format!("#step-{} .ingredients", step_id)),
&ron_api::Ingredient { &ron_api::Ingredient {
id: response.ingredient_id, id: response.id,
name: "".to_string(), name: "".to_string(),
comment: "".to_string(), comment: "".to_string(),
quantity_value: None, quantity_value: None,
@ -577,7 +574,7 @@ fn create_ingredient_element(step_element: &Element, ingredient: &ron_api::Ingre
set_draggable(&ingredient_element, "ingredient", |element| { set_draggable(&ingredient_element, "ingredient", |element| {
let element = element.clone(); let element = element.clone();
spawn_local(async move { spawn_local(async move {
let ingredient_ids = element let ids = element
.parent_element() .parent_element()
.unwrap() .unwrap()
.selector_all::<Element>(".ingredient") .selector_all::<Element>(".ingredient")
@ -585,7 +582,7 @@ fn create_ingredient_element(step_element: &Element, ingredient: &ron_api::Ingre
.map(|e| e.id()[11..].parse::<i64>().unwrap()) .map(|e| e.id()[11..].parse::<i64>().unwrap())
.collect(); .collect();
let body = ron_api::SetIngredientOrders { ingredient_ids }; let body = ron_api::Ids { ids };
let _ = request::put::<(), _>("recipe/set_ingredients_order", body).await; let _ = request::put::<(), _>("recipe/set_ingredients_order", body).await;
}); });
}); });
@ -682,7 +679,7 @@ fn create_ingredient_element(step_element: &Element, ingredient: &ron_api::Ingre
if modal_dialog::show(&format!("Are you sure to delete the ingredient '{}'", name)) if modal_dialog::show(&format!("Are you sure to delete the ingredient '{}'", name))
.await .await
{ {
let body = ron_api::RemoveRecipeIngredient { ingredient_id }; let body = ron_api::Id { id: ingredient_id };
let _ = request::delete::<(), _>("recipe/remove_ingredient", body).await; let _ = request::delete::<(), _>("recipe/remove_ingredient", body).await;
by_id::<Element>(&format!("ingredient-{}", ingredient_id)).remove(); by_id::<Element>(&format!("ingredient-{}", ingredient_id)).remove();
} }