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

use stoat_database::iso8601_timestamp::Timestamp;
use stoat_models::v0::{DataMemberEdit, FieldsMember, Member};

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

pub struct EditMemberBuilder {
    http: HttpClient,
    server_id: String,
    member_id: String,
    data: DataMemberEdit,
}

impl EditMemberBuilder {
    pub fn new(http: HttpClient, server_id: String, member_id: String) -> Self {
        Self {
            http,
            server_id,
            member_id,
            data: DataMemberEdit {
                nickname: None,
                avatar: None,
                roles: None,
                timeout: None,
                can_publish: None,
                can_receive: None,
                voice_channel: None,
                remove: Vec::new(),
            },
        }
    }

    pub fn nickname(&mut self, nickname: Option<String>) -> &mut Self {
        if nickname.is_some() {
            self.data.nickname = nickname;
        } else {
            self.data.remove.push(FieldsMember::Nickname);
        };

        self
    }

    pub fn avatar(&mut self, avatar: Option<String>) -> &mut Self {
        if avatar.is_some() {
            self.data.avatar = avatar;
        } else {
            self.data.remove.push(FieldsMember::Avatar);
        };

        self
    }

    pub fn roles(&mut self, roles: Vec<String>) -> &mut Self {
        if !roles.is_empty() {
            self.data.roles = Some(roles);
        } else {
            self.data.remove.push(FieldsMember::Roles);
        };

        self
    }

    pub fn timeout<T: Into<Option<Timestamp>>>(&mut self, timestamp: T) -> &mut Self {
        if let Some(timestamp) = timestamp.into() {
            self.data.timeout = Some(timestamp);
        } else {
            self.data.remove.push(FieldsMember::Timeout);
        };

        self
    }

    pub fn can_publish(&mut self, can_publish: Option<bool>) -> &mut Self {
        if can_publish.is_some() {
            self.data.can_publish = can_publish;
        } else {
            self.data.remove.push(FieldsMember::CanPublish);
        };

        self
    }

    pub fn can_receive(&mut self, can_receive: Option<bool>) -> &mut Self {
        if can_receive.is_some() {
            self.data.can_receive = can_receive;
        } else {
            self.data.remove.push(FieldsMember::CanReceive);
        };

        self
    }

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

        self
    }

    pub async fn build(&self) -> Result<Member, Error> {
        self.http
            .edit_member(&self.server_id, &self.member_id, &self.data)
            .await
    }
}