Compare commits
7 commits
Author | SHA1 | Date | |
---|---|---|---|
Tobias Reisinger | b827471e6d | ||
Tobias Reisinger | 915c2ccbbf | ||
Tobias Reisinger | 895f5f9373 | ||
Tobias Reisinger | 70e0a1d0b4 | ||
Tobias Reisinger | ea7815535c | ||
Tobias Reisinger | ae411b6dcc | ||
Tobias Reisinger | f860fe3689 |
2
Cargo.lock
generated
2
Cargo.lock
generated
|
@ -182,7 +182,7 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "teamspeak-query-lib"
|
||||
version = "0.1.2"
|
||||
version = "0.1.5"
|
||||
dependencies = [
|
||||
"clap",
|
||||
"serde",
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
[package]
|
||||
name = "teamspeak-query-lib"
|
||||
version = "0.1.2"
|
||||
version = "0.1.5"
|
||||
edition = "2021"
|
||||
|
||||
[dependencies]
|
||||
|
|
4
Makefile
4
Makefile
|
@ -2,11 +2,13 @@
|
|||
|
||||
INSTALL_DIR = $(HOME)/.local/bin
|
||||
|
||||
export PATH := target/debug:$(PATH)
|
||||
|
||||
build:
|
||||
@cargo build
|
||||
|
||||
run: build
|
||||
@PATH=$(PWD)/target/debug:$(PATH) ./ts-control
|
||||
./ts-control
|
||||
|
||||
install:
|
||||
mkdir -p "$(INSTALL_DIR)"
|
||||
|
|
11
src/cli.rs
11
src/cli.rs
|
@ -1,4 +1,4 @@
|
|||
use clap::{Args, Parser, Subcommand};
|
||||
use clap::{Args, Parser, Subcommand, ValueEnum};
|
||||
use telnet::Telnet;
|
||||
|
||||
use crate::parameter::ParameterList;
|
||||
|
@ -79,9 +79,18 @@ pub struct UpdateArgs {
|
|||
speakers: Option<bool>,
|
||||
}
|
||||
|
||||
#[derive(Clone, ValueEnum)]
|
||||
pub enum EventArgsFilter {
|
||||
All,
|
||||
Mine,
|
||||
Others,
|
||||
}
|
||||
|
||||
#[derive(Args)]
|
||||
pub struct EventArgs {
|
||||
pub event: Vec<EventType>,
|
||||
#[arg(long, short)]
|
||||
pub filter: Option<EventArgsFilter>,
|
||||
}
|
||||
|
||||
impl FetchArgs {
|
||||
|
|
66
src/command_utils/events.rs
Normal file
66
src/command_utils/events.rs
Normal file
|
@ -0,0 +1,66 @@
|
|||
use telnet::Telnet;
|
||||
|
||||
use crate::{commands, wrappers};
|
||||
use crate::cli::EventArgsFilter;
|
||||
use crate::models::{Client, Event, EventType};
|
||||
use crate::response::Response;
|
||||
|
||||
pub fn register_events(connection: &mut Telnet, events: Vec<EventType>) -> Result<(), String> {
|
||||
for event in events {
|
||||
if commands::clientnotifyregister(connection, 1, event).is_err() {
|
||||
return Err(String::from("Failed to register event listener."));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn handle_event_response(connection: &mut Telnet, event: Event, known_clients: &mut Vec<Client>) {
|
||||
match serde_json::to_string(&event) {
|
||||
Ok(json) => println!("{}", json),
|
||||
Err(err) => {
|
||||
// TODO: Handle serialization error
|
||||
eprintln!("Serialization error: {}", err);
|
||||
}
|
||||
}
|
||||
|
||||
if let Ok(new_clients) = wrappers::get_clients(connection) {
|
||||
*known_clients = new_clients;
|
||||
}
|
||||
}
|
||||
|
||||
fn try_get_self_clid(connection: &mut Telnet) -> Option<i32> {
|
||||
wrappers::get_self_clid(connection)
|
||||
.unwrap_or_default()
|
||||
.parse()
|
||||
.map(Some)
|
||||
.unwrap_or(None)
|
||||
}
|
||||
|
||||
pub fn loop_response_reader(connection: &mut Telnet, filter: &EventArgsFilter) {
|
||||
let mut known_clients = wrappers::get_clients(connection).unwrap_or_else(|_| Vec::new());
|
||||
|
||||
let mut self_clid: Option<i32> = try_get_self_clid(connection);
|
||||
|
||||
loop {
|
||||
match commands::read_response(connection, true, String::new()) {
|
||||
Ok(response) => {
|
||||
if let Response::Event(event_type, params) = response {
|
||||
let event = Event::new(connection, event_type, params, &known_clients);
|
||||
|
||||
if self_clid.is_none() {
|
||||
self_clid = try_get_self_clid(connection);
|
||||
}
|
||||
if !event.should_handle(filter, self_clid) {
|
||||
continue;
|
||||
}
|
||||
|
||||
handle_event_response(connection, event, &mut known_clients);
|
||||
}
|
||||
}
|
||||
Err(_) => {
|
||||
// print error?
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
1
src/command_utils/mod.rs
Normal file
1
src/command_utils/mod.rs
Normal file
|
@ -0,0 +1 @@
|
|||
pub mod events;
|
|
@ -1,5 +1,6 @@
|
|||
use std::time::Duration;
|
||||
use crate::utils::SendTextMessageTarget;
|
||||
use telnet::Event::Data;
|
||||
use telnet::Event::{Data, TimedOut};
|
||||
use telnet::Telnet;
|
||||
use crate::models::EventType;
|
||||
|
||||
|
@ -14,18 +15,21 @@ fn to_single_response(resp: Response) -> Response {
|
|||
}
|
||||
|
||||
fn read_part(connection: &mut Telnet) -> Result<String, String> {
|
||||
match connection.read() {
|
||||
match connection.read_timeout(Duration::new(5, 0)) {
|
||||
Ok(event) => {
|
||||
match event {
|
||||
Data(bytes) => Ok(String::from_utf8(bytes.to_vec())
|
||||
.map_err(|_| "Teamspeak returned a badly formatted models.")?),
|
||||
.map_err(|_| "Teamspeak returned an invalid response.")?),
|
||||
TimedOut => {
|
||||
Ok(String::new())
|
||||
},
|
||||
_ => {
|
||||
Err(String::from("Received unknown event from Teamspeak."))
|
||||
}
|
||||
}
|
||||
}
|
||||
Err(_) => {
|
||||
Err(String::from("Failed to read from Teamspeak."))
|
||||
Err(err) => {
|
||||
Err(format!("Failed to read from Teamspeak: {}", err))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
132
src/main.rs
132
src/main.rs
|
@ -1,11 +1,8 @@
|
|||
use std::process::exit;
|
||||
use std::io::{Error, ErrorKind};
|
||||
|
||||
use telnet::Telnet;
|
||||
|
||||
use crate::cli::Commands;
|
||||
use crate::models::{Channel, Event};
|
||||
use crate::models::Client;
|
||||
use crate::response::Response;
|
||||
use crate::cli::{Commands, EventArgsFilter};
|
||||
|
||||
mod wrappers;
|
||||
mod commands;
|
||||
|
@ -14,41 +11,38 @@ mod cli;
|
|||
mod utils;
|
||||
mod models;
|
||||
mod response;
|
||||
mod command_utils;
|
||||
|
||||
fn channel_or_exit(channel_res: Result<Option<Channel>, String>) -> Channel {
|
||||
channel_res.unwrap_or_else(|err| {
|
||||
println!("Failed to find channel: {}", err);
|
||||
exit(1);
|
||||
})
|
||||
.unwrap_or_else(|| {
|
||||
println!("Failed to find channel.");
|
||||
exit(1);
|
||||
})
|
||||
fn result_or_error<T>(res: Result<Option<T>, String>, result_type: &str) -> Result<T, Error> {
|
||||
let error_action = format!("find {}", result_type);
|
||||
res.map_err(|err| make_action_error(&error_action, err))?
|
||||
.ok_or_else(|| make_action_error(&error_action, String::from("Not Found.")))
|
||||
}
|
||||
|
||||
fn client_or_exit(client_res: Result<Option<Client>, String>) -> Client {
|
||||
client_res.unwrap_or_else(|err| {
|
||||
println!("Failed to find client: {}", err);
|
||||
exit(1);
|
||||
})
|
||||
.unwrap_or_else(|| {
|
||||
println!("Failed to find client.");
|
||||
exit(1);
|
||||
})
|
||||
fn connect() -> Result<Telnet, Error> {
|
||||
let mut connection = Telnet::connect(("127.0.0.1", 25639), 512 * 1024)
|
||||
.map_err(|_| Error::new(ErrorKind::AddrNotAvailable, String::from("Failed to connect to Teamspeak.")))?;
|
||||
|
||||
wrappers::skip_welcome(&mut connection)
|
||||
.map_err(to_other_error)?;
|
||||
wrappers::login(&mut connection)
|
||||
.map_err(|msg| Error::new(ErrorKind::PermissionDenied, msg))?;
|
||||
|
||||
Ok(connection)
|
||||
}
|
||||
|
||||
fn main() {
|
||||
fn to_other_error(msg: String) -> Error {
|
||||
Error::new(ErrorKind::Other, msg)
|
||||
}
|
||||
|
||||
fn make_action_error(action: &str, msg: String) -> Error {
|
||||
Error::new(ErrorKind::Other, format!("Failed to {}: {}", action, msg))
|
||||
}
|
||||
|
||||
fn main() -> Result<(), Error> {
|
||||
let cli = cli::init();
|
||||
|
||||
let connection = Telnet::connect(("127.0.0.1", 25639), 512 * 1024);
|
||||
if connection.is_err() {
|
||||
println!("Failed to connect to Teamspeak.");
|
||||
exit(1);
|
||||
}
|
||||
let mut connection = connection.unwrap();
|
||||
|
||||
wrappers::skip_welcome(&mut connection);
|
||||
wrappers::login(&mut connection);
|
||||
let mut connection = connect()?;
|
||||
|
||||
// You can check for the existence of subcommands, and if found use their
|
||||
// matches just as you would the top level cmd
|
||||
|
@ -61,8 +55,7 @@ fn main() {
|
|||
}
|
||||
}
|
||||
Err(msg) => {
|
||||
println!("Failed to get channels: {}", msg);
|
||||
exit(1);
|
||||
return Err(make_action_error("get channels", msg));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -75,71 +68,62 @@ fn main() {
|
|||
}
|
||||
}
|
||||
Err(msg) => {
|
||||
println!("Failed to get clients: {}", msg);
|
||||
exit(1);
|
||||
return Err(make_action_error("get clients", msg));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Commands::Fetch(args) => {
|
||||
if args.want_client() && args.want_channel() {
|
||||
println!("Fetching both clients and channels is not supported.");
|
||||
exit(1);
|
||||
return Err(Error::new(ErrorKind::InvalidInput, "Fetching both clients and channels is not supported."));
|
||||
}
|
||||
if !args.want_client() && !args.want_channel() {
|
||||
println!("No clients or channels specified.");
|
||||
exit(1);
|
||||
return Err(Error::new(ErrorKind::InvalidInput, "No clients or channels specified."));
|
||||
}
|
||||
|
||||
if args.want_client() {
|
||||
let client = client_or_exit(args.client(&mut connection));
|
||||
let client = result_or_error(args.client(&mut connection), "client")?;
|
||||
|
||||
match wrappers::fetch_client(&mut connection, &[client]) {
|
||||
Ok(_) => println!("Successfully fetched client."),
|
||||
Err(msg) => {
|
||||
println!("Failed to fetch client: {}", msg);
|
||||
exit(1);
|
||||
return Err(make_action_error("fetch client", msg));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if args.want_channel() {
|
||||
let channel = channel_or_exit(args.channel(&mut connection));
|
||||
let channel = result_or_error(args.channel(&mut connection), "channel")?;
|
||||
|
||||
match wrappers::fetch_channel(&mut connection, channel) {
|
||||
Ok(_) => println!("Successfully fetched channel."),
|
||||
Err(msg) => {
|
||||
println!("Failed to fetch channel: {}", msg);
|
||||
exit(1);
|
||||
return Err(make_action_error("fetch channel", msg));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Commands::Message(args) => {
|
||||
let target = args.target(&mut connection).unwrap_or_else(|err| {
|
||||
println!("Failed to get message target: {}", err);
|
||||
exit(1);
|
||||
});
|
||||
let target = args.target(&mut connection)
|
||||
.map_err(|msg| make_action_error("message target", msg))?;
|
||||
|
||||
match wrappers::send_text_message(&mut connection, target, args.message) {
|
||||
Ok(_) => println!("Successfully sent message."),
|
||||
Err(msg) => {
|
||||
println!("Failed to send message: {}", msg);
|
||||
exit(1);
|
||||
return Err(make_action_error("send message", msg));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Commands::Move(args) => {
|
||||
let channel = channel_or_exit(args.channel(&mut connection));
|
||||
let client = client_or_exit(args.client(&mut connection));
|
||||
let channel = result_or_error(args.channel(&mut connection), "channel")?;
|
||||
let client = result_or_error(args.client(&mut connection), "client")?;
|
||||
|
||||
match wrappers::move_client(&mut connection, &channel, &[client]) {
|
||||
Ok(resp) => println!("Successfully moved client: {}", resp),
|
||||
Err(msg) => {
|
||||
println!("Failed to move client: {}", msg);
|
||||
exit(1);
|
||||
return Err(make_action_error("move client", msg));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -148,40 +132,24 @@ fn main() {
|
|||
match wrappers::update_client(&mut connection, args.to_parameter_list()) {
|
||||
Ok(_) => println!("Successfully updated client."),
|
||||
Err(msg) => {
|
||||
println!("Failed to update client: {}", msg);
|
||||
exit(1);
|
||||
return Err(make_action_error("update client", msg));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Commands::Events(args) => {
|
||||
for event in args.event {
|
||||
if commands::clientnotifyregister(&mut connection, 1, event).is_err() {
|
||||
println!("Failed to register event listener.");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
let filter = args.filter.unwrap_or(EventArgsFilter::All);
|
||||
loop {
|
||||
match commands::read_response(&mut connection, true, String::new()) {
|
||||
Ok(response) => {
|
||||
if let Response::Event(event_type, params) = response {
|
||||
command_utils::events::register_events(&mut connection, args.event.clone())
|
||||
.map_err(to_other_error)?;
|
||||
|
||||
let event = Event::new(&mut connection, event_type, params);
|
||||
match serde_json::to_string(&event) {
|
||||
Ok(json) => println!("{}", json),
|
||||
Err(_) => {
|
||||
// TODO: Handle error
|
||||
}
|
||||
}
|
||||
command_utils::events::loop_response_reader(&mut connection, &filter);
|
||||
|
||||
}
|
||||
}
|
||||
Err(_) => {
|
||||
// TODO: Handle error
|
||||
}
|
||||
}
|
||||
// loop_response_reader failed. Let's try to reconnect after 1 second.
|
||||
std::thread::sleep(std::time::Duration::from_secs(1));
|
||||
connection = connect()?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
|
@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
|
|||
|
||||
use crate::parameter::{parameter_find, ParameterList};
|
||||
|
||||
#[derive(Serialize, Deserialize, Debug)]
|
||||
#[derive(Serialize, Deserialize, Clone, Debug)]
|
||||
pub struct Client {
|
||||
pub cid: i32,
|
||||
pub clid: i32,
|
||||
|
|
|
@ -1,8 +1,10 @@
|
|||
use std::fmt::{Display, Formatter};
|
||||
use std::str::FromStr;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde::{Deserialize, Serialize, Serializer};
|
||||
use serde::ser::SerializeStruct;
|
||||
use telnet::Telnet;
|
||||
use crate::cli::EventArgsFilter;
|
||||
|
||||
use crate::models::{Channel, Client};
|
||||
use crate::parameter::{parameter_find, ParameterList};
|
||||
|
@ -43,7 +45,7 @@ pub enum EventType {
|
|||
NotifyConnectStatusChange,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Debug)]
|
||||
#[derive(Debug)]
|
||||
pub struct Event {
|
||||
pub event_type: EventType,
|
||||
pub params: ParameterList,
|
||||
|
@ -152,36 +154,58 @@ impl Display for EventType {
|
|||
}
|
||||
|
||||
impl EventType {
|
||||
|
||||
pub fn find_channel(&self, connection: &mut Telnet, params: &ParameterList, param_name: &str) -> Option<Channel> {
|
||||
let id = parameter_find(params, param_name)?
|
||||
.parse::<i32>().unwrap_or(0);
|
||||
wrappers::find_channel(connection, "cid", &id.to_string(), true).unwrap().or(None)
|
||||
}
|
||||
pub fn get_channel(&self, connection: &mut Telnet, params: &ParameterList) -> Option<Channel> {
|
||||
match self {
|
||||
EventType::NotifyClientMoved => {
|
||||
let id = parameter_find(params, "ctid")?
|
||||
.parse::<i32>().unwrap_or(0);
|
||||
wrappers::find_channel(connection, "cid", &id.to_string(), true).unwrap().or(None)
|
||||
self.find_channel(connection, params, "ctid")
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_client(&self, connection: &mut Telnet, params: &ParameterList) -> Option<Client> {
|
||||
match self {
|
||||
EventType::NotifyClientMoved => {
|
||||
let id = parameter_find(params, "clid")?
|
||||
pub fn find_client(&self, connection: &mut Telnet, params: &ParameterList, param_name: &str) -> Option<Client> {
|
||||
let id = parameter_find(params, param_name)?
|
||||
.parse::<i32>().unwrap_or(0);
|
||||
wrappers::find_client(connection, "clid", &id.to_string(), true).unwrap().or(None)
|
||||
}
|
||||
|
||||
pub fn get_client(&self, connection: &mut Telnet, params: &ParameterList) -> Option<Client> {
|
||||
match self {
|
||||
EventType::NotifyClientMoved => {
|
||||
self.find_client(connection, params, "clid")
|
||||
}
|
||||
EventType::NotifyClientEnterView => {
|
||||
Some(Client::from(params.clone()))
|
||||
}
|
||||
EventType::NotifyTextMessage => {
|
||||
self.find_client(connection, params, "invokerid")
|
||||
}
|
||||
EventType::NotifyClientPoke => {
|
||||
self.find_client(connection, params, "invokerid")
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Event {
|
||||
pub fn new(connection: &mut Telnet, event_type: EventType, params: ParameterList) -> Event {
|
||||
pub fn new(connection: &mut Telnet, event_type: EventType, params: ParameterList, known_clients: &[Client]) -> Event {
|
||||
let channel = event_type.get_channel(connection, ¶ms);
|
||||
let client = event_type.get_client(connection, ¶ms);
|
||||
let mut client = event_type.get_client(connection, ¶ms);
|
||||
|
||||
if client.is_none() {
|
||||
let id = parameter_find(¶ms, "clid")
|
||||
.unwrap_or_else(|| String::from("0"))
|
||||
.parse::<i32>().unwrap_or(0);
|
||||
let client_id = id.to_string();
|
||||
client = known_clients.iter().find(|c| c.clid.to_string() == client_id).cloned();
|
||||
}
|
||||
|
||||
Event {
|
||||
event_type,
|
||||
|
@ -190,4 +214,88 @@ impl Event {
|
|||
client,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_client_name(&self) -> String {
|
||||
match &self.client {
|
||||
Some(client) => client.client_nickname.clone(),
|
||||
None => String::from("UNKNOWN"),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_channel_name(&self) -> String {
|
||||
match &self.channel {
|
||||
Some(channel) => channel.channel_name.clone(),
|
||||
None => String::from("UNKNOWN"),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_event_msg(&self) -> String {
|
||||
parameter_find(&self.params, "msg").unwrap_or_else(|| String::from(""))
|
||||
}
|
||||
|
||||
pub fn get_message(&self) -> String {
|
||||
match &self.event_type {
|
||||
EventType::NotifyClientPoke => {
|
||||
format!("{}: {}",
|
||||
self.get_client_name(),
|
||||
self.get_event_msg()
|
||||
)
|
||||
}
|
||||
EventType::NotifyTextMessage => {
|
||||
format!("{}: {}",
|
||||
self.get_client_name(),
|
||||
self.get_event_msg()
|
||||
)
|
||||
}
|
||||
EventType::NotifyClientMoved => {
|
||||
format!("{} joined {}",
|
||||
self.get_client_name(),
|
||||
self.get_channel_name()
|
||||
)
|
||||
}
|
||||
EventType::NotifyClientLeftView => {
|
||||
format!("{} left",
|
||||
self.get_client_name()
|
||||
)
|
||||
}
|
||||
EventType::NotifyClientEnterView => {
|
||||
format!("{} connected",
|
||||
self.get_client_name()
|
||||
)
|
||||
}
|
||||
_ => String::from(""),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_mine(&self, self_clid: Option<i32>) -> bool {
|
||||
if let Some(self_clid) = self_clid {
|
||||
if let Some(client) = &self.client {
|
||||
return client.clid == self_clid;
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
pub fn should_handle(&self, filter: &EventArgsFilter, self_clid: Option<i32>) -> bool {
|
||||
match filter {
|
||||
EventArgsFilter::All => true,
|
||||
EventArgsFilter::Mine => self.is_mine(self_clid),
|
||||
EventArgsFilter::Others => !self.is_mine(self_clid),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Serialize for Event {
|
||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
||||
where
|
||||
S: Serializer,
|
||||
{
|
||||
let mut x = serializer.serialize_struct("Event", 4)?;
|
||||
x.serialize_field("type", &self.event_type)?;
|
||||
x.serialize_field("channel", &self.channel)?;
|
||||
x.serialize_field("client", &self.client)?;
|
||||
x.serialize_field("params", &self.params)?;
|
||||
x.serialize_field("message", &self.get_message())?;
|
||||
x.end()
|
||||
}
|
||||
}
|
|
@ -5,7 +5,7 @@ pub type ParameterList = HashMap<String, String>;
|
|||
pub type Parameter = (String, String);
|
||||
|
||||
pub fn parameter_find(params: &ParameterList, name: &str) -> Option<String> {
|
||||
params.get(name).map(|value| value.clone())
|
||||
params.get(name).cloned()
|
||||
}
|
||||
|
||||
pub fn parameter_list_has(params: &ParameterList, key: &str, value: &str, strict: bool) -> bool {
|
||||
|
@ -17,7 +17,7 @@ pub fn parameter_list_has(params: &ParameterList, key: &str, value: &str, strict
|
|||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
false
|
||||
}
|
||||
|
||||
pub fn parameter_list_find(param_lists: &Vec<ParameterList>, key: &str, value: &str, strict: bool) -> Option<ParameterList> {
|
||||
|
@ -44,7 +44,7 @@ pub fn parameter_parse(params_str: &str) -> ParameterList {
|
|||
|
||||
let mut response_params = ParameterList::new();
|
||||
parts.iter().for_each(|part| {
|
||||
let (key, value) = part.split_once('=').unwrap_or((part, "1"));
|
||||
let (key, value) = part.split_once('=').unwrap_or((part, ""));
|
||||
response_params.insert(key.to_string(), decode_value(value));
|
||||
});
|
||||
|
||||
|
@ -58,7 +58,7 @@ pub fn parameter_to_string(param: Parameter) -> String {
|
|||
pub fn parameter_list_to_string(parameter_list: ParameterList, sep: &str) -> String {
|
||||
parameter_list
|
||||
.into_iter()
|
||||
.map(|param| parameter_to_string(param))
|
||||
.map(parameter_to_string)
|
||||
.collect::<Vec<String>>()
|
||||
.join(sep)
|
||||
}
|
||||
|
@ -66,7 +66,7 @@ pub fn parameter_list_to_string(parameter_list: ParameterList, sep: &str) -> Str
|
|||
pub fn parameters_to_string(parameters: Vec<Parameter>, sep: &str) -> String {
|
||||
parameters
|
||||
.into_iter()
|
||||
.map(|param| parameter_to_string(param))
|
||||
.map(parameter_to_string)
|
||||
.collect::<Vec<String>>()
|
||||
.join(sep)
|
||||
}
|
|
@ -45,7 +45,7 @@ fn get_response_type(type_str: &str) -> Result<ResponseType, String> {
|
|||
return Ok(ResponseType::Event(event_type));
|
||||
}
|
||||
|
||||
return Ok(ResponseType::Unknown);
|
||||
Ok(ResponseType::Unknown)
|
||||
}
|
||||
|
||||
impl TryFrom<String> for Response {
|
||||
|
@ -54,7 +54,7 @@ impl TryFrom<String> for Response {
|
|||
fn try_from(response_str: String) -> Result<Self, ResponseError> {
|
||||
let response_str = response_str.trim_end_matches("\n\r");
|
||||
|
||||
let (rsp_type, rsp_params) = split_type_and_params(&response_str)
|
||||
let (rsp_type, rsp_params) = split_type_and_params(response_str)
|
||||
.map_err(|err| ResponseError {
|
||||
id: -1,
|
||||
msg: err,
|
||||
|
@ -66,7 +66,7 @@ impl TryFrom<String> for Response {
|
|||
parameter_lists.push(response_params);
|
||||
}
|
||||
|
||||
return match rsp_type {
|
||||
match rsp_type {
|
||||
ResponseType::Error => {
|
||||
Err(ResponseError::create_error(¶meter_lists[0]))
|
||||
}
|
||||
|
|
|
@ -1,4 +1,3 @@
|
|||
use std::process::exit;
|
||||
use std::time::Duration;
|
||||
|
||||
use telnet::Event::TimedOut;
|
||||
|
@ -11,34 +10,28 @@ use crate::models::Client;
|
|||
use crate::response::Response;
|
||||
use crate::utils::SendTextMessageTarget;
|
||||
|
||||
pub fn skip_welcome(connection: &mut Telnet) {
|
||||
pub fn skip_welcome(connection: &mut Telnet) -> Result<(), String> {
|
||||
loop {
|
||||
let event_result = connection.read_timeout(Duration::from_millis(100));
|
||||
match event_result {
|
||||
Ok(event) => {
|
||||
if let TimedOut = event {
|
||||
break;
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
Err(_) => println!("Failed to read from Teamspeak."),
|
||||
Err(_) => return Err(String::from("Failed to read from Teamspeak.")),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn login(connection: &mut Telnet) {
|
||||
pub fn login(connection: &mut Telnet) -> Result<(), String> {
|
||||
// read api key from environment variable
|
||||
let apikey = std::env::var("TS3_CLIENT_API_KEY").unwrap_or_else(|_| {
|
||||
println!("No API key found in environment variable TS3_CLIENT_API_KEY.");
|
||||
exit(1);
|
||||
});
|
||||
let apikey = std::env::var("TS3_CLIENT_API_KEY")
|
||||
.map_err(|_| String::from("No API key found in environment variable TS3_CLIENT_API_KEY."))?;
|
||||
|
||||
match commands::login(connection, &apikey) {
|
||||
Ok(_) => {}
|
||||
Err(msg) => {
|
||||
println!("Failed to authenticate with Teamspeak: {}", msg);
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
commands::login(connection, &apikey)
|
||||
.map(|_| ())
|
||||
.map_err(|err| format!("Failed to authenticate with Teamspeak: {}", err))
|
||||
}
|
||||
|
||||
pub fn get_channels(connection: &mut Telnet, spacers: bool) -> Result<Vec<Channel>, String> {
|
||||
|
@ -117,7 +110,7 @@ pub fn get_channel_clients(connection: &mut Telnet, channel: &Channel) -> Result
|
|||
}
|
||||
}
|
||||
|
||||
fn get_self_clid(connection: &mut Telnet) -> Result<String, String> {
|
||||
pub fn get_self_clid(connection: &mut Telnet) -> Result<String, String> {
|
||||
match commands::whoami(connection)? {
|
||||
Response::Data(params) => {
|
||||
match parameter::parameter_find(¶ms, "clid") {
|
||||
|
|
53
ts-control
53
ts-control
|
@ -1,4 +1,4 @@
|
|||
#!/usr/bin/env sh
|
||||
#!/usr/bin/env bash
|
||||
|
||||
actions="quick
|
||||
move
|
||||
|
@ -9,7 +9,8 @@ not away
|
|||
back
|
||||
message
|
||||
message-user
|
||||
events-move"
|
||||
events
|
||||
ntfy-events"
|
||||
|
||||
_ts_control_get_entity() {
|
||||
entity=$(_ts_control_single_or_dmenu "$(teamspeak-query-lib "$1s")" "$2")
|
||||
|
@ -54,6 +55,41 @@ _ts_control_single_or_dmenu() {
|
|||
fi
|
||||
}
|
||||
|
||||
handle_ntfy_events() {
|
||||
while read -r data; do
|
||||
msg=$(echo "$data" | jq -r --unbuffered '.message')
|
||||
type=$(echo "$data" | jq -r --unbuffered '.type')
|
||||
mode=$(echo "$data" | jq -r --unbuffered '.params.targetmode')
|
||||
|
||||
echo "$data"
|
||||
|
||||
if [ "$type" = "NotifyTextMessage" ] && [ "$mode" != "1" ]; then
|
||||
continue # Skip all messages that are not direct messages
|
||||
fi
|
||||
|
||||
friendly_type="Event"
|
||||
case $type in
|
||||
"NotifyClientPoke")
|
||||
friendly_type="Poke"
|
||||
;;
|
||||
"NotifyTextMessage")
|
||||
friendly_type="Message"
|
||||
;;
|
||||
esac
|
||||
|
||||
echo "($friendly_type) $target: $msg"
|
||||
|
||||
curl -sSL \
|
||||
-H "Authorization: Bearer $TS3_NTFY_TOKEN" \
|
||||
-d "{
|
||||
\"topic\": \"$TS3_NTFY_TOPIC\",
|
||||
\"message\": \"$msg\",
|
||||
\"title\": \"TS3 $friendly_type\"
|
||||
}" \
|
||||
"$TS3_NTFY_HOST"
|
||||
done
|
||||
}
|
||||
|
||||
# Add '$' to $1 to add 'End of line' to the regex for grep
|
||||
action=$(_ts_control_single_or_dmenu "$actions" "$1$")
|
||||
|
||||
|
@ -98,8 +134,13 @@ case $action in
|
|||
message=$(_ts_control_get_message "$3")
|
||||
teamspeak-query-lib message --strict-client --client "$user" "$message"
|
||||
;;
|
||||
"events-move")
|
||||
teamspeak-query-lib events NotifyClientMoved NotifyClientEnterView \
|
||||
| jq -r --unbuffered '.client.client_nickname + " joined " + .channel.channel_name // "the server"' \
|
||||
| xargs -I{} notify-send "TS3 movement" "{}"
|
||||
"events")
|
||||
teamspeak-query-lib events --filter=others NotifyClientMoved NotifyClientEnterView NotifyClientLeftView NotifyTextMessage NotifyClientPoke \
|
||||
| jq -r --unbuffered '.message' \
|
||||
| tee >(xargs -I{} notify-send "TS3 Event" "{}")
|
||||
;;
|
||||
"ntfy-events")
|
||||
teamspeak-query-lib events --filter=others NotifyClientPoke NotifyTextMessage \
|
||||
| handle_ntfy_events
|
||||
;;
|
||||
esac
|
||||
|
|
Loading…
Reference in a new issue