Completed the creation of the MTT client.

src/lib.rs

@@ -7,11 +7,11 @@ mod queue;
 
 use document::{Clock, CreateDoc, Session};
 use isolang::Language;
-use message::{wrapper::Message, MessageID, MessageAction};
+use message::{wrapper::Message, MessageAction, MessageID};
 use queue::{
-    SenderID,
     data_director::{RegMsg, Register},
     router::Queue,
+    SenderID,
 };
 use std::{
     sync::mpsc::{channel, Receiver, RecvTimeoutError, Sender},
@@ -39,14 +39,14 @@ mod support_tests {
 
 static TIMEOUT: Duration = Duration::from_secs(10);
 
-pub struct MTTClient {
+struct PreBuildClient {
     queue: Queue,
+    msg_id: MessageID,
     rx: Receiver<Message>,
     sender_id: SenderID,
-    session_id: Uuid,
 }
 
-impl MTTClient {
+impl PreBuildClient {
     fn new(mut queue: Queue) -> Self {
         let sess_name = Session::doc_names()[0].clone();
         let (tx, rx) = channel();
@@ -69,27 +69,94 @@ impl MTTClient {
             queue.send(Message::with_id(msg_id.clone(), reg_msg));
             let result = rx.recv().unwrap();
         }
-        let add = Addition::new(sess_name);
-        queue.send(Message::with_id(msg_id, add));
-        let sess_info = rx.recv().unwrap();
-        let session_id = match sess_info.get_action() {
-            MsgAction::Records(data) => {
-                let rec = data.iter().last().unwrap();
-                match rec.get(Session::id_field_names()[0].clone()).unwrap().clone() {
-                    Field::Uuid(id) => id.clone(),
-                    _ => unreachable!("should only return uuid"),
-                }
-            }
-            _ => unreachable!("new session request should always succeed"),
-        };
         Self {
             queue: queue,
+            msg_id: msg_id,
             rx: rx,
             sender_id: sender_id,
+        }
+    }
+
+    fn send<MA>(&self, action: MA) -> Records
+    where
+        MA: Into<MsgAction>,
+    {
+        self.queue
+            .send(Message::with_id(self.msg_id.clone(), action));
+        let result = self.rx.recv().unwrap();
+        match result.get_action() {
+            MsgAction::Records(data) => data.clone(),
+            _ => unreachable!("session requests should always return data"),
+        }
+    }
+}
+
+pub struct MTTClient {
+    queue: Queue,
+    rx: Receiver<Message>,
+    sender_id: SenderID,
+    session_id: Uuid,
+}
+
+impl MTTClient {
+    fn internal_new(prebuild: PreBuildClient, lang: Option<Language>) -> Self {
+        let mut add = Addition::new(Session::doc_names()[0].clone());
+        match lang {
+            Some(language) => {
+                let field: Field = language.into();
+                add.add_field(Session::language_field_names()[0].clone(), field);
+            }
+            None => {}
+        }
+        let result = prebuild.send(add);
+        let rec = result.iter().last().unwrap();
+        let session_id = match rec.get(Session::id_field_names()[0].clone()).unwrap() {
+            Field::Uuid(data) => data.clone(),
+            _ => unreachable!("should always be uuid"),
+        };
+        Self {
+            queue: prebuild.queue,
+            rx: prebuild.rx,
+            sender_id: prebuild.sender_id,
             session_id: session_id,
         }
     }
 
+    fn new(mut queue: Queue, lang: Option<Language>) -> Self {
+        let prebuild = PreBuildClient::new(queue);
+        Self::internal_new(prebuild, lang)
+    }
+
+    fn with_session(queue: Queue, id: String, lang: Option<Language>) -> Self {
+        let prebuild = PreBuildClient::new(queue.clone());
+        let sess_id = match Uuid::try_from(id.as_str()) {
+            Ok(data) => data,
+            Err(_) => return Self::internal_new(prebuild, lang),
+        };
+        let mut qry = Query::new(Session::doc_names()[0].clone());
+        let mut calc = Calculation::new(Operand::Equal);
+        calc.add_value(CalcValue::Existing(FieldType::Uuid))
+            .unwrap();
+        calc.add_value(sess_id).unwrap();
+        qry.add(Session::id_field_names()[0].clone(), calc);
+        let result = prebuild.send(qry);
+        if result.len() == 0 {
+            Self::internal_new(prebuild, lang)
+        } else {
+            let rec = result.iter().last().unwrap();
+            let session_id = match rec.get(Session::id_field_names()[0].clone()).unwrap() {
+                Field::Uuid(data) => data.clone(),
+                _ => unreachable!("should always be uuid"),
+            };
+            Self {
+                queue: queue,
+                rx: prebuild.rx,
+                sender_id: prebuild.sender_id.clone(),
+                session_id: session_id,
+            }
+        }
+    }
+
     pub fn session_id(&self) -> String {
         self.session_id.to_string()
     }
@@ -121,7 +188,15 @@ impl MoreThanText {
     }
 
     pub fn client(&self) -> MTTClient {
-        MTTClient::new(self.queue.clone())
+        MTTClient::new(self.queue.clone(), None)
+    }
+
+    pub fn client_with_language(&self, lang: Language) -> MTTClient {
+        MTTClient::new(self.queue.clone(), Some(lang))
+    }
+
+    pub fn client_with_session(&self, id: String, lang: Option<Language>) -> MTTClient {
+        MTTClient::with_session(self.queue.clone(), id, lang)
     }
 
     fn new_session(lang: Option<Language>) -> ClientAction {