Init

aoc-helper/src/cookies/session.rs

@@ -0,0 +1,78 @@
+use diesel::prelude::*;
+use diesel::{ConnectionResult, SqliteConnection};
+use log::debug;
+use std::path::Path;
+use std::{env, fmt, fs, io};
+
+use super::model::Cookies;
+
+pub const CONFIG_DIR: &str = ".config/aoc-helper";
+pub const SESSION_FILE: &str = "session";
+
+#[derive(Debug)]
+pub enum SessionError {
+    Connection(diesel::result::ConnectionError),
+    Query(diesel::result::Error),
+    NotFound,
+}
+
+impl From<diesel::result::ConnectionError> for SessionError {
+    fn from(value: diesel::result::ConnectionError) -> Self {
+        Self::Connection(value)
+    }
+}
+
+impl From<diesel::result::Error> for SessionError {
+    fn from(value: diesel::result::Error) -> Self {
+        Self::Query(value)
+    }
+}
+
+impl fmt::Display for SessionError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        match self {
+            Self::Connection(e) => write!(f, "connection to database error: {e}"),
+            Self::Query(e) => write!(f, "query database error: {e}"),
+            Self::NotFound => write!(f, "'.adventofcode.com' session not found"),
+        }
+    }
+}
+
+fn connect_database<P: AsRef<Path>>(path: P) -> ConnectionResult<SqliteConnection> {
+    let database_url = path.as_ref().to_str().unwrap();
+    SqliteConnection::establish(database_url)
+}
+
+pub fn retrieve_session<P: AsRef<Path>>(path: P) -> Result<String, SessionError> {
+    use super::schema::moz_cookies::dsl::{host, moz_cookies, name};
+
+    let mut conn = connect_database(path)?;
+    debug!("connected to database");
+
+    let records = moz_cookies
+        .filter(host.eq(".adventofcode.com"))
+        .filter(name.eq("session"))
+        .limit(1)
+        .load::<Cookies>(&mut conn)?;
+
+    debug!("retrieved: {} record", records.len());
+    if !records.is_empty() {
+        let session = &records[0];
+        session
+            .value
+            .to_owned()
+            .ok_or_else(|| SessionError::NotFound)
+    } else {
+        Err(SessionError::NotFound)
+    }
+}
+
+pub fn write_session_to_file(session: &str, filename: &str) -> io::Result<()> {
+    let home_path = env::home_dir().unwrap();
+    let config_dir_path = home_path.join(CONFIG_DIR);
+    if !fs::exists(&config_dir_path)? {
+        fs::create_dir(&config_dir_path)?;
+    }
+    fs::write(config_dir_path.join(filename), session)?;
+    Ok(())
+}