Made records produce a document name.

src/action/message.rs

@@ -31,9 +31,14 @@ impl MessageAction for MsgAction {
     fn doc_name(&self) -> &NameType {
         match self {
             Self::Addition(data) => data.doc_name(),
-            Self::Query(data) => data.doc_name(),
             Self::Create(data) => data.doc_name(),
             Self::Error(data) => data.doc_name(),
+            Self::OnAddition(data) => data.doc_name(),
+            Self::OnDelete(data) => data.doc_name(),
+            Self::OnQuery(data) => data.doc_name(),
+            Self::OnUpdate(data) => data.doc_name(),
+            Self::Query(data) => data.doc_name(),
+            Self::Records(data) => data.doc_name(),
             _ => &NameType::None,
         }
     }

src/document/clock.rs

@@ -22,21 +22,27 @@ impl Clock {
         Self { queue: queue }
     }
 
+    pub fn doc_names() -> Vec<Name> {
+        vec![Name::english("clock")]
+    }
+
+    /*
     fn get_name() -> Name {
         Name::english("clock")
     }
+    */
 
     fn gen_message() -> Message {
         Message::new(
-            Clock::get_name(),
-            MsgAction::OnUpdate(Records::new(Names::new())),
+            Clock::doc_names()[0].clone(),
+            MsgAction::OnUpdate(Records::new(Clock::doc_names(), Names::new())),
         )
     }
 
     pub fn get_path() -> Path {
         Path::new(
             Include::All,
-            Include::Just(Clock::get_name().into()),
+            Include::Just(Clock::doc_names()[0].clone().into()),
             Include::Just(Action::OnUpdate),
         )
     }
@@ -45,7 +51,7 @@ impl Clock {
         let clock = Clock::new(queue.clone());
         let (tx, rx) = channel();
         let id = queue.add_sender(tx);
-        let reg_msg = Register::new(id, RegMsg::AddDocName([Clock::get_name()].to_vec()));
+        let reg_msg = Register::new(id, RegMsg::AddDocName(Clock::doc_names()));
         let msg = Message::new(NameType::None, reg_msg.clone());
         queue.send(msg);
         rx.recv().unwrap();
@@ -99,7 +105,7 @@ mod clocks {
         let end = Utc::now();
         assert!((end - start) > TimeDelta::seconds(1));
         assert!((end - start) < TimeDelta::seconds(2));
-        let reg_request = Register::new(id, RegMsg::GetNameID(Clock::get_name()));
+        let reg_request = Register::new(id, RegMsg::GetNameID(Clock::doc_names()[0].clone()));
         queue.send(Message::new(NameType::None, reg_request));
         rx.recv_timeout(TIMEOUT).unwrap();
         for msg in holder.iter() {

src/document/create.rs

@@ -616,7 +616,10 @@ impl DocumentFile {
             };
             holder.insert(field_id.clone(), corrected.clone());
         }
-        let mut records = Records::new(self.docdef.get_field_names().clone());
+        let mut records = Records::new(
+            self.docdef.get_document_names().clone(),
+            self.docdef.get_field_names().clone(),
+        );
         if !holder.is_empty() {
             let mut oid = Oid::new();
             while self.docs.contains_key(&oid) {
@@ -653,7 +656,11 @@ impl DocumentFile {
             }
             self.docs.remove(oid);
         }
-        let rec = Records::with_data(self.docdef.get_field_names().clone(), records);
+        let rec = Records::with_data(
+            self.docdef.get_document_names().clone(),
+            self.docdef.get_field_names().clone(),
+            records,
+        );
         self.queue.send(msg.response(rec.clone()));
         self.queue.send(msg.response(MsgAction::OnDelete(rec)));
     }
@@ -722,7 +729,11 @@ impl DocumentFile {
                 return;
             }
         };
-        let recs = Records::with_data(self.docdef.get_field_names().clone(), records);
+        let recs = Records::with_data(
+            self.docdef.get_document_names().clone(),
+            self.docdef.get_field_names().clone(),
+            records,
+        );
         self.queue.send(msg.response(recs.clone()));
         self.queue.send(msg.response(MsgAction::OnQuery(recs)));
     }
@@ -769,7 +780,11 @@ impl DocumentFile {
             }
             self.docs.insert(oid.clone(), new_rec.clone());
         }
