n08i40k/schedule-parser-rusted
1
0
Fork 0
mirror of https://github.com/n08i40k/schedule-parser-rusted.git synced 2025-12-06 09:47:50 +03:00
Code Issues Packages Projects Releases Wiki Activity

Использование функции для осуществления операций в базе данных вместо ручного блокирования мьютекса.

Browse Source
This commit is contained in:
N08I40K
2025-04-15 13:08:46 +04:00
parent 5b6f5c830f
commit 057dac5b09
10 changed files with 138 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -4,3 +4,4 @@ schedule.json
teachers.json
.env*
/*-firebase-adminsdk-*.json

1
.idea/schedule-parser-rusted.iml generated
View File

@@ -10,6 +10,7 @@
<excludeFolder url="file://$MODULE_DIR$/actix-macros/target" />
<excludeFolder url="file://$MODULE_DIR$/actix-test/target" />
<excludeFolder url="file://$MODULE_DIR$/target" />
<excludeFolder url="file://$MODULE_DIR$/.idea/dataSources" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />

20
src/app_state.rs
View File

@@ -7,8 +7,7 @@ use diesel::{Connection, PgConnection};
use sha1::{Digest, Sha1};
use std::env;
use std::hash::Hash;
use std::ops::DerefMut;
use std::sync::{Mutex, MutexGuard};
use std::sync::Mutex;
#[derive(Clone)]
pub struct Schedule {
@@ -74,23 +73,6 @@ impl AppState {
}
}
impl AppState {
/// Получение объекта соединения с базой данных PostgreSQL
pub fn connection(&self) -> MutexGuard<PgConnection> {
self.database.lock().unwrap()
}
pub fn lock_connection<T, F>(&self, f: F) -> T
where
F: FnOnce(&mut PgConnection) -> T,
{
let mut lock = self.connection();
let conn = lock.deref_mut();
f(conn)
}
}
/// Создание нового объекта web::Data<AppState>
pub fn app_state() -> web::Data<AppState> {
web::Data::new(AppState::new())

164
src/database/driver.rs
View File

@@ -1,118 +1,112 @@
pub mod users {
use crate::app_state::AppState;
use crate::database::models::User;
use crate::database::schema::users::dsl::users;
use crate::database::schema::users::dsl::*;
use actix_web::web;
use diesel::SelectableHelper;
use diesel::{insert_into, ExpressionMethods, QueryResult};
use diesel::{PgConnection, SelectableHelper};
use diesel::{QueryDsl, RunQueryDsl};
use std::ops::DerefMut;
use std::sync::Mutex;
use crate::utility::mutex::MutexScope;
pub fn get(connection: &Mutex<PgConnection>, _id: &String) -> QueryResult<User> {
let mut lock = connection.lock().unwrap();
let con = lock.deref_mut();
users
.filter(id.eq(_id))
.select(User::as_select())
.first(con)
pub fn get(state: &web::Data<AppState>, _id: &String) -> QueryResult<User> {
state.database.scope(|conn| {
users
.filter(id.eq(_id))
.select(User::as_select())
.first(conn)
})
}
pub fn get_by_username(
connection: &Mutex<PgConnection>,
_username: &String,
) -> QueryResult<User> {
let mut lock = connection.lock().unwrap();
let con = lock.deref_mut();
users
.filter(username.eq(_username))
.select(User::as_select())
.first(con)
pub fn get_by_username(state: &web::Data<AppState>, _username: &String) -> QueryResult<User> {
state.database.scope(|conn| {
users
.filter(username.eq(_username))
.select(User::as_select())
.first(conn)
})
}
pub fn get_by_vk_id(connection: &Mutex<PgConnection>, _vk_id: i32) -> QueryResult<User> {
let mut lock = connection.lock().unwrap();
let con = lock.deref_mut();
users
.filter(vk_id.eq(_vk_id))
.select(User::as_select())
.first(con)
//noinspection RsTraitObligations
pub fn get_by_vk_id(state: &web::Data<AppState>, _vk_id: i32) -> QueryResult<User> {
state.database.scope(|conn| {
users
.filter(vk_id.eq(_vk_id))
.select(User::as_select())
.first(conn)
})
}
pub fn contains_by_username(connection: &Mutex<PgConnection>, _username: &String) -> bool {
let mut lock = connection.lock().unwrap();
let con = lock.deref_mut();
match users
.filter(username.eq(_username))
.count()
.get_result::<i64>(con)
{
Ok(count) => count > 0,
Err(_) => false,
}
//noinspection DuplicatedCode
pub fn contains_by_username(state: &web::Data<AppState>, _username: &String) -> bool {
// и как это нахуй сократить блять примеров нихуя нет, нихуя не работает
// как меня этот раст заебал уже
state.database.scope(|conn| {
match users
.filter(username.eq(_username))
.count()
.get_result::<i64>(conn)
{
Ok(count) => count > 0,
Err(_) => false,
}
})
}
pub fn contains_by_vk_id(connection: &Mutex<PgConnection>, _vk_id: i32) -> bool {
let mut lock = connection.lock().unwrap();
let con = lock.deref_mut();
match users
.filter(vk_id.eq(_vk_id))
.count()
.get_result::<i64>(con)
{
Ok(count) => count > 0,
Err(_) => false,
}
//noinspection DuplicatedCode
//noinspection RsTraitObligations
pub fn contains_by_vk_id(state: &web::Data<AppState>, _vk_id: i32) -> bool {
state.database.scope(|conn| {
match users
.filter(vk_id.eq(_vk_id))
.count()
.get_result::<i64>(conn)
{
Ok(count) => count > 0,
Err(_) => false,
}
})
}
pub fn insert(connection: &Mutex<PgConnection>, user: &User) -> QueryResult<usize> {
let mut lock = connection.lock().unwrap();
let con = lock.deref_mut();
insert_into(users).values(user).execute(con)
pub fn insert(state: &web::Data<AppState>, user: &User) -> QueryResult<usize> {
state.database.scope(|conn| insert_into(users).values(user).execute(conn))
}
#[cfg(test)]
pub fn delete_by_username(connection: &Mutex<PgConnection>, _username: &String) -> bool {
let mut lock = connection.lock().unwrap();
let con = lock.deref_mut();
match diesel::delete(users.filter(username.eq(_username))).execute(con) {
Ok(count) => count > 0,
Err(_) => false,
}
pub fn delete_by_username(state: &web::Data<AppState>, _username: &String) -> bool {
state.database.scope(|conn| {
match diesel::delete(users.filter(username.eq(_username))).execute(conn) {
Ok(count) => count > 0,
Err(_) => false,
}
})
}
#[cfg(test)]
pub fn insert_or_ignore(connection: &Mutex<PgConnection>, user: &User) -> QueryResult<usize> {
let mut lock = connection.lock().unwrap();
let con = lock.deref_mut();
insert_into(users)
.values(user)
.on_conflict_do_nothing()
.execute(con)
pub fn insert_or_ignore(state: &web::Data<AppState>, user: &User) -> QueryResult<usize> {
state.database.scope(|conn| {
insert_into(users)
.values(user)
.on_conflict_do_nothing()
.execute(conn)
})
}
}
pub mod fcm {
use crate::app_state::AppState;
use crate::database::models::{User, FCM};
use actix_web::web;
use diesel::QueryDsl;
use diesel::RunQueryDsl;
use diesel::{BelongingToDsl, PgConnection, QueryResult, SelectableHelper};
use std::ops::DerefMut;
use std::sync::Mutex;
use diesel::{BelongingToDsl, QueryResult, SelectableHelper};
use crate::utility::mutex::MutexScope;
pub fn from_user(connection: &Mutex<PgConnection>, user: &User) -> QueryResult<FCM> {
let mut lock = connection.lock().unwrap();
let con = lock.deref_mut();
FCM::belonging_to(&user)
.select(FCM::as_select())
.get_result(con)
pub fn from_user(state: &web::Data<AppState>, user: &User) -> QueryResult<FCM> {
state.database.scope(|conn| {
FCM::belonging_to(&user)
.select(FCM::as_select())
.get_result(conn)
})
}
}

4
src/extractors/authorized_user.rs
View File

@@ -63,7 +63,7 @@ impl FromRequestSync for User {
let app_state = req.app_data::<web::Data<AppState>>().unwrap();
driver::users::get(&app_state.database, &user_id).map_err(|_| Error::NoUser.into())
driver::users::get(&app_state, &user_id).map_err(|_| Error::NoUser.into())
}
}
@@ -100,7 +100,7 @@ impl<const FCM: bool> FromRequestSync for UserExtractor<{ FCM }> {
Ok(Self {
fcm: if FCM {
driver::fcm::from_user(&app_state.database, &user).ok()
driver::fcm::from_user(&app_state, &user).ok()
} else {
None
},

28
src/routes/auth/sign_in.rs
View File

@@ -5,10 +5,10 @@ use crate::routes::auth::shared::parse_vk_id;
use crate::routes::auth::sign_in::schema::SignInData::{Default, Vk};
use crate::routes::schema::user::UserResponse;
use crate::routes::schema::{IntoResponseAsError, ResponseError};
use crate::{utility, AppState};
use crate::utility::mutex::MutexScope;
use crate::{AppState, utility};
use actix_web::{post, web};
use diesel::SaveChangesDsl;
use std::ops::DerefMut;
use web::Json;
async fn sign_in_combined(
@@ -16,8 +16,8 @@ async fn sign_in_combined(
app_state: &web::Data<AppState>,
) -> Result<UserResponse, ErrorCode> {
let user = match &data {
Default(data) => driver::users::get_by_username(&app_state.database, &data.username),
Vk(id) => driver::users::get_by_vk_id(&app_state.database, *id),
Default(data) => driver::users::get_by_username(&app_state, &data.username),
Vk(id) => driver::users::get_by_vk_id(&app_state, *id),
};
match user {
@@ -35,13 +35,12 @@ async fn sign_in_combined(
}
}
let mut lock = app_state.connection();
let conn = lock.deref_mut();
user.access_token = utility::jwt::encode(&user.id);
user.save_changes::<User>(conn)
.expect("Failed to update user");
app_state.database.scope(|conn| {
user.save_changes::<User>(conn)
.expect("Failed to update user")
});
Ok(user.into())
}
@@ -56,7 +55,9 @@ async fn sign_in_combined(
))]
#[post("/sign-in")]
pub async fn sign_in(data: Json<Request>, app_state: web::Data<AppState>) -> ServiceResponse {
sign_in_combined(Default(data.into_inner()), &app_state).await.into()
sign_in_combined(Default(data.into_inner()), &app_state)
.await
.into()
}
#[utoipa::path(responses(
@@ -64,7 +65,10 @@ pub async fn sign_in(data: Json<Request>, app_state: web::Data<AppState>) -> Ser
(status = NOT_ACCEPTABLE, body = ResponseError<ErrorCode>)
))]
#[post("/sign-in-vk")]
pub async fn sign_in_vk(data_json: Json<vk::Request>, app_state: web::Data<AppState>) -> ServiceResponse {
pub async fn sign_in_vk(
data_json: Json<vk::Request>,
app_state: web::Data<AppState>,
) -> ServiceResponse {
let data = data_json.into_inner();
match parse_vk_id(&data.access_token) {
@@ -176,7 +180,7 @@ mod tests {
let app_state = static_app_state();
driver::users::insert_or_ignore(
&app_state.database,
&app_state,
&User {
id: id.clone(),
username,

10
src/routes/auth/sign_up.rs
View File

@@ -28,19 +28,19 @@ async fn sign_up_combined(
}
// If user with specified username already exists.
if driver::users::contains_by_username(&app_state.database, &data.username) {
if driver::users::contains_by_username(&app_state, &data.username) {
return Err(ErrorCode::UsernameAlreadyExists);
}
// If user with specified VKID already exists.
if let Some(id) = data.vk_id {
if driver::users::contains_by_vk_id(&app_state.database, id) {
if driver::users::contains_by_vk_id(&app_state, id) {
return Err(ErrorCode::VkAlreadyExists);
}
}
let user = data.into();
driver::users::insert(&app_state.database, &user).unwrap();
driver::users::insert(&app_state, &user).unwrap();
Ok(UserResponse::from(&user)).into()
}
@@ -281,7 +281,7 @@ mod tests {
test_env();
let app_state = static_app_state();
driver::users::delete_by_username(&app_state.database, &"test::sign_up_valid".to_string());
driver::users::delete_by_username(&app_state, &"test::sign_up_valid".to_string());
// test
@@ -303,7 +303,7 @@ mod tests {
let app_state = static_app_state();
driver::users::delete_by_username(
&app_state.database,
&app_state,
&"test::sign_up_multiple".to_string(),
);

6
src/routes/fcm/update_callback.rs
View File

@@ -1,6 +1,7 @@
use crate::app_state::AppState;
use crate::database::models::User;
use crate::extractors::base::SyncExtractor;
use crate::utility::mutex::MutexScope;
use actix_web::{HttpResponse, Responder, post, web};
use diesel::SaveChangesDsl;
@@ -18,7 +19,10 @@ async fn update_callback(
user.version = version.into_inner();
match app_state.lock_connection(|con| user.save_changes::<User>(con)) {
match app_state
.database
.scope(|conn| user.save_changes::<User>(conn))
{
Ok(_) => HttpResponse::Ok(),
Err(e) => {
eprintln!("Failed to update user: {}", e);

1
src/utility/mod.rs
View File

@@ -1,3 +1,4 @@
pub mod jwt;
pub mod error;
pub mod hasher;
pub mod mutex;

21
src/utility/mutex.rs Normal file
View File

@@ -0,0 +1,21 @@
use std::ops::DerefMut;
use std::sync::Mutex;
pub trait MutexScope<T, ScopeFn, ScopeFnOutput>
where
ScopeFn: FnOnce(&mut T) -> ScopeFnOutput,
{
fn scope(&self, f: ScopeFn) -> ScopeFnOutput;
}
impl<T, ScopeFn, ScopeFnOutput> MutexScope<T, ScopeFn, ScopeFnOutput> for Mutex<T>
where
ScopeFn: FnOnce(&mut T) -> ScopeFnOutput,
{
fn scope(&self, f: ScopeFn) -> ScopeFnOutput {
let mut lock = self.lock().unwrap();
let inner = lock.deref_mut();
f(inner)
}
}