create foobert prototype

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "foobert"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0.95"
+matrix-sdk = "0.9.0"
+rumqttc = "0.24.0"
+tokio = { version = "1.43.0", features = ["macros", "rt-multi-thread"] } 
+tracing-subscriber = "0.3.19"
+

src/main.rs

@@ -0,0 +1,102 @@
+use std::{env, process::exit};
+
+use matrix_sdk::{
+    config::SyncSettings,
+    ruma::events::room::message::{
+        MessageType, OriginalSyncRoomMessageEvent, RoomMessageEventContent,
+    },
+    Client, Room, RoomState,
+};
+
+use rumqttc::{MqttOptions, AsyncClient, QoS};
+use std::time::Duration;
+use std::thread;
+
+async fn on_room_message(event: OriginalSyncRoomMessageEvent, room: Room) {
+    if room.state() != RoomState::Joined {
+        return;
+    }
+    let MessageType::Text(text_content) = event.content.msgtype else {
+        return;
+    };
+
+    if text_content.body.contains("!party") {
+
+        // mosquitto_pub -h mqtt.chaospott.de -t foobar/oben/licht -m "baellebad,100"
+
+        let mut mqttoptions = MqttOptions::new("rumqtt-sync", "mqtt.chaospott.de", 1883);
+        mqttoptions.set_keep_alive(Duration::from_secs(5));
+
+        let (mut client, mut eventloop) = AsyncClient::new(mqttoptions, 10);
+
+        if let Ok(resp) = client.publish("foobert/willwas", QoS::AtLeastOnce, false, vec![3; 3]).await {
+            println!("{:?}", resp)
+        }
+        else { println!("fuckit") }
+
+        let content = RoomMessageEventContent::text_plain("🎉🎊🥳 let's PARTY!! 🥳🎊🎉");
+
+        println!("sending");
+
+        // send our message to the room we found the "!party" command in
+        room.send(content).await.unwrap();
+
+        println!("message sent");
+    }
+}
+
+async fn login_and_sync(
+    homeserver_url: String,
+    username: String,
+    password: String,
+) -> anyhow::Result<()> {
+    // Note that when encryption is enabled, you should use a persistent store to be
+    // able to restore the session with a working encryption setup.
+    // See the `persist_session` example.
+    let client = Client::builder().homeserver_url(homeserver_url).build().await.unwrap();
+    client
+        .matrix_auth()
+        .login_username(&username, &password)
+        .initial_device_display_name("command bot")
+        .await?;
+
+    println!("logged in as {username}");
+
+    // An initial sync to set up state and so our bot doesn't respond to old
+    // messages.
+    let response = client.sync_once(SyncSettings::default()).await.unwrap();
+    // add our CommandBot to be notified of incoming messages, we do this after the
+    // initial sync to avoid responding to messages before the bot was running.
+    client.add_event_handler(on_room_message);
+
+    // since we called `sync_once` before we entered our sync loop we must pass
+    // that sync token to `sync`
+    let settings = SyncSettings::default().token(response.next_batch);
+    // this keeps state from the server streaming in to CommandBot via the
+    // EventHandler trait
+    client.sync(settings).await?;
+
+    Ok(())
+}
+
+
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt::init();
+
+    let (homeserver_url, username, password) =
+        match (env::args().nth(1), env::args().nth(2), env::args().nth(3)) {
+            (Some(a), Some(b), Some(c)) => (a, b, c),
+            _ => {
+                eprintln!(
+                    "Usage: {} <homeserver_url> <username> <password>",
+                    env::args().next().unwrap()
+                );
+                exit(1)
+            }
+        };
+
+    login_and_sync(homeserver_url, username, password).await?;
+    Ok(())
+}