136 lines
3.7 KiB
Rust
136 lines
3.7 KiB
Rust
use anyhow::{Context, Result};
|
|
use std::fs::File;
|
|
use std::io::prelude::*;
|
|
use std::path::PathBuf;
|
|
use structopt::StructOpt;
|
|
|
|
use ibis::config::{ListOptions, CONFIG};
|
|
use ibis::courses::{Course, Meeting};
|
|
use ibis::{rofi, util};
|
|
|
|
#[derive(StructOpt)]
|
|
struct Cli {
|
|
#[structopt(short, long)]
|
|
debug: bool,
|
|
#[structopt(subcommand)]
|
|
cmd: Command,
|
|
}
|
|
|
|
#[derive(StructOpt)]
|
|
enum Command {
|
|
ShowConfig,
|
|
#[structopt(name = "show")]
|
|
ShowCurrentCourse,
|
|
ListCourses(ListOptions),
|
|
ListLectures(ListOptions),
|
|
SelectCourse(ListOptions),
|
|
SelectLecture,
|
|
AddCourse(Course),
|
|
AddMeeting(Meeting),
|
|
AddLecture,
|
|
Init,
|
|
Check(ListOptions),
|
|
Meetings(ListOptions),
|
|
}
|
|
|
|
#[derive(StructOpt)]
|
|
struct NewMeeting {}
|
|
|
|
// #[derive(StructOpt)]
|
|
// struct ObjectStruct {
|
|
// #[structopt(subcommand)]
|
|
// object: Option<Object>,
|
|
// }
|
|
#[derive(StructOpt, Debug)]
|
|
enum Object {
|
|
Courses,
|
|
Lectures,
|
|
}
|
|
|
|
fn main() -> Result<()> {
|
|
let args = Cli::from_args();
|
|
match args.cmd {
|
|
Command::ListCourses(options) => {
|
|
for c in Course::list(&options)?.iter() {
|
|
println!("{}", c);
|
|
}
|
|
}
|
|
Command::ListLectures(options) => {
|
|
for l in list_lectures(options)? {
|
|
println!("{:?}", l);
|
|
}
|
|
}
|
|
Command::AddCourse(course) => add(course, args.debug)?,
|
|
Command::AddLecture => (),
|
|
Command::SelectCourse(options) => rofi::select_course(&options)?,
|
|
Command::SelectLecture => (),
|
|
Command::Init => (),
|
|
Command::Check(list_options) => Course::check(&list_options)?,
|
|
Command::Meetings(options) => rofi::select_meeting(&options)?,
|
|
Command::ShowConfig => println!("{:?}", *CONFIG),
|
|
Command::AddMeeting(_meeting) => (),
|
|
Command::ShowCurrentCourse => println!("{:?}", Course::current()),
|
|
//Course::current().meetings.push(meeting),
|
|
};
|
|
Ok(())
|
|
}
|
|
|
|
fn add(mut course: Course, debug: bool) -> Result<()> {
|
|
if course.semesters().is_empty() {
|
|
course.semesters_mut().push(util::get_current_semester())
|
|
}
|
|
let toml = toml::to_string(&course)?;
|
|
println!("{}", toml);
|
|
let target_dir = [
|
|
CONFIG
|
|
.files_root
|
|
.canonicalize()?
|
|
.to_str()
|
|
.expect("I hate paths"), // TODO
|
|
"/",
|
|
util::to_snail_case(&course.name).as_ref(),
|
|
]
|
|
.concat();
|
|
let toml_path = PathBuf::from([&target_dir, "/course.toml"].concat());
|
|
if !(cfg!(debug_assertions) || debug) {
|
|
if !CONFIG.files_root.is_dir() {
|
|
std::fs::create_dir_all(CONFIG.files_root.canonicalize().with_context(|| {
|
|
format!("The root path {:?} seems malformed", CONFIG.files_root)
|
|
})?)?;
|
|
}
|
|
if !PathBuf::from(&target_dir).is_dir() {
|
|
std::fs::create_dir_all(&target_dir)?;
|
|
} else {
|
|
panic!("Folder {} already exists!", &target_dir);
|
|
}
|
|
let mut toml_handle = File::create(&toml_path).unwrap();
|
|
write!(toml_handle, "{}", toml).unwrap();
|
|
println!("Created files!")
|
|
}
|
|
println!("Path was {:?}", &toml_path);
|
|
Ok(())
|
|
}
|
|
|
|
fn list_lectures(options: ListOptions) -> Result<Vec<PathBuf>> {
|
|
let lectures = util::glob_paths(
|
|
if options.all {
|
|
&CONFIG.files_root
|
|
} else {
|
|
&CONFIG.link_path
|
|
},
|
|
"/**/lecture*",
|
|
);
|
|
|
|
let lectures = lectures?
|
|
.into_iter()
|
|
.filter(|path| {
|
|
if let Some(ext) = path.extension() {
|
|
let ext = ext.to_owned().to_string_lossy().into();
|
|
CONFIG.note_extensions.contains(&ext)
|
|
} else {
|
|
false
|
|
}
|
|
})
|
|
.collect();
|
|
Ok(lectures)
|
|
}
|