feat: activity

5 files changed, 121 insertions, 8 deletions

diff --git a/src/server/activities.rs b/src/server/activities.rs
index 62d6fa2..5e2ad4b 100644
--- a/src/server/activities.rs
+++ b/src/server/activities.rs
@@ -1 +1,2 @@
+pub mod accept;
 pub mod follow;
diff --git a/src/server/activities/accept.rs b/src/server/activities/accept.rs
new file mode 100644
index 0000000..44f26f6
--- /dev/null
+++ b/src/server/activities/accept.rs
@@ -0,0 +1,52 @@
+use crate::{
+    entity::user::User, error::AppError, server::activities::follow::Follow, state::AppHandle,
+};
+use activitypub_federation::{
+    config::Data, fetch::object_id::ObjectId, kinds::activity::AcceptType, traits::Activity,
+};
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Accept {
+    actor: ObjectId<User>,
+    object: Follow,
+    #[serde(rename = "type")]
+    kind: AcceptType,
+    id: Url,
+}
+
+impl Accept {
+    pub fn new(actor: ObjectId<User>, object: Follow, id: Url) -> Accept {
+        Accept {
+            actor,
+            object,
+            kind: Default::default(),
+            id,
+        }
+    }
+}
+
+#[async_trait]
+impl Activity for Accept {
+    type DataType = AppHandle;
+    type Error = AppError;
+
+    fn id(&self) -> &Url {
+        &self.id
+    }
+
+    fn actor(&self) -> &Url {
+        self.actor.inner()
+    }
+
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    async fn receive(self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
diff --git a/src/server/activities/follow.rs b/src/server/activities/follow.rs
index 9148f02..466edb7 100644
--- a/src/server/activities/follow.rs
+++ b/src/server/activities/follow.rs
@@ -1,11 +1,20 @@
 use activitypub_federation::{
-    config::Data, fetch::object_id::ObjectId, kinds::activity::FollowType, traits::Activity,
+    config::Data,
+    fetch::object_id::ObjectId,
+    kinds::activity::FollowType,
+    traits::{Activity, Actor},
 };
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use url::Url;
+use uuid::Uuid;
 
-use crate::{entity::user::User, error::AppError, state::AppHandle};
+use crate::{
+    entity::user::User,
+    error::AppError,
+    server::{activities::accept::Accept, generate_object_id},
+    state::AppHandle,
+};
 
 #[derive(Deserialize, Serialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
@@ -39,20 +48,20 @@ impl Activity for Follow {
 
     #[doc = " `id` field of the activity"]
     fn id(&self) -> &Url {
-        todo!()
+        &self.id
     }
 
     #[doc = " `actor` field of activity"]
     fn actor(&self) -> &Url {
-        todo!()
+        self.actor.inner()
     }
 
     #[doc = " Verifies that the received activity is valid."]
     #[doc = ""]
     #[doc = " This needs to be a separate method, because it might be used for activities"]
     #[doc = " like `Undo/Follow`, which shouldn\'t perform any database write for the inner `Follow`."]
-    async fn verify(&self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
-        todo!()
+    async fn verify(&self, _data: &Data<Self::DataType>) -> Result<(), Self::Error> {
+        Ok(())
     }
 
     #[doc = " Called when an activity is received."]
@@ -60,6 +69,23 @@ impl Activity for Follow {
     #[doc = " Should perform validation and possibly write action to the database. In case the activity"]
     #[doc = " has a nested `object` field, must call `object.from_json` handler."]
     async fn receive(self, data: &Data<Self::DataType>) -> Result<(), Self::Error> {
-        todo!()
+        let id = Uuid::now_v7();
+
+        sqlx::query!("insert into following (id, follower, followee) values ($1, $2, $3) on conflict (follower, followee) do nothing"
+            ,id,
+            self.actor.inner().as_str(),
+            self.object.inner().as_str(),
+            ).execute(&data.services.postgres).await?;
+
+        let follower = self.actor.dereference(data).await?;
+        let id = generate_object_id(data.domain(), data.environment)?;
+
+        let local_user = self.object.dereference(data).await?;
+        let accept = Accept::new(self.object.clone(), self, id.clone());
+
+        local_user
+            .send(accept, vec![follower.shared_inbox_or_inbox()], false, data)
+            .await?;
+        Ok(())
     }
 }
diff --git a/src/server/routes/users.rs b/src/server/routes/users.rs
index d3ce446..9c9a3bf 100644
--- a/src/server/routes/users.rs
+++ b/src/server/routes/users.rs
@@ -1,12 +1,30 @@
 pub mod get_outbox;
+pub mod post_inbox;
 pub mod get_user;
 pub mod webfinger;
 
-use axum::{Router, routing::get};
+use activitypub_federation::traits::Activity;
+use axum::{routing::{get, post}, Router};
+use serde::{Deserialize, Serialize};
+
+use crate::server::activities::{accept::Accept, follow::Follow};
+use url::Url;
+use activitypub_federation::config::Data;
+
+/// List of all activities which this actor can receive.
+#[derive(Deserialize, Serialize, Debug)]
+#[serde(untagged)]
+#[enum_delegate::implement(Activity)]
+pub enum PersonAcceptedActivities {
+    Follow(Follow),
+    Accept(Accept),
+}
+
 
 pub fn users_router() -> Router {
     Router::new()
         .route("/users/{username}", get(get_user::http_get_user))
         .route("/users/{username}/outbox", get(get_outbox::http_get_outbox))
+        .route("/users/{username}/inbox", post(post_inbox::http_post_user_inbox))
         .route("/.well-known/webfinger", get(webfinger::webfinger))
 }
diff --git a/src/server/routes/users/post_inbox.rs b/src/server/routes/users/post_inbox.rs
new file mode 100644
index 0000000..5e3258b
--- /dev/null
+++ b/src/server/routes/users/post_inbox.rs
@@ -0,0 +1,16 @@
+use activitypub_federation::{axum::inbox::{receive_activity, ActivityData}, config::Data, protocol::context::WithContext};
+use axum::response::IntoResponse;
+
+use crate::{entity::user::User, server::routes::users::PersonAcceptedActivities, state::AppHandle};
+
+pub async fn http_post_user_inbox(
+    data: Data<AppHandle>,
+    activity_data: ActivityData,
+) -> impl IntoResponse {
+    receive_activity::<WithContext<PersonAcceptedActivities>, User, AppHandle>(
+        activity_data,
+        &data,
+    )
+    .await
+}
+