Added simple dump and stats commands.

Author: rxw1

Cargo.toml

@@ -6,7 +6,7 @@ version = "0.3.1"
 readme = "README.md"
 description = "Session Buddy Helper"
 homepage = "https://www.asdf.cx/sbh"
-authors = ["René Wilhelm <[email protected]>"]
+authors = ["René <[email protected]>"]
 keywords = ["chrome", "extension", "cli"]
 repository = "https://github.com/rxw1/sbh"
 categories = ["command-line-utilities"]

src/args/mod.rs renamed to src/args.rs

@@ -11,6 +11,20 @@ pub struct Args {
 
 #[derive(Subcommand, Debug)]
 pub enum Action {
+    /// Dump database to stdout
+    Dump {
+        /// Dump all URLs
+        #[arg()]
+        path: PathBuf
+    },
+
+    /// Print database statistics
+    Stats {
+        /// Path to search for databases
+        #[arg()]
+        path: PathBuf
+    },
+
     /// Search for Session Buddy databases and print out their path
     Search {
         /// Path to search for databases
@@ -22,7 +36,7 @@ pub enum Action {
     Backup {
         /// Database to backup
         #[arg(value_name = "DATABASE")]
-        db: PathBuf,
+        path: PathBuf,
 
         /// Output <FILENAME>
         #[arg(short, long, value_name = "FILENAME")]
@@ -33,7 +47,7 @@ pub enum Action {
     Import {
         /// Path to the database where the data should be imported to
         #[arg(short, long)]
-        database: PathBuf,
+        path: PathBuf,
 
         /// File that should be imported. Can be a JSON file exported
         /// by the Session Buddy extension or another database

src/main.rs

@@ -1,4 +1,6 @@
 use clap::Parser;
+use sbh::session_buddy::settings::get_datetime_value_setting;
+use sbh::session_buddy::settings::get_string_value_setting;
 use serde::ser::StdError;
 
 use log::{error, info};
@@ -10,7 +12,50 @@ async fn main() -> Result<(), Box<dyn StdError>> {
     pretty_env_logger::init();
     let args = Args::parse();
     match args.action {
-        Action::Backup { db, out } => match database::backup(&db, out).await {
+        Action::Dump { path } => {
+            for session in database::saved_sessions(&path).await? {
+                for window in session.windows.iter() {
+                    match &window.tabs {
+                        Some(tabs) => {
+                            for tab in tabs.iter() {
+                                match &tab.url {
+                                    Some(url) => {
+                                        println!("{}", url);
+                                    }
+                                    None => {}
+                                }
+                            }
+                        }
+                        None => {}
+                    }
+                }
+            }
+        }
+
+        Action::Stats { path } => {
+            let installation_id =
+                get_string_value_setting(&path, "Settings", "installationID").await?;
+
+            let installation_date =
+                get_datetime_value_setting(&path, "Settings", "installationTimeStamp").await?;
+
+            let sessions = database::saved_sessions(&path).await?;
+
+            let session_count = sessions.len();
+
+            let window_count: i32 = sessions.iter().map(|s| s.count_windows()).sum();
+
+            let tab_count: i32 = sessions.iter().map(|s| s.count_tabs()).sum();
+
+            println!("Path:              {}", path.display());
+            println!("Installation ID:   {}", installation_id);
+            println!("Installation Date: {}", installation_date);
+            println!("Tabs:              {:>5}", tab_count);
+            println!("Windows:           {:>5}", window_count);
+            println!("Sessions:          {:>5}", session_count);
+        }
+
+        Action::Backup { path, out } => match database::backup(&path, out).await {
             Ok(_) => {
                 info!("Database created");
             }
@@ -37,26 +82,24 @@ async fn main() -> Result<(), Box<dyn StdError>> {
             }
         }
 
-        Action::Import { database, files } => {
-            match database::collect_saved_sessions(&files).await {
-                Ok(sessions) => {
-                    let mut conn = database::connect(&database).await?;
-                    match database::import(&mut conn, &sessions).await {
-                        Ok(()) => {
-                            info!("Imported {} sessions", sessions.len());
-                        }
-                        Err(e) => {
-                            error!("{:?}", e);
-                            std::process::exit(1)
-                        }
-                    };
-                }
-                Err(e) => {
-                    error!("{:?}", e);
-                    std::process::exit(1)
-                }
+        Action::Import { path, files } => match database::collect_saved_sessions(&files).await {
+            Ok(sessions) => {
+                let mut conn = database::connect(&path).await?;
+                match database::import(&mut conn, &sessions).await {
+                    Ok(()) => {
+                        info!("Imported {} sessions", sessions.len());
+                    }
+                    Err(e) => {
+                        error!("{:?}", e);
+                        std::process::exit(1)
+                    }
+                };
             }
-        }
+            Err(e) => {
+                error!("{:?}", e);
+                std::process::exit(1)
+            }
+        },
 
         Action::New { path } => match database::create(&path).await {
             Ok(result) => {

src/session_buddy/backup.rs

@@ -6,7 +6,7 @@ use serde::ser::StdError;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::session_buddy::session::get_saved_sessions;
+use crate::session_buddy::database;
 use crate::session_buddy::session::SavedSession;
 use crate::session_buddy::settings::get_datetime_value_setting;
 use crate::session_buddy::settings::get_string_value_setting;
@@ -75,7 +75,7 @@ impl Backup {
 
         // Saved sessions
         self.sessions.extend(
-            get_saved_sessions(db)
+            database::saved_sessions(db)
                 .await?
                 //.iter()
                 //.map(SavedSession::from)

src/session_buddy/database.rs

@@ -4,6 +4,7 @@ use std::io::{BufWriter, Write};
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 
+use chrono::{DateTime, Utc};
 use log::info;
 use serde::ser::StdError;
 use sqlx::sqlite::{SqliteConnectOptions, SqliteQueryResult};
@@ -13,11 +14,37 @@ use crate::chrome::get_path;
 use crate::util::get_output_filename;
 
 use super::backup::Backup;
-use super::session::SavedSession;
+use super::session::{PreviousSession, SavedSession};
 
 // Key "tags" is present on SavedSessions in the database
 // but not in JSON backups. Not ok.
 
+#[derive(Default)]
+pub struct Stats {
+    pub sessions: i32,
+    pub tabs: i32,
+    pub windows: i32,
+    pub created: DateTime<Utc>,
+    pub modified: DateTime<Utc>,
+    pub atime: DateTime<Utc>,
+    pub mtime: DateTime<Utc>,
+    pub ctime: DateTime<Utc>,
+    pub newest_session: DateTime<Utc>,
+    pub oldest_session: DateTime<Utc>,
+    pub duplicate_urls: i32
+}
+
+//struct SessionStats {}
+//struct TabStats {}
+
+pub async fn stats(path: &Path) -> Result<Stats, Box<dyn StdError>> {
+    let backup = Backup::new(path).await?;
+    println!("{}", serde_json::to_string(&backup).unwrap());
+    Ok(Stats {
+        ..Default::default()
+    })
+}
+
 /// Get a new connection to a SQLite database.
 pub async fn connect(filename: &Path) -> Result<SqliteConnection, sqlx::Error> {
     SqliteConnectOptions::from_str(format!("sqlite://{}", filename.display()).as_str())?
@@ -196,6 +223,27 @@ pub async fn search(basepath: Option<PathBuf>) -> Result<Vec<PathBuf>, Box<dyn E
     Ok(dbs)
 }
 
+
+pub async fn saved_sessions(db: &Path) -> Result<Vec<SavedSession>, Box<dyn StdError>> {
+    let mut conn = connect(db).await?;
+
+    Ok(
+        sqlx::query_as::<_, SavedSession>("SELECT * FROM SavedSessions")
+            .fetch_all(&mut conn)
+            .await?
+    )
+}
+
+pub async fn previous_sessions(db: &Path) -> Result<Vec<PreviousSession>, Box<dyn StdError>> {
+    let mut conn = connect(db).await?;
+
+    Ok(
+        sqlx::query_as::<_, PreviousSession>("SELECT * FROM PreviousSessions")
+            .fetch_all(&mut conn)
+            .await?
+    )
+}
+
 const SCHEMA: &str = r#"
 CREATE TABLE Settings (
     key TEXT PRIMARY KEY,

src/session_buddy/session.rs

@@ -1,16 +1,11 @@
-use sqlx::types::JsonValue;
 use std::convert::From;
-use std::path::Path;
 
-use log::warn;
-use serde::ser::StdError;
 use serde::Deserialize;
 use serde::Serialize;
 use sqlx::types::chrono::DateTime;
 use sqlx::types::chrono::Utc;
 use sqlx::types::Json;
-use sqlx::Connection;
-use sqlx::SqliteConnection;
+use sqlx::types::JsonValue;
 
 use crate::chrome::window::Window;
 
@@ -31,9 +26,12 @@ pub struct SavedSession {
 
     // Key "gid" is present on SavedSessions in JSON exports but not in the database. Skip when
     // running INSERT statements on the database.
-    pub gid: String,
+    #[sqlx(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub gid: Option<String>,
 
     // Key "type" is present on SavedSession in JSON exports but not in the database. Actually ok.
+    #[sqlx(default, rename = "type")]
     #[serde(rename = "type")]
     pub type_: String,
 
@@ -79,6 +77,11 @@ pub struct SavedSession {
     pub filtered_tab_count: i32
 }
 
+//impl From<&Path> for Vec<SavedSession> {
+//    fn from(s: &Path) {
+//    }
+//}
+
 impl SavedSession {
     // TODO Implement functions for filtered window/tab count
 
@@ -124,35 +127,3 @@ pub struct PreviousSession {
     unfiltered_tab_count: i32,
     filtered_tab_count: i32
 }
-
-// TODO Dry up
-
-pub async fn get_saved_sessions(db: &Path) -> Result<Vec<SavedSession>, Box<dyn StdError>> {
-    if !db.exists() {
-        warn!("Database file not found");
-        std::process::exit(1)
-    }
-
-    let mut conn = SqliteConnection::connect(db.to_str().expect("[102] BAD DB PATH")).await?;
-
-    Ok(
-        sqlx::query_as::<_, SavedSession>("SELECT * FROM SavedSessions")
-            .fetch_all(&mut conn)
-            .await?
-    )
-}
-
-pub async fn get_previous_sessions(db: &Path) -> Result<Vec<PreviousSession>, Box<dyn StdError>> {
-    if !db.exists() {
-        warn!("Database file not found");
-        std::process::exit(1)
-    }
-
-    let mut conn = SqliteConnection::connect(db.to_str().expect("[382] BAD DB PATH")).await?;
-
-    Ok(
-        sqlx::query_as::<_, PreviousSession>("SELECT * FROM PreviousSessions")
-            .fetch_all(&mut conn)
-            .await?
-    )
-}