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.

3 files changed, 73 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())
diff --git a/src/lib.rs b/src/lib.rs
index 43ae727..a51fc97 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -16,10 +16,12 @@
 
 extern crate reqwest;
 extern crate serde;
+extern crate serde_urlencoded;
 
 mod client;
 mod error;
 mod item;
+mod xchan;
 
 use client::Client;
 
diff --git a/src/xchan.rs b/src/xchan.rs
new file mode 100644
index 0000000..564531a
--- /dev/null
+++ b/src/xchan.rs
@@ -0,0 +1,42 @@
+// zotapi - Rust wrapper for Sot API as implemented by Hubzilla
+// Copyright (C) 2018  Harald Eilertsen <haraldei@anduin.net>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use client::{self, Client};
+use error::Error;
+use std::collections::BTreeMap;
+
+pub struct XChanFetcher<'a> {
+    client: &'a Client,
+    data: BTreeMap<&'a str, &'a str>,
+}
+
+impl<'a> XChanFetcher<'a> {
+    pub fn new(client: &'a Client) -> XChanFetcher<'a> {
+        XChanFetcher {
+            client,
+            data: BTreeMap::new(),
+        }
+    }
+
+    pub fn by_address(&mut self, addr: &'a str) -> &mut XChanFetcher<'a> {
+        self.data.insert("address", addr);
+        self
+    }
+
+    pub fn fetch(&self) -> Result<String, Error> {
+        self.client.fetch_stream(client::ZOTAPI_XCHAN_PATH, &self.data)
+    }
+}