Add support for fetching xchan data by address.

Not entirely happy with it, have updated the signature of 
Client::fetch_stream and Client::url to take args, which are left out if 
they're not serializable (or empty, I hope.) Should probably use an 
Option instead, or maybe even two entry points for the api.

1 files changed, 29 insertions, 9 deletions

diff --git a/src/client.rs b/src/client.rs
index 2459f64..c724526 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -23,11 +23,14 @@ use reqwest::{
     StatusCode,
 };
 use serde::Serialize;
+use serde_urlencoded;
 use std::io::Read;
+use xchan::XChanFetcher;
 
 pub const ZOTAPI_CHANNEL_STREAM_PATH : &str = "/api/z/1.0/channel/stream";
 pub const ZOTAPI_NETWORK_STREAM_PATH : &str = "/api/z/1.0/network/stream";
 pub const ZOTAPI_ITEM_UPDATE_PATH : &str = "/api/z/1.0/item/update";
+pub const ZOTAPI_XCHAN_PATH : &str = "/api/z/1.0/xchan";
 
 pub struct Client {
     inner: reqwest::Client,
@@ -45,25 +48,39 @@ impl Client {
             pw: String::from(pw),
         }
     }
-    
+
     pub fn channel_stream(&self) -> Result<String, Error> {
-        self.fetch_stream(ZOTAPI_CHANNEL_STREAM_PATH)
+        self.fetch_stream(ZOTAPI_CHANNEL_STREAM_PATH, &())
     }
 
     pub fn network_stream(&self) -> Result<String, Error> {
-        self.fetch_stream(ZOTAPI_NETWORK_STREAM_PATH)
+        self.fetch_stream(ZOTAPI_NETWORK_STREAM_PATH, &())
     }
 
     pub fn item(&self) -> ItemBuilder {
         ItemBuilder::new(self)
     }
 
-    fn url(&self, path: &str) -> String {
-        self.base_url.clone() + path
+    pub fn xchan(&self) -> XChanFetcher {
+        XChanFetcher::new(self)
+    }
+
+    fn url<T>(&self, path: &str, args: &T) -> String
+        where T: Serialize
+    {
+        let r = self.base_url.clone() + path;
+        if let Ok(a) = serde_urlencoded::to_string(args) {
+            r + "?" + &a
+        }
+        else {
+            r
+        }
     }
 
-    fn fetch_stream(&self, path: &str) -> Result<String, Error> {
-        let url = self.url(path);
+    pub fn fetch_stream<T>(&self, path: &str, args: &T) -> Result<String, Error>
+        where T: Serialize
+    {
+        let url = self.url(path, args);
         let mut res = self.inner.get(&url)
             .header(Accept(vec![qitem(mime::APPLICATION_JSON)]))
             .basic_auth(self.user.clone(), Some(self.pw.clone()))
@@ -76,14 +93,17 @@ impl Client {
                 res.read_to_string(&mut body)?;
                 Ok(body)
             },
-            _ => Err(Error::Unknown)
+            _ => {
+                println!("Received unknown status: {:?}", res.status());
+                Err(Error::Unknown)
+            }
         }
     }
 
     pub fn post_data<T>(&self, path: &str, data: &T) -> Result<String, Error>
         where T: Serialize,
     {
-        let url = self.url(path);
+        let url = self.url(path, &());
         let mut res = self.inner.post(&url)
             .header(Accept(vec![qitem(mime::APPLICATION_JSON)]))
             .header(ContentType::form_url_encoded())