Added language inforation into session.

src/document/field.rs

@@ -16,6 +16,7 @@ pub enum Field {
     DateTime(DateTime<Utc>),
     Duration(Duration),
     Integer(i128),
+    Language(Language),
     None,
     StaticString(String),
     Uuid(Uuid),
@@ -111,6 +112,12 @@ impl From<i32> for Field {
     }
 }
 
+impl From<Language> for Field {
+    fn from(value: Language) -> Self {
+        Self::Language(value)
+    }
+}
+
 impl PartialOrd for Field {
     fn partial_cmp(&self, other: &Field) -> Option<Ordering> {
         match (self, other) {
@@ -272,6 +279,7 @@ pub enum FieldType {
     DateTime,
     Duration,
     Integer,
+    Language,
     None,
     StaticString,
     Uuid,
@@ -284,6 +292,7 @@ impl FieldType {
             FieldType::DateTime => Utc::now().into(),
             FieldType::Duration => Duration::from_secs(0).into(),
             FieldType::Integer => 0.into(),
+            FieldType::Language => Language::from_639_1("en").unwrap().into(),
             FieldType::None => Field::None,
             FieldType::StaticString => "".into(),
             FieldType::Uuid => Uuid::new_v4().into(),
@@ -298,6 +307,7 @@ impl From<&Field> for FieldType {
             Field::DateTime(_) => Self::DateTime,
             Field::Duration(_) => Self::Duration,
             Field::Integer(_) => Self::Integer,
+            Field::Language(_) => Self::Language,
             Field::None => Self::None,
             Field::StaticString(_) => Self::StaticString,
             Field::Uuid(_) => Self::Uuid,

src/document/session.rs

@@ -38,9 +38,17 @@ impl Session {
         names
     }
 
+    pub fn language_field_names() -> Vec<Name> {
+        let mut names = Vec::new();
+        names.push(Name::english("language"));
+        names.push(Name::japanese("言語"));
+        names
+    }
+
     pub fn document_definition() -> DocDef {
         let name_id = Self::id_field_names()[0].clone();
         let name_expire = Self::expire_field_names()[0].clone();
+        let name_lang = Self::language_field_names()[0].clone();
 
         let mut docdef = DocDef::with_names(Self::doc_names());
 
@@ -56,6 +64,9 @@ impl Session {
         docdef.set_default(&name_expire, calc.clone()).unwrap();
         docdef.add_index(&name_expire, IndexType::Index).unwrap();
 
+        docdef.add_field(Self::language_field_names(), FieldType::Language);
+        docdef.set_default(&name_lang, FieldType::Language).unwrap();
+
         let mut update = Update::new(Session::doc_names()[0].clone());
         update
             .get_values_mut()

src/lib.rs

@@ -6,6 +6,7 @@ pub mod name;
 mod queue;
 
 use document::{Clock, CreateDoc, Session};
+use isolang::Language;
 use message::{wrapper::Message, MessageAction};
 use queue::{
     data_director::{RegMsg, Register},
@@ -56,18 +57,27 @@ impl MoreThanText {
         output
     }
 
-    fn new_session() -> ClientAction {
-        Addition::new(Session::doc_names()[0].clone()).into()
+    fn new_session(lang: Option<Language>) -> ClientAction {
+        let mut output = Addition::new(Session::doc_names()[0].clone());
+        match lang {
+            Some(data) => {
+                let name = Session::language_field_names()[0].clone();
+                let field: Field = data.into();
+                output.add_field(name, field);
+            }
+            None => {}
+        }
+        output.into()
     }
 
-    fn recursive_message_request<UA>(&mut self, action: UA) -> Uuid
+    fn recursive_message_request<CA>(&mut self, action: CA, lang: Option<Language>) -> Uuid
     where
-        UA: Into<ClientAction>,
+        CA: Into<ClientAction>,
     {
         match self.records(action) {
             Ok(data) => {
                 if data.len() == 0 {
-                    self.recursive_message_request(MoreThanText::new_session())
+                    self.recursive_message_request(MoreThanText::new_session(lang), lang)
                 } else {
                     let rec = data.iter().last().unwrap();
                     match rec.get(Name::english("id")).unwrap() {
@@ -76,11 +86,11 @@ impl MoreThanText {
                     }
                 }
             }
-            Err(_) => self.recursive_message_request(MoreThanText::new_session()),
+            Err(_) => self.recursive_message_request(MoreThanText::new_session(lang), lang),
         }
     }
 
-    pub fn validate_session(&mut self, session: Option<String>) -> Uuid {
+    pub fn validate_session(&mut self, session: Option<String>, lang: Option<Language>) -> Uuid {
         let action = match session {
             Some(data) => match Uuid::try_from(data.as_str()) {
                 Ok(id) => {
@@ -92,11 +102,11 @@ impl MoreThanText {
                     query.add(Name::english("id"), calc);
                     query.into()
                 }
-                Err(_) => MoreThanText::new_session(),
+                Err(_) => MoreThanText::new_session(lang),
             },
-            None => MoreThanText::new_session(),
+            None => MoreThanText::new_session(lang),
         };
-        self.recursive_message_request(action)
+        self.recursive_message_request(action, lang)
     }
 
     pub fn records<UA>(&mut self, request: UA) -> Result<Records, MTTError>

src/main.rs

@@ -73,7 +73,9 @@ where
         let requested = req_id.clone();
         let (tx, mut rx) = channel(1);
         spawn(async move {
-            tx.send(state.validate_session(requested)).await.unwrap();
+            tx.send(state.validate_session(requested, None))
+                .await
+                .unwrap();
         });
         let id = rx.recv().await.unwrap();
         if !req_id.is_some_and(|x| x == id.to_string()) {