Cargo.lock

@@ -182,7 +182,7 @@ dependencies = [
 
 [[package]]
 name = "teamspeak-query-lib"
-version = "0.1.5"
+version = "0.1.2"
 dependencies = [
  "clap",
  "serde",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "teamspeak-query-lib"
-version = "0.1.5"
+version = "0.1.2"
 edition = "2021"
 
 [dependencies]

Makefile

@@ -2,13 +2,11 @@
 
 INSTALL_DIR = $(HOME)/.local/bin
 
-export PATH := target/debug:$(PATH)
-
 build:
 	@cargo build
 
 run: build
-	./ts-control
+	@PATH=$(PWD)/target/debug:$(PATH) ./ts-control
 
 install:
 	mkdir -p "$(INSTALL_DIR)"

src/cli.rs

@@ -1,4 +1,4 @@
-use clap::{Args, Parser, Subcommand, ValueEnum};
+use clap::{Args, Parser, Subcommand};
 use telnet::Telnet;
 
 use crate::parameter::ParameterList;
@@ -79,18 +79,9 @@ 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 {

src/command_utils/events.rs

@@ -1,66 +0,0 @@
-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;
-            }
-        }
-    }
-}

src/command_utils/mod.rs

@@ -1 +0,0 @@
-pub mod events;

src/commands.rs

@@ -1,6 +1,5 @@
-use std::time::Duration;
 use crate::utils::SendTextMessageTarget;
-use telnet::Event::{Data, TimedOut};
+use telnet::Event::Data;
 use telnet::Telnet;
 use crate::models::EventType;
 
