111 lines
3.8 KiB
Rust
111 lines
3.8 KiB
Rust
use kuska_ssb::api::dto::content::{FriendsHops, RelationshipQuery};
|
|
|
|
use crate::{error::GolgiError, messages::SsbMessageContent, sbot::sbot_connection::Sbot, utils};
|
|
|
|
impl Sbot {
|
|
/// Convenience method to set a relationship with following: true, blocking: false.
|
|
pub async fn follow(&mut self, contact: &str) -> Result<String, GolgiError> {
|
|
self.set_relationship(contact, true, false).await
|
|
}
|
|
|
|
/// Convenience method to set a relationship with following: false, blocking: true.
|
|
pub async fn block(&mut self, contact: &str) -> Result<String, GolgiError> {
|
|
self.set_relationship(contact, false, true).await
|
|
}
|
|
|
|
/// Publishes a contact relationship to the given user (with ssb_id) with the given state.
|
|
pub async fn set_relationship(
|
|
&mut self,
|
|
contact: &str,
|
|
following: bool,
|
|
blocking: bool,
|
|
) -> Result<String, GolgiError> {
|
|
let msg = SsbMessageContent::Contact {
|
|
contact: Some(contact.to_string()),
|
|
following: Some(following),
|
|
blocking: Some(blocking),
|
|
autofollow: None,
|
|
};
|
|
self.publish(msg).await
|
|
}
|
|
|
|
/// Call the `friends isFollowing` RPC method and return a message reference.
|
|
/// Returns true if src_id is following dest_id and false otherwise.
|
|
pub async fn friends_is_following(
|
|
&mut self,
|
|
args: RelationshipQuery,
|
|
) -> Result<String, GolgiError> {
|
|
let mut sbot_connection = self.get_sbot_connection().await?;
|
|
let req_id = sbot_connection
|
|
.client
|
|
.friends_is_following_req_send(args)
|
|
.await?;
|
|
|
|
utils::get_async(
|
|
&mut sbot_connection.rpc_reader,
|
|
req_id,
|
|
utils::string_res_parse,
|
|
)
|
|
.await
|
|
}
|
|
|
|
/// Call the `friends isblocking` RPC method and return a message reference.
|
|
/// Returns true if src_id is blocking dest_id and false otherwise.
|
|
pub async fn friends_is_blocking(
|
|
&mut self,
|
|
args: RelationshipQuery,
|
|
) -> Result<String, GolgiError> {
|
|
let mut sbot_connection = self.get_sbot_connection().await?;
|
|
let req_id = sbot_connection
|
|
.client
|
|
.friends_is_blocking_req_send(args)
|
|
.await?;
|
|
|
|
utils::get_async(
|
|
&mut sbot_connection.rpc_reader,
|
|
req_id,
|
|
utils::string_res_parse,
|
|
)
|
|
.await
|
|
}
|
|
|
|
/// Return a Vec<String> where each element is a peer you are following.
|
|
pub async fn get_follows(&mut self) -> Result<Vec<String>, GolgiError> {
|
|
self.friends_hops(FriendsHops {
|
|
max: 1,
|
|
start: None,
|
|
reverse: Some(false),
|
|
})
|
|
.await
|
|
}
|
|
|
|
// Gets a Vec<String> where each element is a peer who follows you
|
|
/// TODO: currently this method is not working
|
|
/// go-sbot does not seem to listen to the reverse=True parameter
|
|
/// and just returns follows
|
|
async fn _get_followers(&mut self) -> Result<Vec<String>, GolgiError> {
|
|
self.friends_hops(FriendsHops {
|
|
max: 1,
|
|
start: None,
|
|
reverse: Some(true),
|
|
})
|
|
.await
|
|
}
|
|
|
|
/// Call the `friends hops` RPC method and return a Vector<String>
|
|
/// where each element of the vector is the ssb_id of a peer.
|
|
///
|
|
/// When opts.reverse = True, it should return peers who are following you
|
|
/// (but this is currently not working)
|
|
pub async fn friends_hops(&mut self, args: FriendsHops) -> Result<Vec<String>, GolgiError> {
|
|
let mut sbot_connection = self.get_sbot_connection().await?;
|
|
let req_id = sbot_connection.client.friends_hops_req_send(args).await?;
|
|
utils::get_source_until_eof(
|
|
&mut sbot_connection.rpc_reader,
|
|
req_id,
|
|
utils::string_res_parse,
|
|
)
|
|
.await
|
|
}
|
|
}
|