static_files.rs

use crate::app_state::AppState;
use std::path::PathBuf;

pub struct StaticFilesManager {
    dir: PathBuf,
    index: Vec<String>,
}

impl StaticFilesManager {
    fn create_dir_if_missing(app_dir: &PathBuf) -> Result<PathBuf, String> {
        let static_dir = app_dir.join("static");

        if !static_dir.exists() {
            match std::fs::create_dir_all(&static_dir) {
                Ok(_) => {
                    if let Err(err) = Self::copy_default(&static_dir) {
                        return Err(format!("{}", err));
                    }
                }
                Err(err) => return Err(format!("{}", err)),
            }
        }

        Ok(static_dir)
    }

    fn copy_default(static_dir: &PathBuf) -> Result<(), String> {
        let local_default_static = std::env::current_dir().unwrap().join("default_static");
        let default_static = static_dir.join("default");
        match std::fs::create_dir_all(&default_static) {
            Err(err) => Err(format!("{}", err)),
            Ok(_) => {
                let mut copy_default_options = fs_extra::dir::CopyOptions::new();
                copy_default_options.content_only = true;
                match fs_extra::dir::copy(
                    local_default_static,
                    default_static,
                    &copy_default_options,
                ) {
                    Err(err) => Err(format!("{}", err)),
                    Ok(_) => Ok(()),
                }
            }
        }
    }

    pub fn new(app_state: &AppState) -> Result<Self, String> {
        match Self::create_dir_if_missing(&app_state.config.storage_dir) {
            Ok(dir) => Ok(StaticFilesManager {
                index: Vec::new(),
                dir,
            }),
            Err(msg) => Err(msg),
        }
    }

    pub fn build_index(&mut self) -> Result<(), String> {
        self.index.push("TODO".to_string());
        Ok(())
    }
}