GKaszewski/movies-diary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: per-entity federation privacy toggles for reviews and watchlist

Browse Source 
- add federate_reviews + federate_watchlist to UserSettings (default true)
- new UserFederationSettingsQuery port with FederationFlags struct
- remove get_user_federate_goals from LocalApContentQuery
- gate ReviewLogged, ReviewUpdated, WatchlistEntryAdded, on_poster_synced on flags
- goals gating migrated to UserFederationSettingsQuery
- ReviewDeleted and WatchlistEntryRemoved ungated (tombstones always fire)
- sqlite + postgres migrations and adapter impls
- settings API and SPA toggles
This commit is contained in:
Gabriel Kaszewski
2026-06-12 02:26:01 +02:00
parent 33aa5bdab3
commit ca7ca51949
25 changed files with 372 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
crates/adapters/activitypub/src/event_handler.rs
View File

@@ -4,7 +4,7 @@ use domain::ports::EventHandler;
use domain::{
errors::DomainError,
events::DomainEvent,
ports::LocalApContentQuery,
ports::{LocalApContentQuery, UserFederationSettingsQuery},
value_objects::{MovieId, ReviewId, UserId},
};
use std::sync::Arc;
@@ -17,6 +17,7 @@ use crate::urls::{actor_url, goal_url, review_url};
pub struct ActivityPubEventHandler {
ap_service: Arc<ActivityPubService>,
content_query: Arc<dyn LocalApContentQuery>,
federation_settings: Arc<dyn UserFederationSettingsQuery>,
base_url: String,
}
@@ -24,11 +25,13 @@ impl ActivityPubEventHandler {
pub fn new(
ap_service: Arc<ActivityPubService>,
content_query: Arc<dyn LocalApContentQuery>,
federation_settings: Arc<dyn UserFederationSettingsQuery>,
base_url: String,
) -> Self {
Self {
ap_service,
content_query,
federation_settings,
base_url,
}
}
@@ -131,6 +134,12 @@ impl EventHandler for ActivityPubEventHandler {
impl ActivityPubEventHandler {
async fn on_review_logged(&self, user_id: &UserId, review_id: &ReviewId) -> anyhow::Result<()> {
let flags = self.federation_settings.get_federation_flags(user_id).await
.unwrap_or(domain::ports::FederationFlags { goals: true, reviews: true, watchlist: true });
if !flags.reviews {
return Ok(());
}
let review = match self.content_query.get_review_by_id(review_id).await? {
Some(r) => r,
None => return Ok(()),
@@ -184,6 +193,12 @@ impl ActivityPubEventHandler {
user_id: &UserId,
review_id: &ReviewId,
) -> anyhow::Result<()> {
let flags = self.federation_settings.get_federation_flags(user_id).await
.unwrap_or(domain::ports::FederationFlags { goals: true, reviews: true, watchlist: true });
if !flags.reviews {
return Ok(());
}
let review = match self.content_query.get_review_by_id(review_id).await? {
Some(r) => r,
None => return Ok(()),
@@ -250,6 +265,12 @@ impl ActivityPubEventHandler {
external_metadata_id: &Option<String>,
added_at: &chrono::NaiveDateTime,
) -> anyhow::Result<()> {
let flags = self.federation_settings.get_federation_flags(user_id).await
.unwrap_or(domain::ports::FederationFlags { goals: true, reviews: true, watchlist: true });
if !flags.watchlist {
return Ok(());
}
use crate::urls::watchlist_entry_url;
let ap_id = watchlist_entry_url(&self.base_url, user_id.value(), movie_id.value());
let actor = actor_url(&self.base_url, user_id.value());
@@ -316,6 +337,13 @@ impl ActivityPubEventHandler {
for entry in entries {
let review = entry.review();
let user_id = review.user_id();
let flags = self.federation_settings.get_federation_flags(user_id).await
.unwrap_or(domain::ports::FederationFlags { goals: true, reviews: true, watchlist: true });
if !flags.reviews {
continue;
}
let ap_id = review_url(&self.base_url, review.id());
let actor = actor_url(&self.base_url, user_id.value());
@@ -343,12 +371,9 @@ impl ActivityPubEventHandler {
user_id: &UserId,
year: u16,
) -> anyhow::Result<()> {
if !self
.content_query
.get_user_federate_goals(user_id)
.await
.unwrap_or(false)
{
let flags = self.federation_settings.get_federation_flags(user_id).await
.unwrap_or(domain::ports::FederationFlags { goals: true, reviews: true, watchlist: true });
if !flags.goals {
return Ok(());
}
let Some((goal, current)) = self
@@ -384,12 +409,9 @@ impl ActivityPubEventHandler {
target_count: u32,
is_create: bool,
) -> anyhow::Result<()> {
if !self
.content_query
.get_user_federate_goals(user_id)
.await
.unwrap_or(false)
{
let flags = self.federation_settings.get_federation_flags(user_id).await
.unwrap_or(domain::ports::FederationFlags { goals: true, reviews: true, watchlist: true });
if !flags.goals {
return Ok(());
}
let current = self
@@ -418,12 +440,9 @@ impl ActivityPubEventHandler {
}
async fn on_goal_deleted(&self, user_id: &UserId, year: u16) -> anyhow::Result<()> {
if !self
.content_query
.get_user_federate_goals(user_id)
.await
.unwrap_or(false)
{
let flags = self.federation_settings.get_federation_flags(user_id).await
.unwrap_or(domain::ports::FederationFlags { goals: true, reviews: true, watchlist: true });
if !flags.goals {
return Ok(());
}
let ap_id = goal_url(&self.base_url, user_id.value(), year);

3
crates/adapters/activitypub/src/lib.rs
View File

@@ -52,6 +52,7 @@ pub struct ActivityPubDeps {
pub remote_goal_repo: std::sync::Arc<dyn domain::ports::RemoteGoalRepository>,
pub local_ap_content: std::sync::Arc<dyn domain::ports::LocalApContentQuery>,
pub user_repo: std::sync::Arc<dyn domain::ports::UserRepository>,
pub federation_settings: std::sync::Arc<dyn domain::ports::UserFederationSettingsQuery>,
pub base_url: String,
pub allow_registration: bool,
pub event_publisher: std::sync::Arc<dyn domain::ports::EventPublisher>,
@@ -68,6 +69,7 @@ pub async fn wire(deps: ActivityPubDeps) -> anyhow::Result<ActivityPubWire> {
remote_goal_repo,
local_ap_content,
user_repo,
federation_settings,
base_url,
allow_registration,
event_publisher,
@@ -129,6 +131,7 @@ pub async fn wire(deps: ActivityPubDeps) -> anyhow::Result<ActivityPubWire> {
let event_handler = std::sync::Arc::new(ActivityPubEventHandler::new(
std::sync::Arc::clone(&concrete),
local_ap_content,
federation_settings,
base_url,
)) as std::sync::Arc<dyn domain::ports::EventHandler>;

2
crates/adapters/postgres/migrations/0028_federation_privacy.sql Normal file
View File

@@ -0,0 +1,2 @@
ALTER TABLE user_settings ADD COLUMN federate_reviews BOOLEAN NOT NULL DEFAULT TRUE;
ALTER TABLE user_settings ADD COLUMN federate_watchlist BOOLEAN NOT NULL DEFAULT TRUE;

17
crates/adapters/postgres/src/ap_content.rs
View File

@@ -229,23 +229,6 @@ impl LocalApContentQuery for PostgresApContentQuery {
rows.into_iter().map(DiaryRow::into_domain).collect()
}
async fn get_user_federate_goals(&self, user_id: &UserId) -> Result<bool, DomainError> {
let uid = user_id.value().to_string();
let row = sqlx::query("SELECT federate_goals FROM user_settings WHERE user_id = $1")
.bind(&uid)
.fetch_optional(&self.pool)
.await
.map_err(Self::map_err)?;
match row {
Some(r) => {
let val: i64 = r.try_get("federate_goals").unwrap_or(0);
Ok(val != 0)
}
None => Ok(false),
}
}
async fn get_goal_with_progress(
&self,
user_id: &UserId,

8
crates/adapters/postgres/src/lib.rs
View File

@@ -93,6 +93,7 @@ pub struct PostgresWireOutput {
pub wrapup_stats: std::sync::Arc<dyn domain::ports::WrapUpStatsQuery>,
pub goal: std::sync::Arc<dyn domain::ports::GoalRepository>,
pub user_settings: std::sync::Arc<dyn domain::ports::UserSettingsRepository>,
pub federation_settings: std::sync::Arc<dyn domain::ports::UserFederationSettingsQuery>,
pub remote_goal: std::sync::Arc<dyn domain::ports::RemoteGoalRepository>,
}
@@ -108,6 +109,8 @@ pub async fn wire(database_url: &str) -> anyhow::Result<PostgresWireOutput> {
.map_err(|e| anyhow::anyhow!("{e}"))
.context("Database migration failed")?;
let user_settings_repo = std::sync::Arc::new(user_settings::PostgresUserSettingsRepository::new(pool.clone()));
Ok(PostgresWireOutput {
pool: pool.clone(),
movie: std::sync::Arc::new(PostgresMovieRepository::new(pool.clone())) as _,
@@ -125,9 +128,8 @@ pub async fn wire(database_url: &str) -> anyhow::Result<PostgresWireOutput> {
wrapup_repo: std::sync::Arc::new(PostgresWrapUpRepository::new(pool.clone())) as _,
wrapup_stats: std::sync::Arc::new(PostgresWrapUpStatsQuery::new(pool.clone())) as _,
goal: std::sync::Arc::new(goals::PostgresGoalRepository::new(pool.clone())) as _,
user_settings: std::sync::Arc::new(user_settings::PostgresUserSettingsRepository::new(
pool.clone(),
)) as _,
user_settings: std::sync::Arc::clone(&user_settings_repo) as _,
federation_settings: user_settings_repo as _,
remote_goal: std::sync::Arc::new(remote_goals::PostgresRemoteGoalRepository::new(pool))
as _,
})

70
crates/adapters/postgres/src/user_settings.rs
View File

@@ -1,6 +1,9 @@
use async_trait::async_trait;
use domain::{
errors::DomainError, models::UserSettings, ports::UserSettingsRepository, value_objects::UserId,
errors::DomainError,
models::UserSettings,
ports::{FederationFlags, UserFederationSettingsQuery, UserSettingsRepository},
value_objects::UserId,
};
use sqlx::{PgPool, Row};
@@ -23,20 +26,25 @@ impl PostgresUserSettingsRepository {
impl UserSettingsRepository for PostgresUserSettingsRepository {
async fn get(&self, user_id: &UserId) -> Result<UserSettings, DomainError> {
let uid = user_id.value().to_string();
let row =
sqlx::query("SELECT user_id, federate_goals FROM user_settings WHERE user_id = $1")
.bind(&uid)
.fetch_optional(&self.pool)
.await
.map_err(Self::map_err)?;
let row = sqlx::query(
"SELECT federate_goals, federate_reviews, federate_watchlist \
FROM user_settings WHERE user_id = $1",
)
.bind(&uid)
.fetch_optional(&self.pool)
.await
.map_err(Self::map_err)?;
match row {
Some(r) => {
let federate: i64 = r.try_get("federate_goals").unwrap_or(0);
let goals: bool = r.try_get("federate_goals").unwrap_or(true);
let reviews: bool = r.try_get("federate_reviews").unwrap_or(true);
let watchlist: bool = r.try_get("federate_watchlist").unwrap_or(true);
Ok(UserSettings::from_persistence(
user_id.clone(),
federate != 0,
goals,
reviews,
watchlist,
))
}
None => Ok(UserSettings::new(user_id.clone())),
@@ -45,18 +53,48 @@ impl UserSettingsRepository for PostgresUserSettingsRepository {
async fn save(&self, settings: &UserSettings) -> Result<(), DomainError> {
let uid = settings.user_id().value().to_string();
let federate = if settings.federate_goals() { 1i64 } else { 0 };
sqlx::query(
"INSERT INTO user_settings (user_id, federate_goals) VALUES ($1, $2) \
ON CONFLICT (user_id) DO UPDATE SET federate_goals = $2",
"INSERT INTO user_settings (user_id, federate_goals, federate_reviews, federate_watchlist) \
VALUES ($1, $2, $3, $4) \
ON CONFLICT (user_id) DO UPDATE \
SET federate_goals = $2, federate_reviews = $3, federate_watchlist = $4",
)
.bind(&uid)
.bind(federate)
.bind(settings.federate_goals())
.bind(settings.federate_reviews())
.bind(settings.federate_watchlist())
.execute(&self.pool)
.await
.map_err(Self::map_err)?;
Ok(())
}
}
#[async_trait]
impl UserFederationSettingsQuery for PostgresUserSettingsRepository {
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 = $1",
)
.bind(&uid)
.fetch_optional(&self.pool)
.await
.map_err(Self::map_err)?;
match row {
Some(r) => {
let goals: bool = r.try_get("federate_goals").unwrap_or(true);
let reviews: bool = r.try_get("federate_reviews").unwrap_or(true);
let watchlist: bool = r.try_get("federate_watchlist").unwrap_or(true);
Ok(FederationFlags { goals, reviews, watchlist })
}
None => Ok(FederationFlags {
goals: true,
reviews: true,
watchlist: true,
}),
}
}
}

2
crates/adapters/sqlite/migrations/0028_federation_privacy.sql Normal file
View File

@@ -0,0 +1,2 @@
ALTER TABLE user_settings ADD COLUMN federate_reviews BOOLEAN NOT NULL DEFAULT TRUE;
ALTER TABLE user_settings ADD COLUMN federate_watchlist BOOLEAN NOT NULL DEFAULT TRUE;

19
crates/adapters/sqlite/src/ap_content.rs
View File

@@ -5,7 +5,7 @@ use domain::{
ports::LocalApContentQuery,
value_objects::{MovieId, ReviewId, UserId},
};
use sqlx::{Row, SqlitePool};
use sqlx::SqlitePool;
use crate::models::{DiaryRow, MovieRow, ReviewRow, WatchlistRow};
@@ -169,23 +169,6 @@ impl LocalApContentQuery for SqliteApContentQuery {
rows.into_iter().map(DiaryRow::into_domain).collect()
}
async fn get_user_federate_goals(&self, user_id: &UserId) -> Result<bool, DomainError> {
let uid = user_id.value().to_string();
let row = sqlx::query("SELECT federate_goals FROM user_settings WHERE user_id = ?")
.bind(&uid)
.fetch_optional(&self.pool)
.await
.map_err(Self::map_err)?;
match row {
Some(r) => {
let val: i64 = r.try_get("federate_goals").unwrap_or(0);
Ok(val != 0)
}
None => Ok(false),
}
}
async fn get_goal_with_progress(
&self,
user_id: &UserId,

8
crates/adapters/sqlite/src/lib.rs
View File

@@ -89,6 +89,7 @@ pub struct SqliteWireOutput {
pub wrapup_stats: std::sync::Arc<dyn domain::ports::WrapUpStatsQuery>,
pub goal: std::sync::Arc<dyn domain::ports::GoalRepository>,
pub user_settings: std::sync::Arc<dyn domain::ports::UserSettingsRepository>,
pub federation_settings: std::sync::Arc<dyn domain::ports::UserFederationSettingsQuery>,
pub remote_goal: std::sync::Arc<dyn domain::ports::RemoteGoalRepository>,
}
@@ -113,6 +114,8 @@ pub async fn wire(database_url: &str) -> anyhow::Result<SqliteWireOutput> {
.map_err(|e| anyhow::anyhow!("{e}"))
.context("Database migration failed")?;
let user_settings_repo = std::sync::Arc::new(user_settings::SqliteUserSettingsRepository::new(pool.clone()));
Ok(SqliteWireOutput {
pool: pool.clone(),
movie: std::sync::Arc::new(SqliteMovieRepository::new(pool.clone())) as _,
@@ -128,9 +131,8 @@ pub async fn wire(database_url: &str) -> anyhow::Result<SqliteWireOutput> {
wrapup_repo: std::sync::Arc::new(SqliteWrapUpRepository::new(pool.clone())) as _,
wrapup_stats: std::sync::Arc::new(SqliteWrapUpStatsQuery::new(pool.clone())) as _,
goal: std::sync::Arc::new(goals::SqliteGoalRepository::new(pool.clone())) as _,
user_settings: std::sync::Arc::new(user_settings::SqliteUserSettingsRepository::new(
pool.clone(),
)) as _,
user_settings: std::sync::Arc::clone(&user_settings_repo) as _,
federation_settings: user_settings_repo as _,
remote_goal: std::sync::Arc::new(remote_goals::SqliteRemoteGoalRepository::new(pool)) as _,
})
}

82
crates/adapters/sqlite/src/user_settings.rs
View File

@@ -1,6 +1,9 @@
use async_trait::async_trait;
use domain::{
errors::DomainError, models::UserSettings, ports::UserSettingsRepository, value_objects::UserId,
errors::DomainError,
models::UserSettings,
ports::{FederationFlags, UserFederationSettingsQuery, UserSettingsRepository},
value_objects::UserId,
};
use sqlx::{Row, SqlitePool};
@@ -23,20 +26,25 @@ impl SqliteUserSettingsRepository {
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 user_id, federate_goals FROM user_settings WHERE user_id = ?")
.bind(&uid)
.fetch_optional(&self.pool)
.await
.map_err(Self::map_err)?;
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 federate: i64 = r.try_get("federate_goals").unwrap_or(0);
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(),
federate != 0,
goals != 0,
reviews != 0,
watchlist != 0,
))
}
None => Ok(UserSettings::new(user_id.clone())),
@@ -45,15 +53,51 @@ impl UserSettingsRepository for SqliteUserSettingsRepository {
async fn save(&self, settings: &UserSettings) -> Result<(), DomainError> {
let uid = settings.user_id().value().to_string();
let federate = if settings.federate_goals() { 1i64 } else { 0 };
sqlx::query("INSERT OR REPLACE INTO user_settings (user_id, federate_goals) VALUES (?, ?)")
.bind(&uid)
.bind(federate)
.execute(&self.pool)
.await
.map_err(Self::map_err)?;
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,
}),
}
}
}

4
crates/api-types/src/goals.rs
View File

@@ -29,9 +29,13 @@ pub struct UpdateGoalRequest {
#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
pub struct UserSettingsDto {
pub federate_goals: bool,
pub federate_reviews: bool,
pub federate_watchlist: bool,
}
#[derive(Debug, Clone, Deserialize, utoipa::ToSchema)]
pub struct UpdateUserSettingsRequest {
pub federate_goals: bool,
pub federate_reviews: bool,
pub federate_watchlist: bool,
}

4
crates/application/src/users/tests/get_settings.rs
View File

@@ -11,5 +11,7 @@ async fn returns_default_settings() {
.await
.unwrap();
assert!(!settings.federate_goals());
assert!(settings.federate_goals());
assert!(settings.federate_reviews());
assert!(settings.federate_watchlist());
}

53
crates/application/src/users/tests/update_settings.rs
View File

@@ -13,7 +13,31 @@ async fn updates_federate_goals() {
let settings_repo = InMemoryUserSettingsRepository::new();
let b = TestContextBuilder::new().with_user_settings(Arc::clone(&settings_repo) as _);
let user_settings = b.user_settings_repo.clone();
let uid = Uuid::nil();
crate::users::update_settings::execute(
user_settings.clone(),
UpdateUserSettingsCommand {
user_id: uid,
federate_goals: false,
federate_reviews: true,
federate_watchlist: true,
},
)
.await
.unwrap();
let settings = get_settings::execute(user_settings, uid).await.unwrap();
assert!(!settings.federate_goals());
assert!(settings.federate_reviews());
assert!(settings.federate_watchlist());
}
#[tokio::test]
async fn updates_federate_reviews() {
let settings_repo = InMemoryUserSettingsRepository::new();
let b = TestContextBuilder::new().with_user_settings(Arc::clone(&settings_repo) as _);
let user_settings = b.user_settings_repo.clone();
let uid = Uuid::nil();
crate::users::update_settings::execute(
@@ -21,6 +45,8 @@ async fn updates_federate_goals() {
UpdateUserSettingsCommand {
user_id: uid,
federate_goals: true,
federate_reviews: false,
federate_watchlist: true,
},
)
.await
@@ -28,4 +54,31 @@ async fn updates_federate_goals() {
let settings = get_settings::execute(user_settings, uid).await.unwrap();
assert!(settings.federate_goals());
assert!(!settings.federate_reviews());
assert!(settings.federate_watchlist());
}
#[tokio::test]
async fn updates_federate_watchlist() {
let settings_repo = InMemoryUserSettingsRepository::new();
let b = TestContextBuilder::new().with_user_settings(Arc::clone(&settings_repo) as _);
let user_settings = b.user_settings_repo.clone();
let uid = Uuid::nil();
crate::users::update_settings::execute(
user_settings.clone(),
UpdateUserSettingsCommand {
user_id: uid,
federate_goals: true,
federate_reviews: true,
federate_watchlist: false,
},
)
.await
.unwrap();
let settings = get_settings::execute(user_settings, uid).await.unwrap();
assert!(settings.federate_goals());
assert!(settings.federate_reviews());
assert!(!settings.federate_watchlist());
}

4
crates/application/src/users/update_settings.rs
View File

@@ -5,6 +5,8 @@ use domain::{errors::DomainError, ports::UserSettingsRepository, value_objects::
pub struct UpdateUserSettingsCommand {
pub user_id: uuid::Uuid,
pub federate_goals: bool,
pub federate_reviews: bool,
pub federate_watchlist: bool,
}
pub async fn execute(
@@ -14,6 +16,8 @@ pub async fn execute(
let uid = UserId::from_uuid(cmd.user_id);
let mut settings = user_settings.get(&uid).await?;
settings.set_federate_goals(cmd.federate_goals);
settings.set_federate_reviews(cmd.federate_reviews);
settings.set_federate_watchlist(cmd.federate_watchlist);
user_settings.save(&settings).await
}

39
crates/domain/src/models/user_settings.rs
View File

@@ -4,27 +4,34 @@ use crate::value_objects::UserId;
pub struct UserSettings {
user_id: UserId,
federate_goals: bool,
federate_reviews: bool,
federate_watchlist: bool,
}
impl UserSettings {
pub fn new(user_id: UserId) -> Self {
Self {
user_id,
federate_goals: false,
federate_goals: true,
federate_reviews: true,
federate_watchlist: true,
}
}
pub fn from_persistence(user_id: UserId, federate_goals: bool) -> Self {
pub fn from_persistence(
user_id: UserId,
federate_goals: bool,
federate_reviews: bool,
federate_watchlist: bool,
) -> Self {
Self {
user_id,
federate_goals,
federate_reviews,
federate_watchlist,
}
}
pub fn set_federate_goals(&mut self, value: bool) {
self.federate_goals = value;
}
pub fn user_id(&self) -> &UserId {
&self.user_id
}
@@ -32,4 +39,24 @@ impl UserSettings {
pub fn federate_goals(&self) -> bool {
self.federate_goals
}
pub fn set_federate_goals(&mut self, value: bool) {
self.federate_goals = value;
}
pub fn federate_reviews(&self) -> bool {
self.federate_reviews
}
pub fn set_federate_reviews(&mut self, value: bool) {
self.federate_reviews = value;
}
pub fn federate_watchlist(&self) -> bool {
self.federate_watchlist
}
pub fn set_federate_watchlist(&mut self, value: bool) {
self.federate_watchlist = value;
}
}

13
crates/domain/src/ports.rs
View File

@@ -456,6 +456,17 @@ pub trait UserSettingsRepository: Send + Sync {
async fn save(&self, settings: &UserSettings) -> Result<(), DomainError>;
}
pub struct FederationFlags {
pub goals: bool,
pub reviews: bool,
pub watchlist: bool,
}
#[async_trait]
pub trait UserFederationSettingsQuery: Send + Sync {
async fn get_federation_flags(&self, user_id: &UserId) -> Result<FederationFlags, DomainError>;
}
#[async_trait]
pub trait RemoteGoalRepository: Send + Sync {
async fn save(&self, entry: RemoteGoalEntry) -> Result<(), DomainError>;
@@ -502,8 +513,6 @@ pub trait LocalApContentQuery: Send + Sync {
limit: usize,
) -> Result<Vec<DiaryEntry>, DomainError>;
async fn get_user_federate_goals(&self, user_id: &UserId) -> Result<bool, DomainError>;
async fn get_goal_with_progress(
&self,
user_id: &UserId,

23
crates/domain/src/testing/in_memory.rs
View File

@@ -18,9 +18,10 @@ use crate::{
collections::{PageParams, Paginated},
},
ports::{
GoalRepository, ImportProfileRepository, ImportSessionRepository, MovieProfileRepository,
MovieRepository, RefreshSessionRepository, ReviewRepository, UserProfileFieldsRepository,
UserRepository, UserSettingsRepository, WatchEventRepository, WatchlistRepository,
FederationFlags, GoalRepository, ImportProfileRepository, ImportSessionRepository,
MovieProfileRepository, MovieRepository, RefreshSessionRepository, ReviewRepository,
UserFederationSettingsQuery, UserProfileFieldsRepository, UserRepository,
UserSettingsRepository, WatchEventRepository, WatchlistRepository,
WebhookTokenRepository,
},
value_objects::{
@@ -441,6 +442,22 @@ impl UserSettingsRepository for InMemoryUserSettingsRepository {
}
}
#[async_trait]
impl UserFederationSettingsQuery for InMemoryUserSettingsRepository {
async fn get_federation_flags(&self, user_id: &UserId) -> Result<FederationFlags, DomainError> {
let store = self.store.lock().unwrap();
let settings = store
.get(&user_id.value())
.cloned()
.unwrap_or_else(|| UserSettings::new(user_id.clone()));
Ok(FederationFlags {
goals: settings.federate_goals(),
reviews: settings.federate_reviews(),
watchlist: settings.federate_watchlist(),
})
}
}
// ── InMemoryWebhookTokenRepository ──────────────────────────────────────────
pub struct InMemoryWebhookTokenRepository {

3
crates/presentation/src/factory.rs
View File

@@ -36,6 +36,7 @@ pub struct DatabaseOutput {
pub wrapup_repo: Arc<dyn domain::ports::WrapUpRepository>,
pub goal: Arc<dyn domain::ports::GoalRepository>,
pub user_settings: Arc<dyn domain::ports::UserSettingsRepository>,
pub federation_settings: std::sync::Arc<dyn domain::ports::UserFederationSettingsQuery>,
pub remote_goal: Arc<dyn domain::ports::RemoteGoalRepository>,
pub refresh_session: Arc<dyn RefreshSessionRepository>,
pub db_pool: DbPool,
@@ -78,6 +79,7 @@ pub async fn build_database_adapters(backend: &str, url: &str) -> anyhow::Result
wrapup_repo: w.wrapup_repo,
goal: w.goal,
user_settings: w.user_settings,
federation_settings: w.federation_settings,
remote_goal: w.remote_goal,
refresh_session: Arc::new(postgres::PostgresRefreshSessionAdapter::new(
w.pool.clone(),
@@ -119,6 +121,7 @@ pub async fn build_database_adapters(backend: &str, url: &str) -> anyhow::Result
wrapup_repo: w.wrapup_repo,
goal: w.goal,
user_settings: w.user_settings,
federation_settings: w.federation_settings,
remote_goal: w.remote_goal,
refresh_session: Arc::new(sqlite::SqliteRefreshSessionAdapter::new(w.pool.clone()))
as _,

4
crates/presentation/src/handlers/goals.rs
View File

@@ -176,6 +176,8 @@ pub async fn get_settings(
.await?;
Ok(Json(UserSettingsDto {
federate_goals: settings.federate_goals(),
federate_reviews: settings.federate_reviews(),
federate_watchlist: settings.federate_watchlist(),
}))
}
@@ -198,6 +200,8 @@ pub async fn update_settings(
application::users::update_settings::UpdateUserSettingsCommand {
user_id: user.0.value(),
federate_goals: req.federate_goals,
federate_reviews: req.federate_reviews,
federate_watchlist: req.federate_watchlist,
},
)
.await?;

1
crates/presentation/src/main.rs
View File

@@ -119,6 +119,7 @@ async fn wire_dependencies() -> anyhow::Result<(AppState, axum::Router)> {
remote_goal_repo: Arc::clone(&db.remote_goal),
local_ap_content: Arc::clone(&ap_content_repo),
user_repo: Arc::clone(&db.user),
federation_settings: std::sync::Arc::clone(&db.federation_settings),
base_url: app_config.base_url.clone(),
allow_registration: app_config.allow_registration,
event_publisher: Arc::clone(&ep),

5
crates/worker/src/db.rs
View File

@@ -4,7 +4,7 @@ use anyhow::Context;
use domain::ports::{
ImageRefCommand, ImageRefQuery, ImportSessionRepository, LocalApContentQuery,
MovieProfileRepository, MovieRepository, PersonCommand, PersonQuery, SearchCommand,
UserRepository, WatchEventRepository,
UserFederationSettingsQuery, UserRepository, WatchEventRepository,
};
pub enum DbPool {
@@ -30,6 +30,7 @@ pub struct WorkerDbOutput {
pub wrapup_repo: Arc<dyn domain::ports::WrapUpRepository>,
pub remote_goal: Arc<dyn domain::ports::RemoteGoalRepository>,
pub refresh_session: Arc<dyn domain::ports::RefreshSessionRepository>,
pub federation_settings: Arc<dyn domain::ports::UserFederationSettingsQuery>,
pub db_pool: DbPool,
}
@@ -64,6 +65,7 @@ pub async fn connect(database_url: &str, backend: &str) -> anyhow::Result<Worker
refresh_session: Arc::new(postgres::PostgresRefreshSessionAdapter::new(
w.pool.clone(),
)) as _,
federation_settings: w.federation_settings,
db_pool: DbPool::Postgres(w.pool),
})
}
@@ -95,6 +97,7 @@ pub async fn connect(database_url: &str, backend: &str) -> anyhow::Result<Worker
remote_goal: w.remote_goal,
refresh_session: Arc::new(sqlite::SqliteRefreshSessionAdapter::new(w.pool.clone()))
as _,
federation_settings: w.federation_settings,
db_pool: DbPool::Sqlite(w.pool),
})
}

1
crates/worker/src/main.rs
View File

@@ -241,6 +241,7 @@ async fn main() -> anyhow::Result<()> {
base_url,
allow_registration,
event_publisher: Arc::clone(&event_publisher),
federation_settings: std::sync::Arc::clone(&db.federation_settings),
})
.await?;