443 lines
17 KiB
Rust
443 lines
17 KiB
Rust
use std::convert::TryFrom;
|
|
use std::io::{BufRead, Write};
|
|
|
|
use clap::ArgMatches;
|
|
use chrono::{DateTime, Utc, Duration};
|
|
use regex::Regex;
|
|
|
|
use crate::database::Database;
|
|
use crate::error::{Error, Result};
|
|
use crate::commands::{Command, Facts};
|
|
use crate::timeparse::{parse_time, parse_hours};
|
|
use crate::old::{entries_or_warning, time_or_warning};
|
|
use crate::formatters::text;
|
|
use crate::regex::parse_regex;
|
|
use crate::interactive::ask;
|
|
use crate::io::Streams;
|
|
use crate::models::Entry;
|
|
|
|
#[derive(Default)]
|
|
pub struct Args {
|
|
start: Option<DateTime<Utc>>,
|
|
end: Option<DateTime<Utc>>,
|
|
grep: Option<Regex>,
|
|
hours: Option<u16>,
|
|
fake: bool,
|
|
sheet: Option<String>,
|
|
}
|
|
|
|
impl<'a> TryFrom<&'a ArgMatches> for Args {
|
|
type Error = Error;
|
|
|
|
fn try_from(matches: &'a ArgMatches) -> Result<Self> {
|
|
Ok(Args {
|
|
start: matches.value_of("start").map(parse_time).transpose()?,
|
|
end: matches.value_of("end").map(parse_time).transpose()?,
|
|
grep: matches.value_of("grep").map(parse_regex).transpose()?,
|
|
hours: matches.value_of("time").map(parse_hours).transpose()?,
|
|
fake: matches.is_present("fake"),
|
|
sheet: matches.value_of("sheet").map(|s| s.to_owned()),
|
|
})
|
|
}
|
|
}
|
|
|
|
/// Modify the given Entry such that it only lasts the given `time`, and return
|
|
/// the data needed to create a new entry with mostly the same attributes such
|
|
/// that it accounts for the time substracted from the original.
|
|
fn split_entry(entry: &mut Entry, time: Duration) -> (DateTime<Utc>, Option<DateTime<Utc>>, Option<String>, String) {
|
|
let Entry {
|
|
id: _, note, start, end, sheet,
|
|
} = entry.clone();
|
|
|
|
let old_entry_end = start + time;
|
|
let new_entry_start = old_entry_end;
|
|
|
|
entry.end = Some(old_entry_end);
|
|
|
|
(new_entry_start, end, note, sheet)
|
|
}
|
|
|
|
pub struct ArchiveCommand {}
|
|
|
|
impl<'a> Command<'a> for ArchiveCommand {
|
|
type Args = Args;
|
|
|
|
fn handle<D, I, O, E>(args: Args, streams: &mut Streams<D, I, O, E>, facts: &Facts) -> Result<()>
|
|
where
|
|
D: Database,
|
|
I: BufRead,
|
|
O: Write,
|
|
E: Write,
|
|
{
|
|
// Get all entries from the database that match the filter criteria
|
|
// given from the command line: start time, end time and sheet.
|
|
let entries = {
|
|
let started_after = args.start.map(|s| time_or_warning(s, &streams.db)).transpose()?.map(|s| s.0);
|
|
let started_before = args.end.map(|e| time_or_warning(e, &streams.db)).transpose()?.map(|e| e.0);
|
|
let sheet = args.sheet.map(Ok).unwrap_or_else(|| streams.db.current_sheet())?;
|
|
|
|
let mut entries = streams.db.entries_by_sheet(&sheet, started_after, started_before)?;
|
|
|
|
// only archive those entries that are finished.
|
|
entries.retain(|e| e.end.is_some());
|
|
|
|
if let Some(re) = args.grep {
|
|
entries.retain(|e| re.is_match(&e.note.clone().unwrap_or_default()));
|
|
}
|
|
|
|
entries
|
|
};
|
|
|
|
// If the user requested to archive entries by a total time then not all
|
|
// entries will be archived, and instead just those oldest ones that
|
|
// accumulate the given time will be. If the total time of the filtered
|
|
// entries is more than the requested time the last one will be split
|
|
// into two pieces.
|
|
let (time, entries, new, extra_msg) = if let Some(hours) = args.hours {
|
|
let requested_time = Duration::hours(hours as i64);
|
|
// archive the maximum amount of consecutive entries whose
|
|
// accumulated time is not bigger that `time`.
|
|
let mut selected_entries = Vec::with_capacity(entries.len());
|
|
let mut accumulated_time = Duration::seconds(0);
|
|
let mut new = None;
|
|
|
|
for entry in entries {
|
|
// Can unwrap because only entries with an end time get this far
|
|
let timespan = entry.timespan().unwrap();
|
|
|
|
if accumulated_time < requested_time {
|
|
if accumulated_time + timespan > requested_time {
|
|
// should split the last entry
|
|
let missing_time = requested_time - accumulated_time;
|
|
let mut entry = entry;
|
|
let parts = split_entry(&mut entry, missing_time);
|
|
new.replace(parts);
|
|
selected_entries.push(entry);
|
|
accumulated_time = accumulated_time + missing_time;
|
|
} else {
|
|
// fits perfectly, just add it
|
|
selected_entries.push(entry);
|
|
accumulated_time = accumulated_time + timespan;
|
|
}
|
|
} else {
|
|
// accumulated_time is equal or higher than requested_time,
|
|
// no more entries are admitted
|
|
break;
|
|
}
|
|
}
|
|
|
|
let msg = if new.is_some() {
|
|
String::from("\nAdditionally an entry will be split so that the total archived time is exact.")
|
|
} else if accumulated_time < requested_time {
|
|
let requested_time_str = text::format_hours(requested_time);
|
|
let missing_time_str = text::format_hours(requested_time - accumulated_time);
|
|
format!("\nThere were not enough entries to fulfill the requested time of {requested_time_str} (difference: {missing_time_str}).")
|
|
} else {
|
|
String::new()
|
|
};
|
|
|
|
(text::format_hours(accumulated_time), selected_entries, new, msg)
|
|
} else {
|
|
(text::format_hours(
|
|
entries
|
|
.iter()
|
|
.filter_map(|e| e.end.map(|end| end - e.start))
|
|
.fold(Duration::seconds(0), |acc, new| {
|
|
acc + new
|
|
})
|
|
), entries, None, String::from(""))
|
|
};
|
|
|
|
let n = entries.len();
|
|
let n_entries = if n == 1 {
|
|
String::from("1 entry")
|
|
} else {
|
|
format!("{n} entries")
|
|
};
|
|
|
|
if args.fake {
|
|
let (entries, _) = entries_or_warning(entries, &streams.db)?;
|
|
|
|
writeln!(streams.out, "These entries would be archived:\n")?;
|
|
|
|
text::print_formatted(
|
|
entries,
|
|
&mut streams.out,
|
|
facts,
|
|
true,
|
|
)?;
|
|
} else if ask(streams, &format!("A total of {n_entries} accounting for {time} will be archived.{extra_msg}\nProceed?"))? {
|
|
for entry in entries {
|
|
streams.db.entry_update(entry.id, entry.start, entry.end, entry.note, &format!("_{}", entry.sheet))?;
|
|
}
|
|
|
|
if let Some((start, end, note, sheet)) = new {
|
|
streams.db.entry_insert(start, end, note, &sheet)?;
|
|
}
|
|
} else {
|
|
writeln!(streams.out, "Ok, they're still there")?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use pretty_assertions::{assert_eq, assert_str_eq};
|
|
use chrono::TimeZone;
|
|
|
|
use crate::models::Entry;
|
|
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn archive_archives() {
|
|
let args: Args = Default::default();
|
|
let mut streams = Streams::fake(b"y\n");
|
|
let facts = Facts::new();
|
|
|
|
streams.db.set_current_sheet("foo").unwrap();
|
|
streams.db.entry_insert(facts.now - Duration::hours(3), Some(facts.now - Duration::minutes(90)), Some("first".into()), "foo").unwrap();
|
|
streams.db.entry_insert(facts.now - Duration::minutes(90), Some(facts.now), Some("second".into()), "foo").unwrap();
|
|
|
|
ArchiveCommand::handle(args, &mut streams, &facts).unwrap();
|
|
|
|
let remaining = streams.db.entries_by_sheet("foo", None, None).unwrap();
|
|
let archived = streams.db.entries_by_sheet("_foo", None, None).unwrap();
|
|
|
|
assert_eq!(String::from_utf8_lossy(&streams.out), "A total of 2 entries accounting for 3h will be archived.\nProceed? [y/N] ");
|
|
|
|
// First entry gets archived whole, second entry gets split in two:
|
|
// - a 30 minute piece to complete the requested 2 hour span
|
|
// - a 1 hour piece that remains unarchived
|
|
assert_eq!(archived, vec![
|
|
Entry {
|
|
id: 1,
|
|
note: Some("first".into()),
|
|
start: facts.now - Duration::hours(3),
|
|
end: Some(facts.now - Duration::minutes(90)),
|
|
sheet: "_foo".into(),
|
|
},
|
|
Entry {
|
|
id: 2,
|
|
note: Some("second".into()),
|
|
start: facts.now - Duration::minutes(90),
|
|
end: Some(facts.now),
|
|
sheet: "_foo".into(),
|
|
},
|
|
]);
|
|
assert_eq!(remaining, vec![]);
|
|
}
|
|
|
|
#[test]
|
|
fn no_running_entry_is_archived() {
|
|
let args: Args = Default::default();
|
|
let mut streams = Streams::fake(b"y\n");
|
|
let facts = Facts::new();
|
|
|
|
streams.db.set_current_sheet("foo").unwrap();
|
|
streams.db.entry_insert(facts.now - Duration::hours(3), Some(facts.now - Duration::minutes(90)), Some("first".into()), "foo").unwrap();
|
|
streams.db.entry_insert(facts.now - Duration::minutes(90), None, Some("running".into()), "foo").unwrap();
|
|
|
|
ArchiveCommand::handle(args, &mut streams, &facts).unwrap();
|
|
|
|
let remaining = streams.db.entries_by_sheet("foo", None, None).unwrap();
|
|
let archived = streams.db.entries_by_sheet("_foo", None, None).unwrap();
|
|
|
|
assert_eq!(String::from_utf8_lossy(&streams.out), "A total of 1 entry accounting for 1h 30m will be archived.\nProceed? [y/N] ");
|
|
|
|
// First entry gets archived whole, second entry gets split in two:
|
|
// - a 30 minute piece to complete the requested 2 hour span
|
|
// - a 1 hour piece that remains unarchived
|
|
assert_eq!(archived, vec![
|
|
Entry {
|
|
id: 1,
|
|
note: Some("first".into()),
|
|
start: facts.now - Duration::hours(3),
|
|
end: Some(facts.now - Duration::minutes(90)),
|
|
sheet: "_foo".into(),
|
|
},
|
|
]);
|
|
assert_eq!(remaining, vec![
|
|
Entry {
|
|
id: 2,
|
|
note: Some("running".into()),
|
|
start: facts.now - Duration::minutes(90),
|
|
end: None,
|
|
sheet: "foo".into(),
|
|
},
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn entries_are_split_properly() {
|
|
let mut old_entry = Entry {
|
|
id: 1,
|
|
start: Utc.with_ymd_and_hms(2022, 7, 29, 10, 0, 0).unwrap(),
|
|
end: Some(Utc.with_ymd_and_hms(2022, 7, 29, 11, 0, 0).unwrap()),
|
|
note: Some("an entry".to_string()),
|
|
sheet: "foo".to_string(),
|
|
};
|
|
|
|
assert_eq!(split_entry(&mut old_entry, Duration::minutes(25)), (
|
|
Utc.with_ymd_and_hms(2022, 7, 29, 10, 25, 0).unwrap(),
|
|
Some(Utc.with_ymd_and_hms(2022, 7, 29, 11, 0, 0).unwrap()),
|
|
Some("an entry".to_string()),
|
|
"foo".to_string(),
|
|
));
|
|
assert_eq!(old_entry, Entry {
|
|
id: 1,
|
|
start: Utc.with_ymd_and_hms(2022, 7, 29, 10, 0, 0).unwrap(),
|
|
end: Some(Utc.with_ymd_and_hms(2022, 7, 29, 10, 25, 0).unwrap()),
|
|
note: Some("an entry".to_string()),
|
|
sheet: "foo".to_string(),
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn archive_by_hours() {
|
|
let args = Args {
|
|
hours: Some(2),
|
|
..Default::default()
|
|
};
|
|
let mut streams = Streams::fake(b"y\n");
|
|
let facts = Facts::new();
|
|
|
|
streams.db.set_current_sheet("foo").unwrap();
|
|
streams.db.entry_insert(facts.now - Duration::hours(3), Some(facts.now - Duration::minutes(90)), Some("first".into()), "foo").unwrap();
|
|
streams.db.entry_insert(facts.now - Duration::minutes(90), Some(facts.now), Some("second".into()), "foo").unwrap();
|
|
|
|
ArchiveCommand::handle(args, &mut streams, &facts).unwrap();
|
|
|
|
let remaining = streams.db.entries_by_sheet("foo", None, None).unwrap();
|
|
let archived = streams.db.entries_by_sheet("_foo", None, None).unwrap();
|
|
|
|
assert_str_eq!(String::from_utf8_lossy(&streams.out), "A total of 2 entries accounting for 2h will be archived.
|
|
Additionally an entry will be split so that the total archived time is exact.
|
|
Proceed? [y/N] ");
|
|
|
|
// First entry gets archived whole, second entry gets split in two:
|
|
// - a 30 minute piece to complete the requested 2 hour span
|
|
// - a 1 hour piece that remains unarchived
|
|
assert_eq!(archived, vec![
|
|
Entry {
|
|
id: 1,
|
|
note: Some("first".into()),
|
|
start: facts.now - Duration::hours(3),
|
|
end: Some(facts.now - Duration::minutes(90)),
|
|
sheet: "_foo".into(),
|
|
},
|
|
Entry {
|
|
id: 2,
|
|
note: Some("second".into()),
|
|
start: facts.now - Duration::minutes(90),
|
|
end: Some(facts.now - Duration::hours(1)),
|
|
sheet: "_foo".into(),
|
|
},
|
|
]);
|
|
assert_eq!(remaining, vec![
|
|
Entry {
|
|
id: 3,
|
|
note: Some("second".into()),
|
|
start: facts.now - Duration::hours(1),
|
|
end: Some(facts.now),
|
|
sheet: "foo".into(),
|
|
},
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn not_enough_entries_to_archive_time() {
|
|
let args = Args {
|
|
hours: Some(2),
|
|
..Default::default()
|
|
};
|
|
let mut streams = Streams::fake(b"y\n");
|
|
let facts = Facts::new();
|
|
|
|
streams.db.set_current_sheet("foo").unwrap();
|
|
streams.db.entry_insert(facts.now - Duration::hours(3), Some(facts.now - Duration::minutes(90)), Some("first".into()), "foo").unwrap();
|
|
|
|
ArchiveCommand::handle(args, &mut streams, &facts).unwrap();
|
|
|
|
let remaining = streams.db.entries_by_sheet("foo", None, None).unwrap();
|
|
let archived = streams.db.entries_by_sheet("_foo", None, None).unwrap();
|
|
|
|
assert_str_eq!(String::from_utf8_lossy(&streams.out), "A total of 1 entry accounting for 1h 30m will be archived.
|
|
There were not enough entries to fulfill the requested time of 2h (difference: 30m).
|
|
Proceed? [y/N] ");
|
|
|
|
// First entry gets archived whole, second entry gets split in two:
|
|
// - a 30 minute piece to complete the requested 2 hour span
|
|
// - a 1 hour piece that remains unarchived
|
|
assert_eq!(archived, vec![
|
|
Entry {
|
|
id: 1,
|
|
note: Some("first".into()),
|
|
start: facts.now - Duration::hours(3),
|
|
end: Some(facts.now - Duration::minutes(90)),
|
|
sheet: "_foo".into(),
|
|
},
|
|
]);
|
|
assert_eq!(remaining, vec![]);
|
|
}
|
|
|
|
#[test]
|
|
fn fake_and_split_work_well_together() {
|
|
std::env::set_var("TZ", "CST+6");
|
|
|
|
let args = Args {
|
|
hours: Some(2),
|
|
fake: true,
|
|
..Default::default()
|
|
};
|
|
let mut streams = Streams::fake(b"y\n");
|
|
let facts = Facts::new();
|
|
let time_a = Utc.with_ymd_and_hms(2022, 8, 1, 10, 0, 0).unwrap();
|
|
let time_b = time_a + Duration::minutes(90);
|
|
let time_d = time_a + Duration::hours(3);
|
|
|
|
streams.db.set_current_sheet("foo").unwrap();
|
|
streams.db.entry_insert(time_a, Some(time_b), Some("first".into()), "foo").unwrap();
|
|
streams.db.entry_insert(time_b, Some(time_d), Some("second".into()), "foo").unwrap();
|
|
|
|
ArchiveCommand::handle(args, &mut streams, &facts).unwrap();
|
|
|
|
let remaining = streams.db.entries_by_sheet("foo", None, None).unwrap();
|
|
let archived = streams.db.entries_by_sheet("_foo", None, None).unwrap();
|
|
|
|
assert_str_eq!(String::from_utf8_lossy(&streams.out), "These entries would be archived:
|
|
|
|
Timesheet: foo
|
|
ID Day Start End Duration Notes
|
|
1 Mon Aug 01, 2022 04:00:00 - 05:30:00 1:30:00 first
|
|
2 05:30:00 - 06:00:00 0:30:00 second
|
|
2:00:00
|
|
------------------------------------------------------------
|
|
Total 2:00:00
|
|
");
|
|
|
|
// First entry gets archived whole, second entry gets split in two:
|
|
// - a 30 minute piece to complete the requested 2 hour span
|
|
// - a 1 hour piece that remains unarchived
|
|
assert_eq!(archived, vec![]);
|
|
assert_eq!(remaining, vec![
|
|
Entry {
|
|
id: 1,
|
|
note: Some("first".into()),
|
|
start: time_a,
|
|
end: Some(time_b),
|
|
sheet: "foo".into(),
|
|
},
|
|
Entry {
|
|
id: 2,
|
|
note: Some("second".into()),
|
|
start: time_b,
|
|
end: Some(time_d),
|
|
sheet: "foo".into(),
|
|
},
|
|
]);
|
|
}
|
|
}
|