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

use stoat_models::v0::{
    BulkMessageResponse, Member, Message, MessageSort, OptionsQueryMessages, User,
};

use crate::{HttpClient, error::Error};

#[derive(Debug, Clone)]
pub struct MessagesWithUsers {
    pub messages: Vec<Message>,
    pub users: Vec<User>,
    pub members: Vec<Member>,
}

pub struct FetchMessagesBuilder {
    http: HttpClient,
    channel_id: String,
    data: OptionsQueryMessages,
}

impl FetchMessagesBuilder {
    pub fn new(http: HttpClient, channel_id: String) -> Self {
        Self {
            http,
            channel_id,
            data: OptionsQueryMessages {
                limit: None,
                before: None,
                after: None,
                sort: None,
                nearby: None,
                include_users: None,
            },
        }
    }

    pub fn limit(&mut self, limit: i64) -> &mut Self {
        self.data.limit = Some(limit);

        self
    }

    pub fn before(&mut self, before: String) -> &mut Self {
        self.data.before = Some(before);

        self
    }

    pub fn after(&mut self, after: String) -> &mut Self {
        self.data.after = Some(after);

        self
    }

    pub fn sort(&mut self, sort: MessageSort) -> &mut Self {
        self.data.sort = Some(sort);

        self
    }

    pub fn nearby(&mut self, nearby: String) -> &mut Self {
        self.data.nearby = Some(nearby);

        self
    }

    pub async fn build_raw(&mut self, with_users: bool) -> Result<BulkMessageResponse, Error> {
        self.data.include_users = Some(with_users);

        self.http.fetch_messages(&self.channel_id, &self.data).await
    }

    pub async fn build_with_users(&mut self) -> Result<MessagesWithUsers, Error> {
        let bulk = self.build_raw(true).await?;

        if let BulkMessageResponse::MessagesAndUsers {
            messages,
            users,
            members,
        } = bulk
        {
            Ok(MessagesWithUsers {
                messages,
                users,
                members: members.unwrap_or_default(),
            })
        } else {
            Err(Error::InternalError)
        }
    }

    pub async fn build(&mut self) -> Result<Vec<Message>, Error> {
        let bulk = self.build_raw(false).await?;

        if let BulkMessageResponse::JustMessages(messages) = bulk {
            Ok(messages)
        } else {
            Err(Error::InternalError)
        }
    }
}