imag/bin/domain/imag-contact/src/main.rs

357 lines
12 KiB
Rust

//
// imag - the personal information management suite for the commandline
// Copyright (C) 2015-2018 Matthias Beyer <mail@beyermatthias.de> and contributors
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; version
// 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
#![deny(
non_camel_case_types,
non_snake_case,
path_statements,
trivial_numeric_casts,
unstable_features,
unused_allocation,
unused_import_braces,
unused_imports,
unused_must_use,
unused_mut,
unused_qualifications,
while_true,
)]
extern crate clap;
#[macro_use] extern crate log;
#[macro_use] extern crate vobject;
extern crate toml;
extern crate toml_query;
extern crate handlebars;
extern crate walkdir;
extern crate uuid;
extern crate serde_json;
extern crate libimagcontact;
extern crate libimagstore;
#[macro_use] extern crate libimagrt;
extern crate libimagerror;
extern crate libimagutil;
extern crate libimaginteraction;
extern crate libimagentryref;
extern crate libimagentryedit;
use std::process::exit;
use std::path::PathBuf;
use std::io::Write;
use handlebars::Handlebars;
use clap::ArgMatches;
use vobject::vcard::Vcard;
use toml_query::read::TomlValueReadTypeExt;
use walkdir::WalkDir;
use libimagrt::runtime::Runtime;
use libimagrt::setup::generate_runtime_setup;
use libimagerror::str::ErrFromStr;
use libimagerror::trace::MapErrTrace;
use libimagerror::io::ToExitCode;
use libimagerror::exit::ExitUnwrap;
use libimagcontact::store::ContactStore;
use libimagcontact::store::UniqueContactPathGenerator;
use libimagcontact::error::ContactError as CE;
use libimagcontact::contact::Contact;
use libimagcontact::deser::DeserVcard;
use libimagstore::iter::get::StoreIdGetIteratorExtension;
use libimagentryref::reference::Ref;
use libimagentryref::refstore::RefStore;
mod ui;
mod util;
mod create;
use ui::build_ui;
use util::build_data_object_for_handlebars;
use create::create;
fn main() {
let version = make_imag_version!();
let rt = generate_runtime_setup("imag-contact",
&version,
"Contact management tool",
build_ui);
rt.cli()
.subcommand_name()
.map(|name| {
debug!("Call {}", name);
match name {
"list" => list(&rt),
"import" => import(&rt),
"show" => show(&rt),
"find" => find(&rt),
"create" => create(&rt),
_ => {
error!("Unknown command"); // More error handling
},
}
});
}
fn list(rt: &Runtime) {
let scmd = rt.cli().subcommand_matches("list").unwrap();
let list_format = get_contact_print_format("contact.list_format", rt, &scmd);
let iterator = rt
.store()
.all_contacts()
.map_err_trace_exit_unwrap(1)
.into_get_iter(rt.store())
.map(|fle| {
let fle = fle
.map_err_trace_exit_unwrap(1)
.ok_or_else(|| CE::from("StoreId not found".to_owned()))
.map_err_trace_exit_unwrap(1);
fle
.get_contact_data()
.map(|cd| (fle, cd))
.map(|(fle, cd)| (fle, cd.into_inner()))
.map(|(fle, cd)| {
let card = Vcard::from_component(cd).unwrap_or_else(|e| {
error!("Element is not a VCARD object: {:?}", e);
exit(1)
});
(fle, card)
})
.map_err_trace_exit_unwrap(1)
})
.enumerate();
if scmd.is_present("json") {
let v : Vec<DeserVcard> = iterator
.map(|(_, (_, vcard))| DeserVcard::from(vcard)).collect();
match ::serde_json::to_string(&v) {
Ok(s) => writeln!(rt.stdout(), "{}", s).to_exit_code().unwrap_or_exit(),
Err(e) => {
error!("Error generating JSON: {:?}", e);
::std::process::exit(1)
}
}
} else {
iterator
.map(|(i, (fle, vcard))| {
let hash = String::from(fle.get_hash().map_err_trace_exit_unwrap(1));
let data = build_data_object_for_handlebars(i, hash, &vcard);
list_format.render("format", &data)
.err_from_str()
.map_err(CE::from)
.map_err_trace_exit_unwrap(1)
})
// collect, so that we can have rendered all the things and printing is faster.
.collect::<Vec<String>>()
.into_iter()
.for_each(|s| {
writeln!(rt.stdout(), "{}", s).to_exit_code().unwrap_or_exit()
});
}
}
fn import(rt: &Runtime) {
let scmd = rt.cli().subcommand_matches("import").unwrap(); // secured by main
let path = scmd.value_of("path").map(PathBuf::from).unwrap(); // secured by clap
if !path.exists() {
error!("Path does not exist");
exit(1)
}
if path.is_file() {
let _ = rt
.store()
.create_from_path(&path)
.map_err_trace_exit_unwrap(1);
} else if path.is_dir() {
for entry in WalkDir::new(path).min_depth(1).into_iter() {
let entry = entry
.err_from_str()
.map_err(CE::from)
.map_err_trace_exit_unwrap(1);
if entry.file_type().is_file() {
let pb = PathBuf::from(entry.path());
let _ = rt
.store()
.create_from_path(&pb)
.map_err_trace_exit_unwrap(1);
info!("Imported: {}", entry.path().to_str().unwrap_or("<non UTF-8 path>"));
} else {
warn!("Ignoring non-file: {}", entry.path().to_str().unwrap_or("<non UTF-8 path>"));
}
}
} else {
error!("Path is neither directory nor file");
exit(1)
}
}
fn show(rt: &Runtime) {
let scmd = rt.cli().subcommand_matches("show").unwrap();
let hash = scmd.value_of("hash").map(String::from).unwrap(); // safed by clap
let contact_data = rt.store()
.get_ref::<UniqueContactPathGenerator, _>(hash.clone())
.map_err_trace_exit_unwrap(1)
.ok_or(CE::from(format!("No entry for hash {}", hash)))
.map_err_trace_exit_unwrap(1)
.get_contact_data()
.map_err_trace_exit_unwrap(1)
.into_inner();
let vcard = Vcard::from_component(contact_data)
.unwrap_or_else(|e| {
error!("Element is not a VCARD object: {:?}", e);
exit(1)
});
let show_format = get_contact_print_format("contact.show_format", rt, &scmd);
let data = build_data_object_for_handlebars(0, hash, &vcard);
let s = show_format
.render("format", &data)
.err_from_str()
.map_err(CE::from)
.map_err_trace_exit_unwrap(1);
let _ = writeln!(::std::io::stdout(), "{}", s).to_exit_code().unwrap_or_exit();
}
fn find(rt: &Runtime) {
let scmd = rt.cli().subcommand_matches("find").unwrap();
let grepstring = scmd
.values_of("string")
.unwrap() // safed by clap
.map(String::from)
.collect::<Vec<String>>();
// We don't know yet which we need, but we pay that price for simplicity of the codebase
let show_format = get_contact_print_format("contact.show_format", rt, &scmd);
let list_format = get_contact_print_format("contact.list_format", rt, &scmd);
let iterator = rt
.store()
.all_contacts()
.map_err_trace_exit_unwrap(1)
.into_get_iter(rt.store())
.map(|el| {
el.map_err_trace_exit_unwrap(1)
.ok_or_else(|| {
error!("Could not get StoreId from Store::all_contacts(). This is a BUG!");
::std::process::exit(1)
})
.unwrap() // safed above
})
.filter_map(|cont| {
let comp = cont
.get_contact_data()
.map_err_trace_exit_unwrap(1)
.into_inner();
let card = Vcard::from_component(comp)
.map_err(|_| {
error!("Could not build Vcard from {:?}", cont.get_location());
::std::process::exit(1)
})
.unwrap(); // safed above
let str_contains_any = |s: &String, v: &Vec<String>| {
v.iter().any(|i| s.contains(i))
};
let take = card.adr().iter().any(|a| str_contains_any(a.raw(), &grepstring))
|| card.email().iter().any(|a| str_contains_any(a.raw(), &grepstring))
|| card.fullname().iter().any(|a| str_contains_any(a.raw(), &grepstring));
if take {
// optimization so we don't have to parse again in the next step
Some((cont, card))
} else {
None
}
})
.enumerate();
if scmd.is_present("json") {
let v : Vec<DeserVcard> = iterator
.map(|(_, (_, vcard))| DeserVcard::from(vcard)).collect();
match ::serde_json::to_string(&v) {
Ok(s) => writeln!(rt.stdout(), "{}", s).to_exit_code().unwrap_or_exit(),
Err(e) => {
error!("Error generating JSON: {:?}", e);
::std::process::exit(1)
}
}
} else {
iterator
.for_each(|(i, (fle, card))| {
let fmt = if scmd.is_present("find-show") {
&show_format
} else if scmd.is_present("find-list") {
&list_format
} else { // default: find-list
&list_format
};
let hash = fle.get_hash().map(String::from).map_err_trace_exit_unwrap(1);
let data = build_data_object_for_handlebars(i, hash, &card);
let s = fmt
.render("format", &data)
.err_from_str()
.map_err(CE::from)
.map_err_trace_exit_unwrap(1);
let _ = writeln!(rt.stdout(), "{}", s)
.to_exit_code()
.unwrap_or_exit();
});
}
}
fn get_contact_print_format(config_value_path: &'static str, rt: &Runtime, scmd: &ArgMatches) -> Handlebars {
let fmt = scmd
.value_of("format")
.map(String::from)
.unwrap_or_else(|| {
rt.config()
.ok_or_else(|| CE::from("No configuration file".to_owned()))
.map_err_trace_exit_unwrap(1)
.read_string(config_value_path)
.map_err_trace_exit_unwrap(1)
.ok_or_else(|| CE::from("Configuration 'contact.list_format' does not exist".to_owned()))
.map_err_trace_exit_unwrap(1)
});
let mut hb = Handlebars::new();
let _ = hb
.register_template_string("format", fmt)
.err_from_str()
.map_err(CE::from)
.map_err_trace_exit_unwrap(1);
hb.register_escape_fn(::handlebars::no_escape);
::libimaginteraction::format::register_all_color_helpers(&mut hb);
::libimaginteraction::format::register_all_format_helpers(&mut hb);
hb
}