108 lines
3.4 KiB
Rust
108 lines
3.4 KiB
Rust
use async_trait::async_trait;
|
|
use domain::{
|
|
errors::DomainError,
|
|
models::UserSettings,
|
|
ports::{FederationFlags, UserFederationSettingsQuery, UserSettingsRepository},
|
|
value_objects::UserId,
|
|
};
|
|
use sqlx::{Row, SqlitePool};
|
|
|
|
pub struct SqliteUserSettingsRepository {
|
|
pool: SqlitePool,
|
|
}
|
|
|
|
impl SqliteUserSettingsRepository {
|
|
pub fn new(pool: SqlitePool) -> Self {
|
|
Self { pool }
|
|
}
|
|
|
|
fn map_err(e: sqlx::Error) -> DomainError {
|
|
tracing::error!("Database error: {:?}", e);
|
|
DomainError::InfrastructureError("Database operation failed".into())
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl UserSettingsRepository for SqliteUserSettingsRepository {
|
|
async fn get(&self, user_id: &UserId) -> Result<UserSettings, DomainError> {
|
|
let uid = user_id.value().to_string();
|
|
let row = sqlx::query(
|
|
"SELECT federate_goals, federate_reviews, federate_watchlist \
|
|
FROM user_settings WHERE user_id = ?",
|
|
)
|
|
.bind(&uid)
|
|
.fetch_optional(&self.pool)
|
|
.await
|
|
.map_err(Self::map_err)?;
|
|
|
|
match row {
|
|
Some(r) => {
|
|
let goals: i64 = r.try_get("federate_goals").unwrap_or(1);
|
|
let reviews: i64 = r.try_get("federate_reviews").unwrap_or(1);
|
|
let watchlist: i64 = r.try_get("federate_watchlist").unwrap_or(1);
|
|
Ok(UserSettings::from_persistence(
|
|
user_id.clone(),
|
|
goals != 0,
|
|
reviews != 0,
|
|
watchlist != 0,
|
|
))
|
|
}
|
|
None => Ok(UserSettings::new(user_id.clone())),
|
|
}
|
|
}
|
|
|
|
async fn save(&self, settings: &UserSettings) -> Result<(), DomainError> {
|
|
let uid = settings.user_id().value().to_string();
|
|
sqlx::query(
|
|
"INSERT OR REPLACE INTO user_settings \
|
|
(user_id, federate_goals, federate_reviews, federate_watchlist) \
|
|
VALUES (?, ?, ?, ?)",
|
|
)
|
|
.bind(&uid)
|
|
.bind(if settings.federate_goals() { 1i64 } else { 0 })
|
|
.bind(if settings.federate_reviews() { 1i64 } else { 0 })
|
|
.bind(if settings.federate_watchlist() {
|
|
1i64
|
|
} else {
|
|
0
|
|
})
|
|
.execute(&self.pool)
|
|
.await
|
|
.map_err(Self::map_err)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl UserFederationSettingsQuery for SqliteUserSettingsRepository {
|
|
async fn get_federation_flags(&self, user_id: &UserId) -> Result<FederationFlags, DomainError> {
|
|
let uid = user_id.value().to_string();
|
|
let row = sqlx::query(
|
|
"SELECT federate_goals, federate_reviews, federate_watchlist \
|
|
FROM user_settings WHERE user_id = ?",
|
|
)
|
|
.bind(&uid)
|
|
.fetch_optional(&self.pool)
|
|
.await
|
|
.map_err(Self::map_err)?;
|
|
|
|
match row {
|
|
Some(r) => {
|
|
let goals: i64 = r.try_get("federate_goals").unwrap_or(1);
|
|
let reviews: i64 = r.try_get("federate_reviews").unwrap_or(1);
|
|
let watchlist: i64 = r.try_get("federate_watchlist").unwrap_or(1);
|
|
Ok(FederationFlags {
|
|
goals: goals != 0,
|
|
reviews: reviews != 0,
|
|
watchlist: watchlist != 0,
|
|
})
|
|
}
|
|
None => Ok(FederationFlags {
|
|
goals: true,
|
|
reviews: true,
|
|
watchlist: true,
|
|
}),
|
|
}
|
|
}
|
|
}
|