mayhem-db 0.2.0-beta.1

A Discord-like chat application optimized for security, stability, speed, and ultimate customization. => Database Module
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
116
117
118
119
120
121
122

use sea_orm::{DbConn, DbErr, ModelTrait};
use std::sync::Arc;

use super::common::ConnectionHolder;
use crate::{
    models::server::{channel, member, role, server},
    util::{CompleteMember, CompleteRole},
};

#[derive(Clone)]
pub struct ServerQueryHelper {
    pub client: Arc<DbConn>,
}

unsafe impl Sync for ServerQueryHelper {}
unsafe impl Send for ServerQueryHelper {}

impl ConnectionHolder for ServerQueryHelper {
    fn get_connection(&self) -> &DbConn {
        return &self.client as &DbConn;
    }

    fn get_connection_ref(&self) -> Arc<DbConn> {
        return self.client.clone();
    }

    fn get_connection_raw(&self) -> *const DbConn {
        return Arc::into_raw(self.client.clone());
    }
}

impl ServerQueryHelper {
    pub async fn find_server_roles(
        &self,
        server: &server::Model,
    ) -> Result<Vec<CompleteRole>, DbErr> {
        let mut roles: Vec<CompleteRole> = Vec::new();

        let found_roles = server
            .clone()
            .find_related(role::Entity)
            .all(&self.client as &DbConn)
            .await;

        let ok_roles: Vec<role::Model> = match found_roles {
            Ok(res) => res,
            Err(err) => return Err(err),
        };

        for role in ok_roles {
            let members = role
                .find_related(member::Entity)
                .all(&self.client as &DbConn)
                .await
                .unwrap()
                .iter()
                .map(|val| val.id)
                .collect();

            roles.push(CompleteRole {
                id: role.id,
                name: role.name,
                server_id: role.server_id,
                member_ids: members,
            });
        }

        return Ok(roles);
    }

    pub async fn find_server_members(
        &self,
        server: &server::Model,
    ) -> Result<Vec<CompleteMember>, DbErr> {
        let mut members: Vec<CompleteMember> = Vec::new();

        let members_found = server
            .clone()
            .find_related(member::Entity)
            .all(&self.client as &DbConn)
            .await;

        let ok_members: Vec<member::Model> = match members_found {
            Ok(res) => res,
            Err(err) => return Err(err),
        };

        for member in ok_members {
            let roles_local = member
                .find_related(role::Entity)
                .all(&self.client as &DbConn)
                .await
                .unwrap()
                .iter()
                .map(|val| val.id)
                .collect();

            members.push(CompleteMember {
                id: member.id,
                name: member.name,
                nick: member.nick,
                server_id: member.server_id,
                role_ids: roles_local,
            });
        }

        return Ok(members);
    }

    pub async fn find_server_channels(
        &self,
        server: &server::Model,
    ) -> Result<Vec<channel::Model>, DbErr> {
        let channels = server
            .clone()
            .find_related(channel::Entity)
            .all(&self.client as &DbConn)
            .await;

        return channels;
    }
}