CLI should use Agent in requests #986

Author: joepio

cli/src/commit.rs

@@ -8,7 +8,7 @@ pub fn set(context: &Context, subject: &str, property: &str, value: &str) -> Ato
         Ok(r) => r,
         Err(_) => atomic_lib::Resource::new(subject.into()),
     };
-    resource.set_shortname(&property, &value, &context.store)?;
+    resource.set_shortname(property, value, &context.store)?;
     resource.save(&context.store)?;
     Ok(())
 }
@@ -22,22 +22,22 @@ pub fn edit(context: &Context, subject: &str, prop: &str) -> AtomicResult<()> {
         Err(_) => atomic_lib::Resource::new(subject.into()),
     };
     // If the prop is not found, create it
-    let current_val = match resource.get_shortname(&prop, &context.store) {
+    let current_val = match resource.get_shortname(prop, &context.store) {
         Ok(val) => val.to_string(),
         Err(_) => "".to_string(),
     };
     let edited = edit::edit(current_val)?;
     // Remove newline - or else I can's save shortnames or numbers using vim;
     let trimmed = edited.trim_end_matches('\n');
-    resource.set_shortname(&prop, trimmed, &context.store)?;
+    resource.set_shortname(prop, trimmed, &context.store)?;
     resource.save(&context.store)?;
     Ok(())
 }
 
 /// Apply a Commit using the Remove method - removes a property from a resource
 pub fn remove(context: &Context, subject: &str, prop: &str) -> AtomicResult<()> {
     let mut resource = context.store.get_resource(subject)?;
-    resource.remove_propval_shortname(&prop, &context.store)?;
+    resource.remove_propval_shortname(prop, &context.store)?;
     resource.save(&context.store)?;
     Ok(())
 }

cli/src/main.rs

@@ -223,6 +223,7 @@ fn main() -> AtomicResult<()> {
 
 fn exec_command(context: &mut Context) -> AtomicResult<()> {
     let command = context.matches.clone();
+    context.read_config();
 
     match command {
         Commands::Destroy { subject } => {

cli/src/path.rs

@@ -4,29 +4,31 @@ use atomic_lib::{agents::ForAgent, errors::AtomicResult, serialize, storelike, A
 /// Resolves an Atomic Path query
 pub fn get_path(
     context: &mut Context,
-    path_vec: &Vec<String>,
+    path_vec: &[String],
     serialize: &SerializeOptions,
 ) -> AtomicResult<()> {
     // let subcommand_matches = context.matches.subcommand_matches("get").unwrap();
     let path_string: String = path_vec.join(" ");
 
+    let for_agent: ForAgent = context.store.get_default_agent()?.into();
     // Returns a URL or Value
-    let store = &mut context.store;
-    let path = store.get_path(
+    let path = context.store.get_path(
         &path_string,
         Some(&context.mapping.lock().unwrap()),
-        &ForAgent::Sudo,
+        &for_agent,
     )?;
     let out = match path {
         storelike::PathReturn::Subject(subject) => {
-            let resource = store.get_resource_extended(&subject, false, &ForAgent::Sudo)?;
+            let resource = context
+                .store
+                .get_resource_extended(&subject, false, &for_agent)?;
             print_resource(context, &resource, serialize)?;
             return Ok(());
         }
         storelike::PathReturn::Atom(atom) => match serialize {
             SerializeOptions::NTriples => {
                 let atoms: Vec<Atom> = vec![*atom];
-                serialize::atoms_to_ntriples(atoms, store)?
+                serialize::atoms_to_ntriples(atoms, &context.store)?
             }
             _other => atom.value.to_string(),
         },

lib/src/agents.rs

@@ -44,6 +44,19 @@ impl<T: Into<String>> From<T> for ForAgent {
     }
 }
 
+// From Agent to ForAgent
+impl From<&Agent> for ForAgent {
+    fn from(agent: &Agent) -> Self {
+        ForAgent::AgentSubject(agent.subject.clone())
+    }
+}
+
+impl From<Agent> for ForAgent {
+    fn from(agent: Agent) -> Self {
+        ForAgent::AgentSubject(agent.subject)
+    }
+}
+
 /// An Agent can be thought of as a User. Agents are used for authentication and authorization.
 /// The private key of the Agent is used to sign [crate::Commit]s.
 #[derive(Clone, Debug)]