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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use crate::db::runner::DbRunner;
use crate::helper::get_instrument_as_id_from_uuid;
use crate::schema::mls_group_conversations;
use anyhow::Result;
use chrono::{DateTime, Utc};
use diesel::prelude::*;
use diesel::Insertable;
use diesel::{AsChangeset, Identifiable, Queryable};
use jdt_activity_pub::{ApInstrument, ApInstrumentType};
use serde::{Deserialize, Serialize};

#[derive(Identifiable, Queryable, AsChangeset, Serialize, Clone, Default, Debug)]
#[diesel(table_name = mls_group_conversations)]
pub struct MlsGroupConversation {
    #[serde(skip_serializing)]
    pub id: i32,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub uuid: String,
    pub actor_id: i32,
    pub conversation: String,
    pub mls_group: String,
}

#[derive(Serialize, Deserialize, Insertable, Default, Debug, Clone)]
#[diesel(table_name = mls_group_conversations)]
pub struct NewMlsGroupConversation {
    pub uuid: String,
    pub actor_id: i32,
    pub conversation: String,
    pub mls_group: String,
}

impl From<MlsGroupConversation> for ApInstrument {
    fn from(mgc: MlsGroupConversation) -> Self {
        Self {
            kind: ApInstrumentType::MlsGroupId,
            id: Some(get_instrument_as_id_from_uuid(mgc.uuid.clone())),
            content: Some(mgc.mls_group),
            uuid: None,
            hash: None,
            name: None,
            url: None,
            mutation_of: None,
            conversation: Some(mgc.conversation),
            activity: None,
        }
    }
}

// profile_id, mls_group, conversation
type GroupTuple = (i32, String, String);

impl From<GroupTuple> for NewMlsGroupConversation {
    fn from((actor_id, mls_group, conversation): GroupTuple) -> NewMlsGroupConversation {
        NewMlsGroupConversation {
            actor_id,
            uuid: uuid::Uuid::new_v4().to_string(),
            conversation,
            mls_group,
        }
    }
}

pub async fn create_mls_group_conversation<C: DbRunner>(
    conn: &C,
    mls_group_conversation: NewMlsGroupConversation,
) -> Result<MlsGroupConversation> {
    conn.run(move |c| {
        diesel::insert_into(mls_group_conversations::table)
            .values(&mls_group_conversation)
            .get_result::<MlsGroupConversation>(c)
    })
    .await
    .map_err(anyhow::Error::msg)
}

pub async fn get_mls_group_conversations_by_actor_id<C: DbRunner>(
    conn: &C,
    id: i32,
    limit: i64,
    offset: i64,
) -> Vec<MlsGroupConversation> {
    conn.run(move |c| {
        let query = mls_group_conversations::table
            .filter(mls_group_conversations::actor_id.eq(id))
            .order(mls_group_conversations::created_at.asc())
            .limit(limit)
            .offset(offset)
            .into_boxed();

        query.get_results::<MlsGroupConversation>(c)
    })
    .await
    .unwrap_or(vec![])
}

pub async fn get_mls_group_conversation_by_conversation_and_actor_id<C: DbRunner>(
    conn: &C,
    conversation: String,
    actor_id: i32,
) -> Result<i64> {
    conn.run(move |c| {
        mls_group_conversations::table
            .filter(
                mls_group_conversations::conversation
                    .eq(conversation)
                    .and(mls_group_conversations::actor_id.eq(actor_id)),
            )
            .count()
            .get_result(c)
    })
    .await
    .map_err(anyhow::Error::msg)
}