panda 0.5.3

An async Rust library for Discord
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

// commands
mod identify;
use identify::{Identify, IdentifyContent, IdentifyProperties};

mod heartbeat;
use heartbeat::Heartbeat;

mod resume;
use resume::{Resume, ResumeContent};

mod status_update;
use status_update::StatusUpdatePayload;

use super::payload::{Opcode, Payload};
use crate::models::user;

use async_tungstenite::tungstenite::Message as TungsteniteMessage;
use std::env::consts::OS;

#[allow(dead_code)] // TODO: Add support for Voice
#[derive(Debug, PartialEq)]
pub(crate) enum Command {
    Identify(Identify),
    Resume(Resume),
    Heartbeat(Heartbeat),
    RequestGuildMembers(Payload),
    UpdateVoiceState(Payload),
    StatusUpdate(StatusUpdatePayload),
    Close,
}

impl Command {
    /// This function transform a command into a TungsteniteMessage and needs the last
    /// gateway sequence in order to send it correctly
    pub(crate) fn to_tungstenite_message(self, sequence: Option<u64>) -> TungsteniteMessage {
        match self {
            Self::Identify(mut i) => {
                i.s = sequence;
                let cmd_str = serde_json::to_string(&i).unwrap();
                TungsteniteMessage::Text(cmd_str)
            }
            Self::Heartbeat(mut h) => {
                h.d = sequence;
                let cmd_str = serde_json::to_string(&h).unwrap();
                TungsteniteMessage::Text(cmd_str)
            }
            Self::Resume(r) => {
                let cmd_str = serde_json::to_string(&r).unwrap();
                TungsteniteMessage::Text(cmd_str)
            }
            Self::StatusUpdate(p) => {
                let cmd_str = serde_json::to_string(&p).unwrap();
                TungsteniteMessage::Text(cmd_str)
            }
            _ => todo!(),
        }
    }

    /// Returns a Identify Command
    pub(crate) fn new_identify(
        token: impl Into<String>,
        large_threshold: u8,
        guild_subscriptions: bool,
        shard: [u64; 2],
    ) -> Command {
        let identify_properties = IdentifyProperties {
            os: OS,
            browser: "discord".into(),
            device: "discord".into(),
        };

        let identify = Identify {
            op: Opcode::Identify,
            d: IdentifyContent {
                token: token.into(),
                properties: identify_properties,
                compress: true,
                large_threshold: Some(large_threshold),
                shard: Some(shard),
                presence: None,
                guild_subscriptions: Some(guild_subscriptions),
            },
            s: None,
        };

        Command::Identify(identify)
    }

    /// Returns a Heartbeat(without sequence) command
    pub(crate) fn new_heartbeat() -> Command {
        Command::Heartbeat(Heartbeat {
            op: Opcode::Heartbeat,
            d: None,
        })
    }

    /// Returns a Resume command
    pub(crate) fn new_resume(token: String, session_id: String, seq: Option<u64>) -> Command {
        let resume_content = ResumeContent { token, session_id, seq };

        let resume = Resume {
            op: Opcode::Resume,
            d: resume_content,
        };

        Command::Resume(resume)
    }

    pub(crate) fn new_status_update(status_update: user::StatusUpdate) -> Command {
        let status_update = StatusUpdatePayload {
            op: Opcode::StatusUpdate,
            d: status_update,
        };

        Command::StatusUpdate(status_update)
    }
}