format files

src/activities/create_post.rs

@@ -1,8 +1,18 @@
 use crate::{
-    database::StateHandle, entities::{self, post, prelude, user}, error::Error, objects::{
+    database::StateHandle,
+    entities::{self, post, prelude, user},
+    error::Error,
+    objects::{
         person::DbUser,
         post::{DbPost, Note},
-    }, utils::{base_url_encode, generate_create_id, generate_random_object_id}, versia::{conversion::{versia_post_from_db, versia_user_from_db}, objects::SortAlphabetically, superx::request_client}, API_DOMAIN, AUTH, DB
+    },
+    utils::{base_url_encode, generate_create_id, generate_random_object_id},
+    versia::{
+        conversion::{versia_post_from_db, versia_user_from_db},
+        objects::SortAlphabetically,
+        superx::request_client,
+    },
+    API_DOMAIN, AUTH, DB,
 };
 use activitypub_federation::{
     activity_sending::SendActivityTask,
@@ -75,13 +85,9 @@ impl CreatePost {
             id: generate_create_id(data.domain(), &db_entry.id, &encoded_url)?,
         };
         let create_with_context = WithContext::new_default(create);
-        let sends = SendActivityTask::prepare(
+        let sends =
-            &create_with_context,
+            SendActivityTask::prepare(&create_with_context, &data.local_user().await?, inbox, data)
-            &data.local_user().await?,
+                .await?;
-            inbox,
-            data,
-        )
-        .await?;
         for send in sends {
             send.sign_and_send(data).await?;
         }
@@ -130,9 +136,9 @@ async fn federate_inbox(note: crate::entities::post::Model) -> anyhow::Result<()
     let db = DB.get().unwrap();
 
     let list_model = entities::prelude::FollowRelation::find()
-            .filter(entities::follow_relation::Column::FolloweeId.eq(note.creator.to_string()))
+        .filter(entities::follow_relation::Column::FolloweeId.eq(note.creator.to_string()))
-            .all(db)
+        .all(db)
-            .await?;
+        .await?;
 
     let mut list_url = Vec::new();
 
@@ -150,9 +156,11 @@ async fn federate_inbox(note: crate::entities::post::Model) -> anyhow::Result<()
     let model = prelude::User::find()
         .filter(user::Column::Id.eq(note.creator.as_str()))
         .one(db)
-        .await?.unwrap();
+        .await?
+        .unwrap();
     for inbox in array {
-        let push = req_client.post(inbox.clone())
+        let push = req_client
+            .post(inbox.clone())
             .bearer_auth(AUTH.to_string())
             .json(&SortAlphabetically(&versia_post));
         warn!("{}", inbox.to_string());
@@ -162,7 +170,7 @@ async fn federate_inbox(note: crate::entities::post::Model) -> anyhow::Result<()
     Ok(())
 }
 
-async fn push_to_inbox(req: RequestBuilder) -> anyhow::Result<()>{
+async fn push_to_inbox(req: RequestBuilder) -> anyhow::Result<()> {
     let req_client = request_client();
     let response = req_client.execute(req.build()?).await?;
 

src/activities/follow.rs

@@ -17,8 +17,8 @@ use crate::{
         post, prelude, user,
     },
     error,
-    versia::funcs::send_follow_accept_to_versia,
     utils::{generate_follow_accept_id, generate_random_object_id},
+    versia::funcs::send_follow_accept_to_versia,
     DB,
 };
 

src/http.rs

@@ -2,12 +2,12 @@ use crate::{
     database::StateHandle,
     entities::user,
     error::Error,
+    objects::person::{DbUser, PersonAcceptedActivities},
+    utils::generate_user_id,
     versia::{
         self,
         conversion::{db_user_from_url, local_db_user_from_name, receive_versia_note},
     },
-    objects::person::{DbUser, PersonAcceptedActivities},
-    utils::generate_user_id,
     API_DOMAIN, LYSAND_DOMAIN,
 };
 use activitypub_federation::{

src/main.rs

@@ -15,9 +15,6 @@ use clap::Parser;
 use database::Database;
 use entities::post;
 use http::{http_get_user, http_post_user_inbox, webfinger};
-use versia::http::{
-    create_activity, fetch_versia_post, fetch_post, fetch_user, versia_inbox, query_post,
-};
 use objects::person::{DbUser, Person};
 use sea_orm::{ActiveModelTrait, DatabaseConnection, Set};
 use serde::{Deserialize, Serialize};
@@ -32,6 +29,9 @@ use tracing::{info, instrument::WithSubscriber};
 use url::Url;
 use utils::generate_object_id;
 use uuid::Uuid;
+use versia::http::{
+    create_activity, fetch_post, fetch_user, fetch_versia_post, query_post, versia_inbox,
+};
 
 use crate::{
     activities::create_post::CreatePost,
@@ -47,9 +47,9 @@ mod database;
 mod entities;
 mod error;
 mod http;
-mod versia;
 mod objects;
 mod utils;
+mod versia;
 
 #[derive(Debug, Serialize, Deserialize)]
 struct Response {

src/objects/person.rs

@@ -188,10 +188,7 @@ impl Object for user::Model {
         Ok(())
     }
 
-    async fn from_json(
+    async fn from_json(json: Self::Kind, data: &Data<Self::DataType>) -> Result<Self, Self::Error> {
-        json: Self::Kind,
-        data: &Data<Self::DataType>,
-    ) -> Result<Self, Self::Error> {
         let query = User::find()
             .filter(user::Column::Url.eq(json.id.inner().as_str()))
             .one(data.database_connection.as_ref())

src/objects/post.rs

@@ -1,5 +1,11 @@
 use crate::{
-    activities::create_post::CreatePost, database::StateHandle, entities::{prelude::Post, user, post}, error::Error, objects::person::DbUser, utils::generate_object_id, versia::conversion::db_user_from_url
+    activities::create_post::CreatePost,
+    database::StateHandle,
+    entities::{post, prelude::Post, user},
+    error::Error,
+    objects::person::DbUser,
+    utils::generate_object_id,
+    versia::conversion::db_user_from_url,
 };
 use activitypub_federation::{
     config::Data,

src/versia/conversion.rs

@@ -146,10 +146,12 @@ pub async fn versia_user_from_db(
     } else {
         inbox_url = Url::parse(&("https://".to_string() + &API_DOMAIN + "/apbridge/versia/inbox"))?;
         followers_url = Url::parse(
-            ("https://".to_string() + &API_DOMAIN + "/apbridge/versia/followers/" + &user.id).as_str(),
+            ("https://".to_string() + &API_DOMAIN + "/apbridge/versia/followers/" + &user.id)
+                .as_str(),
         )?;
         following_url = Url::parse(
-            ("https://".to_string() + &API_DOMAIN + "/apbridge/versia/following/" + &user.id).as_str(),
+            ("https://".to_string() + &API_DOMAIN + "/apbridge/versia/following/" + &user.id)
+                .as_str(),
         )?;
     }
 
@@ -489,9 +491,9 @@ pub async fn receive_versia_note(
     db_id: String,
 ) -> anyhow::Result<entities::post::Model> {
     let post_res: Option<post::Model> = prelude::Post::find()
-    .filter(entities::post::Column::Id.eq(note.id.to_string()))
+        .filter(entities::post::Column::Id.eq(note.id.to_string()))
-    .one(DB.get().unwrap())
+        .one(DB.get().unwrap())
-    .await?;
+        .await?;
 
     if let Some(post) = post_res {
         return Ok(post);
@@ -522,10 +524,18 @@ pub async fn receive_versia_note(
                     kind: Default::default(),
                 });
                 continue;
-            } else if !(l_tag.clone().to_string().contains(LYSAND_DOMAIN.as_str()) || l_tag.clone().to_string().contains(domain)) {
+            } else if !(l_tag.clone().to_string().contains(LYSAND_DOMAIN.as_str())
-                println!("{}", l_tag.clone().to_string().contains(LYSAND_DOMAIN.as_str()) );
+                || l_tag.clone().to_string().contains(domain))
+            {
+                println!(
+                    "{}",
+                    l_tag.clone().to_string().contains(LYSAND_DOMAIN.as_str())
+                );
                 println!("{}", l_tag.clone().to_string().contains(domain));
-                println!("-------------- {} -----------------a", l_tag.clone().to_string());
+                println!(
+                    "-------------- {} -----------------a",
+                    l_tag.clone().to_string()
+                );
                 tag.push(Mention {
                     href: l_tag,
                     kind: Default::default(),
@@ -534,10 +544,8 @@ pub async fn receive_versia_note(
             }
             println!("+++++++ --------- ++++++++++");
             let user = db_user_from_url(l_tag).await?;
-            let ap_url = Url::parse(&format!(
+            let ap_url =
-                "https://{}/apbridge/user/{}",
+                Url::parse(&format!("https://{}/apbridge/user/{}", domain, user.id).to_string())?;
-                domain, user.id
-            ).to_string())?;
             tag.push(Mention {
                 href: ap_url,
                 kind: Default::default(),
@@ -618,12 +626,11 @@ pub async fn receive_versia_note(
             to,
             tag,
             attributed_to: {
-            let user = db_user_from_url(Url::parse(user.uri.clone().as_str()).unwrap()).await?;
+                let user = db_user_from_url(Url::parse(user.uri.clone().as_str()).unwrap()).await?;
-            let ap_url = Url::parse(&format!(
+                let ap_url = Url::parse(
-                "https://{}/apbridge/user/{}",
+                    &format!("https://{}/apbridge/user/{}", domain, user.id).to_string(),
-                domain, user.id
+                )?;
-            ).to_string())?;
+                ap_url.into()
-            ap_url.into()
             },
             content: option_content_format_text(note.content)
                 .await

src/versia/http.rs

@@ -16,12 +16,12 @@ use crate::{
         prelude, user,
     },
     error,
+    objects::{self, person::Person},
+    utils::{base_url_decode, generate_create_id, generate_user_id},
     versia::{
         conversion::{versia_post_from_db, versia_user_from_db},
         inbox::inbox_entry,
     },
-    objects::{self, person::Person},
-    utils::{base_url_decode, generate_create_id, generate_user_id},
     Response, API_DOMAIN, DB, FEDERATION_CONFIG,
 };
 

src/versia/inbox.rs

@@ -1,9 +1,13 @@
 use crate::{
-    activities::{create_post::CreatePost, follow::Follow}, entities::{
+    activities::{create_post::CreatePost, follow::Follow},
+    entities::{
         self, follow_relation,
         prelude::{self, FollowRelation},
         user,
-    }, utils::generate_follow_req_id, versia::http::main_versia_url_to_user_and_model, API_DOMAIN, DB, FEDERATION_CONFIG
+    },
+    utils::generate_follow_req_id,
+    versia::http::main_versia_url_to_user_and_model,
+    API_DOMAIN, DB, FEDERATION_CONFIG,
 };
 use activitypub_federation::{
     activity_sending::SendActivityTask, fetch::object_id::ObjectId, protocol::context::WithContext,
@@ -153,7 +157,10 @@ async fn get_inbox_vec(ap_note: &crate::objects::post::Note) -> Vec<Url> {
     let mut inbox: Vec<Url> = Vec::new();
 
     let entry = ap_note.to.get(0).unwrap();
-    if entry.to_string().eq_ignore_ascii_case(public().to_string().as_str()) {
+    if entry
+        .to_string()
+        .eq_ignore_ascii_case(public().to_string().as_str())
+    {
         let (_, mentions) = ap_note.to.split_at(2);
         inbox_users.append(&mut mentions.to_vec());
     } else {
@@ -163,13 +170,14 @@ async fn get_inbox_vec(ap_note: &crate::objects::post::Note) -> Vec<Url> {
 
     inbox_users.dedup();
 
-
     let conf = FEDERATION_CONFIG.get().unwrap();
     let data = &conf.to_request_data();
 
     for user in inbox_users {
-        let ap_user = ObjectId::<user::Model>::from(user).dereference(data)
+        let ap_user = ObjectId::<user::Model>::from(user)
-        .await.unwrap();
+            .dereference(data)
+            .await
+            .unwrap();
         inbox.push(Url::parse(&ap_user.inbox).unwrap());
     }
 

src/versia/objects.rs

@@ -266,12 +266,12 @@ pub struct UserCollections {
     pub following: Url,
     #[serde(
         skip_serializing_if = "Option::is_none",
-        rename="pub.versia:likes/Likes"
+        rename = "pub.versia:likes/Likes"
     )]
     pub likes: Option<Url>,
     #[serde(
         skip_serializing_if = "Option::is_none",
-        rename="pub.versia:likes/Dislikes"
+        rename = "pub.versia:likes/Dislikes"
     )]
     pub dislikes: Option<Url>,
 }

src/versia/superx.rs

@@ -15,9 +15,7 @@ pub async fn deserialize_versia_type(data: String) -> anyhow::Result<String> {
     Ok(versia_type)
 }
 
-pub async fn serialize_versia_type(
+pub async fn serialize_versia_type(versia_type: String) -> anyhow::Result<String> {
-    versia_type: String,
-) -> anyhow::Result<String> {
     let data = serde_json::to_string(&versia_type)?;
     Ok(data)
 }

src/versia/test.rs

@@ -13,7 +13,11 @@ async fn test_user_serial() {
     let user = super::superx::deserialize_user(response.text().await.unwrap())
         .await
         .unwrap();
-    let response_outbox = client.get(user.collections.outbox.as_str()).send().await.unwrap();
+    let response_outbox = client
+        .get(user.collections.outbox.as_str())
+        .send()
+        .await
+        .unwrap();
     let outbox = super::superx::deserialize_outbox(response_outbox.text().await.unwrap())
         .await
         .unwrap();