266 lines
8.1 KiB
Rust
266 lines
8.1 KiB
Rust
use anyhow::{anyhow, bail};
|
|
use serde::{self, Deserialize, Deserializer};
|
|
use serde_json::Value;
|
|
use std::collections::HashMap;
|
|
use taskchampion::chrono::{DateTime, TimeZone, Utc};
|
|
use taskchampion::{Replica, Uuid};
|
|
use termcolor::{Color, ColorSpec, WriteColor};
|
|
|
|
pub(crate) fn execute<W: WriteColor>(w: &mut W, replica: &mut Replica) -> Result<(), crate::Error> {
|
|
w.set_color(ColorSpec::new().set_bold(true))?;
|
|
writeln!(w, "Importing tasks from stdin.")?;
|
|
w.reset()?;
|
|
|
|
let mut tasks: Vec<HashMap<String, Value>> =
|
|
serde_json::from_reader(std::io::stdin()).map_err(|_| anyhow!("Invalid JSON"))?;
|
|
|
|
for task_json in tasks.drain(..) {
|
|
import_task(w, replica, task_json)?;
|
|
}
|
|
|
|
w.set_color(ColorSpec::new().set_bold(true))?;
|
|
writeln!(w, "{} tasks imported.", tasks.len())?;
|
|
w.reset()?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Convert the given value to a string, failing on compound types (arrays
|
|
/// and objects).
|
|
fn stringify(v: Value) -> anyhow::Result<String> {
|
|
Ok(match v {
|
|
Value::String(s) => s,
|
|
Value::Number(n) => n.to_string(),
|
|
Value::Bool(true) => "true".to_string(),
|
|
Value::Bool(false) => "false".to_string(),
|
|
Value::Null => "null".to_string(),
|
|
_ => bail!("{:?} cannot be converted to a string", v),
|
|
})
|
|
}
|
|
|
|
pub fn deserialize_tw_datetime<'de, D>(deserializer: D) -> Result<DateTime<Utc>, D::Error>
|
|
where
|
|
D: Deserializer<'de>,
|
|
{
|
|
const FORMAT: &str = "%Y%m%dT%H%M%SZ";
|
|
let s = String::deserialize(deserializer)?;
|
|
Utc.datetime_from_str(&s, FORMAT)
|
|
.map_err(serde::de::Error::custom)
|
|
}
|
|
|
|
/// Deserialize a string in the TaskWarrior format into a DateTime
|
|
#[derive(Deserialize)]
|
|
struct TwDateTime(#[serde(deserialize_with = "deserialize_tw_datetime")] DateTime<Utc>);
|
|
|
|
impl TwDateTime {
|
|
/// Generate the data-model style UNIX timestamp for this DateTime
|
|
fn tc_timestamp(&self) -> String {
|
|
self.0.timestamp().to_string()
|
|
}
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
struct Annotation {
|
|
entry: TwDateTime,
|
|
description: String,
|
|
}
|
|
|
|
fn import_task<W: WriteColor>(
|
|
w: &mut W,
|
|
replica: &mut Replica,
|
|
mut task_json: HashMap<String, Value>,
|
|
) -> anyhow::Result<()> {
|
|
let uuid = task_json
|
|
.get("uuid")
|
|
.ok_or_else(|| anyhow!("task has no uuid"))?;
|
|
let uuid = uuid
|
|
.as_str()
|
|
.ok_or_else(|| anyhow!("uuid is not a string"))?;
|
|
let uuid = Uuid::parse_str(uuid)?;
|
|
replica.import_task_with_uuid(uuid)?;
|
|
|
|
let mut description = None;
|
|
for (k, v) in task_json.drain() {
|
|
match k.as_ref() {
|
|
// `id` is the working-set ID and is not stored
|
|
"id" => {}
|
|
|
|
// `urgency` is also calculated and not stored
|
|
"urgency" => {}
|
|
|
|
// `uuid` was already handled
|
|
"uuid" => {}
|
|
|
|
// `annotations` is a sub-aray
|
|
"annotations" => {
|
|
let annotations: Vec<Annotation> = serde_json::from_value(v)?;
|
|
for ann in annotations {
|
|
let k = format!("annotation_{}", ann.entry.tc_timestamp());
|
|
replica.update_task(uuid, k, Some(ann.description))?;
|
|
}
|
|
}
|
|
|
|
// `depends` is a sub-aray
|
|
"depends" => {
|
|
let deps: Vec<String> = serde_json::from_value(v)?;
|
|
for dep in deps {
|
|
let k = format!("dep_{}", dep);
|
|
replica.update_task(uuid, k, Some("".to_owned()))?;
|
|
}
|
|
}
|
|
|
|
// `tags` is a sub-aray
|
|
"tags" => {
|
|
let tags: Vec<String> = serde_json::from_value(v)?;
|
|
for tag in tags {
|
|
let k = format!("tag_{}", tag);
|
|
replica.update_task(uuid, k, Some("".to_owned()))?;
|
|
}
|
|
}
|
|
|
|
// convert all datetimes -> epoch integers
|
|
"end" | "entry" | "modified" | "wait" | "due" => {
|
|
let v: TwDateTime = serde_json::from_value(v)?;
|
|
replica.update_task(uuid, k, Some(v.tc_timestamp()))?;
|
|
}
|
|
|
|
// everything else is inserted directly
|
|
_ => {
|
|
let v = stringify(v)?;
|
|
if k == "description" {
|
|
// keep a copy of the description for console output
|
|
description = Some(v.clone());
|
|
}
|
|
replica.update_task(uuid, k, Some(v))?;
|
|
}
|
|
}
|
|
}
|
|
|
|
w.set_color(ColorSpec::new().set_fg(Some(Color::Yellow)))?;
|
|
write!(w, "{}", uuid)?;
|
|
w.reset()?;
|
|
writeln!(
|
|
w,
|
|
" {}",
|
|
description.unwrap_or_else(|| "(no description)".into())
|
|
)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
use crate::invocation::test::*;
|
|
use pretty_assertions::assert_eq;
|
|
use serde_json::json;
|
|
use std::convert::TryInto;
|
|
use taskchampion::chrono::{TimeZone, Utc};
|
|
use taskchampion::Status;
|
|
|
|
#[test]
|
|
fn stringify_string() {
|
|
assert_eq!(stringify(json!("foo")).unwrap(), "foo".to_string());
|
|
}
|
|
|
|
#[test]
|
|
fn stringify_number() {
|
|
assert_eq!(stringify(json!(2.14)).unwrap(), "2.14".to_string());
|
|
}
|
|
|
|
#[test]
|
|
fn stringify_bool() {
|
|
assert_eq!(stringify(json!(true)).unwrap(), "true".to_string());
|
|
assert_eq!(stringify(json!(false)).unwrap(), "false".to_string());
|
|
}
|
|
|
|
#[test]
|
|
fn stringify_null() {
|
|
assert_eq!(stringify(json!(null)).unwrap(), "null".to_string());
|
|
}
|
|
|
|
#[test]
|
|
fn stringify_invalid() {
|
|
assert!(stringify(json!([1])).is_err());
|
|
assert!(stringify(json!({"a": 1})).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn test_import() -> anyhow::Result<()> {
|
|
let mut w = test_writer();
|
|
let mut replica = test_replica();
|
|
|
|
let task_json = serde_json::from_value(json!({
|
|
"id": 0,
|
|
"description": "repair window",
|
|
"end": "20211231T175614Z", // TODO (#327)
|
|
"entry": "20211117T022410Z", // TODO (#326)
|
|
"modified": "20211231T175614Z",
|
|
"priority": "M",
|
|
"status": "completed",
|
|
"uuid": "fa01e916-1587-4c7d-a646-f7be62be8ee7",
|
|
"wait": "20211225T001523Z",
|
|
"due": "20211225T040000Z", // TODO (#82)
|
|
|
|
// TODO: recurrence (#81)
|
|
"imask": 2,
|
|
"recur": "monthly",
|
|
"rtype": "periodic",
|
|
"mask": "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--",
|
|
|
|
// (legacy) UDAs
|
|
"githubcreatedon": "20211110T175919Z",
|
|
"githubnamespace": "djmitche",
|
|
"githubnumber": 228,
|
|
|
|
"tags": [
|
|
"house"
|
|
],
|
|
"depends": [ // TODO (#84)
|
|
"4f71035d-1704-47f0-885c-6f9134bcefb2"
|
|
],
|
|
"annotations": [
|
|
{
|
|
"entry": "20211223T142031Z",
|
|
"description": "ordered from website"
|
|
}
|
|
],
|
|
"urgency": 4.16849
|
|
}))?;
|
|
import_task(&mut w, &mut replica, task_json)?;
|
|
|
|
let task = replica
|
|
.get_task(Uuid::parse_str("fa01e916-1587-4c7d-a646-f7be62be8ee7").unwrap())
|
|
.unwrap()
|
|
.unwrap();
|
|
assert_eq!(task.get_description(), "repair window");
|
|
assert_eq!(task.get_status(), Status::Completed);
|
|
assert_eq!(task.get_priority(), "M".to_string());
|
|
assert_eq!(
|
|
task.get_wait(),
|
|
Some(Utc.ymd(2021, 12, 25).and_hms(00, 15, 23))
|
|
);
|
|
assert_eq!(
|
|
task.get_modified(),
|
|
Some(Utc.ymd(2021, 12, 31).and_hms(17, 56, 14))
|
|
);
|
|
assert!(task.has_tag(&"house".try_into().unwrap()));
|
|
assert!(!task.has_tag(&"PENDING".try_into().unwrap()));
|
|
assert_eq!(
|
|
task.get_annotations().collect::<Vec<_>>(),
|
|
vec![taskchampion::Annotation {
|
|
entry: Utc.ymd(2021, 12, 23).and_hms(14, 20, 31),
|
|
description: "ordered from website".into(),
|
|
}]
|
|
);
|
|
assert_eq!(
|
|
task.get_legacy_uda("githubcreatedon"),
|
|
Some("20211110T175919Z")
|
|
);
|
|
assert_eq!(task.get_legacy_uda("githubnamespace"), Some("djmitche"));
|
|
assert_eq!(task.get_legacy_uda("githubnumber"), Some("228"));
|
|
|
|
Ok(())
|
|
}
|
|
}
|