@@ -15,21 +14,18 @@ fn to_single_response(resp: Response) -> Response {
 }
 
 fn read_part(connection: &mut Telnet) -> Result<String, String> {
-    match connection.read_timeout(Duration::new(5, 0)) {
+    match connection.read() {
         Ok(event) => {
             match event {
                 Data(bytes) => Ok(String::from_utf8(bytes.to_vec())
-                    .map_err(|_| "Teamspeak returned an invalid response.")?),
+                    .map_err(|_| "Teamspeak returned a badly formatted models.")?),
-                TimedOut => {
-                    Ok(String::new())
-                },
                 _ => {
                     Err(String::from("Received unknown event from Teamspeak."))
                 }
             }
         }
-        Err(err) => {
+        Err(_) => {
-            Err(format!("Failed to read from Teamspeak: {}", err))
+            Err(String::from("Failed to read from Teamspeak."))
         }
     }
 }

src/main.rs

@@ -1,8 +1,11 @@
-use std::io::{Error, ErrorKind};
+use std::process::exit;
 
 use telnet::Telnet;
 
-use crate::cli::{Commands, EventArgsFilter};
+use crate::cli::Commands;
+use crate::models::{Channel, Event};
+use crate::models::Client;
+use crate::response::Response;
 
 mod wrappers;
 mod commands;
@@ -11,38 +14,41 @@ mod cli;
 mod utils;
 mod models;
 mod response;
-mod command_utils;
 
-fn result_or_error<T>(res: Result<Option<T>, String>, result_type: &str) -> Result<T, Error> {
+fn channel_or_exit(channel_res: Result<Option<Channel>, String>) -> Channel {
-    let error_action = format!("find {}", result_type);
+    channel_res.unwrap_or_else(|err| {
-    res.map_err(|err| make_action_error(&error_action, err))?
+        println!("Failed to find channel: {}", err);
-        .ok_or_else(|| make_action_error(&error_action, String::from("Not Found.")))
+        exit(1);
+    })
+        .unwrap_or_else(|| {
+            println!("Failed to find channel.");
+            exit(1);
+        })
 }
 
-fn connect() -> Result<Telnet, Error> {
+fn client_or_exit(client_res: Result<Option<Client>, String>) -> Client {
-    let mut connection = Telnet::connect(("127.0.0.1", 25639), 512 * 1024)
+    client_res.unwrap_or_else(|err| {
-        .map_err(|_| Error::new(ErrorKind::AddrNotAvailable, String::from("Failed to connect to Teamspeak.")))?;
+        println!("Failed to find client: {}", err);
-
+        exit(1);
-    wrappers::skip_welcome(&mut connection)
+    })
-        .map_err(to_other_error)?;
+        .unwrap_or_else(|| {
-    wrappers::login(&mut connection)
+            println!("Failed to find client.");
-        .map_err(|msg| Error::new(ErrorKind::PermissionDenied, msg))?;
+            exit(1);
-
+        })
-    Ok(connection)
 }
 
-fn to_other_error(msg: String) -> Error {
+fn main() {
-    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 mut connection = connect()?;
+    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);
 
     // You can check for the existence of subcommands, and if found use their
     // matches just as you would the top level cmd
@@ -55,7 +61,8 @@ fn main() -> Result<(), Error> {
                     }
                 }
                 Err(msg) => {
-                    return Err(make_action_error("get channels", msg));
+                    println!("Failed to get channels: {}", msg);
+                    exit(1);
                 }
             }
         }
@@ -68,62 +75,71 @@ fn main() -> Result<(), Error> {
                     }
                 }
                 Err(msg) => {
-                    return Err(make_action_error("get clients", msg));
+                    println!("Failed to get clients: {}", msg);
+                    exit(1);
                 }
             }
         }
 
         Commands::Fetch(args) => {
             if args.want_client() && args.want_channel() {
-                return Err(Error::new(ErrorKind::InvalidInput, "Fetching both clients and channels is not supported."));
+                println!("Fetching both clients and channels is not supported.");
+                exit(1);
             }
             if !args.want_client() && !args.want_channel() {
-                return Err(Error::new(ErrorKind::InvalidInput, "No clients or channels specified."));
+                println!("No clients or channels specified.");
+                exit(1);
             }
 
             if args.want_client() {
-                let client = result_or_error(args.client(&mut connection), "client")?;
+                let client = client_or_exit(args.client(&mut connection));
 
                 match wrappers::fetch_client(&mut connection, &[client]) {
                     Ok(_) => println!("Successfully fetched client."),
                     Err(msg) => {
-                        return Err(make_action_error("fetch client", msg));
+                        println!("Failed to fetch client: {}", msg);
+                        exit(1);
                     }
                 }
             }
 
             if args.want_channel() {
-                let channel = result_or_error(args.channel(&mut connection), "channel")?;
+                let channel = channel_or_exit(args.channel(&mut connection));
 
                 match wrappers::fetch_channel(&mut connection, channel) {
                     Ok(_) => println!("Successfully fetched channel."),
                     Err(msg) => {
-                        return Err(make_action_error("fetch channel", msg));
+                        println!("Failed to fetch channel: {}", msg);
+                        exit(1);
                     }
                 }
             }
         }
 
         Commands::Message(args) => {
-            let target = args.target(&mut connection)
+            let target = args.target(&mut connection).unwrap_or_else(|err| {
-                .map_err(|msg| make_action_error("message target", msg))?;
+                println!("Failed to get message target: {}", err);
+                exit(1);
+            });
 
             match wrappers::send_text_message(&mut connection, target, args.message) {
                 Ok(_) => println!("Successfully sent message."),
                 Err(msg) => {
-                    return Err(make_action_error("send message", msg));
+                    println!("Failed to send message: {}", msg);
+                    exit(1);
                 }
             }
         }
 
         Commands::Move(args) => {
-            let channel = result_or_error(args.channel(&mut connection), "channel")?;
+            let channel = channel_or_exit(args.channel(&mut connection));
-            let client = result_or_error(args.client(&mut connection), "client")?;
+            let client = client_or_exit(args.client(&mut connection));
 
             match wrappers::move_client(&mut connection, &channel, &[client]) {
                 Ok(resp) => println!("Successfully moved client: {}", resp),
                 Err(msg) => {
-                    return Err(make_action_error("move client", msg));
+                    println!("Failed to move client: {}", msg);
+                    exit(1);
                 }
             }
         }
