config store & event loop with reconn

src/main.rs

@@ -1,33 +1,97 @@
+#![deny(unused_must_use)]
+
 #[macro_use]
 extern crate log;
 #[macro_use]
 extern crate smart_default;
 #[macro_use]
 extern crate serde;
+#[macro_use]
+extern crate thiserror;
 extern crate elefren;
 
-use elefren::prelude::*;
-use elefren::helpers::{cli, toml};
 use elefren::entities::event::Event;
 use log::LevelFilter;
 use elefren::entities::notification::NotificationType;
 use elefren::entities::account::Account;
 use elefren::status_builder::Visibility;
+use elefren::{Registration, Scopes, StatusBuilder, FediClient};
+use tokio_stream::{Stream, StreamExt};
+use elefren::scopes;
+use crate::store::{NewGroupOptions, StoreOptions};
+use elefren::debug::NotificationDisplay;
 
-fn main() -> anyhow::Result<()> {
-    simple_logging::log_to_stderr(LevelFilter::Trace);
+mod store;
+mod group_handle;
+mod utils;
 
-    let client = if let Ok(data) = toml::from_file("group-actor-data.toml") {
-        Mastodon::from(data)
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    env_logger::Builder::new()
+        .filter_level(LevelFilter::Debug)
+        .write_style(env_logger::WriteStyle::Always)
+        .filter_module("rustls", LevelFilter::Warn)
+        .filter_module("reqwest", LevelFilter::Warn)
+        .init();
+
+    let store = store::ConfigStore::new(StoreOptions {
+        store_path: "groups.json".to_string(),
+        save_pretty: true
+    }).await?;
+
+    /*
+    let mut new_group = store.auth_new_group(NewGroupOptions {
+        server: "https://botsin.space".to_string(),
+        acct: "betty@botsin.space".to_string()
+    }).await?;
+    // */
+
+    let mut groups = store.spawn_groups().await;
+    //groups.push(new_group);
+
+
+/*
+    let mut betty = groups.remove(0);
+
+    let notifications = betty.client.notifications().await?;
+    let mut iter = notifications.items_iter();
+
+    let mut num = 0;
+    while let Some(n) = iter.next_item().await {
+        debug!("A notification: {}", NotificationDisplay(&n));
+        num += 1;
+        if num > 10 {
+            break;
+        }
+    }
+
+    return Ok(());
+    */
+
+    let mut handles = vec![];
+
+    for mut g in groups {
+        handles.push(tokio::spawn(async move {
+            g.run().await
+        }));
+    }
+
+    futures::future::join_all(handles).await;
+
+    /*
+
+    let client = if let Ok(data) = elefren::helpers::toml::from_file("group-actor-data.toml") {
+        FediClient::from(data)
     } else {
-        register()?
+        register().await?
     };
 
-    let you = client.verify_credentials()?;
-
+    let you = client.verify_credentials().await?;
     println!("{:#?}", you);
 
-    for event in client.streaming_user()? {
+    let mut events = client.streaming_user().await?;
+
+    while let Some(event) = events.next().await {
         match event {
             Event::Update(status) => {
                 info!("Status: {:?}", status);
@@ -36,6 +100,7 @@ fn main() -> anyhow::Result<()> {
                 info!("Notification: {:?}", notification.notification_type);
                 debug!("{:?}", notification);
 
+                /*
                 match notification.notification_type {
                     NotificationType::Mention => {
                         if let Some(status) = notification.status {
@@ -72,10 +137,11 @@ fn main() -> anyhow::Result<()> {
                             .visibility(Visibility::Unlisted)
                             .build().expect("error build status");
 
-                        let _ = client.new_status(post);
+                        let _ = client.new_status(post).await;
                     }
                     _ => {}
                 }
+                */
             },
             Event::Delete(id) => {
                 info!("Delete: {}", id);
@@ -87,24 +153,29 @@ fn main() -> anyhow::Result<()> {
         }
     }
 
+    */
+
     println!("Main loop ended!");
 
     Ok(())
 }
 
-fn register() -> anyhow::Result<Mastodon> {
+/*
+async fn register() -> anyhow::Result<FediClient> {
     let registration = Registration::new("https://piggo.space")
         .client_name("group-actor")
-        .scopes(Scopes::all())
-        .build()?;
-    let client = cli::authenticate(registration)?;
-    toml::to_file(&*client, "group-actor-data.toml")?;
+        .force_login(true)
+        .scopes(
+            Scopes::read(scopes::Read::Accounts)
+                | Scopes::read(scopes::Read::Notifications)
+                | Scopes::read(scopes::Read::Statuses)
+                | Scopes::read(scopes::Read::Follows)
+                | Scopes::write(scopes::Write::Statuses)
+                | Scopes::write(scopes::Write::Media)
+        )
+        .build().await?;
+    let client = elefren::helpers::cli::authenticate(registration).await?;
+    elefren::helpers::toml::to_file(&*client, "group-actor-data.toml")?;
     Ok(client)
 }
-
-fn make_mention(user : &Account) -> String {
-    format!(r#"<span class="h-card"><a class="u-url mention" data-user="{id}" href="{url}" rel="ugc">@<span>{handle}</span></a></span>"#,
-            id=user.id,
-            url=user.url, handle=user.acct
-    )
-}
+*/