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.4"
+version = "0.1.5"
 dependencies = [
  "clap",
  "serde",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "teamspeak-query-lib"
-version = "0.1.4"
+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

@@ -1,5 +1,7 @@
 use telnet::Telnet;
+
 use crate::{commands, wrappers};
+use crate::cli::EventArgsFilter;
 use crate::models::{Client, Event, EventType};
 use crate::response::Response;
 
@@ -12,29 +14,49 @@ pub fn register_events(connection: &mut Telnet, events: Vec<EventType>) -> Resul
     Ok(())
 }
 
-pub fn handle_event_response(connection: &mut Telnet, response: Response, known_clients: &mut Vec<Client>) {
+pub fn handle_event_response(connection: &mut Telnet, event: Event, known_clients: &mut Vec<Client>) {
-    if let Response::Event(event_type, params) = response {
+    match serde_json::to_string(&event) {
-
+        Ok(json) => println!("{}", json),
-        let event = Event::new(connection, event_type, params, known_clients);
+        Err(err) => {
-        match serde_json::to_string(&event) {
+            // TODO: Handle serialization error
-            Ok(json) => println!("{}", json),
+            eprintln!("Serialization error: {}", err);
-            Err(err) => {
-                // TODO: Handle serialization error
-                eprintln!("Serialization error: {}", err);
-            }
         }
+    }
 
-        if let Ok(new_clients) = wrappers::get_clients(connection) {
+    if let Ok(new_clients) = wrappers::get_clients(connection) {
-            *known_clients = new_clients;
+        *known_clients = new_clients;
-        }
     }
 }
 
-pub fn loop_response_reader(connection: &mut Telnet) {
+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) => handle_event_response(connection, response, &mut known_clients),
+            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/main.rs

@@ -2,9 +2,7 @@ use std::io::{Error, ErrorKind};
 
 use telnet::Telnet;
 
-use crate::cli::Commands;
+use crate::cli::{Commands, EventArgsFilter};
-use crate::models::Channel;
-use crate::models::Client;
 
 mod wrappers;
 mod commands;
@@ -15,14 +13,10 @@ mod models;
 mod response;
 mod command_utils;
 
-fn channel_or_error(channel_res: Result<Option<Channel>, String>) -> Result<Channel, Error> {
+fn result_or_error<T>(res: Result<Option<T>, String>, result_type: &str) -> Result<T, Error> {
-    channel_res.map_err(|err| make_action_error("find channel", err))?
+    let error_action = format!("find {}", result_type);
-        .ok_or_else(|| make_action_error("find channel", String::from("Not Found.")))
+    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_error(client_res: Result<Option<Client>, String>) -> Result<Client, Error> {
-    client_res.map_err(|err| make_action_error("find client", err))?
-        .ok_or_else(|| make_action_error("find client", String::from("Not Found.")))
 }
 
 fn connect() -> Result<Telnet, Error> {
@@ -88,7 +82,7 @@ fn main() -> Result<(), Error> {
             }
 
             if args.want_client() {
-                let client = client_or_error(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."),
@@ -99,7 +93,7 @@ fn main() -> Result<(), Error> {
             }
 
             if args.want_channel() {
-                let channel = channel_or_error(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."),
@@ -123,8 +117,8 @@ fn main() -> Result<(), Error> {
         }
 
         Commands::Move(args) => {
-            let channel = channel_or_error(args.channel(&mut connection))?;
+            let channel = result_or_error(args.channel(&mut connection), "channel")?;
-            let client = client_or_error(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),
@@ -144,10 +138,12 @@ fn main() -> Result<(), Error> {
         }
 
         Commands::Events(args) => {
+            let filter = args.filter.unwrap_or(EventArgsFilter::All);
             loop {
                 command_utils::events::register_events(&mut connection, args.event.clone())
                     .map_err(to_other_error)?;
-                command_utils::events::loop_response_reader(&mut connection);
+
+                command_utils::events::loop_response_reader(&mut connection, &filter);
 
                 // loop_response_reader failed. Let's try to reconnect after 1 second.
                 std::thread::sleep(std::time::Duration::from_secs(1));

src/models/event.rs

@@ -4,6 +4,7 @@ use std::str::FromStr;
 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};
@@ -265,6 +266,23 @@ impl Event {
             _ => 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 {
@@ -276,6 +294,7 @@ impl Serialize for Event {
         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/wrappers.rs

@@ -110,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

@@ -9,7 +9,8 @@ not away
 back
 message
 message-user
-events"
+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$")
 
@@ -99,7 +135,12 @@ case $action in
 		teamspeak-query-lib message --strict-client --client "$user" "$message"
 		;;
 	"events")
-		teamspeak-query-lib events NotifyClientMoved NotifyClientEnterView NotifyClientLeftView NotifyTextMessage NotifyClientPoke \
+		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