@@ -132,24 +148,40 @@ fn main() -> Result<(), Error> {
             match wrappers::update_client(&mut connection, args.to_parameter_list()) {
                 Ok(_) => println!("Successfully updated client."),
                 Err(msg) => {
-                    return Err(make_action_error("update client", msg));
+                    println!("Failed to update client: {}", msg);
+                    exit(1);
                 }
             }
         }
 
         Commands::Events(args) => {
-            let filter = args.filter.unwrap_or(EventArgsFilter::All);
+            for event in args.event {
+                if commands::clientnotifyregister(&mut connection, 1, event).is_err() {
+                    println!("Failed to register event listener.");
+                    exit(1);
+                }
+            }
+
             loop {
-                command_utils::events::register_events(&mut connection, args.event.clone())
+                match commands::read_response(&mut connection, true, String::new()) {
-                    .map_err(to_other_error)?;
+                    Ok(response) => {
+                        if let Response::Event(event_type, params) = response {
 
-                command_utils::events::loop_response_reader(&mut connection, &filter);
+                            let event = Event::new(&mut connection, event_type, params);
+                            match serde_json::to_string(&event) {
+                                Ok(json) => println!("{}", json),
+                                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()?;
+                    Err(_) => {
+                        // TODO: Handle error
+                    }
+                }
             }
         }
     }
-    Ok(())
 }

src/models/client.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::parameter::{parameter_find, ParameterList};
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct Client {
     pub cid: i32,
     pub clid: i32,

src/models/event.rs

@@ -1,10 +1,8 @@
 use std::fmt::{Display, Formatter};
 use std::str::FromStr;
 
-use serde::{Deserialize, Serialize, Serializer};
+use serde::{Deserialize, Serialize};
-use serde::ser::SerializeStruct;
 use telnet::Telnet;
-use crate::cli::EventArgsFilter;
 
 use crate::models::{Channel, Client};
 use crate::parameter::{parameter_find, ParameterList};
@@ -45,7 +43,7 @@ pub enum EventType {
     NotifyConnectStatusChange,
 }
 
-#[derive(Debug)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct Event {
     pub event_type: EventType,
     pub params: ParameterList,
@@ -154,58 +152,36 @@ 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 => {
-                self.find_channel(connection, params, "ctid")
+                let id = parameter_find(params, "ctid")?
+                    .parse::<i32>().unwrap_or(0);
+                wrappers::find_channel(connection, "cid", &id.to_string(), true).unwrap().or(None)
             }
             _ => None,
         }
     }
 
-    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")
+                let id = parameter_find(params, "clid")?
+                    .parse::<i32>().unwrap_or(0);
+                wrappers::find_client(connection, "clid", &id.to_string(), true).unwrap().or(None)
             }
             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, known_clients: &[Client]) -> Event {
+    pub fn new(connection: &mut Telnet, event_type: EventType, params: ParameterList) -> Event {
         let channel = event_type.get_channel(connection, &params);
-        let mut client = event_type.get_client(connection, &params);
+        let client = event_type.get_client(connection, &params);
-
-        if client.is_none() {
-            let id = parameter_find(&params, "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,
@@ -214,88 +190,4 @@ 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()
-    }
 }

src/parameter.rs

@@ -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).cloned()
+    params.get(name).map(|value| value.clone())
 }
 
 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;
         }
     }
-    false
+    return 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, ""));
+        let (key, value) = part.split_once('=').unwrap_or((part, "1"));
         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(parameter_to_string)
+        .map(|param| parameter_to_string(param))
         .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(parameter_to_string)
+        .map(|param| parameter_to_string(param))
         .collect::<Vec<String>>()
         .join(sep)
 }

src/response.rs

@@ -45,7 +45,7 @@ fn get_response_type(type_str: &str) -> Result<ResponseType, String> {
         return Ok(ResponseType::Event(event_type));
     }
 
