Add ntfy-events

Don't crash without self_clid
Improve functions in main.rs

Cargo.lock

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

Cargo.toml

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

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)"

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 {

src/command_utils/events.rs

@@ -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;
+            }
+        }
+    }
+}

src/command_utils/mod.rs

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

src/commands.rs

@@ -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(err) => {
-            Err(String::from("Failed to read from Teamspeak."))
+            Err(format!("Failed to read from Teamspeak: {}", err))
         }
     }
 }

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::cli::{Commands, EventArgsFilter};
-use crate::models::{Channel, Event};
-use crate::models::Client;
-use crate::response::Response;
 
 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 {
+fn result_or_error<T>(res: Result<Option<T>, String>, result_type: &str) -> Result<T, Error> {
-    channel_res.unwrap_or_else(|err| {
+    let error_action = format!("find {}", result_type);
-        println!("Failed to find channel: {}", err);
+    res.map_err(|err| make_action_error(&error_action, err))?
-        exit(1);
+        .ok_or_else(|| make_action_error(&error_action, String::from("Not Found.")))
-    })
-        .unwrap_or_else(|| {
-            println!("Failed to find channel.");
-            exit(1);
-        })
 }
 
-fn client_or_exit(client_res: Result<Option<Client>, String>) -> Client {
+fn connect() -> Result<Telnet, Error> {
-    client_res.unwrap_or_else(|err| {
+    let mut connection = Telnet::connect(("127.0.0.1", 25639), 512 * 1024)
-        println!("Failed to find client: {}", err);
+        .map_err(|_| Error::new(ErrorKind::AddrNotAvailable, String::from("Failed to connect to Teamspeak.")))?;
-        exit(1);
+
-    })
+    wrappers::skip_welcome(&mut connection)
-        .unwrap_or_else(|| {
+        .map_err(to_other_error)?;
-            println!("Failed to find client.");
+    wrappers::login(&mut connection)
-            exit(1);
+        .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);
+    let mut connection = connect()?;
-    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
@@ -61,8 +55,7 @@ fn main() {
                     }
                 }
                 Err(msg) => {
-                    println!("Failed to get channels: {}", msg);
+                    return Err(make_action_error("get channels", msg));
-                    exit(1);
                 }
             }
         }
@@ -75,71 +68,62 @@ fn main() {
                     }
                 }
                 Err(msg) => {
-                    println!("Failed to get clients: {}", msg);
+                    return Err(make_action_error("get clients", msg));
-                    exit(1);
                 }
             }
         }
 
         Commands::Fetch(args) => {
             if args.want_client() && args.want_channel() {
-                println!("Fetching both clients and channels is not supported.");
+                return Err(Error::new(ErrorKind::InvalidInput, "Fetching both clients and channels is not supported."));
-                exit(1);
             }
             if !args.want_client() && !args.want_channel() {
-                println!("No clients or channels specified.");
+                return Err(Error::new(ErrorKind::InvalidInput, "No clients or channels specified."));
-                exit(1);
             }
 
             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);
+                        return Err(make_action_error("fetch client", msg));
-                        exit(1);
                     }
                 }
             }
 
             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);
+                        return Err(make_action_error("fetch channel", msg));
-                        exit(1);
                     }
                 }
             }
         }
 
         Commands::Message(args) => {
-            let target = args.target(&mut connection).unwrap_or_else(|err| {
+            let target = args.target(&mut connection)
-                println!("Failed to get message target: {}", err);
+                .map_err(|msg| make_action_error("message target", msg))?;
-                exit(1);
-            });
 
             match wrappers::send_text_message(&mut connection, target, args.message) {
                 Ok(_) => println!("Successfully sent message."),
                 Err(msg) => {
-                    println!("Failed to send message: {}", msg);
+                    return Err(make_action_error("send message", msg));
-                    exit(1);
                 }
             }
         }
 
         Commands::Move(args) => {
-            let channel = channel_or_exit(args.channel(&mut connection));
+            let channel = result_or_error(args.channel(&mut connection), "channel")?;
-            let client = client_or_exit(args.client(&mut connection));
+            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);
+                    return Err(make_action_error("move client", msg));
-                    exit(1);
                 }
             }
         }
@@ -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);
+                    return Err(make_action_error("update client", msg));
-                    exit(1);
                 }
             }
         }
 
         Commands::Events(args) => {
-            for event in args.event {
+            let filter = args.filter.unwrap_or(EventArgsFilter::All);
-                if commands::clientnotifyregister(&mut connection, 1, event).is_err() {
-                    println!("Failed to register event listener.");
-                    exit(1);
-                }
-            }
-
             loop {
-                match commands::read_response(&mut connection, true, String::new()) {
+                command_utils::events::register_events(&mut connection, args.event.clone())
-                    Ok(response) => {
+                    .map_err(to_other_error)?;
-                        if let Response::Event(event_type, params) = response {
 
-                            let event = Event::new(&mut connection, event_type, params);
+                command_utils::events::loop_response_reader(&mut connection, &filter);
-                            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));
-                    Err(_) => {
+                connection = connect()?;
-                        // 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, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct Client {
     pub cid: i32,
     pub clid: i32,

src/models/event.rs

@@ -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")?
+                self.find_channel(connection, params, "ctid")
-                    .parse::<i32>().unwrap_or(0);
-                wrappers::find_channel(connection, "cid", &id.to_string(), true).unwrap().or(None)
             }
             _ => None,
         }
     }
 
-    pub fn get_client(&self, connection: &mut Telnet, params: &ParameterList) -> Option<Client> {
+    pub fn find_client(&self, connection: &mut Telnet, params: &ParameterList, param_name: &str) -> Option<Client> {
-        match self {
+        let id = parameter_find(params, param_name)?
-            EventType::NotifyClientMoved => {
-                let id = parameter_find(params, "clid")?
             .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, &params);
-        let client = event_type.get_client(connection, &params);
+        let mut 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,
@@ -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()
+    }
 }

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).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)
 }

src/response.rs

@@ -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(&parameter_lists[0]))
             }

src/wrappers.rs

@@ -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(|_| {
+    let apikey = std::env::var("TS3_CLIENT_API_KEY")
-        println!("No API key found in environment variable TS3_CLIENT_API_KEY.");
+        .map_err(|_| String::from("No API key found in environment variable TS3_CLIENT_API_KEY."))?;
-        exit(1);
-    });
 
-    match commands::login(connection, &apikey) {
+    commands::login(connection, &apikey)
-        Ok(_) => {}
+        .map(|_| ())
-        Err(msg) => {
+        .map_err(|err| format!("Failed to authenticate with Teamspeak: {}", err))
-            println!("Failed to authenticate with Teamspeak: {}", msg);
-            exit(1);
-        }
-    }
 }
 
 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(&params, "clid") {

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")
+	"events")
-		teamspeak-query-lib events NotifyClientMoved NotifyClientEnterView \
+		teamspeak-query-lib events --filter=others NotifyClientMoved NotifyClientEnterView NotifyClientLeftView NotifyTextMessage NotifyClientPoke \
-			| jq -r --unbuffered '.client.client_nickname + " joined " + .channel.channel_name // "the server"' \
+			| jq -r --unbuffered '.message' \
-			| xargs -I{} notify-send "TS3 movement" "{}"
+			| tee >(xargs -I{} notify-send "TS3 Event" "{}")
+		;;
+	"ntfy-events")
+		teamspeak-query-lib events --filter=others NotifyClientPoke NotifyTextMessage \
+      | handle_ntfy_events
+  	;;
 esac