mrsbfh

Matrix-Rust-SDK-Bot-Framework-Helper
git clone git://archive.git.mtrnord.blog/MTRNord/mrsbfh.git
Log | Files | Refs | README

mod.rs (2817B)

      1 use crate::config::Config;
      2 use matrix_sdk::{Client, ClientConfig, Session as SDKSession, SyncSettings};
      3 use mrsbfh::url::Url;
      4 use mrsbfh::utils::Session;
      5 use std::{convert::TryFrom, error::Error, fs, path::Path, sync::Arc};
      6 use tokio::sync::Mutex;
      7 use tracing::*;
      8 
      9 mod sync;
     10 
     11 pub async fn setup(config: Config<'_>) -> Result<Client, Box<dyn Error>> {
     12     info!("Beginning Matrix Setup");
     13     let store_path_string = config.store_path.to_string();
     14     let store_path = Path::new(&store_path_string);
     15     if !store_path.exists() {
     16         fs::create_dir_all(store_path)?;
     17     }
     18     let client_config = ClientConfig::new().store_path(fs::canonicalize(&store_path)?);
     19 
     20     let homeserver_url =
     21         Url::parse(&config.homeserver_url).expect("Couldn't parse the homeserver URL");
     22 
     23     let client = Client::new_with_config(homeserver_url, client_config).unwrap();
     24 
     25     if let Some(session) = Session::load(config.session_path.parse().unwrap()) {
     26         info!("Starting relogin");
     27 
     28         let session = SDKSession {
     29             access_token: session.access_token,
     30             device_id: session.device_id.into(),
     31             user_id: matrix_sdk::ruma::UserId::try_from(session.user_id.as_str()).unwrap(),
     32         };
     33 
     34         if let Err(e) = client.restore_login(session).await {
     35             error!("{}", e);
     36         };
     37         info!("Finished relogin");
     38     } else {
     39         info!("Starting login");
     40         let login_response = client
     41             .login(
     42                 &config.mxid,
     43                 &config.password,
     44                 None,
     45                 Some(&"timetracking-bot".to_string()),
     46             )
     47             .await;
     48         match login_response {
     49             Ok(login_response) => {
     50                 info!("Session: {:#?}", login_response);
     51                 let session = Session {
     52                     homeserver: client.homeserver().await.to_string(),
     53                     user_id: login_response.user_id.to_string(),
     54                     access_token: login_response.access_token,
     55                     device_id: login_response.device_id.into(),
     56                 };
     57                 session.save(config.session_path.parse().unwrap())?;
     58             }
     59             Err(e) => error!("Error while login: {}", e),
     60         }
     61         info!("Finished login");
     62     }
     63 
     64     info!("logged in as {}", config.mxid);
     65 
     66     Ok(client)
     67 }
     68 
     69 pub async fn start_sync(
     70     client: &mut Client,
     71     config: Config<'static>,
     72 ) -> Result<(), Box<dyn Error>> {
     73     client.register_event_handler(mrsbfh::sync::autojoin).await;
     74 
     75     let config = Arc::new(Mutex::new(config));
     76     client
     77         .register_event_handler(move |ev, room, client| {
     78             sync::on_room_message(ev, room, client, config.clone())
     79         })
     80         .await;
     81 
     82     info!("Starting full Sync...");
     83     client.sync(SyncSettings::default()).await;
     84 
     85     Ok(())
     86 }