twilio 1.1.0

Rust bindings for the Twilio API
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

use super::{format_xml_string, Action, Method};
use std::default::Default;

pub enum Transcribe {
    DontTranscribe,
    StoreTranscription,
    CallbackTranscription(String),
}

pub struct Record {
    pub action: Option<String>,
    pub method: Method,
    pub timeout_seconds: u32,
    pub finish_on_key: char,
    pub max_length_seconds: u32,
    pub transcribe: Transcribe,
    pub play_beep: bool,
    pub trim: bool,
}

impl Action for Record {
    fn as_twiml(&self) -> String {
        let timeout_string = format!("{}", self.timeout_seconds);
        let finish_string = self.finish_on_key.to_string();
        let length_string = format!("{}", self.max_length_seconds);
        let mut attrs = Vec::new();
        let method_str = match self.method {
            Method::Get => "GET",
            Method::Post => "POST",
        };
        attrs.push(("method", method_str));
        if let Some(ref a) = self.action {
            attrs.push(("action", a));
        }
        attrs.push(("timeout", timeout_string.as_ref()));
        attrs.push(("finishOnKey", finish_string.as_ref()));
        attrs.push(("maxLength", length_string.as_ref()));
        attrs.push(("playBeep", if self.play_beep { "true" } else { "false" }));
        attrs.push((
            "trim",
            if self.trim {
                "trim-silence"
            } else {
                "do-not-trim"
            },
        ));
        match self.transcribe {
            Transcribe::DontTranscribe => {
                attrs.push(("transcribe", "false"));
            }
            Transcribe::StoreTranscription => {
                attrs.push(("transcribe", "true"));
            }
            Transcribe::CallbackTranscription(ref s) => {
                /* transcribe=true is implied in this case */
                attrs.push(("transcribeCallback", s.as_ref()));
            }
        };
        format_xml_string("Record", &attrs, "")
    }
}

impl Default for Record {
    fn default() -> Record {
        Record {
            action: None,
            method: Method::Post,
            timeout_seconds: 5,
            finish_on_key: '*',
            max_length_seconds: 3600,
            transcribe: Transcribe::DontTranscribe,
            play_beep: true,
            trim: true,
        }
    }
}