enigmatick 0.4.1

Enigmatick is a social media platform that integrates with servers that implement the ActivityPub protocol (e.g., Mastodon)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

use crate::db::runner::DbRunner;
use crate::server::routes::Outbox;
use deadpool_diesel::postgres::Pool;
use jdt_activity_pub::{ApActivity, ApAnnounce};
use reqwest::StatusCode;

use crate::{
    models::{
        activities::{create_activity, NewActivity, TryFromExtendedActivity},
        actors::Actor,
        objects::get_object_by_as_id,
    },
    runner,
};
use jdt_activity_pub::MaybeReference;
use serde_json::Value;

use super::ActivityJson;

impl Outbox for ApAnnounce {
    async fn outbox<C: DbRunner>(
        &self,
        conn: &C,
        pool: Pool,
        profile: Actor,
        raw: Value,
    ) -> Result<ActivityJson<ApActivity>, StatusCode> {
        announce_outbox(conn, pool, self.clone(), profile, raw).await
    }
}

async fn announce_outbox<C: DbRunner>(
    conn: &C,
    pool: Pool,
    announce: ApAnnounce,
    _profile: Actor,
    raw: Value,
) -> Result<ActivityJson<ApActivity>, StatusCode> {
    if let MaybeReference::Reference(as_id) = announce.clone().object {
        let object = get_object_by_as_id(conn, as_id).await.map_err(|e| {
            log::error!("FAILED TO RETRIEVE Object: {e:#?}");
            StatusCode::NOT_FOUND
        })?;

        let mut activity = NewActivity::try_from((announce.into(), Some(object.clone().into())))
            .map_err(|e| {
                log::error!("FAILED TO BUILD Activity: {e:#?}");
                StatusCode::INTERNAL_SERVER_ERROR
            })?
            .link_actor(conn)
            .await;

        activity.raw = Some(raw);

        let activity = create_activity(conn, activity).await.map_err(|e| {
            log::error!("FAILED TO CREATE Activity: {e:#?}");
            StatusCode::INTERNAL_SERVER_ERROR
        })?;

        let ap_id = activity
            .ap_id
            .clone()
            .ok_or(StatusCode::INTERNAL_SERVER_ERROR)?;

        runner::run(runner::send_activity_task, pool, None, vec![ap_id]).await;

        let activity: ApActivity =
            ApActivity::try_from_extended_activity((activity, None, Some(object), None)).map_err(
                |e| {
                    log::error!("Failed to build ApActivity: {e:#?}");
                    StatusCode::INTERNAL_SERVER_ERROR
                },
            )?;

        Ok(ActivityJson(activity))
    } else {
        log::error!("ANNOUNCE OBJECT IS NOT A REFERENCE");
        Err(StatusCode::INTERNAL_SERVER_ERROR)
    }
}