Init

src/commands.rs

@@ -0,0 +1,107 @@
+use telnet::Telnet;
+use telnet::Event::Data;
+use crate::parameter::ParameterList;
+
+use crate::response::Response;
+
+fn to_single_response(resp: Response) -> Response {
+    match resp {
+        Response::DataList(list) => Response::Data(list[0].clone()),
+        _ => resp
+    }
+}
+
+fn read_part(connection: &mut Telnet) -> Result<String, String> {
+    match connection.read() {
+        Ok(event) => {
+            match event {
+                Data(bytes) => Ok(String::from_utf8(bytes.to_vec())
+                    .map_err(|_| "Teamspeak returned a badly formatted response.")?),
+                _ => {
+                    Err(String::from("Received unknown event from Teamspeak."))
+                }
+            }
+        }
+        Err(_) => {
+            Err(String::from("Failed to read from Teamspeak."))
+        }
+    }
+}
+
+fn read_response_buffer(connection: &mut Telnet, buffer: &mut String) -> Result<(String, String), String> {
+    loop {
+        buffer.push_str(&read_part(connection)?);
+        match buffer.split_once("\n\r") {
+            None => {}
+            Some((response, remaining)) => {
+                return Ok((String::from(response), String::from(remaining)));
+            }
+        }
+    }
+}
+
+fn send_command(connection: &mut Telnet, command: &str, skip_ok: bool) -> Result<Response, String> {
+    connection.write(command.as_bytes()).map_err(|_| "Failed to write to Teamspeak.")?;
+
+    read_response(connection, skip_ok, String::new())
+}
+fn read_response(connection: &mut Telnet, skip_ok: bool, mut buffer: String) -> Result<Response, String> {
+    let (response_str, buffer) = read_response_buffer(connection, &mut buffer)?;
+
+    match Response::try_from(response_str) {
+        Ok(resp) => {
+            Ok(resp)
+        }
+        Err(err) => {
+            if err.is_error_okay() {
+                if skip_ok {
+                    read_response(connection, skip_ok, buffer)
+                } else {
+                    // empty Ok response
+                    Ok(Response::Data(Vec::new()))
+                }
+            } else {
+                Err(format!("Received error response from Teamspeak: {} ({})", err.msg, err.id))
+            }
+        }
+    }
+}
+
+pub fn login(connection: &mut Telnet, apikey: &str) -> Result<Response, String> {
+    send_command(connection, &format!("auth apikey={}\n", apikey), false)
+}
+
+#[allow(dead_code)]
+pub fn set_name(connection: &mut Telnet, name: &str) -> Result<Response, String> {
+    send_command(connection, &format!("clientupdate client_nickname={}\n", name), true)
+}
+
+pub fn channellist(connection: &mut Telnet) -> Result<Response, String> {
+    send_command(connection, "channellist\n", true)
+}
+
+pub fn clientlist(connection: &mut Telnet) -> Result<Response, String> {
+    send_command(connection, "clientlist\n", true)
+}
+
+pub fn whoami(connection: &mut Telnet) -> Result<Response, String> {
+    send_command(connection, "whoami\n", true).map(to_single_response)
+}
+
+pub fn clientmove(connection: &mut Telnet, cid: &i32, clid_list: Vec<&i32>) -> Result<Response, String> {
+    let clid_str = clid_list
+        .iter()
+        .map(|clid| format!("clid={}", clid))
+        .collect::<Vec<String>>()
+        .join("|");
+    send_command(connection, &format!("clientmove cid={} {}\n", cid, clid_str), false)
+}
+
+pub fn clientupdate(connection: &mut Telnet, parameters: &ParameterList) -> Result<Response, String> {
+    let parameters_str = parameters
+        .iter()
+        .map(|param| format!("{}={}", param.name, param.value))
+        .collect::<Vec<String>>()
+        .join(" ");
+    send_command(connection, &format!("clientupdate {}\n", parameters_str), false)
+}