254 lines
7.1 KiB
Rust
254 lines
7.1 KiB
Rust
use crate::database;
|
|
use crate::structures::{Bookmark, Container, ContainerTypes, Keyspace};
|
|
use chrono::Utc;
|
|
use paris::*;
|
|
use serde_json::json;
|
|
use std::env::VarError;
|
|
use std::fs::File;
|
|
use std::io::{BufReader, BufWriter};
|
|
use std::path::PathBuf;
|
|
use url::Url;
|
|
use uuid::Uuid;
|
|
use uuid_simd::UuidExt;
|
|
|
|
use dialoguer::{console::Term, theme::ColorfulTheme, Select};
|
|
|
|
pub fn edit_bookmark(json: bool, url: &Option<Url>, path: Option<PathBuf>) {
|
|
if json {
|
|
println!(
|
|
"{}",
|
|
json!({
|
|
"status": "fail",
|
|
"reason": "unsupported command",
|
|
})
|
|
);
|
|
std::process::exit(exitcode::DATAERR);
|
|
} else {
|
|
match url {
|
|
Some(link) => {
|
|
println!("User selected item :\n{}", link);
|
|
}
|
|
None => match database::get_all(json, path, Keyspace::Bookmarks) {
|
|
Some(bookmarks) => {
|
|
let mut items: Vec<&Url> = Vec::new();
|
|
for i in &bookmarks {
|
|
items.push(&i.link);
|
|
}
|
|
let selection = Select::with_theme(&ColorfulTheme::default())
|
|
.items(&items)
|
|
.default(0)
|
|
.interact_on_opt(&Term::stderr())
|
|
.unwrap();
|
|
|
|
match selection {
|
|
Some(index) => {
|
|
println!(
|
|
"User selected item :\n{}",
|
|
bookmarks[index]
|
|
);
|
|
}
|
|
None => println!("User did not select anything"),
|
|
}
|
|
}
|
|
None => {
|
|
if json {
|
|
println!(
|
|
"{}",
|
|
json!({
|
|
"status": "fail",
|
|
"reason": "an error ocurred in running your command",
|
|
})
|
|
);
|
|
} else {
|
|
warn!("an error ocurred in running your command");
|
|
}
|
|
}
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn add_bookmark(
|
|
url: &Url,
|
|
name: &String,
|
|
description: &Option<String>,
|
|
tags: &Vec<String>,
|
|
json: bool,
|
|
path: Option<PathBuf>,
|
|
) {
|
|
let bookmark = Bookmark {
|
|
link: url.to_owned(),
|
|
label: name.to_string(),
|
|
description: description.to_owned(),
|
|
tags: tags.to_vec(),
|
|
container: None,
|
|
created_at: Utc::now(),
|
|
};
|
|
|
|
database::insert_entry(json, path, Keyspace::Bookmarks, &bookmark);
|
|
if json {
|
|
println!("{}", serde_json::to_string(&bookmark).unwrap());
|
|
} else {
|
|
println!("Added new bookmark!");
|
|
println!("{}", bookmark);
|
|
};
|
|
}
|
|
|
|
pub fn list_bookmarks(json: bool, path: Option<PathBuf>) {
|
|
match database::get_all(json, path, Keyspace::Bookmarks) {
|
|
Some(bookmarks) => {
|
|
for i in bookmarks {
|
|
if json {
|
|
println!(
|
|
"{}",
|
|
serde_json::to_string(&i).unwrap()
|
|
);
|
|
} else {
|
|
println!("{}", &i);
|
|
}
|
|
}
|
|
}
|
|
None => {
|
|
if json {
|
|
println!(
|
|
"{}",
|
|
json!({
|
|
"status": "fail",
|
|
"reason": "an error ocurred in running your command",
|
|
})
|
|
);
|
|
} else {
|
|
warn!("an error ocurred in running your command");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn env_err(json: bool, e: VarError) {
|
|
if json {
|
|
println!(
|
|
"{}",
|
|
json!({
|
|
"status": "fail",
|
|
"reason": e.to_string(),
|
|
})
|
|
);
|
|
} else {
|
|
warn!("couldn't read $HOME environment variable: {}", e);
|
|
}
|
|
}
|
|
|
|
pub fn export(file_path: PathBuf, json: bool, path: Option<PathBuf>) {
|
|
let file = match File::create(&file_path) {
|
|
Ok(f) => f,
|
|
Err(e) => {
|
|
if json {
|
|
println!(
|
|
"{}",
|
|
json!({
|
|
"status": "fail",
|
|
"reason": e.to_string(),
|
|
})
|
|
);
|
|
} else {
|
|
warn!("error opening file! {}", e);
|
|
}
|
|
std::process::exit(exitcode::DATAERR);
|
|
}
|
|
};
|
|
let writer = BufWriter::new(file);
|
|
|
|
match database::get_all(json, path, Keyspace::Bookmarks) {
|
|
Some(bookmarks) => serde_json::to_writer(writer, &bookmarks).unwrap(),
|
|
None => std::process::exit(exitcode::IOERR),
|
|
}
|
|
|
|
if json {
|
|
println!(
|
|
"{}",
|
|
json!({
|
|
"status": "success",
|
|
"reason": format!("exported bookmarks to {}", file_path.to_str().unwrap()),
|
|
})
|
|
);
|
|
} else {
|
|
info!(
|
|
"Succesfully exported bookmarks to {}!",
|
|
file_path.to_str().unwrap()
|
|
);
|
|
}
|
|
}
|
|
|
|
pub fn import(file_path: PathBuf, json: bool, store_path: Option<PathBuf>) {
|
|
let file = match File::open(&file_path) {
|
|
Ok(f) => f,
|
|
Err(e) => {
|
|
if json {
|
|
println!(
|
|
"{}",
|
|
json!({
|
|
"status": "fail",
|
|
"reason": e.to_string(),
|
|
})
|
|
);
|
|
} else {
|
|
warn!("error opening file! {}", e);
|
|
}
|
|
std::process::exit(exitcode::DATAERR);
|
|
}
|
|
};
|
|
let reader = BufReader::new(file);
|
|
|
|
let bookmarks: Vec<Bookmark> = match serde_json::from_reader(reader) {
|
|
Ok(contents) => contents,
|
|
Err(e) => {
|
|
if json {
|
|
println!(
|
|
"{}",
|
|
json!({
|
|
"status": "fail",
|
|
"reason": e.to_string(),
|
|
})
|
|
);
|
|
} else {
|
|
warn!("error serializing file! {}", e);
|
|
}
|
|
std::process::exit(exitcode::DATAERR);
|
|
}
|
|
};
|
|
|
|
database::insert_multiple(&bookmarks, json, store_path, Keyspace::Bookmarks);
|
|
|
|
if json {
|
|
println!(
|
|
"{}",
|
|
json!({
|
|
"status": "success",
|
|
"reason": format!("imported bookmarks from {}", file_path.to_str().unwrap()),
|
|
})
|
|
);
|
|
} else {
|
|
info!(
|
|
"succesfully imported bookmarks from {}!",
|
|
file_path.to_str().unwrap()
|
|
);
|
|
}
|
|
}
|
|
|
|
pub fn new_folder(label: &String, json: bool) {
|
|
let folder = Container {
|
|
id: Uuid::new_v4(),
|
|
label: label.to_string(),
|
|
container: None,
|
|
container_type: ContainerTypes::Folder,
|
|
};
|
|
println!("{:?}", folder);
|
|
if json {
|
|
println!("{}", serde_json::to_string(&folder).unwrap());
|
|
} else {
|
|
println!("{:?}", folder);
|
|
}
|
|
}
|
|
|
|
pub fn create_heirarchy(bookmarks: Vec<Bookmark>, containers: Vec<Container>) {}
|