Save group name on the group creation

Author: Ojin13

src/group.rs

@@ -87,24 +87,23 @@ impl Group {
     }
 }
 
-// impl From<&Group> for crate::proto::Group {
-//     fn from(group: &Group) -> Self {
-//         crate::proto::Group {
-//             identifier: group.identifier().to_vec(),
-//             name: group.name().to_owned(),
-//             threshold: group.threshold(),
-//             device_ids: group
-//                 .devices()
-//                 .iter()
-//                 .map(|x| x.identifier())
-//                 .map(Vec::from)
-//                 .collect(),
-//             protocol: group.protocol().into(),
-//             key_type: group.key_type().into(),
-//             note: group.note().map(String::from),
-//         }
-//     }
-// }
+impl From<&Group> for crate::proto::Group {
+    fn from(group: &Group) -> Self {
+        crate::proto::Group {
+            identifier: group.identifier().to_vec(),
+            name: group.name().to_owned(),
+            threshold: group.threshold(),
+            device_ids: group
+                .participants()
+                .iter()
+                .flat_map(|p| std::iter::repeat(p.device.id.clone()).take(p.shares as usize))
+                .collect(),
+            protocol: group.protocol() as i32,
+            key_type: group.key_type() as i32,
+            note: group.note().map(String::from),
+        }
+    }
+}
 
 #[cfg(test)]
 mod tests {

src/interfaces/grpc.rs

@@ -18,7 +18,7 @@ use tonic::{Request, Response, Status};
 use uuid::Uuid;
 
 use crate::persistence::DeviceKind;
-use crate::proto::{Group, KeyType, MeeSign, MeeSignServer, ProtocolType};
+use crate::proto::{KeyType, MeeSign, MeeSignServer, ProtocolType};
 use crate::state::State;
 use crate::{proto as msg, utils, CA_CERT, CA_KEY};
 
@@ -275,21 +275,52 @@ impl MeeSign for MeeSignService {
         debug!("GroupsRequest device_id={}", device_str);
 
         let state = self.state.lock().await;
-        // TODO: refactor, consider storing device IDS in the group model directly
         let groups = if let Some(device_id) = device_id {
             state.activate_device(&device_id);
             state
                 .get_device_groups(&device_id)
                 .await?
                 .into_iter()
-                .map(Group::from_model)
+                .map(|group_model| {
+                    msg::Group {
+                        identifier: group_model.id.clone(),
+                        name: group_model.name.clone(),
+                        threshold: group_model.threshold as u32,
+                        device_ids: group_model
+                            .participant_ids_shares
+                            .iter()
+                            .flat_map(|(device_id, shares)| {
+                                std::iter::repeat(device_id.clone()).take(*shares as usize)
+                            })
+                            .collect(),
+                        protocol: group_model.protocol as i32,
+                        key_type: group_model.key_type as i32,
+                        note: group_model.note.clone(),
+                    }
+                })
                 .collect()
         } else {
             state
                 .get_groups()
                 .await?
                 .into_iter()
-                .map(Group::from_model)
+                .map(|group_model| {
+                    msg::Group {
+                        identifier: group_model.id.clone(),
+                        name: group_model.name.clone(),
+                        threshold: group_model.threshold as u32,
+                        device_ids: group_model
+                            .participant_ids_shares
+                            .iter()
+                            .flat_map(|(device_id, shares)| {
+                                std::iter::repeat(device_id.clone()).take(*shares as usize)
+                            })
+                            .collect(),
+                        protocol: group_model.protocol as i32,
+                        key_type: group_model.key_type as i32,
+                        note: group_model.note.clone(),
+                    }
+                })
                 .collect()
         };
 

src/state.rs

@@ -286,6 +286,13 @@ impl State {
         Ok(self.get_repo().get_groups().await?)
     }
 
+    pub async fn get_group_participants(
+        &self,
+        group_id: &[u8],
+    ) -> Result<Vec<Participant>, Error> {
+        Ok(self.get_repo().get_group_participants(group_id).await?)
+    }
+
     pub async fn get_tasks(&self) -> Result<Vec<TaskModel>, Error> {
         Ok(self.repo.get_tasks().await?)
     }

src/tasks/group.rs

@@ -4,7 +4,7 @@ use crate::group::Group;
 use crate::persistence::Participant;
 use crate::persistence::PersistenceError;
 use crate::persistence::Task as TaskModel;
-use crate::proto::{KeyType, ProtocolType, TaskType};
+use crate::proto::{GroupRequest, KeyType, ProtocolType, TaskType};
 use crate::protocols::{create_keygen_protocol, Protocol};
 use crate::tasks::{DecisionUpdate, RestartUpdate, RoundUpdate, Task, TaskResult};
 use crate::utils;
@@ -125,6 +125,10 @@ impl GroupTask {
             model.protocol_round as u16,
         )?;
 
+        // Parse the GroupRequest from the task's request field to get the name
+        let group_request = GroupRequest::decode(model.request.as_slice())
+            .map_err(|e| Error::GeneralProtocolError(format!("Failed to parse GroupRequest: {}", e)))?;
+        
         // TODO: refactor
         let result = model.result.map(|res| res.try_into_result()).transpose()?;
         let result = match result {
@@ -142,10 +146,12 @@ impl GroupTask {
             Some(Err(err)) => Some(Err(err)),
             None => None,
         };
+        // Use the name from the GroupRequest if the group hasn't been established yet,
+        // otherwise use the name from the established group
         let name = if let Some(Ok(group)) = &result {
             group.name().into()
         } else {
-            "".into() // TODO add field to the task table
+            group_request.name
         };
         let Some(certificates_sent) = model.group_certificates_sent else {
             return Err(Error::PersistenceError(