versia-pub/activitypub
2
0
Fork 0
mirror of https://github.com/versia-pub/activitypub.git synced 2025-12-06 06:38:20 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

format files

Browse source
This commit is contained in:
April John 2025-02-11 14:03:32 +01:00
parent 23bd522ade
commit e5851e2c9b
12 changed files with 90 additions and 62 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
src/activities/create_post.rs
View file

@ -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(
&create_with_context,
&data.local_user().await?,
inbox,
data,
)
.await?;
let sends =
SendActivityTask::prepare(&create_with_context, &data.local_user().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()))
.all(db)
.await?;
.filter(entities::follow_relation::Column::FolloweeId.eq(note.creator.to_string()))
.all(db)
.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?;
@ -170,4 +178,4 @@ async fn push_to_inbox(req: RequestBuilder) -> anyhow::Result<()>{
info!("{:?}", response.text().await?);
Ok(())
}
}

2
src/activities/follow.rs
View file

@ -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,
};

4
src/http.rs
View file

@ -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::{

8
src/main.rs
View file

@ -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 {

5
src/objects/person.rs
View file

@ -188,10 +188,7 @@ impl Object for user::Model {
Ok(())
}
async fn from_json(
json: Self::Kind,
data: &Data<Self::DataType>,
) -> Result<Self, Self::Error> {
async fn from_json(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())

8
src/objects/post.rs
View file

@ -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,

43
src/versia/conversion.rs
View file

@ -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()))
.one(DB.get().unwrap())
.await?;
.filter(entities::post::Column::Id.eq(note.id.to_string()))
.one(DB.get().unwrap())
.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)) {
println!("{}", l_tag.clone().to_string().contains(LYSAND_DOMAIN.as_str()) );
} else if !(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!(
"https://{}/apbridge/user/{}",
domain, user.id
).to_string())?;
let ap_url =
Url::parse(&format!("https://{}/apbridge/user/{}", 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 ap_url = Url::parse(&format!(
"https://{}/apbridge/user/{}",
domain, user.id
).to_string())?;
ap_url.into()
let user = db_user_from_url(Url::parse(user.uri.clone().as_str()).unwrap()).await?;
let ap_url = Url::parse(
&format!("https://{}/apbridge/user/{}", domain, user.id).to_string(),
)?;
ap_url.into()
},
content: option_content_format_text(note.content)
.await

4
src/versia/http.rs
View file

@ -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,
};

24
src/versia/inbox.rs
View file

@ -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,
@ -138,7 +142,7 @@ async fn federate_inbox(note: super::objects::Note) -> Result<()> {
tokio::spawn(async move {
let conf = FEDERATION_CONFIG.get().unwrap();
let inbox = get_inbox_vec(&ap_note).await;
let res = CreatePost::sends(ap_note, note, inbox, &conf.to_request_data()).await;
if let Err(e) = res {
panic!("Problem federating: {e:?}");
@ -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,17 +170,18 @@ 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)
.await.unwrap();
let ap_user = ObjectId::<user::Model>::from(user)
.dereference(data)
.await
.unwrap();
inbox.push(Url::parse(&ap_user.inbox).unwrap());
}
inbox.dedup();
inbox
}
}

4
src/versia/objects.rs
View file

@ -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>,
}

4
src/versia/superx.rs
View file

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

6
src/versia/test.rs
View file

@ -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();