789 lines
23 KiB
Rust
789 lines
23 KiB
Rust
use uuid::Uuid;
|
|
|
|
use fedimovies_utils::id::generate_ulid;
|
|
|
|
use crate::database::{catch_unique_violation, DatabaseClient, DatabaseError};
|
|
use crate::notifications::queries::create_follow_notification;
|
|
use crate::profiles::{
|
|
queries::{update_follower_count, update_following_count, update_subscriber_count},
|
|
types::DbActorProfile,
|
|
};
|
|
|
|
use super::types::{
|
|
DbFollowRequest, DbRelationship, FollowRequestStatus, RelatedActorProfile, RelationshipType,
|
|
};
|
|
|
|
pub async fn get_relationships(
|
|
db_client: &impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
) -> Result<Vec<DbRelationship>, DatabaseError> {
|
|
let rows = db_client
|
|
.query(
|
|
"
|
|
SELECT source_id, target_id, relationship_type
|
|
FROM relationship
|
|
WHERE
|
|
source_id = $1 AND target_id = $2
|
|
OR
|
|
source_id = $2 AND target_id = $1
|
|
UNION ALL
|
|
SELECT source_id, target_id, $4
|
|
FROM follow_request
|
|
WHERE
|
|
source_id = $1 AND target_id = $2
|
|
AND request_status = $3
|
|
",
|
|
&[
|
|
&source_id,
|
|
&target_id,
|
|
&FollowRequestStatus::Pending,
|
|
&RelationshipType::FollowRequest,
|
|
],
|
|
)
|
|
.await?;
|
|
let relationships = rows
|
|
.iter()
|
|
.map(DbRelationship::try_from)
|
|
.collect::<Result<_, _>>()?;
|
|
Ok(relationships)
|
|
}
|
|
|
|
pub async fn has_relationship(
|
|
db_client: &impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
relationship_type: RelationshipType,
|
|
) -> Result<bool, DatabaseError> {
|
|
let maybe_row = db_client
|
|
.query_opt(
|
|
"
|
|
SELECT 1
|
|
FROM relationship
|
|
WHERE
|
|
source_id = $1 AND target_id = $2
|
|
AND relationship_type = $3
|
|
",
|
|
&[&source_id, &target_id, &relationship_type],
|
|
)
|
|
.await?;
|
|
Ok(maybe_row.is_some())
|
|
}
|
|
|
|
pub async fn follow(
|
|
db_client: &mut impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
) -> Result<(), DatabaseError> {
|
|
let transaction = db_client.transaction().await?;
|
|
transaction
|
|
.execute(
|
|
"
|
|
INSERT INTO relationship (source_id, target_id, relationship_type)
|
|
VALUES ($1, $2, $3)
|
|
",
|
|
&[&source_id, &target_id, &RelationshipType::Follow],
|
|
)
|
|
.await
|
|
.map_err(catch_unique_violation("relationship"))?;
|
|
let target_profile = update_follower_count(&transaction, target_id, 1).await?;
|
|
update_following_count(&transaction, source_id, 1).await?;
|
|
if target_profile.is_local() {
|
|
create_follow_notification(&transaction, source_id, target_id).await?;
|
|
};
|
|
transaction.commit().await?;
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn unfollow(
|
|
db_client: &mut impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
) -> Result<Option<Uuid>, DatabaseError> {
|
|
let transaction = db_client.transaction().await?;
|
|
let deleted_count = transaction
|
|
.execute(
|
|
"
|
|
DELETE FROM relationship
|
|
WHERE
|
|
source_id = $1 AND target_id = $2
|
|
AND relationship_type = $3
|
|
",
|
|
&[&source_id, &target_id, &RelationshipType::Follow],
|
|
)
|
|
.await?;
|
|
let relationship_deleted = deleted_count > 0;
|
|
// Delete follow request (for remote follows)
|
|
let follow_request_deleted =
|
|
delete_follow_request_opt(&transaction, source_id, target_id).await?;
|
|
if !relationship_deleted && follow_request_deleted.is_none() {
|
|
return Err(DatabaseError::NotFound("relationship"));
|
|
};
|
|
if relationship_deleted {
|
|
// Also reset repost and reply visibility settings
|
|
show_reposts(&transaction, source_id, target_id).await?;
|
|
show_replies(&transaction, source_id, target_id).await?;
|
|
// Update counters only if relationship existed
|
|
update_follower_count(&transaction, target_id, -1).await?;
|
|
update_following_count(&transaction, source_id, -1).await?;
|
|
};
|
|
transaction.commit().await?;
|
|
Ok(follow_request_deleted)
|
|
}
|
|
|
|
// Follow remote actor
|
|
pub async fn create_follow_request(
|
|
db_client: &impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
) -> Result<DbFollowRequest, DatabaseError> {
|
|
let request_id = generate_ulid();
|
|
let row = db_client
|
|
.query_one(
|
|
"
|
|
INSERT INTO follow_request (
|
|
id, source_id, target_id, request_status
|
|
)
|
|
VALUES ($1, $2, $3, $4)
|
|
RETURNING follow_request
|
|
",
|
|
&[
|
|
&request_id,
|
|
&source_id,
|
|
&target_id,
|
|
&FollowRequestStatus::Pending,
|
|
],
|
|
)
|
|
.await
|
|
.map_err(catch_unique_violation("follow request"))?;
|
|
let request = row.try_get("follow_request")?;
|
|
Ok(request)
|
|
}
|
|
|
|
// Save follow request from remote actor
|
|
pub async fn create_remote_follow_request_opt(
|
|
db_client: &impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
activity_id: &str,
|
|
) -> Result<DbFollowRequest, DatabaseError> {
|
|
let request_id = generate_ulid();
|
|
let row = db_client
|
|
.query_one(
|
|
"
|
|
INSERT INTO follow_request (
|
|
id,
|
|
source_id,
|
|
target_id,
|
|
activity_id,
|
|
request_status
|
|
)
|
|
VALUES ($1, $2, $3, $4, $5)
|
|
ON CONFLICT (source_id, target_id)
|
|
DO UPDATE SET activity_id = $4
|
|
RETURNING follow_request
|
|
",
|
|
&[
|
|
&request_id,
|
|
&source_id,
|
|
&target_id,
|
|
&activity_id,
|
|
&FollowRequestStatus::Pending,
|
|
],
|
|
)
|
|
.await?;
|
|
let request = row.try_get("follow_request")?;
|
|
Ok(request)
|
|
}
|
|
|
|
pub async fn follow_request_accepted(
|
|
db_client: &mut impl DatabaseClient,
|
|
request_id: &Uuid,
|
|
) -> Result<(), DatabaseError> {
|
|
let mut transaction = db_client.transaction().await?;
|
|
let maybe_row = transaction
|
|
.query_opt(
|
|
"
|
|
UPDATE follow_request
|
|
SET request_status = $1
|
|
WHERE id = $2
|
|
RETURNING source_id, target_id
|
|
",
|
|
&[&FollowRequestStatus::Accepted, &request_id],
|
|
)
|
|
.await?;
|
|
let row = maybe_row.ok_or(DatabaseError::NotFound("follow request"))?;
|
|
let source_id: Uuid = row.try_get("source_id")?;
|
|
let target_id: Uuid = row.try_get("target_id")?;
|
|
follow(&mut transaction, &source_id, &target_id).await?;
|
|
transaction.commit().await?;
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn follow_request_rejected(
|
|
db_client: &impl DatabaseClient,
|
|
request_id: &Uuid,
|
|
) -> Result<(), DatabaseError> {
|
|
let updated_count = db_client
|
|
.execute(
|
|
"
|
|
UPDATE follow_request
|
|
SET request_status = $1
|
|
WHERE id = $2
|
|
",
|
|
&[&FollowRequestStatus::Rejected, &request_id],
|
|
)
|
|
.await?;
|
|
if updated_count == 0 {
|
|
return Err(DatabaseError::NotFound("follow request"));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
async fn delete_follow_request_opt(
|
|
db_client: &impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
) -> Result<Option<Uuid>, DatabaseError> {
|
|
let maybe_row = db_client
|
|
.query_opt(
|
|
"
|
|
DELETE FROM follow_request
|
|
WHERE source_id = $1 AND target_id = $2
|
|
RETURNING id
|
|
",
|
|
&[&source_id, &target_id],
|
|
)
|
|
.await?;
|
|
let maybe_request_id = if let Some(row) = maybe_row {
|
|
let request_id: Uuid = row.try_get("id")?;
|
|
Some(request_id)
|
|
} else {
|
|
None
|
|
};
|
|
Ok(maybe_request_id)
|
|
}
|
|
|
|
pub async fn get_follow_request_by_id(
|
|
db_client: &impl DatabaseClient,
|
|
request_id: &Uuid,
|
|
) -> Result<DbFollowRequest, DatabaseError> {
|
|
let maybe_row = db_client
|
|
.query_opt(
|
|
"
|
|
SELECT follow_request
|
|
FROM follow_request
|
|
WHERE id = $1
|
|
",
|
|
&[&request_id],
|
|
)
|
|
.await?;
|
|
let row = maybe_row.ok_or(DatabaseError::NotFound("follow request"))?;
|
|
let request = row.try_get("follow_request")?;
|
|
Ok(request)
|
|
}
|
|
|
|
pub async fn get_follow_request_by_activity_id(
|
|
db_client: &impl DatabaseClient,
|
|
activity_id: &str,
|
|
) -> Result<DbFollowRequest, DatabaseError> {
|
|
let maybe_row = db_client
|
|
.query_opt(
|
|
"
|
|
SELECT follow_request
|
|
FROM follow_request
|
|
WHERE activity_id = $1
|
|
",
|
|
&[&activity_id],
|
|
)
|
|
.await?;
|
|
let row = maybe_row.ok_or(DatabaseError::NotFound("follow request"))?;
|
|
let request = row.try_get("follow_request")?;
|
|
Ok(request)
|
|
}
|
|
|
|
pub async fn get_followers(
|
|
db_client: &impl DatabaseClient,
|
|
profile_id: &Uuid,
|
|
) -> Result<Vec<DbActorProfile>, DatabaseError> {
|
|
let rows = db_client
|
|
.query(
|
|
"
|
|
SELECT actor_profile
|
|
FROM actor_profile
|
|
JOIN relationship
|
|
ON (actor_profile.id = relationship.source_id)
|
|
WHERE
|
|
relationship.target_id = $1
|
|
AND relationship.relationship_type = $2
|
|
",
|
|
&[&profile_id, &RelationshipType::Follow],
|
|
)
|
|
.await?;
|
|
let profiles = rows
|
|
.iter()
|
|
.map(|row| row.try_get("actor_profile"))
|
|
.collect::<Result<_, _>>()?;
|
|
Ok(profiles)
|
|
}
|
|
|
|
pub async fn get_followers_paginated(
|
|
db_client: &impl DatabaseClient,
|
|
profile_id: &Uuid,
|
|
max_relationship_id: Option<i32>,
|
|
limit: u16,
|
|
) -> Result<Vec<RelatedActorProfile>, DatabaseError> {
|
|
let rows = db_client
|
|
.query(
|
|
"
|
|
SELECT relationship.id, actor_profile
|
|
FROM actor_profile
|
|
JOIN relationship
|
|
ON (actor_profile.id = relationship.source_id)
|
|
WHERE
|
|
relationship.target_id = $1
|
|
AND relationship.relationship_type = $2
|
|
AND ($3::integer IS NULL OR relationship.id < $3)
|
|
ORDER BY relationship.id DESC
|
|
LIMIT $4
|
|
",
|
|
&[
|
|
&profile_id,
|
|
&RelationshipType::Follow,
|
|
&max_relationship_id,
|
|
&i64::from(limit),
|
|
],
|
|
)
|
|
.await?;
|
|
let related_profiles = rows
|
|
.iter()
|
|
.map(RelatedActorProfile::try_from)
|
|
.collect::<Result<_, _>>()?;
|
|
Ok(related_profiles)
|
|
}
|
|
|
|
pub async fn has_local_followers(
|
|
db_client: &impl DatabaseClient,
|
|
actor_id: &str,
|
|
) -> Result<bool, DatabaseError> {
|
|
let maybe_row = db_client
|
|
.query_opt(
|
|
"
|
|
SELECT 1
|
|
FROM relationship
|
|
JOIN actor_profile ON (relationship.target_id = actor_profile.id)
|
|
WHERE
|
|
actor_profile.actor_id = $1
|
|
AND relationship_type = $2
|
|
LIMIT 1
|
|
",
|
|
&[&actor_id, &RelationshipType::Follow],
|
|
)
|
|
.await?;
|
|
Ok(maybe_row.is_some())
|
|
}
|
|
|
|
pub async fn get_following(
|
|
db_client: &impl DatabaseClient,
|
|
profile_id: &Uuid,
|
|
) -> Result<Vec<DbActorProfile>, DatabaseError> {
|
|
let rows = db_client
|
|
.query(
|
|
"
|
|
SELECT actor_profile
|
|
FROM actor_profile
|
|
JOIN relationship
|
|
ON (actor_profile.id = relationship.target_id)
|
|
WHERE
|
|
relationship.source_id = $1
|
|
AND relationship.relationship_type = $2
|
|
",
|
|
&[&profile_id, &RelationshipType::Follow],
|
|
)
|
|
.await?;
|
|
let profiles = rows
|
|
.iter()
|
|
.map(|row| row.try_get("actor_profile"))
|
|
.collect::<Result<_, _>>()?;
|
|
Ok(profiles)
|
|
}
|
|
|
|
pub async fn get_following_paginated(
|
|
db_client: &impl DatabaseClient,
|
|
profile_id: &Uuid,
|
|
max_relationship_id: Option<i32>,
|
|
limit: u16,
|
|
) -> Result<Vec<RelatedActorProfile>, DatabaseError> {
|
|
let rows = db_client
|
|
.query(
|
|
"
|
|
SELECT relationship.id, actor_profile
|
|
FROM actor_profile
|
|
JOIN relationship
|
|
ON (actor_profile.id = relationship.target_id)
|
|
WHERE
|
|
relationship.source_id = $1
|
|
AND relationship.relationship_type = $2
|
|
AND ($3::integer IS NULL OR relationship.id < $3)
|
|
ORDER BY relationship.id DESC
|
|
LIMIT $4
|
|
",
|
|
&[
|
|
&profile_id,
|
|
&RelationshipType::Follow,
|
|
&max_relationship_id,
|
|
&i64::from(limit),
|
|
],
|
|
)
|
|
.await?;
|
|
let related_profiles = rows
|
|
.iter()
|
|
.map(RelatedActorProfile::try_from)
|
|
.collect::<Result<_, _>>()?;
|
|
Ok(related_profiles)
|
|
}
|
|
|
|
pub async fn subscribe(
|
|
db_client: &mut impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
) -> Result<(), DatabaseError> {
|
|
let transaction = db_client.transaction().await?;
|
|
transaction
|
|
.execute(
|
|
"
|
|
INSERT INTO relationship (source_id, target_id, relationship_type)
|
|
VALUES ($1, $2, $3)
|
|
",
|
|
&[&source_id, &target_id, &RelationshipType::Subscription],
|
|
)
|
|
.await
|
|
.map_err(catch_unique_violation("relationship"))?;
|
|
update_subscriber_count(&transaction, target_id, 1).await?;
|
|
transaction.commit().await?;
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn subscribe_opt(
|
|
db_client: &mut impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
) -> Result<(), DatabaseError> {
|
|
let transaction = db_client.transaction().await?;
|
|
let inserted_count = transaction
|
|
.execute(
|
|
"
|
|
INSERT INTO relationship (source_id, target_id, relationship_type)
|
|
VALUES ($1, $2, $3)
|
|
ON CONFLICT (source_id, target_id, relationship_type) DO NOTHING
|
|
",
|
|
&[&source_id, &target_id, &RelationshipType::Subscription],
|
|
)
|
|
.await?;
|
|
if inserted_count > 0 {
|
|
update_subscriber_count(&transaction, target_id, 1).await?;
|
|
};
|
|
transaction.commit().await?;
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn unsubscribe(
|
|
db_client: &mut impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
) -> Result<(), DatabaseError> {
|
|
let transaction = db_client.transaction().await?;
|
|
let deleted_count = transaction
|
|
.execute(
|
|
"
|
|
DELETE FROM relationship
|
|
WHERE
|
|
source_id = $1 AND target_id = $2
|
|
AND relationship_type = $3
|
|
",
|
|
&[&source_id, &target_id, &RelationshipType::Subscription],
|
|
)
|
|
.await?;
|
|
if deleted_count == 0 {
|
|
return Err(DatabaseError::NotFound("relationship"));
|
|
};
|
|
update_subscriber_count(&transaction, target_id, -1).await?;
|
|
transaction.commit().await?;
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn get_subscribers(
|
|
db_client: &impl DatabaseClient,
|
|
profile_id: &Uuid,
|
|
) -> Result<Vec<DbActorProfile>, DatabaseError> {
|
|
let rows = db_client
|
|
.query(
|
|
"
|
|
SELECT actor_profile
|
|
FROM actor_profile
|
|
JOIN relationship
|
|
ON (actor_profile.id = relationship.source_id)
|
|
WHERE
|
|
relationship.target_id = $1
|
|
AND relationship.relationship_type = $2
|
|
ORDER BY relationship.id DESC
|
|
",
|
|
&[&profile_id, &RelationshipType::Subscription],
|
|
)
|
|
.await?;
|
|
let profiles = rows
|
|
.iter()
|
|
.map(|row| row.try_get("actor_profile"))
|
|
.collect::<Result<_, _>>()?;
|
|
Ok(profiles)
|
|
}
|
|
|
|
pub async fn hide_reposts(
|
|
db_client: &impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
) -> Result<(), DatabaseError> {
|
|
db_client
|
|
.execute(
|
|
"
|
|
INSERT INTO relationship (source_id, target_id, relationship_type)
|
|
VALUES ($1, $2, $3)
|
|
ON CONFLICT (source_id, target_id, relationship_type) DO NOTHING
|
|
",
|
|
&[&source_id, &target_id, &RelationshipType::HideReposts],
|
|
)
|
|
.await?;
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn show_reposts(
|
|
db_client: &impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
) -> Result<(), DatabaseError> {
|
|
// Does not return NotFound error
|
|
db_client
|
|
.execute(
|
|
"
|
|
DELETE FROM relationship
|
|
WHERE
|
|
source_id = $1 AND target_id = $2
|
|
AND relationship_type = $3
|
|
",
|
|
&[&source_id, &target_id, &RelationshipType::HideReposts],
|
|
)
|
|
.await?;
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn hide_replies(
|
|
db_client: &impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
) -> Result<(), DatabaseError> {
|
|
db_client
|
|
.execute(
|
|
"
|
|
INSERT INTO relationship (source_id, target_id, relationship_type)
|
|
VALUES ($1, $2, $3)
|
|
ON CONFLICT (source_id, target_id, relationship_type) DO NOTHING
|
|
",
|
|
&[&source_id, &target_id, &RelationshipType::HideReplies],
|
|
)
|
|
.await?;
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn show_replies(
|
|
db_client: &impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
) -> Result<(), DatabaseError> {
|
|
// Does not return NotFound error
|
|
db_client
|
|
.execute(
|
|
"
|
|
DELETE FROM relationship
|
|
WHERE
|
|
source_id = $1 AND target_id = $2
|
|
AND relationship_type = $3
|
|
",
|
|
&[&source_id, &target_id, &RelationshipType::HideReplies],
|
|
)
|
|
.await?;
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn mute_posts(
|
|
db_client: &impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
) -> Result<(), DatabaseError> {
|
|
db_client
|
|
.execute(
|
|
"
|
|
INSERT INTO relationship (source_id, target_id, relationship_type)
|
|
VALUES ($1, $2, $3)
|
|
ON CONFLICT (source_id, target_id, relationship_type) DO NOTHING
|
|
",
|
|
&[&source_id, &target_id, &RelationshipType::Mute],
|
|
)
|
|
.await?;
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn unmute_posts(
|
|
db_client: &impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
) -> Result<(), DatabaseError> {
|
|
// Does not return NotFound error
|
|
db_client
|
|
.execute(
|
|
"
|
|
DELETE FROM relationship
|
|
WHERE
|
|
source_id = $1 AND target_id = $2
|
|
AND relationship_type = $3
|
|
",
|
|
&[&source_id, &target_id, &RelationshipType::Mute],
|
|
)
|
|
.await?;
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn is_muted(
|
|
db_client: &impl DatabaseClient,
|
|
source_id: &Uuid,
|
|
target_id: &Uuid,
|
|
) -> Result<bool, DatabaseError> {
|
|
let rows = db_client
|
|
.query(
|
|
"
|
|
SELECT 1
|
|
FROM relationship
|
|
WHERE
|
|
source_id = $1 AND target_id = $2
|
|
AND relationship_type = $3
|
|
",
|
|
&[&source_id, &target_id, &RelationshipType::Mute],
|
|
)
|
|
.await?;
|
|
Ok(rows.len() > 0)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::database::{test_utils::create_test_database, DatabaseError};
|
|
use crate::profiles::{
|
|
queries::create_profile,
|
|
types::{DbActor, ProfileCreateData},
|
|
};
|
|
use crate::users::{queries::create_user, types::UserCreateData};
|
|
use serial_test::serial;
|
|
|
|
#[tokio::test]
|
|
#[serial]
|
|
async fn test_follow_remote_profile() {
|
|
let db_client = &mut create_test_database().await;
|
|
let source_data = UserCreateData {
|
|
username: "test".to_string(),
|
|
password_hash: Some("test".to_string()),
|
|
..Default::default()
|
|
};
|
|
let source = create_user(db_client, source_data).await.unwrap();
|
|
let target_actor_id = "https://example.org/users/1";
|
|
let target_data = ProfileCreateData {
|
|
username: "followed".to_string(),
|
|
hostname: Some("example.org".to_string()),
|
|
actor_json: Some(DbActor {
|
|
id: target_actor_id.to_string(),
|
|
..Default::default()
|
|
}),
|
|
..Default::default()
|
|
};
|
|
let target = create_profile(db_client, target_data).await.unwrap();
|
|
// Create follow request
|
|
let follow_request = create_follow_request(db_client, &source.id, &target.id)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(follow_request.source_id, source.id);
|
|
assert_eq!(follow_request.target_id, target.id);
|
|
assert_eq!(follow_request.activity_id, None);
|
|
assert_eq!(follow_request.request_status, FollowRequestStatus::Pending);
|
|
let following = get_following(db_client, &source.id).await.unwrap();
|
|
assert!(following.is_empty());
|
|
// Accept follow request
|
|
follow_request_accepted(db_client, &follow_request.id)
|
|
.await
|
|
.unwrap();
|
|
let follow_request = get_follow_request_by_id(db_client, &follow_request.id)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(follow_request.request_status, FollowRequestStatus::Accepted);
|
|
let following = get_following(db_client, &source.id).await.unwrap();
|
|
assert_eq!(following[0].id, target.id);
|
|
let target_has_followers = has_local_followers(db_client, target_actor_id)
|
|
.await
|
|
.unwrap();
|
|
assert!(target_has_followers);
|
|
|
|
// Unfollow
|
|
let follow_request_id = unfollow(db_client, &source.id, &target.id)
|
|
.await
|
|
.unwrap()
|
|
.unwrap();
|
|
assert_eq!(follow_request_id, follow_request.id);
|
|
let follow_request_result = get_follow_request_by_id(db_client, &follow_request_id).await;
|
|
assert!(matches!(
|
|
follow_request_result,
|
|
Err(DatabaseError::NotFound("follow request")),
|
|
));
|
|
let following = get_following(db_client, &source.id).await.unwrap();
|
|
assert!(following.is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
#[serial]
|
|
async fn test_followed_by_remote_profile() {
|
|
let db_client = &mut create_test_database().await;
|
|
let source_data = ProfileCreateData {
|
|
username: "follower".to_string(),
|
|
hostname: Some("example.org".to_string()),
|
|
actor_json: Some(DbActor::default()),
|
|
..Default::default()
|
|
};
|
|
let source = create_profile(db_client, source_data).await.unwrap();
|
|
let target_data = UserCreateData {
|
|
username: "test".to_string(),
|
|
password_hash: Some("test".to_string()),
|
|
..Default::default()
|
|
};
|
|
let target = create_user(db_client, target_data).await.unwrap();
|
|
// Create follow request
|
|
let activity_id = "https://example.org/objects/123";
|
|
let _follow_request =
|
|
create_remote_follow_request_opt(db_client, &source.id, &target.id, activity_id)
|
|
.await
|
|
.unwrap();
|
|
// Repeat
|
|
let follow_request =
|
|
create_remote_follow_request_opt(db_client, &source.id, &target.id, activity_id)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(follow_request.source_id, source.id);
|
|
assert_eq!(follow_request.target_id, target.id);
|
|
assert_eq!(follow_request.activity_id, Some(activity_id.to_string()));
|
|
assert_eq!(follow_request.request_status, FollowRequestStatus::Pending);
|
|
// Accept follow request
|
|
follow_request_accepted(db_client, &follow_request.id)
|
|
.await
|
|
.unwrap();
|
|
let follow_request = get_follow_request_by_id(db_client, &follow_request.id)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(follow_request.request_status, FollowRequestStatus::Accepted);
|
|
}
|
|
}
|