added generic sender

examples/get_session.rs

@@ -12,7 +12,7 @@ async fn main() -> Result<()> {
     let url= env::var("TURL")?;
     let basic_auth = BasicAuth{user: env::var("TUSER")?, password: env::var("TPWD")?};
     let client = TransClient::with_auth(&url, basic_auth);
-    let response: Result<RpcResponse<SessionInfo>> = client.get_session().await;
+    let response: Result<RpcResponse<SessionInfo>> = client.session_get().await;
     match response {
         Ok(_) => println!("Yay!"),
         Err(_) => panic!("Oh no!")

src/lib.rs

@@ -1,5 +1,5 @@
-#[allow(unused_imports)]
+// #[allow(unused_imports)]
-#[allow(dead_code)]
+// #[allow(dead_code)]
 
 extern crate ajson;
 extern crate bb8;
@@ -10,10 +10,12 @@ extern crate log;
 extern crate reqwest;
 extern crate tokio_postgres;
 
+use serde::Serialize;
+use serde::de::DeserializeOwned;
 use reqwest::header::CONTENT_TYPE;
 
 pub mod types;
-use types::{Result, RpcResponse, SessionGet, SessionInfo};
+use types::{Result, RpcRequestArgument, RpcResponse, RpcResponseArgument, SessionGet, SessionInfo};
 use types::BasicAuth;
 
 pub struct TransClient {
@@ -50,7 +52,7 @@ impl TransClient {
     async fn get_session_id(&self) -> String {
         info!("Requesting session id info");
         let response: reqwest::Response = self.rpc_request()
-        .json(&SessionGet::default())
+        .json(&SessionGet::new())
         .send()
         .await
         .unwrap();
@@ -65,15 +67,24 @@ impl TransClient {
     }
 
     
-    pub async fn get_session(&self) -> Result<RpcResponse<SessionInfo>> {
+    pub async fn session_get(&self) -> Result<RpcResponse<SessionInfo>> {
+        self.call(SessionGet::new()).await
+    }
+
+    pub async fn torrent_get(&self) -> Result<RpcResponse<>>{}
+
+    async fn call<T, U> (&self, request: T) -> Result<RpcResponse<U>>
+    where   T : RpcRequestArgument + Serialize,
+            U : RpcResponseArgument + DeserializeOwned + std::fmt::Debug
+    {
         info!("Loaded auth: {:?}", &self.auth);
         let rq: reqwest::RequestBuilder = self.rpc_request()
             .header("X-Transmission-Session-Id", self.get_session_id().await)
-            .json(&SessionGet::default());
+            .json(&request);
-        debug!("Request body: {:?}", rq.try_clone().unwrap().body_string()?);
+        info!("Request body: {:?}", rq.try_clone().unwrap().body_string()?);
         let resp: reqwest::Response = rq.send().await?;
         // print!("{:?}", resp.text().await);
-        let rpc_response: RpcResponse<SessionInfo> = resp.json().await?;
+        let rpc_response: RpcResponse<U> = resp.json().await?;
         info!("{:#?}", rpc_response);
         Ok(rpc_response)
     }
@@ -104,7 +115,7 @@ mod tests {
         env_logger::init();
         let url= env::var("TURL")?;
         let basic_auth = BasicAuth{user: env::var("TUSER")?, password: env::var("TPWD")?};
-        TransClient::with_auth(&url, basic_auth).get_session().await;
+        TransClient::with_auth(&url, basic_auth).session_get().await;
         Ok(())
     }
 }

src/types/entity.rs

@@ -1,21 +0,0 @@
-use serde::Deserialize;
-
-#[derive(Debug)]
-pub struct BasicAuth {
-    pub user: String,
-    pub password: String,
-}
-
-#[derive(Deserialize, Debug)]
-pub struct SessionInfo {
-    #[serde(rename="blocklist-enabled")]
-    blocklist_enabled: bool,
-    #[serde(rename="download-dir")]
-    download_dir: String,
-    encryption: String,
-    #[serde(rename="rpc-version")]
-    rpc_version: i32,
-    #[serde(rename="rpc-version-minimum")]
-    rpc_version_minimum: i32,
-    version: String,
-}

src/types/mod.rs

@@ -1,13 +1,19 @@
 
 mod request;
 mod response;
-mod entity;
 
 pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
 
+#[derive(Debug)]
+pub struct BasicAuth {
+    pub user: String,
+    pub password: String,
+}
+
+pub(crate) use self::request::RpcRequestArgument;
 pub(crate) use self::request::SessionGet;
 
 pub use self::response::RpcResponse;
 
-pub use self::entity::BasicAuth;
+pub(crate) use self::response::RpcResponseArgument;
-pub use self::entity::SessionInfo;
+pub use self::response::SessionInfo;

src/types/request.rs

@@ -5,8 +5,12 @@ pub struct SessionGet {
     method: String
 }
 
-impl Default for SessionGet{
+impl SessionGet{
-    fn default() -> SessionGet {
+    pub fn new() -> SessionGet {
         SessionGet { method: String::from("session-get") }
    }
-}
+}
+
+
+pub trait RpcRequestArgument {}
+impl RpcRequestArgument for SessionGet{}

src/types/response.rs

@@ -3,4 +3,21 @@ use serde::Deserialize;
 pub struct RpcResponse<T> {
     arguments: T,
     result: String
-}
+}
+
+#[derive(Deserialize, Debug)]
+pub struct SessionInfo {
+    #[serde(rename="blocklist-enabled")]
+    blocklist_enabled: bool,
+    #[serde(rename="download-dir")]
+    download_dir: String,
+    encryption: String,
+    #[serde(rename="rpc-version")]
+    rpc_version: i32,
+    #[serde(rename="rpc-version-minimum")]
+    rpc_version_minimum: i32,
+    version: String,
+}
+
+pub trait RpcResponseArgument {}
+impl RpcResponseArgument for SessionInfo{}