stoat-rs 0.2.5

Stoat API Wrapper
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

use async_trait::async_trait;
use bytes::Bytes;
use stoat_models::v0::{
    DataEditUser, FlagResponse, MutualResponse, User, UserProfile, UserVoiceState,
};

use crate::{FileExt, GlobalCache, HttpClient, Identifiable, Result, builders::SendMessageBuilder};

#[async_trait]
pub trait UserExt: Identifiable {
    fn mention(&self) -> String;
    fn name(&self) -> &str;

    fn voice(&self, cache: impl AsRef<GlobalCache>) -> Vec<(String, UserVoiceState)>;

    async fn send(&self, http: impl AsRef<HttpClient> + Send) -> Result<SendMessageBuilder>;
    async fn edit(
        &mut self,
        http: impl AsRef<HttpClient> + Send,
        data: &DataEditUser,
    ) -> Result<()>;
    async fn fetch_profile(&self, http: impl AsRef<HttpClient> + Send) -> Result<UserProfile>;
    async fn fetch_flags(&self, http: impl AsRef<HttpClient> + Send) -> Result<FlagResponse>;
    async fn fetch_mutuals(&self, http: impl AsRef<HttpClient> + Send) -> Result<MutualResponse>;
    async fn fetch_default_avatar(&self, http: impl AsRef<HttpClient> + Send) -> Result<Bytes>;

    fn avatar_url(&self, http: impl AsRef<HttpClient> + Send) -> String;
    fn default_avatar_url(&self, http: impl AsRef<HttpClient> + Send) -> String;
}

#[async_trait]
impl UserExt for User {
    fn mention(&self) -> String {
        format!("<@{}>", &self.id)
    }

    fn name(&self) -> &str {
        self.display_name.as_deref().unwrap_or(&self.username)
    }

    fn voice(&self, cache: impl AsRef<GlobalCache>) -> Vec<(String, UserVoiceState)> {
        let mut states = Vec::new();

        cache.as_ref().servers.iter_sync(|_, server| {
            for channel in &server.channels {
                if let Some(channel_voice_state) = cache.as_ref().voice_states.get_sync(channel) {
                    if let Some(user_voice_state) = channel_voice_state
                        .participants
                        .iter()
                        .find(|s| &s.id == &self.id)
                    {
                        states.push((channel.clone(), user_voice_state.clone()));
                    }
                }
            }

            true
        });

        states
    }

    async fn send(&self, http: impl AsRef<HttpClient> + Send) -> Result<SendMessageBuilder> {
        let dm_channel = http.as_ref().open_dm(&self.id).await?;

        Ok(SendMessageBuilder::new(
            http.as_ref().clone(),
            dm_channel.id().to_string(),
        ))
    }

    async fn edit(
        &mut self,
        http: impl AsRef<HttpClient> + Send,
        data: &DataEditUser,
    ) -> Result<()> {
        let user = http.as_ref().edit_user(&self.id, data).await?;

        *self = user;

        Ok(())
    }

    async fn fetch_profile(&self, http: impl AsRef<HttpClient> + Send) -> Result<UserProfile> {
        http.as_ref().fetch_user_profile(&self.id).await
    }

    async fn fetch_flags(&self, http: impl AsRef<HttpClient> + Send) -> Result<FlagResponse> {
        http.as_ref().fetch_user_flags(&self.id).await
    }

    async fn fetch_mutuals(&self, http: impl AsRef<HttpClient> + Send) -> Result<MutualResponse> {
        http.as_ref().fetch_user_mutuals(&self.id).await
    }

    async fn fetch_default_avatar(&self, http: impl AsRef<HttpClient> + Send) -> Result<Bytes> {
        http.as_ref().fetch_default_avatar(&self.id).await
    }

    fn avatar_url(&self, http: impl AsRef<HttpClient> + Send) -> String {
        self.avatar
            .as_ref()
            .map(|file| file.url(http.as_ref(), false))
            .unwrap_or_else(|| self.default_avatar_url(http.as_ref()))
    }

    fn default_avatar_url(&self, http: impl AsRef<HttpClient> + Send) -> String {
        format!("{}/users/{}/default_avatar", &http.as_ref().base, &self.id)
    }
}

impl Identifiable for User {
    fn id(&self) -> &str {
        &self.id
    }
}