vk-bot 0.4.0

Build chat bots for VK (VKontakte) communities easily.
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
123
124
125
126
127
128

//! Structs for storing response information.

use crate::keyboard::Keyboard;
use std::fmt::{Display, Error, Formatter};

/// Manages the bot's current response to a message/event.
#[derive(Debug)]
pub struct Response {
    message: String,
    attachments: Vec<AttachmentInformation>,
    keyboard: Option<Keyboard>,
}

impl Default for Response {
    fn default() -> Self {
        Self {
            message: String::new(),
            attachments: Vec::new(),
            keyboard: None,
        }
    }
}

impl Response {
    /// Creates a new [`Response`].
    pub fn new() -> Self {
        Default::default()
    }

    /// Returns the attachments of this response.
    pub fn attachments(&self) -> &Vec<AttachmentInformation> {
        &self.attachments
    }

    /// Attaches another attachment to the response.
    pub fn attach(&mut self, info: AttachmentInformation) {
        self.attachments.push(info);
    }

    /// Returns the message of this response.
    pub fn message(&self) -> &String {
        &self.message
    }

    /// Sets a new message text for the response.
    pub fn set_message(&mut self, msg: &str) {
        self.message = msg.into();
    }

    /// Returns the keyboard of this response, if present.
    pub fn keyboard(&self) -> &Option<Keyboard> {
        &self.keyboard
    }

    /// Sets a new keyboard for the response.
    pub fn set_keyboard(&mut self, kbd: Keyboard) {
        self.keyboard = Some(kbd);
    }

    /// Sets an empty keyboard for the response, which will remove the keyboard
    /// on the user side once this response is sent.
    pub fn set_keyboard_empty(&mut self) {
        self.keyboard = Some(Default::default());
    }
}

/// Essentially an attachment's unique ID, possibly with an access key.
#[derive(Debug)]
pub struct AttachmentInformation {
    r#type: String,
    owner_id: i64,
    resource_id: i64,
    access_key: Option<String>,
}

impl Display for AttachmentInformation {
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
        f.write_str(&format!(
            "{}{}_{}{}",
            self.r#type,
            self.owner_id,
            self.resource_id,
            match &self.access_key {
                Some(key) => format!("_{}", key),
                None => "".into(),
            }
        ))
    }
}

impl From<(String, i64, i64)> for AttachmentInformation {
    fn from((r#type, owner_id, resource_id): (String, i64, i64)) -> Self {
        Self {
            r#type,
            owner_id,
            resource_id,
            access_key: None,
        }
    }
}

impl From<(String, i64, i64, String)> for AttachmentInformation {
    fn from((r#type, owner_id, resource_id, access_key): (String, i64, i64, String)) -> Self {
        Self {
            r#type,
            owner_id,
            resource_id,
            access_key: Some(access_key),
        }
    }
}

impl AttachmentInformation {
    /// Creates a new [`AttachmentInformation`].
    pub fn new(
        r#type: String,
        owner_id: i64,
        resource_id: i64,
        access_key: Option<String>,
    ) -> Self {
        Self {
            r#type,
            owner_id,
            resource_id,
            access_key,
        }
    }
}