-    Ok(ResponseType::Unknown)
+    return 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);
         }
 
-        match rsp_type {
+        return match rsp_type {
             ResponseType::Error => {
                 Err(ResponseError::create_error(&parameter_lists[0]))
             }

src/wrappers.rs

@@ -1,3 +1,4 @@
+use std::process::exit;
 use std::time::Duration;
 
 use telnet::Event::TimedOut;
@@ -10,28 +11,34 @@ use crate::models::Client;
 use crate::response::Response;
 use crate::utils::SendTextMessageTarget;
 
-pub fn skip_welcome(connection: &mut Telnet) -> Result<(), String> {
+pub fn skip_welcome(connection: &mut Telnet) {
     loop {
         let event_result = connection.read_timeout(Duration::from_millis(100));
         match event_result {
             Ok(event) => {
                 if let TimedOut = event {
-                    return Ok(());
+                    break;
                 }
             }
-            Err(_) => return Err(String::from("Failed to read from Teamspeak.")),
+            Err(_) => println!("Failed to read from Teamspeak."),
         }
     }
 }
 
-pub fn login(connection: &mut Telnet) -> Result<(), String> {
+pub fn login(connection: &mut Telnet) {
     // read api key from environment variable
-    let apikey = std::env::var("TS3_CLIENT_API_KEY")
+    let apikey = std::env::var("TS3_CLIENT_API_KEY").unwrap_or_else(|_| {
-        .map_err(|_| String::from("No API key found in environment variable TS3_CLIENT_API_KEY."))?;
+        println!("No API key found in environment variable TS3_CLIENT_API_KEY.");
+        exit(1);
+    });
 
-    commands::login(connection, &apikey)
+    match commands::login(connection, &apikey) {
-        .map(|_| ())
+        Ok(_) => {}
-        .map_err(|err| format!("Failed to authenticate with Teamspeak: {}", err))
+        Err(msg) => {
+            println!("Failed to authenticate with Teamspeak: {}", msg);
+            exit(1);
+        }
+    }
 }
 
 pub fn get_channels(connection: &mut Telnet, spacers: bool) -> Result<Vec<Channel>, String> {
@@ -110,7 +117,7 @@ pub fn get_channel_clients(connection: &mut Telnet, channel: &Channel) -> Result
     }
 }
 
-pub fn get_self_clid(connection: &mut Telnet) -> Result<String, String> {
+fn get_self_clid(connection: &mut Telnet) -> Result<String, String> {
     match commands::whoami(connection)? {
         Response::Data(params) => {
             match parameter::parameter_find(&params, "clid") {

ts-control

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/usr/bin/env sh
 
 actions="quick
 move
@@ -9,8 +9,7 @@ not away
 back
 message
 message-user
-events
+events-move"
-ntfy-events"
 
 _ts_control_get_entity() {
 	entity=$(_ts_control_single_or_dmenu "$(teamspeak-query-lib "$1s")" "$2")
@@ -55,41 +54,6 @@ _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$")
 
@@ -134,13 +98,8 @@ case $action in
 		message=$(_ts_control_get_message "$3")
 		teamspeak-query-lib message --strict-client --client "$user" "$message"
 		;;
-	"events")
+	"events-move")
-		teamspeak-query-lib events --filter=others NotifyClientMoved NotifyClientEnterView NotifyClientLeftView NotifyTextMessage NotifyClientPoke \
+		teamspeak-query-lib events NotifyClientMoved NotifyClientEnterView \
-			| jq -r --unbuffered '.message' \
+			| jq -r --unbuffered '.client.client_nickname + " joined " + .channel.channel_name // "the server"' \
-			| tee >(xargs -I{} notify-send "TS3 Event" "{}")
+			| xargs -I{} notify-send "TS3 movement" "{}"
-		;;
-	"ntfy-events")
-		teamspeak-query-lib events --filter=others NotifyClientPoke NotifyTextMessage \
-      | handle_ntfy_events
-  	;;
 esac