-        let recs = Records::with_data(self.docdef.get_field_names().clone(), updates);
+        let recs = Records::with_data(
+            self.docdef.get_document_names().clone(),
+            self.docdef.get_field_names().clone(),
+            updates,
+        );
         self.queue
             .send(msg.response(MsgAction::OnUpdate(recs.clone())));
         Ok(recs)
@@ -822,8 +837,8 @@ impl DocumentFile {
 mod document_files {
     use super::*;
     use crate::{
-        action::{Addition, Operand},
-        document::field::FieldType,
+        action::{Addition, FieldType, Operand},
+        document::Clock,
         message::wrapper::Delete,
         name::{Name, Names},
         support_tests::TIMEOUT,
@@ -2406,7 +2421,7 @@ mod document_files {
         }
         let trigger = Message::new(
             Name::english("clock"),
-            MsgAction::OnUpdate(Records::new(Names::new())),
+            MsgAction::OnUpdate(Records::new(Clock::doc_names(), Names::new())),
         );
         queue.send(trigger.clone());
         sleep(TIMEOUT);

src/document/definition.rs

@@ -199,7 +199,6 @@ impl PathAction {
 
 #[derive(Clone, Debug)]
 pub struct DocDef {
-    doc_name: NameType,
     doc_names: Vec<Name>,
     field_names: Names,
     fields: HashMap<Uuid, FieldSetting>,
@@ -257,7 +256,6 @@ impl DocDef {
             ),
         ];
         Self {
-            doc_name: NameType::None,
             doc_names: names,
             field_names: Names::new(),
             fields: HashMap::new(),
@@ -376,7 +374,7 @@ impl DocDef {
 
 impl MessageAction for DocDef {
     fn doc_name(&self) -> &NameType {
-        &self.doc_name
+        &NameType::None
     }
 }
 

src/document/record.rs

@@ -1,5 +1,6 @@
 use crate::{
     action::Field,
+    message::MessageAction,
     mtterror::{ErrorID, MTTError},
     name::{Name, NameType, Names},
 };
@@ -142,20 +143,23 @@ impl Record {
 
 #[derive(Clone, Debug)]
 pub struct Records {
+    doc_name: NameType,
     names: Names,
     data: InternalRecords,
 }
 
 impl Records {
-    pub fn new(names: Names) -> Self {
+    pub fn new(doc_names: Vec<Name>, names: Names) -> Self {
         Self {
+            doc_name: doc_names[0].clone().into(),
             names: names,
             data: InternalRecords::new(),
         }
     }
 
-    pub fn with_data(names: Names, records: InternalRecords) -> Self {
+    pub fn with_data(doc_names: Vec<Name>, names: Names, records: InternalRecords) -> Self {
         Self {
+            doc_name: doc_names[0].clone().into(),
             names: names,
             data: records,
         }
@@ -178,6 +182,12 @@ impl Records {
     }
 }
 
+impl MessageAction for Records {
+    fn doc_name(&self) -> &NameType {
+        &self.doc_name
+    }
+}
+
 struct RecordIter {
     names: Names,
     recs: Vec<InternalRecord>,
@@ -202,3 +212,24 @@ impl Iterator for RecordIter {
         }
     }
 }
+
+#[cfg(test)]
+mod records {
+    use super::*;
+
+    #[test]
+    fn does_recourds_store_document_name() {
+        let doc_name = Name::english(uuid::Uuid::new_v4().to_string().as_str());
+        let expected: NameType = doc_name.clone().into();
+        let recs = Records::new(vec![doc_name.clone()], Names::new());
+        assert_eq!(recs.doc_name(), &expected);
+    }
+
+    #[test]
+    fn does_records_with_data_store_document_name() {
+        let doc_name = Name::english(uuid::Uuid::new_v4().to_string().as_str());
+        let expected: NameType = doc_name.clone().into();
+        let recs = Records::with_data(vec![doc_name.clone()], Names::new(), InternalRecords::new());
+        assert_eq!(recs.doc_name(), &expected);
+    }
+}

src/message/wrapper.rs

@@ -266,7 +266,6 @@ impl Operation {
     }
 }
 
-
 #[allow(dead_code)]
 #[derive(Clone, Debug)]
 pub struct Reply {

src/queue/data_director.rs

@@ -131,7 +131,7 @@ mod paths {
             (Name::english("one"), MsgAction::Show),
             (
                 Name::english("two"),
-                MsgAction::Records(Records::new(Names::new())),
+                MsgAction::Records(Records::new(vec![Name::english("two")], Names::new())),
             ),
         ];
         for item in input.iter() {