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

Update to Axum 0.8

Browse source
This commit is contained in:
Greg Burri 2025-01-14 15:57:02 +01:00
parent 975d1ceee2
commit e355800f98
20 changed files with 1377 additions and 1199 deletions
Download patch file Download diff file Expand all files Collapse all files

7
backend/src/services/fragments.rs
View file

@ -1,15 +1,16 @@
use axum::{
debug_handler,
extract::{Extension, Query, State},
response::{IntoResponse, Result},
response::{Html, IntoResponse},
};
use rinja::Template;
use serde::Deserialize;
// use tracing::{event, Level};
use crate::{
data::{db, model},
html_templates::*,
translation,
translation, Result,
};
#[derive(Deserialize)]
@ -37,5 +38,5 @@ pub async fn recipes_list_fragments(
},
current_id: current_recipe.current_recipe_id,
};
Ok(RecipesListFragmentTemplate { tr, recipes })
Ok(Html(RecipesListFragmentTemplate { tr, recipes }.render()?))
}

30
backend/src/services/mod.rs
View file

@ -3,13 +3,14 @@ use axum::{
extract::{Extension, Request, State},
http::{header, StatusCode},
middleware::Next,
response::{IntoResponse, Response, Result},
response::{Html, IntoResponse, Response},
};
use rinja::Template;
use crate::{
data::{db, model},
html_templates::*,
ron_utils, translation,
ron_utils, translation, Result,
};
pub mod fragments;
@ -31,12 +32,15 @@ pub async fn ron_error_to_html(
Ok(bytes) => String::from_utf8(bytes.to_vec()).unwrap_or_default(),
Err(error) => error.to_string(),
};
return Ok(MessageTemplate {
user: None,
message: &message,
as_code: true,
tr,
}
return Ok(Html(
MessageTemplate {
user: None,
message: &message,
as_code: true,
tr,
}
.render()?,
)
.into_response());
}
}
@ -66,7 +70,7 @@ pub async fn home_page(
current_id: None,
};
Ok(HomeTemplate { user, recipes, tr })
Ok(Html(HomeTemplate { user, recipes, tr }.render()?))
}
///// 404 /////
@ -75,9 +79,9 @@ pub async fn home_page(
pub async fn not_found(
Extension(user): Extension<Option<model::User>>,
Extension(tr): Extension<translation::Tr>,
) -> impl IntoResponse {
(
) -> Result<impl IntoResponse> {
Ok((
StatusCode::NOT_FOUND,
MessageTemplate::new_with_user("404: Not found", tr, user),
)
Html(MessageTemplate::new_with_user("404: Not found", tr, user).render()?),
))
}

69
backend/src/services/recipe.rs
View file

@ -1,14 +1,16 @@
use axum::{
debug_handler,
extract::{Extension, Path, State},
response::{IntoResponse, Redirect, Response, Result},
response::{Html, IntoResponse, Redirect, Response},
};
use rinja::Template;
// use tracing::{event, Level};
use crate::{
data::{db, model},
html_templates::*,
translation::{self, Sentence},
Result,
};
#[debug_handler]
@ -21,7 +23,7 @@ pub async fn create(
let recipe_id = connection.create_recipe(user.id).await?;
Ok(Redirect::to(&format!("/recipe/edit/{}", recipe_id)).into_response())
} else {
Ok(MessageTemplate::new(tr.t(Sentence::NotLoggedIn), tr).into_response())
Ok(Html(MessageTemplate::new(tr.t(Sentence::NotLoggedIn), tr).render()?).into_response())
}
}
@ -45,24 +47,33 @@ pub async fn edit_recipe(
current_id: Some(recipe_id),
};
Ok(RecipeEditTemplate {
user: Some(user),
tr,
recipes,
recipe,
}
Ok(Html(
RecipeEditTemplate {
user: Some(user),
tr,
recipes,
recipe,
}
.render()?,
)
.into_response())
} else {
Ok(
MessageTemplate::new(tr.t(Sentence::RecipeNotAllowedToEdit), tr)
.into_response(),
Html(
MessageTemplate::new(tr.t(Sentence::RecipeNotAllowedToEdit), tr)
.render()?,
)
.into_response(),
)
}
} else {
Ok(MessageTemplate::new(tr.t(Sentence::RecipeNotFound), tr).into_response())
Ok(
Html(MessageTemplate::new(tr.t(Sentence::RecipeNotFound), tr).render()?)
.into_response(),
)
}
} else {
Ok(MessageTemplate::new(tr.t(Sentence::NotLoggedIn), tr).into_response())
Ok(Html(MessageTemplate::new(tr.t(Sentence::NotLoggedIn), tr).render()?).into_response())
}
}
@ -78,10 +89,13 @@ pub async fn view(
if !recipe.is_published
&& (user.is_none() || recipe.user_id != user.as_ref().unwrap().id)
{
return Ok(MessageTemplate::new_with_user(
&tr.tp(Sentence::RecipeNotAllowedToView, &[Box::new(recipe_id)]),
tr,
user,
return Ok(Html(
MessageTemplate::new_with_user(
&tr.tp(Sentence::RecipeNotAllowedToView, &[Box::new(recipe_id)]),
tr,
user,
)
.render()?,
)
.into_response());
}
@ -103,17 +117,20 @@ pub async fn view(
current_id: Some(recipe_id),
};
Ok(RecipeViewTemplate {
user,
tr,
recipes,
recipe,
}
Ok(Html(
RecipeViewTemplate {
user,
tr,
recipes,
recipe,
}
.render()?,
)
.into_response())
}
None => Ok(
MessageTemplate::new_with_user(tr.t(Sentence::RecipeNotFound), tr, user)
.into_response(),
),
None => Ok(Html(
MessageTemplate::new_with_user(tr.t(Sentence::RecipeNotFound), tr, user).render()?,
)
.into_response()),
}
}

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

@ -142,6 +142,25 @@ async fn check_user_rights_recipe_step(
}
}
async fn check_user_rights_recipe_steps(
connection: &db::Connection,
user: &Option<model::User>,
step_ids: &[i64],
) -> Result<()> {
if user.is_none()
|| !connection
.can_edit_recipe_all_steps(user.as_ref().unwrap().id, step_ids)
.await?
{
Err(ErrorResponse::from(ron_error(
StatusCode::UNAUTHORIZED,
NOT_AUTHORIZED_MESSAGE,
)))
} else {
Ok(())
}
}
async fn check_user_rights_recipe_ingredient(
connection: &db::Connection,
user: &Option<model::User>,
@ -463,6 +482,17 @@ pub async fn set_step_action(
Ok(StatusCode::OK)
}
#[debug_handler]
pub async fn set_step_orders(
State(connection): State<db::Connection>,
Extension(user): Extension<Option<model::User>>,
ExtractRon(ron): ExtractRon<common::ron_api::SetStepOrders>,
) -> Result<impl IntoResponse> {
check_user_rights_recipe_steps(&connection, &user, &ron.step_ids).await?;
connection.set_steps_order(&ron.step_ids).await?;
Ok(StatusCode::OK)
}
#[debug_handler]
pub async fn add_ingredient(
State(connection): State<db::Connection>,

459
backend/src/services/user.rs
View file

@ -3,13 +3,17 @@ use std::{collections::HashMap, net::SocketAddr};
use axum::{
body::Body,
debug_handler,
extract::{ConnectInfo, Extension, Host, Query, Request, State},
extract::{ConnectInfo, Extension, Query, Request, State},
http::HeaderMap,
response::{IntoResponse, Redirect, Response, Result},
response::{Html, IntoResponse, Redirect, Response},
Form,
};
use axum_extra::extract::cookie::{Cookie, CookieJar};
use axum_extra::extract::{
cookie::{Cookie, CookieJar},
Host,
};
use chrono::Duration;
use rinja::Template;
use serde::Deserialize;
use tracing::{event, Level};
@ -20,7 +24,7 @@ use crate::{
email,
html_templates::*,
translation::{self, Sentence},
utils, AppState,
utils, AppState, Result,
};
/// SIGN UP ///
@ -30,14 +34,17 @@ pub async fn sign_up_get(
Extension(user): Extension<Option<model::User>>,
Extension(tr): Extension<translation::Tr>,
) -> Result<impl IntoResponse> {
Ok(SignUpFormTemplate {
user,
tr,
email: String::new(),
message: "",
message_email: "",
message_password: "",
})
Ok(Html(
SignUpFormTemplate {
user,
tr,
email: String::new(),
message: "",
message_email: "",
message_password: "",
}
.render()?,
))
}
#[derive(Deserialize, Debug)]
@ -75,26 +82,29 @@ pub async fn sign_up_post(
Sentence::InvalidPassword,
&[Box::new(common::consts::MIN_PASSWORD_SIZE)],
);
Ok(SignUpFormTemplate {
user,
email: form_data.email.clone(),
message_email: match error {
SignUpError::InvalidEmail => tr.t(Sentence::InvalidEmail),
_ => "",
},
message_password: match error {
SignUpError::PasswordsNotEqual => tr.t(Sentence::PasswordDontMatch),
SignUpError::InvalidPassword => invalid_password_mess,
_ => "",
},
message: match error {
SignUpError::UserAlreadyExists => tr.t(Sentence::EmailAlreadyTaken),
SignUpError::DatabaseError => tr.t(Sentence::DatabaseError),
SignUpError::UnableSendEmail => tr.t(Sentence::UnableToSendEmail),
_ => "",
},
tr,
}
Ok(Html(
SignUpFormTemplate {
user,
email: form_data.email.clone(),
message_email: match error {
SignUpError::InvalidEmail => tr.t(Sentence::InvalidEmail),
_ => "",
},
message_password: match error {
SignUpError::PasswordsNotEqual => tr.t(Sentence::PasswordDontMatch),
SignUpError::InvalidPassword => invalid_password_mess,
_ => "",
},
message: match error {
SignUpError::UserAlreadyExists => tr.t(Sentence::EmailAlreadyTaken),
SignUpError::DatabaseError => tr.t(Sentence::DatabaseError),
SignUpError::UnableSendEmail => tr.t(Sentence::UnableToSendEmail),
_ => "",
},
tr,
}
.render()?,
)
.into_response())
}
@ -140,12 +150,11 @@ pub async fn sign_up_post(
)
.await
{
Ok(()) => {
Ok(
MessageTemplate::new_with_user(tr.t(Sentence::SignUpEmailSent), tr, user)
.into_response(),
)
}
Ok(()) => Ok(Html(
MessageTemplate::new_with_user(tr.t(Sentence::SignUpEmailSent), tr, user)
.render()?,
)
.into_response()),
Err(_) => {
// error!("Email validation error: {}", error); // TODO: log
error_response(SignUpError::UnableSendEmail, &form_data, user, tr)
@ -172,7 +181,14 @@ pub async fn sign_up_validation(
if user.is_some() {
return Ok((
jar,
MessageTemplate::new_with_user(tr.t(Sentence::ValidationUserAlreadyExists), tr, user),
Html(
MessageTemplate::new_with_user(
tr.t(Sentence::ValidationUserAlreadyExists),
tr,
user,
)
.render()?,
),
));
}
let (client_ip, client_user_agent) = utils::get_ip_and_user_agent(&headers, addr);
@ -194,34 +210,46 @@ pub async fn sign_up_validation(
let user = connection.load_user(user_id).await?;
Ok((
jar,
MessageTemplate::new_with_user(
tr.t(Sentence::SignUpEmailValidationSuccess),
tr,
user,
Html(
MessageTemplate::new_with_user(
tr.t(Sentence::SignUpEmailValidationSuccess),
tr,
user,
)
.render()?,
),
))
}
db::user::ValidationResult::ValidationExpired => Ok((
jar,
MessageTemplate::new_with_user(
tr.t(Sentence::SignUpValidationExpired),
tr,
user,
Html(
MessageTemplate::new_with_user(
tr.t(Sentence::SignUpValidationExpired),
tr,
user,
)
.render()?,
),
)),
db::user::ValidationResult::UnknownUser => Ok((
jar,
MessageTemplate::new_with_user(
tr.t(Sentence::SignUpValidationErrorTryAgain),
tr,
user,
Html(
MessageTemplate::new_with_user(
tr.t(Sentence::SignUpValidationErrorTryAgain),
tr,
user,
)
.render()?,
),
)),
}
}
None => Ok((
jar,
MessageTemplate::new_with_user(tr.t(Sentence::ValidationError), tr, user),
Html(
MessageTemplate::new_with_user(tr.t(Sentence::ValidationError), tr, user)
.render()?,
),
)),
}
}
@ -233,12 +261,15 @@ pub async fn sign_in_get(
Extension(user): Extension<Option<model::User>>,
Extension(tr): Extension<translation::Tr>,
) -> Result<impl IntoResponse> {
Ok(SignInFormTemplate {
user,
tr,
email: "",
message: "",
})
Ok(Html(
SignInFormTemplate {
user,
tr,
email: "",
message: "",
}
.render()?,
))
}
#[derive(Deserialize, Debug)]
@ -270,22 +301,28 @@ pub async fn sign_in_post(
{
db::user::SignInResult::AccountNotValidated => Ok((
jar,
SignInFormTemplate {
user,
email: &form_data.email,
message: tr.t(Sentence::AccountMustBeValidatedFirst),
tr,
}
Html(
SignInFormTemplate {
user,
email: &form_data.email,
message: tr.t(Sentence::AccountMustBeValidatedFirst),
tr,
}
.render()?,
)
.into_response(),
)),
db::user::SignInResult::UserNotFound | db::user::SignInResult::WrongPassword => Ok((
jar,
SignInFormTemplate {
user,
email: &form_data.email,
message: tr.t(Sentence::WrongEmailOrPassword),
tr,
}
Html(
SignInFormTemplate {
user,
email: &form_data.email,
message: tr.t(Sentence::WrongEmailOrPassword),
tr,
}
.render()?,
)
.into_response(),
)),
db::user::SignInResult::Ok(token, _user_id) => {
@ -319,18 +356,22 @@ pub async fn ask_reset_password_get(
Extension(tr): Extension<translation::Tr>,
) -> Result<Response> {
if user.is_some() {
Ok(
Ok(Html(
MessageTemplate::new_with_user(tr.t(Sentence::AskResetAlreadyLoggedInError), tr, user)
.into_response(),
.render()?,
)
.into_response())
} else {
Ok(AskResetPasswordTemplate {
user,
tr,
email: "",
message: "",
message_email: "",
}
Ok(Html(
AskResetPasswordTemplate {
user,
tr,
email: "",
message: "",
message_email: "",
}
.render()?,
)
.into_response())
}
}
@ -363,24 +404,29 @@ pub async fn ask_reset_password_post(
user: Option<model::User>,
tr: translation::Tr,
) -> Result<Response> {
Ok(AskResetPasswordTemplate {
user,
email,
message_email: match error {
AskResetPasswordError::InvalidEmail => tr.t(Sentence::InvalidEmail),
_ => "",
},
message: match error {
AskResetPasswordError::EmailAlreadyReset => {
tr.t(Sentence::AskResetEmailAlreadyResetError)
}
AskResetPasswordError::EmailUnknown => tr.t(Sentence::EmailUnknown),
AskResetPasswordError::UnableSendEmail => tr.t(Sentence::UnableToSendResetEmail),
AskResetPasswordError::DatabaseError => tr.t(Sentence::DatabaseError),
_ => "",
},
tr,
}
Ok(Html(
AskResetPasswordTemplate {
user,
email,
message_email: match error {
AskResetPasswordError::InvalidEmail => tr.t(Sentence::InvalidEmail),
_ => "",
},
message: match error {
AskResetPasswordError::EmailAlreadyReset => {
tr.t(Sentence::AskResetEmailAlreadyResetError)
}
AskResetPasswordError::EmailUnknown => tr.t(Sentence::EmailUnknown),
AskResetPasswordError::UnableSendEmail => {
tr.t(Sentence::UnableToSendResetEmail)
}
AskResetPasswordError::DatabaseError => tr.t(Sentence::DatabaseError),
_ => "",
},
tr,
}
.render()?,
)
.into_response())
}
@ -432,12 +478,11 @@ pub async fn ask_reset_password_post(
)
.await
{
Ok(()) => {
Ok(
MessageTemplate::new_with_user(tr.t(Sentence::AskResetEmailSent), tr, user)
.into_response(),
)
}
Ok(()) => Ok(Html(
MessageTemplate::new_with_user(tr.t(Sentence::AskResetEmailSent), tr, user)
.render()?,
)
.into_response()),
Err(_) => {
// error!("Email validation error: {}", error); // TODO: log
error_response(
@ -477,25 +522,30 @@ pub async fn reset_password_get(
)
.await?
{
Ok(ResetPasswordTemplate {
user,
tr,
reset_token,
message: "",
message_password: "",
}
Ok(Html(
ResetPasswordTemplate {
user,
tr,
reset_token,
message: "",
message_password: "",
}
.render()?,
)
.into_response())
} else {
Ok(
Ok(Html(
MessageTemplate::new_with_user(tr.t(Sentence::AskResetTokenMissing), tr, user)
.into_response(),
.render()?,
)
.into_response())
}
} else {
Ok(
Ok(Html(
MessageTemplate::new_with_user(tr.t(Sentence::AskResetTokenMissing), tr, user)
.into_response(),
.render()?,
)
.into_response())
}
}
@ -530,21 +580,24 @@ pub async fn reset_password_post(
Sentence::InvalidPassword,
&[Box::new(common::consts::MIN_PASSWORD_SIZE)],
);
Ok(ResetPasswordTemplate {
user,
reset_token: &form_data.reset_token,
message_password: match error {
ResetPasswordError::PasswordsNotEqual => tr.t(Sentence::PasswordDontMatch),
ResetPasswordError::InvalidPassword => reset_password_mess,
_ => "",
},
message: match error {
ResetPasswordError::TokenExpired => tr.t(Sentence::AskResetTokenExpired),
ResetPasswordError::DatabaseError => tr.t(Sentence::DatabaseError),
_ => "",
},
tr,
}
Ok(Html(
ResetPasswordTemplate {
user,
reset_token: &form_data.reset_token,
message_password: match error {
ResetPasswordError::PasswordsNotEqual => tr.t(Sentence::PasswordDontMatch),
ResetPasswordError::InvalidPassword => reset_password_mess,
_ => "",
},
message: match error {
ResetPasswordError::TokenExpired => tr.t(Sentence::AskResetTokenExpired),
ResetPasswordError::DatabaseError => tr.t(Sentence::DatabaseError),
_ => "",
},
tr,
}
.render()?,
)
.into_response())
}
@ -566,12 +619,10 @@ pub async fn reset_password_post(
)
.await
{
Ok(db::user::ResetPasswordResult::Ok) => {
Ok(
MessageTemplate::new_with_user(tr.t(Sentence::PasswordReset), tr, user)
.into_response(),
)
}
Ok(db::user::ResetPasswordResult::Ok) => Ok(Html(
MessageTemplate::new_with_user(tr.t(Sentence::PasswordReset), tr, user).render()?,
)
.into_response()),
Ok(db::user::ResetPasswordResult::ResetTokenExpired) => {
error_response(ResetPasswordError::TokenExpired, &form_data, user, tr)
}
@ -585,21 +636,24 @@ pub async fn reset_password_post(
pub async fn edit_user_get(
Extension(user): Extension<Option<model::User>>,
Extension(tr): Extension<translation::Tr>,
) -> Response {
if let Some(user) = user {
ProfileTemplate {
username: &user.name,
email: &user.email,
message: "",
message_email: "",
message_password: "",
user: Some(user.clone()),
tr,
}
) -> Result<Response> {
Ok(if let Some(user) = user {
Html(
ProfileTemplate {
username: &user.name,
email: &user.email,
message: "",
message_email: "",
message_password: "",
user: Some(user.clone()),
tr,
}
.render()?,
)
.into_response()
} else {
MessageTemplate::new(tr.t(Sentence::NotLoggedIn), tr).into_response()
}
Html(MessageTemplate::new(tr.t(Sentence::NotLoggedIn), tr).render()?).into_response()
})
}
#[derive(Deserialize, Debug)]
@ -640,27 +694,30 @@ pub async fn edit_user_post(
Sentence::InvalidPassword,
&[Box::new(common::consts::MIN_PASSWORD_SIZE)],
);
Ok(ProfileTemplate {
user: Some(user),
username: &form_data.name,
email: &form_data.email,
message_email: match error {
ProfileUpdateError::InvalidEmail => tr.t(Sentence::InvalidEmail),
ProfileUpdateError::EmailAlreadyTaken => tr.t(Sentence::EmailAlreadyTaken),
_ => "",
},
message_password: match error {
ProfileUpdateError::PasswordsNotEqual => tr.t(Sentence::PasswordDontMatch),
ProfileUpdateError::InvalidPassword => invalid_password_mess,
_ => "",
},
message: match error {
ProfileUpdateError::DatabaseError => tr.t(Sentence::DatabaseError),
ProfileUpdateError::UnableSendEmail => tr.t(Sentence::UnableToSendEmail),
_ => "",
},
tr,
}
Ok(Html(
ProfileTemplate {
user: Some(user),
username: &form_data.name,
email: &form_data.email,
message_email: match error {
ProfileUpdateError::InvalidEmail => tr.t(Sentence::InvalidEmail),
ProfileUpdateError::EmailAlreadyTaken => tr.t(Sentence::EmailAlreadyTaken),
_ => "",
},
message_password: match error {
ProfileUpdateError::PasswordsNotEqual => tr.t(Sentence::PasswordDontMatch),
ProfileUpdateError::InvalidPassword => invalid_password_mess,
_ => "",
},
message: match error {
ProfileUpdateError::DatabaseError => tr.t(Sentence::DatabaseError),
ProfileUpdateError::UnableSendEmail => tr.t(Sentence::UnableToSendEmail),
_ => "",
},
tr,
}
.render()?,
)
.into_response())
}
@ -742,18 +799,21 @@ pub async fn edit_user_post(
// Reload after update.
let user = connection.load_user(user.id).await?;
Ok(ProfileTemplate {
user,
username: &form_data.name,
email: &form_data.email,
message,
message_email: "",
message_password: "",
tr,
}
Ok(Html(
ProfileTemplate {
user,
username: &form_data.name,
email: &form_data.email,
message,
message_email: "",
message_password: "",
tr,
}
.render()?,
)
.into_response())
} else {
Ok(MessageTemplate::new(tr.t(Sentence::NotLoggedIn), tr).into_response())
Ok(Html(MessageTemplate::new(tr.t(Sentence::NotLoggedIn), tr).render()?).into_response())
}
}
@ -770,7 +830,14 @@ pub async fn email_revalidation(
if user.is_some() {
return Ok((
jar,
MessageTemplate::new_with_user(tr.t(Sentence::ValidationUserAlreadyExists), tr, user),
Html(
MessageTemplate::new_with_user(
tr.t(Sentence::ValidationUserAlreadyExists),
tr,
user,
)
.render()?,
),
));
}
let (client_ip, client_user_agent) = utils::get_ip_and_user_agent(&headers, addr);
@ -792,30 +859,42 @@ pub async fn email_revalidation(
let user = connection.load_user(user_id).await?;
Ok((
jar,
MessageTemplate::new_with_user(
tr.t(Sentence::ValidationSuccessful),
tr,
user,
Html(
MessageTemplate::new_with_user(
tr.t(Sentence::ValidationSuccessful),
tr,
user,
)
.render()?,
),
))
}
db::user::ValidationResult::ValidationExpired => Ok((
jar,
MessageTemplate::new_with_user(tr.t(Sentence::ValidationExpired), tr, user),
Html(
MessageTemplate::new_with_user(tr.t(Sentence::ValidationExpired), tr, user)
.render()?,
),
)),
db::user::ValidationResult::UnknownUser => Ok((
jar,
MessageTemplate::new_with_user(
tr.t(Sentence::ValidationErrorTryToSignUpAgain),
tr,
user,
Html(
MessageTemplate::new_with_user(
tr.t(Sentence::ValidationErrorTryToSignUpAgain),
tr,
user,
)
.render()?,
),
)),
}
}
None => Ok((
jar,
MessageTemplate::new_with_user(tr.t(Sentence::ValidationError), tr, user),
Html(
MessageTemplate::new_with_user(tr.t(Sentence::ValidationError), tr, user)
.render()?,
),
)),
}
}