creddy/src-tauri/src/config.rs

use std::net::Ipv4Addr;
use std::path::PathBuf;

use auto_launch::AutoLaunchBuilder;
use serde::{Serialize, Deserialize};
use sqlx::SqlitePool;

use crate::errors::*;


#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct AppConfig {
    #[serde(default = "default_listen_addr")]
    pub listen_addr: Ipv4Addr,
    #[serde(default = "default_listen_port")]
    pub listen_port: u16,
    #[serde(default = "default_rehide_ms")]
    pub rehide_ms: u64,
    #[serde(default = "default_start_minimized")]
    pub start_minimized: bool,
    #[serde(default = "default_start_on_login")]
    pub start_on_login: bool,
}


impl Default for AppConfig {
    fn default() -> Self {
        AppConfig {
            listen_addr: default_listen_addr(),
            listen_port: default_listen_port(),
            rehide_ms: default_rehide_ms(),
            start_minimized: default_start_minimized(),
            start_on_login: default_start_on_login(),
        }
    }
}


impl AppConfig {
    pub async fn load(pool: &SqlitePool) -> Result<AppConfig, SetupError> {
        let res = sqlx::query!("SELECT * from config where name = 'main'")
            .fetch_optional(pool)
            .await?;

        let row = match res {
            Some(row) => row,
            None => return Ok(AppConfig::default()),
        };

        Ok(serde_json::from_str(&row.data)?)
    }

    pub async fn save(&self, pool: &SqlitePool) -> Result<(), sqlx::error::Error> {
        let data = serde_json::to_string(self).unwrap();
        sqlx::query(
            "INSERT INTO config (name, data) VALUES ('main', ?)
            ON CONFLICT (name) DO UPDATE SET data = ?"
        )
            .bind(&data)
            .bind(&data)
            .execute(pool)
            .await?;

        Ok(())
    }
}


pub fn set_auto_launch(is_configured: bool) -> Result<(), SetupError> {
    let path_buf = std::env::current_exe()
        .map_err(|e| auto_launch::Error::Io(e))?;
    let path = path_buf
        .to_string_lossy();

    let auto = AutoLaunchBuilder::new()
        .set_app_name("Creddy")
        .set_app_path(&path)
        .build()?;

    let is_enabled = auto.is_enabled()?;
    if is_configured && !is_enabled {
        auto.enable()?;
    }
    else if !is_configured && is_enabled {
        auto.disable()?;
    }

    Ok(())
}


pub fn get_or_create_db_path() -> Result<PathBuf, DataDirError> {
    // debug_assertions doesn't always mean we are running in dev
    if cfg!(debug_assertions) && std::env::var("HOME").is_ok() {
        return Ok(PathBuf::from("./creddy.db"));
    }

    let mut path = dirs::data_dir()
        .ok_or(DataDirError::NotFound)?;

    std::fs::create_dir_all(&path)?;
    path.push("creddy.db");

    Ok(path)
}


fn default_listen_port() -> u16 {
    if cfg!(debug_assertions) {
        12_345
    }
    else {
        19_923
    }
}

fn default_listen_addr() -> Ipv4Addr { Ipv4Addr::LOCALHOST }
fn default_rehide_ms() -> u64 { 1000 }
// start minimized and on login only in production mode
fn default_start_minimized() -> bool { !cfg!(debug_assertions) }
fn default_start_on_login() -> bool { !cfg!(debug_assertions) }