made websockets able to run functions

src/bk_week_cmds.rs

@@ -1,4 +1,7 @@
-use crate::{rs_println, websocket, Context, Error};
+use serde_json::json;
+
+use crate::websocket::send_cmd_json;
+use crate::{Context, Error};
 use crate::messages::send_msg;
 
 use std::fs;
@@ -8,7 +11,7 @@ pub async fn bk_week_help(
   ctx: Context<'_>,
 ) -> Result<(), Error>
 {
-  let help = fs::read_to_string("./bk_week_help.txt").unwrap();
+  let help = fs::read_to_string("./bk_week_help.md").unwrap();
   send_msg(ctx, help, true, true).await;
 
   return Ok(());
@@ -21,9 +24,7 @@ pub async fn bk_week_get(
   #[description = "The post URL"] url: Option<String>
 ) -> Result<(), Error>
 {
-  // log all posts in a thread
-  rs_println!("Sending hello to python...");
-  websocket::send_msg("Hello from Rust!").await;
+  send_cmd_json("update_data_file", json!([])).await;
   return Ok(());
 }
 

src/macros.rs

@@ -1,9 +1,8 @@
 #[macro_export]
 macro_rules! rs_println {
   ($($arg:tt)*) => {
-    println!("{}RS{} - {}",
+    println!("{}RS - {}",
       "\x1b[31m",
-      "\x1b[0m",
       format!($($arg)*)
     );
   };
@@ -13,10 +12,9 @@ macro_rules! rs_println {
 #[macro_export]
 macro_rules! rs_errln {
   ($($arg:tt)*) => {
-    println!("{}ERROR{} RS{} - {}",
+    println!("{}ERROR{} RS - {}",
       "\x1b[41m",
       "\x1b[0m\x1b[31m",
-      "\x1b[0m",
       format!($($arg)*)
     );
     process::exit(1);

src/python/data.py

@@ -79,6 +79,7 @@ def read_data(bot: botPy.Bot):
 
 
 def write_data(bot: botPy.Bot):
+  bot.data["TEST"] = True
   bot.data_f.seek(0)
   json.dump(bot.data, bot.data_f, indent=2)
   bot.data_f.truncate()

src/python/macros.py

@@ -2,7 +2,7 @@ from printColors import PrintColors
 
 def py_print(*args: str):
   print(
-    PrintColors.FG.blue + "Py" + PrintColors.Special.reset,
+    PrintColors.FG.blue + "Py",
     "-",
     " ".join(args)
   )
@@ -10,7 +10,7 @@ def py_print(*args: str):
 def py_error(*args: str):
   print(
     PrintColors.BG.red + "ERROR" + PrintColors.Special.reset,
-    PrintColors.FG.blue + "Py" + PrintColors.Special.reset,
+    PrintColors.FG.blue + "Py",
     "-",
     " ".join(args)
   )

src/python/py_websocket.py

@@ -1,8 +1,10 @@
 import websockets
 import asyncio
+import json
 
 from macros import py_print
 import bot as botPy
+import data
 
 ws_global = None
 is_connected = False
@@ -23,9 +25,37 @@ async def websocket_client(bot: botPy.Bot):
     while True:
       response = await ws.recv()
       py_print(f"Received from Rust: {response}")
+      parse_json(response, bot)
+
+
+def parse_json(response: str, bot: botPy.Bot):
+  if response.startswith("json:"):
+    json_str = response[5:]
+    try:
+      json_response = json.loads(json_str)
+      json_to_func(json_response, bot)
+    except json.JSONDecodeError as e:
+      if bot.args["dev"]: py_print(f"failed to parse json: {json_str}\n     reason: {e}")
 
 
 def run_thread(bot: botPy.Bot):
   loop = asyncio.new_event_loop()
   asyncio.set_event_loop(loop)
-  loop.run_until_complete(websocket_client(bot))
+  loop.run_until_complete(websocket_client(bot))
+
+
+def json_to_func(v: dict, bot: botPy.Bot):
+  if "type" not in v or "value" not in v or not isinstance(v, dict):
+    if bot.args["dev"]: py_print("JSON is not a dictionary or does not include \"type\" and \"value\" keys.")
+    return
+  if v["type"] != "function":
+    if bot.args["dev"]: py_print(f"Type \"{v['type']}\" is not supported.")
+    return
+
+  value_supported = True
+  match v["value"]:
+    case "update_data_file": data.write_data(bot)
+    case _: value_supported = False
+
+  if bot.args["dev"] and not value_supported:
+    print(f"Value {v['value']} is not supported")

src/websocket.rs

@@ -4,6 +4,7 @@ use tokio::net::TcpListener;
 use tokio_tungstenite::{accept_async, tungstenite};
 use futures::StreamExt;
 use std::sync::Arc;
+use serde_json::Value;
 
 use crate::rs_println;
 use crate::Args;
@@ -33,6 +34,22 @@ pub async fn send_msg(msg: &str) {
 }
 
 
+pub async fn send_cmd_json(func_name: &str, func_args: Value) {
+  unsafe {
+    if let Some(sender) = &GLOBAL_SENDER {
+      let mut sender = sender.lock().await;
+      if let Some(s) = sender.as_mut() {
+        let json_str: String = format!(
+          "json:{{\"type\": \"function\", \"value\":\"{}\", \"args\": {}}}",
+          func_name, func_args
+        );
+        s.send(tungstenite::Message::Text(json_str.into())).await.unwrap();
+      }
+    }
+  }
+}
+
+
 pub async fn start(args: Args) {
   rs_println!("Starting local websocket...");
   let ip = format!("127.0.0.1:{}", args.port);