200 lines
6.4 KiB
Rust
200 lines
6.4 KiB
Rust
mod api;
|
|
mod cmd;
|
|
mod config;
|
|
mod errors;
|
|
|
|
use api::{LocationModel, TagModel, API};
|
|
use chrono::offset::Local;
|
|
use chrono::{NaiveDate, NaiveDateTime, NaiveTime, ParseError};
|
|
use cmd::*;
|
|
use config::Config;
|
|
use errors::{GenericError, MessagedError};
|
|
use std::io::prelude::*;
|
|
use std::sync::mpsc::TryRecvError;
|
|
use std::time::Duration;
|
|
|
|
fn main() {
|
|
let env: EnvOpt = argh::from_env();
|
|
if let Err(e) = from_env(env) {
|
|
eprintln!("Critical Error: {}", e);
|
|
std::process::exit(1);
|
|
}
|
|
}
|
|
|
|
fn from_env(env: EnvOpt) -> Result<(), GenericError> {
|
|
match env.subcommand {
|
|
Subcommand::Between(opt) => {
|
|
let config = Config::from_path(&env.config)?;
|
|
|
|
let since =
|
|
Some(try_get_datetime(opt.since, &config).with_msg("Failed to parse since")?);
|
|
|
|
let until = match opt.until {
|
|
Some(until) => {
|
|
Some(try_get_datetime(until, &config).with_msg("Failed to parse until")?)
|
|
}
|
|
None => None,
|
|
};
|
|
|
|
let locs = run(&config, opt.device, since, until)?;
|
|
dbg!(
|
|
&locs.iter().map(|loc| loc.0).collect::<Vec<NaiveDateTime>>(),
|
|
locs.len(),
|
|
);
|
|
Ok(())
|
|
}
|
|
Subcommand::Init(_) => {
|
|
let config = Config::default();
|
|
config.write_to(&env.config)?;
|
|
Ok(())
|
|
}
|
|
Subcommand::Nick(opt) => {
|
|
let mut config = Config::from_path(&env.config)?;
|
|
let mut api = API::new(config.clone());
|
|
|
|
let tags = api.get_tags()?;
|
|
|
|
match opt.subcommand {
|
|
NickSub::List(_) => {
|
|
for (idx, tag) in tags.iter().enumerate() {
|
|
println!(
|
|
"{}. {}\n{}",
|
|
idx + 1,
|
|
tag.get_nick(&config)
|
|
.unwrap_or("No current nick".to_owned()),
|
|
tag
|
|
);
|
|
}
|
|
Ok(())
|
|
}
|
|
NickSub::Set(opt) => {
|
|
if let Some(tag) = tags.get((opt.index - 1).max(0) as usize) {
|
|
if let Some(id) = &tag.id {
|
|
config.nicknames.insert(id.clone(), opt.nickname);
|
|
config.write_to(&env.config)?;
|
|
Ok(())
|
|
} else {
|
|
Err(GenericError::MessagedError(
|
|
format!("Device with index {} does not have an id", opt.index),
|
|
None,
|
|
))
|
|
}
|
|
} else {
|
|
Err(GenericError::MessagedError(
|
|
format!("Could not find device with index {}", opt.index),
|
|
None,
|
|
))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn run(
|
|
config: &Config,
|
|
tag_str: String,
|
|
from: Option<NaiveDateTime>,
|
|
to: Option<NaiveDateTime>,
|
|
) -> Result<Vec<(NaiveDateTime, LocationModel)>, GenericError> {
|
|
let mut api = API::new(config.clone());
|
|
|
|
let tags = api.get_tags()?;
|
|
let tag_id = find_tag(tag_str, &tags, config)?.get_id()?;
|
|
|
|
print!("Preparing..\r");
|
|
std::io::stdout().lock().flush().ok();
|
|
|
|
let state_list = api.get_states(&tag_id)?;
|
|
|
|
let states = API::get_between(&state_list, from, to, true, &config);
|
|
|
|
let mut locations = Vec::new();
|
|
for (_, state) in states.iter() {
|
|
api.queue_location(&tag_id, state.id.as_ref().unwrap());
|
|
}
|
|
let receiver = api.begin_location_fetch();
|
|
let mut counter = 0;
|
|
loop {
|
|
match receiver.try_recv() {
|
|
Ok(res) => match res {
|
|
Ok(loc) => {
|
|
if loc.is_ok() {
|
|
counter += 1;
|
|
}
|
|
let remaining = exp_time(&api, states.len() as u64 - counter as u64);
|
|
print!(
|
|
"Done: {:<5.2}% Remaining: {:<5.2} seconds\r",
|
|
counter as f32 / states.len() as f32 * 100.,
|
|
remaining.as_secs_f32()
|
|
);
|
|
std::io::stdout().lock().flush().ok();
|
|
match loc {
|
|
Ok(mut loc) => locations.append(&mut loc),
|
|
Err(e) => eprintln!(
|
|
"Error fetching location data: {}",
|
|
e.message.unwrap_or(String::new())
|
|
),
|
|
}
|
|
}
|
|
Err(e) => eprintln!("{}", e),
|
|
},
|
|
Err(e) => {
|
|
if let TryRecvError::Disconnected = e {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
println!("{:<100}", "Done!");
|
|
locations.sort_by(|loc1, loc2| loc2.timestamp.cmp(&loc1.timestamp));
|
|
|
|
let locs = API::get_between(&locations, from, to, false, &config);
|
|
Ok(locs)
|
|
}
|
|
|
|
fn exp_time(api: &API, reqs_left: u64) -> Duration {
|
|
let interval = 1_000 / api.config.throttle as u64;
|
|
Duration::from_millis(interval * reqs_left)
|
|
}
|
|
|
|
fn try_get_datetime(parsed: String, config: &Config) -> Result<NaiveDateTime, ParseError> {
|
|
match NaiveDateTime::parse_from_str(&parsed, &config.timedate_format) {
|
|
Ok(timedate) => Ok(timedate),
|
|
Err(_) => match NaiveDate::parse_from_str(&parsed, &config.date_format) {
|
|
Ok(date) => Ok(date.and_hms(0, 0, 0)),
|
|
Err(_) => match NaiveTime::parse_from_str(&parsed, &config.time_format) {
|
|
Ok(time) => Ok(Local::today().naive_local().and_time(time)),
|
|
Err(e) => Err(e),
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
fn find_tag(
|
|
tag_str: String,
|
|
tags: &Vec<TagModel>,
|
|
config: &Config,
|
|
) -> Result<TagModel, GenericError> {
|
|
let mut tag = None;
|
|
if let Ok(num) = tag_str.parse::<i32>() {
|
|
if let Some(found) = tags.get((num - 1).max(0) as usize) {
|
|
tag = Some(found.clone());
|
|
}
|
|
}
|
|
for curr in tags.iter() {
|
|
if let Some(nick) = curr.get_nick(config) {
|
|
if nick == tag_str {
|
|
tag = Some(curr.clone());
|
|
}
|
|
}
|
|
}
|
|
match tag {
|
|
Some(tag) => Ok(tag),
|
|
None => Err(GenericError::MessagedError(
|
|
format!("Could not find device {}", tag_str),
|
|
None,
|
|
)),
|
|
}
|
|
}
|