implemented list-featureo

imag-todo/src/main.rs

@@ -72,7 +72,7 @@ fn main() {
                 }
             }
             else if subcmd.is_present("delete") {
-                println!("To be implemented");
+                unimplemented!();
                 //
                 // Functionality to delete Entry in the store
                 //
@@ -80,7 +80,7 @@ fn main() {
             else {
                 // Should not be possible, as one argument is required via
                 // ArgGroup
-                panic!("Reached unreachable Code");
+                unreachable!();
             }
         },
         Some("exec") => {
@@ -104,9 +104,67 @@ fn main() {
             } else {
                 panic!("faild to execute: You need to exec --command");
             }
+        }
+        Some("list") => {
+            let subcmd = rt.cli().subcommand_matches("list").unwrap();
+            let mut args = Vec::new();
+            let verbose = subcmd.is_present("verbose");
+            let iter = match libimagtodo::read::get_todo_iterator(rt.store()) {
+                //let iter = match rt.store().retrieve_for_module("todo/taskwarrior") {
+                Err(e) => {
+                    error!("{}", e);
+                    return;
+                }
+                Ok(val) => val,
+            };
+            for task in iter {
+                match task {
+                    Ok(val) => {
+                        //let val = libimagtodo::task::Task::new(fle);
+                        //println!("{:#?}", val.flentry);
+                        let uuid = match val.flentry.get_header().read("todo.uuid") {
+                            Ok(Some(u)) => u,
+                            Ok(None) => continue,
+                            Err(e) => {
+                                error!("{}", e);
+                                continue;
+                            }
+                        };
+                        if verbose {
+                            args.clear();
+                            args.push(format!("uuid:{}", uuid));
+                            args.push(format!("{}", "information"));
+                            let tw_process = Command::new("task").stdin(Stdio::null()).args(&args).spawn()
+                                .unwrap_or_else(|e| {
+                                    error!("{}", e);
+                                    panic!("failed");
+                                });
+                            let output = tw_process.wait_with_output().unwrap_or_else(|e| {
+                                panic!("failed to unwrap output: {}", e);
+                            });
+                            let outstring = String::from_utf8(output.stdout).unwrap_or_else(|e| {
+                                panic!("failed to ececute: {}", e);
+                            });
+                            println!("{}", outstring);
+                        }
+                        else {
+                            println!("{}", match uuid {
+                                toml::Value::String(s) => s,
+                                _ => {
+                                    error!("Unexpected type for todo.uuid: {}", uuid);
+                                    continue;
                                 },
-                _ => panic!("Reached unreachable Code"),
+                            });
+                        }
+                    }
+                    Err(e) => {
+                        error!("{}", e);
+                        continue;
+                    }
+                }
+            }
+            }
+            _ => unimplemented!(),
+        }
     }
 
-}
-

libimagtodo/src/read.rs

@@ -6,7 +6,7 @@ use result::Result;
 
 pub fn get_todo_iterator(store: &Store) -> Result<TaskIterator> {
 
-    store.retrieve_for_module("uuid")
+    store.retrieve_for_module("todo/taskwarrior")
         .map(|iter| TaskIterator::new(store, iter))
         .map_err(|e| TodoError::new(TodoErrorKind::StoreError, Some(Box::new(e))))
 }

libimagtodo/src/task.rs

@@ -14,7 +14,7 @@ use result::Result;
 /// Task struct containing a `FileLockEntry`
 #[derive(Debug)]
 pub struct Task<'a> {
-    flentry : FileLockEntry<'a>,
+    pub flentry : FileLockEntry<'a>,
 }
 
 impl<'a> Task<'a> {