From b289ed92deb3104eb6a3c6fe79f440a173b80bf0 Mon Sep 17 00:00:00 2001
From: Mashy <himesh.kapadia@gmail.com>
Date: Fri, 19 Jul 2019 21:01:12 +1000
Subject: [PATCH] tidying fns

---
 server/src/net.rs | 36 +++++++++++++++++-------------------
 1 file changed, 17 insertions(+), 19 deletions(-)

diff --git a/server/src/net.rs b/server/src/net.rs
index 80766191..b7d1ffc6 100644
--- a/server/src/net.rs
+++ b/server/src/net.rs
@@ -41,21 +41,31 @@ pub enum MnmlHttpError {
 
 #[derive(Serialize, Deserialize)]
 struct JsonResponse {
-  response: String,
+  response: Option<String>,
   success: bool,
-  error_message: String
+  error_message: Option<String>
 }
 
 impl JsonResponse {
   fn success(response: String) -> Self {
-    JsonResponse { response: response, success: true, error_message: "".to_string() }
+    JsonResponse { response: Some(response), success: true, error_message: None }
   }
 
   fn error(msg: String) -> Self {
-    JsonResponse { response: "".to_string(), success: false, error_message: msg }
+    JsonResponse { response: None, success: false, error_message: Some(msg) }
   }
 }
 
+fn iron_response (status: status::Status, message: String) -> Response {
+    let content_type = "application/json".parse::<Mime>().unwrap();
+    let msg = match status {
+        status::Ok => JsonResponse::success(message),
+        _ => JsonResponse::error(message)
+    };
+    let msg_out = serde_json::to_string(&msg).unwrap();
+    return Response::with((content_type, status, msg_out));
+}
+
 impl From<MnmlHttpError> for IronError {
     fn from(m_err: MnmlHttpError) -> Self {
         let (err, res) = match m_err {
@@ -67,11 +77,7 @@ impl From<MnmlHttpError> for IronError {
             MnmlHttpError::PasswordUnacceptable => (m_err.compat(), status::BadRequest),
             MnmlHttpError::InvalidCode => (m_err.compat(), status::Unauthorized),
         };
-        let err_msg = JsonResponse::error(m_err.to_string());
-        let err_out = serde_json::to_string(&err_msg).expect("Failed to encode response");
-        let content_type = "application/json".parse::<Mime>().expect("Failed to parse content type");
-
-        IronError::new(err, (content_type, res, err_out))
+        IronError { error: Box::new(err), response: iron_response(res, m_err.to_string()) }
     }
 }
 
@@ -132,15 +138,7 @@ fn token_res(token: String) -> Response {
         .max_age(Duration::weeks(1)) // 1 week aligns with db set
         .finish();
 
-        let content_type = "application/json".parse::<Mime>().expect("Failed to parse content type");
-        let msg = JsonResponse {
-            response: "success666".to_string(),
-            success: true,
-            error_message: "".to_string()
-        };
-        let msg_out = serde_json::to_string(&msg).expect("Failed to encode response");
-
-        let mut res = Response::with((content_type, status::Ok, msg_out));
+        let mut res = iron_response(status::Ok, "token_res".to_string());
         res.headers.set(SetCookie(vec![v.to_string()]));
 
     return res;
@@ -216,7 +214,7 @@ fn logout(req: &mut Request) -> IronResult<Response> {
 
             tx.commit().or(Err(MnmlHttpError::ServerError))?;
 
-            let mut res = Response::with(status::Ok);
+            let mut res = iron_response(status::Ok, "token_res".to_string());
             res.headers.set(SetCookie(vec![AUTH_CLEAR.to_string()]));
             Ok(res)